@effect-vfs/core 0.9.0 → 0.10.0

package/dist/internal/resolution.js

@@ -1,332 +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 { make as makeConfinement } from "./confinement.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();
-const EMPTY_AUTHORITIES = [];
-/** @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, confinement, additional, authorityView }) => {
-    const visibleRoot = confinement?.root ?? ROOT_INO;
-    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* (lookup, ino) {
-        const node = lookup(ino);
-        return node === undefined ? yield* Effect.die("Inode left the table during resolution") : node;
-    });
-    const directoryAt = Effect.fnUntraced(function* (lookup, ino) {
-        const node = yield* nodeAt(lookup, ino);
-        return node.kind !== "directory" ? yield* Effect.die("Directory left the table during resolution") : node;
-    });
-    const callerDirectory = Effect.fnUntraced(function* (lookup, op) {
-        const ino = TokenRegistry.inode(caller);
-        const node = ino === undefined ? undefined : lookup(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 baseAuthorities = base === undefined
-            ? EMPTY_AUTHORITIES
-            : registry.handleBoundaries(base).map((roots) => makeConfinement(authorityView, roots));
-        const authorizeDirectory = baseAuthorities.length === 0 ? authorize : Effect.fnUntraced(function* (node, callerIdentity, bits, context) {
-            for (const authority of baseAuthorities)
-                yield* authority.check(node, context, true);
-            yield* authorize(node, callerIdentity, bits, context);
-        });
-        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");
-        }
-        if (additional !== undefined && additional.length > 0) {
-            for (const authority of additional)
-                yield* authority.alive(pathOp);
-        }
-        if (confinement !== undefined)
-            yield* confinement.alive(pathOp);
-        if (path.absolute && base !== undefined &&
-            (confinement !== undefined || (additional?.length ?? 0) > 0 || baseAuthorities.length > 0)) {
-            const node = yield* TokenRegistry.nodeOrFail(yield* registry.resolve(base, "directory"), "handle", pathOp);
-            yield* registry.authorizeHandle(base, node, pathOp);
-            if (confinement !== undefined)
-                yield* confinement.check(node, pathOp);
-            if (additional !== undefined && additional.length > 0) {
-                for (const authority of additional)
-                    yield* authority.check(node, pathOp);
-            }
-        }
-        // Reads remain live so recursive creation can revisit nodes added earlier in this walk.
-        const lookup = yield* authorityView;
-        let current = path.absolute ? (yield* nodeAt(lookup, visibleRoot)) : yield* callerDirectory(lookup, 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");
-            yield* registry.authorizeHandle(base, directory, pathOp);
-            current = directory;
-            yield* authorize(current, identity, 0o1, pathOp);
-        }
-        if (confinement !== undefined)
-            yield* confinement.check(current, pathOp);
-        if (additional !== undefined && additional.length > 0) {
-            for (const authority of additional)
-                yield* authority.check(current, 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* authorizeDirectory(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(lookup, confinement !== undefined && current.ino === visibleRoot ? current.ino : current.parent);
-                parent = undefined;
-                name = undefined;
-                continue;
-            }
-            parent = current;
-            name = component;
-            const childIno = current.entries.get(component);
-            const child = childIno === undefined ? undefined : lookup(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(lookup, visibleRoot);
-                index = -1;
-            }
-            else
-                current = child;
-        }
-        if (baseAuthorities.length > 0) {
-            for (const authority of baseAuthorities)
-                yield* authority.check(current, pathOp, true);
-        }
-        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);
-        if (!Predicate.isTagged(target, "Reference"))
-            yield* registry.authorizeHandle(target.handle, node, op);
-        if (confinement !== undefined)
-            yield* confinement.check(node, op);
-        if (additional !== undefined && additional.length > 0) {
-            for (const authority of additional)
-                yield* authority.check(node, 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));
-            // Following an entry link must retain the directory capability's boundaries.
-            const base = Predicate.isTagged(prepared.directory, "Handle")
-                ? prepared.directory.handle
-                : Predicate.isTagged(prepared.directory, "Path")
-                    ? prepared.directory.relativeTo
-                    : undefined;
-            result = yield* walk(path, base, 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
-}));

package/dist/internal/tokenRegistry.d.ts

@@ -1,83 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Scope from "effect/Scope";
-import type { FsFailure } from "../VfsError.js";
-import type { DirectoryHandle, FileHandle, ObjectReference } from "../VirtualFileSystem.js";
-import type { OpContext } from "./errors.js";
-import type { Ino, Node } from "./volumeState.js";
-/** @internal */
-export type HandleLifecycle = {
-    readonly kind: "acquiring";
-} | {
-    readonly kind: "open";
-    readonly ino: Ino;
-} | {
-    readonly kind: "releasedPendingCommit";
-    readonly ino: Ino | undefined;
-} | {
-    readonly kind: "closed";
-};
-/** @internal */
-export interface HandleReference {
-    readonly volume: symbol;
-    lifecycle: HandleLifecycle;
-    namespaceRoots?: ReadonlyArray<Ino> | undefined;
-    boundaries?: ReadonlyArray<ReadonlyArray<Ino>> | undefined;
-    authority?: ((node: Node, op: OpContext) => Effect.Effect<void, FsFailure>) | undefined;
-    scope: Scope.Closeable | undefined;
-}
-/** @internal */
-export interface FileReference extends HandleReference {
-    offset: bigint;
-    readonly access: "read" | "write" | "readWrite";
-    readonly append: boolean;
-}
-/** @internal */
-export type DirectoryReference = HandleReference;
-/** @internal */
-export type Token = ObjectReference | FileHandle | DirectoryHandle;
-/** @internal */
-export type Resolution = {
-    readonly kind: "unknown";
-} | {
-    readonly kind: "foreign";
-} | {
-    readonly kind: "stale";
-} | {
-    readonly kind: "live";
-    readonly node: Node;
-};
-/** @internal */
-export declare const inode: (reference: HandleReference) => Ino | undefined;
-/** @internal */
-export declare const isOpen: (reference: HandleReference) => boolean;
-/** @internal */
-export declare const publish: (reference: HandleReference, ino: Ino) => void;
-/** @internal */
-export declare const released: (reference: HandleReference) => void;
-/** @internal */
-export declare const release: <E, R>(reference: HandleReference, releaseInode: (ino: Ino) => Effect.Effect<void, E, R>, afterRelease: (action: () => void) => Effect.Effect<void, never, R>) => Effect.Effect<void, E, R>;
-/** @internal */
-export declare const closeReleasedScope: (reference: HandleReference) => Effect.Effect<void, never, never>;
-/** @internal */
-export declare const finalize: (reference: HandleReference, close: Effect.Effect<unknown, FsFailure>, fallback: Effect.Effect<void>) => Effect.Effect<void, never, never>;
-/** @internal */
-export declare const acquire: <A, E, R, ReleaseR, CoordinateR>(reference: HandleReference, coordinate: (acquire: Effect.Effect<A, E, R | ReleaseR>) => Effect.Effect<A, E | FsFailure, CoordinateR>, acquisition: Effect.Effect<A, E, R>, releaseAcquired: () => Effect.Effect<void, never, ReleaseR>, finalizer: Effect.Effect<void, never, never>) => Effect.Effect<A, E | FsFailure, CoordinateR | Scope.Scope>;
-/** @internal */
-export declare const nodeOrFail: (result: Resolution, addressing: "reference" | "handle", op: OpContext) => Effect.Effect<never, FsFailure, never> | Effect.Effect<Node, never, never>;
-/** @internal */
-export declare const make: (volume: symbol, get: (ino: Ino) => Effect.Effect<Node | undefined>) => {
-    referenceIdentity: (token: ObjectReference, op: OpContext) => Effect.Effect<Ino, FsFailure>;
-    handleBoundaries: (token: Token) => readonly (readonly Ino[])[];
-    authorizeHandle: (token: Token, node: Node, op: OpContext) => Effect.Effect<void, FsFailure, never>;
-    resolve: (token: Token, addressing: "reference" | "handle" | "directory") => Effect.Effect<Resolution, never, never>;
-    resolveInode: (ino: Ino) => Effect.Effect<Resolution>;
-    referenceFor: (ino: Ino) => ObjectReference;
-    forget: (ino: Ino) => boolean;
-    file: (access: FileReference["access"], append: boolean) => FileReference;
-    directory: (ino?: Ino) => DirectoryReference;
-    registerFile: (handle: FileHandle, reference: FileReference) => WeakMap<object, FileReference>;
-    registerDirectory: (handle: DirectoryHandle, reference: DirectoryReference) => WeakMap<object, HandleReference>;
-};
-/** @internal */
-export type TokenRegistry = ReturnType<typeof make>;
-//# sourceMappingURL=tokenRegistry.d.ts.map

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

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

package/dist/internal/tokenRegistry.js

@@ -1,146 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Predicate from "effect/Predicate";
-import * as Scope from "effect/Scope";
-import { ObjectReferenceId } from "../Caller.js";
-// Shared across volumes so a genuine token from another registry is distinguishable from a forgery.
-const references = new WeakMap();
-const files = new WeakMap();
-const directories = new WeakMap();
-/** @internal */
-export const inode = (reference) => reference.lifecycle.kind === "open" || reference.lifecycle.kind === "releasedPendingCommit"
-    ? reference.lifecycle.ino
-    : undefined;
-/** @internal */
-export const isOpen = (reference) => reference.lifecycle.kind === "open";
-/** @internal */
-export const publish = (reference, ino) => {
-    reference.lifecycle = reference.lifecycle.kind === "releasedPendingCommit" || reference.lifecycle.kind === "closed"
-        ? { kind: "releasedPendingCommit", ino }
-        : { kind: "open", ino };
-};
-/** @internal */
-export const released = (reference) => {
-    reference.lifecycle = reference.lifecycle.kind === "acquiring" ||
-        (reference.lifecycle.kind === "releasedPendingCommit" && reference.lifecycle.ino === undefined)
-        ? { kind: "releasedPendingCommit", ino: undefined }
-        : { kind: "closed" };
-};
-// A release callback changes the engine's draft; publication may be immediate cleanup or after installation.
-/** @internal */
-export const release = Effect.fnUntraced(function* (reference, releaseInode, afterRelease) {
-    const ino = inode(reference);
-    yield* afterRelease(() => released(reference));
-    if (ino !== undefined)
-        yield* releaseInode(ino);
-});
-/** @internal */
-export const closeReleasedScope = (reference) => Effect.suspend(() => isOpen(reference) || reference.scope === undefined ? Effect.void : Scope.close(reference.scope, Exit.void));
-// The inode, rather than the open tag, decides whether a rerun must release a late publication.
-/** @internal */
-export const finalize = (reference, close, fallback) => Effect.uninterruptible(Effect.suspend(() => {
-    if (inode(reference) === undefined) {
-        // Check and mark together: acquisition can publish between separate Effect steps.
-        released(reference);
-        return Effect.void;
-    }
-    return Effect.ignore(close).pipe(Effect.andThen(Effect.suspend(() => inode(reference) === undefined ? Effect.void : fallback)));
-}));
-// Register before waiting: a closed scope runs its finalizer immediately, and engine permits are not reentrant.
-/** @internal */
-export const acquire = Effect.fnUntraced(function* (reference, coordinate, acquisition, releaseAcquired, finalizer) {
-    const scope = yield* Scope.fork(yield* Effect.scope);
-    reference.scope = scope;
-    yield* Scope.addFinalizer(scope, finalizer);
-    const closed = () => Predicate.isTagged(scope.state, "Closed");
-    return yield* coordinate(Effect.suspend(() => closed() ? Effect.interrupt : acquisition).pipe(Effect.tap(() => Effect.suspend(() => closed() ? Effect.andThen(releaseAcquired(), Effect.interrupt) : Effect.void)))).pipe(Effect.tap(() => Effect.suspend(() => closed() ? Effect.interrupt : Effect.void)), Effect.onError(() => Effect.andThen(finalizer, Scope.close(scope, Exit.void))), Effect.onError(() => Effect.sync(() => {
-        if (reference.lifecycle.kind === "releasedPendingCommit" && reference.lifecycle.ino === undefined) {
-            reference.lifecycle = { kind: "closed" };
-        }
-    })));
-});
-/** @internal */
-export const nodeOrFail = (result, addressing, op) => {
-    switch (result.kind) {
-        case "live":
-            return Effect.succeed(result.node);
-        case "unknown":
-            return Effect.fail(op.fail(addressing === "reference" ? "InvalidReference" : "InvalidHandle"));
-        case "foreign":
-            return Effect.fail(op.fail(addressing === "reference" ? "ForeignReference" : "ForeignHandle"));
-        case "stale":
-            return Effect.fail(op.fail(addressing === "reference" ? "StaleReference" : "InvalidHandle"));
-    }
-};
-/** @internal */
-export const make = (volume, get) => {
-    const tokens = new Map();
-    const resolveInode = (ino) => Effect.map(get(ino), (node) => node === undefined || (node.kind === "directory" && node.metadata.nlink === 0)
-        ? { kind: "stale" }
-        : { kind: "live", node });
-    const resolveReference = (token) => Effect.suspend(() => {
-        const known = Predicate.isObject(token) ? references.get(token) : undefined;
-        if (known === undefined)
-            return Effect.succeed({ kind: "unknown" });
-        if (known.volume !== volume)
-            return Effect.succeed({ kind: "foreign" });
-        return resolveInode(known.ino);
-    });
-    const resolveHandle = (token, directoryOnly = false) => Effect.suspend(() => {
-        const known = Predicate.isObject(token)
-            ? directories.get(token) ?? (directoryOnly ? undefined : files.get(token))
-            : undefined;
-        if (known === undefined)
-            return Effect.succeed({ kind: "unknown" });
-        if (known.volume !== volume)
-            return Effect.succeed({ kind: "foreign" });
-        if (!isOpen(known))
-            return Effect.succeed({ kind: "stale" });
-        const ino = inode(known);
-        return ino === undefined
-            ? Effect.succeed({ kind: "stale" })
-            : Effect.map(get(ino), (node) => node === undefined ? { kind: "stale" } : { kind: "live", node });
-    });
-    return {
-        referenceIdentity: (token, op) => {
-            const known = Predicate.isObject(token) ? references.get(token) : undefined;
-            if (known === undefined)
-                return Effect.fail(op.fail("InvalidReference"));
-            if (known.volume !== volume)
-                return Effect.fail(op.fail("ForeignReference"));
-            return Effect.succeed(known.ino);
-        },
-        handleBoundaries: (token) => (files.get(token) ?? directories.get(token))?.boundaries ?? [],
-        authorizeHandle: (token, node, op) => {
-            const reference = files.get(token) ?? directories.get(token);
-            return reference?.authority?.(node, op) ?? Effect.void;
-        },
-        resolve: (token, addressing) => addressing === "reference" ? resolveReference(token) : resolveHandle(token, addressing === "directory"),
-        resolveInode,
-        referenceFor: (ino) => {
-            const existing = tokens.get(ino);
-            if (existing !== undefined)
-                return existing;
-            const reference = Object.freeze({ [ObjectReferenceId]: true });
-            references.set(reference, { volume, ino });
-            tokens.set(ino, reference);
-            return reference;
-        },
-        forget: (ino) => tokens.delete(ino),
-        file: (access, append) => ({
-            volume,
-            lifecycle: { kind: "acquiring" },
-            scope: undefined,
-            offset: 0n,
-            access,
-            append
-        }),
-        directory: (ino) => ({
-            volume,
-            lifecycle: ino === undefined ? { kind: "acquiring" } : { kind: "open", ino },
-            scope: undefined
-        }),
-        registerFile: (handle, reference) => files.set(handle, reference),
-        registerDirectory: (handle, reference) => directories.set(handle, reference)
-    };
-};

package/dist/internal/turnstile.d.ts

@@ -1,8 +0,0 @@
-import * as Effect from "effect/Effect";
-/** @internal */
-export interface Turnstile {
-    readonly withTurn: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-}
-/** @internal */
-export declare const makeTurnstile: () => Turnstile;
-//# sourceMappingURL=turnstile.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"turnstile.d.ts","sourceRoot":"","sources":["../../src/internal/turnstile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,gBAAgB;AAChB,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACvF;AASD,gBAAgB;AAChB,eAAO,MAAM,aAAa,QAAO,SAkDhC,CAAA"}