@crowdedkingdoms/crowdy-dsh 0.4.7-dev.1 → 0.4.8-dev.1

package/dist/dsh-web/BUILD.json

@@ -1,10 +1,10 @@
 {
   "package": "@crowdedkingdoms/crowdy-dsh",
-  "version": "0.4.7",
-  "builtAt": "2026-10-15T20:11:28.339Z",
+  "version": "0.4.8",
+  "builtAt": "2026-10-15T22:43:35.458Z",
   "source": {
     "repository": "CrowdedKingdoms/crowdy-dsh",
-    "commit": "5809199d9f08d3adcef9fa0cb25ecb2694c41caf",
+    "commit": "6be157fc87333ca64a2688d5e2ab77c9e57101dc",
     "dirty": false
   },
   "upstream": {
@@ -15,7 +15,7 @@
   },
   "crowdyjs": {
     "name": "@crowdedkingdoms/crowdyjs",
-    "version": "18.11.0-dev.1",
+    "version": "18.12.0-dev.1",
     "source": "node_modules"
   },
   "files": {
@@ -112,7 +112,7 @@
     "manifest.webmanifest": "sha256:9b54d57eea00f2fdd1affe6e7999a4209a515755f12ac1a3299da2d55e178d4c",
     "preview/bootstrap-CYECZNXt.js": "sha256:9f303a0485c0badfdd19fad0c357ef050c5b9a343744ab5bf0c70015e7d95092",
     "preview/crowdy-boot-Cklh1qNl.js": "sha256:b21e8eb126e1cd8a52159d2d577e610df6c8af36a436f9ed5028cfabd11a85ff",
-    "preview/vfs-image.tar.gz": "sha256:a399e9c5b46f89f6aad3eab2a9b97bc18acdbd6450bcb0abd754efafaeae00b5",
+    "preview/vfs-image.tar.gz": "sha256:95c3425e186deba4ce4355980db01d6451cca0404591c372180bef6c33ea2e5b",
     "preview/worker-C8-_ANaz.js": "sha256:81099e5732dfe0c32bacd5897316b7956c5a0a22da01b4a0c6e21d0a3b9d9aa1"
   }
 }

package/lib/vendor/crowdyjs-sdk.js

@@ -10595,6 +10595,316 @@ var CollectionMirror = class extends TopicMirror {
     return this.get()?.get(id);
   }
 };
+var PrivateState = class {
+  constructor(runtime, source) {
+    this.runtime = runtime;
+    this.source = source;
+    this.reading = null;
+    this.again = false;
+    this.stopSub = null;
+    this.offReconnect = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.watching = null;
+    this.whats = new Set(typeof source.what === "string" ? [source.what] : source.what);
+  }
+  /** Subscribes and reads the first value. Idempotent. */
+  start() {
+    if (!this.watching) {
+      this.watching = (async () => {
+        this.offReconnect = this.runtime.onReconnect(() => void this.refresh().catch(() => void 0));
+        this.stopSub = await this.runtime.subscribe(this.source.nodeType, this.source.key, this.source.topic, (p) => this.onPush(p));
+        return this.refresh();
+      })().catch((e) => {
+        this.watching = null;
+        throw e;
+      });
+    }
+    return this.watching;
+  }
+  async stop() {
+    this.offReconnect?.();
+    this.offReconnect = null;
+    const stop = this.stopSub;
+    this.stopSub = null;
+    this.watching = null;
+    await stop?.();
+  }
+  /** Reads the value again (one read at a time; a request during one runs after it). */
+  refresh() {
+    if (this.reading) {
+      this.again = true;
+      return this.reading;
+    }
+    this.reading = (async () => {
+      try {
+        let v;
+        do {
+          this.again = false;
+          v = await this.source.read();
+        } while (this.again);
+        this.value = v;
+        for (const l of [...this.listeners])
+          l(v);
+        return v;
+      } finally {
+        this.reading = null;
+      }
+    })();
+    return this.reading;
+  }
+  get() {
+    return this.value;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  onPush(push) {
+    const msg = splitKitMessage(push.value);
+    if (!msg || msg.header.kind !== "changed" || !this.whats.has(msg.body.what))
+      return;
+    const who = Array.isArray(msg.body.who) ? msg.body.who.map(String) : [];
+    void this.runtime.playerId().then((me) => {
+      if (me === null || who.includes(me))
+        void this.refresh().catch(() => void 0);
+    });
+  }
+};
+
+var ArenasKit = class {
+  constructor(runtime, nodeType = "arena") {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.arenas = /* @__PURE__ */ new Map();
+  }
+  arena(key) {
+    let a = this.arenas.get(key);
+    if (!a) {
+      a = new ArenaMatch(this.runtime, this.nodeType, key);
+      this.arenas.set(key, a);
+    }
+    return a;
+  }
+};
+var ArenaMatch = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.view = new HubState(runtime, nodeType, key, "arena");
+  }
+  watch() {
+    return this.view.start();
+  }
+  unwatch() {
+    return this.view.stop();
+  }
+  /** Joins as `heroClass` (the starter's are `warrior` and `mage`). @throws {KitError} `bad_request`, `full`, `started`. */
+  join(heroClass) {
+    return this.runtime.call(this.nodeType, this.key, "join", { class: heroClass }, { action: true });
+  }
+  leave() {
+    return this.runtime.call(this.nodeType, this.key, "leave", null, { action: true });
+  }
+  /** The first to join, or a developer. @throws {KitError} `forbidden`, `not_ready` (one fighter), `started`. */
+  start() {
+    return this.runtime.call(this.nodeType, this.key, "start", null, { action: true });
+  }
+  /**
+   * Reports where the player is; resolves with the position the hub kept (a move too fast is cut
+   * short, a jump refused). Not sent with an action id: the next report replaces it.
+   * @throws {KitError} `forbidden` (removed for movement the warden refused), `conflict` (down).
+   */
+  move(x, z) {
+    return this.runtime.call(this.nodeType, this.key, "move", { x, z });
+  }
+  /**
+   * Casts `ability` aimed at `(x, z)`; resolves with whether a hit-scan strike hit someone at once
+   * (a projectile or an area lands later, as an `impact` event).
+   * @throws {KitError} `cooldown`, `insufficient` (resource), `out_of_reach`, `not_found` (not the class's).
+   */
+  cast(ability, x, z) {
+    return this.runtime.call(this.nodeType, this.key, "cast", { ability, x, z }, { action: true });
+  }
+};
+
+var EncountersKit = class {
+  constructor(runtime, nodeType = "director") {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.encounters = /* @__PURE__ */ new Map();
+  }
+  encounter(key) {
+    let e = this.encounters.get(key);
+    if (!e) {
+      e = new Encounter(this.runtime, this.nodeType, key);
+      this.encounters.set(key, e);
+    }
+    return e;
+  }
+};
+var Encounter = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.view = new HubState(runtime, nodeType, key, "encounter");
+  }
+  watch() {
+    return this.view.start();
+  }
+  unwatch() {
+    return this.view.stop();
+  }
+  /** @throws {KitError} `full`. */
+  join() {
+    return this.runtime.call(this.nodeType, this.key, "join", null, { action: true });
+  }
+  /** The first to join, or a developer. @throws {KitError} `forbidden`, `started`, `bad_request` (no way to the base). */
+  start() {
+    return this.runtime.call(this.nodeType, this.key, "start", null, { action: true });
+  }
+  /**
+   * Builds a tower at `(x, z)`; resolves with the gold left.
+   * @throws {KitError} `blocks_lane`, `insufficient` (gold), `conflict` (taken), `bad_request`, `not_member`.
+   */
+  build(x, z) {
+    return this.runtime.call(this.nodeType, this.key, "build", { x, z }, { action: true });
+  }
+  /** Strikes enemy `enemy`; resolves with its hp left. @throws {KitError} `cooldown`, `not_found`, `not_member`. */
+  hit(enemy) {
+    return this.runtime.call(this.nodeType, this.key, "hit", { enemy }, { action: true });
+  }
+};
+
+var InstancesKit = class {
+  constructor(runtime, nodeType = "instance") {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.runs = /* @__PURE__ */ new Map();
+  }
+  /** The run with key `key` (a key the game makes up, one per run). */
+  run(key) {
+    let r = this.runs.get(key);
+    if (!r) {
+      r = new InstanceRun(this.runtime, this.nodeType, key);
+      this.runs.set(key, r);
+    }
+    return r;
+  }
+};
+var InstanceRun = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.view = new HubState(runtime, nodeType, key, "run");
+  }
+  watch() {
+    return this.view.start();
+  }
+  unwatch() {
+    return this.view.stop();
+  }
+  /**
+   * Opens the run as its owner (a developer kit opens one for `party`); resolves with its seed.
+   * @throws {KitError} `started`, `bad_request` (party size), `conflict` (its grid could not be reserved).
+   */
+  open(options = {}) {
+    const args = {};
+    if (options.seed !== void 0)
+      args.seed = options.seed;
+    if (options.party?.length)
+      args.party = options.party.map(Number);
+    return this.runtime.call(this.nodeType, this.key, "open", args, { action: true });
+  }
+  /** The owner invites a player. @throws {KitError} `forbidden`, `full`. */
+  invite(player) {
+    return this.runtime.call(this.nodeType, this.key, "invite", { player: Number(player) }, { action: true });
+  }
+  /** An invited player joins. @throws {KitError} `forbidden`. */
+  join() {
+    return this.runtime.call(this.nodeType, this.key, "join", null, { action: true });
+  }
+  /**
+   * Resolves the room the party is at; resolves with what happened, as the log has it.
+   * @throws {KitError} `not_member`, `forbidden` (the caller is down), `conflict` (descend first), `finished`.
+   */
+  enter() {
+    return this.runtime.call(this.nodeType, this.key, "enter", null, { action: true });
+  }
+  /** The owner leads the party to the next floor; resolves with it. @throws {KitError} `not_ready` (rooms left), `forbidden`. */
+  descend() {
+    return this.runtime.call(this.nodeType, this.key, "descend", null, { action: true });
+  }
+  /** The owner (or a developer) ends the run. */
+  abandon() {
+    return this.runtime.call(this.nodeType, this.key, "abandon", null, { action: true });
+  }
+};
+
+var LeaderboardsKit = class {
+  constructor(runtime, nodeType = "leaderboard") {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.boards = /* @__PURE__ */ new Map();
+  }
+  /** The board named `name` (`weekly-score`, `fastest-lap`, ...). */
+  board(name) {
+    let b = this.boards.get(name);
+    if (!b) {
+      b = new LeaderboardHandle(this.runtime, this.nodeType, name);
+      this.boards.set(name, b);
+    }
+    return b;
+  }
+};
+var LeaderboardHandle = class {
+  constructor(runtime, nodeType, name) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.name = name;
+    this.view = new HubState(runtime, nodeType, name, "board");
+  }
+  watch() {
+    return this.view.start();
+  }
+  unwatch() {
+    return this.view.stop();
+  }
+  /** A page of the board, best first. */
+  top(options = {}) {
+    return this.runtime.call(this.nodeType, this.name, "top", options);
+  }
+  /** The places around a player (the caller's own, without `player`). */
+  around(options = {}) {
+    const args = {};
+    if (options.player !== void 0)
+      args.player = Number(options.player);
+    if (options.radius !== void 0)
+      args.radius = options.radius;
+    return this.runtime.call(this.nodeType, this.name, "around", args);
+  }
+  /** The caller's own place, or null without a score this season. */
+  me() {
+    return this.runtime.call(this.nodeType, this.name, "me");
+  }
+  season() {
+    return this.runtime.call(this.nodeType, this.name, "season");
+  }
+  /** Submits a score for `player`. Developers only (a developer kit); players are refused. */
+  submit(player, score) {
+    return this.runtime.call(this.nodeType, this.name, "submit", { player: Number(player), score }, { action: true });
+  }
+  /** Sets the board's config. Developers only. */
+  configure(config) {
+    return this.runtime.call(this.nodeType, this.name, "configure", config, { action: true });
+  }
+  /** Ends the season now; resolves with the new season. Developers only. */
+  roll() {
+    return this.runtime.call(this.nodeType, this.name, "roll", null, { action: true });
+  }
+};
 
 var WritableKitStore = class {
   constructor(initial) {
@@ -10721,6 +11031,55 @@ var MatchQueue = class {
   }
 };
 
+var MinigamesKit = class {
+  constructor(runtime, nodeType = "minigame") {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.duels = /* @__PURE__ */ new Map();
+  }
+  duel(key) {
+    let d = this.duels.get(key);
+    if (!d) {
+      d = new Duel(this.runtime, this.nodeType, key);
+      this.duels.set(key, d);
+    }
+    return d;
+  }
+};
+var Duel = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.view = new HubState(runtime, nodeType, key, "duel");
+  }
+  watch() {
+    return this.view.start();
+  }
+  unwatch() {
+    return this.view.stop();
+  }
+  /** Takes a seat; resolves with whether this seat started the first round. @throws {KitError} `full`. */
+  join() {
+    return this.runtime.call(this.nodeType, this.key, "join", null, { action: true });
+  }
+  /** Before the duel starts. @throws {KitError} `started`. */
+  leave() {
+    return this.runtime.call(this.nodeType, this.key, "leave", null, { action: true });
+  }
+  /**
+   * The caller's hidden throw this round; resolves with whether it completed the round.
+   * @throws {KitError} `conflict` (already in, or no round open), `bad_request` (not a hand), `not_member`.
+   */
+  throw(hand) {
+    return this.runtime.call(this.nodeType, this.key, "throw", { hand }, { action: true });
+  }
+  /** Once it is over: play again. @throws {KitError} `conflict`, `not_member`. */
+  rematch() {
+    return this.runtime.call(this.nodeType, this.key, "rematch", null, { action: true });
+  }
+};
+
 var NpcsKit = class {
   constructor(runtime, options = {}) {
     this.runtime = runtime;
@@ -10921,6 +11280,105 @@ var EmotesKit = class {
   }
 };
 
+var RacingKit = class {
+  constructor(runtime, raceType = "race", ballType = "ball") {
+    this.runtime = runtime;
+    this.raceType = raceType;
+    this.ballType = ballType;
+    this.races = /* @__PURE__ */ new Map();
+    this.matches = /* @__PURE__ */ new Map();
+  }
+  /** The race with key `key`. */
+  race(key) {
+    let r = this.races.get(key);
+    if (!r) {
+      r = new Race(this.runtime, this.raceType, key);
+      this.races.set(key, r);
+    }
+    return r;
+  }
+  /** The ball game with key `key`. */
+  ball(key) {
+    let m = this.matches.get(key);
+    if (!m) {
+      m = new BallMatch(this.runtime, this.ballType, key);
+      this.matches.set(key, m);
+    }
+    return m;
+  }
+};
+var Race = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.view = new HubState(runtime, nodeType, key, "race");
+  }
+  watch() {
+    return this.view.start();
+  }
+  unwatch() {
+    return this.view.stop();
+  }
+  /** @throws {KitError} `started`, `full`. */
+  join() {
+    return this.runtime.call(this.nodeType, this.key, "join", null, { action: true });
+  }
+  leave() {
+    return this.runtime.call(this.nodeType, this.key, "leave", null, { action: true });
+  }
+  /** Starts the countdown (the first to join, or a developer). @throws {KitError} `forbidden`, `started`. */
+  start() {
+    return this.runtime.call(this.nodeType, this.key, "start", null, { action: true });
+  }
+  /** Reports where the racer is; resolves with the position the hub kept. */
+  pos(x, z) {
+    return this.runtime.call(this.nodeType, this.key, "pos", { x, z });
+  }
+  /** The winner's run, once there is one. */
+  ghost() {
+    return this.runtime.call(this.nodeType, this.key, "ghost");
+  }
+};
+var BallMatch = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.view = new HubState(runtime, nodeType, key, "ball");
+  }
+  watch() {
+    return this.view.start();
+  }
+  unwatch() {
+    return this.view.stop();
+  }
+  /** @throws {KitError} `bad_request` (red or blue), `full`, `started`. */
+  join(team) {
+    return this.runtime.call(this.nodeType, this.key, "join", { team }, { action: true });
+  }
+  /** @throws {KitError} `forbidden`, `not_ready` (each team needs a player), `started`. */
+  start() {
+    return this.runtime.call(this.nodeType, this.key, "start", null, { action: true });
+  }
+  /** Reports where the player is; resolves with the position the hub kept. */
+  pos(x, z) {
+    return this.runtime.call(this.nodeType, this.key, "pos", { x, z });
+  }
+  /** Claims the ball. @throws {KitError} `out_of_reach`, `cooldown` (too soon, or its holder's protection), `conflict` (a teammate has it). */
+  claim() {
+    return this.runtime.call(this.nodeType, this.key, "claim", null, { action: true });
+  }
+  /** Passes to a teammate. @throws {KitError} `conflict` (not the holder), `bad_request` (not a teammate). */
+  pass(to) {
+    return this.runtime.call(this.nodeType, this.key, "pass", { to: Number(to) }, { action: true });
+  }
+  /** Shoots toward `(x, z)`. @throws {KitError} `conflict` (not the holder). */
+  shoot(x, z) {
+    return this.runtime.call(this.nodeType, this.key, "shoot", { x, z }, { action: true });
+  }
+};
+
 var SessionsKit = class {
   constructor(runtime, options = {}) {
     this.runtime = runtime;
@@ -10998,6 +11456,206 @@ var GameSessionHandle = class {
   }
 };
 
+var TablesKit = class {
+  constructor(runtime, nodeType = "deck") {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.tables = /* @__PURE__ */ new Map();
+  }
+  table(key) {
+    let t = this.tables.get(key);
+    if (!t) {
+      t = new CardTable(this.runtime, this.nodeType, key);
+      this.tables.set(key, t);
+    }
+    return t;
+  }
+};
+var CardTable = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.table = new HubState(runtime, nodeType, key, "table");
+    this.hand = new PrivateState(runtime, {
+      nodeType,
+      key,
+      topic: "table",
+      what: "hand",
+      read: () => runtime.call(nodeType, key, "hand")
+    });
+  }
+  /** Mirrors the table and the caller's hand. */
+  async watch() {
+    const [view] = await Promise.all([this.table.start(), this.hand.start()]);
+    return view;
+  }
+  async unwatch() {
+    await Promise.all([this.table.stop(), this.hand.stop()]);
+  }
+  /** @throws {KitError} `started`, `full`. */
+  join() {
+    return this.runtime.call(this.nodeType, this.key, "join", null, { action: true });
+  }
+  leave() {
+    return this.runtime.call(this.nodeType, this.key, "leave", null, { action: true });
+  }
+  /** Deals (the host, from two players). @throws {KitError} `forbidden`, `too_few_players`, `started`. */
+  start() {
+    return this.runtime.call(this.nodeType, this.key, "start", null, { action: true });
+  }
+  /**
+   * Plays a card from the caller's hand; an eight names `suit` (`S`, `H`, `D` or `C`).
+   * @throws {KitError} `not_your_turn`, `not_found` (not in the hand), `not_playable` (the rule),
+   *   `bad_request` (an eight without a suit).
+   */
+  play(card, suit) {
+    const args = suit === void 0 ? { card } : { card, suit };
+    return this.runtime.call(this.nodeType, this.key, "play", args, { action: true });
+  }
+  /** Draws a card (once a turn). @throws {KitError} `not_your_turn`, `conflict`, `empty`. */
+  draw() {
+    return this.runtime.call(this.nodeType, this.key, "draw", null, { action: true });
+  }
+  /** Passes, after drawing. @throws {KitError} `conflict` (draw first). */
+  pass() {
+    return this.runtime.call(this.nodeType, this.key, "pass", null, { action: true });
+  }
+};
+
+var TacticsKit = class {
+  constructor(runtime, nodeType = "tactics") {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.battles = /* @__PURE__ */ new Map();
+  }
+  battle(key) {
+    let b = this.battles.get(key);
+    if (!b) {
+      b = new TacticsBattle(this.runtime, this.nodeType, key);
+      this.battles.set(key, b);
+    }
+    return b;
+  }
+};
+var TacticsBattle = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.battle = new HubState(runtime, nodeType, key, "battle");
+  }
+  watch() {
+    return this.battle.start();
+  }
+  unwatch() {
+    return this.battle.stop();
+  }
+  /** The player's units, as the mirror last saw them. */
+  async myUnits() {
+    const me = await this.runtime.playerId();
+    return (this.battle.get()?.units ?? []).filter((u) => me !== null && String(u.owner) === me);
+  }
+  /** @throws {KitError} `started`, `full`. */
+  join() {
+    return this.runtime.call(this.nodeType, this.key, "join", null, { action: true });
+  }
+  /** @throws {KitError} `forbidden` (the host starts it), `started`. */
+  start() {
+    return this.runtime.call(this.nodeType, this.key, "start", null, { action: true });
+  }
+  /**
+   * Moves the player's unit to `(x, z)`.
+   * @throws {KitError} `not_your_turn`, `conflict` (it moved), `out_of_reach`, `not_member`.
+   */
+  move(x, z) {
+    return this.runtime.call(this.nodeType, this.key, "move", { x, z }, { action: true });
+  }
+  /**
+   * Attacks unit `target` with the player's unit.
+   * @throws {KitError} `not_your_turn`, `conflict` (it attacked), `out_of_reach`, `forbidden` (its own side), `not_found`.
+   */
+  attack(target) {
+    return this.runtime.call(this.nodeType, this.key, "attack", { target }, { action: true });
+  }
+  /** Ends the player's turn this phase. */
+  endTurn() {
+    return this.runtime.call(this.nodeType, this.key, "end_turn", null, { action: true });
+  }
+};
+
+var TerritoryKit = class {
+  constructor(runtime, territoryType = "territory", zoneType = "zone") {
+    this.runtime = runtime;
+    this.territoryType = territoryType;
+    this.zoneType = zoneType;
+    this.maps = /* @__PURE__ */ new Map();
+    this.zones = /* @__PURE__ */ new Map();
+  }
+  /** The war on map `key`. */
+  map(key) {
+    let m = this.maps.get(key);
+    if (!m) {
+      m = new TerritoryMap(this.runtime, this.territoryType, key);
+      this.maps.set(key, m);
+    }
+    return m;
+  }
+  /** The circle of match `key`. */
+  zone(key) {
+    let z = this.zones.get(key);
+    if (!z) {
+      z = new ZoneMatch(this.runtime, this.zoneType, key);
+      this.zones.set(key, z);
+    }
+    return z;
+  }
+};
+var TerritoryMap = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.view = new HubState(runtime, nodeType, key, "territory");
+  }
+  watch() {
+    return this.view.start();
+  }
+  unwatch() {
+    return this.view.stop();
+  }
+  /** Joins a faction, once: a player keeps theirs. @throws {KitError} `conflict`, `bad_request`, `full`. */
+  join(faction) {
+    return this.runtime.call(this.nodeType, this.key, "join", { faction }, { action: true });
+  }
+  /** A new war. Developers only. */
+  reset() {
+    return this.runtime.call(this.nodeType, this.key, "reset", null, { action: true });
+  }
+};
+var ZoneMatch = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.view = new HubState(runtime, nodeType, key, "zone");
+  }
+  watch() {
+    return this.view.start();
+  }
+  unwatch() {
+    return this.view.stop();
+  }
+  /** @throws {KitError} `started`, `full`. */
+  join() {
+    return this.runtime.call(this.nodeType, this.key, "join", null, { action: true });
+  }
+  /** The first to join, or a developer. @throws {KitError} `forbidden`, `not_ready`, `started`. */
+  start() {
+    return this.runtime.call(this.nodeType, this.key, "start", null, { action: true });
+  }
+};
+
 var WorldKit = class {
   constructor(runtime, options = {}) {
     this.runtime = runtime;
@@ -11578,6 +12236,15 @@ var GameKitClient = class {
     this.spectateKit = null;
     this.emotesKit = null;
     this.shardKit = null;
+    this.leaderboardsKit = null;
+    this.tablesKit = null;
+    this.tacticsKit = null;
+    this.encountersKit = null;
+    this.minigamesKit = null;
+    this.instancesKit = null;
+    this.arenasKit = null;
+    this.racingKit = null;
+    this.territoryKit = null;
     this.social = new SocialKit(appId, domains.teams, domains.channels, domains.udp, gameApps, options.social);
     this.runtime = new KitRuntime(String(appId), domains.exec, options, domains.whoAmI);
   }
@@ -11601,6 +12268,42 @@ var GameKitClient = class {
     const opts = { nodeType: this.options.nodes?.npcs, areaSize: this.options.areaSize };
     return this.npcsKit ?? (this.npcsKit = new NpcsKit(this.runtime, opts));
   }
+  /** Leaderboards the hubs rank (a client never submits its own score). */
+  get leaderboards() {
+    return this.leaderboardsKit ?? (this.leaderboardsKit = new LeaderboardsKit(this.runtime, this.options.nodes?.leaderboard));
+  }
+  /** Card tables with hidden hands the hub holds. */
+  get tables() {
+    return this.tablesKit ?? (this.tablesKit = new TablesKit(this.runtime, this.options.nodes?.deck));
+  }
+  /** Grid battles in turns, against the hub's units. */
+  get tactics() {
+    return this.tacticsKit ?? (this.tacticsKit = new TacticsKit(this.runtime, this.options.nodes?.tactics));
+  }
+  /** Encounters: waves down a lane, towers, a boss with phases. */
+  get encounters() {
+    return this.encountersKit ?? (this.encountersKit = new EncountersKit(this.runtime, this.options.nodes?.director));
+  }
+  /** Duels of hidden throws, revealed together. */
+  get minigames() {
+    return this.minigamesKit ?? (this.minigamesKit = new MinigamesKit(this.runtime, this.options.nodes?.minigame));
+  }
+  /** Private runs for one party: seeded floors, permadeath, expiry. */
+  get instances() {
+    return this.instancesKit ?? (this.instancesKit = new InstancesKit(this.runtime, this.options.nodes?.instance));
+  }
+  /** Real-time arenas: classes, abilities, the hub's referee. */
+  get arenas() {
+    return this.arenasKit ?? (this.arenasKit = new ArenasKit(this.runtime, this.options.nodes?.arena));
+  }
+  /** Races and ball games, on positions the hub's warden keeps. */
+  get racing() {
+    return this.racingKit ?? (this.racingKit = new RacingKit(this.runtime, this.options.nodes?.race, this.options.nodes?.ball));
+  }
+  /** Control points factions capture, and shrinking circles. */
+  get territory() {
+    return this.territoryKit ?? (this.territoryKit = new TerritoryKit(this.runtime, this.options.nodes?.territory, this.options.nodes?.zone));
+  }
   /** Composing and deploying the app's tree of starter hubs (developers). */
   get topology() {
     return this.topologyKit ?? (this.topologyKit = new KitTopology(String(this.appId), this.domains.exec));

package/lib/vendor/crowdyjs-sdk.version.json

@@ -1,5 +1,5 @@
 {
   "name": "@crowdedkingdoms/crowdyjs",
-  "version": "18.11.0-dev.1",
+  "version": "18.12.0-dev.1",
   "source": "node_modules"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdedkingdoms/crowdy-dsh",
-  "version": "0.4.7-dev.1",
+  "version": "0.4.8-dev.1",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -94,11 +94,11 @@
   "crowdyDsh": {
     "build": {
       "package": "@crowdedkingdoms/crowdy-dsh",
-      "version": "0.4.7",
-      "builtAt": "2026-10-15T20:11:28.339Z",
+      "version": "0.4.8",
+      "builtAt": "2026-10-15T22:43:35.458Z",
       "source": {
         "repository": "CrowdedKingdoms/crowdy-dsh",
-        "commit": "5809199d9f08d3adcef9fa0cb25ecb2694c41caf",
+        "commit": "6be157fc87333ca64a2688d5e2ab77c9e57101dc",
         "dirty": false
       },
       "upstream": {
@@ -109,7 +109,7 @@
       },
       "crowdyjs": {
         "name": "@crowdedkingdoms/crowdyjs",
-        "version": "18.11.0-dev.1",
+        "version": "18.12.0-dev.1",
         "source": "node_modules"
       },
       "files": {
@@ -206,7 +206,7 @@
         "manifest.webmanifest": "sha256:9b54d57eea00f2fdd1affe6e7999a4209a515755f12ac1a3299da2d55e178d4c",
         "preview/bootstrap-CYECZNXt.js": "sha256:9f303a0485c0badfdd19fad0c357ef050c5b9a343744ab5bf0c70015e7d95092",
         "preview/crowdy-boot-Cklh1qNl.js": "sha256:b21e8eb126e1cd8a52159d2d577e610df6c8af36a436f9ed5028cfabd11a85ff",
-        "preview/vfs-image.tar.gz": "sha256:a399e9c5b46f89f6aad3eab2a9b97bc18acdbd6450bcb0abd754efafaeae00b5",
+        "preview/vfs-image.tar.gz": "sha256:95c3425e186deba4ce4355980db01d6451cca0404591c372180bef6c33ea2e5b",
         "preview/worker-C8-_ANaz.js": "sha256:81099e5732dfe0c32bacd5897316b7956c5a0a22da01b4a0c6e21d0a3b9d9aa1"
       }
     }