import type { FsNode } from "../sandbox/node/fs_node";
import type { ParsedApplyPatch, WorkspaceFile } from "../../lib/patch/index";
import type { MimeResolver } from "../sandbox/contracts/mime_resolver";
import type { SandboxFileSystem } from "../sandbox/contracts/file_system";
import type { PathTranslator } from "../sandbox/contracts/path_translator";
import type { DevFileAccess, DevInvocation, FileChangeSummary } from "./types";
import type { Diagnostic, ExecutionState, RawDiagnostic, StampedDelta, WorkspaceBounds } from "./types";
/** Internal provenance marker for runtime diagnostics that name an engine. */
export declare const runtimeDiagnostic: unique symbol;
/** Whole-file names that are known textual despite having no useful extension. */
export declare const DEV_FILENAME_MIME: Readonly<Record<string, string>>;
/** Resolve an admission MIME, giving the normative filename map precedence. */
export declare const resolveDevMime: (path: string, resolver: MimeResolver | undefined, bytes: Uint8Array) => Promise<string | undefined>;
/** Canonicalize an absolute host workspace root for comparisons and engine requests. */
export declare const canonicalizeDevRoot: (value: string) => string;
/** Check all workspace resource limits against a proposed map. */
export declare const assertBounds: (files: ReadonlyMap<string, WorkspaceFile>, bounds: WorkspaceBounds) => void;
/** Resolve acquisition paths without reading file contents. */
export declare const resolveAcquisitionTargets: (options: {
    paths: readonly string[];
    fileSystem: SandboxFileSystem;
    pathTranslator: PathTranslator;
    signal?: AbortSignal;
}) => Promise<string[]>;
/** Acquire explicitly requested files, expanding only entries containing an asterisk. */
export declare const acquireWorkspace: (options: {
    paths: readonly string[];
    fileSystem: SandboxFileSystem;
    pathTranslator: PathTranslator;
    bounds: WorkspaceBounds;
    mimeResolver?: MimeResolver;
    signal?: AbortSignal;
    /** Previously resolved targets, used to keep approval and acquisition consistent. */
    targets?: readonly string[];
}) => Promise<Map<string, WorkspaceFile>>;
/**
 * Derive the canonical workspace delta for a completely parsed structured patch.
 *
 * The patch primitive mutates its input map, so this always applies it to a clone and returns
 * nothing until the entire operation list has succeeded.
 */
export declare const derivePatchOutcome: (files: Map<string, WorkspaceFile>, parsed: ParsedApplyPatch) => {
    delta: {
        changed: Map<string, string>;
        added: Map<string, WorkspaceFile>;
        deleted: Set<string>;
        renamed: Map<string, string>;
        diagnostics: never[];
    };
    recreated: Set<string>;
};
/** Normalize, validate, and apply one engine delta without mutating it. */
export declare const applyDelta: (options: {
    delta: StampedDelta;
    files: Map<string, WorkspaceFile>;
    state: ExecutionState;
    bounds: WorkspaceBounds;
    fileSystem: SandboxFileSystem;
    pathTranslator: PathTranslator;
    mimeResolver?: MimeResolver;
    persistedPaths?: Map<string, string>;
    pendingDeletions?: Map<string, string>;
    recreated?: Set<string>;
    renames?: Map<string, string>;
    /** Paths vacated earlier in this execution by a deletion or rename. */
    vacated?: Set<string>;
    unreadable?: ReadonlySet<string>;
    engineId?: string;
    /** Resolved existing paths this engine invocation was authorized to modify. */
    invocationPaths?: readonly string[];
    /** Authored selector patterns; additions must match these when present. */
    selector?: readonly string[] | null;
    /** Structured patch additions are textual by construction and retain their inferred MIME. */
    skipAddedMimeResolution?: boolean;
}) => Promise<StampedDelta>;
/** Normalize and scope-stamp diagnostics after the workspace mutation has completed. */
/** Build the deliberately narrow disk API handed to an in-place engine. */
export declare const makeDevFileAccess: (options: {
    invocation: DevInvocation;
    allowlist: readonly string[];
    fileSystem: SandboxFileSystem;
    pathTranslator: PathTranslator;
    policy: FsNode | undefined;
    selector: readonly string[] | null;
    signal?: AbortSignal;
    renameDestinations: Set<string>;
}) => DevFileAccess;
/** Snapshot an in-place authorization envelope before its capability mutates disk. */
export declare const snapshotInPlaceEnvelope: (options: {
    envelope: readonly (readonly string[])[];
    excluded?: ReadonlySet<string>;
    files: ReadonlyMap<string, WorkspaceFile>;
    fileSystem: SandboxFileSystem;
    pathTranslator: PathTranslator;
    signal?: AbortSignal;
}) => Promise<{
    paths: Set<string>;
    diagnostics: RawDiagnostic[];
}>;
/** Assemble final-state changes, retaining rename identity rather than guessing from text. */
/** Re-read an in-place invocation's authorized envelope against its pre-step snapshot. */
export declare const rereadInPlace: (options: {
    envelope: readonly (readonly string[])[];
    /** Dirty workspace paths whose disk copies must not be admitted by this re-read. */
    excluded?: ReadonlySet<string>;
    beforeSnapshot?: Set<string>;
    files: Map<string, WorkspaceFile>;
    unreadable: Set<string>;
    persistedPaths: Map<string, string>;
    persistedBaseline: Map<string, WorkspaceFile>;
    renames: Map<string, string>;
    recreated: Set<string>;
    fileSystem: SandboxFileSystem;
    pathTranslator: PathTranslator;
    bounds: WorkspaceBounds;
    mimeResolver?: MimeResolver;
    signal?: AbortSignal;
}) => Promise<{
    changed: Set<string>;
    diagnostics: RawDiagnostic[];
}>;
export declare const assembleChanges: (baseline: ReadonlyMap<string, WorkspaceFile>, files: ReadonlyMap<string, WorkspaceFile>, renames: ReadonlyMap<string, string>, recreated: ReadonlySet<string>, unreadable: ReadonlySet<string>) => Promise<{
    changes: FileChangeSummary[];
    lineCountsAvailable: boolean;
}>;
export declare const stampDiagnostics: (diagnostics: readonly (RawDiagnostic & {
    engineId: string | null;
})[], files: ReadonlyMap<string, WorkspaceFile>, root: string, translator: PathTranslator, fallbackEngineId?: string | null) => Diagnostic[];