kirby-api 0.2.2__tar.gz → 0.2.3__tar.gz

{kirby_api-0.2.2/kirby_api.egg-info → kirby_api-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kirby-api
-Version: 0.2.2
+Version: 0.2.3
 Summary: Kirby — HERO System VTT backend API (FastAPI mono)
 Author: PeterB
 License: PolyForm Noncommercial License 1.0.0
@@ -22,7 +22,7 @@ Requires-Dist: cryptography>=44
 Requires-Dist: python-jose[cryptography]>=3.3
 Requires-Dist: pyjwt[crypto]>=2.10
 Requires-Dist: redis>=5.2
-Requires-Dist: kirby-cost>=0.6.1
+Requires-Dist: kirby-cost>=0.6.2
 Requires-Dist: lxml>=5.3
 Requires-Dist: python-multipart>=0.0.20
 Requires-Dist: email-validator>=2.2

kirby_api-0.2.3/kirby/_migrations/versions/20261005_0002_build_doc_fields.py

@@ -0,0 +1,43 @@
+"""columns for the build-doc fields kirby-cost 0.6.2 writes
+
+kirby-cost 0.6.2 stops dropping three things from the canonical build doc,
+and a doc stored here must keep them or the database rebuild differs from the
+engine's own load:
+
+* ``native_tongue`` on a Language -> ``object_skill_mode.native_tongue``.
+  A native tongue is free; without the flag Bokor rebuilds at 279 against
+  his file's 276.
+* the Resistant Protection split -> ``character_objects.pd_levels`` /
+  ``ed_levels`` / ``md_levels`` / ``powd_levels``. Cost is by LEVELS, so the
+  split moves no points; it is which half is physical, which a fight needs.
+* the EQUIPMENT section needs no column: it is stored as rows of
+  object_type ``equipment``.
+
+All nullable and additive: NULL reads back as "not written", which is what
+every row stored before this migration is.
+
+Revision ID: 20261005_0002
+Revises: 20261005_0001
+Create Date: 2026-10-05
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "20261005_0002"
+down_revision = "20261005_0001"
+branch_labels = None
+depends_on = None
+
+_SPLIT = ("pd_levels", "ed_levels", "md_levels", "powd_levels")
+
+
+def upgrade() -> None:
+    for col in _SPLIT:
+        op.add_column("character_objects", sa.Column(col, sa.Integer(), nullable=True))
+    op.add_column("object_skill_mode", sa.Column("native_tongue", sa.Boolean(), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column("object_skill_mode", "native_tongue")
+    for col in _SPLIT:
+        op.drop_column("character_objects", col)

{kirby_api-0.2.2 → kirby_api-0.2.3}/kirby/builds/build_doc_store.py

@@ -34,7 +34,9 @@ _SCALAR_FIELDS = ("levels", "option_id", "input", "notes", "text", "base_cost",
                   # therefore means "not stated", i.e. the engine's True.
                   "affects_primary", "affects_total",
                   "level_cost", "level_value", "min_cost", "max_cost",
-                  "selected", "required", "private", "group", "sense_active")
+                  "selected", "required", "private", "group", "sense_active",
+                  # Resistant Protection's split (kirby-cost >= 0.6.2).
+                  "pd_levels", "ed_levels", "md_levels", "powd_levels")
 _COL = {"input": "input_value",  # build-doc 'input' is stored as input_value
         "text": "text_value",   # 'text' collides with the SQL type name
         "group": "sense_group"}  # 'group' is a SQL reserved word -> sense_group
@@ -44,12 +46,15 @@ _COL = {"input": "input_value",  # build-doc 'input' is stored as input_value
 # min_set/max_set flag is on (value may be exactly 0.0). The DB distinguishes
 # "set to 0.0" (stored 0.0) from "unset" (stored NULL), so a NULL check alone
 # is the right gate for those two.
-_ZERO_SUPPRESSED = {"levels", "base_cost", "level_cost", "level_value"}
+_ZERO_SUPPRESSED = {"levels", "base_cost", "level_cost", "level_value",
+                    "pd_levels", "ed_levels", "md_levels", "powd_levels"}
 _SECTIONS = ("characteristics", "powers", "skills", "perks", "talents", "disadvantages",
-             "martial_arts")
+             "martial_arts", "equipment")
+# Carried gear is its own section (kirby-cost >= 0.6.2) and its own row type,
+# so it reconstructs into "equipment" rather than joining the innate powers.
 _OTYPE = {"characteristics": "characteristic", "powers": "power", "skills": "skill",
           "perks": "perk", "talents": "talent", "disadvantages": "complication",
-          "martial_arts": "maneuver"}
+          "martial_arts": "maneuver", "equipment": "equipment"}
 _SECTION_TYPES = frozenset(_OTYPE.values())
 
 # ForceWall flat fields (engine emits length_levels/height_levels/body_levels)
@@ -109,7 +114,8 @@ def _persist_object(db, character_id, o, *, object_type, parent_id, position,
     # presence of 'familiarity' marks a skill-mode row.
     if "familiarity" in o:
         db.add(ObjectSkillMode(object_id=row.id,
-               **{f: o.get(f) for f in _SKILL_FIELDS}))
+               **{f: o.get(f) for f in _SKILL_FIELDS},
+               native_tongue=o.get("native_tongue")))
     # Maneuver detail row (marker: engine emits "maneuver": True on Maneuver objects).
     # Note: o.get(f) is not None keeps empty-string effect ("") — do NOT change to truthiness.
     if o.get("maneuver"):
@@ -142,6 +148,21 @@ def _persist_object(db, character_id, o, *, object_type, parent_id, position,
                         parent_id=row.id, position=0, costs=costs)
     return row
 
+def persist_object(db: Session, character_id, o: dict[str, Any], *,
+                   object_type: str, parent_id: int | None, position: int,
+                   costs: dict[str, dict[str, float]] | None = None) -> CharacterObject:
+    """Write ONE build-doc object (and its modifiers, adders, sub-powers,
+    Endurance Reserve REC and typed child rows) under ``character_id``.
+
+    The same writer ``persist_build_doc`` uses for a whole character, for a
+    caller that stores objects one at a time — the power library catalogues
+    single powers under a shared owner. ``costs`` is keyed by doc id, as
+    ``extract_costs(...).per_object`` is.
+    """
+    return _persist_object(db, character_id, o, object_type=object_type,
+                           parent_id=parent_id, position=position, costs=costs)
+
+
 def save_build_doc(db: Session, character, doc: dict[str, Any]) -> tuple[dict[str, Any], Any]:
     """Persist an edited build doc onto a character. Normalizes through the
     engine (build_from_json validates + canonicalizes), then persist_loaded
@@ -292,6 +313,10 @@ def _row_to_doc_obj(row, rows_by_id, children_by_parent, fw, sm, mv, prov, rowid
                     o[f] = val
             else:
                 o[f] = bool(val)
+        # Written by the engine on a Language only, so NULL means "not a
+        # Language" (or stored before the column existed) and stays absent.
+        if smr.native_tongue is not None:
+            o["native_tongue"] = bool(smr.native_tongue)
     if row.id in prov:
         o["provides"] = prov[row.id]
     # Maneuver detail fields (reverse of _persist_object; emission conditions

{kirby_api-0.2.2 → kirby_api-0.2.3}/kirby/builds/cli.py

@@ -71,28 +71,6 @@ def cmd_import_template(args) -> int:
     return 0
 
 
-def cmd_import_corpus(args) -> int:
-    from kirby.builds.json_importer import (
-        JSONImporter, _resolve_owner, _resolve_tenant,
-    )
-
-    with SessionLocal() as db:
-        tenant_id = _resolve_tenant(db, args.tenant)
-        owner_id = _resolve_owner(db, args.owner)
-        importer = JSONImporter(db, tenant_id=tenant_id, owner_id=owner_id)
-        counts = importer.import_directory(
-            args.corpus_dir,
-            glob=args.glob,
-            skip_prefix=tuple(args.skip_prefix),
-        )
-
-    sys.stderr.write("\nImported by source:\n")
-    for src in sorted(counts):
-        sys.stderr.write(f"  {src:12s} {counts[src]:>5d}\n")
-    sys.stderr.write(f"  {'TOTAL':12s} {sum(counts.values()):>5d}\n")
-    return 0
-
-
 def cmd_backfill_power_categories(args) -> int:
     """Label stored powers + VPP pools with special-effect categories.
 
@@ -612,33 +590,6 @@ def main() -> int:
     )
     p_import.set_defaults(func=cmd_import_template)
 
-    p_corpus = sub.add_parser(
-        "import-corpus",
-        help="Bulk-import a JSON corpus directory into characters + character_objects",
-    )
-    p_corpus.add_argument(
-        "corpus_dir",
-        help="Directory containing JSON files (e.g. tests/fixtures/oracle/)",
-    )
-    p_corpus.add_argument(
-        "--tenant", default="throwback",
-        help="Tenant slug to attribute imported characters to (default: throwback)",
-    )
-    p_corpus.add_argument(
-        "--owner", default="local-bootstrap",
-        help="User sub to set as owner (default: local-bootstrap)",
-    )
-    p_corpus.add_argument(
-        "--glob", default="*.json",
-        help="Filename glob within corpus_dir (default: *.json)",
-    )
-    p_corpus.add_argument(
-        "--skip-prefix", action="append", default=[],
-        help="Skip files starting with this prefix (repeatable). "
-             "E.g. --skip-prefix bestiary__ to do villains only.",
-    )
-    p_corpus.set_defaults(func=cmd_import_corpus)
-
     p_reimport = sub.add_parser(
         "reimport-hdc",
         help="Re-import a directory of .hdc files (idempotent; backfills maneuvers)",

kirby_api-0.2.3/kirby/builds/json_importer.py

@@ -0,0 +1,117 @@
+"""Character import — the canonical path only.
+
+``JSONImporter.import_hdc_file`` parses an .hdc through the canon engine and
+persists the complete build doc relationally (``persist_loaded``): the engine
+is the single source of structure AND cost.
+
+The module used to also read HD-shaped JSON files (the old HDCConverter
+corpus) and write rows by hand, summing ``total_cost`` itself and filling
+child tables no reader used. That path is gone (kirby-api 0.2.3): the corpus
+is the database, and an .hdc enters it once, through ``import_hdc_file``. The
+class keeps its name because the tests and tooling that construct it do.
+"""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from uuid import UUID
+
+from sqlalchemy.orm import Session
+
+from kirby.auth.models import User
+from kirby.characters.models import CharacterDef
+from kirby.tenants.models import Tenant
+
+
+logger = logging.getLogger(__name__)
+
+
+class JSONImporter:
+    """Imports .hdc files through the canon engine into kirby's tables."""
+
+    def __init__(
+        self, db: Session, tenant_id: UUID, owner_id: UUID,
+        *, category_bearer: str = "",
+    ) -> None:
+        self.db = db
+        self.tenant_id = tenant_id
+        self.owner_id = owner_id
+        # GM Tannhauser JWT used to label powers with special-effect categories
+        # via the generation service. Optional: without it, import proceeds and pools stay
+        # unrestricted (see _populate_categories).
+        self.category_bearer = category_bearer
+
+    # ---------------------------------------------------------------- public
+
+    def import_hdc_file(
+        self, hdc_path: str | Path, *, source: str, is_npc: bool = True,
+    ) -> CharacterDef:
+        """Parse one .hdc via the canon engine, persist its complete build doc
+        relationally (Spec 2/3). The engine is the single source of structure AND
+        cost; kirby stores the build doc + a recomputable cost cache."""
+        from kirby.engines.cost.hdc import build_loader
+        from kirby.builds.build_doc_store import persist_loaded
+
+        hdc_path = Path(hdc_path)
+        # Costs come from kirby's own Main6E catalogue — the same source
+        # load_hdc uses. kirby-cost ships no template, so a bare HDCLoader()
+        # would depend on a file the deployment may not have.
+        loaded = build_loader(self.db).load_file(str(hdc_path))
+        name = (getattr(loaded, "name", "") or "").strip() or hdc_path.stem
+
+        existing = (
+            self.db.query(CharacterDef)
+            .filter_by(tenant_id=self.tenant_id, source=source,
+                       hdc_filename=hdc_path.name)
+            .first()
+        )
+        if existing:
+            self.db.delete(existing)
+            self.db.flush()
+        character = CharacterDef(
+            tenant_id=self.tenant_id, owner_id=self.owner_id, source=source,
+            hdc_filename=hdc_path.name, name=name, is_npc=is_npc,
+        )
+        self.db.add(character)
+        self.db.flush()
+        persist_loaded(self.db, character, loaded)
+        self._populate_categories(character)
+        return character
+
+    def _populate_categories(self, character: CharacterDef) -> None:
+        """Label the freshly-persisted objects with special-effect categories.
+
+        Runs after the objects exist so it can read them relationally. Never
+        raises: categorisation is a labelling pass layered on top of import, and
+        a generation-service outage must not lose a character that already parsed and
+        costed correctly. Without a bearer this is a no-op and pools simply stay
+        unrestricted.
+        """
+        if not self.category_bearer:
+            return
+        from kirby.builds.power_categories import (
+            populate_categories_for_character,
+        )
+
+        try:
+            populate_categories_for_character(
+                self.db, character.id, bearer=self.category_bearer)
+        except Exception:  # noqa: BLE001 — never fail an import over labelling
+            logger.warning("category population failed for %s", character.id,
+                           exc_info=True)
+
+
+# ---------------------------------------------------------------- bootstrap
+
+def _resolve_tenant(db: Session, slug: str) -> UUID:
+    t = db.query(Tenant).filter_by(slug=slug).first()
+    if t is None:
+        raise ValueError(f"Tenant {slug!r} not found in DB")
+    return t.id
+
+
+def _resolve_owner(db: Session, sub: str = "local-bootstrap") -> UUID:
+    u = db.query(User).filter_by(sub=sub).first()
+    if u is None:
+        raise ValueError(f"User with sub={sub!r} not found in DB")
+    return u.id

{kirby_api-0.2.2 → kirby_api-0.2.3}/kirby/builds/models.py

@@ -113,6 +113,12 @@ class CharacterObject(Base):
     private: Mapped[bool | None] = mapped_column(Boolean)
     sense_group: Mapped[str | None] = mapped_column(String(32))
     sense_active: Mapped[bool | None] = mapped_column(Boolean)
+    # Resistant Protection's PD/ED/Mental/Power split. Cost is by LEVELS, so
+    # these move no points; they say which half is physical.
+    pd_levels: Mapped[int | None] = mapped_column(Integer)
+    ed_levels: Mapped[int | None] = mapped_column(Integer)
+    md_levels: Mapped[int | None] = mapped_column(Integer)
+    powd_levels: Mapped[int | None] = mapped_column(Integer)
 
     # build doc carried an explicit base_cost (engine emits 0.0 only when BASECOST was
     # explicit in the source XML); reconstruction must re-emit it
@@ -196,6 +202,9 @@ class ObjectSkillMode(Base):
     levels_only: Mapped[bool | None] = mapped_column(Boolean)
     everyman: Mapped[bool | None] = mapped_column(Boolean)
     characteristic: Mapped[str | None] = mapped_column(String(32))
+    # A Language's NATIVE_TONGUE (it is free). NULL on every other skill: the
+    # engine writes the key on a Language only.
+    native_tongue: Mapped[bool | None] = mapped_column(Boolean)
 
 
 class ObjectManeuver(Base):

{kirby_api-0.2.2 → kirby_api-0.2.3}/kirby/builds/power_library_importer.py

@@ -45,7 +45,6 @@ from kirby.engines.cost.hdc import build_loader
 from kirby.auth.models import User
 from kirby.characters.models import CharacterDef
 from kirby.builds.models import (
-    CharacterObject,
     PowerLibrary,
 )
 from kirby.shared.db import SessionLocal
@@ -167,104 +166,80 @@ def ensure_owner_character(
     return char
 
 
-# ── object_type classifier ──────────────────────────────────────────────────
+# ── the engine's document for a file ───────────────────────────────────────
 
 
-def classify_object_type(obj: Any) -> str:
-    """character_objects.object_type ∈ {power, modifier, adder, ...}."""
-    cls_name = type(obj).__name__.lower()
-    # Modifier class hierarchy in kirby_cost: anything that's an advantage
-    # or limitation is a Modifier subclass. Specific check by XMLID later.
-    if "modifier" in cls_name or "advantage" in cls_name or "limitation" in cls_name:
-        return "modifier"
-    if "adder" in cls_name:
-        return "adder"
-    # XMLIDs for canonical modifiers
-    return "power"
-
-
-# ── recursive insertion ─────────────────────────────────────────────────────
-
+@dataclass
+class FileDoc:
+    """One loaded file's build doc, indexed for cataloguing single powers.
 
-def insert_object_subtree(
+    ``doc_of`` maps an engine object (by identity) to its doc object, so a
+    power picked off ``hero.powers`` finds the document the engine wrote for
+    it. ``costs`` is the per-object cost cache keyed by doc id.
+    """
+    doc_of: dict[int, dict[str, Any]]
+    flat: list[dict[str, Any]]
+    costs: dict[str, dict[str, float]]
+
+
+def file_doc(hero: Any) -> FileDoc:
+    """``to_build_json`` emits one doc object per engine object, in order, so
+    the two lists zip. A length mismatch means that stopped being true, and
+    cataloguing against a misaligned index would file costs under the wrong
+    powers — so it raises instead."""
+    from kirby_cost.io import to_build_json
+
+    doc = to_build_json(hero)
+    doc_of: dict[int, dict[str, Any]] = {}
+    flat: list[dict[str, Any]] = []
+    costs: dict[str, dict[str, float]] = {}
+    for section in ("powers", "equipment"):
+        objs = list(getattr(hero, section, []) or [])
+        docs = doc.get(section) or []
+        if len(objs) != len(docs):
+            raise RuntimeError(
+                f"{section}: {len(objs)} engine objects but {len(docs)} doc objects")
+        for o, d in zip(objs, docs):
+            doc_of[id(o)] = d
+            flat.append(d)
+            costs[d["id"]] = {
+                "base_cost": float(getattr(o, "base_cost", 0) or 0),
+                "active_cost": float(getattr(o, "active_cost", 0) or 0),
+                "real_cost": float(getattr(o, "real_cost", 0) or 0),
+            }
+    return FileDoc(doc_of=doc_of, flat=flat, costs=costs)
+
+
+# ── insertion ───────────────────────────────────────────────────────────────
+
+
+def insert_power_subtree(
     db: Session,
-    obj: Any,
+    d: dict[str, Any],
     *,
+    fdoc: FileDoc,
     character_id: uuid.UUID,
-    parent_id: int | None,
-    position: int,
-    object_type: str | None = None,
-    hero_powers: list[Any] | None = None,
+    parent_id: int | None = None,
+    position: int = 0,
 ) -> int:
-    """Insert one HD object as a ``character_objects`` row, then recurse into
-    its modifiers, adders, and (for framework powers) child slots. Returns
-    the inserted row's id so callers can chain it as a parent_id.
-
-    ``hero_powers`` is the full ``hero.powers`` list — required for
-    Multipower/VPP/ElementalControl slot resolution, because the loader
-    sets ``slot.parent = framework`` but does NOT back-populate
-    ``framework.objects``. We walk ``hero_powers`` filtering by
-    ``slot.parent is obj`` to find slots that belong to ``obj``."""
-    row = CharacterObject(
-        character_id=character_id,
-        parent_id=parent_id,
-        xmlid=str(obj.xmlid),
-        object_type=object_type or classify_object_type(obj),
-        name=(getattr(obj, "name", None) or None) or None,
-        alias=getattr(obj, "alias", None) or None,
-        base_cost=float(getattr(obj, "base_cost", 0.0) or 0.0),
-        levels=int(getattr(obj, "levels", 0) or 0),
-        active_cost=_safe_float(_safe_attr(obj, "active_cost")),
-        real_cost=_safe_float(_safe_attr(obj, "real_cost")),
-        position=position,
-        input_value=getattr(obj, "input", None) or None,
-        option_id=_safe_attr(obj, "selected_option") or None,
-        notes=(getattr(obj, "notes", "") or "").strip() or None,
-    )
-    db.add(row)
-    db.flush()
+    """Write one power's doc object through the build-doc writer, then its
+    framework slots beneath it. Returns the root row's id.
 
-    # Recurse: assigned_modifiers → modifier children
-    for i, mod in enumerate(getattr(obj, "assigned_modifiers", []) or []):
-        insert_object_subtree(
-            db, mod,
-            character_id=character_id, parent_id=row.id,
-            position=i, object_type="modifier",
-        )
-
-    # Recurse: assigned_adders → adder children
-    for i, add in enumerate(getattr(obj, "assigned_adders", []) or []):
-        insert_object_subtree(
-            db, add,
-            character_id=character_id, parent_id=row.id,
-            position=i, object_type="adder",
-        )
+    Modifiers, adders, compound sub-powers and an Endurance Reserve's REC are
+    nested IN the doc object, so the writer handles them. Multipower / VPP /
+    Elemental Control slots — and a LIST's members — are flat doc objects
+    whose ``parent`` names the framework, so they are attached here.
+    """
+    from kirby.builds.build_doc_store import persist_object
 
-    # Framework slot resolution (kirby-cost API only):
-    #   - CompoundPower nests its slots on .powers
-    #   - Multipower / VPP / ElementalControl (extend List) DO have slot
-    #     objects with `.parent = framework`, but the loader does NOT
-    #     back-populate `framework.objects` — so we must walk hero.powers
-    #     and filter by `slot.parent is obj`. (Verified 2026-05-12 by
-    #     instrumenting LoadedHero.)
-    if str(obj.xmlid).upper() in FRAMEWORK_XMLIDS:
-        nested = getattr(obj, "powers", None) or []
-        sibling_slots: list[Any] = []
-        if hero_powers is not None:
-            sibling_slots = [
-                p for p in hero_powers if getattr(p, "parent", None) is obj
-            ]
-        # Prefer parent-linked siblings when present (MP/VPP/EC case);
-        # otherwise fall back to nested .powers (CompoundPower case).
-        slots = sibling_slots if sibling_slots else nested
+    row = persist_object(db, character_id, d, object_type="power",
+                         parent_id=parent_id, position=position,
+                         costs=fdoc.costs)
+    if str(d["xmlid"]).upper() in FRAMEWORK_XMLIDS:
+        slots = [s for s in fdoc.flat if s.get("parent") == d["id"]]
         for i, slot in enumerate(slots):
-            insert_object_subtree(
-                db, slot,
-                character_id=character_id, parent_id=row.id,
-                position=i, object_type="power",
-                hero_powers=hero_powers,
-            )
-
+            insert_power_subtree(db, slot, fdoc=fdoc, character_id=character_id,
+                                 parent_id=row.id, position=i)
     return row.id
 
 
@@ -324,7 +299,7 @@ def write_library_entry(
     sfx_tags: list[str],
     mechanical_tags: list[str],
     embed_fn: Optional[callable] = None,
-    hero_powers: list[Any] | None = None,
+    fdoc: FileDoc,
 ) -> Optional[PowerLibrary]:
     """Insert one POWER's tree into character_objects, then a power_library row.
 
@@ -354,13 +329,8 @@ def write_library_entry(
     kind = FRAMEWORK_KIND_MAP.get(xmlid, "single")
 
     # Insert the character_objects subtree
-    root_object_id = insert_object_subtree(
-        db, power,
-        character_id=owner_character.id,
-        parent_id=None,
-        position=0,
-        object_type="power",
-        hero_powers=hero_powers,
+    root_object_id = insert_power_subtree(
+        db, fdoc.doc_of[id(power)], fdoc=fdoc, character_id=owner_character.id,
     )
 
     description_text = (getattr(power, "notes", "") or "").strip() or None
@@ -448,6 +418,7 @@ def import_file(
     # them apart on a Hero does not apply to a catalogue entry.
     hero_powers = list(getattr(hero, "powers", []) or [])
     hero_powers += list(getattr(hero, "equipment", []) or [])
+    fdoc = file_doc(hero)
     for power in hero_powers:
         stats.powers_seen += 1
         xmlid = str(_safe_attr(power, "xmlid", "")).upper()
@@ -483,7 +454,7 @@ def import_file(
                 sfx_tags=sfx_tags,
                 mechanical_tags=mechanical_tags,
                 embed_fn=embed_fn,
-                hero_powers=hero_powers,
+                fdoc=fdoc,
             )
             sp.commit()
         except Exception as e:

{kirby_api-0.2.2 → kirby_api-0.2.3}/kirby/characters/routes.py

@@ -36,7 +36,7 @@ from kirby.campaigns.services.legacy_translation import (
 )
 from kirby.characters.models import CharacterDef, CharacterNarrative
 from kirby.characters._shared import load_character_in_tenant
-from kirby.builds.json_exporter import export_character
+from kirby.builds.build_doc_store import build_doc_from_rows
 from kirby.tenants.routes import _ensure_user_row
 
 router = APIRouter(prefix="/characters", tags=["characters"])
@@ -223,10 +223,10 @@ def export_character_json(
     db: Session = Depends(get_db),
     download: bool = False,
 ):
-    """Export a character as JSON, in the canonical hdc_parser shape.
+    """Export a character as its canonical build doc.
 
-    The output is the same shape ``JSONImporter.import_file`` reads,
-    so this is the round-trip transport for save / share / backup.
+    The same document ``GET /{id}/build`` returns and ``PUT /{id}/build``
+    accepts, so this is the round-trip transport for save / share / backup.
     Set ``?download=1`` to get a Content-Disposition: attachment
     header for browser-friendly download.
 
@@ -241,7 +241,7 @@ def export_character_json(
         # not-found.
         raise HTTPException(status_code=404, detail="character not found")
 
-    payload = export_character(db, character_id)
+    payload = build_doc_from_rows(db, character_id)
     body = json.dumps(payload, indent=2).encode()
     headers: dict[str, str] = {}
     if download:
@@ -252,7 +252,7 @@ def export_character_json(
             for c in (char.name or str(character_id))
         ) or str(character_id)
         headers["Content-Disposition"] = (
-            f'attachment; filename="{safe}.hdc.json"'
+            f'attachment; filename="{safe}.build.json"'
         )
     return Response(
         content=body,

{kirby_api-0.2.2 → kirby_api-0.2.3/kirby_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kirby-api
-Version: 0.2.2
+Version: 0.2.3
 Summary: Kirby — HERO System VTT backend API (FastAPI mono)
 Author: PeterB
 License: PolyForm Noncommercial License 1.0.0
@@ -22,7 +22,7 @@ Requires-Dist: cryptography>=44
 Requires-Dist: python-jose[cryptography]>=3.3
 Requires-Dist: pyjwt[crypto]>=2.10
 Requires-Dist: redis>=5.2
-Requires-Dist: kirby-cost>=0.6.1
+Requires-Dist: kirby-cost>=0.6.2
 Requires-Dist: lxml>=5.3
 Requires-Dist: python-multipart>=0.0.20
 Requires-Dist: email-validator>=2.2

{kirby_api-0.2.2 → kirby_api-0.2.3}/kirby_api.egg-info/SOURCES.txt

@@ -106,6 +106,7 @@ kirby/_migrations/versions/20260918_0000_drop_combat_tables.py
 kirby/_migrations/versions/20260918_0001_harness_tables.py
 kirby/_migrations/versions/20260918_0002_narration_speaker_id.py
 kirby/_migrations/versions/20261005_0001_knowledge_indexes.py
+kirby/_migrations/versions/20261005_0002_build_doc_fields.py
 kirby/_migrations/versions/21980c836860_add_asset_id_refs.py
 kirby/_migrations/versions/ba28e71c955d_codex_init.py
 kirby/admin/__init__.py
@@ -123,7 +124,6 @@ kirby/builds/cli.py
 kirby/builds/codex_linker.py
 kirby/builds/combatant_loader.py
 kirby/builds/importer.py
-kirby/builds/json_exporter.py
 kirby/builds/json_importer.py
 kirby/builds/models.py
 kirby/builds/power_categories.py

{kirby_api-0.2.2 → kirby_api-0.2.3}/kirby_api.egg-info/requires.txt

@@ -13,7 +13,7 @@ cryptography>=44
 python-jose[cryptography]>=3.3
 pyjwt[crypto]>=2.10
 redis>=5.2
-kirby-cost>=0.6.1
+kirby-cost>=0.6.2
 lxml>=5.3
 python-multipart>=0.0.20
 email-validator>=2.2

{kirby_api-0.2.2 → kirby_api-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kirby-api"
-version = "0.2.2"
+version = "0.2.3"
 description = "Kirby — HERO System VTT backend API (FastAPI mono)"
 # Published to public PyPI. Every runtime dependency below resolves from
 # public PyPI too — kirby-cost, kirby-combat, kirby-dice and kirby-ai all
@@ -91,7 +91,7 @@ dependencies = [
     # columns stay NULL on every import, and a rebuilt character silently
     # counts purchases HD keeps out of its totals — Cobra came back DCV 12
     # where the canonical .hdc load says 10.
-    "kirby-cost>=0.6.1",
+    "kirby-cost>=0.6.2",
     "lxml>=5.3",
 
     # Utilities