vouchington-tooling 0.34.0 → 0.36.0

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

@@ -1,5 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type DiscoverApiResponseContractsOptions } from './response-contract-lenient.mts';
-import { type HandlerBindings } from './response-contract-route-analysis.mts';
-import type { BackendResponseContract } from './response-contract-types.mts';
-export declare function discoverProtocolContracts(sourceFiles: readonly ts.SourceFile[], checker: ts.TypeChecker, bindings: HandlerBindings, contracts: Map<string, BackendResponseContract>, options: DiscoverApiResponseContractsOptions | undefined, requestedKeys?: ReadonlySet<string>): Set<ts.CallExpression>;

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

@@ -1,133 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { nextProtocolKey } from './protocol-contract-keys.mjs';
-import { extractContractSchema } from '../contract-schema/index.mjs';
-import { extractHttpVariants, extractSseEvents } from './protocol-contract-extraction.mjs';
-import { extractHttpBodyKinds } from './protocol-http-body-kinds.mjs';
-import { registerHttpProtocols } from './protocol-http-registration.mjs';
-import { protocolBindingRequested, requestedProtocolKey } from './protocol-requested-keys.mjs';
-import { protocolMarker } from './protocol-marker-analysis.mjs';
-import { registerRouteContract, } from './response-contract-lenient.mjs';
-import { contractError, sourceLocation } from './response-contract-registration.mjs';
-import { enclosingRouteBinding, visit, } from './response-contract-route-analysis.mjs';
-import { rejectRawSseWrites } from './protocol-sse-raw-writes.mjs';
-import { sseEmission } from './protocol-sse-emission.mjs';
-export function discoverProtocolContracts(sourceFiles, checker, bindings, contracts, options, requestedKeys) {
-    if (requestedKeys?.size === 0)
-        return new Set();
-    const calls = [];
-    for (const file of sourceFiles)
-        visit(file, (node) => {
-            if (ts.isCallExpression(node))
-                calls.push(node);
-        });
-    const pending = [];
-    const allocated = new Map();
-    const framedWrites = new Set();
-    const sseBindings = new Map();
-    for (const file of sourceFiles)
-        visit(file, (node) => {
-            if (!ts.isCallExpression(node))
-                return;
-            const marker = protocolMarker(node.expression, checker);
-            if (!marker)
-                return;
-            const binding = enclosingRouteBinding(node, checker, bindings, false);
-            if (!binding)
-                throw contractError(file, node, `${marker} must be inside an app.route handler`);
-            if (!protocolBindingRequested(binding, requestedKeys))
-                return;
-            const keyNode = node.arguments[0];
-            if (!keyNode || !ts.isStringLiteral(keyNode))
-                throw contractError(file, node, `${marker} requires a literal contract key`);
-            const prefix = `${binding.method}:${binding.routeTemplate}`;
-            if (keyNode.text !== prefix && !keyNode.text.startsWith(`${prefix}#`))
-                throw contractError(file, keyNode, `Contract key "${keyNode.text}" does not match enclosing route ${prefix}`);
-            const location = sourceLocation(file, node);
-            let errorKeys = [];
-            try {
-                if (marker === 'apiSseFrame') {
-                    const rowKey = reserveKey(allocated, keyNode.text);
-                    errorKeys = [rowKey];
-                    if (!requestedProtocolKey(rowKey, binding, requestedKeys)) {
-                        if (ts.isCallExpression(node.parent))
-                            framedWrites.add(node.parent);
-                        return;
-                    }
-                    const body = node.arguments[1];
-                    if (!body)
-                        throw new Error(`${marker} requires a protocol body`);
-                    const { write, receiver, status } = sseEmission(node, checker, calls, binding, bindings);
-                    const sseEvents = extractSseEvents(checker.getTypeAtLocation(body), checker, location, options);
-                    contracts.set(rowKey, {
-                        ...extractContractSchema(checker.getStringType(), checker, location, options),
-                        ...binding,
-                        bodyKind: 'content',
-                        mediaType: 'text/event-stream',
-                        mediaTypeKnowledge: 'known',
-                        ...status,
-                        sseEvents,
-                    });
-                    framedWrites.add(write);
-                    const routeWrites = sseBindings.get(prefix) ?? { receivers: [], keys: [] };
-                    routeWrites.receivers.push(receiver);
-                    routeWrites.keys.push(rowKey);
-                    sseBindings.set(prefix, routeWrites);
-                }
-                else {
-                    const declaration = node.parent;
-                    const symbol = ts.isVariableDeclaration(declaration) &&
-                        ts.isIdentifier(declaration.name) &&
-                        ts.isVariableDeclarationList(declaration.parent) &&
-                        !!(declaration.parent.flags & ts.NodeFlags.Const)
-                        ? checker.getSymbolAtLocation(declaration.name)
-                        : undefined;
-                    if (!symbol)
-                        throw new Error('apiOpenApiHttpResponse must bind a response variable');
-                    const keys = [];
-                    errorKeys = keys;
-                    const variants = extractHttpVariants(checker.getTypeAtLocation(node), checker, location, options, () => {
-                        const rowKey = reserveKey(allocated, keyNode.text);
-                        if (!requestedProtocolKey(rowKey, binding, requestedKeys))
-                            return false;
-                        keys.push(rowKey);
-                        return true;
-                    });
-                    pending.push({
-                        call: node,
-                        symbol,
-                        binding,
-                        variants,
-                        get declaredBodyKinds() {
-                            return extractHttpBodyKinds(checker.getTypeAtLocation(node), checker);
-                        },
-                        keys,
-                    });
-                }
-            }
-            catch (error) {
-                for (const key of errorKeys.length ? errorKeys : [reserveKey(allocated, keyNode.text)])
-                    unavailable(contracts, key, binding, location, error, options);
-            }
-        });
-    const covered = registerHttpProtocols(pending, contracts, checker, (response, error) => {
-        for (const key of response.keys)
-            unavailable(contracts, key, response.binding, response.variants[0].source, error, options);
-    });
-    rejectRawSseWrites(sourceFiles, checker, bindings, framedWrites, sseBindings, (node, binding, keys) => {
-        for (const key of keys) {
-            contracts.delete(key);
-            unavailable(contracts, key, binding, sourceLocation(node.getSourceFile(), node), new Error('SSE route writes an unmarked frame'), options);
-        }
-    });
-    return covered;
-}
-function unavailable(contracts, key, binding, location, error, options) {
-    registerRouteContract(contracts, nextProtocolKey(contracts, key), binding, location, { bodyKind: 'content', statusKnowledge: 'unknown', mediaTypeKnowledge: 'unknown' }, () => {
-        throw error;
-    }, options);
-}
-function reserveKey(allocated, key) {
-    const row = nextProtocolKey(allocated, key);
-    allocated.set(row, undefined);
-    return row;
-}

package/dist/api-contract-discovery/protocol-executable-path.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/** Excludes statically dead branches without claiming that dynamic branches always run. */
-export declare function potentiallyExecuted(node: ts.Node): boolean;

package/dist/api-contract-discovery/protocol-executable-path.mjs

@@ -1,64 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { unwrapExpression } from './protocol-marker-analysis.mjs';
-/** Excludes statically dead branches without claiming that dynamic branches always run. */
-export function potentiallyExecuted(node) {
-    let current = node;
-    while (current.parent && !ts.isFunctionLike(current.parent)) {
-        const parent = current.parent;
-        if (ts.isBlock(parent)) {
-            const index = parent.statements.indexOf(current);
-            if (parent.statements.slice(0, index).some(terminates))
-                return false;
-        }
-        if (ts.isIfStatement(parent)) {
-            const condition = unwrapExpression(parent.expression).kind;
-            if (condition === ts.SyntaxKind.FalseKeyword && parent.thenStatement === current)
-                return false;
-            if (condition === ts.SyntaxKind.TrueKeyword && parent.elseStatement === current)
-                return false;
-        }
-        if ((ts.isWhileStatement(parent) || ts.isForStatement(parent)) &&
-            parent.statement === current) {
-            const condition = ts.isWhileStatement(parent) ? parent.expression : parent.condition;
-            if (condition && unwrapExpression(condition).kind === ts.SyntaxKind.FalseKeyword)
-                return false;
-        }
-        if (ts.isConditionalExpression(parent)) {
-            const condition = unwrapExpression(parent.condition).kind;
-            if (condition === ts.SyntaxKind.FalseKeyword && parent.whenTrue === current)
-                return false;
-            if (condition === ts.SyntaxKind.TrueKeyword && parent.whenFalse === current)
-                return false;
-        }
-        if (ts.isBinaryExpression(parent) && parent.right === current) {
-            const left = unwrapExpression(parent.left).kind;
-            if (left === ts.SyntaxKind.FalseKeyword &&
-                parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken)
-                return false;
-            if (left === ts.SyntaxKind.TrueKeyword &&
-                parent.operatorToken.kind === ts.SyntaxKind.BarBarToken)
-                return false;
-        }
-        current = parent;
-    }
-    return true;
-}
-function terminates(statement) {
-    if (ts.isReturnStatement(statement) ||
-        ts.isThrowStatement(statement) ||
-        ts.isBreakStatement(statement) ||
-        ts.isContinueStatement(statement))
-        return true;
-    if (ts.isBlock(statement))
-        return statement.statements.some(terminates);
-    if (!ts.isIfStatement(statement))
-        return false;
-    const condition = unwrapExpression(statement.expression).kind;
-    if (condition === ts.SyntaxKind.TrueKeyword)
-        return terminates(statement.thenStatement);
-    if (condition === ts.SyntaxKind.FalseKeyword)
-        return !!statement.elseStatement && terminates(statement.elseStatement);
-    return (!!statement.elseStatement &&
-        terminates(statement.thenStatement) &&
-        terminates(statement.elseStatement));
-}

package/dist/api-contract-discovery/protocol-execution-path.d.mts

@@ -1,4 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ProtocolCache } from './protocol-analysis-cache.mts';
-/** Proves execution up to an optional handler whose registered binding is already established. */
-export declare function executableProtocolPath(node: ts.Node, checker: ts.TypeChecker, boundHandler?: ts.Node, cache?: ProtocolCache): boolean;

package/dist/api-contract-discovery/protocol-execution-path.mjs

@@ -1,16 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { isSupportedProtocolCallback } from './protocol-callback-invocation.mjs';
-import { potentiallyExecuted } from './protocol-executable-path.mjs';
-import { enclosingFunction } from './protocol-marker-analysis.mjs';
-/** Proves execution up to an optional handler whose registered binding is already established. */
-export function executableProtocolPath(node, checker, boundHandler, cache) {
-    if (!potentiallyExecuted(node))
-        return false;
-    let fn = enclosingFunction(node);
-    while (fn && fn !== boundHandler) {
-        if (!potentiallyExecuted(fn) || !isSupportedProtocolCallback(fn, checker, cache))
-            return false;
-        fn = enclosingFunction(fn);
-    }
-    return true;
-}

package/dist/api-contract-discovery/protocol-http-association.d.mts

@@ -1,7 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function associateHttpResponse(call: ts.CallExpression, response: ts.Symbol, checker: ts.TypeChecker, siblings?: ReadonlySet<ts.Symbol>): Map<ts.CallExpression, 'content' | 'none' | 'status'>;
-/** Opaque callbacks may emit through an independently proven handler's context. */
-export declare function opaqueHttpResponse(call: ts.CallExpression, checker: ts.TypeChecker, context?: ts.Symbol): boolean;
-/** Mutable wrappers on supported callback paths cannot establish a complete contract. */
-export declare function unsupportedContextResponse(call: ts.CallExpression, checker: ts.TypeChecker): boolean;
-export declare function supportedResponseContext(call: ts.CallExpression, checker: ts.TypeChecker): ts.Symbol | undefined;

package/dist/api-contract-discovery/protocol-http-association.mjs

@@ -1,108 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { httpHandlerContext, httpContextScopes, indirectHttpResponseMethod, } from './protocol-http-context.mjs';
-import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
-import { httpEmissionKind, contextResponseMethod } from './protocol-http-emission.mjs';
-import { enclosingFunction } from './protocol-marker-analysis.mjs';
-import { executableProtocolPath } from './protocol-execution-path.mjs';
-import { unsupportedContextAlias } from './protocol-context-alias.mjs';
-import { expressionReceiver } from './protocol-write-receiver.mjs';
-import { visit } from './response-contract-route-analysis.mjs';
-import { isSupportedProtocolCallback } from './protocol-callback-invocation.mjs';
-import { mutatesHttpResponseMethod } from './protocol-http-method-mutations.mjs';
-import { opaqueProtocolCallbackPath } from './protocol-opaque-callback.mjs';
-import { opaqueHttpContextArgument } from './protocol-http-context-escapes.mjs';
-import { mutatedHttpResponse } from './protocol-http-response-mutations.mjs';
-const responseMethods = new Set([
-    'setStatus',
-    'pipeline',
-    'json',
-    'response.buffer',
-    'response.empty',
-]);
-export function associateHttpResponse(call, response, checker, siblings) {
-    const handler = enclosingFunction(call);
-    const handlerContext = handler && httpHandlerContext(handler, checker);
-    if (!handler || !handlerContext)
-        throw new Error('HTTP response must bind the handler context');
-    if (!executableProtocolPath(call, checker))
-        throw new Error('HTTP response must be inside a supported executable handler callback');
-    const emissions = new Map();
-    for (const [scope, context] of httpContextScopes(handler, checker))
-        visit(scope, (node) => {
-            if (mutatedHttpResponse(node, response, checker))
-                throw new Error('HTTP branded response body or status is mutated');
-            if (ts.isCallExpression(node) && opaqueHttpContextArgument(node, checker, context))
-                throw new Error('HTTP response context escapes through an opaque argument');
-            if (mutatesHttpResponseMethod(node, context, checker))
-                throw new Error('HTTP response context method is mutated');
-            if (ts.isCallExpression(node) &&
-                executableProtocolPath(node, checker) &&
-                responseMethods.has(indirectHttpResponseMethod(node, context, checker) ?? ''))
-                throw new Error('HTTP response has an unsupported indirect status or body emission');
-            if (ts.isCallExpression(node) && opaqueHttpResponse(node, checker, context))
-                throw new Error('HTTP response context escapes through an opaque callback');
-            if (ts.isBinaryExpression(node) &&
-                node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-                executableProtocolPath(node, checker)) {
-                const receiver = expressionReceiver(node.right, checker);
-                if (receiver?.root === context &&
-                    (receiver.path.length === 0 ||
-                        (receiver.path.length === 1 && receiver.path[0] === 'response')))
-                    throw new Error('HTTP response context has an unsupported mutable alias');
-            }
-            if (ts.isVariableDeclaration(node) &&
-                enclosingFunction(node) === scope &&
-                unsupportedContextAlias(node, context, checker))
-                throw new Error('HTTP response context has an unsupported mutable or destructured alias');
-            if (!ts.isCallExpression(node) || !executableProtocolPath(node, checker))
-                return;
-            const kind = enclosingFunction(node) === handler
-                ? httpEmissionKind(node, response, context, checker)
-                : undefined;
-            if (kind)
-                emissions.set(node, kind);
-            else if (responseMethods.has(contextResponseMethod(node.expression, context, checker, true) ?? '') &&
-                (enclosingFunction(node) === scope ||
-                    !!contextResponseMethod(node.expression, context, checker)))
-                if (siblings &&
-                    [...siblings].some((symbol) => symbol !== response && !!httpEmissionKind(node, symbol, context, checker)))
-                    return;
-                else
-                    throw new Error('HTTP response has an unrelated status or body emission');
-        });
-    return emissions;
-}
-/** Opaque callbacks may emit through an independently proven handler's context. */
-export function opaqueHttpResponse(call, checker, context) {
-    if (opaqueHttpContextArgument(call, checker, context))
-        return true;
-    if (context)
-        return (responseMethods.has(contextResponseMethod(call.expression, context, checker, true) ??
-            indirectHttpResponseMethod(call, context, checker) ??
-            '') && opaqueProtocolCallbackPath(call, checker));
-    return !!supportedResponseContext(call, checker) && opaqueProtocolCallbackPath(call, checker);
-}
-/** Mutable wrappers on supported callback paths cannot establish a complete contract. */
-export function unsupportedContextResponse(call, checker) {
-    if (!executableProtocolPath(call, checker))
-        return false;
-    const context = supportedResponseContext(call, checker);
-    return !!context && contextResponseMethod(call.expression, context, checker) === undefined;
-}
-export function supportedResponseContext(call, checker) {
-    let handler = enclosingFunction(call);
-    while (handler) {
-        const name = runtimeParameters(handler)[0]?.name;
-        const symbol = name && ts.isIdentifier(name) ? checker.getSymbolAtLocation(name) : undefined;
-        if (symbol &&
-            responseMethods.has(contextResponseMethod(call.expression, symbol, checker, true) ??
-                indirectHttpResponseMethod(call, symbol, checker) ??
-                '') &&
-            httpHandlerContext(handler, checker) === symbol &&
-            isSupportedProtocolCallback(handler, checker) &&
-            executableProtocolPath(handler, checker))
-            return symbol;
-        handler = enclosingFunction(handler);
-    }
-    return undefined;
-}

package/dist/api-contract-discovery/protocol-http-body-kinds.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/** Checks complete wire body kinds without extracting unselected payload schemas. */
-export declare function extractHttpBodyKinds(type: ts.Type, checker: ts.TypeChecker): ReadonlySet<'content' | 'none'>;

package/dist/api-contract-discovery/protocol-http-body-kinds.mjs

@@ -1,19 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { propertyType, stringLiterals, typeVariants } from './protocol-marker-analysis.mjs';
-/** Checks complete wire body kinds without extracting unselected payload schemas. */
-export function extractHttpBodyKinds(type, checker) {
-    const carrier = propertyType(type, 'apiHttpResponseVariants', checker);
-    const kinds = new Set();
-    for (const variant of typeVariants(carrier)) {
-        if (variant.flags & ts.TypeFlags.Undefined)
-            continue;
-        const names = stringLiterals(propertyType(variant, 'bodyKind', checker));
-        if (names.length !== 1)
-            throw new Error('HTTP response requires one concrete body kind per variant');
-        const kind = names[0];
-        if (kind !== 'content' && kind !== 'none')
-            throw new Error('HTTP response body kind is invalid');
-        kinds.add(kind);
-    }
-    return kinds;
-}

package/dist/api-contract-discovery/protocol-http-context-callers.d.mts

@@ -1,7 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ProtocolCache } from './protocol-analysis-cache.mts';
-/** Use the same actual invocation sites for context admission and caller emission coverage. */
-export declare function httpContextInvocations(fn: ts.FunctionLikeDeclaration, checker: ts.TypeChecker, cache?: ProtocolCache): {
-    registered: boolean;
-    callers: ts.CallExpression[];
-};

package/dist/api-contract-discovery/protocol-http-context-callers.mjs

@@ -1,40 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { createProtocolCallbackValueResolver } from './protocol-callback-values.mjs';
-import { callbackArgumentBindings } from './protocol-callback-argument-bindings.mjs';
-import { registeredHandler } from './protocol-callback-registration.mjs';
-import { executableProtocolPath } from './protocol-execution-path.mjs';
-import { enclosingFunction } from './protocol-marker-analysis.mjs';
-/** Use the same actual invocation sites for context admission and caller emission coverage. */
-export function httpContextInvocations(fn, checker, cache) {
-    const resolver = createProtocolCallbackValueResolver(checker);
-    const sourceFile = fn.getSourceFile();
-    let calls = cache?.calls.get(sourceFile);
-    if (!calls) {
-        const found = [];
-        const visit = (node) => {
-            if (ts.isCallExpression(node) && executableProtocolPath(node, checker, undefined, cache))
-                found.push(node);
-            ts.forEachChild(node, visit);
-        };
-        visit(sourceFile);
-        calls = found;
-        cache?.calls.set(sourceFile, calls);
-    }
-    const registered = calls.some((call) => registeredHandler(call) &&
-        call.arguments.some((argument) => resolver.resolve(argument, new Map())?.node === fn));
-    const callers = calls.filter((call) => {
-        if (resolver.resolve(call.expression, new Map())?.node === fn)
-            return true;
-        const owner = enclosingFunction(call);
-        if (!owner)
-            return false;
-        return calls.some((invocation) => {
-            const target = resolver.resolve(invocation.expression, new Map());
-            if (target?.node !== owner)
-                return false;
-            const env = callbackArgumentBindings(owner, invocation, new Map(), target.env, checker, resolver);
-            return !!env && resolver.resolve(call.expression, env)?.node === fn;
-        });
-    });
-    return { registered, callers };
-}

package/dist/api-contract-discovery/protocol-http-context-escapes.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/** Opaque consumers of the canonical context may emit undocumented status or bodies. */
-export declare function opaqueHttpContextArgument(call: ts.CallExpression, checker: ts.TypeChecker, context?: ts.Symbol, active?: Set<ts.FunctionLikeDeclaration>): boolean;

package/dist/api-contract-discovery/protocol-http-context-escapes.mjs

@@ -1,95 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { expressionReceiver } from './protocol-write-receiver.mjs';
-import { httpHandlerContext, contextResponseMethod } from './protocol-http-context.mjs';
-import { httpContextInvocations } from './protocol-http-context-callers.mjs';
-import { callbackArgumentBindings } from './protocol-callback-argument-bindings.mjs';
-import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
-import { enclosingFunction, unwrapExpression } from './protocol-marker-analysis.mjs';
-import { executableProtocolPath } from './protocol-execution-path.mjs';
-import { opaqueProtocolCallbackPath } from './protocol-opaque-callback.mjs';
-import { visit } from './response-contract-route-analysis.mjs';
-import { standardReflectApply } from './protocol-http-reflect.mjs';
-import { createProtocolCallbackValueResolver, isProtocolCallbackFunction, } from './protocol-callback-values.mjs';
-/** Opaque consumers of the canonical context may emit undocumented status or bodies. */
-export function opaqueHttpContextArgument(call, checker, context, active = new Set()) {
-    const matches = (symbol) => call.arguments.some((argument) => contextArgument(argument, symbol, checker));
-    if (context && !matches(context))
-        return false;
-    if (!(executableProtocolPath(call, checker) || opaqueProtocolCallbackPath(call, checker)))
-        return false;
-    if (context)
-        return !implementedCallee(call, context, checker, active);
-    for (let owner = enclosingFunction(call); owner; owner = enclosingFunction(owner)) {
-        const name = runtimeParameters(owner)[0]?.name;
-        const symbol = name && ts.isIdentifier(name) ? checker.getSymbolAtLocation(name) : undefined;
-        if (symbol && matches(symbol) && httpHandlerContext(owner, checker) === symbol)
-            return !implementedCallee(call, symbol, checker, active);
-    }
-    return false;
-}
-function contextArgument(expression, context, checker) {
-    const receiver = expressionReceiver(expression, checker);
-    return ((receiver?.root === context &&
-        (receiver.path.length === 0 ||
-            (receiver.path.length === 1 && receiver.path[0] === 'response'))) ||
-        contextResponseMethod(unwrapExpression(expression), context, checker, true) === 'response');
-}
-/** Actual caller bindings retain the concrete implementations of consumed callback parameters. */
-function implementedCallee(call, context, checker, active) {
-    const resolver = createProtocolCallbackValueResolver(checker);
-    if (standardReflectApply(call, checker)) {
-        const target = call.arguments[0] && resolver.resolve(call.arguments[0], new Map());
-        return !!(target &&
-            isProtocolCallbackFunction(target.node) &&
-            target.node.body &&
-            ts.isBlock(target.node.body) &&
-            target.node.body.statements.length === 0);
-    }
-    const implemented = (env) => {
-        const target = resolver.resolve(call.expression, env);
-        return !!(target &&
-            isProtocolCallbackFunction(target.node) &&
-            target.node.body &&
-            !calleeEscapes(target.node, call, context, checker, active));
-    };
-    if (implemented(new Map()))
-        return true;
-    const expression = unwrapExpression(call.expression);
-    const declaration = ts.isIdentifier(expression)
-        ? checker.getSymbolAtLocation(expression)?.valueDeclaration
-        : undefined;
-    const owner = declaration && ts.isParameter(declaration) ? enclosingFunction(declaration) : undefined;
-    if (!owner || !runtimeParameters(owner).includes(declaration))
-        return false;
-    const callers = httpContextInvocations(owner, checker).callers;
-    return (callers.length > 0 &&
-        callers.every((invocation) => {
-            const target = resolver.resolve(invocation.expression, new Map());
-            if (target?.node !== owner)
-                return false;
-            const env = callbackArgumentBindings(owner, invocation, new Map(), target.env, checker, resolver);
-            return !!env && implemented(env);
-        }));
-}
-/** The current proven call binds canonical arguments; other foreign callers do not hide escapes. */
-function calleeEscapes(fn, call, context, checker, active) {
-    if (active.has(fn))
-        return true;
-    const next = new Set(active).add(fn);
-    const contexts = [context];
-    for (const [index, parameter] of runtimeParameters(fn).entries()) {
-        const argument = call.arguments[index];
-        if (!argument || !contextArgument(argument, context, checker))
-            continue;
-        if (!ts.isIdentifier(parameter.name))
-            return true;
-        contexts.push(checker.getSymbolAtLocation(parameter.name));
-    }
-    let escaped = false;
-    visit(fn.body, (node) => {
-        if (ts.isCallExpression(node) &&
-            contexts.some((symbol) => opaqueHttpContextArgument(node, checker, symbol, next)))
-            escaped = true;
-    });
-    return escaped;
-}

package/dist/api-contract-discovery/protocol-http-context.d.mts

@@ -1,8 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export { contextResponseMethod } from './protocol-http-method-access.mts';
-/** A helper parameter is a response context only when every executable caller passes one. */
-export declare function httpHandlerContext(fn: ts.FunctionLikeDeclaration, checker: ts.TypeChecker, active?: Set<ts.FunctionLikeDeclaration>): ts.Symbol | undefined;
-/** Follow only caller contexts already admitted by the actual-argument proof. */
-export declare function httpContextScopes(fn: ts.FunctionLikeDeclaration, checker: ts.TypeChecker): Map<ts.FunctionLikeDeclaration, ts.Symbol>;
-/** Indirect methods cannot prove the declared status or body, including borrowed this receivers. */
-export declare function indirectHttpResponseMethod(call: ts.CallExpression, context: ts.Symbol, checker: ts.TypeChecker): string | undefined;

package/dist/api-contract-discovery/protocol-http-context.mjs

@@ -1,85 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { httpContextInvocations } from './protocol-http-context-callers.mjs';
-import { enclosingFunction } from './protocol-marker-analysis.mjs';
-import { expressionReceiver } from './protocol-write-receiver.mjs';
-import { hasBindingWrite } from './registered-route-binding-writes.mjs';
-import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
-import { contextResponseMethod, methodAccess } from './protocol-http-method-access.mjs';
-import { reflectHttpResponseMethod } from './protocol-http-reflect.mjs';
-export { contextResponseMethod } from './protocol-http-method-access.mjs';
-/** A helper parameter is a response context only when every executable caller passes one. */
-export function httpHandlerContext(fn, checker, active = new Set()) {
-    if (active.has(fn))
-        return undefined;
-    const parameter = runtimeParameters(fn)[0];
-    const context = parameter && ts.isIdentifier(parameter.name)
-        ? checker.getSymbolAtLocation(parameter.name)
-        : undefined;
-    if (!context || hasBindingWrite(parameter, checker))
-        return undefined;
-    const { registered, callers } = httpContextInvocations(fn, checker);
-    const next = new Set(active).add(fn);
-    const valid = (registered || callers.length > 0) &&
-        callers.every((call) => {
-            const argument = call.arguments[0];
-            const receiver = argument && expressionReceiver(argument, checker);
-            const declaration = receiver?.root.valueDeclaration;
-            const owner = declaration && ts.isParameter(declaration) ? enclosingFunction(declaration) : undefined;
-            return (!!owner &&
-                !!receiver &&
-                receiver.path.length === 0 &&
-                !receiver.mutableAlias &&
-                receiver.root === httpHandlerContext(owner, checker, next));
-        });
-    const result = valid ? context : undefined;
-    return result;
-}
-/** Follow only caller contexts already admitted by the actual-argument proof. */
-export function httpContextScopes(fn, checker) {
-    const scopes = new Map();
-    const pending = [fn];
-    const seen = new Set();
-    while (pending.length) {
-        const current = pending.pop();
-        if (seen.has(current))
-            continue;
-        seen.add(current);
-        const context = httpHandlerContext(current, checker);
-        if (!context)
-            continue;
-        scopes.set(current, context);
-        for (const call of httpContextInvocations(current, checker).callers) {
-            // Admission above proves every caller's parameter-owned context.
-            const receiver = expressionReceiver(call.arguments[0], checker);
-            pending.push(enclosingFunction(receiver.root.valueDeclaration));
-        }
-    }
-    return scopes;
-}
-/** Indirect methods cannot prove the declared status or body, including borrowed this receivers. */
-export function indirectHttpResponseMethod(call, context, checker) {
-    const reflected = reflectHttpResponseMethod(call, context, checker);
-    if (reflected)
-        return reflected;
-    const outer = methodAccess(call.expression);
-    if (!outer || !['call', 'apply', 'bind'].includes(outer.name))
-        return undefined;
-    const direct = contextResponseMethod(outer.receiver, context, checker, true);
-    if (direct)
-        return direct;
-    const method = expressionReceiver(outer.receiver, checker);
-    if (method?.root === context)
-        return method.path[0] === 'response' ? method.path.slice(0, 2).join('.') : method.path[0];
-    const receiver = call.arguments[0] && expressionReceiver(call.arguments[0], checker);
-    if (receiver?.root !== context)
-        return undefined;
-    const target = methodAccess(outer.receiver);
-    const name = target?.name ?? method?.path.at(-1);
-    if (!name)
-        return undefined;
-    return receiver.path.length === 0
-        ? name
-        : receiver.path.length === 1 && receiver.path[0] === 'response'
-            ? `response.${name}`
-            : undefined;
-}

package/dist/api-contract-discovery/protocol-http-emission.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export { contextResponseMethod } from './protocol-http-context.mts';
-export declare function httpEmissionKind(call: ts.CallExpression, response: ts.Symbol, context: ts.Symbol, checker: ts.TypeChecker): 'content' | 'none' | 'status' | undefined;