vouchington-tooling 0.35.0 → 0.36.0

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

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

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

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

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

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

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

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

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

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

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

@@ -1,3 +0,0 @@
-import type { QueryParameterContract } from './query-contract-types.mts';
-import ts from '../contract-schema/typescript-api.mts';
-export declare function extractQueryParameterDescriptor(type: ts.Type, checker: ts.TypeChecker, sourceFile: ts.SourceFile, node: ts.Node, parameterName: string): QueryParameterContract;

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

@@ -1,82 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { contractError } from './response-contract-registration.mjs';
-import { optionalNumberLiteral, declaresProperty, optionalTrueLiteral, optionalStringLiteral, requiredBooleanLiteral, requiredNumberLiteral, requiredPropertyType, rejectUnresolvedType, requiredStringLiteral, stringTuple, } from './query-contract-literals.mjs';
-export function extractQueryParameterDescriptor(type, checker, sourceFile, node, parameterName) {
-    rejectUnresolvedType(type, failure(sourceFile, node, parameterName));
-    const descriptor = extractDescriptorShape(type, checker, sourceFile, node, parameterName);
-    if (!optionalTrueLiteral(type, 'required', checker, failure(sourceFile, node, parameterName))) {
-        return descriptor;
-    }
-    if (declaresProperty(type, 'default')) {
-        failure(sourceFile, node, parameterName)('required cannot be combined with default');
-    }
-    return { ...descriptor, required: true };
-}
-function failure(sourceFile, node, parameterName) {
-    return (detail) => {
-        throw contractError(sourceFile, node, `Malformed query parameter "${parameterName}": ${detail}`);
-    };
-}
-function extractDescriptorShape(type, checker, sourceFile, node, parameterName) {
-    const fail = failure(sourceFile, node, parameterName);
-    const kind = requiredStringLiteral(type, 'kind', checker, fail);
-    const description = optionalStringLiteral(type, 'description', checker, node, fail);
-    const options = description === undefined ? {} : { description };
-    if (kind === 'string') {
-        const format = optionalStringLiteral(type, 'format', checker, node, fail);
-        if (format === 'uuid')
-            return { kind, format, ...options };
-        if (format === 'uri')
-            return { kind, format, ...options };
-        if (format !== undefined)
-            fail('unsupported format');
-        return { kind, ...options };
-    }
-    if (kind === 'uuid-or-uri' ||
-        kind === 'boolean' ||
-        kind === 'nullable-boolean' ||
-        kind === 'number') {
-        return { kind, ...options };
-    }
-    if (kind === 'integer') {
-        const minimum = requiredNumberLiteral(type, 'minimum', checker, fail);
-        const maximum = requiredNumberLiteral(type, 'maximum', checker, fail);
-        const defaultValue = optionalNumberLiteral(type, 'default', checker, node, fail);
-        return {
-            kind,
-            minimum,
-            maximum,
-            ...(defaultValue === undefined ? {} : { default: defaultValue }),
-            ...options,
-        };
-    }
-    if (kind === 'enum') {
-        const values = stringTuple(type, 'values', checker, fail);
-        const defaultValue = optionalStringLiteral(type, 'default', checker, node, fail);
-        if (defaultValue !== undefined && !values.includes(defaultValue)) {
-            fail('default must be one of values');
-        }
-        return {
-            kind,
-            values,
-            ...(defaultValue === undefined ? {} : { default: defaultValue }),
-            ...options,
-        };
-    }
-    if (kind === 'csv-array') {
-        if (requiredStringLiteral(type, 'style', checker, fail) !== 'form')
-            fail('style must be form');
-        if (requiredBooleanLiteral(type, 'explode', checker, fail) !== false)
-            fail('explode must be false');
-        const itemType = requiredPropertyType(type, 'items', checker, fail);
-        rejectUnresolvedType(itemType, fail);
-        if (declaresProperty(itemType, 'required'))
-            fail('array items cannot be required');
-        const items = extractDescriptorShape(itemType, checker, sourceFile, node, `${parameterName}[]`);
-        if (items.kind === 'string' || items.kind === 'enum') {
-            return { kind, items, style: 'form', explode: false, ...options };
-        }
-        return fail('array items must be string or enum');
-    }
-    return fail(`unsupported kind "${kind}"`);
-}

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

@@ -1,13 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function requiredPropertyType(type: ts.Type, name: string, checker: ts.TypeChecker, fail: (detail: string) => never): ts.Type;
-export declare function requiredStringLiteral(type: ts.Type, name: string, checker: ts.TypeChecker, fail: (detail: string) => never): string;
-export declare function requiredNumberLiteral(type: ts.Type, name: string, checker: ts.TypeChecker, fail: (detail: string) => never): number;
-export declare function requiredBooleanLiteral(type: ts.Type, name: string, checker: ts.TypeChecker, fail: (detail: string) => never): boolean;
-export declare function optionalStringLiteral(type: ts.Type, name: string, checker: ts.TypeChecker, node: ts.Node, fail: (detail: string) => never): string | undefined;
-export declare function optionalNumberLiteral(type: ts.Type, name: string, checker: ts.TypeChecker, node: ts.Node, fail: (detail: string) => never): number | undefined;
-export declare function optionalTrueLiteral(type: ts.Type, name: string, checker: ts.TypeChecker, fail: (detail: string) => never): boolean;
-/** True when the type, or any member of a union type, declares the property. */
-export declare function declaresProperty(type: ts.Type, name: string): boolean;
-export declare function stringTuple(type: ts.Type, name: string, checker: ts.TypeChecker, fail: (detail: string) => never): readonly string[];
-/** Fails when the type, or any union/intersection constituent, is conditional or generic. */
-export declare function rejectUnresolvedType(type: ts.Type, fail: (detail: string) => never): void;

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

@@ -1,83 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-export function requiredPropertyType(type, name, checker, fail) {
-    const property = type.getProperty(name);
-    if (!property || property.flags & ts.SymbolFlags.Optional)
-        return fail(`requires literal ${name}`);
-    const location = property.valueDeclaration ?? property.declarations?.[0];
-    if (!location)
-        return fail(`requires declared ${name}`);
-    return checker.getTypeOfSymbolAtLocation(property, location);
-}
-export function requiredStringLiteral(type, name, checker, fail) {
-    const value = requiredPropertyType(type, name, checker, fail);
-    return value.isStringLiteral() ? value.value : fail(`requires literal ${name}`);
-}
-export function requiredNumberLiteral(type, name, checker, fail) {
-    const value = requiredPropertyType(type, name, checker, fail);
-    return value.isNumberLiteral() ? value.value : fail(`requires literal ${name}`);
-}
-export function requiredBooleanLiteral(type, name, checker, fail) {
-    const value = requiredPropertyType(type, name, checker, fail);
-    if (value.flags & ts.TypeFlags.BooleanLiteral)
-        return checker.typeToString(value) === 'true';
-    return fail(`requires literal ${name}`);
-}
-export function optionalStringLiteral(type, name, checker, node, fail) {
-    const property = type.getProperty(name);
-    if (!property)
-        return undefined;
-    if (property.flags & ts.SymbolFlags.Optional)
-        return fail(`${name} must be literal when present`);
-    const location = property.valueDeclaration ?? property.declarations?.[0] ?? node;
-    const value = checker.getTypeOfSymbolAtLocation(property, location);
-    return value.isStringLiteral() ? value.value : fail(`requires literal ${name}`);
-}
-export function optionalNumberLiteral(type, name, checker, node, fail) {
-    const property = type.getProperty(name);
-    if (!property)
-        return undefined;
-    if (property.flags & ts.SymbolFlags.Optional)
-        return fail(`${name} must be literal when present`);
-    const location = property.valueDeclaration ?? property.declarations?.[0] ?? node;
-    const value = checker.getTypeOfSymbolAtLocation(property, location);
-    return value.isNumberLiteral() ? value.value : fail(`requires literal ${name}`);
-}
-export function optionalTrueLiteral(type, name, checker, fail) {
-    const property = type.getProperty(name);
-    if (!property) {
-        if (declaresProperty(type, name))
-            return fail(`${name} must be present on every union member`);
-        return false;
-    }
-    if (property.flags & ts.SymbolFlags.Optional)
-        return fail(`${name} must be literal when present`);
-    const value = requiredPropertyType(type, name, checker, fail);
-    const isTrue = value.flags & ts.TypeFlags.BooleanLiteral && checker.typeToString(value) === 'true';
-    return isTrue ? true : fail(`${name} must be the literal true`);
-}
-/** True when the type, or any member of a union type, declares the property. */
-export function declaresProperty(type, name) {
-    if (type.getProperty(name))
-        return true;
-    return type.isUnion() && type.types.some((member) => member.getProperty(name) !== undefined);
-}
-export function stringTuple(type, name, checker, fail) {
-    const value = requiredPropertyType(type, name, checker, fail);
-    if (!checker.isTupleType(value))
-        return fail(`${name} must be a literal tuple`);
-    const values = checker.getTypeArguments(value);
-    if (values.length === 0 || values.some((item) => !item.isStringLiteral())) {
-        return fail(`${name} must contain string literals`);
-    }
-    return values.map((item) => item.value);
-}
-/** Fails when the type, or any union/intersection constituent, is conditional or generic. */
-export function rejectUnresolvedType(type, fail) {
-    if (type.flags & (ts.TypeFlags.Conditional | ts.TypeFlags.Instantiable)) {
-        fail('descriptor must not contain unresolved conditional or generic types');
-    }
-    if (type.isUnionOrIntersection()) {
-        for (const member of type.types)
-            rejectUnresolvedType(member, fail);
-    }
-}

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

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { BackendQueryContractRegistry } from './query-contract-types.mts';
-export declare function discoverApiQueryContracts(program: ts.Program, sourceFiles: readonly ts.SourceFile[], knownResponseRoutes: ReadonlySet<string>): BackendQueryContractRegistry;

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

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

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

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

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

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

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

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

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

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

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

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

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

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