@effect-vfs/core 0.5.0 → 0.6.0

package/dist/internal/image.js

@@ -1,187 +1,157 @@
-// Snapshot validation and serialization used by VirtualFileSystem.
-import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
-import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import { DecodeLimits, ImageError, SnapshotTypeId } from "../Snapshot.js";
-import { CanonicalBase64 } from "./canonicalBase64.js";
-import { StoredMetadata, WireStoredMetadata } from "./metadata.js";
+import * as Stream from "effect/Stream";
+import { decodeOption } from "../BytePath.js";
+import { SnapshotTypeId } from "../Snapshot.js";
+import { make as makeBytePath } from "./bytePath.js";
+import { fsFailure, imageFailure } from "./errors.js";
+import * as Lines from "./lines.js";
+import { DOT_DOT_HEX, DOT_HEX, joinPath, MAX_SYMLINK_TRAVERSALS, nameBytes, ownedPath, preparePath } from "./path.js";
+import * as Tree from "./tree.js";
+import { assemble, byEntryName, getNode, ROOT_INO, storedMetadata } from "./volumeState.js";
+// Volume values are immutable, so snapshots share them without exposing their state.
 class SnapshotImpl {
     [SnapshotTypeId] = SnapshotTypeId;
+    #value;
+    constructor(value) {
+        this.#value = value;
+    }
+    static valueOf(snapshot) {
+        return #value in snapshot ? snapshot.#value : undefined;
+    }
 }
 /** @internal */
-export { StoredMetadata };
-const id = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(128));
+export const make = (value) => Object.freeze(new SnapshotImpl(value));
 /** @internal */
-export const Record = Schema.TaggedUnion({
-    directory: {
-        id,
-        metadata: StoredMetadata,
-        entries: Schema.Array(Schema.Struct({ name: CanonicalBase64.Encoded, target: id }))
-    },
-    file: { id, metadata: StoredMetadata, data: CanonicalBase64.Encoded },
-    symlink: { id, metadata: StoredMetadata, target: CanonicalBase64.Encoded }
+export const valueOf = (snapshot) => Effect.suspend(() => {
+    const value = SnapshotImpl.valueOf(snapshot);
+    return value === undefined
+        ? imageFailure("decodeSnapshot", "InvalidStructure", { field: "snapshot" })
+        : Effect.succeed(value);
 });
+const HEADER = JSON.stringify(Tree.SnapshotHeader.make({ format: "effect-vfs", version: 1 }));
+const nodeText = Schema.encodeResult(Schema.fromJsonString(Tree.TreeNode));
+// Charge encoded lines by decoder rules so any successful output fits the same budget.
 /** @internal */
-export const Document = Schema.Struct({
-    format: Schema.Literal("effect-vfs"),
-    version: Schema.Literal(1),
-    root: id,
-    records: Schema.Array(Record)
-});
-const WireRecord = Schema.TaggedUnion({
-    directory: {
-        id,
-        metadata: WireStoredMetadata,
-        entries: Schema.Array(Schema.Struct({ name: Schema.String, target: id }))
-    },
-    file: { id, metadata: WireStoredMetadata, data: Schema.String },
-    symlink: { id, metadata: WireStoredMetadata, target: Schema.String }
-});
-const WireDocument = Schema.Struct({
-    format: Schema.Literal("effect-vfs"),
-    version: Schema.Literal(1),
-    root: id,
-    records: Schema.Array(WireRecord)
-});
-const VersionProbe = Schema.Struct({
-    format: Schema.Literal("effect-vfs"),
-    version: Schema.Unknown
-});
-const snapshots = new WeakMap();
+export const encodeSnapshotStream = (snapshot, budget) => Stream.unwrap(Effect.gen(function* () {
+    const nodes = yield* Tree.treeNodes(yield* valueOf(snapshot));
+    const operation = "encodeSnapshot";
+    return Tree.writeTree({
+        operation,
+        documentField: "text",
+        header: HEADER,
+        node: Tree.treeNode,
+        text: nodeText,
+        meter: budget === undefined ? undefined : Tree.meter(budget, operation)
+    }, nodes);
+}));
 /** @internal */
-export const inspect = (snapshot) => Effect.suspend(() => {
-    const document = snapshots.get(snapshot);
-    return document === undefined
-        ? new ImageError({ code: "InvalidStructure", field: "snapshot" })
-        : Effect.succeed(document);
-});
+export const encodeSnapshot = (snapshot, budget) => Lines.collect(encodeSnapshotStream(snapshot, budget));
 /** @internal */
-export const capture = Effect.fnUntraced(function* (input, limits, trusted = false) {
-    const wire = trusted ? undefined : Schema.decodeUnknownResult(WireDocument, { onExcessProperty: "error" })(input);
-    if (wire !== undefined && Result.isFailure(wire)) {
-        return yield* new ImageError({ code: "InvalidStructure", field: "document" });
-    }
-    const decoded = trusted ? undefined : Schema.decodeUnknownResult(Document, { onExcessProperty: "error" })(input);
-    if (decoded !== undefined && Result.isFailure(decoded)) {
-        return yield* new ImageError({ code: "InvalidEncoding", field: "document" });
-    }
-    // SAFETY: a trusted caller passes a Document it built; an untrusted one has just been decoded.
-    const document = decoded === undefined ? input : decoded.success;
-    const records = new Map();
-    let entries = 0;
-    let payload = ByteSize.zero;
-    if (limits !== undefined && document.records.length > limits.maxRecords) {
-        return yield* new ImageError({ code: "LimitExceeded", field: "records" });
-    }
-    for (const record of document.records) {
-        if (records.has(record.id))
-            return yield* new ImageError({ code: "InvalidStructure", field: "id" });
-        records.set(record.id, record);
-        Match.value(record).pipe(Match.tag("directory", (record) => {
-            entries += record.entries.length;
-        }), Match.undefined);
-    }
-    if (limits !== undefined && entries > limits.maxEntries) {
-        return yield* new ImageError({ code: "LimitExceeded", field: "entries" });
-    }
-    // Count every payload before allocating any decoded payload buffer. Trusted records carry
-    // base64 this module produced, so the scan only runs when a limit depends on the tally.
-    if (!trusted || limits !== undefined) {
-        for (const record of document.records) {
-            const values = Match.value(record).pipe(Match.tag("directory", (record) => record.entries.map((entry) => entry.name)), Match.tag("file", (record) => [record.data]), Match.tag("symlink", (record) => [record.target]), Match.exhaustive);
-            for (const value of values) {
-                if (!CanonicalBase64.is(value)) {
-                    return yield* new ImageError({ code: "InvalidEncoding", field: record.id });
-                }
-                payload = ByteSize.sum(payload, ByteSize.bytes(CanonicalBase64.decodedLength(value)));
-                if (limits !== undefined && ByteSize.isGreaterThan(payload, limits.maxDecodedBytes)) {
-                    return yield* new ImageError({ code: "LimitExceeded", field: "bytes" });
-                }
-            }
-        }
-    }
-    const root = records.get(document.root);
-    if (root === undefined || !Record.guards.directory(root)) {
-        return yield* new ImageError({ code: "InvalidStructure", field: "root" });
-    }
-    const parents = new Map();
-    for (const record of document.records) {
-        if (Record.guards.directory(record)) {
-            const names = new Set();
-            for (const entry of record.entries) {
-                if (names.has(entry.name) || CanonicalBase64.decodedLength(entry.name) < 1 ||
-                    CanonicalBase64.decodedLength(entry.name) > 255)
-                    return yield* new ImageError({ code: "InvalidStructure", field: "name" });
-                names.add(entry.name);
-                const name = yield* CanonicalBase64.decode(entry.name);
-                if (name.includes(0) || name.includes(47) || (name.length === 1 && name[0] === 46) ||
-                    (name.length === 2 && name[0] === 46 && name[1] === 46))
-                    return yield* new ImageError({ code: "InvalidStructure", field: "name" });
-                const target = records.get(entry.target);
-                if (target === undefined)
-                    return yield* new ImageError({ code: "InvalidStructure", field: "target" });
-                parents.set(target.id, (parents.get(target.id) ?? 0) + 1);
-            }
+export const decodeSnapshotSink = (budget) => {
+    const operation = "decodeSnapshot";
+    return Lines.sink({ operation, inputField: "input", textField: "text" }, () => {
+        const meter = Tree.meter(budget, operation);
+        const reader = Tree.snapshotReader({ operation, documentField: "document", meter });
+        return {
+            meter,
+            fold: { line: reader.line, end: () => Result.map(reader.end(), (read) => make(assemble(read.specs))) }
+        };
+    });
+};
+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);
+    if (Result.isFailure(prepared))
+        return Result.fail(prepared.failure);
+    const root = getNode(value, ROOT_INO);
+    let work = prepared.success;
+    let current = root;
+    let traversals = 0;
+    for (let index = 0; index < work.components.length; index++) {
+        if (current.kind !== "directory")
+            return fail("NotDirectory");
+        const component = work.components[index];
+        if (component === DOT_HEX)
+            continue;
+        if (component === DOT_DOT_HEX) {
+            current = getNode(value, current.parent);
+            continue;
         }
-        else if (Record.guards.symlink(record) && (yield* CanonicalBase64.decode(record.target)).includes(0)) {
-            return yield* new ImageError({ code: "InvalidStructure", field: "symlink" });
+        const ino = current.entries.get(component);
+        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)) {
+            current = child;
+            continue;
         }
+        if (child.target.length === 0)
+            return fail("NotFound");
+        if (++traversals > MAX_SYMLINK_TRAVERSALS)
+            return fail("SymlinkLoop");
+        const suffix = work.suffixes[index] ?? new Uint8Array(0);
+        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);
+        if (Result.isFailure(expanded))
+            return fail(expanded.failure.code);
+        work = expanded.success;
+        if (work.absolute)
+            current = root;
+        index = -1;
     }
-    if (parents.has(root.id))
-        return yield* new ImageError({ code: "InvalidStructure", field: "root" });
-    for (const record of document.records) {
-        const invalidParent = Match.value(record).pipe(Match.tag("directory", (record) => parents.get(record.id) !== 1), Match.tag("file", (record) => !parents.has(record.id)), Match.tag("symlink", (record) => !parents.has(record.id)), Match.exhaustive);
-        if (record !== root && invalidParent) {
-            return yield* new ImageError({ code: "InvalidStructure", field: "parent" });
+    return work.trailingSlash && current.kind !== "directory" ? fail("NotDirectory") : Result.succeed(current);
+};
+const text = (bytes) => Option.getOrUndefined(decodeOption(bytes));
+const childPath = (parent, name) => {
+    const named = text(name);
+    if (Predicate.isString(parent) && named !== undefined)
+        return parent === "/" ? `/${named}` : `${parent}/${named}`;
+    return joinPath(Predicate.isString(parent) ? encoder.encode(parent) : parent, name);
+};
+const pathInput = (path) => (Predicate.isString(path) ? path : makeBytePath(path));
+// Emit the first hard-link path as content and later paths as links; copy file bytes only on pull.
+function* walk(value, node) {
+    const pending = [[node, "/"]];
+    const first = new Map();
+    for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+        const [current, walked] = next;
+        const path = pathInput(walked);
+        const metadata = storedMetadata(current.metadata);
+        if (current.kind === "directory") {
+            yield { kind: "directory", path, metadata };
+            const children = [...current.entries].sort(byEntryName).reverse();
+            for (const [name, ino] of children)
+                pending.push([getNode(value, ino), childPath(walked, nameBytes(name))]);
+            continue;
         }
-    }
-    const visited = new Set();
-    const pending = [root.id];
-    while (pending.length > 0) {
-        const next = pending.pop();
-        if (next === undefined || visited.has(next))
+        const alias = current.links.length > 1 ? first.get(current.ino) : undefined;
+        if (alias !== undefined) {
+            yield { kind: "hardLink", path, target: alias };
             continue;
-        visited.add(next);
-        const record = records.get(next);
-        if (record !== undefined) {
-            Match.value(record).pipe(Match.tag("directory", (record) => {
-                for (const entry of record.entries)
-                    pending.push(entry.target);
-            }), Match.tag("file", () => undefined), Match.tag("symlink", () => undefined), Match.exhaustive);
+        }
+        if (current.links.length > 1)
+            first.set(current.ino, path);
+        if (current.kind === "file")
+            yield { kind: "file", path, bytes: current.data.slice(), metadata };
+        else {
+            const target = text(current.target);
+            yield { kind: "symlink", path, target: target ?? makeBytePath(current.target.slice()), metadata };
         }
     }
-    if (visited.size !== records.size)
-        return yield* new ImageError({ code: "InvalidStructure", field: "reachability" });
-    const snapshot = Object.freeze(new SnapshotImpl());
-    snapshots.set(snapshot, document);
-    return snapshot;
-});
-/** @internal */
-export const encodeSnapshot = Effect.fn("VirtualFileSystem.encodeSnapshot")(function* (snapshot) {
-    const text = yield* Schema.encodeEffect(Schema.fromJsonString(Document))(yield* inspect(snapshot)).pipe(Effect.mapError(() => new ImageError({ code: "InvalidStructure", field: "text" })));
-    return new TextEncoder().encode(text);
-});
+}
 /** @internal */
-export const decodeSnapshot = Effect.fn("VirtualFileSystem.decodeSnapshot")(function* (input, limits) {
-    const checked = Schema.decodeResult(DecodeLimits, { onExcessProperty: "error" })(limits);
-    if (Result.isFailure(checked))
-        return yield* new ImageError({ code: "InvalidStructure", field: "limits" });
-    if (!(input instanceof Uint8Array) || !(input.buffer instanceof ArrayBuffer)) {
-        return yield* new ImageError({ code: "InvalidEncoding", field: "input" });
-    }
-    if (ByteSize.isGreaterThan(ByteSize.bytes(input.byteLength), checked.success.maxEncodedBytes)) {
-        return yield* new ImageError({ code: "LimitExceeded", field: "encodedBytes" });
-    }
-    const text = yield* Effect.try({
-        try: () => new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(input)),
-        catch: () => new ImageError({ code: "InvalidEncoding", field: "text" })
-    });
-    const value = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown))(text).pipe(Effect.mapError(() => new ImageError({ code: "InvalidEncoding", field: "text" })));
-    const version = Schema.decodeUnknownResult(VersionProbe)(value);
-    if (Result.isSuccess(version) && version.success.version !== 1) {
-        return yield* new ImageError({ code: "UnsupportedVersion", field: "version" });
-    }
-    return yield* capture(value, checked.success);
-});
+export const snapshotEntries = (snapshot, root) => Stream.unwrap(Effect.gen(function* () {
+    const value = yield* valueOf(snapshot);
+    const node = yield* Effect.fromResult(resolve(value, root));
+    // Bound each pulled chunk to one file's copied bytes.
+    return Stream.fromIterable({ [Symbol.iterator]: () => walk(value, node) }, { chunkSize: 1 });
+}));

package/dist/internal/inodeTable.d.ts

@@ -0,0 +1,20 @@
+/** @internal */
+export type Owner = symbol;
+interface Slots<A> {
+    readonly owner: Owner | undefined;
+    readonly items: Array<Slots<A> | A | undefined>;
+}
+/** @internal */
+export interface InodeTable<A> {
+    readonly root: Slots<A>;
+    readonly levels: number;
+    readonly capacity: number;
+}
+/** @internal */
+export declare const empty: <A>() => InodeTable<A>;
+/** @internal */
+export declare const get: <A>(table: InodeTable<A>, key: number) => A | undefined;
+/** @internal */
+export declare const set: <A>(table: InodeTable<A>, key: number, value: A | undefined, owner?: Owner) => InodeTable<A>;
+export {};
+//# sourceMappingURL=inodeTable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inodeTable.d.ts","sourceRoot":"","sources":["../../src/internal/inodeTable.ts"],"names":[],"mappings":"AAQA,gBAAgB;AAChB,MAAM,MAAM,KAAK,GAAG,MAAM,CAAA;AAE1B,UAAU,KAAK,CAAC,CAAC;IACf,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAAA;IACjC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,CAAA;CAChD;AAED,gBAAgB;AAChB,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED,gBAAgB;AAChB,eAAO,MAAM,KAAK,GAAI,CAAC,OAAK,UAAU,CAAC,CAAC,CAA4E,CAAA;AAKpH,gBAAgB;AAChB,eAAO,MAAM,GAAG,GAAI,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,OAAO,MAAM,KAAG,CAAC,GAAG,SAgB9D,CAAA;AAsBD,gBAAgB;AAChB,eAAO,MAAM,GAAG,GAAI,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,OAAO,MAAM,SAAS,CAAC,GAAG,SAAS,UAAU,KAAK,KAAG,UAAU,CAAC,CAAC,CAU3G,CAAA"}

package/dist/internal/inodeTable.js

@@ -0,0 +1,48 @@
+// A 32-way persistent trie. One owner may mutate paths it has already copied within a batch.
+const BITS = 5;
+const WIDTH = 1 << BITS;
+const MASK = WIDTH - 1;
+const SHIFTABLE = 0x100000000; // Shifts wrap keys at 2^32 and shift counts at 32.
+const MAX_SHIFT = 32;
+/** @internal */
+export const empty = () => ({ root: { owner: undefined, items: [] }, levels: 1, capacity: WIDTH });
+const index = (key, shift) => key < SHIFTABLE && shift < MAX_SHIFT ? (key >>> shift) & MASK : Math.floor(key / 2 ** shift) % WIDTH;
+/** @internal */
+export const get = (table, key) => {
+    if (key >= table.capacity)
+        return undefined;
+    let node = table.root;
+    let shift = (table.levels - 1) * BITS;
+    while (shift > 0) {
+        const next = node.items[index(key, shift)];
+        if (next === undefined)
+            return undefined;
+        // SAFETY: every slot above the leaf level holds a Slots value or nothing.
+        node = next;
+        shift -= BITS;
+    }
+    // SAFETY: leaf level slots hold values or nothing.
+    return node.items[key & MASK];
+};
+const setIn = (node, key, value, shift, owner) => {
+    const target = owner !== undefined && node.owner === owner ? node : { owner, items: node.items.slice() };
+    if (shift === 0)
+        target.items[key & MASK] = value;
+    else {
+        const at = index(key, shift);
+        // SAFETY: every slot above the leaf level holds a Slots value or nothing.
+        const child = node.items[at] ?? { owner: undefined, items: [] };
+        target.items[at] = setIn(child, key, value, shift - BITS, owner);
+    }
+    return target;
+};
+/** @internal */
+export const set = (table, key, value, owner) => {
+    let { capacity, levels, root } = table;
+    while (key >= capacity) {
+        root = { owner, items: [root] };
+        levels += 1;
+        capacity *= WIDTH;
+    }
+    return { root: setIn(root, key, value, (levels - 1) * BITS, owner), levels, capacity };
+};

package/dist/internal/lines.d.ts

@@ -0,0 +1,36 @@
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import type * as Schema from "effect/Schema";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import type { ImageFailure } from "../VfsError.js";
+/** @internal */
+export interface Framing {
+    readonly operation: string;
+    readonly inputField: string;
+    readonly textField: string;
+}
+/** @internal */
+export interface FrameMeter {
+    readonly line: (bytes: number, ended: boolean) => Result.Result<void, ImageFailure>;
+}
+/** @internal */
+export interface LineFold<A> {
+    readonly line: (value: typeof Schema.Unknown.Type, index: number) => Result.Result<void, ImageFailure>;
+    readonly end: () => Result.Result<A, ImageFailure>;
+}
+/** @internal */
+export declare const byteLimit: (limit: ByteSize.ByteSize) => number;
+/** @internal */
+export declare const sink: <A>(framing: Framing, start: () => {
+    readonly meter: FrameMeter;
+    readonly fold: LineFold<A>;
+}) => Sink.Sink<A, Uint8Array, never, ImageFailure>;
+/** @internal */
+export declare const frame: (lines: ReadonlyArray<Uint8Array>) => Uint8Array;
+/** @internal */
+export declare const encodeLine: (text: string) => Uint8Array;
+/** @internal */
+export declare const collect: <E, R>(stream: Stream.Stream<Uint8Array, E, R>) => Effect.Effect<Uint8Array, E, R>;
+//# sourceMappingURL=lines.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lines.d.ts","sourceRoot":"","sources":["../../src/internal/lines.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAQlD,gBAAgB;AAChB,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,gBAAgB;AAChB,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;CACpF;AAED,gBAAgB;AAChB,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;IACtG,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,YAAY,CAAC,CAAA;CACnD;AAED,gBAAgB;AAChB,eAAO,MAAM,SAAS,UAAW,QAAQ,CAAC,QAAQ,KAAG,MAIpD,CAAA;AAkGD,gBAAgB;AAChB,eAAO,MAAM,IAAI,GAAI,CAAC,WACX,OAAO,SACT,MAAM;IAAE,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAA;CAAE,KACtE,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,CAUsB,CAAA;AAIrE,gBAAgB;AAChB,eAAO,MAAM,KAAK,UAAW,aAAa,CAAC,UAAU,CAAC,KAAG,UAWxD,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,UAAU,SAAU,MAAM,KAAG,UAAkC,CAAA;AAE5E,gBAAgB;AAChB,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,UAAU,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,EAAE,CAAC,CAInG,CAAA"}

package/dist/internal/lines.js

@@ -0,0 +1,115 @@
+// Tree images require bounded, newline-terminated JSON lines with strict UTF-8. Text stream operators cannot
+// enforce these byte limits or reject malformed UTF-8 and lone carriage returns.
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import { imageFailure } from "./errors.js";
+import { isAttachedBytes } from "./path.js";
+import { WALK_YIELD_INTERVAL } from "./volumeState.js";
+const NEWLINE = 0x0a;
+const CARRIAGE_RETURN = 0x0d;
+/** @internal */
+export const byteLimit = (limit) => {
+    const bytes = ByteSize.toBigInt(limit);
+    return bytes > BigInt(Number.MAX_SAFE_INTEGER) ? Number.POSITIVE_INFINITY : Number(bytes);
+};
+const concat = (pieces, length) => {
+    const out = new Uint8Array(length);
+    let offset = 0;
+    for (const piece of pieces) {
+        out.set(piece, offset);
+        offset += piece.length;
+    }
+    return out;
+};
+const EMPTY = new Uint8Array(0);
+const makeReader = (framing, meter, fold) => {
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    const invalid = (cause) => imageFailure(framing.operation, "InvalidEncoding", { field: framing.textField, cause });
+    // Chunks may be reused after reading, so an unfinished line owns its bytes.
+    let pending = EMPTY;
+    let pendingBytes = 0;
+    let lines = 0;
+    const hold = (piece, length) => {
+        if (length > pending.length) {
+            const grown = new Uint8Array(Math.max(length, pending.length * 2));
+            grown.set(pending.subarray(0, pendingBytes));
+            pending = grown;
+        }
+        pending.set(piece, pendingBytes);
+        pendingBytes = length;
+    };
+    const parse = (bytes) => {
+        if (bytes.length === 0 || bytes[bytes.length - 1] === CARRIAGE_RETURN)
+            return Result.fail(invalid());
+        try {
+            return Result.succeed(JSON.parse(decoder.decode(bytes)));
+        }
+        catch (cause) {
+            return Result.fail(invalid(cause));
+        }
+    };
+    const scan = (chunk, from) => {
+        for (let start = from, batch = 0; start < chunk.length; batch++) {
+            if (batch === WALK_YIELD_INTERVAL)
+                return Result.succeed(start);
+            const newline = chunk.indexOf(NEWLINE, start);
+            const stop = newline < 0 ? chunk.length : newline;
+            const length = pendingBytes + stop - start;
+            const bounded = meter.line(length, newline >= 0);
+            if (Result.isFailure(bounded))
+                return Result.fail(bounded.failure);
+            if (newline < 0) {
+                hold(chunk.subarray(start), length);
+                break;
+            }
+            let bytes = chunk.subarray(start, stop);
+            if (pendingBytes > 0) {
+                hold(bytes, length);
+                bytes = pending.subarray(0, length);
+                pending = EMPTY;
+                pendingBytes = 0;
+            }
+            start = newline + 1;
+            const read = Result.flatMap(parse(bytes), (value) => fold.line(value, lines++));
+            if (Result.isFailure(read))
+                return Result.fail(read.failure);
+        }
+        return Result.succeed(chunk.length);
+    };
+    const push = Effect.fnUntraced(function* (chunk) {
+        if (!isAttachedBytes(chunk)) {
+            return yield* imageFailure(framing.operation, "InvalidEncoding", { field: framing.inputField });
+        }
+        // Yield during large chunks so other fibers run and interruption is observed.
+        for (let start = yield* Effect.fromResult(scan(chunk, 0)); start < chunk.length;) {
+            yield* Effect.yieldNow;
+            start = yield* Effect.fromResult(scan(chunk, start));
+        }
+    });
+    const end = () => (pendingBytes > 0 ? Result.fail(invalid()) : fold.end());
+    return { push, end };
+};
+/** @internal */
+export const sink = (framing, start) => Sink.foldArray(() => {
+    const { fold, meter } = start();
+    return makeReader(framing, meter, fold);
+}, () => true, (reader, chunks) => Effect.as(Effect.forEach(chunks, (chunk) => reader.push(chunk), { discard: true }), reader)).pipe(Sink.mapEffect((reader) => Effect.fromResult(reader.end())));
+const encoder = new TextEncoder();
+/** @internal */
+export const frame = (lines) => {
+    const out = new Uint8Array(lines.reduce((sum, line) => sum + line.length + 1, 0));
+    let offset = 0;
+    for (const line of lines) {
+        out.set(line, offset);
+        offset += line.length;
+        out[offset++] = NEWLINE;
+    }
+    return out;
+};
+/** @internal */
+export const encodeLine = (text) => encoder.encode(text);
+/** @internal */
+export const collect = (stream) => Effect.map(Stream.runCollect(stream), (chunks) => concat(chunks, chunks.reduce((sum, chunk) => sum + chunk.length, 0)));