vouchington-tooling 0.35.0 → 0.36.0

package/dist/api-contract-discovery/request-validation.test-helpers.mjs

@@ -1,108 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { discoverRequestValidationFacts } from './request-validation-facts.mjs';
-/** Synthetic library modules shared by the request-validation fixtures. */
-export const librarySources = {
-    'lib/validation.ts': `
-    export function validateInput(ctx: any, operation: string, input?: any): boolean {
-      if (ctx.query.limit && input && operation) ctx.throw(400)
-      return true
-    }
-    export function validatePage(ctx: any, operation: string, options?: any): boolean {
-      if (ctx.query.limit && operation && options) ctx.throw(400)
-      return true
-    }
-  `,
-    'lib/factory.ts': `
-    import { validateInput } from './validation'
-    export function createThingHandler(options: any) {
-      return (ctx: any) => {
-        if (options.mode) validateInput(ctx, options.operation, { path: ctx.params })
-        ctx.status = 204
-      }
-    }
-  `,
-    'lib/reexport.ts': `export { validateInput as checkInput } from './validation'`,
-    'lib/keys.ts': `export const LIST_KEY = 'GET:/api/items'`,
-};
-export const validators = [
-    {
-        module: 'lib/validation.ts',
-        exportName: 'validateInput',
-        operationArgument: 1,
-        carriers: { kind: 'input-object', argument: 2 },
-    },
-    {
-        module: 'lib/validation',
-        exportName: 'validatePage',
-        operationArgument: 1,
-        carriers: {
-            kind: 'fixed',
-            carriers: ['query'],
-            optionCarriers: [{ argument: 2, property: 'path', carrier: 'path' }],
-        },
-    },
-];
-const factories = [
-    {
-        module: 'lib/factory.ts',
-        exportName: 'createThingHandler',
-        optionsArgument: 0,
-        operationProperty: 'operation',
-        carriers: ['path', 'body'],
-    },
-];
-const ROOT = '/virtual/';
-/** Builds a program whose files can import each other, relatively or through `@lib/*`. */
-export function buildModuleProgram(files) {
-    const sources = new Map(Object.entries(files).map(([path, text]) => [
-        `${ROOT}${path}`,
-        path.startsWith('global/') ? text : `${text}\nexport {}\n`,
-    ]));
-    const options = {
-        module: ts.ModuleKind.ESNext,
-        moduleResolution: ts.ModuleResolutionKind.Bundler,
-        baseUrl: ROOT,
-        paths: { '@lib/*': ['lib/*'] },
-        skipLibCheck: true,
-        strict: true,
-        target: ts.ScriptTarget.ESNext,
-    };
-    const host = ts.createCompilerHost(options, true);
-    const getSourceFile = host.getSourceFile.bind(host);
-    host.getSourceFile = (requested, languageVersion, ...rest) => {
-        const text = sources.get(requested);
-        return text === undefined
-            ? getSourceFile(requested, languageVersion, ...rest)
-            : ts.createSourceFile(requested, text, languageVersion, true, ts.ScriptKind.TS);
-    };
-    host.fileExists = (requested) => sources.has(requested) || ts.sys.fileExists(requested);
-    host.directoryExists = (requested) => [...sources.keys()].some((path) => path.startsWith(`${requested.replace(/\/$/, '')}/`)) ||
-        !!ts.sys.directoryExists?.(requested);
-    host.readFile = (requested) => sources.get(requested) ?? ts.sys.readFile(requested);
-    const program = ts.createProgram([...sources.keys()], options, host);
-    return {
-        program,
-        sourceFile(path) {
-            const sourceFile = program.getSourceFile(`${ROOT}${path}`);
-            const diagnostics = [
-                ...program.getSyntacticDiagnostics(sourceFile),
-                ...program.getSemanticDiagnostics(sourceFile),
-            ];
-            if (diagnostics.length > 0)
-                throw new Error(diagnostics
-                    .map((item) => ts.flattenDiagnosticMessageText(item.messageText, '\n'))
-                    .join('\n'));
-            return sourceFile;
-        },
-    };
-}
-/** Runs discovery over the given files with the shared configuration. */
-export function discover(built, paths, overrides = {}) {
-    return discoverRequestValidationFacts({
-        program: built.program,
-        sourceFiles: paths.map((path) => built.sourceFile(path)),
-        validators,
-        factories,
-        ...overrides,
-    });
-}

package/dist/api-contract-discovery/response-contract-attribution-facts.d.mts

@@ -1,2 +0,0 @@
-import type { AmbiguousAttributionFact } from './response-contract-lenient.mts';
-export declare function sortAttributionFacts(facts: readonly AmbiguousAttributionFact[]): AmbiguousAttributionFact[];

package/dist/api-contract-discovery/response-contract-attribution-facts.mjs

@@ -1,18 +0,0 @@
-export function sortAttributionFacts(facts) {
-    return [...facts].toSorted((left, right) => {
-        const first = parseSourceLocation(left.sourceLocation);
-        const second = parseSourceLocation(right.sourceLocation);
-        if (first.path !== second.path)
-            return first.path < second.path ? -1 : 1;
-        return first.line - second.line || first.column - second.column;
-    });
-}
-function parseSourceLocation(location) {
-    const columnSeparator = location.lastIndexOf(':');
-    const lineSeparator = location.lastIndexOf(':', columnSeparator - 1);
-    return {
-        path: location.slice(0, lineSeparator),
-        line: Number(location.slice(lineSeparator + 1, columnSeparator)),
-        column: Number(location.slice(columnSeparator + 1)),
-    };
-}

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

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type HandlerBindings, type AmbiguousHandlerBindings } from './response-contract-route-analysis.mts';
-export declare function ambiguousRoutesForCall(node: ts.Node, checker: ts.TypeChecker, handlerBindings: HandlerBindings, ambiguousBindings: AmbiguousHandlerBindings): readonly string[] | undefined;

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

@@ -1,23 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { executableProtocolPath } from './protocol-execution-path.mjs';
-import { attributionFunctionSymbol, attributionSymbol } from './response-contract-symbols.mjs';
-import { isInlineRouteHandler } from './response-contract-route-syntax.mjs';
-import {} from './response-contract-route-analysis.mjs';
-export function ambiguousRoutesForCall(node, checker, handlerBindings, ambiguousBindings) {
-    let current = node;
-    while (current) {
-        if (isInlineRouteHandler(current))
-            return undefined;
-        const symbol = attributionFunctionSymbol(current, checker);
-        if (symbol) {
-            const resolved = attributionSymbol(symbol, checker);
-            const routes = ambiguousBindings.get(resolved);
-            if (routes)
-                return executableProtocolPath(node, checker, current) ? routes : undefined;
-            if (handlerBindings.has(resolved))
-                return undefined;
-        }
-        current = current.parent;
-    }
-    return undefined;
-}

package/dist/api-contract-discovery/response-contract-call-classification.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export type ImplicitResponseCallLabel = 'ctx.json()' | 'ctx.pipeline()' | 'ctx.response.xml()' | 'ctx.response.buffer()' | 'ctx.response.empty()';
-export declare function implicitResponseCallLabel(call: ts.CallExpression, excludeDynamicErrorObjects?: boolean, checker?: ts.TypeChecker): ImplicitResponseCallLabel | undefined;

package/dist/api-contract-discovery/response-contract-call-classification.mjs

@@ -1,37 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { isInErrorBranch } from './response-contract-error-branch.mjs';
-import { isXmlResponseCall } from './response-contract-media.mjs';
-import { containsResponseMarker } from './response-contract-registration.mjs';
-import { isContextMethod, isContextResponseBufferCall, isContextResponseEmptyCall, } from './response-contract-route-analysis.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-export function implicitResponseCallLabel(call, excludeDynamicErrorObjects = false, checker) {
-    if (isContextMethod(call.expression, 'json')) {
-        if (!call.arguments[0] || isInErrorBranch(call, excludeDynamicErrorObjects, checker))
-            return undefined;
-        return 'ctx.json()';
-    }
-    if (isStreamJsonPipeline(call, excludeDynamicErrorObjects))
-        return isInErrorBranch(call, excludeDynamicErrorObjects, checker) ? undefined : 'ctx.pipeline()';
-    if (excludeDynamicErrorObjects && isInErrorBranch(call, true, checker))
-        return undefined;
-    if (isXmlResponseCall(call))
-        return call.arguments[0] ? 'ctx.response.xml()' : undefined;
-    if (isContextResponseBufferCall(call.expression))
-        return 'ctx.response.buffer()';
-    if (isContextResponseEmptyCall(call.expression))
-        return 'ctx.response.empty()';
-    if (isContextMethod(call.expression, 'pipeline') && !containsResponseMarker(call))
-        return 'ctx.pipeline()';
-    return undefined;
-}
-function isStreamJsonPipeline(call, unwrapArguments) {
-    if (!isContextMethod(call.expression, 'pipeline'))
-        return false;
-    const originalBody = call.arguments[0];
-    const pipelineBody = originalBody && (unwrapArguments ? unwrapTransparentExpression(originalBody) : originalBody);
-    return (!!pipelineBody &&
-        ts.isCallExpression(pipelineBody) &&
-        ts.isIdentifier(pipelineBody.expression) &&
-        pipelineBody.expression.text === 'streamJsonObject' &&
-        !!pipelineBody.arguments[0]);
-}

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

@@ -1,7 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function responseMarker(expression: ts.Expression): 'apiOpenApiRawResponse' | 'apiResponse' | 'apiNoContent' | undefined;
-export declare function isContextMethod(expression: ts.Expression, method: string): boolean;
-/** Detects the framework's explicit no-body signal independently of the response status. */
-export declare function isContextResponseEmptyCall(expression: ts.Expression): boolean;
-/** Detects `ctx.response.buffer(...)`: a raw pass-through body whose shape can't be statically extracted. */
-export declare function isContextResponseBufferCall(expression: ts.Expression): boolean;

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

@@ -1,28 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-export function responseMarker(expression) {
-    if (!ts.isIdentifier(expression))
-        return undefined;
-    if (expression.text === 'apiOpenApiRawResponse' ||
-        expression.text === 'apiResponse' ||
-        expression.text === 'apiNoContent')
-        return expression.text;
-    return undefined;
-}
-export function isContextMethod(expression, method) {
-    return (ts.isPropertyAccessExpression(expression) &&
-        ts.isIdentifier(expression.expression) &&
-        expression.expression.text === 'ctx' &&
-        expression.name.text === method);
-}
-/** Detects the framework's explicit no-body signal independently of the response status. */
-export function isContextResponseEmptyCall(expression) {
-    if (!ts.isPropertyAccessExpression(expression) || expression.name.text !== 'empty')
-        return false;
-    return isContextMethod(expression.expression, 'response');
-}
-/** Detects `ctx.response.buffer(...)`: a raw pass-through body whose shape can't be statically extracted. */
-export function isContextResponseBufferCall(expression) {
-    if (!ts.isPropertyAccessExpression(expression) || expression.name.text !== 'buffer')
-        return false;
-    return isContextMethod(expression.expression, 'response');
-}

package/dist/api-contract-discovery/response-contract-error-branch.d.mts

@@ -1,15 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/**
- * Detects a hand-rolled early-return error guard: `ctx.setStatus(NNN >= 400)` followed by a
- * response body call in the same block (e.g. `auth-me.mts`'s `ctx.setStatus(401); return
- * ctx.json({error})` before its `ctx.json({user})` success body). Skipping these keeps the
- * bare implicit key free for the route's actual success body instead of locking onto whichever
- * error branch happens to appear first in document order.
- *
- * Deliberately narrow: only a *direct* sibling `ExpressionStatement` counts, not a nested one
- * inside an earlier sibling's own subtree (e.g. inside an earlier, unrelated `if` guard's own
- * block). Recursing into nested subtrees would flag a trailing success statement that follows
- * two independent, self-contained early-return guards, even though neither guard's error status
- * is in effect on the path that reaches the trailing statement.
- */
-export declare function isInErrorBranch(call: ts.CallExpression, excludeDynamicErrorObjects?: boolean, checker?: ts.TypeChecker): boolean;

package/dist/api-contract-discovery/response-contract-error-branch.mjs

@@ -1,150 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { isContextMethod } from './response-contract-route-analysis.mjs';
-import { potentiallyExecuted } from './protocol-executable-path.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-import { responseBodyExpression } from './response-contract-registration.mjs';
-/**
- * Detects a hand-rolled early-return error guard: `ctx.setStatus(NNN >= 400)` followed by a
- * response body call in the same block (e.g. `auth-me.mts`'s `ctx.setStatus(401); return
- * ctx.json({error})` before its `ctx.json({user})` success body). Skipping these keeps the
- * bare implicit key free for the route's actual success body instead of locking onto whichever
- * error branch happens to appear first in document order.
- *
- * Deliberately narrow: only a *direct* sibling `ExpressionStatement` counts, not a nested one
- * inside an earlier sibling's own subtree (e.g. inside an earlier, unrelated `if` guard's own
- * block). Recursing into nested subtrees would flag a trailing success statement that follows
- * two independent, self-contained early-return guards, even though neither guard's error status
- * is in effect on the path that reaches the trailing statement.
- */
-export function isInErrorBranch(call, excludeDynamicErrorObjects = false, checker) {
-    let statement = call;
-    while (!ts.isStatement(statement))
-        statement = statement.parent;
-    if (!excludeDynamicErrorObjects)
-        return precededByErrorStatus(statement);
-    const latestStatus = latestStatusSetter(statement);
-    if (!latestStatus)
-        return false;
-    if (isBareErrorStatusStatement(latestStatus, true))
-        return true;
-    return isErrorObjectJson(call, checker) && isDynamicStatusStatement(latestStatus);
-}
-/**
- * Walks outward through enclosing blocks so a `ctx.setStatus(>=400)` set before the branch's own
- * containing statement — not just a direct sibling in the same block — still marks the branch as
- * an error path. Needed for a shared helper like `data-request.mts`'s `sendActiveRequestConflict`,
- * which sets one error status up front, then branches into two differently-shaped `ctx.json`
- * bodies nested one block deeper.
- */
-function precededByErrorStatus(statement) {
-    return precededByStatus(statement, isBareErrorStatusStatement);
-}
-function precededByStatus(statement, matches) {
-    const block = statement.parent;
-    if (!ts.isBlock(block))
-        return false;
-    const index = block.statements.indexOf(statement);
-    if (block.statements.slice(0, index).some(matches))
-        return true;
-    const enclosing = block.parent;
-    return ts.isStatement(enclosing) ? precededByStatus(enclosing, matches) : false;
-}
-function latestStatusSetter(statement) {
-    const block = statement.parent;
-    if (!ts.isBlock(block))
-        return undefined;
-    const index = block.statements.indexOf(statement);
-    for (let previous = index - 1; previous >= 0; previous--) {
-        const candidate = block.statements[previous];
-        if (isStatusSetterStatement(candidate)) {
-            if (potentiallyExecuted(candidate))
-                return candidate;
-            continue;
-        }
-        if (mayConditionallySetStatus(candidate))
-            return undefined;
-    }
-    const enclosing = block.parent;
-    return ts.isStatement(enclosing) ? latestStatusSetter(enclosing) : undefined;
-}
-function mayConditionallySetStatus(statement) {
-    if (ts.isFunctionDeclaration(statement) ||
-        ts.isInterfaceDeclaration(statement) ||
-        ts.isTypeAliasDeclaration(statement) ||
-        ts.isImportDeclaration(statement))
-        return false;
-    let found = false;
-    const inspect = (node) => {
-        if (node !== statement && isNestedFunction(node))
-            return;
-        if (ts.isCallExpression(node) &&
-            isContextMethod(node.expression, 'setStatus') &&
-            potentiallyExecuted(node))
-            found = true;
-        ts.forEachChild(node, inspect);
-    };
-    inspect(statement);
-    return found;
-}
-function isNestedFunction(node) {
-    return (ts.isFunctionDeclaration(node) ||
-        ts.isFunctionExpression(node) ||
-        ts.isArrowFunction(node) ||
-        ts.isMethodDeclaration(node) ||
-        ts.isGetAccessorDeclaration(node) ||
-        ts.isSetAccessorDeclaration(node) ||
-        ts.isConstructorDeclaration(node));
-}
-function isStatusSetterStatement(statement) {
-    return (ts.isExpressionStatement(statement) &&
-        ts.isCallExpression(statement.expression) &&
-        isContextMethod(statement.expression.expression, 'setStatus'));
-}
-function isDynamicStatusStatement(statement) {
-    const status = statement.expression.arguments[0];
-    return !!status && !ts.isNumericLiteral(unwrapTransparentExpression(status));
-}
-function isErrorObjectJson(call, checker) {
-    const body = responseBodyExpression(call, true);
-    const errorObject = body && resolveConstObjectAlias(unwrapTransparentExpression(body), checker);
-    return (!!errorObject &&
-        ts.isObjectLiteralExpression(errorObject) &&
-        errorObject.properties.some((property) => {
-            if (ts.isSpreadAssignment(property) || ts.isMethodDeclaration(property))
-                return false;
-            // Every remaining object-literal member has a name; spread members were excluded above.
-            const name = property.name;
-            if (ts.isIdentifier(name) || ts.isStringLiteral(name))
-                return name.text === 'error';
-            if (!ts.isComputedPropertyName(name))
-                return false;
-            const key = unwrapTransparentExpression(name.expression);
-            return ts.isStringLiteral(key) && key.text === 'error';
-        }));
-}
-function resolveConstObjectAlias(expression, checker, seen = new Set()) {
-    if (!checker || !ts.isIdentifier(expression))
-        return expression;
-    const symbol = checker.getSymbolAtLocation(expression);
-    if (!symbol || seen.has(symbol))
-        return expression;
-    seen.add(symbol);
-    const declaration = symbol.valueDeclaration;
-    if (!declaration ||
-        !ts.isVariableDeclaration(declaration) ||
-        !declaration.initializer ||
-        !ts.isVariableDeclarationList(declaration.parent) ||
-        !(declaration.parent.flags & ts.NodeFlags.Const))
-        return expression;
-    return resolveConstObjectAlias(unwrapTransparentExpression(declaration.initializer), checker, seen);
-}
-function isBareErrorStatusStatement(statement, unwrapStatus = false) {
-    if (!ts.isExpressionStatement(statement))
-        return false;
-    const expression = statement.expression;
-    if (!ts.isCallExpression(expression) || !isContextMethod(expression.expression, 'setStatus'))
-        return false;
-    const statusArgument = expression.arguments[0];
-    const status = statusArgument && (unwrapStatus ? unwrapTransparentExpression(statusArgument) : statusArgument);
-    return !!status && ts.isNumericLiteral(status) && Number(status.text) >= 400;
-}

package/dist/api-contract-discovery/response-contract-handler-bindings.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { AmbiguousHandlerBindings, HandlerBindings } from './response-contract-route-analysis.mts';
-export declare function collectHandlerBindings(sourceFiles: readonly ts.SourceFile[], checker: ts.TypeChecker, ambiguousBindings?: AmbiguousHandlerBindings): HandlerBindings;

package/dist/api-contract-discovery/response-contract-handler-bindings.mjs

@@ -1,126 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { executableProtocolPath } from './protocol-execution-path.mjs';
-import { potentiallyExecuted } from './protocol-executable-path.mjs';
-import { attributionSymbol, resolveSymbol } from './response-contract-symbols.mjs';
-import { findMutatedBindings, findMutatedProperties, } from './response-contract-property-mutations.mjs';
-import { handlerArgumentSymbols, isMutatedPropertyAccess, } from './response-contract-handler-calls.mjs';
-import { HTTP_METHODS, propertyName, routeTemplateFromExpression, unwrapTransparentExpression, visit, } from './response-contract-route-syntax.mjs';
-import { destructuredPropertyImplementationSymbol, propertyImplementationSymbol, } from './response-contract-object-symbols.mjs';
-export function collectHandlerBindings(sourceFiles, checker, ambiguousBindings) {
-    const bindingsBySymbol = new Map();
-    const attributionBindingsBySymbol = new Map();
-    const mutatedProperties = ambiguousBindings
-        ? findMutatedProperties(sourceFiles, checker)
-        : undefined;
-    const mutatedBindings = ambiguousBindings ? findMutatedBindings(sourceFiles, checker) : undefined;
-    for (const sourceFile of sourceFiles) {
-        visit(sourceFile, (node) => {
-            if (!ts.isCallExpression(node))
-                return;
-            const method = propertyName(node.expression)?.toUpperCase();
-            if (!method || !HTTP_METHODS.has(method))
-                return;
-            const routeTemplate = routeTemplateFromExpression(node.expression);
-            if (!routeTemplate)
-                return;
-            const binding = { method, routeTemplate };
-            for (const symbol of handlerArgumentSymbols(node, checker)) {
-                const resolved = resolveSymbol(symbol, checker);
-                const candidates = bindingsBySymbol.get(resolved) ?? [];
-                candidates.push(binding);
-                bindingsBySymbol.set(resolved, candidates);
-            }
-            if (ambiguousBindings) {
-                if (!potentiallyExecuted(node))
-                    return;
-                if (!isExportedRouteBuilder(node) && !executableProtocolPath(node, checker))
-                    return;
-                for (const symbol of handlerArgumentSymbols(node, checker, true, mutatedProperties)) {
-                    const propertySymbol = attributionSymbol(resolveSymbol(symbol, checker), checker);
-                    if (mutatedProperties?.has(propertySymbol))
-                        continue;
-                    const handlerSymbol = resolveHandlerSymbol(symbol, checker, mutatedProperties);
-                    const resolvedAttributionSymbol = attributionSymbol(handlerSymbol, checker);
-                    if (mutatedProperties?.has(resolvedAttributionSymbol))
-                        continue;
-                    if (mutatedBindings?.has(resolvedAttributionSymbol))
-                        continue;
-                    const attributionCandidates = attributionBindingsBySymbol.get(resolvedAttributionSymbol) ?? [];
-                    attributionCandidates.push(binding);
-                    attributionBindingsBySymbol.set(resolvedAttributionSymbol, attributionCandidates);
-                }
-            }
-        });
-    }
-    const bindings = new Map();
-    for (const [symbol, candidates] of bindingsBySymbol) {
-        const [first] = candidates;
-        const unambiguous = candidates.every((candidate) => candidate.method === first.method && candidate.routeTemplate === first.routeTemplate);
-        if (unambiguous) {
-            bindings.set(symbol, first);
-        }
-    }
-    if (ambiguousBindings) {
-        for (const [symbol, candidates] of attributionBindingsBySymbol) {
-            const [first] = candidates;
-            const unambiguous = candidates.every((candidate) => candidate.method === first.method && candidate.routeTemplate === first.routeTemplate);
-            if (!unambiguous) {
-                ambiguousBindings.set(symbol, [
-                    ...new Set(candidates.map(({ method, routeTemplate }) => `${method}:${routeTemplate}`)),
-                ].toSorted());
-            }
-        }
-    }
-    return bindings;
-}
-function isExportedRouteBuilder(node) {
-    let current = node.parent;
-    while (current) {
-        if (ts.isFunctionLike(current))
-            return (ts.isFunctionDeclaration(current) &&
-                !!(ts.getCombinedModifierFlags(current) &
-                    (ts.ModifierFlags.Export | ts.ModifierFlags.Default)));
-        current = current.parent;
-    }
-    return false;
-}
-function resolveHandlerSymbol(symbol, checker, mutatedProperties) {
-    const seen = new Set();
-    let current = resolveSymbol(symbol, checker);
-    while (!seen.has(current)) {
-        seen.add(current);
-        const declaration = current.valueDeclaration;
-        if (declaration && ts.isBindingElement(declaration)) {
-            const value = destructuredPropertyImplementationSymbol(declaration, checker);
-            if (!value)
-                return current;
-            current = resolveSymbol(value, checker);
-            continue;
-        }
-        if (declaration && ts.isShorthandPropertyAssignment(declaration)) {
-            const value = checker.getShorthandAssignmentValueSymbol(declaration);
-            if (!value)
-                return current;
-            current = resolveSymbol(value, checker);
-            continue;
-        }
-        if (!declaration || !ts.isVariableDeclaration(declaration) || !declaration.initializer)
-            return current;
-        if (!ts.isVariableDeclarationList(declaration.parent) ||
-            !(declaration.parent.flags & ts.NodeFlags.Const))
-            return current;
-        const initializer = unwrapTransparentExpression(declaration.initializer);
-        if (ts.isPropertyAccessExpression(initializer) &&
-            isMutatedPropertyAccess(initializer, checker, mutatedProperties))
-            return current;
-        const next = ts.isIdentifier(initializer)
-            ? checker.getSymbolAtLocation(initializer)
-            : ts.isPropertyAccessExpression(initializer)
-                ? propertyImplementationSymbol(initializer, checker)
-                : undefined;
-        if (!next)
-            return current;
-        current = resolveSymbol(next, checker);
-    }
-    return current;
-}

package/dist/api-contract-discovery/response-contract-handler-calls.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function handlerArgumentSymbols(node: ts.CallExpression, checker: ts.TypeChecker, unwrapArguments?: boolean, mutatedProperties?: ReadonlySet<ts.Symbol>): ts.Symbol[];
-export declare function isMutatedPropertyAccess(expression: ts.Expression, checker: ts.TypeChecker, mutatedProperties: ReadonlySet<ts.Symbol> | undefined): boolean;

package/dist/api-contract-discovery/response-contract-handler-calls.mjs

@@ -1,81 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { executableProtocolPath } from './protocol-execution-path.mjs';
-import { attributionSymbol, resolveSymbol } from './response-contract-symbols.mjs';
-import { propertyImplementationSymbol } from './response-contract-object-symbols.mjs';
-import { isInlineRouteHandler, unwrapTransparentExpression, } from './response-contract-route-syntax.mjs';
-export function handlerArgumentSymbols(node, checker, unwrapArguments = false, mutatedProperties) {
-    const symbols = [];
-    for (const originalArgument of node.arguments) {
-        const argument = unwrapArguments
-            ? unwrapTransparentExpression(originalArgument)
-            : originalArgument;
-        if (ts.isIdentifier(argument)) {
-            const symbol = checker.getSymbolAtLocation(argument);
-            if (symbol)
-                symbols.push(symbol);
-            continue;
-        }
-        if (unwrapArguments && ts.isPropertyAccessExpression(argument)) {
-            const mutatedSymbol = mutatedPropertyAccessSymbol(argument, checker, mutatedProperties);
-            if (mutatedSymbol) {
-                symbols.push(mutatedSymbol);
-                continue;
-            }
-            const symbol = propertyImplementationSymbol(argument, checker);
-            if (symbol)
-                symbols.push(symbol);
-            continue;
-        }
-        if (!isFunctionLike(argument))
-            continue;
-        visitHandlerCalls(argument, argument, checker, unwrapArguments, (child) => {
-            const callee = unwrapArguments
-                ? unwrapTransparentExpression(child.expression)
-                : child.expression;
-            const mutatedSymbol = mutatedPropertyAccessSymbol(callee, checker, mutatedProperties);
-            if (mutatedSymbol) {
-                symbols.push(mutatedSymbol);
-                return;
-            }
-            const symbol = handlerSymbol(callee, checker, unwrapArguments);
-            if (symbol)
-                symbols.push(symbol);
-        });
-    }
-    return symbols;
-}
-export function isMutatedPropertyAccess(expression, checker, mutatedProperties) {
-    return !!mutatedPropertyAccessSymbol(expression, checker, mutatedProperties);
-}
-function mutatedPropertyAccessSymbol(expression, checker, mutatedProperties) {
-    if (!mutatedProperties || !ts.isPropertyAccessExpression(expression))
-        return undefined;
-    const contextual = checker.getSymbolAtLocation(expression.name);
-    return contextual &&
-        mutatedProperties.has(attributionSymbol(resolveSymbol(contextual, checker), checker))
-        ? contextual
-        : undefined;
-}
-function handlerSymbol(expression, checker, resolvePropertyImplementation) {
-    if (resolvePropertyImplementation && ts.isPropertyAccessExpression(expression))
-        return propertyImplementationSymbol(expression, checker);
-    return checker.getSymbolAtLocation(expression);
-}
-function visitHandlerCalls(node, root, checker, attributeNestedCalls, onCall) {
-    if (node !== root && isInlineRouteHandler(node))
-        return;
-    const callee = ts.isCallExpression(node)
-        ? attributeNestedCalls
-            ? unwrapTransparentExpression(node.expression)
-            : node.expression
-        : undefined;
-    if (ts.isCallExpression(node) &&
-        !!callee &&
-        (ts.isIdentifier(callee) || (attributeNestedCalls && ts.isPropertyAccessExpression(callee))) &&
-        executableProtocolPath(node, checker, attributeNestedCalls ? root : undefined))
-        onCall(node);
-    ts.forEachChild(node, (child) => visitHandlerCalls(child, root, checker, attributeNestedCalls, onCall));
-}
-function isFunctionLike(node) {
-    return ts.isArrowFunction(node) || ts.isFunctionExpression(node);
-}