stageflow 0.16.0 → 0.19.0

package/dist/runtime/cloneSchedule.js

@@ -1,8 +1,7 @@
-import { isNeedTerminalState, predecessorEdges } from "../config/pipelineNeeds.js";
+import { predecessorEdges } from "../config/pipelineNeeds.js";
 import { appendCloneInstances, instancesOfDefinition, } from "../runstore/pipelineDagSnapshot.js";
-import { definitionIdForInstance } from "../runstore/stageInstanceId.js";
+import { cloneInstanceOrdinal, definitionIdForInstance, } from "../runstore/stageInstanceId.js";
 import { collectDownstreamStageIds } from "./dagTraversal.js";
-import { activeCohortFromCloneIds, filterJoinInputs, } from "./forkGeneration.js";
 function asDagSnapshot(dag) {
     const snapshot = dag;
     if (Array.isArray(snapshot.stage_ids))
@@ -22,53 +21,34 @@ function definitionInstances(dag, catalogId) {
 export function isCloneInstance(dag, stageId) {
     return definitionIdForInstance(asDagSnapshot(dag), stageId) !== stageId;
 }
-function isParallelCloneInstance(dag, stageId, completedEnvelopes) {
+function emitterCloneMode(dag, stageId) {
     if (!isCloneInstance(dag, stageId))
-        return false;
-    const defId = definitionIdForInstance(asDagSnapshot(dag), stageId);
-    for (const envelope of completedEnvelopes.values()) {
-        for (const item of envelope.clone_forks ?? []) {
-            if (item.action === "fanout" &&
-                item.mode === "parallel" &&
-                item.successor_id === defId &&
-                definitionInstances(dag, defId).includes(stageId)) {
-                return true;
-            }
-        }
-    }
-    return false;
+        return undefined;
+    const node = dag.nodes.find((n) => n.id === stageId);
+    const emitterId = typeof node?.needs === "string" && node.needs ? node.needs : undefined;
+    if (emitterId === undefined)
+        return undefined;
+    return dag.nodes.find((n) => n.id === emitterId)?.clone_mode;
 }
-function isSequentialFanoutSuccessor(completedEnvelopes, successorId) {
-    for (const envelope of completedEnvelopes.values()) {
-        for (const item of envelope.clone_forks ?? []) {
-            if (item.action === "fanout" &&
-                item.mode === "sequential" &&
-                item.successor_id === successorId) {
-                return true;
-            }
-        }
-    }
-    return false;
+function isParallelCloneInstance(dag, stageId, _completedEnvelopes) {
+    return emitterCloneMode(dag, stageId) === "parallel";
 }
 function isSequentialCloneInstance(dag, stageId, completedEnvelopes) {
-    if (!isCloneInstance(dag, stageId))
-        return false;
-    const defId = definitionIdForInstance(asDagSnapshot(dag), stageId);
-    if (!isSequentialFanoutSuccessor(completedEnvelopes, defId))
-        return false;
-    return definitionInstances(dag, defId).includes(stageId);
+    return sequentialInstanceList(dag, stageId, completedEnvelopes) !== undefined;
 }
-function sequentialInstanceList(dag, stageId, completedEnvelopes) {
-    for (const envelope of completedEnvelopes.values()) {
-        for (const item of envelope.clone_forks ?? []) {
-            if (item.action !== "fanout" || item.mode !== "sequential")
-                continue;
-            const instances = definitionInstances(dag, item.successor_id);
-            if (instances.includes(stageId))
-                return instances;
-        }
-    }
-    return undefined;
+function sequentialInstanceList(dag, stageId, _completedEnvelopes) {
+    if (!isCloneInstance(dag, stageId))
+        return undefined;
+    const snapshot = asDagSnapshot(dag);
+    const defId = definitionIdForInstance(snapshot, stageId);
+    const node = dag.nodes.find((n) => n.id === stageId);
+    const emitterId = typeof node?.needs === "string" && node.needs ? node.needs : undefined;
+    if (emitterId === undefined)
+        return undefined;
+    const emitter = dag.nodes.find((n) => n.id === emitterId);
+    if (emitter?.clone_mode !== "sequential")
+        return undefined;
+    return definitionInstances(dag, defId);
 }
 function sequentialPreviousUnsatisfied(dag, stageId, states, completedEnvelopes) {
     const instances = sequentialInstanceList(dag, stageId, completedEnvelopes);
@@ -91,27 +71,21 @@ export function sequentialLaterCloneIds(dag, stageId, completedEnvelopes) {
 function parentNeedEdge(node, parentId, parentDefId) {
     return predecessorEdges(node).find((edge) => edge.id === parentId || edge.id === parentDefId);
 }
-function edgeInstancesReady(dag, edge, states) {
-    const instances = definitionInstances(dag, edge.id);
-    if (instances.length === 0)
-        return false;
-    const hasSucceededSibling = instances.some((id) => states.get(id) === "succeeded");
-    return instances.every((id) => {
-        const state = states.get(id);
-        if (!isNeedTerminalState(state))
-            return false;
-        if (edge.on.includes(state))
-            return true;
-        return state === "skipped" && hasSucceededSibling;
-    });
-}
 function shouldSkipForObservedNeed(dag, node, parentId, parentDefId, observed) {
+    // A multi-parent join is never skip-cascaded from one parent. Once every
+    // parent is terminal: run if any succeeded (skipped siblings do not
+    // block) unless every parent succeeded and an inbound `if` missed;
+    // stay pending if any failed; force-skip when every parent is skipped
+    // or every parent succeeded with an inbound miss (`pickStalledJoinSkips`).
+    // A single-parent node keeps eager skip-cascade below.
+    if (predecessorEdges(node).length > 1)
+        return false;
     const edge = parentNeedEdge(node, parentId, parentDefId);
     if (!edge)
         return false;
     if (edge.on.includes(observed))
         return false;
-    if (observed === "skipped" &&
+    if ((observed === "skipped" || observed === "failed") &&
         predecessorEdges(node).length === 1 &&
         typeof node.needs === "string" &&
         isCloneInstance(dag, parentId)) {
@@ -164,41 +138,7 @@ function joinAndDownstreamIds(dag, cloneStageId) {
     }
     return ids;
 }
-/**
- * A fresh clone_forks fanout targeting a catalog id that already has
- * instances is only safe when every existing instance was put back to
- * `pending` by the current retry cascade (`retryDownstreamIds`) — that means
- * an ancestor was legitimately retried and this parent re-emitted the same
- * fanout for reactivation. Instances that are still active/terminal, or
- * merely `pending` without having gone through a retry reset (e.g. an
- * envelope processed twice in one live run), are rejected as before.
- *
- * Feedback-loop replay is different: the prior cohort was superseded
- * (`skipped`) and a new generation must mint fresh `~N` ids, so
- * `forceFreshCloneIds` bypasses the conflict.
- */
-export function cloneFanoutConflict(dag, envelope, states, retryDownstreamIds, options) {
-    if (options?.forceFreshCloneIds === true)
-        return undefined;
-    const snapshot = asDagSnapshot(dag);
-    for (const item of envelope.clone_forks ?? []) {
-        if (item.action !== "fanout")
-            continue;
-        const existing = definitionInstances(dag, item.successor_id).filter((id) => id !== item.successor_id);
-        if (existing.length > 0) {
-            const reactivatable = existing.every((id) => states.get(id) === "pending" && retryDownstreamIds.has(id));
-            if (!reactivatable) {
-                return `clone fan-out for "${item.successor_id}" is already instanced`;
-            }
-            continue;
-        }
-        if (!snapshot.stage_ids.includes(item.successor_id)) {
-            return `clone fan-out for "${item.successor_id}" is already instanced`;
-        }
-    }
-    return undefined;
-}
-export function nextFreeCloneSuffix(snapshot, catalogId) {
+function nextFreeCloneSuffix(snapshot, catalogId) {
     const prefix = `${catalogId}~`;
     let max = 0;
     for (const id of snapshot.stage_ids) {
@@ -210,15 +150,127 @@ export function nextFreeCloneSuffix(snapshot, catalogId) {
     }
     return max + 1;
 }
-export function protectedClonableChildIds(dag, predecessorId, envelope) {
+function catalogCloneChildId(dag, emitterId) {
+    const catalogChildId = (dag.childrenOf[emitterId] ?? []).find((id) => {
+        const child = dag.nodes.find((n) => n.id === id);
+        return child !== undefined && (child.definition_id ?? child.id) === child.id;
+    });
+    if (catalogChildId !== undefined)
+        return catalogChildId;
+    const instanceChild = (dag.childrenOf[emitterId] ?? []).find((id) => {
+        const child = dag.nodes.find((n) => n.id === id);
+        return child?.definition_id !== undefined && child.definition_id !== child.id;
+    });
+    return instanceChild
+        ? dag.nodes.find((n) => n.id === instanceChild)?.definition_id
+        : undefined;
+}
+export function mint(dag, emitterId, envelope) {
+    const emitter = dag.nodes.find((n) => n.id === emitterId);
+    const field = emitter?.clone_array_field;
+    if (field === undefined)
+        return { kind: "none" };
+    const catalogChildId = catalogCloneChildId(dag, emitterId);
+    if (catalogChildId === undefined)
+        return { kind: "none" };
+    const arr = envelope.payload?.[field];
+    if (!Array.isArray(arr) || arr.length < 1) {
+        return {
+            kind: "error",
+            reason: `Clone Array "${field}" must contain at least one item`,
+        };
+    }
+    const snapshot = asDagSnapshot(dag);
+    const { snapshot: next, instanceIds } = appendCloneInstances(snapshot, {
+        catalogId: catalogChildId,
+        predecessorId: emitterId,
+        count: arr.length,
+        startAt: nextFreeCloneSuffix(snapshot, catalogChildId),
+    });
+    return {
+        kind: "minted",
+        dag: next,
+        catalogChildId,
+        instanceIds,
+    };
+}
+function cloneAssignmentIndex(dag, stageId, definitionId, arrayLength) {
+    const ordinal = cloneInstanceOrdinal(stageId, definitionId);
+    if (ordinal === undefined)
+        return undefined;
+    const snapshot = dag;
+    if (!Array.isArray(snapshot.stage_ids) || arrayLength < 1) {
+        return ordinal - 1;
+    }
+    const siblings = instancesOfDefinition(snapshot, definitionId)
+        .map((id) => ({ id, ordinal: cloneInstanceOrdinal(id, definitionId) }))
+        .filter((row) => row.ordinal !== undefined)
+        .sort((a, b) => a.ordinal - b.ordinal);
+    const cohort = siblings.slice(-arrayLength);
+    const index = cohort.findIndex((row) => row.id === stageId);
+    return index === -1 ? undefined : index;
+}
+export function assignment(dag, stageId, definitionId, completedEnvelopes) {
+    const ordinal = cloneInstanceOrdinal(stageId, definitionId);
+    if (ordinal === undefined)
+        return undefined;
+    const node = dag.nodes.find((n) => n.id === stageId);
+    if (!node)
+        return undefined;
+    const emitterId = typeof node.needs === "string" && node.needs
+        ? node.needs
+        : predecessorEdges(node)[0]?.id;
+    if (emitterId === undefined)
+        return undefined;
+    const emitter = dag.nodes.find((n) => n.id === emitterId);
+    const field = emitter?.clone_array_field;
+    if (field === undefined)
+        return undefined;
+    const parent = completedEnvelopes.get(emitterId);
+    if (parent === undefined || parent.status !== "success") {
+        return {
+            ok: false,
+            reason: `missing envelope for Clone Chain emitter "${emitterId}"`,
+        };
+    }
+    const arr = parent.payload?.[field];
+    if (!Array.isArray(arr)) {
+        return {
+            ok: false,
+            reason: `missing Clone Array element ${ordinal} on "${emitterId}"`,
+        };
+    }
+    const index = cloneAssignmentIndex(dag, stageId, definitionId, arr.length);
+    if (index === undefined || index >= arr.length) {
+        return {
+            ok: false,
+            reason: `missing Clone Array element ${ordinal} on "${emitterId}"`,
+        };
+    }
+    const element = arr[index];
+    if (element === null || typeof element !== "object" || Array.isArray(element)) {
+        return {
+            ok: false,
+            reason: `Clone Array element ${index + 1} is not an object`,
+        };
+    }
+    return {
+        ok: true,
+        prior: {
+            status: "success",
+            summary: parent.summary,
+            artifacts: [],
+            payload: structuredClone(element),
+        },
+    };
+}
+export function protectedClonableChildIds(dag, predecessorId, _envelope) {
     const ids = new Set();
+    const predecessor = dag.nodes.find((n) => n.id === predecessorId);
+    if (predecessor?.clone_array_field === undefined)
+        return ids;
     for (const childId of dag.childrenOf[predecessorId] ?? []) {
-        const child = dag.nodes.find((n) => n.id === childId);
-        if (child?.clonable === true)
-            ids.add(childId);
-    }
-    for (const item of envelope.clone_forks ?? []) {
-        ids.add(item.successor_id);
+        ids.add(childId);
     }
     return ids;
 }
@@ -276,142 +328,9 @@ export function cloneFailFastSkipIds(dag, stageId, completedEnvelopes) {
     ids.push(...joinAndDownstreamIds(dag, stageId));
     return ids;
 }
-export function cloneScheduleAllowsRun(dag, stageId, states, completedEnvelopes, options) {
-    const node = dag.nodes.find((n) => n.id === stageId);
-    if (!node)
-        return false;
+export function cloneScheduleAllowsRun(dag, stageId, states, completedEnvelopes) {
     if (definitionInstances(dag, stageId).some((id) => id !== stageId)) {
         return false;
     }
-    const edges = predecessorEdges(node);
-    if (edges.length === 0) {
-        return !sequentialPreviousUnsatisfied(dag, stageId, states, completedEnvelopes);
-    }
-    if (edges.length >= 2) {
-        for (const edge of edges) {
-            if (!edgeInstancesReady(dag, edge, states))
-                return false;
-        }
-    }
-    else {
-        const parentNeedId = typeof node.needs === "string" && node.needs ? node.needs : edges[0].id;
-        const allInstances = definitionInstances(dag, parentNeedId);
-        const cohort = options?.activeCohortForNeeds?.(parentNeedId) ??
-            activeCohortFromCloneIds(options?.activeCloneIdsForNeeds?.(parentNeedId));
-        if (cohort.kind === "awaiting_mint") {
-            return false;
-        }
-        const instances = filterJoinInputs(allInstances, cohort);
-        if (instances.length <= 1) {
-            const parentId = instances[0] ?? parentNeedId;
-            if (states.get(parentId) !== "succeeded")
-                return false;
-        }
-        else if (cohort.kind === "active") {
-            if (!instances.every((id) => states.get(id) === "succeeded")) {
-                return false;
-            }
-        }
-        else if (!instances.every((id) => states.get(id) === "succeeded" || states.get(id) === "skipped")) {
-            return false;
-        }
-    }
     return !sequentialPreviousUnsatisfied(dag, stageId, states, completedEnvelopes);
 }
-export function applyCloneForksToSchedule(dag, predecessorId, envelope, states, options) {
-    let current = asDagSnapshot(dag);
-    const skippedIds = [];
-    const mintedBySuccessor = new Map();
-    const forceFresh = options?.forceFreshCloneIds === true;
-    const skipPending = (stageId) => {
-        if (states.get(stageId) === "pending") {
-            states.set(stageId, "skipped");
-            skippedIds.push(stageId);
-        }
-    };
-    for (const item of envelope.clone_forks ?? []) {
-        if (item.action === "skip") {
-            skipPending(item.successor_id);
-            skipRejectedNeedDependents(current, item.successor_id, states, "skipped", skipPending);
-            continue;
-        }
-        if (item.action !== "fanout")
-            continue;
-        const existing = definitionInstances(current, item.successor_id).filter((id) => id !== item.successor_id);
-        if (forceFresh) {
-            const { snapshot, instanceIds } = appendCloneInstances(current, {
-                catalogId: item.successor_id,
-                predecessorId,
-                count: item.clones.length,
-                startAt: nextFreeCloneSuffix(current, item.successor_id),
-            });
-            current = snapshot;
-            states.delete(item.successor_id);
-            for (const id of instanceIds) {
-                states.set(id, "pending");
-            }
-            mintedBySuccessor.set(item.successor_id, instanceIds);
-            continue;
-        }
-        if (existing.length > 0) {
-            // Reactivating instances a retry cascade reset to `pending` (see
-            // cloneFanoutConflict), which only allows this fanout through when
-            // *every* existing instance is pending. Anything short of that —
-            // a normal resume re-apply of an already-processed fanout, or only
-            // one sibling out of a cohort being retried directly — must stay a
-            // no-op here: growing/shrinking the cohort in those cases would mint
-            // or skip instances no retry actually asked for.
-            const allPending = existing.every((id) => states.get(id) === "pending");
-            if (!allPending)
-                continue;
-            const desired = item.clones.length;
-            for (const id of existing.slice(desired)) {
-                skipPending(id);
-                skipRejectedNeedDependents(current, id, states, "skipped", skipPending);
-            }
-            if (desired > existing.length) {
-                const { snapshot, instanceIds } = appendCloneInstances(current, {
-                    catalogId: item.successor_id,
-                    predecessorId,
-                    count: desired - existing.length,
-                    startAt: nextFreeCloneSuffix(current, item.successor_id),
-                });
-                current = snapshot;
-                for (const id of instanceIds) {
-                    states.set(id, "pending");
-                }
-            }
-            continue;
-        }
-        const { snapshot, instanceIds } = appendCloneInstances(current, {
-            catalogId: item.successor_id,
-            predecessorId,
-            count: item.clones.length,
-        });
-        current = snapshot;
-        states.delete(item.successor_id);
-        for (const id of instanceIds) {
-            states.set(id, "pending");
-        }
-        mintedBySuccessor.set(item.successor_id, instanceIds);
-    }
-    return {
-        dag: current,
-        skippedIds,
-        ...(mintedBySuccessor.size > 0 ? { mintedBySuccessor } : {}),
-    };
-}
-export function applyCloneForksFromEnvelopes(dag, states, completedEnvelopes) {
-    let current = asDagSnapshot(dag);
-    const skippedIds = [];
-    const predecessors = [...current.nodes];
-    for (const node of predecessors) {
-        const envelope = completedEnvelopes.get(node.id);
-        if (!envelope?.clone_forks?.length)
-            continue;
-        const applied = applyCloneForksToSchedule(current, node.id, envelope, states);
-        current = applied.dag;
-        skippedIds.push(...applied.skippedIds);
-    }
-    return { dag: current, skippedIds };
-}

package/dist/runtime/envelopeRouting.js

@@ -1,14 +1,7 @@
 import { predecessorEdges } from "../config/pipelineNeeds.js";
-import { instancesOfDefinition, } from "../runstore/pipelineDagSnapshot.js";
 import { definitionIdForInstance } from "../runstore/stageInstanceId.js";
 import { activeCohortFromCloneIds, filterJoinInputs, selectActiveInput, } from "./forkGeneration.js";
-function definitionInstances(dag, catalogId) {
-    const snapshot = dag;
-    if (Array.isArray(snapshot.stage_ids)) {
-        return instancesOfDefinition(snapshot, catalogId);
-    }
-    return dag.nodes.some((n) => n.id === catalogId) ? [catalogId] : [];
-}
+import { expandJoinParent } from "./joinReadiness.js";
 async function resolveActiveCohortForNeeds(dag, needsId, store, runId, activeCloneIds, scheduleOverride) {
     if (activeCloneIds !== undefined) {
         return activeCohortFromCloneIds(activeCloneIds);
@@ -59,29 +52,6 @@ export function buildStageConfigById(loaded) {
 function dagNode(dag, stageId) {
     return dag.nodes.find((node) => node.id === stageId);
 }
-const SYNTHETIC_SKIPPED_TERMINAL = {
-    status: "skipped",
-    summary: "stage was skipped",
-    artifacts: [],
-};
-function mintedCloneInstances(dag, parentId) {
-    return definitionInstances(dag, parentId).filter((id) => id !== parentId);
-}
-function isClonableParent(dag, parentId) {
-    const node = dagNode(dag, parentId);
-    return node?.clonable === true || mintedCloneInstances(dag, parentId).length > 0;
-}
-function failureReasonFromSnapshot(snap) {
-    let reason = "stage failed";
-    if (snap === undefined)
-        return reason;
-    for (const ev of snap.events) {
-        if (ev.event === "failed" && typeof ev.reason === "string" && ev.reason) {
-            reason = ev.reason;
-        }
-    }
-    return reason;
-}
 async function loadStageSnapshots(options) {
     if (options.stages !== undefined)
         return options.stages;
@@ -107,24 +77,10 @@ async function readCachedEnvelope(options, snapshots, stageId) {
     }
     return undefined;
 }
-async function terminalForPersistedStage(options, snapshots, stageId) {
+async function successTerminalForPersistedStage(options, snapshots, stageId) {
     const snap = snapshots.get(stageId);
-    if (snap?.status === "skipped") {
-        return { ok: true, value: { ...SYNTHETIC_SKIPPED_TERMINAL } };
-    }
-    if (snap?.status === "failed") {
-        const envelope = await readCachedEnvelope(options, snapshots, stageId);
-        if (envelope?.status === "failure") {
-            return { ok: true, value: envelope };
-        }
-        return {
-            ok: true,
-            value: {
-                status: "failure",
-                summary: failureReasonFromSnapshot(snap),
-                artifacts: [],
-            },
-        };
+    if (snap?.status === "skipped" || snap?.status === "failed") {
+        return { ok: true, omit: true };
     }
     if (snap?.status === "succeeded") {
         const envelope = await readCachedEnvelope(options, snapshots, stageId);
@@ -134,8 +90,18 @@ async function terminalForPersistedStage(options, snapshots, stageId) {
                 reason: `missing envelope for upstream stage "${stageId}"`,
             };
         }
+        if (envelope.status !== "success") {
+            return { ok: true, omit: true };
+        }
         return { ok: true, value: envelope };
     }
+    const fromMap = options.completedEnvelopes.get(stageId);
+    if (fromMap?.status === "success") {
+        return { ok: true, value: structuredClone(fromMap) };
+    }
+    if (fromMap !== undefined) {
+        return { ok: true, omit: true };
+    }
     return {
         ok: false,
         reason: `missing envelope for upstream stage "${stageId}"`,
@@ -146,32 +112,27 @@ async function resolveGenericJoinPriors(options, node) {
     const priorEnvelopesByStage = {};
     for (const edge of predecessorEdges(node)) {
         const parentId = edge.id;
-        if (isClonableParent(options.dag, parentId)) {
-            const minted = mintedCloneInstances(options.dag, parentId);
-            if (minted.length > 0) {
-                const list = [];
-                for (const id of minted) {
-                    const terminal = await terminalForPersistedStage(options, snapshots, id);
-                    if (!terminal.ok)
-                        return terminal;
-                    list.push(terminal.value);
-                }
-                priorEnvelopesByStage[parentId] = list;
-                continue;
+        const expanded = expandJoinParent(options.dag, parentId);
+        if (expanded.length > 1 || expanded[0] !== parentId) {
+            const list = [];
+            for (const id of expanded) {
+                const terminal = await successTerminalForPersistedStage(options, snapshots, id);
+                if (!terminal.ok)
+                    return terminal;
+                if ("omit" in terminal)
+                    continue;
+                list.push(terminal.value);
             }
-            if (snapshots.get(parentId)?.status === "skipped") {
-                priorEnvelopesByStage[parentId] = [];
-                continue;
+            if (list.length > 0) {
+                priorEnvelopesByStage[parentId] = list;
             }
-            const once = await terminalForPersistedStage(options, snapshots, parentId);
-            if (!once.ok)
-                return once;
-            priorEnvelopesByStage[parentId] = [once.value];
             continue;
         }
-        const terminal = await terminalForPersistedStage(options, snapshots, parentId);
+        const terminal = await successTerminalForPersistedStage(options, snapshots, parentId);
         if (!terminal.ok)
             return terminal;
+        if ("omit" in terminal)
+            continue;
         priorEnvelopesByStage[parentId] = terminal.value;
     }
     return { ok: true, prior: null, priorEnvelopesByStage };
@@ -192,21 +153,30 @@ export async function resolvePriorEnvelope(options) {
         return resolveGenericJoinPriors(options, node);
     }
     const parentId = typeof node.needs === "string" && node.needs ? node.needs : edges[0].id;
-    const allJoinInstances = definitionInstances(options.dag, parentId);
-    if (allJoinInstances.length > 1) {
+    const expanded = expandJoinParent(options.dag, parentId);
+    if (expanded.length > 1 || expanded[0] !== parentId) {
         const cohort = await resolveActiveCohortForNeeds(options.dag, parentId, options.store, options.runId, options.activeCloneIds, options.scheduleOverride);
-        const joinInstances = filterJoinInputs(allJoinInstances, cohort);
+        const joinInstances = filterJoinInputs(expanded, cohort);
+        const snapshots = new Map((await loadStageSnapshots(options)).map((snap) => [snap.stage_id, snap]));
         const joinPriors = [];
         for (const id of joinInstances) {
+            const snap = snapshots.get(id);
+            if (snap?.status === "skipped" || snap?.status === "failed") {
+                continue;
+            }
             const fromMap = options.completedEnvelopes.get(id);
             if (fromMap !== undefined) {
-                joinPriors.push(structuredClone(fromMap));
+                if (fromMap.status === "success") {
+                    joinPriors.push(structuredClone(fromMap));
+                }
                 continue;
             }
             if (options.store !== undefined && options.runId !== undefined) {
                 try {
                     const envelope = await options.store.readEnvelope(options.runId, id);
-                    joinPriors.push(structuredClone(envelope));
+                    if (envelope.status === "success") {
+                        joinPriors.push(structuredClone(envelope));
+                    }
                     continue;
                 }
                 catch {
@@ -242,26 +212,5 @@ export async function resolvePriorEnvelope(options) {
             reason: `missing envelope for upstream stage "${parentId}"`,
         };
     }
-    for (const item of parent.clone_forks ?? []) {
-        if (item.action === "once" && item.successor_id === options.stageId) {
-            return { ok: true, prior: structuredClone(item.envelope) };
-        }
-        if (item.action === "fanout") {
-            const allInstanceIds = definitionInstances(options.dag, item.successor_id);
-            const cohort = await resolveActiveCohortForNeeds(options.dag, item.successor_id, options.store, options.runId, options.activeCloneIds, options.scheduleOverride);
-            const instanceIds = filterJoinInputs(allInstanceIds, cohort);
-            const index = instanceIds.indexOf(options.stageId);
-            if (index >= 0) {
-                const clone = item.clones[index];
-                if (clone === undefined) {
-                    return {
-                        ok: false,
-                        reason: `missing clone envelope for instance "${options.stageId}"`,
-                    };
-                }
-                return { ok: true, prior: structuredClone(clone.envelope) };
-            }
-        }
-    }
     return { ok: true, prior: structuredClone(parent) };
 }

package/dist/runtime/forkGeneration.d.ts

@@ -1,8 +1,8 @@
 import type { ForkGenerationRecord, RunStore } from "../runstore/port.js";
 import type { ResolvedPipelineDag } from "../types/pipeline.js";
-/** Persistent route stages that fan out to clonable successors (or already have instances). */
+/** Persistent route stages that fan out to Clone Chain children (or already have instances). */
 export declare function routeRelatedForkParentIds(dag: ResolvedPipelineDag, routeStageIds: readonly string[]): string[];
-/** Clone instance ids currently under clonable successors of a fork parent. */
+/** Clone instance ids currently under Clone Chain children of a fork parent. */
 export declare function cloneInstanceIdsForForkParent(dag: ResolvedPipelineDag, forkParentStageId: string): string[];
 export declare function backfillActiveGenerationIfNeeded(store: RunStore, runId: string, options: {
     dag: ResolvedPipelineDag;
@@ -63,6 +63,10 @@ export declare function selectActiveInput(options: {
     needsStageId: string;
     scheduleOverride?: ReadonlyMap<string, ReadonlySet<string>>;
 }): Promise<ActiveCohort>;
+export declare function forkCohortMapsFromStore(store: Pick<RunStore, "listForkGenerations">, runId: string): Promise<{
+    supersededCloneIds: Set<string>;
+    cohortByForkParent: Map<string, Set<string>>;
+}>;
 export declare function filterJoinInputs(allInstanceIds: readonly string[], cohort: ActiveCohort): string[];
 export declare function filterJoinInstanceIds(allInstanceIds: readonly string[], activeCloneIds: Set<string> | null): string[];
 /**