@effect-vfs/core 0.4.0 → 0.6.0

package/dist/internal/liveImage.d.ts

@@ -1,286 +1,27 @@
 import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { ImageError } from "../Snapshot.js";
+import type { VolumeLimits } from "../VirtualFileSystem.js";
+import type { VolumeIdentity } from "../Volume.js";
+import type { KeySecret, VolumeEpoch } from "./hex128.js";
+import * as Tree from "./tree.js";
+import { type RegularFile, type VolumeState } from "./volumeState.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">;
-    }>;
-}>;
+export declare const retainedFiles: (state: VolumeState) => Array<RegularFile>;
+type StoredLimits = Tree.Runtime["limits"];
 /** @internal */
-export type Record = typeof Record.Type;
+export interface Naming {
+    readonly identity: VolumeIdentity;
+    readonly epoch: VolumeEpoch;
+    readonly keySecret: KeySecret;
+}
 /** @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">;
-        }>;
-    }>>;
-}>;
+export interface Restored extends Naming {
+    readonly value: VolumeState;
+    readonly limits: StoredLimits;
+}
 /** @internal */
-export type Document = typeof Document.Type;
+export declare const encode: (state: VolumeState, args_1: Naming, limits: VolumeLimits) => Effect.Effect<Uint8Array<ArrayBufferLike>, import("../VfsError.js").ImageFailure, never>;
 /** @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>;
+export declare const decode: (bytes: Uint8Array, maxEncodedBytes: ByteSize.ByteSize) => Effect.Effect<Restored, import("../VfsError.js").ImageFailure, never>;
+export {};
 //# sourceMappingURL=liveImage.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"liveImage.d.ts","sourceRoot":"","sources":["../../src/internal/liveImage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAEzD,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,EAAqC,KAAK,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAKxG,gBAAgB;AAChB,eAAO,MAAM,aAAa,UAAW,WAAW,KAAG,KAAK,CAAC,WAAW,CAUnE,CAAA;AAED,KAAK,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;AAE1C,gBAAgB;AAChB,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;CAC9B;AAED,gBAAgB;AAChB,MAAM,WAAW,QAAS,SAAQ,MAAM;IACtC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;IAC3B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;CAC9B;AAQD,gBAAgB;AAChB,eAAO,MAAM,MAAM,wJAwCjB,CAAA;AAWF,gBAAgB;AAChB,eAAO,MAAM,MAAM,UAAW,UAAU,mBAAmB,QAAQ,CAAC,QAAQ,0EAyBzE,CAAA"}

package/dist/internal/liveImage.js

@@ -1,176 +1,85 @@
-// Private, versioned image for a live volume. Unlike a public snapshot, this
-// retains inode numbers, revisions, allocator state, and open unlinked files.
+// Live images persist runtime identity and revisions along with the tree, including unlinked open 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 }
-});
+import * as Stream from "effect/Stream";
+import * as Lines from "./lines.js";
+import * as Tree from "./tree.js";
+import { assemble, getNode, Ino } from "./volumeState.js";
+const OPERATION = "openImage";
+const DOCUMENT_FIELD = "liveImage";
 /** @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();
+export const retainedFiles = (state) => {
+    const retained = [];
+    for (const ino of state.open.keys()) {
+        const node = getNode(state, ino);
+        if (node?.kind === "file" && node.links.length === 0)
+            retained.push(node);
     }
-    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;
+    return retained;
+};
+const headerText = Schema.encodeResult(Schema.fromJsonString(Tree.LiveHeader));
+const nodeText = Schema.encodeResult(Schema.fromJsonString(Tree.LiveTreeNode));
+const liveNode = (node) => ({ ...Tree.treeNode(node), rev: node.revision });
+/** @internal */
+export const encode = Effect.fnUntraced(function* (state, { epoch, identity, keySecret }, limits) {
+    const nodes = yield* Tree.treeNodes(state, retainedFiles(state));
+    const stored = {};
+    if (limits.maxEntries !== undefined)
+        stored.maxEntries = limits.maxEntries;
+    if (limits.maxBytes !== undefined)
+        stored.maxBytes = ByteSize.toBigInt(limits.maxBytes);
+    stored.maxFileBytes = ByteSize.toBigInt(limits.maxFileBytes);
+    if (limits.maxPathBytes !== undefined)
+        stored.maxPathBytes = ByteSize.toBigInt(limits.maxPathBytes);
+    const header = yield* Effect.fromResult(headerText({
+        format: "effect-vfs-live",
+        version: 1,
+        runtime: {
+            identity,
+            epoch,
+            keySecret,
+            nextInode: state.nextInode,
+            revision: state.revision,
+            limits: stored,
+            usage: { entries: state.entries, usedBytes: state.usedBytes }
         }
-        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;
+    })).pipe(Effect.mapError((cause) => Tree.encodeFailure(OPERATION, DOCUMENT_FIELD, cause)));
+    return yield* Lines.collect(Tree.writeTree({
+        operation: OPERATION,
+        documentField: DOCUMENT_FIELD,
+        header,
+        node: liveNode,
+        text: nodeText,
+        meter: undefined
+    }, nodes));
 });
-/** @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);
+// The store's byte bound covers this whole image; no separate decode budget is needed.
+const imageBudget = (maxEncodedBytes) => ({
+    encodedBytes: maxEncodedBytes,
+    lineBytes: maxEncodedBytes,
+    decodedBytes: maxEncodedBytes,
+    records: Number.MAX_SAFE_INTEGER,
+    entries: Number.MAX_SAFE_INTEGER
 });
 /** @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);
-});
+export const decode = (bytes, maxEncodedBytes) => Stream.run(Stream.succeed(bytes), Lines.sink({ operation: OPERATION, inputField: DOCUMENT_FIELD, textField: DOCUMENT_FIELD }, () => {
+    const reader = Tree.liveReader({ operation: OPERATION, documentField: DOCUMENT_FIELD });
+    return {
+        meter: Tree.meter(imageBudget(maxEncodedBytes), OPERATION),
+        fold: {
+            line: reader.line,
+            end: () => Result.map(reader.end(), ({ header: { runtime }, specs }) => {
+                const value = assemble(specs);
+                return {
+                    value: { ...value, nextInode: Ino(runtime.nextInode), revision: runtime.revision },
+                    identity: runtime.identity,
+                    epoch: runtime.epoch,
+                    keySecret: runtime.keySecret,
+                    limits: runtime.limits
+                };
+            })
+        }
+    };
+}));

package/dist/internal/merkle.d.ts

@@ -0,0 +1,45 @@
+import * as ByteSize from "effect/ByteSize";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type * as PlatformError from "effect/PlatformError";
+import type { ImageFailure } from "../VfsError.js";
+import { type Ino, type Node, type VolumeState } from "./volumeState.js";
+/** @internal */
+export declare const DIGEST_BYTES = 32;
+/** @internal */
+export interface WalkBudget {
+    readonly operation: string;
+    readonly records: number;
+    readonly recordsField: string;
+    readonly entries: number;
+    readonly identityBytes: ByteSize.ByteSize;
+    readonly payloadBytes?: {
+        readonly limit: ByteSize.ByteSize;
+        readonly field: string;
+    };
+}
+/** @internal */
+export interface Identity {
+    readonly digest: Uint8Array;
+    readonly digests: ReadonlyMap<Ino, Uint8Array>;
+    readonly groups: ReadonlyMap<Ino, ReadonlyArray<Uint8Array>>;
+    readonly records: number;
+    readonly payloadBytes: number;
+    readonly nodeBytes: number;
+}
+/** @internal */
+export declare const nodeBytes: (node: Node) => number;
+/** @internal */
+export interface Meter {
+    readonly charge: (bytes: number) => Effect.Effect<void, ImageFailure>;
+    readonly spent: () => number;
+}
+/** @internal */
+export declare const meter: (budget: WalkBudget) => Meter;
+/** @internal */
+export declare const nodeDigest: (node: Node, childDigest: (ino: Ino) => Uint8Array, meter: Meter) => Effect.Effect<Uint8Array<ArrayBufferLike>, PlatformError.PlatformError | ImageFailure, Crypto.Crypto>;
+/** @internal */
+export declare const identityDigest: (root: Uint8Array<ArrayBufferLike>, groups: Iterable<readonly Uint8Array<ArrayBufferLike>[]>, meter: Meter) => Effect.Effect<Uint8Array<ArrayBufferLike>, PlatformError.PlatformError | ImageFailure, Crypto.Crypto>;
+/** @internal */
+export declare const identify: (state: VolumeState, budget: WalkBudget) => Effect.Effect<Identity, PlatformError.PlatformError | ImageFailure, Crypto.Crypto>;
+//# sourceMappingURL=merkle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merkle.d.ts","sourceRoot":"","sources":["../../src/internal/merkle.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,aAAa,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAIlD,OAAO,EAAwB,KAAK,GAAG,EAAE,KAAK,IAAI,EAAuB,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnH,gBAAgB;AAChB,eAAO,MAAM,YAAY,KAAK,CAAA;AAQ9B,gBAAgB;AAChB,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,QAAQ,CAAA;IAEzC,QAAQ,CAAC,YAAY,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,QAAQ,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CACtF;AAED,gBAAgB;AAChB,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,GAAG,EAAE,UAAU,CAAC,CAAA;IAC9C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC,CAAA;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AA4CD,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,IAAI,KAAG,MAA6B,CAAA;AAyBpE,gBAAgB;AAChB,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;IACrE,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAA;CAC7B;AAED,gBAAgB;AAChB,eAAO,MAAM,KAAK,WAAY,UAAU,KAAG,KAc1C,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,UAAU,kCAA8D,GAAG,KAAK,UAAU,wHAOrG,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc,sNAsB1B,CAAA;AAGD,gBAAgB;AAChB,eAAO,MAAM,QAAQ,gIAmGpB,CAAA"}