@openapi-flow/n8n 0.0.0-stage → 0.3.0

package/dist/nodes/native/common/create-material-planning-capability.js

@@ -0,0 +1,14 @@
+import { defineMaterialBoundCapability } from './define-material-bound-capability.js';
+/** A stable implementation definition, not a ready output contract or executable node. */
+export function createMaterialPlanningCapability(definition, bind) {
+    function requireBinding() {
+        throw new Error(`Native feature ${definition.name} requires actual material contract binding before value references, output or compilation`);
+    }
+    return defineMaterialBoundCapability({
+        ...definition,
+        bindMaterialContracts: bind,
+        responseReferences: requireBinding,
+        outputSchema: requireBinding,
+        compile: requireBinding,
+    });
+}

package/dist/nodes/native/common/create-native-fragment.d.ts

@@ -0,0 +1,2 @@
+import type { N8nNodeFragment, N8nSdkNode } from '../../../types/node-fragment.js';
+export declare function createNativeFragment(sdkNode: N8nSdkNode, inputs: string[], outputs: string[]): N8nNodeFragment;

package/dist/nodes/native/common/create-native-fragment.js

@@ -0,0 +1,10 @@
+export function createNativeFragment(sdkNode, inputs, outputs) {
+    return {
+        nodeId: sdkNode.id,
+        nodes: [sdkNode],
+        entry: sdkNode,
+        exit: sdkNode,
+        inputPorts: Object.fromEntries(inputs.map((port, index) => [port, index])),
+        outputPorts: Object.fromEntries(outputs.map((port, index) => [port, index])),
+    };
+}

package/dist/nodes/native/common/define-material-bound-capability.d.ts

@@ -0,0 +1,4 @@
+import type { MaterialBindableN8nCapability } from '../../../types/native-material-binding.js';
+import type { N8nNativeCapability } from '../../../types/native-capability.js';
+/** A material binder cannot silently discard a caller's different implementation or source receipt. */
+export declare function defineMaterialBoundCapability(definition: MaterialBindableN8nCapability): N8nNativeCapability;

package/dist/nodes/native/common/define-material-bound-capability.js

@@ -0,0 +1,33 @@
+import { isDeepStrictEqual } from 'node:util';
+/** A material binder cannot silently discard a caller's different implementation or source receipt. */
+export function defineMaterialBoundCapability(definition) {
+    if (definition.materialRequirements !== undefined)
+        definition.materialRequirements = structuredClone(definition.materialRequirements);
+    const requirements = structuredClone(definition.materialRequirements);
+    if (definition.parameterReferenceSources !== undefined)
+        definition.parameterReferenceSources = structuredClone(definition.parameterReferenceSources);
+    const referenceSources = structuredClone(definition.parameterReferenceSources);
+    const bind = definition.bindMaterialContracts;
+    const fields = new Map(Object.entries(definition).filter(([key]) => key !== 'bindMaterialContracts' && key !== 'materialSources'));
+    const receipts = structuredClone(definition.materialSources);
+    definition.bindMaterialContracts = function (sources) {
+        const changed = [...fields]
+            .filter(([key, value]) => Reflect.get(this, key) !== value)
+            .map(([key]) => key);
+        const extra = Object.keys(this).filter((key) => key !== 'bindMaterialContracts' &&
+            key !== 'materialSources' &&
+            !fields.has(key));
+        if (!isDeepStrictEqual(this.materialSources, receipts))
+            changed.push('materialSources');
+        if (!isDeepStrictEqual(this.parameterReferenceSources, referenceSources) &&
+            !changed.includes('parameterReferenceSources'))
+            changed.push('parameterReferenceSources');
+        if (!isDeepStrictEqual(this.materialRequirements, requirements) &&
+            !changed.includes('materialRequirements'))
+            changed.push('materialRequirements');
+        if (changed.length || extra.length)
+            throw new Error(`Native material definition ${definition.name} changed ${[...changed, ...extra].join(', ')} without a coherent bindMaterialContracts implementation`);
+        return bind.call(this, sources);
+    };
+    return definition;
+}

package/dist/nodes/native/common/resolve-native-runtime-source.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveNativeRuntimeSourceInput } from '../../../types/native-material-binding.js';
+import type { N8nNativeOutputSource } from '../../../types/output-binding-source.js';
+export declare function resolveNativeRuntimeSource(input: ResolveNativeRuntimeSourceInput): N8nNativeOutputSource;

package/dist/nodes/native/common/resolve-native-runtime-source.js

@@ -0,0 +1,15 @@
+import { isDeepStrictEqual } from 'node:util';
+export function resolveNativeRuntimeSource(input) {
+    if (input.binding.kind === 'compiled' &&
+        !Array.isArray(input.compiledSources))
+        throw new Error(`Native ${input.consumerId}: compile.nativeOutputSources is required for the current material revision`);
+    const sources = input.binding.kind === 'provided'
+        ? input.binding.sources
+        : input.compiledSources;
+    const matches = sources.filter((source) => source.nodeId === input.contract.nodeId);
+    if (matches.length !== 1 ||
+        !matches[0].nodeName?.trim() ||
+        !isDeepStrictEqual(matches[0].schema, input.contract.schema))
+        throw new Error(`Native ${input.consumerId}: source ${input.contract.nodeId} requires exactly one matching actual compiled name/schema`);
+    return matches[0];
+}

package/dist/nodes/native/common/response-reference-bindings.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowNativeReferenceBinding } from '@openapi-flow/core';
+import type { NativeCheck } from '../../../types/native-capability.js';
+/** The comparison implementation owns these operand locations. */
+export declare function responseReferenceBindings(checks: NativeCheck[], prefix: string): WorkflowNativeReferenceBinding[];

package/dist/nodes/native/common/response-reference-bindings.js

@@ -0,0 +1,15 @@
+/** The comparison implementation owns these operand locations. */
+export function responseReferenceBindings(checks, prefix) {
+    return checks.flatMap((check, index) => ['left', 'right'].flatMap((side) => {
+        const operand = check[side];
+        return operand.source === 'response'
+            ? [
+                {
+                    nodeIdPointer: `${prefix}/${index}/${side}/nodeId`,
+                    valuePointer: `${prefix}/${index}/${side}/pointer`,
+                    reference: { ...operand },
+                },
+            ]
+            : [];
+    }));
+}

package/dist/nodes/native/common/response-references.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowResponseReference } from '@openapi-flow/core';
+import type { NativeCheck } from '../../../types/native-capability.js';
+export declare function responseReferences(checks: NativeCheck[]): WorkflowResponseReference[];

package/dist/nodes/native/common/response-references.js

@@ -0,0 +1,5 @@
+export function responseReferences(checks) {
+    return checks
+        .flatMap((check) => [check.left, check.right])
+        .filter((operand) => operand.source === 'response');
+}

package/dist/nodes/native/create-exclusive-branch-merge-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../types/native-capability.js';
+/** Separate semantic contract from the all-independent-inputs Merge capability. */
+export declare function createExclusiveBranchMergeCapability(): N8nNativeCapability;

package/dist/nodes/native/create-exclusive-branch-merge-capability.js

@@ -0,0 +1,43 @@
+import { node } from '@n8n/workflow-sdk';
+import { exclusiveBranchMergeParametersSchema } from '../../schemas/exclusive-branch-merge-schema.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+/** Separate semantic contract from the all-independent-inputs Merge capability. */
+export function createExclusiveBranchMergeCapability() {
+    return {
+        name: 'rejoin-exclusive-branches',
+        description: 'Rejoin both alternative paths of one supplied IF instance using official Merge append. input1 and input2 each cover a distinct true/false path. Preserves existing items and ancestry; never creates an empty completion item. Both paths must return, including a skip path when no business call is required.',
+        parametersSchema: exclusiveBranchMergeParametersSchema,
+        parameterReferenceSources: ['exclusive-output'],
+        parameterReferenceBindings: (parameters) => [
+            {
+                nodeIdPointer: '/sourceNodeId',
+                reference: {
+                    source: 'exclusive-output',
+                    nodeId: exclusiveBranchMergeParametersSchema.parse(parameters).sourceNodeId,
+                },
+            },
+        ],
+        inputPorts: () => ['input1', 'input2'],
+        outputPorts: () => ['main'],
+        responseReferences: () => [],
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        rejoinsExclusiveOutputs: (parameters) => exclusiveBranchMergeParametersSchema.parse(parameters).sourceNodeId,
+        compile: ({ planned, position }) => {
+            const { sourceNodeId } = exclusiveBranchMergeParametersSchema.parse(planned.parameters);
+            return {
+                ...createNativeFragment(node({
+                    type: 'n8n-nodes-base.merge',
+                    version: 3.2,
+                    config: {
+                        id: planned.id,
+                        name: planned.id,
+                        position,
+                        parameters: { mode: 'append', numberInputs: 2 },
+                    },
+                }), ['input1', 'input2'], ['main']),
+                rejoinsExclusiveOutputs: sourceNodeId,
+            };
+        },
+    };
+}

package/dist/nodes/native/create-json-output-capability.d.ts

@@ -0,0 +1,3 @@
+import type { CreateJsonOutputCapabilityInput, N8nNativeCapability } from '../../types/native-capability.js';
+/** Explicit typed literals through Edit Fields JSON mode; no casts or mapping expressions. */
+export declare function createJsonOutputCapability(input: CreateJsonOutputCapabilityInput): N8nNativeCapability;

package/dist/nodes/native/create-json-output-capability.js

@@ -0,0 +1,48 @@
+import { node } from '@n8n/workflow-sdk';
+import { z } from 'zod';
+import { parseNativeNodeParameters } from '@openapi-flow/core';
+import { javascriptJsonLiteral } from '../../utils/javascript-json-literal.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+import { prependNativeParameterGuard } from './inputs/prepend-native-parameter-guard.js';
+/** Explicit typed literals through Edit Fields JSON mode; no casts or mapping expressions. */
+export function createJsonOutputCapability(input) {
+    if (!input.name.trim() || !input.description.trim())
+        throw new Error('JSON output capability requires name and description');
+    const capability = {
+        ...input,
+        supportsRuntimeParameters: true,
+        inputPorts: () => ['main'],
+        outputPorts: () => ['main'],
+        responseReferences: () => [],
+        parameterReferenceSources: [],
+        parameterReferenceBindings: () => [],
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        outputSchema: () => z.toJSONSchema(input.parametersSchema, { io: 'output' }),
+        compile: (source) => {
+            const { planned, position } = source;
+            const jsonOutput = planned.runtimeParameters !== undefined
+                ? '={{ JSON.stringify($json) }}'
+                : `={{ ${javascriptJsonLiteral(parseNativeNodeParameters(planned, capability))} }}`;
+            const fragment = createNativeFragment(node({
+                type: 'n8n-nodes-base.set',
+                version: 3.4,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position,
+                    parameters: {
+                        mode: 'raw',
+                        jsonOutput,
+                        includeOtherFields: false,
+                        options: { dotNotation: false },
+                    },
+                },
+            }), ['main'], ['main']);
+            return planned.runtimeParameters !== undefined
+                ? prependNativeParameterGuard({ input: source, capability, fragment })
+                : fragment;
+        },
+    };
+    return capability;
+}

package/dist/nodes/native/create-native-capabilities.d.ts

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

package/dist/nodes/native/create-native-capabilities.js

@@ -0,0 +1,15 @@
+import { resolveN8nNativeFeatures } from './registry/resolve-n8n-native-features.js';
+import { validateNativeFeatureContext } from './registry/validate-native-feature-context.js';
+import { N8nNativeFeature } from '../../types/native-feature-registry.js';
+export function createN8nNativeCapabilities(input = {}) {
+    validateNativeFeatureContext(input);
+    return resolveN8nNativeFeatures({
+        ...input,
+        features: [
+            N8nNativeFeature.If,
+            N8nNativeFeature.MergeAppend,
+            N8nNativeFeature.AssertResponses,
+            N8nNativeFeature.StopAndError,
+        ],
+    }).capabilities;
+}

package/dist/nodes/native/create-pass-through-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../types/native-capability.js';
+/** An explicit identity step; never generate a request, value or completion item. */
+export declare function createPassThroughCapability(): N8nNativeCapability;

package/dist/nodes/native/create-pass-through-capability.js

@@ -0,0 +1,32 @@
+import { node } from '@n8n/workflow-sdk';
+import { passThroughParametersSchema } from '../../schemas/native-capability-schemas.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+/** An explicit identity step; never generate a request, value or completion item. */
+export function createPassThroughCapability() {
+    return {
+        name: 'pass-through',
+        description: 'n8n No Operation: forward all input items unchanged with their original links. Main input/output, no configuration or new data. Can provide a common entry before a fan-out. This does not merge branches, collect results or replace a missing API.',
+        parametersSchema: passThroughParametersSchema,
+        parameterReferenceSources: [],
+        inputPorts: () => ['main'],
+        outputPorts: () => ['main'],
+        responseReferences: () => [],
+        parameterReferenceBindings: () => [],
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        compile: ({ planned, position }) => {
+            passThroughParametersSchema.parse(planned.parameters);
+            const fragment = createNativeFragment(node({
+                type: 'n8n-nodes-base.noOp',
+                version: 1,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position,
+                    parameters: {},
+                },
+            }), ['main'], ['main']);
+            return { ...fragment, preservesInputItems: true };
+        },
+    };
+}

package/dist/nodes/native/create-response-array-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../types/native-capability.js';
+import type { CreateResponseArrayCapabilityInput } from '../../types/array-iteration.js';
+export declare function createResponseArrayCapability(input: CreateResponseArrayCapabilityInput): N8nNativeCapability;

package/dist/nodes/native/create-response-array-capability.js

@@ -0,0 +1,78 @@
+import { defineMaterialBoundCapability } from './common/define-material-bound-capability.js';
+import { createResponseArrayItemSchema } from '@openapi-flow/core';
+import { createResponseArrayParametersSchema } from '../../schemas/response-array-schema.js';
+import { createArrayNodeFragment } from './arrays/create-array-node-fragment.js';
+import { responseArrayDefinition } from './response-array-definition.js';
+export function createResponseArrayCapability(input) {
+    if (input.itemMode !== undefined && input.itemMode !== 'linked')
+        throw new Error('response array capability: itemMode must be linked or omitted');
+    const linked = input.itemMode === 'linked';
+    const materials = new Map(input.materials.map((material) => [material.callId, material]));
+    if (!materials.size ||
+        materials.size !== input.materials.length ||
+        input.materials.some((material) => !material.callId.trim()))
+        throw new Error('response array capability requires unique API materials');
+    const parametersSchema = createResponseArrayParametersSchema([
+        ...materials.keys(),
+    ]);
+    function source(parameters) {
+        const material = materials.get(parameters.sourceNodeId);
+        if (!material)
+            throw new Error(`response array: unknown sourceNodeId ${parameters.sourceNodeId}`);
+        createResponseArrayItemSchema(material.operation, parameters.pointer);
+        return material;
+    }
+    return defineMaterialBoundCapability({
+        ...responseArrayDefinition,
+        parametersSchema,
+        materialSources: {
+            apiMaterials: structuredClone(input.materials),
+            nativeOutputs: [],
+        },
+        bindMaterialContracts: (sources) => createResponseArrayCapability({
+            materials: sources.apiMaterials,
+            itemMode: input.itemMode,
+        }),
+        responseReferences: (values) => {
+            const parameters = parametersSchema.parse(values);
+            source(parameters);
+            return [
+                {
+                    source: 'response',
+                    nodeId: parameters.sourceNodeId,
+                    pointer: parameters.pointer,
+                },
+            ];
+        },
+        outputSchema: (values) => {
+            const parameters = parametersSchema.parse(values);
+            return {
+                type: 'object',
+                properties: {
+                    item: createResponseArrayItemSchema(source(parameters).operation, parameters.pointer),
+                },
+                required: ['item'],
+                additionalProperties: false,
+            };
+        },
+        compile: ({ planned, position, apiNodeNames }) => {
+            const parameters = parametersSchema.parse(planned.parameters);
+            const material = source(parameters);
+            if (!Object.hasOwn(apiNodeNames, material.callId) ||
+                !apiNodeNames[material.callId].trim())
+                throw new Error(`apiNodeNames is missing ${material.callId}`);
+            return createArrayNodeFragment({
+                planned,
+                position,
+                parameters,
+                linked,
+                source: {
+                    kind: 'api-response',
+                    nodeId: material.callId,
+                    nodeName: apiNodeNames[material.callId],
+                    operation: material.operation,
+                },
+            });
+        },
+    });
+}

package/dist/nodes/native/create-response-collection-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../types/native-capability.js';
+import type { CreateResponseCollectionCapabilityInput } from '../../types/response-collection.js';
+export declare function createResponseCollectionCapability(input: CreateResponseCollectionCapabilityInput): N8nNativeCapability;

package/dist/nodes/native/create-response-collection-capability.js

@@ -0,0 +1,134 @@
+import { defineMaterialBoundCapability } from './common/define-material-bound-capability.js';
+import { node } from '@n8n/workflow-sdk';
+import { readFileSync } from 'node:fs';
+import { createResponseValueSchema } from '@openapi-flow/core';
+import { createResponseCollectionParametersSchema } from '../../schemas/response-collection-schema.js';
+import { responseCollectionDefinition } from './response-collection-definition.js';
+import { createOutputReaderCode } from '../request/bindings/create-output-reader-code.js';
+import { javascriptJsonLiteral } from '../../utils/javascript-json-literal.js';
+export function createResponseCollectionCapability(input) {
+    const materials = new Map(input.materials.map((material) => [material.callId, material]));
+    if (!materials.size ||
+        materials.size !== input.materials.length ||
+        input.materials.some((material) => !material.callId.trim()))
+        throw new Error('response collection capability requires unique API materials');
+    const parametersSchema = createResponseCollectionParametersSchema([
+        ...materials.keys(),
+    ]);
+    function source(parameters) {
+        const material = materials.get(parameters.sourceNodeId);
+        if (!material)
+            throw new Error(`response collection: unknown sourceNodeId ${parameters.sourceNodeId}`);
+        createResponseValueSchema(material.operation, parameters.pointer);
+        return material;
+    }
+    return defineMaterialBoundCapability({
+        ...responseCollectionDefinition,
+        parametersSchema,
+        materialSources: {
+            apiMaterials: structuredClone(input.materials),
+            nativeOutputs: [],
+        },
+        bindMaterialContracts: (sources) => createResponseCollectionCapability({ materials: sources.apiMaterials }),
+        responseReferences: (values) => {
+            const parameters = parametersSchema.parse(values);
+            source(parameters);
+            return [
+                {
+                    source: 'response',
+                    nodeId: parameters.sourceNodeId,
+                    pointer: parameters.pointer,
+                },
+            ];
+        },
+        outputSchema: (values) => {
+            const parameters = parametersSchema.parse(values);
+            return {
+                type: 'object',
+                properties: {
+                    items: {
+                        type: 'array',
+                        items: createResponseValueSchema(source(parameters).operation, parameters.pointer),
+                    },
+                },
+                required: ['items'],
+                additionalProperties: false,
+            };
+        },
+        compile: ({ planned, position, apiNodeNames }) => {
+            const parameters = parametersSchema.parse(planned.parameters);
+            const material = source(parameters);
+            if (!Object.hasOwn(apiNodeNames, material.callId) ||
+                !apiNodeNames[material.callId].trim())
+                throw new Error(`apiNodeNames is missing ${material.callId}`);
+            const runtime = readFileSync(new URL('../request/runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
+            const read = createOutputReaderCode([
+                {
+                    kind: 'api-response',
+                    nodeId: material.callId,
+                    nodeName: apiNodeNames[material.callId],
+                    operation: material.operation,
+                },
+            ], true);
+            const extract = node({
+                type: 'n8n-nodes-base.code',
+                version: 2,
+                config: {
+                    id: `${planned.id}-read-values`,
+                    name: `Read values ${planned.id}`,
+                    position,
+                    parameters: {
+                        mode: 'runOnceForAllItems',
+                        jsCode: `${runtime}\nconst parameters=${javascriptJsonLiteral(parameters)};\nreturn $input.all().map((_,inputIndex)=>{${read}\nconst value=OpenApiFlowRequestRuntime.pointerValue(responses[parameters.sourceNodeId],parameters.pointer);if(value===undefined)throw new Error('Missing response pointer '+parameters.sourceNodeId+parameters.pointer);return {json:{value},pairedItem:{item:inputIndex}};});`,
+                    },
+                },
+            });
+            const aggregate = node({
+                type: 'n8n-nodes-base.aggregate',
+                version: 1,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position: [position[0] + 220, position[1]],
+                    parameters: {
+                        aggregate: 'aggregateIndividualFields',
+                        fieldsToAggregate: {
+                            fieldToAggregate: [
+                                {
+                                    fieldToAggregate: 'value',
+                                    renameField: true,
+                                    outputFieldName: 'items',
+                                },
+                            ],
+                        },
+                        options: {
+                            disableDotNotation: true,
+                            mergeLists: false,
+                            keepMissing: true,
+                            includeBinaries: false,
+                        },
+                    },
+                },
+            });
+            return {
+                nodeId: planned.id,
+                bindingSources: [
+                    {
+                        kind: 'api-response',
+                        nodeId: material.callId,
+                        nodeName: apiNodeNames[material.callId],
+                        operation: material.operation,
+                    },
+                ],
+                nodes: [extract, aggregate],
+                entry: extract,
+                exit: aggregate,
+                inputPorts: { main: 0 },
+                outputPorts: { main: 0 },
+                internalEdges: [
+                    { from: extract.id, output: 0, to: aggregate.id, input: 0 },
+                ],
+            };
+        },
+    });
+}

package/dist/nodes/native/if-capability.d.ts

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

package/dist/nodes/native/if-capability.js

@@ -0,0 +1,80 @@
+import { node } from '@n8n/workflow-sdk';
+import { ifParametersSchema } from '../../schemas/native-capability-schemas.js';
+import { createIfPlanningParametersSchema } 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 { conditionExpression } from './response-check-code.js';
+import { createResponseCheckReader } from './response-checks/create-response-check-reader.js';
+import { createResponseCheckGuard } from './response-checks/create-response-check-guard.js';
+export function createIfCapability(input = {}) {
+    return {
+        name: 'if',
+        description: 'n8n IF: main input; true and false OUTPUT PORTS are mutually exclusive. Multiple edges from the SAME port all execute (fan-out) and can be joined. Type-strict declarative conditions.',
+        parametersSchema: ifParametersSchema,
+        parameterReferenceSources: ['response'],
+        createPlanningParametersSchema: createIfPlanningParametersSchema,
+        inputPorts: () => ['main'],
+        outputPorts: () => ['true', 'false'],
+        responseReferences: (parameters) => responseReferences(ifParametersSchema.parse(parameters).conditions),
+        parameterReferenceBindings: (parameters) => responseReferenceBindings(ifParametersSchema.parse(parameters).conditions, '/conditions'),
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: true,
+        compile: ({ planned, apiNodeNames, apiResponseContracts, singletonApiResponseIds, position, }) => {
+            const parameters = ifParametersSchema.parse(planned.parameters);
+            const reader = createResponseCheckReader({
+                nodeId: planned.id,
+                checks: parameters.conditions,
+                apiNodeNames,
+                apiResponseContracts,
+                singletonApiResponseIds,
+                linked: input.itemMode === 'linked',
+            });
+            const fragment = createNativeFragment(node({
+                type: 'n8n-nodes-base.if',
+                version: 2.2,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position,
+                    parameters: {
+                        conditions: {
+                            options: {
+                                caseSensitive: true,
+                                leftValue: '',
+                                typeValidation: 'strict',
+                                version: 2,
+                            },
+                            conditions: parameters.conditions.map((check, index) => ({
+                                id: `${planned.id}-${index}`,
+                                leftValue: conditionExpression(check, apiNodeNames, input.itemMode === 'linked', singletonApiResponseIds),
+                                rightValue: true,
+                                operator: { type: 'boolean', operation: 'equals' },
+                            })),
+                            combinator: parameters.combinator,
+                        },
+                        options: {},
+                    },
+                },
+            }), ['main'], ['true', 'false']);
+            const partition = { ...fragment, partitionsInputItems: true };
+            if (!reader.bindingSources.length)
+                return partition;
+            const guard = createResponseCheckGuard({
+                nodeId: planned.id,
+                readerCode: reader.code,
+                linked: input.itemMode === 'linked',
+                position,
+            });
+            return {
+                ...partition,
+                entry: guard,
+                nodes: [guard, ...fragment.nodes],
+                internalEdges: [
+                    { from: guard.id, output: 0, to: fragment.entry.id, input: 0 },
+                ],
+                bindingSources: reader.bindingSources,
+            };
+        },
+    };
+}

package/dist/nodes/native/inputs/native-input-runtime.bundle.js

@@ -0,0 +1,24 @@
+/*! MIT License
+
+Copyright (c) 2026 carefreelife98
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+var OpenApiFlowNativeInputRuntime;
+(()=>{function f(e){if(e==="")return[];if(!e.startsWith("/")||/~(?![01])/u.test(e))throw new Error(`Invalid JSON Pointer: ${e}`);return e.slice(1).split("/").map(i=>i.replaceAll("~1","/").replaceAll("~0","~"))}function l(e){if(Array.isArray(e))return e.map(l);if(e===null||typeof e!="object")return e;let i=Object.create(null);for(let[c,r]of Object.entries(e))i[c]=l(r);return i}function y(e){let i=f(e.pointer);if(!i.length)throw new Error(`${e.source} must identify a JSON field`);let c=l(e.values),r=c;for(let[o,t]of i.entries()){if(Array.isArray(r)&&(!/^(0|[1-9][0-9]*)$/.test(t)||Number(t)>r.length))throw new Error(`${e.source} ${e.pointer} requires an explicit complete array prefix`);if(o===i.length-1){if(Object.hasOwn(r,t))throw new Error(`${e.source} conflicts with existing value at ${e.pointer}`);Reflect.set(r,t,l(e.value))}else{if(!Object.hasOwn(r,t)){let a="/"+i.slice(0,o+1).map(s=>s.replaceAll("~","~0").replaceAll("/","~1")).join("/");Reflect.set(r,t,e.containerKind(a)==="array"?[]:Object.create(null))}let n=Reflect.get(r,t);if(n===null||typeof n!="object")throw new Error(`${e.source} traverses non-container ${e.pointer}`);r=n}}return JSON.parse(JSON.stringify(c))}function d(e,i){let c=l(e.parameters),r=[...e.inputs].sort((o,t)=>{let n=f(o.targetPointer),a=f(t.targetPointer);for(let s=0;s<Math.min(n.length,a.length);s++)if(n[s]!==a[s])return/^(0|[1-9][0-9]*)$/.test(n[s])&&/^(0|[1-9][0-9]*)$/.test(a[s])?Number(n[s])-Number(a[s]):n[s].localeCompare(a[s]);return n.length-a.length});for(let o of r){if(!Object.hasOwn(i,o.id))throw new Error(`Missing native runtime input ${o.id} for ${e.nodeId}${o.targetPointer}`);let t=i[o.id];if(o.targetPointer===""){if(r.length!==1||Object.keys(c).length||t===null||typeof t!="object"||Array.isArray(t))throw new Error(`Native runtime input ${e.nodeId} must be an exclusive JSON parameter object`);c=l(t)}else c=y({values:c,pointer:o.targetPointer,value:t,source:`Native runtime input ${e.nodeId}`,containerKind(n){if(!Object.hasOwn(o.containerKinds,n))throw new Error(`Native runtime input ${e.nodeId} has no declared container at ${n}`);return o.containerKinds[n]}})}return c}OpenApiFlowNativeInputRuntime={materializeNativeRuntimeParameters:d};})();

package/dist/nodes/native/inputs/prepend-native-parameter-guard.d.ts

@@ -0,0 +1,4 @@
+import type { PrependNativeParameterGuardInput } from '../../../types/native-runtime-parameters.js';
+import type { N8nNodeFragment } from '../../../types/node-fragment.js';
+/** Validate the unchanged declared parameter object again immediately before the native node. */
+export declare function prependNativeParameterGuard({ input, capability, fragment, }: PrependNativeParameterGuardInput): N8nNodeFragment;