vouchington-tooling 0.35.0 → 0.36.1

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 {};

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

@@ -1,143 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { handlerBindings } from './request-validation-handler-state.mjs';
-import { httpContextInvocations } from './protocol-http-context-callers.mjs';
-import { potentiallyExecuted } from './protocol-executable-path.mjs';
-import { executedCallbackFunctions, invokedUnconditionally, } from './request-validation-callbacks.mjs';
-import { isConditionalPosition } from './request-validation-conditional.mjs';
-import { followedImplementations, inlineFunction, } from './request-validation-follow.mjs';
-import { calledFactory } from './request-validation-factory-calls.mjs';
-import { findConfig } from './request-validation-match.mjs';
-import { rawReadsAt } from './request-validation-reads.mjs';
-import { factorySite, sourceOf, validatorSite } from './request-validation-sites.mjs';
-import { createReporter } from './request-validation-report.mjs';
-import { createRegistrationScanner } from './request-validation-registration.mjs';
-import { createStateKey, emptyState, } from './request-validation-state-key.mjs';
-import { bindArguments } from './request-validation-trace.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-/** Walks handlers and the helpers they run, collecting validation facts for one route. */
-export function createRouteWalker(config) {
-    const { checker, sourceFiles, validators, factories, executedCallbacks, protocolCache } = config;
-    const configured = [...validators, ...factories, ...executedCallbacks];
-    const facts = { validatorSites: [], factorySites: [], carrierReads: [] };
-    const report = createReporter();
-    const visited = new Map();
-    const scopeOf = (state) => ({
-        checker,
-        sourceFiles,
-        configured,
-        roots: state.roots,
-        keys: state.keys,
-        cache: protocolCache,
-    });
-    const stateKey = createStateKey();
-    const inputs = new Set();
-    const pendingReads = [];
-    const isInput = (node) => {
-        for (let current = node; current; current = current.parent)
-            if (inputs.has(current))
-                return true;
-        return false;
-    };
-    function walkFunction(fn, state) {
-        const seen = visited.get(fn) ?? new Set();
-        const key = stateKey(state);
-        if (seen.has(key))
-            return;
-        visited.set(fn, seen.add(key));
-        walk(fn.body, state);
-    }
-    /** Records a configured validator call; its input arguments are not raw reads. */
-    function reportValidator(call, state) {
-        const validator = findConfig(call.expression, validators, checker);
-        if (!validator)
-            return false;
-        const { site, inputNodes } = validatorSite(call, validator, scopeOf(state), state.conditional || isConditionalPosition(call));
-        inputNodes.forEach((node) => inputs.add(node));
-        const { conditional, ...identity } = site;
-        // A site reached both conditionally and unconditionally is unconditional.
-        report('validator', facts.validatorSites, site, call, identity).conditional &&= conditional;
-        return true;
-    }
-    /** Records a factory site once per call node; one reached both ways is unconditional. */
-    function recordFactory(call, factory, state, conditional) {
-        const site = factorySite(call, factory, scopeOf(state), conditional);
-        const { conditional: merged, ...identity } = site;
-        report('factory', facts.factorySites, site, call, identity).conditional &&= merged;
-    }
-    /** Records a configured factory call whose returned handler is a registration-time value. */
-    function reportFactory(call, state) {
-        const factory = findConfig(call.expression, factories, checker);
-        if (!factory)
-            return false;
-        recordFactory(call, factory, state, state.conditional || isConditionalPosition(call));
-        return true;
-    }
-    function visitCall(call, state) {
-        const conditional = state.conditional || isConditionalPosition(call);
-        // A handler built by a configured factory at module level and invoked here.
-        const built = calledFactory(call, factories, checker);
-        if (built)
-            recordFactory(built.call, built.config, emptyState, conditional);
-        const inline = inlineFunction(unwrapTransparentExpression(call.expression));
-        const callee = inline?.asteriskToken ? undefined : inline;
-        const via = new Set(state.via).add(call);
-        const runners = new Set(callee ? [callee] : []);
-        if (callee) {
-            const { keys, roots } = bindArguments(callee, call, scopeOf(state));
-            walkFunction(callee, { keys, roots, conditional, via });
-        }
-        for (const implementation of followedImplementations(call, scopeOf(state))) {
-            const { keys, roots } = bindArguments(implementation, call, scopeOf(state));
-            runners.add(implementation);
-            walkFunction(implementation, { keys, roots, conditional, via });
-        }
-        // Listed callbacks of a configured host take only the call's own condition.
-        for (const callback of executedCallbackFunctions(call, executedCallbacks, checker))
-            walkFunction(callback, { ...state, conditional });
-        for (const argument of call.arguments) {
-            const callback = unwrapTransparentExpression(argument);
-            if (!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback))
-                continue;
-            const { callers } = httpContextInvocations(callback, checker, protocolCache);
-            // A helper that runs the callback under its own condition makes the sites conditional.
-            if (callers.length > 0)
-                walkFunction(callback, {
-                    ...state,
-                    conditional: conditional || !invokedUnconditionally(callers, runners),
-                });
-        }
-    }
-    function walk(node, state) {
-        if (!potentiallyExecuted(node))
-            return;
-        if (ts.isCallExpression(node))
-            reportValidator(node, state);
-        for (const read of rawReadsAt(node, scopeOf(state)))
-            pendingReads.push({ node, read: { ...read, source: sourceOf(node) }, via: state.via });
-        if (ts.isCallExpression(node))
-            visitCall(node, state);
-        ts.forEachChild(node, (child) => {
-            if (!ts.isFunctionLike(child))
-                walk(child, state);
-        });
-    }
-    const scanRegistration = createRegistrationScanner(scopeOf, reportFactory);
-    return {
-        /** The collected facts; reads that only build a validator's input are left out. */
-        get facts() {
-            for (const { node, read, via } of pendingReads)
-                if (!isInput(node) && ![...via].some(isInput))
-                    report('read', facts.carrierReads, read);
-            pendingReads.length = 0;
-            return facts;
-        },
-        scanRegistration: (node) => scanRegistration(node),
-        walkHandler(proof) {
-            walkFunction(proof.node, {
-                ...handlerBindings(proof, checker),
-                conditional: proof.conditional ?? false,
-                via: emptyState.via,
-            });
-        },
-    };
-}

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

@@ -1,39 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ExecutedCallbackConfig, FactoryConfig, ValidatorConfig } from './request-validation-types.mts';
-/** Synthetic library modules shared by the request-validation fixtures. */
-export declare const librarySources: {
-    readonly '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
-    }
-  `;
-    readonly '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
-      }
-    }
-  `;
-    readonly 'lib/reexport.ts': `export { validateInput as checkInput } from './validation'`;
-    readonly 'lib/keys.ts': `export const LIST_KEY = 'GET:/api/items'`;
-};
-export declare const validators: readonly ValidatorConfig[];
-/** Builds a program whose files can import each other, relatively or through `@lib/*`. */
-export declare function buildModuleProgram(files: Readonly<Record<string, string>>): {
-    program: ts.Program;
-    sourceFile(path: string): ts.SourceFile;
-};
-export type ModuleProgram = ReturnType<typeof buildModuleProgram>;
-/** Runs discovery over the given files with the shared configuration. */
-export declare function discover(built: ModuleProgram, paths: readonly string[], overrides?: {
-    validators?: readonly ValidatorConfig[];
-    factories?: readonly FactoryConfig[];
-    executedCallbacks?: readonly ExecutedCallbackConfig[];
-}): Record<string, import("./request-validation-types.mts").RouteValidationFacts>;