carrick 0.3.58 → 0.3.60

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

@@ -37,6 +37,8 @@ import { installedVersions, lockfileVersions } from './lockfile.js';
 import { rewriteEmittedSpecifiers } from './paths-rewrite.js';
 import { selfCheckStub } from './self-check.js';
 import { collectSpecifiers, isRelative, packageNameOf } from './specifiers.js';
+import { DenoProject, findDenoConfig } from './deno-project.js';
+export { DenoProject, findDenoConfig } from './deno-project.js';
 // v2 check core ("tsc as the judge"). Same bundle, same seam: the sidecar
 // reaches it only through this door (index.js).
 export { runCheck } from './check.js';
@@ -90,10 +92,23 @@ export function captureStub(opts) {
     const stubDir = path.resolve(opts.outDir);
     const errors = [];
     const configPath = opts.tsconfigPath
-        ? path.resolve(opts.tsconfigPath)
+        ? path.resolve(repoRoot, opts.tsconfigPath)
         : path.join(repoRoot, 'tsconfig.json');
     let parsed;
-    if (!fs.existsSync(configPath)) {
+    let deno;
+    try {
+        const config = findDenoConfig(repoRoot, opts.tsconfigPath);
+        if (config)
+            deno = new DenoProject(config, repoRoot);
+    }
+    catch (err) {
+        return fail(stubDir, packageName, [err instanceof Error ? err.message : String(err)]);
+    }
+    if (deno) {
+        parsed = deno.parsed;
+        errors.push(...deno.diagnostics);
+    }
+    else if (!fs.existsSync(configPath)) {
         if (opts.tsconfigPath) {
             // An explicitly named tsconfig that does not exist is a caller bug.
             return fail(stubDir, packageName, [`tsconfig not found at ${configPath}`]);
@@ -137,17 +152,20 @@ export function captureStub(opts) {
     const entryDir = parsed.options.rootDir
         ? path.resolve(path.dirname(configPath), parsed.options.rootDir)
         : repoRoot;
-    const entryPath = path.join(entryDir, `${SURFACE_ENTRY_BASENAME}.ts`);
+    const entryPath = deno
+        ? path.join(deno.cacheDir, `${SURFACE_ENTRY_BASENAME}.ts`)
+        : path.join(entryDir, `${SURFACE_ENTRY_BASENAME}.ts`);
+    fs.mkdirSync(path.dirname(entryPath), { recursive: true });
     // ---- Phase A: analysis program over placeholder entry + anchor sources ----
     let resolved;
     try {
-        resolved = resolveAnchors(opts, parsed, { repoRoot, entryDir, entryPath });
+        resolved = resolveAnchors(opts, parsed, { repoRoot, entryDir: path.dirname(entryPath), entryPath }, deno);
     }
     catch (err) {
         return fail(stubDir, packageName, [err instanceof Error ? err.message : String(err)]);
     }
     // ---- Augmentation detection over the tsconfig's full file list ----
-    const augmentationSources = findAugmentationFiles(parsed.fileNames.filter((f) => !f.includes(`${path.sep}node_modules${path.sep}`)));
+    const augmentationSources = [...new Set([...findAugmentationFiles(parsed.fileNames.filter((f) => !f.includes(`${path.sep}node_modules${path.sep}`))), ...(deno?.globals ?? [])])];
     // ---- Phase B: declaration emit of the final entry ----
     const entryLines = ['// Generated by Carrick capture v2. Deleted after emit.'];
     for (const anchor of resolved) {
@@ -162,6 +180,7 @@ export function captureStub(opts) {
     // 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;
     try {
         fs.writeFileSync(entryPath, entryLines.join('\n') + '\n');
@@ -179,8 +198,12 @@ export function captureStub(opts) {
             outDir: staging,
             rootDir: entryDir,
         };
-        const program = ts.createProgram([entryPath, ...augmentationSources], emitOptions);
-        const emitResult = program.emit(undefined, (fileName, text) => emitted.set(fileName, text), undefined, 
+        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
@@ -202,6 +225,7 @@ export function captureStub(opts) {
             if (rel.startsWith('..') || rel.includes('node_modules/'))
                 continue;
             declarationSources.set(rel, sourceFile.getFullText());
+            sourceByEmitted.set(rel, abs);
         }
     }
     catch (err) {
@@ -235,8 +259,13 @@ export function captureStub(opts) {
     let surfaceAbsPath = '';
     for (const [fileName, text] of emitted) {
         let rel = path.relative(staging, fileName).split(path.sep).join('/');
-        if (rel === `${SURFACE_ENTRY_BASENAME}.d.ts`)
+        if (path.basename(rel) === `${SURFACE_ENTRY_BASENAME}.d.ts`) {
+            const source = sourceByEmitted.get(rel);
+            sourceByEmitted.delete(rel);
             rel = 'surface.d.ts';
+            if (source)
+                sourceByEmitted.set(rel, source);
+        }
         const dest = path.join(typesDir, rel);
         fs.mkdirSync(path.dirname(dest), { recursive: true });
         fs.writeFileSync(dest, text);
@@ -268,7 +297,14 @@ export function captureStub(opts) {
         .filter((rel) => emittedFiles.includes(rel))
         .map((rel) => `types/${rel}`);
     // ---- Post-emit specifier rewrite (paths mappings + absolute internals) ----
-    const specifierRewrites = rewriteEmittedSpecifiers({
+    let denoRewrites = 0;
+    try {
+        denoRewrites = deno?.rewrite(typesDir, emittedFiles, sourceByEmitted) ?? 0;
+    }
+    catch (err) {
+        return fail(stubDir, packageName, [err instanceof Error ? err.message : String(err)]);
+    }
+    const specifierRewrites = denoRewrites + rewriteEmittedSpecifiers({
         typesDir,
         files: emittedFiles,
         options: parsed.options,
@@ -297,16 +333,19 @@ export function captureStub(opts) {
     // only transitives resolve").
     const installed = installedVersions(repoRoot, externalSpecs);
     const lockVersions = lockfileVersions(repoRoot);
+    for (const name of Object.keys(deno?.pinned ?? {}))
+        externalSpecs.add(name);
     const pinned = {};
     const unpinned = [];
     for (const name of [...externalSpecs].sort()) {
-        const version = installed.get(name) ?? lockVersions.get(name);
+        const version = deno?.pinned[name] ?? installed.get(name) ?? lockVersions.get(name);
         if (version)
             pinned[name] = version;
         else
             unpinned.push(name);
     }
-    const bareCheckout = !fs.existsSync(path.join(repoRoot, 'node_modules'));
+    const dependencyRoot = deno?.config.workspaceRoot ?? repoRoot;
+    const bareCheckout = !deno && !fs.existsSync(path.join(dependencyRoot, 'node_modules'));
     fs.writeFileSync(path.join(stubDir, 'package.json'), JSON.stringify({
         name: packageName,
         version: '0.0.0-carrick',
@@ -329,7 +368,8 @@ export function captureStub(opts) {
         resolved,
         pinned,
         bareCheckout,
-        repoRoot,
+        repoRoot: dependencyRoot,
+        compilerHost: deno ? options => deno.host(options) : undefined,
     });
     const fidelity = computeFidelity(aliases);
     fs.writeFileSync(path.join(stubDir, 'carrick-manifest.json'), JSON.stringify({
@@ -371,7 +411,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 (rel === `${SURFACE_ENTRY_BASENAME}.d.ts`)
+        if (path.basename(rel) === `${SURFACE_ENTRY_BASENAME}.d.ts`)
             surfaceKey = fileName;
         if (rel.endsWith('.d.ts'))
             treeModules.add(rel.slice(0, -'.d.ts'.length));
@@ -380,10 +420,10 @@ function demoteDanglingAliases(args) {
         if (rel.endsWith('.d.ts'))
             treeModules.add(rel.slice(0, -'.d.ts'.length));
     }
-    // The surface sits at the tree root, so its relative specifiers resolve
-    // against the root; anything escaping the root cannot be in the tree.
+    // Deno's temporary surface lives in the cache inside the emitted tree.
+    const surfaceDir = surfaceKey ? path.posix.dirname(path.relative(args.staging, surfaceKey).split(path.sep).join('/')) : '.';
     const moduleInTree = (spec) => {
-        const id = path.posix.normalize(spec);
+        const id = path.posix.normalize(path.posix.join(surfaceDir, spec));
         if (id.startsWith('..'))
             return false;
         return treeModules.has(id) || treeModules.has(`${id}/index`);
@@ -429,7 +469,7 @@ function rewriteSurfaceAliasesToUnknown(text, demoted) {
     return out;
 }
 /** Phase A: build the placeholder entry, then resolve every anchor. */
-function resolveAnchors(opts, parsed, ctx) {
+function resolveAnchors(opts, parsed, ctx, deno) {
     const placeholderLines = ['// Carrick capture v2 analysis placeholder.'];
     for (const anchor of opts.anchors) {
         placeholderLines.push(`export type ${anchor.alias} = unknown;`);
@@ -441,10 +481,11 @@ function resolveAnchors(opts, parsed, ctx) {
                 .filter((a) => a.kind !== 'literal')
                 .map((a) => path.join(ctx.repoRoot, a.source_file))),
         ].filter((f) => fs.existsSync(f));
-        const program = ts.createProgram([ctx.entryPath, ...anchorSources], {
+        const options = {
             ...parsed.options,
             noEmit: true,
-        });
+        };
+        const program = ts.createProgram([ctx.entryPath, ...anchorSources, ...(deno?.globals ?? [])], options, deno?.host(options));
         const entrySource = program.getSourceFile(ctx.entryPath);
         const placeholders = new Map();
         if (entrySource) {

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

@@ -24,6 +24,7 @@
  * (import-type seeds, then BFS over relative imports). The spike's
  * file-granularity shortcut is gone.
  */
+import ts from 'typescript';
 import type { CaptureAliasRecord } from './api.js';
 import type { ResolvedAnchor } from './anchors.js';
 export interface SelfCheckArgs {
@@ -34,5 +35,6 @@ export interface SelfCheckArgs {
     bareCheckout: boolean;
     /** Producer repo root; its node_modules (if any) backs resolution. */
     repoRoot: string;
+    compilerHost?: (options: ts.CompilerOptions) => ts.CompilerHost;
 }
 export declare function selfCheckStub(args: SelfCheckArgs): CaptureAliasRecord[];

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

@@ -61,7 +61,7 @@ export function selfCheckStub(args) {
     }
 }
 function runSelfCheck(args, treeFiles) {
-    const program = ts.createProgram(treeFiles, {
+    const options = {
         noEmit: true,
         strict: true,
         // MUST be false: the whole stub tree is .d.ts (see module header).
@@ -69,7 +69,8 @@ function runSelfCheck(args, treeFiles) {
         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);
     // Failed module specifiers, split external-pinned vs internal, per FILE.

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

@@ -12,6 +12,7 @@
 import { Project } from 'ts-morph';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
+import { DenoProject, findDenoConfig } from './capture/index.js';
 /**
  * Source-file patterns used when the repo declares no tsconfig, relative to
  * the repo root. `node_modules` is excluded explicitly: a glob that matches
@@ -169,7 +170,27 @@ export class ProjectLoader {
             // Priority 2: Use tsconfig.json file
             else {
                 const tsconfigPath = this.findTsConfig();
-                if (tsconfigPath) {
+                const denoConfig = findDenoConfig(this.repoRoot, this.tsconfigPath);
+                if (denoConfig) {
+                    this.log(`Project will load with Deno config: ${denoConfig.configPath}`);
+                    this.buildProject = () => {
+                        const deno = new DenoProject(denoConfig, this.repoRoot);
+                        const project = new Project({
+                            compilerOptions: deno.parsed.options,
+                            skipAddingFilesFromTsConfig: true,
+                            resolutionHost: (host, getOptions) => ({
+                                resolveModuleNames: (names, from) => names.map(name => deno.resolve(name, from, getOptions(), host)),
+                                resolveTypeReferenceDirectives: (names, from) => names.map(name => deno.resolveTypeReference(typeof name === 'string' ? name : name.fileName, from, getOptions(), host)),
+                            }),
+                        });
+                        for (const file of deno.parsed.fileNames)
+                            project.addSourceFileAtPath(file);
+                        for (const diagnostic of deno.diagnostics)
+                            this.logError(diagnostic);
+                        return project;
+                    };
+                }
+                else if (tsconfigPath) {
                     this.log(`Project will load with tsconfig: ${tsconfigPath}`);
                     this.buildProject = () => new Project({
                         tsConfigFilePath: tsconfigPath,

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

@@ -272,6 +272,24 @@ export declare class TypeInferrer {
      * Check if a type string is "useless" for payload purposes.
      */
     private isUselessType;
+    /**
+     * A type that can be CALLED or constructed is machinery, never a payload
+     * (carrick#964).
+     *
+     * A context-object framework hands the handler one object that both reads the
+     * request and sends the response, so that object has a `body` MEMBER whose
+     * type is the response sender. Every anchor that reads a member off the
+     * handler's parameter, and every locator that lands on such a member, can
+     * therefore resolve to a perfectly concrete type that is the wrong side of
+     * the exchange — and, being concrete, it sails past the useless-type guard and
+     * publishes as an explicit contract.
+     *
+     * Nothing crosses an HTTP (or queue, or topic) boundary as a function, so the
+     * presence of call or construct signatures is a structural, framework-free
+     * proof that the resolution landed on machinery. The caller abstains, which
+     * leaves the row honestly unresolved instead of confidently wrong.
+     */
+    private isCallableType;
     private unwrapExpressionNode;
     /**
      * If `node` is a `JSON.stringify(arg)` call, return the (expression-unwrapped)
@@ -797,6 +815,18 @@ export declare class TypeInferrer {
      * the route declares its request nowhere we can read.
      */
     private requestContractFromRegistration;
+    /**
+     * The request contract a route DECLARES, in anchor order: the handler's
+     * parameter annotation (a), the registration's schema object (b), then a
+     * validator middleware bound to the request body (b2).
+     *
+     * Both callers — the registration locator and the expression locator whose
+     * line is a registration — consult exactly this set, so the two cannot drift.
+     * The typed request READ inside the handler body is deliberately not part of
+     * it: that anchor is itself an expression, and the expression path keeps its
+     * own locator authoritative when a route declares nothing.
+     */
+    private declaredRequestContract;
     /**
      * Anchor (a): the request contract declared on the handler's own signature.
      *
@@ -810,6 +840,28 @@ export declare class TypeInferrer {
      * anchor runs.
      */
     private requestBodyFromHandlerParams;
+    /**
+     * Anchor (b2): the contract declared by a VALIDATOR MIDDLEWARE on the
+     * registration (carrick#964).
+     *
+     * A route can declare its body by binding a schema to a named part of the
+     * request in a middleware the registration carries alongside the handler:
+     *
+     *   router.post('/search', validate('json', PayloadSchema), async (c) => …)
+     *
+     * The shape is a CALL among the registration's arguments whose own arguments
+     * are a request part and a schema value. Neither the middleware's name nor
+     * the schema library is checked: the part is read off the string literal, and
+     * the schema is whatever exposes a parsed output (`schemaOutputTypeText`) —
+     * the same test anchor (b) already applies to a `schema: { body: … }` object.
+     *
+     * `REQUEST_BODY_PARTS` is HTTP vocabulary for how a body is carried, not a
+     * framework list. A middleware bound to any other part (`query`, `param`,
+     * `header`, `cookie`) declares no BODY, and a middleware that names no part
+     * at all is not read: publishing a query schema as the request contract would
+     * be the same confident-and-wrong answer this anchor exists to remove.
+     */
+    private validatedBodyContractText;
     /**
      * Anchor (b): the contract declared in the route's validation schema.
      *

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

@@ -123,6 +123,16 @@ const RESPONSE_HELPER_MAX_DEPTH = 4;
  * the branch an error path, whose shape is not the endpoint's contract.
  */
 const STATUS_MEMBER_NAMES = ['status', 'statusCode'];
+/**
+ * The parts of a request that ARE the body, as validator middleware names them
+ * (`validate('json', Schema)`). HTTP vocabulary for how a body is carried — the
+ * same class of generic route vocabulary as the `schema` / `body` / `response` /
+ * `handler` keys the schema anchors already read, and deliberately not a list of
+ * libraries. Every other part a validator can bind (`query`, `param`, `header`,
+ * `cookie`) is NOT the body, so a schema bound to one of those declares no
+ * request contract.
+ */
+const REQUEST_BODY_PARTS = new Set(['json', 'form', 'body']);
 /**
  * Print a `Type` to its string form WITHOUT the compiler's default truncation.
  *
@@ -790,16 +800,15 @@ export class TypeInferrer {
         // ships as machinery and decays to `any` in the cross-repo surface.
         //
         // A DECLARED contract outranks whatever expression the locator picked,
-        // exactly as it does on the response side, so read anchors (a) and (b)
-        // first and fall through to the expression only when the route declares
-        // its request nowhere. The third registration anchor — the typed request
-        // READ inside the handler body — is deliberately not consulted here: that
-        // one is itself an expression, so the locator's own expression stays
-        // authoritative when nothing is declared.
+        // exactly as it does on the response side, so read the DECLARED anchors
+        // (a), (b) and (b2) first and fall through to the expression only when the
+        // route declares its request nowhere. The remaining registration anchor —
+        // the typed request READ inside the handler body — is deliberately not
+        // consulted here: that one is itself an expression, so the locator's own
+        // expression stays authoritative when nothing is declared.
         const declaredAt = this.registrationAtLine(sourceFile, request.line_number);
         if (declaredAt) {
-            const declared = this.requestBodyFromHandlerParams(declaredAt.handler) ??
-                this.routeSchemaContractText(declaredAt.registration, 'body');
+            const declared = this.declaredRequestContract(declaredAt.registration, declaredAt.handler);
             if (declared) {
                 this.log(`Route registration at ${request.file_path}:${request.line_number} declares its ` +
                     'request contract; using the declaration over the located expression');
@@ -895,6 +904,19 @@ export class TypeInferrer {
             typeString = explicitType;
             isExplicit = true;
         }
+        // Publication guard (carrick#964): the locator landed on machinery — a
+        // callable member of the handler's context, a method reference, a handler
+        // binding — and neither a wrapper rule nor a declared type recovered a
+        // payload from it. Publishing that would assert an explicit contract for a
+        // type nothing can send over the wire, so abstain and let the row say
+        // unknown.
+        if (this.isCallableType(payloadType) &&
+            !unwrapResult.wasUnwrapped &&
+            !explicitType) {
+            this.log(`Request locator at ${request.file_path}:${request.line_number} resolved a callable ` +
+                `(${typeString}); a function is not a payload, leaving unresolved`);
+            return null;
+        }
         typeString = this.unwrapPromise(typeString, payloadType);
         return this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(node), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined);
     }
@@ -1611,6 +1633,32 @@ export class TypeInferrer {
         const trimmed = typeString.trim();
         return useless.includes(trimmed) || trimmed === '';
     }
+    /**
+     * A type that can be CALLED or constructed is machinery, never a payload
+     * (carrick#964).
+     *
+     * A context-object framework hands the handler one object that both reads the
+     * request and sends the response, so that object has a `body` MEMBER whose
+     * type is the response sender. Every anchor that reads a member off the
+     * handler's parameter, and every locator that lands on such a member, can
+     * therefore resolve to a perfectly concrete type that is the wrong side of
+     * the exchange — and, being concrete, it sails past the useless-type guard and
+     * publishes as an explicit contract.
+     *
+     * Nothing crosses an HTTP (or queue, or topic) boundary as a function, so the
+     * presence of call or construct signatures is a structural, framework-free
+     * proof that the resolution landed on machinery. The caller abstains, which
+     * leaves the row honestly unresolved instead of confidently wrong.
+     */
+    isCallableType(type) {
+        try {
+            return (type.getCallSignatures().length > 0 ||
+                type.getConstructSignatures().length > 0);
+        }
+        catch {
+            return false;
+        }
+    }
     unwrapExpressionNode(node) {
         let current = node;
         while (current) {
@@ -2799,6 +2847,9 @@ export class TypeInferrer {
     structuralTextFromTypeNode(typeNode) {
         try {
             const resolved = this.unwrapPromiseType(typeNode.getType());
+            if (this.isCallableType(resolved)) {
+                return null;
+            }
             const bare = typeText(resolved, typeNode);
             if (this.isUselessType(bare)) {
                 return null;
@@ -2817,6 +2868,9 @@ export class TypeInferrer {
     structuralTextFromType(type, at) {
         try {
             const resolved = this.unwrapPromiseType(type);
+            if (this.isCallableType(resolved)) {
+                return null;
+            }
             const bare = typeText(resolved, at);
             if (this.isUselessType(bare)) {
                 return null;
@@ -2891,9 +2945,24 @@ export class TypeInferrer {
      * the route declares its request nowhere we can read.
      */
     requestContractFromRegistration(registration, handler) {
+        return (this.declaredRequestContract(registration, handler) ??
+            this.inferRequestReadFromHandler(handler));
+    }
+    /**
+     * The request contract a route DECLARES, in anchor order: the handler's
+     * parameter annotation (a), the registration's schema object (b), then a
+     * validator middleware bound to the request body (b2).
+     *
+     * Both callers — the registration locator and the expression locator whose
+     * line is a registration — consult exactly this set, so the two cannot drift.
+     * The typed request READ inside the handler body is deliberately not part of
+     * it: that anchor is itself an expression, and the expression path keeps its
+     * own locator authoritative when a route declares nothing.
+     */
+    declaredRequestContract(registration, handler) {
         return (this.requestBodyFromHandlerParams(handler) ??
             this.routeSchemaContractText(registration, 'body') ??
-            this.inferRequestReadFromHandler(handler));
+            this.validatedBodyContractText(registration));
     }
     /**
      * Anchor (a): the request contract declared on the handler's own signature.
@@ -2934,6 +3003,58 @@ export class TypeInferrer {
         }
         return null;
     }
+    /**
+     * Anchor (b2): the contract declared by a VALIDATOR MIDDLEWARE on the
+     * registration (carrick#964).
+     *
+     * A route can declare its body by binding a schema to a named part of the
+     * request in a middleware the registration carries alongside the handler:
+     *
+     *   router.post('/search', validate('json', PayloadSchema), async (c) => …)
+     *
+     * The shape is a CALL among the registration's arguments whose own arguments
+     * are a request part and a schema value. Neither the middleware's name nor
+     * the schema library is checked: the part is read off the string literal, and
+     * the schema is whatever exposes a parsed output (`schemaOutputTypeText`) —
+     * the same test anchor (b) already applies to a `schema: { body: … }` object.
+     *
+     * `REQUEST_BODY_PARTS` is HTTP vocabulary for how a body is carried, not a
+     * framework list. A middleware bound to any other part (`query`, `param`,
+     * `header`, `cookie`) declares no BODY, and a middleware that names no part
+     * at all is not read: publishing a query schema as the request contract would
+     * be the same confident-and-wrong answer this anchor exists to remove.
+     */
+    validatedBodyContractText(registration) {
+        if (!Node.isCallExpression(registration)) {
+            return null;
+        }
+        for (const argument of registration.getArguments()) {
+            const middleware = this.unwrapExpressionNode(argument);
+            if (!Node.isCallExpression(middleware)) {
+                continue;
+            }
+            const middlewareArgs = middleware
+                .getArguments()
+                .map((arg) => this.unwrapExpressionNode(arg));
+            const parts = middlewareArgs.filter((arg) => Node.isStringLiteral(arg));
+            if (parts.length === 0) {
+                continue;
+            }
+            if (!parts.some((part) => REQUEST_BODY_PARTS.has(part.getLiteralValue().toLowerCase()))) {
+                continue;
+            }
+            for (const candidate of middlewareArgs) {
+                if (Node.isStringLiteral(candidate)) {
+                    continue;
+                }
+                const declared = this.schemaOutputTypeText(candidate);
+                if (declared) {
+                    return declared;
+                }
+            }
+        }
+        return null;
+    }
     /**
      * Anchor (b): the contract declared in the route's validation schema.
      *

package/dist/init/identity.d.ts

@@ -1,20 +0,0 @@
-export type Identity = {
-    /** The GitHub login, when the source could name one. */
-    login: string | null;
-    source: "gh" | "token";
-};
-export type IdentityLookup = {
-    identity: Identity | null;
-    /** What to do about it, ready to print. Null when there is an identity. */
-    problem: string | null;
-};
-export type IdentityOptions = {
-    env?: NodeJS.ProcessEnv;
-    /** Injectable for tests: runs `gh auth status` and returns its output. */
-    ghStatus?: () => string;
-};
-/** The login out of `gh auth status`, whatever wording it used. */
-export declare function loginFromGhStatus(output: string): string | null;
-export declare function githubIdentity(options?: IdentityOptions): IdentityLookup;
-/** One line for the summary. */
-export declare function describeIdentity(identity: Identity): string;

package/dist/init/identity.js

@@ -1,60 +0,0 @@
-// The GitHub identity `carrick init` requires.
-//
-// There is no anonymous tier (carrick#729, ruled 2026-09-08): the local index
-// is built from the identified free tier's allowance, so setup asks who you are
-// before it writes anything. The check is offline and reuses whatever the
-// machine already has — the GitHub CLI's login, or a token in the environment —
-// rather than opening a browser flow of its own.
-//
-// This states the identity. Spending an allowance against it is the cloud's
-// side (carrick-cloud#601) and is not wired here.
-import { spawnSync } from "node:child_process";
-function defaultGhStatus() {
-    // Both streams: `gh auth status` writes to stderr on older versions and to
-    // stdout on newer ones, and a run that reads one of them finds nothing on
-    // half the machines it runs on.
-    const run = spawnSync("gh", ["auth", "status"], { encoding: "utf8" });
-    if (run.error)
-        throw run.error;
-    return `${run.stdout ?? ""}\n${run.stderr ?? ""}`;
-}
-/** The login out of `gh auth status`, whatever wording it used. */
-export function loginFromGhStatus(output) {
-    const match = /Logged in to \S+ account (\S+)/.exec(output) ?? /Logged in to \S+ as (\S+)/.exec(output);
-    return match?.[1] ?? null;
-}
-export function githubIdentity(options = {}) {
-    const env = options.env ?? process.env;
-    const ghStatus = options.ghStatus ?? defaultGhStatus;
-    try {
-        const login = loginFromGhStatus(ghStatus());
-        if (login)
-            return { identity: { login, source: "gh" }, problem: null };
-    }
-    catch {
-        // No gh, or gh is not logged in. The token below is the other way in.
-    }
-    const token = env["GITHUB_TOKEN"] || env["GH_TOKEN"];
-    if (token)
-        return { identity: { login: null, source: "token" }, problem: null };
-    return {
-        identity: null,
-        problem: [
-            "carrick init needs your GitHub identity, and this machine has none it can use.",
-            "",
-            "Either:",
-            "  gh auth login                 (the GitHub CLI: https://cli.github.com)",
-            "  export GITHUB_TOKEN=<token>   (any token that identifies you)",
-            "",
-            "Carrick indexes what you already have access to, and the free tier's",
-            "allowance is counted against the account that asks for it.",
-        ].join("\n"),
-    };
-}
-/** One line for the summary. */
-export function describeIdentity(identity) {
-    return identity.login
-        ? `GitHub identity: ${identity.login} (from the GitHub CLI)`
-        : "GitHub identity: the token in this environment";
-}
-//# sourceMappingURL=identity.js.map

package/dist/init/identity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/init/identity.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,EAAE;AACF,8EAA8E;AAC9E,gFAAgF;AAChF,0EAA0E;AAC1E,gFAAgF;AAChF,iDAAiD;AACjD,EAAE;AACF,4EAA4E;AAC5E,kDAAkD;AAElD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAoB/C,SAAS,eAAe;IACtB,2EAA2E;IAC3E,0EAA0E;IAC1E,gCAAgC;IAChC,MAAM,GAAG,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IACtE,IAAI,GAAG,CAAC,KAAK;QAAE,MAAM,GAAG,CAAC,KAAK,CAAC;IAC/B,OAAO,GAAG,GAAG,CAAC,MAAM,IAAI,EAAE,KAAK,GAAG,CAAC,MAAM,IAAI,EAAE,EAAE,CAAC;AACpD,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,MAAM,KAAK,GACT,gCAAgC,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,2BAA2B,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5F,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,UAA2B,EAAE;IAC1D,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC;IACvC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAAC;IACrD,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,iBAAiB,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC5C,IAAI,KAAK;YAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IACzE,CAAC;IAAC,MAAM,CAAC;QACP,sEAAsE;IACxE,CAAC;IAED,MAAM,KAAK,GAAG,GAAG,CAAC,cAAc,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC;IACrD,IAAI,KAAK;QAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAEhF,OAAO;QACL,QAAQ,EAAE,IAAI;QACd,OAAO,EAAE;YACP,gFAAgF;YAChF,EAAE;YACF,SAAS;YACT,0EAA0E;YAC1E,iEAAiE;YACjE,EAAE;YACF,sEAAsE;YACtE,4DAA4D;SAC7D,CAAC,IAAI,CAAC,IAAI,CAAC;KACb,CAAC;AACJ,CAAC;AAED,gCAAgC;AAChC,MAAM,UAAU,gBAAgB,CAAC,QAAkB;IACjD,OAAO,QAAQ,CAAC,KAAK;QACnB,CAAC,CAAC,oBAAoB,QAAQ,CAAC,KAAK,wBAAwB;QAC5D,CAAC,CAAC,gDAAgD,CAAC;AACvD,CAAC"}