carrick 0.3.107 → 0.3.109

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
@@ -256,7 +258,8 @@ export function captureStub(opts) {
     }
     // ---- Phase A: analysis program over placeholder entry + anchor sources ----
     let resolved;
-    const analysisCtx = { repoRoot, entryDir: path.dirname(entryPath), entryPath, guard };
+    const progress = opts.onProgress ?? (() => { });
+    const analysisCtx = { repoRoot, entryDir: path.dirname(entryPath), entryPath, guard, progress };
     try {
         resolved = ownerGroups && emitProject
             ? resolveAnchorsByOwner(opts, ownerGroups, emitProject, analysisCtx, errors)
@@ -277,16 +280,11 @@ export function captureStub(opts) {
     }
     const scratch = WriteGuard.scratch('carrick-capture-v2-');
     const staging = scratch.dir;
-    const emitted = new Map();
-    // Input .d.ts files (ambient stubs, augmentation declarations, local
-    // hand-written declarations in the import closure) are never re-emitted by
-    // tsc; they must ship verbatim or the tree's references to them dangle.
-    const declarationSources = new Map();
-    const sourceByEmitted = new Map();
-    let emitPartial = false;
+    let written;
     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.
@@ -299,36 +297,14 @@ export function captureStub(opts) {
             incremental: false,
             outDir: staging,
             rootDir: entryDir,
-        };
-        const program = ts.createProgram([entryPath, ...augmentationSources], emitOptions, deno?.host(emitOptions));
-        const emitResult = program.emit(undefined, (fileName, text, _bom, _error, sources) => {
-            emitted.set(fileName, text);
-            if (sources?.[0])
-                sourceByEmitted.set(path.relative(staging, fileName).split(path.sep).join('/'), sources[0].fileName);
-        }, undefined, 
-        /* emitOnlyDtsFiles */ true);
-        // emitSkipped is PER-PROGRAM even when only one file's declaration emit
-        // failed (e.g. TS4023 from a hand-rolled ambient stub shadowing a real
-        // package): every other file's .d.ts was still written to the callback.
-        // Fail wholesale only when nothing at all emitted; otherwise keep the
-        // emitted subset and demote exactly the aliases it cannot support.
-        if (emitResult.emitSkipped && emitted.size === 0) {
-            return fail(stubDir, packageName, ['declaration emit was skipped']);
-        }
-        emitPartial = emitResult.emitSkipped;
-        for (const d of emitResult.diagnostics) {
-            errors.push(ts.flattenDiagnosticMessageText(d.messageText, '\n'));
-        }
-        for (const sourceFile of program.getSourceFiles()) {
-            if (!sourceFile.isDeclarationFile)
-                continue;
-            const abs = path.resolve(sourceFile.fileName);
-            const rel = path.relative(entryDir, abs).split(path.sep).join('/');
-            if (rel.startsWith('..') || rel.includes('node_modules/'))
-                continue;
-            declarationSources.set(rel, sourceFile.getFullText());
-            sourceByEmitted.set(rel, abs);
-        }
+        });
+        written = emitDeclarations({
+            rootNames: [entryPath, ...augmentationSources],
+            options: emitOptions,
+            host: deno?.host(emitOptions),
+            staging,
+            entryDir,
+        });
     }
     catch (err) {
         return fail(stubDir, packageName, [err instanceof Error ? err.message : String(err)]);
@@ -338,6 +314,9 @@ export function captureStub(opts) {
             guard.unlink(entryPath);
         scratch.guard.remove(staging);
     }
+    const { emitted, declarationSources, sourceByEmitted } = written;
+    const emitPartial = written.partial;
+    errors.push(...written.diagnostics);
     // ---- Partial-emit recovery ----
     // The corpus-2 notifications-svc shape: one file's declaration emit was
     // skipped but the rest of the tree emitted fine. Keep the tree; demote any
@@ -490,6 +469,7 @@ export function captureStub(opts) {
         target: parsed.options.target !== undefined ? ts.ScriptTarget[parsed.options.target] : undefined,
     }, null, 2) + '\n');
     // ---- Capture-time self-check (per-alias closure attribution) ----
+    progress('self-check', 'checking the stub');
     const aliases = selfCheckStub({
         guard: stubGuard,
         stubDir,
@@ -526,6 +506,58 @@ export function captureStub(opts) {
         errors,
     };
 }
+/**
+ * Phase B: build the program of the final entry and emit its declarations.
+ *
+ * A function of its own so that its program dies with it (carrick#1916). The
+ * program is as large as the service, and nothing after the emit reads it:
+ * what the capture needs is the text returned here. While the emit ran inside
+ * `captureStub`, that one long function's frame went on holding the program
+ * for as long as the capture ran, so the self-check loaded its own program
+ * beside it; on a 2,345-file service that was 1,290 MB of a 2,741 MB peak.
+ *
+ * The caller builds the options and the host. A host is held by its program
+ * and holds none itself, so the caller keeping one keeps no program alive.
+ *
+ * Throws when the emit was skipped and wrote nothing.
+ */
+function emitDeclarations(args) {
+    const emitted = new Map();
+    const declarationSources = new Map();
+    const sourceByEmitted = new Map();
+    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])
+            sourceByEmitted.set(path.relative(args.staging, fileName).split(path.sep).join('/'), sources[0].fileName);
+    }, undefined, 
+    /* emitOnlyDtsFiles */ true);
+    // emitSkipped is PER-PROGRAM even when only one file's declaration emit
+    // failed (e.g. TS4023 from a hand-rolled ambient stub shadowing a real
+    // package): every other file's .d.ts was still written to the callback.
+    // Fail wholesale only when nothing at all emitted; otherwise keep the
+    // emitted subset and demote exactly the aliases it cannot support.
+    if (emitResult.emitSkipped && emitted.size === 0) {
+        throw new Error('declaration emit was skipped');
+    }
+    for (const sourceFile of program.getSourceFiles()) {
+        if (!sourceFile.isDeclarationFile)
+            continue;
+        const abs = path.resolve(sourceFile.fileName);
+        const rel = path.relative(args.entryDir, abs).split(path.sep).join('/');
+        if (rel.startsWith('..') || rel.includes('node_modules/'))
+            continue;
+        declarationSources.set(rel, sourceFile.getFullText());
+        sourceByEmitted.set(rel, abs);
+    }
+    return {
+        emitted,
+        declarationSources,
+        sourceByEmitted,
+        partial: emitResult.emitSkipped,
+        diagnostics: emitResult.diagnostics.map((d) => ts.flattenDiagnosticMessageText(d.messageText, '\n')),
+    };
+}
 /**
  * Partial-emit demotion: demote every anchor whose alias text names, by a
  * relative or an absolute path, a module the stub will not resolve, and
@@ -655,15 +687,21 @@ function resolveAnchors(opts, parsed, ctx, deno) {
     }
     ctx.guard.writeFile(ctx.entryPath, placeholderLines.join('\n') + '\n');
     try {
+        ctx.progress('program', 'building the program the anchors are read in');
         const anchorSources = [
             ...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
+        // report below says the program is whole before any anchor is read.
+        program.getTypeChecker();
+        ctx.progress('anchors', `0 of ${opts.anchors.length}`);
         const entrySource = program.getSourceFile(ctx.entryPath);
         const placeholders = new Map();
         if (entrySource) {
@@ -696,13 +734,17 @@ function resolveAnchors(opts, parsed, ctx, deno) {
                 siblingSymbolSpecs.set(anchor.symbol_name, entryRelativeSpecifier(ctx.entryDir, ctx.repoRoot, anchor.source_file, resolveFromEntry));
             }
         }
-        return opts.anchors.map((request) => resolveAnchor(program, request, {
-            repoRoot: ctx.repoRoot,
-            entryDir: ctx.entryDir,
-            placeholder: placeholders.get(request.alias),
-            siblingSymbolSpecs,
-            resolveFromEntry,
-        }));
+        return opts.anchors.map((request, index) => {
+            const anchor = resolveAnchor(program, request, {
+                repoRoot: ctx.repoRoot,
+                entryDir: ctx.entryDir,
+                placeholder: placeholders.get(request.alias),
+                siblingSymbolSpecs,
+                resolveFromEntry,
+            });
+            ctx.progress('anchors', `${index + 1} of ${opts.anchors.length}`);
+            return anchor;
+        });
     }
     finally {
         if (fs.existsSync(ctx.entryPath))

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.d.ts

@@ -26,11 +26,12 @@
  * inference path in `type-inferrer.ts`), which walks the resolved `Type` and
  * rebuilds the inlined text.
  *
- * Each resolve call builds its own throwaway in-memory project over the stub
- * tree, so the warm sidecar's long-lived project never sees stub files and
- * cannot accumulate stale trees across requests.
+ * Each resolve call builds its own throwaway project over the stub tree and
+ * reads nothing else: not the service's project, and not whether the sidecar
+ * was ever initialised. So the request costs what the stub costs, in a process
+ * that has built nothing as in one that has (carrick#1927), and the sidecar's
+ * long-lived project never sees stub files.
  */
-import { Project } from 'ts-morph';
 export interface ResolvedDefinition {
     type_alias: string;
     /** Original declaration text as written (preserves named types) */
@@ -39,10 +40,6 @@ export interface ResolvedDefinition {
     expanded: string;
 }
 export declare class DefinitionResolver {
-    private readonly project;
-    constructor(options: {
-        project: Project;
-    });
     /**
      * Resolve surface aliases from a capture stub package directory
      * (`<stub_dir>/types/surface.d.ts` + its declaration tree).

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

@@ -26,19 +26,18 @@
  * inference path in `type-inferrer.ts`), which walks the resolved `Type` and
  * rebuilds the inlined text.
  *
- * Each resolve call builds its own throwaway in-memory project over the stub
- * tree, so the warm sidecar's long-lived project never sees stub files and
- * cannot accumulate stale trees across requests.
+ * Each resolve call builds its own throwaway project over the stub tree and
+ * reads nothing else: not the service's project, and not whether the sidecar
+ * was ever initialised. So the request costs what the stub costs, in a process
+ * that has built nothing as in one that has (carrick#1927), and the sidecar's
+ * long-lived project never sees stub files.
  */
 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 {
-    project;
-    constructor(options) {
-        this.project = options.project;
-    }
     /**
      * Resolve surface aliases from a capture stub package directory
      * (`<stub_dir>/types/surface.d.ts` + its declaration tree).
@@ -59,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

@@ -27,6 +27,8 @@ import { captureStub, findDisqualifyingTopTypes, jsonWireDeclarations, runCheck,
 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
 // ===========================================================================
@@ -38,6 +40,20 @@ let initTimeMs = null;
  * the service's files (carrick#1604).
  */
 let components = new Map();
+/**
+ * Reads a capture stub's own declaration tree and nothing of the init'd
+ * project, so it is not one of the project's components: taking it from them
+ * would build the service's whole program to answer about the stub
+ * (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.
@@ -45,15 +61,12 @@ let components = new Map();
  * @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
@@ -67,7 +80,6 @@ function projectComponents(key = '') {
         built = {
             typeBundler: new TypeBundler({ project, repoRoot }),
             typeInferrer,
-            definitionResolver: new DefinitionResolver({ project }),
             // Locates calls exactly as `infer` does, so it rewrites the node the
             // consumer's published type came from (carrick#1491).
             // The walk is typed against the capture bundle's compiler copy and
@@ -218,6 +230,10 @@ function handleBundle(request) {
 function handleCaptureV2(request) {
     try {
         log(`capture_v2 for service '${request.service_name}' (${request.anchors.length} anchor(s))`);
+        // A frame for each stage as the capture reaches it, and within a stage
+        // (one report per anchor) at most one per interval.
+        let stage;
+        const withinStage = atMostEvery(PROGRESS_INTERVAL_MS, (phase, message) => writeProgress(request.request_id, phase, message));
         const result = captureStub({
             repoRoot: request.repo_root,
             serviceName: request.service_name,
@@ -225,6 +241,12 @@ function handleCaptureV2(request) {
             outDir: request.out_dir,
             tsconfigPath: request.tsconfig_path,
             scanRoot: request.scan_root,
+            onProgress: (phase, message) => {
+                if (phase === stage)
+                    return withinStage(phase, message);
+                stage = phase;
+                writeProgress(request.request_id, phase, message);
+            },
         });
         return {
             request_id: request.request_id,
@@ -316,6 +338,9 @@ function handleInfer(request) {
             request_id: request.request_id,
             status: result.success ? 'success' : 'error',
             inferred_types: result.inferred_types,
+            // Beside the answers and never in them: what the requests cost, for
+            // the caller's log (carrick#1985).
+            infer_timing: mergeInferTimings(results.map((r) => r.timing)),
             errors: result.errors,
         };
     }
@@ -345,11 +370,19 @@ function handleRetypeCheck(request) {
         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);
+        // One count for the request, whichever programs its items span, reported
+        // as `infer` reports its batch (carrick#1914, carrick#1945).
+        let judged = 0;
+        const report = atMostEvery(PROGRESS_INTERVAL_MS, () => writeProgress(request.request_id, 'retype', `${judged} of ${request.items.length}`));
+        const onJudged = () => {
+            judged += 1;
+            report();
+        };
         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)
+                .retyper.run(entries.map(({ item }) => item), remaining, onJudged)
                 .forEach((outcome, position) => {
                 outcomes[entries[position].index] = outcome;
             });
@@ -446,12 +479,13 @@ function handleListLibrarySurface(request) {
 }
 /**
  * Handle the 'resolve_definitions' action - resolve surface aliases from a
- * v2 capture stub package's declaration tree.
+ * v2 capture stub package's declaration tree. Stateless, as `capture_v2` is:
+ * it needs no init and builds no project but the stub's own.
  */
 function handleResolveDefinitions(request) {
     try {
         log(`Resolving ${request.aliases.length} type alias(es) from ${request.stub_dir}`);
-        const results = projectComponents().definitionResolver.resolveFromStub(request.stub_dir, request.aliases);
+        const results = definitionResolver.resolveFromStub(request.stub_dir, request.aliases);
         return {
             request_id: request.request_id,
             status: 'success',
@@ -472,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
  */
@@ -524,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':
@@ -619,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
  */
@@ -634,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/infer-timing.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Which requests of an `infer` batch were slow, and at what (carrick#1985).
+ *
+ * A pass can send thousands of requests and spend most of its time in a few
+ * of them. The inferrer times every request; this module turns those timings
+ * into what the batch's answer carries: how many there were and what they
+ * add up to, the slowest few by name, the request that printed the longest
+ * type, and the requests that were the first asked of their file, apart.
+ *
+ * A request's time is also told apart by what it went on: the compiler call
+ * that computes the type, and the print of that type to text. The two have
+ * different remedies, and a printed length alone cannot say which one a slow
+ * request was: a type of four characters can take seconds to compute, and a
+ * type of a million can take half a second to print.
+ *
+ * It measures and names. It changes no answer and holds no type text.
+ */
+import type { InferSlotTiming, InferTiming } from './types.js';
+/**
+ * How many of its slowest requests a batch's answer names.
+ *
+ * Enough for a reader adding batches up to say what the slowest hundredth of
+ * a whole pass took: a pass's slowest requests are among its batches'
+ * slowest, and the last one a batch names is the most any it left out can
+ * have taken.
+ */
+export declare const SLOWEST_SLOTS = 25;
+/** How long something that started at `startedMs` has taken by `nowMs`. */
+export declare function elapsedMs(startedMs: number, nowMs: number): number;
+/**
+ * The parts of a request's time that are told apart: `type` is the compiler
+ * call that computes a type, `print` is the print of a type to text.
+ */
+export type TimedPhase = 'type' | 'print';
+/**
+ * Run `work`, and count how long it took as `phase`.
+ *
+ * The count is the process's, not a request's: whoever wants one request's
+ * share reads `phaseClock` before the request and after it. One request runs
+ * at a time, so the difference is that request's and nobody else's.
+ */
+export declare function timedPhase<T>(phase: TimedPhase, work: () => T): T;
+/** What each phase has come to so far, in milliseconds. */
+export declare function phaseClock(): Readonly<Record<TimedPhase, number>>;
+/**
+ * What a batch's answer says of the time its requests took. `slots` holds one
+ * timing per request, in the order the batch was done with them.
+ */
+export declare function inferTiming(slots: readonly InferSlotTiming[]): InferTiming;
+/**
+ * One timing for a request several projects answered, each with its own:
+ * the counts and the times added up, and the slowest of all of them.
+ */
+export declare function mergeInferTimings(parts: readonly InferTiming[]): InferTiming;