<!--
=== BUILD LOG: APPADAY 146 SAGA FORGE ===
Each pass reads this log first and appends to it last.

PASS 1 (2026-09-30, Opus): KIT:CORE and Shell. COMPLETE.
  Shell: header (title, App 146, backlink, theme toggle, Settings gear), top bar (project title rename,
    validation badge, Save, Slots, Import, Export), tab bar with lock icon plus tooltip reason from canEnter,
    scrolling workspace area, footer backlink. Night and Parchment themes via CSS custom properties
    (system default, override in Settings or header toggle). Fonts: Cinzel (display), Alegreya Sans (UI).
    Component classes: panel, card, field, btn (primary, ghost, danger, icon), chip (error, broken, forward,
    warning, ok, muted, accent), dialog, drawer, tbl / tbl-wrap, form-grid, klist, ref-btn, radio-cards, stub.
  Public API (window.Kit):
    Kit.util: now, isObj, clone, esc, rand36, slug, debounce(flush, pending, cancel), canonical, parsePath,
      getPath, parentPath, download, readFile, detach, clear, el, fmtDate, fmtSize, sha256 (sync, UTF-8).
    Kit.icon(name), Kit.on / off / emit. Events: load, change, validated, settings, slots, theme, jump.
    Kit.store.get / set / del / usage / keys (try/catch, warns past about 4.5 MB). Kit.uiState.get / set (kit:ui).
    Kit.settings.get / set / hasKey / open (kit:settings holds key, session, tiers{haiku, sonnet, opus, fable}).
    Kit.getModel(tier): Settings tier override, then ../config.json, then the portal config.json, then fallback.
    Kit.claude({tier, system, messages, maxTokens, expectJson, silent}) -> {text, json, model, response}.
      Sends anthropic-dangerous-direct-browser-access and thinking {type:'disabled'} (retried as {type:'between_tools'} for models that require it); extracts the first JSON
      block; one repair retry; logs block types and stop_reason on empty replies; errors toast unless silent.
      Kit.claude.extractJson(text).
    Kit.bundle: create, blank, load, current, touch, hash, migrate, slug, save, flush, dirty, open(ns), close(ns),
      restoreDraft, exportFile({status, download}) -> {filename, text, hash}, importText, importFile,
      slots.list / save / load / delete (4 slots in kit:slots), suspend.save / load / clear (kit:suspend).
      Autosave to kit:draft with 800 ms debounce. Hash is SHA 256 of canonical sorted JSON excluding
      kit.contentHash. exportFile stamps forges['146'] {status, exportedAt, charterVersion} and contentHash
      on the current bundle, so hash(current) equals the exported file's hash.
    Kit.index(bundle) -> {byId, byPrefix, dupes}: walks charter, rules, art, world, story for objects with a
      valid prefixed id. Kit.index.invalidate().
    Kit.records.list(prefix) / get(id) / put(rec) / del(id). put stores rules records at rules['chr_'][id]
      (key includes the underscore). Other namespaces own their storage.
    Kit.ids.mint(prefix, name) -> prefix + slug + '_' + 4 char base36, unique. prefixOf, isValid, all, RE.
      No rename API.
    Kit.codex: PREFIXES table (ns, forge, module), ID_RE, normPrefix, prefixInfo, nsOf, ownerOf, isOpened(ns),
      register(def) / unregister(name) for runtime types, types(), type(name), typeFor(prefix), fields(typeName).
      Type def: {name, prefix, label, fields:[descriptor], dependsOn:[paths], module}. codex.types in the
      bundle override runtime types; codex.prefixes[prefix] may be a type name or {type}.
    Descriptor extras beyond the manifest: values (static enum list), rows / rowsFrom / columns / cell
      (table), itemLabel (list), placeholder, step, full. refPrefix may be a string or an array.
      Table values: {row: number} or, with columns, {row: {col: value}}.
    Kit.vocab(desc) -> [{value, label}] from values or enumFrom (arrays of strings or {key|id, label}).
    Kit.validate(bundle) -> {errors, broken, forward, warnings, byRecord}; items {recordId, fieldPath, message,
      level, id?, owedBy?}. Kit.validate.register / unregister / list, .record(typeName, record, {draft}),
      .summary(res), .last. Formula fields call Kit.expr.parse when it exists.
    Kit.form.render(container, typeName, record, onChange, {draft, readOnly}) -> {el, validate, refresh,
      focusPath}. Kit.form.preview(typeName, record) opens a drawer editor.
    Kit.review.open(drafts, typeName, onAccept) (default onAccept is Kit.records.put).
    Kit.ai.hasKey, button(label, handler, {kind, busyLabel}), charterSummary, draftRecords(typeName,
      {prompt, count, tier, onAccept}).
    Kit.ui.toast, dialog, confirm, prompt, drawer, busy.show / hide / active, pickRef, stub, closeTop, overlayCount.
    Kit.mount(id, {title, icon, render, canEnter, onLeave, focus}); canEnter returns true or a reason string.
      Kit.go, Kit.canEnter, Kit.active, Kit.workspaces, Kit.rerender, Kit.paintTabs, Kit.jump(recordId, fieldPath).
    Kit.refreshValidation, Kit.openValidation, Kit.openSlots, Kit.openExport, Kit.importPicked,
      Kit.renameProject, Kit.theme.get / set / toggle / apply / effective, Kit.dev.fieldDemo().
  window.WS: charter, codex, rules, arena, sim stubs. canEnter chain: Charter always; Codex needs a locked
    Charter; Rules also needs codex.version and codex.types; Arena needs a trp_ record; Simulator needs trp_
    and eps_. ENGINE_BATTLE is a placeholder object (version 0.0.0).
  Keyboard: Ctrl or Cmd + S saves, Esc closes the top dialog or drawer.
  Known deferrals: kit.opened starts empty; Pass 2 opens charter on lock, Pass 3 or 6 opens rules.
    Export writes only the bundle JSON (engine-battle.js and the manifest come in Pass 6).
    Kit.expr is not built yet (Pass 4a). Charter chp_ storage location is Pass 2's call.
    Pass 3 should tighten WS.rules.canEnter to "Codex validates".
=== PASS 2: CHARTER WORKSPACE (Sonnet), COMPLETE ===
  Built: WS:CHARTER css and js fences. Left section list (drawer toggle under 820px) plus Kit.form editor for
    Premise, Magic, Villain, Protagonist, Party, Chapters, Endings, Themes, Canon, Glossary, Specs, Quotas,
    Ruleset. Ruleset cards Saga, Classic, Custom (exact preset contents, Modified chip, confirm on switch);
    Custom starts blank with a Load default stats button (hp, mp, str, mag, def, mdef, spd, luck).
    Interviewer drawer: Ask (Sonnet), Give Me Options (Sonnet, three drafts through Kit.review), Check
    Contradictions (Opus, {fieldPaths, conflict, suggestion} as linked cards); chat kept per section in
    saga146:charter:chat. No key shows the hint and makes no call.
    Lock needs zero Charter errors, stamps version 1 and opens charter; Amend unlocks; relock bumps the version,
    stores {from,to,changedPaths,at,note} and shows a diff dialog of stale downstream records. Unchanged
    relock keeps the version. Codex and Rules stay closed until the Charter is locked.
  Public API added: WS.charter {lock({note,quiet}), amend({skipConfirm}), applyPreset, PRESETS, defaultStats,
    resolution(b), sections, sectionItems, lockCheck, impact(b, changedPaths, version), focus, goToPath, render}.
    Kit.jump.register(handler), Kit.jump.can(id), Kit.ai.describeFields(fields, bundle), Kit.review.open 4th arg
    {section, note}, type descriptor flag section:true (no prefix, no auto Name and Notes, no id minting).
  Core patches: P1 hasName honors section types; P2 Kit.form.render skips Name and Notes for section types;
    P3 Kit.review.open accepts ropts; P4 Kit.ai.describeFields; P5 Kit.jump handlers and pseudo record ids for
    validation panel jumps. Also .ai-hint button now 44px tall.
  Storage: charter.sections.<name> (chapters array holds chp_ records), specs, quotas, canon, glossary, ruleset,
    lockFingerprint, amendments. dependsOn paths accepted as 'charter.sections.party' or 'charter.party'
    (prefix overlap on normalized segments). Default resolution 256x224 is stamped at lock.
  Validation: an untouched section adds no errors (empty project stays valid); lock runs a strict check.
    chp_ references are FORWARD before lock and BROKEN after.
  Acceptance: presets, blank Custom, interviewer calls with key and hint without, lock refusal, amendment
    version bump and diff, reload persistence, export and import hash round trip, 375px no horizontal scroll,
    dark and light themes, syntax check, ASCII scan, forbidden API scan, backlinks, fence order.
  Known deferrals: element, relation and taxonomy editors are basic Kit.form fields until Pass 4a; Codex
    generation is Pass 3; Pass 3 should tighten WS.rules.canEnter to "Codex validates".
=== END PASS 2 ===
=== PASS 3: CODEX WORKSPACE (Opus), COMPLETE ===
  Built: WS:CODEX css and js fences. Generate / Regenerate builds codex.types (plain JSON descriptors, persisted in
    the bundle), codex.prefixes ({prefix: {type, ns, forge, module, active}} for every prefix), codex.modules
    ([progression, 'living']), codex.saveSchema, codex.version, generatedFromCharter, rulesetHash, generatedAt.
    Generation opens the rules namespace (kit.opened becomes charter, rules). Records are never touched; a
    regeneration report lists types added and removed, fields added, removed, and retyped per type, and orphaned
    records whose prefix lost its type (kept, flagged inactive). Report kept in saga146:codex:report.
  Types (name / prefix): Character chr_, Ability abl_, Item itm_, Equipment eqp_, Status sta_, Formula frm_,
    Family fam_, Enemy enm_, Gambit gmb_, Troop trp_, Shop shp_, Weather wth_, Limit lim_, ExpectedPartyState eps_,
    plus exactly one module type: Materia mat_ | Job job_ | Class cls_, plus Living World Rumor rmr_, SideQuest sdq_,
    BossStrategy bst_ (bst_ rules and counters reuse the gmb_ shape). Chapter chp_ stays the Charter runtime type.
    Each def carries group (core, module, living), dependsOn paths, and fields; name and notes are added by Kit.form.
  Field notes for later passes: table values are {rowKey: value}; stat tables use rowsFrom charter.ruleset.stats,
    element tables rowsFrom charter.ruleset.elements. eqp_ adds tier and price; slotLayout.links is [[i,j]] (a list
    of int pairs, Pass 4b replaces the generic editor with the visual builder). enm_ adds level; affinityOverrides
    cells are weak|normal|resist|immune|absorb. fam_ adds absorbsOwnType; defaultAffinity is derived and read only.
    eps_ holds materiaSet | jobSet | classSet by module; targetWinRate is a percent 0 to 100. Gambit condition is
    {kind, param} with param text (number, or a sta_ ID for status kinds); target {selector}; action {abl};
    counters {trigger, action {abl}}. Drops, steal, shop stock and quest rewards use key item (itm_, eqp_, mat_ when
    materia). Vocabularies exported on WS.codex: FORMULA_IDS, ABL_KINDS, MAT_KINDS, MAT_GRANTS, AFFINITIES, COND_KINDS,
    SELECTORS, TRIGGERS, SUPPORT_EFFECTS, MODULE_TYPE.
  Public API added: WS.codex {generate({quiet}), check(b) -> {ok, state:none|stale|ready|invalid, errors, warnings},
    buildTypes(ruleset), buildSaveSchema(ruleset), diffTypes(old, new), defaultAffinity(b, typeValue, absorbOwn),
    enemyAffinity(b, enm), forwardSlots(b), focus, render, canEnter}. Kit.codex.derive.familyAffinity.
  Validators registered: codex (stale or missing Codex as warnings, structural descriptor problems as errors, on
    record 'codex' with a jump handler), codex.affinity (override contradicts family default, warning),
    codex.slotLinks (link past slot count or self link, warning), codex.materiaGrants (ability kind not allowed for
    the materia kind, support grants anything, warning), codex.gambitParams (numeric params, status IDs; missing
    sta_ is broken), codex.formulaSource (neither or both of template and expr, warning), codex.orphans (warning).
  Core patches: P6 table cells of type enum render a select from desc.cellValues / cellEnumFrom and validate against
    them; P7 per field desc.readOnly and desc.derived (Kit.codex.derive[name](record, bundle) fills the value, shown
    read only, skipped by validation and by Kit.ai.describeFields); describeFields reports table cell type and values.
  WS.rules.canEnter now requires WS.codex.check(b).ok (stale after an amendment keeps Rules locked).
  Codex browser: status bar with Generate or Regenerate and Open Rules, blocking issues and advisories, last
    regeneration report, record types grouped Core, Module, Living World, Charter with a filter and collapsible
    field tables (prefix, forge, namespace open state, record count, dependsOn), forward slots by owing forge with
    held forward IDs as jump links, prefix table, save schema.
  Acceptance: Saga yields Materia and not Job or Class; Classic yields Class; Rules locked until the Codex validates
    and again when stale; amendment regeneration reports eps_ materiaSet added and classSet removed and keeps an
    orphaned cls_ record; affinity, slot link and materia grant warnings fire; portrait shows FORWARD owed by 147;
    troop to a missing enemy is BROKEN; export and import hash round trip; reload persistence; 375px with no
    horizontal scroll in night and parchment; syntax check, ASCII scan, forbidden API scan, backlinks, fence order.
  Known deferrals: Pass 4a builds the systems editors (and the absorb toggle UI beyond the fam_ field), Kit.expr, and
    formula previews; Pass 4b replaces generic editors for slot layout, gambits and troops. Pass 6 export still must
    add rules to kit.opened for bundles that never generated a Codex.
=== END PASS 3 ===
=== PASS 4a: RULES SYSTEMS (Sonnet), COMPLETE ===
  Built: WS:RULES css and js fences, Kit.expr in KIT:CORE, a duplicate evaluator in ENGINE:BATTLE (version 0.1.0).
  Rules workspace: left rail (a scroller under 820px) with Systems (Stats, Elements, Relations, Taxonomy, Affinity,
    Formulas, Statuses, Weather states, Progression for the active module type) and Content (every other rules type the
    Codex declares, living types last). Every list has search, New, Duplicate, Delete through a confirm dialog, Draft with
    Claude and Draft a Set (2 to 8 records through Kit.ai.draftRecords and Kit.review). Editors use Kit.form with a Back
    button, stale chip, and Mark reviewed (sets charterVersion to the current Charter version). Content types use the generic
    list and editor; Pass 4b specializes them.
  Systems editors write to charter.ruleset and are read only while the Charter is locked, with an Amend Charter banner.
    Because Rules opens only while the Charter is locked, the same editors open fully editable in a drawer from the Charter
    Ruleset section (patch P8, button Edit stats, elements, relations, taxonomy). Keys are permanent once a record or formula
    uses them (usage scanner); deleting an element removes its relations and taxonomy value, and lists other users.
    Default affinity is computed by WS.codex.defaultAffinity from the relation table; the Affinity view previews the absorb
    option per taxonomy value and toggles absorbsOwnType on real families.
  Formula library (WS.rules.FORMULA_LIB, mirrored in Pass 5, parameter names and defaults are the contract):
    phys.ff6 {levelDiv 256, defBase 256, mult 1, floor 1}; mag.ff6 {powerMult 4, levelDiv 32, defBase 256, floor 1};
    phys.sub {atkMult 1, defMult 0.5, floor 1}; mag.flat {magMult 1, mdefMult 0.5, floor 1}; heal.std {magMult 2, mult 1, floor 1};
    var.std {spread 0.1, roll 0.5}; exp.curve {base 40, exponent 2.1}; ap.curve {base 100, growth 2}; atb.fill {spdOffset 20, rate 8}.
    Each template has an expression mirror (FORMULA_LIB[id].expr) that Pass 5 must reproduce exactly in ENGINE:BATTLE templates.
  Kit.expr: parse(src, {stats, params}) to AST, evaluate(astOrSrc, scope, opts), variables(ast), FUNCTIONS, MAX_LEN. Numbers,
    + - * / ^, parentheses, min max floor ceil round clamp pow sqrt, and only a.<stat>, a.level, t.<stat>, t.level, power,
    p.<param>. Unary minus binds looser than ^ (so -2 ^ 2 is -4); ^ is right associative. Anything else is a parse error with
    a position. Division by zero, sqrt of a negative, clamp with low above high, and non finite results throw at evaluation.
    ENGINE_BATTLE.evalExpr has the identical core text and returns the same results (checked on 11 cases including errors).
  Preview: WS.rules.preview(host, getSource) draws a Chart.js line for levels 1 to a cap (default 99) with editable sample
    level, power, cap, and attacker and target stats; it degrades to a results table when Chart.js is unavailable.
  Other: Weather Suggest from meteorology (Sonnet, ranges 0 to 5, review table before Apply); Materia Fill AP thresholds from
    the AP formula; validator rules.formulas (template exists, expression parses with declared stats and params, formulaSet roles
    resolve); Kit.mount focus support so validation jumps land on the record and field.
  Public API added: WS.rules {canEnter, render, focus, open(view, id), openSystems(tab), systems {stats, elements, relations,
    taxonomy, affinity}, preview, formulaSource(id), evalFormula(id, scope), roleId(role), evalRole(role, scope), usage(kind, key),
    staleIds(), FORMULA_LIB, FORMULA_ORDER, state}. evalFormula scope is {a:{level,<stat>}, t:{level,<stat>}, power}; p comes
    from the template or record parameters.
  Acceptance: every systems record (stats, elements, relations, taxonomy, statuses, weather, formulas, materia) created from
    scratch and drafted with a mocked Claude reply; illegal tokens (os.exit, semicolon, brackets, backticks, unknown stat, unknown
    parameter, dangling operator) rejected with a message in the preview, the form, and the validator; preview charts update on
    template swap, sample edits, cap edits, and expression edits; locked read only view and unlocked drawer editing; stale
    review flow; 375px with no horizontal scroll and 44px targets in Night and Parchment; syntax check, ASCII scan, forbidden API
    scan, backlink count, fence order.
  Known deferrals: Pass 4b replaces the generic editors for equipment slot layout, gambits, troops, and enemies. Pass 5 builds
    the engine templates against FORMULA_LIB and the turn loop. The Charter validation for the ruleset section is unchanged.
=== END PASS 4a ===
=== PASS 4b: RULES CONTENT (Sonnet), COMPLETE ===
  Built: content editors inside the WS:RULES css and js fences only. ENGINE:BATTLE is untouched.
  Editors: abilities and items (plain language summary, Create an effect ability from an item); equipment (SVG slot layout
    builder: tap a slot then a second slot to toggle a link, Fewer/More slots 0 to 8, Clear links, links past the count pruned);
    characters (stats by level table, inline Limit tree builder with Add existing, New limit here, reorder, remove, level order
    warning); families and enemies (tier generator clones a family into tiers 2 to N with scaled stats clamped to stat max, scaled
    level, gil, exp, ap, and a hue shift stored on the cloned family; enemy tools show effective affinity, a scale stats tool,
    gambit link or create, and troops that use the enemy); gambits and boss strategies (rule and counter rows, condition, param,
    target and ability pickers, plain language line, Never reached chip after an Always rule, up/down and drag reorder);
    troops (Back row and Front row lanes, up to 8 members, move row, reorder, change, remove, gil/exp/ap totals, Broken chip);
    shops (effective price sheet); Expected Party State table; Economy panel (view 'econ' in the Content rail).
  Fill from curves: total EXP for the final level (default 50, editable) from the ruleset exp formula, spread across chapters by
    cumulative target minutes; each chapter gets the highest level whose requirement fits. Confirms before overwriting levels above 1.
  Economy: battles per minute (default 1) times average troop gil and AP per chapter (troops tagged to the chapter), cumulative
    gil and AP against the cheapest stocked gear kit at the chapter target tier. Flags: notroops, noeps, notier, nogear,
    unaffordable (error), unstocked, apshort. Chart.js line chart degrades to a table when unavailable.
  Drafting: every content type supports Draft with Claude and Draft a Set (count and direction). Characters are seeded from
    Charter party entries (Draft per member, Create blank). IDs are never minted by Claude.
  Public API: WS.rules.content {slotLayoutOf, describeRule, describeCounter, generateTiers, planCurves, applyCurves, economy,
    troopYield, shiftHex, ablSummary, chaptersOf, epsOfChapter, partyMembers, seedPrompt, shopEffective}. TYPE_CFG entries gain
    hide (paths shown by a builder instead of the form) and listExtras hooks. Troop members are {enm, row}; slotLayout is
    {count, links [[i,j]]}; Pass 5 reads these shapes.
  Acceptance: all 18 rules and system types created from scratch and drafted (Draft a Set, 3 drafts, review, accept) against a
    mocked Claude reply; troop referencing a deleted enemy reports BROKEN on members[i].enm; a character with a portrait id reports
    FORWARD owed by forge 147; tier generation makes 2 extra families and 4 enemies; slot links toggle; Fill from curves gave
    levels 23, 36, 50; economy flags an unaffordable tier 2 kit; 375px with no horizontal scroll and 44px targets in Night and
    Parchment; syntax check, ASCII scan, forbidden API scan, backlink count 3, fence order. Fixed: hidden chips were shown because
    of chip display rules (added a scoped [hidden] rule).
  Known deferrals: Pass 5 builds the battle loop and gambit evaluation against these shapes. Arena and Simulator are still
    placeholders. Pass 6 owns the README and final polish.
=== END PASS 4b ===
=== PASS 5: ENGINE:BATTLE, ARENA, TEST HARNESS (Opus), COMPLETE ===
  Built: ENGINE:BATTLE (version 1.0.0, still self contained, no host globals), WS:ARENA css and js fences. Harness and fixtures
    live in the execution workspace only (test/harness.js, test/fixture-saga.json, test/fixture-classic.json), never shipped.
  Engine API: ENGINE_BATTLE {version, templates, evalExpr, gaugeMax, schedulers, progressions, init(data, seed, opts) -> state,
    advance(state, input) -> {state, events, awaiting}, run(data, seed, policy, opts) -> {events, result},
    replay(data, seed, opts, inputs) -> {state, events, awaiting}, forecast(state, n), suggest(state, policy) -> input}.
    data = {ruleset, records (bundle.rules, keyed 'chr_' etc.), party, troopId, weatherId}. Party member = {chr, level,
    equipment [eqp ids], materia [{eqp, slot, mat, ap}], job, jobLevel, cls, abilities [abl ids], row, hp, mp, limitLevel,
    limitUses, kills, limitGauge}. opts = {waitMode, scheduler, tickCap (20000), attackPower, damageCap, limitRate, events,
    noDamageLog}. advance input: null (run to the next decision), {type:'step', ticks}, {type:'command', actor, abl,
    target | targets}, {type:'flee', actor}. advance deep clones; run and replay mutate only their own state.
    result = {outcome win|lose|flee|timeout, ticks, turns, preemptive, rngCalls, rewards {gil, exp, ap}, partyEnd, resourcesUsed
    {hpLost, mpSpent, hpPct, mpPct, items}, damageLog [{t, actor, target, side, value, element, crit, abl}], warnings}.
    Events: tick (one per advance call, value = ticks advanced), ready, command, action, damage, heal, miss, status,
    limitReady, ko, revive, end; each {type, t, actor, target, value, element, crit} plus abl, name, targets where useful.
  Internals: mulberry32 in state.rng {a, calls}. Templates mirror WS.rules.FORMULA_LIB exactly (harness checks). Formulas
    compile to ASTs at init (template, frm_ template with param overrides, or frm_ expression). Schedulers: atb (gauge 0 to
    65536, fill from the atb formula or (spd+20)*8, wait mode stops time while a party member waits, chargeTicks wind up),
    rounds (speed order, rng tiebreak, one tick per turn), conditional (CTB nextAt queue, charge adds to the next delay).
    Progression: materia (grants by AP level, magic/summon/command commands, statMods, support on a linked pair:
    all, element, addedEffect, counter, hpAbsorb, mpAbsorb), jobs, classes. Resolver: physical hit and crit from luck, formula,
    var.std roll from the rng, back row halves physical, affinity (weak 2, resist 0.5, immune 0, absorb heals) then weather,
    heal inversion on taxonomy.inverts, statuses with chance, freeze and empty gauges, tick effects, onHit cures.
    Limit gauge fills by damage over max HP; full swaps Attack for the highest unlocked lim_; levels unlock by uses or kills.
    Foes use bst_ (boss strategy) first, then their gmb_ rules, then a basic attack. Counters fire once per hit and never
    answer a counter. Default party policy: heal the lowest ally under 35 percent, else the strongest affordable attack
    (Limit weighted up). The built in attack is '_attack' with ruleset.battle.attackPower (default 12). Abilities may carry an
    optional revive flag (a seam, not in the Codex yet).
  Arena: setup panel (troop, weather, party pick up to 4, Custom level plus gear tier plus materia chips or job/class per
    character, or a chapter Expected Party State, rows, seed with random, Wait or Active, speed 1x 2x 4x). Canvas at
    charter.specs.resolution, integer scale, smoothing off, 3x5 pixel font. Foes are symmetric procedural silhouettes (arcTo
    and rect only) seeded by the family id hash, tinted by the family palette, tier hue shifts the accent; party are tinted
    rectangles with a weapon class glyph. Canvas HUD: foe names and HP bars, party HP, MP, time gauge, limit gauge, popups,
    weather overlay, round counter, result banner. DOM command menu of 44px buttons (command, ability list, targets, All
    foes/allies for all scope), Auto toggle, New battle, Replay same seed, Watch replay, Copy battle code (clipboard or a
    dialog), Paste battle code, Battle log drawer, result card. Battle codes are base64 JSON {v, troopId, party, seed, inputs
    [{t, input}], weatherId, opts, end}; playback applies inputs at their exact tick and reports whether the end matched.
  Public API added: WS.arena {canEnter, render, buildParty(b, cfg), expectedParty(b, chapterId, chars), dataFor(b, troopId,
    party, weatherId), start, preload(troopId, {source, seed}), playCode(code), encodeCode, decodeCode}. Setup kept in
    saga146:arena:setup.
  Acceptance: harness 14 of 14 (fence has no document, window, or Kit; API present; templates equal FORMULA_LIB; same seed
    identical event streams across 3 runs for atb and rounds; atb, rounds, and conditional complete; level 20 party wins 20 of
    20, level 1 party loses 20 of 20; heal inversion damages the unholy ghost and heals the air wolf; linked All plus Fire hits
    all 3 foes and the unlinked pair hits 1; Kit.expr and evalExpr agree on 50 random expressions and 6 illegal ones; advance
    does not mutate; hand driven battles replay identically from a base64 battle code in wait and active modes; Limit swap;
    counters and a custom policy; jobs and freeze statuses). Browser (Chromium) at 1280 and 375: authored troop fought by
    hand and won, Watch replay matched exactly, auto battle with a level 1 party lost, battle log drawer, no horizontal scroll,
    no tap target under 44px, Night and Parchment, zero console errors. Syntax check, ASCII scan, forbidden API scan,
    backlink count 3, fence order.
  Known deferrals: Pass 6 builds the Simulator Worker from the ENGINE:BATTLE fence text (use run(data, seed, null,
    {events:false}) and WS.arena.expectedParty / dataFor), the export of engine-battle.js and the manifest, and can call
    WS.arena.preload(troopId) from flagged rows. Items in battle (Item command) are not modeled yet; inventory has no battle
    state. Arena targets are chosen from buttons, not by tapping sprites.
=== END PASS 5 ===
=== PASS 6: SIMULATOR, EXPORT, POLISH, README (Sonnet), COMPLETE ===
  Built: WS:SIM css and js fences, the Export dialog in KIT:CORE, the welcome card, shortcuts check, README.md. ENGINE:BATTLE is
    byte for byte unchanged from Pass 5 (version 1.0.0). The harness and fixtures were not in the repo, so they were rebuilt in
    the execution workspace (test/harness.js, test/fixture-saga.json, test/fixture-classic.json) and are never shipped.
  Simulator: Kit.engine.source() finds the engine fence text in the page's own script element by marker search. The markers are
    assembled from two string pieces so no literal marker appears outside the two fence lines. WS.sim builds a Blob from that text
    plus a small message handler (workerMain, stringified), then a Worker. Worker creation failure shows an error and never runs
    on the main thread. Controls: chapter or All, battles per troop (1 to 5000, default 200), base seed, weather, party from the
    Expected Party State or a custom party (characters, level, gear tier, materia), Run and Cancel, a progress bar. Battle k of
    troop t uses seed base + t * 1000003 + k, so results are reproducible. Each battle is ENGINE_BATTLE.run(data, seed, null,
    {events:false}); the Worker aggregates per troop and posts one message when a troop finishes. Troops run against their own
    chapter's eps_; troops without a chapter, without an eps_ (in Expected Party State mode), without enemies, or with a missing
    enemy are skipped with a reason. Cancel terminates the Worker and keeps finished troops. Four Chart.js charts (win rate with a
    target line, turn count histogram, resource cost, damage by element) degrade to tables when Chart.js is missing. A troop picker
    scopes the turn and damage charts. The results table flags troops more than 10 points from target (too hard or too easy), and
    each flagged row links to the troop, its enemies (Kit.jump), and the Arena preloaded with the same party and a recorded seed
    (a lost battle when too hard, a won one when too easy). Results live in memory and are marked stale when the project changes.
    The Simulator reuses the Arena party chip classes (ar-pick, ar-chars, ar-seg, ar-seedrow).
  Export: Kit.openExport lists three files with per file Download buttons and a Download all three action. Final is disabled, with
    the broken list shown, while broken is nonzero. Kit.buildExport(status) opens the rules namespace if needed, revalidates,
    stamps forge 146 through Kit.bundle.exportFile, and returns {hash, files}. Files: slug-bundle.json, engine-battle.js (header
    comment with engine version and bundle hash, then the exact fence text), slug-manifest.json {forge, bundleHash, charterVersion,
    created, referenced, forward [{id, owedBy}], broken [{id, recordId, fieldPath}], counts by prefix}. Kit.exportManifest,
    Kit.engineFile, Kit.engine {source, version, OPEN, CLOSE}.
  Polish: first run welcome card (three stages, dismissed by button or first edit, reopened from the footer Welcome guide link,
    flag welcomeSeen in kit:ui), primary actions on the Affinity and Economy empty states (every other list already had one),
    Ctrl or Cmd S and Esc verified, button labels stay visible in the Simulator and Export at 375px.
  Public API added: WS.sim {canEnter, render, run, cancel, running, last, workerSource}, Kit.engine, Kit.buildExport,
    Kit.exportManifest, Kit.engineFile, Kit.welcome {show, hide}. Storage: saga146:sim:setup.
  Acceptance (Chromium, plus node harness): harness 38 of 38 and 42 of 42 when pointed at the exported engine file (fence self
    contained; same seed identical across 3 runs on atb and rounds; both schedulers finish; heal inversion; linked support
    materia; Kit.expr equals evalExpr on 50 random expressions and both reject 6 illegal ones; shared data is not mutated by run).
    Simulator: 4 troops by 60 battles in a Worker, worker results identical to main thread runs for the same seeds, four charts,
    flags too hard and too easy, Troop, Enemy, and Arena links (the Arena replayed a recorded loss seed and lost), Cancel keeps a
    partial result, Worker failure shows an error with zero main thread runs, no Chart.js gives four tables, Classic preset run,
    custom party, chapter filter, skipped troop reasons. Export: three files, manifest hash equals the bundle hash, import verifies
    the hash, forward reference owed by 147 listed, Final blocked by a broken reference while Draft still exports, exported engine
    passes node --check and the harness. 375px and 1280px audit of Charter, Codex, Rules (five views), Arena, and Simulator in Night
    and Parchment: no horizontal scroll, no tap target under 44px, zero console errors. Syntax check, ASCII scan, forbidden API
    scan, backlink count 3, fence order.
  Known deferrals: the test project was authored through the app's own record APIs (Kit.records.put, WS.charter.lock,
    WS.codex.generate), not by typing every field into the forms. Items in battle are still not modeled. Arena targets are chosen
    from buttons. Simulator results are not persisted across reloads. Troops are reported only when all of their battles finish.
=== END PASS 6 ===
PASS 6 PATCH: Charter section renamed from Party to Starting Party (label, member field, target note). Field key 'party'
and the charter.party namespace are unchanged, so bundles stay compatible. Recruiting companions mid journey (a joins at
chapter reference on characters, party size changes per chapter) is DEFERRED to Day 148 World or Day 149 Story.
=== END BUILD LOG ===
-->
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
<link rel="apple-touch-icon" href="https://augustineiacopelli.github.io/appaday/icons/146.png">
<meta name="apple-mobile-web-app-title" content="Saga Forge">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<link rel="manifest" href="https://augustineiacopelli.github.io/appaday/manifests/146.webmanifest">
<script src="https://augustineiacopelli.github.io/appaday/save.js" defer></script>
<script src="https://augustineiacopelli.github.io/appaday/keys.js" data-app="146" data-legacy-key="kit:settings:key" data-accent="#A63D9E" defer></script>
<title>Saga Forge | AppADay 146</title>
<meta name="description" content="Saga Forge: author the Charter, Codex, and Rules of a classic JRPG, then fight and simulate its battles. AppADay 146.">
<meta name="theme-color" content="#10121a">
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Alegreya+Sans:ital,wght@0,400;0,500;0,700;0,800;1,400&family=Cinzel:wght@500;700&display=swap" rel="stylesheet">
<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js" defer></script>
<style>
/* === KIT:CORE CSS BEGIN === */
:root {
  --bg: #10121a; --bg2: #161a27; --panel: #1b2030; --panel2: #232a3d; --line: #323a52; --line2: #414a66;
  --ink: #ece4cf; --ink2: #c4bba3; --muted: #9b937e;
  --accent: #e3b453; --accent-ink: #1b1405; --accent-soft: rgba(227,180,83,.14);
  --accent2: #6fc7b6; --danger: #f07a6e; --warn: #eaa84a; --fwd: #b1a1ff; --broken: #ff8aa0; --ok: #86cf88;
  --bg-grad: radial-gradient(120% 80% at 50% -10%, #242b4f 0%, #141726 45%, #10121a 100%);
  --shadow: 0 18px 40px rgba(0,0,0,.5); --shadow-sm: 0 4px 14px rgba(0,0,0,.35);
  --scrim: rgba(6,7,12,.62);
  --radius: 14px; --radius-sm: 9px;
  --font-display: 'Cinzel', Georgia, 'Times New Roman', serif;
  --font-ui: 'Alegreya Sans', 'Segoe UI', system-ui, -apple-system, sans-serif;
  --font-mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
  color-scheme: dark;
}
@media (prefers-color-scheme: light) {
  :root:not([data-theme="night"]) {
    --bg: #efe4c8; --bg2: #e7d8b4; --panel: #fbf5e3; --panel2: #f4e9cc; --line: #d3bf93; --line2: #c2ab7a;
    --ink: #2a2315; --ink2: #4f4430; --muted: #6a5d42;
    --accent: #8a5a08; --accent-ink: #fff8e6; --accent-soft: rgba(138,90,8,.12);
    --accent2: #1d7465; --danger: #b1342a; --warn: #8f5500; --fwd: #5840bf; --broken: #ad1f48; --ok: #2d7a31;
    --bg-grad: radial-gradient(120% 80% at 50% -10%, #fbf3dc 0%, #efe4c8 55%, #e4d4ad 100%);
    --shadow: 0 18px 40px rgba(70,50,10,.22); --shadow-sm: 0 4px 14px rgba(70,50,10,.14);
    --scrim: rgba(40,30,10,.38);
    color-scheme: light;
  }
}
:root[data-theme="parchment"] {
  --bg: #efe4c8; --bg2: #e7d8b4; --panel: #fbf5e3; --panel2: #f4e9cc; --line: #d3bf93; --line2: #c2ab7a;
  --ink: #2a2315; --ink2: #4f4430; --muted: #6a5d42;
  --accent: #8a5a08; --accent-ink: #fff8e6; --accent-soft: rgba(138,90,8,.12);
  --accent2: #1d7465; --danger: #b1342a; --warn: #8f5500; --fwd: #5840bf; --broken: #ad1f48; --ok: #2d7a31;
  --bg-grad: radial-gradient(120% 80% at 50% -10%, #fbf3dc 0%, #efe4c8 55%, #e4d4ad 100%);
  --shadow: 0 18px 40px rgba(70,50,10,.22); --shadow-sm: 0 4px 14px rgba(70,50,10,.14);
  --scrim: rgba(40,30,10,.38);
  color-scheme: light;
}
*, *::before, *::after { box-sizing: border-box; }
html { -webkit-text-size-adjust: 100%; }
body {
  margin: 0; min-height: 100dvh; background: var(--bg); background-image: var(--bg-grad); background-attachment: fixed;
  color: var(--ink); font-family: var(--font-ui); font-size: 17px; line-height: 1.45; overflow-x: hidden;
}
a { color: var(--accent); }
a:focus-visible, button:focus-visible, input:focus-visible, select:focus-visible, textarea:focus-visible, [tabindex]:focus-visible {
  outline: 2px solid var(--accent); outline-offset: 2px;
}
code, .mono { font-family: var(--font-mono); font-size: .82em; }
.muted { color: var(--muted); }
.sr-only { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }
svg.ico { width: 20px; height: 20px; flex: none; fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; }

/* Shell */
.app { height: 100dvh; display: flex; flex-direction: column; min-width: 0; }
.app-head {
  display: flex; align-items: center; gap: 10px; padding: 6px 12px 6px 16px;
  border-bottom: 1px solid var(--line); background: color-mix(in srgb, var(--bg) 70%, transparent);
}
.brand { display: flex; align-items: baseline; gap: 10px; min-width: 0; flex: 1; }
.brand-title { font-family: var(--font-display); font-weight: 700; font-size: 1.3rem; letter-spacing: .08em; margin: 0; color: var(--accent); white-space: nowrap; }
.brand-num { font-size: .78rem; font-weight: 800; letter-spacing: .14em; text-transform: uppercase; color: var(--ink2); white-space: nowrap; }
.backlink { display: inline-flex; align-items: center; min-height: 44px; padding: 0 8px; font-weight: 700; font-size: .9rem; text-decoration: none; white-space: nowrap; }
.backlink:hover { text-decoration: underline; }
.topbar {
  display: flex; flex-wrap: wrap; align-items: center; gap: 8px; padding: 8px 12px;
  background: color-mix(in srgb, var(--bg2) 80%, transparent); border-bottom: 1px solid var(--line);
}
.btn.proj-title {
  flex: 1 1 150px; min-width: 0; justify-content: flex-start; font-family: var(--font-display); font-weight: 700; font-size: 1rem; letter-spacing: .03em;
}
.proj-title span.t { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.top-actions { display: flex; gap: 6px; flex-wrap: wrap; }
.vbadge { gap: 5px; padding: 0 10px; }
.vbadge .chip { pointer-events: none; }
.tabs {
  display: flex; gap: 2px; overflow-x: auto; padding: 0 8px; border-bottom: 1px solid var(--line);
  scrollbar-width: none; background: color-mix(in srgb, var(--bg) 60%, transparent);
}
.tabs::-webkit-scrollbar { display: none; }
.tab {
  display: inline-flex; align-items: center; gap: 6px; min-height: 46px; padding: 0 14px; border: 0; background: none;
  color: var(--ink2); font: inherit; font-weight: 700; letter-spacing: .03em; cursor: pointer; white-space: nowrap;
  border-bottom: 3px solid transparent; flex: none;
}
.tab:hover { color: var(--ink); }
.tab[aria-selected="true"] { color: var(--accent); border-bottom-color: var(--accent); }
.tab.locked { color: var(--muted); }
.tab.locked svg.ico { width: 16px; height: 16px; }
.ws { flex: 1; min-height: 0; overflow-y: auto; overflow-x: hidden; overscroll-behavior: contain; }
.ws-inner { padding: 16px; max-width: 1200px; margin: 0 auto; }
.app-foot {
  display: flex; justify-content: center; align-items: center; gap: 8px; flex-wrap: wrap; padding: 0 12px;
  border-top: 1px solid var(--line); font-size: .85rem; color: var(--muted);
}

/* Components */
.panel { background: var(--panel); border: 1px solid var(--line); border-radius: var(--radius); padding: 16px; box-shadow: var(--shadow-sm); }
.panel + .panel { margin-top: 14px; }
.panel-title { font-family: var(--font-display); font-weight: 700; font-size: 1.15rem; letter-spacing: .04em; margin: 0 0 6px; color: var(--ink); }
.card { background: var(--panel2); border: 1px solid var(--line); border-radius: var(--radius-sm); padding: 12px; min-width: 0; }
.grid-cards { display: grid; gap: 12px; grid-template-columns: repeat(auto-fill, minmax(min(100%, 240px), 1fr)); }
.kv { display: grid; grid-template-columns: max-content 1fr; gap: 4px 12px; font-size: .92rem; }
.kv dt { color: var(--muted); }
.kv dd { margin: 0; min-width: 0; overflow-wrap: anywhere; }
.btn {
  display: inline-flex; align-items: center; justify-content: center; gap: 6px; min-height: 44px; min-width: 44px; padding: 0 14px;
  border-radius: 10px; border: 1px solid var(--line2); background: var(--panel2); color: var(--ink);
  font: inherit; font-weight: 700; font-size: .95rem; cursor: pointer; text-decoration: none; white-space: nowrap;
  transition: background .15s, border-color .15s, transform .05s;
}
.btn:hover { border-color: var(--accent); }
.btn:active { transform: translateY(1px); }
.btn[disabled], .btn[aria-disabled="true"] { opacity: .5; cursor: not-allowed; transform: none; }
.btn-primary { background: var(--accent); border-color: var(--accent); color: var(--accent-ink); }
.btn-primary:hover { filter: brightness(1.08); }
.btn-ghost { background: transparent; border-color: transparent; }
.btn-ghost:hover { background: var(--accent-soft); border-color: transparent; }
.btn-danger { color: var(--danger); border-color: color-mix(in srgb, var(--danger) 55%, transparent); background: transparent; }
.btn-danger.solid { background: var(--danger); color: #fff; }
.btn-icon { padding: 0; width: 44px; }
.btn .spin { width: 16px; height: 16px; border: 2px solid currentColor; border-right-color: transparent; border-radius: 50%; animation: kspin .8s linear infinite; }
@keyframes kspin { to { transform: rotate(360deg); } }
.btn-row { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
.chip {
  display: inline-flex; align-items: center; gap: 4px; padding: 1px 8px; border-radius: 999px; border: 1px solid currentColor;
  font-size: .72rem; font-weight: 800; letter-spacing: .06em; text-transform: uppercase; white-space: nowrap; line-height: 1.5;
}
.chip-error { color: var(--danger); }
.chip-broken { color: var(--broken); }
.chip-forward { color: var(--fwd); }
.chip-warning { color: var(--warn); }
.chip-ok { color: var(--ok); }
.chip-muted { color: var(--muted); }
.chip-accent { color: var(--accent); }
.field { display: flex; flex-direction: column; gap: 4px; min-width: 0; }
.field-label { font-size: .8rem; font-weight: 800; letter-spacing: .08em; text-transform: uppercase; color: var(--ink2); }
.field-label .req { color: var(--accent); }
.field-help { font-size: .82rem; color: var(--muted); }
.field-msg:empty { display: none; }
.field-msg { display: flex; flex-direction: column; gap: 2px; font-size: .84rem; }
.msg { display: flex; gap: 6px; align-items: baseline; }
.msg-error { color: var(--danger); } .msg-broken { color: var(--broken); } .msg-forward { color: var(--fwd); } .msg-warning { color: var(--warn); }
.field.has-error > .field-body .inp, .field.has-error > .field-body .ref-btn { border-color: var(--danger); }
.inp {
  width: 100%; min-height: 44px; padding: 9px 11px; border-radius: 9px; border: 1px solid var(--line2);
  background: var(--bg2); color: var(--ink); font: inherit; font-size: 1rem;
}
.inp::placeholder { color: var(--muted); opacity: .8; }
textarea.inp { resize: vertical; min-height: 88px; line-height: 1.45; }
textarea.inp.mono { font-family: var(--font-mono); font-size: .9rem; min-height: 64px; }
select.inp { appearance: none; background-image: linear-gradient(45deg, transparent 50%, var(--ink2) 50%), linear-gradient(135deg, var(--ink2) 50%, transparent 50%); background-position: calc(100% - 18px) 55%, calc(100% - 12px) 55%; background-size: 6px 6px; background-repeat: no-repeat; padding-right: 32px; }
.switch { display: inline-flex; align-items: center; gap: 10px; min-height: 44px; cursor: pointer; }
.switch input { position: absolute; opacity: 0; width: 1px; height: 1px; }
.switch .track { width: 48px; height: 28px; border-radius: 999px; background: var(--line2); position: relative; transition: background .15s; flex: none; }
.switch .track::after { content: ''; position: absolute; top: 3px; left: 3px; width: 22px; height: 22px; border-radius: 50%; background: var(--ink); transition: transform .15s; }
.switch input:checked + .track { background: var(--accent); }
.switch input:checked + .track::after { transform: translateX(20px); background: var(--accent-ink); }
.switch input:focus-visible + .track { outline: 2px solid var(--accent); outline-offset: 2px; }
.color-row { display: flex; gap: 8px; align-items: center; }
.color-row input[type="color"] { width: 44px; height: 44px; padding: 2px; border-radius: 9px; border: 1px solid var(--line2); background: var(--bg2); cursor: pointer; flex: none; }
.form-grid { display: grid; gap: 12px 14px; grid-template-columns: repeat(auto-fill, minmax(min(100%, 230px), 1fr)); }
.span-all { grid-column: 1 / -1; }
.kform-head { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; margin-bottom: 12px; }
.kform-type { font-family: var(--font-display); font-weight: 700; letter-spacing: .04em; }
.kform-head .field-msg { flex-basis: 100%; }
code.id { color: var(--muted); background: var(--accent-soft); padding: 1px 6px; border-radius: 5px; overflow-wrap: anywhere; }
.ref-row { display: flex; gap: 6px; min-width: 0; }
.ref-btn {
  flex: 1; min-width: 0; min-height: 44px; display: flex; flex-wrap: wrap; align-items: center; gap: 4px 8px; text-align: left;
  padding: 6px 11px; border-radius: 9px; border: 1px solid var(--line2); background: var(--bg2); color: var(--ink); font: inherit; cursor: pointer;
}
.ref-btn:hover { border-color: var(--accent); }
.ref-name { font-weight: 700; overflow-wrap: anywhere; }
.ref-empty { color: var(--muted); font-style: italic; }
.ref-static { flex: 1; min-width: 0; display: flex; flex-wrap: wrap; gap: 4px 8px; align-items: center; padding: 6px 10px; border: 1px solid var(--line); border-radius: 9px; background: var(--bg2); min-height: 44px; }
.klist { display: flex; flex-direction: column; gap: 8px; }
.klist-item { border: 1px solid var(--line); border-left: 3px solid var(--accent); border-radius: var(--radius-sm); padding: 8px 10px 10px; background: color-mix(in srgb, var(--panel2) 60%, transparent); min-width: 0; }
.klist-bar { display: flex; align-items: center; justify-content: space-between; gap: 6px; margin-bottom: 6px; }
.klist-num { font-weight: 800; color: var(--accent); font-size: .85rem; letter-spacing: .08em; }
.klist-ctrls { display: flex; gap: 2px; }
.reflist-row { display: flex; gap: 4px; align-items: center; min-width: 0; }
.fieldset { border: 1px dashed var(--line2); border-radius: var(--radius-sm); padding: 10px; }
.empty-line { color: var(--muted); font-style: italic; font-size: .92rem; padding: 4px 2px; }
.tbl-wrap { overflow-x: auto; max-width: 100%; border: 1px solid var(--line); border-radius: var(--radius-sm); }
.tbl { width: 100%; border-collapse: collapse; font-size: .92rem; }
.tbl th, .tbl td { padding: 6px 10px; border-bottom: 1px solid var(--line); text-align: left; vertical-align: middle; }
.tbl thead th { font-size: .74rem; letter-spacing: .08em; text-transform: uppercase; color: var(--ink2); background: var(--panel2); }
.tbl tbody tr:last-child td, .tbl tbody tr:last-child th { border-bottom: 0; }
.tbl-edit td { padding: 4px; }
.tbl-edit .inp { min-width: 84px; }
.tbl-edit th small { display: block; color: var(--muted); font-weight: 400; font-family: var(--font-mono); font-size: .72rem; }

/* Overlays */
.overlay { position: fixed; inset: 0; z-index: 50; background: var(--scrim); display: flex; align-items: center; justify-content: center; padding: 12px; animation: kfade .12s ease-out; }
@keyframes kfade { from { opacity: 0; } to { opacity: 1; } }
.dialog {
  width: min(560px, 100%); max-height: calc(100dvh - 24px); display: flex; flex-direction: column;
  background: var(--panel); color: var(--ink); border: 1px solid var(--line2); border-radius: var(--radius); box-shadow: var(--shadow);
}
.dialog.wide { width: min(820px, 100%); }
.dlg-head { display: flex; align-items: center; gap: 8px; padding: 8px 8px 8px 16px; border-bottom: 1px solid var(--line); }
.dlg-title { flex: 1; min-width: 0; margin: 0; font-family: var(--font-display); font-size: 1.1rem; letter-spacing: .04em; }
.dlg-body { padding: 16px; overflow-y: auto; min-height: 0; }
.dlg-body > p:first-child { margin-top: 0; }
.dlg-foot { display: flex; flex-wrap: wrap; justify-content: flex-end; gap: 8px; padding: 10px 16px; border-top: 1px solid var(--line); }
.overlay.drawer-overlay { justify-content: flex-end; align-items: stretch; padding: 0; }
.drawer {
  width: min(580px, 100vw); height: 100dvh; display: flex; flex-direction: column; background: var(--panel); border-left: 1px solid var(--line2);
  box-shadow: var(--shadow); animation: kslide .18s ease-out;
}
@keyframes kslide { from { transform: translateX(40px); opacity: .4; } to { transform: none; opacity: 1; } }
.drawer .dlg-body { flex: 1; }
.toast-root { position: fixed; left: 50%; bottom: 16px; transform: translateX(-50%); z-index: 90; display: flex; flex-direction: column; gap: 8px; width: min(460px, calc(100vw - 24px)); pointer-events: none; }
.toast {
  pointer-events: auto; padding: 10px 14px; border-radius: 10px; background: var(--panel2); color: var(--ink); border: 1px solid var(--line2);
  border-left: 4px solid var(--accent2); box-shadow: var(--shadow); font-weight: 500; animation: kfade .15s;
}
.toast.error { border-left-color: var(--danger); } .toast.warn { border-left-color: var(--warn); } .toast.ok { border-left-color: var(--ok); }
.busy { position: fixed; inset: 0; z-index: 80; background: var(--scrim); display: flex; align-items: center; justify-content: center; }
.busy-card { display: flex; align-items: center; gap: 12px; padding: 16px 20px; background: var(--panel); border: 1px solid var(--line2); border-radius: var(--radius); box-shadow: var(--shadow); font-weight: 700; }
.busy-card .spin { width: 22px; height: 22px; border: 3px solid var(--accent); border-right-color: transparent; border-radius: 50%; animation: kspin .8s linear infinite; }
.pick-search { margin-bottom: 10px; }
.pick-list { display: flex; flex-direction: column; gap: 4px; }
.pick-item { justify-content: space-between; flex-wrap: wrap; text-align: left; height: auto; padding: 8px 12px; }
.pick-item[aria-current="true"] { border-color: var(--accent); background: var(--accent-soft); }
.ai-wrap { display: inline-flex; flex-direction: column; gap: 4px; align-items: flex-start; }
.ai-hint { font-size: .85rem; color: var(--warn); }
.ai-hint button { background: none; border: 0; padding: 0; color: var(--accent); font: inherit; font-weight: 700; text-decoration: underline; cursor: pointer; min-height: 44px; min-width: 44px; }

/* Validation panel, review, stubs */
.vgroup { border: 1px solid var(--line); border-radius: var(--radius-sm); margin-bottom: 10px; overflow: hidden; }
.vgroup-head { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; padding: 6px 6px 6px 12px; background: var(--panel2); }
.vgroup-head strong { flex: 1; min-width: 0; overflow-wrap: anywhere; }
.vitem { display: flex; gap: 8px; align-items: baseline; padding: 6px 12px; border-top: 1px solid var(--line); font-size: .92rem; flex-wrap: wrap; }
.vitem code { color: var(--muted); }
.vsummary { display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 12px; }
.section-h { font-family: var(--font-display); font-size: .95rem; letter-spacing: .06em; margin: 16px 0 8px; color: var(--ink2); }
.review-card { border: 1px solid var(--line); border-radius: var(--radius-sm); padding: 12px; margin-bottom: 12px; background: var(--panel2); }
.review-card.ok { border-left: 3px solid var(--ok); } .review-card.bad { border-left: 3px solid var(--danger); }
.review-title { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; margin-bottom: 6px; }
.review-title strong { font-size: 1.05rem; }
.review-issues { margin: 6px 0 8px; padding: 0; list-style: none; font-size: .88rem; }
.review-form { margin-top: 10px; padding-top: 10px; border-top: 1px dashed var(--line2); }
.stub { text-align: center; padding: 36px 18px; }
.stub-glyph { width: 64px; height: 64px; margin: 0 auto 10px; border-radius: 50%; display: grid; place-items: center; background: var(--accent-soft); color: var(--accent); }
.stub-glyph svg.ico { width: 30px; height: 30px; }
.stub h2 { font-family: var(--font-display); letter-spacing: .05em; margin: 0 0 6px; }
.stub p { max-width: 560px; margin: 6px auto; color: var(--ink2); }
.slot-row { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; justify-content: space-between; padding: 10px 12px; border: 1px solid var(--line); border-radius: var(--radius-sm); margin-bottom: 8px; background: var(--panel2); }
.slot-info { min-width: 0; flex: 1 1 180px; }
.slot-info strong { display: block; overflow-wrap: anywhere; }
.slot-info small { color: var(--muted); }
.radio-cards { display: grid; gap: 8px; grid-template-columns: repeat(auto-fit, minmax(min(100%, 200px), 1fr)); margin: 10px 0; }
.radio-card { display: flex; gap: 10px; align-items: flex-start; padding: 10px 12px; border: 1px solid var(--line2); border-radius: var(--radius-sm); cursor: pointer; min-height: 44px; }
.radio-card input { width: 20px; height: 20px; margin: 2px 0 0; accent-color: var(--accent); flex: none; }
.radio-card.disabled { opacity: .55; cursor: not-allowed; }
.settings-test { font-size: .9rem; min-height: 1.4em; }
.settings-test.ok { color: var(--ok); } .settings-test.bad { color: var(--danger); }

@media (max-width: 600px) {
  body { font-size: 16px; }
  .lbl { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }
  .top-actions .btn { padding: 0; width: 44px; }
  .brand-num { display: none; }
  .ws-inner { padding: 12px; }
  .panel { padding: 12px; }
  .dlg-body { padding: 12px; }
}
@media (max-width: 380px) {
  .brand-title { font-size: 1.1rem; letter-spacing: .05em; }
  .backlink { padding: 0 4px; font-size: .82rem; }
}
@media (prefers-reduced-motion: reduce) { *, *::before, *::after { animation: none !important; transition: none !important; } }
.welcome { margin: 12px 16px 0; padding: 16px; border: 1px solid var(--line2); border-radius: var(--radius); background: var(--panel); box-shadow: var(--shadow-sm); }
.welcome[hidden] { display: none; }
.welcome h2 { font-family: var(--font-display); font-size: 1.2rem; letter-spacing: .04em; margin: 0 0 4px; color: var(--accent); }
.welcome p { margin: 0 0 10px; color: var(--ink2); }
.welcome-stages { display: grid; gap: 10px; grid-template-columns: minmax(0, 1fr); margin: 0 0 12px; padding: 0; list-style: none; counter-reset: stage; }
@media (min-width: 760px) { .welcome-stages { grid-template-columns: repeat(3, minmax(0, 1fr)); } }
.welcome-stages li { counter-increment: stage; border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--bg2); padding: 10px 12px; min-width: 0; }
.welcome-stages li::before { content: 'Stage ' counter(stage); display: block; font-size: .72rem; font-weight: 800; letter-spacing: .1em; text-transform: uppercase; color: var(--muted); }
.welcome-stages strong { display: block; font-family: var(--font-display); font-size: 1rem; margin: 2px 0 4px; }
.welcome-stages span { font-size: .92rem; color: var(--ink2); }
.welcome .btn-row { margin-top: 2px; }
.foot-link { min-height: 44px; padding: 0 8px; border: 0; background: transparent; color: var(--accent); font: inherit; text-decoration: underline; cursor: pointer; }
/* === KIT:CORE CSS END === */
/* === WS:CHARTER CSS BEGIN === */
.ch-bar { display: flex; flex-wrap: wrap; align-items: center; gap: 10px 14px; }
.ch-bar-info { flex: 1 1 260px; min-width: 0; }
.ch-bar-info .panel-title { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin-bottom: 2px; }
.ch-bar-hint { margin: 0; color: var(--ink2); font-size: .92rem; }
.ch-bar-actions { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
.ch-body { display: grid; grid-template-columns: 236px minmax(0, 1fr); gap: 14px; margin-top: 14px; align-items: start; }
.ch-navwrap { min-width: 0; position: sticky; top: 0; align-self: start; }
.ch-navtoggle { display: none; width: 100%; justify-content: space-between; margin-bottom: 8px; }
.ch-nav { display: flex; flex-direction: column; gap: 4px; padding: 8px; background: var(--panel); border: 1px solid var(--line); border-radius: var(--radius); }
.ch-nav-item {
  display: flex; align-items: center; justify-content: space-between; gap: 8px; min-height: 44px; padding: 6px 10px;
  border-radius: 9px; border: 1px solid transparent; background: none; color: var(--ink); font: inherit; font-weight: 700; text-align: left; cursor: pointer;
}
.ch-nav-item:hover { background: var(--accent-soft); }
.ch-nav-item[aria-current="true"] { background: var(--accent-soft); border-color: var(--accent); color: var(--accent); }
.ch-nav-chips { display: inline-flex; gap: 4px; align-items: center; flex: none; }
.ch-nav-chips svg.ico { width: 14px; height: 14px; }
.ch-main { min-width: 0; }
.ch-main-head { margin-bottom: 12px; }
.ch-main-head h2 { font-family: var(--font-display); letter-spacing: .04em; margin: 0 0 4px; font-size: 1.25rem; }
.ch-main-head p { margin: 0; color: var(--ink2); }
.ch-banner {
  display: flex; flex-wrap: wrap; align-items: center; gap: 10px; padding: 10px 12px; margin-bottom: 14px;
  border: 1px solid var(--ok); border-left-width: 4px; border-radius: var(--radius-sm); background: color-mix(in srgb, var(--ok) 10%, transparent);
}
.ch-banner span { flex: 1 1 200px; min-width: 0; }
.ch-banner.amending { border-color: var(--warn); background: color-mix(in srgb, var(--warn) 10%, transparent); }
.preset-grid { display: grid; gap: 10px; grid-template-columns: repeat(auto-fit, minmax(min(100%, 220px), 1fr)); margin-bottom: 16px; }
.preset-card {
  display: flex; flex-direction: column; align-items: flex-start; gap: 6px; min-height: 44px; padding: 12px; text-align: left;
  border: 1px solid var(--line2); border-radius: var(--radius-sm); background: var(--panel2); color: var(--ink); font: inherit; cursor: pointer;
}
.preset-card:hover { border-color: var(--accent); }
.preset-card[aria-pressed="true"] { border-color: var(--accent); box-shadow: 0 0 0 1px var(--accent) inset; background: var(--accent-soft); }
.preset-card[disabled] { opacity: .6; cursor: not-allowed; }
.preset-card strong { font-family: var(--font-display); letter-spacing: .04em; font-size: 1.02rem; }
.preset-card .muted { font-size: .9rem; }
.preset-tags { display: flex; flex-wrap: wrap; gap: 4px; min-height: 22px; }
.chap-tools { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 12px; margin-bottom: 12px; }
.chap-tools .grow { flex: 1 1 200px; min-width: 0; color: var(--ink2); }
.chap-list { display: flex; flex-direction: column; gap: 10px; }
.chap-card { border: 1px solid var(--line); border-left: 3px solid var(--accent); border-radius: var(--radius-sm); background: var(--panel2); min-width: 0; }
.chap-card.flash { animation: chflash 1.2s ease-out; }
@keyframes chflash { from { box-shadow: 0 0 0 3px var(--accent); } to { box-shadow: 0 0 0 0 transparent; } }
.chap-head { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 10px; padding: 6px 6px 6px 12px; }
.chap-title { flex: 1 1 200px; min-width: 0; display: flex; flex-wrap: wrap; align-items: baseline; gap: 2px 10px; }
.chap-num { font-weight: 800; color: var(--accent); font-size: .82rem; letter-spacing: .08em; text-transform: uppercase; }
.chap-name { font-weight: 700; overflow-wrap: anywhere; }
.chap-meta { display: flex; flex-wrap: wrap; gap: 4px; }
.chap-ctrls { display: flex; gap: 2px; }
.chap-body { padding: 4px 12px 12px; border-top: 1px dashed var(--line2); }
.chat-log { display: flex; flex-direction: column; gap: 8px; margin: 10px 0; }
.chat-msg { padding: 8px 12px; border-radius: 12px; border: 1px solid var(--line); background: var(--panel2); max-width: 100%; overflow-wrap: anywhere; white-space: pre-wrap; }
.chat-msg.assistant { border-left: 3px solid var(--accent); }
.chat-msg.user { border-left: 3px solid var(--accent2); background: color-mix(in srgb, var(--accent2) 8%, transparent); }
.chat-msg small { display: block; color: var(--muted); font-weight: 800; letter-spacing: .08em; text-transform: uppercase; font-size: .7rem; margin-bottom: 2px; }
.iv-tools { display: flex; flex-wrap: wrap; gap: 10px; align-items: flex-start; margin: 12px 0; }
.finding { border: 1px solid var(--line); border-left: 3px solid var(--warn); border-radius: var(--radius-sm); padding: 10px 12px; margin-bottom: 10px; background: var(--panel2); }
.finding p { margin: 4px 0; }
.finding .paths { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 8px; }
.finding .paths .btn { min-height: 44px; font-size: .82rem; font-family: var(--font-mono); font-weight: 600; white-space: normal; text-align: left; overflow-wrap: anywhere; }
.diff-list { margin: 6px 0 12px; padding: 0; list-style: none; display: flex; flex-direction: column; gap: 4px; }
.diff-list li { display: flex; flex-wrap: wrap; gap: 4px 10px; align-items: baseline; padding: 6px 10px; border: 1px solid var(--line); border-radius: 8px; background: var(--panel2); overflow-wrap: anywhere; }
.diff-list code { color: var(--muted); }
.lock-group { border: 1px solid var(--line); border-radius: var(--radius-sm); margin-bottom: 10px; overflow: hidden; }
.lock-group-head { padding: 6px 12px; background: var(--panel2); font-weight: 800; }
.lock-row { display: flex; flex-wrap: wrap; align-items: center; gap: 6px 10px; padding: 4px 6px 4px 12px; border-top: 1px solid var(--line); }
.lock-row span { flex: 1 1 200px; min-width: 0; overflow-wrap: anywhere; }
@media (max-width: 820px) {
  .ch-body { grid-template-columns: minmax(0, 1fr); }
  .ch-navwrap { position: static; }
  .ch-navtoggle { display: inline-flex; }
  .ch-nav { display: none; }
  .ch-nav.open { display: flex; }
}
@media (max-width: 600px) {
  .ch-bar-actions { width: 100%; }
  .ch-bar-actions .btn, .ch-bar-actions .ai-wrap { flex: 1 1 140px; }
  .ch-bar-actions .btn { min-width: 0; }
  .chap-head { padding-left: 10px; }
}
/* === WS:CHARTER CSS END === */
/* === WS:CODEX CSS BEGIN === */
.cx-bar { display: flex; flex-wrap: wrap; align-items: center; gap: 10px 14px; }
.cx-bar-info { flex: 1 1 260px; min-width: 0; }
.cx-bar-info .panel-title { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin-bottom: 2px; }
.cx-hint { margin: 0; color: var(--ink2); font-size: .92rem; }
.cx-bar-actions { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
.cx-issues .diff-list li span:last-child { flex: 1 1 220px; min-width: 0; }
.cx-empty { text-align: center; padding: 30px 18px; }
.cx-empty h2 { font-family: var(--font-display); letter-spacing: .05em; margin: 0 0 6px; }
.cx-empty p { max-width: 560px; margin: 6px auto 14px; color: var(--ink2); }
.cx-sec-head { display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: 8px 12px; margin-bottom: 8px; }
.cx-sec-head .section-h { margin: 0; }
.cx-search { flex: 0 1 320px; min-width: 0; width: 100%; min-height: 44px; }
.cx-group { margin-top: 14px; }
.cx-group-h { margin: 0; font-family: var(--font-display); letter-spacing: .05em; font-size: 1rem; color: var(--accent); }
.cx-group-text { margin: 2px 0 8px; font-size: .9rem; }
.cx-type-list { display: flex; flex-direction: column; gap: 6px; }
.cx-type { border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--panel2); min-width: 0; }
.cx-type[open] { border-color: var(--line2); }
.cx-type > summary, .cx-block-sum {
  display: flex; flex-wrap: wrap; align-items: center; gap: 6px 10px; min-height: 44px; padding: 6px 12px; cursor: pointer; list-style: none;
}
.cx-type > summary::-webkit-details-marker, .cx-block-sum::-webkit-details-marker { display: none; }
.cx-type > summary::before, .cx-block-sum::before { content: "\25B8"; color: var(--accent); flex: none; transition: transform .15s; }
.cx-type[open] > summary::before, details[open] > .cx-block-sum::before { transform: rotate(90deg); }
.cx-type-name { font-weight: 800; flex: 1 1 140px; min-width: 0; overflow-wrap: anywhere; }
.cx-type-meta { display: inline-flex; flex-wrap: wrap; gap: 4px; align-items: center; }
.cx-prefix { font-family: var(--font-mono); font-weight: 700; color: var(--accent); padding: 1px 6px; border: 1px solid var(--line2); border-radius: 6px; }
.cx-type-body { padding: 4px 12px 12px; border-top: 1px dashed var(--line2); }
.cx-deps { display: flex; flex-wrap: wrap; gap: 4px 6px; align-items: center; margin: 8px 0; }
.cx-fields td { vertical-align: top; }
.cx-fields .cx-key { white-space: nowrap; }
.cx-fields .req { color: var(--danger); font-weight: 800; }
.cx-detail { color: var(--ink2); font-size: .86rem; overflow-wrap: anywhere; min-width: 140px; }
.cx-block-sum .section-h { margin: 0; flex: 1 1 auto; }
details.cx-block > .cx-block-sum { padding: 0; }
.cx-block .tbl .num { text-align: right; }
.cx-fwd-grid { display: grid; gap: 10px; grid-template-columns: repeat(auto-fit, minmax(min(100%, 260px), 1fr)); margin-top: 8px; }
.cx-fwd { min-width: 0; }
.cx-fwd-head { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; justify-content: space-between; }
.cx-fwd p { margin: 4px 0 6px; font-size: .9rem; }
.cx-fwd-list { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 4px; }
.cx-fwd-list li { display: flex; gap: 8px; align-items: baseline; font-size: .86rem; overflow-wrap: anywhere; }
.cx-fwd-list li code { flex: none; color: var(--fwd); font-weight: 700; }
.cx-fwd-list li span { min-width: 0; color: var(--ink2); }
.cx-held { display: flex; flex-wrap: wrap; gap: 4px; margin-top: 8px; }
.cx-held-btn { min-height: 44px; font-size: .82rem; white-space: normal; text-align: left; overflow-wrap: anywhere; flex-wrap: wrap; }
.cx-report p { margin: 6px 0; }
.cx-report-type { margin: 8px 0; }
.cx-orphan { color: var(--warn); display: flex; gap: 6px; align-items: flex-start; }
.field.derived .inp[readonly] { opacity: .8; }
@media (max-width: 600px) {
  .cx-bar-actions { width: 100%; }
  .cx-bar-actions .btn { flex: 1 1 140px; min-width: 0; }
  .cx-search { flex: 1 1 100%; }
}
/* === WS:CODEX CSS END === */
/* === WS:RULES CSS BEGIN === */
.rl-wrap { display: grid; grid-template-columns: 220px minmax(0, 1fr); gap: 14px; align-items: start; }
.rl-rail { display: flex; flex-direction: column; gap: 12px; padding: 10px; background: var(--panel); border: 1px solid var(--line); border-radius: var(--radius); position: sticky; top: 8px; max-height: calc(100vh - 24px); overflow: auto; }
.rl-group { display: flex; flex-direction: column; gap: 3px; }
.rl-group-h { font-family: var(--font-display); font-size: .78rem; letter-spacing: .12em; text-transform: uppercase; color: var(--muted); padding: 4px 8px; }
.rl-nav { display: flex; align-items: center; gap: 8px; min-height: 44px; padding: 6px 10px; border: 1px solid transparent; border-radius: var(--radius-sm); background: transparent; color: var(--ink); font: inherit; text-align: left; cursor: pointer; width: 100%; }
.rl-nav:hover { background: var(--accent-soft); }
.rl-nav.on { background: var(--accent-soft); border-color: var(--accent); color: var(--accent); }
.rl-nav:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
.rl-nav-l { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.rl-count { font-size: .78rem; color: var(--muted); background: var(--bg2); border-radius: 999px; padding: 1px 8px; flex: none; }
.rl-main { min-width: 0; }
.rl-h2 { font-family: var(--font-display); font-size: 1.25rem; margin: 0 0 10px; }
.rl-lead { margin: 0 0 12px; }
.rl-note { font-size: .86rem; }
.rl-banner { display: flex; flex-wrap: wrap; gap: 10px; align-items: center; justify-content: space-between; padding: 10px 12px; margin-bottom: 12px; border: 1px solid var(--line2); border-left: 4px solid var(--accent); border-radius: var(--radius-sm); background: var(--accent-soft); }
.rl-banner span { flex: 1 1 220px; }
.rl-rows { display: flex; flex-direction: column; gap: 10px; }
.rl-row { display: flex; flex-wrap: wrap; gap: 10px; align-items: flex-end; padding: 10px; border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--bg2); }
.rl-row.bad { border-color: var(--danger, #d9534f); }
.rl-f { display: flex; flex-direction: column; gap: 4px; min-width: 0; flex: 1 1 140px; }
.rl-f.sm { flex: 0 1 110px; }
.rl-f.md { flex: 0 1 170px; }
.rl-f.lg { flex: 1 1 180px; }
.rl-f > label { font-size: .82rem; color: var(--ink2); }
.rl-keycode { display: flex; align-items: center; min-height: 44px; padding: 0 10px; font-family: var(--font-mono); border: 1px dashed var(--line2); border-radius: var(--radius-sm); color: var(--ink2); }
.rl-ctrls { display: flex; gap: 2px; margin-left: auto; }
.rl-msgs { flex: 1 1 100%; display: flex; flex-direction: column; gap: 2px; }
.rl-msgs:empty { display: none; }
.rl-pairnote { flex: 1 1 100%; font-size: .86rem; }
.rl-pairnote:empty { display: none; }
.rl-addbar { margin-top: 12px; }
.rl-chipbar { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; margin-top: 12px; }
.rl-chipbtn { min-height: 44px; }
.rl-tabs { display: flex; gap: 4px; overflow-x: auto; margin-bottom: 12px; border-bottom: 1px solid var(--line); }
.rl-tab { min-height: 44px; padding: 0 14px; border: 0; border-bottom: 3px solid transparent; background: transparent; color: var(--ink2); font: inherit; cursor: pointer; white-space: nowrap; }
.rl-tab[aria-selected="true"] { color: var(--accent); border-bottom-color: var(--accent); }
.rl-aff { text-transform: capitalize; }
.rl-aff-weak { background: rgba(217,83,79,.18); color: var(--danger, #d9534f); }
.rl-aff-resist { background: rgba(80,140,220,.18); }
.rl-aff-immune, .rl-aff-absorb { background: rgba(90,180,110,.2); }
.rl-matrix th, .rl-matrix td { white-space: nowrap; }
.rl-main .switch, .drawer .switch, .rl-tbl-wrap { position: relative; }
.rl-famrow { align-items: center; }
.rl-affsum { display: flex; flex-wrap: wrap; gap: 4px; flex: 1 1 100%; }
.rl-toolbar { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; margin-bottom: 12px; }
.rl-search { flex: 1 1 200px; min-width: 0; }
.rl-reclist { display: flex; flex-direction: column; gap: 6px; }
.rl-rec { display: flex; align-items: center; gap: 4px; border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--bg2); padding-right: 4px; }
.rl-rec-main { flex: 1; min-width: 0; display: flex; flex-wrap: wrap; gap: 4px 10px; align-items: center; min-height: 48px; padding: 6px 12px; border: 0; background: transparent; color: var(--ink); font: inherit; text-align: left; cursor: pointer; border-radius: var(--radius-sm); }
.rl-rec-main:hover { background: var(--accent-soft); }
.rl-rec-main:focus-visible { outline: 2px solid var(--accent); }
.rl-edhead { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; margin-bottom: 12px; }
.rl-edtitle { display: flex; flex-wrap: wrap; gap: 4px 10px; align-items: baseline; flex: 1 1 160px; min-width: 0; }
.rl-edacts { display: flex; flex-wrap: wrap; gap: 6px; }
.rl-extras { margin-top: 16px; display: flex; flex-direction: column; gap: 12px; }
.rl-tools { display: flex; flex-wrap: wrap; gap: 8px 12px; align-items: center; }
.rl-tools select { max-width: 320px; }
.rl-expr code, .rl-defaults code { word-break: break-word; }
.rl-defaults code { margin-right: 6px; }
.rl-block { margin-bottom: 20px; }
.rl-roles { display: flex; flex-wrap: wrap; gap: 8px; }
.rl-role { display: inline-flex; gap: 8px; align-items: center; min-height: 44px; padding: 4px 12px; border: 1px solid var(--line2); border-radius: 999px; background: var(--bg2); color: var(--ink); font: inherit; cursor: pointer; }
.rl-role.bad { border-color: var(--danger, #d9534f); }
.rl-libgrid { display: grid; grid-template-columns: repeat(auto-fill, minmax(230px, 1fr)); gap: 10px; }
.rl-libcard { display: flex; flex-direction: column; gap: 6px; }
.rl-libcard p { margin: 0; flex: 1; font-size: .9rem; }
.rl-libhead { display: flex; justify-content: space-between; gap: 6px; align-items: center; }
.rl-prev { border: 1px solid var(--line); border-radius: var(--radius-sm); padding: 12px; background: var(--bg2); }
.rl-prev-inputs { display: flex; flex-wrap: wrap; gap: 12px; margin-bottom: 10px; }
.rl-si-group { display: flex; flex-wrap: wrap; gap: 8px; align-items: flex-end; flex: 1 1 200px; min-width: 0; }
.rl-si-title { flex: 1 1 100%; font-size: .82rem; letter-spacing: .06em; text-transform: uppercase; color: var(--muted); }
.rl-si { display: flex; flex-direction: column; gap: 3px; flex: 0 1 84px; min-width: 70px; font-size: .8rem; color: var(--ink2); }
.rl-si .inp { padding-left: 8px; padding-right: 8px; }
.rl-prev-read { margin: 6px 0; }
.rl-chart { position: relative; height: 240px; width: 100%; }
.rl-chart canvas { max-width: 100%; }
.rl-prev-table { margin-top: 10px; max-height: 200px; overflow: auto; }
@media (max-width: 820px) {
  .rl-wrap { grid-template-columns: minmax(0, 1fr); }
  .rl-rail { position: static; max-height: none; flex-direction: column; }
  .rl-group { flex-direction: row; overflow-x: auto; gap: 6px; padding-bottom: 2px; }
  .rl-group-h { flex: none; align-self: center; padding: 0 6px 0 2px; }
  .rl-nav { width: auto; flex: none; }
  .rl-nav-l { overflow: visible; }
}
@media (max-width: 480px) {
  .rl-f.sm { flex: 1 1 90px; }
  .rl-ctrls { flex: 1 1 100%; justify-content: flex-end; margin-left: 0; }
}
/* Pass 4B content editors */
.rl-summary { display: flex; flex-direction: column; gap: 8px; }
.rl-sumline { line-height: 1.45; overflow-wrap: anywhere; }
.rl-summary .section-h { margin: 0; }
.rl-link { min-height: 44px; padding: 4px 10px; text-align: left; overflow-wrap: anywhere; }
.rl-slotb, .rl-limb, .rl-gmb, .rl-trp { display: flex; flex-direction: column; gap: 10px; }
.rl-slotb .section-h, .rl-limb .section-h, .rl-gmb .section-h, .rl-trp .section-h { margin: 8px 0 0; }
.rl-slotcount { min-width: 90px; text-align: center; }
.rl-slotsvg { display: block; width: min(100%, 360px); height: auto; align-self: center; touch-action: manipulation; }
.rl-slot { cursor: pointer; outline: none; }
.rl-slot circle { fill: var(--bg2); stroke: var(--line2); stroke-width: 3; }
.rl-slot:hover circle { stroke: var(--accent); }
.rl-slot:focus-visible circle { stroke: var(--accent); stroke-width: 6; }
.rl-slot.sel circle { fill: var(--accent-soft); stroke: var(--accent); stroke-width: 5; }
.rl-slot text { fill: var(--ink); font-family: var(--font-ui); font-weight: 700; font-size: 18px; text-anchor: middle; dominant-baseline: central; pointer-events: none; }
.rl-slot-bar { stroke: var(--accent); stroke-width: 10; stroke-linecap: round; fill: none; opacity: .85; }
.rl-slot-bar.arc { stroke-width: 7; }
.rl-linkchip { display: inline-flex; align-items: center; gap: 2px; }
.rl-lcard { display: flex; flex-wrap: wrap; gap: 6px 10px; align-items: center; padding: 8px 10px; border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--bg2); }
.rl-lcard-main { flex: 1 1 200px; min-width: 0; display: flex; flex-direction: column; gap: 4px; }
.rl-lbadge { font-family: var(--font-display); font-size: .78rem; letter-spacing: .1em; text-transform: uppercase; color: var(--accent); }
.rl-ltitle { display: flex; flex-wrap: wrap; gap: 4px 8px; align-items: center; }
.rl-lmeta { display: flex; flex-wrap: wrap; gap: 4px 6px; }
.rl-grow { border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--bg2); padding: 10px; display: flex; flex-direction: column; gap: 8px; }
.rl-grow.dragging { opacity: .5; }
.rl-grow.dropping { border-color: var(--accent); box-shadow: 0 0 0 2px var(--accent-soft); }
.rl-grow-head { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; }
.rl-grow-head strong { flex: 1 1 auto; }
.rl-grow-head .rl-ctrls { margin-left: 0; }
.rl-grow-body { display: flex; flex-wrap: wrap; gap: 10px; }
.rl-gline { flex: 1 1 100%; font-style: italic; color: var(--ink2); overflow-wrap: anywhere; }
.rl-grip { width: 44px; height: 44px; flex: none; border-radius: var(--radius-sm); cursor: grab; border: 1px dashed var(--line2); background: radial-gradient(circle, var(--muted) 2px, transparent 2.5px) 0 0 / 11px 11px; }
.rl-grip:active { cursor: grabbing; }
.rl-lanes { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); gap: 10px; }
.rl-lane { border: 1px dashed var(--line2); border-radius: var(--radius-sm); padding: 10px; display: flex; flex-direction: column; gap: 8px; background: var(--bg2); min-width: 0; }
.rl-lane-h { display: flex; justify-content: space-between; align-items: center; font-family: var(--font-display); font-size: .82rem; letter-spacing: .08em; text-transform: uppercase; color: var(--ink2); }
.rl-mcard { border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--panel); padding: 8px; display: flex; flex-direction: column; gap: 6px; min-width: 0; }
.rl-mtop { display: flex; flex-wrap: wrap; gap: 4px 8px; align-items: center; }
.rl-mctl { display: flex; flex-wrap: wrap; gap: 4px; align-items: center; }
.rl-tiergrid { display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 10px; margin: 10px 0; }
.rl-tiergrid .rl-f { flex: initial; }
.rl-pacing .rl-tools { align-items: flex-end; }
.rl-egrid { display: flex; flex-direction: column; gap: 8px; margin-bottom: 8px; }
.rl-ehead { display: none; }
.rl-erow { display: flex; flex-wrap: wrap; gap: 8px 10px; align-items: flex-end; padding: 10px; border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--bg2); }
.rl-echap { flex: 1 1 100%; display: flex; flex-wrap: wrap; gap: 4px 10px; align-items: baseline; min-width: 0; }
.rl-noeps { flex: 1 1 120px; }
.rl-erow .rl-f.sm { flex: 1 1 96px; }
.ws-inner[data-ws=rules] [hidden] { display: none !important; }
.rl-econ { display: grid; grid-template-columns: repeat(auto-fill, minmax(min(100%, 300px), 1fr)); gap: 10px; margin-bottom: 20px; }
.rl-ecard { display: flex; flex-direction: column; gap: 8px; }
.rl-ecard.bad { border-color: var(--danger); }
.rl-ecard-h { display: flex; flex-wrap: wrap; gap: 4px 8px; align-items: center; justify-content: space-between; }
.rl-kv { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 6px 12px; }
.rl-kv span { display: block; font-size: .78rem; color: var(--muted); }
.rl-kv strong { font-variant-numeric: tabular-nums; overflow-wrap: anywhere; }
.rl-flags { display: flex; flex-direction: column; gap: 3px; }
.rl-seedlist { display: flex; flex-direction: column; gap: 6px; margin-bottom: 10px; }
.rl-seed { display: flex; gap: 10px; align-items: flex-start; min-height: 44px; padding: 6px 8px; border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--bg2); cursor: pointer; }
.rl-seed input { width: 22px; height: 22px; margin-top: 8px; flex: none; accent-color: var(--accent); }
.rl-seed-t { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
.rl-seedrow { flex-wrap: wrap; }
.rl-seedinfo { cursor: default; }
.rl-seedinfo:hover { background: transparent; }
.rl-seedpast { flex: 1 1 100%; }
.rl-seedacts { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; padding: 4px; }
.tbl .num { text-align: right; font-variant-numeric: tabular-nums; }
@media (min-width: 900px) {
  .rl-ehead, .rl-erow { display: grid; grid-template-columns: minmax(150px, 1.6fr) 96px 96px 120px 110px auto; gap: 8px; align-items: center; }
  .rl-ehead { padding: 0 10px; font-size: .74rem; letter-spacing: .08em; text-transform: uppercase; color: var(--ink2); }
  .rl-erow .rl-f > label { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }
  .rl-echap { flex: initial; }
  .rl-noeps { grid-column: span 4; }
}
@media (max-width: 600px) {
  .rl-lanes { grid-template-columns: minmax(0, 1fr); }
}
/* === WS:RULES CSS END === */
/* === WS:ARENA CSS BEGIN === */
.ar-wrap { display: grid; gap: 14px; grid-template-columns: minmax(0, 1fr); }
@media (min-width: 980px) { .ar-wrap { grid-template-columns: 330px minmax(0, 1fr); align-items: start; } }
@media (max-width: 979px) { .ar-stagepanel { order: -1; } }
.ar-empty .btn { margin-top: 8px; }
.ar-setup .form-grid { grid-template-columns: repeat(auto-fill, minmax(min(100%, 200px), 1fr)); }
.ar-setup h3 { margin: 12px 0 6px; }
.ar-chars { display: flex; flex-wrap: wrap; gap: 6px; }
.ar-pick { display: inline-flex; align-items: center; gap: 8px; min-height: 44px; padding: 0 12px; border-radius: 10px; border: 1px solid var(--line2); background: var(--bg2); color: var(--ink); font: inherit; font-weight: 700; cursor: pointer; }
.ar-pick[aria-pressed="true"] { border-color: var(--accent); background: var(--accent-soft); color: var(--accent); }
.ar-pick .dot { width: 10px; height: 10px; border-radius: 3px; flex: none; }
.ar-cust { display: flex; flex-direction: column; gap: 8px; margin-top: 8px; }
.ar-crow { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1.3fr); gap: 8px; align-items: center; }
.ar-seg { display: inline-flex; border: 1px solid var(--line2); border-radius: 10px; overflow: hidden; }
.ar-seg button { min-height: 44px; min-width: 52px; padding: 0 12px; border: 0; background: var(--bg2); color: var(--ink2); font: inherit; font-weight: 700; cursor: pointer; }
.ar-seg button + button { border-left: 1px solid var(--line2); }
.ar-seg button[aria-pressed="true"] { background: var(--accent); color: var(--accent-ink); }
.ar-seedrow { display: flex; gap: 6px; }
.ar-seedrow .inp { flex: 1; min-width: 0; font-family: var(--font-mono); }
.ar-note { font-size: .85rem; color: var(--muted); margin: 4px 0 0; }
.ar-stagepanel { padding: 12px; }
.ar-head { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; justify-content: space-between; margin-bottom: 10px; }
.ar-head .panel-title { margin: 0; }
.ar-stage { position: relative; display: flex; justify-content: center; background: #07080d; border: 1px solid var(--line); border-radius: var(--radius-sm); padding: 8px 0; min-height: 120px; overflow: hidden; }
.ar-stage canvas { display: block; image-rendering: pixelated; image-rendering: crisp-edges; touch-action: manipulation; }
.ar-empty { color: #c9c1ab; text-align: center; padding: 40px 16px; max-width: 420px; }
.ar-empty h3 { font-family: var(--font-display); margin: 0 0 6px; color: #e3b453; }
.ar-menu { margin-top: 10px; border: 1px solid var(--line2); border-radius: var(--radius-sm); background: var(--panel2); padding: 10px; }
.ar-menu[hidden] { display: none; }
.ar-menu-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-bottom: 8px; font-weight: 800; }
.ar-menu-head .who { font-family: var(--font-display); color: var(--accent); letter-spacing: .04em; }
.ar-menu-grid { display: grid; gap: 6px; grid-template-columns: repeat(auto-fill, minmax(min(100%, 150px), 1fr)); }
.ar-menu-grid .btn { justify-content: space-between; white-space: normal; text-align: left; line-height: 1.15; padding: 6px 12px; }
.ar-menu-grid .btn small { font-weight: 600; color: var(--muted); font-size: .78rem; }
.ar-menu-grid .btn.limit { border-color: var(--accent); color: var(--accent); }
.ar-controls { display: flex; flex-wrap: wrap; gap: 8px; margin-top: 10px; align-items: center; }
.ar-result { margin-top: 10px; }
.ar-result[hidden] { display: none; }
.ar-result .kv { margin-top: 6px; }
.ar-status { font-size: .88rem; color: var(--muted); }
.ar-log { display: flex; flex-direction: column; gap: 2px; font-size: .9rem; }
.ar-log .ln { display: grid; grid-template-columns: 58px minmax(0, 1fr); gap: 8px; padding: 3px 0; border-bottom: 1px solid var(--line); }
.ar-log .ln .t { font-family: var(--font-mono); color: var(--muted); font-size: .78rem; text-align: right; }
.ar-log .ln.k-damage .m { color: var(--danger); }
.ar-log .ln.k-heal .m { color: var(--ok); }
.ar-log .ln.k-ko .m, .ar-log .ln.k-end .m { font-weight: 800; }
.ar-log .ln.k-limitReady .m { color: var(--accent); }
.ar-code { width: 100%; font-family: var(--font-mono); font-size: .8rem; min-height: 120px; }
/* === WS:ARENA CSS END === */
/* === WS:SIM CSS BEGIN === */
.sim-root { display: flex; flex-direction: column; gap: 14px; min-width: 0; }
.sim-root > .panel + .panel, .sim-out > .panel + .panel { margin-top: 0; }
.sim-out { display: flex; flex-direction: column; gap: 14px; min-width: 0; }
.sim-lead { margin: 0 0 10px; color: var(--ink2); }
.sim-grid { grid-template-columns: repeat(auto-fill, minmax(min(100%, 240px), 1fr)); }
.sim-setup h3 { margin: 14px 0 6px; }
.sim-actions { margin-top: 14px; }
.sim-progress { margin-top: 12px; }
.sim-progress[hidden] { display: none; }
.sim-track { height: 14px; border-radius: 99px; background: var(--bg2); border: 1px solid var(--line2); overflow: hidden; }
.sim-track i { display: block; height: 100%; width: 0; background: var(--accent); transition: width .12s linear; }
.sim-progtext { margin-top: 6px; font-size: .88rem; color: var(--muted); font-family: var(--font-mono); overflow-wrap: anywhere; }
.sim-empty, .sim-error { color: var(--ink2); }
.sim-empty h3, .sim-error h3 { font-family: var(--font-display); margin: 0 0 6px; color: var(--accent); }
.sim-empty p, .sim-error p { margin: 0 0 10px; }
.sim-empty .btn { margin-top: 4px; }
.sim-chips { display: flex; flex-wrap: wrap; gap: 6px; }
.sim-summary .panel-title { margin-bottom: 8px; }
.sim-tbl th small, .sim-tbl td small { display: block; color: var(--muted); font-size: .72rem; font-weight: 400; }
.sim-tbl th small.mono { font-family: var(--font-mono); }
.sim-tbl tr.is-flag { background: var(--accent-soft); }
.sim-tbl th[scope="row"] { font-weight: 700; min-width: 130px; }
.sim-fix { white-space: normal; min-width: 220px; }
.sim-fix .btn { margin: 2px 4px 2px 0; padding: 0 12px; }
.sim-skipbox { margin-top: 10px; }
.sim-skiph { margin: 0 0 4px; font-size: .8rem; letter-spacing: .08em; text-transform: uppercase; color: var(--ink2); }
.sim-skips { margin: 0; padding-left: 18px; color: var(--ink2); font-size: .92rem; }
.sim-charts { display: grid; gap: 14px; grid-template-columns: minmax(0, 1fr); }
@media (min-width: 980px) { .sim-charts { grid-template-columns: repeat(2, minmax(0, 1fr)); } .sim-pickrow { grid-column: 1 / -1; } }
.sim-pickrow { max-width: 420px; }
@media (min-width: 980px) { #simChart1, #simChart3 { height: 300px; } .sim-chartpanel.is-wide { grid-column: 1 / -1; } }
.sim-chartpanel { min-width: 0; }
.sim-chartpanel + .sim-chartpanel { margin-top: 0; }
.sim-charthead .section-h { margin: 0 0 4px; }
.sim-chart { position: relative; height: 280px; min-width: 0; }
.sim-chart.is-table { height: auto; }
.sim-chart canvas { max-width: 100%; }
.sim-root .btn .lbl, .exp-files .btn .lbl { position: static; width: auto; height: auto; overflow: visible; clip: auto; }
.exp-files { display: flex; flex-direction: column; gap: 8px; }
.exp-file { display: flex; gap: 10px; align-items: center; justify-content: space-between; flex-wrap: wrap; padding: 8px 10px; border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--bg2); }
.exp-file-t { display: flex; flex-direction: column; gap: 2px; min-width: 0; flex: 1 1 200px; overflow-wrap: anywhere; }
.exp-file-t .muted { font-size: .85rem; }
/* === WS:SIM CSS END === */
</style>
</head>
<body>
<div class="app" id="app">
  <header class="app-head">
    <div class="brand">
      <h1 class="brand-title">Saga Forge</h1>
      <span class="brand-num">App 146</span>
    </div>
    <a class="backlink" href="https://augustineiacopelli.github.io/appaday/" title="Back to the AppADay portfolio">&larr; AppADay</a>
    <button class="btn btn-ghost btn-icon" id="btnTheme" type="button" aria-label="Toggle night and parchment theme" title="Toggle theme"></button>
    <button class="btn btn-ghost btn-icon" id="btnSettings" type="button" aria-label="Settings" title="Settings"></button>
  </header>
  <div class="topbar" role="toolbar" aria-label="Project">
    <button class="btn btn-ghost proj-title" id="btnTitle" type="button" title="Rename project"><span class="t">Untitled Saga</span></button>
    <button class="btn vbadge" id="btnValidation" type="button" title="Open validation panel" aria-label="Validation status"></button>
    <div class="top-actions">
      <button class="btn" id="btnSave" type="button" title="Save draft (Ctrl+S)"></button>
      <button class="btn" id="btnSlots" type="button" title="Project slots"></button>
      <button class="btn" id="btnImport" type="button" title="Import a bundle"></button>
      <button class="btn" id="btnExport" type="button" title="Export the bundle"></button>
    </div>
    <input type="file" id="fileImport" accept=".json,application/json" hidden>
  </div>
  <nav class="tabs" id="tabs" role="tablist" aria-label="Workspaces"></nav>
  <section class="welcome" id="welcome" aria-label="Welcome to Saga Forge" hidden></section>
  <main class="ws" id="ws" tabindex="-1"></main>
  <footer class="app-foot">
    <span>Saga Forge &middot; AppADay 146 &middot; <button class="foot-link" id="btnWelcome" type="button">Welcome guide</button></span>
    <a class="backlink" href="https://augustineiacopelli.github.io/appaday/">augustineiacopelli.github.io/appaday</a>
  </footer>
</div>
<div id="overlays"></div>
<div class="toast-root" id="toasts" aria-live="polite" role="status"></div>
<script>
// === KIT:CORE BEGIN ===
(function () {
  'use strict';

  var Kit = window.Kit = {};
  window.WS = window.WS || {};
  Kit.version = '1.0.0';

  // ---------------------------------------------------------------- util
  var U = Kit.util = {};
  U.now = function () { return new Date().toISOString(); };
  U.isObj = function (o) { return o !== null && typeof o === 'object' && !Array.isArray(o); };
  U.clone = function (o) { return o === undefined ? undefined : JSON.parse(JSON.stringify(o)); };
  U.noop = function () {};
  U.esc = function (s) {
    return String(s == null ? '' : s).replace(/[&<>"']/g, function (c) {
      return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c];
    });
  };
  U.rand36 = function (n) {
    var out = '', chars = '0123456789abcdefghijklmnopqrstuvwxyz', buf = new Uint8Array(n);
    try { crypto.getRandomValues(buf); } catch (e) { for (var j = 0; j < n; j++) buf[j] = Math.floor(Math.random() * 256); }
    for (var i = 0; i < n; i++) out += chars[buf[i] % 36];
    return out;
  };
  U.slug = function (s, sep) {
    sep = sep || '-';
    var t = String(s == null ? '' : s).toLowerCase();
    try { t = t.normalize('NFKD').replace(/[\u0300-\u036f]/g, ''); } catch (e) {}
    return t.replace(/[^a-z0-9]+/g, sep).replace(new RegExp('^' + sep + '+|' + sep + '+$', 'g'), '');
  };
  U.debounce = function (fn, ms) {
    var t = null, args = null, self = null;
    function run() { t = null; var a = args; args = null; fn.apply(self, a || []); }
    function d() { args = arguments; self = this; clearTimeout(t); t = setTimeout(run, ms); }
    d.flush = function () { if (t) { clearTimeout(t); run(); } };
    d.pending = function () { return !!t; };
    d.cancel = function () { clearTimeout(t); t = null; args = null; };
    return d;
  };
  U.canonical = function canonical(v) {
    if (v === null || typeof v !== 'object') {
      if (v === undefined || (typeof v === 'number' && !isFinite(v))) return 'null';
      return JSON.stringify(v);
    }
    if (Array.isArray(v)) {
      return '[' + v.map(function (x) { return x === undefined ? 'null' : canonical(x); }).join(',') + ']';
    }
    var keys = Object.keys(v).filter(function (k) { return v[k] !== undefined && typeof v[k] !== 'function'; }).sort();
    return '{' + keys.map(function (k) { return JSON.stringify(k) + ':' + canonical(v[k]); }).join(',') + '}';
  };
  // Path helpers: 'a.b[2].c'
  U.parsePath = function (path) {
    var out = [];
    String(path || '').replace(/\[(\d+)\]|[^.[\]]+/g, function (m, idx) { out.push(idx !== undefined ? Number(idx) : m); return m; });
    return out;
  };
  U.getPath = function (obj, path) {
    var parts = U.parsePath(path), cur = obj;
    for (var i = 0; i < parts.length; i++) { if (cur == null) return undefined; cur = cur[parts[i]]; }
    return cur;
  };
  U.parentPath = function (path) {
    path = String(path || '');
    var m = /^(.*)(\[\d+\]|\.[^.[\]]+)$/.exec(path);
    return m ? m[1] : '';
  };
  U.download = function (name, text, mime) {
    var blob = new Blob([text], { type: mime || 'application/octet-stream' });
    var url = URL.createObjectURL(blob);
    var a = document.createElement('a');
    a.href = url; a.download = name; a.style.display = 'none';
    document.body.appendChild(a); a.click();
    setTimeout(function () { U.detach(a); URL.revokeObjectURL(url); }, 1000);
  };
  U.readFile = function (file) {
    return new Promise(function (resolve, reject) {
      var r = new FileReader();
      r.onload = function () { resolve(String(r.result)); };
      r.onerror = function () { reject(new Error('Could not read the file.')); };
      r.readAsText(file);
    });
  };
  U.detach = function (node) { if (node && node.parentNode) node.parentNode.removeChild(node); };
  U.clear = function (node) { while (node && node.firstChild) node.removeChild(node.firstChild); };
  U.el = function (tag, cls, html) {
    var n = document.createElement(tag);
    if (cls) n.className = cls;
    if (html != null) n.innerHTML = html;
    return n;
  };
  U.fmtDate = function (iso) {
    if (!iso) return '';
    try { return new Date(iso).toLocaleString(undefined, { dateStyle: 'medium', timeStyle: 'short' }); } catch (e) { return iso; }
  };
  U.fmtSize = function (chars) { return chars > 1e6 ? (chars / 1e6).toFixed(2) + ' MB' : Math.max(1, Math.round(chars / 1e3)) + ' KB'; };

  // SHA-256 (sync, UTF-8), so hashing works on file:// and inside tests.
  var SHA_K = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];
  U.sha256 = function (str) {
    var msg = new TextEncoder().encode(String(str));
    var l = msg.length, total = Math.ceil((l + 9) / 64) * 64;
    var buf = new Uint8Array(total);
    buf.set(msg); buf[l] = 0x80;
    var dv = new DataView(buf.buffer);
    dv.setUint32(total - 8, Math.floor(l / 0x20000000));
    dv.setUint32(total - 4, (l * 8) >>> 0);
    var H = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
    var W = new Array(64);
    for (var off = 0; off < total; off += 64) {
      var i;
      for (i = 0; i < 16; i++) W[i] = dv.getUint32(off + i * 4);
      for (i = 16; i < 64; i++) {
        var w15 = W[i - 15], w2 = W[i - 2];
        var s0 = ((w15 >>> 7) | (w15 << 25)) ^ ((w15 >>> 18) | (w15 << 14)) ^ (w15 >>> 3);
        var s1 = ((w2 >>> 17) | (w2 << 15)) ^ ((w2 >>> 19) | (w2 << 13)) ^ (w2 >>> 10);
        W[i] = (W[i - 16] + s0 + W[i - 7] + s1) >>> 0;
      }
      var a = H[0], b = H[1], c = H[2], d = H[3], e = H[4], f = H[5], g = H[6], h = H[7];
      for (i = 0; i < 64; i++) {
        var S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
        var ch = (e & f) ^ (~e & g);
        var t1 = (h + S1 + ch + SHA_K[i] + W[i]) >>> 0;
        var S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
        var mj = (a & b) ^ (a & c) ^ (b & c);
        var t2 = (S0 + mj) >>> 0;
        h = g; g = f; f = e; e = (d + t1) >>> 0; d = c; c = b; b = a; a = (t1 + t2) >>> 0;
      }
      H[0] = (H[0] + a) >>> 0; H[1] = (H[1] + b) >>> 0; H[2] = (H[2] + c) >>> 0; H[3] = (H[3] + d) >>> 0;
      H[4] = (H[4] + e) >>> 0; H[5] = (H[5] + f) >>> 0; H[6] = (H[6] + g) >>> 0; H[7] = (H[7] + h) >>> 0;
    }
    return H.map(function (x) { return ('00000000' + x.toString(16)).slice(-8); }).join('');
  };

  // ---------------------------------------------------------------- icons
  var ICONS = {
    gear: '<circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.7 1.7 0 0 0 .3 1.8l.1.1a2 2 0 1 1-2.8 2.8l-.1-.1a1.7 1.7 0 0 0-1.8-.3 1.7 1.7 0 0 0-1 1.5V21a2 2 0 1 1-4 0v-.1a1.7 1.7 0 0 0-1.1-1.5 1.7 1.7 0 0 0-1.8.3l-.1.1a2 2 0 1 1-2.8-2.8l.1-.1a1.7 1.7 0 0 0 .3-1.8 1.7 1.7 0 0 0-1.5-1H3a2 2 0 1 1 0-4h.1a1.7 1.7 0 0 0 1.5-1.1 1.7 1.7 0 0 0-.3-1.8l-.1-.1a2 2 0 1 1 2.8-2.8l.1.1a1.7 1.7 0 0 0 1.8.3H9a1.7 1.7 0 0 0 1-1.5V3a2 2 0 1 1 4 0v.1a1.7 1.7 0 0 0 1 1.5 1.7 1.7 0 0 0 1.8-.3l.1-.1a2 2 0 1 1 2.8 2.8l-.1.1a1.7 1.7 0 0 0-.3 1.8V9a1.7 1.7 0 0 0 1.5 1H21a2 2 0 1 1 0 4h-.1a1.7 1.7 0 0 0-1.5 1z"/>',
    lock: '<rect x="5" y="11" width="14" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/>',
    save: '<path d="M5 3h11l3 3v15H5z"/><path d="M8 3v5h7V3M8 21v-7h8v7"/>',
    slots: '<rect x="3" y="4" width="8" height="7" rx="1.5"/><rect x="13" y="4" width="8" height="7" rx="1.5"/><rect x="3" y="13" width="8" height="7" rx="1.5"/><rect x="13" y="13" width="8" height="7" rx="1.5"/>',
    import: '<path d="M12 3v12M7 10l5 5 5-5M4 21h16"/>',
    export: '<path d="M12 15V3M7 8l5-5 5 5M4 21h16"/>',
    check: '<path d="M5 12l5 5 9-10"/>',
    x: '<path d="M6 6l12 12M18 6L6 18"/>',
    up: '<path d="M6 15l6-6 6 6"/>',
    down: '<path d="M6 9l6 6 6-6"/>',
    plus: '<path d="M12 5v14M5 12h14"/>',
    trash: '<path d="M4 7h16M9 7V4h6v3M6 7l1 14h10l1-14"/>',
    search: '<circle cx="11" cy="11" r="7"/><path d="M20 20l-4-4"/>',
    spark: '<path d="M12 3l2.2 5.8L20 11l-5.8 2.2L12 19l-2.2-5.8L4 11l5.8-2.2z"/>',
    moon: '<path d="M20 14.5A8 8 0 1 1 9.5 4a6.5 6.5 0 0 0 10.5 10.5z"/>',
    sun: '<circle cx="12" cy="12" r="4"/><path d="M12 2v2M12 20v2M4.9 4.9l1.4 1.4M17.7 17.7l1.4 1.4M2 12h2M20 12h2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4"/>',
    warn: '<path d="M12 3l9.5 17h-19z"/><path d="M12 10v4M12 17.5v.2"/>',
    jump: '<path d="M7 17L17 7M9 7h8v8"/>',
    edit: '<path d="M4 20h4L20 8l-4-4L4 16z"/>',
    scroll: '<path d="M6 4h11a3 3 0 0 1 0 6h-1v8a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2z"/><path d="M8 9h5M8 13h5"/>',
    book: '<path d="M4 5a2 2 0 0 1 2-2h14v16H6a2 2 0 0 0-2 2z"/><path d="M4 21V5M8 7h8"/>',
    sword: '<path d="M14 4h6v6L9 21l-2-2-2 2-2-2 2-2-2-2z"/><path d="M13 11l-6 6"/>',
    arena: '<path d="M3 20h18M5 20V10l7-5 7 5v10"/><path d="M10 20v-5h4v5"/>',
    chart: '<path d="M4 20V4M4 20h16"/><path d="M8 16v-4M12 16V8M16 16v-6"/>',
    key: '<circle cx="8" cy="15" r="4"/><path d="M11 12l9-9M16 7l3 3"/>'
  };
  Kit.icon = function (name, cls) {
    return '<svg class="ico' + (cls ? ' ' + cls : '') + '" viewBox="0 0 24 24" aria-hidden="true">' + (ICONS[name] || '') + '</svg>';
  };

  // ---------------------------------------------------------------- events
  var listeners = {};
  Kit.on = function (evt, fn) { (listeners[evt] = listeners[evt] || []).push(fn); return function () { Kit.off(evt, fn); }; };
  Kit.off = function (evt, fn) { var l = listeners[evt] || []; var i = l.indexOf(fn); if (i >= 0) l.splice(i, 1); };
  Kit.emit = function (evt, data) {
    (listeners[evt] || []).slice().forEach(function (fn) {
      try { fn(data); } catch (e) { console.error('[Kit] listener for ' + evt + ' failed', e); }
    });
  };

  // ---------------------------------------------------------------- store
  var STORE_WARN = 4.5e6;
  var lastStoreWarn = 0;
  function warnStorage(projected) {
    var t = Date.now();
    if (t - lastStoreWarn < 30000) return;
    lastStoreWarn = t;
    if (Kit.ui && Kit.ui.toast) Kit.ui.toast('Browser storage is nearly full (' + U.fmtSize(projected) + '). Export your bundle to keep your work safe.', 'warn', 7000);
  }
  Kit.store = {
    get: function (key, fallback) {
      try { var v = localStorage.getItem(key); return v == null ? fallback : JSON.parse(v); } catch (e) { return fallback; }
    },
    set: function (key, value) {
      var s;
      try { s = JSON.stringify(value); } catch (e) { return false; }
      try {
        var old = localStorage.getItem(key);
        var projected = Kit.store.usage() - (old != null ? old.length + key.length : 0) + s.length + key.length;
        if (projected > STORE_WARN) warnStorage(projected);
      } catch (e) {}
      try { localStorage.setItem(key, s); return true; } catch (e) {
        if (Kit.ui && Kit.ui.toast) Kit.ui.toast('Could not save to browser storage. Export your bundle now to keep your work.', 'error', 8000);
        return false;
      }
    },
    del: function (key) { try { localStorage.removeItem(key); return true; } catch (e) { return false; } },
    usage: function () {
      var n = 0;
      try {
        for (var i = 0; i < localStorage.length; i++) {
          var k = localStorage.key(i); var v = localStorage.getItem(k) || '';
          n += k.length + v.length;
        }
      } catch (e) {}
      return n;
    },
    keys: function (prefix) {
      var out = [];
      try { for (var i = 0; i < localStorage.length; i++) { var k = localStorage.key(i); if (!prefix || k.indexOf(prefix) === 0) out.push(k); } } catch (e) {}
      return out;
    },
    LIMIT_WARN: STORE_WARN
  };

  // UI state (kit:ui)
  Kit.uiState = {
    get: function () { var s = Kit.store.get('kit:ui', {}); return U.isObj(s) ? s : {}; },
    set: function (patch) { var s = Kit.uiState.get(); Object.keys(patch).forEach(function (k) { s[k] = patch[k]; }); Kit.store.set('kit:ui', s); return s; }
  };

  // ---------------------------------------------------------------- settings
  var SETTINGS_KEY = 'kit:settings';
  var TIERS = ['haiku', 'sonnet', 'opus', 'fable'];
  var settingsCache = null;
  Kit.settings = {
    TIERS: TIERS,
    get: function () {
      if (!settingsCache) {
        var s = Kit.store.get(SETTINGS_KEY, {});
        if (!U.isObj(s)) s = {};
        var tiers = U.isObj(s.tiers) ? s.tiers : {};
        settingsCache = { key: '', session: typeof s.session === 'string' ? s.session : '', tiers: {} };
        TIERS.forEach(function (t) { settingsCache.tiers[t] = typeof tiers[t] === 'string' ? tiers[t] : ''; });
      }
      return settingsCache;
    },
    set: function (patch) {
      var s = Kit.settings.get();
      if (patch.session !== undefined) s.session = String(patch.session).trim();
      if (U.isObj(patch.tiers)) TIERS.forEach(function (t) { if (patch.tiers[t] !== undefined) s.tiers[t] = String(patch.tiers[t]).trim(); });
      Kit.store.set(SETTINGS_KEY, s);
      Kit.emit('settings', s);
      return s;
    },
    hasKey: function () { return !!(window.AppKeys && window.AppKeys.has()); },
    open: function () { openSettings(); }
  };

  // ---------------------------------------------------------------- models
  var MODEL_FALLBACK = { haiku: 'claude-haiku-4-5-20251001', sonnet: 'claude-sonnet-5-5', opus: 'claude-opus-5-5', fable: 'claude-fable-5-1' };
  var configPromise = null;
  function loadConfig() {
    if (!configPromise) {
      configPromise = (async function () {
        var urls = ['../config.json', 'https://augustineiacopelli.github.io/appaday/config.json'];
        for (var i = 0; i < urls.length; i++) {
          try {
            var r = await fetch(urls[i], { cache: 'no-cache' });
            if (!r.ok) continue;
            var c = await r.json();
            if (c && c.models) return c;
          } catch (e) { /* try next */ }
        }
        return null;
      })();
    }
    return configPromise;
  }
  // Standard AppADay getModel(tier): Settings override, then ../config.json, then fallback.
  async function getModel(tier) {
    tier = tier || 'sonnet';
    var override = Kit.settings.get().tiers[tier];
    if (override) return override;
    try { var c = await loadConfig(); if (c && c.models && c.models[tier]) return c.models[tier]; } catch (e) {}
    return MODEL_FALLBACK[tier] || MODEL_FALLBACK.sonnet;
  }
  Kit.getModel = getModel;

  // ---------------------------------------------------------------- claude
  var API_URL = 'https://api.anthropic.com/v1/messages';
  var NO_KEY_MSG = 'Add your Claude API key in Settings to use AI features.';

  function firstBalanced(text) {
    var start = -1;
    for (var i = 0; i < text.length; i++) { if (text[i] === '{' || text[i] === '[') { start = i; break; } }
    if (start < 0) return null;
    var depth = 0, inStr = false, esc = false;
    for (var j = start; j < text.length; j++) {
      var c = text[j];
      if (inStr) {
        if (esc) esc = false; else if (c === '\\') esc = true; else if (c === '"') inStr = false;
        continue;
      }
      if (c === '"') inStr = true;
      else if (c === '{' || c === '[') depth++;
      else if (c === '}' || c === ']') { depth--; if (depth === 0) return text.slice(start, j + 1); }
    }
    return null;
  }
  function extractJson(text) {
    if (!text || !String(text).trim()) return { ok: false, error: 'empty reply' };
    text = String(text);
    var cands = [], lastErr = 'no JSON found';
    var fence = /```(?:json)?\s*([\s\S]*?)```/i.exec(text);
    if (fence) cands.push(fence[1]);
    var bal = firstBalanced(text);
    if (bal) cands.push(bal);
    cands.push(text);
    for (var i = 0; i < cands.length; i++) {
      try { return { ok: true, value: JSON.parse(cands[i].trim()) }; } catch (e) { lastErr = e.message; }
    }
    return { ok: false, error: lastErr };
  }

  async function callApi(key, body) {
    var res, data = null;
    try {
      res = await fetch(API_URL, {
        method: 'POST',
        headers: {
          'content-type': 'application/json',
          'x-api-key': key,
          'anthropic-version': '2023-06-01',
          'anthropic-dangerous-direct-browser-access': 'true'
        },
        body: JSON.stringify(body)
      });
    } catch (e) {
      throw new Error('Could not reach the Claude API (' + e.message + ').');
    }
    try { data = await res.json(); } catch (e) { data = null; }
    if (!res.ok) {
      var m = data && data.error && data.error.message ? data.error.message : 'HTTP ' + res.status;
      var err = new Error('Claude API error: ' + m);
      err.status = res.status;
      throw err;
    }
    var blocks = (data && data.content) || [];
    var text = blocks.filter(function (b) { return b && b.type === 'text'; }).map(function (b) { return b.text; }).join('');
    if (!text.trim()) {
      console.warn('[Kit.claude] Empty reply.', { blockTypes: blocks.map(function (b) { return b && b.type; }), stop_reason: data && data.stop_reason });
      throw new Error('Claude returned an empty reply (stop_reason: ' + (data && data.stop_reason) + ').');
    }
    return { text: text, data: data };
  }

  // Some models reject thinking {type:'disabled'} and ask for {type:'between_tools'} instead. The first rejection is
  // detected from the API message, the request is retried once with the other mode, and the choice is remembered per model.
  var THINK_MODE = {};
  async function callApiThinking(key, body) {
    try {
      return await callApi(key, body);
    } catch (e) {
      var msg = String(e && e.message || '');
      if (e && e.status === 400 && msg.indexOf('between_tools') >= 0 && body.thinking && body.thinking.type !== 'between_tools') {
        THINK_MODE[body.model] = 'between_tools';
        body.thinking = { type: 'between_tools' };
        return await callApi(key, body);
      }
      throw e;
    }
  }

  Kit.claude = async function (opts) {
    opts = opts || {};
    var key = null;
    if (window.AppKeys) key = (opts.silent && !window.AppKeys.has()) ? null : await window.AppKeys.get();
    if (!key) {
      var nk = new Error(NO_KEY_MSG); nk.code = 'NO_KEY';
      if (!opts.silent) Kit.ui.toast(NO_KEY_MSG, 'warn');
      throw nk;
    }
    try {
      var model = await getModel(opts.tier || 'sonnet');
      var messages = (opts.messages || []).slice();
      var body = { model: model, max_tokens: opts.maxTokens || 1024, messages: messages, thinking: { type: THINK_MODE[model] || 'disabled' } };
      if (opts.system) body.system = opts.system;
      var reply = await callApiThinking(key, body);
      if (!opts.expectJson) return { text: reply.text, json: null, model: model, response: reply.data };
      var parsed = extractJson(reply.text);
      if (!parsed.ok) {
        body.messages = messages.concat([
          { role: 'assistant', content: reply.text },
          { role: 'user', content: 'Your previous reply could not be parsed as JSON (' + parsed.error + '). Reply again with only the corrected, complete, valid JSON and nothing else.' }
        ]);
        reply = await callApiThinking(key, body);
        parsed = extractJson(reply.text);
        if (!parsed.ok) throw new Error('Claude returned JSON that could not be parsed, even after one repair attempt.');
      }
      return { text: reply.text, json: parsed.value, model: model, response: reply.data };
    } catch (e) {
      if (!opts.silent) Kit.ui.toast(e.message, 'error', 7000);
      throw e;
    }
  };
  Kit.claude.extractJson = extractJson;
  Kit.claude.NO_KEY_MSG = NO_KEY_MSG;

  // ---------------------------------------------------------------- codex (prefix table + types)
  var PREFIXES = {};
  function defPrefixes(ns, forge, list, module) {
    list.split(' ').forEach(function (p) { PREFIXES[p + '_'] = { prefix: p + '_', ns: ns, forge: forge, module: module || null }; });
  }
  defPrefixes('rules', 146, 'chr abl itm eqp sta frm fam enm gmb trp shp wth lim eps');
  defPrefixes('rules', 146, 'mat', 'materia');
  defPrefixes('rules', 146, 'job', 'jobs');
  defPrefixes('rules', 146, 'cls', 'classes');
  defPrefixes('rules', 146, 'rmr sdq bst', 'living');
  defPrefixes('charter', 146, 'chp');
  defPrefixes('art', 147, 'spr por anm sfx ico mus');
  defPrefixes('world', 148, 'map reg npc twn dgn');
  defPrefixes('story', 149, 'flg qst dlg evt end');
  var ID_RE = /^[a-z]{3}_[a-z0-9_]*[a-z0-9]$/;

  function normPrefix(p) {
    if (!p) return null;
    p = String(p).toLowerCase();
    if (p.length === 3) p += '_';
    return p;
  }
  function prefixOf(id) {
    var m = typeof id === 'string' && /^([a-z]{3})_/.exec(id);
    return m ? m[1] + '_' : null;
  }
  var typeRegistry = {};
  function mergedTypes(bundle) {
    var out = {};
    Object.keys(typeRegistry).forEach(function (k) { out[k] = typeRegistry[k]; });
    var bt = bundle && bundle.codex && U.isObj(bundle.codex.types) ? bundle.codex.types : {};
    Object.keys(bt).forEach(function (k) { if (U.isObj(bt[k])) out[k] = bt[k]; });
    return out;
  }
  Kit.codex = {
    PREFIXES: PREFIXES,
    ID_RE: ID_RE,
    normPrefix: normPrefix,
    prefixInfo: function (p) { return PREFIXES[normPrefix(p)] || null; },
    nsOf: function (p) { var i = PREFIXES[normPrefix(p)]; return i ? i.ns : null; },
    ownerOf: function (p) { var i = PREFIXES[normPrefix(p)]; return i ? i.forge : null; },
    isOpened: function (ns, bundle) {
      bundle = bundle || current;
      return !!(bundle && bundle.kit && Array.isArray(bundle.kit.opened) && bundle.kit.opened.indexOf(ns) >= 0);
    },
    // Runtime registration (not persisted). def = {name, prefix, label, fields:[descriptors], dependsOn:[paths], module}
    register: function (def) {
      if (!def || !def.name || !Array.isArray(def.fields)) throw new Error('Kit.codex.register needs {name, prefix, fields}.');
      var p = normPrefix(def.prefix);
      if (p && !PREFIXES[p]) PREFIXES[p] = { prefix: p, ns: def.ns || 'rules', forge: def.forge || 146, module: def.module || null };
      def.prefix = p;
      typeRegistry[def.name] = def;
      Kit.index.invalidate();
      return def;
    },
    unregister: function (name) { delete typeRegistry[name]; Kit.index.invalidate(); },
    types: function (bundle) { return mergedTypes(bundle || current); },
    type: function (name, bundle) { return mergedTypes(bundle || current)[name] || null; },
    typeFor: function (prefix, bundle) {
      bundle = bundle || current;
      var p = normPrefix(prefix);
      var cp = bundle && bundle.codex && bundle.codex.prefixes && bundle.codex.prefixes[p];
      if (typeof cp === 'string') return cp;
      if (U.isObj(cp) && cp.type) return cp.type;
      var all = mergedTypes(bundle), names = Object.keys(all);
      for (var i = 0; i < names.length; i++) { if (normPrefix(all[names[i]].prefix) === p) return names[i]; }
      return null;
    },
    fields: function (typeName, bundle) {
      var t = mergedTypes(bundle || current)[typeName];
      return t && Array.isArray(t.fields) ? t.fields : [];
    },
    // P7 (Pass 3): derived field functions, keyed by desc.derived. fn(record, bundle, path) -> value.
    derive: {}
  };

  // ---------------------------------------------------------------- bundle
  var SCHEMA_VERSION = 1;
  var DRAFT_KEY = 'kit:draft', SLOTS_KEY = 'kit:slots', SUSPEND_KEY = 'kit:suspend';
  var SLOT_COUNT = 4;
  var current = null;
  var changeCounter = 0;

  function emptyBundle(title) {
    var t = U.now();
    return {
      kit: {
        format: 'saga-bundle', schemaVersion: SCHEMA_VERSION, bundleId: 'bnd_' + U.rand36(12),
        title: title || 'Untitled Saga', createdAt: t, updatedAt: t, contentHash: '',
        opened: [], forges: { '146': { status: 'draft', exportedAt: null, charterVersion: 0 } }
      },
      charter: { version: 0, locked: false, lockedAt: null, sections: {}, specs: {}, quotas: {}, canon: [], glossary: [], ruleset: {}, amendments: [] },
      codex: { version: 0, generatedFromCharter: null, prefixes: {}, types: {}, modules: [] },
      rules: {}, art: {}, world: {}, story: {}
    };
  }
  function fillDefaults(target, base) {
    Object.keys(base).forEach(function (k) {
      if (target[k] === undefined) {
        target[k] = U.clone(base[k]);
      } else if (U.isObj(base[k]) && U.isObj(target[k]) && k !== 'types' && k !== 'rules') {
        fillDefaults(target[k], base[k]);
      }
    });
  }
  function migrate(b) {
    if (!U.isObj(b) || !U.isObj(b.kit) || b.kit.format !== 'saga-bundle') throw new Error('This file is not a Saga Forge bundle.');
    var v = Number(b.kit.schemaVersion) || 0;
    if (v > SCHEMA_VERSION) throw new Error('This bundle uses schema version ' + v + ', which is newer than this Forge supports.');
    var base = emptyBundle(b.kit.title);
    ['kit', 'charter', 'codex'].forEach(function (k) { if (!U.isObj(b[k])) b[k] = {}; });
    fillDefaults(b, base);
    if (!Array.isArray(b.kit.opened)) b.kit.opened = [];
    if (!U.isObj(b.kit.forges)) b.kit.forges = {};
    if (!U.isObj(b.kit.forges['146'])) b.kit.forges['146'] = { status: 'draft', exportedAt: null, charterVersion: 0 };
    ['rules', 'art', 'world', 'story'].forEach(function (k) { if (!U.isObj(b[k])) b[k] = {}; });
    b.kit.schemaVersion = SCHEMA_VERSION;
    return b;
  }
  function persistDraft() {
    if (!current) return false;
    return Kit.store.set(DRAFT_KEY, current);
  }
  var autosave = U.debounce(persistDraft, 800);
  function setCurrent(b) {
    autosave.cancel();
    current = b;
    changeCounter++;
    persistDraft();
    Kit.emit('load', b);
    Kit.emit('change', { reason: 'load' });
  }
  function hashOf(b) {
    if (!b) return '';
    var copy = {};
    Object.keys(b).forEach(function (k) { copy[k] = b[k]; });
    if (U.isObj(b.kit)) {
      copy.kit = {};
      Object.keys(b.kit).forEach(function (k) { if (k !== 'contentHash') copy.kit[k] = b.kit[k]; });
    }
    return U.sha256(U.canonical(copy));
  }
  function slotsRaw() {
    var arr = Kit.store.get(SLOTS_KEY, []);
    if (!Array.isArray(arr)) arr = [];
    for (var i = 0; i < SLOT_COUNT; i++) if (arr[i] === undefined) arr[i] = null;
    return arr.slice(0, SLOT_COUNT);
  }
  function titleSlug(b) { return U.slug((b && b.kit && b.kit.title) || 'saga') || 'saga'; }

  Kit.bundle = {
    SCHEMA_VERSION: SCHEMA_VERSION,
    SLOT_COUNT: SLOT_COUNT,
    create: function (title) { var b = emptyBundle(title); setCurrent(b); return b; },
    blank: function (title) { return emptyBundle(title); },
    load: function (b) { migrate(b); setCurrent(b); return b; },
    current: function () { return current; },
    touch: function (reason) {
      if (!current) return;
      current.kit.updatedAt = U.now();
      changeCounter++;
      autosave();
      Kit.emit('change', { reason: reason || 'edit' });
    },
    hash: function (b) { return hashOf(b || current); },
    migrate: migrate,
    slug: function (b) { return titleSlug(b || current); },
    save: function () { autosave.cancel(); return persistDraft(); },
    flush: function () { if (autosave.pending()) autosave.flush(); },
    dirty: function () { return autosave.pending(); },
    open: function (ns) {
      if (!current || !ns) return;
      if (current.kit.opened.indexOf(ns) < 0) { current.kit.opened.push(ns); Kit.bundle.touch('open:' + ns); }
    },
    close: function (ns) {
      if (!current) return;
      var i = current.kit.opened.indexOf(ns);
      if (i >= 0) { current.kit.opened.splice(i, 1); Kit.bundle.touch('close:' + ns); }
    },
    restoreDraft: function () {
      var b = Kit.store.get(DRAFT_KEY, null);
      if (!b) return null;
      try { migrate(b); } catch (e) { console.warn('[Kit] Draft could not be restored', e); return null; }
      current = b; changeCounter++;
      Kit.emit('load', b); Kit.emit('change', { reason: 'restore' });
      return b;
    },
    // opts: {status:'draft'|'final', download:true}
    exportFile: function (opts) {
      opts = opts || {};
      if (!current) throw new Error('No project is open.');
      if (opts.status) {
        var f = current.kit.forges['146'] = current.kit.forges['146'] || {};
        f.status = opts.status;
        f.exportedAt = U.now();
        f.charterVersion = current.charter.version || 0;
      }
      current.kit.contentHash = hashOf(current);
      autosave.cancel(); persistDraft();
      changeCounter++;
      var text = JSON.stringify(current, null, 2);
      var name = titleSlug(current) + '-bundle.json';
      if (opts.download !== false) U.download(name, text, 'application/json');
      return { filename: name, text: text, hash: current.kit.contentHash };
    },
    importText: function (text) {
      var b;
      try { b = JSON.parse(text); } catch (e) { throw new Error('That file is not valid JSON.'); }
      migrate(b);
      var h = hashOf(b);
      var matches = !b.kit.contentHash || b.kit.contentHash === h;
      setCurrent(b);
      return { bundle: b, hash: h, storedHash: b.kit.contentHash || '', matches: matches };
    },
    importFile: function (file) { return U.readFile(file).then(function (text) { return Kit.bundle.importText(text); }); },
    slots: {
      list: function () {
        return slotsRaw().map(function (s, i) {
          return s ? { index: i, name: s.name, title: s.title, savedAt: s.savedAt, hash: s.hash, size: JSON.stringify(s.bundle || {}).length } : null;
        });
      },
      save: function (i, name) {
        if (!current) return false;
        if (i < 0 || i >= SLOT_COUNT) throw new Error('Slot index out of range.');
        Kit.bundle.flush();
        var arr = slotsRaw(), b = U.clone(current);
        arr[i] = { name: name || current.kit.title, title: current.kit.title, savedAt: U.now(), hash: hashOf(b), bundle: b };
        var ok = Kit.store.set(SLOTS_KEY, arr);
        if (ok) Kit.emit('slots', Kit.bundle.slots.list());
        return ok;
      },
      load: function (i) {
        var s = slotsRaw()[i];
        if (!s || !s.bundle) throw new Error('That slot is empty.');
        var b = U.clone(s.bundle);
        migrate(b);
        setCurrent(b);
        return b;
      },
      delete: function (i) {
        var arr = slotsRaw();
        arr[i] = null;
        var ok = Kit.store.set(SLOTS_KEY, arr);
        if (ok) Kit.emit('slots', Kit.bundle.slots.list());
        return ok;
      }
    },
    // Suspend: flushes the draft and records where the author was, restored on next boot.
    suspend: {
      save: function (extra) {
        if (!current) return false;
        Kit.bundle.flush();
        return Kit.store.set(SUSPEND_KEY, { at: U.now(), bundleId: current.kit.bundleId, hash: hashOf(current), workspace: Kit.active(), extra: extra || null });
      },
      load: function () { return Kit.store.get(SUSPEND_KEY, null); },
      clear: function () { return Kit.store.del(SUSPEND_KEY); }
    }
  };

  // ---------------------------------------------------------------- index + records
  var indexCache = { bundle: null, counter: -1, value: null };
  function buildIndex(b) {
    var byId = {}, byPrefix = {}, dupes = [];
    function visit(node, path, depth) {
      if (depth > 14 || node === null || typeof node !== 'object') return;
      if (Array.isArray(node)) { for (var i = 0; i < node.length; i++) visit(node[i], path + '[' + i + ']', depth + 1); return; }
      if (typeof node.id === 'string' && ID_RE.test(node.id) && PREFIXES[prefixOf(node.id)]) {
        var p = prefixOf(node.id);
        if (byId[node.id]) dupes.push({ id: node.id, path: path });
        else {
          var e = { id: node.id, prefix: p, name: String(node.name || node.title || node.term || node.id), path: path, record: node };
          byId[node.id] = e;
          (byPrefix[p] = byPrefix[p] || []).push(e);
        }
      }
      Object.keys(node).forEach(function (k) { visit(node[k], path ? path + '.' + k : k, depth + 1); });
    }
    ['charter', 'rules', 'art', 'world', 'story'].forEach(function (k) { if (b) visit(b[k], k, 0); });
    return { byId: byId, byPrefix: byPrefix, dupes: dupes };
  }
  Kit.index = function (bundle) {
    bundle = bundle || current;
    if (bundle !== current) return buildIndex(bundle);
    if (indexCache.bundle === bundle && indexCache.counter === changeCounter) return indexCache.value;
    indexCache = { bundle: bundle, counter: changeCounter, value: buildIndex(bundle) };
    return indexCache.value;
  };
  Kit.index.invalidate = function () { changeCounter++; };

  Kit.records = {
    list: function (prefix) { return (Kit.index().byPrefix[normPrefix(prefix)] || []).map(function (e) { return e.record; }); },
    get: function (id) { var e = Kit.index().byId[id]; return e ? e.record : null; },
    // Stores rules-namespace records at bundle.rules[prefix][id]. Other namespaces own their own storage.
    put: function (rec) {
      var p = prefixOf(rec && rec.id), info = PREFIXES[p];
      if (!info) throw new Error('Record has no valid ID prefix.');
      if (info.ns !== 'rules') throw new Error('Kit.records.put stores rules records only; ' + p + ' belongs to ' + info.ns + '.');
      current.rules[p] = current.rules[p] || {};
      current.rules[p][rec.id] = rec;
      Kit.index.invalidate();
      return rec;
    },
    del: function (id) {
      var p = prefixOf(id);
      if (p && current.rules[p] && current.rules[p][id]) {
        delete current.rules[p][id];
        if (!Object.keys(current.rules[p]).length) delete current.rules[p];
        Kit.index.invalidate();
        return true;
      }
      return false;
    }
  };

  // ---------------------------------------------------------------- ids
  var mintedThisSession = {};
  Kit.ids = {
    RE: ID_RE,
    prefixOf: prefixOf,
    isValid: function (id) { return typeof id === 'string' && ID_RE.test(id) && !!PREFIXES[prefixOf(id)]; },
    all: function () { return Object.keys(Kit.index().byId); },
    // IDs are permanent. There is deliberately no rename API; display names change freely.
    mint: function (prefix, name) {
      var p = normPrefix(prefix);
      if (!p || !PREFIXES[p]) throw new Error('Unknown ID prefix: ' + prefix);
      var slug = U.slug(name, '_').slice(0, 24).replace(/_+$/, '') || 'item';
      var taken = Kit.index().byId;
      for (var i = 0; i < 2000; i++) {
        var id = p + slug + '_' + U.rand36(4);
        if (!taken[id] && !mintedThisSession[id]) { mintedThisSession[id] = 1; return id; }
      }
      throw new Error('Could not mint a unique ID.');
    }
  };

  // ---------------------------------------------------------------- validation
  var validators = {};
  var BUCKET = { error: 'errors', broken: 'broken', forward: 'forward', warning: 'warnings' };
  function makeResult() { return { errors: [], broken: [], forward: [], warnings: [], byRecord: {} }; }
  function addItem(res, item) {
    item.level = BUCKET[item.level] ? item.level : 'error';
    res[BUCKET[item.level]].push(item);
    (res.byRecord[item.recordId] = res.byRecord[item.recordId] || []).push(item);
  }
  function vocabEntries(desc, bundle) {
    var src = null;
    if (Array.isArray(desc.values)) src = desc.values;
    else if (desc.enumFrom) src = U.getPath(bundle, desc.enumFrom);
    else return null;
    if (U.isObj(src) && Array.isArray(src.values)) src = src.values;
    if (!Array.isArray(src)) return [];
    return src.map(function (v) {
      if (U.isObj(v)) {
        var val = v.key != null ? v.key : v.id != null ? v.id : v.value;
        return { value: String(val), label: String(v.label || v.name || val) };
      }
      return { value: String(v), label: String(v) };
    }).filter(function (v) { return v.value !== 'undefined'; });
  }
  Kit.vocab = function (desc, bundle) { return vocabEntries(desc, bundle || current); };

  function checkRecord(bundle, idx, typeName, record, res, opts) {
    opts = opts || {};
    var rid = record.id || opts.draftId || '(draft)';
    var fields = Kit.codex.fields(typeName, bundle);
    var hasName = !!(Kit.codex.type(typeName, bundle) || {}).section || fields.some(function (f) { return f.key === 'name'; });
    if (!hasName && !String(record.name || '').trim()) addItem(res, { recordId: rid, fieldPath: 'name', message: 'Name is required.', level: 'error' });
    var typePrefix = normPrefix((Kit.codex.type(typeName, bundle) || {}).prefix);
    if (record.id && typePrefix && prefixOf(record.id) !== typePrefix) {
      addItem(res, { recordId: rid, fieldPath: 'id', message: 'ID prefix does not match type ' + typeName + '.', level: 'error' });
    }
    function err(path, msg, level, extra) {
      var it = { recordId: rid, fieldPath: path, message: msg, level: level || 'error' };
      if (extra) Object.keys(extra).forEach(function (k) { it[k] = extra[k]; });
      addItem(res, it);
    }
    function checkRef(desc, value, path, label) {
      if (typeof value !== 'string' || !ID_RE.test(value)) { err(path, label + ': "' + value + '" is not a valid ID.'); return; }
      var p = prefixOf(value), info = PREFIXES[p];
      if (!info) { err(path, label + ': unknown prefix ' + p + '.'); return; }
      if (desc.refPrefix) {
        var allowed = [].concat(desc.refPrefix).map(normPrefix);
        if (allowed.indexOf(p) < 0) { err(path, label + ' must reference ' + allowed.join(' or ') + ' records, not ' + p + '.'); return; }
      }
      var opened = Kit.codex.isOpened(info.ns, bundle);
      if (!opened) {
        if (opts.draft) err(path, label + ': forward ID ' + value + ' was not supplied in context. Leave it empty until forge ' + info.forge + ' provides it.', 'warning', { id: value });
        else err(path, 'Forward reference ' + value + ' is owed by forge ' + info.forge + '.', 'forward', { id: value, owedBy: info.forge });
      } else if (!idx.byId[value]) {
        err(path, (opts.draft ? 'Unknown reference: ' : 'Broken reference: ') + value + ' does not exist.', 'broken', { id: value });
      }
    }
    function checkField(desc, value, path) {
      if (desc.derived) return; // P7 (Pass 3): derived fields are computed, never validated.
      var label = desc.label || desc.key;
      var empty = value === undefined || value === null || value === '' || (Array.isArray(value) && !value.length) || (desc.type === 'object' || desc.type === 'table') && U.isObj(value) && !Object.keys(value).length;
      if (empty) { if (desc.required) err(path, label + ' is required.'); return; }
      switch (desc.type) {
        case 'text': case 'longtext': case 'formula':
          if (typeof value !== 'string') { err(path, label + ' must be text.'); break; }
          if (desc.max != null && value.length > desc.max) err(path, label + ' is longer than ' + desc.max + ' characters.');
          if (desc.type === 'formula' && Kit.expr && typeof Kit.expr.parse === 'function') {
            try { Kit.expr.parse(value); } catch (e) { err(path, label + ': ' + e.message); }
          }
          break;
        case 'int': case 'num':
          if (typeof value !== 'number' || !isFinite(value)) { err(path, label + ' must be a number.'); break; }
          if (desc.type === 'int' && Math.floor(value) !== value) err(path, label + ' must be a whole number.');
          if (desc.min != null && value < desc.min) err(path, label + ' must be at least ' + desc.min + '.');
          if (desc.max != null && value > desc.max) err(path, label + ' must be at most ' + desc.max + '.');
          break;
        case 'bool':
          if (typeof value !== 'boolean') err(path, label + ' must be true or false.');
          break;
        case 'enum': {
          var v = vocabEntries(desc, bundle) || [];
          if (!v.some(function (e) { return e.value === String(value); })) {
            err(path, label + ': "' + value + '" is not in the declared vocabulary' + (desc.enumFrom ? ' (' + desc.enumFrom + ')' : '') + '.');
          }
          break;
        }
        case 'color':
          if (typeof value !== 'string' || !/^#[0-9a-fA-F]{6}$/.test(value)) err(path, label + ' must be a hex color like #a1b2c3.');
          break;
        case 'ref':
          checkRef(desc, value, path, label);
          break;
        case 'refList':
          if (!Array.isArray(value)) { err(path, label + ' must be a list of references.'); break; }
          value.forEach(function (x, i) { if (x != null && x !== '') checkRef(desc, x, path + '[' + i + ']', label); });
          if (desc.min != null && value.length < desc.min) err(path, label + ' needs at least ' + desc.min + ' entries.');
          if (desc.max != null && value.length > desc.max) err(path, label + ' allows at most ' + desc.max + ' entries.');
          break;
        case 'list':
          if (!Array.isArray(value)) { err(path, label + ' must be a list.'); break; }
          if (desc.min != null && value.length < desc.min) err(path, label + ' needs at least ' + desc.min + ' entries.');
          if (desc.max != null && value.length > desc.max) err(path, label + ' allows at most ' + desc.max + ' entries.');
          value.forEach(function (item, i) {
            var ip = path + '[' + i + ']';
            if (Array.isArray(desc.of)) {
              if (!U.isObj(item)) { err(ip, label + ' entry ' + (i + 1) + ' must be an object.'); return; }
              checkFields(desc.of, item, ip);
            } else if (desc.of) {
              checkField(Object.assign({ label: label + ' ' + (i + 1) }, desc.of), item, ip);
            }
          });
          break;
        case 'object':
          if (!U.isObj(value)) { err(path, label + ' must be an object.'); break; }
          if (Array.isArray(desc.of)) checkFields(desc.of, value, path);
          break;
        case 'table': {
          if (!U.isObj(value)) { err(path, label + ' must be a table.'); break; }
          var rows = desc.rows ? vocabEntries({ values: desc.rows }, bundle) : desc.rowsFrom ? vocabEntries({ enumFrom: desc.rowsFrom }, bundle) : null;
          var cellDesc = { type: desc.cell || 'num', min: desc.min, max: desc.max, values: desc.cellValues, enumFrom: desc.cellEnumFrom };
          Object.keys(value).forEach(function (rk) {
            var rp = path + '.' + rk;
            if (rows && !rows.some(function (r) { return r.value === rk; })) err(rp, label + ': row "' + rk + '" is not in the declared vocabulary' + (desc.rowsFrom ? ' (' + desc.rowsFrom + ')' : '') + '.');
            var cell = value[rk];
            if (Array.isArray(desc.columns)) {
              if (!U.isObj(cell)) { err(rp, label + ': row "' + rk + '" must hold column values.'); return; }
              desc.columns.forEach(function (c) {
                if (cell[c.key] !== undefined) checkField(Object.assign({}, cellDesc, c, { label: label + ' ' + rk + '/' + (c.label || c.key) }), cell[c.key], rp + '.' + c.key);
              });
            } else {
              checkField(Object.assign({}, cellDesc, { label: label + ' ' + rk }), cell, rp);
            }
          });
          break;
        }
        default:
          break;
      }
    }
    function checkFields(fields, obj, base) {
      fields.forEach(function (f) {
        if (!f || !f.key) return;
        checkField(f, obj[f.key], base ? base + '.' + f.key : f.key);
      });
    }
    checkFields(fields, record, '');
  }

  Kit.validate = function (bundle) {
    bundle = bundle || current;
    var res = makeResult();
    if (!bundle) return res;
    var idx = Kit.index(bundle);
    idx.dupes.forEach(function (d) { addItem(res, { recordId: d.id, fieldPath: 'id', message: 'Duplicate ID also found at ' + d.path + '.', level: 'error' }); });
    Object.keys(idx.byId).forEach(function (id) {
      var e = idx.byId[id];
      var tn = Kit.codex.typeFor(e.prefix, bundle);
      if (tn) checkRecord(bundle, idx, tn, e.record, res, {});
    });
    Object.keys(validators).forEach(function (name) {
      try {
        var out = validators[name](bundle, { index: idx, add: function (it) { addItem(res, it); } });
        if (Array.isArray(out)) out.forEach(function (it) { addItem(res, it); });
      } catch (e) {
        addItem(res, { recordId: '(validator)', fieldPath: name, message: 'Validator "' + name + '" failed: ' + e.message, level: 'warning' });
      }
    });
    if (bundle === current) Kit.validate.last = res;
    return res;
  };
  Kit.validate.last = null;
  Kit.validate.register = function (name, fn) { validators[name] = fn; Kit.index.invalidate(); };
  Kit.validate.unregister = function (name) { delete validators[name]; Kit.index.invalidate(); };
  Kit.validate.list = function () { return Object.keys(validators); };
  // Validate a single record (bundle record or unsaved draft). Returns a flat array of items.
  Kit.validate.record = function (typeName, record, opts) {
    opts = opts || {};
    var bundle = opts.bundle || current;
    var res = makeResult();
    checkRecord(bundle, Kit.index(bundle), typeName, record, res, opts);
    return res.errors.concat(res.broken, res.warnings, res.forward);
  };
  Kit.validate.summary = function (res) {
    res = res || Kit.validate.last || makeResult();
    return { errors: res.errors.length, broken: res.broken.length, forward: res.forward.length, warnings: res.warnings.length };
  };

  // ---------------------------------------------------------------- ui
  var overlayStack = [];
  function overlayRoot() { return document.getElementById('overlays') || document.body; }
  function pushOverlay(ov, close) {
    var prevFocus = document.activeElement;
    var entry = { el: ov, close: close, prevFocus: prevFocus };
    overlayStack.push(entry);
    overlayRoot().appendChild(ov);
    return entry;
  }
  function popOverlay(entry) {
    var i = overlayStack.indexOf(entry);
    if (i >= 0) overlayStack.splice(i, 1);
    U.detach(entry.el);
    if (entry.prevFocus && entry.prevFocus.focus && document.contains(entry.prevFocus)) { try { entry.prevFocus.focus({ preventScroll: true }); } catch (e) {} }
  }
  function focusFirst(node) {
    var f = node.querySelector('[autofocus], input:not([type=hidden]):not([disabled]), select, textarea, .dlg-body button, .dlg-foot button');
    if (f) { try { f.focus({ preventScroll: true }); } catch (e) {} }
  }

  Kit.ui = {};
  Kit.ui.toast = function (msg, kind, ms) {
    var root = document.getElementById('toasts');
    if (!root) { console.log('[toast]', msg); return; }
    var t = U.el('div', 'toast' + (kind ? ' ' + kind : ''));
    t.textContent = msg;
    t.setAttribute('role', kind === 'error' ? 'alert' : 'status');
    root.appendChild(t);
    while (root.children.length > 4) root.removeChild(root.firstChild);
    setTimeout(function () { U.detach(t); }, ms || (kind === 'error' ? 6000 : 3200));
    t.addEventListener('click', function () { U.detach(t); });
  };

  // dialog({title, body: Node|string|fn(bodyEl, handle), actions:[{label, kind, value, onClick(handle)->false keeps open, disabled}], onResult, wide, className})
  Kit.ui.dialog = function (o) {
    o = o || {};
    var ov = U.el('div', 'overlay');
    var dlg = U.el('div', 'dialog' + (o.wide ? ' wide' : '') + (o.className ? ' ' + o.className : ''));
    dlg.setAttribute('role', 'dialog'); dlg.setAttribute('aria-modal', 'true');
    var titleId = 'dlgt_' + U.rand36(6);
    dlg.setAttribute('aria-labelledby', titleId);
    var head = U.el('div', 'dlg-head');
    var h = U.el('h2', 'dlg-title'); h.id = titleId; h.textContent = o.title || '';
    var x = U.el('button', 'btn btn-ghost btn-icon', Kit.icon('x')); x.type = 'button'; x.setAttribute('aria-label', 'Close');
    head.appendChild(h); head.appendChild(x);
    var body = U.el('div', 'dlg-body');
    var foot = U.el('div', 'dlg-foot');
    dlg.appendChild(head); dlg.appendChild(body); dlg.appendChild(foot);
    ov.appendChild(dlg);
    var done = false, entry;
    var handle = {
      el: dlg, body: body, foot: foot, head: head,
      close: function (value) {
        if (done) return; done = true;
        popOverlay(entry);
        if (o.onResult) o.onResult(value);
      },
      setActions: function (actions) {
        U.clear(foot);
        (actions || []).forEach(function (a) {
          var b = U.el('button', 'btn' + (a.kind ? ' btn-' + a.kind : ''), (a.icon ? Kit.icon(a.icon) : '') + '<span>' + U.esc(a.label) + '</span>');
          b.type = 'button';
          if (a.disabled) b.disabled = true;
          if (a.id) b.id = a.id;
          b.addEventListener('click', function () {
            if (a.onClick && a.onClick(handle) === false) return;
            handle.close(a.value);
          });
          foot.appendChild(b);
        });
        foot.style.display = (actions && actions.length) ? '' : 'none';
      }
    };
    x.addEventListener('click', function () { handle.close(undefined); });
    ov.addEventListener('mousedown', function (e) { if (e.target === ov && o.dismissable !== false) handle.close(undefined); });
    entry = pushOverlay(ov, function () { handle.close(undefined); });
    if (typeof o.body === 'function') o.body(body, handle);
    else if (o.body instanceof Node) body.appendChild(o.body);
    else if (o.body != null) body.innerHTML = o.body;
    handle.setActions(o.actions || []);
    focusFirst(dlg);
    return handle;
  };

  // Promise-based confirm that replaces window confirm dialogs.
  Kit.ui.confirm = function (o) {
    if (typeof o === 'string') o = { message: o };
    o = o || {};
    return new Promise(function (resolve) {
      Kit.ui.dialog({
        title: o.title || 'Please confirm',
        body: function (b) { var p = U.el('p'); p.textContent = o.message || 'Are you sure?'; b.appendChild(p); if (o.detail) { var d = U.el('p', 'muted'); d.textContent = o.detail; b.appendChild(d); } },
        actions: [
          { label: o.cancelLabel || 'Cancel', kind: 'ghost', value: false },
          { label: o.okLabel || 'Confirm', kind: o.danger ? 'danger solid' : 'primary', value: true }
        ],
        onResult: function (v) { resolve(v === true); }
      });
    });
  };

  Kit.ui.prompt = function (o) {
    if (typeof o === 'string') o = { label: o };
    o = o || {};
    return new Promise(function (resolve) {
      var input, msg;
      var dlg = Kit.ui.dialog({
        title: o.title || 'Enter a value',
        body: function (b) {
          var f = U.el('div', 'field');
          var lab = U.el('label', 'field-label'); lab.textContent = o.label || 'Value';
          input = U.el(o.multiline ? 'textarea' : 'input', 'inp');
          if (!o.multiline) input.type = 'text';
          input.id = 'kprompt_' + U.rand36(5); lab.htmlFor = input.id;
          input.value = o.value || ''; input.placeholder = o.placeholder || '';
          msg = U.el('div', 'field-msg');
          f.appendChild(lab); f.appendChild(input); f.appendChild(msg);
          b.appendChild(f);
          input.addEventListener('keydown', function (e) { if (e.key === 'Enter' && !o.multiline) { e.preventDefault(); submit(); } });
        },
        actions: [
          { label: 'Cancel', kind: 'ghost', value: null },
          { label: o.okLabel || 'OK', kind: 'primary', onClick: function () { submit(); return false; } }
        ],
        onResult: function (v) { resolve(v === undefined ? null : v); }
      });
      function submit() {
        var v = input.value;
        if (o.validate) {
          var problem = o.validate(v);
          if (problem) { msg.innerHTML = '<span class="msg msg-error">' + U.esc(problem) + '</span>'; input.focus(); return; }
        }
        dlg.close(v);
      }
      setTimeout(function () { try { input.focus(); input.select(); } catch (e) {} }, 0);
    });
  };

  // drawer({title, body(bodyEl, handle), actions, onClose}) -> handle {el, body, foot, close()}
  Kit.ui.drawer = function (o) {
    o = o || {};
    var ov = U.el('div', 'overlay drawer-overlay');
    var dr = U.el('aside', 'drawer');
    dr.setAttribute('role', 'dialog'); dr.setAttribute('aria-modal', 'true');
    var tid = 'drt_' + U.rand36(6); dr.setAttribute('aria-labelledby', tid);
    var head = U.el('div', 'dlg-head');
    var h = U.el('h2', 'dlg-title'); h.id = tid; h.textContent = o.title || '';
    var x = U.el('button', 'btn btn-ghost btn-icon', Kit.icon('x')); x.type = 'button'; x.setAttribute('aria-label', 'Close');
    head.appendChild(h); head.appendChild(x);
    var body = U.el('div', 'dlg-body');
    var foot = U.el('div', 'dlg-foot'); foot.style.display = 'none';
    dr.appendChild(head); dr.appendChild(body); dr.appendChild(foot);
    ov.appendChild(dr);
    var done = false, entry;
    var handle = {
      el: dr, body: body, foot: foot, titleEl: h,
      setTitle: function (t) { h.textContent = t; },
      close: function () { if (done) return; done = true; popOverlay(entry); if (o.onClose) o.onClose(); }
    };
    x.addEventListener('click', handle.close);
    ov.addEventListener('mousedown', function (e) { if (e.target === ov) handle.close(); });
    entry = pushOverlay(ov, handle.close);
    if (typeof o.body === 'function') o.body(body, handle);
    else if (o.body instanceof Node) body.appendChild(o.body);
    focusFirst(dr);
    return handle;
  };

  var busyCount = 0, busyEl = null;
  Kit.ui.busy = {
    show: function (msg) {
      busyCount++;
      if (!busyEl) {
        busyEl = U.el('div', 'busy', '<div class="busy-card" role="status"><span class="spin"></span><span class="busy-msg"></span></div>');
        document.body.appendChild(busyEl);
      }
      busyEl.querySelector('.busy-msg').textContent = msg || 'Working...';
    },
    hide: function () {
      busyCount = Math.max(0, busyCount - 1);
      if (!busyCount && busyEl) { U.detach(busyEl); busyEl = null; }
    },
    active: function () { return busyCount > 0; }
  };

  Kit.ui.closeTop = function () {
    var top = overlayStack[overlayStack.length - 1];
    if (top) { top.close(); return true; }
    return false;
  };
  Kit.ui.overlayCount = function () { return overlayStack.length; };

  Kit.ui.stub = function (o) {
    var p = U.el('section', 'panel stub');
    p.innerHTML = '<div class="stub-glyph">' + Kit.icon(o.icon || 'scroll') + '</div><h2>' + U.esc(o.title) + '</h2><p>' + U.esc(o.lead || '') + '</p>' + (o.status ? '<p class="muted">' + U.esc(o.status) + '</p>' : '');
    return p;
  };

  // Searchable reference picker. Resolves an ID, null (cleared), or undefined (cancelled).
  Kit.ui.pickRef = function (o) {
    o = o || {};
    var prefixes = o.prefix ? [].concat(o.prefix).map(normPrefix) : Object.keys(PREFIXES);
    var idx = Kit.index();
    var items = [];
    prefixes.forEach(function (p) { (idx.byPrefix[p] || []).forEach(function (e) { items.push(e); }); });
    items.sort(function (a, b) { return a.name.localeCompare(b.name); });
    var fwd = prefixes.filter(function (p) { return PREFIXES[p] && !Kit.codex.isOpened(PREFIXES[p].ns); });
    return new Promise(function (resolve) {
      var dlg = Kit.ui.dialog({
        title: o.title || 'Choose a record',
        body: function (b, h) {
          var s = U.el('input', 'inp pick-search'); s.type = 'search'; s.placeholder = 'Search by name'; s.setAttribute('aria-label', 'Search records');
          var list = U.el('div', 'pick-list');
          b.appendChild(s); b.appendChild(list);
          function paint() {
            U.clear(list);
            var q = s.value.trim().toLowerCase();
            var shown = items.filter(function (e) { return !q || e.name.toLowerCase().indexOf(q) >= 0 || e.id.indexOf(q) >= 0; }).slice(0, 200);
            if (!shown.length) list.appendChild(U.el('div', 'empty-line', items.length ? 'No matches.' : 'No ' + prefixes.join(' / ') + ' records exist yet.'));
            shown.forEach(function (e) {
              var btn = U.el('button', 'btn pick-item', '<span class="ref-name">' + U.esc(e.name) + '</span><code class="id">' + U.esc(e.id) + '</code>');
              btn.type = 'button';
              if (e.id === o.current) btn.setAttribute('aria-current', 'true');
              btn.addEventListener('click', function () { h.close(e.id); });
              list.appendChild(btn);
            });
          }
          s.addEventListener('input', paint);
          paint();
          if (fwd.length) {
            var fw = U.el('div', 'field'); fw.style.marginTop = '14px';
            fw.innerHTML = '<label class="field-label">Forward ID</label><div class="field-help">' + U.esc(fwd.join(', ')) + ' records are owed by forge ' + U.esc(fwd.map(function (p) { return PREFIXES[p].forge; }).filter(function (v, i, a) { return a.indexOf(v) === i; }).join(', ')) + '. Enter an ID to hold the slot.</div>';
            var row = U.el('div', 'ref-row');
            var fi = U.el('input', 'inp'); fi.type = 'text'; fi.placeholder = fwd[0] + 'example_ab12'; fi.setAttribute('aria-label', 'Forward ID');
            var go = U.el('button', 'btn', 'Use'); go.type = 'button';
            var fm = U.el('div', 'field-msg');
            row.appendChild(fi); row.appendChild(go); fw.appendChild(row); fw.appendChild(fm);
            go.addEventListener('click', function () {
              var v = fi.value.trim().toLowerCase();
              if (!ID_RE.test(v) || fwd.indexOf(prefixOf(v)) < 0) { fm.innerHTML = '<span class="msg msg-error">Use an ID starting with ' + U.esc(fwd.join(' or ')) + ' (lowercase letters, digits, underscores).</span>'; return; }
              h.close(v);
            });
            b.appendChild(fw);
          }
        },
        actions: [{ label: 'Clear', kind: 'ghost', value: null }, { label: 'Cancel', value: undefined }],
        onResult: function (v) { resolve(v); }
      });
      return dlg;
    });
  };

  // ---------------------------------------------------------------- form renderer
  var uid = 0;
  var FULL_TYPES = { longtext: 1, list: 1, object: 1, table: 1, refList: 1, formula: 1 };

  function refLabelHtml(v) {
    if (!v) return '<span class="ref-empty">None. Tap to choose.</span>';
    var e = Kit.index().byId[v], info = PREFIXES[prefixOf(v)], chip = '';
    if (info && !Kit.codex.isOpened(info.ns)) chip = '<span class="chip chip-forward">Forward &middot; ' + info.forge + '</span>';
    else if (!e) chip = '<span class="chip chip-broken">Broken</span>';
    return '<span class="ref-name">' + U.esc(e ? e.name : v) + '</span><code class="id">' + U.esc(v) + '</code>' + chip;
  }
  function iconBtn(icon, label, onClick, cls) {
    var b = U.el('button', 'btn btn-ghost btn-icon' + (cls ? ' ' + cls : ''), Kit.icon(icon));
    b.type = 'button'; b.setAttribute('aria-label', label); b.title = label;
    b.addEventListener('click', onClick);
    return b;
  }
  function defaultFor(desc) {
    if (!desc) return '';
    switch (desc.type) {
      case 'int': case 'num': return desc.min != null ? desc.min : 0;
      case 'bool': return false;
      case 'color': return '#888888';
      case 'ref': return null;
      case 'object': case 'table': return {};
      case 'list': case 'refList': return [];
      default: return '';
    }
  }
  function childSlot(slot, key) {
    return {
      get: function () { var o = slot.get(); return U.isObj(o) || Array.isArray(o) ? o[key] : undefined; },
      set: function (v) {
        var o = slot.get();
        if (!U.isObj(o)) { o = {}; slot.set(o); }
        if (v === undefined) delete o[key]; else o[key] = v;
      }
    };
  }
  function itemSlot(listSlot, i) {
    return {
      get: function () { var a = listSlot.get(); return Array.isArray(a) ? a[i] : undefined; },
      set: function (v) { var a = listSlot.get(); if (Array.isArray(a)) a[i] = v === undefined ? null : v; }
    };
  }

  var W = {};
  W.text = function (ctx, desc, slot, path, body, id) {
    var i = U.el('input', 'inp'); i.type = 'text'; i.id = id;
    i.value = slot.get() == null ? '' : String(slot.get());
    if (desc.placeholder) i.placeholder = desc.placeholder;
    if (ctx.readOnly) i.readOnly = true;
    i.addEventListener('input', function () { slot.set(i.value === '' ? undefined : i.value); ctx.changed(path); });
    body.appendChild(i);
  };
  W.longtext = function (ctx, desc, slot, path, body, id, mono) {
    var t = U.el('textarea', 'inp' + (mono ? ' mono' : '')); t.id = id; t.rows = mono ? 2 : 3;
    t.value = slot.get() == null ? '' : String(slot.get());
    if (desc.placeholder) t.placeholder = desc.placeholder;
    if (mono) { t.spellcheck = false; t.setAttribute('autocapitalize', 'off'); }
    if (ctx.readOnly) t.readOnly = true;
    function grow() { t.style.height = 'auto'; t.style.height = Math.min(480, t.scrollHeight + 2) + 'px'; }
    t.addEventListener('input', function () { slot.set(t.value === '' ? undefined : t.value); ctx.changed(path); grow(); });
    body.appendChild(t);
    setTimeout(grow, 0);
  };
  W.formula = function (ctx, desc, slot, path, body, id) { W.longtext(ctx, desc, slot, path, body, id, true); };
  W.int = W.num = function (ctx, desc, slot, path, body, id) {
    var i = U.el('input', 'inp'); i.type = 'number'; i.id = id;
    i.inputMode = desc.type === 'int' ? 'numeric' : 'decimal';
    i.step = desc.step != null ? desc.step : desc.type === 'int' ? 1 : 'any';
    if (desc.min != null) i.min = desc.min;
    if (desc.max != null) i.max = desc.max;
    var v = slot.get(); i.value = v == null ? '' : v;
    if (ctx.readOnly) i.readOnly = true;
    i.addEventListener('input', function () {
      if (i.value === '') slot.set(undefined);
      else { var n = Number(i.value); slot.set(isFinite(n) ? n : i.value); }
      ctx.changed(path);
    });
    body.appendChild(i);
  };
  W.bool = function (ctx, desc, slot, path, body, id) {
    var l = U.el('label', 'switch');
    var c = U.el('input'); c.type = 'checkbox'; c.id = id; c.checked = slot.get() === true;
    if (ctx.readOnly) c.disabled = true;
    var tr = U.el('span', 'track'); var tx = U.el('span', 'switch-text');
    function paint() { tx.textContent = c.checked ? 'Yes' : 'No'; }
    c.addEventListener('change', function () { slot.set(c.checked); ctx.changed(path); paint(); });
    l.appendChild(c); l.appendChild(tr); l.appendChild(tx); paint();
    body.appendChild(l);
  };
  W.enum = function (ctx, desc, slot, path, body, id) {
    var s = U.el('select', 'inp'); s.id = id;
    var vocab = vocabEntries(desc, current) || [];
    var cur = slot.get();
    s.appendChild(new Option(vocab.length ? 'Choose...' : 'No values declared yet', ''));
    vocab.forEach(function (e) { s.appendChild(new Option(e.label === e.value ? e.label : e.label + ' (' + e.value + ')', e.value)); });
    if (cur != null && cur !== '' && !vocab.some(function (e) { return e.value === String(cur); })) {
      s.appendChild(new Option(String(cur) + ' (not in vocabulary)', String(cur)));
    }
    s.value = cur == null ? '' : String(cur);
    if (ctx.readOnly) s.disabled = true;
    s.addEventListener('change', function () { slot.set(s.value === '' ? undefined : s.value); ctx.changed(path); });
    body.appendChild(s);
  };
  W.color = function (ctx, desc, slot, path, body, id) {
    var row = U.el('div', 'color-row');
    var c = U.el('input'); c.type = 'color'; c.setAttribute('aria-label', (desc.label || desc.key) + ' swatch');
    var t = U.el('input', 'inp mono'); t.type = 'text'; t.id = id; t.placeholder = '#rrggbb'; t.maxLength = 7; t.spellcheck = false;
    var v = slot.get();
    t.value = v || '';
    c.value = /^#[0-9a-fA-F]{6}$/.test(v || '') ? v : '#888888';
    if (ctx.readOnly) { c.disabled = true; t.readOnly = true; }
    c.addEventListener('input', function () { t.value = c.value; slot.set(c.value); ctx.changed(path); });
    t.addEventListener('input', function () {
      var val = t.value.trim();
      if (/^#[0-9a-fA-F]{6}$/.test(val)) c.value = val;
      slot.set(val === '' ? undefined : val); ctx.changed(path);
    });
    row.appendChild(c); row.appendChild(t);
    body.appendChild(row);
  };
  W.ref = function (ctx, desc, slot, path, body, id) {
    var row = U.el('div', 'ref-row');
    var btn = U.el('button', 'ref-btn'); btn.type = 'button'; btn.id = id;
    var clr = iconBtn('x', 'Clear reference', function () { slot.set(undefined); ctx.changed(path); paint(); });
    function paint() { btn.innerHTML = refLabelHtml(slot.get()); clr.style.visibility = slot.get() ? 'visible' : 'hidden'; }
    btn.addEventListener('click', function () {
      if (ctx.readOnly) return;
      Kit.ui.pickRef({ prefix: desc.refPrefix, title: 'Choose ' + (desc.label || desc.key), current: slot.get() }).then(function (v) {
        if (v === undefined) return;
        slot.set(v || undefined); ctx.changed(path); paint();
      });
    });
    row.appendChild(btn); row.appendChild(clr);
    body.appendChild(row);
    paint();
  };
  W.refList = function (ctx, desc, slot, path, body) {
    var box = U.el('div', 'klist');
    body.appendChild(box);
    function arr() { var a = slot.get(); return Array.isArray(a) ? a : []; }
    function paint() {
      U.clear(box);
      var a = arr();
      if (!a.length) box.appendChild(U.el('div', 'empty-line', 'No references yet.'));
      a.forEach(function (idv, i) {
        var row = U.el('div', 'reflist-row');
        row.dataset.path = path + '[' + i + ']';
        var st = U.el('div', 'ref-static', refLabelHtml(idv));
        row.appendChild(st);
        if (!ctx.readOnly) {
          row.appendChild(iconBtn('up', 'Move up', function () { if (i > 0) { var x = a[i - 1]; a[i - 1] = a[i]; a[i] = x; ctx.changed(path); paint(); } }));
          row.appendChild(iconBtn('down', 'Move down', function () { if (i < a.length - 1) { var x = a[i + 1]; a[i + 1] = a[i]; a[i] = x; ctx.changed(path); paint(); } }));
          row.appendChild(iconBtn('trash', 'Remove', function () { a.splice(i, 1); if (!a.length) slot.set(undefined); ctx.changed(path); paint(); }));
        }
        box.appendChild(row);
      });
      if (!ctx.readOnly) {
        var add = U.el('button', 'btn', Kit.icon('plus') + '<span>Add reference</span>'); add.type = 'button';
        add.addEventListener('click', function () {
          Kit.ui.pickRef({ prefix: desc.refPrefix, title: 'Add to ' + (desc.label || desc.key) }).then(function (v) {
            if (!v) return;
            var a2 = slot.get();
            if (!Array.isArray(a2)) { a2 = []; slot.set(a2); }
            a2.push(v); ctx.changed(path); paint();
          });
        });
        box.appendChild(add);
      }
    }
    paint();
  };
  W.object = function (ctx, desc, slot, path, body) {
    var fs = U.el('div', 'fieldset form-grid');
    (Array.isArray(desc.of) ? desc.of : []).forEach(function (f) {
      fs.appendChild(renderField(ctx, f, childSlot(slot, f.key), path + '.' + f.key));
    });
    body.appendChild(fs);
  };
  W.list = function (ctx, desc, slot, path, body) {
    var box = U.el('div', 'klist');
    body.appendChild(box);
    function paint() {
      U.clear(box);
      var a = slot.get();
      if (!Array.isArray(a) || !a.length) box.appendChild(U.el('div', 'empty-line', 'No entries yet.'));
      (Array.isArray(a) ? a : []).forEach(function (item, i) {
        var ip = path + '[' + i + ']';
        var card = U.el('div', 'klist-item');
        card.dataset.path = ip;
        var bar = U.el('div', 'klist-bar', '<span class="klist-num">' + U.esc(desc.itemLabel || 'Entry') + ' ' + (i + 1) + '</span>');
        var ctr = U.el('div', 'klist-ctrls');
        if (!ctx.readOnly) {
          ctr.appendChild(iconBtn('up', 'Move up', function () { if (i > 0) { var x = a[i - 1]; a[i - 1] = a[i]; a[i] = x; ctx.changed(path); paint(); } }));
          ctr.appendChild(iconBtn('down', 'Move down', function () { if (i < a.length - 1) { var x = a[i + 1]; a[i + 1] = a[i]; a[i] = x; ctx.changed(path); paint(); } }));
          ctr.appendChild(iconBtn('trash', 'Remove entry', function () { a.splice(i, 1); if (!a.length) slot.set(undefined); ctx.changed(path); paint(); }));
        }
        bar.appendChild(ctr); card.appendChild(bar);
        var isl = itemSlot(slot, i);
        if (Array.isArray(desc.of)) {
          if (!U.isObj(item)) { a[i] = {}; }
          var g = U.el('div', 'form-grid');
          desc.of.forEach(function (f) { g.appendChild(renderField(ctx, f, childSlot(isl, f.key), ip + '.' + f.key)); });
          card.appendChild(g);
        } else {
          var d2 = Object.assign({ key: String(i), label: 'Value' }, desc.of || { type: 'text' });
          card.appendChild(renderField(ctx, d2, isl, ip));
        }
        box.appendChild(card);
      });
      if (!ctx.readOnly) {
        var add = U.el('button', 'btn', Kit.icon('plus') + '<span>Add ' + U.esc((desc.itemLabel || 'entry').toLowerCase()) + '</span>'); add.type = 'button';
        add.addEventListener('click', function () {
          var a2 = slot.get();
          if (!Array.isArray(a2)) { a2 = []; slot.set(a2); }
          a2.push(Array.isArray(desc.of) ? {} : defaultFor(desc.of || { type: 'text' }));
          ctx.changed(path); paint();
          var items = box.querySelectorAll('.klist-item');
          var last = items[items.length - 1];
          if (last) { var f = last.querySelector('input, select, textarea, .ref-btn'); if (f) try { f.focus(); } catch (e) {} }
        });
        box.appendChild(add);
      }
    }
    paint();
  };
  W.table = function (ctx, desc, slot, path, body) {
    var wrap = U.el('div');
    body.appendChild(wrap);
    var cols = Array.isArray(desc.columns) && desc.columns.length ? desc.columns : null;
    var cellType = desc.cell || 'num';
    function rows() {
      if (desc.rows) return vocabEntries({ values: desc.rows }, current);
      if (desc.rowsFrom) return vocabEntries({ enumFrom: desc.rowsFrom }, current);
      var v = slot.get();
      return U.isObj(v) ? Object.keys(v).map(function (k) { return { value: k, label: k }; }) : [];
    }
    var free = !desc.rows && !desc.rowsFrom;
    function paint() {
      U.clear(wrap);
      var rs = rows();
      var val = U.isObj(slot.get()) ? slot.get() : {};
      Object.keys(val).forEach(function (k) { if (!rs.some(function (r) { return r.value === k; })) rs.push({ value: k, label: k + ' (undeclared)' }); });
      if (!rs.length) {
        wrap.appendChild(U.el('div', 'empty-line', free ? 'No rows yet.' : 'No rows yet. Declare ' + U.esc(desc.rowsFrom || 'rows') + ' first.'));
      } else {
        var tw = U.el('div', 'tbl-wrap');
        var t = U.el('table', 'tbl tbl-edit');
        var hr = '<tr><th scope="col">' + U.esc(desc.rowLabel || 'Row') + '</th>' + (cols ? cols.map(function (c) { return '<th scope="col">' + U.esc(c.label || c.key) + '</th>'; }).join('') : '<th scope="col">' + U.esc(desc.valueLabel || 'Value') + '</th>') + (free && !ctx.readOnly ? '<th><span class="sr-only">Remove</span></th>' : '') + '</tr>';
        t.innerHTML = '<thead>' + hr + '</thead>';
        var tb = U.el('tbody');
        rs.forEach(function (r) {
          var tr = U.el('tr');
          tr.dataset.path = path + '.' + r.value;
          var th = U.el('th', null, U.esc(r.label) + (r.label !== r.value ? '<small>' + U.esc(r.value) + '</small>' : ''));
          th.scope = 'row';
          tr.appendChild(th);
          (cols || [{ key: null }]).forEach(function (c) {
            var td = U.el('td');
            var ct = (c && c.type) || cellType;
            var cur = c.key ? (U.isObj(val[r.value]) ? val[r.value][c.key] : undefined) : val[r.value];
            if (ct === 'enum') {
              // P6 (Pass 3): enum cells render a select from desc.cellValues (or the column's values / enumFrom).
              var sel = U.el('select', 'inp');
              var cv = vocabEntries(c.key ? c : { values: desc.cellValues, enumFrom: desc.cellEnumFrom }, current) || [];
              sel.appendChild(new Option(desc.cellPlaceholder || '(default)', ''));
              cv.forEach(function (e) { sel.appendChild(new Option(e.label, e.value)); });
              if (cur != null && cur !== '' && !cv.some(function (e) { return e.value === String(cur); })) sel.appendChild(new Option(String(cur) + ' (not in vocabulary)', String(cur)));
              sel.value = cur == null ? '' : String(cur);
              sel.setAttribute('aria-label', r.label + (c.key ? ' ' + (c.label || c.key) : ''));
              if (ctx.readOnly) sel.disabled = true;
              sel.addEventListener('change', function () {
                var obj = slot.get();
                if (!U.isObj(obj)) { obj = {}; slot.set(obj); }
                var v2 = sel.value === '' ? undefined : sel.value;
                if (c.key) {
                  var ro = U.isObj(obj[r.value]) ? obj[r.value] : (obj[r.value] = {});
                  if (v2 === undefined) delete ro[c.key]; else ro[c.key] = v2;
                  if (!Object.keys(ro).length) delete obj[r.value];
                } else if (v2 === undefined) delete obj[r.value];
                else obj[r.value] = v2;
                ctx.changed(path + '.' + r.value + (c.key ? '.' + c.key : ''));
              });
              td.appendChild(sel);
              tr.appendChild(td);
              return;
            }
            var inp = U.el('input', 'inp');
            inp.type = ct === 'text' ? 'text' : 'number';
            if (ct !== 'text') { inp.inputMode = ct === 'int' ? 'numeric' : 'decimal'; inp.step = ct === 'int' ? 1 : 'any'; }
            inp.setAttribute('aria-label', r.label + (c.key ? ' ' + (c.label || c.key) : ''));
            inp.value = cur == null ? '' : cur;
            if (ctx.readOnly) inp.readOnly = true;
            inp.addEventListener('input', function () {
              var obj = slot.get();
              if (!U.isObj(obj)) { obj = {}; slot.set(obj); }
              var raw = inp.value, v = raw === '' ? undefined : ct === 'text' ? raw : Number(raw);
              if (c.key) {
                var rowObj = U.isObj(obj[r.value]) ? obj[r.value] : (obj[r.value] = {});
                if (v === undefined) delete rowObj[c.key]; else rowObj[c.key] = v;
                if (!Object.keys(rowObj).length) delete obj[r.value];
              } else if (v === undefined) delete obj[r.value];
              else obj[r.value] = v;
              ctx.changed(path + '.' + r.value + (c.key ? '.' + c.key : ''));
            });
            td.appendChild(inp);
            tr.appendChild(td);
          });
          if (free && !ctx.readOnly) {
            var td2 = U.el('td');
            td2.appendChild(iconBtn('trash', 'Remove row ' + r.value, function () { var o2 = slot.get(); if (U.isObj(o2)) delete o2[r.value]; ctx.changed(path); paint(); }));
            tr.appendChild(td2);
          }
          tb.appendChild(tr);
        });
        t.appendChild(tb); tw.appendChild(t); wrap.appendChild(tw);
      }
      if (free && !ctx.readOnly) {
        var add = U.el('button', 'btn', Kit.icon('plus') + '<span>Add row</span>'); add.type = 'button'; add.style.marginTop = '8px';
        add.addEventListener('click', function () {
          Kit.ui.prompt({ title: 'Add row', label: 'Row key', validate: function (v) { return v.trim() ? null : 'Enter a key.'; } }).then(function (k) {
            if (k == null) return;
            k = k.trim();
            var o3 = slot.get(); if (!U.isObj(o3)) { o3 = {}; slot.set(o3); }
            if (o3[k] === undefined) o3[k] = cols ? {} : defaultFor({ type: cellType });
            ctx.changed(path); paint();
          });
        });
        wrap.appendChild(add);
      }
    }
    paint();
  };

  function renderField(ctx, desc, slot, path) {
    var wrap = U.el('div', 'field');
    wrap.dataset.path = path;
    if (FULL_TYPES[desc.type] || desc.full) wrap.classList.add('span-all');
    var id = 'kf_' + (++uid);
    var lab = U.el('label', 'field-label');
    lab.textContent = desc.label || desc.key;
    if (desc.required) lab.insertAdjacentHTML('beforeend', ' <span class="req" aria-hidden="true">*</span>');
    if (desc.forward || (desc.refPrefix && [].concat(desc.refPrefix).every(function (p) { var i = PREFIXES[normPrefix(p)]; return i && i.forge !== 146; }))) {
      var fg = [].concat(desc.refPrefix || []).map(function (p) { var i = PREFIXES[normPrefix(p)]; return i ? i.forge : ''; }).filter(Boolean);
      lab.insertAdjacentHTML('beforeend', ' <span class="chip chip-forward">Forward' + (fg.length ? ' &middot; ' + fg[0] : '') + '</span>');
    }
    if (!{ list: 1, refList: 1, object: 1, table: 1 }[desc.type]) lab.htmlFor = id;
    wrap.appendChild(lab);
    var body = U.el('div', 'field-body');
    wrap.appendChild(body);
    // P7 (Pass 3): desc.readOnly locks one field; desc.derived names a Kit.codex.derive function whose result is shown read only.
    var fctx = ctx;
    if (desc.readOnly || desc.derived) {
      fctx = Object.create(ctx); fctx.readOnly = true;
      if (desc.derived) {
        wrap.classList.add('derived');
        lab.insertAdjacentHTML('beforeend', ' <span class="chip chip-muted">Derived</span>');
        var dfn = Kit.codex.derive && Kit.codex.derive[desc.derived];
        if (typeof dfn === 'function') {
          try {
            var dv = dfn(ctx.record, current, path);
            if (U.canonical(dv) !== U.canonical(slot.get())) slot.set(dv);
          } catch (e) { console.warn('[Kit] derive ' + desc.derived + ' failed', e); }
        }
      }
    }
    (W[desc.type] || W.text)(fctx, desc, slot, path, body, id);
    if (desc.help) wrap.appendChild(U.el('div', 'field-help', U.esc(desc.help)));
    var msg = U.el('div', 'field-msg'); msg.setAttribute('aria-live', 'polite');
    wrap.appendChild(msg);
    return wrap;
  }

  function showMessages(ctx) {
    var items = Kit.validate.record(ctx.typeName, ctx.record, { draft: ctx.draft });
    var wraps = ctx.root.querySelectorAll('.field[data-path]');
    var map = {};
    Array.prototype.forEach.call(wraps, function (w) {
      map[w.dataset.path] = w;
      w.classList.remove('has-error');
      var m = w.querySelector(':scope > .field-msg'); if (m) U.clear(m);
    });
    U.clear(ctx.headMsg);
    items.forEach(function (it) {
      var p = it.fieldPath, w = null;
      while (p) { if (map[p]) { w = map[p]; break; } p = U.parentPath(p); }
      var target = w ? w.querySelector(':scope > .field-msg') : ctx.headMsg;
      if (!target) return;
      var line = U.el('div', 'msg msg-' + it.level);
      line.textContent = it.message;
      target.appendChild(line);
      if (w && (it.level === 'error' || it.level === 'broken')) w.classList.add('has-error');
    });
    return items;
  }

  Kit.form = {};
  // render(container, typeName, record, onChange, opts{draft, readOnly}) -> {el, record, validate(), refresh()}
  Kit.form.render = function (container, typeName, record, onChange, opts) {
    opts = opts || {};
    U.clear(container);
    var tdef = Kit.codex.type(typeName);
    if (!tdef) { container.appendChild(U.el('p', 'muted', 'Unknown type: ' + U.esc(typeName))); return null; }
    var fields = (tdef.fields || []).slice();
    if (!tdef.section) {
      if (!fields.some(function (f) { return f.key === 'name'; })) fields.unshift({ key: 'name', label: 'Name', type: 'text', required: true });
      if (!fields.some(function (f) { return f.key === 'notes'; })) fields.push({ key: 'notes', label: 'Notes', type: 'longtext' });
    }
    var root = U.el('div', 'kform');
    var head = U.el('div', 'kform-head');
    head.innerHTML = '<span class="kform-type">' + U.esc(tdef.label || tdef.name) + '</span>' +
      (tdef.section ? '' : record.id ? '<code class="id">' + U.esc(record.id) + '</code>' : '<span class="chip chip-muted">ID assigned on accept</span>') +
      (record.charterVersion != null ? '<span class="chip chip-muted">Charter v' + U.esc(record.charterVersion) + '</span>' : '');
    var headMsg = U.el('div', 'field-msg'); head.appendChild(headMsg);
    root.appendChild(head);
    var ctx = { typeName: typeName, record: record, draft: !!opts.draft, readOnly: !!opts.readOnly, root: root, headMsg: headMsg };
    ctx.changed = function (path) { if (onChange) onChange(record, path); showMessages(ctx); };
    var rootSlot = { get: function () { return record; }, set: function () {} };
    var grid = U.el('div', 'form-grid');
    fields.forEach(function (f) {
      if (!f || !f.key || f.key === 'id' || f.key === 'charterVersion') return;
      grid.appendChild(renderField(ctx, f, childSlot(rootSlot, f.key), f.key));
    });
    root.appendChild(grid);
    container.appendChild(root);
    showMessages(ctx);
    return {
      el: root, record: record,
      validate: function () { return showMessages(ctx); },
      refresh: function () { return Kit.form.render(container, typeName, record, onChange, opts); },
      focusPath: function (p) {
        var w = null;
        while (p) { w = root.querySelector('.field[data-path="' + p.replace(/"/g, '') + '"]'); if (w) break; p = U.parentPath(p); }
        if (w) { w.scrollIntoView({ block: 'center' }); var f = w.querySelector('input, select, textarea, button'); if (f) try { f.focus({ preventScroll: true }); } catch (e) {} }
        return !!w;
      }
    };
  };
  // Open any record in a drawer editor (handy from the console).
  Kit.form.preview = function (typeName, record, onChange) {
    record = record || {};
    var ctl = null;
    Kit.ui.drawer({ title: 'Edit ' + ((Kit.codex.type(typeName) || {}).label || typeName), body: function (b) { ctl = Kit.form.render(b, typeName, record, onChange); } });
    return { record: record, form: ctl };
  };

  // ---------------------------------------------------------------- review drawer
  Kit.review = {};
  Kit.review.open = function (drafts, typeName, onAccept, ropts) {
    var tdef = Kit.codex.type(typeName);
    if (!tdef) { Kit.ui.toast('Unknown type ' + typeName + '.', 'error'); return null; }
    var prefix = normPrefix(tdef.prefix);
    ropts = ropts || {};
    var section = !!(ropts.section || tdef.section);
    onAccept = onAccept || function (rec) { Kit.records.put(rec); };
    var pending = (drafts || []).map(function (d, i) { var c = U.isObj(d) ? U.clone(d) : {}; delete c.id; delete c.charterVersion; return { key: i, draft: c, open: false }; });
    var accepted = 0;
    var dr = Kit.ui.drawer({ title: (section ? 'Review options: ' : 'Review drafts: ') + (tdef.label || tdef.name) });
    function draftTitle(p) {
      if (!section) return p.draft.name || '(unnamed draft)';
      var first = '';
      Object.keys(p.draft).some(function (k) { var v = p.draft[k]; if (typeof v === 'string' && v.trim()) { first = v.trim(); return true; } return false; });
      return 'Option ' + (p.key + 1) + (first ? ': ' + first.slice(0, 60) : '');
    }
    function issues(p) { return Kit.validate.record(typeName, p.draft, { draft: true }); }
    function isValid(p) { return !issues(p).some(function (it) { return it.level === 'error' || it.level === 'broken'; }); }
    function accept(p) {
      var rec = p.draft;
      if (!section) {
        rec.id = Kit.ids.mint(prefix, rec.name || tdef.name);
        rec.charterVersion = current.charter.version || 0;
      }
      try { onAccept(rec); } catch (e) { if (!section) delete rec.id; Kit.ui.toast('Could not accept draft: ' + e.message, 'error'); return false; }
      Kit.index.invalidate();
      pending.splice(pending.indexOf(p), 1);
      accepted++;
      Kit.bundle.touch('review-accept');
      return true;
    }
    function paint() {
      U.clear(dr.body);
      if (ropts.note) dr.body.appendChild(U.el('p', 'muted', U.esc(ropts.note)));
      var top = U.el('div', 'btn-row');
      top.style.marginBottom = '12px';
      var validCount = pending.filter(isValid).length;
      top.appendChild(U.el('span', 'muted', pending.length + ' pending, ' + accepted + ' accepted'));
      var all = U.el('button', 'btn btn-primary', Kit.icon('check') + '<span>Accept All Valid (' + validCount + ')</span>'); all.type = 'button';
      all.disabled = !validCount;
      all.addEventListener('click', function () {
        pending.filter(isValid).forEach(accept);
        Kit.ui.toast('Accepted ' + validCount + ' draft' + (validCount === 1 ? '' : 's') + '.', 'ok');
        paint();
      });
      top.appendChild(all);
      dr.body.appendChild(top);
      if (!pending.length) {
        var done = U.el('div', 'panel stub', '<div class="stub-glyph">' + Kit.icon('check') + '</div><h2>All drafts handled</h2><p>' + accepted + ' accepted into the bundle.</p>');
        var cb = U.el('button', 'btn btn-primary', 'Close'); cb.type = 'button'; cb.addEventListener('click', dr.close);
        done.appendChild(cb);
        dr.body.appendChild(done);
        return;
      }
      pending.forEach(function (p) {
        var its = issues(p);
        var nE = its.filter(function (i) { return i.level === 'error'; }).length;
        var nB = its.filter(function (i) { return i.level === 'broken'; }).length;
        var nW = its.filter(function (i) { return i.level === 'warning'; }).length;
        var card = U.el('div', 'review-card ' + (nE + nB ? 'bad' : 'ok'));
        var title = U.el('div', 'review-title');
        title.innerHTML = '<strong>' + U.esc(draftTitle(p)) + '</strong>' +
          (nE ? '<span class="chip chip-error">' + nE + ' error' + (nE > 1 ? 's' : '') + '</span>' : '') +
          (nB ? '<span class="chip chip-broken">' + nB + ' unknown ref' + (nB > 1 ? 's' : '') + '</span>' : '') +
          (nW ? '<span class="chip chip-warning">' + nW + ' warning' + (nW > 1 ? 's' : '') + '</span>' : '') +
          (!nE && !nB && !nW ? '<span class="chip chip-ok">Valid</span>' : '');
        card.appendChild(title);
        if (its.length && !p.open) {
          var ul = U.el('ul', 'review-issues');
          its.slice(0, 4).forEach(function (it) { ul.appendChild(U.el('li', 'msg msg-' + it.level, U.esc(it.message))); });
          if (its.length > 4) ul.appendChild(U.el('li', 'muted', '+' + (its.length - 4) + ' more'));
          card.appendChild(ul);
        }
        var row = U.el('div', 'btn-row');
        var bA = U.el('button', 'btn btn-primary', Kit.icon('check') + '<span>Accept</span>'); bA.type = 'button';
        var bE = U.el('button', 'btn', Kit.icon('edit') + '<span>' + (p.open ? 'Done editing' : 'Edit') + '</span>'); bE.type = 'button';
        var bR = U.el('button', 'btn btn-ghost', Kit.icon('x') + '<span>Reject</span>'); bR.type = 'button';
        bA.addEventListener('click', function () {
          var bad = nE + nB;
          var go = bad ? Kit.ui.confirm({ title: 'Accept with issues?', message: 'This draft has ' + bad + ' blocking issue' + (bad > 1 ? 's' : '') + '. Accept it anyway and fix it later?', okLabel: 'Accept anyway' }) : Promise.resolve(true);
          go.then(function (ok) { if (ok && accept(p)) paint(); });
        });
        bE.addEventListener('click', function () { p.open = !p.open; paint(); });
        bR.addEventListener('click', function () { pending.splice(pending.indexOf(p), 1); paint(); });
        row.appendChild(bA); row.appendChild(bE); row.appendChild(bR);
        card.appendChild(row);
        if (p.open) {
          var fwrap = U.el('div', 'review-form');
          card.appendChild(fwrap);
          Kit.form.render(fwrap, typeName, p.draft, function () {
            var its2 = issues(p);
            var bad2 = its2.some(function (i) { return i.level === 'error' || i.level === 'broken'; });
            card.className = 'review-card ' + (bad2 ? 'bad' : 'ok');
          }, { draft: true });
        }
        dr.body.appendChild(card);
      });
    }
    paint();
    return { drawer: dr, pending: pending };
  };

  // ---------------------------------------------------------------- AI helpers
  function summarizeCharter(b) {
    var c = b.charter || {};
    function trim(v, n) {
      if (typeof v === 'string') return v.length > n ? v.slice(0, n) + '...' : v;
      if (Array.isArray(v)) return v.slice(0, 24).map(function (x) { return trim(x, n); });
      if (U.isObj(v)) { var o = {}; Object.keys(v).forEach(function (k) { o[k] = trim(v[k], n); }); return o; }
      return v;
    }
    var rs = c.ruleset || {};
    return {
      locked: !!c.locked, version: c.version || 0,
      sections: trim(c.sections || {}, 400),
      ruleset: { preset: rs.preset, battleEngine: rs.battleEngine, scheduler: rs.scheduler, progression: rs.progression, stats: rs.stats, elements: rs.elements, elementRelations: rs.elementRelations, taxonomy: rs.taxonomy },
      canon: trim(c.canon || [], 240),
      glossary: trim(c.glossary || [], 200)
    };
  }
  function describeFields(fields, bundle) {
    return fields.filter(function (f) { return f && f.key && f.key !== 'id' && f.key !== 'charterVersion' && !f.derived && !f.readOnly; }).map(function (f) {
      var d = { key: f.key, type: f.type };
      if (f.type === 'table') { d.cell = f.cell || 'num'; if (f.cellValues || f.cellEnumFrom) d.cellValues = (vocabEntries({ values: f.cellValues, enumFrom: f.cellEnumFrom }, bundle) || []).map(function (e) { return e.value; }); }
      if (f.label) d.label = f.label;
      if (f.required) d.required = true;
      if (f.help) d.help = f.help;
      if (f.min != null) d.min = f.min;
      if (f.max != null) d.max = f.max;
      if (f.refPrefix) d.refPrefix = f.refPrefix;
      var v = vocabEntries(f, bundle);
      if (v) d.allowedValues = v.map(function (e) { return e.value; });
      if (f.rowsFrom || f.rows) d.rows = (vocabEntries(f.rows ? { values: f.rows } : { enumFrom: f.rowsFrom }, bundle) || []).map(function (e) { return e.value; });
      if (f.columns) d.columns = f.columns.map(function (c) { return c.key; });
      if (Array.isArray(f.of)) d.of = describeFields(f.of, bundle);
      else if (f.of) d.of = describeFields([Object.assign({ key: 'item' }, f.of)], bundle)[0];
      return d;
    });
  }
  function collectRefPrefixes(fields, out) {
    fields.forEach(function (f) {
      if (!f) return;
      if (f.refPrefix) [].concat(f.refPrefix).forEach(function (p) { out[normPrefix(p)] = 1; });
      if (Array.isArray(f.of)) collectRefPrefixes(f.of, out);
      else if (U.isObj(f.of)) collectRefPrefixes([f.of], out);
    });
    return out;
  }

  Kit.ai = {
    NO_KEY: NO_KEY_MSG,
    describeFields: function (fields, bundle) { return describeFields(fields, bundle || current); },
    hasKey: function () { return Kit.settings.hasKey(); },
    charterSummary: function (b) { return summarizeCharter(b || current); },
    // Build an AI button that shows a one-line Settings hint when no key is saved.
    button: function (label, handler, opts) {
      opts = opts || {};
      var wrap = U.el('span', 'ai-wrap');
      var b = U.el('button', 'btn' + (opts.kind ? ' btn-' + opts.kind : ''), Kit.icon('spark') + '<span>' + U.esc(label) + '</span>');
      b.type = 'button';
      var hint = U.el('span', 'ai-hint'); hint.hidden = true;
      hint.innerHTML = 'Add a Claude API key in <button type="button">Settings</button> to use this.';
      hint.querySelector('button').addEventListener('click', function () { Kit.settings.open(); });
      b.addEventListener('click', function () {
        if (!Kit.ai.hasKey()) { hint.hidden = false; return; }
        hint.hidden = true;
        var html = b.innerHTML;
        b.disabled = true; b.innerHTML = '<span class="spin"></span><span>' + U.esc(opts.busyLabel || 'Thinking...') + '</span>';
        Promise.resolve().then(handler).catch(function (e) { console.warn('[Kit.ai.button]', e); }).then(function () { b.disabled = false; b.innerHTML = html; });
      });
      wrap.appendChild(b); wrap.appendChild(hint);
      return wrap;
    },
    // Ask Claude (Sonnet) for draft records of a type, validate them, and open review.
    draftRecords: async function (typeName, o) {
      o = o || {};
      var tdef = Kit.codex.type(typeName);
      if (!tdef) throw new Error('Unknown type ' + typeName + '.');
      if (!Kit.ai.hasKey()) { Kit.ui.toast(NO_KEY_MSG, 'warn'); return null; }
      var count = Math.max(1, Math.min(12, o.count || 1));
      var b = current, idx = Kit.index();
      var refs = {};
      Object.keys(collectRefPrefixes(tdef.fields || [], {})).forEach(function (p) {
        var info = PREFIXES[p];
        if (!info) return;
        if (!Kit.codex.isOpened(info.ns, b)) { refs[p] = { forward: true, owedBy: info.forge, note: 'Not yet available. Use null.' }; return; }
        refs[p] = (idx.byPrefix[p] || []).slice(0, 120).map(function (e) { return { id: e.id, name: e.name }; });
      });
      var context = {
        charter: summarizeCharter(b),
        type: { name: tdef.name, label: tdef.label || tdef.name, prefix: tdef.prefix, fields: describeFields([{ key: 'name', type: 'text', required: true }].concat((tdef.fields || []).filter(function (f) { return f.key !== 'name'; })), b) },
        referenceTargets: refs,
        existingNames: (idx.byPrefix[normPrefix(tdef.prefix)] || []).slice(0, 80).map(function (e) { return e.name; })
      };
      var system = [
        'You draft records for Saga Forge, a tool for authoring a classic 16-bit style JRPG.',
        'Stay consistent with the Charter summary: its canon, glossary, tone, and ruleset vocabularies.',
        'Return ONLY JSON of the form {"drafts":[{...}, ...]} with exactly ' + count + ' draft' + (count > 1 ? 's' : '') + '.',
        'Each draft uses the field keys given. Never include "id" or "charterVersion"; IDs are assigned later.',
        'For enum fields and table rows use only the allowedValues or rows listed.',
        'For ref and refList fields use only IDs listed in referenceTargets. If none fit, or the target is forward, use null (or an empty list).',
        'Numbers must be plain JSON numbers. Avoid names already in existingNames.'
      ].join(' ');
      var user = 'Context:\n' + JSON.stringify(context) + '\n\nRequest: ' + (o.prompt || ('Draft ' + count + ' ' + (tdef.label || tdef.name) + ' record' + (count > 1 ? 's' : '') + '.'));
      Kit.ui.busy.show('Drafting with Claude...');
      var out;
      try {
        out = await Kit.claude({ tier: o.tier || 'sonnet', system: system, messages: [{ role: 'user', content: user }], maxTokens: Math.min(8000, 1200 + 900 * count), expectJson: true });
      } finally { Kit.ui.busy.hide(); }
      var j = out.json;
      var drafts = Array.isArray(j) ? j : j && Array.isArray(j.drafts) ? j.drafts : [];
      drafts = drafts.filter(U.isObj).map(function (d) { delete d.id; delete d.charterVersion; return d; });
      if (!drafts.length) { Kit.ui.toast('Claude returned no usable drafts.', 'warn'); return []; }
      Kit.review.open(drafts, typeName, o.onAccept);
      return drafts;
    }
  };

  // ---------------------------------------------------------------- workspaces
  var mounts = {}, order = [], activeId = null;
  Kit.mount = function (id, o) {
    o = o || {};
    if (!mounts[id]) order.push(id);
    mounts[id] = { id: id, title: o.title || id, icon: o.icon || null, render: o.render || U.noop, canEnter: o.canEnter || function () { return true; }, onLeave: o.onLeave || null, focus: o.focus || null };
    paintTabs();
    return mounts[id];
  };
  Kit.canEnter = function (id) {
    var m = mounts[id];
    if (!m) return { ok: false, reason: 'Unknown workspace.' };
    var r;
    try { r = m.canEnter(current); } catch (e) { r = 'This workspace could not check its requirements.'; }
    if (r === true || r === undefined) return { ok: true, reason: '' };
    if (typeof r === 'string') return { ok: false, reason: r };
    if (U.isObj(r)) return { ok: !!r.ok, reason: r.reason || '' };
    return { ok: false, reason: 'Locked for now.' };
  };
  Kit.active = function () { return activeId; };
  Kit.workspaces = function () { return order.slice(); };
  Kit.go = function (id, opts) {
    opts = opts || {};
    var c = Kit.canEnter(id);
    if (!c.ok) { if (!opts.silent) Kit.ui.toast(c.reason || 'That workspace is locked.', 'warn'); return false; }
    if (activeId && activeId !== id && mounts[activeId] && mounts[activeId].onLeave) {
      if (mounts[activeId].onLeave() === false) return false;
    }
    activeId = id;
    Kit.uiState.set({ tab: id });
    paintTabs();
    Kit.rerender();
    return true;
  };
  Kit.rerender = function () {
    var host = document.getElementById('ws');
    if (!host || !activeId) return;
    U.clear(host);
    var inner = U.el('div', 'ws-inner');
    inner.dataset.ws = activeId;
    host.appendChild(inner);
    try { mounts[activeId].render(inner, current); }
    catch (e) {
      console.error('[Kit] render failed for ' + activeId, e);
      inner.appendChild(Kit.ui.stub({ title: 'Something went wrong', lead: e.message, icon: 'warn' }));
    }
  };
  function paintTabs() {
    var nav = document.getElementById('tabs');
    if (!nav) return;
    U.clear(nav);
    order.forEach(function (id) {
      var m = mounts[id], c = Kit.canEnter(id);
      var b = U.el('button', 'tab' + (c.ok ? '' : ' locked'));
      b.type = 'button';
      b.setAttribute('role', 'tab');
      b.setAttribute('aria-selected', id === activeId ? 'true' : 'false');
      b.dataset.ws = id;
      b.innerHTML = (c.ok ? '' : Kit.icon('lock')) + '<span>' + U.esc(m.title) + '</span>';
      if (!c.ok) { b.title = c.reason; b.setAttribute('aria-disabled', 'true'); b.setAttribute('aria-label', m.title + ' (locked: ' + c.reason + ')'); }
      else b.title = m.title;
      b.addEventListener('click', function () { Kit.go(id); });
      nav.appendChild(b);
    });
  }
  Kit.paintTabs = paintTabs;
  // Jump to a record (and field) from the Validation panel.
  var jumpHandlers = [];
  function jumpHandler(id) {
    for (var i = 0; i < jumpHandlers.length; i++) { if (jumpHandlers[i].test(id)) return jumpHandlers[i]; }
    return null;
  }
  Kit.jump = function (recordId, fieldPath) {
    var hd = jumpHandler(recordId);
    if (hd) return !!hd.go(recordId, fieldPath);
    var info = PREFIXES[prefixOf(recordId)];
    var ws = info ? (info.ns === 'charter' ? 'charter' : info.ns === 'rules' ? 'rules' : null) : null;
    if (!ws || !mounts[ws]) { Kit.ui.toast('No workspace edits ' + recordId + ' yet.', 'warn'); return false; }
    if (activeId !== ws && !Kit.go(ws)) return false;
    Kit.emit('jump', { recordId: recordId, fieldPath: fieldPath, workspace: ws });
    if (mounts[ws].focus) mounts[ws].focus(recordId, fieldPath);
    return true;
  };

  // Workspaces register {test(id), name(id), go(id, fieldPath)} for record IDs that are not prefixed records.
  Kit.jump.register = function (h) { jumpHandlers.push(h); };
  Kit.jump.can = function (id) { return Kit.ids.isValid(id) || !!jumpHandler(id); };

  // ---------------------------------------------------------------- validation badge + panel
  var lastResult = null;
  function paintBadge(res) {
    var b = document.getElementById('btnValidation');
    if (!b) return;
    var s = Kit.validate.summary(res);
    var html = '';
    if (!s.errors && !s.broken && !s.warnings && !s.forward) html = '<span class="chip chip-ok">' + Kit.icon('check') + 'Valid</span>';
    else {
      if (s.errors) html += '<span class="chip chip-error" title="Errors">' + s.errors + ' err</span>';
      if (s.broken) html += '<span class="chip chip-broken" title="Broken references">' + s.broken + ' broken</span>';
      if (s.forward) html += '<span class="chip chip-forward" title="Forward references">' + s.forward + ' fwd</span>';
      if (s.warnings) html += '<span class="chip chip-warning" title="Warnings">' + s.warnings + ' warn</span>';
      if (!s.errors && !s.broken) html = '<span class="chip chip-ok">' + Kit.icon('check') + 'OK</span>' + html;
    }
    b.innerHTML = html;
    b.setAttribute('aria-label', 'Validation: ' + s.errors + ' errors, ' + s.broken + ' broken, ' + s.forward + ' forward, ' + s.warnings + ' warnings. Open panel.');
  }
  Kit.refreshValidation = function () {
    lastResult = Kit.validate(current);
    paintBadge(lastResult);
    Kit.emit('validated', lastResult);
    return lastResult;
  };
  var refreshSoon = U.debounce(function () { Kit.refreshValidation(); paintTabs(); }, 200);

  function recordName(id) {
    var hd = jumpHandler(id);
    if (hd && hd.name) return hd.name(id);
    var e = Kit.index().byId[id];
    return e ? e.name : id;
  }
  Kit.openValidation = function () {
    var res = Kit.refreshValidation();
    var s = Kit.validate.summary(res);
    Kit.ui.drawer({
      title: 'Validation',
      body: function (b, h) {
        var sum = U.el('div', 'vsummary');
        sum.innerHTML = '<span class="chip chip-error">' + s.errors + ' errors</span><span class="chip chip-broken">' + s.broken + ' broken</span><span class="chip chip-forward">' + s.forward + ' forward</span><span class="chip chip-warning">' + s.warnings + ' warnings</span>';
        b.appendChild(sum);
        var intro = U.el('p', 'muted');
        intro.textContent = 'Errors and broken references block a final export. Forward references point at forges 147 to 149 and are legal. Drafts can always be exported.';
        b.appendChild(intro);
        var blocking = {}, warnOnly = {};
        res.errors.concat(res.broken).forEach(function (it) { (blocking[it.recordId] = blocking[it.recordId] || []).push(it); });
        res.warnings.forEach(function (it) { (warnOnly[it.recordId] = warnOnly[it.recordId] || []).push(it); });
        function group(title, map) {
          var ids = Object.keys(map);
          if (!ids.length) return;
          b.appendChild(U.el('h3', 'section-h', U.esc(title)));
          ids.forEach(function (rid) {
            var g = U.el('div', 'vgroup');
            var head = U.el('div', 'vgroup-head', '<strong>' + U.esc(recordName(rid)) + '</strong><code class="id">' + U.esc(rid) + '</code>');
            if (Kit.jump.can(rid)) {
              var j = U.el('button', 'btn btn-ghost', Kit.icon('jump') + '<span>Jump</span>'); j.type = 'button';
              j.addEventListener('click', function () { h.close(); Kit.jump(rid, map[rid][0].fieldPath); });
              head.appendChild(j);
            }
            g.appendChild(head);
            map[rid].forEach(function (it) {
              var row = U.el('div', 'vitem', '<span class="chip chip-' + it.level + '">' + it.level + '</span><span>' + U.esc(it.message) + '</span>' + (it.fieldPath ? '<code>' + U.esc(it.fieldPath) + '</code>' : ''));
              g.appendChild(row);
            });
            b.appendChild(g);
          });
        }
        group('Blocking', blocking);
        group('Warnings', warnOnly);
        if (res.forward.length) {
          b.appendChild(U.el('h3', 'section-h', 'Forward references by owing forge'));
          var byForge = {};
          res.forward.forEach(function (it) { (byForge[it.owedBy] = byForge[it.owedBy] || []).push(it); });
          Object.keys(byForge).sort().forEach(function (f) {
            var g = U.el('div', 'vgroup');
            g.appendChild(U.el('div', 'vgroup-head', '<strong>Forge ' + U.esc(f) + '</strong><span class="chip chip-forward">' + byForge[f].length + ' owed</span>'));
            byForge[f].forEach(function (it) {
              g.appendChild(U.el('div', 'vitem', '<code>' + U.esc(it.id) + '</code><span>from ' + U.esc(recordName(it.recordId)) + '</span><code>' + U.esc(it.fieldPath) + '</code>'));
            });
            b.appendChild(g);
          });
        }
        if (!res.errors.length && !res.broken.length && !res.warnings.length && !res.forward.length) {
          b.appendChild(U.el('div', 'panel stub', '<div class="stub-glyph">' + Kit.icon('check') + '</div><h2>No issues</h2><p>The bundle validates cleanly.</p>'));
        }
      }
    });
  };

  // ---------------------------------------------------------------- settings modal
  function openSettings() {
    var s = Kit.settings.get();
    var ui = Kit.uiState.get();
    var refs = {};
    Kit.ui.dialog({
      title: 'Settings',
      body: function (b) {
        b.innerHTML =
          '<div class="form-grid">' +
          '<div class="field span-all" id="setKeyMount"></div>' +
          '<div class="field span-all"><div class="btn-row"><button class="btn" type="button" id="setTest">' + Kit.icon('spark') + '<span>Test Key</span></button><span class="settings-test" id="setTestOut" aria-live="polite"></span></div></div>' +
          '<div class="field span-all"><label class="field-label" for="setSession">Session name</label><input class="inp" id="setSession" type="text" placeholder="e.g. Saga weekend build"><div class="field-help">A label for your own reference, kept with your settings.</div></div>' +
          '<div class="field"><label class="field-label" for="setTheme">Theme</label><select class="inp" id="setTheme"><option value="system">Match system</option><option value="night">Night</option><option value="parchment">Parchment</option></select></div>' +
          '</div>' +
          '<h3 class="section-h">Model tiers</h3><p class="field-help">Leave blank to use the portfolio config.json, then the built-in default.</p>' +
          '<div class="form-grid" id="setTiers"></div>' +
          '<h3 class="section-h">Storage</h3><p class="muted" id="setUsage"></p>';
        if (window.AppKeys) window.AppKeys.mountSettings(b.querySelector('#setKeyMount'));
        refs.session = b.querySelector('#setSession'); refs.session.value = s.session;
        refs.theme = b.querySelector('#setTheme'); refs.theme.value = ui.theme || 'system';
        refs.out = b.querySelector('#setTestOut');
        refs.theme.addEventListener('change', function () { Kit.theme.set(refs.theme.value); });
        var tg = b.querySelector('#setTiers');
        refs.tiers = {};
        TIERS.forEach(function (t) {
          var f = U.el('div', 'field');
          f.innerHTML = '<label class="field-label" for="setTier_' + t + '">' + t + '</label><input class="inp mono" id="setTier_' + t + '" type="text" spellcheck="false" placeholder="' + MODEL_FALLBACK[t] + '">';
          tg.appendChild(f);
          refs.tiers[t] = f.querySelector('input'); refs.tiers[t].value = s.tiers[t] || '';
        });
        var used = Kit.store.usage();
        b.querySelector('#setUsage').textContent = 'This browser holds about ' + U.fmtSize(used) + ' for this site. A warning appears past about 4.5 MB.';
        var test = b.querySelector('#setTest');
        test.addEventListener('click', function () {
          save();
          refs.out.className = 'settings-test';
          if (!Kit.settings.hasKey()) { refs.out.classList.add('bad'); refs.out.textContent = 'Enter a key first.'; return; }
          refs.out.textContent = 'Testing...';
          test.disabled = true;
          Kit.claude({ tier: 'haiku', maxTokens: 16, messages: [{ role: 'user', content: 'Reply with the single word OK.' }], silent: true })
            .then(function (r) { refs.out.classList.add('ok'); refs.out.textContent = 'Success. ' + r.model + ' replied "' + r.text.trim().slice(0, 20) + '".'; })
            .catch(function (e) { refs.out.classList.add('bad'); refs.out.textContent = 'Failed: ' + e.message; })
            .then(function () { test.disabled = false; });
        });
      },
      actions: [
        { label: 'Save', kind: 'primary', onClick: function () { save(); Kit.ui.toast('Settings saved.', 'ok'); } }
      ]
    });
    function save() {
      var tiers = {};
      TIERS.forEach(function (t) { tiers[t] = refs.tiers[t].value; });
      Kit.settings.set({ session: refs.session.value, tiers: tiers });
    }
  }

  // ---------------------------------------------------------------- theme
  Kit.theme = {
    get: function () { return Kit.uiState.get().theme || 'system'; },
    effective: function () {
      var t = Kit.theme.get();
      if (t !== 'system') return t;
      try { return window.matchMedia('(prefers-color-scheme: light)').matches ? 'parchment' : 'night'; } catch (e) { return 'night'; }
    },
    apply: function () {
      var t = Kit.theme.get();
      if (t === 'system') document.documentElement.removeAttribute('data-theme');
      else document.documentElement.setAttribute('data-theme', t);
      var eff = Kit.theme.effective();
      var btn = document.getElementById('btnTheme');
      if (btn) btn.innerHTML = Kit.icon(eff === 'night' ? 'sun' : 'moon');
      var meta = document.querySelector('meta[name="theme-color"]');
      if (meta) meta.setAttribute('content', eff === 'night' ? '#10121a' : '#efe4c8');
      Kit.emit('theme', eff);
    },
    set: function (t) { Kit.uiState.set({ theme: t }); Kit.theme.apply(); },
    toggle: function () { Kit.theme.set(Kit.theme.effective() === 'night' ? 'parchment' : 'night'); }
  };

  // ---------------------------------------------------------------- top bar dialogs
  Kit.openSlots = function () {
    Kit.ui.dialog({
      title: 'Project slots',
      body: function (b, h) {
        function paint() {
          U.clear(b);
          var intro = U.el('p', 'muted');
          intro.textContent = 'Four named slots live in this browser. Your working draft autosaves separately.';
          b.appendChild(intro);
          Kit.bundle.slots.list().forEach(function (s, i) {
            var row = U.el('div', 'slot-row');
            var info = U.el('div', 'slot-info');
            info.innerHTML = s ? '<strong>' + (i + 1) + '. ' + U.esc(s.name) + '</strong><small>' + U.esc(s.title) + ' &middot; ' + U.esc(U.fmtDate(s.savedAt)) + ' &middot; ' + U.esc(U.fmtSize(s.size)) + ' &middot; <code>' + U.esc(s.hash.slice(0, 10)) + '</code></small>'
              : '<strong>' + (i + 1) + '. Empty slot</strong><small>Save the current project here.</small>';
            row.appendChild(info);
            var btns = U.el('div', 'btn-row');
            var sv = U.el('button', 'btn', Kit.icon('save') + '<span>' + (s ? 'Overwrite' : 'Save here') + '</span>'); sv.type = 'button';
            sv.addEventListener('click', function () {
              var go = s ? Kit.ui.confirm({ title: 'Overwrite slot ' + (i + 1) + '?', message: '"' + s.name + '" will be replaced with the current project.', okLabel: 'Overwrite', danger: true }) : Promise.resolve(true);
              go.then(function (ok) {
                if (!ok) return null;
                return Kit.ui.prompt({ title: 'Name this slot', label: 'Slot name', value: current.kit.title, okLabel: 'Save' });
              }).then(function (name) {
                if (name == null) return;
                if (Kit.bundle.slots.save(i, name.trim() || current.kit.title)) Kit.ui.toast('Saved to slot ' + (i + 1) + '.', 'ok');
                paint();
              });
            });
            btns.appendChild(sv);
            if (s) {
              var ld = U.el('button', 'btn btn-primary', '<span>Load</span>'); ld.type = 'button';
              ld.addEventListener('click', function () {
                Kit.ui.confirm({ title: 'Load slot ' + (i + 1) + '?', message: 'The current working draft will be replaced by "' + s.name + '". Save it to a slot first if you want to keep it.', okLabel: 'Load' }).then(function (ok) {
                  if (!ok) return;
                  try { Kit.bundle.slots.load(i); Kit.ui.toast('Loaded "' + s.name + '".', 'ok'); h.close(); } catch (e) { Kit.ui.toast(e.message, 'error'); }
                });
              });
              var dl = U.el('button', 'btn btn-danger btn-icon', Kit.icon('trash')); dl.type = 'button'; dl.setAttribute('aria-label', 'Delete slot ' + (i + 1)); dl.title = 'Delete slot';
              dl.addEventListener('click', function () {
                Kit.ui.confirm({ title: 'Delete slot ' + (i + 1) + '?', message: '"' + s.name + '" will be permanently removed from this browser.', okLabel: 'Delete', danger: true }).then(function (ok) {
                  if (!ok) return;
                  Kit.bundle.slots.delete(i); paint();
                });
              });
              btns.appendChild(ld); btns.appendChild(dl);
            }
            row.appendChild(btns);
            b.appendChild(row);
          });
        }
        paint();
      },
      actions: [
        { label: 'New project', kind: 'ghost', icon: 'plus', onClick: function (h) {
          Kit.ui.confirm({ title: 'Start a new project?', message: 'The current working draft will be replaced by an empty bundle. Save it to a slot or export it first if you want to keep it.', okLabel: 'Start new', danger: true }).then(function (ok) {
            if (!ok) return;
            return Kit.ui.prompt({ title: 'New project', label: 'Project title', value: 'Untitled Saga', okLabel: 'Create' }).then(function (t) {
              if (t == null) return;
              Kit.bundle.create(t.trim() || 'Untitled Saga');
              Kit.ui.toast('New project created.', 'ok');
              h.close();
            });
          });
          return false;
        } },
        { label: 'Close', value: null }
      ]
    });
  };

  // ---------------------------------------------------------------- engine source and export (Pass 6)
  // The ENGINE:BATTLE fence text is read from the page's own script source by marker search. The markers are assembled
  // from two pieces so that no literal marker string appears anywhere except on the two fence lines themselves.
  Kit.engine = (function () {
    var OPEN = '// === ENGINE:BATTLE' + ' BEGIN ===', CLOSE = '// === ENGINE:BATTLE' + ' END ===';
    var cache = null;
    function pageScript() {
      var list = document.getElementsByTagName('script'), i, t;
      for (i = 0; i < list.length; i++) {
        t = list[i].textContent || '';
        if (t.indexOf(OPEN) >= 0 && t.indexOf(CLOSE) >= 0) return t;
      }
      return '';
    }
    return {
      OPEN: OPEN, CLOSE: CLOSE,
      // The exact text between the two marker lines ('' when the page source cannot be read).
      source: function () {
        if (cache) return cache;
        var t = pageScript(), a = t.indexOf(OPEN), z = t.indexOf(CLOSE, a + 1);
        if (a < 0 || z < 0) return '';
        a = t.indexOf('\n', a);
        z = t.lastIndexOf('\n', z);
        if (a < 0 || z < a) return '';
        cache = t.slice(a + 1, z + 1);
        return cache;
      },
      version: function () { try { return window.ENGINE_BATTLE && window.ENGINE_BATTLE.version ? String(window.ENGINE_BATTLE.version) : 'unknown'; } catch (e) { return 'unknown'; } }
    };
  })();

  // Every valid ID mentioned inside a rules record, other than the record's own ID.
  function collectRefs(node, out, top) {
    if (typeof node === 'string') { if (Kit.ids.isValid(node)) out[node] = 1; return; }
    if (Array.isArray(node)) { node.forEach(function (n) { collectRefs(n, out, false); }); return; }
    if (U.isObj(node)) Object.keys(node).forEach(function (k) {
      if ((top && k === 'id') || k === 'name' || k === 'notes') return;
      collectRefs(node[k], out, false);
    });
  }
  Kit.exportManifest = function (bundle, res, hash) {
    var refs = {}, counts = {};
    var rules = bundle.rules || {};
    Object.keys(rules).forEach(function (p) {
      var map = rules[p], n = 0;
      if (!U.isObj(map)) return;
      Object.keys(map).forEach(function (id) {
        if (!U.isObj(map[id])) return;
        n++;
        collectRefs(map[id], refs, true);
      });
      if (n) counts[p] = n;
    });
    var chs = bundle.charter && bundle.charter.sections && Array.isArray(bundle.charter.sections.chapters) ? bundle.charter.sections.chapters : [];
    var nch = chs.filter(function (c) { return U.isObj(c) && c.id; }).length;
    if (nch) counts.chp_ = nch;
    var seen = {}, fwd = [];
    (res.forward || []).forEach(function (it) {
      if (!it.id || seen[it.id]) return;
      seen[it.id] = 1;
      fwd.push({ id: it.id, owedBy: it.owedBy == null ? null : it.owedBy });
    });
    fwd.sort(function (a, b) { return a.id < b.id ? -1 : a.id > b.id ? 1 : 0; });
    var brk = (res.broken || []).map(function (it) { return { id: it.id || null, recordId: it.recordId, fieldPath: it.fieldPath }; });
    var f = bundle.kit && bundle.kit.forges && bundle.kit.forges['146'] || {};
    var sorted = {};
    Object.keys(counts).sort().forEach(function (k) { sorted[k] = counts[k]; });
    return {
      forge: 146,
      bundleHash: hash,
      charterVersion: bundle.charter ? (bundle.charter.version || 0) : 0,
      created: f.exportedAt || U.now(),
      referenced: Object.keys(refs).sort(),
      forward: fwd,
      broken: brk,
      counts: sorted
    };
  };
  Kit.engineFile = function (hash) {
    var src = Kit.engine.source();
    if (!src) throw new Error('The engine source could not be read from the page.');
    return '/* Saga Forge ENGINE:BATTLE, engine version ' + Kit.engine.version() + '\n * Bundle hash: ' + hash + '\n * Forge 146 export. Declares one global, ENGINE_BATTLE. No dependencies. */\n' + src;
  };
  // which: 'all' or one of 'bundle', 'engine', 'manifest'. Returns {files:[{name, text, mime}], hash}.
  Kit.buildExport = function (status) {
    if (!current) throw new Error('No project is open.');
    if (Kit.codex.isOpened('rules') === false) Kit.bundle.open('rules');
    var res = Kit.refreshValidation();
    if (status === 'final' && res.broken.length) throw new Error('Final export is blocked by ' + res.broken.length + ' broken reference' + (res.broken.length > 1 ? 's' : '') + '.');
    var out = Kit.bundle.exportFile({ status: status, download: false });
    var slug = Kit.bundle.slug();
    var manifest = Kit.exportManifest(current, res, out.hash);
    return {
      hash: out.hash,
      files: [
        { key: 'bundle', name: out.filename, text: out.text, mime: 'application/json' },
        { key: 'engine', name: 'engine-battle.js', text: Kit.engineFile(out.hash), mime: 'text/javascript' },
        { key: 'manifest', name: slug + '-manifest.json', text: JSON.stringify(manifest, null, 2), mime: 'application/json' }
      ]
    };
  };

  Kit.openExport = function () {
    var res = Kit.refreshValidation();
    var s = Kit.validate.summary(res);
    var status = 'draft';
    var engineOk = !!Kit.engine.source();
    Kit.ui.dialog({
      title: 'Export forge 146',
      body: function (b) {
        var slug = Kit.bundle.slug();
        b.innerHTML = '<dl class="kv"><dt>Project</dt><dd>' + U.esc(current.kit.title) + '</dd><dt>Content hash</dt><dd><code id="expHash">' + U.esc(Kit.bundle.hash()) + '</code></dd><dt>Issues</dt><dd>' +
          '<span class="chip chip-error">' + s.errors + ' err</span> <span class="chip chip-broken">' + s.broken + ' broken</span> <span class="chip chip-forward">' + s.forward + ' fwd</span></dd></dl>';
        var rc = U.el('div', 'radio-cards');
        var finalBlocked = s.broken > 0;
        rc.innerHTML =
          '<label class="radio-card"><input type="radio" name="expStatus" value="draft" checked><span><strong>Draft</strong><br><span class="muted">Always allowed. Work in progress.</span></span></label>' +
          '<label class="radio-card' + (finalBlocked ? ' disabled' : '') + '"><input type="radio" name="expStatus" value="final"' + (finalBlocked ? ' disabled' : '') + '><span><strong>Final</strong><br><span class="muted">' + (finalBlocked ? 'Blocked by ' + s.broken + ' broken reference' + (s.broken > 1 ? 's' : '') + '.' : 'Marks forge 146 final.') + '</span></span></label>';
        b.appendChild(rc);
        Array.prototype.forEach.call(rc.querySelectorAll('input'), function (r) { r.addEventListener('change', function () { status = r.value; }); });
        if (finalBlocked) {
          b.appendChild(U.el('h3', 'section-h', 'Broken references'));
          var ul = U.el('ul');
          res.broken.slice(0, 30).forEach(function (it) { ul.appendChild(U.el('li', 'msg msg-broken', '<code>' + U.esc(it.id || '') + '</code> in ' + U.esc(recordName(it.recordId)) + ' <code>' + U.esc(it.fieldPath) + '</code>')); });
          if (res.broken.length > 30) ul.appendChild(U.el('li', 'muted', '+' + (res.broken.length - 30) + ' more'));
          b.appendChild(ul);
        }
        b.appendChild(U.el('h3', 'section-h', 'Files'));
        var list = U.el('div', 'exp-files');
        [
          ['bundle', slug + '-bundle.json', 'The project bundle with forge 146 status, rules opened, and a fresh content hash.'],
          ['engine', 'engine-battle.js', 'The battle engine exactly as it runs here, stamped with its version and the bundle hash.'],
          ['manifest', slug + '-manifest.json', 'Hash, Charter version, referenced IDs, forward references owed to other forges, broken list, counts by prefix.']
        ].forEach(function (f) {
          var row = U.el('div', 'exp-file');
          row.appendChild(U.el('div', 'exp-file-t', '<code>' + U.esc(f[1]) + '</code><span class="muted">' + U.esc(f[2]) + '</span>'));
          var bt = U.el('button', 'btn', Kit.icon('export') + '<span class="lbl">Download</span>');
          bt.type = 'button';
          if (f[0] === 'engine' && !engineOk) { bt.disabled = true; bt.title = 'The engine source could not be read from this page.'; }
          bt.addEventListener('click', function () {
            try {
              var out = Kit.buildExport(status);
              var hit = out.files.filter(function (x) { return x.key === f[0]; })[0];
              U.download(hit.name, hit.text, hit.mime);
              var hh = document.getElementById('expHash'); if (hh) hh.textContent = out.hash;
              Kit.ui.toast('Downloaded ' + hit.name + ' (' + status + ').', 'ok');
            } catch (e) { Kit.ui.toast(e.message, 'error', 7000); }
          });
          row.appendChild(bt);
          list.appendChild(row);
        });
        b.appendChild(list);
        if (!engineOk) b.appendChild(U.el('p', 'msg msg-warning', 'This page cannot read its own engine source, so engine-battle.js is unavailable.'));
      },
      actions: [
        { label: 'Close', kind: 'ghost', value: null },
        { label: 'Download all three', kind: 'primary', icon: 'export', onClick: function () {
          try {
            var out = Kit.buildExport(status);
            out.files.forEach(function (f, i) { setTimeout(function () { U.download(f.name, f.text, f.mime); }, i * 350); });
            Kit.ui.toast('Exported ' + out.files.length + ' files (' + status + '). Hash ' + out.hash.slice(0, 12) + '.', 'ok', 6000);
          } catch (e) { Kit.ui.toast(e.message, 'error', 7000); return false; }
        } }
      ]
    });
  };

  Kit.importPicked = function (file) {
    if (!file) return Promise.resolve(null);
    return Kit.ui.confirm({ title: 'Import ' + file.name + '?', message: 'The current working draft will be replaced by the imported bundle. Save it to a slot first if you want to keep it.', okLabel: 'Import' }).then(function (ok) {
      if (!ok) return null;
      return Kit.bundle.importFile(file).then(function (r) {
        if (r.matches) Kit.ui.toast('Imported "' + r.bundle.kit.title + '". Content hash verified.', 'ok');
        else Kit.ui.toast('Imported "' + r.bundle.kit.title + '", but its content hash does not match. The file was edited outside Saga Forge.', 'warn', 8000);
        return r;
      }).catch(function (e) { Kit.ui.toast(e.message, 'error', 7000); return null; });
    });
  };

  Kit.renameProject = function () {
    Kit.ui.prompt({ title: 'Rename project', label: 'Project title', value: current.kit.title, okLabel: 'Rename', validate: function (v) { return v.trim() ? null : 'Enter a title.'; } }).then(function (t) {
      if (t == null) return;
      current.kit.title = t.trim();
      Kit.bundle.touch('rename');
    });
  };

  function paintTitle() {
    var b = document.getElementById('btnTitle');
    if (b && current) { b.querySelector('.t').textContent = current.kit.title; b.title = 'Rename project: ' + current.kit.title; }
  }

  Kit.on('settings', function () {
    if (!Kit.ai.hasKey()) return;
    Array.prototype.forEach.call(document.querySelectorAll('.ai-hint'), function (h) { h.hidden = true; });
  });

  // Keep the chrome in sync with the bundle.
  Kit.on('change', function () { paintTitle(); refreshSoon(); });
  Kit.on('load', function () { paintTitle(); Kit.refreshValidation(); paintTabs(); if (activeId && !Kit.canEnter(activeId).ok) Kit.go(order[0], { silent: true }); else Kit.rerender(); });

  // ---------------------------------------------------------------- safe expression language (Pass 4a)
  // Tokenizer, shunting yard to AST, evaluator. Identical text lives in ENGINE:BATTLE (evalExpr); tests compare both.
  Kit.expr = (function () {
  'use strict';
    var FUNCS = { min: [1, 99], max: [1, 99], floor: [1, 1], ceil: [1, 1], round: [1, 1], clamp: [3, 3], pow: [2, 2], sqrt: [1, 1] };
    var FUNC_NAMES = ['min', 'max', 'floor', 'ceil', 'round', 'clamp', 'pow', 'sqrt'];
    var MAX_LEN = 2000;
    var VAR_HELP = 'Use a.<stat>, a.level, t.<stat>, t.level, power, or p.<param>.';
    var PREC = { '+': 1, '-': 1, '*': 2, '/': 2, '^': 4 };

    function fail(msg, pos) { var e = new Error(msg); if (pos != null) e.pos = pos; throw e; }
    function has(o, k) { return o !== null && typeof o === 'object' && Object.prototype.hasOwnProperty.call(o, k); }
    function isDigit(c) { return c >= '0' && c <= '9'; }
    function isIdStart(c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_'; }
    function isIdPart(c) { return isIdStart(c) || isDigit(c); }

    function tokenize(src) {
      if (typeof src !== 'string') fail('The expression must be text.');
      if (src.length > MAX_LEN) fail('The expression is longer than ' + MAX_LEN + ' characters.');
      var out = [], i = 0, n = src.length, c, j, k, d, seenDot, nx;
      while (i < n) {
        c = src.charAt(i);
        if (c === ' ' || c === '\t' || c === '\n' || c === '\r') { i++; continue; }
        if (isDigit(c) || (c === '.' && i + 1 < n && isDigit(src.charAt(i + 1)))) {
          j = i; seenDot = false;
          while (j < n) {
            d = src.charAt(j);
            if (isDigit(d)) j++;
            else if (d === '.' && !seenDot) { seenDot = true; j++; }
            else break;
          }
          nx = src.charAt(j);
          if (nx === '.') fail("Unexpected '.' at position " + (j + 1) + '.', j);
          if (nx !== '' && isIdStart(nx)) fail("Unexpected '" + nx + "' after a number at position " + (j + 1) + '.', j);
          out.push({ t: 'num', v: parseFloat(src.slice(i, j)), pos: i });
          i = j;
          continue;
        }
        if (isIdStart(c)) {
          k = i + 1;
          while (k < n && isIdPart(src.charAt(k))) k++;
          if (src.charAt(k) === '.' && k + 1 < n && isIdStart(src.charAt(k + 1))) {
            k++;
            while (k < n && isIdPart(src.charAt(k))) k++;
          }
          out.push({ t: 'id', v: src.slice(i, k), pos: i });
          i = k;
          continue;
        }
        if (c === '+' || c === '-' || c === '*' || c === '/' || c === '^') { out.push({ t: 'op', v: c, pos: i }); i++; continue; }
        if (c === '(') { out.push({ t: 'lp', pos: i }); i++; continue; }
        if (c === ')') { out.push({ t: 'rp', pos: i }); i++; continue; }
        if (c === ',') { out.push({ t: 'comma', pos: i }); i++; continue; }
        fail("Illegal character '" + c + "' at position " + (i + 1) + '.', i);
      }
      return out;
    }

    function checkVar(name, pos, opts) {
      var m, who, key, i, ok;
      if (name === 'power') return;
      m = /^([atp])\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(name);
      if (!m) fail("Unknown variable '" + name + "'. " + VAR_HELP, pos);
      who = m[1]; key = m[2];
      if (who === 'p') {
        if (opts && opts.params) {
          ok = false;
          for (i = 0; i < opts.params.length; i++) { if (opts.params[i] === key) ok = true; }
          if (!ok) fail("Unknown parameter 'p." + key + "'. Declared parameters: " + (opts.params.length ? opts.params.join(', ') : 'none') + '.', pos);
        }
        return;
      }
      if (key === 'level') return;
      if (!/^[a-z][a-z0-9]*$/.test(key)) fail("Unknown variable '" + name + "'. " + VAR_HELP, pos);
      if (opts && opts.stats) {
        ok = false;
        for (i = 0; i < opts.stats.length; i++) { if (opts.stats[i] === key) ok = true; }
        if (!ok) fail("Unknown stat '" + key + "' in " + name + '. Declared stats: ' + (opts.stats.length ? opts.stats.join(', ') : 'none') + '.', pos);
      }
    }

    // Tokenizer plus shunting yard parser. Returns an AST of {type:'num'|'var'|'un'|'bin'|'call'}.
    function parse(src, opts) {
      var toks = tokenize(src), out = [], ops = [], prev = 'start', i, t, top, nxt, prec, right, ar, argc, args, v;
      if (!toks.length) fail('The expression is empty.');
      function popApply() {
        var op = ops.pop(), r, l;
        if (op.k === 'un') {
          if (out.length < 1) fail("Missing operand after '" + op.v + "' at position " + (op.pos + 1) + '.', op.pos);
          out.push({ type: 'un', op: op.v, arg: out.pop() });
        } else {
          if (out.length < 2) fail("Missing operand for '" + op.v + "' at position " + (op.pos + 1) + '.', op.pos);
          r = out.pop(); l = out.pop();
          out.push({ type: 'bin', op: op.v, left: l, right: r });
        }
      }
      function unwindToMarker() {
        while (ops.length && ops[ops.length - 1].k !== 'lp' && ops[ops.length - 1].k !== 'fn') popApply();
      }
      for (i = 0; i < toks.length; i++) {
        t = toks[i];
        if (t.t === 'num') {
          if (prev === 'operand') fail("Missing operator before '" + t.v + "' at position " + (t.pos + 1) + '.', t.pos);
          out.push({ type: 'num', value: t.v });
          prev = 'operand';
        } else if (t.t === 'id') {
          if (prev === 'operand') fail("Missing operator before '" + t.v + "' at position " + (t.pos + 1) + '.', t.pos);
          nxt = toks[i + 1];
          if (nxt && nxt.t === 'lp') {
            if (!has(FUNCS, t.v)) fail("Unknown function '" + t.v + "'. Allowed functions: " + FUNC_NAMES.join(', ') + '.', t.pos);
            ops.push({ k: 'fn', v: t.v, argc: 0, pos: t.pos });
            i++;
            prev = 'open';
          } else {
            checkVar(t.v, t.pos, opts);
            out.push({ type: 'var', name: t.v });
            prev = 'operand';
          }
        } else if (t.t === 'lp') {
          if (prev === 'operand') fail("Missing operator before '(' at position " + (t.pos + 1) + '.', t.pos);
          ops.push({ k: 'lp', pos: t.pos });
          prev = 'open';
        } else if (t.t === 'rp') {
          if (prev === 'op' || prev === 'comma') fail("Missing operand before ')' at position " + (t.pos + 1) + '.', t.pos);
          unwindToMarker();
          if (!ops.length) fail("Unmatched ')' at position " + (t.pos + 1) + '.', t.pos);
          top = ops.pop();
          if (top.k === 'lp') {
            if (prev === 'open') fail("Empty parentheses at position " + (t.pos + 1) + '.', t.pos);
          } else {
            argc = prev === 'open' ? 0 : top.argc + 1;
            ar = FUNCS[top.v];
            if (argc < ar[0] || argc > ar[1]) {
              fail(top.v + ' takes ' + (ar[0] === ar[1] ? 'exactly ' + ar[0] : 'at least ' + ar[0]) + ' argument' + (ar[0] === 1 ? '' : 's') + ' but got ' + argc + '.', top.pos);
            }
            args = out.splice(out.length - argc, argc);
            out.push({ type: 'call', name: top.v, args: args });
          }
          prev = 'operand';
        } else if (t.t === 'comma') {
          if (prev !== 'operand') fail("Missing argument before ',' at position " + (t.pos + 1) + '.', t.pos);
          unwindToMarker();
          if (!ops.length || ops[ops.length - 1].k !== 'fn') fail("Unexpected ',' at position " + (t.pos + 1) + '. Commas only separate function arguments.', t.pos);
          ops[ops.length - 1].argc++;
          prev = 'comma';
        } else {
          v = t.v;
          if (prev === 'operand') {
            prec = PREC[v]; right = v === '^';
            while (ops.length) {
              top = ops[ops.length - 1];
              if (top.k !== 'bin' && top.k !== 'un') break;
              if (top.prec > prec || (top.prec === prec && !right)) popApply(); else break;
            }
            ops.push({ k: 'bin', v: v, prec: prec, pos: t.pos });
            prev = 'op';
          } else {
            if (v !== '-' && v !== '+') fail("Unexpected operator '" + v + "' at position " + (t.pos + 1) + '.', t.pos);
            ops.push({ k: 'un', v: v, prec: 3, pos: t.pos });
            prev = 'op';
          }
        }
      }
      if (prev !== 'operand') fail(prev === 'start' ? 'The expression is empty.' : 'The expression ends unexpectedly.');
      while (ops.length) {
        top = ops[ops.length - 1];
        if (top.k === 'lp' || top.k === 'fn') fail("Unmatched '(' at position " + (top.pos + 1) + '.', top.pos);
        popApply();
      }
      if (out.length !== 1) fail('The expression is not well formed.');
      return out[0];
    }

    function finite(v, what) {
      if (typeof v !== 'number' || !isFinite(v)) fail('The result of ' + what + ' is not a finite number.');
      return v;
    }
    function lookup(scope, name) {
      var dot, who, key, bag, v;
      if (name === 'power') v = scope ? scope.power : undefined;
      else {
        dot = name.indexOf('.'); who = name.slice(0, dot); key = name.slice(dot + 1);
        bag = scope ? (who === 'a' ? scope.a : who === 't' ? scope.t : scope.p) : undefined;
        v = has(bag, key) ? bag[key] : undefined;
      }
      if (typeof v !== 'number' || !isFinite(v)) fail('No value was supplied for ' + name + '.');
      return v;
    }
    function ev(node, scope) {
      var l, r, v, args, k;
      switch (node.type) {
        case 'num': return node.value;
        case 'var': return lookup(scope, node.name);
        case 'un': v = ev(node.arg, scope); return node.op === '-' ? -v : v;
        case 'bin':
          l = ev(node.left, scope); r = ev(node.right, scope);
          if (node.op === '+') v = l + r;
          else if (node.op === '-') v = l - r;
          else if (node.op === '*') v = l * r;
          else if (node.op === '/') { if (r === 0) fail('Division by zero.'); v = l / r; }
          else v = Math.pow(l, r);
          return finite(v, "'" + node.op + "'");
        case 'call':
          args = [];
          for (k = 0; k < node.args.length; k++) args.push(ev(node.args[k], scope));
          switch (node.name) {
            case 'min': v = Math.min.apply(null, args); break;
            case 'max': v = Math.max.apply(null, args); break;
            case 'floor': v = Math.floor(args[0]); break;
            case 'ceil': v = Math.ceil(args[0]); break;
            case 'round': v = Math.round(args[0]); break;
            case 'sqrt': if (args[0] < 0) fail('sqrt needs a value that is not negative.'); v = Math.sqrt(args[0]); break;
            case 'pow': v = Math.pow(args[0], args[1]); break;
            default:
              if (args[1] > args[2]) fail('clamp needs its low bound to be at most its high bound.');
              v = Math.min(Math.max(args[0], args[1]), args[2]);
          }
          return finite(v, node.name + '()');
        default:
          return fail('The expression is not well formed.');
      }
    }
    // scope = {a:{level, <stat>...}, t:{level, <stat>...}, power, p:{<param>...}}
    function evaluate(astOrSrc, scope, opts) {
      var ast = typeof astOrSrc === 'string' ? parse(astOrSrc, opts) : astOrSrc;
      return finite(ev(ast, scope || {}), 'the expression');
    }
    // Names of every variable an AST uses, sorted and unique.
    function variables(ast) {
      var seen = {}, list = [];
      (function walk(n) {
        var i;
        if (!n) return;
        if (n.type === 'var') { if (!seen[n.name]) { seen[n.name] = 1; list.push(n.name); } }
        else if (n.type === 'un') walk(n.arg);
        else if (n.type === 'bin') { walk(n.left); walk(n.right); }
        else if (n.type === 'call') { for (i = 0; i < n.args.length; i++) walk(n.args[i]); }
      })(ast);
      return list.sort();
    }
  return { parse: parse, evaluate: evaluate, variables: variables, FUNCTIONS: FUNC_NAMES.slice(), MAX_LEN: MAX_LEN, VAR_HELP: VAR_HELP };
  })();

  // ---------------------------------------------------------------- dev helpers
  Kit.dev = {
    // Registers a throwaway type covering every field type and opens it in the form renderer.
    fieldDemo: function () {
      Kit.codex.register({
        name: 'ZzDemo', prefix: 'rmr_', label: 'Field Type Demo', fields: [
          { key: 'name', label: 'Name', type: 'text', required: true },
          { key: 'blurb', label: 'Longtext', type: 'longtext', help: 'Multi-line text.' },
          { key: 'level', label: 'Int', type: 'int', min: 1, max: 99, required: true },
          { key: 'rate', label: 'Num', type: 'num', min: 0, max: 1 },
          { key: 'boss', label: 'Bool', type: 'bool' },
          { key: 'kind', label: 'Enum (static)', type: 'enum', values: ['magic', 'summon', 'support'] },
          { key: 'element', label: 'Enum (enumFrom)', type: 'enum', enumFrom: 'charter.ruleset.elements' },
          { key: 'ability', label: 'Ref', type: 'ref', refPrefix: 'abl_' },
          { key: 'portrait', label: 'Forward ref', type: 'ref', refPrefix: 'por_', forward: true },
          { key: 'limits', label: 'Ref list', type: 'refList', refPrefix: 'lim_' },
          { key: 'tags', label: 'List of text', type: 'list', of: { type: 'text' }, itemLabel: 'Tag' },
          { key: 'drops', label: 'List of objects', type: 'list', itemLabel: 'Drop', of: [{ key: 'itm', label: 'Item', type: 'ref', refPrefix: 'itm_' }, { key: 'chance', label: 'Chance', type: 'num', min: 0, max: 1 }] },
          { key: 'cost', label: 'Object', type: 'object', of: [{ key: 'mp', label: 'MP', type: 'int', min: 0 }, { key: 'ap', label: 'AP', type: 'int', min: 0 }] },
          { key: 'dmg', label: 'Formula', type: 'formula', help: 'Safe expression. Parsing arrives with Kit.expr.' },
          { key: 'leanings', label: 'Table (rowsFrom)', type: 'table', rowsFrom: 'charter.ruleset.stats', cell: 'num' },
          { key: 'mods', label: 'Table (free rows, columns)', type: 'table', columns: [{ key: 'rate', label: 'Rate', type: 'num' }, { key: 'note', label: 'Note', type: 'text' }] },
          { key: 'tint', label: 'Color', type: 'color' }
        ]
      });
      return Kit.form.preview('ZzDemo', { name: 'Demo record', kind: 'nonsense', portrait: 'por_hero_ab12', ability: 'abl_missing_zz99' });
    }
  };
})();
// === KIT:CORE END ===
// === WS:CHARTER BEGIN ===
(function () {
  'use strict';
  var U = Kit.util;
  var WSX = window.WS.charter = { id: 'charter' };

  var CHAT_KEY = 'saga146:charter:chat';
  var UI_KEY = 'saga146:charter:ui';
  var FIND_KEY = 'saga146:charter:issues';
  var DEFAULT_RES = { w: 256, h: 224 };
  var FORMULA_IDS = ['phys.ff6', 'mag.ff6', 'phys.sub', 'mag.flat', 'heal.std', 'var.std', 'exp.curve', 'ap.curve', 'atb.fill'];
  var ENGINE_VALUES = ['turn.atb', 'turn.rounds', 'turn.ctb'];
  var SCHED_VALUES = ['atb', 'rounds', 'conditional'];
  var PROG_VALUES = ['materia', 'jobs', 'classes'];
  var SAVE_MODES = ['savepoint', 'anywhere'];
  var CONTROL_VALUES = [
    { key: 'dpad', label: 'D pad and buttons' },
    { key: 'stick', label: 'Virtual stick and buttons' },
    { key: 'tap', label: 'Tap to move' },
    { key: 'hybrid', label: 'Hybrid: stick, tap, and buttons' }
  ];
  var GLOSS_CATS = ['person', 'place', 'faction', 'creature', 'item', 'magic', 'concept', 'other'];

  function cur() { return Kit.bundle.current(); }
  function isEmpty(v) {
    if (v === null || v === undefined || v === false) return true;
    if (typeof v === 'string') return !v.trim();
    if (Array.isArray(v)) return v.every(isEmpty);
    if (U.isObj(v)) return Object.keys(v).every(function (k) { return isEmpty(v[k]); });
    return false;
  }
  function fd(key, label, type, o) { return Object.assign({ key: key, label: label, type: type }, o || {}); }

  // ---------------------------------------------------------------- type descriptors
  var TYPES = {
    premise: { name: 'charter.premise', label: 'Premise', section: true, fields: [
      fd('title', 'Saga title', 'text', { required: true, max: 80, help: 'The name of your game.' }),
      fd('premise', 'Premise', 'longtext', { required: true, help: 'Two or three sentences: who, where, and what is at stake.' }),
      fd('setting', 'Setting', 'longtext', { required: true, help: 'The world, its regions, and its era.' }),
      fd('tone', 'Tone', 'text', { required: true, max: 160, help: 'For example hopeful, melancholy, or wry.' }),
      fd('techLevel', 'Technology level', 'text', { required: true, max: 160, help: 'For example medieval, steam age, or ruined machines.' })
    ] },
    magic: { name: 'charter.magic', label: 'Magic', section: true, fields: [
      fd('magicSystem', 'Magic system', 'longtext', { required: true, help: 'Where magic comes from, what it costs, and who can use it.' }),
      fd('weatherTie', 'Weather tie', 'longtext', { help: 'How magic connects to weather, sky, or seasons. Rules can use this to ground weather states.' })
    ] },
    villain: { name: 'charter.villain', label: 'Villain', section: true, fields: [
      fd('villain', 'Villain', 'longtext', { required: true, help: 'Who they are and what they command.' }),
      fd('motive', 'Motive', 'longtext', { required: true, help: 'Why they do it. The best motives are almost sympathetic.' })
    ] },
    protagonist: { name: 'charter.protagonist', label: 'Protagonist', section: true, fields: [
      fd('protagonist', 'Protagonist', 'longtext', { required: true, help: 'Who they are, what they want, and what stands in the way.' })
    ] },
    party: { name: 'charter.party', label: 'Starting Party', section: true, fields: [
      fd('members', 'Starting party members', 'list', { required: true, itemLabel: 'Member', help: 'The companions who begin the journey with the hero. The target is eight members, but you can add more or fewer.', of: [
        fd('name', 'Name', 'text', { required: true, max: 60 }),
        fd('past', 'Past', 'longtext', { required: true, max: 300, help: 'One sentence about who they were before the story.' })
      ] })
    ] },
    endings: { name: 'charter.endings', label: 'Endings', section: true, fields: [
      fd('endings', 'Ending concepts', 'list', { required: true, itemLabel: 'Ending', of: [
        fd('name', 'Name', 'text', { required: true, max: 80 }),
        fd('concept', 'Concept', 'longtext', { required: true })
      ] })
    ] },
    themes: { name: 'charter.themes', label: 'Themes', section: true, fields: [
      fd('themes', 'Themes', 'list', { required: true, itemLabel: 'Theme', of: { type: 'text' }, help: 'Short phrases such as "grief and memory" or "borrowed time".' })
    ] },
    canon: { name: 'charter.canon', label: 'Canon', section: true, fields: [
      fd('canon', 'Canon rules', 'list', { itemLabel: 'Rule', help: 'One statement per rule. Each rule gets a permanent ID.', of: [
        fd('statement', 'Statement', 'longtext', { required: true, max: 400 })
      ] })
    ] },
    glossary: { name: 'charter.glossary', label: 'Glossary', section: true, fields: [
      fd('glossary', 'Terms', 'list', { itemLabel: 'Term', of: [
        fd('term', 'Term', 'text', { required: true, max: 80 }),
        fd('category', 'Category', 'enum', { values: GLOSS_CATS }),
        fd('definition', 'Definition', 'longtext', { required: true, max: 500 })
      ] })
    ] },
    specs: { name: 'charter.specs', label: 'Specs', section: true, fields: [
      fd('tileSize', 'Tile size in pixels', 'int', { required: true, min: 8, max: 64, help: 'Square tiles. Sixteen is common for this style.' }),
      fd('resolution', 'Internal resolution', 'object', { help: 'Width and height of the game canvas. Empty uses 256 by 224.', of: [
        fd('w', 'Width', 'int', { min: 64, max: 1920, placeholder: '256' }),
        fd('h', 'Height', 'int', { min: 64, max: 1080, placeholder: '224' })
      ] }),
      fd('paletteSize', 'Palette size', 'int', { required: true, min: 2, max: 256, help: 'Number of colors in the master palette.' }),
      fd('mobileControls', 'Mobile control scheme', 'enum', { required: true, values: CONTROL_VALUES })
    ] },
    quotas: { name: 'charter.quotas', label: 'Quotas', section: true, fields: [
      fd('towns', 'Towns', 'int', { required: true, min: 0, max: 99 }),
      fd('dungeons', 'Dungeons', 'int', { required: true, min: 0, max: 99 }),
      fd('enemyFamilies', 'Enemy families', 'int', { required: true, min: 0, max: 200 }),
      fd('bosses', 'Bosses', 'int', { required: true, min: 0, max: 200 }),
      fd('targetPlayHours', 'Target play hours', 'num', { required: true, min: 1, max: 500 })
    ] },
    ruleset: { name: 'charter.ruleset', label: 'Ruleset', section: true, fields: [
      fd('battleEngine', 'Battle engine', 'enum', { required: true, values: ENGINE_VALUES, help: 'turn.atb is Active Time Battle. turn.rounds is classic rounds. turn.ctb is a forecast queue.' }),
      fd('scheduler', 'Scheduler', 'enum', { required: true, values: SCHED_VALUES }),
      fd('progression', 'Progression', 'enum', { required: true, values: PROG_VALUES, help: 'Materia, jobs, or classes. Codex generates the matching record type.' }),
      fd('battle', 'Battle options', 'object', { of: [
        fd('waitMode', 'Wait mode', 'bool', { help: 'Pause the gauges while a menu is open.' }),
        fd('tickRate', 'Tick rate', 'int', { min: 1, max: 240 })
      ] }),
      fd('savePolicy', 'Save policy', 'object', { required: true, of: [
        fd('slots', 'Slots', 'int', { required: true, min: 1, max: 16 }),
        fd('mode', 'Mode', 'enum', { required: true, values: SAVE_MODES }),
        fd('suspend', 'Suspend save', 'bool', { help: 'Allow a temporary save that is deleted when loaded.' })
      ] }),
      fd('stats', 'Stats', 'list', { required: true, itemLabel: 'Stat', help: 'Every stat is editable. Keys are lowercase letters and digits.', of: [
        fd('key', 'Key', 'text', { required: true, max: 12 }),
        fd('label', 'Label', 'text', { required: true, max: 30 }),
        fd('min', 'Min', 'int', { min: 0, max: 99999 }),
        fd('max', 'Max', 'int', { min: 1, max: 99999 })
      ] }),
      fd('elements', 'Elements', 'list', { itemLabel: 'Element', of: [
        fd('key', 'Key', 'text', { required: true, max: 16 }),
        fd('label', 'Label', 'text', { required: true, max: 30 }),
        fd('color', 'Color', 'color')
      ] }),
      fd('elementRelations', 'Element relations', 'list', { itemLabel: 'Relation', help: 'Opposed pairs. Each side is the other side\'s weakness.', of: [
        fd('a', 'Element A', 'enum', { required: true, enumFrom: 'charter.ruleset.elements' }),
        fd('b', 'Element B', 'enum', { required: true, enumFrom: 'charter.ruleset.elements' }),
        fd('kind', 'Kind', 'enum', { required: true, values: ['opposed'] })
      ] }),
      fd('taxonomy', 'Taxonomy', 'object', { help: 'A label and the values that classify enemy families. Inverted values are healed by damage and hurt by healing.', of: [
        fd('label', 'Label', 'text', { max: 30 }),
        fd('values', 'Values', 'list', { itemLabel: 'Value', of: { type: 'text' } }),
        fd('inverts', 'Inverted values', 'list', { itemLabel: 'Value', of: { type: 'text' } })
      ] }),
      fd('formulaSet', 'Formula set', 'table', { cell: 'text', rowLabel: 'Role', valueLabel: 'Formula id', help: 'Maps a role such as phys or heal to a template id or a formula record id.' })
    ] },
    chapter: { name: 'Chapter', prefix: 'chp_', label: 'Chapter', dependsOn: ['charter.sections.chapters'], fields: [
      fd('continentLabel', 'Continent label', 'text', { required: true, max: 60, help: 'Where this chapter takes place, for example "Northern Reach".' }),
      fd('summary', 'Summary', 'longtext', { required: true }),
      fd('targetMinutes', 'Target minutes', 'int', { required: true, min: 1, max: 600, help: 'How long an average player should take.' })
    ] }
  };
  Object.keys(TYPES).forEach(function (k) { Kit.codex.register(TYPES[k]); });

  // ---------------------------------------------------------------- presets
  function defaultStats() {
    return [
      { key: 'hp', label: 'HP', min: 1, max: 9999 }, { key: 'mp', label: 'MP', min: 0, max: 999 },
      { key: 'str', label: 'Strength', min: 1, max: 99 }, { key: 'mag', label: 'Magic', min: 1, max: 99 },
      { key: 'def', label: 'Defense', min: 0, max: 255 }, { key: 'mdef', label: 'Magic Defense', min: 0, max: 255 },
      { key: 'spd', label: 'Speed', min: 1, max: 99 }, { key: 'luck', label: 'Luck', min: 0, max: 99 }
    ];
  }
  var PRESETS = {
    saga: function () {
      return {
        preset: 'saga', battleEngine: 'turn.atb', scheduler: 'atb', schedulerConfig: { gaugeMax: 65536 }, progression: 'materia',
        stats: defaultStats(),
        elements: [
          { key: 'fire', label: 'Fire', color: '#e4572e' }, { key: 'water', label: 'Water', color: '#3a86c8' },
          { key: 'earth', label: 'Earth', color: '#8a6a3d' }, { key: 'air', label: 'Air', color: '#9ad1d4' },
          { key: 'holy', label: 'Holy', color: '#f2d16b' }, { key: 'unholy', label: 'Unholy', color: '#7b4a9e' }
        ],
        elementRelations: [{ a: 'fire', b: 'water', kind: 'opposed' }, { a: 'earth', b: 'air', kind: 'opposed' }, { a: 'holy', b: 'unholy', kind: 'opposed' }],
        taxonomy: { label: 'Type', values: ['fire', 'water', 'earth', 'air', 'holy', 'unholy'], inverts: ['unholy'] },
        formulaSet: { phys: 'phys.ff6', mag: 'mag.ff6', heal: 'heal.std', exp: 'exp.curve', ap: 'ap.curve', atb: 'atb.fill', 'var': 'var.std' },
        savePolicy: { slots: 4, mode: 'savepoint', suspend: true },
        battle: { waitMode: true, tickRate: 30 }
      };
    },
    classic: function () {
      return {
        preset: 'classic', battleEngine: 'turn.rounds', scheduler: 'rounds', schedulerConfig: {}, progression: 'classes',
        stats: defaultStats(),
        elements: [
          { key: 'fire', label: 'Fire', color: '#e4572e' }, { key: 'ice', label: 'Ice', color: '#8fd3f4' },
          { key: 'lightning', label: 'Lightning', color: '#f5d442' }, { key: 'earth', label: 'Earth', color: '#8a6a3d' }
        ],
        elementRelations: [],
        taxonomy: { label: 'Kind', values: ['fire', 'ice', 'lightning', 'earth'], inverts: [] },
        formulaSet: { phys: 'phys.sub', mag: 'mag.flat', heal: 'heal.std', exp: 'exp.curve', 'var': 'var.std' },
        savePolicy: { slots: 3, mode: 'anywhere', suspend: false },
        battle: { waitMode: false, tickRate: 30 }
      };
    },
    custom: function () {
      return { preset: 'custom', schedulerConfig: {}, stats: [], elements: [], elementRelations: [], taxonomy: { label: '', values: [], inverts: [] }, formulaSet: {}, savePolicy: {}, battle: {} };
    }
  };
  var PRESET_INFO = {
    saga: { title: 'Saga Preset', text: 'Active Time Battle with wait mode, materia progression, six elements with three opposed pairs, and four savepoint slots with suspend saves.' },
    classic: { title: 'Classic Preset', text: 'Round based turns, class progression, four elements with no relations, and three slots that save anywhere.' },
    custom: { title: 'Custom', text: 'A blank slate. Declare the engine, scheduler, progression, stats, and elements yourself.' }
  };
  WSX.PRESETS = PRESETS;
  WSX.defaultStats = defaultStats;
  WSX.resolution = function (b) {
    b = b || cur();
    var r = b && b.charter && b.charter.specs && b.charter.specs.resolution;
    return r && r.w > 0 && r.h > 0 ? { w: r.w, h: r.h } : { w: DEFAULT_RES.w, h: DEFAULT_RES.h };
  };

  // ---------------------------------------------------------------- sections
  function plain(key) {
    return {
      peek: function (b) { var s = b.charter.sections; return s && U.isObj(s[key]) ? s[key] : {}; },
      commit: function (b, rec) { if (!U.isObj(b.charter.sections)) b.charter.sections = {}; b.charter.sections[key] = rec; }
    };
  }
  function top(key) {
    return {
      peek: function (b) { return U.isObj(b.charter[key]) ? b.charter[key] : {}; },
      commit: function (b, rec) { b.charter[key] = rec; }
    };
  }
  function wrapList(key) {
    return {
      peek: function (b) { var o = {}; o[key] = Array.isArray(b.charter[key]) ? b.charter[key] : []; return o; },
      commit: function (b, rec) { b.charter[key] = Array.isArray(rec[key]) ? rec[key] : []; }
    };
  }
  function mk(id, label, help, storage, extra) { return Object.assign({ id: id, label: label, help: help, kind: 'form' }, storage, extra || {}); }

  function item(sec, path, message, level, rid) {
    return { recordId: rid || ('charter:' + sec.id), fieldPath: path, message: message, level: level || 'error' };
  }
  function keyProblems(sec, arr, base, what, out) {
    var seen = {};
    (Array.isArray(arr) ? arr : []).forEach(function (s, i) {
      if (!U.isObj(s) || !s.key) return;
      var k = String(s.key);
      if (!/^[a-z][a-z0-9]*$/.test(k)) out.push(item(sec, base + '[' + i + '].key', what + ' key "' + k + '" must be lowercase letters and digits, starting with a letter.'));
      if (seen[k]) out.push(item(sec, base + '[' + i + '].key', 'Duplicate ' + what.toLowerCase() + ' key "' + k + '".'));
      seen[k] = 1;
    });
  }

  var SECTIONS = [
    mk('premise', 'Premise', 'The seed of the saga: what it is, where it happens, and how it feels.', plain('premise'), { type: TYPES.premise }),
    mk('magic', 'Magic', 'How magic works in this world, and how it ties to weather and the sky.', plain('magic'), { type: TYPES.magic }),
    mk('villain', 'Villain', 'The opposing force and the reason behind it.', plain('villain'), { type: TYPES.villain }),
    mk('protagonist', 'Protagonist', 'The hero at the center of the story.', plain('protagonist'), { type: TYPES.protagonist }),
    mk('party', 'Starting Party', 'The companions who begin the journey with the hero. The target is eight, but the list is not capped. Recruiting more along the way is planned for the World and Story days.', plain('party'), { type: TYPES.party, extra: function (b, rec) {
      var out = [], S = SECTION_BY.party, m = Array.isArray(rec.members) ? rec.members : [];
      if (m.length && m.length < 8) out.push(item(S, 'members', 'The target is eight starting party members and you have ' + m.length + '.', 'warning'));
      var seen = {};
      m.forEach(function (x, i) {
        var n = U.isObj(x) && x.name ? String(x.name).trim().toLowerCase() : '';
        if (n && seen[n]) out.push(item(S, 'members[' + i + '].name', 'Another party member is also named "' + x.name + '".', 'warning'));
        if (n) seen[n] = 1;
      });
      return out;
    } }),
    mk('chapters', 'Chapters', 'The chapter outline. Each chapter is a record with a permanent ID that later stages refer to.', {
      peek: function (b) { var s = b.charter.sections; return s && Array.isArray(s.chapters) ? s.chapters : []; },
      commit: function (b, arr) { if (!U.isObj(b.charter.sections)) b.charter.sections = {}; b.charter.sections.chapters = arr; }
    }, { kind: 'chapters', type: null, extra: function (b, arr, strict) {
      var out = [], S = SECTION_BY.chapters;
      if (strict && !arr.length) out.push(item(S, '', 'Add at least one chapter.'));
      if (strict) {
        arr.forEach(function (rec) {
          Kit.validate.record('Chapter', rec, { bundle: b }).forEach(function (it) { if (it.level === 'error' || it.level === 'broken') out.push(it); });
        });
      }
      var total = arr.reduce(function (n, r) { return n + (U.isObj(r) && typeof r.targetMinutes === 'number' ? r.targetMinutes : 0); }, 0);
      var hours = b.charter.quotas && b.charter.quotas.targetPlayHours;
      if (arr.length && typeof hours === 'number' && hours > 0 && total > 0) {
        var ratio = total / 60 / hours;
        if (ratio < 0.7 || ratio > 1.3) out.push(item(S, '', 'Chapter minutes add up to ' + (total / 60).toFixed(1) + ' hours, which is far from the target of ' + hours + ' hours.', 'warning'));
      }
      var seen = {};
      arr.forEach(function (r) {
        var n = U.isObj(r) && r.name ? String(r.name).trim().toLowerCase() : '';
        if (n && seen[n]) out.push(item(S, 'name', 'Two chapters are named "' + r.name + '".', 'warning', r.id));
        if (n) seen[n] = 1;
      });
      return out;
    } }),
    mk('endings', 'Endings', 'The ways the story can conclude.', plain('endings'), { type: TYPES.endings }),
    mk('themes', 'Themes', 'The ideas the saga keeps returning to.', plain('themes'), { type: TYPES.themes, extra: function (b, rec, strict) {
      var out = [], S = SECTION_BY.themes, arr = Array.isArray(rec.themes) ? rec.themes : [];
      var filled = arr.filter(function (t) { return typeof t === 'string' && t.trim(); });
      if (strict && arr.length && !filled.length) out.push(item(S, 'themes', 'Write at least one theme.'));
      arr.forEach(function (t, i) { if (!(typeof t === 'string' && t.trim())) out.push(item(S, 'themes[' + i + ']', 'This theme is empty. Fill it in or remove it.', 'warning')); });
      return out;
    } }),
    mk('canon', 'Canon', 'Rules of the world that must never be contradicted. The interviewer checks new material against these.', wrapList('canon'), { type: TYPES.canon, after: function (b) { ensureCanonIds(b); } }),
    mk('glossary', 'Glossary', 'Names and terms with a short definition and a category.', wrapList('glossary'), { type: TYPES.glossary, extra: function (b, rec) {
      var out = [], S = SECTION_BY.glossary, seen = {};
      (rec.glossary || []).forEach(function (t, i) {
        var n = U.isObj(t) && t.term ? String(t.term).trim().toLowerCase() : '';
        if (n && seen[n]) out.push(item(S, 'glossary[' + i + '].term', 'The term "' + t.term + '" is defined twice.', 'warning'));
        if (n) seen[n] = 1;
      });
      return out;
    } }),
    mk('specs', 'Specs', 'Technical targets for the game canvas and controls.', top('specs'), { type: TYPES.specs, extra: function (b, rec) {
      var out = [], S = SECTION_BY.specs, res = WSX.resolution(b), t = rec.tileSize;
      var r0 = U.isObj(rec.resolution) ? rec.resolution : {};
      if ((r0.w > 0) !== (r0.h > 0)) out.push(item(S, 'resolution', 'Set both width and height, or leave both empty to use 256 by 224.'));
      if (typeof t === 'number' && t > 0 && (res.w % t || res.h % t)) out.push(item(S, 'resolution', 'The resolution ' + res.w + ' by ' + res.h + ' is not a whole number of ' + t + ' pixel tiles.', 'warning'));
      return out;
    } }),
    mk('quotas', 'Quotas', 'How much content the saga should contain.', top('quotas'), { type: TYPES.quotas }),
    mk('ruleset', 'Ruleset', 'Choose the battle rules the whole project is built on.', top('ruleset'), { kind: 'ruleset', type: TYPES.ruleset, extra: function (b, rs, strict) {
      var out = [], S = SECTION_BY.ruleset;
      function e(path, msg, level) { out.push(item(S, path, msg, level)); }
      if (strict && !rs.preset) { e('preset', 'Choose a ruleset: Saga, Classic, or Custom.'); return out; }
      if (!rs.preset) return out;
      keyProblems(S, rs.stats, 'stats', 'Stat', out);
      (rs.stats || []).forEach(function (s, i) { if (U.isObj(s) && typeof s.min === 'number' && typeof s.max === 'number' && s.min > s.max) e('stats[' + i + '].max', 'Max must be at least min.'); });
      keyProblems(S, rs.elements, 'elements', 'Element', out);
      var ekeys = (rs.elements || []).map(function (x) { return U.isObj(x) ? x.key : null; }).filter(Boolean);
      if (!ekeys.length) e('elements', 'No elements are declared, so abilities will have no element to choose.', 'warning');
      var pairs = {};
      (rs.elementRelations || []).forEach(function (r, i) {
        if (!U.isObj(r) || !r.a || !r.b) return;
        if (r.a === r.b) e('elementRelations[' + i + ']', 'An element cannot oppose itself.');
        var pk = [r.a, r.b].sort().join('|');
        if (pairs[pk]) e('elementRelations[' + i + ']', 'The pair ' + r.a + ' and ' + r.b + ' is declared twice.', 'warning');
        pairs[pk] = 1;
      });
      var tax = U.isObj(rs.taxonomy) ? rs.taxonomy : {};
      if (Array.isArray(tax.values) && tax.values.length && !String(tax.label || '').trim()) e('taxonomy.label', 'Give the taxonomy a label such as Type or Kind.');
      (Array.isArray(tax.inverts) ? tax.inverts : []).forEach(function (v, i) {
        if ((tax.values || []).indexOf(v) < 0) e('taxonomy.inverts[' + i + ']', 'Inverted value "' + v + '" is not one of the taxonomy values.');
      });
      var fs = U.isObj(rs.formulaSet) ? rs.formulaSet : {};
      Object.keys(fs).forEach(function (role) {
        var v = fs[role];
        if (typeof v === 'string' && v && FORMULA_IDS.indexOf(v) < 0 && !(Kit.ids.isValid(v) && Kit.ids.prefixOf(v) === 'frm_')) e('formulaSet.' + role, 'Unknown formula id "' + v + '". Use a template id or a formula record id.', 'warning');
      });
      if (rs.battleEngine === 'turn.atb' && rs.scheduler && rs.scheduler !== 'atb') e('scheduler', 'The turn.atb engine expects the atb scheduler.', 'warning');
      if (rs.battleEngine === 'turn.rounds' && rs.scheduler && rs.scheduler !== 'rounds') e('scheduler', 'The turn.rounds engine expects the rounds scheduler.', 'warning');
      return out;
    } })
  ];
  var SECTION_BY = {};
  SECTIONS.forEach(function (s) { SECTION_BY[s.id] = s; });
  WSX.sections = SECTIONS;

  function ensureCanonIds(b) {
    var arr = b.charter.canon;
    if (!Array.isArray(arr)) return false;
    var used = {}, changed = false;
    arr.forEach(function (c) { if (U.isObj(c) && c.id) used[c.id] = 1; });
    arr.forEach(function (c) {
      if (!U.isObj(c) || c.id) return;
      var id;
      do { id = 'can_' + U.rand36(8); } while (used[id]);
      used[id] = 1; c.id = id; changed = true;
    });
    return changed;
  }

  // ---------------------------------------------------------------- issues
  function sectionItems(b, sec, strict) {
    var rec = sec.peek(b), items = [];
    if (sec.type) items = Kit.validate.record(sec.type.name, rec, { bundle: b, draftId: 'charter:' + sec.id });
    if (sec.extra) items = items.concat(sec.extra(b, rec, strict) || []);
    if (!strict && isEmpty(rec)) return [];
    return items;
  }
  function isBlocking(it) { return it.level === 'error' || it.level === 'broken'; }
  WSX.sectionItems = sectionItems;
  WSX.lockCheck = function (b) {
    b = b || cur();
    var items = [];
    SECTIONS.forEach(function (sec) { items = items.concat(sectionItems(b, sec, true).filter(isBlocking)); });
    return { ok: items.length === 0, items: items };
  };
  Kit.validate.register('charter', function (b) {
    var out = [];
    SECTIONS.forEach(function (sec) { out = out.concat(sectionItems(b, sec, false)); });
    return out;
  });
  function secStatus(b, sec) {
    var items = sectionItems(b, sec, true);
    var blocking = items.filter(isBlocking).length;
    return { blocking: blocking, warnings: items.filter(function (i) { return i.level === 'warning'; }).length, started: !isEmpty(sec.peek(b)), done: blocking === 0 };
  }

  // ---------------------------------------------------------------- fingerprints and amendments
  var PRINT_KEYS = ['sections', 'specs', 'quotas', 'canon', 'glossary', 'ruleset'];
  function h10(v) { return U.sha256(U.canonical(v)).slice(0, 10); }
  function flatten(v, path, out) {
    if (Array.isArray(v)) {
      if (!v.length) out[path] = h10(v);
      else v.forEach(function (x, i) { flatten(x, path + '[' + (U.isObj(x) && typeof x.id === 'string' && x.id ? x.id : i) + ']', out); });
    } else if (U.isObj(v)) {
      var ks = Object.keys(v);
      if (!ks.length) out[path] = h10(v);
      else ks.forEach(function (k) { flatten(v[k], path + '.' + k, out); });
    } else out[path] = h10(v === undefined ? null : v);
  }
  function fingerprint(b) {
    var out = {};
    PRINT_KEYS.forEach(function (k) { if (b.charter[k] !== undefined) flatten(b.charter[k], 'charter.' + k, out); });
    return out;
  }
  function diffPrints(a, c) {
    var out = [];
    Object.keys(c).forEach(function (p) { if (a[p] !== c[p]) out.push(p); });
    Object.keys(a).forEach(function (p) { if (c[p] === undefined) out.push(p); });
    return out.sort();
  }
  function segs(p) {
    p = String(p || '').replace(/^charter\./, '').replace(/^sections\./, '');
    return p.split(/[.\[\]]+/).filter(Boolean);
  }
  function overlap(a, c) {
    var x = segs(a), y = segs(c), n = Math.min(x.length, y.length);
    for (var i = 0; i < n; i++) if (x[i] !== y[i]) return false;
    return true;
  }
  WSX.fingerprint = fingerprint;
  WSX.overlap = overlap;
  // Downstream records (outside the charter namespace) whose type depends on a changed path and whose charterVersion is behind.
  WSX.impact = function (b, changedPaths, newVersion) {
    b = b || cur();
    var idx = Kit.index(b), types = Kit.codex.types(b), out = [];
    Object.keys(idx.byId).forEach(function (id) {
      var e = idx.byId[id], info = Kit.codex.prefixInfo(e.prefix);
      if (!info || info.ns === 'charter') return;
      var v = Number(e.record.charterVersion) || 0;
      if (v >= newVersion) return;
      var tn = Kit.codex.typeFor(e.prefix, b), td = tn ? types[tn] : null;
      var deps = td && Array.isArray(td.dependsOn) ? td.dependsOn : [];
      var hit = [];
      deps.forEach(function (d) { if (changedPaths.some(function (p) { return overlap(d, p); }) && hit.indexOf(d) < 0) hit.push(d); });
      if (hit.length) out.push({ id: id, name: e.name, prefix: e.prefix, type: tn, charterVersion: v, dependsOn: hit });
    });
    out.sort(function (x, y) { return x.prefix.localeCompare(y.prefix) || x.name.localeCompare(y.name); });
    return out;
  };

  // ---------------------------------------------------------------- lock and amend
  function labelForPath(p) {
    var r = resolvePath(p);
    return r ? (SECTION_BY[r.sec].label + (r.field ? ' / ' + r.field : '')) : p;
  }
  function showBlockers(items) {
    var groups = {}, order = [];
    items.forEach(function (it) {
      var k = it.recordId;
      if (!groups[k]) { groups[k] = []; order.push(k); }
      groups[k].push(it);
    });
    Kit.ui.dialog({
      title: 'The Charter cannot lock yet',
      body: function (body, h) {
        body.appendChild(U.el('p', null, U.esc(items.length + ' item' + (items.length === 1 ? '' : 's') + ' still need attention. Locking needs zero Charter errors.')));
        order.forEach(function (rid) {
          var g = U.el('div', 'lock-group');
          var name = /^charter:/.test(rid) ? (SECTION_BY[rid.slice(8)] || { label: rid }).label : ((Kit.index().byId[rid] || {}).name || rid);
          g.appendChild(U.el('div', 'lock-group-head', U.esc(name)));
          groups[rid].forEach(function (it) {
            var row = U.el('div', 'lock-row');
            row.appendChild(U.el('span', null, U.esc(it.message)));
            var go = U.el('button', 'btn btn-ghost', Kit.icon('jump') + '<span>Go</span>'); go.type = 'button';
            go.addEventListener('click', function () { h.close(); WSX.focus(rid, it.fieldPath); });
            row.appendChild(go);
            g.appendChild(row);
          });
          body.appendChild(g);
        });
      },
      actions: [{ label: 'Close', kind: 'primary' }]
    });
  }
  function showDiff(result) {
    var am = result.amendment, imp = result.impact || [];
    Kit.ui.dialog({
      title: 'Charter version ' + am.to + ' recorded', wide: true,
      body: function (body) {
        body.appendChild(U.el('p', null, 'The Charter was relocked as version ' + am.to + ' (it was ' + am.from + ').' + (am.note ? ' Note: ' + U.esc(am.note) : '')));
        body.appendChild(U.el('h3', 'section-h', 'Changed paths (' + am.changedPaths.length + ')'));
        var ul = U.el('ul', 'diff-list');
        am.changedPaths.slice(0, 40).forEach(function (p) { ul.appendChild(U.el('li', null, '<span>' + U.esc(labelForPath(p)) + '</span><code>' + U.esc(p) + '</code>')); });
        if (am.changedPaths.length > 40) ul.appendChild(U.el('li', 'muted', '+' + (am.changedPaths.length - 40) + ' more'));
        body.appendChild(ul);
        body.appendChild(U.el('h3', 'section-h', 'Downstream records to review (' + imp.length + ')'));
        if (!imp.length) body.appendChild(U.el('p', 'muted', 'No downstream record depends on the changed paths, or no downstream records exist yet.'));
        else {
          var ul2 = U.el('ul', 'diff-list');
          imp.forEach(function (r) {
            ul2.appendChild(U.el('li', null, '<strong>' + U.esc(r.name) + '</strong><code>' + U.esc(r.id) + '</code><span class="chip chip-warning">v' + r.charterVersion + ' to v' + am.to + '</span><span class="muted">depends on ' + U.esc(r.dependsOn.join(', ')) + '</span>'));
          });
          body.appendChild(ul2);
          body.appendChild(U.el('p', 'muted', 'These records keep their old Charter version until you review them in Rules.'));
        }
      },
      actions: [{ label: 'Close', kind: 'primary' }]
    });
  }
  // opts: {note, quiet}. Resolves {ok, reason, version, first, unchanged, amendment, impact, items}.
  WSX.lock = async function (opts) {
    opts = opts || {};
    var b = cur(), c = b.charter;
    if (c.locked) return { ok: false, reason: 'already-locked' };
    var chk = WSX.lockCheck(b);
    if (!chk.ok) {
      if (!opts.quiet) { showBlockers(chk.items); Kit.ui.toast('Lock refused: ' + chk.items.length + ' item' + (chk.items.length === 1 ? '' : 's') + ' need attention.', 'warn'); }
      return { ok: false, reason: 'errors', items: chk.items };
    }
    var prevRes = c.specs.resolution;
    var needsRes = !U.isObj(prevRes) || !(prevRes.w > 0) || !(prevRes.h > 0);
    if (needsRes) c.specs.resolution = { w: DEFAULT_RES.w, h: DEFAULT_RES.h };
    var from = c.version || 0, result = { ok: true, first: from < 1 };
    var next = fingerprint(b);
    if (from < 1) {
      c.version = 1;
    } else {
      var prev = c.lockFingerprint && c.lockFingerprint.map;
      var changed = prev ? diffPrints(prev, next) : ['charter'];
      if (changed.length) {
        var note = opts.note;
        if (note === undefined) {
          note = await Kit.ui.prompt({ title: 'Relock the Charter', label: 'Amendment note (optional)', multiline: true, okLabel: 'Relock as version ' + (from + 1), placeholder: 'What changed and why?' });
          if (note === null) { if (needsRes) c.specs.resolution = prevRes; return { ok: false, reason: 'cancelled' }; }
        }
        var am = { from: from, to: from + 1, changedPaths: changed, at: U.now(), note: String(note || '').trim() };
        c.amendments.push(am);
        c.version = from + 1;
        result.amendment = am;
        result.impact = WSX.impact(b, changed, c.version);
      } else result.unchanged = true;
    }
    c.locked = true;
    c.lockedAt = U.now();
    c.lockFingerprint = { version: c.version, at: c.lockedAt, map: next };
    result.version = c.version;
    Kit.bundle.open('charter');
    if (b.kit.forges && b.kit.forges['146']) b.kit.forges['146'].charterVersion = c.version;
    Kit.bundle.touch('charter-lock');
    Kit.paintTabs();
    if (Kit.active() === 'charter') Kit.rerender();
    if (result.first) Kit.ui.toast('Charter locked at version 1. The Codex is now open.', 'ok', 4500);
    else if (result.unchanged) Kit.ui.toast('No changes since version ' + c.version + '. The Charter is locked again.', 'ok');
    else if (!opts.quiet) showDiff(result);
    return result;
  };
  WSX.amend = async function (opts) {
    opts = opts || {};
    var b = cur(), c = b.charter;
    if (!c.locked) return { ok: false, reason: 'not-locked' };
    if (!opts.skipConfirm) {
      var ok = await Kit.ui.confirm({ title: 'Amend the Charter?', message: 'The Charter unlocks so you can edit it. The Codex and Rules tabs close until you relock. Relocking raises the version and lists the records that need review.', okLabel: 'Amend' });
      if (!ok) return { ok: false, reason: 'cancelled' };
    }
    c.locked = false;
    Kit.bundle.touch('charter-amend');
    Kit.paintTabs();
    if (Kit.active() !== 'charter') Kit.go('charter'); else Kit.rerender();
    return { ok: true, version: c.version };
  };
  WSX.applyPreset = function (key, o) {
    o = o || {};
    var b = cur();
    if (!PRESETS[key]) throw new Error('Unknown preset ' + key + '.');
    if (b.charter.locked) return false;
    b.charter.ruleset = PRESETS[key]();
    Kit.bundle.touch('charter-preset');
    if (!o.silent && Kit.active() === 'charter') paintMain();
    return true;
  };

  // ---------------------------------------------------------------- state and layout
  var st = { section: null, ctl: null, open: {}, chapCtl: {}, navOpen: false };
  var els = { bar: null, nav: null, navWrap: null, main: null, toggle: null };
  function alive(n) { return n && document.contains(n); }
  function uiGet() { var s = Kit.store.get(UI_KEY, {}); return U.isObj(s) ? s : {}; }

  function paintBar() {
    if (!alive(els.bar)) return;
    var b = cur(), c = b.charter;
    var chk = WSX.lockCheck(b);
    U.clear(els.bar);
    var info = U.el('div', 'ch-bar-info');
    var chip = c.locked ? '<span class="chip chip-ok">Locked v' + c.version + '</span>' : c.version >= 1 ? '<span class="chip chip-warning">Amending v' + c.version + '</span>' : '<span class="chip chip-muted">Draft</span>';
    info.innerHTML = '<h2 class="panel-title">Charter ' + chip + '</h2>';
    var hint = c.locked ? 'The Codex and Rules are open. Amend the Charter to change it.'
      : c.version >= 1 ? 'The Codex and Rules are closed until you relock.' + (chk.ok ? ' Ready to relock.' : ' ' + chk.items.length + ' item' + (chk.items.length === 1 ? '' : 's') + ' to finish first.')
      : (chk.ok ? 'Every section is complete. Lock the Charter to open the Codex.' : chk.items.length + ' item' + (chk.items.length === 1 ? '' : 's') + ' to finish before the Charter can lock.');
    info.appendChild(U.el('p', 'ch-bar-hint', U.esc(hint)));
    els.bar.appendChild(info);
    var act = U.el('div', 'ch-bar-actions');
    var iv = U.el('button', 'btn', Kit.icon('spark') + '<span>Interviewer</span>'); iv.type = 'button';
    iv.addEventListener('click', openInterviewer);
    act.appendChild(iv);
    if (c.locked) {
      var am = U.el('button', 'btn', Kit.icon('edit') + '<span>Amend</span>'); am.type = 'button';
      am.addEventListener('click', function () { WSX.amend(); });
      act.appendChild(am);
    } else {
      var lk = U.el('button', 'btn btn-primary', Kit.icon('lock') + '<span>' + (c.version >= 1 ? 'Relock Charter' : 'Lock Charter') + '</span>'); lk.type = 'button';
      lk.addEventListener('click', function () { WSX.lock(); });
      act.appendChild(lk);
    }
    els.bar.appendChild(act);
  }
  function paintNav() {
    if (!alive(els.nav)) return;
    var b = cur();
    U.clear(els.nav);
    SECTIONS.forEach(function (sec) {
      var s = secStatus(b, sec);
      var btn = U.el('button', 'ch-nav-item'); btn.type = 'button'; btn.dataset.sec = sec.id;
      if (sec.id === st.section) btn.setAttribute('aria-current', 'true');
      var chips = '';
      if (s.done && !s.started) chips += '<span class="chip chip-muted">Optional</span>';
      else if (s.done) chips += '<span class="chip chip-ok" title="Complete">' + Kit.icon('check') + '</span>';
      else if (!s.started) chips += '<span class="chip chip-muted">To do</span>';
      else chips += '<span class="chip chip-error" title="Items to fix">' + s.blocking + '</span>';
      if (s.warnings && s.started) chips += '<span class="chip chip-warning" title="Warnings">' + s.warnings + '</span>';
      btn.innerHTML = '<span>' + U.esc(sec.label) + '</span><span class="ch-nav-chips">' + chips + '</span>';
      btn.setAttribute('aria-label', sec.label + ': ' + (s.done && !s.started ? 'optional' : s.done ? 'complete' : s.started ? s.blocking + ' items to fix' : 'to do'));
      btn.addEventListener('click', function () { goSection(sec.id); });
      els.nav.appendChild(btn);
    });
    if (alive(els.toggle)) els.toggle.querySelector('.cur').textContent = SECTION_BY[st.section].label;
  }
  function goSection(id, fieldPath, chapterId) {
    if (!SECTION_BY[id]) return false;
    st.section = id; st.navOpen = false;
    Kit.store.set(UI_KEY, { section: id });
    if (alive(els.nav)) els.nav.className = 'ch-nav';
    paintNav(); paintMain();
    if (id === 'chapters' && chapterId) focusChapter(chapterId, fieldPath);
    else if (fieldPath && st.ctl) st.ctl.focusPath(fieldPath);
    return true;
  }
  function touch() { Kit.bundle.touch('charter-edit'); }

  function paintMain() {
    if (!alive(els.main)) return;
    var b = cur(), c = b.charter, sec = SECTION_BY[st.section], locked = !!c.locked;
    U.clear(els.main);
    st.ctl = null; st.chapCtl = {};
    var head = U.el('div', 'ch-main-head');
    head.innerHTML = '<h2>' + U.esc(sec.label) + '</h2><p>' + U.esc(sec.help) + '</p>';
    var panel = U.el('section', 'panel');
    panel.appendChild(head);
    els.main.appendChild(panel);
    if (locked) {
      var bn = U.el('div', 'ch-banner');
      bn.appendChild(U.el('span', null, 'Locked at version ' + c.version + '. Fields are read only. Amend the Charter to edit.'));
      var ab = U.el('button', 'btn', Kit.icon('edit') + '<span>Amend</span>'); ab.type = 'button';
      ab.addEventListener('click', function () { WSX.amend(); });
      bn.appendChild(ab);
      panel.appendChild(bn);
    } else if (c.version >= 1) {
      panel.appendChild(U.el('div', 'ch-banner amending', '<span>Amending from version ' + c.version + '. Relock when you are done to record what changed.</span>'));
    }
    if (sec.kind === 'chapters') paintChapters(panel, sec, b, locked);
    else if (sec.kind === 'ruleset') paintRuleset(panel, sec, b, locked);
    else {
      var host = U.el('div');
      panel.appendChild(host);
      var rec = sec.peek(b);
      st.ctl = Kit.form.render(host, sec.type.name, rec, function () {
        sec.commit(b, rec);
        if (sec.after) sec.after(b, rec);
        touch();
      }, { readOnly: locked });
    }
  }

  // ---- chapters
  function chapterRefs(b, id) {
    var out = [], idx = Kit.index(b);
    Object.keys(idx.byId).forEach(function (rid) {
      var e = idx.byId[rid];
      if (rid === id || e.prefix === 'chp_') return;
      if (JSON.stringify(e.record).indexOf('"' + id + '"') >= 0) out.push(e.name);
    });
    return out;
  }
  function addChapterRecord(rec) {
    var b = cur(), arr = SECTION_BY.chapters.peek(b);
    arr.push(rec);
    SECTION_BY.chapters.commit(b, arr);
    return rec;
  }
  function paintChapters(panel, sec, b, locked) {
    var arr = sec.peek(b);
    var tools = U.el('div', 'chap-tools');
    var total = arr.reduce(function (n, r) { return n + (U.isObj(r) && typeof r.targetMinutes === 'number' ? r.targetMinutes : 0); }, 0);
    var hours = b.charter.quotas && b.charter.quotas.targetPlayHours;
    tools.appendChild(U.el('div', 'grow', U.esc(arr.length ? arr.length + ' chapter' + (arr.length === 1 ? '' : 's') + ', about ' + (total / 60).toFixed(1) + ' hours' + (typeof hours === 'number' ? ' against a target of ' + hours : '') + '.' : 'No chapters yet.')));
    if (!locked) {
      var add = U.el('button', 'btn btn-primary', Kit.icon('plus') + '<span>Add chapter</span>'); add.type = 'button';
      add.addEventListener('click', function () {
        Kit.ui.prompt({ title: 'Add a chapter', label: 'Chapter name', okLabel: 'Add', validate: function (v) { return v.trim() ? null : 'Enter a name.'; } }).then(function (name) {
          if (name == null) return;
          var rec = { id: Kit.ids.mint('chp_', name.trim()), name: name.trim(), charterVersion: b.charter.version || 0 };
          addChapterRecord(rec);
          st.open[rec.id] = true;
          touch(); paintMain();
          focusChapter(rec.id);
        });
      });
      tools.appendChild(add);
    }
    panel.appendChild(tools);
    var list = U.el('div', 'chap-list');
    panel.appendChild(list);
    if (!arr.length) {
      list.appendChild(U.el('div', 'empty-line', locked ? 'This Charter has no chapters.' : 'Chapters are the spine of the saga. Add the first one to begin the outline.'));
    }
    arr.forEach(function (rec, i) {
      var card = U.el('div', 'chap-card'); card.dataset.id = rec.id;
      var headEl = U.el('div', 'chap-head');
      var title = U.el('div', 'chap-title');
      var meta = U.el('div', 'chap-meta');
      var ctrls = U.el('div', 'chap-ctrls');
      function paintHead() {
        title.innerHTML = '<span class="chap-num">Chapter ' + (i + 1) + '</span><span class="chap-name">' + U.esc(rec.name || '(unnamed)') + '</span>';
        var bad = Kit.validate.record('Chapter', rec, { bundle: cur() }).filter(isBlocking).length;
        meta.innerHTML = (rec.continentLabel ? '<span class="chip chip-muted">' + U.esc(rec.continentLabel) + '</span>' : '') +
          (typeof rec.targetMinutes === 'number' ? '<span class="chip chip-muted">' + rec.targetMinutes + ' min</span>' : '') +
          (bad ? '<span class="chip chip-error">' + bad + ' to fix</span>' : '<span class="chip chip-ok">' + Kit.icon('check') + '</span>');
      }
      function btn(icon, label, fn, cls) {
        var x = U.el('button', 'btn btn-ghost btn-icon' + (cls ? ' ' + cls : ''), Kit.icon(icon)); x.type = 'button'; x.setAttribute('aria-label', label); x.title = label;
        x.addEventListener('click', fn); return x;
      }
      var body = U.el('div', 'chap-body');
      body.hidden = !st.open[rec.id];
      var toggle = btn('edit', (st.open[rec.id] ? 'Collapse' : 'Edit') + ' chapter ' + (i + 1), function () {
        st.open[rec.id] = !st.open[rec.id];
        body.hidden = !st.open[rec.id];
        if (st.open[rec.id] && !body.firstChild) buildForm();
      });
      ctrls.appendChild(toggle);
      if (!locked) {
        ctrls.appendChild(btn('up', 'Move chapter up', function () { if (i > 0) { var t = arr[i - 1]; arr[i - 1] = arr[i]; arr[i] = t; touch(); paintMain(); } }));
        ctrls.appendChild(btn('down', 'Move chapter down', function () { if (i < arr.length - 1) { var t = arr[i + 1]; arr[i + 1] = arr[i]; arr[i] = t; touch(); paintMain(); } }));
        ctrls.appendChild(btn('trash', 'Delete chapter', function () {
          var refs = chapterRefs(b, rec.id);
          Kit.ui.confirm({ title: 'Delete "' + (rec.name || 'this chapter') + '"?', message: 'The chapter and its ID are removed for good.', detail: refs.length ? refs.length + ' record' + (refs.length === 1 ? '' : 's') + ' refer to it and will show a broken reference: ' + refs.slice(0, 5).join(', ') + (refs.length > 5 ? ', and more.' : '.') : '', okLabel: 'Delete', danger: true }).then(function (ok) {
            if (!ok) return;
            arr.splice(i, 1); touch(); paintMain();
          });
        }));
      }
      headEl.appendChild(title); headEl.appendChild(meta); headEl.appendChild(ctrls);
      card.appendChild(headEl); card.appendChild(body);
      function buildForm() {
        st.chapCtl[rec.id] = Kit.form.render(body, 'Chapter', rec, function () { touch(); paintHead(); }, { readOnly: locked });
      }
      paintHead();
      if (st.open[rec.id]) buildForm();
      list.appendChild(card);
    });
  }
  function focusChapter(id, fieldPath) {
    var arr = SECTION_BY.chapters.peek(cur());
    if (!arr.some(function (r) { return r.id === id; })) return false;
    if (st.section !== 'chapters') { st.section = 'chapters'; paintNav(); }
    st.open[id] = true;
    paintMain();
    var card = els.main.querySelector('.chap-card[data-id="' + id + '"]');
    if (!card) return false;
    card.scrollIntoView({ block: 'center' });
    card.className = 'chap-card flash';
    if (fieldPath && st.chapCtl[id]) st.chapCtl[id].focusPath(fieldPath);
    return true;
  }

  // ---- ruleset
  function rulesetModified(rs) {
    var f = PRESETS[rs.preset];
    return !!f && U.canonical(rs) !== U.canonical(f());
  }
  function paintRuleset(panel, sec, b, locked) {
    var rs = b.charter.ruleset;
    var grid = U.el('div', 'preset-grid');
    function tagsFor(k) {
      return rs.preset === k ? '<span class="chip chip-ok">' + Kit.icon('check') + 'Selected</span>' + (rulesetModified(rs) ? '<span class="chip chip-warning">Modified</span>' : '') : '';
    }
    ['saga', 'classic', 'custom'].forEach(function (k) {
      var info = PRESET_INFO[k];
      var card = U.el('button', 'preset-card'); card.type = 'button'; card.dataset.preset = k;
      card.setAttribute('aria-pressed', rs.preset === k ? 'true' : 'false');
      if (locked) card.disabled = true;
      card.innerHTML = '<strong>' + U.esc(info.title) + '</strong><span class="muted">' + U.esc(info.text) + '</span><span class="preset-tags">' + tagsFor(k) + '</span>';
      card.addEventListener('click', function () { choosePreset(k); });
      grid.appendChild(card);
    });
    panel.appendChild(grid);
    function refreshTags() {
      Array.prototype.forEach.call(grid.querySelectorAll('.preset-card'), function (card) { card.querySelector('.preset-tags').innerHTML = tagsFor(card.dataset.preset); });
    }
    if (!rs.preset) {
      panel.appendChild(U.el('p', 'muted', 'Choose a ruleset to continue. Saga and Classic fill the systems declaration for you. Custom starts blank.'));
      return;
    }
    if (!Array.isArray(rs.stats) || !rs.stats.length) {
      var row = U.el('div', 'btn-row'); row.style.marginBottom = '12px';
      row.appendChild(U.el('span', 'muted', 'No stats declared yet.'));
      if (!locked) {
        var ld = U.el('button', 'btn', Kit.icon('plus') + '<span>Load default stats</span>'); ld.type = 'button';
        ld.addEventListener('click', function () { rs.stats = defaultStats(); touch(); paintMain(); });
        row.appendChild(ld);
      }
      panel.appendChild(row);
    }
    var sysRow = U.el('div', 'btn-row'); sysRow.style.margin = '4px 0 12px';
    var sysBtn = U.el('button', 'btn', Kit.icon('gear') + '<span>' + (locked ? 'View systems' : 'Edit stats, elements, relations, taxonomy') + '</span>'); sysBtn.type = 'button';
    sysBtn.addEventListener('click', function () { if (window.WS.rules && window.WS.rules.openSystems) window.WS.rules.openSystems('stats'); });
    sysRow.appendChild(sysBtn); panel.appendChild(sysRow);
    var host = U.el('div');
    panel.appendChild(host);
    st.ctl = Kit.form.render(host, sec.type.name, rs, function () { touch(); refreshTags(); }, { readOnly: locked });
  }
  function choosePreset(k) {
    var b = cur(), rs = b.charter.ruleset;
    if (b.charter.locked) { Kit.ui.toast('The Charter is locked. Amend it to change the ruleset.', 'warn'); return; }
    var hasContent = rs.preset && !isEmpty(Object.assign({}, rs, { preset: null, schedulerConfig: null }));
    var needConfirm = rs.preset && (rs.preset !== k ? hasContent : rulesetModified(rs));
    var go = needConfirm ? Kit.ui.confirm({ title: rs.preset === k ? 'Reset to the ' + PRESET_INFO[k].title + '?' : 'Switch to the ' + PRESET_INFO[k].title + '?', message: 'This replaces the current systems declaration, including any edits to stats, elements, relations, and formulas.', okLabel: 'Replace', danger: true }) : Promise.resolve(true);
    go.then(function (ok) { if (ok) { WSX.applyPreset(k); Kit.ui.toast(PRESET_INFO[k].title + ' applied.', 'ok'); } });
  }

  // ---------------------------------------------------------------- path resolution and focus
  function resolvePath(path) {
    var p = String(path || '').replace(/^charter\./, ''), m;
    if ((m = /^sections\.chapters\[([^\]]+)\](?:\.(.*))?$/.exec(p))) {
      var arr = SECTION_BY.chapters.peek(cur()), key = m[1], rec = /^\d+$/.test(key) ? arr[Number(key)] : arr.filter(function (r) { return r.id === key; })[0];
      return { sec: 'chapters', field: m[2] || '', chapterId: rec ? rec.id : null };
    }
    if ((m = /^sections\.([a-z]+)(?:\.(.*))?$/.exec(p)) && SECTION_BY[m[1]]) return { sec: m[1], field: m[2] || '' };
    if ((m = /^(canon|glossary)(.*)$/.exec(p))) return { sec: m[1], field: m[1] + m[2] };
    if ((m = /^(specs|quotas|ruleset)(?:\.(.*))?$/.exec(p))) return { sec: m[1], field: m[2] || '' };
    return null;
  }
  WSX.resolvePath = resolvePath;
  WSX.focus = function (recordId, fieldPath) {
    if (Kit.active() !== 'charter') Kit.go('charter');
    var id = String(recordId || '');
    if (/^charter:/.test(id)) return goSection(id.slice(8), fieldPath);
    if (/^chp_/.test(id)) return goSection('chapters', fieldPath, id);
    return false;
  };
  WSX.goToPath = function (path) {
    var r = resolvePath(path);
    if (!r) return false;
    if (Kit.active() !== 'charter') Kit.go('charter');
    return goSection(r.sec, r.field, r.chapterId);
  };
  Kit.jump.register({
    test: function (rid) { return /^charter:[a-z]+$/.test(rid) && !!SECTION_BY[rid.slice(8)]; },
    name: function (rid) { return 'Charter: ' + SECTION_BY[rid.slice(8)].label; },
    go: function (rid, fp) { return WSX.focus(rid, fp); }
  });

  // ---------------------------------------------------------------- interviewer
  function chatAll() { var s = Kit.store.get(CHAT_KEY, {}); return U.isObj(s) ? s : {}; }
  function chatGet(secId) {
    var a = chatAll(), bid = cur().kit.bundleId;
    return a[bid] && Array.isArray(a[bid][secId]) ? a[bid][secId] : [];
  }
  function chatPush(secId, role, content) {
    var a = chatAll(), bid = cur().kit.bundleId;
    if (!U.isObj(a[bid])) a[bid] = {};
    var arr = Array.isArray(a[bid][secId]) ? a[bid][secId] : [];
    arr.push({ role: role, content: content, at: U.now() });
    a[bid][secId] = arr.slice(-24);
    Kit.store.set(CHAT_KEY, a);
  }
  function chatClear(secId) {
    var a = chatAll(), bid = cur().kit.bundleId;
    if (a[bid]) { delete a[bid][secId]; Kit.store.set(CHAT_KEY, a); }
  }
  function sectionFieldsFor(sec) {
    var t = sec.kind === 'chapters' ? TYPES.chapter : sec.type;
    var f = (t.fields || []).slice();
    if (!t.section && !f.some(function (x) { return x.key === 'name'; })) f.unshift({ key: 'name', label: 'Name', type: 'text', required: true });
    return Kit.ai.describeFields(f, cur());
  }
  function fullCharterLines(b) {
    var out = [], c = b.charter;
    function walk(v, path) {
      if (Array.isArray(v)) v.forEach(function (x, i) { walk(x, path + '[' + i + ']'); });
      else if (U.isObj(v)) Object.keys(v).forEach(function (k) { if (k !== 'id' && k !== 'charterVersion') walk(v[k], path + '.' + k); });
      else if (v !== undefined && v !== null && v !== '') out.push(path + ': ' + String(v));
    }
    walk(c.sections, 'charter.sections');
    walk(c.specs, 'charter.specs');
    walk(c.quotas, 'charter.quotas');
    var canon = (c.canon || []).map(function (x) { return { statement: x.statement }; });
    walk(canon, 'charter.canon');
    walk(c.glossary, 'charter.glossary');
    var rs = c.ruleset || {};
    walk({ preset: rs.preset, battleEngine: rs.battleEngine, scheduler: rs.scheduler, progression: rs.progression, elements: (rs.elements || []).map(function (e) { return e.key; }), elementRelations: (rs.elementRelations || []).map(function (r) { return r.a + ' opposes ' + r.b; }), taxonomy: rs.taxonomy, stats: (rs.stats || []).map(function (s) { return s.key; }) }, 'charter.ruleset');
    return out;
  }
  function loadFindings() {
    var a = Kit.store.get(FIND_KEY, {});
    var f = U.isObj(a) ? a[cur().kit.bundleId] : null;
    return f && Array.isArray(f.items) ? f : null;
  }
  function saveFindings(items) {
    var a = Kit.store.get(FIND_KEY, {});
    if (!U.isObj(a)) a = {};
    a[cur().kit.bundleId] = { at: U.now(), items: items };
    Kit.store.set(FIND_KEY, a);
  }

  function applyOption(sec, rec) {
    var b = cur(), target = sec.peek(b);
    Object.keys(rec).forEach(function (k) {
      var v = rec[k];
      if (k === 'id' || k === 'charterVersion' || v === null || v === undefined || v === '') return;
      if (Array.isArray(v) && Array.isArray(target[k])) target[k] = target[k].concat(v);
      else target[k] = v;
    });
    sec.commit(b, target);
    if (sec.after) sec.after(b, target);
    if (alive(els.main) && st.section === sec.id) paintMain();
  }

  async function askQuestion(sec, paintChat) {
    var b = cur();
    var context = { section: { id: sec.id, label: sec.label, fields: sectionFieldsFor(sec), current: sec.peek(b) }, charter: Kit.ai.charterSummary(b) };
    var hist = chatGet(sec.id);
    var msgs = [{ role: 'user', content: 'Context:\n' + JSON.stringify(context) + '\n\nAsk me one probing question about the ' + sec.label + ' section that would make the saga sharper.' }];
    hist.forEach(function (m) { msgs.push({ role: m.role, content: m.content }); });
    if (hist.length && hist[hist.length - 1].role === 'assistant') msgs.push({ role: 'user', content: 'Ask a different probing question that has not been asked yet.' });
    var system = 'You are the interviewer inside Saga Forge, a tool for authoring a classic JRPG. You help the author sharpen one section of their Charter at a time. Reply with exactly one probing question of at most forty words. No preamble, no list, no dashes, no answer of your own. Respect the canon and glossary in the context.';
    var out = await Kit.claude({ tier: 'sonnet', system: system, messages: msgs, maxTokens: 300 });
    chatPush(sec.id, 'assistant', out.text.trim());
    paintChat();
  }
  async function giveOptions(sec) {
    var b = cur();
    if (b.charter.locked) { Kit.ui.toast('The Charter is locked. Amend it to apply options.', 'warn'); return; }
    if (sec.kind === 'ruleset') { Kit.ui.toast('Options are not offered for the ruleset. Pick a preset instead.', 'warn'); return; }
    var isChap = sec.kind === 'chapters';
    var context = { section: { id: sec.id, label: sec.label, fields: sectionFieldsFor(sec), current: sec.peek(b) }, charter: Kit.ai.charterSummary(b), conversation: chatGet(sec.id).slice(-8).map(function (m) { return m.role + ': ' + m.content; }) };
    var system = 'You are the interviewer inside Saga Forge, a tool for authoring a classic JRPG. Return ONLY JSON of the form {"options":[{...},{...},{...}]} with exactly three options that contrast strongly in direction, for example in tone, scale, or theme. ' +
      (isChap ? 'Each option is one chapter record using the field keys given, including name. ' : 'Each option is a small draft using the field keys given. For list fields give two or three entries. ') +
      'Never include "id" or "charterVersion". For enum fields use only the allowedValues listed. Numbers are plain JSON numbers. Stay consistent with the canon and glossary. Do not use dashes in prose.';
    Kit.ui.busy.show('Drafting options...');
    var out;
    try {
      out = await Kit.claude({ tier: 'sonnet', system: system, messages: [{ role: 'user', content: 'Context:\n' + JSON.stringify(context) + '\n\nGive me three contrasting options for the ' + sec.label + ' section.' }], maxTokens: 3000, expectJson: true });
    } finally { Kit.ui.busy.hide(); }
    var j = out.json;
    var opts = (Array.isArray(j) ? j : j && Array.isArray(j.options) ? j.options : []).filter(U.isObj).slice(0, 3);
    if (!opts.length) { Kit.ui.toast('Claude returned no usable options.', 'warn'); return; }
    if (isChap) Kit.review.open(opts, 'Chapter', function (rec) { addChapterRecord(rec); if (alive(els.main) && st.section === 'chapters') { st.open[rec.id] = true; paintMain(); } }, { note: 'Each accepted option is added to the end of the chapter outline.' });
    else Kit.review.open(opts, sec.type.name, function (rec) { applyOption(sec, rec); }, { section: true, note: 'Accepting an option replaces the fields it fills and adds its list entries to this section.' });
  }
  async function checkContradictions(paintFindings) {
    var b = cur(), lines = fullCharterLines(b);
    if (!lines.length) { Kit.ui.toast('The Charter is empty, so there is nothing to check yet.', 'warn'); return; }
    var text = lines.join('\n');
    if (text.length > 160000) text = text.slice(0, 160000);
    var system = 'You audit a game Charter for Saga Forge, a tool for authoring a classic JRPG. Find real contradictions between fields, canon rules, glossary definitions, quotas, chapters, and the ruleset. Ignore style opinions. Return ONLY JSON of the form {"items":[{"fieldPaths":["charter.sections.premise.tone"],"conflict":"...","suggestion":"..."}]}. Copy each fieldPaths entry exactly from the path column of the input. Return {"items":[]} when there are no contradictions. Do not use dashes in prose.';
    Kit.ui.busy.show('Checking the whole Charter with Opus...');
    var out;
    try {
      out = await Kit.claude({ tier: 'opus', system: system, messages: [{ role: 'user', content: 'Charter lines, one per line as path: value\n\n' + text }], maxTokens: 4000, expectJson: true });
    } finally { Kit.ui.busy.hide(); }
    var j = out.json;
    var items = (Array.isArray(j) ? j : j && Array.isArray(j.items) ? j.items : []).filter(U.isObj).map(function (x) {
      return { fieldPaths: (Array.isArray(x.fieldPaths) ? x.fieldPaths : []).map(String), conflict: String(x.conflict || ''), suggestion: String(x.suggestion || '') };
    }).filter(function (x) { return x.conflict; });
    saveFindings(items);
    paintFindings();
    Kit.ui.toast(items.length ? items.length + ' possible contradiction' + (items.length === 1 ? '' : 's') + ' found.' : 'No contradictions found.', items.length ? 'warn' : 'ok');
  }
  function openInterviewer() {
    var sec = SECTION_BY[st.section];
    var dr;
    dr = Kit.ui.drawer({
      title: 'Interviewer: ' + sec.label,
      body: function (body) {
        body.appendChild(U.el('p', 'muted', 'Ask for a probing question, get three contrasting options to react to, or check the whole Charter for contradictions. Ask and Options use Sonnet. Contradictions use Opus.'));
        var log = U.el('div', 'chat-log'); log.setAttribute('aria-live', 'polite');
        body.appendChild(log);
        var f = U.el('div', 'field');
        f.innerHTML = '<label class="field-label" for="ivAnswer">Your answer or notes</label>';
        var ta = U.el('textarea', 'inp'); ta.id = 'ivAnswer'; ta.placeholder = 'Answer the last question. Your reply is kept with this section and sent with the next request.';
        f.appendChild(ta);
        body.appendChild(f);
        var row = U.el('div', 'btn-row'); row.style.marginTop = '8px';
        var send = U.el('button', 'btn', Kit.icon('check') + '<span>Save answer</span>'); send.type = 'button';
        var clr = U.el('button', 'btn btn-ghost', Kit.icon('trash') + '<span>Clear chat</span>'); clr.type = 'button';
        row.appendChild(send); row.appendChild(clr);
        body.appendChild(row);
        var tools = U.el('div', 'iv-tools');
        tools.appendChild(Kit.ai.button('Ask', function () { return askQuestion(sec, paintChat); }, { kind: 'primary', busyLabel: 'Asking...' }));
        tools.appendChild(Kit.ai.button('Give Me Options', function () { return giveOptions(sec); }, { busyLabel: 'Drafting...' }));
        tools.appendChild(Kit.ai.button('Check Contradictions', function () { return checkContradictions(paintFindings); }, { busyLabel: 'Auditing...' }));
        body.appendChild(tools);
        var fh = U.el('h3', 'section-h', 'Contradictions');
        var finds = U.el('div');
        body.appendChild(fh); body.appendChild(finds);
        function paintChat() {
          U.clear(log);
          var hist = chatGet(sec.id);
          if (!hist.length) log.appendChild(U.el('div', 'empty-line', 'No conversation for this section yet. Press Ask to begin.'));
          hist.forEach(function (m) {
            var d = U.el('div', 'chat-msg ' + m.role);
            d.innerHTML = '<small>' + (m.role === 'assistant' ? 'Interviewer' : 'You') + '</small>';
            d.appendChild(document.createTextNode(m.content));
            log.appendChild(d);
          });
          log.scrollTop = log.scrollHeight;
        }
        function paintFindings() {
          U.clear(finds);
          var f2 = loadFindings();
          if (!f2) { finds.appendChild(U.el('div', 'empty-line', 'No audit has been run for this project yet.')); return; }
          finds.appendChild(U.el('p', 'muted', 'Last audit ' + U.esc(U.fmtDate(f2.at)) + '.'));
          if (!f2.items.length) finds.appendChild(U.el('div', 'chip chip-ok', Kit.icon('check') + 'No contradictions'));
          f2.items.forEach(function (it) {
            var card = U.el('div', 'finding');
            card.appendChild(U.el('p', null, '<strong>Conflict.</strong> ' + U.esc(it.conflict)));
            if (it.suggestion) card.appendChild(U.el('p', null, '<strong>Suggestion.</strong> ' + U.esc(it.suggestion)));
            var paths = U.el('div', 'paths');
            it.fieldPaths.forEach(function (p) {
              var pb = U.el('button', 'btn', Kit.icon('jump') + '<span>' + U.esc(p) + '</span>'); pb.type = 'button';
              pb.title = resolvePath(p) ? 'Open ' + labelForPath(p) : 'This path could not be matched to a field';
              if (!resolvePath(p)) pb.disabled = true;
              pb.addEventListener('click', function () { dr.close(); WSX.goToPath(p); });
              paths.appendChild(pb);
            });
            card.appendChild(paths);
            finds.appendChild(card);
          });
        }
        send.addEventListener('click', function () {
          var v = ta.value.trim();
          if (!v) return;
          chatPush(sec.id, 'user', v);
          ta.value = '';
          paintChat();
        });
        clr.addEventListener('click', function () { chatClear(sec.id); paintChat(); });
        paintChat(); paintFindings();
      }
    });
  }
  WSX.openInterviewer = openInterviewer;

  // ---------------------------------------------------------------- render
  WSX.render = function (host) {
    var b = cur();
    if (ensureCanonIds(b)) Kit.bundle.touch('canon-ids');
    var saved = uiGet().section;
    if (!st.section || !SECTION_BY[st.section]) st.section = SECTION_BY[saved] ? saved : 'premise';
    els.bar = U.el('section', 'panel ch-bar');
    host.appendChild(els.bar);
    var body = U.el('div', 'ch-body');
    els.navWrap = U.el('div', 'ch-navwrap');
    els.toggle = U.el('button', 'btn ch-navtoggle', '<span>Section: <strong class="cur"></strong></span>' + Kit.icon('down'));
    els.toggle.type = 'button';
    els.toggle.setAttribute('aria-controls', 'chNav');
    els.nav = U.el('nav', 'ch-nav'); els.nav.id = 'chNav'; els.nav.setAttribute('aria-label', 'Charter sections');
    els.toggle.addEventListener('click', function () {
      st.navOpen = !st.navOpen;
      els.nav.className = 'ch-nav' + (st.navOpen ? ' open' : '');
      els.toggle.setAttribute('aria-expanded', st.navOpen ? 'true' : 'false');
    });
    els.navWrap.appendChild(els.toggle); els.navWrap.appendChild(els.nav);
    els.main = U.el('div', 'ch-main');
    body.appendChild(els.navWrap); body.appendChild(els.main);
    host.appendChild(body);
    paintBar(); paintNav(); paintMain();
  };
  Kit.on('validated', function () { paintBar(); paintNav(); });
  Kit.mount('charter', { title: 'Charter', icon: 'scroll', canEnter: function () { return true; }, render: WSX.render, focus: function (rid, fp) { WSX.focus(rid, fp); } });
})();
// === WS:CHARTER END ===
// === WS:CODEX BEGIN ===
(function () {
  'use strict';
  var U = Kit.util;
  var WSX = window.WS.codex = { id: 'codex' };
  var UI_KEY = 'saga146:codex:ui';
  var REPORT_KEY = 'saga146:codex:report';
  var CODEX_FORMAT = 1;

  // ---------------------------------------------------------------- vocabularies
  var FORMULA_IDS = ['phys.ff6', 'mag.ff6', 'phys.sub', 'mag.flat', 'heal.std', 'var.std', 'exp.curve', 'ap.curve', 'atb.fill'];
  var ABL_KINDS = [
    { key: 'attack', label: 'Attack (physical)' }, { key: 'magic', label: 'Magic' }, { key: 'heal', label: 'Heal' },
    { key: 'status', label: 'Status' }, { key: 'summon', label: 'Summon' }, { key: 'command', label: 'Command' },
    { key: 'limit', label: 'Limit' }, { key: 'enemy', label: 'Enemy skill' }, { key: 'passive', label: 'Passive' }
  ];
  var MAT_KINDS = ['magic', 'summon', 'command', 'support', 'independent'];
  // Which ability kinds each materia kind may grant. Support materia modifies its linked neighbor and grants no abilities.
  var MAT_GRANTS = { magic: ['magic', 'heal', 'status'], summon: ['summon'], command: ['attack', 'command'], support: [], independent: ['passive'] };
  var SUPPORT_EFFECTS = [
    { key: 'all', label: 'All (hit every target)' }, { key: 'element', label: 'Element (add the neighbor element)' },
    { key: 'addedEffect', label: 'Added effect (add the neighbor status)' }, { key: 'counter', label: 'Counter' },
    { key: 'hpAbsorb', label: 'HP absorb' }, { key: 'mpAbsorb', label: 'MP absorb' }
  ];
  var AFFINITIES = [
    { key: 'weak', label: 'Weak' }, { key: 'normal', label: 'Normal' }, { key: 'resist', label: 'Resist' },
    { key: 'immune', label: 'Immune' }, { key: 'absorb', label: 'Absorb' }
  ];
  var COND_KINDS = [
    { key: 'always', label: 'Always' }, { key: 'selfHpBelow', label: 'Own HP below fraction' },
    { key: 'selfHpAbove', label: 'Own HP above fraction' }, { key: 'allyHpBelow', label: 'An ally below HP fraction' },
    { key: 'targetHpBelow', label: 'Target HP below fraction' }, { key: 'targetHasStatus', label: 'Target has status' },
    { key: 'targetLacksStatus', label: 'Target lacks status' }, { key: 'turnEvery', label: 'Every N turns' },
    { key: 'enemyCountBelow', label: 'Fewer foes than N' }, { key: 'allyCountBelow', label: 'Fewer allies than N' },
    { key: 'chance', label: 'Random chance' }
  ];
  var NUMERIC_CONDS = { selfHpBelow: 1, selfHpAbove: 1, allyHpBelow: 1, targetHpBelow: 1, turnEvery: 1, enemyCountBelow: 1, allyCountBelow: 1, chance: 1 };
  var STATUS_CONDS = { targetHasStatus: 1, targetLacksStatus: 1 };
  var SELECTORS = [
    { key: 'self', label: 'Self' }, { key: 'randomFoe', label: 'Random foe' }, { key: 'lowestHpFoe', label: 'Foe with lowest HP' },
    { key: 'highestHpFoe', label: 'Foe with highest HP' }, { key: 'allFoes', label: 'All foes' },
    { key: 'randomAlly', label: 'Random ally' }, { key: 'lowestHpAlly', label: 'Ally with lowest HP' },
    { key: 'allAllies', label: 'All allies' }, { key: 'attacker', label: 'The attacker (counters)' }
  ];
  var TRIGGERS = [
    { key: 'onPhysical', label: 'Hit by a physical attack' }, { key: 'onMagic', label: 'Hit by magic' },
    { key: 'onDamaged', label: 'Takes any damage' }, { key: 'onAllyKo', label: 'An ally is KO' },
    { key: 'onLowHp', label: 'Falls below a quarter HP' }, { key: 'onStatus', label: 'Receives a status' }
  ];
  var STAT_PATH = 'charter.ruleset.stats';
  var ELEM_PATH = 'charter.ruleset.elements';
  var TAX_PATH = 'charter.ruleset.taxonomy';
  var MODULE_TYPE = { materia: 'Materia', jobs: 'Job', classes: 'Class' };
  var MODULE_PREFIX = { materia: 'mat_', jobs: 'job_', classes: 'cls_' };
  var SET_KEY = { materia: 'materiaSet', jobs: 'jobSet', classes: 'classSet' };
  var FORGE_NAMES = { 146: 'Saga Forge (Rules)', 147: 'Art Forge', 148: 'World Forge', 149: 'Story Forge' };
  var GROUPS = [
    { key: 'core', label: 'Core types', text: 'Every saga gets these, whatever the ruleset.' },
    { key: 'module', label: 'Progression module', text: 'Chosen by the Charter ruleset progression.' },
    { key: 'living', label: 'Living World', text: 'Text payloads plus references that Claude and later forges can fill.' },
    { key: 'charter', label: 'Charter records', text: 'Owned by the Charter itself.' }
  ];

  function cur() { return Kit.bundle.current(); }
  function fd(key, label, type, o) { return Object.assign({ key: key, label: label, type: type }, o || {}); }
  function fwd(key, label, prefix, o) { return fd(key, label, 'ref', Object.assign({ refPrefix: prefix, forward: true }, o || {})); }

  // ---------------------------------------------------------------- type builder
  // Returns plain JSON descriptors built from the ruleset. Nothing here is a function, so the codex stores in the bundle.
  function buildTypes(rs) {
    rs = U.isObj(rs) ? rs : {};
    var prog = MODULE_TYPE[rs.progression] ? rs.progression : null;
    var modPrefix = prog ? MODULE_PREFIX[prog] : null;
    var lootPrefixes = ['itm_', 'eqp_'].concat(prog === 'materia' ? ['mat_'] : []);
    var gambitRule = [
      fd('condition', 'Condition', 'object', { required: true, of: [
        fd('kind', 'Kind', 'enum', { required: true, values: COND_KINDS }),
        fd('param', 'Parameter', 'text', { max: 40, help: 'A fraction such as 0.35, a count such as 2, or a status ID for status conditions.' })
      ] }),
      fd('target', 'Target', 'object', { required: true, of: [fd('selector', 'Selector', 'enum', { required: true, values: SELECTORS })] }),
      fd('action', 'Action', 'object', { required: true, of: [fd('abl', 'Ability', 'ref', { required: true, refPrefix: 'abl_' })] })
    ];
    var counterRule = [
      fd('trigger', 'Trigger', 'enum', { required: true, values: TRIGGERS }),
      fd('action', 'Action', 'object', { required: true, of: [fd('abl', 'Ability', 'ref', { required: true, refPrefix: 'abl_' })] })
    ];
    var T = {};
    function add(def) { T[def.name] = def; }

    add({ name: 'Character', prefix: 'chr_', label: 'Character', group: 'core', dependsOn: ['charter.sections.party', STAT_PATH], fields: [
      fd('weaponClass', 'Weapon class', 'text', { max: 30, help: 'For example sword, staff, or claw. Equipment with the same class can be worn.' }),
      fd('statLeanings', 'Stat leanings', 'table', { rowsFrom: STAT_PATH, cell: 'num', min: 0, max: 5, rowLabel: 'Stat', valueLabel: 'Lean', help: 'Relative strengths. One is average, two is double.' }),
      fd('baseStats', 'Base stats', 'table', { required: true, rowsFrom: STAT_PATH, cell: 'int', min: 0, max: 99999, rowLabel: 'Stat', valueLabel: 'Level 1' }),
      fd('growth', 'Growth per level', 'table', { rowsFrom: STAT_PATH, cell: 'num', min: 0, max: 9999, rowLabel: 'Stat', valueLabel: 'Per level' }),
      fd('limitTree', 'Limit tree', 'refList', { refPrefix: 'lim_', help: 'Limit breaks in unlock order.' }),
      fwd('portrait', 'Portrait', 'por_'),
      fwd('leitmotif', 'Leitmotif', 'mus_'),
      fd('relationshipHooks', 'Relationship hooks', 'list', { itemLabel: 'Hook', of: [
        fd('chr', 'Character', 'ref', { required: true, refPrefix: 'chr_' }),
        fd('note', 'Note', 'text', { required: true, max: 200 })
      ] }),
      fd('bStoryline', 'B storyline', 'longtext', { help: 'The personal subplot that runs under the main story.' }),
      fd('move', 'Move', 'int', { min: 1, max: 12, help: 'Optional tactics seam: tiles per turn.' })
    ] });

    add({ name: 'Ability', prefix: 'abl_', label: 'Ability', group: 'core', dependsOn: [ELEM_PATH, 'charter.ruleset.formulaSet'], fields: [
      fd('kind', 'Kind', 'enum', { required: true, values: ABL_KINDS }),
      fd('element', 'Element', 'enum', { enumFrom: ELEM_PATH, help: 'Empty means non elemental.' }),
      fd('power', 'Power', 'int', { min: 0, max: 9999 }),
      fd('cost', 'Cost', 'object', { of: [
        fd('mp', 'MP', 'int', { min: 0, max: 9999 }),
        fd('ap', 'AP', 'int', { min: 0, max: 9999 }),
        fd('item', 'Item consumed', 'ref', { refPrefix: 'itm_' })
      ] }),
      fd('targeting', 'Targeting', 'object', { required: true, of: [
        fd('side', 'Side', 'enum', { required: true, values: ['foe', 'ally', 'self', 'any'] }),
        fd('scope', 'Scope', 'enum', { required: true, values: ['single', 'all', 'row', 'random'] })
      ] }),
      fd('chargeTicks', 'Charge ticks', 'int', { min: 0, max: 65536, help: 'Wind up before the action lands. Zero is instant.' }),
      fd('formula', 'Formula', 'ref', { refPrefix: 'frm_', help: 'Empty uses the ruleset formula set for this kind.' }),
      fd('statusEffects', 'Status effects', 'list', { itemLabel: 'Effect', of: [
        fd('sta', 'Status', 'ref', { required: true, refPrefix: 'sta_' }),
        fd('chance', 'Chance', 'num', { min: 0, max: 1, help: 'Zero to one.' })
      ] }),
      fd('range', 'Range', 'int', { min: 0, max: 20, help: 'Optional tactics seam.' }),
      fd('area', 'Area', 'int', { min: 0, max: 10, help: 'Optional tactics seam.' }),
      fwd('animation', 'Animation', 'anm_'),
      fwd('sfx', 'Sound effect', 'sfx_'),
      fwd('icon', 'Icon', 'ico_')
    ] });

    add({ name: 'Item', prefix: 'itm_', label: 'Item', group: 'core', dependsOn: [], fields: [
      fd('kind', 'Kind', 'enum', { required: true, values: ['consumable', 'key', 'material'] }),
      fd('price', 'Price', 'int', { min: 0, max: 9999999 }),
      fd('effect', 'Effect', 'ref', { refPrefix: 'abl_', help: 'The ability that fires when the item is used.' }),
      fwd('icon', 'Icon', 'ico_')
    ] });

    add({ name: 'Equipment', prefix: 'eqp_', label: 'Equipment', group: 'core', dependsOn: [STAT_PATH], fields: [
      fd('slot', 'Slot', 'enum', { required: true, values: ['weapon', 'armor', 'accessory'] }),
      fd('weaponClass', 'Weapon class', 'text', { max: 30, help: 'Weapons only. Matches a character weapon class.' }),
      fd('tier', 'Gear tier', 'int', { min: 1, max: 20, help: 'Compared with the Expected Party State gear tier.' }),
      fd('price', 'Price', 'int', { min: 0, max: 9999999 }),
      fd('stats', 'Stat bonuses', 'table', { rowsFrom: STAT_PATH, cell: 'int', min: -9999, max: 9999, rowLabel: 'Stat', valueLabel: 'Bonus' }),
      fd('slotLayout', 'Slot layout', 'object', { of: [
        fd('count', 'Slots', 'int', { min: 0, max: 8 }),
        fd('links', 'Links', 'list', { itemLabel: 'Link', help: 'Each link is a pair of slot numbers counted from zero, such as 0 and 1.', of: { type: 'list', of: { type: 'int', min: 0, max: 7 }, min: 2, max: 2 } })
      ] }),
      fwd('icon', 'Icon', 'ico_')
    ] });

    add({ name: 'Status', prefix: 'sta_', label: 'Status', group: 'core', dependsOn: [], fields: [
      fd('gauge', 'Gauge effect', 'enum', { required: true, values: ['normal', 'freeze', 'empty'], help: 'Freeze stops the gauge. Empty resets it each tick.' }),
      fd('tickEffect', 'Tick effect', 'object', { of: [
        fd('kind', 'Kind', 'enum', { values: ['none', 'damage', 'heal', 'mpDrain'] }),
        fd('percent', 'Percent of max', 'num', { min: 0, max: 100 })
      ] }),
      fd('duration', 'Duration in turns', 'int', { min: 0, max: 99, help: 'Zero lasts until cured.' }),
      fd('cure', 'Cure', 'object', { of: [
        fd('battleEnd', 'Ends with battle', 'bool'),
        fd('onHit', 'Ends when hit', 'bool'),
        fd('curedBy', 'Cured by', 'refList', { refPrefix: ['itm_', 'abl_'] })
      ] })
    ] });

    add({ name: 'Formula', prefix: 'frm_', label: 'Formula', group: 'core', dependsOn: ['charter.ruleset.formulaSet', STAT_PATH], fields: [
      fd('template', 'Template', 'enum', { values: FORMULA_IDS, help: 'A built in template. Leave empty to write an expression.' }),
      fd('expr', 'Expression', 'formula', { help: 'Used when no template is chosen. Variables: a.<stat>, a.level, t.<stat>, t.level, power, p.<param>.' }),
      fd('params', 'Parameters', 'table', { cell: 'num', rowLabel: 'Param', valueLabel: 'Value', help: 'Read in expressions as p.<name>.' })
    ] });

    add({ name: 'Family', prefix: 'fam_', label: 'Enemy family', group: 'core', dependsOn: [TAX_PATH, ELEM_PATH, 'charter.ruleset.elementRelations'], fields: [
      fd('type', rs.taxonomy && rs.taxonomy.label ? String(rs.taxonomy.label) : 'Type', 'enum', { required: true, enumFrom: TAX_PATH }),
      fd('palette', 'Palette', 'object', { of: [fd('base', 'Base', 'color'), fd('accent', 'Accent', 'color')] }),
      fd('absorbsOwnType', 'Absorbs its own type', 'bool', { help: 'Its own element heals it instead of being resisted.' }),
      fd('defaultAffinity', 'Default affinity', 'table', { derived: 'familyAffinity', rowsFrom: ELEM_PATH, cell: 'text', rowLabel: 'Element', valueLabel: 'Affinity', help: 'Computed from the type and the relation table: its own type is resisted and its opposite is the weakness.' }),
      fwd('sprite', 'Sprite', 'spr_')
    ] });

    add({ name: 'Enemy', prefix: 'enm_', label: 'Enemy', group: 'core', dependsOn: [STAT_PATH, ELEM_PATH], fields: [
      fd('family', 'Family', 'ref', { required: true, refPrefix: 'fam_' }),
      fd('tier', 'Tier', 'int', { min: 1, max: 9 }),
      fd('level', 'Level', 'int', { min: 1, max: 99 }),
      fd('stats', 'Stats', 'table', { required: true, rowsFrom: STAT_PATH, cell: 'int', min: 0, max: 999999, rowLabel: 'Stat', valueLabel: 'Value' }),
      fd('affinityOverrides', 'Affinity overrides', 'table', { rowsFrom: ELEM_PATH, cell: 'enum', cellValues: AFFINITIES, cellPlaceholder: '(family default)', rowLabel: 'Element', valueLabel: 'Override' }),
      fd('gambits', 'Gambits', 'ref', { refPrefix: 'gmb_' }),
      fd('drops', 'Drops', 'list', { itemLabel: 'Drop', of: [
        fd('item', 'Item', 'ref', { required: true, refPrefix: lootPrefixes }),
        fd('chance', 'Chance', 'num', { min: 0, max: 1 })
      ] }),
      fd('steal', 'Steal', 'list', { itemLabel: 'Steal', of: [
        fd('item', 'Item', 'ref', { required: true, refPrefix: lootPrefixes }),
        fd('chance', 'Chance', 'num', { min: 0, max: 1 })
      ] }),
      fd('gil', 'Gil', 'int', { min: 0, max: 9999999 }),
      fd('exp', 'EXP', 'int', { min: 0, max: 9999999 }),
      fd('ap', 'AP', 'int', { min: 0, max: 99999 }),
      fd('isBoss', 'Boss', 'bool')
    ] });

    add({ name: 'Gambit', prefix: 'gmb_', label: 'Gambit set', group: 'core', dependsOn: [], fields: [
      fd('rules', 'Rules', 'list', { required: true, itemLabel: 'Rule', help: 'Checked top to bottom. The first rule whose condition holds acts.', of: gambitRule }),
      fd('counters', 'Counters', 'list', { itemLabel: 'Counter', of: counterRule })
    ] });

    add({ name: 'Troop', prefix: 'trp_', label: 'Troop', group: 'core', dependsOn: ['charter.sections.chapters'], fields: [
      fd('members', 'Members', 'list', { required: true, min: 1, max: 8, itemLabel: 'Member', of: [
        fd('enm', 'Enemy', 'ref', { required: true, refPrefix: 'enm_' }),
        fd('row', 'Row', 'enum', { values: ['front', 'back'] })
      ] }),
      fd('chapter', 'Chapter', 'ref', { refPrefix: 'chp_' }),
      fd('flags', 'Flags', 'object', { of: [
        fd('noEscape', 'No escape', 'bool'),
        fd('preemptiveChance', 'Preemptive chance', 'num', { min: 0, max: 1 })
      ] })
    ] });

    add({ name: 'Shop', prefix: 'shp_', label: 'Shop', group: 'core', dependsOn: ['charter.sections.chapters'], fields: [
      fd('inventory', 'Inventory', 'list', { itemLabel: 'Stock', of: [
        fd('item', 'Item', 'ref', { required: true, refPrefix: lootPrefixes }),
        fd('priceOverride', 'Price override', 'int', { min: 0, max: 9999999 })
      ] }),
      fd('chapterAvailable', 'Available from chapter', 'ref', { refPrefix: 'chp_' })
    ] });

    add({ name: 'Weather', prefix: 'wth_', label: 'Weather state', group: 'core', dependsOn: [ELEM_PATH, 'charter.sections.magic'], fields: [
      fd('realWorld', 'Real world phenomenon', 'text', { required: true, max: 80, help: 'For example supercell thunderstorm or radiation fog.' }),
      fd('elementMultipliers', 'Element multipliers', 'table', { rowsFrom: ELEM_PATH, cell: 'num', min: 0, max: 5, rowLabel: 'Element', valueLabel: 'Multiplier' }),
      fd('encounterModifiers', 'Encounter modifiers', 'object', { of: [
        fd('rate', 'Encounter rate', 'num', { min: 0, max: 5, help: 'One is normal.' }),
        fd('familyWeights', 'Family weights', 'list', { itemLabel: 'Weight', of: [
          fd('fam', 'Family', 'ref', { required: true, refPrefix: 'fam_' }),
          fd('weight', 'Weight', 'num', { min: 0, max: 10 })
        ] })
      ] })
    ] });

    add({ name: 'Limit', prefix: 'lim_', label: 'Limit break', group: 'core', dependsOn: [], fields: [
      fd('level', 'Limit level', 'int', { required: true, min: 1, max: 4 }),
      fd('unlock', 'Unlock', 'object', { of: [
        fd('uses', 'After uses', 'int', { min: 0, max: 999, help: 'Uses of the previous limit.' }),
        fd('kills', 'After kills', 'int', { min: 0, max: 9999 })
      ] }),
      fd('action', 'Action', 'ref', { required: true, refPrefix: 'abl_' })
    ] });

    var eps = [
      fd('chapter', 'Chapter', 'ref', { required: true, refPrefix: 'chp_' }),
      fd('targetLevel', 'Target level', 'int', { min: 1, max: 99 }),
      fd('gearTier', 'Gear tier', 'int', { min: 1, max: 20 })
    ];
    if (prog) eps.push(fd(SET_KEY[prog], MODULE_TYPE[prog] + ' set', 'refList', { refPrefix: modPrefix }));
    eps.push(fd('gil', 'Gil on hand', 'int', { min: 0, max: 9999999 }));
    eps.push(fd('abilities', 'Abilities', 'refList', { refPrefix: 'abl_' }));
    eps.push(fd('targetWinRate', 'Target win rate', 'num', { min: 0, max: 100, help: 'Percent. The Simulator draws this as the target line.' }));
    add({ name: 'ExpectedPartyState', prefix: 'eps_', label: 'Expected Party State', group: 'core', dependsOn: ['charter.sections.chapters', 'charter.ruleset.progression'], fields: eps });

    if (prog === 'materia') {
      add({ name: 'Materia', prefix: 'mat_', label: 'Materia', group: 'module', module: 'materia', dependsOn: ['charter.ruleset.progression', ELEM_PATH, STAT_PATH], fields: [
        fd('kind', 'Kind', 'enum', { required: true, values: MAT_KINDS }),
        fd('element', 'Element', 'enum', { enumFrom: ELEM_PATH }),
        fd('apThresholds', 'AP thresholds', 'list', { itemLabel: 'Level', of: { type: 'int', min: 0, max: 9999999 }, help: 'AP needed to reach each level after the first.' }),
        fd('grants', 'Grants per level', 'list', { itemLabel: 'Grant', of: [
          fd('level', 'Level', 'int', { required: true, min: 1, max: 9 }),
          fd('abl', 'Ability', 'ref', { refPrefix: 'abl_' }),
          fd('statMods', 'Stat mods', 'table', { rowsFrom: STAT_PATH, cell: 'num', min: -100, max: 100, rowLabel: 'Stat', valueLabel: 'Percent' })
        ] }),
        fd('supportEffect', 'Support effect', 'enum', { values: SUPPORT_EFFECTS, help: 'Support materia only: how it modifies its linked neighbor.' }),
        fd('price', 'Price', 'int', { min: 0, max: 9999999 })
      ] });
    } else if (prog === 'jobs') {
      add({ name: 'Job', prefix: 'job_', label: 'Job', group: 'module', module: 'jobs', dependsOn: ['charter.ruleset.progression', STAT_PATH], fields: [
        fd('abilities', 'Abilities by level', 'list', { itemLabel: 'Ability', of: [
          fd('level', 'Job level', 'int', { required: true, min: 1, max: 99 }),
          fd('abl', 'Ability', 'ref', { required: true, refPrefix: 'abl_' })
        ] }),
        fd('statMods', 'Stat mods', 'table', { rowsFrom: STAT_PATH, cell: 'num', min: -100, max: 100, rowLabel: 'Stat', valueLabel: 'Percent' })
      ] });
    } else if (prog === 'classes') {
      add({ name: 'Class', prefix: 'cls_', label: 'Class', group: 'module', module: 'classes', dependsOn: ['charter.ruleset.progression', STAT_PATH], fields: [
        fd('skillTree', 'Skill tree', 'list', { itemLabel: 'Skill', of: [
          fd('abl', 'Ability', 'ref', { required: true, refPrefix: 'abl_' }),
          fd('level', 'Level', 'int', { required: true, min: 1, max: 99 })
        ] }),
        fd('statMods', 'Stat mods', 'table', { rowsFrom: STAT_PATH, cell: 'num', min: -100, max: 100, rowLabel: 'Stat', valueLabel: 'Percent' })
      ] });
    }

    var worldRefs = ['chr_', 'enm_', 'fam_', 'itm_', 'eqp_', 'abl_', 'npc_', 'twn_', 'dgn_', 'reg_', 'map_'];
    add({ name: 'Rumor', prefix: 'rmr_', label: 'Rumor', group: 'living', module: 'living', dependsOn: ['charter.canon', 'charter.glossary'], fields: [
      fd('text', 'Rumor', 'longtext', { required: true, max: 600, help: 'What townsfolk say.' }),
      fd('chapter', 'Chapter', 'ref', { refPrefix: 'chp_' }),
      fd('truthful', 'Truthful', 'bool'),
      fd('refs', 'About', 'refList', { refPrefix: worldRefs })
    ] });
    add({ name: 'SideQuest', prefix: 'sdq_', label: 'Side quest seed', group: 'living', module: 'living', dependsOn: ['charter.canon', 'charter.sections.chapters'], fields: [
      fd('text', 'Quest seed', 'longtext', { required: true, max: 1200 }),
      fd('chapter', 'Chapter', 'ref', { refPrefix: 'chp_' }),
      fwd('giver', 'Giver', 'npc_'),
      fd('rewards', 'Rewards', 'list', { itemLabel: 'Reward', of: [
        fd('item', 'Item', 'ref', { required: true, refPrefix: lootPrefixes }),
        fd('qty', 'Quantity', 'int', { min: 1, max: 99 })
      ] }),
      fd('refs', 'Involves', 'refList', { refPrefix: worldRefs }),
      fwd('flag', 'Completion flag', 'flg_')
    ] });
    add({ name: 'BossStrategy', prefix: 'bst_', label: 'Boss strategy', group: 'living', module: 'living', dependsOn: [], fields: [
      fd('text', 'Strategy', 'longtext', { required: true, max: 1200, help: 'The plan in words. The rules below are what the engine runs.' }),
      fd('boss', 'Boss', 'ref', { required: true, refPrefix: 'enm_' }),
      fd('rules', 'Rules', 'list', { required: true, itemLabel: 'Rule', help: 'Same shape as a gambit set, so it validates and simulates the same way.', of: U.clone(gambitRule) }),
      fd('counters', 'Counters', 'list', { itemLabel: 'Counter', of: U.clone(counterRule) })
    ] });

    Object.keys(T).forEach(function (k) { T[k].prefix = Kit.codex.normPrefix(T[k].prefix); T[k].codex = CODEX_FORMAT; });
    return T;
  }

  function buildSaveSchema(rs) {
    rs = U.isObj(rs) ? rs : {};
    var sp = U.isObj(rs.savePolicy) ? rs.savePolicy : {};
    var prog = MODULE_TYPE[rs.progression] ? rs.progression : null;
    var member = [
      fd('chr', 'Character', 'ref', { required: true, refPrefix: 'chr_' }),
      fd('level', 'Level', 'int', { required: true, min: 1, max: 99 }),
      fd('exp', 'EXP', 'int', { min: 0 }),
      fd('hp', 'HP', 'int', { min: 0 }),
      fd('mp', 'MP', 'int', { min: 0 }),
      fd('equipment', 'Equipment', 'refList', { refPrefix: 'eqp_' }),
      fd('limitLevel', 'Limit level', 'int', { min: 1, max: 4 }),
      fd('limitUses', 'Limit uses', 'int', { min: 0 }),
      fd('kills', 'Kills', 'int', { min: 0 }),
      fd('status', 'Lasting statuses', 'refList', { refPrefix: 'sta_' })
    ];
    if (prog === 'materia') member.push(fd('slots', 'Slotted materia', 'list', { itemLabel: 'Slot', of: [fd('eqp', 'Equipment', 'ref', { refPrefix: 'eqp_' }), fd('slot', 'Slot', 'int', { min: 0, max: 7 }), fd('mat', 'Materia', 'ref', { refPrefix: 'mat_' }), fd('ap', 'AP', 'int', { min: 0 })] }));
    if (prog === 'jobs') member.push(fd('job', 'Job', 'ref', { refPrefix: 'job_' }), fd('jobLevels', 'Job levels', 'table', { cell: 'int' }));
    if (prog === 'classes') member.push(fd('cls', 'Class', 'ref', { refPrefix: 'cls_' }));
    var fields = [
      fd('slotMeta', 'Slot meta', 'object', { required: true, of: [
        fd('slot', 'Slot', 'int', { required: true, min: 1, max: Math.max(1, Number(sp.slots) || 1) }),
        fd('label', 'Label', 'text', { max: 60 }),
        fd('savedAt', 'Saved at', 'text'),
        fd('chapter', 'Chapter', 'ref', { refPrefix: 'chp_' }),
        fd('suspend', 'Suspend save', 'bool')
      ] }),
      fd('party', 'Party', 'list', { required: true, itemLabel: 'Member', of: member }),
      fd('inventory', 'Inventory', 'list', { itemLabel: 'Stack', of: [fd('item', 'Item', 'ref', { required: true, refPrefix: ['itm_', 'eqp_'] }), fd('qty', 'Quantity', 'int', { min: 0, max: 999 })] })
    ];
    if (prog === 'materia') fields.push(fd('materia', 'Materia stock', 'list', { itemLabel: 'Materia', of: [fd('mat', 'Materia', 'ref', { required: true, refPrefix: 'mat_' }), fd('ap', 'AP', 'int', { min: 0 })] }));
    fields.push(
      fd('gil', 'Gil', 'int', { min: 0 }),
      fd('flags', 'Flags', 'list', { itemLabel: 'Flag', of: [fwd('flg', 'Flag', 'flg_', { required: true }), fd('value', 'Value', 'int')] }),
      fwd('location', 'Location', 'map_', { required: true }),
      fd('playTime', 'Play time in seconds', 'int', { required: true, min: 0 }),
      fd('bundleHash', 'Bundle hash', 'text', { required: true, help: 'The content hash of the bundle this save was made against.' }),
      fd('schemaVersion', 'Schema version', 'int', { required: true, min: 1 })
    );
    return {
      name: 'SaveGame', label: 'Save game', schemaVersion: 1,
      policy: { slots: Number(sp.slots) || 0, mode: sp.mode || null, suspend: !!sp.suspend },
      fields: fields
    };
  }

  // ---------------------------------------------------------------- affinity
  function elementKeys(b) {
    var els = b && b.charter && b.charter.ruleset && Array.isArray(b.charter.ruleset.elements) ? b.charter.ruleset.elements : [];
    return els.map(function (e) { return U.isObj(e) ? String(e.key) : String(e); }).filter(function (k) { return k && k !== 'undefined'; });
  }
  function opposites(b, key) {
    var rel = b && b.charter && b.charter.ruleset && Array.isArray(b.charter.ruleset.elementRelations) ? b.charter.ruleset.elementRelations : [];
    var out = [];
    rel.forEach(function (r) {
      if (!U.isObj(r) || (r.kind && r.kind !== 'opposed')) return;
      if (r.a === key && r.b) out.push(String(r.b));
      if (r.b === key && r.a) out.push(String(r.a));
    });
    return out;
  }
  // Default affinity for a taxonomy value: own element resisted (or absorbed), opposed elements are weaknesses.
  WSX.defaultAffinity = function (b, typeValue, absorbOwn) {
    b = b || cur();
    var out = {}, opp = typeValue ? opposites(b, String(typeValue)) : [];
    elementKeys(b).forEach(function (k) {
      if (typeValue && k === String(typeValue)) out[k] = absorbOwn ? 'absorb' : 'resist';
      else if (opp.indexOf(k) >= 0) out[k] = 'weak';
      else out[k] = 'normal';
    });
    return out;
  };
  // Effective affinity for an enemy: family default, then overrides.
  WSX.enemyAffinity = function (b, enm) {
    b = b || cur();
    var fam = enm && enm.family ? Kit.index(b).byId[enm.family] : null;
    var fr = fam ? fam.record : {};
    var base = WSX.defaultAffinity(b, fr.type, !!fr.absorbsOwnType);
    var ov = enm && U.isObj(enm.affinityOverrides) ? enm.affinityOverrides : {};
    Object.keys(ov).forEach(function (k) { if (ov[k]) base[k] = ov[k]; });
    return base;
  };
  Kit.codex.derive.familyAffinity = function (rec, b) { return WSX.defaultAffinity(b, rec && rec.type, !!(rec && rec.absorbsOwnType)); };

  // ---------------------------------------------------------------- generation
  function fieldPaths(fields, base, out) {
    (fields || []).forEach(function (f) {
      if (!f || !f.key) return;
      var p = base ? base + '.' + f.key : f.key;
      out[p] = f.type;
      if (Array.isArray(f.of)) fieldPaths(f.of, p + '[]', out);
      else if (U.isObj(f.of) && f.of.type) out[p + '[]'] = f.of.type;
    });
    return out;
  }
  function diffTypes(oldT, newT) {
    oldT = U.isObj(oldT) ? oldT : {}; newT = U.isObj(newT) ? newT : {};
    var rep = { typesAdded: [], typesRemoved: [], fields: [] };
    Object.keys(newT).forEach(function (k) { if (!oldT[k]) rep.typesAdded.push(k); });
    Object.keys(oldT).forEach(function (k) { if (!newT[k]) rep.typesRemoved.push(k); });
    Object.keys(newT).forEach(function (k) {
      if (!oldT[k]) return;
      var a = fieldPaths(oldT[k].fields, '', {}), c = fieldPaths(newT[k].fields, '', {});
      var added = Object.keys(c).filter(function (p) { return a[p] === undefined; });
      var removed = Object.keys(a).filter(function (p) { return c[p] === undefined; });
      var retyped = Object.keys(c).filter(function (p) { return a[p] !== undefined && a[p] !== c[p]; });
      if (added.length || removed.length || retyped.length) rep.fields.push({ type: k, prefix: newT[k].prefix, added: added, removed: removed, retyped: retyped });
    });
    return rep;
  }
  function rulesetHash(rs) { return U.sha256(U.canonical(U.isObj(rs) ? rs : {})).slice(0, 16); }
  function prefixTable(types) {
    var out = {}, byPrefix = {};
    Object.keys(types).forEach(function (k) { byPrefix[types[k].prefix] = k; });
    Object.keys(Kit.codex.PREFIXES).sort().forEach(function (p) {
      var info = Kit.codex.PREFIXES[p];
      var tn = byPrefix[p] || null;
      if (!tn && p === 'chp_') tn = 'Chapter';
      out[p] = { type: tn, ns: info.ns, forge: info.forge, module: info.module || null, active: !!tn || info.forge !== 146 };
    });
    return out;
  }
  function recordsByPrefix(b) {
    var out = {};
    var idx = Kit.index(b);
    Object.keys(idx.byPrefix).forEach(function (p) { out[p] = idx.byPrefix[p].length; });
    return out;
  }
  // Generates (or regenerates) codex.types, codex.prefixes, codex.modules and codex.saveSchema. Records are never touched.
  WSX.generate = function (opts) {
    opts = opts || {};
    var b = cur();
    if (!b.charter.locked) return { ok: false, reason: 'Lock the Charter before generating the Codex.' };
    var rs = b.charter.ruleset || {};
    if (!MODULE_TYPE[rs.progression]) return { ok: false, reason: 'The ruleset needs a progression (materia, jobs, or classes).' };
    var oldTypes = U.clone(b.codex.types || {});
    var first = !b.codex.version;
    var types = buildTypes(rs);
    var report = first ? { typesAdded: Object.keys(types), typesRemoved: [], fields: [] } : diffTypes(oldTypes, types);
    var modules = [rs.progression, 'living'];
    b.codex.types = types;
    b.codex.prefixes = prefixTable(types);
    b.codex.modules = modules;
    b.codex.saveSchema = buildSaveSchema(rs);
    b.codex.version = (b.codex.version || 0) + 1;
    b.codex.generatedFromCharter = b.charter.version || 0;
    b.codex.rulesetHash = rulesetHash(rs);
    b.codex.generatedAt = U.now();
    // Orphans: records kept whose prefix no longer has a type (for example materia after switching to classes).
    var counts = recordsByPrefix(b), orphans = [];
    Object.keys(counts).forEach(function (p) {
      var info = Kit.codex.prefixInfo(p);
      if (info && info.ns === 'rules' && !b.codex.prefixes[p].type) orphans.push({ prefix: p, count: counts[p] });
    });
    // Refresh derived values on every family.
    Object.keys((b.rules && b.rules.fam_) || {}).forEach(function (id) {
      var r = b.rules.fam_[id];
      r.defaultAffinity = WSX.defaultAffinity(b, r.type, !!r.absorbsOwnType);
    });
    Kit.bundle.open('rules');
    Kit.index.invalidate();
    var full = { at: b.codex.generatedAt, version: b.codex.version, charterVersion: b.codex.generatedFromCharter, first: first, report: report, orphans: orphans, preserved: Object.keys(counts).reduce(function (s, p) { return s + (Kit.codex.prefixInfo(p) && Kit.codex.prefixInfo(p).ns === 'rules' ? counts[p] : 0); }, 0) };
    Kit.store.set(REPORT_KEY, full);
    Kit.bundle.touch('codex-generate');
    Kit.paintTabs();
    if (!opts.quiet) {
      if (first) Kit.ui.toast('Codex version 1 generated with ' + Object.keys(types).length + ' record types. Rules is open.', 'ok', 4500);
      else showReport(full);
    }
    if (Kit.active() === 'codex') Kit.rerender();
    return { ok: true, version: b.codex.version, report: report, orphans: orphans, first: first };
  };
  WSX.buildTypes = buildTypes;
  WSX.buildSaveSchema = buildSaveSchema;
  WSX.diffTypes = diffTypes;

  // ---------------------------------------------------------------- codex validity
  function resolves(b, path) {
    var v = U.getPath(b, path);
    if (U.isObj(v) && Array.isArray(v.values)) return v.values.length;
    return Array.isArray(v) ? v.length : -1;
  }
  function walkFields(fields, fn, base) {
    (fields || []).forEach(function (f) {
      if (!f || !f.key) return;
      var p = base ? base + '.' + f.key : f.key;
      fn(f, p);
      if (Array.isArray(f.of)) walkFields(f.of, fn, p);
      else if (U.isObj(f.of)) fn(f.of, p + '[]');
    });
  }
  // Returns {ok, state:'none|stale|ready|invalid', errors:[], warnings:[]} with items {path, message}.
  WSX.check = function (b) {
    b = b || cur();
    var out = { ok: false, state: 'none', errors: [], warnings: [] };
    if (!b || !b.charter) { out.errors.push({ path: 'charter', message: 'No project is loaded.' }); return out; }
    if (!b.charter.locked) { out.errors.push({ path: 'charter.locked', message: 'Lock the Charter first.' }); out.state = 'none'; return out; }
    var cx = b.codex || {}, rs = b.charter.ruleset || {};
    if (!cx.version || !U.isObj(cx.types) || !Object.keys(cx.types).length) { out.errors.push({ path: 'codex.version', message: 'Generate the Codex from the locked ruleset.' }); return out; }
    if (cx.generatedFromCharter !== b.charter.version || (cx.rulesetHash && cx.rulesetHash !== rulesetHash(rs))) {
      out.state = 'stale';
      out.errors.push({ path: 'codex.generatedFromCharter', message: 'The Charter is at version ' + b.charter.version + ' but the Codex was generated from version ' + cx.generatedFromCharter + '. Regenerate the Codex.' });
    }
    var prog = rs.progression;
    if (!MODULE_TYPE[prog]) out.errors.push({ path: 'charter.ruleset.progression', message: 'The ruleset has no progression module.' });
    else {
      var mt = MODULE_TYPE[prog];
      if (!cx.types[mt]) out.errors.push({ path: 'codex.types.' + mt, message: 'The ' + prog + ' module type ' + mt + ' is missing. Regenerate the Codex.' });
      Object.keys(MODULE_TYPE).forEach(function (m) { if (m !== prog && cx.types[MODULE_TYPE[m]]) out.errors.push({ path: 'codex.types.' + MODULE_TYPE[m], message: 'Type ' + MODULE_TYPE[m] + ' belongs to the inactive ' + m + ' module. Regenerate the Codex.' }); });
    }
    if (resolves(b, STAT_PATH) <= 0) out.errors.push({ path: STAT_PATH, message: 'The ruleset declares no stats, so stat tables cannot be built.' });
    if (resolves(b, ELEM_PATH) <= 0) out.warnings.push({ path: ELEM_PATH, message: 'The ruleset declares no elements. Element fields will be empty.' });
    if (resolves(b, TAX_PATH) <= 0) out.warnings.push({ path: TAX_PATH, message: 'The taxonomy has no values. Enemy families cannot be typed.' });
    var fs = U.isObj(rs.formulaSet) ? rs.formulaSet : {};
    Object.keys(fs).forEach(function (role) {
      var v = fs[role];
      if (FORMULA_IDS.indexOf(v) < 0 && !(typeof v === 'string' && /^frm_/.test(v))) out.warnings.push({ path: 'charter.ruleset.formulaSet.' + role, message: 'Formula set role ' + role + ' names "' + v + '", which is neither a template nor a formula record.' });
    });
    var seen = {};
    Object.keys(cx.types).forEach(function (tn) {
      var t = cx.types[tn];
      if (!U.isObj(t) || !Array.isArray(t.fields)) { out.errors.push({ path: 'codex.types.' + tn, message: 'Type ' + tn + ' has no field list.' }); return; }
      var p = Kit.codex.normPrefix(t.prefix);
      if (!p || !Kit.codex.prefixInfo(p)) out.errors.push({ path: 'codex.types.' + tn + '.prefix', message: 'Type ' + tn + ' uses an unknown prefix ' + t.prefix + '.' });
      else if (seen[p]) out.errors.push({ path: 'codex.types.' + tn + '.prefix', message: 'Types ' + seen[p] + ' and ' + tn + ' share the prefix ' + p + '.' });
      else seen[p] = tn;
      walkFields(t.fields, function (f, fp) {
        var where = 'codex.types.' + tn + '.' + fp;
        if (f.refPrefix) [].concat(f.refPrefix).forEach(function (rp) { if (!Kit.codex.prefixInfo(rp)) out.errors.push({ path: where, message: tn + '.' + fp + ' references unknown prefix ' + rp + '.' }); });
        if (f.enumFrom && resolves(b, f.enumFrom) < 0) out.errors.push({ path: where, message: tn + '.' + fp + ' reads a vocabulary at ' + f.enumFrom + ' that does not exist.' });
        if (f.rowsFrom && resolves(b, f.rowsFrom) < 0) out.errors.push({ path: where, message: tn + '.' + fp + ' reads rows at ' + f.rowsFrom + ' that do not exist.' });
      });
    });
    if (!U.isObj(cx.saveSchema) || !Array.isArray(cx.saveSchema.fields)) out.errors.push({ path: 'codex.saveSchema', message: 'The save schema is missing. Regenerate the Codex.' });
    if (!out.errors.length) out.state = 'ready';
    else if (out.state !== 'stale') out.state = 'invalid';
    out.ok = !out.errors.length;
    return out;
  };

  // ---------------------------------------------------------------- module validators
  function add(ctx, id, path, msg, level) { ctx.add({ recordId: id, fieldPath: path, message: msg, level: level || 'warning' }); }
  function rulesOf(b, p) { return b.rules && U.isObj(b.rules[p]) ? b.rules[p] : {}; }
  Kit.validate.register('codex', function (b, ctx) {
    if (!b.charter || !b.charter.locked) return;
    var c = WSX.check(b);
    c.errors.forEach(function (e) {
      var level = (c.state === 'stale' || /^codex\.version$/.test(e.path)) ? 'warning' : 'error';
      add(ctx, 'codex', e.path, e.message, level);
    });
    c.warnings.forEach(function (e) { add(ctx, 'codex', e.path, e.message, 'warning'); });
  });
  Kit.validate.register('codex.affinity', function (b, ctx) {
    var enms = rulesOf(b, 'enm_');
    Object.keys(enms).forEach(function (id) {
      var e = enms[id], ov = U.isObj(e.affinityOverrides) ? e.affinityOverrides : null;
      if (!ov || !e.family) return;
      var fe = Kit.index(b).byId[e.family];
      if (!fe) return;
      var def = WSX.defaultAffinity(b, fe.record.type, !!fe.record.absorbsOwnType);
      Object.keys(ov).forEach(function (k) {
        var d = def[k], o = ov[k];
        if (!o || !d) return;
        var good = { resist: 1, immune: 1, absorb: 1 };
        if ((good[d] && o === 'weak') || (d === 'weak' && good[o])) {
          add(ctx, id, 'affinityOverrides.' + k, 'Override ' + k + ' is ' + o + ' but the ' + fe.name + ' family ' + (d === 'weak' ? 'is weak to it' : (d === 'absorb' ? 'absorbs it' : 'resists it')) + '. Make sure this contradiction is intended.');
        }
      });
    });
  });
  Kit.validate.register('codex.slotLinks', function (b, ctx) {
    var eq = rulesOf(b, 'eqp_');
    Object.keys(eq).forEach(function (id) {
      var sl = eq[id].slotLayout;
      if (!U.isObj(sl) || !Array.isArray(sl.links)) return;
      var n = Number(sl.count) || 0;
      sl.links.forEach(function (lk, i) {
        var path = 'slotLayout.links[' + i + ']';
        if (!Array.isArray(lk) || lk.length !== 2) { add(ctx, id, path, 'Link ' + (i + 1) + ' must be a pair of slot numbers.'); return; }
        var a = Number(lk[0]), c = Number(lk[1]);
        if (!(a >= 0 && a < n) || !(c >= 0 && c < n)) add(ctx, id, path, 'Link ' + (i + 1) + ' (' + lk[0] + ' to ' + lk[1] + ') points past the ' + n + ' slot' + (n === 1 ? '' : 's') + ' this gear has.');
        else if (a === c) add(ctx, id, path, 'Link ' + (i + 1) + ' joins slot ' + a + ' to itself.');
      });
    });
  });
  Kit.validate.register('codex.materiaGrants', function (b, ctx) {
    var mats = rulesOf(b, 'mat_');
    var idx = Kit.index(b);
    Object.keys(mats).forEach(function (id) {
      var m = mats[id], allowed = MAT_GRANTS[m.kind];
      if (!allowed || !Array.isArray(m.grants)) return;
      m.grants.forEach(function (g, i) {
        if (!U.isObj(g) || !g.abl) return;
        var ab = idx.byId[g.abl];
        if (!ab || !ab.record.kind) return;
        if (allowed.indexOf(ab.record.kind) < 0) {
          add(ctx, id, 'grants[' + i + '].abl', m.kind === 'support'
            ? 'Support materia modifies its linked neighbor and should not grant abilities, but it grants ' + ab.name + '.'
            : ab.name + ' is ' + (/^[aeiou]/.test(ab.record.kind) ? 'an ' : 'a ') + ab.record.kind + ' ability, which ' + m.kind + ' materia should not grant (expected ' + allowed.join(' or ') + ').');
        }
      });
    });
  });
  Kit.validate.register('codex.gambitParams', function (b, ctx) {
    var idx = Kit.index(b);
    function checkRules(id, list, base) {
      if (!Array.isArray(list)) return;
      list.forEach(function (r, i) {
        var c = U.isObj(r) && U.isObj(r.condition) ? r.condition : null;
        if (!c || !c.kind) return;
        var path = base + '[' + i + '].condition.param', prm = c.param == null ? '' : String(c.param).trim();
        if (NUMERIC_CONDS[c.kind] && (prm === '' || !isFinite(Number(prm)))) add(ctx, id, path, 'Condition ' + c.kind + ' needs a number parameter.');
        if (STATUS_CONDS[c.kind]) {
          if (!/^sta_/.test(prm)) add(ctx, id, path, 'Condition ' + c.kind + ' needs a status ID parameter.');
          else if (!idx.byId[prm]) add(ctx, id, path, 'Broken reference: ' + prm + ' does not exist.', 'broken');
        }
      });
    }
    ['gmb_', 'bst_'].forEach(function (p) {
      var rs = rulesOf(b, p);
      Object.keys(rs).forEach(function (id) { checkRules(id, rs[id].rules, 'rules'); });
    });
  });
  Kit.validate.register('codex.formulaSource', function (b, ctx) {
    var fs = rulesOf(b, 'frm_');
    Object.keys(fs).forEach(function (id) {
      var f = fs[id], hasT = !!f.template, hasE = !!(f.expr && String(f.expr).trim());
      if (!hasT && !hasE) add(ctx, id, 'template', 'Choose a template or write an expression.');
      else if (hasT && hasE) add(ctx, id, 'expr', 'Both a template and an expression are set. The template wins.');
    });
  });
  Kit.validate.register('codex.orphans', function (b, ctx) {
    if (!b.codex || !b.codex.version || !U.isObj(b.codex.prefixes)) return;
    Object.keys(b.rules || {}).forEach(function (p) {
      var cp = b.codex.prefixes[p];
      if (cp && cp.type) return;
      Object.keys(b.rules[p] || {}).forEach(function (id) {
        add(ctx, id, 'id', 'No type in Codex version ' + b.codex.version + ' covers ' + p + ' records. The record is kept but inactive.');
      });
    });
  });
  Kit.jump.register({
    test: function (rid) { return rid === 'codex'; },
    name: function () { return 'Codex'; },
    go: function () { return Kit.go('codex'); }
  });

  // ---------------------------------------------------------------- UI helpers
  function uiGet() { var s = Kit.store.get(UI_KEY, {}); return U.isObj(s) ? s : {}; }
  function uiSet(patch) { var s = uiGet(); Object.keys(patch).forEach(function (k) { s[k] = patch[k]; }); Kit.store.set(UI_KEY, s); }
  function typeDetail(f) {
    var bits = [];
    if (f.refPrefix) bits.push('refs ' + [].concat(f.refPrefix).join(' '));
    if (f.enumFrom) bits.push('from ' + f.enumFrom);
    if (f.rowsFrom) bits.push('rows from ' + f.rowsFrom);
    if (f.values) bits.push(f.values.map(function (v) { return U.isObj(v) ? v.key : v; }).join(' | '));
    if (f.cellValues) bits.push('cells ' + f.cellValues.map(function (v) { return U.isObj(v) ? v.key : v; }).join(' | '));
    if (f.cell && f.type === 'table') bits.push('cell ' + f.cell);
    if (f.min != null || f.max != null) bits.push((f.min != null ? f.min : '') + ' to ' + (f.max != null ? f.max : ''));
    if (f.derived) bits.push('derived, read only');
    return bits.join('; ');
  }
  function fieldRows(fields, depth, rows) {
    (fields || []).forEach(function (f) {
      if (!f || !f.key) return;
      var fwdInfo = f.refPrefix && [].concat(f.refPrefix).every(function (p) { var i = Kit.codex.prefixInfo(p); return i && i.forge !== 146; });
      rows.push('<tr><td class="cx-key" style="padding-left:' + (8 + depth * 16) + 'px"><code>' + U.esc(f.key) + '</code>' + (f.required ? ' <span class="req" title="Required">*</span>' : '') + '</td>' +
        '<td>' + U.esc(f.label || f.key) + '</td>' +
        '<td><span class="chip chip-muted">' + U.esc(f.type) + '</span>' + (fwdInfo || f.forward ? ' <span class="chip chip-forward">Forward &middot; ' + U.esc(Kit.codex.ownerOf([].concat(f.refPrefix)[0])) + '</span>' : '') + '</td>' +
        '<td class="cx-detail">' + U.esc(typeDetail(f)) + '</td></tr>');
      if (Array.isArray(f.of)) fieldRows(f.of, depth + 1, rows);
      else if (U.isObj(f.of) && f.of.type) fieldRows([Object.assign({ key: '[item]', label: 'Each item' }, f.of)], depth + 1, rows);
    });
    return rows;
  }
  function fieldsTable(fields, withBase) {
    var all = withBase ? [{ key: 'id', label: 'ID', type: 'text', required: true, readOnly: true }, { key: 'name', label: 'Name', type: 'text', required: true }, { key: 'charterVersion', label: 'Charter version', type: 'int' }].concat(fields, [{ key: 'notes', label: 'Notes', type: 'longtext' }]) : fields;
    return '<div class="tbl-wrap"><table class="tbl cx-fields"><thead><tr><th scope="col">Key</th><th scope="col">Label</th><th scope="col">Type</th><th scope="col">Detail</th></tr></thead><tbody>' + fieldRows(all, 0, []).join('') + '</tbody></table></div>';
  }
  function showReport(full) {
    var r = full.report || {};
    Kit.ui.dialog({
      title: 'Codex version ' + full.version + ' generated', wide: true,
      body: function (body) {
        body.appendChild(U.el('p', null, 'Built from Charter version ' + full.charterVersion + '. ' + full.preserved + ' Rules record' + (full.preserved === 1 ? ' was' : 's were') + ' preserved; regenerating never deletes records.'));
        body.appendChild(reportNode(full));
      },
      actions: [{ label: 'Close', kind: 'primary' }]
    });
  }
  function reportNode(full) {
    var r = full.report || {}, wrap = U.el('div', 'cx-report');
    var parts = [];
    if (r.typesAdded && r.typesAdded.length && !full.first) parts.push('<p><strong>Types added:</strong> ' + r.typesAdded.map(U.esc).join(', ') + '</p>');
    if (r.typesRemoved && r.typesRemoved.length) parts.push('<p><strong>Types removed:</strong> ' + r.typesRemoved.map(U.esc).join(', ') + '</p>');
    (r.fields || []).forEach(function (f) {
      var li = [];
      f.added.forEach(function (p) { li.push('<li><span class="chip chip-ok">added</span> <code>' + U.esc(p) + '</code></li>'); });
      f.removed.forEach(function (p) { li.push('<li><span class="chip chip-error">removed</span> <code>' + U.esc(p) + '</code></li>'); });
      f.retyped.forEach(function (p) { li.push('<li><span class="chip chip-warning">retyped</span> <code>' + U.esc(p) + '</code></li>'); });
      parts.push('<div class="cx-report-type"><strong>' + U.esc(f.type) + '</strong> <code>' + U.esc(f.prefix) + '</code><ul class="diff-list">' + li.join('') + '</ul></div>');
    });
    (full.orphans || []).forEach(function (o) { parts.push('<p class="cx-orphan">' + Kit.icon('warn') + ' ' + o.count + ' ' + U.esc(o.prefix) + ' record' + (o.count === 1 ? ' has' : 's have') + ' no type in this Codex. They are kept and flagged as inactive.</p>'); });
    if (full.first) parts.push('<p>' + (r.typesAdded || []).length + ' record types created.</p>');
    else if (!parts.length) parts.push('<p class="muted">No fields were added or removed.</p>');
    wrap.innerHTML = parts.join('');
    return wrap;
  }

  // ---------------------------------------------------------------- render
  var st = { filter: '' };
  function statusChip(c) {
    if (c.state === 'ready') return '<span class="chip chip-ok">' + Kit.icon('check') + 'Valid</span>';
    if (c.state === 'stale') return '<span class="chip chip-warning">' + Kit.icon('warn') + 'Needs regenerating</span>';
    if (c.state === 'invalid') return '<span class="chip chip-error">' + Kit.icon('warn') + 'Invalid</span>';
    return '<span class="chip chip-muted">Not generated</span>';
  }
  function paintBar(host, b, c) {
    var bar = U.el('section', 'panel cx-bar');
    var info = U.el('div', 'cx-bar-info');
    var cx = b.codex || {};
    info.innerHTML = '<h2 class="panel-title">Codex ' + statusChip(c) + (cx.version ? '<span class="chip chip-accent">v' + cx.version + '</span>' : '') + '</h2>' +
      '<p class="cx-hint">' + (cx.version
        ? 'Generated from Charter v' + U.esc(cx.generatedFromCharter) + ' with the ' + U.esc(b.charter.ruleset.progression || 'no') + ' module on ' + U.esc(U.fmtDate ? U.fmtDate(cx.generatedAt) : cx.generatedAt) + '.'
        : 'The Codex turns the locked ruleset into record types, ID prefixes, and a save schema. Rules opens once it validates.') + '</p>';
    bar.appendChild(info);
    var acts = U.el('div', 'cx-bar-actions');
    var gen = U.el('button', 'btn ' + (c.state === 'ready' ? '' : 'btn-primary'), Kit.icon('spark') + '<span>' + (cx.version ? 'Regenerate' : 'Generate Codex') + '</span>');
    gen.type = 'button';
    gen.title = cx.version ? 'Rebuild the Codex from the locked ruleset. Records are kept.' : 'Build the Codex from the locked ruleset.';
    gen.addEventListener('click', async function () {
      if (cx.version && c.state === 'ready') {
        var ok = await Kit.ui.confirm({ title: 'Regenerate the Codex?', message: 'The Codex is already current. Regenerating rebuilds the types from the ruleset and keeps every record.', okLabel: 'Regenerate' });
        if (!ok) return;
      }
      var r = WSX.generate();
      if (!r.ok) Kit.ui.toast(r.reason, 'warn');
    });
    acts.appendChild(gen);
    if (c.ok) {
      var go = U.el('button', 'btn btn-primary', Kit.icon('sword') + '<span>Open Rules</span>'); go.type = 'button';
      go.addEventListener('click', function () { Kit.go('rules'); });
      acts.appendChild(go);
    }
    bar.appendChild(acts);
    host.appendChild(bar);
    if (c.errors.length || c.warnings.length) {
      var iss = U.el('section', 'panel cx-issues');
      iss.innerHTML = '<h3 class="section-h">' + (c.errors.length ? 'Blocking issues' : 'Advisories') + '</h3>';
      var ul = U.el('ul', 'diff-list');
      c.errors.forEach(function (e) { ul.appendChild(U.el('li', null, '<span class="chip chip-error">error</span><span>' + U.esc(e.message) + '</span>')); });
      c.warnings.forEach(function (e) { ul.appendChild(U.el('li', null, '<span class="chip chip-warning">warning</span><span>' + U.esc(e.message) + '</span>')); });
      iss.appendChild(ul);
      host.appendChild(iss);
    }
  }
  function paintEmpty(host) {
    var p = U.el('section', 'panel cx-empty');
    p.innerHTML = '<div class="stub-glyph">' + Kit.icon('book') + '</div><h2>No Codex yet</h2><p>Generate the Codex to turn your locked ruleset into record types. Nothing is created in Rules; the Codex only defines what records can hold.</p>';
    var gen = U.el('button', 'btn btn-primary', Kit.icon('spark') + '<span>Generate Codex</span>'); gen.type = 'button';
    gen.addEventListener('click', function () { var r = WSX.generate(); if (!r.ok) Kit.ui.toast(r.reason, 'warn'); });
    p.appendChild(gen);
    host.appendChild(p);
  }
  function typeCard(b, t, counts, openSet) {
    var info = Kit.codex.prefixInfo(t.prefix) || {};
    var opened = Kit.codex.isOpened(info.ns, b);
    var det = U.el('details', 'cx-type');
    det.dataset.type = t.name;
    if (openSet[t.name]) det.open = true;
    var sum = U.el('summary');
    sum.innerHTML = '<span class="cx-type-name">' + U.esc(t.label || t.name) + '</span>' +
      '<span class="cx-type-meta"><code class="cx-prefix">' + U.esc(t.prefix) + '</code>' +
      '<span class="chip chip-muted">forge ' + U.esc(info.forge) + '</span>' +
      '<span class="chip ' + (opened ? 'chip-ok' : 'chip-muted') + '">' + U.esc(info.ns) + (opened ? ' open' : ' closed') + '</span>' +
      '<span class="chip chip-accent">' + (counts[t.prefix] || 0) + ' record' + ((counts[t.prefix] || 0) === 1 ? '' : 's') + '</span></span>';
    det.appendChild(sum);
    det.addEventListener('toggle', function () { var o = uiGet().open || {}; if (det.open) o[t.name] = 1; else delete o[t.name]; uiSet({ open: o }); if (det.open && !det.dataset.painted) paintTypeBody(det, t); });
    if (det.open) paintTypeBody(det, t);
    return det;
  }
  function paintTypeBody(det, t) {
    det.dataset.painted = '1';
    var body = U.el('div', 'cx-type-body');
    var deps = (t.dependsOn || []).length ? t.dependsOn.map(function (d) { return '<code class="chip chip-muted">' + U.esc(d) + '</code>'; }).join(' ') : '<span class="muted">No Charter dependencies.</span>';
    body.innerHTML = '<p class="cx-deps"><strong>Depends on:</strong> ' + deps + '</p>' + fieldsTable(t.fields, true);
    det.appendChild(body);
  }
  function paintTypes(host, b) {
    var types = Kit.codex.types(b), counts = recordsByPrefix(b), openSet = uiGet().open || {};
    var sec = U.el('section', 'panel cx-types');
    var head = U.el('div', 'cx-sec-head');
    head.innerHTML = '<h3 class="section-h">Record types</h3>';
    var srch = U.el('input', 'inp cx-search'); srch.type = 'search'; srch.placeholder = 'Filter by name, prefix, or field'; srch.setAttribute('aria-label', 'Filter record types'); srch.value = st.filter;
    head.appendChild(srch);
    sec.appendChild(head);
    var groupsHost = U.el('div');
    sec.appendChild(groupsHost);
    function paint() {
      U.clear(groupsHost);
      var q = st.filter.trim().toLowerCase(), any = false;
      GROUPS.forEach(function (g) {
        var list = Object.keys(types).map(function (k) { return types[k]; }).filter(function (t) {
          if (!t.prefix || t.section || t.name === 'ZzDemo') return false;
          var grp = t.group || (t.prefix === 'chp_' ? 'charter' : 'core');
          if (grp !== g.key) return false;
          if (!q) return true;
          var hay = [t.name, t.label, t.prefix].concat(Object.keys(fieldPaths(t.fields, '', {}))).join(' ').toLowerCase();
          return hay.indexOf(q) >= 0;
        });
        if (!list.length) return;
        any = true;
        var gh = U.el('div', 'cx-group');
        gh.innerHTML = '<h4 class="cx-group-h">' + U.esc(g.label) + ' <span class="muted">' + list.length + '</span></h4><p class="muted cx-group-text">' + U.esc(g.text) + '</p>';
        var grid = U.el('div', 'cx-type-list');
        list.forEach(function (t) { grid.appendChild(typeCard(b, t, counts, openSet)); });
        gh.appendChild(grid);
        groupsHost.appendChild(gh);
      });
      if (!any) groupsHost.appendChild(U.el('p', 'empty-line', 'No types match that filter.'));
    }
    srch.addEventListener('input', U.debounce(function () { st.filter = srch.value; paint(); }, 150));
    paint();
    host.appendChild(sec);
  }
  function paintPrefixes(host, b) {
    var cx = b.codex || {}, counts = recordsByPrefix(b);
    var sec = U.el('details', 'panel cx-block');
    sec.open = !!uiGet().prefixesOpen;
    sec.addEventListener('toggle', function () { uiSet({ prefixesOpen: sec.open }); });
    var rows = Object.keys(Kit.codex.PREFIXES).sort(function (x, y) {
      var a = Kit.codex.PREFIXES[x], c = Kit.codex.PREFIXES[y];
      return (a.forge - c.forge) || x.localeCompare(y);
    }).map(function (p) {
      var info = Kit.codex.PREFIXES[p], cp = U.isObj(cx.prefixes) ? cx.prefixes[p] : null;
      var tn = cp && cp.type ? cp.type : null;
      var opened = Kit.codex.isOpened(info.ns, b);
      var state = tn ? '<span class="chip chip-accent">' + U.esc(tn) + '</span>' : info.forge !== 146 ? '<span class="chip chip-forward">Owed by ' + info.forge + '</span>' : '<span class="chip chip-muted">Inactive module</span>';
      return '<tr><td><code>' + U.esc(p) + '</code></td><td>' + U.esc(info.ns) + ' <span class="chip ' + (opened ? 'chip-ok' : 'chip-muted') + '">' + (opened ? 'open' : 'closed') + '</span></td><td>' + info.forge + '</td><td>' + U.esc(info.module || 'core') + '</td><td>' + state + '</td><td class="num">' + (counts[p] || 0) + '</td></tr>';
    });
    sec.innerHTML = '<summary class="cx-block-sum"><h3 class="section-h">Prefix table</h3><span class="muted">' + rows.length + ' prefixes</span></summary>' +
      '<div class="tbl-wrap"><table class="tbl"><thead><tr><th scope="col">Prefix</th><th scope="col">Namespace</th><th scope="col">Forge</th><th scope="col">Module</th><th scope="col">Type</th><th scope="col">Records</th></tr></thead><tbody>' + rows.join('') + '</tbody></table></div>';
    host.appendChild(sec);
  }
  // Forward slots: every field that can hold an ID owed by a later forge, plus the forward IDs actually held today.
  WSX.forwardSlots = function (b) {
    b = b || cur();
    var types = Kit.codex.types(b), out = {};
    function bucket(f) { return out[f] = out[f] || { forge: f, name: FORGE_NAMES[f] || ('Forge ' + f), slots: [], held: [] }; }
    Object.keys(types).forEach(function (tn) {
      var t = types[tn];
      if (!t.prefix || t.section || tn === 'ZzDemo') return;
      walkFields(t.fields, function (f, fp) {
        if (!f.refPrefix) return;
        [].concat(f.refPrefix).forEach(function (p) {
          var info = Kit.codex.prefixInfo(p);
          if (info && info.forge !== 146) bucket(info.forge).slots.push({ type: tn, typePrefix: t.prefix, field: fp, prefix: Kit.codex.normPrefix(p) });
        });
      });
    });
    if (b.codex && b.codex.saveSchema) walkFields(b.codex.saveSchema.fields, function (f, fp) {
      if (!f.refPrefix) return;
      [].concat(f.refPrefix).forEach(function (p) { var info = Kit.codex.prefixInfo(p); if (info && info.forge !== 146) bucket(info.forge).slots.push({ type: 'SaveGame', typePrefix: 'save', field: fp, prefix: Kit.codex.normPrefix(p) }); });
    });
    var res = Kit.validate(b);
    res.forward.forEach(function (it) { if (it.owedBy) bucket(it.owedBy).held.push({ id: it.id, recordId: it.recordId, fieldPath: it.fieldPath }); });
    return Object.keys(out).sort().map(function (k) { return out[k]; });
  };
  function paintForward(host, b) {
    var sec = U.el('section', 'panel cx-block cx-forward');
    sec.innerHTML = '<h3 class="section-h">Forward slots by owing forge</h3><p class="muted">Fields that hold IDs from later forges. They are legal now and listed in the export manifest as owed.</p>';
    var grid = U.el('div', 'cx-fwd-grid');
    WSX.forwardSlots(b).forEach(function (g) {
      var card = U.el('div', 'card cx-fwd');
      var byPrefix = {};
      g.slots.forEach(function (s) { (byPrefix[s.prefix] = byPrefix[s.prefix] || []).push(s); });
      var lines = Object.keys(byPrefix).sort().map(function (p) {
        return '<li><code>' + U.esc(p) + '</code><span>' + byPrefix[p].map(function (s) { return U.esc(s.typePrefix === 'save' ? 'save' : s.typePrefix) + '.' + U.esc(s.field); }).join(', ') + '</span></li>';
      });
      card.innerHTML = '<div class="cx-fwd-head"><strong>' + U.esc(g.name) + '</strong><span class="chip chip-forward">forge ' + g.forge + '</span></div>' +
        '<p class="muted">' + g.slots.length + ' slot' + (g.slots.length === 1 ? '' : 's') + ' declared, ' + g.held.length + ' forward ID' + (g.held.length === 1 ? '' : 's') + ' held.</p>' +
        '<ul class="cx-fwd-list">' + lines.join('') + '</ul>';
      if (g.held.length) {
        var hl = U.el('div', 'cx-held');
        g.held.slice(0, 12).forEach(function (h) {
          var bt = U.el('button', 'btn btn-ghost cx-held-btn', '<code>' + U.esc(h.id) + '</code><span class="muted">in ' + U.esc(h.recordId) + '</span>'); bt.type = 'button';
          bt.addEventListener('click', function () { Kit.jump(h.recordId, h.fieldPath); });
          hl.appendChild(bt);
        });
        if (g.held.length > 12) hl.appendChild(U.el('span', 'muted', '+' + (g.held.length - 12) + ' more'));
        card.appendChild(hl);
      }
      grid.appendChild(card);
    });
    sec.appendChild(grid);
    host.appendChild(sec);
  }
  function paintSave(host, b) {
    var ss = b.codex && b.codex.saveSchema;
    if (!ss) return;
    var sec = U.el('details', 'panel cx-block');
    sec.open = !!uiGet().saveOpen;
    sec.addEventListener('toggle', function () { uiSet({ saveOpen: sec.open }); });
    var pol = ss.policy || {};
    sec.innerHTML = '<summary class="cx-block-sum"><h3 class="section-h">Save schema</h3><span class="muted">v' + ss.schemaVersion + ' &middot; ' + (pol.slots || 0) + ' slot' + (pol.slots === 1 ? '' : 's') + ', ' + U.esc(pol.mode || 'no mode') + (pol.suspend ? ', suspend on' : '') + '</span></summary>' +
      '<p class="muted">Stored at codex.saveSchema. Game builds write saves in this shape; bundleHash ties a save to the bundle it was made against.</p>' + fieldsTable(ss.fields, false);
    host.appendChild(sec);
  }
  function paintLastReport(host, b) {
    var rep = Kit.store.get(REPORT_KEY, null);
    if (!U.isObj(rep) || !b.codex.version || rep.version !== b.codex.version || rep.first) return;
    var sec = U.el('details', 'panel cx-block');
    sec.innerHTML = '<summary class="cx-block-sum"><h3 class="section-h">Last regeneration</h3><span class="muted">v' + rep.version + ' from Charter v' + rep.charterVersion + '</span></summary>';
    sec.appendChild(reportNode(rep));
    host.appendChild(sec);
  }
  WSX.canEnter = function (b) { return b && b.charter.locked ? true : 'Lock the Charter to open the Codex.'; };
  WSX.render = function (host) {
    var b = cur(), c = WSX.check(b);
    paintBar(host, b, c);
    if (!b.codex.version) { paintEmpty(host); return; }
    paintLastReport(host, b);
    paintTypes(host, b);
    paintForward(host, b);
    paintPrefixes(host, b);
    paintSave(host, b);
  };
  WSX.focus = function (rid) {
    var t = Kit.codex.typeFor(Kit.ids.prefixOf(rid) || '');
    var el = t && document.querySelector('.cx-type[data-type="' + t + '"]');
    if (el) { el.open = true; el.scrollIntoView({ block: 'start' }); }
  };
  WSX.FORMULA_IDS = FORMULA_IDS;
  WSX.ABL_KINDS = ABL_KINDS;
  WSX.MAT_KINDS = MAT_KINDS;
  WSX.MAT_GRANTS = MAT_GRANTS;
  WSX.AFFINITIES = AFFINITIES;
  WSX.COND_KINDS = COND_KINDS;
  WSX.SELECTORS = SELECTORS;
  WSX.TRIGGERS = TRIGGERS;
  WSX.SUPPORT_EFFECTS = SUPPORT_EFFECTS;
  WSX.MODULE_TYPE = MODULE_TYPE;
  Kit.mount('codex', { title: 'Codex', icon: 'book', canEnter: WSX.canEnter, render: WSX.render, focus: function (rid) { WSX.focus(rid); } });
})();
// === WS:CODEX END ===
// === WS:RULES BEGIN ===
(function () {
  'use strict';
  var U = Kit.util;
  var WSX = window.WS.rules = { id: 'rules' };
  var UI_KEY = 'saga146:rules:ui';
  var STAT_PATH = 'charter.ruleset.stats', ELEM_PATH = 'charter.ruleset.elements', TAX_PATH = 'charter.ruleset.taxonomy';
  var KEY_RE = /^[a-z][a-z0-9]*$/;
  var uidn = 0;

  function cur() { return Kit.bundle.current(); }
  function rsOf(b) { b = b || cur(); return b && b.charter && U.isObj(b.charter.ruleset) ? b.charter.ruleset : {}; }
  function alive(n) { return !!n && document.contains(n); }
  function el(tag, cls, html) { return U.el(tag, cls, html); }
  function esc(s) { return U.esc(s); }
  function hasOwn(o, k) { return o !== null && typeof o === 'object' && Object.prototype.hasOwnProperty.call(o, k); }
  function uiGet() { var s = Kit.store.get(UI_KEY, {}); return U.isObj(s) ? s : {}; }
  function uiSet(patch) { var s = uiGet(); Object.keys(patch).forEach(function (k) { s[k] = patch[k]; }); Kit.store.set(UI_KEY, s); return s; }
  function button(label, icon, cls, fn) {
    var b = el('button', 'btn' + (cls ? ' ' + cls : ''), (icon ? Kit.icon(icon) : '') + '<span>' + esc(label) + '</span>');
    b.type = 'button';
    if (fn) b.addEventListener('click', fn);
    return b;
  }
  function iconButton(icon, label, fn, cls) {
    var b = el('button', 'btn btn-ghost btn-icon' + (cls ? ' ' + cls : ''), Kit.icon(icon));
    b.type = 'button'; b.setAttribute('aria-label', label); b.title = label;
    if (fn) b.addEventListener('click', fn);
    return b;
  }
  function cap1(s) { s = String(s || ''); return s.charAt(0).toUpperCase() + s.slice(1); }

  WSX.canEnter = function (b) {
    if (!b || !b.charter.locked) return 'Lock the Charter to open Rules.';
    if (!b.codex.version || !Object.keys(b.codex.types || {}).length) return 'Generate the Codex to open Rules.';
    var c = window.WS.codex && window.WS.codex.check ? window.WS.codex.check(b) : { ok: true };
    if (!c.ok) return c.state === 'stale' ? 'Regenerate the Codex after the Charter amendment to open Rules.' : 'Fix the Codex issues to open Rules.';
    return true;
  };

  // ---------------------------------------------------------------- formula library
  // Mirror of the template registry that ENGINE:BATTLE implements in Pass 5. Parameter names and defaults are the
  // contract. Each template is also written as a safe expression so the previews and the engine can be compared.
  var FORMULA_ORDER = ['phys.ff6', 'mag.ff6', 'phys.sub', 'mag.flat', 'heal.std', 'var.std', 'exp.curve', 'ap.curve', 'atb.fill'];
  var FORMULA_LIB = {
    'phys.ff6': {
      id: 'phys.ff6', role: 'phys', kind: 'damage', label: 'Physical damage, FF6 style',
      expr: 'max(p.floor, floor((power + a.level * a.level * a.str / p.levelDiv) * (p.defBase - min(t.def, p.defBase - 1)) / p.defBase * p.mult))',
      params: { levelDiv: 256, defBase: 256, mult: 1, floor: 1 },
      note: 'Base damage grows with the square of the attacker level, then the target defense scales it down.'
    },
    'mag.ff6': {
      id: 'mag.ff6', role: 'mag', kind: 'damage', label: 'Magic damage, FF6 style',
      expr: 'max(p.floor, floor((power * p.powerMult + a.level * a.mag * power / p.levelDiv) * (p.defBase - min(t.mdef, p.defBase - 1)) / p.defBase))',
      params: { powerMult: 4, levelDiv: 32, defBase: 256, floor: 1 },
      note: 'Spell power dominates. Level and magic add to it, and magic defense scales the total down.'
    },
    'phys.sub': {
      id: 'phys.sub', role: 'phys', kind: 'damage', label: 'Physical damage, subtractive',
      expr: 'max(p.floor, floor(a.str * p.atkMult + power - t.def * p.defMult))',
      params: { atkMult: 1, defMult: 0.5, floor: 1 },
      note: 'Attack plus power minus a share of defense. Simple and easy to balance by hand.'
    },
    'mag.flat': {
      id: 'mag.flat', role: 'mag', kind: 'damage', label: 'Magic damage, flat',
      expr: 'max(p.floor, floor(power + a.mag * p.magMult - t.mdef * p.mdefMult))',
      params: { magMult: 1, mdefMult: 0.5, floor: 1 },
      note: 'Spell power plus magic minus a share of magic defense.'
    },
    'heal.std': {
      id: 'heal.std', role: 'heal', kind: 'heal', label: 'Healing, standard',
      expr: 'max(p.floor, floor((power + a.mag * p.magMult) * p.mult))',
      params: { magMult: 2, mult: 1, floor: 1 },
      note: 'Spell power plus magic, then a multiplier. Heal inversion for undead is applied by the engine.'
    },
    'var.std': {
      id: 'var.std', role: 'var', kind: 'variance', label: 'Damage variance',
      expr: '1 + p.spread * (2 * p.roll - 1)',
      params: { spread: 0.1, roll: 0.5 },
      note: 'A multiplier around one. The engine feeds roll from the seeded random stream, between 0 and 1.'
    },
    'exp.curve': {
      id: 'exp.curve', role: 'exp', kind: 'curve', label: 'EXP needed to reach a level',
      expr: 'floor(p.base * pow(max(a.level - 1, 0), p.exponent))',
      params: { base: 40, exponent: 2.1 },
      note: 'Total EXP required to reach level a.level. Sweep the level to see the whole curve.'
    },
    'ap.curve': {
      id: 'ap.curve', role: 'ap', kind: 'curve', label: 'AP needed to advance a level',
      expr: 'floor(p.base * pow(p.growth, max(a.level - 1, 0)))',
      params: { base: 100, growth: 2 },
      note: 'AP needed to move from level a.level to the next one. Used for materia levels.'
    },
    'atb.fill': {
      id: 'atb.fill', role: 'atb', kind: 'rate', label: 'ATB gauge fill per tick',
      expr: 'floor((a.spd + p.spdOffset) * p.rate)',
      params: { spdOffset: 20, rate: 8 },
      note: 'Gauge units added each tick. The gauge holds 65536 units.'
    }
  };
  WSX.FORMULA_LIB = FORMULA_LIB;
  WSX.FORMULA_ORDER = FORMULA_ORDER;

  function statKeys(b) {
    var st = rsOf(b).stats;
    return (Array.isArray(st) ? st : []).map(function (s) { return U.isObj(s) ? String(s.key || '') : ''; }).filter(Boolean);
  }
  function numericParams(o) {
    var out = {};
    if (U.isObj(o)) Object.keys(o).forEach(function (k) { if (typeof o[k] === 'number' && isFinite(o[k])) out[k] = o[k]; });
    return out;
  }
  function libSource(id) {
    var l = FORMULA_LIB[id];
    return l ? { id: l.id, label: l.label, kind: l.kind, expr: l.expr, params: U.clone(l.params), template: l.id, note: l.note } : null;
  }
  // A frm_ record resolves to an expression plus its parameters. A template wins over an expression.
  function recordSource(rec) {
    if (!U.isObj(rec)) return null;
    var over = numericParams(rec.params), params;
    if (rec.template && FORMULA_LIB[rec.template]) {
      var lib = FORMULA_LIB[rec.template];
      params = Object.assign(U.clone(lib.params), over);
      return { id: rec.id, label: rec.name || lib.label, kind: lib.kind, expr: lib.expr, params: params, template: rec.template, note: lib.note };
    }
    if (typeof rec.expr === 'string' && rec.expr.trim()) return { id: rec.id, label: rec.name || 'Formula', kind: 'custom', expr: rec.expr, params: over, template: null };
    return null;
  }
  // id may be a template id or a frm_ record id.
  WSX.formulaSource = function (id) {
    if (FORMULA_LIB[id]) return libSource(id);
    if (typeof id === 'string' && Kit.ids.isValid(id) && Kit.ids.prefixOf(id) === 'frm_') return recordSource(Kit.records.get(id));
    return null;
  };
  var astCache = {}, astCount = 0;
  function parseCached(expr) {
    if (astCache[expr]) return astCache[expr];
    var ast = Kit.expr.parse(expr);
    if (astCount > 300) { astCache = {}; astCount = 0; }
    astCache[expr] = ast; astCount++;
    return ast;
  }
  // scope = {a:{...}, t:{...}, power}. The formula parameters are added as scope.p.
  WSX.evalFormula = function (id, scope) {
    var src = WSX.formulaSource(id);
    if (!src) throw new Error('No formula found for ' + id + '.');
    var sc = { a: scope && scope.a || {}, t: scope && scope.t || {}, power: scope && scope.power != null ? scope.power : 0, p: src.params };
    return Kit.expr.evaluate(parseCached(src.expr), sc);
  };
  WSX.roleId = function (role) {
    var fs = rsOf().formulaSet;
    return U.isObj(fs) && typeof fs[role] === 'string' && fs[role] ? fs[role] : null;
  };
  // Evaluates the formula the ruleset assigns to a role (phys, mag, heal, exp, ap, atb, var).
  WSX.evalRole = function (role, scope) {
    var id = WSX.roleId(role);
    if (!id) throw new Error('The ruleset has no formula for the ' + role + ' role.');
    return WSX.evalFormula(id, scope);
  };

  // ---------------------------------------------------------------- usage and staleness
  function walkFields(obj, fields, base, cb) {
    if (!U.isObj(obj)) return;
    (fields || []).forEach(function (f) {
      if (!f || !f.key) return;
      var v = obj[f.key];
      if (v === undefined) return;
      var p = base ? base + '.' + f.key : f.key;
      cb(f, v, p);
      if (f.type === 'object' && Array.isArray(f.of)) walkFields(v, f.of, p, cb);
      else if (f.type === 'list' && Array.isArray(f.of) && Array.isArray(v)) v.forEach(function (it, i) { walkFields(it, f.of, p + '[' + i + ']', cb); });
    });
  }
  // What depends on a stat key, an element key, or a taxonomy value. Used to lock keys and to warn before deleting.
  WSX.usage = function (kind, key) {
    var b = cur(), out = [], types = Kit.codex.types(b), idx = Kit.index(b), r = rsOf(b);
    function add(rid, name, path) { out.push({ recordId: rid, name: name, path: path }); }
    if (kind === 'element') {
      (Array.isArray(r.elementRelations) ? r.elementRelations : []).forEach(function (x, i) {
        if (U.isObj(x) && (x.a === key || x.b === key)) add('charter:ruleset', 'Element relation ' + (i + 1), 'elementRelations[' + i + ']');
      });
      if (U.isObj(r.taxonomy) && Array.isArray(r.taxonomy.values) && r.taxonomy.values.indexOf(key) >= 0) add('charter:ruleset', 'Taxonomy value', 'taxonomy.values');
    }
    var re = kind === 'stat' ? new RegExp('\\b[at]\\.' + key + '\\b') : null;
    Object.keys(idx.byId).forEach(function (id) {
      var e = idx.byId[id], info = Kit.codex.prefixInfo(e.prefix);
      if (!info || info.ns !== 'rules') return;
      var tn = Kit.codex.typeFor(e.prefix, b), td = tn ? types[tn] : null;
      if (!td) return;
      walkFields(e.record, td.fields, '', function (desc, val, path) {
        if (kind === 'stat') {
          if (desc.type === 'table' && desc.rowsFrom === STAT_PATH && hasOwn(val, key)) add(id, e.name, path + '.' + key);
          else if (desc.type === 'formula' && typeof val === 'string' && re.test(val)) add(id, e.name, path);
        } else if (kind === 'element') {
          if (desc.type === 'table' && desc.rowsFrom === ELEM_PATH && hasOwn(val, key)) add(id, e.name, path + '.' + key);
          else if (desc.type === 'enum' && desc.enumFrom === ELEM_PATH && val === key) add(id, e.name, path);
        } else if (kind === 'taxon') {
          if (desc.type === 'enum' && desc.enumFrom === TAX_PATH && val === key) add(id, e.name, path);
        }
      });
    });
    return out;
  };
  function usageText(list) {
    var names = [], seen = {};
    list.forEach(function (u) { if (!seen[u.name]) { seen[u.name] = 1; names.push(u.name); } });
    return list.length + ' place' + (list.length === 1 ? '' : 's') + ' use it: ' + names.slice(0, 5).join(', ') + (names.length > 5 ? ', and more.' : '.');
  }
  // Records an amendment touched that have not been reviewed yet. Maps id to {need, hit}.
  function staleMap(b) {
    var m = {}, ams = b && b.charter && Array.isArray(b.charter.amendments) ? b.charter.amendments : [];
    if (!window.WS.charter || !window.WS.charter.impact) return m;
    ams.forEach(function (am) {
      window.WS.charter.impact(b, am.changedPaths || [], am.to).forEach(function (r) { m[r.id] = { need: am.to, hit: r.dependsOn }; });
    });
    return m;
  }
  WSX.staleIds = function () { return Object.keys(staleMap(cur())); };
  function refsTo(id) {
    var out = [], idx = Kit.index();
    Object.keys(idx.byId).forEach(function (rid) {
      if (rid === id) return;
      var e = idx.byId[rid];
      if (JSON.stringify(e.record).indexOf('"' + id + '"') >= 0) out.push(e.name);
    });
    if (JSON.stringify(rsOf().formulaSet || {}).indexOf('"' + id + '"') >= 0) out.push('Ruleset formula set');
    return out;
  }

  // ---------------------------------------------------------------- systems editors (write to charter.ruleset)
  var RS = WSX.systems = {};
  var ELEM_COLORS = ['#e4572e', '#3a86c8', '#8a6a3d', '#9ad1d4', '#f2d16b', '#7b4a9e', '#6fc7b6', '#f07a6e'];

  function ensureRuleset() {
    var b = cur();
    if (!U.isObj(b.charter.ruleset)) b.charter.ruleset = {};
    return b.charter.ruleset;
  }
  function sysCtx(onChange) {
    return {
      readOnly: !!cur().charter.locked,
      rs: ensureRuleset,
      changed: function () { Kit.index.invalidate(); Kit.bundle.touch('rules-systems'); if (onChange) onChange(); }
    };
  }
  function mkInput(o) {
    var i = el('input', 'inp' + (o.mono ? ' mono' : ''));
    i.type = o.type || 'text';
    if (o.type === 'number') { i.inputMode = o.step === 1 ? 'numeric' : 'decimal'; i.step = o.step != null ? o.step : 'any'; if (o.min != null) i.min = o.min; if (o.max != null) i.max = o.max; }
    i.value = o.value == null ? '' : o.value;
    if (o.label) i.setAttribute('aria-label', o.label);
    if (o.placeholder) i.placeholder = o.placeholder;
    if (o.maxLength) i.maxLength = o.maxLength;
    if (o.mono) i.spellcheck = false;
    if (o.readOnly) i.readOnly = true;
    if (o.onInput) i.addEventListener('input', function () { o.onInput(i.value, i); });
    return i;
  }
  function mkSelect(options, value, o) {
    var s = el('select', 'inp');
    s.appendChild(new Option(o.placeholder || 'Choose...', ''));
    options.forEach(function (x) { s.appendChild(new Option(x.label, x.value)); });
    if (value && !options.some(function (x) { return x.value === value; })) s.appendChild(new Option(value + ' (not declared)', value));
    s.value = value || '';
    if (o.label) s.setAttribute('aria-label', o.label);
    if (o.readOnly) s.disabled = true;
    if (o.onChange) s.addEventListener('change', function () { o.onChange(s.value); });
    return s;
  }
  function fieldBox(labelText, node, cls) {
    var f = el('div', 'rl-f' + (cls ? ' ' + cls : ''));
    var l = el('label', null, esc(labelText));
    if (node.tagName === 'INPUT' || node.tagName === 'SELECT') { var id = 'rlf_' + (++uidn); node.id = id; l.htmlFor = id; }
    f.appendChild(l); f.appendChild(node);
    return f;
  }
  function colorControl(value, readOnly, label, onChange) {
    var wrap = el('div', 'color-row');
    var c = el('input'); c.type = 'color'; c.setAttribute('aria-label', label + ' swatch');
    c.value = /^#[0-9a-fA-F]{6}$/.test(value || '') ? value : '#888888';
    var t = el('input', 'inp mono'); t.type = 'text'; t.maxLength = 7; t.spellcheck = false; t.placeholder = '#rrggbb'; t.value = value || '';
    t.setAttribute('aria-label', label + ' hex');
    if (readOnly) { c.disabled = true; t.readOnly = true; }
    c.addEventListener('input', function () { t.value = c.value; onChange(c.value); });
    t.addEventListener('input', function () { var v = t.value.trim(); if (/^#[0-9a-fA-F]{6}$/.test(v)) c.value = v; onChange(v); });
    wrap.appendChild(c); wrap.appendChild(t);
    return wrap;
  }
  function paintMsgs(refs, probs) {
    refs.forEach(function (r, i) {
      var m = probs[i] || [];
      U.clear(r.msg);
      r.row.classList.toggle('bad', m.length > 0);
      m.forEach(function (t) { r.msg.appendChild(el('div', 'msg msg-' + (t.level || 'error'), esc(t.text || t))); });
    });
  }
  function rowControls(ctx, arr, i, name, repaint, onDelete) {
    var box = el('div', 'rl-ctrls');
    if (ctx.readOnly) return box;
    box.appendChild(iconButton('up', 'Move ' + name + ' up', function () { if (i > 0) { var x = arr[i - 1]; arr[i - 1] = arr[i]; arr[i] = x; ctx.changed(); repaint(); } }));
    box.appendChild(iconButton('down', 'Move ' + name + ' down', function () { if (i < arr.length - 1) { var x = arr[i + 1]; arr[i + 1] = arr[i]; arr[i] = x; ctx.changed(); repaint(); } }));
    box.appendChild(iconButton('trash', 'Delete ' + name, onDelete));
    return box;
  }
  function keyPrompt(title, label, taken, maxLen) {
    return Kit.ui.prompt({
      title: title, label: label, okLabel: 'Add',
      placeholder: 'lowercase letters and digits',
      validate: function (v) {
        v = v.trim();
        if (!KEY_RE.test(v)) return 'Use lowercase letters and digits, starting with a letter.';
        if (v.length > maxLen) return 'Use at most ' + maxLen + ' characters.';
        if (taken.indexOf(v) >= 0) return 'That key is already in use.';
        return null;
      }
    });
  }
  function focusRow(host, idx) {
    var rows = host.querySelectorAll('.rl-row');
    var row = rows[idx];
    if (!row) return;
    row.scrollIntoView({ block: 'center' });
    var f = row.querySelector('input.inp:not([readonly])');
    if (f) { try { f.focus({ preventScroll: true }); } catch (e) {} }
  }

  // Stats
  function statProblems(arr) {
    var out = [], seen = {};
    arr.forEach(function (s) {
      var m = [];
      if (U.isObj(s)) {
        var k = String(s.key || '');
        if (!k) m.push('Give the stat a key.');
        else if (!KEY_RE.test(k)) m.push('Key must be lowercase letters and digits, starting with a letter.');
        else if (seen[k]) m.push('Another stat already uses the key "' + k + '".');
        if (k) seen[k] = 1;
        if (!String(s.label || '').trim()) m.push('Give the stat a label.');
        if (typeof s.min === 'number' && typeof s.max === 'number' && s.min > s.max) m.push('Max must be at least min.');
      }
      out.push(m);
    });
    return out;
  }
  RS.stats = function (host, ctx) {
    U.clear(host);
    var r = ctx.rs(), arr = Array.isArray(r.stats) ? r.stats : [], refs = [];
    host.appendChild(el('p', 'muted rl-lead', 'Stats are the numbers every character and enemy carries. Formulas read them as a.<key> and t.<key>. A key is permanent once a record or formula uses it. Labels can change at any time.'));
    var list = el('div', 'rl-rows');
    host.appendChild(list);
    function repaint() { RS.stats(host, ctx); }
    function paint() { paintMsgs(refs, statProblems(arr)); }
    if (!arr.length) list.appendChild(el('div', 'empty-line', ctx.readOnly ? 'No stats are declared.' : 'No stats yet. Load the defaults or add your own.'));
    arr.forEach(function (s, i) {
      if (!U.isObj(s)) return;
      var row = el('div', 'rl-row'), msg = el('div', 'rl-msgs');
      var used = ctx.readOnly ? [] : WSX.usage('stat', s.key);
      var keyNode;
      if (ctx.readOnly || used.length) {
        keyNode = el('div', 'rl-keycode', esc(s.key));
        if (used.length) keyNode.title = 'Locked. ' + usageText(used);
      } else keyNode = mkInput({ value: s.key, label: 'Stat key ' + (i + 1), maxLength: 12, mono: true, onInput: function (v) { s.key = v.trim(); ctx.changed(); paint(); } });
      row.appendChild(fieldBox('Key', keyNode, 'sm'));
      row.appendChild(fieldBox('Label', mkInput({ value: s.label, label: 'Label for ' + s.key, maxLength: 30, readOnly: ctx.readOnly, onInput: function (v) { s.label = v; ctx.changed(); paint(); } }), 'lg'));
      ['min', 'max'].forEach(function (k) {
        row.appendChild(fieldBox(cap1(k), mkInput({
          type: 'number', step: 1, min: 0, max: 99999, value: s[k], label: cap1(k) + ' for ' + s.key, readOnly: ctx.readOnly,
          onInput: function (v) { if (v === '') delete s[k]; else s[k] = Number(v); ctx.changed(); paint(); }
        }), 'sm'));
      });
      row.appendChild(rowControls(ctx, arr, i, 'stat ' + s.key, repaint, function () {
        Kit.ui.confirm({
          title: 'Delete the stat "' + s.key + '"?', message: 'It is removed from the ruleset.',
          detail: used.length ? usageText(used) + ' Those places show errors until you fix them.' : '', okLabel: 'Delete', danger: true
        }).then(function (ok) { if (!ok) return; arr.splice(i, 1); ctx.changed(); repaint(); });
      }));
      row.appendChild(msg);
      list.appendChild(row);
      refs.push({ row: row, msg: msg });
    });
    paint();
    if (!ctx.readOnly) {
      var bar = el('div', 'btn-row rl-addbar');
      bar.appendChild(button('Add stat', 'plus', 'btn-primary', function () {
        keyPrompt('Add a stat', 'Stat key', statKeys(cur()), 12).then(function (k) {
          if (k == null) return;
          k = k.trim();
          var a2 = Array.isArray(r.stats) ? r.stats : (r.stats = []);
          a2.push({ key: k, label: cap1(k), min: 0, max: 99 });
          ctx.changed(); repaint(); focusRow(host, a2.length - 1);
        });
      }));
      if (!arr.length && window.WS.charter && window.WS.charter.defaultStats) {
        bar.appendChild(button('Load default stats', null, '', function () { r.stats = window.WS.charter.defaultStats(); ctx.changed(); repaint(); }));
      }
      host.appendChild(bar);
    }
  };

  // Elements
  function elementProblems(arr) {
    var out = [], seen = {};
    arr.forEach(function (s) {
      var m = [];
      if (U.isObj(s)) {
        var k = String(s.key || '');
        if (!k) m.push('Give the element a key.');
        else if (!KEY_RE.test(k)) m.push('Key must be lowercase letters and digits, starting with a letter.');
        else if (seen[k]) m.push('Another element already uses the key "' + k + '".');
        if (k) seen[k] = 1;
        if (!String(s.label || '').trim()) m.push('Give the element a label.');
        if (s.color && !/^#[0-9a-fA-F]{6}$/.test(s.color)) m.push('Color must be a hex value like #a1b2c3.');
      }
      out.push(m);
    });
    return out;
  }
  function elemList(r) { return (Array.isArray(r.elements) ? r.elements : []).filter(U.isObj); }
  RS.elements = function (host, ctx) {
    U.clear(host);
    var r = ctx.rs(), arr = Array.isArray(r.elements) ? r.elements : [], refs = [];
    host.appendChild(el('p', 'muted rl-lead', 'Elements color abilities, weather, and enemy families. Relations and the taxonomy build on them. A key is permanent once anything uses it.'));
    var list = el('div', 'rl-rows');
    host.appendChild(list);
    function repaint() { RS.elements(host, ctx); }
    function paint() { paintMsgs(refs, elementProblems(arr)); }
    if (!arr.length) list.appendChild(el('div', 'empty-line', ctx.readOnly ? 'No elements are declared.' : 'No elements yet. Add the first one.'));
    arr.forEach(function (s, i) {
      if (!U.isObj(s)) return;
      var row = el('div', 'rl-row'), msg = el('div', 'rl-msgs');
      var used = ctx.readOnly ? [] : WSX.usage('element', s.key);
      var keyNode;
      if (ctx.readOnly || used.length) {
        keyNode = el('div', 'rl-keycode', esc(s.key));
        if (used.length) keyNode.title = 'Locked. ' + usageText(used);
      } else keyNode = mkInput({ value: s.key, label: 'Element key ' + (i + 1), maxLength: 16, mono: true, onInput: function (v) { s.key = v.trim(); ctx.changed(); paint(); } });
      row.appendChild(fieldBox('Key', keyNode, 'sm'));
      row.appendChild(fieldBox('Label', mkInput({ value: s.label, label: 'Label for ' + s.key, maxLength: 30, readOnly: ctx.readOnly, onInput: function (v) { s.label = v; ctx.changed(); paint(); } }), 'lg'));
      row.appendChild(fieldBox('Color', colorControl(s.color, ctx.readOnly, 'Color for ' + s.key, function (v) { if (v) s.color = v; else delete s.color; ctx.changed(); paint(); }), 'lg'));
      row.appendChild(rowControls(ctx, arr, i, 'element ' + s.key, repaint, function () {
        var rels = (Array.isArray(r.elementRelations) ? r.elementRelations : []).filter(function (x) { return U.isObj(x) && (x.a === s.key || x.b === s.key); }).length;
        var inTax = U.isObj(r.taxonomy) && Array.isArray(r.taxonomy.values) && r.taxonomy.values.indexOf(s.key) >= 0;
        var others = used.filter(function (u) { return u.recordId !== 'charter:ruleset'; });
        var detail = 'Relations that use it' + (inTax ? ' and its taxonomy value' : '') + ' are removed with it.';
        if (others.length) detail += ' ' + usageText(others) + ' Those records show errors until you fix them.';
        Kit.ui.confirm({ title: 'Delete the element "' + s.key + '"?', message: rels ? 'It is removed from the ruleset, along with ' + rels + ' relation' + (rels === 1 ? '' : 's') + '.' : 'It is removed from the ruleset.', detail: detail, okLabel: 'Delete', danger: true }).then(function (ok) {
          if (!ok) return;
          arr.splice(i, 1);
          if (Array.isArray(r.elementRelations)) r.elementRelations = r.elementRelations.filter(function (x) { return !(U.isObj(x) && (x.a === s.key || x.b === s.key)); });
          if (U.isObj(r.taxonomy)) {
            if (Array.isArray(r.taxonomy.values)) r.taxonomy.values = r.taxonomy.values.filter(function (v) { return v !== s.key; });
            if (Array.isArray(r.taxonomy.inverts)) r.taxonomy.inverts = r.taxonomy.inverts.filter(function (v) { return v !== s.key; });
          }
          ctx.changed(); repaint();
        });
      }));
      row.appendChild(msg);
      list.appendChild(row);
      refs.push({ row: row, msg: msg });
    });
    paint();
    if (!ctx.readOnly) {
      var bar = el('div', 'btn-row rl-addbar');
      bar.appendChild(button('Add element', 'plus', 'btn-primary', function () {
        keyPrompt('Add an element', 'Element key', arr.map(function (x) { return U.isObj(x) ? x.key : ''; }), 16).then(function (k) {
          if (k == null) return;
          k = k.trim();
          var a2 = Array.isArray(r.elements) ? r.elements : (r.elements = []);
          a2.push({ key: k, label: cap1(k), color: ELEM_COLORS[a2.length % ELEM_COLORS.length] });
          ctx.changed(); repaint(); focusRow(host, a2.length - 1);
        });
      }));
      host.appendChild(bar);
    }
  };

  // Relations (opposed pairs)
  function relationProblems(arr, keys) {
    var out = [], seen = {};
    arr.forEach(function (x) {
      var m = [];
      if (U.isObj(x)) {
        if (!x.a || !x.b) m.push({ text: 'Choose both elements.', level: 'error' });
        else {
          if (x.a === x.b) m.push({ text: 'An element cannot oppose itself.', level: 'error' });
          if (keys.indexOf(x.a) < 0) m.push({ text: 'The element "' + x.a + '" is not declared.', level: 'error' });
          if (keys.indexOf(x.b) < 0) m.push({ text: 'The element "' + x.b + '" is not declared.', level: 'error' });
          var pk = [x.a, x.b].sort().join('|');
          if (seen[pk]) m.push({ text: 'This pair is declared twice.', level: 'warning' });
          seen[pk] = 1;
        }
      }
      out.push(m);
    });
    return out;
  }
  RS.relations = function (host, ctx) {
    U.clear(host);
    var r = ctx.rs(), arr = Array.isArray(r.elementRelations) ? r.elementRelations : [], refs = [];
    var elems = elemList(r), keys = elems.map(function (e) { return e.key; });
    var opts = elems.map(function (e) { return { value: e.key, label: (e.label || e.key) + ' (' + e.key + ')' }; });
    var nameOf = {}; elems.forEach(function (e) { nameOf[e.key] = e.label || e.key; });
    host.appendChild(el('p', 'muted rl-lead', 'An opposed pair means each element is the other side\'s weakness. Enemy families resist their own type and are weak to its opposite. Elements with no pair have no weakness.'));
    var list = el('div', 'rl-rows');
    host.appendChild(list);
    function repaint() { RS.relations(host, ctx); }
    function paint() { paintMsgs(refs, relationProblems(arr, keys)); }
    if (!arr.length) list.appendChild(el('div', 'empty-line', ctx.readOnly ? 'No relations are declared, so no element has a weakness.' : 'No pairs yet. Add one to give elements weaknesses.'));
    arr.forEach(function (x, i) {
      if (!U.isObj(x)) return;
      var row = el('div', 'rl-row'), msg = el('div', 'rl-msgs'), note = el('div', 'rl-pairnote muted');
      function paintNote() { note.textContent = x.a && x.b && x.a !== x.b ? (nameOf[x.a] || x.a) + ' is weak to ' + (nameOf[x.b] || x.b) + ', and ' + (nameOf[x.b] || x.b) + ' is weak to ' + (nameOf[x.a] || x.a) + '.' : ''; }
      ['a', 'b'].forEach(function (side) {
        row.appendChild(fieldBox('Element ' + side.toUpperCase(), mkSelect(opts, x[side], { label: 'Element ' + side.toUpperCase() + ' of pair ' + (i + 1), readOnly: ctx.readOnly, onChange: function (v) { if (v) x[side] = v; else delete x[side]; x.kind = 'opposed'; ctx.changed(); paint(); paintNote(); } }), 'lg'));
      });
      row.appendChild(rowControls(ctx, arr, i, 'pair ' + (i + 1), repaint, function () {
        Kit.ui.confirm({ title: 'Delete this pair?', message: 'The elements stay. They just stop opposing each other.', okLabel: 'Delete', danger: true }).then(function (ok) { if (!ok) return; arr.splice(i, 1); ctx.changed(); repaint(); });
      }));
      paintNote();
      row.appendChild(note);
      row.appendChild(msg);
      list.appendChild(row);
      refs.push({ row: row, msg: msg });
    });
    paint();
    if (!ctx.readOnly) {
      var bar = el('div', 'btn-row rl-addbar');
      var add = button('Add pair', 'plus', 'btn-primary', function () {
        if (keys.length < 2) { Kit.ui.toast('Declare at least two elements first.', 'warn'); return; }
        var have = {}; arr.forEach(function (x) { if (U.isObj(x) && x.a && x.b) have[[x.a, x.b].sort().join('|')] = 1; });
        var pick = null;
        for (var p = 0; p < keys.length && !pick; p++) { for (var q = p + 1; q < keys.length; q++) { if (!have[[keys[p], keys[q]].sort().join('|')]) { pick = [keys[p], keys[q]]; break; } } }
        pick = pick || [keys[0], keys[1]];
        var a2 = Array.isArray(r.elementRelations) ? r.elementRelations : (r.elementRelations = []);
        a2.push({ a: pick[0], b: pick[1], kind: 'opposed' });
        ctx.changed(); repaint(); focusRow(host, a2.length - 1);
      });
      if (keys.length < 2) add.title = 'Declare at least two elements first.';
      bar.appendChild(add);
      host.appendChild(bar);
    }
  };

  // Taxonomy
  function ensureTax(r) {
    if (!U.isObj(r.taxonomy)) r.taxonomy = { label: '', values: [], inverts: [] };
    if (!Array.isArray(r.taxonomy.values)) r.taxonomy.values = [];
    if (!Array.isArray(r.taxonomy.inverts)) r.taxonomy.inverts = [];
    return r.taxonomy;
  }
  RS.taxonomy = function (host, ctx) {
    U.clear(host);
    var r = ctx.rs(), tax = U.isObj(r.taxonomy) ? r.taxonomy : { label: '', values: [], inverts: [] };
    var vals = Array.isArray(tax.values) ? tax.values : [], refs = [];
    function repaint() { RS.taxonomy(host, ctx); }
    host.appendChild(el('p', 'muted rl-lead', 'The taxonomy classifies enemy families, for example by Type or Kind. Each value can be an element key or a custom word. An inverted value is healed by damage and hurt by healing, which is how undead work.'));
    var lab = mkInput({ value: tax.label, label: 'Taxonomy label', maxLength: 30, placeholder: 'For example Type or Kind', readOnly: ctx.readOnly, onInput: function (v) { ensureTax(r).label = v; ctx.changed(); paintLabel(); } });
    var labMsg = el('div', 'field-msg');
    function paintLabel() {
      U.clear(labMsg);
      if (vals.length && !String(ensureTaxRead().label || '').trim()) labMsg.appendChild(el('div', 'msg msg-error', 'Give the taxonomy a label such as Type or Kind.'));
    }
    function ensureTaxRead() { return U.isObj(r.taxonomy) ? r.taxonomy : tax; }
    var lf = fieldBox('Label', lab, 'lg'); lf.appendChild(labMsg);
    var top = el('div', 'rl-row'); top.appendChild(lf); host.appendChild(top);
    paintLabel();
    var list = el('div', 'rl-rows');
    host.appendChild(list);
    function problems() {
      var seen = {};
      return vals.map(function (v) {
        var m = [];
        if (!v) m.push('Enter a value.');
        else if (!/^[a-z][a-z0-9_-]*$/.test(v)) m.push('Use lowercase letters, digits, hyphens, or underscores, starting with a letter.');
        else if (seen[v]) m.push('This value is listed twice.');
        if (v) seen[v] = 1;
        return m;
      });
    }
    function paint() { paintMsgs(refs, problems()); }
    if (!vals.length) list.appendChild(el('div', 'empty-line', ctx.readOnly ? 'No taxonomy values are declared.' : 'No values yet. Add them from your elements or type your own.'));
    vals.forEach(function (v, i) {
      var row = el('div', 'rl-row'), msg = el('div', 'rl-msgs');
      var used = ctx.readOnly ? [] : WSX.usage('taxon', v);
      var keyNode;
      if (ctx.readOnly || used.length) {
        keyNode = el('div', 'rl-keycode', esc(v));
        if (used.length) keyNode.title = 'Locked. ' + usageText(used);
      } else keyNode = mkInput({
        value: v, label: 'Taxonomy value ' + (i + 1), maxLength: 24, mono: true,
        onInput: function (nv) {
          nv = nv.trim();
          var t = ensureTax(r), was = t.values[i], j = t.inverts.indexOf(was);
          t.values[i] = nv;
          if (j >= 0) t.inverts[j] = nv;
          vals = t.values; ctx.changed(); paint();
        }
      });
      row.appendChild(fieldBox('Value', keyNode, 'lg'));
      var inv = el('label', 'switch');
      var cb = el('input'); cb.type = 'checkbox'; cb.checked = Array.isArray(tax.inverts) && tax.inverts.indexOf(v) >= 0;
      cb.setAttribute('aria-label', 'Inverted: ' + v);
      if (ctx.readOnly) cb.disabled = true;
      var track = el('span', 'track'), txt = el('span', 'switch-text', cb.checked ? 'Inverted' : 'Normal');
      cb.addEventListener('change', function () {
        var t = ensureTax(r), j = t.inverts.indexOf(v);
        if (cb.checked && j < 0) t.inverts.push(v);
        if (!cb.checked && j >= 0) t.inverts.splice(j, 1);
        txt.textContent = cb.checked ? 'Inverted' : 'Normal';
        ctx.changed();
      });
      inv.appendChild(cb); inv.appendChild(track); inv.appendChild(txt);
      row.appendChild(fieldBox('Healing', inv, 'md'));
      row.appendChild(rowControls(ctx, vals, i, 'value ' + v, repaint, function () {
        Kit.ui.confirm({ title: 'Delete the value "' + v + '"?', message: 'It is removed from the taxonomy.', detail: used.length ? usageText(used) + ' Those records show errors until you fix them.' : '', okLabel: 'Delete', danger: true }).then(function (ok) {
          if (!ok) return;
          var t = ensureTax(r);
          t.values.splice(i, 1);
          t.inverts = t.inverts.filter(function (x) { return x !== v; });
          ctx.changed(); repaint();
        });
      }));
      row.appendChild(msg);
      list.appendChild(row);
      refs.push({ row: row, msg: msg });
    });
    paint();
    if (!ctx.readOnly) {
      var missing = elemList(r).map(function (e) { return e.key; }).filter(function (k) { return vals.indexOf(k) < 0; });
      if (missing.length) {
        var chips = el('div', 'rl-chipbar');
        chips.appendChild(el('span', 'muted', 'Add from elements:'));
        missing.forEach(function (k) {
          chips.appendChild(button(k, 'plus', 'btn-ghost rl-chipbtn', function () { ensureTax(r).values.push(k); ctx.changed(); repaint(); }));
        });
        host.appendChild(chips);
      }
      var bar = el('div', 'btn-row rl-addbar');
      bar.appendChild(button('Add custom value', 'plus', 'btn-primary', function () {
        Kit.ui.prompt({
          title: 'Add a taxonomy value', label: 'Value', okLabel: 'Add', placeholder: 'For example beast or machine',
          validate: function (nv) {
            nv = nv.trim();
            if (!/^[a-z][a-z0-9_-]*$/.test(nv)) return 'Use lowercase letters, digits, hyphens, or underscores, starting with a letter.';
            if (vals.indexOf(nv) >= 0) return 'That value already exists.';
            return null;
          }
        }).then(function (nv) {
          if (nv == null) return;
          ensureTax(r).values.push(nv.trim());
          ctx.changed(); repaint(); focusRow(host, ensureTax(r).values.length);
        });
      }));
      host.appendChild(bar);
    }
  };

  // Default affinity, computed from the relation table.
  var absorbPreview = {};
  function affinityChip(a) {
    return '<span class="chip rl-aff rl-aff-' + a + '">' + esc(a) + '</span>';
  }
  RS.affinity = function (host, ctx) {
    U.clear(host);
    var b = cur(), r = rsOf(b), elems = elemList(r), tax = U.isObj(r.taxonomy) ? r.taxonomy : {};
    var vals = Array.isArray(tax.values) ? tax.values : [];
    host.appendChild(el('p', 'muted rl-lead', 'Default affinity is computed, never typed. A family resists its own type, is weak to the opposite of that type, and takes normal damage from everything else. Turn on absorb and its own type heals it instead. Enemies can override any cell on their own record.'));
    if (!elems.length || !vals.length) {
      host.appendChild(el('div', 'empty-line', !elems.length ? 'Declare elements first.' : 'Add taxonomy values to see the default affinity of each family type.'));
    } else {
      var wrap = el('div', 'tbl-wrap'), t = el('table', 'tbl rl-matrix');
      var head = '<tr><th scope="col">' + esc(tax.label || 'Type') + '</th>' + elems.map(function (e) { return '<th scope="col">' + esc(e.label || e.key) + '</th>'; }).join('') + '<th scope="col">Absorb</th></tr>';
      t.innerHTML = '<thead>' + head + '</thead>';
      var tb = el('tbody');
      vals.forEach(function (v) {
        var tr = el('tr');
        tr.appendChild(el('th', null, esc(v)));
        tr.firstChild.scope = 'row';
        var aff = window.WS.codex.defaultAffinity(b, v, !!absorbPreview[v]);
        elems.forEach(function (e) { tr.appendChild(el('td', null, affinityChip(aff[e.key] || 'normal'))); });
        var td = el('td'), lab = el('label', 'switch');
        var cb = el('input'); cb.type = 'checkbox'; cb.checked = !!absorbPreview[v]; cb.setAttribute('aria-label', 'Preview absorb for ' + v);
        cb.addEventListener('change', function () { absorbPreview[v] = cb.checked; RS.affinity(host, ctx); });
        lab.appendChild(cb); lab.appendChild(el('span', 'track')); td.appendChild(lab); tr.appendChild(td);
        tb.appendChild(tr);
      });
      t.appendChild(tb); wrap.appendChild(t); host.appendChild(wrap);
      host.appendChild(el('p', 'muted rl-note', 'The Absorb column previews the option. To mark a real family as absorbing, use its switch below or its own record.'));
    }
    var fams = Kit.records.list('fam_');
    host.appendChild(el('h3', 'section-h', 'Families'));
    if (!fams.length) {
      host.appendChild(el('div', 'empty-line', 'No enemy families exist yet. They are authored under Content.'));
      var goF = el('button', 'btn btn-primary', 'Create an enemy family'); goF.type = 'button';
      goF.addEventListener('click', function () { WSX.open('type:Family'); });
      host.appendChild(goF);
    }
    else {
      var list = el('div', 'rl-rows');
      fams.slice().sort(function (x, y) { return String(x.name).localeCompare(String(y.name)); }).forEach(function (f) {
        var row = el('div', 'rl-row rl-famrow');
        row.appendChild(el('div', 'rl-f lg', '<strong>' + esc(f.name || f.id) + '</strong><span class="muted">' + esc((tax.label || 'Type') + ': ' + (f.type || 'not set')) + '</span>'));
        var sw = el('label', 'switch'), cb = el('input'); cb.type = 'checkbox'; cb.checked = !!f.absorbsOwnType; cb.setAttribute('aria-label', 'Absorbs its own type: ' + (f.name || f.id));
        var tx = el('span', 'switch-text', cb.checked ? 'Absorbs own type' : 'Resists own type');
        cb.addEventListener('change', function () {
          f.absorbsOwnType = cb.checked; tx.textContent = cb.checked ? 'Absorbs own type' : 'Resists own type';
          Kit.bundle.touch('rules-affinity'); summary();
        });
        sw.appendChild(cb); sw.appendChild(el('span', 'track')); sw.appendChild(tx);
        row.appendChild(sw);
        var sum = el('div', 'rl-affsum');
        function summary() {
          var a = window.WS.codex.defaultAffinity(cur(), f.type, !!f.absorbsOwnType), parts = [];
          Object.keys(a).forEach(function (k) { if (a[k] !== 'normal') parts.push(affinityChip(a[k]).replace('</span>', ' ' + esc(k) + '</span>')); });
          sum.innerHTML = parts.length ? parts.join('') : '<span class="muted">Normal to everything</span>';
        }
        summary();
        row.appendChild(sum);
        list.appendChild(row);
      });
      host.appendChild(list);
    }
  };
  RS.ORDER = ['stats', 'elements', 'relations', 'taxonomy', 'affinity'];
  RS.LABELS = { stats: 'Stats', elements: 'Elements', relations: 'Relations', taxonomy: 'Taxonomy', affinity: 'Affinity' };

  function lockedBanner(host) {
    var b = cur(), c = b.charter;
    if (!c.locked) return;
    var bn = el('div', 'rl-banner');
    bn.appendChild(el('span', null, 'These systems live in the Charter, which is locked at version ' + c.version + '. They are read only here. Amend the Charter to change them.'));
    var ab = button('Amend Charter', 'edit', '', function () { window.WS.charter.amend(); });
    bn.appendChild(ab);
    host.appendChild(bn);
  }
  // Drawer used from the Charter while it is unlocked. The same editors, fully editable.
  WSX.openSystems = function (tab) {
    var b = cur(), state = { tab: RS.ORDER.indexOf(tab) >= 0 ? tab : 'stats' };
    var panel, tabs;
    function paint() {
      Array.prototype.forEach.call(tabs.children, function (t) { t.setAttribute('aria-selected', t.dataset.tab === state.tab ? 'true' : 'false'); });
      U.clear(panel);
      var ctx = sysCtx(function () { Kit.refreshValidation(); });
      if (ctx.readOnly) lockedBanner(panel);
      var host = el('div');
      panel.appendChild(host);
      RS[state.tab](host, ctx);
    }
    return Kit.ui.drawer({
      title: 'Ruleset systems',
      onClose: function () { if (Kit.active() === 'charter') Kit.rerender(); },
      body: function (body) {
        tabs = el('div', 'rl-tabs'); tabs.setAttribute('role', 'tablist');
        RS.ORDER.forEach(function (k) {
          var t = el('button', 'rl-tab', esc(RS.LABELS[k])); t.type = 'button'; t.dataset.tab = k; t.setAttribute('role', 'tab');
          t.addEventListener('click', function () { state.tab = k; paint(); });
          tabs.appendChild(t);
        });
        panel = el('div', 'rl-tabpanel');
        body.appendChild(tabs); body.appendChild(panel);
        paint();
      }
    });
  };

  // ---------------------------------------------------------------- formula preview (live, Chart.js)
  var sampleState = { level: 10, power: 20, cap: 99, a: {}, t: {} };
  function whenChart(cb, tries) {
    if (window.Chart) { cb(window.Chart); return; }
    if ((tries || 0) > 40) { cb(null); return; }
    setTimeout(function () { whenChart(cb, (tries || 0) + 1); }, 150);
  }
  function defaultSample(b, which) {
    var st = rsOf(b).stats, out = {};
    (Array.isArray(st) ? st : []).forEach(function (s) {
      if (!U.isObj(s) || !s.key) return;
      var lo = typeof s.min === 'number' ? s.min : 0, hi = typeof s.max === 'number' ? s.max : 99;
      var v = which === 'a' ? lo + (hi - lo) * 0.3 : lo + (hi - lo) * 0.2;
      out[s.key] = Math.max(lo, Math.round(v));
    });
    return out;
  }
  function sampleScope(b) {
    var keys = statKeys(b), a = { level: sampleState.level }, t = { level: sampleState.level };
    keys.forEach(function (k) {
      if (sampleState.a[k] == null) sampleState.a[k] = defaultSample(b, 'a')[k];
      if (sampleState.t[k] == null) sampleState.t[k] = defaultSample(b, 't')[k];
      a[k] = sampleState.a[k]; t[k] = sampleState.t[k];
    });
    return { a: a, t: t, power: sampleState.power };
  }
  function fmtNum(n) {
    if (typeof n !== 'number' || !isFinite(n)) return String(n);
    return Math.abs(n) >= 1000 ? String(Math.round(n)) : String(Math.round(n * 1000) / 1000);
  }
  // getSource() returns {expr, params, kind} or null. Returns {update(), destroy()}.
  WSX.preview = function (host, getSource, o) {
    o = o || {};
    U.clear(host);
    var chart = null, dead = false;
    var box = el('div', 'rl-prev');
    var head = el('div', 'rl-prev-head', '<h3 class="section-h">Live preview</h3>');
    box.appendChild(head);
    var inputs = el('div', 'rl-prev-inputs');
    var readout = el('div', 'rl-prev-read');
    var errBox = el('div', 'rl-prev-err');
    var chartWrap = el('div', 'rl-chart');
    var canvas = el('canvas'); canvas.setAttribute('role', 'img');
    chartWrap.appendChild(canvas);
    var table = el('div', 'tbl-wrap rl-prev-table');
    box.appendChild(inputs); box.appendChild(errBox); box.appendChild(readout); box.appendChild(chartWrap); box.appendChild(table);
    host.appendChild(box);

    function numIn(label, get, set, min, max) {
      var w = el('label', 'rl-si'), lab = el('span', null, esc(label));
      var i = el('input', 'inp'); i.type = 'number'; i.inputMode = 'decimal'; i.step = 'any'; i.value = get();
      i.setAttribute('aria-label', 'Sample ' + label);
      i.addEventListener('input', function () {
        var v = Number(i.value);
        if (i.value === '' || !isFinite(v)) return;
        if (min != null && v < min) v = min;
        if (max != null && v > max) v = max;
        set(v); update();
      });
      w.appendChild(lab); w.appendChild(i);
      return w;
    }
    function buildInputs() {
      U.clear(inputs);
      var b = cur(), keys = statKeys(b);
      sampleScope(b);
      var g1 = el('div', 'rl-si-group'), g2 = el('div', 'rl-si-group'), g3 = el('div', 'rl-si-group');
      g1.appendChild(el('div', 'rl-si-title', 'Sample'));
      g1.appendChild(numIn('level', function () { return sampleState.level; }, function (v) { sampleState.level = Math.round(v); }, 1, 999));
      g1.appendChild(numIn('power', function () { return sampleState.power; }, function (v) { sampleState.power = v; }, 0, 99999));
      g1.appendChild(numIn('level cap', function () { return sampleState.cap; }, function (v) { sampleState.cap = Math.max(2, Math.min(200, Math.round(v))); }, 2, 200));
      g2.appendChild(el('div', 'rl-si-title', 'Attacker a.'));
      g3.appendChild(el('div', 'rl-si-title', 'Target t.'));
      keys.forEach(function (k) {
        g2.appendChild(numIn(k, function () { return sampleState.a[k]; }, function (v) { sampleState.a[k] = v; }, 0, 999999));
        g3.appendChild(numIn(k, function () { return sampleState.t[k]; }, function (v) { sampleState.t[k] = v; }, 0, 999999));
      });
      inputs.appendChild(g1); inputs.appendChild(g2); inputs.appendChild(g3);
    }
    function series(src) {
      var b = cur(), base = sampleScope(b), ast = Kit.expr.parse(src.expr, { stats: statKeys(b), params: Object.keys(src.params || {}) });
      var pts = [], cap = sampleState.cap;
      for (var l = 1; l <= cap; l++) {
        var sc = { a: Object.assign({}, base.a, { level: l }), t: Object.assign({}, base.t, { level: l }), power: base.power, p: src.params || {} };
        var y = null;
        try { y = Kit.expr.evaluate(ast, sc); } catch (e) { y = null; }
        pts.push(y);
      }
      var one = Kit.expr.evaluate(ast, { a: base.a, t: base.t, power: base.power, p: src.params || {} });
      return { pts: pts, value: one };
    }
    function paintTable(pts) {
      U.clear(table);
      var steps = [1, 5, 10, 20, 30, 50, 75, 99].filter(function (l) { return l <= sampleState.cap; });
      if (steps.indexOf(sampleState.cap) < 0) steps.push(sampleState.cap);
      var t = el('table', 'tbl');
      t.innerHTML = '<caption class="sr-only">Formula results by level</caption><thead><tr><th scope="col">Level</th><th scope="col">Result</th></tr></thead>';
      var tb = el('tbody');
      steps.forEach(function (l) { tb.appendChild(el('tr', null, '<td>' + l + '</td><td>' + esc(pts[l - 1] == null ? 'error' : fmtNum(pts[l - 1])) + '</td>')); });
      t.appendChild(tb); table.appendChild(t);
    }
    function update() {
      if (dead || !alive(box)) return;
      var src = getSource();
      U.clear(errBox); readout.textContent = '';
      if (!src || !src.expr) {
        errBox.appendChild(el('div', 'msg msg-warning', 'Choose a template or write an expression to see a preview.'));
        chartWrap.hidden = true; table.hidden = true; return;
      }
      var res;
      try { res = series(src); }
      catch (e) {
        errBox.appendChild(el('div', 'msg msg-error', esc(e.message)));
        chartWrap.hidden = true; table.hidden = true; return;
      }
      readout.innerHTML = 'At level ' + sampleState.level + ' the result is <strong>' + esc(fmtNum(res.value)) + '</strong>.';
      chartWrap.hidden = false; table.hidden = false;
      var labels = []; for (var l = 1; l <= sampleState.cap; l++) labels.push(String(l));
      var desc = 'Formula result for levels 1 to ' + sampleState.cap + '. Level 1 gives ' + (res.pts[0] == null ? 'an error' : fmtNum(res.pts[0])) + ' and level ' + sampleState.cap + ' gives ' + (res.pts[res.pts.length - 1] == null ? 'an error' : fmtNum(res.pts[res.pts.length - 1])) + '.';
      canvas.setAttribute('aria-label', desc);
      paintTable(res.pts);
      whenChart(function (C) {
        if (dead || !alive(box)) return;
        if (!C) { chartWrap.hidden = true; return; }
        table.classList.add('rl-prev-table-fallback');
        var cs = getComputedStyle(document.documentElement);
        var accent = (cs.getPropertyValue('--accent') || '#d4a24c').trim() || '#d4a24c';
        var grid = (cs.getPropertyValue('--line') || 'rgba(128,128,128,.25)').trim() || 'rgba(128,128,128,.25)';
        var txt = (cs.getPropertyValue('--muted') || '#999').trim() || '#999';
        if (!chart) {
          chart = new C(canvas.getContext('2d'), {
            type: 'line',
            data: { labels: labels, datasets: [{ label: 'Result', data: res.pts, borderColor: accent, backgroundColor: accent, borderWidth: 2, pointRadius: 0, pointHoverRadius: 4, tension: 0.15, spanGaps: false }] },
            options: {
              responsive: true, maintainAspectRatio: false, animation: false,
              interaction: { mode: 'index', intersect: false },
              plugins: { legend: { display: false } },
              scales: {
                x: { title: { display: true, text: 'Level', color: txt }, ticks: { color: txt, maxTicksLimit: 10 }, grid: { color: grid } },
                y: { title: { display: true, text: 'Result', color: txt }, ticks: { color: txt }, grid: { color: grid }, beginAtZero: true }
              }
            }
          });
        } else {
          chart.data.labels = labels; chart.data.datasets[0].data = res.pts;
          chart.data.datasets[0].borderColor = accent; chart.data.datasets[0].backgroundColor = accent;
          chart.update('none');
        }
        canvas.dataset.points = String(res.pts.length);
        canvas.dataset.last = res.pts[res.pts.length - 1] == null ? '' : String(res.pts[res.pts.length - 1]);
      });
    }
    buildInputs();
    update();
    return { update: update, rebuild: function () { buildInputs(); update(); }, destroy: function () { dead = true; if (chart) { chart.destroy(); chart = null; } }, chart: function () { return chart; } };
  };

  // ---------------------------------------------------------------- records workspace
  var state = { view: null, editing: null, search: {}, focusPath: null };
  var hostRef = null, kform = null, prevCtl = null;

  function typeMap() { return Kit.codex.types(cur()) || {}; }
  function typeByName(n) { return typeMap()[n] || null; }
  function progType() {
    var tm = typeMap(), names = Object.keys(tm);
    for (var i = 0; i < names.length; i++) { if (tm[names[i]].group === 'module') return names[i]; }
    return null;
  }
  var SYSTEM_TYPES = ['Status', 'Formula', 'Weather'];
  function railModel() {
    var tm = typeMap(), sys = [], content = [];
    sys.push({ view: 'sys:stats', label: 'Stats', icon: 'gear' });
    sys.push({ view: 'sys:elements', label: 'Elements', icon: 'spark' });
    sys.push({ view: 'sys:relations', label: 'Relations', icon: 'jump' });
    sys.push({ view: 'sys:taxonomy', label: 'Taxonomy', icon: 'book' });
    sys.push({ view: 'sys:affinity', label: 'Affinity', icon: 'sword' });
    sys.push({ view: 'sys:formulas', label: 'Formulas', icon: 'chart' });
    SYSTEM_TYPES.forEach(function (n) {
      if (n === 'Formula' || !tm[n]) return;
      sys.push({ view: 'type:' + n, label: n === 'Weather' ? 'Weather states' : 'Statuses', icon: n === 'Weather' ? 'moon' : 'warn', type: n });
    });
    var pn = progType();
    if (pn) sys.push({ view: 'type:' + pn, label: 'Progression: ' + (tm[pn].label || pn), icon: 'key', type: pn });
    Object.keys(tm).forEach(function (n) {
      var t = tm[n];
      if (!t || !t.prefix || SYSTEM_TYPES.indexOf(n) >= 0 || n === pn) return;
      var info = Kit.codex.prefixInfo(t.prefix);
      if (!info || info.ns !== 'rules') return;
      content.push({ view: 'type:' + n, label: t.label || n, icon: 'scroll', type: n, order: t.group === 'living' ? 2 : 1 });
    });
    content.push({ view: 'econ', label: 'Economy', icon: 'chart', order: 1.5 });
    content.sort(function (a, b) { return a.order - b.order || a.label.localeCompare(b.label); });
    return { sys: sys, content: content };
  }
  function viewExists(v) {
    if (!v) return false;
    if (v === 'econ') return true;
    if (v.indexOf('type:') === 0) return !!typeByName(v.slice(5));
    var m = railModel();
    return m.sys.concat(m.content).some(function (x) { return x.view === v; });
  }
  function counts(type) {
    var t = typeByName(type);
    return t && t.prefix ? Kit.records.list(t.prefix).length : 0;
  }
  function typeOfRecordId(id) {
    if (!Kit.ids.isValid(id)) return null;
    return Kit.codex.typeFor(Kit.ids.prefixOf(id), cur());
  }
  function typeDefaults(typeName, rec) {
    var cfg = TYPE_CFG[typeName];
    if (cfg && cfg.init) cfg.init(rec);
    return rec;
  }
  function newRecord(typeName, name) {
    var t = typeByName(typeName), b = cur();
    var rec = { id: Kit.ids.mint(t.prefix, name), name: name, charterVersion: b.charter.version || 0 };
    typeDefaults(typeName, rec);
    Kit.records.put(rec);
    Kit.bundle.touch('rules-new');
    return rec;
  }
  function askName(title, initial) {
    return Kit.ui.prompt({ title: title, label: 'Name', value: initial || '', okLabel: 'Create', validate: function (v) { return v.trim() ? (v.trim().length > 60 ? 'Use at most 60 characters.' : null) : 'Give it a name.'; } });
  }
  function dupRecord(rec, typeName) {
    var copy = U.clone(rec), t = typeByName(typeName);
    var name = String(rec.name || 'Copy').replace(/ copy( \d+)?$/, '') + ' copy';
    copy.id = Kit.ids.mint(t.prefix, name);
    copy.name = name;
    copy.charterVersion = cur().charter.version || 0;
    Kit.records.put(copy);
    Kit.bundle.touch('rules-duplicate');
    return copy;
  }
  function deleteRecord(rec, typeName) {
    var refs = refsTo(rec.id);
    return Kit.ui.confirm({
      title: 'Delete "' + (rec.name || rec.id) + '"?',
      message: 'This removes the record. Its ID is not reused.',
      detail: refs.length ? 'It is referenced by ' + refs.slice(0, 5).join(', ') + (refs.length > 5 ? ', and more' : '') + '. Those references will show as broken until you fix them.' : '',
      okLabel: 'Delete', danger: true
    }).then(function (ok) {
      if (!ok) return false;
      Kit.records.del(rec.id);
      Kit.bundle.touch('rules-delete');
      return true;
    });
  }
  function markReviewed(rec) {
    rec.charterVersion = cur().charter.version || 0;
    Kit.bundle.touch('rules-reviewed');
  }

  // Per type extras. init sets new record defaults; extras paints tools under the form.
  var TYPE_CFG = {
    Status: {
      init: function (rec) { rec.gauge = 'normal'; rec.tickEffect = { kind: 'none', percent: 0 }; rec.duration = 3; rec.cure = { battleEnd: true, onHit: false, curedBy: [] }; },
      draftPrompt: 'Draft a status effect that fits the Charter tone. Choose a gauge effect, an optional tick effect, a duration, and how it is cured.'
    },
    Formula: {
      init: function (rec) { rec.template = 'phys.sub'; rec.params = {}; },
      extras: function (box, rec, api) { formulaExtras(box, rec, api); },
      draftPrompt: 'Draft a battle formula. Prefer a template from the library and only override parameters you need to change. If you write an expression use only a.<stat>, a.level, t.<stat>, t.level, power, p.<param>, the operators + - * / ^, parentheses, and the functions min, max, floor, ceil, round, clamp, pow, sqrt.'
    },
    Weather: {
      init: function (rec) {
        rec.realWorld = '';
        rec.elementMultipliers = {};
        elemList(rsOf()).forEach(function (e) { rec.elementMultipliers[e.key] = 1; });
        rec.encounterModifiers = { rate: 1, familyWeights: [] };
      },
      extras: function (box, rec, api) { weatherExtras(box, rec, api); },
      draftPrompt: 'Draft a weather state grounded in a real meteorological phenomenon. Set element multipliers between 0 and 5 where one is neutral, and an encounter rate near one.'
    },
    Materia: {
      extras: function (box, rec, api) { materiaExtras(box, rec, api); }
    },
    Ability: {
      init: function (rec) { rec.kind = 'attack'; rec.power = 10; rec.cost = { mp: 0, ap: 0 }; rec.targeting = { side: 'foe', scope: 'single' }; rec.chargeTicks = 0; rec.statusEffects = []; },
      extras: function (box, rec, api) { abilityExtras(box, rec, api); },
      draftPrompt: 'Draft an ability that fits the Charter magic system and tone. Choose a kind, an element from the declared elements when it fits, a power between 5 and 120, an MP cost, and targeting.'
    },
    Item: {
      init: function (rec) { rec.kind = 'consumable'; rec.price = 0; },
      extras: function (box, rec, api) { itemExtras(box, rec, api); },
      draftPrompt: 'Draft an item that fits the Charter setting. Choose consumable, key, or material, a fair price in gil, and for a consumable the effect ability by its ID when one fits.'
    },
    Equipment: {
      init: function (rec) { rec.slot = 'weapon'; rec.tier = 1; rec.price = 0; rec.stats = {}; rec.slotLayout = { count: 0, links: [] }; },
      hide: ['slotLayout'],
      extras: function (box, rec, api) { equipmentExtras(box, rec, api); },
      draftPrompt: 'Draft a piece of equipment for a weapon, armor, or accessory slot. Give it a gear tier, a price, stat bonuses using only the declared stats, and a slot layout with a count of slots and links written as pairs of slot numbers counted from zero.'
    },
    Character: {
      init: function (rec) {
        var b = cur();
        rec.weaponClass = '';
        rec.statLeanings = statTable(b, function () { return 1; });
        rec.baseStats = statTable(b, function (s) { return typeof s.min === 'number' ? s.min : 1; });
        rec.growth = statTable(b, function () { return 0; });
        rec.limitTree = []; rec.relationshipHooks = [];
      },
      hide: ['limitTree'],
      extras: function (box, rec, api) { characterExtras(box, rec, api); },
      listExtras: function (main) { characterListExtras(main); },
      draftPrompt: 'Draft a playable character from a Charter party entry.'
    },
    Family: {
      init: function (rec) {
        var tx = rsOf().taxonomy, v0 = tx && Array.isArray(tx.values) ? tx.values[0] : '';
        rec.type = U.isObj(v0) ? String(v0.key || '') : (v0 == null ? '' : String(v0));
        rec.palette = { base: '#6d5a7a', accent: '#e4b363' }; rec.absorbsOwnType = false;
      },
      extras: function (box, rec, api) { familyExtras(box, rec, api); },
      draftPrompt: 'Draft an enemy family. Choose its type from the taxonomy values and a base and accent color that suit it. Its affinity is computed from the type, so do not invent one.'
    },
    Enemy: {
      init: function (rec) { var b = cur(); rec.tier = 1; rec.level = 1; rec.stats = statTable(b, function (s) { return typeof s.min === 'number' ? s.min : 1; }); rec.drops = []; rec.steal = []; rec.gil = 0; rec.exp = 0; rec.ap = 0; rec.isBoss = false; },
      extras: function (box, rec, api) { enemyExtras(box, rec, api); },
      draftPrompt: function (b) {
        var st = statList(b).map(function (s) { return s.key + ' ' + (typeof s.min === 'number' ? s.min : 0) + ' to ' + (typeof s.max === 'number' ? s.max : 99); }).join(', ');
        return 'Draft an enemy that belongs to one of the listed families, chosen by its ID. Keep stats inside these ranges: ' + st + '. Pick a level, and modest gil, EXP, and AP rewards that suit the level.';
      }
    },
    Gambit: {
      init: function (rec) { rec.rules = []; rec.counters = []; },
      hide: ['rules', 'counters'],
      extras: function (box, rec, api) { gambitBuilder(box, rec, api, 'Gambit'); },
      draftPrompt: 'Draft a gambit set: two to four rules checked from the top, with the most urgent first and a fallback always rule last. Use only listed abilities and statuses. Condition parameters are a fraction such as 0.35, a whole number, or a status ID.'
    },
    BossStrategy: {
      init: function (rec) { rec.text = ''; rec.rules = []; rec.counters = []; },
      hide: ['rules', 'counters'],
      extras: function (box, rec, api) { gambitBuilder(box, rec, api, 'BossStrategy'); },
      draftPrompt: 'Draft a boss strategy for a listed boss enemy, chosen by its ID. Write the plan in words, then rules and counters that carry it out using only listed abilities.'
    },
    Troop: {
      init: function (rec) { rec.members = []; rec.flags = { noEscape: false, preemptiveChance: 0 }; },
      hide: ['members'],
      extras: function (box, rec, api) { troopBuilder(box, rec, api); },
      draftPrompt: 'Draft a troop of one to four listed enemies with a row for each (front or back), tied to a listed chapter when one fits.'
    },
    Shop: {
      init: function (rec) { rec.inventory = []; },
      extras: function (box, rec, api) { shopExtras(box, rec, api); },
      draftPrompt: 'Draft a shop with a small inventory of listed items and equipment, and the chapter it opens in when one fits. Only use price overrides when a price should differ from the base.'
    },
    Limit: {
      init: function (rec) { rec.level = 1; rec.unlock = { uses: 0 }; },
      extras: function (box, rec, api) { limitExtras(box, rec, api); },
      draftPrompt: 'Draft a limit break with a level from one to four, an unlock by uses or kills, and the action ability by its ID.'
    },
    ExpectedPartyState: {
      init: function (rec) { rec.targetLevel = 1; rec.gearTier = 1; rec.gil = 0; rec.targetWinRate = 80; },
      draftPrompt: 'Draft an Expected Party State row for a listed chapter, choosing the chapter by its ID. Give a target level, gear tier, gil on hand, and a target win rate near 80 percent.'
    }
  };

  function formulaExtras(box, rec, api) {
    var b = cur();
    var lib = el('div', 'rl-tools');
    var sel = el('select', 'inp'); sel.setAttribute('aria-label', 'Load a library template');
    sel.appendChild(new Option('Load a library template...', ''));
    FORMULA_ORDER.forEach(function (id) { sel.appendChild(new Option(id + ': ' + FORMULA_LIB[id].label, id)); });
    sel.addEventListener('change', function () {
      var id = sel.value; if (!id) return;
      rec.template = id; rec.params = {};
      api.changed(true);
    });
    lib.appendChild(sel);
    var note = el('div', 'muted rl-note');
    var src = recordSource(rec);
    note.textContent = src && src.template ? FORMULA_LIB[src.template].note : 'Custom expression. Variables are a.<stat>, a.level, t.<stat>, t.level, power, and p.<param>.';
    lib.appendChild(note);
    if (rec.template && FORMULA_LIB[rec.template]) {
      var dp = el('div', 'rl-defaults');
      dp.innerHTML = '<span class="muted">Default parameters:</span> ' + Object.keys(FORMULA_LIB[rec.template].params).map(function (k) { return '<code>' + esc(k) + ' = ' + esc(FORMULA_LIB[rec.template].params[k]) + '</code>'; }).join(' ');
      lib.appendChild(dp);
      var exp = el('div', 'rl-expr'); exp.innerHTML = '<span class="muted">Expression:</span> <code>' + esc(FORMULA_LIB[rec.template].expr) + '</code>';
      lib.appendChild(exp);
    }
    box.appendChild(lib);
    var pv = el('div');
    box.appendChild(pv);
    prevCtl = WSX.preview(pv, function () { return recordSource(rec); });
    api.onLive(function () { if (prevCtl) prevCtl.update(); });
    void b;
  }

  function weatherExtras(box, rec, api) {
    var tools = el('div', 'rl-tools');
    var wrap = Kit.ai.button('Suggest from meteorology', function () { return suggestWeather(rec, api); }, { busyLabel: 'Consulting Claude...' });
    tools.appendChild(wrap);
    tools.appendChild(el('span', 'muted rl-note', 'Sonnet reads the real world phenomenon and proposes an element multiplier for each element. You review before anything changes.'));
    box.appendChild(tools);
  }
  async function suggestWeather(rec, api) {
    var phen = String(rec.realWorld || '').trim();
    if (!phen) { Kit.ui.toast('Fill in the real world phenomenon first.', 'warn'); return; }
    var elems = elemList(rsOf());
    if (!elems.length) { Kit.ui.toast('Declare elements in the Charter first.', 'warn'); return; }
    var system = 'You are a meteorology-literate game designer. Given a real weather phenomenon and a list of game elements, set an element damage multiplier for each element based on the physics of the phenomenon. One is neutral. Use 0 to 5, typically 0.5 to 2. Explain each briefly. Return ONLY JSON: {"multipliers":{"<elementKey>":number},"rationale":{"<elementKey>":"one short sentence"}}. Include every element key exactly once. Do not use dashes in the text.';
    var user = 'Phenomenon: ' + phen + '\nElements: ' + JSON.stringify(elems.map(function (e) { return { key: e.key, label: e.label || e.key }; }));
    var out = await Kit.claude({ tier: 'sonnet', system: system, messages: [{ role: 'user', content: user }], maxTokens: 900, expectJson: true });
    var j = out && out.json;
    var m = j && U.isObj(j.multipliers) ? j.multipliers : null;
    if (!m) { Kit.ui.toast('Claude did not return usable multipliers.', 'warn'); return; }
    var clean = {}, why = U.isObj(j.rationale) ? j.rationale : {};
    elems.forEach(function (e) {
      var v = Number(m[e.key]);
      clean[e.key] = isFinite(v) ? Math.max(0, Math.min(5, Math.round(v * 100) / 100)) : 1;
    });
    return new Promise(function (resolve) {
      Kit.ui.dialog({
        title: 'Suggested multipliers for ' + phen,
        body: function (body) {
          var t = el('table', 'tbl'); t.innerHTML = '<thead><tr><th scope="col">Element</th><th scope="col">Now</th><th scope="col">Suggested</th><th scope="col">Why</th></tr></thead>';
          var tb = el('tbody');
          elems.forEach(function (e) {
            var now = rec.elementMultipliers && rec.elementMultipliers[e.key];
            tb.appendChild(el('tr', null, '<th scope="row">' + esc(e.label || e.key) + '</th><td>' + esc(now == null ? '1' : now) + '</td><td><strong>' + esc(clean[e.key]) + '</strong></td><td>' + esc(why[e.key] || '') + '</td>'));
          });
          t.appendChild(tb);
          var w = el('div', 'tbl-wrap'); w.appendChild(t); body.appendChild(w);
        },
        actions: [{ label: 'Keep mine', kind: 'ghost', value: false }, { label: 'Apply', kind: 'primary', value: true }],
        onResult: function (v) {
          if (v === true) { rec.elementMultipliers = clean; api.changed(true); Kit.ui.toast('Multipliers applied.', 'ok'); }
          resolve();
        }
      });
    });
  }

  function materiaExtras(box, rec, api) {
    if (!WSX.roleId('ap')) return;
    var tools = el('div', 'rl-tools');
    tools.appendChild(button('Fill AP thresholds from the AP formula', 'chart', '', function () {
      try {
        var levels = 5, acc = 0, out = [];
        for (var l = 1; l < levels; l++) { acc += WSX.evalRole('ap', { a: { level: l }, t: {}, power: 0 }); out.push(acc); }
        rec.apThresholds = out; api.changed(true);
      } catch (e) { Kit.ui.toast(e.message, 'warn'); }
    }));
    tools.appendChild(el('span', 'muted rl-note', 'Uses the ruleset AP formula and adds the amounts up for five levels.'));
    box.appendChild(tools);
  }

  // ================================================================ Pass 4B: content editors
  // Helpers shared by the content editors below. Everything writes straight into the record, then calls api.changed.
  function nameOf(id) { var e = id ? Kit.index().byId[id] : null; return e ? e.name : (id || ''); }
  function recOf(id) { return id ? Kit.records.get(id) : null; }
  function missingId(id) { return !!id && !Kit.index().byId[id]; }
  function num(v) { v = Number(v); return isFinite(v) ? v : 0; }
  function clampInt(v, lo, hi, dflt) { v = Math.round(Number(v)); if (!isFinite(v)) v = dflt; return Math.max(lo, Math.min(hi, v)); }
  function vocab(name) { return (window.WS.codex && window.WS.codex[name]) || []; }
  function vocabLabel(list, key) { var l = list || []; for (var i = 0; i < l.length; i++) { if (l[i].key === key) return l[i].label; } return key || ''; }
  function vocabOptions(name) { return vocab(name).map(function (k) { return { value: k.key, label: k.label }; }); }
  function statList(b) { var st = rsOf(b).stats; return (Array.isArray(st) ? st : []).filter(function (s) { return U.isObj(s) && s.key; }); }
  function statTable(b, fn) { var o = {}; statList(b).forEach(function (s) { o[s.key] = fn(s); }); return o; }
  function elemLabel(k) { var l = elemList(rsOf()).filter(function (e) { return e.key === k; })[0]; return l ? (l.label || l.key) : k; }
  function pathHit(path, prefixes) {
    path = String(path || '');
    return prefixes.some(function (p) { return path === p || path.indexOf(p + '.') === 0 || path.indexOf(p + '[') === 0; });
  }
  // A message box that shows the validator's findings for the fields a builder owns.
  function issueBox(typeName, rec, prefixes) {
    var box = el('div', 'rl-msgs');
    box.paint = function () {
      U.clear(box);
      Kit.validate.record(typeName, rec).forEach(function (it) {
        if (!pathHit(it.fieldPath, prefixes)) return;
        box.appendChild(el('div', 'msg msg-' + it.level, esc(it.message)));
      });
    };
    box.paint();
    return box;
  }
  function refBtnHtml(id) {
    if (!id) return '<span class="ref-empty">None. Tap to choose.</span>';
    return '<span class="ref-name">' + esc(nameOf(id)) + '</span><code class="id">' + esc(id) + '</code>' + (missingId(id) ? '<span class="chip chip-broken">Broken</span>' : '');
  }
  // A ref picker button. get returns the current id, set stores the new one (null clears).
  function refButton(prefix, title, get, set, label) {
    var b = el('button', 'ref-btn', refBtnHtml(get())); b.type = 'button';
    if (label) b.setAttribute('aria-label', label);
    b.addEventListener('click', function () {
      Kit.ui.pickRef({ prefix: prefix, title: title, current: get() }).then(function (v) {
        if (v === undefined) return;
        set(v || null);
        b.innerHTML = refBtnHtml(get());
      });
    });
    return b;
  }
  function openRecord(id) {
    var tn = typeOfRecordId(id);
    if (!tn) return;
    state.view = 'type:' + tn; state.editing = id; repaint();
  }
  function recLink(id, text) {
    var b = el('button', 'btn btn-ghost rl-link', esc(text || nameOf(id))); b.type = 'button';
    b.addEventListener('click', function () { openRecord(id); });
    return b;
  }
  function swapIn(arr, i, j) { if (i < 0 || j < 0 || i >= arr.length || j >= arr.length) return false; var t = arr[i]; arr[i] = arr[j]; arr[j] = t; return true; }
  // Native drag and drop for sortable rows. Buttons remain the touch and keyboard route.
  function enableDrag(row, grip, kind, arr, i, done) {
    grip.draggable = true;
    grip.addEventListener('dragstart', function (e) {
      try { e.dataTransfer.setData('text/plain', kind + ':' + i); e.dataTransfer.effectAllowed = 'move'; } catch (x) { /* older browsers */ }
      row.classList.add('dragging');
    });
    grip.addEventListener('dragend', function () { row.classList.remove('dragging'); });
    row.addEventListener('dragover', function (e) { e.preventDefault(); row.classList.add('dropping'); });
    row.addEventListener('dragleave', function () { row.classList.remove('dropping'); });
    row.addEventListener('drop', function (e) {
      e.preventDefault(); row.classList.remove('dropping');
      var raw = ''; try { raw = e.dataTransfer.getData('text/plain'); } catch (x) { raw = ''; }
      var m = /^(\w+):(\d+)$/.exec(raw);
      if (!m || m[1] !== kind) return;
      var from = Number(m[2]);
      if (from === i || from >= arr.length) return;
      var item = arr.splice(from, 1)[0];
      arr.splice(i, 0, item);
      done();
    });
  }
  var SVGNS = 'http://www.w3.org/2000/svg';
  function svgEl(tag, attrs, cls) {
    var n = document.createElementNS(SVGNS, tag);
    Object.keys(attrs || {}).forEach(function (k) { n.setAttribute(k, attrs[k]); });
    if (cls) n.setAttribute('class', cls);
    return n;
  }

  // ---------------------------------------------------------------- abilities and items
  var SIDE_NOUN = { foe: ['foe', 'foes'], ally: ['ally', 'allies'], any: ['target', 'targets'] };
  function targetPhrase(t) {
    t = U.isObj(t) ? t : {};
    if (t.side === 'self') return 'the user';
    var n = SIDE_NOUN[t.side] || ['target', 'targets'];
    switch (t.scope) {
      case 'all': return 'all ' + n[1];
      case 'row': return 'a row of ' + n[1];
      case 'random': return 'a random ' + n[0];
      default: return 'one ' + n[0];
    }
  }
  function ablSummary(rec) {
    var kind = vocabLabel(vocab('ABL_KINDS'), rec.kind) || 'Ability';
    var s = kind + (rec.element ? ', ' + elemLabel(rec.element) : '') + '. Power ' + num(rec.power) + '. ';
    var c = U.isObj(rec.cost) ? rec.cost : {}, cost = [];
    if (num(c.mp)) cost.push(num(c.mp) + ' MP');
    if (num(c.ap)) cost.push(num(c.ap) + ' AP');
    if (c.item) cost.push(nameOf(c.item));
    s += cost.length ? 'Costs ' + cost.join(' and ') + '. ' : 'Free to use. ';
    s += 'Targets ' + targetPhrase(rec.targeting) + '. ';
    s += num(rec.chargeTicks) ? 'Charges for ' + num(rec.chargeTicks) + ' ticks.' : 'No charge time.';
    var n = Array.isArray(rec.statusEffects) ? rec.statusEffects.length : 0;
    if (n) s += ' Can inflict ' + n + ' status' + (n === 1 ? '' : 'es') + '.';
    return s;
  }
  var ABL_ROLE = { attack: 'phys', magic: 'mag', heal: 'heal', summon: 'mag', enemy: 'phys', limit: 'phys' };
  function ablSample(rec) {
    var role = ABL_ROLE[rec.kind];
    if (!role) return null;
    var fid = rec.formula && recOf(rec.formula) ? rec.formula : WSX.roleId(role);
    if (!fid) return 'The ruleset has no ' + role + ' formula, so there is no sample.';
    var sc = sampleScope(cur());
    sc.power = num(rec.power);
    try {
      var v = WSX.evalFormula(fid, sc);
      return 'Sample at level ' + sampleState.level + ' with power ' + sc.power + ': about ' + fmtNum(v) + (rec.kind === 'heal' ? ' HP restored.' : ' damage.') + ' Sample stats come from the Formulas preview.';
    } catch (e) { return 'Sample not available: ' + e.message; }
  }
  function abilityExtras(box, rec, api) {
    var card = el('div', 'card rl-summary');
    box.appendChild(card);
    function paint() {
      var samp = ablSample(rec);
      card.innerHTML = '<div class="rl-sumline">' + esc(ablSummary(rec)) + '</div>' + (samp ? '<div class="muted rl-note">' + esc(samp) + '</div>' : '');
    }
    paint(); api.onLive(paint);
  }
  function itemExtras(box, rec, api) {
    var card = el('div', 'card rl-summary');
    box.appendChild(card);
    function paint() {
      U.clear(card);
      var txt;
      if (rec.kind === 'consumable') txt = rec.effect ? 'Consumable. Using it fires ' + nameOf(rec.effect) + '.' : 'Consumable with no effect yet.';
      else if (rec.kind === 'key') txt = 'Key item. It stays in the bag and is not normally sold.';
      else txt = 'Crafting material.';
      if (num(rec.price)) txt += ' Base price ' + num(rec.price) + ' gil.';
      card.appendChild(el('div', 'rl-sumline', esc(txt)));
      if (rec.kind === 'key' && num(rec.price) > 0) card.appendChild(el('div', 'msg msg-warning', 'A key item with a price could end up for sale. Check the shops.'));
      if (rec.kind === 'consumable' && !rec.effect) {
        var row = el('div', 'btn-row');
        row.appendChild(button('Create an effect ability', 'plus', '', function () {
          var name = String(rec.name || 'Item') + ' effect';
          var abl = { id: Kit.ids.mint('abl_', name), name: name, charterVersion: cur().charter.version || 0 };
          typeDefaults('Ability', abl);
          abl.kind = 'heal'; abl.targeting = { side: 'ally', scope: 'single' }; abl.power = 50;
          Kit.records.put(abl); rec.effect = abl.id;
          Kit.bundle.touch('rules-new'); api.changed(true);
          Kit.ui.toast('Created ' + name + ' and linked it.', 'ok');
        }));
        card.appendChild(row);
      }
    }
    paint(); api.onLive(paint);
  }

  // ---------------------------------------------------------------- equipment: visual slot layout builder
  function slotLayoutOf(rec) {
    if (!U.isObj(rec.slotLayout)) rec.slotLayout = {};
    var L = rec.slotLayout;
    L.count = clampInt(L.count, 0, 8, 0);
    var seen = {}, out = [];
    (Array.isArray(L.links) ? L.links : []).forEach(function (p) {
      if (!Array.isArray(p) || p.length !== 2) return;
      var i = Math.round(Number(p[0])), j = Math.round(Number(p[1]));
      if (!isFinite(i) || !isFinite(j) || i === j) return;
      if (i > j) { var t = i; i = j; j = t; }
      var k = i + ':' + j;
      if (seen[k]) return;
      seen[k] = 1; out.push([i, j]);
    });
    L.links = out;
    return L;
  }
  // Slots sit in rows of four inside a 256 unit wide drawing, so the picture scales to any screen.
  function slotPos(i, count) {
    var r = Math.floor(i / 4), c = i % 4, inRow = Math.min(4, count - r * 4);
    return { x: (256 - inRow * 64) / 2 + 32 + c * 64, y: 46 + r * 72 };
  }
  function slotBuilder(box, rec, api) {
    var host = el('div', 'rl-slotb'); host.setAttribute('data-bpath', 'slotLayout');
    box.appendChild(host);
    var sel = -1, issues = issueBox('Equipment', rec, ['slotLayout']);
    function setCount(n) {
      var L = slotLayoutOf(rec), before = L.links.length;
      n = clampInt(n, 0, 8, 0);
      L.count = n;
      L.links = L.links.filter(function (p) { return p[0] < n && p[1] < n; });
      if (L.links.length < before) Kit.ui.toast('Removed ' + (before - L.links.length) + ' link' + (before - L.links.length === 1 ? '' : 's') + ' that pointed past the last slot.', 'warn');
      if (sel >= n) sel = -1;
      api.changed(false); paint();
    }
    function toggleLink(i, j) {
      var L = slotLayoutOf(rec);
      if (i > j) { var t = i; i = j; j = t; }
      var at = -1;
      L.links.forEach(function (p, k) { if (p[0] === i && p[1] === j) at = k; });
      if (at >= 0) L.links.splice(at, 1); else L.links.push([i, j]);
      L.links.sort(function (a, b) { return a[0] - b[0] || a[1] - b[1]; });
    }
    function pick(i) {
      if (sel < 0) { sel = i; paint(); return; }
      if (sel === i) { sel = -1; paint(); return; }
      toggleLink(sel, i); sel = -1; api.changed(false); paint();
    }
    function paint() {
      U.clear(host);
      var L = slotLayoutOf(rec);
      host.appendChild(el('h3', 'section-h', 'Slot layout'));
      host.appendChild(el('p', 'muted rl-note', 'Choose how many slots this piece has. Then tap one slot and a second slot to link or unlink them. Linked slots are joined by a bar.'));
      var ctl = el('div', 'rl-tools');
      var less = button('Fewer slots', 'down', 'btn-ghost', function () { setCount(L.count - 1); });
      var more = button('More slots', 'plus', 'btn-ghost', function () { setCount(L.count + 1); });
      less.disabled = L.count <= 0; more.disabled = L.count >= 8;
      ctl.appendChild(less);
      ctl.appendChild(el('span', 'rl-slotcount', '<strong>' + L.count + '</strong> slot' + (L.count === 1 ? '' : 's')));
      ctl.appendChild(more);
      var clr = button('Clear links', 'x', 'btn-ghost', function () { L.links = []; sel = -1; api.changed(false); paint(); });
      clr.disabled = !L.links.length;
      ctl.appendChild(clr);
      host.appendChild(ctl);
      if (L.count > 0) {
        var rows = Math.ceil(L.count / 4), H = rows * 72 + 22;
        var svg = svgEl('svg', { viewBox: '0 0 256 ' + H, role: 'group', 'aria-label': 'Slot layout with ' + L.count + ' slots and ' + L.links.length + ' links' }, 'rl-slotsvg');
        L.links.forEach(function (p) {
          if (p[0] >= L.count || p[1] >= L.count) return;
          var a = slotPos(p[0], L.count), c = slotPos(p[1], L.count);
          var sameRow = Math.floor(p[0] / 4) === Math.floor(p[1] / 4), adj = sameRow && p[1] - p[0] === 1;
          if (sameRow && !adj) svg.appendChild(svgEl('path', { d: 'M' + a.x + ' ' + a.y + ' Q' + ((a.x + c.x) / 2) + ' ' + (a.y - 46) + ' ' + c.x + ' ' + c.y }, 'rl-slot-bar arc'));
          else svg.appendChild(svgEl('line', { x1: a.x, y1: a.y, x2: c.x, y2: c.y }, 'rl-slot-bar'));
        });
        for (var i = 0; i < L.count; i++) (function (idx) {
          var pos = slotPos(idx, L.count);
          var g = svgEl('g', { tabindex: '0', role: 'button', 'aria-pressed': sel === idx ? 'true' : 'false', 'aria-label': 'Slot ' + (idx + 1) + (sel === idx ? ', selected. Choose a second slot to link.' : '') }, 'rl-slot' + (sel === idx ? ' sel' : ''));
          g.appendChild(svgEl('circle', { cx: pos.x, cy: pos.y, r: 22 }));
          var tx = svgEl('text', { x: pos.x, y: pos.y }); tx.textContent = String(idx + 1);
          g.appendChild(tx);
          g.addEventListener('click', function () { pick(idx); });
          g.addEventListener('keydown', function (e) { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); pick(idx); } });
          svg.appendChild(g);
        })(i);
        host.appendChild(svg);
      } else host.appendChild(el('div', 'empty-line', 'No slots yet. Use More slots to add the first one.'));
      if (L.links.length) {
        var chips = el('div', 'rl-chipbar');
        L.links.forEach(function (p, k) {
          var bad = p[0] >= L.count || p[1] >= L.count;
          var chip = el('span', 'chip ' + (bad ? 'chip-warning' : 'chip-accent'), 'Slot ' + (p[0] + 1) + ' linked to slot ' + (p[1] + 1) + (bad ? ' (past the last slot)' : ''));
          var rm = iconButton('x', 'Remove link between slot ' + (p[0] + 1) + ' and slot ' + (p[1] + 1), function () { L.links.splice(k, 1); api.changed(false); paint(); });
          var wrap = el('span', 'rl-linkchip'); wrap.appendChild(chip); wrap.appendChild(rm);
          chips.appendChild(wrap);
        });
        host.appendChild(chips);
      }
      issues.paint();
      host.appendChild(issues);
    }
    paint();
  }
  function equipmentExtras(box, rec, api) {
    var card = el('div', 'card rl-summary');
    box.appendChild(card);
    function paint() {
      var bits = [cap1(rec.slot || 'gear')];
      if (rec.slot === 'weapon' && rec.weaponClass) bits.push(rec.weaponClass + ' class');
      if (rec.tier) bits.push('tier ' + rec.tier);
      if (num(rec.price)) bits.push(num(rec.price) + ' gil');
      var bon = [], st = U.isObj(rec.stats) ? rec.stats : {};
      Object.keys(st).forEach(function (k) { if (num(st[k])) bon.push(k + ' ' + (num(st[k]) > 0 ? '+' : '') + num(st[k])); });
      var L = U.isObj(rec.slotLayout) ? rec.slotLayout : {};
      card.innerHTML = '<div class="rl-sumline">' + esc(bits.join(', ') + '.') + (bon.length ? ' Bonuses: ' + esc(bon.join(', ')) + '.' : '') + ' ' + esc((L.count || 0) + ' slot' + (L.count === 1 ? '' : 's') + ', ' + ((L.links || []).length) + ' link' + ((L.links || []).length === 1 ? '' : 's') + '.') + '</div>';
    }
    paint(); api.onLive(paint);
    slotBuilder(box, rec, api);
  }

  // ---------------------------------------------------------------- characters: limit tree builder and previews
  function partyMembers(b) {
    var s = b.charter && b.charter.sections, p = s && s.party;
    return p && Array.isArray(p.members) ? p.members.filter(function (m) { return U.isObj(m) && String(m.name || '').trim(); }) : [];
  }
  function chrByName(name) {
    name = String(name || '').trim().toLowerCase();
    return Kit.records.list('chr_').filter(function (c) { return String(c.name || '').trim().toLowerCase() === name; })[0] || null;
  }
  function unlockText(lim) {
    var u = U.isObj(lim.unlock) ? lim.unlock : {};
    if (num(u.uses) > 0) return 'after ' + num(u.uses) + ' uses of the previous limit';
    if (num(u.kills) > 0) return 'after ' + num(u.kills) + ' kills';
    return 'available at once';
  }
  function limitBuilder(box, rec, api) {
    var host = el('div', 'rl-limb'); host.setAttribute('data-bpath', 'limitTree');
    box.appendChild(host);
    var issues = issueBox('Character', rec, ['limitTree']);
    function tree() { if (!Array.isArray(rec.limitTree)) rec.limitTree = []; return rec.limitTree; }
    function commit() { api.changed(false); paint(); }
    function addExisting() {
      Kit.ui.pickRef({ prefix: 'lim_', title: 'Add a limit break to ' + (rec.name || 'this character') }).then(function (id) {
        if (!id) return;
        if (tree().indexOf(id) >= 0) { Kit.ui.toast('That limit is already in the tree.', 'warn'); return; }
        tree().push(id); commit();
      });
    }
    function addNew() {
      if (tree().length >= 4) { Kit.ui.toast('A limit tree holds at most four levels.', 'warn'); return; }
      askName('New limit break', '').then(function (n) {
        if (n == null) return;
        return Kit.ui.pickRef({ prefix: 'abl_', title: 'Choose the limit action (optional)' }).then(function (abl) {
          var level = Math.min(4, tree().length + 1);
          var lim = { id: Kit.ids.mint('lim_', n.trim()), name: n.trim(), charterVersion: cur().charter.version || 0 };
          typeDefaults('Limit', lim);
          lim.level = level; lim.unlock = level > 1 ? { uses: 3 } : { uses: 0 };
          lim.action = abl || null;
          Kit.records.put(lim); tree().push(lim.id);
          Kit.bundle.touch('rules-new'); commit();
        });
      });
    }
    function paint() {
      U.clear(host);
      host.appendChild(el('h3', 'section-h', 'Limit tree'));
      host.appendChild(el('p', 'muted rl-note', 'Limit breaks in unlock order. The gauge fills as this character takes damage, and each level opens after the uses or kills you set on the limit.'));
      var list = tree();
      if (!list.length) host.appendChild(el('div', 'empty-line', 'No limit breaks yet. Add an existing one, or create a new one here.'));
      var prev = 0, ascending = true;
      list.forEach(function (id, i) {
        var lim = recOf(id), card = el('div', 'rl-lcard');
        var main = el('div', 'rl-lcard-main');
        main.appendChild(el('span', 'rl-lbadge', 'Limit ' + (i + 1)));
        var title = el('div', 'rl-ltitle');
        title.appendChild(recLink(id, lim ? lim.name : id));
        if (!lim) title.appendChild(el('span', 'chip chip-broken', 'Broken'));
        main.appendChild(title);
        if (lim) {
          var meta = el('div', 'rl-lmeta');
          meta.innerHTML = '<span class="chip chip-muted">Level ' + esc(lim.level == null ? '?' : lim.level) + '</span><span class="chip chip-muted">' + esc(unlockText(lim)) + '</span>' +
            '<span class="chip ' + (lim.action ? (missingId(lim.action) ? 'chip-broken' : 'chip-accent') : 'chip-warning') + '">' + esc(lim.action ? nameOf(lim.action) : 'No action yet') + '</span>';
          main.appendChild(meta);
          if (num(lim.level) < prev) ascending = false;
          prev = num(lim.level);
        }
        card.appendChild(main);
        var ctrls = el('div', 'rl-ctrls');
        var up = iconButton('up', 'Move limit ' + (i + 1) + ' up', function () { if (swapIn(list, i, i - 1)) commit(); });
        var dn = iconButton('down', 'Move limit ' + (i + 1) + ' down', function () { if (swapIn(list, i, i + 1)) commit(); });
        up.disabled = i === 0; dn.disabled = i === list.length - 1;
        ctrls.appendChild(up); ctrls.appendChild(dn);
        ctrls.appendChild(iconButton('trash', 'Remove limit ' + (i + 1) + ' from the tree', function () { list.splice(i, 1); commit(); }, 'btn-danger'));
        card.appendChild(ctrls);
        host.appendChild(card);
      });
      if (!ascending) host.appendChild(el('div', 'msg msg-warning', 'Limit levels should rise down the list. Reorder the limits or change a level.'));
      var bar = el('div', 'btn-row');
      bar.appendChild(button('Add existing limit', 'plus', '', addExisting));
      bar.appendChild(button('New limit here', 'spark', '', addNew));
      host.appendChild(bar);
      issues.paint();
      host.appendChild(issues);
    }
    paint();
  }
  function characterExtras(box, rec, api) {
    var b = cur();
    var seed = el('div', 'card rl-summary');
    box.appendChild(seed);
    var m = partyMembers(b).filter(function (p) { return String(p.name).trim().toLowerCase() === String(rec.name || '').trim().toLowerCase(); })[0];
    if (m) seed.innerHTML = '<div class="rl-sumline"><strong>Charter party entry.</strong> ' + esc(m.past || 'No past written yet.') + '</div>';
    else seed.innerHTML = '<div class="muted rl-note">No Charter party entry has this name, so this character is not tied to the party list.</div>';
    // Stats by level, from the base stats plus growth per level.
    var prevBox = el('div', 'rl-block');
    box.appendChild(prevBox);
    function paintStats() {
      U.clear(prevBox);
      prevBox.appendChild(el('h3', 'section-h', 'Stats by level'));
      var stats = statList(cur());
      if (!stats.length) { prevBox.appendChild(el('div', 'empty-line', 'Declare stats in the Charter first.')); return; }
      var levels = [1, 10, 25, 50, 99];
      var t = el('table', 'tbl');
      var head = '<thead><tr><th scope="col">Stat</th>' + levels.map(function (l) { return '<th scope="col" class="num">Lv ' + l + '</th>'; }).join('') + '</tr></thead>';
      var rows = stats.map(function (s) {
        var base = num(rec.baseStats && rec.baseStats[s.key]), gr = num(rec.growth && rec.growth[s.key]);
        return '<tr><th scope="row">' + esc(s.label || s.key) + '</th>' + levels.map(function (l) {
          var v = Math.round(base + gr * (l - 1));
          if (typeof s.max === 'number') v = Math.min(v, s.max);
          return '<td class="num">' + v + '</td>';
        }).join('') + '</tr>';
      }).join('');
      t.innerHTML = head + '<tbody>' + rows + '</tbody>';
      var w = el('div', 'tbl-wrap'); w.appendChild(t); prevBox.appendChild(w);
      prevBox.appendChild(el('p', 'muted rl-note', 'Base stats plus growth per level, capped at each stat maximum.'));
    }
    paintStats(); api.onLive(paintStats);
    limitBuilder(box, rec, api);
  }
  function limitExtras(box, rec, api) {
    var users = Kit.records.list('chr_').filter(function (c) { return Array.isArray(c.limitTree) && c.limitTree.indexOf(rec.id) >= 0; });
    var card = el('div', 'card rl-summary');
    card.appendChild(el('div', 'rl-sumline', esc(unlockText(rec).replace(/^./, function (c) { return c.toUpperCase(); }) + '. Fires ' + (rec.action ? nameOf(rec.action) : 'no action yet') + '.')));
    var row = el('div', 'rl-chipbar');
    if (!users.length) row.appendChild(el('span', 'muted rl-note', 'No character has this limit in a tree yet.'));
    users.forEach(function (c) { row.appendChild(recLink(c.id, c.name)); });
    card.appendChild(row);
    box.appendChild(card);
    void api;
  }


  // ---------------------------------------------------------------- families: tier generator, enemies
  function hexToHsl(hex) {
    var m = /^#?([0-9a-f]{6})$/i.exec(String(hex || '').trim());
    if (!m) return null;
    var n = parseInt(m[1], 16), r = ((n >> 16) & 255) / 255, g = ((n >> 8) & 255) / 255, b = (n & 255) / 255;
    var mx = Math.max(r, g, b), mn = Math.min(r, g, b), l = (mx + mn) / 2, h = 0, s = 0, d = mx - mn;
    if (d) {
      s = l > 0.5 ? d / (2 - mx - mn) : d / (mx + mn);
      if (mx === r) h = (g - b) / d + (g < b ? 6 : 0);
      else if (mx === g) h = (b - r) / d + 2;
      else h = (r - g) / d + 4;
      h *= 60;
    }
    return { h: h, s: s, l: l };
  }
  function hslToHex(h, s, l) {
    h = ((h % 360) + 360) % 360;
    var c = (1 - Math.abs(2 * l - 1)) * s, x = c * (1 - Math.abs((h / 60) % 2 - 1)), m = l - c / 2, r = 0, g = 0, b = 0;
    if (h < 60) { r = c; g = x; } else if (h < 120) { r = x; g = c; } else if (h < 180) { g = c; b = x; }
    else if (h < 240) { g = x; b = c; } else if (h < 300) { r = x; b = c; } else { r = c; b = x; }
    function hx(v) { var t = Math.round((v + m) * 255).toString(16); return t.length < 2 ? '0' + t : t; }
    return '#' + hx(r) + hx(g) + hx(b);
  }
  function shiftHex(hex, deg) { var hsl = hexToHsl(hex); return hsl ? hslToHex(hsl.h + deg, hsl.s, hsl.l) : hex; }
  function tierBase(name) { return String(name || '').replace(/ T\d+$/, ''); }

  // Clones a family, and every enemy in it, into tiers 2 to N. Each tier family gets a shifted palette, and each tier
  // enemy gets scaled stats, level, and rewards. The originals are never changed apart from a missing tier number.
  function generateTiers(famId, o) {
    o = o || {};
    var b = cur(), fam = recOf(famId);
    if (!fam || Kit.ids.prefixOf(famId) !== 'fam_') throw new Error('Choose an enemy family first.');
    var T = clampInt(o.tiers, 2, 9, 3);
    var scale = num(o.scale) > 0 ? num(o.scale) : 1.5;
    var rew = num(o.rewardScale) > 0 ? num(o.rewardScale) : scale;
    var lvStep = clampInt(o.levelStep, 0, 30, 8);
    var shift = isFinite(Number(o.shift)) && o.shift !== '' && o.shift != null ? Number(o.shift) : 30;
    var maxOf = {};
    statList(b).forEach(function (s) { maxOf[s.key] = typeof s.max === 'number' ? s.max : 999999; });
    var srcs = Kit.records.list('enm_').filter(function (e) { return e.family === famId; });
    if (!srcs.length) throw new Error('This family has no enemies to clone yet. Add an enemy first.');
    srcs.forEach(function (e) { if (!e.tier) e.tier = 1; });
    var out = { families: [], enemies: [] }, version = b.charter.version || 0, fbase = tierBase(fam.name);
    for (var k = 2; k <= T; k++) (function (k) {
      var f = U.clone(fam);
      f.name = fbase + ' T' + k; f.id = Kit.ids.mint('fam_', f.name); f.charterVersion = version;
      if (U.isObj(f.palette)) f.palette = { base: shiftHex(f.palette.base, shift * (k - 1)), accent: shiftHex(f.palette.accent, shift * (k - 1)) };
      if (window.WS.codex && window.WS.codex.defaultAffinity) f.defaultAffinity = window.WS.codex.defaultAffinity(b, f.type, !!f.absorbsOwnType);
      Kit.records.put(f); out.families.push(f.id);
      srcs.forEach(function (e) {
        var st = num(e.tier) || 1;
        if (k <= st) return;
        var pw = k - st, c = U.clone(e);
        c.name = tierBase(e.name) + ' T' + k; c.id = Kit.ids.mint('enm_', c.name); c.charterVersion = version;
        c.family = f.id; c.tier = k;
        c.level = clampInt(num(e.level || 1) + lvStep * pw, 1, 99, 1);
        if (U.isObj(e.stats)) {
          c.stats = {};
          Object.keys(e.stats).forEach(function (sk) {
            var v = Math.round(num(e.stats[sk]) * Math.pow(scale, pw));
            c.stats[sk] = Math.max(0, Math.min(v, maxOf[sk] != null ? maxOf[sk] : 999999));
          });
        }
        ['gil', 'exp', 'ap'].forEach(function (rk) { if (e[rk] != null) c[rk] = Math.max(0, Math.round(num(e[rk]) * Math.pow(rew, pw))); });
        Kit.records.put(c); out.enemies.push(c.id);
      });
    })(k);
    Kit.index.invalidate(); Kit.bundle.touch('rules-tiers');
    return out;
  }
  function tierDialog(fam, api) {
    var src = Kit.records.list('enm_').filter(function (e) { return e.family === fam.id; });
    var ins = {}, note;
    function val(k) { return ins[k] ? ins[k].value : ''; }
    function preview() {
      var T = clampInt(val('tiers'), 2, 9, 3), n = 0;
      for (var k = 2; k <= T; k++) src.forEach(function (e) { if (k > (num(e.tier) || 1)) n++; });
      note.textContent = 'This creates ' + (T - 1) + ' famil' + (T - 1 === 1 ? 'y' : 'ies') + ' and ' + n + ' enem' + (n === 1 ? 'y' : 'ies') + '.';
    }
    Kit.ui.dialog({
      title: 'Generate tiers for ' + (fam.name || fam.id),
      body: function (body) {
        if (!src.length) { body.appendChild(el('p', 'msg msg-warning', 'This family has no enemies yet. Add an enemy to it first, then generate tiers.')); return; }
        body.appendChild(el('p', 'muted', 'Clones this family and its ' + src.length + ' enemy record' + (src.length === 1 ? '' : 's') + ' into higher tiers. Each tier gets its own family with a shifted palette. Its enemies get scaled stats, level, and rewards. The originals stay as they are.'));
        var defs = [
          ['tiers', 'Tiers in total', 3, { min: 2, max: 9, step: 1 }],
          ['scale', 'Stat scale per tier', 1.5, { min: 1.05, max: 4, step: 0.05 }],
          ['levelStep', 'Levels added per tier', 8, { min: 0, max: 30, step: 1 }],
          ['rewardScale', 'Reward scale per tier', 1.5, { min: 1, max: 4, step: 0.05 }],
          ['shift', 'Palette shift per tier (degrees)', 30, { min: 0, max: 180, step: 5 }]
        ];
        var grid = el('div', 'rl-tiergrid');
        defs.forEach(function (d) {
          var inp = mkInput({ type: 'number', step: d[3].step, min: d[3].min, max: d[3].max, value: d[2], label: d[1], onInput: preview });
          ins[d[0]] = inp;
          grid.appendChild(fieldBox(d[1], inp));
        });
        body.appendChild(grid);
        note = el('p', 'rl-sumline'); body.appendChild(note);
        preview();
      },
      actions: src.length ? [{ label: 'Cancel', kind: 'ghost', value: null }, { label: 'Generate', kind: 'primary', value: 'go' }] : [{ label: 'Close', kind: 'ghost', value: null }],
      onResult: function (v) {
        if (v !== 'go') return;
        try {
          var r = generateTiers(fam.id, { tiers: val('tiers'), scale: val('scale'), levelStep: val('levelStep'), rewardScale: val('rewardScale'), shift: val('shift') });
          Kit.ui.toast('Created ' + r.families.length + ' families and ' + r.enemies.length + ' enemies.', 'ok');
          api.changed(true);
        } catch (e) { Kit.ui.toast(e.message, 'error'); }
      }
    });
  }
  function familyExtras(box, rec, api) {
    var card = el('div', 'card rl-summary');
    box.appendChild(card);
    card.appendChild(el('h3', 'section-h', 'Enemies in this family'));
    var enemies = Kit.records.list('enm_').filter(function (e) { return e.family === rec.id; });
    if (!enemies.length) card.appendChild(el('div', 'empty-line', 'No enemies belong to this family yet.'));
    else {
      var chips = el('div', 'rl-chipbar');
      enemies.forEach(function (e) { chips.appendChild(recLink(e.id, e.name + ' (tier ' + (e.tier || 1) + ')')); });
      card.appendChild(chips);
    }
    var bar = el('div', 'btn-row');
    bar.appendChild(button('Add an enemy to this family', 'plus', '', function () {
      askName('New enemy in ' + (rec.name || 'this family'), '').then(function (n) {
        if (n == null) return;
        var e = newRecord('Enemy', n.trim());
        e.family = rec.id; Kit.bundle.touch('rules-new');
        state.view = 'type:Enemy'; state.editing = e.id; repaint();
      });
    }));
    bar.appendChild(button('Generate tiers', 'spark', '', function () { tierDialog(rec, api); }));
    card.appendChild(bar);
    card.appendChild(el('p', 'muted rl-note', 'Generate tiers clones this family and its enemies into N tiers, with scaled stats and a palette shift for each tier.'));
  }
  function enemyExtras(box, rec, api) {
    var aff = el('div', 'card rl-summary');
    box.appendChild(aff);
    function paintAff() {
      U.clear(aff);
      aff.appendChild(el('h3', 'section-h', 'Effective affinity'));
      if (!rec.family || missingId(rec.family)) { aff.appendChild(el('div', 'empty-line', 'Choose a family to see how this enemy takes each element.')); return; }
      var map = window.WS.codex.enemyAffinity(cur(), rec), row = el('div', 'rl-affsum');
      Object.keys(map).forEach(function (k) { row.appendChild(el('span', 'chip rl-aff rl-aff-' + map[k], esc(elemLabel(k)) + ': ' + esc(map[k]))); });
      aff.appendChild(row);
      aff.appendChild(el('p', 'muted rl-note', 'The family default first, then this enemy\'s overrides.'));
    }
    paintAff(); api.onLive(paintAff);
    var g = el('div', 'card rl-summary');
    box.appendChild(g);
    g.appendChild(el('h3', 'section-h', 'Gambit set'));
    if (rec.gambits) {
      var gr = el('div', 'rl-chipbar');
      gr.appendChild(recLink(rec.gambits, nameOf(rec.gambits)));
      if (missingId(rec.gambits)) gr.appendChild(el('span', 'chip chip-broken', 'Broken'));
      g.appendChild(gr);
    } else {
      g.appendChild(el('div', 'muted rl-note', 'No gambit set yet. Create one to script how this enemy chooses its actions.'));
      g.appendChild(button('Create a gambit set for this enemy', 'plus', '', function () {
        var nm = String(rec.name || 'Enemy') + ' gambits';
        var gm = { id: Kit.ids.mint('gmb_', nm), name: nm, charterVersion: cur().charter.version || 0 };
        typeDefaults('Gambit', gm);
        Kit.records.put(gm); rec.gambits = gm.id; Kit.bundle.touch('rules-new'); api.changed(true);
      }));
    }
    var sc = el('div', 'card rl-summary');
    box.appendChild(sc);
    sc.appendChild(el('h3', 'section-h', 'Scale stats'));
    var srow = el('div', 'rl-tools');
    var f = mkInput({ type: 'number', step: 0.05, min: 0.1, max: 10, value: 1.25, label: 'Scale factor' });
    f.style.maxWidth = '120px';
    srow.appendChild(f);
    srow.appendChild(button('Scale all stats', 'chart', '', function () {
      var k = Number(f.value);
      if (!(k > 0)) { Kit.ui.toast('Enter a factor above zero.', 'warn'); return; }
      if (!U.isObj(rec.stats)) rec.stats = {};
      statList(cur()).forEach(function (s) {
        var v = Math.round(num(rec.stats[s.key]) * k);
        rec.stats[s.key] = Math.max(0, Math.min(v, typeof s.max === 'number' ? s.max : 999999));
      });
      api.changed(true);
    }));
    srow.appendChild(el('span', 'muted rl-note', 'Multiplies every stat by the factor and keeps each within its declared maximum.'));
    sc.appendChild(srow);
    var used = Kit.records.list('trp_').filter(function (t) { return (t.members || []).some(function (m) { return m && m.enm === rec.id; }); });
    var ub = el('div', 'card rl-summary');
    box.appendChild(ub);
    ub.appendChild(el('h3', 'section-h', 'Used in troops'));
    if (!used.length) ub.appendChild(el('div', 'empty-line', 'No troop uses this enemy yet.'));
    else { var ch = el('div', 'rl-chipbar'); used.forEach(function (t) { ch.appendChild(recLink(t.id, t.name)); }); ub.appendChild(ch); }
  }

  // ---------------------------------------------------------------- gambits: sortable rule list with a plain language line
  var COND_DEFAULT = { selfHpBelow: '0.35', selfHpAbove: '0.5', allyHpBelow: '0.35', targetHpBelow: '0.3', turnEvery: '3', enemyCountBelow: '2', allyCountBelow: '2', chance: '0.25' };
  var FRACTION_CONDS = { selfHpBelow: 1, selfHpAbove: 1, allyHpBelow: 1, targetHpBelow: 1, chance: 1 };
  var COUNT_CONDS = { turnEvery: 1, enemyCountBelow: 1, allyCountBelow: 1 };
  var STATUS_COND_KINDS = { targetHasStatus: 1, targetLacksStatus: 1 };
  var SEL_TEXT = { self: 'itself', randomFoe: 'a random foe', lowestHpFoe: 'the foe with the lowest HP', highestHpFoe: 'the foe with the highest HP', allFoes: 'all foes', randomAlly: 'a random ally', lowestHpAlly: 'the ally with the lowest HP', allAllies: 'all allies', attacker: 'the attacker' };
  var TRIG_TEXT = { onPhysical: 'it is hit by a physical attack', onMagic: 'it is hit by magic', onDamaged: 'it takes any damage', onAllyKo: 'an ally is knocked out', onLowHp: 'it falls below a quarter of its HP', onStatus: 'it receives a status' };
  function condText(c) {
    c = U.isObj(c) ? c : {};
    var p = c.param, blank = p === '' || p == null || !isFinite(Number(p));
    var pc = blank ? '(set a value)' : Math.round(Number(p) * 100) + ' percent';
    var n = blank ? '(set a number)' : String(Math.round(Number(p)));
    var st = p ? nameOf(p) : '(choose a status)';
    switch (c.kind) {
      case 'always': return 'Always';
      case 'selfHpBelow': return 'If its own HP is below ' + pc;
      case 'selfHpAbove': return 'If its own HP is above ' + pc;
      case 'allyHpBelow': return 'If an ally is below ' + pc + ' HP';
      case 'targetHpBelow': return 'If the target is below ' + pc + ' HP';
      case 'targetHasStatus': return 'If the target has ' + st;
      case 'targetLacksStatus': return 'If the target lacks ' + st;
      case 'turnEvery': return 'Every ' + n + ' turns';
      case 'enemyCountBelow': return 'If fewer than ' + n + ' foes remain';
      case 'allyCountBelow': return 'If fewer than ' + n + ' allies remain';
      case 'chance': return 'With a ' + pc + ' chance';
      default: return 'Choose a condition';
    }
  }
  function describeRule(r) {
    r = U.isObj(r) ? r : {};
    var c = U.isObj(r.condition) ? r.condition : {}, t = U.isObj(r.target) ? r.target : {}, a = U.isObj(r.action) ? r.action : {};
    var act = a.abl ? nameOf(a.abl) : '(choose an ability)', tg = SEL_TEXT[t.selector] || '(choose a target)';
    if (c.kind === 'always') return 'Always use ' + act + ' on ' + tg + '.';
    return condText(c) + ', use ' + act + ' on ' + tg + '.';
  }
  function describeCounter(r) {
    r = U.isObj(r) ? r : {};
    var a = U.isObj(r.action) ? r.action : {};
    return 'When ' + (TRIG_TEXT[r.trigger] || '(choose a trigger)') + ', counter with ' + (a.abl ? nameOf(a.abl) : '(choose an ability)') + '.';
  }
  function gambitBuilder(box, rec, api, typeName) {
    var host = el('div', 'rl-gmb'); host.setAttribute('data-bpath', 'rules');
    box.appendChild(host);
    var issues = issueBox(typeName, rec, ['rules', 'counters']);
    var lines = [], nevers = [];
    function rules() { if (!Array.isArray(rec.rules)) rec.rules = []; return rec.rules; }
    function counters() { if (!Array.isArray(rec.counters)) rec.counters = []; return rec.counters; }
    function paintLines() {
      lines.forEach(function (l) { l.el.textContent = l.text(); });
      var first = -1;
      rules().forEach(function (r, i) { if (first < 0 && r && r.condition && r.condition.kind === 'always') first = i; });
      nevers.forEach(function (n, i) { if (n) n.hidden = !(first >= 0 && i > first); });
    }
    function changed(rebuild) {
      api.changed(false);
      if (rebuild) paint(); else { paintLines(); issues.paint(); }
    }
    function ctrlButtons(list, i, kind, label) {
      var c = el('div', 'rl-ctrls');
      var up = iconButton('up', 'Move ' + label + ' up', function () { if (swapIn(list, i, i - 1)) changed(true); });
      var dn = iconButton('down', 'Move ' + label + ' down', function () { if (swapIn(list, i, i + 1)) changed(true); });
      up.disabled = i === 0; dn.disabled = i === list.length - 1;
      c.appendChild(up); c.appendChild(dn);
      c.appendChild(iconButton('trash', 'Delete ' + label, function () { list.splice(i, 1); changed(true); }, 'btn-danger'));
      return c;
    }
    function ruleRow(r, i) {
      if (!U.isObj(r.condition)) r.condition = { kind: 'always', param: '' };
      if (!U.isObj(r.target)) r.target = { selector: '' };
      if (!U.isObj(r.action)) r.action = { abl: null };
      var list = rules(), row = el('div', 'rl-grow'), head = el('div', 'rl-grow-head');
      var grip = el('span', 'rl-grip'); grip.title = 'Drag to reorder'; grip.setAttribute('aria-hidden', 'true');
      head.appendChild(grip);
      head.appendChild(el('strong', null, 'Rule ' + (i + 1)));
      var never = el('span', 'chip chip-warning', 'Never reached'); never.hidden = true;
      nevers[i] = never; head.appendChild(never);
      head.appendChild(ctrlButtons(list, i, 'rule', 'rule ' + (i + 1)));
      row.appendChild(head);
      var body = el('div', 'rl-grow-body');
      body.appendChild(fieldBox('Condition', mkSelect(vocabOptions('COND_KINDS'), r.condition.kind, { label: 'Condition for rule ' + (i + 1), placeholder: 'Condition...', onChange: function (v) { r.condition.kind = v; r.condition.param = COND_DEFAULT[v] || ''; changed(true); } }), 'lg'));
      var k = r.condition.kind;
      if (FRACTION_CONDS[k]) body.appendChild(fieldBox('Fraction, 0 to 1', mkInput({ type: 'number', step: 0.05, min: 0, max: 1, value: r.condition.param, label: 'Fraction for rule ' + (i + 1), onInput: function (v) { r.condition.param = v; changed(false); } }), 'sm'));
      else if (COUNT_CONDS[k]) body.appendChild(fieldBox('Number', mkInput({ type: 'number', step: 1, min: 1, max: 99, value: r.condition.param, label: 'Number for rule ' + (i + 1), onInput: function (v) { r.condition.param = v; changed(false); } }), 'sm'));
      else if (STATUS_COND_KINDS[k]) body.appendChild(fieldBox('Status', refButton('sta_', 'Choose a status', function () { return r.condition.param || null; }, function (v) { r.condition.param = v || ''; changed(false); }, 'Status for rule ' + (i + 1)), 'lg'));
      body.appendChild(fieldBox('Target', mkSelect(vocabOptions('SELECTORS'), r.target.selector, { label: 'Target for rule ' + (i + 1), placeholder: 'Target...', onChange: function (v) { r.target.selector = v; changed(false); } }), 'lg'));
      body.appendChild(fieldBox('Ability', refButton('abl_', 'Choose the ability', function () { return r.action.abl || null; }, function (v) { r.action.abl = v; changed(false); }, 'Ability for rule ' + (i + 1)), 'lg'));
      var line = el('div', 'rl-gline'); line.setAttribute('aria-live', 'polite');
      lines.push({ el: line, text: function () { return describeRule(r); } });
      body.appendChild(line);
      row.appendChild(body);
      enableDrag(row, grip, 'rule', list, i, function () { changed(true); });
      return row;
    }
    function counterRow(r, i) {
      if (!U.isObj(r.action)) r.action = { abl: null };
      var list = counters(), row = el('div', 'rl-grow'), head = el('div', 'rl-grow-head');
      var grip = el('span', 'rl-grip'); grip.title = 'Drag to reorder'; grip.setAttribute('aria-hidden', 'true');
      head.appendChild(grip);
      head.appendChild(el('strong', null, 'Counter ' + (i + 1)));
      head.appendChild(ctrlButtons(list, i, 'counter', 'counter ' + (i + 1)));
      row.appendChild(head);
      var body = el('div', 'rl-grow-body');
      body.appendChild(fieldBox('Trigger', mkSelect(vocabOptions('TRIGGERS'), r.trigger, { label: 'Trigger for counter ' + (i + 1), placeholder: 'Trigger...', onChange: function (v) { r.trigger = v; changed(false); } }), 'lg'));
      body.appendChild(fieldBox('Ability', refButton('abl_', 'Choose the counter ability', function () { return r.action.abl || null; }, function (v) { r.action.abl = v; changed(false); }, 'Ability for counter ' + (i + 1)), 'lg'));
      var line = el('div', 'rl-gline'); line.setAttribute('aria-live', 'polite');
      lines.push({ el: line, text: function () { return describeCounter(r); } });
      body.appendChild(line);
      row.appendChild(body);
      enableDrag(row, grip, 'counter', list, i, function () { changed(true); });
      return row;
    }
    function paint() {
      U.clear(host); lines = []; nevers = [];
      host.appendChild(el('h3', 'section-h', 'Rules'));
      host.appendChild(el('p', 'muted rl-note', 'Checked from the top. The first rule whose condition holds acts. Use the arrows or drag the handle to reorder.'));
      var rs = rules();
      if (!rs.length) host.appendChild(el('div', 'empty-line', 'No rules yet. Add the first one below.'));
      rs.forEach(function (r, i) { if (U.isObj(r)) host.appendChild(ruleRow(r, i)); });
      host.appendChild(button('Add a rule', 'plus', '', function () { rules().push({ condition: { kind: 'always', param: '' }, target: { selector: 'randomFoe' }, action: { abl: null } }); changed(true); }));
      var ch3 = el('h3', 'section-h', 'Counters'); ch3.setAttribute('data-bpath', 'counters');
      host.appendChild(ch3);
      host.appendChild(el('p', 'muted rl-note', 'Reactions that fire when the trigger happens, outside the normal turn order.'));
      var cs = counters();
      if (!cs.length) host.appendChild(el('div', 'empty-line', 'No counters yet.'));
      cs.forEach(function (r, i) { if (U.isObj(r)) host.appendChild(counterRow(r, i)); });
      host.appendChild(button('Add a counter', 'plus', '', function () { counters().push({ trigger: 'onDamaged', action: { abl: null } }); changed(true); }));
      paintLines(); issues.paint();
      host.appendChild(issues);
    }
    paint();
  }

  // ---------------------------------------------------------------- troops: row layout builder
  function troopYield(t) {
    var y = { gil: 0, exp: 0, ap: 0, count: 0, missing: 0, boss: false };
    (Array.isArray(t.members) ? t.members : []).forEach(function (m) {
      var e = m ? recOf(m.enm) : null;
      if (!e) { y.missing++; return; }
      y.gil += num(e.gil); y.exp += num(e.exp); y.ap += num(e.ap); y.count++;
      if (e.isBoss) y.boss = true;
    });
    return y;
  }
  function troopBuilder(box, rec, api) {
    var host = el('div', 'rl-trp'); host.setAttribute('data-bpath', 'members');
    box.appendChild(host);
    var issues = issueBox('Troop', rec, ['members']);
    function mem() { if (!Array.isArray(rec.members)) rec.members = []; return rec.members; }
    function rowOf(m) { return m && m.row === 'back' ? 'back' : 'front'; }
    function commit() { api.changed(false); paint(); }
    function neighbor(i, d) {
      var list = mem(), row = rowOf(list[i]), j = i + d;
      while (j >= 0 && j < list.length) { if (rowOf(list[j]) === row) return j; j += d; }
      return -1;
    }
    function addTo(row) {
      if (mem().length >= 8) { Kit.ui.toast('A troop holds at most eight enemies.', 'warn'); return; }
      Kit.ui.pickRef({ prefix: 'enm_', title: 'Add an enemy to the ' + row + ' row' }).then(function (id) {
        if (!id) return;
        mem().push({ enm: id, row: row }); commit();
      });
    }
    function card(m, i) {
      var e = recOf(m.enm), c = el('div', 'rl-mcard'), top = el('div', 'rl-mtop');
      if (e) top.appendChild(recLink(m.enm, e.name));
      else { top.appendChild(el('span', 'ref-empty', esc(m.enm || 'No enemy chosen'))); top.appendChild(el('span', 'chip chip-broken', m.enm ? 'Broken' : 'Empty')); }
      c.appendChild(top);
      if (e) {
        var meta = el('div', 'rl-lmeta');
        meta.innerHTML = '<span class="chip chip-muted">Lv ' + esc(e.level == null ? '?' : e.level) + '</span>' + (e.isBoss ? '<span class="chip chip-warning">Boss</span>' : '') + (e.family ? '<span class="chip chip-muted">' + esc(nameOf(e.family)) + '</span>' : '');
        c.appendChild(meta);
      }
      var ctl = el('div', 'rl-mctl');
      var other = rowOf(m) === 'front' ? 'back' : 'front';
      ctl.appendChild(button('To ' + other + ' row', 'jump', 'btn-ghost', function () { m.row = other; commit(); }));
      ctl.appendChild(iconButton('edit', 'Change enemy', function () {
        Kit.ui.pickRef({ prefix: 'enm_', title: 'Choose an enemy', current: m.enm }).then(function (id) { if (id) { m.enm = id; commit(); } });
      }));
      var up = iconButton('up', 'Move up in the row', function () { var j = neighbor(i, -1); if (j >= 0 && swapIn(mem(), i, j)) commit(); });
      var dn = iconButton('down', 'Move down in the row', function () { var j = neighbor(i, 1); if (j >= 0 && swapIn(mem(), i, j)) commit(); });
      up.disabled = neighbor(i, -1) < 0; dn.disabled = neighbor(i, 1) < 0;
      ctl.appendChild(up); ctl.appendChild(dn);
      ctl.appendChild(iconButton('trash', 'Remove from the troop', function () { mem().splice(i, 1); commit(); }, 'btn-danger'));
      c.appendChild(ctl);
      return c;
    }
    function lane(row, title) {
      var l = el('div', 'rl-lane'), h = el('div', 'rl-lane-h');
      var n = mem().filter(function (m) { return rowOf(m) === row; }).length;
      h.innerHTML = '<span>' + esc(title) + '</span><span class="rl-count">' + n + '</span>';
      l.appendChild(h);
      if (!n) l.appendChild(el('div', 'empty-line', 'Empty.'));
      mem().forEach(function (m, i) { if (U.isObj(m) && rowOf(m) === row) l.appendChild(card(m, i)); });
      var add = button('Add to ' + row + ' row', 'plus', '', function () { addTo(row); });
      add.disabled = mem().length >= 8;
      l.appendChild(add);
      return l;
    }
    function paint() {
      U.clear(host);
      host.appendChild(el('h3', 'section-h', 'Row layout'));
      host.appendChild(el('p', 'muted rl-note', 'The front row stands nearest the party. Add up to eight enemies, and move them between rows.'));
      var lanes = el('div', 'rl-lanes');
      lanes.appendChild(lane('back', 'Back row'));
      lanes.appendChild(lane('front', 'Front row'));
      host.appendChild(lanes);
      var y = troopYield(rec);
      host.appendChild(el('div', 'card rl-summary', '<div class="rl-sumline">' + y.count + ' enem' + (y.count === 1 ? 'y' : 'ies') + '. Rewards: ' + y.gil + ' gil, ' + y.exp + ' EXP, ' + y.ap + ' AP.' + (y.boss ? ' Includes a boss.' : '') + (y.missing ? ' ' + y.missing + ' member' + (y.missing === 1 ? '' : 's') + ' need attention.' : '') + '</div>'));
      issues.paint();
      host.appendChild(issues);
    }
    paint();
  }

  // ---------------------------------------------------------------- shops: price sheet
  function shopEffective(entry) {
    if (!U.isObj(entry)) return null;
    var it = recOf(entry.item), base = it && typeof it.price === 'number' ? it.price : 0;
    var ov = entry.priceOverride;
    return typeof ov === 'number' && isFinite(ov) ? ov : base;
  }
  function shopExtras(box, rec, api) {
    var card = el('div', 'card rl-summary');
    box.appendChild(card);
    function paint() {
      U.clear(card);
      card.appendChild(el('h3', 'section-h', 'Price sheet'));
      var inv = Array.isArray(rec.inventory) ? rec.inventory.filter(U.isObj) : [];
      if (!inv.length) card.appendChild(el('div', 'empty-line', 'Nothing in stock yet. Add stock in the Inventory field above.'));
      else {
        var t = el('table', 'tbl'), total = 0;
        var rows = inv.map(function (s) {
          var it = recOf(s.item), eff = shopEffective(s);
          total += num(eff);
          var flag = !it ? ' <span class="chip chip-broken">Missing</span>' : it.kind === 'key' ? ' <span class="chip chip-warning">Key item</span>' : num(eff) === 0 ? ' <span class="chip chip-warning">Free</span>' : '';
          return '<tr><th scope="row">' + esc(it ? it.name : (s.item || '?')) + flag + '</th><td class="num">' + (it && typeof it.price === 'number' ? it.price : 0) + '</td><td class="num">' + (typeof s.priceOverride === 'number' ? s.priceOverride : '') + '</td><td class="num"><strong>' + num(eff) + '</strong></td></tr>';
        }).join('');
        t.innerHTML = '<thead><tr><th scope="col">Stock</th><th scope="col" class="num">Base</th><th scope="col" class="num">Override</th><th scope="col" class="num">Pays</th></tr></thead><tbody>' + rows + '</tbody>';
        var w = el('div', 'tbl-wrap'); w.appendChild(t); card.appendChild(w);
        card.appendChild(el('div', 'muted rl-note', inv.length + ' line' + (inv.length === 1 ? '' : 's') + ', ' + total + ' gil for one of each.'));
      }
      var ch = rec.chapterAvailable ? recOf(rec.chapterAvailable) : null;
      card.appendChild(el('div', 'muted rl-note', ch ? 'Opens in ' + ch.name + '.' : 'Open from the start, since no chapter is set.'));
    }
    paint(); api.onLive(paint);
  }


  // ---------------------------------------------------------------- Expected Party State table and Fill from curves
  function chaptersOf(b) {
    var s = b.charter && b.charter.sections;
    return s && Array.isArray(s.chapters) ? s.chapters.filter(function (c) { return U.isObj(c) && c.id; }) : [];
  }
  function epsOfChapter(id) {
    var l = Kit.records.list('eps_');
    for (var i = 0; i < l.length; i++) { if (l[i].chapter === id) return l[i]; }
    return null;
  }
  function newEps(ch) {
    var name = (ch.name || 'Chapter') + ' state';
    var rec = { id: Kit.ids.mint('eps_', name), name: name, charterVersion: cur().charter.version || 0 };
    typeDefaults('ExpectedPartyState', rec);
    rec.chapter = ch.id;
    Kit.records.put(rec);
    return rec;
  }
  // Total EXP for the final level is spread across the chapters by target minutes. Each chapter gets the highest level
  // whose exp.curve requirement fits inside the EXP the party is expected to have earned by the end of that chapter.
  function planCurves(opts) {
    opts = opts || {};
    var b = cur(), chs = chaptersOf(b);
    if (!chs.length) throw new Error('The Charter has no chapters yet.');
    var finalLevel = clampInt(opts.finalLevel != null && opts.finalLevel !== '' ? opts.finalLevel : uiGet().finalLevel, 2, 99, 50);
    var total = 0;
    chs.forEach(function (c) { total += Math.max(0, num(c.targetMinutes)); });
    if (!(total > 0)) throw new Error('Give the chapters target minutes in the Charter first.');
    function need(L) { return WSX.evalRole('exp', { a: { level: L }, t: {}, power: 0 }); }
    var expFinal = need(finalLevel), acc = 0, rows = [];
    chs.forEach(function (c) {
      acc += Math.max(0, num(c.targetMinutes));
      var target = expFinal * acc / total, lvl = 1;
      for (var L = 1; L <= 99; L++) { if (need(L) <= target) lvl = L; else break; }
      rows.push({ chapter: c.id, name: c.name, level: Math.min(lvl, finalLevel), minutes: num(c.targetMinutes), exp: Math.round(target) });
    });
    return { finalLevel: finalLevel, expFinal: expFinal, totalMinutes: total, rows: rows };
  }
  function applyCurves(plan) {
    var created = 0, changedN = 0, chs = chaptersOf(cur());
    plan.rows.forEach(function (r) {
      var ch = chs.filter(function (c) { return c.id === r.chapter; })[0];
      if (!ch) return;
      var eps = epsOfChapter(r.chapter);
      if (!eps) { eps = newEps(ch); created++; }
      if (eps.targetLevel !== r.level) { eps.targetLevel = r.level; changedN++; }
    });
    Kit.index.invalidate(); Kit.bundle.touch('rules-curves');
    return { created: created, changed: changedN };
  }
  function epsView(main) {
    var b = cur(), chs = chaptersOf(b);
    main.appendChild(el('h2', 'rl-h2', 'Expected Party State'));
    main.appendChild(el('p', 'muted rl-lead', 'One row per chapter: where the party should stand on arrival. The Simulator fights every troop against these rows.'));
    if (!chs.length) main.appendChild(el('div', 'empty-line', 'The Charter has no chapters yet, so there is nothing to plan. Add chapters in the Charter first.'));
    else {
      var pace = el('div', 'rl-block rl-pacing');
      var fl = mkInput({ type: 'number', step: 1, min: 2, max: 99, value: clampInt(uiGet().finalLevel, 2, 99, 50), label: 'Level at the last chapter', onInput: function (v) { uiSet({ finalLevel: clampInt(v, 2, 99, 50) }); } });
      var bar = el('div', 'rl-tools');
      bar.appendChild(fieldBox('Level at the last chapter', fl, 'md'));
      var fill = button('Fill from curves', 'chart', 'btn-primary', function () {
        var plan;
        try { plan = planCurves({ finalLevel: fl.value }); } catch (e) { Kit.ui.toast(e.message, 'warn'); return; }
        uiSet({ finalLevel: plan.finalLevel });
        var clash = plan.rows.filter(function (r) { var e = epsOfChapter(r.chapter); return e && num(e.targetLevel) > 1 && e.targetLevel !== r.level; }).length;
        var go = clash ? Kit.ui.confirm({ title: 'Replace ' + clash + ' target level' + (clash === 1 ? '' : 's') + '?', message: 'Fill from curves overwrites the target level on rows that already have one.', okLabel: 'Replace' }) : Promise.resolve(true);
        go.then(function (ok) {
          if (!ok) return;
          var r = applyCurves(plan);
          Kit.ui.toast('Filled ' + plan.rows.length + ' chapters (' + r.created + ' new rows).', 'ok');
          repaint(true);
        });
      });
      bar.appendChild(fill);
      bar.appendChild(button('Create missing rows', 'plus', 'btn-ghost', function () {
        var n = 0;
        chs.forEach(function (c) { if (!epsOfChapter(c.id)) { newEps(c); n++; } });
        Kit.bundle.touch('rules-new'); Kit.ui.toast(n ? 'Created ' + n + ' row' + (n === 1 ? '' : 's') + '.' : 'Every chapter already has a row.', n ? 'ok' : undefined); repaint(true);
      }));
      pace.appendChild(bar);
      pace.appendChild(el('p', 'muted rl-note', 'Fill from curves uses the EXP curve (exp.curve). The EXP for the last chapter level is spread over the chapters by their target minutes, and each chapter gets the highest level that EXP reaches.'));
      main.appendChild(pace);
      var grid = el('div', 'rl-egrid');
      grid.appendChild(el('div', 'rl-ehead', '<span>Chapter</span><span>Target level</span><span>Gear tier</span><span>Gil on hand</span><span>Target win rate</span><span></span>'));
      chs.forEach(function (c) {
        var eps = epsOfChapter(c.id), row = el('div', 'rl-erow');
        var cap = el('div', 'rl-echap');
        cap.innerHTML = '<strong>' + esc(c.name) + '</strong><span class="muted">' + esc(c.continentLabel || '') + '</span><span class="chip chip-muted">' + num(c.targetMinutes) + ' min</span>';
        row.appendChild(cap);
        if (!eps) {
          row.appendChild(el('span', 'muted rl-note rl-noeps', 'No row yet.'));
          row.appendChild(button('Create row', 'plus', '', function () { newEps(c); Kit.bundle.touch('rules-new'); repaint(true); }));
          grid.appendChild(row);
          return;
        }
        function numField(label, key, o) {
          var inp = mkInput({ type: 'number', step: o.step, min: o.min, max: o.max, value: eps[key] == null ? '' : eps[key], label: label + ' for ' + c.name, onInput: function (v) {
            if (v === '') delete eps[key]; else eps[key] = o.int ? Math.round(Number(v)) : Number(v);
            Kit.index.invalidate(); Kit.bundle.touch('rules-edit');
          } });
          inp.dataset.eps = eps.id; inp.dataset.key = key;
          return fieldBox(label, inp, 'sm');
        }
        row.appendChild(numField('Target level', 'targetLevel', { int: true, step: 1, min: 1, max: 99 }));
        row.appendChild(numField('Gear tier', 'gearTier', { int: true, step: 1, min: 1, max: 20 }));
        row.appendChild(numField('Gil on hand', 'gil', { int: true, step: 1, min: 0, max: 9999999 }));
        row.appendChild(numField('Target win rate', 'targetWinRate', { step: 1, min: 0, max: 100 }));
        row.appendChild(button('Details', 'edit', 'btn-ghost', function () { state.editing = eps.id; repaint(); }));
        grid.appendChild(row);
      });
      main.appendChild(grid);
    }
    var rb = el('div', 'rl-block');
    rb.appendChild(el('h3', 'section-h', 'Records'));
    var host = el('div');
    rb.appendChild(host); main.appendChild(rb);
    listView(host, 'ExpectedPartyState');
  }

  // ---------------------------------------------------------------- economy panel
  function stockedPrice(eqpId, ci, shops, idxOf) {
    var best = null;
    shops.forEach(function (s) {
      var open = s.chapterAvailable ? (idxOf[s.chapterAvailable] != null ? idxOf[s.chapterAvailable] : Infinity) : 0;
      if (open > ci) return;
      (Array.isArray(s.inventory) ? s.inventory : []).forEach(function (e) {
        if (!U.isObj(e) || e.item !== eqpId) return;
        var p = shopEffective(e);
        if (p != null && (best == null || p < best)) best = p;
      });
    });
    return best;
  }
  // The cheapest kit at a gear tier: one weapon, one armor, one accessory. A piece that no open shop sells yet is priced at its base price.
  function gearCost(tier, ci, shops, eqps, idxOf) {
    var cost = 0, parts = [], anyGear = false, unstocked = false;
    ['weapon', 'armor', 'accessory'].forEach(function (slot) {
      var cands = eqps.filter(function (e) { return e.slot === slot && Number(e.tier) === Number(tier); });
      if (!cands.length) return;
      anyGear = true;
      var best = null, bestStocked = null;
      cands.forEach(function (e) {
        var p = stockedPrice(e.id, ci, shops, idxOf), base = num(e.price);
        if (p != null && (bestStocked == null || p < bestStocked.price)) bestStocked = { id: e.id, price: p };
        if (best == null || base < best.price) best = { id: e.id, price: base };
      });
      if (bestStocked) { cost += bestStocked.price; parts.push({ slot: slot, id: bestStocked.id, price: bestStocked.price, stocked: true }); }
      else { cost += best.price; unstocked = true; parts.push({ slot: slot, id: best.id, price: best.price, stocked: false }); }
    });
    return { cost: cost, parts: parts, anyGear: anyGear, unstocked: unstocked };
  }
  function economyModel(b) {
    b = b || cur();
    var bpm = Number(uiGet().battlesPerMin);
    if (!isFinite(bpm) || bpm <= 0) bpm = 1;
    var chs = chaptersOf(b), shops = Kit.records.list('shp_'), eqps = Kit.records.list('eqp_'), troops = Kit.records.list('trp_');
    var idxOf = {}, cumGil = 0, cumAp = 0, rows = [], materia = rsOf(b).progression === 'materia';
    chs.forEach(function (c, i) { idxOf[c.id] = i; });
    chs.forEach(function (c, ci) {
      var ts = troops.filter(function (t) { return t.chapter === c.id; }), ys = ts.map(troopYield);
      var avgGil = 0, avgAp = 0;
      ys.forEach(function (y) { avgGil += y.gil; avgAp += y.ap; });
      if (ys.length) { avgGil /= ys.length; avgAp /= ys.length; }
      var minutes = Math.max(0, num(c.targetMinutes)), battles = Math.round(minutes * bpm);
      var gilIn = Math.round(avgGil * battles), apIn = Math.round(avgAp * battles);
      cumGil += gilIn; cumAp += apIn;
      var eps = epsOfChapter(c.id), tier = eps && eps.gearTier ? eps.gearTier : null;
      var gear = tier ? gearCost(tier, ci, shops, eqps, idxOf) : null;
      var flags = [];
      if (!ts.length) flags.push({ key: 'notroops', level: 'warning', text: 'No troops are tagged to this chapter, so it earns nothing.' });
      if (!eps) flags.push({ key: 'noeps', level: 'warning', text: 'No Expected Party State row, so no gear tier target.' });
      else if (!tier) flags.push({ key: 'notier', level: 'warning', text: 'The Expected Party State row has no gear tier.' });
      if (gear) {
        if (!gear.anyGear) flags.push({ key: 'nogear', level: 'warning', text: 'No equipment is defined at gear tier ' + tier + '.' });
        else {
          if (gear.cost > cumGil) flags.push({ key: 'unaffordable', level: 'error', text: 'Gear tier ' + tier + ' costs about ' + gear.cost + ' gil, but the party has earned about ' + cumGil + ' by now.' });
          if (gear.unstocked) flags.push({ key: 'unstocked', level: 'warning', text: 'No shop open by this chapter sells every piece of tier ' + tier + ' gear.' });
        }
      }
      var apNeed = null;
      if (materia && eps && Array.isArray(eps.materiaSet)) {
        apNeed = 0;
        eps.materiaSet.forEach(function (id) {
          var m = recOf(id), th = m && Array.isArray(m.apThresholds) ? m.apThresholds : [];
          if (th.length) apNeed += num(th[th.length - 1]);
        });
        if (apNeed > cumAp) flags.push({ key: 'apshort', level: 'warning', text: 'The materia set needs about ' + apNeed + ' AP to master, and the party has earned about ' + cumAp + '.' });
      }
      rows.push({ id: c.id, name: c.name, minutes: minutes, troops: ts.length, avgGil: avgGil, avgAp: avgAp, battles: battles, gilIn: gilIn, apIn: apIn, cumGil: cumGil, cumAp: cumAp, tier: tier, gear: gear, apNeed: apNeed, flags: flags });
    });
    var priceLists = shops.map(function (s) {
      var inv = (Array.isArray(s.inventory) ? s.inventory : []).filter(U.isObj), prices = inv.map(shopEffective).filter(function (p) { return p != null; });
      var open = s.chapterAvailable ? (idxOf[s.chapterAvailable] != null ? chs[idxOf[s.chapterAvailable]].name : 'unknown chapter') : 'the start';
      return { id: s.id, name: s.name, open: open, lines: inv.length, cheapest: prices.length ? Math.min.apply(null, prices) : null, priciest: prices.length ? Math.max.apply(null, prices) : null };
    });
    var unaffordable = rows.filter(function (r) { return r.flags.some(function (f) { return f.key === 'unaffordable'; }); }).map(function (r) { return r.id; });
    return { battlesPerMin: bpm, rows: rows, shops: priceLists, unaffordable: unaffordable, totalGil: cumGil, totalAp: cumAp };
  }
  function economyView(main) {
    var b = cur(), m = economyModel(b);
    main.appendChild(el('h2', 'rl-h2', 'Economy'));
    main.appendChild(el('p', 'muted rl-lead', 'A planning estimate, not a simulation. Income is the average gil and AP of the troops tagged to each chapter, times the number of battles the target minutes allow. It is compared with the price of the gear tier the Expected Party State expects.'));
    var pace = el('div', 'rl-tools');
    var bp = mkInput({ type: 'number', step: 0.1, min: 0.1, max: 10, value: m.battlesPerMin, label: 'Battles per minute' });
    bp.addEventListener('change', function () { var v = Number(bp.value); uiSet({ battlesPerMin: isFinite(v) && v > 0 ? v : 1 }); repaint(true); });
    pace.appendChild(fieldBox('Battles per minute', bp, 'md'));
    var sum = el('div', 'rl-chipbar');
    sum.innerHTML = '<span class="chip chip-muted">' + m.rows.length + ' chapters</span><span class="chip chip-muted">' + m.totalGil + ' gil in total</span><span class="chip chip-muted">' + m.totalAp + ' AP in total</span><span class="chip ' + (m.unaffordable.length ? 'chip-error' : 'chip-ok') + '">' + m.unaffordable.length + ' unaffordable</span>';
    pace.appendChild(sum);
    main.appendChild(pace);
    if (!m.rows.length) { main.appendChild(el('div', 'empty-line', 'The Charter has no chapters yet. Add chapters in the Charter, then tag troops to them.')); return; }
    var chartWrap = el('div', 'rl-block');
    chartWrap.appendChild(el('h3', 'section-h', 'Gil earned against gear cost'));
    var cw = el('div', 'rl-chart'), canvas = el('canvas');
    canvas.setAttribute('role', 'img');
    canvas.setAttribute('aria-label', 'Cumulative gil earned by chapter compared with the cost of the target gear tier. The cards below give every number.');
    cw.appendChild(canvas); chartWrap.appendChild(cw);
    main.appendChild(chartWrap);
    var chart = null, dead = false;
    prevCtl = { destroy: function () { dead = true; if (chart) { chart.destroy(); chart = null; } } };
    whenChart(function (C) {
      if (dead || !alive(cw)) return;
      if (!C) { chartWrap.hidden = true; return; }
      var cs = getComputedStyle(document.documentElement);
      var accent = (cs.getPropertyValue('--accent') || '#d4a24c').trim() || '#d4a24c';
      var warn = (cs.getPropertyValue('--warn') || '#eaa84a').trim() || '#eaa84a';
      var grid = (cs.getPropertyValue('--line') || 'rgba(128,128,128,.25)').trim() || 'rgba(128,128,128,.25)';
      var txt = (cs.getPropertyValue('--muted') || '#999').trim() || '#999';
      chart = new C(canvas.getContext('2d'), {
        type: 'line',
        data: { labels: m.rows.map(function (r) { return r.name; }), datasets: [
          { label: 'Cumulative gil earned', data: m.rows.map(function (r) { return r.cumGil; }), borderColor: accent, backgroundColor: accent, borderWidth: 2, pointRadius: 3, tension: 0.1 },
          { label: 'Target gear cost', data: m.rows.map(function (r) { return r.gear && r.gear.anyGear ? r.gear.cost : null; }), borderColor: warn, backgroundColor: warn, borderWidth: 2, borderDash: [6, 4], pointRadius: 3, tension: 0.1, spanGaps: true }
        ] },
        options: { responsive: true, maintainAspectRatio: false, animation: false, interaction: { mode: 'index', intersect: false },
          plugins: { legend: { labels: { color: txt } } },
          scales: { x: { ticks: { color: txt, maxRotation: 45, autoSkip: true }, grid: { color: grid } }, y: { title: { display: true, text: 'Gil', color: txt }, ticks: { color: txt }, grid: { color: grid }, beginAtZero: true } } }
      });
      canvas.dataset.points = String(m.rows.length);
    });
    var cards = el('div', 'rl-econ');
    m.rows.forEach(function (r) {
      var c = el('div', 'card rl-ecard' + (r.flags.some(function (f) { return f.level === 'error'; }) ? ' bad' : ''));
      var head = el('div', 'rl-ecard-h');
      head.innerHTML = '<strong>' + esc(r.name) + '</strong>' + (r.tier ? '<span class="chip chip-muted">Gear tier ' + r.tier + '</span>' : '');
      c.appendChild(head);
      var kv = el('div', 'rl-kv');
      function item(k, v) { kv.appendChild(el('div', null, '<span>' + esc(k) + '</span><strong>' + esc(v) + '</strong>')); }
      item('Minutes', r.minutes); item('Troops tagged', r.troops);
      item('Avg gil per battle', Math.round(r.avgGil)); item('Battles', r.battles);
      item('Gil earned', r.gilIn); item('Cumulative gil', r.cumGil);
      item('AP earned', r.apIn); item('Cumulative AP', r.cumAp);
      item('Target gear cost', r.gear && r.gear.anyGear ? r.gear.cost : 'None');
      item('AP to master set', r.apNeed == null ? 'None' : r.apNeed);
      c.appendChild(kv);
      if (r.flags.length) {
        var fl = el('div', 'rl-flags');
        r.flags.forEach(function (f) { fl.appendChild(el('div', 'msg msg-' + (f.level === 'error' ? 'error' : 'warning'), esc(f.text))); });
        c.appendChild(fl);
      }
      cards.appendChild(c);
    });
    main.appendChild(cards);
    var sh = el('div', 'rl-block');
    sh.appendChild(el('h3', 'section-h', 'Shop price lists'));
    if (!m.shops.length) {
      sh.appendChild(el('div', 'empty-line', 'No shops yet. Create shops in the Shops list.'));
      var goS = el('button', 'btn btn-primary', 'Create a shop'); goS.type = 'button';
      goS.addEventListener('click', function () { WSX.open('type:Shop'); });
      sh.appendChild(goS);
    }
    else {
      var list = el('div', 'rl-reclist');
      m.shops.forEach(function (s) {
        var row = el('div', 'rl-rec'), btn = el('button', 'rl-rec-main'); btn.type = 'button';
        btn.innerHTML = '<strong>' + esc(s.name) + '</strong><span class="muted">Opens at ' + esc(s.open) + '. ' + s.lines + ' line' + (s.lines === 1 ? '' : 's') + (s.cheapest == null ? '' : ', ' + s.cheapest + ' to ' + s.priciest + ' gil') + '.</span>';
        btn.addEventListener('click', function () { openRecord(s.id); });
        row.appendChild(btn); list.appendChild(row);
      });
      sh.appendChild(list);
    }
    main.appendChild(sh);
  }

  // ---------------------------------------------------------------- characters: draft from the Charter party
  function seedPrompt(seeds, dir) {
    var n = seeds.length;
    return 'Draft ' + n + ' playable character' + (n > 1 ? 's' : '') + ', one for each of these Charter party entries' + (n > 1 ? ', in this order' : '') + '. Use each name exactly as written and let the character honor the past. ' +
      seeds.map(function (m, k) { return (k + 1) + '. ' + m.name + ': ' + (m.past || 'no past written yet') + '.'; }).join(' ') +
      ' Give each a distinct weapon class and stat leanings, base stats near the low end of each declared stat range for level 1, and small growth values.' + (dir ? ' Direction: ' + dir : '');
  }
  function characterDraftDialog(mode, preselect) {
    var members = partyMembers(cur());
    if (!members.length) return Promise.resolve({ generic: true });
    return new Promise(function (resolve) {
      var inputs = [], dir;
      Kit.ui.dialog({
        title: mode === 'set' ? 'Draft characters from the Charter party' : 'Draft a character from the Charter party',
        body: function (body) {
          body.appendChild(el('p', 'muted', 'Each draft is seeded by a party entry and keeps its name and past.'));
          var list = el('div', 'rl-seedlist'), firstFree = -1;
          members.forEach(function (m, i) { if (firstFree < 0 && !chrByName(m.name)) firstFree = i; });
          members.forEach(function (m, i) {
            var has = chrByName(m.name), lab = el('label', 'rl-seed');
            var inp = el('input'); inp.type = mode === 'set' ? 'checkbox' : 'radio'; inp.name = 'rl_seed'; inp.value = String(i);
            inp.checked = preselect != null ? preselect === i : (mode === 'set' ? !has : (firstFree >= 0 ? i === firstFree : i === 0));
            inputs.push(inp);
            lab.appendChild(inp);
            var txt = el('span', 'rl-seed-t');
            txt.innerHTML = '<strong>' + esc(m.name) + '</strong>' + (has ? ' <span class="chip chip-ok">Has a record</span>' : ' <span class="chip chip-muted">No record yet</span>') + '<span class="muted rl-note">' + esc(m.past || '') + '</span>';
            lab.appendChild(txt);
            list.appendChild(lab);
          });
          body.appendChild(list);
          var f = el('div', 'field'); f.appendChild(el('label', 'field-label', 'Direction'));
          dir = el('textarea', 'inp'); dir.rows = 2; dir.id = 'rl_cdir'; dir.placeholder = 'Optional. For example: keep the party balanced between melee and magic.';
          f.firstChild.htmlFor = 'rl_cdir'; f.appendChild(dir); body.appendChild(f);
        },
        actions: [{ label: 'Cancel', kind: 'ghost', value: null }, { label: mode === 'set' ? 'Draft the set' : 'Draft', kind: 'primary', value: 'go' }],
        onResult: function (v) {
          if (v !== 'go') { resolve(null); return; }
          var seeds = [];
          inputs.forEach(function (inp, i) { if (inp.checked) seeds.push(members[i]); });
          if (!seeds.length) { Kit.ui.toast('Choose at least one party entry.', 'warn'); resolve(null); return; }
          seeds = seeds.slice(0, 12);
          resolve({ count: seeds.length, prompt: seedPrompt(seeds, dir.value.trim()) });
        }
      });
    });
  }
  function characterListExtras(main) {
    var members = partyMembers(cur());
    var box = el('div', 'rl-block');
    box.appendChild(el('h3', 'section-h', 'Charter party'));
    if (!members.length) { box.appendChild(el('div', 'empty-line', 'The Charter party has no members yet. Add them in the Charter, and each one can seed a character here.')); main.appendChild(box); return; }
    var list = el('div', 'rl-reclist');
    members.forEach(function (m, i) {
      var has = chrByName(m.name), row = el('div', 'rl-rec rl-seedrow');
      var info = el('div', 'rl-rec-main rl-seedinfo');
      info.innerHTML = '<strong>' + esc(m.name) + '</strong>' + (has ? '<span class="chip chip-ok">Has a record</span>' : '<span class="chip chip-muted">No record yet</span>') + '<span class="muted rl-note rl-seedpast">' + esc(m.past || '') + '</span>';
      row.appendChild(info);
      var acts = el('div', 'rl-seedacts');
      if (has) acts.appendChild(recLink(has.id, 'Open'));
      else acts.appendChild(button('Create blank', 'plus', 'btn-ghost', function () {
        var rec = newRecord('Character', String(m.name).trim());
        state.view = 'type:Character'; state.editing = rec.id; repaint();
      }));
      acts.appendChild(Kit.ai.button('Draft', function () { return runDraft('Character', 'one', i).then(function () { repaint(); }); }, { busyLabel: 'Drafting...' }));
      row.appendChild(acts);
      list.appendChild(row);
    });
    box.appendChild(list);
    main.appendChild(box);
  }
  WSX.content = {
    slotLayoutOf: slotLayoutOf, describeRule: describeRule, describeCounter: describeCounter, generateTiers: generateTiers,
    planCurves: planCurves, applyCurves: applyCurves, economy: economyModel, troopYield: troopYield, shiftHex: shiftHex,
    ablSummary: ablSummary, chaptersOf: chaptersOf, epsOfChapter: epsOfChapter, partyMembers: partyMembers, seedPrompt: seedPrompt, shopEffective: shopEffective
  };

  function editorView(main, typeName, rec) {
    var t = typeByName(typeName), b = cur();
    var stale = staleMap(b)[rec.id];
    var head = el('div', 'rl-edhead');
    head.appendChild(button('Back', 'up', 'btn-ghost rl-back', function () { state.editing = null; if (typeName === 'Formula') state.view = 'sys:formulas'; repaint(); }));
    var title = el('div', 'rl-edtitle', '<strong>' + esc(rec.name || rec.id) + '</strong><code class="id">' + esc(rec.id) + '</code>');
    head.appendChild(title);
    var acts = el('div', 'rl-edacts');
    if (stale) {
      head.appendChild(el('span', 'chip chip-warning', 'Needs review for Charter v' + stale.need));
      acts.appendChild(button('Mark reviewed', 'check', '', function () { markReviewed(rec); repaint(); }));
    }
    acts.appendChild(button('Duplicate', 'slots', 'btn-ghost', function () { var c = dupRecord(rec, typeName); state.editing = c.id; repaint(); Kit.ui.toast('Duplicated as ' + c.name + '.', 'ok'); }));
    acts.appendChild(button('Delete', 'trash', 'btn-ghost btn-danger', function () { deleteRecord(rec, typeName).then(function (ok) { if (ok) { state.editing = null; repaint(); } }); }));
    head.appendChild(acts);
    main.appendChild(head);
    var formHost = el('div', 'rl-form'), extras = el('div', 'rl-extras');
    main.appendChild(formHost); main.appendChild(extras);
    var live = [];
    var api = {
      onLive: function (fn) { live.push(fn); },
      changed: function (rebuild) {
        Kit.index.invalidate(); Kit.bundle.touch('rules-edit');
        if (rebuild) { repaint(true); return; }
        live.forEach(function (fn) { fn(); });
      }
    };
    kform = Kit.form.render(formHost, typeName, rec, function () { api.changed(false); }, {});
    // Fields that a visual builder below the form owns are hidden here, so nothing is edited in two places.
    ((TYPE_CFG[typeName] || {}).hide || []).forEach(function (p) {
      var w = formHost.querySelector('.field[data-path="' + p + '"]');
      if (w) { w.style.display = 'none'; w.setAttribute('data-hidden', 'builder'); }
    });
    var cfg = TYPE_CFG[typeName];
    if (cfg && cfg.extras) cfg.extras(extras, rec, api);
    void t;
  }

  function matches(rec, q) {
    if (!q) return true;
    q = q.toLowerCase();
    return String(rec.name || '').toLowerCase().indexOf(q) >= 0 || String(rec.id || '').indexOf(q) >= 0 || String(rec.notes || '').toLowerCase().indexOf(q) >= 0;
  }
  function draftDialog(typeName, mode) {
    var t = typeByName(typeName), label = t.label || typeName;
    var cfg = TYPE_CFG[typeName] || {};
    return new Promise(function (resolve) {
      var count, dir;
      Kit.ui.dialog({
        title: mode === 'set' ? 'Draft a set of ' + label + ' records' : 'Draft a ' + label + ' with Claude',
        body: function (body) {
          if (mode === 'set') {
            var f1 = el('div', 'field'); f1.appendChild(el('label', 'field-label', 'How many'));
            count = el('input', 'inp'); count.type = 'number'; count.min = 2; count.max = 8; count.value = 4; count.inputMode = 'numeric'; count.id = 'rl_dcount';
            f1.firstChild.htmlFor = 'rl_dcount'; f1.appendChild(count); body.appendChild(f1);
          }
          var f2 = el('div', 'field'); f2.appendChild(el('label', 'field-label', mode === 'set' ? 'Direction for the set' : 'What should it be?'));
          dir = el('textarea', 'inp'); dir.rows = 3; dir.id = 'rl_ddir'; dir.placeholder = 'Optional. For example: things found in the frozen north.';
          f2.firstChild.htmlFor = 'rl_ddir'; f2.appendChild(dir); body.appendChild(f2);
        },
        actions: [{ label: 'Cancel', kind: 'ghost', value: null }, { label: mode === 'set' ? 'Draft the set' : 'Draft', kind: 'primary', value: 'go' }],
        onResult: function (v) {
          if (v !== 'go') { resolve(null); return; }
          var n = mode === 'set' ? Math.max(2, Math.min(8, Math.round(Number(count.value)) || 4)) : 1;
          var d = dir.value.trim();
          var base = typeof cfg.draftPrompt === 'function' ? cfg.draftPrompt(cur()) : cfg.draftPrompt;
          var p = (base || ('Draft ' + n + ' ' + label + ' record' + (n > 1 ? 's' : '') + ' that fit the Charter.')) + (n > 1 ? ' Draft ' + n + ' records that work well together and do not repeat each other.' : '') + (d ? ' Direction: ' + d : '');
          resolve({ count: n, prompt: p });
        }
      });
    });
  }
  function runDraft(typeName, mode, seed) {
    function go(o) {
      if (!o) return null;
      return Kit.ai.draftRecords(typeName, {
        count: o.count, prompt: o.prompt, tier: 'sonnet',
        onAccept: function (rec) { Kit.records.put(rec); Kit.index.invalidate(); if (o.count === 1) { state.view = 'type:' + typeName; state.editing = rec.id; } }
      });
    }
    // Characters are seeded from the Charter party entries. With no party entries the plain dialog is used.
    var first = typeName === 'Character' ? characterDraftDialog(mode, seed) : draftDialog(typeName, mode);
    return first.then(function (o) { return o && o.generic ? draftDialog(typeName, mode).then(go) : go(o); });
  }

  function listView(main, typeName) {
    var t = typeByName(typeName), b = cur();
    var label = t.label || typeName;
    var all = Kit.records.list(t.prefix).slice().sort(function (x, y) { return String(x.name || '').localeCompare(String(y.name || '')); });
    var stale = staleMap(b);
    var bar = el('div', 'rl-toolbar');
    var s = el('input', 'inp rl-search'); s.type = 'search'; s.placeholder = 'Search ' + label.toLowerCase() + ' records'; s.setAttribute('aria-label', 'Search ' + label + ' records');
    s.value = state.search[typeName] || '';
    bar.appendChild(s);
    bar.appendChild(button('New', 'plus', 'btn-primary', function () {
      askName('New ' + label, '').then(function (n) {
        if (n == null) return;
        var rec = newRecord(typeName, n.trim());
        state.view = 'type:' + typeName; state.editing = rec.id; repaint();
      });
    }));
    bar.appendChild(Kit.ai.button('Draft with Claude', function () { return runDraft(typeName, 'one').then(function () { repaint(); }); }, { busyLabel: 'Drafting...' }));
    bar.appendChild(Kit.ai.button('Draft a Set', function () { return runDraft(typeName, 'set').then(function () { repaint(); }); }, { busyLabel: 'Drafting...' }));
    main.appendChild(bar);
    var lcfg = TYPE_CFG[typeName];
    if (lcfg && lcfg.listExtras) lcfg.listExtras(main);
    var list = el('div', 'rl-reclist');
    main.appendChild(list);
    function paint() {
      U.clear(list);
      var q = s.value.trim();
      var shown = all.filter(function (r) { return matches(r, q); });
      if (!all.length) { list.appendChild(el('div', 'empty-line', 'No ' + label.toLowerCase() + ' records yet. Use New, or ask Claude to draft some.')); return; }
      if (!shown.length) { list.appendChild(el('div', 'empty-line', 'No matches for that search.')); return; }
      var errs = (Kit.validate.last && Kit.validate.last.byRecord) || {};
      shown.forEach(function (r) {
        var row = el('div', 'rl-rec');
        var open = el('button', 'rl-rec-main'); open.type = 'button';
        var n = (errs[r.id] || []).filter(function (x) { return x.level === 'error' || x.level === 'broken'; }).length;
        open.innerHTML = '<strong>' + esc(r.name || r.id) + '</strong><code class="id">' + esc(r.id) + '</code>' +
          (stale[r.id] ? '<span class="chip chip-warning">Review</span>' : '') + (n ? '<span class="chip chip-error">' + n + ' issue' + (n === 1 ? '' : 's') + '</span>' : '');
        open.addEventListener('click', function () { state.view = 'type:' + typeName; state.editing = r.id; repaint(); });
        row.appendChild(open);
        row.appendChild(iconButton('slots', 'Duplicate ' + (r.name || r.id), function () { var c = dupRecord(r, typeName); state.view = 'type:' + typeName; state.editing = c.id; repaint(); }));
        row.appendChild(iconButton('trash', 'Delete ' + (r.name || r.id), function () { deleteRecord(r, typeName).then(function (ok) { if (ok) repaint(); }); }));
        list.appendChild(row);
      });
    }
    s.addEventListener('input', function () { state.search[typeName] = s.value; paint(); });
    paint();
  }

  function formulasView(main) {
    var t = typeByName('Formula');
    var fs = rsOf().formulaSet;
    var role = el('div', 'rl-block');
    role.appendChild(el('h3', 'section-h', 'Formula set'));
    var roles = U.isObj(fs) ? Object.keys(fs) : [];
    if (!roles.length) role.appendChild(el('div', 'empty-line', 'The ruleset assigns no formulas yet. Choose a preset in the Charter, or amend it.'));
    else {
      var tb = el('div', 'rl-roles');
      roles.forEach(function (rk) {
        var id = fs[rk], ok = !!WSX.formulaSource(id);
        var chip = el('button', 'rl-role' + (ok ? '' : ' bad')); chip.type = 'button';
        chip.innerHTML = '<span class="muted">' + esc(rk) + '</span><code>' + esc(id) + '</code>' + (ok ? '' : '<span class="chip chip-error">missing</span>');
        chip.addEventListener('click', function () { if (FORMULA_LIB[id]) showLib(id); else if (ok) { state.view = 'type:Formula'; state.editing = id; repaint(); } });
        tb.appendChild(chip);
      });
      role.appendChild(tb);
    }
    main.appendChild(role);
    var lib = el('div', 'rl-block');
    lib.appendChild(el('h3', 'section-h', 'Template library'));
    lib.appendChild(el('p', 'muted rl-lead', 'These templates mirror the ones the battle engine implements. Preview any of them, or start a formula record from one.'));
    var grid = el('div', 'rl-libgrid');
    FORMULA_ORDER.forEach(function (id) {
      var l = FORMULA_LIB[id], card = el('div', 'card rl-libcard');
      card.innerHTML = '<div class="rl-libhead"><code>' + esc(id) + '</code><span class="chip chip-muted">' + esc(l.kind) + '</span></div><strong>' + esc(l.label) + '</strong><p class="muted">' + esc(l.note) + '</p>';
      var act = el('div', 'btn-row');
      act.appendChild(button('Preview', 'chart', 'btn-ghost', function () { showLib(id); }));
      if (t) act.appendChild(button('Use', 'plus', '', function () {
        askName('New formula from ' + id, l.label).then(function (n) {
          if (n == null) return;
          var rec = newRecord('Formula', n.trim()); rec.template = id; rec.params = {};
          Kit.bundle.touch('rules-new'); state.view = 'type:Formula'; state.editing = rec.id; repaint();
        });
      }));
      card.appendChild(act); grid.appendChild(card);
    });
    lib.appendChild(grid);
    main.appendChild(lib);
    if (t) {
      var rec = el('div', 'rl-block');
      rec.appendChild(el('h3', 'section-h', 'Your formulas'));
      var box = el('div'); rec.appendChild(box); main.appendChild(rec);
      listView(box, 'Formula');
    }
  }
  function showLib(id) {
    var src = libSource(id), ctl = null;
    Kit.ui.drawer({
      title: id + ': ' + src.label,
      onClose: function () { if (ctl) ctl.destroy(); },
      body: function (body) {
        var d = el('div', 'rl-expr'); d.innerHTML = '<span class="muted">Expression:</span> <code>' + esc(src.expr) + '</code>';
        var p = el('div', 'rl-defaults'); p.innerHTML = '<span class="muted">Parameters:</span> ' + Object.keys(src.params).map(function (k) { return '<code>' + esc(k) + ' = ' + esc(src.params[k]) + '</code>'; }).join(' ');
        body.appendChild(el('p', 'muted', esc(src.note))); body.appendChild(d); body.appendChild(p);
        var host = el('div'); body.appendChild(host);
        ctl = WSX.preview(host, function () { return libSource(id); });
      }
    });
  }

  function systemsView(main, which) {
    var head = el('div', 'rl-syshead');
    head.appendChild(el('h2', 'rl-h2', esc(RS.LABELS[which])));
    main.appendChild(head);
    var b = cur();
    var ctx = sysCtx(function () { Kit.refreshValidation(); });
    if (which !== 'affinity') {
      if (ctx.readOnly) lockedBanner(main);
    }
    var host = el('div', 'rl-sys');
    main.appendChild(host);
    RS[which](host, ctx);
    void b;
  }

  // ---------------------------------------------------------------- shell
  function repaint(keepScroll) {
    if (!hostRef || !alive(hostRef)) return;
    var y = keepScroll ? window.scrollY : 0;
    var host = hostRef;
    WSX.render(host, cur(), true);
    if (keepScroll) window.scrollTo(0, y);
  }
  function railButton(item, active) {
    var b = el('button', 'rl-nav' + (active ? ' on' : '')); b.type = 'button';
    var n = item.type ? counts(item.type) : null;
    b.innerHTML = Kit.icon(item.icon) + '<span class="rl-nav-l">' + esc(item.label) + '</span>' + (n != null ? '<span class="rl-count">' + n + '</span>' : '');
    b.dataset.view = item.view;
    if (active) b.setAttribute('aria-current', 'page');
    b.addEventListener('click', function () { state.view = item.view; state.editing = null; uiSet({ view: item.view }); repaint(); });
    return b;
  }
  WSX.render = function (host, b, isRepaint) {
    hostRef = host;
    if (prevCtl) { prevCtl.destroy(); prevCtl = null; }
    U.clear(host);
    var model = railModel();
    if (!state.view || !viewExists(state.view)) { var saved = uiGet().view; state.view = viewExists(saved) ? saved : 'sys:stats'; }
    var wrap = el('div', 'rl-wrap');
    var rail = el('nav', 'rl-rail'); rail.setAttribute('aria-label', 'Rules sections');
    var g1 = el('div', 'rl-group'), g2 = el('div', 'rl-group');
    var curView = state.view === 'type:Formula' ? 'sys:formulas' : state.view;
    g1.appendChild(el('div', 'rl-group-h', 'Systems'));
    model.sys.forEach(function (i) { g1.appendChild(railButton(i, i.view === curView)); });
    g2.appendChild(el('div', 'rl-group-h', 'Content'));
    model.content.forEach(function (i) { g2.appendChild(railButton(i, i.view === curView)); });
    if (!model.content.length) g2.appendChild(el('div', 'muted rl-note', 'Generate the Codex to add content types.'));
    rail.appendChild(g1); rail.appendChild(g2);
    var main = el('section', 'rl-main panel');
    wrap.appendChild(rail); wrap.appendChild(main);
    host.appendChild(wrap);
    var v = state.view;
    if (v === 'econ') { state.editing = null; economyView(main); }
    else if (v.indexOf('sys:') === 0) {
      var k = v.slice(4);
      if (k === 'formulas') { main.appendChild(el('h2', 'rl-h2', 'Formulas')); state.editing = null; formulasView(main); }
      else systemsView(main, k);
    } else {
      var tn = v.slice(5), t = typeByName(tn);
      if (!t) main.appendChild(el('div', 'empty-line', 'That type is not in the Codex.'));
      else {
        var rec = state.editing ? Kit.records.get(state.editing) : null;
        if (state.editing && !rec) state.editing = null;
        if (rec) editorView(main, tn, rec);
        else if (tn === 'ExpectedPartyState') epsView(main);
        else { main.appendChild(el('h2', 'rl-h2', esc(v === 'type:Status' ? 'Statuses' : v === 'type:Weather' ? 'Weather states' : (t.label || tn)))); listView(main, tn); }
      }
    }
    if (isRepaint && state.focusPath) {
      // Fields owned by a builder are hidden in the form, so jump to the builder that carries that path.
      var fp = state.focusPath, bh = null;
      Array.prototype.forEach.call(host.querySelectorAll('[data-bpath]'), function (n) {
        var bp = n.getAttribute('data-bpath');
        if (fp === bp || fp.indexOf(bp + '.') === 0 || fp.indexOf(bp + '[') === 0) bh = n;
      });
      if (bh) bh.scrollIntoView({ block: 'center' });
      else if (kform) kform.focusPath(fp);
      state.focusPath = null;
    }
  };

  WSX.focus = function (recordId, fieldPath) {
    if (recordId === 'charter:ruleset') {
      var m = /^(stats|elements|elementRelations|taxonomy)/.exec(fieldPath || '');
      state.view = 'sys:' + (m ? { stats: 'stats', elements: 'elements', elementRelations: 'relations', taxonomy: 'taxonomy' }[m[1]] : 'stats');
      state.editing = null; repaint(); return true;
    }
    var tn = typeOfRecordId(recordId);
    if (!tn) return false;
    state.view = 'type:' + tn; state.editing = recordId; state.focusPath = fieldPath || null;
    repaint();
    return true;
  };
  WSX.open = function (view, id) { state.view = view; state.editing = id || null; if (Kit.active() === 'rules') repaint(); else Kit.go('rules'); };
  WSX.state = state;

  // ---------------------------------------------------------------- validation
  Kit.validate.register('rules.formulas', function (b) {
    var out = [], fs = rsOf(b).formulaSet;
    Kit.records.list('frm_').forEach(function (r) {
      var hasT = !!r.template, hasE = typeof r.expr === 'string' && r.expr.trim();
      if (hasT && !FORMULA_LIB[r.template]) out.push({ recordId: r.id, fieldPath: 'template', message: 'The template "' + r.template + '" is not in the formula library.', level: 'error' });
      else if (!hasT && !hasE) out.push({ recordId: r.id, fieldPath: 'template', message: 'Choose a template or write an expression.', level: 'error' });
      else if (!hasT && hasE) {
        try { Kit.expr.parse(r.expr, { stats: statKeys(b), params: Object.keys(numericParams(r.params)) }); }
        catch (e) { out.push({ recordId: r.id, fieldPath: 'expr', message: e.message, level: 'error' }); }
      }
    });
    if (U.isObj(fs)) Object.keys(fs).forEach(function (role) {
      var id = fs[role];
      if (!id) return;
      if (!FORMULA_LIB[id] && !(Kit.ids.isValid(id) && Kit.records.get(id))) out.push({ recordId: 'charter:ruleset', fieldPath: 'formulaSet.' + role, message: 'The ' + role + ' formula "' + id + '" does not exist.', level: 'warning' });
    });
    return out;
  });

  Kit.mount('rules', { title: 'Rules', icon: 'sword', canEnter: WSX.canEnter, render: WSX.render, focus: WSX.focus });
})();
// === WS:RULES END ===
// === ENGINE:BATTLE BEGIN ===
var ENGINE_BATTLE = (function () {
  'use strict';
  // Pure battle engine. This fence must stay self contained: no host globals and no outer variables. Pass 4a added the
  // safe expression evaluator (a duplicate of the shared expression core); Pass 5 adds the templates, the seeded rng,
  // the scheduler and progression registries, the resolver, gambits, counters, Limits, and init / advance / run / replay.
  var expr = (function () {
    var FUNCS = { min: [1, 99], max: [1, 99], floor: [1, 1], ceil: [1, 1], round: [1, 1], clamp: [3, 3], pow: [2, 2], sqrt: [1, 1] };
    var FUNC_NAMES = ['min', 'max', 'floor', 'ceil', 'round', 'clamp', 'pow', 'sqrt'];
    var MAX_LEN = 2000;
    var VAR_HELP = 'Use a.<stat>, a.level, t.<stat>, t.level, power, or p.<param>.';
    var PREC = { '+': 1, '-': 1, '*': 2, '/': 2, '^': 4 };

    function fail(msg, pos) { var e = new Error(msg); if (pos != null) e.pos = pos; throw e; }
    function has(o, k) { return o !== null && typeof o === 'object' && Object.prototype.hasOwnProperty.call(o, k); }
    function isDigit(c) { return c >= '0' && c <= '9'; }
    function isIdStart(c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_'; }
    function isIdPart(c) { return isIdStart(c) || isDigit(c); }

    function tokenize(src) {
      if (typeof src !== 'string') fail('The expression must be text.');
      if (src.length > MAX_LEN) fail('The expression is longer than ' + MAX_LEN + ' characters.');
      var out = [], i = 0, n = src.length, c, j, k, d, seenDot, nx;
      while (i < n) {
        c = src.charAt(i);
        if (c === ' ' || c === '\t' || c === '\n' || c === '\r') { i++; continue; }
        if (isDigit(c) || (c === '.' && i + 1 < n && isDigit(src.charAt(i + 1)))) {
          j = i; seenDot = false;
          while (j < n) {
            d = src.charAt(j);
            if (isDigit(d)) j++;
            else if (d === '.' && !seenDot) { seenDot = true; j++; }
            else break;
          }
          nx = src.charAt(j);
          if (nx === '.') fail("Unexpected '.' at position " + (j + 1) + '.', j);
          if (nx !== '' && isIdStart(nx)) fail("Unexpected '" + nx + "' after a number at position " + (j + 1) + '.', j);
          out.push({ t: 'num', v: parseFloat(src.slice(i, j)), pos: i });
          i = j;
          continue;
        }
        if (isIdStart(c)) {
          k = i + 1;
          while (k < n && isIdPart(src.charAt(k))) k++;
          if (src.charAt(k) === '.' && k + 1 < n && isIdStart(src.charAt(k + 1))) {
            k++;
            while (k < n && isIdPart(src.charAt(k))) k++;
          }
          out.push({ t: 'id', v: src.slice(i, k), pos: i });
          i = k;
          continue;
        }
        if (c === '+' || c === '-' || c === '*' || c === '/' || c === '^') { out.push({ t: 'op', v: c, pos: i }); i++; continue; }
        if (c === '(') { out.push({ t: 'lp', pos: i }); i++; continue; }
        if (c === ')') { out.push({ t: 'rp', pos: i }); i++; continue; }
        if (c === ',') { out.push({ t: 'comma', pos: i }); i++; continue; }
        fail("Illegal character '" + c + "' at position " + (i + 1) + '.', i);
      }
      return out;
    }

    function checkVar(name, pos, opts) {
      var m, who, key, i, ok;
      if (name === 'power') return;
      m = /^([atp])\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(name);
      if (!m) fail("Unknown variable '" + name + "'. " + VAR_HELP, pos);
      who = m[1]; key = m[2];
      if (who === 'p') {
        if (opts && opts.params) {
          ok = false;
          for (i = 0; i < opts.params.length; i++) { if (opts.params[i] === key) ok = true; }
          if (!ok) fail("Unknown parameter 'p." + key + "'. Declared parameters: " + (opts.params.length ? opts.params.join(', ') : 'none') + '.', pos);
        }
        return;
      }
      if (key === 'level') return;
      if (!/^[a-z][a-z0-9]*$/.test(key)) fail("Unknown variable '" + name + "'. " + VAR_HELP, pos);
      if (opts && opts.stats) {
        ok = false;
        for (i = 0; i < opts.stats.length; i++) { if (opts.stats[i] === key) ok = true; }
        if (!ok) fail("Unknown stat '" + key + "' in " + name + '. Declared stats: ' + (opts.stats.length ? opts.stats.join(', ') : 'none') + '.', pos);
      }
    }

    // Tokenizer plus shunting yard parser. Returns an AST of {type:'num'|'var'|'un'|'bin'|'call'}.
    function parse(src, opts) {
      var toks = tokenize(src), out = [], ops = [], prev = 'start', i, t, top, nxt, prec, right, ar, argc, args, v;
      if (!toks.length) fail('The expression is empty.');
      function popApply() {
        var op = ops.pop(), r, l;
        if (op.k === 'un') {
          if (out.length < 1) fail("Missing operand after '" + op.v + "' at position " + (op.pos + 1) + '.', op.pos);
          out.push({ type: 'un', op: op.v, arg: out.pop() });
        } else {
          if (out.length < 2) fail("Missing operand for '" + op.v + "' at position " + (op.pos + 1) + '.', op.pos);
          r = out.pop(); l = out.pop();
          out.push({ type: 'bin', op: op.v, left: l, right: r });
        }
      }
      function unwindToMarker() {
        while (ops.length && ops[ops.length - 1].k !== 'lp' && ops[ops.length - 1].k !== 'fn') popApply();
      }
      for (i = 0; i < toks.length; i++) {
        t = toks[i];
        if (t.t === 'num') {
          if (prev === 'operand') fail("Missing operator before '" + t.v + "' at position " + (t.pos + 1) + '.', t.pos);
          out.push({ type: 'num', value: t.v });
          prev = 'operand';
        } else if (t.t === 'id') {
          if (prev === 'operand') fail("Missing operator before '" + t.v + "' at position " + (t.pos + 1) + '.', t.pos);
          nxt = toks[i + 1];
          if (nxt && nxt.t === 'lp') {
            if (!has(FUNCS, t.v)) fail("Unknown function '" + t.v + "'. Allowed functions: " + FUNC_NAMES.join(', ') + '.', t.pos);
            ops.push({ k: 'fn', v: t.v, argc: 0, pos: t.pos });
            i++;
            prev = 'open';
          } else {
            checkVar(t.v, t.pos, opts);
            out.push({ type: 'var', name: t.v });
            prev = 'operand';
          }
        } else if (t.t === 'lp') {
          if (prev === 'operand') fail("Missing operator before '(' at position " + (t.pos + 1) + '.', t.pos);
          ops.push({ k: 'lp', pos: t.pos });
          prev = 'open';
        } else if (t.t === 'rp') {
          if (prev === 'op' || prev === 'comma') fail("Missing operand before ')' at position " + (t.pos + 1) + '.', t.pos);
          unwindToMarker();
          if (!ops.length) fail("Unmatched ')' at position " + (t.pos + 1) + '.', t.pos);
          top = ops.pop();
          if (top.k === 'lp') {
            if (prev === 'open') fail("Empty parentheses at position " + (t.pos + 1) + '.', t.pos);
          } else {
            argc = prev === 'open' ? 0 : top.argc + 1;
            ar = FUNCS[top.v];
            if (argc < ar[0] || argc > ar[1]) {
              fail(top.v + ' takes ' + (ar[0] === ar[1] ? 'exactly ' + ar[0] : 'at least ' + ar[0]) + ' argument' + (ar[0] === 1 ? '' : 's') + ' but got ' + argc + '.', top.pos);
            }
            args = out.splice(out.length - argc, argc);
            out.push({ type: 'call', name: top.v, args: args });
          }
          prev = 'operand';
        } else if (t.t === 'comma') {
          if (prev !== 'operand') fail("Missing argument before ',' at position " + (t.pos + 1) + '.', t.pos);
          unwindToMarker();
          if (!ops.length || ops[ops.length - 1].k !== 'fn') fail("Unexpected ',' at position " + (t.pos + 1) + '. Commas only separate function arguments.', t.pos);
          ops[ops.length - 1].argc++;
          prev = 'comma';
        } else {
          v = t.v;
          if (prev === 'operand') {
            prec = PREC[v]; right = v === '^';
            while (ops.length) {
              top = ops[ops.length - 1];
              if (top.k !== 'bin' && top.k !== 'un') break;
              if (top.prec > prec || (top.prec === prec && !right)) popApply(); else break;
            }
            ops.push({ k: 'bin', v: v, prec: prec, pos: t.pos });
            prev = 'op';
          } else {
            if (v !== '-' && v !== '+') fail("Unexpected operator '" + v + "' at position " + (t.pos + 1) + '.', t.pos);
            ops.push({ k: 'un', v: v, prec: 3, pos: t.pos });
            prev = 'op';
          }
        }
      }
      if (prev !== 'operand') fail(prev === 'start' ? 'The expression is empty.' : 'The expression ends unexpectedly.');
      while (ops.length) {
        top = ops[ops.length - 1];
        if (top.k === 'lp' || top.k === 'fn') fail("Unmatched '(' at position " + (top.pos + 1) + '.', top.pos);
        popApply();
      }
      if (out.length !== 1) fail('The expression is not well formed.');
      return out[0];
    }

    function finite(v, what) {
      if (typeof v !== 'number' || !isFinite(v)) fail('The result of ' + what + ' is not a finite number.');
      return v;
    }
    function lookup(scope, name) {
      var dot, who, key, bag, v;
      if (name === 'power') v = scope ? scope.power : undefined;
      else {
        dot = name.indexOf('.'); who = name.slice(0, dot); key = name.slice(dot + 1);
        bag = scope ? (who === 'a' ? scope.a : who === 't' ? scope.t : scope.p) : undefined;
        v = has(bag, key) ? bag[key] : undefined;
      }
      if (typeof v !== 'number' || !isFinite(v)) fail('No value was supplied for ' + name + '.');
      return v;
    }
    function ev(node, scope) {
      var l, r, v, args, k;
      switch (node.type) {
        case 'num': return node.value;
        case 'var': return lookup(scope, node.name);
        case 'un': v = ev(node.arg, scope); return node.op === '-' ? -v : v;
        case 'bin':
          l = ev(node.left, scope); r = ev(node.right, scope);
          if (node.op === '+') v = l + r;
          else if (node.op === '-') v = l - r;
          else if (node.op === '*') v = l * r;
          else if (node.op === '/') { if (r === 0) fail('Division by zero.'); v = l / r; }
          else v = Math.pow(l, r);
          return finite(v, "'" + node.op + "'");
        case 'call':
          args = [];
          for (k = 0; k < node.args.length; k++) args.push(ev(node.args[k], scope));
          switch (node.name) {
            case 'min': v = Math.min.apply(null, args); break;
            case 'max': v = Math.max.apply(null, args); break;
            case 'floor': v = Math.floor(args[0]); break;
            case 'ceil': v = Math.ceil(args[0]); break;
            case 'round': v = Math.round(args[0]); break;
            case 'sqrt': if (args[0] < 0) fail('sqrt needs a value that is not negative.'); v = Math.sqrt(args[0]); break;
            case 'pow': v = Math.pow(args[0], args[1]); break;
            default:
              if (args[1] > args[2]) fail('clamp needs its low bound to be at most its high bound.');
              v = Math.min(Math.max(args[0], args[1]), args[2]);
          }
          return finite(v, node.name + '()');
        default:
          return fail('The expression is not well formed.');
      }
    }
    // scope = {a:{level, <stat>...}, t:{level, <stat>...}, power, p:{<param>...}}
    function evaluate(astOrSrc, scope, opts) {
      var ast = typeof astOrSrc === 'string' ? parse(astOrSrc, opts) : astOrSrc;
      return finite(ev(ast, scope || {}), 'the expression');
    }
    // Names of every variable an AST uses, sorted and unique.
    function variables(ast) {
      var seen = {}, list = [];
      (function walk(n) {
        var i;
        if (!n) return;
        if (n.type === 'var') { if (!seen[n.name]) { seen[n.name] = 1; list.push(n.name); } }
        else if (n.type === 'un') walk(n.arg);
        else if (n.type === 'bin') { walk(n.left); walk(n.right); }
        else if (n.type === 'call') { for (i = 0; i < n.args.length; i++) walk(n.args[i]); }
      })(ast);
      return list.sort();
    }
  return { parse: parse, evaluate: evaluate, variables: variables };
  })();
  // ------------------------------------------------------------------ Pass 5: templates, rng, battle loop
  var VERSION = '1.0.0';
  var GAUGE_MAX = 65536;
  // Template registry. Parameter names, defaults and expressions mirror WS.rules.FORMULA_LIB exactly (the harness checks).
  var TEMPLATES = {
    'phys.ff6': { id: 'phys.ff6', role: 'phys', kind: 'damage', expr: 'max(p.floor, floor((power + a.level * a.level * a.str / p.levelDiv) * (p.defBase - min(t.def, p.defBase - 1)) / p.defBase * p.mult))', params: { levelDiv: 256, defBase: 256, mult: 1, floor: 1 } },
    'mag.ff6': { id: 'mag.ff6', role: 'mag', kind: 'damage', expr: 'max(p.floor, floor((power * p.powerMult + a.level * a.mag * power / p.levelDiv) * (p.defBase - min(t.mdef, p.defBase - 1)) / p.defBase))', params: { powerMult: 4, levelDiv: 32, defBase: 256, floor: 1 } },
    'phys.sub': { id: 'phys.sub', role: 'phys', kind: 'damage', expr: 'max(p.floor, floor(a.str * p.atkMult + power - t.def * p.defMult))', params: { atkMult: 1, defMult: 0.5, floor: 1 } },
    'mag.flat': { id: 'mag.flat', role: 'mag', kind: 'damage', expr: 'max(p.floor, floor(power + a.mag * p.magMult - t.mdef * p.mdefMult))', params: { magMult: 1, mdefMult: 0.5, floor: 1 } },
    'heal.std': { id: 'heal.std', role: 'heal', kind: 'heal', expr: 'max(p.floor, floor((power + a.mag * p.magMult) * p.mult))', params: { magMult: 2, mult: 1, floor: 1 } },
    'var.std': { id: 'var.std', role: 'var', kind: 'variance', expr: '1 + p.spread * (2 * p.roll - 1)', params: { spread: 0.1, roll: 0.5 } },
    'exp.curve': { id: 'exp.curve', role: 'exp', kind: 'curve', expr: 'floor(p.base * pow(max(a.level - 1, 0), p.exponent))', params: { base: 40, exponent: 2.1 } },
    'ap.curve': { id: 'ap.curve', role: 'ap', kind: 'curve', expr: 'floor(p.base * pow(p.growth, max(a.level - 1, 0)))', params: { base: 100, growth: 2 } },
    'atb.fill': { id: 'atb.fill', role: 'atb', kind: 'rate', expr: 'floor((a.spd + p.spdOffset) * p.rate)', params: { spdOffset: 20, rate: 8 } }
  };
  var ABL_ROLE = { attack: 'phys', magic: 'mag', heal: 'heal', summon: 'mag', enemy: 'phys', limit: 'phys', command: 'phys' };
  var PHYS_KINDS = { attack: 1, enemy: 1, limit: 1, command: 1 };
  var AFF_MULT = { weak: 2, normal: 1, resist: 0.5, immune: 0, absorb: -1 };
  var SCHEDULERS = { atb: 1, rounds: 1, conditional: 1 };
  var PROGRESSIONS = { materia: 1, jobs: 1, classes: 1 };
  var EV = null; // event sink for the call in progress (single threaded)

  function isObj(o) { return o !== null && typeof o === 'object' && !Array.isArray(o); }
  function arr(a) { return Array.isArray(a) ? a : []; }
  function clone(o) { return o === undefined ? undefined : JSON.parse(JSON.stringify(o)); }
  function num(v, d) { return typeof v === 'number' && isFinite(v) ? v : (d === undefined ? 0 : d); }
  function clampN(v, lo, hi) { return v < lo ? lo : v > hi ? hi : v; }
  function prefixOf(id) { var m = /^([a-z]{3}_)/.exec(typeof id === 'string' ? id : ''); return m ? m[1] : null; }
  function numParams(o) { var out = {}; if (isObj(o)) Object.keys(o).forEach(function (k) { if (typeof o[k] === 'number' && isFinite(o[k])) out[k] = o[k]; }); return out; }

  // mulberry32 seeded by an integer. The state and the call count live in the battle state.
  function mkRng(seed) { return { a: (Math.floor(num(seed, 1)) | 0), calls: 0 }; }
  function rnd(S) {
    var a = (S.rng.a + 0x6D2B79F5) | 0, t;
    S.rng.a = a; S.rng.calls++;
    t = Math.imul(a ^ (a >>> 15), 1 | a);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  }

  function emit(S, type, o) {
    if (!EV) return;
    o = o || {};
    var e = { type: type, t: S.t, actor: o.actor == null ? null : o.actor, target: o.target == null ? null : o.target, value: o.value === undefined ? null : o.value, element: o.element || null, crit: !!o.crit };
    if (o.abl) e.abl = o.abl;
    if (o.name) e.name = o.name;
    if (o.targets) e.targets = o.targets;
    EV.push(e);
  }

  // ------------------------------------------------------------------ formulas
  function fxFrom(db, id, R) {
    if (!id) return null;
    if (db.fx[id]) return id;
    var src = null, t, rec;
    if (TEMPLATES[id]) { t = TEMPLATES[id]; src = { expr: t.expr, params: clone(t.params) }; }
    else if (prefixOf(id) === 'frm_') {
      rec = R.frm_ && R.frm_[id];
      if (isObj(rec)) {
        if (rec.template && TEMPLATES[rec.template]) { t = TEMPLATES[rec.template]; src = { expr: t.expr, params: Object.assign(clone(t.params), numParams(rec.params)) }; }
        else if (typeof rec.expr === 'string' && rec.expr.trim()) src = { expr: rec.expr, params: numParams(rec.params) };
      }
    }
    if (!src) return null;
    try { db.fx[id] = { ast: expr.parse(src.expr), params: src.params }; }
    catch (e) { db.warnings.push('Formula ' + id + ' does not parse: ' + e.message); return null; }
    return id;
  }
  function scopeOf(u) {
    var o = { level: u ? u.level : 1 }, k;
    if (u) for (k in u.stats) o[k] = u.stats[k];
    return o;
  }
  function evalF(S, fid, a, t, power, extra, fallback) {
    var f = fid && S.db.fx[fid], p, k;
    if (!f) return fallback;
    p = {};
    for (k in f.params) p[k] = f.params[k];
    if (extra) for (k in extra) p[k] = extra[k];
    try { return expr.evaluate(f.ast, { a: a, t: t, power: num(power), p: p }); }
    catch (e) {
      if (S.db.warnings.length < 20) S.db.warnings.push('Formula ' + fid + ': ' + e.message);
      return fallback;
    }
  }
  function roleFx(S, role) { return S.db.roles[role] || null; }

  // ------------------------------------------------------------------ compile the data into a compact db
  function compile(data, opts) {
    var rs = isObj(data.ruleset) ? data.ruleset : {}, R = isObj(data.records) ? data.records : {};
    var battle = isObj(rs.battle) ? rs.battle : {}, db, tax = isObj(rs.taxonomy) ? rs.taxonomy : {};
    db = {
      abl: {}, sta: {}, gmb: {}, fx: {}, roles: {}, warnings: [],
      stats: arr(rs.stats).filter(isObj).map(function (s) { return { key: String(s.key), min: num(s.min, 0), max: num(s.max, 999999) }; }).filter(function (s) { return s.key; }),
      elements: arr(rs.elements).map(function (e) { return isObj(e) ? String(e.key) : String(e); }).filter(Boolean),
      relations: arr(rs.elementRelations).filter(function (r) { return isObj(r) && (!r.kind || r.kind === 'opposed'); }).map(function (r) { return [String(r.a), String(r.b)]; }),
      inverts: arr(tax.inverts).map(String),
      weather: {},
      attackPower: num(opts.attackPower, num(battle.attackPower, 12)),
      damageCap: num(opts.damageCap, num(battle.damageCap, 9999)),
      limitRate: Math.max(0, num(opts.limitRate, num(battle.limitRate, 1)))
    };
    var fs = isObj(rs.formulaSet) ? rs.formulaSet : {};
    ['phys', 'mag', 'heal', 'var', 'atb', 'exp', 'ap'].forEach(function (role) { var id = fxFrom(db, fs[role], R); if (id) db.roles[role] = id; });
    var w = data.weatherId && R.wth_ && R.wth_[data.weatherId];
    if (isObj(w) && isObj(w.elementMultipliers)) Object.keys(w.elementMultipliers).forEach(function (k) { var v = w.elementMultipliers[k]; if (typeof v === 'number' && isFinite(v)) db.weather[k] = v; });
    db.weatherId = isObj(w) ? data.weatherId : null;
    db.attack = { id: '_attack', name: 'Attack', kind: 'attack', power: db.attackPower, targeting: { side: 'foe', scope: 'single' }, cost: {}, statusEffects: [], chargeTicks: 0 };
    return db;
  }
  function rec(R, id) { var p = prefixOf(id); return p && isObj(R[p]) && isObj(R[p][id]) ? R[p][id] : null; }
  function addAbl(db, R, id) {
    if (!id) return null;
    if (id === '_attack') return db.attack;
    if (db.abl[id]) return db.abl[id];
    var r = rec(R, id), a;
    if (!r || prefixOf(id) !== 'abl_') return null;
    a = {
      id: id, name: String(r.name || id), kind: String(r.kind || 'attack'), element: r.element || null, power: num(r.power),
      cost: { mp: num(r.cost && r.cost.mp) }, chargeTicks: Math.max(0, Math.floor(num(r.chargeTicks))),
      targeting: { side: (r.targeting && r.targeting.side) || 'foe', scope: (r.targeting && r.targeting.scope) || 'single' },
      statusEffects: arr(r.statusEffects).filter(function (s) { return isObj(s) && s.sta; }).map(function (s) { return { sta: s.sta, chance: num(s.chance, 1) }; }),
      fx: fxFrom(db, r.formula, R), revive: !!r.revive
    };
    a.statusEffects.forEach(function (s) { addSta(db, R, s.sta); });
    db.abl[id] = a;
    return a;
  }
  function addSta(db, R, id) {
    if (db.sta[id]) return db.sta[id];
    var r = rec(R, id);
    if (!r) return null;
    db.sta[id] = {
      id: id, name: String(r.name || id), gauge: r.gauge || 'normal',
      tick: { kind: (r.tickEffect && r.tickEffect.kind) || 'none', percent: num(r.tickEffect && r.tickEffect.percent) },
      duration: Math.max(0, Math.floor(num(r.duration))), onHit: !!(r.cure && r.cure.onHit)
    };
    return db.sta[id];
  }
  function addRules(db, R, id, rules, counters) {
    var g = { rules: [], counters: [] };
    arr(rules).forEach(function (x) {
      if (!isObj(x)) return;
      var abl = x.action && x.action.abl;
      if (!addAbl(db, R, abl)) return;
      var c = isObj(x.condition) ? x.condition : { kind: 'always' };
      if ((c.kind === 'targetHasStatus' || c.kind === 'targetLacksStatus') && c.param) addSta(db, R, String(c.param).trim());
      g.rules.push({ condition: { kind: c.kind || 'always', param: c.param == null ? '' : String(c.param) }, target: { selector: (x.target && x.target.selector) || 'randomFoe' }, action: { abl: abl } });
    });
    arr(counters).forEach(function (x) {
      if (!isObj(x) || !x.trigger) return;
      var abl = x.action && x.action.abl;
      if (!addAbl(db, R, abl)) return;
      g.counters.push({ trigger: x.trigger, abl: abl });
    });
    db.gmb[id] = g;
    return id;
  }

  // ------------------------------------------------------------------ units
  function statsFor(db, base, growth, level) {
    var out = {};
    db.stats.forEach(function (s) {
      var v = Math.round(num(base && base[s.key]) + num(growth && growth[s.key]) * (level - 1));
      out[s.key] = clampN(v, s.min, s.max);
    });
    return out;
  }
  function groupFor(kind) {
    if (kind === 'magic' || kind === 'heal' || kind === 'status') return 'magic';
    if (kind === 'summon') return 'summon';
    if (kind === 'limit' || kind === 'passive') return null;
    return 'skill';
  }
  function matLevel(m, ap) {
    var lv = 1;
    arr(m.apThresholds).forEach(function (th) { if (typeof th === 'number' && ap >= th) lv++; });
    return lv;
  }
  var PROGRESSION = {
    // Slotted materia and linked pairs produce commands, abilities and stat mods. Support materia modifies its linked neighbor.
    materia: function (db, R, m, u, grant, mods) {
      var slots = arr(m.materia).filter(function (x) { return isObj(x) && rec(R, x.mat); });
      var info = slots.map(function (x) {
        var mr = rec(R, x.mat), lv = matLevel(mr, num(x.ap)), abls = [];
        arr(mr.grants).forEach(function (g) {
          if (!isObj(g) || num(g.level, 1) > lv) return;
          if (g.abl && addAbl(db, R, g.abl)) abls.push(g.abl);
          if (isObj(g.statMods)) Object.keys(g.statMods).forEach(function (k) { mods[k] = num(mods[k]) + num(g.statMods[k]); });
        });
        return { x: x, rec: mr, level: lv, abls: abls };
      });
      info.forEach(function (it) {
        var kind = it.rec.kind;
        if (kind === 'support') return;
        it.abls.forEach(function (id) {
          var a = db.abl[id];
          if (kind === 'command') grant('cmd:' + id, a.name, id);
          else if (kind === 'summon') grant('summon', 'Summon', id);
          else if (kind === 'magic') grant('magic', 'Magic', id);
          else { var gr = groupFor(a.kind); if (gr) grant(gr, gr === 'magic' ? 'Magic' : gr === 'summon' ? 'Summon' : 'Skill', id); }
        });
      });
      // linked support materia
      info.forEach(function (it) {
        if (it.rec.kind !== 'support') return;
        var eq = rec(R, it.x.eqp), links = eq && isObj(eq.slotLayout) ? arr(eq.slotLayout.links) : [], n = null, cnt = eq && isObj(eq.slotLayout) ? num(eq.slotLayout.count) : 0;
        links.forEach(function (l) {
          if (n || !Array.isArray(l) || l.length !== 2) return;
          var other = l[0] === it.x.slot ? l[1] : l[1] === it.x.slot ? l[0] : null;
          if (other === null || other >= cnt || it.x.slot >= cnt) return;
          info.forEach(function (o) { if (!n && o !== it && o.x.eqp === it.x.eqp && o.x.slot === other) n = o; });
        });
        if (!n) return;
        var eff = it.rec.supportEffect;
        u.supports.push({ mat: it.x.mat, effect: eff, neighbor: n.x.mat });
        if (eff === 'all' || eff === 'hpAbsorb' || eff === 'mpAbsorb') {
          n.abls.forEach(function (id) { var md = u.mods[id] || (u.mods[id] = {}); md[eff === 'all' ? 'all' : eff] = true; });
        } else if (eff === 'element') {
          if (n.rec.element) u.attackElement = n.rec.element;
        } else if (eff === 'addedEffect') {
          n.abls.forEach(function (id) { db.abl[id].statusEffects.forEach(function (s) { u.addedEffects.push({ sta: s.sta, chance: s.chance }); }); });
        } else if (eff === 'counter') {
          u.counter = n.abls[0] || '_attack';
        }
      });
    },
    jobs: function (db, R, m, u, grant, mods) {
      var j = rec(R, m.job), jl = num(m.jobLevel, u.level);
      if (!j) return;
      arr(j.abilities).forEach(function (x) { if (isObj(x) && num(x.level, 1) <= jl && addAbl(db, R, x.abl)) { var a = db.abl[x.abl], g = groupFor(a.kind); if (g) grant(g, g === 'magic' ? 'Magic' : g === 'summon' ? 'Summon' : 'Skill', x.abl); } });
      if (isObj(j.statMods)) Object.keys(j.statMods).forEach(function (k) { mods[k] = num(mods[k]) + num(j.statMods[k]); });
    },
    classes: function (db, R, m, u, grant, mods) {
      var c = rec(R, m.cls);
      if (!c) return;
      arr(c.skillTree).forEach(function (x) { if (isObj(x) && num(x.level, 1) <= u.level && addAbl(db, R, x.abl)) { var a = db.abl[x.abl], g = groupFor(a.kind); if (g) grant(g, g === 'magic' ? 'Magic' : g === 'summon' ? 'Summon' : 'Skill', x.abl); } });
      if (isObj(c.statMods)) Object.keys(c.statMods).forEach(function (k) { mods[k] = num(mods[k]) + num(c.statMods[k]); });
    }
  };

  function partyUnit(db, R, m, i, prog) {
    var c = rec(R, m.chr);
    if (!c) { db.warnings.push('Party member ' + (i + 1) + ' has no character record.'); return null; }
    var L = clampN(Math.floor(num(m.level, 1)), 1, 99), mods = {}, cmds = [], byKey = {};
    var u = {
      uid: 'p' + i, side: 'party', ref: m.chr, name: String(c.name || m.chr), level: L, row: m.row === 'back' ? 'back' : 'front',
      weaponClass: c.weaponClass || '', stats: statsFor(db, c.baseStats, c.growth, L), mods: {}, supports: [], addedEffects: [],
      attackElement: null, counter: null, affinity: {}, tax: null, gambit: null
    };
    arr(m.equipment).forEach(function (eid) {
      var e = rec(R, eid);
      if (!e || !isObj(e.stats)) return;
      Object.keys(e.stats).forEach(function (k) { if (u.stats[k] !== undefined) u.stats[k] += Math.round(num(e.stats[k])); });
    });
    function grant(key, label, id) {
      if (!byKey[key]) { byKey[key] = { key: key, label: label, abls: [] }; cmds.push(byKey[key]); }
      if (byKey[key].abls.indexOf(id) < 0) byKey[key].abls.push(id);
    }
    if (PROGRESSION[prog]) PROGRESSION[prog](db, R, m, u, grant, mods);
    arr(m.abilities).forEach(function (id) { var a = addAbl(db, R, id), g; if (a) { g = groupFor(a.kind); if (g) grant(g, g === 'magic' ? 'Magic' : g === 'summon' ? 'Summon' : 'Skill', id); } });
    db.stats.forEach(function (s) { if (mods[s.key]) u.stats[s.key] = clampN(Math.round(u.stats[s.key] * (1 + mods[s.key] / 100)), s.min, s.max); });
    u.statMods = mods;
    u.commands = cmds.sort(function (a, b) { var o = { magic: 1, summon: 2 }; return (o[a.key] || 3) - (o[b.key] || 3); });
    u.maxHp = Math.max(1, num(u.stats.hp, 100));
    u.maxMp = Math.max(0, num(u.stats.mp, 0));
    u.hp = m.hp != null ? clampN(Math.floor(num(m.hp)), 0, u.maxHp) : u.maxHp;
    u.mp = m.mp != null ? clampN(Math.floor(num(m.mp)), 0, u.maxMp) : u.maxMp;
    u.limits = arr(c.limitTree).map(function (lid) { return rec(R, lid) ? { id: lid, r: rec(R, lid) } : null; }).filter(Boolean)
      .filter(function (x) { return addAbl(db, R, x.r.action); })
      .map(function (x) { return { id: x.id, level: clampN(Math.floor(num(x.r.level, 1)), 1, 4), abl: x.r.action, uses: num(x.r.unlock && x.r.unlock.uses), kills: num(x.r.unlock && x.r.unlock.kills) }; })
      .sort(function (a, b) { return a.level - b.level; });
    u.limit = { gauge: clampN(num(m.limitGauge), 0, 1), level: clampN(Math.floor(num(m.limitLevel, 1)), 1, 4), uses: num(m.limitUses), usesAtLevel: 0, kills: num(m.kills) };
    if (u.counter) addAbl(db, R, u.counter);
    return u;
  }

  function affinityFor(db, famType, absorbOwn, overrides) {
    var out = {}, opp = [];
    db.relations.forEach(function (p) { if (p[0] === famType) opp.push(p[1]); if (p[1] === famType) opp.push(p[0]); });
    db.elements.forEach(function (k) {
      if (famType && k === famType) out[k] = absorbOwn ? 'absorb' : 'resist';
      else if (opp.indexOf(k) >= 0) out[k] = 'weak';
      else out[k] = 'normal';
    });
    if (isObj(overrides)) Object.keys(overrides).forEach(function (k) { if (AFF_MULT[overrides[k]] !== undefined) out[k] = overrides[k]; });
    return out;
  }

  function foeUnits(db, R, troopId) {
    var t = rec(R, troopId), out = [], names = {};
    if (!t) { db.warnings.push('Troop ' + troopId + ' was not found.'); return out; }
    db.troop = { id: troopId, name: String(t.name || troopId), noEscape: !!(t.flags && t.flags.noEscape), preemptive: num(t.flags && t.flags.preemptiveChance) };
    var bst = {};
    Object.keys(isObj(R.bst_) ? R.bst_ : {}).forEach(function (id) { var b = R.bst_[id]; if (isObj(b) && b.boss && !bst[b.boss]) bst[b.boss] = id; });
    arr(t.members).forEach(function (mb, i) {
      if (!isObj(mb)) return;
      var e = rec(R, mb.enm);
      if (!e) { db.warnings.push('Troop member ' + (i + 1) + ' references a missing enemy.'); return; }
      var fam = rec(R, e.family) || {}, st = {}, gid = null;
      db.stats.forEach(function (s) { st[s.key] = clampN(Math.round(num(e.stats && e.stats[s.key])), s.min, s.max); });
      if (bst[mb.enm]) gid = addRules(db, R, bst[mb.enm], R.bst_[bst[mb.enm]].rules, R.bst_[bst[mb.enm]].counters);
      else if (e.gambits && rec(R, e.gambits)) gid = addRules(db, R, e.gambits, rec(R, e.gambits).rules, rec(R, e.gambits).counters);
      var nm = String(e.name || mb.enm);
      names[nm] = (names[nm] || 0) + 1;
      out.push({
        uid: 'e' + i, side: 'foe', ref: mb.enm, name: nm, level: clampN(Math.floor(num(e.level, 1)), 1, 99), row: mb.row === 'back' ? 'back' : 'front',
        fam: e.family || null, tier: Math.max(1, Math.floor(num(e.tier, 1))), palette: isObj(fam.palette) ? { base: fam.palette.base || null, accent: fam.palette.accent || null } : { base: null, accent: null },
        tax: fam.type || null, affinity: affinityFor(db, fam.type || null, !!fam.absorbsOwnType, e.affinityOverrides),
        stats: st, maxHp: Math.max(1, num(st.hp, 1)), maxMp: Math.max(0, num(st.mp)), gambit: gid, isBoss: !!e.isBoss,
        gil: num(e.gil), exp: num(e.exp), ap: num(e.ap), mods: {}, addedEffects: [], attackElement: null, counter: null, commands: [], limits: [], limit: null
      });
    });
    out.forEach(function (u) { u.hp = u.maxHp; u.mp = u.maxMp; });
    // Letter suffixes for repeated names
    var seen = {};
    out.forEach(function (u) { if (names[u.name] > 1) { seen[u.name] = (seen[u.name] || 0) + 1; u.name = u.name + ' ' + String.fromCharCode(64 + seen[u.name]); } });
    return out;
  }

  function fillOf(S, u) {
    var f = evalF(S, roleFx(S, 'atb'), scopeOf(u), {}, 0, null, null);
    if (f == null) f = Math.floor((num(u.stats.spd, 10) + 20) * 8);
    return Math.max(1, Math.floor(f));
  }
  function delayOf(S, u) { return Math.ceil(GAUGE_MAX / u.fill); }

  // ------------------------------------------------------------------ init
  function init(data, seed, opts) {
    data = isObj(data) ? data : {};
    opts = isObj(opts) ? opts : {};
    var rs = isObj(data.ruleset) ? data.ruleset : {}, R = isObj(data.records) ? data.records : {};
    var db = compile(data, opts);
    var sched = SCHEDULERS[opts.scheduler] ? opts.scheduler : SCHEDULERS[rs.scheduler] ? rs.scheduler : 'atb';
    var prog = PROGRESSIONS[rs.progression] ? rs.progression : null;
    var battle = isObj(rs.battle) ? rs.battle : {};
    var S = {
      v: VERSION, seed: Math.floor(num(seed, 1)) | 0, rng: mkRng(seed), t: 0, turns: 0, sched: sched, progression: prog,
      waitMode: opts.waitMode != null ? !!opts.waitMode : battle.waitMode != null ? !!battle.waitMode : true,
      tickCap: Math.max(10, Math.floor(num(opts.tickCap, 20000))), gaugeMax: GAUGE_MAX,
      db: db, units: [], readyQueue: [], awaiting: null, round: null, preemptive: false, result: null,
      res: { mpSpent: 0, hpStart: 0, hpMax: 0, mpMax: 0, itemsUsed: 0 }, damageLog: [], lastAttacker: {}, noLog: !!opts.noDamageLog
    };
    arr(data.party).forEach(function (m, i) { if (isObj(m)) { var u = partyUnit(db, R, m, i, prog); if (u) S.units.push(u); } });
    foeUnits(db, R, data.troopId).forEach(function (u) { S.units.push(u); });
    S.units.forEach(function (u) {
      u.gauge = 0; u.ready = false; u.charging = null; u.statuses = []; u.ko = u.hp <= 0; u.turns = 0; u.kills = u.limit ? u.limit.kills : 0;
      u.fill = fillOf(S, u); u.nextAt = 0; u.frozenTicks = 0; u.limitFlag = false;
    });
    S.units.forEach(function (u) { if (u.side === 'party') { S.res.hpStart += u.hp; S.res.hpMax += u.maxHp; S.res.mpMax += u.maxMp; } });
    S.preemptive = !!(db.troop && db.troop.preemptive > 0 && rnd(S) < db.troop.preemptive);
    S.units.forEach(function (u) {
      if (u.ko) return;
      if (sched === 'atb') u.gauge = S.preemptive && u.side === 'party' ? GAUGE_MAX - 1 : Math.floor(rnd(S) * GAUGE_MAX * 0.5);
      else if (sched === 'conditional') u.nextAt = S.preemptive && u.side === 'party' ? 0 : Math.floor(delayOf(S, u) * (0.25 + rnd(S) * 0.5));
    });
    if (!partyOf(S).length || !foesOf(S).length) S.result = finish(S, partyOf(S).length ? 'win' : 'lose', true);
    return S;
  }

  // ------------------------------------------------------------------ helpers over units
  function unit(S, uid) { for (var i = 0; i < S.units.length; i++) if (S.units[i].uid === uid) return S.units[i]; return null; }
  function sideOf(S, side, alive) { return S.units.filter(function (u) { return u.side === side && (!alive || !u.ko); }); }
  function partyOf(S) { return sideOf(S, 'party', false); }
  function foesOf(S) { return sideOf(S, 'foe', false); }
  function other(side) { return side === 'party' ? 'foe' : 'party'; }
  function frac(u) { return u.maxHp ? u.hp / u.maxHp : 0; }
  function hasSta(u, id) { for (var i = 0; i < u.statuses.length; i++) if (u.statuses[i].sta === id) return true; return false; }
  function blockedBy(S, u) {
    for (var i = 0; i < u.statuses.length; i++) { var d = S.db.sta[u.statuses[i].sta]; if (d && (d.gauge === 'freeze' || d.gauge === 'empty')) return d.gauge; }
    return null;
  }
  function ablOf(S, id) { return id === '_attack' ? S.db.attack : S.db.abl[id] || null; }
  function affordable(u, a) { return !!a && u.mp >= num(a.cost && a.cost.mp); }

  // ------------------------------------------------------------------ statuses
  function applyStatus(S, actor, u, staId) {
    var d = S.db.sta[staId];
    if (!d || u.ko) return;
    var had = false;
    u.statuses.forEach(function (s) { if (s.sta === staId) { s.left = d.duration || -1; had = true; } });
    if (!had) u.statuses.push({ sta: staId, left: d.duration || -1 });
    if (d.gauge === 'empty' && S.sched === 'atb') u.gauge = 0;
    if (d.gauge !== 'normal') { u.ready = false; u.charging = null; dropReady(S, u); }
    emit(S, 'status', { actor: actor ? actor.uid : null, target: u.uid, value: staId, name: d.name });
    counters(S, u, actor, 'onStatus', null);
  }
  function removeStatus(S, u, staId, why) {
    var before = u.statuses.length;
    u.statuses = u.statuses.filter(function (s) { return s.sta !== staId; });
    if (u.statuses.length !== before) emit(S, 'status', { target: u.uid, value: '-' + staId, name: why || 'cured' });
  }
  // Runs at the start of a unit's own turn (or once per skipped turn): tick effects, then durations.
  function statusTurn(S, u) {
    u.statuses.slice().forEach(function (s) {
      var d = S.db.sta[s.sta], v;
      if (!d || u.ko) return;
      if (d.tick.kind === 'damage' && d.tick.percent > 0) {
        v = Math.max(1, Math.floor(u.maxHp * d.tick.percent / 100));
        dealDamage(S, null, u, v, null, false, null);
      } else if (d.tick.kind === 'heal' && d.tick.percent > 0) {
        v = Math.max(1, Math.floor(u.maxHp * d.tick.percent / 100));
        u.hp = Math.min(u.maxHp, u.hp + v);
        emit(S, 'heal', { target: u.uid, value: v });
      } else if (d.tick.kind === 'mpDrain' && d.tick.percent > 0) {
        u.mp = Math.max(0, u.mp - Math.max(1, Math.floor(u.maxMp * d.tick.percent / 100)));
      }
      if (s.left > 0) { s.left--; if (s.left === 0) removeStatus(S, u, s.sta, 'wore off'); }
    });
  }

  // ------------------------------------------------------------------ damage, KO, limits, counters
  function dropReady(S, u) {
    S.readyQueue = S.readyQueue.filter(function (x) { return x !== u.uid; });
    if (S.awaiting && S.awaiting.actor === u.uid) { S.awaiting = null; nextAwaiting(S); }
  }
  function ko(S, u, killer) {
    u.ko = true; u.hp = 0; u.gauge = 0; u.ready = false; u.charging = null; u.statuses = [];
    if (u.limit) u.limit.gauge = 0;
    dropReady(S, u);
    emit(S, 'ko', { actor: killer ? killer.uid : null, target: u.uid });
    if (killer && killer.side !== u.side) {
      killer.kills++;
      if (killer.limit) { killer.limit.kills++; unlockLimits(S, killer); }
    }
    sideOf(S, u.side, true).forEach(function (a) { counters(S, a, killer, 'onAllyKo', null); });
  }
  function unlockLimits(S, u) {
    if (!u.limit || !u.limits.length) return;
    var next = null;
    u.limits.forEach(function (l) { if (!next && l.level === u.limit.level + 1) next = l; });
    if (!next) return;
    if ((next.uses > 0 && u.limit.usesAtLevel >= next.uses) || (next.kills > 0 && u.limit.kills >= next.kills)) {
      u.limit.level = next.level; u.limit.usesAtLevel = 0;
      emit(S, 'limitReady', { target: u.uid, value: 'level' + next.level, name: 'Limit level ' + next.level });
    }
  }
  function currentLimit(u) {
    var best = null;
    if (!u.limit) return null;
    u.limits.forEach(function (l) { if (l.level <= u.limit.level && (!best || l.level >= best.level)) best = l; });
    return best;
  }
  function dealDamage(S, actor, u, v, element, crit, abl) {
    var lowBefore = frac(u) >= 0.25;
    v = Math.max(0, Math.min(S.db.damageCap, Math.round(v)));
    u.hp = Math.max(0, u.hp - v);
    emit(S, 'damage', { actor: actor ? actor.uid : null, target: u.uid, value: v, element: element, crit: crit, abl: abl ? abl.id : null });
    if (!S.noLog) S.damageLog.push({ t: S.t, actor: actor ? actor.uid : null, target: u.uid, side: u.side, value: v, element: element || null, crit: !!crit, abl: abl ? abl.id : null });
    if (v > 0) {
      u.statuses.slice().forEach(function (s) { var d = S.db.sta[s.sta]; if (d && d.onHit) removeStatus(S, u, s.sta, 'woke'); });
      if (u.limit && u.limits.length && !u.ko && u.hp > 0) {
        var was = u.limit.gauge;
        u.limit.gauge = Math.min(1, u.limit.gauge + v / u.maxHp * S.db.limitRate);
        if (was < 1 && u.limit.gauge >= 1) emit(S, 'limitReady', { target: u.uid, value: 'full', name: 'Limit ready' });
      }
    }
    if (actor) S.lastAttacker[u.uid] = actor.uid;
    if (u.hp <= 0 && !u.ko) { ko(S, u, actor); return v; }
    if (actor && abl && v > 0) {
      counters(S, u, actor, PHYS_KINDS[abl.kind] ? 'onPhysical' : 'onMagic', abl);
      counters(S, u, actor, 'onDamaged', abl);
      if (lowBefore && frac(u) < 0.25) counters(S, u, actor, 'onLowHp', abl);
    }
    return v;
  }
  function healUnit(S, actor, u, v, abl) {
    v = Math.max(0, Math.min(S.db.damageCap, Math.round(v)));
    var before = u.hp;
    u.hp = Math.min(u.maxHp, u.hp + v);
    emit(S, 'heal', { actor: actor ? actor.uid : null, target: u.uid, value: u.hp - before, abl: abl ? abl.id : null });
  }
  // A counter fires at most once per hit and never answers another counter.
  function counters(S, u, attacker, trigger, abl) {
    if (!u || u.ko || S.inCounter || !attacker || attacker.side === u.side && trigger !== 'onAllyKo') return;
    if (trigger === 'onAllyKo' && (!attacker || attacker.side === u.side)) return;
    var pick = null, a;
    if (u.gambit && S.db.gmb[u.gambit]) {
      S.db.gmb[u.gambit].counters.forEach(function (c) { if (!pick && c.trigger === trigger) pick = c.abl; });
    }
    if (!pick && u.counter && trigger === 'onPhysical' && rnd(S) < 0.5) pick = u.counter;
    a = ablOf(S, pick);
    if (!a || !affordable(u, a) || attacker.ko) return;
    var targets = a.targeting.side === 'ally' || a.targeting.side === 'self' ? [u.uid] : [attacker.uid];
    if (a.targeting.scope === 'all' || (u.mods[a.id] && u.mods[a.id].all)) targets = sideOf(S, a.targeting.side === 'ally' || a.targeting.side === 'self' ? u.side : attacker.side, true).map(function (x) { return x.uid; });
    S.inCounter = true;
    try { perform(S, u, a.id, targets, true); } finally { S.inCounter = false; }
  }

  // ------------------------------------------------------------------ the resolver
  function elementMult(S, u, element) {
    if (!element) return 1;
    var aff = u.affinity && u.affinity[element] ? AFF_MULT[u.affinity[element]] : 1;
    var w = S.db.weather[element];
    return (aff === undefined ? 1 : aff) * (typeof w === 'number' ? w : 1);
  }
  function resolveOne(S, actor, u, a) {
    var md = actor.mods[a.id] || {}, role = ABL_ROLE[a.kind] || null, phys = !!PHYS_KINDS[a.kind];
    var element = a.id === '_attack' ? actor.attackElement : a.element;
    if (u.ko) {
      if (a.revive && a.kind === 'heal') {
        u.ko = false; u.hp = 1;
        emit(S, 'revive', { actor: actor.uid, target: u.uid, abl: a.id });
        healUnit(S, actor, u, evalF(S, a.fx || roleFx(S, 'heal'), scopeOf(actor), scopeOf(u), a.power, null, a.power), a);
      }
      return;
    }
    if (phys) {
      var hit = clampN(0.9 + (num(actor.stats.luck) - num(u.stats.luck)) / 256, 0.5, 0.99);
      if (rnd(S) >= hit) { emit(S, 'miss', { actor: actor.uid, target: u.uid, abl: a.id }); return; }
    }
    if (role) {
      var fid = a.fx || roleFx(S, role);
      var base = evalF(S, fid, scopeOf(actor), scopeOf(u), a.power, { allies: sideOf(S, actor.side, true).length }, a.power);
      var variance = roleFx(S, 'var') ? evalF(S, roleFx(S, 'var'), scopeOf(actor), scopeOf(u), a.power, { roll: rnd(S) }, 1) : 1;
      var crit = false;
      if (phys && a.kind !== 'limit') crit = rnd(S) < clampN(0.03 + num(actor.stats.luck) / 512, 0, 0.5);
      var v = base * variance * (crit ? 2 : 1);
      if (phys && actor.row === 'back') v *= 0.5;
      if (phys && u.row === 'back') v *= 0.5;
      if (a.kind === 'heal') {
        if (u.tax && S.db.inverts.indexOf(u.tax) >= 0) dealDamage(S, actor, u, v, element || null, false, a);
        else healUnit(S, actor, u, v, a);
      } else {
        var mult = elementMult(S, u, element);
        if (mult < 0) healUnit(S, actor, u, v * -mult, a);
        else {
          var dealt = dealDamage(S, actor, u, v * mult, element, crit, a);
          if (md.hpAbsorb && !actor.ko) { actor.hp = Math.min(actor.maxHp, actor.hp + dealt); emit(S, 'heal', { actor: actor.uid, target: actor.uid, value: dealt, abl: a.id }); }
          if (md.mpAbsorb && !actor.ko) actor.mp = Math.min(actor.maxMp, actor.mp + Math.floor(dealt / 10));
        }
      }
    }
    if (u.ko) return;
    var effects = a.statusEffects.slice();
    if (a.id === '_attack') effects = effects.concat(actor.addedEffects || []);
    effects.forEach(function (s) { if (!u.ko && rnd(S) < num(s.chance, 1)) applyStatus(S, actor, u, s.sta); else if (a.kind === 'status' && !u.ko) emit(S, 'miss', { actor: actor.uid, target: u.uid, abl: a.id, value: s.sta }); });
  }
  function perform(S, actor, ablId, targetUids, isCounter) {
    var a = ablOf(S, ablId);
    if (!a || actor.ko) return;
    var mp = num(a.cost && a.cost.mp);
    if (actor.mp < mp) { emit(S, 'miss', { actor: actor.uid, abl: a.id, value: 'mp', name: 'Not enough MP' }); return; }
    actor.mp -= mp;
    if (actor.side === 'party') S.res.mpSpent += mp;
    var list = targetUids.map(function (id) { return unit(S, id); }).filter(Boolean);
    // single target that fell: retarget to a living unit on the same side
    if (list.length === 1 && list[0].ko && !a.revive) {
      var alive = sideOf(S, list[0].side, true);
      list = alive.length ? [alive[Math.floor(rnd(S) * alive.length)]] : [];
    }
    emit(S, 'action', { actor: actor.uid, abl: a.id, name: a.name, element: a.id === '_attack' ? actor.attackElement : a.element, targets: list.map(function (x) { return x.uid; }), value: isCounter ? 'counter' : null });
    list.forEach(function (u) { resolveOne(S, actor, u, a); });
    if (actor.limit && !isCounter && (a.kind === 'limit' || actor.limits.some(function (l) { return l.abl === a.id; }))) {
      actor.limit.gauge = 0; actor.limit.uses++; actor.limit.usesAtLevel++;
      unlockLimits(S, actor);
    }
    checkEnd(S);
  }

  // ------------------------------------------------------------------ gambits and the party policy
  function candidates(S, u, sel) {
    if (sel === 'self') return [u];
    if (sel === 'attacker') {
      var at = S.lastAttacker[u.uid] && unit(S, S.lastAttacker[u.uid]);
      return at && !at.ko ? [at] : sideOf(S, other(u.side), true);
    }
    if (/Ally$|Allies$/.test(sel || '')) return sideOf(S, u.side, true);
    return sideOf(S, other(u.side), true);
  }
  function pickFrom(S, sel, pool) {
    if (!pool.length) return [];
    if (sel === 'allFoes' || sel === 'allAllies') return pool.slice();
    if (sel === 'lowestHpFoe' || sel === 'lowestHpAlly') return [pool.slice().sort(function (a, b) { return a.hp - b.hp || (a.uid < b.uid ? -1 : 1); })[0]];
    if (sel === 'highestHpFoe') return [pool.slice().sort(function (a, b) { return b.hp - a.hp || (a.uid < b.uid ? -1 : 1); })[0]];
    if (sel === 'self' || sel === 'attacker') return [pool[0]];
    return [pool[Math.floor(rnd(S) * pool.length)]];
  }
  function expand(S, u, a, targets) {
    if (!targets.length) return targets;
    if (a.targeting.scope === 'all' || (u.mods[a.id] && u.mods[a.id].all)) return sideOf(S, targets[0].side, true);
    if (a.targeting.scope === 'row') { var r = targets[0].row, s = targets[0].side; return sideOf(S, s, true).filter(function (x) { return x.row === r; }); }
    if (a.targeting.scope === 'random') { var pool = sideOf(S, targets[0].side, true); return [pool[Math.floor(rnd(S) * pool.length)]]; }
    return targets;
  }
  function chooseByRules(S, u, g) {
    var rules = g && g.rules ? g.rules : [], i, x, a, c, p, pool, ok, sel, t;
    for (i = 0; i < rules.length; i++) {
      x = rules[i]; a = ablOf(S, x.action.abl);
      if (!affordable(u, a)) continue;
      c = x.condition; p = parseFloat(c.param); sel = x.target.selector;
      pool = candidates(S, u, sel);
      ok = true;
      switch (c.kind) {
        case 'always': break;
        case 'selfHpBelow': ok = frac(u) < p; break;
        case 'selfHpAbove': ok = frac(u) > p; break;
        case 'allyHpBelow':
          ok = sideOf(S, u.side, true).some(function (y) { return frac(y) < p; });
          if (/Ally$|Allies$/.test(sel)) pool = pool.filter(function (y) { return frac(y) < p; });
          break;
        case 'targetHpBelow': pool = pool.filter(function (y) { return frac(y) < p; }); break;
        case 'targetHasStatus': pool = pool.filter(function (y) { return hasSta(y, String(c.param).trim()); }); break;
        case 'targetLacksStatus': pool = pool.filter(function (y) { return !hasSta(y, String(c.param).trim()); }); break;
        case 'turnEvery': ok = ((u.turns + 1) % Math.max(1, Math.round(num(p, 1)))) === 0; break;
        case 'enemyCountBelow': ok = sideOf(S, other(u.side), true).length < p; break;
        case 'allyCountBelow': ok = sideOf(S, u.side, true).length < p; break;
        case 'chance': ok = rnd(S) < num(p, 0); break;
        default: ok = false;
      }
      if (!ok || !pool.length) continue;
      t = expand(S, u, a, pickFrom(S, sel, pool));
      if (t.length) return { abl: a.id, targets: t.map(function (y) { return y.uid; }) };
    }
    return null;
  }
  function basicAttack(S, u) {
    var pool = sideOf(S, other(u.side), true);
    return pool.length ? { abl: '_attack', targets: [pool[Math.floor(rnd(S) * pool.length)].uid] } : null;
  }
  function estimate(S, u, a, t) {
    var role = ABL_ROLE[a.kind];
    if (!role || a.kind === 'heal') return 0;
    var v = num(evalF(S, a.fx || roleFx(S, role), scopeOf(u), scopeOf(t), a.power, { allies: sideOf(S, u.side, true).length }, a.power));
    var m = elementMult(S, t, a.id === '_attack' ? u.attackElement : a.element);
    var n = (a.targeting.scope === 'all' || (u.mods[a.id] && u.mods[a.id].all)) ? sideOf(S, t.side, true).length : 1;
    return v * Math.max(0, m) * n;
  }
  // Default party policy: heal below 35 percent, then a ready Limit, otherwise the strongest affordable attack.
  function defaultPolicy(S, u) {
    var aw = S.awaiting, allies = sideOf(S, 'party', true), foes = sideOf(S, 'foe', true), heals = [], hurt, best = null, bestV = -1, target;
    if (!foes.length) return null;
    aw.commands.forEach(function (c) { c.abls.forEach(function (x) { var a = ablOf(S, x.id); if (x.ok && a && a.kind === 'heal' && a.targeting.side !== 'foe') heals.push(a); }); });
    hurt = allies.filter(function (y) { return frac(y) < 0.35; }).sort(function (a, b) { return frac(a) - frac(b); });
    if (hurt.length && heals.length) {
      heals.sort(function (a, b) { return b.power - a.power; });
      return { type: 'command', actor: u.uid, cmd: 'heal', abl: heals[0].id, target: hurt[0].uid };
    }
    target = foes.slice().sort(function (a, b) { return a.hp - b.hp || (a.uid < b.uid ? -1 : 1); })[0];
    aw.commands.forEach(function (c) {
      if (c.key === 'flee') return;
      c.abls.forEach(function (x) {
        var a = ablOf(S, x.id), v;
        if (!x.ok || !a || a.kind === 'heal' || a.kind === 'status' || a.targeting.side === 'ally' || a.targeting.side === 'self') return;
        v = estimate(S, u, a, target) * (c.key === 'limit' ? 1.5 : 1);
        if (v > bestV) { bestV = v; best = { type: 'command', actor: u.uid, cmd: c.key, abl: a.id, target: target.uid }; }
      });
    });
    return best || { type: 'command', actor: u.uid, cmd: 'attack', abl: '_attack', target: target.uid };
  }
  function policyInput(S, policy) {
    var u = unit(S, S.awaiting.actor), ch;
    if (isObj(policy) && Array.isArray(policy.rules) && policy.rules.length) {
      if (!policy._compiled) {
        var g = { rules: [], counters: [] };
        policy.rules.forEach(function (x) { if (isObj(x) && x.action && ablOf(S, x.action.abl)) g.rules.push({ condition: isObj(x.condition) ? { kind: x.condition.kind || 'always', param: String(x.condition.param == null ? '' : x.condition.param) } : { kind: 'always', param: '' }, target: { selector: (x.target && x.target.selector) || 'lowestHpFoe' }, action: { abl: x.action.abl } }); });
        policy._compiled = g;
      }
      ch = chooseByRules(S, u, policy._compiled);
      if (ch) return { type: 'command', actor: u.uid, cmd: 'policy', abl: ch.abl, target: ch.targets[0], targets: ch.targets };
    }
    return defaultPolicy(S, u);
  }

  // ------------------------------------------------------------------ turns
  function commandsFor(S, u) {
    var out = [], lim = u.limit && u.limit.gauge >= 1 ? currentLimit(u) : null;
    function row(id) { var a = ablOf(S, id); return { id: id, name: a.name, mp: num(a.cost.mp), ok: affordable(u, a), side: a.targeting.side, scope: (u.mods[id] && u.mods[id].all) ? 'all' : a.targeting.scope, element: id === '_attack' ? u.attackElement : a.element, kind: a.kind }; }
    if (lim) out.push({ key: 'limit', label: 'Limit', abls: [row(lim.abl)] });
    else out.push({ key: 'attack', label: 'Attack', abls: [row('_attack')] });
    u.commands.forEach(function (c) { out.push({ key: c.key, label: c.label, abls: c.abls.filter(function (id) { return ablOf(S, id); }).map(row) }); });
    if (!(S.db.troop && S.db.troop.noEscape)) out.push({ key: 'flee', label: 'Flee', abls: [] });
    return out;
  }
  function nextAwaiting(S) {
    if (S.awaiting || S.result) return;
    while (S.readyQueue.length) {
      var u = unit(S, S.readyQueue[0]);
      if (u && !u.ko && u.ready) {
        S.awaiting = { actor: u.uid, commands: commandsFor(S, u), targets: { foe: sideOf(S, 'foe', true).map(function (x) { return x.uid; }), party: sideOf(S, 'party', true).map(function (x) { return x.uid; }) } };
        return;
      }
      S.readyQueue.shift();
    }
  }
  function refreshAwaiting(S) {
    if (!S.awaiting) return;
    var u = unit(S, S.awaiting.actor);
    if (!u || u.ko) { S.awaiting = null; S.readyQueue.shift(); nextAwaiting(S); return; }
    S.awaiting.commands = commandsFor(S, u);
    S.awaiting.targets = { foe: sideOf(S, 'foe', true).map(function (x) { return x.uid; }), party: sideOf(S, 'party', true).map(function (x) { return x.uid; }) };
  }
  // A unit's turn begins: statuses tick, then party members wait for input and foes act.
  function beginTurn(S, u) {
    statusTurn(S, u);
    if (u.ko || S.result) return;
    u.ready = true;
    emit(S, 'ready', { actor: u.uid });
    if (u.side === 'party') { S.readyQueue.push(u.uid); nextAwaiting(S); return; }
    var ch = (u.gambit && chooseByRules(S, u, S.db.gmb[u.gambit])) || basicAttack(S, u);
    u.ready = false;
    if (!ch) return;
    commit(S, u, ch.abl, ch.targets);
  }
  function commit(S, u, ablId, targets) {
    var a = ablOf(S, ablId);
    u.turns++; S.turns++;
    emit(S, 'command', { actor: u.uid, abl: ablId, name: a ? a.name : '', targets: targets });
    if (S.sched === 'atb' && a && a.chargeTicks > 0) { u.charging = { abl: ablId, targets: targets, left: a.chargeTicks }; u.gauge = 0; return; }
    u.gauge = 0;
    if (S.sched === 'conditional' && a && a.chargeTicks > 0) u.nextAt += a.chargeTicks;
    perform(S, u, ablId, targets, false);
  }
  function checkEnd(S) {
    if (S.result) return;
    if (!sideOf(S, 'foe', true).length) S.result = finish(S, 'win');
    else if (!sideOf(S, 'party', true).length) S.result = finish(S, 'lose');
  }
  function finish(S, outcome, quiet) {
    var party = partyOf(S), hpEnd = 0, rewards = { gil: 0, exp: 0, ap: 0 };
    party.forEach(function (u) { hpEnd += u.hp; });
    if (outcome === 'win') foesOf(S).forEach(function (u) { rewards.gil += u.gil; rewards.exp += u.exp; rewards.ap += u.ap; });
    S.awaiting = null; S.readyQueue = [];
    var r = {
      outcome: outcome, ticks: S.t, turns: S.turns, preemptive: S.preemptive, rngCalls: S.rng.calls, rewards: rewards,
      partyEnd: party.map(function (u) { return { uid: u.uid, chr: u.ref, name: u.name, hp: u.hp, maxHp: u.maxHp, mp: u.mp, maxMp: u.maxMp, ko: u.ko, limitLevel: u.limit ? u.limit.level : 1, limitUses: u.limit ? u.limit.uses : 0, kills: u.kills }; }),
      resourcesUsed: {
        hpLost: Math.max(0, S.res.hpStart - hpEnd), mpSpent: S.res.mpSpent, items: S.res.itemsUsed,
        hpPct: S.res.hpMax ? Math.round(Math.max(0, S.res.hpStart - hpEnd) / S.res.hpMax * 1000) / 10 : 0,
        mpPct: S.res.mpMax ? Math.round(S.res.mpSpent / S.res.mpMax * 1000) / 10 : 0
      },
      damageLog: S.damageLog, warnings: S.db.warnings.slice(0, 20)
    };
    if (!quiet) emit(S, 'end', { value: outcome });
    return r;
  }

  // One unit of time for each scheduler.
  var SCHED = {
    atb: function (S) {
      S.units.forEach(function (u) {
        if (u.ko || S.result) return;
        var b = blockedBy(S, u);
        if (b) {
          if (b === 'empty') u.gauge = 0;
          if (++u.frozenTicks >= delayOf(S, u)) { u.frozenTicks = 0; statusTurn(S, u); }
          return;
        }
        if (u.charging) {
          if (--u.charging.left <= 0) { var c = u.charging; u.charging = null; perform(S, u, c.abl, c.targets, false); }
          return;
        }
        if (u.ready) return;
        u.gauge = Math.min(GAUGE_MAX, u.gauge + u.fill);
        if (u.gauge >= GAUGE_MAX) beginTurn(S, u);
      });
      S.t++;
    },
    rounds: function (S) {
      if (!S.round || S.round.i >= S.round.q.length) {
        var keyed = sideOf(S, 'party', true).concat(sideOf(S, 'foe', true)).map(function (u) { return { uid: u.uid, spd: num(u.stats.spd), k: rnd(S) }; });
        keyed.sort(function (a, b) { return b.spd - a.spd || b.k - a.k; });
        S.round = { n: S.round ? S.round.n + 1 : 1, q: keyed.map(function (x) { return x.uid; }), i: 0 };
      }
      var u = unit(S, S.round.q[S.round.i++]);
      S.t++;
      if (!u || u.ko) return;
      if (blockedBy(S, u)) { statusTurn(S, u); return; }
      beginTurn(S, u);
    },
    conditional: function (S) {
      var live = S.units.filter(function (u) { return !u.ko; }), u = null;
      live.forEach(function (x) { if (!u || x.nextAt < u.nextAt) u = x; });
      if (!u) return;
      S.t = Math.max(S.t + 1, u.nextAt);
      u.nextAt = S.t + delayOf(S, u);
      if (blockedBy(S, u)) { statusTurn(S, u); return; }
      beginTurn(S, u);
    }
  };
  function step(S, maxTicks) {
    var had = !!S.awaiting, n = 0, t0 = S.t;
    while (!S.result && n < maxTicks) {
      if (S.awaiting && (S.waitMode || S.sched !== 'atb')) break;
      if (S.awaiting && !had) break;
      SCHED[S.sched](S);
      n++;
      if (!S.result && S.t >= S.tickCap) S.result = finish(S, 'timeout');
    }
    if (S.t > t0) emit(S, 'tick', { value: S.t - t0 });
    return n;
  }
  function apply(S, input) {
    var aw = S.awaiting, u, a, tg, list, r;
    if (!aw || !input || input.actor !== aw.actor) { emit(S, 'miss', { actor: input && input.actor, value: 'rejected', name: 'No unit is waiting for that input.' }); return false; }
    u = unit(S, aw.actor);
    if (input.type === 'flee') {
      if (S.db.troop && S.db.troop.noEscape) { emit(S, 'miss', { actor: u.uid, value: 'flee', name: 'Cannot escape' }); return false; }
      var ps = sideOf(S, 'party', true), fs = sideOf(S, 'foe', true);
      var avg = function (l) { return l.reduce(function (s, x) { return s + num(x.stats.spd); }, 0) / Math.max(1, l.length); };
      var chance = clampN(0.5 + (avg(ps) - avg(fs)) / 100, 0.1, 0.9);
      u.ready = false; u.gauge = 0; S.readyQueue.shift(); S.awaiting = null; u.turns++; S.turns++;
      emit(S, 'command', { actor: u.uid, value: 'flee', name: 'Flee' });
      if (rnd(S) < chance) { S.result = finish(S, 'flee'); return true; }
      emit(S, 'miss', { actor: u.uid, value: 'flee', name: 'Could not escape' });
      nextAwaiting(S);
      return true;
    }
    a = ablOf(S, input.abl);
    var allowed = false;
    aw.commands.forEach(function (c) { c.abls.forEach(function (x) { if (x.id === input.abl && x.ok) allowed = true; }); });
    if (!a || !allowed) { emit(S, 'miss', { actor: u.uid, value: 'rejected', name: 'That ability is not available.' }); return false; }
    if (Array.isArray(input.targets) && input.targets.length) list = input.targets.map(function (id) { return unit(S, id); }).filter(function (x) { return x && !x.ko; });
    else {
      tg = input.target ? unit(S, input.target) : null;
      if (!tg || tg.ko) {
        var side = a.targeting.side === 'foe' ? 'foe' : 'party';
        if (a.targeting.side === 'self') tg = u;
        else { var pool = sideOf(S, side, true); tg = pool[0] || null; }
      }
      list = tg ? expand(S, u, a, [tg]) : [];
    }
    if (a.targeting.side === 'self') list = [u];
    if (!list.length) { emit(S, 'miss', { actor: u.uid, value: 'rejected', name: 'No target.' }); return false; }
    u.ready = false; S.readyQueue.shift(); S.awaiting = null;
    commit(S, u, a.id, list.map(function (x) { return x.uid; }));
    nextAwaiting(S);
    refreshAwaiting(S);
    r = true;
    return r;
  }

  function skipAwaiting(S) {
    var u = S.awaiting && unit(S, S.awaiting.actor);
    if (u) { u.ready = false; u.gauge = 0; u.turns++; }
    S.readyQueue.shift(); S.awaiting = null;
    nextAwaiting(S);
  }

  // ------------------------------------------------------------------ public API
  function out(S) {
    var e = EV; EV = null;
    return { state: S, events: e, awaiting: S.awaiting ? clone(S.awaiting) : null };
  }
  // advance never mutates its input. input: null (run to the next decision), {type:'step', ticks},
  // {type:'command', actor, abl, target | targets}, or {type:'flee', actor}.
  function advance(state, input) {
    var S = clone(state);
    EV = [];
    if (S.result) return out(S);
    if (input && (input.type === 'command' || input.type === 'flee')) apply(S, input);
    else step(S, input && input.type === 'step' ? Math.max(0, Math.floor(num(input.ticks, 1))) : S.tickCap);
    refreshAwaiting(S);
    return out(S);
  }
  // Drives advance with gambits for foes and the party policy until the battle ends.
  function run(data, seed, policy, opts) {
    opts = isObj(opts) ? opts : {};
    var S = init(data, seed, opts), all = [], keep = opts.events !== false, guard = 0, pol = isObj(policy) ? clone(policy) : null;
    EV = [];
    while (!S.result && guard++ < 200000) {
      if (S.awaiting) { if (!apply(S, policyInput(S, pol))) skipAwaiting(S); }
      else step(S, S.tickCap);
      if (keep) { Array.prototype.push.apply(all, EV); }
      EV = [];
    }
    if (!S.result) S.result = finish(S, 'timeout');
    if (keep) Array.prototype.push.apply(all, EV || []);
    EV = null;
    return { events: keep ? all : [], result: S.result };
  }
  // Rebuilds a battle from recorded inputs [{t, input}]. Inputs apply at the exact tick they were given.
  function replay(data, seed, opts, inputs) {
    var S = init(data, seed, opts), all = [], k, rec, guard, n;
    EV = [];
    for (k = 0; k < arr(inputs).length && !S.result; k++) {
      rec = inputs[k]; guard = 0;
      while (!S.result && S.t < num(rec.t) && guard++ < 1000000) {
        n = step(S, num(rec.t) - S.t);
        if (!n) break;
      }
      if (S.result) break;
      apply(S, rec.input);
      refreshAwaiting(S);
    }
    Array.prototype.push.apply(all, EV); EV = null;
    return { state: S, events: all, awaiting: S.awaiting ? clone(S.awaiting) : null };
  }
  // The input the party policy would give for the unit awaiting a command (default policy when none is supplied).
  function suggest(state, policy) {
    if (!state || !state.awaiting || state.result) return null;
    var S = clone(state), e = EV, r;
    EV = null;
    r = policyInput(S, isObj(policy) ? clone(policy) : null);
    EV = e;
    return r;
  }
  // Turn order forecast for the conditional scheduler (and an estimate for the others).
  function forecast(state, n) {
    var sim = state.units.filter(function (u) { return !u.ko; }).map(function (u) { return { uid: u.uid, at: state.sched === 'conditional' ? u.nextAt : Math.ceil((GAUGE_MAX - u.gauge) / u.fill), d: Math.ceil(GAUGE_MAX / u.fill) }; });
    var list = [], i, best;
    for (i = 0; i < (n || 6) && sim.length; i++) {
      best = sim[0];
      sim.forEach(function (x) { if (x.at < best.at) best = x; });
      list.push(best.uid); best.at += best.d;
    }
    return list;
  }

  return {
    version: VERSION, templates: TEMPLATES, evalExpr: expr, gaugeMax: GAUGE_MAX,
    schedulers: Object.keys(SCHEDULERS), progressions: Object.keys(PROGRESSIONS),
    init: init, advance: advance, run: run, replay: replay, forecast: forecast, suggest: suggest
  };
})();
// === ENGINE:BATTLE END ===
// === WS:ARENA BEGIN ===
(function () {
  'use strict';
  var U = Kit.util, el = function (t, c, h) { return U.el(t, c, h); }, esc = U.esc;
  var WSX = window.WS.arena = { id: 'arena' };
  var SETUP_KEY = 'saga146:arena:setup';
  var PARTY_MAX = 4;
  var PARTY_TINTS = ['#e3b453', '#6fc7b6', '#e07a9a', '#8fa8ff', '#b7d56b', '#f09a5a', '#c89cf0', '#66b8e0'];

  function cur() { return Kit.bundle.current(); }
  function count(b, p) { return b && b.rules && b.rules[p] ? Object.keys(b.rules[p]).length : 0; }
  function recs(b, p) { var o = b && b.rules && b.rules[p] ? b.rules[p] : {}; return Object.keys(o).map(function (k) { return o[k]; }).filter(function (r) { return U.isObj(r) && r.id; }); }
  function recOf(b, id) { var p = Kit.ids.prefixOf(id); return p && b.rules && b.rules[p] && b.rules[p][id] ? b.rules[p][id] : null; }
  function num(v, d) { return typeof v === 'number' && isFinite(v) ? v : (d === undefined ? 0 : d); }
  function rs(b) { return (b && b.charter && b.charter.ruleset) || {}; }
  function chapters(b) { return window.WS.rules && WS.rules.content ? WS.rules.content.chaptersOf(b) : []; }
  function epsFor(b, chId) { var l = recs(b, 'eps_'); for (var i = 0; i < l.length; i++) if (l[i].chapter === chId) return l[i]; return null; }
  function resolution(b) { return window.WS.charter && WS.charter.resolution ? WS.charter.resolution(b) : { w: 256, h: 224 }; }
  function randomSeed() { return Math.floor(Math.random() * 2147483646) + 1; }

  WSX.canEnter = function (b) {
    var r = window.WS.rules.canEnter(b);
    if (r !== true) return r;
    return count(b, 'trp_') ? true : 'Author a troop in Rules to open the Arena.';
  };

  // ------------------------------------------------------------------ party building (shared with the Simulator)
  function bestGear(b, slot, weaponClass, tier) {
    var best = null;
    recs(b, 'eqp_').forEach(function (e) {
      if (e.slot !== slot) return;
      if (slot === 'weapon' && e.weaponClass && weaponClass && String(e.weaponClass).toLowerCase() !== String(weaponClass).toLowerCase()) return;
      var t = num(e.tier, 1);
      if (t > tier) return;
      if (!best || t > num(best.tier, 1) || (t === num(best.tier, 1) && num(e.price) > num(best.price))) best = e;
    });
    return best;
  }
  // Places materia into the party gear: each support materia takes a free linked pair beside the next non support materia,
  // then everything else fills free slots member by member.
  function placeMateria(b, members, matIds) {
    var slots = [];
    members.forEach(function (m, mi) {
      (m.equipment || []).forEach(function (eid) {
        var e = recOf(b, eid), lay = e && U.isObj(e.slotLayout) ? e.slotLayout : null, n = lay ? Math.max(0, Math.min(8, num(lay.count))) : 0;
        for (var i = 0; i < n; i++) slots.push({ mi: mi, eqp: eid, slot: i, links: (lay.links || []).filter(function (l) { return Array.isArray(l) && (l[0] === i || l[1] === i); }), used: false });
      });
    });
    var mats = (matIds || []).map(function (id) { return recOf(b, id); }).filter(Boolean);
    var supports = mats.filter(function (m) { return m.kind === 'support'; }), others = mats.filter(function (m) { return m.kind !== 'support'; });
    function free(eqp, mi, s) { for (var i = 0; i < slots.length; i++) if (slots[i].mi === mi && slots[i].eqp === eqp && slots[i].slot === s && !slots[i].used) return slots[i]; return null; }
    function put(sl, m) { sl.used = true; members[sl.mi].materia.push({ eqp: sl.eqp, slot: sl.slot, mat: m.id, ap: 0 }); }
    supports.forEach(function (sm) {
      var partner = others[0], done = false;
      slots.forEach(function (sl) {
        if (done || sl.used) return;
        sl.links.forEach(function (l) {
          if (done) return;
          var o = l[0] === sl.slot ? l[1] : l[0], os = free(sl.eqp, sl.mi, o);
          if (!os) return;
          put(sl, sm); done = true;
          if (partner) { put(os, partner); others.shift(); }
        });
      });
      if (!done) others.push(sm);
    });
    var mi = 0;
    others.forEach(function (m) {
      var tries = 0, sl = null;
      while (!sl && tries < members.length) {
        for (var i = 0; i < slots.length; i++) if (!slots[i].used && slots[i].mi === (mi + tries) % members.length) { sl = slots[i]; break; }
        tries++;
      }
      if (!sl) for (var j = 0; j < slots.length; j++) if (!slots[j].used) { sl = slots[j]; break; }
      if (sl) { put(sl, m); mi = (sl.mi + 1) % Math.max(1, members.length); }
    });
    return members;
  }
  // cfg = {chars:[chr ids], source:'custom'|chp id, level, gearTier, materia:[mat ids], jobs:{chr: job}, classes:{chr: cls}, rows:{chr: row}}
  WSX.buildParty = function (b, cfg) {
    b = b || cur(); cfg = cfg || {};
    var prog = rs(b).progression, eps = cfg.source && cfg.source !== 'custom' ? epsFor(b, cfg.source) : null;
    var level = eps ? num(eps.targetLevel, 1) : num(cfg.level, 10);
    var tier = eps ? num(eps.gearTier, 1) : num(cfg.gearTier, 1);
    var chars = (cfg.chars || []).map(function (id) { return recOf(b, id); }).filter(Boolean).slice(0, PARTY_MAX);
    var members = chars.map(function (c, i) {
      var eq = ['weapon', 'armor', 'accessory'].map(function (s) { return bestGear(b, s, c.weaponClass, tier); }).filter(Boolean).map(function (e) { return e.id; });
      var m = { chr: c.id, level: Math.max(1, Math.min(99, Math.round(level))), equipment: eq, materia: [], abilities: eps && Array.isArray(eps.abilities) ? eps.abilities.slice() : [], row: (cfg.rows && cfg.rows[c.id]) || 'front' };
      if (prog === 'jobs') { var js = eps && Array.isArray(eps.jobSet) && eps.jobSet.length ? eps.jobSet : null; m.job = js ? js[i % js.length] : (cfg.jobs && cfg.jobs[c.id]) || null; m.jobLevel = m.level; }
      if (prog === 'classes') { var cs = eps && Array.isArray(eps.classSet) && eps.classSet.length ? eps.classSet : null; m.cls = cs ? cs[i % cs.length] : (cfg.classes && cfg.classes[c.id]) || null; }
      return m;
    });
    if (prog === 'materia') placeMateria(b, members, eps ? (eps.materiaSet || []) : (cfg.materia || []));
    return members;
  };
  // Expected Party State for a chapter: the first PARTY_MAX characters unless chars is given.
  WSX.expectedParty = function (b, chapterId, chars) {
    b = b || cur();
    return WSX.buildParty(b, { source: chapterId, chars: chars && chars.length ? chars : recs(b, 'chr_').slice(0, PARTY_MAX).map(function (c) { return c.id; }) });
  };
  WSX.dataFor = function (b, troopId, party, weatherId) {
    b = b || cur();
    return { ruleset: rs(b), records: b.rules || {}, party: party, troopId: troopId, weatherId: weatherId || null };
  };

  // ------------------------------------------------------------------ battle codes
  function b64enc(str) { return btoa(unescape(encodeURIComponent(str))); }
  function b64dec(str) { return decodeURIComponent(escape(atob(String(str).replace(/\s+/g, '')))); }
  WSX.encodeCode = function (o) { return b64enc(JSON.stringify(o)); };
  WSX.decodeCode = function (code) {
    var o = JSON.parse(b64dec(code));
    if (!U.isObj(o) || !o.troopId || !Array.isArray(o.party) || typeof o.seed !== 'number' || !Array.isArray(o.inputs)) throw new Error('That is not a Saga Forge battle code.');
    return o;
  };

  // ------------------------------------------------------------------ pixel font (3 by 5)
  var GLYPHS = {
    A: '25755', B: '65656', C: '34443', D: '65556', E: '74647', F: '74644', G: '34553', H: '55755', I: '72227', J: '11152',
    K: '55655', L: '44447', M: '57755', N: '65555', O: '25552', P: '65644', Q: '25563', R: '65655', S: '34216', T: '72222',
    U: '55557', V: '55552', W: '55775', X: '55255', Y: '55222', Z: '71247',
    '0': '75557', '1': '26227', '2': '61247', '3': '61216', '4': '55711', '5': '74616', '6': '34757', '7': '71222', '8': '75757', '9': '75716',
    ' ': '00000', '/': '11244', ':': '02020', '.': '00002', '-': '00700', '+': '02720', '!': '22202', '?': '61202', '%': '51245', "'": '22000', ',': '00024'
  };
  function textW(s, sc) { return String(s).length * 4 * (sc || 1) - (sc || 1); }
  function drawText(g, s, x, y, color, sc, shadow) {
    sc = sc || 1; s = String(s).toUpperCase();
    if (shadow !== false) drawText(g, s, x + sc, y + sc, 'rgba(0,0,0,.85)', sc, false);
    g.fillStyle = color;
    for (var i = 0; i < s.length; i++) {
      var gl = GLYPHS[s.charAt(i)] || GLYPHS['?'];
      for (var r = 0; r < 5; r++) {
        var bits = +gl.charAt(r);
        if (bits & 4) g.fillRect(x + i * 4 * sc, y + r * sc, sc, sc);
        if (bits & 2) g.fillRect(x + i * 4 * sc + sc, y + r * sc, sc, sc);
        if (bits & 1) g.fillRect(x + i * 4 * sc + 2 * sc, y + r * sc, sc, sc);
      }
    }
  }
  function shortName(n, max) { n = String(n || '').toUpperCase().replace(/[^A-Z0-9 ]/g, ''); return n.length > max ? n.slice(0, max) : n; }

  // ------------------------------------------------------------------ procedural sprites (arcTo and rect only)
  function rr(g, x, y, w, h, r) {
    r = Math.max(0, Math.min(r, w / 2, h / 2));
    g.beginPath();
    g.moveTo(x + r, y);
    g.arcTo(x + w, y, x + w, y + h, r);
    g.arcTo(x + w, y + h, x, y + h, r);
    g.arcTo(x, y + h, x, y, r);
    g.arcTo(x, y, x + w, y, r);
    g.closePath();
    g.fill();
  }
  function hashStr(s) { var h = 2166136261; s = String(s || ''); for (var i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 16777619); } return h >>> 0; }
  function mulberry(a) { return function () { a = (a + 0x6D2B79F5) | 0; var t = Math.imul(a ^ (a >>> 15), 1 | a); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; }
  function hexRgb(h) { var m = /^#?([0-9a-f]{6})$/i.exec(String(h || '')); if (!m) return null; var n = parseInt(m[1], 16); return [(n >> 16) & 255, (n >> 8) & 255, n & 255]; }
  function rgbHex(c) { return '#' + c.map(function (v) { v = Math.max(0, Math.min(255, Math.round(v))); return (v < 16 ? '0' : '') + v.toString(16); }).join(''); }
  function hueShift(hex, deg) {
    if (window.WS.rules && WS.rules.content && WS.rules.content.shiftHex) { try { return WS.rules.content.shiftHex(hex, deg); } catch (e) {} }
    var c = hexRgb(hex); if (!c) return hex;
    var a = deg * Math.PI / 180, cs = Math.cos(a), sn = Math.sin(a), r = c[0], g = c[1], bb = c[2];
    return rgbHex([
      r * (.213 + cs * .787 - sn * .213) + g * (.715 - cs * .715 - sn * .715) + bb * (.072 - cs * .072 + sn * .928),
      r * (.213 - cs * .213 + sn * .143) + g * (.715 + cs * .285 + sn * .140) + bb * (.072 - cs * .072 - sn * .283),
      r * (.213 - cs * .213 - sn * .787) + g * (.715 - cs * .715 + sn * .715) + bb * (.072 + cs * .928 + sn * .072)
    ]);
  }
  function shade(hex, f) { var c = hexRgb(hex); return c ? rgbHex(c.map(function (v) { return f < 0 ? v * (1 + f) : v + (255 - v) * f; })) : hex; }
  var spriteCache = {};
  function makeCanvas(w, h) { var c = document.createElement('canvas'); c.width = w; c.height = h; return c; }
  // Symmetric blob from seeded shapes. Every off center shape is drawn twice, mirrored about the vertical axis.
  function foeSprite(famId, tier, palette, size) {
    var base = (palette && palette.base) || '#7a6f9e', acc = (palette && palette.accent) || '#e3b453';
    if (tier > 1) acc = hueShift(acc, (tier - 1) * 40);
    var key = famId + '|' + tier + '|' + base + '|' + acc + '|' + size;
    if (spriteCache[key]) return spriteCache[key];
    var R = mulberry(hashStr(famId || 'none')), S = size, c = makeCanvas(S, S), g = c.getContext('2d');
    function sym(fn) { fn(false); fn(true); }
    function mx(x, w, m) { return m ? S - x - w : x; }
    g.fillStyle = base;
    var bw = Math.round(S * (0.42 + R() * 0.3)), bh = Math.round(S * (0.34 + R() * 0.28)), by = S - bh - Math.round(S * 0.08);
    rr(g, (S - bw) / 2, by, bw, bh, Math.round(bh * (0.2 + R() * 0.3)));
    var hasHead = R() < 0.7, hw = Math.round(bw * (0.45 + R() * 0.3)), hh = Math.round(S * (0.18 + R() * 0.12)), hy = by - hh + Math.round(hh * 0.3);
    if (hasHead) rr(g, (S - hw) / 2, hy, hw, hh, Math.round(hh * 0.4));
    var topY = hasHead ? hy : by;
    var limbs = 1 + Math.floor(R() * 3);
    for (var i = 0; i < limbs; i++) {
      var lw = Math.max(2, Math.round(S * (0.08 + R() * 0.12))), lh = Math.max(3, Math.round(S * (0.12 + R() * 0.25)));
      var lx = Math.round((S - bw) / 2 - lw * (0.3 + R() * 0.6)), ly = Math.round(by + R() * (bh - lh * 0.6));
      var round = R() < 0.5;
      sym(function (m) { if (round) rr(g, mx(lx, lw, m), ly, lw, lh, lw / 2); else g.fillRect(mx(lx, lw, m), ly, lw, lh); });
    }
    if (R() < 0.6) {
      var ew = Math.max(2, Math.round(S * (0.05 + R() * 0.07))), eh = Math.max(3, Math.round(S * (0.1 + R() * 0.14))), ex = Math.round(S / 2 - hw / 2 + R() * hw * 0.3);
      sym(function (m) { rr(g, mx(ex, ew, m), topY - eh + 2, ew, eh, ew / 2); });
    }
    if (R() < 0.35) g.fillRect(Math.round(S / 2 - 1), Math.max(0, topY - Math.round(S * 0.12)), 2, Math.round(S * 0.14));
    // shading on the lower half
    g.globalCompositeOperation = 'source-atop';
    g.fillStyle = 'rgba(0,0,0,.28)'; g.fillRect(0, Math.round(by + bh * 0.55), S, S);
    g.fillStyle = 'rgba(255,255,255,.12)'; g.fillRect(0, 0, S, Math.round(topY + 3));
    // accent: belly and eyes
    g.fillStyle = acc;
    if (R() < 0.6) { var sw = Math.round(bw * 0.4), sh = Math.max(2, Math.round(bh * 0.3)); rr(g, (S - sw) / 2, by + Math.round(bh * 0.35), sw, sh, sh / 2); }
    var eyeY = hasHead ? hy + Math.round(hh * 0.4) : by + Math.round(bh * 0.2), eyeX = Math.round(S / 2 - Math.max(3, (hasHead ? hw : bw) * (0.14 + R() * 0.12)));
    var es = Math.max(1, Math.round(S / 16));
    sym(function (m) { g.fillRect(mx(eyeX, es + 1, m), eyeY, es + 1, es + 1); });
    g.globalCompositeOperation = 'source-over';
    // outline
    var o = makeCanvas(S + 2, S + 2), og = o.getContext('2d');
    var mask = makeCanvas(S, S), mg = mask.getContext('2d');
    mg.drawImage(c, 0, 0); mg.globalCompositeOperation = 'source-in'; mg.fillStyle = '#07080d'; mg.fillRect(0, 0, S, S);
    [[0, 1], [2, 1], [1, 0], [1, 2]].forEach(function (d) { og.drawImage(mask, d[0], d[1]); });
    og.drawImage(c, 1, 1);
    spriteCache[key] = o;
    return o;
  }
  function weaponGlyph(g, cls, x, y, color) {
    cls = String(cls || '').toLowerCase();
    g.fillStyle = color;
    if (/staff|rod|wand|cane/.test(cls)) { g.fillRect(x, y - 10, 1, 16); g.fillStyle = '#9ad1ff'; rr(g, x - 1, y - 13, 3, 3, 1); }
    else if (/axe|hammer|mace/.test(cls)) { g.fillRect(x, y - 8, 1, 13); g.fillRect(x - 3, y - 9, 4, 4); }
    else if (/bow|gun|rifle/.test(cls)) { g.fillRect(x - 2, y - 8, 1, 12); g.fillRect(x - 1, y - 9, 1, 1); g.fillRect(x - 1, y + 4, 1, 1); g.fillStyle = 'rgba(255,255,255,.5)'; g.fillRect(x, y - 8, 1, 12); }
    else if (/spear|lance|pole/.test(cls)) { g.fillRect(x, y - 12, 1, 18); g.fillStyle = '#e8e8e8'; g.fillRect(x - 1, y - 14, 3, 3); }
    else if (/claw|fist|glove/.test(cls)) { g.fillStyle = '#e8e8e8'; g.fillRect(x - 3, y, 3, 1); g.fillRect(x - 3, y + 2, 3, 1); }
    else { g.fillStyle = '#e8e8e8'; g.fillRect(x, y - 11, 1, 12); g.fillStyle = color; g.fillRect(x - 2, y, 5, 1); g.fillRect(x, y + 1, 1, 3); }
  }

  // ------------------------------------------------------------------ view state
  var V = null; // the running battle view
  function stopLoop() { if (V && V.raf) { cancelAnimationFrame(V.raf); V.raf = 0; } }
  function loadSetup() {
    var s = Kit.store.get(SETUP_KEY);
    return U.isObj(s) ? s : {};
  }
  function saveSetup(s) { Kit.store.set(SETUP_KEY, s); }
  function defaultSetup(b) {
    var s = loadSetup(), troops = recs(b, 'trp_'), chars = recs(b, 'chr_');
    if (!s.troopId || !recOf(b, s.troopId)) s.troopId = troops[0] ? troops[0].id : null;
    s.chars = (Array.isArray(s.chars) ? s.chars : []).filter(function (id) { return recOf(b, id); });
    if (!s.chars.length) s.chars = chars.slice(0, Math.min(3, PARTY_MAX)).map(function (c) { return c.id; });
    if (!s.source || (s.source !== 'custom' && !epsFor(b, s.source))) {
      var tr = s.troopId && recOf(b, s.troopId), ch = tr && tr.chapter && epsFor(b, tr.chapter) ? tr.chapter : null;
      s.source = ch || 'custom';
    }
    if (typeof s.level !== 'number') s.level = 10;
    if (typeof s.gearTier !== 'number') s.gearTier = 1;
    if (!Array.isArray(s.materia)) s.materia = [];
    s.materia = s.materia.filter(function (id) { return recOf(b, id); });
    if (!U.isObj(s.jobs)) s.jobs = {};
    if (!U.isObj(s.classes)) s.classes = {};
    if (!U.isObj(s.rows)) s.rows = {};
    if (s.weatherId && !recOf(b, s.weatherId)) s.weatherId = null;
    if (typeof s.seed !== 'number' || !isFinite(s.seed)) s.seed = randomSeed();
    var bt = rs(b).battle || {};
    if (typeof s.waitMode !== 'boolean') s.waitMode = bt.waitMode !== false;
    if ([1, 2, 4].indexOf(s.speed) < 0) s.speed = 1;
    return s;
  }

  // ------------------------------------------------------------------ render
  WSX.render = function (host) {
    stopLoop();
    var b = cur(), setup = defaultSetup(b);
    var wrap = el('div', 'ar-wrap');
    host.appendChild(wrap);
    var left = el('section', 'panel ar-setup');
    var right = el('section', 'panel ar-stagepanel');
    wrap.appendChild(left); wrap.appendChild(right);
    V = { host: host, setup: setup, b: b, right: right };
    paintSetup(left, b, setup);
    paintStage(right, b);
    if (WSX._pending) { var p = WSX._pending; WSX._pending = null; if (p.code) playCode(p.code); else if (p.start) startBattle(); }
  };

  function field(label, node, help) {
    var f = el('div', 'field');
    var l = el('label', 'field-label'); l.textContent = label;
    if (node.id) l.htmlFor = node.id;
    f.appendChild(l);
    var body = el('div', 'field-body'); body.appendChild(node); f.appendChild(body);
    if (help) { var h = el('div', 'field-help'); h.textContent = help; f.appendChild(h); }
    return f;
  }
  function select(id, options, value, onChange) {
    var s = el('select', 'inp'); s.id = id;
    options.forEach(function (o) { var op = el('option'); op.value = o.value; op.textContent = o.label; if (String(o.value) === String(value)) op.selected = true; s.appendChild(op); });
    s.addEventListener('change', function () { onChange(s.value); });
    return s;
  }
  function seg(values, value, onChange, labelFor) {
    var box = el('div', 'ar-seg'); box.setAttribute('role', 'group');
    values.forEach(function (v) {
      var bt = el('button'); bt.type = 'button'; bt.textContent = labelFor ? labelFor(v) : String(v);
      bt.setAttribute('aria-pressed', v === value ? 'true' : 'false');
      bt.addEventListener('click', function () { U.clear(box); box.parentNode.replaceChild(seg(values, v, onChange, labelFor), box); onChange(v); });
      box.appendChild(bt);
    });
    return box;
  }

  function paintSetup(box, b, s) {
    U.clear(box);
    var R = rs(b), prog = R.progression;
    box.appendChild(el('h2', 'panel-title', 'Battle Setup'));
    var grid = el('div', 'form-grid');
    box.appendChild(grid);
    // troop
    var chs = chapters(b), chName = {};
    chs.forEach(function (c, i) { chName[c.id] = 'Ch ' + (i + 1) + ': ' + (c.name || c.id); });
    var troopOpts = recs(b, 'trp_').map(function (t) { return { value: t.id, label: (t.name || t.id) + (t.chapter && chName[t.chapter] ? ' (' + chName[t.chapter] + ')' : '') }; });
    grid.appendChild(field('Troop', select('arTroop', troopOpts, s.troopId, function (v) { s.troopId = v; var tr = recOf(b, v); if (tr && tr.chapter && epsFor(b, tr.chapter) && s.source !== 'custom') s.source = tr.chapter; saveSetup(s); paintSetup(box, b, s); })));
    // weather
    var wOpts = [{ value: '', label: 'Clear (no weather)' }].concat(recs(b, 'wth_').map(function (w) { return { value: w.id, label: (w.name || w.id) + (w.realWorld ? ', ' + w.realWorld : '') }; }));
    grid.appendChild(field('Weather', select('arWeather', wOpts, s.weatherId || '', function (v) { s.weatherId = v || null; saveSetup(s); })));
    // party
    box.appendChild(el('h3', 'section-h', 'Party'));
    var chars = recs(b, 'chr_');
    if (!chars.length) box.appendChild(el('div', 'empty-line', 'Author characters in Rules to field a party.'));
    var pick = el('div', 'ar-chars');
    chars.forEach(function (c, i) {
      var on = s.chars.indexOf(c.id) >= 0;
      var bt = el('button', 'ar-pick', '<span class="dot" style="background:' + PARTY_TINTS[i % PARTY_TINTS.length] + '"></span>' + esc(c.name || c.id));
      bt.type = 'button'; bt.setAttribute('aria-pressed', on ? 'true' : 'false');
      bt.addEventListener('click', function () {
        var k = s.chars.indexOf(c.id);
        if (k >= 0) s.chars.splice(k, 1);
        else { if (s.chars.length >= PARTY_MAX) { Kit.ui.toast('A party holds up to ' + PARTY_MAX + ' characters.', 'warn'); return; } s.chars.push(c.id); }
        saveSetup(s); paintSetup(box, b, s);
      });
      pick.appendChild(bt);
    });
    box.appendChild(pick);
    // source
    var srcOpts = [{ value: 'custom', label: 'Custom level and gear' }];
    chs.forEach(function (c) { if (epsFor(b, c.id)) srcOpts.push({ value: c.id, label: 'Use ' + chName[c.id] + ' expected state' }); });
    var g2 = el('div', 'form-grid'); g2.style.marginTop = '10px';
    box.appendChild(g2);
    g2.appendChild(field('Level and gear', select('arSource', srcOpts, s.source, function (v) { s.source = v; saveSetup(s); paintSetup(box, b, s); })));
    if (s.source !== 'custom') {
      var e = epsFor(b, s.source);
      var note = el('p', 'ar-note');
      note.textContent = e ? 'Level ' + num(e.targetLevel, 1) + ', gear tier ' + num(e.gearTier, 1) + (prog === 'materia' ? ', ' + ((e.materiaSet || []).length) + ' materia' : prog === 'jobs' ? ', ' + ((e.jobSet || []).length) + ' jobs' : prog === 'classes' ? ', ' + ((e.classSet || []).length) + ' classes' : '') + ', ' + ((e.abilities || []).length) + ' extra abilities. Gear is the best stocked piece at that tier.' : '';
      box.appendChild(note);
    } else {
      var lv = el('input', 'inp'); lv.type = 'number'; lv.min = 1; lv.max = 99; lv.id = 'arLevel'; lv.value = s.level;
      lv.addEventListener('change', function () { s.level = Math.max(1, Math.min(99, Math.round(+lv.value || 1))); lv.value = s.level; saveSetup(s); });
      g2.appendChild(field('Level', lv));
      var gt = el('input', 'inp'); gt.type = 'number'; gt.min = 1; gt.max = 20; gt.id = 'arTier'; gt.value = s.gearTier;
      gt.addEventListener('change', function () { s.gearTier = Math.max(1, Math.min(20, Math.round(+gt.value || 1))); gt.value = s.gearTier; saveSetup(s); });
      g2.appendChild(field('Gear tier', gt));
      if (prog === 'materia') {
        var mats = recs(b, 'mat_');
        box.appendChild(el('h3', 'section-h', 'Materia'));
        if (!mats.length) box.appendChild(el('div', 'empty-line', 'No materia authored yet.'));
        var mp = el('div', 'ar-chars');
        mats.forEach(function (m) {
          var on = s.materia.indexOf(m.id) >= 0;
          var bt = el('button', 'ar-pick', esc(m.name || m.id) + ' <small class="muted">' + esc(m.kind || '') + '</small>');
          bt.type = 'button'; bt.setAttribute('aria-pressed', on ? 'true' : 'false');
          bt.addEventListener('click', function () { var k = s.materia.indexOf(m.id); if (k >= 0) s.materia.splice(k, 1); else s.materia.push(m.id); saveSetup(s); bt.setAttribute('aria-pressed', k >= 0 ? 'false' : 'true'); });
          mp.appendChild(bt);
        });
        box.appendChild(mp);
        box.appendChild(el('p', 'ar-note', 'Support materia is placed in a linked pair beside the next materia you picked.'));
      } else if (prog === 'jobs' || prog === 'classes') {
        var pre = prog === 'jobs' ? 'job_' : 'cls_', bag = prog === 'jobs' ? s.jobs : s.classes, list = recs(b, pre);
        var cust = el('div', 'ar-cust');
        s.chars.forEach(function (id) {
          var c = recOf(b, id); if (!c) return;
          var row = el('div', 'ar-crow');
          row.appendChild(el('span', '', esc(c.name || id)));
          row.appendChild(select('arMod_' + id, [{ value: '', label: 'No ' + (prog === 'jobs' ? 'job' : 'class') }].concat(list.map(function (x) { return { value: x.id, label: x.name || x.id }; })), bag[id] || '', function (v) { bag[id] = v || null; saveSetup(s); }));
          cust.appendChild(row);
        });
        box.appendChild(cust);
      }
    }
    // rows
    if (s.chars.length) {
      box.appendChild(el('h3', 'section-h', 'Rows'));
      var rowsBox = el('div', 'ar-cust');
      s.chars.forEach(function (id) {
        var c = recOf(b, id); if (!c) return;
        var row = el('div', 'ar-crow');
        row.appendChild(el('span', '', esc(c.name || id)));
        row.appendChild(seg(['front', 'back'], s.rows[id] || 'front', function (v) { s.rows[id] = v; saveSetup(s); }, function (v) { return v === 'front' ? 'Front' : 'Back'; }));
        rowsBox.appendChild(row);
      });
      box.appendChild(rowsBox);
    }
    // seed, mode, speed
    box.appendChild(el('h3', 'section-h', 'Run'));
    var g3 = el('div', 'form-grid');
    box.appendChild(g3);
    var seedRow = el('div', 'ar-seedrow');
    var si = el('input', 'inp'); si.type = 'number'; si.id = 'arSeed'; si.value = s.seed; si.min = 1; si.step = 1;
    si.addEventListener('change', function () { var v = Math.floor(+si.value); if (!isFinite(v) || v < 1) v = 1; s.seed = v; si.value = v; saveSetup(s); });
    var rb = el('button', 'btn btn-icon', Kit.icon('spark')); rb.type = 'button'; rb.title = 'Random seed'; rb.setAttribute('aria-label', 'Random seed');
    rb.addEventListener('click', function () { s.seed = randomSeed(); si.value = s.seed; saveSetup(s); });
    seedRow.appendChild(si); seedRow.appendChild(rb);
    g3.appendChild(field('Seed', seedRow));
    var atb = (R.scheduler || 'atb') === 'atb';
    g3.appendChild(field('Time mode', seg([true, false], s.waitMode, function (v) { s.waitMode = v; saveSetup(s); }, function (v) { return v ? 'Wait' : 'Active'; }), atb ? 'Wait pauses the gauges while you choose.' : 'The ' + (R.scheduler || 'atb') + ' scheduler always waits for your command.'));
    g3.appendChild(field('Battle speed', seg([1, 2, 4], s.speed, function (v) { s.speed = v; saveSetup(s); if (V) V.speed = v; }, function (v) { return v + 'x'; })));
    var go = el('div', 'btn-row'); go.style.marginTop = '12px';
    var start = el('button', 'btn btn-primary', Kit.icon('sword') + '<span>Start battle</span>'); start.type = 'button'; start.id = 'arStart';
    start.addEventListener('click', function () { startBattle(); });
    var paste = el('button', 'btn', Kit.icon('import') + '<span>Paste battle code</span>'); paste.type = 'button';
    paste.addEventListener('click', pasteCode);
    go.appendChild(start); go.appendChild(paste);
    box.appendChild(go);
  }

  function paintStage(box, b) {
    U.clear(box);
    var head = el('div', 'ar-head');
    head.appendChild(el('h2', 'panel-title', 'Arena'));
    var st = el('span', 'ar-status'); st.id = 'arStatus'; head.appendChild(st);
    box.appendChild(head);
    var stage = el('div', 'ar-stage'); stage.id = 'arStage';
    stage.innerHTML = '<div class="ar-empty"><h3>Choose a troop and start</h3><p>Every battle is seeded, so the same seed and the same commands replay exactly. Copy a battle code to share a fight.</p></div>';
    var sb = el('button', 'btn btn-primary', Kit.icon('sword') + '<span>Start battle</span>'); sb.type = 'button';
    sb.addEventListener('click', function () { startBattle(); });
    stage.firstChild.appendChild(sb);
    box.appendChild(stage);
    var menu = el('div', 'ar-menu'); menu.id = 'arMenu'; menu.hidden = true; box.appendChild(menu);
    var res = el('div', 'card ar-result'); res.id = 'arResult'; res.hidden = true; box.appendChild(res);
    var ctr = el('div', 'ar-controls'); ctr.id = 'arControls'; box.appendChild(ctr);
    paintControls();
  }
  function paintControls() {
    var ctr = document.getElementById('arControls');
    if (!ctr) return;
    U.clear(ctr);
    var live = !!(V && V.S);
    function btn(label, icon, fn, o) {
      var x = el('button', 'btn' + (o && o.kind ? ' btn-' + o.kind : ''), (icon ? Kit.icon(icon) : '') + '<span>' + esc(label) + '</span>');
      x.type = 'button'; if (o && o.disabled) x.disabled = true; if (o && o.pressed != null) x.setAttribute('aria-pressed', o.pressed ? 'true' : 'false');
      x.addEventListener('click', fn); ctr.appendChild(x); return x;
    }
    btn('New battle', 'sword', function () { startBattle(); }, { kind: 'primary', disabled: !live });
    btn(V && V.auto ? 'Auto: on' : 'Auto: off', 'spark', function () { if (!V) return; V.auto = !V.auto; paintControls(); if (V.auto) closeMenu(); }, { disabled: !live || (V && V.playback), pressed: !!(V && V.auto) });
    btn('Replay same seed', 'up', function () { if (V && V.last) startBattle(V.last.cfgSeed); }, { disabled: !(V && V.last) });
    btn('Watch replay', 'jump', function () { if (V && V.last && V.last.code) playCode(V.last.code); }, { disabled: !(V && V.last && V.last.code && V.last.inputs && V.last.inputs.length) });
    btn('Copy battle code', 'export', copyCode, { disabled: !(V && V.last && V.last.code) });
    btn('Battle log', 'book', openLog, { disabled: !(V && V.S) });
  }
  function status(t) { var s = document.getElementById('arStatus'); if (s) s.textContent = t || ''; }

  // ------------------------------------------------------------------ battle lifecycle
  function startBattle(seedOverride, preset) {
    var b = cur(), s = V ? V.setup : defaultSetup(b);
    if (!recOf(b, s.troopId)) { Kit.ui.toast('Choose a troop first.', 'warn'); return; }
    var party = preset ? preset.party : WSX.buildParty(b, s);
    if (!party.length) { Kit.ui.toast('Pick at least one character for the party.', 'warn'); return; }
    var seed = preset ? preset.seed : (typeof seedOverride === 'number' ? seedOverride : s.seed);
    var troopId = preset ? preset.troopId : s.troopId, weatherId = preset ? preset.weatherId || null : s.weatherId || null;
    var opts = preset ? (preset.opts || {}) : { waitMode: s.waitMode };
    var data = WSX.dataFor(b, troopId, party, weatherId);
    var S;
    try { S = ENGINE_BATTLE.init(data, seed, opts); }
    catch (e) { Kit.ui.toast('The battle could not start: ' + e.message, 'error'); console.error(e); return; }
    if (!V) return;
    stopLoop();
    V.S = S; V.data = data; V.seed = seed; V.opts = opts; V.party = party; V.troopId = troopId; V.weatherId = weatherId;
    V.inputs = []; V.log = []; V.queue = []; V.popups = []; V.anim = null; V.flash = {}; V.fade = {}; V.acc = 0; V.lastTs = 0; V.idle = 0;
    V.playback = preset && preset.inputs ? { inputs: preset.inputs.slice(), i: 0, expect: preset.end || null } : null;
    V.auto = V.playback ? false : !!V.auto;
    V.speed = V.setup.speed || 1;
    V.menu = null; V.ended = false;
    V.disp = {}; S.units.forEach(function (u) { V.disp[u.uid] = { hp: u.hp, mp: u.mp, ko: u.ko }; });
    V.names = {}; S.units.forEach(function (u) { V.names[u.uid] = u.name; });
    V.last = { cfgSeed: seed, troopId: troopId, party: party, seed: seed, weatherId: weatherId, opts: opts, inputs: V.inputs, code: null };
    if (S.db.warnings.length) Kit.ui.toast(S.db.warnings[0], 'warn', 5000);
    if (S.result) { Kit.ui.toast('That troop or party has no fighters.', 'warn'); }
    buildCanvas();
    var res = document.getElementById('arResult'); if (res) res.hidden = true;
    closeMenu();
    paintControls();
    status((V.playback ? 'Replaying seed ' : 'Seed ') + seed + ' | ' + S.sched + (S.sched === 'atb' ? (S.waitMode ? ' wait' : ' active') : '') + (S.preemptive ? ' | preemptive strike' : ''));
    if (S.preemptive) pushLog({ type: 'note', t: 0, text: 'Preemptive strike. The party moves first.' });
    V.raf = requestAnimationFrame(frame);
  }
  WSX.start = startBattle;
  // Opens the Arena with a troop selected (and optionally a chapter expected state), then starts the battle.
  WSX.preload = function (troopId, o) {
    var b = cur(), s = defaultSetup(b);
    s.troopId = troopId;
    var tr = recOf(b, troopId);
    if (o && o.source) s.source = o.source; else if (tr && tr.chapter && epsFor(b, tr.chapter)) s.source = tr.chapter;
    if (o && o.seed) s.seed = o.seed;
    saveSetup(s);
    WSX._pending = { start: true };
    if (Kit.active() === 'arena') Kit.rerender(); else Kit.go('arena');
  };

  function buildCanvas() {
    var stage = document.getElementById('arStage');
    if (!stage) return;
    U.clear(stage);
    var res = resolution(cur());
    var c = el('canvas'); c.width = res.w; c.height = res.h; c.setAttribute('role', 'img'); c.setAttribute('aria-label', 'Battle view');
    stage.appendChild(c);
    V.canvas = c; V.g = c.getContext('2d'); V.g.imageSmoothingEnabled = false; V.res = res;
    fitCanvas();
    if (!V.ro && typeof ResizeObserver === 'function') { V.ro = new ResizeObserver(function () { fitCanvas(); }); V.ro.observe(stage); }
    layout();
  }
  function fitCanvas() {
    if (!V || !V.canvas || !V.canvas.isConnected) return;
    var stage = V.canvas.parentNode, w = stage.clientWidth - 8, vh = (window.innerHeight || 800) * 0.62;
    var sc = Math.max(1, Math.min(Math.floor(w / V.res.w), Math.floor(vh / V.res.h)));
    V.canvas.style.width = (V.res.w * sc) + 'px';
    V.canvas.style.height = (V.res.h * sc) + 'px';
    V.scale = sc;
  }
  // Positions of every unit on the canvas.
  function layout() {
    var W = V.res.w, H = V.res.h, field = Math.round(H * 0.64), foes = V.S.units.filter(function (u) { return u.side === 'foe'; }), party = V.S.units.filter(function (u) { return u.side === 'party'; });
    V.pos = {};
    var front = foes.filter(function (u) { return u.row !== 'back'; }), back = foes.filter(function (u) { return u.row === 'back'; });
    var n = Math.max(front.length, back.length, 1);
    var size = Math.max(16, Math.min(48, Math.floor((field - 16) / Math.max(1, Math.ceil(n))) - 2));
    function col(list, x) {
      var gap = (field - 12) / (list.length + 1);
      list.forEach(function (u, i) { var s = u.isBoss ? Math.min(64, Math.round(size * 1.35)) : size; V.pos[u.uid] = { x: Math.round(x - s / 2), y: Math.round(8 + gap * (i + 1) - s / 2), w: s, h: s }; });
    }
    col(back, W * 0.16); col(front, W * 0.36);
    var pg = (field - 12) / (party.length + 1);
    party.forEach(function (u, i) { var x = Math.round(W * (u.row === 'back' ? 0.86 : 0.78)); V.pos[u.uid] = { x: x - 6, y: Math.round(8 + pg * (i + 1) - 10), w: 12, h: 20, tint: PARTY_TINTS[i % PARTY_TINTS.length] }; });
    V.field = field;
  }

  // ------------------------------------------------------------------ main loop
  var DUR = { action: 520, damage: 90, heal: 90, miss: 90, ko: 360, status: 90, revive: 200, limitReady: 240, end: 400 };
  function frame(ts) {
    if (!V || !V.canvas || !V.canvas.isConnected) { stopLoop(); return; }
    var dt = V.lastTs ? Math.min(100, ts - V.lastTs) : 16;
    V.lastTs = ts;
    var sp = V.speed || 1;
    // presentation queue first
    if (V.queue.length) {
      V.idle += dt * sp;
      while (V.queue.length && V.idle >= 0) {
        var e = V.queue[0];
        if (!e._started) { e._started = true; playEvent(e); V.idle -= (DUR[e.type] || 0); if (V.idle < 0) break; }
        V.queue.shift();
      }
      if (!V.queue.length) { syncDisp(); V.idle = 0; if (V.S.result && !V.ended) onEnd(); }
    } else if (!V.S.result) {
      tickEngine(dt * sp);
    } else if (!V.ended) { onEnd(); }
    draw(ts);
    V.raf = requestAnimationFrame(frame);
  }
  function feed(r) {
    V.S = r.state;
    (r.events || []).forEach(function (e) {
      if (e.type === 'tick') return;
      V.queue.push(e);
      pushLog(e);
    });
  }
  function tickEngine(ms) {
    var S = V.S, pb = V.playback;
    // playback: apply recorded inputs at their exact tick
    if (pb && pb.i < pb.inputs.length && S.t >= pb.inputs[pb.i].t) {
      var rec = pb.inputs[pb.i++];
      V.inputs.push(rec);
      feed(ENGINE_BATTLE.advance(S, rec.input));
      return;
    }
    if (S.awaiting && !pb) {
      if (V.auto) { var sug = ENGINE_BATTLE.suggest(S, null); if (sug) { give(sug); return; } }
      openMenu();
      if (S.waitMode || S.sched !== 'atb') return;
    } else if (!S.awaiting) closeMenu();
    if (S.sched === 'atb') {
      var rate = num((rs(cur()).battle || {}).tickRate, 30);
      V.acc += ms * rate / 1000;
      var n = Math.floor(V.acc);
      if (n < 1) return;
      V.acc -= n;
      if (pb && pb.i < pb.inputs.length) n = Math.min(n, pb.inputs[pb.i].t - S.t);
      if (n < 1) return;
      feed(ENGINE_BATTLE.advance(S, { type: 'step', ticks: n }));
    } else {
      V.acc += ms;
      if (V.acc < 380) return;
      V.acc = 0;
      if (pb && pb.i < pb.inputs.length && S.t >= pb.inputs[pb.i].t) return;
      feed(ENGINE_BATTLE.advance(S, { type: 'step', ticks: 1 }));
    }
  }
  function give(input) {
    var S = V.S, t = S.t, r = ENGINE_BATTLE.advance(S, input);
    var rejected = (r.events || []).some(function (e) { return e.value === 'rejected'; });
    if (rejected) { var why = r.events.filter(function (e) { return e.value === 'rejected'; })[0]; Kit.ui.toast(why.name || 'That command was rejected.', 'warn'); return false; }
    V.inputs.push({ t: t, input: input });
    closeMenu();
    feed(r);
    return true;
  }
  function syncDisp() { V.S.units.forEach(function (u) { V.disp[u.uid] = { hp: u.hp, mp: u.mp, ko: u.ko }; }); }
  function popup(uid, text, color) {
    var p = V.pos[uid]; if (!p) return;
    V.popups.push({ x: p.x + p.w / 2, y: p.y + 2, text: String(text), color: color, born: V.lastTs });
  }
  function playEvent(e) {
    var d;
    if (e.type === 'action') {
      V.anim = { actor: e.actor, born: V.lastTs, targets: e.targets || [], element: e.element, name: e.name };
      var u = V.S.units.filter(function (x) { return x.uid === e.actor; })[0];
      if (u && V.disp[u.uid]) V.disp[u.uid].mp = u.mp;
    } else if (e.type === 'damage') {
      d = V.disp[e.target]; if (d) d.hp = Math.max(0, d.hp - num(e.value));
      popup(e.target, e.value, e.crit ? '#ffe066' : '#ffffff');
      V.flash[e.target] = V.lastTs;
    } else if (e.type === 'heal') {
      d = V.disp[e.target]; if (d) d.hp = d.hp + num(e.value);
      popup(e.target, e.value, '#7dff9a');
    } else if (e.type === 'miss') {
      if (e.target) popup(e.target, 'MISS', '#b8c4d8');
    } else if (e.type === 'ko') {
      d = V.disp[e.target]; if (d) { d.ko = true; d.hp = 0; }
      V.fade[e.target] = V.lastTs;
    } else if (e.type === 'revive') {
      d = V.disp[e.target]; if (d) d.ko = false; delete V.fade[e.target];
    } else if (e.type === 'limitReady' && e.value === 'full') {
      popup(e.target, 'LIMIT', '#e3b453');
    } else if (e.type === 'status' && e.target) {
      popup(e.target, String(e.value).charAt(0) === '-' ? 'CURED' : shortName(e.name || 'STATUS', 7), '#c89cf0');
    }
  }
  function onEnd() {
    V.ended = true;
    closeMenu();
    var r = V.S.result;
    V.last.inputs = V.inputs.slice();
    V.last.end = { outcome: r.outcome, ticks: r.ticks, turns: r.turns, rngCalls: r.rngCalls };
    V.last.code = WSX.encodeCode({ v: 1, troopId: V.troopId, party: V.party, seed: V.seed, inputs: V.last.inputs, weatherId: V.weatherId, opts: V.opts, end: V.last.end });
    var box = document.getElementById('arResult');
    if (box) {
      var label = { win: 'Victory', lose: 'Defeat', flee: 'Escaped', timeout: 'Time out' }[r.outcome] || r.outcome;
      var chip = { win: 'chip-ok', lose: 'chip-error', flee: 'chip-muted', timeout: 'chip-warning' }[r.outcome] || 'chip-muted';
      var match = '';
      if (V.playback && V.playback.expect) {
        var ok = V.playback.expect.outcome === r.outcome && V.playback.expect.ticks === r.ticks && V.playback.expect.turns === r.turns && (V.playback.expect.rngCalls == null || V.playback.expect.rngCalls === r.rngCalls);
        match = '<p class="' + (ok ? 'msg msg-forward' : 'msg msg-error') + '">' + (ok ? 'Replay matched the original battle exactly.' : 'Replay diverged from the original. The records may have changed since the code was made.') + '</p>';
        Kit.ui.toast(ok ? 'Replay matched the original battle.' : 'Replay diverged from the original.', ok ? 'ok' : 'warn');
      }
      box.innerHTML = '<div class="btn-row"><span class="chip ' + chip + '">' + esc(label) + '</span><strong>' + esc(V.S.db.troop ? V.S.db.troop.name : '') + '</strong></div>' + match +
        '<dl class="kv"><dt>Ticks</dt><dd>' + r.ticks + '</dd><dt>Turns</dt><dd>' + r.turns + '</dd><dt>HP lost</dt><dd>' + r.resourcesUsed.hpLost + ' (' + r.resourcesUsed.hpPct + '%)</dd><dt>MP spent</dt><dd>' + r.resourcesUsed.mpSpent + ' (' + r.resourcesUsed.mpPct + '%)</dd>' +
        (r.outcome === 'win' ? '<dt>Rewards</dt><dd>' + r.rewards.gil + ' gil, ' + r.rewards.exp + ' EXP, ' + r.rewards.ap + ' AP</dd>' : '') +
        '<dt>Seed</dt><dd>' + V.seed + '</dd><dt>Inputs</dt><dd>' + V.inputs.length + '</dd></dl>';
      box.hidden = false;
    }
    paintControls();
    status('Seed ' + V.seed + ' | ' + r.outcome + ' in ' + r.turns + ' turns');
  }

  // ------------------------------------------------------------------ command menu (DOM overlay, 44px buttons)
  function closeMenu() { var m = document.getElementById('arMenu'); if (m) { m.hidden = true; U.clear(m); } if (V) V.menu = null; }
  function openMenu() {
    var S = V.S, aw = S.awaiting, m = document.getElementById('arMenu');
    if (!aw || !m) return;
    var key = aw.actor + '|' + aw.commands.map(function (c) { return c.key + ':' + c.abls.map(function (x) { return x.id + (x.ok ? 1 : 0); }).join(','); }).join(';') + '|' + aw.targets.foe.join(',') + '|' + aw.targets.party.join(',');
    if (V.menu && V.menu.key === key) {
      if (V.menu.level === 'targets') Array.prototype.forEach.call(m.querySelectorAll('[data-uid] small'), function (sm) {
        var u = S.units.filter(function (x) { return x.uid === sm.parentNode.getAttribute('data-uid'); })[0];
        if (u) { var t = u.hp + ' / ' + u.maxHp + ' HP'; if (sm.textContent !== t) sm.textContent = t; }
      });
      return;
    }
    var keep = V.menu && V.menu.actor === aw.actor ? V.menu : null;
    V.menu = { key: key, actor: aw.actor, level: keep ? keep.level : 'root', cmd: keep ? keep.cmd : null, abl: keep ? keep.abl : null };
    paintMenu();
  }
  function paintMenu() {
    var S = V.S, aw = S.awaiting, m = document.getElementById('arMenu'), st = V.menu;
    if (!aw || !m || !st) return;
    U.clear(m); m.hidden = false;
    var cmd = st.cmd ? aw.commands.filter(function (c) { return c.key === st.cmd; })[0] : null;
    if (st.level !== 'root' && !cmd) st.level = 'root';
    var head = el('div', 'ar-menu-head');
    head.appendChild(el('span', 'who', esc(V.names[aw.actor] || aw.actor) + (st.level === 'root' ? '' : ' | ' + esc(cmd.label))));
    if (st.level !== 'root') {
      var back = el('button', 'btn btn-ghost', Kit.icon('up') + '<span>Back</span>'); back.type = 'button';
      back.addEventListener('click', function () { st.level = st.level === 'targets' && cmd.abls.length > 1 ? 'abls' : 'root'; st.abl = null; paintMenu(); });
      head.appendChild(back);
    } else if (!S.waitMode && S.sched === 'atb') head.appendChild(el('span', 'chip chip-warning', 'Active'));
    m.appendChild(head);
    var grid = el('div', 'ar-menu-grid');
    m.appendChild(grid);
    function b(label, sub, fn, o) {
      var x = el('button', 'btn' + (o && o.cls ? ' ' + o.cls : ''), '<span>' + esc(label) + '</span>' + (sub ? '<small>' + esc(sub) + '</small>' : ''));
      x.type = 'button'; if (o && o.disabled) x.disabled = true;
      x.addEventListener('click', fn); grid.appendChild(x); return x;
    }
    if (st.level === 'root') {
      aw.commands.forEach(function (c) {
        if (c.key === 'flee') { b('Flee', '', function () { give({ type: 'flee', actor: aw.actor }); }); return; }
        var usable = c.abls.some(function (x) { return x.ok; });
        b(c.label, c.abls.length > 1 ? c.abls.length + ' abilities' : (c.abls[0] && c.abls[0].mp ? c.abls[0].mp + ' MP' : ''), function () {
          st.cmd = c.key;
          if (c.abls.length === 1) { st.abl = c.abls[0].id; st.level = 'targets'; } else st.level = 'abls';
          if (st.level === 'targets' && !needsTarget(c.abls[0])) { fire(c.abls[0], null); return; }
          paintMenu();
        }, { disabled: !usable, cls: c.key === 'limit' ? 'limit' : '' });
      });
    } else if (st.level === 'abls') {
      cmd.abls.forEach(function (x) {
        b(x.name, (x.mp ? x.mp + ' MP' : 'Free') + (x.scope === 'all' ? ' | all' : '') + (x.element ? ' | ' + x.element : ''), function () {
          st.abl = x.id;
          if (!needsTarget(x)) { fire(x, null); return; }
          st.level = 'targets'; paintMenu();
        }, { disabled: !x.ok });
      });
    } else {
      var ab = cmd.abls.filter(function (x) { return x.id === st.abl; })[0];
      if (!ab) { st.level = 'root'; paintMenu(); return; }
      var first = ab.side === 'ally' ? 'party' : 'foe', order = first === 'party' ? ['party', 'foe'] : ['foe', 'party'];
      if (ab.scope === 'all') {
        order.forEach(function (side) {
          if (!aw.targets[side].length) return;
          b(side === 'foe' ? 'All foes' : 'All allies', aw.targets[side].length + ' target' + (aw.targets[side].length === 1 ? '' : 's'), function () { fire(ab, aw.targets[side][0]); });
        });
        return;
      }
      order.forEach(function (side) {
        aw.targets[side].forEach(function (uid) {
          var u = V.S.units.filter(function (x) { return x.uid === uid; })[0];
          if (!u) return;
          var label = V.names[uid] || uid;
          b(label, u.hp + ' / ' + u.maxHp + ' HP', function () { fire(ab, uid); }).setAttribute('data-uid', uid);
        });
      });
    }
  }
  function needsTarget(x) { return x && x.side !== 'self'; }
  function fire(x, uid) {
    var aw = V.S.awaiting;
    if (!aw) return;
    var tgt = uid || (x.side === 'ally' ? aw.targets.party[0] : aw.targets.foe[0]);
    give({ type: 'command', actor: aw.actor, abl: x.id, target: tgt });
  }

  // ------------------------------------------------------------------ drawing
  function bar(g, x, y, w, h, frac, color, back) {
    g.fillStyle = back || '#1d2233'; g.fillRect(x, y, w, h);
    g.fillStyle = color; g.fillRect(x, y, Math.max(0, Math.round(w * Math.max(0, Math.min(1, frac)))), h);
  }
  function elementColor(k) {
    var els = rs(cur()).elements || [];
    for (var i = 0; i < els.length; i++) if (els[i] && els[i].key === k && els[i].color) return els[i].color;
    return '#ffffff';
  }
  function draw(ts) {
    var g = V.g, W = V.res.w, H = V.res.h, S = V.S, field = V.field;
    g.imageSmoothingEnabled = false;
    // backdrop
    g.fillStyle = '#10142a'; g.fillRect(0, 0, W, field);
    g.fillStyle = '#18203c'; g.fillRect(0, Math.round(field * 0.35), W, Math.round(field * 0.25));
    g.fillStyle = '#243052'; g.fillRect(0, Math.round(field * 0.6), W, field - Math.round(field * 0.6));
    g.fillStyle = '#2e3c63'; for (var gx = 0; gx < W; gx += 16) g.fillRect(gx, Math.round(field * 0.6) + ((gx / 16) % 2 ? 6 : 12), 8, 1);
    if (V.weatherId) {
      var w = recOf(cur(), V.weatherId), txt = w ? String(w.realWorld || w.name || '') : '';
      g.fillStyle = 'rgba(160,190,255,.25)';
      var off = Math.floor(ts / 40) % 12;
      if (/rain|storm|shower|drizzle|monsoon|hail/i.test(txt)) for (var rx = -20; rx < W; rx += 12) for (var ry = 0; ry < field; ry += 18) g.fillRect(rx + ((ry + off * 2) % 12), (ry + off * 3) % field, 1, 4);
      else if (/snow|blizzard|flurr/i.test(txt)) for (var sx = 0; sx < W; sx += 14) g.fillRect((sx + off) % W, (sx * 7 + off * 2) % field, 1, 1);
      else if (/fog|mist|haze|smog/i.test(txt)) { g.fillStyle = 'rgba(200,210,230,.10)'; g.fillRect(0, Math.round(field * 0.4), W, Math.round(field * 0.6)); }
      else if (/heat|sun|drought|clear/i.test(txt)) { g.fillStyle = 'rgba(255,190,90,.08)'; g.fillRect(0, 0, W, field); }
      if (txt) drawText(g, shortName(txt, 20), 3, 3, '#9fb3d9', 1);
    }
    var an = V.anim && ts - V.anim.born < 520 / (V.speed || 1) ? V.anim : null;
    // foes
    S.units.forEach(function (u) {
      var p = V.pos[u.uid], d = V.disp[u.uid];
      if (!p) return;
      var dx = an && an.actor === u.uid ? (u.side === 'foe' ? 6 : -6) : 0;
      var alpha = 1;
      if (d && d.ko) { var ft = V.fade[u.uid] ? (ts - V.fade[u.uid]) / 500 : 1; alpha = u.side === 'foe' ? Math.max(0, 1 - ft) : 1; }
      if (alpha <= 0) return;
      g.globalAlpha = alpha;
      if (u.side === 'foe') {
        var spr = foeSprite(u.fam, u.tier, u.palette, p.w);
        g.drawImage(spr, p.x + dx - 1, p.y - 1);
        if (u.charging) { g.fillStyle = '#e3b453'; g.fillRect(p.x + dx, p.y - 3, Math.round(p.w * (1 - u.charging.left / Math.max(1, (S.db.abl[u.charging.abl] || {}).chargeTicks || 1))), 1); }
      } else {
        var koP = d && d.ko;
        if (koP) {
          g.fillStyle = '#555a66'; g.fillRect(p.x - 4, p.y + p.h - 5, p.h, 5);
        } else {
          var tint = p.tint, x = p.x + dx, y = p.y;
          g.fillStyle = '#07080d'; g.fillRect(x - 1, y - 1, p.w + 2, p.h + 2);
          g.fillStyle = tint; g.fillRect(x, y + 6, p.w, p.h - 6);
          g.fillStyle = shade(tint, 0.35); g.fillRect(x + 2, y, p.w - 4, 7);
          g.fillStyle = '#f1d7b8'; g.fillRect(x + 3, y + 2, p.w - 6, 4);
          g.fillStyle = '#07080d'; g.fillRect(x + 4, y + 3, 1, 1);
          g.fillStyle = shade(tint, -0.35); g.fillRect(x, y + p.h - 5, p.w, 2);
          if (frac2(u, d) < 0.25) { g.fillStyle = 'rgba(255,80,80,.35)'; g.fillRect(x, y, p.w, p.h); }
          weaponGlyph(g, u.weaponClass, x - 2, y + 11, '#c9c1ab');
          if (S.awaiting && S.awaiting.actor === u.uid && Math.floor(ts / 300) % 2) { g.fillStyle = '#e3b453'; g.fillRect(x + p.w / 2 - 1, y - 6, 3, 3); }
        }
      }
      if (V.flash[u.uid] && ts - V.flash[u.uid] < 140) { g.globalAlpha = 0.6; g.fillStyle = '#ffffff'; g.fillRect(p.x + dx, p.y, p.w, p.h); }
      g.globalAlpha = 1;
      if (u.statuses && u.statuses.length && !(d && d.ko)) { g.fillStyle = '#c89cf0'; g.fillRect(p.x + dx, p.y + p.h + 1, Math.min(p.w, u.statuses.length * 3), 1); }
    });
    // action flash lines
    if (an) {
      var ap = V.pos[an.actor], col = an.element ? elementColor(an.element) : '#ffffff';
      drawText(g, shortName(an.name, 18), Math.round(W / 2 - textW(shortName(an.name, 18)) / 2), Math.max(10, field - 12), '#ffffff');
      if (ap) (an.targets || []).forEach(function (t) {
        var tp = V.pos[t]; if (!tp) return;
        g.fillStyle = col; g.globalAlpha = 0.35;
        g.fillRect(tp.x - 1, tp.y - 1, tp.w + 2, 1); g.fillRect(tp.x - 1, tp.y + tp.h, tp.w + 2, 1);
        g.globalAlpha = 1;
      });
    }
    // popups
    V.popups = V.popups.filter(function (p) { return ts - p.born < 900 / Math.max(1, (V.speed || 1) * 0.75); });
    V.popups.forEach(function (p) { var age = (ts - p.born) / 900; var s = p.text.length > 4 ? 1 : 2; drawText(g, p.text, Math.round(p.x - textW(p.text, s) / 2), Math.round(p.y - age * 12), p.color, s); });
    // HUD
    var hy = field, hh = H - field;
    g.fillStyle = '#0b0e1d'; g.fillRect(0, hy, W, hh);
    g.fillStyle = '#3a4a80'; g.fillRect(0, hy, W, 1); g.fillRect(Math.round(W * 0.36), hy + 3, 1, hh - 6);
    var foes = S.units.filter(function (u) { return u.side === 'foe'; }), party = S.units.filter(function (u) { return u.side === 'party'; });
    var fy = hy + 4;
    foes.forEach(function (u) {
      if (fy > H - 7) return;
      var d = V.disp[u.uid];
      drawText(g, shortName(u.name, Math.floor((W * 0.36 - 8) / 4)), 4, fy, d && d.ko ? '#5d6480' : '#e8e2cf');
      if (!(d && d.ko)) bar(g, 4, fy + 6, Math.round(W * 0.36 - 10), 1, frac2(u, d), '#e07a6e');
      fy += 9;
    });
    var px = Math.round(W * 0.36) + 4, pw = W - px - 3, rowH = Math.max(9, Math.min(14, Math.floor((hh - 6) / Math.max(1, party.length))));
    party.forEach(function (u, i) {
      var d = V.disp[u.uid] || u, y = hy + 4 + i * rowH, isAw = S.awaiting && S.awaiting.actor === u.uid;
      var nameCols = Math.max(3, Math.floor(pw * 0.26 / 4));
      drawText(g, shortName(u.name, nameCols), px, y, d.ko ? '#5d6480' : isAw ? '#e3b453' : '#e8e2cf');
      var hpTxt = d.hp + '/' + u.maxHp, hx = px + nameCols * 4 + 3;
      var lowCol = d.ko ? '#8a4a4a' : frac2(u, d) < 0.25 ? '#ffb347' : '#e8e2cf';
      drawText(g, hpTxt, hx, y, lowCol);
      var gx0 = hx + textW('9999/9999') + 4, gw = Math.max(10, W - 3 - gx0);
      if (rowH >= 12) {
        drawText(g, String(d.mp), gx0, y, '#9ad1ff');
        var gy = y + 6;
        bar(g, gx0 + 14, y + 1, Math.max(8, gw - 14), 2, S.sched === 'atb' ? u.gauge / S.gaugeMax : (u.ready ? 1 : 0), u.ready ? '#e3b453' : '#6fc7b6');
        if (u.limits && u.limits.length) bar(g, gx0 + 14, gy - 1, Math.max(8, gw - 14), 1, u.limit.gauge, u.limit.gauge >= 1 ? '#ff8aa0' : '#8a5a9e');
      } else {
        bar(g, gx0, y + 2, gw, 2, S.sched === 'atb' ? u.gauge / S.gaugeMax : (u.ready ? 1 : 0), u.ready ? '#e3b453' : '#6fc7b6');
      }
    });
    if (S.sched !== 'atb' && !S.result) drawText(g, (S.sched === 'rounds' ? 'ROUND ' + (S.round ? S.round.n : 1) : 'CTB') + ' T' + S.t, W - textW('ROUND 99 T9999') - 3, 3, '#9fb3d9');
    if (S.result && V.ended) {
      var lab = { win: 'VICTORY', lose: 'DEFEAT', flee: 'ESCAPED', timeout: 'TIME OUT' }[S.result.outcome] || '';
      var sc = W >= 200 ? 3 : 2, tw = textW(lab, sc);
      g.fillStyle = 'rgba(7,8,13,.6)'; g.fillRect(0, Math.round(field / 2 - 14), W, 28);
      drawText(g, lab, Math.round(W / 2 - tw / 2), Math.round(field / 2 - 7), S.result.outcome === 'win' ? '#e3b453' : S.result.outcome === 'lose' ? '#f07a6e' : '#c9c1ab', sc);
    }
  }
  function frac2(u, d) { return u.maxHp ? (d ? d.hp : u.hp) / u.maxHp : 0; }

  // ------------------------------------------------------------------ log, codes
  function nm(uid) { return uid ? (V.names[uid] || uid) : ''; }
  function describe(e) {
    switch (e.type) {
      case 'note': return e.text;
      case 'ready': return nm(e.actor) + ' is ready.';
      case 'command': return e.value === 'flee' ? nm(e.actor) + ' tries to flee.' : nm(e.actor) + ' chooses ' + (e.name || e.abl) + '.';
      case 'action': return nm(e.actor) + (e.value === 'counter' ? ' counters with ' : ' uses ') + (e.name || e.abl) + ' on ' + (e.targets || []).map(nm).join(', ') + '.';
      case 'damage': return nm(e.target) + ' takes ' + e.value + (e.element ? ' ' + e.element : '') + ' damage' + (e.crit ? ', a critical hit' : '') + '.';
      case 'heal': return nm(e.target) + ' recovers ' + e.value + ' HP.';
      case 'miss': return e.value === 'mp' ? nm(e.actor) + ' lacks the MP.' : e.value === 'flee' ? (e.name || 'Could not escape') + '.' : e.value === 'rejected' ? (e.name || 'Rejected.') : nm(e.actor) + ' misses ' + nm(e.target) + '.';
      case 'status': return String(e.value).charAt(0) === '-' ? nm(e.target) + ' is free of ' + String(e.value).slice(1) + ' (' + e.name + ').' : nm(e.target) + ' is afflicted with ' + (e.name || e.value) + '.';
      case 'limitReady': return e.value === 'full' ? nm(e.target) + ' is ready to break their Limit.' : nm(e.target) + ' reached ' + (e.name || 'a new Limit level') + '.';
      case 'ko': return nm(e.target) + ' is knocked out' + (e.actor ? ' by ' + nm(e.actor) : '') + '.';
      case 'revive': return nm(e.target) + ' is revived.';
      case 'end': return 'Battle over: ' + e.value + '.';
      default: return e.type;
    }
  }
  function pushLog(e) { V.log.push(e); if (V.log.length > 2000) V.log.splice(0, V.log.length - 2000); }
  function openLog() {
    if (!V || !V.log) return;
    Kit.ui.drawer({
      title: 'Battle log',
      body: function (bd) {
        var p = el('p', 'muted'); p.textContent = V.log.length + ' events, seed ' + V.seed + '. Newest last.'; bd.appendChild(p);
        var list = el('div', 'ar-log');
        V.log.slice(-600).forEach(function (e) {
          var ln = el('div', 'ln k-' + e.type);
          ln.innerHTML = '<span class="t">t ' + e.t + '</span><span class="m">' + esc(describe(e)) + '</span>';
          list.appendChild(ln);
        });
        bd.appendChild(list);
        setTimeout(function () { bd.scrollTop = bd.scrollHeight; }, 0);
      }
    });
  }
  function copyCode() {
    if (!V || !V.last || !V.last.code) return;
    var code = V.last.code;
    function shown() {
      Kit.ui.dialog({ title: 'Battle code', body: function (bd) { var t = el('textarea', 'inp ar-code'); t.readOnly = true; t.value = code; bd.appendChild(el('p', 'muted', 'Paste this into any Saga Forge with the same records to replay the fight tick for tick.')); bd.appendChild(t); setTimeout(function () { t.focus(); t.select(); }, 0); }, actions: [{ label: 'Done', kind: 'primary' }] });
    }
    try {
      if (navigator.clipboard && navigator.clipboard.writeText) navigator.clipboard.writeText(code).then(function () { Kit.ui.toast('Battle code copied.', 'ok'); }, shown);
      else shown();
    } catch (e) { shown(); }
  }
  function playCode(code) {
    var o;
    try { o = WSX.decodeCode(code); } catch (e) { Kit.ui.toast(e.message || 'That battle code could not be read.', 'error'); return false; }
    var b = cur();
    if (!recOf(b, o.troopId)) { Kit.ui.toast('This project has no troop ' + o.troopId + '.', 'error'); return false; }
    if (!V || Kit.active() !== 'arena' || !document.getElementById('arStage')) { WSX._pending = { code: code }; if (Kit.active() === 'arena') Kit.rerender(); else Kit.go('arena'); return true; }
    startBattle(null, o);
    return true;
  }
  WSX.playCode = playCode;
  function pasteCode() {
    Kit.ui.prompt({ title: 'Paste battle code', label: 'Battle code', multiline: true, okLabel: 'Replay', validate: function (v) { try { WSX.decodeCode(v); return null; } catch (e) { return 'That is not a valid battle code.'; } } }).then(function (v) { if (v) playCode(v); });
  }

  Kit.mount('arena', { title: 'Arena', icon: 'arena', canEnter: WSX.canEnter, render: WSX.render, onLeave: function () { stopLoop(); closeMenu(); return true; } });
})();
// === WS:ARENA END ===
// === WS:SIM BEGIN ===
(function () {
  'use strict';
  var U = Kit.util, el = function (t, c, h) { return U.el(t, c, h); }, esc = U.esc;
  var WSX = window.WS.sim = { id: 'sim' };
  var SETUP_KEY = 'saga146:sim:setup';
  var PARTY_MAX = 4;
  var SEED_STRIDE = 1000003;
  var NONE = '_none';
  var CHARTS = {};
  var RUN = null;     // the run in progress: {worker, url, total, done, rows, meta, status}
  var LAST = null;    // the last finished (or cancelled) run: {rows, skipped, meta, status, stamp}
  var V = { host: null, focus: 'all' };

  function cur() { return Kit.bundle.current(); }
  function recs(b, p) { var o = b && b.rules && b.rules[p] ? b.rules[p] : {}; return Object.keys(o).map(function (k) { return o[k]; }).filter(function (r) { return U.isObj(r) && r.id; }); }
  function count(b, p) { return recs(b, p).length; }
  function recOf(b, id) { var p = Kit.ids.prefixOf(id); return p && b.rules && b.rules[p] && b.rules[p][id] ? b.rules[p][id] : null; }
  function num(v, d) { return typeof v === 'number' && isFinite(v) ? v : (d === undefined ? 0 : d); }
  function rs(b) { return (b && b.charter && b.charter.ruleset) || {}; }
  function chapters(b) { return window.WS.rules && WS.rules.content ? WS.rules.content.chaptersOf(b) : []; }
  function epsFor(b, chId) { var l = recs(b, 'eps_'); for (var i = 0; i < l.length; i++) if (l[i].chapter === chId) return l[i]; return null; }
  function randomSeed() { return Math.floor(Math.random() * 2147483646) + 1; }
  function clampInt(v, lo, hi, d) { v = Math.round(Number(v)); if (!isFinite(v)) v = d; return Math.max(lo, Math.min(hi, v)); }
  function pct(v) { return (Math.round(v * 10) / 10).toFixed(1) + '%'; }

  WSX.canEnter = function (b) {
    var r = window.WS.rules.canEnter(b);
    if (r !== true) return r;
    if (!count(b, 'trp_')) return 'Author troops in Rules to run the Simulator.';
    if (!count(b, 'eps_')) return 'Fill the Expected Party State in Rules to run the Simulator.';
    return true;
  };

  // ------------------------------------------------------------------ setup
  function loadSetup() { var s = Kit.store.get(SETUP_KEY, null); return U.isObj(s) ? s : {}; }
  function saveSetup(s) { Kit.store.set(SETUP_KEY, s); }
  function defaultSetup(b) {
    var s = loadSetup(), chars = recs(b, 'chr_');
    var chs = chapters(b);
    if (s.chapter !== 'all' && !chs.some(function (c) { return c.id === s.chapter; })) s.chapter = 'all';
    s.battles = clampInt(s.battles, 1, 5000, 200);
    if (typeof s.seed !== 'number' || !isFinite(s.seed)) s.seed = randomSeed();
    if (s.mode !== 'custom') s.mode = 'eps';
    s.chars = (Array.isArray(s.chars) ? s.chars : []).filter(function (id) { return recOf(b, id); }).slice(0, PARTY_MAX);
    if (!s.chars.length) s.chars = chars.slice(0, PARTY_MAX).map(function (c) { return c.id; });
    s.level = clampInt(s.level, 1, 99, 10);
    s.gearTier = clampInt(s.gearTier, 1, 9, 1);
    s.materia = (Array.isArray(s.materia) ? s.materia : []).filter(function (id) { return recOf(b, id); });
    if (s.weatherId && !recOf(b, s.weatherId)) s.weatherId = null;
    return s;
  }

  // ------------------------------------------------------------------ job planning
  function partyFor(b, s, troop) {
    var cfg = { chars: s.chars };
    if (s.mode === 'eps') cfg.source = troop.chapter;
    else {
      cfg.source = 'custom'; cfg.level = s.level; cfg.gearTier = s.gearTier; cfg.materia = s.materia;
      var prog = rs(b).progression;
      if (prog === 'jobs') { cfg.jobs = {}; var js = recs(b, 'job_'); s.chars.forEach(function (id, i) { if (js.length) cfg.jobs[id] = js[i % js.length].id; }); }
      if (prog === 'classes') { cfg.classes = {}; var cs = recs(b, 'cls_'); s.chars.forEach(function (id, i) { if (cs.length) cfg.classes[id] = cs[i % cs.length].id; }); }
    }
    return WS.arena.buildParty(b, cfg);
  }
  // Decides which troops run and which are skipped (with the reason).
  function plan(b, s) {
    var chs = chapters(b), chIndex = {};
    chs.forEach(function (c, i) { chIndex[c.id] = i; });
    var jobs = [], skipped = [];
    var troops = recs(b, 'trp_').slice().sort(function (a, z) {
      var ia = chIndex[a.chapter] == null ? 9999 : chIndex[a.chapter], iz = chIndex[z.chapter] == null ? 9999 : chIndex[z.chapter];
      return ia - iz;
    });
    troops.forEach(function (t) {
      if (s.chapter !== 'all' && t.chapter !== s.chapter) return;
      if (!t.chapter || chIndex[t.chapter] == null) { skipped.push({ troopId: t.id, name: t.name || t.id, reason: 'The troop is not tagged to a chapter.' }); return; }
      var eps = epsFor(b, t.chapter);
      if (s.mode === 'eps' && !eps) { skipped.push({ troopId: t.id, name: t.name || t.id, reason: 'Its chapter has no Expected Party State.' }); return; }
      if (!Array.isArray(t.members) || !t.members.length) { skipped.push({ troopId: t.id, name: t.name || t.id, reason: 'The troop has no enemies.' }); return; }
      var broken = t.members.some(function (m) { return !m || !recOf(b, m.enm); });
      if (broken) { skipped.push({ troopId: t.id, name: t.name || t.id, reason: 'The troop references an enemy that does not exist.' }); return; }
      var party = partyFor(b, s, t);
      if (!party.length) { skipped.push({ troopId: t.id, name: t.name || t.id, reason: 'No party could be built.' }); return; }
      jobs.push({
        idx: jobs.length, troopId: t.id, name: t.name || t.id, chapterId: t.chapter, chapterNo: chIndex[t.chapter] + 1,
        chapterName: chs[chIndex[t.chapter]].name || t.chapter, party: party, weatherId: s.weatherId || null,
        target: eps && typeof eps.targetWinRate === 'number' ? eps.targetWinRate : null, battles: s.battles,
        seed: (s.seed + jobs.length * SEED_STRIDE) >>> 0
      });
    });
    return { jobs: jobs, skipped: skipped };
  }

  // ------------------------------------------------------------------ worker
  // This function runs inside the Worker. It is stringified into the Blob after the ENGINE:BATTLE fence text, so it may only
  // use the ENGINE_BATTLE global and Worker APIs.
  function workerMain() {
    self.onmessage = function (e) {
      var m = e.data;
      if (!m || m.type !== 'run') return;
      var total = 0, done = 0, last = Date.now();
      m.jobs.forEach(function (j) { total += j.battles; });
      try {
        m.jobs.forEach(function (j) {
          var agg = { battles: 0, win: 0, lose: 0, flee: 0, timeout: 0, turns: [], hpSum: 0, mpSum: 0, ticksSum: 0, damage: {}, warnings: [], seedWin: null, seedLoss: null };
          var data = { ruleset: m.base.ruleset, records: m.base.records, party: j.party, troopId: j.troopId, weatherId: j.weatherId };
          for (var i = 0; i < j.battles; i++) {
            var seed = ((j.seed + i) >>> 0) || 1;
            var r = ENGINE_BATTLE.run(data, seed, null, { events: false }).result;
            agg.battles++;
            if (r.outcome === 'win') { agg.win++; if (agg.seedWin === null) agg.seedWin = seed; }
            else if (r.outcome === 'lose') { agg.lose++; if (agg.seedLoss === null) agg.seedLoss = seed; }
            else if (r.outcome === 'flee') agg.flee++;
            else agg.timeout++;
            agg.turns.push(r.turns);
            agg.ticksSum += r.ticks;
            agg.hpSum += r.resourcesUsed.hpPct;
            agg.mpSum += r.resourcesUsed.mpPct;
            for (var k = 0; k < r.damageLog.length; k++) {
              var d = r.damageLog[k];
              if (d.side !== 'foe') continue;
              var key = d.element || '_none';
              agg.damage[key] = (agg.damage[key] || 0) + d.value;
            }
            if (agg.warnings.length < 3 && r.warnings) for (var w = 0; w < r.warnings.length && agg.warnings.length < 3; w++) if (agg.warnings.indexOf(r.warnings[w]) < 0) agg.warnings.push(r.warnings[w]);
            done++;
            if (Date.now() - last > 80) { last = Date.now(); self.postMessage({ type: 'progress', done: done, total: total, idx: j.idx }); }
          }
          self.postMessage({ type: 'troop', idx: j.idx, agg: agg });
        });
        self.postMessage({ type: 'progress', done: total, total: total, idx: -1 });
        self.postMessage({ type: 'done' });
      } catch (err) {
        self.postMessage({ type: 'error', message: String(err && err.message ? err.message : err) });
      }
    };
  }
  function workerSource() {
    var eng = Kit.engine.source();
    if (!eng) throw new Error('The engine source could not be read from this page.');
    return eng + '\n;(' + workerMain.toString() + ')();\n';
  }
  WSX.workerSource = workerSource;

  // ------------------------------------------------------------------ running
  function toRow(job, agg) {
    var n = Math.max(1, agg.battles);
    var row = {
      idx: job.idx, troopId: job.troopId, name: job.name, chapterId: job.chapterId, chapterNo: job.chapterNo, chapterName: job.chapterName,
      battles: agg.battles, win: agg.win, lose: agg.lose, flee: agg.flee, timeout: agg.timeout,
      winPct: agg.win / n * 100, target: job.target, avgTurns: agg.turns.reduce(function (a, v) { return a + v; }, 0) / n,
      hpPct: agg.hpSum / n, mpPct: agg.mpSum / n, turns: agg.turns, damage: agg.damage, warnings: agg.warnings,
      seedWin: agg.seedWin, seedLoss: agg.seedLoss, chars: job.party.map(function (m) { return m.chr; })
    };
    row.gap = row.target == null ? null : row.winPct - row.target;
    row.flag = row.gap != null && Math.abs(row.gap) > 10 ? (row.gap < 0 ? 'hard' : 'easy') : null;
    return row;
  }
  function closeWorker() {
    if (!RUN) return;
    try { if (RUN.worker) RUN.worker.terminate(); } catch (e) {}
    try { if (RUN.url) URL.revokeObjectURL(RUN.url); } catch (e2) {}
    RUN.worker = null; RUN.url = null;
  }
  function finishRun(status, message) {
    if (!RUN) return;
    closeWorker();
    var rows = Object.keys(RUN.rows).map(function (k) { return RUN.rows[k]; }).sort(function (a, z) { return a.idx - z.idx; });
    LAST = { rows: rows, skipped: RUN.skipped, meta: RUN.meta, status: status, message: message || '', stamp: RUN.stamp };
    RUN = null;
    V.focus = 'all';
    if (V.host && document.getElementById('simRoot')) paintAll();
    if (status === 'done') Kit.ui.toast('Simulation finished: ' + rows.length + ' troop' + (rows.length === 1 ? '' : 's') + '.', 'ok');
    else if (status === 'cancelled') Kit.ui.toast('Simulation cancelled. ' + rows.length + ' troop' + (rows.length === 1 ? '' : 's') + ' finished.', 'warn');
    else Kit.ui.toast(message || 'The simulation failed.', 'error', 7000);
  }
  function startRun() {
    if (RUN) return;
    var b = cur(), s = defaultSetup(b);
    saveSetup(s);
    var chars = recs(b, 'chr_');
    if (!chars.length) { Kit.ui.toast('Author at least one character in Rules first.', 'warn'); return; }
    if (!s.chars.length) { Kit.ui.toast('Pick at least one party member.', 'warn'); return; }
    var p;
    try { p = plan(b, s); } catch (e) { Kit.ui.toast('Could not plan the run: ' + e.message, 'error', 7000); return; }
    if (!p.jobs.length) {
      LAST = { rows: [], skipped: p.skipped, meta: { battles: s.battles, seed: s.seed, chapter: s.chapter, mode: s.mode }, status: 'empty', message: '', stamp: b.kit.updatedAt };
      paintAll();
      Kit.ui.toast('No troop can run with these settings.', 'warn');
      return;
    }
    var src, url, worker;
    try {
      src = workerSource();
      if (typeof Worker !== 'function' || typeof Blob !== 'function') throw new Error('This browser does not support Web Workers.');
      url = URL.createObjectURL(new Blob([src], { type: 'text/javascript' }));
      worker = new Worker(url);
    } catch (e) {
      if (url) { try { URL.revokeObjectURL(url); } catch (e3) {} }
      LAST = { rows: [], skipped: [], meta: null, status: 'noworker', message: 'The simulator could not start a Web Worker (' + (e && e.message ? e.message : 'unknown error') + '). Nothing was run. The simulator does not fall back to the main thread.', stamp: b.kit.updatedAt };
      paintAll();
      Kit.ui.toast('The simulator could not start a Web Worker.', 'error', 7000);
      return;
    }
    var total = 0;
    p.jobs.forEach(function (j) { total += j.battles; });
    RUN = { worker: worker, url: url, total: total, done: 0, idx: 0, jobs: p.jobs, rows: {}, skipped: p.skipped, stamp: b.kit.updatedAt, status: 'running', startedAt: Date.now(),
      meta: { battles: s.battles, seed: s.seed, chapter: s.chapter, mode: s.mode, weatherId: s.weatherId || null, level: s.level, gearTier: s.gearTier } };
    worker.onmessage = function (e) {
      var m = e.data;
      if (!RUN || !m) return;
      if (m.type === 'progress') { RUN.done = m.done; if (m.idx >= 0) RUN.idx = m.idx; paintProgress(); }
      else if (m.type === 'troop') { RUN.rows[m.idx] = toRow(RUN.jobs[m.idx], m.agg); RUN.done = Math.max(RUN.done, 0); paintProgress(); }
      else if (m.type === 'done') finishRun('done');
      else if (m.type === 'error') finishRun('error', 'The simulation stopped: ' + m.message);
    };
    worker.onerror = function (e) { finishRun('error', 'The simulation worker failed' + (e && e.message ? ': ' + e.message : '.')); };
    worker.postMessage({ type: 'run', base: { ruleset: rs(b), records: b.rules || {} }, jobs: p.jobs });
    paintAll();
  }
  function cancelRun() {
    if (!RUN) return;
    finishRun('cancelled');
  }
  WSX.run = startRun;
  WSX.cancel = cancelRun;
  WSX.last = function () { return LAST; };
  WSX.running = function () { return !!RUN; };

  // ------------------------------------------------------------------ view helpers
  function field(label, node, help) {
    var f = el('div', 'field');
    var l = el('label', 'field-label'); l.textContent = label;
    if (node.id) l.htmlFor = node.id;
    f.appendChild(l);
    var body = el('div', 'field-body'); body.appendChild(node); f.appendChild(body);
    if (help) { var h = el('div', 'field-help'); h.textContent = help; f.appendChild(h); }
    return f;
  }
  function select(id, options, value, onChange) {
    var sel = el('select', 'inp'); sel.id = id;
    options.forEach(function (o) { var op = el('option'); op.value = o.value; op.textContent = o.label; if (String(o.value) === String(value)) op.selected = true; sel.appendChild(op); });
    sel.addEventListener('change', function () { onChange(sel.value); });
    return sel;
  }
  function numInput(id, value, min, max, onChange) {
    var inp = el('input', 'inp'); inp.id = id; inp.type = 'number'; inp.inputMode = 'numeric'; inp.min = String(min); inp.max = String(max); inp.step = '1'; inp.value = String(value);
    inp.addEventListener('change', function () { var v = clampInt(inp.value, min, max, value); inp.value = String(v); onChange(v); });
    return inp;
  }
  function cssVar(n, d) { try { var v = getComputedStyle(document.documentElement).getPropertyValue(n).trim(); return v || d; } catch (e) { return d; } }
  function shortName(n, max) { n = String(n || ''); return n.length > max ? n.slice(0, max - 3) + '...' : n; }

  // ------------------------------------------------------------------ rendering
  WSX.render = function (host) {
    V.host = host;
    U.clear(host);
    var root = el('div', 'sim-root'); root.id = 'simRoot';
    host.appendChild(root);
    paintAll();
  };
  function destroyCharts() {
    Object.keys(CHARTS).forEach(function (k) { try { CHARTS[k].destroy(); } catch (e) {} });
    CHARTS = {};
  }
  function paintAll() {
    var root = document.getElementById('simRoot');
    if (!root) return;
    destroyCharts();
    U.clear(root);
    var b = cur(), s = defaultSetup(b);
    var setupPanel = el('section', 'panel sim-setup'); setupPanel.id = 'simSetup';
    root.appendChild(setupPanel);
    paintSetup(setupPanel, b, s);
    var out = el('div', 'sim-out'); out.id = 'simOut';
    root.appendChild(out);
    paintResults(out, b, s);
  }
  function paintSetup(box, b, s) {
    U.clear(box);
    var running = !!RUN;
    box.appendChild(el('h2', 'panel-title', 'Simulator'));
    box.appendChild(el('p', 'sim-lead', 'Runs every troop tagged to a chapter again and again against a party and charts how the fights balance. Each battle is fought by the engine with the default party policy, inside a Web Worker.'));
    var grid = el('div', 'form-grid sim-grid');
    box.appendChild(grid);
    var chs = chapters(b);
    var chOpts = [{ value: 'all', label: 'All chapters' }].concat(chs.map(function (c, i) { return { value: c.id, label: 'Ch ' + (i + 1) + ': ' + (c.name || c.id) }; }));
    var selCh = select('simChapter', chOpts, s.chapter, function (v) { s.chapter = v; saveSetup(s); });
    selCh.disabled = running;
    grid.appendChild(field('Chapter', selCh));
    var nb = numInput('simBattles', s.battles, 1, 5000, function (v) { s.battles = v; saveSetup(s); });
    nb.disabled = running;
    grid.appendChild(field('Battles per troop', nb, '1 to 5000. Default 200.'));
    var seedRow = el('div', 'ar-seedrow');
    var sd = numInput('simSeed', s.seed, 1, 2147483646, function (v) { s.seed = v; saveSetup(s); });
    sd.disabled = running;
    seedRow.appendChild(sd);
    var dice = el('button', 'btn', '<span class="lbl">Random</span>'); dice.type = 'button'; dice.disabled = running;
    dice.addEventListener('click', function () { s.seed = randomSeed(); saveSetup(s); sd.value = String(s.seed); });
    seedRow.appendChild(dice);
    grid.appendChild(field('Base seed', seedRow, 'Battle k of troop t uses base + t x ' + SEED_STRIDE + ' + k.'));
    var wOpts = [{ value: '', label: 'Clear (no weather)' }].concat(recs(b, 'wth_').map(function (w) { return { value: w.id, label: w.name || w.id }; }));
    var selW = select('simWeather', wOpts, s.weatherId || '', function (v) { s.weatherId = v || null; saveSetup(s); });
    selW.disabled = running;
    grid.appendChild(field('Weather', selW));

    box.appendChild(el('h3', 'section-h', 'Party'));
    var seg = el('div', 'ar-seg'); seg.setAttribute('role', 'group'); seg.setAttribute('aria-label', 'Party source');
    [['eps', 'Expected Party State'], ['custom', 'Custom']].forEach(function (o) {
      var bt = el('button'); bt.type = 'button'; bt.textContent = o[1]; bt.disabled = running;
      bt.setAttribute('aria-pressed', s.mode === o[0] ? 'true' : 'false');
      bt.addEventListener('click', function () { s.mode = o[0]; saveSetup(s); paintSetup(box, b, s); });
      seg.appendChild(bt);
    });
    box.appendChild(seg);
    box.appendChild(el('p', 'ar-note', s.mode === 'eps'
      ? 'Each troop is fought by the party its chapter expects: the level, gear tier, materia, jobs, or classes from that chapter\'s Expected Party State.'
      : 'Every troop is fought by one custom party at the level and gear tier below.'));
    var chars = recs(b, 'chr_');
    if (!chars.length) box.appendChild(el('div', 'empty-line', 'Author characters in Rules to field a party.'));
    var pick = el('div', 'ar-chars');
    chars.forEach(function (c) {
      var on = s.chars.indexOf(c.id) >= 0;
      var bt = el('button', 'ar-pick', esc(c.name || c.id)); bt.type = 'button'; bt.disabled = running;
      bt.setAttribute('aria-pressed', on ? 'true' : 'false');
      bt.addEventListener('click', function () {
        var k = s.chars.indexOf(c.id);
        if (k >= 0) s.chars.splice(k, 1);
        else if (s.chars.length >= PARTY_MAX) { Kit.ui.toast('A party holds at most ' + PARTY_MAX + '.', 'warn'); return; }
        else s.chars.push(c.id);
        saveSetup(s); paintSetup(box, b, s);
      });
      pick.appendChild(bt);
    });
    box.appendChild(pick);
    if (s.mode === 'custom') {
      var cg = el('div', 'form-grid sim-grid');
      var lv = numInput('simLevel', s.level, 1, 99, function (v) { s.level = v; saveSetup(s); }); lv.disabled = running;
      cg.appendChild(field('Level', lv));
      var gt = numInput('simGear', s.gearTier, 1, 9, function (v) { s.gearTier = v; saveSetup(s); }); gt.disabled = running;
      cg.appendChild(field('Gear tier', gt));
      box.appendChild(cg);
      if (rs(b).progression === 'materia') {
        var mats = recs(b, 'mat_');
        if (mats.length) {
          box.appendChild(el('h3', 'section-h', 'Materia'));
          var mp = el('div', 'ar-chars');
          mats.forEach(function (m) {
            var on = s.materia.indexOf(m.id) >= 0;
            var bt = el('button', 'ar-pick', esc(m.name || m.id)); bt.type = 'button'; bt.disabled = running;
            bt.setAttribute('aria-pressed', on ? 'true' : 'false');
            bt.addEventListener('click', function () { var k = s.materia.indexOf(m.id); if (k >= 0) s.materia.splice(k, 1); else s.materia.push(m.id); saveSetup(s); paintSetup(box, b, s); });
            mp.appendChild(bt);
          });
          box.appendChild(mp);
        }
      }
    }

    var bar = el('div', 'btn-row sim-actions');
    var go = el('button', 'btn btn-primary', Kit.icon('sword') + '<span class="lbl">' + (running ? 'Running...' : 'Run simulation') + '</span>'); go.type = 'button'; go.id = 'simRun'; go.disabled = running;
    go.addEventListener('click', startRun);
    bar.appendChild(go);
    if (running) {
      var cx = el('button', 'btn btn-danger', Kit.icon('x') + '<span class="lbl">Cancel</span>'); cx.type = 'button'; cx.id = 'simCancel';
      cx.addEventListener('click', cancelRun);
      bar.appendChild(cx);
    }
    box.appendChild(bar);
    var prog = el('div', 'sim-progress'); prog.id = 'simProgress'; prog.hidden = !running;
    prog.innerHTML = '<div class="sim-track" role="progressbar" aria-valuemin="0" aria-valuemax="100" aria-valuenow="0" aria-label="Simulation progress"><i id="simBar"></i></div><div class="sim-progtext" id="simProgText" aria-live="polite"></div>';
    box.appendChild(prog);
    if (running) paintProgress();
  }
  function paintProgress() {
    if (!RUN) return;
    var bar = document.getElementById('simBar'), txt = document.getElementById('simProgText'), tr = bar && bar.parentNode;
    if (!bar || !txt) return;
    var p = RUN.total ? Math.min(100, Math.round(RUN.done / RUN.total * 100)) : 0;
    bar.style.width = p + '%';
    if (tr) tr.setAttribute('aria-valuenow', String(p));
    var finished = Object.keys(RUN.rows).length;
    txt.textContent = p + ' percent, ' + RUN.done + ' of ' + RUN.total + ' battles, ' + finished + ' of ' + RUN.jobs.length + ' troops finished';
    // Keep the partial table current while the run goes.
    var out = document.getElementById('simOut');
    if (out && out.getAttribute('data-finished') !== String(finished)) {
      out.setAttribute('data-finished', String(finished));
      destroyCharts();
      U.clear(out);
      paintResults(out, cur(), defaultSetup(cur()));
    }
  }

  function currentRows() {
    if (RUN) return { rows: Object.keys(RUN.rows).map(function (k) { return RUN.rows[k]; }).sort(function (a, z) { return a.idx - z.idx; }), skipped: RUN.skipped, meta: RUN.meta, status: 'running', stamp: RUN.stamp };
    return LAST;
  }
  function paintResults(box, b, s) {
    var d = currentRows();
    if (!d) {
      var e0 = el('section', 'panel sim-empty');
      e0.innerHTML = '<h3>No results yet</h3><p>Run the simulation to see the win rate of every troop against its target, how long fights last, what they cost, and where the damage comes from.</p>';
      var b0 = el('button', 'btn btn-primary', Kit.icon('sword') + '<span class="lbl">Run simulation</span>'); b0.type = 'button';
      b0.addEventListener('click', startRun);
      e0.appendChild(b0);
      box.appendChild(e0);
      return;
    }
    if (d.status === 'noworker') {
      box.appendChild(el('section', 'panel sim-error', '<h3>Simulator unavailable</h3><p class="msg msg-error">' + esc(d.message) + '</p>'));
      return;
    }
    if (d.status === 'error') box.appendChild(el('section', 'panel sim-error', '<p class="msg msg-error">' + esc(d.message) + '</p>'));
    var rows = d.rows || [];
    if (!rows.length) {
      var e1 = el('section', 'panel sim-empty');
      var lines = (d.skipped || []).map(function (k) { return '<li><strong>' + esc(k.name) + '</strong>: ' + esc(k.reason) + '</li>'; }).join('');
      var title = d.status === 'running' ? 'Waiting for the first troop' : d.status === 'cancelled' ? 'Cancelled before any troop finished' : 'Nothing to simulate';
      var text = d.status === 'running' ? 'The first results appear when one troop finishes all of its battles.' : d.status === 'cancelled' ? 'A troop is only reported once all of its battles are done. Run again with fewer battles per troop to see results sooner.' : 'No troop matched these settings. Tag troops to a chapter in Rules and give each chapter an Expected Party State.';
      e1.innerHTML = '<h3>' + title + '</h3><p>' + text + '</p>' +
        (lines ? '<ul class="sim-skips">' + lines + '</ul>' : '');
      box.appendChild(e1);
      return;
    }
    // summary
    var flagged = rows.filter(function (r) { return r.flag; }).length;
    var totalBattles = rows.reduce(function (a, r) { return a + r.battles; }, 0);
    var sum = el('section', 'panel sim-summary');
    var stale = !RUN && d.stamp && b.kit.updatedAt !== d.stamp;
    sum.innerHTML = '<h2 class="panel-title">Results</h2><div class="sim-chips">' +
      '<span class="chip">' + rows.length + ' troop' + (rows.length === 1 ? '' : 's') + '</span>' +
      '<span class="chip">' + totalBattles + ' battles</span>' +
      '<span class="chip ' + (flagged ? 'chip-warning' : 'chip-ok') + '">' + flagged + ' off target</span>' +
      (d.skipped && d.skipped.length ? '<span class="chip chip-muted">' + d.skipped.length + ' skipped</span>' : '') +
      (d.status === 'running' ? '<span class="chip chip-accent">partial, still running</span>' : '') +
      (d.status === 'cancelled' ? '<span class="chip chip-warning">cancelled, partial</span>' : '') +
      (stale ? '<span class="chip chip-warning">the project changed since this run</span>' : '') +
      '</div>';
    box.appendChild(sum);
    paintTable(box, b, rows, d);
    paintCharts(box, b, rows);
  }
  function statusChip(r) {
    if (r.target == null) return '<span class="chip chip-muted">no target</span>';
    if (!r.flag) return '<span class="chip chip-ok">on target</span>';
    return r.flag === 'hard' ? '<span class="chip chip-error">too hard</span>' : '<span class="chip chip-warning">too easy</span>';
  }
  function paintTable(box, b, rows, d) {
    var sec = el('section', 'panel sim-table');
    sec.appendChild(el('h3', 'section-h', 'Win rate by troop'));
    sec.appendChild(el('p', 'ar-note', 'A troop is flagged when its win rate is more than 10 points from its chapter\'s target.'));
    var wrap = el('div', 'tbl-wrap');
    var tb = el('table', 'tbl sim-tbl');
    tb.innerHTML = '<thead><tr><th>Troop</th><th>Chapter</th><th>Win</th><th>Target</th><th>Gap</th><th>Turns</th><th>HP</th><th>MP</th><th>Status</th><th>Fix</th></tr></thead>';
    var body = el('tbody');
    rows.forEach(function (r) {
      var tr = el('tr', r.flag ? 'is-flag' : '');
      tr.setAttribute('data-troop', r.troopId);
      tr.innerHTML = '<th scope="row">' + esc(r.name) + '<small class="mono">' + esc(r.troopId) + '</small></th>' +
        '<td>' + r.chapterNo + '. ' + esc(shortName(r.chapterName, 22)) + '</td>' +
        '<td>' + pct(r.winPct) + '<small>' + r.win + ' of ' + r.battles + '</small></td>' +
        '<td>' + (r.target == null ? '-' : pct(r.target)) + '</td>' +
        '<td>' + (r.gap == null ? '-' : (r.gap > 0 ? '+' : '') + (Math.round(r.gap * 10) / 10).toFixed(1)) + '</td>' +
        '<td>' + (Math.round(r.avgTurns * 10) / 10).toFixed(1) + '</td>' +
        '<td>' + pct(r.hpPct) + '</td><td>' + pct(r.mpPct) + '</td>' +
        '<td>' + statusChip(r) + (r.timeout ? '<small>' + r.timeout + ' timed out</small>' : '') + '</td>';
      var fix = el('td', 'sim-fix');
      if (r.flag) {
        var t = recOf(b, r.troopId);
        var bT = el('button', 'btn', 'Troop'); bT.type = 'button'; bT.title = 'Open this troop in Rules';
        bT.addEventListener('click', function () { Kit.jump(r.troopId); });
        fix.appendChild(bT);
        var seen = {};
        var enemies = (t && Array.isArray(t.members) ? t.members : []).map(function (m) { return m && m.enm; }).filter(function (id) { if (!id || seen[id]) return false; seen[id] = 1; return !!recOf(b, id); });
        enemies.slice(0, 3).forEach(function (id) {
          var en = recOf(b, id);
          var bE = el('button', 'btn', 'Enemy: ' + esc(shortName(en.name || id, 14))); bE.type = 'button'; bE.title = 'Open this enemy in Rules';
          bE.addEventListener('click', function () { Kit.jump(id); });
          fix.appendChild(bE);
        });
        var bA = el('button', 'btn btn-primary', 'Arena'); bA.type = 'button'; bA.title = 'Fight this troop with the same party and a recorded seed';
        bA.addEventListener('click', function () { openArena(r, d.meta); });
        fix.appendChild(bA);
      } else fix.appendChild(el('span', 'muted', '-'));
      tr.appendChild(fix);
      body.appendChild(tr);
    });
    tb.appendChild(body);
    wrap.appendChild(tb);
    sec.appendChild(wrap);
    if (d.skipped && d.skipped.length) {
      var sk = el('div', 'sim-skipbox');
      sk.appendChild(el('h4', 'sim-skiph', 'Skipped troops'));
      var ul = el('ul', 'sim-skips');
      d.skipped.forEach(function (k) { ul.appendChild(el('li', '', '<strong>' + esc(k.name) + '</strong>: ' + esc(k.reason))); });
      sk.appendChild(ul);
      sec.appendChild(sk);
    }
    box.appendChild(sec);
  }
  // Loads the Arena with the same party and a seed from this run (a lost battle for a troop that is too hard, a won one when too easy).
  function openArena(r, meta) {
    var cfg = Kit.store.get('saga146:arena:setup', null);
    cfg = U.isObj(cfg) ? cfg : {};
    cfg.chars = r.chars.slice(0, PARTY_MAX);
    cfg.weatherId = meta && meta.weatherId ? meta.weatherId : null;
    var source = r.chapterId;
    if (meta && meta.mode === 'custom') { source = 'custom'; cfg.level = meta.level; cfg.gearTier = meta.gearTier; cfg.materia = cur() ? (defaultSetup(cur()).materia || []) : []; }
    cfg.source = source;
    Kit.store.set('saga146:arena:setup', cfg);
    var seed = r.flag === 'easy' ? (r.seedWin || r.seedLoss) : (r.seedLoss || r.seedWin);
    window.WS.arena.preload(r.troopId, { source: source, seed: seed || undefined });
  }

  // ------------------------------------------------------------------ charts
  function chartBox(title, id, help) {
    var p = el('section', 'panel sim-chartpanel');
    var h = el('div', 'sim-charthead');
    h.appendChild(el('h3', 'section-h', title));
    p.appendChild(h);
    if (help) p.appendChild(el('p', 'ar-note', help));
    var holder = el('div', 'sim-chart'); holder.id = id;
    p.appendChild(holder);
    return { panel: p, holder: holder, head: h };
  }
  function fallbackTable(holder, labels, sets) {
    var wrap = el('div', 'tbl-wrap');
    var tb = el('table', 'tbl');
    var th = '<thead><tr><th></th>' + sets.map(function (x) { return '<th>' + esc(x.label) + '</th>'; }).join('') + '</tr></thead>';
    var bd = labels.map(function (l, i) { return '<tr><th scope="row">' + esc(l) + '</th>' + sets.map(function (x) { return '<td>' + (Math.round(num(x.data[i]) * 10) / 10) + '</td>'; }).join('') + '</tr>'; }).join('');
    tb.innerHTML = th + '<tbody>' + bd + '</tbody>';
    wrap.appendChild(tb);
    holder.classList.add('is-table');
    holder.appendChild(wrap);
    holder.appendChild(el('p', 'ar-note', 'Chart.js could not load, so the numbers are shown as a table.'));
  }
  function drawChart(holder, key, cfg, labels, sets, alt) {
    if (typeof window.Chart !== 'function') { fallbackTable(holder, labels, sets); return; }
    var canvas = el('canvas'); canvas.setAttribute('role', 'img'); canvas.setAttribute('aria-label', alt);
    holder.appendChild(canvas);
    try { CHARTS[key] = new window.Chart(canvas.getContext('2d'), cfg); }
    catch (e) { U.clear(holder); fallbackTable(holder, labels, sets); }
  }
  function baseOptions(yTitle, xTitle) {
    var ink = cssVar('--ink2', '#c4bba3'), grid = cssVar('--line', '#323a52');
    return {
      responsive: true, maintainAspectRatio: false, animation: false,
      plugins: { legend: { labels: { color: ink, boxWidth: 12 } }, tooltip: { intersect: false, mode: 'index' } },
      scales: {
        x: { ticks: { color: ink, maxRotation: 50, autoSkip: true }, grid: { color: grid }, title: { display: !!xTitle, text: xTitle || '', color: ink } },
        y: { beginAtZero: true, ticks: { color: ink }, grid: { color: grid }, title: { display: !!yTitle, text: yTitle || '', color: ink } }
      }
    };
  }
  function focusRows(rows) { return V.focus === 'all' ? rows : rows.filter(function (r) { return r.troopId === V.focus; }); }
  function paintCharts(box, b, rows) {
    var grid = el('div', 'sim-charts');
    box.appendChild(grid);
    var ok = cssVar('--ok', '#86cf88'), danger = cssVar('--danger', '#f07a6e'), accent = cssVar('--accent', '#e3b453'), fwd = cssVar('--fwd', '#b1a1ff'), ink = cssVar('--ink2', '#c4bba3');
    var labels = rows.map(function (r) { return shortName(r.name, 16); });

    // 1. win rate by troop with the target line
    var c1 = chartBox('Win rate by troop', 'simChart1', 'Bars are the simulated win rate. The dashed line is the target from the chapter\'s Expected Party State.');
    c1.panel.classList.add('is-wide');
    grid.appendChild(c1.panel);
    var win = rows.map(function (r) { return Math.round(r.winPct * 10) / 10; });
    var tgt = rows.map(function (r) { return r.target == null ? null : r.target; });
    var o1 = baseOptions('Win rate (%)');
    o1.scales.y.max = 100;
    drawChart(c1.holder, 'win', {
      type: 'bar',
      data: { labels: labels, datasets: [
        { type: 'bar', label: 'Win rate', data: win, backgroundColor: rows.map(function (r) { return r.flag ? (r.flag === 'hard' ? danger : accent) : ok; }), borderWidth: 0, order: 2 },
        { type: 'line', label: 'Target', data: tgt, borderColor: ink, backgroundColor: ink, borderDash: [6, 4], borderWidth: 2, pointStyle: 'rectRot', pointRadius: 5, spanGaps: true, order: 1 }
      ] },
      options: o1
    }, labels, [{ label: 'Win %', data: win }, { label: 'Target %', data: tgt.map(function (v) { return v == null ? 0 : v; }) }], 'Bar chart of simulated win rate per troop with a target line.');

    // 3. resource cost
    var c3 = chartBox('Resource cost', 'simChart3', 'Average HP lost and MP spent per battle, as a percent of the party\'s maximum.');
    c3.panel.classList.add('is-wide');
    grid.appendChild(c3.panel);
    var hp = rows.map(function (r) { return Math.round(r.hpPct * 10) / 10; }), mp = rows.map(function (r) { return Math.round(r.mpPct * 10) / 10; });
    var o3 = baseOptions('Percent of maximum (%)');
    drawChart(c3.holder, 'cost', {
      type: 'bar', data: { labels: labels, datasets: [
        { label: 'HP lost', data: hp, backgroundColor: danger, borderWidth: 0 },
        { label: 'MP spent', data: mp, backgroundColor: fwd, borderWidth: 0 }
      ] }, options: o3
    }, labels, [{ label: 'HP %', data: hp }, { label: 'MP %', data: mp }], 'Grouped bar chart of HP lost and MP spent per troop.');

    // troop picker for charts 2 and 4
    var pick = el('div', 'sim-pickrow');
    var selOpts = [{ value: 'all', label: 'All troops' }].concat(rows.map(function (r) { return { value: r.troopId, label: r.name }; }));
    if (V.focus !== 'all' && !rows.some(function (r) { return r.troopId === V.focus; })) V.focus = 'all';
    var sel = select('simFocus', selOpts, V.focus, function (v) {
      V.focus = v;
      var out = document.getElementById('simOut');
      if (out) { destroyCharts(); U.clear(out); paintResults(out, cur(), defaultSetup(cur())); }
    });
    pick.appendChild(field('Turns and damage charts show', sel));
    grid.appendChild(pick);

    var fr = focusRows(rows);
    var fLabel = V.focus === 'all' ? 'all troops' : (fr[0] ? fr[0].name : '');

    // 2. turn count distribution
    var c2 = chartBox('Turn count distribution', 'simChart2', 'How many turns each battle lasted, for ' + fLabel + '.');
    grid.appendChild(c2.panel);
    var all = [];
    fr.forEach(function (r) { r.turns.forEach(function (t) { all.push(t); }); });
    var maxT = all.reduce(function (a, v) { return Math.max(a, v); }, 1);
    var width = Math.max(1, Math.ceil(maxT / 20)), nb = Math.ceil(maxT / width) + 1, bins = [], bl = [], i;
    for (i = 0; i < nb; i++) { bins.push(0); bl.push(width === 1 ? String(i) : (i * width) + '-' + (i * width + width - 1)); }
    all.forEach(function (t) { bins[Math.min(nb - 1, Math.floor(t / width))]++; });
    var o2 = baseOptions('Battles', 'Turns');
    o2.plugins.legend.display = false;
    drawChart(c2.holder, 'turns', {
      type: 'bar', data: { labels: bl, datasets: [{ label: 'Battles', data: bins, backgroundColor: fwd, borderWidth: 0 }] }, options: o2
    }, bl, [{ label: 'Battles', data: bins }], 'Histogram of battle lengths in turns for ' + fLabel + '.');

    // 4. damage spread by element
    var c4 = chartBox('Damage by element', 'simChart4', 'Total party damage dealt to foes, for ' + fLabel + '.');
    grid.appendChild(c4.panel);
    var elements = (rs(b).elements || []).filter(function (e) { return e && e.key; });
    var tot = {};
    fr.forEach(function (r) { Object.keys(r.damage).forEach(function (k) { tot[k] = (tot[k] || 0) + r.damage[k]; }); });
    var keys = elements.map(function (e) { return e.key; });
    Object.keys(tot).forEach(function (k) { if (k !== NONE && keys.indexOf(k) < 0) keys.push(k); });
    keys.push(NONE);
    var el4 = keys.map(function (k) { if (k === NONE) return 'Neutral'; var e = elements.filter(function (x) { return x.key === k; })[0]; return e ? (e.label || k) : k; });
    var dv = keys.map(function (k) { return Math.round(tot[k] || 0); });
    var dc = keys.map(function (k) { var e = elements.filter(function (x) { return x.key === k; })[0]; return e && /^#[0-9a-f]{6}$/i.test(e.color || '') ? e.color : (k === NONE ? '#8c8778' : accent); });
    var o4 = baseOptions(null, 'Damage');
    o4.indexAxis = 'y'; o4.plugins.legend.display = false;
    o4.scales.y = { ticks: { color: ink }, grid: { color: cssVar('--line', '#323a52') } };
    o4.scales.x.beginAtZero = true;
    drawChart(c4.holder, 'dmg', {
      type: 'bar', data: { labels: el4, datasets: [{ label: 'Damage', data: dv, backgroundColor: dc, borderWidth: 0 }] }, options: o4
    }, el4, [{ label: 'Damage', data: dv }], 'Bar chart of party damage by element for ' + fLabel + '.');
  }

  Kit.on('theme', function () { if (Kit.active() === 'sim' && document.getElementById('simRoot')) paintAll(); });
  Kit.on('load', function () { LAST = null; });
  Kit.mount('sim', { title: 'Simulator', icon: 'chart', canEnter: WSX.canEnter, render: WSX.render, onLeave: function () { destroyCharts(); V.host = null; return true; } });
})();
// === WS:SIM END ===
// === APP:BOOT BEGIN ===
(function () {
  'use strict';
  function wire(id, icon, label, fn) {
    var b = document.getElementById(id);
    if (!b) return;
    if (icon) b.innerHTML = Kit.icon(icon) + (label ? '<span class="lbl">' + label + '</span>' : '');
    b.addEventListener('click', fn);
  }
  Kit.theme.apply();
  try {
    window.matchMedia('(prefers-color-scheme: light)').addEventListener('change', function () { if (Kit.theme.get() === 'system') Kit.theme.apply(); });
  } catch (e) {}
  wire('btnSettings', 'gear', null, function () { Kit.settings.open(); });
  document.getElementById('btnTheme').addEventListener('click', Kit.theme.toggle);
  wire('btnTitle', null, null, Kit.renameProject);
  wire('btnValidation', null, null, Kit.openValidation);
  wire('btnSave', 'save', 'Save', function () { if (Kit.bundle.save()) Kit.ui.toast('Draft saved in this browser.', 'ok'); });
  wire('btnSlots', 'slots', 'Slots', Kit.openSlots);
  wire('btnImport', 'import', 'Import', function () { var f = document.getElementById('fileImport'); f.value = ''; f.click(); });
  wire('btnExport', 'export', 'Export', Kit.openExport);
  // First run welcome card (Pass 6). It explains the three stages and stays out of the way once dismissed.
  function paintWelcome() {
    var w = document.getElementById('welcome');
    if (!w) return;
    U_clear(w);
    w.innerHTML = '<h2>Welcome to Saga Forge</h2>' +
      '<p>Saga Forge starts empty. You define everything yourself in three stages, then test the battles you made.</p>' +
      '<ol class="welcome-stages">' +
      '<li><strong>Charter</strong><span>Write your saga: premise, party, chapters, and the ruleset. Lock it when it has no errors.</span></li>' +
      '<li><strong>Codex</strong><span>Generate the record types that your locked ruleset calls for, such as materia or classes.</span></li>' +
      '<li><strong>Rules</strong><span>Author characters, abilities, enemies, and troops. Fight them in the Arena and balance them in the Simulator.</span></li>' +
      '</ol>' +
      '<div class="btn-row"><button class="btn btn-primary" id="welcomeGo" type="button">Start with the Charter</button><button class="btn btn-ghost" id="welcomeHide" type="button">Dismiss</button></div>';
    document.getElementById('welcomeGo').addEventListener('click', function () { hideWelcome(); Kit.go('charter'); });
    document.getElementById('welcomeHide').addEventListener('click', hideWelcome);
  }
  function U_clear(n) { while (n.firstChild) n.removeChild(n.firstChild); }
  function hideWelcome() { var w = document.getElementById('welcome'); if (w) w.hidden = true; Kit.uiState.set({ welcomeSeen: true }); }
  function showWelcome() { var w = document.getElementById('welcome'); if (!w) return; paintWelcome(); w.hidden = false; try { w.scrollIntoView({ block: 'start' }); } catch (e) {} }
  document.getElementById('btnWelcome').addEventListener('click', showWelcome);
  Kit.welcome = { show: showWelcome, hide: hideWelcome };
  var booted = false;
  Kit.on('change', function (e) {
    var w = document.getElementById('welcome');
    if (booted && w && !w.hidden && String((e && e.reason) || 'edit') !== 'restore') hideWelcome();
  });
  document.getElementById('fileImport').addEventListener('change', function (e) {
    var f = e.target.files && e.target.files[0];
    Kit.importPicked(f);
  });
  document.addEventListener('keydown', function (e) {
    if ((e.ctrlKey || e.metaKey) && !e.shiftKey && !e.altKey && (e.key === 's' || e.key === 'S')) {
      e.preventDefault();
      if (Kit.bundle.save()) Kit.ui.toast('Draft saved in this browser.', 'ok');
    } else if (e.key === 'Escape' && Kit.ui.overlayCount() && !Kit.ui.busy.active()) {
      e.preventDefault();
      Kit.ui.closeTop();
    }
  });
  var suspended = Kit.bundle.suspend.load();
  if (!Kit.uiState.get().welcomeSeen) { paintWelcome(); document.getElementById('welcome').hidden = false; }
  var b = Kit.bundle.restoreDraft() || Kit.bundle.create('Untitled Saga');
  var want = (suspended && suspended.bundleId === b.kit.bundleId && suspended.workspace) || Kit.uiState.get().tab || 'charter';
  if (!Kit.go(want, { silent: true })) Kit.go('charter', { silent: true });
  booted = true;
  document.addEventListener('visibilitychange', function () { if (document.visibilityState === 'hidden') Kit.bundle.suspend.save(); });
  window.addEventListener('pagehide', function () { Kit.bundle.suspend.save(); });
})();
// === APP:BOOT END ===
</script>
</body>
</html>