loom-engine-rpg 2.3.0__tar.gz

loom_engine_rpg-2.3.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: loom-engine-rpg
+Version: 2.3.0
+Summary: Deterministic TTRPG simulation core for AI-run games - the Python surface of loom-engine. Engine-is-truth: seeded, replay-safe rules the AI narrates but cannot invent.
+License-Expression: BUSL-1.1
+Project-URL: Homepage, https://www.npmjs.com/package/loom-engine
+Keywords: ttrpg,rpg,deterministic,ai-game-master,5e,pathfinder,simulation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+
+# loom-engine (Python)
+
+The Python surface of [loom-engine](https://www.npmjs.com/package/loom-engine) - a
+deterministic rules core for AI-run tabletop and RPG games.
+
+```sh
+pip install loom-engine-rpg   # the bare 'loom-engine' name is taken on PyPI
+```
+```python
+import loom_engine            # the import name is loom_engine
+```
+
+The design principle: **the engine is truth.** Dice, action economy, initiative,
+range, conditions, reactions, and validation are resolved by pure, replay-safe
+code. An AI narrator can describe the outcome, but it never gets to invent the
+roll, change the numbers, or rewrite what happened.
+
+This package is a **byte-parity** port of the TypeScript engine: the same inputs
+produce identical results in Python (your server/backend) and TypeScript (the
+browser), so a server-authoritative resolution and a client one can never
+disagree. That parity is enforced by a shared cross-language golden-vector suite.
+
+## Modules (v2.3.0)
+
+- `loom_engine.range_bands` - grid-free Engaged/Near/Far positioning.
+- `loom_engine.reaction_economy` - the per-round "1 reaction per combatant" ceiling.
+- `loom_engine.narration_contract` - `find_invented_number`: reject prose that
+  states a mechanics number the engine never produced (numerals **and** number-words).
+- `loom_engine.ruleset` - 5e + PF2e action economy, initiative ordering, conditions.
+
+Pure stdlib, zero runtime dependencies. Compatible with the D&D 5e SRD (CC-BY-4.0)
+and the Pathfinder 2e Remaster ruleset (ORC License); see `../NOTICE.md`. Not
+affiliated with or endorsed by Wizards of the Coast or Paizo.
+
+## Determinism
+
+These modules use ordered dicts + explicit sorts for all logic (never `hash()`
+ordering). For any cross-language hashing, serialize with
+`json.dumps(obj, sort_keys=True, separators=(',', ':'))` and run with
+`PYTHONHASHSEED=0`. Floats are banned in deterministic paths.

loom_engine_rpg-2.3.0/README.md

@@ -0,0 +1,40 @@
+# loom-engine (Python)
+
+The Python surface of [loom-engine](https://www.npmjs.com/package/loom-engine) - a
+deterministic rules core for AI-run tabletop and RPG games.
+
+```sh
+pip install loom-engine-rpg   # the bare 'loom-engine' name is taken on PyPI
+```
+```python
+import loom_engine            # the import name is loom_engine
+```
+
+The design principle: **the engine is truth.** Dice, action economy, initiative,
+range, conditions, reactions, and validation are resolved by pure, replay-safe
+code. An AI narrator can describe the outcome, but it never gets to invent the
+roll, change the numbers, or rewrite what happened.
+
+This package is a **byte-parity** port of the TypeScript engine: the same inputs
+produce identical results in Python (your server/backend) and TypeScript (the
+browser), so a server-authoritative resolution and a client one can never
+disagree. That parity is enforced by a shared cross-language golden-vector suite.
+
+## Modules (v2.3.0)
+
+- `loom_engine.range_bands` - grid-free Engaged/Near/Far positioning.
+- `loom_engine.reaction_economy` - the per-round "1 reaction per combatant" ceiling.
+- `loom_engine.narration_contract` - `find_invented_number`: reject prose that
+  states a mechanics number the engine never produced (numerals **and** number-words).
+- `loom_engine.ruleset` - 5e + PF2e action economy, initiative ordering, conditions.
+
+Pure stdlib, zero runtime dependencies. Compatible with the D&D 5e SRD (CC-BY-4.0)
+and the Pathfinder 2e Remaster ruleset (ORC License); see `../NOTICE.md`. Not
+affiliated with or endorsed by Wizards of the Coast or Paizo.
+
+## Determinism
+
+These modules use ordered dicts + explicit sorts for all logic (never `hash()`
+ordering). For any cross-language hashing, serialize with
+`json.dumps(obj, sort_keys=True, separators=(',', ':'))` and run with
+`PYTHONHASHSEED=0`. Floats are banned in deterministic paths.

loom_engine_rpg-2.3.0/loom_engine/__init__.py

@@ -0,0 +1,39 @@
+"""loom_engine - deterministic TTRPG simulation core (Python surface).
+
+Byte-parity Python port of the loom-engine TypeScript package (npm: loom-engine).
+The deterministic primitives - range bands, reaction economy, narration contract,
+5e/PF2e ruleset adapters - produce identical results to the TS engine for the
+same inputs, so a Python-server resolution equals a TS-client one: the basis for
+server-authoritative anti-cheat + honest AI-narrated play.
+
+DETERMINISM NOTE: these modules use ordered dicts + explicit sorts for all LOGIC,
+so they never depend on hash() ordering. For any cross-language HASHING, serialize
+with json.dumps(obj, sort_keys=True, separators=(',', ':')) and run with
+PYTHONHASHSEED=0. Ban floats in deterministic paths; use an explicit floor-div
+helper if negative-operand division is ever needed (JS truncates toward zero,
+Python // floors).
+"""
+
+__version__ = "2.3.0"
+
+from .range_bands import (  # noqa: F401
+    RANGE_BAND_ENGAGED, RANGE_BAND_NEAR, RANGE_BAND_FAR, ENGAGED_MAX_FT,
+    NEAR_MAX_FT, band_from_distance_ft, normalize_band, band_within,
+    compare_bands, RangeBandField, RESOURCE_RANGE_BANDS,
+)
+from .reaction_economy import (  # noqa: F401
+    REACTIONS_PER_ROUND, ReactionLedger, create_reaction_ledger, can_react,
+    reactions_remaining, spend_reaction, advance_reaction_round,
+    set_reaction_round, prune_stale_spends, clear_reactions,
+    reaction_ledger_snapshot, RESOURCE_REACTION_ECONOMY,
+)
+from .narration_contract import (  # noqa: F401
+    parse_number_word, extract_candidate_numbers, find_invented_number,
+    is_narration_grounded, RESOURCE_NARRATION_CONTRACT,
+)
+from .ruleset import (  # noqa: F401
+    RULESET_5E, RULESET_PF2E, start_turn_budget, can_spend, spend,
+    initiative_order, create_condition_track, apply_condition,
+    remove_condition, has_condition, condition_remaining, tick_conditions,
+    active_conditions, DURATION_UNTIL_REMOVED, RESOURCE_RULESET,
+)

loom_engine_rpg-2.3.0/loom_engine/narration_contract.py

@@ -0,0 +1,103 @@
+"""loom_engine.narration_contract - engine-owns-outcomes (no-invented-number).
+
+Byte-parity hand-port of the TypeScript runtime/narration-contract.ts. Given the
+canonical numbers the engine produced this turn, find any mechanics-significant
+number in the prose the engine did NOT produce - catching numerals AND
+number-words. The differentiator vs pure-LLM story apps: the AI may describe the
+engine's outcomes, never invent them. Pure + deterministic.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Iterable, List, Optional
+
+_ONES = {
+    "zero": 0, "one": 1, "two": 2, "three": 3, "four": 4, "five": 5, "six": 6,
+    "seven": 7, "eight": 8, "nine": 9, "ten": 10, "eleven": 11, "twelve": 12,
+    "thirteen": 13, "fourteen": 14, "fifteen": 15, "sixteen": 16,
+    "seventeen": 17, "eighteen": 18, "nineteen": 19,
+}
+_TENS = {
+    "twenty": 20, "thirty": 30, "forty": 40, "fifty": 50, "sixty": 60,
+    "seventy": 70, "eighty": 80, "ninety": 90,
+}
+
+_NUMERAL_RE = re.compile(r"\d[\d,]*")
+_WORD_SPLIT_RE = re.compile(r"[^a-z]+")
+
+
+def parse_number_word(token) -> Optional[int]:
+    """Parse a single number-word ('seven', 'twenty', 'twenty-one', 'twenty one')
+    to its value, or None."""
+    t = str(token or "").strip().lower()
+    if not t:
+        return None
+    if t in _ONES:
+        return _ONES[t]
+    if t in _TENS:
+        return _TENS[t]
+    parts = re.split(r"[\s-]+", t)
+    if len(parts) == 2 and parts[0] in _TENS and parts[1] in _ONES:
+        ones = _ONES[parts[1]]
+        if 1 <= ones <= 9:
+            return _TENS[parts[0]] + ones
+    return None
+
+
+def extract_candidate_numbers(text) -> List[int]:
+    """Every candidate mechanics number in `text` - numerals (incl. 1,024) and
+    number-words (incl. 'twenty-one'), order-preserving with duplicates."""
+    out: List[int] = []
+    if not text or not isinstance(text, str):
+        return out
+    for m in _NUMERAL_RE.finditer(text):
+        raw = m.group(0).replace(",", "")
+        try:
+            out.append(int(raw))
+        except ValueError:
+            pass
+    words = _WORD_SPLIT_RE.split(text.lower())
+    i = 0
+    while i < len(words):
+        w = words[i]
+        if not w:
+            i += 1
+            continue
+        if w in _TENS:
+            nxt = words[i + 1] if i + 1 < len(words) else ""
+            if nxt in _ONES and 1 <= _ONES[nxt] <= 9:
+                out.append(_TENS[w] + _ONES[nxt])
+                i += 2
+                continue
+            out.append(_TENS[w])
+        elif w in _ONES:
+            out.append(_ONES[w])
+        i += 1
+    return out
+
+
+def find_invented_number(text, attested: Iterable[int],
+                         ignore_at_or_below: int = 2) -> Optional[int]:
+    """First mechanics number in `text` NOT in the engine's attested set, or None.
+    Numbers <= ignore_at_or_below are treated as ambiguous flavor (default 2)."""
+    allowed = set()
+    if attested:
+        for a in attested:
+            if isinstance(a, (int, float)) and a == a:
+                allowed.add(int(a) if isinstance(a, int) else a)
+                allowed.add(a)
+    for c in extract_candidate_numbers(text):
+        if c <= ignore_at_or_below:
+            continue
+        if c not in allowed:
+            return c
+    return None
+
+
+def is_narration_grounded(text, attested: Iterable[int],
+                          ignore_at_or_below: int = 2) -> bool:
+    return find_invented_number(text, attested, ignore_at_or_below) is None
+
+
+RESOURCE_NARRATION_CONTRACT = "narrationContract"

loom_engine_rpg-2.3.0/loom_engine/range_bands.py

@@ -0,0 +1,128 @@
+"""loom_engine.range_bands - grid-free relative positioning.
+
+PARITY CONTRACT: this is a hand-port of the TypeScript runtime/range-bands.ts.
+The band math + ordering MUST match the TS module byte-for-byte (same
+thresholds, same insertion-ordered iteration via Python's ordered dict), so a
+Python-server result is identical to a TS-client result for the same inputs.
+The shared golden vectors in ../test_vectors/ are the cross-language gate.
+
+Pure + deterministic: no RNG, no floats stored (distance is advisory).
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Dict, List, Optional
+
+RANGE_BAND_ENGAGED = "engaged"
+RANGE_BAND_NEAR = "near"
+RANGE_BAND_FAR = "far"
+
+ENGAGED_MAX_FT = 5
+NEAR_MAX_FT = 30
+
+_BAND_ORDER: Dict[str, int] = {"engaged": 0, "near": 1, "far": 2}
+
+
+def band_from_distance_ft(feet) -> str:
+    """Map a distance in feet to a band. The cross-language contract is INTEGER
+    feet (the Rust/WASM core takes i64), so a fractional input is TRUNCATED toward
+    zero first - trunc(5.49) == 5 -> Engaged - matching Math.trunc (TS) and
+    `feet as i64` (Rust). Negative / NaN / unparseable -> the neutral Near."""
+    try:
+        d = float(feet)
+    except (TypeError, ValueError):
+        return RANGE_BAND_NEAR
+    if d != d:  # NaN
+        return RANGE_BAND_NEAR
+    if d < 0:
+        return RANGE_BAND_NEAR
+    if math.isinf(d):  # trunc(inf) would raise; +inf is past every threshold
+        return RANGE_BAND_FAR
+    d = math.trunc(d)  # integer-feet contract
+    if d <= ENGAGED_MAX_FT:
+        return RANGE_BAND_ENGAGED
+    if d <= NEAR_MAX_FT:
+        return RANGE_BAND_NEAR
+    return RANGE_BAND_FAR
+
+
+def normalize_band(band) -> Optional[str]:
+    return band if band in _BAND_ORDER else None
+
+
+def band_within(band: str, max_band: str) -> bool:
+    """True iff `band` is at least as close as `max_band` (engaged < near < far)."""
+    a = _BAND_ORDER.get(band)
+    b = _BAND_ORDER.get(max_band)
+    if a is None or b is None:
+        return False
+    return a <= b
+
+
+def compare_bands(a: str, b: str) -> int:
+    ai = _BAND_ORDER.get(a, 99)
+    bi = _BAND_ORDER.get(b, 99)
+    return ai - bi
+
+
+def _pair_key(source: str, target: str) -> str:
+    return source + " " + target
+
+
+class RangeBandField:
+    """Directed (source -> target) band store for one encounter. set_pair writes
+    both directions symmetrically by default. Backed by an insertion-ordered
+    dict (Python 3.7+), matching the TS Map iteration order."""
+
+    def __init__(self) -> None:
+        self.bands: Dict[str, str] = {}
+
+    def set_pair(self, a: str, b: str, band: Optional[str] = None,
+                 distance_feet=None, symmetric: bool = True) -> str:
+        explicit = normalize_band(band) if band is not None else None
+        if explicit is not None:
+            resolved = explicit
+        elif distance_feet is not None:
+            resolved = band_from_distance_ft(distance_feet)
+        else:
+            resolved = RANGE_BAND_NEAR
+        if not a or not b or a == b:
+            return resolved
+        self.bands[_pair_key(a, b)] = resolved
+        if symmetric:
+            self.bands[_pair_key(b, a)] = resolved
+        return resolved
+
+    def get_band(self, source: str, target: str) -> Optional[str]:
+        return self.bands.get(_pair_key(source, target))
+
+    def is_engaged(self, a: str, b: str) -> bool:
+        return self.get_band(a, b) == RANGE_BAND_ENGAGED
+
+    def targets_within(self, source: str, max_band: str) -> List[str]:
+        out: List[str] = []
+        prefix = source + " "
+        for key, band in self.bands.items():
+            if key.startswith(prefix) and band_within(band, max_band):
+                out.append(key[len(prefix):])
+        # Codex P1: canonical SORTED order (UTF-8 bytes) to match the Rust core's
+        # BTreeMap iteration - identical across languages.
+        out.sort(key=lambda s: s.encode("utf-8"))
+        return out
+
+    def engaged_with(self, source: str) -> List[str]:
+        return self.targets_within(source, RANGE_BAND_ENGAGED)
+
+    def clear(self) -> None:
+        self.bands.clear()
+
+    def snapshot(self) -> List[dict]:
+        out: List[dict] = []
+        for key, band in self.bands.items():
+            i = key.index(" ")
+            out.append({"source": key[:i], "target": key[i + 1:], "band": band})
+        return out
+
+
+RESOURCE_RANGE_BANDS = "rangeBands"

loom_engine_rpg-2.3.0/loom_engine/reaction_economy.py

@@ -0,0 +1,85 @@
+"""loom_engine.reaction_economy - the per-round reaction ceiling.
+
+Byte-parity hand-port of the TypeScript runtime/reaction-economy.ts: exactly ONE
+reaction per combatant per round, each spend round-tagged so a stale prior-round
+record is inert. Pure + deterministic (no RNG, no wall-clock; ordered dict
+matches the TS Map). See ../test_vectors/ for the cross-language gate.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List
+
+REACTIONS_PER_ROUND = 1
+
+
+class ReactionLedger:
+    """round is 1-based. spent_in_round maps entity_id -> the round it last spent
+    its reaction (ordered-insertion dict, matching the TS Map)."""
+
+    def __init__(self, round_no: int = 1) -> None:
+        self.round = int(round_no) if isinstance(round_no, int) and round_no > 0 else 1
+        self.spent_in_round: Dict[str, int] = {}
+
+
+def create_reaction_ledger(round_no: int = 1) -> ReactionLedger:
+    return ReactionLedger(round_no)
+
+
+def can_react(ledger: ReactionLedger, entity_id: str) -> bool:
+    """True iff entity_id still has its reaction available THIS round."""
+    if not entity_id:
+        return False
+    return ledger.spent_in_round.get(entity_id) != ledger.round
+
+
+def reactions_remaining(ledger: ReactionLedger, entity_id: str) -> int:
+    return REACTIONS_PER_ROUND if can_react(ledger, entity_id) else 0
+
+
+def spend_reaction(ledger: ReactionLedger, entity_id: str) -> bool:
+    """Spend the reaction. True if spent, False if already spent this round (the
+    ceiling refusing a second) or the id is empty."""
+    if not entity_id:
+        return False
+    if ledger.spent_in_round.get(entity_id) == ledger.round:
+        return False
+    ledger.spent_in_round[entity_id] = ledger.round
+    return True
+
+
+def advance_reaction_round(ledger: ReactionLedger) -> int:
+    """Advance to the next round - everyone's reaction refreshes (prior records
+    become stale). Returns the new round number."""
+    ledger.round += 1
+    return ledger.round
+
+
+def set_reaction_round(ledger: ReactionLedger, round_no: int) -> None:
+    if isinstance(round_no, int) and round_no > 0:
+        ledger.round = round_no
+
+
+def prune_stale_spends(ledger: ReactionLedger) -> int:
+    """Drop spend-records older than the current round (memory bound). Behavior
+    unchanged - stale records are already inert. Returns the count removed."""
+    stale = [eid for eid, r in ledger.spent_in_round.items() if r < ledger.round]
+    for eid in stale:
+        del ledger.spent_in_round[eid]
+    return len(stale)
+
+
+def clear_reactions(ledger: ReactionLedger) -> None:
+    ledger.spent_in_round.clear()
+
+
+def reaction_ledger_snapshot(ledger: ReactionLedger) -> dict:
+    """Deterministic, insertion-ordered snapshot for serialization / replay."""
+    return {
+        "round": ledger.round,
+        "spent": [{"entity_id": eid, "round": r}
+                  for eid, r in ledger.spent_in_round.items()],
+    }
+
+
+RESOURCE_REACTION_ECONOMY = "reactionEconomy"

loom_engine_rpg-2.3.0/loom_engine/ruleset.py

@@ -0,0 +1,170 @@
+"""loom_engine.ruleset - 5e + PF2e action economy / initiative / conditions.
+
+Byte-parity hand-port of the TypeScript runtime/ruleset.ts. Deterministic +
+content-agnostic (condition NAMES are caller-supplied, so no SRD text is
+reproduced). Compatible with the D&D 5e SRD (CC-BY-4.0) and the Pathfinder 2e
+Remaster ruleset (ORC License) - see ../../NOTICE.md. Pure (no RNG; the d20 is
+rolled by the engine PRNG - this does the ruleset-correct ORDERING).
+"""
+
+from __future__ import annotations
+
+import functools
+from typing import Dict, List, Optional
+
+RULESET_5E = "5e"
+RULESET_PF2E = "pf2e"
+
+
+# ---- action economy ----
+
+def start_turn_budget(ruleset: str) -> dict:
+    """5e: 1 action + 1 bonus + 1 reaction. PF2e: 3 actions + 1 reaction."""
+    if ruleset == RULESET_PF2E:
+        return {"ruleset": RULESET_PF2E, "resources": {"action": 3, "reaction": 1}}
+    return {"ruleset": RULESET_5E,
+            "resources": {"action": 1, "bonus": 1, "reaction": 1}}
+
+
+def can_spend(budget: dict, resource: str, n: int = 1) -> bool:
+    need = n if isinstance(n, int) and n > 0 else 1
+    have = budget.get("resources", {}).get(resource)
+    return isinstance(have, int) and have >= need
+
+
+def spend(budget: dict, resource: str, n: int = 1) -> bool:
+    """Spend n (default 1) of a resource. True if spent, False if insufficient."""
+    need = n if isinstance(n, int) and n > 0 else 1
+    if not can_spend(budget, resource, need):
+        return False
+    budget["resources"][resource] -= need
+    return True
+
+
+# ---- initiative ordering ----
+
+def _is_pure_numeric(s: str) -> bool:
+    """An optional '-' then >=1 ASCII digit."""
+    rest = s[1:] if s[:1] == "-" else s
+    return len(rest) > 0 and all("0" <= c <= "9" for c in rest)
+
+
+def _normalize_numeric(s: str):
+    neg = s[:1] == "-"
+    digits = s[1:] if neg else s
+    mag = digits.lstrip("0") or "0"
+    return (neg and mag != "0", mag)  # -0 is +0
+
+
+def _byte_cmp(a: str, b: str) -> int:
+    ba = a.encode("utf-8")
+    bb = b.encode("utf-8")
+    return -1 if ba < bb else (1 if ba > bb else 0)
+
+
+def compare_ids(a: str, b: str) -> int:
+    """Numeric-aware id comparison (Codex P1 / the shadow-wire finding). Numeric
+    ids sort by VALUE (2 < 10), strings lexicographically, numbers before strings.
+    No int parsing - sign + digit-length + UTF-8 bytes, so ids beyond i64 (uuids,
+    huge numbers) are correct. Byte-identical to the TS + Rust comparators."""
+    na = _is_pure_numeric(a)
+    nb = _is_pure_numeric(b)
+    if na and not nb:
+        return -1  # numbers before strings
+    if not na and nb:
+        return 1
+    if not na and not nb:
+        return _byte_cmp(a, b)
+    a_neg, a_mag = _normalize_numeric(a)
+    b_neg, b_mag = _normalize_numeric(b)
+    if not a_neg and b_neg:
+        return 1  # +a > -b
+    if a_neg and not b_neg:
+        return -1
+    if len(a_mag) != len(b_mag):
+        mag = -1 if len(a_mag) < len(b_mag) else 1
+    else:
+        mag = _byte_cmp(a_mag, b_mag)
+    by_value = -mag if a_neg else mag  # both negative: larger magnitude is smaller
+    if by_value != 0:
+        return by_value
+    return _byte_cmp(a, b)  # math-equal (e.g. "02" vs "2"): raw bytes, total order
+
+
+def _initiative_cmp(a: dict, b: dict) -> int:
+    for key in ("total", "modifier", "d20"):
+        av = int(a.get(key, 0) or 0)
+        bv = int(b.get(key, 0) or 0)
+        if av != bv:
+            return -1 if av > bv else 1  # DESC
+    return compare_ids(str(a.get("id", "")), str(b.get("id", "")))
+
+
+def initiative_order(entries: List[dict]) -> List[dict]:
+    """Deterministic order: total DESC, then modifier DESC, then natural d20 DESC,
+    then a NUMERIC-AWARE id tiebreak (compare_ids). Correct for BOTH 5e and PF2e
+    and for integer ids AND string entity ids. New list; input untouched."""
+    return sorted(list(entries), key=functools.cmp_to_key(_initiative_cmp))
+
+
+# ---- conditions (content-agnostic duration tracker) ----
+
+DURATION_UNTIL_REMOVED = -1
+
+
+def create_condition_track() -> dict:
+    return {"conditions": {}}
+
+
+def apply_condition(track: dict, condition_id: str, rounds: Optional[int] = None) -> None:
+    """Apply / refresh a condition. rounds 0 or None -> 'until removed'."""
+    if not condition_id:
+        return
+    r = int(rounds) if isinstance(rounds, int) else DURATION_UNTIL_REMOVED
+    if r == 0:
+        r = DURATION_UNTIL_REMOVED
+    track["conditions"][condition_id] = r
+
+
+def remove_condition(track: dict, condition_id: str) -> bool:
+    if condition_id in track["conditions"]:
+        del track["conditions"][condition_id]
+        return True
+    return False
+
+
+def has_condition(track: dict, condition_id: str) -> bool:
+    return condition_id in track["conditions"]
+
+
+def condition_remaining(track: dict, condition_id: str) -> int:
+    return track["conditions"].get(condition_id, 0)
+
+
+def tick_conditions(track: dict) -> List[str]:
+    """Tick every FINITE condition down one round; expire (remove) any reaching 0.
+    DURATION_UNTIL_REMOVED never ticks. Returns expired ids (insertion order)."""
+    conds = track["conditions"]
+    expired: List[str] = []
+    for cid, rem in list(conds.items()):
+        if rem == DURATION_UNTIL_REMOVED:
+            continue
+        if rem <= 1:
+            expired.append(cid)
+        else:
+            conds[cid] = rem - 1
+    for cid in expired:
+        del conds[cid]
+    # Codex P1: SORTED by UTF-8 bytes so the result matches the Rust core's
+    # BTreeMap order - identical across languages, not insertion-dependent.
+    expired.sort(key=lambda s: s.encode("utf-8"))
+    return expired
+
+
+def active_conditions(track: dict) -> List[str]:
+    """Active condition ids in canonical SORTED order (UTF-8 bytes), matching the
+    Rust core's BTreeMap - identical across languages."""
+    return sorted(track["conditions"].keys(), key=lambda s: s.encode("utf-8"))
+
+
+RESOURCE_RULESET = "ruleset"

loom_engine_rpg-2.3.0/loom_engine_rpg.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: loom-engine-rpg
+Version: 2.3.0
+Summary: Deterministic TTRPG simulation core for AI-run games - the Python surface of loom-engine. Engine-is-truth: seeded, replay-safe rules the AI narrates but cannot invent.
+License-Expression: BUSL-1.1
+Project-URL: Homepage, https://www.npmjs.com/package/loom-engine
+Keywords: ttrpg,rpg,deterministic,ai-game-master,5e,pathfinder,simulation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+
+# loom-engine (Python)
+
+The Python surface of [loom-engine](https://www.npmjs.com/package/loom-engine) - a
+deterministic rules core for AI-run tabletop and RPG games.
+
+```sh
+pip install loom-engine-rpg   # the bare 'loom-engine' name is taken on PyPI
+```
+```python
+import loom_engine            # the import name is loom_engine
+```
+
+The design principle: **the engine is truth.** Dice, action economy, initiative,
+range, conditions, reactions, and validation are resolved by pure, replay-safe
+code. An AI narrator can describe the outcome, but it never gets to invent the
+roll, change the numbers, or rewrite what happened.
+
+This package is a **byte-parity** port of the TypeScript engine: the same inputs
+produce identical results in Python (your server/backend) and TypeScript (the
+browser), so a server-authoritative resolution and a client one can never
+disagree. That parity is enforced by a shared cross-language golden-vector suite.
+
+## Modules (v2.3.0)
+
+- `loom_engine.range_bands` - grid-free Engaged/Near/Far positioning.
+- `loom_engine.reaction_economy` - the per-round "1 reaction per combatant" ceiling.
+- `loom_engine.narration_contract` - `find_invented_number`: reject prose that
+  states a mechanics number the engine never produced (numerals **and** number-words).
+- `loom_engine.ruleset` - 5e + PF2e action economy, initiative ordering, conditions.
+
+Pure stdlib, zero runtime dependencies. Compatible with the D&D 5e SRD (CC-BY-4.0)
+and the Pathfinder 2e Remaster ruleset (ORC License); see `../NOTICE.md`. Not
+affiliated with or endorsed by Wizards of the Coast or Paizo.
+
+## Determinism
+
+These modules use ordered dicts + explicit sorts for all logic (never `hash()`
+ordering). For any cross-language hashing, serialize with
+`json.dumps(obj, sort_keys=True, separators=(',', ':'))` and run with
+`PYTHONHASHSEED=0`. Floats are banned in deterministic paths.

loom_engine_rpg-2.3.0/loom_engine_rpg.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+loom_engine/__init__.py
+loom_engine/narration_contract.py
+loom_engine/py.typed
+loom_engine/range_bands.py
+loom_engine/reaction_economy.py
+loom_engine/ruleset.py
+loom_engine_rpg.egg-info/PKG-INFO
+loom_engine_rpg.egg-info/SOURCES.txt
+loom_engine_rpg.egg-info/dependency_links.txt
+loom_engine_rpg.egg-info/requires.txt
+loom_engine_rpg.egg-info/top_level.txt
+tests/test_golden_vectors.py
+tests/test_narration_contract.py
+tests/test_range_bands.py
+tests/test_reaction_economy.py
+tests/test_ruleset.py

loom_engine_rpg-2.3.0/loom_engine_rpg.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

loom_engine_rpg-2.3.0/loom_engine_rpg.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[test]
+pytest>=7.0.0

loom_engine_rpg-2.3.0/loom_engine_rpg.egg-info/top_level.txt

@@ -0,0 +1 @@
+loom_engine

loom_engine_rpg-2.3.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+# pip-install name: 'loom-engine' is blocked on PyPI (too similar to the
+# unrelated existing 'loomengine'). The IMPORT name stays `loom_engine`; the
+# npm package stays `loom-engine`. Like `pip install beautifulsoup4` -> `import bs4`.
+name = "loom-engine-rpg"
+version = "2.3.0"  # pinned to track the npm loom-engine version
+description = "Deterministic TTRPG simulation core for AI-run games - the Python surface of loom-engine. Engine-is-truth: seeded, replay-safe rules the AI narrates but cannot invent."
+readme = "README.md"
+requires-python = ">=3.9"
+# SPDX expression (PEP 639) - matches the npm package. The free-text
+# `{ text = ... }` form emits a deprecated Metadata-2.4 `License:` field that
+# PyPI rejects with a 400. Full terms: LICENSE + COMMERCIAL_LICENSE_TERMS.md.
+license = "BUSL-1.1"
+keywords = ["ttrpg", "rpg", "deterministic", "ai-game-master", "5e", "pathfinder", "simulation"]
+dependencies = []  # ZERO runtime deps - the deterministic core is pure stdlib
+
+[project.optional-dependencies]
+test = ["pytest>=7.0.0"]
+
+[project.urls]
+Homepage = "https://www.npmjs.com/package/loom-engine"
+
+[build-system]
+requires = ["setuptools>=77.0.0"]  # PEP 639 SPDX `license = "..."` support
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["loom_engine"]
+
+[tool.setuptools.package-data]
+loom_engine = ["py.typed"]

loom_engine_rpg-2.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

loom_engine_rpg-2.3.0/tests/test_golden_vectors.py

@@ -0,0 +1,93 @@
+"""Cross-language golden-vector runner (Python side).
+
+Loads the SHARED test_vectors/*.json - the same files the TS (and future Rust)
+harnesses load - and asserts the Python implementation produces the canonical
+outputs. If TS and Python both pass against the same vectors, they are proven
+byte-identical for those cases. This is the parity gate.
+
+Run: python python/tests/test_golden_vectors.py
+"""
+import functools
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, ".."))
+VECTOR_DIR = os.path.join(HERE, "..", "..", "test_vectors")
+
+from loom_engine.range_bands import band_from_distance_ft, band_within  # noqa: E402
+from loom_engine.narration_contract import find_invented_number  # noqa: E402
+from loom_engine.ruleset import initiative_order, compare_ids  # noqa: E402
+from loom_engine.reaction_economy import (  # noqa: E402
+    create_reaction_ledger, can_react, spend_reaction, advance_reaction_round,
+)
+
+PASS = 0
+FAIL = 0
+
+
+def ck(label, cond):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print("  OK   " + label)
+    else:
+        FAIL += 1
+        print("  FAIL " + label)
+
+
+def run_reaction_script(ops):
+    """Replay a scripted op list against a fresh ledger; return the result list."""
+    ledger = create_reaction_ledger()
+    out = []
+    for op in ops:
+        kind = op[0]
+        if kind == "spend":
+            out.append(spend_reaction(ledger, op[1]))
+        elif kind == "can_react":
+            out.append(can_react(ledger, op[1]))
+        elif kind == "advance":
+            out.append(advance_reaction_round(ledger))
+    return out
+
+
+def main():
+    path = os.path.join(VECTOR_DIR, "v2_3_0_primitives.json")
+    with open(path, "r", encoding="utf-8") as f:
+        vectors = json.load(f)
+
+    for case in vectors["range_bands.band_from_distance_ft"]:
+        got = band_from_distance_ft(case["args"][0])
+        ck("band_from_distance_ft%s -> %s" % (case["args"], case["expect"]),
+           got == case["expect"])
+
+    for case in vectors["range_bands.band_within"]:
+        got = band_within(case["args"][0], case["args"][1])
+        ck("band_within%s -> %s" % (case["args"], case["expect"]),
+           got == case["expect"])
+
+    for case in vectors["narration.find_invented_number"]:
+        got = find_invented_number(case["args"][0], case["args"][1])
+        ck("find_invented_number(%r,...) -> %s" % (case["args"][0][:24], case["expect"]),
+           got == case["expect"])
+
+    for case in vectors["ruleset.initiative_order_ids"]:
+        got = [e["id"] for e in initiative_order(case["entries"])]
+        ck("initiative_order_ids -> %s" % case["expect"], got == case["expect"])
+
+    for case in vectors["ruleset.compare_ids"]:
+        got = sorted(case["input"], key=functools.cmp_to_key(compare_ids))
+        ck("compare_ids %s -> %s" % (case["input"], case["expect_asc"]),
+           got == case["expect_asc"])
+
+    for case in vectors["reaction.scripted"]:
+        got = run_reaction_script(case["ops"])
+        ck("reaction.scripted -> %s" % case["expect"], got == case["expect"])
+
+    print("\npassed=%d failed=%d" % (PASS, FAIL))
+    sys.exit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    main()

loom_engine_rpg-2.3.0/tests/test_narration_contract.py

@@ -0,0 +1,58 @@
+"""Parity tests for loom_engine.narration_contract (mirror tests/narration-contract.test.ts).
+
+Run: python python/tests/test_narration_contract.py
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+from loom_engine.narration_contract import (  # noqa: E402
+    parse_number_word, extract_candidate_numbers, find_invented_number,
+    is_narration_grounded, RESOURCE_NARRATION_CONTRACT,
+)
+
+PASS = 0
+FAIL = 0
+
+
+def ck(label, cond):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print("  OK   " + label)
+    else:
+        FAIL += 1
+        print("  FAIL " + label)
+
+
+ck("RESOURCE key", RESOURCE_NARRATION_CONTRACT == "narrationContract")
+
+ck("parse seven", parse_number_word("seven") == 7)
+ck("parse twenty", parse_number_word("twenty") == 20)
+ck("parse twenty-one", parse_number_word("twenty-one") == 21)
+ck("parse twenty one", parse_number_word("twenty one") == 21)
+ck("parse ninety-nine", parse_number_word("ninety-nine") == 99)
+ck("parse banana None", parse_number_word("banana") is None)
+
+ck("extract numerals + words", extract_candidate_numbers("you roll 18 and take 7 damage") == [18, 7])
+ck("extract words folded", extract_candidate_numbers("seven damage, a total of twenty-one") == [7, 21])
+ck("extract 1,024", extract_candidate_numbers("1,024 gold pieces") == [1024])
+ck("extract none", extract_candidate_numbers("no numbers here") == [])
+
+ck("grounded numeral", find_invented_number("Your blade bites for 7 damage.", [7]) is None)
+ck("invented numeral", find_invented_number("Your blade bites for 9 damage.", [7]) == 9)
+ck("grounded number-word", find_invented_number("You take seven damage.", [7]) is None)
+ck("invented number-word", find_invented_number("You take eight damage.", [7]) == 8)
+
+attested = [18, 15, 7]
+ck("full attested exchange grounded",
+   is_narration_grounded("You roll 18 against DC 15 and deal 7 damage.", attested) is True)
+ck("one stray invented",
+   find_invented_number("You roll 18 against DC 15 and deal twenty-one damage.", attested) == 21)
+
+ck("small flavor ignored", find_invented_number("Two guards block the door.", []) is None)
+ck("floor=0 scrutinizes", find_invented_number("Two guards block the door.", [], 0) == 2)
+
+print("\npassed=%d failed=%d" % (PASS, FAIL))
+sys.exit(1 if FAIL else 0)

loom_engine_rpg-2.3.0/tests/test_range_bands.py

@@ -0,0 +1,88 @@
+"""Parity tests for loom_engine.range_bands - assertions mirror the TypeScript
+tests/range-bands.test.ts so the two implementations stay byte-identical.
+
+Run: python python/tests/test_range_bands.py
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+from loom_engine.range_bands import (  # noqa: E402
+    band_from_distance_ft,
+    normalize_band,
+    band_within,
+    compare_bands,
+    RangeBandField,
+    RANGE_BAND_ENGAGED,
+    RANGE_BAND_NEAR,
+    RANGE_BAND_FAR,
+    RESOURCE_RANGE_BANDS,
+)
+
+PASS = 0
+FAIL = 0
+
+
+def ck(label, cond):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print("  OK   " + label)
+    else:
+        FAIL += 1
+        print("  FAIL " + label)
+
+
+ck("RESOURCE key stable", RESOURCE_RANGE_BANDS == "rangeBands")
+
+# integer-feet contract: fractions truncate toward zero (parity with TS / Rust)
+ck("0 -> engaged", band_from_distance_ft(0) == RANGE_BAND_ENGAGED)
+ck("5 -> engaged", band_from_distance_ft(5) == RANGE_BAND_ENGAGED)
+ck("5.49 -> engaged (trunc 5)", band_from_distance_ft(5.49) == RANGE_BAND_ENGAGED)
+ck("30 -> near", band_from_distance_ft(30) == RANGE_BAND_NEAR)
+ck("30.49 -> near (trunc 30)", band_from_distance_ft(30.49) == RANGE_BAND_NEAR)
+ck("31 -> far", band_from_distance_ft(31) == RANGE_BAND_FAR)
+ck("inf -> far", band_from_distance_ft(float("inf")) == RANGE_BAND_FAR)
+ck("-10 -> near (defensive)", band_from_distance_ft(-10) == RANGE_BAND_NEAR)
+ck("nan -> near (defensive)", band_from_distance_ft(float("nan")) == RANGE_BAND_NEAR)
+ck("junk -> near (defensive)", band_from_distance_ft("xyz") == RANGE_BAND_NEAR)
+
+ck("normalize valid", normalize_band("engaged") == RANGE_BAND_ENGAGED)
+ck("normalize junk -> None", normalize_band("sideways") is None)
+
+ck("within engaged<=near", band_within("engaged", "near") is True)
+ck("within far<=near False", band_within("far", "near") is False)
+ck("within near<=engaged False", band_within("near", "engaged") is False)
+ck("compare_bands engaged<near", compare_bands("engaged", "near") < 0)
+ck("compare_bands far>near", compare_bands("far", "near") > 0)
+ck("compare_bands near==near", compare_bands("near", "near") == 0)
+
+# field: symmetric write + derive from distance
+f = RangeBandField()
+ck("set dist=5 -> engaged", f.set_pair("pc", "goblin", distance_feet=5) == RANGE_BAND_ENGAGED)
+ck("get pc->goblin engaged", f.get_band("pc", "goblin") == RANGE_BAND_ENGAGED)
+ck("get goblin->pc engaged (symmetric)", f.get_band("goblin", "pc") == RANGE_BAND_ENGAGED)
+ck("is_engaged True", f.is_engaged("pc", "goblin") is True)
+
+ck("explicit band wins", f.set_pair("pc", "g2", band=RANGE_BAND_FAR, distance_feet=5) == RANGE_BAND_FAR)
+ck("no band/dist -> near", f.set_pair("pc", "g3") == RANGE_BAND_NEAR)
+
+f2 = RangeBandField()
+f2.set_pair("pc", "goblin", distance_feet=5)
+f2.set_pair("pc", "archer", distance_feet=20)
+f2.set_pair("pc", "sniper", distance_feet=60)
+ck("targets_within near = engaged+near", sorted(f2.targets_within("pc", "near")) == ["archer", "goblin"])
+ck("engaged_with = [goblin]", f2.engaged_with("pc") == ["goblin"])
+ck("targets_within far = all 3", len(f2.targets_within("pc", "far")) == 3)
+
+f3 = RangeBandField()
+f3.set_pair("pc", "g", band=RANGE_BAND_ENGAGED, symmetric=False)
+ck("asymmetric: pc->g set", f3.get_band("pc", "g") == RANGE_BAND_ENGAGED)
+ck("asymmetric: g->pc not set", f3.get_band("g", "pc") is None)
+ck("self-pair no-op", (f3.set_pair("x", "x", band=RANGE_BAND_ENGAGED) and f3.get_band("x", "x")) is None)
+snap = f3.snapshot()
+ck("snapshot shape", len(snap) == 1 and snap[0] == {"source": "pc", "target": "g", "band": RANGE_BAND_ENGAGED})
+
+print("\npassed=%d failed=%d" % (PASS, FAIL))
+sys.exit(1 if FAIL else 0)

loom_engine_rpg-2.3.0/tests/test_reaction_economy.py

@@ -0,0 +1,72 @@
+"""Parity tests for loom_engine.reaction_economy (mirror tests/reaction-economy.test.ts).
+
+Run: python python/tests/test_reaction_economy.py
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+from loom_engine.reaction_economy import (  # noqa: E402
+    REACTIONS_PER_ROUND, create_reaction_ledger, can_react, reactions_remaining,
+    spend_reaction, advance_reaction_round, set_reaction_round,
+    prune_stale_spends, clear_reactions, reaction_ledger_snapshot,
+    RESOURCE_REACTION_ECONOMY,
+)
+
+PASS = 0
+FAIL = 0
+
+
+def ck(label, cond):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print("  OK   " + label)
+    else:
+        FAIL += 1
+        print("  FAIL " + label)
+
+
+ck("constants", REACTIONS_PER_ROUND == 1 and RESOURCE_REACTION_ECONOMY == "reactionEconomy")
+
+l = create_reaction_ledger()
+ck("fresh round 1", l.round == 1)
+ck("fresh can_react", can_react(l, "pc") is True)
+ck("reactions_remaining 1", reactions_remaining(l, "pc") == 1)
+ck("spend once True", spend_reaction(l, "pc") is True)
+ck("can_react False after spend", can_react(l, "pc") is False)
+ck("reactions_remaining 0", reactions_remaining(l, "pc") == 0)
+ck("spend twice False (ceiling)", spend_reaction(l, "pc") is False)
+ck("foe independent", can_react(l, "goblin") is True)
+ck("spend foe", spend_reaction(l, "goblin") is True)
+
+ck("advance -> round 2", advance_reaction_round(l) == 2)
+ck("refresh pc", can_react(l, "pc") is True)
+ck("refresh goblin", can_react(l, "goblin") is True)
+ck("spend again round 2", spend_reaction(l, "pc") is True)
+
+l2 = create_reaction_ledger()
+spend_reaction(l2, "pc")           # round 1
+advance_reaction_round(l2)         # round 2; round-1 record stale
+ck("stale record inert", can_react(l2, "pc") is True)
+
+ck("empty id no-op", spend_reaction(l2, "") is False and can_react(l2, "") is False)
+
+l3 = create_reaction_ledger()
+spend_reaction(l3, "pc")
+spend_reaction(l3, "goblin")
+set_reaction_round(l3, 3)
+set_reaction_round(l3, -5)         # ignored
+ck("set_reaction_round", l3.round == 3)
+ck("pc free after round set", can_react(l3, "pc") is True)
+ck("prune removes 2 stale", prune_stale_spends(l3) == 2)
+ck("snapshot empty after prune", len(reaction_ledger_snapshot(l3)["spent"]) == 0)
+spend_reaction(l3, "pc")
+snap = reaction_ledger_snapshot(l3)
+ck("snapshot shape", snap["round"] == 3 and snap["spent"] == [{"entity_id": "pc", "round": 3}])
+clear_reactions(l3)
+ck("clear empties", len(reaction_ledger_snapshot(l3)["spent"]) == 0)
+
+print("\npassed=%d failed=%d" % (PASS, FAIL))
+sys.exit(1 if FAIL else 0)

loom_engine_rpg-2.3.0/tests/test_ruleset.py

@@ -0,0 +1,77 @@
+"""Parity tests for loom_engine.ruleset (mirror tests/ruleset.test.ts).
+
+Run: python python/tests/test_ruleset.py
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+from loom_engine.ruleset import (  # noqa: E402
+    start_turn_budget, can_spend, spend, initiative_order,
+    create_condition_track, apply_condition, remove_condition, has_condition,
+    condition_remaining, tick_conditions, active_conditions,
+    DURATION_UNTIL_REMOVED, RESOURCE_RULESET,
+)
+
+PASS = 0
+FAIL = 0
+
+
+def ck(label, cond):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print("  OK   " + label)
+    else:
+        FAIL += 1
+        print("  FAIL " + label)
+
+
+ck("RESOURCE key", RESOURCE_RULESET == "ruleset")
+
+b5 = start_turn_budget("5e")
+ck("5e budget", b5["resources"] == {"action": 1, "bonus": 1, "reaction": 1})
+ck("5e spend action", spend(b5, "action") is True)
+ck("5e action exhausted", spend(b5, "action") is False)
+ck("5e bonus ok", spend(b5, "bonus") is True)
+
+bp = start_turn_budget("pf2e")
+ck("pf2e budget", bp["resources"] == {"action": 3, "reaction": 1})
+ck("pf2e spend 1", spend(bp, "action") is True)
+ck("pf2e spend 2 more", spend(bp, "action", 2) is True)
+ck("pf2e 0 left", spend(bp, "action") is False)
+ck("pf2e reaction", spend(bp, "reaction") is True and spend(bp, "reaction") is False)
+
+order = initiative_order([
+    {"id": "c", "total": 18, "modifier": 2, "d20": 16},
+    {"id": "a", "total": 18, "modifier": 5, "d20": 13},
+    {"id": "b", "total": 12, "modifier": 1, "d20": 11},
+    {"id": "d", "total": 18, "modifier": 2, "d20": 16},
+])
+ck("initiative tiebreak total>mod>d20>id", [e["id"] for e in order] == ["a", "c", "d", "b"])
+inp = [{"id": "x", "total": 5}, {"id": "y", "total": 9}]
+out = initiative_order(inp)
+ck("initiative no-mutate", inp[0]["id"] == "x" and [e["id"] for e in out] == ["y", "x"])
+
+t = create_condition_track()
+apply_condition(t, "frightened", 3)
+apply_condition(t, "prone")
+ck("has frightened", has_condition(t, "frightened") is True)
+ck("remaining 3", condition_remaining(t, "frightened") == 3)
+ck("prone until removed", condition_remaining(t, "prone") == DURATION_UNTIL_REMOVED)
+ck("absent -> 0", condition_remaining(t, "poisoned") == 0)
+ck("remove prone", remove_condition(t, "prone") is True and has_condition(t, "prone") is False)
+
+t2 = create_condition_track()
+apply_condition(t2, "frightened", 2)
+apply_condition(t2, "slowed", 1)
+apply_condition(t2, "doomed")
+ck("tick expires slowed", tick_conditions(t2) == ["slowed"])
+ck("frightened decremented", condition_remaining(t2, "frightened") == 1)
+ck("active after tick", sorted(active_conditions(t2)) == ["doomed", "frightened"])
+ck("tick expires frightened", tick_conditions(t2) == ["frightened"])
+ck("until-removed survives", active_conditions(t2) == ["doomed"])
+
+print("\npassed=%d failed=%d" % (PASS, FAIL))
+sys.exit(1 if FAIL else 0)