@vibe-agent-toolkit/utils 0.2.0-rc.10 → 0.2.0-rc.12

package/dist/errors/fs-boundary.js

@@ -0,0 +1,121 @@
+/**
+ * `fsBoundary`: decide a fault's side from the path the OS named, against the
+ * roots each side owns. Built on the classifier (`fs-fault.ts`) and on
+ * `path-containment.ts`; it lives apart from the classifier so that the path
+ * helpers `path-containment.ts` itself imports can classify without a cycle.
+ */
+import { lstatSync } from 'node:fs';
+import { canonicalPath, isUnderRoot } from '../path-containment.js';
+import { fsFaultOf, isPathAbsentError, pathsActedOn } from './errno-table.js';
+import { classifyFsFault, FS_SIDES } from './fs-fault.js';
+/**
+ * Whether `candidate` is `root` itself or under it. `isUnderRoot` answers `outside`
+ * for the root itself (it needs a strict `root/` prefix), but a fault ON the root
+ * (`mkdir(outRoot)`, `stat(sourceRoot)`, creating the staging dir) is the commonest
+ * kind there is. A root the OS refuses to examine owns nothing; any other failure
+ * is a defect and propagates.
+ */
+function containedBy(root, candidate) {
+    try {
+        // Both are the verb's own roots and the paths it names: each is its own edge.
+        return canonicalPath(root, root) === canonicalPath(candidate, root) || isUnderRoot(root, candidate) !== 'outside';
+    }
+    catch (error) {
+        if (fsFaultOf(error) !== undefined)
+            return false;
+        throw error;
+    }
+}
+/** Whether nothing is at `path`; a probe the OS refuses proves nothing, so it answers `false`. */
+function nothingAt(path) {
+    try {
+        lstatSync(path);
+        return false;
+    }
+    catch (error) {
+        return isPathAbsentError(error);
+    }
+}
+/**
+ * The paths a fault is SIDED by, in order ({@link pathsActedOn}) — except a `rename` refused as
+ * absent whose SOURCE end is the one not there: an `ENOENT` rename is either a destination with
+ * no parent or an entry that was never there to move, and the second is the source's absence,
+ * with nothing wrong where it was to land. Asked of the filesystem, because the errno cannot say.
+ */
+function sidingPaths(facts) {
+    const acted = pathsActedOn(facts);
+    const { path: from } = facts;
+    if (facts.syscall !== 'rename' || facts.faultClass !== 'absent' || from === undefined || !nothingAt(from))
+        return acted;
+    return [from, ...acted.filter((each) => each !== from)];
+}
+/**
+ * Role by PATH, not by wrapper. A wrapper names the side its author had in mind;
+ * the path the failing call acted on ({@link pathsActedOn} — never a symlink's target
+ * text, and a rename's landing place first) is what actually failed, and one call routinely touches
+ * both an input and an output (a `copyFile` whose source is unreadable fails
+ * under the SOURCE root even though the wrapper says "write"). Falls back to the
+ * call's declared side only when the error names no path or the path is under no
+ * root.
+ */
+export function fsBoundary(roots, options = {}) {
+    const declared = FS_SIDES.flatMap((side) => (roots[side] ?? []).map((root) => ({ side, root })));
+    function sideOf(path) {
+        let best;
+        for (const entry of declared) {
+            const longer = best === undefined || entry.root.length > best.root.length;
+            if (longer && containedBy(entry.root, path))
+                best = entry;
+        }
+        return best?.side;
+    }
+    function sideOfError(error) {
+        const facts = fsFaultOf(error);
+        if (facts === undefined)
+            return undefined;
+        for (const path of sidingPaths(facts)) {
+            const side = sideOf(path);
+            if (side !== undefined)
+                return side;
+        }
+        return undefined;
+    }
+    /** The side the error's path names; a defect while examining a root is thrown with the fault it was classifying, so neither is lost. */
+    function sideOfFault(error) {
+        try {
+            return sideOfError(error);
+        }
+        catch (error_) {
+            throw new AggregateError([error_, error], 'Could not classify a filesystem fault: examining a root failed');
+        }
+    }
+    function classify(error, action, fallback) {
+        return classifyFsFault(error, {
+            side: sideOfFault(error) ?? fallback,
+            action,
+            ...(options.origin === undefined ? {} : { origin: options.origin }),
+            ...(options.shapeFromSource === undefined ? {} : { shapeFromSource: options.shapeFromSource }),
+        });
+    }
+    return {
+        sideOf,
+        classify,
+        async run(action, fallback, work) {
+            try {
+                return await work();
+            }
+            catch (error) {
+                throw classify(error, action, fallback);
+            }
+        },
+        runSync(action, fallback, work) {
+            try {
+                return work();
+            }
+            catch (error) {
+                throw classify(error, action, fallback);
+            }
+        },
+    };
+}
+//# sourceMappingURL=fs-boundary.js.map

package/dist/errors/fs-boundary.js.map

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

package/dist/errors/fs-fault.d.ts

@@ -0,0 +1,176 @@
+/**
+ * The one errno classifier: turns a raw `node:fs` error into an {@link FsFaultError}
+ * that says WHICH SIDE of a verb the OS refused (`source`, `destination`,
+ * `environment`) and WHAT KIND of refusal it was ({@link FsFaultClass}).
+ *
+ * The errno → class table and the single-errno questions (`isPathAbsentError`,
+ * `isRenameContentionError`, …) live in the leaf `errno-table.ts`. This module
+ * imports only that table, `vat-error.ts` and the link-chain refusal
+ * (`tree-change/host-chain.ts`, which imports neither this module nor
+ * `path-utils.ts`), so the path helpers below it (`path-utils.ts`:
+ * `normalizedTmpdir`) can classify their own faults. Deciding a
+ * side by containment needs `path-containment.ts`, which imports `path-utils.ts`:
+ * that is `fs-boundary.ts`, one level up, never imported back.
+ *
+ * `RefusalCode` lives in `schema`, so nothing here names one. The side × class →
+ * refusal table (and the remedy prose) belongs to `schema`; this module only
+ * produces the facts.
+ */
+import { type FsFaultClass, type FsFaultFacts } from './errno-table.js';
+import { VatError } from './vat-error.js';
+/** The one code every classified filesystem refusal carries. */
+export declare const FS_FAULT_CODE = "FS_FAULT";
+/**
+ * Which side of a verb the OS refused: an input it reads (`source`), an output or
+ * user state it writes (`destination`), or VAT's own scratch — staging, `$TMPDIR`,
+ * caches, locks (`environment`).
+ */
+export type FsSide = (typeof FS_SIDES)[number];
+/** Every {@link FsSide}, for a consumer that must key a table by them (the schema refusal table's drift test). */
+export declare const FS_SIDES: readonly ["source", "destination", "environment"];
+/**
+ * The side of any path an operation touches, decided the way the verb decides every other path's.
+ *
+ * One probe touches more than its own path — a link walk `lstat`s each component beneath its tree,
+ * a confirmed absence lists the parent — and those paths can lie on another side than the one
+ * asked about (`<project>/dist` is the project's, `dist/skills` an input). A fault is charged to the
+ * side of the path the OS REFUSED, never to the side of the question the read was answering.
+ */
+export type SideOfPath = (path: string) => FsSide;
+/** A {@link SideOfPath} for an operation every path of which is on one side: VAT's own scratch, one input tree. */
+export declare function everywhere(side: FsSide): SideOfPath;
+/**
+ * A {@link SideOfPath} for a probe of ONE input inside a tree on another side: `root` and what lies
+ * beneath it are on `side`, every other path the probe touches — a component above it, the parent
+ * a confirmed absence lists — on `outside`. E.g. the project config (`source`) in a project a build
+ * writes `dist/` into (`destination`).
+ */
+export declare function sideWithin(root: string, side: FsSide, outside: FsSide): SideOfPath;
+/**
+ * The path a refusal names — the one a {@link SideOfPath} is asked about: a refused link chain's
+ * path, the path the failing syscall acted on, or `fallback` when the error names none.
+ *
+ * @returns Forward slashes, as every path VAT compares
+ */
+export declare function refusedPathOf(error: unknown, fallback: string): string;
+/** For a `source` fault, who named the input: a CLI argument, a config value, or content read from inside another input. */
+export type SourceOrigin = (typeof SOURCE_ORIGINS)[number];
+/** Every {@link SourceOrigin}. */
+export declare const SOURCE_ORIGINS: readonly ["argument", "config", "content"];
+/** A filesystem refusal, classified. The message carries no remedy: the schema table owns that prose. */
+export declare class FsFaultError extends VatError {
+    readonly side: FsSide;
+    readonly faultClass: FsFaultClass;
+    readonly errno: string;
+    /** The path the failing call acted on: for a link it could not create, the link; for a rename, where the entry could not land. */
+    readonly path: string | undefined;
+    /** For a refused rename, the entry that was being moved to {@link path}; `undefined` for every other call. */
+    readonly movedFrom: string | undefined;
+    readonly origin: SourceOrigin;
+    readonly action: string;
+    constructor(facts: {
+        side: FsSide;
+        faultClass: FsFaultClass;
+        errno: string;
+        path: string | undefined;
+        /** Only a refused rename has one. */
+        movedFrom?: string | undefined;
+        origin: SourceOrigin;
+        action: string;
+        cause: unknown;
+    });
+}
+/**
+ * Whether `error` is an {@link FsFaultError}. Reads the VAT brand, the code and
+ * the fields — never the prototype — so a `dist` copy still matches a `src`
+ * instance, as {@link isVatError} does.
+ */
+export declare function isFsFaultError(error: unknown): error is FsFaultError;
+/** What a catch site knows about the call it wrapped. */
+export interface FsFaultContext {
+    side: FsSide;
+    /** A verb phrase for the message: `read the skill source`, `write the plugin registry`. */
+    action: string;
+    /** Used only when the error names no path of its own. */
+    path?: string;
+    /** For a `source` fault; default `argument`. */
+    origin?: SourceOrigin;
+    /**
+     * The write's LAYOUT was decided by an input (an archive extracted into staging, a
+     * skill bundle's `files:` layout): a layout fault ({@link isLayoutFault}) — the
+     * `wrong-type` and `occupied` classes (`EISDIR`, `EEXIST`: one entry landing on or
+     * under another), and `ENOTDIR` on the write (a file in the way of a directory the
+     * layout needs, at any depth) — is the input's, so it becomes `source`. Everything
+     * else keeps the side: a refused output (`refused`), a vanished one (`ENOENT`) and
+     * a machine that ran out (`exhausted`, `busy`, `unsupported`, `device`) say nothing
+     * about the layout.
+     */
+    shapeFromSource?: boolean;
+}
+/**
+ * Whether a fault on a write is one an input's layout decided — the only kind
+ * `shapeFromSource` moves to `source`: a `wrong-type` or `occupied` class, or
+ * `ENOTDIR` ({@link isFileInTheWayError}), keyed on the errno because the class
+ * table files it under `absent`. `ENOENT` is never one: a vanished output.
+ *
+ * @param fault - The fault's class and errno, as {@link fsFaultOf} or an `FsFaultError` carries them
+ */
+export declare function isLayoutFault(fault: {
+    readonly faultClass: FsFaultClass;
+    readonly errno: string;
+}): boolean;
+/**
+ * Whether a fault is a CAPACITY fault: the machine ran out (`exhausted`), something
+ * held the path (`busy`), or the filesystem cannot do this or failed (`unsupported`,
+ * `device`). The refusal table stops the run (`RUN_INCOMPLETE`) for every one of them on a
+ * destination or an environment side; reading an input it does so for `exhausted` and `busy`
+ * only (the machine's own state), while an `unsupported` or `device` fault there is the
+ * input's (`INPUT_UNREADABLE`). Among several failures of one operation it is the one to
+ * report first: a full disk explains the entries that failed after it.
+ *
+ * @param fault - The fault's class, as {@link fsFaultOf} or an `FsFaultError` carries it
+ */
+export declare function isCapacityFault(fault: {
+    readonly faultClass: FsFaultClass;
+}): boolean;
+/**
+ * Classify `error`. Returns an {@link FsFaultError} for a filesystem errno, and the
+ * input untouched for anything else — a `TypeError` is a defect, and an existing
+ * {@link VatError} already says what it means.
+ */
+export declare function classifyFsFault(error: unknown, ctx: FsFaultContext): unknown;
+/** Run `work`; a filesystem errno escaping it is rethrown classified, everything else as it was. */
+export declare function withFsFault<T>(ctx: FsFaultContext, work: () => Promise<T>): Promise<T>;
+/**
+ * The catch body of a WRITE lane that resolves a link, or a path through links, and has an answer
+ * for one that resolves to nothing (a dangling link's own spelling, `null`, its nearest ancestor):
+ * returns when `error` says so ({@link isUnresolvableLinkError}), and otherwise throws it —
+ * a filesystem errno classified on `ctx` (the OS declined, ran short or could not look, which says
+ * nothing about the link), anything else as it was. A lane that acts on the path cannot act on one
+ * it could not resolve, so the run stops.
+ *
+ * A READ/report lane asks {@link linkResolutionFault} instead: one bad target is a finding about
+ * that target, never the end of the run.
+ *
+ * @throws FsFaultError on `ctx.side` for every other filesystem errno; `error` itself for a non-filesystem error
+ */
+export declare function assertUnresolvableLink(error: unknown, ctx: FsFaultContext): void;
+/**
+ * The catch body of a READ/report lane that resolves a link target: the same one predicate as
+ * {@link assertUnresolvableLink} ({@link isUnresolvableLinkError}), but a fault is handed back for
+ * the lane to report against that ONE target (a row, a finding, carrying `errno` and `faultClass`)
+ * instead of thrown — one target the OS declined to resolve never rejects a batch, never aborts the
+ * run and never loses another target's finding. No side is picked: nothing is thrown.
+ *
+ * A chain VAT would not hand the kernel (`LinkChainRefusedError`: a link on the way names a
+ * network path, or the chain never ends) is a fault of the `refused` class on that one target,
+ * its `errno` the refusal's code — VAT, not the OS, declined to look.
+ *
+ * @returns `undefined` when the link resolves to nothing; the fault's facts when the OS declined,
+ *   ran short or could not look, or VAT declined to ask it
+ * @throws `error` itself when it carries no filesystem errno — a bug stays loud
+ */
+export declare function linkResolutionFault(error: unknown): FsFaultFacts | undefined;
+/** Synchronous {@link withFsFault}. */
+export declare function withFsFaultSync<T>(ctx: FsFaultContext, work: () => T): T;
+//# sourceMappingURL=fs-fault.d.ts.map

package/dist/errors/fs-fault.d.ts.map

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

package/dist/errors/fs-fault.js

@@ -0,0 +1,215 @@
+/**
+ * The one errno classifier: turns a raw `node:fs` error into an {@link FsFaultError}
+ * that says WHICH SIDE of a verb the OS refused (`source`, `destination`,
+ * `environment`) and WHAT KIND of refusal it was ({@link FsFaultClass}).
+ *
+ * The errno → class table and the single-errno questions (`isPathAbsentError`,
+ * `isRenameContentionError`, …) live in the leaf `errno-table.ts`. This module
+ * imports only that table, `vat-error.ts` and the link-chain refusal
+ * (`tree-change/host-chain.ts`, which imports neither this module nor
+ * `path-utils.ts`), so the path helpers below it (`path-utils.ts`:
+ * `normalizedTmpdir`) can classify their own faults. Deciding a
+ * side by containment needs `path-containment.ts`, which imports `path-utils.ts`:
+ * that is `fs-boundary.ts`, one level up, never imported back.
+ *
+ * `RefusalCode` lives in `schema`, so nothing here names one. The side × class →
+ * refusal table (and the remedy prose) belongs to `schema`; this module only
+ * produces the facts.
+ */
+import { relativeEscapesRoot, safePath, toForwardSlash } from '../path-core.js';
+import { isLinkChainRefusedError } from '../tree-change/host-chain.js';
+import { fsFaultOf, isFileInTheWayError, isUnresolvableLinkError, LINK_CHAIN_REFUSED_CODE, movedFromOf, pathsActedOn } from './errno-table.js';
+import { isVatError, VatError } from './vat-error.js';
+/** The one code every classified filesystem refusal carries. */
+export const FS_FAULT_CODE = 'FS_FAULT';
+/** Every {@link FsSide}, for a consumer that must key a table by them (the schema refusal table's drift test). */
+export const FS_SIDES = ['source', 'destination', 'environment'];
+/** A {@link SideOfPath} for an operation every path of which is on one side: VAT's own scratch, one input tree. */
+export function everywhere(side) {
+    return () => side;
+}
+/**
+ * A {@link SideOfPath} for a probe of ONE input inside a tree on another side: `root` and what lies
+ * beneath it are on `side`, every other path the probe touches — a component above it, the parent
+ * a confirmed absence lists — on `outside`. E.g. the project config (`source`) in a project a build
+ * writes `dist/` into (`destination`).
+ */
+export function sideWithin(root, side, outside) {
+    return (path) => (relativeEscapesRoot(safePath.relative(root, path)) ? outside : side);
+}
+/**
+ * The path a refusal names — the one a {@link SideOfPath} is asked about: a refused link chain's
+ * path, the path the failing syscall acted on, or `fallback` when the error names none.
+ *
+ * @returns Forward slashes, as every path VAT compares
+ */
+export function refusedPathOf(error, fallback) {
+    if (isLinkChainRefusedError(error))
+        return toForwardSlash(error.path);
+    const facts = fsFaultOf(error);
+    const acted = facts === undefined ? undefined : pathsActedOn(facts)[0];
+    return toForwardSlash(acted ?? fallback);
+}
+/** Every {@link SourceOrigin}. */
+export const SOURCE_ORIGINS = ['argument', 'config', 'content'];
+/** A filesystem refusal, classified. The message carries no remedy: the schema table owns that prose. */
+export class FsFaultError extends VatError {
+    side;
+    faultClass;
+    errno;
+    /** The path the failing call acted on: for a link it could not create, the link; for a rename, where the entry could not land. */
+    path;
+    /** For a refused rename, the entry that was being moved to {@link path}; `undefined` for every other call. */
+    movedFrom;
+    origin;
+    action;
+    constructor(facts) {
+        // The ONE place a fault gets its path, so the one place it gets its spelling: forward slashes,
+        // as every path VAT displays or compares. An errno's own `path` is the host's — on Windows Node
+        // hands back the backslash form whatever the caller passed — while a context's is VAT's. (The
+        // win32 namespace prefix is already gone: `fsFaultOf` reads every errno path without it.)
+        const path = facts.path === undefined ? undefined : toForwardSlash(facts.path);
+        const movedFrom = facts.movedFrom === undefined ? undefined : toForwardSlash(facts.movedFrom);
+        const ends = [movedFrom, path].filter((end) => end !== undefined).join(' -> ');
+        const where = ends === '' ? '' : `: ${ends}`;
+        super(FS_FAULT_CODE, `Could not ${facts.action} (${facts.errno})${where}`, { cause: facts.cause });
+        this.side = facts.side;
+        this.faultClass = facts.faultClass;
+        this.errno = facts.errno;
+        this.path = path;
+        this.movedFrom = movedFrom;
+        this.origin = facts.origin;
+        this.action = facts.action;
+    }
+}
+/**
+ * Whether `error` is an {@link FsFaultError}. Reads the VAT brand, the code and
+ * the fields — never the prototype — so a `dist` copy still matches a `src`
+ * instance, as {@link isVatError} does.
+ */
+export function isFsFaultError(error) {
+    if (!isVatError(error, FS_FAULT_CODE))
+        return false;
+    const fields = error;
+    return typeof fields['side'] === 'string' && typeof fields['faultClass'] === 'string' && typeof fields['errno'] === 'string';
+}
+/** The classes an input's layout can decide. */
+const LAYOUT_CLASSES = new Set(['wrong-type', 'occupied']);
+/**
+ * Whether a fault on a write is one an input's layout decided — the only kind
+ * `shapeFromSource` moves to `source`: a `wrong-type` or `occupied` class, or
+ * `ENOTDIR` ({@link isFileInTheWayError}), keyed on the errno because the class
+ * table files it under `absent`. `ENOENT` is never one: a vanished output.
+ *
+ * @param fault - The fault's class and errno, as {@link fsFaultOf} or an `FsFaultError` carries them
+ */
+export function isLayoutFault(fault) {
+    return LAYOUT_CLASSES.has(fault.faultClass) || isFileInTheWayError({ code: fault.errno });
+}
+/** The classes that are the machine or the filesystem giving out — nothing about an input's content or layout. */
+const CAPACITY_CLASSES = new Set(['exhausted', 'busy', 'unsupported', 'device']);
+/**
+ * Whether a fault is a CAPACITY fault: the machine ran out (`exhausted`), something
+ * held the path (`busy`), or the filesystem cannot do this or failed (`unsupported`,
+ * `device`). The refusal table stops the run (`RUN_INCOMPLETE`) for every one of them on a
+ * destination or an environment side; reading an input it does so for `exhausted` and `busy`
+ * only (the machine's own state), while an `unsupported` or `device` fault there is the
+ * input's (`INPUT_UNREADABLE`). Among several failures of one operation it is the one to
+ * report first: a full disk explains the entries that failed after it.
+ *
+ * @param fault - The fault's class, as {@link fsFaultOf} or an `FsFaultError` carries it
+ */
+export function isCapacityFault(fault) {
+    return CAPACITY_CLASSES.has(fault.faultClass);
+}
+/**
+ * Classify `error`. Returns an {@link FsFaultError} for a filesystem errno, and the
+ * input untouched for anything else — a `TypeError` is a defect, and an existing
+ * {@link VatError} already says what it means.
+ */
+export function classifyFsFault(error, ctx) {
+    // A chain VAT would not hand the kernel is a refusal on the caller's side like any other — the one
+    // side × class table decides its refusal and remedy, never a fixed code of its own.
+    if (isLinkChainRefusedError(error)) {
+        return new FsFaultError({ side: ctx.side, faultClass: 'refused', errno: LINK_CHAIN_REFUSED_CODE, path: error.path, origin: ctx.origin ?? 'argument', action: `${ctx.action} — ${error.message}`, cause: error });
+    }
+    if (isVatError(error))
+        return error;
+    const facts = fsFaultOf(error);
+    if (facts === undefined)
+        return error;
+    const promoted = ctx.shapeFromSource === true && ctx.side !== 'source' && isLayoutFault(facts);
+    const side = promoted ? 'source' : ctx.side;
+    return new FsFaultError({
+        side,
+        faultClass: facts.faultClass,
+        errno: facts.errno,
+        path: pathsActedOn(facts)[0] ?? ctx.path,
+        movedFrom: movedFromOf(facts),
+        origin: ctx.origin ?? (ctx.shapeFromSource === true && side === 'source' ? 'content' : 'argument'),
+        action: ctx.action,
+        cause: error,
+    });
+}
+/** Run `work`; a filesystem errno escaping it is rethrown classified, everything else as it was. */
+export async function withFsFault(ctx, work) {
+    try {
+        return await work();
+    }
+    catch (error) {
+        throw classifyFsFault(error, ctx);
+    }
+}
+/**
+ * The catch body of a WRITE lane that resolves a link, or a path through links, and has an answer
+ * for one that resolves to nothing (a dangling link's own spelling, `null`, its nearest ancestor):
+ * returns when `error` says so ({@link isUnresolvableLinkError}), and otherwise throws it —
+ * a filesystem errno classified on `ctx` (the OS declined, ran short or could not look, which says
+ * nothing about the link), anything else as it was. A lane that acts on the path cannot act on one
+ * it could not resolve, so the run stops.
+ *
+ * A READ/report lane asks {@link linkResolutionFault} instead: one bad target is a finding about
+ * that target, never the end of the run.
+ *
+ * @throws FsFaultError on `ctx.side` for every other filesystem errno; `error` itself for a non-filesystem error
+ */
+export function assertUnresolvableLink(error, ctx) {
+    if (!isUnresolvableLinkError(error))
+        throw classifyFsFault(error, ctx);
+}
+/**
+ * The catch body of a READ/report lane that resolves a link target: the same one predicate as
+ * {@link assertUnresolvableLink} ({@link isUnresolvableLinkError}), but a fault is handed back for
+ * the lane to report against that ONE target (a row, a finding, carrying `errno` and `faultClass`)
+ * instead of thrown — one target the OS declined to resolve never rejects a batch, never aborts the
+ * run and never loses another target's finding. No side is picked: nothing is thrown.
+ *
+ * A chain VAT would not hand the kernel (`LinkChainRefusedError`: a link on the way names a
+ * network path, or the chain never ends) is a fault of the `refused` class on that one target,
+ * its `errno` the refusal's code — VAT, not the OS, declined to look.
+ *
+ * @returns `undefined` when the link resolves to nothing; the fault's facts when the OS declined,
+ *   ran short or could not look, or VAT declined to ask it
+ * @throws `error` itself when it carries no filesystem errno — a bug stays loud
+ */
+export function linkResolutionFault(error) {
+    // No syscall: VAT, not the OS, declined — and a hop-limit refusal read every `readlink` it asked.
+    if (isLinkChainRefusedError(error))
+        return { errno: LINK_CHAIN_REFUSED_CODE, faultClass: 'refused', path: error.path, dest: undefined, syscall: undefined };
+    if (isUnresolvableLinkError(error))
+        return undefined;
+    const facts = fsFaultOf(error);
+    if (facts === undefined || isVatError(error))
+        throw error;
+    return facts;
+}
+/** Synchronous {@link withFsFault}. */
+export function withFsFaultSync(ctx, work) {
+    try {
+        return work();
+    }
+    catch (error) {
+        throw classifyFsFault(error, ctx);
+    }
+}
+//# sourceMappingURL=fs-fault.js.map

package/dist/errors/fs-fault.js.map

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

package/dist/errors/git-errno.d.ts

@@ -0,0 +1,13 @@
+/**
+ * git's `strerror` text → errno. The one place a line of git's stderr becomes an
+ * errno, so the classifier (`fsFaultOf`) can judge it like any `node:fs` error.
+ * This module PARSES text into errnos; it classifies nothing.
+ */
+/**
+ * The errno git's C-locale `strerror` text names, or `undefined` for a reason
+ * this table does not know.
+ *
+ * @param reason - The text after the colon on git's `could not open directory` line
+ */
+export declare function errnoForGitReason(reason: string): string | undefined;
+//# sourceMappingURL=git-errno.d.ts.map

package/dist/errors/git-errno.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-errno.d.ts","sourceRoot":"","sources":["../../src/errors/git-errno.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiCH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEpE"}

package/dist/errors/git-errno.js

@@ -0,0 +1,45 @@
+/**
+ * git's `strerror` text → errno. The one place a line of git's stderr becomes an
+ * errno, so the classifier (`fsFaultOf`) can judge it like any `node:fs` error.
+ * This module PARSES text into errnos; it classifies nothing.
+ */
+/**
+ * C-locale `strerror` text → errno, for the reasons git can print here.
+ *
+ * git does not print the errno name, only its message; every listing in `git-utils.ts`
+ * runs with `LC_ALL=C` so the message is the C-locale one and this table can
+ * be short. An unlisted reason is still a refusal — it becomes `UNKNOWN`, the
+ * same answer `listingFailure` gives an error carrying no errno — because
+ * dropping the line would reinstate the silent gap for exactly the errnos
+ * nobody thought of.
+ *
+ * The two ABSENCE reasons are listed so that `listingFailure` — the one owner
+ * of the absent/unreadable split — can recognise them and the line can be
+ * skipped: git prints "No such file or directory" for an untracked directory
+ * deleted between its parent's `readdir` and its own `opendir` (a concurrent
+ * `rm -rf tmp/`), and the walk route treats that same race as "no longer in
+ * the population" rather than as a refusal. Left unmapped it read as an
+ * `UNKNOWN` refusal, and the git route aborted a run the walk completed.
+ */
+const ERRNO_BY_STRERROR = new Map([
+    ['Permission denied', 'EACCES'],
+    ['Too many open files', 'EMFILE'],
+    ['Too many open files in system', 'ENFILE'],
+    ['Too many levels of symbolic links', 'ELOOP'],
+    ['Resource temporarily unavailable', 'EAGAIN'],
+    ['Input/output error', 'EIO'],
+    ['Stale file handle', 'ESTALE'],
+    ['Stale NFS file handle', 'ESTALE'],
+    ['No such file or directory', 'ENOENT'],
+    ['Not a directory', 'ENOTDIR'],
+]);
+/**
+ * The errno git's C-locale `strerror` text names, or `undefined` for a reason
+ * this table does not know.
+ *
+ * @param reason - The text after the colon on git's `could not open directory` line
+ */
+export function errnoForGitReason(reason) {
+    return ERRNO_BY_STRERROR.get(reason);
+}
+//# sourceMappingURL=git-errno.js.map

package/dist/errors/git-errno.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-errno.js","sourceRoot":"","sources":["../../src/errors/git-errno.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,iBAAiB,GAAgC,IAAI,GAAG,CAAC;IAC7D,CAAC,mBAAmB,EAAE,QAAQ,CAAC;IAC/B,CAAC,qBAAqB,EAAE,QAAQ,CAAC;IACjC,CAAC,+BAA+B,EAAE,QAAQ,CAAC;IAC3C,CAAC,mCAAmC,EAAE,OAAO,CAAC;IAC9C,CAAC,kCAAkC,EAAE,QAAQ,CAAC;IAC9C,CAAC,oBAAoB,EAAE,KAAK,CAAC;IAC7B,CAAC,mBAAmB,EAAE,QAAQ,CAAC;IAC/B,CAAC,uBAAuB,EAAE,QAAQ,CAAC;IACnC,CAAC,2BAA2B,EAAE,QAAQ,CAAC;IACvC,CAAC,iBAAiB,EAAE,SAAS,CAAC;CAC/B,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,OAAO,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC"}