@openapi-flow/core 0.2.0 → 0.3.1

package/dist/workflow/planning/validate-native-node-planning-record.js

@@ -0,0 +1,12 @@
+import { isDeepStrictEqual } from 'node:util';
+import { nativeNodePlanningRecordSchema } from '../../schemas/native-node-planning-record-schema.js';
+import { createNativeNodePlanningRecord } from './create-native-node-planning-record.js';
+export function validateNativeNodePlanningRecord(input) {
+    const record = nativeNodePlanningRecordSchema.parse(input.record);
+    const expected = createNativeNodePlanningRecord({
+        ...input,
+        ...(record.kind === 'model-plan' ? { assessment: record.assessment } : {}),
+    });
+    if (!isDeepStrictEqual(record, expected))
+        throw new Error('Native planning record differs from the original scenario, prepared instances, implementation contracts or actual proposal');
+}

package/dist/workflow/planning/validate-native-producer-dependency-graph.d.ts

@@ -0,0 +1,3 @@
+import type { NativeInstanceDependencyProposal } from '../../types/native-instance-dependencies.js';
+/** Selected roles must form a planning DAG. Existing external contracts do not become generated roles. */
+export declare function validateNativeProducerDependencyGraph(nodeIds: string[], proposal: NativeInstanceDependencyProposal): void;

package/dist/workflow/planning/validate-native-producer-dependency-graph.js

@@ -0,0 +1,19 @@
+/** Selected roles must form a planning DAG. Existing external contracts do not become generated roles. */
+export function validateNativeProducerDependencyGraph(nodeIds, proposal) {
+    const remaining = new Map(nodeIds.map((nodeId) => [
+        nodeId,
+        new Set(proposal.sourcesByNodeId[nodeId].sourceNodeIds.filter((id) => nodeIds.includes(id))),
+    ]));
+    while (remaining.size) {
+        const ready = [...remaining]
+            .filter(([, sources]) => sources.size === 0)
+            .map(([id]) => id);
+        if (!ready.length)
+            throw new Error('Native producer dependency cycle: ' + [...remaining.keys()].join(', '));
+        for (const id of ready)
+            remaining.delete(id);
+        for (const sources of remaining.values())
+            for (const id of ready)
+                sources.delete(id);
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { ResolveNativeMaterialSnapshotInput, NativeMaterialSnapshot } from '../types/native-material-snapshot.js';
+/** Resolve actual source contracts in dependency order; unresolved output is never replaced by an old schema. */
+export declare function resolveNativeMaterialSnapshot(input: ResolveNativeMaterialSnapshotInput): NativeMaterialSnapshot;

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

@@ -0,0 +1,200 @@
+import { isDeepStrictEqual } from 'node:util';
+import { inspectNativeReferenceStructure } from './inspect-native-reference-structure.js';
+import { createWorkflowNodeContracts } from './create-workflow-node-contracts.js';
+import { createNativeOutputContracts } from './create-native-output-contracts.js';
+import { validateNativeOutputContracts } from '../bindings/validate-native-output-contracts.js';
+import { validateNativeMaterialSources } from './validate-native-material-sources.js';
+import { describeNativeReferenceBindings } from './describe-native-reference-bindings.js';
+import { bindNativeMaterialContracts } from './bind-native-material-contracts.js';
+/** Resolve actual source contracts in dependency order; unresolved output is never replaced by an old schema. */
+export function resolveNativeMaterialSnapshot(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        throw new Error('Native material snapshot input must be an object');
+    for (const field of [
+        'apiMaterials',
+        'nativeOutputs',
+        'nativeNodes',
+        'capabilities',
+        'deferredNodeIds',
+    ])
+        if (!Array.isArray(input[field]))
+            throw new Error(`Native material snapshot.${field} must be an explicit array`);
+    if (input.shouldDeferNode !== undefined &&
+        typeof input.shouldDeferNode !== 'function')
+        throw new Error('Native material snapshot.shouldDeferNode must be a function');
+    if (input.capabilities.some((capability) => typeof capability?.name !== 'string' || !capability.name.trim()))
+        throw new Error('Native material snapshot.capabilities must have non-empty names');
+    const registry = new Map(input.capabilities.map((capability) => [capability.name, capability]));
+    const ids = [
+        ...input.apiMaterials.map((source) => source.callId),
+        ...input.nativeNodes.map((node) => node.id),
+    ];
+    if (new Set(ids).size !== ids.length ||
+        ids.some((id) => typeof id !== 'string' || !id.trim()) ||
+        registry.size !== input.capabilities.length)
+        throw new Error('Native material snapshot requires unique actual node IDs and capability names');
+    if (new Set(input.deferredNodeIds).size !== input.deferredNodeIds.length ||
+        input.deferredNodeIds.some((id) => !input.nativeNodes.some((node) => node.id === id)))
+        throw new Error('Native material snapshot deferredNodeIds must name distinct actual native nodes');
+    validateNativeOutputContracts(input.nativeOutputs);
+    if (input.nativeOutputs.some((output) => ids.includes(output.nodeId)))
+        throw new Error('Native material snapshot external outputs cannot replace a current workflow node');
+    const references = new Map();
+    for (const node of input.nativeNodes) {
+        const capability = registry.get(node.capability);
+        if (!capability)
+            throw new Error(`Native material snapshot node ${node.id}: unknown capability ${node.capability}`);
+        if (capability.bindMaterialContracts &&
+            (!capability.referenceStructureSchema ||
+                !capability.parameterReferenceBindings))
+            throw new Error(`Native capability ${capability.name} requires explicit reference structure for material binding`);
+        if (capability.referenceStructureSchema)
+            references.set(node.id, inspectNativeReferenceStructure({ node, capability }).map((binding) => binding.reference));
+        else {
+            const [contract] = createWorkflowNodeContracts({
+                materials: [],
+                nativeNodes: [node],
+                capabilities: [capability],
+            });
+            references.set(node.id, [
+                ...contract.references,
+                ...Object.values(contract.inputReferences === undefined
+                    ? {}
+                    : contract.inputReferences).flat(),
+                ...(contract.rejoinsExclusiveOutputs === undefined
+                    ? []
+                    : [
+                        {
+                            source: 'exclusive-output',
+                            nodeId: contract.rejoinsExclusiveOutputs,
+                        },
+                    ]),
+            ]);
+        }
+    }
+    const remaining = [...input.nativeNodes];
+    for (const [nodeId, declared] of references)
+        for (const reference of declared) {
+            if (reference.source !== 'response' &&
+                input.apiMaterials.some((source) => source.callId === reference.nodeId))
+                throw new Error(`node ${nodeId}: expected declared native node ${reference.nodeId} for ${reference.source}; supplied source is an API`);
+            if (reference.source === 'response' &&
+                (input.nativeNodes.some((node) => node.id === reference.nodeId) ||
+                    input.nativeOutputs.some((output) => output.nodeId === reference.nodeId)))
+                throw new Error(`node ${nodeId}: expected supplied API callId ${reference.nodeId}, not a native source`);
+        }
+    const outputs = [];
+    const bindings = [];
+    const pending = [];
+    const sources = () => ({
+        apiMaterials: structuredClone(input.apiMaterials),
+        nativeOutputs: structuredClone([...input.nativeOutputs, ...outputs]),
+    });
+    function bind(definition) {
+        return bindNativeMaterialContracts(definition, sources());
+    }
+    let progressed = true;
+    while (remaining.length && progressed) {
+        progressed = false;
+        for (let index = 0; index < remaining.length;) {
+            const node = remaining[index];
+            if (input.deferredNodeIds.includes(node.id) ||
+                input.shouldDeferNode?.(node.id, structuredClone(outputs), bindings.map((binding) => binding.nodeId)) === true) {
+                pending.push({
+                    nodeId: node.id,
+                    capability: node.capability,
+                    kind: 'deferred-reference',
+                    sourceNodeIds: [
+                        ...new Set(references.get(node.id).map((reference) => reference.nodeId)),
+                    ],
+                });
+                remaining.splice(index, 1);
+                progressed = true;
+                continue;
+            }
+            const unresolved = references
+                .get(node.id)
+                .filter((reference) => reference.source === 'response'
+                ? !input.apiMaterials.some((source) => source.callId === reference.nodeId)
+                : reference.source === 'exclusive-output'
+                    ? !bindings.some((bound) => bound.nodeId === reference.nodeId)
+                    : ![...input.nativeOutputs, ...outputs].some((output) => output.nodeId === reference.nodeId));
+            if (unresolved.length) {
+                index++;
+                continue;
+            }
+            const capability = bind(registry.get(node.capability));
+            if (capability.parameterReferenceBindings)
+                describeNativeReferenceBindings({ node, capability });
+            const [contract] = createWorkflowNodeContracts({
+                materials: [],
+                nativeNodes: [node],
+                capabilities: [capability],
+            });
+            const actualReferences = [
+                ...contract.references,
+                ...Object.values(contract.inputReferences === undefined
+                    ? {}
+                    : contract.inputReferences).flat(),
+            ];
+            validateNativeMaterialSources(capability, actualReferences, sources());
+            outputs.push(...createNativeOutputContracts({
+                nativeNodes: [node],
+                capabilities: [capability],
+            }));
+            bindings.push({ nodeId: node.id, capability });
+            remaining.splice(index, 1);
+            progressed = true;
+        }
+    }
+    for (const node of remaining)
+        pending.push({
+            nodeId: node.id,
+            capability: node.capability,
+            kind: 'unavailable-source',
+            sourceNodeIds: [
+                ...new Set(references
+                    .get(node.id)
+                    .filter((reference) => reference.source === 'response'
+                    ? !input.apiMaterials.some((source) => source.callId === reference.nodeId)
+                    : reference.source === 'exclusive-output'
+                        ? !bindings.some((bound) => bound.nodeId === reference.nodeId)
+                        : ![...input.nativeOutputs, ...outputs].some((output) => output.nodeId === reference.nodeId))
+                    .map((reference) => reference.nodeId)),
+            ],
+        });
+    if (pending.length)
+        return { status: 'pending', bindings, outputs, pending };
+    const capabilities = [
+        ...new Set(input.nativeNodes.map((node) => node.capability)),
+    ].map((name) => bind(registry.get(name)));
+    const completedContracts = createWorkflowNodeContracts({
+        materials: [],
+        nativeNodes: input.nativeNodes,
+        capabilities,
+    });
+    for (const node of input.nativeNodes) {
+        const capability = capabilities.find((candidate) => candidate.name === node.capability);
+        const contract = completedContracts.find((candidate) => candidate.id === node.id);
+        validateNativeMaterialSources(capability, [
+            ...contract.references,
+            ...Object.values(contract.inputReferences === undefined
+                ? {}
+                : contract.inputReferences).flat(),
+        ], sources());
+    }
+    const completed = createNativeOutputContracts({
+        nativeNodes: input.nativeNodes,
+        capabilities,
+    });
+    for (const output of outputs)
+        if (!isDeepStrictEqual(output, completed.find((item) => item.nodeId === output.nodeId)))
+            throw new Error(`Native material binding ${output.nodeId} changes its output when unrelated contracts become available`);
+    return {
+        status: 'ready',
+        bindings,
+        outputs: completed,
+        pending,
+        capabilities,
+    };
+}

package/dist/workflow/resolve-native-structure-parameters.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValueObject } from '../types/api-arguments.js';
+import type { PlannedNativeNode, WorkflowCapability } from '../types/workflow-plan.js';
+/** {} is a declared binding source, never a fabricated complete parameter value. */
+export declare function resolveNativeStructureParameters(planned: PlannedNativeNode, capability: WorkflowCapability): JsonValueObject;

package/dist/workflow/resolve-native-structure-parameters.js

@@ -0,0 +1,56 @@
+import { parseNativeNodeParameters } from './parse-native-node-parameters.js';
+import { nativeRuntimeParametersSchema, nativeParameterValuesSchema, } from '../schemas/native-runtime-input-slot-schema.js';
+import { hasPointer, pointerTokens, pointerValue, } from '../bindings/json-pointer.js';
+import { createNativeRuntimeParametersSchema } from '../schemas/create-native-runtime-parameters-schema.js';
+import { optionalRequestProperties } from '../schemas/operation-plan-schema.js';
+import { createOasValueValidator } from '../openapi/common/create-oas-value-validator.js';
+import { projectLiteralInputSchema } from '../schemas/project-literal-input-schema.js';
+/** {} is a declared binding source, never a fabricated complete parameter value. */
+export function resolveNativeStructureParameters(planned, capability) {
+    if (planned.runtimeParameters === undefined)
+        return parseNativeNodeParameters(planned, capability);
+    if (capability.supportsRuntimeParameters !== true)
+        throw new Error(`node ${planned.id}: capability ${capability.name} does not declare runtime-independent parameter structure`);
+    const parsed = nativeRuntimeParametersSchema.safeParse(planned.runtimeParameters);
+    if (!parsed.success)
+        throw new Error(`node ${planned.id}: runtime-independent parameters require true or explicit pointer selection`, { cause: parsed.error });
+    const ownership = parsed.data;
+    if (ownership !== true) {
+        nativeParameterValuesSchema.parse(planned.parameters);
+        const seen = [];
+        for (const pointer of ownership.pointers) {
+            const tokens = pointerTokens(pointer);
+            for (let length = 1; length < tokens.length; length++) {
+                const parent = '/' +
+                    tokens
+                        .slice(0, length)
+                        .map((token) => token.replaceAll('~', '~0').replaceAll('/', '~1'))
+                        .join('/');
+                if (!hasPointer(planned.parameters, parent))
+                    continue;
+                const value = pointerValue(planned.parameters, parent);
+                if (value === null || typeof value !== 'object')
+                    throw new Error(`node ${planned.id}: runtime parameter ${pointer} traverses literal non-container ${parent}`);
+            }
+            if (seen.some((other) => other === pointer ||
+                other.startsWith(pointer + '/') ||
+                pointer.startsWith(other + '/')))
+                throw new Error(`node ${planned.id}: runtime parameter pointers overlap at ${pointer}`);
+            if (hasPointer(planned.parameters, pointer))
+                throw new Error(`node ${planned.id}: runtime parameter ${pointer} also contains a literal value`);
+            seen.push(pointer);
+        }
+        const literalSchema = optionalRequestProperties(createNativeRuntimeParametersSchema(capability));
+        const schema = projectLiteralInputSchema(literalSchema, ownership.pointers.map(pointerTokens), `native partial parameters ${planned.id}`).schema;
+        const checked = createOasValueValidator(schema, 'draft-2020-12', `native partial parameters ${planned.id}`).validate(planned.parameters);
+        if (!checked.valid)
+            throw new Error(`node ${planned.id}: partial parameter literals violate their schema: ${checked.errors.map((error) => error.message).join('; ')}`);
+        return planned.parameters;
+    }
+    if (!planned.parameters ||
+        typeof planned.parameters !== 'object' ||
+        Array.isArray(planned.parameters) ||
+        Object.keys(planned.parameters).length !== 0)
+        throw new Error(`node ${planned.id}: runtime parameters must not also contain literal parameter values`);
+    return planned.parameters;
+}

package/dist/workflow/validate-native-api-response-references.js

@@ -1,5 +1,5 @@
 import { assertApiCallIdentities } from './assert-api-call-identities.js';
-import { parseNativeNodeParameters } from './parse-native-node-parameters.js';
+import { resolveNativeStructureParameters } from './resolve-native-structure-parameters.js';
 export function validateNativeApiResponseReferences({ nativeNodes, capabilities, apiCallIds, }) {
     assertApiCallIdentities(apiCallIds);
     const registry = new Map(capabilities.map((capability) => [capability.name, capability]));
@@ -10,7 +10,7 @@ export function validateNativeApiResponseReferences({ nativeNodes, capabilities,
         const capability = registry.get(native.capability);
         if (!capability)
             throw new Error(`node ${native.id}: unknown capability ${native.capability}`);
-        const parameters = parseNativeNodeParameters(native, capability);
+        const parameters = resolveNativeStructureParameters(native, capability);
         const references = [
             ...capability.responseReferences(parameters),
             ...Object.values(capability.inputReferences

package/dist/workflow/validate-native-material-sources.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowCapability, WorkflowValueReference } from '../types/workflow-plan.js';
+import type { WorkflowNativeMaterialSources } from '../types/native-material-snapshot.js';
+/** Captured contracts must describe the actual referenced producer, not another material revision. */
+export declare function validateNativeMaterialSources(capability: WorkflowCapability, references: WorkflowValueReference[], sources: WorkflowNativeMaterialSources): void;

package/dist/workflow/validate-native-material-sources.js

@@ -0,0 +1,26 @@
+import { isDeepStrictEqual } from 'node:util';
+/** Captured contracts must describe the actual referenced producer, not another material revision. */
+export function validateNativeMaterialSources(capability, references, sources) {
+    if (capability.bindMaterialContracts && !capability.materialSources)
+        throw new Error(`Native capability ${capability.name}.bindMaterialContracts must declare its actual materialSources`);
+    if (!capability.materialSources)
+        return;
+    for (const reference of references) {
+        if (reference.source === 'response') {
+            const actual = sources.apiMaterials.find((source) => source.callId === reference.nodeId);
+            const captured = capability.materialSources.apiMaterials.find((source) => source.callId === reference.nodeId);
+            if (!actual ||
+                !captured ||
+                !isDeepStrictEqual(actual.operation, captured.operation))
+                throw new Error(`Native capability ${capability.name}: API source ${reference.nodeId} does not match the current material contract`);
+        }
+        else {
+            const actual = sources.nativeOutputs.find((source) => source.nodeId === reference.nodeId);
+            const captured = capability.materialSources.nativeOutputs.find((source) => source.nodeId === reference.nodeId);
+            if (!actual ||
+                !captured ||
+                !isDeepStrictEqual(actual.schema, captured.schema))
+                throw new Error(`Native capability ${capability.name}: native source ${reference.nodeId} does not match the current material contract`);
+        }
+    }
+}

package/dist/workflow/validate-native-reference-binding-locations.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValueObject } from '../types/api-arguments.js';
+import type { WorkflowNativeReferenceBinding } from '../types/native-parameter-reference.js';
+/** Physical location validation is independent of whether the producer contract is ready. */
+export declare function validateNativeReferenceBindingLocations(nodeId: string, parameters: JsonValueObject, bindings: WorkflowNativeReferenceBinding[]): void;

package/dist/workflow/validate-native-reference-binding-locations.js

@@ -0,0 +1,35 @@
+import { nativeReferenceBindingSchema } from '../schemas/native-reference-binding-schema.js';
+import { pointerTokens, pointerValue } from '../bindings/json-pointer.js';
+/** Physical location validation is independent of whether the producer contract is ready. */
+export function validateNativeReferenceBindingLocations(nodeId, parameters, bindings) {
+    nativeReferenceBindingSchema.array().parse(bindings);
+    const signatures = new Set();
+    for (const binding of bindings) {
+        if (!pointerTokens(binding.nodeIdPointer).length ||
+            pointerValue(parameters, binding.nodeIdPointer) !==
+                binding.reference.nodeId)
+            throw new Error(`Native reference binding for ${nodeId} must locate its actual node ID value`);
+        if ('pointer' in binding.reference) {
+            try {
+                pointerTokens(binding.reference.pointer);
+            }
+            catch (cause) {
+                throw new Error(`node ${nodeId}: invalid ${binding.reference.source} JSON pointer ${binding.reference.pointer} in reference binding ${binding.nodeIdPointer}`, { cause });
+            }
+        }
+        if (binding.valuePointer !== undefined &&
+            (!pointerTokens(binding.valuePointer).length ||
+                !('pointer' in binding.reference) ||
+                pointerValue(parameters, binding.valuePointer) !==
+                    binding.reference.pointer))
+            throw new Error(`Native reference binding for ${nodeId} must locate its actual declared value pointer`);
+        const signature = JSON.stringify([
+            binding.nodeIdPointer,
+            binding.valuePointer,
+            binding.reference,
+        ]);
+        if (signatures.has(signature))
+            throw new Error(`Native reference bindings for ${nodeId} repeat an identical location`);
+        signatures.add(signature);
+    }
+}

package/dist/workflow/validate-reviewable-workflow-graph-plan.js

@@ -1,4 +1,4 @@
-import { validateApiArguments } from '../arguments/validate-api-arguments.js';
+import { validateWorkflowApiInputReadiness } from './validate-workflow-api-input-readiness.js';
 import { validateApiBindingAssignments } from '../bindings/validate-api-binding-assignments.js';
 import { validateApiBindingGaps } from '../bindings/validate-api-binding-gaps.js';
 import { createReviewableNodeContracts } from './create-reviewable-node-contracts.js';
@@ -31,18 +31,8 @@ export function validateReviewableWorkflowGraphPlan(input) {
                 item.gapIds.some((id) => !blocked.get(item.callId)?.includes(id)))
                 throw new Error(`review plan omitted blocked requirement for ${item.callId}`);
         }
-        else {
-            const args = item.arguments;
-            const result = validateApiArguments({
-                operation: item.operation,
-                values: args.values,
-                bindings: args.bindings,
-                requestMediaType: args.requestMediaType,
-            });
-            if (args.unresolvedInputs.length || !result.valid)
-                throw new Error(`review ready material ${args.callId} has unresolved request inputs`);
-        }
     }
+    validateWorkflowApiInputReadiness(input);
     if (materials.length)
         validateApiBindingAssignments({
             nativeOutputs: createNativeOutputContracts({

package/dist/workflow/validate-workflow-api-input-readiness.d.ts

@@ -0,0 +1,4 @@
+import type { DeferredApiInputSlot } from '../types/deferred-api-inputs.js';
+import type { WorkflowApiInputReadinessInput } from '../types/workflow-api-input-readiness.js';
+/** Missing literals may be planned, but only with explicit, current slot ownership. */
+export declare function validateWorkflowApiInputReadiness(input: WorkflowApiInputReadinessInput): DeferredApiInputSlot[];

package/dist/workflow/validate-workflow-api-input-readiness.js

@@ -0,0 +1,33 @@
+import { collectDeferredApiInputSlots } from '../inputs/collect-deferred-api-input-slots.js';
+import { workflowDeferredApiInputIdsSchema } from '../schemas/workflow-api-input-deferral-schema.js';
+/** Missing literals may be planned, but only with explicit, current slot ownership. */
+export function validateWorkflowApiInputReadiness(input) {
+    const ids = input.deferredApiInputIds === undefined
+        ? []
+        : workflowDeferredApiInputIdsSchema.parse(input.deferredApiInputIds);
+    const ready = input.materials.filter((material) => material.status === 'ready');
+    // This validates supplied values against their original OAS before deriving missing slots.
+    const slots = collectDeferredApiInputSlots({
+        materials: ready.map((material) => ({
+            operation: material.operation,
+            callId: material.arguments.callId,
+            values: material.arguments.values,
+            bindings: material.arguments.bindings,
+            requestMediaType: material.arguments.requestMediaType,
+            requestedInputs: material.arguments.requestedInputs,
+        })),
+    });
+    for (const id of ids)
+        if (!slots.some((slot) => slot.id === id))
+            throw new Error(`deferredApiInputIds contains unknown or stale slot ${id}`);
+    for (const slot of slots)
+        if (!ids.includes(slot.id))
+            throw new Error(`materials[${slot.callId}] has unresolved OAS request inputs or scenario-requested inputs: ${slot.targetPointer}; explicitly defer current slot ${slot.id} or supply its value`);
+    for (const material of ready) {
+        const args = material.arguments;
+        if (new Set(args.unresolvedInputs).size !== args.unresolvedInputs.length ||
+            args.unresolvedInputs.some((pointer) => !slots.some((slot) => slot.callId === args.callId && slot.targetPointer === pointer)))
+            throw new Error(`materials[${args.callId}].unresolvedInputs must name current OAS request input slots without duplicates`);
+    }
+    return slots;
+}

package/dist/workflow/validate-workflow-graph-plan.d.ts

@@ -1,3 +1,3 @@
 import type { ValidateWorkflowGraphPlanInput } from '../types/workflow-plan.js';
 /** Reject invalid graph proposals; never repair or infer edges. */
-export declare function validateWorkflowGraphPlan({ plan, materials, capabilities, }: ValidateWorkflowGraphPlanInput): void;
+export declare function validateWorkflowGraphPlan({ plan, materials, capabilities, unresolvedNodes, }: ValidateWorkflowGraphPlanInput): void;

package/dist/workflow/validate-workflow-graph-plan.js

@@ -1,13 +1,24 @@
 import { validateApiBindingPlan } from '../bindings/validate-api-binding-plan.js';
 import { createWorkflowNodeContracts } from './create-workflow-node-contracts.js';
 import { validateWorkflowTopology } from './validate-workflow-topology.js';
-import { createNativeOutputContracts } from './create-native-output-contracts.js';
+import { resolveNativeMaterialSnapshot } from './resolve-native-material-snapshot.js';
+import { NativeMaterialResolutionError } from './native-material-resolution-error.js';
 /** Reject invalid graph proposals; never repair or infer edges. */
-export function validateWorkflowGraphPlan({ plan, materials, capabilities, }) {
-    const nativeOutputs = createNativeOutputContracts({
+export function validateWorkflowGraphPlan({ plan, materials, capabilities, unresolvedNodes, }) {
+    const snapshot = resolveNativeMaterialSnapshot({
+        apiMaterials: materials.map((material) => ({
+            callId: material.arguments.callId,
+            operation: material.operation,
+            requestMediaType: material.arguments.requestMediaType,
+        })),
+        nativeOutputs: [],
+        deferredNodeIds: [],
         nativeNodes: plan.nativeNodes,
         capabilities,
     });
+    if (snapshot.status !== 'ready')
+        throw new NativeMaterialResolutionError(snapshot.pending);
+    const nativeOutputs = snapshot.outputs;
     if (materials.length)
         validateApiBindingPlan({
             nativeOutputs,
@@ -30,7 +41,8 @@ export function validateWorkflowGraphPlan({ plan, materials, capabilities, }) {
     const contracts = createWorkflowNodeContracts({
         materials,
         nativeNodes: plan.nativeNodes,
-        capabilities,
+        capabilities: snapshot.capabilities,
+        unresolvedNodes,
     });
     validateWorkflowTopology({
         contracts,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openapi-flow/core",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "license": "MIT",
   "description": "Engine-independent OpenAPI catalogs, operation contracts and typed request schemas",
   "keywords": [
@@ -57,6 +57,12 @@
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",
     "fast-uri": "3.1.8",
+    "jsonc-parser": "3.3.1"
+  },
+  "peerDependencies": {
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
     "zod": "4.6.5"
   }
 }