@openapi-flow/core 0.2.0 → 0.3.1

package/dist/draft/edits/native/describe-workflow-draft-native-parameter-edit.js

@@ -0,0 +1,67 @@
+import { createHash } from 'node:crypto';
+import { resolveWorkflowPlanningMessages } from '../../../planning/evidence/resolve-workflow-planning-messages.js';
+import { z } from 'zod';
+import { stageWorkflowDraftEdit } from '../stage-workflow-draft-edit.js';
+import { createWorkflowPlanningCapabilities } from '../../../workflow/create-workflow-planning-capabilities.js';
+import { describeWorkflowDraftReferenceSources } from '../references/describe-workflow-draft-reference-sources.js';
+import { nativeMaterialSourcesFromDraftReferences } from '../references/native-material-sources-from-draft-references.js';
+import { bindNativeMaterialContracts } from '../../../workflow/bind-native-material-contracts.js';
+/** Resolve an unfinished native revision, never replace its identity or registered capability. */
+export function describeWorkflowDraftNativeParameterEdit(input) {
+    if (input.allowRuntimeParameters !== undefined &&
+        typeof input.allowRuntimeParameters !== 'boolean')
+        throw new Error('Native parameter edit allowRuntimeParameters must be a boolean');
+    const stage = stageWorkflowDraftEdit(input);
+    const step = input.plan.steps.find((step) => step.id === input.stepId);
+    if (!step || step.decision.kind !== 'revise-native-node')
+        throw new Error('Native parameter edit stepId must identify a revise-native-node decision');
+    if (!stage.pendingResolutionStepIds.includes(step.id))
+        throw new Error('Native parameter edit already has an explicit result; remove it before replanning');
+    const nodeId = step.decision.nodeId;
+    const node = stage.content.nativeNodes.find((node) => node.id === nodeId);
+    if (stage.content.requirements.some((requirement) => requirement.state !== 'confirmed' &&
+        (requirement.scope.kind === 'workflow' ||
+            requirement.scope.nodeIds.includes(node.id))))
+        throw new Error(`Native parameter target ${node.id} is blocked by an unresolved requirement`);
+    const definition = input.context.capabilities.find((capability) => capability.name === node.capability);
+    const sources = describeWorkflowDraftReferenceSources({
+        stage,
+        context: input.context,
+        excludedNodeIds: [node.id],
+    });
+    const original = bindNativeMaterialContracts(definition, nativeMaterialSourcesFromDraftReferences(sources));
+    const [planning] = createWorkflowPlanningCapabilities({
+        capabilities: [original],
+        apiCallIds: sources.values
+            .filter((source) => source.kind === 'api')
+            .map((source) => source.nodeId),
+    });
+    const fields = {
+        stage,
+        node: structuredClone(node),
+        capability: {
+            name: original.name,
+            description: original.description,
+            supportsRuntimeParameters: original.supportsRuntimeParameters === true,
+        },
+        parametersSchema: JSON.parse(JSON.stringify(z.toJSONSchema(planning.parametersSchema, {
+            io: 'input',
+            target: 'draft-2020-12',
+            reused: 'inline',
+            cycles: 'ref',
+        }))),
+        instruction: step.decision.instruction,
+        messages: structuredClone(resolveWorkflowPlanningMessages(input.context).filter((message) => input.requestMessageIds.includes(message.id))),
+        backgroundMessages: structuredClone(resolveWorkflowPlanningMessages(input.context).filter((message) => !input.requestMessageIds.includes(message.id))),
+        sourceCandidates: sources.values,
+        exclusiveOutputSources: sources.exclusiveOutputs,
+        includeExplanations: input.plan.options.includeExplanations,
+        allowRuntimeParameters: input.allowRuntimeParameters === true,
+    };
+    return {
+        fingerprint: createHash('sha256')
+            .update(JSON.stringify(fields))
+            .digest('hex'),
+        ...fields,
+    };
+}

package/dist/draft/edits/native/repairs/collect-native-reference-repair-pointers.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowNativeReferenceBinding } from '../../../../types/native-parameter-reference.js';
+/** A shared physical setting couples every declared reference using that setting. */
+export declare function collectNativeReferenceRepairPointers(bindings: WorkflowNativeReferenceBinding[], changedValueSources: ReadonlySet<string>, changedControlSources: ReadonlySet<string>): string[];

package/dist/draft/edits/native/repairs/collect-native-reference-repair-pointers.js

@@ -0,0 +1,29 @@
+/** A shared physical setting couples every declared reference using that setting. */
+export function collectNativeReferenceRepairPointers(bindings, changedValueSources, changedControlSources) {
+    const pointers = new Set();
+    const locations = (binding) => [
+        binding.nodeIdPointer,
+        ...(binding.valuePointer === undefined ? [] : [binding.valuePointer]),
+    ];
+    for (const binding of bindings)
+        if ((binding.reference.source === 'exclusive-output'
+            ? changedControlSources
+            : changedValueSources).has(binding.reference.nodeId))
+            for (const pointer of locations(binding))
+                pointers.add(pointer);
+    let expanded = true;
+    while (expanded) {
+        expanded = false;
+        for (const binding of bindings) {
+            const shared = locations(binding);
+            if (!shared.some((pointer) => pointers.has(pointer)))
+                continue;
+            for (const pointer of shared)
+                if (!pointers.has(pointer)) {
+                    pointers.add(pointer);
+                    expanded = true;
+                }
+        }
+    }
+    return [...pointers].sort();
+}

package/dist/draft/edits/native/repairs/describe-workflow-draft-native-reference-repair.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftNativeReferenceRepairInput, WorkflowDraftNativeReferenceRepairDescription } from '../../../../types/workflow-draft-native-reference-repair.js';
+/** Only an actual pending consumer task can authorize these reference-location changes. */
+export declare function describeWorkflowDraftNativeReferenceRepair(input: WorkflowDraftNativeReferenceRepairInput): WorkflowDraftNativeReferenceRepairDescription;

package/dist/draft/edits/native/repairs/describe-workflow-draft-native-reference-repair.js

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto';
+import { resolveWorkflowPlanningMessages } from '../../../../planning/evidence/resolve-workflow-planning-messages.js';
+import { stageWorkflowDraftEdit } from '../../stage-workflow-draft-edit.js';
+import { describeNativeReferenceBindings } from '../../../../workflow/describe-native-reference-bindings.js';
+import { inspectNativeReferenceStructure } from '../../../../workflow/inspect-native-reference-structure.js';
+import { describeWorkflowDraftReferenceSources } from '../../references/describe-workflow-draft-reference-sources.js';
+/** Only an actual pending consumer task can authorize these reference-location changes. */
+export function describeWorkflowDraftNativeReferenceRepair(input) {
+    const stage = stageWorkflowDraftEdit(input);
+    const task = stage.pendingRepairs.find((task) => task.id === input.taskId);
+    if (!task || task.kind !== 'native-parameters')
+        throw new Error('Native reference repair taskId must identify a current native consumer repair');
+    if (stage.blockedSourceNodeIds.includes(task.nodeId))
+        throw new Error(`Native repair target ${task.nodeId} is blocked by an unresolved contract or requirement`);
+    const node = stage.content.nativeNodes.find((node) => node.id === task.nodeId);
+    const capability = input.context.capabilities.find((capability) => capability.name === node.capability);
+    const bindings = (capability.referenceStructureSchema
+        ? inspectNativeReferenceStructure({ node, capability })
+        : describeNativeReferenceBindings({ node, capability }))
+        .filter((binding) => task.targetPointers.includes(binding.nodeIdPointer) ||
+        (binding.valuePointer !== undefined &&
+            task.targetPointers.includes(binding.valuePointer)))
+        .map((binding) => ({
+        id: 'reference-' +
+            createHash('sha256')
+                .update(JSON.stringify([
+                node.id,
+                binding.nodeIdPointer,
+                binding.valuePointer,
+                binding.reference,
+            ]))
+                .digest('hex'),
+        ...binding,
+    }));
+    const pointers = new Set(bindings.flatMap((binding) => [
+        binding.nodeIdPointer,
+        ...(binding.valuePointer === undefined ? [] : [binding.valuePointer]),
+    ]));
+    if (!bindings.length ||
+        task.targetPointers.some((pointer) => !pointers.has(pointer)) ||
+        [...pointers].some((pointer) => !task.targetPointers.includes(pointer)))
+        throw new Error('Native consumer repair requires complete implementation-owned parameter reference locations');
+    const sources = describeWorkflowDraftReferenceSources({
+        stage,
+        context: input.context,
+        excludedNodeIds: [node.id],
+    });
+    const fields = {
+        stage,
+        task: structuredClone(task),
+        node: structuredClone(node),
+        bindings,
+        sources,
+        messages: structuredClone(resolveWorkflowPlanningMessages(input.context).filter((message) => input.requestMessageIds.includes(message.id))),
+        backgroundMessages: structuredClone(resolveWorkflowPlanningMessages(input.context).filter((message) => !input.requestMessageIds.includes(message.id))),
+        instructions: input.plan.steps.map((step) => step.decision.instruction),
+        includeExplanations: input.plan.options.includeExplanations,
+    };
+    return {
+        fingerprint: createHash('sha256')
+            .update(JSON.stringify(fields))
+            .digest('hex'),
+        ...fields,
+    };
+}

package/dist/draft/edits/native/repairs/resolve-workflow-draft-native-reference-repair.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveWorkflowDraftNativeReferenceRepairInput, WorkflowDraftNativeReferenceRepairResult } from '../../../../types/workflow-draft-native-reference-repair.js';
+/** Only reference-location strings change. A question never hides an invalid explicit keep/bind. */
+export declare function resolveWorkflowDraftNativeReferenceRepair(input: ResolveWorkflowDraftNativeReferenceRepairInput): WorkflowDraftNativeReferenceRepairResult;

package/dist/draft/edits/native/repairs/resolve-workflow-draft-native-reference-repair.js

@@ -0,0 +1,119 @@
+import { createHash } from 'node:crypto';
+import { describeWorkflowDraftNativeReferenceRepair } from './describe-workflow-draft-native-reference-repair.js';
+import { createWorkflowDraftNativeReferenceRepairSchema } from '../../../../schemas/workflow-draft-native-reference-repair-schema.js';
+import { resolveWorkflowDraftSourceEvidence } from '../../references/resolve-workflow-draft-source-evidence.js';
+import { validateWorkflowDraftNativeReference } from '../../references/validate-workflow-draft-native-reference.js';
+import { validateWorkflowDraftNativeReferences } from '../../references/validate-workflow-draft-native-references.js';
+import { pointerValue } from '../../../../bindings/json-pointer.js';
+import { applyWorkflowDraftValueEdits } from '../../values/apply-workflow-draft-value-edits.js';
+import { parseNativeNodeParameters } from '../../../../workflow/parse-native-node-parameters.js';
+import { workflowDraftNativeNodeSchema } from '../../../../schemas/workflow-draft-schema.js';
+import { bindNativeMaterialContracts } from '../../../../workflow/bind-native-material-contracts.js';
+import { nativeMaterialSourcesFromDraftReferences } from '../../references/native-material-sources-from-draft-references.js';
+/** Only reference-location strings change. A question never hides an invalid explicit keep/bind. */
+export function resolveWorkflowDraftNativeReferenceRepair(input) {
+    const context = describeWorkflowDraftNativeReferenceRepair(input);
+    if (input.fingerprint !== context.fingerprint)
+        throw new Error('Native reference repair fingerprint is stale or describes different staged materials');
+    const proposal = createWorkflowDraftNativeReferenceRepairSchema(context).parse(input.proposal);
+    const assignments = new Map();
+    const questions = [];
+    const decisions = {};
+    function assign(pointer, value) {
+        if (assignments.has(pointer) && assignments.get(pointer) !== value)
+            throw new Error(`Native reference repair decisions conflict at shared parameter ${pointer}`);
+        assignments.set(pointer, value);
+    }
+    for (const binding of context.bindings) {
+        const decision = proposal.decisions[binding.id];
+        const evidence = resolveWorkflowDraftSourceEvidence({
+            decision,
+            description: context,
+            capabilities: input.context.capabilities,
+        });
+        decisions[binding.id] =
+            decision.kind === 'bind'
+                ? {
+                    kind: 'bind',
+                    sourceNodeId: decision.sourceNodeId,
+                    ...(decision.sourcePointer === undefined
+                        ? {}
+                        : { sourcePointer: decision.sourcePointer }),
+                    ...evidence,
+                }
+                : decision.kind === 'keep'
+                    ? { kind: 'keep', ...evidence }
+                    : {
+                        kind: 'needs-clarification',
+                        message: decision.message,
+                        ...evidence,
+                    };
+        if (decision.kind === 'needs-clarification') {
+            questions.push({
+                id: 'native-reference-question:' +
+                    createHash('sha256')
+                        .update(JSON.stringify([context.fingerprint, binding.id, decision]))
+                        .digest('hex'),
+                bindingId: binding.id,
+                nodeId: context.node.id,
+                message: decision.message,
+                ...evidence,
+            });
+            continue;
+        }
+        let reference;
+        if (decision.kind === 'keep')
+            reference = binding.reference;
+        else if (binding.reference.source === 'exclusive-output')
+            reference = { source: 'exclusive-output', nodeId: decision.sourceNodeId };
+        else {
+            if (binding.valuePointer !== undefined &&
+                decision.sourcePointer === undefined)
+                throw new Error('Native reference repair requires its declared configurable sourcePointer');
+            reference = {
+                source: binding.reference.source,
+                nodeId: decision.sourceNodeId,
+                pointer: binding.valuePointer === undefined
+                    ? binding.reference.pointer
+                    : decision.sourcePointer,
+            };
+        }
+        validateWorkflowDraftNativeReference({
+            reference,
+            sources: context.sources,
+        });
+        assign(binding.nodeIdPointer, reference.nodeId);
+        if (binding.valuePointer !== undefined) {
+            if (!('pointer' in reference))
+                throw new Error('A control source cannot supply a value pointer');
+            assign(binding.valuePointer, reference.pointer);
+        }
+    }
+    const fields = { fingerprint: context.fingerprint, proposal, decisions };
+    if (questions.length)
+        return { status: 'needs-clarification', ...fields, questions };
+    const edits = [...assignments]
+        .filter(([pointer, value]) => pointerValue(context.node.parameters, pointer) !== value)
+        .map(([pointer, value]) => ({ kind: 'set', pointer, value }));
+    const node = workflowDraftNativeNodeSchema.parse({
+        ...context.node,
+        parameters: applyWorkflowDraftValueEdits({
+            value: context.node.parameters,
+            edits,
+            source: `Native consumer repair ${context.node.id}`,
+        }),
+    });
+    const definition = input.context.capabilities.find((capability) => capability.name === node.capability);
+    const capability = bindNativeMaterialContracts(definition, nativeMaterialSourcesFromDraftReferences(context.sources));
+    parseNativeNodeParameters(node, capability);
+    validateWorkflowDraftNativeReferences({
+        node,
+        capability,
+        sources: context.sources,
+    });
+    return {
+        status: 'ready',
+        ...fields,
+        repair: { taskId: context.task.id, kind: 'native-parameters', edits },
+    };
+}

package/dist/draft/edits/native/resolve-workflow-draft-native-parameter-edit-targets.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveWorkflowDraftNativeParameterEditTargetsInput, WorkflowDraftNativeParameterEditTargetsResult } from '../../../types/workflow-draft-native-parameter-edit.js';
+/** Code derives target identities and original schema resources; the proposal owns no schema. */
+export declare function resolveWorkflowDraftNativeParameterEditTargets(input: ResolveWorkflowDraftNativeParameterEditTargetsInput): WorkflowDraftNativeParameterEditTargetsResult;

package/dist/draft/edits/native/resolve-workflow-draft-native-parameter-edit-targets.js

@@ -0,0 +1,103 @@
+import { createHash } from 'node:crypto';
+import { describeWorkflowDraftNativeParameterEdit } from './describe-workflow-draft-native-parameter-edit.js';
+import { createWorkflowDraftNativeParameterEditProposalSchema } from '../../../schemas/workflow-draft-native-parameter-edit-schema.js';
+import { validateWorkflowPlanningEvidence } from '../../../planning/evidence/validate-workflow-planning-evidence.js';
+import { pointerTokens, hasPointer } from '../../../bindings/json-pointer.js';
+import { schemasAtPointer } from '../../../bindings/schema-at-pointer.js';
+import { createSchemaResourceContext } from '../../../bindings/resources/create-schema-resource-context.js';
+/** Code derives target identities and original schema resources; the proposal owns no schema. */
+export function resolveWorkflowDraftNativeParameterEditTargets(input) {
+    const context = describeWorkflowDraftNativeParameterEdit(input);
+    if (input.fingerprint !== context.fingerprint)
+        throw new Error('Native parameter edit fingerprint is stale or describes different staged materials');
+    const { decision: proposal } = createWorkflowDraftNativeParameterEditProposalSchema(context).parse(input.proposal);
+    const decisions = proposal.status === 'targets' ? proposal.targets : [proposal];
+    for (const decision of decisions) {
+        validateWorkflowPlanningEvidence({
+            context: { messages: context.messages },
+            evidence: decision.sources,
+        });
+        if (decision.explanation)
+            validateWorkflowPlanningEvidence({
+                context: { messages: context.messages },
+                evidence: decision.explanation.evidence,
+            });
+    }
+    if (proposal.status === 'needs-clarification')
+        return {
+            status: 'needs-clarification',
+            questions: [
+                {
+                    id: 'native-parameter-question:' +
+                        createHash('sha256')
+                            .update(JSON.stringify([context.fingerprint, proposal]))
+                            .digest('hex'),
+                    nodeId: context.node.id,
+                    message: proposal.message,
+                    sources: proposal.sources,
+                    ...(proposal.explanation === undefined
+                        ? {}
+                        : { explanation: proposal.explanation }),
+                },
+            ],
+        };
+    if (proposal.status === 'runtime-parameters')
+        return {
+            status: 'runtime-parameters',
+            resolution: { stepId: input.stepId, kind: 'native-runtime' },
+        };
+    const resources = createSchemaResourceContext(context.parametersSchema);
+    const seen = [];
+    const targets = proposal.targets.map((target, index) => {
+        pointerTokens(target.pointer);
+        if (seen.some((pointer) => pointer === '' ||
+            target.pointer === '' ||
+            pointer === target.pointer ||
+            pointer.startsWith(target.pointer + '/') ||
+            target.pointer.startsWith(pointer + '/')))
+            throw new Error(`Native parameter edit has duplicate or overlapping targets at ${target.pointer}`);
+        seen.push(target.pointer);
+        if (context.node.runtimeParameters === true &&
+            (target.kind !== 'set' || target.pointer !== ''))
+            throw new Error('Runtime-owned native parameters need an explicit whole-object literal replacement');
+        if (target.kind === 'defer' && target.pointer === '')
+            throw new Error('Native parameter deferral needs a field pointer; use runtime-parameters for the whole object');
+        if (context.node.runtimeParameters !== undefined &&
+            context.node.runtimeParameters !== true &&
+            context.node.runtimeParameters.pointers.some((pointer) => target.pointer.startsWith(pointer + '/')))
+            throw new Error(`Native parameter edit ${target.pointer} needs an explicit whole-parent replacement of its runtime-owned parent`);
+        if (target.kind === 'remove' &&
+            (target.pointer === '' ||
+                (!hasPointer(context.node.parameters, target.pointer) &&
+                    !(context.node.runtimeParameters !== undefined &&
+                        context.node.runtimeParameters !== true &&
+                        context.node.runtimeParameters.pointers.some((pointer) => pointer === target.pointer ||
+                            pointer.startsWith(target.pointer + '/'))))))
+            throw new Error(`Native parameter edit cannot remove absent value or parameter root ${target.pointer}`);
+        const schema = target.kind !== 'remove'
+            ? schemasAtPointer(resources.root, target.pointer, resources)[0]
+            : undefined;
+        if (target.kind !== 'remove' &&
+            (schema === undefined || schema === false))
+            throw new Error(`Native parameter edit target ${target.pointer} is not permitted by the registered schema`);
+        const fields = { ...target, id: `parameter-${index + 1}` };
+        return target.kind !== 'set'
+            ? { ...fields, kind: target.kind }
+            : { ...fields, kind: 'set', schema: schema };
+    });
+    const fields = {
+        fingerprint: context.fingerprint,
+        stepId: input.stepId,
+        nodeId: context.node.id,
+        schemaResource: resources.root,
+        targets,
+    };
+    return {
+        status: 'ready',
+        contract: {
+            id: 'native-parameter-edit:' +
+                createHash('sha256').update(JSON.stringify(fields)).digest('hex'),
+            ...fields,
+        },
+    };
+}

package/dist/draft/edits/native/resolve-workflow-draft-native-parameter-edits.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveWorkflowDraftNativeParameterEditsInput, WorkflowDraftNativeParameterEditResult } from '../../../types/workflow-draft-native-parameter-edit.js';
+/** A parameter-stage result is not graph readiness: connections/consumer changes remain explicit. */
+export declare function resolveWorkflowDraftNativeParameterEdits(input: ResolveWorkflowDraftNativeParameterEditsInput): WorkflowDraftNativeParameterEditResult;

package/dist/draft/edits/native/resolve-workflow-draft-native-parameter-edits.js

@@ -0,0 +1,92 @@
+import { createHash } from 'node:crypto';
+import { createWorkflowDraftNativeParameterEditValuesSchema } from '../../../schemas/create-workflow-draft-native-parameter-edit-values-schema.js';
+import { describeWorkflowDraftNativeParameterEdit } from './describe-workflow-draft-native-parameter-edit.js';
+import { validateWorkflowPlanningEvidence } from '../../../planning/evidence/validate-workflow-planning-evidence.js';
+import { applyWorkflowDraftNativeParameterChanges } from './apply-workflow-draft-native-parameter-changes.js';
+import { orderWorkflowDraftValueEdits } from '../values/order-workflow-draft-value-edits.js';
+import { resolveNativeStructureParameters } from '../../../workflow/resolve-native-structure-parameters.js';
+import { validateWorkflowDraftNativeReferences } from '../references/validate-workflow-draft-native-references.js';
+import { bindNativeMaterialContracts } from '../../../workflow/bind-native-material-contracts.js';
+import { nativeMaterialSourcesFromDraftReferences } from '../references/native-material-sources-from-draft-references.js';
+/** A parameter-stage result is not graph readiness: connections/consumer changes remain explicit. */
+export function resolveWorkflowDraftNativeParameterEdits(input) {
+    const output = createWorkflowDraftNativeParameterEditValuesSchema(input).parse(input.output);
+    const context = describeWorkflowDraftNativeParameterEdit(input);
+    const edits = [];
+    const questions = [];
+    for (const target of input.contract.targets) {
+        if (target.kind !== 'set') {
+            edits.push({ kind: target.kind, pointer: target.pointer });
+            continue;
+        }
+        const answer = output.values[target.id];
+        validateWorkflowPlanningEvidence({
+            context: { messages: context.messages },
+            evidence: answer.sources,
+        });
+        if (answer.explanation)
+            validateWorkflowPlanningEvidence({
+                context: { messages: context.messages },
+                evidence: answer.explanation.evidence,
+            });
+        if (answer.status === 'needs-input') {
+            questions.push({
+                id: 'native-parameter-question:' +
+                    createHash('sha256')
+                        .update(JSON.stringify([input.contract.id, target.id, answer]))
+                        .digest('hex'),
+                nodeId: context.node.id,
+                targetId: target.id,
+                pointer: target.pointer,
+                message: answer.message,
+                sources: answer.sources,
+                ...(answer.explanation === undefined
+                    ? {}
+                    : { explanation: answer.explanation }),
+            });
+        }
+        else
+            edits.push({ kind: 'set', pointer: target.pointer, value: answer.value });
+    }
+    if (questions.length)
+        return {
+            status: 'needs-input',
+            contractId: input.contract.id,
+            values: output,
+            questions,
+        };
+    const ordered = [
+        ...orderWorkflowDraftValueEdits(edits.filter((edit) => edit.kind !== 'defer')),
+        ...edits.filter((edit) => edit.kind === 'defer'),
+    ];
+    const definition = input.context.capabilities.find((capability) => capability.name === context.node.capability);
+    const capability = bindNativeMaterialContracts(definition, nativeMaterialSourcesFromDraftReferences({
+        values: context.sourceCandidates,
+        exclusiveOutputs: context.exclusiveOutputSources,
+    }));
+    const node = applyWorkflowDraftNativeParameterChanges({
+        node: context.node,
+        capability,
+        edits: ordered,
+        source: `Native parameter edit ${context.node.id}`,
+    });
+    resolveNativeStructureParameters(node, capability);
+    validateWorkflowDraftNativeReferences({
+        node,
+        capability,
+        sources: {
+            values: context.sourceCandidates,
+            exclusiveOutputs: context.exclusiveOutputSources,
+        },
+    });
+    return {
+        status: 'ready',
+        contractId: input.contract.id,
+        values: output,
+        resolution: {
+            stepId: input.stepId,
+            kind: 'native-parameters',
+            edits: ordered,
+        },
+    };
+}

package/dist/draft/edits/native/validate-workflow-draft-native-parameter-edit-contract.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowDraftNativeParameterEditContractInput } from '../../../types/workflow-draft-native-parameter-edit.js';
+export declare function validateWorkflowDraftNativeParameterEditContract(input: WorkflowDraftNativeParameterEditContractInput): void;

package/dist/draft/edits/native/validate-workflow-draft-native-parameter-edit-contract.js

@@ -0,0 +1,24 @@
+import { isDeepStrictEqual } from 'node:util';
+import { workflowDraftNativeParameterEditContractSchema } from '../../../schemas/workflow-draft-native-parameter-edit-schema.js';
+import { resolveWorkflowDraftNativeParameterEditTargets } from './resolve-workflow-draft-native-parameter-edit-targets.js';
+export function validateWorkflowDraftNativeParameterEditContract(input) {
+    workflowDraftNativeParameterEditContractSchema.parse(input.contract);
+    const expected = resolveWorkflowDraftNativeParameterEditTargets({
+        ...input,
+        fingerprint: input.contract.fingerprint,
+        proposal: {
+            decision: {
+                status: 'targets',
+                targets: input.contract.targets.map(({ kind, pointer, sources, explanation }) => ({
+                    kind,
+                    pointer,
+                    sources,
+                    ...(explanation === undefined ? {} : { explanation }),
+                })),
+            },
+        },
+    });
+    if (expected.status !== 'ready' ||
+        !isDeepStrictEqual(expected.contract, input.contract))
+        throw new Error('Native parameter edit contract is stale or has modified identities, fields or schemas');
+}

package/dist/draft/edits/prepare-workflow-draft-edit.d.ts

@@ -0,0 +1,3 @@
+import type { PrepareWorkflowDraftEditInput, PreparedWorkflowDraftEdit } from '../../types/workflow-draft-edit-assembly.js';
+/** Planning materials are deliberately not a validated canonical draft or executable workflow. */
+export declare function prepareWorkflowDraftEdit(input: PrepareWorkflowDraftEditInput): PreparedWorkflowDraftEdit;

package/dist/draft/edits/prepare-workflow-draft-edit.js

@@ -0,0 +1,15 @@
+import { resolvePreparedWorkflowDraftEdit } from './assembly/resolve-prepared-workflow-draft-edit.js';
+/** Planning materials are deliberately not a validated canonical draft or executable workflow. */
+export function prepareWorkflowDraftEdit(input) {
+    const prepared = resolvePreparedWorkflowDraftEdit(input, 'complete');
+    return {
+        kind: prepared.kind,
+        planId: prepared.planId,
+        baseRevision: prepared.baseRevision,
+        content: prepared.content,
+        nodeRemovalConnections: prepared.nodeRemovalConnections,
+        pendingRepairs: prepared.pendingRepairs,
+        deferredRequirementIds: prepared.deferredRequirementIds,
+        pendingClarificationQuestionIds: prepared.pendingClarificationQuestionIds,
+    };
+}

package/dist/draft/edits/references/describe-workflow-draft-reference-sources.d.ts

@@ -0,0 +1,3 @@
+import type { DescribeWorkflowDraftReferenceSourcesInput, WorkflowDraftReferenceSources } from '../../../types/workflow-draft-reference-sources.js';
+/** Actual declarations only. A native awaiting consumer repair has no confirmed new output. */
+export declare function describeWorkflowDraftReferenceSources(input: DescribeWorkflowDraftReferenceSourcesInput): WorkflowDraftReferenceSources;

package/dist/draft/edits/references/describe-workflow-draft-reference-sources.js

@@ -0,0 +1,58 @@
+import { resolveNativeMaterialSnapshot } from '../../../workflow/resolve-native-material-snapshot.js';
+import { createWorkflowNodeContracts } from '../../../workflow/create-workflow-node-contracts.js';
+import { listApiResponsePointers } from '../../../openapi/response/list-api-response-pointers.js';
+/** Actual declarations only. A native awaiting consumer repair has no confirmed new output. */
+export function describeWorkflowDraftReferenceSources(input) {
+    const unavailable = new Set([
+        ...input.excludedNodeIds,
+        ...input.stage.blockedSourceNodeIds,
+        ...input.stage.pendingRepairs
+            .filter((task) => task.kind === 'native-parameters')
+            .map((task) => task.nodeId),
+    ]);
+    const apis = input.stage.apiResponseSources
+        .filter((source) => !input.excludedNodeIds.includes(source.nodeId) &&
+        !input.stage.content.requirements.some((requirement) => requirement.state !== 'confirmed' &&
+            (requirement.scope.kind === 'workflow' ||
+                requirement.scope.nodeIds.includes(source.nodeId))))
+        .map((source) => ({
+        ...structuredClone(source),
+        kind: 'api',
+        responsePointerCatalog: listApiResponsePointers(source.operation),
+    }));
+    const snapshot = resolveNativeMaterialSnapshot({
+        apiMaterials: apis.map((source) => ({
+            callId: source.nodeId,
+            operation: source.operation,
+        })),
+        nativeOutputs: [],
+        nativeNodes: input.stage.content.nativeNodes,
+        capabilities: input.context.capabilities,
+        deferredNodeIds: input.stage.content.nativeNodes
+            .filter((node) => unavailable.has(node.id))
+            .map((node) => node.id),
+    });
+    const natives = input.stage.content.nativeNodes.filter((node) => snapshot.bindings.some((binding) => binding.nodeId === node.id));
+    const outputs = snapshot.outputs.map((output) => ({
+        kind: 'native',
+        nodeId: output.nodeId,
+        schema: structuredClone(output.schema),
+        node: structuredClone(natives.find((node) => node.id === output.nodeId)),
+    }));
+    const contracts = snapshot.bindings.flatMap((binding) => createWorkflowNodeContracts({
+        materials: [],
+        nativeNodes: [natives.find((node) => node.id === binding.nodeId)],
+        capabilities: [binding.capability],
+    }));
+    return {
+        values: [...apis, ...outputs],
+        exclusiveOutputs: contracts
+            .filter((contract) => contract.exclusiveOutputPorts)
+            .map((contract) => ({
+            kind: 'exclusive-output',
+            nodeId: contract.id,
+            node: structuredClone(natives.find((node) => node.id === contract.id)),
+            outputPorts: [...contract.outputs],
+        })),
+    };
+}

package/dist/draft/edits/references/native-material-sources-from-draft-references.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftReferenceSources } from '../../../types/workflow-draft-reference-sources.js';
+import type { WorkflowNativeMaterialSources } from '../../../types/native-material-snapshot.js';
+export declare function nativeMaterialSourcesFromDraftReferences(sources: WorkflowDraftReferenceSources): WorkflowNativeMaterialSources;

package/dist/draft/edits/references/native-material-sources-from-draft-references.js

@@ -0,0 +1,15 @@
+export function nativeMaterialSourcesFromDraftReferences(sources) {
+    return {
+        apiMaterials: sources.values.flatMap((source) => source.kind === 'api'
+            ? [
+                {
+                    callId: source.nodeId,
+                    operation: source.operation,
+                },
+            ]
+            : []),
+        nativeOutputs: sources.values.flatMap((source) => source.kind === 'native'
+            ? [{ nodeId: source.nodeId, schema: source.schema }]
+            : []),
+    };
+}

package/dist/draft/edits/references/resolve-workflow-draft-api-response-sources.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveWorkflowDraftApiResponseSourcesInput, WorkflowDraftApiResponseSource } from '../../../types/workflow-draft-api-response-sources.js';
+/** Selection establishes response declarations; only an explicit resolution establishes request data. */
+export declare function resolveWorkflowDraftApiResponseSources(input: ResolveWorkflowDraftApiResponseSourcesInput): WorkflowDraftApiResponseSource[];