gitnexus 1.6.10-rc.99 → 1.6.10

package/dist/_shared/lbug/schema-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-constants.d.ts","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,wWAkCd,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,SAAS,iYAoCZ,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}
+{"version":3,"file":"schema-constants.d.ts","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,YACtB,MAAM,EACN,QAAQ,EACR,UAAU,EACV,OAAO,EACP,WAAW,EACX,QAAQ,EACR,aAAa,EACb,WAAW,EACX,SAAS,EACT,SAAS,EACT,QAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,EACT,OAAO,EACP,WAAW,EACX,OAAO,EACP,MAAM,EACN,WAAW,EACX,OAAO,EACP,QAAQ,EACR,UAAU,EACV,UAAU,EACV,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,aAAa,EACb,UAAU,EACV,QAAQ,EACR,OAAO,EACP,MAAM,EAEN,YAAY,CACJ,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,SAAS,YACpB,UAAU,EACV,SAAS,EACT,SAAS,EACT,OAAO,EACP,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,SAAS,EACT,cAAc,EACd,gBAAgB,EAChB,OAAO,EACP,SAAS,EACT,SAAS,EACT,gBAAgB,EAChB,UAAU,EACV,YAAY,EAIZ,KAAK,EACL,cAAc,EACd,SAAS,EACT,WAAW,EACX,YAAY,EAKZ,KAAK,EACL,eAAe,CACP,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}

package/dist/_shared/lbug/schema-constants.js

@@ -65,6 +65,9 @@ export const REL_TYPES = [
     'WRAPS',
     'QUERIES',
     'INJECTS',
+    'CONDITIONAL_ON',
+    'DECLARES',
+    'ADVISED_BY',
     // Taint/PDG substrate (issue #2080) — reserved edge types, emitted by no
     // phase yet (CFG → M1, REACHING_DEF → M2, TAINTED/SANITIZES/TAINT_PATH →
     // M3/M4). REACHING_DEF's variable name rides the relation's `reason` column.

package/dist/_shared/lbug/schema-constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema-constants.js","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,WAAW;IACX,QAAQ;IACR,aAAa;IACb,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,MAAM;IACN,OAAO;IACP,SAAS;IACT,OAAO;IACP,WAAW;IACX,OAAO;IACP,MAAM;IACN,WAAW;IACX,OAAO;IACP,QAAQ;IACR,UAAU;IACV,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,aAAa;IACb,UAAU;IACV,QAAQ;IACR,OAAO;IACP,MAAM;IACN,2EAA2E;IAC3E,YAAY;CACJ,CAAC;AAIX,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,SAAS;IACT,OAAO;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,UAAU;IACV,kBAAkB;IAClB,WAAW,EAAE,mEAAmE;IAChF,mBAAmB;IACnB,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,SAAS;IACT,cAAc;IACd,gBAAgB;IAChB,OAAO;IACP,SAAS;IACT,SAAS;IACT,yEAAyE;IACzE,yEAAyE;IACzE,6EAA6E;IAC7E,KAAK;IACL,cAAc;IACd,SAAS;IACT,WAAW;IACX,YAAY;IACZ,4EAA4E;IAC5E,uEAAuE;IACvE,4EAA4E;IAC5E,8EAA8E;IAC9E,KAAK;IACL,eAAe;CACP,CAAC;AAIX,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}
+{"version":3,"file":"schema-constants.js","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,WAAW;IACX,QAAQ;IACR,aAAa;IACb,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,MAAM;IACN,OAAO;IACP,SAAS;IACT,OAAO;IACP,WAAW;IACX,OAAO;IACP,MAAM;IACN,WAAW;IACX,OAAO;IACP,QAAQ;IACR,UAAU;IACV,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,aAAa;IACb,UAAU;IACV,QAAQ;IACR,OAAO;IACP,MAAM;IACN,2EAA2E;IAC3E,YAAY;CACJ,CAAC;AAIX,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,SAAS;IACT,OAAO;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,UAAU;IACV,kBAAkB;IAClB,WAAW,EAAE,mEAAmE;IAChF,mBAAmB;IACnB,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,SAAS;IACT,cAAc;IACd,gBAAgB;IAChB,OAAO;IACP,SAAS;IACT,SAAS;IACT,gBAAgB;IAChB,UAAU;IACV,YAAY;IACZ,yEAAyE;IACzE,yEAAyE;IACzE,6EAA6E;IAC7E,KAAK;IACL,cAAc;IACd,SAAS;IACT,WAAW;IACX,YAAY;IACZ,4EAA4E;IAC5E,uEAAuE;IACvE,4EAA4E;IAC5E,8EAA8E;IAC9E,KAAK;IACL,eAAe;CACP,CAAC;AAIX,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}

package/dist/_shared/scope-resolution/evidence-weights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evidence-weights.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/evidence-weights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe;IAE1B,sCAAsC;;IAEtC,uCAAuC;;IAEvC,yCAAyC;;IAEzC,0CAA0C;;IAE1C,yCAAyC;;IAIzC,uEAAuE;;IAIvE;;;;;OAKG;;IAIH,qEAAqE;;IAErE;uEACmE;;IAInE,0DAA0D;;IAE1D,uDAAuD;;IAEvD;uEACmE;;IAInE,oDAAoD;;IAEpD,4EAA4E;;IAI5E,kEAAkE;;IAIlE;;;;;;OAMG;;CAEK,CAAC;AAEX;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKjE"}
+{"version":3,"file":"evidence-weights.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/evidence-weights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe;IAE1B,sCAAsC;aACtC,KAAK,EAAE,IAAI;IACX,uCAAuC;aACvC,MAAM,EAAE,IAAI;IACZ,yCAAyC;aACzC,QAAQ,EAAE,GAAG;IACb,0CAA0C;aAC1C,SAAS,EAAE,GAAG;IACd,yCAAyC;aACzC,QAAQ,EAAE,GAAG;IAGb,uEAAuE;aACvE,kBAAkB,EAAE,CAAC,IAAI;IAGzB;;;;;OAKG;aACH,qBAAqB,YAAG,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG;IAGlD,qEAAqE;aACrE,UAAU,EAAE,GAAG;IACf;uEACmE;aACnE,SAAS,EAAE,CAAG;IAGd,0DAA0D;aAC1D,oBAAoB,EAAE,GAAG;IACzB,uDAAuD;aACvD,iBAAiB,EAAE,CAAG;IACtB;uEACmE;aACnE,sBAAsB,EAAE,CAAC,IAAI;IAG7B,oDAAoD;aACpD,eAAe,EAAE,IAAI;IACrB,4EAA4E;aAC5E,UAAU,EAAE,GAAG;IAGf,kEAAkE;aAClE,uBAAuB,EAAE,IAAI;IAG7B;;;;;;OAMG;aACH,wBAAwB,EAAE,GAAG;CACrB,CAAC;AAEX;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKjE"}

package/dist/_shared/scope-resolution/finalize-algorithm.d.ts

@@ -84,6 +84,11 @@ export interface FinalizeHooks {
      * `numpy` is external to the workspace).
      */
     resolveImportTarget(targetRaw: string, fromFile: string, workspaceIndex: WorkspaceIndex, parsedImport?: ParsedImport): string | readonly string[] | null;
+    /**
+     * Reclassify syntax that names an imported symbol as a namespace import
+     * after target resolution proves the symbol is itself a module.
+     */
+    readonly isNamespaceImport?: (parsedImport: ParsedImport, targetFile: string, fromFile: string) => boolean;
     /**
      * For a wildcard `import * from M`, return the names visible in the
      * exporting module scope `M`. The finalize pass looks each name up in

package/dist/_shared/scope-resolution/finalize-algorithm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"finalize-algorithm.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/finalize-algorithm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIhG,4CAA4C;AAC5C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gFAAgF;IAChF,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,SAAS,YAAY,EAAE,CAAC;IAChD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACjD;AAED,2BAA2B;AAC3B,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC,4DAA4D;IAC5D,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CACzC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,mBAAmB,CACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,cAAc,EAC9B,YAAY,CAAC,EAAE,YAAY,GAC1B,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAErC;;;;;OAKG;IACH,iBAAiB,CAAC,iBAAiB,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,GAAG,SAAS,MAAM,EAAE,CAAC;IAEjG;;;;;;OAMG;IACH,aAAa,CACX,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,KAAK,EAAE,OAAO,GACb,SAAS,UAAU,EAAE,CAAC;CAC1B;AAED,8CAA8C;AAC9C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,cAAc;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC;IAC9D,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC,CAAC;IACpF,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B;AAID,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,cAAc,CA8InF"}
+{"version":3,"file":"finalize-algorithm.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/finalize-algorithm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIhG,4CAA4C;AAC5C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gFAAgF;IAChF,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,SAAS,YAAY,EAAE,CAAC;IAChD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACjD;AAED,2BAA2B;AAC3B,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC,4DAA4D;IAC5D,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CACzC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,mBAAmB,CACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,cAAc,EAC9B,YAAY,CAAC,EAAE,YAAY,GAC1B,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAErC;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAC3B,YAAY,EAAE,YAAY,EAC1B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,KACb,OAAO,CAAC;IAEb;;;;;OAKG;IACH,iBAAiB,CAAC,iBAAiB,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,GAAG,SAAS,MAAM,EAAE,CAAC;IAEjG;;;;;;OAMG;IACH,aAAa,CACX,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,KAAK,EAAE,OAAO,GACb,SAAS,UAAU,EAAE,CAAC;CAC1B;AAED,8CAA8C;AAC9C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,cAAc;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC;IAC9D,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC,CAAC;IACpF,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B;AAID,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,cAAc,CA8InF"}

package/dist/_shared/scope-resolution/finalize-algorithm.js

@@ -200,6 +200,8 @@ function makeEdgeDrafts(parsed, file, hooks, workspace) {
             targetFile: null,
             targetExportedName: extractExportedName(parsed),
             kind: edgeKindFor(parsed),
+            ...typeOnlyFor(parsed),
+            ...runsOnlyWhenCalledFor(parsed),
             linkStatus: 'unresolved',
         };
         return [
@@ -218,6 +220,12 @@ function makeEdgeDrafts(parsed, file, hooks, workspace) {
     // and resolved-dynamic imports are terminal at the file level — no
     // `targetDefId` needed since they materialize no `BindingRef`. Pre-
     // finalize them here so the fixpoint loop skips them entirely.
+    // Annotated rather than inferred: `isArray`'s `arg is any[]` predicate widens
+    // the true branch to a MUTABLE array, and a resolver may hand back a cached,
+    // frozen candidate list (Kotlin's `dirChildren` buckets do). Only `.map` is
+    // wanted here, so pinning `readonly` makes an in-place `.sort()`/`.push()` —
+    // which would reorder that resolver's index for the rest of the run — a
+    // compile error rather than a runtime TypeError.
     const targetFiles = Array.isArray(targetFile) ? targetFile : [targetFile];
     const isFileLevelTerminal = parsed.kind === 'side-effect' || parsed.kind === 'dynamic-resolved';
     return targetFiles.map((tf) => {
@@ -225,7 +233,11 @@ function makeEdgeDrafts(parsed, file, hooks, workspace) {
             localName: extractLocalName(parsed),
             targetFile: tf,
             targetExportedName: extractExportedName(parsed),
-            kind: edgeKindFor(parsed),
+            kind: hooks.isNamespaceImport?.(parsed, tf, file.filePath) === true
+                ? 'namespace'
+                : edgeKindFor(parsed),
+            ...typeOnlyFor(parsed),
+            ...runsOnlyWhenCalledFor(parsed),
         };
         return {
             source: parsed,
@@ -242,6 +254,67 @@ function edgeKindFor(parsed) {
         return 'wildcard-expanded';
     return parsed.kind;
 }
+/**
+ * Carry `ParsedImport.typeOnly` onto the edge — the erasure fact `check
+ * --cycles` needs and cannot re-derive, because `kind` is identical for the
+ * erased and the runtime spelling of the same import (`import type D` and
+ * `import D` both arrive as `alias`).
+ *
+ * `'typeOnly' in parsed` rather than a switch over the erasable kinds: only
+ * four variants declare the property, so `parsed.typeOnly` does not compile
+ * against the whole union, and `in` narrows it without naming them. That is
+ * also the safer shape — an enumeration has to be updated when a variant gains
+ * the property or the fact silently stops reaching the edge, while this form
+ * handles a new variant correctly whether or not it declares one.
+ *
+ * Returns a spreadable object rather than a `boolean` so an edge that is not
+ * type-only keeps the exact property set it had before this field existed.
+ * Every `finalized` edge is built by spreading `base`, so setting it here is
+ * enough for all of them.
+ */
+function typeOnlyFor(parsed) {
+    return 'typeOnly' in parsed && parsed.typeOnly === true ? { typeOnly: true } : {};
+}
+/**
+ * Re-carry both runtime-presence flags from an existing edge onto a derived
+ * one.
+ *
+ * `expandWildcard` builds each `wildcard-expanded` edge from scratch rather
+ * than spreading the source (three fields differ per exported name), so every
+ * field it does not name is dropped. That is exactly how both flags were lost
+ * once already. Naming the pair here keeps "these two travel together" in one
+ * place, so a third presence flag is added in one place too.
+ */
+function carriedPresenceFlags(edge) {
+    return {
+        ...(edge.typeOnly === true ? { typeOnly: true } : {}),
+        ...(edge.runsOnlyWhenCalled === true ? { runsOnlyWhenCalled: true } : {}),
+    };
+}
+/**
+ * Carry `ParsedImport.runsOnlyWhenCalled` onto the edge — the position fact
+ * `check --cycles` needs and, unlike every other property of an import, cannot
+ * look up for itself.
+ *
+ * The scope an import was written in does not survive to here:
+ * `FinalizeFile.parsedImports` is a flat per-file list, and Phase 4 publishes
+ * the finalized edges under `file.moduleScope` (see `linkedByScope.set` above),
+ * so the consumer's map is keyed by the Module scope for every file. Walking
+ * that map's key to look for an enclosing `Function` therefore always starts —
+ * and ends — at a `Module`. Only the extractor still knows, so the edge has to
+ * carry what it decided.
+ *
+ * No `in` guard, unlike {@link typeOnlyFor}: position is a property of where
+ * the statement sits, so every variant declares `runsOnlyWhenCalled` and
+ * `parsed.runsOnlyWhenCalled` compiles against the whole union. A new variant
+ * that omits it is a build break here, which is the right outcome.
+ *
+ * Returns a spreadable object rather than a `boolean` so an edge that is not
+ * deferred keeps the exact property set it had before this field existed.
+ */
+function runsOnlyWhenCalledFor(parsed) {
+    return parsed.runsOnlyWhenCalled === true ? { runsOnlyWhenCalled: true } : {};
+}
 function extractLocalName(parsed) {
     switch (parsed.kind) {
         case 'wildcard':
@@ -288,7 +361,7 @@ function tryFinalize(draft, byFilePath, reexportClosures) {
     // languages emit a synthetic module-def), pick it up as the `targetDefId`
     // so consumers can reach the module as a symbol — but its absence is not
     // a failure.
-    if (draft.source.kind === 'namespace') {
+    if (draft.base.kind === 'namespace') {
         const moduleDef = findExportByName(targetModule.localDefs, extractExportedName(draft.source));
         return {
             ...draft.base,
@@ -324,8 +397,10 @@ function tryFinalize(draft, byFilePath, reexportClosures) {
         // re-export inside the target's SCC surfaces it in a later iteration.
         return null;
     }
-    const viaFiles = [targetFile, ...followed.via];
-    const transitiveVia = draft.source.kind === 'reexport' || viaFiles.length > 1 ? Object.freeze(viaFiles) : undefined;
+    // Capped here too, not just inside the closure: this is the last hop, the
+    // one the emitted edge carries.
+    const viaFiles = extendVia(targetFile, followed.via);
+    const transitiveVia = draft.source.kind === 'reexport' || viaFiles.length > 1 ? viaFiles : undefined;
     return {
         ...draft.base,
         targetModuleScope: targetModule.moduleScope,
@@ -341,11 +416,19 @@ function tryFinalize(draft, byFilePath, reexportClosures) {
  * level import graph. Replaces the legacy recursive
  * `followReexportChain` crawl with a bounded, stack-safe pass:
  *
- *   1. **Sub-graph.** Build a directed graph whose edges are
- *      `reexport` and `wildcard` drafts only (regular imports do not
- *      contribute to the export surface, and `namespace`/
- *      `reexport-namespace` are terminal — their target def lives in
- *      `localDefs`).
+ *   1. **Sub-graph.** Build a directed graph whose edges are `wildcard`
+ *      drafts, `reexport` drafts, and `named`/`alias` drafts flagged
+ *      `reexportsName` by their provider. `namespace`/`reexport-namespace`
+ *      are terminal — their target def lives in `localDefs` — and are
+ *      excluded on `base.kind`, after any `isNamespaceImport`
+ *      reclassification.
+ *
+ *      The flagged-named case is what languages with no dedicated
+ *      re-export form need (today: Python, whose module-level
+ *      `from m import x` both binds and republishes). For those providers
+ *      the sub-graph is close to the file-level named-import graph, NOT a
+ *      sparse barrel graph — measured ~20× more edges on the CPython
+ *      stdlib — so read every bound below with that input class in mind.
  *   2. **SCC condensation.** Run the same iterative `tarjanSccs` over
  *      the sub-graph. Output is in reverse-topological order (leaves
  *      first), so when we process an SCC every out-of-SCC neighbor
@@ -359,21 +442,34 @@ function tryFinalize(draft, byFilePath, reexportClosures) {
  *          the cycle; first-wins precedence keeps the map monotone
  *          so the fixpoint converges in at most |SCC| hops).
  *
- * **Precedence semantics — preserved from the recursive crawl.**
+ * **Precedence semantics.**
  *   * Named re-exports take precedence over wildcards.
  *   * Within each kind, declaration order wins (first match for a
- *     given exported name is kept; later drafts skip).
+ *     given exported name is kept; later drafts skip). This is only sound
+ *     where the language makes a duplicate export illegal — true for TS
+ *     and Rust `kind: 'reexport'`, false for the flagged-named form, where
+ *     the module namespace rebinds (last write wins) and `if`/`try` pairs
+ *     execute exactly one branch. For those, an in-file collision on the
+ *     same published name with two different in-workspace targets is
+ *     genuinely ambiguous and is dropped instead of guessed — see
+ *     `collectAmbiguousReexports`.
  *
  * **Complexity.**
  *   * Pre-pass: O(V + E_re) for SCC, plus O(|SCC| × Σ drafts) per cyclic
- *     SCC. For tree-shaped barrel graphs (the common case) it
- *     collapses to O(E_re) total.
- *   * Per-edge lookup at finalize time: O(1).
+ *     SCC. Tree-shaped barrel graphs collapse to O(E_re) total; the
+ *     flagged-named input class does not — the CPython stdlib produces 10
+ *     cyclic SCCs here where TypeScript-shaped input produced none.
+ *   * Per-edge lookup at finalize time: O(1). Target `localDefs` are
+ *     indexed by simple name on first use (`findExportByName`), so the
+ *     per-hop cost is O(1) rather than a linear scan of the target file.
  *   * `transitiveVia` preserves the exact file path chain for diagnostics
  *     and graph provenance. Building those arrays copies the inherited path,
- *     which is O(depth²) in a pathological single-name barrel chain; practical
- *     TypeScript barrel chains are shallow enough that we keep exact paths
- *     instead of capping or summarizing them.
+ *     which is Θ(depth²) in a single-name chain, and Θ(|SCC|²) for a cyclic
+ *     SCC whose chain tracks the cycle. `MAX_REEXPORT_DEPTH = 100` bounded
+ *     this until it was removed in `fc919ad6` for shallow TypeScript
+ *     barrels; **nothing bounds it now**, and the flagged-named class feeds
+ *     it far deeper input. Real `__init__.py` chains measure ≤ ~6, so this
+ *     is a known unenforced assumption, not a live regression.
  *   * Pathological deep chains that previously needed
  *     `MAX_REEXPORT_DEPTH=100` to bound stack growth now resolve
  *     in full and are bounded only by available memory — the
@@ -383,15 +479,17 @@ function buildReexportClosures(files, byFilePath, edgeIndex) {
     const closures = new Map();
     for (const file of files)
         closures.set(file.filePath, new Map());
-    // ── Step 1: build the re-export sub-graph (only resolvable
-    // reexport/wildcard targets contribute edges).
+    // ── Step 1: build the re-export sub-graph (only resolvable wildcard /
+    // reexport / flagged-named targets contribute edges), and collect the
+    // per-file ambiguous names in the same walk.
     const subGraph = new Map();
+    const ambiguous = new Map();
     for (const file of files) {
         const targets = new Set();
         const drafts = edgeIndex.get(file.filePath);
         if (drafts !== undefined) {
             for (const d of drafts) {
-                if (d.source.kind !== 'reexport' && d.source.kind !== 'wildcard')
+                if (!contributesReexportEdge(d))
                     continue;
                 if (d.targetFile === null)
                     continue;
@@ -399,6 +497,7 @@ function buildReexportClosures(files, byFilePath, edgeIndex) {
                     continue;
                 targets.add(d.targetFile);
             }
+            ambiguous.set(file.filePath, collectAmbiguousReexports(drafts, byFilePath));
         }
         subGraph.set(file.filePath, targets);
     }
@@ -412,7 +511,7 @@ function buildReexportClosures(files, byFilePath, edgeIndex) {
         if (!scc.isCycle) {
             const filePath = scc.files[0];
             if (filePath !== undefined) {
-                populateFileClosure(filePath, byFilePath, edgeIndex, closures);
+                populateFileClosure(filePath, byFilePath, edgeIndex, closures, ambiguous);
             }
             continue;
         }
@@ -426,7 +525,7 @@ function buildReexportClosures(files, byFilePath, edgeIndex) {
             progressed = false;
             iter++;
             for (const filePath of scc.files) {
-                if (populateFileClosure(filePath, byFilePath, edgeIndex, closures)) {
+                if (populateFileClosure(filePath, byFilePath, edgeIndex, closures, ambiguous)) {
                     progressed = true;
                 }
             }
@@ -434,6 +533,96 @@ function buildReexportClosures(files, byFilePath, edgeIndex) {
     }
     return closures;
 }
+/**
+ * Does this import republish names from its target under the *importing* file,
+ * making it an edge in the re-export sub-graph?
+ *
+ * `reexport` and `wildcard` are the explicit forms; `named`/`alias` drafts
+ * flagged `reexportsName` cover providers whose ordinary import syntax also
+ * republishes (see that field on `ParsedImport` for the contract).
+ *
+ * Tested on `base.kind`, not `source.kind`: `isNamespaceImport` can reclassify
+ * a `named` draft to `namespace` (Python's `from . import submodule`), and a
+ * namespace import aliases the target *module* — it publishes no name, so
+ * admitting it would republish whatever def happens to share the module's
+ * simple name.
+ */
+function contributesReexportEdge(draft) {
+    if (draft.base.kind === 'namespace')
+        return false;
+    if (draft.source.kind === 'wildcard')
+        return true;
+    return isNamedReexport(draft);
+}
+/**
+ * Named (non-wildcard) re-export. The narrowed type lets `populateFileClosure`
+ * read `localName` (the name this file publishes) and `importedName` (the name
+ * the target exports) without re-discriminating on `kind`.
+ */
+function isNamedReexport(draft) {
+    if (draft.base.kind === 'namespace')
+        return false;
+    const source = draft.source;
+    if (source.kind === 'reexport')
+        return true;
+    return (source.kind === 'named' || source.kind === 'alias') && source.reexportsName === true;
+}
+/**
+ * Names this file publishes ambiguously, which the closure must decline to
+ * answer for rather than guess at.
+ *
+ * Declaration-order first-wins is sound only where a duplicate export is
+ * illegal — two `export { X } from …` is a TypeScript compile error, so the
+ * rule never fires. The flagged-named form has no such guarantee: CPython's
+ * module namespace rebinds, so
+ *
+ *     from .v1 import Client   # legacy, left behind
+ *     from .v2 import Client   # the actual public Client
+ *
+ * binds `v2`, and first-wins would attribute every `from pkg import Client` in
+ * the repo to the dead implementation. Last-wins is not the answer either —
+ * for the equally common `try:`/`except ImportError:` and `if
+ * sys.version_info` pairs exactly one branch runs, and which one is not
+ * decidable here. So both directions are wrong on real code and the entry is
+ * dropped: the importer stays unresolved, which is exactly the pre-#2864
+ * answer, and the file-level IMPORTS edge is unaffected.
+ *
+ * Computed once per file from data phase 0 froze (`edgeIndex`, `targetFile`)
+ * and never revised, so the closure map stays monotone and the `|SCC| + 1`
+ * fixpoint cap keeps the meaning it has above. A set that could grow mid-
+ * fixpoint would need retraction to propagate to files that already inherited
+ * the name, and would break both.
+ *
+ * Only two flagged drafts resolving to two *different in-workspace files*
+ * count. Duplicates of the same target are harmless, and an unresolvable
+ * target (`null` — the `try: import ujson / except: import json` shape, both
+ * external) never entered the closure to begin with.
+ *
+ * ponytail: named-vs-named only. Wildcard-vs-wildcard collisions are also
+ * first-wins today, but their inherited half depends on target closures that
+ * are still filling in, so detecting them needs a set that grows during the
+ * fixpoint — the thing this pre-pass exists to avoid.
+ */
+function collectAmbiguousReexports(drafts, byFilePath) {
+    const firstTarget = new Map();
+    const conflicting = new Set();
+    for (const draft of drafts) {
+        if (!isNamedReexport(draft))
+            continue;
+        if (draft.source.kind === 'reexport')
+            continue; // explicit form: duplicates are illegal upstream
+        const targetFile = draft.targetFile;
+        if (targetFile === null || !byFilePath.has(targetFile))
+            continue;
+        const localName = draft.source.localName;
+        const seen = firstTarget.get(localName);
+        if (seen === undefined)
+            firstTarget.set(localName, targetFile);
+        else if (seen !== targetFile)
+            conflicting.add(localName);
+    }
+    return conflicting;
+}
 /**
  * Populate one file's re-export closure for one pass. Returns `true`
  * iff the closure grew (signalling fixpoint progress to the caller).
@@ -448,7 +637,7 @@ function buildReexportClosures(files, byFilePath, edgeIndex) {
  * targets on the first iteration; the outer fixpoint loop handles
  * that by re-invoking this function.
  */
-function populateFileClosure(filePath, byFilePath, edgeIndex, closures) {
+function populateFileClosure(filePath, byFilePath, edgeIndex, closures, ambiguousByFile) {
     const myClosure = closures.get(filePath);
     if (myClosure === undefined)
         return false;
@@ -456,10 +645,14 @@ function populateFileClosure(filePath, byFilePath, edgeIndex, closures) {
     const drafts = edgeIndex.get(filePath);
     if (drafts === undefined)
         return false;
+    // Fixed for the whole run — see `collectAmbiguousReexports`. Consulted in
+    // both loops below: suppressing only the named one would let a later
+    // `import *` refill the name and reinstate an arbitrary winner.
+    const ambiguous = ambiguousByFile.get(filePath) ?? EMPTY_NAME_SET;
     // Named re-exports — precedence over wildcards, declaration order
     // first-wins for duplicates of the same exported name.
     for (const draft of drafts) {
-        if (draft.source.kind !== 'reexport')
+        if (!isNamedReexport(draft))
             continue;
         const targetFile = draft.targetFile;
         if (targetFile === null)
@@ -468,7 +661,7 @@ function populateFileClosure(filePath, byFilePath, edgeIndex, closures) {
         if (targetModule === undefined)
             continue;
         const localName = draft.source.localName;
-        if (myClosure.has(localName))
+        if (ambiguous.has(localName) || myClosure.has(localName))
             continue;
         const importedName = draft.source.importedName;
         const direct = findExportByName(targetModule.localDefs, importedName);
@@ -480,7 +673,7 @@ function populateFileClosure(filePath, byFilePath, edgeIndex, closures) {
         if (inherited !== undefined) {
             myClosure.set(localName, {
                 def: inherited.def,
-                via: Object.freeze([targetFile, ...inherited.via]),
+                via: extendVia(targetFile, inherited.via),
             });
         }
         // Else: target's closure is still empty (in-SCC, awaiting next
@@ -500,24 +693,52 @@ function populateFileClosure(filePath, byFilePath, edgeIndex, closures) {
             continue;
         for (const def of targetModule.localDefs) {
             const name = deriveSimpleName(def);
-            if (name === null || myClosure.has(name))
+            if (name === null || ambiguous.has(name) || myClosure.has(name))
                 continue;
             myClosure.set(name, { def, via: Object.freeze([targetFile]) });
         }
         const targetClosure = closures.get(targetFile);
         if (targetClosure !== undefined) {
             for (const [name, entry] of targetClosure) {
-                if (myClosure.has(name))
+                if (ambiguous.has(name) || myClosure.has(name))
                     continue;
                 myClosure.set(name, {
                     def: entry.def,
-                    via: Object.freeze([targetFile, ...entry.via]),
+                    via: extendVia(targetFile, entry.via),
                 });
             }
         }
     }
     return myClosure.size > before;
 }
+/**
+ * Longest `transitiveVia` chain kept intact. Beyond this the tail is replaced
+ * by {@link VIA_TRUNCATED}, so the entry still says "this came through a long
+ * chain" without carrying it.
+ *
+ * Reinstates a bound the algorithm lost. Each hop copies the inherited path,
+ * so an uncapped chain is Θ(depth²) in both time and retained memory, and
+ * Θ(|SCC|²) for a cycle whose chain tracks it. `MAX_REEXPORT_DEPTH = 100`
+ * covered this until `fc919ad6` removed it — correctly, for the TypeScript
+ * barrels that were then the only input, which are shallow. Admitting
+ * flagged-named imports changes the input class, so the bound comes back.
+ *
+ * 32 against a measured real-world worst case of ~6 for `__init__.py` chains:
+ * five times the deepest chain anyone has, and it turns the quadratic into
+ * O(depth × 32). Safe to truncate because `ImportEdge.transitiveVia` has no
+ * production reader — it is diagnostic provenance, emitted and typed but not
+ * consumed by graph emission (`emitImportEdges` dedups on source→target and
+ * drops it).
+ */
+const MAX_VIA_LENGTH = 32;
+const VIA_TRUNCATED = '…';
+function extendVia(head, inherited) {
+    if (inherited.length + 1 <= MAX_VIA_LENGTH)
+        return Object.freeze([head, ...inherited]);
+    // Already truncated one hop down: re-truncating keeps the array at the cap
+    // rather than growing it by one per hop, which is the whole point.
+    return Object.freeze([head, ...inherited.slice(0, MAX_VIA_LENGTH - 2), VIA_TRUNCATED]);
+}
 /**
  * O(1) lookup into a precomputed re-export closure. Replaces the legacy
  * recursive `followReexportChain` traversal with a single map indexing.
@@ -572,17 +793,46 @@ function findExportByName(defs, name) {
     //
     // See `gitnexus/test/integration/resolvers/typescript-hof-callbacks.test.ts`
     // for the cross-file regression this rule prevents.
-    let fallback;
+    return indexExportsByName(defs).get(name);
+}
+/**
+ * `simple name → winning def` for one file's `localDefs`, built once and
+ * memoized on the array itself.
+ *
+ * Every caller of `findExportByName` sits in a loop that revisits the same
+ * target files: the phase-3 fixpoint rescans a target once per iteration, and
+ * `populateFileClosure` scans once per admitted re-export — which for a
+ * provider setting `reexportsName` is every named import in the file, where it
+ * used to be zero. Keeping the scan turned that into O(edges × defs).
+ *
+ * Safe to key on identity because `FinalizeFile.localDefs` is documented static
+ * input that the fixpoint never mutates; a `WeakMap` ties each index to its
+ * array's lifetime with no cross-pass state to invalidate. Same shape as the
+ * `defById` map `materializeBindings` already builds for the same reason.
+ */
+const EXPORTS_BY_NAME = new WeakMap();
+function indexExportsByName(defs) {
+    const cached = EXPORTS_BY_NAME.get(defs);
+    if (cached !== undefined)
+        return cached;
+    const index = new Map();
     for (const d of defs) {
-        if (deriveSimpleName(d) !== name)
+        const name = deriveSimpleName(d);
+        if (name === null)
             continue;
-        if (isCallableOrTypeLike(d.type))
-            return d;
-        if (fallback === undefined)
-            fallback = d;
+        const existing = index.get(name);
+        // First match wins within a tier; a callable displaces a stored value
+        // shadow but never another callable — identical to the linear scan's
+        // "first callable if any, else first match".
+        if (existing === undefined)
+            index.set(name, d);
+        else if (!isCallableOrTypeLike(existing.type) && isCallableOrTypeLike(d.type))
+            index.set(name, d);
     }
-    return fallback;
+    EXPORTS_BY_NAME.set(defs, index);
+    return index;
 }
+const EMPTY_NAME_SET = new Set();
 const CALLABLE_OR_TYPE_LIKE = new Set([
     'Function',
     'Method',
@@ -649,6 +899,35 @@ function expandWildcard(edge, byFilePath, hooks, workspace) {
             kind: 'wildcard-expanded',
             targetModuleScope: edge.targetModuleScope,
             targetDefId: def.nodeId,
+            // Every expanded edge inherits the presence facts of the ONE statement it
+            // came from. They are built fresh rather than spread from `edge` because
+            // `localName`, `targetExportedName` and `targetDefId` all differ per name
+            // — which is exactly how a property added to the wildcard edge upstream
+            // gets silently dropped here, and how `runsOnlyWhenCalled` was.
+            //
+            // `runsOnlyWhenCalled`: Ruby's `def f; require './m'; end` is one
+            // statement inside one method body — and every Ruby `require` is a
+            // wildcard, since the required file's whole surface becomes visible — so
+            // each name it brings in is bound only when `f` runs. Losing the flag
+            // here re-reports the pair as an initialization dependency and
+            // suppresses nothing — it INVENTS a cycle (`check --cycles`), which is
+            // why this is carried and not derived.
+            //
+            // Ruby is the reachable spelling. Python has no function-local
+            // `from x import *` — it is a SyntaxError — and Rust's `fn f() { use
+            // m::*; }`, which IS legal, is not deferred at all: `use` is a
+            // compile-time path alias, so the Rust provider opts out of the position
+            // rule (`LanguageProvider.importsExecuteWhereWritten`).
+            //
+            // `typeOnly`: unreachable today and deliberately kept. No provider emits
+            // a type-only wildcard — `reexport-wildcard` returns `kind: 'wildcard'`
+            // with no `typeOnly` because `export type *` is unparseable by the
+            // vendored grammar (documented on `ParsedImport`'s `wildcard` variant).
+            // It is propagated so the day that gap closes does not silently
+            // reintroduce this same defect for erasure. Do not delete it as dead
+            // code; `typeOnlyFor` is the gate that decides whether it can ever be
+            // set, and it is where the correspondence is enforced.
+            ...carriedPresenceFlags(edge),
         });
     }
     return expanded;