vouchington-tooling 0.34.0 → 0.36.0

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

@@ -1,70 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { registerPlatformCompilerLibraries } from './protocol-platform-callbacks.mjs';
-import { extractQueryParameterDescriptor } from './query-contract-extraction.mjs';
-import { contractError } from './response-contract-registration.mjs';
-import { collectHandlerBindings, enclosingRouteBinding, visit, } from './response-contract-route-analysis.mjs';
-export function discoverApiQueryContracts(program, sourceFiles, knownResponseRoutes) {
-    registerPlatformCompilerLibraries(program);
-    const checker = program.getTypeChecker();
-    const handlerBindings = collectHandlerBindings(sourceFiles, checker);
-    const contracts = new Map();
-    const knownOperations = new Set([...knownResponseRoutes].map((key) => key.split('#')[0]));
-    for (const sourceFile of sourceFiles) {
-        visit(sourceFile, (node) => {
-            if (!ts.isCallExpression(node) || !isApiQueryMarker(node.expression))
-                return;
-            const keyNode = node.arguments[0];
-            if (!keyNode || !ts.isStringLiteral(keyNode)) {
-                throw contractError(sourceFile, node, 'apiQuery requires a literal operation key');
-            }
-            const binding = enclosingRouteBinding(node, checker, handlerBindings);
-            if (!binding)
-                throw contractError(sourceFile, node, 'apiQuery must be inside an app.route handler');
-            const expectedKey = `${binding.method}:${binding.routeTemplate}`;
-            if (keyNode.text !== expectedKey) {
-                throw contractError(sourceFile, keyNode, `Query operation key "${keyNode.text}" does not match enclosing route ${expectedKey}`);
-            }
-            if (!knownOperations.has(expectedKey)) {
-                throw contractError(sourceFile, keyNode, `apiQuery references unknown response route ${expectedKey}`);
-            }
-            if (contracts.has(expectedKey)) {
-                throw contractError(sourceFile, keyNode, `Duplicate apiQuery marker for ${expectedKey}`);
-            }
-            if (node.arguments.length < 2) {
-                throw contractError(sourceFile, node, 'apiQuery requires at least one query contract carrier');
-            }
-            const parameters = Object.create(null);
-            for (const carrier of node.arguments.slice(1)) {
-                const carrierType = checker.getTypeAtLocation(carrier);
-                const queryContractSymbol = carrierType.getProperty('queryContract');
-                if (!queryContractSymbol || queryContractSymbol.flags & ts.SymbolFlags.Optional) {
-                    throw contractError(sourceFile, carrier, 'apiQuery carrier requires a queryContract property');
-                }
-                const queryContractType = checker.getTypeOfSymbolAtLocation(queryContractSymbol, carrier);
-                if (queryContractType.getStringIndexType()) {
-                    throw contractError(sourceFile, carrier, 'apiQuery queryContract keys must be literal names');
-                }
-                const properties = queryContractType.getProperties();
-                if (properties.length === 0) {
-                    throw contractError(sourceFile, carrier, 'apiQuery queryContract must define parameters');
-                }
-                for (const property of properties) {
-                    const name = property.getName();
-                    if (property.flags & ts.SymbolFlags.Optional) {
-                        throw contractError(sourceFile, carrier, `Query parameter "${name}" must not be optional`);
-                    }
-                    if (Object.hasOwn(parameters, name)) {
-                        throw contractError(sourceFile, carrier, `Duplicate query parameter contract: ${name}`);
-                    }
-                    const descriptorType = checker.getTypeOfSymbolAtLocation(property, carrier);
-                    parameters[name] = extractQueryParameterDescriptor(descriptorType, checker, sourceFile, carrier, name);
-                }
-            }
-            contracts.set(expectedKey, { ...binding, parameters });
-        });
-    }
-    return Object.fromEntries([...contracts.entries()].toSorted(([left], [right]) => left.localeCompare(right)));
-}
-function isApiQueryMarker(expression) {
-    return ts.isIdentifier(expression) && expression.text === 'apiQuery';
-}

package/dist/api-contract-discovery/query-contract-types.d.mts

@@ -1,8 +0,0 @@
-import type { OpenApiQueryContract, OpenApiQueryParameter } from '../openapi-document/index.mts';
-export type QueryParameterContract = OpenApiQueryParameter;
-export type BackendQueryContract = {
-    method: string;
-    routeTemplate: string;
-    parameters: OpenApiQueryContract;
-};
-export type BackendQueryContractRegistry = Readonly<Record<string, BackendQueryContract>>;

package/dist/api-contract-discovery/registered-route-binding-writes.d.mts

@@ -1,4 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ProtocolCache } from './protocol-analysis-cache.mts';
-/** Helper and factory parameter bindings must remain unchanged in their declaring source. */
-export declare function hasBindingWrite(declaration: ts.FunctionDeclaration | ts.ParameterDeclaration, checker: ts.TypeChecker, cache?: ProtocolCache): boolean;

package/dist/api-contract-discovery/registered-route-binding-writes.mjs

@@ -1,47 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-/** Every symbol assigned, updated, or looped over in the source file, found in one scan. */
-function writtenSymbols(sourceFile, checker) {
-    const written = new Set();
-    const referencesBinding = (node) => {
-        // Index expressions and computed property names read their keys, not write them.
-        // inspect still visits these expressions separately to detect nested side-effect writes.
-        if (ts.isComputedPropertyName(node))
-            return;
-        if (ts.isElementAccessExpression(node)) {
-            referencesBinding(node.expression);
-            return;
-        }
-        if (ts.isIdentifier(node))
-            written.add(checker.getSymbolAtLocation(node));
-        node.forEachChild(referencesBinding);
-    };
-    const inspect = (node) => {
-        if (ts.isBinaryExpression(node) &&
-            node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
-            node.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
-            referencesBinding(node.left);
-        if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
-            (node.operator === ts.SyntaxKind.PlusPlusToken ||
-                node.operator === ts.SyntaxKind.MinusMinusToken))
-            referencesBinding(node.operand);
-        if (ts.isForOfStatement(node) || ts.isForInStatement(node))
-            referencesBinding(node.initializer);
-        node.forEachChild(inspect);
-    };
-    inspect(sourceFile);
-    return written;
-}
-/** Helper and factory parameter bindings must remain unchanged in their declaring source. */
-export function hasBindingWrite(declaration, checker, cache) {
-    if (!declaration.name)
-        return false;
-    if (!ts.isIdentifier(declaration.name))
-        return true;
-    const sourceFile = declaration.getSourceFile();
-    let written = cache?.writtenSymbols.get(sourceFile);
-    if (!written) {
-        written = writtenSymbols(sourceFile, checker);
-        cache?.writtenSymbols.set(sourceFile, written);
-    }
-    return written.has(checker.getSymbolAtLocation(declaration.name));
-}

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

@@ -1,10 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export type RegisteredRoute = {
-    method: string;
-    routeTemplate: string;
-    kind: 'ordinary' | 'sse' | 'error-only' | 'fixed-no-content';
-    fixedStatus?: number;
-    source: string;
-};
-export declare const routeShape: (routeTemplate: string) => string;
-export declare function discoverRegisteredRoutes(program: ts.Program, sourceFiles: readonly ts.SourceFile[]): RegisteredRoute[];

package/dist/api-contract-discovery/registered-route-catalog.mjs

@@ -1,85 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { handlerNodes } from './registered-route-handler-analysis.mjs';
-import { isTerminal405Handler } from './registered-route-terminal-error.mjs';
-import { propertyName, routeTemplateFromExpression, visit, } from './response-contract-route-analysis.mjs';
-export const routeShape = (routeTemplate) => routeTemplate.replace(/:[^/]+/g, ':');
-export function discoverRegisteredRoutes(program, sourceFiles) {
-    const checker = program.getTypeChecker();
-    const routes = [];
-    const registrations = new Map();
-    sourceFiles.forEach((sourceFile) => {
-        visit(sourceFile, (node) => {
-            if (!ts.isCallExpression(node))
-                return;
-            const method = propertyName(node.expression)?.toUpperCase();
-            if (!method || !['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(method))
-                return;
-            const routeTemplate = routeTemplateFromExpression(node.expression);
-            if (!routeTemplate)
-                return;
-            const key = `${method}:${routeShape(routeTemplate)}`;
-            const source = `${sourceFile.fileName}:${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}`;
-            const classification = classifyHandler(node, checker, method, routeTemplate);
-            const route = {
-                method,
-                routeTemplate,
-                ...classification,
-                source,
-            };
-            const existing = registrations.get(key);
-            if (existing)
-                throw new Error(`Duplicate registered API route ${key} at ${existing.source} and ${source}`);
-            registrations.set(key, route);
-            routes.push(route);
-        });
-    });
-    return routes.toSorted((left, right) => `${left.method}:${left.routeTemplate}`.localeCompare(`${right.method}:${right.routeTemplate}`));
-}
-function classifyHandler(call, checker, method, routeTemplate) {
-    const nodes = call.arguments.flatMap((argument) => handlerNodes(argument, checker));
-    if (nodes.length === 0)
-        throw new Error(`Cannot inspect registered route handler ${method}:${routeTemplate}`);
-    let sse = false;
-    const proofGroups = call.arguments
-        .filter((argument) => !ts.isStringLiteral(argument))
-        .map((argument) => {
-        const proofs = [];
-        const nodes = handlerNodes(argument, checker, new Map(), new Set(), true, proofs);
-        return nodes.some(ts.isFunctionLike) ? proofs : [];
-    });
-    const error405 = proofGroups.length > 0 &&
-        proofGroups.every((handlers) => handlers.length > 0 &&
-            handlers.every((proof) => isTerminal405Handler(proof.node, checker, proof.bindings)));
-    let fixedStatus;
-    nodes.forEach((node) => {
-        visit(node, (child) => {
-            if (!ts.isCallExpression(child))
-                return;
-            if (ts.isIdentifier(child.expression) && child.expression.text === 'apiOpenApiNoContent') {
-                const [key, status] = child.arguments;
-                if (!key || !ts.isStringLiteral(key) || key.text !== `${method}:${routeTemplate}`)
-                    throw new Error(`apiOpenApiNoContent key must match registered route ${method}:${routeTemplate}`);
-                if (!status || !ts.isNumericLiteral(status))
-                    throw new Error('apiOpenApiNoContent status requires a numeric literal');
-                const value = Number(status.text);
-                if (fixedStatus !== undefined && fixedStatus !== value)
-                    throw new Error(`Conflicting apiOpenApiNoContent statuses for ${method}:${routeTemplate}`);
-                fixedStatus = value;
-            }
-            if (ts.isIdentifier(child.expression) && child.expression.text === 'startSSE')
-                sse = true;
-            if (ts.isPropertyAccessExpression(child.expression) &&
-                child.expression.name.text === 'setType' &&
-                child.arguments[0] &&
-                ts.isStringLiteral(child.arguments[0]) &&
-                child.arguments[0].text.toLowerCase() === 'text/event-stream')
-                sse = true;
-        });
-    });
-    if (fixedStatus !== undefined) {
-        if (sse)
-            throw new Error(`apiOpenApiNoContent conflicts with SSE response handling for ${method}:${routeTemplate}`);
-        return { kind: 'fixed-no-content', fixedStatus };
-    }
-    return { kind: sse ? 'sse' : error405 ? 'error-only' : 'ordinary' };
-}

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

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function returnedExpressions(declaration: ts.FunctionLikeDeclaration): (ts.Expression | undefined)[];
-export declare function returnsOnEveryPath(node: ts.ConciseBody | ts.Statement): boolean;

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);
-        }
-    }
-}