carrick 0.3.98 → 0.3.100

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.98",
+  "version": "0.3.100",
   "description": "Maps your entire TypeScript codebase across services and repositories, giving AI agents full context on existing types, routes, and function behaviours over MCP before they write duplicate or breaking code.",
   "keywords": [
     "typescript",
@@ -58,11 +58,11 @@
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "@carrick-tools/cli-darwin-arm64": "0.3.98",
-    "@carrick-tools/cli-darwin-x64": "0.3.98",
-    "@carrick-tools/cli-linux-arm64": "0.3.98",
-    "@carrick-tools/cli-linux-x64": "0.3.98",
-    "@carrick-tools/cli-win32-x64": "0.3.98"
+    "@carrick-tools/cli-darwin-arm64": "0.3.100",
+    "@carrick-tools/cli-darwin-x64": "0.3.100",
+    "@carrick-tools/cli-linux-arm64": "0.3.100",
+    "@carrick-tools/cli-linux-x64": "0.3.100",
+    "@carrick-tools/cli-win32-x64": "0.3.100"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "carrick",
   "description": "Claude Code plugin for Carrick, which indexes TypeScript codebases across service and repository boundaries. After each edit it adds the file's routes, calls, and cross-service type mismatches to the session, and it registers Carrick's language server. It pairs with the Carrick MCP server, which lets agents search functions by intent rather than name.",
-  "version": "0.3.98",
+  "version": "0.3.100",
   "author": {
     "name": "Carrick",
     "email": "hello@carrick.tools"

package/sidecar/dist/src/bundler.d.ts

@@ -122,6 +122,8 @@ export declare class TypeBundler {
     private dedupeSymbols;
     private validateSymbols;
     private validateSymbol;
+    /** Where a requested symbol is declared, or undefined when it cannot be found. */
+    private siteOf;
     /**
      * Structural body (`{ ... }`) for an interface/object type, with every nested
      * named member inlined recursively. Returns null when the expansion is not a

package/sidecar/dist/src/bundler.js

@@ -11,7 +11,7 @@
  * - Supports scoped packages and subpaths
  * - Includes a safety pass for any compiler-introduced raw specifiers
  */
-import { Node, } from 'ts-morph';
+import { Node, ts, } from 'ts-morph';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { expandTypeStructural, } from './type-structural-expander.js';
@@ -25,6 +25,97 @@ import { expandTypeStructural, } from './type-structural-expander.js';
  * as any other symbol the bundler can't extract a type for.
  */
 const MAX_ARRAY_DEPTH = 10;
+/** Whether `sourceFile` itself declares `name` in a form the bundle reads. */
+function declaresName(sourceFile, name) {
+    return Boolean(sourceFile.getInterface(name) ??
+        sourceFile.getTypeAlias(name) ??
+        sourceFile.getClass(name) ??
+        sourceFile.getEnum(name) ??
+        sourceFile.getVariableDeclaration(name) ??
+        sourceFile.getFunction(name));
+}
+/**
+ * The declarations `name` resolves to when imported from `sourceFile`
+ * (carrick#1605), or `ambiguous`.
+ *
+ * A name the module exports itself (declared there, `export { X }`, `export {
+ * X } from`, `export { X as Y } from`) wins over `export *`, and the checker
+ * follows it. Otherwise each `export *` is followed, at any depth. Two of them
+ * providing different declarations make the name ambiguous: TypeScript
+ * reports TS2308 and an ES module exports neither, while the checker's export
+ * table silently keeps the first, so the stars are walked here rather than
+ * read from it.
+ */
+function exportedDeclarations(sourceFile, name, seen) {
+    const key = sourceFile.getFilePath();
+    if (seen.has(key))
+        return [];
+    seen.add(key);
+    const ownExports = sourceFile.getSymbol()?.compilerSymbol.exports;
+    if (ownExports?.has(ts.escapeLeadingUnderscores(name))) {
+        return sourceFile.getExportedDeclarations().get(name) ?? [];
+    }
+    const found = [];
+    for (const declaration of sourceFile.getExportDeclarations()) {
+        // Only `export * from`: named and namespace re-exports are own exports.
+        if (declaration.hasNamedExports() || declaration.getNamespaceExport())
+            continue;
+        const target = declaration.getModuleSpecifierSourceFile();
+        if (!target)
+            continue;
+        const declarations = exportedDeclarations(target, name, seen);
+        if (declarations === 'ambiguous')
+            return declarations;
+        if (declarations.length > 0)
+            found.push(declarations);
+    }
+    const distinct = new Set(found.map(([first]) => `${first.getSourceFile().getFilePath()}:${first.getStart()}`));
+    if (distinct.size > 1)
+        return 'ambiguous';
+    return found[0] ?? [];
+}
+/** The name a re-exported declaration carries where it is declared. */
+function declaredName(declaration) {
+    if (Node.isInterfaceDeclaration(declaration) ||
+        Node.isTypeAliasDeclaration(declaration) ||
+        Node.isClassDeclaration(declaration) ||
+        Node.isEnumDeclaration(declaration) ||
+        Node.isVariableDeclaration(declaration) ||
+        Node.isFunctionDeclaration(declaration)) {
+        return declaration.getName();
+    }
+    return undefined;
+}
+/**
+ * Where `name`, as `sourceFile` exports it, is declared (carrick#1605). A name
+ * the file declares is its own. Otherwise it is followed the way an import of
+ * it is: a model names a type where the consumer imports it from, usually a
+ * barrel that only has `export *`.
+ */
+function declarationSite(sourceFile, name, label) {
+    if (declaresName(sourceFile, name))
+        return { sourceFile, name };
+    const declarations = exportedDeclarations(sourceFile, name, new Set());
+    if (declarations === 'ambiguous') {
+        return {
+            reason: `Symbol '${name}' is exported by more than one \`export *\` in ${label}`,
+        };
+    }
+    for (const declaration of declarations) {
+        const file = declaration.getSourceFile();
+        // An installed package's declaration names types from the package's own
+        // files, which the bundle does not carry, so its text would dangle. The
+        // failure is what it was before the walk, and inference keeps the row.
+        if (file.isInNodeModules() || file.isFromExternalLibrary()) {
+            return { reason: `Symbol '${name}' is re-exported from an installed package in ${label}` };
+        }
+        const declared = declaredName(declaration);
+        if (declared && declaresName(declaration.getSourceFile(), declared)) {
+            return { sourceFile: declaration.getSourceFile(), name: declared };
+        }
+    }
+    return { reason: `Symbol '${name}' not found in ${label}` };
+}
 /**
  * SurfaceEmitter - Generates .d.ts surface files with rewritten imports
  *
@@ -428,31 +519,19 @@ export class TypeBundler {
                 reason: `Failed to load source file: ${err instanceof Error ? err.message : String(err)}`,
             };
         }
-        // Look for the symbol in the file
-        const symbolName = symbol.symbol_name;
-        // Check interfaces
-        if (sourceFile.getInterface(symbolName))
-            return { valid: true };
-        // Check type aliases
-        if (sourceFile.getTypeAlias(symbolName))
-            return { valid: true };
-        // Check classes
-        if (sourceFile.getClass(symbolName))
-            return { valid: true };
-        // Check enums
-        if (sourceFile.getEnum(symbolName))
-            return { valid: true };
-        // Check exported variables
-        if (sourceFile.getVariableDeclaration(symbolName))
-            return { valid: true };
-        // Check functions
-        if (sourceFile.getFunction(symbolName))
-            return { valid: true };
-        // Symbol not found
-        return {
-            valid: false,
-            reason: `Symbol '${symbolName}' not found in ${symbol.source_file}`,
-        };
+        const site = declarationSite(sourceFile, symbol.symbol_name, symbol.source_file);
+        return 'reason' in site ? { valid: false, reason: site.reason } : { valid: true };
+    }
+    /** Where a requested symbol is declared, or undefined when it cannot be found. */
+    siteOf(symbol) {
+        const absolutePath = path.isAbsolute(symbol.source_file)
+            ? symbol.source_file
+            : path.resolve(this.repoRoot, symbol.source_file);
+        const sourceFile = this.project.getSourceFile(absolutePath);
+        if (!sourceFile)
+            return undefined;
+        const site = declarationSite(sourceFile, symbol.symbol_name, symbol.source_file);
+        return 'reason' in site ? undefined : site;
     }
     /**
      * Structural body (`{ ... }`) for an interface/object type, with every nested
@@ -525,13 +604,10 @@ export class TypeBundler {
     /// union/intersection/function that would misparse; those are re-resolved
     /// from the source Type here (this runs only on the rare array_depth path).
     elementNeedsArrayParens(symbol) {
-        const absolutePath = path.isAbsolute(symbol.source_file)
-            ? symbol.source_file
-            : path.resolve(this.repoRoot, symbol.source_file);
-        const sourceFile = this.project.getSourceFile(absolutePath);
-        if (!sourceFile)
+        const site = this.siteOf(symbol);
+        if (!site)
             return false;
-        const name = symbol.symbol_name;
+        const { sourceFile, name } = site;
         const decl = sourceFile.getTypeAlias(name) ?? sourceFile.getVariableDeclaration(name);
         if (!decl)
             return false;
@@ -546,15 +622,15 @@ export class TypeBundler {
     // verbatim declaration text from a fallback branch. Only expressions can be
     // array-wrapped by `extractTypeDefinition`.
     extractTypeDefinitionBase(symbol) {
-        const absolutePath = path.isAbsolute(symbol.source_file)
-            ? symbol.source_file
-            : path.resolve(this.repoRoot, symbol.source_file);
-        const sourceFile = this.project.getSourceFile(absolutePath);
-        if (!sourceFile) {
+        const site = this.siteOf(symbol);
+        if (!site) {
             return null;
         }
-        const symbolName = symbol.symbol_name;
-        const alias = symbol.alias || symbolName;
+        // `symbolName` is the declaration's own name, which a renamed re-export
+        // (`export { Account as AccountView }`) does not share with the request;
+        // the bundle declares the name the symbol was requested under.
+        const { sourceFile, name: symbolName } = site;
+        const alias = symbol.alias || symbol.symbol_name;
         // Try interface
         const iface = sourceFile.getInterface(symbolName);
         if (iface) {

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

@@ -30,6 +30,7 @@
 import type { CaptureStubOptions, CaptureStubResult } from './api.js';
 export type { CaptureStubOptions, CaptureStubResult } from './api.js';
 export { DenoProject, findDenoConfig } from './deno-project.js';
+export { serviceConfigPath } from './project-references.js';
 export { runCheck } from './check.js';
 export type { CheckProgress } from './check.js';
 export { jsonWireDeclarations } from './check-probe.js';

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

@@ -39,7 +39,9 @@ import { typesPackageOf, withInstalledPackages } from './installed-package.js';
 import { selfCheckStub } from './self-check.js';
 import { collectSpecifiers, isRelative, packageNameOf } from './specifiers.js';
 import { DenoProject, findDenoConfig } from './deno-project.js';
+import { emitsAlike, ProjectGraph } from './project-references.js';
 export { DenoProject, findDenoConfig } from './deno-project.js';
+export { serviceConfigPath } from './project-references.js';
 // v2 check core ("tsc as the judge"). Same bundle, same seam: the sidecar
 // reaches it only through this door (index.js).
 export { runCheck } from './check.js';
@@ -128,6 +130,13 @@ export function captureStub(opts) {
         ? path.resolve(repoRoot, opts.tsconfigPath)
         : path.join(repoRoot, 'tsconfig.json');
     let parsed;
+    // The config the emit's options came from: the named one, or the project
+    // that owns the most anchors' files (carrick#1604).
+    let projectConfigPath = configPath;
+    // Anchor indexes by the project that owns their file, when the named config
+    // references others and the anchors' files do not all belong to one project.
+    let ownerGroups;
+    let emitProject;
     let deno;
     try {
         const config = findDenoConfig(repoRoot, opts.tsconfigPath);
@@ -164,18 +173,44 @@ export function captureStub(opts) {
         }, ts.sys, repoRoot);
     }
     else {
-        const configHost = {
-            ...ts.sys,
-            onUnRecoverableConfigFileDiagnostic: (d) => {
-                throw new Error(ts.flattenDiagnosticMessageText(d.messageText, '\n'));
-            },
-        };
+        // Each anchor is typed under the project that owns its file: the named
+        // config when it lists the file, else the first project it references
+        // (depth-first, in declared order) that does, else the named config.
+        let graph;
         try {
-            parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, configHost) ?? undefined;
+            graph = new ProjectGraph(configPath);
         }
         catch (err) {
             return fail(stubDir, packageName, [err instanceof Error ? err.message : String(err)]);
         }
+        const groups = new Map();
+        const unfiled = [];
+        opts.anchors.forEach((anchor, index) => {
+            const file = anchor.source_file ? path.resolve(repoRoot, anchor.source_file) : undefined;
+            if (!file || !fs.existsSync(file)) {
+                unfiled.push(index);
+                return;
+            }
+            const owner = graph.ownerOf(file);
+            groups.set(owner, [...(groups.get(owner) ?? []), index]);
+        });
+        // One emit: under the owner of the most anchors, ties to search order.
+        let emit = graph.named;
+        let most = 0;
+        for (const [owner, indexes] of groups) {
+            if (indexes.length > most || (indexes.length === most && graph.rank(owner) < graph.rank(emit))) {
+                emit = owner;
+                most = indexes.length;
+            }
+        }
+        if (unfiled.length > 0)
+            groups.set(emit, [...(groups.get(emit) ?? []), ...unfiled]);
+        errors.push(...graph.diagnostics);
+        parsed = emit.parsed;
+        projectConfigPath = emit.configPath;
+        emitProject = emit;
+        if (groups.size > 1)
+            ownerGroups = groups;
     }
     if (!parsed) {
         return fail(stubDir, packageName, [`failed to parse ${configPath}`]);
@@ -183,7 +218,7 @@ export function captureStub(opts) {
     // The surface entry must live inside the effective rootDir (design doc
     // Capture step 1: an entry at repo root with rootDir "src" fails TS6059).
     const entryDir = parsed.options.rootDir
-        ? path.resolve(path.dirname(configPath), parsed.options.rootDir)
+        ? path.resolve(path.dirname(projectConfigPath), parsed.options.rootDir)
         : repoRoot;
     const surfaceEntry = surfaceEntryFileName();
     const surfaceDeclaration = `${surfaceEntry}.d.ts`;
@@ -193,8 +228,11 @@ export function captureStub(opts) {
     fs.mkdirSync(path.dirname(entryPath), { recursive: true });
     // ---- Phase A: analysis program over placeholder entry + anchor sources ----
     let resolved;
+    const analysisCtx = { repoRoot, entryDir: path.dirname(entryPath), entryPath };
     try {
-        resolved = resolveAnchors(opts, parsed, { repoRoot, entryDir: path.dirname(entryPath), entryPath }, deno);
+        resolved = ownerGroups && emitProject
+            ? resolveAnchorsByOwner(opts, ownerGroups, emitProject, analysisCtx, errors)
+            : resolveAnchors(opts, parsed, analysisCtx, deno);
     }
     catch (err) {
         return fail(stubDir, packageName, [err instanceof Error ? err.message : String(err)]);
@@ -343,7 +381,7 @@ export function captureStub(opts) {
         typesDir,
         files: emittedFiles,
         options: parsed.options,
-        configPath,
+        configPath: projectConfigPath,
         entryDir,
     });
     const specifierRewrites = denoRewrites + rewritten.rewrites;
@@ -513,6 +551,49 @@ function rewriteSurfaceAliasesToUnknown(text, demoted) {
     }
     return out;
 }
+/**
+ * Phase A when the anchors' files belong to different projects (carrick#1604):
+ * each owner's anchors are resolved in a program built from that owner's
+ * options, so a file is never typed under a project that does not own it.
+ *
+ * The surface is emitted once, under `emit`'s options. An anchor from another
+ * project keeps its text when the text stands alone, or when the two projects
+ * would emit a declaration the same way. Otherwise its text names a module the
+ * emit would declare under the wrong options (a symbol or handler anchor, or
+ * a print that imports a module), so it is demoted with the reason, and cannot
+ * self-check clean.
+ */
+function resolveAnchorsByOwner(opts, groups, emit, ctx, errors) {
+    const resolved = new Array(opts.anchors.length);
+    for (const [owner, indexes] of groups) {
+        const anchors = indexes.map((index) => opts.anchors[index]);
+        const group = resolveAnchors({ ...opts, anchors }, owner.parsed, ctx);
+        let demoted = 0;
+        group.forEach((anchor, position) => {
+            const index = indexes[position];
+            const namesModule = anchor.request.kind === 'symbol' ||
+                anchor.request.kind === 'handler_return' ||
+                collectSpecifiers(anchor.aliasText).size > 0;
+            if (owner === emit || anchor.failureReason !== undefined || !namesModule || emitsAlike(owner, emit)) {
+                resolved[index] = anchor;
+                return;
+            }
+            demoted += 1;
+            resolved[index] = {
+                request: anchor.request,
+                aliasText: 'unknown',
+                serialization: 'structural_fallback',
+                failureReason: `typed under ${owner.configPath}, the project that owns its file, whose options differ ` +
+                    `from ${emit.configPath}, which emits the surface; the module it names would be declared under the wrong options`,
+            };
+        });
+        if (owner !== emit) {
+            errors.push(`${indexes.length} anchor(s) typed under ${owner.configPath}, the project that owns their files` +
+                (demoted > 0 ? `; ${demoted} demoted because the surface is emitted under ${emit.configPath}` : ''));
+        }
+    }
+    return resolved;
+}
 /** Phase A: build the placeholder entry, then resolve every anchor. */
 function resolveAnchors(opts, parsed, ctx, deno) {
     const placeholderLines = ['// Carrick capture v2 analysis placeholder.'];

package/sidecar/dist/src/capture/project-references.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Which project types a file of a service whose tsconfig references others
+ * (carrick#1604).
+ *
+ * A "solution" tsconfig (`"files": []` plus `references`) carries no compiler
+ * options: they live in the projects it references. Parsing the named file
+ * alone typed every file with none, so `customConditions`, `paths` and the
+ * module resolution mode never applied and workspace imports fell through to
+ * unbuilt output.
+ *
+ * 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.
+ */
+import ts from 'typescript';
+/** One parsed tsconfig. */
+export interface ServiceProject {
+    /** Absolute path of the config file the options came from. */
+    configPath: string;
+    parsed: ts.ParsedCommandLine;
+}
+/**
+ * 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.
+ */
+export declare class ProjectGraph {
+    readonly named: ServiceProject;
+    /** References that could not be read, one line each. */
+    readonly diagnostics: string[];
+    private readonly extendedConfigCache;
+    private walked;
+    private readonly namedFiles;
+    /** Throws when the named config cannot be read, as a bare parse would. */
+    constructor(configPath: string);
+    /** Whether the named config references other projects at all. */
+    get hasReferences(): boolean;
+    /**
+     * 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.
+     */
+    ownerOf(file: string): ServiceProject;
+    /** Position in search order, 0 for the named config. */
+    rank(project: ServiceProject): number;
+    private projects;
+}
+/**
+ * For the loader: the config each file of the service is typed under. The
+ * returned function gives the owner's config path for a file, and the named
+ * config for no file; a reference that cannot be read goes to `report`. A named config that references nothing is not parsed
+ * here (`references` is never inherited through `extends`), so the function
+ * answers the named path for every file and the common case costs nothing.
+ */
+export declare function serviceConfigPath(configPath: string, report?: (diagnostic: string) => void): (file?: string) => string;
+/**
+ * Whether two projects' options would emit a declaration the same way, so a
+ * type one of them names can be emitted by the other.
+ */
+export declare function emitsAlike(a: ServiceProject, b: ServiceProject): boolean;

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

@@ -0,0 +1,157 @@
+/**
+ * Which project types a file of a service whose tsconfig references others
+ * (carrick#1604).
+ *
+ * A "solution" tsconfig (`"files": []` plus `references`) carries no compiler
+ * options: they live in the projects it references. Parsing the named file
+ * alone typed every file with none, so `customConditions`, `paths` and the
+ * module resolution mode never applied and workspace imports fell through to
+ * unbuilt output.
+ *
+ * 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.
+ */
+import * as path from 'node:path';
+import ts from 'typescript';
+/** Parse one config; throws on a file that cannot be read or parsed. */
+function parseConfig(configPath, extendedConfigCache) {
+    const host = {
+        ...ts.sys,
+        onUnRecoverableConfigFileDiagnostic: (d) => {
+            throw new Error(ts.flattenDiagnosticMessageText(d.messageText, '\n'));
+        },
+    };
+    const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, host, extendedConfigCache);
+    if (!parsed)
+        throw new Error(`failed to parse ${configPath}`);
+    return { configPath: path.resolve(configPath), parsed };
+}
+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.
+ */
+export class ProjectGraph {
+    named;
+    /** References that could not be read, one line each. */
+    diagnostics = [];
+    extendedConfigCache = new Map();
+    walked;
+    namedFiles;
+    /** Throws when the named config cannot be read, as a bare parse would. */
+    constructor(configPath) {
+        this.named = parseConfig(configPath, this.extendedConfigCache);
+        this.namedFiles = new Set(this.named.parsed.fileNames.map(fileKey));
+    }
+    /** Whether the named config references other projects at all. */
+    get hasReferences() {
+        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.
+     */
+    ownerOf(file) {
+        const key = fileKey(file);
+        if (this.namedFiles.has(key) || !this.hasReferences)
+            return this.named;
+        return this.projects().find((entry) => entry.files.has(key))?.project ?? this.named;
+    }
+    /** Position in search order, 0 for the named config. */
+    rank(project) {
+        if (project === this.named)
+            return 0;
+        const index = this.projects().findIndex((entry) => entry.project === project);
+        return index === -1 ? Number.MAX_SAFE_INTEGER : index;
+    }
+    projects() {
+        if (this.walked)
+            return this.walked;
+        const visited = new Set([this.named.configPath]);
+        const order = [];
+        const visit = (project, files) => {
+            order.push({ project, files });
+            for (const reference of project.parsed.projectReferences ?? []) {
+                const referencePath = path.resolve(ts.resolveProjectReferencePath(reference));
+                if (visited.has(referencePath))
+                    continue;
+                visited.add(referencePath);
+                let child;
+                try {
+                    child = parseConfig(referencePath, this.extendedConfigCache);
+                }
+                catch (err) {
+                    this.diagnostics.push(`referenced tsconfig ${referencePath} (from ${project.configPath}) could not be read and was skipped: ` +
+                        (err instanceof Error ? err.message : String(err)));
+                    continue;
+                }
+                visit(child, new Set(child.parsed.fileNames.map(fileKey)));
+            }
+        };
+        visit(this.named, this.namedFiles);
+        this.walked = order;
+        return order;
+    }
+}
+/**
+ * For the loader: the config each file of the service is typed under. The
+ * returned function gives the owner's config path for a file, and the named
+ * config for no file; a reference that cannot be read goes to `report`. A named config that references nothing is not parsed
+ * here (`references` is never inherited through `extends`), so the function
+ * answers the named path for every file and the common case costs nothing.
+ */
+export function serviceConfigPath(configPath, report = () => { }) {
+    const raw = ts.readConfigFile(configPath, ts.sys.readFile).config;
+    if (!Array.isArray(raw?.references) || raw.references.length === 0) {
+        return () => configPath;
+    }
+    let graph;
+    return (file) => {
+        if (file === undefined)
+            return configPath;
+        graph ??= new ProjectGraph(configPath);
+        const reported = graph.diagnostics.length;
+        const owner = graph.ownerOf(file);
+        graph.diagnostics.slice(reported).forEach(report);
+        return owner === graph.named ? configPath : owner.configPath;
+    };
+}
+/** Compiler options that only place output, so two projects differing only in these emit the same declarations. */
+const OUTPUT_ONLY_OPTIONS = new Set([
+    'rootDir',
+    'outDir',
+    'declarationDir',
+    'outFile',
+    'composite',
+    'declaration',
+    'declarationMap',
+    'emitDeclarationOnly',
+    'incremental',
+    'tsBuildInfoFile',
+    'configFilePath',
+    'noEmit',
+    'sourceMap',
+    'inlineSourceMap',
+    'inlineSources',
+]);
+/**
+ * Whether two projects' options would emit a declaration the same way, so a
+ * type one of them names can be emitted by the other.
+ */
+export function emitsAlike(a, b) {
+    const relevant = (options) => JSON.stringify(Object.keys(options)
+        .filter((key) => !OUTPUT_ONLY_OPTIONS.has(key))
+        .sort()
+        .map((key) => [key, options[key]]));
+    return relevant(a.parsed.options) === relevant(b.parsed.options);
+}

package/sidecar/dist/src/index.js

@@ -28,23 +28,29 @@ import { ClientSemanticsVerifier } from './client-semantics.js';
 let projectLoader = null;
 let monorepoBuilder = null;
 let initTimeMs = null;
-let components = null;
+/**
+ * Components by project key (`ProjectLoader.projectKeyFor`): `''` is the
+ * default project, any other key the program of a project that owns some of
+ * the service's files (carrick#1604).
+ */
+let components = new Map();
 /**
  * Get the project-backed components, building the project if this is the
  * first request that needs it.
  *
  * @throws if init has not run, or if the project cannot be built
  */
-function projectComponents() {
+function projectComponents(key = '') {
     if (!projectLoader?.isInitialized()) {
         throw new Error('Sidecar not initialized. Call init first.');
     }
-    if (!components) {
+    let built = components.get(key);
+    if (!built) {
         // Bound here rather than read from the module slot inside the components:
         // a re-init drops `components` and points the slot at another service, and
         // nothing built over this project may follow it there.
         const loader = projectLoader;
-        const project = loader.getProject();
+        const project = loader.getProjectFor(key);
         const repoRoot = loader.getRepoRoot();
         // The module graph, where the project resolved through one, is the only
         // thing that can name the package a file belongs to: a Deno service
@@ -54,7 +60,7 @@ function projectComponents() {
             repoRoot,
             packageOf: (filePath) => loader.packageOf(filePath),
         });
-        components = {
+        built = {
             typeBundler: new TypeBundler({ project, repoRoot }),
             surfaceEmitter: new SurfaceEmitter({ project, repoRoot }),
             typeInferrer,
@@ -70,8 +76,41 @@ function projectComponents() {
             retyper: new Retyper(project, typeInferrer, jsonWireDeclarations, findDisqualifyingTopTypes),
             semanticsVerifier: new ClientSemanticsVerifier(project),
         };
+        components.set(key, built);
     }
-    return components;
+    return built;
+}
+/** One bundle answer from the answers of several programs. */
+function mergeBundles(results) {
+    const symbol_failures = results.flatMap((r) => r.symbol_failures ?? []);
+    const answered = results.filter((r) => r.success);
+    if (answered.length === 0) {
+        return {
+            success: false,
+            symbol_failures,
+            errors: [...new Set(results.flatMap((r) => r.errors ?? []))],
+        };
+    }
+    return {
+        success: true,
+        dts_content: answered.map((r) => r.dts_content ?? '').join('\n'),
+        manifest: answered.flatMap((r) => r.manifest ?? []),
+        symbol_failures: symbol_failures.length > 0 ? symbol_failures : undefined,
+    };
+}
+/**
+ * Split a request's items by the project that types their file, keeping each
+ * group in request order. One group, the default project's, for a service
+ * whose tsconfig references nothing.
+ */
+function byProject(items, fileOf) {
+    // An empty request is still answered by the default project, as before.
+    const groups = new Map(items.length === 0 ? [['', []]] : []);
+    for (const item of items) {
+        const key = projectLoader?.projectKeyFor(fileOf(item)) ?? '';
+        groups.set(key, [...(groups.get(key) ?? []), item]);
+    }
+    return groups;
 }
 // ===========================================================================
 // Request Handlers
@@ -85,7 +124,7 @@ function handleInit(request) {
         log(`Initializing with repo_root: ${request.repo_root}`);
         // Re-init re-scopes the sidecar to another root: drop everything built
         // over the previous project before resolving the new one.
-        components = null;
+        components = new Map();
         projectLoader = new ProjectLoader({
             repoRoot: request.repo_root,
             tsconfigPath: request.tsconfig_path,
@@ -131,7 +170,10 @@ function handleInit(request) {
 function handleBundle(request) {
     try {
         log(`Bundling ${request.symbols.length} symbol(s)`);
-        const result = projectComponents().typeBundler.bundle(request.symbols);
+        // A symbol named by a path is bundled from the program of the project
+        // that owns that file (carrick#1604).
+        const results = [...byProject(request.symbols, (symbol) => symbol.source_file)].map(([key, symbols]) => projectComponents(key).typeBundler.bundle(symbols));
+        const result = results.length === 1 ? results[0] : mergeBundles(results);
         if (!result.success) {
             return {
                 request_id: request.request_id,
@@ -277,7 +319,18 @@ async function handleCheckV2Async(request) {
 function handleInfer(request) {
     try {
         log(`Inferring ${request.requests.length} type(s)`);
-        const result = projectComponents().typeInferrer.infer(request.requests, request.extraction_config);
+        const results = [...byProject(request.requests, (item) => item.file_path)].map(([key, items]) => projectComponents(key).typeInferrer.infer(items, request.extraction_config));
+        const result = results.length === 1
+            ? results[0]
+            : (() => {
+                const inferred_types = results.flatMap((r) => r.inferred_types ?? []);
+                const errors = results.flatMap((r) => r.errors ?? []);
+                return {
+                    success: errors.length === 0 || inferred_types.length > 0,
+                    inferred_types,
+                    errors: errors.length > 0 ? errors : undefined,
+                };
+            })();
         return {
             request_id: request.request_id,
             status: result.success ? 'success' : 'error',
@@ -307,7 +360,19 @@ const RETYPE_BUDGET_MS = 600_000;
 function handleRetypeCheck(request) {
     try {
         log(`Retyping ${request.items.length} consumer call(s)`);
-        const outcomes = projectComponents().retyper.run(request.items, request.budget_ms ?? RETYPE_BUDGET_MS);
+        const budget = request.budget_ms ?? RETYPE_BUDGET_MS;
+        const groups = byProject(request.items.map((item, index) => ({ item, index })), ({ item }) => item.file_path);
+        const deadline = performance.now() + budget;
+        const outcomes = new Array(request.items.length);
+        for (const [key, entries] of groups) {
+            // One budget for the request, whichever programs it spans.
+            const remaining = groups.size === 1 ? budget : Math.max(0, deadline - performance.now());
+            projectComponents(key)
+                .retyper.run(entries.map(({ item }) => item), remaining)
+                .forEach((outcome, position) => {
+                outcomes[entries[position].index] = outcome;
+            });
+        }
         return { request_id: request.request_id, status: 'success', outcomes };
     }
     catch (err) {

package/sidecar/dist/src/module-format.d.ts

@@ -0,0 +1,32 @@
+/**
+ * How the init'd project resolves an import: in the mode the compiler picks
+ * for the file that imports it (carrick#1619).
+ *
+ * Under `module` `node16`..`nodenext` the compiler reads each file's own
+ * format (its nearest `package.json` `"type"`, or its extension) to decide
+ * whether an import resolves with the `import` or the `require` export
+ * conditions. The program asks its host to create each file with that format,
+ * but ts-morph's host creates every file with the script target only, so no
+ * file had a format and every import resolved as a `require`. A package whose
+ * `exports` entry only has an `import` branch did not resolve at all, while
+ * the capture, which uses the compiler directly, resolved the same import.
+ *
+ * This resolution host gives the importing file its format before its imports
+ * are resolved, then resolves each import as the compiler's default does:
+ * `ts.resolveModuleName` in the mode `ts.getModeForUsageLocation` reads off
+ * that import. The format is only set under `node16`..`nodenext`. Under other
+ * `module` settings the compiler still takes an import's mode from its syntax
+ * (`import`, `require`, a `resolution-mode` attribute) and reads a file's
+ * format only in narrow cases; setting it there made answers worse, because
+ * ts-morph's TypeScript copy shares one resolution-cache entry across modes
+ * under Bundler (carrick#1632), so those settings keep their old modes.
+ *
+ * The hook receives one entry per import, by module name, so one name
+ * imported twice in different modes (a `require` beside an `import`) needs
+ * each entry matched to its own import. It is, by position, when every import
+ * of the name is being resolved; when only some of them are (the compiler
+ * reusing earlier answers) and their modes differ, the entry cannot be placed
+ * and is left unresolved rather than given another import's mode.
+ */
+import { type ResolutionHostFactory } from 'ts-morph';
+export declare const moduleFormatResolutionHost: ResolutionHostFactory;

package/sidecar/dist/src/module-format.js

@@ -0,0 +1,102 @@
+/**
+ * How the init'd project resolves an import: in the mode the compiler picks
+ * for the file that imports it (carrick#1619).
+ *
+ * Under `module` `node16`..`nodenext` the compiler reads each file's own
+ * format (its nearest `package.json` `"type"`, or its extension) to decide
+ * whether an import resolves with the `import` or the `require` export
+ * conditions. The program asks its host to create each file with that format,
+ * but ts-morph's host creates every file with the script target only, so no
+ * file had a format and every import resolved as a `require`. A package whose
+ * `exports` entry only has an `import` branch did not resolve at all, while
+ * the capture, which uses the compiler directly, resolved the same import.
+ *
+ * This resolution host gives the importing file its format before its imports
+ * are resolved, then resolves each import as the compiler's default does:
+ * `ts.resolveModuleName` in the mode `ts.getModeForUsageLocation` reads off
+ * that import. The format is only set under `node16`..`nodenext`. Under other
+ * `module` settings the compiler still takes an import's mode from its syntax
+ * (`import`, `require`, a `resolution-mode` attribute) and reads a file's
+ * format only in narrow cases; setting it there made answers worse, because
+ * ts-morph's TypeScript copy shares one resolution-cache entry across modes
+ * under Bundler (carrick#1632), so those settings keep their old modes.
+ *
+ * The hook receives one entry per import, by module name, so one name
+ * imported twice in different modes (a `require` beside an `import`) needs
+ * each entry matched to its own import. It is, by position, when every import
+ * of the name is being resolved; when only some of them are (the compiler
+ * reusing earlier answers) and their modes differ, the entry cannot be placed
+ * and is left unresolved rather than given another import's mode.
+ */
+import { ts } from 'ts-morph';
+/** Whether the compiler decides an import's mode from the importing file's format. */
+function formatDecidesMode(options) {
+    const kind = options.module;
+    return kind !== undefined && kind >= ts.ModuleKind.Node16 && kind <= ts.ModuleKind.NodeNext;
+}
+/**
+ * The literals in `file` the program resolves, by module name and in source
+ * order: its imports, then its module augmentations. Neither list is in the
+ * public declaration file.
+ */
+function usagesOf(file) {
+    const internal = file;
+    const usages = new Map();
+    const add = (literal) => {
+        usages.set(literal.text, [...(usages.get(literal.text) ?? []), literal]);
+    };
+    for (const literal of internal.imports ?? [])
+        add(literal);
+    for (const literal of internal.moduleAugmentations ?? []) {
+        if (ts.isStringLiteral(literal))
+            add(literal);
+    }
+    return usages;
+}
+/** Why a module name cannot be given one mode: see the header. */
+const UNPLACED = Symbol('unplaced');
+export const moduleFormatResolutionHost = (host, getOptions) => {
+    let cache;
+    let cacheOptions;
+    const cacheFor = (options) => {
+        if (!cache || cacheOptions !== options) {
+            cache = ts.createModuleResolutionCache(process.cwd(), (fileName) => fileName, options);
+            cacheOptions = options;
+        }
+        return cache;
+    };
+    return {
+        resolveModuleNames: (moduleNames, containingFile, _reusedNames, redirectedReference, options, containingSourceFile) => {
+            const compilerOptions = options ?? getOptions();
+            const resolutionCache = cacheFor(compilerOptions);
+            if (containingSourceFile &&
+                containingSourceFile.impliedNodeFormat === undefined &&
+                formatDecidesMode(compilerOptions)) {
+                containingSourceFile.impliedNodeFormat =
+                    ts.getImpliedNodeFormatForFile(containingFile, resolutionCache.getPackageJsonInfoCache(), host, compilerOptions);
+            }
+            const usages = containingSourceFile ? usagesOf(containingSourceFile) : undefined;
+            const asked = new Map();
+            for (const name of moduleNames)
+                asked.set(name, (asked.get(name) ?? 0) + 1);
+            const seen = new Map();
+            const modeOf = (name) => {
+                const occurrence = seen.get(name) ?? 0;
+                seen.set(name, occurrence + 1);
+                const literals = usages?.get(name) ?? [];
+                if (!containingSourceFile || literals.length === 0)
+                    return undefined;
+                const modes = literals.map((literal) => ts.getModeForUsageLocation(containingSourceFile, literal, compilerOptions));
+                if (new Set(modes).size === 1)
+                    return modes[0];
+                return asked.get(name) === literals.length ? modes[occurrence] : UNPLACED;
+            };
+            return moduleNames.map((name) => {
+                const mode = modeOf(name);
+                if (mode === UNPLACED)
+                    return undefined;
+                return ts.resolveModuleName(name, containingFile, compilerOptions, host, resolutionCache, redirectedReference, mode).resolvedModule;
+            });
+        },
+    };
+};

package/sidecar/dist/src/project-loader.d.ts

@@ -61,6 +61,12 @@ export declare class ProjectLoader {
      * build, so it is there from the first `getProject()` onwards.
      */
     private denoProject;
+    /** The tsconfig the service names, when the project is built from one. */
+    private namedTsconfigPath;
+    /** Each file's owning config (carrick#1604), resolved on first use. */
+    private configPathFor;
+    /** Programs built for owning projects other than the named tsconfig. */
+    private readonly ownerProjects;
     private readonly repoRoot;
     private readonly tsconfigPath;
     private readonly tsconfigSnapshot;
@@ -82,6 +88,24 @@ export declare class ProjectLoader {
      * Convert a TsconfigSnapshot to ts-morph CompilerOptions
      */
     private snapshotToCompilerOptions;
+    /** A ts-morph project built from one tsconfig and the files it lists. */
+    private projectFromConfig;
+    /**
+     * Which project types `file` (carrick#1604): the key of its owning
+     * project's program, or `''` for the default one. A tsconfig that
+     * references other projects owns only the files it lists itself; any other
+     * file belongs to the first project it references (depth-first, in
+     * declared order) whose file list includes it, and is typed under that
+     * project's options. A file no project includes, and every request that
+     * names no file, uses the default project, built from the named tsconfig
+     * as before.
+     */
+    projectKeyFor(file?: string): string;
+    /**
+     * The project behind a key from `projectKeyFor`, built on first use and
+     * kept: a service whose files all belong to one project builds one.
+     */
+    getProjectFor(key: string): Project;
     /**
      * Get the ts-morph Project, building it on first call.
      *

package/sidecar/dist/src/project-loader.js

@@ -12,7 +12,8 @@
 import { Project } from 'ts-morph';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
-import { DenoProject, findDenoConfig } from './capture/index.js';
+import { DenoProject, findDenoConfig, serviceConfigPath } from './capture/index.js';
+import { moduleFormatResolutionHost } from './module-format.js';
 /**
  * Source-file patterns used when the repo declares no tsconfig, relative to
  * the repo root. `node_modules` is excluded explicitly: a glob that matches
@@ -115,6 +116,12 @@ export class ProjectLoader {
      * build, so it is there from the first `getProject()` onwards.
      */
     denoProject;
+    /** The tsconfig the service names, when the project is built from one. */
+    namedTsconfigPath;
+    /** Each file's owning config (carrick#1604), resolved on first use. */
+    configPathFor;
+    /** Programs built for owning projects other than the named tsconfig. */
+    ownerProjects = new Map();
     repoRoot;
     tsconfigPath;
     tsconfigSnapshot;
@@ -200,10 +207,8 @@ export class ProjectLoader {
                 }
                 else if (tsconfigPath) {
                     this.log(`Project will load with tsconfig: ${tsconfigPath}`);
-                    this.buildProject = () => new Project({
-                        tsConfigFilePath: tsconfigPath,
-                        skipAddingFilesFromTsConfig: false,
-                    });
+                    this.namedTsconfigPath = tsconfigPath;
+                    this.buildProject = () => this.projectFromConfig(tsconfigPath);
                 }
                 else {
                     this.log('No tsconfig.json found, using default compiler options');
@@ -306,6 +311,49 @@ export class ProjectLoader {
         }
         return result;
     }
+    /** A ts-morph project built from one tsconfig and the files it lists. */
+    projectFromConfig(configPath) {
+        return new Project({
+            tsConfigFilePath: configPath,
+            skipAddingFilesFromTsConfig: false,
+            // Each import resolves in its file's own module format (carrick#1619).
+            resolutionHost: moduleFormatResolutionHost,
+        });
+    }
+    /**
+     * Which project types `file` (carrick#1604): the key of its owning
+     * project's program, or `''` for the default one. A tsconfig that
+     * references other projects owns only the files it lists itself; any other
+     * file belongs to the first project it references (depth-first, in
+     * declared order) whose file list includes it, and is typed under that
+     * project's options. A file no project includes, and every request that
+     * names no file, uses the default project, built from the named tsconfig
+     * as before.
+     */
+    projectKeyFor(file) {
+        if (!this.namedTsconfigPath || file === undefined)
+            return '';
+        this.configPathFor ??= serviceConfigPath(this.namedTsconfigPath, (d) => this.logError(d));
+        const config = this.configPathFor(path.resolve(this.repoRoot, file));
+        return config === this.namedTsconfigPath ? '' : config;
+    }
+    /**
+     * The project behind a key from `projectKeyFor`, built on first use and
+     * kept: a service whose files all belong to one project builds one.
+     */
+    getProjectFor(key) {
+        if (key === '')
+            return this.getProject();
+        let project = this.ownerProjects.get(key);
+        if (!project) {
+            const startTime = performance.now();
+            project = this.projectFromConfig(key);
+            this.ownerProjects.set(key, project);
+            this.log(`Project for ${key}, the project that owns the requested files, built in ` +
+                `${Math.round(performance.now() - startTime)}ms (${project.getSourceFiles().length} source files)`);
+        }
+        return project;
+    }
     /**
      * Get the ts-morph Project, building it on first call.
      *

package/sidecar/dist/src/types.d.ts

@@ -685,8 +685,9 @@ export interface InferredType {
      * anchor symbol has a resolvable source declaration. Lets the scanner's
      * pub/sub two-anchor arbitration (carrick#413) re-aim a demoted explicit
      * `SymbolRequest` at the tsc-witnessed payload type: the bundler requires
-     * the symbol to be DECLARED in the request's `source_file`, and the
-     * inference is the only party that knows where that is. Reported only by
+     * the symbol to be declared in, or re-exported by, the request's
+     * `source_file`, and the inference is the only party that knows where that
+     * is. Reported only by
      * the pub/sub infer kinds (`function_param`, `expression`); other kinds
      * omit it.
      */