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

package/dist/tree-change/host-chain.js

@@ -0,0 +1,85 @@
+/**
+ * The link-chain resolver ({@link walkLinkChain}) bound to this host's filesystem: `lstat` and
+ * `readlink`, and nothing that follows a link. Every call VAT makes that FOLLOWS a link — a
+ * `stat`, a `realpath` — reads the chain here first (`link-following.ts`, `assertLocalChain`), so
+ * no lane — a write lane, a read lane, an untrusted tree or the user's own — hands the kernel a
+ * chain whose every text has not been read.
+ */
+import { lstatSync, readlinkSync } from 'node:fs';
+import { isPathAbsentError, LINK_CHAIN_REFUSED_CODE } from '../errors/errno-table.js';
+import { isVatError, VatError } from '../errors/vat-error.js';
+import { safePath, toForwardSlash } from '../path-core.js';
+import { MAX_LINK_HOPS, walkLinkChain } from './link-chain.js';
+/**
+ * What stands at `path`, a link there not followed. A probe the OS refuses is thrown raw, for the
+ * caller to classify.
+ *
+ * ⚠️ "Not followed" is `lstat`'s word, and on Windows libuv keeps it only for what it calls a
+ * symbolic link: a junction to a volume (`\??\Volume{…}\`) and a reparse point of another tag
+ * (cloud files, dedup, WCI) are retried as a link-FOLLOWING `stat` and reported as the directory
+ * or file they lead to. Their targets are local — the kernel refuses a remote mount point — so no
+ * credential leaves the host, but the walk reads such a place as a plain directory where the
+ * kernel reparses it.
+ */
+export function hostPlaceKind(path) {
+    try {
+        const stats = lstatSync(path);
+        if (stats.isSymbolicLink())
+            return 'link';
+        return stats.isDirectory() ? 'directory' : 'file';
+    }
+    catch (error) {
+        if (isPathAbsentError(error))
+            return 'absent';
+        throw error;
+    }
+}
+/** The probe of this host's filesystem: `lstat` and `readlink` alone. */
+const HOST_PROBE = { kindAt: hostPlaceKind, textAt: (path) => readlinkSync(path) };
+/**
+ * Where `path` leads on this host's filesystem, under `rule` ({@link walkLinkChain}).
+ *
+ * @param path - Absolute, or relative to cwd; either separator
+ * @param rule - The flavor (bound from the host at the edge), the tree, and what the chain may do outside it
+ * @throws The raw errno of an `lstat` or `readlink` the OS refused, for the caller to classify
+ */
+export function walkHostChain(path, rule) {
+    return walkLinkChain(toForwardSlash(safePath.resolve(path)), rule, HOST_PROBE);
+}
+/** How each refusal reads, after "the symbolic link <link> ". */
+function refusalClause(refusal) {
+    switch (refusal.why) {
+        case 'network':
+            return `leads to ${refusal.text}, a network or device path, which VAT never asks the OS to follow (a Windows host would offer the operator's credentials to it)`;
+        case 'hop-limit':
+            return `starts a chain of more than ${MAX_LINK_HOPS.toString()} symbolic links that is not a cycle, so where it ends was never read`;
+        case 'unportable':
+            return `has a text no kernel resolves as written (${JSON.stringify(refusal.text)}: a NUL, or a name ending in a dot or a space)`;
+        case 'absolute':
+        case 'drive-relative':
+        case 'climbs-out':
+            return `leads outside the tree it is in (${refusal.text})`;
+    }
+}
+/**
+ * A path VAT would not resolve: a link on the way to it leads to a network path, or the chain is
+ * longer than any kernel follows. A read lane records it as that one target's fault
+ * (`linkResolutionFault`); a lane that stops classifies it on its own side, like any refusal
+ * (`classifyFsFault`), so a destination's refused chain reads as the destination's.
+ */
+export class LinkChainRefusedError extends VatError {
+    /** The path whose resolution was asked. */
+    path;
+    /** Why, with the link whose text decided it. */
+    refusal;
+    constructor(path, refusal) {
+        super(LINK_CHAIN_REFUSED_CODE, `Refusing to resolve ${path}: the symbolic link ${refusal.link} ${refusalClause(refusal)} — replace the link with the files it names.`);
+        this.path = path;
+        this.refusal = refusal;
+    }
+}
+/** Whether `error` is a {@link LinkChainRefusedError}, by its code (a `dist` copy never `instanceof`-matches a `src` one). */
+export function isLinkChainRefusedError(error) {
+    return isVatError(error, LINK_CHAIN_REFUSED_CODE) && 'refusal' in error;
+}
+//# sourceMappingURL=host-chain.js.map

package/dist/tree-change/host-chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-chain.js","sourceRoot":"","sources":["../../src/tree-change/host-chain.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE3D,OAAO,EAAsE,aAAa,EAAkB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEnJ;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;QAC9B,IAAI,KAAK,CAAC,cAAc,EAAE;YAAE,OAAO,MAAM,CAAC;QAC1C,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC;IACpD,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,IAAI,iBAAiB,CAAC,KAAK,CAAC;YAAE,OAAO,QAAQ,CAAC;QAC9C,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,GAAe,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;AAE/F;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,IAAe;IACzD,OAAO,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;AACjF,CAAC;AAED,iEAAiE;AACjE,SAAS,aAAa,CAAC,OAAqB;IAC1C,QAAQ,OAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,SAAS;YACZ,OAAO,YAAY,OAAO,CAAC,IAAI,iIAAiI,CAAC;QACnK,KAAK,WAAW;YACd,OAAO,+BAA+B,aAAa,CAAC,QAAQ,EAAE,sEAAsE,CAAC;QACvI,KAAK,YAAY;YACf,OAAO,6CAA6C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,gDAAgD,CAAC;QACnI,KAAK,UAAU,CAAC;QAChB,KAAK,gBAAgB,CAAC;QACtB,KAAK,YAAY;YACf,OAAO,oCAAoC,OAAO,CAAC,IAAI,GAAG,CAAC;IAC/D,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,OAAO,qBAAsB,SAAQ,QAAQ;IACjD,2CAA2C;IAClC,IAAI,CAAS;IACtB,gDAAgD;IACvC,OAAO,CAAe;IAC/B,YAAY,IAAY,EAAE,OAAqB;QAC7C,KAAK,CAAC,uBAAuB,EAAE,uBAAuB,IAAI,uBAAuB,OAAO,CAAC,IAAI,IAAI,aAAa,CAAC,OAAO,CAAC,8CAA8C,CAAC,CAAC;QACvK,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;CACF;AAED,8HAA8H;AAC9H,MAAM,UAAU,uBAAuB,CAAC,KAAc;IACpD,OAAO,UAAU,CAAC,KAAK,EAAE,uBAAuB,CAAC,IAAI,SAAS,IAAI,KAAK,CAAC;AAC1E,CAAC"}

package/dist/tree-change/identity-compare.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Deciding sameness and containment from entry identities already read off the filesystem.
+ * Pure: the examination is handed in, so the decision is the same whoever asked the OS.
+ */
+/** One way an entry answers to being identified: a filesystem id, or a folded real path when the filesystem reports none. */
+export type Identity = {
+    readonly id: string;
+} | {
+    readonly foldedRealPath: string;
+};
+/** Whether two entries are one. `unknown` means it could not be decided: treat it as `same` when deciding whether to delete. */
+export type EntrySameness = 'same' | 'different' | 'unknown';
+/** Whether an entry lies strictly under another. `unknown` means it could not be decided. */
+export type EntryContainment = 'inside' | 'outside' | 'unknown';
+/** What one round of identity questions needs: each entry's identities, or `undefined` when the OS refuses to examine it. */
+export type Examiner = (entry: string) => readonly Identity[] | undefined;
+export declare function sameBy(examine: Examiner, a: string, b: string): EntrySameness;
+/**
+ * Where an entry physically is: every spelling of it with no link left in its directories (its own
+ * place, and — for a link — its target's), or `undefined` when the OS refuses to resolve it.
+ */
+export type PhysicalSpellings = (entry: string) => readonly string[] | undefined;
+/**
+ * Whether `child` lies strictly under `ancestor`: some directory above it IS the ancestor. Walked
+ * along the spelling given AND along every physical spelling of the child — a directory of the given
+ * spelling that is a link to somewhere BELOW the ancestor is neither the ancestor nor a link to it,
+ * and the directories between its target and the ancestor are only on the physical way up.
+ */
+export declare function insideBy(examine: Examiner, child: string, ancestor: string, physical: PhysicalSpellings): EntryContainment;
+/**
+ * The identity a `stat` answers with: the filesystem's own id when it reports both a device and an
+ * inode, else the fold — which is only computed then, since it costs a `realpath`.
+ *
+ * @param stats - The `dev` and `ino` of a `bigint` stat
+ * @param fold - The folded real path, for a filesystem that reports no inode
+ */
+export declare function identityOf(stats: {
+    readonly dev: bigint;
+    readonly ino: bigint;
+}, fold: () => Identity): Identity;
+/** Sameness and containment over one memo, and the one throwing examination of an entry they share. */
+export interface IdentityOracle {
+    /** The entry's identities, read once: a refusal is remembered and thrown again. */
+    readonly identities: (entry: string) => readonly Identity[];
+    /** Whether the OS refuses to examine `entry` (the remembered answer of {@link IdentityOracle.identities}). */
+    readonly refuses: (entry: string) => boolean;
+    readonly sameEntry: (a: string, b: string) => EntrySameness;
+    readonly isInside: (child: string, ancestor: string) => EntryContainment;
+}
+/**
+ * Identity questions that examine each entry ONCE: every answer is built from the same
+ * observation of each entry. One plan's decisions asked the filesystem again and again,
+ * so a refusal seen by one (subsumption: `unknown`) and not by the next (the overlap
+ * check: `inside`) made the planner refuse its own plan.
+ *
+ * @param read - The examination: an entry's identities, or a thrown classified fault when the OS
+ *   refuses. Anything else it throws is a defect and is never remembered as a refusal.
+ * @param physical - Where an entry physically is, for containment (see {@link insideBy})
+ */
+export declare function identityOracleOver(read: (entry: string) => readonly Identity[], physical: PhysicalSpellings): IdentityOracle;
+//# sourceMappingURL=identity-compare.d.ts.map

package/dist/tree-change/identity-compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-compare.d.ts","sourceRoot":"","sources":["../../src/tree-change/identity-compare.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,6HAA6H;AAC7H,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC;AAErF,gIAAgI;AAChI,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;AAE7D,6FAA6F;AAC7F,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;AAkBhE,6HAA6H;AAC7H,MAAM,MAAM,QAAQ,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,QAAQ,EAAE,GAAG,SAAS,CAAC;AAE1E,wBAAgB,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,CAI7E;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;AAgBjF;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,GAAG,gBAAgB,CAO1H;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,EAAE,MAAM,QAAQ,GAAG,QAAQ,CAEhH;AAED,uGAAuG;AACvG,MAAM,WAAW,cAAc;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,QAAQ,EAAE,CAAC;IAC5D,8GAA8G;IAC9G,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;IAC5D,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,gBAAgB,CAAC;CAC1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,QAAQ,EAAE,EAAE,QAAQ,EAAE,iBAAiB,GAAG,cAAc,CA8B5H"}

package/dist/tree-change/identity-compare.js

@@ -0,0 +1,115 @@
+/**
+ * Deciding sameness and containment from entry identities already read off the filesystem.
+ * Pure: the examination is handed in, so the decision is the same whoever asked the OS.
+ */
+import path from 'node:path';
+import { isFsFaultError } from '../errors/fs-fault.js';
+function hasFold(identities) {
+    return identities.some((identity) => 'foldedRealPath' in identity);
+}
+/** One entry when both are filesystem ids and equal, or both are folds and equal; an id never equals a fold. */
+function sameIdentity(left, right) {
+    if ('id' in left && 'id' in right)
+        return left.id === right.id;
+    return 'foldedRealPath' in left && 'foldedRealPath' in right && left.foldedRealPath === right.foldedRealPath;
+}
+function compare(left, right) {
+    if (left.length === 0 || right.length === 0)
+        return 'different';
+    if (left.some((l) => right.some((r) => sameIdentity(l, r))))
+        return 'same';
+    return hasFold(left) || hasFold(right) ? 'unknown' : 'different';
+}
+export function sameBy(examine, a, b) {
+    const left = examine(a);
+    const right = examine(b);
+    return left === undefined || right === undefined ? 'unknown' : compare(left, right);
+}
+/** Whether some directory above `start`, spelled as given, is the wanted entry. */
+function ancestorAbove(examine, start, wanted) {
+    let undecided = false;
+    let current = start;
+    for (let parent = path.dirname(current); parent !== current; parent = path.dirname(current)) {
+        const found = examine(parent);
+        const verdict = found === undefined ? 'unknown' : compare(found, wanted);
+        if (verdict === 'same')
+            return 'inside';
+        if (verdict === 'unknown')
+            undecided = true;
+        current = parent;
+    }
+    return undecided ? 'unknown' : 'outside';
+}
+/**
+ * Whether `child` lies strictly under `ancestor`: some directory above it IS the ancestor. Walked
+ * along the spelling given AND along every physical spelling of the child — a directory of the given
+ * spelling that is a link to somewhere BELOW the ancestor is neither the ancestor nor a link to it,
+ * and the directories between its target and the ancestor are only on the physical way up.
+ */
+export function insideBy(examine, child, ancestor, physical) {
+    const wanted = examine(ancestor);
+    if (wanted === undefined)
+        return 'unknown';
+    const resolved = physical(child);
+    const verdicts = new Set([...new Set([child, ...(resolved ?? [])])].map((start) => ancestorAbove(examine, start, wanted)));
+    if (verdicts.has('inside'))
+        return 'inside';
+    return resolved === undefined || verdicts.has('unknown') ? 'unknown' : 'outside';
+}
+/**
+ * The identity a `stat` answers with: the filesystem's own id when it reports both a device and an
+ * inode, else the fold — which is only computed then, since it costs a `realpath`.
+ *
+ * @param stats - The `dev` and `ino` of a `bigint` stat
+ * @param fold - The folded real path, for a filesystem that reports no inode
+ */
+export function identityOf(stats, fold) {
+    return stats.dev !== 0n && stats.ino !== 0n ? { id: `${stats.dev}:${stats.ino}` } : fold();
+}
+/**
+ * Identity questions that examine each entry ONCE: every answer is built from the same
+ * observation of each entry. One plan's decisions asked the filesystem again and again,
+ * so a refusal seen by one (subsumption: `unknown`) and not by the next (the overlap
+ * check: `inside`) made the planner refuse its own plan.
+ *
+ * @param read - The examination: an entry's identities, or a thrown classified fault when the OS
+ *   refuses. Anything else it throws is a defect and is never remembered as a refusal.
+ * @param physical - Where an entry physically is, for containment (see {@link insideBy})
+ */
+export function identityOracleOver(read, physical) {
+    const memo = new Map();
+    const identities = (entry) => {
+        let seen = memo.get(entry);
+        if (seen === undefined) {
+            try {
+                seen = { ok: read(entry) };
+            }
+            catch (error) {
+                if (!isFsFaultError(error))
+                    throw error;
+                seen = { refused: error };
+            }
+            memo.set(entry, seen);
+        }
+        if ('refused' in seen)
+            throw seen.refused;
+        return seen.ok;
+    };
+    const undecided = (entry) => {
+        try {
+            return identities(entry);
+        }
+        catch (error) {
+            if (isFsFaultError(error))
+                return undefined;
+            throw error;
+        }
+    };
+    return {
+        identities,
+        refuses: (entry) => undecided(entry) === undefined,
+        sameEntry: (a, b) => sameBy(undecided, a, b),
+        isInside: (child, ancestor) => insideBy(undecided, child, ancestor, physical),
+    };
+}
+//# sourceMappingURL=identity-compare.js.map

package/dist/tree-change/identity-compare.js.map

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

package/dist/tree-change/identity.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Entry identity: are two names ONE entry on disk?
+ *
+ * Two changes to a tree can alias without sharing a spelling — `plugins/Old` and
+ * `plugins/old` on APFS or NTFS, a link and its target, two links to one target.
+ * Comparing names cannot see it, and acting on a wrong "different" deletes what the
+ * user just installed. So identity is asked of the filesystem:
+ *
+ * - `dev` and `ino` both nonzero → the id `${dev}:${ino}`, from a `bigint` `lstat` of
+ *   the entry, plus a `stat` of a link's target. A link answers to BOTH: removing it
+ *   removes only the link, but it aliases its target.
+ * - Otherwise (a filesystem that reports `ino` 0) → a folded real path: the real
+ *   parent, a `/`, the base name, NFC then lower-cased. The fold can only err toward
+ *   "same", which keeps what it is asked to remove.
+ *
+ * An entry the OS refuses to examine is `unknown`, never `different`: the caller
+ * keeps. {@link entryIdentities} throws the refusal as an `FsFaultError` on the side
+ * the CALLER names, so whatever surfaces it reports a classified fault, not a raw errno.
+ */
+import { type FsSide } from '../errors/fs-fault.js';
+import { type EntryContainment, type EntrySameness, type Identity, type IdentityOracle } from './identity-compare.js';
+/**
+ * Every identity `entry` answers to: `[]` when nothing is there; its own (`lstat`) for
+ * anything; plus its target's (`stat`) when it is a link that resolves.
+ *
+ * @param entry - Absolute path to identify
+ * @param side - The side of the verb that named `entry`; every fault (the `lstat`, the `stat`, the real path of a fold) is raised on it
+ * @throws FsFaultError on `side` when the OS refuses to examine `entry`
+ */
+export declare function entryIdentities(entry: string, side: FsSide): readonly Identity[];
+/**
+ * Whether `a` and `b` are one entry. Any shared identity is `same`; identities on
+ * both sides with a filesystem id each and none shared is `different`; a folded path
+ * on either side that does not match is `unknown`; an entry the OS refuses to
+ * examine is `unknown`; an absent entry is `different` (nothing there can alias).
+ *
+ * @param a - Absolute path
+ * @param b - Absolute path
+ */
+export declare function sameEntry(a: string, b: string): EntrySameness;
+/**
+ * Whether `child` lies strictly under `ancestor`, judged by identity: some directory
+ * on the way up from `child` — along its spelling as given, and along where it
+ * physically is — is the same entry as `ancestor`. So a linked or case-aliased
+ * spelling of the ancestor is found, and so is a directory of `child`'s spelling that
+ * is a link to somewhere BELOW the ancestor. `child` need not exist.
+ * `unknown` when no ancestor proved `same` and one could not be examined.
+ *
+ * ⚠️ On a filesystem that reports `ino` 0 the answer for an existing `ancestor` is
+ * `unknown`, never `outside`: a fold cannot prove two names apart. A caller that
+ * refuses on `inside` must not refuse on `unknown`, or every copy there is refused.
+ *
+ * @param child - Absolute path
+ * @param ancestor - Absolute path
+ */
+export declare function isInsideByIdentity(child: string, ancestor: string): EntryContainment;
+/**
+ * {@link sameEntry} and {@link isInsideByIdentity} over one memo: each entry is examined once
+ * (`entryIdentities(entry, 'destination')`), so every answer of a plan is built from one observation.
+ */
+export declare function identityOracle(): IdentityOracle;
+//# sourceMappingURL=identity.d.ts.map

package/dist/tree-change/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../src/tree-change/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH,OAAO,EAA+C,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAMjG,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAc,KAAK,cAAc,EAAwC,MAAM,uBAAuB,CAAC;AAkCxK;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE,CAYhF;AA8BD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,CAE7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAEpF;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,cAAc,CAE/C"}

package/dist/tree-change/identity.js

@@ -0,0 +1,152 @@
+/**
+ * Entry identity: are two names ONE entry on disk?
+ *
+ * Two changes to a tree can alias without sharing a spelling — `plugins/Old` and
+ * `plugins/old` on APFS or NTFS, a link and its target, two links to one target.
+ * Comparing names cannot see it, and acting on a wrong "different" deletes what the
+ * user just installed. So identity is asked of the filesystem:
+ *
+ * - `dev` and `ino` both nonzero → the id `${dev}:${ino}`, from a `bigint` `lstat` of
+ *   the entry, plus a `stat` of a link's target. A link answers to BOTH: removing it
+ *   removes only the link, but it aliases its target.
+ * - Otherwise (a filesystem that reports `ino` 0) → a folded real path: the real
+ *   parent, a `/`, the base name, NFC then lower-cased. The fold can only err toward
+ *   "same", which keeps what it is asked to remove.
+ *
+ * An entry the OS refuses to examine is `unknown`, never `different`: the caller
+ * keeps. {@link entryIdentities} throws the refusal as an `FsFaultError` on the side
+ * the CALLER names, so whatever surfaces it reports a classified fault, not a raw errno.
+ */
+import { lstatSync } from 'node:fs';
+import path from 'node:path';
+import { requireConfirmedAbsent } from '../errors/confirmed-absent.js';
+import { isPathAbsentError } from '../errors/errno-table.js';
+import { classifyFsFault, everywhere, isFsFaultError } from '../errors/fs-fault.js';
+import { edgeBigintStatSync } from '../link-following.js';
+import { canonicalPath } from '../path-containment.js';
+import { safePath, toForwardSlash, toNfc } from '../path-core.js';
+import { normalizePath } from '../path-utils.js';
+import { identityOf, identityOracleOver, insideBy, sameBy } from './identity-compare.js';
+/** Run `work` for `entry`; a filesystem refusal is rethrown classified on `side`, anything else as it was. */
+function guarded(entry, side, work) {
+    try {
+        return work();
+    }
+    catch (error) {
+        throw classifyFsFault(error, { side, action: 'examine the entry', path: entry });
+    }
+}
+/** The fold of `real` (an absolute path): its real parent, a `/`, its base name, NFC then lower-cased. */
+function foldedRealPath(entry, side, real) {
+    return guarded(entry, side, () => ({
+        foldedRealPath: toNfc(`${toForwardSlash(normalizePath(path.dirname(real), path.dirname(real)))}/${path.basename(real)}`).toLowerCase(),
+    }));
+}
+/**
+ * `stat(entry)` for an entry that may be absent: `undefined` when nothing is there — believed only when
+ * the parent's listing agrees — and a classified fault when the OS refuses.
+ */
+function examine(entry, side, follows) {
+    const ctx = { side, action: 'examine the entry', path: entry };
+    try {
+        return follows ? edgeBigintStatSync(entry) : lstatSync(entry, { bigint: true });
+    }
+    catch (error) {
+        if (!isPathAbsentError(error))
+            throw classifyFsFault(error, ctx);
+        // A `stat` follows a link (a dangling one is absent); an `lstat` sees the link itself.
+        requireConfirmedAbsent(entry, error, { action: ctx.action, path: entry }, { follows, sideOf: everywhere(side) });
+        return undefined;
+    }
+}
+/**
+ * Every identity `entry` answers to: `[]` when nothing is there; its own (`lstat`) for
+ * anything; plus its target's (`stat`) when it is a link that resolves.
+ *
+ * @param entry - Absolute path to identify
+ * @param side - The side of the verb that named `entry`; every fault (the `lstat`, the `stat`, the real path of a fold) is raised on it
+ * @throws FsFaultError on `side` when the OS refuses to examine `entry`
+ */
+export function entryIdentities(entry, side) {
+    const own = examine(entry, side, false);
+    if (own === undefined)
+        return [];
+    const identities = [identityOf(own, () => foldedRealPath(entry, side, entry))];
+    if (!own.isSymbolicLink())
+        return identities;
+    // Every entry identified here is one the verb itself names (a destination it writes or removes):
+    // the operator's own path, its own link the edge the kernel answers.
+    const target = examine(entry, side, true);
+    if (target !== undefined) {
+        identities.push(identityOf(target, () => foldedRealPath(entry, side, guarded(entry, side, () => normalizePath(entry, entry)))));
+    }
+    return identities;
+}
+/**
+ * The identities of `entry`, or `undefined` when the OS refuses to examine it. The
+ * side is irrelevant here: a refusal becomes `unknown` and never surfaces.
+ */
+function identitiesOrUndecided(entry) {
+    try {
+        return entryIdentities(entry, 'destination');
+    }
+    catch (error) {
+        if (isFsFaultError(error))
+            return undefined;
+        throw error;
+    }
+}
+/**
+ * Where `entry` physically is — its own place (its real parent directory, then its name) and, for a
+ * link, its target's — or `undefined` when the OS refuses to resolve it. `entry` need not exist: it
+ * is resolved from its deepest existing ancestor.
+ */
+function physicalSpellings(entry) {
+    try {
+        return [safePath.join(canonicalPath(path.dirname(entry), path.dirname(entry)), path.basename(entry)), canonicalPath(entry, entry)];
+    }
+    catch (error) {
+        // A refusal is `unknown` to the caller, exactly as an entry it cannot examine is; a defect stays loud.
+        if (isFsFaultError(classifyFsFault(error, { side: 'destination', action: 'resolve the entry', path: entry })))
+            return undefined;
+        throw error;
+    }
+}
+/**
+ * Whether `a` and `b` are one entry. Any shared identity is `same`; identities on
+ * both sides with a filesystem id each and none shared is `different`; a folded path
+ * on either side that does not match is `unknown`; an entry the OS refuses to
+ * examine is `unknown`; an absent entry is `different` (nothing there can alias).
+ *
+ * @param a - Absolute path
+ * @param b - Absolute path
+ */
+export function sameEntry(a, b) {
+    return sameBy(identitiesOrUndecided, a, b);
+}
+/**
+ * Whether `child` lies strictly under `ancestor`, judged by identity: some directory
+ * on the way up from `child` — along its spelling as given, and along where it
+ * physically is — is the same entry as `ancestor`. So a linked or case-aliased
+ * spelling of the ancestor is found, and so is a directory of `child`'s spelling that
+ * is a link to somewhere BELOW the ancestor. `child` need not exist.
+ * `unknown` when no ancestor proved `same` and one could not be examined.
+ *
+ * ⚠️ On a filesystem that reports `ino` 0 the answer for an existing `ancestor` is
+ * `unknown`, never `outside`: a fold cannot prove two names apart. A caller that
+ * refuses on `inside` must not refuse on `unknown`, or every copy there is refused.
+ *
+ * @param child - Absolute path
+ * @param ancestor - Absolute path
+ */
+export function isInsideByIdentity(child, ancestor) {
+    return insideBy(identitiesOrUndecided, child, ancestor, physicalSpellings);
+}
+/**
+ * {@link sameEntry} and {@link isInsideByIdentity} over one memo: each entry is examined once
+ * (`entryIdentities(entry, 'destination')`), so every answer of a plan is built from one observation.
+ */
+export function identityOracle() {
+    return identityOracleOver((entry) => entryIdentities(entry, 'destination'), physicalSpellings);
+}
+//# sourceMappingURL=identity.js.map

package/dist/tree-change/identity.js.map

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

package/dist/tree-change/index.d.ts

@@ -0,0 +1,24 @@
+/** The plan/apply tree-change primitive: entry identity, the readable-tree proof and the copy, the planner, the applier and the file helpers. */
+export { entryIdentities, isInsideByIdentity, sameEntry } from './identity.js';
+export type { EntryContainment, EntrySameness, Identity } from './identity-compare.js';
+export { COPY_LINK_ESCAPES_SOURCE_CODE, CopyLinkEscapesSourceError, DIRECTORY_WALK_REVISITED_CODE, DirectoryWalkRevisitedError, FollowedWalk, } from './followed-walk.js';
+export { proveTreeReadable, readRegularFile } from './readable-tree.js';
+export type { ProveTreeReadableOptions } from './readable-tree.js';
+export { copyRegularFile, copyTree } from './copy-tree.js';
+export type { CopyRegularFileOptions, CopyTreeOptions } from './copy-tree.js';
+export type { CopyOnto } from './copy-decisions.js';
+export type { LinkPolicy, TreeWalkOptions } from './tree-walk.js';
+export { refuseEscapingLinks, treeChain, treeContainment } from './link-containment.js';
+export type { LinkContainmentCheck } from './link-containment.js';
+export { isLinkChainRefusedError } from './host-chain.js';
+export { HOST_PATH_FLAVOR, isWithinUnder, untrustedLinkRefusal, untrustedTextRefusal, win32FoldedName } from './link-chain.js';
+export { planTreeChanges, TREE_DEST_HOLDS_SOURCE_CODE, TREE_DEST_NOT_OWNED_CODE, TREE_DEST_OCCUPIED_CODE, TREE_DESTS_OVERLAP_CODE, TREE_SOURCE_HOLDS_DEST_CODE, } from './plan.js';
+export type { EntryKind, FileContents, Ownership, OwnershipVerdict, PlannedAction, PlannedChange, TreeChange, TreeFill, TreePlan } from './plan.js';
+export { applyTreePlan, applyTreePlanOrLeftover, TREE_CLEANUP_INCOMPLETE_CODE } from './apply.js';
+export { TREE_ROLLBACK_INCOMPLETE_CODE, TreeRollbackIncompleteError } from './rollback-error.js';
+export type { TreeRollbackStranded } from './rollback-error.js';
+export type { ApplyOptions, ApplyOutcome, ApplyResult, TreeChangeWarning } from './apply.js';
+export type { TempDirOutcome } from './files.js';
+export { disposeTempDir, disposeTempDirAfterFailure, disposeTempDirSync, makeDirectoryUnder, renameFileAtomic, replaceFile, TEMP_DIR_OUTSIDE_TMPDIR_CODE, withTempDir, writeFileUnder } from './files.js';
+export { isParkedTreeEntry, isTreeChangeResidue } from './staging-names.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tree-change/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tree-change/index.ts"],"names":[],"mappings":"AAAA,iJAAiJ;AACjJ,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/E,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACvF,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,6BAA6B,EAC7B,2BAA2B,EAC3B,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACxE,YAAY,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC3D,YAAY,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC9E,YAAY,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxF,YAAY,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC/H,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACpJ,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAClG,OAAO,EAAE,6BAA6B,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AACjG,YAAY,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC7F,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,WAAW,EAAE,4BAA4B,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC1M,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/tree-change/index.js

@@ -0,0 +1,14 @@
+/** The plan/apply tree-change primitive: entry identity, the readable-tree proof and the copy, the planner, the applier and the file helpers. */
+export { entryIdentities, isInsideByIdentity, sameEntry } from './identity.js';
+export { COPY_LINK_ESCAPES_SOURCE_CODE, CopyLinkEscapesSourceError, DIRECTORY_WALK_REVISITED_CODE, DirectoryWalkRevisitedError, FollowedWalk, } from './followed-walk.js';
+export { proveTreeReadable, readRegularFile } from './readable-tree.js';
+export { copyRegularFile, copyTree } from './copy-tree.js';
+export { refuseEscapingLinks, treeChain, treeContainment } from './link-containment.js';
+export { isLinkChainRefusedError } from './host-chain.js';
+export { HOST_PATH_FLAVOR, isWithinUnder, untrustedLinkRefusal, untrustedTextRefusal, win32FoldedName } from './link-chain.js';
+export { planTreeChanges, TREE_DEST_HOLDS_SOURCE_CODE, TREE_DEST_NOT_OWNED_CODE, TREE_DEST_OCCUPIED_CODE, TREE_DESTS_OVERLAP_CODE, TREE_SOURCE_HOLDS_DEST_CODE, } from './plan.js';
+export { applyTreePlan, applyTreePlanOrLeftover, TREE_CLEANUP_INCOMPLETE_CODE } from './apply.js';
+export { TREE_ROLLBACK_INCOMPLETE_CODE, TreeRollbackIncompleteError } from './rollback-error.js';
+export { disposeTempDir, disposeTempDirAfterFailure, disposeTempDirSync, makeDirectoryUnder, renameFileAtomic, replaceFile, TEMP_DIR_OUTSIDE_TMPDIR_CODE, withTempDir, writeFileUnder } from './files.js';
+export { isParkedTreeEntry, isTreeChangeResidue } from './staging-names.js';
+//# sourceMappingURL=index.js.map

package/dist/tree-change/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tree-change/index.ts"],"names":[],"mappings":"AAAA,iJAAiJ;AACjJ,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/E,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,6BAA6B,EAC7B,2BAA2B,EAC3B,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI3D,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC/H,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAClG,OAAO,EAAE,6BAA6B,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAIjG,OAAO,EAAE,cAAc,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,WAAW,EAAE,4BAA4B,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC1M,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC"}