vouchington-tooling 0.35.0 → 0.36.0

package/dist/api-contract-discovery/protocol-callback-argument-bindings.mjs

@@ -1,33 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
-/** Binds literal callback parameters, declining unsupported destructuring shapes. */
-export function callbackArgumentBindings(fn, call, env, captured, checker, resolver) {
-    const next = new Map(captured);
-    for (const [index, parameter] of runtimeParameters(fn).entries()) {
-        const argument = call.arguments?.[index];
-        if (!argument)
-            continue;
-        if (ts.isSpreadElement(argument))
-            return undefined;
-        if (ts.isIdentifier(parameter.name)) {
-            next.set(checker.getSymbolAtLocation(parameter.name), { node: argument, env });
-        }
-        else {
-            if (!ts.isObjectBindingPattern(parameter.name))
-                return undefined;
-            const value = resolver.resolve(argument, env);
-            for (const element of parameter.name.elements) {
-                const key = element.propertyName ?? element.name;
-                if (!ts.isIdentifier(element.name) ||
-                    element.dotDotDotToken ||
-                    element.initializer ||
-                    !(ts.isIdentifier(key) || ts.isStringLiteral(key)))
-                    return undefined;
-                const bound = resolver.property(value, key.text, new Set());
-                if (bound)
-                    next.set(checker.getSymbolAtLocation(element.name), bound);
-            }
-        }
-    }
-    return next;
-}

package/dist/api-contract-discovery/protocol-callback-invocation.d.mts

@@ -1,6 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ProtocolCache } from './protocol-analysis-cache.mts';
-type FunctionNode = ts.FunctionLikeDeclaration;
-/** Proves callback consumption through concrete helper bodies, without executing nested closures. */
-export declare function isSupportedProtocolCallback(fn: FunctionNode, checker: ts.TypeChecker, cache?: ProtocolCache): boolean;
-export {};

package/dist/api-contract-discovery/protocol-callback-invocation.mjs

@@ -1,111 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
-import { invokedResult, registeredHandler } from './protocol-callback-registration.mjs';
-import { platformCallbackArgument } from './protocol-platform-callbacks.mjs';
-import { potentiallyExecuted } from './protocol-executable-path.mjs';
-import { callbackBindingReplaced, callbackOptionsEscape } from './protocol-callback-mutations.mjs';
-import { enclosingFunction } from './protocol-marker-analysis.mjs';
-import { createProtocolCallbackValueResolver, isProtocolCallbackFunction as functionNode, protocolCallbackSourceCalls, protocolCallbackHasWrittenBindings, } from './protocol-callback-values.mjs';
-/** Proves callback consumption through concrete helper bodies, without executing nested closures. */
-export function isSupportedProtocolCallback(fn, checker, cache) {
-    const known = cache?.supported.get(fn);
-    if (known !== undefined)
-        return known;
-    const supported = proveProtocolCallback(fn, checker, cache);
-    cache?.supported.set(fn, supported);
-    return supported;
-}
-function proveProtocolCallback(fn, checker, cache) {
-    if (!fn.body || fn.asteriskToken || protocolCallbackHasWrittenBindings(fn, checker, cache))
-        return false;
-    const resolver = createProtocolCallbackValueResolver(checker);
-    const { resolve, symbol } = resolver;
-    let invalidated = false;
-    function consumed(call, env, active, returned = false) {
-        const platform = platformCallbackArgument(call, checker);
-        const callee = resolve(platform ?? call.expression, env);
-        if (!callee || !functionNode(callee.node) || !callee.node.body || callee.node.asteriskToken) {
-            invalidated ||= callbackOptionsEscape(call, env, fn, resolver);
-            return false;
-        }
-        if (protocolCallbackHasWrittenBindings(callee.node, checker, cache)) {
-            invalidated = true;
-            return false;
-        }
-        if (callee.node === fn)
-            return !returned;
-        if (active.has(callee.node))
-            return false;
-        const chain = new Set([...active, callee.node]);
-        if (platform)
-            return body(callee.node.body, callee.env, chain, false);
-        const next = new Map(callee.env);
-        runtimeParameters(callee.node).forEach((parameter, index) => {
-            const argument = call.arguments[index];
-            const target = symbol(parameter.name);
-            if (argument && !ts.isSpreadElement(argument))
-                next.set(target, { node: argument, env });
-        });
-        return body(callee.node.body, next, chain, returned || invokedResult(call));
-    }
-    function body(content, env, active, returned) {
-        let found = false;
-        let replaced = false;
-        function visit(node) {
-            if (found || replaced || !potentiallyExecuted(node))
-                return;
-            if (functionNode(node))
-                return;
-            if (callbackBindingReplaced(node, env, fn, resolver)) {
-                replaced = true;
-                invalidated = true;
-                return;
-            }
-            if ((ts.isCallExpression(node) || ts.isNewExpression(node)) &&
-                consumed(node, env, active, returned && ts.isReturnStatement(node.parent)) &&
-                (!returned || ts.isReturnStatement(node.parent))) {
-                found = true;
-                return;
-            }
-            if (returned && ts.isReturnStatement(node) && node.expression) {
-                const value = resolve(node.expression, env);
-                if (value &&
-                    functionNode(value.node) &&
-                    value.node.body &&
-                    !value.node.asteriskToken &&
-                    !active.has(value.node) &&
-                    body(value.node.body, value.env, new Set([...active, value.node]), false)) {
-                    found = true;
-                    return;
-                }
-            }
-            ts.forEachChild(node, visit);
-        }
-        visit(content);
-        return found && !invalidated;
-    }
-    let argument = fn;
-    while (ts.isPropertyAssignment(argument.parent) ||
-        ts.isObjectLiteralExpression(argument.parent) ||
-        ts.isParenthesizedExpression(argument.parent) ||
-        ts.isAsExpression(argument.parent) ||
-        ts.isNonNullExpression(argument.parent))
-        argument = argument.parent;
-    const call = argument.parent;
-    if (!ts.isCallExpression(call) && !ts.isNewExpression(call)) {
-        const owner = enclosingFunction(fn);
-        if (owner && isSupportedProtocolCallback(owner, checker, cache))
-            return body(owner.body, new Map(), new Set([owner]), false);
-        return protocolCallbackSourceCalls(fn).some((candidate) => potentiallyExecuted(candidate) &&
-            ((registeredHandler(candidate) &&
-                candidate.arguments.some((value) => resolve(value, new Map())?.node === fn)) ||
-                consumed(candidate, new Map(), new Set())));
-    }
-    if (!potentiallyExecuted(call))
-        return false;
-    if (ts.isCallExpression(call) && call.expression === argument)
-        return true;
-    if (argument === fn && ts.isCallExpression(call) && registeredHandler(call))
-        return true;
-    return (!!call.arguments?.includes(argument) && consumed(call, new Map(), new Set()));
-}

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

@@ -1,5 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { CallbackBindings, createProtocolCallbackValueResolver } from './protocol-callback-values.mts';
-export declare function callbackBindingReplaced(node: ts.Node, env: CallbackBindings, fn: ts.FunctionLikeDeclaration, resolver: ReturnType<typeof createProtocolCallbackValueResolver>): boolean;
-/** An opaque callee may replace a callback stored in a forwarded options object. */
-export declare function callbackOptionsEscape(node: ts.CallExpression | ts.NewExpression, env: CallbackBindings, fn: ts.FunctionLikeDeclaration, resolver: ReturnType<typeof createProtocolCallbackValueResolver>): boolean;

package/dist/api-contract-discovery/protocol-callback-mutations.mjs

@@ -1,42 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { unwrapExpression } from './protocol-marker-analysis.mjs';
-export function callbackBindingReplaced(node, env, fn, resolver) {
-    const { resolve, symbol } = resolver;
-    const write = ts.isDeleteExpression(node)
-        ? node.expression
-        : ts.isBinaryExpression(node) &&
-            node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
-            node.operatorToken.kind <= ts.SyntaxKind.LastAssignment
-            ? node.left
-            : undefined;
-    if (!write)
-        return false;
-    let root = unwrapExpression(write);
-    while (ts.isPropertyAccessExpression(root) || ts.isElementAccessExpression(root))
-        root = unwrapExpression(root.expression);
-    return (ts.isIdentifier(root) && env.has(symbol(root))) || resolve(write, env)?.node === fn;
-}
-/** An opaque callee may replace a callback stored in a forwarded options object. */
-export function callbackOptionsEscape(node, env, fn, resolver) {
-    function contains(value, bindings, seen = new Set()) {
-        const resolved = resolver.resolve(value, bindings);
-        if (!resolved || seen.has(resolved.node))
-            return false;
-        seen.add(resolved.node);
-        if (resolved.node === fn)
-            return true;
-        if (ts.isArrayLiteralExpression(resolved.node))
-            return resolved.node.elements.some((element) => contains(ts.isSpreadElement(element) ? element.expression : element, resolved.env, seen));
-        if (!ts.isObjectLiteralExpression(resolved.node))
-            return false;
-        return resolved.node.properties.some((member) => member === fn ||
-            (ts.isPropertyAssignment(member)
-                ? contains(member.initializer, resolved.env, seen)
-                : ts.isShorthandPropertyAssignment(member) &&
-                    (() => {
-                        const target = resolver.property(resolved, member.name.text, new Set());
-                        return !!target && contains(target.node, target.env, seen);
-                    })()));
-    }
-    return !!node.arguments?.some((argument) => contains(argument, env));
-}

package/dist/api-contract-discovery/protocol-callback-registration.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function registeredHandler(call: ts.CallExpression): boolean;
-export declare function invokedResult(call: ts.CallExpression | ts.NewExpression): boolean;

package/dist/api-contract-discovery/protocol-callback-registration.mjs

@@ -1,27 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { unwrapExpression } from './protocol-marker-analysis.mjs';
-export function registeredHandler(call) {
-    const method = unwrapExpression(call.expression);
-    if (!ts.isPropertyAccessExpression(method) ||
-        !['get', 'post', 'put', 'patch', 'delete', 'head', 'options'].includes(method.name.text))
-        return false;
-    let receiver = method.expression;
-    while (ts.isCallExpression(receiver) && ts.isPropertyAccessExpression(receiver.expression)) {
-        if (receiver.expression.name.text === 'route')
-            return true;
-        receiver = receiver.expression.expression;
-    }
-    return false;
-}
-export function invokedResult(call) {
-    let node = call;
-    while (ts.isParenthesizedExpression(node.parent) ||
-        ts.isAsExpression(node.parent) ||
-        ts.isNonNullExpression(node.parent) ||
-        ts.isAwaitExpression(node.parent))
-        node = node.parent;
-    const parent = node.parent;
-    return (ts.isCallExpression(parent) &&
-        (parent.expression === node ||
-            (registeredHandler(parent) && parent.arguments.includes(node))));
-}

package/dist/api-contract-discovery/protocol-callback-values.d.mts

@@ -1,18 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ProtocolCache } from './protocol-analysis-cache.mts';
-type FunctionNode = ts.FunctionLikeDeclaration;
-export type CallbackValue = {
-    node: ts.Node;
-    env: CallbackBindings;
-};
-export type CallbackBindings = ReadonlyMap<ts.Symbol, CallbackValue>;
-export declare function isProtocolCallbackFunction(node: ts.Node): node is FunctionNode;
-/** Resolves stable named uses in outer statements and directly registered inline handlers. */
-export declare function protocolCallbackSourceCalls(fn: FunctionNode): ts.CallExpression[];
-export declare function createProtocolCallbackValueResolver(checker: ts.TypeChecker): {
-    resolve: (node: ts.Node, env: CallbackBindings, seen?: Set<ts.Node>) => CallbackValue | undefined;
-    symbol: (node: ts.Node) => ts.Symbol | undefined;
-    property: (value: CallbackValue | undefined, name: string, seen: Set<ts.Node>) => CallbackValue | undefined;
-};
-export declare function protocolCallbackHasWrittenBindings(fn: FunctionNode, checker: ts.TypeChecker, cache?: ProtocolCache): boolean;
-export {};

package/dist/api-contract-discovery/protocol-callback-values.mjs

@@ -1,114 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { registeredHandler } from './protocol-callback-registration.mjs';
-import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
-import { hasBindingWrite } from './registered-route-binding-writes.mjs';
-import { unwrapExpression } from './protocol-marker-analysis.mjs';
-export function isProtocolCallbackFunction(node) {
-    return ts.isFunctionLike(node) && 'body' in node;
-}
-/** Resolves stable named uses in outer statements and directly registered inline handlers. */
-export function protocolCallbackSourceCalls(fn) {
-    const declaration = fn.parent;
-    if (!ts.isFunctionDeclaration(fn) &&
-        (!ts.isVariableDeclaration(declaration) ||
-            !ts.isIdentifier(declaration.name) ||
-            !ts.isVariableDeclarationList(declaration.parent) ||
-            !(declaration.parent.flags & ts.NodeFlags.Const)))
-        return [];
-    const calls = [];
-    function visit(node) {
-        if (isProtocolCallbackFunction(node) &&
-            !(ts.isCallExpression(node.parent) &&
-                registeredHandler(node.parent) &&
-                node.parent.arguments.includes(node)))
-            return;
-        if (ts.isCallExpression(node))
-            calls.push(node);
-        ts.forEachChild(node, visit);
-    }
-    visit(fn.getSourceFile());
-    return calls;
-}
-function literalName(node) {
-    return ts.isIdentifier(node) || ts.isStringLiteral(node) ? node.text : undefined;
-}
-export function createProtocolCallbackValueResolver(checker) {
-    function symbol(node) {
-        const found = checker.getSymbolAtLocation(node);
-        return found?.flags && found.flags & ts.SymbolFlags.Alias
-            ? checker.getAliasedSymbol(found)
-            : found;
-    }
-    function property(value, name, seen) {
-        if (!value ||
-            !ts.isObjectLiteralExpression(value.node) ||
-            value.node.properties.some(ts.isSpreadAssignment))
-            return undefined;
-        const member = value.node.properties.find((item) => item.name && literalName(item.name) === name);
-        if (member && ts.isPropertyAssignment(member))
-            return resolve(member.initializer, value.env, seen);
-        if (member && ts.isShorthandPropertyAssignment(member)) {
-            const target = checker.getShorthandAssignmentValueSymbol(member);
-            return target ? declaration(target, value.env, seen) : undefined;
-        }
-        return member && isProtocolCallbackFunction(member)
-            ? { node: member, env: value.env }
-            : undefined;
-    }
-    function declaration(target, env, seen) {
-        const bound = env.get(target);
-        if (bound)
-            return resolve(bound.node, bound.env, seen);
-        const implemented = target.declarations?.find((item) => isProtocolCallbackFunction(item) && item.body);
-        if (implemented)
-            return { node: implemented, env };
-        const node = target.valueDeclaration;
-        if (!node || seen.has(node))
-            return undefined;
-        seen.add(node);
-        if (ts.isVariableDeclaration(node) &&
-            node.initializer &&
-            ts.isVariableDeclarationList(node.parent) &&
-            node.parent.flags & ts.NodeFlags.Const)
-            return resolve(node.initializer, env, seen);
-        if (ts.isBindingElement(node) && ts.isObjectBindingPattern(node.parent)) {
-            const owner = node.parent.parent;
-            const name = literalName(node.propertyName ?? node.name);
-            if (name &&
-                ts.isVariableDeclaration(owner) &&
-                owner.initializer &&
-                ts.isVariableDeclarationList(owner.parent) &&
-                owner.parent.flags & ts.NodeFlags.Const)
-                return property(resolve(owner.initializer, env, seen), name, seen);
-        }
-        return undefined;
-    }
-    function resolve(node, env, seen = new Set()) {
-        if (ts.isExpression(node))
-            node = unwrapExpression(node);
-        if (seen.has(node))
-            return undefined;
-        seen.add(node);
-        if (isProtocolCallbackFunction(node) ||
-            ts.isObjectLiteralExpression(node) ||
-            ts.isArrayLiteralExpression(node))
-            return { node, env };
-        if (ts.isIdentifier(node)) {
-            const target = symbol(node);
-            return target ? declaration(target, env, seen) : undefined;
-        }
-        if (ts.isPropertyAccessExpression(node)) {
-            const member = property(resolve(node.expression, env, seen), node.name.text, seen);
-            if (member)
-                return member;
-            const target = symbol(node.name);
-            return target ? declaration(target, env, seen) : undefined;
-        }
-        return undefined;
-    }
-    return { resolve, symbol, property };
-}
-export function protocolCallbackHasWrittenBindings(fn, checker, cache) {
-    return ((ts.isFunctionDeclaration(fn) && hasBindingWrite(fn, checker, cache)) ||
-        runtimeParameters(fn).some((parameter) => hasBindingWrite(parameter, checker, cache)));
-}

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

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function unsupportedContextAlias(node: ts.VariableDeclaration, context: ts.Symbol, checker: ts.TypeChecker): boolean;
-export declare function unsupportedContextAssignment(node: ts.Node, context: ts.Symbol, checker: ts.TypeChecker): boolean;

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

@@ -1,20 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { expressionReceiver } from './protocol-write-receiver.mjs';
-export function unsupportedContextAlias(node, context, checker) {
-    if (!node.initializer)
-        return false;
-    const receiver = expressionReceiver(node.initializer, checker);
-    return (receiver?.root === context &&
-        (receiver.path.length === 0 ||
-            (receiver.path.length === 1 && receiver.path[0] === 'response')) &&
-        (!ts.isIdentifier(node.name) ||
-            !ts.isVariableDeclarationList(node.parent) ||
-            !(node.parent.flags & ts.NodeFlags.Const)));
-}
-export function unsupportedContextAssignment(node, context, checker) {
-    if (!ts.isBinaryExpression(node) || node.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
-        return false;
-    const receiver = expressionReceiver(node.right, checker);
-    return (receiver?.root === context &&
-        (receiver.path.length === 0 || (receiver.path.length === 1 && receiver.path[0] === 'response')));
-}

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

@@ -1,9 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type ExtractedResponseContract } from '../contract-schema/index.mts';
-import type { DiscoverApiResponseContractsOptions } from './response-contract-lenient.mts';
-import type { BackendResponseContract } from './response-contract-types.mts';
-export declare function extractSseEvents(type: ts.Type, checker: ts.TypeChecker, source: string, options: DiscoverApiResponseContractsOptions | undefined): {
-    eventName: string;
-    contract: ExtractedResponseContract;
-}[];
-export declare function extractHttpVariants(type: ts.Type, checker: ts.TypeChecker, source: string, options: DiscoverApiResponseContractsOptions | undefined, selectRow: (index: number) => boolean): Omit<BackendResponseContract, 'method' | 'routeTemplate'>[];

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

@@ -1,87 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { extractContractSchema } from '../contract-schema/index.mjs';
-import { propertyType, stringLiterals, typeVariants } from './protocol-marker-analysis.mjs';
-import { noContentContract } from './response-contract-registration.mjs';
-import { statusForbidsBody } from './protocol-body-status.mjs';
-export function extractSseEvents(type, checker, source, options) {
-    return typeVariants(type).flatMap((variant) => {
-        const names = stringLiterals(propertyType(variant, 'event', checker));
-        const contract = concretePayload(propertyType(variant, 'data', checker), checker, source, options);
-        return names.map((eventName) => ({ eventName, contract }));
-    });
-}
-export function extractHttpVariants(type, checker, source, options, selectRow) {
-    const carrier = propertyType(type, 'apiHttpResponseVariants', checker);
-    const variants = typeVariants(carrier).filter((variant) => !(variant.flags & ts.TypeFlags.Undefined));
-    if (variants.length === 0)
-        throw new Error('HTTP response requires concrete variants');
-    let row = 0;
-    const selections = variants.map((variant) => {
-        const rawMedia = rawPropertyType(variant, 'mediaType', checker);
-        const rawKind = rawPropertyType(variant, 'bodyKind', checker);
-        const count = rawKind?.isStringLiteral() && rawKind.value === 'none'
-            ? 1
-            : rawMedia?.isUnion()
-                ? rawMedia.types.length
-                : 1;
-        const selected = Array.from({ length: count }, () => selectRow(row++));
-        return selected;
-    });
-    return variants.flatMap((variant, index) => {
-        const selected = selections[index];
-        if (!selected.some(Boolean))
-            return [];
-        const status = propertyType(variant, 'status', checker);
-        if (!(status.flags & ts.TypeFlags.NumberLiteral))
-            throw new Error('HTTP response requires a literal status');
-        const value = status.value;
-        if (!Number.isInteger(value) || value < 100 || value > 599)
-            throw new Error('HTTP response status is invalid');
-        const kinds = stringLiterals(propertyType(variant, 'bodyKind', checker));
-        if (kinds.length !== 1)
-            throw new Error('HTTP response requires one concrete body kind per variant');
-        const statusCodes = [value];
-        if (kinds[0] === 'none')
-            return [
-                {
-                    ...noContentContract(source),
-                    statusCodes,
-                    statusKnowledge: 'explicit',
-                    bodyKind: 'none',
-                    mediaTypeKnowledge: 'none',
-                    ...(value === 400 ? { includeDefaultError: true } : {}),
-                },
-            ];
-        if (kinds[0] !== 'content')
-            throw new Error('HTTP response body kind is invalid');
-        if (statusForbidsBody(value))
-            throw new Error(`HTTP status ${value} forbids response content`);
-        const contract = concretePayload(propertyType(variant, 'body', checker), checker, source, options);
-        return stringLiterals(propertyType(variant, 'mediaType', checker)).flatMap((mediaType, index) => selected[index]
-            ? [
-                {
-                    ...contract,
-                    statusCodes,
-                    statusKnowledge: 'explicit',
-                    bodyKind: 'content',
-                    mediaType,
-                    mediaTypeKnowledge: 'known',
-                    ...(value === 400 ? { includeDefaultError: true } : {}),
-                },
-            ]
-            : []);
-    });
-}
-function concretePayload(type, checker, source, options) {
-    const contract = extractContractSchema(type, checker, source, options);
-    if (contract.schema.root.type === 'unknown')
-        throw new Error('Protocol payload must have a concrete root');
-    return contract;
-}
-function rawPropertyType(type, name, checker) {
-    const property = checker.getPropertyOfType(type, name);
-    const declaration = property?.valueDeclaration ?? property?.declarations?.[0];
-    return property && declaration
-        ? checker.getTypeOfSymbolAtLocation(property, declaration)
-        : undefined;
-}

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

@@ -1 +0,0 @@
-export declare function nextProtocolKey(contracts: ReadonlyMap<string, unknown>, key: string): string;

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

@@ -1,8 +0,0 @@
-export function nextProtocolKey(contracts, key) {
-    if (!contracts.has(key))
-        return key;
-    let index = 2;
-    while (contracts.has(`${key}#protocol-${index}`))
-        index++;
-    return `${key}#protocol-${index}`;
-}

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;