@effect-vfs/core 0.4.0 → 0.6.0

package/dist/internal/virtualFileSystem/errors.js

@@ -1,47 +0,0 @@
-// Virtual filesystem failure schemas and identities shared by the runtime implementation.
-import * as Predicate from "effect/Predicate";
-import * as Result from "effect/Result";
-import * as Schema from "effect/Schema";
-import { ConfigurationError, FsError } from "../../VirtualFileSystemError.js";
-/** @internal */
-export { ConfigurationError, FsError };
-/** @internal */
-export const FsCode = Schema.Literals([
-    "NotFound",
-    "AlreadyExists",
-    "NotEmpty",
-    "NotDirectory",
-    "AccessDenied",
-    "InvalidHandle",
-    "ForeignHandle",
-    "InvalidReference",
-    "ForeignReference",
-    "StaleReference",
-    "ClosedCaller",
-    "InvalidArgument",
-    "InvalidPathEncoding",
-    "PathTooLong",
-    "NoSpace",
-    "IsDirectory",
-    "FileTooLarge",
-    "NoData",
-    "SymlinkLoop",
-    "UnrepresentableName",
-    // A durable provider knows the mutation was not committed.
-    "StorageRejected",
-    // A commit or publication failed after its outcome ceased to be knowable to the caller.
-    "OutcomeUnknown",
-    // The provider stopped serving operations until recovery establishes its state.
-    "VolumeUnavailable",
-    "VolumeBusy"
-]);
-// Names the offending option so the caller learns which key it got wrong, not just that decoding failed.
-const configurationField = (issue) => {
-    if (Predicate.isTagged("Pointer")(issue))
-        return issue.path.map(String).join(".");
-    if (Predicate.isTagged("Composite")(issue))
-        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/fixture.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fixture.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/fixture.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAoB9C,gBAAgB;AAChB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kNAwLvB,CAAA"}

package/dist/internal/virtualFileSystem/fixture.js

@@ -1,150 +0,0 @@
-// Fixture image construction.
-import * as Effect from "effect/Effect";
-import * as Result from "effect/Result";
-import * as Schema from "effect/Schema";
-import { ImageError } from "../../Snapshot.js";
-import { CanonicalBase64 } from "../canonicalBase64.js";
-import * as Image from "../image.js";
-import { Fixture as FixtureSchema, FixtureEntry, makeVolume, VolumeIdentity, VolumeOptions as VolumeOptionsSchema, VolumeSource } from "../virtualFileSystem.js";
-import { decodeConfiguration, FsError } from "./errors.js";
-import { inputBytes, isAttachedBytes, isDotComponent, nameBytes, preparePath } from "./path.js";
-const DEFAULT_MODE = { directory: 0o755, file: 0o644, symlink: 0o777 };
-const EPOCH_NS = 0n;
-/** @internal */
-export const fromFixture = Effect.fn("VirtualFileSystem.fromFixture")(function* (fixture, options) {
-    const config = decodeConfiguration(VolumeOptionsSchema, options ?? {});
-    if (Result.isFailure(config))
-        return yield* config.failure;
-    const decoded = Schema.decodeResult(FixtureSchema, { onExcessProperty: "error" })(fixture);
-    if (Result.isFailure(decoded))
-        return yield* new ImageError({ code: "InvalidStructure", field: "fixture" });
-    const source = decoded.success;
-    if (source.entries.some((entry) => FixtureEntry.match(entry, {
-        directory: () => false,
-        file: ({ bytes }) => !isAttachedBytes(bytes),
-        symlink: () => false,
-        hardLink: () => false
-    }))) {
-        return yield* new ImageError({ code: "InvalidEncoding", field: "bytes" });
-    }
-    const metadata = (kind, overrides) => ({
-        uid: overrides?.uid ?? 0,
-        gid: overrides?.gid ?? 0,
-        mode: overrides?.mode ?? DEFAULT_MODE[kind],
-        atimeNs: overrides?.atimeNs ?? EPOCH_NS,
-        mtimeNs: overrides?.mtimeNs ?? EPOCH_NS,
-        ctimeNs: overrides?.ctimeNs ?? EPOCH_NS,
-        birthtimeNs: overrides?.birthtimeNs ?? EPOCH_NS
-    });
-    const declarations = new Map();
-    const aliases = new Map();
-    const paths = new Map();
-    const root = Image.Record.cases.directory.make({
-        id: "root",
-        metadata: metadata("directory", source.rootMetadata),
-        entries: []
-    });
-    declarations.set("", root);
-    const fixturePath = (input) => preparePath(input, "fixture", config.success.maxPathBytes).pipe(Result.flatMap((path) => !path.absolute || path.components.length === 0 ||
-        path.components.some(isDotComponent)
-        ? Result.fail(new FsError({ code: "InvalidArgument", operation: "fixture", path: input })) :
-        Result.succeed(path.components)));
-    // Encode caller-owned byte buffers now: nothing below yields until Image.capture, so a caller
-    // cannot mutate them first.
-    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);
-        const error = FixtureEntry.match(entry, {
-            hardLink: ({ target }) => {
-                const parsedTarget = fixturePath(target);
-                if (Result.isFailure(parsedTarget))
-                    return new ImageError({ code: "InvalidStructure", field: "target" });
-                aliases.set(key, parsedTarget.success.join("/"));
-            },
-            directory: (entry) => {
-                declarations.set(key, Image.Record.cases.directory.make({
-                    id: String(paths.size),
-                    metadata: metadata("directory", entry.metadata),
-                    entries: []
-                }));
-            },
-            file: (entry) => {
-                declarations.set(key, Image.Record.cases.file.make({
-                    id: String(paths.size),
-                    metadata: metadata("file", entry.metadata),
-                    data: CanonicalBase64.encode(entry.bytes)
-                }));
-            },
-            symlink: ({ metadata: overrides, target: input }) => {
-                const target = inputBytes(input);
-                if (Result.isFailure(target)) {
-                    return new ImageError({
-                        code: target.failure === "InvalidPathEncoding" ? "InvalidEncoding" : "InvalidStructure",
-                        field: "target"
-                    });
-                }
-                if (target.success.includes(0))
-                    return new ImageError({ code: "InvalidStructure", field: "target" });
-                declarations.set(key, Image.Record.cases.symlink.make({
-                    id: String(paths.size),
-                    metadata: metadata("symlink", overrides),
-                    target: CanonicalBase64.encode(target.success)
-                }));
-            }
-        });
-        if (error instanceof ImageError)
-            return yield* error;
-    }
-    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 || Image.Record.guards.directory(node)) {
-            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?._tag !== "directory" || child === undefined || name === undefined) {
-            return yield* new ImageError({ code: "InvalidStructure", field: "parent" });
-        }
-        const entries = children.get(parent.id) ?? [];
-        entries.push({ name: CanonicalBase64.encode(nameBytes(name)), target: child.id });
-        children.set(parent.id, entries);
-    }
-    const records = [...new Set(declarations.values())].map((record) => Image.Record.match(record, {
-        directory: (record) => ({ ...record, entries: children.get(record.id) ?? [] }),
-        file: (record) => record,
-        symlink: (record) => record
-    }));
-    const snapshot = yield* Image.capture({ format: "effect-vfs", version: 1, root: "root", records }, undefined, true);
-    const image = yield* Image.inspect(snapshot);
-    const { identity, ...volumeOptions } = config.success;
-    if (identity === undefined)
-        return yield* makeVolume(VolumeSource.Snapshot({ image }), volumeOptions);
-    return yield* makeVolume(VolumeSource.Snapshot({ image }), {
-        ...volumeOptions,
-        identity: VolumeIdentity.make(identity)
-    });
-});

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

@@ -1,15 +0,0 @@
-import type { Snapshot } from "../../Snapshot.js";
-import * as Image from "../image.js";
-/** @internal */
-export interface Content {
-    readonly bytes: Uint8Array;
-}
-/** @internal */
-export declare const hasOverlayContents: (snapshot: Snapshot) => boolean;
-/** @internal */
-export declare const make: (bytes: Uint8Array) => Content;
-/** @internal */
-export declare const empty: () => Content;
-/** @internal */
-export declare const forOverlay: (snapshot: Snapshot, image: Image.Document) => ReadonlyMap<string, Content>;
-//# sourceMappingURL=overlayContent.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"overlayContent.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/overlayContent.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAEjD,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,CAiBjG,CAAA"}

package/dist/internal/virtualFileSystem/overlayContent.js

@@ -1,29 +0,0 @@
-// Immutable regular-file payloads shared by overlay workspaces.
-import * as Result from "effect/Result";
-import * as Schema from "effect/Schema";
-import { CanonicalBase64 } from "../canonicalBase64.js";
-import * as Image from "../image.js";
-const overlayContents = new WeakMap();
-/** @internal */
-export const hasOverlayContents = (snapshot) => overlayContents.has(snapshot);
-/** @internal */
-export const make = (bytes) => ({ bytes });
-/** @internal */
-export const empty = () => make(new Uint8Array(0));
-// 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)
-        return cached;
-    const decoded = new Map();
-    for (const record of image.records) {
-        if (Image.Record.guards.file(record)) {
-            const bytes = Schema.decodeResult(CanonicalBase64.Bytes)(record.data);
-            if (Result.isSuccess(bytes))
-                decoded.set(record.id, make(bytes.success));
-        }
-    }
-    overlayContents.set(snapshot, decoded);
-    return decoded;
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"overlayDiff.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/overlayDiff.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,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,cAAc,CAAA;CAClC;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;AA4DH,gBAAgB;AAChB,eAAO,MAAM,cAAc,SACnB,aAAa,CAAC,gBAAgB,CAAC,WAC5B,aAAa,CAAC,gBAAgB,CAAC,kCAEvC,aAAa,CAAC,gBAAgB,CAgFhC,CAAA"}

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

@@ -1 +0,0 @@
-{"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;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAE3D,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAGrC,gBAAgB;AAChB,eAAO,MAAM,SAAS,OAAO,CAAA;AAE7B,gBAAgB;AAChB,eAAO,MAAM,OAAO,OAAO,CAAA;AAE3B,gBAAgB;AAChB,eAAO,MAAM,WAAW,SAAS,CAAA;AAEjC,gBAAgB;AAChB,eAAO,MAAM,UAAU,KAAK,CAAA;AAG5B,gBAAgB;AAChB,eAAO,MAAM,cAAc,MAAM,CAAA;AAKjC,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,0CAI7D,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,MAAM,KAAG,UAAyD,CAAA;AAgBlG,gBAAgB;AAChB,eAAO,MAAM,eAAe,UAAW,UAAU,KAAG,OAC2C,CAAA;AAE/F,gBAAgB;AAChB,eAAO,MAAM,aAAa,iFASxB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,WAAW,4EAMtB,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;AAoBD,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,OAAO,CAgDrC,CAAA"}

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

@@ -1,22 +0,0 @@
-import * as Effect from "effect/Effect";
-import { FsError } from "./errors.js";
-/** @internal */
-export type CommitOutcome = "committed" | "rejected" | "unknown";
-/** @internal */
-export interface CommitProvider<State> {
-    /** Provides a gate-coordinated shutdown effect once staging is ready. */
-    readonly onReady?: (shutdown: Effect.Effect<void>) => void;
-    /** Checks and encodes a candidate before the commit boundary. Failure leaves the volume available. */
-    readonly prepare?: (candidate: State) => Effect.Effect<void, FsError>;
-    /** Classifies a candidate as committed, definitely rejected, or uncertain. */
-    readonly commit: (candidate: State) => Effect.Effect<CommitOutcome>;
-}
-/** @internal */
-export declare const makeStagedState: <State, Event = never>(initial: State, copy: (current: State) => Effect.Effect<State>, rawProvider: CommitProvider<State>, publish?: (candidate: State, events: ReadonlyArray<Event>) => void) => {
-    read: <A, E, R>(operation: string, inspect: (state: Readonly<State>) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | FsError, R>;
-    mutate: <A, E, R>(operation: string, change: (candidate: State, emit: (event: Event) => void) => Effect.Effect<A, E, R>, onStorageFailure?: () => void) => Effect.Effect<A, E | FsError, R>;
-    coordinate: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-    checkAvailable: (operation: string) => Effect.Effect<void, FsError, never>;
-    shutdown: Effect.Effect<void, never, never>;
-};
-//# sourceMappingURL=stagedState.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"stagedState.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/stagedState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAErC,gBAAgB;AAChB,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,CAAA;AAEhE,gBAAgB;AAChB,MAAM,WAAW,cAAc,CAAC,KAAK;IACnC,yEAAyE;IACzE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,CAAA;IAC1D,sGAAsG;IACtG,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;IACrE,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAA;CACpE;AAED,gBAAgB;AAChB,eAAO,MAAM,eAAe,GAAI,KAAK,EAAE,KAAK,mBACjC,KAAK,QAER,CAAC,OAAO,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,eACjC,cAAc,CAAC,KAAK,CAAC,YACxB,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,IAAI;WAyBpD,CAAC,EAAE,CAAC,EAAE,CAAC,aAAa,MAAM,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;aAOrF,CAAC,EAAE,CAAC,EAAE,CAAC,aACV,MAAM,UACT,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,qBAC/D,MAAM,IAAI;iBAhBX,CAAC,EAAE,CAAC,EAAE,CAAC,UAAU,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;gCAPxB,MAAM;;CA0E1C,CAAA"}

package/dist/internal/virtualFileSystem/stagedState.js

@@ -1,62 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Semaphore from "effect/Semaphore";
-import { FsError } from "./errors.js";
-/** @internal */
-export const makeStagedState = (initial, 
-// The copy must detach every mutable value that change can reach.
-copy, rawProvider, publish) => {
-    const gate = Semaphore.makeUnsafe(1);
-    const provider = {
-        ...rawProvider,
-        commit: (candidate) => Effect.suspend(() => rawProvider.commit(candidate))
-    };
-    let current = initial;
-    let available = true;
-    const checkAvailable = (operation) => Effect.suspend(() => available
-        ? Effect.void
-        : Effect.fail(new FsError({ code: "VolumeUnavailable", operation })));
-    const coordinate = (effect) => gate.withPermit(effect);
-    const shutdown = coordinate(Effect.sync(() => {
-        available = false;
-    }));
-    const read = (operation, inspect) => coordinate(Effect.gen(function* () {
-        yield* checkAvailable(operation);
-        return yield* inspect(current);
-    }));
-    const mutate = (operation, change, onStorageFailure) => coordinate(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
-        yield* checkAvailable(operation);
-        const candidate = yield* restore(copy(current));
-        const events = [];
-        const value = yield* restore(change(candidate, (event) => events.push(event)));
-        if (provider.prepare !== undefined)
-            yield* restore(provider.prepare(candidate));
-        const committed = yield* Effect.exit(Effect.suspend(() => provider.commit(candidate)));
-        if (Exit.isFailure(committed)) {
-            available = false;
-            onStorageFailure?.();
-            return yield* new FsError({ code: "OutcomeUnknown", operation });
-        }
-        const outcome = committed.value;
-        if (outcome === "rejected") {
-            if (onStorageFailure !== undefined) {
-                available = false;
-                onStorageFailure();
-            }
-            return yield* new FsError({ code: "StorageRejected", operation });
-        }
-        if (outcome === "unknown") {
-            available = false;
-            onStorageFailure?.();
-            return yield* new FsError({ code: "OutcomeUnknown", operation });
-        }
-        current = candidate;
-        const published = yield* Effect.exit(Effect.sync(() => publish?.(candidate, events)));
-        if (Exit.isFailure(published)) {
-            available = false;
-            return yield* new FsError({ code: "OutcomeUnknown", operation });
-        }
-        return value;
-    })));
-    return { read, mutate, coordinate, checkAvailable, shutdown };
-};

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

@@ -1,20 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,IAMpF,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,IAMlF,CAAA"}

package/dist/internal/virtualFileSystem/testHooks.js

@@ -1,23 +0,0 @@
-// 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

@@ -1,16 +0,0 @@
-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, E = never> {
-    readonly publishUnsafe: (event: () => A) => void;
-    readonly publishManyUnsafe: (events: () => Iterable<A>) => void;
-    readonly subscribe: (afterSubscribe?: Effect.Effect<void>) => Effect.Effect<Stream.Stream<A>, E, Scope.Scope>;
-}
-/** @internal */
-export declare const make: <A, E = never>(coordinate: Coordinator, capacity: number, rescan: () => A, checkAvailable?: Effect.Effect<void, E, never> | undefined) => Effect.Effect<WatchHub<A, E>, never, never>;
-//# sourceMappingURL=watchHub.d.ts.map

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

@@ -1 +0,0 @@
-{"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,EAAE,CAAC,GAAG,KAAK;IACpC,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,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;CAC9G;AAQD,gBAAgB;AAChB,eAAO,MAAM,IAAI,GAA+B,CAAC,EAAE,CAAC,mEAGpC,CAAC,4GAiEf,CAAA"}

package/dist/internal/virtualFileSystem/watchHub.js

@@ -1,54 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Queue from "effect/Queue";
-import * as Stream from "effect/Stream";
-/** @internal */
-export const make = Effect.fnUntraced(function* (coordinate, capacity, rescan, checkAvailable) {
-    const subscribers = new Set();
-    const publish = (event) => {
-        for (const subscriber of subscribers) {
-            if (subscriber.overflowed)
-                continue;
-            if (Queue.sizeUnsafe(subscriber.queue) < capacity - 1) {
-                Queue.offerUnsafe(subscriber.queue, event);
-            }
-            else {
-                subscriber.overflowed = true;
-                subscriber.marker = rescan();
-                Queue.offerUnsafe(subscriber.queue, subscriber.marker);
-            }
-        }
-    };
-    const publishUnsafe = (event) => {
-        if (subscribers.size > 0)
-            publish(event());
-    };
-    const publishManyUnsafe = (events) => {
-        if (subscribers.size > 0) {
-            for (const event of events())
-                publish(event);
-        }
-    };
-    const subscribe = (afterSubscribe) => Effect.acquireRelease(coordinate(Effect.gen(function* () {
-        if (checkAvailable !== undefined)
-            yield* checkAvailable;
-        const queue = yield* Queue.bounded(capacity);
-        const subscriber = {
-            queue,
-            overflowed: false,
-            marker: undefined
-        };
-        if (afterSubscribe !== undefined)
-            yield* afterSubscribe;
-        subscribers.add(subscriber);
-        return subscriber;
-    })), (subscriber) => coordinate(Effect.sync(() => {
-        subscribers.delete(subscriber);
-    })).pipe(Effect.andThen(Queue.shutdown(subscriber.queue))), { interruptible: true }).pipe(Effect.map((subscriber) => Stream.fromEffectRepeat(Queue.take(subscriber.queue)).pipe(Stream.map((event) => {
-        if (subscriber.overflowed && event === subscriber.marker) {
-            subscriber.overflowed = false;
-            subscriber.marker = undefined;
-        }
-        return event;
-    }))));
-    return { publishUnsafe, publishManyUnsafe, subscribe };
-});