carrick 0.3.77 → 0.3.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.77",
+  "version": "0.3.79",
   "description": "The API contract index for a TypeScript workspace: what the other services do with the routes and calls in the file you are editing, in your editor and in your agent's context",
   "keywords": [
     "typescript",
@@ -57,11 +57,11 @@
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "@carrick-tools/cli-darwin-arm64": "0.3.77",
-    "@carrick-tools/cli-darwin-x64": "0.3.77",
-    "@carrick-tools/cli-linux-arm64": "0.3.77",
-    "@carrick-tools/cli-linux-x64": "0.3.77",
-    "@carrick-tools/cli-win32-x64": "0.3.77"
+    "@carrick-tools/cli-darwin-arm64": "0.3.79",
+    "@carrick-tools/cli-darwin-x64": "0.3.79",
+    "@carrick-tools/cli-linux-arm64": "0.3.79",
+    "@carrick-tools/cli-linux-x64": "0.3.79",
+    "@carrick-tools/cli-win32-x64": "0.3.79"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",

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

@@ -162,7 +162,7 @@ export function resolveAnchor(program, request, args) {
             return demote(`no handler parameter '${request.param_name}' resolved in ` +
                 `${request.source_file} (${paramLocatorHints(request)})`);
         }
-        return finishInferAnchor(program, sourceFile, request, param, args.placeholder, undefined);
+        return finishInferAnchor(program, sourceFile, request, param, args.placeholder, undefined, args.repoRoot);
     }
     let located = locateNode(sourceFile, request);
     if (!located) {
@@ -187,7 +187,7 @@ export function resolveAnchor(program, request, args) {
         located = builderReaim.node;
         reaimNote = builderReaim.note;
     }
-    return finishInferAnchor(program, sourceFile, request, located, args.placeholder, reaimNote);
+    return finishInferAnchor(program, sourceFile, request, located, args.placeholder, reaimNote, args.repoRoot);
 }
 /**
  * Shared tail of the infer paths (locator-resolved node and #498
@@ -195,7 +195,7 @@ export function resolveAnchor(program, request, args) {
  * transport layer, run the #433 recovery and the carrick#371 machinery guard,
  * and print through the node builder.
  */
-function finishInferAnchor(program, sourceFile, request, located, placeholder, reaimNote) {
+function finishInferAnchor(program, sourceFile, request, located, placeholder, reaimNote, repoRoot) {
     const checker = program.getTypeChecker();
     const demote = (reason) => ({
         request,
@@ -265,7 +265,7 @@ function finishInferAnchor(program, sourceFile, request, located, placeholder, r
     // type. No source locator points at a distinct clean payload here (the payload
     // lives inside the wrapper's response builder), so degrade to `unknown` —
     // abstain, never a concrete verdict off the machinery.
-    if (typeIsOrContainsMachinery(checker, type, located)) {
+    if (typeIsOrContainsMachinery(program, type, located, repoRoot)) {
         return demote('resolved type is or contains framework machinery (Response/Request-shaped); ' +
             'degraded to unknown rather than emit a wrapper envelope as a response contract');
     }

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

@@ -32,6 +32,25 @@ export type { CaptureStubOptions, CaptureStubResult } from './api.js';
 export { DenoProject, findDenoConfig } from './deno-project.js';
 export { runCheck } from './check.js';
 export type { CheckProgress } from './check.js';
+/**
+ * The name of THIS capture's surface entry, without an extension
+ * (carrick#1046).
+ *
+ * The entry has to live inside the effective `rootDir` — an entry beside a
+ * `rootDir` of `src` fails TS6059 — so it is written into the scanned tree and
+ * unlinked afterwards. One name per repo root made two captures of the same
+ * tree share a single file: whichever finished first unlinked it while the
+ * other's program was still reading it, and every alias whose print anchors in
+ * that destination then demoted to `structural_fallback` with an accessibility
+ * reason that described the harness rather than the code. Concurrent captures
+ * of one tree are ordinary — the test suite does it on every run, and two
+ * services of a monorepo can share a root — so the name, not the locking, is
+ * what has to give.
+ *
+ * A leftover from an interrupted capture is also identifiable as one process's
+ * (carrick#1069), rather than a fixed name the next scan reads as source.
+ */
+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;

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

@@ -44,6 +44,31 @@ export { DenoProject, findDenoConfig } from './deno-project.js';
 // reaches it only through this door (index.js).
 export { runCheck } from './check.js';
 const SURFACE_ENTRY_BASENAME = '__carrick_surface__';
+/** Captures made by this process, so each one's entry file has a name of its
+ * own. Paired with the pid it is unique across processes too. */
+let surfaceEntrySequence = 0;
+/**
+ * The name of THIS capture's surface entry, without an extension
+ * (carrick#1046).
+ *
+ * The entry has to live inside the effective `rootDir` — an entry beside a
+ * `rootDir` of `src` fails TS6059 — so it is written into the scanned tree and
+ * unlinked afterwards. One name per repo root made two captures of the same
+ * tree share a single file: whichever finished first unlinked it while the
+ * other's program was still reading it, and every alias whose print anchors in
+ * that destination then demoted to `structural_fallback` with an accessibility
+ * reason that described the harness rather than the code. Concurrent captures
+ * of one tree are ordinary — the test suite does it on every run, and two
+ * services of a monorepo can share a root — so the name, not the locking, is
+ * what has to give.
+ *
+ * A leftover from an interrupted capture is also identifiable as one process's
+ * (carrick#1069), rather than a fixed name the next scan reads as source.
+ */
+export function surfaceEntryFileName() {
+    surfaceEntrySequence += 1;
+    return `${SURFACE_ENTRY_BASENAME}.${process.pid}.${surfaceEntrySequence}`;
+}
 /** Same normalization intent as bundle_file_stems on the Rust side. */
 export function sanitizeServiceName(name) {
     return name.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
@@ -153,9 +178,11 @@ export function captureStub(opts) {
     const entryDir = parsed.options.rootDir
         ? path.resolve(path.dirname(configPath), parsed.options.rootDir)
         : repoRoot;
+    const surfaceEntry = surfaceEntryFileName();
+    const surfaceDeclaration = `${surfaceEntry}.d.ts`;
     const entryPath = deno
-        ? path.join(deno.cacheDir, `${SURFACE_ENTRY_BASENAME}.ts`)
-        : path.join(entryDir, `${SURFACE_ENTRY_BASENAME}.ts`);
+        ? path.join(deno.cacheDir, `${surfaceEntry}.ts`)
+        : path.join(entryDir, `${surfaceEntry}.ts`);
     fs.mkdirSync(path.dirname(entryPath), { recursive: true });
     // ---- Phase A: analysis program over placeholder entry + anchor sources ----
     let resolved;
@@ -250,7 +277,7 @@ export function captureStub(opts) {
     if (emitPartial) {
         errors.push(`declaration emit was partial: kept ${emitted.size} emitted file(s); ` +
             'aliases referencing unemitted modules are demoted to structural_fallback');
-        resolved = demoteDanglingAliases({ resolved, emitted, declarationSources, staging });
+        resolved = demoteDanglingAliases({ resolved, emitted, declarationSources, staging, surfaceDeclaration });
     }
     // ---- Relocate the emitted tree into the stub package ----
     const typesDir = path.join(stubDir, 'types');
@@ -260,7 +287,7 @@ export function captureStub(opts) {
     let surfaceAbsPath = '';
     for (const [fileName, text] of emitted) {
         let rel = path.relative(staging, fileName).split(path.sep).join('/');
-        if (path.basename(rel) === `${SURFACE_ENTRY_BASENAME}.d.ts`) {
+        if (path.basename(rel) === surfaceDeclaration) {
             const source = sourceByEmitted.get(rel);
             sourceByEmitted.delete(rel);
             rel = 'surface.d.ts';
@@ -422,7 +449,7 @@ function demoteDanglingAliases(args) {
     let surfaceKey;
     for (const fileName of args.emitted.keys()) {
         const rel = path.relative(args.staging, fileName).split(path.sep).join('/');
-        if (path.basename(rel) === `${SURFACE_ENTRY_BASENAME}.d.ts`)
+        if (path.basename(rel) === args.surfaceDeclaration)
             surfaceKey = fileName;
         if (rel.endsWith('.d.ts'))
             treeModules.add(rel.slice(0, -'.d.ts'.length));

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

@@ -14,8 +14,8 @@
  * detection shape are duplicated here in lockstep — the same pattern by which
  * `BUILTIN_ANCHOR_SYMBOLS` mirrors `socket_io.rs`. Detection is STRUCTURAL and
  * framework-agnostic: no framework NAME appears, only the shared HTTP-message
- * member surface, gated by a lib / `node_modules` declaration origin so a user
- * payload that merely shares a member name can never trip it.
+ * member surface, gated by a lib / installed-dependency declaration origin so a
+ * user payload that merely shares a member name can never trip it.
  */
 import ts from 'typescript';
 /**
@@ -50,20 +50,39 @@ export declare const MACHINERY_MEMBER_INDICATORS: Set<string>;
  *     Promise-unwrapped before the check — only call-signature returns are);
  *   - an array element type: `Response[]` is not descended to its element;
  *   - `interface X extends Response` declared in USER source — the origin gate
- *     is lib/`node_modules` only, so a user-declared subtype reads as a real
+ *     is lib/installed-dependency only, so a user-declared subtype reads as a real
  *     contract.
  *
  * The depth cap + origin gate keep a legitimate payload that merely references a
  * machinery type far inside from over-abstaining.
  */
-export declare function typeIsOrContainsMachinery(checker: ts.TypeChecker, type: ts.Type, node: ts.Node): boolean;
+export declare function typeIsOrContainsMachinery(program: ts.Program, type: ts.Type, node: ts.Node, repoRoot: string): boolean;
 /**
- * True when a declaration file path is runtime/library origin: a TS lib
- * (`lib.*.d.ts`), an installed package, or the runtime declarations Carrick
- * materialises for a non-Node runtime under `.carrick/deno/` (carrick#1017 —
- * there the platform `Response` lives in Carrick's own generated file, so
- * without this the gate stayed shut and the wrapper was published as a
- * contract). Lockstep mirror of `isExternalOrigin` in `type-inferrer.ts`;
- * `machinery-indicator-mirror.test.ts` guards the pair.
+ * True when a declaration's source file is runtime/library origin rather than
+ * user source. Four answers, in order:
+ *
+ *  1. The runtime declarations Carrick materialises for a non-Node runtime
+ *     under `.carrick/deno/` (carrick#1017), and the remote (JSR, `https:`)
+ *     modules it copies beside them. Carrick's own artefact layout, not a
+ *     guess about anyone else's.
+ *  2. A TypeScript default library (`lib.dom.d.ts`, ...), as the program
+ *     classifies it; on a bare checkout the DOM `Response` resolves from here.
+ *  3. An install under a `node_modules` segment, however it entered the
+ *     program (an import, or a root the loader registered).
+ *  4. A file the PROGRAM'S RESOLVER marked as an external library import.
+ *     This is the graph-backed answer for a project whose resolution does not
+ *     go through `node_modules` (carrick#1264): Deno serves an npm dependency's
+ *     types from its own cache, a path with no `node_modules` segment, and
+ *     `DenoProject.resolve` hands the compiler `isExternalLibraryImport` from
+ *     the graph, which the compiler records on the file. Nothing crosses the
+ *     capture seam; both programs are built with that host. One exclusion: a
+ *     workspace package reached through a `node_modules` symlink is also
+ *     marked external by the compiler but is the user's own source, so a file
+ *     inside the checkout (the nearest `.git` above the service root) that
+ *     carries no `node_modules` segment stays user source.
+ *
+ * Lockstep mirror of `isExternalOrigin` in `type-inferrer.ts` (the capture seam
+ * forbids sharing a module); `machinery-indicator-mirror.test.ts` guards the
+ * pair on a real program.
  */
-export declare function isExternalOrigin(filePath: string): boolean;
+export declare function isExternalOrigin(program: ts.Program, sourceFile: ts.SourceFile, repoRoot: string): boolean;

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

@@ -14,10 +14,12 @@
  * detection shape are duplicated here in lockstep — the same pattern by which
  * `BUILTIN_ANCHOR_SYMBOLS` mirrors `socket_io.rs`. Detection is STRUCTURAL and
  * framework-agnostic: no framework NAME appears, only the shared HTTP-message
- * member surface, gated by a lib / `node_modules` declaration origin so a user
- * payload that merely shares a member name can never trip it.
+ * member surface, gated by a lib / installed-dependency declaration origin so a
+ * user payload that merely shares a member name can never trip it.
  */
 import ts from 'typescript';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 /**
  * Strongly-discriminating member names of HTTP transport machinery. Kept
  * identical to `MACHINERY_MEMBER_INDICATORS` in `type-inferrer.ts`. These are
@@ -71,21 +73,23 @@ const MACHINERY_INDICATOR_THRESHOLD = 3;
  *     Promise-unwrapped before the check — only call-signature returns are);
  *   - an array element type: `Response[]` is not descended to its element;
  *   - `interface X extends Response` declared in USER source — the origin gate
- *     is lib/`node_modules` only, so a user-declared subtype reads as a real
+ *     is lib/installed-dependency only, so a user-declared subtype reads as a real
  *     contract.
  *
  * The depth cap + origin gate keep a legitimate payload that merely references a
  * machinery type far inside from over-abstaining.
  */
-export function typeIsOrContainsMachinery(checker, type, node) {
-    return isOrContains(checker, type, node, 0);
+export function typeIsOrContainsMachinery(program, type, node, repoRoot) {
+    const scope = { program, checker: program.getTypeChecker(), repoRoot };
+    return isOrContains(scope, type, node, 0);
 }
-function isOrContains(checker, type, node, depth) {
-    if (isFrameworkMachinery(checker, type)) {
+function isOrContains(scope, type, node, depth) {
+    const { checker } = scope;
+    if (isFrameworkMachinery(scope, type)) {
         return true;
     }
     if (type.isUnion() || type.isIntersection()) {
-        return type.types.some((part) => isOrContains(checker, part, node, depth));
+        return type.types.some((part) => isOrContains(scope, part, node, depth));
     }
     if (depth >= 1) {
         return false;
@@ -94,14 +98,14 @@ function isOrContains(checker, type, node, depth) {
     for (const sig of checker.getSignaturesOfType(type, ts.SignatureKind.Call)) {
         const returnType = sig.getReturnType();
         const awaited = checker.getAwaitedType?.(returnType) ?? returnType;
-        if (isOrContains(checker, awaited, node, depth + 1)) {
+        if (isOrContains(scope, awaited, node, depth + 1)) {
             return true;
         }
     }
     // Direct properties: the `{ response: Response; error }` envelope shape.
     for (const prop of checker.getPropertiesOfType(type)) {
         const propType = checker.getTypeOfSymbolAtLocation(prop, node);
-        if (isOrContains(checker, propType, node, depth + 1)) {
+        if (isOrContains(scope, propType, node, depth + 1)) {
             return true;
         }
     }
@@ -110,11 +114,11 @@ function isOrContains(checker, type, node, depth) {
 /**
  * True when `type` itself is an HTTP-machinery type: it structurally carries at
  * least `MACHINERY_INDICATOR_THRESHOLD` of the indicator members AND its symbol
- * is declared in a lib (`lib.*.d.ts`) or `node_modules` origin.
+ * is declared in a lib or installed-dependency origin.
  */
-function isFrameworkMachinery(checker, type) {
+function isFrameworkMachinery(scope, type) {
     let hits = 0;
-    for (const prop of checker.getPropertiesOfType(type)) {
+    for (const prop of scope.checker.getPropertiesOfType(type)) {
         if (MACHINERY_MEMBER_INDICATORS.has(prop.getName())) {
             hits += 1;
             if (hits >= MACHINERY_INDICATOR_THRESHOLD)
@@ -124,42 +128,96 @@ function isFrameworkMachinery(checker, type) {
     if (hits < MACHINERY_INDICATOR_THRESHOLD) {
         return false;
     }
-    return symbolIsLibOrExternalOrigin(checker, type.getSymbol() ?? type.aliasSymbol);
+    return symbolIsLibOrExternalOrigin(scope, type.getSymbol() ?? type.aliasSymbol);
 }
 /**
- * True when a declaration file path is runtime/library origin: a TS lib
- * (`lib.*.d.ts`), an installed package, or the runtime declarations Carrick
- * materialises for a non-Node runtime under `.carrick/deno/` (carrick#1017 —
- * there the platform `Response` lives in Carrick's own generated file, so
- * without this the gate stayed shut and the wrapper was published as a
- * contract). Lockstep mirror of `isExternalOrigin` in `type-inferrer.ts`;
- * `machinery-indicator-mirror.test.ts` guards the pair.
+ * True when a declaration's source file is runtime/library origin rather than
+ * user source. Four answers, in order:
+ *
+ *  1. The runtime declarations Carrick materialises for a non-Node runtime
+ *     under `.carrick/deno/` (carrick#1017), and the remote (JSR, `https:`)
+ *     modules it copies beside them. Carrick's own artefact layout, not a
+ *     guess about anyone else's.
+ *  2. A TypeScript default library (`lib.dom.d.ts`, ...), as the program
+ *     classifies it; on a bare checkout the DOM `Response` resolves from here.
+ *  3. An install under a `node_modules` segment, however it entered the
+ *     program (an import, or a root the loader registered).
+ *  4. A file the PROGRAM'S RESOLVER marked as an external library import.
+ *     This is the graph-backed answer for a project whose resolution does not
+ *     go through `node_modules` (carrick#1264): Deno serves an npm dependency's
+ *     types from its own cache, a path with no `node_modules` segment, and
+ *     `DenoProject.resolve` hands the compiler `isExternalLibraryImport` from
+ *     the graph, which the compiler records on the file. Nothing crosses the
+ *     capture seam; both programs are built with that host. One exclusion: a
+ *     workspace package reached through a `node_modules` symlink is also
+ *     marked external by the compiler but is the user's own source, so a file
+ *     inside the checkout (the nearest `.git` above the service root) that
+ *     carries no `node_modules` segment stays user source.
+ *
+ * Lockstep mirror of `isExternalOrigin` in `type-inferrer.ts` (the capture seam
+ * forbids sharing a module); `machinery-indicator-mirror.test.ts` guards the
+ * pair on a real program.
  */
-export function isExternalOrigin(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
-    return (normalized.includes('/node_modules/') ||
-        /\/lib\.[^/]*\.d\.ts$/.test(normalized) ||
-        normalized.includes('/.carrick/deno/'));
+export function isExternalOrigin(program, sourceFile, repoRoot) {
+    const file = sourceFile.fileName.replace(/\\/g, '/');
+    if (file.includes('/.carrick/deno/')) {
+        return true;
+    }
+    if (program.isSourceFileDefaultLibrary(sourceFile)) {
+        return true;
+    }
+    if (file.includes('/node_modules/')) {
+        return true;
+    }
+    return program.isSourceFileFromExternalLibrary(sourceFile) && !isInsideCheckout(file, repoRoot);
+}
+const checkoutRoots = new Map();
+/** The checkout the service root sits in: the nearest ancestor holding a
+ * `.git` entry (a directory, or the file a worktree carries), else the service
+ * root itself. */
+function checkoutRootOf(repoRoot) {
+    const key = path.resolve(repoRoot);
+    const cached = checkoutRoots.get(key);
+    if (cached)
+        return cached;
+    let dir = key;
+    let root = key;
+    for (;;) {
+        if (fs.existsSync(path.join(dir, '.git'))) {
+            root = dir;
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    checkoutRoots.set(key, root);
+    return root;
+}
+function isInsideCheckout(file, repoRoot) {
+    const root = checkoutRootOf(repoRoot).replace(/\\/g, '/');
+    return file === root || file.startsWith(root.endsWith('/') ? root : root + '/');
 }
 /**
  * True when the symbol is declared in a runtime/library origin. Works on a bare
  * checkout: the DOM `Response`/`Request` resolve from the bundled
  * `lib.dom.d.ts` even with no installed dependencies.
  */
-function symbolIsLibOrExternalOrigin(checker, symbol) {
+function symbolIsLibOrExternalOrigin(scope, symbol) {
     if (!symbol) {
         return false;
     }
     for (const decl of symbol.getDeclarations() ?? []) {
-        if (isExternalOrigin(decl.getSourceFile().fileName)) {
+        if (isExternalOrigin(scope.program, decl.getSourceFile(), scope.repoRoot)) {
             return true;
         }
     }
     if (symbol.flags & ts.SymbolFlags.Alias) {
         try {
-            const aliased = checker.getAliasedSymbol(symbol);
+            const aliased = scope.checker.getAliasedSymbol(symbol);
             if (aliased && aliased !== symbol) {
-                return symbolIsLibOrExternalOrigin(checker, aliased);
+                return symbolIsLibOrExternalOrigin(scope, aliased);
             }
         }
         catch {

package/sidecar/dist/src/index.js

@@ -51,6 +51,7 @@ function projectComponents() {
             // resolves nothing under `node_modules` (carrick#1260).
             typeInferrer: new TypeInferrer({
                 project,
+                repoRoot,
                 packageOf: (filePath) => loader.packageOf(filePath),
             }),
             definitionResolver: new DefinitionResolver({ project }),

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

@@ -17,12 +17,12 @@
  * (redirects, 204s), the LLM emits null and we fall back to the containing
  * function's return type.
  */
-import { Project } from 'ts-morph';
+import { Project, ts } from 'ts-morph';
 import type { InferRequestItem, InferResult, ExtractionConfig } from './types.js';
 /**
  * Strongly-discriminating member names of HTTP transport machinery — the
  * fetch/DOM `Response` & `Request`, a Node `http.ServerResponse`, a framework
- * reply object. A type declared in a lib or `node_modules` origin that carries
+ * reply object. A type declared in a lib or installed-dependency origin that carries
  * a subset of these is framework machinery, never a user contract: the
  * PRODUCER-side structural mirror of the consumer `machineryIndicators`
  * (ExtractionConfig), used to reject a wrapper envelope whose response field is
@@ -39,23 +39,34 @@ import type { InferRequestItem, InferResult, ExtractionConfig } from './types.js
  */
 export declare const MACHINERY_MEMBER_INDICATORS: Set<string>;
 /**
- * True when a declaration file path is runtime/library origin rather than user
- * source: a TypeScript lib (`lib.dom.d.ts`), an installed package, or the
- * runtime declarations Carrick itself materialises for a non-Node runtime
- * (`.carrick/deno/<hash>/runtime.d.ts`, and the remote modules cached beside
- * it).
+ * True when a declaration's source file is runtime/library origin rather than
+ * user source. Four answers, in order:
  *
- * The third case is carrick#1017: on a Deno service the platform `Response`
- * is declared in Carrick's own generated runtime file, which is neither a
- * `lib.*.d.ts` nor under `node_modules`, so the machinery origin gate stayed
- * shut and every route published the fetch `Response` wrapper as its response
- * contract. The path is Carrick's own artefact, not a framework name.
+ *  1. The runtime declarations Carrick materialises for a non-Node runtime
+ *     under `.carrick/deno/` (carrick#1017), and the remote (JSR, `https:`)
+ *     modules it copies beside them. Carrick's own artefact layout, not a
+ *     guess about anyone else's.
+ *  2. A TypeScript default library (`lib.dom.d.ts`, ...), as the program
+ *     classifies it; on a bare checkout the DOM `Response` resolves from here.
+ *  3. An install under a `node_modules` segment, however it entered the
+ *     program (an import, or a root the loader registered).
+ *  4. A file the PROGRAM'S RESOLVER marked as an external library import.
+ *     This is the graph-backed answer for a project whose resolution does not
+ *     go through `node_modules` (carrick#1264): Deno serves an npm dependency's
+ *     types from its own cache, a path with no `node_modules` segment, and
+ *     `DenoProject.resolve` hands the compiler `isExternalLibraryImport` from
+ *     the graph, which the compiler records on the file. Nothing crosses the
+ *     capture seam; both programs are built with that host. One exclusion: a
+ *     workspace package reached through a `node_modules` symlink is also
+ *     marked external by the compiler but is the user's own source, so a file
+ *     inside the checkout (the nearest `.git` above the service root) that
+ *     carries no `node_modules` segment stays user source.
  *
- * Kept in lockstep with `capture/machinery.ts`'s copy (the capture seam forbids
- * sharing a module across it); `machinery-indicator-mirror.test.ts` guards the
- * pair.
+ * Lockstep mirror of `isExternalOrigin` in `capture/machinery.ts` (the capture
+ * seam forbids sharing a module); `machinery-indicator-mirror.test.ts` guards
+ * the pair on a real program.
  */
-export declare function isExternalOrigin(filePath: string): boolean;
+export declare function isExternalOrigin(program: ts.Program, sourceFile: ts.SourceFile, repoRoot: string): boolean;
 /**
  * Options for TypeInferrer construction
  */
@@ -69,6 +80,12 @@ export interface TypeInferrerOptions {
      * absent otherwise, and the path itself is then the only thing to read.
      */
     packageOf?: (filePath: string) => string | undefined;
+    /**
+     * The service root the project was built for. The machinery origin gate
+     * reads it to tell a workspace package the compiler reached through a
+     * `node_modules` symlink from an installed dependency (carrick#1264).
+     */
+    repoRoot: string;
 }
 /**
  * TypeInferrer - Extracts types from source code, both explicit and inferred
@@ -80,6 +97,7 @@ export interface TypeInferrerOptions {
 export declare class TypeInferrer {
     private readonly project;
     private readonly packageOf;
+    private readonly repoRoot;
     constructor(options: TypeInferrerOptions);
     /**
      * Infer types for the given requests
@@ -296,7 +314,7 @@ export declare class TypeInferrer {
      *     Promise-unwrapped before the machinery check);
      *   - an array element type: `Response[]` is not descended to its element;
      *   - `interface X extends Response` declared in USER source — the origin gate
-     *     is lib/`node_modules` only, so a user-declared subtype reads as a real
+     *     is lib/installed-dependency only, so a user-declared subtype reads as a real
      *     contract, not machinery;
      *   - a function / call-signature return type: the response paths that call
      *     this resolve a handler's RETURN (an envelope/object), never a function
@@ -313,7 +331,7 @@ export declare class TypeInferrer {
      * True when `type` itself is an HTTP-machinery type: it structurally carries
      * at least `MACHINERY_INDICATOR_THRESHOLD` of the strongly-discriminating
      * `MACHINERY_MEMBER_INDICATORS`, AND its symbol is declared in a lib
-     * (`lib.dom.d.ts`, ...) or `node_modules` origin. Both gates are required —
+     * (`lib.dom.d.ts`, ...) or installed-dependency origin. Both gates are required —
      * the indicator subset alone essentially never matches a JSON payload, and
      * the origin gate makes certain a user's own local type sharing those member
      * names is never mistaken for framework machinery (the advisor's guard).
@@ -327,12 +345,13 @@ export declare class TypeInferrer {
      */
     private hasMachineryIndicatorThreshold;
     /**
-     * True when the symbol is declared in a TypeScript lib file (`lib.*.d.ts`),
-     * under `node_modules`, or in the runtime declarations Carrick materialises
-     * for a non-Node runtime under `.carrick/deno/` — i.e. framework/runtime
-     * machinery, not user source. Works on a bare checkout: the DOM
-     * `Response`/`Request` resolve from the bundled `lib.dom.d.ts` even with no
-     * installed dependencies.
+     * True when the symbol is declared in a runtime/library origin
+     * (`isExternalOrigin`): a TypeScript lib, an installed dependency however
+     * the program resolved it, or the runtime declarations Carrick materialises
+     * under `.carrick/deno/` — framework/runtime machinery, not user source.
+     * Works on a bare checkout: the DOM `Response`/`Request` resolve from the
+     * bundled `lib.dom.d.ts` even with no installed dependencies. The program is
+     * read per call: the project adds source files lazily and rebuilds it.
      */
     private symbolIsLibOrExternalOrigin;
     /**

package/sidecar/dist/src/type-inferrer.js

@@ -18,6 +18,8 @@
  * function's return type.
  */
 import { Node, SyntaxKind, ts, } from 'ts-morph';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { validateInferRequestItem } from './validators.js';
 import { expandTypeStructural, } from './type-structural-expander.js';
 /**
@@ -75,7 +77,7 @@ const BUILTIN_ANCHOR_SYMBOLS = new Set([
 /**
  * Strongly-discriminating member names of HTTP transport machinery — the
  * fetch/DOM `Response` & `Request`, a Node `http.ServerResponse`, a framework
- * reply object. A type declared in a lib or `node_modules` origin that carries
+ * reply object. A type declared in a lib or installed-dependency origin that carries
  * a subset of these is framework machinery, never a user contract: the
  * PRODUCER-side structural mirror of the consumer `machineryIndicators`
  * (ExtractionConfig), used to reject a wrapper envelope whose response field is
@@ -151,27 +153,73 @@ const RESPONSE_INIT_MEMBER_NAMES = new Set([
     'headers',
 ]);
 /**
- * True when a declaration file path is runtime/library origin rather than user
- * source: a TypeScript lib (`lib.dom.d.ts`), an installed package, or the
- * runtime declarations Carrick itself materialises for a non-Node runtime
- * (`.carrick/deno/<hash>/runtime.d.ts`, and the remote modules cached beside
- * it).
+ * True when a declaration's source file is runtime/library origin rather than
+ * user source. Four answers, in order:
  *
- * The third case is carrick#1017: on a Deno service the platform `Response`
- * is declared in Carrick's own generated runtime file, which is neither a
- * `lib.*.d.ts` nor under `node_modules`, so the machinery origin gate stayed
- * shut and every route published the fetch `Response` wrapper as its response
- * contract. The path is Carrick's own artefact, not a framework name.
+ *  1. The runtime declarations Carrick materialises for a non-Node runtime
+ *     under `.carrick/deno/` (carrick#1017), and the remote (JSR, `https:`)
+ *     modules it copies beside them. Carrick's own artefact layout, not a
+ *     guess about anyone else's.
+ *  2. A TypeScript default library (`lib.dom.d.ts`, ...), as the program
+ *     classifies it; on a bare checkout the DOM `Response` resolves from here.
+ *  3. An install under a `node_modules` segment, however it entered the
+ *     program (an import, or a root the loader registered).
+ *  4. A file the PROGRAM'S RESOLVER marked as an external library import.
+ *     This is the graph-backed answer for a project whose resolution does not
+ *     go through `node_modules` (carrick#1264): Deno serves an npm dependency's
+ *     types from its own cache, a path with no `node_modules` segment, and
+ *     `DenoProject.resolve` hands the compiler `isExternalLibraryImport` from
+ *     the graph, which the compiler records on the file. Nothing crosses the
+ *     capture seam; both programs are built with that host. One exclusion: a
+ *     workspace package reached through a `node_modules` symlink is also
+ *     marked external by the compiler but is the user's own source, so a file
+ *     inside the checkout (the nearest `.git` above the service root) that
+ *     carries no `node_modules` segment stays user source.
  *
- * Kept in lockstep with `capture/machinery.ts`'s copy (the capture seam forbids
- * sharing a module across it); `machinery-indicator-mirror.test.ts` guards the
- * pair.
+ * Lockstep mirror of `isExternalOrigin` in `capture/machinery.ts` (the capture
+ * seam forbids sharing a module); `machinery-indicator-mirror.test.ts` guards
+ * the pair on a real program.
  */
-export function isExternalOrigin(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
-    return (normalized.includes('/node_modules/') ||
-        /\/lib\.[^/]*\.d\.ts$/.test(normalized) ||
-        normalized.includes('/.carrick/deno/'));
+export function isExternalOrigin(program, sourceFile, repoRoot) {
+    const file = sourceFile.fileName.replace(/\\/g, '/');
+    if (file.includes('/.carrick/deno/')) {
+        return true;
+    }
+    if (program.isSourceFileDefaultLibrary(sourceFile)) {
+        return true;
+    }
+    if (file.includes('/node_modules/')) {
+        return true;
+    }
+    return program.isSourceFileFromExternalLibrary(sourceFile) && !isInsideCheckout(file, repoRoot);
+}
+const checkoutRoots = new Map();
+/** The checkout the service root sits in: the nearest ancestor holding a
+ * `.git` entry (a directory, or the file a worktree carries), else the service
+ * root itself. */
+function checkoutRootOf(repoRoot) {
+    const key = path.resolve(repoRoot);
+    const cached = checkoutRoots.get(key);
+    if (cached)
+        return cached;
+    let dir = key;
+    let root = key;
+    for (;;) {
+        if (fs.existsSync(path.join(dir, '.git'))) {
+            root = dir;
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    checkoutRoots.set(key, root);
+    return root;
+}
+function isInsideCheckout(file, repoRoot) {
+    const root = checkoutRootOf(repoRoot).replace(/\\/g, '/');
+    return file === root || file.startsWith(root.endsWith('/') ? root : root + '/');
 }
 /**
  * How far the response-helper recovery (carrick#631) descends through nested
@@ -250,9 +298,11 @@ function typeText(type, enclosingNode) {
 export class TypeInferrer {
     project;
     packageOf;
+    repoRoot;
     constructor(options) {
         this.project = options.project;
         this.packageOf = options.packageOf;
+        this.repoRoot = options.repoRoot;
     }
     /**
      * Infer types for the given requests
@@ -1805,7 +1855,7 @@ export class TypeInferrer {
      *     Promise-unwrapped before the machinery check);
      *   - an array element type: `Response[]` is not descended to its element;
      *   - `interface X extends Response` declared in USER source — the origin gate
-     *     is lib/`node_modules` only, so a user-declared subtype reads as a real
+     *     is lib/installed-dependency only, so a user-declared subtype reads as a real
      *     contract, not machinery;
      *   - a function / call-signature return type: the response paths that call
      *     this resolve a handler's RETURN (an envelope/object), never a function
@@ -1852,7 +1902,7 @@ export class TypeInferrer {
      * True when `type` itself is an HTTP-machinery type: it structurally carries
      * at least `MACHINERY_INDICATOR_THRESHOLD` of the strongly-discriminating
      * `MACHINERY_MEMBER_INDICATORS`, AND its symbol is declared in a lib
-     * (`lib.dom.d.ts`, ...) or `node_modules` origin. Both gates are required —
+     * (`lib.dom.d.ts`, ...) or installed-dependency origin. Both gates are required —
      * the indicator subset alone essentially never matches a JSON payload, and
      * the origin gate makes certain a user's own local type sharing those member
      * names is never mistaken for framework machinery (the advisor's guard).
@@ -1889,19 +1939,21 @@ export class TypeInferrer {
         return false;
     }
     /**
-     * True when the symbol is declared in a TypeScript lib file (`lib.*.d.ts`),
-     * under `node_modules`, or in the runtime declarations Carrick materialises
-     * for a non-Node runtime under `.carrick/deno/` — i.e. framework/runtime
-     * machinery, not user source. Works on a bare checkout: the DOM
-     * `Response`/`Request` resolve from the bundled `lib.dom.d.ts` even with no
-     * installed dependencies.
+     * True when the symbol is declared in a runtime/library origin
+     * (`isExternalOrigin`): a TypeScript lib, an installed dependency however
+     * the program resolved it, or the runtime declarations Carrick materialises
+     * under `.carrick/deno/` — framework/runtime machinery, not user source.
+     * Works on a bare checkout: the DOM `Response`/`Request` resolve from the
+     * bundled `lib.dom.d.ts` even with no installed dependencies. The program is
+     * read per call: the project adds source files lazily and rebuilds it.
      */
     symbolIsLibOrExternalOrigin(symbol) {
         if (!symbol) {
             return false;
         }
+        const program = this.project.getProgram().compilerObject;
         for (const decl of symbol.getDeclarations()) {
-            if (isExternalOrigin(decl.getSourceFile().getFilePath())) {
+            if (isExternalOrigin(program, decl.getSourceFile().compilerNode, this.repoRoot)) {
                 return true;
             }
         }