@telora/daemon 0.22.104 → 0.22.132

package/dist/worktree/install-inputs.js

@@ -0,0 +1,625 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/worktree/install-inputs.test.ts
+// PINNED-BY-END
+/**
+ * What one `npm ci` CONSUMES from the repo: the single install-input model behind
+ * both the provisioning fingerprint (worktree/worktree-package-provisioning.ts --
+ * is a reused worktree's install current?) and the baseline dependency parity
+ * (verify/verification-baseline-run.ts -- do the focus worktree's installs stand
+ * for the base's?).
+ *
+ * Why one model (TEL-9). Both used to read only manifests: parity compared an
+ * install lifecycle command STRING, the fingerprint hashed lockfile + package.json.
+ * An unchanged `postinstall: node scripts/patch.cjs` whose script changed was
+ * therefore comparable AND current: HEAD's `npm ci` mutated node_modules one way,
+ * the base checkout borrowed those modules, and a red the focus's script caused
+ * reproduced on the base and was demoted. Two answers over two input sets can
+ * disagree; one set cannot.
+ *
+ * Design: static reference resolution, not a base install. The inventory of this
+ * repo (2026-09-15) drove it. Its install roots (tracked lockfiles) are the root,
+ * packages/daemon, packages/daemon-core, mcp/telora-products and
+ * starters/aurora-shell; across them there is exactly ONE install lifecycle
+ * script -- mcp/telora-products `postinstall: node scripts/postinstall.js || true`,
+ * a builtins-only ESM file -- and no prepare/husky, no gypfile, no binding.gyp,
+ * no workspaces or in-repo links (mcp/telora-ai's `postinstall: telora-ai
+ * setup-hooks` has no lockfile, so no install runs it). Following `node <file>`
+ * and what it loads keeps base attribution live for every focus that leaves that
+ * script alone. Building the base under its own inputs would instead cost an
+ * `npm ci` of every root per base commit (minutes on the daemon hosts, and
+ * registry-dependent), and the fingerprint would still need this input set.
+ *
+ * The model, for an install root R (a directory holding a tracked
+ * package-lock.json or npm-shrinkwrap.json):
+ *   - MANIFESTS: R's lockfiles and .npmrc, and the package.json and binding.gyp
+ *     of every package the install touches -- R, and each in-repo package R's
+ *     lockfile lists (a workspace member or `file:` link, whose lifecycle
+ *     scripts npm runs too);
+ *   - CONSUMED: what each touched package's install lifecycle scripts read. A
+ *     command is split on `&&` `||` `;` `|` `&` and newlines into simple
+ *     commands, each followed: `node <file>` (the file, its transitive RELATIVE
+ *     requires/imports, every string-literal token naming a tracked path, and
+ *     what its code reads, lists, copies and spawns -- worktree/install-script-effects.ts:
+ *     each builtin fs call's path and child_process command, resolved
+ *     statically to literal paths and commands, the commands followed in turn);
+ *     `sh|bash <file>` / `sh -c <cmd>` / `./<file>` (the script, its lines
+ *     followed as commands); `npm run <x>` (expanded into pre<x>, x, post<x>);
+ *     `patch-package` (its patch directory); `node-gyp` (a native build);
+ *     every other argument token that names a tracked file or directory is
+ *     consumed. {@link READS_NOTHING} lists, each with its reason, the commands
+ *     that read no install-relevant source;
+ *   - THE MANIFEST, WHOLE: a JS file that reaches the environment (`env`,
+ *     `npm_package_*`, `process` as a value) consumes its package's package.json,
+ *     every byte of it: npm exports the manifest to lifecycle scripts as
+ *     npm_package_* (config, version, ...), which the install-intent projection
+ *     parity compares does not carry;
+ *   - NATIVE ADDON: a package with a binding.gyp or `gypfile: true` (npm's
+ *     implicit `node-gyp rebuild`) consumes every tracked file under it;
+ *   - a JS file that addresses paths relative to its own location or the
+ *     working directory (`__dirname`, `import.meta`, `process.cwd`) consumes
+ *     every tracked file under its package.
+ * A path under the home or temp directory, or an absolute one, is host state,
+ * not a tracked input.
+ *
+ * Fail closed. Whatever the model cannot follow is UNRESOLVABLE: shell expansion
+ * (`$npm_package_config_mode` included), redirection or globbing; an environment
+ * assignment; a node flag or inline program; an unknown program (a node_modules
+ * bin can read anything); a relative import that names no tracked file; an import
+ * of in-repo package source by bare name, of a registry package (its functions
+ * can read any path), or of a builtin whose file access the scan does not follow;
+ * dynamic code loading (`require(expr)`, `import(expr)`, `eval`, `createRequire`,
+ * `process.chdir`); a file read, listing, copy or spawn whose path or command
+ * the script computes in a way that does not resolve to literals (a computed
+ * string, a variable bound more than once, an aliased fs function, a glob, a
+ * spawn `cwd`), and source the scan cannot tokenize; an unreadable lockfile or
+ * manifest. An unresolvable install's CONSUMED set widens to every tracked file
+ * of the REPOSITORY, not only R -- what the model cannot follow can read outside
+ * its root -- so the fingerprint changes when any of them does, and parity
+ * refuses it outright. Tracked files only: the model reads what git tracks, never
+ * untracked output.
+ *
+ * @module worktree/install-inputs
+ */
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { builtinModules } from 'node:module';
+import { join, posix } from 'node:path';
+import { runGitSync } from '../git/types.js';
+import { FOLLOWED_BUILTIN_MODULES, readScriptEffects } from './install-script-effects.js';
+/** The lockfiles that make a directory an install root (npm ci prefers the shrinkwrap). */
+export const INSTALL_LOCKFILES = ['npm-shrinkwrap.json', 'package-lock.json'];
+/**
+ * The package.json scripts an install runs, at any depth. npm documents the
+ * `npm ci` / `npm install` order in `npm help scripts` ("Life Cycle Operations":
+ * preinstall, install, postinstall, prepublish, preprepare, prepare, postprepare;
+ * "Life Cycle Scripts": `dependencies` runs after any operation that modifies
+ * node_modules), and npm 10's source runs exactly these:
+ *   - the root, after the tree is reified (lib/commands/ci.js, install.js):
+ *     preinstall, install, postinstall, prepublish, preprepare, prepare, postprepare;
+ *   - the root, whenever node_modules changed -- which `npm ci` always does
+ *     (@npmcli/arborist reify.js): predependencies, dependencies, postdependencies;
+ *   - every workspace and in-repo `file:` link (@npmcli/arborist rebuild.js):
+ *     preinstall, prepare, install, postinstall -- and `prepare` again for a
+ *     directory dependency packed under install-links (pacote dir.js).
+ * The pack scripts (prepack, postpack) are not in it: pacote runs "*only*
+ * prepare" when it packs a directory dependency, and the CLI runs them for
+ * pack/publish; a git dependency runs them from its remote manifest, which the
+ * lockfile pins. Every other script is gate or tool source the checkout pins.
+ */
+export const INSTALL_LIFECYCLE_SCRIPTS = [
+    'preinstall', 'install', 'postinstall', 'prepublish', 'preprepare', 'prepare', 'postprepare',
+    'predependencies', 'dependencies', 'postdependencies',
+];
+/** The fingerprint format; a marker holding any other value (an older format) is never current. */
+export const INSTALL_FINGERPRINT_FORMAT = 'install-inputs/v2';
+/** A bound on the files one install's scan follows; past it the install is unresolvable. */
+const MAX_SCANNED_FILES = 256;
+/** A bound on nested `npm run` expansion. */
+const MAX_SCRIPT_DEPTH = 16;
+const DEPENDENCY_DIR = 'node_modules';
+const isPlainObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+/** Normalize `rel` against a repo-relative `dir`; null when it leaves the repo or is absolute. */
+function joinRel(dir, rel) {
+    if (rel.startsWith('/'))
+        return null;
+    const joined = posix.normalize(dir === '' ? rel : `${dir}/${rel}`).replace(/\/+$/, '');
+    if (joined === '..' || joined.startsWith('../'))
+        return null;
+    return joined === '.' ? '' : joined;
+}
+const underNodeModules = (path) => path.split('/').includes(DEPENDENCY_DIR);
+/**
+ * A tree over a tracked path list and a byte reader. Paths under a node_modules
+ * segment are not install inputs and are dropped; `read` answers null for an
+ * untracked path without calling the reader.
+ */
+export function trackedInstallTree(paths, read) {
+    const files = [...new Set(paths.filter((path) => path.length > 0 && !underNodeModules(path)))].sort();
+    const tracked = new Set(files);
+    const filesUnder = (dir) => {
+        if (dir === '')
+            return [...files];
+        const prefix = `${dir}/`;
+        let low = 0;
+        let high = files.length;
+        while (low < high) {
+            const mid = (low + high) >> 1;
+            if (files[mid] < prefix)
+                low = mid + 1;
+            else
+                high = mid;
+        }
+        const found = [];
+        for (let index = low; index < files.length && files[index].startsWith(prefix); index++)
+            found.push(files[index]);
+        return found;
+    };
+    return { has: (path) => tracked.has(path), filesUnder, read: (path) => (tracked.has(path) ? read(path) : null) };
+}
+/** A working-tree file's bytes; null when it is gone (a tracked file deleted in the worktree). */
+function readWorkingFile(path) {
+    try {
+        return readFileSync(path);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT' || code === 'ENOTDIR')
+            return null;
+        throw err;
+    }
+}
+/**
+ * A worktree's tracked tree as its installs read it: git's tracked paths, their
+ * bytes from the working tree. Null when git cannot list the worktree.
+ */
+export function readWorktreeInstallTree(worktreePath, runGit = runGitSync) {
+    const listed = runGit(['ls-files', '-z'], worktreePath);
+    if (!listed.success)
+        return null;
+    return trackedInstallTree(listed.output.split('\0'), (path) => readWorkingFile(join(worktreePath, path)));
+}
+/** Every install root of the tree: the directories holding a tracked lockfile ('' = the repo root). Sorted. */
+export function listInstallRoots(tree) {
+    const roots = new Set();
+    for (const path of tree.filesUnder('')) {
+        if (INSTALL_LOCKFILES.includes(posix.basename(path))) {
+            const dir = posix.dirname(path);
+            roots.add(dir === '.' ? '' : dir);
+        }
+    }
+    return [...roots].sort();
+}
+function fail(walk, manifest, reason) {
+    walk.unresolvable.push({ manifest, reason });
+}
+const clip = (text) => (text.length > 120 ? `${text.slice(0, 117)}...` : text);
+function readText(walk, path) {
+    return walk.tree.read(path)?.toString('utf8') ?? null;
+}
+function consumeTree(walk, dir) {
+    for (const file of walk.tree.filesUnder(dir))
+        walk.consumed.add(file);
+}
+/** A JSON object from a tracked file: the object, null when absent, or 'invalid'. */
+function readJsonObject(walk, path) {
+    const text = readText(walk, path);
+    if (text === null)
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        return isPlainObject(parsed) ? parsed : 'invalid';
+    }
+    catch {
+        return 'invalid';
+    }
+}
+/**
+ * The packages an install at `root` touches (module doc) and the names it links
+ * to in-repo source, read from its lockfile. A lockfile the model cannot read is
+ * unresolvable, and the root alone is followed.
+ */
+function readTouchedPackages(walk, root) {
+    const dirs = [root];
+    const linkedNames = new Set();
+    const lockPath = INSTALL_LOCKFILES.map((name) => joinRel(root, name) ?? name).find((path) => walk.tree.has(path));
+    if (lockPath === undefined)
+        return { dirs, linkedNames };
+    const lock = readJsonObject(walk, lockPath);
+    if (lock === null)
+        return { dirs, linkedNames };
+    if (lock === 'invalid' || (!isPlainObject(lock.packages) && lock.dependencies !== undefined)) {
+        fail(walk, lockPath, `${lockPath} is not a lockfile whose in-repo packages the model can read`);
+        return { dirs, linkedNames };
+    }
+    for (const [key, entry] of Object.entries(isPlainObject(lock.packages) ? lock.packages : {})) {
+        if (key === '')
+            continue;
+        const segments = key.split('/');
+        if (segments.includes(DEPENDENCY_DIR)) {
+            if (isPlainObject(entry) && entry.link === true)
+                linkedNames.add(key.slice(key.lastIndexOf(`${DEPENDENCY_DIR}/`) + DEPENDENCY_DIR.length + 1));
+            continue;
+        }
+        const dir = joinRel(root, key);
+        if (dir === null)
+            fail(walk, lockPath, `${lockPath} links ${key}, outside the repo`);
+        else if (!dirs.includes(dir))
+            dirs.push(dir);
+    }
+    return { dirs, linkedNames };
+}
+/** Follow one touched package: its manifests, a native build, and its install lifecycle scripts. */
+function followPackage(walk, dir, linkedNames) {
+    const manifestPath = joinRel(dir, 'package.json') ?? 'package.json';
+    const gypPath = joinRel(dir, 'binding.gyp') ?? 'binding.gyp';
+    if (walk.tree.has(gypPath))
+        walk.manifests.add(gypPath);
+    if (!walk.tree.has(manifestPath)) {
+        if (walk.tree.has(gypPath))
+            consumeTree(walk, dir);
+        return;
+    }
+    walk.manifests.add(manifestPath);
+    const manifest = readJsonObject(walk, manifestPath);
+    if (manifest === null || manifest === 'invalid' || (manifest.scripts !== undefined && !isPlainObject(manifest.scripts))) {
+        fail(walk, manifestPath, `${manifestPath} is not a manifest whose install scripts the model can read`);
+        return;
+    }
+    if (walk.tree.has(gypPath) || manifest.gypfile === true)
+        consumeTree(walk, dir);
+    const scope = {
+        dir,
+        manifest: manifestPath,
+        scripts: isPlainObject(manifest.scripts) ? manifest.scripts : {},
+        ownName: typeof manifest.name === 'string' ? manifest.name : null,
+        linkedNames,
+        expanding: new Set(),
+    };
+    for (const script of INSTALL_LIFECYCLE_SCRIPTS) {
+        const body = scope.scripts[script];
+        if (body === undefined)
+            continue;
+        if (typeof body !== 'string')
+            fail(walk, manifestPath, `${manifestPath} scripts.${script} is not a command`);
+        else
+            resolveCommand(walk, scope, body, `scripts.${script}`);
+    }
+}
+/**
+ * What an install at `root` consumes (module doc). Throws when a tracked input
+ * cannot be read (the caller reports the tree unreadable).
+ */
+export function readInstallInputs(tree, root) {
+    const walk = { tree, manifests: new Set(), consumed: new Set(), scanned: new Set(), unresolvable: [] };
+    for (const name of [...INSTALL_LOCKFILES, '.npmrc']) {
+        const path = joinRel(root, name);
+        if (path !== null && tree.has(path))
+            walk.manifests.add(path);
+    }
+    const touched = readTouchedPackages(walk, root);
+    for (const dir of touched.dirs)
+        followPackage(walk, dir, touched.linkedNames);
+    // An input the model cannot follow can address any tracked path -- a nested
+    // install's `../../shared.json` included -- so the fallback is the whole repository.
+    if (walk.unresolvable.length > 0)
+        consumeTree(walk, '');
+    return { manifests: [...walk.manifests].sort(), consumed: [...walk.consumed].sort(), unresolvable: walk.unresolvable };
+}
+/**
+ * The provisioning fingerprint of an install at `root`: every manifest and
+ * consumed file, path and bytes, under {@link INSTALL_FINGERPRINT_FORMAT}. Equal
+ * fingerprints mean no input the install reads changed.
+ */
+export function installInputsFingerprint(tree, root) {
+    const inputs = readInstallInputs(tree, root);
+    const hash = createHash('sha256').update(INSTALL_FINGERPRINT_FORMAT);
+    for (const path of [...new Set([...inputs.manifests, ...inputs.consumed])].sort()) {
+        const bytes = tree.read(path);
+        hash.update('\0').update(path).update('\0').update(bytes === null ? 'absent' : `${bytes.length}:`);
+        if (bytes !== null)
+            hash.update(bytes);
+    }
+    return `${INSTALL_FINGERPRINT_FORMAT}:${hash.digest('hex')}`;
+}
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+/** Shell syntax the model does not follow: expansion, substitution, redirection, globbing, escapes, comments. */
+const UNFOLLOWED_SHELL = /[$`()<>*?[\]{}~\\!#]/;
+/**
+ * Commands that read no tracked file an install's effect depends on, each with why.
+ * A command here is admitted with any arguments.
+ */
+export const READS_NOTHING = new Map([
+    ['true', 'a shell no-op: the `|| true` that keeps an optional step from failing the install'],
+    ['false', 'a shell no-op'],
+    [':', 'a shell no-op'],
+    ['exit', 'ends the script'],
+    ['echo', 'prints its arguments; no expansion is admitted, so it reads nothing'],
+    ['set', 'sets shell options (`set -e`)'],
+    ['which', 'prints where a program name resolves on PATH; reads no file content'],
+    ['husky', 'installs git hooks (`husky`, `husky install`): sets core.hooksPath and writes hook shims under .husky, never reads source into node_modules'],
+]);
+/** Split a command into simple commands of words; null when it uses shell syntax the model does not follow. */
+export function splitShellCommands(command) {
+    if (UNFOLLOWED_SHELL.test(command))
+        return null;
+    const commands = [];
+    let words = [];
+    let word = '';
+    let quoted = false;
+    let quote = null;
+    const endWord = () => {
+        if (word.length > 0 || quoted)
+            words.push(word);
+        word = '';
+        quoted = false;
+    };
+    const endCommand = () => {
+        endWord();
+        if (words.length > 0)
+            commands.push(words);
+        words = [];
+    };
+    for (const char of command) {
+        if (quote !== null) {
+            if (char === quote)
+                quote = null;
+            else
+                word += char;
+        }
+        else if (char === '"' || char === "'") {
+            quote = char;
+            quoted = true;
+        }
+        else if (char === '&' || char === '|' || char === ';' || char === '\n') {
+            endCommand();
+        }
+        else if (/\s/.test(char)) {
+            endWord();
+        }
+        else {
+            word += char;
+        }
+    }
+    if (quote !== null)
+        return null;
+    endCommand();
+    return commands;
+}
+function resolveCommand(walk, scope, command, origin) {
+    const commands = splitShellCommands(command);
+    if (commands === null) {
+        fail(walk, scope.manifest, `${scope.manifest} ${origin}: \`${clip(command)}\` uses shell syntax the model does not follow`);
+        return;
+    }
+    for (const words of commands)
+        resolveSimpleCommand(walk, scope, words, origin);
+}
+function resolveSimpleCommand(walk, scope, words, origin) {
+    const [program = '', ...args] = words;
+    const unresolvable = (why) => fail(walk, scope.manifest, `${scope.manifest} ${origin}: \`${clip(words.join(' '))}\` ${why}`);
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(program))
+        return unresolvable('sets an environment variable the model does not follow');
+    if (READS_NOTHING.has(program))
+        return;
+    if (program === 'node')
+        return resolveNode(walk, scope, args, unresolvable);
+    if (program === 'sh' || program === 'bash')
+        return resolveShell(walk, scope, args, origin, unresolvable);
+    if (program === 'npm')
+        return resolveNpmRun(walk, scope, args, origin, unresolvable);
+    if (program === 'patch-package')
+        return resolvePatchPackage(walk, scope, args, unresolvable);
+    if (program === 'node-gyp')
+        return consumeTree(walk, scope.dir); // a native build reads the package's sources
+    if (program.includes('/'))
+        return resolveExecutable(walk, scope, program, args, origin, unresolvable);
+    unresolvable('runs a program the model does not follow (a bin can read any file)');
+}
+/** Resolve every argument token (or `--flag=value` value) that names a tracked file or directory. */
+function resolveArgumentTokens(walk, scope, args) {
+    for (const arg of args)
+        resolveLiteralToken(walk, scope, scope.dir, arg.includes('=') ? arg.slice(arg.indexOf('=') + 1) : arg);
+}
+function resolveNode(walk, scope, args, unresolvable) {
+    const [entry, ...rest] = args;
+    if (entry === undefined || entry.startsWith('-'))
+        return unresolvable('passes node a flag or an inline program');
+    const file = resolveModuleFile(walk.tree, scope.dir, entry);
+    if (file === null)
+        return unresolvable(`runs ${entry}, which is not a tracked file`);
+    scanScript(walk, scope, file);
+    resolveArgumentTokens(walk, scope, rest);
+}
+function resolveShell(walk, scope, args, origin, unresolvable) {
+    const [first, ...rest] = args;
+    if (first === '-c' && rest[0] !== undefined) {
+        resolveCommand(walk, scope, rest[0], origin);
+        return resolveArgumentTokens(walk, scope, rest.slice(1));
+    }
+    if (first === undefined || first.startsWith('-'))
+        return unresolvable('passes the shell a flag the model does not follow');
+    const file = joinRel(scope.dir, first);
+    if (file === null || !walk.tree.has(file))
+        return unresolvable(`runs ${first}, which is not a tracked file`);
+    scanShellScript(walk, scope, file, origin);
+    resolveArgumentTokens(walk, scope, rest);
+}
+function resolveExecutable(walk, scope, program, args, origin, unresolvable) {
+    const file = joinRel(scope.dir, program);
+    if (file === null || !walk.tree.has(file))
+        return unresolvable(`runs ${program}, which is not a tracked file`);
+    const shebang = (readText(walk, file) ?? '').split('\n', 1)[0];
+    if (/^#!.*\bnode\b/.test(shebang))
+        scanScript(walk, scope, file);
+    else if (!shebang.startsWith('#!') || /^#!.*\b(?:sh|bash)\b/.test(shebang))
+        scanShellScript(walk, scope, file, origin);
+    else
+        return unresolvable(`runs ${program} under an interpreter the model does not follow`);
+    resolveArgumentTokens(walk, scope, args);
+}
+/** `npm run <x> [-- args]`: pre<x>, <x> and post<x>, as npm runs them. */
+function resolveNpmRun(walk, scope, args, origin, unresolvable) {
+    const [sub, name, ...rest] = args;
+    if ((sub !== 'run' && sub !== 'run-script') || name === undefined || name.startsWith('-') || (rest.length > 0 && rest[0] !== '--')) {
+        return unresolvable('is an npm invocation the model does not follow (only `npm run <script> [-- args]`)');
+    }
+    for (const script of [`pre${name}`, name, `post${name}`]) {
+        const body = scope.scripts[script];
+        if (body === undefined && script !== name)
+            continue;
+        if (typeof body !== 'string')
+            return unresolvable(`runs scripts.${script}, which is not a command`);
+        if (scope.expanding.has(script) || scope.expanding.size >= MAX_SCRIPT_DEPTH)
+            return unresolvable('expands scripts recursively');
+        scope.expanding.add(script);
+        resolveCommand(walk, scope, body, `${origin} > scripts.${script}`);
+        scope.expanding.delete(script);
+    }
+    resolveArgumentTokens(walk, scope, rest.slice(1));
+}
+/** `patch-package` applies the patches in its patch directory (default `patches`) to node_modules. */
+function resolvePatchPackage(walk, scope, args, unresolvable) {
+    let patchDir = 'patches';
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (arg === '--patch-dir' && args[index + 1] !== undefined)
+            patchDir = args[++index];
+        else if (arg !== '--error-on-fail' && arg !== '--error-on-warn')
+            return unresolvable(`passes patch-package ${arg}, a flag the model does not follow`);
+    }
+    const dir = joinRel(scope.dir, patchDir);
+    if (dir === null)
+        return unresolvable(`reads patches from ${patchDir}, outside the repo`);
+    consumeTree(walk, dir);
+}
+// ---------------------------------------------------------------------------
+// Scripts
+// ---------------------------------------------------------------------------
+/** Code loading a static scan cannot follow. */
+const DYNAMIC_LOADING = /\brequire\s*\(\s*[^'"\s)]|\bimport\s*\(\s*[^'"\s)]|\beval\s*\(|\bnew\s+Function\b|\bcreateRequire\b|\bmodule\.require\b|\bprocess\.dlopen\b|\bprocess\.chdir\b/;
+/** Paths addressed relative to the script's location or the working directory: the whole package is in reach. */
+const LOCATION_ANCHORED = /\b__dirname\b|\b__filename\b|\bimport\.meta\b|\bprocess\.cwd\b/;
+const IMPORT_SPECIFIERS = [
+    /\brequire\s*\(\s*(['"])([^'"\n]+)\1\s*\)/g,
+    /\bimport\s*\(\s*(['"])([^'"\n]+)\1/g,
+    /\b(?:import|export)\s[^'"`;]*?\bfrom\s*(['"])([^'"\n]+)\1/g,
+    /\bimport\s*(['"])([^'"\n]+)\1/g,
+];
+const STRING_LITERALS = /'((?:[^'\\\n]|\\.)*)'|"((?:[^"\\\n]|\\.)*)"|`((?:[^`\\]|\\.)*)`/g;
+const MODULE_SUFFIXES = ['', '.js', '.cjs', '.mjs', '.json', '.ts', '.cts', '.mts', '/index.js', '/index.cjs', '/index.mjs', '/index.json'];
+const SCANNED_SOURCE = /\.(?:[cm]?js|[cm]?ts)$|^[^.]*$/;
+/** The tracked file `node` loads for `specifier` from `dir`, trying Node's extensions and index files. */
+function resolveModuleFile(tree, dir, specifier) {
+    for (const suffix of MODULE_SUFFIXES) {
+        const candidate = joinRel(dir, `${specifier}${suffix}`);
+        if (candidate !== null && candidate !== '' && tree.has(candidate))
+            return candidate;
+    }
+    return null;
+}
+function scanShellScript(walk, scope, file, origin) {
+    if (!enterScan(walk, scope, file))
+        return;
+    const text = readText(walk, file) ?? '';
+    const body = text.split('\n').filter((line) => !line.trimStart().startsWith('#')).join('\n');
+    resolveCommand(walk, scope, body, `${origin} > ${file}`);
+}
+/** Mark `file` consumed and scanned; false when it already was, or the scan bound is spent (unresolvable). */
+function enterScan(walk, scope, file) {
+    walk.consumed.add(file);
+    if (walk.scanned.has(file))
+        return false;
+    walk.scanned.add(file);
+    if (walk.scanned.size <= MAX_SCANNED_FILES)
+        return true;
+    fail(walk, scope.manifest, `${scope.manifest}: its install scripts load more than ${MAX_SCANNED_FILES} files`);
+    return false;
+}
+/** A JS entry: its content, its transitive relative imports, and every literal token naming a tracked path (module doc). */
+function scanScript(walk, scope, file) {
+    if (!enterScan(walk, scope, file) || !SCANNED_SOURCE.test(posix.basename(file)))
+        return;
+    const text = readText(walk, file) ?? '';
+    const dynamic = DYNAMIC_LOADING.exec(text);
+    if (dynamic) {
+        fail(walk, scope.manifest, `${file} loads code the static scan cannot follow (\`${clip(dynamic[0])}\`)`);
+        return;
+    }
+    const effects = readScriptEffects(text, posix.basename(file));
+    if ('unresolvable' in effects) {
+        fail(walk, scope.manifest, `${file} ${effects.unresolvable}`);
+        return;
+    }
+    if (LOCATION_ANCHORED.test(text))
+        consumeTree(walk, scope.dir);
+    const from = posix.dirname(file) === '.' ? '' : posix.dirname(file);
+    for (const pattern of IMPORT_SPECIFIERS) {
+        for (const match of text.matchAll(pattern))
+            resolveImport(walk, scope, file, from, match[2]);
+    }
+    for (const match of text.matchAll(STRING_LITERALS)) {
+        const literal = (match[1] ?? match[2] ?? match[3] ?? '').replace(/\$\{[^}]*\}/g, ' ');
+        for (const token of literal.split(/\s+/))
+            resolveLiteralToken(walk, scope, from, token);
+    }
+    followScriptEffects(walk, scope, file, from, effects);
+}
+/** What a script's code reads, spawns and takes from the environment (worktree/install-script-effects.ts). */
+function followScriptEffects(walk, scope, file, from, effects) {
+    if (effects.readsManifest)
+        walk.consumed.add(scope.manifest);
+    for (const read of effects.reads) {
+        const path = joinRel(read.anchor === 'cwd' ? scope.dir : from, read.path);
+        if (path === null)
+            fail(walk, scope.manifest, `${file} reads ${read.path}, outside the repo`);
+        else
+            consumePath(walk, scope, path);
+    }
+    for (const command of effects.commands)
+        resolveCommand(walk, scope, command, `${file} spawns`);
+}
+function resolveImport(walk, scope, file, from, specifier) {
+    if (specifier.startsWith('.')) {
+        const target = resolveModuleFile(walk.tree, from, specifier);
+        if (target === null)
+            fail(walk, scope.manifest, `${file} imports ${specifier}, which is not a tracked file`);
+        else
+            scanScript(walk, scope, target);
+        return;
+    }
+    if (specifier.startsWith('node:') || builtinModules.includes(specifier)) {
+        if (!FOLLOWED_BUILTIN_MODULES.has(specifier.replace(/^node:/, ''))) {
+            fail(walk, scope.manifest, `${file} imports ${specifier}, a builtin whose file access the scan does not follow`);
+        }
+        return;
+    }
+    const name = specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
+    const inRepo = /^[a-z][a-z0-9+.-]*:/i.test(specifier) || specifier.startsWith('/') || specifier.startsWith('#')
+        || name === scope.ownName || scope.linkedNames.has(name);
+    // The lockfile pins a registry package's code, not the paths its functions read -- the same reason an unknown bin is unresolvable.
+    fail(walk, scope.manifest, inRepo
+        ? `${file} imports ${specifier}, which the lockfile does not pin (in-repo or addressed source)`
+        : `${file} imports ${specifier}, a registry package whose file reads the scan does not follow`);
+}
+/** A token naming a tracked file or directory relative to the package or `from` (see {@link consumePath}). */
+function resolveLiteralToken(walk, scope, from, token) {
+    if (token.length === 0 || token.startsWith('/') || token.includes('://'))
+        return;
+    for (const base of new Set([scope.dir, from])) {
+        const path = joinRel(base, token);
+        if (path !== null)
+            consumePath(walk, scope, path);
+    }
+}
+/** A tracked file (a JS source is scanned), or every tracked file under a directory (none for an untracked path). */
+function consumePath(walk, scope, path) {
+    if (!walk.tree.has(path))
+        consumeTree(walk, path);
+    else if (/\.(?:[cm]?js|[cm]?ts)$/.test(path))
+        scanScript(walk, scope, path);
+    else
+        walk.consumed.add(path);
+}
+//# sourceMappingURL=install-inputs.js.map