carrick 0.3.108 → 0.3.109

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.108",
+  "version": "0.3.109",
   "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",
@@ -53,20 +53,19 @@
     "@clack/prompts": "1.8.1",
     "picocolors": "1.1.1",
     "pnpm": "10.34.5",
-    "ts-morph": "^25.0.1",
-    "typescript": "^5.8.0",
+    "ts-morph": "28.0.0",
+    "typescript": "6.0.2",
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "@carrick-tools/cli-darwin-arm64": "0.3.108",
-    "@carrick-tools/cli-darwin-x64": "0.3.108",
-    "@carrick-tools/cli-linux-arm64": "0.3.108",
-    "@carrick-tools/cli-linux-x64": "0.3.108",
-    "@carrick-tools/cli-win32-x64": "0.3.108"
+    "@carrick-tools/cli-darwin-arm64": "0.3.109",
+    "@carrick-tools/cli-darwin-x64": "0.3.109",
+    "@carrick-tools/cli-linux-arm64": "0.3.109",
+    "@carrick-tools/cli-linux-x64": "0.3.109",
+    "@carrick-tools/cli-win32-x64": "0.3.109"
   },
   "devDependencies": {
-    "@types/node": "^24.13.3",
-    "typescript": "^5.9.2"
+    "@types/node": "^24.13.3"
   },
   "publishConfig": {
     "access": "public",

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.108",
+  "version": "0.3.109",
   "author": {
     "name": "Carrick",
     "email": "hello@carrick.tools"

package/sidecar/dist/src/capture/check-deep.js

@@ -18,6 +18,7 @@
 import ts from 'typescript';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { sidecarCompilerOptions } from './compiler-options.js';
 import { findDisqualifyingTopTypes, provenanceOf } from './deep-walk.js';
 export function openProbeProgram(probesDir, plans) {
     if (plans.length === 0)
@@ -35,7 +36,7 @@ export function openProbeProgram(probesDir, plans) {
             .filter((f) => fs.existsSync(f));
         if (fileNames.length === 0)
             return undefined;
-        const program = ts.createProgram(fileNames, { ...parsed.options, noEmit: true });
+        const program = ts.createProgram(fileNames, sidecarCompilerOptions({ ...parsed.options, noEmit: true }));
         return { program, checker: program.getTypeChecker(), probesDir };
     }
     catch {

package/sidecar/dist/src/capture/check-workspace.d.ts

@@ -53,3 +53,4 @@ export interface AssembleOptions {
 export declare function assembleWorkspace(opts: AssembleOptions): AssembledWorkspace;
 /** Write the generated probe files into the assembled probes package. */
 export declare function writeProbes(ws: AssembledWorkspace, plans: ProbePlan[]): void;
+export declare const CHECKER_TSCONFIG: string;

package/sidecar/dist/src/capture/check-workspace.js

@@ -195,8 +195,11 @@ const NPMRC = [
 // TS2717 collisions so the poison rule can convert them to honest
 // unverifiables). noUnusedLocals/Parameters:false keep TS6133/6196 off the
 // gate/assignment lines. moduleResolution bundler accepts both node16
-// `.js`-suffixed and extensionless specifiers in one program.
-const CHECKER_TSCONFIG = JSON.stringify({
+// `.js`-suffixed and extensionless specifiers in one program. The rest is
+// what `sidecarCompilerOptions` sets on every other program (carrick#2019):
+// `tsc` reads this file itself, so each value is written out, and a test
+// holds the file to what that function would make of it.
+export const CHECKER_TSCONFIG = JSON.stringify({
     compilerOptions: {
         strict: true,
         exactOptionalPropertyTypes: false,
@@ -210,6 +213,14 @@ const CHECKER_TSCONFIG = JSON.stringify({
         types: [],
         noEmit: true,
         forceConsistentCasingInFileNames: true,
+        esModuleInterop: false,
+        allowSyntheticDefaultImports: true,
+        resolveJsonModule: true,
+        alwaysStrict: true,
+        noUncheckedSideEffectImports: false,
+        libReplacement: true,
+        stableTypeOrdering: true,
+        ignoreDeprecations: '6.0',
     },
     include: ['probes/**/*.ts'],
 }, null, 2) + '\n';

package/sidecar/dist/src/capture/compiler-options.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The options every program the sidecar builds carries (carrick#2019).
+ *
+ * Every `ts.createProgram`, every ts-morph `Project` and the `tsconfig.json`
+ * the check hands to `tsc` goes through `sidecarCompilerOptions`, whatever
+ * its options came from: a project's tsconfig, a snapshot of one, a Deno
+ * config, or the sidecar's own literal set.
+ *
+ * Two things are added:
+ *
+ * - `stableTypeOrdering`. Without it the compiler prints a union's members in
+ *   the order the checker first met them, and an object made by a mapped type
+ *   lists its properties in the order its keys were created, so the same type
+ *   printed text that depended on what the process had read before. With it
+ *   the checker orders types by their content, and one process prints the
+ *   same text whatever it did first.
+ * - TypeScript 5's effective value for every option whose default TypeScript 6
+ *   changed, where the options leave it unset (`typescript5Defaults`). A
+ *   project written against TypeScript 5 is read as its own compiler reads
+ *   it, and as the sidecar read it before it moved to 6. A project that sets
+ *   an option keeps its own value. Several of those values are deprecated in
+ *   TypeScript 6 (target ES5, moduleResolution node10, esModuleInterop false),
+ *   and so are options many projects still set themselves (baseUrl), so
+ *   `ignoreDeprecations` is set too: a deprecated option still works in 6, and
+ *   the error it would raise is not the project's.
+ */
+import ts from 'typescript';
+/**
+ * For each option whose default TypeScript 6 changed and `options` leaves
+ * unset, the value TypeScript 5 (5.9, its last minor) computes for it from
+ * the options that are set. Only unset options appear in the result.
+ */
+export declare function typescript5Defaults(options: ts.CompilerOptions): ts.CompilerOptions;
+/**
+ * `options` with TypeScript 5's defaults filled in and the sidecar's own set.
+ * Takes ts-morph's `CompilerOptions` as well as the compiler's: the two
+ * declare the same option enums separately, and the values are the same.
+ */
+export declare function sidecarCompilerOptions<O extends object>(options: O): O;

package/sidecar/dist/src/capture/compiler-options.js

@@ -0,0 +1,100 @@
+/**
+ * The options every program the sidecar builds carries (carrick#2019).
+ *
+ * Every `ts.createProgram`, every ts-morph `Project` and the `tsconfig.json`
+ * the check hands to `tsc` goes through `sidecarCompilerOptions`, whatever
+ * its options came from: a project's tsconfig, a snapshot of one, a Deno
+ * config, or the sidecar's own literal set.
+ *
+ * Two things are added:
+ *
+ * - `stableTypeOrdering`. Without it the compiler prints a union's members in
+ *   the order the checker first met them, and an object made by a mapped type
+ *   lists its properties in the order its keys were created, so the same type
+ *   printed text that depended on what the process had read before. With it
+ *   the checker orders types by their content, and one process prints the
+ *   same text whatever it did first.
+ * - TypeScript 5's effective value for every option whose default TypeScript 6
+ *   changed, where the options leave it unset (`typescript5Defaults`). A
+ *   project written against TypeScript 5 is read as its own compiler reads
+ *   it, and as the sidecar read it before it moved to 6. A project that sets
+ *   an option keeps its own value. Several of those values are deprecated in
+ *   TypeScript 6 (target ES5, moduleResolution node10, esModuleInterop false),
+ *   and so are options many projects still set themselves (baseUrl), so
+ *   `ignoreDeprecations` is set too: a deprecated option still works in 6, and
+ *   the error it would raise is not the project's.
+ */
+import ts from 'typescript';
+/** Options the sidecar sets on every program, over anything else. */
+const ALWAYS = {
+    stableTypeOrdering: true,
+    ignoreDeprecations: '6.0',
+};
+/**
+ * For each option whose default TypeScript 6 changed and `options` leaves
+ * unset, the value TypeScript 5 (5.9, its last minor) computes for it from
+ * the options that are set. Only unset options appear in the result.
+ */
+export function typescript5Defaults(options) {
+    const fill = {};
+    const { ModuleKind: M, ModuleResolutionKind: R, ScriptTarget: T } = ts;
+    // 5.x ignores ES3 as it ignores no target: both take the default.
+    const statedTarget = options.target === T.ES3 ? undefined : options.target;
+    const target = statedTarget ??
+        (options.module === M.Node16 || options.module === M.Node18
+            ? T.ES2022
+            : options.module === M.Node20
+                ? T.ES2023
+                : options.module === M.NodeNext
+                    ? T.ESNext
+                    : T.ES5);
+    if (statedTarget === undefined)
+        fill.target = target;
+    const module = options.module ?? (target >= T.ES2015 ? M.ES2015 : M.CommonJS);
+    if (options.module === undefined)
+        fill.module = module;
+    const moduleResolution = options.moduleResolution ??
+        (module === M.CommonJS
+            ? R.Node10
+            : module === M.Node16 || module === M.Node18 || module === M.Node20
+                ? R.Node16
+                : module === M.NodeNext
+                    ? R.NodeNext
+                    : module === M.Preserve
+                        ? R.Bundler
+                        : R.Classic);
+    if (options.moduleResolution === undefined)
+        fill.moduleResolution = moduleResolution;
+    const nodeFamily = module === M.Node16 || module === M.Node18 || module === M.Node20 || module === M.NodeNext;
+    const esModuleInterop = options.esModuleInterop ?? (nodeFamily || module === M.Preserve);
+    if (options.esModuleInterop === undefined)
+        fill.esModuleInterop = esModuleInterop;
+    if (options.allowSyntheticDefaultImports === undefined) {
+        fill.allowSyntheticDefaultImports = esModuleInterop || module === M.System || moduleResolution === R.Bundler;
+    }
+    if (options.resolveJsonModule === undefined) {
+        fill.resolveJsonModule = module === M.Node20 || module === M.NodeNext || moduleResolution === R.Bundler;
+    }
+    // Each strict flag a project leaves unset follows `strict`, which was off
+    // unless set; `alwaysStrict` followed it too.
+    if (options.strict === undefined)
+        fill.strict = false;
+    if (options.alwaysStrict === undefined)
+        fill.alwaysStrict = options.strict ?? false;
+    // Every package under each `typeRoots` directory (`@types/*`), not none.
+    if (options.types === undefined)
+        fill.types = ['*'];
+    if (options.noUncheckedSideEffectImports === undefined)
+        fill.noUncheckedSideEffectImports = false;
+    if (options.libReplacement === undefined)
+        fill.libReplacement = true;
+    return fill;
+}
+/**
+ * `options` with TypeScript 5's defaults filled in and the sidecar's own set.
+ * Takes ts-morph's `CompilerOptions` as well as the compiler's: the two
+ * declare the same option enums separately, and the values are the same.
+ */
+export function sidecarCompilerOptions(options) {
+    return { ...options, ...typescript5Defaults(options), ...ALWAYS };
+}

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

@@ -5,6 +5,7 @@ import * as path from 'node:path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
+import { sidecarCompilerOptions } from './compiler-options.js';
 import { rewriteSpecifiers } from './specifiers.js';
 import { WriteGuard } from './guarded-fs.js';
 function readConfig(file) {
@@ -452,11 +453,11 @@ export class DenoProject {
 /** Runtime declarations belong to their producer, not the checker's globals. */
 function isolateRuntime(guard, typesDir, files, runtimeRel) {
     const runtimePath = path.join(typesDir, runtimeRel);
-    const program = ts.createProgram(files.map(file => path.join(typesDir, file)), {
+    const program = ts.createProgram(files.map(file => path.join(typesDir, file)), sidecarCompilerOptions({
         strict: true, skipLibCheck: true, target: ts.ScriptTarget.ESNext,
         module: ts.ModuleKind.ESNext, moduleResolution: ts.ModuleResolutionKind.Bundler,
         types: [],
-    });
+    }));
     const checker = program.getTypeChecker();
     const runtime = program.getSourceFile(runtimePath);
     const retained = new Set();

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 { sidecarCompilerOptions } from './compiler-options.js';
 export { serviceConfigPath } from './project-references.js';
 export { findServiceTsconfig } from './service-config.js';
 export { runCheck } from './check.js';

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

@@ -42,7 +42,9 @@ import { emitsAlike, ProjectGraph } from './project-references.js';
 import { findServiceTsconfig } from './service-config.js';
 import { placeEmittedTree, surfaceModuleInTree } from './outside-root.js';
 import { WriteGuard } from './guarded-fs.js';
+import { sidecarCompilerOptions } from './compiler-options.js';
 export { DenoProject, findDenoConfig } from './deno-project.js';
+export { sidecarCompilerOptions } from './compiler-options.js';
 export { serviceConfigPath } from './project-references.js';
 export { findServiceTsconfig } from './service-config.js';
 // v2 check core ("tsc as the judge"). Same bundle, same seam: the sidecar
@@ -282,7 +284,7 @@ export function captureStub(opts) {
     try {
         progress('emit', 'emitting declarations');
         guard.writeFile(entryPath, entryLines.join('\n') + '\n');
-        const emitOptions = {
+        const emitOptions = sidecarCompilerOptions({
             ...parsed.options,
             // The load-bearing trio: emit declarations without checking, so
             // type-error-laden and bare (no node_modules) checkouts still emit.
@@ -295,7 +297,7 @@ export function captureStub(opts) {
             incremental: false,
             outDir: staging,
             rootDir: entryDir,
-        };
+        });
         written = emitDeclarations({
             rootNames: [entryPath, ...augmentationSources],
             options: emitOptions,
@@ -523,7 +525,7 @@ function emitDeclarations(args) {
     const emitted = new Map();
     const declarationSources = new Map();
     const sourceByEmitted = new Map();
-    const program = ts.createProgram(args.rootNames, args.options, args.host);
+    const program = ts.createProgram(args.rootNames, sidecarCompilerOptions(args.options), args.host);
     const emitResult = program.emit(undefined, (fileName, text, _bom, _error, sources) => {
         emitted.set(fileName, text);
         if (sources?.[0])
@@ -690,10 +692,10 @@ function resolveAnchors(opts, parsed, ctx, deno) {
             ...new Set(opts.anchors
                 .flatMap((a) => (a.source_file ? [path.join(ctx.repoRoot, a.source_file)] : []))),
         ].filter((f) => fs.existsSync(f));
-        const options = {
+        const options = sidecarCompilerOptions({
             ...parsed.options,
             noEmit: true,
-        };
+        });
         const program = ts.createProgram([ctx.entryPath, ...anchorSources, ...(deno?.globals ?? [])], options, deno?.host(options));
         // The checker binds every file of the program when it is first asked for,
         // which the first anchor would otherwise do: asked for here, so that the

package/sidecar/dist/src/capture/installed-package.js

@@ -24,16 +24,17 @@
 import ts from 'typescript';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { sidecarCompilerOptions } from './compiler-options.js';
 import { isPublishedSemver } from './lockfile.js';
 const DECLARATION_SUFFIXES = ['', '.d.ts', '.d.mts', '.d.cts', '.ts', '.mts', '.cts', '/index.d.ts'];
-const RESOLUTION_OPTIONS = {
+const RESOLUTION_OPTIONS = sidecarCompilerOptions({
     module: ts.ModuleKind.ESNext,
     moduleResolution: ts.ModuleResolutionKind.Bundler,
     target: ts.ScriptTarget.ESNext,
     noEmit: true,
     skipLibCheck: true,
     types: [],
-};
+});
 /** DefinitelyTyped packages are imported by the runtime name (TS6137). */
 function publicNameOf(name) {
     if (!name.startsWith('@types/'))

package/sidecar/dist/src/capture/self-check.js

@@ -32,6 +32,7 @@
 import ts from 'typescript';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { sidecarCompilerOptions } from './compiler-options.js';
 import { collectSpecifiers, declarationCandidates, isDeclarationFileName, isRelative, packageNameOf, } from './specifiers.js';
 import { repairDanglingImports } from './repair-dangling.js';
 import { findDisqualifyingTopTypes, findUnresolvedPlaceholders, isErrorPlaceholder, provenanceOf, unemittedModuleProvenance, unresolvedInTreeProvenance, } from './deep-walk.js';
@@ -78,7 +79,7 @@ export function selfCheckStub(args) {
     }
 }
 function runSelfCheck(args, treeFiles, repaired) {
-    const options = {
+    const options = sidecarCompilerOptions({
         noEmit: true,
         strict: true,
         // MUST be false: the whole stub tree is .d.ts (see module header).
@@ -86,7 +87,7 @@ function runSelfCheck(args, treeFiles, repaired) {
         module: ts.ModuleKind.ESNext,
         moduleResolution: ts.ModuleResolutionKind.Bundler,
         types: [],
-    };
+    });
     const program = ts.createProgram(treeFiles, options, args.compilerHost?.(options));
     const checker = program.getTypeChecker();
     const diagnostics = ts.getPreEmitDiagnostics(program);

package/sidecar/dist/src/definition-resolver.js

@@ -35,6 +35,7 @@
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { Project, Node } from 'ts-morph';
+import { sidecarCompilerOptions } from './capture/index.js';
 import { expandTypeStructural, } from './type-structural-expander.js';
 export class DefinitionResolver {
     /**
@@ -57,13 +58,13 @@ export class DefinitionResolver {
         }
         try {
             const stubProject = new Project({
-                compilerOptions: {
+                compilerOptions: sidecarCompilerOptions({
                     target: 99, // ESNext
                     module: 99, // ESNext
                     moduleResolution: 100, // Bundler
                     strict: true,
                     skipLibCheck: true,
-                },
+                }),
                 skipAddingFilesFromTsConfig: true,
             });
             for (const filePath of walkDtsFiles(typesDir)) {

package/sidecar/dist/src/index.js

@@ -28,6 +28,7 @@ import { Retyper } from './retype.js';
 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';
 // ===========================================================================
 // Module-level state
 // ===========================================================================
@@ -46,6 +47,13 @@ let components = new Map();
  * (carrick#1927).
  */
 const definitionResolver = new DefinitionResolver();
+/** The init'd project loader, or the error every project-backed action gives without one. */
+function initializedLoader() {
+    if (!projectLoader?.isInitialized()) {
+        throw new Error('Sidecar not initialized. Call init first.');
+    }
+    return projectLoader;
+}
 /**
  * Get the project-backed components, building the project if this is the
  * first request that needs it.
@@ -53,15 +61,12 @@ const definitionResolver = new DefinitionResolver();
  * @throws if init has not run, or if the project cannot be built
  */
 function projectComponents(key = '') {
-    if (!projectLoader?.isInitialized()) {
-        throw new Error('Sidecar not initialized. Call init first.');
-    }
+    // 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 = initializedLoader();
     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.getProjectFor(key);
         const repoRoot = loader.getRepoRoot();
         // The module graph, where the project resolved through one, is the only
@@ -501,6 +506,55 @@ function handleResolveDefinitions(request) {
         };
     }
 }
+/**
+ * Handle the 'list_program_files' action - the root files the default
+ * project's program was built from, in order (carrick#2027). It is the only
+ * program a request grows: a file a referenced project owns is in that
+ * project's program from its tsconfig, so a program built for an owning
+ * project (carrick#1604) holds the same files in every process. A process
+ * that has not built the default project lists nothing, and does not build
+ * it to answer.
+ */
+function handleListProgramFiles(request) {
+    try {
+        const project = initializedLoader().builtProject();
+        const files = project ? listProgramFiles(project) : [];
+        log(`Listing ${files.length} program file(s)`);
+        return { request_id: request.request_id, status: 'success', files };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        logError(`Listing program files failed: ${error}`);
+        return { request_id: request.request_id, status: 'error', errors: [error] };
+    }
+}
+/**
+ * Handle the 'add_program_files' action - add the given files to the default
+ * project's program in the given order, rebuilding it at most once
+ * (carrick#2027). A file a referenced project owns is skipped, as an `infer`
+ * on it would never add it to this program: its owner's program already holds
+ * it.
+ */
+function handleAddProgramFiles(request) {
+    try {
+        const loader = initializedLoader();
+        const startTime = performance.now();
+        const files = request.files
+            .map((file) => path.resolve(loader.getRepoRoot(), file))
+            .filter((file) => loader.projectKeyFor(file) === '');
+        const added = files.length === 0
+            ? 0
+            : addProgramFiles(loader.getProject(), files, (file, reason) => logError(`Not added to the program: ${file}: ${reason}`));
+        log(`Added ${added} of ${request.files.length} file(s) to the program in ` +
+            `${Math.round(performance.now() - startTime)}ms`);
+        return { request_id: request.request_id, status: 'success', added };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        logError(`Adding program files failed: ${error}`);
+        return { request_id: request.request_id, status: 'error', errors: [error] };
+    }
+}
 /**
  * Handle the 'health' action - report initialization status
  */
@@ -553,6 +607,10 @@ function handleRequest(request) {
             return handleVerifyLibraryClaims(request);
         case 'list_library_surface':
             return handleListLibrarySurface(request);
+        case 'list_program_files':
+            return handleListProgramFiles(request);
+        case 'add_program_files':
+            return handleAddProgramFiles(request);
         case 'health':
             return handleHealth(request);
         case 'shutdown':
@@ -648,6 +706,31 @@ function processLine(line) {
     const response = handleRequest(parseResult.request);
     writeResponse(response);
 }
+/** How often the sidecar looks for the process that started it. */
+const PARENT_CHECK_MS = 1000;
+/**
+ * Exit once the process that started this one is gone (carrick#2029).
+ *
+ * Its death closes stdin, which ends this process, unless another process
+ * still holds the write end. Then the only sign is that this process has a
+ * new parent: whatever adopts it (init, or a subreaper on Linux) has a pid of
+ * its own. So the parent at startup is kept and compared, never 1. A process
+ * already adopted at startup has no parent to watch, and stdin alone decides.
+ *
+ * The timer is unref'd: it never keeps an otherwise finished process alive.
+ * A handler that blocks the event loop holds it off until it returns.
+ */
+function exitWhenParentIsGone() {
+    const startedBy = process.ppid;
+    if (startedBy <= 1)
+        return;
+    setInterval(() => {
+        if (process.ppid !== startedBy) {
+            log(`parent ${startedBy} is gone, exiting`);
+            process.exit(0);
+        }
+    }, PARENT_CHECK_MS).unref();
+}
 /**
  * Start the message loop
  */
@@ -663,6 +746,7 @@ function main() {
         log('stdin closed, exiting');
         process.exit(0);
     });
+    exitWhenParentIsGone();
     // Handle process signals
     process.on('SIGINT', () => {
         log('SIGINT received, exiting');

package/sidecar/dist/src/print-type.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The compiler's own print of a type, with a module the print names written
+ * as the file that declares it (carrick#2019).
+ *
+ * When a type comes from a module the enclosing file does not import, the
+ * compiler writes it as `import("<module>").Name`. TypeScript 5 wrote the
+ * declaring file's path there: the node builder had no module-specifier host
+ * unless a declaration emit gave it one. TypeScript 6 gives every print a
+ * host, so the same type printed at an enclosing node reads
+ * `import("../model").Name` or `import("<package>").Name`: a specifier that
+ * depends on which file it was printed from, so one type printed from two
+ * files gives two texts. Everything downstream reads the declaring file's
+ * path: the scanner's path scrub writes it repo-relative or as
+ * `<package>@<version>`, and a capture pastes an inferred text into its
+ * surface entry, where a specifier relative to another file names nothing.
+ *
+ * These functions run the compiler's own code with no host: a tracker whose
+ * `moduleResolverHost` is `false` (falsy, so the builder writes the declaring
+ * file; not nullish, so the builder does not supply its own). Nothing in the
+ * text is rewritten afterwards. `typeToStringAsDeclared` is the checker's
+ * `typeToString`, step for step, with that one tracker.
+ *
+ * Only prints with an enclosing node differ: with none, the compiler has no
+ * file to write a specifier relative to and writes the declaring file
+ * anyway. A print that must name modules the way a declaration file would
+ * (the capture's surface emit) passes a host of its own and does not use
+ * this.
+ */
+import { ts } from 'ts-morph';
+/**
+ * The compiler's internal `SymbolTracker`: callbacks the node builder reports
+ * to, and the module-specifier host it writes specifiers with.
+ */
+export interface SymbolTracker {
+    moduleResolverHost?: unknown;
+}
+/**
+ * The checker's `typeToTypeNode`, writing each module a node names as the
+ * file that declares it. A caller's own tracker keeps its callbacks.
+ */
+export declare function typeToTypeNodeAsDeclared(checker: ts.TypeChecker, type: ts.Type, enclosing: ts.Node | undefined, flags: ts.NodeBuilderFlags, tracker?: SymbolTracker): ts.TypeNode | undefined;
+/**
+ * The checker's `typeToString(type, enclosing, flags)`, writing each module
+ * the print names as the file that declares it. `noErrorTruncation` is the
+ * program's option of that name, which `typeToString` reads when `flags`
+ * leave truncation on.
+ */
+export declare function typeToStringAsDeclared(checker: ts.TypeChecker, type: ts.Type, enclosing: ts.Node | undefined, flags?: ts.TypeFormatFlags, noErrorTruncation?: boolean): string;