vouchington-tooling 0.34.0 → 0.36.0

package/dist/api-contract-discovery/request-validation-select.mjs

@@ -1,36 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { ABSENT, findProperty, stableConstInitializer } from './request-validation-keys.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-/** The property name or array position a destructured binding selects, when it is static. */
-export function bindingKey(element) {
-    if (element.dotDotDotToken)
-        return undefined;
-    if (ts.isArrayBindingPattern(element.parent))
-        return element.parent.elements.indexOf(element);
-    const name = element.propertyName ?? element.name;
-    return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
-}
-/**
- * The expression a literal (or a const naming one) holds at a property or position: `null` when
- * nothing is there, `undefined` when it cannot be resolved statically.
- */
-export function literalMember(node, key, scope, seen = new Set()) {
-    const value = unwrapTransparentExpression(node);
-    if (seen.has(value))
-        return undefined;
-    if (ts.isIdentifier(value)) {
-        const initializer = stableConstInitializer(value, scope.checker);
-        return initializer && literalMember(initializer, key, scope, new Set(seen).add(value));
-    }
-    if (typeof key === 'number') {
-        if (!ts.isArrayLiteralExpression(value))
-            return undefined;
-        if (value.elements.slice(0, key + 1).some(ts.isSpreadElement))
-            return undefined;
-        return value.elements[key] ?? null;
-    }
-    if (!ts.isObjectLiteralExpression(value))
-        return undefined;
-    const found = findProperty(value, key, scope.checker, scope.roots, new Set([value]));
-    return found === ABSENT ? null : found;
-}

package/dist/api-contract-discovery/request-validation-sites.d.mts

@@ -1,9 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { Scope } from './request-validation-follow.mts';
-import { type FactoryConfig, type FactorySite, type ValidatorConfig, type ValidatorSite } from './request-validation-types.mts';
-export declare function sourceOf(node: ts.Node): string;
-export declare function validatorSite(call: ts.CallExpression, config: ValidatorConfig, scope: Scope, conditional: boolean): {
-    site: ValidatorSite;
-    inputNodes: ts.Node[];
-};
-export declare function factorySite(call: ts.CallExpression, config: FactoryConfig, scope: Scope, conditional: boolean): FactorySite;

package/dist/api-contract-discovery/request-validation-sites.mjs

@@ -1,77 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { ABSENT, findProperty, resolveKey, resolveObject, resolveOptionString, } from './request-validation-keys.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-import { resolveInput } from './request-validation-input.mjs';
-import {} from './request-validation-types.mjs';
-export function sourceOf(node) {
-    const file = node.getSourceFile();
-    return `${file.fileName}:${file.getLineAndCharacterOfPosition(node.getStart()).line + 1}`;
-}
-/** Whether the options object ends with `property: true`, applying spreads in order. */
-function optionEnabled(options, property, scope) {
-    if (!options)
-        return { enabled: false };
-    const object = resolveObject(options, scope.checker, scope.roots);
-    if (!object)
-        return {
-            enabled: false,
-            unresolved: `options \`${options.getText()}\` are not statically resolvable`,
-        };
-    const found = findProperty(object, property, scope.checker, scope.roots, new Set([object]));
-    if (found === undefined)
-        return { enabled: false, unresolved: `option "${property}" is not statically resolvable` };
-    return {
-        enabled: found !== ABSENT && unwrapTransparentExpression(found).kind === ts.SyntaxKind.TrueKeyword,
-    };
-}
-function fixedInput(config, call, scope) {
-    const options = (config.optionCarriers ?? []).map((option) => ({
-        option,
-        ...optionEnabled(call.arguments[option.argument], option.property, scope),
-    }));
-    const added = options.filter((item) => item.enabled).map((item) => item.option.carrier);
-    const unresolved = options.find((item) => item.unresolved)?.unresolved;
-    return {
-        carriers: [...new Set([...config.carriers, ...added])].map((carrier) => ({
-            carrier,
-            origins: [carrier],
-        })),
-        ...(unresolved && { unresolved }),
-        nodes: [],
-    };
-}
-export function validatorSite(call, config, scope, conditional) {
-    const argument = call.arguments[config.operationArgument];
-    const operation = resolveKey(argument, scope.checker, scope.keys) ?? null;
-    const input = config.carriers.kind === 'input-object'
-        ? resolveInput(call.arguments[config.carriers.argument], scope)
-        : fixedInput(config.carriers, call, scope);
-    const site = {
-        exportName: config.exportName,
-        source: sourceOf(call),
-        operation,
-        ...(operation === null && { unresolvedReason: unresolved(argument) }),
-        carriers: input.carriers,
-        ...(input.unresolved && { unresolvedCarriers: input.unresolved }),
-        conditional,
-    };
-    return { site, inputNodes: input.nodes };
-}
-export function factorySite(call, config, scope, conditional) {
-    const operation = resolveOptionString(call.arguments[config.optionsArgument], config.operationProperty, scope.checker, scope.keys, scope.roots) ?? null;
-    return {
-        exportName: config.exportName,
-        source: sourceOf(call),
-        operation,
-        ...(operation === null && {
-            unresolvedReason: `option "${config.operationProperty}" is not statically resolvable`,
-        }),
-        carriers: [...config.carriers],
-        conditional,
-    };
-}
-function unresolved(argument) {
-    return argument
-        ? `operation key \`${argument.getText()}\` is not statically resolvable`
-        : 'operation argument is missing';
-}

package/dist/api-contract-discovery/request-validation-state-key.d.mts

@@ -1,13 +0,0 @@
-import type ts from '../contract-schema/typescript-api.mts';
-import type { KeyBindings } from './request-validation-keys.mts';
-import type { RootBindings } from './request-validation-origin.mts';
-export type WalkState = {
-    keys: KeyBindings;
-    roots: RootBindings;
-    conditional: boolean;
-    /** The calls this walk was entered through, innermost last; a call may build a validator input. */
-    via: ReadonlySet<ts.Node>;
-};
-export declare const emptyState: WalkState;
-/** A stable identity for the bindings a function is walked with, used to stop repeat walks. */
-export declare function createStateKey(): (state: WalkState) => string;

package/dist/api-contract-discovery/request-validation-state-key.mjs

@@ -1,30 +0,0 @@
-export const emptyState = {
-    keys: new Map(),
-    roots: new Map(),
-    conditional: false,
-    via: new Set(),
-};
-/** A stable identity for the bindings a function is walked with, used to stop repeat walks. */
-export function createStateKey() {
-    const symbolIds = new Map();
-    const symbolId = (symbol) => {
-        if (!symbolIds.has(symbol))
-            symbolIds.set(symbol, symbolIds.size);
-        return symbolIds.get(symbol);
-    };
-    const nodeIds = new Map();
-    const nodeId = (node) => {
-        if (!nodeIds.has(node))
-            nodeIds.set(node, nodeIds.size);
-        return nodeIds.get(node);
-    };
-    const bound = (value) => JSON.stringify(value, (name, item) => name === 'expression' ? nodeId(item) : item);
-    return (state) => [
-        ...[...state.keys].map(([symbol, value]) => JSON.stringify(['k', symbolId(symbol), value])),
-        ...[...state.roots].map(([symbol, value]) => bound(['r', symbolId(symbol), value])),
-        JSON.stringify(state.conditional),
-        JSON.stringify([...state.via].map(nodeId).toSorted((left, right) => left - right)),
-    ]
-        .toSorted((left, right) => left.localeCompare(right))
-        .join('|');
-}

package/dist/api-contract-discovery/request-validation-trace-helpers.d.mts

@@ -1,14 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ProtocolCache } from './protocol-analysis-cache.mts';
-import type { Followable } from './request-validation-follow.mts';
-/**
- * The assignments that can supply a value at the use: property writes, plus reassignments of the
- * identifier itself made earlier in the same function. An unconditional reassignment replaces
- * everything before it, including the initializer; conditional ones merge.
- */
-export declare function reachingWrites(use: ts.Node, symbol: ts.Symbol, checker: ts.TypeChecker, cache?: ProtocolCache): {
-    writes: ts.Expression[];
-    initializer: boolean;
-};
-/** Returned expressions of a function, including an arrow function's expression body. */
-export declare function returnedValues(fn: Followable): ts.Node[];

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

@@ -1,80 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { isConditionalPosition } from './request-validation-conditional.mjs';
-import { potentiallyExecuted } from './protocol-executable-path.mjs';
-const owningFunction = (node) => {
-    let current = node.parent;
-    while (current && !ts.isFunctionLike(current))
-        current = current.parent;
-    return current;
-};
-function writtenSymbol(left, checker) {
-    let current = left;
-    while (ts.isPropertyAccessExpression(current) || ts.isElementAccessExpression(current))
-        current = current.expression;
-    return ts.isIdentifier(current) ? checker.getSymbolAtLocation(current) : undefined;
-}
-/** True when the node may not run, within its function: conditional branches and `try` blocks. */
-function maybeSkipped(node) {
-    if (isConditionalPosition(node))
-        return true;
-    let child = node;
-    for (let parent = node.parent; parent && !ts.isFunctionLike(parent); parent = parent.parent) {
-        if (ts.isTryStatement(parent) && child === parent.tryBlock)
-            return true;
-        child = parent;
-    }
-    return false;
-}
-/** Plain assignments to the symbol within the scope, excluding nested functions, in source order. */
-function assignmentsTo(scope, symbol, checker, cache) {
-    let bySymbol = cache?.assignments.get(scope);
-    if (!bySymbol) {
-        const found = new Map();
-        const scan = (node) => {
-            if (node !== scope && ts.isFunctionLike(node))
-                return;
-            if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-                const written = writtenSymbol(node.left, checker);
-                const entry = { node, direct: ts.isIdentifier(node.left), start: node.getStart() };
-                if (written)
-                    found.set(written, [...(found.get(written) ?? []), entry]);
-            }
-            ts.forEachChild(node, scan);
-        };
-        scan(scope);
-        bySymbol = found;
-        cache?.assignments.set(scope, bySymbol);
-    }
-    return bySymbol.get(symbol) ?? [];
-}
-/**
- * The assignments that can supply a value at the use: property writes, plus reassignments of the
- * identifier itself made earlier in the same function. An unconditional reassignment replaces
- * everything before it, including the initializer; conditional ones merge.
- */
-export function reachingWrites(use, symbol, checker, cache) {
-    const scope = owningFunction(use) ?? use.getSourceFile();
-    const before = use.getStart();
-    const entries = assignmentsTo(scope, symbol, checker, cache).filter((entry) => entry.start < before &&
-        (!entry.direct || entry.node.getEnd() <= before) &&
-        potentiallyExecuted(entry.node));
-    const killer = entries.findLast((entry) => entry.direct && !maybeSkipped(entry.node));
-    const kept = entries.filter((entry) => !entry.direct || !killer || entries.indexOf(entry) >= entries.indexOf(killer));
-    return { writes: kept.map((entry) => entry.node.right), initializer: !killer };
-}
-/** Returned expressions of a function, including an arrow function's expression body. */
-export function returnedValues(fn) {
-    const body = fn.body;
-    if (!ts.isBlock(body))
-        return [body];
-    const values = [];
-    const scan = (node) => {
-        if (ts.isFunctionLike(node))
-            return;
-        if (ts.isReturnStatement(node) && node.expression && potentiallyExecuted(node.expression))
-            values.push(node.expression);
-        ts.forEachChild(node, scan);
-    };
-    ts.forEachChild(body, scan);
-    return values;
-}

package/dist/api-contract-discovery/request-validation-trace-select.d.mts

@@ -1,23 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type Scope } from './request-validation-follow.mts';
-import type { Carrier } from './request-validation-types.mts';
-/** The request carriers a value derives from, and why part of it could not be traced. */
-export type Trace = {
-    origins: Set<Carrier>;
-    unresolved?: string | undefined;
-};
-export type Visit = {
-    trace: Trace;
-    seen: Set<ts.Node>;
-    functions: Set<ts.Node>;
-    /** Calls whose arguments are being traced, so a value that feeds its own call terminates. */
-    calls: Set<ts.Node>;
-};
-/** The tracer's own entry points, passed in so this module does not import it back. */
-type Deps = {
-    visitValue: (node: ts.Node, scope: Scope, visit: Visit) => void;
-    bindArguments: (fn: ts.FunctionLikeDeclaration, call: ts.CallExpression, scope: Scope, calls: Set<ts.Node>) => Scope;
-};
-/** Traces only what a destructured local binds; false when the selection cannot be resolved. */
-export declare function visitSelected(element: ts.BindingElement, initializer: ts.Expression, scope: Scope, visit: Visit, deps: Deps): boolean;
-export {};

package/dist/api-contract-discovery/request-validation-trace-select.mjs

@@ -1,45 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { followedImplementations } from './request-validation-follow.mjs';
-import { bindingKey, literalMember } from './request-validation-select.mjs';
-import { returnedValues } from './request-validation-trace-helpers.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-/** Traces only what a destructured local binds; false when the selection cannot be resolved. */
-export function visitSelected(element, initializer, scope, visit, deps) {
-    const key = bindingKey(element);
-    const selected = { ...visit, trace: { origins: new Set() } };
-    if (key === undefined || !visitMember(initializer, key, scope, selected, deps))
-        return false;
-    if (element.initializer)
-        deps.visitValue(element.initializer, scope, selected);
-    selected.trace.origins.forEach((origin) => visit.trace.origins.add(origin));
-    visit.trace.unresolved ??= selected.trace.unresolved;
-    return true;
-}
-/** Visits one member of a literal, a const naming one, or a followed helper's returned value. */
-function visitMember(node, key, scope, visit, deps) {
-    const value = unwrapTransparentExpression(node);
-    if (ts.isAwaitExpression(value))
-        return visitMember(value.expression, key, scope, visit, deps);
-    const literal = literalMember(value, key, scope);
-    if (literal !== undefined) {
-        if (literal)
-            deps.visitValue(literal, scope, visit);
-        return true;
-    }
-    if (!ts.isCallExpression(value) || visit.calls.has(value))
-        return false;
-    const followed = followedImplementations(value, scope);
-    return (followed.length > 0 &&
-        followed.every((fn) => {
-            if (visit.functions.has(fn))
-                return false;
-            const next = {
-                ...visit,
-                seen: new Set(),
-                functions: new Set(visit.functions).add(fn),
-                calls: new Set(visit.calls).add(value),
-            };
-            const bound = deps.bindArguments(fn, value, scope, next.calls);
-            return returnedValues(fn).every((returned) => visitMember(returned, key, bound, next, deps));
-        }));
-}

package/dist/api-contract-discovery/request-validation-trace.d.mts

@@ -1,8 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type Scope } from './request-validation-follow.mts';
-import { type Trace } from './request-validation-trace-select.mts';
-export type { Trace };
-/** Binds a followed function's parameters to what the call passes, with their origins. */
-export declare function bindArguments(fn: ts.FunctionLikeDeclaration, call: ts.CallExpression, scope: Scope, calls?: Set<ts.Node>): Scope;
-/** Unions the request origins found anywhere in a value expression. */
-export declare function traceValue(node: ts.Node, scope: Scope, calls?: Set<ts.Node>): Trace;

package/dist/api-contract-discovery/request-validation-trace.mjs

@@ -1,130 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { followedImplementations } from './request-validation-follow.mjs';
-import { reachingWrites, returnedValues } from './request-validation-trace-helpers.mjs';
-import { identifierSymbol, resolveKey } from './request-validation-keys.mjs';
-import { rootKind } from './request-validation-origin.mjs';
-import { visitSelected } from './request-validation-trace-select.mjs';
-import { requestOrigin } from './request-validation-request-origin.mjs';
-import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
-/** Binds a followed function's parameters to what the call passes, with their origins. */
-export function bindArguments(fn, call, scope, calls = new Set()) {
-    const keys = new Map(scope.keys);
-    const roots = new Map(scope.roots);
-    runtimeParameters(fn).forEach((parameter, index) => {
-        const symbol = ts.isIdentifier(parameter.name)
-            ? scope.checker.getSymbolAtLocation(parameter.name)
-            : undefined;
-        if (!symbol)
-            return;
-        keys.delete(symbol);
-        roots.delete(symbol);
-        const argument = call.arguments[index];
-        const key = resolveKey(argument, scope.checker, scope.keys);
-        if (key !== undefined)
-            keys.set(symbol, key);
-        const bound = boundValue(parameter, argument, scope, calls);
-        if (bound)
-            roots.set(symbol, bound);
-    });
-    return { ...scope, keys, roots };
-}
-function boundValue(parameter, argument, scope, calls) {
-    // An omitted optional or defaulted parameter is not request-derived: it stays resolved.
-    if (!argument)
-        return parameter.questionToken || parameter.initializer ? { origins: [] } : undefined;
-    const traced = traceValue(argument, scope, calls);
-    return {
-        kind: rootKind(argument, scope.roots, scope.checker),
-        origins: [...traced.origins],
-        unresolved: traced.unresolved,
-        expression: argument,
-    };
-}
-function visitIdentifier(identifier, scope, visit) {
-    const { seen } = visit;
-    const symbol = identifierSymbol(identifier, scope.checker);
-    if (!symbol || seen.has(identifier))
-        return;
-    seen.add(identifier);
-    const { writes, initializer } = reachingWrites(identifier, symbol, scope.checker, scope.cache);
-    if (initializer)
-        visitDeclared(identifier, symbol, scope, visit);
-    for (const write of writes)
-        visitValue(write, scope, visit);
-}
-/** The value a binding starts with: a call-site binding, a parameter, or its initializer. */
-function visitDeclared(identifier, symbol, scope, visit) {
-    const { trace } = visit;
-    const bound = scope.roots.get(symbol);
-    if (bound) {
-        bound.origins.forEach((origin) => trace.origins.add(origin));
-        trace.unresolved ??= bound.unresolved;
-        return;
-    }
-    for (const declaration of symbol.declarations ?? []) {
-        if (ts.isParameter(declaration)) {
-            if (!scope.keys.has(symbol))
-                trace.unresolved ??= `parameter \`${identifier.text}\` has no call-site binding`;
-            continue;
-        }
-        const owner = ts.isBindingElement(declaration) ? declaration.parent.parent : declaration;
-        if (ts.isVariableDeclaration(owner) && owner.initializer) {
-            if (!ts.isBindingElement(declaration) ||
-                !visitSelected(declaration, owner.initializer, scope, visit, { visitValue, bindArguments }))
-                visitValue(owner.initializer, scope, visit);
-        }
-        // `for (const [key, value] of Object.entries(x))` derives from the iterated expression.
-        else if (ts.isVariableDeclaration(owner) && ts.isForOfStatement(owner.parent.parent))
-            visitValue(owner.parent.parent.expression, scope, visit);
-    }
-}
-function visitCall(call, scope, visit) {
-    if (visit.calls.has(call))
-        return;
-    const followed = followedImplementations(call, scope);
-    for (const fn of followed) {
-        if (visit.functions.has(fn))
-            continue;
-        const next = {
-            ...visit,
-            seen: new Set(),
-            functions: new Set(visit.functions).add(fn),
-            calls: new Set(visit.calls).add(call),
-        };
-        const bound = bindArguments(fn, call, scope, next.calls);
-        for (const value of returnedValues(fn))
-            visitValue(value, bound, next);
-    }
-    // An opaque call may use any argument; a followed helper's return values already say which.
-    if (followed.length === 0)
-        ts.forEachChild(call, (child) => visitValue(child, scope, visit));
-}
-function visitValue(node, scope, visit) {
-    const { checker, roots } = scope;
-    const { trace } = visit;
-    if (ts.isFunctionLike(node))
-        return;
-    const origin = requestOrigin(node, roots, checker);
-    if (origin)
-        trace.origins.add(origin);
-    else if (ts.isCallExpression(node))
-        visitCall(node, scope, visit);
-    else if (ts.isConditionalExpression(node)) {
-        visitValue(node.whenTrue, scope, visit);
-        visitValue(node.whenFalse, scope, visit);
-    }
-    else if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node))
-        visitValue(node.expression, scope, visit);
-    else if (ts.isPropertyAssignment(node))
-        visitValue(node.initializer, scope, visit);
-    else if (ts.isIdentifier(node))
-        visitIdentifier(node, scope, visit);
-    else
-        ts.forEachChild(node, (child) => visitValue(child, scope, visit));
-}
-/** Unions the request origins found anywhere in a value expression. */
-export function traceValue(node, scope, calls = new Set()) {
-    const trace = { origins: new Set() };
-    visitValue(node, scope, { trace, seen: new Set(), functions: new Set(), calls });
-    return trace;
-}

package/dist/api-contract-discovery/request-validation-types.d.mts

@@ -1,84 +0,0 @@
-import type { RegisteredRoute } from './registered-route-catalog.mts';
-export type Carrier = 'path' | 'query' | 'body' | 'header';
-export declare const CARRIERS: readonly Carrier[];
-export type ValidatorConfig = {
-    /** Resolved declaration file path suffix, or a package specifier, of the export. */
-    module: string;
-    exportName: string;
-    operationArgument: number;
-    carriers: {
-        kind: 'input-object';
-        argument: number;
-    } | {
-        kind: 'fixed';
-        carriers: readonly Carrier[];
-        optionCarriers?: readonly {
-            argument: number;
-            property: string;
-            carrier: Carrier;
-        }[];
-    };
-};
-export type FactoryConfig = {
-    module: string;
-    exportName: string;
-    optionsArgument: number;
-    operationProperty: string;
-    carriers: readonly Carrier[];
-};
-/** A validated carrier and the request carriers its value derives from. */
-export type ValidatorSiteCarrier = {
-    carrier: Carrier;
-    origins: Carrier[];
-    /** Set when part of the value cannot be traced, such as an unbound parameter. */
-    unresolved?: string;
-};
-export type ExecutedCallbackConfig = {
-    module: string;
-    exportName: string;
-    /** Index of the object-literal argument. */
-    argument: number;
-    /** Function-valued properties of that object treated as executed. */
-    properties: readonly string[];
-};
-export type ValidatorSite = {
-    exportName: string;
-    source: string;
-    operation: string | null;
-    unresolvedReason?: string;
-    carriers: ValidatorSiteCarrier[];
-    /**
-     * Set when the input object cannot be fully resolved (a non-literal input, an unresolvable
-     * spread or a computed property name), so `carriers` may be incomplete.
-     */
-    unresolvedCarriers?: string;
-    conditional: boolean;
-};
-export type FactorySite = {
-    exportName: string;
-    source: string;
-    operation: string | null;
-    unresolvedReason?: string;
-    carriers: Carrier[];
-    /** True when the factory call is reached only under a branch, loop or short-circuit. */
-    conditional: boolean;
-};
-/**
- * `key` for a static key, `computed` for a non-static key (`key: null`), `whole` for the carrier
- * used as a value or a body read (`key: null`).
- */
-type CarrierReadAccess = 'key' | 'computed' | 'whole';
-export type CarrierRead = {
-    carrier: Carrier;
-    key: string | null;
-    access: CarrierReadAccess;
-    source: string;
-};
-export type RouteValidationFacts = {
-    kind: RegisteredRoute['kind'];
-    source: string;
-    validatorSites: ValidatorSite[];
-    factorySites: FactorySite[];
-    carrierReads: CarrierRead[];
-};
-export {};

package/dist/api-contract-discovery/request-validation-types.mjs

@@ -1 +0,0 @@
-export const CARRIERS = ['path', 'query', 'body', 'header'];

package/dist/api-contract-discovery/request-validation-walker.d.mts

@@ -1,26 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ProtocolCache } from './protocol-analysis-cache.mts';
-import type { HandlerProof } from './registered-route-handler-analysis.mts';
-import type { CarrierRead, ExecutedCallbackConfig, FactoryConfig, FactorySite, ValidatorConfig, ValidatorSite } from './request-validation-types.mts';
-type RouteFacts = {
-    validatorSites: ValidatorSite[];
-    factorySites: FactorySite[];
-    carrierReads: CarrierRead[];
-};
-export type WalkerConfig = {
-    checker: ts.TypeChecker;
-    sourceFiles: ReadonlySet<ts.SourceFile>;
-    validators: readonly ValidatorConfig[];
-    factories: readonly FactoryConfig[];
-    executedCallbacks: readonly ExecutedCallbackConfig[];
-    /** Shared across the routes of one facts run. */
-    protocolCache?: ProtocolCache;
-};
-/** Walks handlers and the helpers they run, collecting validation facts for one route. */
-export declare function createRouteWalker(config: WalkerConfig): {
-    /** The collected facts; reads that only build a validator's input are left out. */
-    readonly facts: RouteFacts;
-    scanRegistration: (node: ts.Node) => void;
-    walkHandler(proof: HandlerProof): void;
-};
-export {};