@effect-vfs/core 0.7.1 → 0.9.0

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/path.js

@@ -63,7 +63,7 @@ const attachedBuffer = (bytes) => {
 /** @internal */
 export const isAttachedBytes = (bytes) => Predicate.isUint8Array(bytes) && bytes.buffer instanceof ArrayBuffer && attachedBuffer(bytes);
 /** @internal */
-export const pathFromBytes = Effect.fn("VirtualFileSystem.pathFromBytes")(function* (bytes) {
+export const pathFromBytes = Effect.fnUntraced(function* (bytes) {
     if (!isAttachedBytes(bytes))
         return yield* fsFailure("InvalidArgument", "pathFromBytes");
     const owned = new Uint8Array(bytes);
@@ -73,7 +73,7 @@ export const pathFromBytes = Effect.fn("VirtualFileSystem.pathFromBytes")(functi
     return makeBytePath(owned);
 });
 /** @internal */
-export const pathToBytes = Effect.fn("VirtualFileSystem.pathToBytes")(function* (path) {
+export const pathToBytes = Effect.fnUntraced(function* (path) {
     const bytes = getBytePathBytes(path);
     if (bytes === undefined)
         return yield* fsFailure("InvalidArgument", "pathToBytes");

package/dist/internal/resolution.d.ts

@@ -0,0 +1,139 @@
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import type { Identity } from "../Caller.js";
+import { type EntryInput, type NameInput, type Target } from "../Target.js";
+import type { FsFailure } from "../VfsError.js";
+import type { DirectoryHandle, FileHandle, PathInput } from "../VirtualFileSystem.js";
+import { type Confinement } from "./confinement.js";
+import type { OpContext } from "./errors.js";
+import { type PreparedPath } from "./path.js";
+import * as TokenRegistry from "./tokenRegistry.js";
+import { type Directory, type Ino, type Node } from "./volumeState.js";
+/** @internal */
+export type PreparedEntry = {
+    readonly kind: "path";
+    readonly path: PreparedPath;
+    readonly base: DirectoryHandle | undefined;
+} | {
+    readonly kind: "entry";
+    readonly directory: Target;
+    readonly name: string;
+};
+/** @internal */
+export interface NodeMode<R = never> {
+    readonly kind: "Node";
+    readonly followFinalSymlink?: boolean;
+    readonly final?: boolean;
+    readonly createMissing?: (parent: Directory, name: string, final: boolean) => Effect.Effect<Directory, FsFailure, R>;
+}
+/** @internal */
+export interface ParentMode {
+    readonly kind: "Parent";
+}
+/** @internal */
+export interface OrCreateMode<R = never> {
+    readonly kind: "OrCreate";
+    readonly create: "never" | "ifMissing" | "exclusive";
+    readonly finalSymlink: "follow" | "preserve";
+    readonly entryExclusive?: "afterSymlink";
+    readonly beforeFollow?: (parent: Directory, child: Node | undefined) => Effect.Effect<void, FsFailure, R>;
+}
+/** @internal */
+export type NodeResult = {
+    readonly kind: "node";
+    readonly node: Node;
+    readonly op: OpContext;
+} | {
+    readonly kind: "entry";
+    readonly node: Node;
+    readonly parent: Directory;
+    readonly name: string;
+    readonly op: OpContext;
+};
+/** @internal */
+export interface ParentResult {
+    readonly kind: "parent";
+    readonly parent: Ino;
+    readonly name: string | undefined;
+    readonly trailingSlash: boolean;
+    readonly addressing: "path" | "entry";
+    readonly op: OpContext;
+}
+interface CreateEntry {
+    readonly parent: Directory;
+    readonly name: string;
+    readonly trailingSlash: boolean;
+    readonly addressing: "path" | "entry";
+    readonly op: OpContext;
+    readonly origin: {
+        readonly parent: Directory;
+        readonly name: string;
+    };
+}
+/** @internal */
+export type CreateResult = (CreateEntry & {
+    readonly kind: "existing";
+    readonly node: Node;
+}) | (CreateEntry & {
+    readonly kind: "missing";
+});
+/** @internal */
+export declare const inGroup: (identity: Identity, gid: number) => boolean;
+/** @internal */
+export declare const permitted: (node: Node, identity: Identity) => number;
+/** @internal */
+export declare const authorize: (node: Node, identity: Identity, bits: number, op: OpContext) => Effect.Effect<void, never, never> | Effect.Effect<never, FsFailure, never>;
+/** @internal */
+export declare const entryName: (input: NameInput, op: OpContext) => Result.Result<string, FsFailure>;
+/** @internal */
+export declare const make: ({ caller, get, identity, maxPathBytes, registry, confinement, additional, authorityView }: {
+    readonly additional?: ReadonlyArray<Confinement> | undefined;
+    readonly authorityView: Effect.Effect<(ino: Ino) => Node | undefined>;
+    readonly confinement?: Confinement | undefined;
+    readonly caller: TokenRegistry.DirectoryReference;
+    readonly get: (ino: Ino) => Effect.Effect<Node | undefined>;
+    readonly identity: Identity;
+    readonly maxPathBytes: ByteSize.ByteSize | undefined;
+    readonly registry: TokenRegistry.TokenRegistry;
+}) => {
+    prepare: (input: PathInput, op: OpContext) => Result.Result<PreparedPath, FsFailure>;
+    prepareEntry: (input: EntryInput, op: OpContext) => Result.Result<PreparedEntry, FsFailure>;
+    resolve: {
+        <R = never>(target: Target, mode: NodeMode<R>, op: OpContext): Effect.Effect<NodeResult, FsFailure, R>;
+        (prepared: PreparedEntry, mode: ParentMode, op: OpContext): Effect.Effect<ParentResult, FsFailure>;
+        <R = never>(prepared: PreparedEntry, mode: OrCreateMode<R>, op: OpContext): Effect.Effect<CreateResult, FsFailure, R>;
+    };
+    directory: (target: {
+        readonly _tag: "Handle";
+        readonly handle: FileHandle | DirectoryHandle;
+    } | {
+        readonly _tag: "Path";
+        readonly path: PathInput;
+        readonly relativeTo?: DirectoryHandle;
+        readonly followFinalSymlink?: boolean;
+    } | {
+        readonly _tag: "Reference";
+        readonly reference: import("../VirtualFileSystem.js").ObjectReference;
+    }, op: OpContext) => Effect.Effect<{
+        node: Directory;
+        op: OpContext;
+    }, FsFailure, never>;
+    entryDirectory: (target: {
+        readonly _tag: "Handle";
+        readonly handle: FileHandle | DirectoryHandle;
+    } | {
+        readonly _tag: "Path";
+        readonly path: PathInput;
+        readonly relativeTo?: DirectoryHandle;
+        readonly followFinalSymlink?: boolean;
+    } | {
+        readonly _tag: "Reference";
+        readonly reference: import("../VirtualFileSystem.js").ObjectReference;
+    }, op: OpContext) => Effect.Effect<{
+        node: Directory;
+        op: OpContext;
+    }, FsFailure, never>;
+};
+export {};
+//# sourceMappingURL=resolution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolution.d.ts","sourceRoot":"","sources":["../../src/internal/resolution.ts"],"names":[],"mappings":"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"}