@effect-vfs/core 0.9.0 → 0.11.0

package/dist/internal/engine.d.ts

@@ -0,0 +1,1305 @@
+import * as Brand from "effect/Brand";
+import * as ByteSize from "effect/ByteSize";
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as HashMap from "effect/HashMap";
+import * as Order from "effect/Order";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import { DirectoryHandleId, FileHandleId, SeekMode } from "../FileHandle.js";
+import type { BytePath } from "./bytePath.js";
+import { type Metadata, OwnerUpdate, Times } from "../Metadata.js";
+import { type ArgumentFailure, type FsCode, type FsFailure, VfsError } from "../VfsError.js";
+/** Filesystem capability contracts owned by the engine; public modules are compatibility views. @internal */
+export type PathInput = string | BytePath;
+/** @internal */
+export interface EngineLimits {
+    readonly maxBytes: ByteSize.ByteSize | undefined;
+    readonly maxFileBytes: ByteSize.ByteSize;
+    readonly maxEntries: number | undefined;
+    readonly maxPathBytes: ByteSize.ByteSize | undefined;
+    /** Waiting budget; at most this many plus one callers are admitted at once. */
+    readonly maxPendingOperations: number;
+}
+/** @internal */
+export interface VolumeUsage {
+    readonly usedBytes: bigint;
+    readonly entries: number;
+}
+/** @internal */
+export interface ObjectReference {
+    readonly [ObjectReferenceId]: true;
+}
+/** @internal */
+export interface ObjectObservation<A> {
+    readonly value: A;
+    readonly revision: bigint;
+}
+/** @internal */
+export interface DirectoryEntry {
+    readonly name: Uint8Array;
+    readonly reference: ObjectReference;
+}
+/** @internal */
+export interface WalkEntry {
+    readonly path: BytePath;
+    readonly name: Uint8Array;
+    readonly reference: ObjectReference;
+    readonly directory: ObjectReference;
+    readonly kind: Metadata["kind"];
+    readonly depth: number;
+}
+/** @internal */
+export interface ReferenceEntryResult {
+    readonly reference: ObjectReference;
+    readonly directory: DirectoryChange;
+}
+/** @internal */
+export interface DirectoryHandle {
+    readonly [DirectoryHandleId]: true;
+    readonly stat: Effect.Effect<Metadata, FsFailure>;
+    readonly close: Effect.Effect<void, FsFailure>;
+}
+/** @internal */
+export interface OpenEntryResult {
+    readonly handle: FileHandle;
+    readonly reference: ObjectReference;
+    readonly created: boolean;
+    readonly directory: DirectoryChange;
+}
+/** @internal */
+export interface ReadResult {
+    readonly bytes: Uint8Array;
+    readonly eof: boolean;
+}
+/** @internal */
+export interface FileHandle {
+    readonly [FileHandleId]: true;
+    readonly read: (maximumBytes: number) => Effect.Effect<Uint8Array, FsFailure>;
+    readonly pread: (maximumBytes: number, offset: bigint) => Effect.Effect<ReadResult, FsFailure>;
+    readonly write: (bytes: Uint8Array) => Effect.Effect<number, FsFailure>;
+    readonly pwrite: {
+        (offset: bigint): (bytes: Uint8Array) => Effect.Effect<number, FsFailure>;
+        (bytes: Uint8Array, offset: bigint): Effect.Effect<number, FsFailure>;
+    };
+    readonly seek: {
+        (mode: SeekMode): (offset: bigint) => Effect.Effect<bigint, FsFailure>;
+        (offset: bigint, mode: SeekMode): Effect.Effect<bigint, FsFailure>;
+    };
+    readonly truncate: (length: bigint) => Effect.Effect<void, FsFailure>;
+    readonly stat: Effect.Effect<Metadata, FsFailure>;
+    readonly sync: Effect.Effect<void, FsFailure>;
+    readonly close: Effect.Effect<void, FsFailure>;
+}
+/** @internal */
+export type WalkFailure = FsFailure | (VfsError & {
+    readonly code: "LimitExceeded";
+});
+/** Filesystem error helpers; image/codec helpers remain community-owned. @internal */
+export declare namespace Errors {
+    /** @internal */
+    export const errorPath: (input: PathInput) => BytePath | undefined;
+    interface Details {
+        readonly path?: PathInput;
+        readonly field?: string;
+        readonly cause?: unknown;
+    }
+    /** @internal */
+    export const argumentFailure: (operation: string, field: string, cause?: unknown) => ArgumentFailure;
+    /** @internal */
+    export const decodeConfiguration: <A, I>(schema: Schema.Codec<A, I>, value: typeof Schema.Unknown.Type, operation: string) => Result.Result<A, ArgumentFailure>;
+    /** @internal */
+    export const fsFailure: (code: FsCode, operation: string, details?: Details) => FsFailure;
+    /** @internal */
+    export interface OpContext {
+        readonly operation: string;
+        readonly fail: (code: FsCode, details?: {
+            readonly cause?: unknown;
+            readonly field?: string;
+        }) => FsFailure;
+        readonly at: (path: PathInput) => OpContext;
+    }
+    /** @internal */
+    export const OpContext: {
+        make: (operation: string) => OpContext;
+    };
+    export {};
+}
+declare const OpContext: {
+    make: (operation: string) => Errors.OpContext;
+};
+type OpContext = Errors.OpContext;
+/** Byte-name rules and filesystem lookup preparation. @internal */
+export declare namespace Paths {
+    /** @internal */
+    const SLASH_HEX = "2f";
+    /** @internal */
+    const DOT_HEX = "2e";
+    /** @internal */
+    const DOT_DOT_HEX = "2e2e";
+    /** @internal */
+    const SLASH_BYTE = 47;
+    /** @internal */
+    const NUL_BYTE = 0;
+    /** @internal */
+    const MAX_SYMLINK_TRAVERSALS = 40;
+    /** @internal */
+    const MAX_NAME_BYTES = 255;
+    /** @internal */
+    const isNameBytes: (name: Uint8Array) => boolean;
+    /** @internal */
+    const ROOT_PATH: Uint8Array<ArrayBuffer>;
+    /** @internal */
+    const joinPath: (prefix: Uint8Array, name: Uint8Array) => Uint8Array;
+    /** @internal */
+    const isDotComponent: (name: string | undefined) => name is undefined | typeof DOT_HEX | typeof DOT_DOT_HEX;
+    /** @internal */
+    const ownedPath: (bytes: Uint8Array) => BytePath;
+    /** @internal */
+    const strictString: (bytes: Uint8Array, operation: string) => Effect.Effect<string, FsFailure, never>;
+    /** @internal */
+    const nameBytes: (name: string) => Uint8Array;
+    /** @internal */
+    const isAttachedBytes: (bytes: Uint8Array) => boolean;
+    /** @internal */
+    const pathFromBytes: (bytes: Uint8Array<ArrayBufferLike>) => Effect.Effect<BytePath, FsFailure, never>;
+    /** @internal */
+    const pathToBytes: (path: BytePath) => Effect.Effect<Uint8Array<ArrayBuffer>, FsFailure, never>;
+    /** @internal */
+    interface PreparedPath {
+        readonly input: PathInput;
+        readonly absolute: boolean;
+        readonly trailingSlash: boolean;
+        readonly bytes: Uint8Array;
+        readonly suffixes: ReadonlyArray<Uint8Array>;
+        readonly components: ReadonlyArray<string>;
+    }
+    /** @internal */
+    const isWellFormed: (value: string) => boolean;
+    /** @internal */
+    const inputBytes: (input: PathInput) => Result.Result<Uint8Array, "InvalidPathEncoding" | "InvalidArgument">;
+    /** @internal */
+    const preparePath: (input: PathInput, operation: string, maxPathBytes: ByteSize.ByteSize | undefined) => Result.Result<PreparedPath, FsFailure>;
+}
+type PreparedPath = Paths.PreparedPath;
+/** @internal */
+export interface VolumeTestSeams {
+    readonly afterSubscribe: Effect.Effect<void>;
+    readonly betweenSnapshotAndSummary: Effect.Effect<void>;
+    readonly beforeTreeRemoval: Effect.Effect<void>;
+}
+/**
+ * Read in the caller's fiber, so a test supplies it with `withVolumeTestSeams` on the call under test.
+ *
+ * @internal
+ */
+export declare const VolumeTestSeams: Context.Reference<VolumeTestSeams>;
+/** @internal */
+export declare const withVolumeTestSeams: (seams: Partial<VolumeTestSeams>) => <XA, E, R>(self: Effect.Effect<XA, E, R>) => Effect.Effect<XA, E, R>;
+type CommitOutcome = "committed" | "rejected" | "unknown" | {
+    readonly _tag: "Rejected";
+    readonly cause: Cause.Cause<never>;
+};
+/** Private addressing; the public Target module is a compatibility view. @internal */
+export declare namespace Address {
+    /**
+     * How a caller names what it operates on. A `Target` is a path, an object
+     * reference, or an open handle; an `Entry` is a child of a directory target
+     * called `name`. Every verb takes one or the other, so the three addressing
+     * modes share one body and one option vocabulary.
+     *
+     * @since 0.6.0
+     */
+    /**
+     * A target: a path resolved from the caller's working directory or a base
+     * handle, an object reference, or an open handle.
+     *
+     * @category models
+     * @since 0.6.0
+     */
+    export type Target = Data.TaggedEnum<{
+        readonly Path: {
+            readonly path: PathInput;
+            /** A live directory handle from the same volume that a relative path starts from. */
+            readonly relativeTo?: DirectoryHandle;
+            /** Whether a final symbolic link is followed. Defaults to `true`. */
+            readonly followFinalSymlink?: boolean;
+        };
+        readonly Reference: {
+            readonly reference: ObjectReference;
+        };
+        readonly Handle: {
+            readonly handle: FileHandle | DirectoryHandle;
+        };
+    }>;
+    const enumeration: Data.TaggedEnum.Constructor<{
+        readonly _tag: "Handle";
+        readonly handle: FileHandle | DirectoryHandle;
+    } | {
+        readonly _tag: "Path";
+        readonly path: PathInput;
+        readonly relativeTo?: DirectoryHandle;
+        readonly followFinalSymlink?: boolean;
+    } | {
+        readonly _tag: "Reference";
+        readonly reference: ObjectReference;
+    }>;
+    /**
+     * Whether a value is a `Target`.
+     *
+     * @category predicates
+     * @since 0.6.0
+     */
+    export const isTarget: (value: unknown) => value is Target;
+    /**
+     * Anything a verb accepts where it takes a target: a `Target`, or the bare
+     * path, reference, or handle it would wrap.
+     *
+     * @category models
+     * @since 0.6.0
+     */
+    export type TargetInput = Target | PathInput | ObjectReference | FileHandle | DirectoryHandle;
+    /**
+     * Constructors and matchers for `Target`, plus `of`, which wraps a bare path,
+     * reference, or handle.
+     *
+     * @category constructors
+     * @since 0.6.0
+     */
+    export const Target: typeof enumeration & {
+        readonly of: (input: TargetInput) => Target;
+    };
+    /**
+     * A directory entry name as bytes or as a string encoded as UTF-8: one to 255
+     * bytes with no NUL and no slash. `.` and `..` are well formed but reserved.
+     *
+     * @category models
+     * @since 0.6.0
+     */
+    export type NameInput = string | Uint8Array;
+    /**
+     * Schema for a well-formed entry name, as bytes.
+     *
+     * @category schemas
+     * @since 0.6.0
+     */
+    export const Name: Schema.Uint8Array;
+    /**
+     * A well-formed entry name, as bytes.
+     *
+     * @category models
+     * @since 0.6.0
+     */
+    export type Name = typeof Name.Type;
+    /**
+     * A child of a directory target, called `name`.
+     *
+     * @category models
+     * @since 0.6.0
+     */
+    export interface Entry {
+        readonly directory: Target;
+        readonly name: NameInput;
+    }
+    /**
+     * Anything a verb accepts where it takes an entry: an `Entry`, or a path (bare
+     * or as a path target with a base) whose final component is the name and
+     * whose prefix is the directory.
+     *
+     * @category models
+     * @since 0.6.0
+     */
+    export type EntryInput = Entry | PathInput | PathTarget;
+    /**
+     * The path variant of `Target`.
+     *
+     * @category models
+     * @since 0.6.0
+     */
+    export type PathTarget = Extract<Target, {
+        readonly _tag: "Path";
+    }>;
+    /**
+     * Whether a value is an `Entry`.
+     *
+     * @category predicates
+     * @since 0.6.0
+     */
+    export const isEntry: (value: unknown) => value is Entry;
+    /**
+     * Names a child of a directory. The directory may be given bare.
+     *
+     * @example
+     * ```ts
+     * import { Entry, Target } from "@effect-vfs/core/Target"
+     *
+     * const explicit = Entry(Target.Path({ path: "/var" }), "log")
+     * const bare = Entry("/var", "log")
+     * ```
+     *
+     * @category constructors
+     * @since 0.6.0
+     */
+    export const Entry: {
+        (name: NameInput): (directory: TargetInput) => Entry;
+        (directory: TargetInput, name: NameInput): Entry;
+    };
+    /**
+     * Whether a path input is a byte path rather than a string.
+     *
+     * @category predicates
+     * @since 0.6.0
+     */
+    export const isBytePathInput: (input: PathInput) => boolean;
+    export {};
+}
+declare const Target: {
+    readonly Handle: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Handle";
+        readonly handle: FileHandle | DirectoryHandle;
+    }, "_tag">;
+    readonly Path: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Path";
+        readonly path: PathInput;
+        readonly relativeTo?: DirectoryHandle;
+        readonly followFinalSymlink?: boolean;
+    }, "_tag">;
+    readonly Reference: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Reference";
+        readonly reference: ObjectReference;
+    }, "_tag">;
+} & {
+    readonly $is: <Tag extends "Handle" | "Path" | "Reference">(tag: Tag) => (u: unknown) => u is Extract<{
+        readonly _tag: "Handle";
+        readonly handle: FileHandle | DirectoryHandle;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Path";
+        readonly path: PathInput;
+        readonly relativeTo?: DirectoryHandle;
+        readonly followFinalSymlink?: boolean;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Reference";
+        readonly reference: ObjectReference;
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends { readonly [Tag in "Handle" | "Path" | "Reference"]: (args: Extract<{
+            readonly _tag: "Handle";
+            readonly handle: FileHandle | DirectoryHandle;
+        } | {
+            readonly _tag: "Path";
+            readonly path: PathInput;
+            readonly relativeTo?: DirectoryHandle;
+            readonly followFinalSymlink?: boolean;
+        } | {
+            readonly _tag: "Reference";
+            readonly reference: ObjectReference;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: {
+            readonly _tag: "Handle";
+            readonly handle: FileHandle | DirectoryHandle;
+        } | {
+            readonly _tag: "Path";
+            readonly path: PathInput;
+            readonly relativeTo?: DirectoryHandle;
+            readonly followFinalSymlink?: boolean;
+        } | {
+            readonly _tag: "Reference";
+            readonly reference: ObjectReference;
+        }) => import("effect/Unify").Unify<ReturnType<Cases["Handle" | "Path" | "Reference"]>>;
+        <Cases extends { readonly [Tag in "Handle" | "Path" | "Reference"]: (args: Extract<{
+            readonly _tag: "Handle";
+            readonly handle: FileHandle | DirectoryHandle;
+        } | {
+            readonly _tag: "Path";
+            readonly path: PathInput;
+            readonly relativeTo?: DirectoryHandle;
+            readonly followFinalSymlink?: boolean;
+        } | {
+            readonly _tag: "Reference";
+            readonly reference: ObjectReference;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: {
+            readonly _tag: "Handle";
+            readonly handle: FileHandle | DirectoryHandle;
+        } | {
+            readonly _tag: "Path";
+            readonly path: PathInput;
+            readonly relativeTo?: DirectoryHandle;
+            readonly followFinalSymlink?: boolean;
+        } | {
+            readonly _tag: "Reference";
+            readonly reference: ObjectReference;
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Handle" | "Path" | "Reference"]>>;
+    };
+} & {
+    readonly of: (input: Address.TargetInput) => Address.Target;
+};
+type Target = Address.Target;
+type TargetInput = Address.TargetInput;
+type NameInput = Address.NameInput;
+type Entry = Address.Entry;
+type EntryInput = Address.EntryInput;
+/**
+ * Brand key that marks an object reference.
+ *
+ * @category type IDs
+ * @since 0.6.0
+ */
+export declare const ObjectReferenceId: unique symbol;
+/**
+ * Brand key that marks an object reference.
+ *
+ * @category type IDs
+ * @since 0.6.0
+ */
+export type ObjectReferenceId = typeof ObjectReferenceId;
+/**
+ * Schema for a caller's credentials. `privileged` is explicit; uid zero alone
+ * grants nothing.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const Identity: Schema.Struct<{
+    readonly uid: Schema.Natural;
+    readonly gid: Schema.Natural;
+    readonly groups: Schema.$Array<Schema.Natural>;
+    readonly privileged: Schema.Boolean;
+}>;
+/**
+ * A caller's credentials.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type Identity = typeof Identity.Type;
+/**
+ * Schema for the options of a root caller.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const RootCallerOptions: Schema.Struct<{
+    readonly identity: Schema.optionalKey<Schema.Struct<{
+        readonly uid: Schema.Natural;
+        readonly gid: Schema.Natural;
+        readonly groups: Schema.$Array<Schema.Natural>;
+        readonly privileged: Schema.Boolean;
+    }>>;
+    readonly umask: Schema.optionalKey<Schema.Natural>;
+}>;
+/**
+ * Options of a root caller.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type RootCallerOptions = typeof RootCallerOptions.Type;
+/**
+ * Schema for the options of `open` on a target: the access mode, whether a
+ * missing file is created, the creation mode, and append and truncate flags.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const OpenOptions: Schema.Struct<{
+    readonly access: Schema.Literals<readonly ["read", "write", "readWrite"]>;
+    readonly create: Schema.optionalKey<Schema.Literals<readonly ["never", "ifMissing", "exclusive"]>>;
+    readonly mode: Schema.optionalKey<Schema.Natural>;
+    readonly append: Schema.optionalKey<Schema.Boolean>;
+    readonly truncate: Schema.optionalKey<Schema.Boolean>;
+}>;
+/**
+ * Options of `open` on a target.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type OpenOptions = typeof OpenOptions.Type;
+/**
+ * Schema for the options of `writeFile`: the open options plus whether a
+ * final symbolic link is replaced or followed and the mode the file ends with.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const WriteFileOptions: Schema.Struct<{
+    readonly access: Schema.Literals<readonly ["read", "write", "readWrite"]>;
+    readonly create: Schema.optionalKey<Schema.Literals<readonly ["never", "ifMissing", "exclusive"]>>;
+    readonly mode: Schema.optionalKey<Schema.Natural>;
+    readonly append: Schema.optionalKey<Schema.Boolean>;
+    readonly truncate: Schema.optionalKey<Schema.Boolean>;
+    readonly followFinalSymlink: Schema.optionalKey<Schema.Boolean>;
+    readonly replaceFinalSymlink: Schema.optionalKey<Schema.Boolean>;
+    readonly finalMode: Schema.optionalKey<Schema.Natural>;
+}>;
+/**
+ * Options of `writeFile`.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type WriteFileOptions = typeof WriteFileOptions.Type;
+/**
+ * Schema for a directory's revision before and after a change.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const DirectoryChange: Schema.Struct<{
+    readonly before: Schema.BigInt;
+    readonly after: Schema.BigInt;
+}>;
+/**
+ * A directory's revision before and after a change.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type DirectoryChange = typeof DirectoryChange.Type;
+/**
+ * Schema for the result of `rename`.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const RenameReferenceResult: Schema.TaggedUnion<{
+    readonly DifferentDirectories: Schema.TaggedStruct<"DifferentDirectories", {
+        readonly sourceDirectory: Schema.Struct<{
+            readonly before: Schema.BigInt;
+            readonly after: Schema.BigInt;
+        }>;
+        readonly destinationDirectory: Schema.Struct<{
+            readonly before: Schema.BigInt;
+            readonly after: Schema.BigInt;
+        }>;
+    }>;
+    readonly SameDirectory: Schema.TaggedStruct<"SameDirectory", {
+        readonly directory: Schema.Struct<{
+            readonly before: Schema.BigInt;
+            readonly after: Schema.BigInt;
+        }>;
+    }>;
+}>;
+/**
+ * The result of `rename`.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type RenameReferenceResult = typeof RenameReferenceResult.Type;
+/**
+ * Schema for the options of `mkdir`. `exactMode` skips the caller's umask for
+ * an explicit creation mode; permission policy still applies. `recursive`
+ * creates every missing directory on the path in one change, as `mkdir -p`
+ * does, and succeeds when the final directory already exists; the mode
+ * applies to every directory it creates and the times to the final one.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const MkdirOptions: Schema.Struct<{
+    readonly mode: Schema.optionalKey<Schema.Natural>;
+    readonly exactMode: Schema.optionalKey<Schema.Boolean>;
+    readonly times: Schema.optionalKey<Schema.Struct<{
+        readonly access: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"now">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"omit">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"value">;
+            readonly nanoseconds: Schema.BigInt;
+        }>]>;
+        readonly modification: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"now">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"omit">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"value">;
+            readonly nanoseconds: Schema.BigInt;
+        }>]>;
+    }>>;
+    readonly recursive: Schema.optionalKey<Schema.Boolean>;
+}>;
+/**
+ * Options of `mkdir`.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type MkdirOptions = typeof MkdirOptions.Type;
+/**
+ * Schema for the options of `walk`: the order entries arrive in and the
+ * optional bounds on how deep, how many, and how many bytes the walk may
+ * reach. `order` defaults to `"pre"`, each directory before its entries; a
+ * `"post"` walk reports each directory after them. Every bound defaults to
+ * unbounded, and a walk that would pass one fails with `LimitExceeded` naming
+ * the bound in `field`.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const WalkOptions: Schema.Struct<{
+    readonly order: Schema.optionalKey<Schema.Literals<readonly ["pre", "post"]>>;
+    readonly maxDepth: Schema.optionalKey<Schema.Natural>;
+    readonly maxEntries: Schema.optionalKey<Schema.Natural>;
+    readonly maxBytes: Schema.optionalKey<Schema.ByteSize>;
+}>;
+/**
+ * Options of `walk`.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type WalkOptions = typeof WalkOptions.Type;
+/**
+ * Schema for the options of `remove`. `recursive` removes a directory and
+ * everything under it; `force` succeeds when the target itself is missing.
+ * `expected` pins object identity at each coordinated removal stage. A replacement fails `VolumeBusy`.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const RemoveOptions: Schema.Struct<{
+    readonly recursive: Schema.optionalKey<Schema.Boolean>;
+    readonly force: Schema.optionalKey<Schema.Boolean>;
+    readonly expected: Schema.optionalKey<Schema.suspend<Schema.declare<ObjectReference, ObjectReference>>>;
+}>;
+/**
+ * Options of `remove`.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type RemoveOptions = typeof RemoveOptions.Type;
+/**
+ * Schema for the options of `symlink`.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const SymlinkOptions: Schema.Struct<{
+    readonly times: Schema.optionalKey<Schema.Struct<{
+        readonly access: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"now">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"omit">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"value">;
+            readonly nanoseconds: Schema.BigInt;
+        }>]>;
+        readonly modification: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"now">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"omit">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"value">;
+            readonly nanoseconds: Schema.BigInt;
+        }>]>;
+    }>>;
+}>;
+/**
+ * Options of `symlink`.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type SymlinkOptions = typeof SymlinkOptions.Type;
+/**
+ * Schema for the attributes `setattr` changes together: a regular file's
+ * size, the permission mode, the owner, and the access and modification
+ * times. An omitted attribute keeps its current value. `expected` pins the
+ * target's revision the caller last observed, checked inside the same change,
+ * and fails as `StaleReference` naming `expected` when the target has moved
+ * on, so a change decided from that observation never applies to a newer one.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const SetattrOptions: Schema.Struct<{
+    readonly size: Schema.optionalKey<Schema.BigInt>;
+    readonly mode: Schema.optionalKey<Schema.Natural>;
+    readonly owner: Schema.optionalKey<Schema.Struct<{
+        readonly uid: Schema.optionalKey<Schema.Natural>;
+        readonly gid: Schema.optionalKey<Schema.Natural>;
+    }>>;
+    readonly times: Schema.optionalKey<Schema.Struct<{
+        readonly access: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"now">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"omit">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"value">;
+            readonly nanoseconds: Schema.BigInt;
+        }>]>;
+        readonly modification: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"now">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"omit">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"value">;
+            readonly nanoseconds: Schema.BigInt;
+        }>]>;
+    }>>;
+    readonly expected: Schema.optionalKey<Schema.Struct<{
+        readonly revision: Schema.BigInt;
+    }>>;
+}>;
+/**
+ * Attributes of `setattr`.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type SetattrOptions = typeof SetattrOptions.Type;
+/**
+ * Schema for an object reference: any value carrying the reference brand. Whether the volume issued it is checked
+ * where it is used.
+ *
+ * @internal
+ */
+export declare const ObjectReferenceSchema: Schema.declare<ObjectReference, ObjectReference>;
+/**
+ * Schema for the options of `open` on an entry, a lookup-or-create-and-open in
+ * one gate hold. `expected` pins the child the caller last observed under the
+ * name (or `null` for none) and fails as `VolumeBusy` when another has
+ * appeared; `expectedChild` pins its revision and times as well and fails as
+ * `StaleReference` when they moved.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const OpenEntryOptions: Schema.Struct<{
+    readonly access: Schema.Literals<readonly ["read", "write", "readWrite"]>;
+    readonly create: Schema.optionalKey<Schema.Literals<readonly ["never", "ifMissing", "exclusive"]>>;
+    readonly mode: Schema.optionalKey<Schema.Natural>;
+    readonly append: Schema.optionalKey<Schema.Boolean>;
+    readonly truncate: Schema.optionalKey<Schema.Boolean>;
+    readonly followFinalSymlink: Schema.optionalKey<Schema.Boolean>;
+    readonly times: Schema.optionalKey<Schema.Struct<{
+        readonly access: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"now">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"omit">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"value">;
+            readonly nanoseconds: Schema.BigInt;
+        }>]>;
+        readonly modification: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"now">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"omit">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"value">;
+            readonly nanoseconds: Schema.BigInt;
+        }>]>;
+    }>>;
+    readonly initialSize: Schema.optionalKey<Schema.BigInt>;
+    readonly exactMode: Schema.optionalKey<Schema.Boolean>;
+    readonly owner: Schema.optionalKey<Schema.Struct<{
+        readonly uid: Schema.optionalKey<Schema.Natural>;
+        readonly gid: Schema.optionalKey<Schema.Natural>;
+    }>>;
+    readonly expected: Schema.optionalKey<Schema.NullOr<Schema.declare<ObjectReference, ObjectReference>>>;
+    readonly expectedChild: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly reference: Schema.declare<ObjectReference, ObjectReference>;
+        readonly revision: Schema.BigInt;
+        readonly atimeNs: Schema.BigInt;
+        readonly mtimeNs: Schema.BigInt;
+    }>>>;
+}>;
+/**
+ * Options of `open` on an entry.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type OpenEntryOptions = typeof OpenEntryOptions.Type;
+/** State shared with community codecs through the legacy volumeState view. @internal */
+export declare namespace State {
+    /** @internal */
+    type Ino = number & Brand.Brand<"@effect-vfs/core/Ino">;
+    /** @internal */
+    const Ino: Brand.Constructor<Ino>;
+    /** @internal */
+    const ROOT_INO: Ino;
+    /** @internal */
+    const MAX_INO: number;
+    /** @internal */
+    const MAX_FILE_BYTES = 4294967295;
+    /** @internal */
+    const WALK_YIELD_INTERVAL = 128;
+    /** @internal */
+    interface Link {
+        readonly parent: Ino;
+        readonly name: string;
+    }
+    /** @internal */
+    type NodeMetadata = Omit<Metadata, "revision">;
+    /** @internal */
+    interface Directory {
+        readonly kind: "directory";
+        readonly ino: Ino;
+        readonly parent: Ino;
+        readonly name: string;
+        readonly entries: ReadonlyMap<string, Ino>;
+        readonly metadata: NodeMetadata;
+        readonly revision: bigint;
+    }
+    /** @internal */
+    interface RegularFile {
+        readonly kind: "file";
+        readonly ino: Ino;
+        readonly data: Uint8Array;
+        readonly links: ReadonlyArray<Link>;
+        readonly metadata: NodeMetadata;
+        readonly revision: bigint;
+    }
+    /** @internal */
+    interface SymbolicLink {
+        readonly kind: "symlink";
+        readonly ino: Ino;
+        readonly target: Uint8Array;
+        readonly links: ReadonlyArray<Link>;
+        readonly metadata: NodeMetadata;
+        readonly revision: bigint;
+    }
+    /** @internal */
+    type Node = Directory | RegularFile | SymbolicLink;
+    /** @internal */
+    interface VolumeState {
+        readonly inodes: HashMap.HashMap<Ino, Node>;
+        readonly open: ReadonlyMap<Ino, number>;
+        readonly nextInode: Ino;
+        readonly revision: bigint;
+        readonly entries: number;
+        readonly usedBytes: bigint;
+    }
+    /** @internal */
+    const getNode: (state: VolumeState, ino: Ino) => Node | undefined;
+    /** @internal */
+    const setNode: (inodes: HashMap.HashMap<Ino, Node>, node: Node) => HashMap.HashMap<Ino, Node>;
+    /** @internal */
+    const byIno: Order.Order<Node>;
+    /** @internal */
+    const byEntryName: Order.Order<readonly [string, Ino]>;
+    const inEntryOrder: (directory: Directory) => Directory;
+    /** @internal */
+    const payloadOf: (node: Node) => Uint8Array | undefined;
+    /** @internal */
+    const directoryMetadata: (ino: bigint, uid: number, gid: number, mode: number, now: bigint) => NodeMetadata;
+    /** @internal */
+    const pathOf: (get: (ino: Ino) => Node | undefined, ino: Ino) => string | undefined;
+    /** @internal */
+    const entryPath: (prefix: string, name: string) => BytePath;
+    /** @internal */
+    const emptyRoot: (now: bigint) => Directory;
+    /** @internal */
+    const emptyState: (now: bigint) => VolumeState;
+}
+declare const Ino: Brand.Constructor<State.Ino>;
+type Ino = State.Ino;
+type Link = State.Link;
+type Directory = State.Directory;
+type Node = State.Node;
+type VolumeState = State.VolumeState;
+/** @internal */
+export declare namespace TokenRegistry {
+    /** @internal */
+    type HandleLifecycle = {
+        readonly kind: "acquiring";
+    } | {
+        readonly kind: "open";
+        readonly ino: Ino;
+    } | {
+        readonly kind: "releasedPendingCommit";
+        readonly ino: Ino | undefined;
+    } | {
+        readonly kind: "closed";
+    };
+    /** @internal */
+    interface HandleReference {
+        readonly volume: symbol;
+        lifecycle: HandleLifecycle;
+        namespaceRoots?: ReadonlyArray<Ino> | undefined;
+        boundaries?: ReadonlyArray<ReadonlyArray<Ino>> | undefined;
+        authority?: ((node: Node, op: OpContext) => Effect.Effect<void, FsFailure>) | undefined;
+        scope: Scope.Closeable | undefined;
+    }
+    /** @internal */
+    interface FileReference extends HandleReference {
+        offset: bigint;
+        readonly access: "read" | "write" | "readWrite";
+        readonly append: boolean;
+    }
+    /** @internal */
+    type DirectoryReference = HandleReference;
+    /** @internal */
+    type Token = ObjectReference | FileHandle | DirectoryHandle;
+    /** @internal */
+    type Resolution = {
+        readonly kind: "unknown";
+    } | {
+        readonly kind: "foreign";
+    } | {
+        readonly kind: "stale";
+    } | {
+        readonly kind: "live";
+        readonly node: Node;
+    };
+    /** @internal */
+    const inode: (reference: HandleReference) => Ino | undefined;
+    /** @internal */
+    const isOpen: (reference: HandleReference) => boolean;
+    /** @internal */
+    const publish: (reference: HandleReference, ino: Ino) => void;
+    /** @internal */
+    const released: (reference: HandleReference) => void;
+    /** @internal */
+    const release: <E, R>(reference: HandleReference, releaseInode: (ino: Ino) => Effect.Effect<void, E, R>, afterRelease: (action: () => void) => Effect.Effect<void, never, R>) => Effect.Effect<void, E, R>;
+    /** @internal */
+    const closeReleasedScope: (reference: HandleReference) => Effect.Effect<void, never, never>;
+    /** @internal */
+    const finalize: (reference: HandleReference, close: Effect.Effect<unknown, FsFailure>, fallback: Effect.Effect<void>) => Effect.Effect<void, never, never>;
+    /** @internal */
+    const acquire: <A, E, R, ReleaseR, CoordinateR>(reference: HandleReference, coordinate: (acquire: Effect.Effect<A, E, R | ReleaseR>) => Effect.Effect<A, E | FsFailure, CoordinateR>, acquisition: Effect.Effect<A, E, R>, releaseAcquired: () => Effect.Effect<void, never, ReleaseR>, finalizer: Effect.Effect<void, never, never>) => Effect.Effect<A, E | FsFailure, CoordinateR | Scope.Scope>;
+    /** @internal */
+    const nodeOrFail: (result: Resolution, addressing: "reference" | "handle", op: OpContext) => Effect.Effect<never, FsFailure, never> | Effect.Effect<State.Node, never, never>;
+    /** @internal */
+    const make: (volume: symbol, get: (ino: Ino) => Effect.Effect<Node | undefined>) => {
+        referenceIdentity: (token: ObjectReference, op: OpContext) => Effect.Effect<Ino, FsFailure>;
+        handleBoundaries: (token: Token) => readonly (readonly State.Ino[])[];
+        authorizeHandle: (token: Token, node: Node, op: OpContext) => Effect.Effect<void, FsFailure, never>;
+        resolve: (token: Token, addressing: "reference" | "handle" | "directory") => Effect.Effect<Resolution, never, never>;
+        resolveInode: (ino: Ino) => Effect.Effect<Resolution>;
+        referenceFor: (ino: Ino) => ObjectReference;
+        forget: (ino: Ino) => boolean;
+        file: (access: FileReference["access"], append: boolean) => FileReference;
+        directory: (ino?: Ino) => DirectoryReference;
+        registerFile: (handle: FileHandle, reference: FileReference) => WeakMap<object, FileReference>;
+        registerDirectory: (handle: DirectoryHandle, reference: DirectoryReference) => WeakMap<object, HandleReference>;
+    };
+    /** @internal */
+    type TokenRegistry = ReturnType<typeof make>;
+}
+/** @internal */
+declare namespace Confinement {
+    /** @internal */
+    const make: (view: Effect.Effect<(ino: Ino) => Node | undefined>, roots: ReadonlyArray<Ino>) => {
+        roots: readonly State.Ino[];
+        root: State.Ino;
+        alive: (op: OpContext, handle?: boolean) => Effect.Effect<undefined, FsFailure, never>;
+        contains: (node: Node) => Effect.Effect<boolean, never, never>;
+        check: (node: State.Node, op: Errors.OpContext, handle?: boolean | undefined) => Effect.Effect<void, FsFailure, never>;
+        path: (ino: State.Ino) => Effect.Effect<string | undefined, never, never>;
+    };
+    /** @internal */
+    type Confinement = ReturnType<typeof make>;
+}
+/** @internal */
+export declare namespace Resolution {
+    /** @internal */
+    export type PreparedEntry = {
+        readonly kind: "path";
+        readonly path: PreparedPath;
+        readonly base: DirectoryHandle | undefined;
+    } | {
+        readonly kind: "entry";
+        readonly directory: Target;
+        readonly name: string;
+    };
+    /** @internal */
+    export interface NodeMode<R = never> {
+        readonly kind: "Node";
+        readonly followFinalSymlink?: boolean;
+        readonly final?: boolean;
+        readonly createMissing?: (parent: Directory, name: string, final: boolean) => Effect.Effect<Directory, FsFailure, R>;
+    }
+    /** @internal */
+    export interface ParentMode {
+        readonly kind: "Parent";
+    }
+    /** @internal */
+    export interface OrCreateMode<R = never> {
+        readonly kind: "OrCreate";
+        readonly create: "never" | "ifMissing" | "exclusive";
+        readonly finalSymlink: "follow" | "preserve";
+        readonly entryExclusive?: "afterSymlink";
+        readonly beforeFollow?: (parent: Directory, child: Node | undefined) => Effect.Effect<void, FsFailure, R>;
+    }
+    /** @internal */
+    export type NodeResult = {
+        readonly kind: "node";
+        readonly node: Node;
+        readonly op: OpContext;
+    } | {
+        readonly kind: "entry";
+        readonly node: Node;
+        readonly parent: Directory;
+        readonly name: string;
+        readonly op: OpContext;
+    };
+    /** @internal */
+    export interface ParentResult {
+        readonly kind: "parent";
+        readonly parent: Ino;
+        readonly name: string | undefined;
+        readonly trailingSlash: boolean;
+        readonly addressing: "path" | "entry";
+        readonly op: OpContext;
+    }
+    interface CreateEntry {
+        readonly parent: Directory;
+        readonly name: string;
+        readonly trailingSlash: boolean;
+        readonly addressing: "path" | "entry";
+        readonly op: OpContext;
+        readonly origin: {
+            readonly parent: Directory;
+            readonly name: string;
+        };
+    }
+    /** @internal */
+    export type CreateResult = (CreateEntry & {
+        readonly kind: "existing";
+        readonly node: Node;
+    }) | (CreateEntry & {
+        readonly kind: "missing";
+    });
+    /** @internal */
+    export const inGroup: (identity: Identity, gid: number) => boolean;
+    /** @internal */
+    export const permitted: (node: Node, identity: Identity) => number;
+    /** @internal */
+    export const authorize: (node: Node, identity: Identity, bits: number, op: OpContext) => Effect.Effect<void, never, never> | Effect.Effect<never, FsFailure, never>;
+    /** @internal */
+    export const entryName: (input: NameInput, op: OpContext) => Result.Result<string, FsFailure>;
+    /** @internal */
+    export const make: ({ caller, get, identity, maxPathBytes, registry, confinement, additional, authorityView }: {
+        readonly additional?: ReadonlyArray<Confinement.Confinement> | undefined;
+        readonly authorityView: Effect.Effect<(ino: Ino) => Node | undefined>;
+        readonly confinement?: Confinement.Confinement | undefined;
+        readonly caller: TokenRegistry.DirectoryReference;
+        readonly get: (ino: Ino) => Effect.Effect<Node | undefined>;
+        readonly identity: Identity;
+        readonly maxPathBytes: ByteSize.ByteSize | undefined;
+        readonly registry: TokenRegistry.TokenRegistry;
+    }) => {
+        prepare: (input: PathInput, op: OpContext) => Result.Result<Paths.PreparedPath, FsFailure>;
+        prepareEntry: (input: EntryInput, op: OpContext) => Result.Result<PreparedEntry, FsFailure>;
+        resolve: {
+            <R = never>(target: Target, mode: NodeMode<R>, op: OpContext): Effect.Effect<NodeResult, FsFailure, R>;
+            (prepared: PreparedEntry, mode: ParentMode, op: OpContext): Effect.Effect<ParentResult, FsFailure>;
+            <R = never>(prepared: PreparedEntry, mode: OrCreateMode<R>, op: OpContext): Effect.Effect<CreateResult, FsFailure, R>;
+        };
+        directory: (target: {
+            readonly _tag: "Handle";
+            readonly handle: FileHandle | DirectoryHandle;
+        } | {
+            readonly _tag: "Path";
+            readonly path: PathInput;
+            readonly relativeTo?: DirectoryHandle;
+            readonly followFinalSymlink?: boolean;
+        } | {
+            readonly _tag: "Reference";
+            readonly reference: ObjectReference;
+        }, op: Errors.OpContext) => Effect.Effect<{
+            node: State.Directory;
+            op: Errors.OpContext;
+        }, FsFailure, never>;
+        entryDirectory: (target: {
+            readonly _tag: "Handle";
+            readonly handle: FileHandle | DirectoryHandle;
+        } | {
+            readonly _tag: "Path";
+            readonly path: PathInput;
+            readonly relativeTo?: DirectoryHandle;
+            readonly followFinalSymlink?: boolean;
+        } | {
+            readonly _tag: "Reference";
+            readonly reference: ObjectReference;
+        }, op: Errors.OpContext) => Effect.Effect<{
+            node: State.Directory;
+            op: Errors.OpContext;
+        }, FsFailure, never>;
+    };
+    export {};
+}
+/** @internal */
+export interface EngineOptions {
+    readonly execution?: "cooperative" | "sync" | undefined;
+    readonly limits?: BasicLimits | undefined;
+    readonly initialTime?: bigint | undefined;
+    readonly initialState?: VolumeState | undefined;
+    readonly commitProvider?: CommitProvider<VolumeState> | undefined;
+    readonly installed?: ((events: () => Iterable<WatchEvent>, installation: Installation) => void) | undefined;
+}
+/** @internal */
+export declare const BasicLimits: Schema.Struct<{
+    readonly maxEntries: Schema.optional<Schema.Natural>;
+    readonly maxBytes: Schema.optional<Schema.ByteSize>;
+    readonly maxFileBytes: Schema.optional<Schema.ByteSize>;
+    readonly maxPathBytes: Schema.optional<Schema.ByteSize>;
+    readonly maxPendingOperations: Schema.optional<Schema.Int>;
+}>;
+/** @internal */
+export type BasicLimits = typeof BasicLimits.Type;
+/** @internal */
+export interface Rename {
+    readonly ino: Ino;
+    readonly from: Link;
+    readonly to: Link;
+}
+/** @internal */
+export interface Installation {
+    readonly before: VolumeState;
+    readonly after: VolumeState;
+    readonly renames?: ReadonlyArray<Rename>;
+}
+/** @internal */
+export interface WatchEvent {
+    readonly change: {
+        readonly _tag: "Create" | "Update" | "Remove";
+        readonly path: BytePath;
+    };
+    readonly parent: Ino;
+    readonly ino: Ino;
+    readonly name?: string;
+}
+/** @internal */
+export interface WatchTarget {
+    readonly roots: ReadonlyArray<Ino>;
+    readonly additionalRoots: ReadonlyArray<ReadonlyArray<Ino>>;
+    readonly target: Ino;
+    readonly recursive: boolean;
+    readonly selected?: Link;
+}
+/** @internal */
+export interface EngineOperations {
+    readonly limits: EngineLimits;
+    readonly root: Effect.Effect<ObjectReference, FsFailure>;
+    readonly lookup: (entry: EntryInput) => Effect.Effect<ObjectReference, FsFailure>;
+    readonly parent: (directory: TargetInput) => Effect.Effect<ObjectReference, FsFailure>;
+    readonly stat: (target: TargetInput) => Effect.Effect<Metadata, FsFailure>;
+    readonly readDirectory: (directory: TargetInput) => Effect.Effect<ObjectObservation<ReadonlyArray<DirectoryEntry>>, FsFailure>;
+    readonly walk: (directory: TargetInput, options?: WalkOptions) => Stream.Stream<WalkEntry, WalkFailure>;
+    readonly readLink: (target: TargetInput) => Effect.Effect<Uint8Array, FsFailure>;
+    readonly realPath: (target: TargetInput) => Effect.Effect<BytePath, FsFailure>;
+    readonly access: (target: TargetInput, bits?: number) => Effect.Effect<number, FsFailure>;
+    readonly readFile: (target: TargetInput) => Effect.Effect<Uint8Array, FsFailure>;
+    readonly writeFile: {
+        (bytes: Uint8Array, options: WriteFileOptions): (entry: EntryInput) => Effect.Effect<ObjectReference, FsFailure>;
+        (entry: EntryInput, bytes: Uint8Array, options: WriteFileOptions): Effect.Effect<ObjectReference, FsFailure>;
+    };
+    readonly open: {
+        (target: Target | PathInput | ObjectReference | FileHandle, options: OpenOptions): Effect.Effect<FileHandle, FsFailure, Scope.Scope>;
+        (entry: Entry, options: OpenEntryOptions): Effect.Effect<OpenEntryResult, FsFailure, Scope.Scope>;
+    };
+    readonly mkdir: (entry: EntryInput, options?: MkdirOptions) => Effect.Effect<ReferenceEntryResult, FsFailure>;
+    readonly symlink: (target: PathInput, entry: EntryInput, options?: SymlinkOptions) => Effect.Effect<ReferenceEntryResult, FsFailure>;
+    readonly link: {
+        (entry: EntryInput): (source: TargetInput) => Effect.Effect<ReferenceEntryResult, FsFailure>;
+        (source: TargetInput, entry: EntryInput): Effect.Effect<ReferenceEntryResult, FsFailure>;
+    };
+    readonly unlink: (entry: EntryInput) => Effect.Effect<DirectoryChange, FsFailure>;
+    readonly rmdir: (entry: EntryInput) => Effect.Effect<DirectoryChange, FsFailure>;
+    readonly remove: {
+        (entry: EntryInput, options?: RemoveOptions & {
+            readonly force?: false;
+        }): Effect.Effect<DirectoryChange, FsFailure>;
+        (entry: EntryInput, options: RemoveOptions): Effect.Effect<DirectoryChange | undefined, FsFailure>;
+    };
+    readonly rename: {
+        (to: EntryInput): (from: EntryInput) => Effect.Effect<RenameReferenceResult, FsFailure>;
+        (from: EntryInput, to: EntryInput): Effect.Effect<RenameReferenceResult, FsFailure>;
+    };
+    readonly chmod: {
+        (mode: number): (target: TargetInput) => Effect.Effect<void, FsFailure>;
+        (target: TargetInput, mode: number): Effect.Effect<void, FsFailure>;
+    };
+    readonly chown: {
+        (owner: OwnerUpdate): (target: TargetInput) => Effect.Effect<void, FsFailure>;
+        (target: TargetInput, owner: OwnerUpdate): Effect.Effect<void, FsFailure>;
+    };
+    readonly utimes: {
+        (times: Times): (target: TargetInput) => Effect.Effect<void, FsFailure>;
+        (target: TargetInput, times: Times): Effect.Effect<void, FsFailure>;
+    };
+    readonly truncate: {
+        (length: bigint): (target: TargetInput) => Effect.Effect<void, FsFailure>;
+        (target: TargetInput, length: bigint): Effect.Effect<void, FsFailure>;
+    };
+    readonly setattr: {
+        (attributes: SetattrOptions): (target: TargetInput) => Effect.Effect<void, FsFailure>;
+        (target: TargetInput, attributes: SetattrOptions): Effect.Effect<void, FsFailure>;
+    };
+    readonly openDirectory: (directory: TargetInput) => Effect.Effect<DirectoryHandle, FsFailure, Scope.Scope>;
+}
+/** @internal */
+export interface EngineContext {
+    readonly operations: EngineOperations;
+    readonly selectWatch: (input: TargetInput, options: {
+        readonly recursive?: boolean | undefined;
+        readonly alias?: "all" | "resolved" | undefined;
+    }) => Effect.Effect<WatchTarget, FsFailure>;
+    readonly withRoot: (input: TargetInput) => Effect.Effect<EngineContext, FsFailure, Scope.Scope>;
+    readonly withDirectory: (input: TargetInput) => Effect.Effect<EngineContext, FsFailure, Scope.Scope>;
+}
+/** @internal */
+export interface CommitProvider<State> {
+    readonly mode: "memory" | "durable";
+    readonly commit: (candidate: State) => Effect.Effect<CommitOutcome, FsFailure & {
+        readonly code: "StorageRejected";
+    }>;
+    readonly shutdown: Effect.Effect<void>;
+}
+/** @internal */
+export declare const memoryCommitProvider: CommitProvider<VolumeState>;
+/** @internal */
+export declare const makeEngine: (options?: EngineOptions | undefined) => Effect.Effect<Readonly<{
+    limits: Readonly<{
+        maxEntries: number | undefined;
+        maxBytes: ByteSize.ByteSize | undefined;
+        maxPathBytes: ByteSize.ByteSize | undefined;
+        maxFileBytes: ByteSize.ByteSize;
+        maxPendingOperations: number;
+    }>;
+    shutdown: Effect.Effect<void, never, never>;
+    usage: Effect.Effect<VolumeUsage, FsFailure, never>;
+    context: (options?: {
+        readonly identity?: {
+            readonly uid: number;
+            readonly gid: number;
+            readonly groups: readonly number[];
+            readonly privileged: boolean;
+        };
+        readonly umask?: number;
+    } | undefined) => Effect.Effect<EngineContext, FsFailure, never>;
+    coordinate: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | FsFailure, R>;
+    admit: <A, E, R>(op: OpContext, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | FsFailure, R>;
+    checkAvailable: (operation: string) => Effect.Effect<void, FsFailure, never>;
+    execution: "cooperative" | "sync";
+    syncBinding: Readonly<{
+        check: (operation: string) => Result.Result<void, FsFailure>;
+    }> | undefined;
+    preflight: (op: OpContext) => Effect.Effect<void, FsFailure>;
+    capture: (operation: string) => Effect.Effect<State.VolumeState, FsFailure, never>;
+    cooperativeCapture: (<A, E, R>(operation: string, read: (state: VolumeState) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | FsFailure, R>) | undefined;
+    referenceInode: (reference: ObjectReference, op: OpContext) => Effect.Effect<State.Ino, FsFailure, never>;
+    objectFor: (resolveInode: Effect.Effect<Ino, FsFailure>, op: OpContext) => Effect.Effect<ObjectReference, FsFailure, never>;
+    watchRoot: (reference: ObjectReference, op: Errors.OpContext) => Effect.Effect<State.Ino, FsFailure, never>;
+}>, ArgumentFailure, never>;
+export {};
+//# sourceMappingURL=engine.d.ts.map