@bct-app/game-engine 0.1.2 → 0.1.6-beta.0

package/dist/index.mjs

@@ -84,33 +84,43 @@ var getValueFromPayloads = (payloads, idx) => {
   return payloads[idx];
 };
 var getSourceValue = (source, payloads) => {
-  if (source.from === "PAYLOAD") {
+  if (source?.from === "PAYLOAD") {
     if (!isNumberOrNumberArray(source.value)) {
       return void 0;
     }
     return getValueFromPayloads(payloads, source.value);
   }
-  if (source.from === "CONSTANT") {
+  if (source?.from === "CONSTANT") {
     return source.value;
   }
   return null;
 };
-var resolveSourceValue = (source, writableParts, payloads, effector, snapshotSeatMap, resolveFromPlayer) => {
-  if (source.from === "PAYLOAD") {
+var resolveSourceValue = (source, writableInputs, payloads, effector, snapshotSeatMap, resolveFromPlayer, isResolvedValue, resolveFromCharacter) => {
+  const castOrValidate = (value) => {
+    if (!isResolvedValue) {
+      return value;
+    }
+    return isResolvedValue(value) ? value : void 0;
+  };
+  if (source?.from === "PAYLOAD") {
     const payloadValue = getSourceValue(source, payloads);
     const idx = adjustValueAsNumberArray(source.value);
-    const part = writableParts[idx[0]];
-    if (part?.type === "PLAYER") {
+    const input = writableInputs[idx[0]];
+    if (input?.type === "PLAYER") {
       const seat = adjustValueAsNumber(payloadValue);
       const player = typeof seat === "number" ? snapshotSeatMap.get(seat) : void 0;
       return player ? resolveFromPlayer(player) : void 0;
     }
-    return payloadValue;
+    if (input?.type === "CHARACTER") {
+      const characterId = typeof payloadValue === "string" ? payloadValue : void 0;
+      return characterId && resolveFromCharacter ? resolveFromCharacter(characterId) : void 0;
+    }
+    return castOrValidate(payloadValue);
   }
-  if (source.from === "CONSTANT") {
-    return source.value;
+  if (source?.from === "CONSTANT") {
+    return castOrValidate(source.value);
   }
-  if (source.from === "EFFECTOR") {
+  if (source?.from === "EFFECTOR") {
     if (!effector) {
       return void 0;
     }
@@ -120,7 +130,607 @@ var resolveSourceValue = (source, writableParts, payloads, effector, snapshotSea
   return void 0;
 };
 
+// src/effects/handler-types.ts
+var createEffectHandler = (type, handler) => {
+  return (context) => {
+    if (context.effect.type !== type) {
+      console.warn("Invalid effect type for handler:", context.effect.type, "expected:", type);
+      return;
+    }
+    handler({
+      ...context,
+      effect: context.effect
+    });
+  };
+};
+
+// src/effects/handlers/ability-change.ts
+var toAbilityIdList = (value) => {
+  if (typeof value === "string") {
+    return value.length > 0 ? [value] : void 0;
+  }
+  if (Array.isArray(value)) {
+    const ids = value.filter((item) => typeof item === "string" && item.length > 0);
+    return ids.length > 0 ? ids : void 0;
+  }
+  return void 0;
+};
+var applyAbilityChange = createEffectHandler("ABILITY_CHANGE", ({
+  effect,
+  operation,
+  payloads,
+  effector,
+  writableInputs,
+  getSnapshotSeatMap,
+  abilityMap,
+  makePlayersEffect,
+  characterMap
+}) => {
+  const resolvedRaw = resolveSourceValue(
+    effect.source,
+    writableInputs,
+    payloads,
+    effector,
+    getSnapshotSeatMap(),
+    (player) => player.abilities,
+    (value) => typeof value === "string" && value.length > 0 || Array.isArray(value) && value.every((item) => typeof item === "string"),
+    (characterId) => {
+      const character = characterMap.get(characterId);
+      if (!character) {
+        console.warn("Character not found for ABILITY_CHANGE effect source:", characterId);
+        return [];
+      }
+      return character.abilities.map((a) => a.id);
+    }
+  );
+  const resolvedAbilityIds = toAbilityIdList(resolvedRaw);
+  if (!resolvedAbilityIds) {
+    console.warn("Ability ID not found for ABILITY_CHANGE effect:", effect.source);
+    return;
+  }
+  makePlayersEffect.forEach((player) => {
+    const overrideRaw = operation.abilityChangeOverrides?.[String(player.seat)];
+    const overrideIds = toAbilityIdList(overrideRaw);
+    const finalAbilityIds = overrideIds ?? resolvedAbilityIds;
+    finalAbilityIds.forEach((finalAbilityId) => {
+      const newAbility = abilityMap.get(finalAbilityId);
+      if (!newAbility) {
+        console.warn("Ability not found for ABILITY_CHANGE effect:", finalAbilityId);
+        return;
+      }
+      const replaceAtSameStage = (abilities) => {
+        const idx = abilities.findIndex((aid) => abilityMap.get(aid)?.stage === newAbility.stage);
+        if (idx >= 0) {
+          abilities[idx] = finalAbilityId;
+        } else {
+          abilities.push(finalAbilityId);
+        }
+      };
+      replaceAtSameStage(player.abilities);
+      if (player.perceivedCharacter?.asCharacter) {
+        replaceAtSameStage(player.perceivedCharacter.abilities);
+      }
+    });
+  });
+});
+
+// src/effects/handlers/alignment-change.ts
+var applyAlignmentChange = createEffectHandler("ALIGNMENT_CHANGE", ({
+  effect,
+  payloads,
+  effector,
+  writableInputs,
+  getSnapshotSeatMap,
+  makePlayersEffect
+}) => {
+  const alignment = resolveSourceValue(
+    effect.source,
+    writableInputs,
+    payloads,
+    effector,
+    getSnapshotSeatMap(),
+    (player) => player.alignment,
+    (isResolvedValue) => typeof isResolvedValue === "string" && (isResolvedValue === "GOOD" || isResolvedValue === "EVIL")
+  );
+  if (!alignment) {
+    console.warn("Alignment not found for ALIGNMENT_CHANGE effect:", effect.source);
+    return;
+  }
+  makePlayersEffect.forEach((player) => {
+    player.alignment = alignment;
+  });
+});
+
+// src/effects/handlers/character-change.ts
+var resolveCharacterId = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value) && typeof value[0] === "string") {
+    return value[0];
+  }
+  return void 0;
+};
+var applyCharacterChange = createEffectHandler("CHARACTER_CHANGE", ({
+  effect,
+  payloads,
+  effector,
+  writableInputs,
+  getSnapshotSeatMap,
+  characterMap,
+  makePlayersEffect
+}) => {
+  const resolvedCharacterId = resolveSourceValue(
+    effect.source,
+    writableInputs,
+    payloads,
+    effector,
+    getSnapshotSeatMap(),
+    (player) => player.characterId
+  );
+  const characterId = resolveCharacterId(resolvedCharacterId);
+  if (!characterId) {
+    console.warn("Character ID not found for CHARACTER_CHANGE effect:", effect.source);
+    return;
+  }
+  const newCharacter = characterMap.get(characterId);
+  if (!newCharacter) {
+    console.warn("Character not found for CHARACTER_CHANGE effect:", characterId);
+    return;
+  }
+  const abilityIds = newCharacter.abilities.map((ability) => ability.id);
+  makePlayersEffect.forEach((player) => {
+    player.characterId = newCharacter.id;
+    player.abilities = abilityIds;
+  });
+});
+
+// src/effects/handlers/character-count-change.ts
+var applyCharacterCountChange = createEffectHandler("CHARACTER_COUNT_CHANGE", () => {
+  console.warn("CHARACTER_COUNT_CHANGE effect handling not implemented yet.");
+});
+
+// src/effects/handlers/game-change.ts
+var applyGameChange = createEffectHandler("GAME_CHANGE", () => {
+  console.warn("GAME_CHANGE effect handling not implemented yet.");
+});
+
+// src/effects/handlers/perceived-character-change.ts
+var resolveCharacterId2 = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value) && typeof value[0] === "string") {
+    return value[0];
+  }
+  return void 0;
+};
+var applyPerceivedCharacterChange = createEffectHandler("PERCEIVED_CHARACTER_CHANGE", ({
+  effect,
+  payloads,
+  effector,
+  writableInputs,
+  getSnapshotSeatMap,
+  characterMap,
+  makePlayersEffect
+}) => {
+  const resolvedCharacterId = resolveSourceValue(
+    effect.source,
+    writableInputs,
+    payloads,
+    effector,
+    getSnapshotSeatMap(),
+    (player) => player.characterId
+  );
+  const characterId = resolveCharacterId2(resolvedCharacterId);
+  if (!characterId) {
+    console.warn("Character ID not found for PERCEIVED_CHARACTER_CHANGE effect:", effect.source);
+    return;
+  }
+  const newCharacter = characterMap.get(characterId);
+  if (!newCharacter) {
+    console.warn("Character not found for PERCEIVED_CHARACTER_CHANGE effect:", characterId);
+    return;
+  }
+  makePlayersEffect.forEach((player) => {
+    player.perceivedCharacter = {
+      characterId: newCharacter.id,
+      abilities: newCharacter.abilities.map((ability) => ability.id),
+      asCharacter: effect.followPriority || false
+    };
+  });
+});
+
+// src/effects/handlers/reminder-add.ts
+var applyReminderAdd = createEffectHandler("REMINDER_ADD", ({
+  effect,
+  payloads,
+  nowTimelineIndex,
+  operationInTimelineIdx,
+  makePlayersEffect
+}) => {
+  const maybeReminder = getSourceValue(effect.source, payloads);
+  if (!isReminder(maybeReminder)) {
+    console.warn("Invalid reminder data for REMINDER_ADD effect:", maybeReminder);
+    return;
+  }
+  const timelineDistance = nowTimelineIndex - operationInTimelineIdx;
+  if (typeof maybeReminder.duration === "number" && maybeReminder.duration > 0 && timelineDistance >= maybeReminder.duration) {
+    return;
+  }
+  makePlayersEffect.forEach((player) => {
+    if (!player.reminders) {
+      player.reminders = [];
+    }
+    player.reminders.push(maybeReminder);
+  });
+});
+
+// src/effects/handlers/reminder-remove.ts
+var applyReminderRemove = createEffectHandler("REMINDER_REMOVE", ({ effect, payloads, playerSeatMap }) => {
+  const maybeReminder = getSourceValue(effect.source, payloads);
+  if (!isPlayerReminderArray(maybeReminder)) {
+    console.warn("Invalid reminder data for REMINDER_REMOVE effect:", maybeReminder);
+    return;
+  }
+  maybeReminder.sort((left, right) => right.index - left.index).forEach((reminder) => {
+    const player = playerSeatMap.get(reminder.playerSeat);
+    if (!player) {
+      console.warn("Player not found for REMINDER_REMOVE effect:", reminder.playerSeat);
+      return;
+    }
+    if (!player.reminders) {
+      player.reminders = [];
+    }
+    player.reminders = player.reminders.filter((_value, index) => index !== reminder.index);
+  });
+});
+
+// src/effects/handlers/seat-change.ts
+var applySeatChange = createEffectHandler("SEAT_CHANGE", () => {
+  console.warn("SEAT_CHANGE effect handling not implemented yet.");
+});
+
+// src/effects/handlers/status-change.ts
+var applyStatusChange = createEffectHandler("STATUS_CHANGE", ({ effect, payloads, makePlayersEffect }) => {
+  const maybeStatus = getSourceValue(effect.source, payloads);
+  if (maybeStatus === "DEAD") {
+    makePlayersEffect.forEach((player) => {
+      player.isDead = true;
+    });
+    return;
+  }
+  if (maybeStatus === "ALIVE") {
+    makePlayersEffect.forEach((player) => {
+      player.isDead = false;
+    });
+    return;
+  }
+  console.warn("Invalid status value for STATUS_CHANGE effect:", maybeStatus);
+});
+
+// src/effects/registry.ts
+var effectHandlers = {
+  ABILITY_CHANGE: applyAbilityChange,
+  ALIGNMENT_CHANGE: applyAlignmentChange,
+  CHARACTER_CHANGE: applyCharacterChange,
+  CHARACTER_COUNT_CHANGE: applyCharacterCountChange,
+  GAME_CHANGE: applyGameChange,
+  PERCEIVED_CHARACTER_CHANGE: applyPerceivedCharacterChange,
+  REMINDER_ADD: applyReminderAdd,
+  REMINDER_REMOVE: applyReminderRemove,
+  SEAT_CHANGE: applySeatChange,
+  STATUS_CHANGE: applyStatusChange
+};
+
+// src/effects/resolve-targets.ts
+var isPayloadRef = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  if (candidate.from !== "PAYLOAD") {
+    return false;
+  }
+  return typeof candidate.value === "number" || Array.isArray(candidate.value);
+};
+var resolveDynamicValue = (value, payloads, isExpected) => {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (!isPayloadRef(value)) {
+    return isExpected(value) ? value : void 0;
+  }
+  const resolved = getValueFromPayloads(payloads, value.value);
+  if (!isExpected(resolved)) {
+    return void 0;
+  }
+  return resolved;
+};
+var getSortedPlayers = (playerSeatMap) => {
+  return [...playerSeatMap.values()].sort((left, right) => left.seat - right.seat);
+};
+var getCircularDistance = (anchorIdx, targetIdx, total) => {
+  const clockwise = (targetIdx - anchorIdx + total) % total;
+  const anticlockwise = (anchorIdx - targetIdx + total) % total;
+  return Math.min(clockwise, anticlockwise);
+};
+var getAnchorSeat = (dynamicTarget, payloads, effector) => {
+  const anchor = dynamicTarget.anchor;
+  if (!anchor || anchor.from === "EFFECTOR") {
+    return effector?.seat;
+  }
+  if (anchor.from === "STATIC") {
+    return anchor.value;
+  }
+  const payloadSeat = getValueFromPayloads(payloads, anchor.value);
+  return typeof payloadSeat === "number" ? payloadSeat : void 0;
+};
+var resolveSelectorScope = (dynamicTarget, payloads) => {
+  return resolveDynamicValue(
+    dynamicTarget.selector?.scope,
+    payloads,
+    (value) => value === "BOTH_SIDES" || value === "LEFT_SIDE" || value === "RIGHT_SIDE"
+  ) ?? "BOTH_SIDES";
+};
+var getCandidatesBySelector = (dynamicTarget, sortedPlayers, anchorSeat, payloads) => {
+  const selector = dynamicTarget.selector;
+  if (!selector) {
+    return sortedPlayers;
+  }
+  const scope = resolveSelectorScope(dynamicTarget, payloads);
+  if (!anchorSeat) {
+    return [];
+  }
+  const anchorIdx = sortedPlayers.findIndex((player) => player.seat === anchorSeat);
+  if (anchorIdx < 0) {
+    return [];
+  }
+  const total = sortedPlayers.length;
+  if (scope === "LEFT_SIDE") {
+    const left2 = [];
+    for (let step = 1; step < total; step += 1) {
+      left2.push(sortedPlayers[(anchorIdx - step + total) % total]);
+    }
+    return left2;
+  }
+  if (scope === "RIGHT_SIDE") {
+    const right2 = [];
+    for (let step = 1; step < total; step += 1) {
+      right2.push(sortedPlayers[(anchorIdx + step) % total]);
+    }
+    return right2;
+  }
+  const left = [];
+  const right = [];
+  for (let step = 1; step < total; step += 1) {
+    left.push(sortedPlayers[(anchorIdx - step + total) % total]);
+    right.push(sortedPlayers[(anchorIdx + step) % total]);
+  }
+  return [...left, ...right];
+};
+var matchesCondition = (player, condition, payloads, characterMap) => {
+  if (condition.field === "IS_DEAD") {
+    const expected = resolveDynamicValue(condition.value, payloads, (value) => typeof value === "boolean");
+    if (typeof expected !== "boolean") {
+      return false;
+    }
+    return Boolean(player.isDead) === expected;
+  }
+  if (condition.field === "SEAT") {
+    if (condition.operator === "IN") {
+      const expectedSeats = resolveDynamicValue(condition.value, payloads, (value) => Array.isArray(value) && value.every((item) => typeof item === "number"));
+      return Array.isArray(expectedSeats) && expectedSeats.includes(player.seat);
+    }
+    const expectedSeat = resolveDynamicValue(condition.value, payloads, (value) => typeof value === "number");
+    return typeof expectedSeat === "number" && player.seat === expectedSeat;
+  }
+  const character = characterMap.get(player.characterId);
+  const kind = character?.kind;
+  if (!kind) {
+    return false;
+  }
+  if (condition.operator === "IN") {
+    const expectedKinds = resolveDynamicValue(condition.value, payloads, (value) => Array.isArray(value) && value.every((item) => typeof item === "string"));
+    return Array.isArray(expectedKinds) && expectedKinds.includes(kind);
+  }
+  const expectedKind = resolveDynamicValue(condition.value, payloads, (value) => typeof value === "string");
+  return typeof expectedKind === "string" && kind === expectedKind;
+};
+var filterByWhere = (candidates, dynamicTarget, payloads, characterMap) => {
+  const where = dynamicTarget.where;
+  const conditions = where?.conditions ?? [];
+  if (conditions.length === 0) {
+    return candidates;
+  }
+  const isAllMode = where?.mode !== "ANY";
+  return candidates.filter((player) => {
+    const results = conditions.map((condition) => matchesCondition(player, condition, payloads, characterMap));
+    return isAllMode ? results.every(Boolean) : results.some(Boolean);
+  });
+};
+var applySort = (candidates, dynamicTarget, payloads, sortedPlayers, anchorSeat) => {
+  const scope = resolveSelectorScope(dynamicTarget, payloads);
+  if (scope !== "BOTH_SIDES") {
+    return [...candidates];
+  }
+  if (!anchorSeat || sortedPlayers.length <= 1) {
+    return [...candidates].sort((left, right) => left.seat - right.seat);
+  }
+  const seatIndexMap = new Map(sortedPlayers.map((player, idx) => [player.seat, idx]));
+  const anchorIdx = seatIndexMap.get(anchorSeat);
+  if (typeof anchorIdx !== "number") {
+    return [...candidates].sort((left, right) => left.seat - right.seat);
+  }
+  return [...candidates].sort((left, right) => {
+    const leftIdx = seatIndexMap.get(left.seat);
+    const rightIdx = seatIndexMap.get(right.seat);
+    if (typeof leftIdx !== "number" || typeof rightIdx !== "number") {
+      return left.seat - right.seat;
+    }
+    const leftDistance = getCircularDistance(anchorIdx, leftIdx, sortedPlayers.length);
+    const rightDistance = getCircularDistance(anchorIdx, rightIdx, sortedPlayers.length);
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
+    return left.seat - right.seat;
+  });
+};
+var pickTargets = (sortedCandidates, dynamicTarget, payloads) => {
+  const dedupedCandidates = [...new Map(sortedCandidates.map((player) => [player.seat, player])).values()];
+  const configuredLimit = resolveDynamicValue(dynamicTarget.limit, payloads, (value) => typeof value === "number");
+  if (typeof configuredLimit === "undefined") {
+    return dedupedCandidates;
+  }
+  if (configuredLimit <= 0) {
+    return [];
+  }
+  return dedupedCandidates.slice(0, configuredLimit);
+};
+var resolveEffectTargets = ({
+  effect,
+  operation,
+  payloads,
+  effector,
+  playerSeatMap,
+  characterMap
+}) => {
+  if (!("target" in effect)) {
+    return [];
+  }
+  if (effect.target.from === "EFFECTOR") {
+    if (!effector) {
+      console.warn("Effector player not found for operation:", operation, "effector index:", operation.effector);
+      return null;
+    }
+    return [effector];
+  }
+  if (effect.target.from === "PAYLOAD") {
+    const seatValue = getValueFromPayloads(payloads, effect.target.value);
+    if (typeof seatValue !== "number" && !Array.isArray(seatValue)) {
+      console.warn("Expected seat number or array of seat numbers from payloads, got:", seatValue);
+      return null;
+    }
+    const seats = Array.isArray(seatValue) ? seatValue : [seatValue];
+    return seats.map((seat) => playerSeatMap.get(seat)).filter((player) => Boolean(player));
+  }
+  if (effect.target.from === "DYNAMIC") {
+    const dynamicTarget = effect.target;
+    const sortedPlayers = getSortedPlayers(playerSeatMap);
+    const anchorSeat = getAnchorSeat(dynamicTarget, payloads, effector);
+    const candidates = getCandidatesBySelector(dynamicTarget, sortedPlayers, anchorSeat, payloads);
+    const filtered = filterByWhere(candidates, dynamicTarget, payloads, characterMap);
+    const ordered = applySort(filtered, dynamicTarget, payloads, sortedPlayers, anchorSeat);
+    return pickTargets(ordered, dynamicTarget, payloads);
+  }
+  return [];
+};
+
+// src/effects/evaluate-lifetime.ts
+var getLifetime = (effect) => {
+  if ("lifetime" in effect) {
+    return effect.lifetime;
+  }
+  return void 0;
+};
+var matchesLifetimeCondition = (player, condition, characterMap) => {
+  const { field, operator } = condition;
+  const value = condition.value;
+  if (field === "IS_DEAD") {
+    return Boolean(player.isDead) === Boolean(value);
+  }
+  if (field === "CHARACTER_ID") {
+    if (operator === "IN" && Array.isArray(value)) {
+      return value.includes(player.characterId);
+    }
+    return typeof value === "string" && player.characterId === value;
+  }
+  if (field === "CHARACTER_KIND") {
+    const kind = characterMap.get(player.characterId)?.kind;
+    if (!kind) return false;
+    if (operator === "IN" && Array.isArray(value)) {
+      return value.includes(kind);
+    }
+    return typeof value === "string" && kind === value;
+  }
+  if (field === "HAS_ABILITY") {
+    if (operator === "IN" && Array.isArray(value)) {
+      return value.some((id) => player.abilities.includes(id));
+    }
+    return typeof value === "string" && player.abilities.includes(value);
+  }
+  return false;
+};
+var evaluateConditions = (player, conditions, mode, characterMap) => {
+  if (!player) return false;
+  if (conditions.length === 0) return true;
+  const results = conditions.map((c) => matchesLifetimeCondition(player, c, characterMap));
+  return mode === "ALL" ? results.every(Boolean) : results.some(Boolean);
+};
+var evaluateLifetime = ({
+  effect,
+  operationTimelineIdx,
+  nowTimelineIndex,
+  timelines,
+  effector,
+  targets,
+  snapshotSeatMap,
+  characterMap
+}) => {
+  const lifetime = getLifetime(effect);
+  if (!lifetime || lifetime.kind === "PERMANENT") {
+    return targets;
+  }
+  if (lifetime.kind === "TURNS") {
+    const opTurn = operationTimelineIdx >= 0 ? timelines[operationTimelineIdx]?.turn : void 0;
+    const nowTurn = nowTimelineIndex >= 0 ? timelines[nowTimelineIndex]?.turn : void 0;
+    if (typeof opTurn !== "number" || typeof nowTurn !== "number") {
+      return targets;
+    }
+    return nowTurn - opTurn < lifetime.count ? targets : [];
+  }
+  if (lifetime.kind === "UNTIL_EVENT") {
+    if (operationTimelineIdx < 0) return targets;
+    for (let idx = operationTimelineIdx + 1; idx <= nowTimelineIndex; idx += 1) {
+      const tl = timelines[idx];
+      if (!tl) continue;
+      if (lifetime.event === "NEXT_DAY" && tl.time === "day") return [];
+      if (lifetime.event === "NEXT_NIGHT" && tl.time === "night") return [];
+      if (lifetime.event === "NEXT_EXECUTION" && (tl.nominations?.length ?? 0) > 0) return [];
+    }
+    return targets;
+  }
+  if (lifetime.kind === "WHILE") {
+    if (!snapshotSeatMap) {
+      return targets;
+    }
+    const subject = lifetime.subject ?? "EFFECTOR";
+    const mode = lifetime.mode ?? "ALL";
+    const conditions = lifetime.conditions ?? [];
+    if (subject === "EFFECTOR") {
+      const current = effector ? snapshotSeatMap.get(effector.seat) : void 0;
+      return evaluateConditions(current, conditions, mode, characterMap) ? targets : [];
+    }
+    return targets.filter((target) => {
+      const current = snapshotSeatMap.get(target.seat);
+      return evaluateConditions(current, conditions, mode, characterMap);
+    });
+  }
+  return targets;
+};
+
 // src/apply-operation.ts
+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 applyOperationToPlayers = ({
   players,
   operations,
@@ -136,7 +746,6 @@ var applyOperationToPlayers = ({
   const characterMap = new Map(characters.map((character) => [character.id, character]));
   const operationTimelineMap = /* @__PURE__ */ new Map();
   timelines.forEach((timeline, idx) => timeline.operations?.forEach((op) => operationTimelineMap.set(op, idx)));
-  const playersWithStatus = copyPlayers(players);
   const nowTimelineIndex = typeof timelineIndexAtNow === "number" ? timelineIndexAtNow : timelines.length - 1;
   const operationsByTimeline = /* @__PURE__ */ new Map();
   operations.forEach((operation) => {
@@ -146,216 +755,124 @@ var applyOperationToPlayers = ({
     }
     operationsByTimeline.get(timelineIndex)?.push(operation);
   });
-  const applyOps = (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 writableParts = ability.inputs.filter((part) => !part.readonly);
-      let snapshotSeatMap = null;
-      const getSnapshotSeatMap = () => {
-        if (!snapshotSeatMap) {
-          snapshotSeatMap = buildPlayerSeatMap(copyPlayers(playersWithStatus));
-        }
-        return snapshotSeatMap;
-      };
-      ability.effects.forEach((effect) => {
-        const makePlayersEffect = [];
-        if (effect.type === "GAME_CHANGE" || effect.type === "CHARACTER_COUNT_CHANGE") {
-          console.warn(effect.type + " effect handling not implemented yet.");
+  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;
         }
-        if (effect.target.from === "EFFECTOR") {
-          if (!effector) {
-            console.warn("Effector player not found for operation:", operation, "effector index:", operation.effector);
-            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));
           }
-          makePlayersEffect.push(effector);
-        } else if (effect.target.from === "PAYLOAD") {
-          const seatValue = getValueFromPayloads(payloads, effect.target.value);
-          if (typeof seatValue !== "number" && !Array.isArray(seatValue)) {
-            console.warn("Expected seat number or array of seat numbers from payloads, got:", seatValue);
+          return snapshotSeatMap;
+        };
+        ability.effects.forEach((effect) => {
+          const resolvedTargets = resolveEffectTargets({
+            effect,
+            operation,
+            payloads,
+            effector,
+            playerSeatMap,
+            characterMap
+          });
+          if (!resolvedTargets) {
             return;
           }
-          const seats = Array.isArray(seatValue) ? seatValue : [seatValue];
-          seats.forEach((seat) => {
-            const player = playerSeatMap.get(seat);
-            if (player) {
-              makePlayersEffect.push(player);
-            }
+          const makePlayersEffect = evaluateLifetime({
+            effect,
+            operationTimelineIdx: operationInTimelineIdx,
+            nowTimelineIndex,
+            timelines,
+            effector,
+            targets: resolvedTargets,
+            snapshotSeatMap: lifetimeSnapshotSeatMap,
+            characterMap
           });
-        } else if (effect.target.from === "CUSTOM") {
-          console.warn("Custom target handling not implemented yet.");
-        }
-        switch (effect.type) {
-          case "ABILITY_CHANGE": {
-            console.warn("ABILITY_CHANGE effect handling not implemented yet.");
-            break;
-          }
-          case "ALIGNMENT_CHANGE": {
-            const resolved = resolveSourceValue(
-              effect.source,
-              writableParts,
-              payloads,
-              effector,
-              getSnapshotSeatMap(),
-              (player) => player.alignment
-            );
-            let alignment;
-            if (resolved === "GOOD" || resolved === "EVIL") {
-              alignment = resolved;
-            }
-            if (!alignment) {
-              console.warn("Alignment not found for ALIGNMENT_CHANGE effect:", effect.source);
-              return;
-            }
-            makePlayersEffect.forEach((player) => {
-              player.alignment = alignment;
-            });
-            break;
-          }
-          case "CHARACTER_CHANGE":
-          case "PERCEIVED_CHARACTER_CHANGE": {
-            const resolvedCharacterId = resolveSourceValue(
-              effect.source,
-              writableParts,
-              payloads,
-              effector,
-              getSnapshotSeatMap(),
-              (player) => player.characterId
-            );
-            let characterId;
-            if (typeof resolvedCharacterId === "string") {
-              characterId = resolvedCharacterId;
-            } else if (Array.isArray(resolvedCharacterId) && typeof resolvedCharacterId[0] === "string") {
-              characterId = resolvedCharacterId[0];
-            }
-            if (!characterId) {
-              console.warn("Character ID not found for " + effect.type + " effect:", effect.source);
-              return;
-            }
-            const newCharacter = characterMap.get(characterId);
-            if (!newCharacter) {
-              console.warn("Character not found for " + effect.type + " effect:", characterId);
-              return;
-            }
-            if (effect.type === "CHARACTER_CHANGE") {
-              const abilityIds = newCharacter.abilities.map((ability2) => ability2.id);
-              makePlayersEffect.forEach((player) => {
-                player.characterId = newCharacter.id;
-                player.abilities = abilityIds;
-              });
-            } else {
-              makePlayersEffect.forEach((player) => {
-                player.perceivedCharacter = {
-                  characterId: newCharacter.id,
-                  abilities: newCharacter.abilities.map((ability2) => ability2.id),
-                  asCharacter: effect.followPriority || false
-                };
-              });
-            }
-            break;
-          }
-          case "REMINDER_ADD": {
-            const maybeReminder = getSourceValue(effect.source, payloads);
-            if (!isReminder(maybeReminder)) {
-              console.warn("Invalid reminder data for REMINDER_ADD effect:", maybeReminder);
-              return;
-            }
-            const timelineDistance = nowTimelineIndex - operationInTimelineIdx;
-            if (typeof maybeReminder.duration === "number" && maybeReminder.duration > 0 && timelineDistance >= maybeReminder.duration) {
-              break;
-            }
-            makePlayersEffect.forEach((player) => {
-              if (!player.reminders) {
-                player.reminders = [];
-              }
-              player.reminders.push(maybeReminder);
-            });
-            break;
-          }
-          case "REMINDER_REMOVE": {
-            const maybeReminder = getSourceValue(effect.source, payloads);
-            if (!isPlayerReminderArray(maybeReminder)) {
-              console.warn("Invalid reminder data for REMINDER_REMOVE effect:", maybeReminder);
-              return;
-            }
-            maybeReminder.sort((left, right) => right.index - left.index).forEach((reminder) => {
-              const player = playerSeatMap.get(reminder.playerSeat);
-              if (!player) {
-                console.warn("Player not found for REMINDER_REMOVE effect:", reminder.playerSeat);
-                return;
-              }
-              if (!player.reminders) {
-                player.reminders = [];
-              }
-              player.reminders = player.reminders.filter((_value, index) => index !== reminder.index);
-            });
-            break;
-          }
-          case "SEAT_CHANGE": {
-            console.warn("SEAT_CHANGE effect handling not implemented yet.");
-            break;
-          }
-          case "STATUS_CHANGE": {
-            const maybeStatus = getSourceValue(effect.source, payloads);
-            if (maybeStatus === "DEAD") {
-              makePlayersEffect.forEach((player) => {
-                player.isDead = true;
-              });
-            } else if (maybeStatus === "ALIVE") {
-              makePlayersEffect.forEach((player) => {
-                player.isDead = false;
-              });
-            } else {
-              console.warn("Invalid status value for STATUS_CHANGE effect:", maybeStatus);
-            }
-            break;
-          }
-          default: {
+          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 settingsOps = operationsByTimeline.get(-1);
-  if (settingsOps) {
-    applyOps(settingsOps);
-  }
-  for (let i = 0; i <= nowTimelineIndex; i += 1) {
-    const timeline = timelines[i];
-    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) {
+    };
+    const applyOps = (ops) => {
+      const normalOps = [];
+      const deferredOps = [];
+      ops.forEach((operation) => {
+        if (isDeferredOperation(operation, abilityMap)) {
+          deferredOps.push(operation);
           return;
         }
-        voterSeats.forEach((seat) => {
-          const player = playerSeatMap.get(seat);
-          if (player && player.isDead && !player.hasUsedDeadVote) {
-            player.hasUsedDeadVote = true;
-          }
-        });
+        normalOps.push(operation);
       });
+      applyOpsSequence(normalOps);
+      applyOpsSequence(deferredOps);
+    };
+    const settingsOps = operationsByTimeline.get(-1);
+    if (settingsOps) {
+      applyOps(settingsOps);
     }
-    const timelineOps = operationsByTimeline.get(i);
-    if (timelineOps) {
-      applyOps(timelineOps);
+    for (let i = 0; i <= nowTimelineIndex; i += 1) {
+      const timeline = timelines[i];
+      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;
+          }
+          voterSeats.forEach((seat) => {
+            const player = playerSeatMap.get(seat);
+            if (player && player.isDead && !player.hasUsedDeadVote) {
+              player.hasUsedDeadVote = true;
+            }
+          });
+        });
+      }
+      const timelineOps = operationsByTimeline.get(i);
+      if (timelineOps) {
+        applyOps(timelineOps);
+      }
     }
+    return playersWithStatus;
+  };
+  if (!hasGatedLifetime(allAbilities)) {
+    return transformEmptyArray(runReplay(null));
   }
-  return transformEmptyArray(playersWithStatus);
+  const groundTruth = runReplay(null);
+  const groundTruthSeatMap = buildPlayerSeatMap(groundTruth);
+  const final = runReplay(groundTruthSeatMap);
+  return transformEmptyArray(final);
 };
 export {
   adjustValueAsNumber,