vouchington-tooling 0.29.0 → 0.31.0

package/dist/api-contract-discovery/protocol-sse-write-helpers.mjs

@@ -0,0 +1,66 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { hasBindingWrite } from './registered-route-binding-writes.mjs';
+import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
+import { enclosingFunction } from './protocol-marker-analysis.mjs';
+import { executableProtocolPath } from './protocol-execution-path.mjs';
+import { enclosingRouteBinding, } from './response-contract-route-analysis.mjs';
+import { expressionReceiver } from './protocol-write-receiver.mjs';
+export function routeKey(binding) {
+    return `${binding.method}:${binding.routeTemplate}`;
+}
+function implementationDeclaration(declaration, checker) {
+    if (!declaration)
+        return undefined;
+    if (ts.isArrowFunction(declaration) || ts.isFunctionExpression(declaration))
+        return declaration;
+    if (ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration)) {
+        if (declaration.body)
+            return declaration;
+        const symbol = declaration.name && checker.getSymbolAtLocation(declaration.name);
+        return symbol?.declarations?.find((candidate) => (ts.isFunctionDeclaration(candidate) || ts.isMethodDeclaration(candidate)) &&
+            !!candidate.body);
+    }
+    return undefined;
+}
+export function helperBindings(node, calls, checker, bindings) {
+    const fn = enclosingFunction(node);
+    if (!fn || fn.asteriskToken)
+        return [];
+    return calls.flatMap((call) => {
+        if (implementationDeclaration(checker.getResolvedSignature(call)?.declaration, checker) !== fn ||
+            !executableProtocolPath(call, checker))
+            return [];
+        const binding = enclosingRouteBinding(call, checker, bindings, false);
+        return binding ? [binding] : [];
+    });
+}
+export function actualReceivers(receiver, binding, calls, checker, bindings, active = new Set()) {
+    const declaration = receiver.root.valueDeclaration;
+    if (receiver.mutableAlias ||
+        (declaration &&
+            (ts.isBindingElement(declaration) ||
+                (ts.isVariableDeclaration(declaration) &&
+                    !(declaration.parent.flags & ts.NodeFlags.Const)) ||
+                (ts.isParameter(declaration) && hasBindingWrite(declaration, checker)))))
+        return [undefined];
+    const fn = declaration && enclosingFunction(declaration);
+    if (!declaration || !ts.isParameter(declaration) || !fn)
+        return [receiver];
+    if (active.has(receiver.root))
+        return [undefined];
+    const index = runtimeParameters(fn).indexOf(declaration);
+    const actuals = calls.flatMap((call) => {
+        if (implementationDeclaration(checker.getResolvedSignature(call)?.declaration, checker) !== fn ||
+            !executableProtocolPath(call, checker))
+            return [];
+        const callBinding = enclosingRouteBinding(call, checker, bindings, false);
+        if (!callBinding || routeKey(callBinding) !== routeKey(binding))
+            return [];
+        const argument = call.arguments[index] ?? declaration.initializer;
+        const actual = argument && expressionReceiver(argument, checker);
+        if (!actual || receiver.path.length)
+            return [undefined];
+        return actualReceivers(actual, binding, calls, checker, bindings, new Set(active).add(receiver.root));
+    });
+    return actuals.length ? actuals : [receiver];
+}

package/dist/api-contract-discovery/protocol-sse-write-mutations.d.mts

@@ -0,0 +1,9 @@
+import ts from '../contract-schema/typescript-api.mts';
+import { type WriteReceiver } from './protocol-write-receiver.mts';
+export type SseWriteMutation = {
+    node: ts.Node;
+    receiver: ts.Expression;
+};
+export declare function sseWriteMutation(node: ts.Node): SseWriteMutation | undefined;
+export declare function mutationAffectsSelectedStream(mutations: readonly SseWriteMutation[], frameReceivers: readonly WriteReceiver[], checker: ts.TypeChecker, isSameRoute: (node: ts.Node) => boolean, resolveActual: (expression: ts.Expression) => readonly (WriteReceiver | undefined)[] | undefined, resolveFrame: (receiver: WriteReceiver) => readonly (WriteReceiver | undefined)[]): boolean;
+export declare function isSourceLevelMutation(node: ts.Node): boolean;

package/dist/api-contract-discovery/protocol-sse-write-mutations.mjs

@@ -0,0 +1,36 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { executableProtocolPath } from './protocol-execution-path.mjs';
+import { sameWriteReceiver } from './protocol-write-receiver.mjs';
+import { writeAccess } from './protocol-sse-write-resolution.mjs';
+export function sseWriteMutation(node) {
+    if (ts.isBinaryExpression(node) && isAssignment(node.operatorToken.kind)) {
+        const access = writeAccess(node.left);
+        if (access && (access.method === 'write' || access.method === 'end'))
+            return { node, receiver: access.receiver };
+    }
+    if (ts.isDeleteExpression(node)) {
+        const access = writeAccess(node.expression);
+        if (access && (access.method === 'write' || access.method === 'end'))
+            return { node, receiver: access.receiver };
+    }
+    return undefined;
+}
+function isAssignment(kind) {
+    return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+}
+export function mutationAffectsSelectedStream(mutations, frameReceivers, checker, isSameRoute, resolveActual, resolveFrame) {
+    const framed = frameReceivers.flatMap(resolveFrame);
+    return mutations.some(({ node, receiver }) => {
+        if ((!isSourceLevelMutation(node) && !executableProtocolPath(node, checker)) ||
+            !isSameRoute(node))
+            return false;
+        const actual = resolveActual(receiver);
+        if (!actual)
+            return true;
+        return actual.some((value) => value === undefined ||
+            framed.some((frame) => frame === undefined || sameWriteReceiver(frame, value)));
+    });
+}
+export function isSourceLevelMutation(node) {
+    return ts.isExpressionStatement(node.parent) && ts.isSourceFile(node.parent.parent);
+}

package/dist/api-contract-discovery/protocol-sse-write-resolution.d.mts

@@ -0,0 +1,14 @@
+import ts from '../contract-schema/typescript-api.mts';
+export type WriteAccess = {
+    receiver: ts.Expression;
+    method: string | undefined;
+};
+export type WriteInvocation = {
+    receiver: ts.Expression | undefined;
+    method: string | undefined;
+    rawBytes: boolean;
+};
+export declare function writeAccess(expression: ts.Expression): WriteAccess | undefined;
+export declare function reflectApplyInvocation(call: ts.CallExpression, checker: ts.TypeChecker): WriteInvocation | undefined;
+export declare function indirectPayload(method: 'call' | 'apply', call: ts.CallExpression, checker: ts.TypeChecker): readonly ts.Expression[] | undefined;
+export declare function hasRawBytes(method: string | undefined, payload: readonly ts.Expression[] | undefined, checker: ts.TypeChecker, indirect: boolean): boolean;

package/dist/api-contract-discovery/protocol-sse-write-resolution.mjs

@@ -0,0 +1,79 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { unwrapExpression } from './protocol-marker-analysis.mjs';
+export function writeAccess(expression) {
+    expression = unwrapExpression(expression);
+    if (ts.isPropertyAccessExpression(expression))
+        return { receiver: expression.expression, method: expression.name.text };
+    if (!ts.isElementAccessExpression(expression))
+        return undefined;
+    const method = unwrapExpression(expression.argumentExpression);
+    return {
+        receiver: expression.expression,
+        method: ts.isStringLiteralLike(method) ? method.text : undefined,
+    };
+}
+export function reflectApplyInvocation(call, checker) {
+    const expression = unwrapExpression(call.expression);
+    if (!ts.isPropertyAccessExpression(expression) ||
+        expression.name.text !== 'apply' ||
+        !ts.isIdentifier(expression.expression) ||
+        expression.expression.text !== 'Reflect')
+        return undefined;
+    const defaultApply = checker
+        .getSymbolAtLocation(expression.name)
+        ?.declarations?.some((declaration) => declaration.getSourceFile().fileName.endsWith('/lib.es2015.reflect.d.ts'));
+    if (!defaultApply)
+        return undefined;
+    const target = call.arguments[0] && writeAccess(call.arguments[0]);
+    const receiver = call.arguments[1];
+    const payload = applyPayload(call.arguments[2], checker);
+    if (target?.method === 'pipe') {
+        const destination = payload?.[0];
+        return {
+            receiver: destination,
+            method: 'write',
+            rawBytes: payload === undefined || destination !== undefined,
+        };
+    }
+    const method = target?.method === 'write' || target?.method === 'end' ? target.method : undefined;
+    return {
+        receiver,
+        method,
+        rawBytes: payload === undefined || hasRawBytes(method, payload, checker, true),
+    };
+}
+export function indirectPayload(method, call, checker) {
+    if (method === 'call')
+        return call.arguments.slice(1);
+    return applyPayload(call.arguments[1], checker);
+}
+function applyPayload(argument, checker) {
+    if (!argument)
+        return [];
+    const value = unwrapExpression(argument);
+    if (isNullish(argument, checker))
+        return [];
+    if (!ts.isArrayLiteralExpression(value) || value.elements.some(ts.isSpreadElement))
+        return undefined;
+    return value.elements.filter(ts.isExpression);
+}
+function isNullish(expression, checker) {
+    const value = unwrapExpression(expression);
+    if (value.kind === ts.SyntaxKind.NullKeyword)
+        return true;
+    if (ts.isIdentifier(value) && value.text === 'undefined')
+        return true;
+    const flags = checker.getTypeAtLocation(expression).flags;
+    return !!(flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null));
+}
+export function hasRawBytes(method, payload, checker, indirect) {
+    if (payload === undefined || method === undefined)
+        return true;
+    if (method === 'write')
+        return !indirect || payload.length > 0;
+    if (method !== 'end' || !payload[0])
+        return false;
+    const type = checker.getTypeAtLocation(payload[0]);
+    return (!(type.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)) &&
+        type.getCallSignatures().length === 0);
+}

package/dist/api-contract-discovery/protocol-status-dominance.d.mts

@@ -0,0 +1,5 @@
+import ts from '../contract-schema/typescript-api.mts';
+/** Requires the last potentially preceding proven status setter to belong to this response. */
+export declare function statusDominatesEmission(emission: ts.CallExpression | ts.NewExpression, statuses: ReadonlySet<ts.CallExpression>, allStatuses?: ReadonlySet<ts.CallExpression>): boolean;
+/** Finds the last setter through unconditional blocks, excluding conditional compound statements. */
+export declare function unconditionalStatusSetter(statement: ts.Statement, statuses: ReadonlySet<ts.CallExpression>): ts.CallExpression | undefined;

package/dist/api-contract-discovery/protocol-status-dominance.mjs

@@ -0,0 +1,35 @@
+import ts from '../contract-schema/typescript-api.mjs';
+/** Requires the last potentially preceding proven status setter to belong to this response. */
+export function statusDominatesEmission(emission, statuses, allStatuses = statuses) {
+    let current = emission;
+    while (current.parent && !ts.isFunctionLike(current.parent)) {
+        const parent = current.parent;
+        if (ts.isBlock(parent)) {
+            const index = parent.statements.indexOf(current);
+            for (const statement of parent.statements.slice(0, index).toReversed())
+                if (containsStatus(statement, allStatuses)) {
+                    const setter = unconditionalStatusSetter(statement, allStatuses);
+                    return !!setter && statuses.has(setter);
+                }
+        }
+        current = parent;
+    }
+    return false;
+}
+/** Finds the last setter through unconditional blocks, excluding conditional compound statements. */
+export function unconditionalStatusSetter(statement, statuses) {
+    if (ts.isBlock(statement)) {
+        for (const child of statement.statements.toReversed())
+            if (containsStatus(child, statuses))
+                return unconditionalStatusSetter(child, statuses);
+    }
+    else if (ts.isExpressionStatement(statement) &&
+        ts.isCallExpression(statement.expression) &&
+        statuses.has(statement.expression))
+        return statement.expression;
+    return undefined;
+}
+function containsStatus(node, statuses) {
+    return ((ts.isCallExpression(node) && statuses.has(node)) ||
+        (ts.forEachChild(node, (child) => containsStatus(child, statuses)) ?? false));
+}

package/dist/api-contract-discovery/protocol-write-receiver.d.mts

@@ -0,0 +1,9 @@
+import ts from '../contract-schema/typescript-api.mts';
+export type WriteReceiver = {
+    root: ts.Symbol;
+    path: readonly string[];
+    mutableAlias?: boolean;
+};
+export declare function writeReceiver(call: ts.CallExpression, checker: ts.TypeChecker): WriteReceiver | undefined;
+export declare function sameWriteReceiver(left: WriteReceiver, right: WriteReceiver | undefined): boolean;
+export declare function expressionReceiver(expression: ts.Expression, checker: ts.TypeChecker, active?: Set<ts.Symbol>): WriteReceiver | undefined;

package/dist/api-contract-discovery/protocol-write-receiver.mjs

@@ -0,0 +1,79 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { unwrapExpression } from './protocol-marker-analysis.mjs';
+export function writeReceiver(call, checker) {
+    const target = unwrapExpression(call.expression);
+    if (!ts.isPropertyAccessExpression(target) || target.name.text !== 'write')
+        return undefined;
+    return expressionReceiver(target.expression, checker);
+}
+export function sameWriteReceiver(left, right) {
+    return (right !== undefined &&
+        left.root === right.root &&
+        left.path.length === right.path.length &&
+        left.path.every((part, index) => part === right.path[index]));
+}
+export function expressionReceiver(expression, checker, active = new Set()) {
+    const value = unwrapExpression(expression);
+    if (ts.isIdentifier(value)) {
+        const symbol = checker.getSymbolAtLocation(value);
+        if (!symbol)
+            return undefined;
+        return symbolReceiver(symbol, checker, active);
+    }
+    if (!ts.isPropertyAccessExpression(value))
+        return undefined;
+    const propertySymbol = checker.getSymbolAtLocation(value.name);
+    if (propertySymbol && active.has(propertySymbol))
+        return undefined;
+    const property = literalProperty(value, checker) ?? propertySymbol?.valueDeclaration;
+    const propertyActive = new Set(active);
+    if (propertySymbol)
+        propertyActive.add(propertySymbol);
+    // Object literal properties remain writable even when their variable is const.
+    // Track the original receiver for raw-write rejection; never trust a marked wrapper.
+    if (property && ts.isPropertyAssignment(property)) {
+        const receiver = expressionReceiver(property.initializer, checker, propertyActive);
+        return receiver && { ...receiver, mutableAlias: true };
+    }
+    if (property && ts.isShorthandPropertyAssignment(property)) {
+        const symbol = checker.getShorthandAssignmentValueSymbol(property);
+        const receiver = symbol && symbolReceiver(symbol, checker, propertyActive);
+        return receiver && { ...receiver, mutableAlias: true };
+    }
+    const parent = expressionReceiver(value.expression, checker, active);
+    return parent ? { ...parent, path: [...parent.path, value.name.text] } : undefined;
+}
+function symbolReceiver(symbol, checker, active) {
+    const root = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    if (active.has(root))
+        return undefined;
+    const declaration = root.valueDeclaration;
+    if (declaration &&
+        ts.isVariableDeclaration(declaration) &&
+        declaration.initializer &&
+        ts.isVariableDeclarationList(declaration.parent)) {
+        const initializer = unwrapExpression(declaration.initializer);
+        if (ts.isIdentifier(initializer) || ts.isPropertyAccessExpression(initializer)) {
+            const receiver = expressionReceiver(initializer, checker, new Set(active).add(root));
+            return (receiver && {
+                ...receiver,
+                ...(!(declaration.parent.flags & ts.NodeFlags.Const) ? { mutableAlias: true } : {}),
+            });
+        }
+    }
+    return { root, path: [] };
+}
+function literalProperty(value, checker) {
+    const base = unwrapExpression(value.expression);
+    if (!ts.isIdentifier(base))
+        return undefined;
+    const declaration = checker.getSymbolAtLocation(base)?.valueDeclaration;
+    if (!declaration || !ts.isVariableDeclaration(declaration) || !declaration.initializer)
+        return undefined;
+    const initializer = unwrapExpression(declaration.initializer);
+    if (!ts.isObjectLiteralExpression(initializer))
+        return undefined;
+    return initializer.properties.find((member) => (ts.isPropertyAssignment(member) || ts.isShorthandPropertyAssignment(member)) &&
+        ts.isIdentifier(member.name) &&
+        member.name.text === value.name.text);
+}

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

@@ -1,8 +1,10 @@
 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();

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

@@ -0,0 +1,3 @@
+import ts from '../contract-schema/typescript-api.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): boolean;

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

@@ -0,0 +1,30 @@
+import ts from '../contract-schema/typescript-api.mjs';
+/** Helper and factory parameter bindings must remain unchanged in their declaring source. */
+export function hasBindingWrite(declaration, checker) {
+    if (!declaration.name)
+        return false;
+    if (!ts.isIdentifier(declaration.name))
+        return true;
+    const binding = checker.getSymbolAtLocation(declaration.name);
+    let written = false;
+    const referencesBinding = (node) => {
+        if (ts.isIdentifier(node) && checker.getSymbolAtLocation(node) === binding)
+            written = true;
+        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(declaration.getSourceFile());
+    return written;
+}

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

@@ -1,5 +1,6 @@
 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) {
@@ -39,7 +40,16 @@ function classifyHandler(call, checker, method, routeTemplate) {
     if (nodes.length === 0)
         throw new Error(`Cannot inspect registered route handler ${method}:${routeTemplate}`);
     let sse = false;
-    let error405 = 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) => {
@@ -64,12 +74,6 @@ function classifyHandler(call, checker, method, routeTemplate) {
                 ts.isStringLiteral(child.arguments[0]) &&
                 child.arguments[0].text.toLowerCase() === 'text/event-stream')
                 sse = true;
-            if (ts.isPropertyAccessExpression(child.expression) &&
-                child.expression.name.text === 'throw' &&
-                child.arguments[0] &&
-                ts.isNumericLiteral(child.arguments[0]) &&
-                child.arguments[0].text === '405')
-                error405 = true;
         });
     });
     if (fixedStatus !== undefined) {

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,29 @@
+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,2 +1,6 @@
 import ts from '../contract-schema/typescript-api.mts';
-export declare function handlerNodes(argument: ts.Expression, checker: ts.TypeChecker, parameterBindings?: Map<ts.Symbol, ts.Expression>): ts.Node[];
+export type HandlerProof = {
+    node: ts.FunctionLikeDeclaration;
+    bindings: Map<ts.Symbol, ts.Expression>;
+};
+export declare function handlerNodes(argument: ts.Expression, checker: ts.TypeChecker, parameterBindings?: Map<ts.Symbol, ts.Expression>, active?: Set<ts.Node>, staticProof?: boolean, proofs?: HandlerProof[]): ts.Node[];

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

@@ -1,74 +1,118 @@
 import ts from '../contract-schema/typescript-api.mjs';
-export function handlerNodes(argument, checker, parameterBindings = new Map()) {
-    if (ts.isIdentifier(argument)) {
-        const symbol = checker.getSymbolAtLocation(argument);
-        const boundArgument = symbol && parameterBindings.get(symbol);
-        if (boundArgument)
-            return handlerNodes(boundArgument, checker, parameterBindings);
+import { returnedExpressions, returnsOnEveryPath } from './registered-route-factory-returns.mjs';
+import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
+import { hasBindingWrite } from './registered-route-binding-writes.mjs';
+export function handlerNodes(argument, checker, parameterBindings = new Map(), active = new Set(), staticProof = false, proofs) {
+    const unwrapped = unwrapHandlerExpression(argument);
+    if (unwrapped !== argument)
+        return handlerNodes(unwrapped, checker, parameterBindings, active, staticProof, proofs);
+    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 (ts.isArrowFunction(argument) || ts.isFunctionExpression(argument))
+    if (bound !== argument)
+        return handlerNodes(bound, checker, parameterBindings, active, staticProof, proofs);
+    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)) {
-        return callableImplementations(argument.expression, checker).flatMap((implementation) => {
+        const resolvedProofs = [];
+        const groups = callableImplementations(argument.expression, checker, staticProof).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);
-            implementation.parameters.forEach((parameter, index) => {
+            runtimeParameters(implementation).forEach((parameter, index) => {
                 const callArgument = argument.arguments[index];
                 const symbol = checker.getSymbolAtLocation(parameter.name);
                 if (callArgument && symbol)
                     bindings.set(symbol, callArgument);
             });
-            return returnedExpressions(implementation).flatMap((returnedExpression) => handlerNodes(returnedExpression, checker, bindings));
+            const returned = returnedExpressions(implementation);
+            if (staticProof &&
+                (!returnsOnEveryPath(implementation.body) || returned.some((value) => !value)))
+                return [];
+            const results = returned.map((value) => value ? handlerNodes(value, checker, bindings, next, staticProof, resolvedProofs) : []);
+            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);
+    return declarationImplementations(argument, checker, next, staticProof, parameterBindings, proofs);
 }
-function callableImplementations(node, checker) {
+function callableImplementations(node, checker, staticProof = false) {
     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 (staticProof && !hasStableBinding(declaration, checker))
+            continue;
         if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
-            const initializer = declaration.initializer;
+            const initializer = unwrapHandlerExpression(declaration.initializer);
             if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer))
                 implementations.push(initializer);
             continue;
         }
-        if ((ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration)) &&
+        if ((ts.isFunctionDeclaration(declaration) ||
+            (!staticProof && ts.isMethodDeclaration(declaration))) &&
             declaration.body)
             implementations.push(declaration);
     }
     return implementations;
 }
-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)) {
-            if (node.expression)
-                returned.push(node.expression);
-            return;
-        }
-        node.forEachChild(collect);
-    };
-    body.forEachChild(collect);
-    return returned;
-}
-function declarationImplementations(node, checker) {
+function declarationImplementations(node, checker, active, staticProof, parameterBindings, proofs) {
     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 (ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration))
+        if (staticProof && !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)];
+            return [
+                declaration,
+                ...handlerNodes(declaration.initializer, checker, parameterBindings, active, staticProof, proofs),
+            ];
         return [];
     });
 }
+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);
+}
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,3 @@
+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;