vouchington-tooling 0.34.0 → 0.36.0

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

@@ -1,19 +0,0 @@
-export type HeaderContract = {
-    requestHeaders: Readonly<Record<string, HeaderDescriptor>>;
-    responseHeaders: Readonly<Record<number, ResponseHeaderDescriptor>>;
-};
-export type HeaderDescriptor = {
-    description?: string;
-    format?: 'uuid';
-    required: boolean;
-    type: 'integer' | 'string';
-};
-export type ResponseHeaderDescriptor = {
-    description?: string;
-    errors?: readonly {
-        code: string;
-        message: string;
-    }[];
-    headers: Readonly<Record<string, HeaderDescriptor>>;
-};
-export type HeaderContractRegistry = Readonly<Record<string, HeaderContract>>;

package/dist/api-contract-discovery/index.d.mts

@@ -1,34 +0,0 @@
-import type ts from '../contract-schema/typescript-api.mts';
-import type { DiscoverApiResponseContractsOptions } from './response-contract-lenient.mts';
-export declare const APP_ROUTE_CTX_ADAPTER_VERSION: 1;
-export type AppRouteCtxDiscoveryInput = {
-    program: ts.Program;
-    sourceFiles: readonly ts.SourceFile[];
-    requestedKeys?: ReadonlySet<string>;
-    options?: DiscoverApiResponseContractsOptions;
-};
-/** Discovers the version-one `app.route(...).method(handler)` and `ctx` convention. */
-export declare function discoverAppRouteCtxContractsV1(input: AppRouteCtxDiscoveryInput): {
-    adapterVersion: 1;
-    routes: import("./registered-route-catalog.mts").RegisteredRoute[];
-    responses: Record<string, import("./response-contract-types.mts").BackendResponseContract>;
-    requests: Record<string, import("./request-contract-types.mts").BackendRequestContract>;
-    queries: Readonly<Record<string, import("./query-contract-types.mts").BackendQueryContract>>;
-    headers: Readonly<Record<string, import("./header-contract-types.mts").HeaderContract>>;
-};
-export { discoverApiResponseContracts } from './response-contract-registry.mts';
-export { discoverApiRequestContracts } from './request-contract-registry.mts';
-export { discoverApiQueryContracts } from './query-contract-registry.mts';
-export { discoverApiHeaderContracts } from './header-contract-registry.mts';
-export { discoverRegisteredRoutes, routeShape } from './registered-route-catalog.mts';
-export { responseStatusCodesForContract } from './response-contract-status.mts';
-export type { BackendResponseContract } from './response-contract-types.mts';
-export type { BackendRequestContract } from './request-contract-types.mts';
-export type { BackendQueryContract, BackendQueryContractRegistry } from './query-contract-types.mts';
-export type { HeaderContract, HeaderContractRegistry } from './header-contract-types.mts';
-export type { RegisteredRoute } from './registered-route-catalog.mts';
-export type { AmbiguousAttributionFact, RouteDiscoveryError, DiscoverApiResponseContractsOptions, } from './response-contract-lenient.mts';
-export type { DiscoverApiRequestContractsOptions } from './request-contract-lenient.mts';
-export { discoverRequestValidationFacts } from './request-validation-facts.mts';
-export type { RequestValidationFactsInput } from './request-validation-facts.mts';
-export type { Carrier, CarrierRead, ExecutedCallbackConfig, FactoryConfig, FactorySite, RouteValidationFacts, ValidatorConfig, ValidatorSite, ValidatorSiteCarrier, } from './request-validation-types.mts';

package/dist/api-contract-discovery/index.mjs

@@ -1,27 +0,0 @@
-import { discoverApiHeaderContracts } from './header-contract-registry.mjs';
-import { discoverApiQueryContracts } from './query-contract-registry.mjs';
-import { discoverRegisteredRoutes } from './registered-route-catalog.mjs';
-import { discoverApiRequestContracts } from './request-contract-registry.mjs';
-import { discoverApiResponseContracts } from './response-contract-registry.mjs';
-export const APP_ROUTE_CTX_ADAPTER_VERSION = 1;
-/** Discovers the version-one `app.route(...).method(handler)` and `ctx` convention. */
-export function discoverAppRouteCtxContractsV1(input) {
-    const { program, sourceFiles, requestedKeys, options } = input;
-    const responses = discoverApiResponseContracts(program, sourceFiles, requestedKeys, options);
-    const knownResponseRoutes = new Set(Object.keys(responses));
-    return {
-        adapterVersion: APP_ROUTE_CTX_ADAPTER_VERSION,
-        routes: discoverRegisteredRoutes(program, sourceFiles),
-        responses,
-        requests: discoverApiRequestContracts(program, sourceFiles, requestedKeys, options),
-        queries: discoverApiQueryContracts(program, sourceFiles, knownResponseRoutes),
-        headers: discoverApiHeaderContracts(program, sourceFiles, knownResponseRoutes),
-    };
-}
-export { discoverApiResponseContracts } from './response-contract-registry.mjs';
-export { discoverApiRequestContracts } from './request-contract-registry.mjs';
-export { discoverApiQueryContracts } from './query-contract-registry.mjs';
-export { discoverApiHeaderContracts } from './header-contract-registry.mjs';
-export { discoverRegisteredRoutes, routeShape } from './registered-route-catalog.mjs';
-export { responseStatusCodesForContract } from './response-contract-status.mjs';
-export { discoverRequestValidationFacts } from './request-validation-facts.mjs';

package/dist/api-contract-discovery/protocol-analysis-cache.d.mts

@@ -1,21 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export type Assignment = {
-    node: ts.BinaryExpression;
-    direct: boolean;
-    start: number;
-};
-/**
- * Memoized protocol-proof results for one analysis run. Nodes are immutable, so every entry stays
- * valid for the run; callers create one per run and drop it afterwards.
- */
-export type ProtocolCache = {
-    /** Plain assignments per owning function (or source file), grouped by the symbol they write. */
-    assignments: Map<ts.Node, Map<ts.Symbol, Assignment[]>>;
-    /** Symbols written (assigned, updated, or looped over) anywhere in a source file. */
-    writtenSymbols: Map<ts.SourceFile, Set<ts.Symbol | undefined>>;
-    /** Whether a function is a supported protocol callback. */
-    supported: Map<ts.Node, boolean>;
-    /** Executable call expressions of a source file. */
-    calls: Map<ts.SourceFile, ts.CallExpression[]>;
-};
-export declare const createProtocolCache: () => ProtocolCache;

package/dist/api-contract-discovery/protocol-analysis-cache.mjs

@@ -1,7 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-export const createProtocolCache = () => ({
-    assignments: new Map(),
-    writtenSymbols: new Map(),
-    supported: new Map(),
-    calls: new Map(),
-});

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

@@ -1,2 +0,0 @@
-/** RFC 9110 sections 6.4.1 and 15.3.6 prohibit content at these response statuses. */
-export declare function statusForbidsBody(status: number): boolean;

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

@@ -1,4 +0,0 @@
-/** RFC 9110 sections 6.4.1 and 15.3.6 prohibit content at these response statuses. */
-export function statusForbidsBody(status) {
-    return (status >= 100 && status < 200) || status === 204 || status === 205 || status === 304;
-}

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

@@ -1,7 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { CallbackBindings, createProtocolCallbackValueResolver } from './protocol-callback-values.mts';
-/** Binds literal callback parameters, declining unsupported destructuring shapes. */
-export declare function callbackArgumentBindings(fn: ts.FunctionLikeDeclaration, call: ts.CallExpression | ts.NewExpression, env: CallbackBindings, captured: CallbackBindings, checker: ts.TypeChecker, resolver: ReturnType<typeof createProtocolCallbackValueResolver>): Map<ts.Symbol, {
-    node: ts.Node;
-    env: CallbackBindings;
-}> | undefined;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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