@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

package/dist/compiler/wsdlPolicyRequirements.js

@@ -0,0 +1,239 @@
+/** Source-owned WS-Policy requirements; recognition never grants transport or message-security admission. */
+import { assertLoadedSchemaInput } from '../loader/schemaInput.js';
+import { syntaxAttribute, syntaxElements, isXmlNCName, WSDL_NAMESPACE } from '../loader/orderedSyntax.js';
+import { normalizeWhitespace } from './datatypeValues.js';
+export const POLICY_12 = 'http://schemas.xmlsoap.org/ws/2004/09/policy';
+export const SECURITY_POLICY_11 = 'http://schemas.xmlsoap.org/ws/2005/07/securitypolicy';
+const WSU = 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd';
+const suites = ['Basic256', 'Basic192', 'Basic128', 'TripleDes', 'Basic256Rsa15', 'Basic192Rsa15', 'Basic128Rsa15',
+    'TripleDesRsa15', 'Basic256Sha256', 'Basic192Sha256', 'Basic128Sha256', 'TripleDesSha256',
+    'Basic256Sha256Rsa15', 'Basic192Sha256Rsa15', 'Basic128Sha256Rsa15', 'TripleDesSha256Rsa15'];
+const layouts = ['Strict', 'Lax', 'LaxTsFirst', 'LaxTsLast'];
+const issued = new WeakMap();
+class Stop extends Error {
+    result;
+    constructor(result) {
+        super(result.rule);
+        this.result = result;
+    }
+}
+/** Authenticate the exact loaded snapshot; copied reports or source-shaped records confer no policy authority. */
+export function assertWsdlPolicyRequirements(input, value) {
+    assertLoadedSchemaInput(input);
+    if (issued.get(value) !== input)
+        throw new TypeError('Fresh source-bound WSDL policy requirements required');
+}
+/** Interpret a closed single-alternative HTTPS transport-policy fragment and same-document binding references.
+ * @remarks Unknown assertions, external/nested references, multiple alternatives/attachments and digest references
+ *   remain explicit refusals. No policy fetch, endpoint permission, algorithm execution or security-header emission occurs.
+ *   The July 2005 defaults are Lax layout and no timestamp. Client-certificate omission is outside this qualified fragment.
+ * @returns Source-owned requirements or an explicit unsupported/invalid/resource result; enforcement remains false.
+ * @throws TypeError For unauthenticated source or foreign binding inspection. Caller cancellation propagates unchanged.
+ * @see https://www.w3.org/submissions/WS-Policy/
+ * @see https://specs.xmlsoap.org/ws/2005/07/securitypolicy/ws-securitypolicy.pdf
+ */
+export function prepareWsdlPolicyRequirements(input, budget, check) {
+    assertLoadedSchemaInput(input);
+    return budget.guard(() => {
+        const fail = (node, rule, kind = 'unsupported') => {
+            budget.chargeWork(64 + rule.length);
+            throw new Stop(Object.freeze({ kind, rule, source: node.source }));
+        };
+        const elements = (node) => {
+            check();
+            budget.chargeWork(32 + node.children.length * 8 + node.attributes.length * 16);
+            for (const child of node.children)
+                if (child.kind === 'text' && /[^\t\r\n ]/.test(child.value))
+                    fail(node, 'policy-text', 'invalid-schema');
+            return syntaxElements(node);
+        };
+        const attrs = (node, allowed = [], id = false) => {
+            for (const attribute of node.attributes) {
+                check();
+                budget.chargeWork(32 + attribute.value.length * 4);
+                if (attribute.name.namespace === '' && allowed.includes(attribute.name.local))
+                    continue;
+                if (id && attribute.name.namespace === WSU && attribute.name.local === 'Id')
+                    continue;
+                fail(node, 'policy-attribute');
+            }
+        };
+        const is = (node, namespace, local) => node.name.namespace === namespace && node.name.local === local;
+        // Framework flattening is iterative and refuses choice instead of guessing an alternative.
+        const assertions = (policy) => {
+            const pending = [policy], result = [];
+            while (pending.length) {
+                check();
+                const node = pending.pop();
+                if (node.name.namespace === POLICY_12 && ['Policy', 'All', 'ExactlyOne'].includes(node.name.local)) {
+                    attrs(node, [], node === policy && node.name.local === 'Policy');
+                    const children = elements(node);
+                    if (node.name.local === 'ExactlyOne' && children.length !== 1)
+                        fail(node, 'policy-alternatives');
+                    for (let i = children.length - 1; i >= 0; i--) {
+                        check();
+                        pending.push(children[i]);
+                    }
+                }
+                else {
+                    if (node.name.namespace === POLICY_12)
+                        fail(node, 'nested-policy-reference-or-operator');
+                    result.push(node);
+                }
+            }
+            return result;
+        };
+        const nested = (node) => {
+            attrs(node);
+            const children = elements(node);
+            if (children.length !== 1 || !is(children[0], POLICY_12, 'Policy'))
+                return fail(node, 'nested-policy-required');
+            return assertions(children[0]);
+        };
+        const leaf = (node) => { attrs(node); if (elements(node).length)
+            fail(node, 'policy-leaf-content'); };
+        const transport = (node) => {
+            const parts = nested(node), byName = new Map();
+            for (const part of parts) {
+                check();
+                if (part.name.namespace !== SECURITY_POLICY_11 || !['TransportToken', 'AlgorithmSuite', 'Layout', 'IncludeTimestamp'].includes(part.name.local))
+                    fail(part, 'transport-policy-assertion');
+                if (byName.has(part.name.local))
+                    fail(part, 'duplicate-transport-property', 'invalid-schema');
+                byName.set(part.name.local, part);
+            }
+            const token = byName.get('TransportToken'), suite = byName.get('AlgorithmSuite');
+            if (!token || !suite)
+                return fail(node, 'transport-token-and-algorithm-suite-required', 'invalid-schema');
+            const tokens = nested(token);
+            if (tokens.length !== 1 || !is(tokens[0], SECURITY_POLICY_11, 'HttpsToken'))
+                return fail(token, 'transport-token-kind');
+            const https = tokens[0];
+            attrs(https, ['RequireClientCertificate']);
+            if (elements(https).length)
+                fail(https, 'https-token-additional-policy');
+            const certificate = syntaxAttribute(https, 'RequireClientCertificate');
+            if (certificate === undefined)
+                return fail(https, 'https-token-client-certificate-default-unqualified');
+            const lexical = normalizeWhitespace(certificate, 'collapse');
+            if (!['true', '1', 'false', '0'].includes(lexical))
+                fail(https, 'https-token-client-certificate-boolean', 'invalid-schema');
+            const algorithms = nested(suite);
+            if (algorithms.length !== 1 || algorithms[0].name.namespace !== SECURITY_POLICY_11 || !suites.some(name => name === algorithms[0].name.local))
+                return fail(suite, 'algorithm-suite');
+            leaf(algorithms[0]);
+            let layout = 'Lax';
+            const layoutNode = byName.get('Layout');
+            if (layoutNode) {
+                const selected = nested(layoutNode);
+                if (selected.length !== 1 || selected[0].name.namespace !== SECURITY_POLICY_11 || !layouts.some(name => name === selected[0].name.local))
+                    return fail(layoutNode, 'security-header-layout');
+                leaf(selected[0]);
+                layout = selected[0].name.local;
+            }
+            const timestamp = byName.get('IncludeTimestamp');
+            if (timestamp)
+                leaf(timestamp);
+            budget.chargeWork(128);
+            return Object.freeze({ kind: 'https-transport', requireClientCertificate: lexical === 'true' || lexical === '1',
+                algorithmSuite: algorithms[0].name.local, layout, includeTimestamp: timestamp !== undefined,
+                source: node.source, enforced: false });
+        };
+        try {
+            const metadata = new Set(), bindings = new Map();
+            const none = Object.freeze({ kind: 'none' });
+            for (const document of input.documents) {
+                check();
+                if (!is(document.root, WSDL_NAMESPACE, 'definitions'))
+                    continue;
+                const ids = new Map(), pending = [document.root];
+                while (pending.length) {
+                    check();
+                    const node = pending.pop(), lexicalId = syntaxAttribute(node, 'Id', WSU);
+                    if (lexicalId !== undefined) {
+                        budget.chargeWork(32 + lexicalId.length * 4);
+                        const id = normalizeWhitespace(lexicalId, 'collapse');
+                        if (!isXmlNCName(id) || ids.has(id))
+                            fail(node, 'policy-id-uniqueness', 'invalid-schema');
+                        ids.set(id, node);
+                    }
+                    for (const child of syntaxElements(node)) {
+                        check();
+                        pending.push(child);
+                    }
+                }
+                const policies = new Map();
+                const parse = (policy) => {
+                    const cached = policies.get(policy);
+                    if (cached)
+                        return cached;
+                    const leaves = assertions(policy);
+                    if (leaves.length > 1)
+                        return fail(policy, 'policy-assertion-combination');
+                    if (leaves.length && !is(leaves[0], SECURITY_POLICY_11, 'TransportBinding'))
+                        return fail(leaves[0], 'policy-assertion');
+                    const result = leaves.length ? transport(leaves[0]) : none;
+                    policies.set(policy, result);
+                    return result;
+                };
+                for (const node of syntaxElements(document.root))
+                    if (is(node, POLICY_12, 'Policy')) {
+                        parse(node);
+                        metadata.add(node);
+                    }
+                for (const binding of syntaxElements(document.root, WSDL_NAMESPACE, 'binding')) {
+                    const attachments = syntaxElements(binding).filter(node => node.name.namespace === POLICY_12);
+                    if (attachments.length > 1)
+                        fail(binding, 'multiple-policy-attachments');
+                    let result = none;
+                    for (const attachment of attachments) {
+                        if (is(attachment, POLICY_12, 'Policy'))
+                            result = parse(attachment);
+                        else if (is(attachment, POLICY_12, 'PolicyReference')) {
+                            attrs(attachment, ['URI']);
+                            if (elements(attachment).length)
+                                fail(attachment, 'policy-reference-content');
+                            const uri = syntaxAttribute(attachment, 'URI');
+                            if (!uri?.startsWith('#'))
+                                return fail(attachment, 'external-policy-reference');
+                            if (new URL(attachment.baseUri).href.split('#')[0] !== new URL(document.uri).href.split('#')[0])
+                                return fail(attachment, 'external-policy-reference');
+                            let id;
+                            try {
+                                id = decodeURIComponent(uri.slice(1));
+                            }
+                            catch {
+                                return fail(attachment, 'policy-reference-fragment', 'invalid-schema');
+                            }
+                            const target = ids.get(id);
+                            if (!target || !is(target, POLICY_12, 'Policy'))
+                                return fail(attachment, 'policy-reference-target', 'invalid-schema');
+                            if (!metadata.has(target))
+                                return fail(attachment, 'policy-reference-placement');
+                            result = parse(target);
+                        }
+                        else
+                            return fail(attachment, 'policy-attachment');
+                        metadata.add(attachment);
+                    }
+                    bindings.set(binding, result);
+                }
+            }
+            const owner = Object.freeze({ kind: 'wsdl-policy-requirements', admitted: false,
+                isPolicyMetadata(node) { return metadata.has(node); },
+                forBinding(binding) {
+                    const value = bindings.get(binding);
+                    if (!value)
+                        throw new TypeError('Original source binding required for policy requirements');
+                    return value;
+                } });
+            issued.set(owner, input);
+            return owner;
+        }
+        catch (error) {
+            if (error instanceof Stop)
+                return error.result;
+            throw error;
+        }
+    });
+}

package/dist/config.d.ts

@@ -64,4 +64,3 @@ export declare function resolveCompilerOptions(input: Partial<CompilerOptions>,
     wsdl: string;
     out: string;
 }): CompilerOptions;
-//# sourceMappingURL=config.d.ts.map

package/dist/gateway/generateCheckedGateway.d.ts

@@ -0,0 +1,32 @@
+import type { ReconstructedComponentSource } from '../compiler/directSourceCapsule.js';
+interface CheckedGatewayOptions {
+    /** Internal non-writing preparation; native qualification and lowering still run. */
+    readonly emit?: boolean;
+    readonly clientDir: string;
+    readonly gatewayDir: string;
+    readonly openapiFile: string;
+    readonly routePath: string;
+    readonly signal?: AbortSignal;
+}
+/** Lower component mappings through the existing checked gateway emitter, retaining native supplemental validation. */
+export declare function generateComponentGateway(expected: ReconstructedComponentSource, options: CheckedGatewayOptions): Promise<{
+    doc: unknown;
+    emit: () => Promise<void>;
+}>;
+/** Compose per-operation checked routers without merging native source, service or binding identities.
+ * @returns One OpenAPI document and exact operation-to-route mapping, both descriptions rather than authority.
+ * @throws For mixed native handles, invalid/colliding paths, cancellation or filesystem failures.
+ */
+export declare function generateComponentServiceGateway(expected: readonly ReconstructedComponentSource[], options: {
+    clientDir: string;
+    gatewayDir: string;
+    openapiFile: string;
+    basePath: string;
+    signal?: AbortSignal;
+    emit?: boolean;
+}): Promise<{
+    doc: unknown;
+    routes: Readonly<Record<string, string>>;
+    emit: () => Promise<void>;
+}>;
+export {};

package/dist/gateway/generateCheckedGateway.js

@@ -0,0 +1,293 @@
+/**
+ * Lowers issued direct mappings into HTTP documentation and a checked gateway.
+ * @since 1.1.6
+ * @constraints Serialized descriptions never issue native source or execution authority.
+ */
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { componentSourceCapsuleBytes, inspectReconstructedComponentSource, inspectComponentSourceService } from '../compiler/directSourceCapsule.js';
+import { lowerComponentShape } from '../generation/componentShape.js';
+import { checkSemanticBudget } from '../compiler/semanticBudget.js';
+import { inspectDirectOperation } from '../compiler/directOperation.js';
+import { inspectComponentValueMapping } from '../compiler/directValues.js';
+import { composeGeneratedSource, resolvePreamble } from '../generation/preamble.js';
+const draft07 = 'http://json-schema.org/draft-07/schema#';
+/** Lower component mappings through the existing checked gateway emitter, retaining native supplemental validation. */
+export async function generateComponentGateway(expected, options) {
+    inspectReconstructedComponentSource(expected);
+    return generateGatewayFromReconstruction(expected, options);
+}
+async function generateGatewayFromReconstruction(expected, options) {
+    if (options.signal?.aborted)
+        throw new Error('Checked gateway generation cancelled');
+    inspectReconstructedComponentSource(expected);
+    const capsule = { bytes: componentSourceCapsuleBytes(expected, options.signal) };
+    const runtime = 'checkedComponentRuntimeV1';
+    if (!options.routePath.startsWith('/') || options.routePath.split('/').slice(1)
+        .some(segment => !segment || !/^(?:[A-Za-z0-9._~-]|%[0-9A-Fa-f]{2})+$/.test(segment))) {
+        throw new TypeError('Checked routePath requires literal nonempty path segments');
+    }
+    const input = expected.mappings.find(mapping => mapping.direction.kind === 'input');
+    const output = expected.mappings.find(mapping => mapping.direction.kind === 'output');
+    if (!input || !output)
+        throw new TypeError('Issued input and output mappings required');
+    const schema = (mapping, role) => {
+        const { budget } = inspectDirectOperation(expected.contract).context;
+        return lowerComponentShape(expected.contract, mapping, role, () => {
+            checkSemanticBudget(budget);
+            if (options.signal?.aborted)
+                throw new Error('Checked gateway generation cancelled');
+        }).schema;
+    };
+    const request = schema(input, 'Request'), response = schema(output, 'Response');
+    const faults = expected.mappings.filter(mapping => mapping.direction.kind === 'fault').map(mapping => {
+        if (mapping.direction.kind !== 'fault')
+            throw new TypeError('Declared fault mapping required');
+        return { name: mapping.direction.name, value: schema(mapping, `Fault_${expected.mappings.filter(item => item.direction.kind === 'fault').indexOf(mapping)}`) };
+    });
+    const faultVariants = faults.map(fault => ({
+        type: 'object', additionalProperties: false, required: ['fault', 'value'],
+        properties: {
+            value: fault.value,
+            fault: {
+                type: 'object', additionalProperties: false, required: ['name', 'code', 'string'],
+                properties: {
+                    name: { const: fault.name }, string: { type: 'string' }, actor: { type: 'string' },
+                    code: { type: 'object', additionalProperties: false, required: ['namespace', 'local'],
+                        properties: { namespace: { type: 'string' }, local: { type: 'string' } } },
+                },
+            },
+        },
+    }));
+    const fault = faultVariants.length ? { oneOf: faultVariants } : { not: {} };
+    const schemas = { request: { $schema: draft07, ...request }, response: { $schema: draft07, ...response }, fault: { $schema: draft07, ...fault } };
+    const grouped = expected.mappings.some(mapping => mapping.kind === 'component-mapping'
+        && inspectComponentValueMapping(mapping, expected.contract).applicationGroups);
+    const components = Object.create(null);
+    const documented = (value, dictionary = false) => {
+        if (Array.isArray(value))
+            return value.map(item => documented(item));
+        if (!value || typeof value !== 'object')
+            return value;
+        const record = value, result = Object.create(null);
+        // @why Property names belong to the application; definitions and $id are keywords only at schema nodes.
+        if (dictionary) {
+            for (const [key, item] of Object.entries(record))
+                result[key] = documented(item);
+            return result;
+        }
+        if (Object.hasOwn(record, 'definitions'))
+            for (const [key, definition] of Object.entries(record.definitions)) {
+                const resolved = documented(definition);
+                if (components[key] && JSON.stringify(components[key]) !== JSON.stringify(resolved))
+                    throw new TypeError(`applicationGroups OpenAPI component collision ${key}`);
+                components[key] = resolved;
+            }
+        for (const [key, item] of Object.entries(record)) {
+            if (key === 'definitions' || key === '$id')
+                continue;
+            result[key] = ['const', 'enum', 'default', 'examples'].includes(key) ? item
+                : key === '$ref' && typeof item === 'string' && item.startsWith('#/definitions/') ? item.replace('#/definitions/', '#/components/schemas/')
+                    : documented(item, ['properties', 'patternProperties', 'dependencies', 'dependentSchemas'].includes(key));
+        }
+        return result;
+    };
+    const documentation = grouped ? { request: documented(request), response: documented(response), fault: documented(fault) } : { request, response, fault };
+    const doc = {
+        openapi: '3.1.1', jsonSchemaDialect: 'https://json-schema.org/draft/2020-12/schema',
+        info: { title: expected.selection.service.local, version: '1.0.0' },
+        ...(grouped ? { components: { schemas: components } } : {}),
+        'x-checked-model': { model: 'checked-components-v1', scope: 'native-component-structured-soap11',
+            ...(expected.responseProjection
+                ? { responseProjection: { spec: expected.responseProjection.spec, delivery: 'buffered', retainedValue: 'complete-companion-payload' } } : {}),
+            documentationDialect: '2020-12', runtimeDialect: 'draft-07', jsonShapeComplete: false,
+            supplementalValidation: ['native-source-compatibility', 'native-xml-scalar-and-particle'], admitted: false,
+            selection: { selector: expected.contract.selector, ...expected.selection } },
+        paths: { [options.routePath]: { post: { operationId: expected.contract.selector.operation,
+                    ...(expected.responseProjection
+                        ? { 'x-response-projection': { spec: expected.responseProjection.spec, delivery: 'buffered', retainedValue: 'complete-companion-payload' } } : {}),
+                    requestBody: { required: true, content: { 'application/json': { schema: documentation.request } } },
+                    responses: { '200': { description: 'Independently validated SOAP response', content: { 'application/json': { schema: documentation.response } } },
+                        '400': { description: 'Invalid HTTP request; no SOAP request is dispatched' },
+                        '502': { description: 'Declared SOAP fault or refused upstream response', content: { 'application/json': { schema: { oneOf: [documentation.fault,
+                                            { type: 'object', additionalProperties: false, required: ['kind', 'rule'], properties: { kind: { type: 'string' }, rule: { type: 'string' } } }] } } } },
+                        '500': { description: 'Incompatible artifacts or gateway configuration' } } } } },
+    };
+    let clientImport = path.relative(options.gatewayDir, path.join(options.clientDir, 'client.js')).replace(/\\/g, '/');
+    if (!clientImport.startsWith('.'))
+        clientImport = './' + clientImport;
+    const literal = (value) => JSON.stringify(value).replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+    // language=TypeScript
+    const body = `import type {FastifyPluginAsync} from 'fastify';
+import {Ajv} from 'ajv';
+import {types} from 'node:util';
+import {${runtime}} from '@techspokes/typescript-wsdl-client';
+import {createClient, expectedCapsuleBase64, type Options, type Request} from ${literal(clientImport)};
+
+export interface CheckedGatewayOptions { readonly clientOptions: Options }
+// @constraints JSON parsing preserves XML names such as __proto__ as ordinary own data properties.
+export const schemas = JSON.parse(${literal(JSON.stringify(schemas))}) as {request: Record<string, unknown>; response: Record<string, unknown>; fault: Record<string, unknown>};
+export const expectedOpenApiJson = ${literal(JSON.stringify(doc))};
+
+// @constraints Read only data properties before composing per-request cancellation.
+function dataCopy<T extends object>(value: T): T {
+  if (!value || typeof value !== 'object' || types.isProxy(value)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(value) as object | null)) throw new TypeError('Data-only checked gateway options required');
+  const copy: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key)!;
+    if (typeof key !== 'string' || !Object.hasOwn(descriptor, 'value')) throw new TypeError('Data-only checked gateway options required');
+    copy[key] = descriptor.value;
+  }
+  return copy as T;
+}
+
+const plugin: FastifyPluginAsync<CheckedGatewayOptions> = async (fastify, options) => {
+  if (expectedCapsuleBase64 !== ${literal(Buffer.from(capsule.bytes).toString('base64'))}) throw new Error('incompatible-artifact: generated gateway/client mismatch; regenerate the complete project');
+  const client = createClient(${runtime});
+  const ajv = new Ajv({coerceTypes: false, useDefaults: false, removeAdditional: false, ownProperties: true, strict: true, allErrors: true});
+  const validateRequest = ajv.compile(schemas.request);
+  const validateResponse = ajv.compile(schemas.response);
+  const validateFault = ajv.compile(schemas.fault);
+  const base = dataCopy(options.clientOptions);
+  const soap = dataCopy(base.soap);
+  fastify.post(${literal(options.routePath)}, {
+    schema: {body: schemas.request},
+    validatorCompiler: () => validateRequest,
+    // @constraints Serialization preserves every validated member and never establishes validity.
+    serializerCompiler: () => value => JSON.stringify(value),
+  }, async (request, reply) => {
+    const controller = new AbortController();
+    const disconnected = () => {if (!reply.raw.writableEnded) controller.abort();};
+    request.raw.once('aborted', disconnected);
+    reply.raw.once('close', disconnected);
+    if (request.raw.aborted || reply.raw.destroyed) controller.abort();
+    try {
+      const signal = soap.signal ? AbortSignal.any([soap.signal, controller.signal]) : controller.signal;
+      const result = await client[${literal(expected.contract.selector.operation)}](request.body as Request,
+        {...base, soap: {...soap, signal}});
+      if (result.kind === 'soap-response') {
+        if (!validateResponse(result.value)) return reply.code(502).send({kind: 'value-invalid', rule: 'http-response-shape'});
+        return reply.type('application/json').serializer(value => JSON.stringify(value)).send(result.value);
+      }
+      if (result.kind === 'soap-fault') {
+        const fault = {name: result.fault.name, code: {namespace: result.fault.code.namespace, local: result.fault.code.local},
+          string: result.fault.string, ...(result.fault.actor === undefined ? {} : {actor: result.fault.actor})};
+        const value = {fault, value: result.value};
+        if (!validateFault(value)) return reply.code(502).send({kind: 'value-invalid', rule: 'http-fault-shape'});
+        return reply.code(502).type('application/json').serializer(value => JSON.stringify(value)).send(value);
+      }
+      const status = result.kind === 'incompatible-artifact' || result.kind === 'missing-authority' ? 500
+        : result.kind === 'cancelled' ? 499 : result.phase === 'input' ? 400 : 502;
+      return reply.code(status).send({kind: result.kind, rule: result.rule});
+    } finally {
+      request.raw.removeListener('aborted', disconnected);
+      reply.raw.removeListener('close', disconnected);
+    }
+  });
+};
+export default plugin;
+`;
+    if (options.signal?.aborted)
+        throw new Error('Checked gateway generation cancelled');
+    const source = composeGeneratedSource(body, resolvePreamble('gateway'));
+    const emit = async () => {
+        inspectReconstructedComponentSource(expected);
+        checkSemanticBudget(inspectDirectOperation(expected.contract).context.budget);
+        if (options.signal?.aborted)
+            throw new Error('Checked gateway generation cancelled');
+        await mkdir(options.gatewayDir, { recursive: true });
+        await mkdir(path.dirname(options.openapiFile), { recursive: true });
+        await writeFile(path.join(options.gatewayDir, 'plugin.ts'), source, 'utf8');
+        await writeFile(path.join(options.gatewayDir, 'schemas.json'), JSON.stringify(schemas, null, 2) + '\n', 'utf8');
+        await writeFile(options.openapiFile, JSON.stringify(doc, null, 2) + '\n', 'utf8');
+    };
+    if (options.emit !== false)
+        await emit();
+    return { doc, emit };
+}
+/** Compose per-operation checked routers without merging native source, service or binding identities.
+ * @returns One OpenAPI document and exact operation-to-route mapping, both descriptions rather than authority.
+ * @throws For mixed native handles, invalid/colliding paths, cancellation or filesystem failures.
+ */
+export async function generateComponentServiceGateway(expected, options) {
+    const operations = inspectComponentSourceService(expected), routes = Object.create(null);
+    const paths = Object.create(null);
+    const documents = [];
+    const emissions = [];
+    const tick = () => {
+        checkSemanticBudget(inspectDirectOperation(operations[0].contract).context.budget);
+        if (options.signal?.aborted)
+            throw new Error('Checked gateway generation cancelled');
+    };
+    for (const [index, operation] of operations.entries()) {
+        tick();
+        const name = operation.contract.selector.operation, routePath = `${options.basePath}/${encodeURIComponent(name)}`;
+        const result = await generateComponentGateway(operation, { clientDir: path.join(options.clientDir, 'operations', String(index)),
+            gatewayDir: path.join(options.gatewayDir, 'routes', String(index)), openapiFile: path.join(options.gatewayDir, 'routes', String(index), 'openapi.json'), routePath, signal: options.signal, emit: false });
+        emissions.push(result.emit);
+        const doc = result.doc;
+        documents.push(doc);
+        routes[name] = routePath;
+        for (const [route, value] of Object.entries(doc.paths)) {
+            if (Object.hasOwn(paths, route))
+                throw new TypeError('Duplicate checked route');
+            paths[route] = value;
+        }
+    }
+    const { responseProjection: firstProjection, ...serviceModel } = documents[0]['x-checked-model'];
+    void firstProjection;
+    const componentSchemas = Object.create(null);
+    for (const document of documents) {
+        const schemas = document.components?.schemas ?? {};
+        for (const [name, schema] of Object.entries(schemas)) {
+            if (componentSchemas[name] && JSON.stringify(componentSchemas[name]) !== JSON.stringify(schema))
+                throw new TypeError(`applicationGroups OpenAPI component collision ${name}`);
+            componentSchemas[name] = schema;
+        }
+    }
+    const doc = { ...documents[0], ...(Object.keys(componentSchemas).length ? { components: { schemas: componentSchemas } } : {}), 'x-checked-model': { ...serviceModel,
+            selection: { service: operations[0].selection.service, port: operations[0].selection.port,
+                selectors: operations.map(operation => operation.contract.selector) } }, paths };
+    let clientImport = path.relative(options.gatewayDir, path.join(options.clientDir, 'client.js')).replaceAll('\\', '/');
+    if (!clientImport.startsWith('.'))
+        clientImport = './' + clientImport;
+    const literal = (value) => JSON.stringify(value).replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+    const names = operations.map(operation => operation.contract.selector.operation);
+    const lines = ["import type {FastifyPluginAsync} from 'fastify';", "import {types} from 'node:util';",
+        `import type {Options} from ${literal(clientImport)};`,
+        ...operations.map((_, index) => `import operation_${index} from './routes/${index}/plugin.js';`),
+        'export interface CheckedGatewayOptions {readonly clientOptions: Options; readonly capsules: Readonly<Record<string, Uint8Array>>}',
+        `export const expectedOpenApiJson = ${literal(JSON.stringify(doc))};`,
+        'function data(value: unknown, allowed: readonly string[]): Record<string, unknown> {',
+        "  if (!value || typeof value !== 'object' || types.isProxy(value) || ![null, Object.prototype].includes(Object.getPrototypeOf(value) as object | null)) throw new TypeError('Data-only service options required');",
+        '  const result: Record<string, unknown> = Object.create(null) as Record<string, unknown>;',
+        '  for (const key of Reflect.ownKeys(value)) {',
+        '    const descriptor = Object.getOwnPropertyDescriptor(value, key)!;',
+        "    if (typeof key !== 'string' || !allowed.includes(key) || !Object.hasOwn(descriptor, 'value')) throw new TypeError('Unsupported service option');",
+        '    result[key] = descriptor.value;', '  }', '  return result;', '}',
+        'const plugin: FastifyPluginAsync<CheckedGatewayOptions> = async (fastify, options) => {',
+        "  const outer = data(options, ['clientOptions', 'capsules', 'prefix']);",
+        "  const clientOptions = data(outer.clientOptions, ['localSource', 'fileRoots', 'sourceResources', 'sourceOrigins', 'sourceUri', 'namespaceLocations', 'standardLibraries', 'recordSources', 'soap']) as unknown as Options;",
+        `  const capsules = data(outer.capsules, ${literal(names)});`,
+        ...operations.map((operation, index) => `  if (!Object.hasOwn(capsules, ${literal(operation.contract.selector.operation)})) throw new TypeError('Missing operation capsule');
+  await fastify.register(operation_${index}, {clientOptions: {...clientOptions, capsule: capsules[${literal(operation.contract.selector.operation)}] as Uint8Array}});`),
+        '};', 'export default plugin;', '',
+    ];
+    tick();
+    const source = composeGeneratedSource(lines.join('\n'), resolvePreamble('gateway'));
+    const emit = async () => {
+        tick();
+        for (const write of emissions) {
+            tick();
+            await write();
+        }
+        await mkdir(options.gatewayDir, { recursive: true });
+        await mkdir(path.dirname(options.openapiFile), { recursive: true });
+        await writeFile(path.join(options.gatewayDir, 'plugin.ts'), source, 'utf8');
+        await writeFile(options.openapiFile, JSON.stringify(doc, null, 2) + '\n', 'utf8');
+    };
+    if (options.emit !== false)
+        await emit();
+    return { doc, routes: Object.freeze(routes), emit };
+}

package/dist/gateway/generateGateway.d.ts

@@ -83,4 +83,3 @@ export interface GenerateGatewayOptions {
  * });
  */
 export declare function generateGateway(opts: GenerateGatewayOptions): Promise<void>;
-//# sourceMappingURL=generateGateway.d.ts.map

package/dist/gateway/generators.d.ts

@@ -170,4 +170,3 @@ export declare function emitTypeCheckFixture(outDir: string, clientMeta: ClientM
  * @param {any} [catalog] - Compiled catalog for detecting ArrayOf* wrapper types to unwrap
  */
 export declare function emitRouteFilesWithHandlers(outDir: string, routesDir: string, versionSlug: string, serviceSlug: string, operations: OperationMetadata[], importsMode: "js" | "ts" | "bare", clientMeta: ClientMeta, catalog?: any): void;
-//# sourceMappingURL=generators.d.ts.map

package/dist/gateway/helpers.d.ts

@@ -256,4 +256,3 @@ export declare function resolveOperationMeta(operationId: string, operationSlug:
  * @returns Number of unique schema components reachable via $ref
  */
 export declare function measureSchemaRefComplexity(startSchemaName: string, allSchemas: Record<string, any>, limit?: number): number;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/generation/componentShape.d.ts

@@ -0,0 +1,14 @@
+import type { DirectOperationContract } from '../compiler/directOperation.js';
+type Schema = Record<string, unknown>;
+/** Lower an authenticated mapping to recursive TypeScript and JSON shape descriptions.
+ * @remarks Scalar restrictions, fixed/default semantics, ordered occurrence correlation and strict wildcard
+ *   declaration membership require native validation. These descriptions never grant source/runtime authority.
+ * @returns Role-scoped definitions and root descriptions; no native handles or retrieval paths are emitted.
+ * @throws TypeError For foreign mappings or unsupported scalar representation. Caller cancellation propagates.
+ */
+export declare function lowerComponentShape(contract: DirectOperationContract, supplied: unknown, role: string, check: () => void): {
+    type: string;
+    declarations: readonly string[];
+    schema: Schema;
+};
+export {};