@bct-app/game-engine 0.1.15 → 0.1.16-beta.1

package/dist/index.js

@@ -1078,13 +1078,7 @@ var isDeferredOperation = (operation, abilityMap) => {
   const ability = abilityMap.get(operation.abilityId);
   return ability?.executionTiming === "DEFER_TO_END";
 };
-var hasGatedLifetime = (allAbilities) => {
-  return allAbilities.some((ability) => ability.effects.some((effect) => {
-    if (!("lifetime" in effect)) return false;
-    const lifetime = effect.lifetime;
-    return Boolean(lifetime) && lifetime?.kind !== "PERMANENT";
-  }));
-};
+var FIXED_POINT_MAX_ITERATIONS = 32;
 var applyOperationToPlayers = ({
   players,
   operations,
@@ -1110,134 +1104,81 @@ var applyOperationToPlayers = ({
     }
     operationsByTimeline.get(timelineIndex)?.push(operation);
   });
-  const preconditionCache = /* @__PURE__ */ new Map();
-  const runReplay = (lifetimeSnapshotSeatMap) => {
-    const playersWithStatus = copyPlayers(players);
-    const applyOpsSequence = (ops) => {
-      ops.forEach((operation) => {
-        const operationInTimelineIdx = operationTimelineMap.get(operation) ?? -1;
-        const ability = abilityMap.get(operation.abilityId);
-        if (!ability) {
-          console.warn("Ability not found for operation:", operation);
-          return;
-        }
-        const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
-        const effector = playerSeatMap.get(operation.effector);
-        const payloads = operation.payloads || [];
-        const writableInputs = ability.inputs.filter((part) => !part.readonly);
-        let snapshotSeatMap = null;
-        const getSnapshotSeatMap = () => {
-          if (!snapshotSeatMap) {
-            snapshotSeatMap = buildPlayerSeatMap(copyPlayers(playersWithStatus));
-          }
-          return snapshotSeatMap;
-        };
-        ability.effects.forEach((effect, effectIdx) => {
-          const resolvedTargets = resolveEffectTargets({
-            effect,
-            operation,
-            payloads,
-            effector,
-            playerSeatMap,
-            characterMap
-          });
-          if (!resolvedTargets) {
-            return;
-          }
-          const precondition = "precondition" in effect ? effect.precondition : void 0;
-          let gatedTargets;
-          if (precondition) {
-            const cachedSeats = preconditionCache.get(operation)?.get(effectIdx);
-            if (cachedSeats) {
-              gatedTargets = resolvedTargets.filter((t) => cachedSeats.has(t.seat));
-            } else {
-              gatedTargets = evaluatePrecondition({
-                expr: precondition,
-                operationTimelineIdx: operationInTimelineIdx,
-                nowTimelineIndex,
-                timelines,
-                effector,
-                targets: resolvedTargets,
-                snapshotSeatMap: playerSeatMap,
-                characterMap,
-                payloads,
-                customResolver
-              });
-              const opCache = preconditionCache.get(operation) ?? /* @__PURE__ */ new Map();
-              opCache.set(effectIdx, new Set(gatedTargets.map((t) => t.seat)));
-              preconditionCache.set(operation, opCache);
-            }
-          } else {
-            gatedTargets = resolvedTargets;
-          }
-          if (gatedTargets.length === 0 && resolvedTargets.length > 0) {
-            return;
-          }
-          const makePlayersEffect = evaluateLifetime({
-            effect,
-            operationTimelineIdx: operationInTimelineIdx,
-            nowTimelineIndex,
-            timelines,
-            effector,
-            targets: gatedTargets,
-            snapshotSeatMap: lifetimeSnapshotSeatMap,
-            characterMap,
-            payloads,
-            customResolver
-          });
-          const handler = effectHandlers[effect.type];
-          if (!handler) {
-            console.warn("Unknown effect type:", effect.type);
-            return;
-          }
-          const context = {
-            effect,
-            operation,
-            payloads,
-            effector,
-            writableInputs,
-            playerSeatMap,
-            getSnapshotSeatMap,
-            characterMap,
-            abilityMap,
-            nowTimelineIndex,
-            operationInTimelineIdx,
-            makePlayersEffect
-          };
-          handler(context);
-        });
-      });
-    };
-    const applyOps = (ops) => {
-      const normalOps = [];
-      const deferredOps = [];
-      ops.forEach((operation) => {
-        if (isDeferredOperation(operation, abilityMap)) {
-          deferredOps.push(operation);
-          return;
-        }
-        normalOps.push(operation);
-      });
-      applyOpsSequence(normalOps);
-      applyOpsSequence(deferredOps);
+  const orderedOpsForTimeline = (timelineIdx) => {
+    const ops = operationsByTimeline.get(timelineIdx) ?? [];
+    const normal = [];
+    const deferred = [];
+    ops.forEach((op) => {
+      if (isDeferredOperation(op, abilityMap)) deferred.push(op);
+      else normal.push(op);
+    });
+    return [...normal, ...deferred];
+  };
+  const allOpsInOrder = [];
+  allOpsInOrder.push(...orderedOpsForTimeline(-1));
+  for (let i = 0; i <= nowTimelineIndex; i += 1) {
+    if (timelines[i]) allOpsInOrder.push(...orderedOpsForTimeline(i));
+  }
+  const processedOps = /* @__PURE__ */ new Set();
+  const records = [];
+  const recordsByOp = /* @__PURE__ */ new Map();
+  const applyRecordsForOp = (op, playersWithStatus) => {
+    const opRecords = recordsByOp.get(op);
+    if (!opRecords || opRecords.length === 0) return;
+    const ability = abilityMap.get(op.abilityId);
+    if (!ability) return;
+    const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
+    const effector = playerSeatMap.get(op.effector);
+    const payloads = op.payloads || [];
+    const writableInputs = ability.inputs.filter((part) => !part.readonly);
+    let snapshotSeatMap = null;
+    const getSnapshotSeatMap = () => {
+      if (!snapshotSeatMap) {
+        snapshotSeatMap = buildPlayerSeatMap(copyPlayers(playersWithStatus));
+      }
+      return snapshotSeatMap;
     };
-    const settingsOps = operationsByTimeline.get(-1);
-    if (settingsOps) {
-      applyOps(settingsOps);
-    }
+    opRecords.forEach((record) => {
+      const effect = ability.effects[record.effectIdx];
+      if (!effect) return;
+      const handler = effectHandlers[effect.type];
+      if (!handler) {
+        console.warn("Unknown effect type:", effect.type);
+        return;
+      }
+      const makePlayersEffect = record.activeTargetSeats.map((seat) => playerSeatMap.get(seat)).filter((p) => Boolean(p));
+      const context = {
+        effect,
+        operation: op,
+        payloads,
+        effector,
+        writableInputs,
+        playerSeatMap,
+        getSnapshotSeatMap,
+        characterMap,
+        abilityMap,
+        nowTimelineIndex,
+        operationInTimelineIdx: record.operationInTimelineIdx,
+        makePlayersEffect
+      };
+      handler(context);
+    });
+  };
+  const rebuildState = () => {
+    const playersWithStatus = copyPlayers(players);
+    const settingsOps = orderedOpsForTimeline(-1);
+    settingsOps.forEach((op) => {
+      if (processedOps.has(op)) applyRecordsForOp(op, playersWithStatus);
+    });
     for (let i = 0; i <= nowTimelineIndex; i += 1) {
       const timeline = timelines[i];
-      if (!timeline) {
-        continue;
-      }
+      if (!timeline) continue;
       const nominations = timeline.nominations;
       if (nominations && nominations.length > 0) {
         const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
         nominations.forEach((nomination) => {
           const voterSeats = nomination.voterSeats;
-          if (!voterSeats || voterSeats.length === 0) {
-            return;
-          }
+          if (!voterSeats || voterSeats.length === 0) return;
           voterSeats.forEach((seat) => {
             const player = playerSeatMap.get(seat);
             if (player && player.isDead && !player.hasUsedDeadVote) {
@@ -1246,20 +1187,126 @@ var applyOperationToPlayers = ({
           });
         });
       }
-      const timelineOps = operationsByTimeline.get(i);
-      if (timelineOps) {
-        applyOps(timelineOps);
-      }
+      orderedOpsForTimeline(i).forEach((op) => {
+        if (processedOps.has(op)) applyRecordsForOp(op, playersWithStatus);
+      });
     }
     return playersWithStatus;
   };
-  if (!hasGatedLifetime(allAbilities)) {
-    return transformEmptyArray(runReplay(null));
-  }
-  const groundTruth = runReplay(null);
-  const groundTruthSeatMap = buildPlayerSeatMap(groundTruth);
-  const final = runReplay(groundTruthSeatMap);
-  return transformEmptyArray(final);
+  const computeRecordsForOp = (op, state) => {
+    const ability = abilityMap.get(op.abilityId);
+    if (!ability) {
+      console.warn("Ability not found for operation:", op);
+      return [];
+    }
+    const playerSeatMap = buildPlayerSeatMap(state);
+    const effector = playerSeatMap.get(op.effector);
+    const payloads = op.payloads || [];
+    const operationInTimelineIdx = operationTimelineMap.get(op) ?? -1;
+    const newRecords = [];
+    ability.effects.forEach((effect, effectIdx) => {
+      const resolvedTargets = resolveEffectTargets({
+        effect,
+        operation: op,
+        payloads,
+        effector,
+        playerSeatMap,
+        characterMap
+      });
+      if (!resolvedTargets) return;
+      const precondition = "precondition" in effect ? effect.precondition : void 0;
+      const gatedTargets = precondition ? evaluatePrecondition({
+        expr: precondition,
+        operationTimelineIdx: operationInTimelineIdx,
+        nowTimelineIndex,
+        timelines,
+        effector,
+        targets: resolvedTargets,
+        snapshotSeatMap: playerSeatMap,
+        characterMap,
+        payloads,
+        customResolver
+      }) : resolvedTargets;
+      if (gatedTargets.length === 0 && resolvedTargets.length > 0) {
+        return;
+      }
+      const lifeTargets = evaluateLifetime({
+        effect,
+        operationTimelineIdx: operationInTimelineIdx,
+        nowTimelineIndex,
+        timelines,
+        effector,
+        targets: gatedTargets,
+        snapshotSeatMap: playerSeatMap,
+        characterMap,
+        payloads,
+        customResolver
+      });
+      newRecords.push({
+        operation: op,
+        effectIdx,
+        operationInTimelineIdx,
+        activeTargetSeats: lifeTargets.map((t) => t.seat)
+      });
+    });
+    return newRecords;
+  };
+  const reEvaluateLifetimes = (state) => {
+    const playerSeatMap = buildPlayerSeatMap(state);
+    let anyShrunk = false;
+    records.forEach((record) => {
+      if (record.activeTargetSeats.length === 0) return;
+      const ability = abilityMap.get(record.operation.abilityId);
+      if (!ability) return;
+      const effect = ability.effects[record.effectIdx];
+      if (!effect) return;
+      const effector = playerSeatMap.get(record.operation.effector);
+      const payloads = record.operation.payloads || [];
+      const targets = record.activeTargetSeats.map((seat) => playerSeatMap.get(seat)).filter((p) => Boolean(p));
+      const liveTargets = evaluateLifetime({
+        effect,
+        operationTimelineIdx: record.operationInTimelineIdx,
+        nowTimelineIndex,
+        timelines,
+        effector,
+        targets,
+        snapshotSeatMap: playerSeatMap,
+        characterMap,
+        payloads,
+        customResolver
+      });
+      const newSeats = liveTargets.map((t) => t.seat);
+      if (newSeats.length < record.activeTargetSeats.length) {
+        record.activeTargetSeats = newSeats;
+        anyShrunk = true;
+      }
+    });
+    return anyShrunk;
+  };
+  let lastState = copyPlayers(players);
+  allOpsInOrder.forEach((op) => {
+    const newRecords = computeRecordsForOp(op, lastState);
+    if (newRecords.length > 0) {
+      records.push(...newRecords);
+      const arr = recordsByOp.get(op) ?? [];
+      arr.push(...newRecords);
+      recordsByOp.set(op, arr);
+    }
+    processedOps.add(op);
+    let state = rebuildState();
+    let iter = 0;
+    while (iter < FIXED_POINT_MAX_ITERATIONS) {
+      const shrunk = reEvaluateLifetimes(state);
+      if (!shrunk) break;
+      state = rebuildState();
+      iter += 1;
+    }
+    if (iter >= FIXED_POINT_MAX_ITERATIONS) {
+      console.warn("applyOperationToPlayers: lifetime fixed-point did not converge within %d iterations after op %s", FIXED_POINT_MAX_ITERATIONS, op.abilityId);
+    }
+    lastState = state;
+  });
+  return transformEmptyArray(lastState);
 };
 
 // src/can-invoke-ability.ts

package/dist/index.mjs

@@ -1038,13 +1038,7 @@ var isDeferredOperation = (operation, abilityMap) => {
   const ability = abilityMap.get(operation.abilityId);
   return ability?.executionTiming === "DEFER_TO_END";
 };
-var hasGatedLifetime = (allAbilities) => {
-  return allAbilities.some((ability) => ability.effects.some((effect) => {
-    if (!("lifetime" in effect)) return false;
-    const lifetime = effect.lifetime;
-    return Boolean(lifetime) && lifetime?.kind !== "PERMANENT";
-  }));
-};
+var FIXED_POINT_MAX_ITERATIONS = 32;
 var applyOperationToPlayers = ({
   players,
   operations,
@@ -1070,134 +1064,81 @@ var applyOperationToPlayers = ({
     }
     operationsByTimeline.get(timelineIndex)?.push(operation);
   });
-  const preconditionCache = /* @__PURE__ */ new Map();
-  const runReplay = (lifetimeSnapshotSeatMap) => {
-    const playersWithStatus = copyPlayers(players);
-    const applyOpsSequence = (ops) => {
-      ops.forEach((operation) => {
-        const operationInTimelineIdx = operationTimelineMap.get(operation) ?? -1;
-        const ability = abilityMap.get(operation.abilityId);
-        if (!ability) {
-          console.warn("Ability not found for operation:", operation);
-          return;
-        }
-        const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
-        const effector = playerSeatMap.get(operation.effector);
-        const payloads = operation.payloads || [];
-        const writableInputs = ability.inputs.filter((part) => !part.readonly);
-        let snapshotSeatMap = null;
-        const getSnapshotSeatMap = () => {
-          if (!snapshotSeatMap) {
-            snapshotSeatMap = buildPlayerSeatMap(copyPlayers(playersWithStatus));
-          }
-          return snapshotSeatMap;
-        };
-        ability.effects.forEach((effect, effectIdx) => {
-          const resolvedTargets = resolveEffectTargets({
-            effect,
-            operation,
-            payloads,
-            effector,
-            playerSeatMap,
-            characterMap
-          });
-          if (!resolvedTargets) {
-            return;
-          }
-          const precondition = "precondition" in effect ? effect.precondition : void 0;
-          let gatedTargets;
-          if (precondition) {
-            const cachedSeats = preconditionCache.get(operation)?.get(effectIdx);
-            if (cachedSeats) {
-              gatedTargets = resolvedTargets.filter((t) => cachedSeats.has(t.seat));
-            } else {
-              gatedTargets = evaluatePrecondition({
-                expr: precondition,
-                operationTimelineIdx: operationInTimelineIdx,
-                nowTimelineIndex,
-                timelines,
-                effector,
-                targets: resolvedTargets,
-                snapshotSeatMap: playerSeatMap,
-                characterMap,
-                payloads,
-                customResolver
-              });
-              const opCache = preconditionCache.get(operation) ?? /* @__PURE__ */ new Map();
-              opCache.set(effectIdx, new Set(gatedTargets.map((t) => t.seat)));
-              preconditionCache.set(operation, opCache);
-            }
-          } else {
-            gatedTargets = resolvedTargets;
-          }
-          if (gatedTargets.length === 0 && resolvedTargets.length > 0) {
-            return;
-          }
-          const makePlayersEffect = evaluateLifetime({
-            effect,
-            operationTimelineIdx: operationInTimelineIdx,
-            nowTimelineIndex,
-            timelines,
-            effector,
-            targets: gatedTargets,
-            snapshotSeatMap: lifetimeSnapshotSeatMap,
-            characterMap,
-            payloads,
-            customResolver
-          });
-          const handler = effectHandlers[effect.type];
-          if (!handler) {
-            console.warn("Unknown effect type:", effect.type);
-            return;
-          }
-          const context = {
-            effect,
-            operation,
-            payloads,
-            effector,
-            writableInputs,
-            playerSeatMap,
-            getSnapshotSeatMap,
-            characterMap,
-            abilityMap,
-            nowTimelineIndex,
-            operationInTimelineIdx,
-            makePlayersEffect
-          };
-          handler(context);
-        });
-      });
-    };
-    const applyOps = (ops) => {
-      const normalOps = [];
-      const deferredOps = [];
-      ops.forEach((operation) => {
-        if (isDeferredOperation(operation, abilityMap)) {
-          deferredOps.push(operation);
-          return;
-        }
-        normalOps.push(operation);
-      });
-      applyOpsSequence(normalOps);
-      applyOpsSequence(deferredOps);
+  const orderedOpsForTimeline = (timelineIdx) => {
+    const ops = operationsByTimeline.get(timelineIdx) ?? [];
+    const normal = [];
+    const deferred = [];
+    ops.forEach((op) => {
+      if (isDeferredOperation(op, abilityMap)) deferred.push(op);
+      else normal.push(op);
+    });
+    return [...normal, ...deferred];
+  };
+  const allOpsInOrder = [];
+  allOpsInOrder.push(...orderedOpsForTimeline(-1));
+  for (let i = 0; i <= nowTimelineIndex; i += 1) {
+    if (timelines[i]) allOpsInOrder.push(...orderedOpsForTimeline(i));
+  }
+  const processedOps = /* @__PURE__ */ new Set();
+  const records = [];
+  const recordsByOp = /* @__PURE__ */ new Map();
+  const applyRecordsForOp = (op, playersWithStatus) => {
+    const opRecords = recordsByOp.get(op);
+    if (!opRecords || opRecords.length === 0) return;
+    const ability = abilityMap.get(op.abilityId);
+    if (!ability) return;
+    const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
+    const effector = playerSeatMap.get(op.effector);
+    const payloads = op.payloads || [];
+    const writableInputs = ability.inputs.filter((part) => !part.readonly);
+    let snapshotSeatMap = null;
+    const getSnapshotSeatMap = () => {
+      if (!snapshotSeatMap) {
+        snapshotSeatMap = buildPlayerSeatMap(copyPlayers(playersWithStatus));
+      }
+      return snapshotSeatMap;
     };
-    const settingsOps = operationsByTimeline.get(-1);
-    if (settingsOps) {
-      applyOps(settingsOps);
-    }
+    opRecords.forEach((record) => {
+      const effect = ability.effects[record.effectIdx];
+      if (!effect) return;
+      const handler = effectHandlers[effect.type];
+      if (!handler) {
+        console.warn("Unknown effect type:", effect.type);
+        return;
+      }
+      const makePlayersEffect = record.activeTargetSeats.map((seat) => playerSeatMap.get(seat)).filter((p) => Boolean(p));
+      const context = {
+        effect,
+        operation: op,
+        payloads,
+        effector,
+        writableInputs,
+        playerSeatMap,
+        getSnapshotSeatMap,
+        characterMap,
+        abilityMap,
+        nowTimelineIndex,
+        operationInTimelineIdx: record.operationInTimelineIdx,
+        makePlayersEffect
+      };
+      handler(context);
+    });
+  };
+  const rebuildState = () => {
+    const playersWithStatus = copyPlayers(players);
+    const settingsOps = orderedOpsForTimeline(-1);
+    settingsOps.forEach((op) => {
+      if (processedOps.has(op)) applyRecordsForOp(op, playersWithStatus);
+    });
     for (let i = 0; i <= nowTimelineIndex; i += 1) {
       const timeline = timelines[i];
-      if (!timeline) {
-        continue;
-      }
+      if (!timeline) continue;
       const nominations = timeline.nominations;
       if (nominations && nominations.length > 0) {
         const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
         nominations.forEach((nomination) => {
           const voterSeats = nomination.voterSeats;
-          if (!voterSeats || voterSeats.length === 0) {
-            return;
-          }
+          if (!voterSeats || voterSeats.length === 0) return;
           voterSeats.forEach((seat) => {
             const player = playerSeatMap.get(seat);
             if (player && player.isDead && !player.hasUsedDeadVote) {
@@ -1206,20 +1147,126 @@ var applyOperationToPlayers = ({
           });
         });
       }
-      const timelineOps = operationsByTimeline.get(i);
-      if (timelineOps) {
-        applyOps(timelineOps);
-      }
+      orderedOpsForTimeline(i).forEach((op) => {
+        if (processedOps.has(op)) applyRecordsForOp(op, playersWithStatus);
+      });
     }
     return playersWithStatus;
   };
-  if (!hasGatedLifetime(allAbilities)) {
-    return transformEmptyArray(runReplay(null));
-  }
-  const groundTruth = runReplay(null);
-  const groundTruthSeatMap = buildPlayerSeatMap(groundTruth);
-  const final = runReplay(groundTruthSeatMap);
-  return transformEmptyArray(final);
+  const computeRecordsForOp = (op, state) => {
+    const ability = abilityMap.get(op.abilityId);
+    if (!ability) {
+      console.warn("Ability not found for operation:", op);
+      return [];
+    }
+    const playerSeatMap = buildPlayerSeatMap(state);
+    const effector = playerSeatMap.get(op.effector);
+    const payloads = op.payloads || [];
+    const operationInTimelineIdx = operationTimelineMap.get(op) ?? -1;
+    const newRecords = [];
+    ability.effects.forEach((effect, effectIdx) => {
+      const resolvedTargets = resolveEffectTargets({
+        effect,
+        operation: op,
+        payloads,
+        effector,
+        playerSeatMap,
+        characterMap
+      });
+      if (!resolvedTargets) return;
+      const precondition = "precondition" in effect ? effect.precondition : void 0;
+      const gatedTargets = precondition ? evaluatePrecondition({
+        expr: precondition,
+        operationTimelineIdx: operationInTimelineIdx,
+        nowTimelineIndex,
+        timelines,
+        effector,
+        targets: resolvedTargets,
+        snapshotSeatMap: playerSeatMap,
+        characterMap,
+        payloads,
+        customResolver
+      }) : resolvedTargets;
+      if (gatedTargets.length === 0 && resolvedTargets.length > 0) {
+        return;
+      }
+      const lifeTargets = evaluateLifetime({
+        effect,
+        operationTimelineIdx: operationInTimelineIdx,
+        nowTimelineIndex,
+        timelines,
+        effector,
+        targets: gatedTargets,
+        snapshotSeatMap: playerSeatMap,
+        characterMap,
+        payloads,
+        customResolver
+      });
+      newRecords.push({
+        operation: op,
+        effectIdx,
+        operationInTimelineIdx,
+        activeTargetSeats: lifeTargets.map((t) => t.seat)
+      });
+    });
+    return newRecords;
+  };
+  const reEvaluateLifetimes = (state) => {
+    const playerSeatMap = buildPlayerSeatMap(state);
+    let anyShrunk = false;
+    records.forEach((record) => {
+      if (record.activeTargetSeats.length === 0) return;
+      const ability = abilityMap.get(record.operation.abilityId);
+      if (!ability) return;
+      const effect = ability.effects[record.effectIdx];
+      if (!effect) return;
+      const effector = playerSeatMap.get(record.operation.effector);
+      const payloads = record.operation.payloads || [];
+      const targets = record.activeTargetSeats.map((seat) => playerSeatMap.get(seat)).filter((p) => Boolean(p));
+      const liveTargets = evaluateLifetime({
+        effect,
+        operationTimelineIdx: record.operationInTimelineIdx,
+        nowTimelineIndex,
+        timelines,
+        effector,
+        targets,
+        snapshotSeatMap: playerSeatMap,
+        characterMap,
+        payloads,
+        customResolver
+      });
+      const newSeats = liveTargets.map((t) => t.seat);
+      if (newSeats.length < record.activeTargetSeats.length) {
+        record.activeTargetSeats = newSeats;
+        anyShrunk = true;
+      }
+    });
+    return anyShrunk;
+  };
+  let lastState = copyPlayers(players);
+  allOpsInOrder.forEach((op) => {
+    const newRecords = computeRecordsForOp(op, lastState);
+    if (newRecords.length > 0) {
+      records.push(...newRecords);
+      const arr = recordsByOp.get(op) ?? [];
+      arr.push(...newRecords);
+      recordsByOp.set(op, arr);
+    }
+    processedOps.add(op);
+    let state = rebuildState();
+    let iter = 0;
+    while (iter < FIXED_POINT_MAX_ITERATIONS) {
+      const shrunk = reEvaluateLifetimes(state);
+      if (!shrunk) break;
+      state = rebuildState();
+      iter += 1;
+    }
+    if (iter >= FIXED_POINT_MAX_ITERATIONS) {
+      console.warn("applyOperationToPlayers: lifetime fixed-point did not converge within %d iterations after op %s", FIXED_POINT_MAX_ITERATIONS, op.abilityId);
+    }
+    lastState = state;
+  });
+  return transformEmptyArray(lastState);
 };
 
 // src/can-invoke-ability.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bct-app/game-engine",
-  "version": "0.1.15",
+  "version": "0.1.16-beta.1",
   "description": "Game engine utilities for BCT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,6 +43,7 @@
     "build": "tsup src/index.ts --dts --format cjs,esm",
     "dev": "tsup src/index.ts --dts --format cjs,esm --watch",
     "test": "vitest",
-    "test:run": "vitest run"
+    "test:run": "vitest run",
+    "publish:beta": "pnpm publish --tag beta --no-git-checks"
   }
 }