vouchington-tooling 0.35.0 → 0.36.1

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 }
-                : {}),
-        });
-    }
-}

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

@@ -1,41 +0,0 @@
-import type { ExtractedResponseContract, ExtractContractSchemaOptions } from '../contract-schema/index.mts';
-import type { RouteBinding } from './response-contract-route-analysis.mts';
-import type { BackendResponseContract } from './response-contract-types.mts';
-export type RouteDiscoveryError = {
-    method: string;
-    routeTemplate: string;
-    source: string;
-    reason: string;
-};
-/**
- * A response emitter found in a named handler registered for multiple routes. `sourceLocation`
- * is a normalized source path followed by one-based line and column; `routes` contains unique,
- * lexically sorted `METHOD:path` keys. `label` identifies the implicit response form.
- */
-export type AmbiguousAttributionFact = {
-    sourceLocation: string;
-    label: string;
-    routes: readonly string[];
-};
-export type DiscoverApiResponseContractsOptions = ExtractContractSchemaOptions & {
-    onRouteError?: (error: RouteDiscoveryError) => void;
-    /**
-     * Opt in to response-attribution facts from the existing discovery pass. Facts are delivered
-     * after discovery succeeds, ordered by normalized source location; each callback receives its
-     * own copy of the sorted route list. Dynamic error payloads paired with a non-literal status are
-     * excluded from these facts; discovery output keeps its existing behavior. Consumers choose
-     * whether a fact needs a diagnostic or policy.
-     */
-    onAmbiguousAttribution?: (fact: AmbiguousAttributionFact) => void;
-};
-/** Marks `key` unavailable regardless of AST visit order, for a route that can send a raw buffered body (e.g. a proxied MCP response) alongside a no-content branch. */
-export declare function markBufferedRouteUnavailable(contracts: Map<string, BackendResponseContract>, key: string, binding: RouteBinding, source: string): void;
-/**
- * Extracts a route's response contract and registers it. When `options.onRouteError` is
- * set, an extraction failure is caught, reported, and replaced with an `unavailable`
- * placeholder instead of aborting discovery for every other route. With `options` absent
- * (or `onRouteError` unset), behavior is unchanged: extraction failures throw.
- */
-export declare function registerRouteContract(contracts: Map<string, BackendResponseContract>, key: string, binding: RouteBinding, location: string, emission: Pick<BackendResponseContract, 'bodyKind' | 'mediaType' | 'mediaTypeKnowledge' | 'statusCodes' | 'statusKnowledge'> & {
-    unavailableReason?: string;
-}, extract: () => ExtractedResponseContract, options: DiscoverApiResponseContractsOptions | undefined): void;

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

@@ -1,52 +0,0 @@
-import { hashContractSchema } from '../contract-schema/index.mjs';
-import { registerContract } from './response-contract-registration.mjs';
-/** Placeholder contract for a route whose response type could not be extracted. */
-function unavailableContract(source, reason) {
-    const schema = { root: { type: 'unknown' }, definitions: {} };
-    return { source, schema, hash: hashContractSchema(schema), unavailableReason: reason };
-}
-/** Marks `key` unavailable regardless of AST visit order, for a route that can send a raw buffered body (e.g. a proxied MCP response) alongside a no-content branch. */
-export function markBufferedRouteUnavailable(contracts, key, binding, source) {
-    contracts.set(key, {
-        ...unavailableContract(source, 'route can send a raw buffered response body (ctx.response.buffer) whose shape is not statically determinable'),
-        ...binding,
-        bodyKind: 'content',
-        statusKnowledge: 'unknown',
-        mediaTypeKnowledge: 'unknown',
-    });
-}
-/**
- * Extracts a route's response contract and registers it. When `options.onRouteError` is
- * set, an extraction failure is caught, reported, and replaced with an `unavailable`
- * placeholder instead of aborting discovery for every other route. With `options` absent
- * (or `onRouteError` unset), behavior is unchanged: extraction failures throw.
- */
-export function registerRouteContract(contracts, key, binding, location, emission, extract, options) {
-    let extracted;
-    try {
-        if (emission.unavailableReason)
-            throw new Error(emission.unavailableReason);
-        extracted = extract();
-    }
-    catch (error) {
-        if (!options?.onRouteError)
-            throw error;
-        const reason = error instanceof Error ? error.message : String(error);
-        options.onRouteError({
-            method: binding.method,
-            routeTemplate: binding.routeTemplate,
-            source: location,
-            reason,
-        });
-        extracted = unavailableContract(location, reason);
-    }
-    registerContract(contracts, key, {
-        ...extracted,
-        ...binding,
-        ...(emission.bodyKind ? { bodyKind: emission.bodyKind } : {}),
-        ...(emission.mediaType ? { mediaType: emission.mediaType } : {}),
-        ...(emission.mediaTypeKnowledge ? { mediaTypeKnowledge: emission.mediaTypeKnowledge } : {}),
-        ...(emission.statusCodes ? { statusCodes: emission.statusCodes } : {}),
-        ...(emission.statusKnowledge ? { statusKnowledge: emission.statusKnowledge } : {}),
-    });
-}

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

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function isXmlResponseCall(call: ts.CallExpression): boolean;
-export declare function streamingTextMediaType(call: ts.CallExpression): 'application/xml' | 'text/csv' | undefined;

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

@@ -1,46 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { isContextMethod } from './response-contract-route-analysis.mjs';
-export function isXmlResponseCall(call) {
-    const expression = call.expression;
-    return (ts.isPropertyAccessExpression(expression) &&
-        expression.name.text === 'xml' &&
-        isContextMethod(expression.expression, 'response'));
-}
-export function streamingTextMediaType(call) {
-    let statement = call;
-    while (!ts.isStatement(statement))
-        statement = statement.parent;
-    const contentType = precedingContentType(statement);
-    return contentType === 'unsupported' ? undefined : contentType;
-}
-function precedingContentType(statement) {
-    const block = statement.parent;
-    if (!ts.isBlock(block))
-        return undefined;
-    const index = block.statements.indexOf(statement);
-    for (let i = index - 1; i >= 0; i--) {
-        const contentType = contentTypeStatement(block.statements[i]);
-        if (contentType)
-            return contentType;
-    }
-    const enclosing = block.parent;
-    return ts.isStatement(enclosing) ? precedingContentType(enclosing) : undefined;
-}
-function contentTypeStatement(statement) {
-    if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression))
-        return undefined;
-    const setter = statement.expression;
-    if (!isContextMethod(setter.expression, 'set'))
-        return undefined;
-    const [name, value] = setter.arguments;
-    if (!name || !ts.isStringLiteral(name) || name.text.toLowerCase() !== 'content-type')
-        return undefined;
-    if (!value || !ts.isStringLiteral(value))
-        return 'unsupported';
-    const contentType = value.text.toLowerCase();
-    if (contentType.startsWith('text/csv'))
-        return 'text/csv';
-    if (contentType.startsWith('application/xml'))
-        return 'application/xml';
-    return 'unsupported';
-}

package/dist/api-contract-discovery/response-contract-object-symbols.d.mts

@@ -1,3 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-export declare function propertyImplementationSymbol(access: ts.PropertyAccessExpression, checker: ts.TypeChecker): ts.Symbol | undefined;
-export declare function destructuredPropertyImplementationSymbol(declaration: ts.BindingElement, checker: ts.TypeChecker): ts.Symbol | undefined;

package/dist/api-contract-discovery/response-contract-object-symbols.mjs

@@ -1,80 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-export function propertyImplementationSymbol(access, checker) {
-    const contextual = checker.getSymbolAtLocation(access.name);
-    const receiver = unwrapTransparentExpression(access.expression);
-    if (!contextual || !ts.isIdentifier(receiver))
-        return undefined;
-    const receiverSymbol = checker.getSymbolAtLocation(receiver);
-    const declaration = receiverSymbol?.valueDeclaration;
-    if (!declaration || !ts.isVariableDeclaration(declaration))
-        return contextual;
-    if (!declaration.initializer ||
-        !ts.isVariableDeclarationList(declaration.parent) ||
-        !(declaration.parent.flags & ts.NodeFlags.Const))
-        return undefined;
-    return constObjectPropertySymbol(receiver, access.name.text, checker);
-}
-export function destructuredPropertyImplementationSymbol(declaration, checker) {
-    const pattern = declaration.parent;
-    if (!ts.isObjectBindingPattern(pattern) || !ts.isIdentifier(declaration.name))
-        return undefined;
-    const variable = pattern.parent;
-    if (!ts.isVariableDeclaration(variable) ||
-        !variable.initializer ||
-        !ts.isVariableDeclarationList(variable.parent) ||
-        !(variable.parent.flags & ts.NodeFlags.Const))
-        return undefined;
-    if (declaration.dotDotDotToken || declaration.initializer)
-        return undefined;
-    const property = declaration.propertyName ?? declaration.name;
-    if (!ts.isIdentifier(property) && !ts.isStringLiteral(property))
-        return undefined;
-    const initializer = unwrapTransparentExpression(variable.initializer);
-    return ts.isIdentifier(initializer)
-        ? constObjectPropertySymbol(initializer, property.text, checker)
-        : undefined;
-}
-function constObjectPropertySymbol(receiver, key, checker, seen = new Set()) {
-    const receiverSymbol = checker.getSymbolAtLocation(receiver);
-    if (!receiverSymbol || seen.has(receiverSymbol))
-        return undefined;
-    seen.add(receiverSymbol);
-    const declaration = receiverSymbol.valueDeclaration;
-    if (!declaration ||
-        !ts.isVariableDeclaration(declaration) ||
-        !declaration.initializer ||
-        !ts.isVariableDeclarationList(declaration.parent) ||
-        !(declaration.parent.flags & ts.NodeFlags.Const))
-        return undefined;
-    const initializer = unwrapTransparentExpression(declaration.initializer);
-    if (ts.isIdentifier(initializer))
-        return constObjectPropertySymbol(initializer, key, checker, seen);
-    if (!ts.isObjectLiteralExpression(initializer))
-        return undefined;
-    if (initializer.properties.some(ts.isSpreadAssignment))
-        return undefined;
-    const implementation = initializer.properties.findLast((property) => {
-        const name = property.name;
-        return objectLiteralPropertyName(name) === key;
-    });
-    if (implementation && ts.isPropertyAssignment(implementation)) {
-        const value = unwrapTransparentExpression(implementation.initializer);
-        if (ts.isIdentifier(value))
-            return checker.getSymbolAtLocation(value);
-    }
-    if (implementation &&
-        (ts.isGetAccessorDeclaration(implementation) || ts.isSetAccessorDeclaration(implementation)))
-        return undefined;
-    return implementation?.name && checker.getSymbolAtLocation(implementation.name);
-}
-function objectLiteralPropertyName(name) {
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
-        return name.text;
-    if (!ts.isComputedPropertyName(name))
-        return undefined;
-    const expression = unwrapTransparentExpression(name.expression);
-    return ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)
-        ? expression.text
-        : undefined;
-}

package/dist/api-contract-discovery/response-contract-property-mutations.d.mts

@@ -1,5 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/** Direct syntactic property writes are excluded; indirect mutation is outside this proof. */
-export declare function findMutatedProperties(sourceFiles: readonly ts.SourceFile[], checker: ts.TypeChecker): Set<ts.Symbol>;
-/** Direct identifier and destructuring writes are excluded; indirect writes are unproven. */
-export declare function findMutatedBindings(sourceFiles: readonly ts.SourceFile[], checker: ts.TypeChecker): Set<ts.Symbol>;