vouchington-tooling 0.34.0 → 0.36.0

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

@@ -1,42 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { hasRawBytes, indirectPayload, reflectApplyInvocation, writeAccess, } from './protocol-sse-write-resolution.mjs';
-/** Resolves direct and indirect SSE writes without losing their actual receiver. */
-export function sseWriteInvocation(call, checker) {
-    const reflected = reflectApplyInvocation(call, checker);
-    if (reflected)
-        return reflected;
-    const access = writeAccess(call.expression);
-    if (!access)
-        return undefined;
-    if (access.method === 'pipe')
-        return call.arguments[0]
-            ? { receiver: call.arguments[0], method: 'write', rawBytes: true }
-            : undefined;
-    if (access.method === 'bind') {
-        const target = writeAccess(access.receiver);
-        if (target?.method !== 'write' && target?.method !== 'end')
-            return undefined;
-        return { receiver: call.arguments[0], method: target.method, rawBytes: true };
-    }
-    if (access.method !== 'call' && access.method !== 'apply')
-        return { ...access, rawBytes: hasRawBytes(access.method, call.arguments, checker, false) };
-    const target = writeAccess(access.receiver);
-    const receiver = call.arguments[0];
-    if (!receiver)
-        return undefined;
-    const payload = indirectPayload(access.method, call, 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),
-    };
-}

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

@@ -1,7 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type HandlerBindings, type RouteBinding } from './response-contract-route-analysis.mts';
-import { type WriteReceiver } from './protocol-write-receiver.mts';
-export declare function routeKey(binding: RouteBinding): string;
-export declare function opaqueCallReceivesSelectedStream(call: ts.CallExpression, selectedReceivers: readonly WriteReceiver[], binding: RouteBinding, calls: readonly ts.CallExpression[], checker: ts.TypeChecker, bindings: HandlerBindings): boolean;
-export declare function helperBindings(node: ts.Node, calls: readonly ts.CallExpression[], checker: ts.TypeChecker, bindings: HandlerBindings): RouteBinding[];
-export declare function actualReceivers(receiver: WriteReceiver, binding: RouteBinding, calls: readonly ts.CallExpression[], checker: ts.TypeChecker, bindings: HandlerBindings, active?: Set<ts.Symbol>): (WriteReceiver | undefined)[];

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

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

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

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

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

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

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

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

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

@@ -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;