carrick 0.3.116 → 0.3.118

package/sidecar/dist/src/capture/project-references.js

@@ -10,12 +10,15 @@
  *
  * TypeScript's editor answers "which project types this file" by searching
  * the named config, then its references depth-first in declared order, for
- * the first project whose file list includes the file. That project is the
- * file's owner here too, and a file is only ever typed under its owner's
- * options: the loader builds one program per owner it is asked about, and
- * the capture types each anchor in its owner's program. A file no reachable
- * project includes is owned by the named config, which is how it was typed
- * before references were read.
+ * the first project that lists the file and is not a project one of whose
+ * own references lists it too (tsserver's default-project rule, carrick#2418:
+ * a file a referenced project lists is that project's source, so a solution
+ * config whose default include lists every file owns none of them). That
+ * project is the file's owner here too, and a file is only ever typed under
+ * its owner's options: the loader builds one program per owner it is asked
+ * about, and the capture types each anchor in its owner's program. A file no
+ * reachable project owns is owned by the named config, which is how it was
+ * typed before references were read.
  */
 import * as path from 'node:path';
 import ts from 'typescript';
@@ -36,9 +39,8 @@ function parseConfig(configPath, extendedConfigCache) {
 const fileKey = (file) => path.resolve(file);
 /**
  * The projects a named config reaches and the owner of each file among them.
- * References are read only when a file the named config does not include is
- * asked about, so a service whose files the named config includes costs one
- * parse, as before.
+ * References are read on the first question about a file, and never for a
+ * named config that references nothing, which costs one parse, as before.
  */
 export class ProjectGraph {
     named;
@@ -47,6 +49,7 @@ export class ProjectGraph {
     extendedConfigCache = new Map();
     walked;
     namedFiles;
+    closures = new Map();
     /** Throws when the named config cannot be read, as a bare parse would. */
     constructor(configPath) {
         this.named = parseConfig(configPath, this.extendedConfigCache);
@@ -57,16 +60,50 @@ export class ProjectGraph {
         return (this.named.parsed.projectReferences?.length ?? 0) > 0;
     }
     /**
-     * The project that owns `file`: the first in search order whose file list
-     * includes it (the named config, then its references depth-first in
-     * declared order; a config reached twice is visited once). The named config
-     * when none does.
+     * The project that owns `file`: the first in search order (the named
+     * config, then its references depth-first in declared order; a config
+     * reached twice is visited once) that lists it while no project in its own
+     * reference closure lists it. The named config when none does.
      */
     ownerOf(file) {
-        const key = fileKey(file);
-        if (this.namedFiles.has(key) || !this.hasReferences)
+        if (!this.hasReferences)
             return this.named;
-        return this.projects().find((entry) => entry.files.has(key))?.project ?? this.named;
+        const key = fileKey(file);
+        const owner = this.projects().find((entry) => entry.files.has(key) && !this.closure(entry.project).some((reached) => reached.files.has(key)));
+        return owner?.project ?? this.named;
+    }
+    /**
+     * Every project `project` reaches through its references, transitively,
+     * depth-first in declared order, without itself. Only projects this graph
+     * reached from the named config are known, which is every one a project
+     * the graph holds can reach.
+     */
+    closureOf(project) {
+        return this.hasReferences ? this.closure(project).map((reached) => reached.project) : [];
+    }
+    closure(project) {
+        let found = this.closures.get(project);
+        if (found)
+            return found;
+        const byPath = new Map(this.projects().map((entry) => [entry.project.configPath, entry]));
+        const seen = new Set([project.configPath]);
+        found = [];
+        const visit = (from) => {
+            for (const reference of from.parsed.projectReferences ?? []) {
+                const referencePath = path.resolve(ts.resolveProjectReferencePath(reference));
+                if (seen.has(referencePath))
+                    continue;
+                seen.add(referencePath);
+                const entry = byPath.get(referencePath);
+                if (!entry)
+                    continue;
+                found.push(entry);
+                visit(entry.project);
+            }
+        };
+        visit(project);
+        this.closures.set(project, found);
+        return found;
     }
     /** Position in search order, 0 for the named config. */
     rank(project) {

package/sidecar/dist/src/capture/reference-redirect.d.ts

@@ -0,0 +1,84 @@
+/**
+ * How a program built from one owner config reads the projects that config
+ * references (carrick#2418): as an editor reads them.
+ *
+ * A workspace package a service references is usually not built on a scanned
+ * checkout: its `package.json` points `types` at `dist/index.d.ts`, which
+ * does not exist, so the import read as the error type. The compiler's editor
+ * mode (`projectReferences` with `useSourceOfProjectReferenceRedirect`) reads
+ * the package's source instead, under the package's own options. The
+ * sidecar's programs cannot be handed references (ts-morph never passes them,
+ * and the capture's emit would then skip the sources), so this module does
+ * what the compiler's `updateHostForUseSourceOfProjectReferenceRedirect` does,
+ * in the resolver:
+ *
+ *  1. Every project in the owner's reference closure is parsed through the
+ *     read bound (`ProjectGraph`), its options through
+ *     `sidecarCompilerOptions`.
+ *  2. Each of its inputs maps to its declaration output, by the compiler's
+ *     own `getOutputFileNames` with declarations on (a project with `outFile`
+ *     has no per-file map and is skipped). A project that leaves `rootDir`
+ *     unset is laid out as TypeScript 5 lays it out: under the config's
+ *     directory when `composite`, else under the common directory of its
+ *     inputs. TypeScript 6 puts every such project under the config's
+ *     directory (`src/index.ts` to `dist/src/index.d.ts`), where a package
+ *     written against 5 points its `types` at `dist/index.d.ts`.
+ *  3. The resolver's host answers that an output exists while its source
+ *     does, and that the directories outputs sit in exist. An output is
+ *     looked up by the real path of its deepest existing ancestor: a package
+ *     reached through a `node_modules` link has no `dist/`, so the real path
+ *     of the output itself is the link path and would miss the map.
+ *  4. An import made from a referenced project's own file resolves under that
+ *     project's options (`redirectedReference`), and an answer that lands on
+ *     an output becomes its source. A source inside the checkout and under no
+ *     `node_modules` is not an external-library import, so the origin gates
+ *     read it as the user's code.
+ *
+ * A package the owner does not reference stays unresolved, as in the editor.
+ * Nothing here writes, and every read goes through the host it wraps.
+ */
+import ts from 'typescript';
+import { type ServiceProject } from './project-references.js';
+/** The part of a resolved module this module reads and rewrites. */
+interface ResolvedModuleLike {
+    resolvedFileName: string;
+    extension?: string;
+    isExternalLibraryImport?: boolean;
+    resolvedUsingTsExtension?: boolean;
+}
+/** The part of a module resolution host this module wraps. */
+interface ResolutionHostLike {
+    fileExists(fileName: string): boolean;
+    directoryExists?(directoryName: string): boolean;
+}
+export interface ReferenceRedirect {
+    /**
+     * The referenced project that lists `containingFile`, for
+     * `ts.resolveModuleName`'s `redirectedReference`; `undefined` for a file
+     * of the owner itself.
+     */
+    referenceFor(containingFile: string): ts.ResolvedProjectReference | undefined;
+    /** `host` answering for the outputs of referenced projects (step 3). */
+    resolutionHost<H extends ResolutionHostLike>(host: H): H;
+    /** `answer`, or the source behind it when it is a referenced output (step 4). */
+    sourceAnswer<R extends ResolvedModuleLike | undefined>(answer: R): R;
+}
+/**
+ * The redirect for a program whose owner reaches `references` (its reference
+ * closure, from `ProjectGraph.closureOf`), or `undefined` when there are none.
+ */
+export declare function referenceRedirect(references: readonly ServiceProject[], repoRoot: string): ReferenceRedirect | undefined;
+/**
+ * For the loader, which builds a program from one config path: the redirect
+ * for that config's reference closure. A config that references nothing is
+ * not parsed (`references` is never inherited through `extends`).
+ */
+export declare function referenceRedirectOf(configPath: string, repoRoot: string): ReferenceRedirect | undefined;
+/**
+ * For the capture's anchor program: `host` resolving every import through
+ * `redirect`, with the module resolution cache it uses handed to the program.
+ * A host with its own resolver and no cache makes declaration emit name a
+ * transitive package through another (TS2742).
+ */
+export declare function redirectingCompilerHost(host: ts.CompilerHost, options: ts.CompilerOptions, redirect: ReferenceRedirect): ts.CompilerHost;
+export {};

package/sidecar/dist/src/capture/reference-redirect.js

@@ -0,0 +1,209 @@
+/**
+ * How a program built from one owner config reads the projects that config
+ * references (carrick#2418): as an editor reads them.
+ *
+ * A workspace package a service references is usually not built on a scanned
+ * checkout: its `package.json` points `types` at `dist/index.d.ts`, which
+ * does not exist, so the import read as the error type. The compiler's editor
+ * mode (`projectReferences` with `useSourceOfProjectReferenceRedirect`) reads
+ * the package's source instead, under the package's own options. The
+ * sidecar's programs cannot be handed references (ts-morph never passes them,
+ * and the capture's emit would then skip the sources), so this module does
+ * what the compiler's `updateHostForUseSourceOfProjectReferenceRedirect` does,
+ * in the resolver:
+ *
+ *  1. Every project in the owner's reference closure is parsed through the
+ *     read bound (`ProjectGraph`), its options through
+ *     `sidecarCompilerOptions`.
+ *  2. Each of its inputs maps to its declaration output, by the compiler's
+ *     own `getOutputFileNames` with declarations on (a project with `outFile`
+ *     has no per-file map and is skipped). A project that leaves `rootDir`
+ *     unset is laid out as TypeScript 5 lays it out: under the config's
+ *     directory when `composite`, else under the common directory of its
+ *     inputs. TypeScript 6 puts every such project under the config's
+ *     directory (`src/index.ts` to `dist/src/index.d.ts`), where a package
+ *     written against 5 points its `types` at `dist/index.d.ts`.
+ *  3. The resolver's host answers that an output exists while its source
+ *     does, and that the directories outputs sit in exist. An output is
+ *     looked up by the real path of its deepest existing ancestor: a package
+ *     reached through a `node_modules` link has no `dist/`, so the real path
+ *     of the output itself is the link path and would miss the map.
+ *  4. An import made from a referenced project's own file resolves under that
+ *     project's options (`redirectedReference`), and an answer that lands on
+ *     an output becomes its source. A source inside the checkout and under no
+ *     `node_modules` is not an external-library import, so the origin gates
+ *     read it as the user's code.
+ *
+ * A package the owner does not reference stays unresolved, as in the editor.
+ * Nothing here writes, and every read goes through the host it wraps.
+ */
+import * as path from 'node:path';
+import ts from 'typescript';
+import { boundedSys, isInsideCheckout, realOf, untrustedReadBound } from './checkout.js';
+import { sidecarCompilerOptions } from './compiler-options.js';
+import { ProjectGraph } from './project-references.js';
+const DECLARATION = /\.d\.[cm]?ts$/;
+/** `realOf`, cached per directory: the resolver asks about many files in few directories. */
+function realPaths() {
+    const dirs = new Map();
+    return (p) => {
+        const abs = path.resolve(p);
+        const dir = path.dirname(abs);
+        let real = dirs.get(dir);
+        if (real === undefined) {
+            real = realOf(dir);
+            dirs.set(dir, real);
+        }
+        return path.join(real, path.basename(abs));
+    };
+}
+/** The directory every input sits under, as TypeScript computes it. */
+function commonDirectory(files, ignoreCase) {
+    let common;
+    const key = (part) => (ignoreCase ? part.toLowerCase() : part);
+    for (const file of files) {
+        const parts = path.dirname(path.resolve(file)).split(path.sep);
+        if (!common) {
+            common = parts;
+            continue;
+        }
+        let n = 0;
+        while (n < common.length && n < parts.length && key(common[n]) === key(parts[n]))
+            n += 1;
+        common = common.slice(0, n);
+    }
+    return common && common.length > 0 ? common.join(path.sep) || path.sep : undefined;
+}
+/**
+ * `parsed` with declarations on and, when it leaves `rootDir` unset,
+ * TypeScript 5's root (see the header, step 2).
+ */
+function declarationLayout(parsed, ignoreCase) {
+    const options = { ...parsed.options, declaration: true, emitDeclarationOnly: true };
+    if (!options.rootDir) {
+        const rootDir = options.composite
+            ? path.dirname(path.resolve(String(options.configFilePath)))
+            : commonDirectory(parsed.fileNames.filter((file) => !DECLARATION.test(file) && !file.endsWith('.json')), ignoreCase);
+        if (rootDir)
+            options.rootDir = rootDir;
+    }
+    return { ...parsed, options };
+}
+/**
+ * The redirect for a program whose owner reaches `references` (its reference
+ * closure, from `ProjectGraph.closureOf`), or `undefined` when there are none.
+ */
+export function referenceRedirect(references, repoRoot) {
+    if (references.length === 0)
+        return undefined;
+    const realOf = realPaths();
+    const ignoreCase = !ts.sys.useCaseSensitiveFileNames;
+    /** Real path of an output -> its source. */
+    const outputs = new Map();
+    /** Real paths of the directories outputs sit in, up to their project's. */
+    const outputDirs = new Set();
+    /** Base names of outputs and of their directories: the cheap test first. */
+    const names = new Set();
+    const byFile = new Map();
+    for (const project of references) {
+        const configFile = project.parsed.options.configFile;
+        if (!configFile)
+            continue;
+        // Its own imports resolve under its options with TypeScript 5's defaults.
+        const commandLine = { ...project.parsed, options: sidecarCompilerOptions(project.parsed.options) };
+        const reference = { commandLine, sourceFile: configFile };
+        const projectDir = realOf(path.dirname(project.configPath));
+        const layout = project.parsed.options.outFile ? undefined : declarationLayout(project.parsed, ignoreCase);
+        for (const file of project.parsed.fileNames) {
+            const key = path.resolve(file);
+            if (!byFile.has(key))
+                byFile.set(key, reference);
+            if (!layout || file.endsWith('.json') || DECLARATION.test(file))
+                continue;
+            const declaration = ts.getOutputFileNames(layout, file, ignoreCase).find((out) => DECLARATION.test(out));
+            if (!declaration)
+                continue;
+            const output = realOf(declaration);
+            if (outputs.has(output))
+                continue;
+            outputs.set(output, key);
+            names.add(path.basename(output));
+            for (let dir = path.dirname(output); !outputDirs.has(dir); dir = path.dirname(dir)) {
+                outputDirs.add(dir);
+                names.add(path.basename(dir));
+                if (dir === projectDir || path.dirname(dir) === dir)
+                    break;
+            }
+        }
+    }
+    const sourceOf = (file) => DECLARATION.test(file) && names.has(path.basename(file)) ? outputs.get(realOf(file)) : undefined;
+    const isOutputDir = (dir) => names.has(path.basename(dir)) && outputDirs.has(realOf(dir));
+    return {
+        referenceFor: (containingFile) => byFile.get(path.resolve(containingFile)),
+        resolutionHost: (host) => {
+            const wrapped = Object.create(host);
+            wrapped.fileExists = (file) => {
+                if (host.fileExists(file))
+                    return true;
+                const source = sourceOf(file);
+                return source !== undefined && host.fileExists(source);
+            };
+            if (host.directoryExists) {
+                const directoryExists = host.directoryExists.bind(host);
+                wrapped.directoryExists = (dir) => directoryExists(dir) || isOutputDir(dir);
+            }
+            return wrapped;
+        },
+        sourceAnswer: (answer) => {
+            if (!answer)
+                return answer;
+            const source = sourceOf(answer.resolvedFileName);
+            if (!source)
+                return answer;
+            const own = isInsideCheckout(source.replace(/\\/g, '/'), repoRoot) &&
+                !source.includes(`${path.sep}node_modules${path.sep}`);
+            return {
+                ...answer,
+                resolvedFileName: source,
+                extension: path.extname(source),
+                resolvedUsingTsExtension: false,
+                isExternalLibraryImport: own ? false : answer.isExternalLibraryImport,
+            };
+        },
+    };
+}
+/**
+ * For the loader, which builds a program from one config path: the redirect
+ * for that config's reference closure. A config that references nothing is
+ * not parsed (`references` is never inherited through `extends`).
+ */
+export function referenceRedirectOf(configPath, repoRoot) {
+    const sys = boundedSys(untrustedReadBound(path.dirname(configPath)));
+    const raw = ts.readConfigFile(configPath, (file) => sys.readFile(file)).config;
+    if (!Array.isArray(raw?.references) || raw.references.length === 0)
+        return undefined;
+    let graph;
+    try {
+        graph = new ProjectGraph(configPath);
+    }
+    catch {
+        return undefined;
+    }
+    return referenceRedirect(graph.closureOf(graph.named), repoRoot);
+}
+/**
+ * For the capture's anchor program: `host` resolving every import through
+ * `redirect`, with the module resolution cache it uses handed to the program.
+ * A host with its own resolver and no cache makes declaration emit name a
+ * transitive package through another (TS2742).
+ */
+export function redirectingCompilerHost(host, options, redirect) {
+    const resolutionHost = redirect.resolutionHost(host);
+    const cache = ts.createModuleResolutionCache(host.getCurrentDirectory(), (fileName) => host.getCanonicalFileName(fileName), options);
+    host.getModuleResolutionCache = () => cache;
+    host.resolveModuleNameLiterals = (literals, containingFile, redirectedReference, compilerOptions, containingSourceFile) => literals.map((literal) => {
+        const answer = ts.resolveModuleName(literal.text, containingFile, compilerOptions, resolutionHost, cache, redirectedReference ?? redirect.referenceFor(containingFile), ts.getModeForUsageLocation(containingSourceFile, literal, compilerOptions));
+        return { ...answer, resolvedModule: redirect.sourceAnswer(answer.resolvedModule) };
+    });
+    return host;
+}

package/sidecar/dist/src/capture/unresolved.d.ts

@@ -17,6 +17,14 @@
  */
 import ts from 'typescript';
 import { type UnresolvedAtAnchor } from './deep-walk.js';
+/**
+ * Name the files of `program` the surface emit cannot carry (carrick#2418):
+ * the sources of the projects its owner references, which the anchor program
+ * reads and the emit reaches only as unbuilt output. A position typed from
+ * one of them counts as unresolved, so a top type the emit leaves there is
+ * labelled with its cause and never as declared.
+ */
+export declare function markUncarried(program: ts.Program, uncarried: (fileName: string) => boolean): void;
 /**
  * The unresolved placeholders inside `type` (read at `location` in `sourceFile`),
  * or `undefined` when it has none — the common case, which costs one walk.

package/sidecar/dist/src/capture/unresolved.js

@@ -16,11 +16,23 @@
  * self-check labels the matching findings. Seam: node builtins + `typescript`.
  */
 import ts from 'typescript';
-import { findUnresolvedPlaceholders } from './deep-walk.js';
+import { findUncarriedPositions, findUnresolvedPlaceholders } from './deep-walk.js';
 /** Files the specifier walk visits from one anchor before it stops. */
 const MAX_REACHABLE_FILES = 256;
 /** Per-program memo: source file name -> unresolved specifiers it reaches. */
 const reachableCache = new WeakMap();
+/** Per anchor program: the files it reads that the surface emit cannot carry. */
+const uncarriedByProgram = new WeakMap();
+/**
+ * Name the files of `program` the surface emit cannot carry (carrick#2418):
+ * the sources of the projects its owner references, which the anchor program
+ * reads and the emit reaches only as unbuilt output. A position typed from
+ * one of them counts as unresolved, so a top type the emit leaves there is
+ * labelled with its cause and never as declared.
+ */
+export function markUncarried(program, uncarried) {
+    uncarriedByProgram.set(program, uncarried);
+}
 /**
  * The unresolved placeholders inside `type` (read at `location` in `sourceFile`),
  * or `undefined` when it has none — the common case, which costs one walk.
@@ -31,7 +43,11 @@ const reachableCache = new WeakMap();
  */
 export function unresolvedAtAnchor(program, sourceFile, type, location, pathPrefix = '') {
     const checker = program.getTypeChecker();
-    const paths = findUnresolvedPlaceholders(type, program, checker, location).map((path) => prefixPath(pathPrefix, path));
+    const uncarried = uncarriedByProgram.get(program);
+    const found = findUnresolvedPlaceholders(type, program, checker, location);
+    if (uncarried)
+        found.push(...findUncarriedPositions(type, program, checker, location, uncarried));
+    const paths = [...new Set(found)].map((path) => prefixPath(pathPrefix, path));
     if (paths.length === 0)
         return undefined;
     return { paths, specifiers: unresolvedSpecifiersReachableFrom(program, sourceFile) };

package/sidecar/dist/src/declaration-attribution.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Which declaration a symbol is attributed to, and which installed package a
+ * declaring file belongs to. Shared by the inferrer's `declaring_package`
+ * answer and the per-position rows (carrick#2405), so the two can never name
+ * different declarations or packages for one symbol.
+ */
+import type { ts } from 'ts-morph';
+/**
+ * The declaration a symbol is attributed to (carrick#2031). One declaration
+ * is itself. Where several files merge one symbol (a global interface the
+ * compiler's library declares and a typings package augments), their order
+ * is the order the checker merged them in, and on TypeScript 6 that changes
+ * once the program is rebuilt, so the first one is not an answer. The
+ * compiler's default library wins where it declares the symbol; otherwise,
+ * and among the library's own files, the declaring file whose path sorts
+ * first, then the earliest declaration in it.
+ *
+ * `programOf` is called only when there are several: asking a ts-morph
+ * project for its program rebuilds one that has changed since, and a symbol
+ * with one declaration needs none.
+ */
+export declare function attributedDeclaration<T extends ts.Node>(programOf: () => ts.Program, declarations: readonly T[]): T | undefined;
+/**
+ * The npm package a declaring file belongs to, by the module graph where
+ * there is one and by its path otherwise. `undefined` when neither names one.
+ *
+ * The module graph is asked first, where there is one, because it is the
+ * only thing that can answer for a project whose resolution does not go
+ * through `node_modules`. Deno resolves an npm dependency's types straight
+ * out of its own cache (`$DENO_DIR/npm/<registry-host>/<name>/<version>/…`),
+ * a path with no `node_modules` segment anywhere in it (carrick#1260). It
+ * runs first rather than second because a mixed checkout has both, and the
+ * graph is what actually resolved the module.
+ *
+ * The path rule is the Node answer: the LAST `node_modules` segment wins,
+ * which is what a nested or content-addressed store
+ * (`node_modules/.store/pkg@1.0.0/node_modules/pkg`) requires. Scoped names
+ * keep both segments; a scope with no name after it names nothing.
+ */
+export declare function installedPackageOf(filePath: string, packageOf?: (filePath: string) => string | undefined): string | undefined;

package/sidecar/dist/src/declaration-attribution.js

@@ -0,0 +1,66 @@
+/**
+ * Which declaration a symbol is attributed to, and which installed package a
+ * declaring file belongs to. Shared by the inferrer's `declaring_package`
+ * answer and the per-position rows (carrick#2405), so the two can never name
+ * different declarations or packages for one symbol.
+ */
+import { packageNameOf } from './capture/index.js';
+/**
+ * The declaration a symbol is attributed to (carrick#2031). One declaration
+ * is itself. Where several files merge one symbol (a global interface the
+ * compiler's library declares and a typings package augments), their order
+ * is the order the checker merged them in, and on TypeScript 6 that changes
+ * once the program is rebuilt, so the first one is not an answer. The
+ * compiler's default library wins where it declares the symbol; otherwise,
+ * and among the library's own files, the declaring file whose path sorts
+ * first, then the earliest declaration in it.
+ *
+ * `programOf` is called only when there are several: asking a ts-morph
+ * project for its program rebuilds one that has changed since, and a symbol
+ * with one declaration needs none.
+ */
+export function attributedDeclaration(programOf, declarations) {
+    if (declarations.length <= 1)
+        return declarations[0];
+    const program = programOf();
+    const fromLibrary = declarations.filter((declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
+    const candidates = fromLibrary.length > 0 ? fromLibrary : declarations;
+    return [...candidates].sort((a, b) => {
+        const pathA = a.getSourceFile().fileName;
+        const pathB = b.getSourceFile().fileName;
+        return pathA < pathB ? -1 : pathA > pathB ? 1 : a.getStart() - b.getStart();
+    })[0];
+}
+/**
+ * The npm package a declaring file belongs to, by the module graph where
+ * there is one and by its path otherwise. `undefined` when neither names one.
+ *
+ * The module graph is asked first, where there is one, because it is the
+ * only thing that can answer for a project whose resolution does not go
+ * through `node_modules`. Deno resolves an npm dependency's types straight
+ * out of its own cache (`$DENO_DIR/npm/<registry-host>/<name>/<version>/…`),
+ * a path with no `node_modules` segment anywhere in it (carrick#1260). It
+ * runs first rather than second because a mixed checkout has both, and the
+ * graph is what actually resolved the module.
+ *
+ * The path rule is the Node answer: the LAST `node_modules` segment wins,
+ * which is what a nested or content-addressed store
+ * (`node_modules/.store/pkg@1.0.0/node_modules/pkg`) requires. Scoped names
+ * keep both segments; a scope with no name after it names nothing.
+ */
+export function installedPackageOf(filePath, packageOf) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const named = packageOf?.(normalized);
+    if (named)
+        return named;
+    const marker = '/node_modules/';
+    const index = normalized.lastIndexOf(marker);
+    if (index < 0)
+        return undefined;
+    const rest = normalized.slice(index + marker.length);
+    if (rest.length === 0 || rest.startsWith('/'))
+        return undefined;
+    if (rest.startsWith('@') && !rest.includes('/'))
+        return undefined;
+    return packageNameOf(rest);
+}

package/sidecar/dist/src/index.js

@@ -29,6 +29,7 @@ import { LibraryClaimsVerifier, httpCheck } from './library-claims.js';
 import { PROGRESS_INTERVAL_MS, atMostEvery } from './progress.js';
 import { mergeInferTimings } from './infer-timing.js';
 import { addProgramFiles, listProgramFiles } from './program-files.js';
+import { writePositionRows } from './position-rows.js';
 // ===========================================================================
 // Module-level state
 // ===========================================================================
@@ -555,6 +556,40 @@ function handleAddProgramFiles(request) {
         return { request_id: request.request_id, status: 'error', errors: [error] };
     }
 }
+/**
+ * Handle the 'position_rows' action - write the compiler's rows for each
+ * call, member access, comparison and identifier of the given files
+ * (carrick#2405). Asked of a process of its own: it releases each owner's
+ * program once its files are walked, so nothing built before it is kept.
+ */
+function handlePositionRows(request) {
+    try {
+        const loader = initializedLoader();
+        // Built over programs the walk releases; nothing may read them after it.
+        components = new Map();
+        let done = 0;
+        const report = atMostEvery(PROGRESS_INTERVAL_MS, () => writeProgress(request.request_id, 'positions', `${done} of ${request.files.length}`));
+        const result = writePositionRows({
+            loader,
+            files: request.files,
+            scanRoot: request.scan_root,
+            outPath: request.out_path,
+            service: request.service,
+            onFile: () => {
+                done += 1;
+                report();
+            },
+        });
+        log(`Position rows: ${result.rows} row(s) over ${result.files} file(s), ` +
+            `${result.bytes} byte(s), load ${result.load_ms}ms, walk ${result.walk_ms}ms`);
+        return { request_id: request.request_id, status: 'success', result };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        logError(`Position rows failed: ${error}`);
+        return { request_id: request.request_id, status: 'error', errors: [error] };
+    }
+}
 /**
  * Handle the 'health' action - report initialization status
  */
@@ -611,6 +646,8 @@ function handleRequest(request) {
             return handleListProgramFiles(request);
         case 'add_program_files':
             return handleAddProgramFiles(request);
+        case 'position_rows':
+            return handlePositionRows(request);
         case 'health':
             return handleHealth(request);
         case 'shutdown':