@openapi-flow/n8n 0.2.0 → 0.3.1

package/dist/types/native-feature-registry.js

@@ -0,0 +1,14 @@
+/** Supported OSS feature families, not every built-in node in n8n. */
+export const N8nNativeFeature = Object.freeze({
+    If: 'if',
+    MergeAppend: 'merge-append',
+    AssertResponses: 'assert-responses',
+    StopAndError: 'stop-and-error',
+    PassThrough: 'pass-through',
+    RejoinExclusiveBranches: 'rejoin-exclusive-branches',
+    JsonOutput: 'json-output',
+    SplitApiResponseArray: 'split-api-response-array',
+    CollectApiResponses: 'collect-api-responses',
+    SplitNativeOutputArray: 'split-native-output-array',
+    JoinApiItems: 'join-api-items',
+});

package/dist/types/native-material-binding.d.ts

@@ -0,0 +1,56 @@
+import type { NativeOutputContract, ApiBindingMaterial, PlannedNativeNode, WorkflowNativeMaterialSources } from '@openapi-flow/core';
+import type { N8nNativeOutputSource } from './output-binding-source.js';
+import type { NativeItemExecutionOptions } from './native-capability.js';
+import type { N8nNativeCapability } from './native-capability.js';
+import type { N8nNodeFragment } from './node-fragment.js';
+export type NativeRuntimeSourceBinding = {
+    kind: 'provided';
+    sources: N8nNativeOutputSource[];
+} | {
+    kind: 'compiled';
+};
+export interface ResolveNativeRuntimeSourceInput {
+    binding: NativeRuntimeSourceBinding;
+    contract: NativeOutputContract;
+    compiledSources?: N8nNativeOutputSource[];
+    consumerId: string;
+}
+export interface BoundNativeArrayCapabilityInput extends NativeItemExecutionOptions {
+    sources: NativeOutputContract[];
+    runtime: NativeRuntimeSourceBinding;
+}
+export interface BoundItemJoinCapabilityInput {
+    materials: ApiBindingMaterial[];
+    scopes: NativeOutputContract[];
+    runtime: NativeRuntimeSourceBinding;
+}
+export interface ResolveN8nNativeMaterialsInput {
+    apiMaterials: ApiBindingMaterial[];
+    nativeOutputs: NativeOutputContract[];
+    nativeNodes: PlannedNativeNode[];
+    capabilities: N8nNativeCapability[];
+}
+export interface ResolvedN8nNativeMaterials {
+    capabilities: N8nNativeCapability[];
+    outputs: NativeOutputContract[];
+}
+export interface CompileNativeMaterialFragmentsInput {
+    nativeNodes: PlannedNativeNode[];
+    materials: ResolvedN8nNativeMaterials;
+    apiMaterials: ApiBindingMaterial[];
+    apiNodeNames: Record<string, string>;
+    singletonApiResponseIds?: string[];
+    externalNativeOutputSources: N8nNativeOutputSource[];
+    nodeIds: string[];
+}
+export interface CompiledNativeMaterialFragments {
+    fragments: N8nNodeFragment[];
+    outputSources: N8nNativeOutputSource[];
+}
+export interface MaterialBindableN8nCapability extends N8nNativeCapability {
+    bindMaterialContracts: NonNullable<N8nNativeCapability['bindMaterialContracts']>;
+}
+export interface MaterialBoundN8nCapability extends MaterialBindableN8nCapability {
+    materialSources: WorkflowNativeMaterialSources;
+}
+export type NativeMaterialFeatureDefinition = Pick<N8nNativeCapability, 'name' | 'description' | 'parametersSchema' | 'parameterReferenceSources' | 'referenceStructureSchema' | 'parameterReferenceBindings' | 'waitsForAllInputs' | 'exclusiveOutputPorts' | 'materialRequirements' | 'inputPorts' | 'outputPorts'>;

package/dist/types/native-material-binding.js

@@ -0,0 +1 @@
+export {};

package/dist/types/native-runtime-parameters.d.ts

@@ -0,0 +1,55 @@
+import type { NativeRuntimeParameterMaterialization, NativeRuntimeInputSlot, NativeRuntimeInputValues, PlannedNativeNode, ApiBindingMaterial, NativeOutputContract } from '@openapi-flow/core';
+import type { N8nTemplateInputSlotMapping } from './workflow-template.js';
+import type { BuildN8nWorkflowInput, N8nWorkflowJSON } from './workflow-compilation.js';
+import type { CompileNativeNodeInput, N8nNativeCapability } from './native-capability.js';
+import type { N8nNodeFragment } from './node-fragment.js';
+export interface N8nNativeRuntimeInput {
+    materialization: NativeRuntimeParameterMaterialization;
+    revision: number;
+    inputNodeName: string;
+}
+export interface PrependNativeParameterGuardInput {
+    input: CompileNativeNodeInput;
+    capability: N8nNativeCapability;
+    fragment: N8nNodeFragment;
+}
+export interface N8nNativeInputConfiguration {
+    revision: number;
+    /** Omission leaves actual execution values absent; no dummy values are generated. */
+    inputValues?: NativeRuntimeInputValues;
+}
+export type N8nNativeInputSlot = NativeRuntimeInputSlot & N8nTemplateInputSlotMapping;
+export interface N8nNativeInputTemplate {
+    revision: number;
+    inputsReady: boolean;
+    inputSlots: N8nNativeInputSlot[];
+    guide: string;
+}
+export interface PrepareNativeRuntimeInputsInput {
+    nativeNodes: PlannedNativeNode[];
+    capabilities: N8nNativeCapability[];
+    apiMaterials: ApiBindingMaterial[];
+    nativeOutputs: NativeOutputContract[];
+    nativeInputs?: N8nNativeInputConfiguration;
+}
+export interface PreparedNativeRuntimeInputs {
+    revision: number;
+    inputValues: NativeRuntimeInputValues;
+    inputsReady: boolean;
+    slots: NativeRuntimeInputSlot[];
+    nativeParameters: NativeRuntimeParameterMaterialization[];
+    capabilities: N8nNativeCapability[];
+}
+export interface CreateRuntimeInputNativeCapabilitiesInput {
+    capabilities: N8nNativeCapability[];
+    slots: NativeRuntimeInputSlot[];
+    revision: number;
+    inputNodeName: string;
+}
+export interface AssembleNativeRuntimeInputsInput extends BuildN8nWorkflowInput {
+    nativeInputs: PreparedNativeRuntimeInputs;
+}
+export interface N8nNativeInputCompilationResult {
+    workflow: N8nWorkflowJSON;
+    nativeInputTemplate: N8nNativeInputTemplate;
+}

package/dist/types/native-runtime-parameters.js

@@ -0,0 +1 @@
+export {};

package/dist/types/output-binding-source.d.ts

@@ -2,6 +2,7 @@ import type { NativeOutputContract } from '@openapi-flow/core';
 import type { PlannedNativeNode } from '@openapi-flow/core';
 import type { N8nNativeCapability } from './native-capability.js';
 import type { ApiOperationContract } from '@openapi-flow/core';
+import type { N8nNativeInputConfiguration } from './native-runtime-parameters.js';
 export interface N8nNativeOutputSource extends NativeOutputContract {
     nodeName: string;
 }
@@ -19,4 +20,8 @@ export interface CreateN8nNativeOutputSourcesInput {
     nativeNodes: PlannedNativeNode[];
     capabilities: N8nNativeCapability[];
     apiNodeNames: Record<string, string>;
+    apiResponseContracts?: Record<string, ApiOperationContract>;
+    /** Actual SDK output sources outside this explicitly supplied native subset. */
+    externalNativeOutputSources?: N8nNativeOutputSource[];
+    nativeInputs?: N8nNativeInputConfiguration;
 }

package/dist/types/request-materialization.d.ts

@@ -1,11 +1,19 @@
 import type { ApiCallArguments, ApiOperationContract, JsonValue } from '@openapi-flow/core';
 import type { Operation } from '@openapi-flow/core/internal';
+import type { DeferredApiInputSlot } from '@openapi-flow/core';
 import type { PreparedRequestBody, RequestHeader } from './legacy/request-node.js';
 export interface RequestMaterializationConfig {
     contract: ApiOperationContract;
     operation: Operation;
-    arguments: ApiCallArguments;
+    arguments: RequestMaterializationArguments;
     templateUrl: string;
+    deferredInputs?: DeferredRequestRuntimeInputs;
+}
+export type RequestMaterializationArguments = Pick<ApiCallArguments, 'callId' | 'values' | 'bindings' | 'unresolvedInputs' | 'requestMediaType' | 'requestedInputs'>;
+export interface DeferredRequestRuntimeInputs {
+    revision: number;
+    inputNodeName: string;
+    slots: DeferredApiInputSlot[];
 }
 export interface MaterializedHttpRequest {
     url: string;

package/dist/types/request-node-configuration.d.ts

@@ -0,0 +1,13 @@
+import type { CreateBoundHttpRequestNodeInput, N8nNodeFragment } from './node-fragment.js';
+import type { RequestMaterializationConfig } from './request-materialization.js';
+import type { ResolvedHttpRequestDeployment } from './request-deployment.js';
+export interface ResolveHttpRequestNodeConfigurationResult {
+    input: CreateBoundHttpRequestNodeInput;
+    config: RequestMaterializationConfig;
+}
+export interface FinalizeHttpRequestFragmentInput {
+    fragment: N8nNodeFragment;
+    method: string;
+    documentId: string;
+    deployment: ResolvedHttpRequestDeployment;
+}

package/dist/types/request-node-configuration.js

@@ -0,0 +1 @@
+export {};

package/dist/types/response-check-compilation.d.ts

@@ -1,6 +1,6 @@
 import type { CompileNativeNodeInput, NativeCheck } from './native-capability.js';
 import type { N8nApiResponseSource } from './output-binding-source.js';
-export interface CreateResponseCheckReaderInput extends Pick<CompileNativeNodeInput, 'apiNodeNames' | 'apiResponseContracts'> {
+export interface CreateResponseCheckReaderInput extends Pick<CompileNativeNodeInput, 'apiNodeNames' | 'apiResponseContracts' | 'singletonApiResponseIds'> {
     nodeId: string;
     checks: NativeCheck[];
     linked: boolean;

package/dist/types/reviewable-workflow.d.ts

@@ -1,6 +1,7 @@
 import type { ReviewableWorkflowGraphPlan, ReviewableWorkflowApiMaterial, WorkflowReviewGap, ApiOperationContract } from '@openapi-flow/core';
 import type { N8nNativeCapability } from './native-capability.js';
 import type { N8nNodeFragment, N8nSdkNode } from './node-fragment.js';
+import type { N8nNativeInputConfiguration } from './native-runtime-parameters.js';
 export interface CompileReviewableN8nWorkflowInput {
     id: string;
     name: string;
@@ -8,6 +9,7 @@ export interface CompileReviewableN8nWorkflowInput {
     materials: ReviewableWorkflowApiMaterial[];
     apiNodes: N8nNodeFragment[];
     capabilities: N8nNativeCapability[];
+    nativeInputs?: N8nNativeInputConfiguration;
 }
 export interface CreateGapNodeInput {
     nodeId: string;

package/dist/types/workflow-compilation.d.ts

@@ -3,6 +3,7 @@ import type { N8nNodeFragment } from './node-fragment.js';
 import type { N8nSdkNode } from './node-fragment.js';
 import type { WorkflowReviewGap } from '@openapi-flow/core';
 import type { N8nBatchExecutionScope } from './batch-execution.js';
+import type { N8nNativeInputTemplate } from './native-runtime-parameters.js';
 export interface N8nGraphEdge {
     from: string;
     output: string;
@@ -19,6 +20,7 @@ export interface AssembleN8nWorkflowInput {
 export interface N8nCompileResult {
     status: 'complete';
     workflow: WorkflowJSON;
+    nativeInputTemplate?: N8nNativeInputTemplate;
 }
 export interface BuildN8nWorkflowInput extends AssembleN8nWorkflowInput {
     triggerConnections: 'connected' | 'detached';
@@ -32,5 +34,6 @@ export interface N8nNeedsReviewResult {
     status: 'needs-review';
     workflow: N8nWorkflowJSON;
     diagnostics: WorkflowReviewGap[];
+    nativeInputTemplate?: N8nNativeInputTemplate;
 }
 export type N8nWorkflowResult = N8nCompileResult | N8nNeedsReviewResult;

package/dist/types/workflow-template.d.ts

@@ -0,0 +1,121 @@
+import type { WorkflowDraft, WorkflowDraftContext, WorkflowDraftReadiness, DeferredApiInputSlot, DeferredApiInputValues, WorkflowApiMaterial, WorkflowGraphPlan, ApiOperationContract, NativeRuntimeInputSlot, WorkflowRuntimeInputSlot, NativeRuntimeParameterMaterialization, WorkflowDraftCapabilityGap } from '@openapi-flow/core';
+import type { N8nNativeCapability } from './native-capability.js';
+import type { N8nNodeFragment } from './node-fragment.js';
+import type { HttpRequestDeploymentOptions } from './request-deployment.js';
+import type { RequestMaterializationConfig } from './request-materialization.js';
+import type { N8nWorkflowJSON } from './workflow-compilation.js';
+export interface N8nTemplateDeployment extends HttpRequestDeploymentOptions {
+    documentId: string;
+}
+export interface SelectN8nTemplateDeploymentsInput {
+    deployments: N8nTemplateDeployment[];
+    availableDocumentIds: string[];
+    selectedDocumentIds: string[];
+}
+export interface N8nTemplateContext extends Omit<WorkflowDraftContext, 'capabilities'> {
+    capabilities: N8nNativeCapability[];
+}
+export interface CompileN8nWorkflowTemplateInput {
+    draft: WorkflowDraft;
+    context: N8nTemplateContext;
+    name: string;
+    /** Resolve each request's declared references by actual n8n item ancestry. */
+    itemMode?: 'linked';
+    deployments?: N8nTemplateDeployment[];
+    /** Only explicit actual values; omission means no supplied runtime values. */
+    inputValues?: DeferredApiInputValues;
+}
+export interface N8nTemplateNodeMappingBase {
+    nodeId: string;
+    sdkNodeIds: string[];
+    entryNodeName: string;
+    exitNodeName: string;
+}
+export interface N8nTemplateApiNodeMapping extends N8nTemplateNodeMappingBase {
+    kind: 'api';
+    operation: N8nTemplateOperationMapping;
+}
+export interface N8nTemplateOperationMapping extends Pick<ApiOperationContract, 'key' | 'method' | 'path'> {
+    summary?: string;
+}
+export interface N8nTemplateNativeNodeMapping extends N8nTemplateNodeMappingBase {
+    kind: 'native';
+    capability: string;
+}
+export type N8nTemplateNodeMapping = N8nTemplateApiNodeMapping | N8nTemplateNativeNodeMapping | N8nTemplateGapNodeMapping;
+export interface N8nTemplateGapNodeMapping extends N8nTemplateNodeMappingBase {
+    kind: 'capability-gap';
+    gap: WorkflowDraftCapabilityGap;
+    inventoryCurrent: boolean;
+}
+export interface N8nTemplateInputSlotMapping {
+    editNodeId: string;
+    editNodeName: string;
+    editParameter: 'jsCode';
+    materializerNodeName: string;
+}
+export type N8nTemplateInputSlot = WorkflowRuntimeInputSlot & N8nTemplateInputSlotMapping;
+export interface N8nTemplateDeploymentRequirement {
+    callId: string;
+    documentId: string;
+    fields: string[];
+    materializerNodeName: string;
+    requestNodeName: string;
+}
+export interface N8nWorkflowTemplateResult {
+    revision: number;
+    workflow: N8nWorkflowJSON;
+    /** Canonical draft state, separate from supplied execution-time values. */
+    draftReadiness: WorkflowDraftReadiness;
+    requestInputsReady: boolean;
+    nativeInputsReady: boolean;
+    runtimeInputsReady: boolean;
+    /** References supplied, not proof of access to the user's n8n credentials. */
+    deploymentConfigured: boolean;
+    triggerConnected: boolean;
+    inputSlots: N8nTemplateInputSlot[];
+    deploymentRequirements: N8nTemplateDeploymentRequirement[];
+    nodeMappings: N8nTemplateNodeMapping[];
+    guide: string;
+}
+export interface CreateTemplateInputNodesInput {
+    revision: number;
+    slots: WorkflowRuntimeInputSlot[];
+    inputValues: DeferredApiInputValues;
+    requests: RequestMaterializationConfig[];
+    nativeParameters: NativeRuntimeParameterMaterialization[];
+}
+export interface CreateTemplateGuideInput {
+    draft: WorkflowDraft;
+    readiness: WorkflowDraftReadiness;
+    slots: N8nTemplateInputSlot[];
+    mappings: N8nTemplateNodeMapping[];
+    deploymentRequirements: N8nTemplateDeploymentRequirement[];
+    requestInputsReady: boolean;
+    nativeInputsReady: boolean;
+    triggerConnected: boolean;
+}
+export interface PrepareTemplateApiFragmentsInput {
+    template: CompileN8nWorkflowTemplateInput;
+    /** Runtime-bound compilers, separate from original planning/evidence context. */
+    capabilities: N8nNativeCapability[];
+    materials: WorkflowApiMaterial[];
+    slots: DeferredApiInputSlot[];
+    plan: WorkflowGraphPlan;
+}
+export interface PreparedTemplateApiFragments {
+    apiNodes: N8nNodeFragment[];
+    requests: RequestMaterializationConfig[];
+    deploymentRequirements: N8nTemplateDeploymentRequirement[];
+}
+export interface CreateTemplateArtifactMappingInput {
+    context: WorkflowDraftContext;
+    draft: WorkflowDraft;
+    materials: WorkflowApiMaterial[];
+    fragments: N8nNodeFragment[];
+    slots: (DeferredApiInputSlot | NativeRuntimeInputSlot)[];
+}
+export interface TemplateArtifactMapping {
+    mappings: N8nTemplateNodeMapping[];
+    inputSlots: N8nTemplateInputSlot[];
+}

package/dist/types/workflow-template.js

@@ -0,0 +1 @@
+export {};

package/dist/workflow/batch/compile-batched-n8n-workflow.js

@@ -1,18 +1,36 @@
 import { batchExecutionScopesSchema } from '../../schemas/batch-execution-schema.js';
 import { compileValidatedWorkflowFragments } from '../compile-validated-workflow-fragments.js';
 import { buildN8nWorkflow } from '../build-n8n-workflow.js';
+import { prepareNativeRuntimeInputs, assembleNativeRuntimeInputs, } from '../inputs/compile-native-runtime-inputs.js';
 export function compileBatchedN8nWorkflow(input) {
     const batchScopes = batchExecutionScopesSchema.parse(input.batchScopes);
-    const workflow = buildN8nWorkflow({
+    const nativeInputs = prepareNativeRuntimeInputs({
+        nativeInputs: input.nativeInputs,
+        nativeNodes: input.plan.nativeNodes,
+        capabilities: input.capabilities,
+        apiMaterials: input.materials.map((item) => ({
+            callId: item.arguments.callId,
+            operation: item.operation,
+            requestMediaType: item.arguments.requestMediaType,
+        })),
+        nativeOutputs: [],
+    });
+    const graph = {
         id: input.id,
         name: input.name,
-        nodes: compileValidatedWorkflowFragments(input),
+        nodes: compileValidatedWorkflowFragments(nativeInputs === undefined
+            ? input
+            : { ...input, capabilities: nativeInputs.capabilities }),
         edges: input.plan.edges,
         starts: input.plan.starts,
         triggerConnections: 'connected',
         annotations: [],
         batchScopes,
-    });
+    };
+    const result = nativeInputs === undefined
+        ? { workflow: buildN8nWorkflow(graph) }
+        : assembleNativeRuntimeInputs({ ...graph, nativeInputs });
+    const workflow = result.workflow;
     workflow.settings = { ...workflow.settings, executionOrder: 'v1' };
-    return { status: 'complete', workflow };
+    return { status: 'complete', ...result };
 }

package/dist/workflow/build-n8n-workflow.js

@@ -1,4 +1,5 @@
-import { trigger, workflow, validateWorkflow } from '@n8n/workflow-sdk';
+import { workflow, validateWorkflow } from '@n8n/workflow-sdk';
+import { createN8nManualTrigger } from './entrypoint/manual-trigger.js';
 import { validateNodeFragments } from './validate-node-fragments.js';
 import { createBatchExecutionScopes } from './batch/create-batch-execution-scopes.js';
 export function buildN8nWorkflow({ id, name, nodes, edges, starts, triggerConnections, annotations, batchScopes, }) {
@@ -92,11 +93,7 @@ export function buildN8nWorkflow({ id, name, nodes, edges, starts, triggerConnec
     }
     if (visited !== nodes.length)
         throw new Error('workflow DAG has a cycle');
-    const start = trigger({
-        type: 'n8n-nodes-base.manualTrigger',
-        version: 1,
-        config: { id: 'openapi-flow-start', name: 'Start', position: [0, 0] },
-    });
+    const start = createN8nManualTrigger();
     let built = workflow(id, name).add(start);
     for (const fragment of nodes)
         for (const node of fragment.nodes)

package/dist/workflow/compile-native-material-fragments.d.ts

@@ -0,0 +1,3 @@
+import type { CompileNativeMaterialFragmentsInput, CompiledNativeMaterialFragments } from '../types/native-material-binding.js';
+/** Compile dependency names from actual SDK exits; graph execution order is still owned by explicit edges. */
+export declare function compileNativeMaterialFragments(input: CompileNativeMaterialFragmentsInput): CompiledNativeMaterialFragments;

package/dist/workflow/compile-native-material-fragments.js

@@ -0,0 +1,76 @@
+/** Compile dependency names from actual SDK exits; graph execution order is still owned by explicit edges. */
+export function compileNativeMaterialFragments(input) {
+    const registry = new Map(input.materials.capabilities.map((capability) => [
+        capability.name,
+        capability,
+    ]));
+    const selected = new Set(input.nodeIds);
+    if (selected.size !== input.nodeIds.length ||
+        input.nodeIds.some((id) => !input.nativeNodes.some((node) => node.id === id)))
+        throw new Error('Native compilation requires distinct actual selected nodeIds');
+    const pending = input.nativeNodes.filter((node) => selected.has(node.id));
+    const sources = [...input.externalNativeOutputSources];
+    const fragments = new Map();
+    const apiResponseContracts = Object.fromEntries(input.apiMaterials.map((material) => [material.callId, material.operation]));
+    let progressed = true;
+    while (pending.length && progressed) {
+        progressed = false;
+        for (let index = 0; index < pending.length;) {
+            const node = pending[index];
+            const capability = registry.get(node.capability);
+            if (!capability)
+                throw new Error(`Missing current native compiler ${node.capability}`);
+            const references = [
+                ...(capability.nodeOutputReferences
+                    ? capability.nodeOutputReferences(node.parameters)
+                    : []),
+                ...Object.values(capability.inputReferences
+                    ? capability.inputReferences(node.parameters)
+                    : {})
+                    .flat()
+                    .filter((reference) => reference.source === 'node-output'),
+            ];
+            if (references.some((reference) => !sources.some((source) => source.nodeId === reference.nodeId))) {
+                index++;
+                continue;
+            }
+            const compiled = capability.compile({
+                planned: node,
+                apiNodeNames: input.apiNodeNames,
+                apiResponseContracts,
+                singletonApiResponseIds: input.singletonApiResponseIds,
+                nativeOutputSources: sources,
+                position: [
+                    600 +
+                        input.nativeNodes.findIndex((planned) => planned.id === node.id) *
+                            250,
+                    300,
+                ],
+            });
+            if (compiled.nodeId !== node.id ||
+                !compiled.exit.name.trim() ||
+                JSON.stringify(Object.keys(compiled.inputPorts)) !==
+                    JSON.stringify(capability.inputPorts(node.parameters)) ||
+                JSON.stringify(Object.keys(compiled.outputPorts)) !==
+                    JSON.stringify(capability.outputPorts(node.parameters)))
+                throw new Error(`Native compiler ${node.capability} violated declared node identity/ports`);
+            if (compiled.rejoinsExclusiveOutputs !==
+                capability.rejoinsExclusiveOutputs?.(node.parameters))
+                throw new Error(`Native compiler ${node.capability} violated declared rejoinsExclusiveOutputs`);
+            fragments.set(node.id, compiled);
+            const output = input.materials.outputs.find((output) => output.nodeId === node.id);
+            if (output)
+                sources.push({ ...output, nodeName: compiled.exit.name });
+            pending.splice(index, 1);
+            progressed = true;
+        }
+    }
+    if (pending.length)
+        throw new Error(`Native compilation is missing actual producer exits for ${pending.map((node) => node.id).join(', ')}`);
+    return {
+        fragments: input.nativeNodes
+            .filter((node) => selected.has(node.id))
+            .map((node) => fragments.get(node.id)),
+        outputSources: sources.filter((source) => selected.has(source.nodeId)),
+    };
+}

package/dist/workflow/compile-native-workflow-nodes.js

@@ -1,26 +1,25 @@
+import { resolveN8nNativeMaterials } from './resolve-n8n-native-materials.js';
+import { compileNativeMaterialFragments } from './compile-native-material-fragments.js';
+import { findSingletonApiResponses } from './find-singleton-api-responses.js';
 export function compileNativeWorkflowNodes(input) {
-    const names = Object.fromEntries(input.apiNodes.map((item) => [item.nodeId, item.exit.name]));
-    const apiResponseContracts = Object.fromEntries(input.materials.map((item) => [item.arguments.callId, item.operation]));
-    const nativeNodes = input.plan.nativeNodes.map((planned, index) => {
-        const capability = input.capabilities.find((item) => item.name === planned.capability);
-        if (!capability)
-            throw new Error(`Missing native compiler ${planned.capability}`);
-        const compiled = capability.compile({
-            planned,
-            apiNodeNames: names,
-            apiResponseContracts,
-            position: [600 + index * 250, 300],
-        });
-        if (compiled.nodeId !== planned.id ||
-            JSON.stringify(Object.keys(compiled.inputPorts)) !==
-                JSON.stringify(capability.inputPorts(planned.parameters)) ||
-            JSON.stringify(Object.keys(compiled.outputPorts)) !==
-                JSON.stringify(capability.outputPorts(planned.parameters)))
-            throw new Error(`Native compiler ${planned.capability} violated declared node identity/ports`);
-        if (compiled.rejoinsExclusiveOutputs !==
-            capability.rejoinsExclusiveOutputs?.(planned.parameters))
-            throw new Error(`Native compiler ${planned.capability} violated declared rejoinsExclusiveOutputs`);
-        return compiled;
+    const apiMaterials = input.materials.map((item) => ({
+        callId: item.arguments.callId,
+        operation: item.operation,
+        requestMediaType: item.arguments.requestMediaType,
+    }));
+    const materials = resolveN8nNativeMaterials({
+        apiMaterials,
+        nativeOutputs: [],
+        nativeNodes: input.plan.nativeNodes,
+        capabilities: input.capabilities,
     });
-    return nativeNodes;
+    return compileNativeMaterialFragments({
+        nativeNodes: input.plan.nativeNodes,
+        materials,
+        apiMaterials,
+        apiNodeNames: Object.fromEntries(input.apiNodes.map((item) => [item.nodeId, item.exit.name])),
+        singletonApiResponseIds: findSingletonApiResponses(input),
+        externalNativeOutputSources: [],
+        nodeIds: input.plan.nativeNodes.map((node) => node.id),
+    }).fragments;
 }

package/dist/workflow/compile-planned-n8n-workflow.js

@@ -1,14 +1,39 @@
 import { assembleN8nWorkflow } from './assemble-n8n-workflow.js';
 import { compileValidatedWorkflowFragments } from './compile-validated-workflow-fragments.js';
+import { prepareNativeRuntimeInputs, assembleNativeRuntimeInputs, } from './inputs/compile-native-runtime-inputs.js';
 export function compilePlannedN8nWorkflow(input) {
-    const nodes = compileValidatedWorkflowFragments(input);
-    const result = assembleN8nWorkflow({
+    const nativeInputs = prepareNativeRuntimeInputs({
+        nativeInputs: input.nativeInputs,
+        nativeNodes: input.plan.nativeNodes,
+        capabilities: input.capabilities,
+        apiMaterials: input.materials.map((item) => ({
+            callId: item.arguments.callId,
+            operation: item.operation,
+            requestMediaType: item.arguments.requestMediaType,
+        })),
+        nativeOutputs: [],
+    });
+    const nodes = compileValidatedWorkflowFragments(nativeInputs === undefined
+        ? input
+        : { ...input, capabilities: nativeInputs.capabilities });
+    const graph = {
         id: input.id,
         name: input.name,
         nodes,
         edges: input.plan.edges,
         starts: input.plan.starts,
-    });
+    };
+    const result = nativeInputs === undefined
+        ? assembleN8nWorkflow(graph)
+        : {
+            status: 'complete',
+            ...assembleNativeRuntimeInputs({
+                ...graph,
+                nativeInputs,
+                triggerConnections: 'connected',
+                annotations: [],
+            }),
+        };
     result.workflow.settings = {
         ...result.workflow.settings,
         executionOrder: 'v1',