@effect-vfs/core 0.3.0 → 0.4.0

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

@@ -1,12 +1,21 @@
 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 { BytePath } from "../../BytePath.js";
 import type { PathInput } from "../../VirtualFileSystem.js";
-import { ConfigurationError, type FsCode, FsError } from "./errors.js";
+import { FsError } from "./errors.js";
 /** @internal */
-export declare const failure: (code: FsCode, operation: string, path?: PathInput) => FsError;
+export declare const SLASH_HEX = "2f";
+/** @internal */
+export declare const DOT_HEX = "2e";
+/** @internal */
+export declare const DOT_DOT_HEX = "2e2e";
+/** @internal */
+export declare const SLASH_BYTE = 47;
+/** @internal */
+export declare const MAX_NAME_BYTES = 255;
+/** @internal */
+export declare const isDotComponent: (name: string | undefined) => name is undefined | typeof DOT_HEX | typeof DOT_DOT_HEX;
 /** @internal */
 export declare const ownedPath: (bytes: Uint8Array) => BytePath;
 /** @internal */
@@ -14,18 +23,12 @@ export declare const strictString: (bytes: Uint8Array, operation: string) => Eff
 /** @internal */
 export declare const nameBytes: (name: string) => Uint8Array;
 /** @internal */
-export declare const attachedBuffer: (bytes: Uint8Array) => boolean;
+export declare const isAttachedBytes: (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;
@@ -35,9 +38,7 @@ export interface PreparedPath {
     readonly components: ReadonlyArray<string>;
 }
 /** @internal */
-export declare const wellFormed: (value: string) => boolean;
+export declare const inputBytes: (input: PathInput) => Result.Result<Uint8Array, "InvalidPathEncoding" | "InvalidArgument">;
 /** @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

@@ -1 +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"}
+{"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/path.js

@@ -2,33 +2,41 @@
 import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
+import * as Predicate from "effect/Predicate";
 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";
+import { FsError } from "./errors.js";
+// Components are hex-encoded bytes so names compare as bytes, not text: 2f is "/", 2e is ".", 2e2e is "..".
 /** @internal */
-export const failure = (code, operation, path) => new FsError({ code, operation, ...(path === undefined ? {} : { path }) });
+export const SLASH_HEX = "2f";
 /** @internal */
-export const ownedPath = (bytes) => {
-    return makeBytePath(bytes);
-};
+export const DOT_HEX = "2e";
+/** @internal */
+export const DOT_DOT_HEX = "2e2e";
+/** @internal */
+export const SLASH_BYTE = 47;
+// POSIX NAME_MAX: the longest single path component.
+/** @internal */
+export const MAX_NAME_BYTES = 255;
+// A missing final component is rejected wherever "." and ".." are, so it counts as a dot component.
+// Callers pass the code POSIX gives their operation, so the codes differ on purpose: EEXIST for
+// create (link, symlink, mkdir), EISDIR for open and unlink, EINVAL for rename and rmdir.
+/** @internal */
+export const isDotComponent = (name) => name === undefined || name === DOT_HEX || name === DOT_DOT_HEX;
+/** @internal */
+export const ownedPath = (bytes) => 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)
+    catch: () => new FsError({ code: "UnrepresentableName", operation })
 });
 /** @internal */
-export const nameBytes = (name) => {
-    return Result.getOrThrow(Encoding.decodeHex(name));
-};
+export const nameBytes = (name) => Result.getOrThrow(Encoding.decodeHex(name));
 // A zero-length view distinguishes a detached buffer from a valid empty buffer.
-/** @internal */
-export const attachedBuffer = (bytes) => {
+const attachedBuffer = (bytes) => {
     try {
-        new Uint8Array(bytes.buffer, bytes.byteOffset, 0);
-        return true;
+        const probe = new Uint8Array(bytes.buffer, bytes.byteOffset, 0);
+        return probe.byteLength === 0;
     }
     catch (error) {
         if (error instanceof TypeError)
@@ -36,27 +44,29 @@ export const attachedBuffer = (bytes) => {
         throw error;
     }
 };
+// Accepts any Uint8Array, subclasses such as Node's Buffer included; rejects views over a
+// SharedArrayBuffer or a detached buffer before the bytes are copied or trusted.
+/** @internal */
+export const isAttachedBytes = (bytes) => Predicate.isUint8Array(bytes) && bytes.buffer instanceof ArrayBuffer && attachedBuffer(bytes);
 /** @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");
+    if (!isAttachedBytes(bytes))
+        return yield* new FsError({ code: "InvalidArgument", operation: "pathFromBytes" });
     const owned = new Uint8Array(bytes);
-    if (owned.length === 0 || owned.includes(0))
-        return yield* failure("InvalidArgument", "pathFromBytes");
+    if (owned.length === 0 || owned.includes(0)) {
+        return yield* new FsError({ code: "InvalidArgument", operation: "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 yield* new FsError({ code: "InvalidArgument", operation: "pathToBytes" });
     return new Uint8Array(bytes);
 });
-/** @internal */
-export const wellFormed = (value) => {
+// Hand-rolled because String.prototype.isWellFormed is ES2024 and the package targets ES2023.
+const wellFormed = (value) => {
     for (let index = 0; index < value.length; index++) {
         const code = value.charCodeAt(index);
         if (code >= 0xd800 && code <= 0xdbff) {
@@ -69,36 +79,38 @@ export const wellFormed = (value) => {
     }
     return true;
 };
+const UTF8_ENCODER = new TextEncoder();
+// Strings must be well-formed UTF-16 before encoding; BytePaths must belong to this package.
+/** @internal */
+export const inputBytes = (input) => Predicate.isString(input)
+    ? wellFormed(input) ? Result.succeed(UTF8_ENCODER.encode(input)) : Result.fail("InvalidPathEncoding")
+    : Result.fromNullishOr(getBytePathBytes(input), () => "InvalidArgument");
 /** @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);
+    const encoded = inputBytes(input);
+    if (Result.isFailure(encoded)) {
+        return Result.fail(encoded.failure === "InvalidPathEncoding"
+            ? new FsError({ code: "InvalidPathEncoding", operation, path: input })
+            : new FsError({ code: "InvalidArgument", operation }));
     }
-    else if (typeof input === "object" && input !== null) {
-        bytes = getBytePathBytes(input);
-    }
-    if (bytes === undefined)
-        return Result.fail(failure("InvalidArgument", operation));
+    const bytes = encoded.success;
     if (bytes.length === 0)
-        return Result.fail(failure("NotFound", operation, input));
+        return Result.fail(new FsError({ code: "NotFound", operation, path: input }));
     if (bytes.includes(0))
-        return Result.fail(failure("InvalidArgument", operation, input));
+        return Result.fail(new FsError({ code: "InvalidArgument", operation, path: input }));
     if (maxPathBytes !== undefined && ByteSize.isGreaterThan(ByteSize.bytes(bytes.length), maxPathBytes)) {
-        return Result.fail(failure("PathTooLong", operation, input));
+        return Result.fail(new FsError({ code: "PathTooLong", operation, path: input }));
     }
     const components = [];
     const suffixes = [];
     let start = 0;
     for (let index = 0; index <= bytes.length; index++) {
-        if (index !== bytes.length && bytes[index] !== 47)
+        if (index !== bytes.length && bytes[index] !== SLASH_BYTE)
             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));
+            if (index - start > MAX_NAME_BYTES) {
+                return Result.fail(new FsError({ code: "PathTooLong", operation, path: input }));
+            }
             components.push(Encoding.encodeHex(bytes.subarray(start, index)));
             suffixes.push(bytes.subarray(index));
         }
@@ -106,19 +118,10 @@ export const preparePath = (input, operation, maxPathBytes) => {
     }
     return Result.succeed({
         input,
-        absolute: bytes[0] === 47,
-        trailingSlash: bytes.at(-1) === 47,
+        absolute: bytes[0] === SLASH_BYTE,
+        trailingSlash: bytes.at(-1) === SLASH_BYTE,
         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/stagedState.d.ts

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

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

@@ -0,0 +1,62 @@
+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.map

@@ -1 +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"}
+{"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/watchHub.d.ts

@@ -6,11 +6,11 @@ export interface Coordinator {
     <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
 }
 /** @internal */
-export interface WatchHub<A> {
+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>, never, Scope.Scope>;
+    readonly subscribe: (afterSubscribe?: Effect.Effect<void>) => Effect.Effect<Stream.Stream<A>, E, Scope.Scope>;
 }
 /** @internal */
-export declare const make: <A>(coordinate: Coordinator) => Effect.Effect<WatchHub<A>, never, never>;
+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 +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"}
+{"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,33 +1,54 @@
 import * as Effect from "effect/Effect";
-import * as PubSub from "effect/PubSub";
+import * as Queue from "effect/Queue";
 import * as Stream from "effect/Stream";
 /** @internal */
-export const make = Effect.fnUntraced(function* (coordinate) {
-    const pubsub = yield* PubSub.unbounded();
-    let activeSubscribers = 0;
+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 (activeSubscribers === 0)
-            return;
-        PubSub.publishUnsafe(pubsub, event());
+        if (subscribers.size > 0)
+            publish(event());
     };
     const publishManyUnsafe = (events) => {
-        if (activeSubscribers === 0)
-            return;
-        for (const event of events())
-            PubSub.publishUnsafe(pubsub, event);
+        if (subscribers.size > 0) {
+            for (const event of events())
+                publish(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);
-    }));
+    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 };
 });