@open-slot-ui/core 0.0.1

package/dist/index.js

@@ -0,0 +1,2271 @@
+// src/signal.ts
+var Signal = class {
+  _value;
+  subs = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this._value = initial;
+  }
+  get() {
+    return this._value;
+  }
+  set(next) {
+    if (Object.is(next, this._value)) return;
+    this._value = next;
+    for (const fn of [...this.subs]) fn(next);
+  }
+  /** Mutate-in-place then notify (for objects whose identity is stable). */
+  update(mutate) {
+    mutate(this._value);
+    for (const fn of [...this.subs]) fn(this._value);
+  }
+  subscribe(fn) {
+    this.subs.add(fn);
+    return () => {
+      this.subs.delete(fn);
+    };
+  }
+  get size() {
+    return this.subs.size;
+  }
+};
+function effect(fn, deps) {
+  const run = () => fn();
+  const disposers = deps.map((d) => d.subscribe(run));
+  run();
+  return () => {
+    for (const d of disposers) d();
+  };
+}
+
+// src/events.ts
+var EventBus = class {
+  map = /* @__PURE__ */ new Map();
+  on(type, fn) {
+    let set = this.map.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.map.set(type, set);
+    }
+    const wrapped = fn;
+    set.add(wrapped);
+    return () => {
+      set?.delete(wrapped);
+    };
+  }
+  emit(type, payload) {
+    const set = this.map.get(type);
+    if (!set) return;
+    for (const fn of [...set]) fn(payload);
+  }
+};
+
+// src/theme/tokens.ts
+var defaultTheme = {
+  color: {
+    accent: "#ffc935",
+    accentText: "#1a1a1a",
+    surface: "#161b22",
+    surfaceAlt: "#0b0e13",
+    text: "#ffffff",
+    textDim: "#7a8290",
+    disabled: "#3a3f47"
+  },
+  radius: { pill: 999, card: 16 },
+  space: { sm: 8, md: 16, lg: 24 },
+  type: { family: "system-ui, sans-serif", size: { sm: 14, md: 18, lg: 28 } },
+  motion: { fast: 120, base: 200, slow: 360 }
+};
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function merge(base, patch) {
+  const out = { ...base };
+  for (const key of Object.keys(patch)) {
+    const pv = patch[key];
+    const bv = base[key];
+    out[key] = isObject(pv) && isObject(bv) ? merge(bv, pv) : pv;
+  }
+  return out;
+}
+function extendTheme(base, patch) {
+  return merge(base, patch);
+}
+
+// src/layout/screen.ts
+var defaultLayoutConfig = {
+  refLandscape: [1920, 1080],
+  refPortrait: [1080, 1920],
+  portraitBelowAspect: 0.85,
+  breakpoints: { mobile: 480, tablet: 840 }
+};
+function breakpointFor(width, height, cfg) {
+  const short = Math.min(Math.max(width, 1), Math.max(height, 1));
+  if (short <= cfg.breakpoints.mobile) return "mobile";
+  if (short <= cfg.breakpoints.tablet) return "tablet";
+  return "desktop";
+}
+function computeScreen(width, height, cfg) {
+  const w = Math.max(width, 1);
+  const h = Math.max(height, 1);
+  const orientation = w / h < cfg.portraitBelowAspect ? "portrait" : "landscape";
+  const [rw, rh] = orientation === "portrait" ? cfg.refPortrait : cfg.refLandscape;
+  const scale = Math.min(w / rw, h / rh);
+  return { width: w, height: h, orientation, breakpoint: breakpointFor(w, h, cfg), scale };
+}
+
+// src/layout/anchor.ts
+function anchorFactors(anchor) {
+  const ax = anchor.includes("left") ? 0 : anchor.includes("right") ? 1 : 0.5;
+  const ay = anchor.includes("top") ? 0 : anchor.includes("bottom") ? 1 : 0.5;
+  return [ax, ay];
+}
+function resolvePlacement(spec, screen) {
+  const [ax, ay] = anchorFactors(spec.anchor);
+  const [ox, oy] = spec.offset ?? [0, 0];
+  return {
+    x: ax * screen.width + ox * screen.scale,
+    y: ay * screen.height + oy * screen.scale,
+    scale: screen.scale * (spec.scale ?? 1),
+    rotation: (spec.rotation ?? 0) * Math.PI / 180
+  };
+}
+
+// src/transition/Transition.ts
+var Squish = class {
+  constructor(scale = 0.92, ms = 120) {
+    this.scale = scale;
+    this.ms = ms;
+  }
+  scale;
+  ms;
+  kind = "squish";
+};
+var Pulse = class {
+  constructor(scale = 1.06, ms = 160) {
+    this.scale = scale;
+    this.ms = ms;
+  }
+  scale;
+  ms;
+  kind = "pulse";
+};
+var Turn = class {
+  /** Rotations per second; loops until the state changes. */
+  constructor(rps = 1, loop = true) {
+    this.rps = rps;
+    this.loop = loop;
+  }
+  rps;
+  loop;
+  kind = "turn";
+};
+var Fade = class {
+  constructor(alpha = 0.4, ms = 160) {
+    this.alpha = alpha;
+    this.ms = ms;
+  }
+  alpha;
+  ms;
+  kind = "fade";
+};
+var Sequence = class {
+  constructor(steps) {
+    this.steps = steps;
+  }
+  steps;
+  kind = "sequence";
+};
+var Parallel = class {
+  constructor(steps) {
+    this.steps = steps;
+  }
+  steps;
+  kind = "parallel";
+};
+
+// src/control/Control.ts
+var Control = class {
+  id;
+  role;
+  layout;
+  /** Current state name, observable. */
+  state;
+  /** The renderer sets this so `inspect()` can report bounds/animation. */
+  viewInspect;
+  /**
+   * Optional host gate (e.g. a ref-counted input lock). When set, the control is
+   * interactable only if its state allows it AND the gate returns true. Set per
+   * instance — by OpenUI on register — so multiple HUDs on one page never share
+   * lock state. Interactability stays *derived*, never stored (Charter P6).
+   */
+  gate;
+  disposers = [];
+  transitionSubs = /* @__PURE__ */ new Set();
+  constructor(opts, initial) {
+    this.id = opts.id;
+    this.role = opts.role;
+    this.layout = opts.layout;
+    this.state = new Signal(initial);
+  }
+  get current() {
+    return this.state.get();
+  }
+  /** Derived, never stored (Charter P6). Folds in the optional host gate. */
+  get interactable() {
+    const base = this.states[this.current]?.interactable ?? false;
+    return base && (this.gate?.() ?? true);
+  }
+  /** Transition to a new state. Throws on unknown states (illegal states unrepresentable). */
+  setState(to) {
+    if (!(to in this.states)) {
+      throw new Error(`[open-ui] control "${this.id}": unknown state "${to}"`);
+    }
+    const from = this.current;
+    if (to === from) return;
+    this.state.set(to);
+    const t = this.states[to]?.transition;
+    for (const fn of [...this.transitionSubs]) fn(t, to, from);
+  }
+  /** The renderer subscribes to play the entry transition for each state change. */
+  onTransition(fn) {
+    this.transitionSubs.add(fn);
+    return () => {
+      this.transitionSubs.delete(fn);
+    };
+  }
+  inspect() {
+    return this.viewInspect?.() ?? { bounds: null, animating: false };
+  }
+  /** Leak-free teardown (Charter P12). */
+  dispose() {
+    for (const d of this.disposers) d();
+    this.disposers.length = 0;
+    this.transitionSubs.clear();
+    this.viewInspect = void 0;
+  }
+};
+
+// src/controls/SpinControl.ts
+var SpinControl = class extends Control {
+  constructor(opts, bus) {
+    super({ id: opts.id ?? "spin", role: "button", layout: opts.layout }, "idle");
+    this.bus = bus;
+    this.holdToSpin = opts.holdToSpin ?? false;
+  }
+  bus;
+  states = {
+    idle: { interactable: true, transition: new Squish(0.94, 120) },
+    hover: { interactable: true, transition: new Pulse(1.06, 160) },
+    pressed: { interactable: true, transition: new Squish(0.86, 70) },
+    // Spinning no longer rotates — the button just squishes on press and sits.
+    spinning: { interactable: false, transition: new Squish(0.94, 120) },
+    stop: { interactable: true, transition: new Pulse(1.08, 140) },
+    auto: { interactable: true, transition: new Pulse(1.06, 160) },
+    disabled: { interactable: false, transition: new Fade(0.4, 160) }
+  };
+  /**
+   * When true, the view arms press-and-hold: holding the spin button fires a
+   * `holdSpinStarted` and the host turbo-spins until release (`holdSpinStopped`).
+   * A quick tap still spins once. Toggleable via the `spin.press` config.
+   */
+  holdToSpin = false;
+  /**
+   * Whether tapping mid-spin slam-stops/skips the reels. Stake Engine's
+   * `disabledSlamstop` jurisdiction flag sets this false → the button then LOCKS
+   * (dims, no tap) during a spin instead of skipping. Observable so the view can
+   * re-dim if it flips at runtime (e.g. on `applyJurisdiction`).
+   */
+  allowSlamStop = new Signal(true);
+  /**
+   * Whether the keyboard (Space / Enter) can trigger a spin. Stake's
+   * `disabledSpacebar` sets this false (and turns off hold-to-spin). The renderer
+   * reads it; RTS 14D requires a fresh press per cycle (no auto-repeat).
+   */
+  allowKeyboard = new Signal(true);
+  /**
+   * Remaining free spins (0 = normal play). Set it > 0 and the spin button switches
+   * to its free-spins face — a big remaining count over an "FS" label — via the view;
+   * back to 0 returns the normal play button. The host drives the loop; this is just
+   * the display. Set with {@link setFreeSpins}.
+   */
+  freeSpins = new Signal(0);
+  /**
+   * Derived (Charter P6), with the slam-stop guard folded in: when slam-stop is
+   * disabled, the in-spin `stop`/`auto` affordance is locked — the button can't be
+   * tapped to skip; it just dims.
+   */
+  get interactable() {
+    if (!this.allowSlamStop.get() && (this.current === "auto" || this.current === "stop")) return false;
+    return super.interactable;
+  }
+  // ---- façade (the game talks to these) ----
+  busy() {
+    this.setState("spinning");
+  }
+  idle() {
+    this.setState("idle");
+  }
+  stopState() {
+    this.setState("stop");
+  }
+  /** Show the autoplay-engaged look (press to stop). */
+  auto() {
+    this.setState("auto");
+  }
+  enable() {
+    if (this.current === "disabled") this.setState("idle");
+  }
+  disable() {
+    this.setState("disabled");
+  }
+  // ---- input (the view calls this on a valid press-release) ----
+  activate() {
+    if (this.current === "auto") {
+      if (this.allowSlamStop.get()) this.bus.emit("skipRequested", void 0);
+      return;
+    }
+    if (this.interactable) this.bus.emit("spinRequested", void 0);
+  }
+  /** View calls this when a press is held past the hold threshold. Returns whether
+   *  hold-to-spin engaged (so the view knows to wait for release). */
+  holdBegin() {
+    if (!this.holdToSpin || !this.interactable) return false;
+    this.bus.emit("holdSpinStarted", void 0);
+    return true;
+  }
+  /** View calls this on release after a hold — the host stops the turbo loop. */
+  holdEnd() {
+    this.bus.emit("holdSpinStopped", void 0);
+  }
+  /** Switch the button to / from its free-spins face. `n > 0` shows "n FS"; `0`
+   *  restores the normal play button. Non-number/negative is clamped to 0 (P11). */
+  setFreeSpins(n) {
+    this.freeSpins.set(typeof n === "number" && Number.isFinite(n) && n > 0 ? Math.floor(n) : 0);
+  }
+};
+
+// src/safe.ts
+function safeAmount(n, lastGood) {
+  return typeof n === "number" && Number.isFinite(n) ? n : lastGood;
+}
+function clampDecimals(d) {
+  if (typeof d !== "number" || !Number.isFinite(d)) return 2;
+  return Math.max(0, Math.min(8, Math.trunc(d)));
+}
+function clampDigits(n) {
+  if (typeof n !== "number" || !Number.isFinite(n)) return 9;
+  return Math.max(1, Math.min(18, Math.trunc(n)));
+}
+function clampMinDigits(n) {
+  if (typeof n !== "number" || !Number.isFinite(n)) return 0;
+  return Math.max(0, Math.min(18, Math.trunc(n)));
+}
+function integerDigits(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 1;
+  return String(Math.floor(Math.abs(value))).length;
+}
+function displayDigits(value, minTotal, decimals) {
+  const d = clampDecimals(decimals);
+  const min = clampMinDigits(minTotal);
+  return Math.min(18, Math.max(min, integerDigits(value) + d, d + 1));
+}
+function valueFitMaxWidth(digits, columnWidth) {
+  return clampDigits(digits) * columnWidth + 64;
+}
+
+// src/controls/ValueDisplay.ts
+var ValueDisplay = class extends Control {
+  states = { idle: { interactable: false } };
+  value = new Signal(0);
+  currency;
+  label;
+  /** Minimum odometer column width (0 = auto: sized tightly to the value, grows as it
+   *  does). Read by the renderer at build time, so set it before mount (or declaratively
+   *  via `controls.{id}.digits`). */
+  digits;
+  constructor(opts) {
+    super({ id: opts.id, role: "status", layout: opts.layout }, "idle");
+    const c = opts.currency;
+    this.currency = new Signal(
+      c && typeof c.code === "string" ? { ...c, decimals: clampDecimals(c.decimals) } : { code: "USD", decimals: 2 }
+    );
+    this.label = opts.label;
+    this.digits = clampMinDigits(opts.digits ?? 0);
+    if (opts.initial != null) this.value.set(opts.initial);
+  }
+  /** Set the minimum odometer column width (clamped 0..18; 0 = auto). Read by the
+   *  renderer at build time, so set it before mount (or via `controls.{id}.digits`). */
+  setDigits(n) {
+    this.digits = clampMinDigits(n);
+  }
+  /** Never-reject: NaN/Infinity/non-number degrade to a no-op, keeping the last
+   *  good value — malformed host data never throws into the render loop (P11). */
+  set(amount) {
+    this.value.set(safeAmount(amount, this.value.get()));
+  }
+  get() {
+    return this.value.get();
+  }
+  /** Keep the prior spec on malformed input; clamp decimals to 0..8 (P11). */
+  setCurrency(spec) {
+    if (!spec || typeof spec.code !== "string") return;
+    this.currency.set({ ...spec, decimals: clampDecimals(spec.decimals) });
+  }
+  /** Integer minor units for the counter (no float drift). */
+  get minorUnits() {
+    return Math.round(this.value.get() * Math.pow(10, this.currency.get().decimals));
+  }
+};
+
+// src/controls/ButtonControl.ts
+var ButtonControl = class extends Control {
+  constructor(opts, bus) {
+    super({ id: opts.id, role: opts.role ?? "button", layout: opts.layout }, "idle");
+    this.bus = bus;
+    this.label = opts.label;
+  }
+  bus;
+  states = {
+    idle: { interactable: true, transition: new Squish(0.94, 110) },
+    hover: { interactable: true, transition: new Pulse(1.05, 140) },
+    pressed: { interactable: true, transition: new Squish(0.88, 70) },
+    disabled: { interactable: false, transition: new Fade(0.4, 150) }
+  };
+  label;
+  enable() {
+    if (this.current === "disabled") this.setState("idle");
+  }
+  disable() {
+    this.setState("disabled");
+  }
+  /** The view calls this on a valid press-release. */
+  activate() {
+    if (this.interactable) this.bus?.emit("buttonActivated", { id: this.id });
+  }
+};
+
+// src/controls/SliderControl.ts
+var clamp01 = (v) => Math.min(1, Math.max(0, v));
+var SliderControl = class extends Control {
+  constructor(opts, bus) {
+    super({ id: opts.id, role: "slider", layout: opts.layout }, "idle");
+    this.bus = bus;
+    this.label = opts.label;
+    if (opts.initial != null) this.value.set(clamp01(opts.initial));
+  }
+  bus;
+  states = {
+    idle: { interactable: true },
+    dragging: { interactable: true }
+  };
+  value = new Signal(0.5);
+  label;
+  /** Set the normalized value (0..1) and notify. */
+  setNormalized(v) {
+    const c = clamp01(v);
+    if (c === this.value.get()) return;
+    this.value.set(c);
+    this.bus?.emit("valueChanged", { id: this.id, value: c });
+  }
+  beginDrag() {
+    this.setState("dragging");
+  }
+  endDrag() {
+    this.setState("idle");
+  }
+};
+
+// src/controls/PanelControl.ts
+var PanelControl = class extends Control {
+  constructor(opts, bus) {
+    super({ id: opts.id, role: "dialog", layout: opts.layout ?? { anchor: "center" } }, "closed");
+    this.bus = bus;
+    this.variant = opts.variant;
+    this.title = opts.title;
+  }
+  bus;
+  states = {
+    closed: { interactable: false },
+    open: { interactable: true }
+  };
+  variant;
+  title;
+  get isOpen() {
+    return this.current === "open";
+  }
+  openPanel() {
+    if (this.isOpen) return;
+    this.setState("open");
+    this.bus?.emit("panelToggled", { id: this.id, open: true });
+  }
+  closePanel() {
+    if (!this.isOpen) return;
+    this.setState("closed");
+    this.bus?.emit("panelToggled", { id: this.id, open: false });
+  }
+  toggle() {
+    if (this.isOpen) this.closePanel();
+    else this.openPanel();
+  }
+};
+
+// src/controls/ToggleControl.ts
+var ToggleControl = class extends Control {
+  constructor(opts, bus) {
+    super({ id: opts.id, role: "switch", layout: opts.layout }, opts.on ? "on" : "off");
+    this.bus = bus;
+  }
+  bus;
+  states = {
+    off: { interactable: true, transition: new Squish(0.92, 110) },
+    on: { interactable: true, transition: new Pulse(1.08, 150) },
+    disabled: { interactable: false, transition: new Fade(0.4, 150) }
+  };
+  get isOn() {
+    return this.current === "on";
+  }
+  set(on) {
+    const next = on ? "on" : "off";
+    if (next === this.current) return;
+    this.setState(next);
+    this.bus?.emit("toggled", { id: this.id, on });
+  }
+  /** Called by the view on a valid press-release. */
+  toggle() {
+    if (this.current === "disabled") return;
+    this.set(!this.isOn);
+  }
+  enable() {
+    if (this.current === "disabled") this.setState("off");
+  }
+  disable() {
+    this.setState("disabled");
+  }
+};
+
+// src/controls/TurboControl.ts
+var TurboControl = class _TurboControl extends Control {
+  constructor(opts, bus) {
+    const modes = opts.modes?.length ? opts.modes.slice() : ["off", "on"];
+    const start = clampIndex(opts.index ?? 0, modes.length);
+    super({ id: opts.id, role: "switch", layout: opts.layout }, modes[start]);
+    this.bus = bus;
+    this._modes = modes;
+    this.states = _TurboControl.buildStates(modes);
+    this.index = new Signal(start);
+  }
+  bus;
+  states;
+  _modes;
+  /** Current mode index, observable (0 = off). */
+  index;
+  static buildStates(modes) {
+    const states = {};
+    modes.forEach((m, i) => {
+      states[m] = { interactable: true, transition: i === 0 ? new Squish(0.92, 110) : new Pulse(1.06 + i * 0.02, 150) };
+    });
+    states.disabled = { interactable: false, transition: new Fade(0.4, 150) };
+    return states;
+  }
+  /** The ordered modes (the first is "off"). */
+  get modes() {
+    return this._modes;
+  }
+  /** Number of modes (2 = toggle, 3 = three-mode switcher). */
+  get modeCount() {
+    return this._modes.length;
+  }
+  /** The current mode name. */
+  get mode() {
+    return this.current;
+  }
+  /** True for any mode past "off" — the 2-mode `isOn` semantics, preserved. */
+  get isOn() {
+    return this.current !== "disabled" && this.index.get() > 0;
+  }
+  /** Replace the mode ladder (e.g. switch a game from 2-mode to 3-mode at runtime). */
+  setModes(modes) {
+    if (!modes.length) return;
+    this._modes = modes.slice();
+    this.states = _TurboControl.buildStates(this._modes);
+    this.goTo(clampIndex(this.index.get(), this._modes.length), false);
+  }
+  /** Advance to the next mode, wrapping back to "off". The view's tap handler. */
+  cycle() {
+    if (this.current === "disabled") return;
+    this.goTo((this.index.get() + 1) % this._modes.length);
+  }
+  /** Jump to a specific mode index (clamped). */
+  setIndex(i) {
+    if (this.current === "disabled") return;
+    this.goTo(clampIndex(i, this._modes.length));
+  }
+  /** 2-mode convenience: off (index 0) or on (index 1). */
+  set(on) {
+    this.goTo(on ? Math.min(1, this._modes.length - 1) : 0);
+  }
+  /** Alias kept so old `toggle()` callers compile — same as `cycle()`. */
+  toggle() {
+    this.cycle();
+  }
+  goTo(i, emit = true) {
+    const next = this._modes[i];
+    const changed = next !== this.current || i !== this.index.get();
+    this.index.set(i);
+    this.setState(next);
+    if (emit && changed) {
+      this.bus?.emit("turboChanged", { id: this.id, mode: next, index: i });
+      this.bus?.emit("toggled", { id: this.id, on: i > 0 });
+    }
+  }
+  enable() {
+    if (this.current === "disabled") this.goTo(this.index.get(), false);
+  }
+  disable() {
+    this.setState("disabled");
+  }
+};
+function clampIndex(i, len) {
+  if (!Number.isFinite(i)) return 0;
+  return Math.max(0, Math.min(Math.floor(i), len - 1));
+}
+
+// src/controls/StepperControl.ts
+var StepperControl = class extends Control {
+  constructor(opts, bus) {
+    super({ id: opts.id, role: "spinbutton", layout: opts.layout }, "idle");
+    this.bus = bus;
+    this.levels = opts.levels.length ? opts.levels : [0];
+    this.index = new Signal(this.clampIndex(opts.index ?? 0));
+    this.label = opts.label;
+  }
+  bus;
+  states = { idle: { interactable: true } };
+  index;
+  /** Optional caption (e.g. "Bet"). */
+  label;
+  levels;
+  clampIndex(i) {
+    return Math.max(0, Math.min(this.levels.length - 1, i));
+  }
+  get value() {
+    return this.levels[this.index.get()] ?? 0;
+  }
+  get canInc() {
+    return this.index.get() < this.levels.length - 1;
+  }
+  get canDec() {
+    return this.index.get() > 0;
+  }
+  inc() {
+    if (this.canInc) this.setIndex(this.index.get() + 1);
+  }
+  dec() {
+    if (this.canDec) this.setIndex(this.index.get() - 1);
+  }
+  setIndex(i) {
+    const next = this.clampIndex(i);
+    if (next === this.index.get()) return;
+    this.index.set(next);
+    this.bus?.emit("valueChanged", { id: this.id, value: this.value });
+  }
+  /** Replace the level list (e.g. when the currency/limits change). */
+  setLevels(levels, index = 0) {
+    const prior = this.value;
+    if (levels.length) this.levels = levels;
+    this.index.set(this.clampIndex(index));
+    if (this.value !== prior) this.bus?.emit("valueChanged", { id: this.id, value: this.value });
+  }
+};
+
+// src/controls/AutoplayControl.ts
+var AutoplayControl = class extends Control {
+  constructor(opts, bus) {
+    super({ id: opts.id, role: "button", layout: opts.layout }, "idle");
+    this.bus = bus;
+    this._options = opts.options ?? [10, 25, 50, 100, Infinity];
+    this._lossLimitOptions = opts.lossLimitOptions ?? [];
+    this._winLimitOptions = opts.winLimitOptions ?? [];
+    this.mode = opts.mode ?? "options";
+    this.count = new Signal(0);
+  }
+  bus;
+  states = {
+    idle: { interactable: true, transition: new Squish(0.94, 110) },
+    picking: { interactable: true },
+    active: { interactable: true, transition: new Pulse(1.06, 150) },
+    disabled: { interactable: false, transition: new Fade(0.4, 150) }
+  };
+  /** Remaining spins while active (Infinity = ∞). 0 when not active. */
+  count;
+  _options;
+  _lossLimitOptions;
+  _winLimitOptions;
+  /** Active stop-on-total-loss (multiples of bet; Infinity = no limit). */
+  lossLimit = Infinity;
+  /** Active stop-on-single-win (multiples of bet; Infinity = no limit). */
+  singleWinLimit = Infinity;
+  /** Running net loss this autoplay session (bet − win, summed). */
+  netLoss = 0;
+  /** Tap behavior (`'options'` opens the picker, `'infinite'` starts immediately). */
+  mode;
+  /** Count choices shown in the picker (Infinity allowed = ∞). */
+  get options() {
+    return this._options;
+  }
+  /** Loss-limit choices for the picker (multiples of bet; Infinity = no limit). */
+  get lossLimitOptions() {
+    return this._lossLimitOptions;
+  }
+  /** Single-win-stop choices for the picker (multiples of bet; Infinity = no limit). */
+  get winLimitOptions() {
+    return this._winLimitOptions;
+  }
+  /** Replace the picker's count choices (e.g. when limits change). */
+  setOptions(options) {
+    if (options.length) this._options = options.slice();
+  }
+  /** Replace the picker's loss-limit / single-win-stop choices. */
+  setLossLimitOptions(options) {
+    this._lossLimitOptions = Array.isArray(options) ? options.slice() : [];
+  }
+  setWinLimitOptions(options) {
+    this._winLimitOptions = Array.isArray(options) ? options.slice() : [];
+  }
+  get isActive() {
+    return this.current === "active";
+  }
+  openPicker() {
+    if (this.current === "idle") this.setState("picking");
+  }
+  cancelPicker() {
+    if (this.current === "picking") this.setState("idle");
+  }
+  /** Choose a count (+ optional RG limits) from the picker → start autoplay. */
+  pick(count, limits = {}) {
+    if (this.current !== "picking") return;
+    this.begin(count, limits);
+  }
+  /** Start autoplay with a count (Infinity = ∞) + optional RG limits, from idle or
+   *  the picker. The limits are enforced as the host reports each round's outcome
+   *  via {@link reportResult}. */
+  begin(count, limits = {}) {
+    if (this.current !== "idle" && this.current !== "picking") return;
+    this.lossLimit = limits.lossLimit ?? Infinity;
+    this.singleWinLimit = limits.singleWinLimit ?? Infinity;
+    this.netLoss = 0;
+    this.count.set(count);
+    this.setState("active");
+    this.bus?.emit("autoplayStarted", { count, lossLimit: this.lossLimit, singleWinLimit: this.singleWinLimit });
+  }
+  /**
+   * The host reports one completed autoplay round's outcome (major units) — this is
+   * the responsible-gambling guardrail. It advances the remaining count and stops
+   * autoplay if: the count is exhausted, the cumulative net loss reaches the
+   * loss-limit, or this single win reaches the single-win-stop. No-op when autoplay
+   * isn't active or the inputs are malformed (Charter P11).
+   */
+  reportResult(win, bet) {
+    if (this.current !== "active") return;
+    if (!Number.isFinite(win) || !Number.isFinite(bet)) return;
+    this.netLoss += bet - win;
+    const c = this.count.get();
+    if (Number.isFinite(c)) this.count.set(Math.max(0, c - 1));
+    const winHit = Number.isFinite(this.singleWinLimit) && win >= this.singleWinLimit * bet;
+    const lossHit = Number.isFinite(this.lossLimit) && this.netLoss >= this.lossLimit * bet;
+    if (this.count.get() <= 0 || winHit || lossHit) this.stop();
+  }
+  stop() {
+    if (this.current !== "active") return;
+    this.count.set(0);
+    this.setState("idle");
+    this.bus?.emit("autoplayStopped", void 0);
+  }
+  /** Host updates the remaining count during play. Infinity is valid (∞); only
+   *  NaN/non-number is rejected, so bad host data never corrupts the badge (P11). */
+  setCount(n) {
+    if (typeof n !== "number" || Number.isNaN(n)) return;
+    this.count.set(n);
+  }
+  /** The view's tap handler. In `'infinite'` mode, idle starts straight away;
+   *  in `'options'` mode, idle opens the picker. Active always stops. */
+  press() {
+    if (this.current === "idle") {
+      if (this.mode === "infinite") this.begin(Infinity);
+      else this.openPicker();
+    } else if (this.current === "active") this.stop();
+    else if (this.current === "picking") this.cancelPicker();
+  }
+  disable() {
+    this.setState("disabled");
+  }
+  enable() {
+    if (this.current === "disabled") this.setState("idle");
+  }
+};
+
+// src/controls/ReadoutControl.ts
+var ReadoutControl = class extends Control {
+  states = { idle: { interactable: false } };
+  value = new Signal(0);
+  /** Whether a `'duration'` readout is currently advancing. */
+  running = new Signal(false);
+  kind;
+  label;
+  decimals;
+  signed;
+  /** Present for the `'currency'` kind so the view can format + react to changes. */
+  currency;
+  constructor(opts) {
+    super({ id: opts.id, role: "status", layout: opts.layout }, "idle");
+    this.kind = opts.kind ?? "plain";
+    this.label = opts.label;
+    this.decimals = opts.decimals ?? (this.kind === "percent" ? 1 : 0);
+    this.signed = opts.signed ?? true;
+    if (opts.currency) this.currency = new Signal(opts.currency);
+    if (opts.value != null) this.value.set(safeAmount(opts.value, 0));
+  }
+  /** Never-reject: malformed input keeps the last good value (P11). */
+  set(v) {
+    this.value.set(safeAmount(v, this.value.get()));
+  }
+  get() {
+    return this.value.get();
+  }
+  setCurrency(spec) {
+    if (this.currency && spec && typeof spec.code === "string") this.currency.set(spec);
+  }
+  // ── duration / session timer ────────────────────────────────────────────────
+  /** Advance an elapsed-time readout by `deltaSec` (the renderer calls this each frame). */
+  tick(deltaSec) {
+    if (this.kind !== "duration" || !this.running.get()) return;
+    if (!Number.isFinite(deltaSec) || deltaSec <= 0) return;
+    this.value.set(this.value.get() + deltaSec);
+  }
+  start() {
+    this.running.set(true);
+  }
+  stop() {
+    this.running.set(false);
+  }
+  reset() {
+    this.value.set(0);
+  }
+};
+
+// src/controls/CardControl.ts
+var CardControl = class extends Control {
+  constructor(opts, bus) {
+    super({ id: opts.id, role: "button", layout: opts.layout }, "idle");
+    this.bus = bus;
+    this.title = opts.title;
+    this.price = opts.price;
+    this.image = opts.image;
+  }
+  bus;
+  states = {
+    idle: { interactable: true, transition: new Squish(0.96, 110) },
+    hover: { interactable: true, transition: new Pulse(1.04, 140) },
+    pressed: { interactable: true, transition: new Squish(0.9, 70) },
+    disabled: { interactable: false, transition: new Fade(0.4, 150) }
+  };
+  title;
+  price;
+  image;
+  enable() {
+    if (this.current === "disabled") this.setState("idle");
+  }
+  disable() {
+    this.setState("disabled");
+  }
+  /** The view calls this on a valid press-release. */
+  activate() {
+    if (this.interactable) this.bus?.emit("cardActivated", { id: this.id });
+  }
+};
+
+// src/controls/SelectControl.ts
+var SelectControl = class extends Control {
+  constructor(opts, bus) {
+    if (!opts.options || opts.options.length === 0) {
+      throw new Error(`[open-ui] select "${opts.id}": needs at least one option`);
+    }
+    super({ id: opts.id, role: opts.role ?? "listbox", layout: opts.layout }, "closed");
+    this.bus = bus;
+    this._options = opts.options.slice();
+    this.caption = opts.label;
+    this.index = new Signal(this.clamp(opts.index ?? 0));
+  }
+  bus;
+  states = {
+    closed: { interactable: true, transition: new Squish(0.96, 100) },
+    open: { interactable: true, transition: new Pulse(1.04, 140) },
+    disabled: { interactable: false, transition: new Fade(0.4, 150) }
+  };
+  index;
+  /** Caption (e.g. "Language") — distinct from the selected option's label. */
+  caption;
+  _options;
+  clamp(i) {
+    if (!Number.isFinite(i)) return 0;
+    return Math.max(0, Math.min(this._options.length - 1, Math.trunc(i)));
+  }
+  get options() {
+    return this._options;
+  }
+  get value() {
+    return this._options[this.index.get()]?.value ?? "";
+  }
+  get optionLabel() {
+    return this._options[this.index.get()]?.label ?? "";
+  }
+  get isOpen() {
+    return this.current === "open";
+  }
+  openList() {
+    if (this.current === "closed") this.setState("open");
+  }
+  closeList() {
+    if (this.current === "open") this.setState("closed");
+  }
+  /** Choose by value (the view's list-item handler). Closes the list. */
+  choose(value) {
+    const i = this._options.findIndex((o) => o.value === value);
+    if (i < 0) return;
+    if (i !== this.index.get()) {
+      this.index.set(i);
+      this.bus?.emit("optionSelected", { id: this.id, value: this.value, index: i });
+    }
+    if (this.current === "open") this.setState("closed");
+  }
+  /** Jump to an index (clamped). Emits only if it changed. */
+  setIndex(i) {
+    const next = this.clamp(i);
+    if (next === this.index.get()) return;
+    this.index.set(next);
+    this.bus?.emit("optionSelected", { id: this.id, value: this.value, index: next });
+  }
+  /** Advance to the next option, wrapping (the view's cycle-on-tap handler). */
+  cycle() {
+    if (this._options.length < 2) return;
+    this.setIndex((this.index.get() + 1) % this._options.length);
+  }
+  /** Replace the option list (e.g. when limits or locale change). */
+  setOptions(options, index = 0) {
+    if (!options.length) return;
+    this._options = options.slice();
+    this.index.set(this.clamp(index));
+    this.bus?.emit("optionSelected", { id: this.id, value: this.value, index: this.index.get() });
+  }
+  enable() {
+    if (this.current === "disabled") this.setState("closed");
+  }
+  disable() {
+    this.setState("disabled");
+  }
+};
+
+// src/theme/presets.ts
+var themePresets = Object.freeze({
+  default: defaultTheme
+});
+var HEX = /^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var RGB = /^rgba?\(\s*[0-9.\s,%/]+\)$/i;
+function isSafeColor(v) {
+  return typeof v === "string" && (HEX.test(v.trim()) || RGB.test(v.trim()));
+}
+var clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
+function sanitizeThemeOverrides(ov, onIssue) {
+  const out = {};
+  if (ov.color) {
+    const color = {};
+    for (const [k, v] of Object.entries(ov.color)) {
+      if (isSafeColor(v)) color[k] = v.trim();
+      else onIssue?.({ level: "warn", path: `theme.color.${k}`, code: "bad-color", message: `"${String(v)}" is not a valid colour \u2014 kept the theme default` });
+    }
+    if (Object.keys(color).length) out.color = color;
+  }
+  if (ov.radius) {
+    const radius = {};
+    for (const [k, v] of Object.entries(ov.radius)) {
+      if (typeof v === "number" && Number.isFinite(v)) radius[k] = clamp(v, 0, 999);
+      else onIssue?.({ level: "warn", path: `theme.radius.${k}`, code: "bad-radius", message: `radius "${String(v)}" must be a finite number \u2014 ignored` });
+    }
+    if (Object.keys(radius).length) out.radius = radius;
+  }
+  if (ov.type?.family != null) {
+    if (typeof ov.type.family === "string" && ov.type.family.trim()) out.type = { family: ov.type.family };
+    else onIssue?.({ level: "warn", path: "theme.type.family", code: "bad-family", message: "font family must be a non-empty string \u2014 ignored" });
+  }
+  return out;
+}
+function isPresetChoice(c) {
+  return typeof c === "object" && c !== null && ("preset" in c || "overrides" in c);
+}
+function resolveTheme(choice, onIssue) {
+  if (!choice) return defaultTheme;
+  if (typeof choice === "string") return themePresets[choice] ?? defaultTheme;
+  if (isPresetChoice(choice)) {
+    const base = choice.preset ? themePresets[choice.preset] ?? defaultTheme : defaultTheme;
+    if (!choice.overrides) return base;
+    return Object.freeze(extendTheme(base, sanitizeThemeOverrides(choice.overrides, onIssue)));
+  }
+  return Object.freeze(extendTheme(defaultTheme, sanitizeThemeOverrides(choice, onIssue)));
+}
+
+// src/registry/ControlRegistry.ts
+var CENTER = { anchor: "center" };
+var ControlRegistry = class _ControlRegistry {
+  factories = /* @__PURE__ */ new Map();
+  register(kind, factory) {
+    this.factories.set(kind, factory);
+  }
+  has(kind) {
+    return this.factories.has(kind);
+  }
+  /** Build the Control for a block, or null for non-control blocks / unknown kinds. */
+  resolve(block, bus) {
+    return this.factories.get(block.kind)?.(block, bus) ?? null;
+  }
+  /** A registry with every built-in block kind wired to its reference control. */
+  static defaults() {
+    const r = new _ControlRegistry();
+    r.register("slider", (b, bus) => b.kind === "slider" ? new SliderControl({ id: b.id, layout: CENTER, label: b.label, initial: b.initial }, bus) : null);
+    r.register("toggle", (b, bus) => b.kind === "toggle" ? new ToggleControl({ id: b.id, layout: CENTER, on: b.on }, bus) : null);
+    r.register("button", (b, bus) => b.kind === "button" ? new ButtonControl({ id: b.id, layout: CENTER, label: b.label, role: b.role }, bus) : null);
+    r.register("select", (b, bus) => b.kind === "select" ? new SelectControl({ id: b.id, layout: CENTER, options: b.options, index: b.index, label: b.label }, bus) : null);
+    r.register("stepper", (b, bus) => b.kind === "stepper" ? new StepperControl({ id: b.id, layout: CENTER, levels: b.levels, index: b.index, label: b.label }, bus) : null);
+    r.register("value", (b) => b.kind === "value" ? new ValueDisplay({ id: b.id, layout: CENTER, label: b.label, currency: b.currency ?? { code: "USD", decimals: 2 }, initial: b.initial }) : null);
+    return r;
+  }
+};
+
+// src/spec/types.ts
+var BLOCK_KINDS = [
+  "slider",
+  "toggle",
+  "button",
+  "select",
+  "stepper",
+  "value",
+  "text",
+  "heading",
+  "subheading",
+  "callout",
+  "stat-grid",
+  "steps",
+  "table",
+  "paytable",
+  "image",
+  "media",
+  "cards",
+  "legal",
+  "divider",
+  "group"
+];
+
+// src/spec/validateSpec.ts
+var ANCHORS = /* @__PURE__ */ new Set([
+  "top-left",
+  "top-center",
+  "top-right",
+  "center-left",
+  "center",
+  "center-right",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right"
+]);
+var AUTOPLAY_MODES = /* @__PURE__ */ new Set(["options", "infinite"]);
+var SPIN_PRESS = /* @__PURE__ */ new Set(["tap", "hold-to-spin"]);
+var RESPONSIVE_KEYS = /* @__PURE__ */ new Set(["mobile", "tablet", "desktop", "portrait", "landscape"]);
+function validateSpec(spec) {
+  const issues = [];
+  const add = (level, path, code, message) => {
+    issues.push({ level, path, code, message });
+  };
+  const ids = /* @__PURE__ */ new Set();
+  const seeId = (id, path) => {
+    if (!id || !id.trim()) add("error", path, "blank-id", "control id must be a non-empty string");
+    else if (ids.has(id)) add("error", path, "dup-id", `duplicate control id "${id}"`);
+    else ids.add(id);
+  };
+  const checkLayout = (anchor, path) => {
+    if (anchor && !ANCHORS.has(anchor)) add("error", path, "bad-anchor", `unknown anchor "${anchor}"`);
+  };
+  try {
+    if (spec.betLadder) {
+      const lv = spec.betLadder.levels;
+      if (!Array.isArray(lv) || lv.length === 0) {
+        add("error", "betLadder.levels", "empty-levels", "bet ladder needs at least one level");
+      } else if (spec.betLadder.index != null && (spec.betLadder.index < 0 || spec.betLadder.index >= lv.length)) {
+        add("error", "betLadder.index", "index-oor", `index ${spec.betLadder.index} is out of range 0..${lv.length - 1}`);
+      }
+    }
+    if (spec.autoplay?.options) {
+      spec.autoplay.options.forEach((o, i) => {
+        if (!(typeof o === "number" && o > 0)) {
+          add("error", `autoplay.options[${i}]`, "bad-option", `autoplay option must be > 0 (Infinity allowed), got ${String(o)}`);
+        }
+      });
+    }
+    if (spec.autoplay?.mode && !AUTOPLAY_MODES.has(spec.autoplay.mode)) {
+      add("error", "autoplay.mode", "bad-mode", `autoplay.mode must be 'options' or 'infinite', got "${String(spec.autoplay.mode)}"`);
+    }
+    for (const key of ["lossLimits", "winLimits"]) {
+      const arr = spec.autoplay?.[key];
+      if (arr) {
+        arr.forEach((o, i) => {
+          if (!(typeof o === "number" && o > 0)) add("error", `autoplay.${key}[${i}]`, "bad-limit", `autoplay ${key} must be > 0 (Infinity allowed), got ${String(o)}`);
+        });
+      }
+    }
+    if (spec.turbo) {
+      const m = spec.turbo.modes;
+      if (Array.isArray(m)) {
+        if (m.length < 2) add("error", "turbo.modes", "turbo-too-few", "a turbo ladder needs at least 2 modes (first = off)");
+        if (m.some((x) => typeof x !== "string" || !x.trim())) add("error", "turbo.modes", "turbo-bad-mode", "turbo mode names must be non-empty strings");
+        if (new Set(m).size !== m.length) add("error", "turbo.modes", "turbo-dup-mode", "turbo mode names must be unique");
+      } else if (m != null && m !== 2 && m !== 3) {
+        add("error", "turbo.modes", "turbo-bad-count", `turbo.modes preset must be 2 or 3, got ${String(m)}`);
+      }
+      const len = Array.isArray(m) ? m.length : m ?? 2;
+      if (spec.turbo.index != null && (spec.turbo.index < 0 || spec.turbo.index >= len)) {
+        add("error", "turbo.index", "index-oor", `turbo.index ${spec.turbo.index} is out of range 0..${len - 1}`);
+      }
+    }
+    if (spec.spin?.press && !SPIN_PRESS.has(spec.spin.press)) {
+      add("error", "spin.press", "bad-press", `spin.press must be 'tap' or 'hold-to-spin', got "${String(spec.spin.press)}"`);
+    }
+    if (spec.responsive) {
+      for (const [key, ov] of Object.entries(spec.responsive)) {
+        if (!RESPONSIVE_KEYS.has(key)) {
+          add("error", `responsive.${key}`, "bad-bucket", `unknown responsive bucket "${key}" (expected ${[...RESPONSIVE_KEYS].join(", ")})`);
+        }
+        if (ov?.controls) {
+          for (const [id, co] of Object.entries(ov.controls)) {
+            checkLayout(co.layout?.anchor, `responsive.${key}.controls.${id}.layout.anchor`);
+          }
+        }
+      }
+    }
+    if (spec.currency && typeof spec.currency === "object" && typeof spec.currency.decimals === "number") {
+      const d = spec.currency.decimals;
+      if (d < 0 || d > 8) add("warn", "currency.decimals", "decimals-range", `decimals ${d} clamped to 0..8`);
+    }
+    if (spec.jurisdiction) {
+      for (const [k, v] of Object.entries(spec.jurisdiction)) {
+        if (k === "minimumRoundDuration") {
+          if (v != null && !(typeof v === "number" && Number.isFinite(v) && v >= 0)) {
+            add("error", `jurisdiction.${k}`, "bad-duration", `minimumRoundDuration must be a non-negative number, got ${String(v)}`);
+          }
+        } else if (v != null && typeof v !== "boolean") {
+          add("error", `jurisdiction.${k}`, "bad-flag", `jurisdiction.${k} must be a boolean, got ${String(v)}`);
+        }
+      }
+    }
+    if (spec.rtp != null && !(typeof spec.rtp === "number" && Number.isFinite(spec.rtp))) {
+      add("error", "rtp", "bad-rtp", `rtp must be a number, got ${String(spec.rtp)}`);
+    }
+    if (spec.statusBar != null && spec.statusBar !== "top" && spec.statusBar !== "bottom") {
+      add("error", "statusBar", "bad-statusbar", `statusBar must be 'top' or 'bottom', got "${String(spec.statusBar)}"`);
+    }
+    if (spec.realityCheck != null && !(typeof spec.realityCheck.everyMinutes === "number" && spec.realityCheck.everyMinutes > 0)) {
+      add("error", "realityCheck.everyMinutes", "bad-interval", "realityCheck.everyMinutes must be a number > 0");
+    }
+    if (spec.controls) {
+      for (const [id, ov] of Object.entries(spec.controls)) {
+        checkLayout(ov.layout?.anchor, `controls.${id}.layout.anchor`);
+        if (ov.digits != null) {
+          if (!(typeof ov.digits === "number" && Number.isFinite(ov.digits))) {
+            add("error", `controls.${id}.digits`, "bad-digits", `digits must be a number, got ${String(ov.digits)}`);
+          } else if (ov.digits < 0 || ov.digits > 18) {
+            add("warn", `controls.${id}.digits`, "digits-range", `digits ${ov.digits} clamped to 0..18 (0 = auto)`);
+          }
+        }
+      }
+    }
+    const walkBlocks = (blocks, base) => {
+      blocks?.forEach((b, i) => {
+        const p = `${base}[${i}]`;
+        if (!BLOCK_KINDS.includes(b.kind)) {
+          add("error", `${p}.kind`, "unknown-kind", `unknown block kind "${String(b.kind)}"`);
+          return;
+        }
+        seeId(b.id, `${p}.id`);
+        if (b.kind === "select" && (!b.options || b.options.length === 0)) {
+          add("error", `${p}.options`, "select-empty", "a select block needs at least one option");
+        }
+        if (b.kind === "slider" && b.initial != null && (b.initial < 0 || b.initial > 1)) {
+          add("error", `${p}.initial`, "slider-range", `slider initial ${b.initial} must be 0..1`);
+        }
+        if (b.kind === "stepper" && (!b.levels || b.levels.length === 0)) {
+          add("error", `${p}.levels`, "empty-levels", "a stepper block needs at least one level");
+        }
+        if (b.kind === "stat-grid" && (!b.items || b.items.length === 0)) {
+          add("warn", `${p}.items`, "empty-grid", "a stat-grid block has no items");
+        }
+        if (b.kind === "steps" && (!b.items || b.items.length === 0)) {
+          add("warn", `${p}.items`, "empty-steps", "a steps block has no items");
+        }
+        if (b.kind === "paytable" && (!b.rows || b.rows.length === 0)) {
+          add("warn", `${p}.rows`, "empty-paytable", "a paytable block has no rows");
+        }
+        if (b.kind === "image" && (!b.src || !b.src.trim())) {
+          add("error", `${p}.src`, "image-src", "an image block needs a src");
+        }
+        if (b.kind === "image" && (b.width != null && b.width <= 0 || b.height != null && b.height <= 0)) {
+          add("error", `${p}.width`, "image-dims", "image width/height must be > 0 when set");
+        }
+        if (b.kind === "media" && (!b.src || !b.src.trim())) {
+          add("error", `${p}.src`, "image-src", "a media block needs an image src");
+        }
+        if (b.kind === "media" && (b.width != null && b.width <= 0 || b.height != null && b.height <= 0)) {
+          add("error", `${p}.width`, "image-dims", "media width/height must be > 0 when set");
+        }
+        if (b.kind === "cards" && (!b.items || b.items.length === 0)) {
+          add("warn", `${p}.items`, "empty-cards", "a cards block has no items");
+        }
+        if (b.kind === "table" && (!b.rows || b.rows.length === 0)) {
+          add("warn", `${p}.rows`, "empty-table", "a table block has no rows");
+        }
+        if (b.kind === "group") walkBlocks(b.children, `${p}.children`);
+      });
+    };
+    if (spec.menu?.banner && (!spec.menu.banner.src || !spec.menu.banner.src.trim())) {
+      add("error", "menu.banner.src", "image-src", "a menu banner needs a src");
+    }
+    walkBlocks(spec.menu?.settings, "menu.settings");
+    walkBlocks(spec.menu?.paytable, "menu.paytable");
+    walkBlocks(spec.menu?.rules, "menu.rules");
+    walkBlocks(spec.rules, "rules");
+    spec.panels?.forEach((pn, i) => {
+      seeId(pn.id, `panels[${i}].id`);
+      checkLayout(pn.layout?.anchor, `panels[${i}].layout.anchor`);
+      walkBlocks(pn.blocks, `panels[${i}].blocks`);
+    });
+  } catch (e) {
+    add("error", "", "validator-crash", e instanceof Error ? e.message : String(e));
+  }
+  return { ok: !issues.some((i) => i.level === "error"), issues };
+}
+
+// src/spec/buildPanel.ts
+function buildBlocks(blocks, bus, registry = ControlRegistry.defaults(), reuse) {
+  const controls = [];
+  const walk = (bs) => {
+    for (const b of bs) {
+      if (b.kind === "group") {
+        walk(b.children);
+        continue;
+      }
+      if (b.kind === "text") continue;
+      const existing = reuse?.(b.id);
+      if (existing) {
+        controls.push(existing);
+        continue;
+      }
+      const c = registry.resolve(b, bus);
+      if (c) controls.push(c);
+    }
+  };
+  walk(blocks);
+  return controls;
+}
+function buildPanel(spec, bus, registry = ControlRegistry.defaults()) {
+  const panel = new PanelControl(
+    { id: spec.id, variant: spec.variant, title: spec.title, layout: spec.layout },
+    bus
+  );
+  const controls = buildBlocks(spec.blocks, bus, registry);
+  return { panel, controls, blocks: spec.blocks };
+}
+function buttonBlocks(blocks) {
+  const out = [];
+  const walk = (bs) => {
+    for (const b of bs) {
+      if (b.kind === "button") out.push(b);
+      else if (b.kind === "group") walk(b.children);
+    }
+  };
+  walk(blocks);
+  return out;
+}
+
+// src/spec/jurisdiction.ts
+function applyJurisdiction(ui, jur) {
+  if (!jur) return;
+  const lockHidden = (id) => {
+    ui.forceHidden.add(id);
+    ui.setHidden(id, true);
+  };
+  if (jur.disabledFullscreen) lockHidden("fullscreen");
+  if (jur.disabledTurbo) lockHidden("turbo");
+  if (jur.disabledAutoplay) {
+    lockHidden("autoplay");
+    ui.autoplay.disable();
+  }
+  if (jur.disabledBuyFeature) {
+    lockHidden("bonus");
+    ui.bonusButton.disable();
+  }
+  if (jur.disabledSuperTurbo && ui.turbo.modeCount > 2) ui.turbo.setModes(["off", "on"]);
+  if (jur.disabledSlamstop) ui.spin.allowSlamStop.set(false);
+  if (jur.disabledSpacebar) {
+    ui.spin.holdToSpin = false;
+    ui.spin.allowKeyboard.set(false);
+  }
+  if (jur.displayRTP != null) ui.setHidden("rtp", !jur.displayRTP);
+  if (jur.displayNetPosition != null) ui.setHidden("net-position", !jur.displayNetPosition);
+  if (jur.displaySessionTimer != null) {
+    ui.setHidden("session-timer", !jur.displaySessionTimer);
+    if (jur.displaySessionTimer) ui.sessionTimer.start();
+    else ui.sessionTimer.stop();
+  }
+  if (jur.socialCasino != null) ui.setSocial(jur.socialCasino);
+  if (typeof jur.minimumRoundDuration === "number" && Number.isFinite(jur.minimumRoundDuration)) {
+    ui.minimumRoundDuration = Math.max(0, jur.minimumRoundDuration);
+  }
+}
+
+// src/notice.ts
+var RGS_ERROR_KEYS = Object.freeze({
+  ERR_IPB: { title: "openui.err.insufficient.title", message: "openui.err.insufficient.message" },
+  ERR_IS: { title: "openui.err.session.title", message: "openui.err.session.message" },
+  ERR_ATE: { title: "openui.err.session.title", message: "openui.err.session.message" },
+  ERR_GLE: { title: "openui.err.limit.title", message: "openui.err.limit.message" },
+  ERR_BE: { title: "openui.err.activebet.title", message: "openui.err.activebet.message" },
+  ERR_BNF: { title: "openui.err.generic.title", message: "openui.err.generic.message" },
+  ERR_LOC: { title: "openui.err.location.title", message: "openui.err.location.message" },
+  ERR_MAINTENANCE: { title: "openui.err.maintenance.title", message: "openui.err.maintenance.message" },
+  ERR_VAL: { title: "openui.err.generic.title", message: "openui.err.generic.message" },
+  ERR_GEN: { title: "openui.err.generic.title", message: "openui.err.generic.message" },
+  ERR_UE: { title: "openui.err.generic.title", message: "openui.err.generic.message" },
+  ERR_TIMEOUT: { title: "openui.err.connection.title", message: "openui.err.connection.message" }
+});
+var DEFAULT_NOTICE_ACTION = { label: "openui.ok", variant: "primary" };
+function errorBlocks(message, title, tone) {
+  return [
+    { kind: "heading", id: "notice-title", text: title },
+    { kind: "callout", id: "notice-body", tone, text: message }
+  ];
+}
+
+// src/i18n/translator.ts
+var openuiDefaults = {
+  "openui.spin": "Spin",
+  "openui.stop": "Stop",
+  "openui.autoplay": "Autoplay",
+  "openui.bet": "Bet",
+  "openui.balance": "Balance",
+  "openui.win": "Win",
+  "openui.menu": "Menu",
+  "openui.rules": "Rules",
+  "openui.paytable": "Paytable",
+  "openui.settings": "Settings",
+  "openui.close": "Close",
+  "openui.language": "Language",
+  // compliance readouts + autoplay limit headings
+  "openui.rtp": "RTP",
+  "openui.net": "Net",
+  "openui.session": "Session",
+  "openui.lossLimit": "Stop on loss",
+  "openui.winLimit": "Stop on single win",
+  // notice / error modal
+  "openui.ok": "OK",
+  "openui.cancel": "Cancel",
+  "openui.confirm": "Confirm",
+  "openui.continue": "Continue",
+  "openui.reload": "Reload",
+  "openui.error": "Error",
+  "openui.notice": "Notice",
+  "openui.replay": "Replay",
+  "openui.buyFeature.title": "Buy feature",
+  "openui.buyFeature.message": "Buy this feature now?",
+  "openui.freeSpins": "FS",
+  // ── social / sweepstakes wording (used when `ui.social` is on; see OpenUI.t) ──
+  // open-ui resolves `<key>.social` first in social mode, falling back to the base
+  // key. These are the gambling-loaded terms a sweepstakes jurisdiction must avoid;
+  // override any of them (or add `openui.bet.social` etc.) in your messages dict.
+  "openui.buyFeature.title.social": "Play bonus",
+  "openui.buyFeature.message.social": "Play this bonus now?",
+  "openui.win.social": "Prize",
+  // reality check (RTS 13) — {{minutes}} is interpolated by open-ui's scheduler
+  "openui.realityCheck.title": "Reality check",
+  "openui.realityCheck.message": "You've been playing for {{minutes}} minutes. Take a moment before continuing.",
+  // RGS error defaults (override via your messages dict or per-call)
+  "openui.err.generic.title": "Something went wrong",
+  "openui.err.generic.message": "Sorry, something went wrong. Please try again.",
+  "openui.err.insufficient.title": "Insufficient funds",
+  "openui.err.insufficient.message": "You don't have enough balance to place this bet.",
+  "openui.err.session.title": "Session expired",
+  "openui.err.session.message": "Your session has expired. Reload the game to continue.",
+  "openui.err.limit.title": "Limit reached",
+  "openui.err.limit.message": "A gambling limit has been reached. Please try again later.",
+  "openui.err.activebet.title": "Round in progress",
+  "openui.err.activebet.message": "You already have a round in progress. Reload to finish it.",
+  "openui.err.location.title": "Unavailable here",
+  "openui.err.location.message": "This game is not available in your location.",
+  "openui.err.maintenance.title": "Under maintenance",
+  "openui.err.maintenance.message": "The game is briefly down for maintenance. Please try again soon.",
+  "openui.err.connection.title": "Connection lost",
+  "openui.err.connection.message": "A stable connection is required. Reload to finish any open round."
+};
+function interpolate(template, vars) {
+  if (!vars) return template;
+  return template.replace(/\{\{(\w+)\}\}/g, (_m, k) => String(vars[k] ?? `{{${k}}}`));
+}
+var DictionaryTranslator = class {
+  constructor(messages, locale) {
+    this.messages = messages;
+    this._locale = locale;
+  }
+  messages;
+  _locale;
+  subs = /* @__PURE__ */ new Set();
+  get locale() {
+    return this._locale;
+  }
+  setLocale(next) {
+    if (next === this._locale) return;
+    this._locale = next;
+    for (const cb of [...this.subs]) cb(next);
+  }
+  t(key, vars) {
+    const resolved = this.messages[this._locale]?.[key] ?? openuiDefaults[key] ?? key;
+    return interpolate(resolved, vars);
+  }
+  onChange(cb) {
+    this.subs.add(cb);
+    return () => {
+      this.subs.delete(cb);
+    };
+  }
+};
+function dictionary(messages, locale) {
+  return new DictionaryTranslator(messages, locale);
+}
+
+// src/format/currency.ts
+var ZERO_DECIMAL = ["JPY", "KRW", "VND", "CLP", "ISK", "HUF", "TWD", "UGX", "XAF", "XOF", "PYG", "RWF"];
+var CRYPTO = { BTC: 8, ETH: 8, LTC: 8, BCH: 8, DOGE: 8, XRP: 6, SOL: 6, TRX: 6, USDT: 2, USDC: 2 };
+var CURRENCY_TABLE = Object.freeze({
+  ...Object.fromEntries(ZERO_DECIMAL.map((c) => [c, { decimals: 0 }])),
+  ...Object.fromEntries(Object.entries(CRYPTO).map(([c, d]) => [c, { decimals: d }])),
+  // Stake social currencies: Gold Coins + Stake Cash — shown as GC/SC, not fiat.
+  XGC: { decimals: 2, display: "GC", social: true },
+  XSC: { decimals: 2, display: "SC", social: true },
+  GC: { decimals: 2, display: "GC", social: true },
+  SC: { decimals: 2, display: "SC", social: true }
+});
+var upper = (code) => typeof code === "string" ? code.toUpperCase() : "";
+function isSocialCurrency(code) {
+  return CURRENCY_TABLE[upper(code)]?.social === true;
+}
+function resolveCurrency(code, overrides = {}) {
+  const info = CURRENCY_TABLE[upper(code)] ?? { decimals: 2 };
+  return {
+    code: overrides.code ?? info.display ?? code,
+    decimals: clampDecimals(overrides.decimals ?? info.decimals),
+    position: overrides.position ?? "suffix",
+    separator: overrides.separator ?? ",",
+    decimalChar: overrides.decimalChar ?? "."
+  };
+}
+function formatAmount(value, spec, opts = {}) {
+  const decimals = clampDecimals(spec.decimals);
+  const sep = spec.separator ?? ",";
+  const dot = spec.decimalChar ?? ".";
+  const n = Number.isFinite(value) ? value : 0;
+  const fixed = Math.abs(n).toFixed(decimals);
+  const [int = "0", frac] = fixed.split(".");
+  const grouped = int.replace(/\B(?=(\d{3})+(?!\d))/g, sep);
+  const body = frac ? `${grouped}${dot}${frac}` : grouped;
+  const sign = n < 0 ? "-" : opts.signed ? "+" : "";
+  const number = `${sign}${body}`;
+  return (spec.position ?? "suffix") === "prefix" ? `${spec.code} ${number}` : `${number} ${spec.code}`;
+}
+
+// src/OpenUI.ts
+var OpenUI = class {
+  theme;
+  layoutConfig;
+  bus = new EventBus();
+  screen;
+  /** i18n translator (the port — no hard i18next dep, Charter B5/B8). */
+  translator;
+  /** Current locale, observable — views re-render their text when it changes. */
+  locale;
+  /**
+   * Ref-counted input lock. While the count is above zero, `locked` is true and
+   * EVERY registered control reports not-interactable through its derived getter
+   * (Charter P6/G7) — no per-button bookkeeping, no desync. Instance-scoped: the
+   * gate each control receives in `register` reads THIS ui's `locked`.
+   */
+  locked = new Signal(false);
+  lockCount = 0;
+  /** Every subscription this ui owns, torn down by `dispose()` (Charter P12). */
+  disposers = [];
+  /** Control ids the spec marked hidden — still registered (so they stay
+   *  introspectable in `snapshot()`) but skipped by the renderer (Charter P10). */
+  hidden = /* @__PURE__ */ new Set();
+  /** Ids hidden UNCONDITIONALLY (e.g. a jurisdiction `disabled*` flag): `setHidden`
+   *  refuses to re-show these, so a responsive resize can't undo a compliance hide. */
+  forceHidden = /* @__PURE__ */ new Set();
+  /** Master mute (music+sfx), observable so an icon can reflect it. */
+  muted = new Signal(false);
+  /** Social / sweepstakes mode: swaps gambling wording (Bet/Buy → social terms) and,
+   *  paired with a social coin, shows GC/SC. Toggle with {@link setSocial}. */
+  social = new Signal(false);
+  /** Declarative blocks backing the menu-style notice/error modal. */
+  noticeBlocks = new Signal([]);
+  /** Action buttons for the notice/error modal (a single dismiss when empty). */
+  noticeActions = new Signal([]);
+  /** Whether the open notice is a BLOCKING/fatal modal — no backdrop/✕ dismiss and
+   *  the HUD is locked; it can be removed only in code (`hideNotice`). */
+  noticeBlocking = new Signal(false);
+  noticeLockHeld = false;
+  /** Cumulative amount staked this session (major units) — RTS 12 "money spent". */
+  totalStaked = new Signal(0);
+  /** Cumulative amount won this session (major units). */
+  totalWon = new Signal(0);
+  /** The Stake jurisdiction config currently applied (read-back for guards/queries). */
+  jurisdiction = {};
+  /** Replay mode (Stake `replay=true`): the HUD locks + a REPLAY badge shows. */
+  replay = new Signal(false);
+  /** Game name + version (shown in the menu footer; for support / certification). */
+  gameInfo = {};
+  /** Minimum round duration (ms) from jurisdiction — stored for the GAME to enforce. */
+  minimumRoundDuration = 0;
+  sessionNet = 0;
+  prevVolumes = null;
+  /** The frozen UISpec `createUI` built this from, if any — authored = run = tested. */
+  spec;
+  /** Typed convenience handles for the controls. */
+  spin;
+  balance;
+  bet;
+  settingsButton;
+  settingsPanel;
+  musicSlider;
+  sfxSlider;
+  rulesButton;
+  infoPanel;
+  infoClose;
+  turbo;
+  autoplay;
+  bonusButton;
+  betStepper;
+  betPlus;
+  betMinus;
+  fullscreenButton;
+  muteButton;
+  /** Compliance display readouts — hidden until a jurisdiction reveals them. */
+  rtp;
+  netPosition;
+  sessionTimer;
+  /** Menu-style notice/error modal (content set via `showNotice`). */
+  noticePanel;
+  controls = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.theme = opts.theme ?? defaultTheme;
+    this.layoutConfig = opts.layout ?? defaultLayoutConfig;
+    this.screen = new Signal(computeScreen(1920, 1080, this.layoutConfig));
+    this.translator = opts.translator ?? new DictionaryTranslator({}, "en");
+    this.locale = new Signal(this.translator.locale);
+    this.disposers.push(
+      this.translator.onChange((loc) => {
+        if (this.locale.get() === loc) return;
+        this.locale.set(loc);
+        this.bus.emit("localeChanged", loc);
+      })
+    );
+    this.spin = new SpinControl({ layout: { anchor: "bottom-center", offset: [0, -440] } }, this.bus);
+    this.balance = new ValueDisplay({
+      id: "balance",
+      label: "openui.balance",
+      // i18n key → localizes + swaps in social mode
+      layout: { anchor: "bottom-left", offset: [220, -96] },
+      currency: { code: "USD", decimals: 2 },
+      initial: 1e3
+    });
+    this.bet = new ValueDisplay({
+      id: "bet",
+      label: "openui.bet",
+      layout: { anchor: "bottom-right", offset: [-220, -96] },
+      currency: { code: "USD", decimals: 2 },
+      initial: 1
+    });
+    this.settingsButton = new ButtonControl(
+      { id: "settings", layout: { anchor: "bottom-center", offset: [400, -440] } },
+      this.bus
+    );
+    this.settingsPanel = new PanelControl(
+      { id: "settings-panel", variant: "popover", layout: { anchor: "bottom-right", offset: [-24, -470] } },
+      this.bus
+    );
+    this.musicSlider = new SliderControl({ id: "music", label: "Music", layout: { anchor: "center" }, initial: 0.7 }, this.bus);
+    this.sfxSlider = new SliderControl({ id: "sfx", label: "Sound", layout: { anchor: "center" }, initial: 0.5 }, this.bus);
+    this.rulesButton = new ButtonControl({ id: "rules", label: "Rules", layout: { anchor: "center" } }, this.bus);
+    this.infoPanel = new PanelControl({ id: "info-panel", variant: "modal", title: "Game Info", layout: { anchor: "center" } }, this.bus);
+    this.infoClose = new ButtonControl({ id: "info-close", layout: { anchor: "top-right" } }, this.bus);
+    this.bonusButton = new ButtonControl({ id: "bonus", layout: { anchor: "bottom-center", offset: [-400, -440] } }, this.bus);
+    this.autoplay = new AutoplayControl(
+      { id: "autoplay", layout: { anchor: "bottom-center", offset: [-225, -440] }, options: [5, 10, 25, 50, 100, Infinity] },
+      this.bus
+    );
+    this.turbo = new TurboControl({ id: "turbo", layout: { anchor: "bottom-center", offset: [225, -440] } }, this.bus);
+    this.betMinus = new ButtonControl({ id: "bet-minus", layout: { anchor: "bottom-center", offset: [-150, -270] } }, this.bus);
+    this.betPlus = new ButtonControl({ id: "bet-plus", layout: { anchor: "bottom-center", offset: [150, -270] } }, this.bus);
+    this.betStepper = new StepperControl({ id: "bet-stepper", layout: { anchor: "center" }, levels: [0.5, 1, 2, 5, 10, 20], index: 1 }, this.bus);
+    this.muteButton = new ButtonControl({ id: "mute", layout: { anchor: "top-right", offset: [-110, 28] } }, this.bus);
+    this.fullscreenButton = new ButtonControl({ id: "fullscreen", layout: { anchor: "top-right", offset: [-52, 28] } }, this.bus);
+    this.rtp = new ReadoutControl({ id: "rtp", kind: "percent", label: "RTP", layout: { anchor: "top-left", offset: [120, 96] } });
+    this.netPosition = new ReadoutControl({ id: "net-position", kind: "currency", label: "Net", currency: { code: "USD", decimals: 2 }, layout: { anchor: "top-center", offset: [0, 56] } });
+    this.sessionTimer = new ReadoutControl({ id: "session-timer", kind: "duration", label: "Session", layout: { anchor: "top-left", offset: [120, 56] } });
+    this.noticePanel = new PanelControl({ id: "notice-panel", variant: "modal", layout: { anchor: "center" } }, this.bus);
+    for (const c of [
+      this.spin,
+      this.balance,
+      this.bet,
+      this.settingsButton,
+      this.settingsPanel,
+      this.musicSlider,
+      this.sfxSlider,
+      this.rulesButton,
+      this.infoPanel,
+      this.infoClose,
+      this.bonusButton,
+      this.autoplay,
+      this.turbo,
+      this.betMinus,
+      this.betPlus,
+      this.betStepper,
+      this.muteButton,
+      this.fullscreenButton,
+      this.rtp,
+      this.netPosition,
+      this.sessionTimer,
+      this.noticePanel
+    ]) {
+      this.register(c);
+    }
+    this.hidden.add("rtp");
+    this.hidden.add("net-position");
+    this.hidden.add("session-timer");
+    this.bus.on("buttonActivated", ({ id }) => {
+      if (id === "settings") this.settingsPanel.toggle();
+      else if (id === "rules") {
+        this.settingsPanel.closePanel();
+        this.infoPanel.openPanel();
+      } else if (id === "info-close") {
+        this.infoPanel.closePanel();
+      } else if (id === "bet-plus") {
+        this.betStepper.inc();
+      } else if (id === "bet-minus") {
+        this.betStepper.dec();
+      } else if (id === "mute") {
+        this.toggleMute();
+      }
+    });
+    this.bus.on("valueChanged", ({ id, value }) => {
+      if (id === "bet-stepper") this.bet.set(value);
+    });
+    const syncStepperButtons = () => {
+      this.betStepper.canInc ? this.betPlus.enable() : this.betPlus.disable();
+      this.betStepper.canDec ? this.betMinus.enable() : this.betMinus.disable();
+    };
+    this.disposers.push(this.betStepper.index.subscribe(syncStepperButtons));
+    this.bet.set(this.betStepper.value);
+    syncStepperButtons();
+    this.disposers.push(
+      this.noticePanel.state.subscribe(() => {
+        if (this.noticePanel.isOpen) return;
+        if (this.noticeLockHeld) {
+          this.unlock();
+          this.noticeLockHeld = false;
+        }
+        if (this.noticeBlocking.get()) this.noticeBlocking.set(false);
+        this.bus.emit("noticeDismissed", void 0);
+      })
+    );
+    if (opts.startMuted) this.setMuted(true);
+  }
+  register(control) {
+    this.controls.set(control.id, control);
+    control.gate = () => !this.locked.get();
+    this.disposers.push(
+      control.onTransition((_t, to, from) => {
+        this.bus.emit("stateChanged", { id: control.id, from, to });
+      })
+    );
+  }
+  control(id) {
+    return this.controls.get(id);
+  }
+  all() {
+    return [...this.controls.values()];
+  }
+  /** Renderer calls this on resize; recomputes breakpoint + fit scale. */
+  setScreen(width, height) {
+    this.screen.set(computeScreen(width, height, this.layoutConfig));
+  }
+  /**
+   * Hide or show a control at runtime and tell the renderer (Charter P10). The
+   * control stays registered — still in `snapshot()` — but the view is not drawn.
+   * Used by the responsive layer to drop controls on small screens.
+   */
+  setHidden(id, hidden) {
+    if (!hidden && this.forceHidden.has(id)) return;
+    const was = this.hidden.has(id);
+    if (hidden === was) return;
+    if (hidden) this.hidden.add(id);
+    else this.hidden.delete(id);
+    this.bus.emit("visibilityChanged", { id, hidden });
+  }
+  /** Push the ref-counted input lock (e.g. for the duration of a spin round). */
+  lock() {
+    this.lockCount += 1;
+    if (this.lockCount === 1) this.locked.set(true);
+  }
+  /** Pop the lock; the HUD becomes interactable again only at zero. */
+  unlock() {
+    if (this.lockCount === 0) return;
+    this.lockCount -= 1;
+    if (this.lockCount === 0) this.locked.set(false);
+  }
+  /** Toggle master mute (music + sfx). */
+  toggleMute() {
+    this.setMuted(!this.muted.get());
+  }
+  /** Mute/unmute music+sfx, remembering the levels to restore on unmute. */
+  setMuted(m) {
+    if (m === this.muted.get()) return;
+    if (m) {
+      this.prevVolumes = { music: this.musicSlider.value.get(), sfx: this.sfxSlider.value.get() };
+      this.musicSlider.setNormalized(0);
+      this.sfxSlider.setNormalized(0);
+    } else if (this.prevVolumes) {
+      this.musicSlider.setNormalized(this.prevVolumes.music);
+      this.sfxSlider.setNormalized(this.prevVolumes.sfx);
+      this.prevVolumes = null;
+    }
+    this.muted.set(m);
+  }
+  /**
+   * Report one completed round (major units): updates the net-position readout and,
+   * while autoplay is running, advances its count + enforces its RG loss/single-win
+   * limits. One feed point powers both `displayNetPosition` and the autoplay stops.
+   */
+  reportRound(win, bet) {
+    if (!Number.isFinite(win) || !Number.isFinite(bet)) return;
+    this.sessionNet += win - bet;
+    this.netPosition.set(this.sessionNet);
+    this.totalStaked.set(this.totalStaked.get() + bet);
+    this.totalWon.set(this.totalWon.get() + win);
+    if (this.autoplay.isActive) {
+      this.autoplay.reportResult(win, bet);
+      if (this.autoplay.isActive && this.balance.get() < this.bet.get()) this.autoplay.stop();
+    }
+  }
+  /** Reset the running session net + aggregates + timer (e.g. on a fresh session). */
+  resetSession() {
+    this.sessionNet = 0;
+    this.netPosition.set(0);
+    this.totalStaked.set(0);
+    this.totalWon.set(0);
+    this.sessionTimer.reset();
+  }
+  /** Show the menu-style notice modal: declarative blocks + optional action buttons.
+   *  Every string (block text + button labels) runs through `ui.t`, so pass exact
+   *  literals OR your own i18n keys. Omit `actions` → a single dismiss button. */
+  showNotice(blocks, actions, opts = {}) {
+    const blocking = !!opts.blocking;
+    this.noticeBlocks.set(Array.isArray(blocks) ? blocks : []);
+    this.noticeActions.set(actions && actions.length ? actions : blocking ? [] : [DEFAULT_NOTICE_ACTION]);
+    this.noticeBlocking.set(blocking);
+    if (blocking && !this.noticeLockHeld) {
+      this.lock();
+      this.noticeLockHeld = true;
+    } else if (!blocking && this.noticeLockHeld) {
+      this.unlock();
+      this.noticeLockHeld = false;
+    }
+    this.noticePanel.openPanel();
+    this.bus.emit("noticeShown", { blocking });
+  }
+  /** Show a simple error/notice: a title + a tone-coloured message. `message` and
+   *  `opts.title` are literal-or-key (localized via `ui.t`); `opts.actions` adds
+   *  custom buttons (e.g. a "Reload"). `opts.blocking` → a fatal modal (locks the
+   *  HUD, no backdrop/✕ dismiss; removable only via `hideNotice`). */
+  showError(message, opts = {}) {
+    this.showNotice(errorBlocks(message, opts.title ?? "openui.error", opts.tone ?? "warning"), opts.actions, {
+      blocking: opts.blocking
+    });
+  }
+  /** Show a FATAL error: a blocking modal that locks the HUD and can be removed only
+   *  in code (`hideNotice`) — for unrecoverable RGS states. Pass `actions` (e.g. a
+   *  "Reload" that reloads the page) for the only way out. */
+  showFatal(message, opts = {}) {
+    this.showError(message, { ...opts, blocking: true });
+  }
+  /** Show the default (localizable, overridable) message for an RGS status code.
+   *  Override the exact text per call via `opts.title` / `opts.message`. Stops an
+   *  active autoplay by default (`opts.stopAutoplay = false` to keep it). Pass
+   *  `opts.blocking` for unrecoverable codes (session expiry, maintenance). */
+  showRgsError(code, opts = {}) {
+    const def = RGS_ERROR_KEYS[code] ?? RGS_ERROR_KEYS.ERR_GEN;
+    if (opts.stopAutoplay !== false && this.autoplay.isActive) this.autoplay.stop();
+    this.showError(opts.message ?? def.message, {
+      title: opts.title ?? def.title,
+      tone: opts.tone ?? "warning",
+      actions: opts.actions,
+      blocking: opts.blocking
+    });
+  }
+  /** Close the notice / error modal. */
+  hideNotice() {
+    this.noticePanel.closePanel();
+  }
+  /** Enter/leave replay mode (Stake `replay=true`) — locks the HUD so no real bet is
+   *  placed; the renderer shows a REPLAY badge while it's on. */
+  setReplay(on) {
+    if (on === this.replay.get()) return;
+    this.replay.set(on);
+    if (on) this.lock();
+    else this.unlock();
+  }
+  /** Apply a Stake Engine `jurisdiction` config to the live HUD (whole switchboard).
+   *  The merged config is stored for `isDisabled()` read-back. */
+  applyJurisdiction(jur) {
+    this.jurisdiction = Object.freeze({ ...this.jurisdiction, ...jur });
+    applyJurisdiction(this, jur);
+  }
+  /** Tear down every subscription and control this ui created (Charter P12). */
+  dispose() {
+    for (const d of this.disposers) d();
+    this.disposers.length = 0;
+    for (const c of this.controls.values()) c.dispose();
+    this.controls.clear();
+  }
+  /**
+   * Switch language. Drives the translator (if it can self-switch) and emits
+   * `localeChanged`; controls' views, subscribed to `locale`, re-render their text.
+   */
+  setLocale(next) {
+    this.translator.setLocale(next);
+  }
+  /** Translate a key (or pass plain text through) via the active translator. In
+   *  social mode, a `<key>.social` variant wins when one resolves — so gambling
+   *  wording (Bet/Buy feature) swaps to sweepstakes terms automatically. */
+  t(key, vars) {
+    if (this.social.get()) {
+      const sk = `${key}.social`;
+      const s = this.translator.t(sk, vars);
+      if (s !== sk) return s;
+    }
+    return this.translator.t(key, vars);
+  }
+  /**
+   * Turn social / sweepstakes mode on or off (one switch). Swaps gambling wording
+   * (Bet/Buy feature → social terms via `<key>.social` i18n) AND, when a `coin` is
+   * given (e.g. `'GC'`/`'SC'`/`'XGC'`), shows balance/bet/net in that coin. Wording
+   * re-renders live; the host can still override any `.social` key.
+   */
+  setSocial(on, coin) {
+    if (on !== this.social.get()) {
+      this.social.set(on);
+      this.locale.update(() => {
+      });
+    }
+    if (coin) {
+      const cur = resolveCurrency(coin);
+      this.balance.setCurrency(cur);
+      this.bet.setCurrency(cur);
+      this.netPosition.setCurrency(cur);
+    }
+  }
+  /** Read-back: did the applied jurisdiction disable this feature? (real guard, not
+   *  just a hide — `confirmBuy`/autoplay entry points consult this). */
+  isDisabled(feature) {
+    const j = this.jurisdiction;
+    return feature === "autoplay" && !!j.disabledAutoplay || feature === "buyFeature" && !!j.disabledBuyFeature || feature === "turbo" && !!j.disabledTurbo || feature === "superTurbo" && !!j.disabledSuperTurbo || feature === "fullscreen" && !!j.disabledFullscreen || feature === "slamstop" && !!j.disabledSlamstop || feature === "spacebar" && !!j.disabledSpacebar;
+  }
+  /**
+   * Start a reality-check reminder (RTS 13). Every `everyMinutes` (WALL-CLOCK, so a
+   * backgrounded tab can't cheat it) it emits a `realityCheck` event, stops autoplay,
+   * and — unless `showModal: false` — shows an acknowledge modal. You provide only
+   * the interval + (optional) title/message text; `{{minutes}}`/`{{spent}}`/`{{won}}`
+   * are interpolated. Returns a disposer (also torn down by `dispose()`).
+   */
+  startRealityCheck(opts) {
+    const everyMs = Math.max(1, opts.everyMinutes) * 6e4;
+    let last = Date.now();
+    let timer;
+    const tick = () => {
+      if (this.noticePanel.isOpen) {
+        timer = setTimeout(tick, 1e3);
+        return;
+      }
+      const elapsedMs = Date.now() - last;
+      last = Date.now();
+      this.fireRealityCheck(opts, elapsedMs);
+      timer = setTimeout(tick, everyMs);
+    };
+    timer = setTimeout(tick, everyMs);
+    const dispose = () => {
+      if (timer) clearTimeout(timer);
+      timer = void 0;
+    };
+    this.disposers.push(dispose);
+    return dispose;
+  }
+  /** Fire one reality check now: emit the event (+ session totals), stop autoplay,
+   *  and show the modal unless `showModal:false`. Exposed for manual triggers / tests. */
+  fireRealityCheck(opts, elapsedMs = 0) {
+    const minutes = Math.max(1, Math.round(opts.everyMinutes));
+    const totalStaked = this.totalStaked.get();
+    const totalWon = this.totalWon.get();
+    this.bus.emit("realityCheck", { minutes, elapsedMs, totalStaked, totalWon });
+    if (this.autoplay.isActive) this.autoplay.stop();
+    if (opts.showModal === false) return;
+    const vars = { minutes, spent: totalStaked, won: totalWon };
+    this.showNotice(
+      [
+        { kind: "heading", id: "rc-title", text: this.t(opts.title ?? "openui.realityCheck.title", vars) },
+        { kind: "callout", id: "rc-body", tone: "info", text: this.t(opts.message ?? "openui.realityCheck.message", vars) }
+      ],
+      opts.actions ?? [{ label: "openui.continue", variant: "primary" }]
+    );
+  }
+  on(type, fn) {
+    return this.bus.on(type, fn);
+  }
+  /** Serializable snapshot for the introspection / e2e API (Charter P10). */
+  snapshot() {
+    return this.all().map((c) => {
+      const { bounds, animating } = c.inspect();
+      return {
+        id: c.id,
+        role: c.role,
+        state: c.current,
+        interactable: c.interactable,
+        bounds,
+        animating
+      };
+    });
+  }
+};
+
+// src/spec/responsive.ts
+function cloneLayout(l) {
+  return { anchor: l.anchor, offset: l.offset ? [l.offset[0], l.offset[1]] : void 0, scale: l.scale };
+}
+function activeKeys(screen) {
+  return [screen.orientation, screen.breakpoint];
+}
+function installResponsive(ui, responsive) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(responsive)) {
+    const ov = responsive[key];
+    if (ov?.controls) for (const id of Object.keys(ov.controls)) ids.add(id);
+  }
+  if (!ids.size) return () => {
+  };
+  const base = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const c = ui.control(id);
+    if (!c) continue;
+    base.set(id, { layout: cloneLayout(c.layout), hidden: ui.hidden.has(id) });
+  }
+  const apply = (screen) => {
+    const keys = activeKeys(screen);
+    for (const [id, b] of base) {
+      const c = ui.control(id);
+      if (!c) continue;
+      let layout = b.layout;
+      let hidden = b.hidden;
+      for (const key of keys) {
+        const ov = responsive[key]?.controls?.[id];
+        if (!ov) continue;
+        if (ov.layout) layout = ov.layout;
+        if (ov.hidden != null) hidden = ov.hidden;
+      }
+      c.layout = cloneLayout(layout);
+      ui.setHidden(id, hidden);
+    }
+  };
+  const off = ui.screen.subscribe(apply);
+  apply(ui.screen.get());
+  return off;
+}
+
+// src/spec/createUI.ts
+function resolveTurboModes(modes) {
+  if (Array.isArray(modes)) return modes.length ? modes : ["off", "on"];
+  if (modes === 3) return ["off", "turbo", "super"];
+  return ["off", "on"];
+}
+function defineUI(spec) {
+  return spec;
+}
+var ANALYTICS_EVENTS = [
+  "stateChanged",
+  "buttonActivated",
+  "valueChanged",
+  "toggled",
+  "optionSelected",
+  "panelToggled",
+  "autoplayStarted",
+  "autoplayStopped"
+];
+function createUI(spec = {}, hooks = {}) {
+  const { issues } = validateSpec(spec);
+  for (const issue of issues) hooks.onDataIssue?.(issue);
+  const translator = spec.locale ? new DictionaryTranslator(spec.locale.messages, spec.locale.locale) : void 0;
+  const theme = resolveTheme(spec.theme, (i) => hooks.onDataIssue?.(i));
+  const ui = new OpenUI({ theme, layout: spec.layout, translator, startMuted: spec.audio?.startMuted });
+  if (spec.currency) {
+    const cur = typeof spec.currency === "string" ? resolveCurrency(spec.currency) : spec.currency;
+    ui.balance.setCurrency(cur);
+    ui.bet.setCurrency(cur);
+    ui.netPosition.setCurrency(cur);
+  }
+  if (spec.social) {
+    if (typeof spec.social === "object") ui.setSocial(true, spec.social.coin);
+    else ui.setSocial(true);
+  }
+  if (typeof spec.rtp === "number") ui.rtp.set(spec.rtp);
+  if (spec.game) ui.gameInfo = { name: spec.game.name, version: spec.game.version };
+  if (spec.betLadder?.levels?.length) {
+    ui.betStepper.setLevels(spec.betLadder.levels, spec.betLadder.index ?? 0);
+    ui.bet.set(ui.betStepper.value);
+  }
+  if (spec.autoplay?.options?.length) {
+    ui.autoplay.setOptions(spec.autoplay.options);
+  }
+  if (spec.autoplay?.mode) {
+    ui.autoplay.mode = spec.autoplay.mode;
+  }
+  if (spec.autoplay?.lossLimits) ui.autoplay.setLossLimitOptions(spec.autoplay.lossLimits);
+  if (spec.autoplay?.winLimits) ui.autoplay.setWinLimitOptions(spec.autoplay.winLimits);
+  if (spec.turbo) {
+    ui.turbo.setModes(resolveTurboModes(spec.turbo.modes));
+    if (spec.turbo.index != null) ui.turbo.setIndex(spec.turbo.index);
+  }
+  if (spec.spin?.press) {
+    ui.spin.holdToSpin = spec.spin.press === "hold-to-spin";
+  }
+  if (spec.controls) {
+    for (const [id, ov] of Object.entries(spec.controls)) {
+      const c = ui.control(id);
+      if (!c) continue;
+      if (ov.layout) c.layout = ov.layout;
+      if (ov.hidden) ui.hidden.add(id);
+      const disable = c.disable;
+      if (ov.disabled && typeof disable === "function") disable.call(c);
+      if (c instanceof ValueDisplay) {
+        if (ov.currency) c.setCurrency(ov.currency);
+        if (ov.initial != null) c.set(ov.initial);
+        if (ov.digits != null) c.setDigits(ov.digits);
+      }
+    }
+  }
+  if (spec.jurisdiction) ui.applyJurisdiction(spec.jurisdiction);
+  if (spec.responsive) {
+    installResponsive(ui, spec.responsive);
+  }
+  if (spec.lockDuringSpin !== false) {
+    let wasSpinning = false;
+    ui.spin.state.subscribe((s) => {
+      const now = s === "spinning";
+      if (now && !wasSpinning) ui.lock();
+      else if (!now && wasSpinning) ui.unlock();
+      wasSpinning = now;
+    });
+  }
+  if (spec.realityCheck && spec.realityCheck.everyMinutes > 0) {
+    ui.startRealityCheck(spec.realityCheck);
+  }
+  const localeSelectId = spec.localeSelectId ?? "lang";
+  ui.on("optionSelected", ({ id, value }) => {
+    if (id === localeSelectId) ui.setLocale(value);
+  });
+  if (hooks.onAnalyticsEvent) {
+    const forward = hooks.onAnalyticsEvent;
+    for (const type of ANALYTICS_EVENTS) {
+      ui.on(type, (payload) => forward(type, payload));
+    }
+  }
+  ui.spec = Object.freeze(spec);
+  return ui;
+}
+
+// src/spec/menu.ts
+var DEFAULT_MENU_TITLES = { settings: "Settings", paytable: "Paytable", rules: "Rules" };
+var LOCALE_LABELS = {
+  en: "English",
+  es: "Espa\xF1ol",
+  pt: "Portugu\xEAs",
+  de: "Deutsch",
+  fr: "Fran\xE7ais",
+  ru: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439",
+  tr: "T\xFCrk\xE7e",
+  zh: "\u4E2D\u6587",
+  ja: "\u65E5\u672C\u8A9E",
+  ar: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629",
+  pl: "Polski",
+  ko: "\uD55C\uAD6D\uC5B4",
+  hi: "\u0939\u093F\u0928\u094D\u0926\u0940",
+  id: "Bahasa Indonesia",
+  vi: "Ti\u1EBFng Vi\u1EC7t",
+  fi: "Suomi",
+  it: "Italiano",
+  nl: "Nederlands"
+};
+function composeMenu(menu, opts = {}) {
+  const titles = { ...DEFAULT_MENU_TITLES, ...menu?.titles };
+  const out = [];
+  if (menu?.banner?.src) {
+    out.push({ kind: "image", id: "menu-banner", src: menu.banner.src, width: menu.banner.width, height: menu.banner.height });
+  }
+  out.push({ kind: "heading", id: "menu-sec-settings", text: titles.settings });
+  out.push({ kind: "slider", id: "music", label: "Music" });
+  out.push({ kind: "slider", id: "sfx", label: "Sound" });
+  const locales = opts.locales ?? [];
+  if (locales.length >= 2) {
+    out.push({
+      kind: "select",
+      id: opts.localeSelectId ?? "lang",
+      label: "Language",
+      options: locales.map((code) => ({ value: code, label: LOCALE_LABELS[code] ?? code.toUpperCase() }))
+    });
+  }
+  if (menu?.settings?.length) out.push(...menu.settings);
+  if (menu?.paytable?.length) {
+    out.push({ kind: "heading", id: "menu-sec-paytable", text: titles.paytable });
+    out.push(...menu.paytable);
+  }
+  const rules = menu?.rules?.length ? menu.rules : opts.rulesFallback;
+  if (rules?.length) {
+    out.push({ kind: "heading", id: "menu-sec-rules", text: titles.rules });
+    out.push(...rules);
+  }
+  return out;
+}
+
+// src/spec/defaultHudSpec.ts
+var defaultHudSpec = Object.freeze({
+  meta: { id: "open-ui-reference-hud", version: 1 },
+  currency: { code: "USD", decimals: 2 },
+  betLadder: { levels: [0.5, 1, 2, 5, 10, 20], index: 1 },
+  autoplay: { options: [5, 10, 25, 50, 100, Infinity] },
+  lockDuringSpin: true
+});
+
+// src/EventLog.ts
+var ALL_EVENTS = [
+  "spinRequested",
+  "skipRequested",
+  "stateChanged",
+  "buttonActivated",
+  "valueChanged",
+  "panelToggled",
+  "toggled",
+  "optionSelected",
+  "autoplayStarted",
+  "autoplayStopped",
+  "cardActivated",
+  "localeChanged"
+];
+var EventLog = class {
+  buf = [];
+  cap;
+  clock;
+  disposers = [];
+  constructor(bus, opts = {}) {
+    this.cap = opts.capacity ?? 200;
+    this.clock = opts.now ?? defaultNow;
+    for (const type of ALL_EVENTS) {
+      this.disposers.push(bus.on(type, (payload) => this.record(type, payload)));
+    }
+  }
+  record(type, payload) {
+    this.buf.push({ t: this.clock(), type, payload });
+    if (this.buf.length > this.cap) this.buf.shift();
+  }
+  /** The most recent payload of `type`, or undefined. */
+  last(type) {
+    for (let i = this.buf.length - 1; i >= 0; i--) {
+      if (this.buf[i].type === type) return this.buf[i].payload;
+    }
+    return void 0;
+  }
+  /** How many of `type` are in the buffer. */
+  count(type) {
+    let n = 0;
+    for (const e of this.buf) if (e.type === type) n += 1;
+    return n;
+  }
+  /** Every event at or after timestamp `t`, in order. */
+  since(t) {
+    return this.buf.filter((e) => e.t >= t);
+  }
+  clear() {
+    this.buf.length = 0;
+  }
+  dispose() {
+    for (const d of this.disposers) d();
+    this.disposers.length = 0;
+  }
+};
+function defaultNow() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") return performance.now();
+  return Date.now();
+}
+
+// src/bet.ts
+var API_AMOUNT_DIVISOR = 1e6;
+function buildBetLadder(cfg, divisor = API_AMOUNT_DIVISOR) {
+  let minor;
+  if (cfg.betLevels?.length) {
+    minor = cfg.betLevels.slice();
+  } else {
+    const min = cfg.minBet ?? 0;
+    const max = Math.max(min, cfg.maxBet ?? min);
+    const step = cfg.stepBet && cfg.stepBet > 0 ? cfg.stepBet : max - min || 1;
+    minor = [];
+    for (let v = min; v <= max && minor.length < 500; v += step) minor.push(v);
+    if (!minor.length) minor = [min];
+  }
+  const levels = minor.map((v) => v / divisor);
+  const want = (cfg.defaultBetLevel ?? minor[0]) / divisor;
+  const found = levels.findIndex((v) => v >= want);
+  return { levels, index: found < 0 ? 0 : found };
+}
+function clampBet(amount, cfg, divisor = API_AMOUNT_DIVISOR) {
+  const min = (cfg.minBet ?? 0) / divisor;
+  const max = (cfg.maxBet ?? Infinity) / divisor;
+  const step = (cfg.stepBet ?? 0) / divisor;
+  let v = Math.min(max, Math.max(min, Number.isFinite(amount) ? amount : min));
+  if (step > 0) v = min + Math.round((v - min) / step) * step;
+  return Math.min(max, Math.max(min, v));
+}
+
+// src/win.ts
+var DEFAULT_WIN_TIERS = Object.freeze([
+  { name: "big", minMultiplier: 10 },
+  { name: "mega", minMultiplier: 50 },
+  { name: "epic", minMultiplier: 100 }
+]);
+function winTier(win, stake, tiers = DEFAULT_WIN_TIERS) {
+  if (!Number.isFinite(win) || !Number.isFinite(stake) || stake <= 0 || win <= stake) return "none";
+  const mult = win / stake;
+  let name = "win";
+  for (const t of tiers) if (mult >= t.minMultiplier) name = t.name;
+  return name;
+}
+
+export { API_AMOUNT_DIVISOR, AutoplayControl, BLOCK_KINDS, ButtonControl, CURRENCY_TABLE, CardControl, Control, ControlRegistry, DEFAULT_MENU_TITLES, DEFAULT_NOTICE_ACTION, DEFAULT_WIN_TIERS, DictionaryTranslator, EventBus, EventLog, Fade, LOCALE_LABELS, OpenUI, PanelControl, Parallel, Pulse, RGS_ERROR_KEYS, ReadoutControl, SelectControl, Sequence, Signal, SliderControl, SpinControl, Squish, StepperControl, ToggleControl, TurboControl, Turn, ValueDisplay, applyJurisdiction, breakpointFor, buildBetLadder, buildBlocks, buildPanel, buttonBlocks, clampBet, clampDecimals, clampDigits, clampMinDigits, composeMenu, computeScreen, createUI, defaultHudSpec, defaultLayoutConfig, defaultTheme, defineUI, dictionary, displayDigits, effect, errorBlocks, extendTheme, formatAmount, installResponsive, integerDigits, isSafeColor, isSocialCurrency, openuiDefaults, resolveCurrency, resolvePlacement, resolveTheme, resolveTurboModes, safeAmount, sanitizeThemeOverrides, themePresets, validateSpec, valueFitMaxWidth, winTier };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map