@effect-vfs/core 0.8.0 → 0.10.0

package/dist/internal/path.js

@@ -1,141 +0,0 @@
-import * as ByteSize from "effect/ByteSize";
-import * as Effect from "effect/Effect";
-import * as Hex from "effect/encoding/Hex";
-import * as Predicate from "effect/Predicate";
-import * as Result from "effect/Result";
-import { getBytes as getBytePathBytes, make as makeBytePath } from "./bytePath.js";
-import { fsFailure } from "./errors.js";
-/** @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;
-const DOT_BYTE = 46;
-/** @internal */
-export const NUL_BYTE = 0;
-/** @internal */
-export const MAX_SYMLINK_TRAVERSALS = 40;
-/** @internal */
-export const MAX_NAME_BYTES = 255;
-/** @internal */
-export const isNameBytes = (name) => name.length >= 1 && name.length <= MAX_NAME_BYTES && !name.includes(NUL_BYTE) && !name.includes(SLASH_BYTE) &&
-    !(name.length === 1 && name[0] === DOT_BYTE) && !(name.length === 2 && name[0] === DOT_BYTE && name[1] === DOT_BYTE);
-/** @internal */
-export const ROOT_PATH = new Uint8Array([SLASH_BYTE]);
-/** @internal */
-export const joinPath = (prefix, name) => {
-    const separator = prefix.length === 0 || prefix[prefix.length - 1] === SLASH_BYTE ? 0 : 1;
-    const joined = new Uint8Array(prefix.length + separator + name.length);
-    joined.set(prefix);
-    if (separator === 1)
-        joined[prefix.length] = SLASH_BYTE;
-    joined.set(name, prefix.length + separator);
-    return joined;
-};
-// A missing final component follows the same rejection path as "." and ".."; callers choose the POSIX error code.
-/** @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: () => fsFailure("UnrepresentableName", operation)
-});
-/** @internal */
-export const nameBytes = (name) => Result.getOrThrow(Hex.decode(name));
-// Constructing a view detects detached buffers, including empty ones.
-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;
-    }
-};
-// Reject shared or detached buffers before copying; Buffer subclasses remain valid.
-/** @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* fsFailure("InvalidArgument", "pathFromBytes");
-    const owned = new Uint8Array(bytes);
-    if (owned.length === 0 || owned.includes(0)) {
-        return yield* fsFailure("InvalidArgument", "pathFromBytes");
-    }
-    return makeBytePath(owned);
-});
-/** @internal */
-export const pathToBytes = Effect.fn("VirtualFileSystem.pathToBytes")(function* (path) {
-    const bytes = getBytePathBytes(path);
-    if (bytes === undefined)
-        return yield* fsFailure("InvalidArgument", "pathToBytes");
-    return new Uint8Array(bytes);
-});
-// String.prototype.isWellFormed requires ES2024; this package targets ES2023.
-/** @internal */
-export const isWellFormed = (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();
-/** @internal */
-export const inputBytes = (input) => Predicate.isString(input)
-    ? isWellFormed(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"
-            ? fsFailure("InvalidPathEncoding", operation, { path: input })
-            : fsFailure("InvalidArgument", operation));
-    }
-    const bytes = encoded.success;
-    if (bytes.length === 0)
-        return Result.fail(fsFailure("NotFound", operation, { path: input }));
-    if (bytes.includes(0))
-        return Result.fail(fsFailure("InvalidArgument", operation, { path: input }));
-    if (maxPathBytes !== undefined && ByteSize.isGreaterThan(ByteSize.bytes(bytes.length), maxPathBytes)) {
-        return Result.fail(fsFailure("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(fsFailure("PathTooLong", operation, { path: input }));
-            }
-            components.push(Hex.encode(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/resolution.d.ts

@@ -1,135 +0,0 @@
-import * as ByteSize from "effect/ByteSize";
-import * as Effect from "effect/Effect";
-import * as Result from "effect/Result";
-import type { Identity } from "../Caller.js";
-import { type EntryInput, type NameInput, type Target } from "../Target.js";
-import type { FsFailure } from "../VfsError.js";
-import type { DirectoryHandle, PathInput } from "../VirtualFileSystem.js";
-import type { OpContext } from "./errors.js";
-import { type PreparedPath } from "./path.js";
-import * as TokenRegistry from "./tokenRegistry.js";
-import { type Directory, type Ino, type Node } from "./volumeState.js";
-/** @internal */
-export type PreparedEntry = {
-    readonly kind: "path";
-    readonly path: PreparedPath;
-    readonly base: DirectoryHandle | undefined;
-} | {
-    readonly kind: "entry";
-    readonly directory: Target;
-    readonly name: string;
-};
-/** @internal */
-export interface NodeMode<R = never> {
-    readonly kind: "Node";
-    readonly followFinalSymlink?: boolean;
-    readonly final?: boolean;
-    readonly createMissing?: (parent: Directory, name: string, final: boolean) => Effect.Effect<Directory, FsFailure, R>;
-}
-/** @internal */
-export interface ParentMode {
-    readonly kind: "Parent";
-}
-/** @internal */
-export interface OrCreateMode<R = never> {
-    readonly kind: "OrCreate";
-    readonly create: "never" | "ifMissing" | "exclusive";
-    readonly finalSymlink: "follow" | "preserve";
-    readonly entryExclusive?: "afterSymlink";
-    readonly beforeFollow?: (parent: Directory, child: Node | undefined) => Effect.Effect<void, FsFailure, R>;
-}
-/** @internal */
-export type NodeResult = {
-    readonly kind: "node";
-    readonly node: Node;
-    readonly op: OpContext;
-} | {
-    readonly kind: "entry";
-    readonly node: Node;
-    readonly parent: Directory;
-    readonly name: string;
-    readonly op: OpContext;
-};
-/** @internal */
-export interface ParentResult {
-    readonly kind: "parent";
-    readonly parent: Ino;
-    readonly name: string | undefined;
-    readonly trailingSlash: boolean;
-    readonly addressing: "path" | "entry";
-    readonly op: OpContext;
-}
-interface CreateEntry {
-    readonly parent: Directory;
-    readonly name: string;
-    readonly trailingSlash: boolean;
-    readonly addressing: "path" | "entry";
-    readonly op: OpContext;
-    readonly origin: {
-        readonly parent: Directory;
-        readonly name: string;
-    };
-}
-/** @internal */
-export type CreateResult = (CreateEntry & {
-    readonly kind: "existing";
-    readonly node: Node;
-}) | (CreateEntry & {
-    readonly kind: "missing";
-});
-/** @internal */
-export declare const inGroup: (identity: Identity, gid: number) => boolean;
-/** @internal */
-export declare const permitted: (node: Node, identity: Identity) => number;
-/** @internal */
-export declare const authorize: (node: Node, identity: Identity, bits: number, op: OpContext) => Effect.Effect<void, never, never> | Effect.Effect<never, FsFailure, never>;
-/** @internal */
-export declare const entryName: (input: NameInput, op: OpContext) => Result.Result<string, FsFailure>;
-/** @internal */
-export declare const make: ({ caller, get, identity, maxPathBytes, registry }: {
-    readonly caller: TokenRegistry.DirectoryReference;
-    readonly get: (ino: Ino) => Effect.Effect<Node | undefined>;
-    readonly identity: Identity;
-    readonly maxPathBytes: ByteSize.ByteSize | undefined;
-    readonly registry: TokenRegistry.TokenRegistry;
-}) => {
-    prepare: (input: PathInput, op: OpContext) => Result.Result<PreparedPath, FsFailure>;
-    prepareEntry: (input: EntryInput, op: OpContext) => Result.Result<PreparedEntry, FsFailure>;
-    resolve: {
-        <R = never>(target: Target, mode: NodeMode<R>, op: OpContext): Effect.Effect<NodeResult, FsFailure, R>;
-        (prepared: PreparedEntry, mode: ParentMode, op: OpContext): Effect.Effect<ParentResult, FsFailure>;
-        <R = never>(prepared: PreparedEntry, mode: OrCreateMode<R>, op: OpContext): Effect.Effect<CreateResult, FsFailure, R>;
-    };
-    directory: (target: {
-        readonly _tag: "Handle";
-        readonly handle: import("../VirtualFileSystem.js").FileHandle | DirectoryHandle;
-    } | {
-        readonly _tag: "Path";
-        readonly path: PathInput;
-        readonly relativeTo?: DirectoryHandle;
-        readonly followFinalSymlink?: boolean;
-    } | {
-        readonly _tag: "Reference";
-        readonly reference: import("../VirtualFileSystem.js").ObjectReference;
-    }, op: OpContext) => Effect.Effect<{
-        node: Directory;
-        op: OpContext;
-    }, FsFailure, never>;
-    entryDirectory: (target: {
-        readonly _tag: "Handle";
-        readonly handle: import("../VirtualFileSystem.js").FileHandle | DirectoryHandle;
-    } | {
-        readonly _tag: "Path";
-        readonly path: PathInput;
-        readonly relativeTo?: DirectoryHandle;
-        readonly followFinalSymlink?: boolean;
-    } | {
-        readonly _tag: "Reference";
-        readonly reference: import("../VirtualFileSystem.js").ObjectReference;
-    }, op: OpContext) => Effect.Effect<{
-        node: Directory;
-        op: OpContext;
-    }, FsFailure, never>;
-};
-export {};
-//# sourceMappingURL=resolution.d.ts.map

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

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

package/dist/internal/resolution.js

@@ -1,277 +0,0 @@
-import * as ByteSize from "effect/ByteSize";
-import * as Effect from "effect/Effect";
-import * as Hex from "effect/encoding/Hex";
-import * as Predicate from "effect/Predicate";
-import * as Result from "effect/Result";
-import { isEntry, isTarget } from "../Target.js";
-import { DOT_DOT_HEX, DOT_HEX, isAttachedBytes, isDotComponent, isWellFormed, MAX_NAME_BYTES, MAX_SYMLINK_TRAVERSALS, nameBytes, ownedPath, preparePath, SLASH_BYTE } from "./path.js";
-import * as TokenRegistry from "./tokenRegistry.js";
-import { ROOT_INO } from "./volumeState.js";
-const encoder = new TextEncoder();
-/** @internal */
-export const inGroup = (identity, gid) => identity.gid === gid || identity.groups.includes(gid);
-/** @internal */
-export const permitted = (node, identity) => {
-    const shift = identity.uid === node.metadata.uid ? 6 : inGroup(identity, node.metadata.gid) ? 3 : 0;
-    return (node.metadata.mode >> shift) & 0o7;
-};
-/** @internal */
-export const authorize = (node, identity, bits, op) => identity.privileged || (permitted(node, identity) & bits) === bits
-    ? Effect.void
-    : Effect.fail(op.fail("AccessDenied"));
-/** @internal */
-export const entryName = (input, op) => {
-    if (Predicate.isString(input) && !isWellFormed(input))
-        return Result.fail(op.fail("InvalidPathEncoding"));
-    const bytes = Predicate.isString(input) ? encoder.encode(input) : input;
-    if (!isAttachedBytes(bytes) || bytes.length === 0 || bytes.length > MAX_NAME_BYTES || bytes.includes(0) ||
-        bytes.includes(SLASH_BYTE))
-        return Result.fail(op.fail("InvalidArgument"));
-    return Result.succeed(Hex.encode(new Uint8Array(bytes)));
-};
-/** @internal */
-export const make = ({ caller, get, identity, maxPathBytes, registry }) => {
-    const prepare = (input, op) => preparePath(input, op.operation, maxPathBytes);
-    const prepareEntry = (input, op) => isEntry(input)
-        ? Result.map(entryName(input.name, op), (name) => ({ kind: "entry", directory: input.directory, name }))
-        : isTarget(input)
-            ? Result.map(prepare(input.path, op), (path) => ({ kind: "path", path, base: input.relativeTo }))
-            : Result.map(prepare(input, op), (path) => ({ kind: "path", path, base: undefined }));
-    const nodeAt = Effect.fnUntraced(function* (ino) {
-        const node = yield* get(ino);
-        return node === undefined ? yield* Effect.die("Inode left the table during resolution") : node;
-    });
-    const directoryAt = Effect.fnUntraced(function* (ino) {
-        const node = yield* nodeAt(ino);
-        return node.kind !== "directory" ? yield* Effect.die("Directory left the table during resolution") : node;
-    });
-    const callerDirectory = Effect.fnUntraced(function* (op) {
-        const ino = TokenRegistry.inode(caller);
-        const node = ino === undefined ? undefined : yield* get(ino);
-        return node?.kind !== "directory" ? yield* op.fail("ClosedCaller") : node;
-    });
-    const walk = Effect.fnUntraced(function* (path, base, op, mode, referencedBase) {
-        const pathOp = op.at(path.input);
-        const parentOnly = mode.kind === "Parent";
-        const allowMissing = mode.kind === "OrCreate" && mode.create !== "never";
-        const followFinalSymlink = mode.kind === "Node"
-            ? mode.followFinalSymlink !== false
-            : mode.kind === "Parent" || mode.finalSymlink === "follow";
-        const createMissing = mode.kind === "Node" ? mode.createMissing : undefined;
-        if (!TokenRegistry.isOpen(caller)) {
-            return yield* pathOp.fail("ClosedCaller");
-        }
-        let current = path.absolute ? (yield* nodeAt(ROOT_INO)) : yield* callerDirectory(pathOp);
-        if (!path.absolute && referencedBase !== undefined) {
-            current = referencedBase;
-            yield* authorize(current, identity, 0o1, op);
-        }
-        else if (!path.absolute && base !== undefined) {
-            const directory = yield* TokenRegistry.nodeOrFail(yield* registry.resolve(base, "directory"), "handle", pathOp);
-            if (directory.kind !== "directory")
-                return yield* pathOp.fail("InvalidHandle");
-            current = directory;
-            yield* authorize(current, identity, 0o1, pathOp);
-        }
-        if (current.metadata.nlink === 0) {
-            return yield* pathOp.fail("NotFound");
-        }
-        let work = path;
-        let parent;
-        let name;
-        let traversals = 0;
-        // Leading components that came from a symbolic link's target. Only the components the caller wrote are
-        // created, so a dangling link stays missing, as it does for mkdir -p.
-        let linked = 0;
-        for (let index = 0; index < work.components.length - (parentOnly ? 1 : 0); index++) {
-            if (current.kind !== "directory") {
-                return yield* pathOp.fail("NotDirectory");
-            }
-            yield* authorize(current, identity, 0o1, pathOp);
-            const component = work.components[index];
-            if (component === undefined)
-                break;
-            if (component === DOT_HEX)
-                continue;
-            if (component === DOT_DOT_HEX) {
-                current = yield* directoryAt(current.parent);
-                parent = undefined;
-                name = undefined;
-                continue;
-            }
-            parent = current;
-            name = component;
-            const childIno = current.entries.get(component);
-            const child = childIno === undefined ? undefined : (yield* get(childIno));
-            if (child === undefined) {
-                if (allowMissing && index === work.components.length - 1) {
-                    return { kind: "missing", parent, name, op: pathOp };
-                }
-                if (createMissing !== undefined && index >= linked) {
-                    current = yield* createMissing(current, component, index === work.components.length - 1);
-                    continue;
-                }
-                return yield* pathOp.fail("NotFound");
-            }
-            if (child.kind === "symlink" && (followFinalSymlink || index < work.components.length - 1 || work.trailingSlash)) {
-                if (child.target.length === 0) {
-                    return yield* pathOp.fail("NotFound");
-                }
-                if (++traversals > MAX_SYMLINK_TRAVERSALS) {
-                    return yield* pathOp.fail("SymlinkLoop");
-                }
-                const suffix = work.suffixes[index] ?? new Uint8Array(0);
-                const remaining = work.components.length - index - 1;
-                if (maxPathBytes !== undefined &&
-                    ByteSize.isGreaterThan(ByteSize.bytes(child.target.length + suffix.length), maxPathBytes)) {
-                    return yield* pathOp.fail("PathTooLong");
-                }
-                const expansion = new Uint8Array(child.target.length + suffix.length);
-                expansion.set(child.target);
-                expansion.set(suffix, child.target.length);
-                const expanded = preparePath(ownedPath(expansion), op.operation, maxPathBytes);
-                // The expansion is synthetic: its per-component limits are the caller's to hear about,
-                // but the path in the error has to be the one the caller passed in, so the
-                // expansion's own failure is not kept as the cause.
-                if (Result.isFailure(expanded)) {
-                    return yield* pathOp.fail(expanded.failure.code);
-                }
-                work = expanded.success;
-                linked = work.components.length - remaining + Math.max(0, linked - index - 1);
-                if (work.absolute)
-                    current = yield* nodeAt(ROOT_INO);
-                index = -1;
-            }
-            else
-                current = child;
-        }
-        if (!parentOnly && work.trailingSlash && current.kind !== "directory") {
-            return yield* pathOp.fail("NotDirectory");
-        }
-        return parent === undefined || name === undefined
-            ? { kind: "node", node: current, op: pathOp }
-            : { kind: "entry", node: current, parent, name, op: pathOp };
-    });
-    const resolveNode = Effect.fnUntraced(function* (target, mode, op) {
-        if (Predicate.isTagged(target, "Path")) {
-            const path = yield* Effect.fromResult(prepare(target.path, op));
-            const result = yield* walk(path, target.relativeTo, op, {
-                ...mode,
-                followFinalSymlink: mode.final === true
-                    ? mode.followFinalSymlink ?? true
-                    : target.followFinalSymlink ?? mode.followFinalSymlink ?? true
-            });
-            return result.kind === "missing" ? yield* result.op.fail("NotFound") : result;
-        }
-        if (!TokenRegistry.isOpen(caller))
-            return yield* op.fail("ClosedCaller");
-        const node = yield* TokenRegistry.nodeOrFail(yield* (Predicate.isTagged(target, "Reference")
-            ? registry.resolve(target.reference, "reference")
-            : registry.resolve(target.handle, "handle")), Predicate.isTagged(target, "Reference") ? "reference" : "handle", op);
-        return { kind: "node", node, op };
-    });
-    const directory = Effect.fnUntraced(function* (target, op) {
-        const resolved = yield* resolveNode(target, { kind: "Node" }, op);
-        if (resolved.node.kind !== "directory")
-            return yield* resolved.op.fail("NotDirectory");
-        return { node: resolved.node, op: resolved.op };
-    });
-    const entryDirectory = Effect.fnUntraced(function* (target, op) {
-        const resolved = yield* directory(target, op);
-        if (resolved.node.metadata.nlink === 0)
-            return yield* resolved.op.fail("NotFound");
-        return resolved;
-    });
-    const parent = Effect.fnUntraced(function* (prepared, op) {
-        if (prepared.kind === "entry") {
-            const resolved = yield* entryDirectory(prepared.directory, op);
-            return {
-                kind: "parent",
-                parent: resolved.node.ino,
-                name: prepared.name,
-                trailingSlash: false,
-                addressing: "entry",
-                op
-            };
-        }
-        const resolved = yield* walk(prepared.path, prepared.base, op, { kind: "Parent" });
-        if (resolved.kind === "missing")
-            return yield* resolved.op.fail("NotFound");
-        if (resolved.node.kind !== "directory")
-            return yield* resolved.op.fail("NotDirectory");
-        return {
-            kind: "parent",
-            parent: resolved.node.ino,
-            name: prepared.path.components.at(-1),
-            trailingSlash: prepared.path.trailingSlash,
-            addressing: "path",
-            op: resolved.op
-        };
-    });
-    const creationResult = (result, trailingSlash, addressing, op, origin) => {
-        if (result.kind === "node")
-            return Effect.fail(op.fail("IsDirectory"));
-        const entry = {
-            parent: result.parent,
-            name: result.name,
-            trailingSlash,
-            addressing,
-            op,
-            origin: origin ?? { parent: result.parent, name: result.name }
-        };
-        return Effect.succeed(result.kind === "missing" ? { ...entry, kind: "missing" } : { ...entry, kind: "existing", node: result.node });
-    };
-    const orCreate = Effect.fnUntraced(function* (prepared, mode, op) {
-        if (prepared.kind === "path") {
-            const pathOp = op.at(prepared.path.input);
-            if (mode.create === "exclusive") {
-                const exists = yield* Effect.result(walk(prepared.path, prepared.base, op, { kind: "Node", followFinalSymlink: false }));
-                if (Result.isSuccess(exists))
-                    return yield* pathOp.fail("AlreadyExists");
-                if (exists.failure.code !== "NotFound")
-                    return yield* exists.failure;
-            }
-            return yield* creationResult(yield* walk(prepared.path, prepared.base, op, mode), prepared.path.trailingSlash, "path", pathOp);
-        }
-        const { node: parent } = yield* entryDirectory(prepared.directory, op);
-        if (isDotComponent(prepared.name))
-            return yield* op.fail("InvalidArgument");
-        yield* authorize(parent, identity, 0o1, op);
-        const directIno = parent.entries.get(prepared.name);
-        const direct = directIno === undefined ? undefined : yield* get(directIno);
-        if (mode.beforeFollow !== undefined)
-            yield* mode.beforeFollow(parent, direct);
-        if (mode.create === "exclusive" && mode.entryExclusive !== "afterSymlink" && direct !== undefined) {
-            return yield* op.fail("AlreadyExists");
-        }
-        let result = direct === undefined
-            ? { kind: "missing", parent, name: prepared.name, op }
-            : { kind: "entry", node: direct, parent, name: prepared.name, op };
-        if (direct?.kind === "symlink" && mode.finalSymlink === "follow") {
-            const path = yield* Effect.fromResult(preparePath(ownedPath(nameBytes(prepared.name)), op.operation, undefined));
-            result = yield* walk(path, undefined, op, mode, parent);
-            // Entry writeFile rejects a followed directory before checking exclusive creation.
-            if (mode.create === "exclusive" && mode.entryExclusive === "afterSymlink" &&
-                (result.kind === "node" || (result.kind === "entry" && result.node.kind === "directory"))) {
-                return yield* op.fail("IsDirectory");
-            }
-        }
-        if (result.kind === "missing" && mode.create === "never")
-            return yield* op.fail("NotFound");
-        if (mode.create === "exclusive" && mode.entryExclusive === "afterSymlink" && result.kind !== "missing") {
-            return yield* op.fail("AlreadyExists");
-        }
-        return yield* creationResult(result, false, "entry", op, { parent, name: prepared.name });
-    });
-    function resolve(input, mode, op) {
-        if (isTarget(input)) {
-            return mode.kind === "Node" ? resolveNode(input, mode, op) : Effect.die("A node target requires Node resolution");
-        }
-        return mode.kind === "Parent"
-            ? parent(input, op)
-            : mode.kind === "OrCreate"
-                ? orCreate(input, mode, op)
-                : Effect.die("An entry requires Parent or OrCreate resolution");
-    }
-    return { prepare, prepareEntry, resolve, directory, entryDirectory };
-};

package/dist/internal/testSeams.d.ts

@@ -1,17 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-/** @internal */
-export interface VolumeTestSeams {
-    readonly afterSubscribe: Effect.Effect<void>;
-    readonly betweenSnapshotAndSummary: Effect.Effect<void>;
-    readonly beforeTreeRemoval: Effect.Effect<void>;
-}
-/**
- * Read in the caller's fiber, so a test supplies it with `withVolumeTestSeams` on the call under test.
- *
- * @internal
- */
-export declare const VolumeTestSeams: Context.Reference<VolumeTestSeams>;
-/** @internal */
-export declare const withVolumeTestSeams: (seams: Partial<VolumeTestSeams>) => <XA, E, R>(self: Effect.Effect<XA, E, R>) => Effect.Effect<XA, E, R>;
-//# sourceMappingURL=testSeams.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"testSeams.d.ts","sourceRoot":"","sources":["../../src/internal/testSeams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,gBAAgB;AAChB,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC5C,QAAQ,CAAC,yBAAyB,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAEvD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAChD;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,OAAO,CAAC,SAAS,CAAC,eAAe,CAS9D,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,UAAW,OAAO,CAAC,eAAe,CAAC,yEAK9D,CAAA"}

package/dist/internal/testSeams.js

@@ -1,20 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-/**
- * Read in the caller's fiber, so a test supplies it with `withVolumeTestSeams` on the call under test.
- *
- * @internal
- */
-export const VolumeTestSeams = Context.Reference("@effect-vfs/core/VolumeTestSeams", {
-    defaultValue: () => ({
-        afterSubscribe: Effect.void,
-        betweenSnapshotAndSummary: Effect.void,
-        beforeTreeRemoval: Effect.void
-    })
-});
-/** @internal */
-export const withVolumeTestSeams = (seams) => Effect.updateService(VolumeTestSeams, (current) => ({
-    afterSubscribe: seams.afterSubscribe ?? current.afterSubscribe,
-    betweenSnapshotAndSummary: seams.betweenSnapshotAndSummary ?? current.betweenSnapshotAndSummary,
-    beforeTreeRemoval: seams.beforeTreeRemoval ?? current.beforeTreeRemoval
-}));