@openapi-flow/core 0.2.0 → 0.3.0

package/dist/draft/resolve-workflow-draft-materials.js

@@ -0,0 +1,29 @@
+import { resolveWorkflowDraftApiMaterials } from './resolve-workflow-draft-api-materials.js';
+import { collectDeferredApiInputSlots } from '../inputs/collect-deferred-api-input-slots.js';
+import { collectNativeRuntimeInputSlots } from '../inputs/native/collect-native-runtime-input-slots.js';
+import { resolveWorkflowDraftNativeSnapshot } from './resolve-workflow-draft-native-snapshot.js';
+import { NativeMaterialResolutionError } from '../workflow/native-material-resolution-error.js';
+export function resolveWorkflowDraftMaterials(input) {
+    if (!input.context || !Array.isArray(input.context.operations))
+        throw new Error('draft context.operations must be an array');
+    const materials = resolveWorkflowDraftApiMaterials({
+        content: input.draft,
+        context: input.context,
+    });
+    const snapshot = resolveWorkflowDraftNativeSnapshot({
+        content: input.draft,
+        context: input.context,
+        deferredNodeIds: [],
+        unavailableApiNodeIds: [],
+    });
+    if (snapshot.status !== 'ready')
+        throw new NativeMaterialResolutionError(snapshot.pending);
+    return {
+        materials,
+        slots: collectDeferredApiInputSlots({ materials }),
+        nativeSlots: collectNativeRuntimeInputSlots({
+            nativeNodes: input.draft.nativeNodes,
+            capabilities: snapshot.capabilities,
+        }),
+    };
+}

package/dist/draft/resolve-workflow-draft-native-snapshot.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveWorkflowDraftNativeSnapshotInput } from '../types/workflow-draft-native-materials.js';
+import type { NativeMaterialSnapshot } from '../types/native-material-snapshot.js';
+export declare function resolveWorkflowDraftNativeSnapshot(input: ResolveWorkflowDraftNativeSnapshotInput): NativeMaterialSnapshot;

package/dist/draft/resolve-workflow-draft-native-snapshot.js

@@ -0,0 +1,18 @@
+import { resolveWorkflowDraftApiMaterials } from './resolve-workflow-draft-api-materials.js';
+import { resolveNativeMaterialSnapshot } from '../workflow/resolve-native-material-snapshot.js';
+export function resolveWorkflowDraftNativeSnapshot(input) {
+    const materials = resolveWorkflowDraftApiMaterials({
+        content: input.content,
+        context: input.context,
+    });
+    return resolveNativeMaterialSnapshot({
+        apiMaterials: materials.filter((material) => !input.unavailableApiNodeIds.includes(material.callId)),
+        nativeOutputs: [],
+        nativeNodes: input.content.nativeNodes,
+        capabilities: input.context.capabilities,
+        deferredNodeIds: input.deferredNodeIds,
+        ...(input.shouldDeferNode === undefined
+            ? {}
+            : { shouldDeferNode: input.shouldDeferNode }),
+    });
+}

package/dist/draft/validate-workflow-draft.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftInput } from '../types/workflow-draft.js';
+/** A canonical draft retains valid structure even while values/decisions await input. */
+export declare function validateWorkflowDraft(input: WorkflowDraftInput): void;

package/dist/draft/validate-workflow-draft.js

@@ -0,0 +1,96 @@
+import { workflowDraftSchema } from '../schemas/workflow-draft-schema.js';
+import { resolveWorkflowDraftMaterials } from './resolve-workflow-draft-materials.js';
+import { validateWorkflowGraphPlan } from '../workflow/validate-workflow-graph-plan.js';
+import { validateWorkflowDraftRequirementHistory } from './requirements/history/validate-workflow-draft-requirement-history.js';
+import { workflowPlanningMessageIdsSchema } from '../schemas/workflow-planning-message-ids-schema.js';
+import { inspectWorkflowDraftCapabilityGap } from './gaps/inspect-workflow-draft-capability-gap.js';
+/** A canonical draft retains valid structure even while values/decisions await input. */
+export function validateWorkflowDraft(input) {
+    const draft = workflowDraftSchema.parse(input.draft);
+    if (!input.context ||
+        !Array.isArray(input.context.operations) ||
+        !Array.isArray(input.context.messages) ||
+        !Array.isArray(input.context.capabilities))
+        throw new Error('draft context.operations, context.messages and context.capabilities must be arrays');
+    const { materials, slots } = resolveWorkflowDraftMaterials({
+        ...input,
+        draft,
+    });
+    const capabilityNames = input.context.capabilities.map((capability) => capability.name);
+    if (new Set(capabilityNames).size !== capabilityNames.length ||
+        capabilityNames.some((name) => typeof name !== 'string' || !name.trim()))
+        throw new Error('draft context.capabilities requires distinct non-empty names');
+    const ids = [
+        ...draft.apiCalls.map((call) => call.id),
+        ...draft.nativeNodes.map((node) => node.id),
+        ...(draft.gapNodes === undefined
+            ? []
+            : draft.gapNodes.map((node) => node.id)),
+    ];
+    const known = new Set(ids);
+    for (const gap of draft.gapNodes === undefined ? [] : draft.gapNodes)
+        inspectWorkflowDraftCapabilityGap({ gap, context: input.context });
+    if (known.size !== ids.length)
+        throw new Error('Draft node IDs must be unique across API and native instances, including unresolved gaps');
+    const messageIds = new Set(input.context.messages.map((message) => message.id));
+    if (messageIds.size !== input.context.messages.length ||
+        input.context.messages.some((message) => !message.id?.trim() || typeof message.text !== 'string'))
+        throw new Error('draft context.messages requires distinct non-empty IDs and text');
+    if (new Set(draft.requirements.map((item) => item.id)).size !==
+        draft.requirements.length)
+        throw new Error('Draft requirements require distinct IDs');
+    if (input.context.planningMessageIds !== undefined &&
+        workflowPlanningMessageIdsSchema
+            .parse(input.context.planningMessageIds)
+            .some((id) => !messageIds.has(id)))
+        throw new Error('draft context.planningMessageIds references an unknown message');
+    for (const requirement of draft.requirements) {
+        if (requirement.sourceMessageIds.some((id) => !messageIds.has(id)))
+            throw new Error(`Requirement ${requirement.id} references an unknown source message`);
+        if (requirement.scope.kind === 'nodes' &&
+            requirement.scope.nodeIds.some((id) => !known.has(id)))
+            throw new Error(`Requirement ${requirement.id} references an unknown node`);
+    }
+    validateWorkflowDraftRequirementHistory({ draft, context: input.context });
+    if (new Set(draft.approvals.map((item) => item.id)).size !==
+        draft.approvals.length)
+        throw new Error('Draft approval IDs must be distinct');
+    for (const approval of draft.approvals) {
+        if (approval.revision > draft.revision ||
+            approval.invalidatedNodeIds.some((id) => !approval.nodeIds.includes(id)) ||
+            approval.nodeIds.some((id) => !known.has(id) && !approval.invalidatedNodeIds.includes(id)))
+            throw new Error(`Draft approval ${approval.id} has invalid revision or scope`);
+    }
+    if (!ids.length) {
+        if (draft.edges.length)
+            throw new Error('An empty draft cannot contain edges');
+        return;
+    }
+    validateWorkflowGraphPlan({
+        unresolvedNodes: draft.gapNodes,
+        capabilities: input.context.capabilities,
+        materials: materials.map((material) => ({
+            operation: material.operation,
+            arguments: {
+                callId: material.callId,
+                values: material.values,
+                bindings: material.bindings,
+                ...(material.requestedInputs === undefined
+                    ? {}
+                    : { requestedInputs: material.requestedInputs }),
+                unresolvedInputs: slots
+                    .filter((slot) => slot.callId === material.callId)
+                    .map((slot) => slot.targetPointer),
+                ...(material.requestMediaType !== undefined
+                    ? { requestMediaType: material.requestMediaType }
+                    : {}),
+            },
+        })),
+        plan: {
+            nativeNodes: draft.nativeNodes,
+            edges: draft.edges,
+            starts: ids.filter((id) => !draft.edges.some((edge) => edge.to === id)),
+            gaps: [],
+        },
+    });
+}

package/dist/inputs/collect-deferred-api-input-slots.d.ts

@@ -0,0 +1,3 @@
+import type { CollectDeferredApiInputSlotsInput, DeferredApiInputSlot } from '../types/deferred-api-inputs.js';
+/** Derive slots from the original OAS and current literal/binding ownership. */
+export declare function collectDeferredApiInputSlots(input: CollectDeferredApiInputSlotsInput): DeferredApiInputSlot[];

package/dist/inputs/collect-deferred-api-input-slots.js

@@ -0,0 +1,35 @@
+import { inspectApiArgumentRequirements } from '../arguments/clarification/inspect-api-argument-requirements.js';
+import { apiOperationKeySchema } from '../schemas/api-operation-key-schema.js';
+/** Derive slots from the original OAS and current literal/binding ownership. */
+export function collectDeferredApiInputSlots(input) {
+    if (!Array.isArray(input.materials))
+        throw new Error('collectDeferredApiInputSlots.materials must be an array');
+    const ids = new Set();
+    return input.materials.flatMap((material) => {
+        if (typeof material.callId !== 'string' ||
+            !material.callId.trim() ||
+            ids.has(material.callId))
+            throw new Error('Input materials require distinct non-empty callIds');
+        ids.add(material.callId);
+        apiOperationKeySchema.parse(material.operation.key);
+        return inspectApiArgumentRequirements(material).requirements.map((requirement) => ({
+            kind: 'api-request-input',
+            state: 'deferred',
+            id: `input:${requirement.id}`,
+            callId: requirement.callId,
+            operation: requirement.operation,
+            targetPointer: requirement.targetPointer,
+            ...(requirement.requestedInputs === undefined
+                ? {}
+                : { requestedInputs: requirement.requestedInputs }),
+            schema: requirement.schema,
+            openapiVersion: requirement.openapiVersion,
+            ...(requirement.operationSummary !== undefined
+                ? { operationSummary: requirement.operationSummary }
+                : {}),
+            ...(requirement.parameterDescription !== undefined
+                ? { parameterDescription: requirement.parameterDescription }
+                : {}),
+        }));
+    });
+}

package/dist/inputs/deferred-api-input-error.d.ts

@@ -0,0 +1,5 @@
+import type { DeferredApiInputIssue } from '../types/deferred-api-inputs.js';
+export declare class DeferredApiInputError extends Error {
+    readonly issues: DeferredApiInputIssue[];
+    constructor(issues: DeferredApiInputIssue[]);
+}

package/dist/inputs/deferred-api-input-error.js

@@ -0,0 +1,8 @@
+export class DeferredApiInputError extends Error {
+    issues;
+    constructor(issues) {
+        super(issues.map((issue) => issue.message).join('; '));
+        this.name = 'DeferredApiInputError';
+        this.issues = structuredClone(issues);
+    }
+}

package/dist/inputs/inspect-deferred-api-inputs.d.ts

@@ -0,0 +1,3 @@
+import type { DeferredApiInputInspection, InspectDeferredApiInputsInput } from '../types/deferred-api-inputs.js';
+/** Missing values are explicit state; malformed supplied values are never repaired. */
+export declare function inspectDeferredApiInputs(input: InspectDeferredApiInputsInput): DeferredApiInputInspection;

package/dist/inputs/inspect-deferred-api-inputs.js

@@ -0,0 +1,98 @@
+import { deferredApiInputValuesSchema } from '../schemas/deferred-api-input-schema.js';
+import { collectDeferredApiInputSlots } from './collect-deferred-api-input-slots.js';
+import { createOasValueValidator } from '../openapi/common/create-oas-value-validator.js';
+import { assignApiInputValue } from '../arguments/clarification/assign-api-input-value.js';
+import { validateApiArguments } from '../arguments/validate-api-arguments.js';
+import { listMissingRequestedApiInputs } from '../arguments/clarification/list-missing-requested-api-inputs.js';
+/** Missing values are explicit state; malformed supplied values are never repaired. */
+export function inspectDeferredApiInputs(input) {
+    const slots = collectDeferredApiInputSlots(input);
+    const parsed = deferredApiInputValuesSchema.safeParse(input.inputValues);
+    if (!parsed.success)
+        return {
+            status: 'invalid-input',
+            slots,
+            issues: parsed.error.issues.map((issue) => ({
+                code: 'invalid-value',
+                inputId: String(issue.path[0] ?? ''),
+                message: `inputValues must contain JSON values: ${issue.message}`,
+            })),
+        };
+    const values = parsed.data;
+    const known = new Set(slots.map((slot) => slot.id));
+    const issues = Object.keys(values)
+        .filter((id) => !known.has(id))
+        .map((inputId) => ({
+        code: 'unknown-input',
+        inputId,
+        message: `inputValues contains undeclared or stale input slot ${inputId}`,
+    }));
+    for (const slot of slots) {
+        if (!Object.hasOwn(values, slot.id)) {
+            issues.push({
+                code: 'missing-input',
+                inputId: slot.id,
+                callId: slot.callId,
+                targetPointer: slot.targetPointer,
+                message: `Missing runtime input ${slot.id} for ${slot.callId}${slot.targetPointer}`,
+            });
+            continue;
+        }
+        const checked = createOasValueValidator(slot.schema, slot.openapiVersion.startsWith('3.0.') ? 'openapi-3.0' : 'draft-2020-12', `inputValues[${slot.id}] for ${slot.callId}${slot.targetPointer}`).validate(values[slot.id]);
+        if (!checked.valid)
+            issues.push({
+                code: 'invalid-value',
+                inputId: slot.id,
+                callId: slot.callId,
+                targetPointer: slot.targetPointer,
+                message: `Runtime input ${slot.id} for ${slot.callId}${slot.targetPointer} violates its OAS schema: ${checked.errors.map((issue) => issue.message).join('; ')}`,
+            });
+        else {
+            const missing = listMissingRequestedApiInputs({
+                source: `Runtime input ${slot.id}`,
+                rootPointer: slot.targetPointer,
+                value: values[slot.id],
+                requestedInputs: slot.requestedInputs,
+            });
+            if (missing.length)
+                issues.push({
+                    code: 'invalid-value',
+                    inputId: slot.id,
+                    callId: slot.callId,
+                    targetPointer: slot.targetPointer,
+                    message: `Runtime input omits scenario-requested inputs: ${missing.join(', ')}`,
+                });
+        }
+    }
+    if (issues.length)
+        return {
+            status: issues.every((issue) => issue.code === 'missing-input')
+                ? 'needs-input'
+                : 'invalid-input',
+            slots,
+            issues,
+        };
+    const args = input.materials.map((material) => {
+        const resolved = structuredClone(material.values);
+        for (const slot of slots.filter((slot) => slot.callId === material.callId))
+            assignApiInputValue(resolved, slot.targetPointer, values[slot.id], material);
+        // Preserve the complete original OAS check after slot assignment. A union
+        // projection for one field never substitutes for the final request contract.
+        const checked = validateApiArguments({ ...material, values: resolved });
+        if (!checked.valid)
+            throw new Error(`Resolved request ${material.callId} still requires ${checked.missingInputs.join(', ')}`);
+        return {
+            callId: material.callId,
+            values: resolved,
+            bindings: structuredClone(material.bindings),
+            unresolvedInputs: [],
+            ...(material.requestMediaType !== undefined
+                ? { requestMediaType: material.requestMediaType }
+                : {}),
+            ...(material.requestedInputs === undefined
+                ? {}
+                : { requestedInputs: structuredClone(material.requestedInputs) }),
+        };
+    });
+    return { status: 'ready', slots, arguments: args, issues: [] };
+}

package/dist/inputs/materialize-deferred-api-inputs.d.ts

@@ -0,0 +1,4 @@
+import type { ApiCallArguments } from '../types/api-arguments.js';
+import type { InspectDeferredApiInputsInput } from '../types/deferred-api-inputs.js';
+/** Execution boundary: no missing slot can become an outbound request value. */
+export declare function materializeDeferredApiInputs(input: InspectDeferredApiInputsInput): ApiCallArguments[];

package/dist/inputs/materialize-deferred-api-inputs.js

@@ -0,0 +1,9 @@
+import { inspectDeferredApiInputs } from './inspect-deferred-api-inputs.js';
+import { DeferredApiInputError } from './deferred-api-input-error.js';
+/** Execution boundary: no missing slot can become an outbound request value. */
+export function materializeDeferredApiInputs(input) {
+    const checked = inspectDeferredApiInputs(input);
+    if (checked.status !== 'ready')
+        throw new DeferredApiInputError(checked.issues);
+    return checked.arguments;
+}

package/dist/inputs/native/collect-native-runtime-input-slots.d.ts

@@ -0,0 +1,3 @@
+import type { CollectNativeRuntimeInputSlotsInput, NativeRuntimeInputSlot } from '../../types/native-runtime-inputs.js';
+/** Slot identities are owned by code and scoped to the original node and schema. */
+export declare function collectNativeRuntimeInputSlots(input: CollectNativeRuntimeInputSlotsInput): NativeRuntimeInputSlot[];

package/dist/inputs/native/collect-native-runtime-input-slots.js

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto';
+import { resolveNativeStructureParameters } from '../../workflow/resolve-native-structure-parameters.js';
+import { createNativeRuntimeParametersSchema } from '../../schemas/create-native-runtime-parameters-schema.js';
+import { schemasAtPointer } from '../../bindings/schema-at-pointer.js';
+import { createSchemaResourceContext } from '../../bindings/resources/create-schema-resource-context.js';
+/** Slot identities are owned by code and scoped to the original node and schema. */
+export function collectNativeRuntimeInputSlots(input) {
+    if (!Array.isArray(input.nativeNodes) || !Array.isArray(input.capabilities))
+        throw new Error('native runtime input nativeNodes and capabilities must be arrays');
+    const registry = new Map(input.capabilities.map((capability) => [capability.name, capability]));
+    if (registry.size !== input.capabilities.length)
+        throw new Error('native runtime input capabilities requires distinct names');
+    const ids = new Set();
+    return input.nativeNodes.flatMap((planned) => {
+        if (!planned ||
+            typeof planned.id !== 'string' ||
+            !planned.id.trim() ||
+            ids.has(planned.id))
+            throw new Error('native runtime inputs require distinct non-empty node IDs');
+        ids.add(planned.id);
+        const capability = registry.get(planned.capability);
+        if (!capability)
+            throw new Error(`node ${planned.id}: unknown capability ${planned.capability}`);
+        resolveNativeStructureParameters(planned, capability);
+        if (planned.runtimeParameters === undefined)
+            return [];
+        const originalSchema = createNativeRuntimeParametersSchema(capability);
+        const resources = createSchemaResourceContext(originalSchema);
+        const pointers = planned.runtimeParameters === true
+            ? ['']
+            : planned.runtimeParameters.pointers;
+        return pointers.map((targetPointer) => {
+            const projection = targetPointer === ''
+                ? originalSchema
+                : schemasAtPointer(resources.root, targetPointer, resources)[0];
+            if (projection === undefined)
+                throw new Error(`node ${planned.id}: runtime parameter ${targetPointer} is not permitted by its original schema`);
+            const schema = targetPointer === '' ? originalSchema : resources.bundle(projection);
+            const hash = createHash('sha256')
+                .update(JSON.stringify({
+                nodeId: planned.id,
+                capability: capability.name,
+                schema,
+                ...(targetPointer === ''
+                    ? {}
+                    : {
+                        targetPointer,
+                        parameters: planned.parameters,
+                        pointers: [...pointers].sort(),
+                    }),
+            }))
+                .digest('hex');
+            return {
+                kind: 'native-parameters-input',
+                state: 'deferred',
+                id: `native-input:${hash}`,
+                nodeId: planned.id,
+                capability: capability.name,
+                targetPointer,
+                schema,
+                description: capability.description,
+            };
+        });
+    });
+}

package/dist/inputs/native/create-native-runtime-parameter-materialization.d.ts

@@ -0,0 +1,3 @@
+import type { CollectNativeRuntimeInputSlotsInput, NativeRuntimeParameterMaterialization } from '../../types/native-runtime-inputs.js';
+/** Derive immutable execution material from explicit owners and the actual registered schema. */
+export declare function createNativeRuntimeParameterMaterializations(input: CollectNativeRuntimeInputSlotsInput): NativeRuntimeParameterMaterialization[];

package/dist/inputs/native/create-native-runtime-parameter-materialization.js

@@ -0,0 +1,47 @@
+import { collectNativeRuntimeInputSlots } from './collect-native-runtime-input-slots.js';
+import { createNativeRuntimeParametersSchema } from '../../schemas/create-native-runtime-parameters-schema.js';
+import { createSchemaResourceContext } from '../../bindings/resources/create-schema-resource-context.js';
+import { schemasAtPointer } from '../../bindings/schema-at-pointer.js';
+import { schemaAllowsContainer } from '../../bindings/schema-allows-container.js';
+import { pointerTokens, hasPointer } from '../../bindings/json-pointer.js';
+/** Derive immutable execution material from explicit owners and the actual registered schema. */
+export function createNativeRuntimeParameterMaterializations(input) {
+    const slots = collectNativeRuntimeInputSlots(input);
+    return input.nativeNodes
+        .filter((node) => node.runtimeParameters !== undefined)
+        .map((node) => {
+        const capability = input.capabilities.find((entry) => entry.name === node.capability);
+        const schema = createNativeRuntimeParametersSchema(capability);
+        const resources = createSchemaResourceContext(schema);
+        return {
+            nodeId: node.id,
+            parameters: structuredClone(node.parameters),
+            schema,
+            inputs: slots
+                .filter((slot) => slot.nodeId === node.id)
+                .map((slot) => {
+                const containerKinds = Object.create(null);
+                const tokens = pointerTokens(slot.targetPointer);
+                for (let length = 1; length < tokens.length; length++) {
+                    const pointer = '/' +
+                        tokens
+                            .slice(0, length)
+                            .map((part) => part.replaceAll('~', '~0').replaceAll('/', '~1'))
+                            .join('/');
+                    if (hasPointer(node.parameters, pointer))
+                        continue;
+                    const projections = schemasAtPointer(resources.root, pointer, resources);
+                    const kinds = ['object', 'array'].filter((kind) => projections.some((projection) => schemaAllowsContainer(projection, kind)));
+                    if (kinds.length !== 1)
+                        throw new Error(`node ${node.id}: runtime parameter ${pointer} needs an explicit literal container; schema does not determine object versus array`);
+                    containerKinds[pointer] = kinds[0];
+                }
+                return {
+                    id: slot.id,
+                    targetPointer: slot.targetPointer,
+                    containerKinds,
+                };
+            }),
+        };
+    });
+}

package/dist/inputs/native/inspect-native-runtime-inputs.d.ts

@@ -0,0 +1,2 @@
+import type { InspectNativeRuntimeInputsInput, NativeRuntimeInputInspection } from '../../types/native-runtime-inputs.js';
+export declare function inspectNativeRuntimeInputs(input: InspectNativeRuntimeInputsInput): NativeRuntimeInputInspection;

package/dist/inputs/native/inspect-native-runtime-inputs.js

@@ -0,0 +1,116 @@
+import { deferredApiInputValuesSchema } from '../../schemas/deferred-api-input-schema.js';
+import { collectNativeRuntimeInputSlots } from './collect-native-runtime-input-slots.js';
+import { parseNativeNodeParameters } from '../../workflow/parse-native-node-parameters.js';
+import { createOasValueValidator } from '../../openapi/common/create-oas-value-validator.js';
+import { nativeParameterValuesSchema } from '../../schemas/native-runtime-input-slot-schema.js';
+import { createNativeRuntimeParameterMaterializations } from './create-native-runtime-parameter-materialization.js';
+import { materializeNativeRuntimeParameters } from './materialize-native-runtime-parameters.js';
+export function inspectNativeRuntimeInputs(input) {
+    const slots = collectNativeRuntimeInputSlots(input);
+    const parsed = deferredApiInputValuesSchema.safeParse(input.inputValues);
+    if (!parsed.success)
+        return {
+            status: 'invalid-input',
+            slots,
+            issues: [
+                {
+                    code: 'invalid-value',
+                    inputId: '',
+                    message: 'native inputValues must be a JSON value map',
+                },
+            ],
+        };
+    const values = parsed.data;
+    const known = new Set(slots.map((slot) => slot.id));
+    const issues = Object.keys(values)
+        .filter((id) => !known.has(id))
+        .map((inputId) => ({
+        code: 'unknown-input',
+        inputId,
+        message: `Undeclared or stale native runtime input ${inputId}`,
+    }));
+    const resolved = new Map();
+    for (const slot of slots) {
+        if (!Object.hasOwn(values, slot.id)) {
+            issues.push({
+                code: 'missing-input',
+                inputId: slot.id,
+                nodeId: slot.nodeId,
+                message: `Missing native runtime input ${slot.id} for ${slot.nodeId}`,
+            });
+            continue;
+        }
+        if (slot.targetPointer === '' &&
+            !nativeParameterValuesSchema.safeParse(values[slot.id]).success) {
+            issues.push({
+                code: 'invalid-value',
+                inputId: slot.id,
+                nodeId: slot.nodeId,
+                message: `Native runtime input ${slot.nodeId} must be a JSON parameter object`,
+            });
+            continue;
+        }
+        try {
+            const checked = createOasValueValidator(slot.schema, 'draft-2020-12', `native input ${slot.nodeId}`).validate(values[slot.id]);
+            if (!checked.valid)
+                throw new Error(checked.errors.map((error) => error.message).join('; '));
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            issues.push({
+                code: 'invalid-value',
+                inputId: slot.id,
+                nodeId: slot.nodeId,
+                message: `Native runtime input ${slot.nodeId} violates its original parameter schema: ${error.message}`,
+            });
+        }
+    }
+    if (issues.length)
+        return {
+            status: issues.every((issue) => issue.code === 'missing-input')
+                ? 'needs-input'
+                : 'invalid-input',
+            slots,
+            issues,
+        };
+    for (const material of createNativeRuntimeParameterMaterializations(input)) {
+        const node = input.nativeNodes.find((node) => node.id === material.nodeId);
+        const capability = input.capabilities.find((entry) => entry.name === node.capability);
+        try {
+            const parameters = parseNativeNodeParameters({
+                id: node.id,
+                capability: node.capability,
+                parameters: materializeNativeRuntimeParameters(material, values),
+            }, capability);
+            const checked = createOasValueValidator(material.schema, 'draft-2020-12', `native complete input ${node.id}`).validate(parameters);
+            if (!checked.valid)
+                throw new Error(checked.errors.map((error) => error.message).join('; '));
+            resolved.set(node.id, {
+                id: node.id,
+                capability: node.capability,
+                parameters: structuredClone(parameters),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            issues.push({
+                code: 'invalid-value',
+                inputId: material.inputs[0].id,
+                nodeId: node.id,
+                message: `Native runtime input ${node.id} violates its complete original parameter schema: ${error.message}`,
+            });
+        }
+    }
+    if (issues.length)
+        return { status: 'invalid-input', slots, issues };
+    return {
+        status: 'ready',
+        slots,
+        issues: [],
+        nativeNodes: input.nativeNodes.map((node) => node.runtimeParameters !== undefined
+            ? resolved.get(node.id)
+            : structuredClone(node)),
+    };
+}

package/dist/inputs/native/materialize-native-runtime-parameters.d.ts

@@ -0,0 +1,4 @@
+import type { NativeRuntimeParameterMaterialization, NativeRuntimeInputValues } from '../../types/native-runtime-inputs.js';
+import type { JsonValueObject } from '../../types/api-arguments.js';
+/** Pure runtime assignment shared by in-process inspection and generated offline n8n guards. */
+export declare function materializeNativeRuntimeParameters(material: NativeRuntimeParameterMaterialization, values: NativeRuntimeInputValues): JsonValueObject;

package/dist/inputs/native/materialize-native-runtime-parameters.js

@@ -0,0 +1,47 @@
+import { assignJsonInputValue } from '../../bindings/assign-json-input-value.js';
+import { pointerTokens } from '../../bindings/json-pointer.js';
+import { cloneJsonValue } from '../../utils/clone-json-value.js';
+/** Pure runtime assignment shared by in-process inspection and generated offline n8n guards. */
+export function materializeNativeRuntimeParameters(material, values) {
+    let parameters = cloneJsonValue(material.parameters);
+    const inputs = [...material.inputs].sort((left, right) => {
+        const a = pointerTokens(left.targetPointer), b = pointerTokens(right.targetPointer);
+        for (let index = 0; index < Math.min(a.length, b.length); index++) {
+            if (a[index] === b[index])
+                continue;
+            return /^(0|[1-9][0-9]*)$/.test(a[index]) &&
+                /^(0|[1-9][0-9]*)$/.test(b[index])
+                ? Number(a[index]) - Number(b[index])
+                : a[index].localeCompare(b[index]);
+        }
+        return a.length - b.length;
+    });
+    for (const source of inputs) {
+        if (!Object.hasOwn(values, source.id))
+            throw new Error(`Missing native runtime input ${source.id} for ${material.nodeId}${source.targetPointer}`);
+        const value = values[source.id];
+        if (source.targetPointer === '') {
+            if (inputs.length !== 1 ||
+                Object.keys(parameters).length ||
+                value === null ||
+                typeof value !== 'object' ||
+                Array.isArray(value))
+                throw new Error(`Native runtime input ${material.nodeId} must be an exclusive JSON parameter object`);
+            parameters = cloneJsonValue(value);
+        }
+        else {
+            parameters = assignJsonInputValue({
+                values: parameters,
+                pointer: source.targetPointer,
+                value,
+                source: `Native runtime input ${material.nodeId}`,
+                containerKind(pointer) {
+                    if (!Object.hasOwn(source.containerKinds, pointer))
+                        throw new Error(`Native runtime input ${material.nodeId} has no declared container at ${pointer}`);
+                    return source.containerKinds[pointer];
+                },
+            });
+        }
+    }
+    return parameters;
+}

package/dist/openapi/catalog/api-operation-key-equals.d.ts

@@ -0,0 +1,2 @@
+import type { ApiOperationKey } from '../../types/api-catalog.js';
+export declare function apiOperationKeyEquals(left: ApiOperationKey, right: ApiOperationKey): boolean;

package/dist/openapi/catalog/api-operation-key-equals.js

@@ -0,0 +1,5 @@
+export function apiOperationKeyEquals(left, right) {
+    return (left.documentId === right.documentId &&
+        left.snapshotId === right.snapshotId &&
+        left.operationRef === right.operationRef);
+}