vouchington-tooling 0.29.0 → 0.30.0

package/dist/api-contract-discovery/protocol-sse-emission.mjs

@@ -0,0 +1,61 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
+import { isSupportedProtocolCallback } from './protocol-callback-invocation.mjs';
+import { potentiallyExecuted } from './protocol-executable-path.mjs';
+import { enclosingFunction } from './protocol-marker-analysis.mjs';
+import { sseCallerScope } from './protocol-sse-callers.mjs';
+import { resolveSseStatus } from './protocol-sse-status.mjs';
+import { writeReceiver } from './protocol-write-receiver.mjs';
+export function sseEmission(call, checker, calls, binding, bindings) {
+    const write = call.parent;
+    if (!ts.isCallExpression(write) ||
+        !ts.isPropertyAccessExpression(write.expression) ||
+        write.expression.name.text !== 'write' ||
+        write.arguments[0] !== call)
+        throw new Error('apiSseFrame must be the frame written by its route');
+    const receiver = writeReceiver(write, checker);
+    if (!receiver)
+        throw new Error('SSE frame requires a bound stream receiver');
+    if (receiver.mutableAlias)
+        throw new Error('SSE frame uses a mutable stream alias');
+    let fn = enclosingFunction(call);
+    let context;
+    const callbacks = [];
+    const functions = [];
+    while (fn) {
+        functions.push(fn);
+        if (!potentiallyExecuted(fn) || !potentiallyExecuted(call))
+            throw new Error('SSE frame is not on an executable callback path');
+        if (fn.asteriskToken)
+            throw new Error('SSE frame is in a deferred generator');
+        if (!isSupportedProtocolCallback(fn, checker))
+            throw new Error('SSE frame is in an uninvoked callback');
+        if (ts.isFunctionDeclaration(fn)) {
+            const name = runtimeParameters(fn)[0]?.name;
+            if (name && ts.isIdentifier(name))
+                context = checker.getSymbolAtLocation(name);
+        }
+        else {
+            let value = fn;
+            while (ts.isPropertyAssignment(value.parent) || ts.isObjectLiteralExpression(value.parent))
+                value = value.parent;
+            if (ts.isCallExpression(value.parent) || ts.isNewExpression(value.parent))
+                callbacks.push(value.parent);
+            if ((ts.isCallExpression(value.parent) &&
+                ts.isPropertyAccessExpression(value.parent.expression) &&
+                ['get', 'post', 'put', 'patch', 'delete'].includes(value.parent.expression.name.text)) ||
+                (ts.isVariableDeclaration(fn.parent) && !enclosingFunction(fn))) {
+                const name = runtimeParameters(fn)[0]?.name;
+                if (name && ts.isIdentifier(name))
+                    context = checker.getSymbolAtLocation(name);
+            }
+        }
+        fn = enclosingFunction(fn);
+    }
+    const caller = sseCallerScope(functions, calls, binding, bindings, checker);
+    const anchors = [write, ...callbacks];
+    const paths = caller ? caller.paths.map((path) => [...anchors, ...path]) : [anchors];
+    const contexts = caller?.contexts ?? new Set(context ? [context] : []);
+    const status = resolveSseStatus(paths, [...new Set([...functions, ...(caller?.functions ?? [])])], contexts, checker);
+    return { write, receiver, status };
+}

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

@@ -0,0 +1,3 @@
+import ts from '../contract-schema/typescript-api.mts';
+/** Excludes a sibling branch or a statement that cannot precede this anchor. */
+export declare function statusCanPrecede(setter: ts.Node, anchor: ts.Node): boolean;

package/dist/api-contract-discovery/protocol-sse-feasible-status.mjs

@@ -0,0 +1,24 @@
+import ts from '../contract-schema/typescript-api.mjs';
+/** Excludes a sibling branch or a statement that cannot precede this anchor. */
+export function statusCanPrecede(setter, anchor) {
+    const ancestors = new Set();
+    for (let node = anchor; node; node = node.parent)
+        ancestors.add(node);
+    for (let node = setter; node.parent; node = node.parent) {
+        const parent = node.parent;
+        if (ts.isIfStatement(parent) && parent.elseStatement) {
+            const opposite = parent.thenStatement === node ? parent.elseStatement : parent.thenStatement;
+            if (ancestors.has(opposite))
+                return false;
+        }
+        if (ts.isBlock(parent) && ancestors.has(parent)) {
+            let statement = anchor;
+            while (statement.parent !== parent)
+                statement = statement.parent;
+            if (parent.statements.indexOf(node) >
+                parent.statements.indexOf(statement))
+                return false;
+        }
+    }
+    return true;
+}

package/dist/api-contract-discovery/protocol-sse-raw-writes.d.mts

@@ -0,0 +1,9 @@
+import ts from '../contract-schema/typescript-api.mts';
+import { type HandlerBindings, type RouteBinding } from './response-contract-route-analysis.mts';
+import { type WriteReceiver } from './protocol-write-receiver.mts';
+export type SseRouteWrites = {
+    receivers: WriteReceiver[];
+    keys: string[];
+};
+/** Reports unmarked writes on executable or opaque escaping paths to a selected frame's stream. */
+export declare function rejectRawSseWrites(files: readonly ts.SourceFile[], checker: ts.TypeChecker, bindings: HandlerBindings, framedWrites: ReadonlySet<ts.CallExpression>, routes: ReadonlyMap<string, SseRouteWrites>, reject: (node: ts.CallExpression, binding: RouteBinding, keys: readonly string[]) => void): void;

package/dist/api-contract-discovery/protocol-sse-raw-writes.mjs

@@ -0,0 +1,70 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { potentiallyExecuted } from './protocol-executable-path.mjs';
+import { executableProtocolPath } from './protocol-execution-path.mjs';
+import { opaqueProtocolCallbackPath } from './protocol-opaque-callback.mjs';
+import { enclosingRouteBinding, visit, } from './response-contract-route-analysis.mjs';
+import { expressionReceiver, sameWriteReceiver, } from './protocol-write-receiver.mjs';
+import { sseWriteInvocation } from './protocol-sse-write-access.mjs';
+import { isSourceLevelMutation, mutationAffectsSelectedStream, sseWriteMutation, } from './protocol-sse-write-mutations.mjs';
+import { actualReceivers, helperBindings, routeKey } from './protocol-sse-write-helpers.mjs';
+/** Reports unmarked writes on executable or opaque escaping paths to a selected frame's stream. */
+export function rejectRawSseWrites(files, checker, bindings, framedWrites, routes, reject) {
+    const calls = [];
+    const mutations = [];
+    for (const file of files)
+        visit(file, (node) => {
+            if (ts.isCallExpression(node))
+                calls.push(node);
+            const mutation = sseWriteMutation(node);
+            if (mutation)
+                mutations.push(mutation);
+        });
+    for (const node of calls) {
+        if (framedWrites.has(node)) {
+            const binding = enclosingRouteBinding(node, checker, bindings, false);
+            const route = binding && routes.get(routeKey(binding));
+            const source = node.getSourceFile();
+            if (binding &&
+                route &&
+                mutationAffectsSelectedStream(mutations, route.receivers, checker, (mutationNode) => {
+                    if (mutationNode.getSourceFile() === source && isSourceLevelMutation(mutationNode))
+                        return true;
+                    const candidate = enclosingRouteBinding(mutationNode, checker, bindings, false);
+                    return !!candidate && routeKey(candidate) === routeKey(binding);
+                }, (expression) => {
+                    const receiver = expressionReceiver(expression, checker);
+                    return receiver && actualReceivers(receiver, binding, calls, checker, bindings);
+                }, (receiver) => actualReceivers(receiver, binding, calls, checker, bindings)))
+                reject(node, binding, route.keys);
+            continue;
+        }
+        const access = sseWriteInvocation(node, checker);
+        if (!access || !access.rawBytes || !potentiallyExecuted(node))
+            continue;
+        const proven = executableProtocolPath(node, checker) || opaqueProtocolCallbackPath(node, checker);
+        const helpers = helperBindings(node, calls, checker, bindings);
+        if (!proven && !helpers.length)
+            continue;
+        const binding = proven ? enclosingRouteBinding(node, checker, bindings, false) : undefined;
+        const candidates = binding ? [binding] : helpers;
+        for (const candidate of candidates) {
+            const route = routes.get(routeKey(candidate));
+            if (!route)
+                continue;
+            if (!access.receiver) {
+                reject(node, candidate, route.keys);
+                continue;
+            }
+            const receiver = expressionReceiver(access.receiver, checker);
+            if (!receiver) {
+                reject(node, candidate, route.keys);
+                continue;
+            }
+            const actual = actualReceivers(receiver, candidate, calls, checker, bindings);
+            const framed = route.receivers.flatMap((value) => actualReceivers(value, candidate, calls, checker, bindings));
+            if (actual.some((value) => value === undefined ||
+                framed.some((frame) => frame === undefined || sameWriteReceiver(frame, value))))
+                reject(node, candidate, route.keys);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+import ts from '../contract-schema/typescript-api.mts';
+import { resolveEmissionStatus } from './response-contract-status.mts';
+export declare function resolveSseStatus(paths: readonly (readonly (ts.CallExpression | ts.NewExpression)[])[], functions: readonly ts.FunctionLikeDeclaration[], contexts: ReadonlySet<ts.Symbol>, checker: ts.TypeChecker): ReturnType<typeof resolveEmissionStatus>;

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

@@ -0,0 +1,84 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { executableProtocolPath } from './protocol-execution-path.mjs';
+import { unsupportedContextAlias, unsupportedContextAssignment } from './protocol-context-alias.mjs';
+import { contextResponseMethod } from './protocol-http-emission.mjs';
+import { enclosingFunction, unwrapExpression } from './protocol-marker-analysis.mjs';
+import { expressionReceiver } from './protocol-write-receiver.mjs';
+import { statusCanPrecede } from './protocol-sse-feasible-status.mjs';
+import { statusDominatesEmission, unconditionalStatusSetter } from './protocol-status-dominance.mjs';
+import { visit } from './response-contract-route-analysis.mjs';
+import { resolveEmissionStatus } from './response-contract-status.mjs';
+import { statusForbidsBody } from './protocol-body-status.mjs';
+export function resolveSseStatus(paths, functions, contexts, checker) {
+    const matches = (expression) => [...contexts].some((context) => contextResponseMethod(expression, context, checker) === 'setStatus');
+    const setters = new Set();
+    for (const fn of functions)
+        visit(fn, (node) => {
+            if (!executableProtocolPath(node, checker))
+                return;
+            if ([...contexts].some((context) => (ts.isVariableDeclaration(node) && unsupportedContextAlias(node, context, checker)) ||
+                unsupportedContextAssignment(node, context, checker)))
+                throw new Error('SSE context has an unsupported mutable or destructured alias');
+            if (ts.isCallExpression(node) && indirectSetter(node.expression, contexts, checker))
+                throw new Error('SSE context uses an unsupported indirect status setter');
+            if (ts.isCallExpression(node) && matches(node.expression))
+                setters.add(node);
+        });
+    const statuses = paths.map((path) => {
+        for (const setter of setters) {
+            const anchors = path.filter((anchor) => enclosingFunction(anchor) === enclosingFunction(setter));
+            if ((!anchors.length || anchors.some((anchor) => statusCanPrecede(setter, anchor))) &&
+                !anchors.some((anchor) => statusDominatesEmission(anchor, new Set([setter]))))
+                throw new Error('SSE status does not dominate its frame emission');
+        }
+        for (const anchor of path) {
+            const setter = nearestSetter(anchor, setters);
+            if (setter) {
+                const status = resolveEmissionStatus(setter, matches);
+                if (status.unavailableReason)
+                    throw new Error(status.unavailableReason);
+                return status;
+            }
+        }
+        return { statusKnowledge: 'default' };
+    });
+    if (statuses.every((status) => status.statusKnowledge === 'default'))
+        return { statusKnowledge: 'default' };
+    const codes = [...new Set(statuses.flatMap((status) => status.statusCodes ?? [200]))].toSorted((a, b) => a - b);
+    if (codes.some((code) => !Number.isInteger(code) || code < 100 || code > 599))
+        throw new Error('SSE status must be an integer from 100 through 599');
+    if (codes.some(statusForbidsBody))
+        throw new Error('SSE HTTP status forbids response content');
+    return { statusKnowledge: 'explicit', statusCodes: codes };
+}
+function indirectSetter(expression, contexts, checker) {
+    const access = unwrapExpression(expression);
+    const name = ts.isPropertyAccessExpression(access)
+        ? access.name.text
+        : ts.isElementAccessExpression(access) && ts.isStringLiteral(access.argumentExpression)
+            ? access.argumentExpression.text
+            : undefined;
+    if (!name || !['call', 'apply', 'bind'].includes(name))
+        return false;
+    const target = access.expression;
+    if ([...contexts].some((context) => contextResponseMethod(target, context, checker) === 'setStatus'))
+        return true;
+    const receiver = expressionReceiver(target, checker);
+    return !!receiver && contexts.has(receiver.root) && receiver.path[0] === 'setStatus';
+}
+function nearestSetter(anchor, setters) {
+    let current = anchor;
+    while (current.parent && !ts.isFunctionLike(current.parent)) {
+        const parent = current.parent;
+        if (ts.isBlock(parent)) {
+            const index = parent.statements.indexOf(current);
+            for (const statement of parent.statements.slice(0, index).toReversed()) {
+                const setter = unconditionalStatusSetter(statement, setters);
+                if (setter)
+                    return setter;
+            }
+        }
+        current = parent;
+    }
+    return undefined;
+}

package/dist/api-contract-discovery/protocol-sse-write-access.d.mts

@@ -0,0 +1,9 @@
+import ts from '../contract-schema/typescript-api.mts';
+type WriteInvocation = {
+    receiver: ts.Expression | undefined;
+    method: string | undefined;
+    rawBytes: boolean;
+};
+/** Resolves direct and indirect SSE writes without losing their actual receiver. */
+export declare function sseWriteInvocation(call: ts.CallExpression, checker: ts.TypeChecker): WriteInvocation | undefined;
+export {};

package/dist/api-contract-discovery/protocol-sse-write-access.mjs

@@ -0,0 +1,42 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { hasRawBytes, indirectPayload, reflectApplyInvocation, writeAccess, } from './protocol-sse-write-resolution.mjs';
+/** Resolves direct and indirect SSE writes without losing their actual receiver. */
+export function sseWriteInvocation(call, checker) {
+    const reflected = reflectApplyInvocation(call, checker);
+    if (reflected)
+        return reflected;
+    const access = writeAccess(call.expression);
+    if (!access)
+        return undefined;
+    if (access.method === 'pipe')
+        return call.arguments[0]
+            ? { receiver: call.arguments[0], method: 'write', rawBytes: true }
+            : undefined;
+    if (access.method === 'bind') {
+        const target = writeAccess(access.receiver);
+        if (target?.method !== 'write' && target?.method !== 'end')
+            return undefined;
+        return { receiver: call.arguments[0], method: target.method, rawBytes: true };
+    }
+    if (access.method !== 'call' && access.method !== 'apply')
+        return { ...access, rawBytes: hasRawBytes(access.method, call.arguments, checker, false) };
+    const target = writeAccess(access.receiver);
+    const receiver = call.arguments[0];
+    if (!receiver)
+        return undefined;
+    const payload = indirectPayload(access.method, call, checker);
+    if (target?.method === 'pipe') {
+        const destination = payload?.[0];
+        return {
+            receiver: destination,
+            method: 'write',
+            rawBytes: payload === undefined || destination !== undefined,
+        };
+    }
+    const method = target?.method === 'write' || target?.method === 'end' ? target.method : undefined;
+    return {
+        receiver,
+        method,
+        rawBytes: payload === undefined || hasRawBytes(method, payload, checker, true),
+    };
+}

package/dist/api-contract-discovery/protocol-sse-write-helpers.d.mts

@@ -0,0 +1,6 @@
+import ts from '../contract-schema/typescript-api.mts';
+import { type HandlerBindings, type RouteBinding } from './response-contract-route-analysis.mts';
+import { type WriteReceiver } from './protocol-write-receiver.mts';
+export declare function routeKey(binding: RouteBinding): string;
+export declare function helperBindings(node: ts.Node, calls: readonly ts.CallExpression[], checker: ts.TypeChecker, bindings: HandlerBindings): RouteBinding[];
+export declare function actualReceivers(receiver: WriteReceiver, binding: RouteBinding, calls: readonly ts.CallExpression[], checker: ts.TypeChecker, bindings: HandlerBindings, active?: Set<ts.Symbol>): (WriteReceiver | undefined)[];

package/dist/api-contract-discovery/protocol-sse-write-helpers.mjs

@@ -0,0 +1,66 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { hasBindingWrite } from './registered-route-binding-writes.mjs';
+import { runtimeParameters } from './registered-route-runtime-parameters.mjs';
+import { enclosingFunction } from './protocol-marker-analysis.mjs';
+import { executableProtocolPath } from './protocol-execution-path.mjs';
+import { enclosingRouteBinding, } from './response-contract-route-analysis.mjs';
+import { expressionReceiver } from './protocol-write-receiver.mjs';
+export function routeKey(binding) {
+    return `${binding.method}:${binding.routeTemplate}`;
+}
+function implementationDeclaration(declaration, checker) {
+    if (!declaration)
+        return undefined;
+    if (ts.isArrowFunction(declaration) || ts.isFunctionExpression(declaration))
+        return declaration;
+    if (ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration)) {
+        if (declaration.body)
+            return declaration;
+        const symbol = declaration.name && checker.getSymbolAtLocation(declaration.name);
+        return symbol?.declarations?.find((candidate) => (ts.isFunctionDeclaration(candidate) || ts.isMethodDeclaration(candidate)) &&
+            !!candidate.body);
+    }
+    return undefined;
+}
+export function helperBindings(node, calls, checker, bindings) {
+    const fn = enclosingFunction(node);
+    if (!fn || fn.asteriskToken)
+        return [];
+    return calls.flatMap((call) => {
+        if (implementationDeclaration(checker.getResolvedSignature(call)?.declaration, checker) !== fn ||
+            !executableProtocolPath(call, checker))
+            return [];
+        const binding = enclosingRouteBinding(call, checker, bindings, false);
+        return binding ? [binding] : [];
+    });
+}
+export function actualReceivers(receiver, binding, calls, checker, bindings, active = new Set()) {
+    const declaration = receiver.root.valueDeclaration;
+    if (receiver.mutableAlias ||
+        (declaration &&
+            (ts.isBindingElement(declaration) ||
+                (ts.isVariableDeclaration(declaration) &&
+                    !(declaration.parent.flags & ts.NodeFlags.Const)) ||
+                (ts.isParameter(declaration) && hasBindingWrite(declaration, checker)))))
+        return [undefined];
+    const fn = declaration && enclosingFunction(declaration);
+    if (!declaration || !ts.isParameter(declaration) || !fn)
+        return [receiver];
+    if (active.has(receiver.root))
+        return [undefined];
+    const index = runtimeParameters(fn).indexOf(declaration);
+    const actuals = calls.flatMap((call) => {
+        if (implementationDeclaration(checker.getResolvedSignature(call)?.declaration, checker) !== fn ||
+            !executableProtocolPath(call, checker))
+            return [];
+        const callBinding = enclosingRouteBinding(call, checker, bindings, false);
+        if (!callBinding || routeKey(callBinding) !== routeKey(binding))
+            return [];
+        const argument = call.arguments[index] ?? declaration.initializer;
+        const actual = argument && expressionReceiver(argument, checker);
+        if (!actual || receiver.path.length)
+            return [undefined];
+        return actualReceivers(actual, binding, calls, checker, bindings, new Set(active).add(receiver.root));
+    });
+    return actuals.length ? actuals : [receiver];
+}

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

@@ -0,0 +1,9 @@
+import ts from '../contract-schema/typescript-api.mts';
+import { type WriteReceiver } from './protocol-write-receiver.mts';
+export type SseWriteMutation = {
+    node: ts.Node;
+    receiver: ts.Expression;
+};
+export declare function sseWriteMutation(node: ts.Node): SseWriteMutation | undefined;
+export declare function mutationAffectsSelectedStream(mutations: readonly SseWriteMutation[], frameReceivers: readonly WriteReceiver[], checker: ts.TypeChecker, isSameRoute: (node: ts.Node) => boolean, resolveActual: (expression: ts.Expression) => readonly (WriteReceiver | undefined)[] | undefined, resolveFrame: (receiver: WriteReceiver) => readonly (WriteReceiver | undefined)[]): boolean;
+export declare function isSourceLevelMutation(node: ts.Node): boolean;

package/dist/api-contract-discovery/protocol-sse-write-mutations.mjs

@@ -0,0 +1,36 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { executableProtocolPath } from './protocol-execution-path.mjs';
+import { sameWriteReceiver } from './protocol-write-receiver.mjs';
+import { writeAccess } from './protocol-sse-write-resolution.mjs';
+export function sseWriteMutation(node) {
+    if (ts.isBinaryExpression(node) && isAssignment(node.operatorToken.kind)) {
+        const access = writeAccess(node.left);
+        if (access && (access.method === 'write' || access.method === 'end'))
+            return { node, receiver: access.receiver };
+    }
+    if (ts.isDeleteExpression(node)) {
+        const access = writeAccess(node.expression);
+        if (access && (access.method === 'write' || access.method === 'end'))
+            return { node, receiver: access.receiver };
+    }
+    return undefined;
+}
+function isAssignment(kind) {
+    return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+}
+export function mutationAffectsSelectedStream(mutations, frameReceivers, checker, isSameRoute, resolveActual, resolveFrame) {
+    const framed = frameReceivers.flatMap(resolveFrame);
+    return mutations.some(({ node, receiver }) => {
+        if ((!isSourceLevelMutation(node) && !executableProtocolPath(node, checker)) ||
+            !isSameRoute(node))
+            return false;
+        const actual = resolveActual(receiver);
+        if (!actual)
+            return true;
+        return actual.some((value) => value === undefined ||
+            framed.some((frame) => frame === undefined || sameWriteReceiver(frame, value)));
+    });
+}
+export function isSourceLevelMutation(node) {
+    return ts.isExpressionStatement(node.parent) && ts.isSourceFile(node.parent.parent);
+}

package/dist/api-contract-discovery/protocol-sse-write-resolution.d.mts

@@ -0,0 +1,14 @@
+import ts from '../contract-schema/typescript-api.mts';
+export type WriteAccess = {
+    receiver: ts.Expression;
+    method: string | undefined;
+};
+export type WriteInvocation = {
+    receiver: ts.Expression | undefined;
+    method: string | undefined;
+    rawBytes: boolean;
+};
+export declare function writeAccess(expression: ts.Expression): WriteAccess | undefined;
+export declare function reflectApplyInvocation(call: ts.CallExpression, checker: ts.TypeChecker): WriteInvocation | undefined;
+export declare function indirectPayload(method: 'call' | 'apply', call: ts.CallExpression, checker: ts.TypeChecker): readonly ts.Expression[] | undefined;
+export declare function hasRawBytes(method: string | undefined, payload: readonly ts.Expression[] | undefined, checker: ts.TypeChecker, indirect: boolean): boolean;

package/dist/api-contract-discovery/protocol-sse-write-resolution.mjs

@@ -0,0 +1,79 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { unwrapExpression } from './protocol-marker-analysis.mjs';
+export function writeAccess(expression) {
+    expression = unwrapExpression(expression);
+    if (ts.isPropertyAccessExpression(expression))
+        return { receiver: expression.expression, method: expression.name.text };
+    if (!ts.isElementAccessExpression(expression))
+        return undefined;
+    const method = unwrapExpression(expression.argumentExpression);
+    return {
+        receiver: expression.expression,
+        method: ts.isStringLiteralLike(method) ? method.text : undefined,
+    };
+}
+export function reflectApplyInvocation(call, checker) {
+    const expression = unwrapExpression(call.expression);
+    if (!ts.isPropertyAccessExpression(expression) ||
+        expression.name.text !== 'apply' ||
+        !ts.isIdentifier(expression.expression) ||
+        expression.expression.text !== 'Reflect')
+        return undefined;
+    const defaultApply = checker
+        .getSymbolAtLocation(expression.name)
+        ?.declarations?.some((declaration) => declaration.getSourceFile().fileName.endsWith('/lib.es2015.reflect.d.ts'));
+    if (!defaultApply)
+        return undefined;
+    const target = call.arguments[0] && writeAccess(call.arguments[0]);
+    const receiver = call.arguments[1];
+    const payload = applyPayload(call.arguments[2], checker);
+    if (target?.method === 'pipe') {
+        const destination = payload?.[0];
+        return {
+            receiver: destination,
+            method: 'write',
+            rawBytes: payload === undefined || destination !== undefined,
+        };
+    }
+    const method = target?.method === 'write' || target?.method === 'end' ? target.method : undefined;
+    return {
+        receiver,
+        method,
+        rawBytes: payload === undefined || hasRawBytes(method, payload, checker, true),
+    };
+}
+export function indirectPayload(method, call, checker) {
+    if (method === 'call')
+        return call.arguments.slice(1);
+    return applyPayload(call.arguments[1], checker);
+}
+function applyPayload(argument, checker) {
+    if (!argument)
+        return [];
+    const value = unwrapExpression(argument);
+    if (isNullish(argument, checker))
+        return [];
+    if (!ts.isArrayLiteralExpression(value) || value.elements.some(ts.isSpreadElement))
+        return undefined;
+    return value.elements.filter(ts.isExpression);
+}
+function isNullish(expression, checker) {
+    const value = unwrapExpression(expression);
+    if (value.kind === ts.SyntaxKind.NullKeyword)
+        return true;
+    if (ts.isIdentifier(value) && value.text === 'undefined')
+        return true;
+    const flags = checker.getTypeAtLocation(expression).flags;
+    return !!(flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null));
+}
+export function hasRawBytes(method, payload, checker, indirect) {
+    if (payload === undefined || method === undefined)
+        return true;
+    if (method === 'write')
+        return !indirect || payload.length > 0;
+    if (method !== 'end' || !payload[0])
+        return false;
+    const type = checker.getTypeAtLocation(payload[0]);
+    return (!(type.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)) &&
+        type.getCallSignatures().length === 0);
+}

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

@@ -0,0 +1,5 @@
+import ts from '../contract-schema/typescript-api.mts';
+/** Requires the last potentially preceding proven status setter to belong to this response. */
+export declare function statusDominatesEmission(emission: ts.CallExpression | ts.NewExpression, statuses: ReadonlySet<ts.CallExpression>, allStatuses?: ReadonlySet<ts.CallExpression>): boolean;
+/** Finds the last setter through unconditional blocks, excluding conditional compound statements. */
+export declare function unconditionalStatusSetter(statement: ts.Statement, statuses: ReadonlySet<ts.CallExpression>): ts.CallExpression | undefined;

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

@@ -0,0 +1,35 @@
+import ts from '../contract-schema/typescript-api.mjs';
+/** Requires the last potentially preceding proven status setter to belong to this response. */
+export function statusDominatesEmission(emission, statuses, allStatuses = statuses) {
+    let current = emission;
+    while (current.parent && !ts.isFunctionLike(current.parent)) {
+        const parent = current.parent;
+        if (ts.isBlock(parent)) {
+            const index = parent.statements.indexOf(current);
+            for (const statement of parent.statements.slice(0, index).toReversed())
+                if (containsStatus(statement, allStatuses)) {
+                    const setter = unconditionalStatusSetter(statement, allStatuses);
+                    return !!setter && statuses.has(setter);
+                }
+        }
+        current = parent;
+    }
+    return false;
+}
+/** Finds the last setter through unconditional blocks, excluding conditional compound statements. */
+export function unconditionalStatusSetter(statement, statuses) {
+    if (ts.isBlock(statement)) {
+        for (const child of statement.statements.toReversed())
+            if (containsStatus(child, statuses))
+                return unconditionalStatusSetter(child, statuses);
+    }
+    else if (ts.isExpressionStatement(statement) &&
+        ts.isCallExpression(statement.expression) &&
+        statuses.has(statement.expression))
+        return statement.expression;
+    return undefined;
+}
+function containsStatus(node, statuses) {
+    return ((ts.isCallExpression(node) && statuses.has(node)) ||
+        (ts.forEachChild(node, (child) => containsStatus(child, statuses)) ?? false));
+}

package/dist/api-contract-discovery/protocol-write-receiver.d.mts

@@ -0,0 +1,9 @@
+import ts from '../contract-schema/typescript-api.mts';
+export type WriteReceiver = {
+    root: ts.Symbol;
+    path: readonly string[];
+    mutableAlias?: boolean;
+};
+export declare function writeReceiver(call: ts.CallExpression, checker: ts.TypeChecker): WriteReceiver | undefined;
+export declare function sameWriteReceiver(left: WriteReceiver, right: WriteReceiver | undefined): boolean;
+export declare function expressionReceiver(expression: ts.Expression, checker: ts.TypeChecker, active?: Set<ts.Symbol>): WriteReceiver | undefined;