@openapi-flow/n8n 0.0.0-stage → 0.3.0

package/dist/nodes/native/registry/resolve-native-feature-registry.js

@@ -0,0 +1,99 @@
+import { N8nNativeFeature } from '../../../types/native-feature-registry.js';
+import { n8nNativeFeatureSelectionSchema } from '../../../schemas/native-feature-registry-schema.js';
+import { nativeFeatureDefinitions } from './native-feature-definitions.js';
+import { validateNativeFeatureContext } from './validate-native-feature-context.js';
+/** No model calls, fabricated contracts, source discovery or automatic registration retries. */
+export function resolveNativeFeatureRegistry(input, mode) {
+    validateNativeFeatureContext(input);
+    const selection = n8nNativeFeatureSelectionSchema.safeParse(input.features === undefined
+        ? Object.values(N8nNativeFeature)
+        : input.features);
+    if (!selection.success)
+        throw new Error('native features.features is invalid', {
+            cause: selection.error,
+        });
+    const registrations = selection.data.map((feature) => {
+        const definition = nativeFeatureDefinitions[feature];
+        if (!definition)
+            throw new Error(`native feature ${feature} has no registered factory`);
+        const missingContext = definition.requirements
+            .filter((requirement) => {
+            if (requirement.field === 'jsonOutput')
+                return input.jsonOutput === undefined;
+            const materials = input[requirement.field];
+            return (materials === undefined ||
+                materials.length < requirement.minimumItems);
+        })
+            .map((requirement) => ({ ...requirement }));
+        if (missingContext.length) {
+            if (mode === 'materials' && input.features !== undefined) {
+                const requiredFields = missingContext
+                    .map((requirement) => requirement.field === 'jsonOutput'
+                    ? requirement.field
+                    : `${requirement.field} (at least ${requirement.minimumItems})`)
+                    .join(', ');
+                throw new Error(`native feature ${feature} requires ${requiredFields}`);
+            }
+            return { feature, status: 'requires-context', missingContext };
+        }
+        const capability = definition.create(input);
+        if (feature !== N8nNativeFeature.JsonOutput &&
+            capability.name !== feature)
+            throw new Error(`native feature ${feature} factory changed its identity`);
+        return { feature, status: 'ready', capability };
+    });
+    const capabilities = [
+        ...registrations.flatMap((registration) => registration.status === 'ready' ? [registration.capability] : []),
+        ...(input.extensions === undefined ? [] : input.extensions),
+    ];
+    const planningRegistrations = registrations.flatMap((registration) => {
+        if (registration.status === 'ready')
+            return [
+                {
+                    feature: registration.feature,
+                    capability: registration.capability,
+                },
+            ];
+        if (mode === 'materials')
+            return [];
+        const factory = nativeFeatureDefinitions[registration.feature].createPlanning;
+        return factory === undefined
+            ? []
+            : [
+                {
+                    feature: registration.feature,
+                    capability: factory({ itemMode: input.itemMode }),
+                },
+            ];
+    });
+    const planningCapabilities = [
+        ...planningRegistrations.map((entry) => entry.capability),
+        ...(input.extensions === undefined ? [] : input.extensions),
+    ];
+    const names = new Set();
+    for (const capability of planningCapabilities) {
+        if (!capability ||
+            typeof capability.name !== 'string' ||
+            !capability.name.trim() ||
+            typeof capability.description !== 'string' ||
+            !capability.description.trim() ||
+            !capability.parametersSchema ||
+            typeof capability.parametersSchema.safeParse !== 'function' ||
+            typeof capability.compile !== 'function' ||
+            typeof capability.inputPorts !== 'function' ||
+            typeof capability.outputPorts !== 'function' ||
+            typeof capability.responseReferences !== 'function' ||
+            typeof capability.waitsForAllInputs !== 'boolean' ||
+            typeof capability.exclusiveOutputPorts !== 'boolean')
+            throw new Error('native features requires complete named capability implementations');
+        if (names.has(capability.name))
+            throw new Error(`native features contains duplicate capability ${capability.name}`);
+        names.add(capability.name);
+    }
+    return {
+        registrations,
+        capabilities,
+        planningCapabilities,
+        planningRegistrations,
+    };
+}

package/dist/nodes/native/registry/validate-native-feature-context.d.ts

@@ -0,0 +1,2 @@
+import type { ResolveN8nNativeFeaturesInput } from '../../../types/native-feature-registry.js';
+export declare function validateNativeFeatureContext(input: ResolveN8nNativeFeaturesInput): void;

package/dist/nodes/native/registry/validate-native-feature-context.js

@@ -0,0 +1,46 @@
+import { validateNativeOutputContracts } from '@openapi-flow/core';
+import { nativeItemExecutionOptionsSchema } from '../../../schemas/native-feature-registry-schema.js';
+export function validateNativeFeatureContext(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        throw new Error('native features input must be an object');
+    const execution = nativeItemExecutionOptionsSchema.safeParse({
+        itemMode: input.itemMode,
+    });
+    if (!execution.success)
+        throw new Error('native features.itemMode must be linked or omitted', {
+            cause: execution.error,
+        });
+    if (input.apiMaterials !== undefined) {
+        if (!Array.isArray(input.apiMaterials))
+            throw new Error('native features.apiMaterials must be an array');
+        const ids = new Set();
+        for (const material of input.apiMaterials) {
+            if (!material ||
+                typeof material.callId !== 'string' ||
+                !material.callId.trim() ||
+                ids.has(material.callId) ||
+                !material.operation ||
+                material.operation.source !== 'paths')
+                throw new Error('native features.apiMaterials requires unique callIds and resolved OAS operation contracts');
+            ids.add(material.callId);
+        }
+    }
+    if (input.nativeOutputSources !== undefined) {
+        validateNativeOutputContracts(input.nativeOutputSources);
+        if (input.nativeOutputSources.some((source) => typeof source.nodeName !== 'string' || !source.nodeName.trim()))
+            throw new Error('native features.nativeOutputSources requires actual compiled nodeName values');
+    }
+    if (input.jsonOutput !== undefined) {
+        const output = input.jsonOutput;
+        if (!output ||
+            typeof output.name !== 'string' ||
+            !output.name.trim() ||
+            typeof output.description !== 'string' ||
+            !output.description.trim() ||
+            !output.parametersSchema ||
+            typeof output.parametersSchema.safeParse !== 'function')
+            throw new Error('native features.jsonOutput requires name, description and a Zod parametersSchema');
+    }
+    if (input.extensions !== undefined && !Array.isArray(input.extensions))
+        throw new Error('native features.extensions must be an array');
+}

package/dist/nodes/native/response-array-definition.d.ts

@@ -0,0 +1,2 @@
+import type { NativeMaterialFeatureDefinition } from '../../types/native-material-binding.js';
+export declare const responseArrayDefinition: NativeMaterialFeatureDefinition;

package/dist/nodes/native/response-array-definition.js

@@ -0,0 +1,27 @@
+import { responseArrayParametersSchema } from '../../schemas/response-array-schema.js';
+export const responseArrayDefinition = {
+    name: 'split-api-response-array',
+    materialRequirements: [{ field: 'apiMaterials', minimumItems: 1 }],
+    description: 'Split a declared OAS response array into one unchanged JSON item per element using n8n Split Out. Output is {item: element}. Downstream bound requests must use linked item mode. An empty array creates no downstream items.',
+    parametersSchema: responseArrayParametersSchema,
+    parameterReferenceSources: ['response'],
+    inputPorts: () => ['main'],
+    outputPorts: () => ['main'],
+    referenceStructureSchema: responseArrayParametersSchema,
+    parameterReferenceBindings: (values) => {
+        const parameters = responseArrayParametersSchema.parse(values);
+        return [
+            {
+                nodeIdPointer: '/sourceNodeId',
+                valuePointer: '/pointer',
+                reference: {
+                    source: 'response',
+                    nodeId: parameters.sourceNodeId,
+                    pointer: parameters.pointer,
+                },
+            },
+        ];
+    },
+    waitsForAllInputs: false,
+    exclusiveOutputPorts: false,
+};

package/dist/nodes/native/response-assertion-capability.d.ts

@@ -0,0 +1,2 @@
+import type { N8nNativeCapability, NativeItemExecutionOptions } from '../../types/native-capability.js';
+export declare function createResponseAssertionCapability(input?: NativeItemExecutionOptions): N8nNativeCapability;

package/dist/nodes/native/response-assertion-capability.js

@@ -0,0 +1,57 @@
+import { node } from '@n8n/workflow-sdk';
+import { assertionParametersSchema } from '../../schemas/native-capability-schemas.js';
+import { createAssertionPlanningParametersSchema } from '../../schemas/create-native-comparison-planning-schema.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+import { responseReferences } from './common/response-references.js';
+import { responseReferenceBindings } from './common/response-reference-bindings.js';
+import { responseCheckCode } from './response-check-code.js';
+import { createResponseCheckReader } from './response-checks/create-response-check-reader.js';
+export function createResponseAssertionCapability(input = {}) {
+    return {
+        name: 'assert-responses',
+        description: 'n8n Code: library-generated JSON comparisons. main input/output. Returns pass/assertionCount on success and can be the final node; no separate success/end node is needed. Failed checks throw their message and fail the workflow, without a failure output port. Join branches before comparing their responses.',
+        parametersSchema: assertionParametersSchema,
+        parameterReferenceSources: ['response'],
+        createPlanningParametersSchema: createAssertionPlanningParametersSchema,
+        inputPorts: () => ['main'],
+        outputPorts: () => ['main'],
+        responseReferences: (parameters) => responseReferences(assertionParametersSchema.parse(parameters).checks),
+        parameterReferenceBindings: (parameters) => responseReferenceBindings(assertionParametersSchema.parse(parameters).checks, '/checks'),
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        compile: ({ planned, apiNodeNames, apiResponseContracts, singletonApiResponseIds, position, }) => {
+            const parameters = assertionParametersSchema.parse(planned.parameters);
+            const reader = createResponseCheckReader({
+                nodeId: planned.id,
+                checks: parameters.checks,
+                apiNodeNames,
+                apiResponseContracts,
+                singletonApiResponseIds,
+                linked: input.itemMode === 'linked',
+            });
+            const checkCode = `${responseCheckCode(reader.code)}\nconst checks = ${JSON.stringify(parameters.checks)};\nfor (const check of checks) if (!compare(check)) throw new Error(check.message);`;
+            const code = input.itemMode === 'linked'
+                ? `return $input.all().map((_,inputIndex)=>{${checkCode}\nreturn {json:{pass:true,assertionCount:checks.length},pairedItem:{item:inputIndex}};});`
+                : `${checkCode}\nreturn [{json: {pass: true, assertionCount: checks.length}}];`;
+            const fragment = createNativeFragment(node({
+                type: 'n8n-nodes-base.code',
+                version: 2,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position,
+                    parameters: {
+                        mode: 'runOnceForAllItems',
+                        language: 'javaScript',
+                        jsCode: code,
+                    },
+                },
+            }), ['main'], ['main']);
+            return {
+                ...fragment,
+                preservesInputItems: input.itemMode === 'linked',
+                bindingSources: reader.bindingSources,
+            };
+        },
+    };
+}

package/dist/nodes/native/response-check-code.d.ts

@@ -0,0 +1,3 @@
+import type { NativeCheck } from '../../types/native-capability.js';
+export declare function responseCheckCode(responseReaderCode: string): string;
+export declare function conditionExpression(check: NativeCheck, names: Record<string, string>, linked?: boolean, singletonApiResponseIds?: string[]): string;

package/dist/nodes/native/response-check-code.js

@@ -0,0 +1,65 @@
+import { javascriptJsonLiteral } from '../../utils/javascript-json-literal.js';
+import { responseReferences } from './common/response-references.js';
+import { createOutputItemReaderCode } from '../request/bindings/create-output-item-reader-code.js';
+/** Library-owned runtime, shared by IF expressions and assertion Code nodes. */
+function responseCheckRuntime() {
+    return `
+function read(operand) {
+  if (operand.source === 'literal') return operand.value;
+  if (!Object.hasOwn(responses, operand.nodeId) || responses[operand.nodeId] === undefined)
+    throw new Error('Missing response body: ' + operand.nodeId);
+  let value = responses[operand.nodeId];
+  if (operand.pointer === '') return value;
+  for (const encoded of operand.pointer.slice(1).split('/')) {
+    const key = encoded.replace(/~1/g, '/').replace(/~0/g, '~');
+    if (value === null || typeof value !== 'object' || !Object.hasOwn(value, key))
+      throw new Error('Missing response pointer: ' + operand.nodeId + operand.pointer);
+    value = value[key];
+  }
+  return value;
+}
+function equal(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every(key => Object.hasOwn(b, key) && equal(a[key], b[key]));
+}
+function compare(check) {
+  const left = read(check.left), right = read(check.right);
+  switch (check.operator) {
+    case 'equals': return equal(left, right);
+    case 'notEquals': return !equal(left, right);
+    case 'keysEqual':
+      if (left === null || right === null || typeof left !== 'object' || typeof right !== 'object' || Array.isArray(left) || Array.isArray(right))
+        throw new Error('keysEqual requires objects');
+      return equal(Object.keys(left).sort(), Object.keys(right).sort());
+    case 'greaterThan': case 'lessThan':
+      if (typeof left !== 'number' || typeof right !== 'number') throw new Error('Numeric comparison requires numbers');
+      return check.operator === 'greaterThan' ? left > right : left < right;
+    default: throw new Error('Unknown comparison operator');
+  }
+}`;
+}
+export function responseCheckCode(responseReaderCode) {
+    return `${responseReaderCode}\n${responseCheckRuntime()}`;
+}
+export function conditionExpression(check, names, linked = false, singletonApiResponseIds = []) {
+    const sources = responseReferences([check]).map((ref) => ({
+        nodeId: ref.nodeId,
+        nodeName: names[ref.nodeId],
+        singleton: singletonApiResponseIds.includes(ref.nodeId),
+    }));
+    // The preceding Code guard validates full responses. Keep IF expressions small.
+    const reader = `const sources=${javascriptJsonLiteral(sources)};
+const responses=Object.create(null);
+for (const source of sources) {
+  ${createOutputItemReaderCode(linked)}
+  const envelope=item;
+  if (!envelope || !envelope.json || !Object.hasOwn(envelope.json, 'body'))
+    throw new Error('Missing response body: '+source.nodeId);
+  responses[source.nodeId]=envelope.json.body;
+}
+`;
+    return `={{ (() => { ${linked ? 'const inputIndex=$itemIndex;' : ''}${responseCheckCode(reader)}; return compare(${javascriptJsonLiteral(check)}); })() }}`;
+}

package/dist/nodes/native/response-checks/create-response-check-guard.d.ts

@@ -0,0 +1,4 @@
+import type { CreateResponseCheckGuardInput } from '../../../types/response-check-guard.js';
+import type { N8nSdkNode } from '../../../types/node-fragment.js';
+/** Validate in Code, not inside n8n's expression-delimited IF parameter. */
+export declare function createResponseCheckGuard({ nodeId, readerCode, linked, position, }: CreateResponseCheckGuardInput): N8nSdkNode;

package/dist/nodes/native/response-checks/create-response-check-guard.js

@@ -0,0 +1,22 @@
+import { node } from '@n8n/workflow-sdk';
+/** Validate in Code, not inside n8n's expression-delimited IF parameter. */
+export function createResponseCheckGuard({ nodeId, readerCode, linked, position, }) {
+    const forward = 'return {...item,pairedItem:{item:inputIndex}};';
+    const code = linked
+        ? `return $input.all().map((item,inputIndex)=>{${readerCode}\n${forward}});`
+        : `${readerCode}\nreturn $input.all().map((item,inputIndex)=>{${forward}});`;
+    return node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: `${nodeId}-response-contract`,
+            name: `Validate responses ${nodeId}`,
+            position: [position[0] - 220, position[1]],
+            parameters: {
+                mode: 'runOnceForAllItems',
+                language: 'javaScript',
+                jsCode: code,
+            },
+        },
+    });
+}

package/dist/nodes/native/response-checks/create-response-check-reader.d.ts

@@ -0,0 +1,3 @@
+import type { CreateResponseCheckReaderInput, CompiledResponseCheckReader } from '../../../types/response-check-compilation.js';
+/** Reuse full OAS response validation before native comparisons, without changing data. */
+export declare function createResponseCheckReader({ nodeId, checks, apiNodeNames, apiResponseContracts, singletonApiResponseIds, linked, }: CreateResponseCheckReaderInput): CompiledResponseCheckReader;

package/dist/nodes/native/response-checks/create-response-check-reader.js

@@ -0,0 +1,23 @@
+import { readFileSync } from 'node:fs';
+import { responseReferences } from '../common/response-references.js';
+import { createOutputReaderCode } from '../../request/bindings/create-output-reader-code.js';
+/** Reuse full OAS response validation before native comparisons, without changing data. */
+export function createResponseCheckReader({ nodeId, checks, apiNodeNames, apiResponseContracts, singletonApiResponseIds, linked, }) {
+    const ids = [...new Set(responseReferences(checks).map((ref) => ref.nodeId))];
+    const bindingSources = ids.map((id) => {
+        const operation = apiResponseContracts?.[id];
+        if (!operation)
+            throw new Error(`native node ${nodeId}: apiResponseContracts is missing ${id}`);
+        const nodeName = apiNodeNames[id];
+        if (typeof nodeName !== 'string' || !nodeName.trim())
+            throw new Error(`native node ${nodeId}: apiNodeNames is missing ${id}`);
+        return { kind: 'api-response', nodeId: id, nodeName, operation };
+    });
+    if (!bindingSources.length)
+        return { code: 'const responses=Object.create(null);', bindingSources };
+    const runtime = readFileSync(new URL('../../request/runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
+    return {
+        code: `${runtime}\n${createOutputReaderCode(bindingSources, linked, singletonApiResponseIds)}`,
+        bindingSources,
+    };
+}

package/dist/nodes/native/response-collection-definition.d.ts

@@ -0,0 +1,2 @@
+import type { NativeMaterialFeatureDefinition } from '../../types/native-material-binding.js';
+export declare const responseCollectionDefinition: NativeMaterialFeatureDefinition;

package/dist/nodes/native/response-collection-definition.js

@@ -0,0 +1,27 @@
+import { responseCollectionParametersSchema } from '../../schemas/response-collection-schema.js';
+export const responseCollectionDefinition = {
+    name: 'collect-api-responses',
+    materialRequirements: [{ field: 'apiMaterials', minimumItems: 1 }],
+    description: 'Collect unchanged item-linked API response values from one incoming stream into {items: values} using n8n Aggregate. Validates each full OAS response first. Preserves null, nested arrays, duplicates and received order. Not a branch join. Empty streams do not trigger this node or create an artificial result.',
+    parametersSchema: responseCollectionParametersSchema,
+    parameterReferenceSources: ['response'],
+    inputPorts: () => ['main'],
+    outputPorts: () => ['main'],
+    referenceStructureSchema: responseCollectionParametersSchema,
+    parameterReferenceBindings: (values) => {
+        const parameters = responseCollectionParametersSchema.parse(values);
+        return [
+            {
+                nodeIdPointer: '/sourceNodeId',
+                valuePointer: '/pointer',
+                reference: {
+                    source: 'response',
+                    nodeId: parameters.sourceNodeId,
+                    pointer: parameters.pointer,
+                },
+            },
+        ];
+    },
+    waitsForAllInputs: false,
+    exclusiveOutputPorts: false,
+};

package/dist/nodes/native/stop-and-error-capability.d.ts

@@ -0,0 +1,2 @@
+import type { N8nNativeCapability } from '../../types/native-capability.js';
+export declare function createStopAndErrorCapability(): N8nNativeCapability;

package/dist/nodes/native/stop-and-error-capability.js

@@ -0,0 +1,43 @@
+import { node } from '@n8n/workflow-sdk';
+import { resolveNativeStructureParameters } from '@openapi-flow/core';
+import { stopParametersSchema } from '../../schemas/native-capability-schemas.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+import { prependNativeParameterGuard } from './inputs/prepend-native-parameter-guard.js';
+export function createStopAndErrorCapability() {
+    const capability = {
+        name: 'stop-and-error',
+        description: 'n8n StopAndError: main input, no outputs. Fail the workflow with an explicit message.',
+        parametersSchema: stopParametersSchema,
+        parameterReferenceSources: [],
+        supportsRuntimeParameters: true,
+        inputPorts: () => ['main'],
+        outputPorts: () => [],
+        responseReferences: () => [],
+        parameterReferenceBindings: () => [],
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        compile: (source) => {
+            const { planned, position } = source;
+            resolveNativeStructureParameters(planned, capability);
+            const fragment = createNativeFragment(node({
+                type: 'n8n-nodes-base.stopAndError',
+                version: 1,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position,
+                    parameters: {
+                        errorType: 'errorMessage',
+                        errorMessage: planned.runtimeParameters !== undefined
+                            ? '={{ $json.message }}'
+                            : stopParametersSchema.parse(planned.parameters).message,
+                    },
+                },
+            }), ['main'], []);
+            return planned.runtimeParameters !== undefined
+                ? prependNativeParameterGuard({ input: source, capability, fragment })
+                : fragment;
+        },
+    };
+    return capability;
+}

package/dist/nodes/request/authentication/credential-field-name.d.ts

@@ -0,0 +1 @@
+export declare function looksLikeCredential(name: string): boolean;

package/dist/nodes/request/authentication/credential-field-name.js

@@ -0,0 +1,3 @@
+export function looksLikeCredential(name) {
+    return /(token|secret|password|authorization|api.?key)/i.test(name);
+}

package/dist/nodes/request/authentication/resolve-http-request-authentication.d.ts

@@ -0,0 +1,2 @@
+import type { HttpRequestAuthenticationMapping, ResolveHttpRequestAuthenticationInput } from '../../../types/authentication.js';
+export declare function resolveHttpRequestAuthentication(input: ResolveHttpRequestAuthenticationInput): HttpRequestAuthenticationMapping | undefined;

package/dist/nodes/request/authentication/resolve-http-request-authentication.js

@@ -0,0 +1,42 @@
+import { resolveOpenApiSecurity } from '@openapi-flow/core';
+import { UnsupportedOperationError } from '@openapi-flow/core/internal';
+export function resolveHttpRequestAuthentication(input) {
+    const contract = input.operation;
+    const selected = resolveOpenApiSecurity({
+        operationRef: contract.key.operationRef,
+        security: contract.effective.security,
+        securitySchemes: contract.effective.securitySchemes,
+        requirementIndex: input.securityRequirementIndex,
+    });
+    if (!selected || !selected.schemes.length)
+        return undefined;
+    if (selected.schemes.length !== 1)
+        throw new UnsupportedOperationError(contract.key.operationRef, `${contract.key.operationRef}: combined security schemes require a separate composite credential mapping`);
+    const { name, definition, scopes } = selected.schemes[0];
+    if (definition.type === 'http') {
+        const scheme = String(definition.scheme).toLowerCase();
+        if (scheme === 'bearer')
+            return { schemeName: name, credentialType: 'httpBearerAuth' };
+        if (scheme === 'basic')
+            return { schemeName: name, credentialType: 'httpBasicAuth' };
+        if (scheme === 'digest')
+            return { schemeName: name, credentialType: 'httpDigestAuth' };
+    }
+    if (definition.type === 'apiKey' &&
+        ['header', 'query'].includes(String(definition.in))) {
+        if (typeof definition.name !== 'string' || !definition.name.trim())
+            throw new Error(`${contract.key.operationRef}.securitySchemes.${name}.name is required`);
+        return {
+            schemeName: name,
+            credentialType: definition.in === 'header' ? 'httpHeaderAuth' : 'httpQueryAuth',
+            credentialRequirements: `OAS ${name}: configure the credential ${definition.in} Name as ${JSON.stringify(definition.name)}. The workflow contains only a credential reference; the stored secret and Name are owned by n8n.`,
+        };
+    }
+    if (definition.type === 'oauth2')
+        return {
+            schemeName: name,
+            credentialType: 'oAuth2Api',
+            credentialRequirements: `OAS ${name}: use an existing OAuth2 credential configured for the declared flows and required scopes ${JSON.stringify(scopes)}. This compiler does not create grants, invent tokens or verify the stored credential configuration.`,
+        };
+    throw new UnsupportedOperationError(contract.key.operationRef, `${contract.key.operationRef}.securitySchemes.${name}: ${definition.type}/${definition.scheme ?? definition.in ?? ''} has no implemented HTTP Request credential mapping`);
+}

package/dist/nodes/request/bindings/compile-native-output-validators.d.ts

@@ -0,0 +1,3 @@
+import type { N8nOutputBindingSource } from '../../../types/output-binding-source.js';
+/** Every producer retains its own schema resource root and reference scope. */
+export declare function compileNativeOutputValidators(sources: N8nOutputBindingSource[]): string;

package/dist/nodes/request/bindings/compile-native-output-validators.js

@@ -0,0 +1,12 @@
+import { compileStandaloneValidator } from '../../common/validation/compile-standalone-validator.js';
+/** Every producer retains its own schema resource root and reference scope. */
+export function compileNativeOutputValidators(sources) {
+    return sources
+        .map((source, index) => source.kind === 'native-json'
+        ? compileStandaloneValidator({
+            schema: source.schema,
+            globalName: `OpenApiFlowNativeOutputValidator${index}`,
+        })
+        : '')
+        .join('\n');
+}

package/dist/nodes/request/bindings/compile-request-validator.d.ts

@@ -0,0 +1,3 @@
+import type { RequestMaterializationConfig } from '../../../types/request-materialization.js';
+/** Compile OAS schemas on the host; n8n receives no schema compiler/eval. */
+export declare function compileRequestValidator(config: RequestMaterializationConfig, globalName?: string): string;

package/dist/nodes/request/bindings/compile-request-validator.js

@@ -0,0 +1,13 @@
+import { createApiRequestSchema } from '@openapi-flow/core';
+import { compileStandaloneValidator } from '../../common/validation/compile-standalone-validator.js';
+/** Compile OAS schemas on the host; n8n receives no schema compiler/eval. */
+export function compileRequestValidator(config, globalName = 'OpenApiFlowRequestValidator') {
+    const schema = createApiRequestSchema({
+        operation: config.contract,
+        requestMediaType: config.arguments.requestMediaType,
+    });
+    return compileStandaloneValidator({
+        schema,
+        globalName,
+    });
+}

package/dist/nodes/request/bindings/compile-source-response-validators.d.ts

@@ -0,0 +1,2 @@
+import type { N8nOutputBindingSource } from '../../../types/output-binding-source.js';
+export declare function compileSourceResponseValidators(sources: N8nOutputBindingSource[]): string;

package/dist/nodes/request/bindings/compile-source-response-validators.js

@@ -0,0 +1,12 @@
+import { createApiResponseSchema } from '@openapi-flow/core';
+import { compileStandaloneValidator } from '../../common/validation/compile-standalone-validator.js';
+export function compileSourceResponseValidators(sources) {
+    return sources
+        .map((source, index) => source.kind === 'api-response' && source.operation
+        ? compileStandaloneValidator({
+            schema: createApiResponseSchema({ operation: source.operation }),
+            globalName: `OpenApiFlowResponseValidator${index}`,
+        })
+        : '')
+        .join('\n');
+}

package/dist/nodes/request/bindings/create-bound-request-fragment.d.ts

@@ -0,0 +1,3 @@
+import type { CreateBoundHttpRequestNodeInput, N8nNodeFragment } from '../../../types/node-fragment.js';
+import type { RequestMaterializationConfig } from '../../../types/request-materialization.js';
+export declare function createBoundRequestFragment(input: CreateBoundHttpRequestNodeInput, config: RequestMaterializationConfig): N8nNodeFragment;