@effect-vfs/core 0.3.1 → 0.5.0

package/dist/internal/{virtualFileSystem/errors.js → errors.js}

@@ -1,8 +1,10 @@
 // Virtual filesystem failure schemas and identities shared by the runtime implementation.
-import * as Data from "effect/Data";
 import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
+import { ConfigurationError, FsError } from "../VirtualFileSystemError.js";
+/** @internal */
+export { ConfigurationError, FsError };
 /** @internal */
 export const FsCode = Schema.Literals([
     "NotFound",
@@ -24,21 +26,15 @@ export const FsCode = Schema.Literals([
     "FileTooLarge",
     "NoData",
     "SymlinkLoop",
-    "UnrepresentableName"
+    "UnrepresentableName",
+    // A durable provider knows the mutation was not committed.
+    "StorageRejected",
+    // A commit or publication failed after its outcome ceased to be knowable to the caller.
+    "OutcomeUnknown",
+    // The provider stopped serving operations until recovery establishes its state.
+    "VolumeUnavailable",
+    "VolumeBusy"
 ]);
-/** @internal */
-export class FsError extends Data.TaggedError("FsError") {
-    // The path is omitted on purpose: byte paths are not printable and may carry user data.
-    get message() {
-        return `${this.operation} failed with ${this.code}`;
-    }
-}
-/** @internal */
-export class ConfigurationError extends Data.TaggedError("ConfigurationError") {
-    get message() {
-        return `Invalid option: ${this.field}`;
-    }
-}
 // Names the offending option so the caller learns which key it got wrong, not just that decoding failed.
 const configurationField = (issue) => {
     if (Predicate.isTagged("Pointer")(issue))

package/dist/internal/{virtualFileSystem/fixture.d.ts → fixture.d.ts}

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect";
-import { ImageError } from "../../Snapshot.js";
+import { ImageError } from "../Snapshot.js";
 /** @internal */
 export declare const fromFixture: (fixture: {
     readonly rootMetadata?: {
@@ -13,7 +13,7 @@ export declare const fromFixture: (fixture: {
     };
     readonly entries: readonly ({
         readonly kind: "directory";
-        readonly path: string | import("../../BytePath.js").BytePath;
+        readonly path: string | import("../BytePath.js").BytePath;
         readonly metadata?: {
             readonly uid?: number;
             readonly gid?: number;
@@ -25,7 +25,7 @@ export declare const fromFixture: (fixture: {
         };
     } | {
         readonly kind: "file";
-        readonly path: string | import("../../BytePath.js").BytePath;
+        readonly path: string | import("../BytePath.js").BytePath;
         readonly bytes: Uint8Array<ArrayBufferLike>;
         readonly metadata?: {
             readonly uid?: number;
@@ -38,8 +38,8 @@ export declare const fromFixture: (fixture: {
         };
     } | {
         readonly kind: "symlink";
-        readonly path: string | import("../../BytePath.js").BytePath;
-        readonly target: string | import("../../BytePath.js").BytePath;
+        readonly path: string | import("../BytePath.js").BytePath;
+        readonly target: string | import("../BytePath.js").BytePath;
         readonly metadata?: {
             readonly uid?: number;
             readonly gid?: number;
@@ -51,13 +51,16 @@ export declare const fromFixture: (fixture: {
         };
     } | {
         readonly kind: "hardLink";
-        readonly path: string | import("../../BytePath.js").BytePath;
-        readonly target: string | import("../../BytePath.js").BytePath;
+        readonly path: string | import("../BytePath.js").BytePath;
+        readonly target: string | import("../BytePath.js").BytePath;
     })[];
 }, options?: {
+    readonly identity?: string & import("effect/Brand").Brand<"@effect-vfs/core/VolumeIdentity">;
     readonly maxEntries?: number;
+    readonly maxPendingOperations?: number;
+    readonly maxWatchEvents?: number;
     readonly maxBytes?: import("effect/ByteSize").ByteSize;
     readonly maxFileBytes?: import("effect/ByteSize").ByteSize;
     readonly maxPathBytes?: import("effect/ByteSize").ByteSize;
-} | undefined) => Effect.Effect<import("../../VirtualFileSystem.js").Volume, import("./errors.js").ConfigurationError | ImageError, never>;
+} | undefined) => Effect.Effect<import("../VirtualFileSystem.js").Volume, import("./errors.js").ConfigurationError | ImageError | import("effect/PlatformError").PlatformError, import("effect/Crypto").Crypto>;
 //# sourceMappingURL=fixture.d.ts.map

package/dist/internal/fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture.d.ts","sourceRoot":"","sources":["../../src/internal/fixture.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAoB3C,gBAAgB;AAChB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+MAwLvB,CAAA"}

package/dist/internal/{virtualFileSystem/fixture.js → fixture.js}

@@ -2,12 +2,12 @@
 import * as Effect from "effect/Effect";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import { ImageError } from "../../Snapshot.js";
-import { CanonicalBase64 } from "../canonicalBase64.js";
-import * as Image from "../image.js";
-import { Fixture as FixtureSchema, FixtureEntry, makeVolume, VolumeOptions as VolumeOptionsSchema, VolumeSource } from "../virtualFileSystem.js";
+import { ImageError } from "../Snapshot.js";
+import { CanonicalBase64 } from "./canonicalBase64.js";
 import { decodeConfiguration, FsError } from "./errors.js";
+import * as Image from "./image.js";
 import { inputBytes, isAttachedBytes, isDotComponent, nameBytes, preparePath } from "./path.js";
+import { Fixture as FixtureSchema, FixtureEntry, makeVolume, VolumeIdentity, VolumeOptions as VolumeOptionsSchema, VolumeSource } from "./virtualFileSystem.js";
 const DEFAULT_MODE = { directory: 0o755, file: 0o644, symlink: 0o777 };
 const EPOCH_NS = 0n;
 /** @internal */
@@ -140,5 +140,11 @@ export const fromFixture = Effect.fn("VirtualFileSystem.fromFixture")(function*
     }));
     const snapshot = yield* Image.capture({ format: "effect-vfs", version: 1, root: "root", records }, undefined, true);
     const image = yield* Image.inspect(snapshot);
-    return yield* makeVolume(VolumeSource.Snapshot({ image }), config.success);
+    const { identity, ...volumeOptions } = config.success;
+    if (identity === undefined)
+        return yield* makeVolume(VolumeSource.Snapshot({ image }), volumeOptions);
+    return yield* makeVolume(VolumeSource.Snapshot({ image }), {
+        ...volumeOptions,
+        identity: VolumeIdentity.make(identity)
+    });
 });

package/dist/internal/liveImage.d.ts

@@ -0,0 +1,286 @@
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { ImageError } from "../Snapshot.js";
+/** @internal */
+export declare const Record: Schema.TaggedUnion<{
+    readonly directory: Schema.TaggedStruct<"directory", {
+        readonly ino: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        readonly revision: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        readonly lineage: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.Struct<{
+            readonly uid: Schema.Natural;
+            readonly gid: Schema.Natural;
+            readonly mode: Schema.Natural;
+            readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly nlink: Schema.Natural;
+            readonly size: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        }>;
+        readonly entries: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+            readonly target: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        }>>;
+    }>;
+    readonly file: Schema.TaggedStruct<"file", {
+        readonly ino: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        readonly revision: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        readonly lineage: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.Struct<{
+            readonly uid: Schema.Natural;
+            readonly gid: Schema.Natural;
+            readonly mode: Schema.Natural;
+            readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly nlink: Schema.Natural;
+            readonly size: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        }>;
+        readonly data: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+    }>;
+    readonly symlink: Schema.TaggedStruct<"symlink", {
+        readonly ino: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        readonly revision: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        readonly lineage: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.Struct<{
+            readonly uid: Schema.Natural;
+            readonly gid: Schema.Natural;
+            readonly mode: Schema.Natural;
+            readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly nlink: Schema.Natural;
+            readonly size: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        }>;
+        readonly target: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+    }>;
+}>;
+/** @internal */
+export type Record = typeof Record.Type;
+/** @internal */
+export declare const Document: Schema.Struct<{
+    readonly format: Schema.Literal<"effect-vfs-live">;
+    readonly version: Schema.Literal<1>;
+    readonly identity: Schema.String;
+    readonly root: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+    readonly nextInode: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+    readonly revisionCounter: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+    readonly entries: Schema.Natural;
+    readonly usedBytes: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+    readonly limits: Schema.Struct<{
+        readonly maxEntries: Schema.optionalKey<Schema.Natural>;
+        readonly maxBytes: Schema.optionalKey<Schema.decodeTo<Schema.BigInt, Schema.String, never, never>>;
+        readonly maxFileBytes: Schema.optionalKey<Schema.decodeTo<Schema.BigInt, Schema.String, never, never>>;
+        readonly maxPathBytes: Schema.optionalKey<Schema.decodeTo<Schema.BigInt, Schema.String, never, never>>;
+    }>;
+    readonly retainedFiles: Schema.$Array<Schema.decodeTo<Schema.BigInt, Schema.String, never, never>>;
+    readonly records: Schema.$Array<Schema.TaggedUnion<{
+        readonly directory: Schema.TaggedStruct<"directory", {
+            readonly ino: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly revision: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly lineage: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.Struct<{
+                readonly uid: Schema.Natural;
+                readonly gid: Schema.Natural;
+                readonly mode: Schema.Natural;
+                readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly nlink: Schema.Natural;
+                readonly size: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }>;
+            readonly entries: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+                readonly target: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }>>;
+        }>;
+        readonly file: Schema.TaggedStruct<"file", {
+            readonly ino: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly revision: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly lineage: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.Struct<{
+                readonly uid: Schema.Natural;
+                readonly gid: Schema.Natural;
+                readonly mode: Schema.Natural;
+                readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly nlink: Schema.Natural;
+                readonly size: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }>;
+            readonly data: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+        }>;
+        readonly symlink: Schema.TaggedStruct<"symlink", {
+            readonly ino: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly revision: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly lineage: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.Struct<{
+                readonly uid: Schema.Natural;
+                readonly gid: Schema.Natural;
+                readonly mode: Schema.Natural;
+                readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly nlink: Schema.Natural;
+                readonly size: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }>;
+            readonly target: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+        }>;
+    }>>;
+}>;
+/** @internal */
+export type Document = typeof Document.Type;
+/** @internal */
+export declare const encode: (document: {
+    readonly format: "effect-vfs-live";
+    readonly version: 1;
+    readonly identity: string;
+    readonly root: bigint;
+    readonly nextInode: bigint;
+    readonly revisionCounter: bigint;
+    readonly entries: number;
+    readonly usedBytes: bigint;
+    readonly limits: {
+        readonly maxEntries?: number;
+        readonly maxBytes?: bigint;
+        readonly maxFileBytes?: bigint;
+        readonly maxPathBytes?: bigint;
+    };
+    readonly retainedFiles: readonly bigint[];
+    readonly records: readonly ({
+        readonly _tag: "directory";
+        readonly ino: bigint;
+        readonly revision: bigint;
+        readonly lineage?: string;
+        readonly metadata: {
+            readonly uid: number;
+            readonly gid: number;
+            readonly mode: number;
+            readonly atimeNs: bigint;
+            readonly mtimeNs: bigint;
+            readonly ctimeNs: bigint;
+            readonly birthtimeNs: bigint;
+            readonly nlink: number;
+            readonly size: bigint;
+        };
+        readonly entries: readonly {
+            readonly name: string & import("effect/Brand").Brand<"CanonicalBase64">;
+            readonly target: bigint;
+        }[];
+    } | {
+        readonly _tag: "file";
+        readonly ino: bigint;
+        readonly revision: bigint;
+        readonly lineage?: string;
+        readonly metadata: {
+            readonly uid: number;
+            readonly gid: number;
+            readonly mode: number;
+            readonly atimeNs: bigint;
+            readonly mtimeNs: bigint;
+            readonly ctimeNs: bigint;
+            readonly birthtimeNs: bigint;
+            readonly nlink: number;
+            readonly size: bigint;
+        };
+        readonly data: string & import("effect/Brand").Brand<"CanonicalBase64">;
+    } | {
+        readonly _tag: "symlink";
+        readonly ino: bigint;
+        readonly revision: bigint;
+        readonly lineage?: string;
+        readonly metadata: {
+            readonly uid: number;
+            readonly gid: number;
+            readonly mode: number;
+            readonly atimeNs: bigint;
+            readonly mtimeNs: bigint;
+            readonly ctimeNs: bigint;
+            readonly birthtimeNs: bigint;
+            readonly nlink: number;
+            readonly size: bigint;
+        };
+        readonly target: string & import("effect/Brand").Brand<"CanonicalBase64">;
+    })[];
+}) => Effect.Effect<Uint8Array<ArrayBuffer>, ImageError, never>;
+/** @internal */
+export declare const decode: (bytes: Uint8Array<ArrayBufferLike>, maxEncodedBytes: ByteSize.ByteSize) => Effect.Effect<{
+    readonly format: "effect-vfs-live";
+    readonly version: 1;
+    readonly identity: string;
+    readonly root: bigint;
+    readonly nextInode: bigint;
+    readonly revisionCounter: bigint;
+    readonly entries: number;
+    readonly usedBytes: bigint;
+    readonly limits: {
+        readonly maxEntries?: number;
+        readonly maxBytes?: bigint;
+        readonly maxFileBytes?: bigint;
+        readonly maxPathBytes?: bigint;
+    };
+    readonly retainedFiles: readonly bigint[];
+    readonly records: readonly ({
+        readonly _tag: "directory";
+        readonly ino: bigint;
+        readonly revision: bigint;
+        readonly lineage?: string;
+        readonly metadata: {
+            readonly uid: number;
+            readonly gid: number;
+            readonly mode: number;
+            readonly atimeNs: bigint;
+            readonly mtimeNs: bigint;
+            readonly ctimeNs: bigint;
+            readonly birthtimeNs: bigint;
+            readonly nlink: number;
+            readonly size: bigint;
+        };
+        readonly entries: readonly {
+            readonly name: string & import("effect/Brand").Brand<"CanonicalBase64">;
+            readonly target: bigint;
+        }[];
+    } | {
+        readonly _tag: "file";
+        readonly ino: bigint;
+        readonly revision: bigint;
+        readonly lineage?: string;
+        readonly metadata: {
+            readonly uid: number;
+            readonly gid: number;
+            readonly mode: number;
+            readonly atimeNs: bigint;
+            readonly mtimeNs: bigint;
+            readonly ctimeNs: bigint;
+            readonly birthtimeNs: bigint;
+            readonly nlink: number;
+            readonly size: bigint;
+        };
+        readonly data: string & import("effect/Brand").Brand<"CanonicalBase64">;
+    } | {
+        readonly _tag: "symlink";
+        readonly ino: bigint;
+        readonly revision: bigint;
+        readonly lineage?: string;
+        readonly metadata: {
+            readonly uid: number;
+            readonly gid: number;
+            readonly mode: number;
+            readonly atimeNs: bigint;
+            readonly mtimeNs: bigint;
+            readonly ctimeNs: bigint;
+            readonly birthtimeNs: bigint;
+            readonly nlink: number;
+            readonly size: bigint;
+        };
+        readonly target: string & import("effect/Brand").Brand<"CanonicalBase64">;
+    })[];
+}, ImageError, never>;
+//# sourceMappingURL=liveImage.d.ts.map

package/dist/internal/liveImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveImage.d.ts","sourceRoot":"","sources":["../../src/internal/liveImage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAmB3C,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOjB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC,gBAAgB;AAChB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBnB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAgI3C,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAMjB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuBjB,CAAA"}

package/dist/internal/liveImage.js

@@ -0,0 +1,176 @@
+// Private, versioned image for a live volume. Unlike a public snapshot, this
+// retains inode numbers, revisions, allocator state, and open unlinked files.
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import { ImageError } from "../Snapshot.js";
+import { CanonicalBase64 } from "./canonicalBase64.js";
+import { StoredMetadata } from "./metadata.js";
+const NaturalBigInt = Schema.String.check(Schema.isPattern(/^(0|[1-9][0-9]{0,127})$/)).pipe(Schema.decodeTo(Schema.BigInt, SchemaTransformation.bigintFromString));
+const Common = {
+    ino: NaturalBigInt,
+    revision: NaturalBigInt,
+    lineage: Schema.optionalKey(Schema.String),
+    metadata: Schema.Struct({
+        ...StoredMetadata.fields,
+        nlink: Schema.Natural,
+        size: NaturalBigInt
+    })
+};
+/** @internal */
+export const Record = Schema.TaggedUnion({
+    directory: {
+        ...Common,
+        entries: Schema.Array(Schema.Struct({ name: CanonicalBase64.Encoded, target: NaturalBigInt }))
+    },
+    file: { ...Common, data: CanonicalBase64.Encoded },
+    symlink: { ...Common, target: CanonicalBase64.Encoded }
+});
+/** @internal */
+export const Document = Schema.Struct({
+    format: Schema.Literal("effect-vfs-live"),
+    version: Schema.Literal(1),
+    identity: Schema.String.check(Schema.isPattern(/^[0-9a-f]{32}$/)),
+    root: NaturalBigInt,
+    nextInode: NaturalBigInt,
+    revisionCounter: NaturalBigInt,
+    entries: Schema.Natural,
+    usedBytes: NaturalBigInt,
+    limits: Schema.Struct({
+        maxEntries: Schema.optionalKey(Schema.Natural),
+        maxBytes: Schema.optionalKey(NaturalBigInt),
+        maxFileBytes: Schema.optionalKey(NaturalBigInt),
+        maxPathBytes: Schema.optionalKey(NaturalBigInt)
+    }),
+    retainedFiles: Schema.Array(NaturalBigInt),
+    records: Schema.Array(Record)
+});
+const invalid = () => new ImageError({ code: "InvalidStructure", field: "liveImage" });
+const validate = Effect.fnUntraced(function* (document) {
+    const records = new Map();
+    for (const record of document.records) {
+        if (record.ino < 1n || records.has(record.ino) || record.revision < 1n ||
+            record.revision > document.revisionCounter || record.ino >= document.nextInode)
+            return yield* invalid();
+        records.set(record.ino, record);
+    }
+    const root = records.get(document.root);
+    if (document.root !== 1n || root?._tag !== "directory" || document.revisionCounter < 1n) {
+        return yield* invalid();
+    }
+    const links = new Map();
+    const pending = [[root, 1n]];
+    const seenDirectories = new Set();
+    const reachable = new Set();
+    let entries = 0;
+    for (let index = 0; index < pending.length; index++) {
+        const current = pending[index];
+        if (current === undefined)
+            return yield* invalid();
+        const [directory, pathBytes] = current;
+        if (seenDirectories.has(directory.ino))
+            return yield* invalid();
+        seenDirectories.add(directory.ino);
+        reachable.add(directory.ino);
+        const names = new Set();
+        for (const entry of directory.entries) {
+            if (names.has(entry.name) || entry.target === document.root)
+                return yield* invalid();
+            names.add(entry.name);
+            const name = yield* CanonicalBase64.decode(entry.name);
+            if (name.length < 1 || name.length > 255 || name.includes(0) || name.includes(47) ||
+                (name.length === 1 && name[0] === 46) ||
+                (name.length === 2 && name[0] === 46 && name[1] === 46))
+                return yield* invalid();
+            const childPathBytes = pathBytes + BigInt(name.length) + (pathBytes === 1n ? 0n : 1n);
+            if (document.limits.maxPathBytes !== undefined && childPathBytes > document.limits.maxPathBytes) {
+                return yield* invalid();
+            }
+            const target = records.get(entry.target);
+            if (target === undefined)
+                return yield* invalid();
+            entries++;
+            links.set(target.ino, (links.get(target.ino) ?? 0) + 1);
+            reachable.add(target.ino);
+            if (Record.guards.directory(target))
+                pending.push([target, childPathBytes]);
+        }
+    }
+    if (entries !== document.entries || links.has(root.ino))
+        return yield* invalid();
+    const retained = new Set(document.retainedFiles);
+    if (retained.size !== document.retainedFiles.length)
+        return yield* invalid();
+    let usedBytes = 0n;
+    for (const record of document.records) {
+        const actualLinks = links.get(record.ino) ?? 0;
+        if (Record.guards.directory(record)) {
+            const childDirectories = record.entries.filter((entry) => {
+                const child = records.get(entry.target);
+                return child !== undefined && Record.guards.directory(child);
+            }).length;
+            if (!seenDirectories.has(record.ino) || (record.ino !== root.ino && actualLinks !== 1) ||
+                record.metadata.nlink !== 2 + childDirectories || record.metadata.size !== 0n)
+                return yield* invalid();
+        }
+        else {
+            const payload = Record.guards.file(record) ? record.data : record.target;
+            const length = BigInt(CanonicalBase64.decodedLength(payload));
+            if (record.metadata.size !== length || record.metadata.nlink !== actualLinks)
+                return yield* invalid();
+            if (Record.guards.file(record)) {
+                if (document.limits.maxFileBytes !== undefined && length > document.limits.maxFileBytes) {
+                    return yield* invalid();
+                }
+                if (actualLinks === 0 && !retained.has(record.ino))
+                    return yield* invalid();
+                if (actualLinks > 0 && retained.has(record.ino))
+                    return yield* invalid();
+            }
+            else {
+                if (actualLinks === 0 || retained.has(record.ino) || (yield* CanonicalBase64.decode(record.target)).includes(0)) {
+                    return yield* invalid();
+                }
+            }
+            usedBytes += length;
+        }
+        if (!reachable.has(record.ino) && !retained.has(record.ino))
+            return yield* invalid();
+    }
+    if (document.limits.maxPathBytes !== undefined && document.limits.maxPathBytes < 1n)
+        return yield* invalid();
+    if (usedBytes !== document.usedBytes ||
+        (document.limits.maxEntries !== undefined && entries > document.limits.maxEntries) ||
+        (document.limits.maxBytes !== undefined && usedBytes > document.limits.maxBytes))
+        return yield* invalid();
+    for (const ino of retained) {
+        if (records.get(ino)?._tag !== "file" || reachable.has(ino))
+            return yield* invalid();
+    }
+    return document;
+});
+/** @internal */
+export const encode = Effect.fnUntraced(function* (document) {
+    const text = yield* Schema.encodeEffect(Schema.fromJsonString(Document))(yield* validate(document)).pipe(Effect.mapError(() => new ImageError({ code: "InvalidStructure", field: "liveImage" })));
+    return new TextEncoder().encode(text);
+});
+/** @internal */
+export const decode = Effect.fnUntraced(function* (bytes, maxEncodedBytes) {
+    if (!(bytes instanceof Uint8Array) || !(bytes.buffer instanceof ArrayBuffer)) {
+        return yield* new ImageError({ code: "InvalidEncoding", field: "liveImage" });
+    }
+    if (ByteSize.isGreaterThan(ByteSize.bytes(bytes.byteLength), maxEncodedBytes)) {
+        return yield* new ImageError({ code: "LimitExceeded", field: "encodedBytes" });
+    }
+    const text = yield* Effect.try({
+        try: () => new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(bytes)),
+        catch: () => new ImageError({ code: "InvalidEncoding", field: "liveImage" })
+    });
+    const parsed = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown))(text).pipe(Effect.mapError(() => new ImageError({ code: "InvalidEncoding", field: "liveImage" })));
+    const document = Schema.decodeUnknownResult(Document, { onExcessProperty: "error" })(parsed);
+    if (Result.isFailure(document))
+        return yield* new ImageError({ code: "InvalidStructure", field: "liveImage" });
+    return yield* validate(document.success);
+});

package/dist/internal/{virtualFileSystem/overlayContent.d.ts → overlayContent.d.ts}

@@ -1,5 +1,5 @@
-import type { Snapshot } from "../../Snapshot.js";
-import * as Image from "../image.js";
+import type { Snapshot } from "../Snapshot.js";
+import * as Image from "./image.js";
 /** @internal */
 export interface Content {
     readonly bytes: Uint8Array;

package/dist/internal/overlayContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayContent.d.ts","sourceRoot":"","sources":["../../src/internal/overlayContent.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC,gBAAgB;AAChB,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;CAC3B;AAID,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,aAAc,QAAQ,KAAG,OAAwC,CAAA;AAEhG,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,UAAU,KAAG,OAAsB,CAAA;AAE/D,gBAAgB;AAChB,eAAO,MAAM,KAAK,QAAO,OAAkC,CAAA;AAG3D,gBAAgB;AAChB,eAAO,MAAM,UAAU,aAAc,QAAQ,SAAS,KAAK,CAAC,QAAQ,KAAG,WAAW,CAAC,MAAM,EAAE,OAAO,CAiBjG,CAAA"}

package/dist/internal/{virtualFileSystem/overlayContent.js → overlayContent.js}

@@ -1,8 +1,8 @@
 // Immutable regular-file payloads shared by overlay workspaces.
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import { CanonicalBase64 } from "../canonicalBase64.js";
-import * as Image from "../image.js";
+import { CanonicalBase64 } from "./canonicalBase64.js";
+import * as Image from "./image.js";
 const overlayContents = new WeakMap();
 /** @internal */
 export const hasOverlayContents = (snapshot) => overlayContents.has(snapshot);

package/dist/internal/{virtualFileSystem/overlayDiff.d.ts → overlayDiff.d.ts}

@@ -1,4 +1,4 @@
-import type { StoredMetadata } from "../metadata.js";
+import type { StoredMetadata } from "./metadata.js";
 /** @internal */
 export interface ObservationEntry {
     readonly path: Uint8Array;

package/dist/internal/overlayDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayDiff.d.ts","sourceRoot":"","sources":["../../src/internal/overlayDiff.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEnD,gBAAgB;AAChB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAAA;IAC/C,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;CAClC;AAED,gBAAgB;AAChB,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAA;AAEtH,gBAAgB;AAChB,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CAAE,GAC9F;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CAAE,GAChG;IACA,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC7C,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC5C,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;CACvD,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IACvC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;CACvD,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IACvC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;CACvD,CAAA;AA4DH,gBAAgB;AAChB,eAAO,MAAM,cAAc,SACnB,aAAa,CAAC,gBAAgB,CAAC,WAC5B,aAAa,CAAC,gBAAgB,CAAC,kCAEvC,aAAa,CAAC,gBAAgB,CAgFhC,CAAA"}

package/dist/internal/{virtualFileSystem/overlayDiff.js → overlayDiff.js}

@@ -2,7 +2,7 @@ import * as Data from "effect/Data";
 import * as Encoding from "effect/Encoding";
 import * as Order from "effect/Order";
 import * as Predicate from "effect/Predicate";
-import { bytesOrder, sameBytes } from "../bytes.js";
+import { bytesOrder, sameBytes } from "./bytes.js";
 const RawOverlayChange = Data.taggedEnum();
 const timestampFields = new Set(["atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]);
 const differenceOrder = [

package/dist/internal/{virtualFileSystem/path.d.ts → path.d.ts}

@@ -1,8 +1,8 @@
 import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import * as Result from "effect/Result";
-import type { BytePath } from "../../BytePath.js";
-import type { PathInput } from "../../VirtualFileSystem.js";
+import type { BytePath } from "../BytePath.js";
+import type { PathInput } from "../VirtualFileSystem.js";
 import { FsError } from "./errors.js";
 /** @internal */
 export declare const SLASH_HEX = "2f";