gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

package/dist/core/ingestion/languages/typescript/import-target.d.ts

@@ -1,53 +1,41 @@
 /**
  * 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.
+ * Delegates to `module-resolution.ts`, which runs the algorithm `tsc` and Node
+ * actually run. It used to delegate to the shared `resolveImportPath`, whose
+ * final step was `suffixResolve` — a repo-wide search for any file path ending
+ * in the specifier. That is what #2953 removed: this path now resolves only
+ * against declared inputs (real paths, tsconfig `paths`/`baseUrl`, package
+ * manifests) and answers `null` for everything else.
  *
- * 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.
+ * The `WorkspaceIndex` is opaque at the shared contract layer; we narrow it to
+ * a TypeScript-shaped context carrying `fromFile`, the workspace file set, and
+ * the two config indexes the algorithm reads.
  *
  * Returning `null` lets the finalize algorithm mark the edge as
- * `linkStatus: 'unresolved'`.
+ * `linkStatus: 'unresolved'` — which for an external package is the correct
+ * and complete answer.
  */
 import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
-import { SupportedLanguages } from '../../../../_shared/index.js';
-import type { SuffixIndex } from '../../import-resolvers/utils.js';
-import type { TsconfigPaths } from '../../language-config.js';
+import type { NodeWorkspacePackages } from '../../import-resolvers/node-workspace-packages.js';
+import type { TsconfigIndex } from './tsconfig.js';
 export interface TsResolveContext {
     readonly fromFile: string;
-    /** Mutable `Set` because the standard resolver consumes `Set<string>`.
-     *  Callers holding a `ReadonlySet` should copy via `new Set(...)`. */
-    readonly allFilePaths: Set<string>;
-    /** Repo file list, normalized (lowercased) for suffix matching. May
-     *  be supplied by the orchestrator; if absent we derive it on the
-     *  fly from `allFilePaths`. */
-    readonly allFileList?: readonly string[];
-    readonly normalizedFileList?: readonly string[];
-    /** Per-call resolution cache to dedupe repeated lookups. */
-    readonly resolveCache?: Map<string, string | null>;
-    /** Prebuilt suffix index for O(1)-style package/absolute import matching. */
-    readonly index?: SuffixIndex;
-    /** Parsed tsconfig path-aliases. `null` = no aliases configured. */
-    readonly tsconfigPaths?: TsconfigPaths | null;
-    /** JavaScript vs TypeScript switch — affects the extensions the
-     *  resolver tries. Defaults to TypeScript. */
-    readonly language?: SupportedLanguages.TypeScript | SupportedLanguages.JavaScript;
+    /** The workspace file set. */
+    readonly allFilePaths: ReadonlySet<string>;
+    /** Every tsconfig in the repo; `null` when the repo declares none. */
+    readonly tsconfigs?: TsconfigIndex | null;
+    /** Every in-repo `package.json`; `null` when the repo declares none. */
+    readonly nodeWorkspacePackages?: NodeWorkspacePackages | null;
 }
 export declare function resolveTsImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | null;
 /**
- * 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.
+ * Resolve a raw module-path string to a workspace file path. Operates directly
+ * on the source string without requiring a `ParsedImport`, so the
+ * `ScopeResolver.resolveImportTarget` adapter doesn't need to construct a fake
+ * one to reach the resolver.
  *
- * Returns `null` when:
- *   - the context is malformed (missing `fromFile` / `allFilePaths`)
- *   - `targetRaw` is empty
- *   - the resolver finds no matching file
+ * Returns `null` when `targetRaw` is empty, names an external package, or names
+ * something no declared config maps into the repo.
  */
 export declare function resolveTsTarget(targetRaw: string, ctx: TsResolveContext): string | null;

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

@@ -1,20 +1,22 @@
 /**
  * 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.
+ * Delegates to `module-resolution.ts`, which runs the algorithm `tsc` and Node
+ * actually run. It used to delegate to the shared `resolveImportPath`, whose
+ * final step was `suffixResolve` — a repo-wide search for any file path ending
+ * in the specifier. That is what #2953 removed: this path now resolves only
+ * against declared inputs (real paths, tsconfig `paths`/`baseUrl`, package
+ * manifests) and answers `null` for everything else.
  *
- * 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.
+ * The `WorkspaceIndex` is opaque at the shared contract layer; we narrow it to
+ * a TypeScript-shaped context carrying `fromFile`, the workspace file set, and
+ * the two config indexes the algorithm reads.
  *
  * Returning `null` lets the finalize algorithm mark the edge as
- * `linkStatus: 'unresolved'`.
+ * `linkStatus: 'unresolved'` — which for an external package is the correct
+ * and complete answer.
  */
-import { SupportedLanguages } from '../../../../_shared/index.js';
-import { resolveImportPath } from '../../import-resolvers/standard.js';
+import { resolveTsModule } from './module-resolution.js';
 export function resolveTsImportTarget(parsedImport, workspaceIndex) {
     const ctx = narrowTsContext(workspaceIndex);
     if (ctx === null)
@@ -30,25 +32,21 @@ export function resolveTsImportTarget(parsedImport, workspaceIndex) {
     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.
+ * Resolve a raw module-path string to a workspace file path. Operates directly
+ * on the source string without requiring a `ParsedImport`, so the
+ * `ScopeResolver.resolveImportTarget` adapter doesn't need to construct a fake
+ * one to reach the resolver.
  *
- * Returns `null` when:
- *   - the context is malformed (missing `fromFile` / `allFilePaths`)
- *   - `targetRaw` is empty
- *   - the resolver finds no matching file
+ * Returns `null` when `targetRaw` is empty, names an external package, or names
+ * something no declared config maps into the repo.
  */
 export function resolveTsTarget(targetRaw, ctx) {
-    if (targetRaw === '')
-        return null;
-    const language = ctx.language ?? 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 resolveImportPath(ctx.fromFile, targetRaw, ctx.allFilePaths, allFileList, normalizedFileList, resolveCache, language, ctx.tsconfigPaths ?? null, ctx.index);
+    return resolveTsModule(targetRaw, {
+        fromFile: ctx.fromFile,
+        allFilePaths: ctx.allFilePaths,
+        tsconfigs: ctx.tsconfigs ?? null,
+        workspacePackages: ctx.nodeWorkspacePackages ?? null,
+    });
 }
 function narrowTsContext(workspaceIndex) {
     const ctx = workspaceIndex;

package/dist/core/ingestion/languages/typescript/interpret.d.ts

@@ -8,7 +8,8 @@
  *
  * The import matches arrive pre-decomposed by `emitTsScopeCaptures`
  * (one imported name per match, with synthesized
- * `@import.kind/source/name/alias` markers — see `import-decomposer.ts`).
+ * `@import.kind/source/name/alias/type-only` markers — see
+ * `import-decomposer.ts`).
  * The type-binding matches arrive straight from the raw query captures —
  * each `@type-binding.*` anchor carries `@type-binding.name` +
  * `@type-binding.type`.
@@ -33,3 +34,22 @@ export declare function interpretTsImport(captures: CaptureMatch): ParsedImport
  *     to TS today, since TS uses `.values()` / `.keys()` call syntax)
  */
 export declare function interpretTsTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;
+/**
+ * Would this interpreter reduce `text` to the type it CONTAINS rather than to
+ * the type it names? True for the array suffix (`Repo[]`) and for every
+ * transparent wrapper on {@link stripGeneric}'s list (`Array<Repo>`,
+ * `Promise<Repo>`, `Set<Repo>`, …).
+ *
+ * Exported for the ONE caller that must decline exactly what this returns true
+ * for: the JavaScript provider's JSDoc `@type` FIELD binding (#2833). Element
+ * reduction is right where it was built — a chain step, a `for…of` variable, an
+ * awaited value — and wrong for a field, whose declared type IS the container:
+ * a field annotated `{Repo[]}` reduced to `Repo` makes `this.repos.find(…)`,
+ * an Array method call, resolve to a repository class's own `find`. A wrong
+ * edge, which #2833 treats as strictly worse than a missing one.
+ *
+ * A predicate rather than a copied name list on purpose: the list lives in
+ * `stripGeneric` and a second copy would drift out of sync silently, exactly
+ * the failure mode `python/interpret.ts` records for its own reduction.
+ */
+export declare function reducesToContainedType(text: string): boolean;

package/dist/core/ingestion/languages/typescript/interpret.js

@@ -8,18 +8,22 @@
  *
  * The import matches arrive pre-decomposed by `emitTsScopeCaptures`
  * (one imported name per match, with synthesized
- * `@import.kind/source/name/alias` markers — see `import-decomposer.ts`).
+ * `@import.kind/source/name/alias/type-only` markers — see
+ * `import-decomposer.ts`).
  * The type-binding matches arrive straight from the raw query captures —
  * each `@type-binding.*` anchor carries `@type-binding.name` +
  * `@type-binding.type`.
  */
+/** Shared empty result for the non-type-only path — see `typeOnly` below. */
+const NO_TYPE_ONLY = Object.freeze({});
 // ─── interpretImport ──────────────────────────────────────────────────────
 export function interpretTsImport(captures) {
     // Markers attached by `splitImportStatement` (import-decomposer.ts):
-    //   @import.kind   : one of the kinds documented there
-    //   @import.name   : imported name from the source module
-    //   @import.alias  : local alias name (for default / aliased / namespace forms)
-    //   @import.source : module path (always present except dynamic-unresolved)
+    //   @import.kind      : one of the kinds documented there
+    //   @import.name      : imported name from the source module
+    //   @import.alias     : local alias name (for default / aliased / namespace forms)
+    //   @import.source    : module path (always present except dynamic-unresolved)
+    //   @import.type-only : presence-only — this specifier is erased by `tsc`
     const kindCap = captures['@import.kind'];
     const nameCap = captures['@import.name'];
     const aliasCap = captures['@import.alias'];
@@ -27,6 +31,13 @@ export function interpretTsImport(captures) {
     const kind = kindCap?.text;
     if (kind === undefined)
         return null;
+    // Spread rather than `typeOnly: <boolean>` so a value import keeps the exact
+    // object shape it had before this marker existed — every `ParsedImport`
+    // equality assertion in the suite compares whole objects.
+    // `NO_TYPE_ONLY` is shared rather than a fresh `{}` per import: the spread
+    // reads it and never retains it, and the ~99% of imports that are not
+    // type-only would otherwise each allocate an object to contribute nothing.
+    const typeOnly = captures['@import.type-only'] !== undefined ? { typeOnly: true } : NO_TYPE_ONLY;
     switch (kind) {
         case 'default': {
             // `import D from './m'` — semantically "alias for the module's
@@ -41,6 +52,7 @@ export function interpretTsImport(captures) {
                 importedName: 'default',
                 alias: aliasCap.text,
                 targetRaw: sourceCap.text,
+                ...typeOnly,
             };
         }
         case 'named': {
@@ -52,6 +64,7 @@ export function interpretTsImport(captures) {
                 localName: nameCap.text,
                 importedName: nameCap.text,
                 targetRaw: sourceCap.text,
+                ...typeOnly,
             };
         }
         case 'named-alias': {
@@ -65,6 +78,7 @@ export function interpretTsImport(captures) {
                 importedName: nameCap.text,
                 alias: aliasCap.text,
                 targetRaw: sourceCap.text,
+                ...typeOnly,
             };
         }
         case 'namespace': {
@@ -76,6 +90,7 @@ export function interpretTsImport(captures) {
                 localName: aliasCap.text,
                 importedName: sourceCap.text,
                 targetRaw: sourceCap.text,
+                ...typeOnly,
             };
         }
         case 'reexport': {
@@ -87,6 +102,7 @@ export function interpretTsImport(captures) {
                 localName: nameCap.text,
                 importedName: nameCap.text,
                 targetRaw: sourceCap.text,
+                ...typeOnly,
             };
         }
         case 'reexport-alias': {
@@ -100,6 +116,7 @@ export function interpretTsImport(captures) {
                 importedName: nameCap.text,
                 alias: aliasCap.text,
                 targetRaw: sourceCap.text,
+                ...typeOnly,
             };
         }
         case 'reexport-wildcard': {
@@ -120,6 +137,7 @@ export function interpretTsImport(captures) {
                 localName: aliasCap.text,
                 importedName: sourceCap.text,
                 targetRaw: sourceCap.text,
+                ...typeOnly,
             };
         }
         case 'dynamic': {
@@ -315,3 +333,25 @@ function stripQualifier(text) {
         return text;
     return text.slice(lastDot + 1);
 }
+/**
+ * Would this interpreter reduce `text` to the type it CONTAINS rather than to
+ * the type it names? True for the array suffix (`Repo[]`) and for every
+ * transparent wrapper on {@link stripGeneric}'s list (`Array<Repo>`,
+ * `Promise<Repo>`, `Set<Repo>`, …).
+ *
+ * Exported for the ONE caller that must decline exactly what this returns true
+ * for: the JavaScript provider's JSDoc `@type` FIELD binding (#2833). Element
+ * reduction is right where it was built — a chain step, a `for…of` variable, an
+ * awaited value — and wrong for a field, whose declared type IS the container:
+ * a field annotated `{Repo[]}` reduced to `Repo` makes `this.repos.find(…)`,
+ * an Array method call, resolve to a repository class's own `find`. A wrong
+ * edge, which #2833 treats as strictly worse than a missing one.
+ *
+ * A predicate rather than a copied name list on purpose: the list lives in
+ * `stripGeneric` and a second copy would drift out of sync silently, exactly
+ * the failure mode `python/interpret.ts` records for its own reduction.
+ */
+export function reducesToContainedType(text) {
+    const trimmed = stripReadonly(text.trim());
+    return stripArraySuffix(trimmed) !== trimmed || stripGeneric(trimmed) !== trimmed;
+}

package/dist/core/ingestion/languages/typescript/module-resolution.d.ts

@@ -0,0 +1,48 @@
+/**
+ * TypeScript / JavaScript module resolution (#2953).
+ *
+ * This is the algorithm `tsc` and Node actually run, in the order they run it.
+ * It replaces `import-resolvers/utils.ts:suffixResolve` on the TS/JS/Vue path,
+ * which answered a different question — "does any file in this repo have a path
+ * ending in this specifier?" — and answered it by dropping leading segments
+ * until something matched. That is why `@acme/telemetry/nest`, a registry
+ * dependency, landed on the repo's only path ending in `nest/index.ts`.
+ *
+ * Every rule below resolves against something DECLARED: a real path, a
+ * `tsconfig` mapping, or a `package.json` manifest. A specifier that matches
+ * none of them is external, and external resolves to nothing. There is
+ * deliberately no fallback: a guess is what this module exists to remove, and
+ * an edge nobody declared is worse than a missing one precisely because it
+ * cannot be told apart from a real one downstream.
+ *
+ * ## The order, and why it is this order
+ *
+ *   1. relative / absolute — a path is a path; nothing else can claim it.
+ *   2. `#`-prefixed — package.json `imports`, which is scoped to the importing
+ *      package and shadows everything else by design.
+ *   3. tsconfig `paths` — explicit mappings win over `baseUrl`, and the LONGEST
+ *      matching pattern wins among them (tsc's rule, not first-declared).
+ *   4. tsconfig `baseUrl` — the rule that makes `import 'src/utils/foo'` legal.
+ *      Note it applies only when a config actually declares one; without it,
+ *      TypeScript treats a non-relative specifier as a package lookup, and so
+ *      does this module.
+ *   5. workspace package — the manifest map, resolved through that package's
+ *      own `exports` / `main` / `module` / `types`.
+ *   6. anything else — external. `null`.
+ */
+import type { NodeWorkspacePackages } from '../../import-resolvers/node-workspace-packages.js';
+import { type TsconfigIndex } from './tsconfig.js';
+export interface TsModuleResolutionContext {
+    readonly fromFile: string;
+    readonly allFilePaths: ReadonlySet<string>;
+    readonly tsconfigs: TsconfigIndex | null;
+    readonly workspacePackages: NodeWorkspacePackages | null;
+}
+/**
+ * Resolve one specifier to a repo file, or `null` when nothing in the repo
+ * declares it.
+ */
+export declare function resolveTsModule(specifier: string, ctx: TsModuleResolutionContext): string | null;
+/** Whether a specifier names a package rather than a path — used by callers
+ *  that want to report an unresolved import as external rather than missing. */
+export declare function isPackageSpecifier(specifier: string): boolean;

package/dist/core/ingestion/languages/typescript/module-resolution.js

@@ -0,0 +1,171 @@
+/**
+ * TypeScript / JavaScript module resolution (#2953).
+ *
+ * This is the algorithm `tsc` and Node actually run, in the order they run it.
+ * It replaces `import-resolvers/utils.ts:suffixResolve` on the TS/JS/Vue path,
+ * which answered a different question — "does any file in this repo have a path
+ * ending in this specifier?" — and answered it by dropping leading segments
+ * until something matched. That is why `@acme/telemetry/nest`, a registry
+ * dependency, landed on the repo's only path ending in `nest/index.ts`.
+ *
+ * Every rule below resolves against something DECLARED: a real path, a
+ * `tsconfig` mapping, or a `package.json` manifest. A specifier that matches
+ * none of them is external, and external resolves to nothing. There is
+ * deliberately no fallback: a guess is what this module exists to remove, and
+ * an edge nobody declared is worse than a missing one precisely because it
+ * cannot be told apart from a real one downstream.
+ *
+ * ## The order, and why it is this order
+ *
+ *   1. relative / absolute — a path is a path; nothing else can claim it.
+ *   2. `#`-prefixed — package.json `imports`, which is scoped to the importing
+ *      package and shadows everything else by design.
+ *   3. tsconfig `paths` — explicit mappings win over `baseUrl`, and the LONGEST
+ *      matching pattern wins among them (tsc's rule, not first-declared).
+ *   4. tsconfig `baseUrl` — the rule that makes `import 'src/utils/foo'` legal.
+ *      Note it applies only when a config actually declares one; without it,
+ *      TypeScript treats a non-relative specifier as a package lookup, and so
+ *      does this module.
+ *   5. workspace package — the manifest map, resolved through that package's
+ *      own `exports` / `main` / `module` / `types`.
+ *   6. anything else — external. `null`.
+ */
+import { matchSubpathMap, nodePackageNameOf, owningPackage, resolveNodeWorkspaceImport, substituteStar, } from '../../import-resolvers/node-workspace-packages.js';
+import { resolveFile } from './file-candidates.js';
+import { tsconfigFor } from './tsconfig.js';
+/**
+ * Resolve one specifier to a repo file, or `null` when nothing in the repo
+ * declares it.
+ */
+export function resolveTsModule(specifier, ctx) {
+    if (specifier === '')
+        return null;
+    // 1. A path specifier.
+    if (specifier.startsWith('.')) {
+        const joined = joinFrom(ctx.fromFile, specifier);
+        return joined === null ? null : resolveFile(joined, ctx.allFilePaths);
+    }
+    if (specifier.startsWith('/')) {
+        return resolveFile(specifier.slice(1), ctx.allFilePaths);
+    }
+    // 2. Package-internal `#imports`. Scoped to the importing package, so it is
+    //    looked up there and nowhere else — a `#` specifier that the package does
+    //    not declare is an error in Node, not a repo-wide search.
+    if (specifier.startsWith('#')) {
+        return resolveSubpathImport(specifier, ctx);
+    }
+    const config = tsconfigFor(ctx.tsconfigs, ctx.fromFile);
+    // 3. `paths`, longest matching pattern first.
+    if (config !== null && config.paths.length > 0) {
+        const viaPaths = resolveViaPaths(specifier, config.paths, ctx.allFilePaths);
+        if (viaPaths !== null)
+            return viaPaths;
+    }
+    // 4. `baseUrl`.
+    if (config !== null && config.baseUrl !== null) {
+        const viaBaseUrl = resolveFile(joinRepo(config.baseUrl, specifier), ctx.allFilePaths);
+        if (viaBaseUrl !== null)
+            return viaBaseUrl;
+    }
+    // 5. A package that lives in this repo.
+    const viaWorkspace = resolveNodeWorkspaceImport(specifier, ctx.workspacePackages, ctx.allFilePaths);
+    if (viaWorkspace !== null)
+        return viaWorkspace;
+    // 6. External. Nothing in the repo declared it, so it resolves to nothing —
+    //    which for a registry dependency is the correct and complete answer.
+    return null;
+}
+/**
+ * Apply `paths` the way tsc does: the pattern with the longest literal prefix
+ * before `*` wins, and its targets are tried in declaration order.
+ *
+ * The old loader kept `targets[0]` and treated the pattern as a plain prefix,
+ * which silently mis-resolves the common `"@/*": ["./src/*", "./generated/*"]`
+ * shape — the second target is where half of a generated-code monorepo lives.
+ */
+function resolveViaPaths(specifier, paths, allFiles) {
+    const matches = [];
+    for (const mapping of paths) {
+        const star = mapping.pattern.indexOf('*');
+        if (star === -1) {
+            if (mapping.pattern === specifier) {
+                matches.push({ mapping, stem: null, prefixLength: mapping.pattern.length });
+            }
+            continue;
+        }
+        const prefix = mapping.pattern.slice(0, star);
+        const suffix = mapping.pattern.slice(star + 1);
+        if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix))
+            continue;
+        if (specifier.length < prefix.length + suffix.length)
+            continue;
+        matches.push({
+            mapping,
+            stem: specifier.slice(prefix.length, specifier.length - suffix.length),
+            prefixLength: prefix.length,
+        });
+    }
+    // An exact (starless) pattern outranks any wildcard, THEN longer prefix wins.
+    // Sorting on prefix length alone left that first rule to luck: `a` and `a*`
+    // both match `a` with prefix length 1, so whichever was declared first won.
+    matches.sort((a, b) => Number(a.stem !== null) - Number(b.stem !== null) || b.prefixLength - a.prefixLength);
+    for (const match of matches) {
+        for (const target of match.mapping.targets) {
+            const candidate = match.stem === null ? target : substituteStar(target, match.stem);
+            const resolved = resolveFile(candidate, allFiles);
+            if (resolved !== null)
+                return resolved;
+        }
+    }
+    return null;
+}
+/** Resolve `#name` against the importing file's own package manifest. */
+function resolveSubpathImport(specifier, ctx) {
+    const packages = ctx.workspacePackages;
+    if (packages === null)
+        return null;
+    const owner = owningPackage(ctx.fromFile, packages);
+    if (owner === null)
+        return null;
+    // `imports` takes pattern keys (`"#internal/*"`) exactly like `exports`, so
+    // it gets the same matcher rather than an exact lookup.
+    for (const stem of matchSubpathMap(owner.subpathImports, specifier) ?? []) {
+        const resolved = resolveFile(stem, ctx.allFilePaths);
+        if (resolved !== null)
+            return resolved;
+    }
+    return null;
+}
+/**
+ * Resolve a relative specifier against the importing file's directory, or
+ * `null` when it climbs out of the repository.
+ *
+ * Popping an empty segment list would silently CLAMP at the root, so
+ * `../../../secret` from `src/main.ts` became `secret` and could resolve a
+ * repo-root file the specifier never named. Outside the repo there is nothing
+ * indexed to resolve to, so the honest answer is nothing.
+ */
+function joinFrom(fromFile, specifier) {
+    const segments = fromFile.split('/').slice(0, -1);
+    for (const part of specifier.split('/')) {
+        if (part === '.' || part === '')
+            continue;
+        if (part === '..') {
+            if (segments.length === 0)
+                return null;
+            segments.pop();
+        }
+        else {
+            segments.push(part);
+        }
+    }
+    return segments.join('/');
+}
+function joinRepo(dir, rest) {
+    return dir === '' ? rest : `${dir}/${rest}`;
+}
+/** Whether a specifier names a package rather than a path — used by callers
+ *  that want to report an unresolved import as external rather than missing. */
+export function isPackageSpecifier(specifier) {
+    return nodePackageNameOf(specifier) !== null;
+}

package/dist/core/ingestion/languages/typescript/nuxt-auto-imports.js

@@ -202,7 +202,8 @@ function isProjectLocalPath(source) {
 /** True when `absPath` is `repoRoot` itself or lives beneath it. */
 function isWithinRepo(repoRoot, absPath) {
     const root = path.resolve(repoRoot);
-    return absPath === root || absPath.startsWith(root + path.sep);
+    const safeRoot = root.endsWith(path.sep) ? root : root + path.sep;
+    return absPath === root || absPath.startsWith(safeRoot);
 }
 async function resolveExtension(base) {
     const directFile = await firstExistingFile([...FILE_EXTENSIONS.map((ext) => base + ext), base]);

package/dist/core/ingestion/languages/typescript/query.d.ts

@@ -50,6 +50,7 @@
  * sitter init cost per file.
  */
 import Parser from 'tree-sitter';
+export declare const TYPESCRIPT_SCOPE_QUERY: string;
 /**
  * Return the right tree-sitter parser for `filePath` (or the TS parser
  * when no path is given — the legacy callsite shape).