vouchington-tooling 0.34.0 → 0.36.0

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

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

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

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

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

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

package/dist/api-contract-discovery/response-contract-implicit-sources.test-helpers.d.mts

@@ -1,145 +0,0 @@
-export declare const responseContractImplicitSources: {
-    readonly 'called-helper': `
-    declare const app: any
-    async function handleCreate(ctx: any) {
-      ctx.setStatus(201)
-      return { id: 'one' as string }
-    }
-    app.route('/api/v1/items').post(async (ctx: any) => {
-      ctx.json(await handleCreate(ctx))
-    })
-  `;
-    readonly 'shared-helper': `
-    declare const app: any
-    function markCreated(ctx: any) { ctx.setStatus(201) }
-    app.route('/api/v1/items').post((ctx: any) => {
-      markCreated(ctx)
-      ctx.json({ id: 'one' as string })
-    })
-    app.route('/api/v1/widgets').post((ctx: any) => {
-      markCreated(ctx)
-      ctx.json({ id: 'one' as string })
-    })
-  `;
-    readonly empty: `
-    declare const app: any
-    app.route('/api/v1/items/:id').delete((ctx: any) => {
-      ctx.setStatus(200)
-      ctx.response.empty()
-    })
-  `;
-    readonly 'error-guard': `
-    declare const app: any
-    app.route('/api/v1/auth/me').get((ctx: any) => {
-      if (!ctx.user) {
-        ctx.setStatus(401)
-        return ctx.json({ error: 'not authenticated' as string })
-      }
-      ctx.json({ user: { id: 'one' as string } })
-    })
-  `;
-    readonly 'two-guards': `
-    declare const app: any
-    app.route('/api/v1/items/:id').get((ctx: any) => {
-      if (!ctx.user) {
-        ctx.setStatus(401)
-        return ctx.json({ error: 'not authenticated' as string })
-      }
-      if (!ctx.item) {
-        ctx.setStatus(404)
-        return ctx.json({ error: 'not found' as string })
-      }
-      ctx.json({ item: { id: 'one' as string } })
-    })
-  `;
-    readonly conflict: `
-    declare const app: any
-    const sendConflict = (ctx: any, existing: any) => {
-      ctx.setStatus(409)
-      if (!existing) {
-        ctx.json({ error: 'conflict' as string })
-        return
-      }
-      ctx.json({ error: 'conflict' as string, id: 'x' as string })
-    }
-    app.route('/api/v1/items').post((ctx: any) => {
-      const conflict: any = {}
-      if (conflict.existing !== undefined) {
-        sendConflict(ctx, conflict.existing)
-        return
-      }
-      ctx.setStatus(201)
-      ctx.json({ id: 'one' as string, status: 'pending' as string })
-    })
-  `;
-    readonly ternary: `
-    declare const app: any
-    declare const created: boolean
-    app.route('/api/v1/items').post((ctx: any) => {
-      ctx.setStatus(created ? 201 : 200)
-      ctx.json({ id: 'one' as string })
-    })
-  `;
-    readonly variants: `
-    declare const app: any
-    declare function apiResponse<K extends string, T>(key: K, body: T): T
-    app.route('/api/v1/items').post((ctx: any) => {
-      ctx.setStatus(422)
-      apiResponse('POST:/api/v1/items#validation', { error: 'invalid' as string })
-      ctx.setStatus(201)
-      apiResponse('POST:/api/v1/items', { id: 'one' as string })
-    })
-  `;
-    readonly branches: `
-    declare const app: any
-    app.route('/api/v1/webhooks/:id').post((ctx: any) => {
-      if (ctx.body.event === 'known') {
-        ctx.json({ received: true as boolean })
-        return
-      }
-      ctx.json({ ignored: true as boolean })
-    })
-  `;
-    readonly 'secondary-failure': `
-    declare const app: any
-    declare function riskyLookup(): any
-    app.route('/api/v1/jobs/:id').get((ctx: any) => {
-      if (ctx.query.mode === 'basic') {
-        ctx.json({ ready: true as boolean })
-        return
-      }
-      ctx.json({ value: riskyLookup() })
-    })
-  `;
-    readonly 'empty-then-buffer': `
-    declare const app: any
-    declare const body: any
-    declare const contentType: string
-    app.route('/api/v1/mcp').post((ctx: any) => {
-      if (body.byteLength === 0) {
-        ctx.response.empty()
-      } else {
-        ctx.response.buffer(body, contentType)
-      }
-    })
-  `;
-    readonly 'buffer-then-empty': `
-    declare const app: any
-    declare const body: any
-    declare const contentType: string
-    app.route('/api/v1/mcp').post((ctx: any) => {
-      if (body.byteLength > 0) {
-        ctx.response.buffer(body, contentType)
-      } else {
-        ctx.response.empty()
-      }
-    })
-  `;
-    readonly 'single-failure': `
-    declare const app: any
-    declare function riskyLookup(): any
-    app.route('/api/v1/jobs/:id').get((ctx: any) => {
-      ctx.json({ value: riskyLookup() })
-    })
-  `;
-};

package/dist/api-contract-discovery/response-contract-implicit-sources.test-helpers.mjs

@@ -1,145 +0,0 @@
-export const responseContractImplicitSources = {
-    'called-helper': `
-    declare const app: any
-    async function handleCreate(ctx: any) {
-      ctx.setStatus(201)
-      return { id: 'one' as string }
-    }
-    app.route('/api/v1/items').post(async (ctx: any) => {
-      ctx.json(await handleCreate(ctx))
-    })
-  `,
-    'shared-helper': `
-    declare const app: any
-    function markCreated(ctx: any) { ctx.setStatus(201) }
-    app.route('/api/v1/items').post((ctx: any) => {
-      markCreated(ctx)
-      ctx.json({ id: 'one' as string })
-    })
-    app.route('/api/v1/widgets').post((ctx: any) => {
-      markCreated(ctx)
-      ctx.json({ id: 'one' as string })
-    })
-  `,
-    empty: `
-    declare const app: any
-    app.route('/api/v1/items/:id').delete((ctx: any) => {
-      ctx.setStatus(200)
-      ctx.response.empty()
-    })
-  `,
-    'error-guard': `
-    declare const app: any
-    app.route('/api/v1/auth/me').get((ctx: any) => {
-      if (!ctx.user) {
-        ctx.setStatus(401)
-        return ctx.json({ error: 'not authenticated' as string })
-      }
-      ctx.json({ user: { id: 'one' as string } })
-    })
-  `,
-    'two-guards': `
-    declare const app: any
-    app.route('/api/v1/items/:id').get((ctx: any) => {
-      if (!ctx.user) {
-        ctx.setStatus(401)
-        return ctx.json({ error: 'not authenticated' as string })
-      }
-      if (!ctx.item) {
-        ctx.setStatus(404)
-        return ctx.json({ error: 'not found' as string })
-      }
-      ctx.json({ item: { id: 'one' as string } })
-    })
-  `,
-    conflict: `
-    declare const app: any
-    const sendConflict = (ctx: any, existing: any) => {
-      ctx.setStatus(409)
-      if (!existing) {
-        ctx.json({ error: 'conflict' as string })
-        return
-      }
-      ctx.json({ error: 'conflict' as string, id: 'x' as string })
-    }
-    app.route('/api/v1/items').post((ctx: any) => {
-      const conflict: any = {}
-      if (conflict.existing !== undefined) {
-        sendConflict(ctx, conflict.existing)
-        return
-      }
-      ctx.setStatus(201)
-      ctx.json({ id: 'one' as string, status: 'pending' as string })
-    })
-  `,
-    ternary: `
-    declare const app: any
-    declare const created: boolean
-    app.route('/api/v1/items').post((ctx: any) => {
-      ctx.setStatus(created ? 201 : 200)
-      ctx.json({ id: 'one' as string })
-    })
-  `,
-    variants: `
-    declare const app: any
-    declare function apiResponse<K extends string, T>(key: K, body: T): T
-    app.route('/api/v1/items').post((ctx: any) => {
-      ctx.setStatus(422)
-      apiResponse('POST:/api/v1/items#validation', { error: 'invalid' as string })
-      ctx.setStatus(201)
-      apiResponse('POST:/api/v1/items', { id: 'one' as string })
-    })
-  `,
-    branches: `
-    declare const app: any
-    app.route('/api/v1/webhooks/:id').post((ctx: any) => {
-      if (ctx.body.event === 'known') {
-        ctx.json({ received: true as boolean })
-        return
-      }
-      ctx.json({ ignored: true as boolean })
-    })
-  `,
-    'secondary-failure': `
-    declare const app: any
-    declare function riskyLookup(): any
-    app.route('/api/v1/jobs/:id').get((ctx: any) => {
-      if (ctx.query.mode === 'basic') {
-        ctx.json({ ready: true as boolean })
-        return
-      }
-      ctx.json({ value: riskyLookup() })
-    })
-  `,
-    'empty-then-buffer': `
-    declare const app: any
-    declare const body: any
-    declare const contentType: string
-    app.route('/api/v1/mcp').post((ctx: any) => {
-      if (body.byteLength === 0) {
-        ctx.response.empty()
-      } else {
-        ctx.response.buffer(body, contentType)
-      }
-    })
-  `,
-    'buffer-then-empty': `
-    declare const app: any
-    declare const body: any
-    declare const contentType: string
-    app.route('/api/v1/mcp').post((ctx: any) => {
-      if (body.byteLength > 0) {
-        ctx.response.buffer(body, contentType)
-      } else {
-        ctx.response.empty()
-      }
-    })
-  `,
-    'single-failure': `
-    declare const app: any
-    declare function riskyLookup(): any
-    app.route('/api/v1/jobs/:id').get((ctx: any) => {
-      ctx.json({ value: riskyLookup() })
-    })
-  `,
-};

package/dist/api-contract-discovery/response-contract-implicit-variants.d.mts

@@ -1,2 +0,0 @@
-import type { BackendResponseContract } from './response-contract-types.mts';
-export declare function nextImplicitVariantKey(contracts: Map<string, BackendResponseContract>, key: string): string;

package/dist/api-contract-discovery/response-contract-implicit-variants.mjs

@@ -1,6 +0,0 @@
-export function nextImplicitVariantKey(contracts, key) {
-    let suffix = 2;
-    while (contracts.has(`${key}#implicit-${suffix}`))
-        suffix++;
-    return `${key}#implicit-${suffix}`;
-}

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

@@ -1,6 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ImplicitResponseCallLabel } from './response-contract-call-classification.mts';
-import { type DiscoverApiResponseContractsOptions } from './response-contract-lenient.mts';
-import { type HandlerBindings } from './response-contract-route-analysis.mts';
-import type { BackendResponseContract } from './response-contract-types.mts';
-export declare function discoverImplicitContract(call: ts.CallExpression, checker: ts.TypeChecker, sourceFile: ts.SourceFile, contracts: Map<string, BackendResponseContract>, handlerBindings: HandlerBindings, callLabel: ImplicitResponseCallLabel | undefined, requestedKeys: ReadonlySet<string> | undefined, options: DiscoverApiResponseContractsOptions | undefined): void;

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

@@ -1,120 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { extractContractSchema } from '../contract-schema/index.mjs';
-import { isInErrorBranch } from './response-contract-error-branch.mjs';
-import { containsResponseMarker, noContentContract, registerContract, responseBodyExpression, sourceLocation, } from './response-contract-registration.mjs';
-import { streamingTextMediaType } from './response-contract-media.mjs';
-import { nextImplicitVariantKey } from './response-contract-implicit-variants.mjs';
-import { markBufferedRouteUnavailable, registerRouteContract, } from './response-contract-lenient.mjs';
-import { enclosingRouteBinding, isContextMethod, requestedKeyForBinding, responseMarker, } from './response-contract-route-analysis.mjs';
-import { resolveEmissionStatus } from './response-contract-status.mjs';
-import { opaqueHttpResponse, unsupportedContextResponse, supportedResponseContext, } from './protocol-http-association.mjs';
-import { contextResponseMethod } from './protocol-http-context.mjs';
-import { taintRouteKeys, markRouteTaint, isSseSetter } from './protocol-http-implicit-taint.mjs';
-export function discoverImplicitContract(call, checker, sourceFile, contracts, handlerBindings, callLabel, requestedKeys, options) {
-    const opaqueResponse = opaqueHttpResponse(call, checker);
-    const binding = enclosingRouteBinding(call, checker, handlerBindings, !opaqueResponse);
-    if (!binding)
-        return;
-    const key = requestedKeyForBinding(binding, requestedKeys);
-    const taintKeys = taintRouteKeys(contracts, binding, key);
-    if (!taintKeys.length)
-        return;
-    const context = supportedResponseContext(call, checker);
-    const bracketResponse = context &&
-        (ts.isElementAccessExpression(call.expression) ||
-            (ts.isPropertyAccessExpression(call.expression) &&
-                ts.isElementAccessExpression(call.expression.expression))) &&
-        contextResponseMethod(call.expression, context, checker);
-    const mutableResponse = unsupportedContextResponse(call, checker);
-    const sseSetter = isSseSetter(contracts, binding, bracketResponse || undefined);
-    if (opaqueResponse ||
-        mutableResponse ||
-        (bracketResponse && !sseSetter && !containsResponseMarker(call))) {
-        markRouteTaint(contracts, taintKeys, binding, sourceLocation(sourceFile, call), !!mutableResponse &&
-            !!context &&
-            !!contextResponseMethod(call.expression, context, checker, true));
-        return;
-    }
-    if (!key)
-        return;
-    const body = responseBodyExpression(call);
-    if (body) {
-        if (ts.isCallExpression(body) && responseMarker(body.expression))
-            return;
-        if (requestedKeys && contracts.has(key))
-            return;
-        if (isInErrorBranch(call))
-            return;
-        const location = sourceLocation(sourceFile, call);
-        const extract = () => extractContractSchema(checker.getTypeAtLocation(body), checker, location, options);
-        const status = resolveEmissionStatus(call);
-        const emission = {
-            bodyKind: 'content',
-            mediaType: 'application/json',
-            mediaTypeKnowledge: 'known',
-            ...status,
-        };
-        // Keep primary extraction failures unavailable in both full and subset discovery.
-        if (requestedKeys || !contracts.has(key)) {
-            registerRouteContract(contracts, key, binding, location, emission, extract, options);
-            return;
-        }
-        // Preserve every additional unmarked body under a deterministic variant key, including
-        // unavailable secondary extractions. Route grouping merges these without hiding a branch.
-        registerRouteContract(contracts, nextImplicitVariantKey(contracts, key), binding, location, emission, extract, options);
-        return;
-    }
-    if (callLabel === 'ctx.response.xml()') {
-        if (requestedKeys && contracts.has(key))
-            return;
-        const body = call.arguments[0];
-        const location = sourceLocation(sourceFile, call);
-        registerRouteContract(contracts, contracts.has(key) ? nextImplicitVariantKey(contracts, key) : key, binding, location, {
-            bodyKind: 'content',
-            mediaType: 'application/xml',
-            mediaTypeKnowledge: 'known',
-            ...resolveEmissionStatus(call),
-        }, () => extractContractSchema(checker.getTypeAtLocation(body), checker, location, options), options);
-        return;
-    }
-    const streamedTextMediaType = isContextMethod(call.expression, 'pipeline')
-        ? streamingTextMediaType(call)
-        : undefined;
-    if (streamedTextMediaType) {
-        const location = sourceLocation(sourceFile, call);
-        registerRouteContract(contracts, contracts.has(key) ? nextImplicitVariantKey(contracts, key) : key, binding, location, {
-            bodyKind: 'content',
-            mediaType: streamedTextMediaType,
-            mediaTypeKnowledge: 'known',
-            ...resolveEmissionStatus(call),
-        }, () => extractContractSchema(checker.getStringType(), checker, location, options), options);
-        return;
-    }
-    // Empty branches must not hide any unmarked buffer or pipeline body.
-    if (callLabel === 'ctx.response.buffer()' ||
-        (callLabel === 'ctx.pipeline()' && !body && !containsResponseMarker(call))) {
-        markBufferedRouteUnavailable(contracts, key, binding, sourceLocation(sourceFile, call));
-        return;
-    }
-    if (requestedKeys && contracts.has(key))
-        return;
-    const emissionStatus = resolveEmissionStatus(call);
-    const isExplicitNoContentCall = (isContextMethod(call.expression, 'setStatus') &&
-        call.arguments[0] &&
-        ts.isNumericLiteral(call.arguments[0]) &&
-        (call.arguments[0].text === '204' || call.arguments[0].text === '205')) ||
-        callLabel === 'ctx.response.empty()';
-    if (isExplicitNoContentCall) {
-        registerContract(contracts, contracts.has(key) ? nextImplicitVariantKey(contracts, key) : key, {
-            ...noContentContract(sourceLocation(sourceFile, call)),
-            ...binding,
-            bodyKind: 'none',
-            mediaTypeKnowledge: 'none',
-            ...(emissionStatus.statusCodes ? { statusCodes: emissionStatus.statusCodes } : {}),
-            statusKnowledge: emissionStatus.statusKnowledge,
-            ...(emissionStatus.unavailableReason
-                ? { unavailableReason: emissionStatus.unavailableReason }
-                : {}),
-        });
-    }
-}