phase-rs · matthewevans · Aug 14, 2026 · Aug 12, 2026 · Aug 13, 2026 · Aug 13, 2026
@@ -49,14 +49,83 @@ function getChoiceTypeKey(choiceType: string | Record<string, unknown>): string
 
 const MAX_RESULTS = 10;
 
+/** CR 107.1a/b: the minimum of an unbounded number choice, or null when this is
+ *  not one. The engine omits `max` entirely for "choose a number 0 or greater",
+ *  so an absent max — not an empty option list — is what identifies the
+ *  free-entry numeric form. A bounded range keeps its options and its grid. */
+function unboundedNumberMin(
+  choiceType: string | Record<string, unknown>,
+): number | null {
+  if (typeof choiceType === "string") return null;
+  const payload = (choiceType as Record<string, unknown>).NumberRange;
+  if (payload == null || typeof payload !== "object") return null;
+  const fields = payload as { min?: unknown; max?: unknown };
+  if (fields.max != null) return null;
+  return typeof fields.min === "number" ? fields.min : 0;
+}
+
 export function NamedChoiceModal({ data }: { data: OptionChoice["data"] }) {
   const typeKey = getChoiceTypeKey(data.choice_type);
   if (typeKey === "CardName") {
     return <CardNameSearch />;
   }
+  const unboundedMin = unboundedNumberMin(data.choice_type);
+  if (unboundedMin !== null) {
+    return <NumberEntry min={unboundedMin} />;
+  }
   return <ButtonGrid data={data} typeKey={typeKey} />;
 }
 
+/** CR 107.1a/b: free-entry numeric prompt for a choice with no stated maximum.
+ *  The engine validates the answer authoritatively (`accepts_free_entry_answer`);
+ *  this only keeps the player from submitting something it would reject. */
+function NumberEntry({ min }: { min: number }) {
+  const { t } = useTranslation("game");
+  const dispatch = useGameDispatch();
+  const [value, setValue] = useState(String(min));
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  useEffect(() => {
+    inputRef.current?.focus();
+    inputRef.current?.select();
+  }, []);
+
+  // Mirrors the engine's rule: a nonnegative integer at least `min`, within the
+  // i32 quantity domain the rest of the engine can represent.
+  const parsed = /^\d+$/.test(value.trim()) ? Number(value.trim()) : null;
+  const valid =
+    parsed !== null && Number.isSafeInteger(parsed) && parsed >= min && parsed <= 2147483647;
+
+  const confirm = useCallback(() => {
+    if (valid) {
+      dispatch({ type: "ChooseOption", data: { choice: String(parsed) } });
+    }
+  }, [dispatch, parsed, valid]);
+
+  return (
+    <ChoiceOverlay
+      title={t("namedChoice.title.numberRange")}
+      subtitle={t("namedChoice.numberSubtitle", { min })}
+      footer={<ConfirmButton onClick={confirm} disabled={!valid} />}
+    >
+      <input
+        ref={inputRef}
+        type="text"
+        inputMode="numeric"
+        value={value}
+        onChange={(e) => setValue(e.target.value)}
+        onKeyDown={(e) => {
+          if (e.key === "Enter" && valid) {
+            e.preventDefault();
+            confirm();
+          }
+        }}
+        className="w-40 rounded-lg border-2 border-gray-600 bg-gray-900/90 px-4 py-3 text-center text-xl text-white outline-none transition focus:border-cyan-400"
+      />
+    </ChoiceOverlay>
+  );
+}
+
 function CardNameSearch() {
   const { t } = useTranslation("game");
   const dispatch = useGameDispatch();

@@ -5,6 +5,11 @@
     "close": "Schließen",
     "closeNamed": "{{name}} schließen"
   },
+  "quantityRef": {
+    "highestNumber": "die höchste Zahl",
+    "lowestNumber": "die niedrigste Zahl",
+    "chosenNumber": "die gewählte Zahl"
+  },
   "scryOutcome": {
     "title": "Spähen abgeschlossen",
     "you": "Du",

@@ -2042,6 +2042,7 @@
     "searchPlaceholder": "Nach Name suchen...",
     "noCardsFound": "Keine Karten gefunden",
     "buttonSubtitle": "Wähle eine Option",
+    "numberSubtitle": "Gib eine Zahl {{min}} oder größer ein",
     "filterPlaceholder": "Optionen filtern...",
     "noOptionsMatch": "Keine Option passt"
   },

@@ -5,6 +5,11 @@
     "close": "Close",
     "closeNamed": "Close {{name}}"
   },
+  "quantityRef": {
+    "highestNumber": "the highest number",
+    "lowestNumber": "the lowest number",
+    "chosenNumber": "the chosen number"
+  },
   "scryOutcome": {
     "title": "Scry complete",
     "you": "You",

@@ -2086,6 +2086,7 @@
     "searchPlaceholder": "Search by name...",
     "noCardsFound": "No cards found",
     "buttonSubtitle": "Select one option",
+    "numberSubtitle": "Enter a number {{min}} or greater",
     "filterPlaceholder": "Filter options...",
     "noOptionsMatch": "No options match"
   },

@@ -5,6 +5,11 @@
     "close": "Cerrar",
     "closeNamed": "Cerrar {{name}}"
   },
+  "quantityRef": {
+    "highestNumber": "el número más alto",
+    "lowestNumber": "el número más bajo",
+    "chosenNumber": "el número elegido"
+  },
   "scryOutcome": {
     "title": "Adivinación completada",
     "you": "Tú",

@@ -2042,6 +2042,7 @@
     "searchPlaceholder": "Buscar por nombre...",
     "noCardsFound": "No se encontraron cartas",
     "buttonSubtitle": "Selecciona una opción",
+    "numberSubtitle": "Introduce un número {{min}} o mayor",
     "filterPlaceholder": "Filtrar opciones...",
     "noOptionsMatch": "Ninguna opción coincide"
   },

@@ -5,6 +5,11 @@
     "close": "Fermer",
     "closeNamed": "Fermer {{name}}"
   },
+  "quantityRef": {
+    "highestNumber": "le nombre le plus élevé",
+    "lowestNumber": "le nombre le plus bas",
+    "chosenNumber": "le nombre choisi"
+  },
   "scryOutcome": {
     "title": "Regard terminé",
     "you": "Vous",

@@ -2042,6 +2042,7 @@
     "searchPlaceholder": "Rechercher par nom...",
     "noCardsFound": "Aucune carte trouvée",
     "buttonSubtitle": "Sélectionnez une option",
+    "numberSubtitle": "Entrez un nombre supérieur ou égal à {{min}}",
     "filterPlaceholder": "Filtrer les options...",
     "noOptionsMatch": "Aucune option ne correspond"
   },

@@ -5,6 +5,11 @@
     "close": "Chiudi",
     "closeNamed": "Chiudi {{name}}"
   },
+  "quantityRef": {
+    "highestNumber": "il numero più alto",
+    "lowestNumber": "il numero più basso",
+    "chosenNumber": "il numero scelto"
+  },
   "scryOutcome": {
     "title": "Scry completato",
     "you": "Tu",

@@ -2042,6 +2042,7 @@
     "searchPlaceholder": "Cerca per nome...",
     "noCardsFound": "Nessuna carta trovata",
     "buttonSubtitle": "Seleziona un'opzione",
+    "numberSubtitle": "Inserisci un numero {{min}} o maggiore",
     "filterPlaceholder": "Filtra opzioni...",
     "noOptionsMatch": "Nessuna opzione corrisponde"
   },

@@ -5,6 +5,11 @@
     "close": "Zamknij",
     "closeNamed": "Zamknij {{name}}"
   },
+  "quantityRef": {
+    "highestNumber": "najwyższa liczba",
+    "lowestNumber": "najniższa liczba",
+    "chosenNumber": "wybrana liczba"
+  },
   "scryOutcome": {
     "title": "Wróżenie zakończone",
     "you": "Ty",

@@ -2042,6 +2042,7 @@
     "searchPlaceholder": "Szukaj po nazwie...",
     "noCardsFound": "Nie znaleziono kart",
     "buttonSubtitle": "Wybierz jedną opcję",
+    "numberSubtitle": "Wpisz liczbę {{min}} lub większą",
     "filterPlaceholder": "Filtruj opcje...",
     "noOptionsMatch": "Brak pasujących opcji"
   },

@@ -5,6 +5,11 @@
     "close": "Fechar",
     "closeNamed": "Fechar {{name}}"
   },
+  "quantityRef": {
+    "highestNumber": "o número mais alto",
+    "lowestNumber": "o número mais baixo",
+    "chosenNumber": "o número escolhido"
+  },
   "scryOutcome": {
     "title": "Vidência concluída",
     "you": "Você",

@@ -2042,6 +2042,7 @@
     "searchPlaceholder": "Buscar por nome...",
     "noCardsFound": "Nenhuma carta encontrada",
     "buttonSubtitle": "Selecione uma opção",
+    "numberSubtitle": "Digite um número {{min}} ou maior",
     "filterPlaceholder": "Filtrar opções...",
     "noOptionsMatch": "Nenhuma opção corresponde"
   },

@@ -443,6 +443,44 @@ describe("additionalCostChoices — repeatable additional cost", () => {
 });
 
 describe("formatAbilityCost", () => {
+  // CR 101.4: `QuantityRef::PlayerChosenNumber` renders the cross-player fold the
+  // engine supplies — "the highest number" for `Max`, "the lowest number" for
+  // `Min` — and falls back to the bare noun for a single-player scope, which
+  // carries no fold. All three go through the i18n boundary, so the assertions
+  // read the `en` catalog rather than frontend-authored literals.
+  it.each([
+    ["Max", "Pay the highest number life"],
+    ["Min", "Pay the lowest number life"],
+  ])("formats a chosen-number cost for the %s fold", (aggregate, expected) => {
+    expect(
+      formatAbilityCost({
+        type: "PayLife",
+        amount: {
+          type: "Ref",
+          qty: {
+            type: "PlayerChosenNumber",
+            player: { type: "AllPlayers", aggregate },
+          },
+        },
+      }),
+    ).toBe(expected);
+  });
+
+  it("falls back to the bare noun for a scoped chosen number", () => {
+    expect(
+      formatAbilityCost({
+        type: "PayLife",
+        amount: {
+          type: "Ref",
+          qty: {
+            type: "PlayerChosenNumber",
+            player: { type: "ScopedPlayer" },
+          },
+        },
+      }),
+    ).toBe("Pay the chosen number life");
+  });
+
   it("formats disjunctive activation cost branches", () => {
     expect(formatAbilityCost({
       type: "OneOf",

@@ -7,6 +7,7 @@ import type {
   SerializedAbility,
   SerializedAbilityCost,
 } from "../adapter/types.ts";
+import i18n from "../i18n";
 import { getCrewPower, getSaddlePower } from "./keywordProps.ts";
 import { renderDescription } from "../utils/description.ts";
 
@@ -187,6 +188,20 @@ function formatQuantityRef(ref: { type: string; [key: string]: unknown }): strin
     case "ExiledFromHandThisResolution": return "cards exiled from hand";
     case "Speed": return "your speed";
     case "ChosenNumber": return "the chosen number";
+    // CR 101.4: the number a player secretly chose. The engine supplies the
+    // player scope (and, for the cross-player scopes, the fold); this only
+    // renders it — "the highest number" / "the lowest number". Routed through
+    // the i18n boundary; the surrounding labels in this file are legacy raw
+    // English and are tracked separately.
+    case "PlayerChosenNumber": {
+      const aggregate =
+        ref.player != null && typeof ref.player === "object" && "aggregate" in ref.player
+          ? (ref.player as { aggregate?: string }).aggregate
+          : undefined;
+      if (aggregate === "Max") return i18n.t("quantityRef.highestNumber");
+      if (aggregate === "Min") return i18n.t("quantityRef.lowestNumber");
+      return i18n.t("quantityRef.chosenNumber");
+    }
     case "PreviousEffectAmount": return "the previous amount";
     case "EventContextAmount": return "the amount";
     case "EventContextSourcePower": return "the source's power";

@@ -4704,6 +4704,52 @@ fn named_choice_actions(
     choice_type: &ChoiceType,
     source_display_name: Option<&str>,
 ) -> Vec<CandidateAction> {
+    // CR 107.1a/b: an unbounded number choice ("a number 0 or greater") offers no
+    // option list, so the AI must SAMPLE a domain it cannot enumerate. The sample
+    // is deliberately small and game-relevant rather than a truncated 0..=N walk:
+    // on Wheel of Misfortune the meaningful decisions are "bid nothing", "bid just
+    // enough to wheel", and "bid past a life total", so the ladder is anchored to
+    // the live life totals rather than to an arbitrary ceiling.
+    //
+    // Every candidate is filtered through `accepts_free_entry_answer`, the same
+    // authority the answer seam uses, so the AI can never propose a value the
+    // engine would then reject.
+    if options.is_empty() {
+        if let ChoiceType::NumberRange { min, max: None, .. } = choice_type {
+            let highest_life = state
+                .players
+                .iter()
+                .map(|p| p.life.max(0) as u32)
+                .max()
+                .unwrap_or(0);
+            let mut sample: Vec<u32> = vec![
+                *min,
+                min.saturating_add(1),
+                min.saturating_add(2),
+                highest_life,
+                highest_life.saturating_add(1),
+            ];
+            sample.sort_unstable();
+            sample.dedup();
+            return sample
+                .into_iter()
+                .map(|n| n.to_string())
+                .filter(|choice| {
+                    choice_type
+                        .accepts_free_entry_answer(choice)
+                        .unwrap_or(false)
+                })
+                .map(|choice| {
+                    candidate(
+                        GameAction::ChooseOption { choice },
+                        TacticalClass::Selection,
+                        Some(player),
+                    )
+                })
+                .collect();
+        }
+    }
+
     if options.is_empty() && matches!(choice_type, ChoiceType::CardName) {
         return card_name_choice_candidates(state, player, source_display_name)
             .into_iter()

@@ -918,6 +918,7 @@ fn effect_projection(effect: &Effect) -> Projection {
         | Effect::TargetOnly { .. }
         | Effect::Choose { .. }
         | Effect::SwapChosenLabels { .. }
+        | Effect::RevealChosenNumbers { .. }
         | Effect::ChooseDamageSource { .. }
         | Effect::Suspect { .. }
         | Effect::Unsuspect { .. }

@@ -9011,7 +9011,9 @@ pub fn synthesize_read_ahead(face: &mut CardFace) {
         Effect::Choose {
             choice_type: ChoiceType::NumberRange {
                 min: 1,
-                max: final_chapter.min(u8::MAX as u32) as u8,
+                // CR 702.155b: the Saga states its own upper bound (the final
+                // chapter), so this range is genuinely bounded.
+                max: Some(final_chapter),
                 distinctness: crate::types::ability::NumberDistinctness::Repeatable,
             },
             persist: true,
@@ -23010,7 +23012,7 @@ mod devour_synthesis_tests {
             panic!("read-ahead ETB should choose a number");
         };
         // CR 702.155b + CR 714.2d: between one and the final chapter number (3).
-        assert_eq!((*min, *max), (1, 3));
+        assert_eq!((*min, *max), (1, Some(3)));
         assert!(*persist, "chosen number must persist for ChosenNumber");
 
         let sub = execute