@indigoai-us/hq-cli 5.313.0 → 5.314.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.
 //
-// Four shapes, one cause — a partial/interrupted global install left a file
+// Three 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,14 +36,6 @@
 //   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
@@ -67,15 +59,12 @@
 //      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 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.
+//   3. The ESM shape additionally requires an esm-loader frame — an ordinary
+//      `fs.readFileSync` ENOENT written by hq's own code stays captured.
 import * as fs from "fs";
 import * as path from "path";
-import { packageRoot, stringDerivedPackageRoot } from "./hq-roots.js";
-import { evalThrowShape, hasCjsLoaderSourceReadFrame, packageNameOf } from "./install-tree-torn.js";
+import { packageRoot } from "./hq-roots.js";
+import { 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
@@ -96,26 +85,8 @@ 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 = /^\.\.?[\\/]/;
-/**
- * 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/;
+/** 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[\\/]/;
 const ROOT_DIAGNOSTIC_BYTES = 256;
 const CODE_DIAGNOSTIC_BYTES = 32;
 // Package names live inside hq-cli's own dependency graph, so their universe is
@@ -123,42 +94,19 @@ const CODE_DIAGNOSTIC_BYTES = 32;
 const PACKAGE_NAME_DIAGNOSTIC_BYTES = 128;
 /** The `<something>/node_modules/<something>` directory-boundary marker. */
 const NODE_MODULES_SEGMENT = "/node_modules/";
-/**
- * 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 resolvePackageRootWithSource() {
-    try {
-        return { root: packageRoot(), source: "manifest-walk" };
-    }
-    catch {
-        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.
+ * returns null and the error stays captured.
  */
 function safePackageRoot() {
-    return resolvePackageRootWithSource().root;
+    try {
+        return packageRoot();
+    }
+    catch {
+        return null;
+    }
 }
 /** Call a (possibly injected) resolver without letting it throw. */
 function resolveRootSafely(resolve) {
@@ -189,25 +137,16 @@ function normalizeForCompare(p) {
     return looksWin32(p) ? folded.toLowerCase() : folded;
 }
 /**
- * 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.
+ * 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.
  */
-function isUnderSubdir(candidate, root, subdir) {
+function isUnderNodeModules(candidate, root) {
     if (!candidate || !root)
         return false;
-    const prefix = `${normalizeForCompare(root)}/${subdir}/`;
+    const prefix = `${normalizeForCompare(root)}/node_modules/`;
     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")
@@ -327,10 +266,6 @@ 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
@@ -346,44 +281,10 @@ function isEsmLoaderEnoent(err) {
         hasEsmLoaderFrame(record.stack));
 }
 /**
- * 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.
+ * 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.
  *
  * 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
@@ -434,35 +335,17 @@ 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
-    // 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;
+    // 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;
 }
 /** A readFileSync surface, defaulting to the real fs when the caller injects none. */
 function readFileFrom(fileSystem) {
@@ -509,95 +392,17 @@ 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). Three enriched shapes:
+ * (bare capture). Two enriched shapes:
  *   - a third-party BARE-specifier miss the requirer did not declare (HQ-CLI-1Q)
  *     → { missingPackage, requiringPackage, requirerDeclaresMissing:false };
- *   - 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 }.
+ *   - 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 }.
  * 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
@@ -608,97 +413,41 @@ export function incompleteInstallCaptureContext(err, resolvePackageRoot = safePa
     const bare = bareSpecifierCaptureContext(err, resolvePackageRoot, fileSystem);
     if (bare)
         return bare;
-    // (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)
+    // (B) HQ-CLI-1M — the path-less esm-loader ENOENT, unchanged.
+    if (!isEsmLoaderEnoent(err))
         return undefined;
-    const resolution = resolvePackageRoot === safePackageRoot
-        ? resolvePackageRootWithSource()
-        : {
-            root: resolveRootSafely(resolvePackageRoot),
-            source: "injected",
-        };
-    const root = resolution.root;
-    if (root !== null && !isUnderNodeModules(shape.throwSite, root))
+    // 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;
+        }
+    }
     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),
-            packageRootResolved: root !== null,
-            resolver: resolution.source,
+            packageJsonExists,
+            nodeModulesExists,
+            esmLoaderFrame: true,
+            code: boundedDiagnosticValue(code, CODE_DIAGNOSTIC_BYTES),
         },
     };
 }
-/** 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