carrick 0.3.108 → 0.3.110

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.108",
+  "version": "0.3.110",
   "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.110",
+    "@carrick-tools/cli-darwin-x64": "0.3.110",
+    "@carrick-tools/cli-linux-arm64": "0.3.110",
+    "@carrick-tools/cli-linux-x64": "0.3.110",
+    "@carrick-tools/cli-win32-x64": "0.3.110"
   },
   "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.110",
   "author": {
     "name": "Carrick",
     "email": "hello@carrick.tools"

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

@@ -50,6 +50,16 @@ export declare class TypeBundler {
      */
     private expandOrigin;
     private extractTypeDefinition;
+    /**
+     * carrick#1841: what a consumer receives when the symbol the model named for
+     * its response is a response table keyed by status code (`{ 200: Item;
+     * 404: Problem }`): the table's 2xx values, expanded like any other body.
+     * `unknown` where the table states no success body (no 2xx row, or only
+     * rows such as `204: void`). `undefined` when the symbol is not a table, so
+     * the caller bundles it as written. The capture's symbol anchor reads the
+     * same rule (`capture/anchors.ts`), so both answers agree.
+     */
+    private statusTableBodyText;
     private elementNeedsArrayParens;
     private extractTypeDefinitionBase;
     private isPathSource;

package/sidecar/dist/src/bundler.js

@@ -7,6 +7,7 @@ import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { expandTypeStructural, } from './type-structural-expander.js';
 import { externalImportsOf } from './origin.js';
+import { statusTableBody } from './capture/index.js';
 /**
  * #248: upper bound on `SymbolRequest.array_depth`. SDL list nesting is
  * realistically 1-3 levels (`[Order!]!`, at most `[[Order!]!]!`); this is a
@@ -301,6 +302,17 @@ export class TypeBundler {
         };
     }
     extractTypeDefinition(symbol) {
+        const tableBody = symbol.consumer_response ? this.statusTableBodyText(symbol) : undefined;
+        if (tableBody !== undefined) {
+            const alias = symbol.alias || symbol.symbol_name;
+            const depth = symbol.array_depth ?? 0;
+            if (depth > MAX_ARRAY_DEPTH)
+                return null;
+            const typeString = depth > 0 && tableBody !== 'unknown'
+                ? `(${tableBody})${'[]'.repeat(depth)}`
+                : tableBody;
+            return { definition: `export type ${alias} = ${typeString};`, typeString };
+        }
         const base = this.extractTypeDefinitionBase(symbol);
         if (!base)
             return null;
@@ -338,6 +350,36 @@ export class TypeBundler {
         const typeString = `${element}${'[]'.repeat(depth)}`;
         return { definition: `export type ${alias} = ${typeString};`, typeString };
     }
+    /**
+     * carrick#1841: what a consumer receives when the symbol the model named for
+     * its response is a response table keyed by status code (`{ 200: Item;
+     * 404: Problem }`): the table's 2xx values, expanded like any other body.
+     * `unknown` where the table states no success body (no 2xx row, or only
+     * rows such as `204: void`). `undefined` when the symbol is not a table, so
+     * the caller bundles it as written. The capture's symbol anchor reads the
+     * same rule (`capture/anchors.ts`), so both answers agree.
+     */
+    statusTableBodyText(symbol) {
+        const site = this.siteOf(symbol);
+        if (!site)
+            return undefined;
+        const declaration = site.sourceFile.getTypeAlias(site.name) ?? site.sourceFile.getInterface(site.name);
+        if (!declaration)
+            return undefined;
+        const table = declaration.getType();
+        const checker = this.project.getTypeChecker().compilerObject;
+        const read = statusTableBody(checker, table.compilerType, declaration.compilerNode);
+        if (!read)
+            return undefined;
+        if (read.kind === 'no_body')
+            return 'unknown';
+        const bodies = read.entries.map((entry) => {
+            const value = table.getProperty(entry.key)?.getTypeAtLocation(declaration);
+            return value ? expandTypeStructural(value, this.expandOrigin()) : 'unknown';
+        });
+        const distinct = [...new Set(bodies)];
+        return distinct.length === 1 ? distinct[0] : distinct.map((body) => `(${body})`).join(' | ');
+    }
     /// Whether the element type must be parenthesised before an `[]` suffix.
     /// Interfaces/classes/enums are always object/nominal (never a top-level
     /// union), so only type aliases and typed variables can carry a bare

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

@@ -10,6 +10,7 @@ import { printTypeForDestination, substituteUndeclaredNames, undeclaredNamesIn,
 import { typeIsOrContainsMachinery } from './machinery.js';
 import { installedPackageSpecifier } from './installed-package.js';
 import { realPath } from './service-config.js';
+import { statusTableBody } from './status-table.js';
 import { unresolvedAtAnchor, unresolvedSpecifiersReachableFrom, } from './unresolved.js';
 /**
  * Repo-root-relative source file -> the specifier the surface entry imports
@@ -155,6 +156,37 @@ export function resolveAnchor(program, request, args) {
         }
         const arrayDepth = Math.max(0, request.array_depth ?? 0);
         const declared = checker.getDeclaredTypeOfSymbol(resolvedExport);
+        // carrick#1841: a symbol named for what a consumer receives that is a
+        // response table keyed by status code (`{ 200: Item; 404: Problem }`) is
+        // not the body. The body is its 2xx rows, indexed out of the table so the
+        // compiler still emits it (`import('./m').Table[200]`). A table with no
+        // success body abstains, decided. The v1 bundle reads the same rule
+        // (`TypeBundler.statusTableBodyText`).
+        if (request.consumer_response) {
+            const table = statusTableBody(checker, declared, resolvedExport.declarations?.[0] ?? sourceFile);
+            if (table?.kind === 'no_body') {
+                return {
+                    request,
+                    aliasText: 'unknown',
+                    serialization: 'structural_fallback',
+                    abstainReason: `'${request.symbol_name}' is a response table keyed by status code with no ` +
+                        'success row that states a body, so this consumer states no response contract',
+                };
+            }
+            if (table?.kind === 'body') {
+                const rows = [...new Set(table.entries.map((entry) => entry.key))].map((key) => /^\d+$/.test(key)
+                    ? `import('${spec}').${request.symbol_name}[${key}]`
+                    : `import('${spec}').${request.symbol_name}[${JSON.stringify(key)}]`);
+                const body = rows.join(' | ');
+                const unresolvedBody = unresolvedAtAnchor(program, sourceFile, declared, resolvedExport.declarations?.[0] ?? sourceFile, '<0>'.repeat(arrayDepth));
+                return {
+                    request,
+                    aliasText: arraySuffix && rows.length > 1 ? `(${body})${arraySuffix}` : `${body}${arraySuffix}`,
+                    serialization: 'emitted',
+                    ...(unresolvedBody ? { unresolved: unresolvedBody } : {}),
+                };
+            }
+        }
         const unresolved = unresolvedAtAnchor(program, sourceFile, declared, resolvedExport.declarations?.[0] ?? sourceFile, '<0>'.repeat(arrayDepth));
         return {
             request,

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

@@ -50,6 +50,11 @@ export interface SymbolAnchorRequest {
      * `import('./m').Sym[]`. Omitted/0 captures the symbol as-is.
      */
     array_depth?: number;
+    /**
+     * carrick#1841: the symbol names what a consumer receives, so a response
+     * table keyed by status code captures as its 2xx body, not as the table.
+     */
+    consumer_response?: boolean;
 }
 /**
  * Inline literal type text with no addressable symbol (the v1 inline-alias

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

@@ -15,6 +15,7 @@
 import type { CheckStubInput } from './api.js';
 import type { ProbePlan } from './check-probe.js';
 import { WriteGuard } from './guarded-fs.js';
+import { type ResolutionEdges } from './resolution-edges.js';
 export interface AssembledStub {
     serviceName: string;
     /** Workspace package dir under packages/ (== the @carrick/<dir> suffix). */
@@ -45,6 +46,15 @@ export interface AssembledWorkspace {
 export declare function computeDedupeOverrides(stubs: {
     dependencies: Record<string, string>;
 }[]): Record<string, string>;
+/**
+ * pnpm parent-scoped overrides (`<parent>@<version>><child>`) that install
+ * each edge the stubs recorded at the version the scanned repo installed
+ * (carrick#2091). A parent-scoped override wins over a generic one, so an
+ * edge's version first passes through the dedupe table: one physical copy per
+ * compat group still holds. An edge two stubs record at versions the dedupe
+ * does not reconcile is left to the resolver.
+ */
+export declare function computeResolutionOverrides(edgeSets: ResolutionEdges[], dedupe: Record<string, string>): Record<string, string>;
 export interface AssembleOptions {
     stubs: CheckStubInput[];
     workspaceRoot?: string;
@@ -53,3 +63,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

@@ -15,6 +15,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { WriteGuard } from './guarded-fs.js';
+import { RESOLUTION_FILE } from './resolution-edges.js';
 const PROBES_PACKAGE = 'carrick-probes';
 function parseVersion(v) {
     const core = v.replace(/^[^\d]*/, '').split('-')[0].split('+')[0];
@@ -90,6 +91,57 @@ export function computeDedupeOverrides(stubs) {
         .sort()
         .map((k) => [k, overrides[k]]));
 }
+/** A stub's recorded edges; a stub stored without the file records none. */
+function readStubResolution(stubDir) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(path.join(stubDir, RESOLUTION_FILE), 'utf8'));
+    }
+    catch {
+        return {};
+    }
+    const edges = parsed?.edges;
+    if (!edges || typeof edges !== 'object')
+        return {};
+    const out = {};
+    for (const [parent, children] of Object.entries(edges)) {
+        if (!children || typeof children !== 'object')
+            continue;
+        for (const [child, version] of Object.entries(children)) {
+            if (typeof version === 'string')
+                (out[parent] ??= {})[child] = version;
+        }
+    }
+    return out;
+}
+/**
+ * pnpm parent-scoped overrides (`<parent>@<version>><child>`) that install
+ * each edge the stubs recorded at the version the scanned repo installed
+ * (carrick#2091). A parent-scoped override wins over a generic one, so an
+ * edge's version first passes through the dedupe table: one physical copy per
+ * compat group still holds. An edge two stubs record at versions the dedupe
+ * does not reconcile is left to the resolver.
+ */
+export function computeResolutionOverrides(edgeSets, dedupe) {
+    const versionsOf = new Map();
+    for (const edges of edgeSets) {
+        for (const [parent, children] of Object.entries(edges)) {
+            for (const [child, version] of Object.entries(children)) {
+                const key = `${parent}>${child}`;
+                if (!versionsOf.has(key))
+                    versionsOf.set(key, new Set());
+                versionsOf.get(key).add(dedupe[`${child}@${version}`] ?? version);
+            }
+        }
+    }
+    const overrides = {};
+    for (const key of [...versionsOf.keys()].sort()) {
+        const versions = versionsOf.get(key);
+        if (versions.size === 1)
+            overrides[key] = [...versions][0];
+    }
+    return overrides;
+}
 function readStubPackageName(stubDir) {
     const pkgPath = path.join(stubDir, 'package.json');
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
@@ -116,6 +168,7 @@ export function assembleWorkspace(opts) {
     guard.writeFile(path.join(workspaceDir, 'pnpm-workspace.yaml'), 'packages:\n  - "packages/*"\n');
     const assembled = [];
     const dependencySets = [];
+    const edgeSets = [];
     const svcToPkg = new Map();
     const dirToPkg = new Map();
     const dirToSvc = new Map();
@@ -126,12 +179,20 @@ export function assembleWorkspace(opts) {
         guard.copyTree(stub.stub_dir, dest, (src) => !src.split(path.sep).includes('node_modules'));
         assembled.push({ serviceName: stub.service_name, packageDir, packageName });
         dependencySets.push({ dependencies: readStubDependencies(stub.stub_dir) });
+        edgeSets.push(readStubResolution(stub.stub_dir));
         svcToPkg.set(stub.service_name, packageName);
         dirToPkg.set(packageDir, packageName);
         dirToSvc.set(packageDir, stub.service_name);
     }
-    // Root manifest carries the semver-dedupe overrides.
-    const overrides = computeDedupeOverrides(dependencySets);
+    // Root manifest carries the semver-dedupe overrides and the recorded edges.
+    const dedupe = computeDedupeOverrides(dependencySets);
+    const merged = {
+        ...dedupe,
+        ...computeResolutionOverrides(edgeSets, dedupe),
+    };
+    const overrides = Object.fromEntries(Object.keys(merged)
+        .sort()
+        .map((k) => [k, merged[k]]));
     guard.writeFile(path.join(workspaceDir, 'package.json'), JSON.stringify({
         name: 'carrick-check-workspace',
         version: '0.0.0',
@@ -181,12 +242,13 @@ const NPMRC = [
     'strict-peer-dependencies=false',
     // Determinism: install exactly the pinned closure, no implicit peer pull-in.
     'auto-install-peers=false',
-    // Determinism: the scratch workspace has no committed lockfile, so the
-    // transitive closure would otherwise be a pure function of live registry
-    // state. prefer-offline resolves from the local store/metadata cache
+    // Determinism: the scratch workspace has no committed lockfile. Direct deps
+    // are exact-pinned by the stubs, and every transitive edge a stub recorded
+    // from the scanned repo's installed tree is pinned by a parent-scoped
+    // override in the root manifest. Only unrecorded edges resolve, and for
+    // those prefer-offline resolves from the local store/metadata cache
     // whenever possible (byte-stable across runs on a host), and the explicit
     // resolution-mode pins pnpm's resolver behavior across pnpm versions.
-    // Direct deps are exact-pinned by the stubs; only transitives resolve.
     'prefer-offline=true',
     'resolution-mode=highest',
     '',
@@ -195,8 +257,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 +275,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';
@@ -58,3 +59,4 @@ export declare function surfaceEntryFileName(): string;
 /** Same normalization intent as bundle_file_stems on the Rust side. */
 export declare function sanitizeServiceName(name: string): string;
 export declare function captureStub(opts: CaptureStubOptions): CaptureStubResult;
+export { classifyStatusCodes, constituents, httpStatus, statesNoBody, statusKeyCode, statusTableBody, statusTableOf, successEntries, } from './status-table.js';

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

@@ -33,6 +33,7 @@ import * as path from 'node:path';
 import { entryRelativeSpecifier, resolveAnchor } from './anchors.js';
 import { findAugmentationFiles } from './augmentations.js';
 import { installedVersions, lockfileVersions } from './lockfile.js';
+import { installedResolutionEdges, RESOLUTION_FILE } from './resolution-edges.js';
 import { rewriteEmittedSpecifiers } from './paths-rewrite.js';
 import { installedPackageSpecifier, typesPackageOf, withInstalledPackages } from './installed-package.js';
 import { selfCheckStub } from './self-check.js';
@@ -42,7 +43,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 +285,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 +298,7 @@ export function captureStub(opts) {
             incremental: false,
             outDir: staging,
             rootDir: entryDir,
-        };
+        });
         written = emitDeclarations({
             rootNames: [entryPath, ...augmentationSources],
             options: emitOptions,
@@ -426,9 +429,8 @@ export function captureStub(opts) {
     // repos whose lockfiles we do not parse (yarn classic v1, binary
     // bun.lockb). The parsed lockfile (npm, pnpm, yarn-berry, text bun.lock)
     // remains the bare-checkout fallback. Both paths pin only
-    // the directly-referenced externals; transitives resolve at check-install
-    // (check-workspace NPMRC: "Direct deps are exact-pinned by the stubs;
-    // only transitives resolve").
+    // the directly-referenced externals; what those depend on is recorded
+    // from the installed tree below (RESOLUTION_FILE).
     const installed = installedVersions(repoRoot, externalSpecs);
     const lockVersions = lockfileVersions(repoRoot);
     for (const name of Object.keys(deno?.pinned ?? {}))
@@ -449,6 +451,18 @@ export function captureStub(opts) {
         else if (!rewritten.pins[typesPackageOf(name)])
             unpinned.push(name);
     }
+    // ---- Record how the installed tree resolved what the pins depend on ----
+    // The check pins each recorded edge, so it installs what the repo
+    // installed rather than the newest version in range (carrick#2091).
+    const resolution = deno
+        ? { edges: {}, unrecorded: 0 }
+        : installedResolutionEdges(repoRoot, pinned);
+    const edgeCount = Object.values(resolution.edges).reduce((n, children) => n + Object.keys(children).length, 0);
+    if (edgeCount > 0) {
+        stubGuard.writeFile(path.join(stubDir, RESOLUTION_FILE), JSON.stringify({ edges: resolution.edges }, null, 2) + '\n');
+    }
+    console.error(`[sidecar] capture ${packageName}: ${edgeCount} dependency edge(s) recorded from the installed tree, ` +
+        `${resolution.unrecorded} left to the registry`);
     const dependencyRoot = deno?.config.workspaceRoot ?? repoRoot;
     const bareCheckout = !deno && !fs.existsSync(path.join(dependencyRoot, 'node_modules'));
     stubGuard.writeFile(path.join(stubDir, 'package.json'), JSON.stringify({
@@ -523,7 +537,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 +704,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
@@ -749,3 +763,6 @@ function resolveAnchors(opts, parsed, ctx, deno) {
             ctx.guard.unlink(ctx.entryPath);
     }
 }
+// carrick#1841: the response-table reading the inferrer and the v1 bundle
+// share with the capture's symbol anchor.
+export { classifyStatusCodes, constituents, httpStatus, statesNoBody, statusKeyCode, statusTableBody, statusTableOf, successEntries, } from './status-table.js';