cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/typescript/cjs-module-exports.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * CommonJS module-export capture synthesis, shared by the JavaScript and
+ * TypeScript emitters (#2723; TS parity per the #2729 review, F7).
+ *
+ * These declarations cannot come from the tree-sitter queries: the anonymous
+ * default export takes its name from the FILE, which a query pattern cannot
+ * see. They therefore had to be synthesized in the emitter — and living only in
+ * `javascript/captures.ts` meant a `.ts` file emitted the default-export NODE
+ * (the query and `labelOverride` are wired on both providers) while nothing
+ * ever declared it. That is precisely the "found, zero callers" half-fix state
+ * this issue set out to remove, reintroduced for TypeScript.
+ *
+ * Every grammar node named here exists in both `tree-sitter-javascript` and
+ * `tree-sitter-typescript`, so one implementation serves both.
+ *
+ * Pure given the input nodes. No I/O, no globals.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeCjsReExports = synthesizeCjsReExports;
+exports.synthesizeCjsDefaultExport = synthesizeCjsDefaultExport;
+exports.synthesizeCjsModuleExports = synthesizeCjsModuleExports;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const ts_js_hoc_utils_js_1 = require("../../ts-js-hoc-utils.js");
+const cjs_export_assignment_js_1 = require("./cjs-export-assignment.js");
+/**
+ * Synthesize re-export markers for CJS forwarding assignments (#2723).
+ *
+ *   const lib = require('./lib');
+ *   exports.forwarded = lib.imported;   // re-export of `imported` from ./lib
+ *   const { imported } = require('./lib');
+ *   exports.alsoForwarded = imported;   // same, through a named binding
+ *
+ * The right-hand side is an existing symbol rather than a function literal, so
+ * no definition rule reaches it and importers of `forwarded` resolved to
+ * nothing. Emitted with the `named-alias` vocabulary the destructured
+ * `require()` form already uses, so `interpretJsImport` needs no new case.
+ *
+ * `exports.foo = localFn` (a locally DECLARED function) is deliberately not
+ * handled here: the module scope already binds `localFn`, importers already
+ * resolve through it, and synthesizing a second binding would re-create the
+ * ambiguity the shadow guard exists to prevent.
+ */
+function synthesizeCjsReExports(root, out) {
+    // Namespace and named bindings introduced by require(), by local name.
+    const namespaceSources = new Map();
+    const namedSources = new Map();
+    for (const child of root.namedChildren) {
+        if (child.type !== 'lexical_declaration' && child.type !== 'variable_declaration')
+            continue;
+        for (const declarator of child.namedChildren) {
+            if (declarator.type !== 'variable_declarator')
+                continue;
+            const value = declarator.childForFieldName('value');
+            if (value === null || value.type !== 'call_expression')
+                continue;
+            if (value.childForFieldName('function')?.text !== 'require')
+                continue;
+            const arg = value.childForFieldName('arguments')?.namedChild(0);
+            if (arg === undefined || arg === null || arg.type !== 'string')
+                continue;
+            const source = arg.namedChild(0)?.text ?? arg.text.slice(1, -1);
+            const nameNode = declarator.childForFieldName('name');
+            if (nameNode === null)
+                continue;
+            if (nameNode.type === 'identifier') {
+                namespaceSources.set(nameNode.text, { source, node: arg });
+            }
+            else if (nameNode.type === 'object_pattern') {
+                for (const field of nameNode.namedChildren) {
+                    if (field.type === 'shorthand_property_identifier_pattern') {
+                        namedSources.set(field.text, { source, name: field.text, node: arg });
+                    }
+                    else if (field.type === 'pair_pattern') {
+                        const key = field.childForFieldName('key');
+                        const local = field.childForFieldName('value');
+                        if (key !== null && local !== null && local.type === 'identifier')
+                            namedSources.set(local.text, { source, name: key.text, node: arg });
+                    }
+                }
+            }
+        }
+    }
+    if (namespaceSources.size === 0 && namedSources.size === 0)
+        return;
+    for (const child of root.namedChildren) {
+        if (child.type !== 'expression_statement')
+            continue;
+        const assignment = child.namedChild(0);
+        if (assignment === null || assignment.type !== 'assignment_expression')
+            continue;
+        const left = assignment.childForFieldName('left');
+        if (left === null || left.type !== 'member_expression')
+            continue;
+        const receiver = left.childForFieldName('object');
+        const exposed = left.childForFieldName('property');
+        if (receiver === null || exposed === null || exposed.type !== 'property_identifier')
+            continue;
+        const isExportsReceiver = (receiver.type === 'identifier' && receiver.text === 'exports') ||
+            (receiver.type === 'member_expression' &&
+                receiver.childForFieldName('object')?.text === 'module' &&
+                receiver.childForFieldName('property')?.text === 'exports');
+        if (!isExportsReceiver)
+            continue;
+        const right = assignment.childForFieldName('right');
+        if (right === null)
+            continue;
+        // `exports.fwd = ns.member`
+        if (right.type === 'member_expression') {
+            const ns = right.childForFieldName('object');
+            const member = right.childForFieldName('property');
+            if (ns === null || member === null || ns.type !== 'identifier')
+                continue;
+            const origin = namespaceSources.get(ns.text);
+            if (origin === undefined)
+                continue;
+            out.push({
+                '@import.statement': (0, ast_helpers_js_1.syntheticCapture)('@import.statement', assignment, origin.source),
+                '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', assignment, 'reexport-alias'),
+                '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', member, member.text),
+                '@import.alias': (0, ast_helpers_js_1.syntheticCapture)('@import.alias', exposed, exposed.text),
+                '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', origin.node, origin.source),
+            });
+            continue;
+        }
+        // `exports.fwd = importedName`
+        if (right.type === 'identifier') {
+            const origin = namedSources.get(right.text);
+            if (origin === undefined)
+                continue;
+            out.push({
+                '@import.statement': (0, ast_helpers_js_1.syntheticCapture)('@import.statement', assignment, origin.source),
+                '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', assignment, 'reexport-alias'),
+                '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', right, origin.name),
+                '@import.alias': (0, ast_helpers_js_1.syntheticCapture)('@import.alias', exposed, exposed.text),
+                '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', origin.node, origin.source),
+            });
+        }
+    }
+}
+/**
+ * Synthesize the scope declaration for `module.exports = <function>` (#2723).
+ *
+ * The graph node for this comes from the definition query, but the scope query
+ * cannot produce its name: an anonymous default export takes its name from the
+ * FILE, which a tree-sitter pattern has no access to. Without a declaration the
+ * node exists and nothing resolves to it — the half-fixed state this issue's
+ * first commit already had to correct once.
+ *
+ * A named function expression (`module.exports = function named() {}`) keeps
+ * its own name; the anonymous forms use `deriveDefaultExportHocName`, the
+ * convention already applied to anonymous default exports elsewhere.
+ */
+function synthesizeCjsDefaultExport(root, filePath, out) {
+    for (const child of root.namedChildren) {
+        if (child.type !== 'expression_statement')
+            continue;
+        const assignment = child.namedChild(0);
+        if (assignment === null || assignment.type !== 'assignment_expression')
+            continue;
+        const left = assignment.childForFieldName('left');
+        if (left === null || left.type !== 'member_expression')
+            continue;
+        if (left.childForFieldName('object')?.text !== 'module')
+            continue;
+        if (left.childForFieldName('property')?.text !== 'exports')
+            continue;
+        const value = assignment.childForFieldName('right');
+        if (value === null)
+            continue;
+        if (value.type !== 'function_expression' &&
+            value.type !== 'arrow_function' &&
+            value.type !== 'generator_function')
+            continue;
+        const ownName = value.childForFieldName('name');
+        const name = ownName?.text ?? (0, ts_js_hoc_utils_js_1.deriveDefaultExportHocName)(filePath);
+        // Mirror the worker's suppression: when the DERIVED name collides with a
+        // callable the module already declares, emit nothing. Declaring it anyway
+        // would bind a second callable under one name, merging two functions onto
+        // one node and fabricating a self-recursive call edge (#2729 review F4).
+        if (ownName === null && (0, cjs_export_assignment_js_1.defaultExportNameCollides)(assignment, root, name))
+            continue;
+        // Anchored on the INNER function so the declaration range matches the
+        // `@scope.function` range — the same anchor discipline as every other
+        // closure-binding rule.
+        out.push({
+            '@declaration.function': (0, ast_helpers_js_1.nodeToCapture)('@declaration.function', value),
+            '@declaration.name': (0, ast_helpers_js_1.syntheticCapture)('@declaration.name', ownName ?? value, name),
+        });
+    }
+}
+/** Run every CommonJS export-capture synthesis pass for one file. */
+function synthesizeCjsModuleExports(root, filePath, out) {
+    synthesizeCjsReExports(root, out);
+    synthesizeCjsDefaultExport(root, filePath, out);
+}

package/dist/core/code/engine/core/ingestion/languages/typescript/import-decomposer.js

@@ -0,0 +1,374 @@
+"use strict";
+/**
+ * Decompose a TypeScript `import_statement` / re-export `export_statement` /
+ * dynamic `call_expression(import)` into one `CaptureMatch` per imported
+ * name.
+ *
+ * Why split here? The `LanguageProvider.interpretImport` contract is
+ * one `ParsedImport` per call. Tree-sitter delivers
+ *
+ *   import D, { X as Y, type Z } from './m'
+ *
+ * as a single `import_statement` match, so without decomposition we'd
+ * lose names. The synthesized markers (`@import.kind` / `@import.name`
+ * / `@import.alias` / `@import.source`) carry everything
+ * `interpretTsImport` needs to recover the `ParsedImport` shape —
+ * see `interpret.ts`.
+ *
+ * Kinds we emit and how `interpret.ts` maps them to `ParsedImport`:
+ *
+ *   - `default`            : `import D from './m'`          → alias (importedName=default)
+ *   - `named`              : `import { X } from './m'`      → named
+ *   - `named-alias`        : `import { X as Y } from './m'` → alias
+ *   - `namespace`          : `import * as N from './m'`     → namespace
+ *   - `reexport`           : `export { X } from './m'`      → reexport
+ *   - `reexport-alias`     : `export { X as Y } from './m'` → reexport (with alias)
+ *   - `reexport-wildcard`  : `export * from './m'`          → wildcard
+ *   - `reexport-namespace` : `export * as ns from './m'`    → namespace (local=ns,imported=source)
+ *   - `dynamic`            : `import('./m')` / `import(x)`  → dynamic-resolved or dynamic-unresolved
+ *
+ * Type-only constructs (`import type { X }`, `import { type X }`,
+ * `export type { X }`) emit the same kinds as runtime forms — at the
+ * TypeScript scope-resolution layer, types and values share the same
+ * lookup; runtime-emission is a downstream concern.
+ *
+ * Side-effect imports (`import './polyfill'`) produce a single match
+ * with `kind: 'side-effect'`. The shared finalize algorithm resolves
+ * the target file and emits a file-level IMPORTS edge, but
+ * materializes no `BindingRef` (matching the legacy DAG, which counts
+ * `import './polyfill'` as a module-reachability dependency only).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitImportStatement = splitImportStatement;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+/**
+ * Decompose an import anchor. Handles three node types:
+ *
+ *   - `import_statement`             : all static import forms (incl. side-effect)
+ *   - `export_statement` (w/ source) : re-exports
+ *   - `call_expression` (import fn)  : dynamic `import()`
+ */
+function splitImportStatement(stmtNode) {
+    if (stmtNode.type === 'import_statement')
+        return splitImport(stmtNode);
+    if (stmtNode.type === 'export_statement')
+        return splitReexport(stmtNode);
+    if (stmtNode.type === 'call_expression')
+        return splitDynamicImport(stmtNode);
+    return [];
+}
+// ─── static imports ─────────────────────────────────────────────────────
+function splitImport(stmtNode) {
+    // `import_statement` shape:
+    //   import_clause? "from" string          (static form with bindings)
+    //   string                                (side-effect `import './m'`)
+    //
+    // The `source` field is the string literal — we strip its surrounding
+    // quotes. An import without an `import_clause` child is side-effect
+    // only and still emits one non-binding match.
+    const source = extractSource(stmtNode);
+    if (source === null)
+        return [];
+    const importClause = (0, ast_helpers_js_1.findChild)(stmtNode, 'import_clause');
+    if (importClause === null) {
+        // `import './polyfill'` — no clause, no local binding. Emit a
+        // side-effect match so the finalize layer still produces a
+        // file-level IMPORTS edge (parity with the legacy DAG).
+        return [
+            buildImportMatch(stmtNode, {
+                kind: 'side-effect',
+                source,
+                name: '',
+                atNode: stmtNode,
+            }),
+        ];
+    }
+    const out = [];
+    // An import_clause can have any combination of:
+    //   - leading identifier  (default import)
+    //   - namespace_import    (* as N)
+    //   - named_imports       ({ X, Y as Z })
+    for (let i = 0; i < importClause.namedChildCount; i++) {
+        const child = importClause.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'identifier') {
+            // Default import: `import D from './m'`.
+            out.push(buildImportMatch(stmtNode, {
+                kind: 'default',
+                source,
+                name: 'default',
+                alias: child.text,
+                atNode: child,
+            }));
+            continue;
+        }
+        if (child.type === 'namespace_import') {
+            // `* as N` — the identifier child is the local binding.
+            const aliasId = (0, ast_helpers_js_1.findChild)(child, 'identifier');
+            if (aliasId !== null) {
+                out.push(buildImportMatch(stmtNode, {
+                    kind: 'namespace',
+                    source,
+                    name: source,
+                    alias: aliasId.text,
+                    atNode: child,
+                }));
+            }
+            continue;
+        }
+        if (child.type === 'named_imports') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const spec = child.namedChild(j);
+                if (spec === null || spec.type !== 'import_specifier')
+                    continue;
+                const decomposed = decomposeNamedSpecifier(spec, source, stmtNode);
+                if (decomposed !== null)
+                    out.push(decomposed);
+            }
+            continue;
+        }
+        // Other children (e.g. `type` keyword token for `import type { ... }`)
+        // are ignored — they carry no per-specifier info; we fold type-only
+        // semantics into the same emitted kinds.
+    }
+    return out;
+}
+/**
+ * Decompose a single `import_specifier` into one match. Handles:
+ *
+ *   - `{ X }`            → named
+ *   - `{ X as Y }`       → named-alias
+ *   - `{ type X }`       → named (type-only; same shape)
+ *   - `{ type X as Y }`  → named-alias (type-only)
+ */
+function decomposeNamedSpecifier(spec, source, stmtNode) {
+    // `import_specifier` layout:
+    //   name: identifier
+    //   alias: identifier?            (only when `as` is present)
+    //   plus an optional `type` keyword token in front (per-specifier type-only)
+    //
+    // tree-sitter-typescript exposes `name` and `alias` as named fields.
+    // If `name` is absent, fail closed rather than guessing positionally:
+    // binding the alias as the imported name would invert the edge.
+    const nameNode = spec.childForFieldName('name');
+    const aliasNode = spec.childForFieldName('alias');
+    if (nameNode === null)
+        return null;
+    const name = nameNode.text;
+    if (aliasNode !== null && aliasNode.startIndex !== nameNode.startIndex) {
+        return buildImportMatch(stmtNode, {
+            kind: 'named-alias',
+            source,
+            name,
+            alias: aliasNode.text,
+            atNode: spec,
+        });
+    }
+    return buildImportMatch(stmtNode, {
+        kind: 'named',
+        source,
+        name,
+        atNode: spec,
+    });
+}
+// ─── re-exports ──────────────────────────────────────────────────────────
+function splitReexport(stmtNode) {
+    // `export_statement` with a `source:` field is a re-export. Forms:
+    //
+    //   export { X, Y as Z } from './m'          → export_clause children
+    //   export * from './m'                      → no clause
+    //   export * as ns from './m'                → namespace_export child
+    //   export type { X } from './m'             → same clause path
+    //
+    // Local `export { X }` (no `from`) is visibility metadata, not an
+    // import; the captures-layer query guards with a `source: (string)`
+    // predicate so we always have a source here — but we defend
+    // structurally anyway.
+    const source = extractSource(stmtNode);
+    if (source === null)
+        return [];
+    const exportClause = (0, ast_helpers_js_1.findChild)(stmtNode, 'export_clause');
+    if (exportClause !== null) {
+        const out = [];
+        for (let i = 0; i < exportClause.namedChildCount; i++) {
+            const spec = exportClause.namedChild(i);
+            if (spec === null || spec.type !== 'export_specifier')
+                continue;
+            const decomposed = decomposeReexportSpecifier(spec, source, stmtNode);
+            if (decomposed !== null)
+                out.push(decomposed);
+        }
+        return out;
+    }
+    // `export * as ns from './m'` — tree-sitter-typescript emits a
+    // `namespace_export` child whose identifier is the local re-export
+    // name. Two facts are emitted:
+    //
+    //   1. An `@import.statement` (kind `reexport-namespace`) so finalize
+    //      knows the barrel imports `./m` as `ns` (binds `ns` locally
+    //      inside the barrel for consumers like `barrel.ts` calling
+    //      `ns.X()`).
+    //   2. A synthetic `@declaration.namespace` so the central
+    //      scope-extractor adds a `Namespace` SymbolDefinition for `ns`
+    //      to the barrel's `localDefs`. Without this, downstream files
+    //      doing `import { ns } from './barrel'` cannot resolve `ns`:
+    //      `findExportByName` and the precomputed re-export closure only
+    //      consult `localDefs` / `reexport` / `wildcard` drafts, never
+    //      `namespace`-kind imports. The synthetic declaration fixes that
+    //      without growing the shared finalizer's surface.
+    const namespaceExport = (0, ast_helpers_js_1.findChild)(stmtNode, 'namespace_export');
+    if (namespaceExport !== null) {
+        const aliasId = (0, ast_helpers_js_1.findChild)(namespaceExport, 'identifier');
+        if (aliasId !== null) {
+            return [
+                buildImportMatch(stmtNode, {
+                    kind: 'reexport-namespace',
+                    source,
+                    name: source,
+                    alias: aliasId.text,
+                    atNode: namespaceExport,
+                }),
+                buildNamespaceDeclarationMatch(namespaceExport, aliasId),
+            ];
+        }
+    }
+    // `export * from './m'` — no clause, no namespace_export. The bare
+    // `*` token is the only remaining marker; we don't need to inspect
+    // it since the shape alone says "wildcard".
+    return [
+        buildImportMatch(stmtNode, {
+            kind: 'reexport-wildcard',
+            source,
+            name: '*',
+            atNode: stmtNode,
+        }),
+    ];
+}
+function decomposeReexportSpecifier(spec, source, stmtNode) {
+    const nameNode = spec.childForFieldName('name');
+    const aliasNode = spec.childForFieldName('alias');
+    if (nameNode === null)
+        return null;
+    const name = nameNode.text;
+    if (aliasNode !== null && aliasNode.startIndex !== nameNode.startIndex) {
+        return buildImportMatch(stmtNode, {
+            kind: 'reexport-alias',
+            source,
+            name,
+            alias: aliasNode.text,
+            atNode: spec,
+        });
+    }
+    return buildImportMatch(stmtNode, {
+        kind: 'reexport',
+        source,
+        name,
+        atNode: spec,
+    });
+}
+// ─── dynamic imports ─────────────────────────────────────────────────────
+function splitDynamicImport(callNode) {
+    // `call_expression` shape for dynamic imports:
+    //   function: (import)                   — named leaf node in tree-sitter-typescript
+    //   arguments: (arguments (string) ...)  — first arg is the path
+    //
+    // When the argument is a string literal, preserve its value. When it's
+    // anything else (variable, template literal, member access), surface
+    // the raw text for diagnostics and let `interpretTsImport` emit
+    // `dynamic-unresolved` with a `targetRaw` hint.
+    const args = callNode.childForFieldName('arguments');
+    if (args === null) {
+        return [
+            buildImportMatch(callNode, {
+                kind: 'dynamic',
+                source: null,
+                name: '',
+                atNode: callNode,
+            }),
+        ];
+    }
+    const firstArg = args.namedChild(0);
+    if (firstArg === null) {
+        return [
+            buildImportMatch(callNode, {
+                kind: 'dynamic',
+                source: null,
+                name: '',
+                atNode: callNode,
+            }),
+        ];
+    }
+    if (firstArg.type === 'string') {
+        const source = stripQuotes(firstArg.text);
+        return [
+            buildImportMatch(callNode, {
+                kind: 'dynamic',
+                source,
+                name: '',
+                atNode: callNode,
+                literalSource: true,
+            }),
+        ];
+    }
+    // Non-literal argument — preserve source text so downstream
+    // diagnostics show what the user wrote.
+    return [
+        buildImportMatch(callNode, {
+            kind: 'dynamic',
+            source: firstArg.text,
+            name: '',
+            atNode: callNode,
+        }),
+    ];
+}
+// ─── helpers ─────────────────────────────────────────────────────────────
+function extractSource(stmtNode) {
+    // Both `import_statement` and `export_statement` expose the module
+    // path through the `source:` field. It's typed as `string` in the
+    // grammar; we strip its surrounding quotes.
+    const sourceField = stmtNode.childForFieldName('source');
+    if (sourceField === null || sourceField.type !== 'string')
+        return null;
+    return stripQuotes(sourceField.text);
+}
+function stripQuotes(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length < 2)
+        return trimmed;
+    const first = trimmed.charAt(0);
+    const last = trimmed.charAt(trimmed.length - 1);
+    if ((first === '"' && last === '"') ||
+        (first === "'" && last === "'") ||
+        (first === '`' && last === '`')) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function buildImportMatch(stmtNode, spec) {
+    const m = {
+        '@import.statement': (0, ast_helpers_js_1.nodeToCapture)('@import.statement', stmtNode),
+        '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', spec.atNode, spec.kind),
+        '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', spec.atNode, spec.name),
+    };
+    if (spec.source !== null) {
+        m['@import.source'] = (0, ast_helpers_js_1.syntheticCapture)('@import.source', spec.atNode, spec.source);
+    }
+    if (spec.alias !== undefined) {
+        m['@import.alias'] = (0, ast_helpers_js_1.syntheticCapture)('@import.alias', spec.atNode, spec.alias);
+    }
+    if (spec.literalSource === true) {
+        m['@import.literal'] = (0, ast_helpers_js_1.syntheticCapture)('@import.literal', spec.atNode, '');
+    }
+    return m;
+}
+/** Synthesize a `@declaration.namespace` match for `export * as ns from './m'`.
+ *  The central scope-extractor turns this into a `SymbolDefinition` of type
+ *  `Namespace` in the barrel's `localDefs`, which makes `findExportByName`
+ *  resolve `ns` for downstream `import { ns } from './barrel'` consumers. */
+function buildNamespaceDeclarationMatch(namespaceExportNode, aliasId) {
+    return {
+        '@declaration.namespace': (0, ast_helpers_js_1.nodeToCapture)('@declaration.namespace', namespaceExportNode),
+        '@declaration.name': (0, ast_helpers_js_1.nodeToCapture)('@declaration.name', aliasId),
+    };
+}

package/dist/core/code/engine/core/ingestion/languages/typescript/import-target.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Adapter from `(ParsedImport, WorkspaceIndex)` → concrete file path.
+ *
+ * Delegates to the existing standard-strategy resolver
+ * (`resolveImportPath`) so tsconfig path aliases (`@/`, `~/`, …) and
+ * suffix-based resolution follow the same rules as the legacy path.
+ *
+ * The `WorkspaceIndex` is opaque at the shared contract layer; we
+ * narrow it to a TypeScript-shaped context that carries `fromFile` +
+ * the full `allFilePaths` set + the optional `tsconfigPaths` the
+ * resolver reads.
+ *
+ * Returning `null` lets the finalize algorithm mark the edge as
+ * `linkStatus: 'unresolved'`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTsImportTarget = resolveTsImportTarget;
+exports.resolveTsTarget = resolveTsTarget;
+const index_js_1 = require("../../../../../shared/index.js");
+const standard_js_1 = require("../../import-resolvers/standard.js");
+function resolveTsImportTarget(parsedImport, workspaceIndex) {
+    const ctx = narrowTsContext(workspaceIndex);
+    if (ctx === null)
+        return null;
+    // Dynamic imports carry `targetRaw` only for diagnostics; when the
+    // expression isn't a string literal we can't resolve a file.
+    // A string-literal dynamic import (`import('./m')`) resolves like a
+    // static import — fall through to the shared path resolver.
+    if (parsedImport.kind === 'dynamic-unresolved' && parsedImport.targetRaw === null)
+        return null;
+    if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
+        return null;
+    return resolveTsTarget(parsedImport.targetRaw, ctx);
+}
+/**
+ * Resolve a raw module-path string to a workspace file path using the
+ * same standard-strategy resolver as the legacy DAG. Operates directly on
+ * the source string without requiring a `ParsedImport`, so the
+ * `ScopeResolver.resolveImportTarget` adapter doesn't need to construct
+ * a fake `ParsedImport` to reach the resolver.
+ *
+ * Returns `null` when:
+ *   - the context is malformed (missing `fromFile` / `allFilePaths`)
+ *   - `targetRaw` is empty
+ *   - the resolver finds no matching file
+ */
+function resolveTsTarget(targetRaw, ctx) {
+    if (targetRaw === '')
+        return null;
+    const language = ctx.language ?? index_js_1.SupportedLanguages.TypeScript;
+    const allFileList = ctx.allFileList ?? Array.from(ctx.allFilePaths);
+    const normalizedFileList = ctx.normalizedFileList ?? allFileList.map((f) => f.toLowerCase());
+    const resolveCache = ctx.resolveCache ?? new Map();
+    return (0, standard_js_1.resolveImportPath)(ctx.fromFile, targetRaw, ctx.allFilePaths, allFileList, normalizedFileList, resolveCache, language, ctx.tsconfigPaths ?? null, ctx.index);
+}
+function narrowTsContext(workspaceIndex) {
+    const ctx = workspaceIndex;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        !(ctx.allFilePaths instanceof Set)) {
+        return null;
+    }
+    return ctx;
+}