@openapi-flow/core 0.1.0 → 0.3.0

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[];

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

@@ -0,0 +1,42 @@
+import { apiOperationKeyEquals } from '../../../openapi/catalog/api-operation-key-equals.js';
+import { resolveWorkflowDraftApiMaterials } from '../../resolve-workflow-draft-api-materials.js';
+/** Selection establishes response declarations; only an explicit resolution establishes request data. */
+export function resolveWorkflowDraftApiResponseSources(input) {
+    const sources = new Map();
+    for (const material of resolveWorkflowDraftApiMaterials(input)) {
+        const request = input.content.apiCalls.find((call) => call.id === material.callId);
+        sources.set(material.callId, {
+            nodeId: material.callId,
+            operation: structuredClone(material.operation),
+            preparation: {
+                status: 'request-planned',
+                request: structuredClone(request),
+            },
+        });
+    }
+    for (const step of input.plan.steps) {
+        if (!input.pendingResolutionStepIds.includes(step.id))
+            continue;
+        const decision = step.decision;
+        if (decision.kind !== 'add-api-call' &&
+            decision.kind !== 'replace-api-operation')
+            continue;
+        const nodeId = decision.kind === 'add-api-call' ? step.newNodeId : decision.nodeId;
+        if (typeof nodeId !== 'string' || !nodeId.trim())
+            throw new Error(`Selected API response source ${step.id} requires its actual instance identity`);
+        const matches = input.context.operations.filter((operation) => apiOperationKeyEquals(operation.key, decision.operation));
+        if (matches.length !== 1)
+            throw new Error(`Selected API response source ${nodeId} requires exactly one original OAS contract and snapshot`);
+        sources.set(nodeId, {
+            nodeId,
+            operation: structuredClone(matches[0]),
+            preparation: {
+                status: 'request-pending',
+                stepId: step.id,
+                kind: decision.kind,
+                instruction: decision.instruction,
+            },
+        });
+    }
+    return [...sources.values()];
+}

package/dist/draft/edits/references/resolve-workflow-draft-source-evidence.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveWorkflowDraftSourceEvidenceInput, ResolvedWorkflowDraftSourceEvidence } from '../../../types/workflow-draft-source-evidence.js';
+/** No quote/pointer repair: canonical evidence is constructed from explicitly selected actual IDs. */
+export declare function resolveWorkflowDraftSourceEvidence(input: ResolveWorkflowDraftSourceEvidenceInput): ResolvedWorkflowDraftSourceEvidence;

package/dist/draft/edits/references/resolve-workflow-draft-source-evidence.js

@@ -0,0 +1,56 @@
+import { validateWorkflowPlanningEvidence } from '../../../planning/evidence/validate-workflow-planning-evidence.js';
+/** No quote/pointer repair: canonical evidence is constructed from explicitly selected actual IDs. */
+export function resolveWorkflowDraftSourceEvidence(input) {
+    const { decision, description } = input;
+    const messageEvidence = (id) => {
+        const message = description.messages.find((message) => message.id === id);
+        if (!message)
+            throw new Error(`Draft source evidence cites unavailable current message ${id}`);
+        return { kind: 'message', messageId: message.id, quote: message.text };
+    };
+    const sources = decision.sourceMessageIds.map(messageEvidence);
+    const explanation = decision.explanation === undefined
+        ? undefined
+        : {
+            reason: decision.explanation.reason,
+            evidence: decision.explanation.evidence.map((item) => {
+                if (item.kind === 'message')
+                    return messageEvidence(item.messageId);
+                const source = [
+                    ...description.sources.values,
+                    ...description.sources.exclusiveOutputs,
+                ].find((source) => source.nodeId === item.nodeId);
+                if (!source)
+                    throw new Error(`Draft source evidence cites unavailable source contract ${item.nodeId}`);
+                return source.kind === 'api'
+                    ? {
+                        kind: 'oas',
+                        operation: structuredClone(source.operation.key),
+                        pointer: '',
+                    }
+                    : { kind: 'native', capability: source.node.capability };
+            }),
+        };
+    // Multiple actual instances may cite one original contract; canonical contract facts are unique.
+    if (explanation)
+        explanation.evidence = [
+            ...new Map(explanation.evidence.map((item) => [JSON.stringify(item), item])).values(),
+        ];
+    const operations = [
+        ...new Map(description.sources.values.flatMap((source) => source.kind === 'api'
+            ? [[JSON.stringify(source.operation.key), source.operation]]
+            : [])).values(),
+    ];
+    const context = {
+        messages: description.messages,
+        operations,
+        capabilities: input.capabilities,
+    };
+    validateWorkflowPlanningEvidence({ context, evidence: sources });
+    if (explanation)
+        validateWorkflowPlanningEvidence({
+            context,
+            evidence: explanation.evidence,
+        });
+    return { sources, ...(explanation === undefined ? {} : { explanation }) };
+}

package/dist/draft/edits/references/validate-workflow-draft-native-reference.d.ts

@@ -0,0 +1,2 @@
+import type { ValidateWorkflowDraftNativeReferenceInput } from '../../../types/native-reference-validation.js';
+export declare function validateWorkflowDraftNativeReference(input: ValidateWorkflowDraftNativeReferenceInput): void;

package/dist/draft/edits/references/validate-workflow-draft-native-reference.js

@@ -0,0 +1,22 @@
+import { createResponseValueSchema } from '../../../openapi/response/create-response-value-schema.js';
+import { schemasAtPointer } from '../../../bindings/schema-at-pointer.js';
+import { createSchemaResourceContext } from '../../../bindings/resources/create-schema-resource-context.js';
+export function validateWorkflowDraftNativeReference(input) {
+    const { reference, sources } = input;
+    if (reference.source === 'exclusive-output') {
+        if (!sources.exclusiveOutputs.some((source) => source.nodeId === reference.nodeId))
+            throw new Error(`Native control reference ${reference.nodeId} is not an available exclusive-output source`);
+        return;
+    }
+    const source = sources.values.find((source) => source.nodeId === reference.nodeId);
+    if (!source ||
+        source.kind !== (reference.source === 'response' ? 'api' : 'native'))
+        throw new Error(`Native parameter reference ${reference.nodeId} is not an available ${reference.source} source`);
+    if (source.kind === 'api')
+        createResponseValueSchema(source.operation, reference.pointer);
+    else {
+        const resources = createSchemaResourceContext(source.schema);
+        if (!schemasAtPointer(resources.root, reference.pointer, resources).length)
+            throw new Error(`Native parameter reference ${reference.nodeId}${reference.pointer} is not declared by its native output`);
+    }
+}

package/dist/draft/edits/references/validate-workflow-draft-native-references.d.ts

@@ -0,0 +1,2 @@
+import type { ValidateWorkflowDraftNativeReferencesInput } from '../../../types/native-reference-validation.js';
+export declare function validateWorkflowDraftNativeReferences(input: ValidateWorkflowDraftNativeReferencesInput): void;

package/dist/draft/edits/references/validate-workflow-draft-native-references.js

@@ -0,0 +1,31 @@
+import { createWorkflowNodeContracts } from '../../../workflow/create-workflow-node-contracts.js';
+import { createNativeOutputContracts } from '../../../workflow/create-native-output-contracts.js';
+import { validateWorkflowDraftNativeReference } from './validate-workflow-draft-native-reference.js';
+import { nativeMaterialSourcesFromDraftReferences } from './native-material-sources-from-draft-references.js';
+import { validateNativeMaterialSources } from '../../../workflow/validate-native-material-sources.js';
+export function validateWorkflowDraftNativeReferences(input) {
+    const [contract] = createWorkflowNodeContracts({
+        materials: [],
+        nativeNodes: [input.node],
+        capabilities: [input.capability],
+    });
+    createNativeOutputContracts({
+        nativeNodes: [input.node],
+        capabilities: [input.capability],
+    });
+    const references = [
+        ...contract.references,
+        ...Object.values(contract.inputReferences === undefined ? {} : contract.inputReferences).flat(),
+    ];
+    validateNativeMaterialSources(input.capability, references, nativeMaterialSourcesFromDraftReferences(input.sources));
+    for (const reference of references)
+        validateWorkflowDraftNativeReference({ reference, sources: input.sources });
+    if (contract.rejoinsExclusiveOutputs !== undefined)
+        validateWorkflowDraftNativeReference({
+            reference: {
+                source: 'exclusive-output',
+                nodeId: contract.rejoinsExclusiveOutputs,
+            },
+            sources: input.sources,
+        });
+}

package/dist/draft/edits/resolve-workflow-draft-edit-options.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowDraftEditOptions, ResolvedWorkflowDraftEditOptions } from '../../types/workflow-draft-edit.js';
+export declare function resolveWorkflowDraftEditOptions(input?: WorkflowDraftEditOptions): ResolvedWorkflowDraftEditOptions;

package/dist/draft/edits/resolve-workflow-draft-edit-options.js

@@ -0,0 +1,9 @@
+import { workflowDraftEditOptionsSchema } from '../../schemas/workflow-draft-edit-options-schema.js';
+export function resolveWorkflowDraftEditOptions(input) {
+    const configured = workflowDraftEditOptionsSchema.parse(input === undefined ? {} : input);
+    return {
+        includeExplanations: configured.includeExplanations === undefined
+            ? true
+            : configured.includeExplanations,
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { PrepareWorkflowDraftEditInput, StagedWorkflowDraftEdit } from '../../types/workflow-draft-edit-assembly.js';
+/** Re-derive completed materials, named missing results and unavailable output sources. */
+export declare function stageWorkflowDraftEdit(input: PrepareWorkflowDraftEditInput): StagedWorkflowDraftEdit;

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

@@ -0,0 +1,63 @@
+import { createHash } from 'node:crypto';
+import { resolvePreparedWorkflowDraftEdit } from './assembly/resolve-prepared-workflow-draft-edit.js';
+import { resolveWorkflowDraftApiResponseSources } from './references/resolve-workflow-draft-api-response-sources.js';
+import { describeWorkflowDraftClarificationOwnership } from './clarification/describe-workflow-draft-clarification-ownership.js';
+/** Re-derive completed materials, named missing results and unavailable output sources. */
+export function stageWorkflowDraftEdit(input) {
+    const prepared = resolvePreparedWorkflowDraftEdit(input, 'staged');
+    const apiResponseSources = resolveWorkflowDraftApiResponseSources({
+        ...input,
+        content: prepared.content,
+        pendingResolutionStepIds: prepared.pendingResolutionStepIds,
+    });
+    const blockedContracts = input.plan.steps.flatMap((step) => {
+        if (!prepared.pendingResolutionStepIds.includes(step.id))
+            return [];
+        if (step.decision.kind === 'replace-api-operation' ||
+            step.decision.kind === 'revise-native-node')
+            return [step.decision.nodeId];
+        if (step.decision.kind === 'add-api-call' ||
+            step.decision.kind === 'add-native-node')
+            return [step.newNodeId];
+        return [];
+    });
+    const nodeIds = [
+        ...prepared.content.apiCalls,
+        ...prepared.content.nativeNodes,
+    ].map((node) => node.id);
+    const blockedSourceNodeIds = [
+        ...new Set([
+            ...blockedContracts,
+            ...prepared.content.requirements.flatMap((requirement) => requirement.state === 'confirmed'
+                ? []
+                : requirement.scope.kind === 'workflow'
+                    ? nodeIds
+                    : requirement.scope.nodeIds),
+        ]),
+    ];
+    const state = {
+        planId: prepared.planId,
+        baseRevision: prepared.baseRevision,
+        content: prepared.content,
+        nodeRemovalConnections: prepared.nodeRemovalConnections,
+        pendingResolutionStepIds: prepared.pendingResolutionStepIds,
+        clarificationOwnership: describeWorkflowDraftClarificationOwnership({
+            draft: input.draft,
+            context: input.context,
+            requestMessageIds: input.requestMessageIds,
+            plan: input.plan,
+        }),
+        apiResponseSources,
+        blockedSourceNodeIds,
+        pendingRepairs: prepared.pendingRepairs,
+        deferredRequirementIds: prepared.deferredRequirementIds,
+        pendingClarificationQuestionIds: prepared.pendingClarificationQuestionIds,
+    };
+    return {
+        kind: 'unvalidated-edit-stage',
+        fingerprint: createHash('sha256')
+            .update(JSON.stringify(state))
+            .digest('hex'),
+        ...state,
+    };
+}

package/dist/draft/edits/validate-workflow-draft-edit-plan.d.ts

@@ -0,0 +1,3 @@
+import type { ValidateWorkflowDraftEditPlanInput } from '../../types/workflow-draft-edit.js';
+/** A persisted proposal cannot silently rebase, alter stage ownership or allocate its own IDs. */
+export declare function validateWorkflowDraftEditPlan(input: ValidateWorkflowDraftEditPlanInput): void;

package/dist/draft/edits/validate-workflow-draft-edit-plan.js

@@ -0,0 +1,20 @@
+import { isDeepStrictEqual } from 'node:util';
+import { createWorkflowDraftEditPlan } from './create-workflow-draft-edit-plan.js';
+import { workflowDraftEditPlanSchema } from '../../schemas/workflow-draft-edit-plan-schema.js';
+/** A persisted proposal cannot silently rebase, alter stage ownership or allocate its own IDs. */
+export function validateWorkflowDraftEditPlan(input) {
+    const envelope = workflowDraftEditPlanSchema.safeParse(input.plan);
+    if (!envelope.success)
+        throw new Error('Draft edit plan has invalid metadata or step fields', {
+            cause: envelope.error,
+        });
+    const expected = createWorkflowDraftEditPlan({
+        draft: input.draft,
+        context: input.context,
+        requestMessageIds: input.requestMessageIds,
+        options: input.plan.options,
+        proposal: { decisions: input.plan.steps.map((step) => step.decision) },
+    });
+    if (!isDeepStrictEqual(expected, input.plan))
+        throw new Error('Draft edit plan is stale or has modified identities, context, stages or decisions');
+}

package/dist/draft/edits/values/apply-workflow-draft-api-input-edits.d.ts

@@ -0,0 +1,4 @@
+import type { ApiArgumentValues } from '../../../types/api-arguments.js';
+import type { WorkflowDraftApiInputEditMaterial } from '../../../types/workflow-draft-api-input-edit.js';
+import type { WorkflowDraftValueEdit } from '../../../types/workflow-draft-edit-assembly.js';
+export declare function applyWorkflowDraftApiInputEdits(values: ApiArgumentValues, edits: WorkflowDraftValueEdit[], material: WorkflowDraftApiInputEditMaterial): ApiArgumentValues;