vouchington-tooling 0.34.0 → 0.36.0

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

@@ -1,43 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { propertyNameText, resolveObject } from './request-validation-keys.mjs';
-import { traceValue } from './request-validation-trace.mjs';
-import { CARRIERS } from './request-validation-types.mjs';
-/** Applies the object's properties in order, so later properties and spreads win. */
-function collect(object, scope, found, seen) {
-    found.nodes.push(object);
-    for (const property of object.properties) {
-        if (ts.isSpreadAssignment(property)) {
-            const spread = resolveObject(property.expression, scope.checker, scope.roots);
-            if (spread && !seen.has(spread))
-                collect(spread, scope, found, new Set(seen).add(spread));
-            else
-                found.unresolved ??= `spread \`${property.expression.getText()}\` is not statically resolvable`;
-        }
-        else if (property.name && ts.isComputedPropertyName(property.name)) {
-            found.unresolved ??= 'a computed property name is not statically resolvable';
-        }
-        else if (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) {
-            const carrier = CARRIERS.find((item) => item === propertyNameText(property.name));
-            if (carrier)
-                found.entries.set(carrier, ts.isPropertyAssignment(property) ? property.initializer : property.name);
-        }
-    }
-}
-/** Resolves the object a validator receives as input, through const objects and spreads. */
-export function resolveInput(input, scope) {
-    const found = { entries: new Map(), nodes: input ? [input] : [] };
-    const object = resolveObject(input, scope.checker, scope.roots);
-    if (object)
-        collect(object, scope, found, new Set([object]));
-    else if (input)
-        found.unresolved = `input \`${input.getText()}\` is not statically resolvable`;
-    const carriers = [...found.entries].map(([carrier, value]) => {
-        const { origins, unresolved } = traceValue(value, scope);
-        return {
-            carrier,
-            origins: CARRIERS.filter((candidate) => origins.has(candidate)),
-            ...(unresolved && { unresolved }),
-        };
-    });
-    return { carriers, ...(found.unresolved && { unresolved: found.unresolved }), nodes: found.nodes };
-}

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

@@ -1,25 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/** Static string values bound to helper or factory parameters. */
-export type KeyBindings = ReadonlyMap<ts.Symbol, string>;
-/** A property name written as an identifier or string literal; computed names are `undefined`. */
-export declare const propertyNameText: (name: ts.PropertyName | undefined) => string | undefined;
-/** The variable symbol an identifier reads, including a shorthand property's value. */
-export declare function identifierSymbol(identifier: ts.Identifier, checker: ts.TypeChecker): ts.Symbol | undefined;
-/** The const initializer an identifier names, unless a property of it is written before the use. */
-export declare function stableConstInitializer(identifier: ts.Identifier, checker: ts.TypeChecker): ts.Expression | undefined;
-/** Resolves string literals, templates, const identifiers and bound parameters, else `undefined`. */
-export declare function resolveKey(expression: ts.Expression | undefined, checker: ts.TypeChecker, bindings: KeyBindings, seen?: Set<ts.Node>): string | undefined;
-/** Call-site bindings of parameters; an `expression` is the argument the call passes. */
-export type ParamBindings = ReadonlyMap<ts.Symbol, {
-    expression?: ts.Expression | undefined;
-}>;
-/** The object literal an expression denotes, through const identifiers and bound parameters. */
-export declare function resolveObject(expression: ts.Expression | undefined, checker: ts.TypeChecker, params?: ParamBindings, seen?: Set<ts.Node>): ts.ObjectLiteralExpression | undefined;
-export declare const ABSENT: unique symbol;
-/** `undefined` means the property cannot be statically resolved. */
-type Found = ts.Expression | undefined | typeof ABSENT;
-/** The value expression a property ends with, applying properties and spreads in order. */
-export declare function findProperty(object: ts.ObjectLiteralExpression, name: string, checker: ts.TypeChecker, params: ParamBindings, seen: Set<ts.Node>): Found;
-/** Resolves a string property of an options object, including from spread const objects. */
-export declare function resolveOptionString(expression: ts.Expression | undefined, name: string, checker: ts.TypeChecker, bindings: KeyBindings, params?: ParamBindings): string | undefined;
-export {};

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

@@ -1,119 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-import { resolveSymbol } from './response-contract-symbols.mjs';
-import { hasPropertyWriteBefore } from './request-validation-mutation.mjs';
-import { reachingWrites } from './request-validation-trace-helpers.mjs';
-const isConst = (declaration) => !!(ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.Const);
-/** A property name written as an identifier or string literal; computed names are `undefined`. */
-export const propertyNameText = (name) => name && (ts.isIdentifier(name) || ts.isStringLiteral(name)) ? name.text : undefined;
-/** The variable symbol an identifier reads, including a shorthand property's value. */
-export function identifierSymbol(identifier, checker) {
-    return ts.isShorthandPropertyAssignment(identifier.parent)
-        ? checker.getShorthandAssignmentValueSymbol(identifier.parent)
-        : checker.getSymbolAtLocation(identifier);
-}
-/** The initializer of the const variable an identifier names, through imports and aliases. */
-function constInitializer(identifier, checker) {
-    const symbol = identifierSymbol(identifier, checker);
-    const declaration = symbol && resolveSymbol(symbol, checker).declarations?.find(ts.isVariableDeclaration);
-    return declaration?.initializer && isConst(declaration) ? declaration.initializer : undefined;
-}
-/** The const initializer an identifier names, unless a property of it is written before the use. */
-export function stableConstInitializer(identifier, checker) {
-    const initializer = constInitializer(identifier, checker);
-    const symbol = identifierSymbol(identifier, checker);
-    return initializer && !hasPropertyWriteBefore(identifier, symbol, checker)
-        ? initializer
-        : undefined;
-}
-/** Folds a template literal whose every substitution resolves to a static string. */
-function resolveTemplate(template, checker, bindings, seen) {
-    let text = template.head.text;
-    for (const span of template.templateSpans) {
-        const part = resolveKey(span.expression, checker, bindings, seen);
-        if (part === undefined)
-            return undefined;
-        text += part + span.literal.text;
-    }
-    return text;
-}
-/** A bound key unless the helper reassigns the parameter: then only a lone reaching write counts. */
-function reassignedKey(identifier, symbol, bound, checker, bindings, seen) {
-    const { writes, initializer } = reachingWrites(identifier, symbol, checker);
-    if (writes.length === 0)
-        return bound;
-    const [write] = writes;
-    if (writes.length > 1 || initializer)
-        return undefined;
-    return resolveKey(write, checker, bindings, seen);
-}
-/** Resolves string literals, templates, const identifiers and bound parameters, else `undefined`. */
-export function resolveKey(expression, checker, bindings, seen = new Set()) {
-    if (!expression)
-        return undefined;
-    const value = unwrapTransparentExpression(expression);
-    if (ts.isStringLiteralLike(value))
-        return value.text;
-    if (ts.isTemplateExpression(value))
-        return resolveTemplate(value, checker, bindings, seen);
-    if (!ts.isIdentifier(value))
-        return undefined;
-    const symbol = identifierSymbol(value, checker);
-    const bound = symbol && bindings.get(symbol);
-    if (symbol && bound !== undefined)
-        return reassignedKey(value, symbol, bound, checker, bindings, seen);
-    const initializer = constInitializer(value, checker);
-    if (!initializer || seen.has(initializer))
-        return undefined;
-    return resolveKey(initializer, checker, bindings, new Set(seen).add(initializer));
-}
-const NO_PARAMS = new Map();
-/** The argument bound to a parameter, unless the helper reassigns the parameter first. */
-function boundArgument(identifier, checker, params) {
-    const symbol = identifierSymbol(identifier, checker);
-    const expression = symbol && params.get(symbol)?.expression;
-    if (!symbol || !expression)
-        return undefined;
-    return reachingWrites(identifier, symbol, checker).writes.length > 0 ? undefined : expression;
-}
-/** The object literal an expression denotes, through const identifiers and bound parameters. */
-export function resolveObject(expression, checker, params = NO_PARAMS, seen = new Set()) {
-    if (!expression || seen.has(expression))
-        return undefined;
-    const value = unwrapTransparentExpression(expression);
-    if (ts.isObjectLiteralExpression(value))
-        return value;
-    if (!ts.isIdentifier(value))
-        return undefined;
-    const next = boundArgument(value, checker, params) ?? stableConstInitializer(value, checker);
-    return resolveObject(next, checker, params, new Set(seen).add(expression));
-}
-export const ABSENT = Symbol('absent');
-/** The value expression a property ends with, applying properties and spreads in order. */
-export function findProperty(object, name, checker, params, seen) {
-    for (const property of object.properties.toReversed()) {
-        if (ts.isSpreadAssignment(property)) {
-            const spread = resolveObject(property.expression, checker, params);
-            const found = spread && !seen.has(spread)
-                ? findProperty(spread, name, checker, params, new Set(seen).add(spread))
-                : undefined;
-            if (found !== ABSENT)
-                return found;
-        }
-        else if (ts.isComputedPropertyName(property.name)) {
-            return undefined;
-        }
-        else if ((ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
-            propertyNameText(property.name) === name)
-            return ts.isPropertyAssignment(property) ? property.initializer : property.name;
-    }
-    return ABSENT;
-}
-/** Resolves a string property of an options object, including from spread const objects. */
-export function resolveOptionString(expression, name, checker, bindings, params = NO_PARAMS) {
-    const object = resolveObject(expression, checker, params);
-    if (!object)
-        return undefined;
-    const found = findProperty(object, name, checker, params, new Set([object]));
-    return found === ABSENT ? undefined : resolveKey(found, checker, bindings);
-}

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

@@ -1,11 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-type ExportRef = {
-    module: string;
-    exportName: string;
-};
-/** Resolves a callee through aliases and re-exports to the symbol it ultimately names. */
-export declare function calleeSymbol(callee: ts.Expression, checker: ts.TypeChecker): ts.Symbol | undefined;
-export declare function findConfig<T extends ExportRef>(callee: ts.Expression, configs: readonly T[], checker: ts.TypeChecker): T | undefined;
-/** True when the node sits inside the implementation of a configured export. */
-export declare function insideConfiguredImplementation(node: ts.Node, configs: readonly ExportRef[], checker: ts.TypeChecker): boolean;
-export {};

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

@@ -1,47 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-import { attributionFunctionSymbol, resolveSymbol } from './response-contract-symbols.mjs';
-/** Resolves a callee through aliases and re-exports to the symbol it ultimately names. */
-export function calleeSymbol(callee, checker) {
-    const target = unwrapTransparentExpression(callee);
-    const name = ts.isPropertyAccessExpression(target) ? target.name : target;
-    const symbol = ts.isIdentifier(name) ? checker.getSymbolAtLocation(name) : undefined;
-    return symbol && resolveSymbol(symbol, checker);
-}
-const stripExtension = (path) => path.replace(/\.d\.[cm]?ts$/, '').replace(/\.[cm]?[jt]sx?$/, '');
-/** Compares extension-less paths, so `.ts`, `.js`, `.mts` and `.d.ts` spellings all agree. */
-function moduleMatches(fileName, module) {
-    const path = fileName.replaceAll('\\', '/');
-    return (path.includes(`/node_modules/${module}/`) ||
-        stripExtension(path).endsWith(`/${stripExtension(module.replace(/^\.?\//, ''))}`));
-}
-/** True when the symbol is the configured export of a declaration file matching the module. */
-function matchesExport(symbol, config, checker) {
-    return (symbol.declarations ?? []).some((declaration) => {
-        const file = declaration.getSourceFile();
-        if (!moduleMatches(file.fileName, config.module))
-            return false;
-        const moduleSymbol = checker.getSymbolAtLocation(file);
-        const exported = moduleSymbol
-            ? checker
-                .getExportsOfModule(moduleSymbol)
-                .find((item) => item.getName() === config.exportName)
-            : undefined;
-        return !!exported && resolveSymbol(exported, checker) === symbol;
-    });
-}
-export function findConfig(callee, configs, checker) {
-    const symbol = calleeSymbol(callee, checker);
-    return symbol ? configs.find((config) => matchesExport(symbol, config, checker)) : undefined;
-}
-/** True when the node sits inside the implementation of a configured export. */
-export function insideConfiguredImplementation(node, configs, checker) {
-    for (let current = node; current; current = current.parent) {
-        const symbol = ts.isFunctionLike(current)
-            ? attributionFunctionSymbol(current, checker)
-            : undefined;
-        if (symbol && configs.some((config) => matchesExport(symbol, config, checker)))
-            return true;
-    }
-    return false;
-}

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

@@ -1,7 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/**
- * True when a property of the const object an identifier names may have been written before the
- * use: in the use's own function, or anywhere in the declaring function or module when that
- * differs. `const` fixes the binding, not the object, so a written object is not its initializer.
- */
-export declare function hasPropertyWriteBefore(identifier: ts.Identifier, symbol: ts.Symbol, checker: ts.TypeChecker): boolean;

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

@@ -1,80 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-import { resolveSymbol } from './response-contract-symbols.mjs';
-const MUTATORS = new Set(['assign', 'defineProperty', 'defineProperties', 'setPrototypeOf']);
-const UPDATES = new Set([ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken]);
-/**
- * Property-write start positions per symbol, per function (or source file). Symbols belong to one
- * checker, so the memo is keyed by checker and never leaks between programs.
- */
-const writesByChecker = new WeakMap();
-const isMember = (node) => ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node);
-/** The identifier an `a.b[c]` chain starts from, through parentheses, `!` and `as`. */
-function rootIdentifier(target) {
-    let current = unwrapTransparentExpression(target);
-    while (isMember(current))
-        current = unwrapTransparentExpression(current.expression);
-    return ts.isIdentifier(current) ? current : undefined;
-}
-/** The object a node writes a property of: `o.p = v`, `delete o.p`, `o.p++`, `Object.assign(o)`. */
-function mutatedObject(node) {
-    let target;
-    if (ts.isBinaryExpression(node) &&
-        node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
-        node.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
-        target = node.left;
-    else if (ts.isDeleteExpression(node))
-        target = node.expression;
-    else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
-        UPDATES.has(node.operator))
-        target = node.operand;
-    if (target)
-        return isMember(target) ? rootIdentifier(target) : undefined;
-    const callee = ts.isCallExpression(node) ? node.expression : undefined;
-    const mutates = callee &&
-        ts.isPropertyAccessExpression(callee) &&
-        ts.isIdentifier(callee.expression) &&
-        callee.expression.text === 'Object' &&
-        MUTATORS.has(callee.name.text);
-    const [first] = mutates ? node.arguments : [];
-    return first ? rootIdentifier(first) : undefined;
-}
-function propertyWrites(scope, checker) {
-    const scopes = writesByChecker.get(checker) ?? new WeakMap();
-    writesByChecker.set(checker, scopes);
-    const cached = scopes.get(scope);
-    if (cached)
-        return cached;
-    const found = new Map();
-    const scan = (node) => {
-        if (node !== scope && ts.isFunctionLike(node))
-            return;
-        const object = mutatedObject(node);
-        const symbol = object && checker.getSymbolAtLocation(object);
-        if (symbol)
-            found.set(symbol, [...(found.get(symbol) ?? []), node.getStart()]);
-        ts.forEachChild(node, scan);
-    };
-    scan(scope);
-    scopes.set(scope, found);
-    return found;
-}
-function ownerOf(node) {
-    let current = node.parent;
-    while (current && !ts.isFunctionLike(current))
-        current = current.parent;
-    return current ?? node.getSourceFile();
-}
-/**
- * True when a property of the const object an identifier names may have been written before the
- * use: in the use's own function, or anywhere in the declaring function or module when that
- * differs. `const` fixes the binding, not the object, so a written object is not its initializer.
- */
-export function hasPropertyWriteBefore(identifier, symbol, checker) {
-    const resolved = resolveSymbol(symbol, checker);
-    const useScope = ownerOf(identifier);
-    const declaration = resolved.declarations.find(ts.isVariableDeclaration);
-    return [...new Set([useScope, ownerOf(declaration)])].some((scope) => [symbol, resolved].some((candidate) => propertyWrites(scope, checker)
-        .get(candidate)
-        ?.some((start) => scope !== useScope || start < identifier.getStart())));
-}

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

@@ -1,20 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { Carrier } from './request-validation-types.mts';
-/** What a value is relative to the handler's request context. */
-export type RootKind = 'context' | 'request' | 'query' | 'path' | 'header';
-/** A value bound to a parameter at a call site, with the request carriers it derives from. */
-export type Bound = {
-    kind?: RootKind | undefined;
-    origins: readonly Carrier[];
-    unresolved?: string | undefined;
-    /** The argument expression the call passed, for resolving object literals through it. */
-    expression?: ts.Expression | undefined;
-};
-export type RootBindings = ReadonlyMap<ts.Symbol, Bound>;
-/** The carrier object a named member of a context or request object denotes. */
-export declare function memberKind(base: RootKind | undefined, name: string): RootKind | undefined;
-export declare function rootKind(expression: ts.Expression, roots: RootBindings, checker: ts.TypeChecker, seen?: Set<ts.Symbol>): RootKind | undefined;
-/** `X.request.json()` and its siblings, where X is the request context. */
-export declare function isBodyRead(call: ts.CallExpression, roots: RootBindings, checker: ts.TypeChecker): boolean;
-/** `ctx.get(name)`. */
-export declare function isHeaderGet(call: ts.CallExpression, roots: RootBindings, checker: ts.TypeChecker): boolean;

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

@@ -1,71 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { identifierSymbol } from './request-validation-keys.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-const BODY_READERS = new Set(['json', 'text', 'buffer', 'formData', 'arrayBuffer', 'blob']);
-/** The carrier object a named member of a context or request object denotes. */
-export function memberKind(base, name) {
-    if (base === 'context' && (name === 'request' || name === 'req'))
-        return 'request';
-    if ((base === 'context' || base === 'request') && name === 'query')
-        return 'query';
-    if (base === 'context' && name === 'params')
-        return 'path';
-    if ((base === 'context' || base === 'request') && (name === 'headers' || name === 'header'))
-        return 'header';
-    return undefined;
-}
-/** The const initializer an identifier aliases, with the destructured key when it is a member. */
-function aliasSource(symbol) {
-    for (const declaration of symbol.declarations ?? []) {
-        const owner = ts.isBindingElement(declaration) ? declaration.parent.parent : declaration;
-        if (!ts.isVariableDeclaration(owner) ||
-            !owner.initializer ||
-            !(ts.getCombinedNodeFlags(owner) & ts.NodeFlags.Const))
-            continue;
-        if (!ts.isBindingElement(declaration))
-            return { initializer: owner.initializer };
-        const name = declaration.propertyName ?? declaration.name;
-        const member = ts.isObjectBindingPattern(declaration.parent) && !declaration.dotDotDotToken;
-        const named = ts.isIdentifier(name) || ts.isStringLiteral(name);
-        return { initializer: owner.initializer, key: member && named ? name.text : null };
-    }
-    return undefined;
-}
-export function rootKind(expression, roots, checker, seen = new Set()) {
-    const value = unwrapTransparentExpression(expression);
-    if (ts.isPropertyAccessExpression(value))
-        return memberKind(rootKind(value.expression, roots, checker, seen), value.name.text);
-    if (ts.isElementAccessExpression(value))
-        return ts.isStringLiteralLike(value.argumentExpression)
-            ? memberKind(rootKind(value.expression, roots, checker, seen), value.argumentExpression.text)
-            : undefined;
-    if (!ts.isIdentifier(value))
-        return undefined;
-    const symbol = identifierSymbol(value, checker);
-    if (!symbol || seen.has(symbol))
-        return undefined;
-    const bound = roots.get(symbol);
-    if (bound)
-        return bound.kind;
-    const alias = aliasSource(symbol);
-    if (!alias)
-        return undefined;
-    const base = rootKind(alias.initializer, roots, checker, new Set(seen).add(symbol));
-    if (alias.key === undefined)
-        return base;
-    return alias.key === null ? undefined : memberKind(base, alias.key);
-}
-/** `X.request.json()` and its siblings, where X is the request context. */
-export function isBodyRead(call, roots, checker) {
-    const callee = unwrapTransparentExpression(call.expression);
-    return (ts.isPropertyAccessExpression(callee) &&
-        BODY_READERS.has(callee.name.text) &&
-        rootKind(callee.expression, roots, checker) === 'request');
-}
-/** `ctx.get(name)`. */
-export function isHeaderGet(call, roots, checker) {
-    const callee = unwrapTransparentExpression(call.expression);
-    return (ts.isPropertyAccessExpression(callee) &&
-        callee.name.text === 'get' &&
-        rootKind(callee.expression, roots, checker) === 'context');
-}

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

@@ -1,13 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type KeyBindings } from './request-validation-keys.mts';
-import { type RootBindings } from './request-validation-origin.mts';
-import type { CarrierRead } from './request-validation-types.mts';
-export type RawRead = Omit<CarrierRead, 'source'>;
-type Scope = {
-    checker: ts.TypeChecker;
-    roots: RootBindings;
-    keys: KeyBindings;
-};
-/** The raw request reads made by exactly this node, not by its children. */
-export declare function rawReadsAt(node: ts.Node, scope: Scope): RawRead[];
-export {};

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

@@ -1,88 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { resolveKey } from './request-validation-keys.mjs';
-import { isBodyRead, isHeaderGet, rootKind, } from './request-validation-origin.mjs';
-const carrierRoot = (node, scope) => {
-    const kind = rootKind(node, scope.roots, scope.checker);
-    return kind === 'query' || kind === 'path' || kind === 'header' ? kind : undefined;
-};
-const isTransparent = (node) => ts.isParenthesizedExpression(node) ||
-    ts.isAsExpression(node) ||
-    ts.isNonNullExpression(node) ||
-    ts.isSatisfiesExpression(node) ||
-    ts.isTypeAssertionExpression(node);
-/** True when an identifier sits where it declares or names a property rather than reads a value. */
-function namesSomething(node) {
-    const { name, propertyName } = node.parent;
-    return (name === node && !ts.isShorthandPropertyAssignment(node.parent)) || propertyName === node;
-}
-/** True when the carrier expression is consumed as a value, not indexed, aliased or destructured. */
-function consumedAsValue(node) {
-    if (ts.isIdentifier(node) && namesSomething(node))
-        return false;
-    let outer = node;
-    while (isTransparent(outer.parent))
-        outer = outer.parent;
-    const parent = outer.parent;
-    if (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent))
-        return parent.expression !== outer;
-    if (ts.isVariableDeclaration(parent) && parent.initializer === outer)
-        return !(ts.isObjectBindingPattern(parent.name) ||
-            (ts.isIdentifier(parent.name) && !!(ts.getCombinedNodeFlags(parent) & ts.NodeFlags.Const)));
-    return !ts.isExpressionStatement(parent);
-}
-/** A whole-carrier read: the carrier object itself used as a value, as in `consume(ctx.query)`. */
-function wholeRead(node, scope) {
-    if (!ts.isExpression(node) || isTransparent(node))
-        return [];
-    const carrier = carrierRoot(node, scope);
-    return carrier && consumedAsValue(node) ? [{ carrier, key: null, access: 'whole' }] : [];
-}
-function destructuredRead(element, carrier) {
-    const name = element.propertyName ?? element.name;
-    if (element.dotDotDotToken)
-        return { carrier, key: null, access: 'whole' };
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name))
-        return { carrier, key: name.text, access: 'key' };
-    return { carrier, key: null, access: 'computed' };
-}
-/** True for the target of a plain assignment or `delete`, which replaces without reading. */
-function isWriteTarget(node) {
-    let outer = node;
-    while (isTransparent(outer.parent))
-        outer = outer.parent;
-    const parent = outer.parent;
-    return (ts.isDeleteExpression(parent) ||
-        (ts.isBinaryExpression(parent) &&
-            parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-            parent.left === outer));
-}
-/** The raw request reads made by exactly this node, not by its children. */
-export function rawReadsAt(node, scope) {
-    const keyed = (carrier, expression) => {
-        const key = resolveKey(expression, scope.checker, scope.keys) ?? null;
-        return { carrier, key, access: key === null ? 'computed' : 'key' };
-    };
-    if (ts.isCallExpression(node)) {
-        if (isBodyRead(node, scope.roots, scope.checker))
-            return [{ carrier: 'body', key: null, access: 'whole' }];
-        return isHeaderGet(node, scope.roots, scope.checker) ? [keyed('header', node.arguments[0])] : [];
-    }
-    if ((ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
-        isWriteTarget(node))
-        return [];
-    if (ts.isPropertyAccessExpression(node)) {
-        const carrier = carrierRoot(node.expression, scope);
-        if (carrier)
-            return [{ carrier, key: node.name.text, access: 'key' }];
-    }
-    if (ts.isElementAccessExpression(node)) {
-        const carrier = carrierRoot(node.expression, scope);
-        if (carrier)
-            return [keyed(carrier, node.argumentExpression)];
-    }
-    if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer) {
-        const carrier = carrierRoot(node.initializer, scope);
-        return carrier ? node.name.elements.map((element) => destructuredRead(element, carrier)) : [];
-    }
-    return wholeRead(node, scope);
-}

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

@@ -1,9 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type Scope } from './request-validation-follow.mts';
-import { type WalkState } from './request-validation-state-key.mts';
-/**
- * Finds configured factory calls in registration-time expressions, without entering handlers.
- * Validators evaluated here run while the handler is built, not per request, so only the walk of
- * the handler itself reports them.
- */
-export declare function createRegistrationScanner(scopeOf: (state: WalkState) => Scope, reportFactory: (call: ts.CallExpression, state: WalkState) => boolean): (node: ts.Node, state?: WalkState) => void;

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

@@ -1,32 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { followedImplementations } from './request-validation-follow.mjs';
-import { bindArguments } from './request-validation-trace.mjs';
-import { returnedValues } from './request-validation-trace-helpers.mjs';
-import { emptyState } from './request-validation-state-key.mjs';
-/**
- * Finds configured factory calls in registration-time expressions, without entering handlers.
- * Validators evaluated here run while the handler is built, not per request, so only the walk of
- * the handler itself reports them.
- */
-export function createRegistrationScanner(scopeOf, reportFactory) {
-    const scanning = new Set();
-    function scan(node, state = emptyState) {
-        if (ts.isFunctionLike(node))
-            return;
-        if (ts.isCallExpression(node) && reportFactory(node, state))
-            return;
-        if (ts.isCallExpression(node))
-            // A helper that builds the handler: follow its returned values with bound arguments.
-            for (const fn of followedImplementations(node, scopeOf(state))) {
-                if (scanning.has(fn))
-                    continue;
-                scanning.add(fn);
-                const { keys, roots } = bindArguments(fn, node, scopeOf(state));
-                for (const value of returnedValues(fn))
-                    scan(value, { ...state, keys, roots });
-                scanning.delete(fn);
-            }
-        ts.forEachChild(node, (child) => scan(child, state));
-    }
-    return scan;
-}

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

@@ -1,3 +0,0 @@
-import type ts from '../contract-schema/typescript-api.mts';
-/** Collects facts once per originating AST node and fact; a repeat returns the fact reported. */
-export declare function createReporter(): <T extends object>(kind: string, target: T[], item: T, node?: ts.Node, identity?: object) => T;

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

@@ -1,21 +0,0 @@
-/** Collects facts once per originating AST node and fact; a repeat returns the fact reported. */
-export function createReporter() {
-    const reported = new Map();
-    const nodeIds = new Map();
-    const nodeId = (node) => {
-        if (!node)
-            return '';
-        if (!nodeIds.has(node))
-            nodeIds.set(node, nodeIds.size);
-        return nodeIds.get(node);
-    };
-    return (kind, target, item, node, identity = item) => {
-        const key = `${kind}${nodeId(node)}${JSON.stringify(identity)}`;
-        const existing = reported.get(key);
-        if (existing)
-            return existing;
-        reported.set(key, item);
-        target.push(item);
-        return item;
-    };
-}

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

@@ -1,5 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type RootBindings } from './request-validation-origin.mts';
-import type { Carrier } from './request-validation-types.mts';
-/** The carrier a node reads directly from the request context, if it is such a read. */
-export declare function requestOrigin(node: ts.Node, roots: RootBindings, checker: ts.TypeChecker): Carrier | undefined;

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

@@ -1,13 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { isBodyRead, isHeaderGet, rootKind, } from './request-validation-origin.mjs';
-/** The carrier a node reads directly from the request context, if it is such a read. */
-export function requestOrigin(node, roots, checker) {
-    const kind = ts.isExpression(node) ? rootKind(node, roots, checker) : undefined;
-    if (kind === 'query' || kind === 'path' || kind === 'header')
-        return kind;
-    if (!ts.isCallExpression(node))
-        return undefined;
-    if (isBodyRead(node, roots, checker))
-        return 'body';
-    return isHeaderGet(node, roots, checker) ? 'header' : undefined;
-}

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

@@ -1,9 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { Scope } from './request-validation-follow.mts';
-/** The property name or array position a destructured binding selects, when it is static. */
-export declare function bindingKey(element: ts.BindingElement): string | number | 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 declare function literalMember(node: ts.Node, key: string | number, scope: Scope, seen?: Set<ts.Node>): ts.Expression | null | undefined;