@openapi-flow/n8n 0.0.0-stage → 0.3.0

package/dist/legacy/workflow/request/request-url.js

@@ -0,0 +1,34 @@
+import { checkSchemaValue } from '@openapi-flow/core/internal';
+import { serializePathParameter, serializeQueryParameter, } from '@openapi-flow/core/internal';
+export function absoluteOperationPath(baseUrl, path) {
+    return baseUrl.origin + baseUrl.pathname.replace(/\/$/, '') + path;
+}
+export function makeUrl(operation, origin, inputs, missing) {
+    let path = operation.path;
+    for (const parameter of operation.parameters) {
+        if (parameter.in !== 'path' && parameter.in !== 'query')
+            continue;
+        const key = parameter.in + '.' + parameter.name;
+        const value = inputs[key];
+        if (value === undefined) {
+            if (parameter.required)
+                missing.push(key);
+            continue;
+        }
+        checkSchemaValue(value, parameter.schema, 'plan.inputs.' + key);
+        if (parameter.in === 'path')
+            path = path.replace('{' + parameter.name + '}', serializePathParameter(parameter, operation.operationRef, value));
+    }
+    const url = new URL(absoluteOperationPath(origin, path));
+    const query = [];
+    for (const parameter of operation.parameters) {
+        if (parameter.in !== 'query')
+            continue;
+        const key = 'query.' + parameter.name;
+        if (inputs[key] !== undefined)
+            query.push(...serializeQueryParameter(parameter, operation.operationRef, inputs[key]));
+    }
+    if (query.length)
+        url.search = query.join('&');
+    return url.href;
+}

package/dist/legacy/workflow/request/response-assertion-code.d.ts

@@ -0,0 +1,3 @@
+import type { RequiredFields } from '../../../types/legacy/request-node.js';
+import type { ExpectedBody } from '../../../types/legacy/request-workflow.js';
+export declare function assertionCode(expectedBody: ExpectedBody, requiredFields?: RequiredFields): string;

package/dist/legacy/workflow/request/response-assertion-code.js

@@ -0,0 +1,28 @@
+export function assertionCode(expectedBody, requiredFields = {}) {
+    const expected = JSON.stringify(expectedBody);
+    const required = JSON.stringify(requiredFields);
+    return [
+        'const items = $input.all();',
+        "if (items.length !== 1) throw new Error('Expected one response item');",
+        'const response = items[0].json;',
+        'const expected = ' + expected + ';',
+        'const required = ' + required + ';',
+        'function equal(actual, expectedValue) {',
+        '  if (Object.is(actual, expectedValue)) return true;',
+        '  if (actual === null || expectedValue === null || typeof actual !== "object" || typeof expectedValue !== "object") return false;',
+        '  if (Array.isArray(actual) !== Array.isArray(expectedValue)) return false;',
+        '  const keys = Object.keys(expectedValue);',
+        '  if (Object.keys(actual).length !== keys.length) return false;',
+        '  return keys.every((key) => Object.prototype.hasOwnProperty.call(actual, key) && equal(actual[key], expectedValue[key]));',
+        '}',
+        'for (const [key, type] of Object.entries(required)) {',
+        '  const value = response.body?.[key];',
+        '  const valid = type === "integer" ? Number.isSafeInteger(value) : type === "number" ? typeof value === "number" && Number.isFinite(value) : typeof value === type;',
+        '  if (!valid) throw new Error("Missing or invalid response body field: " + key);',
+        '}',
+        'for (const [key, value] of Object.entries(expected)) {',
+        '  if (!equal(response.body?.[key], value)) throw new Error("Unexpected response body field: " + key);',
+        '}',
+        'return items;',
+    ].join('\n');
+}

package/dist/legacy/workflow/request/sequence-url.d.ts

@@ -0,0 +1,4 @@
+import type { Operation } from '@openapi-flow/core/internal';
+import type { InputValues } from '../../../types/legacy/request-workflow.js';
+import type { PreviousOperations, RequiredOutputs } from '../../../types/legacy/sequence-workflow.js';
+export declare function sequenceUrl(operation: Operation, origin: URL, inputs: InputValues, previous: PreviousOperations, requiredOutputs: RequiredOutputs, missing: string[]): string;

package/dist/legacy/workflow/request/sequence-url.js

@@ -0,0 +1,104 @@
+import { responseFieldSchemas, responseFieldType, } from '@openapi-flow/core/internal';
+import { checkSchemaValue } from '@openapi-flow/core/internal';
+import { serializePathParameter, serializeQueryParameter, } from '@openapi-flow/core/internal';
+import { UnsupportedOperationError } from '@openapi-flow/core/internal';
+import { isObject } from '@openapi-flow/core/internal';
+import { looksLikeCredential } from './credential-binding.js';
+import { absoluteOperationPath, makeUrl } from './request-url.js';
+export function sequenceUrl(operation, origin, inputs, previous, requiredOutputs, missing) {
+    let path = operation.path;
+    const references = new Map();
+    for (const parameter of operation.parameters) {
+        if (parameter.in !== 'path' && parameter.in !== 'query')
+            continue;
+        const key = parameter.in + '.' + parameter.name;
+        const value = inputs[key];
+        if (value === undefined) {
+            if (parameter.required)
+                missing.push(key);
+            continue;
+        }
+        if (isObject(value)) {
+            if (typeof value.fromStep !== 'string' ||
+                typeof value.field !== 'string' ||
+                Object.keys(value).length !== 2) {
+                throw new Error('plan.inputs.' + key + ' must have fromStep and field');
+            }
+            if (looksLikeCredential(value.field)) {
+                throw new Error('plan.inputs.' + key + ' references a credential-like response field');
+            }
+            const source = previous.get(value.fromStep);
+            if (!source || responseFieldSchemas(source, value.field).length === 0) {
+                throw new Error('plan.inputs.' + key + ' must reference a prior response field');
+            }
+            const sourceType = responseFieldType(source, value.field);
+            const targetType = typeof parameter.schema === 'object'
+                ? parameter.schema.type
+                : undefined;
+            if ((parameter.in === 'path' && parameter.style !== 'simple') ||
+                (parameter.in === 'query' && parameter.style !== 'form') ||
+                parameter.contentMediaType !== undefined ||
+                parameter.allowReserved ||
+                !['string', 'number', 'integer', 'boolean'].includes(String(targetType)))
+                throw new UnsupportedOperationError(operation.operationRef, `operationRef ${operation.operationRef} parameter ${key} cannot serialize a sequence response reference`);
+            if (sourceType !== targetType &&
+                !(sourceType === 'integer' && targetType === 'number')) {
+                throw new Error('plan.inputs.' + key + ' has a response type mismatch');
+            }
+            const required = requiredOutputs.get(value.fromStep) ?? new Set();
+            required.add(value.field);
+            requiredOutputs.set(value.fromStep, required);
+            references.set(key, '$node[' +
+                JSON.stringify('Request ' + value.fromStep) +
+                '].json.body[' +
+                JSON.stringify(value.field) +
+                ']');
+        }
+        else {
+            checkSchemaValue(value, parameter.schema, 'plan.inputs.' + key);
+            if (parameter.in === 'path')
+                path = path.replace('{' + parameter.name + '}', serializePathParameter(parameter, operation.operationRef, value));
+        }
+    }
+    if (missing.length)
+        return '';
+    if (references.size === 0)
+        return makeUrl(operation, origin, inputs, []);
+    const absolute = absoluteOperationPath(origin, path);
+    const parts = [];
+    let offset = 0;
+    for (const match of absolute.matchAll(/\{([^}]+)\}/g)) {
+        const key = 'path.' + match[1];
+        const reference = references.get(key);
+        if (!reference)
+            throw new Error('plan.inputs.' + key + ' is required');
+        parts.push(JSON.stringify(absolute.slice(offset, match.index)), 'encodeURIComponent(' + reference + ')');
+        offset = match.index + match[0].length;
+    }
+    parts.push(JSON.stringify(absolute.slice(offset)));
+    let expression = parts.join(' + ');
+    let firstQuery = true;
+    for (const parameter of operation.parameters) {
+        if (parameter.in !== 'query' ||
+            inputs['query.' + parameter.name] === undefined)
+            continue;
+        const key = 'query.' + parameter.name;
+        const reference = references.get(key);
+        if (reference) {
+            expression +=
+                ' + ' +
+                    JSON.stringify((firstQuery ? '?' : '&') + encodeURIComponent(parameter.name) + '=') +
+                    ' + encodeURIComponent(' +
+                    reference +
+                    ')';
+        }
+        else {
+            expression +=
+                ' + ' +
+                    JSON.stringify((firstQuery ? '?' : '&') +
+                        serializeQueryParameter(parameter, operation.operationRef, inputs[key]).join('&'));
+        }
+        firstQuery = false;
+    }
+    return '={{ ' + expression + ' }}';
+}

package/dist/legacy-api.d.ts

@@ -0,0 +1,25 @@
+export * from './legacy/workflow/common/plan-validation.js';
+export * from './legacy/workflow/common/workflow-id.js';
+export * from './legacy/workflow/inbound/build-inbound-workflow.js';
+export * from './legacy/workflow/inbound/compile-inbound-workflow.js';
+export * from './legacy/workflow/inbound/inbound-response.js';
+export * from './legacy/workflow/request/base-url.js';
+export * from './legacy/workflow/request/build-request-workflow.js';
+export * from './legacy/workflow/request/build-sequence-workflow.js';
+export * from './legacy/workflow/request/compile-catalog-sequence.js';
+export * from './legacy/workflow/request/compile-sequence.js';
+export * from './legacy/workflow/request/compile-workflow.js';
+export * from './legacy/workflow/request/credential-binding.js';
+export * from './legacy/workflow/request/effect-policy.js';
+export * from './legacy/workflow/request/http-request-node.js';
+export * from './legacy/workflow/request/prepare-sequence.js';
+export * from './legacy/workflow/request/request-body.js';
+export * from './legacy/workflow/request/request-headers.js';
+export * from './legacy/workflow/request/request-url.js';
+export * from './legacy/workflow/request/response-assertion-code.js';
+export * from './legacy/workflow/request/sequence-url.js';
+export type * from './types/legacy/catalog-workflow.js';
+export type * from './types/legacy/inbound-workflow.js';
+export type * from './types/legacy/request-node.js';
+export type * from './types/legacy/request-workflow.js';
+export type * from './types/legacy/sequence-workflow.js';

package/dist/legacy-api.js

@@ -0,0 +1,20 @@
+export * from './legacy/workflow/common/plan-validation.js';
+export * from './legacy/workflow/common/workflow-id.js';
+export * from './legacy/workflow/inbound/build-inbound-workflow.js';
+export * from './legacy/workflow/inbound/compile-inbound-workflow.js';
+export * from './legacy/workflow/inbound/inbound-response.js';
+export * from './legacy/workflow/request/base-url.js';
+export * from './legacy/workflow/request/build-request-workflow.js';
+export * from './legacy/workflow/request/build-sequence-workflow.js';
+export * from './legacy/workflow/request/compile-catalog-sequence.js';
+export * from './legacy/workflow/request/compile-sequence.js';
+export * from './legacy/workflow/request/compile-workflow.js';
+export * from './legacy/workflow/request/credential-binding.js';
+export * from './legacy/workflow/request/effect-policy.js';
+export * from './legacy/workflow/request/http-request-node.js';
+export * from './legacy/workflow/request/prepare-sequence.js';
+export * from './legacy/workflow/request/request-body.js';
+export * from './legacy/workflow/request/request-headers.js';
+export * from './legacy/workflow/request/request-url.js';
+export * from './legacy/workflow/request/response-assertion-code.js';
+export * from './legacy/workflow/request/sequence-url.js';

package/dist/nodes/common/validation/compile-standalone-validator.d.ts

@@ -0,0 +1,3 @@
+import type { CompileStandaloneValidatorInput } from '../../../types/schema-compilation.js';
+/** Compile on the host; generated n8n nodes receive validators, not eval. */
+export declare function compileStandaloneValidator({ schema, globalName, }: CompileStandaloneValidatorInput): string;

package/dist/nodes/common/validation/compile-standalone-validator.js

@@ -0,0 +1,44 @@
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import { _ } from 'ajv/dist/compile/codegen/index.js';
+import addFormats from 'ajv-formats';
+import standaloneCode from 'ajv/dist/standalone/index.js';
+import { buildSync } from 'esbuild';
+import { createRequire } from 'node:module';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { bundledLicenseBanner } from '../../../utils/bundled-license-banner.js';
+/** Compile on the host; generated n8n nodes receive validators, not eval. */
+export function compileStandaloneValidator({ schema, globalName, }) {
+    const ajv = new Ajv2020({
+        strict: false,
+        allErrors: true,
+        discriminator: true,
+        code: {
+            source: true,
+            // Own the standalone format expression with this compiler's Code class.
+            formats: _ `require("ajv-formats/dist/formats").fullFormats`,
+        },
+    });
+    addFormats.default(ajv);
+    const compiled = standaloneCode.default(ajv, ajv.compile(schema));
+    const built = buildSync({
+        stdin: { contents: compiled, resolveDir: import.meta.dirname },
+        bundle: true,
+        platform: 'browser',
+        format: 'iife',
+        globalName,
+        target: 'es2022',
+        minify: true,
+        write: false,
+        legalComments: 'inline',
+        metafile: true,
+        // Standard keywords stay intact. JSON equality must not inspect constructors.
+        alias: {
+            'ajv/dist/runtime/equal': fileURLToPath(new URL('../../../utils/json-values-equal.cjs', import.meta.url)),
+        },
+    });
+    const require = createRequire(import.meta.url);
+    return (bundledLicenseBanner(built.metafile, [
+        dirname(require.resolve('ajv/package.json')),
+    ]) + built.outputFiles[0].text);
+}

package/dist/nodes/gap/create-gap-node.d.ts

@@ -0,0 +1,3 @@
+import type { CreateGapNodeInput } from '../../types/reviewable-workflow.js';
+import type { N8nNodeFragment } from '../../types/node-fragment.js';
+export declare function createGapNode(input: CreateGapNodeInput): N8nNodeFragment;

package/dist/nodes/gap/create-gap-node.js

@@ -0,0 +1,35 @@
+import { node } from '@n8n/workflow-sdk';
+import { javascriptJsonLiteral } from '../../utils/javascript-json-literal.js';
+export function createGapNode(input) {
+    if (!input.nodeId.trim() || !input.gaps.length)
+        throw new Error('gap node requires an ID and reported gaps');
+    const message = 'OPENAPI_FLOW_UNRESOLVED_STEP ' +
+        input.nodeId +
+        ': ' +
+        input.gaps.map((gap) => gap.description).join('; ');
+    const placeholder = node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: input.nodeId,
+            name: '확인 필요 · ' + input.nodeId,
+            position: input.position,
+            notes: '미해결 단계입니다. 실행하면 오류로 중단됩니다.',
+            notesInFlow: true,
+            onError: 'stopWorkflow',
+            parameters: {
+                mode: 'runOnceForAllItems',
+                language: 'javaScript',
+                jsCode: `throw new Error(${javascriptJsonLiteral(message)});`,
+            },
+        },
+    });
+    return {
+        nodeId: input.nodeId,
+        nodes: [placeholder],
+        entry: placeholder,
+        exit: placeholder,
+        inputPorts: { main: 0 },
+        outputPorts: { main: 0 },
+    };
+}

package/dist/nodes/inputs/compile-template-input-validators.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowRuntimeInputSlot } from '@openapi-flow/core';
+/** Preserve every original $id and local $ref by compiling slot roots separately. */
+export declare function compileTemplateInputValidators(slots: WorkflowRuntimeInputSlot[]): string;

package/dist/nodes/inputs/compile-template-input-validators.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { createWorkflowRuntimeInputsSchema } from '@openapi-flow/core';
+import { createWorkflowInputValueMapSchema } from '../../schemas/workflow-input-value-map-schema.js';
+import { javascriptJsonLiteral } from '../../utils/javascript-json-literal.js';
+import { compileStandaloneValidator } from '../common/validation/compile-standalone-validator.js';
+/** Preserve every original $id and local $ref by compiling slot roots separately. */
+export function compileTemplateInputValidators(slots) {
+    const contract = createWorkflowRuntimeInputsSchema(slots);
+    const envelope = compileStandaloneValidator({
+        schema: z.toJSONSchema(createWorkflowInputValueMapSchema(Object.keys(contract.shape)), { io: 'input' }),
+        globalName: 'OpenApiFlowInputsValidator',
+    });
+    const values = Object.entries(contract.shape).map(([id, schema], index) => {
+        const name = `OpenApiFlowInputSlotValidator${index}`;
+        const validator = compileStandaloneValidator({
+            schema: z.toJSONSchema(schema, { io: 'input' }),
+            globalName: name,
+        });
+        const slot = slots.find((entry) => entry.id === id);
+        const presence = slot.kind === 'api-request-input' && slot.requestedInputs !== undefined
+            ? `\n{const missing=OpenApiFlowRequestRuntime.listMissingRequestedApiInputs({source:${javascriptJsonLiteral('Runtime input ' + id)},rootPointer:${javascriptJsonLiteral(slot.targetPointer)},value:payload.values[${javascriptJsonLiteral(id)}],requestedInputs:${javascriptJsonLiteral(slot.requestedInputs)}});if(missing.length)throw new Error('Workflow input omits scenario-requested inputs: '+missing.join(', '));}`
+            : '';
+        return `${validator}\nif(!${name}(payload.values[${javascriptJsonLiteral(id)}]))throw new Error('Workflow inputs do not match declared slots: '+${javascriptJsonLiteral(id)}+': '+JSON.stringify(${name}.errors));${presence}`;
+    });
+    return `${envelope}\nif(!OpenApiFlowInputsValidator(payload.values))throw new Error('Workflow inputs do not match declared slots: '+JSON.stringify(OpenApiFlowInputsValidator.errors));\n${values.join('\n')}`;
+}

package/dist/nodes/inputs/create-template-input-nodes.d.ts

@@ -0,0 +1,4 @@
+import type { CreateTemplateInputNodesInput } from '../../types/workflow-template.js';
+import type { N8nNodeFragment } from '../../types/node-fragment.js';
+/** Compile immutable contracts; the user edits only the separate actual-value map. */
+export declare function createTemplateInputNodes(input: CreateTemplateInputNodesInput): N8nNodeFragment[];

package/dist/nodes/inputs/create-template-input-nodes.js

@@ -0,0 +1,61 @@
+import { readFileSync } from 'node:fs';
+import { node } from '@n8n/workflow-sdk';
+import { javascriptJsonLiteral } from '../../utils/javascript-json-literal.js';
+import { compileTemplateInputValidators } from './compile-template-input-validators.js';
+import { compileRequestValidator } from '../request/bindings/compile-request-validator.js';
+import { compileStandaloneValidator } from '../common/validation/compile-standalone-validator.js';
+import { createNativeFragment } from '../native/common/create-native-fragment.js';
+import { TEMPLATE_INPUT_ID, TEMPLATE_INPUT_NAME, TEMPLATE_PREFLIGHT_ID, TEMPLATE_PREFLIGHT_NAME, } from '../../workflow/templates/workflow-template-identities.js';
+/** Compile immutable contracts; the user edits only the separate actual-value map. */
+export function createTemplateInputNodes(input) {
+    const validators = compileTemplateInputValidators(input.slots);
+    const setup = node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: TEMPLATE_INPUT_ID,
+            name: TEMPLATE_INPUT_NAME,
+            position: [220, 0],
+            notes: '실제 값은 inputValues 객체에 슬롯 ID를 키로 추가하세요. 미입력 키는 생략하세요. 타입·스키마·revision은 바꾸지 마세요. 인증 비밀값은 n8n credential에 설정하세요.',
+            notesInFlow: true,
+            parameters: {
+                mode: 'runOnceForAllItems',
+                jsCode: `// 실제 값만 입력하세요. 미입력 값에 임시 값을 넣지 마세요.\nconst inputValues=${javascriptJsonLiteral(input.inputValues)};\nreturn [{json:{revision:${input.revision},values:inputValues}}];`,
+            },
+        },
+    });
+    const runtime = readFileSync(new URL('../request/runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
+    const nativeRuntime = readFileSync(new URL('../native/inputs/native-input-runtime.bundle.js', import.meta.url), 'utf8');
+    // A request without runtime response dependencies can be checked completely
+    // before any branch performs an external call. Dependent requests are checked
+    // again by their materializers after the actual producers have executed.
+    const earlyChecks = input.requests
+        .filter((request) => !request.arguments.bindings.length)
+        .map((request, index) => {
+        const name = `OpenApiFlowInitialRequestValidator${index}`;
+        return `${compileRequestValidator(request, name)}\nOpenApiFlowRequestRuntime.materializeHttpRequest(${javascriptJsonLiteral(request)},Object.create(null),${name},payload.values);`;
+    });
+    const nativeChecks = input.nativeParameters.map((material, index) => {
+        const name = `OpenApiFlowInitialNativeValidator${index}`;
+        return `${compileStandaloneValidator({ schema: material.schema, globalName: name })}\n{const parameters=OpenApiFlowNativeInputRuntime.materializeNativeRuntimeParameters(${javascriptJsonLiteral(material)},payload.values);if(!${name}(parameters))throw new Error('Native runtime input violates complete original schema for '+${javascriptJsonLiteral(material.nodeId)}+': '+JSON.stringify(${name}.errors));}`;
+    });
+    const preflight = node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: TEMPLATE_PREFLIGHT_ID,
+            name: TEMPLATE_PREFLIGHT_NAME,
+            position: [440, 0],
+            notes: '모든 초기 입력을 외부 호출 전에 검사합니다. 선행 응답을 사용하는 요청은 해당 응답을 합친 후 전송 직전에 전체 OAS를 다시 검사합니다. 부분 실행·pinning으로 검사를 건너뛰지 마세요.',
+            notesInFlow: true,
+            parameters: {
+                mode: 'runOnceForAllItems',
+                jsCode: `${runtime}\n${nativeRuntime}\nconst items=$input.all();if(items.length!==1)throw new Error('Workflow input setup requires exactly one JSON item');const payload=items[0].json;if(!payload||payload.revision!==${input.revision})throw new Error('Missing or stale workflow input revision');\n${validators}\n${nativeChecks.join('\n')}\n${earlyChecks.join('\n')}\nreturn [{json:payload,pairedItem:{item:0}}];`,
+            },
+        },
+    });
+    return [
+        createNativeFragment(setup, ['main'], ['main']),
+        createNativeFragment(preflight, ['main'], ['main']),
+    ];
+}

package/dist/nodes/native/arrays/create-array-node-fragment.d.ts

@@ -0,0 +1,4 @@
+import type { CreateArrayNodeFragmentInput } from '../../../types/array-split.js';
+import type { N8nNodeFragment } from '../../../types/node-fragment.js';
+/** Share SDK array mechanics without merging API and native source contracts. */
+export declare function createArrayNodeFragment({ planned, position, source, parameters, linked, }: CreateArrayNodeFragmentInput): N8nNodeFragment;

package/dist/nodes/native/arrays/create-array-node-fragment.js

@@ -0,0 +1,42 @@
+import { node } from '@n8n/workflow-sdk';
+import { createArrayReaderCode } from './create-array-reader-code.js';
+/** Share SDK array mechanics without merging API and native source contracts. */
+export function createArrayNodeFragment({ planned, position, source, parameters, linked, }) {
+    const extract = node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: `${planned.id}-read-array`,
+            name: `Read array ${planned.id}`,
+            position,
+            parameters: {
+                mode: 'runOnceForAllItems',
+                jsCode: createArrayReaderCode(source, parameters, linked),
+            },
+        },
+    });
+    const split = node({
+        type: 'n8n-nodes-base.splitOut',
+        version: 1,
+        config: {
+            id: planned.id,
+            name: planned.id,
+            position: [position[0] + 220, position[1]],
+            parameters: {
+                fieldToSplitOut: 'items',
+                include: 'noOtherFields',
+                options: { destinationFieldName: 'item', disableDotNotation: true },
+            },
+        },
+    });
+    return {
+        nodeId: planned.id,
+        bindingSources: [source],
+        nodes: [extract, split],
+        entry: extract,
+        exit: split,
+        inputPorts: { main: 0 },
+        outputPorts: { main: 0 },
+        internalEdges: [{ from: extract.id, output: 0, to: split.id, input: 0 }],
+    };
+}

package/dist/nodes/native/arrays/create-array-reader-code.d.ts

@@ -0,0 +1,3 @@
+import type { N8nOutputBindingSource } from '../../../types/output-binding-source.js';
+import type { ArraySplitParameters } from '../../../types/array-split.js';
+export declare function createArrayReaderCode(source: N8nOutputBindingSource, parameters: ArraySplitParameters, linked: boolean): string;

package/dist/nodes/native/arrays/create-array-reader-code.js

@@ -0,0 +1,12 @@
+import { readFileSync } from 'node:fs';
+import { createOutputReaderCode } from '../../request/bindings/create-output-reader-code.js';
+import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
+export function createArrayReaderCode(source, parameters, linked) {
+    const runtime = readFileSync(new URL('../../request/runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
+    const read = createOutputReaderCode([source], linked);
+    const extract = `${read}\nconst parameters=${javascriptJsonLiteral(parameters)};\nconst array=OpenApiFlowRequestRuntime.pointerValue(responses[parameters.sourceNodeId],parameters.pointer);if(array===undefined)throw new Error('Missing array pointer '+parameters.sourceNodeId+parameters.pointer);if(!Array.isArray(array))throw new Error('Output '+parameters.sourceNodeId+parameters.pointer+' must be an array');`;
+    const iteration = linked
+        ? `return inputItems.map((_,inputIndex)=>{${extract}\nreturn {json:{items:array},pairedItem:{item:inputIndex}};});`
+        : `if(inputItems.length!==1)throw new Error('Array extraction requires one input item; got '+inputItems.length);\n${extract}\nreturn [{json:{items:array},pairedItem:{item:0}}];`;
+    return `${runtime}\nconst inputItems=$input.all();\n${iteration}`;
+}

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

@@ -0,0 +1,4 @@
+import type { N8nNativeCapability } from '../../../types/native-capability.js';
+import type { BoundNativeArrayCapabilityInput } from '../../../types/native-material-binding.js';
+/** Data-contract binding is independent of runtime SDK producer names. */
+export declare function createBoundNativeArrayCapability(input: BoundNativeArrayCapabilityInput): N8nNativeCapability;

package/dist/nodes/native/arrays/create-bound-native-array-capability.js

@@ -0,0 +1,81 @@
+import { defineMaterialBoundCapability } from '../common/define-material-bound-capability.js';
+import { createNativeArrayItemSchema, validateNativeOutputContracts, } from '@openapi-flow/core';
+import { createNativeArrayParametersSchema } from '../../../schemas/native-array-schema.js';
+import { nativeArrayDefinition } from './native-array-definition.js';
+import { createArrayNodeFragment } from './create-array-node-fragment.js';
+import { resolveNativeRuntimeSource } from '../common/resolve-native-runtime-source.js';
+/** Data-contract binding is independent of runtime SDK producer names. */
+export function createBoundNativeArrayCapability(input) {
+    if (input.itemMode !== undefined && input.itemMode !== 'linked')
+        throw new Error('native array capability: itemMode must be linked or omitted');
+    validateNativeOutputContracts(input.sources);
+    if (!input.sources.length)
+        throw new Error('native array capability requires source contracts');
+    const contracts = input.sources.map(({ nodeId, schema }) => ({
+        nodeId,
+        schema,
+    }));
+    const sources = new Map(contracts.map((source) => [source.nodeId, source]));
+    const parametersSchema = createNativeArrayParametersSchema([
+        ...sources.keys(),
+    ]);
+    function source(parameters) {
+        const output = sources.get(parameters.sourceNodeId);
+        if (!output)
+            throw new Error(`native array: unknown sourceNodeId ${parameters.sourceNodeId}`);
+        createNativeArrayItemSchema(output, parameters.pointer);
+        return output;
+    }
+    return defineMaterialBoundCapability({
+        ...nativeArrayDefinition,
+        parametersSchema,
+        materialSources: {
+            apiMaterials: [],
+            nativeOutputs: structuredClone(contracts),
+        },
+        bindMaterialContracts: (contracts) => createBoundNativeArrayCapability({
+            sources: contracts.nativeOutputs,
+            itemMode: input.itemMode,
+            runtime: { kind: 'compiled' },
+        }),
+        responseReferences: () => [],
+        nodeOutputReferences: (values) => {
+            const parameters = parametersSchema.parse(values);
+            source(parameters);
+            return [
+                {
+                    source: 'node-output',
+                    nodeId: parameters.sourceNodeId,
+                    pointer: parameters.pointer,
+                },
+            ];
+        },
+        outputSchema: (values) => {
+            const parameters = parametersSchema.parse(values);
+            return {
+                type: 'object',
+                properties: {
+                    item: createNativeArrayItemSchema(source(parameters), parameters.pointer),
+                },
+                required: ['item'],
+                additionalProperties: false,
+            };
+        },
+        compile: ({ planned, position, nativeOutputSources }) => {
+            const parameters = parametersSchema.parse(planned.parameters);
+            const runtime = resolveNativeRuntimeSource({
+                binding: input.runtime,
+                contract: source(parameters),
+                compiledSources: nativeOutputSources,
+                consumerId: planned.id,
+            });
+            return createArrayNodeFragment({
+                planned,
+                position,
+                source: { ...runtime, kind: 'native-json' },
+                parameters,
+                linked: input.itemMode === 'linked',
+            });
+        },
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { N8nNativeCapability } from '../../../types/native-capability.js';
+import type { CreateNativeArrayCapabilityInput } from '../../../types/native-array.js';
+/** Existing explicitly named sources remain an immutable binding. New revisions bind contracts separately. */
+export declare function createNativeArrayCapability(input: CreateNativeArrayCapabilityInput): N8nNativeCapability;

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

@@ -0,0 +1,12 @@
+import { createBoundNativeArrayCapability } from './create-bound-native-array-capability.js';
+/** Existing explicitly named sources remain an immutable binding. New revisions bind contracts separately. */
+export function createNativeArrayCapability(input) {
+    if (!input.sources.length ||
+        input.sources.some((source) => typeof source.nodeName !== 'string' || !source.nodeName.trim()))
+        throw new Error('native array capability requires sources with compiled names');
+    return createBoundNativeArrayCapability({
+        sources: input.sources,
+        itemMode: input.itemMode,
+        runtime: { kind: 'provided', sources: input.sources },
+    });
+}

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

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

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

@@ -0,0 +1,27 @@
+import { nativeArrayParametersSchema } from '../../../schemas/native-array-schema.js';
+export const nativeArrayDefinition = {
+    name: 'split-native-output-array',
+    materialRequirements: [{ field: 'nativeOutputs', minimumItems: 1 }],
+    description: 'Split a supplied native JSON output array into {item: unchangedElement} using official n8n Split Out. Validate the full native output schema first. Linked mode preserves parent ancestry across nested splits. Empty arrays emit no child items; never convert, flatten or fabricate values.',
+    parametersSchema: nativeArrayParametersSchema,
+    parameterReferenceSources: ['node-output'],
+    inputPorts: () => ['main'],
+    outputPorts: () => ['main'],
+    referenceStructureSchema: nativeArrayParametersSchema,
+    parameterReferenceBindings: (values) => {
+        const parameters = nativeArrayParametersSchema.parse(values);
+        return [
+            {
+                nodeIdPointer: '/sourceNodeId',
+                valuePointer: '/pointer',
+                reference: {
+                    source: 'node-output',
+                    nodeId: parameters.sourceNodeId,
+                    pointer: parameters.pointer,
+                },
+            },
+        ];
+    },
+    waitsForAllInputs: false,
+    exclusiveOutputPorts: false,
+};

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

@@ -0,0 +1,4 @@
+import type { N8nNativeCapability } from '../../../types/native-capability.js';
+import type { NativeMaterialFeatureDefinition } from '../../../types/native-material-binding.js';
+/** A stable implementation definition, not a ready output contract or executable node. */
+export declare function createMaterialPlanningCapability(definition: NativeMaterialFeatureDefinition, bind: NonNullable<N8nNativeCapability['bindMaterialContracts']>): N8nNativeCapability;