@crowdedkingdoms/crowdy-dsh 0.4.7-dev.1 → 0.4.9-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.9",
+  "builtAt": "2026-10-16T00:55:35.856Z",
   "source": {
     "repository": "CrowdedKingdoms/crowdy-dsh",
-    "commit": "5809199d9f08d3adcef9fa0cb25ecb2694c41caf",
+    "commit": "00f9782d0b449acfcec6025c2e63d52298a0e1ef",
     "dirty": false
   },
   "upstream": {
@@ -15,7 +15,7 @@
   },
   "crowdyjs": {
     "name": "@crowdedkingdoms/crowdyjs",
-    "version": "18.11.0-dev.1",
+    "version": "18.13.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:9eec4e84bf3530fa569beb85862ce4d5c4b914d49c3c86802fe3639e72bab6d0",
     "preview/worker-C8-_ANaz.js": "sha256:81099e5732dfe0c32bacd5897316b7956c5a0a22da01b4a0c6e21d0a3b9d9aa1"
   }
 }

package/lib/vendor/crowdyjs-sdk.js

@@ -10340,6 +10340,28 @@ function parseKitRefusal(message) {
   const m = CODED.exec(message);
   return m ? { code: m[1], text: m[2] } : null;
 }
+var KIT_CODES = {
+  BAD_REQUEST: "bad_request",
+  NOT_FOUND: "not_found",
+  FORBIDDEN: "forbidden",
+  CONFLICT: "conflict",
+  FULL: "full",
+  LIMIT: "limit",
+  COOLDOWN: "cooldown",
+  NOT_YOUR_TURN: "not_your_turn",
+  NOT_MEMBER: "not_member",
+  STARTED: "started",
+  FINISHED: "finished",
+  NOT_READY: "not_ready",
+  RESERVED: "reserved",
+  EMPTY: "empty",
+  OUT_OF_REACH: "out_of_reach",
+  EXPIRED: "expired",
+  INSUFFICIENT: "insufficient",
+  ALREADY_DONE: "already_done",
+  /** A hub the call needed did not answer: the kit sends it again with its action id. */
+  UNAVAILABLE: "unavailable"
+};
 var KitError = class _KitError extends CrowdyExecError {
   constructor(code, text, cause) {
     super("AppError", `kit:${code}: ${text}`, cause);
@@ -10595,6 +10617,443 @@ 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 TOPIC = "market";
+var MarketCore = class {
+  constructor(runtime, nodeType, key) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.key = key;
+    this.view = new HubState(runtime, nodeType, key, TOPIC);
+    const source = { nodeType, key, topic: TOPIC };
+    this.orders = new PrivateState(runtime, { ...source, what: "orders", read: () => runtime.call(nodeType, key, "orders") });
+    this.trades = new PrivateState(runtime, { ...source, what: "trades", read: () => runtime.call(nodeType, key, "trades") });
+  }
+  change(method, args) {
+    return this.runtime.call(this.nodeType, this.key, method, args, { action: true });
+  }
+};
+var MarketsKit = class {
+  constructor(core) {
+    this.core = core;
+  }
+  at(key = "town") {
+    return new MarketHandle(this.core(key));
+  }
+};
+var MarketHandle = class {
+  constructor(core) {
+    this.core = core;
+  }
+  get view() {
+    return this.core.view;
+  }
+  get orders() {
+    return this.core.orders;
+  }
+  async watch() {
+    const [view] = await Promise.all([this.core.view.start(), this.core.orders.start()]);
+    return view;
+  }
+  async unwatch() {
+    await Promise.all([this.core.view.stop(), this.core.orders.stop()]);
+  }
+  book(item) {
+    return this.core.runtime.call(this.core.nodeType, this.core.key, "book", { item });
+  }
+  /**
+   * Places a limit order; a buy holds `price * count` of the market's currency, a sell the items.
+   * @throws {KitError} `insufficient`, `limit` (open orders), `not_found` (no book), `unavailable`.
+   */
+  order(order) {
+    return this.core.change("order", order);
+  }
+  /** Cancels an open order; what it still holds comes back. @throws {KitError} `not_found`. */
+  cancel(order) {
+    return this.core.change("cancel", { order });
+  }
+};
+var ShopsKit = class {
+  constructor(core) {
+    this.core = core;
+  }
+  at(key = "town") {
+    return new ShopHandle(this.core(key));
+  }
+};
+var ShopHandle = class {
+  constructor(core) {
+    this.core = core;
+  }
+  get view() {
+    return this.core.view;
+  }
+  watch() {
+    return this.core.view.start();
+  }
+  unwatch() {
+    return this.core.view.stop();
+  }
+  vendors() {
+    return this.core.runtime.call(this.core.nodeType, this.core.key, "vendors");
+  }
+  /** Buys `count` (one by default). @throws {KitError} `insufficient` (gold or stock), `limit`, `full`, `not_found`, `unavailable`. */
+  buy(vendor, item, count) {
+    return this.core.change("buy", count === void 0 ? { vendor, item } : { vendor, item, count });
+  }
+  /** Sells `count` (one by default). @throws {KitError} `forbidden` (it does not buy them), `insufficient`, `unavailable`. */
+  sell(vendor, item, count) {
+    return this.core.change("sell", count === void 0 ? { vendor, item } : { vendor, item, count });
+  }
+};
+var TradesKit = class {
+  constructor(core) {
+    this.core = core;
+  }
+  at(key = "town") {
+    return new TradeDesk(this.core(key));
+  }
+};
+var TradeDesk = class {
+  constructor(core) {
+    this.core = core;
+  }
+  get mine() {
+    return this.core.trades;
+  }
+  async watch() {
+    return this.core.trades.start();
+  }
+  unwatch() {
+    return this.core.trades.stop();
+  }
+  /** Opens a trade with `player`; resolves with its id. */
+  open(player) {
+    return this.core.change("trade", { with: Number(player) });
+  }
+  /** Offers `bundle` (held at once; an empty one withdraws). @throws {KitError} `insufficient`, `forbidden`, `finished`. */
+  offer(trade, bundle) {
+    return this.core.change("offer", { trade, bundle });
+  }
+  /** Accepts the offers as they stand; resolves with the trade's state. @throws {KitError} `not_ready`, `finished`. */
+  accept(trade) {
+    return this.core.change("accept", { trade });
+  }
+  /** Calls it off; what each offered comes back. */
+  decline(trade) {
+    return this.core.change("decline", { trade });
+  }
+};
 
 var WritableKitStore = class {
   constructor(initial) {
@@ -10721,6 +11180,296 @@ 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 TOPIC2 = "player";
+var Relay = class extends WritableKitStore {
+  constructor() {
+    super(void 0);
+  }
+  attach(source) {
+    source.subscribe((v) => this.set(v));
+    if (source.get() !== void 0)
+      this.set(source.get());
+  }
+};
+var PlayerKit = class {
+  constructor(runtime, nodeType = "player", playerKey) {
+    this.runtime = runtime;
+    this.nodeType = nodeType;
+    this.playerKey = playerKey;
+    this.profile = new Relay();
+    this.inventory = new Relay();
+    this.wallet = new Relay();
+    this.progress = new Relay();
+    this.parts = null;
+    this.rulesRead = null;
+    this.events = /* @__PURE__ */ new Set();
+  }
+  /** The hub's key: the player's id. */
+  async key() {
+    const key = this.playerKey ?? await this.runtime.playerId();
+    if (key === null || key === void 0) {
+      throw new CrowdyError({ message: "the kit does not know which player it is: pass playerId to client.kit()" });
+    }
+    return key;
+  }
+  ready() {
+    this.parts ?? (this.parts = (async () => {
+      const key = await this.key();
+      const read = (method) => () => this.runtime.call(this.nodeType, key, method);
+      const source = { nodeType: this.nodeType, key, topic: TOPIC2 };
+      const parts = {
+        key,
+        profile: new HubState(this.runtime, this.nodeType, key, TOPIC2),
+        inventory: new PrivateState(this.runtime, { ...source, what: "inventory", read: read("inventory") }),
+        wallet: new PrivateState(this.runtime, { ...source, what: "wallet", read: read("wallet") }),
+        progress: new PrivateState(this.runtime, { ...source, what: "progress", read: read("progress") })
+      };
+      this.profile.attach(parts.profile);
+      this.inventory.attach(parts.inventory);
+      this.wallet.attach(parts.wallet);
+      this.progress.attach(parts.progress);
+      parts.profile.onEvent((body) => {
+        for (const l of [...this.events])
+          l(body);
+      });
+      return parts;
+    })().catch((e) => {
+      this.parts = null;
+      throw e;
+    }));
+    return this.parts;
+  }
+  /** Mirrors the profile and reads what only the player reads (all of it, or the parts named). */
+  async watch(...which) {
+    const parts = await this.ready();
+    const all = which.length ? which : ["profile", "inventory", "wallet", "progress"];
+    await Promise.all(all.map((w) => parts[w].start()));
+  }
+  async unwatch() {
+    if (!this.parts)
+      return;
+    const parts = await this.parts;
+    await Promise.all([parts.profile.stop(), parts.inventory.stop(), parts.wallet.stop(), parts.progress.stop()]);
+  }
+  /** Levels gained and achievements unlocked, as the `player` topic announces them. */
+  onEvent(listener) {
+    this.events.add(listener);
+    return () => this.events.delete(listener);
+  }
+  /** Calls the player's hub; a change carries an action id. */
+  async call(method, args, change = true) {
+    return this.runtime.call(this.nodeType, await this.key(), method, args ?? null, change ? { action: true } : {});
+  }
+  /** Everything the hub keeps for the player. */
+  me() {
+    return this.call("me", null, false);
+  }
+  /** The game's items, recipes, loot tables, quests and achievements (read once). */
+  rules() {
+    this.rulesRead ?? (this.rulesRead = this.call("rules", null, false).catch((e) => {
+      this.rulesRead = null;
+      throw e;
+    }));
+    return this.rulesRead;
+  }
+  /** Another player's public profile. */
+  profileOf(player) {
+    return this.runtime.call(this.nodeType, String(player), "profile");
+  }
+};
+var InventoryKit = class {
+  constructor(player) {
+    this.player = player;
+  }
+  get items() {
+    return this.player.inventory;
+  }
+  async watch() {
+    await this.player.watch("inventory");
+    return this.player.inventory.get();
+  }
+  /** How many of `item` the player has, as last read. */
+  count(item) {
+    return (this.player.inventory.get()?.stacks ?? []).filter((s) => s.item === item).reduce((n, s) => n + s.count, 0);
+  }
+  /** @throws {KitError} `insufficient`. */
+  discard(item, count) {
+    return this.player.call("discard", { item, count });
+  }
+  /** Moves what fits from the mail into the inventory; resolves with what moved. */
+  takeMail() {
+    return this.player.call("take_mail");
+  }
+};
+var WalletKit = class {
+  constructor(player) {
+    this.player = player;
+  }
+  get balances() {
+    return this.player.wallet;
+  }
+  async watch() {
+    await this.player.watch("wallet");
+    return this.player.wallet.get();
+  }
+  /** The balance of `currency`, as last read. */
+  balance(currency) {
+    return this.player.wallet.get()?.balances[currency] ?? 0;
+  }
+};
+var ProgressionKit = class {
+  constructor(player) {
+    this.player = player;
+  }
+  get progress() {
+    return this.player.progress;
+  }
+  get profile() {
+    return this.player.profile;
+  }
+  async watch() {
+    await this.player.watch("profile", "progress");
+    return this.player.progress.get();
+  }
+  /** Another player's public profile. */
+  profileOf(player) {
+    return this.player.profileOf(player);
+  }
+  /** Called with each level the player reaches. */
+  onLevel(listener) {
+    return this.player.onEvent((e) => e.type === "level" && listener(e.level));
+  }
+};
+var AchievementsKit = class {
+  constructor(player) {
+    this.player = player;
+  }
+  async watch() {
+    await this.player.watch("profile", "progress");
+    return this.list();
+  }
+  /** The achievements with their counts, as last read (hidden ones once unlocked). */
+  list() {
+    return this.player.progress.get()?.achievements ?? [];
+  }
+  /** Called with each achievement the player unlocks. */
+  onUnlock(listener) {
+    return this.player.onEvent((e) => e.type === "achievement" && listener(e.achievement));
+  }
+};
+var QuestsKit = class {
+  constructor(player) {
+    this.player = player;
+  }
+  async watch() {
+    await this.player.watch("progress");
+    return this.list();
+  }
+  list() {
+    return this.player.progress.get()?.quests ?? [];
+  }
+  /** @throws {KitError} `conflict` (taken, done, or another first), `forbidden` (level), `not_found`. */
+  accept(quest) {
+    return this.player.call("accept", { quest });
+  }
+  /** Claims a complete quest's reward. @throws {KitError} `not_ready`, `full`. */
+  claim(quest) {
+    return this.player.call("claim", { quest });
+  }
+  /**
+   * Reports one of the counters the game lets a client report (a tutorial step).
+   * @throws {KitError} `forbidden` for a counter the game's hubs count.
+   */
+  step(counter) {
+    return this.player.call("step", { counter });
+  }
+};
+var CraftingKit = class {
+  constructor(player) {
+    this.player = player;
+  }
+  async recipes() {
+    return (await this.player.rules()).recipes;
+  }
+  /** Crafts `times` (once by default). @throws {KitError} `insufficient`, `full`, `forbidden` (level), `not_found`. */
+  craft(recipe, times) {
+    return this.player.call("craft", times === void 0 ? { recipe } : { recipe, times });
+  }
+};
+var LootKit = class {
+  constructor(player) {
+    this.player = player;
+  }
+  async tables() {
+    return (await this.player.rules()).loot;
+  }
+  /** Pays the table's cost and rolls once. @throws {KitError} `insufficient`, `full`, `not_found`. */
+  open(table) {
+    return this.player.call("open", { table });
+  }
+};
+var ProductionKit = class {
+  constructor(player) {
+    this.player = player;
+  }
+  async view() {
+    return (await this.player.me()).production;
+  }
+  /** Moves what the producers made into the inventory, as far as it fits. */
+  collect() {
+    return this.player.call("collect");
+  }
+};
+
 var NpcsKit = class {
   constructor(runtime, options = {}) {
     this.runtime = runtime;
@@ -10921,6 +11670,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 +11846,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;
@@ -11135,6 +12183,10 @@ var KitRuntime = class {
         return await conn.call(nodeType, key, method, sent, { timeoutMs: options.timeoutMs });
       } catch (e) {
         const err = KitError.from(e);
+        if (attempt < this.retries && actionId && err instanceof KitError && err.code === KIT_CODES.UNAVAILABLE) {
+          await sleep(Math.min(2e3, 200 * 2 ** attempt) * (0.5 + Math.random() / 2));
+          continue;
+        }
         if (attempt < this.retries && err instanceof CrowdyExecError && !(err instanceof KitError)) {
           if (err.status === "Busy" && err.rateLimited) {
             this.budget.hold(err.retryAfterMs ?? 1e3);
@@ -11578,6 +12630,26 @@ 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.playerKit = null;
+    this.economy = /* @__PURE__ */ new Map();
+    this.markets = /* @__PURE__ */ new Map();
+    this.marketCore = (key) => {
+      let core = this.markets.get(key);
+      if (!core) {
+        core = new MarketCore(this.runtime, this.options.nodes?.market ?? "market", key);
+        this.markets.set(key, core);
+      }
+      return core;
+    };
     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 +12673,96 @@ 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));
+  }
+  /**
+   * The caller's own `player` hub: what they own and what they did. The economy lives in hub
+   * state and is not a ledger. The modules below are views of it.
+   */
+  get player() {
+    return this.playerKit ?? (this.playerKit = new PlayerKit(this.runtime, this.options.nodes?.player));
+  }
+  view(name, make) {
+    if (!this.economy.has(name))
+      this.economy.set(name, make(this.player));
+    return this.economy.get(name);
+  }
+  /** The player's items: stacks in slots, and mail for what did not fit. */
+  get inventory() {
+    return this.view("inventory", (p) => new InventoryKit(p));
+  }
+  /** The player's soft currencies. */
+  get wallet() {
+    return this.view("wallet", (p) => new WalletKit(p));
+  }
+  /** Experience, levels and public profiles. */
+  get progression() {
+    return this.view("progression", (p) => new ProgressionKit(p));
+  }
+  get achievements() {
+    return this.view("achievements", (p) => new AchievementsKit(p));
+  }
+  /** Quests, first-session tutorials among them. */
+  get quests() {
+    return this.view("quests", (p) => new QuestsKit(p));
+  }
+  get crafting() {
+    return this.view("crafting", (p) => new CraftingKit(p));
+  }
+  /** Loot tables with pity. */
+  get loot() {
+    return this.view("loot", (p) => new LootKit(p));
+  }
+  /** Idle production that catches up on the time away. */
+  get production() {
+    return this.view("production", (p) => new ProductionKit(p));
+  }
+  /** Markets' order books. */
+  get market() {
+    return this.view("market", () => new MarketsKit(this.marketCore));
+  }
+  /** Markets' vendors. */
+  get shops() {
+    return this.view("shops", () => new ShopsKit(this.marketCore));
+  }
+  /** Trades between two players at a market. */
+  get trades() {
+    return this.view("trades", () => new TradesKit(this.marketCore));
+  }
   /** 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.13.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.9-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.9",
+      "builtAt": "2026-10-16T00:55:35.856Z",
       "source": {
         "repository": "CrowdedKingdoms/crowdy-dsh",
-        "commit": "5809199d9f08d3adcef9fa0cb25ecb2694c41caf",
+        "commit": "00f9782d0b449acfcec6025c2e63d52298a0e1ef",
         "dirty": false
       },
       "upstream": {
@@ -109,7 +109,7 @@
       },
       "crowdyjs": {
         "name": "@crowdedkingdoms/crowdyjs",
-        "version": "18.11.0-dev.1",
+        "version": "18.13.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:9eec4e84bf3530fa569beb85862ce4d5c4b914d49c3c86802fe3639e72bab6d0",
         "preview/worker-C8-_ANaz.js": "sha256:81099e5732dfe0c32bacd5897316b7956c5a0a22da01b4a0c6e21d0a3b9d9aa1"
       }
     }