@effect-vfs/core 0.7.0 → 0.8.0

package/dist/internal/canonicalBase64.js

@@ -1,4 +1,4 @@
-import * as Encoding from "effect/Encoding";
+import * as Base64 from "effect/encoding/Base64";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import { ENCODING_CHECK } from "./errors.js";
@@ -12,7 +12,7 @@ const encode = (input) => {
     const chunkBytes = 12_288;
     const chunks = [];
     for (let offset = 0; offset < input.length; offset += chunkBytes) {
-        chunks.push(Encoding.encodeBase64(input.subarray(offset, offset + chunkBytes)));
+        chunks.push(Base64.encode(input.subarray(offset, offset + chunkBytes)));
     }
     return Encoded.make(chunks.join(""));
 };
@@ -23,7 +23,7 @@ const Encoded = Schema.String.pipe(Schema.refine((value) => isCanonical(value),
 /** @internal */
 export const CanonicalBase64 = {
     Encoded,
-    toBytes: (input) => Result.getOrThrow(Encoding.decodeBase64(input)),
+    toBytes: (input) => Result.getOrThrow(Base64.decode(input)),
     encode: (input) => encode(input),
     decodedLength: (value) => decodedLength(value)
 };

package/dist/internal/fixture.js

@@ -5,7 +5,7 @@ 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 { makeVolume, memoryCommitProvider, 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;
@@ -124,8 +124,8 @@ export const fromFixture = Effect.fn("VirtualFileSystem.fromFixture")(function*
     const restored = VolumeSource.Restored({ value: assemble(specs) });
     const { identity, ...volumeOptions } = config;
     if (identity === undefined)
-        return (yield* makeVolume(restored, volumeOptions)).volume;
-    const { volume } = yield* makeVolume(restored, {
+        return (yield* makeVolume(restored, memoryCommitProvider, volumeOptions)).volume;
+    const { volume } = yield* makeVolume(restored, memoryCommitProvider, {
         ...volumeOptions,
         identity: VolumeIdentity.make(identity)
     });

package/dist/internal/glob.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Compiles bounded Unicode namespace globs and meters scalar matching work.
+ *
+ * @internal
+ * @since 0.1.0
+ */
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import { BudgetExceeded, type Meter, QueryFailure } from "./searchModel.js";
+type Atom = {
+    readonly low: number;
+    readonly high: number;
+};
+type Token = {
+    readonly tag: "literal";
+    readonly value: string;
+} | {
+    readonly tag: "star";
+} | {
+    readonly tag: "any";
+} | {
+    readonly tag: "class";
+    readonly atoms: ReadonlyArray<Atom>;
+    readonly negate: boolean;
+};
+type Segment = ReadonlyArray<Token> | "**";
+interface Pattern {
+    readonly segments: ReadonlyArray<Segment>;
+    readonly directory: boolean;
+}
+/** @internal */
+export interface CompiledSelectors {
+    readonly include: ReadonlyArray<Pattern>;
+    readonly exclude: ReadonlyArray<Pattern>;
+}
+/** @internal */
+export declare const compile: (selectors: {
+    readonly include: ReadonlyArray<string>;
+    readonly exclude?: ReadonlyArray<string>;
+}, limits: {
+    readonly maxEntries: number;
+    readonly maxDepth: number;
+    readonly maxPathBytes: ByteSize.ByteSize;
+    readonly maxResults: number;
+    readonly maxResultBytes: ByteSize.ByteSize;
+    readonly maxPatternBytes: ByteSize.ByteSize;
+    readonly maxPatterns: number;
+    readonly maxPatternListBytes: ByteSize.ByteSize;
+    readonly maxExpansions: number;
+    readonly maxTokens: number;
+    readonly maxMatchingWork: number;
+    readonly maxScannedBytes: ByteSize.ByteSize;
+    readonly maxFileBytes: ByteSize.ByteSize;
+    readonly maxLineEvaluations: number;
+    readonly maxExcerptBytes: ByteSize.ByteSize;
+}) => Effect.Effect<{
+    include: Pattern[];
+    exclude: Pattern[];
+}, QueryFailure, never>;
+/** @internal */
+export declare const matches: (compiled: CompiledSelectors, parts: readonly string[], kind: "directory" | "file" | "symlink", meter: Meter) => Effect.Effect<{
+    excluded: boolean;
+    included: boolean;
+}, BudgetExceeded, never>;
+export {};
+//# sourceMappingURL=glob.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../src/internal/glob.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,cAAc,EAA0B,KAAK,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEnG,KAAK,IAAI,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3D,KAAK,KAAK,GACN;IAAE,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACxB;IAAE,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAA;CAAE,GACvB;IAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAAA;AAE5F,KAAK,OAAO,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,IAAI,CAAA;AAE1C,UAAU,OAAO;IACf,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;IACzC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED,gBAAgB;AAChB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;IACxC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;CACzC;AAED,gBAAgB;AAChB,eAAO,MAAM,OAAO;sBACa,aAAa,CAAC,MAAM,CAAC;uBAAqB,aAAa,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;uBAqM9F,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,OAAO;;;yBAoFnB,CAAA"}

package/dist/internal/glob.js

@@ -0,0 +1,248 @@
+/**
+ * Compiles bounded Unicode namespace globs and meters scalar matching work.
+ *
+ * @internal
+ * @since 0.1.0
+ */
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import { BudgetExceeded, QueryFailure } from "./searchModel.js";
+/** @internal */
+export const compile = Effect.fnUntraced(function* (selectors, limits) {
+    const fail = (pattern, message, limit) => limit === undefined
+        ? new QueryFailure({ field: "patterns", pattern, message })
+        : new QueryFailure({ field: "patterns", pattern, message, limit });
+    if (selectors.include.length === 0)
+        return yield* fail("", "At least one include pattern is required");
+    if (selectors.include.length + (selectors.exclude?.length ?? 0) > limits.maxPatterns) {
+        return yield* fail("", "Too many patterns", "maxPatterns");
+    }
+    const sources = [...selectors.include, ...selectors.exclude ?? []];
+    let bytes = 0n;
+    let expansions = 0;
+    let tokens = 0;
+    let steps = 0;
+    const include = [];
+    const exclude = [];
+    for (let sourceIndex = 0; sourceIndex < sources.length; sourceIndex++) {
+        const source = sources[sourceIndex];
+        // Count scalar UTF-8 bytes before allocating expanded patterns.
+        let sourceBytes = 0n;
+        for (const scalar of source) {
+            const point = scalar.codePointAt(0);
+            if (point === 0 || point >= 0xd800 && point <= 0xdfff) {
+                return yield* fail(source, "Patterns require Unicode scalar values without NUL");
+            }
+            sourceBytes += BigInt(point <= 0x7f ? 1 : point <= 0x7ff ? 2 : point <= 0xffff ? 3 : 4);
+            if (sourceBytes > ByteSize.toBigInt(limits.maxPatternBytes)) {
+                return yield* fail(source, "Pattern byte limit exceeded", "maxPatternBytes");
+            }
+            if (++steps % 128 === 0)
+                yield* Effect.yieldNow;
+        }
+        bytes += sourceBytes;
+        if (bytes > ByteSize.toBigInt(limits.maxPatternListBytes)) {
+            return yield* fail(source, "Pattern list byte limit exceeded", "maxPatternListBytes");
+        }
+        const pending = [source];
+        const expanded = [];
+        while (pending.length > 0) {
+            const value = pending.pop();
+            const stack = [];
+            let choice;
+            let inClass = false;
+            for (let i = 0; i < value.length; i++) {
+                const char = value[i];
+                if (++steps % 128 === 0)
+                    yield* Effect.yieldNow;
+                if (char === "\\") {
+                    i++;
+                    continue;
+                }
+                if (char === "[")
+                    inClass = true;
+                if (char === "]")
+                    inClass = false;
+                if (inClass)
+                    continue;
+                if (char === "{")
+                    stack.push({ start: i, commas: [] });
+                else if (char === "," && stack.length > 0)
+                    stack[stack.length - 1].commas.push(i);
+                else if (char === "}") {
+                    const open = stack.pop();
+                    if (open === undefined)
+                        return yield* fail(source, "Unmatched closing brace");
+                    // Expand outer choices first so nested braces cannot duplicate sibling alternatives.
+                    if (open.commas.length > 0 && (choice === undefined || open.start < choice.start)) {
+                        choice = { ...open, end: i };
+                    }
+                }
+            }
+            if (stack.length > 0)
+                return yield* fail(source, "Unclosed brace");
+            if (choice === undefined) {
+                if (++expansions > limits.maxExpansions)
+                    return yield* fail(source, "Expansion limit exceeded", "maxExpansions");
+                expanded.push(value);
+            }
+            else {
+                const boundaries = [choice.start, ...choice.commas, choice.end];
+                if (expansions + pending.length + boundaries.length - 1 > limits.maxExpansions) {
+                    return yield* fail(source, "Expansion limit exceeded", "maxExpansions");
+                }
+                for (let i = boundaries.length - 2; i >= 0; i--) {
+                    pending.push(value.slice(0, choice.start) + value.slice(boundaries[i] + 1, boundaries[i + 1]) +
+                        value.slice(choice.end + 1));
+                }
+            }
+        }
+        for (const value of expanded) {
+            const directory = value.endsWith("/");
+            const pieces = (directory ? value.slice(0, -1) : value).split("/");
+            const segments = [];
+            for (const piece of pieces) {
+                if (piece === "" || piece === "." || piece === "..") {
+                    return yield* fail(source, "Empty, absolute and dot segments are unsupported");
+                }
+                if (piece === "**") {
+                    if (++tokens > limits.maxTokens)
+                        return yield* fail(source, "Token limit exceeded", "maxTokens");
+                    segments.push("**");
+                    continue;
+                }
+                const scalars = Array.from(piece);
+                const segment = [];
+                for (let i = 0; i < scalars.length; i++) {
+                    const scalar = scalars[i];
+                    if (++tokens > limits.maxTokens)
+                        return yield* fail(source, "Token limit exceeded", "maxTokens");
+                    if (scalar === "\\") {
+                        const next = scalars[++i];
+                        if (next === undefined)
+                            return yield* fail(source, "Dangling escape");
+                        segment.push({ tag: "literal", value: next });
+                    }
+                    else if (scalar === "*") {
+                        if (scalars[i + 1] === "*")
+                            return yield* fail(source, "Globstar must occupy a whole segment");
+                        segment.push({ tag: "star" });
+                    }
+                    else if (scalar === "?")
+                        segment.push({ tag: "any" });
+                    else if (scalar === "[") {
+                        const negate = scalars[i + 1] === "!";
+                        if (negate)
+                            i++;
+                        const atoms = [];
+                        const read = () => {
+                            let char = scalars[++i];
+                            if (char === "\\")
+                                char = scalars[++i];
+                            return char?.codePointAt(0);
+                        };
+                        while (scalars[i + 1] !== "]") {
+                            const low = read();
+                            if (low === undefined)
+                                return yield* fail(source, "Unclosed character class");
+                            let high = low;
+                            if (scalars[i + 1] === "-" && scalars[i + 2] !== "]") {
+                                i++;
+                                const end = read();
+                                if (end === undefined || end < low)
+                                    return yield* fail(source, "Invalid character range");
+                                high = end;
+                            }
+                            if (++tokens > limits.maxTokens)
+                                return yield* fail(source, "Token limit exceeded", "maxTokens");
+                            atoms.push({ low, high });
+                            if (++steps % 128 === 0)
+                                yield* Effect.yieldNow;
+                        }
+                        i++;
+                        if (atoms.length === 0)
+                            return yield* fail(source, "Empty character class");
+                        segment.push({ tag: "class", atoms, negate });
+                    }
+                    else
+                        segment.push({ tag: "literal", value: scalar });
+                    if (++steps % 128 === 0)
+                        yield* Effect.yieldNow;
+                }
+                segments.push(segment);
+            }
+            ;
+            (sourceIndex < selectors.include.length ? include : exclude).push({ segments, directory });
+        }
+    }
+    return { include, exclude };
+});
+/** @internal */
+export const matches = Effect.fnUntraced(function* (compiled, parts, kind, meter) {
+    const path = parts.join("/");
+    const tick = Effect.fnUntraced(function* () {
+        if (meter.work.matchingWork >= meter.limits.maxMatchingWork) {
+            return yield* new BudgetExceeded({ limit: "maxMatchingWork", path });
+        }
+        meter.work.matchingWork++;
+        if (meter.work.matchingWork % 128 === 0)
+            yield* Effect.yieldNow;
+    });
+    const segmentMatches = Effect.fnUntraced(function* (tokens, text) {
+        const scalars = Array.from(text);
+        let previous = [true, ...scalars.map(() => false)];
+        for (const token of tokens) {
+            const next = scalars.map(() => false);
+            next.push(false);
+            for (let i = 0; i <= scalars.length; i++) {
+                yield* tick();
+                if (token.tag === "star")
+                    next[i] = previous[i] || i > 0 && next[i - 1];
+                else if (i > 0 && previous[i - 1]) {
+                    if (token.tag === "any")
+                        next[i] = true;
+                    else if (token.tag === "literal")
+                        next[i] = token.value === scalars[i - 1];
+                    else {
+                        const point = scalars[i - 1].codePointAt(0);
+                        let found = false;
+                        for (const atom of token.atoms) {
+                            yield* tick();
+                            if (point >= atom.low && point <= atom.high) {
+                                found = true;
+                                break;
+                            }
+                        }
+                        next[i] = token.negate ? !found : found;
+                    }
+                }
+            }
+            previous = next;
+        }
+        return previous[scalars.length];
+    });
+    const any = Effect.fnUntraced(function* (patterns) {
+        for (const pattern of patterns) {
+            yield* tick();
+            if (pattern.directory && kind !== "directory")
+                continue;
+            let previous = [true, ...parts.map(() => false)];
+            for (const segment of pattern.segments) {
+                const next = parts.map(() => false);
+                next.push(false);
+                for (let i = 0; i <= parts.length; i++) {
+                    yield* tick();
+                    next[i] = segment === "**"
+                        ? previous[i] || i > 0 && next[i - 1]
+                        : i > 0 && previous[i - 1] && (yield* segmentMatches(segment, parts[i - 1]));
+                }
+                previous = next;
+            }
+            if (previous[parts.length])
+                return true;
+        }
+        return false;
+    });
+    const excluded = yield* any(compiled.exclude);
+    return { excluded, included: excluded ? false : yield* any(compiled.include) };
+});

package/dist/internal/image.d.ts

@@ -1,4 +1,5 @@
 import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
 import type * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import type { FixtureEntry } from "../Fixture.js";
@@ -6,7 +7,7 @@ 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";
+import { type Node, type VolumeState } from "./volumeState.js";
 /** @internal */
 export declare const make: (value: VolumeState) => Snapshot;
 /** @internal */
@@ -18,5 +19,10 @@ export declare const encodeSnapshot: (snapshot: Snapshot, budget?: Budget) => Ef
 /** @internal */
 export declare const decodeSnapshotSink: (budget: Budget) => Sink.Sink<Snapshot, Uint8Array, never, ImageFailure>;
 /** @internal */
+export declare const resolve: (value: VolumeState, input: PathInput, options: {
+    readonly operation: string;
+    readonly followFinalSymlink: boolean;
+}) => Result.Result<Node, FsFailure>;
+/** @internal */
 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":"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"}
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/internal/image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,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,EAKL,KAAK,IAAI,EAGT,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;AAOD,gBAAgB;AAChB,eAAO,MAAM,OAAO,UACX,WAAW,SACX,SAAS,WACP;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAA;CAAE,KAC5E,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAmD/B,CAAA;AAmDD,gBAAgB;AAChB,eAAO,MAAM,eAAe,aAChB,QAAQ,QACZ,SAAS,KACd,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,GAAG,YAAY,CAOlD,CAAA"}

package/dist/internal/image.js

@@ -64,10 +64,11 @@ export const decodeSnapshotSink = (budget) => {
 };
 const OPERATION = "snapshotEntries";
 const encoder = new TextEncoder();
-// Match privileged lookup: follow intermediate links, honor trailing slashes, and leave the final link intact.
-const resolve = (value, input) => {
-    const fail = (code) => Result.fail(fsFailure(code, OPERATION, { path: input }));
-    const prepared = preparePath(input, OPERATION, undefined);
+// Privileged immutable lookup follows intermediate links and honors trailing slashes.
+/** @internal */
+export const resolve = (value, input, options) => {
+    const fail = (code) => Result.fail(fsFailure(code, options.operation, { path: input }));
+    const prepared = preparePath(input, options.operation, undefined);
     if (Result.isFailure(prepared))
         return Result.fail(prepared.failure);
     const root = getNode(value, ROOT_INO);
@@ -88,7 +89,8 @@ const resolve = (value, input) => {
         const child = ino === undefined ? undefined : getNode(value, ino);
         if (child === undefined)
             return fail("NotFound");
-        if (child.kind !== "symlink" || (index === work.components.length - 1 && !work.trailingSlash)) {
+        if (child.kind !== "symlink" ||
+            (index === work.components.length - 1 && !work.trailingSlash && !options.followFinalSymlink)) {
             current = child;
             continue;
         }
@@ -100,7 +102,7 @@ const resolve = (value, input) => {
         const expansion = new Uint8Array(child.target.length + suffix.length);
         expansion.set(child.target);
         expansion.set(suffix, child.target.length);
-        const expanded = preparePath(ownedPath(expansion), OPERATION, undefined);
+        const expanded = preparePath(ownedPath(expansion), options.operation, undefined);
         if (Result.isFailure(expanded))
             return fail(expanded.failure.code);
         work = expanded.success;
@@ -151,7 +153,7 @@ function* walk(value, node) {
 /** @internal */
 export const snapshotEntries = (snapshot, root) => Stream.unwrap(Effect.gen(function* () {
     const value = yield* valueOf(snapshot);
-    const node = yield* Effect.fromResult(resolve(value, root));
+    const node = yield* Effect.fromResult(resolve(value, root, { operation: OPERATION, followFinalSymlink: false }));
     // Bound each pulled chunk to one file's copied bytes.
     return Stream.fromIterable({ [Symbol.iterator]: () => walk(value, node) }, { chunkSize: 1 });
 }));

package/dist/internal/liveImage.d.ts

@@ -1,4 +1,4 @@
-import * as ByteSize from "effect/ByteSize";
+import type * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import type { VolumeLimits } from "../VirtualFileSystem.js";
 import type { VolumeIdentity } from "../Volume.js";

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"liveImage.d.ts","sourceRoot":"","sources":["../../src/internal/liveImage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAChD,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;AAEjC,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,wJAgCjB,CAAA;AAWF,gBAAgB;AAChB,eAAO,MAAM,MAAM,UAAW,UAAU,mBAAmB,QAAQ,CAAC,QAAQ,0EAyBzE,CAAA"}

package/dist/internal/liveImage.js

@@ -1,11 +1,10 @@
-// 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 Stream from "effect/Stream";
 import * as Lines from "./lines.js";
 import * as Tree from "./tree.js";
+import * as Limits from "./volumeLimits.js";
 import { assemble, getNode, Ino } from "./volumeState.js";
 const OPERATION = "openImage";
 const DOCUMENT_FIELD = "liveImage";
@@ -25,14 +24,7 @@ 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 stored = Limits.toStored(limits);
     const header = yield* Effect.fromResult(headerText({
         format: "effect-vfs-live",
         version: 1,

package/dist/internal/overlayDiff.js

@@ -1,6 +1,6 @@
 import * as Arr from "effect/Array";
 import * as Data from "effect/Data";
-import * as Encoding from "effect/Encoding";
+import * as Hex from "effect/encoding/Hex";
 import * as Order from "effect/Order";
 import * as Predicate from "effect/Predicate";
 import { bytesOrder, sameBytes } from "./bytes.js";
@@ -23,7 +23,7 @@ const tagOrder = {
     Renamed: 3,
     Updated: 4
 };
-const key = Encoding.encodeHex;
+const key = Hex.encode;
 const sourcePath = (change) => Predicate.isTagged("Renamed")(change) ? change.from : change.path;
 const changeOrder = Order.combine(Order.mapInput(bytesOrder, sourcePath), Order.mapInput(Order.Number, (change) => tagOrder[change._tag]));
 const differences = (before, after, includeTimestamps) => Object.freeze(differenceOrder.filter((field) => {

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

@@ -1 +1 @@
-{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/internal/path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAIxD,gBAAgB;AAChB,eAAO,MAAM,SAAS,OAAO,CAAA;AAC7B,gBAAgB;AAChB,eAAO,MAAM,OAAO,OAAO,CAAA;AAC3B,gBAAgB;AAChB,eAAO,MAAM,WAAW,SAAS,CAAA;AACjC,gBAAgB;AAChB,eAAO,MAAM,UAAU,KAAK,CAAA;AAE5B,gBAAgB;AAChB,eAAO,MAAM,QAAQ,IAAI,CAAA;AACzB,gBAAgB;AAChB,eAAO,MAAM,sBAAsB,KAAK,CAAA;AACxC,gBAAgB;AAChB,eAAO,MAAM,cAAc,MAAM,CAAA;AAEjC,gBAAgB;AAChB,eAAO,MAAM,WAAW,SAAU,UAAU,KAAG,OAEuE,CAAA;AAEtH,gBAAgB;AAChB,eAAO,MAAM,SAAS,yBAA+B,CAAA;AAErD,gBAAgB;AAChB,eAAO,MAAM,QAAQ,WAAY,UAAU,QAAQ,UAAU,KAAG,UAS/D,CAAA;AAGD,gBAAgB;AAChB,eAAO,MAAM,cAAc,SAAU,MAAM,GAAG,SAAS,KAAG,IAAI,IAAI,SAAS,GAAG,OAAO,OAAO,GAAG,OAAO,WACtC,CAAA;AAEhE,gBAAgB;AAChB,eAAO,MAAM,SAAS,UAAW,UAAU,KAAG,QAA+B,CAAA;AAE7E,gBAAgB;AAChB,eAAO,MAAM,YAAY,UAAW,UAAU,aAAa,MAAM,4CAI7D,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,MAAM,KAAG,UAAyD,CAAA;AAelG,gBAAgB;AAChB,eAAO,MAAM,eAAe,UAAW,UAAU,KAAG,OAC2C,CAAA;AAE/F,gBAAgB;AAChB,eAAO,MAAM,aAAa,mFASxB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,WAAW,8EAMtB,CAAA;AAEF,gBAAgB;AAChB,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IAC5C,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAC3C;AAGD,gBAAgB;AAChB,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,OAY5C,CAAA;AAID,gBAAgB;AAChB,eAAO,MAAM,UAAU,UAAW,SAAS,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,qBAAqB,GAAG,iBAAiB,CAG5B,CAAA;AAErF,gBAAgB;AAChB,eAAO,MAAM,WAAW,UACf,SAAS,aACL,MAAM,gBACH,QAAQ,CAAC,QAAQ,GAAG,SAAS,KAC1C,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,CAgDvC,CAAA"}
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/internal/path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAIxD,gBAAgB;AAChB,eAAO,MAAM,SAAS,OAAO,CAAA;AAC7B,gBAAgB;AAChB,eAAO,MAAM,OAAO,OAAO,CAAA;AAC3B,gBAAgB;AAChB,eAAO,MAAM,WAAW,SAAS,CAAA;AACjC,gBAAgB;AAChB,eAAO,MAAM,UAAU,KAAK,CAAA;AAE5B,gBAAgB;AAChB,eAAO,MAAM,QAAQ,IAAI,CAAA;AACzB,gBAAgB;AAChB,eAAO,MAAM,sBAAsB,KAAK,CAAA;AACxC,gBAAgB;AAChB,eAAO,MAAM,cAAc,MAAM,CAAA;AAEjC,gBAAgB;AAChB,eAAO,MAAM,WAAW,SAAU,UAAU,KAAG,OAEuE,CAAA;AAEtH,gBAAgB;AAChB,eAAO,MAAM,SAAS,yBAA+B,CAAA;AAErD,gBAAgB;AAChB,eAAO,MAAM,QAAQ,WAAY,UAAU,QAAQ,UAAU,KAAG,UAS/D,CAAA;AAGD,gBAAgB;AAChB,eAAO,MAAM,cAAc,SAAU,MAAM,GAAG,SAAS,KAAG,IAAI,IAAI,SAAS,GAAG,OAAO,OAAO,GAAG,OAAO,WACtC,CAAA;AAEhE,gBAAgB;AAChB,eAAO,MAAM,SAAS,UAAW,UAAU,KAAG,QAA+B,CAAA;AAE7E,gBAAgB;AAChB,eAAO,MAAM,YAAY,UAAW,UAAU,aAAa,MAAM,4CAI7D,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,MAAM,KAAG,UAAiD,CAAA;AAe1F,gBAAgB;AAChB,eAAO,MAAM,eAAe,UAAW,UAAU,KAAG,OAC2C,CAAA;AAE/F,gBAAgB;AAChB,eAAO,MAAM,aAAa,mFASxB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,WAAW,8EAMtB,CAAA;AAEF,gBAAgB;AAChB,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IAC5C,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAC3C;AAGD,gBAAgB;AAChB,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,OAY5C,CAAA;AAID,gBAAgB;AAChB,eAAO,MAAM,UAAU,UAAW,SAAS,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,qBAAqB,GAAG,iBAAiB,CAG5B,CAAA;AAErF,gBAAgB;AAChB,eAAO,MAAM,WAAW,UACf,SAAS,aACL,MAAM,gBACH,QAAQ,CAAC,QAAQ,GAAG,SAAS,KAC1C,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,CAgDvC,CAAA"}

package/dist/internal/path.js

@@ -1,6 +1,6 @@
 import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
-import * as Encoding from "effect/Encoding";
+import * as Hex from "effect/encoding/Hex";
 import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import { getBytes as getBytePathBytes, make as makeBytePath } from "./bytePath.js";
@@ -46,7 +46,7 @@ export const strictString = (bytes, operation) => Effect.try({
     catch: () => fsFailure("UnrepresentableName", operation)
 });
 /** @internal */
-export const nameBytes = (name) => Result.getOrThrow(Encoding.decodeHex(name));
+export const nameBytes = (name) => Result.getOrThrow(Hex.decode(name));
 // Constructing a view detects detached buffers, including empty ones.
 const attachedBuffer = (bytes) => {
     try {
@@ -125,7 +125,7 @@ export const preparePath = (input, operation, maxPathBytes) => {
             if (index - start > MAX_NAME_BYTES) {
                 return Result.fail(fsFailure("PathTooLong", operation, { path: input }));
             }
-            components.push(Encoding.encodeHex(bytes.subarray(start, index)));
+            components.push(Hex.encode(bytes.subarray(start, index)));
             suffixes.push(bytes.subarray(index));
         }
         start = index + 1;