@openapi-flow/n8n 0.2.0 → 0.3.1

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

@@ -0,0 +1,93 @@
+import { createIfCapability } from '../if-capability.js';
+import { createMergeAppendCapability } from '../merge-append-capability.js';
+import { createResponseAssertionCapability } from '../response-assertion-capability.js';
+import { createStopAndErrorCapability } from '../stop-and-error-capability.js';
+import { createPassThroughCapability } from '../create-pass-through-capability.js';
+import { createExclusiveBranchMergeCapability } from '../create-exclusive-branch-merge-capability.js';
+import { createJsonOutputCapability } from '../create-json-output-capability.js';
+import { createResponseArrayCapability } from '../create-response-array-capability.js';
+import { createResponseCollectionCapability } from '../create-response-collection-capability.js';
+import { createNativeArrayCapability } from '../arrays/create-native-array-capability.js';
+import { createItemJoinCapability } from '../item-join/create-item-join-capability.js';
+import { createBoundNativeArrayCapability } from '../arrays/create-bound-native-array-capability.js';
+import { createBoundItemJoinCapability } from '../item-join/create-bound-item-join-capability.js';
+import { createMaterialPlanningCapability } from '../common/create-material-planning-capability.js';
+import { responseArrayDefinition } from '../response-array-definition.js';
+import { responseCollectionDefinition } from '../response-collection-definition.js';
+import { nativeArrayDefinition } from '../arrays/native-array-definition.js';
+import { itemJoinDefinition } from '../item-join/item-join-definition.js';
+import { nativeFeatureMaterialRequirements } from './native-feature-material-requirements.js';
+import { N8nNativeFeature } from '../../../types/native-feature-registry.js';
+/** Material prerequisites belong to their actual factories, not model prompts. */
+export const nativeFeatureDefinitions = {
+    [N8nNativeFeature.If]: {
+        requirements: [],
+        create: createIfCapability,
+    },
+    [N8nNativeFeature.MergeAppend]: {
+        requirements: [],
+        create: createMergeAppendCapability,
+    },
+    [N8nNativeFeature.AssertResponses]: {
+        requirements: [],
+        create: createResponseAssertionCapability,
+    },
+    [N8nNativeFeature.StopAndError]: {
+        requirements: [],
+        create: createStopAndErrorCapability,
+    },
+    [N8nNativeFeature.PassThrough]: {
+        requirements: [],
+        create: createPassThroughCapability,
+    },
+    [N8nNativeFeature.RejoinExclusiveBranches]: {
+        requirements: [],
+        create: createExclusiveBranchMergeCapability,
+    },
+    [N8nNativeFeature.JsonOutput]: {
+        requirements: [{ field: 'jsonOutput' }],
+        create: (context) => createJsonOutputCapability(context.jsonOutput),
+    },
+    [N8nNativeFeature.SplitApiResponseArray]: {
+        requirements: nativeFeatureMaterialRequirements(responseArrayDefinition),
+        createPlanning: (context) => createMaterialPlanningCapability(responseArrayDefinition, (sources) => createResponseArrayCapability({
+            materials: sources.apiMaterials,
+            itemMode: context.itemMode,
+        })),
+        create: (context) => createResponseArrayCapability({
+            materials: context.apiMaterials,
+            itemMode: context.itemMode,
+        }),
+    },
+    [N8nNativeFeature.CollectApiResponses]: {
+        requirements: nativeFeatureMaterialRequirements(responseCollectionDefinition),
+        createPlanning: () => createMaterialPlanningCapability(responseCollectionDefinition, (sources) => createResponseCollectionCapability({
+            materials: sources.apiMaterials,
+        })),
+        create: (context) => createResponseCollectionCapability({ materials: context.apiMaterials }),
+    },
+    [N8nNativeFeature.SplitNativeOutputArray]: {
+        requirements: nativeFeatureMaterialRequirements(nativeArrayDefinition),
+        createPlanning: (context) => createMaterialPlanningCapability(nativeArrayDefinition, (sources) => createBoundNativeArrayCapability({
+            sources: sources.nativeOutputs,
+            itemMode: context.itemMode,
+            runtime: { kind: 'compiled' },
+        })),
+        create: (context) => createNativeArrayCapability({
+            sources: context.nativeOutputSources,
+            itemMode: context.itemMode,
+        }),
+    },
+    [N8nNativeFeature.JoinApiItems]: {
+        requirements: nativeFeatureMaterialRequirements(itemJoinDefinition),
+        createPlanning: () => createMaterialPlanningCapability(itemJoinDefinition, (sources) => createBoundItemJoinCapability({
+            materials: sources.apiMaterials,
+            scopes: sources.nativeOutputs,
+            runtime: { kind: 'compiled' },
+        })),
+        create: (context) => createItemJoinCapability({
+            materials: context.apiMaterials,
+            scopes: context.nativeOutputSources,
+        }),
+    },
+};

package/dist/nodes/native/registry/native-feature-material-requirements.d.ts

@@ -0,0 +1,3 @@
+import type { NativeMaterialFeatureDefinition } from '../../../types/native-material-binding.js';
+import type { N8nNativeFeatureContextRequirement } from '../../../types/native-feature-registry.js';
+export declare function nativeFeatureMaterialRequirements(definition: NativeMaterialFeatureDefinition): N8nNativeFeatureContextRequirement[];

package/dist/nodes/native/registry/native-feature-material-requirements.js

@@ -0,0 +1,10 @@
+export function nativeFeatureMaterialRequirements(definition) {
+    if (!definition.materialRequirements)
+        throw new Error(`Native feature ${definition.name} has no declared material requirements`);
+    return definition.materialRequirements.map((requirement) => ({
+        field: requirement.field === 'nativeOutputs'
+            ? 'nativeOutputSources'
+            : requirement.field,
+        minimumItems: requirement.minimumItems,
+    }));
+}

package/dist/nodes/native/registry/resolve-n8n-native-features.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeFeatureRegistry, ResolveN8nNativeFeaturesInput } from '../../../types/native-feature-registry.js';
+/** Construct capabilities only from already supplied source contracts. */
+export declare function resolveN8nNativeFeatures(input?: ResolveN8nNativeFeaturesInput): N8nNativeFeatureRegistry;

package/dist/nodes/native/registry/resolve-n8n-native-features.js

@@ -0,0 +1,6 @@
+import { resolveNativeFeatureRegistry } from './resolve-native-feature-registry.js';
+/** Construct capabilities only from already supplied source contracts. */
+export function resolveN8nNativeFeatures(input = {}) {
+    const { registrations, capabilities } = resolveNativeFeatureRegistry(input, 'materials');
+    return { registrations, capabilities };
+}

package/dist/nodes/native/registry/resolve-n8n-native-planning-features.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativePlanningFeatureRegistry, ResolveN8nNativeFeaturesInput } from '../../../types/native-feature-registry.js';
+/** Expose stable definitions before API/native producer instances have been planned. */
+export declare function resolveN8nNativePlanningFeatures(input?: ResolveN8nNativeFeaturesInput): N8nNativePlanningFeatureRegistry;

package/dist/nodes/native/registry/resolve-n8n-native-planning-features.js

@@ -0,0 +1,5 @@
+import { resolveNativeFeatureRegistry } from './resolve-native-feature-registry.js';
+/** Expose stable definitions before API/native producer instances have been planned. */
+export function resolveN8nNativePlanningFeatures(input = {}) {
+    return resolveNativeFeatureRegistry(input, 'planning');
+}

package/dist/nodes/native/registry/resolve-native-feature-registry.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativePlanningFeatureRegistry, N8nNativeFeatureResolutionMode, ResolveN8nNativeFeaturesInput } from '../../../types/native-feature-registry.js';
+/** No model calls, fabricated contracts, source discovery or automatic registration retries. */
+export declare function resolveNativeFeatureRegistry(input: ResolveN8nNativeFeaturesInput, mode: N8nNativeFeatureResolutionMode): N8nNativePlanningFeatureRegistry;

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.js

@@ -3,6 +3,7 @@ import { assertionParametersSchema } from '../../schemas/native-capability-schem
 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 = {}) {
@@ -10,19 +11,22 @@ export function createResponseAssertionCapability(input = {}) {
         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, position }) => {
+        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);`;

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

@@ -1,3 +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): string;
+export declare function conditionExpression(check: NativeCheck, names: Record<string, string>, linked?: boolean, singletonApiResponseIds?: string[]): string;

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

@@ -1,5 +1,6 @@
 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 `
@@ -43,16 +44,21 @@ function compare(check) {
 export function responseCheckCode(responseReaderCode) {
     return `${responseReaderCode}\n${responseCheckRuntime()}`;
 }
-export function conditionExpression(check, names, linked = false) {
-    const declaredNames = Object.fromEntries(responseReferences([check]).map((ref) => [ref.nodeId, names[ref.nodeId]]));
+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 names=${javascriptJsonLiteral(declaredNames)};
+    const reader = `const sources=${javascriptJsonLiteral(sources)};
 const responses=Object.create(null);
-for (const id of Object.keys(names)) {
-  ${linked ? 'const envelope=$(names[id]).itemMatching(inputIndex);' : "const items=$(names[id]).all();if(items.length!==1)throw new Error('Response '+id+' requires an unambiguous single JSON item');const envelope=items[0];"}
+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: '+id);
-  responses[id]=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-reader.d.ts

@@ -1,3 +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, linked, }: CreateResponseCheckReaderInput): CompiledResponseCheckReader;
+export declare function createResponseCheckReader({ nodeId, checks, apiNodeNames, apiResponseContracts, singletonApiResponseIds, linked, }: CreateResponseCheckReaderInput): CompiledResponseCheckReader;

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

@@ -2,7 +2,7 @@ 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, linked, }) {
+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];
@@ -17,7 +17,7 @@ export function createResponseCheckReader({ nodeId, checks, apiNodeNames, apiRes
         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)}`,
+        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.js

@@ -1,29 +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() {
-    return {
+    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: ({ planned, position }) => createNativeFragment(node({
-            type: 'n8n-nodes-base.stopAndError',
-            version: 1,
-            config: {
-                id: planned.id,
-                name: planned.id,
-                position,
-                parameters: {
-                    errorType: 'errorMessage',
-                    errorMessage: stopParametersSchema.parse(planned.parameters)
-                        .message,
+        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'], []),
+            }), ['main'], []);
+            return planned.runtimeParameters !== undefined
+                ? prependNativeParameterGuard({ input: source, capability, fragment })
+                : fragment;
+        },
     };
+    return capability;
 }

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

@@ -1,3 +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): string;
+export declare function compileRequestValidator(config: RequestMaterializationConfig, globalName?: string): string;

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

@@ -1,13 +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) {
+export function compileRequestValidator(config, globalName = 'OpenApiFlowRequestValidator') {
     const schema = createApiRequestSchema({
         operation: config.contract,
         requestMediaType: config.arguments.requestMediaType,
     });
     return compileStandaloneValidator({
         schema,
-        globalName: 'OpenApiFlowRequestValidator',
+        globalName,
     });
 }

package/dist/nodes/request/bindings/create-bound-request-fragment.js

@@ -11,8 +11,11 @@ export function createBoundRequestFragment(input, config) {
     const runtime = readFileSync(new URL('../runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
     const validator = compileRequestValidator(config);
     const linked = input.itemMode === 'linked';
-    const materialize = `OpenApiFlowRequestRuntime.materializeHttpRequest(config,responses,OpenApiFlowRequestValidator)`;
-    const code = `${runtime}\n${validator}\nconst config=${javascriptJsonLiteral(config)};\n${linked ? `return $input.all().map((_,inputIndex)=>{${createOutputReaderCode(sources, true)}\nreturn {json:${materialize},pairedItem:{item:inputIndex}};});` : `${createOutputReaderCode(sources)}\nreturn [{json:${materialize}}];`}`;
+    const materialize = `OpenApiFlowRequestRuntime.materializeHttpRequest(config,responses,OpenApiFlowRequestValidator${config.deferredInputs ? ',inputValues' : ''})`;
+    const inputReader = config.deferredInputs
+        ? `const inputItems=$(${javascriptJsonLiteral(config.deferredInputs.inputNodeName)}).all(0,0);if(inputItems.length!==1||inputItems[0].json.revision!==${config.deferredInputs.revision})throw new Error('Missing or stale validated workflow inputs: expected revision ${config.deferredInputs.revision}');const inputValues=inputItems[0].json.values;`
+        : '';
+    const code = `${runtime}\n${validator}\nconst config=${javascriptJsonLiteral(config)};\n${inputReader}\n${linked ? `return $input.all().map((_,inputIndex)=>{${createOutputReaderCode(sources, true)}\nreturn {json:${materialize},pairedItem:{item:inputIndex}};});` : `${createOutputReaderCode(sources)}\nreturn [{json:${materialize}}];`}`;
     const materializer = node({
         type: 'n8n-nodes-base.code',
         version: 2,
@@ -25,7 +28,9 @@ export function createBoundRequestFragment(input, config) {
     });
     const bodyPresent = Object.hasOwn(config.arguments.values, 'body') ||
         config.arguments.bindings.some((binding) => binding.targetPointer === '/body' ||
-            binding.targetPointer.startsWith('/body/'));
+            binding.targetPointer.startsWith('/body/')) ||
+        config.deferredInputs?.slots.some((slot) => slot.targetPointer === '/body' ||
+            slot.targetPointer.startsWith('/body/')) === true;
     const mediaTypes = config.operation.body
         ? Object.keys(config.operation.body.mediaTypes)
         : [];

package/dist/nodes/request/bindings/create-output-item-reader-code.d.ts

@@ -0,0 +1,2 @@
+/** A graph-proven singleton is read as exactly one item, never as an ancestry fallback. */
+export declare function createOutputItemReaderCode(linked: boolean): string;

package/dist/nodes/request/bindings/create-output-item-reader-code.js

@@ -0,0 +1,7 @@
+/** A graph-proven singleton is read as exactly one item, never as an ancestry fallback. */
+export function createOutputItemReaderCode(linked) {
+    const single = "const items=$(source.nodeName).all();if(items.length!==1)throw new Error('Response '+source.nodeId+' requires an unambiguous single JSON item; got '+items.length+' items');return items[0];";
+    return linked
+        ? `const item=source.singleton===true?(()=>{${single}})():$(source.nodeName).itemMatching(inputIndex);`
+        : `const item=(()=>{${single}})();`;
+}

package/dist/nodes/request/bindings/create-output-reader-code.d.ts

@@ -1,3 +1,3 @@
 import type { N8nOutputBindingSource } from '../../../types/output-binding-source.js';
 /** Read declared JSON roots without coercion or ambiguous item selection. */
-export declare function createOutputReaderCode(sources: N8nOutputBindingSource[], linked?: boolean): string;
+export declare function createOutputReaderCode(sources: N8nOutputBindingSource[], linked?: boolean, singletonNodeIds?: string[]): string;

package/dist/nodes/request/bindings/create-output-reader-code.js

@@ -1,12 +1,14 @@
 import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
 import { compileNativeOutputValidators } from './compile-native-output-validators.js';
 import { compileSourceResponseValidators } from './compile-source-response-validators.js';
+import { createOutputItemReaderCode } from './create-output-item-reader-code.js';
 /** Read declared JSON roots without coercion or ambiguous item selection. */
-export function createOutputReaderCode(sources, linked = false) {
+export function createOutputReaderCode(sources, linked = false, singletonNodeIds = []) {
     const declarations = sources.map((source, index) => ({
         nodeId: source.nodeId,
         nodeName: source.nodeName,
         kind: source.kind,
+        singleton: singletonNodeIds.includes(source.nodeId),
         validator: source.kind === 'native-json' || source.operation ? index : null,
     }));
     const responseValidators = sources
@@ -19,8 +21,6 @@ export function createOutputReaderCode(sources, linked = false) {
         ? `OpenApiFlowNativeOutputValidator${index}`
         : 'null')
         .join(',');
-    const reader = linked
-        ? 'const item=$(source.nodeName).itemMatching(inputIndex);'
-        : "const items=$(source.nodeName).all();if(items.length!==1)throw new Error('Response '+source.nodeId+' requires an unambiguous single JSON item; got '+items.length+' items');const item=items[0];";
+    const reader = createOutputItemReaderCode(linked);
     return `${compileNativeOutputValidators(sources)}\n${compileSourceResponseValidators(sources)}\nconst sources=${javascriptJsonLiteral(declarations)};\nconst validators=[${responseValidators}];\nconst nativeValidators=[${nativeValidators}];\nconst responses=Object.create(null);\nfor(const source of sources){${reader}if(!item||!item.json||typeof item.json!=='object')throw new Error('Missing JSON output '+source.nodeId);if(source.kind==='api-response'){if(source.validator!==null){const validate=validators[source.validator];if(!validate(OpenApiFlowRequestRuntime.apiResponseValidationValue(item.json)))throw new Error('Response '+source.nodeId+' does not match its OAS contract: '+JSON.stringify(validate.errors));}if(!Object.hasOwn(item.json,'body'))throw new Error('Missing response body '+source.nodeId);responses[source.nodeId]=item.json.body;}else{const validate=nativeValidators[source.validator];if(!validate(item.json))throw new Error('Native output does not match declared schema: '+JSON.stringify(validate.errors)+' (source '+source.nodeId+')');responses[source.nodeId]=item.json;}}`;
 }