vouchington-tooling 0.35.0 → 0.36.0

package/dist/api-contract-discovery/registered-route-factory-returns.mjs

@@ -1,29 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-export function returnedExpressions(declaration) {
-    const body = declaration.body;
-    if (!ts.isBlock(body))
-        return [body];
-    const returned = [];
-    const collect = (node) => {
-        if (node !== declaration && ts.isFunctionLike(node))
-            return;
-        if (ts.isReturnStatement(node)) {
-            returned.push(node.expression);
-            return;
-        }
-        node.forEachChild(collect);
-    };
-    body.forEachChild(collect);
-    return returned;
-}
-export function returnsOnEveryPath(node) {
-    if (ts.isBlock(node))
-        return node.statements.some(returnsOnEveryPath);
-    if (ts.isReturnStatement(node))
-        return true;
-    if (ts.isIfStatement(node))
-        return (!!node.elseStatement &&
-            returnsOnEveryPath(node.thenStatement) &&
-            returnsOnEveryPath(node.elseStatement));
-    return !ts.isStatement(node);
-}

package/dist/api-contract-discovery/registered-route-handler-analysis.d.mts

@@ -1,12 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export type HandlerProof = {
-    node: ts.FunctionLikeDeclaration;
-    bindings: Map<ts.Symbol, ts.Expression>;
-    /** Set under `executableReturns` when a runtime branch selects the handler. */
-    conditional?: boolean;
-};
-export declare function handlerNodes(argument: ts.Expression, checker: ts.TypeChecker, parameterBindings?: Map<ts.Symbol, ts.Expression>, active?: Set<ts.Node>, staticProof?: boolean, proofs?: HandlerProof[], 
-/** Ignore `let`, `var` and reassigned bindings; always on under `staticProof`. */
-stableBindings?: boolean, 
-/** Ignore returned values on statically dead paths, and mark runtime-branch ones conditional. */
-executableReturns?: boolean): ts.Node[];

package/dist/api-contract-discovery/registered-route-handler-analysis.mjs

@@ -1,119 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { returnedExpressions, returnsOnEveryPath } from './registered-route-factory-returns.mjs';
-import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
-import { potentiallyExecuted } from './protocol-executable-path.mjs';
-import { hasBindingWrite } from './registered-route-binding-writes.mjs';
-import { hasStableBinding, unwrapHandlerExpression } from './registered-route-handler-helpers.mjs';
-import { isConditionalPosition } from './request-validation-conditional.mjs';
-export function handlerNodes(argument, checker, parameterBindings = new Map(), active = new Set(), staticProof = false, proofs, 
-/** Ignore `let`, `var` and reassigned bindings; always on under `staticProof`. */
-stableBindings = staticProof, 
-/** Ignore returned values on statically dead paths, and mark runtime-branch ones conditional. */
-executableReturns = false) {
-    const again = (node, bindings = parameterBindings, seen = active, sink = proofs) => handlerNodes(node, checker, bindings, seen, staticProof, sink, stableBindings, executableReturns);
-    const unwrapped = unwrapHandlerExpression(argument);
-    if (unwrapped !== argument)
-        return again(unwrapped);
-    let bound = argument;
-    const boundIdentifiers = new Set();
-    while (ts.isIdentifier(bound)) {
-        const symbol = checker.getSymbolAtLocation(bound);
-        const nextArgument = symbol && parameterBindings.get(symbol);
-        if (!nextArgument)
-            break;
-        if (boundIdentifiers.has(bound))
-            return [];
-        boundIdentifiers.add(bound);
-        bound = nextArgument;
-    }
-    if (bound !== argument)
-        return again(bound);
-    if (active.has(argument))
-        return [];
-    const next = new Set(active).add(argument);
-    if (ts.isArrowFunction(argument) || ts.isFunctionExpression(argument)) {
-        proofs?.push({ node: argument, bindings: parameterBindings });
-        return [argument];
-    }
-    if (ts.isCallExpression(argument)) {
-        const resolvedProofs = [];
-        const groups = callableImplementations(argument.expression, checker, staticProof, stableBindings).map((implementation) => {
-            if (staticProof &&
-                (implementation.asteriskToken ||
-                    implementation.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ||
-                    runtimeParameters(implementation).some((parameter) => hasBindingWrite(parameter, checker))))
-                return [];
-            const bindings = new Map(parameterBindings);
-            runtimeParameters(implementation).forEach((parameter, index) => {
-                const callArgument = argument.arguments[index];
-                const symbol = checker.getSymbolAtLocation(parameter.name);
-                if (callArgument && symbol)
-                    bindings.set(symbol, callArgument);
-            });
-            const returned = returnedExpressions(implementation).filter((value) => !executableReturns || !value || potentiallyExecuted(value));
-            if (staticProof &&
-                (!returnsOnEveryPath(implementation.body) || returned.some((value) => !value)))
-                return [];
-            const results = returned.map((value) => {
-                const selected = [];
-                const found = value ? again(value, bindings, next, selected) : [];
-                if (executableReturns && value && isConditionalPosition(value))
-                    selected.forEach((proof) => (proof.conditional = true));
-                resolvedProofs.push(...selected);
-                return found;
-            });
-            return staticProof && results.some((result) => !result.some(ts.isFunctionLike))
-                ? []
-                : results.flat();
-        });
-        if (staticProof && groups.some((group) => group.length === 0))
-            return [];
-        proofs?.push(...resolvedProofs);
-        return groups.flat();
-    }
-    return declarationImplementations(argument, checker, next, staticProof, parameterBindings, proofs, stableBindings, executableReturns);
-}
-function callableImplementations(node, checker, staticProof = false, stableBindings = staticProof) {
-    const symbol = checker.getSymbolAtLocation(node);
-    if (!symbol)
-        return [];
-    const resolved = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-    const implementations = [];
-    for (const declaration of resolved.declarations ?? []) {
-        if (stableBindings && !hasStableBinding(declaration, checker))
-            continue;
-        if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
-            const initializer = unwrapHandlerExpression(declaration.initializer);
-            if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer))
-                implementations.push(initializer);
-            continue;
-        }
-        if ((ts.isFunctionDeclaration(declaration) ||
-            (!staticProof && ts.isMethodDeclaration(declaration))) &&
-            declaration.body)
-            implementations.push(declaration);
-    }
-    return implementations;
-}
-function declarationImplementations(node, checker, active, staticProof, parameterBindings, proofs, stableBindings = staticProof, executableReturns = false) {
-    const symbol = checker.getSymbolAtLocation(node);
-    if (!symbol)
-        return [];
-    const resolved = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-    return (resolved.declarations ?? []).flatMap((declaration) => {
-        if (stableBindings && !hasStableBinding(declaration, checker))
-            return [];
-        if (ts.isFunctionDeclaration(declaration) ||
-            (!staticProof && ts.isMethodDeclaration(declaration))) {
-            if (declaration.body)
-                proofs?.push({ node: declaration, bindings: parameterBindings });
-            return declaration.body ? [declaration] : [];
-        }
-        if (ts.isVariableDeclaration(declaration) && declaration.initializer)
-            return [
-                declaration,
-                ...handlerNodes(declaration.initializer, checker, parameterBindings, active, staticProof, proofs, stableBindings, executableReturns),
-            ];
-        return [];
-    });
-}

package/dist/api-contract-discovery/registered-route-handler-helpers.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function hasStableBinding(declaration: ts.Declaration, checker: ts.TypeChecker): boolean;
-export declare function unwrapHandlerExpression(node: ts.Expression): ts.Expression;

package/dist/api-contract-discovery/registered-route-handler-helpers.mjs

@@ -1,16 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { hasBindingWrite } from './registered-route-binding-writes.mjs';
-export function hasStableBinding(declaration, checker) {
-    if (ts.isVariableDeclaration(declaration))
-        return (ts.isVariableDeclarationList(declaration.parent) &&
-            !!(declaration.parent.flags & ts.NodeFlags.Const));
-    return !ts.isFunctionDeclaration(declaration) || !hasBindingWrite(declaration, checker);
-}
-export function unwrapHandlerExpression(node) {
-    while (ts.isParenthesizedExpression(node) ||
-        ts.isAsExpression(node) ||
-        ts.isTypeAssertionExpression(node) ||
-        ts.isSatisfiesExpression(node))
-        node = node.expression;
-    return node;
-}

package/dist/api-contract-discovery/registered-route-runtime-parameters.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/** TypeScript's explicit this parameter is erased and consumes no runtime argument. */
-export declare function runtimeParameters(node: ts.FunctionLikeDeclaration): ts.ParameterDeclaration[];

package/dist/api-contract-discovery/registered-route-runtime-parameters.mjs

@@ -1,5 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-/** TypeScript's explicit this parameter is erased and consumes no runtime argument. */
-export function runtimeParameters(node) {
-    return node.parameters.filter((parameter) => !ts.isIdentifier(parameter.name) || parameter.name.text !== 'this');
-}

package/dist/api-contract-discovery/registered-route-terminal-error.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/** Proves a terminal 405 on the handler's own context, rather than finding a nested throw. */
-export declare function isTerminal405Handler(node: ts.Node, checker: ts.TypeChecker, bindings?: Map<ts.Symbol, ts.Expression>): boolean;

package/dist/api-contract-discovery/registered-route-terminal-error.mjs

@@ -1,98 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
-import { handlerNodes } from './registered-route-handler-analysis.mjs';
-/** Proves a terminal 405 on the handler's own context, rather than finding a nested throw. */
-export function isTerminal405Handler(node, checker, bindings = new Map()) {
-    if (!(ts.isArrowFunction(node) ||
-        ts.isFunctionExpression(node) ||
-        ts.isFunctionDeclaration(node) ||
-        ts.isMethodDeclaration(node)) ||
-        !node.body)
-        return false;
-    const context = runtimeParameters(node)[0]?.name;
-    const symbol = context && ts.isIdentifier(context) ? checker.getSymbolAtLocation(context) : undefined;
-    return !!symbol && terminalBody(node, symbol, checker, new Set(), true, bindings);
-}
-function terminalBody(node, context, checker, active, returned = true, bindings = new Map()) {
-    if (!node.body || node.asteriskToken || active.has(node))
-        return false;
-    if (node.parameters.some((parameter) => !ts.isIdentifier(parameter.name) ||
-        parameter.dotDotDotToken ||
-        (parameter.initializer && !ts.isLiteralExpression(parameter.initializer))))
-        return false;
-    const next = new Set(active).add(node);
-    if (!ts.isBlock(node.body))
-        return terminalCall(node.body, context, checker, next, returned, bindings);
-    const statements = node.body.statements;
-    const terminal = statements.at(-1);
-    if (!terminal ||
-        !statements.slice(0, -1).every((statement) => isInertStatement(statement, context, checker)))
-        return false;
-    if (ts.isExpressionStatement(terminal))
-        return terminalCall(terminal.expression, context, checker, next, false, bindings);
-    return (ts.isReturnStatement(terminal) &&
-        !!terminal.expression &&
-        terminalCall(terminal.expression, context, checker, next, returned, bindings));
-}
-function terminalCall(expression, context, checker, active, returned, bindings) {
-    if (ts.isAwaitExpression(expression))
-        return terminalCall(expression.expression, context, checker, active, true, bindings);
-    if (ts.isParenthesizedExpression(expression))
-        return terminalCall(expression.expression, context, checker, active, returned, bindings);
-    if (!ts.isCallExpression(expression) || expression.questionDotToken)
-        return false;
-    if (expression.arguments.some((argument) => !ts.isIdentifier(argument) && !ts.isLiteralExpression(argument)))
-        return false;
-    const callee = expression.expression;
-    if (ts.isPropertyAccessExpression(callee) && callee.name.text === 'throw') {
-        const status = expression.arguments[0];
-        return (!callee.questionDotToken &&
-            ts.isIdentifier(callee.expression) &&
-            checker.getSymbolAtLocation(callee.expression) === context &&
-            !!status &&
-            ts.isNumericLiteral(status) &&
-            Number(status.text) === 405);
-    }
-    if (!ts.isIdentifier(callee))
-        return false;
-    const implementations = [];
-    handlerNodes(callee, checker, bindings, new Set(), true, implementations);
-    if (!returned && checker.getPropertyOfType(checker.getTypeAtLocation(expression), 'then'))
-        return false;
-    return (implementations.length > 0 &&
-        implementations.every(({ node: implementation, bindings: captured }) => {
-            if (!returned &&
-                implementation.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword))
-                return false;
-            const index = expression.arguments.findIndex((argument) => ts.isIdentifier(argument) && checker.getSymbolAtLocation(argument) === context);
-            const parameter = runtimeParameters(implementation)[index]?.name;
-            const symbol = parameter && ts.isIdentifier(parameter) ? checker.getSymbolAtLocation(parameter) : undefined;
-            return !!symbol && terminalBody(implementation, symbol, checker, active, returned, captured);
-        }));
-}
-function isInertStatement(statement, context, checker) {
-    if (ts.isEmptyStatement(statement))
-        return true;
-    if (ts.isExpressionStatement(statement)) {
-        const expression = statement.expression;
-        if (ts.isStringLiteral(expression))
-            return true;
-        if (!ts.isCallExpression(expression) || expression.arguments.length !== 2)
-            return false;
-        const callee = expression.expression;
-        const [header, value] = expression.arguments;
-        return (ts.isPropertyAccessExpression(callee) &&
-            callee.name.text === 'set' &&
-            ts.isIdentifier(callee.expression) &&
-            checker.getSymbolAtLocation(callee.expression) === context &&
-            ts.isStringLiteral(header) &&
-            header.text.toLowerCase() === 'allow' &&
-            ts.isStringLiteral(value) &&
-            /^[A-Z]+(?:, *[A-Z]+)*$/.test(value.text));
-    }
-    if (!ts.isVariableStatement(statement))
-        return false;
-    return statement.declarationList.declarations.every((declaration) => ts.isIdentifier(declaration.name) &&
-        checker.getSymbolAtLocation(declaration.name) !== context &&
-        (!declaration.initializer || ts.isLiteralExpression(declaration.initializer)));
-}

package/dist/api-contract-discovery/request-contract-implicit.d.mts

@@ -1,17 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type DiscoverApiRequestContractsOptions } from './request-contract-lenient.mts';
-import { type HandlerBindings } from './response-contract-route-analysis.mts';
-import type { BackendRequestContract } from './request-contract-types.mts';
-/**
- * Phase 2 (implicit harvest) dispatch for one call expression. Requests have no `#variant` escape
- * hatch, so precedence is stricter than the response side's: an explicit `apiRequest`/
- * `apiNoRequestBody` marker registered in Phase 1 (`markerKeys`) always wins outright — a harvest
- * never even attempts to register over one. A second implicit body-read for a route an earlier
- * implicit call already covered attempts registration but swallows any failure (extraction error
- * or hash mismatch), keeping the first-registered contract untouched — mirrors
- * `response-contract-implicit.mts`'s secondary-variant handling, minus the variant key (requests
- * get at most one contract per route). A `ctx.request.buffer(...)` read always overrides,
- * regardless of visit order or what's already registered, mirroring the response side's own
- * buffer-detection override.
- */
-export declare function discoverImplicitRequestContract(call: ts.CallExpression, checker: ts.TypeChecker, sourceFile: ts.SourceFile, contracts: Map<string, BackendRequestContract>, markerKeys: ReadonlySet<string>, handlerBindings: HandlerBindings, requestedKeys: ReadonlySet<string> | undefined, options: DiscoverApiRequestContractsOptions | undefined): void;

package/dist/api-contract-discovery/request-contract-implicit.mjs

@@ -1,73 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { extractContractSchema } from '../contract-schema/index.mjs';
-import { markBufferedRequestRouteUnavailable, registerRequestContract, registerRequestRouteContract, } from './request-contract-lenient.mjs';
-import { enclosingRequestBodyCast, isContextRequestBufferCall, isContextRequestJsonCall, } from './request-contract-route-analysis.mjs';
-import { sourceLocation } from './response-contract-registration.mjs';
-import { enclosingRouteBinding, requestedKeyForBinding, } from './response-contract-route-analysis.mjs';
-/**
- * Resolves the effective static type of a body-read call, or `undefined` when `call` isn't a
- * body-read pattern this harvester recognizes at all (most call expressions in a route file
- * aren't). `parseJsonBody<T>(ctx)`'s own call-expression type is `Promise<T>` (or `Promise<unknown>`
- * with no type argument) — `extractContractSchema` auto-unwraps the `Promise` either way, so no
- * special-casing is needed. `ctx.request.json(...)` has no such generic in practice; its effective
- * type comes from the enclosing `as T` cast, when one exists (`enclosingRequestBodyCast`) — absent
- * one, the call's own type is `Promise<unknown>`, which resolves to an honest `{type:'unknown'}`
- * rather than a failure (see `enclosingRequestBodyCast`'s docstring).
- */
-function resolveRequestBodyType(call, checker) {
-    if (ts.isIdentifier(call.expression) && call.expression.text === 'parseJsonBody') {
-        return checker.getTypeAtLocation(call);
-    }
-    if (!isContextRequestJsonCall(call.expression))
-        return undefined;
-    const cast = enclosingRequestBodyCast(call);
-    return checker.getTypeAtLocation(cast ?? call);
-}
-/**
- * Phase 2 (implicit harvest) dispatch for one call expression. Requests have no `#variant` escape
- * hatch, so precedence is stricter than the response side's: an explicit `apiRequest`/
- * `apiNoRequestBody` marker registered in Phase 1 (`markerKeys`) always wins outright — a harvest
- * never even attempts to register over one. A second implicit body-read for a route an earlier
- * implicit call already covered attempts registration but swallows any failure (extraction error
- * or hash mismatch), keeping the first-registered contract untouched — mirrors
- * `response-contract-implicit.mts`'s secondary-variant handling, minus the variant key (requests
- * get at most one contract per route). A `ctx.request.buffer(...)` read always overrides,
- * regardless of visit order or what's already registered, mirroring the response side's own
- * buffer-detection override.
- */
-export function discoverImplicitRequestContract(call, checker, sourceFile, contracts, markerKeys, handlerBindings, requestedKeys, options) {
-    const binding = enclosingRouteBinding(call, checker, handlerBindings);
-    if (!binding)
-        return;
-    const key = requestedKeyForBinding(binding, requestedKeys);
-    if (!key)
-        return;
-    if (isContextRequestBufferCall(call.expression)) {
-        markBufferedRequestRouteUnavailable(contracts, key, binding, sourceLocation(sourceFile, call));
-        return;
-    }
-    if (markerKeys.has(key))
-        return; // An explicit Phase 1 marker always wins; never harvest over it.
-    const bodyType = resolveRequestBodyType(call, checker);
-    if (!bodyType)
-        return;
-    const location = sourceLocation(sourceFile, call);
-    const extract = () => extractContractSchema(bodyType, checker, location, options);
-    if (!contracts.has(key)) {
-        registerRequestRouteContract(contracts, key, binding, location, extract, options);
-        return;
-    }
-    // A second body-read call for a route an earlier implicit harvest already covered — attempt
-    // registration but silently drop it on a hash-mismatch collision, keeping the
-    // first-registered contract. Anything else (a type-checker crash, an AST invariant
-    // violation) is unexpected and worth surfacing rather than swallowing.
-    try {
-        const extracted = extract();
-        registerRequestContract(contracts, key, { ...extracted, ...binding });
-    }
-    catch (error) {
-        if (error instanceof Error && !error.message.includes('resolves to multiple')) {
-            console.warn(`Second body-read extraction for "${key}" failed:`, error);
-        }
-    }
-}

package/dist/api-contract-discovery/request-contract-lenient.d.mts

@@ -1,28 +0,0 @@
-import type { ExtractedResponseContract, ExtractContractSchemaOptions } from '../contract-schema/index.mts';
-import type { RouteBinding } from './response-contract-route-analysis.mts';
-import type { RouteDiscoveryError } from './response-contract-lenient.mts';
-import type { BackendRequestContract } from './request-contract-types.mts';
-export type DiscoverApiRequestContractsOptions = ExtractContractSchemaOptions & {
-    onRouteError?: (error: RouteDiscoveryError) => void;
-};
-/**
- * Marks `key` unavailable regardless of AST visit order or what else is already registered for
- * this route (an explicit marker, or an earlier implicit harvest) — a raw buffered body's shape
- * is never statically determinable, so it always wins. Mirrors the response side's
- * `markBufferedRouteUnavailable` for `ctx.response.buffer(...)`.
- */
-export declare function markBufferedRequestRouteUnavailable(contracts: Map<string, BackendRequestContract>, key: string, binding: RouteBinding, source: string): void;
-/**
- * Inserts `contract` at `key`, throwing if `key` already resolves to a different schema. Requests
- * have no `#variant` escape hatch, so — unlike the response side, where a genuine collision is
- * always a real author bug worth surfacing — callers here must choose deliberately whether a
- * mismatch should throw (an explicit marker collision) or be caught (an implicit harvest
- * collision); see `request-contract-implicit.mts`.
- */
-export declare function registerRequestContract(contracts: Map<string, BackendRequestContract>, key: string, contract: BackendRequestContract): void;
-/**
- * Extracts a route's request contract and registers it. When `options.onRouteError` is set, an
- * extraction failure is caught, reported, and replaced with an `unavailable` placeholder instead
- * of aborting discovery for every other route — mirrors the response side's `registerRouteContract`.
- */
-export declare function registerRequestRouteContract(contracts: Map<string, BackendRequestContract>, key: string, binding: RouteBinding, location: string, extract: () => ExtractedResponseContract, options: DiscoverApiRequestContractsOptions | undefined): void;

package/dist/api-contract-discovery/request-contract-lenient.mjs

@@ -1,59 +0,0 @@
-import { hashContractSchema } from '../contract-schema/index.mjs';
-/** Placeholder contract for a route whose request body could not be extracted. */
-function unavailableRequestContract(source, reason) {
-    const schema = { root: { type: 'unknown' }, definitions: {} };
-    return { source, schema, hash: hashContractSchema(schema), unavailableReason: reason };
-}
-/**
- * Marks `key` unavailable regardless of AST visit order or what else is already registered for
- * this route (an explicit marker, or an earlier implicit harvest) — a raw buffered body's shape
- * is never statically determinable, so it always wins. Mirrors the response side's
- * `markBufferedRouteUnavailable` for `ctx.response.buffer(...)`.
- */
-export function markBufferedRequestRouteUnavailable(contracts, key, binding, source) {
-    contracts.set(key, {
-        ...unavailableRequestContract(source, 'route reads a raw buffered request body (ctx.request.buffer) whose shape is not statically determinable'),
-        ...binding,
-    });
-}
-/**
- * Inserts `contract` at `key`, throwing if `key` already resolves to a different schema. Requests
- * have no `#variant` escape hatch, so — unlike the response side, where a genuine collision is
- * always a real author bug worth surfacing — callers here must choose deliberately whether a
- * mismatch should throw (an explicit marker collision) or be caught (an implicit harvest
- * collision); see `request-contract-implicit.mts`.
- */
-export function registerRequestContract(contracts, key, contract) {
-    const existing = contracts.get(key);
-    if (!existing) {
-        contracts.set(key, contract);
-        return;
-    }
-    if (existing.hash !== contract.hash) {
-        throw new Error(`Backend request contract "${key}" resolves to multiple backend request schemas at ${existing.source} and ${contract.source}`);
-    }
-}
-/**
- * Extracts a route's request contract and registers it. When `options.onRouteError` is set, an
- * extraction failure is caught, reported, and replaced with an `unavailable` placeholder instead
- * of aborting discovery for every other route — mirrors the response side's `registerRouteContract`.
- */
-export function registerRequestRouteContract(contracts, key, binding, location, extract, options) {
-    let extracted;
-    try {
-        extracted = extract();
-    }
-    catch (error) {
-        if (!options?.onRouteError)
-            throw error;
-        const reason = error instanceof Error ? error.message : String(error);
-        options.onRouteError({
-            method: binding.method,
-            routeTemplate: binding.routeTemplate,
-            source: location,
-            reason,
-        });
-        extracted = unavailableRequestContract(location, reason);
-    }
-    registerRequestContract(contracts, key, { ...extracted, ...binding });
-}

package/dist/api-contract-discovery/request-contract-registry.d.mts

@@ -1,14 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type DiscoverApiRequestContractsOptions } from './request-contract-lenient.mts';
-import type { BackendRequestContract } from './request-contract-types.mts';
-export type { BackendRequestContract } from './request-contract-types.mts';
-export type { DiscoverApiRequestContractsOptions } from './request-contract-lenient.mts';
-/**
- * Two full passes over every route file, mirroring `discoverApiResponseContracts`: Phase 1
- * (explicit request-contract markers) completes for every file before Phase 2
- * (implicit harvest of `parseJsonBody`/`ctx.request.json(...) as T`/`ctx.request.buffer(...)`)
- * begins, so a marker anywhere always wins over a harvest anywhere regardless of visit order.
- * `markerKeys` records every key an explicit marker claimed (a body, or a deliberate
- * `apiNoRequestBody` suppression) so Phase 2 knows to never harvest over it.
- */
-export declare function discoverApiRequestContracts(program: ts.Program, sourceFiles: readonly ts.SourceFile[], requestedKeys?: ReadonlySet<string>, options?: DiscoverApiRequestContractsOptions): Record<string, BackendRequestContract>;

package/dist/api-contract-discovery/request-contract-registry.mjs

@@ -1,63 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { registerPlatformCompilerLibraries } from './protocol-platform-callbacks.mjs';
-import { extractContractSchema } from '../contract-schema/index.mjs';
-import { registerRequestRouteContract, } from './request-contract-lenient.mjs';
-import { discoverImplicitRequestContract } from './request-contract-implicit.mjs';
-import { requestMarker } from './request-contract-route-analysis.mjs';
-import { contractError, sourceLocation } from './response-contract-registration.mjs';
-import { collectHandlerBindings, enclosingRouteBinding, visit, } from './response-contract-route-analysis.mjs';
-/**
- * Two full passes over every route file, mirroring `discoverApiResponseContracts`: Phase 1
- * (explicit request-contract markers) completes for every file before Phase 2
- * (implicit harvest of `parseJsonBody`/`ctx.request.json(...) as T`/`ctx.request.buffer(...)`)
- * begins, so a marker anywhere always wins over a harvest anywhere regardless of visit order.
- * `markerKeys` records every key an explicit marker claimed (a body, or a deliberate
- * `apiNoRequestBody` suppression) so Phase 2 knows to never harvest over it.
- */
-export function discoverApiRequestContracts(program, sourceFiles, requestedKeys, options) {
-    registerPlatformCompilerLibraries(program);
-    const checker = program.getTypeChecker();
-    const contracts = new Map();
-    const markerKeys = new Set();
-    const handlerBindings = collectHandlerBindings(sourceFiles, checker);
-    for (const sourceFile of sourceFiles) {
-        visit(sourceFile, (node) => {
-            if (!ts.isCallExpression(node))
-                return;
-            const marker = requestMarker(node.expression);
-            if (!marker)
-                return;
-            const keyNode = node.arguments[0];
-            if (!keyNode || !ts.isStringLiteral(keyNode)) {
-                throw contractError(sourceFile, node, `${marker} requires a literal contract key`);
-            }
-            const binding = enclosingRouteBinding(node, checker, handlerBindings);
-            if (!binding)
-                throw contractError(sourceFile, node, `${marker} must be inside an app.route handler`);
-            const expectedKey = `${binding.method}:${binding.routeTemplate}`;
-            if (keyNode.text !== expectedKey) {
-                // Requests have no `#variant` escape hatch (unlike responses) — the key must match exactly.
-                throw contractError(sourceFile, keyNode, `Contract key "${keyNode.text}" does not match enclosing route ${expectedKey}`);
-            }
-            markerKeys.add(keyNode.text);
-            if (marker === 'apiNoRequestBody')
-                return; // Deliberate suppression: no contract, harvest skips this key.
-            const bodyNode = node.arguments[1];
-            const typeNode = node.typeArguments?.[1];
-            if (marker === 'apiRequest' && !bodyNode)
-                throw contractError(sourceFile, node, 'apiRequest requires a request body');
-            if (marker === 'apiRequestContract' && !typeNode)
-                throw contractError(sourceFile, node, 'apiRequestContract requires a request body type');
-            const location = sourceLocation(sourceFile, node);
-            registerRequestRouteContract(contracts, keyNode.text, binding, location, () => extractContractSchema(typeNode ? checker.getTypeFromTypeNode(typeNode) : checker.getTypeAtLocation(bodyNode), checker, location, options), options);
-        });
-    }
-    for (const sourceFile of sourceFiles) {
-        visit(sourceFile, (node) => {
-            if (!ts.isCallExpression(node) || requestMarker(node.expression))
-                return;
-            discoverImplicitRequestContract(node, checker, sourceFile, contracts, markerKeys, handlerBindings, requestedKeys, options);
-        });
-    }
-    return Object.fromEntries([...contracts.entries()].toSorted(([left], [right]) => left.localeCompare(right)));
-}

package/dist/api-contract-discovery/request-contract-route-analysis.d.mts

@@ -1,25 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/**
- * Detects the request-contract markers in the version-one route convention.
- * Kept out of `responseMarker` (which only recognizes `apiResponse`/`apiNoContent`) so the two
- * AST walks never interfere — see `response-contract-route-analysis.mts` for the response side.
- */
-export declare function requestMarker(expression: ts.Expression): 'apiRequest' | 'apiRequestContract' | 'apiNoRequestBody' | undefined;
-/**
- * Detects `ctx.request.json(...)`: a two-level nested access (`ctx.request` then `.json`) that
- * `isContextMethod`'s single-level match can't see through directly — mirrors
- * `isContextResponseBufferCall`'s own two-level pattern on the response side.
- */
-export declare function isContextRequestJsonCall(expression: ts.Expression): boolean;
-/** Detects `ctx.request.buffer(...)`: a raw request body whose shape can't be statically extracted. */
-export declare function isContextRequestBufferCall(expression: ts.Expression): boolean;
-/**
- * Walks up from a `ctx.request.json(...)` call expression to find the enclosing `as T` cast that
- * gives it a static type, unwrapping the wrapper shapes real call sites use in between:
- * `(await ctx.request.json(...)) as T` and the `.catch()`-guarded
- * `(await ctx.request.json(...).catch(() => ({}))) as T`.
- * Returns `undefined` when no enclosing cast exists (e.g. the read feeds directly into another
- * call, `parseFoo(await ctx.request.json())`) — the caller treats that as an honest untyped
- * success, not a failure.
- */
-export declare function enclosingRequestBodyCast(call: ts.CallExpression): ts.AsExpression | undefined;