@bct-app/game-engine 0.1.6-beta.4 → 0.1.7

package/dist/index.js

@@ -205,7 +205,6 @@ var toIdList = (value) => {
 };
 var applyAbilityChange = createEffectHandler("ABILITY_CHANGE", ({
   effect,
-  operation,
   payloads,
   effector,
   writableInputs,
@@ -231,16 +230,13 @@ var applyAbilityChange = createEffectHandler("ABILITY_CHANGE", ({
   }
   const mode = effect.mode ?? "REPLACE";
   makePlayersEffect.forEach((player) => {
-    const overrideRaw = operation.abilityChangeOverrides?.[String(player.seat)];
-    const overrideIds = toIdList(overrideRaw);
-    const finalCharacterIds = overrideIds ?? resolvedCharacterIds;
     if (!player.gainCharactersAbility) {
       player.gainCharactersAbility = [];
     }
     if (mode === "REPLACE") {
-      player.gainCharactersAbility = [...finalCharacterIds];
+      player.gainCharactersAbility = [...resolvedCharacterIds];
     } else {
-      for (const characterId of finalCharacterIds) {
+      for (const characterId of resolvedCharacterIds) {
         if (!player.gainCharactersAbility.includes(characterId)) {
           player.gainCharactersAbility.push(characterId);
         }
@@ -248,7 +244,7 @@ var applyAbilityChange = createEffectHandler("ABILITY_CHANGE", ({
     }
     if (player.perceivedCharacter?.asCharacter) {
       const perceived = player.perceivedCharacter;
-      finalCharacterIds.forEach((characterId) => {
+      resolvedCharacterIds.forEach((characterId) => {
         const character = characterMap.get(characterId);
         if (!character) return;
         character.abilities.forEach((newAbility) => {
@@ -680,44 +676,264 @@ var getLifetime = (effect, payloads) => {
   if (effect.type === "REMINDER_ADD") {
     const maybeReminder = getSourceValue(effect.source, payloads);
     if (isReminder(maybeReminder) && typeof maybeReminder.duration === "number" && maybeReminder.duration > 0) {
-      return { kind: "PHASES", count: maybeReminder.duration };
+      return {
+        kind: "WHILE",
+        expr: {
+          op: "ATOM",
+          atom: {
+            type: "TIME",
+            spec: { kind: "WITHIN_PHASES", count: maybeReminder.duration }
+          }
+        }
+      };
     }
   }
   return void 0;
 };
-var matchesLifetimeCondition = (player, condition, characterMap) => {
-  const { field, operator } = condition;
-  const value = condition.value;
+var resolveSubject = (subject, ctx) => {
+  if (!ctx.snapshotSeatMap) return [];
+  const map = ctx.snapshotSeatMap;
+  switch (subject.kind) {
+    case "EFFECTOR": {
+      if (!ctx.effector) return [];
+      const player = map.get(ctx.effector.seat);
+      return player ? [player] : [];
+    }
+    case "TARGET": {
+      if (!ctx.target) return [];
+      const player = map.get(ctx.target.seat);
+      return player ? [player] : [];
+    }
+    case "SEAT": {
+      const player = map.get(subject.seat);
+      return player ? [player] : [];
+    }
+    case "PAYLOAD_REF": {
+      const value = getValueFromPayloads(ctx.payloads, subject.payloadIndex);
+      const seat = adjustValueAsNumber(value);
+      if (typeof seat !== "number") return [];
+      const player = map.get(seat);
+      return player ? [player] : [];
+    }
+    case "CHARACTER": {
+      const matches = [];
+      map.forEach((player) => {
+        if (player.characterId === subject.characterId) matches.push(player);
+      });
+      return matches;
+    }
+  }
+};
+var compareString = (actual, operator, value) => {
+  const isInList = Array.isArray(value) && value.every((v) => typeof v === "string") ? value.includes(actual ?? "") : false;
+  const isEqScalar = typeof value === "string" && actual === value;
+  switch (operator) {
+    case "EQ":
+      return isEqScalar;
+    case "NE":
+      return !isEqScalar;
+    case "IN":
+      return actual !== void 0 && isInList;
+    case "NOT_IN":
+      return !isInList;
+  }
+};
+var compareBool = (actual, operator, value) => {
+  const expected = typeof value === "boolean" ? value : true;
+  switch (operator) {
+    case "EQ":
+      return actual === expected;
+    case "NE":
+      return actual !== expected;
+    case "IN":
+    case "NOT_IN":
+      return actual === expected;
+  }
+};
+var evalPlayerStateOnPlayer = (player, atom, ctx) => {
+  const { field, operator, value } = atom;
+  const op = operator ?? "EQ";
+  if (field === "IS_IN_PLAY") {
+    return compareBool(Boolean(player), op, value);
+  }
+  if (!player) return false;
+  if (field === "IS_ALIVE") {
+    return compareBool(!player.isDead, op, value);
+  }
   if (field === "IS_DEAD") {
-    return Boolean(player.isDead) === Boolean(value);
+    return compareBool(Boolean(player.isDead), op, value);
+  }
+  if (field === "IS_POISONED" || field === "IS_DRUNK" || field === "IS_HEALTHY") {
+    const resolved = ctx.statusResolver ? ctx.statusResolver({ player, status: field === "IS_POISONED" ? "POISONED" : field === "IS_DRUNK" ? "DRUNK" : "HEALTHY" }) : false;
+    return compareBool(resolved, op, value);
   }
   if (field === "CHARACTER_ID") {
-    if (operator === "IN" && Array.isArray(value)) {
-      return value.includes(player.characterId);
-    }
-    return typeof value === "string" && player.characterId === value;
+    return compareString(player.characterId, op, 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;
+    const kind = ctx.characterMap.get(player.characterId)?.kind;
+    return compareString(kind, op, value);
+  }
+  if (field === "ALIGNMENT") {
+    return compareString(player.alignment, op, value);
   }
   if (field === "HAS_ABILITY") {
-    if (operator === "IN" && Array.isArray(value)) {
-      return value.some((id) => player.abilities.includes(id));
+    if (op === "EQ" || op === "NE") {
+      const has = typeof value === "string" && player.abilities.includes(value);
+      return op === "EQ" ? has : !has;
+    }
+    const list = Array.isArray(value) ? value : [];
+    const anyMatch = list.some((id) => player.abilities.includes(id));
+    return op === "IN" ? anyMatch : !anyMatch;
+  }
+  if (field === "HAS_REMINDER") {
+    const marks = (player.reminders ?? []).map((r) => r.mark);
+    if (op === "EQ" || op === "NE") {
+      const has = typeof value === "string" && marks.includes(value);
+      return op === "EQ" ? has : !has;
     }
-    return typeof value === "string" && player.abilities.includes(value);
+    const list = Array.isArray(value) ? value : [];
+    const anyMatch = list.some((mark) => marks.includes(mark));
+    return op === "IN" ? anyMatch : !anyMatch;
   }
   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 evalPlayerState = (atom, ctx) => {
+  const subject = atom.subject ?? { kind: "EFFECTOR" };
+  const players = resolveSubject(subject, ctx);
+  if (subject.kind === "CHARACTER") {
+    const quantifier = subject.quantifier ?? "ANY";
+    if (players.length === 0) {
+      return atom.field === "IS_IN_PLAY" ? evalPlayerStateOnPlayer(void 0, atom, ctx) : false;
+    }
+    const results = players.map((p) => evalPlayerStateOnPlayer(p, atom, ctx));
+    return quantifier === "ALL" ? results.every(Boolean) : results.some(Boolean);
+  }
+  const single = players[0];
+  return evalPlayerStateOnPlayer(single, atom, ctx);
+};
+var isExecutionTimeline = (tl) => {
+  if (!tl) return false;
+  return (tl.operations ?? []).some((op) => op.kind === "execution");
+};
+var evalTime = (atom, ctx) => {
+  const { spec } = atom;
+  const opIdx = ctx.operationTimelineIdx;
+  const nowIdx = ctx.nowTimelineIndex;
+  if (spec.kind === "WITHIN_TURNS") {
+    const opTurn = opIdx >= 0 ? ctx.timelines[opIdx]?.turn : void 0;
+    const nowTurn = nowIdx >= 0 ? ctx.timelines[nowIdx]?.turn : void 0;
+    if (typeof opTurn !== "number" || typeof nowTurn !== "number") return true;
+    return nowTurn - opTurn < spec.count;
+  }
+  if (spec.kind === "WITHIN_PHASES") {
+    if (opIdx < 0) return true;
+    return nowIdx - opIdx < spec.count;
+  }
+  if (spec.kind === "BEFORE_EVENT") {
+    if (opIdx < 0) return true;
+    let prevTime = ctx.timelines[opIdx]?.time;
+    for (let i = opIdx + 1; i <= nowIdx; i += 1) {
+      const tl = ctx.timelines[i];
+      if (!tl) continue;
+      if (spec.event === "NEXT_DAY" && tl.time === "day") return false;
+      if (spec.event === "NEXT_NIGHT" && tl.time === "night") return false;
+      if (spec.event === "NEXT_DUSK" && prevTime === "day" && tl.time === "night") return false;
+      if (spec.event === "NEXT_DAWN" && prevTime === "night" && tl.time === "day") return false;
+      if (spec.event === "NEXT_EXECUTION" && isExecutionTimeline(tl)) return false;
+      prevTime = tl.time;
+    }
+    return true;
+  }
+  if (spec.kind === "CURRENT_PHASE_IS") {
+    const current = nowIdx >= 0 ? ctx.timelines[nowIdx]?.time : void 0;
+    const want = spec.phase === "DAY" ? "day" : "night";
+    return current === want;
+  }
+  return true;
+};
+var compareCount = (actual, operator, expected) => {
+  switch (operator) {
+    case "EQ":
+      return actual === expected;
+    case "NE":
+      return actual !== expected;
+    case "GT":
+      return actual > expected;
+    case "GTE":
+      return actual >= expected;
+    case "LT":
+      return actual < expected;
+    case "LTE":
+      return actual <= expected;
+  }
+};
+var evalGameState = (atom, ctx) => {
+  const { spec } = atom;
+  if (spec.kind === "ALIVE_COUNT") {
+    if (!ctx.snapshotSeatMap) return true;
+    let count = 0;
+    ctx.snapshotSeatMap.forEach((p) => {
+      if (!p.isDead) count += 1;
+    });
+    return compareCount(count, spec.operator, spec.count);
+  }
+  if (spec.kind === "EXECUTION_HAPPENED_TODAY") {
+    const turn = ctx.timelines[ctx.nowTimelineIndex]?.turn;
+    if (typeof turn !== "number") return false;
+    return ctx.timelines.some((tl) => tl.turn === turn && tl.time === "day" && isExecutionTimeline(tl));
+  }
+  if (spec.kind === "PLAYER_DIED_TODAY") {
+    const turn = ctx.timelines[ctx.nowTimelineIndex]?.turn;
+    if (typeof turn !== "number") return false;
+    return ctx.timelines.some((tl) => {
+      if (tl.turn !== turn || tl.time !== "day") return false;
+      return (tl.operations ?? []).some((op) => {
+        const kind = op.kind;
+        return kind === "execution" || kind === "death";
+      });
+    });
+  }
+  return true;
+};
+var evalAtom = (atom, ctx) => {
+  switch (atom.type) {
+    case "TIME":
+      return evalTime(atom, ctx);
+    case "PLAYER_STATE":
+      if (!ctx.snapshotSeatMap) return true;
+      return evalPlayerState(atom, ctx);
+    case "GAME_STATE":
+      if (!ctx.snapshotSeatMap) return true;
+      return evalGameState(atom, ctx);
+    case "CUSTOM":
+      if (!ctx.snapshotSeatMap) return true;
+      return ctx.customResolver ? ctx.customResolver({
+        key: atom.key,
+        payload: atom.payload,
+        effector: ctx.effector,
+        target: ctx.target,
+        snapshotSeatMap: ctx.snapshotSeatMap
+      }) : false;
+  }
+};
+var evalExpr = (expr, ctx) => {
+  switch (expr.op) {
+    case "AND":
+      return expr.children.every((child) => evalExpr(child, ctx));
+    case "OR":
+      return expr.children.some((child) => evalExpr(child, ctx));
+    case "NOT":
+      return !evalExpr(expr.child, ctx);
+    case "ATOM":
+      return evalAtom(expr.atom, ctx);
+  }
+};
+var expressionReferencesTarget = (expr) => {
+  if (expr.op === "AND" || expr.op === "OR") return expr.children.some(expressionReferencesTarget);
+  if (expr.op === "NOT") return expressionReferencesTarget(expr.child);
+  const atom = expr.atom;
+  return atom.type === "PLAYER_STATE" && atom.subject?.kind === "TARGET";
 };
 var evaluateLifetime = ({
   effect,
@@ -728,52 +944,31 @@ var evaluateLifetime = ({
   targets,
   snapshotSeatMap,
   characterMap,
-  payloads
+  payloads,
+  statusResolver,
+  customResolver
 }) => {
   const lifetime = getLifetime(effect, payloads);
   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 === "PHASES") {
-    if (operationTimelineIdx < 0) return targets;
-    return nowTimelineIndex - operationTimelineIdx < 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);
-    });
+  const baseCtx = {
+    operationTimelineIdx,
+    nowTimelineIndex,
+    timelines,
+    effector,
+    snapshotSeatMap,
+    characterMap,
+    payloads,
+    statusResolver,
+    customResolver
+  };
+  const expr = lifetime.expr;
+  const dependsOnTarget = expressionReferencesTarget(expr);
+  if (!dependsOnTarget) {
+    return evalExpr(expr, { ...baseCtx, target: void 0 }) ? targets : [];
   }
-  return targets;
+  return targets.filter((target) => evalExpr(expr, { ...baseCtx, target }));
 };
 
 // src/apply-operation.ts
@@ -794,7 +989,9 @@ var applyOperationToPlayers = ({
   allAbilities,
   characters,
   timelines,
-  timelineIndexAtNow
+  timelineIndexAtNow,
+  statusResolver,
+  customResolver
 }) => {
   if (operations.length === 0) {
     return transformEmptyArray(players);
@@ -854,7 +1051,9 @@ var applyOperationToPlayers = ({
             targets: resolvedTargets,
             snapshotSeatMap: lifetimeSnapshotSeatMap,
             characterMap,
-            payloads
+            payloads,
+            statusResolver,
+            customResolver
           });
           const handler = effectHandlers[effect.type];
           if (!handler) {
@@ -934,6 +1133,10 @@ 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)}`;
@@ -946,10 +1149,159 @@ var checkTurns = (turns, currentTurn) => {
   }
   return null;
 };
-var countMatchingPriorOps = (priorOperations, abilityId, effectorSeat, operationTimelineMap, matchTurn, matchTime, timelines) => {
+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 isFirstPhaseForEffector = (timelines, currentIdx, phaseTime) => {
+  for (let i = 0; i < currentIdx; i++) {
+    if (timelines[i]?.time === phaseTime) 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 "<":
+      return actual < expected;
+    case "<=":
+      return actual <= expected;
+    case ">":
+      return actual > expected;
+    case ">=":
+      return actual >= expected;
+    case "=":
+      return actual === expected;
+    case "!=":
+      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++;
+    }
+  }
+  return count;
+};
+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;
+  }
+  if (condition.kind === "NO_EXECUTION_TODAY") {
+    return countExecutionsToday(timelines, currentIdx) > 0 ? "condition NO_EXECUTION_TODAY violated" : null;
+  }
+  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 (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)})`;
+    }
+    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 null;
+};
+var countMatchingPriorOps = (priorOperations, abilityId, effectorSeat, operationTimelineMap, matchTurn, matchTime, timelines, countAcrossEffectors) => {
   return priorOperations.filter((op) => {
     if (op.abilityId !== abilityId) return false;
-    if (typeof effectorSeat === "number" && op.effector !== effectorSeat) 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;
@@ -960,12 +1312,40 @@ var countMatchingPriorOps = (priorOperations, abilityId, effectorSeat, operation
     return true;
   }).length;
 };
+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"})`;
+  }
+  return null;
+};
 var canInvokeAbility = ({
   ability,
   effector,
   currentTimelineIdx,
   timelines,
-  priorOperations = []
+  priorOperations = [],
+  players,
+  event,
+  customConditionResolver
 }) => {
   const trigger = ability.triggerWindow;
   if (!trigger) return { allowed: true };
@@ -977,29 +1357,38 @@ var canInvokeAbility = ({
     const turnError = checkTurns(trigger.turns, currentTimeline.turn);
     if (turnError) return { allowed: false, reason: turnError };
   }
-  if (trigger.phases && trigger.phases.length > 0 && !trigger.phases.includes(currentTimeline.time)) {
-    return { allowed: false, reason: `phase ${currentTimeline.time} not in allowed phases ${JSON.stringify(trigger.phases)}` };
-  }
-  if (trigger.requireEffectorAlive && (!effector || effector.isDead)) {
-    return { allowed: false, reason: "effector is not alive" };
+  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 && priorOperations.length > 0) {
-    const operationTimelineMap = /* @__PURE__ */ new Map();
-    timelines.forEach((tl, idx) => tl.operations?.forEach((op) => operationTimelineMap.set(op, idx)));
-    const matchTurn = trigger.frequency === "ONCE_PER_GAME" ? null : currentTimeline.turn;
-    const matchTime = trigger.frequency === "ONCE_PER_GAME" ? null : trigger.frequency === "ONCE_PER_NIGHT" ? "night" : "day";
-    const count = countMatchingPriorOps(
-      priorOperations,
-      ability.id,
+  if (trigger.frequency) {
+    const freqError = checkFrequency(
+      trigger.frequency,
+      ability,
       effector?.seat,
-      operationTimelineMap,
-      matchTurn,
-      matchTime,
-      timelines
+      timelines,
+      currentTimelineIdx,
+      priorOperations
     );
-    if (count > 0) {
-      return { allowed: false, reason: `frequency ${trigger.frequency} already exhausted (${count} prior op${count === 1 ? "" : "s"})` };
-    }
+    if (freqError) return { allowed: false, reason: freqError };
   }
   return { allowed: true };
 };