@openapi-flow/core 0.1.0 → 0.3.0

package/dist/draft/edits/api/resolve-workflow-draft-api-call-arguments.js

@@ -0,0 +1,77 @@
+import { resolveApiCallArgumentsContext } from './resolve-api-call-arguments-context.js';
+import { createWorkflowDraftApiCallArgumentsSchema } from '../../../schemas/workflow-draft-api-call-arguments-schema.js';
+import { applyConfirmedApiInputs } from '../../../arguments/clarification/apply-confirmed-api-inputs.js';
+import { inspectApiArgumentRequirements } from '../../../arguments/clarification/inspect-api-argument-requirements.js';
+import { resolveWorkflowDraftSourceEvidence } from '../references/resolve-workflow-draft-source-evidence.js';
+import { jsonValuesEqual } from '../../../utils/json-values-equal.js';
+import { resolveWorkflowDraftApiLiteralSources } from './resolve-workflow-draft-api-literal-sources.js';
+/** Resolve one actual request; partial values become typed questions/slots, never dummy data. */
+export function resolveWorkflowDraftApiCallArguments(input) {
+    const { description, fingerprint } = resolveApiCallArgumentsContext(input);
+    if (input.fingerprint !== fingerprint)
+        throw new Error('API call arguments fingerprint is stale or describes different staged materials, bindings or confirmed inputs');
+    const proposal = createWorkflowDraftApiCallArgumentsSchema(input).parse(input.proposal);
+    if (!jsonValuesEqual(proposal, input.proposal))
+        throw new Error('API call arguments must validate without defaults, coercion or transformation');
+    const values = applyConfirmedApiInputs({
+        callId: description.nodeId,
+        operation: description.operation,
+        requestMediaType: description.requestMediaType,
+        bindings: input.bindingPlan.bindings,
+        confirmedInputs: input.confirmedInputs,
+        values: proposal.values,
+    });
+    const inspected = inspectApiArgumentRequirements({
+        callId: description.nodeId,
+        operation: description.operation,
+        requestMediaType: description.requestMediaType,
+        bindings: input.bindingPlan.bindings,
+        values,
+        requestedInputs: proposal.requestedInputs,
+    });
+    const fields = {
+        fingerprint,
+        proposal,
+        literalSources: resolveWorkflowDraftApiLiteralSources({
+            description,
+            proposal,
+        }),
+        ...resolveWorkflowDraftSourceEvidence({
+            description,
+            decision: proposal,
+            capabilities: input.context.capabilities,
+        }),
+        arguments: {
+            callId: description.nodeId,
+            values,
+            ...(proposal.requestedInputs === undefined
+                ? {}
+                : { requestedInputs: structuredClone(proposal.requestedInputs) }),
+            bindings: structuredClone(input.bindingPlan.bindings),
+            unresolvedInputs: inspected.requirements.map((item) => item.targetPointer),
+            ...(description.requestMediaType === undefined
+                ? {}
+                : { requestMediaType: description.requestMediaType }),
+        },
+        requirements: inspected.requirements,
+    };
+    if (inspected.status === 'needs-input' && input.allowRuntimeInputs !== true)
+        return { ...fields, status: 'needs-input' };
+    return {
+        ...fields,
+        status: 'ready',
+        inputMode: inspected.status === 'needs-input' ? 'runtime-inputs' : 'provided',
+        resolution: {
+            stepId: input.stepId,
+            kind: 'api-call',
+            values: structuredClone(values),
+            ...(proposal.requestedInputs === undefined
+                ? {}
+                : { requestedInputs: structuredClone(proposal.requestedInputs) }),
+            bindings: structuredClone(input.bindingPlan.bindings),
+            ...(description.requestMediaType === undefined
+                ? {}
+                : { requestMediaType: description.requestMediaType }),
+        },
+    };
+}

package/dist/draft/edits/api/resolve-workflow-draft-api-call-bindings.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveWorkflowDraftApiCallBindingsInput, WorkflowDraftApiCallBindingResult } from '../../../types/workflow-draft-api-call-planning.js';
+/** Check one target without fabricating calls for unrelated source nodes or changing any graph. */
+export declare function resolveWorkflowDraftApiCallBindings(input: ResolveWorkflowDraftApiCallBindingsInput): WorkflowDraftApiCallBindingResult;

package/dist/draft/edits/api/resolve-workflow-draft-api-call-bindings.js

@@ -0,0 +1,93 @@
+import { describeWorkflowDraftApiCallBindings } from './describe-workflow-draft-api-call-bindings.js';
+import { createWorkflowDraftApiCallBindingsSchema } from '../../../schemas/workflow-draft-api-call-bindings-schema.js';
+import { resolveWorkflowDraftSourceEvidence } from '../references/resolve-workflow-draft-source-evidence.js';
+import { jsonValuesEqual } from '../../../utils/json-values-equal.js';
+import { createWorkflowDraftApiBindingQuestions } from './create-workflow-draft-api-binding-questions.js';
+import { validateWorkflowDraftApiCallMappings } from './validate-workflow-draft-api-call-mappings.js';
+import { workflowDraftApiBindingAnswersSchema } from '../../../schemas/workflow-draft-api-binding-answer-schema.js';
+/** Check one target without fabricating calls for unrelated source nodes or changing any graph. */
+export function resolveWorkflowDraftApiCallBindings(input) {
+    const description = describeWorkflowDraftApiCallBindings(input);
+    if (input.fingerprint !== description.fingerprint)
+        throw new Error('API call bindings fingerprint is stale or describes different staged materials');
+    const proposal = createWorkflowDraftApiCallBindingsSchema(input).parse(input.proposal);
+    if (!jsonValuesEqual(proposal, input.proposal))
+        throw new Error('API call bindings must validate without defaults, coercion or transformation');
+    const evidence = resolveWorkflowDraftSourceEvidence({
+        description,
+        decision: proposal.decision,
+        capabilities: input.context.capabilities,
+    });
+    const mappings = description.hasRequestInputs &&
+        description.sources.values.length > 0 &&
+        description.inputIntent?.targets.length !== 0
+        ? proposal.decision.mappings
+        : [];
+    validateWorkflowDraftApiCallMappings(description, mappings);
+    const answers = input.answers === undefined
+        ? undefined
+        : workflowDraftApiBindingAnswersSchema.parse(input.answers);
+    if (proposal.decision.status === 'provided' && answers !== undefined)
+        throw new Error('Binding answers require an original unresolved proposal');
+    const questions = proposal.decision.status === 'needs-clarification'
+        ? createWorkflowDraftApiBindingQuestions(description, proposal, mappings, evidence)
+        : [];
+    if (description.inputIntent !== undefined) {
+        const addressed = [
+            ...mappings.map((mapping) => mapping.targetPointer),
+            ...questions.map((question) => question.targetPointer),
+        ];
+        if (addressed.length !== description.inputIntent.targets.length ||
+            description.inputIntent.targets.some((target) => !addressed.includes(target)))
+            throw new Error('API binding proposal must resolve or ask about every selected input-intent target exactly once');
+    }
+    const answeredMappings = [...mappings];
+    for (const answer of answers === undefined ? [] : answers) {
+        const question = questions.find((question) => question.id === answer.questionId);
+        if (!question)
+            throw new Error(`Binding answer references an unknown or stale question: ${answer.questionId}`);
+        if (answer.kind === 'no-binding')
+            continue;
+        if (answer.kind === 'choose-source') {
+            const choice = question.choices.find((choice) => choice.id === answer.choiceId);
+            if (!choice)
+                throw new Error(`Binding answer references an unknown source choice: ${answer.choiceId}`);
+            answeredMappings.push({
+                targetPointer: question.targetPointer,
+                sourceNodeId: choice.sourceNodeId,
+                sourcePointer: choice.sourcePointer,
+            });
+        }
+        else
+            answeredMappings.push({
+                targetPointer: question.targetPointer,
+                sourceNodeId: answer.sourceNodeId,
+                sourcePointer: answer.sourcePointer,
+            });
+    }
+    const bindings = validateWorkflowDraftApiCallMappings(description, answeredMappings);
+    const pending = questions.filter((question) => !answers?.some((answer) => answer.questionId === question.id));
+    const choice = pending.length && proposal.decision.status === 'needs-clarification'
+        ? {
+            status: 'needs-clarification',
+            mappings,
+            questions: proposal.decision.questions,
+        }
+        : { status: 'provided', mappings: answeredMappings };
+    const fields = {
+        ...(description.inputIntent === undefined
+            ? {}
+            : { inputIntent: description.inputIntent }),
+        fingerprint: description.fingerprint,
+        proposal,
+        decision: { ...choice, ...evidence },
+        ...(answers === undefined ? {} : { answers }),
+    };
+    if (choice.status === 'needs-clarification')
+        return {
+            ...fields,
+            status: 'needs-clarification',
+            questions: pending,
+        };
+    return { ...fields, status: 'ready', bindings };
+}

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

@@ -0,0 +1,3 @@
+import type { ResolveWorkflowDraftApiLiteralSourcesInput, VerifiedWorkflowDraftApiLiteralSource } from '../../../types/workflow-draft-api-literal-sources.js';
+/** OAS validation and message existence alone do not establish a literal's origin. */
+export declare function resolveWorkflowDraftApiLiteralSources(input: ResolveWorkflowDraftApiLiteralSourcesInput): VerifiedWorkflowDraftApiLiteralSource[];

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;