cgraphx 2.0.2 → 2.0.3

package/dist/core/code/scripts/resolve-analyze-cmd.cjs

@@ -0,0 +1,346 @@
+/**
+ * Single source of truth for how CLI warnings and docs invoke gitnexus.
+ *
+ * Automatically selects a working invocation path:
+ * 1. Global `gitnexus` on PATH (best — no install step)
+ * 2. npm 11+ with pnpm on PATH → `pnpm --allow-build=… dlx` (avoids the npx
+ *    arborist crash *and* pnpm 10+ ignored-build-script failures, #1939)
+ * 3. npm 11+ without pnpm but with bunx → `bunx` (dodges the same crash)
+ * 4. npm < 11 with npm on PATH → `npx` (works; simpler than pnpm dlx)
+ * 5. pnpm-only → `pnpm --allow-build=… dlx`
+ * 6. bun-only → `bunx`
+ * 7. Last resort → `npx` (warned on npm 11+ from analyze.ts)
+ *
+ * The bun branches exist because a Node toolchain is no longer implied: on a
+ * bun-only machine npm, npx and pnpm are all absent, so every rung above
+ * resolved to `npx` and the emitted command could not run at all. `bunx` is
+ * bun's install-free one-shot runner and needs no allow-build equivalent — bun
+ * skips lifecycle scripts unconditionally for a `bunx` fetch, which the native
+ * loader recovers from directly (see core/lbug/native-check.ts). Both bun rungs
+ * gate on `bunx` actually running, not merely existing on PATH — see `hasBun`.
+ *
+ * The `--allow-build` flags MUST precede the `dlx` token. pnpm < 10.14 keeps
+ * `dlx` in its argv escape list, so flags placed *after* `dlx` are parsed as
+ * package specs (ERR_PNPM_SPEC_NOT_SUPPORTED). The pre-`dlx` position parses
+ * into dlx's allow-build option and has been honored since pnpm 10.2.0 (#1939).
+ *
+ * This stays self-contained CJS so the CLI can reuse it from
+ * src/cli/resolve-invocation.ts via createRequire rather than re-implementing
+ * it — the relative path resolves identically from src/cli/ (tsx, vitest) and
+ * dist/cli/ (shipped), since `scripts/` is published alongside `dist/`.
+ */
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const NPX_REF = 'gitnexus@latest';
+
+// Native packages whose postinstall must run under pnpm 10+ (blocked by default).
+const PNPM_ALLOW_BUILD_BASE = ['@ladybugdb/core', 'gitnexus', 'tree-sitter'];
+const PNPM_ALLOW_BUILD_EMBEDDINGS = ['onnxruntime-node'];
+
+// Version-probe timeout, kept under Claude Code's 10s hook budget. PATH presence
+// detection is now spawn-free (resolveOnPath scans PATH directly), so the only
+// subprocesses left are the version probes: in a linked worktree the stale-index
+// hook first runs `git rev-parse --git-common-dir` (~2s) and `git rev-parse HEAD`
+// (~3s); the pnpm path then adds up to two 1s `--version` probes (npm, pnpm), so
+// the worst case is ~7s — within budget. A healthy `--version` returns in well
+// under a second, so the realistic cost is far lower. The bun rungs add at most
+// one more 1s probe (`bunx --version`), reached only when pnpm is unusable and
+// npm is 11+ or unreadable, for a ~8s theoretical cap. That cap needs an absent
+// pnpm to burn its full second, which only Windows can do (`shell: true` spawns
+// cmd.exe); on POSIX an absent pnpm ENOENTs in ~1ms, so the real ceiling is
+// unmoved.
+const PROBE_TIMEOUT_MS = 1000;
+
+/**
+ * Absolute path to `command` on PATH, or null — a pure-Node, spawn-free lookup
+ * that mirrors how a shell resolves a bare command name: each PATH dir × the
+ * platform's executable extensions (PATHEXT on Windows; the bare name + X_OK on
+ * POSIX). This replaces the former `where`/`which` subprocess (#1938 "Option A"):
+ * it is byte-for-byte identical on every OS, with no dependency on the probe
+ * binary being reachable (a sanitized PATH that drops System32 / `/usr/bin` no
+ * longer defeats detection), no shell-spawn surface (CVE-2024-27980), and no
+ * spawn timeout to tune. On Windows it matches PATHEXT extensions ONLY — exactly
+ * what `where`/cmd.exe resolve — so neither an un-spawnable `.ps1`-only shim (not
+ * in default PATHEXT) nor a bare extensionless file (which the shell cannot launch
+ * as `command`) is a false positive. `preferExecExt` returns a recognized
+ * `.cmd`/`.bat`/`.exe` shim ahead of an exotic PATHEXT hit (e.g. `.COM`) when both
+ * match, matching what a user would actually launch. Pure (platform/env injectable)
+ * so it is unit-testable without touching the host PATH.
+ */
+function resolveOnPath(
+  command,
+  preferExecExt = false,
+  { platform = process.platform, env = process.env } = {},
+) {
+  const pathValue = env.PATH || env.Path || env.path || '';
+  if (!pathValue) return null;
+  const isWin = platform === 'win32';
+  const exts = isWin
+    ? (env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
+        .split(';')
+        .map((e) => e.trim())
+        .filter(Boolean)
+        .map((e) => (e.startsWith('.') ? e : `.${e}`))
+    : [''];
+  let weakHit = null;
+  // Split on the host's PATH delimiter. `platform` is injected only to choose the
+  // extension/exec-bit rules; the PATH string is always host-format, so it must
+  // split on the host delimiter (`path.delimiter`) — in production `platform` IS
+  // the host, so they coincide. (Deriving the delimiter from an injected platform
+  // would split a Windows drive-letter path `C:\…` at its colon under a POSIX
+  // injection.)
+  for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+    for (const ext of exts) {
+      const candidate = path.join(dir, `${command}${ext}`);
+      try {
+        if (!fs.statSync(candidate).isFile()) continue;
+        if (!isWin) fs.accessSync(candidate, fs.constants.X_OK);
+        // Prefer a runnable .cmd/.bat/.exe shim; remember an exotic PATHEXT hit
+        // (e.g. .COM) only as a last resort if nothing better turns up.
+        if (isWin && preferExecExt && !/\.(cmd|bat|exe)$/i.test(ext)) {
+          weakHit = weakHit || candidate;
+          continue;
+        }
+        return candidate;
+      } catch {
+        /* not a runnable file here — try the next candidate */
+      }
+    }
+  }
+  return weakHit;
+}
+
+// One spawn of `<command> --version` → { ran, major, minor } (versions null when
+// unreadable). Version injection happens at the resolver seam (getNpmMajorVersion
+// / formatPnpmAllowBuildArgs), so this stays a pure real-process probe.
+//
+// `ran` is liveness, kept separate from the version because a PATH hit proves a
+// file exists, not that it works, and the two answers differ: a banner-printing
+// or oddly-versioned tool is alive with `major: null`, while a stale shim left by
+// a partial uninstall is neither. Only the bun rung consults `ran` today (see
+// hasBun) — it is the one runner with no version to read, so a dedicated probe is
+// its only liveness signal; pnpm gets the same evidence for free from the version
+// spawn it must make anyway, and deliberately forgives an unreadable one (#1939).
+function probeVersion(command) {
+  try {
+    const output = execFileSync(command, ['--version'], {
+      encoding: 'utf-8',
+      timeout: PROBE_TIMEOUT_MS,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      windowsHide: true,
+      // On Windows, npm/pnpm resolve to `.cmd` shims; execFileSync does no
+      // PATHEXT resolution and Node refuses to spawn `.cmd`/`.bat` without a
+      // shell (CVE-2024-27980), so a bare `<command> --version` ENOENTs and the
+      // probe would wrongly report a present tool as absent. A shell lets the OS
+      // resolve the shim. POSIX needs no shell (direct PATH lookup works).
+      shell: process.platform === 'win32',
+    });
+    // Find the first line that starts with a version token (`MAJOR.MINOR`,
+    // optional `v` prefix) rather than splitting the whole output — pnpm/npm
+    // under Corepack or with an update notice can print a banner line on stdout
+    // before the version (stderr is already dropped via the stdio config).
+    const versionLine = output
+      .split('\n')
+      .map((l) => l.trim())
+      .find((l) => /^v?\d+\.\d+/.test(l));
+    const match = versionLine ? versionLine.match(/^v?(\d+)\.(\d+)/) : null;
+    return {
+      ran: true,
+      major: match ? Number(match[1]) : null,
+      minor: match ? Number(match[2]) : null,
+    };
+  } catch {
+    // Spawn failure, non-zero exit, or the timeout — the command did not run.
+    return { ran: false, major: null, minor: null };
+  }
+}
+
+// `deps` is the single injection seam: an explicitly provided key — including a
+// `null` value, detected via `in` — is honored as-is so tests can simulate an
+// absent tool without spawning; an absent key falls through to the real probe.
+function getNpmMajorVersion(deps = {}) {
+  return 'npmMajor' in deps ? deps.npmMajor : probeVersion('npm').major;
+}
+
+/**
+ * `--allow-build` flags for the pre-`dlx` position. Emitted for pnpm >= 10.2
+ * (where the flag exists, and pnpm 10+ blocks build scripts by default). Omitted
+ * below 10.2: pnpm < 10 runs build scripts anyway, and pnpm 10.0/10.1 lack the
+ * flag (it would be rejected as an unknown option). `alwaysAllowBuild` forces the
+ * flags for committed documentation, which cannot probe the reader's pnpm.
+ */
+function formatPnpmAllowBuildArgs(options = {}, deps = {}) {
+  if (!options.alwaysAllowBuild) {
+    const { major, minor } =
+      'pnpmMajor' in deps
+        ? { major: deps.pnpmMajor, minor: 'pnpmMinor' in deps ? deps.pnpmMinor : null }
+        : probeVersion('pnpm');
+    const lacksAllowBuild =
+      major !== null && (major < 10 || (major === 10 && minor !== null && minor < 2));
+    if (lacksAllowBuild) return [];
+  }
+  const pkgs = [...PNPM_ALLOW_BUILD_BASE];
+  if (options.embeddings) pkgs.push(...PNPM_ALLOW_BUILD_EMBEDDINGS);
+  return pkgs.map((p) => `--allow-build=${p}`);
+}
+
+/** Fixed install-free command for committed AGENTS.md / SKILL.md (pnpm >= 10.2). */
+function formatDocumentationDlxCommand(cgraphArgs, options = {}) {
+  const flags = formatPnpmAllowBuildArgs({ ...options, alwaysAllowBuild: true }).join(' ');
+  const prefix = flags ? `${flags} ` : '';
+  return `pnpm ${prefix}dlx ${NPX_REF} ${cgraphArgs}`;
+}
+
+/**
+ * Resolve `gitnexus` | `pnpm` | `bun` | `npx`. `CGRAPH_INVOCATION` forces a
+ * mode (test/escape hatch). `probe` is injectable so the preference order can be
+ * unit-tested without spawning; it defaults to the real PATH probe. `deps` can
+ * inject `{ npmMajor, pnpmMajor, bunPresent, bunRuns }` for tests.
+ */
+function resolveInvocationMode(probe = resolveOnPath, deps = {}) {
+  const forced = process.env.CGRAPH_INVOCATION?.trim().toLowerCase();
+  if (forced === 'gitnexus' || forced === 'pnpm' || forced === 'npx' || forced === 'bun') {
+    return forced;
+  }
+  if (probe('gitnexus', true)) return 'gitnexus';
+
+  const npmMajor = getNpmMajorVersion(deps);
+  // pnpm presence: prefer an explicit `pnpmPresent` flag (set by
+  // formatAnalyzeCommand, which falls back to a PATH probe when the version is
+  // unreadable) so a present-but-unparseable pnpm — slow probe, Corepack
+  // banner — still selects pnpm instead of the npx crash path. Otherwise an
+  // injected version (a successful `pnpm --version` proves presence)
+  // short-circuits the `which pnpm` probe; failing both, fall back to PATH.
+  const hasPnpm =
+    'pnpmPresent' in deps
+      ? deps.pnpmPresent
+      : 'pnpmMajor' in deps
+        ? deps.pnpmMajor !== null
+        : Boolean(probe('pnpm'));
+
+  // bun usability is resolved lazily: only the two branches below can select it,
+  // so a machine with pnpm, or with npm < 11, never pays the PATH scan or the
+  // spawn. `bunx` (not `bun`) is probed because `bunx` is what the resolved
+  // command actually runs. Two gates, `&&`-ordered cheapest first: a spawn-free
+  // PATH scan, then liveness — a PATH hit alone would route a present-but-broken
+  // shim to a command that can only fail at execution time.
+  let bunCache;
+  const hasBun = () => {
+    if (bunCache === undefined) {
+      const present = 'bunPresent' in deps ? Boolean(deps.bunPresent) : Boolean(probe('bunx'));
+      bunCache = present && ('bunRuns' in deps ? Boolean(deps.bunRuns) : probeVersion('bunx').ran);
+    }
+    return bunCache;
+  };
+
+  // npm 11+ npx install crash (#1939) — prefer pnpm dlx when available.
+  if (hasPnpm && npmMajor !== null && npmMajor >= 11) return 'pnpm';
+  // Same crash, no pnpm to fall back on: bunx is install-free and unaffected.
+  if (npmMajor !== null && npmMajor >= 11 && hasBun()) return 'bun';
+  // npm 10 and earlier: npx works; prefer it over pnpm dlx when npm is present.
+  if (npmMajor !== null && npmMajor < 11) return 'npx';
+  // npm absent or unreadable — use pnpm if present (with allow-build flags).
+  if (hasPnpm) return 'pnpm';
+  // Neither npm nor pnpm — bunx is the only install-free runner left. Without
+  // this rung a bun-only machine fell through to `npx`, which is not installed
+  // there, so the emitted command failed with "npx: command not found".
+  if (hasBun()) return 'bun';
+
+  return 'npx';
+}
+
+function formatPnpmDlxCommand(cgraphArgs, options = {}, deps = {}) {
+  const flags = formatPnpmAllowBuildArgs(options, deps).join(' ');
+  const prefix = flags ? `${flags} ` : '';
+  return `pnpm ${prefix}dlx ${NPX_REF} ${cgraphArgs}`;
+}
+
+/**
+ * bun's install-free one-shot runner. Deliberately flag-free: bun has no
+ * per-invocation `--allow-build` equivalent (`--trust` is a `bun add`/`bun
+ * install` flag that writes trustedDependencies into a project package.json,
+ * which a one-shot `bunx` has nowhere to put), so the skipped lifecycle copy is
+ * recovered by the native loader instead of by the invocation.
+ */
+function formatBunxCommand(cgraphArgs) {
+  return `bunx ${NPX_REF} ${cgraphArgs}`;
+}
+
+function formatAnalyzeCommand(options = {}, deps = {}) {
+  const suffix = options.embeddings ? ' --embeddings' : '';
+  // Keep the stale-index hook budget tight by querying each tool at most once.
+  // The memoized `probe` is a spawn-free PATH scan (resolveOnPath) shared with
+  // resolveInvocationMode, so `gitnexus` is scanned only once and no subprocess
+  // is spawned for presence. pnpm's *version* is still captured by a single
+  // `pnpm --version` (the allow-build gate needs the number), which also proves
+  // presence; the memoized scan only re-checks pnpm when that version is
+  // unreadable. Injected deps (tests) and forced/global modes skip the pnpm probe.
+  const cache = new Map();
+  const probe = (command, gitnexusWrapper) => {
+    const key = `${command}:${gitnexusWrapper ? 1 : 0}`;
+    if (!cache.has(key)) cache.set(key, resolveOnPath(command, gitnexusWrapper));
+    return cache.get(key);
+  };
+  let resolved = deps;
+  if (!('pnpmMajor' in deps)) {
+    const forced = process.env.CGRAPH_INVOCATION?.trim().toLowerCase();
+    // pnpm is only consulted when no non-pnpm mode is already certain: forced
+    // cgraph/npx never use pnpm, and a present global gitnexus wins outright.
+    const mightUsePnpm =
+      forced === 'pnpm' || (forced !== 'gitnexus' && forced !== 'npx' && forced !== 'bun');
+    if (mightUsePnpm && (forced === 'pnpm' || !probe('gitnexus', true))) {
+      const { major, minor } = probeVersion('pnpm');
+      // Carry presence separately from version: when the version probe fails
+      // (timeout, Corepack banner) but pnpm is on PATH, still treat it as
+      // present so mode resolution picks pnpm over the npx crash path. The
+      // PATH probe is memoized and only runs when the version is unreadable.
+      const pnpmPresent = major !== null || Boolean(probe('pnpm'));
+      resolved = { ...deps, pnpmMajor: major, pnpmMinor: minor, pnpmPresent };
+    }
+  }
+  const mode = resolveInvocationMode(probe, resolved);
+  if (mode === 'gitnexus') return `gitnexus analyze${suffix}`;
+  if (mode === 'pnpm') return `${formatPnpmDlxCommand(`analyze${suffix}`, options, resolved)}`;
+  if (mode === 'bun') return formatBunxCommand(`analyze${suffix}`);
+  return `npx ${NPX_REF} analyze${suffix}`;
+}
+
+/**
+ * Resolve `mode` into a concrete { program, args } pair for a set of gitnexus
+ * subcommand arguments. Shared by the direct-exec entrypoint below; pure (no
+ * spawn) so it is unit-testable. `--embeddings` widens the pnpm allow-build set.
+ */
+function buildRunnerArgv(mode, cgraphArgs, deps = {}) {
+  // Match both the space form (`--embeddings`) and the equals form
+  // (`--embeddings=5000`) Commander accepts, so the pnpm allow-build set still
+  // widens to onnxruntime-node when a user hand-types the equals form.
+  const embeddings = cgraphArgs.some(
+    (a) => a === '--embeddings' || a.startsWith('--embeddings='),
+  );
+  if (mode === 'gitnexus') return { program: 'gitnexus', args: [...cgraphArgs] };
+  if (mode === 'bun') return { program: 'bunx', args: [NPX_REF, ...cgraphArgs] };
+  if (mode === 'pnpm') {
+    return {
+      program: 'pnpm',
+      args: [...formatPnpmAllowBuildArgs({ embeddings }, deps), 'dlx', NPX_REF, ...cgraphArgs],
+    };
+  }
+  return { program: 'npx', args: [NPX_REF, ...cgraphArgs] };
+}
+
+module.exports = {
+  formatAnalyzeCommand,
+  formatBunxCommand,
+  formatDocumentationDlxCommand,
+  formatPnpmAllowBuildArgs,
+  formatPnpmDlxCommand,
+  resolveInvocationMode,
+  buildRunnerArgv,
+  resolveOnPath,
+  getNpmMajorVersion,
+  NPX_REF,
+  PNPM_ALLOW_BUILD_BASE,
+};

package/dist/core/code/shared/graph/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Graph type definitions — single source of truth.
+ *
+ * Both gitnexus (CLI) and cgraph-web import from this package.
+ * Do NOT add Node.js-specific or browser-specific imports here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/code/shared/index.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNDERSTAND_QUICKLY_DISPATCH_URL = exports.isTerminalNetworkError = exports.parseRetryAfter = exports.RETRY_AFTER_CAP_MS = exports.ResilientFetchExhaustedError = exports.resilientFetch = exports.getBreaker = exports.CircuitOpenError = exports.CircuitBreaker = exports.computeBackoffMs = exports.withRetry = exports.buildPositionIndex = exports.ScopeTreeInvariantError = exports.canParentScope = exports.buildScopeTree = exports.clearScopeIdInternPool = exports.makeScopeId = exports.MACRO_KINDS = exports.FIELD_KINDS = exports.METHOD_KINDS = exports.CLASS_KINDS = exports.CONFIDENCE_EPSILON = exports.compareByConfidenceWithTiebreaks = exports.confidenceFromEvidence = exports.composeEvidence = exports.lookupQualified = exports.lookupCore = exports.buildMacroRegistry = exports.buildFieldRegistry = exports.buildMethodRegistry = exports.buildClassRegistry = exports.finalize = exports.buildMethodDispatchIndex = exports.resolveTypeRef = exports.buildQualifiedNameIndex = exports.buildModuleScopeIndex = exports.buildDefIndex = exports.isProductionLanguage = exports.LanguageClassifications = exports.ORIGIN_PRIORITY = exports.typeBindingWeightAtDepth = exports.EvidenceWeights = exports.isBladeTemplateFilename = exports.getSyntaxLanguageFromFilename = exports.getLanguageFromFilename = exports.SupportedLanguages = exports.EMBEDDING_TABLE_NAME = exports.REL_TYPES = exports.REL_TABLE_NAME = exports.NODE_TABLES = void 0;
+exports.stripGitSuffix = exports.parseOwnerRepoFromRemote = exports.isValidOwnerRepo = exports.buildUqDispatchPayload = exports.UNDERSTAND_QUICKLY_TOKEN_ENV = exports.UNDERSTAND_QUICKLY_EVENT_TYPE = void 0;
+// Schema constants
+var schema_constants_js_1 = require("./lbug/schema-constants.js");
+Object.defineProperty(exports, "NODE_TABLES", { enumerable: true, get: function () { return schema_constants_js_1.NODE_TABLES; } });
+Object.defineProperty(exports, "REL_TABLE_NAME", { enumerable: true, get: function () { return schema_constants_js_1.REL_TABLE_NAME; } });
+Object.defineProperty(exports, "REL_TYPES", { enumerable: true, get: function () { return schema_constants_js_1.REL_TYPES; } });
+Object.defineProperty(exports, "EMBEDDING_TABLE_NAME", { enumerable: true, get: function () { return schema_constants_js_1.EMBEDDING_TABLE_NAME; } });
+// Language support
+var languages_js_1 = require("./languages.js");
+Object.defineProperty(exports, "SupportedLanguages", { enumerable: true, get: function () { return languages_js_1.SupportedLanguages; } });
+var language_detection_js_1 = require("./language-detection.js");
+Object.defineProperty(exports, "getLanguageFromFilename", { enumerable: true, get: function () { return language_detection_js_1.getLanguageFromFilename; } });
+Object.defineProperty(exports, "getSyntaxLanguageFromFilename", { enumerable: true, get: function () { return language_detection_js_1.getSyntaxLanguageFromFilename; } });
+Object.defineProperty(exports, "isBladeTemplateFilename", { enumerable: true, get: function () { return language_detection_js_1.isBladeTemplateFilename; } });
+// Evidence + tie-break constants (RFC Appendix A, Appendix B)
+var evidence_weights_js_1 = require("./scope-resolution/evidence-weights.js");
+Object.defineProperty(exports, "EvidenceWeights", { enumerable: true, get: function () { return evidence_weights_js_1.EvidenceWeights; } });
+Object.defineProperty(exports, "typeBindingWeightAtDepth", { enumerable: true, get: function () { return evidence_weights_js_1.typeBindingWeightAtDepth; } });
+var origin_priority_js_1 = require("./scope-resolution/origin-priority.js");
+Object.defineProperty(exports, "ORIGIN_PRIORITY", { enumerable: true, get: function () { return origin_priority_js_1.ORIGIN_PRIORITY; } });
+// Language classification (RFC §6.1 Ring 3/4 governance)
+var language_classification_js_1 = require("./scope-resolution/language-classification.js");
+Object.defineProperty(exports, "LanguageClassifications", { enumerable: true, get: function () { return language_classification_js_1.LanguageClassifications; } });
+Object.defineProperty(exports, "isProductionLanguage", { enumerable: true, get: function () { return language_classification_js_1.isProductionLanguage; } });
+// Core indexes over per-file artifacts (RFC §3.1; Ring 2 SHARED #913)
+var def_index_js_1 = require("./scope-resolution/def-index.js");
+Object.defineProperty(exports, "buildDefIndex", { enumerable: true, get: function () { return def_index_js_1.buildDefIndex; } });
+var module_scope_index_js_1 = require("./scope-resolution/module-scope-index.js");
+Object.defineProperty(exports, "buildModuleScopeIndex", { enumerable: true, get: function () { return module_scope_index_js_1.buildModuleScopeIndex; } });
+var qualified_name_index_js_1 = require("./scope-resolution/qualified-name-index.js");
+Object.defineProperty(exports, "buildQualifiedNameIndex", { enumerable: true, get: function () { return qualified_name_index_js_1.buildQualifiedNameIndex; } });
+// Strict type-reference resolver (RFC §4.6; Ring 2 SHARED #916)
+// `ScopeLookup` is defined in `./scope-resolution/types.js` and exported
+// from the type-export block above — not from this module.
+var resolve_type_ref_js_1 = require("./scope-resolution/resolve-type-ref.js");
+Object.defineProperty(exports, "resolveTypeRef", { enumerable: true, get: function () { return resolve_type_ref_js_1.resolveTypeRef; } });
+// Method-dispatch materialized view over HeritageMap (RFC §3.1; Ring 2 SHARED #914)
+var method_dispatch_index_js_1 = require("./scope-resolution/method-dispatch-index.js");
+Object.defineProperty(exports, "buildMethodDispatchIndex", { enumerable: true, get: function () { return method_dispatch_index_js_1.buildMethodDispatchIndex; } });
+// SCC-aware cross-file finalize (RFC §3.2 Phase 2; Ring 2 SHARED #915)
+var finalize_algorithm_js_1 = require("./scope-resolution/finalize-algorithm.js");
+Object.defineProperty(exports, "finalize", { enumerable: true, get: function () { return finalize_algorithm_js_1.finalize; } });
+// Scope-aware registries + 7-step lookup (RFC §4; Ring 2 SHARED #917)
+var class_registry_js_1 = require("./scope-resolution/registries/class-registry.js");
+Object.defineProperty(exports, "buildClassRegistry", { enumerable: true, get: function () { return class_registry_js_1.buildClassRegistry; } });
+var method_registry_js_1 = require("./scope-resolution/registries/method-registry.js");
+Object.defineProperty(exports, "buildMethodRegistry", { enumerable: true, get: function () { return method_registry_js_1.buildMethodRegistry; } });
+var field_registry_js_1 = require("./scope-resolution/registries/field-registry.js");
+Object.defineProperty(exports, "buildFieldRegistry", { enumerable: true, get: function () { return field_registry_js_1.buildFieldRegistry; } });
+var macro_registry_js_1 = require("./scope-resolution/registries/macro-registry.js");
+Object.defineProperty(exports, "buildMacroRegistry", { enumerable: true, get: function () { return macro_registry_js_1.buildMacroRegistry; } });
+var lookup_core_js_1 = require("./scope-resolution/registries/lookup-core.js");
+Object.defineProperty(exports, "lookupCore", { enumerable: true, get: function () { return lookup_core_js_1.lookupCore; } });
+var lookup_qualified_js_1 = require("./scope-resolution/registries/lookup-qualified.js");
+Object.defineProperty(exports, "lookupQualified", { enumerable: true, get: function () { return lookup_qualified_js_1.lookupQualified; } });
+var evidence_js_1 = require("./scope-resolution/registries/evidence.js");
+Object.defineProperty(exports, "composeEvidence", { enumerable: true, get: function () { return evidence_js_1.composeEvidence; } });
+Object.defineProperty(exports, "confidenceFromEvidence", { enumerable: true, get: function () { return evidence_js_1.confidenceFromEvidence; } });
+var tie_breaks_js_1 = require("./scope-resolution/registries/tie-breaks.js");
+Object.defineProperty(exports, "compareByConfidenceWithTiebreaks", { enumerable: true, get: function () { return tie_breaks_js_1.compareByConfidenceWithTiebreaks; } });
+Object.defineProperty(exports, "CONFIDENCE_EPSILON", { enumerable: true, get: function () { return tie_breaks_js_1.CONFIDENCE_EPSILON; } });
+var context_js_1 = require("./scope-resolution/registries/context.js");
+Object.defineProperty(exports, "CLASS_KINDS", { enumerable: true, get: function () { return context_js_1.CLASS_KINDS; } });
+Object.defineProperty(exports, "METHOD_KINDS", { enumerable: true, get: function () { return context_js_1.METHOD_KINDS; } });
+Object.defineProperty(exports, "FIELD_KINDS", { enumerable: true, get: function () { return context_js_1.FIELD_KINDS; } });
+Object.defineProperty(exports, "MACRO_KINDS", { enumerable: true, get: function () { return context_js_1.MACRO_KINDS; } });
+// Scope tree spine + position lookup (RFC §2.2 + §3.1; Ring 2 SHARED #912)
+var scope_id_js_1 = require("./scope-resolution/scope-id.js");
+Object.defineProperty(exports, "makeScopeId", { enumerable: true, get: function () { return scope_id_js_1.makeScopeId; } });
+Object.defineProperty(exports, "clearScopeIdInternPool", { enumerable: true, get: function () { return scope_id_js_1.clearScopeIdInternPool; } });
+var scope_tree_js_1 = require("./scope-resolution/scope-tree.js");
+Object.defineProperty(exports, "buildScopeTree", { enumerable: true, get: function () { return scope_tree_js_1.buildScopeTree; } });
+Object.defineProperty(exports, "canParentScope", { enumerable: true, get: function () { return scope_tree_js_1.canParentScope; } });
+Object.defineProperty(exports, "ScopeTreeInvariantError", { enumerable: true, get: function () { return scope_tree_js_1.ScopeTreeInvariantError; } });
+var position_index_js_1 = require("./scope-resolution/position-index.js");
+Object.defineProperty(exports, "buildPositionIndex", { enumerable: true, get: function () { return position_index_js_1.buildPositionIndex; } });
+// Resilient fetch primitives — bounded retries + per-process circuit breaker.
+// Test-only helpers (`__resetBreakerRegistry__`, `classifyOutcome`) are
+// reachable via the separate `cgraph-shared/test-helpers` subpath; do
+// NOT add them here. Production consumers must not call them.
+var retry_js_1 = require("./integrations/retry.js");
+Object.defineProperty(exports, "withRetry", { enumerable: true, get: function () { return retry_js_1.withRetry; } });
+Object.defineProperty(exports, "computeBackoffMs", { enumerable: true, get: function () { return retry_js_1.computeBackoffMs; } });
+var circuit_breaker_js_1 = require("./integrations/circuit-breaker.js");
+Object.defineProperty(exports, "CircuitBreaker", { enumerable: true, get: function () { return circuit_breaker_js_1.CircuitBreaker; } });
+Object.defineProperty(exports, "CircuitOpenError", { enumerable: true, get: function () { return circuit_breaker_js_1.CircuitOpenError; } });
+Object.defineProperty(exports, "getBreaker", { enumerable: true, get: function () { return circuit_breaker_js_1.getBreaker; } });
+var resilient_fetch_js_1 = require("./integrations/resilient-fetch.js");
+Object.defineProperty(exports, "resilientFetch", { enumerable: true, get: function () { return resilient_fetch_js_1.resilientFetch; } });
+Object.defineProperty(exports, "ResilientFetchExhaustedError", { enumerable: true, get: function () { return resilient_fetch_js_1.ResilientFetchExhaustedError; } });
+Object.defineProperty(exports, "RETRY_AFTER_CAP_MS", { enumerable: true, get: function () { return resilient_fetch_js_1.RETRY_AFTER_CAP_MS; } });
+Object.defineProperty(exports, "parseRetryAfter", { enumerable: true, get: function () { return resilient_fetch_js_1.parseRetryAfter; } });
+Object.defineProperty(exports, "isTerminalNetworkError", { enumerable: true, get: function () { return resilient_fetch_js_1.isTerminalNetworkError; } });
+// Understand-Quickly registry integration (opt-in)
+var understand_quickly_js_1 = require("./integrations/understand-quickly.js");
+Object.defineProperty(exports, "UNDERSTAND_QUICKLY_DISPATCH_URL", { enumerable: true, get: function () { return understand_quickly_js_1.UNDERSTAND_QUICKLY_DISPATCH_URL; } });
+Object.defineProperty(exports, "UNDERSTAND_QUICKLY_EVENT_TYPE", { enumerable: true, get: function () { return understand_quickly_js_1.UNDERSTAND_QUICKLY_EVENT_TYPE; } });
+Object.defineProperty(exports, "UNDERSTAND_QUICKLY_TOKEN_ENV", { enumerable: true, get: function () { return understand_quickly_js_1.UNDERSTAND_QUICKLY_TOKEN_ENV; } });
+Object.defineProperty(exports, "buildUqDispatchPayload", { enumerable: true, get: function () { return understand_quickly_js_1.buildUqDispatchPayload; } });
+Object.defineProperty(exports, "isValidOwnerRepo", { enumerable: true, get: function () { return understand_quickly_js_1.isValidOwnerRepo; } });
+Object.defineProperty(exports, "parseOwnerRepoFromRemote", { enumerable: true, get: function () { return understand_quickly_js_1.parseOwnerRepoFromRemote; } });
+Object.defineProperty(exports, "stripGitSuffix", { enumerable: true, get: function () { return understand_quickly_js_1.stripGitSuffix; } });