@effect-vfs/core 0.2.0 → 0.3.0

package/dist/internal/virtualFileSystem/fixture.js

@@ -0,0 +1,144 @@
+// Fixture image construction.
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { ImageError } from "../../Snapshot.js";
+import { getBytes as getBytePathBytes } from "../bytePath.js";
+import * as Image from "../image.js";
+import { Fixture as FixtureSchema, FixtureMetadata, makeVolume, VolumeOptions as VolumeOptionsSchema } from "../virtualFileSystem.js";
+import { attachedBuffer, decodeConfiguration, failure, nameBytes, preparePath, wellFormed } from "./path.js";
+/** @internal */
+export const fromFixture = Effect.fn("VirtualFileSystem.fromFixture")(function* (fixture, options) {
+    const config = decodeConfiguration(VolumeOptionsSchema, options ?? {});
+    if (Result.isFailure(config))
+        return yield* config.failure;
+    const decoded = Schema.decodeResult(FixtureSchema, { onExcessProperty: "error" })(fixture);
+    if (Result.isFailure(decoded))
+        return yield* new ImageError({ code: "InvalidStructure", field: "fixture" });
+    const source = decoded.success;
+    for (const entry of source.entries) {
+        if (entry.kind === "file" && (!(entry.bytes.buffer instanceof ArrayBuffer) || !attachedBuffer(entry.bytes)))
+            return yield* new ImageError({ code: "InvalidEncoding", field: "bytes" });
+    }
+    const metadata = (kind, overrides) => ({
+        uid: overrides?.uid ?? 0,
+        gid: overrides?.gid ?? 0,
+        mode: overrides?.mode ?? (kind === "directory" ? 0o755 : kind === "file" ? 0o644 : 0o777),
+        atimeNs: String(overrides?.atimeNs ?? 0n),
+        mtimeNs: String(overrides?.mtimeNs ?? 0n),
+        ctimeNs: String(overrides?.ctimeNs ?? 0n),
+        birthtimeNs: String(overrides?.birthtimeNs ?? 0n)
+    });
+    const declarations = new Map();
+    const aliases = new Map();
+    const paths = new Map();
+    const root = {
+        id: "root",
+        kind: "directory",
+        metadata: metadata("directory", source.rootMetadata),
+        entries: []
+    };
+    declarations.set("", root);
+    const fixturePath = (input) => preparePath(input, "fixture", config.success.maxPathBytes).pipe(Result.flatMap((path) => !path.absolute || path.components.length === 0 ||
+        path.components.some((name) => name === "2e" || name === "2e2e")
+        ? Result.fail(failure("InvalidArgument", "fixture", input)) :
+        Result.succeed(path.components)));
+    // All byte inputs become immutable strings before the first successful suspension.
+    for (const entry of source.entries) {
+        const parsed = fixturePath(entry.path);
+        if (Result.isFailure(parsed)) {
+            return yield* new ImageError({ code: "InvalidStructure", field: "path" });
+        }
+        const components = parsed.success;
+        const key = components.join("/");
+        if (paths.has(key))
+            return yield* new ImageError({ code: "InvalidStructure", field: "duplicate" });
+        paths.set(key, components);
+        if (entry.kind === "hardLink") {
+            const target = fixturePath(entry.target);
+            if (Result.isFailure(target))
+                return yield* new ImageError({ code: "InvalidStructure", field: "target" });
+            aliases.set(key, target.success.join("/"));
+        }
+        else if (entry.kind === "directory") {
+            declarations.set(key, {
+                id: String(paths.size),
+                kind: "directory",
+                metadata: metadata("directory", entry.metadata),
+                entries: []
+            });
+        }
+        else if (entry.kind === "file") {
+            declarations.set(key, {
+                id: String(paths.size),
+                kind: "file",
+                metadata: metadata("file", entry.metadata),
+                data: Image.base64(entry.bytes)
+            });
+        }
+        else {
+            if (typeof entry.target === "string" && !wellFormed(entry.target)) {
+                return yield* new ImageError({
+                    code: "InvalidEncoding",
+                    field: "target"
+                });
+            }
+            const target = typeof entry.target === "string"
+                ? new TextEncoder().encode(entry.target)
+                : getBytePathBytes(entry.target);
+            if (target === undefined || target.includes(0)) {
+                return yield* new ImageError({
+                    code: "InvalidStructure",
+                    field: "target"
+                });
+            }
+            declarations.set(key, {
+                id: String(paths.size),
+                kind: "symlink",
+                metadata: metadata("symlink", entry.metadata),
+                target: Image.base64(target)
+            });
+        }
+    }
+    for (const [key] of aliases) {
+        let target = key;
+        const seen = new Set();
+        while (!declarations.has(target)) {
+            if (seen.has(target))
+                return yield* new ImageError({ code: "InvalidStructure", field: "hardLink" });
+            seen.add(target);
+            const next = aliases.get(target);
+            if (next === undefined)
+                return yield* new ImageError({ code: "InvalidStructure", field: "hardLink" });
+            target = next;
+        }
+        const node = declarations.get(target);
+        if (node === undefined || node.kind === "directory") {
+            return yield* new ImageError({
+                code: "InvalidStructure",
+                field: "hardLink"
+            });
+        }
+        for (const alias of seen)
+            declarations.set(alias, node);
+    }
+    const children = new Map();
+    for (const [key, components] of paths) {
+        const parent = declarations.get(components.slice(0, -1).join("/"));
+        const child = declarations.get(key);
+        const name = components.at(-1);
+        if (parent?.kind !== "directory" || child === undefined || name === undefined) {
+            return yield* new ImageError({ code: "InvalidStructure", field: "parent" });
+        }
+        const entries = children.get(parent.id) ?? [];
+        entries.push({ name: Image.base64(nameBytes(name)), target: child.id });
+        children.set(parent.id, entries);
+    }
+    const records = [...new Set(declarations.values())].map((record) => record.kind === "directory" ? { ...record, entries: children.get(record.id) ?? [] } : record);
+    const snapshot = yield* Image.capture({ format: "effect-vfs", version: 1, root: "root", records });
+    const image = yield* Image.inspect(snapshot);
+    const result = yield* makeVolume({ _tag: "Snapshot", image }, config.success);
+    if (result._tag === "Overlay")
+        return yield* new ImageError({ code: "InvalidStructure" });
+    return result.volume;
+});

package/dist/internal/{content.d.ts → virtualFileSystem/overlayContent.d.ts}

@@ -1,10 +1,5 @@
-/**
- * Immutable regular-file payloads shared by overlay workspaces.
- *
- * @internal
- */
-import type { Snapshot } from "../Snapshot.js";
-import * as Image from "./image.js";
+import type { Snapshot } from "../../Snapshot.js";
+import * as Image from "../image.js";
 /** @internal */
 export interface Content {
     readonly bytes: Uint8Array;
@@ -15,11 +10,6 @@ export declare const hasOverlayContents: (snapshot: Snapshot) => boolean;
 export declare const make: (bytes: Uint8Array) => Content;
 /** @internal */
 export declare const empty: () => Content;
-/**
- * Returns the immutable file payloads associated with the identity of a base
- * snapshot. The cache is weak so it cannot extend the snapshot's lifetime.
- *
- * @internal
- */
+/** @internal */
 export declare const forOverlay: (snapshot: Snapshot, image: Image.Document) => ReadonlyMap<string, Content>;
-//# sourceMappingURL=content.d.ts.map
+//# sourceMappingURL=overlayContent.d.ts.map

package/dist/internal/virtualFileSystem/overlayContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayContent.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/overlayContent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,KAAK,MAAM,aAAa,CAAA;AAEpC,gBAAgB;AAChB,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;CAC3B;AAID,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,aAAc,QAAQ,KAAG,OAAwC,CAAA;AAEhG,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,UAAU,KAAG,OAAsB,CAAA;AAE/D,gBAAgB;AAChB,eAAO,MAAM,KAAK,QAAO,OAAkC,CAAA;AAG3D,gBAAgB;AAChB,eAAO,MAAM,UAAU,aAAc,QAAQ,SAAS,KAAK,CAAC,QAAQ,KAAG,WAAW,CAAC,MAAM,EAAE,OAAO,CASjG,CAAA"}

package/dist/internal/{content.js → virtualFileSystem/overlayContent.js}

@@ -1,4 +1,4 @@
-import * as Image from "./image.js";
+import * as Image from "../image.js";
 const overlayContents = new WeakMap();
 /** @internal */
 export const hasOverlayContents = (snapshot) => overlayContents.has(snapshot);
@@ -6,12 +6,8 @@ export const hasOverlayContents = (snapshot) => overlayContents.has(snapshot);
 export const make = (bytes) => ({ bytes });
 /** @internal */
 export const empty = () => make(new Uint8Array(0));
-/**
- * Returns the immutable file payloads associated with the identity of a base
- * snapshot. The cache is weak so it cannot extend the snapshot's lifetime.
- *
- * @internal
- */
+// The weak cache shares immutable payloads without extending the snapshot's lifetime.
+/** @internal */
 export const forOverlay = (snapshot, image) => {
     const cached = overlayContents.get(snapshot);
     if (cached !== undefined)

package/dist/internal/{overlayChanges.d.ts → virtualFileSystem/overlayDiff.d.ts}

@@ -47,4 +47,4 @@ export type RawOverlayChange = {
 };
 /** @internal */
 export declare const compareOverlay: (base: ReadonlyArray<ObservationEntry>, current: ReadonlyArray<ObservationEntry>, includeTimestamps?: boolean) => ReadonlyArray<RawOverlayChange>;
-//# sourceMappingURL=overlayChanges.d.ts.map
+//# sourceMappingURL=overlayDiff.d.ts.map

package/dist/internal/virtualFileSystem/overlayDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayDiff.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/overlayDiff.ts"],"names":[],"mappings":"AAGA,gBAAgB;AAChB,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED,gBAAgB;AAChB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAAA;IAC/C,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAA;CACvC;AAED,gBAAgB;AAChB,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAA;AAEtH,gBAAgB;AAChB,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CAAE,GAC9F;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CAAE,GAChG;IACA,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC7C,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC5C,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;CACvD,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IACvC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;CACvD,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IACvC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;CACvD,CAAA;AA4EH,gBAAgB;AAChB,eAAO,MAAM,cAAc,SACnB,aAAa,CAAC,gBAAgB,CAAC,WAC5B,aAAa,CAAC,gBAAgB,CAAC,kCAEvC,aAAa,CAAC,gBAAgB,CAoEhC,CAAA"}

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

@@ -0,0 +1,43 @@
+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 { type BytePath } from "../../BytePath.js";
+import type { PathInput } from "../../VirtualFileSystem.js";
+import { ConfigurationError, type FsCode, FsError } from "./errors.js";
+/** @internal */
+export declare const failure: (code: FsCode, operation: string, path?: PathInput) => FsError;
+/** @internal */
+export declare const ownedPath: (bytes: Uint8Array) => BytePath;
+/** @internal */
+export declare const strictString: (bytes: Uint8Array, operation: string) => Effect.Effect<string, FsError, never>;
+/** @internal */
+export declare const nameBytes: (name: string) => Uint8Array;
+/** @internal */
+export declare const attachedBuffer: (bytes: Uint8Array) => boolean;
+/** @internal */
+export declare const pathFromBytes: (bytes: Uint8Array<ArrayBufferLike>) => Effect.Effect<BytePath, FsError, never>;
+/** @internal */
+export declare const pathToBytes: (path: BytePath) => Effect.Effect<Uint8Array<ArrayBuffer>, FsError, never>;
+/** @internal */
+export interface LookupOptions {
+    readonly followFinalSymlink?: boolean;
+    readonly allowMissing?: boolean;
+    readonly parentOnly?: boolean;
+}
+/** @internal */
+export interface PreparedPath {
+    readonly input: PathInput;
+    readonly absolute: boolean;
+    readonly trailingSlash: boolean;
+    readonly bytes: Uint8Array;
+    readonly suffixes: ReadonlyArray<Uint8Array>;
+    readonly components: ReadonlyArray<string>;
+}
+/** @internal */
+export declare const wellFormed: (value: string) => boolean;
+/** @internal */
+export declare const preparePath: (input: PathInput, operation: string, maxPathBytes: ByteSize.ByteSize | undefined) => Result.Result<PreparedPath, FsError>;
+/** @internal */
+export declare const decodeConfiguration: <A>(schema: Schema.Codec<A>, value: unknown) => Result.Result<A, ConfigurationError>;
+//# sourceMappingURL=path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/path.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAE3D,OAAO,EAAE,kBAAkB,EAAE,KAAK,MAAM,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAEtE,gBAAgB;AAChB,eAAO,MAAM,OAAO,SAAU,MAAM,aAAa,MAAM,SAAS,SAAS,YACE,CAAA;AAE3E,gBAAgB;AAChB,eAAO,MAAM,SAAS,UAAW,UAAU,KAAG,QAE7C,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,YAAY,UAAW,UAAU,aAAa,MAAM,0CAI7D,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,MAAM,KAAG,UAExC,CAAA;AAGD,gBAAgB;AAChB,eAAO,MAAM,cAAc,UAAW,UAAU,KAAG,OAQlD,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,aAAa,iFAQxB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,WAAW,4EAItB,CAAA;AAEF,gBAAgB;AAChB,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;IACrC,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B;AAED,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;AAED,gBAAgB;AAChB,eAAO,MAAM,UAAU,UAAW,MAAM,KAAG,OAS1C,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,WAAW,UACf,SAAS,aACL,MAAM,gBACH,QAAQ,CAAC,QAAQ,GAAG,SAAS,KAC1C,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,OAAO,CAmCrC,CAAA;AAQD,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,GAAI,CAAC,UAAU,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,OAAO,yCAG3E,CAAA"}

package/dist/internal/virtualFileSystem/path.js

@@ -0,0 +1,124 @@
+// Byte-preserving path validation and conversion.
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import * as Encoding from "effect/Encoding";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as SchemaIssue from "effect/SchemaIssue";
+import {} from "../../BytePath.js";
+import { getBytes as getBytePathBytes, make as makeBytePath } from "../bytePath.js";
+import { ConfigurationError, FsError } from "./errors.js";
+/** @internal */
+export const failure = (code, operation, path) => new FsError({ code, operation, ...(path === undefined ? {} : { path }) });
+/** @internal */
+export const ownedPath = (bytes) => {
+    return makeBytePath(bytes);
+};
+/** @internal */
+export const strictString = (bytes, operation) => Effect.try({
+    try: () => new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes),
+    catch: () => failure("UnrepresentableName", operation)
+});
+/** @internal */
+export const nameBytes = (name) => {
+    return Result.getOrThrow(Encoding.decodeHex(name));
+};
+// A zero-length view distinguishes a detached buffer from a valid empty buffer.
+/** @internal */
+export const attachedBuffer = (bytes) => {
+    try {
+        new Uint8Array(bytes.buffer, bytes.byteOffset, 0);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return false;
+        throw error;
+    }
+};
+/** @internal */
+export const pathFromBytes = Effect.fn("VirtualFileSystem.pathFromBytes")(function* (bytes) {
+    if (!(bytes instanceof Uint8Array) || !(bytes.buffer instanceof ArrayBuffer)) {
+        return yield* failure("InvalidArgument", "pathFromBytes");
+    }
+    if (!attachedBuffer(bytes))
+        return yield* failure("InvalidArgument", "pathFromBytes");
+    const owned = new Uint8Array(bytes);
+    if (owned.length === 0 || owned.includes(0))
+        return yield* failure("InvalidArgument", "pathFromBytes");
+    return makeBytePath(owned);
+});
+/** @internal */
+export const pathToBytes = Effect.fn("VirtualFileSystem.pathToBytes")(function* (path) {
+    const bytes = getBytePathBytes(path);
+    if (bytes === undefined)
+        return yield* failure("InvalidArgument", "pathToBytes");
+    return new Uint8Array(bytes);
+});
+/** @internal */
+export const wellFormed = (value) => {
+    for (let index = 0; index < value.length; index++) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(++index);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return false;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff)
+            return false;
+    }
+    return true;
+};
+/** @internal */
+export const preparePath = (input, operation, maxPathBytes) => {
+    let bytes;
+    if (typeof input === "string") {
+        if (!wellFormed(input))
+            return Result.fail(failure("InvalidPathEncoding", operation, input));
+        bytes = new TextEncoder().encode(input);
+    }
+    else if (typeof input === "object" && input !== null) {
+        bytes = getBytePathBytes(input);
+    }
+    if (bytes === undefined)
+        return Result.fail(failure("InvalidArgument", operation));
+    if (bytes.length === 0)
+        return Result.fail(failure("NotFound", operation, input));
+    if (bytes.includes(0))
+        return Result.fail(failure("InvalidArgument", operation, input));
+    if (maxPathBytes !== undefined && ByteSize.isGreaterThan(ByteSize.bytes(bytes.length), maxPathBytes)) {
+        return Result.fail(failure("PathTooLong", operation, input));
+    }
+    const components = [];
+    const suffixes = [];
+    let start = 0;
+    for (let index = 0; index <= bytes.length; index++) {
+        if (index !== bytes.length && bytes[index] !== 47)
+            continue;
+        if (index > start) {
+            // Provisional component bound from decision 0019; names are compared as bytes.
+            if (index - start > 255)
+                return Result.fail(failure("PathTooLong", operation, input));
+            components.push(Encoding.encodeHex(bytes.subarray(start, index)));
+            suffixes.push(bytes.subarray(index));
+        }
+        start = index + 1;
+    }
+    return Result.succeed({
+        input,
+        absolute: bytes[0] === 47,
+        trailingSlash: bytes.at(-1) === 47,
+        bytes,
+        suffixes,
+        components
+    });
+};
+const configurationField = (issue) => {
+    if (issue._tag === "Pointer")
+        return issue.path.map(String).join(".");
+    if (issue._tag === "Composite")
+        return configurationField(issue.issues[0]);
+    return "options";
+};
+/** @internal */
+export const decodeConfiguration = (schema, value) => Schema.decodeUnknownResult(schema, { onExcessProperty: "error" })(value).pipe(Result.mapError((error) => new ConfigurationError({ field: configurationField(error.issue) })));

package/dist/internal/virtualFileSystem/testHooks.d.ts

@@ -0,0 +1,20 @@
+import type * as Effect from "effect/Effect";
+import type { Snapshot } from "../../Snapshot.js";
+import type { Volume } from "../../VirtualFileSystem.js";
+/** @internal */
+export interface ObservationHook {
+    readonly betweenSnapshotAndSummary: Effect.Effect<void>;
+}
+/** @internal */
+export declare const getObservationHook: (snapshot: Snapshot) => ObservationHook | undefined;
+/** @internal */
+export declare const setObservationHook: (snapshot: Snapshot, hook: ObservationHook) => () => void;
+/** @internal */
+export interface RegistrationHook {
+    readonly afterSubscribe: Effect.Effect<void>;
+}
+/** @internal */
+export declare const getRegistrationHook: (volume: Volume) => RegistrationHook | undefined;
+/** @internal */
+export declare const setRegistrationHook: (volume: Volume, hook: RegistrationHook) => () => void;
+//# sourceMappingURL=testHooks.d.ts.map

package/dist/internal/virtualFileSystem/testHooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testHooks.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/testHooks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAA;AAExD,gBAAgB;AAChB,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,yBAAyB,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CACxD;AAID,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,aAAc,QAAQ,KAAG,eAAe,GAAG,SAA2C,CAAA;AAErH,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,aAAc,QAAQ,QAAQ,eAAe,KAAG,MAAM,IAKpF,CAAA;AAED,gBAAgB;AAChB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAC7C;AAID,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,WAAY,MAAM,KAAG,gBAAgB,GAAG,SAA0C,CAAA;AAElH,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,WAAY,MAAM,QAAQ,gBAAgB,KAAG,MAAM,IAKlF,CAAA"}

package/dist/internal/virtualFileSystem/testHooks.js

@@ -0,0 +1,23 @@
+// Package-internal synchronization hooks for deterministic volume tests.
+const observationHooks = new WeakMap();
+/** @internal */
+export const getObservationHook = (snapshot) => observationHooks.get(snapshot);
+/** @internal */
+export const setObservationHook = (snapshot, hook) => {
+    observationHooks.set(snapshot, hook);
+    return () => {
+        if (observationHooks.get(snapshot) === hook)
+            observationHooks.delete(snapshot);
+    };
+};
+const registrationHooks = new WeakMap();
+/** @internal */
+export const getRegistrationHook = (volume) => registrationHooks.get(volume);
+/** @internal */
+export const setRegistrationHook = (volume, hook) => {
+    registrationHooks.set(volume, hook);
+    return () => {
+        if (registrationHooks.get(volume) === hook)
+            registrationHooks.delete(volume);
+    };
+};

package/dist/internal/virtualFileSystem/watchHub.d.ts

@@ -0,0 +1,16 @@
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+/** @internal */
+export interface Coordinator {
+    <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+}
+/** @internal */
+export interface WatchHub<A> {
+    readonly publishUnsafe: (event: () => A) => void;
+    readonly publishManyUnsafe: (events: () => Iterable<A>) => void;
+    readonly subscribe: (afterSubscribe?: Effect.Effect<void>) => Effect.Effect<Stream.Stream<A>, never, Scope.Scope>;
+}
+/** @internal */
+export declare const make: <A>(coordinate: Coordinator) => Effect.Effect<WatchHub<A>, never, never>;
+//# sourceMappingURL=watchHub.d.ts.map

package/dist/internal/virtualFileSystem/watchHub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchHub.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/watchHub.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,gBAAgB;AAChB,MAAM,WAAW,WAAW;IAC1B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAClE;AAED,gBAAgB;AAChB,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,CAAA;IAChD,QAAQ,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;IAC/D,QAAQ,CAAC,SAAS,EAAE,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;CAClH;AAED,gBAAgB;AAChB,eAAO,MAAM,IAAI,GAA+B,CAAC,sEA+B/C,CAAA"}

package/dist/internal/virtualFileSystem/watchHub.js

@@ -0,0 +1,33 @@
+import * as Effect from "effect/Effect";
+import * as PubSub from "effect/PubSub";
+import * as Stream from "effect/Stream";
+/** @internal */
+export const make = Effect.fnUntraced(function* (coordinate) {
+    const pubsub = yield* PubSub.unbounded();
+    let activeSubscribers = 0;
+    const publishUnsafe = (event) => {
+        if (activeSubscribers === 0)
+            return;
+        PubSub.publishUnsafe(pubsub, event());
+    };
+    const publishManyUnsafe = (events) => {
+        if (activeSubscribers === 0)
+            return;
+        for (const event of events())
+            PubSub.publishUnsafe(pubsub, event);
+    };
+    const subscribe = (afterSubscribe) => Effect.uninterruptible(Effect.gen(function* () {
+        const subscription = yield* coordinate(Effect.gen(function* () {
+            const subscription = yield* PubSub.subscribe(pubsub);
+            if (afterSubscribe !== undefined)
+                yield* afterSubscribe;
+            activeSubscribers += 1;
+            return subscription;
+        }));
+        yield* Effect.addFinalizer(() => coordinate(Effect.sync(() => {
+            activeSubscribers -= 1;
+        })));
+        return Stream.fromSubscription(subscription);
+    }));
+    return { publishUnsafe, publishManyUnsafe, subscribe };
+});