@omnigateway/pokemon 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Harismawan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# @omnigateway/pokemon
+
+A Pokémon companion for [OmniGateway](https://github.com/harismawan/omnigateway).
+
+Each gateway API key raises one companion. It hatches, evolves, and graduates
+into a per-key Pokédex on the tokens that key spends, with a shop that spends a
+wallet of those same tokens. It is strictly an observer: nothing it stores
+affects routing, limits, or anything a request depends on.
+
+## Name
+
+Unscoped, on purpose. `@omnigateway/*` is the project's own scope, and a
+third-party plugin could never publish into it — so this repository is named the
+way an external author's would be, `omnigateway-plugin-<name>`, the same
+convention as `eslint-plugin-*`. It is the companion plugin, not a first-party
+one, and the packaging should say so.
+
+## Install
+
+The gateway resolves a plugin by name through npm, so the host needs no checkout
+and no build toolchain:
+
+```bash
+omni plugin install @omnigateway/pokemon
+omni plugin verify pokemon && omni restart
+```
+
+`verify` is the one to run before restarting a gateway that people are using: it
+reaches the same verdict the next boot will, from the same code, without loading
+the plugin.
+
+Resolving a name through npm makes distribution easier; it does not make an
+unknown plugin safer. Integrity checking proves you received the bytes the
+registry advertised, and nothing about who wrote them or what they do once the
+gateway imports them.
+
+### From a checkout
+
+```bash
+bun install
+bun run build                 # writes dist/pokemon
+omni plugin install ./dist/pokemon
+omni restart
+```
+
+The built directory is `dist/pokemon` and the name matters: the installer takes
+the installed directory name from the source and refuses a manifest whose `id`
+disagrees with it, so a plugin cannot be installed under a name that is not its
+own.
+
+## Capabilities
+
+The manifest declares five, and each one is there for a reason a reader can
+check:
+
+| Capability | Why |
+| --- | --- |
+| `storage` | Three tables on the plugin's own migration track, named `plugin_pokemon_<name>` by the host: the companion row per key, the Dex, and the grant ledger. |
+| `files` | The species index and cached sprites live in the plugin's scoped data directory, **not** in a table. That directory is excluded from database snapshots, exactly as `request_bodies/` is — the alternative would put tens of megabytes of artwork into every snapshot an operator downloads, and it re-fetches itself anyway. |
+| `net:outbound` | Species data and sprites are fetched at runtime. The manifest also declares the origins, `https://pokeapi.co` and `https://raw.githubusercontent.com`; the host hands the plugin a `fetch` bound to that allowlist and refuses anything else. |
+| `events:request` | Growth is credited from `RequestCompleted` — all four token classes, which are disjoint, so summing them double-counts nothing. |
+| `events:limit` | A key parked at a `5h` or `1w` ceiling earns a rare candy, rated by the window's own length. A `1m` ceiling pays nothing: a minute is not a span in which work happened. |
+
+Worth restating, because a plugin author reading a capability list will assume
+otherwise: **this is a guardrail, not a sandbox.** A plugin shares the gateway's
+process and can import past all of it. What the declaration buys is that
+accidental overreach is impossible and that the plugin's intent is auditable
+from one readable file. It constrains honest code and not hostile code.
+
+The plugin degrades rather than failing when a capability is absent. With no
+`net`, an incubating egg holds its progress instead of losing it, and the sprite
+route answers `503`.
+
+## Nintendo and Game Freak intellectual property
+
+The sprites, names, and evolution data are Nintendo and Game Freak intellectual
+property, fetched at runtime from PokéAPI and the community sprite repository.
+**Nothing is vendored** — not into this repository, not into the published npm
+package, not into any built artifact. A running install contacts `pokeapi.co`
+and `raw.githubusercontent.com` and caches what it gets in its own scoped data
+directory.
+
+This plugin ships separately, as something an operator chooses to fetch, rather
+than inside OmniGateway's npm package or Docker image. Infrastructure other
+people deploy is a different exposure profile from a personal application, and
+that packaging decision follows from it. Recorded here so it stays a knowing
+one.
+
+## Development
+
+```bash
+bun install
+bun run test      # the plugin's own suites
+bun run test:ui   # the console panel, under happy-dom, separately
+bun run typecheck
+bun run lint
+bun run build
+```
+
+The UI suite runs on its own because registering a DOM mutates process-wide
+globals, which would leak into every other file sharing the process.
+
+This package builds against the published `@omnigateway/plugin-api` and
+`@omnigateway/dashboard-sdk` and against nothing internal to the gateway. That
+is deliberate: a plugin developed inside the monorepo can reach packages an
+installed plugin cannot, and a build that only succeeds there proves nothing
+about one that has to run anywhere else.
+
+## Licence
+
+MIT. See [LICENSE](LICENSE). The licence covers this plugin's code and not the
+third-party assets it fetches at runtime.

package/omni-plugin.json

@@ -0,0 +1,17 @@
+{
+  "id": "pokemon",
+  "name": "Pok\u00e9mon Companion",
+  "version": "1.0.0",
+  "api": 1,
+  "sdk": "^0.1.0",
+  "server": "server/index.js",
+  "ui": "ui/index.js",
+  "nav": {
+    "label": "Companion"
+  },
+  "capabilities": ["storage", "files", "net:outbound", "events:request", "events:limit"],
+  "origins": ["https://pokeapi.co", "https://raw.githubusercontent.com"],
+  "defaults": {
+    "multiplier": 1
+  }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@omnigateway/pokemon",
+  "version": "1.0.0",
+  "description": "A Pokémon companion for OmniGateway. Each gateway key raises one that hatches, evolves, and graduates into a Pokédex on the tokens that key spends.",
+  "license": "MIT",
+  "author": "Harismawan <mail@harismawan.com>",
+  "homepage": "https://github.com/harismawan/omnigateway-plugin-pokemon",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harismawan/omnigateway-plugin-pokemon.git"
+  },
+  "bugs": {
+    "url": "https://github.com/harismawan/omnigateway-plugin-pokemon/issues"
+  },
+  "keywords": [
+    "omnigateway",
+    "omnigateway-plugin",
+    "pokemon"
+  ],
+  "files": [
+    "omni-plugin.json",
+    "server",
+    "ui",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/server/index.js

@@ -0,0 +1,1134 @@
+// @bun
+// node_modules/@omnigateway/plugin-api/src/context.ts
+function definePlugin(definition) {
+  return definition;
+}
+
+// src/balance.ts
+var RARITIES = ["common", "uncommon", "rare", "legendary"];
+function sortRank(rarity) {
+  return RARITIES.indexOf(rarity);
+}
+var CAPTURE_RATE_CEILING = {
+  rare: 45,
+  uncommon: 120,
+  common: 255
+};
+function rarityFromCaptureRate(captureRate, isLegendary, isMythical) {
+  if (isLegendary || isMythical)
+    return "legendary";
+  if (captureRate <= CAPTURE_RATE_CEILING.rare)
+    return "rare";
+  if (captureRate <= CAPTURE_RATE_CEILING.uncommon)
+    return "uncommon";
+  return "common";
+}
+var GRADUATION_TOTAL = {
+  common: 750000000,
+  uncommon: 1875000000,
+  rare: 3000000000,
+  legendary: 6000000000
+};
+function graduationTotal(rarity) {
+  return GRADUATION_TOTAL[rarity];
+}
+function phaseThreshold(rarity, totalForms, stageIndex) {
+  const forms = Math.max(1, totalForms);
+  const step = stageIndex + 1;
+  const denominator = forms * (forms + 1) / 2;
+  return Math.round(graduationTotal(rarity) * step / denominator);
+}
+var EGG_HATCH_THRESHOLD = 5000000;
+var RARE_CANDY_XP = 1e8;
+var ITEM_PRICES = {
+  rareCandy: 500000000,
+  mint: 1e8,
+  shinyCharm: 3000000000
+};
+var ITEM_KINDS = Object.keys(ITEM_PRICES);
+var FRESH_EGG_BASE_PRICE = 1e9;
+function freshEggPrice(tier) {
+  if (tier === null)
+    return FRESH_EGG_BASE_PRICE;
+  if (tier === "legendary") {
+    throw new Error("there is no legendary fresh egg; legendaries come from the upper tiers");
+  }
+  const multiplier = graduationTotal(tier) / graduationTotal("common");
+  return Math.round(FRESH_EGG_BASE_PRICE * multiplier);
+}
+var ODDS = {
+  shiny: 64,
+  shinyWithCharm: 48,
+  dittoDisguise: 128
+};
+var DITTO_SPECIES_ID = 132;
+var ANIMATED_SPECIES_MAX = 649;
+function hasAnimatedSprite(speciesId) {
+  return speciesId >= 1 && speciesId <= ANIMATED_SPECIES_MAX;
+}
+
+// node_modules/@omnigateway/plugin-api/src/events.ts
+var WINDOW_MS = {
+  "1m": 60000,
+  "5h": 5 * 60 * 60 * 1000,
+  "1w": 7 * 24 * 60 * 60 * 1000
+};
+
+// src/grants.ts
+function windowKey(event) {
+  return `${event.dimension}:${event.window}`;
+}
+function grantSize(window) {
+  if (window === "1w")
+    return 5;
+  if (window === "5h")
+    return 1;
+  return 0;
+}
+function decideGrant(input) {
+  if (grantSize(input.window) === 0)
+    return { grant: false };
+  if (input.lastGrantedAt === null)
+    return { grant: false, seedAt: input.now };
+  if (input.now - input.lastGrantedAt < WINDOW_MS[input.window])
+    return { grant: false };
+  return { grant: true, count: grantSize(input.window), at: input.now };
+}
+
+// src/pokeapi.ts
+var POKEAPI_ORIGIN = "https://pokeapi.co";
+var SPRITE_ORIGIN = "https://raw.githubusercontent.com";
+var SPRITE_DIR = "/PokeAPI/sprites/master/sprites/pokemon/versions/generation-v/black-white/animated";
+var MAX_EVOLUTION_CHAIN_ID = 2000;
+var INDEX_FETCH_CONCURRENCY = 8;
+var INDEX_PATH = "species/index.json";
+var speciesPath = (id) => `species/${id}.json`;
+var chainPath = (chainId) => `species/chain-${chainId}.json`;
+var spritePath = (id, shiny) => shiny ? `sprites/shiny/${id}.gif` : `sprites/${id}.gif`;
+function isFetchableSpeciesId(id) {
+  return Number.isInteger(id) && hasAnimatedSprite(id);
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return null;
+  return value;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : null;
+}
+function asFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+async function readJson(deps, path) {
+  try {
+    const bytes = await deps.files.read(path);
+    if (bytes === null)
+      return null;
+    return JSON.parse(decoder.decode(bytes));
+  } catch {
+    return null;
+  }
+}
+async function writeCache(deps, path, bytes) {
+  try {
+    await deps.files.write(path, bytes);
+  } catch {}
+}
+async function writeJson(deps, path, value) {
+  await writeCache(deps, path, encoder.encode(JSON.stringify(value)));
+}
+async function fetchJson(deps, url) {
+  try {
+    const response = await deps.net(url);
+    if (!response.ok)
+      return null;
+    return JSON.parse(await response.text());
+  } catch {
+    return null;
+  }
+}
+async function fetchBytes(deps, url) {
+  try {
+    const response = await deps.net(url);
+    if (!response.ok)
+      return null;
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    return bytes.length === 0 ? null : bytes;
+  } catch {
+    return null;
+  }
+}
+var CHAIN_URL_ID = /\/evolution-chain\/(\d+)\/?$/;
+function chainIdFromUrl(url) {
+  if (typeof url !== "string")
+    return null;
+  const match = CHAIN_URL_ID.exec(url);
+  if (match === null)
+    return null;
+  const id = Number(match[1]);
+  if (!Number.isInteger(id) || id < 1 || id > MAX_EVOLUTION_CHAIN_ID)
+    return null;
+  return id;
+}
+var SPECIES_URL_ID = /\/pokemon-species\/(\d+)\/?$/;
+function speciesIdFromUrl(url) {
+  if (typeof url !== "string")
+    return null;
+  const match = SPECIES_URL_ID.exec(url);
+  if (match === null)
+    return null;
+  const id = Number(match[1]);
+  return isFetchableSpeciesId(id) ? id : null;
+}
+function parseChainNode(raw) {
+  const node = asRecord(raw);
+  if (node === null)
+    return null;
+  const species = asRecord(node.species);
+  const id = speciesIdFromUrl(species?.url);
+  if (id === null)
+    return null;
+  const children = asArray(node.evolves_to) ?? [];
+  const evolvesTo = [];
+  for (const child of children) {
+    const parsed = parseChainNode(child);
+    if (parsed !== null)
+      evolvesTo.push(parsed);
+  }
+  return { id, evolvesTo };
+}
+function pathTo(node, id) {
+  if (node.id === id)
+    return [id];
+  for (const child of node.evolvesTo) {
+    const tail = pathTo(child, id);
+    if (tail !== null)
+      return [node.id, ...tail];
+  }
+  return null;
+}
+function descendFirstBranch(node) {
+  const rest = [];
+  let current = node;
+  while (current.evolvesTo.length > 0) {
+    const next = current.evolvesTo[0];
+    rest.push(next.id);
+    current = next;
+  }
+  return rest;
+}
+function lineThrough(root, id) {
+  const prefix = pathTo(root, id);
+  if (prefix === null)
+    return null;
+  const self = prefix[prefix.length - 1];
+  const node = nodeFor(root, self);
+  return node === null ? prefix : [...prefix, ...descendFirstBranch(node)];
+}
+function nodeFor(node, id) {
+  if (node.id === id)
+    return node;
+  for (const child of node.evolvesTo) {
+    const found = nodeFor(child, id);
+    if (found !== null)
+      return found;
+  }
+  return null;
+}
+function loadChain(deps, chainId, cache) {
+  const inFlight = cache.get(chainId);
+  if (inFlight !== undefined)
+    return inFlight;
+  const pending = (async () => {
+    const path = chainPath(chainId);
+    const cached = await readJson(deps, path);
+    if (cached !== null) {
+      const parsed2 = parseChainNode(cached);
+      if (parsed2 !== null)
+        return parsed2;
+    }
+    const fetched = await fetchJson(deps, `${POKEAPI_ORIGIN}/api/v2/evolution-chain/${chainId}`);
+    if (fetched === null)
+      return null;
+    const root = asRecord(fetched)?.chain;
+    const parsed = parseChainNode(root);
+    if (parsed === null)
+      return null;
+    await writeJson(deps, path, { chain: root });
+    return parsed;
+  })();
+  cache.set(chainId, pending);
+  return pending;
+}
+function parseNames(raw) {
+  const names = {};
+  for (const entry of asArray(raw) ?? []) {
+    const record = asRecord(entry);
+    if (record === null)
+      continue;
+    const language = asRecord(record.language)?.name;
+    const name = record.name;
+    if (typeof language === "string" && typeof name === "string")
+      names[language] = name;
+  }
+  return names;
+}
+function parseCachedDetail(raw, id) {
+  const record = asRecord(raw);
+  if (record === null)
+    return null;
+  const captureRate = asFiniteNumber(record.captureRate);
+  if (captureRate === null)
+    return null;
+  const chainRaw = asArray(record.chain);
+  if (chainRaw === null || chainRaw.length === 0)
+    return null;
+  const chain = [];
+  for (const entry of chainRaw) {
+    if (typeof entry !== "number" || !isFetchableSpeciesId(entry))
+      return null;
+    chain.push(entry);
+  }
+  return {
+    id,
+    names: parseNames(record.names),
+    captureRate,
+    isLegendary: record.isLegendary === true,
+    isMythical: record.isMythical === true,
+    chain
+  };
+}
+function detailToCache(detail) {
+  return {
+    captureRate: detail.captureRate,
+    isLegendary: detail.isLegendary,
+    isMythical: detail.isMythical,
+    chain: detail.chain,
+    names: Object.entries(detail.names).map(([language, name]) => ({
+      language: { name: language },
+      name
+    }))
+  };
+}
+async function loadDetail(deps, id, chains) {
+  if (!isFetchableSpeciesId(id))
+    return null;
+  const path = speciesPath(id);
+  const cached = parseCachedDetail(await readJson(deps, path), id);
+  if (cached !== null)
+    return cached;
+  const raw = asRecord(await fetchJson(deps, `${POKEAPI_ORIGIN}/api/v2/pokemon-species/${id}`));
+  if (raw === null)
+    return null;
+  const captureRate = asFiniteNumber(raw.capture_rate);
+  if (captureRate === null)
+    return null;
+  const chainId = chainIdFromUrl(asRecord(raw.evolution_chain)?.url);
+  if (chainId === null)
+    return null;
+  const root = await loadChain(deps, chainId, chains);
+  if (root === null)
+    return null;
+  const chain = lineThrough(root, id);
+  if (chain === null || chain.length === 0)
+    return null;
+  const detail = {
+    id,
+    names: parseNames(raw.names),
+    captureRate,
+    isLegendary: raw.is_legendary === true,
+    isMythical: raw.is_mythical === true,
+    chain
+  };
+  await writeJson(deps, path, detailToCache(detail));
+  return detail;
+}
+function speciesDetail(deps, id) {
+  return loadDetail(deps, id, new Map);
+}
+function parseCachedIndex(raw) {
+  const entries = asArray(raw);
+  if (entries === null)
+    return null;
+  const candidates = [];
+  for (const entry of entries) {
+    const record = asRecord(entry);
+    if (record === null)
+      return null;
+    const id = asFiniteNumber(record.id);
+    const captureRate = asFiniteNumber(record.captureRate);
+    const forms = asFiniteNumber(record.forms);
+    const finalId = asFiniteNumber(record.finalId);
+    if (id === null || captureRate === null || forms === null || finalId === null)
+      return null;
+    if (!isFetchableSpeciesId(id))
+      return null;
+    candidates.push({ id, captureRate, forms, finalId });
+  }
+  return candidates.length === 0 ? null : candidates;
+}
+async function mapWithConcurrency(ids, limit, worker) {
+  const results = new Array(ids.length);
+  let next = 0;
+  const runners = Array.from({ length: Math.min(limit, ids.length) }, async () => {
+    while (next < ids.length) {
+      const index = next++;
+      results[index] = await worker(ids[index]);
+    }
+  });
+  await Promise.all(runners);
+  return results;
+}
+async function speciesIndex(deps) {
+  const cached = parseCachedIndex(await readJson(deps, INDEX_PATH));
+  if (cached !== null)
+    return cached;
+  const ids = Array.from({ length: ANIMATED_SPECIES_MAX }, (_, i) => i + 1);
+  const chains = new Map;
+  const details = await mapWithConcurrency(ids, INDEX_FETCH_CONCURRENCY, (id) => loadDetail(deps, id, chains));
+  const candidates = [];
+  for (const detail of details) {
+    if (detail === null)
+      continue;
+    if (detail.chain[0] !== detail.id)
+      continue;
+    candidates.push({
+      id: detail.id,
+      captureRate: detail.captureRate,
+      forms: detail.chain.length,
+      finalId: detail.chain[detail.chain.length - 1] ?? detail.id
+    });
+  }
+  if (details.every((detail) => detail !== null))
+    await writeJson(deps, INDEX_PATH, candidates);
+  return candidates;
+}
+async function spriteBytes(deps, id, shiny) {
+  if (!isFetchableSpeciesId(id))
+    return null;
+  const path = spritePath(id, shiny);
+  try {
+    const cached = await deps.files.read(path);
+    if (cached !== null && cached.length > 0)
+      return cached;
+  } catch {}
+  const url = shiny ? `${SPRITE_ORIGIN}${SPRITE_DIR}/shiny/${id}.gif` : `${SPRITE_ORIGIN}${SPRITE_DIR}/${id}.gif`;
+  const bytes = await fetchBytes(deps, url);
+  if (bytes === null)
+    return null;
+  await writeCache(deps, path, bytes);
+  return bytes;
+}
+
+// src/roll.ts
+var NATURES = [
+  "hardy",
+  "lonely",
+  "brave",
+  "adamant",
+  "naughty",
+  "bold",
+  "docile",
+  "relaxed",
+  "impish",
+  "lax",
+  "timid",
+  "hasty",
+  "serious",
+  "jolly",
+  "naive",
+  "modest",
+  "mild",
+  "quiet",
+  "bashful",
+  "rash",
+  "calm",
+  "gentle",
+  "sassy",
+  "careful",
+  "quirky"
+];
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var COLLECTED_WEIGHT = 0.25;
+function roll(input) {
+  const random = mulberry32(input.seed);
+  const eligible = input.candidates.filter((candidate) => {
+    if (!hasAnimatedSprite(candidate.id))
+      return false;
+    if (candidate.id === DITTO_SPECIES_ID)
+      return false;
+    if (input.guarantee === null)
+      return true;
+    const rarity2 = rarityFromCaptureRate(candidate.captureRate, false, false);
+    return sortRank(rarity2) >= sortRank(input.guarantee);
+  });
+  if (eligible.length === 0)
+    return null;
+  const weights = eligible.map((candidate) => {
+    const base = Math.max(1, candidate.captureRate);
+    return input.collectedFinals.has(candidate.finalId) ? base * COLLECTED_WEIGHT : base;
+  });
+  const total = weights.reduce((a, b) => a + b, 0);
+  let target = random() * total;
+  let index = 0;
+  for (let i = 0;i < weights.length; i++) {
+    target -= weights[i];
+    if (target <= 0) {
+      index = i;
+      break;
+    }
+  }
+  const chosen = eligible[index];
+  const shinyDenominator = input.hasShinyCharm ? ODDS.shinyWithCharm : ODDS.shiny;
+  const isShiny = random() < 1 / shinyDenominator;
+  const nature = NATURES[Math.floor(random() * NATURES.length)];
+  const rarity = rarityFromCaptureRate(chosen.captureRate, false, false);
+  const dittoEligible = rarity === "common" && chosen.forms >= 2;
+  const ditto = dittoEligible && random() < 1 / ODDS.dittoDisguise;
+  return { speciesId: chosen.id, isShiny, nature, ditto };
+}
+
+// src/state.ts
+function freshState() {
+  return {
+    consumedTotal: 0,
+    active: null,
+    eggUsage: 0,
+    eggTier: null,
+    pendingHatch: null,
+    inventory: { rareCandy: 0, mint: 0, shinyCharm: 0 }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asInt(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : fallback;
+}
+function asRarity(value) {
+  return RARITIES.includes(value) ? value : null;
+}
+function parseState(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed))
+    return null;
+  const inventory = { rareCandy: 0, mint: 0, shinyCharm: 0 };
+  const storedInventory = parsed.inventory;
+  if (isRecord(storedInventory)) {
+    for (const kind of ITEM_KINDS) {
+      inventory[kind] = Math.max(0, asInt(storedInventory[kind], 0));
+    }
+  }
+  let active = null;
+  const storedActive = parsed.active;
+  if (storedActive !== null && storedActive !== undefined) {
+    if (!isRecord(storedActive))
+      return null;
+    const rarity = asRarity(storedActive.rarity);
+    if (rarity === null)
+      return null;
+    const path = Array.isArray(storedActive.plannedPath) ? storedActive.plannedPath.filter((id) => typeof id === "number" && id > 0) : [];
+    if (path.length === 0)
+      return null;
+    const nature = NATURES.includes(storedActive.nature) ? storedActive.nature : null;
+    active = {
+      baseId: asInt(storedActive.baseId, path[0]),
+      plannedPath: path,
+      stageIndex: Math.min(Math.max(0, asInt(storedActive.stageIndex, 0)), path.length - 1),
+      usedAtStage: Math.max(0, asInt(storedActive.usedAtStage, 0)),
+      rarity,
+      isShiny: storedActive.isShiny === true,
+      nature: nature ?? "hardy",
+      dittoDisguise: typeof storedActive.dittoDisguise === "number" ? storedActive.dittoDisguise : null,
+      dittoRevealed: storedActive.dittoRevealed === true
+    };
+  }
+  const storedPending = parsed.pendingHatch;
+  let pendingHatch = null;
+  if (isRecord(storedPending)) {
+    const rarity = asRarity(storedPending.rarity);
+    const path = Array.isArray(storedPending.path) ? storedPending.path.filter((id) => typeof id === "number" && id > 0) : [];
+    if (rarity !== null && path.length > 0) {
+      const nature = NATURES.includes(storedPending.nature) ? storedPending.nature : "hardy";
+      pendingHatch = {
+        speciesId: asInt(storedPending.speciesId, path[0]),
+        path,
+        rarity,
+        isShiny: storedPending.isShiny === true,
+        nature,
+        ditto: storedPending.ditto === true
+      };
+    }
+  }
+  const eggTier = asRarity(parsed.eggTier);
+  return {
+    consumedTotal: Math.max(0, asInt(parsed.consumedTotal, 0)),
+    active,
+    eggUsage: Math.max(0, asInt(parsed.eggUsage, 0)),
+    eggTier: eggTier === null || eggTier === "legendary" ? null : eggTier,
+    pendingHatch,
+    inventory
+  };
+}
+function serialiseState(state) {
+  return JSON.stringify(state);
+}
+function hasShinyCharm(state) {
+  return (state.inventory.shinyCharm ?? 0) > 0;
+}
+
+// src/advance.ts
+var MAX_TRANSITIONS_PER_ADVANCE = 64;
+function advance(state, tokensTotal) {
+  const gained = Math.max(0, Math.trunc(tokensTotal) - state.consumedTotal);
+  const events = [];
+  let next = { ...state, consumedTotal: Math.trunc(tokensTotal) };
+  if (gained > 0) {
+    next = next.active === null ? { ...next, eggUsage: next.eggUsage + gained } : { ...next, active: { ...next.active, usedAtStage: next.active.usedAtStage + gained } };
+  }
+  for (let step = 0;step < MAX_TRANSITIONS_PER_ADVANCE; step++) {
+    if (next.active === null) {
+      if (next.eggUsage < EGG_HATCH_THRESHOLD)
+        break;
+      if (next.pendingHatch === null)
+        break;
+      const hatch = next.pendingHatch;
+      const active = {
+        baseId: hatch.path[0] ?? hatch.speciesId,
+        plannedPath: hatch.path,
+        stageIndex: 0,
+        usedAtStage: next.eggUsage - EGG_HATCH_THRESHOLD,
+        rarity: hatch.rarity,
+        isShiny: hatch.isShiny,
+        nature: hatch.nature,
+        dittoDisguise: hatch.ditto ? hatch.speciesId : null,
+        dittoRevealed: false
+      };
+      events.push({
+        kind: "hatched",
+        speciesId: hatch.speciesId,
+        isShiny: active.isShiny,
+        ditto: active.dittoDisguise !== null
+      });
+      next = { ...next, active, eggUsage: 0, eggTier: null, pendingHatch: null };
+      continue;
+    }
+    const mon = next.active;
+    const needed = phaseThreshold(mon.rarity, mon.plannedPath.length, mon.stageIndex);
+    if (mon.usedAtStage < needed)
+      break;
+    const excess = mon.usedAtStage - needed;
+    if (mon.stageIndex < mon.plannedPath.length - 1) {
+      events.push({
+        kind: "evolved",
+        from: mon.plannedPath[mon.stageIndex],
+        to: mon.plannedPath[mon.stageIndex + 1]
+      });
+      next = { ...next, active: { ...mon, stageIndex: mon.stageIndex + 1, usedAtStage: excess } };
+      continue;
+    }
+    events.push({
+      kind: "graduated",
+      baseId: mon.baseId,
+      finalId: mon.plannedPath[mon.plannedPath.length - 1],
+      chainOrder: mon.plannedPath,
+      rarity: mon.rarity,
+      isShiny: mon.isShiny,
+      nature: mon.nature
+    });
+    next = { ...next, active: null, eggUsage: excess, eggTier: null, pendingHatch: null };
+  }
+  return { state: next, events };
+}
+
+// src/store.ts
+var MIGRATIONS = [
+  {
+    version: 1,
+    sql: `
+      CREATE TABLE {{companion}} (
+        api_key_id   TEXT PRIMARY KEY,
+        state        TEXT NOT NULL,
+        tokens_total INTEGER NOT NULL DEFAULT 0,
+        tokens_spent INTEGER NOT NULL DEFAULT 0,
+        created_at   INTEGER NOT NULL,
+        updated_at   INTEGER NOT NULL
+      )
+    `
+  },
+  {
+    version: 2,
+    sql: `
+      CREATE TABLE {{dex}} (
+        id          TEXT PRIMARY KEY,
+        api_key_id  TEXT NOT NULL,
+        base_id     INTEGER NOT NULL,
+        final_id    INTEGER NOT NULL,
+        chain_order TEXT NOT NULL,
+        rarity      TEXT NOT NULL,
+        is_shiny    INTEGER NOT NULL DEFAULT 0,
+        nature      TEXT,
+        caught_at   INTEGER NOT NULL
+      )
+    `
+  },
+  {
+    version: 3,
+    sql: `CREATE INDEX {{dex_by_key}} ON {{dex}} (api_key_id, caught_at DESC)`
+  },
+  {
+    version: 4,
+    sql: `
+      CREATE TABLE {{grants}} (
+        api_key_id TEXT NOT NULL,
+        window_key TEXT NOT NULL,
+        -- An instant, not a tier. A grant is rate-limited by the window's own
+        -- duration, because nothing tells this plugin when a window empties.
+        granted_at INTEGER NOT NULL,
+        PRIMARY KEY (api_key_id, window_key)
+      )
+    `
+  },
+  {
+    version: 5,
+    sql: `ALTER TABLE {{companion}} ADD COLUMN last_credit_at INTEGER`
+  }
+];
+function wallet(row) {
+  return Math.max(0, row.tokensTotal - row.tokensSpent);
+}
+function readCompanion(storage, apiKeyId) {
+  const row = storage.get(`SELECT api_key_id, state, tokens_total, tokens_spent, last_credit_at
+     FROM {{companion}} WHERE api_key_id = ?`, [apiKeyId]);
+  if (row === null)
+    return null;
+  return {
+    apiKeyId: row.api_key_id,
+    state: parseState(row.state),
+    tokensTotal: row.tokens_total,
+    tokensSpent: row.tokens_spent,
+    lastCreditAt: row.last_credit_at
+  };
+}
+function creditTokens(storage, apiKeyId, tokens, now) {
+  if (tokens <= 0)
+    return;
+  storage.run(`INSERT INTO {{companion}} (api_key_id, state, tokens_total, tokens_spent, created_at, updated_at, last_credit_at)
+     VALUES (?, ?, ?, 0, ?, ?, ?)
+     ON CONFLICT(api_key_id) DO UPDATE SET
+       tokens_total = tokens_total + excluded.tokens_total,
+       updated_at = excluded.updated_at,
+       last_credit_at = excluded.last_credit_at`, [apiKeyId, serialiseState(freshState()), Math.trunc(tokens), now, now, now]);
+}
+function settle(storage, apiKeyId, now) {
+  const row = readCompanion(storage, apiKeyId);
+  if (row === null)
+    return null;
+  if (row.state === null)
+    return { row, events: [] };
+  const result = advance(row.state, row.tokensTotal);
+  if (result.events.length === 0 && result.state === row.state)
+    return { row, events: [] };
+  storage.run("UPDATE {{companion}} SET state = ?, updated_at = ? WHERE api_key_id = ?", [
+    serialiseState(result.state),
+    now,
+    apiKeyId
+  ]);
+  return { row: { ...row, state: result.state }, events: result.events };
+}
+function recordGraduation(storage, apiKeyId, entry, id) {
+  storage.run(`INSERT INTO {{dex}} (id, api_key_id, base_id, final_id, chain_order, rarity, is_shiny, nature, caught_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    apiKeyId,
+    entry.baseId,
+    entry.finalId,
+    JSON.stringify(entry.chainOrder),
+    entry.rarity,
+    entry.isShiny ? 1 : 0,
+    entry.nature,
+    entry.caughtAt
+  ]);
+}
+function readDex(storage, apiKeyId) {
+  const rows = storage.all(`SELECT id, base_id, final_id, chain_order, rarity, is_shiny, nature, caught_at
+     FROM {{dex}} WHERE api_key_id = ? ORDER BY caught_at DESC`, [apiKeyId]);
+  const entries = [];
+  for (const row of rows) {
+    let chainOrder;
+    try {
+      chainOrder = JSON.parse(row.chain_order);
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(chainOrder))
+      continue;
+    const chain = chainOrder.filter((id) => typeof id === "number");
+    if (chain.length === 0)
+      continue;
+    entries.push({
+      id: row.id,
+      baseId: row.base_id,
+      finalId: row.final_id,
+      chainOrder: chain,
+      rarity: row.rarity,
+      isShiny: row.is_shiny === 1,
+      nature: row.nature,
+      caughtAt: row.caught_at
+    });
+  }
+  return entries;
+}
+function lastGrantedAt(storage, apiKeyId, windowKey2) {
+  const row = storage.get("SELECT granted_at FROM {{grants}} WHERE api_key_id = ? AND window_key = ?", [apiKeyId, windowKey2]);
+  return row?.granted_at ?? null;
+}
+function setGrantedAt(storage, apiKeyId, windowKey2, at) {
+  storage.run(`INSERT INTO {{grants}} (api_key_id, window_key, granted_at) VALUES (?, ?, ?)
+     ON CONFLICT(api_key_id, window_key) DO UPDATE SET granted_at = excluded.granted_at`, [apiKeyId, windowKey2, at]);
+}
+function shopPrice(entry) {
+  return entry.kind === "item" ? ITEM_PRICES[entry.item] : freshEggPrice(entry.tier);
+}
+function consume(storage, apiKeyId, item, applyToState, now) {
+  const row = readCompanion(storage, apiKeyId);
+  if (row === null)
+    return { ok: false, reason: "missing" };
+  if (row.state === null)
+    return { ok: false, reason: "unreadable" };
+  if ((row.state.inventory[item] ?? 0) <= 0)
+    return { ok: false, reason: "none-held" };
+  const nextState = applyToState({
+    ...row.state,
+    inventory: { ...row.state.inventory, [item]: (row.state.inventory[item] ?? 0) - 1 }
+  });
+  storage.run("UPDATE {{companion}} SET state = ?, updated_at = ? WHERE api_key_id = ?", [
+    serialiseState(nextState),
+    now,
+    apiKeyId
+  ]);
+  return { ok: true, row: { ...row, state: nextState } };
+}
+function purchase(storage, apiKeyId, entry, applyToState, now) {
+  const price = shopPrice(entry);
+  {
+    const row = readCompanion(storage, apiKeyId);
+    if (row === null)
+      return { ok: false, reason: "missing" };
+    if (row.state === null)
+      return { ok: false, reason: "unreadable" };
+    if (wallet(row) < price)
+      return { ok: false, reason: "insufficient" };
+    const nextState = applyToState(row.state);
+    storage.run("UPDATE {{companion}} SET state = ?, tokens_spent = tokens_spent + ?, updated_at = ? WHERE api_key_id = ?", [serialiseState(nextState), price, now, apiKeyId]);
+    return {
+      ok: true,
+      row: { ...row, state: nextState, tokensSpent: row.tokensSpent + price }
+    };
+  }
+}
+
+// src/server.ts
+var MAX_MULTIPLIER = 1000;
+function multiplierFrom(config) {
+  const raw = config.multiplier;
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0)
+    return 1;
+  return Math.min(raw, MAX_MULTIPLIER);
+}
+var dexSequence = 0;
+function dexId(apiKeyId, event, now) {
+  dexSequence += 1;
+  return `${apiKeyId}:${event.baseId}:${event.finalId}:${now}:${dexSequence}`;
+}
+var server_default = definePlugin({
+  migrations: MIGRATIONS,
+  setup(ctx) {
+    const storage = ctx.storage;
+    const events = ctx.events;
+    const net = ctx.net;
+    const files = ctx.files;
+    if (storage === undefined)
+      throw new Error("the companion needs the storage capability");
+    const multiplier = multiplierFrom(ctx.config);
+    const inFlight = new Map;
+    const prefetchOnce = (apiKeyId, state) => {
+      const existing = inFlight.get(apiKeyId);
+      if (existing !== undefined)
+        return existing;
+      const started = prefetchHatch(apiKeyId, state).finally(() => inFlight.delete(apiKeyId));
+      inFlight.set(apiKeyId, started);
+      return started;
+    };
+    const settleAndRecord = (apiKeyId) => {
+      const result = settle(storage, apiKeyId, ctx.now());
+      if (result === null)
+        return;
+      for (const event of result.events) {
+        if (event.kind !== "graduated")
+          continue;
+        recordGraduation(storage, apiKeyId, {
+          baseId: event.baseId,
+          finalId: event.finalId,
+          chainOrder: event.chainOrder,
+          rarity: event.rarity,
+          isShiny: event.isShiny,
+          nature: event.nature,
+          caughtAt: ctx.now()
+        }, dexId(apiKeyId, event, ctx.now()));
+        ctx.logger.info("companion graduated", { event: "companion.graduated", count: 1 });
+      }
+    };
+    const prefetchHatch = async (apiKeyId, state) => {
+      if (state.active !== null || state.pendingHatch !== null)
+        return;
+      if (net === undefined || files === undefined)
+        return;
+      const candidates = await speciesIndex({ net, files });
+      if (candidates.length === 0)
+        return;
+      const collected = new Set(readDex(storage, apiKeyId).map((entry) => entry.finalId));
+      const rolled = roll({
+        candidates,
+        seed: hashSeed(`${apiKeyId}:${state.consumedTotal}`),
+        guarantee: state.eggTier,
+        hasShinyCharm: hasShinyCharm(state),
+        collectedFinals: collected
+      });
+      if (rolled === null)
+        return;
+      const detail = await speciesDetail({ net, files }, rolled.speciesId);
+      if (detail === null)
+        return;
+      const path = detail.chain;
+      const rarity = rarityFromCaptureRate(detail.captureRate, detail.isLegendary, detail.isMythical);
+      const current = readCompanion(storage, apiKeyId);
+      if (current?.state == null || current.state.pendingHatch !== null)
+        return;
+      storage.run("UPDATE {{companion}} SET state = ?, updated_at = ? WHERE api_key_id = ?", [
+        JSON.stringify({
+          ...current.state,
+          pendingHatch: {
+            speciesId: rolled.speciesId,
+            path,
+            rarity,
+            isShiny: rolled.isShiny,
+            nature: rolled.nature,
+            ditto: rolled.ditto
+          }
+        }),
+        ctx.now(),
+        apiKeyId
+      ]);
+    };
+    if (events?.onRequestCompleted !== undefined) {
+      events.onRequestCompleted((event) => {
+        const tokens = event.tokens.input + event.tokens.output + event.tokens.cacheRead + event.tokens.cacheWrite;
+        creditTokens(storage, event.apiKeyId, Math.round(tokens * multiplier), ctx.now());
+        settleAndRecord(event.apiKeyId);
+      });
+    }
+    if (events?.onLimitReached !== undefined) {
+      events.onLimitReached((event) => {
+        const key = windowKey(event);
+        const row = readCompanion(storage, event.apiKeyId);
+        if (row?.state == null)
+          return;
+        const decision = decideGrant({
+          window: event.window,
+          lastGrantedAt: lastGrantedAt(storage, event.apiKeyId, key),
+          now: ctx.now()
+        });
+        if (!decision.grant) {
+          if (decision.seedAt !== undefined) {
+            setGrantedAt(storage, event.apiKeyId, key, decision.seedAt);
+          }
+          return;
+        }
+        setGrantedAt(storage, event.apiKeyId, key, decision.at);
+        storage.run("UPDATE {{companion}} SET state = ?, updated_at = ? WHERE api_key_id = ?", [
+          JSON.stringify({
+            ...row.state,
+            inventory: {
+              ...row.state.inventory,
+              rareCandy: row.state.inventory.rareCandy + decision.count
+            }
+          }),
+          ctx.now(),
+          event.apiKeyId
+        ]);
+        ctx.logger.info("companion candy granted", {
+          event: "companion.candy",
+          count: decision.count
+        });
+      });
+    }
+    const routes = [
+      {
+        method: "GET",
+        path: "/keys/:id",
+        handler: (request) => {
+          const apiKeyId = request.params.id ?? "";
+          settleAndRecord(apiKeyId);
+          const row = readCompanion(storage, apiKeyId);
+          if (row === null)
+            return { status: 404, json: { error: "no companion for that key" } };
+          if (row.state !== null)
+            prefetchOnce(apiKeyId, row.state).catch(() => {});
+          const active = row.state?.active ?? null;
+          return {
+            json: {
+              state: row.state,
+              tokensTotal: row.tokensTotal,
+              wallet: wallet(row),
+              lastCreditAt: row.lastCreditAt,
+              dex: readDex(storage, apiKeyId),
+              shop: shopCatalogue(),
+              nextThreshold: active === null ? EGG_HATCH_THRESHOLD : phaseThreshold(active.rarity, active.plannedPath.length, active.stageIndex),
+              progress: active === null ? row.state?.eggUsage ?? 0 : active.usedAtStage
+            }
+          };
+        }
+      },
+      {
+        method: "GET",
+        path: "/sprite/:species",
+        handler: async (request) => {
+          const raw = request.params.species ?? "";
+          const speciesId = Number.parseInt(raw, 10);
+          if (!Number.isInteger(speciesId))
+            return { status: 400, json: { error: "bad species" } };
+          if (net === undefined || files === undefined) {
+            return { status: 503, json: { error: "sprites need the net and files capabilities" } };
+          }
+          const shiny = request.query.shiny === "1";
+          const bytes = await spriteBytes({ net, files }, speciesId, shiny);
+          if (bytes === null)
+            return { status: 404, json: { error: "no sprite" } };
+          return {
+            bytes,
+            contentType: "image/gif",
+            cacheControl: "public, max-age=31536000, immutable"
+          };
+        }
+      },
+      {
+        method: "POST",
+        path: "/keys/:id/use",
+        handler: (request) => {
+          const apiKeyId = request.params.id ?? "";
+          const item = parseHeldItem(request.body);
+          if (item === null)
+            return { status: 400, json: { error: "unknown item" } };
+          const result = consume(storage, apiKeyId, item, (state) => useItem(state, item), ctx.now());
+          if (!result.ok)
+            return { status: 409, json: { error: result.reason } };
+          settleAndRecord(apiKeyId);
+          return { json: { ok: true } };
+        }
+      },
+      {
+        method: "POST",
+        path: "/keys/:id/purchase",
+        handler: (request) => {
+          const apiKeyId = request.params.id ?? "";
+          const entry = parseShopEntry(request.body);
+          if (entry === null)
+            return { status: 400, json: { error: "unknown shop entry" } };
+          const result = purchase(storage, apiKeyId, entry, (state) => applyPurchase(state, entry), ctx.now());
+          if (!result.ok)
+            return { status: 409, json: { error: result.reason } };
+          return { json: { ok: true, wallet: wallet(result.row) } };
+        }
+      }
+    ];
+    return { routes };
+  }
+});
+function hashSeed(input) {
+  let hash = 2166136261;
+  for (let i = 0;i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function shopCatalogue() {
+  return [
+    ...ITEM_KINDS.map((item) => ({
+      entry: { kind: "item", item },
+      price: ITEM_PRICES[item]
+    })),
+    { entry: { kind: "egg", tier: null }, price: freshEggPrice(null) },
+    {
+      entry: { kind: "egg", tier: "uncommon" },
+      price: freshEggPrice("uncommon")
+    },
+    { entry: { kind: "egg", tier: "rare" }, price: freshEggPrice("rare") }
+  ];
+}
+function parseShopEntry(body) {
+  if (typeof body !== "object" || body === null)
+    return null;
+  const record = body;
+  if (record.kind === "item") {
+    const item = record.item;
+    return ITEM_KINDS.includes(item) ? { kind: "item", item } : null;
+  }
+  if (record.kind === "egg") {
+    const tier = record.tier;
+    if (tier === null || tier === undefined)
+      return { kind: "egg", tier: null };
+    if (tier === "uncommon" || tier === "rare")
+      return { kind: "egg", tier };
+    return null;
+  }
+  return null;
+}
+function applyPurchase(state, entry) {
+  if (entry.kind === "egg") {
+    return { ...state, active: null, eggUsage: 0, eggTier: entry.tier, pendingHatch: null };
+  }
+  return {
+    ...state,
+    inventory: { ...state.inventory, [entry.item]: (state.inventory[entry.item] ?? 0) + 1 }
+  };
+}
+function parseHeldItem(body) {
+  if (typeof body !== "object" || body === null)
+    return null;
+  const item = body.item;
+  return item === "rareCandy" || item === "mint" ? item : null;
+}
+function useItem(state, item) {
+  if (item === "mint") {
+    if (state.active === null)
+      return state;
+    const index = NATURES.indexOf(state.active.nature);
+    const nature = NATURES[(index + 1) % NATURES.length];
+    return { ...state, active: { ...state.active, nature } };
+  }
+  return state.active === null ? { ...state, eggUsage: state.eggUsage + RARE_CANDY_XP } : {
+    ...state,
+    active: { ...state.active, usedAtStage: state.active.usedAtStage + RARE_CANDY_XP }
+  };
+}
+export {
+  server_default as default
+};

package/ui/index.js

@@ -0,0 +1,68 @@
+function w(t){return t}import{useMutation as _,useQuery as K,useQueryClient as G}from"@tanstack/react-query";import{useState as f}from"react";import s from"styled-components";import{jsx as n,jsxs as r,Fragment as P}from"react/jsx-runtime";var c=s.section`
+  background: var(--panel);
+  border: 1px solid var(--rule);
+  border-radius: 6px;
+  padding: 16px;
+  color: var(--ink);
+`,b=s.div`
+  display: flex;
+  gap: 16px;
+  align-items: center;
+  flex-wrap: wrap;
+`,H=s.img`
+  width: 96px;
+  height: 96px;
+  image-rendering: pixelated;
+  background: var(--panel-sunk);
+  border-radius: 4px;
+`,C=s.div`
+  background: var(--panel-sunk);
+  border-radius: 3px;
+  height: 8px;
+  overflow: hidden;
+  min-width: 200px;
+`,N=s.div`
+  background: var(--accent);
+  height: 100%;
+  width: ${(t)=>Math.min(100,Math.max(0,t.$pct))}%;
+`,a=s.span`
+  color: var(--ink-dim);
+`,J=s.div`
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(72px, 1fr));
+  gap: 8px;
+  margin-top: 12px;
+`,x=s.button`
+  background: var(--panel-raised);
+  border: 1px solid var(--rule);
+  border-radius: 4px;
+  color: var(--ink);
+  padding: 6px 10px;
+  cursor: pointer;
+  &:disabled {
+    color: var(--ink-faint);
+    cursor: not-allowed;
+  }
+`,U=s.p`
+  color: var(--warn);
+`,Q=s.figure`
+  margin: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 2px;
+`,j=s.figcaption`
+  color: var(--ink-dim);
+  font-size: 11px;
+  text-align: center;
+`,W=s.div`
+  display: flex;
+  align-items: center;
+  gap: 8px;
+`,z=s.div`
+  width: 96px;
+  height: 96px;
+  border-radius: 50% 50% 45% 45%;
+  background: var(--panel-raised);
+  border: 2px solid var(--rule-strong);
+`;function B(t,l,d){return`/api/plugins/${t}/sprite/${l}${d?"?shiny=1":""}`}function p(t){if(t>=1e9)return`${(t/1e9).toFixed(2)}B`;if(t>=1e6)return`${(t/1e6).toFixed(1)}M`;return t.toLocaleString()}function S(t){return t.replace(/([A-Z])/g," $1").toLowerCase()}function M(t){if(t.kind==="item")return S(t.item);return t.tier===null?"fresh egg":`fresh egg (${t.tier}+)`}var Y=["rareCandy","mint"],Z=[null,"common","uncommon","rare","legendary"],L=60000,O=60*L;function X(t,l,d){if(!t)return"egg";if(l===null)return"sleep";let g=d-l;if(g<5*L)return"working";if(g<O)return"idle";if(g<8*O)return"tired";return"sleep"}function ee({pluginId:t,api:l}){let[d,g]=f(""),[u,V]=f(""),[m,F]=f(null),A=G(),k=K({queryKey:["companion",u],queryFn:()=>l.get(`keys/${u}`),enabled:u!==""}),[T,h]=f(null),E=_({mutationFn:(e)=>l.post(`keys/${u}/purchase`,e),onMutate:()=>h(null),onError:(e)=>h(e instanceof Error?e.message:"the purchase was refused"),onSuccess:()=>A.invalidateQueries({queryKey:["companion",u]})}),v=_({mutationFn:(e)=>l.post(`keys/${u}/use`,{item:e}),onMutate:()=>h(null),onError:(e)=>h(e instanceof Error?e.message:"the item could not be used"),onSuccess:()=>A.invalidateQueries({queryKey:["companion",u]})});if(u==="")return r(c,{children:[n("h2",{children:"Companion"}),n("p",{children:n(a,{children:"Each API key raises its own Pokémon. Enter a key id to see it."})}),r("form",{onSubmit:(e)=>{e.preventDefault(),V(d.trim())},children:[n("input",{"aria-label":"API key id",onChange:(e)=>g(e.target.value),placeholder:"key id",value:d}),n(x,{type:"submit",children:"Show"})]})]});if(k.isPending)return n(c,{children:"Loading…"});if(k.isError)return n(c,{children:"No companion for that key yet."});let i=k.data;if(i.state===null)return r(c,{children:[n("h2",{children:"Companion"}),n(U,{children:"This key's save could not be read. It has been left untouched rather than replaced — nothing has been lost, but it needs looking at."})]});let{active:o}=i.state,y=o===null?null:o.plannedPath[o.stageIndex],R=X(o!==null,i.lastCreditAt,Date.now()),D=Object.entries(i.state.inventory).filter(([,e])=>e>0),I=m===null?i.dex:i.dex.filter((e)=>e.rarity===m);return r(c,{children:[n("h2",{children:"Companion"}),r(b,{children:[y===void 0||y===null?n(z,{"aria-label":"An egg, not yet hatched",role:"img"}):n(H,{alt:`Species ${y}${o?.isShiny===!0?", shiny":""}`,src:B(t,y,o?.isShiny===!0)}),r("div",{children:[o===null?r(P,{children:[r("div",{children:["Egg",i.state.eggTier===null?"":` (${i.state.eggTier}+ guaranteed)`]}),r(a,{children:[p(i.progress)," / ",p(i.nextThreshold)," tokens incubated"]}),n(C,{"aria-label":"Incubation",children:n(N,{$pct:i.progress/Math.max(1,i.nextThreshold)*100})})]}):r(P,{children:[r("div",{children:["Stage ",o.stageIndex+1," of ",o.plannedPath.length," · ",o.rarity,o.isShiny?" · shiny":"",o.dittoDisguise===null?"":" · ?"]}),n(a,{children:o.nature}),n(C,{"aria-label":"Growth to the next evolution",children:n(N,{$pct:i.progress/Math.max(1,i.nextThreshold)*100})}),r(a,{children:[p(i.progress)," / ",p(i.nextThreshold)," to the next stage"]})]}),n("div",{"aria-label":`Activity: ${R}`,role:"status",children:R})]})]}),n("p",{children:r(a,{children:[p(i.tokensTotal)," tokens earned · ",p(i.wallet)," to spend"]})}),n("h3",{children:"Shop"}),n(b,{children:i.shop.map((e)=>r(x,{disabled:i.wallet<e.price||E.isPending,onClick:()=>E.mutate(e.entry),type:"button",children:[M(e.entry)," · ",p(e.price)]},`${e.entry.kind}:${M(e.entry)}`))}),n("h3",{children:"Bag"}),D.length===0?n(a,{children:"Nothing in the bag."}):n(b,{children:D.map(([e,q])=>r(W,{children:[r("span",{children:[S(e)," · ",q]}),Y.includes(e)?r(x,{disabled:v.isPending,onClick:()=>v.mutate(e),type:"button",children:["Use ",S(e)]}):n(a,{children:"held"})]},e))}),T===null?null:n(U,{role:"alert",children:T}),n("h3",{children:"Pokédex"}),i.dex.length===0?n(a,{children:"Nothing graduated yet."}):r(P,{children:[n(b,{children:Z.map((e)=>n(x,{"aria-pressed":m===e,onClick:()=>F(e),type:"button",children:e??"all"},e??"all"))}),I.length===0?r(a,{children:["No ",m," graduates yet."]}):n(J,{children:I.map((e)=>r(Q,{children:[n("img",{alt:`${e.rarity}${e.isShiny?" shiny":""} species ${e.finalId}`,src:B(t,e.finalId,e.isShiny),style:{width:"64px",height:"64px",imageRendering:"pixelated"}}),e.nature===null?null:n(j,{children:e.nature})]},e.id))})]})]})}var ke=w({mount:ee});export{X as activityOf,ke as default};