@openapi-flow/core 0.2.0 → 0.3.0

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

@@ -0,0 +1,60 @@
+import { pointerTokens, pointerValue } from '../../../bindings/json-pointer.js';
+import { verifyApiInputLiteralSource } from '../../../arguments/sources/verify-api-input-literal-source.js';
+/** OAS validation and message existence alone do not establish a literal's origin. */
+export function resolveWorkflowDraftApiLiteralSources(input) {
+    const { description, proposal } = input;
+    const sources = [];
+    const messages = [...description.messages, ...description.backgroundMessages];
+    if (proposal.literalSources !== undefined) {
+        for (const selection of proposal.literalSources) {
+            pointerTokens(selection.targetPointer);
+            const label = `API ${description.nodeId} literal ${selection.targetPointer}`;
+            if (sources.some((source) => overlaps(source.targetPointer, selection.targetPointer)))
+                throw new Error(`${label} has duplicate or overlapping literalSources`);
+            const message = messages.find((entry) => entry.id === selection.messageId);
+            if (!message)
+                throw new Error(`${label} cites unavailable user message ${selection.messageId}`);
+            const proposed = pointerValue(proposal.values, selection.targetPointer);
+            if (proposed === undefined)
+                throw new Error(`${label} source targets an absent proposed value`);
+            const parsed = verifyApiInputLiteralSource({
+                ...selection,
+                text: message.text,
+                label,
+                value: proposed,
+            });
+            sources.push({ ...selection, occurrences: parsed.occurrences });
+        }
+    }
+    function check(value, pointer) {
+        if (sources.some((source) => isAncestor(source.targetPointer, pointer)))
+            return;
+        if (value !== null &&
+            typeof value === 'object' &&
+            Object.keys(value).length) {
+            for (const [key, child] of Object.entries(value))
+                check(child, `${pointer}/${key.replaceAll('~', '~0').replaceAll('/', '~1')}`);
+            return;
+        }
+        throw new Error(`API ${description.nodeId} literal ${pointer} requires an exact user source in literalSources`);
+    }
+    for (const [root, value] of Object.entries(proposal.values)) {
+        // Empty parameter-location objects contain no request values. Empty body
+        // objects/arrays are actual data and still require their own source.
+        if (root !== 'body' &&
+            value !== null &&
+            typeof value === 'object' &&
+            !Object.keys(value).length)
+            continue;
+        check(value, `/${root}`);
+    }
+    return sources;
+}
+function isAncestor(ancestor, pointer) {
+    return (ancestor === '' ||
+        pointer === ancestor ||
+        pointer.startsWith(`${ancestor}/`));
+}
+function overlaps(left, right) {
+    return isAncestor(left, right) || isAncestor(right, left);
+}

package/dist/draft/edits/api/validate-workflow-draft-api-call-mappings.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftApiCallBindingsDescription, ProposedWorkflowDraftApiCallMapping } from '../../../types/workflow-draft-api-call-planning.js';
+import type { OutputBinding } from '../../../types/api-arguments.js';
+/** Shared by model mappings, proposed question alternatives and explicit human answers. */
+export declare function validateWorkflowDraftApiCallMappings(description: WorkflowDraftApiCallBindingsDescription, mappings: ProposedWorkflowDraftApiCallMapping[]): OutputBinding[];

package/dist/draft/edits/api/validate-workflow-draft-api-call-mappings.js

@@ -0,0 +1,34 @@
+import { validateApiArguments } from '../../../arguments/validate-api-arguments.js';
+import { validateApiBindingAssignment } from '../../../bindings/validate-api-binding-assignment.js';
+/** Shared by model mappings, proposed question alternatives and explicit human answers. */
+export function validateWorkflowDraftApiCallMappings(description, mappings) {
+    if (description.inputIntent !== undefined)
+        for (const mapping of mappings)
+            if (!description.inputIntent.targets.includes(mapping.targetPointer))
+                throw new Error(`API binding target ${mapping.targetPointer} is outside the selected input intent`);
+    const bindings = mappings.map((mapping) => ({
+        kind: 'node-output',
+        ...mapping,
+    }));
+    const material = {
+        callId: description.nodeId,
+        operation: description.operation,
+        requestMediaType: description.requestMediaType,
+    };
+    validateApiArguments({ ...material, values: {}, bindings });
+    for (const binding of bindings)
+        validateApiBindingAssignment({
+            callId: description.nodeId,
+            binding,
+            materials: [
+                material,
+                ...description.sources.values.flatMap((source) => source.kind === 'api'
+                    ? [{ callId: source.nodeId, operation: source.operation }]
+                    : []),
+            ],
+            nativeOutputs: description.sources.values.flatMap((source) => source.kind === 'native'
+                ? [{ nodeId: source.nodeId, schema: source.schema }]
+                : []),
+        });
+    return bindings;
+}

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

@@ -0,0 +1,3 @@
+import type { AssembleWorkflowDraftEditInput, AssembledWorkflowDraftEdit } from '../../types/workflow-draft-edit-assembly.js';
+/** Return one validated candidate revision; only the host decides whether to adopt it. */
+export declare function assembleWorkflowDraftEdit(input: AssembleWorkflowDraftEditInput): AssembledWorkflowDraftEdit;

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

@@ -0,0 +1,55 @@
+import { workflowDraftEditConnectionChangeSchema } from '../../schemas/workflow-draft-edit-assembly-schema.js';
+import { resolvePreparedWorkflowDraftEdit } from './assembly/resolve-prepared-workflow-draft-edit.js';
+import { applyDraftChangeSet } from '../changes/apply-draft-change-set.js';
+import { WorkflowDraftEditAssemblyError } from './workflow-draft-edit-assembly-error.js';
+import { createWorkflowDraftEditCandidateContext } from '../requirements/create-workflow-draft-edit-candidate-context.js';
+import { validateWorkflowDraftNativeDependencyResolutions } from './native/additions/resolve-workflow-draft-native-dependencies.js';
+/** Return one validated candidate revision; only the host decides whether to adopt it. */
+export function assembleWorkflowDraftEdit(input) {
+    if (input.producerDependencies !== undefined)
+        validateWorkflowDraftNativeDependencyResolutions({
+            ...input,
+            producerDependencies: input.producerDependencies,
+        });
+    const prepared = resolvePreparedWorkflowDraftEdit(input, 'complete');
+    if (prepared.pendingClarificationQuestionIds.length)
+        throw new Error(`Draft edit requires explicit clarification replies before final adoption: ${prepared.pendingClarificationQuestionIds.join(', ')}`);
+    if (prepared.pendingRepairs.length)
+        throw new WorkflowDraftEditAssemblyError({ stage: 'dependency-repairs', pendingRepairs: prepared.pendingRepairs }, new Error(`Draft edit requires explicit dependency repairs: ${prepared.pendingRepairs.map((task) => `${task.id} (${task.nodeId})`).join(', ')}`));
+    const connections = workflowDraftEditConnectionChangeSchema
+        .array()
+        .optional()
+        .parse(input.connections);
+    const changes = [...prepared.changes];
+    for (const connection of connections === undefined ? [] : connections) {
+        if (connection.stepIds.some((id) => !input.plan.steps.some((step) => step.id === id && step.stages.includes('connections'))))
+            throw new Error('Draft connection change requires known connection-planning stepIds');
+        changes.push({ kind: connection.kind, edge: connection.edge });
+    }
+    if (input.plan.status === 'no-change') {
+        if (changes.length)
+            throw new Error('A no-change edit cannot modify draft content');
+        return { status: 'no-change', draft: structuredClone(input.draft) };
+    }
+    if (changes.length === 0)
+        return { status: 'no-change', draft: structuredClone(input.draft) };
+    const changeSet = { baseRevision: input.plan.baseRevision, changes };
+    try {
+        const result = applyDraftChangeSet({
+            draft: input.draft,
+            context: createWorkflowDraftEditCandidateContext(input),
+            changeSet,
+        });
+        return {
+            status: 'changed',
+            ...result,
+            changeSet,
+            deferredRequirementIds: prepared.deferredRequirementIds,
+        };
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftEditAssemblyError({ stage: 'final-validation', changeSet }, cause);
+    }
+}

package/dist/draft/edits/assembly/inspect-workflow-draft-edit-repairs.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftEditRepairTask } from '../../../types/workflow-draft-edit-assembly.js';
+import type { InspectWorkflowDraftEditRepairsInput } from '../../../types/workflow-draft-edit-assembly-internal.js';
+/** Discover consumer decisions before binding their output, then cascade only actually resolved new contracts. */
+export declare function inspectWorkflowDraftEditRepairs(input: InspectWorkflowDraftEditRepairsInput): WorkflowDraftEditRepairTask[];

package/dist/draft/edits/assembly/inspect-workflow-draft-edit-repairs.js

@@ -0,0 +1,188 @@
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { resolveWorkflowDraftApiMaterials } from '../../resolve-workflow-draft-api-materials.js';
+import { resolveWorkflowDraftNativeSnapshot } from '../../resolve-workflow-draft-native-snapshot.js';
+import { createWorkflowNodeContracts } from '../../../workflow/create-workflow-node-contracts.js';
+import { createNativeStructureContracts } from '../../../workflow/create-native-structure-contracts.js';
+import { NativeMaterialResolutionError } from '../../../workflow/native-material-resolution-error.js';
+import { apiOperationKeyEquals } from '../../../openapi/catalog/api-operation-key-equals.js';
+import { validateApiArguments } from '../../../arguments/validate-api-arguments.js';
+import { describeNativeReferenceBindings } from '../../../workflow/describe-native-reference-bindings.js';
+import { collectNativeReferenceRepairPointers } from '../native/repairs/collect-native-reference-repair-pointers.js';
+import { resolveWorkflowDraftApiResponseSources } from '../references/resolve-workflow-draft-api-response-sources.js';
+import { resolveNativeMaterialSnapshot } from '../../../workflow/resolve-native-material-snapshot.js';
+/** Discover consumer decisions before binding their output, then cascade only actually resolved new contracts. */
+export function inspectWorkflowDraftEditRepairs(input) {
+    const oldMaterials = resolveWorkflowDraftApiMaterials({
+        content: input.before,
+        context: input.context,
+    });
+    const newMaterials = resolveWorkflowDraftApiMaterials({
+        content: input.content,
+        context: input.context,
+    });
+    const responseSources = resolveWorkflowDraftApiResponseSources(input);
+    const oldSnapshot = resolveWorkflowDraftNativeSnapshot({
+        content: input.before,
+        context: input.context,
+        deferredNodeIds: [],
+        unavailableApiNodeIds: [],
+    });
+    if (oldSnapshot.status !== 'ready')
+        throw new NativeMaterialResolutionError(oldSnapshot.pending);
+    const oldCapabilities = oldSnapshot.capabilities;
+    const oldContracts = createWorkflowNodeContracts({
+        materials: oldMaterials.map((material) => ({
+            operation: material.operation,
+            arguments: {
+                ...material,
+                unresolvedInputs: validateApiArguments(material).missingInputs,
+            },
+        })),
+        nativeNodes: input.before.nativeNodes,
+        capabilities: oldCapabilities,
+    });
+    const newContracts = createNativeStructureContracts({
+        materials: newMaterials.map((material) => ({
+            operation: material.operation,
+            arguments: {
+                ...material,
+                unresolvedInputs: validateApiArguments(material).missingInputs,
+            },
+        })),
+        nativeNodes: input.content.nativeNodes,
+        capabilities: input.context.capabilities,
+    });
+    const sourceChanges = new Map();
+    const controlChanges = new Map();
+    for (const before of oldContracts) {
+        const after = newContracts.find((contract) => contract.id === before.id);
+        const oldCall = input.before.apiCalls.find((call) => call.id === before.id);
+        const selectedSource = responseSources.find((source) => source.nodeId === before.id);
+        if (!after ||
+            before.exclusiveOutputPorts !== after.exclusiveOutputPorts ||
+            (before.exclusiveOutputPorts &&
+                !isDeepStrictEqual(before.outputs, after.outputs)))
+            controlChanges.set(before.id, JSON.stringify([after?.exclusiveOutputPorts, after?.outputs]));
+        if (!after ||
+            (oldCall &&
+                (!selectedSource ||
+                    !apiOperationKeyEquals(oldCall.operation, selectedSource.operation.key))))
+            sourceChanges.set(before.id, JSON.stringify([
+                selectedSource?.operation.key,
+                undefined,
+                after?.outputs,
+            ]));
+    }
+    const updateNativeChanges = (outputs, resolvedNodeIds) => {
+        for (const nodeId of resolvedNodeIds) {
+            const before = oldContracts.find((contract) => contract.id === nodeId);
+            if (!before)
+                continue;
+            const oldOutput = oldSnapshot.outputs.find((output) => output.nodeId === nodeId);
+            const newOutput = outputs.find((output) => output.nodeId === nodeId);
+            if (!isDeepStrictEqual(oldOutput, newOutput))
+                sourceChanges.set(nodeId, JSON.stringify([
+                    undefined,
+                    newOutput,
+                    newContracts.find((contract) => contract.id === nodeId)?.outputs,
+                ]));
+        }
+    };
+    function taskFor(contract) {
+        if (!newContracts.some((node) => node.id === contract.id))
+            return undefined;
+        const ownDecisions = input.plan.steps
+            .filter((step) => 'nodeId' in step.decision && step.decision.nodeId === contract.id)
+            .map((step) => step.decision.kind);
+        const api = input.before.apiCalls.find((call) => call.id === contract.id);
+        // A primary result for this same contract already supplies its own mapping/settings.
+        if (api
+            ? ownDecisions.some((kind) => kind === 'replace-api-operation' ||
+                kind === 'revise-api-bindings')
+            : ownDecisions.includes('revise-native-node'))
+            return undefined;
+        const references = [
+            ...contract.references,
+            ...Object.values(contract.inputReferences === undefined ? {} : contract.inputReferences).flat(),
+        ];
+        const sourceNodeIds = [
+            ...new Set([
+                ...references
+                    .map((reference) => reference.nodeId)
+                    .filter((id) => sourceChanges.has(id)),
+                ...(contract.rejoinsExclusiveOutputs !== undefined &&
+                    controlChanges.has(contract.rejoinsExclusiveOutputs)
+                    ? [contract.rejoinsExclusiveOutputs]
+                    : []),
+            ]),
+        ].sort();
+        if (!sourceNodeIds.length)
+            return undefined;
+        const native = input.before.nativeNodes.find((node) => node.id === contract.id);
+        const capability = native === undefined
+            ? undefined
+            : oldCapabilities.find((capability) => capability.name === native.capability);
+        const bindings = native && capability?.parameterReferenceBindings
+            ? describeNativeReferenceBindings({ node: native, capability })
+            : [];
+        const targetPointers = api
+            ? api.bindings
+                .filter((binding) => sourceNodeIds.includes(binding.sourceNodeId))
+                .map((binding) => binding.targetPointer)
+                .sort()
+            : collectNativeReferenceRepairPointers(bindings, new Set(sourceChanges.keys()), new Set(controlChanges.keys()));
+        const kind = api
+            ? 'api-bindings'
+            : 'native-parameters';
+        const id = 'draft-repair:' +
+            createHash('sha256')
+                .update(JSON.stringify([
+                input.plan.id,
+                contract.id,
+                kind,
+                sourceNodeIds.map((id) => [
+                    id,
+                    sourceChanges.get(id),
+                    controlChanges.get(id),
+                ]),
+                targetPointers,
+            ]))
+                .digest('hex');
+        return input.acknowledgedTaskIds.has(id)
+            ? undefined
+            : { id, nodeId: contract.id, kind, sourceNodeIds, targetPointers };
+    }
+    const deferredNodeIds = input.plan.steps.flatMap((step) => input.pendingResolutionStepIds.includes(step.id) &&
+        step.decision.kind === 'revise-native-node'
+        ? [step.decision.nodeId]
+        : []);
+    const nativeTasks = new Map();
+    const snapshot = resolveNativeMaterialSnapshot({
+        apiMaterials: responseSources.map((source) => ({
+            callId: source.nodeId,
+            operation: source.operation,
+        })),
+        nativeOutputs: [],
+        nativeNodes: input.content.nativeNodes,
+        capabilities: input.context.capabilities,
+        deferredNodeIds,
+        shouldDeferNode: (nodeId, outputs, resolvedNodeIds) => {
+            updateNativeChanges(outputs, resolvedNodeIds);
+            const original = oldContracts.find((contract) => contract.id === nodeId);
+            const task = original === undefined ? undefined : taskFor(original);
+            if (!task)
+                return false;
+            nativeTasks.set(task.id, task);
+            return true;
+        },
+    });
+    updateNativeChanges(snapshot.outputs, snapshot.bindings.map((binding) => binding.nodeId));
+    const tasks = new Map(nativeTasks);
+    for (const contract of oldContracts) {
+        const task = taskFor(contract);
+        if (task)
+            tasks.set(task.id, task);
+    }
+    return [...tasks.values()];
+}

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

@@ -0,0 +1,4 @@
+import type { PrepareWorkflowDraftEditInput } from '../../../types/workflow-draft-edit-assembly.js';
+import type { PrimaryWorkflowDraftEdit, WorkflowDraftEditPreparationMode } from '../../../types/workflow-draft-edit-assembly-internal.js';
+/** Primary data only; retained edges/references may still need explicitly supplied repairs. */
+export declare function preparePrimaryWorkflowDraftEdit(input: PrepareWorkflowDraftEditInput, mode: WorkflowDraftEditPreparationMode): PrimaryWorkflowDraftEdit;

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

@@ -0,0 +1,288 @@
+import { createHash } from 'node:crypto';
+import { retainRequestedApiInputsAfterEdits } from '../inputs/retain-requested-api-inputs-after-edits.js';
+import { workflowDraftEditResolutionSchema } from '../../../schemas/workflow-draft-edit-assembly-schema.js';
+import { workflowDraftApiCallSchema } from '../../../schemas/workflow-draft-schema.js';
+import { validateWorkflowDraftEditPlan } from '../validate-workflow-draft-edit-plan.js';
+import { applyDraftChange } from '../../changes/apply-draft-change.js';
+import { resolveWorkflowDraftApiMaterials } from '../../resolve-workflow-draft-api-materials.js';
+import { applyWorkflowDraftApiInputEdits } from '../values/apply-workflow-draft-api-input-edits.js';
+import { applyWorkflowDraftBindingEdits } from '../values/apply-workflow-draft-binding-edits.js';
+import { applyWorkflowDraftNativeParameterChanges } from '../native/apply-workflow-draft-native-parameter-changes.js';
+import { projectWorkflowDraftClarificationRequirements } from '../../requirements/project-workflow-draft-clarification-requirements.js';
+import { createWorkflowDraftEditCandidateContext } from '../../requirements/create-workflow-draft-edit-candidate-context.js';
+import { listRemovedWorkflowDraftRequirements } from '../../requirements/history/list-removed-workflow-draft-requirements.js';
+import { createWorkflowDraftCapabilityGap } from '../../gaps/create-workflow-draft-capability-gap.js';
+import { deriveWorkflowDraftNodeRemovalConnections } from '../connections/derive-workflow-draft-node-removal-connections.js';
+/** Primary data only; retained edges/references may still need explicitly supplied repairs. */
+export function preparePrimaryWorkflowDraftEdit(input, mode) {
+    validateWorkflowDraftEditPlan(input);
+    createWorkflowDraftEditCandidateContext(input);
+    const resolutions = workflowDraftEditResolutionSchema
+        .array()
+        .parse(input.resolutions);
+    const byStep = new Map();
+    for (const resolution of resolutions) {
+        if (!input.plan.steps.some((step) => step.id === resolution.stepId) ||
+            byStep.has(resolution.stepId))
+            throw new Error(`Draft edit resolutions require distinct known stepId: ${resolution.stepId}`);
+        byStep.set(resolution.stepId, resolution);
+    }
+    const content = structuredClone({
+        id: input.draft.id,
+        apiCalls: input.draft.apiCalls,
+        nativeNodes: input.draft.nativeNodes,
+        ...(input.draft.gapNodes === undefined
+            ? {}
+            : { gapNodes: input.draft.gapNodes }),
+        requirements: input.draft.requirements,
+        edges: input.draft.edges,
+    });
+    const changes = [];
+    const deferredRequirementIds = [];
+    const pendingResolutionStepIds = [];
+    function add(change) {
+        applyDraftChange(content, change);
+        changes.push(change);
+    }
+    function requireResolution(stepId) {
+        const resolution = byStep.get(stepId);
+        if (!resolution)
+            throw new Error(`Missing draft edit resolution for ${stepId}`);
+        byStep.delete(stepId);
+        return resolution;
+    }
+    const nodeRemovalConnections = deriveWorkflowDraftNodeRemovalConnections(input);
+    for (const connection of nodeRemovalConnections)
+        add({ kind: connection.kind, edge: connection.edge });
+    for (const requirement of projectWorkflowDraftClarificationRequirements(input)) {
+        if (content.requirements.some((existing) => existing.id === requirement.id))
+            throw new Error(`Clarification requirement ${requirement.id} already exists; use an explicit requirements revision`);
+        add({ kind: 'set-requirement', requirement });
+        if (requirement.state !== 'confirmed')
+            deferredRequirementIds.push(requirement.id);
+    }
+    // Node replacement establishes the actual contract before any partial edits.
+    const replacements = input.plan.steps.filter((step) => ['add-api-call', 'replace-api-operation', 'add-native-node'].includes(step.decision.kind));
+    const details = input.plan.steps.filter((step) => !replacements.includes(step));
+    for (const step of [...replacements, ...details]) {
+        const decision = step.decision;
+        if (decision.kind === 'report-capability-gap') {
+            if (step.newNodeId === undefined)
+                throw new Error(`Capability gap ${step.id} requires its allocated node identity`);
+            add({
+                kind: 'add-capability-gap',
+                node: createWorkflowDraftCapabilityGap({
+                    id: step.newNodeId,
+                    requestedBehavior: decision.instruction,
+                    finding: decision.finding,
+                    sourceMessageIds: [
+                        ...new Set(decision.sources.map((source) => source.messageId)),
+                    ],
+                    context: input.context,
+                }),
+            });
+            continue;
+        }
+        if (decision.kind === 'needs-clarification') {
+            if (decision.owner.kind === 'planning-step')
+                continue;
+            const id = 'edit-decision:' + createHash('sha256').update(step.id).digest('hex');
+            if (content.requirements.some((requirement) => requirement.id === id))
+                throw new Error(`Draft edit deferred requirement identity conflict: ${id}`);
+            add({
+                kind: 'set-requirement',
+                requirement: {
+                    id,
+                    text: decision.instruction,
+                    state: 'needs-clarification',
+                    scope: structuredClone(decision.owner.scope),
+                    sourceMessageIds: [
+                        ...new Set(decision.sources.map((source) => source.messageId)),
+                    ],
+                },
+            });
+            deferredRequirementIds.push(id);
+            continue;
+        }
+        if (decision.kind === 'remove-node') {
+            add({ kind: 'remove-node', nodeId: decision.nodeId });
+            continue;
+        }
+        if (decision.kind === 'remove-requirement') {
+            add({
+                kind: 'remove-requirement',
+                requirementId: decision.requirementId,
+                sourceMessageIds: [
+                    ...new Set(decision.sources.map((source) => source.messageId)),
+                ],
+            });
+            continue;
+        }
+        if (decision.kind === 'no-change' || decision.kind === 'revise-connections')
+            continue;
+        if (!byStep.has(step.id) && mode === 'staged') {
+            pendingResolutionStepIds.push(step.id);
+            continue;
+        }
+        if ('nodeId' in decision &&
+            replacements.some((replacement) => replacement.decision.kind === 'replace-api-operation' &&
+                replacement.decision.nodeId === decision.nodeId &&
+                pendingResolutionStepIds.includes(replacement.id)))
+            throw new Error(`Draft edit ${step.id} needs its pending operation replacement before detail results`);
+        const resolution = requireResolution(step.id);
+        const wrongKind = () => new Error(`Draft edit resolution ${step.id} (${resolution.kind}) does not implement ${decision.kind}`);
+        if (decision.kind === 'add-api-call' ||
+            decision.kind === 'replace-api-operation') {
+            if (resolution.kind !== 'api-call')
+                throw wrongKind();
+            const id = decision.kind === 'add-api-call' ? step.newNodeId : decision.nodeId;
+            if (id === undefined)
+                throw new Error(`Draft edit ${step.id} is missing its allocated instance identity`);
+            add({
+                kind: decision.kind === 'add-api-call' ? 'add-api-call' : 'update-api-call',
+                call: workflowDraftApiCallSchema.parse({
+                    id,
+                    operation: decision.operation,
+                    values: resolution.values,
+                    bindings: resolution.bindings,
+                    ...(resolution.requestedInputs === undefined
+                        ? {}
+                        : { requestedInputs: resolution.requestedInputs }),
+                    ...(resolution.requestMediaType === undefined
+                        ? {}
+                        : { requestMediaType: resolution.requestMediaType }),
+                }),
+            });
+        }
+        else if (decision.kind === 'add-native-node' ||
+            decision.kind === 'revise-native-node') {
+            const id = decision.kind === 'add-native-node' ? step.newNodeId : decision.nodeId;
+            if (id === undefined)
+                throw new Error(`Draft edit ${step.id} is missing its allocated instance identity`);
+            const previous = content.nativeNodes.find((node) => node.id === id);
+            const capability = decision.kind === 'add-native-node'
+                ? decision.capability
+                : previous.capability;
+            if (resolution.kind === 'native-runtime')
+                add({
+                    kind: decision.kind === 'add-native-node'
+                        ? 'add-native-node'
+                        : 'update-native-node',
+                    node: { id, capability, parameters: {}, runtimeParameters: true },
+                });
+            else if (decision.kind === 'add-native-node' &&
+                (resolution.kind === 'native-literal' ||
+                    resolution.kind === 'native-mixed'))
+                add({
+                    kind: 'add-native-node',
+                    node: {
+                        id,
+                        capability,
+                        parameters: resolution.parameters,
+                        ...(resolution.kind === 'native-mixed'
+                            ? { runtimeParameters: resolution.runtimeParameters }
+                            : {}),
+                    },
+                });
+            else if (decision.kind === 'revise-native-node' &&
+                resolution.kind === 'native-parameters')
+                add({
+                    kind: 'update-native-node',
+                    node: applyWorkflowDraftNativeParameterChanges({
+                        node: previous,
+                        capability: input.context.capabilities.find((entry) => entry.name === capability),
+                        edits: resolution.edits,
+                        source: `Draft native ${id}`,
+                    }),
+                });
+            else
+                throw wrongKind();
+        }
+        else if (decision.kind === 'revise-api-inputs' ||
+            decision.kind === 'revise-api-bindings') {
+            const call = content.apiCalls.find((call) => call.id === decision.nodeId);
+            const material = resolveWorkflowDraftApiMaterials({
+                content,
+                context: input.context,
+            }).find((material) => material.callId === call.id);
+            if (decision.kind === 'revise-api-inputs' &&
+                resolution.kind === 'api-inputs')
+                add({
+                    kind: 'update-api-call',
+                    call: {
+                        ...call,
+                        ...(call.requestedInputs === undefined
+                            ? {}
+                            : {
+                                requestedInputs: retainRequestedApiInputsAfterEdits(call.requestedInputs, resolution.edits),
+                            }),
+                        values: applyWorkflowDraftApiInputEdits(call.values, resolution.edits, {
+                            ...material,
+                            ...(resolution.requestMediaType === undefined
+                                ? {}
+                                : { requestMediaType: resolution.requestMediaType }),
+                        }),
+                        ...(resolution.requestMediaType === undefined
+                            ? {}
+                            : { requestMediaType: resolution.requestMediaType }),
+                    },
+                });
+            else if (decision.kind === 'revise-api-bindings' &&
+                resolution.kind === 'api-bindings')
+                add({
+                    kind: 'update-api-call',
+                    call: {
+                        ...call,
+                        values: applyWorkflowDraftApiInputEdits(call.values, resolution.valueEdits, material),
+                        bindings: applyWorkflowDraftBindingEdits(call.bindings, resolution.edits, `Draft API ${call.id}`),
+                    },
+                });
+            else
+                throw wrongKind();
+        }
+        else if (decision.kind === 'revise-requirement' ||
+            decision.kind === 'restore-requirement') {
+            if (resolution.kind !== 'requirement')
+                throw wrongKind();
+            const reference = decision.kind === 'restore-requirement'
+                ? listRemovedWorkflowDraftRequirements(input.draft)
+                : content.requirements;
+            const previous = reference.find((requirement) => requirement.id === decision.requirementId);
+            add({
+                kind: 'set-requirement',
+                requirement: {
+                    id: previous.id,
+                    ...(previous.origin === undefined ? {} : { origin: previous.origin }),
+                    text: resolution.text,
+                    state: resolution.state,
+                    scope: resolution.scope,
+                    sourceMessageIds: [
+                        ...new Set([
+                            ...decision.sources.map((source) => source.messageId),
+                            resolution.answerMessageId,
+                        ]),
+                    ],
+                },
+            });
+        }
+    }
+    if (byStep.size)
+        throw new Error(`Unexpected resolution for deterministic draft edit step: ${[...byStep.keys()].join(', ')}`);
+    return {
+        kind: 'unvalidated-edit-materials',
+        planId: input.plan.id,
+        baseRevision: input.plan.baseRevision,
+        content,
+        nodeRemovalConnections,
+        changes,
+        pendingRepairs: [],
+        deferredRequirementIds,
+        pendingResolutionStepIds,
+        pendingClarificationQuestionIds: input.context.clarification === undefined
+            ? []
+            : [
+                ...input.context.clarification.resolution.pendingQuestionIds,
+                ...input.context.clarification.resolution.deferredQuestionIds,
+            ],
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { PrepareWorkflowDraftEditInput } from '../../../types/workflow-draft-edit-assembly.js';
+import type { PrimaryWorkflowDraftEdit, WorkflowDraftEditPreparationMode } from '../../../types/workflow-draft-edit-assembly-internal.js';
+/** Recompute repair authority after each explicit result; never trust client-edited material state. */
+export declare function resolvePreparedWorkflowDraftEdit(input: PrepareWorkflowDraftEditInput, mode: WorkflowDraftEditPreparationMode): PrimaryWorkflowDraftEdit;