loom-engine-rpg 2.3.0__py3-none-any.whl

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/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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+loom_engine/__init__.py,sha256=-MyEtMTBgIS9ACMtNZVhF6nwUpMkTqK6xPDVRlX28Cg,1972
+loom_engine/narration_contract.py,sha256=enD1U02eFXqOntCxYlXhs4DRj977XQIJRBK64y7ybQ4,3608
+loom_engine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loom_engine/range_bands.py,sha256=_62e2_ZmU-urE49fkp8fgpz8s7nk2FOzh4MTMrfCcko,4496
+loom_engine/reaction_economy.py,sha256=WMwJgCJDT91aEbCwHf_Us-NHSiVds7EvtX8VksEa-aE,3029
+loom_engine/ruleset.py,sha256=EPhfSS22saOUcqY0l8zxyCACGQIF3i51yiciVBOUmzg,6017
+loom_engine_rpg-2.3.0.dist-info/METADATA,sha256=VE3YZsQ7c0yMWmqwrexe3oyKX0WkOpGrcuYt8yrcuCA,2465
+loom_engine_rpg-2.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+loom_engine_rpg-2.3.0.dist-info/top_level.txt,sha256=BoKxcCuIL36tXd6FJOI8NtTv6xgsbHP_zd2rUJTocxw,12
+loom_engine_rpg-2.3.0.dist-info/RECORD,,

loom_engine_rpg-2.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

loom_engine_rpg-2.3.0.dist-info/top_level.txt

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