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

package/dist/tree-change/link-chain.d.ts

@@ -0,0 +1,180 @@
+/**
+ * The ONE resolver of a symbolic-link chain: where a path leads, walked hop by hop from what
+ * `lstat` and `readlink` say alone, so nothing is handed to the kernel until the whole chain has
+ * been read as text and shown to be local.
+ *
+ * That order is the point. A Windows kernel asked to resolve a path through a link to
+ * `\\host\share` opens an SMB session and offers the operator's NTLM credentials to that host
+ * before any answer comes back — so a `realpath` or a `stat` that follows links is a SECOND lock,
+ * asked only once this walk has proved the chain local, never the first.
+ *
+ * Pure: the caller supplies the path {@link PathFlavor} and the probe, so a test runs Windows
+ * semantics on any host. The flavor decides two things the kernel decides:
+ *
+ * - what separates a link text's components, and what makes it absolute or a network path
+ *   (`\\host\share`, `\\?\UNC\…`, `\\.\…`, `//host/share` under win32; on POSIX a backslash is a
+ *   character of a name and `//x` is the local root);
+ * - what `..` means. POSIX resolves a link before the `..` after it, physically (the parent of
+ *   where the link LED). Windows joins a relative link text onto the link's directory and collapses
+ *   every `..` lexically before reparsing — `x\..\y` is `y` whether `x` exists, is a file or a link —
+ *   so under win32 each splice is collapsed by string first, and every component it leaves is examined.
+ *
+ * Running out of hops ({@link MAX_LINK_HOPS}) is a refusal, never an answer: a chain the walk did
+ * not finish reading is a chain the kernel would finish for it. A CYCLE is different, and is told
+ * apart exactly: the walk meets the same link with the same text left to read, so every text in
+ * the cycle has been read and is local, and the kernel can only answer `ELOOP` — it resolves to
+ * nothing, as a dangling link does, in every lane.
+ *
+ * An untrusted tree ({@link ChainRule.outside} `refuse`) may be read on either host — a clone made
+ * here is installed there — so its every link text is also held to the OTHER flavor's rules
+ * ({@link untrustedTextRefusal}): a text that is absolute, drive-relative or a network path on
+ * either kernel is refused on both.
+ */
+/** What stands at a place, a link there NOT followed. */
+export type PlaceKind = 'directory' | 'file' | 'link' | 'absent';
+/** Whose path rules a link's text is read by. Bound from `process.platform` at the edge ({@link HOST_PATH_FLAVOR}). */
+export type PathFlavor = 'posix' | 'win32';
+/** The flavor of the host VAT runs on — the edge where a pure caller's flavor is bound. */
+export declare const HOST_PATH_FLAVOR: PathFlavor;
+/**
+ * How many links one resolution follows before it refuses. Windows' limit — 63 reparse points in
+ * one path — is the larger of the two kernels' (Linux's `MAXSYMLINKS` is 40), so no chain a kernel
+ * would still follow is ever cut short and answered.
+ */
+export declare const MAX_LINK_HOPS = 63;
+/** Why a chain is refused before the kernel is asked anything, with the link whose text decided it. */
+export type ChainRefusal = 
+/** A network or device path, at any hop: never handed to the kernel, in any lane. */
+{
+    readonly why: 'network';
+    readonly link: string;
+    readonly text: string;
+}
+/** An absolute local text, in a tree whose links may not leave it ({@link ChainRule.outside} `refuse`). */
+ | {
+    readonly why: 'absolute';
+    readonly link: string;
+    readonly text: string;
+}
+/** A drive-relative text (`C:x`): it names a place relative to a per-drive working directory no walk can know. */
+ | {
+    readonly why: 'drive-relative';
+    readonly link: string;
+    readonly text: string;
+}
+/** A text holding a NUL, or a component ending in a dot or a space, in a tree whose links may not leave it: not the text a kernel resolves. */
+ | {
+    readonly why: 'unportable';
+    readonly link: string;
+    readonly text: string;
+}
+/** A step above the tree's root, in a tree whose links may not leave it. */
+ | {
+    readonly why: 'climbs-out';
+    readonly link: string;
+    readonly text: string;
+}
+/** More than {@link MAX_LINK_HOPS} links that are not a cycle: a chain longer than either kernel follows. */
+ | {
+    readonly why: 'hop-limit';
+    readonly link: string;
+};
+/** Where a chain leads, as far as text can tell. */
+export type LinkChain = 
+/** A local path, every link on the way read: the kernel may now be asked about it. */
+{
+    readonly kind: 'resolved';
+    readonly path: string;
+    readonly final: 'directory' | 'file';
+}
+/**
+ * It leads to nothing: a component is absent or a file stands where a directory must
+ * (`absent`), or the chain comes back to a link it already read with the same text left
+ * (`cycle` — what the kernel answers `ELOOP` for).
+ */
+ | {
+    readonly kind: 'nothing';
+    readonly at: string;
+    readonly cause: 'absent' | 'cycle';
+}
+/** It may not be resolved at all. */
+ | {
+    readonly kind: 'refused';
+    readonly refusal: ChainRefusal;
+};
+/** The tree a chain is resolved in, and what it may do outside it. */
+export interface ChainRule {
+    readonly flavor: PathFlavor;
+    /** The tree's root, canonical (its own components are real directories). */
+    readonly root: string;
+    /**
+     * - `refuse`: an untrusted tree (a clone, an archive, a tree an install copies) — an absolute or
+     *   drive-relative text, or any step above the root, is refused, and nothing outside is probed.
+     * - `follow`: the user's own tree — an absolute local text is followed and walked by the same
+     *   rules, so a later hop's network text is still caught; where the chain ends is the caller's call.
+     */
+    readonly outside: 'refuse' | 'follow';
+}
+/** What the walk may ask the filesystem: never anything that follows a link. */
+export interface ChainProbe {
+    /** What stands at `path`, a link there NOT followed (`lstat`). */
+    readonly kindAt: (path: string) => PlaceKind;
+    /** The text of the link at `path` (`readlink`). */
+    readonly textAt: (path: string) => string;
+}
+declare const CLIMBS_OUT = "climbs-out";
+/**
+ * The root a NAMED path hangs from — `/`, a drive's `C:/`, a share's `//host/share/` — for a walk
+ * of the user's own path, which may lead anywhere local.
+ *
+ * @param path - Absolute, forward- or back-slashed
+ * @param flavor - Whose rules
+ * @throws TypeError for a path that is not absolute under `flavor`
+ */
+export declare function namedPathRoot(path: string, flavor: PathFlavor): string;
+/**
+ * Why a link text in an UNTRUSTED tree is refused by its text alone, under EITHER flavor — the rule
+ * a chain in a `refuse` tree is held to at every hop, and the one a caller that has only the text
+ * (a git clone reading link blobs before checkout) asks directly.
+ *
+ * A text is also `unportable` when it holds a NUL (the OS cuts the text short there, so the walk
+ * would judge bytes no kernel sees) or a component ending in a dot or a space (Win32 strips those,
+ * so `.. ` would climb where the walk read a name) — the win32 rule held on every host.
+ *
+ * @param text - A link's text, verbatim
+ * @returns why either kernel would not read it as a relative text inside the tree; `undefined` for one it would
+ */
+export declare function untrustedTextRefusal(text: string): UntrustedTextRefusal | undefined;
+/** Why an untrusted link's text alone is refused ({@link untrustedTextRefusal}). */
+type UntrustedTextRefusal = 'network' | 'absolute' | 'drive-relative' | 'unportable';
+/**
+ * Why a committed link — `linkPath` (its `/`-separated place in the tree) whose text is `text` — is
+ * refused by its text alone, before it exists on disk: {@link untrustedTextRefusal}, or `climbs-out`
+ * when, joined onto the link's directory and split by EITHER flavor's separators, its `..`s rise above
+ * the tree's root — the same collapse the walk applies under win32.
+ *
+ * @returns The refusal, or `undefined` for a text that stays inside by its text alone
+ */
+export declare function untrustedLinkRefusal(linkPath: string, text: string): UntrustedTextRefusal | typeof CLIMBS_OUT | undefined;
+/**
+ * A name folded as Windows compares names: each character upcased on its own (an ordinal, simple
+ * case fold — never `toLowerCase`, never a mapping that changes a character's length, like `ß` → `SS`).
+ */
+export declare function win32FoldedName(name: string): string;
+/**
+ * Whether `path` is `root` or below it, both forward-slashed — case-blind under win32 by the
+ * ordinal fold Windows compares names with ({@link win32FoldedName}).
+ */
+export declare function isWithinUnder(path: string, root: string, flavor: PathFlavor): boolean;
+/**
+ * Where `start` leads, every link on the way read by its text before anything follows it.
+ *
+ * @param start - An absolute path, in `rule.flavor`'s spelling (forward or back slashes)
+ * @param rule - The flavor, the tree, and what the chain may do outside it
+ * @param probe - `lstat` and `readlink`, and nothing that follows a link
+ * @returns The local path the kernel may now be asked about, nothing, or the refusal
+ * @throws whatever `probe` throws: a probe the OS refused is the caller's to classify
+ */
+export declare function walkLinkChain(start: string, rule: ChainRule, probe: ChainProbe): LinkChain;
+export {};
+//# sourceMappingURL=link-chain.d.ts.map

package/dist/tree-change/link-chain.d.ts.map

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

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

@@ -0,0 +1,377 @@
+/**
+ * The ONE resolver of a symbolic-link chain: where a path leads, walked hop by hop from what
+ * `lstat` and `readlink` say alone, so nothing is handed to the kernel until the whole chain has
+ * been read as text and shown to be local.
+ *
+ * That order is the point. A Windows kernel asked to resolve a path through a link to
+ * `\\host\share` opens an SMB session and offers the operator's NTLM credentials to that host
+ * before any answer comes back — so a `realpath` or a `stat` that follows links is a SECOND lock,
+ * asked only once this walk has proved the chain local, never the first.
+ *
+ * Pure: the caller supplies the path {@link PathFlavor} and the probe, so a test runs Windows
+ * semantics on any host. The flavor decides two things the kernel decides:
+ *
+ * - what separates a link text's components, and what makes it absolute or a network path
+ *   (`\\host\share`, `\\?\UNC\…`, `\\.\…`, `//host/share` under win32; on POSIX a backslash is a
+ *   character of a name and `//x` is the local root);
+ * - what `..` means. POSIX resolves a link before the `..` after it, physically (the parent of
+ *   where the link LED). Windows joins a relative link text onto the link's directory and collapses
+ *   every `..` lexically before reparsing — `x\..\y` is `y` whether `x` exists, is a file or a link —
+ *   so under win32 each splice is collapsed by string first, and every component it leaves is examined.
+ *
+ * Running out of hops ({@link MAX_LINK_HOPS}) is a refusal, never an answer: a chain the walk did
+ * not finish reading is a chain the kernel would finish for it. A CYCLE is different, and is told
+ * apart exactly: the walk meets the same link with the same text left to read, so every text in
+ * the cycle has been read and is local, and the kernel can only answer `ELOOP` — it resolves to
+ * nothing, as a dangling link does, in every lane.
+ *
+ * An untrusted tree ({@link ChainRule.outside} `refuse`) may be read on either host — a clone made
+ * here is installed there — so its every link text is also held to the OTHER flavor's rules
+ * ({@link untrustedTextRefusal}): a text that is absolute, drive-relative or a network path on
+ * either kernel is refused on both.
+ */
+import { posix } from 'node:path';
+import { toForwardSlashAnyPlatform } from '../path-core.js';
+/** The flavor of the host VAT runs on — the edge where a pure caller's flavor is bound. */
+export const HOST_PATH_FLAVOR = process.platform === 'win32' ? 'win32' : 'posix';
+/**
+ * How many links one resolution follows before it refuses. Windows' limit — 63 reparse points in
+ * one path — is the larger of the two kernels' (Linux's `MAXSYMLINKS` is 40), so no chain a kernel
+ * would still follow is ever cut short and answered.
+ */
+export const MAX_LINK_HOPS = 63;
+/** `X:\…` / `X:/…`, slashes already forward: the one absolute form of a link text a Windows kernel resolves locally. */
+const WIN32_DRIVE_ABSOLUTE = /^([A-Za-z]:)\//;
+/** `\\?\C:\…` / `\\.\C:\…`, slashes already forward: a local drive through the Win32 namespace — a NAMED path only. */
+const WIN32_NAMESPACED_DRIVE = /^\/\/[?.]\/([A-Za-z]:)(?:\/|$)/;
+/** `\\?\Volume{GUID}\…`, slashes already forward: a local volume by its GUID — a NAMED path only. */
+const WIN32_VOLUME = /^\/\/\?\/(Volume\{[0-9A-Fa-f-]+\})(?:\/|$)/;
+/** `\\host\share\…` / `\\?\UNC\host\share\…`, slashes already forward: the share a NAMED path (never a link's text) hangs from. */
+const WIN32_SHARE_ROOT = /^\/\/(?:\?\/UNC\/)?([^/?.][^/]*\/[^/]+)(?:\/|$)/i;
+const WIN32_DRIVE_ROOT = /^([A-Za-z]:)(?:\/|$)/;
+const WIN32_DRIVE_RELATIVE = /^[A-Za-z]:/;
+/** The non-empty, non-`.` components of `text`, spelled with POSIX separators (a win32 text is converted first). */
+function partsOf(text) {
+    return text.split(posix.sep).filter((part) => part !== '' && part !== '.');
+}
+const DRIVE_RELATIVE = 'drive-relative';
+const CLIMBS_OUT = 'climbs-out';
+/**
+ * How a link's TEXT reads under `flavor` — an ALLOWLIST under win32, never a list of network
+ * spellings: a text is local only when it is relative (no leading separator, no drive) or
+ * drive-absolute (`X:\…`). Every other form — UNC, `\\?\…`, `\\.\…`, the NT object paths libuv's
+ * `readlink` hands back verbatim (`\??\GLOBALROOT\Device\Mup\…`, `\??\Volume{…}\…`, `\Device\…`,
+ * `\DosDevices\…`, `\GLOBAL??\…`), a root-relative `\x`, and anything not recognised — is a
+ * network or device path, which the walk never resolves and the kernel is never asked about.
+ *
+ * @param text - A link's text, verbatim
+ * @param flavor - Whose rules
+ */
+function textForm(text, flavor) {
+    if (flavor === 'posix') {
+        return text.startsWith('/') ? { form: 'rooted', rooted: { prefix: '/', parts: partsOf(text) } } : { form: 'relative', parts: partsOf(text) };
+    }
+    const slashed = toForwardSlashAnyPlatform(text);
+    const drive = WIN32_DRIVE_ABSOLUTE.exec(slashed);
+    if (drive?.[1] !== undefined)
+        return { form: 'rooted', rooted: { prefix: `${drive[1].toUpperCase()}/`, parts: partsOf(slashed.slice(drive[0].length)) } };
+    if (WIN32_DRIVE_RELATIVE.test(slashed))
+        return { form: DRIVE_RELATIVE };
+    if (slashed.startsWith('/'))
+        return { form: 'network' };
+    return { form: 'relative', parts: partsOf(slashed) };
+}
+/**
+ * How a NAMED path (the start or the root — what the operator or VAT spelled, never a link's text)
+ * reads. Under win32 it may hang from a drive, a namespaced drive, a volume or a share: a tree on
+ * `\\host\share` is the operator's choice, while a link's text naming any of them is never
+ * followed ({@link textForm}). A rooted-but-driveless `\x` hangs from `drive`.
+ */
+function anchoredForm(path, flavor, drive) {
+    if (flavor === 'posix')
+        return textForm(path, flavor);
+    const slashed = toForwardSlashAnyPlatform(path);
+    const rooted = (prefix, rest) => ({ form: 'rooted', rooted: { prefix, parts: partsOf(rest) } });
+    const anchors = [
+        [WIN32_DRIVE_ROOT, (name) => `${name.toUpperCase()}/`],
+        [WIN32_NAMESPACED_DRIVE, (name) => `${name.toUpperCase()}/`],
+        [WIN32_VOLUME, (name) => `//?/${name}/`],
+        [WIN32_SHARE_ROOT, (name) => `//${name}/`],
+    ];
+    for (const [pattern, prefixOf] of anchors) {
+        const match = pattern.exec(slashed);
+        if (match?.[1] !== undefined)
+            return rooted(prefixOf(match[1]), slashed.slice(match[0].length));
+    }
+    if (slashed.startsWith('//'))
+        return { form: 'network' };
+    return slashed.startsWith('/') ? rooted(drive, slashed) : textForm(path, flavor);
+}
+/**
+ * The root a NAMED path hangs from — `/`, a drive's `C:/`, a share's `//host/share/` — for a walk
+ * of the user's own path, which may lead anywhere local.
+ *
+ * @param path - Absolute, forward- or back-slashed
+ * @param flavor - Whose rules
+ * @throws TypeError for a path that is not absolute under `flavor`
+ */
+export function namedPathRoot(path, flavor) {
+    const form = anchoredForm(path, flavor, '/');
+    if (form.form !== 'rooted')
+        throw new TypeError(`namedPathRoot: not an absolute local path: ${path}`);
+    return form.rooted.prefix;
+}
+const FLAVORS = ['posix', 'win32'];
+/**
+ * Why a link text in an UNTRUSTED tree is refused by its text alone, under EITHER flavor — the rule
+ * a chain in a `refuse` tree is held to at every hop, and the one a caller that has only the text
+ * (a git clone reading link blobs before checkout) asks directly.
+ *
+ * A text is also `unportable` when it holds a NUL (the OS cuts the text short there, so the walk
+ * would judge bytes no kernel sees) or a component ending in a dot or a space (Win32 strips those,
+ * so `.. ` would climb where the walk read a name) — the win32 rule held on every host.
+ *
+ * @param text - A link's text, verbatim
+ * @returns why either kernel would not read it as a relative text inside the tree; `undefined` for one it would
+ */
+export function untrustedTextRefusal(text) {
+    if (isUnportableText(text))
+        return 'unportable';
+    const [posixForm, win32Form] = FLAVORS.map((flavor) => textForm(text, flavor).form);
+    // `/etc/x` is a POSIX absolute path (and a device path to Windows); `\\host\share`, `\??\…` and
+    // `//host/share` name a network or device path to Windows whatever POSIX reads them as.
+    if (win32Form === 'network')
+        return posixForm === 'rooted' && !toForwardSlashAnyPlatform(text).startsWith('//') ? 'absolute' : 'network';
+    if (win32Form === DRIVE_RELATIVE)
+        return DRIVE_RELATIVE;
+    if (posixForm === 'rooted' || win32Form === 'rooted')
+        return 'absolute';
+    return undefined;
+}
+/** A component that is a name ending in `.` or a space (never `.` or `..` themselves): Win32 strips the ending. */
+const STRIPPED_ENDING = /(?:^|[/\\])(?!\.\.?(?:[/\\]|$))[^/\\]*[. ](?:[/\\]|$)/;
+/** Whether `text` holds a NUL, or a component Windows would rename by stripping its ending. */
+function isUnportableText(text) {
+    return text.includes(String.fromCodePoint(0)) || STRIPPED_ENDING.test(text);
+}
+/**
+ * Collapse `..` by string — what Windows does to a name before it reparses it — saying whether a
+ * `..` met nothing left to pop: the name climbed above the place it started from.
+ */
+function collapse(parts) {
+    const out = [];
+    let climbed = false;
+    for (const part of parts) {
+        if (part !== '..')
+            out.push(part);
+        else if (out.pop() === undefined)
+            climbed = true;
+    }
+    return { parts: out, climbed };
+}
+/** {@link collapse}, never above the root. */
+function collapsed(parts) {
+    return collapse(parts).parts;
+}
+/**
+ * Why a committed link — `linkPath` (its `/`-separated place in the tree) whose text is `text` — is
+ * refused by its text alone, before it exists on disk: {@link untrustedTextRefusal}, or `climbs-out`
+ * when, joined onto the link's directory and split by EITHER flavor's separators, its `..`s rise above
+ * the tree's root — the same collapse the walk applies under win32.
+ *
+ * @returns The refusal, or `undefined` for a text that stays inside by its text alone
+ */
+export function untrustedLinkRefusal(linkPath, text) {
+    const why = untrustedTextRefusal(text);
+    if (why !== undefined)
+        return why;
+    const splitters = [(value) => value, toForwardSlashAnyPlatform];
+    const climbs = splitters.some((spell) => collapse([...partsOf(posix.dirname(spell(linkPath))), ...partsOf(spell(text))]).climbed);
+    return climbs ? CLIMBS_OUT : undefined;
+}
+/**
+ * A name folded as Windows compares names: each character upcased on its own (an ordinal, simple
+ * case fold — never `toLowerCase`, never a mapping that changes a character's length, like `ß` → `SS`).
+ */
+export function win32FoldedName(name) {
+    let folded = '';
+    for (const character of name) {
+        const upper = character.toUpperCase();
+        folded += upper.length === character.length ? upper : character;
+    }
+    return folded;
+}
+/** `prefix` + `parts`, forward-slashed. */
+function joined(prefix, parts) {
+    return prefix + parts.join('/');
+}
+/**
+ * Whether `path` is `root` or below it, both forward-slashed — case-blind under win32 by the
+ * ordinal fold Windows compares names with ({@link win32FoldedName}).
+ */
+export function isWithinUnder(path, root, flavor) {
+    const [p, r] = flavor === 'win32' ? [win32FoldedName(path), win32FoldedName(root)] : [path, root];
+    const base = r.endsWith('/') ? r : `${r}/`;
+    return p === r || p.startsWith(base);
+}
+/**
+ * Splice a link's text into the walk in place of the link (already popped from `done`), as
+ * `flavor`'s kernel would; or the refusal of a text it never resolves.
+ */
+function splice(walk, link, text, rule) {
+    walk.link = link;
+    walk.text = text;
+    const form = textForm(text, rule.flavor);
+    if (form.form === 'network')
+        return { why: 'network', link, text };
+    if (form.form === 'drive-relative')
+        return { why: DRIVE_RELATIVE, link, text };
+    if (rule.outside === 'refuse') {
+        const why = untrustedTextRefusal(text);
+        if (why !== undefined)
+            return { why, link, text };
+    }
+    if (form.form === 'rooted') {
+        if (rule.flavor === 'win32')
+            return rebase(walk, form.rooted.prefix, collapsed([...form.rooted.parts, ...walk.pending]), rule);
+        walk.prefix = form.rooted.prefix;
+        walk.pending = [...form.rooted.parts, ...walk.pending];
+        walk.done = [];
+        return undefined;
+    }
+    if (rule.flavor === 'win32') {
+        // Joined onto the link's directory and collapsed by string BEFORE anything is looked at, then
+        // re-walked: a `..` never asks what the component before it is.
+        const whole = [...walk.done, ...form.parts, ...walk.pending];
+        // The collapse forgets a climb that comes back in by the root's own name; a tree that may not be left sees it on the way.
+        if (rule.outside === 'refuse' && risesAbove(whole, walk.base.parts.length))
+            return { why: CLIMBS_OUT, link, text };
+        return rebase(walk, walk.prefix, collapsed(whole), rule);
+    }
+    walk.pending = [...form.parts, ...walk.pending];
+    return undefined;
+}
+/** Whether collapsing `parts` by string ever leaves fewer than `floor` components: the name passes above the root. */
+function risesAbove(parts, floor) {
+    let depth = 0;
+    for (const part of parts) {
+        if (part === '..')
+            depth -= 1;
+        else if (part !== '.' && part !== '')
+            depth += 1;
+        if (depth < floor && part === '..')
+            return true;
+    }
+    return false;
+}
+/**
+ * Re-walk the whole name `prefix` + `parts` (a win32 splice, already collapsed): from the tree's
+ * root when the name is below it — the root's own components are real directories — else from the
+ * name's own root, which only a tree whose links may leave it allows.
+ */
+function rebase(walk, prefix, parts, rule) {
+    const { base } = walk;
+    if (isWithinUnder(joined(prefix, parts), joined(base.prefix, base.parts), rule.flavor)) {
+        walk.prefix = base.prefix;
+        walk.done = [...base.parts];
+        walk.pending = parts.slice(base.parts.length);
+        return undefined;
+    }
+    if (rule.outside === 'refuse')
+        return { why: CLIMBS_OUT, link: walk.link, text: walk.text };
+    walk.prefix = prefix;
+    walk.done = [];
+    walk.pending = parts;
+    return undefined;
+}
+/** The walk's starting position for `start`: from the root when `start` is below it, else from its own root. */
+function startOf(start, rule, rootParts) {
+    const form = anchoredForm(start, rule.flavor, rootParts.prefix);
+    if (form.form === 'network')
+        return { why: 'network', link: start, text: start };
+    if (form.form !== 'rooted')
+        return { why: DRIVE_RELATIVE, link: start, text: start };
+    const parts = rule.flavor === 'win32' ? collapsed(form.rooted.parts) : [...form.rooted.parts];
+    const path = joined(form.rooted.prefix, parts);
+    const root = joined(rootParts.prefix, rootParts.parts);
+    if (isWithinUnder(path, root, rule.flavor) && (rule.flavor === 'win32' || !parts.includes('..'))) {
+        return { base: rootParts, prefix: rootParts.prefix, done: [...rootParts.parts], pending: parts.slice(rootParts.parts.length), link: start, text: start };
+    }
+    if (rule.outside === 'refuse')
+        return { why: CLIMBS_OUT, link: start, text: start };
+    return { base: rootParts, prefix: form.rooted.prefix, done: [], pending: parts, link: start, text: start };
+}
+/**
+ * Where `start` leads, every link on the way read by its text before anything follows it.
+ *
+ * @param start - An absolute path, in `rule.flavor`'s spelling (forward or back slashes)
+ * @param rule - The flavor, the tree, and what the chain may do outside it
+ * @param probe - `lstat` and `readlink`, and nothing that follows a link
+ * @returns The local path the kernel may now be asked about, nothing, or the refusal
+ * @throws whatever `probe` throws: a probe the OS refused is the caller's to classify
+ */
+export function walkLinkChain(start, rule, probe) {
+    const rootForm = anchoredForm(rule.root, rule.flavor, '/');
+    if (rootForm.form !== 'rooted')
+        throw new TypeError(`walkLinkChain: the root must be a local absolute path, not ${rule.root}`);
+    const root = joined(rootForm.rooted.prefix, rootForm.rooted.parts);
+    const begun = startOf(start, rule, rootForm.rooted);
+    if ('why' in begun)
+        return { kind: 'refused', refusal: begun };
+    const walk = begun;
+    let final = 'directory';
+    // Each link met, with the text still to read after it: meeting one again is a cycle, exactly.
+    const followed = { met: new Set(), hops: 0 };
+    for (let part = walk.pending.shift(); part !== undefined; part = walk.pending.shift()) {
+        const step = stepTo(walk, part, rule, root, probe);
+        if (step.kind !== 'step')
+            return step;
+        if (step.stands === 'link') {
+            const ended = followLink(walk, rule, probe, followed);
+            if (ended !== undefined)
+                return ended;
+        }
+        else {
+            final = step.stands;
+        }
+    }
+    return { kind: 'resolved', path: joined(walk.prefix, walk.done), final };
+}
+/**
+ * Take one component: the kind that now stands at the walk's place (a `..` is a directory — the
+ * parent of a real directory), or the answer that ends the walk.
+ */
+function stepTo(walk, part, rule, root, probe) {
+    if (part === '..')
+        walk.done.pop();
+    else
+        walk.done.push(part);
+    const here = joined(walk.prefix, walk.done);
+    if (rule.outside === 'refuse' && !isWithinUnder(here, root, rule.flavor))
+        return { kind: 'refused', refusal: { why: CLIMBS_OUT, link: walk.link, text: walk.text } };
+    if (part === '..')
+        return { kind: 'step', stands: 'directory' };
+    const kind = probe.kindAt(here);
+    if (kind === 'absent' || (kind === 'file' && walk.pending.length > 0))
+        return { kind: 'nothing', at: here, cause: 'absent' };
+    return { kind: 'step', stands: kind };
+}
+/**
+ * Follow the link at the walk's place by its text: a cycle when this link was already met with the
+ * same text left to read, the hop limit's refusal past {@link MAX_LINK_HOPS} links, the text's own
+ * refusal, or `undefined` to walk on. The hop count bounds the walk on its own, cycle or not.
+ */
+function followLink(walk, rule, probe, followed) {
+    const here = joined(walk.prefix, walk.done);
+    const state = `${here}\0${walk.pending.join('/')}`;
+    followed.hops += 1;
+    if (followed.met.has(state))
+        return { kind: 'nothing', at: here, cause: 'cycle' };
+    followed.met.add(state);
+    if (followed.hops > MAX_LINK_HOPS)
+        return { kind: 'refused', refusal: { why: 'hop-limit', link: here } };
+    walk.done.pop();
+    const refusal = splice(walk, here, probe.textAt(here), rule);
+    return refusal === undefined ? undefined : { kind: 'refused', refusal };
+}
+//# sourceMappingURL=link-chain.js.map

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

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