vouchington-tooling 0.34.0 → 0.36.0

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

@@ -1,41 +0,0 @@
-import type { ExtractedResponseContract, ExtractContractSchemaOptions } from '../contract-schema/index.mts';
-import type { RouteBinding } from './response-contract-route-analysis.mts';
-import type { BackendResponseContract } from './response-contract-types.mts';
-export type RouteDiscoveryError = {
-    method: string;
-    routeTemplate: string;
-    source: string;
-    reason: string;
-};
-/**
- * A response emitter found in a named handler registered for multiple routes. `sourceLocation`
- * is a normalized source path followed by one-based line and column; `routes` contains unique,
- * lexically sorted `METHOD:path` keys. `label` identifies the implicit response form.
- */
-export type AmbiguousAttributionFact = {
-    sourceLocation: string;
-    label: string;
-    routes: readonly string[];
-};
-export type DiscoverApiResponseContractsOptions = ExtractContractSchemaOptions & {
-    onRouteError?: (error: RouteDiscoveryError) => void;
-    /**
-     * Opt in to response-attribution facts from the existing discovery pass. Facts are delivered
-     * after discovery succeeds, ordered by normalized source location; each callback receives its
-     * own copy of the sorted route list. Dynamic error payloads paired with a non-literal status are
-     * excluded from these facts; discovery output keeps its existing behavior. Consumers choose
-     * whether a fact needs a diagnostic or policy.
-     */
-    onAmbiguousAttribution?: (fact: AmbiguousAttributionFact) => void;
-};
-/** Marks `key` unavailable regardless of AST visit order, for a route that can send a raw buffered body (e.g. a proxied MCP response) alongside a no-content branch. */
-export declare function markBufferedRouteUnavailable(contracts: Map<string, BackendResponseContract>, key: string, binding: RouteBinding, source: string): void;
-/**
- * Extracts a route's response contract and registers it. When `options.onRouteError` is
- * set, an extraction failure is caught, reported, and replaced with an `unavailable`
- * placeholder instead of aborting discovery for every other route. With `options` absent
- * (or `onRouteError` unset), behavior is unchanged: extraction failures throw.
- */
-export declare function registerRouteContract(contracts: Map<string, BackendResponseContract>, key: string, binding: RouteBinding, location: string, emission: Pick<BackendResponseContract, 'bodyKind' | 'mediaType' | 'mediaTypeKnowledge' | 'statusCodes' | 'statusKnowledge'> & {
-    unavailableReason?: string;
-}, extract: () => ExtractedResponseContract, options: DiscoverApiResponseContractsOptions | undefined): void;

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

@@ -1,52 +0,0 @@
-import { hashContractSchema } from '../contract-schema/index.mjs';
-import { registerContract } from './response-contract-registration.mjs';
-/** Placeholder contract for a route whose response type could not be extracted. */
-function unavailableContract(source, reason) {
-    const schema = { root: { type: 'unknown' }, definitions: {} };
-    return { source, schema, hash: hashContractSchema(schema), unavailableReason: reason };
-}
-/** Marks `key` unavailable regardless of AST visit order, for a route that can send a raw buffered body (e.g. a proxied MCP response) alongside a no-content branch. */
-export function markBufferedRouteUnavailable(contracts, key, binding, source) {
-    contracts.set(key, {
-        ...unavailableContract(source, 'route can send a raw buffered response body (ctx.response.buffer) whose shape is not statically determinable'),
-        ...binding,
-        bodyKind: 'content',
-        statusKnowledge: 'unknown',
-        mediaTypeKnowledge: 'unknown',
-    });
-}
-/**
- * Extracts a route's response contract and registers it. When `options.onRouteError` is
- * set, an extraction failure is caught, reported, and replaced with an `unavailable`
- * placeholder instead of aborting discovery for every other route. With `options` absent
- * (or `onRouteError` unset), behavior is unchanged: extraction failures throw.
- */
-export function registerRouteContract(contracts, key, binding, location, emission, extract, options) {
-    let extracted;
-    try {
-        if (emission.unavailableReason)
-            throw new Error(emission.unavailableReason);
-        extracted = extract();
-    }
-    catch (error) {
-        if (!options?.onRouteError)
-            throw error;
-        const reason = error instanceof Error ? error.message : String(error);
-        options.onRouteError({
-            method: binding.method,
-            routeTemplate: binding.routeTemplate,
-            source: location,
-            reason,
-        });
-        extracted = unavailableContract(location, reason);
-    }
-    registerContract(contracts, key, {
-        ...extracted,
-        ...binding,
-        ...(emission.bodyKind ? { bodyKind: emission.bodyKind } : {}),
-        ...(emission.mediaType ? { mediaType: emission.mediaType } : {}),
-        ...(emission.mediaTypeKnowledge ? { mediaTypeKnowledge: emission.mediaTypeKnowledge } : {}),
-        ...(emission.statusCodes ? { statusCodes: emission.statusCodes } : {}),
-        ...(emission.statusKnowledge ? { statusKnowledge: emission.statusKnowledge } : {}),
-    });
-}

package/dist/api-contract-discovery/response-contract-media.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function isXmlResponseCall(call: ts.CallExpression): boolean;
-export declare function streamingTextMediaType(call: ts.CallExpression): 'application/xml' | 'text/csv' | undefined;

package/dist/api-contract-discovery/response-contract-media.mjs

@@ -1,46 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { isContextMethod } from './response-contract-route-analysis.mjs';
-export function isXmlResponseCall(call) {
-    const expression = call.expression;
-    return (ts.isPropertyAccessExpression(expression) &&
-        expression.name.text === 'xml' &&
-        isContextMethod(expression.expression, 'response'));
-}
-export function streamingTextMediaType(call) {
-    let statement = call;
-    while (!ts.isStatement(statement))
-        statement = statement.parent;
-    const contentType = precedingContentType(statement);
-    return contentType === 'unsupported' ? undefined : contentType;
-}
-function precedingContentType(statement) {
-    const block = statement.parent;
-    if (!ts.isBlock(block))
-        return undefined;
-    const index = block.statements.indexOf(statement);
-    for (let i = index - 1; i >= 0; i--) {
-        const contentType = contentTypeStatement(block.statements[i]);
-        if (contentType)
-            return contentType;
-    }
-    const enclosing = block.parent;
-    return ts.isStatement(enclosing) ? precedingContentType(enclosing) : undefined;
-}
-function contentTypeStatement(statement) {
-    if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression))
-        return undefined;
-    const setter = statement.expression;
-    if (!isContextMethod(setter.expression, 'set'))
-        return undefined;
-    const [name, value] = setter.arguments;
-    if (!name || !ts.isStringLiteral(name) || name.text.toLowerCase() !== 'content-type')
-        return undefined;
-    if (!value || !ts.isStringLiteral(value))
-        return 'unsupported';
-    const contentType = value.text.toLowerCase();
-    if (contentType.startsWith('text/csv'))
-        return 'text/csv';
-    if (contentType.startsWith('application/xml'))
-        return 'application/xml';
-    return 'unsupported';
-}

package/dist/api-contract-discovery/response-contract-object-symbols.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function propertyImplementationSymbol(access: ts.PropertyAccessExpression, checker: ts.TypeChecker): ts.Symbol | undefined;
-export declare function destructuredPropertyImplementationSymbol(declaration: ts.BindingElement, checker: ts.TypeChecker): ts.Symbol | undefined;

package/dist/api-contract-discovery/response-contract-object-symbols.mjs

@@ -1,80 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-export function propertyImplementationSymbol(access, checker) {
-    const contextual = checker.getSymbolAtLocation(access.name);
-    const receiver = unwrapTransparentExpression(access.expression);
-    if (!contextual || !ts.isIdentifier(receiver))
-        return undefined;
-    const receiverSymbol = checker.getSymbolAtLocation(receiver);
-    const declaration = receiverSymbol?.valueDeclaration;
-    if (!declaration || !ts.isVariableDeclaration(declaration))
-        return contextual;
-    if (!declaration.initializer ||
-        !ts.isVariableDeclarationList(declaration.parent) ||
-        !(declaration.parent.flags & ts.NodeFlags.Const))
-        return undefined;
-    return constObjectPropertySymbol(receiver, access.name.text, checker);
-}
-export function destructuredPropertyImplementationSymbol(declaration, checker) {
-    const pattern = declaration.parent;
-    if (!ts.isObjectBindingPattern(pattern) || !ts.isIdentifier(declaration.name))
-        return undefined;
-    const variable = pattern.parent;
-    if (!ts.isVariableDeclaration(variable) ||
-        !variable.initializer ||
-        !ts.isVariableDeclarationList(variable.parent) ||
-        !(variable.parent.flags & ts.NodeFlags.Const))
-        return undefined;
-    if (declaration.dotDotDotToken || declaration.initializer)
-        return undefined;
-    const property = declaration.propertyName ?? declaration.name;
-    if (!ts.isIdentifier(property) && !ts.isStringLiteral(property))
-        return undefined;
-    const initializer = unwrapTransparentExpression(variable.initializer);
-    return ts.isIdentifier(initializer)
-        ? constObjectPropertySymbol(initializer, property.text, checker)
-        : undefined;
-}
-function constObjectPropertySymbol(receiver, key, checker, seen = new Set()) {
-    const receiverSymbol = checker.getSymbolAtLocation(receiver);
-    if (!receiverSymbol || seen.has(receiverSymbol))
-        return undefined;
-    seen.add(receiverSymbol);
-    const declaration = receiverSymbol.valueDeclaration;
-    if (!declaration ||
-        !ts.isVariableDeclaration(declaration) ||
-        !declaration.initializer ||
-        !ts.isVariableDeclarationList(declaration.parent) ||
-        !(declaration.parent.flags & ts.NodeFlags.Const))
-        return undefined;
-    const initializer = unwrapTransparentExpression(declaration.initializer);
-    if (ts.isIdentifier(initializer))
-        return constObjectPropertySymbol(initializer, key, checker, seen);
-    if (!ts.isObjectLiteralExpression(initializer))
-        return undefined;
-    if (initializer.properties.some(ts.isSpreadAssignment))
-        return undefined;
-    const implementation = initializer.properties.findLast((property) => {
-        const name = property.name;
-        return objectLiteralPropertyName(name) === key;
-    });
-    if (implementation && ts.isPropertyAssignment(implementation)) {
-        const value = unwrapTransparentExpression(implementation.initializer);
-        if (ts.isIdentifier(value))
-            return checker.getSymbolAtLocation(value);
-    }
-    if (implementation &&
-        (ts.isGetAccessorDeclaration(implementation) || ts.isSetAccessorDeclaration(implementation)))
-        return undefined;
-    return implementation?.name && checker.getSymbolAtLocation(implementation.name);
-}
-function objectLiteralPropertyName(name) {
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
-        return name.text;
-    if (!ts.isComputedPropertyName(name))
-        return undefined;
-    const expression = unwrapTransparentExpression(name.expression);
-    return ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)
-        ? expression.text
-        : undefined;
-}

package/dist/api-contract-discovery/response-contract-property-mutations.d.mts

@@ -1,5 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/** Direct syntactic property writes are excluded; indirect mutation is outside this proof. */
-export declare function findMutatedProperties(sourceFiles: readonly ts.SourceFile[], checker: ts.TypeChecker): Set<ts.Symbol>;
-/** Direct identifier and destructuring writes are excluded; indirect writes are unproven. */
-export declare function findMutatedBindings(sourceFiles: readonly ts.SourceFile[], checker: ts.TypeChecker): Set<ts.Symbol>;

package/dist/api-contract-discovery/response-contract-property-mutations.mjs

@@ -1,84 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { attributionSymbol, resolveSymbol } from './response-contract-symbols.mjs';
-import { unwrapTransparentExpression, visit } from './response-contract-route-syntax.mjs';
-/** Direct syntactic property writes are excluded; indirect mutation is outside this proof. */
-export function findMutatedProperties(sourceFiles, checker) {
-    const mutated = new Set();
-    for (const sourceFile of sourceFiles) {
-        visit(sourceFile, (node) => {
-            let access;
-            if (ts.isBinaryExpression(node) &&
-                node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
-                node.operatorToken.kind <= ts.SyntaxKind.LastAssignment &&
-                ts.isPropertyAccessExpression(unwrapTransparentExpression(node.left)))
-                access = unwrapTransparentExpression(node.left);
-            else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
-                (node.operator === ts.SyntaxKind.PlusPlusToken ||
-                    node.operator === ts.SyntaxKind.MinusMinusToken) &&
-                ts.isPropertyAccessExpression(node.operand))
-                access = node.operand;
-            if (!access)
-                return;
-            const symbol = checker.getSymbolAtLocation(access.name);
-            if (symbol)
-                mutated.add(attributionSymbol(resolveSymbol(symbol, checker), checker));
-        });
-    }
-    return mutated;
-}
-/** Direct identifier and destructuring writes are excluded; indirect writes are unproven. */
-export function findMutatedBindings(sourceFiles, checker) {
-    const mutated = new Set();
-    for (const sourceFile of sourceFiles) {
-        visit(sourceFile, (node) => {
-            let identifiers = [];
-            if (ts.isBinaryExpression(node) &&
-                node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
-                node.operatorToken.kind <= ts.SyntaxKind.LastAssignment &&
-                isAssignmentTarget(node.left))
-                identifiers = assignmentTargetIdentifiers(node.left);
-            else if ((ts.isForInStatement(node) || ts.isForOfStatement(node)) &&
-                !ts.isVariableDeclarationList(node.initializer) &&
-                isAssignmentTarget(node.initializer))
-                identifiers = assignmentTargetIdentifiers(node.initializer);
-            else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
-                (node.operator === ts.SyntaxKind.PlusPlusToken ||
-                    node.operator === ts.SyntaxKind.MinusMinusToken) &&
-                ts.isIdentifier(node.operand))
-                identifiers = [node.operand];
-            for (const identifier of identifiers) {
-                const symbol = checker.getSymbolAtLocation(identifier);
-                if (symbol)
-                    mutated.add(attributionSymbol(resolveSymbol(symbol, checker), checker));
-            }
-        });
-    }
-    return mutated;
-}
-function isAssignmentTarget(expression) {
-    const target = unwrapTransparentExpression(expression);
-    return (ts.isIdentifier(target) ||
-        ts.isArrayLiteralExpression(target) ||
-        ts.isObjectLiteralExpression(target));
-}
-function assignmentTargetIdentifiers(expression) {
-    const target = unwrapTransparentExpression(expression);
-    if (ts.isIdentifier(target))
-        return [target];
-    if (ts.isArrayLiteralExpression(target))
-        return target.elements.flatMap((element) => ts.isOmittedExpression(element)
-            ? []
-            : assignmentTargetIdentifiers(ts.isSpreadElement(element) ? element.expression : element));
-    if (!ts.isObjectLiteralExpression(target))
-        return [];
-    const identifiers = [];
-    for (const property of target.properties) {
-        if (ts.isShorthandPropertyAssignment(property))
-            identifiers.push(property.name);
-        else if (ts.isPropertyAssignment(property))
-            identifiers.push(...assignmentTargetIdentifiers(property.initializer));
-        else if (ts.isSpreadAssignment(property))
-            identifiers.push(...assignmentTargetIdentifiers(property.expression));
-    }
-    return identifiers;
-}

package/dist/api-contract-discovery/response-contract-registration.d.mts

@@ -1,11 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ExtractedResponseContract, ExtractContractSchemaOptions } from '../contract-schema/index.mts';
-import type { BackendResponseContract } from './response-contract-types.mts';
-export declare function responseBodyExpression(call: ts.CallExpression, unwrapPipelineArguments?: boolean): ts.Expression | undefined;
-export declare function containsResponseMarker(node: ts.Node): boolean;
-export declare function extractBodyContract(call: ts.CallExpression, checker: ts.TypeChecker, sourceFile: ts.SourceFile, location: string, options?: ExtractContractSchemaOptions): ExtractedResponseContract;
-export declare function registerContract(contracts: Map<string, BackendResponseContract>, key: string, contract: BackendResponseContract): void;
-export declare function noContentContract(source: string): ExtractedResponseContract;
-export declare function binaryContentContract(source: string): ExtractedResponseContract;
-export declare function sourceLocation(sourceFile: ts.SourceFile, _node: ts.Node): string;
-export declare function contractError(sourceFile: ts.SourceFile, node: ts.Node, message: string): Error;

package/dist/api-contract-discovery/response-contract-registration.mjs

@@ -1,65 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { extractContractSchema, hashContractSchema } from '../contract-schema/index.mjs';
-import { isContextMethod, responseMarker, visit } from './response-contract-route-analysis.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-export function responseBodyExpression(call, unwrapPipelineArguments = false) {
-    if (isContextMethod(call.expression, 'json'))
-        return call.arguments[0];
-    if (!isContextMethod(call.expression, 'pipeline'))
-        return undefined;
-    const originalBody = call.arguments[0];
-    const pipelineBody = originalBody &&
-        (unwrapPipelineArguments ? unwrapTransparentExpression(originalBody) : originalBody);
-    if (!pipelineBody ||
-        !ts.isCallExpression(pipelineBody) ||
-        !ts.isIdentifier(pipelineBody.expression) ||
-        pipelineBody.expression.text !== 'streamJsonObject') {
-        return undefined;
-    }
-    const body = pipelineBody.arguments[0];
-    return body && (unwrapPipelineArguments ? unwrapTransparentExpression(body) : body);
-}
-export function containsResponseMarker(node) {
-    let found = false;
-    visit(node, (child) => {
-        if (ts.isCallExpression(child) && responseMarker(child.expression))
-            found = true;
-    });
-    return found;
-}
-export function extractBodyContract(call, checker, sourceFile, location, options = {}) {
-    const body = call.arguments[1];
-    if (!body)
-        throw contractError(sourceFile, call, 'apiResponse requires a response body');
-    return extractContractSchema(checker.getTypeAtLocation(body), checker, location, options);
-}
-export function registerContract(contracts, key, contract) {
-    const existing = contracts.get(key);
-    if (!existing) {
-        contracts.set(key, contract);
-        return;
-    }
-    if (existing.hash !== contract.hash) {
-        throw new Error(`Backend response contract "${key}" resolves to multiple backend response schemas at ${existing.source} and ${contract.source}`);
-    }
-}
-export function noContentContract(source) {
-    const schema = { root: { type: 'null' }, definitions: {} };
-    return { source, schema, hash: hashContractSchema(schema) };
-}
-export function binaryContentContract(source) {
-    const schema = {
-        root: { type: 'string', format: 'binary' },
-        definitions: {},
-    };
-    return { source, schema, hash: hashContractSchema(schema) };
-}
-export function sourceLocation(sourceFile, _node) {
-    return normalizePath(sourceFile.fileName);
-}
-export function contractError(sourceFile, node, message) {
-    return new Error(`${sourceLocation(sourceFile, node)}: ${message}`);
-}
-function normalizePath(path) {
-    return path.replaceAll('\\', '/');
-}

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

@@ -1,7 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type DiscoverApiResponseContractsOptions } from './response-contract-lenient.mts';
-import type { BackendResponseContract } from './response-contract-types.mts';
-export type { BackendResponseContract } from './response-contract-types.mts';
-export type { DiscoverApiResponseContractsOptions } from './response-contract-lenient.mts';
-export declare function discoverApiResponseContracts(program: ts.Program, sourceFiles: readonly ts.SourceFile[], requestedKeys?: ReadonlySet<string>, options?: DiscoverApiResponseContractsOptions): Record<string, BackendResponseContract>;
-export declare function enclosingResponseEmission(call: ts.CallExpression): ts.CallExpression | undefined;

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

@@ -1,124 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { registerPlatformCompilerLibraries } from './protocol-platform-callbacks.mjs';
-import { protocolBindingRequested, requestedProtocolKey } from './protocol-requested-keys.mjs';
-import { discoverProtocolContracts } from './protocol-contract-registry.mjs';
-import { discoverImplicitContract } from './response-contract-implicit.mjs';
-import { ambiguousRoutesForCall } from './response-contract-attribution.mjs';
-import { sortAttributionFacts } from './response-contract-attribution-facts.mjs';
-import { implicitResponseCallLabel } from './response-contract-call-classification.mjs';
-import { collectHandlerBindings } from './response-contract-handler-bindings.mjs';
-import { registerRouteContract, } from './response-contract-lenient.mjs';
-import { binaryContentContract, contractError, extractBodyContract, noContentContract, sourceLocation, } from './response-contract-registration.mjs';
-import { enclosingRouteBinding, isContextMethod, responseMarker, visit, } from './response-contract-route-analysis.mjs';
-import { resolveEmissionStatus } from './response-contract-status.mjs';
-export function discoverApiResponseContracts(program, sourceFiles, requestedKeys, options) {
-    registerPlatformCompilerLibraries(program);
-    const checker = program.getTypeChecker();
-    const contracts = new Map();
-    const ambiguousBindings = options?.onAmbiguousAttribution
-        ? new Map()
-        : undefined;
-    const handlerBindings = collectHandlerBindings(sourceFiles, checker, ambiguousBindings);
-    const attributionFacts = [];
-    const protocolContracts = new Map();
-    const protocolEmissions = discoverProtocolContracts(sourceFiles, checker, handlerBindings, protocolContracts, options, requestedKeys);
-    for (const [key, contract] of protocolContracts) {
-        const requestedKey = requestedProtocolKey(key, contract, requestedKeys);
-        if (requestedKey)
-            contracts.set(requestedKey, contract);
-    }
-    for (const sourceFile of sourceFiles) {
-        visit(sourceFile, (node) => {
-            if (!ts.isCallExpression(node))
-                return;
-            const marker = responseMarker(node.expression);
-            if (!marker)
-                return;
-            const keyNode = node.arguments[0];
-            if (!keyNode || !ts.isStringLiteral(keyNode)) {
-                throw contractError(sourceFile, node, `${marker} requires a literal contract key`);
-            }
-            const binding = enclosingRouteBinding(node, checker, handlerBindings);
-            if (!binding)
-                throw contractError(sourceFile, node, `${marker} must be inside an app.route handler`);
-            const expectedPrefix = `${binding.method}:${binding.routeTemplate}`;
-            if (keyNode.text !== expectedPrefix && !keyNode.text.startsWith(`${expectedPrefix}#`)) {
-                throw contractError(sourceFile, keyNode, `Contract key "${keyNode.text}" does not match enclosing route ${expectedPrefix}`);
-            }
-            const location = sourceLocation(sourceFile, node);
-            const responseEmission = enclosingResponseEmission(node) ?? node;
-            const status = resolveEmissionStatus(responseEmission);
-            const rawMediaType = rawResponseMediaType(marker, node, sourceFile);
-            registerRouteContract(contracts, keyNode.text, binding, location, {
-                bodyKind: marker === 'apiNoContent' ? 'none' : 'content',
-                ...(marker === 'apiResponse'
-                    ? { mediaType: 'application/json', mediaTypeKnowledge: 'known' }
-                    : rawMediaType
-                        ? { mediaType: rawMediaType, mediaTypeKnowledge: 'known' }
-                        : { mediaTypeKnowledge: 'none' }),
-                ...status,
-            }, () => marker === 'apiNoContent'
-                ? noContentContract(location)
-                : marker === 'apiOpenApiRawResponse'
-                    ? binaryContentContract(location)
-                    : extractBodyContract(node, checker, sourceFile, location, options), options);
-        });
-    }
-    for (const sourceFile of sourceFiles) {
-        visit(sourceFile, (node) => {
-            if (!ts.isCallExpression(node))
-                return;
-            const callLabel = implicitResponseCallLabel(node);
-            if (options?.onAmbiguousAttribution) {
-                const attributionLabel = implicitResponseCallLabel(node, true, checker);
-                const routes = attributionLabel
-                    ? ambiguousBindings &&
-                        ambiguousRoutesForCall(node, checker, handlerBindings, ambiguousBindings)
-                    : undefined;
-                const requestedRoute = !requestedKeys ||
-                    routes?.some((route) => {
-                        const separator = route.indexOf(':');
-                        return (separator > 0 &&
-                            protocolBindingRequested({ method: route.slice(0, separator), routeTemplate: route.slice(separator + 1) }, requestedKeys));
-                    });
-                if (attributionLabel && routes && requestedRoute) {
-                    const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-                    attributionFacts.push({
-                        sourceLocation: `${sourceLocation(sourceFile, node)}:${position.line + 1}:${position.character + 1}`,
-                        label: attributionLabel,
-                        routes: [...routes],
-                    });
-                }
-            }
-            if (responseMarker(node.expression) || protocolEmissions.has(node))
-                return;
-            discoverImplicitContract(node, checker, sourceFile, contracts, handlerBindings, callLabel, requestedKeys, options);
-        });
-    }
-    const result = Object.fromEntries([...contracts.entries()].toSorted(([left], [right]) => left.localeCompare(right)));
-    if (options?.onAmbiguousAttribution) {
-        for (const fact of sortAttributionFacts(attributionFacts))
-            options.onAmbiguousAttribution(fact);
-    }
-    return result;
-}
-function rawResponseMediaType(marker, node, sourceFile) {
-    if (marker !== 'apiOpenApiRawResponse')
-        return undefined;
-    const mediaType = node.arguments[1];
-    if (!mediaType || !ts.isStringLiteral(mediaType)) {
-        throw contractError(sourceFile, node, 'apiOpenApiRawResponse requires a literal media type');
-    }
-    return mediaType.text;
-}
-export function enclosingResponseEmission(call) {
-    let current = call.parent;
-    while (current && !ts.isStatement(current)) {
-        if (ts.isCallExpression(current) &&
-            (isContextMethod(current.expression, 'json') ||
-                isContextMethod(current.expression, 'pipeline')))
-            return current;
-        current = current.parent;
-    }
-    return undefined;
-}

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

@@ -1,12 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export { collectHandlerBindings } from './response-contract-handler-bindings.mts';
-export { propertyName, routeTemplateFromExpression, visit, } from './response-contract-route-syntax.mts';
-export { isContextMethod, isContextResponseBufferCall, isContextResponseEmptyCall, responseMarker, } from './response-contract-ctx-analysis.mts';
-export type RouteBinding = {
-    method: string;
-    routeTemplate: string;
-};
-export type HandlerBindings = Map<ts.Symbol, RouteBinding>;
-export type AmbiguousHandlerBindings = Map<ts.Symbol, readonly string[]>;
-export declare function requestedKeyForBinding(binding: RouteBinding, requestedKeys?: ReadonlySet<string>): string | undefined;
-export declare function enclosingRouteBinding(node: ts.Node, checker: ts.TypeChecker, handlerBindings: HandlerBindings, proveCallbacks?: boolean): RouteBinding | undefined;

package/dist/api-contract-discovery/response-contract-route-analysis.mjs

@@ -1,65 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { functionSymbol, resolveSymbol } from './response-contract-symbols.mjs';
-import { executableProtocolPath } from './protocol-execution-path.mjs';
-import { HTTP_METHODS, propertyName, routeTemplateFromExpression, } from './response-contract-route-syntax.mjs';
-export { collectHandlerBindings } from './response-contract-handler-bindings.mjs';
-export { propertyName, routeTemplateFromExpression, visit, } from './response-contract-route-syntax.mjs';
-export { isContextMethod, isContextResponseBufferCall, isContextResponseEmptyCall, responseMarker, } from './response-contract-ctx-analysis.mjs';
-export function requestedKeyForBinding(binding, requestedKeys) {
-    if (!requestedKeys)
-        return `${binding.method}:${binding.routeTemplate}`;
-    const exact = `${binding.method}:${binding.routeTemplate}`;
-    if (requestedKeys.has(exact))
-        return exact;
-    const bindingShape = routeShape(binding.routeTemplate);
-    return [...requestedKeys]
-        .filter((key) => !key.includes('#'))
-        .find((key) => {
-        const separator = key.indexOf(':');
-        return (key.slice(0, separator) === binding.method &&
-            routeShape(key.slice(separator + 1)) === bindingShape);
-    });
-}
-function routeShape(routeTemplate) {
-    return routeTemplate.replace(/:[^/]+/g, ':');
-}
-export function enclosingRouteBinding(node, checker, handlerBindings, proveCallbacks = true) {
-    let current = node;
-    let insideHandlerFunction = false;
-    while (current) {
-        if (ts.isFunctionLike(current))
-            insideHandlerFunction = true;
-        if (insideHandlerFunction && ts.isCallExpression(current)) {
-            const method = propertyName(current.expression)?.toUpperCase();
-            const routeTemplate = routeTemplateFromExpression(current.expression);
-            if (method && HTTP_METHODS.has(method) && routeTemplate)
-                return !proveCallbacks || executableProtocolPath(node, checker)
-                    ? { method, routeTemplate }
-                    : undefined;
-        }
-        if (isFunctionLike(current) && ts.isCallExpression(current.parent)) {
-            const handlerCall = current.parent;
-            const method = propertyName(handlerCall.expression)?.toUpperCase();
-            if (method && HTTP_METHODS.has(method)) {
-                const routeTemplate = routeTemplateFromExpression(handlerCall.expression);
-                if (routeTemplate)
-                    return !proveCallbacks || executableProtocolPath(node, checker)
-                        ? { method, routeTemplate }
-                        : undefined;
-            }
-        }
-        const handlerSymbol = functionSymbol(current, checker);
-        if (handlerSymbol) {
-            const binding = handlerBindings.get(resolveSymbol(handlerSymbol, checker));
-            if (binding)
-                return !proveCallbacks || executableProtocolPath(node, checker, current)
-                    ? binding
-                    : undefined;
-        }
-        current = current.parent;
-    }
-    return undefined;
-}
-function isFunctionLike(node) {
-    return ts.isArrowFunction(node) || ts.isFunctionExpression(node);
-}

package/dist/api-contract-discovery/response-contract-route-syntax.d.mts

@@ -1,7 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare const HTTP_METHODS: Set<string>;
-export declare function isInlineRouteHandler(node: ts.Node): boolean;
-export declare function routeTemplateFromExpression(expression: ts.Expression): string | undefined;
-export declare function propertyName(expression: ts.Expression): string | undefined;
-export declare function unwrapTransparentExpression(expression: ts.Expression): ts.Expression;
-export declare function visit(node: ts.Node, callback: (node: ts.Node) => void): void;