@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/utils/incomplete-install-error.js

@@ -7,7 +7,7 @@
 // failure inside THIS process rather than a qmd child's captured stderr, which
 // is the gap HQ-CLI-Y's classifier cannot cover.
 //
-// Three shapes, one cause — a partial/interrupted global install left a file
+// Four shapes, one cause — a partial/interrupted global install left a file
 // unwritten, or a concurrent global install rewrote the running tree
 // underneath a command:
 //
@@ -36,6 +36,14 @@
 //   ERR_MODULE_NOT_FOUND at resolve, never ENOENT at load; an ENOENT at load
 //   proves the file vanished between resolve and read.
 //
+//   HQ-CLI-20 (Sentry 7724280783) — CJS load, in-process. The CJS twin of
+//   HQ-CLI-1M: `hq core timeout-guard` registers the full command graph, which
+//   reaches a bundled CommonJS dependency (ajv) whose internal require() resolved
+//   a sibling from Module._pathCache and then read its source after a concurrent
+//   reinstall had vanished it. Node raised `ENOENT` with syscall 'open' from the
+//   CJS loader's source read (defaultLoadImpl/loadSource) — a cjs/loader frame but
+//   NO esm/load frame, so the esm-loader gate missed it and it filed a bare crash.
+//
 // All shapes carry no hq-cli frames, reach the boundary's final `else`, and —
 // before this classifier — filed a bare captureException plus an unactionable
 // `hq: <fallback>` line. The disposition is the one HQ-CLI-Y already
@@ -59,12 +67,15 @@
 //      optional-dependency miss (not guaranteed installed), and an undeclared or
 //      peer-only miss (`Cannot find module 'mqtt'` from a requirer that does not
 //      declare it) all stay loud — the last two enriched with both package names.
-//   3. The ESM shape additionally requires an esm-loader frame — an ordinary
-//      `fs.readFileSync` ENOENT written by hq's own code stays captured.
+//   3. The loader shapes additionally require a loader SOURCE-READ frame — the ESM
+//      shape an `esm/load` frame, the CJS shape (HQ-CLI-20) a cjs/loader frame
+//      immediately beneath the node:fs read. An ordinary `fs.readFileSync` ENOENT
+//      written by hq's own code, or one escaping a third-party module's own
+//      EVALUATION, carries no such frame and stays captured.
 import * as fs from "fs";
 import * as path from "path";
-import { packageRoot } from "./hq-roots.js";
-import { packageNameOf } from "./install-tree-torn.js";
+import { packageRoot, stringDerivedPackageRoot } from "./hq-roots.js";
+import { evalThrowShape, hasCjsLoaderSourceReadFrame, packageNameOf } from "./install-tree-torn.js";
 import { boundedDiagnosticValue } from "./package-root-diagnostics.js";
 /**
  * The actionable remedy shown to the operator. Input-free — nothing from the
@@ -85,8 +96,26 @@ export const INCOMPLETE_INSTALL_REMEDY = "hq couldn't load part of its own insta
     "`pnpm add -g @indigoai-us/hq-cli`).";
 /** A relative module specifier — `./x`, `../x`, `.\x`, `..\x`. */
 const RELATIVE_SPECIFIER = /^\.\.?[\\/]/;
-/** A Node ESM loader frame — proves the ENOENT came from the module loader, not hq's own fs call. */
-const ESM_LOADER_FRAME = /node:internal[\\/]modules[\\/]esm[\\/]/;
+/**
+ * The Node ESM loader's SOURCE-READ frame — `getSourceSync`/`defaultLoad` in
+ * `node:internal/modules/esm/load`. Requiring the `esm/load` module frame (not
+ * merely any frame under `modules/esm/`) proves the loader was READING the
+ * module's source. An ordinary `fs.openSync`/`readFileSync` ENOENT that merely
+ * ESCAPES a module's EVALUATION runs under `esm/module_job`, never `esm/load`,
+ * so it stays captured rather than suppressed. `load\b` excludes the sibling
+ * `esm/loader` module.
+ */
+const ESM_LOADER_FRAME = /node:internal[\\/]modules[\\/]esm[\\/]load\b/;
+/**
+ * The Node module RESOLVER frame — `finalizeResolution` in
+ * `node:internal/modules/esm/resolve`, or the CJS `Module._findPath → toRealPath`
+ * route in `node:internal/modules/cjs/loader`. Alongside `syscall === 'lstat'`
+ * this proves a resolve-time ENOENT (HQ-CLI-1S) — a path component that vanished
+ * between the resolver's stat and its realpathSync lstat — so an ordinary
+ * `fs.lstatSync` ENOENT from hq's own code stays captured. Mirrors the frame
+ * matcher in install-tree-torn.ts (duplicated exactly as ESM_LOADER_FRAME is).
+ */
+const RESOLVER_FRAME = /node:internal[\\/]modules[\\/](?:esm[\\/]resolve|cjs[\\/]loader)\b/;
 const ROOT_DIAGNOSTIC_BYTES = 256;
 const CODE_DIAGNOSTIC_BYTES = 32;
 // Package names live inside hq-cli's own dependency graph, so their universe is
@@ -95,19 +124,42 @@ const PACKAGE_NAME_DIAGNOSTIC_BYTES = 128;
 /** The `<something>/node_modules/<something>` directory-boundary marker. */
 const NODE_MODULES_SEGMENT = "/node_modules/";
 /**
- * packageRoot() walks up from the compiled module and THROWS
- * PackageRootResolutionError when it cannot resolve. This classifier runs inside
- * beforeSend on EVERY event, so it must never throw — a resolution failure
- * returns null and the error stays captured.
+ * Resolve the running install's root, trying the authoritative on-disk manifest
+ * walk first and falling back to the filesystem-free string derivation ONLY when
+ * it throws — the torn-tree case, where a concurrent global install has renamed
+ * the package directory aside so packageRoot() cannot read a manifest. Never
+ * throws; reports which strategy answered so a captured event is attributable.
+ *
+ * packageRoot() itself is deliberately NOT widened: resolveBundledAsset() and
+ * isWithinPackage() require a root that exists on disk, and handing them a
+ * string-derived phantom directory would break them. The fallback lives here,
+ * where the only consumer is classification (a lexical prefix test) that needs
+ * no live filesystem.
  */
-function safePackageRoot() {
+function resolvePackageRootWithSource() {
     try {
-        return packageRoot();
+        return { root: packageRoot(), source: "manifest-walk" };
     }
     catch {
-        return null;
+        const derived = stringDerivedPackageRoot();
+        return derived
+            ? { root: derived, source: "string-derivation" }
+            : { root: null, source: "unresolved" };
     }
 }
+/**
+ * packageRoot() walks up from the compiled module and THROWS
+ * PackageRootResolutionError when it cannot resolve. This classifier runs inside
+ * beforeSend on EVERY event, so it must never throw — a resolution failure
+ * returns null and the error stays captured. When the on-disk walk fails because
+ * a concurrent install renamed the package directory aside, the filesystem-free
+ * string derivation still supplies the root: that is the HQ-CLI-1M repair —
+ * the running install's root must be known even while its directory is
+ * momentarily gone.
+ */
+function safePackageRoot() {
+    return resolvePackageRootWithSource().root;
+}
 /** Call a (possibly injected) resolver without letting it throw. */
 function resolveRootSafely(resolve) {
     try {
@@ -137,16 +189,25 @@ function normalizeForCompare(p) {
     return looksWin32(p) ? folded.toLowerCase() : folded;
 }
 /**
- * True when `candidate` lives under `<root>/node_modules/`. Anchored at a true
- * directory boundary (`<root>` + sep + `node_modules` + sep) so a sibling such
- * as `<root>-old/node_modules/...` can never match.
+ * True when `candidate` lives directly under `<root>/<subdir>/`. Anchored at a
+ * true directory boundary (`<root>` + sep + `<subdir>` + sep) so a sibling such
+ * as `<root>-old/<subdir>/...` can never match. `<subdir>` carries no separator,
+ * so this stays a single lexical prefix test that needs no live filesystem.
  */
-function isUnderNodeModules(candidate, root) {
+function isUnderSubdir(candidate, root, subdir) {
     if (!candidate || !root)
         return false;
-    const prefix = `${normalizeForCompare(root)}/node_modules/`;
+    const prefix = `${normalizeForCompare(root)}/${subdir}/`;
     return normalizeForCompare(candidate).startsWith(prefix);
 }
+/**
+ * True when `candidate` lives under `<root>/node_modules/`. Anchored at a true
+ * directory boundary so a sibling such as `<root>-old/node_modules/...` can
+ * never match.
+ */
+function isUnderNodeModules(candidate, root) {
+    return isUnderSubdir(candidate, root, "node_modules");
+}
 /** The failing specifier from a `Cannot find module '<spec>'` message, or null. */
 function parseMissingSpecifier(message) {
     if (typeof message !== "string")
@@ -266,6 +327,10 @@ function requirerDeclaresDependency(requiringFile, packageName, fileSystem) {
 function hasEsmLoaderFrame(stack) {
     return typeof stack === "string" && ESM_LOADER_FRAME.test(stack);
 }
+/** True when `stack` carries a Node module RESOLVER frame. */
+function hasResolverFrame(stack) {
+    return typeof stack === "string" && RESOLVER_FRAME.test(stack);
+}
 /**
  * The ESM-loader ENOENT SIGNATURE, independent of whether a usable `path`
  * survived: `code === 'ENOENT'`, `syscall === 'open'`, and an esm-loader frame
@@ -281,10 +346,44 @@ function isEsmLoaderEnoent(err) {
         hasEsmLoaderFrame(record.stack));
 }
 /**
- * If `err` is an in-process incomplete-install module-load failure — either the
- * CJS relative-sibling shape (HQ-CLI-1N) or the ESM vanished-file shape
- * (HQ-CLI-1M), with the failing file confirmed under `<packageRoot>/node_modules/`
- * — return the actionable, input-free reinstall remedy; otherwise return null.
+ * The resolve-time ENOENT SIGNATURE (HQ-CLI-1S): `code === 'ENOENT'`,
+ * `syscall === 'lstat'`, and a resolver frame — independent of whether a usable
+ * `path` survived delivery. Sibling of {@link isEsmLoaderEnoent}; the message
+ * classifier additionally requires a `path` under node_modules.
+ */
+function isResolveEnoent(err) {
+    if (err === null || typeof err !== "object")
+        return false;
+    const record = err;
+    return (record.code === "ENOENT" &&
+        record.syscall === "lstat" &&
+        hasResolverFrame(record.stack));
+}
+/** True when `stack` is a CJS loader SOURCE-READ stack (HQ-CLI-20). */
+function hasCjsLoaderFrame(stack) {
+    return typeof stack === "string" && hasCjsLoaderSourceReadFrame(stack);
+}
+/**
+ * The CJS loader-read ENOENT SIGNATURE (HQ-CLI-20): `code === 'ENOENT'`,
+ * `syscall === 'open'`, and a CJS loader SOURCE-READ stack (the positional gate
+ * shared from install-tree-torn.ts) — the CJS twin of {@link isEsmLoaderEnoent},
+ * independent of whether a usable `path` survived. The message classifier
+ * additionally requires a `path` under node_modules.
+ */
+function isCjsLoaderEnoent(err) {
+    if (err === null || typeof err !== "object")
+        return false;
+    const record = err;
+    return (record.code === "ENOENT" &&
+        record.syscall === "open" &&
+        hasCjsLoaderFrame(record.stack));
+}
+/**
+ * If `err` is an in-process incomplete-install module-load failure — the CJS
+ * relative-sibling shape (HQ-CLI-1N), the ESM vanished-at-read shape (HQ-CLI-1M),
+ * or the resolve-time lstat shape (HQ-CLI-1S), with the failing file confirmed
+ * under `<packageRoot>/node_modules/` — return the actionable, input-free reinstall
+ * remedy; otherwise return null.
  *
  * Mirrors qmdModuleMissingMessage so the top-level handler and beforeSend branch
  * the same way: a non-null result means print-the-remedy-and-skip-Sentry, null
@@ -335,17 +434,35 @@ export function incompleteInstallMessage(err, resolvePackageRoot = safePackageRo
             ? INCOMPLETE_INSTALL_REMEDY
             : null;
     }
-    // Shape B (ESM load, HQ-CLI-1M): an ENOENT from the module loader for a file
-    // that was present at resolve and gone at read.
-    if (record.syscall !== "open")
-        return null;
-    if (typeof record.path !== "string")
-        return null;
-    if (!hasEsmLoaderFrame(record.stack))
-        return null;
-    return isUnderNodeModules(record.path, root)
-        ? INCOMPLETE_INSTALL_REMEDY
-        : null;
+    // Shape B (ESM load, HQ-CLI-1M): an ENOENT from the module LOADER for a file
+    // present at resolve and gone at read (syscall 'open' + an esm-loader frame).
+    if (record.syscall === "open" &&
+        typeof record.path === "string" &&
+        hasEsmLoaderFrame(record.stack)) {
+        return isUnderNodeModules(record.path, root) ? INCOMPLETE_INSTALL_REMEDY : null;
+    }
+    // Shape B' (RESOLVE time, HQ-CLI-1S): an ENOENT from the resolver's realpath
+    // step (syscall 'lstat' + a resolver frame) — a path component that a concurrent
+    // reinstall renamed away between the resolver's stat and its lstat. Same
+    // disposition as B: a vanished component under the running install's
+    // node_modules is a torn install, so print the remedy and skip capture.
+    if (record.syscall === "lstat" &&
+        typeof record.path === "string" &&
+        hasResolverFrame(record.stack)) {
+        return isUnderNodeModules(record.path, root) ? INCOMPLETE_INSTALL_REMEDY : null;
+    }
+    // Shape B'' (CJS load-time, HQ-CLI-20): the CJS twin of Shape B — an ENOENT from
+    // the CJS loader's source read (syscall 'open' + a CJS loader SOURCE-READ stack,
+    // NO esm/load frame) for a bundled dependency file present at resolve and gone at
+    // read. Same disposition as B: a vanished file under the running install's
+    // node_modules is a torn install, so print the remedy and skip capture; a miss
+    // under the install's own dist/ or assets/ stays captured.
+    if (record.syscall === "open" &&
+        typeof record.path === "string" &&
+        hasCjsLoaderFrame(record.stack)) {
+        return isUnderNodeModules(record.path, root) ? INCOMPLETE_INSTALL_REMEDY : null;
+    }
+    return null;
 }
 /** A readFileSync surface, defaulting to the real fs when the caller injects none. */
 function readFileFrom(fileSystem) {
@@ -392,17 +509,95 @@ function bareSpecifierCaptureContext(err, resolvePackageRoot, fileSystem) {
         },
     };
 }
+/**
+ * Classify a NOT-suppressed CJS relative requirer LEXICALLY against the resolved
+ * root — never emitting the path itself, only one of four fixed values. A
+ * requirer under `<root>/node_modules/` with a resolved root is ALWAYS suppressed
+ * upstream, so that scope is unreachable here and deliberately absent from the
+ * enum.
+ *   - root null (both resolvers failed)  → 'unresolved-root'
+ *   - under `<root>/dist/`               → 'dist'   (hq-cli's own shipped output)
+ *   - under `<root>/assets/`             → 'assets' (hq-cli's own bundled assets)
+ *   - anything else (a user project, a `<root>-old` sibling, …) → 'outside-root'
+ */
+function classifyRelativeRequirerScope(requiringFile, root) {
+    if (!root)
+        return "unresolved-root";
+    if (isUnderSubdir(requiringFile, root, "dist"))
+        return "dist";
+    if (isUnderSubdir(requiringFile, root, "assets"))
+        return "assets";
+    return "outside-root";
+}
+/**
+ * When a CJS RELATIVE-specifier miss (HQ-CLI-1N's shape) reached the capture path
+ * WITHOUT being suppressed — its requirer sits under the install's own `dist/` or
+ * `assets/`, outside the running install entirely, or the install root could not
+ * be resolved — return a bounded `incomplete_install` block recording a
+ * four-value lexical scope so the next occurrence is attributable instead of
+ * bare; otherwise undefined. The suppression decision is delegated to
+ * incompleteInstallMessage against the SAME injected resolver, so a suppressed
+ * relative miss (requirer under `<root>/node_modules/` with a resolved root) is
+ * never double-attributed here. Never throws; never emits a path or the specifier.
+ */
+function relativeSpecifierCaptureContext(err, resolvePackageRoot, fileSystem) {
+    if (err === null || typeof err !== "object")
+        return undefined;
+    const record = err;
+    if (record.code !== "MODULE_NOT_FOUND")
+        return undefined;
+    const requireStack = record.requireStack;
+    if (!Array.isArray(requireStack) || typeof requireStack[0] !== "string")
+        return undefined;
+    const requiringFile = requireStack[0];
+    const specifier = parseMissingSpecifier(record.message);
+    if (specifier === null || !RELATIVE_SPECIFIER.test(specifier))
+        return undefined;
+    // Suppressed (requirer under <root>/node_modules with a resolved root) →
+    // printed-and-skipped, never captured. Delegated to the classifier against the
+    // SAME resolver so the two decisions can never diverge and nothing that would
+    // be suppressed is ever double-attributed.
+    if (incompleteInstallMessage(err, resolvePackageRoot, readFileFrom(fileSystem)) !== null) {
+        return undefined;
+    }
+    // Not suppressed: record which resolver answered and the lexical requirer scope.
+    const resolution = resolvePackageRoot === safePackageRoot
+        ? resolvePackageRootWithSource()
+        : {
+            root: resolveRootSafely(resolvePackageRoot),
+            source: "injected",
+        };
+    const root = resolution.root;
+    return {
+        incomplete_install: {
+            code: "MODULE_NOT_FOUND",
+            relativeSpecifier: true,
+            packageRoot: boundedDiagnosticValue(root ?? "<unresolved>", ROOT_DIAGNOSTIC_BYTES),
+            packageRootResolved: root !== null,
+            resolver: resolution.source,
+            requirerScope: classifyRelativeRequirerScope(requiringFile, root),
+        },
+    };
+}
 /**
  * When an incomplete-install failure reaches the capture path WITHOUT being
  * suppressed, return a bounded `contexts.incomplete_install` block so the next
  * occurrence carries the evidence this one lacked; otherwise return undefined
- * (bare capture). Two enriched shapes:
+ * (bare capture). Three enriched shapes:
  *   - a third-party BARE-specifier miss the requirer did not declare (HQ-CLI-1Q)
  *     → { missingPackage, requiringPackage, requirerDeclaresMissing:false };
- *   - an esm-loader ENOENT whose path did not survive delivery (HQ-CLI-1M) — the
- *     shape the delivered payload arrived in, where neither the exception value
- *     nor node_system_error carried a `path` → { packageRoot, packageJsonExists,
- *     nodeModulesExists, esmLoaderFrame, code }.
+ *   - a CJS RELATIVE-specifier miss whose requirer sits under the install's own
+ *     dist/ or assets/, outside the install, or under an unresolved root
+ *     (HQ-CLI-1N) → { code, relativeSpecifier:true, packageRoot,
+ *     packageRootResolved, resolver, requirerScope };
+ *   - a loader/resolver ENOENT whose path did not survive delivery (HQ-CLI-1M
+ *     esm-load open, HQ-CLI-1S resolve-time lstat, HQ-CLI-20 CJS load-time open) —
+ *     where neither the exception value nor node_system_error carried a `path` →
+ *     { packageRoot, packageJsonExists, nodeModulesExists, esmLoaderFrame,
+ *     resolverFrame, cjsLoaderFrame, code };
+ *   - a module-EVALUATION throw that reached the boundary raw (HQ-CLI-1T) →
+ *     { evalThrow, errorName, throwSitePackage, packageRoot, packageRootResolved,
+ *     resolver }.
  * Built with the byte-capped, scrubber-safe discipline of
  * package-root-diagnostics.ts — never a caller argv, query, or user-minted
  * value. Never throws. main.ts attaches this on the generic capture path
@@ -413,41 +608,97 @@ export function incompleteInstallCaptureContext(err, resolvePackageRoot = safePa
     const bare = bareSpecifierCaptureContext(err, resolvePackageRoot, fileSystem);
     if (bare)
         return bare;
-    // (B) HQ-CLI-1M — the path-less esm-loader ENOENT, unchanged.
-    if (!isEsmLoaderEnoent(err))
-        return undefined;
-    // Only instrument what we did NOT already confidently suppress: a path under
-    // node_modules is classified and printed above, never captured.
-    if (incompleteInstallMessage(err, resolvePackageRoot, readFileFrom(fileSystem)) !== null) {
-        return undefined;
-    }
-    const record = err;
-    const root = resolveRootSafely(resolvePackageRoot);
-    const code = typeof record.code === "string" ? record.code : "";
-    let packageJsonExists = false;
-    let nodeModulesExists = false;
-    if (root) {
-        try {
-            packageJsonExists = fileSystem.existsSync(path.join(root, "package.json"));
-        }
-        catch {
-            packageJsonExists = false;
-        }
-        try {
-            nodeModulesExists = fileSystem.existsSync(path.join(root, "node_modules"));
-        }
-        catch {
-            nodeModulesExists = false;
+    // (B) HQ-CLI-1N — the not-suppressed CJS relative-sibling miss, made attributable.
+    const relative = relativeSpecifierCaptureContext(err, resolvePackageRoot, fileSystem);
+    if (relative)
+        return relative;
+    // (C) HQ-CLI-1M / HQ-CLI-1S / HQ-CLI-20 — the path-less loader/resolver ENOENT
+    // (esm-load open, resolve-time lstat, or CJS load-time open), made attributable.
+    // An ENOENT whose `path` survived and sits under node_modules is classified and
+    // printed above, never captured; only the unattributable shape (no usable path,
+    // or a path outside node_modules) reaches here.
+    if (isEsmLoaderEnoent(err) || isResolveEnoent(err) || isCjsLoaderEnoent(err)) {
+        if (incompleteInstallMessage(err, resolvePackageRoot, readFileFrom(fileSystem)) === null) {
+            const record = err;
+            const code = typeof record.code === "string" ? record.code : "";
+            // The default resolver knows which strategy answered (manifest walk vs the
+            // string derivation that survives a torn tree); an injected resolver is
+            // opaque, so it is recorded as "injected" and its return used as the root.
+            const resolution = resolvePackageRoot === safePackageRoot
+                ? resolvePackageRootWithSource()
+                : {
+                    root: resolveRootSafely(resolvePackageRoot),
+                    source: "injected",
+                };
+            const root = resolution.root;
+            const diagnostics = {
+                packageRoot: boundedDiagnosticValue(root ?? "<unresolved>", ROOT_DIAGNOSTIC_BYTES),
+                packageRootResolved: root !== null,
+                resolver: resolution.source,
+                // Which route raised it — the esm-loader (source-read) frame for 1M, the
+                // resolver frame for 1S, the CJS loader source-read frame for HQ-CLI-20;
+                // any are recorded from the stack.
+                esmLoaderFrame: hasEsmLoaderFrame(record.stack),
+                resolverFrame: hasResolverFrame(record.stack),
+                cjsLoaderFrame: hasCjsLoaderFrame(record.stack),
+                code: boundedDiagnosticValue(code, CODE_DIAGNOSTIC_BYTES),
+            };
+            // Report the existence booleans ONLY when a root was resolved. Reported for
+            // an unresolved root they were uninitialised `false`s indistinguishable from
+            // "resolved but missing" — the instrumentation defect the prior fix shipped.
+            if (root !== null) {
+                diagnostics.packageJsonExists = safeExistsSync(fileSystem, path.join(root, "package.json"));
+                diagnostics.nodeModulesExists = safeExistsSync(fileSystem, path.join(root, "node_modules"));
+            }
+            return { incomplete_install: diagnostics };
         }
     }
+    // (D) HQ-CLI-1T — a module-EVALUATION throw that reached the boundary raw (the
+    // writer-signal gate found no reinstall in progress), made attributable.
+    return evalThrowCaptureContext(err, resolvePackageRoot);
+}
+/**
+ * When a module-EVALUATION throw (HQ-CLI-1T) reached the capture path raw — a
+ * code-less TypeError/ReferenceError/SyntaxError whose top-level code ran while a
+ * half-written dependency file returned an empty module — return a bounded
+ * `incomplete_install` block naming the offending third-party package so the next
+ * occurrence is attributable instead of bare; otherwise undefined. When the root
+ * resolves, the throw site MUST sit under its node_modules (an hq-cli `dist/` or
+ * `assets/` eval throw is hq's OWN defect and stays a bare capture); when the root
+ * is unresolved the block is still attached with `packageRootResolved:false`.
+ * Never throws; never emits the message, argv, or a full path.
+ */
+function evalThrowCaptureContext(err, resolvePackageRoot) {
+    const shape = evalThrowShape(err);
+    if (!shape)
+        return undefined;
+    const resolution = resolvePackageRoot === safePackageRoot
+        ? resolvePackageRootWithSource()
+        : {
+            root: resolveRootSafely(resolvePackageRoot),
+            source: "injected",
+        };
+    const root = resolution.root;
+    if (root !== null && !isUnderNodeModules(shape.throwSite, root))
+        return undefined;
     return {
         incomplete_install: {
+            evalThrow: true,
+            errorName: boundedDiagnosticValue(shape.errorName, CODE_DIAGNOSTIC_BYTES),
+            throwSitePackage: boundedDiagnosticValue(requiringPackage(shape.throwSite)?.name ?? "<unresolved>", PACKAGE_NAME_DIAGNOSTIC_BYTES),
             packageRoot: boundedDiagnosticValue(root ?? "<unresolved>", ROOT_DIAGNOSTIC_BYTES),
-            packageJsonExists,
-            nodeModulesExists,
-            esmLoaderFrame: true,
-            code: boundedDiagnosticValue(code, CODE_DIAGNOSTIC_BYTES),
+            packageRootResolved: root !== null,
+            resolver: resolution.source,
         },
     };
 }
+/** existsSync that never throws — any filesystem error reads as "absent". */
+function safeExistsSync(fileSystem, target) {
+    try {
+        return fileSystem.existsSync(target);
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=incomplete-install-error.js.map