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

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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAElC,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAQ5D,2FAA2F;AAC3F,MAAM,CAAC,MAAM,gBAAgB,GAAe,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;AAE7F;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAC;AAkEhC,wHAAwH;AACxH,MAAM,oBAAoB,GAAG,gBAAgB,CAAC;AAC9C,uHAAuH;AACvH,MAAM,sBAAsB,GAAG,gCAAgC,CAAC;AAChE,qGAAqG;AACrG,MAAM,YAAY,GAAG,4CAA4C,CAAC;AAClE,mIAAmI;AACnI,MAAM,gBAAgB,GAAG,kDAAkD,CAAC;AAC5E,MAAM,gBAAgB,GAAG,sBAAsB,CAAC;AAChD,MAAM,oBAAoB,GAAG,YAAY,CAAC;AAE1C,oHAAoH;AACpH,SAAS,OAAO,CAAC,IAAY;IAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,IAAI,IAAI,KAAK,GAAG,CAAC,CAAC;AAC7E,CAAC;AAED,MAAM,cAAc,GAAG,gBAAgB,CAAC;AACxC,MAAM,UAAU,GAAG,YAAY,CAAC;AAEhC;;;;;;;;;;GAUG;AACH,SAAS,QAAQ,CAAC,IAAY,EAAE,MAAkB;IAChD,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;QACvB,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;IAC/I,CAAC;IACD,MAAM,OAAO,GAAG,yBAAyB,CAAC,IAAI,CAAC,CAAC;IAChD,MAAM,KAAK,GAAG,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACjD,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC;IAC1J,IAAI,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;IACxE,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IACxD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;AACvD,CAAC;AAED;;;;;GAKG;AACH,SAAS,YAAY,CAAC,IAAY,EAAE,MAAkB,EAAE,KAAa;IACnE,IAAI,MAAM,KAAK,OAAO;QAAE,OAAO,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACtD,MAAM,OAAO,GAAG,yBAAyB,CAAC,IAAI,CAAC,CAAC;IAChD,MAAM,MAAM,GAAG,CAAC,MAAc,EAAE,IAAY,EAAY,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IAC1H,MAAM,OAAO,GAAgE;QAC3E,CAAC,gBAAgB,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC;QACtD,CAAC,sBAAsB,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC;QAC5D,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,GAAG,CAAC;QACxC,CAAC,gBAAgB,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,IAAI,GAAG,CAAC;KAC3C,CAAC;IACF,KAAK,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,IAAI,OAAO,EAAE,CAAC;QAC1C,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,SAAS;YAAE,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAClG,CAAC;IACD,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IACzD,OAAO,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AACnF,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,MAAkB;IAC5D,MAAM,IAAI,GAAG,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7C,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ;QAAE,MAAM,IAAI,SAAS,CAAC,8CAA8C,IAAI,EAAE,CAAC,CAAC;IACtG,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;AAC5B,CAAC;AAED,MAAM,OAAO,GAA0B,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAY;IAC/C,IAAI,gBAAgB,CAAC,IAAI,CAAC;QAAE,OAAO,YAAY,CAAC;IAChD,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;IACpF,gGAAgG;IAChG,wFAAwF;IACxF,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,SAAS,KAAK,QAAQ,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;IACzI,IAAI,SAAS,KAAK,cAAc;QAAE,OAAO,cAAc,CAAC;IACxD,IAAI,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,QAAQ;QAAE,OAAO,UAAU,CAAC;IACxE,OAAO,SAAS,CAAC;AACnB,CAAC;AAKD,mHAAmH;AACnH,MAAM,eAAe,GAAG,uDAAuD,CAAC;AAEhF,+FAA+F;AAC/F,SAAS,gBAAgB,CAAC,IAAY;IACpC,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC9E,CAAC;AAED;;;GAGG;AACH,SAAS,QAAQ,CAAC,KAAwB;IACxC,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,KAAK,IAAI;YAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAC7B,IAAI,GAAG,CAAC,GAAG,EAAE,KAAK,SAAS;YAAE,OAAO,GAAG,IAAI,CAAC;IACnD,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC;AACjC,CAAC;AAED,8CAA8C;AAC9C,SAAS,SAAS,CAAC,KAAwB;IACzC,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC;AAC/B,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAgB,EAAE,IAAY;IACjE,MAAM,GAAG,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACvC,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,GAAG,CAAC;IAClC,MAAM,SAAS,GAA2C,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,yBAAyB,CAAC,CAAC;IACxG,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAClI,OAAO,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,MAAM,SAAS,IAAI,IAAI,EAAE,CAAC;QAC7B,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,2CAA2C;AAC3C,SAAS,MAAM,CAAC,MAAc,EAAE,KAAwB;IACtD,OAAO,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,IAAY,EAAE,MAAkB;IAC1E,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAClG,MAAM,IAAI,GAAG,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IAC3C,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC;AAcD;;;GAGG;AACH,SAAS,MAAM,CAAC,IAAU,EAAE,IAAY,EAAE,IAAY,EAAE,IAAe;IACrE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACjB,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACnE,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB;QAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAC/E,IAAI,IAAI,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;QAC9B,MAAM,GAAG,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,GAAG,KAAK,SAAS;YAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACpD,CAAC;IACD,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,MAAM,KAAK,OAAO;YAAE,OAAO,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QAC/H,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;QACjC,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QACvD,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;QACf,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,IAAI,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;QAC5B,8FAA8F;QAC9F,gEAAgE;QAChE,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7D,0HAA0H;QAC1H,IAAI,IAAI,CAAC,OAAO,KAAK,QAAQ,IAAI,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;YAAE,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QACnH,OAAO,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;IACD,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAChD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,sHAAsH;AACtH,SAAS,UAAU,CAAC,KAAwB,EAAE,KAAa;IACzD,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,KAAK,IAAI;YAAE,KAAK,IAAI,CAAC,CAAC;aACzB,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,EAAE;YAAE,KAAK,IAAI,CAAC,CAAC;QACjD,IAAI,KAAK,GAAG,KAAK,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;IAClD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,SAAS,MAAM,CAAC,IAAU,EAAE,MAAc,EAAE,KAAe,EAAE,IAAe;IAC1E,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;IACtB,IAAI,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACvF,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC9C,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,IAAI,CAAC,OAAO,KAAK,QAAQ;QAAE,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;IAC5F,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACrB,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;IACf,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACrB,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,gHAAgH;AAChH,SAAS,OAAO,CAAC,KAAa,EAAE,IAAe,EAAE,SAAiB;IAChE,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAChE,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACjF,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACrF,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9F,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC/C,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;IACvD,IAAI,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;QACjG,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IAC3J,CAAC;IACD,IAAI,IAAI,CAAC,OAAO,KAAK,QAAQ;QAAE,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACpF,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AAC7G,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa,EAAE,IAAe,EAAE,KAAiB;IAC7E,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3D,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ;QAAE,MAAM,IAAI,SAAS,CAAC,8DAA8D,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IAC/H,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACnE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACpD,IAAI,KAAK,IAAI,KAAK;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC/D,MAAM,IAAI,GAAG,KAAK,CAAC;IACnB,IAAI,KAAK,GAAyB,WAAW,CAAC;IAC9C,8FAA8F;IAC9F,MAAM,QAAQ,GAAa,EAAE,GAAG,EAAE,IAAI,GAAG,EAAU,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;IAC/D,KAAK,IAAI,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,IAAI,KAAK,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;QACtF,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACnD,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,IAAI,CAAC;QACtC,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;YAC3B,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;YACtD,IAAI,KAAK,KAAK,SAAS;gBAAE,OAAO,KAAK,CAAC;QACxC,CAAC;aAAM,CAAC;YACN,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QACtB,CAAC;IACH,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC;AAC3E,CAAC;AAKD;;;GAGG;AACH,SAAS,MAAM,CAAC,IAAU,EAAE,IAAY,EAAE,IAAe,EAAE,IAAY,EAAE,KAAiB;IACxF,IAAI,IAAI,KAAK,IAAI;QAAE,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;;QAC9B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5C,IAAI,IAAI,CAAC,OAAO,KAAK,QAAQ,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;IACrK,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;IAChE,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,IAAI,KAAK,QAAQ,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IAC7H,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AACxC,CAAC;AAQD;;;;GAIG;AACH,SAAS,UAAU,CAAC,IAAU,EAAE,IAAe,EAAE,KAAiB,EAAE,QAAkB;IACpF,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5C,MAAM,KAAK,GAAG,GAAG,IAAI,KAAK,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;IACnD,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;IACnB,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAClF,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACxB,IAAI,QAAQ,CAAC,IAAI,GAAG,aAAa;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC;IACzG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;IAChB,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;IAC7D,OAAO,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;AAC1E,CAAC"}

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

@@ -0,0 +1,105 @@
+/**
+ * The rule for a tree whose links are KEPT: none of them may lead outside it.
+ *
+ * A copy that preserves links carries each link's text verbatim, so a link out of the tree
+ * arrives pointing at whatever stands at that path beside the COPY — the installing user's own
+ * files — and every reader of the copy that follows links reads them as the tree's content. So a
+ * tree that came from somewhere VAT does not own (a cloned repository, a directory an operator
+ * installs from) is checked here before anything reads it.
+ */
+import { type FsSide } from '../errors/fs-fault.js';
+import { type LinkChain, type PathFlavor } from './link-chain.js';
+/** What {@link refuseEscapingLinks} checks, and how its refusal names it. */
+export interface LinkContainmentCheck {
+    /** The tree no link may lead out of. */
+    readonly root: string;
+    /** Where in it to look; the whole of `root` when omitted. */
+    readonly subtree?: string;
+    /** A directory under `root` that is never entered (a clone's `.git`). */
+    readonly skip?: string;
+    /**
+     * Whether the tree is read where it stands, or will be RELOCATED (an install copies it, each
+     * link's text verbatim).
+     *
+     * - `in-place`: a link is judged by where it leads NOW. Its chain is read first, link by link,
+     *   by the one resolver ({@link treeChain}), so nothing is resolved until every text on the way
+     *   is: a network, absolute or drive-relative text anywhere on the way, a climb above the root,
+     *   or a chain no kernel finishes, is refused. Then its real path must be inside. One that leads
+     *   to nothing (a dangle, a cycle) reads nothing, so it is not refused.
+     * - `relocated`: where a link leads now proves nothing about where its text leads once the tree
+     *   is somewhere else, so the text itself is walked ({@link linkTextRefusal}): relative, never
+     *   above the root, through no other link, and ending at something that exists. Then the chain
+     *   from it is read as in place, and only then is the kernel asked ({@link kernelRefusal}).
+     */
+    readonly placement: 'in-place' | 'relocated';
+    /** Which side the tree is on: every probe of it the OS refuses — a listing, an `lstat`, a `readlink`, a link's target — is that side's fault. */
+    readonly side: FsSide;
+    /** Whose kernel reads the tree: bound from `process.platform` at the edge (`HOST_PATH_FLAVOR`). */
+    readonly flavor: PathFlavor;
+    /** What the tree is, for the refusal: `the cloned repository`. */
+    readonly tree: string;
+    /** What a link must stay inside, for the refusal: `the clone`. */
+    readonly within: string;
+    /** What keeping the link would do, for the refusal — a sentence without its full stop. */
+    readonly consequence: string;
+}
+/**
+ * Where `candidate` stands relative to `root`, on real paths. The root itself counts as inside
+ * (`isUnderRoot` calls a root `outside` itself, which is right for a sink and wrong here).
+ *
+ * @param root - The tree
+ * @param candidate - A path in any spelling, existing or not
+ */
+export declare function treeContainment(root: string, candidate: string): 'inside' | 'outside' | 'absent';
+/**
+ * Where `path` leads in an UNTRUSTED tree, read link by link by the one resolver — `lstat` and
+ * `readlink` alone — before anything resolves it: an absolute, drive-relative or network text on
+ * the way (under either flavor: the tree may be read on the other host), a climb above `root`,
+ * or a chain longer than the hop limit that is not a cycle, is refused; a cycle leads to
+ * nothing, as a dangling link does; nothing outside `root` is probed.
+ *
+ * @param root - The tree, spelled as `path` spells it (its own components are never probed)
+ * @param path - A path below it (a link, or a subpath the operator named)
+ * @param flavor - Whose kernel will resolve it: bound from the host at the edge
+ * @throws The raw errno of an `lstat` or `readlink` the OS refused, for the caller to classify
+ */
+export declare function treeChain(root: string, path: string, flavor: PathFlavor): LinkChain;
+/**
+ * The last lock on a link of a tree that will be relocated: the KERNEL's resolution of it, at
+ * the source, must exist and be inside the tree. Asked only once the chain from the link has been
+ * read and shown local ({@link treeChain}). The walk of the text ({@link linkTextRefusal}) shows
+ * the text stays inside wherever the tree goes; this shows the walk's reading of the text is the
+ * kernel's. A probe that failed because the link resolves to nothing
+ * (`isUnresolvableLinkError`: it dangles, it is part of a cycle, Windows cannot follow its reparse
+ * data) is a refusal of the link on every host: nothing can be shown about where it leads. Every
+ * other failure — the OS declining (`EACCES`, `EPERM`), running short (`EMFILE`), held (`EBUSY`) or
+ * unable to look (`EIO`, `ETIMEDOUT`, Windows' ambiguous `UNKNOWN`) — says nothing about the link:
+ * a fault on the tree, thrown classified by the one write-lane catch body
+ * (`assertUnresolvableLink`, on the side the caller names in `check.side`, found as content).
+ *
+ * Exported apart from the walk so the lock can be shown to hold ALONE: with a correct walk, a
+ * link the kernel resolves outside never reaches it from a real tree.
+ *
+ * @param root - The tree, as its canonical path
+ * @param link - The link, spelled by its real directory
+ * @param text - The link's own text, for the refusal
+ * @returns Why the link is refused, after "is a symbolic link ", or `undefined` when the kernel agrees
+ * @throws FsFaultError on `check.side` for a probe that failed for any other reason; an error that carries no errno as it was
+ */
+export declare function kernelRefusal(check: LinkContainmentCheck, root: string, link: string, text: string): string | undefined;
+/**
+ * Refuse a tree holding a symbolic link that may not be kept: one leading outside it, and — for a
+ * tree that will be relocated — one whose text cannot be shown to stay inside wherever the tree
+ * goes ({@link LinkContainmentCheck.placement}). Every directory is walked at its REAL path, once: a
+ * link that stays inside is followed to the directory it names, so a link into a sibling cannot
+ * smuggle out a second hop, a link cycle ends, and a directory first reached through an alias still
+ * has its own links judged where they live.
+ *
+ * @param check - The tree, where in it to look, and how the refusal names it
+ * @throws VatError `COPY_LINK_ESCAPES_SOURCE` — the tree's own link, so the input's refusal —
+ *   naming the first link found leading out; FsFaultError on `check.side`, found as content, for
+ *   every probe of the tree the OS refused (a listing, an `lstat`, a `readlink`, a relocated link's
+ *   target)
+ */
+export declare function refuseEscapingLinks(check: LinkContainmentCheck): void;
+//# sourceMappingURL=link-containment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"link-containment.d.ts","sourceRoot":"","sources":["../../src/tree-change/link-containment.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,EAA0B,KAAK,MAAM,EAAmB,MAAM,uBAAuB,CAAC;AAQ7F,OAAO,EAAqB,KAAK,SAAS,EAAiB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGpG,6EAA6E;AAC7E,MAAM,WAAW,oBAAoB;IACnC,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,SAAS,EAAE,UAAU,GAAG,WAAW,CAAC;IAC7C,iJAAiJ;IACjJ,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mGAAmG;IACnG,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,0FAA0F;IAC1F,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAGhG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,SAAS,CAEnF;AAyCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,oBAAoB,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAavH;AAqCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI,CAgBrE"}