@effect-vfs/core 0.3.0 → 0.4.0

package/dist/internal/image.js

@@ -1,37 +1,28 @@
 // Snapshot validation and serialization used by VirtualFileSystem.
 import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
-import * as Encoding from "effect/Encoding";
+import * as Match from "effect/Match";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import { DecodeLimits, ImageError, SnapshotTypeId } from "../Snapshot.js";
-import * as CanonicalBase64 from "./canonicalBase64.js";
+import { CanonicalBase64 } from "./canonicalBase64.js";
+import { StoredMetadata, WireStoredMetadata } from "./metadata.js";
 class SnapshotImpl {
     [SnapshotTypeId] = SnapshotTypeId;
 }
-const integer = Schema.String.check(Schema.isPattern(/^(?:0|-?[1-9][0-9]{0,127})(?![\s\S])/));
 /** @internal */
-export const StoredMetadata = Schema.Struct({
-    uid: Schema.Natural,
-    gid: Schema.Natural,
-    mode: Schema.Natural.check(Schema.isLessThanOrEqualTo(0o7777)),
-    atimeNs: integer,
-    mtimeNs: integer,
-    ctimeNs: integer,
-    birthtimeNs: integer
-});
+export { StoredMetadata };
 const id = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(128));
 /** @internal */
-export const Record = Schema.Union([
-    Schema.Struct({
+export const Record = Schema.TaggedUnion({
+    directory: {
         id,
-        kind: Schema.Literal("directory"),
         metadata: StoredMetadata,
-        entries: Schema.Array(Schema.Struct({ name: Schema.String, target: id }))
-    }),
-    Schema.Struct({ id, kind: Schema.Literal("file"), metadata: StoredMetadata, data: Schema.String }),
-    Schema.Struct({ id, kind: Schema.Literal("symlink"), metadata: StoredMetadata, target: Schema.String })
-]);
+        entries: Schema.Array(Schema.Struct({ name: CanonicalBase64.Encoded, target: id }))
+    },
+    file: { id, metadata: StoredMetadata, data: CanonicalBase64.Encoded },
+    symlink: { id, metadata: StoredMetadata, target: CanonicalBase64.Encoded }
+});
 /** @internal */
 export const Document = Schema.Struct({
     format: Schema.Literal("effect-vfs"),
@@ -39,97 +30,111 @@ export const Document = Schema.Struct({
     root: id,
     records: Schema.Array(Record)
 });
+const WireRecord = Schema.TaggedUnion({
+    directory: {
+        id,
+        metadata: WireStoredMetadata,
+        entries: Schema.Array(Schema.Struct({ name: Schema.String, target: id }))
+    },
+    file: { id, metadata: WireStoredMetadata, data: Schema.String },
+    symlink: { id, metadata: WireStoredMetadata, target: Schema.String }
+});
+const WireDocument = Schema.Struct({
+    format: Schema.Literal("effect-vfs"),
+    version: Schema.Literal(1),
+    root: id,
+    records: Schema.Array(WireRecord)
+});
+const VersionProbe = Schema.Struct({
+    format: Schema.Literal("effect-vfs"),
+    version: Schema.Unknown
+});
 const snapshots = new WeakMap();
 /** @internal */
-export const decodedLength = CanonicalBase64.decodedLength;
-/** @internal */
-export const base64 = (input) => {
-    // Effect's encoder concatenates individual characters. Join bounded chunks so snapshots
-    // retain flat strings instead of those intermediate string chains. A multiple of three
-    // keeps padding in the final chunk only, preserving canonical base64.
-    const chunkBytes = 12_288;
-    const chunks = [];
-    for (let offset = 0; offset < input.length; offset += chunkBytes) {
-        chunks.push(Encoding.encodeBase64(input.subarray(offset, offset + chunkBytes)));
-    }
-    return chunks.join("");
-};
-const error = (code, field) => new ImageError({ code, ...(field === undefined ? {} : { field }) });
-/** @internal */
-export const bytes = (value) => {
-    return CanonicalBase64.decodeTrusted(value);
-};
-/** @internal */
 export const inspect = (snapshot) => Effect.suspend(() => {
     const document = snapshots.get(snapshot);
-    return document === undefined ? Effect.fail(error("InvalidStructure", "snapshot")) : Effect.succeed(document);
+    return document === undefined
+        ? new ImageError({ code: "InvalidStructure", field: "snapshot" })
+        : Effect.succeed(document);
 });
 /** @internal */
-export const capture = Effect.fnUntraced(function* (input, limits) {
-    const decoded = Schema.decodeUnknownResult(Document, { onExcessProperty: "error" })(input);
-    if (Result.isFailure(decoded))
-        return yield* error("InvalidStructure");
-    const document = decoded.success;
+export const capture = Effect.fnUntraced(function* (input, limits, trusted = false) {
+    const wire = trusted ? undefined : Schema.decodeUnknownResult(WireDocument, { onExcessProperty: "error" })(input);
+    if (wire !== undefined && Result.isFailure(wire)) {
+        return yield* new ImageError({ code: "InvalidStructure", field: "document" });
+    }
+    const decoded = trusted ? undefined : Schema.decodeUnknownResult(Document, { onExcessProperty: "error" })(input);
+    if (decoded !== undefined && Result.isFailure(decoded)) {
+        return yield* new ImageError({ code: "InvalidEncoding", field: "document" });
+    }
+    // SAFETY: a trusted caller passes a Document it built; an untrusted one has just been decoded.
+    const document = decoded === undefined ? input : decoded.success;
     const records = new Map();
     let entries = 0;
     let payload = ByteSize.zero;
     if (limits !== undefined && document.records.length > limits.maxRecords) {
-        return yield* error("LimitExceeded", "records");
+        return yield* new ImageError({ code: "LimitExceeded", field: "records" });
     }
     for (const record of document.records) {
         if (records.has(record.id))
-            return yield* error("InvalidStructure", "id");
+            return yield* new ImageError({ code: "InvalidStructure", field: "id" });
         records.set(record.id, record);
-        if (record.kind === "directory")
+        Match.value(record).pipe(Match.tag("directory", (record) => {
             entries += record.entries.length;
+        }), Match.undefined);
     }
-    if (limits !== undefined && entries > limits.maxEntries)
-        return yield* error("LimitExceeded", "entries");
-    // Count every payload before allocating any decoded payload buffer.
-    for (const record of document.records) {
-        const values = record.kind === "directory"
-            ? record.entries.map((entry) => entry.name)
-            : [record.kind === "file" ? record.data : record.target];
-        for (const value of values) {
-            if (!CanonicalBase64.isCanonical(value))
-                return yield* error("InvalidEncoding", record.id);
-            payload = ByteSize.sum(payload, ByteSize.bytes(decodedLength(value)));
-            if (limits !== undefined && ByteSize.isGreaterThan(payload, limits.maxDecodedBytes)) {
-                return yield* error("LimitExceeded", "bytes");
+    if (limits !== undefined && entries > limits.maxEntries) {
+        return yield* new ImageError({ code: "LimitExceeded", field: "entries" });
+    }
+    // Count every payload before allocating any decoded payload buffer. Trusted records carry
+    // base64 this module produced, so the scan only runs when a limit depends on the tally.
+    if (!trusted || limits !== undefined) {
+        for (const record of document.records) {
+            const values = Match.value(record).pipe(Match.tag("directory", (record) => record.entries.map((entry) => entry.name)), Match.tag("file", (record) => [record.data]), Match.tag("symlink", (record) => [record.target]), Match.exhaustive);
+            for (const value of values) {
+                if (!CanonicalBase64.is(value)) {
+                    return yield* new ImageError({ code: "InvalidEncoding", field: record.id });
+                }
+                payload = ByteSize.sum(payload, ByteSize.bytes(CanonicalBase64.decodedLength(value)));
+                if (limits !== undefined && ByteSize.isGreaterThan(payload, limits.maxDecodedBytes)) {
+                    return yield* new ImageError({ code: "LimitExceeded", field: "bytes" });
+                }
             }
         }
     }
     const root = records.get(document.root);
-    if (root?.kind !== "directory")
-        return yield* error("InvalidStructure", "root");
+    if (root === undefined || !Record.guards.directory(root)) {
+        return yield* new ImageError({ code: "InvalidStructure", field: "root" });
+    }
     const parents = new Map();
     for (const record of document.records) {
-        if (record.kind === "directory") {
+        if (Record.guards.directory(record)) {
             const names = new Set();
             for (const entry of record.entries) {
-                if (names.has(entry.name) || decodedLength(entry.name) < 1 || decodedLength(entry.name) > 255) {
-                    return yield* error("InvalidStructure", "name");
-                }
+                if (names.has(entry.name) || CanonicalBase64.decodedLength(entry.name) < 1 ||
+                    CanonicalBase64.decodedLength(entry.name) > 255)
+                    return yield* new ImageError({ code: "InvalidStructure", field: "name" });
                 names.add(entry.name);
-                const name = bytes(entry.name);
+                const name = yield* CanonicalBase64.decode(entry.name);
                 if (name.includes(0) || name.includes(47) || (name.length === 1 && name[0] === 46) ||
                     (name.length === 2 && name[0] === 46 && name[1] === 46))
-                    return yield* error("InvalidStructure", "name");
+                    return yield* new ImageError({ code: "InvalidStructure", field: "name" });
                 const target = records.get(entry.target);
                 if (target === undefined)
-                    return yield* error("InvalidStructure", "target");
+                    return yield* new ImageError({ code: "InvalidStructure", field: "target" });
                 parents.set(target.id, (parents.get(target.id) ?? 0) + 1);
             }
         }
-        else if (record.kind === "symlink" && bytes(record.target).includes(0)) {
-            return yield* error("InvalidStructure", "symlink");
+        else if (Record.guards.symlink(record) && (yield* CanonicalBase64.decode(record.target)).includes(0)) {
+            return yield* new ImageError({ code: "InvalidStructure", field: "symlink" });
         }
     }
     if (parents.has(root.id))
-        return yield* error("InvalidStructure", "root");
+        return yield* new ImageError({ code: "InvalidStructure", field: "root" });
     for (const record of document.records) {
-        if (record !== root && (record.kind === "directory" ? parents.get(record.id) !== 1 : !parents.has(record.id))) {
-            return yield* error("InvalidStructure", "parent");
+        const invalidParent = Match.value(record).pipe(Match.tag("directory", (record) => parents.get(record.id) !== 1), Match.tag("file", (record) => !parents.has(record.id)), Match.tag("symlink", (record) => !parents.has(record.id)), Match.exhaustive);
+        if (record !== root && invalidParent) {
+            return yield* new ImageError({ code: "InvalidStructure", field: "parent" });
         }
     }
     const visited = new Set();
@@ -140,39 +145,43 @@ export const capture = Effect.fnUntraced(function* (input, limits) {
             continue;
         visited.add(next);
         const record = records.get(next);
-        if (record?.kind === "directory") {
-            for (const entry of record.entries)
-                pending.push(entry.target);
+        if (record !== undefined) {
+            Match.value(record).pipe(Match.tag("directory", (record) => {
+                for (const entry of record.entries)
+                    pending.push(entry.target);
+            }), Match.tag("file", () => undefined), Match.tag("symlink", () => undefined), Match.exhaustive);
         }
     }
     if (visited.size !== records.size)
-        return yield* error("InvalidStructure", "reachability");
+        return yield* new ImageError({ code: "InvalidStructure", field: "reachability" });
     const snapshot = Object.freeze(new SnapshotImpl());
     snapshots.set(snapshot, document);
     return snapshot;
 });
 /** @internal */
 export const encodeSnapshot = Effect.fn("VirtualFileSystem.encodeSnapshot")(function* (snapshot) {
-    const text = yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown))(yield* inspect(snapshot)).pipe(Effect.mapError(() => error("InvalidStructure")));
+    const text = yield* Schema.encodeEffect(Schema.fromJsonString(Document))(yield* inspect(snapshot)).pipe(Effect.mapError(() => new ImageError({ code: "InvalidStructure", field: "text" })));
     return new TextEncoder().encode(text);
 });
 /** @internal */
 export const decodeSnapshot = Effect.fn("VirtualFileSystem.decodeSnapshot")(function* (input, limits) {
     const checked = Schema.decodeResult(DecodeLimits, { onExcessProperty: "error" })(limits);
     if (Result.isFailure(checked))
-        return yield* error("InvalidStructure", "limits");
-    if (!(input instanceof Uint8Array) || !(input.buffer instanceof ArrayBuffer))
-        return yield* error("InvalidEncoding");
+        return yield* new ImageError({ code: "InvalidStructure", field: "limits" });
+    if (!(input instanceof Uint8Array) || !(input.buffer instanceof ArrayBuffer)) {
+        return yield* new ImageError({ code: "InvalidEncoding", field: "input" });
+    }
     if (ByteSize.isGreaterThan(ByteSize.bytes(input.byteLength), checked.success.maxEncodedBytes)) {
-        return yield* error("LimitExceeded", "encodedBytes");
+        return yield* new ImageError({ code: "LimitExceeded", field: "encodedBytes" });
     }
     const text = yield* Effect.try({
         try: () => new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(input)),
-        catch: () => error("InvalidEncoding")
+        catch: () => new ImageError({ code: "InvalidEncoding", field: "text" })
     });
-    const value = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown))(text).pipe(Effect.mapError(() => error("InvalidEncoding")));
-    if (typeof value === "object" && value !== null && "format" in value && value.format === "effect-vfs" &&
-        "version" in value && value.version !== 1)
-        return yield* error("UnsupportedVersion");
+    const value = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown))(text).pipe(Effect.mapError(() => new ImageError({ code: "InvalidEncoding", field: "text" })));
+    const version = Schema.decodeUnknownResult(VersionProbe)(value);
+    if (Result.isSuccess(version) && version.success.version !== 1) {
+        return yield* new ImageError({ code: "UnsupportedVersion", field: "version" });
+    }
     return yield* capture(value, checked.success);
 });

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"}