@bct-app/game-engine 0.1.8 → 0.1.10

package/dist/index.js

@@ -26,12 +26,14 @@ __export(index_exports, {
   buildPlayerSeatMap: () => buildPlayerSeatMap,
   canInvokeAbility: () => canInvokeAbility,
   copyPlayers: () => copyPlayers,
+  deriveContext: () => deriveContext,
   getSourceValue: () => getSourceValue,
   getValueFromPayloads: () => getValueFromPayloads,
   isNumberOrNumberArray: () => isNumberOrNumberArray,
   isPlayerReminderArray: () => isPlayerReminderArray,
   isReminder: () => isReminder,
   resolveSourceValue: () => resolveSourceValue,
+  resolveTargetRef: () => resolveTargetRef,
   transformEmptyArray: () => transformEmptyArray
 });
 module.exports = __toCommonJS(index_exports);
@@ -177,6 +179,47 @@ var resolveSourceValue = (source, writableInputs, payloads, effector, snapshotSe
   }
   return void 0;
 };
+var resolveTargetRef = ({
+  ref,
+  players,
+  effectorSeat,
+  characterMap
+}) => {
+  if (ref.ref === "ANY") return players;
+  if (ref.ref === "EFFECTOR") {
+    if (effectorSeat === void 0) return [];
+    return players.filter((p) => p.seat === effectorSeat);
+  }
+  if (ref.ref === "ROLE") {
+    return players.filter((p) => p.characterId === ref.characterId);
+  }
+  if (ref.ref === "KIND") {
+    if (!characterMap) return [];
+    return players.filter((p) => characterMap.get(p.characterId)?.kind === ref.kind);
+  }
+  if (ref.ref === "ALIGNMENT") {
+    return players.filter((p) => p.alignment === ref.alignment);
+  }
+  if (ref.ref === "NEIGHBOR") {
+    if (effectorSeat === void 0 || players.length === 0) return [];
+    const alive = players.filter((p) => !p.isDead).sort((a, b) => a.seat - b.seat);
+    if (alive.length === 0) return [];
+    const idx = alive.findIndex((p) => p.seat === effectorSeat);
+    if (idx < 0) return [];
+    const left = alive[(idx - 1 + alive.length) % alive.length];
+    const right = alive[(idx + 1) % alive.length];
+    if (ref.side === "LEFT") return left ? [left] : [];
+    if (ref.side === "RIGHT") return right ? [right] : [];
+    const both = [left, right].filter((p) => Boolean(p));
+    const seen = /* @__PURE__ */ new Set();
+    return both.filter((p) => {
+      if (seen.has(p.seat)) return false;
+      seen.add(p.seat);
+      return true;
+    });
+  }
+  return [];
+};
 
 // src/effects/handler-types.ts
 var createEffectHandler = (type, handler) => {
@@ -434,17 +477,31 @@ var applySeatChange = createEffectHandler("SEAT_CHANGE", () => {
 });
 
 // src/effects/handlers/status-change.ts
-var applyStatusChange = createEffectHandler("STATUS_CHANGE", ({ effect, payloads, makePlayersEffect }) => {
+var applyStatusChange = createEffectHandler("STATUS_CHANGE", ({
+  effect,
+  payloads,
+  makePlayersEffect,
+  operationInTimelineIdx,
+  abilityMap,
+  operation
+}) => {
   const maybeStatus = getSourceValue(effect.source, payloads);
   if (maybeStatus === "DEAD") {
+    const ability = abilityMap.get(operation.abilityId);
+    const turn = operationInTimelineIdx >= 0 ? operationInTimelineIdx : 0;
+    const cause = effect.deathCause ?? (ability?.category === "STORYTELLER" ? "STORYTELLER" : "ABILITY");
     makePlayersEffect.forEach((player) => {
       player.isDead = true;
+      player.deathCause = cause;
+      player.deathTurn = turn;
     });
     return;
   }
   if (maybeStatus === "ALIVE") {
     makePlayersEffect.forEach((player) => {
       player.isDead = false;
+      delete player.deathCause;
+      delete player.deathTurn;
     });
     return;
   }
@@ -532,22 +589,22 @@ var getCandidatesBySelector = (dynamicTarget, sortedPlayers, anchorSeat, payload
   if (scope === "LEFT_SIDE") {
     const left2 = [];
     for (let step = 1; step < total; step += 1) {
-      left2.push(sortedPlayers[(anchorIdx - step + total) % total]);
+      left2.push(sortedPlayers[(anchorIdx + step) % total]);
     }
     return left2;
   }
   if (scope === "RIGHT_SIDE") {
     const right2 = [];
     for (let step = 1; step < total; step += 1) {
-      right2.push(sortedPlayers[(anchorIdx + step) % total]);
+      right2.push(sortedPlayers[(anchorIdx - step + total) % 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]);
+    left.push(sortedPlayers[(anchorIdx + step) % total]);
+    right.push(sortedPlayers[(anchorIdx - step + total) % total]);
   }
   return [...left, ...right];
 };
@@ -1133,105 +1190,17 @@ var applyOperationToPlayers = ({
 };
 
 // src/can-invoke-ability.ts
-var PHASE_ALIASES = {
-  NIGHT: "night",
-  DAY: "day"
-};
-var checkTurns = (turns, currentTurn) => {
-  if (turns.only && turns.only.length > 0 && !turns.only.includes(currentTurn)) {
-    return `turn ${currentTurn} not in allowed turns ${JSON.stringify(turns.only)}`;
-  }
-  if (typeof turns.from === "number" && currentTurn < turns.from) {
-    return `turn ${currentTurn} is before allowed start turn ${turns.from}`;
-  }
-  if (typeof turns.to === "number" && currentTurn > turns.to) {
-    return `turn ${currentTurn} is after allowed end turn ${turns.to}`;
-  }
-  return null;
-};
-var checkEffectorState = (state, effector) => {
-  if (state === "ANY") return null;
-  if (state === "ALIVE") {
-    if (!effector || effector.isDead) return "effector is not alive";
-    return null;
-  }
-  if (state === "DEAD") {
-    if (!effector || !effector.isDead) return "effector is not dead";
-    return null;
-  }
-  return null;
+var TIME_TO_PHASE = {
+  night: "NIGHT",
+  day: "DAY"
 };
-var isFirstPhaseForEffector = (timelines, currentIdx, phaseTime) => {
-  for (let i = 0; i < currentIdx; i++) {
-    if (timelines[i]?.time === phaseTime) return false;
-  }
+var checkTurnRange = (range, turn) => {
+  if (!range) return true;
+  if (range.only && range.only.length > 0 && !range.only.includes(turn)) return false;
+  if (typeof range.from === "number" && turn < range.from) return false;
+  if (typeof range.to === "number" && turn > range.to) return false;
   return true;
 };
-var checkPhaseTrigger = (trigger, timelines, currentIdx) => {
-  const expected = PHASE_ALIASES[trigger.phase];
-  const current = timelines[currentIdx]?.time;
-  if (!expected) {
-    return `phase ${trigger.phase} not yet supported in timeline model`;
-  }
-  if (expected !== current) {
-    return `phase ${current} does not match required ${trigger.phase}`;
-  }
-  const occurrence = trigger.occurrence ?? "EVERY";
-  if (occurrence === "EVERY") return null;
-  const isFirst = isFirstPhaseForEffector(timelines, currentIdx, expected);
-  if (occurrence === "FIRST_ONLY" && !isFirst) {
-    return `phase ${trigger.phase} occurrence FIRST_ONLY but this is not the first`;
-  }
-  if (occurrence === "EXCEPT_FIRST" && isFirst) {
-    return `phase ${trigger.phase} occurrence EXCEPT_FIRST but this is the first`;
-  }
-  return null;
-};
-var subjectMatches = (filter, seat, effectorSeat, players) => {
-  if (filter.match === "ANY") return true;
-  if (filter.match === "EFFECTOR") {
-    return seat !== void 0 && seat === effectorSeat;
-  }
-  if (filter.match === "NEIGHBOR_OF_EFFECTOR") {
-    if (seat === void 0 || effectorSeat === void 0 || !players?.length) return false;
-    const alive = players.filter((p) => !p.isDead).sort((a, b) => a.seat - b.seat);
-    const idx = alive.findIndex((p) => p.seat === effectorSeat);
-    if (idx < 0) return false;
-    const left = alive[(idx - 1 + alive.length) % alive.length]?.seat;
-    const right = alive[(idx + 1) % alive.length]?.seat;
-    return seat === left || seat === right;
-  }
-  if (filter.match === "ROLE") {
-    const player = players?.find((p) => p.seat === seat);
-    return !!player && filter.roles.includes(player.characterId);
-  }
-  if (filter.match === "KIND") {
-    return false;
-  }
-  if (filter.match === "ALIGNMENT") {
-    const player = players?.find((p) => p.seat === seat);
-    if (!player?.alignment) return false;
-    const want = filter.value === "good" ? "GOOD" : "EVIL";
-    return player.alignment === want;
-  }
-  return false;
-};
-var checkEventTrigger = (trigger, event, effectorSeat, players, currentTime) => {
-  if (!event) return "event trigger requires event context";
-  if (event.event !== trigger.event) return `event ${event.event} does not match required ${trigger.event}`;
-  if (trigger.phase) {
-    const expected = PHASE_ALIASES[trigger.phase];
-    if (!expected) return `phase ${trigger.phase} not yet supported in timeline model`;
-    if (expected !== currentTime) return `phase ${currentTime} does not match required ${trigger.phase}`;
-  }
-  if (trigger.target && !subjectMatches(trigger.target, event.targetSeat, effectorSeat, players)) {
-    return `event target does not match filter ${trigger.target.match}`;
-  }
-  if (trigger.actor && !subjectMatches(trigger.actor, event.actorSeat, effectorSeat, players)) {
-    return `event actor does not match filter ${trigger.actor.match}`;
-  }
-  return null;
-};
 var compareCount2 = (actual, operator, expected) => {
   switch (operator) {
     case "<":
@@ -1248,149 +1217,256 @@ var compareCount2 = (actual, operator, expected) => {
       return actual !== expected;
   }
 };
-var countExecutionsToday = (timelines, currentIdx) => {
-  const turn = timelines[currentIdx]?.turn;
-  if (typeof turn !== "number") return 0;
-  let count = 0;
-  for (const tl of timelines) {
-    if (tl.turn !== turn || tl.time !== "day") continue;
-    for (const op of tl.operations ?? []) {
-      if (op.kind === "execution") count++;
-    }
+var isFirstOfPhase = (timelines, lastIdx) => {
+  const last = timelines[lastIdx];
+  if (!last) return false;
+  for (let i = 0; i < lastIdx; i++) {
+    if (timelines[i]?.time === last.time) return false;
   }
-  return count;
+  return true;
 };
-var checkCondition = (condition, args) => {
-  const { timelines, currentIdx, players, event, customConditionResolver } = args;
-  if (condition.kind === "PLAYER_COUNT") {
-    if (!players) return `condition ${condition.kind} needs players`;
-    const turn = timelines[currentIdx]?.turn;
-    let actual = 0;
-    if (condition.subject === "ALIVE") actual = players.filter((p) => !p.isDead).length;
-    else if (condition.subject === "DEAD") actual = players.filter((p) => p.isDead).length;
-    else if (condition.subject === "EXECUTED_TODAY") actual = countExecutionsToday(timelines, currentIdx);
-    else if (condition.subject === "NOMINATED_TODAY") {
-      actual = timelines.filter((tl) => tl.turn === turn && tl.time === "day").reduce((acc, tl) => acc + (tl.nominations?.length ?? 0), 0);
-    }
-    if (!compareCount2(actual, condition.operator, condition.value)) {
-      return `condition PLAYER_COUNT ${condition.subject} ${condition.operator} ${condition.value} (actual ${actual})`;
-    }
-    return null;
+var deriveContext = ({
+  timelines,
+  candidate,
+  initialPlayers,
+  allAbilities,
+  characters
+}) => {
+  const lastIdx = timelines.length - 1;
+  const last = timelines[lastIdx];
+  if (!last) {
+    return { error: "timelines must contain at least one entry" };
+  }
+  const players = applyOperationToPlayers({
+    players: initialPlayers,
+    operations: timelines.flatMap((tl) => tl.operations ?? []),
+    allAbilities,
+    characters,
+    timelines,
+    timelineIndexAtNow: lastIdx
+  });
+  const effector = players.find((p) => p.seat === candidate.effector);
+  const operationTurnMap = /* @__PURE__ */ new Map();
+  const operationTimeMap = /* @__PURE__ */ new Map();
+  timelines.forEach((tl) => {
+    tl.operations?.forEach((op) => {
+      operationTurnMap.set(op, tl.turn);
+      operationTimeMap.set(op, tl.time);
+    });
+  });
+  const allOperations = timelines.flatMap((tl) => tl.operations ?? []);
+  const todayOperations = timelines.filter((tl) => tl.turn === last.turn && tl.time === "day").flatMap((tl) => tl.operations ?? []);
+  const tonightOperations = timelines.filter((tl) => tl.turn === last.turn && tl.time === "night").flatMap((tl) => tl.operations ?? []);
+  const yesterdayDayOperations = timelines.filter((tl) => tl.turn === last.turn - 1 && tl.time === "day").flatMap((tl) => tl.operations ?? []);
+  const yesterdayNightOperations = timelines.filter((tl) => tl.turn === last.turn - 1 && tl.time === "night").flatMap((tl) => tl.operations ?? []);
+  const todayNominations = timelines.filter((tl) => tl.turn === last.turn && tl.time === "day").flatMap((tl) => tl.nominations ?? []).map((n) => ({ nominator: n.nominator, nominee: n.nominee }));
+  return {
+    currentTurn: last.turn,
+    currentPhase: TIME_TO_PHASE[last.time],
+    isFirstOfPhase: isFirstOfPhase(timelines, lastIdx),
+    players,
+    allOperations,
+    todayOperations,
+    tonightOperations,
+    yesterdayDayOperations,
+    yesterdayNightOperations,
+    todayNominations,
+    effectorSeat: candidate.effector,
+    effector,
+    abilityId: candidate.abilityId,
+    characterMap: new Map(characters.map((c) => [c.id, c])),
+    operationTurnMap,
+    operationTimeMap
+  };
+};
+var operationsForActionScope = (scope, ctx) => {
+  if (scope === "TONIGHT") return ctx.tonightOperations;
+  if (scope === "TODAY") return ctx.todayOperations;
+  if (scope === "YESTERDAY") {
+    return [...ctx.yesterdayDayOperations, ...ctx.yesterdayNightOperations];
   }
-  if (condition.kind === "NO_EXECUTION_TODAY") {
-    return countExecutionsToday(timelines, currentIdx) > 0 ? "condition NO_EXECUTION_TODAY violated" : null;
+  return ctx.allOperations;
+};
+var seatsMatchingTargetRef = (ref, ctx) => {
+  const matched = resolveTargetRef({
+    ref,
+    players: ctx.players,
+    effectorSeat: ctx.effectorSeat,
+    characterMap: ctx.characterMap
+  });
+  return new Set(matched.map((p) => p.seat));
+};
+var evalAtomTime = (atom, ctx) => {
+  if (atom.phase !== ctx.currentPhase) {
+    return `phase is ${ctx.currentPhase}, required ${atom.phase}`;
   }
-  if (condition.kind === "EFFECTOR_HAS_STATUS") {
-    if (!customConditionResolver) return null;
-    const matched = customConditionResolver({ key: `STATUS:${condition.status}`, value: !condition.negate });
-    return matched ? null : `condition EFFECTOR_HAS_STATUS ${condition.status} unsatisfied`;
+  if (atom.occurrence === "FIRST" && !ctx.isFirstOfPhase) {
+    return `expected FIRST occurrence of ${atom.phase} but is not the first`;
   }
-  if (condition.kind === "EVENT_PAYLOAD") {
-    const payloadValue = event?.payload?.[condition.key];
-    if (payloadValue !== condition.value) {
-      return `condition EVENT_PAYLOAD ${condition.key}=${JSON.stringify(condition.value)} (actual ${JSON.stringify(payloadValue)})`;
+  if (atom.occurrence === "EXCEPT_FIRST" && ctx.isFirstOfPhase) {
+    return `expected EXCEPT_FIRST occurrence of ${atom.phase} but is the first`;
+  }
+  if (!checkTurnRange(atom.turns, ctx.currentTurn)) {
+    return `turn ${ctx.currentTurn} not in allowed turn range`;
+  }
+  return null;
+};
+var evalAtomState = (atom, ctx) => {
+  const seats = seatsMatchingTargetRef(atom.subject, ctx);
+  if (seats.size === 0) return `no players match subject ${atom.subject.ref}`;
+  for (const seat of seats) {
+    const player = ctx.players.find((p) => p.seat === seat);
+    if (!player) continue;
+    const isDead = Boolean(player.isDead);
+    if (atom.aliveness === "ALIVE" && isDead) continue;
+    if (atom.aliveness === "DEAD" && !isDead) continue;
+    if (atom.aliveness === "DEAD") {
+      if (atom.deathCause && player.deathCause !== atom.deathCause) continue;
+      if (atom.deathTurn && !checkTurnRange(atom.deathTurn, player.deathTurn ?? -1)) continue;
     }
     return null;
   }
-  if (condition.kind === "CUSTOM") {
-    if (!customConditionResolver) return null;
-    return customConditionResolver({ key: condition.key, value: condition.value }) ? null : `condition CUSTOM ${condition.key} unsatisfied`;
+  return `no subject in ${atom.subject.ref} satisfies aliveness=${atom.aliveness}`;
+};
+var evalAtomAction = (atom, ctx) => {
+  const subjectSeats = seatsMatchingTargetRef(atom.subject, ctx);
+  if (subjectSeats.size === 0) return `no players match subject ${atom.subject.ref}`;
+  const actorSeats = atom.actor ? seatsMatchingTargetRef(atom.actor, ctx) : null;
+  if (atom.action === "NOMINATED") {
+    const noms = ctx.todayNominations;
+    const found = noms.some(
+      (n) => subjectSeats.has(n.nominee) && (actorSeats === null || actorSeats.has(n.nominator))
+    );
+    return found ? null : "no matching NOMINATED event in today";
+  }
+  const scoped = operationsForActionScope(atom.scope, ctx);
+  if (atom.action === "CHOSEN_AS_TARGET") {
+    const found = scoped.some((op) => {
+      if (actorSeats !== null && !actorSeats.has(op.effector)) return false;
+      const payloadSeats = (op.payloads ?? []).flatMap(
+        (v) => typeof v === "number" ? [v] : Array.isArray(v) ? v.filter((x) => typeof x === "number") : []
+      );
+      return payloadSeats.some((s) => subjectSeats.has(s));
+    });
+    return found ? null : "no matching CHOSEN_AS_TARGET in scope";
   }
-  return null;
+  const turnsInScope = (() => {
+    if (atom.scope === "TONIGHT" || atom.scope === "TODAY") return [ctx.currentTurn];
+    if (atom.scope === "YESTERDAY") return [ctx.currentTurn - 1];
+    return null;
+  })();
+  const turnInScope = (turn) => {
+    if (typeof turn !== "number") return false;
+    if (turnsInScope === null) return true;
+    return turnsInScope.includes(turn);
+  };
+  if (atom.action === "KILLED") {
+    for (const seat of subjectSeats) {
+      const player = ctx.players.find((p) => p.seat === seat);
+      if (!player?.isDead) continue;
+      if (!turnInScope(player.deathTurn)) continue;
+      return null;
+    }
+    return "no matching KILLED in scope";
+  }
+  if (atom.action === "EXECUTED") {
+    for (const seat of subjectSeats) {
+      const player = ctx.players.find((p) => p.seat === seat);
+      if (!player?.isDead) continue;
+      if (player.deathCause !== "EXECUTION") continue;
+      if (!turnInScope(player.deathTurn)) continue;
+      return null;
+    }
+    return "no matching EXECUTED in scope";
+  }
+  void scoped;
+  return `unknown action ${atom.action}`;
 };
-var countMatchingPriorOps = (priorOperations, abilityId, effectorSeat, operationTimelineMap, matchTurn, matchTime, timelines, countAcrossEffectors) => {
-  return priorOperations.filter((op) => {
-    if (op.abilityId !== abilityId) return false;
-    if (!countAcrossEffectors && typeof effectorSeat === "number" && op.effector !== effectorSeat) return false;
-    if (matchTurn === null && matchTime === null) return true;
-    const idx = operationTimelineMap.get(op);
-    if (typeof idx !== "number") return false;
-    const tl = timelines[idx];
-    if (!tl) return false;
-    if (matchTurn !== null && tl.turn !== matchTurn) return false;
-    if (matchTime !== null && tl.time !== matchTime) return false;
+var evalAtomCount = (atom, ctx) => {
+  const ops = atom.scope === "GAME" ? ctx.allOperations : atom.scope === "NIGHT" ? ctx.tonightOperations : ctx.todayOperations;
+  let resetTurn = -1;
+  let resetTime = null;
+  if (atom.resetOn?.length && ctx.effector?.isDead && atom.resetOn.includes("DEATH")) {
+    resetTurn = ctx.effector.deathTurn ?? -1;
+  }
+  const used = ops.filter((op) => {
+    if (op.abilityId !== ctx.abilityId) return false;
+    if (op.effector !== ctx.effectorSeat) return false;
+    if (resetTurn >= 0) {
+      const t = ctx.operationTurnMap.get(op);
+      if (typeof t !== "number") return false;
+      if (t < resetTurn) return false;
+      if (t === resetTurn) {
+        const time = ctx.operationTimeMap.get(op);
+        if (resetTime !== null && time !== resetTime) return false;
+      }
+    }
     return true;
   }).length;
+  return compareCount2(used, atom.operator, atom.value) ? null : `count ${used} fails ${atom.operator} ${atom.value} in ${atom.scope}`;
 };
-var checkFrequency = (frequency, ability, effectorSeat, timelines, currentIdx, priorOperations) => {
-  if (priorOperations.length === 0) return null;
-  const operationTimelineMap = /* @__PURE__ */ new Map();
-  timelines.forEach((tl, idx) => tl.operations?.forEach((op) => operationTimelineMap.set(op, idx)));
-  const currentTurn = timelines[currentIdx]?.turn ?? null;
-  const isOncePerGame = frequency === "ONCE_PER_GAME";
-  const isNightScoped = frequency === "ONCE_PER_NIGHT" || frequency === "FIRST_PER_NIGHT";
-  const isFirstPer = frequency === "FIRST_PER_NIGHT" || frequency === "FIRST_PER_DAY";
-  const matchTurn = isOncePerGame ? null : currentTurn;
-  const matchTime = isOncePerGame ? null : isNightScoped ? "night" : "day";
-  const count = countMatchingPriorOps(
-    priorOperations,
-    ability.id,
-    effectorSeat,
-    operationTimelineMap,
-    matchTurn,
-    matchTime,
-    timelines,
-    isFirstPer
-  );
-  if (count > 0) {
-    return `frequency ${frequency} already exhausted (${count} prior op${count === 1 ? "" : "s"})`;
+var evalAtomGlobalCount = (atom, ctx) => {
+  let actual = 0;
+  if (atom.subject === "ALIVE") actual = ctx.players.filter((p) => !p.isDead).length;
+  else if (atom.subject === "DEAD") actual = ctx.players.filter((p) => p.isDead).length;
+  else if (atom.subject === "NOMINATED_TODAY") actual = ctx.todayNominations.length;
+  else if (atom.subject === "EXECUTED_TODAY") {
+    actual = ctx.players.filter((p) => p.isDead && p.deathCause === "EXECUTION" && p.deathTurn === ctx.currentTurn).length;
+  }
+  return compareCount2(actual, atom.operator, atom.value) ? null : `global count ${atom.subject}=${actual} fails ${atom.operator} ${atom.value}`;
+};
+var evalAtom2 = (atom, ctx, customResolver) => {
+  if (atom.type === "TIME") return evalAtomTime(atom, ctx);
+  if (atom.type === "STATE") return evalAtomState(atom, ctx);
+  if (atom.type === "ACTION") return evalAtomAction(atom, ctx);
+  if (atom.type === "COUNT") return evalAtomCount(atom, ctx);
+  if (atom.type === "GLOBAL_COUNT") return evalAtomGlobalCount(atom, ctx);
+  if (atom.type === "CUSTOM") {
+    if (!customResolver) return `no custom resolver registered for ${atom.resolverId}`;
+    return customResolver({ resolverId: atom.resolverId, args: atom.args }, ctx) ? null : `custom resolver ${atom.resolverId} returned false`;
+  }
+  return "unknown atom";
+};
+var evalExpr2 = (expr, ctx, customResolver) => {
+  if (expr.op === "AND") {
+    for (const child of expr.children) {
+      const reason = evalExpr2(child, ctx, customResolver);
+      if (reason) return reason;
+    }
+    return null;
   }
-  return null;
+  if (expr.op === "OR") {
+    const reasons = [];
+    for (const child of expr.children) {
+      const reason = evalExpr2(child, ctx, customResolver);
+      if (!reason) return null;
+      reasons.push(reason);
+    }
+    return `OR: all branches failed (${reasons.join("; ")})`;
+  }
+  if (expr.op === "NOT") {
+    const reason = evalExpr2(expr.child, ctx, customResolver);
+    return reason ? null : "NOT: inner expression was true";
+  }
+  return evalAtom2(expr.atom, ctx, customResolver);
 };
 var canInvokeAbility = ({
   ability,
-  effector,
-  currentTimelineIdx,
   timelines,
-  priorOperations = [],
-  players,
-  event,
-  customConditionResolver
+  candidate,
+  initialPlayers,
+  allAbilities,
+  characters,
+  customResolver
 }) => {
-  const trigger = ability.triggerWindow;
-  if (!trigger) return { allowed: true };
-  const currentTimeline = timelines[currentTimelineIdx];
-  if (!currentTimeline) {
-    return { allowed: false, reason: `no timeline at index ${currentTimelineIdx}` };
-  }
-  if (trigger.turns) {
-    const turnError = checkTurns(trigger.turns, currentTimeline.turn);
-    if (turnError) return { allowed: false, reason: turnError };
-  }
-  const effectorStateError = checkEffectorState(trigger.effectorState ?? "ALIVE", effector);
-  if (effectorStateError) return { allowed: false, reason: effectorStateError };
-  const spec = trigger.trigger;
-  if (spec.kind === "PHASE") {
-    const phaseError = checkPhaseTrigger(spec, timelines, currentTimelineIdx);
-    if (phaseError) return { allowed: false, reason: phaseError };
-  } else if (spec.kind === "EVENT") {
-    const eventError = checkEventTrigger(spec, event, effector?.seat, players, currentTimeline.time);
-    if (eventError) return { allowed: false, reason: eventError };
-  }
-  if (trigger.conditions && trigger.conditions.length > 0) {
-    for (const condition of trigger.conditions) {
-      const condError = checkCondition(condition, {
-        timelines,
-        currentIdx: currentTimelineIdx,
-        players,
-        event,
-        customConditionResolver
-      });
-      if (condError) return { allowed: false, reason: condError };
-    }
-  }
-  if (trigger.frequency) {
-    const freqError = checkFrequency(
-      trigger.frequency,
-      ability,
-      effector?.seat,
-      timelines,
-      currentTimelineIdx,
-      priorOperations
-    );
-    if (freqError) return { allowed: false, reason: freqError };
-  }
-  return { allowed: true };
+  const window = ability.triggerWindow;
+  if (!window) return { allowed: true };
+  const derived = deriveContext({ timelines, candidate, initialPlayers, allAbilities, characters });
+  if ("error" in derived) {
+    return { allowed: false, reason: derived.error };
+  }
+  const reason = evalExpr2(window, derived, customResolver);
+  return reason ? { allowed: false, reason } : { allowed: true };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1400,11 +1476,13 @@ var canInvokeAbility = ({
   buildPlayerSeatMap,
   canInvokeAbility,
   copyPlayers,
+  deriveContext,
   getSourceValue,
   getValueFromPayloads,
   isNumberOrNumberArray,
   isPlayerReminderArray,
   isReminder,
   resolveSourceValue,
+  resolveTargetRef,
   transformEmptyArray
 });