@effect-vfs/core 0.2.0 → 0.3.1

package/dist/internal/virtualFileSystem/path.js

@@ -0,0 +1,127 @@
+// 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 Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+import { getBytes as getBytePathBytes, make as makeBytePath } from "../bytePath.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 SLASH_HEX = "2f";
+/** @internal */
+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: () => new FsError({ code: "UnrepresentableName", operation })
+});
+/** @internal */
+export const nameBytes = (name) => Result.getOrThrow(Encoding.decodeHex(name));
+// A zero-length view distinguishes a detached buffer from a valid empty buffer.
+const attachedBuffer = (bytes) => {
+    try {
+        const probe = new Uint8Array(bytes.buffer, bytes.byteOffset, 0);
+        return probe.byteLength === 0;
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return false;
+        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 (!isAttachedBytes(bytes))
+        return yield* new FsError({ code: "InvalidArgument", operation: "pathFromBytes" });
+    const owned = new Uint8Array(bytes);
+    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* new FsError({ code: "InvalidArgument", operation: "pathToBytes" });
+    return new Uint8Array(bytes);
+});
+// 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) {
+            const next = value.charCodeAt(++index);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return false;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff)
+            return false;
+    }
+    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) => {
+    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 }));
+    }
+    const bytes = encoded.success;
+    if (bytes.length === 0)
+        return Result.fail(new FsError({ code: "NotFound", operation, path: input }));
+    if (bytes.includes(0))
+        return Result.fail(new FsError({ code: "InvalidArgument", operation, path: input }));
+    if (maxPathBytes !== undefined && ByteSize.isGreaterThan(ByteSize.bytes(bytes.length), maxPathBytes)) {
+        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] !== SLASH_BYTE)
+            continue;
+        if (index > start) {
+            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));
+        }
+        start = index + 1;
+    }
+    return Result.succeed({
+        input,
+        absolute: bytes[0] === SLASH_BYTE,
+        trailingSlash: bytes.at(-1) === SLASH_BYTE,
+        bytes,
+        suffixes,
+        components
+    });
+};

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,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

@@ -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":"AACA,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;AAGD,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,sEAmC/C,CAAA"}

package/dist/internal/virtualFileSystem/watchHub.js

@@ -0,0 +1,33 @@
+// Change broadcasting for Volume.watch: one PubSub per volume, published to only while someone listens.
+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();
+    // Guarded by `coordinate`: publishers run inside coordinated mutations and both writes below hold the gate.
+    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);
+    };
+    // Registration is uninterruptible end to end, including the permit wait, so a watcher is never
+    // half-registered. This deliberately tightens the engine's "permit waits stay interruptible" rule.
+    const subscribe = (afterSubscribe) => Effect.acquireRelease(coordinate(Effect.gen(function* () {
+        const subscription = yield* PubSub.subscribe(pubsub);
+        if (afterSubscribe !== undefined)
+            yield* afterSubscribe;
+        activeSubscribers += 1;
+        return subscription;
+    })), () => coordinate(Effect.sync(() => {
+        activeSubscribers -= 1;
+    }))).pipe(Effect.map(Stream.fromSubscription));
+    return { publishUnsafe, publishManyUnsafe, subscribe };
+});

package/dist/internal/virtualFileSystem.d.ts

@@ -0,0 +1,366 @@
+import * as ByteSize from "effect/ByteSize";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { BytePath } from "../BytePath.js";
+import { ImageError, type Snapshot } from "../Snapshot.js";
+import type { Caller, OverlayVolume, RelativeOptions, Volume } from "../VirtualFileSystem.js";
+import * as Image from "./image.js";
+import { ConfigurationError, FsCode as FsCodeSchema, FsError } from "./virtualFileSystem/errors.js";
+/** @internal */
+export declare const VolumeId: unique symbol;
+/** @internal */
+export declare const CallerId: unique symbol;
+/** @internal */
+export declare const FileHandleId: unique symbol;
+/** @internal */
+export declare const DirectoryHandleId: unique symbol;
+/** @internal */
+export declare const ObjectReferenceId: unique symbol;
+/** @internal */
+export { ConfigurationError, FsCodeSchema as FsCode, FsError };
+/** @internal */
+export declare const Identity: Schema.Struct<{
+    readonly uid: Schema.Natural;
+    readonly gid: Schema.Natural;
+    readonly groups: Schema.$Array<Schema.Natural>;
+    readonly privileged: Schema.Boolean;
+}>;
+/** @internal */
+export type Identity = typeof Identity.Type;
+/** @internal */
+export declare const RootCallerOptions: Schema.Struct<{
+    readonly identity: Schema.optionalKey<Schema.Struct<{
+        readonly uid: Schema.Natural;
+        readonly gid: Schema.Natural;
+        readonly groups: Schema.$Array<Schema.Natural>;
+        readonly privileged: Schema.Boolean;
+    }>>;
+    readonly umask: Schema.optionalKey<Schema.Natural>;
+}>;
+/** @internal */
+export type RootCallerOptions = typeof RootCallerOptions.Type;
+/** @internal */
+export declare const VolumeOptions: Schema.Struct<{
+    readonly maxEntries: Schema.optionalKey<Schema.Natural>;
+    readonly maxBytes: Schema.optionalKey<Schema.ByteSize>;
+    readonly maxFileBytes: Schema.optionalKey<Schema.ByteSize>;
+    readonly maxPathBytes: Schema.optionalKey<Schema.ByteSize>;
+}>;
+/** @internal */
+export type VolumeOptions = typeof VolumeOptions.Type;
+/** @internal */
+export declare const Metadata: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+    readonly ino: Schema.BigInt;
+    readonly nlink: Schema.Natural;
+    readonly size: Schema.BigInt;
+    readonly uid: Schema.Natural;
+    readonly gid: Schema.Natural;
+    readonly mode: Schema.Natural;
+    readonly atimeNs: Schema.BigInt;
+    readonly mtimeNs: Schema.BigInt;
+    readonly ctimeNs: Schema.BigInt;
+    readonly birthtimeNs: Schema.BigInt;
+}>;
+/** @internal */
+export type Metadata = typeof Metadata.Type;
+/** @internal */
+export declare const OwnerUpdate: Schema.Struct<{
+    readonly uid: Schema.optionalKey<Schema.Natural>;
+    readonly gid: Schema.optionalKey<Schema.Natural>;
+}>;
+/** @internal */
+export type OwnerUpdate = typeof OwnerUpdate.Type;
+/** @internal */
+export declare const TimeUpdate: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"now">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"omit">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"value">;
+    readonly nanoseconds: Schema.BigInt;
+}>]>;
+/** @internal */
+export declare const Times: Schema.Struct<{
+    readonly access: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"now">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"omit">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"value">;
+        readonly nanoseconds: Schema.BigInt;
+    }>]>;
+    readonly modification: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"now">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"omit">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"value">;
+        readonly nanoseconds: Schema.BigInt;
+    }>]>;
+}>;
+/** @internal */
+export type Times = typeof Times.Type;
+/** @internal */
+export declare const SeekMode: Schema.Literals<readonly ["start", "current", "end", "data", "hole"]>;
+/** @internal */
+export type SeekMode = typeof SeekMode.Type;
+/** @internal */
+export declare const OpenSettings: Schema.Struct<{
+    readonly access: Schema.Literals<readonly ["read", "write", "readWrite"]>;
+    readonly create: Schema.optionalKey<Schema.Literals<readonly ["never", "ifMissing", "exclusive"]>>;
+    readonly mode: Schema.optionalKey<Schema.Natural>;
+    readonly append: Schema.optionalKey<Schema.Boolean>;
+    readonly truncate: Schema.optionalKey<Schema.Boolean>;
+    readonly followFinalSymlink: Schema.optionalKey<Schema.Boolean>;
+}>;
+/** @internal */
+export type OpenOptions = typeof OpenSettings.Type & RelativeOptions;
+declare const WriteFileSettings: Schema.Struct<{
+    readonly access: Schema.Literals<readonly ["read", "write", "readWrite"]>;
+    readonly create: Schema.optionalKey<Schema.Literals<readonly ["never", "ifMissing", "exclusive"]>>;
+    readonly mode: Schema.optionalKey<Schema.Natural>;
+    readonly append: Schema.optionalKey<Schema.Boolean>;
+    readonly truncate: Schema.optionalKey<Schema.Boolean>;
+    readonly followFinalSymlink: Schema.optionalKey<Schema.Boolean>;
+    readonly replaceFinalSymlink: Schema.optionalKey<Schema.Boolean>;
+    readonly finalMode: Schema.optionalKey<Schema.Natural>;
+}>;
+/** @internal */
+export type WriteFileOptions = typeof WriteFileSettings.Type & RelativeOptions;
+/** @internal */
+export declare const OverlayNodeKind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+/** @internal */
+export type OverlayNodeKind = typeof OverlayNodeKind.Type;
+/** @internal */
+export declare const OverlayDifference: Schema.Literals<readonly ["content", "mode", "uid", "gid", "atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]>;
+/** @internal */
+export type OverlayDifference = typeof OverlayDifference.Type;
+/** @internal */
+export declare const OverlayChange: Schema.Union<readonly [Schema.TaggedStruct<"Added", {
+    readonly path: Schema.declare<BytePath, BytePath>;
+    readonly kind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+}>, Schema.TaggedStruct<"Removed", {
+    readonly path: Schema.declare<BytePath, BytePath>;
+    readonly kind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+}>, Schema.TaggedStruct<"Replaced", {
+    readonly path: Schema.declare<BytePath, BytePath>;
+    readonly beforeKind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+    readonly afterKind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+    readonly differences: Schema.$Array<Schema.Literals<readonly ["content", "mode", "uid", "gid", "atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]>>;
+}>, Schema.TaggedStruct<"Renamed", {
+    readonly from: Schema.declare<BytePath, BytePath>;
+    readonly to: Schema.declare<BytePath, BytePath>;
+    readonly kind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+    readonly differences: Schema.$Array<Schema.Literals<readonly ["content", "mode", "uid", "gid", "atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]>>;
+}>, Schema.TaggedStruct<"Updated", {
+    readonly path: Schema.declare<BytePath, BytePath>;
+    readonly kind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+    readonly differences: Schema.$Array<Schema.Literals<readonly ["content", "mode", "uid", "gid", "atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]>>;
+}>]>;
+/** @internal */
+export type OverlayChange = typeof OverlayChange.Type;
+/** @internal */
+export declare const OverlayChangesOptions: Schema.Struct<{
+    readonly includeTimestamps: Schema.optionalKey<Schema.Boolean>;
+}>;
+/** @internal */
+export type OverlayChangesOptions = typeof OverlayChangesOptions.Type;
+declare const CurrentFileSystem_base: Context.ServiceClass<CurrentFileSystem, "@effect-vfs/core/CurrentFileSystem", Caller>;
+/** @internal */
+export declare class CurrentFileSystem extends CurrentFileSystem_base {
+}
+/** @internal */
+export declare const FixtureMetadata: Schema.Struct<{
+    readonly uid: Schema.optionalKey<Schema.Natural>;
+    readonly gid: Schema.optionalKey<Schema.Natural>;
+    readonly mode: Schema.optionalKey<Schema.Natural>;
+    readonly atimeNs: Schema.optionalKey<Schema.BigInt>;
+    readonly mtimeNs: Schema.optionalKey<Schema.BigInt>;
+    readonly ctimeNs: Schema.optionalKey<Schema.BigInt>;
+    readonly birthtimeNs: Schema.optionalKey<Schema.BigInt>;
+}>;
+/** @internal */
+export declare const FixtureEntry: Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"directory">;
+    readonly path: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly metadata: Schema.optionalKey<Schema.Struct<{
+        readonly uid: Schema.optionalKey<Schema.Natural>;
+        readonly gid: Schema.optionalKey<Schema.Natural>;
+        readonly mode: Schema.optionalKey<Schema.Natural>;
+        readonly atimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly mtimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly ctimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly birthtimeNs: Schema.optionalKey<Schema.BigInt>;
+    }>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"file">;
+    readonly path: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly bytes: Schema.Uint8Array;
+    readonly metadata: Schema.optionalKey<Schema.Struct<{
+        readonly uid: Schema.optionalKey<Schema.Natural>;
+        readonly gid: Schema.optionalKey<Schema.Natural>;
+        readonly mode: Schema.optionalKey<Schema.Natural>;
+        readonly atimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly mtimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly ctimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly birthtimeNs: Schema.optionalKey<Schema.BigInt>;
+    }>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"symlink">;
+    readonly path: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly target: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly metadata: Schema.optionalKey<Schema.Struct<{
+        readonly uid: Schema.optionalKey<Schema.Natural>;
+        readonly gid: Schema.optionalKey<Schema.Natural>;
+        readonly mode: Schema.optionalKey<Schema.Natural>;
+        readonly atimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly mtimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly ctimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly birthtimeNs: Schema.optionalKey<Schema.BigInt>;
+    }>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"hardLink">;
+    readonly path: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly target: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+}>]>;
+/** @internal */
+export declare const Fixture: Schema.Struct<{
+    readonly rootMetadata: Schema.optionalKey<Schema.Struct<{
+        readonly uid: Schema.optionalKey<Schema.Natural>;
+        readonly gid: Schema.optionalKey<Schema.Natural>;
+        readonly mode: Schema.optionalKey<Schema.Natural>;
+        readonly atimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly mtimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly ctimeNs: Schema.optionalKey<Schema.BigInt>;
+        readonly birthtimeNs: Schema.optionalKey<Schema.BigInt>;
+    }>>;
+    readonly entries: Schema.$Array<Schema.toTaggedUnion<"kind", readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"directory">;
+        readonly path: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+        readonly metadata: Schema.optionalKey<Schema.Struct<{
+            readonly uid: Schema.optionalKey<Schema.Natural>;
+            readonly gid: Schema.optionalKey<Schema.Natural>;
+            readonly mode: Schema.optionalKey<Schema.Natural>;
+            readonly atimeNs: Schema.optionalKey<Schema.BigInt>;
+            readonly mtimeNs: Schema.optionalKey<Schema.BigInt>;
+            readonly ctimeNs: Schema.optionalKey<Schema.BigInt>;
+            readonly birthtimeNs: Schema.optionalKey<Schema.BigInt>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"file">;
+        readonly path: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+        readonly bytes: Schema.Uint8Array;
+        readonly metadata: Schema.optionalKey<Schema.Struct<{
+            readonly uid: Schema.optionalKey<Schema.Natural>;
+            readonly gid: Schema.optionalKey<Schema.Natural>;
+            readonly mode: Schema.optionalKey<Schema.Natural>;
+            readonly atimeNs: Schema.optionalKey<Schema.BigInt>;
+            readonly mtimeNs: Schema.optionalKey<Schema.BigInt>;
+            readonly ctimeNs: Schema.optionalKey<Schema.BigInt>;
+            readonly birthtimeNs: Schema.optionalKey<Schema.BigInt>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"symlink">;
+        readonly path: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+        readonly target: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+        readonly metadata: Schema.optionalKey<Schema.Struct<{
+            readonly uid: Schema.optionalKey<Schema.Natural>;
+            readonly gid: Schema.optionalKey<Schema.Natural>;
+            readonly mode: Schema.optionalKey<Schema.Natural>;
+            readonly atimeNs: Schema.optionalKey<Schema.BigInt>;
+            readonly mtimeNs: Schema.optionalKey<Schema.BigInt>;
+            readonly ctimeNs: Schema.optionalKey<Schema.BigInt>;
+            readonly birthtimeNs: Schema.optionalKey<Schema.BigInt>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"hardLink">;
+        readonly path: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+        readonly target: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    }>]>>;
+}>;
+/** @internal */
+export type Fixture = typeof Fixture.Type;
+type VolumeSource = {
+    readonly _tag: "Empty";
+} | {
+    readonly _tag: "Snapshot";
+    readonly image: Image.Document;
+} | {
+    readonly _tag: "Overlay";
+    readonly base: Snapshot;
+    readonly image: Image.Document;
+};
+/** @internal */
+export declare const VolumeSource: {
+    readonly $is: <Tag extends "Empty" | "Overlay" | "Snapshot">(tag: Tag) => (u: unknown) => u is Extract<{
+        readonly _tag: "Empty";
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Snapshot";
+        readonly image: Image.Document;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Overlay";
+        readonly base: Snapshot;
+        readonly image: Image.Document;
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends { readonly [Tag in "Empty" | "Overlay" | "Snapshot"]: (args: Extract<VolumeSource, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: VolumeSource) => import("effect/Unify").Unify<ReturnType<Cases["Empty" | "Overlay" | "Snapshot"]>>;
+        <Cases extends { readonly [Tag in "Empty" | "Overlay" | "Snapshot"]: (args: Extract<VolumeSource, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: VolumeSource, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Empty" | "Overlay" | "Snapshot"]>>;
+    };
+    readonly Empty: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Empty";
+    }, "_tag">;
+    readonly Overlay: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Overlay";
+        readonly base: Snapshot;
+        readonly image: Image.Document;
+    }, "_tag">;
+    readonly Snapshot: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Snapshot";
+        readonly image: Image.Document;
+    }, "_tag">;
+};
+type VolumeFor<S extends VolumeSource> = S extends {
+    readonly _tag: "Overlay";
+} ? OverlayVolume : Volume;
+/** @internal */
+export declare const makeVolume: <S extends VolumeSource>(source: S, options?: {
+    readonly maxEntries?: number;
+    readonly maxBytes?: ByteSize.ByteSize;
+    readonly maxFileBytes?: ByteSize.ByteSize;
+    readonly maxPathBytes?: ByteSize.ByteSize;
+} | undefined) => Effect.Effect<VolumeFor<S>, ConfigurationError | ImageError, never>;
+/** @internal */
+export declare const make: (options?: {
+    readonly maxEntries?: number;
+    readonly maxBytes?: ByteSize.ByteSize;
+    readonly maxFileBytes?: ByteSize.ByteSize;
+    readonly maxPathBytes?: ByteSize.ByteSize;
+} | undefined) => Effect.Effect<Volume, ConfigurationError, never>;
+/** @internal */
+export declare const fromSnapshot: (snapshot: Snapshot, options?: {
+    readonly maxEntries?: number;
+    readonly maxBytes?: ByteSize.ByteSize;
+    readonly maxFileBytes?: ByteSize.ByteSize;
+    readonly maxPathBytes?: ByteSize.ByteSize;
+} | undefined) => Effect.Effect<Volume, ConfigurationError | ImageError, never>;
+/** @internal */
+export declare const makeOverlay: (base: Snapshot, options?: {
+    readonly maxEntries?: number;
+    readonly maxBytes?: ByteSize.ByteSize;
+    readonly maxFileBytes?: ByteSize.ByteSize;
+    readonly maxPathBytes?: ByteSize.ByteSize;
+} | undefined) => Effect.Effect<OverlayVolume, ConfigurationError | ImageError, never>;
+//# sourceMappingURL=virtualFileSystem.d.ts.map

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

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