@quolu/lattice 0.1.0

package/sensor/dist/extraction/dfm-extractor.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfmExtractor = void 0;
+const tree_sitter_helpers_1 = require("./tree-sitter-helpers");
+/**
+ * Custom extractor for Delphi DFM/FMX form files.
+ *
+ * DFM/FMX files describe the visual component hierarchy and event handler
+ * bindings. They use a simple text format (object/end blocks) that we parse
+ * with regex — no tree-sitter grammar exists for this format.
+ *
+ * Extracted information:
+ * - Components as NodeKind `component`
+ * - Nesting as EdgeKind `contains`
+ * - Event handlers (OnClick = MethodName) as UnresolvedReference → EdgeKind `references`
+ */
+class DfmExtractor {
+    filePath;
+    source;
+    nodes = [];
+    edges = [];
+    unresolvedReferences = [];
+    errors = [];
+    constructor(filePath, source) {
+        this.filePath = filePath;
+        this.source = source;
+    }
+    /**
+     * Extract components and event handler references from DFM/FMX source
+     */
+    extract() {
+        const startTime = Date.now();
+        try {
+            const fileNode = this.createFileNode();
+            this.parseComponents(fileNode.id);
+        }
+        catch (error) {
+            this.errors.push({
+                message: `DFM extraction error: ${error instanceof Error ? error.message : String(error)}`,
+                severity: 'error',
+                code: 'parse_error',
+            });
+        }
+        return {
+            nodes: this.nodes,
+            edges: this.edges,
+            unresolvedReferences: this.unresolvedReferences,
+            errors: this.errors,
+            durationMs: Date.now() - startTime,
+        };
+    }
+    /** Create a file node for the DFM form file */
+    createFileNode() {
+        const lines = this.source.split('\n');
+        const id = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'file', this.filePath, 1);
+        const fileNode = {
+            id,
+            kind: 'file',
+            name: this.filePath.split('/').pop() || this.filePath,
+            qualifiedName: this.filePath,
+            filePath: this.filePath,
+            language: 'pascal',
+            startLine: 1,
+            endLine: lines.length,
+            startColumn: 0,
+            endColumn: lines[lines.length - 1]?.length || 0,
+            updatedAt: Date.now(),
+        };
+        this.nodes.push(fileNode);
+        return fileNode;
+    }
+    /** Parse object/end blocks and extract components + event handlers */
+    parseComponents(fileNodeId) {
+        const lines = this.source.split('\n');
+        const stack = [fileNodeId];
+        const objectPattern = /^\s*(object|inherited|inline)\s+(\w+)\s*:\s*(\w+)/;
+        const eventPattern = /^\s*(On\w+)\s*=\s*(\w+)\s*$/;
+        const endPattern = /^\s*end\s*$/;
+        const multiLineStart = /=\s*\(\s*$/;
+        const multiLineItemStart = /=\s*<\s*$/;
+        let inMultiLine = false;
+        let multiLineEndChar = ')';
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNum = i + 1;
+            // Skip multi-line properties
+            if (inMultiLine) {
+                if (line.trimEnd().endsWith(multiLineEndChar))
+                    inMultiLine = false;
+                continue;
+            }
+            if (multiLineStart.test(line)) {
+                inMultiLine = true;
+                multiLineEndChar = ')';
+                continue;
+            }
+            if (multiLineItemStart.test(line)) {
+                inMultiLine = true;
+                multiLineEndChar = '>';
+                continue;
+            }
+            // Component declaration
+            const objMatch = line.match(objectPattern);
+            if (objMatch) {
+                const [, , name, typeName] = objMatch;
+                const nodeId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'component', name, lineNum);
+                this.nodes.push({
+                    id: nodeId,
+                    kind: 'component',
+                    name: name,
+                    qualifiedName: `${this.filePath}#${name}`,
+                    filePath: this.filePath,
+                    language: 'pascal',
+                    startLine: lineNum,
+                    endLine: lineNum,
+                    startColumn: 0,
+                    endColumn: line.length,
+                    signature: typeName,
+                    updatedAt: Date.now(),
+                });
+                this.edges.push({
+                    source: stack[stack.length - 1],
+                    target: nodeId,
+                    kind: 'contains',
+                });
+                stack.push(nodeId);
+                continue;
+            }
+            // Event handler
+            const eventMatch = line.match(eventPattern);
+            if (eventMatch) {
+                const [, , methodName] = eventMatch;
+                this.unresolvedReferences.push({
+                    fromNodeId: stack[stack.length - 1],
+                    referenceName: methodName,
+                    referenceKind: 'references',
+                    line: lineNum,
+                    column: 0,
+                });
+                continue;
+            }
+            // Block end
+            if (endPattern.test(line)) {
+                if (stack.length > 1)
+                    stack.pop();
+            }
+        }
+    }
+}
+exports.DfmExtractor = DfmExtractor;
+//# sourceMappingURL=dfm-extractor.js.map

package/sensor/dist/extraction/dfm-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dfm-extractor.js","sourceRoot":"","sources":["../../src/extraction/dfm-extractor.ts"],"names":[],"mappings":";;;AACA,+DAAuD;AAEvD;;;;;;;;;;;GAWG;AACH,MAAa,YAAY;IACf,QAAQ,CAAS;IACjB,MAAM,CAAS;IACf,KAAK,GAAW,EAAE,CAAC;IACnB,KAAK,GAAW,EAAE,CAAC;IACnB,oBAAoB,GAA0B,EAAE,CAAC;IACjD,MAAM,GAAsB,EAAE,CAAC;IAEvC,YAAY,QAAgB,EAAE,MAAc;QAC1C,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,OAAO;QACL,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE7B,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YACvC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACpC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;gBACf,OAAO,EAAE,yBAAyB,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;gBAC1F,QAAQ,EAAE,OAAO;gBACjB,IAAI,EAAE,aAAa;aACpB,CAAC,CAAC;QACL,CAAC;QAED,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;SACnC,CAAC;IACJ,CAAC;IAED,+CAA+C;IACvC,cAAc;QACpB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,EAAE,GAAG,IAAA,oCAAc,EAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QAEnE,MAAM,QAAQ,GAAS;YACrB,EAAE;YACF,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,QAAQ;YACrD,aAAa,EAAE,IAAI,CAAC,QAAQ;YAC5B,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,QAAQ,EAAE,QAAQ;YAClB,SAAS,EAAE,CAAC;YACZ,OAAO,EAAE,KAAK,CAAC,MAAM;YACrB,WAAW,EAAE,CAAC;YACd,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC;YAC/C,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;SACtB,CAAC;QAEF,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1B,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,sEAAsE;IAC9D,eAAe,CAAC,UAAkB;QACxC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,KAAK,GAAa,CAAC,UAAU,CAAC,CAAC;QAErC,MAAM,aAAa,GAAG,mDAAmD,CAAC;QAC1E,MAAM,YAAY,GAAG,6BAA6B,CAAC;QACnD,MAAM,UAAU,GAAG,aAAa,CAAC;QACjC,MAAM,cAAc,GAAG,YAAY,CAAC;QACpC,MAAM,kBAAkB,GAAG,WAAW,CAAC;QACvC,IAAI,WAAW,GAAG,KAAK,CAAC;QACxB,IAAI,gBAAgB,GAAG,GAAG,CAAC;QAE3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC;YACvB,MAAM,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;YAEtB,6BAA6B;YAC7B,IAAI,WAAW,EAAE,CAAC;gBAChB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC;oBAAE,WAAW,GAAG,KAAK,CAAC;gBACnE,SAAS;YACX,CAAC;YACD,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC9B,WAAW,GAAG,IAAI,CAAC;gBACnB,gBAAgB,GAAG,GAAG,CAAC;gBACvB,SAAS;YACX,CAAC;YACD,IAAI,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBAClC,WAAW,GAAG,IAAI,CAAC;gBACnB,gBAAgB,GAAG,GAAG,CAAC;gBACvB,SAAS;YACX,CAAC;YAED,wBAAwB;YACxB,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;YAC3C,IAAI,QAAQ,EAAE,CAAC;gBACb,MAAM,CAAC,EAAE,AAAD,EAAG,IAAI,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAC;gBACtC,MAAM,MAAM,GAAG,IAAA,oCAAc,EAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAK,EAAE,OAAO,CAAC,CAAC;gBAC1E,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;oBACd,EAAE,EAAE,MAAM;oBACV,IAAI,EAAE,WAAW;oBACjB,IAAI,EAAE,IAAK;oBACX,aAAa,EAAE,GAAG,IAAI,CAAC,QAAQ,IAAI,IAAI,EAAE;oBACzC,QAAQ,EAAE,IAAI,CAAC,QAAQ;oBACvB,QAAQ,EAAE,QAAQ;oBAClB,SAAS,EAAE,OAAO;oBAClB,OAAO,EAAE,OAAO;oBAChB,WAAW,EAAE,CAAC;oBACd,SAAS,EAAE,IAAI,CAAC,MAAM;oBACtB,SAAS,EAAE,QAAQ;oBACnB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;iBACtB,CAAC,CAAC;gBACH,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;oBACd,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAE;oBAChC,MAAM,EAAE,MAAM;oBACd,IAAI,EAAE,UAAU;iBACjB,CAAC,CAAC;gBACH,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACnB,SAAS;YACX,CAAC;YAED,gBAAgB;YAChB,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC5C,IAAI,UAAU,EAAE,CAAC;gBACf,MAAM,CAAC,EAAE,AAAD,EAAG,UAAU,CAAC,GAAG,UAAU,CAAC;gBACpC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC;oBAC7B,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAE;oBACpC,aAAa,EAAE,UAAW;oBAC1B,aAAa,EAAE,YAAY;oBAC3B,IAAI,EAAE,OAAO;oBACb,MAAM,EAAE,CAAC;iBACV,CAAC,CAAC;gBACH,SAAS;YACX,CAAC;YAED,YAAY;YACZ,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC1B,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;oBAAE,KAAK,CAAC,GAAG,EAAE,CAAC;YACpC,CAAC;QACH,CAAC;IACH,CAAC;CACF;AA/ID,oCA+IC"}

package/sensor/dist/extraction/dynamic-import.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Dynamic import() / require() detection and constant-folding for JS/TS.
+ *
+ * The JS/TS extractors only recognized STATIC `import ... from '...'`
+ * (importTypes: ['import_statement']) — dynamic `import(<expr>)` and
+ * CommonJS `require(<expr>)` were invisible, producing false-negative
+ * `imports` edges (ADR 0048, Lattice sensor correctness fix b). The oracle
+ * shape this exists to solve:
+ *
+ *   import { dirname, join, resolve } from "node:path";
+ *   export const ROOT = resolve(import.meta.dirname, "..", "..");
+ *   export const CONTROL_LIB = join(ROOT, "lib", "orchestrate", "control-record.mjs");
+ *   export const loadControl = () => import(CONTROL_LIB);
+ *
+ * which requires 3 folding steps: `import.meta.dirname` -> a project-relative
+ * dirname, `resolve`/`join` -> path arithmetic, and identifier -> a same-file
+ * module-level `const` binding (recursively, since CONTROL_LIB itself refers
+ * to ROOT).
+ *
+ * This module is PURE detection/folding logic — no side effects, no
+ * ExtractionContext dependency — so it's usable from (and unit-testable
+ * independent of) the core extractor's `extractCall` dispatch, which is the
+ * single choke point both AST walkers (the declaration-level `visitNode`
+ * ladder AND the function-body-only `visitForCallsAndStructure`) funnel
+ * every `call_expression` through. See the call site in tree-sitter.ts for
+ * why: a `visitNode`-only hook (the Lua/Ruby `require()` precedent) never
+ * fires for a call nested inside a function body — which is exactly where
+ * `() => import(CONTROL_LIB)` lives.
+ */
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+/**
+ * Sentinel `referenceName` for a dynamic import/require whose argument could
+ * NOT be statically folded (a variable, a non-`join`/`resolve` function call,
+ * a template literal with substitutions, etc.). Deliberately illegal as both
+ * a JS identifier and a file basename (angle brackets, colon) so it can NEVER
+ * coincidentally equal a real symbol/import-local name — `hasAnyPossibleMatch`
+ * and `matchesAnyImport` in the resolver are both name-equality checks, so an
+ * unmatchable sentinel guarantees this never resolves via name-matching into
+ * an accidental wrong edge. It is pushed as a normal unresolved reference so
+ * it goes through the standard resolve-attempt -> mark `status='failed'`
+ * lifecycle (ADR 0048's "no silent fallback" requirement) — a `codegraph
+ * status`/`unresolved_refs` query surfaces it exactly like any other
+ * unresolvable ref, grouped under this one name.
+ */
+export declare const DYNAMIC_IMPORT_UNRESOLVED_MARKER = "<dynamic-import:unresolved>";
+/** True when `node` is a dynamic `import(...)` call (`function` field is the bare `import` keyword node, not an identifier). */
+export declare function isDynamicImportCall(node: SyntaxNode): boolean;
+/**
+ * True when `node` is a bare `require(...)` call. The callee must be a plain
+ * `identifier` reading "require" — `x.require(...)` / `foo.require(...)`
+ * (a `member_expression` callee) is excluded, matching the Lua precedent's
+ * dotted-callee exclusion.
+ */
+export declare function isRequireCall(node: SyntaxNode, source: string): boolean;
+/**
+ * Attempt to fold the single argument of a dynamic import()/require() call
+ * to a constant specifier string. Returns null (folding failure, NOT an
+ * error) when the argument isn't statically determinable — a bare variable,
+ * a function call other than `join`/`resolve`, a template literal with
+ * substitutions, multiple/zero arguments, etc.
+ *
+ * The returned string is used AS-IS as the `imports` unresolved reference's
+ * `referenceName` — a relative literal (`./x.mjs`) resolves through the same
+ * relative-specifier path static `import` statements use (Strategy 2,
+ * resolveViaImport); a project-relative path produced by `join`/`resolve`
+ * arithmetic (`lib/orchestrate/control-record.mjs`) instead lands via
+ * Strategy 3's `matchByFilePath` exact `filePath` match. Both are legitimate,
+ * pre-existing resolution paths — this function doesn't need to know which
+ * one a given result will take.
+ */
+export declare function foldDynamicImportArg(callNode: SyntaxNode, source: string, filePath: string): string | null;
+/**
+ * Public entry point into the same constant-folding logic `foldDynamicImportArg`
+ * uses, for a single already-selected argument node (no argument-count gating).
+ * Reused by spawn-invokes.ts (Lattice sensor correctness fix c/1, ADR 0048) to
+ * fold `child_process` spawn/fork target arguments — a `fork(mod, args, opts)`
+ * call legitimately takes more than one argument, unlike `import()`/`require()`,
+ * so the caller must select the argument node itself rather than going through
+ * `foldDynamicImportArg`'s exactly-one-argument gate.
+ */
+export declare function foldConstantExpr(node: SyntaxNode, source: string, filePath: string): string | null;
+//# sourceMappingURL=dynamic-import.d.ts.map

package/sensor/dist/extraction/dynamic-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-import.d.ts","sourceRoot":"","sources":["../../src/extraction/dynamic-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI1D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gCAAgC,gCAAgC,CAAC;AAK9E,gIAAgI;AAChI,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAI7D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAKvE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,UAAU,EACpB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAWf;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAElG"}

package/sensor/dist/extraction/dynamic-import.js

@@ -0,0 +1,313 @@
+"use strict";
+/**
+ * Dynamic import() / require() detection and constant-folding for JS/TS.
+ *
+ * The JS/TS extractors only recognized STATIC `import ... from '...'`
+ * (importTypes: ['import_statement']) — dynamic `import(<expr>)` and
+ * CommonJS `require(<expr>)` were invisible, producing false-negative
+ * `imports` edges (ADR 0048, Lattice sensor correctness fix b). The oracle
+ * shape this exists to solve:
+ *
+ *   import { dirname, join, resolve } from "node:path";
+ *   export const ROOT = resolve(import.meta.dirname, "..", "..");
+ *   export const CONTROL_LIB = join(ROOT, "lib", "orchestrate", "control-record.mjs");
+ *   export const loadControl = () => import(CONTROL_LIB);
+ *
+ * which requires 3 folding steps: `import.meta.dirname` -> a project-relative
+ * dirname, `resolve`/`join` -> path arithmetic, and identifier -> a same-file
+ * module-level `const` binding (recursively, since CONTROL_LIB itself refers
+ * to ROOT).
+ *
+ * This module is PURE detection/folding logic — no side effects, no
+ * ExtractionContext dependency — so it's usable from (and unit-testable
+ * independent of) the core extractor's `extractCall` dispatch, which is the
+ * single choke point both AST walkers (the declaration-level `visitNode`
+ * ladder AND the function-body-only `visitForCallsAndStructure`) funnel
+ * every `call_expression` through. See the call site in tree-sitter.ts for
+ * why: a `visitNode`-only hook (the Lua/Ruby `require()` precedent) never
+ * fires for a call nested inside a function body — which is exactly where
+ * `() => import(CONTROL_LIB)` lives.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DYNAMIC_IMPORT_UNRESOLVED_MARKER = void 0;
+exports.isDynamicImportCall = isDynamicImportCall;
+exports.isRequireCall = isRequireCall;
+exports.foldDynamicImportArg = foldDynamicImportArg;
+exports.foldConstantExpr = foldConstantExpr;
+const posixPath = __importStar(require("path"));
+const tree_sitter_helpers_1 = require("./tree-sitter-helpers");
+/**
+ * Sentinel `referenceName` for a dynamic import/require whose argument could
+ * NOT be statically folded (a variable, a non-`join`/`resolve` function call,
+ * a template literal with substitutions, etc.). Deliberately illegal as both
+ * a JS identifier and a file basename (angle brackets, colon) so it can NEVER
+ * coincidentally equal a real symbol/import-local name — `hasAnyPossibleMatch`
+ * and `matchesAnyImport` in the resolver are both name-equality checks, so an
+ * unmatchable sentinel guarantees this never resolves via name-matching into
+ * an accidental wrong edge. It is pushed as a normal unresolved reference so
+ * it goes through the standard resolve-attempt -> mark `status='failed'`
+ * lifecycle (ADR 0048's "no silent fallback" requirement) — a `codegraph
+ * status`/`unresolved_refs` query surfaces it exactly like any other
+ * unresolvable ref, grouped under this one name.
+ */
+exports.DYNAMIC_IMPORT_UNRESOLVED_MARKER = '<dynamic-import:unresolved>';
+/** Recursion/cycle guard for identifier -> const-initializer folding. */
+const MAX_FOLD_DEPTH = 8;
+/** True when `node` is a dynamic `import(...)` call (`function` field is the bare `import` keyword node, not an identifier). */
+function isDynamicImportCall(node) {
+    if (node.type !== 'call_expression')
+        return false;
+    const fn = (0, tree_sitter_helpers_1.getChildByField)(node, 'function');
+    return fn?.type === 'import';
+}
+/**
+ * True when `node` is a bare `require(...)` call. The callee must be a plain
+ * `identifier` reading "require" — `x.require(...)` / `foo.require(...)`
+ * (a `member_expression` callee) is excluded, matching the Lua precedent's
+ * dotted-callee exclusion.
+ */
+function isRequireCall(node, source) {
+    if (node.type !== 'call_expression')
+        return false;
+    const fn = (0, tree_sitter_helpers_1.getChildByField)(node, 'function');
+    if (!fn || fn.type !== 'identifier')
+        return false;
+    return (0, tree_sitter_helpers_1.getNodeText)(fn, source) === 'require';
+}
+/**
+ * Attempt to fold the single argument of a dynamic import()/require() call
+ * to a constant specifier string. Returns null (folding failure, NOT an
+ * error) when the argument isn't statically determinable — a bare variable,
+ * a function call other than `join`/`resolve`, a template literal with
+ * substitutions, multiple/zero arguments, etc.
+ *
+ * The returned string is used AS-IS as the `imports` unresolved reference's
+ * `referenceName` — a relative literal (`./x.mjs`) resolves through the same
+ * relative-specifier path static `import` statements use (Strategy 2,
+ * resolveViaImport); a project-relative path produced by `join`/`resolve`
+ * arithmetic (`lib/orchestrate/control-record.mjs`) instead lands via
+ * Strategy 3's `matchByFilePath` exact `filePath` match. Both are legitimate,
+ * pre-existing resolution paths — this function doesn't need to know which
+ * one a given result will take.
+ */
+function foldDynamicImportArg(callNode, source, filePath) {
+    const argsNode = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'arguments');
+    if (!argsNode)
+        return null;
+    const args = argsNode.namedChildren.filter((n) => !!n);
+    // A dynamic import/require legitimately takes exactly one argument. Zero
+    // or multiple (e.g. a webpack magic-comment second arg, which parses as a
+    // comment, not a real 2nd arg, so this is effectively "not exactly one
+    // real argument") is outside what we can safely fold — bail rather than
+    // guess which argument matters.
+    if (args.length !== 1)
+        return null;
+    return foldExpr(args[0], source, filePath, 0, new Set());
+}
+/**
+ * Public entry point into the same constant-folding logic `foldDynamicImportArg`
+ * uses, for a single already-selected argument node (no argument-count gating).
+ * Reused by spawn-invokes.ts (Lattice sensor correctness fix c/1, ADR 0048) to
+ * fold `child_process` spawn/fork target arguments — a `fork(mod, args, opts)`
+ * call legitimately takes more than one argument, unlike `import()`/`require()`,
+ * so the caller must select the argument node itself rather than going through
+ * `foldDynamicImportArg`'s exactly-one-argument gate.
+ */
+function foldConstantExpr(node, source, filePath) {
+    return foldExpr(node, source, filePath, 0, new Set());
+}
+function foldExpr(node, source, filePath, depth, visitedIdentifiers) {
+    if (depth > MAX_FOLD_DEPTH)
+        return null;
+    switch (node.type) {
+        case 'string': {
+            // `string > string_fragment` gives the bare content, sidestepping
+            // quote-char stripping/escaping edge cases (mirrors lua.ts's
+            // requireModule, which reads string_content the same way).
+            const fragment = node.namedChildren.find((c) => c?.type === 'string_fragment');
+            return fragment ? (0, tree_sitter_helpers_1.getNodeText)(fragment, source) : '';
+        }
+        case 'template_string': {
+            // Fold ONLY when every named child is a plain string_fragment — a
+            // `template_substitution` (`${expr}`) OR any other child (e.g. an
+            // `escape_sequence`) makes the literal's runtime value unknowable
+            // from source text alone, so bail rather than approximate.
+            const parts = [];
+            for (const child of node.namedChildren) {
+                if (!child)
+                    continue;
+                if (child.type !== 'string_fragment')
+                    return null;
+                parts.push((0, tree_sitter_helpers_1.getNodeText)(child, source));
+            }
+            return parts.join('');
+        }
+        case 'identifier': {
+            const name = (0, tree_sitter_helpers_1.getNodeText)(node, source);
+            if (name === '__dirname')
+                return projectRelativeDirname(filePath);
+            if (visitedIdentifiers.has(name))
+                return null; // cycle guard (A = B, B = A)
+            const initializer = findModuleLevelConstInitializer(node, name, source);
+            if (!initializer)
+                return null;
+            return foldExpr(initializer, source, filePath, depth + 1, new Set([...visitedIdentifiers, name]));
+        }
+        case 'member_expression': {
+            // `import.meta.dirname` — the ONLY member_expression shape this folds.
+            // tree-sitter-javascript parses `import.meta` as a single `meta_property`
+            // node (not a nested member_expression), so this is a one-level check.
+            const object = (0, tree_sitter_helpers_1.getChildByField)(node, 'object');
+            const property = (0, tree_sitter_helpers_1.getChildByField)(node, 'property');
+            if (object?.type === 'meta_property' &&
+                (0, tree_sitter_helpers_1.getNodeText)(object, source) === 'import.meta' &&
+                property &&
+                (0, tree_sitter_helpers_1.getNodeText)(property, source) === 'dirname') {
+                return projectRelativeDirname(filePath);
+            }
+            return null;
+        }
+        case 'call_expression': {
+            // Bare `join(...)`/`resolve(...)` OR a member form (`path.join(...)`,
+            // `nodePath.resolve(...)`) — the receiver identifier is intentionally
+            // unchecked (spec: "裸 or path.join / path.resolve member 形"), only
+            // the invoked method name matters.
+            const fn = (0, tree_sitter_helpers_1.getChildByField)(node, 'function');
+            const argsNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'arguments');
+            if (!fn || !argsNode)
+                return null;
+            let methodName = null;
+            if (fn.type === 'identifier') {
+                methodName = (0, tree_sitter_helpers_1.getNodeText)(fn, source);
+            }
+            else if (fn.type === 'member_expression') {
+                const property = (0, tree_sitter_helpers_1.getChildByField)(fn, 'property');
+                methodName = property ? (0, tree_sitter_helpers_1.getNodeText)(property, source) : null;
+            }
+            if (methodName !== 'join' && methodName !== 'resolve')
+                return null;
+            const parts = [];
+            for (const arg of argsNode.namedChildren) {
+                if (!arg)
+                    continue;
+                const folded = foldExpr(arg, source, filePath, depth + 1, visitedIdentifiers);
+                if (folded === null)
+                    return null;
+                parts.push(folded);
+            }
+            return foldJoinResolve(parts);
+        }
+        case 'parenthesized_expression': {
+            // `(CONTROL_LIB)` — unwrap defensively; harmless if the grammar never
+            // actually nests one here for our shapes.
+            const inner = node.namedChildren.find((c) => !!c);
+            return inner ? foldExpr(inner, source, filePath, depth + 1, visitedIdentifiers) : null;
+        }
+        default:
+            // Function calls other than join/resolve, binary expressions
+            // (`'./y' + 'z'`), member access on anything else, etc. — not
+            // statically foldable. Folding failure, not an error.
+            return null;
+    }
+}
+/**
+ * Find a module-level (top-of-file) `const NAME = <expr>` declarator's
+ * initializer, honouring an `export` wrapper. Deliberately scoped to
+ * Program's direct children only (not nested inside functions/blocks) —
+ * matches the spec's "module-level const" requirement. `let`/`var` are
+ * excluded (spec: "再代入されうる let/var は畳まない") since they can be
+ * reassigned and the declaration-site value is not necessarily the
+ * call-site value.
+ */
+function findModuleLevelConstInitializer(anyNodeInTree, name, source) {
+    const root = anyNodeInTree.tree.rootNode;
+    for (let i = 0; i < root.namedChildCount; i++) {
+        let decl = root.namedChild(i);
+        if (!decl)
+            continue;
+        if (decl.type === 'export_statement') {
+            const inner = (0, tree_sitter_helpers_1.getChildByField)(decl, 'declaration');
+            if (inner)
+                decl = inner;
+        }
+        if (decl.type !== 'lexical_declaration')
+            continue;
+        const kindNode = (0, tree_sitter_helpers_1.getChildByField)(decl, 'kind');
+        if (kindNode?.type !== 'const')
+            continue;
+        for (let j = 0; j < decl.namedChildCount; j++) {
+            const declarator = decl.namedChild(j);
+            if (declarator?.type !== 'variable_declarator')
+                continue;
+            const nameNode = (0, tree_sitter_helpers_1.getChildByField)(declarator, 'name');
+            if (nameNode && (0, tree_sitter_helpers_1.getNodeText)(nameNode, source) === name) {
+                return (0, tree_sitter_helpers_1.getChildByField)(declarator, 'value');
+            }
+        }
+    }
+    return null;
+}
+/** Project-relative dirname of `filePath` (posix, root as `''` not `'.'`). */
+function projectRelativeDirname(filePath) {
+    const dir = posixPath.posix.dirname(filePath.replace(/\\/g, '/'));
+    return dir === '.' ? '' : dir;
+}
+/**
+ * Fold `join`/`resolve` arguments into one project-relative path. Both are
+ * treated identically — we operate purely in project-relative "pseudo-
+ * absolute" path space (there's no real filesystem CWD at extraction time),
+ * so `resolve`'s "absolute result" semantics and `join`'s "relative to first
+ * arg" semantics collapse to the same segment-join-and-normalize arithmetic.
+ * `..` is resolved (per spec); a result that escapes the project root is a
+ * folding failure — we can't represent "outside the project" as a valid
+ * project-relative file path, and guessing would risk a wrong edge.
+ */
+function foldJoinResolve(parts) {
+    let result = parts[0] ?? '';
+    for (let i = 1; i < parts.length; i++) {
+        const part = parts[i];
+        // A real filesystem-absolute segment (rare in this idiom, and not
+        // something we can map into project-relative space) — bail.
+        if (part.startsWith('/'))
+            return null;
+        result = result ? `${result}/${part}` : part;
+    }
+    const normalized = posixPath.posix.normalize(result);
+    if (normalized === '..' || normalized.startsWith('../'))
+        return null;
+    return normalized === '.' ? '' : normalized;
+}
+//# sourceMappingURL=dynamic-import.js.map

package/sensor/dist/extraction/dynamic-import.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-import.js","sourceRoot":"","sources":["../../src/extraction/dynamic-import.ts"],"names":[],"mappings":"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"}

package/sensor/dist/extraction/extraction-version.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Extraction version
+ *
+ * A monotonically-increasing integer that identifies the *shape and depth* of
+ * what the extractor writes into the graph. Unlike `CURRENT_SCHEMA_VERSION`
+ * (which tracks the SQLite table layout and is migrated in place), this tracks
+ * the EXTRACTED CONTENT — node kinds, edges, synthesizers, resolver coverage.
+ *
+ * When an index was built by an older engine whose `EXTRACTION_VERSION` is
+ * below the running engine's, the data on disk is structurally fine but
+ * *stale*: it's missing whatever a newer extractor would now produce. A schema
+ * migration can't backfill that — only a re-index can. So this is the signal
+ * `codegraph status` uses to recommend a re-index, and the reason `codegraph
+ * upgrade` reminds users to refresh their projects.
+ *
+ * BUMP THIS when a release changes extraction output enough that existing
+ * indexes should be rebuilt to benefit — e.g. a new language/framework
+ * extractor, a new dynamic-dispatch synthesizer, a new node/edge kind, or a
+ * resolver fix that materially changes which edges exist. Do NOT bump for
+ * pure bug fixes, CLI/UX changes, or schema-only migrations. Over-bumping
+ * turns the re-index hint into noise — keep it honest (see CLAUDE.md, "Honesty
+ * in the product is load-bearing").
+ */
+export declare const EXTRACTION_VERSION = 24;
+//# sourceMappingURL=extraction-version.d.ts.map

package/sensor/dist/extraction/extraction-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-version.d.ts","sourceRoot":"","sources":["../../src/extraction/extraction-version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,kBAAkB,KAAK,CAAC"}

package/sensor/dist/extraction/extraction-version.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTRACTION_VERSION = void 0;
+/**
+ * Extraction version
+ *
+ * A monotonically-increasing integer that identifies the *shape and depth* of
+ * what the extractor writes into the graph. Unlike `CURRENT_SCHEMA_VERSION`
+ * (which tracks the SQLite table layout and is migrated in place), this tracks
+ * the EXTRACTED CONTENT — node kinds, edges, synthesizers, resolver coverage.
+ *
+ * When an index was built by an older engine whose `EXTRACTION_VERSION` is
+ * below the running engine's, the data on disk is structurally fine but
+ * *stale*: it's missing whatever a newer extractor would now produce. A schema
+ * migration can't backfill that — only a re-index can. So this is the signal
+ * `codegraph status` uses to recommend a re-index, and the reason `codegraph
+ * upgrade` reminds users to refresh their projects.
+ *
+ * BUMP THIS when a release changes extraction output enough that existing
+ * indexes should be rebuilt to benefit — e.g. a new language/framework
+ * extractor, a new dynamic-dispatch synthesizer, a new node/edge kind, or a
+ * resolver fix that materially changes which edges exist. Do NOT bump for
+ * pure bug fixes, CLI/UX changes, or schema-only migrations. Over-bumping
+ * turns the re-index hint into noise — keep it honest (see CLAUDE.md, "Honesty
+ * in the product is load-bearing").
+ */
+exports.EXTRACTION_VERSION = 24;
+//# sourceMappingURL=extraction-version.js.map

package/sensor/dist/extraction/extraction-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-version.js","sourceRoot":"","sources":["../../src/extraction/extraction-version.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACU,QAAA,kBAAkB,GAAG,EAAE,CAAC"}