gitnexus 1.6.10-rc.98 → 1.6.10

package/dist/core/ingestion/languages/typescript/scope-resolver.js

@@ -17,9 +17,10 @@ import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
 import { simpleKey } from '../../scope-resolution/graph-bridge/node-lookup.js';
 import { typescriptProvider } from '../typescript.js';
-import { loadTsconfigPaths } from '../../language-config.js';
-import { buildSuffixIndex } from '../../import-resolvers/utils.js';
-import { typescriptArityCompatibility, typescriptMergeBindings, resolveTsTarget, } from './index.js';
+import { loadTsconfigIndex } from './tsconfig.js';
+import { loadNodeWorkspacePackages, } from '../../import-resolvers/node-workspace-packages.js';
+import { indexOnlyElementType } from '../../type-extractors/shared.js';
+import { typescriptArityCompatibility, typescriptMergeBindings, resolveTsTarget } from './index.js';
 import { getNuxtAutoImportEntry, hasNuxtAutoImports, loadNuxtAutoImports, } from './nuxt-auto-imports.js';
 const TYPESCRIPT_TYPE_ONLY_BINDING_TYPES = new Set([
     'Interface',
@@ -31,47 +32,32 @@ const TYPESCRIPT_TYPE_ONLY_BINDING_TYPES = new Set([
     'Decorator',
 ]);
 /**
- * Build a `resolveImportTarget` adapter that memoizes the workspace
- * file list, the lower-cased file list, and the per-pass `resolveCache`
- * across every import lookup in a single workspace pass. The
- * orchestrator passes the same `ReadonlySet` reference for every call
- * within a pass — we use that identity to detect when the workspace
- * changes and recompute the derived state lazily.
+ * Build the `resolveImportTarget` adapter.
  *
- * Without this memoization, `resolveTsTarget` re-derived
- * `allFileList` and `normalizedFileList` (both O(N_files)) and threw
- * away the `resolveCache` on every import — O(N_files × N_imports)
- * total work for what should be O(N_files + N_imports).
+ * No per-file-set memo any more: the suffix index it existed to amortize is
+ * gone with #2953. Real resolution derives nothing from the file list — every
+ * candidate comes from a config the repo declares, and checking one is a
+ * `Set.has` — so there is nothing left to cache per pass.
  */
 function makeTsResolveImportTarget() {
-    let cached = null;
     return (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
-        if (cached === null || cached.key !== allFilePaths) {
-            const allFileList = Array.from(allFilePaths);
-            const normalizedFileList = allFileList.map((f) => f.toLowerCase());
-            cached = {
-                key: allFilePaths,
-                allFilePaths: new Set(allFilePaths),
-                allFileList,
-                normalizedFileList,
-                index: buildSuffixIndex(normalizedFileList, allFileList),
-                resolveCache: new Map(),
-            };
-        }
         const cfg = resolutionConfig;
-        const ws = {
+        return resolveTsTarget(targetRaw, {
             fromFile,
-            allFilePaths: cached.allFilePaths,
-            allFileList: cached.allFileList,
-            normalizedFileList: cached.normalizedFileList,
-            index: cached.index,
-            resolveCache: cached.resolveCache,
-            tsconfigPaths: cfg?.tsconfigPaths ?? null,
-        };
-        return resolveTsTarget(targetRaw, ws);
+            allFilePaths,
+            tsconfigs: cfg?.tsconfigs ?? null,
+            nodeWorkspacePackages: cfg?.nodeWorkspacePackages ?? null,
+        });
     };
 }
 const typescriptScopeResolver = {
+    // One hook, both routes. TypeScript exposes collection views as METHOD calls
+    // (`.values()`), which the call-expression branch already handles, so the
+    // accessor route yields nothing here — but it is now the same hook rather
+    // than a second one left undefined.
+    elementTypeOf: indexOnlyElementType,
+    // Construction is keyword-prefixed: `new Service(db).doWork()` (#2708).
+    constructionSyntax: { keyword: 'new' },
     language: SupportedLanguages.TypeScript,
     languageProvider: typescriptProvider,
     importEdgeReason: 'typescript-scope: import',
@@ -83,7 +69,8 @@ const typescriptScopeResolver = {
     // `nuxtAutoImports` is null for non-Nuxt projects (no .nuxt/imports.d.ts),
     // so this adds zero overhead to ordinary TypeScript repos.
     loadResolutionConfig: async (repoPath) => ({
-        tsconfigPaths: await loadTsconfigPaths(repoPath),
+        tsconfigs: await loadTsconfigIndex(repoPath),
+        nodeWorkspacePackages: await loadNodeWorkspacePackages(repoPath),
         nuxtAutoImports: await loadNuxtAutoImports(repoPath),
     }),
     // TypeScript declaration merging + LEGB: local > import > wildcard,
@@ -109,10 +96,10 @@ const typescriptScopeResolver = {
     // boundaries and resolve chained member calls).
     fieldFallbackOnMethodLookup: false,
     propagatesReturnTypesAcrossImports: true,
-    // TypeScript uses `.values()` / `.keys()` method-call syntax for
-    // collection views -- no property-style accessors like C#'s
-    // `Dictionary<K,V>.Values`. Leave `unwrapCollectionAccessor`
-    // undefined and let the regular member-call branch handle them.
+    // TypeScript uses `.values()` / `.keys()` method-call syntax for collection
+    // views -- no property-style accessors like C#'s `Dictionary<K,V>.Values` --
+    // so `elementTypeOf` answers only the `index` route and lets the regular
+    // member-call branch handle the rest.
     //
     // `collapseMemberCallsByCallerTarget` left undefined (= false) --
     // TypeScript legacy DAG emits one edge per call site, so

package/dist/core/ingestion/languages/typescript/simple-hooks.d.ts

@@ -26,16 +26,6 @@ import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } f
  * propagation.
  */
 export declare function tsBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | null;
-/**
- * Walk up the scope chain to find the first scope whose `kind` matches
- * any of `kinds`. Returns the matching scope's id or `null` when no
- * ancestor matches (e.g., a return type binding emitted outside any
- * Module scope — shouldn't happen in well-formed input).
- *
- * Exported so language-specific hook wrappers (e.g. `jsBindingScopeFor`)
- * can reuse it without duplicating the traversal logic.
- */
-export declare function walkToScope(from: Scope, tree: ScopeTree, ...kinds: readonly Scope['kind'][]): ScopeId | null;
 /**
  * TypeScript imports are syntactically top-level: `import_statement` is
  * legal only inside `program` (the module root). `namespace X { … }`

package/dist/core/ingestion/languages/typescript/simple-hooks.js

@@ -4,6 +4,7 @@
  * the provider's choice explicit rather than relying on "absence ==
  * default" so reviewers don't have to re-derive the analysis.
  */
+import { walkToScope } from '../../utils/scope-tree-walk.js';
 // ─── bindingScopeFor ──────────────────────────────────────────────────────
 /**
  * TypeScript/JavaScript has block-scoped `let`/`const` (the innermost
@@ -38,6 +39,27 @@ export function tsBindingScopeFor(decl, innermost, tree) {
     if (decl['@type-binding.parameter-property'] !== undefined) {
         return walkToScope(innermost, tree, 'Class');
     }
+    // `this.p = new Outer()` binds the FIELD, not a method-local, so the binding
+    // belongs on the class the way an annotated field's does — that is the only
+    // place `typeOfMemberOnClass` reads. Left on the innermost scope it would sit
+    // on the method's own Function scope and never be found (#2807). Same shape
+    // as the parameter-property branch above.
+    //
+    // Gated on the marker the `this.<field> = new …` pattern emits, never on
+    // `@type-binding.constructor` at large: that capture also fires for
+    // `const o = new Outer()` inside a method, and hoisting THOSE to the class
+    // would take method locals out of their own scope and mistype them.
+    //
+    // This walk is UNCONDITIONAL by design, and stays correct only because the
+    // marker's producers are bounded: the query nests the pattern under
+    // `class_body → method_definition → statement_block`, and `emitTsScopeCaptures`
+    // drops the static-method case. So `this` here provably IS an instance of the
+    // class this lands on, and a Class ancestor always exists — no `walkToScope`
+    // null-fallback onto some unrelated innermost scope. Anything that widens the
+    // marker's producers has to re-establish both, or restore the guard here.
+    if (decl['@type-binding.this-field'] !== undefined) {
+        return walkToScope(innermost, tree, 'Class');
+    }
     // `var` declarations: hoist to nearest enclosing Function or Module.
     const variable = decl['@declaration.variable'];
     if (variable !== undefined && isVarDeclaration(variable.text)) {
@@ -51,28 +73,6 @@ export function tsBindingScopeFor(decl, innermost, tree) {
     // needed.
     return null;
 }
-/**
- * Walk up the scope chain to find the first scope whose `kind` matches
- * any of `kinds`. Returns the matching scope's id or `null` when no
- * ancestor matches (e.g., a return type binding emitted outside any
- * Module scope — shouldn't happen in well-formed input).
- *
- * Exported so language-specific hook wrappers (e.g. `jsBindingScopeFor`)
- * can reuse it without duplicating the traversal logic.
- */
-export function walkToScope(from, tree, ...kinds) {
-    let cur = from;
-    const kindSet = new Set(kinds);
-    while (cur !== undefined) {
-        if (kindSet.has(cur.kind))
-            return cur.id;
-        const parentId = cur.parent ?? null;
-        if (parentId === null)
-            break;
-        cur = tree.getScope(parentId);
-    }
-    return null;
-}
 /** `var x = 1;` vs `let x = 1;` / `const x = 1;`. The capture's text
  *  starts at the outer declaration's `startIndex` in source, which is
  *  the keyword's first character — no leading whitespace possible. */

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

@@ -0,0 +1,59 @@
+/**
+ * Real `tsconfig.json` loading for module resolution (#2953).
+ *
+ * The previous loader (`language-config.ts:loadTsconfigPaths`) was built to feed
+ * a heuristic, and it shows: it reads three filenames at the repo ROOT only,
+ * gives up unless `compilerOptions.paths` exists, keeps only `targets[0]` of
+ * each mapping, and treats a pattern as a plain prefix. That is enough to make
+ * a guess look plausible and not enough to resolve anything correctly:
+ *
+ *   - a monorepo has one tsconfig PER PACKAGE, and `apps/web/tsconfig.json` is
+ *     what governs `apps/web/src/main.ts` — the root config governs nothing;
+ *   - `extends` is how essentially every real config is written, and the
+ *     `baseUrl` / `paths` almost always live in the extended base;
+ *   - `baseUrl` alone (no `paths`) is a complete resolution rule on its own, and
+ *     it is exactly the rule that makes `import 'src/utils/foo'` legal — the
+ *     case the old suffix matcher was really standing in for;
+ *   - `paths` maps a pattern to an ORDERED LIST of targets, tried in order.
+ *
+ * So this module answers the question TypeScript actually asks: for THIS file,
+ * what are `baseUrl` and `paths`?
+ */
+/** One `paths` entry, pattern and targets kept in declaration order. */
+export interface TsPathMapping {
+    /** The pattern as written, e.g. `@/*`, `@app/*`, `exact`. */
+    readonly pattern: string;
+    /** Targets as written, relative to `baseUrl`. Tried in order. */
+    readonly targets: readonly string[];
+}
+/** The resolution-relevant part of one resolved tsconfig. */
+export interface TsconfigScope {
+    /** Repo-relative directory the config governs (the tsconfig's own directory). */
+    readonly dir: string;
+    /**
+     * Repo-relative `baseUrl`, or `null` when the config declares none.
+     *
+     * `null` is not the same as `'.'`: without `baseUrl`, TypeScript does NOT
+     * resolve non-relative specifiers against the project at all (they are
+     * package lookups), and `paths` targets are resolved against the tsconfig's
+     * own directory instead.
+     */
+    readonly baseUrl: string | null;
+    readonly paths: readonly TsPathMapping[];
+}
+/** Every tsconfig in the repo, indexed so the nearest one to a file wins. */
+export interface TsconfigIndex {
+    /** Deepest-first, so the first `dir` that prefixes a file path governs it. */
+    readonly scopes: readonly TsconfigScope[];
+}
+/**
+ * The config governing `filePath` — the nearest tsconfig at or above it.
+ *
+ * TypeScript resolves a file against the project that includes it; the nearest
+ * enclosing tsconfig is the faithful approximation of that without evaluating
+ * `include`/`exclude` globs, and it is what makes a monorepo's per-package
+ * `baseUrl` apply to that package's files instead of the root's.
+ */
+export declare function tsconfigFor(index: TsconfigIndex | null, filePath: string): TsconfigScope | null;
+/** Load every tsconfig in the repo, resolving `extends` chains. */
+export declare function loadTsconfigIndex(repoRoot: string): Promise<TsconfigIndex | null>;

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

@@ -0,0 +1,292 @@
+/**
+ * Real `tsconfig.json` loading for module resolution (#2953).
+ *
+ * The previous loader (`language-config.ts:loadTsconfigPaths`) was built to feed
+ * a heuristic, and it shows: it reads three filenames at the repo ROOT only,
+ * gives up unless `compilerOptions.paths` exists, keeps only `targets[0]` of
+ * each mapping, and treats a pattern as a plain prefix. That is enough to make
+ * a guess look plausible and not enough to resolve anything correctly:
+ *
+ *   - a monorepo has one tsconfig PER PACKAGE, and `apps/web/tsconfig.json` is
+ *     what governs `apps/web/src/main.ts` — the root config governs nothing;
+ *   - `extends` is how essentially every real config is written, and the
+ *     `baseUrl` / `paths` almost always live in the extended base;
+ *   - `baseUrl` alone (no `paths`) is a complete resolution rule on its own, and
+ *     it is exactly the rule that makes `import 'src/utils/foo'` legal — the
+ *     case the old suffix matcher was really standing in for;
+ *   - `paths` maps a pattern to an ORDERED LIST of targets, tried in order.
+ *
+ * So this module answers the question TypeScript actually asks: for THIS file,
+ * what are `baseUrl` and `paths`?
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { isHardcodedIgnoredDirectoryAtPath } from '../../../../config/ignore-service.js';
+import { logger } from '../../../logger.js';
+const SCAN_MAX_DIRS = 20_000;
+const SCAN_MAX_DEPTH = 24;
+/** Guard against an `extends` cycle or a pathological chain. */
+const MAX_EXTENDS_DEPTH = 16;
+/**
+ * The config governing `filePath` — the nearest tsconfig at or above it.
+ *
+ * TypeScript resolves a file against the project that includes it; the nearest
+ * enclosing tsconfig is the faithful approximation of that without evaluating
+ * `include`/`exclude` globs, and it is what makes a monorepo's per-package
+ * `baseUrl` apply to that package's files instead of the root's.
+ */
+export function tsconfigFor(index, filePath) {
+    if (index === null)
+        return null;
+    for (const scope of index.scopes) {
+        if (scope.dir === '')
+            return scope;
+        if (filePath.startsWith(`${scope.dir}/`))
+            return scope;
+    }
+    return null;
+}
+/** Load every tsconfig in the repo, resolving `extends` chains. */
+export async function loadTsconfigIndex(repoRoot) {
+    const files = await findTsconfigFiles(repoRoot);
+    if (files.length === 0)
+        return null;
+    const ranked = [];
+    for (const absPath of files) {
+        const options = await readCompilerOptions(absPath, 0);
+        if (options === null)
+            continue;
+        // `readCompilerOptions` resolves both to ABSOLUTE paths against whichever
+        // config in the `extends` chain declared them, which is the only way the
+        // chain stays unambiguous. Rebasing to repo-relative happens once, here.
+        const baseUrl = options.baseUrl === undefined ? null : repoRelative(repoRoot, options.baseUrl);
+        const paths = (options.paths ?? []).map((mapping) => ({
+            pattern: mapping.pattern,
+            targets: mapping.targets.map((t) => rebaseTarget(repoRoot, t)),
+        }));
+        // A config declaring NEITHER is kept, not skipped. Dropping it let
+        // `tsconfigFor` fall through to an enclosing config, so a package whose own
+        // tsconfig declares no `baseUrl` — meaning its non-relative specifiers are
+        // package lookups — silently inherited the repo root's aliases instead.
+        // An empty scope is the accurate answer for such a file, and only a scope
+        // can express it.
+        ranked.push({
+            scope: { dir: repoRelative(repoRoot, path.dirname(absPath)), baseUrl, paths },
+            rank: configRank(path.basename(absPath)),
+        });
+    }
+    if (ranked.length === 0)
+        return null;
+    // Deepest first, because `tsconfigFor` takes the first match and it must be
+    // the most specific config rather than whichever the walk reached first.
+    //
+    // Then by filename rank WITHIN a directory, which is the half that is easy to
+    // miss: `tsconfig.json` and `tsconfig.base.json` routinely sit side by side,
+    // and the base exists to be extended, not to govern. Reading whichever the
+    // directory listing returned first made a config's own `paths` invisible
+    // whenever its base happened to be listed earlier.
+    ranked.sort((a, b) => b.scope.dir.length - a.scope.dir.length || a.rank - b.rank);
+    return { scopes: ranked.map((entry) => entry.scope) };
+}
+/**
+ * Precedence among configs sharing a directory: the project config governs, and
+ * everything else is a base or a variant that exists to be extended.
+ */
+function configRank(fileName) {
+    if (fileName === 'tsconfig.json')
+        return 0;
+    if (fileName === 'jsconfig.json')
+        return 1;
+    return 2;
+}
+/**
+ * Read one tsconfig and merge in whatever it `extends`.
+ *
+ * Rebasing happens per FILE, before merging, because `extends` does not rebase
+ * `baseUrl`: a base config at `configs/tsconfig.base.json` declaring
+ * `"baseUrl": "."` means `configs/`, even when extended from `apps/web`. Doing
+ * the rebase at read time is what keeps that true through the chain.
+ */
+async function readCompilerOptions(absPath, depth, repoRootHint) {
+    if (depth > MAX_EXTENDS_DEPTH) {
+        logger.warn(`[typescript] tsconfig extends chain too deep at ${absPath}; ignoring the rest`);
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = parseJsonc(await fs.readFile(absPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    const dir = path.dirname(absPath);
+    // Read what this config extends FIRST: `paths` targets resolve against the
+    // EFFECTIVE `baseUrl`, which a config declaring `paths` alone inherits from
+    // its base. Resolving them against this config's own directory instead would
+    // load the right alias pattern and point every target at the wrong place.
+    const inherited = await readExtended(parsed.extends, dir, depth, repoRootHint);
+    const own = {};
+    const compilerOptions = parsed.compilerOptions;
+    if (compilerOptions !== null && typeof compilerOptions === 'object') {
+        const opts = compilerOptions;
+        if (typeof opts.baseUrl === 'string') {
+            own.baseUrl = path.resolve(dir, opts.baseUrl);
+        }
+        if (opts.paths !== null && typeof opts.paths === 'object' && !Array.isArray(opts.paths)) {
+            // tsc resolves `paths` targets against the effective `baseUrl` — this
+            // config's own if it declares one, otherwise the inherited one — and
+            // against the config's own directory only when neither exists. Doing it
+            // here, per file, is what keeps an `extends` chain unambiguous: by the
+            // time these merge, every target is already absolute.
+            const pathsBase = own.baseUrl ?? inherited?.baseUrl ?? dir;
+            own.paths = [];
+            for (const [pattern, targets] of Object.entries(opts.paths)) {
+                if (!Array.isArray(targets))
+                    continue;
+                const asStrings = targets
+                    .filter((t) => typeof t === 'string')
+                    .map((t) => path.resolve(pathsBase, t));
+                if (asStrings.length > 0)
+                    own.paths.push({ pattern, targets: asStrings });
+            }
+        }
+    }
+    // Own options win over inherited ones — that is what `extends` means. `paths`
+    // is replaced wholesale rather than merged, matching tsc.
+    return {
+        ...(inherited ?? {}),
+        ...own,
+    };
+}
+/** Follow `extends`, which may be a string or (TS 5+) an array, base-first. */
+async function readExtended(value, fromDir, depth, repoRootHint) {
+    const specs = typeof value === 'string' ? [value] : Array.isArray(value) ? value : [];
+    let merged = null;
+    for (const spec of specs) {
+        if (typeof spec !== 'string')
+            continue;
+        const resolved = await resolveExtendsTarget(spec, fromDir);
+        if (resolved === null)
+            continue;
+        const options = await readCompilerOptions(resolved, depth + 1, repoRootHint);
+        if (options === null)
+            continue;
+        // Later entries win over earlier ones, per tsc's array semantics.
+        merged = { ...(merged ?? {}), ...options };
+    }
+    return merged;
+}
+/**
+ * An `extends` value is either a path or a package name.
+ *
+ * The package form (`"extends": "@tsconfig/node20/tsconfig.json"`,
+ * `"@acme/tsconfig"`) lives in `node_modules`, which this tool deliberately
+ * does NOT index — it is dependency code, not the repository's own. But not
+ * indexing it is different from not READING it, and the distinction matters
+ * here: a shared internal base config is exactly where a monorepo puts the
+ * `paths` its packages import through, so refusing to open it loses aliases
+ * that the repository genuinely declares.
+ *
+ * So the file is read from disk when it is there, walking `node_modules` up
+ * from the extending config the way Node does. When it is absent — an
+ * un-installed checkout, which is a shape a static analyser must expect and a
+ * compiler may refuse — the answer is `null`, and the caller keeps whatever the
+ * extending config declared itself. That degrades to fewer resolutions, never
+ * to invented ones.
+ */
+async function resolveExtendsTarget(spec, fromDir) {
+    if (spec.startsWith('.') || path.isAbsolute(spec)) {
+        return firstReadableConfig(path.resolve(fromDir, spec));
+    }
+    for (const modulesDir of nodeModulesChain(fromDir)) {
+        const found = await firstReadableConfig(path.join(modulesDir, spec));
+        if (found !== null)
+            return found;
+    }
+    return null;
+}
+/** `<dir>/node_modules`, then each ancestor's, the way Node resolves. */
+function* nodeModulesChain(fromDir) {
+    let dir = fromDir;
+    for (;;) {
+        if (path.basename(dir) !== 'node_modules')
+            yield path.join(dir, 'node_modules');
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return;
+        dir = parent;
+    }
+}
+/** The first spelling of `base` that is a readable file. */
+async function firstReadableConfig(base) {
+    for (const candidate of [base, `${base}.json`, path.join(base, 'tsconfig.json')]) {
+        try {
+            const stat = await fs.stat(candidate);
+            if (stat.isFile())
+                return candidate;
+        }
+        catch {
+            // try the next spelling
+        }
+    }
+    return null;
+}
+async function findTsconfigFiles(repoRoot) {
+    const found = [];
+    const queue = [{ dir: repoRoot, depth: 0 }];
+    let dirsScanned = 0;
+    while (queue.length > 0 && dirsScanned < SCAN_MAX_DIRS) {
+        const { dir, depth } = queue.shift();
+        dirsScanned++;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const childDir = path.join(dir, entry.name);
+                if (isHardcodedIgnoredDirectoryAtPath(repoRoot, childDir))
+                    continue;
+                if (depth < SCAN_MAX_DEPTH)
+                    queue.push({ dir: childDir, depth: depth + 1 });
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            // `tsconfig.json`, `tsconfig.app.json`, `jsconfig.json`, … — any of them
+            // can carry the `baseUrl`/`paths` that governs its directory.
+            if (/^(ts|js)config(\..+)?\.json$/.test(entry.name)) {
+                found.push(path.join(dir, entry.name));
+            }
+        }
+    }
+    return found;
+}
+/** Strip comments and trailing commas — tsconfig is JSONC, not JSON. */
+function parseJsonc(raw) {
+    const withoutComments = raw
+        .replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*$)|(\/\*[\s\S]*?\*\/)/gm, (match, line, block) => line !== undefined || block !== undefined ? '' : match)
+        .replace(/,(\s*[}\]])/g, '$1');
+    return JSON.parse(withoutComments);
+}
+function repoRelative(repoRoot, absDir) {
+    const rel = path.relative(repoRoot, absDir).split(path.sep).join('/');
+    return rel === '.' || rel === '' ? '' : rel;
+}
+/**
+ * A `paths` target rebased to repo-relative, keeping any trailing `*`.
+ *
+ * `path.resolve` swallows the wildcard into a path segment, so it is stripped
+ * before resolving and re-appended after — the `*` is a substitution marker,
+ * not a directory named `*`.
+ */
+function rebaseTarget(repoRoot, absTarget) {
+    // `/repo/src/*` must come back as `src/*`, not `src*`: stripping only the
+    // star leaves a trailing slash that `path.relative` then eats.
+    const suffix = absTarget.endsWith('/*') ? '/*' : absTarget.endsWith('*') ? '*' : '';
+    const base = suffix === '' ? absTarget : absTarget.slice(0, -suffix.length);
+    return `${repoRelative(repoRoot, base)}${suffix}`;
+}