@bastani/atomic 0.9.44-alpha.4 → 0.9.44-alpha.6

package/dist/builtin/workflows/builtin/{chunk-k8d7ehjx.js → chunk-jvna28mq.js}

@@ -122,6 +122,12 @@ class ScopedDurableBackend {
   getPendingStageMessageDeliveryCount(workflowId, messageId, logicalRunId = workflowId) {
     return this.inner.getPendingStageMessageDeliveryCount?.(this.scope.rootWorkflowId, messageId, logicalRunId) ?? 0;
   }
+  pendingStageDeliveryReceiptChanges(_workflowId, cursor) {
+    return this.inner.pendingStageDeliveryReceiptChanges?.(this.scope.rootWorkflowId, cursor);
+  }
+  pendingStageDeliveryCountVersion(_workflowId) {
+    return this.inner.pendingStageDeliveryCountVersion?.(this.scope.rootWorkflowId);
+  }
   async readPendingStageMessageDeliveryCount(workflowId, messageId, logicalRunId = workflowId) {
     return this.inner.readPendingStageMessageDeliveryCount === undefined ? this.getPendingStageMessageDeliveryCount(workflowId, messageId, logicalRunId) : await this.inner.readPendingStageMessageDeliveryCount(this.scope.rootWorkflowId, messageId, logicalRunId);
   }
@@ -1474,61 +1480,220 @@ function createStoreContext(state = createStoreState()) {
 
 // dist/builtin/workflows/src/shared/pending-stage-retention.ts
 var PENDING_STAGE_SETTLED_MESSAGE_LIMIT = 50;
+function isSettledPendingStageMessage(entry) {
+  return entry.status === "delivered" || entry.status === "undeliverable" && entry.undeliverableNotifiedAt !== undefined;
+}
 async function retainPendingStageMessages(messages, archive) {
-  const settled = messages.filter((entry) => entry.status === "delivered" || entry.status === "undeliverable" && entry.undeliverableNotifiedAt !== undefined);
+  const settled = messages.filter(isSettledPendingStageMessage);
   const expired = new Set(settled.slice(0, Math.max(0, settled.length - PENDING_STAGE_SETTLED_MESSAGE_LIMIT)));
   for (const entry of expired)
     await archive(entry);
   return expired.size === 0 ? messages : messages.filter((entry) => !expired.has(entry));
 }
 
+// dist/builtin/workflows/src/shared/pending-stage-transition-ledger.ts
+class PendingStageTransitionLedger {
+  compacted = [];
+  settled = 0;
+  stages = new Map;
+  fixed = new WeakSet;
+  reconciled = [];
+  reconciledVersion;
+  reconcile(backend, runId, messages) {
+    if (backend.getPendingStageMessageDeliveryCount === undefined)
+      return messages;
+    const version = backend.pendingStageDeliveryCountVersion?.(runId);
+    const base = version !== undefined && version === this.reconciledVersion ? this.reconciled : undefined;
+    let recovered;
+    for (let index = 0;index < messages.length; index++) {
+      const entry = messages[index];
+      if (entry.sticky !== true || base !== undefined && base[index] === entry)
+        continue;
+      const count = backend.getPendingStageMessageDeliveryCount(runId, entry.id, entry.runId);
+      if (count <= (entry.deliveryCount ?? entry.deliveries?.length ?? 0))
+        continue;
+      recovered ??= [...messages];
+      recovered[index] = { ...entry, deliveryCount: count };
+    }
+    const result = recovered ?? messages;
+    this.reconciled = result;
+    this.reconciledVersion = version;
+    return result;
+  }
+  async compact(backend, runId, messages, runs, archiveSettled) {
+    const stageStatus = createStageStatusLookup(runs);
+    const endedStages = [];
+    const dirty = new Set;
+    for (const [deliveryRunId, byStage] of this.stages) {
+      for (const [stageId, entries] of byStage) {
+        if (!isEndedStageStatus(stageStatus(deliveryRunId, stageId)))
+          continue;
+        endedStages.push([deliveryRunId, stageId]);
+        for (const entry of entries)
+          dirty.add(entry);
+      }
+    }
+    const base = this.compacted;
+    const output = [];
+    const removed = [];
+    const added = [];
+    let settled = this.settled;
+    const length = Math.max(base.length, messages.length);
+    for (let index = 0;index < length; index++) {
+      const previous = base[index];
+      const entry = messages[index];
+      if (previous === entry && !dirty.has(entry)) {
+        output.push(entry);
+        continue;
+      }
+      if (previous !== undefined) {
+        removed.push(previous);
+        if (isSettledPendingStageMessage(previous))
+          settled--;
+      }
+      if (entry === undefined)
+        continue;
+      if (isSettledPendingStageMessage(entry))
+        settled++;
+      const next = this.fixed.has(entry) && !dirty.has(entry) ? entry : await compactEntryDeliveries(backend, runId, entry, stageStatus);
+      output.push(next);
+      added.push(next);
+    }
+    let retained = output;
+    if (archiveSettled !== undefined && settled > PENDING_STAGE_SETTLED_MESSAGE_LIMIT) {
+      retained = await retainPendingStageMessages(output, archiveSettled);
+      settled = PENDING_STAGE_SETTLED_MESSAGE_LIMIT;
+    }
+    return {
+      messages: retained,
+      commit: () => {
+        for (const [deliveryRunId, stageId] of endedStages) {
+          const byStage = this.stages.get(deliveryRunId);
+          byStage?.delete(stageId);
+          if (byStage?.size === 0)
+            this.stages.delete(deliveryRunId);
+        }
+        for (const entry of dirty)
+          this.fixed.delete(entry);
+        for (const entry of removed)
+          this.unindex(entry);
+        for (const entry of added)
+          this.index(entry);
+        this.compacted = retained;
+        this.settled = settled;
+      }
+    };
+  }
+  index(entry) {
+    this.fixed.add(entry);
+    for (const delivery of entry.deliveries ?? []) {
+      let byStage = this.stages.get(delivery.runId);
+      if (byStage === undefined) {
+        byStage = new Map;
+        this.stages.set(delivery.runId, byStage);
+      }
+      let entries = byStage.get(delivery.stageId);
+      if (entries === undefined) {
+        entries = new Set;
+        byStage.set(delivery.stageId, entries);
+      }
+      entries.add(entry);
+    }
+  }
+  unindex(entry) {
+    this.fixed.delete(entry);
+    for (const delivery of entry.deliveries ?? []) {
+      const byStage = this.stages.get(delivery.runId);
+      const entries = byStage?.get(delivery.stageId);
+      if (entries === undefined)
+        continue;
+      entries.delete(entry);
+      if (entries.size > 0)
+        continue;
+      byStage.delete(delivery.stageId);
+      if (byStage.size === 0)
+        this.stages.delete(delivery.runId);
+    }
+  }
+}
+function isCompactingBackend(backend) {
+  return backend.archivePendingStageDeliveryReceipt !== undefined && backend.hasPendingStageDeliveryReceipt !== undefined;
+}
+function createStageStatusLookup(runs) {
+  let runById;
+  return (runId, stageId) => {
+    if (runById === undefined) {
+      runById = new Map;
+      for (const run of runs)
+        if (!runById.has(run.id))
+          runById.set(run.id, run);
+    }
+    return runById.get(runId)?.stages.find((stage) => stage.id === stageId)?.status;
+  };
+}
+function isEndedStageStatus(status) {
+  return status === "completed" || status === "skipped" || status === "failed";
+}
+async function compactEntryDeliveries(backend, runId, entry, stageStatus) {
+  if (entry.sticky !== true || entry.deliveries === undefined)
+    return entry;
+  const latest = new Map;
+  entry.deliveries.forEach((delivery, index) => {
+    latest.set(deliverySlot(delivery), index);
+  });
+  const deliveries = [];
+  let archivedThrough = -1;
+  for (let index = 0;index < entry.deliveries.length; index++) {
+    const delivery = entry.deliveries[index];
+    if (entry.status !== "queued" || isEndedStageStatus(stageStatus(delivery.runId, delivery.stageId)) || latest.get(deliverySlot(delivery)) !== index && delivery.sessionId !== undefined) {
+      while (archivedThrough < index) {
+        const prefixIndex = archivedThrough + 1;
+        const receipt = entry.deliveries[prefixIndex];
+        if (!await backend.hasPendingStageDeliveryReceipt(runId, entry.id, receipt, entry.runId))
+          await backend.archivePendingStageDeliveryReceipt(runId, entry.id, receipt, {
+            messageRunId: entry.runId,
+            deliveryCount: (entry.deliveryCount ?? entry.deliveries.length) - entry.deliveries.length + prefixIndex + 1
+          });
+        archivedThrough = prefixIndex;
+      }
+    } else {
+      deliveries.push(delivery);
+    }
+  }
+  return deliveries.length === entry.deliveries.length ? entry : { ...entry, deliveries };
+}
+function deliverySlot(delivery) {
+  return `${delivery.runId.length}:${delivery.runId}${delivery.stageId.length}:${delivery.stageId}${delivery.admission === undefined ? "-" : `+${delivery.admission}`}`;
+}
+
 // dist/builtin/workflows/src/shared/store-pending-stage-delivery-methods.ts
 function createPendingStageDeliveryStoreMethods(context) {
-  const transitions = new Map;
-  const serialize = async (runId, transition) => {
-    const previous = transitions.get(runId) ?? Promise.resolve();
-    const result = previous.catch(() => {
-      return;
-    }).then(transition);
-    const settled = result.then(() => {
-      return;
-    }, () => {
-      return;
-    });
-    transitions.set(runId, settled);
-    settled.finally(() => {
-      if (transitions.get(runId) === settled)
-        transitions.delete(runId);
-    });
-    return await result;
-  };
+  const ledgers = new PendingStageLedgers;
+  const batches = new PendingStageTransitionBatches(context, ledgers);
   return {
     async queueStageMessage(input, senderGroup, runGroup, backend) {
-      return await serialize(input.runId, async () => {
+      return await batches.run(input.runId, backend, async (batch) => {
         const run = context.findRun(input.runId);
         if (run === undefined)
           return;
         const stageIdentity = resolvePendingStageIdentity(run, input.stageKey);
         const receipt = await backend.readSettledPendingStageMessage?.(input.runId, input.message.id);
-        const result = queueStageMessage(receipt === undefined ? run.pendingStageMessages ?? [] : [...run.pendingStageMessages ?? [], receipt], input, senderGroup, runGroup, stageIdentity);
+        const result = queueStageMessage(receipt === undefined ? batch.messages(run) : [...batch.messages(run), receipt], input, senderGroup, runGroup, stageIdentity);
         if (result.ok && !result.deduplicated) {
-          const messages = await persistTransition(backend, input.runId, result.messages, context);
-          const live = context.findRun(input.runId) ?? run;
-          live.pendingStageMessages = [...messages];
-          context.bumpAndNotify();
+          await batch.apply(backend, input.runId, result.messages);
         }
-        return result.ok ? { ...result, messages: (context.findRun(input.runId) ?? run).pendingStageMessages ?? [] } : result;
+        return result.ok ? { ...result, messages: batch.messages(context.findRun(input.runId) ?? run) } : result;
       });
     },
     async validateLiveStageMessage(input) {
-      return await serialize(input.runId, async () => {
+      return await batches.run(input.runId, undefined, async (batch) => {
         const run = context.findRun(input.runId);
         if (run === undefined)
           return;
         const availableBackend = availableRunDurableBackend(context.state.runs, input.runId) ?? context.backend;
         const backend = availableBackend === undefined ? undefined : durableBackendForRun(availableBackend, context.state.runs, input.runId);
         const receipt = await backend?.readSettledPendingStageMessage?.(input.runId, input.message.id);
-        const result = queueStageMessage(receipt === undefined ? run.pendingStageMessages ?? [] : [...run.pendingStageMessages ?? [], receipt], input, undefined, undefined, resolvePendingStageIdentity(run, input.stageKey));
+        const result = queueStageMessage(receipt === undefined ? batch.messages(run) : [...batch.messages(run), receipt], input, undefined, undefined, resolvePendingStageIdentity(run, input.stageKey));
         if (!result.ok) {
           return result.reason === "message_id_conflict" ? { outcome: "message_id_conflict", messageId: result.messageId } : { outcome: "forward" };
         }
@@ -1550,77 +1715,65 @@ function createPendingStageDeliveryStoreMethods(context) {
       return pendingStageMessagesFor(run?.pendingStageMessages ?? [], runId, stageKey, run === undefined ? undefined : resolvePendingStageIdentity(run, stageKey));
     },
     async markPendingStageMessageDelivered(runId, stageKey, messageId, deliveredAt, backend) {
-      return await serialize(runId, async () => {
+      return await batches.run(runId, backend, async (batch) => {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
-        const current = run.pendingStageMessages ?? [];
+        const current = batch.messages(run);
         const next = markPendingStageMessageDelivered(current, runId, stageKey, messageId, deliveredAt, resolvePendingStageIdentity(run, stageKey));
         if (next === current)
           return false;
-        const messages = await persistTransition(backend, runId, next, context);
-        const live = context.findRun(runId) ?? run;
-        live.pendingStageMessages = [...messages];
-        context.bumpAndNotify();
+        await batch.apply(backend, runId, next);
         return true;
       });
     },
     async markPendingStageMessageUndeliverable(runId, stageKey, messageId, reason, backend) {
-      return await serialize(runId, async () => {
+      return await batches.run(runId, backend, async (batch) => {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
-        const current = run.pendingStageMessages ?? [];
+        const current = batch.messages(run);
         const next = markPendingStageMessageUndeliverable(current, runId, stageKey, messageId, reason, resolvePendingStageIdentity(run, stageKey));
         if (next === current)
           return false;
-        const messages = await persistTransition(backend, runId, next, context);
-        const live = context.findRun(runId) ?? run;
-        live.pendingStageMessages = [...messages];
-        context.bumpAndNotify();
+        await batch.apply(backend, runId, next);
         return true;
       });
     },
     async markPendingStageMessageUndeliverableNotified(runId, stageKey, messageId, notificationId, notifiedAt, backend) {
-      return await serialize(runId, async () => {
+      return await batches.run(runId, backend, async (batch) => {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
-        const current = run.pendingStageMessages ?? [];
+        const current = batch.messages(run);
         const next = markPendingStageMessageUndeliverableNotified(current, runId, stageKey, messageId, notificationId, notifiedAt);
         if (next === current)
           return false;
-        const messages = await persistTransition(backend, runId, next, context);
-        const live = context.findRun(runId) ?? run;
-        live.pendingStageMessages = [...messages];
-        context.bumpAndNotify();
+        await batch.apply(backend, runId, next);
         return true;
       });
     },
     async queueStickyStageMessage(input, senderGroup, runGroup, backend) {
-      return await serialize(input.runId, async () => {
+      return await batches.run(input.runId, backend, async (batch) => {
         const run = context.findRun(input.runId);
         if (run === undefined)
           return;
         const receipt = await backend.readSettledPendingStageMessage?.(input.runId, input.message.id);
-        const result = queueStickyStageMessage(receipt === undefined ? run.pendingStageMessages ?? [] : [...run.pendingStageMessages ?? [], receipt], input, senderGroup, runGroup);
+        const result = queueStickyStageMessage(receipt === undefined ? batch.messages(run) : [...batch.messages(run), receipt], input, senderGroup, runGroup);
         if (result.ok && !result.deduplicated) {
-          const messages = await persistTransition(backend, input.runId, result.messages, context);
-          const live = context.findRun(input.runId) ?? run;
-          live.pendingStageMessages = [...messages];
-          context.bumpAndNotify();
+          await batch.apply(backend, input.runId, result.messages);
         }
-        return result.ok ? { ...result, messages: (context.findRun(input.runId) ?? run).pendingStageMessages ?? [] } : result;
+        return result.ok ? { ...result, messages: batch.messages(context.findRun(input.runId) ?? run) } : result;
       });
     },
     async recordPendingStageMessageDeliveries(runId, messageId, records, deliveredAt, backend) {
-      return await serialize(runId, async () => {
+      return await batches.run(runId, backend, async (batch) => {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
         if (records.length === 0)
           await backend.readPendingStageMessageDeliveryCount?.(runId, messageId, runId);
-        let current = reconcileDeliveryCounts(backend, runId, run.pendingStageMessages ?? []);
+        let current = ledgers.for(run).reconcile(backend, runId, batch.messages(run));
         const unconfirmedRecords = [];
         for (const record of records) {
           const contextReceipt = record.admission === "transport" ? { ...record, admission: "context" } : undefined;
@@ -1628,35 +1781,26 @@ function createPendingStageDeliveryStoreMethods(context) {
             unconfirmedRecords.push(record);
           }
         }
-        current = reconcileDeliveryCounts(backend, runId, current);
-        if (current !== run.pendingStageMessages) {
-          run.pendingStageMessages = [...current];
-          context.bumpAndNotify();
-        }
+        current = ledgers.for(run).reconcile(backend, runId, current);
+        batch.reconciled(run, current);
         const next = recordPendingStageMessageDeliveries(current, runId, messageId, unconfirmedRecords, deliveredAt);
         if (next === current)
           return false;
-        const messages = await persistTransition(backend, runId, next, context);
-        const live = context.findRun(runId) ?? run;
-        live.pendingStageMessages = [...messages];
-        context.bumpAndNotify();
+        await batch.apply(backend, runId, next);
         return true;
       });
     },
     async settleStickyPendingStageMessageDelivered(runId, messageId, settledAt, backend) {
-      return await serialize(runId, async () => {
+      return await batches.run(runId, backend, async (batch) => {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
         await backend.readPendingStageMessageDeliveryCount?.(runId, messageId, runId);
-        const current = reconcileDeliveryCounts(backend, runId, run.pendingStageMessages ?? []);
+        const current = ledgers.for(run).reconcile(backend, runId, batch.messages(run));
         const next = settleStickyPendingStageMessageDelivered(current, runId, messageId, settledAt);
         if (next === current)
           return false;
-        const messages = await persistTransition(backend, runId, next, context);
-        const live = context.findRun(runId) ?? run;
-        live.pendingStageMessages = [...messages];
-        context.bumpAndNotify();
+        await batch.apply(backend, runId, next);
         return true;
       });
     }
@@ -1674,74 +1818,181 @@ function resolvePendingStageIdentity(run, stageKey) {
     aliases: stage.id === stage.name ? [stage.id] : [stage.id, stage.name]
   };
 }
-async function persistTransition(backend, runId, messages, context) {
-  let retained = reconcileDeliveryCounts(backend, runId, messages);
-  try {
-    if (backend.archivePendingStageDeliveryReceipt !== undefined && backend.hasPendingStageDeliveryReceipt !== undefined) {
-      const compacted = [];
-      for (const entry of retained) {
-        if (entry.sticky !== true || entry.deliveries === undefined) {
-          compacted.push(entry);
-          continue;
-        }
-        const latest = new Map;
-        entry.deliveries.forEach((delivery, index) => {
-          latest.set(JSON.stringify([delivery.runId, delivery.stageId, delivery.admission]), index);
-        });
-        const deliveries = [];
-        let archivedThrough = -1;
-        for (let index = 0;index < entry.deliveries.length; index++) {
-          const delivery = entry.deliveries[index];
-          const stage = context.state.runs.find((run) => run.id === delivery.runId)?.stages.find((stage) => stage.id === delivery.stageId);
-          if (entry.status !== "queued" || stage?.status === "completed" || stage?.status === "skipped" || stage?.status === "failed" || latest.get(JSON.stringify([delivery.runId, delivery.stageId, delivery.admission])) !== index && delivery.sessionId !== undefined) {
-            while (archivedThrough < index) {
-              const prefixIndex = archivedThrough + 1;
-              await backend.archivePendingStageDeliveryReceipt(runId, entry.id, entry.deliveries[prefixIndex], {
-                messageRunId: entry.runId,
-                deliveryCount: (entry.deliveryCount ?? entry.deliveries.length) - entry.deliveries.length + prefixIndex + 1
-              });
-              archivedThrough = prefixIndex;
-            }
-          } else {
-            deliveries.push(delivery);
-          }
-        }
-        compacted.push(deliveries.length === entry.deliveries.length ? entry : { ...entry, deliveries });
+var PENDING_STAGE_TRANSITION_BATCH_LIMIT = 256;
+
+class PendingStageTransitionBatches {
+  queues = new Map;
+  context;
+  ledgers;
+  constructor(context, ledgers) {
+    this.context = context;
+    this.ledgers = ledgers;
+  }
+  run(runId, backend, step) {
+    return new Promise((resolve, reject) => {
+      const transition = {
+        backend,
+        step,
+        resolve: (value) => resolve(value),
+        reject
+      };
+      const queue = this.queues.get(runId);
+      if (queue !== undefined) {
+        queue.push(transition);
+        return;
+      }
+      const created = [transition];
+      this.queues.set(runId, created);
+      Promise.resolve().then(() => this.drain(runId, created));
+    });
+  }
+  async drain(runId, queue) {
+    while (queue.length > 0)
+      await this.runBatch(runId, takeBatch(queue));
+    this.queues.delete(runId);
+  }
+  async runBatch(runId, transitions) {
+    const batch = new PendingStageTransitionBatch(this.context, this.ledgers, runId);
+    const outcomes = [];
+    for (const transition of transitions) {
+      const changedBefore = batch.changed;
+      try {
+        const value = await transition.step(batch);
+        outcomes.push({ ok: true, value, uncommitted: changedBefore || batch.changed });
+      } catch (error) {
+        outcomes.push({ ok: false, error });
       }
-      retained = compacted;
     }
-    retained = compactStickyStageMessageDeliveries(retained, context.state.runs);
-    if (backend.archivePendingStageMessage !== undefined && backend.readSettledPendingStageMessage !== undefined) {
-      retained = await retainPendingStageMessages(retained, (entry) => backend.archivePendingStageMessage(runId, entry));
+    let failure;
+    try {
+      await batch.persist();
+    } catch (error) {
+      failure = { error };
+    }
+    transitions.forEach((transition, index) => {
+      const outcome = outcomes[index];
+      if (!outcome.ok)
+        transition.reject(outcome.error);
+      else if (failure !== undefined && outcome.uncommitted)
+        transition.reject(failure.error);
+      else
+        transition.resolve(outcome.value);
+    });
+  }
+}
+function takeBatch(queue) {
+  let count = 1;
+  let backend = queue[0].backend;
+  while (count < queue.length && count < PENDING_STAGE_TRANSITION_BATCH_LIMIT) {
+    const next = queue[count].backend;
+    if (next !== undefined && backend !== undefined && next !== backend)
+      break;
+    backend ??= next;
+    count++;
+  }
+  return queue.splice(0, count);
+}
+
+class PendingStageTransitionBatch {
+  changed = false;
+  list;
+  pending;
+  context;
+  ledgers;
+  runId;
+  constructor(context, ledgers, runId) {
+    this.context = context;
+    this.ledgers = ledgers;
+    this.runId = runId;
+  }
+  messages(run) {
+    return this.list ?? run.pendingStageMessages ?? [];
+  }
+  reconciled(run, messages) {
+    if (this.changed) {
+      this.list = messages;
+      return;
+    }
+    if (messages !== run.pendingStageMessages) {
+      run.pendingStageMessages = [...messages];
+      this.context.bumpAndNotify();
     }
-    if (!await backend.persistPendingStageMessages(runId, retained)) {
-      throw new Error(`atomic-workflows: durable workflow ${runId} is unavailable for pending-stage persistence`);
+  }
+  async apply(backend, runId, messages) {
+    const run = this.context.findRun(runId);
+    try {
+      const compacted = await compactTransition(backend, runId, messages, this.context, this.ledgers, run);
+      this.list = compacted.messages;
+      this.changed = true;
+      this.pending = { backend, messages: compacted.messages, commit: compacted.commit, run };
+      return compacted.messages;
+    } catch (error) {
+      if (this.changed && this.list !== undefined) {
+        const ledger = run === undefined ? new PendingStageTransitionLedger : this.ledgers.for(run);
+        this.list = ledger.reconcile(backend, runId, this.list);
+      } else
+        reconcileLive(backend, runId, this.context, this.ledgers);
+      throw error;
     }
-    return retained;
-  } finally {
-    const run = context.findRun(runId);
-    if (run !== undefined) {
-      const current = run.pendingStageMessages ?? [];
-      const recovered = reconcileDeliveryCounts(backend, runId, current);
-      if (recovered !== current) {
-        run.pendingStageMessages = [...recovered];
-        context.bumpAndNotify();
+  }
+  async persist() {
+    if (this.pending === undefined)
+      return;
+    const { backend, messages, commit, run } = this.pending;
+    const published = this.list ?? messages;
+    try {
+      if (!await backend.persistPendingStageMessages(this.runId, messages)) {
+        throw new Error(`atomic-workflows: durable workflow ${this.runId} is unavailable for pending-stage persistence`);
       }
+      commit?.();
+    } finally {
+      reconcileLive(backend, this.runId, this.context, this.ledgers);
     }
+    const live = this.context.findRun(this.runId) ?? run;
+    if (live !== undefined)
+      live.pendingStageMessages = [...published];
+    this.context.bumpAndNotify();
+  }
+}
+async function compactTransition(backend, runId, messages, context, ledgers, run) {
+  const ledger = run === undefined ? new PendingStageTransitionLedger : ledgers.for(run);
+  const reconciled = ledger.reconcile(backend, runId, messages);
+  const archiveSettled = backend.archivePendingStageMessage !== undefined && backend.readSettledPendingStageMessage !== undefined ? (entry) => backend.archivePendingStageMessage(runId, entry) : undefined;
+  if (isCompactingBackend(backend)) {
+    return await ledger.compact(backend, runId, reconciled, context.state.runs, archiveSettled);
+  }
+  let retained = compactStickyStageMessageDeliveries(reconciled, context.state.runs);
+  if (archiveSettled !== undefined)
+    retained = await retainPendingStageMessages(retained, archiveSettled);
+  if (run !== undefined)
+    ledgers.reset(run);
+  return { messages: retained };
+}
+function reconcileLive(backend, runId, context, ledgers) {
+  const current = context.findRun(runId);
+  if (current === undefined)
+    return;
+  const messages = current.pendingStageMessages ?? [];
+  const recovered = ledgers.for(current).reconcile(backend, runId, messages);
+  if (recovered !== messages) {
+    current.pendingStageMessages = [...recovered];
+    context.bumpAndNotify();
   }
 }
-function reconcileDeliveryCounts(backend, runId, messages) {
-  let changed = false;
-  const recovered = messages.map((entry) => {
-    if (entry.sticky !== true)
-      return entry;
-    const count = backend.getPendingStageMessageDeliveryCount?.(runId, entry.id, entry.runId) ?? 0;
-    if (count <= (entry.deliveryCount ?? entry.deliveries?.length ?? 0))
-      return entry;
-    changed = true;
-    return { ...entry, deliveryCount: count };
-  });
-  return changed ? recovered : messages;
+
+class PendingStageLedgers {
+  ledgers = new WeakMap;
+  for(run) {
+    let ledger = this.ledgers.get(run);
+    if (ledger === undefined) {
+      ledger = new PendingStageTransitionLedger;
+      this.ledgers.set(run, ledger);
+    }
+    return ledger;
+  }
+  reset(run) {
+    this.ledgers.delete(run);
+  }
 }
 
 // dist/builtin/workflows/src/shared/store-prompt-methods.ts

package/dist/builtin/workflows/builtin/{chunk-qxpymnaf.js → chunk-vwx023ge.js}

@@ -37,7 +37,7 @@ import {
   parseFailureDiagnostics,
   summarizeReviewConvergence,
   reverify_consolidated_batch
-} from "./chunk-k8d7ehjx.js";
+} from "./chunk-jvna28mq.js";
 import {
   VERIFICATION_SCALE
 } from "./chunk-n1910xc4.js";

package/dist/builtin/workflows/builtin/goal.js

@@ -1,7 +1,7 @@
 import {
   goal_default
-} from "./chunk-qxpymnaf.js";
-import"./chunk-k8d7ehjx.js";
+} from "./chunk-vwx023ge.js";
+import"./chunk-jvna28mq.js";
 import"./chunk-2377r57g.js";
 import"./chunk-z0d03ktm.js";
 import"./chunk-n1910xc4.js";