@openapi-flow/n8n 0.0.0-stage → 0.3.0

package/dist/nodes/native/inputs/prepend-native-parameter-guard.js

@@ -0,0 +1,52 @@
+import { node } from '@n8n/workflow-sdk';
+import { readFileSync } from 'node:fs';
+import { isDeepStrictEqual } from 'node:util';
+import { createNativeRuntimeParameterMaterializations } from '@openapi-flow/core';
+import { compileStandaloneValidator } from '../../common/validation/compile-standalone-validator.js';
+import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
+/** Validate the unchanged declared parameter object again immediately before the native node. */
+export function prependNativeParameterGuard({ input, capability, fragment, }) {
+    const configuration = input.runtimeInput;
+    if (!configuration ||
+        typeof configuration.inputNodeName !== 'string' ||
+        !configuration.inputNodeName.trim() ||
+        !Number.isSafeInteger(configuration.revision) ||
+        configuration.revision < 0)
+        throw new Error(`node ${input.planned.id}: runtime parameters require an explicit template input source and revision`);
+    const [materialization] = createNativeRuntimeParameterMaterializations({
+        nativeNodes: [input.planned],
+        capabilities: [capability],
+    });
+    if (!materialization ||
+        !isDeepStrictEqual(materialization, configuration.materialization))
+        throw new Error(`node ${input.planned.id}: runtime parameter slot differs from its original capability contract`);
+    const validator = compileStandaloneValidator({
+        schema: materialization.schema,
+        globalName: 'OpenApiFlowNativeParametersValidator',
+    });
+    const runtime = readFileSync(new URL('./native-input-runtime.bundle.js', import.meta.url), 'utf8');
+    const read = `const configurations=$(${javascriptJsonLiteral(configuration.inputNodeName)}).all();if(configurations.length!==1)throw new Error('Native runtime input requires exactly one configuration item');const payload=configurations[0].json;if(!payload||payload.revision!==${configuration.revision})throw new Error('Missing or stale native input revision');if(!payload.values||typeof payload.values!=='object')throw new Error('Missing native runtime input values');const parameters=OpenApiFlowNativeInputRuntime.materializeNativeRuntimeParameters(${javascriptJsonLiteral(materialization)},payload.values);if(!OpenApiFlowNativeParametersValidator(parameters))throw new Error('Native runtime input violates original schema for '+${javascriptJsonLiteral(materialization.nodeId)}+': '+JSON.stringify(OpenApiFlowNativeParametersValidator.errors));`;
+    const guard = node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: `${input.planned.id}-parameters`,
+            name: `Parameters ${input.planned.id}`,
+            position: [input.position[0] - 220, input.position[1]],
+            parameters: {
+                mode: 'runOnceForAllItems',
+                language: 'javaScript',
+                jsCode: `${runtime}\n${validator}\n${read}\nreturn $input.all().map((_,index)=>({json:parameters,pairedItem:{item:index}}));`,
+            },
+        },
+    });
+    return {
+        ...fragment,
+        entry: guard,
+        nodes: [guard, ...fragment.nodes],
+        internalEdges: [
+            { from: guard.id, output: 0, to: fragment.entry.id, input: 0 },
+            ...(fragment.internalEdges === undefined ? [] : fragment.internalEdges),
+        ],
+    };
+}

package/dist/nodes/native/item-join/create-bound-item-join-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../../types/native-capability.js';
+import type { BoundItemJoinCapabilityInput } from '../../../types/native-material-binding.js';
+export declare function createBoundItemJoinCapability({ materials, scopes, runtime: sourceBinding, }: BoundItemJoinCapabilityInput): N8nNativeCapability;

package/dist/nodes/native/item-join/create-bound-item-join-capability.js

@@ -0,0 +1,169 @@
+import { defineMaterialBoundCapability } from '../common/define-material-bound-capability.js';
+import { node } from '@n8n/workflow-sdk';
+import { readFileSync } from 'node:fs';
+import { createResponseValueSchema, validateNativeOutputContracts, } from '@openapi-flow/core';
+import { resolveNativeRuntimeSource } from '../common/resolve-native-runtime-source.js';
+import { createItemJoinParametersSchema } from '../../../schemas/item-join-schema.js';
+import { itemJoinDefinition } from './item-join-definition.js';
+import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
+import { createItemJoinReaderCode } from './create-item-join-reader-code.js';
+export function createBoundItemJoinCapability({ materials, scopes, runtime: sourceBinding, }) {
+    const apis = new Map(materials.map((material) => [material.callId, material]));
+    validateNativeOutputContracts(scopes);
+    const scopeContracts = scopes.map(({ nodeId, schema }) => ({
+        nodeId,
+        schema,
+    }));
+    const scopeById = new Map(scopeContracts.map((scope) => [scope.nodeId, scope]));
+    if (apis.size !== materials.length ||
+        materials.some((material) => !material.callId.trim()))
+        throw new Error('item join materials require unique non-empty callIds');
+    if (scopeById.size !== scopes.length ||
+        scopes.some((scope) => !scope.nodeId.trim()))
+        throw new Error('item join scopes require unique non-empty contract identities');
+    const parametersSchema = createItemJoinParametersSchema([...scopeById.keys()], [...apis.keys()]);
+    return defineMaterialBoundCapability({
+        ...itemJoinDefinition,
+        parametersSchema,
+        materialSources: {
+            apiMaterials: structuredClone(materials),
+            nativeOutputs: structuredClone(scopeContracts),
+        },
+        bindMaterialContracts: (sources) => createBoundItemJoinCapability({
+            materials: sources.apiMaterials,
+            scopes: sources.nativeOutputs,
+            runtime: { kind: 'compiled' },
+        }),
+        responseReferences: (values) => parametersSchema.parse(values).sourceCallIds.map((nodeId) => ({
+            source: 'response',
+            nodeId,
+            pointer: '',
+        })),
+        nodeOutputReferences: (values) => [
+            {
+                source: 'node-output',
+                nodeId: parametersSchema.parse(values).scopeNodeId,
+                pointer: '',
+            },
+        ],
+        inputReferences: (values) => {
+            const parameters = parametersSchema.parse(values);
+            return Object.fromEntries(parameters.sourceCallIds.map((nodeId, i) => [
+                `input${i + 1}`,
+                [
+                    { source: 'response', nodeId, pointer: '' },
+                    {
+                        source: 'node-output',
+                        nodeId: parameters.scopeNodeId,
+                        pointer: '',
+                    },
+                ],
+            ]));
+        },
+        outputSchema: (values) => {
+            const parameters = parametersSchema.parse(values);
+            return {
+                type: 'object',
+                required: ['responses'],
+                additionalProperties: false,
+                properties: {
+                    responses: {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: parameters.sourceCallIds,
+                        properties: Object.fromEntries(parameters.sourceCallIds.map((id) => [
+                            id,
+                            createResponseValueSchema(apis.get(id).operation, ''),
+                        ])),
+                    },
+                },
+            };
+        },
+        compile: ({ planned, position, apiNodeNames, nativeOutputSources }) => {
+            const parameters = parametersSchema.parse(planned.parameters);
+            const scope = resolveNativeRuntimeSource({
+                binding: sourceBinding,
+                contract: scopeById.get(parameters.scopeNodeId),
+                compiledSources: nativeOutputSources,
+                consumerId: planned.id,
+            });
+            const bindingSources = [
+                { ...scope, kind: 'native-json' },
+                ...parameters.sourceCallIds.map((id) => {
+                    if (!Object.hasOwn(apiNodeNames, id) || !apiNodeNames[id].trim())
+                        throw new Error(`item join apiNodeNames is missing ${id}`);
+                    return {
+                        kind: 'api-response',
+                        nodeId: id,
+                        nodeName: apiNodeNames[id],
+                        operation: apis.get(id).operation,
+                    };
+                }),
+            ];
+            const readers = parameters.sourceCallIds.map((id, index) => node({
+                type: 'n8n-nodes-base.code',
+                version: 2,
+                config: {
+                    id: `${planned.id}-read-${index}`,
+                    name: `Read branch ${index + 1} ${planned.id}`,
+                    position: [position[0], position[1] + index * 180],
+                    parameters: {
+                        mode: 'runOnceForAllItems',
+                        jsCode: createItemJoinReaderCode({
+                            scope,
+                            sourceCallId: id,
+                            sources: [bindingSources[0], bindingSources[index + 1]],
+                        }),
+                    },
+                },
+            }));
+            const merge = node({
+                type: 'n8n-nodes-base.merge',
+                version: 3.2,
+                config: {
+                    id: `${planned.id}-wait`,
+                    name: `Wait branches ${planned.id}`,
+                    position: [position[0] + 220, position[1]],
+                    parameters: { mode: 'append', numberInputs: readers.length },
+                },
+            });
+            const runtime = readFileSync(new URL('./runtime/item-join-runtime.bundle.js', import.meta.url), 'utf8');
+            const joined = node({
+                type: 'n8n-nodes-base.code',
+                version: 2,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position: [position[0] + 440, position[1]],
+                    parameters: {
+                        mode: 'runOnceForAllItems',
+                        jsCode: `${runtime}\nreturn OpenApiFlowItemJoinRuntime.joinApiItems({items:$input.all(),sourceCallIds:${javascriptJsonLiteral(parameters.sourceCallIds)}});`,
+                    },
+                },
+            });
+            return {
+                nodeId: planned.id,
+                joinsInputItemsByAncestry: { scopeNodeId: parameters.scopeNodeId },
+                nodes: [...readers, merge, joined],
+                entry: readers[0],
+                exit: joined,
+                inputPorts: Object.fromEntries(itemJoinDefinition.inputPorts(parameters).map((port) => [port, 0])),
+                inputEndpoints: Object.fromEntries(readers.map((reader, i) => [
+                    `input${i + 1}`,
+                    { nodeId: reader.id, input: 0 },
+                ])),
+                outputPorts: { main: 0 },
+                bindingSources,
+                internalEdges: [
+                    ...readers.map((reader, index) => ({
+                        from: reader.id,
+                        output: 0,
+                        to: merge.id,
+                        input: index,
+                    })),
+                    { from: merge.id, output: 0, to: joined.id, input: 0 },
+                ],
+            };
+        },
+    });
+}

package/dist/nodes/native/item-join/create-item-join-capability.d.ts

@@ -0,0 +1,4 @@
+import type { N8nNativeCapability } from '../../../types/native-capability.js';
+import type { CreateItemJoinCapabilityInput } from '../../../types/item-join.js';
+/** Preserve explicitly supplied original runtime names; later revisions bind contracts and SDK names separately. */
+export declare function createItemJoinCapability(input: CreateItemJoinCapabilityInput): N8nNativeCapability;

package/dist/nodes/native/item-join/create-item-join-capability.js

@@ -0,0 +1,10 @@
+import { createBoundItemJoinCapability } from './create-bound-item-join-capability.js';
+/** Preserve explicitly supplied original runtime names; later revisions bind contracts and SDK names separately. */
+export function createItemJoinCapability(input) {
+    if (input.scopes.some((scope) => typeof scope.nodeName !== 'string' || !scope.nodeName.trim()))
+        throw new Error('item join scopes require unique non-empty identities and compiled names');
+    return createBoundItemJoinCapability({
+        ...input,
+        runtime: { kind: 'provided', sources: input.scopes },
+    });
+}

package/dist/nodes/native/item-join/create-item-join-reader-code.d.ts

@@ -0,0 +1,2 @@
+import type { CreateItemJoinReaderCodeInput } from '../../../types/item-join.js';
+export declare function createItemJoinReaderCode({ scope, sourceCallId, sources, }: CreateItemJoinReaderCodeInput): string;

package/dist/nodes/native/item-join/create-item-join-reader-code.js

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
+import { createOutputReaderCode } from '../../request/bindings/create-output-reader-code.js';
+export function createItemJoinReaderCode({ scope, sourceCallId, sources, }) {
+    const runtime = readFileSync(new URL('../../request/runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
+    const read = createOutputReaderCode(sources, true);
+    return `${runtime}
+const scopeName=${javascriptJsonLiteral(scope.nodeName)};
+const sourceCallId=${javascriptJsonLiteral(sourceCallId)};
+const scopeItems=$(scopeName).all();
+return $input.all().map((_,inputIndex)=>{
+${read}
+const ancestor=$(scopeName).itemMatching(inputIndex);
+const matches=scopeItems.flatMap((item,index)=>item===ancestor?[index]:[]);
+if(matches.length!==1)throw new Error('Item join '+sourceCallId+': scope ancestry must identify exactly one item in the current scope execution');
+return {json:{scopeIndex:matches[0],sourceCallId,response:responses[sourceCallId]},pairedItem:{item:inputIndex}};
+});`;
+}

package/dist/nodes/native/item-join/item-join-definition.d.ts

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

package/dist/nodes/native/item-join/item-join-definition.js

@@ -0,0 +1,33 @@
+import { itemJoinParametersSchema } from '../../../schemas/item-join-schema.js';
+export const itemJoinDefinition = {
+    name: 'join-api-items',
+    materialRequirements: [
+        { field: 'apiMaterials', minimumItems: 2 },
+        { field: 'nativeOutputs', minimumItems: 1 },
+    ],
+    description: 'Join API branches by their shared native scope item ancestry. Each participating item requires exactly one full OAS-valid response per API. Different orders and duplicate JSON values are safe. Missing/duplicate branch responses fail; no business-ID matching, index zip, Cartesian product or value conversion. Output {responses: {callId: unchangedBody}}.',
+    parametersSchema: itemJoinParametersSchema,
+    parameterReferenceSources: ['response', 'node-output'],
+    inputPorts: (values) => Array.from({ length: itemJoinParametersSchema.parse(values).sourceCallIds.length }, (_, index) => `input${index + 1}`),
+    outputPorts: () => ['main'],
+    referenceStructureSchema: itemJoinParametersSchema,
+    parameterReferenceBindings: (values) => {
+        const parameters = itemJoinParametersSchema.parse(values);
+        return [
+            ...parameters.sourceCallIds.map((nodeId, index) => ({
+                nodeIdPointer: `/sourceCallIds/${index}`,
+                reference: { source: 'response', nodeId, pointer: '' },
+            })),
+            {
+                nodeIdPointer: '/scopeNodeId',
+                reference: {
+                    source: 'node-output',
+                    nodeId: parameters.scopeNodeId,
+                    pointer: '',
+                },
+            },
+        ];
+    },
+    waitsForAllInputs: true,
+    exclusiveOutputPorts: false,
+};

package/dist/nodes/native/item-join/runtime/item-join-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 OpenApiFlowItemJoinRuntime;
+(()=>{function r({items:p,sourceCallIds:i}){if(i.length<2||new Set(i).size!==i.length)throw new Error("item join requires unique sourceCallIds");let s=new Map;for(let[n,o]of p.entries()){let e=o.json;if(!e||!Number.isInteger(e.scopeIndex)||e.scopeIndex<0)throw new Error(`item join input ${n}: scopeIndex is missing or invalid`);if(!i.includes(e.sourceCallId))throw new Error(`item join input ${n}: unknown sourceCallId ${e.sourceCallId}`);if(!Object.hasOwn(e,"response")||e.response===void 0)throw new Error(`item join input ${n}: response is missing`);let t=s.get(e.scopeIndex);if(t||(t={values:new Map,inputIndexes:[]},s.set(e.scopeIndex,t)),t.values.has(e.sourceCallId))throw new Error(`item join scope item ${e.scopeIndex}: duplicate response ${e.sourceCallId}`);t.values.set(e.sourceCallId,e.response),t.inputIndexes.push(n)}for(let[n,o]of s)for(let e of i)if(!o.values.has(e))throw new Error(`item join scope item ${n}: missing response ${e}`);return[...s].sort(([n],[o])=>n-o).map(([,n])=>({json:{responses:Object.fromEntries(i.map(o=>[o,n.values.get(o)]))},pairedItem:n.inputIndexes.map(o=>({item:o}))}))}OpenApiFlowItemJoinRuntime={joinApiItems:r};})();

package/dist/nodes/native/item-join/runtime/join-api-items.d.ts

@@ -0,0 +1,3 @@
+import type { ItemJoinOutputItem, JoinApiItemsInput } from '../../../../types/item-join.js';
+/** Join only reader-attested ancestry, never JSON business fields or stream positions. */
+export declare function joinApiItems({ items, sourceCallIds, }: JoinApiItemsInput): ItemJoinOutputItem[];

package/dist/nodes/native/item-join/runtime/join-api-items.js

@@ -0,0 +1,37 @@
+/** Join only reader-attested ancestry, never JSON business fields or stream positions. */
+export function joinApiItems({ items, sourceCallIds, }) {
+    if (sourceCallIds.length < 2 ||
+        new Set(sourceCallIds).size !== sourceCallIds.length)
+        throw new Error('item join requires unique sourceCallIds');
+    const groups = new Map();
+    for (const [inputIndex, item] of items.entries()) {
+        const row = item.json;
+        if (!row || !Number.isInteger(row.scopeIndex) || row.scopeIndex < 0)
+            throw new Error(`item join input ${inputIndex}: scopeIndex is missing or invalid`);
+        if (!sourceCallIds.includes(row.sourceCallId))
+            throw new Error(`item join input ${inputIndex}: unknown sourceCallId ${row.sourceCallId}`);
+        if (!Object.hasOwn(row, 'response') || row.response === undefined)
+            throw new Error(`item join input ${inputIndex}: response is missing`);
+        let group = groups.get(row.scopeIndex);
+        if (!group) {
+            group = { values: new Map(), inputIndexes: [] };
+            groups.set(row.scopeIndex, group);
+        }
+        if (group.values.has(row.sourceCallId))
+            throw new Error(`item join scope item ${row.scopeIndex}: duplicate response ${row.sourceCallId}`);
+        group.values.set(row.sourceCallId, row.response);
+        group.inputIndexes.push(inputIndex);
+    }
+    for (const [scopeIndex, group] of groups)
+        for (const id of sourceCallIds)
+            if (!group.values.has(id))
+                throw new Error(`item join scope item ${scopeIndex}: missing response ${id}`);
+    return [...groups]
+        .sort(([left], [right]) => left - right)
+        .map(([, group]) => ({
+        json: {
+            responses: Object.fromEntries(sourceCallIds.map((id) => [id, group.values.get(id)])),
+        },
+        pairedItem: group.inputIndexes.map((item) => ({ item })),
+    }));
+}

package/dist/nodes/native/merge-append-capability.d.ts

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

package/dist/nodes/native/merge-append-capability.js

@@ -0,0 +1,33 @@
+import { node } from '@n8n/workflow-sdk';
+import { mergeParametersSchema } from '../../schemas/native-capability-schemas.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+export function createMergeAppendCapability() {
+    return {
+        name: 'merge-append',
+        description: 'n8n Merge append: input1..inputN; main output. Waits for all independent incoming branches.',
+        parametersSchema: mergeParametersSchema,
+        parameterReferenceSources: [],
+        inputPorts: (parameters) => Array.from({ length: mergeParametersSchema.parse(parameters).numberInputs }, (_, index) => `input${index + 1}`),
+        outputPorts: () => ['main'],
+        responseReferences: () => [],
+        parameterReferenceBindings: () => [],
+        waitsForAllInputs: true,
+        exclusiveOutputPorts: false,
+        compile: ({ planned, position }) => {
+            const parameters = mergeParametersSchema.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: parameters.numberInputs,
+                    },
+                },
+            }), Array.from({ length: parameters.numberInputs }, (_, index) => `input${index + 1}`), ['main']);
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+import { N8nNativeFeature } from '../../../types/native-feature-registry.js';
+import type { N8nNativeFeatureDefinition } from '../../../types/native-feature-registry.js';
+/** Material prerequisites belong to their actual factories, not model prompts. */
+export declare const nativeFeatureDefinitions: Record<N8nNativeFeature, N8nNativeFeatureDefinition>;

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;