@effect-vfs/core 0.5.0 → 0.6.0

package/dist/internal/fixture.js

@@ -1,31 +1,25 @@
-// Fixture image construction.
 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 { 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";
+import { Fixture as FixtureSchema, FixtureEntry } from "../Fixture.js";
+import { VolumeIdentity, VolumeOptions as VolumeOptionsSchema } from "../Volume.js";
+import { decodeConfiguration, imageFailure, OpContext, VfsError } from "./errors.js";
+import { inputBytes, isAttachedBytes, isDotComponent, preparePath } from "./path.js";
+import { makeVolume, VolumeSource } from "./virtualFileSystem.js";
+import { assemble, Ino, ROOT_INO } from "./volumeState.js";
 const DEFAULT_MODE = { directory: 0o755, file: 0o644, symlink: 0o777 };
 const EPOCH_NS = 0n;
 /** @internal */
 export const fromFixture = Effect.fn("VirtualFileSystem.fromFixture")(function* (fixture, options) {
-    const config = decodeConfiguration(VolumeOptionsSchema, options ?? {});
-    if (Result.isFailure(config))
-        return yield* config.failure;
-    const decoded = Schema.decodeResult(FixtureSchema, { onExcessProperty: "error" })(fixture);
-    if (Result.isFailure(decoded))
-        return yield* new ImageError({ code: "InvalidStructure", field: "fixture" });
-    const source = decoded.success;
+    const config = yield* Effect.fromResult(decodeConfiguration(VolumeOptionsSchema, options ?? {}, "fromFixture"));
+    const source = yield* Schema.decodeEffect(FixtureSchema, { onExcessProperty: "error" })(fixture).pipe(Effect.mapError((cause) => imageFailure("fromFixture", "InvalidStructure", { field: "fixture", cause })));
     if (source.entries.some((entry) => FixtureEntry.match(entry, {
         directory: () => false,
         file: ({ bytes }) => !isAttachedBytes(bytes),
         symlink: () => false,
         hardLink: () => false
     }))) {
-        return yield* new ImageError({ code: "InvalidEncoding", field: "bytes" });
+        return yield* imageFailure("fromFixture", "InvalidEncoding", { field: "bytes" });
     }
     const metadata = (kind, overrides) => ({
         uid: overrides?.uid ?? 0,
@@ -36,70 +30,53 @@ export const fromFixture = Effect.fn("VirtualFileSystem.fromFixture")(function*
         ctimeNs: overrides?.ctimeNs ?? EPOCH_NS,
         birthtimeNs: overrides?.birthtimeNs ?? EPOCH_NS
     });
+    // Assign inode numbers in declaration order, before resolving hard links.
     const declarations = new Map();
     const aliases = new Map();
     const paths = new Map();
-    const root = Image.Record.cases.directory.make({
-        id: "root",
-        metadata: metadata("directory", source.rootMetadata),
-        entries: []
-    });
-    declarations.set("", root);
-    const fixturePath = (input) => preparePath(input, "fixture", config.success.maxPathBytes).pipe(Result.flatMap((path) => !path.absolute || path.components.length === 0 ||
+    let nextInode = ROOT_INO;
+    const declare = (declared) => {
+        nextInode = Ino(nextInode + 1);
+        return { ...declared, ino: nextInode };
+    };
+    declarations.set("", { kind: "directory", ino: ROOT_INO, metadata: metadata("directory", source.rootMetadata) });
+    const op = OpContext.make("fixture");
+    const fixturePath = (input) => preparePath(input, op.operation, config.maxPathBytes).pipe(Result.flatMap((path) => !path.absolute || path.components.length === 0 ||
         path.components.some(isDotComponent)
-        ? Result.fail(new FsError({ code: "InvalidArgument", operation: "fixture", path: input })) :
+        ? Result.fail(op.at(input).fail("InvalidArgument")) :
         Result.succeed(path.components)));
-    // Encode caller-owned byte buffers now: nothing below yields until Image.capture, so a caller
-    // cannot mutate them first.
+    // Copy caller-owned bytes before storing them.
     for (const entry of source.entries) {
-        const parsed = fixturePath(entry.path);
-        if (Result.isFailure(parsed)) {
-            return yield* new ImageError({ code: "InvalidStructure", field: "path" });
-        }
-        const components = parsed.success;
+        const components = yield* Effect.fromResult(fixturePath(entry.path)).pipe(Effect.mapError((cause) => imageFailure("fromFixture", "InvalidStructure", { field: "path", cause })));
         const key = components.join("/");
         if (paths.has(key))
-            return yield* new ImageError({ code: "InvalidStructure", field: "duplicate" });
+            return yield* imageFailure("fromFixture", "InvalidStructure", { field: "duplicate" });
         paths.set(key, components);
         const error = FixtureEntry.match(entry, {
             hardLink: ({ target }) => {
                 const parsedTarget = fixturePath(target);
-                if (Result.isFailure(parsedTarget))
-                    return new ImageError({ code: "InvalidStructure", field: "target" });
+                if (Result.isFailure(parsedTarget)) {
+                    return imageFailure("fromFixture", "InvalidStructure", { field: "target", cause: parsedTarget.failure });
+                }
                 aliases.set(key, parsedTarget.success.join("/"));
             },
             directory: (entry) => {
-                declarations.set(key, Image.Record.cases.directory.make({
-                    id: String(paths.size),
-                    metadata: metadata("directory", entry.metadata),
-                    entries: []
-                }));
+                declarations.set(key, declare({ kind: "directory", metadata: metadata("directory", entry.metadata) }));
             },
             file: (entry) => {
-                declarations.set(key, Image.Record.cases.file.make({
-                    id: String(paths.size),
-                    metadata: metadata("file", entry.metadata),
-                    data: CanonicalBase64.encode(entry.bytes)
-                }));
+                declarations.set(key, declare({ kind: "file", metadata: metadata("file", entry.metadata), payload: entry.bytes.slice() }));
             },
             symlink: ({ metadata: overrides, target: input }) => {
                 const target = inputBytes(input);
                 if (Result.isFailure(target)) {
-                    return new ImageError({
-                        code: target.failure === "InvalidPathEncoding" ? "InvalidEncoding" : "InvalidStructure",
-                        field: "target"
-                    });
+                    return imageFailure("fromFixture", target.failure === "InvalidPathEncoding" ? "InvalidEncoding" : "InvalidStructure", { field: "target" });
                 }
                 if (target.success.includes(0))
-                    return new ImageError({ code: "InvalidStructure", field: "target" });
-                declarations.set(key, Image.Record.cases.symlink.make({
-                    id: String(paths.size),
-                    metadata: metadata("symlink", overrides),
-                    target: CanonicalBase64.encode(target.success)
-                }));
+                    return imageFailure("fromFixture", "InvalidStructure", { field: "target" });
+                declarations.set(key, declare({ kind: "symlink", metadata: metadata("symlink", overrides), payload: target.success.slice() }));
             }
         });
-        if (error instanceof ImageError)
+        if (Schema.is(VfsError)(error))
             return yield* error;
     }
     for (const [key] of aliases) {
@@ -107,44 +84,50 @@ export const fromFixture = Effect.fn("VirtualFileSystem.fromFixture")(function*
         const seen = new Set();
         while (!declarations.has(target)) {
             if (seen.has(target))
-                return yield* new ImageError({ code: "InvalidStructure", field: "hardLink" });
+                return yield* imageFailure("fromFixture", "InvalidStructure", { field: "hardLink" });
             seen.add(target);
             const next = aliases.get(target);
             if (next === undefined)
-                return yield* new ImageError({ code: "InvalidStructure", field: "hardLink" });
+                return yield* imageFailure("fromFixture", "InvalidStructure", { field: "hardLink" });
             target = next;
         }
         const node = declarations.get(target);
-        if (node === undefined || Image.Record.guards.directory(node)) {
-            return yield* new ImageError({ code: "InvalidStructure", field: "hardLink" });
+        if (node === undefined || node.kind === "directory") {
+            return yield* imageFailure("fromFixture", "InvalidStructure", { field: "hardLink" });
         }
         for (const alias of seen)
             declarations.set(alias, node);
     }
-    const children = new Map();
+    const names = new Map();
     for (const [key, components] of paths) {
         const parent = declarations.get(components.slice(0, -1).join("/"));
         const child = declarations.get(key);
         const name = components.at(-1);
-        if (parent?._tag !== "directory" || child === undefined || name === undefined) {
-            return yield* new ImageError({ code: "InvalidStructure", field: "parent" });
+        if (parent?.kind !== "directory" || child === undefined || name === undefined) {
+            return yield* imageFailure("fromFixture", "InvalidStructure", { field: "parent" });
         }
-        const entries = children.get(parent.id) ?? [];
-        entries.push({ name: CanonicalBase64.encode(nameBytes(name)), target: child.id });
-        children.set(parent.id, entries);
+        names.set(child, [...(names.get(child) ?? []), { parent: parent.ino, name }]);
     }
-    const records = [...new Set(declarations.values())].map((record) => Image.Record.match(record, {
-        directory: (record) => ({ ...record, entries: children.get(record.id) ?? [] }),
-        file: (record) => record,
-        symlink: (record) => record
-    }));
-    const snapshot = yield* Image.capture({ format: "effect-vfs", version: 1, root: "root", records }, undefined, true);
-    const image = yield* Image.inspect(snapshot);
-    const { identity, ...volumeOptions } = config.success;
+    const specs = [...new Set(declarations.values())].map((declared) => {
+        const links = names.get(declared) ?? [];
+        const common = { ino: declared.ino, metadata: declared.metadata, revision: 1n };
+        if (declared.kind === "directory") {
+            // The root has no path; directories cannot have hard links.
+            const [link = { parent: ROOT_INO, name: "" }] = links;
+            return { ...common, kind: "directory", parent: link.parent, name: link.name };
+        }
+        const payload = declared.payload ?? new Uint8Array();
+        return declared.kind === "file"
+            ? { ...common, kind: "file", links, data: payload }
+            : { ...common, kind: "symlink", links, target: payload };
+    });
+    const restored = VolumeSource.Restored({ value: assemble(specs) });
+    const { identity, ...volumeOptions } = config;
     if (identity === undefined)
-        return yield* makeVolume(VolumeSource.Snapshot({ image }), volumeOptions);
-    return yield* makeVolume(VolumeSource.Snapshot({ image }), {
+        return (yield* makeVolume(restored, volumeOptions)).volume;
+    const { volume } = yield* makeVolume(restored, {
         ...volumeOptions,
         identity: VolumeIdentity.make(identity)
     });
+    return volume;
 });

package/dist/internal/hex128.d.ts

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+/** @internal */
+export declare const Hex128: Schema.String;
+/** @internal */
+export declare const VolumeEpoch: Schema.brand<Schema.String, "@effect-vfs/core/VolumeEpoch">;
+/** @internal */
+export type VolumeEpoch = typeof VolumeEpoch.Type;
+/** @internal */
+export declare const KeySecret: Schema.brand<Schema.String, "@effect-vfs/core/KeySecret">;
+/** @internal */
+export type KeySecret = typeof KeySecret.Type;
+//# sourceMappingURL=hex128.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hex128.d.ts","sourceRoot":"","sources":["../../src/internal/hex128.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,gBAAgB;AAChB,eAAO,MAAM,MAAM,eAA0D,CAAA;AAE7E,gBAAgB;AAChB,eAAO,MAAM,WAAW,6DAA4D,CAAA;AAEpF,gBAAgB;AAChB,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD,gBAAgB;AAChB,eAAO,MAAM,SAAS,2DAA0D,CAAA;AAEhF,gBAAgB;AAChB,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA"}

package/dist/internal/hex128.js

@@ -0,0 +1,7 @@
+import * as Schema from "effect/Schema";
+/** @internal */
+export const Hex128 = Schema.String.check(Schema.isPattern(/^[0-9a-f]{32}$/));
+/** @internal */
+export const VolumeEpoch = Hex128.pipe(Schema.brand("@effect-vfs/core/VolumeEpoch"));
+/** @internal */
+export const KeySecret = Hex128.pipe(Schema.brand("@effect-vfs/core/KeySecret"));

package/dist/internal/hmac.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const hmacSha256: (key: Uint8Array, message: Uint8Array) => Uint8Array;
+/** @internal */
+export declare const sameTag: (left: Uint8Array, right: Uint8Array) => boolean;
+//# sourceMappingURL=hmac.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["../../src/internal/hmac.ts"],"names":[],"mappings":"AAqJA,gBAAgB;AAChB,eAAO,MAAM,UAAU,QAAS,UAAU,WAAW,UAAU,KAAG,UAOjE,CAAA;AAGD,gBAAgB;AAChB,eAAO,MAAM,OAAO,SAAU,UAAU,SAAS,UAAU,KAAG,OAQ7D,CAAA"}

package/dist/internal/hmac.js

@@ -0,0 +1,150 @@
+// Synchronous HMAC keeps reference-key methods free of Crypto service requirements.
+const BLOCK_BYTES = 64;
+const ROUND_CONSTANTS = new Uint32Array([
+    0x428a2f98,
+    0x71374491,
+    0xb5c0fbcf,
+    0xe9b5dba5,
+    0x3956c25b,
+    0x59f111f1,
+    0x923f82a4,
+    0xab1c5ed5,
+    0xd807aa98,
+    0x12835b01,
+    0x243185be,
+    0x550c7dc3,
+    0x72be5d74,
+    0x80deb1fe,
+    0x9bdc06a7,
+    0xc19bf174,
+    0xe49b69c1,
+    0xefbe4786,
+    0x0fc19dc6,
+    0x240ca1cc,
+    0x2de92c6f,
+    0x4a7484aa,
+    0x5cb0a9dc,
+    0x76f988da,
+    0x983e5152,
+    0xa831c66d,
+    0xb00327c8,
+    0xbf597fc7,
+    0xc6e00bf3,
+    0xd5a79147,
+    0x06ca6351,
+    0x14292967,
+    0x27b70a85,
+    0x2e1b2138,
+    0x4d2c6dfc,
+    0x53380d13,
+    0x650a7354,
+    0x766a0abb,
+    0x81c2c92e,
+    0x92722c85,
+    0xa2bfe8a1,
+    0xa81a664b,
+    0xc24b8b70,
+    0xc76c51a3,
+    0xd192e819,
+    0xd6990624,
+    0xf40e3585,
+    0x106aa070,
+    0x19a4c116,
+    0x1e376c08,
+    0x2748774c,
+    0x34b0bcb5,
+    0x391c0cb3,
+    0x4ed8aa4a,
+    0x5b9cca4f,
+    0x682e6ff3,
+    0x748f82ee,
+    0x78a5636f,
+    0x84c87814,
+    0x8cc70208,
+    0x90befffa,
+    0xa4506ceb,
+    0xbef9a3f7,
+    0xc67178f2
+]);
+const INITIAL_STATE = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+const rotr = (value, bits) => (value >>> bits) | (value << (32 - bits));
+const sha256 = (message) => {
+    const padded = new Uint8Array(Math.ceil((message.length + 9) / BLOCK_BYTES) * BLOCK_BYTES);
+    padded.set(message);
+    padded[message.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setBigUint64(padded.length - 8, BigInt(message.length) * 8n);
+    const state = Int32Array.from(INITIAL_STATE);
+    const schedule = new Uint32Array(64);
+    for (let block = 0; block < padded.length; block += BLOCK_BYTES) {
+        for (let t = 0; t < 16; t++)
+            schedule[t] = view.getUint32(block + t * 4);
+        for (let t = 16; t < 64; t++) {
+            const w15 = schedule[t - 15];
+            const w2 = schedule[t - 2];
+            const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ (w15 >>> 3);
+            const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ (w2 >>> 10);
+            schedule[t] = (schedule[t - 16] + s0 + schedule[t - 7] + s1) | 0;
+        }
+        let a = state[0];
+        let b = state[1];
+        let c = state[2];
+        let d = state[3];
+        let e = state[4];
+        let f = state[5];
+        let g = state[6];
+        let h = state[7];
+        for (let t = 0; t < 64; t++) {
+            const t1 = (h + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + ROUND_CONSTANTS[t]
+                + schedule[t]) | 0;
+            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        state.set([
+            state[0] + a,
+            state[1] + b,
+            state[2] + c,
+            state[3] + d,
+            state[4] + e,
+            state[5] + f,
+            state[6] + g,
+            state[7] + h
+        ]);
+    }
+    const digest = new Uint8Array(32);
+    const out = new DataView(digest.buffer);
+    for (let word = 0; word < 8; word++)
+        out.setUint32(word * 4, state[word]);
+    return digest;
+};
+const concat = (left, right) => {
+    const joined = new Uint8Array(left.length + right.length);
+    joined.set(left);
+    joined.set(right, left.length);
+    return joined;
+};
+/** @internal */
+export const hmacSha256 = (key, message) => {
+    const block = new Uint8Array(BLOCK_BYTES);
+    block.set(key.length > BLOCK_BYTES ? sha256(key) : key);
+    const inner = block.map((byte) => byte ^ 0x36);
+    const outer = block.map((byte) => byte ^ 0x5c);
+    return sha256(concat(outer, sha256(concat(inner, message))));
+};
+// Compare every byte regardless of the first difference to avoid leaking a matching prefix.
+/** @internal */
+export const sameTag = (left, right) => {
+    if (left.length !== right.length)
+        return false;
+    let difference = 0;
+    for (let index = 0; index < left.length; index++)
+        difference |= left[index] ^ right[index];
+    return difference === 0;
+};

package/dist/internal/image.d.ts

@@ -1,125 +1,22 @@
-import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { ImageError, type Snapshot } from "../Snapshot.js";
-import { StoredMetadata } from "./metadata.js";
+import type * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import type { FixtureEntry } from "../Fixture.js";
+import { type Snapshot } from "../Snapshot.js";
+import type { FsFailure, ImageFailure } from "../VfsError.js";
+import type { PathInput } from "../VirtualFileSystem.js";
+import type { Budget } from "./budget.js";
+import { type VolumeState } from "./volumeState.js";
 /** @internal */
-export { StoredMetadata };
+export declare const make: (value: VolumeState) => Snapshot;
 /** @internal */
-export declare const Record: Schema.TaggedUnion<{
-    readonly directory: Schema.TaggedStruct<"directory", {
-        readonly id: 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 entries: Schema.$Array<Schema.Struct<{
-            readonly name: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
-            readonly target: Schema.String;
-        }>>;
-    }>;
-    readonly file: Schema.TaggedStruct<"file", {
-        readonly id: 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 data: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
-    }>;
-    readonly symlink: Schema.TaggedStruct<"symlink", {
-        readonly id: 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 target: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
-    }>;
-}>;
+export declare const valueOf: (snapshot: Snapshot) => Effect.Effect<VolumeState, ImageFailure>;
 /** @internal */
-export type Record = typeof Record.Type;
+export declare const encodeSnapshotStream: (snapshot: Snapshot, budget?: Budget) => Stream.Stream<Uint8Array, ImageFailure>;
 /** @internal */
-export declare const Document: Schema.Struct<{
-    readonly format: Schema.Literal<"effect-vfs">;
-    readonly version: Schema.Literal<1>;
-    readonly root: Schema.String;
-    readonly records: Schema.$Array<Schema.TaggedUnion<{
-        readonly directory: Schema.TaggedStruct<"directory", {
-            readonly id: 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 entries: Schema.$Array<Schema.Struct<{
-                readonly name: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
-                readonly target: Schema.String;
-            }>>;
-        }>;
-        readonly file: Schema.TaggedStruct<"file", {
-            readonly id: 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 data: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
-        }>;
-        readonly symlink: Schema.TaggedStruct<"symlink", {
-            readonly id: 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 target: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
-        }>;
-    }>>;
-}>;
+export declare const encodeSnapshot: (snapshot: Snapshot, budget?: Budget) => Effect.Effect<Uint8Array, ImageFailure>;
 /** @internal */
-export type Document = typeof Document.Type;
+export declare const decodeSnapshotSink: (budget: Budget) => Sink.Sink<Snapshot, Uint8Array, never, ImageFailure>;
 /** @internal */
-export declare const inspect: (snapshot: Snapshot) => Effect.Effect<Document, ImageError>;
-/** @internal */
-export declare const capture: (input: unknown, limits?: {
-    readonly maxEncodedBytes: ByteSize.ByteSize;
-    readonly maxRecords: number;
-    readonly maxEntries: number;
-    readonly maxDecodedBytes: ByteSize.ByteSize;
-} | undefined, trusted?: any) => Effect.Effect<Snapshot, ImageError, never>;
-/** @internal */
-export declare const encodeSnapshot: (snapshot: Snapshot) => Effect.Effect<Uint8Array<ArrayBuffer>, ImageError, never>;
-/** @internal */
-export declare const decodeSnapshot: (input: Uint8Array<ArrayBufferLike>, limits: {
-    readonly maxEncodedBytes: ByteSize.ByteSize;
-    readonly maxRecords: number;
-    readonly maxEntries: number;
-    readonly maxDecodedBytes: ByteSize.ByteSize;
-}) => Effect.Effect<Snapshot, ImageError, never>;
+export declare const snapshotEntries: (snapshot: Snapshot, root: PathInput) => Stream.Stream<FixtureEntry, FsFailure | ImageFailure>;
 //# sourceMappingURL=image.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/internal/image.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAgB,UAAU,EAAE,KAAK,QAAQ,EAAkB,MAAM,gBAAgB,CAAA;AAExF,OAAO,EAAE,cAAc,EAAsB,MAAM,eAAe,CAAA;AAMlE,gBAAgB;AAChB,OAAO,EAAE,cAAc,EAAE,CAAA;AAIzB,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC,gBAAgB;AAChB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnB,CAAA;AAwBF,gBAAgB;AAChB,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAI3C,gBAAgB;AAChB,eAAO,MAAM,OAAO,aAAc,QAAQ,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAO3E,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,OAAO;;;;;2EAiJlB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc,mFAMzB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;gDA+B1B,CAAA"}
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/internal/image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,EAAE,KAAK,QAAQ,EAAkB,MAAM,gBAAgB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAezC,OAAO,EAQL,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAA;AAgBzB,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,WAAW,KAAG,QAAkD,CAAA;AAE5F,gBAAgB;AAChB,eAAO,MAAM,OAAO,aAAc,QAAQ,KAAG,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,YAAY,CAOhF,CAAA;AAOJ,gBAAgB;AAChB,eAAO,MAAM,oBAAoB,aACrB,QAAQ,WACT,MAAM,KACd,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY,CAapC,CAAA;AAEL,gBAAgB;AAChB,eAAO,MAAM,cAAc,aAAc,QAAQ,WAAW,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY,CACpD,CAAA;AAEvD,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,WAAY,MAAM,KAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,CAYtG,CAAA;AA0GD,gBAAgB;AAChB,eAAO,MAAM,eAAe,aAChB,QAAQ,QACZ,SAAS,KACd,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,GAAG,YAAY,CAOlD,CAAA"}