npm - frogoe - Versions diffs - 0.1.0 - Mend

frogoe 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

package/bin/frogoe.mjs +11 -0
package/dist/cli.js +3124 -0
package/dist/contract/contract.js +236 -0
package/dist/registry/blocks/coin-counter/coin-counter.html +101 -0
package/dist/registry/blocks/coin-counter/registry-item.json +27 -0
package/dist/registry/blocks/combo-counter/combo-counter.html +106 -0
package/dist/registry/blocks/combo-counter/registry-item.json +27 -0
package/dist/registry/blocks/fuel-gauge/fuel-gauge.html +130 -0
package/dist/registry/blocks/fuel-gauge/registry-item.json +29 -0
package/dist/registry/blocks/game-over-card/game-over-card.html +185 -0
package/dist/registry/blocks/game-over-card/registry-item.json +30 -0
package/dist/registry/blocks/hearts-row/hearts-row.html +92 -0
package/dist/registry/blocks/hearts-row/registry-item.json +27 -0
package/dist/registry/blocks/mini-board/mini-board.html +125 -0
package/dist/registry/blocks/mini-board/registry-item.json +28 -0
package/dist/registry/blocks/objective-chip/objective-chip.html +101 -0
package/dist/registry/blocks/objective-chip/registry-item.json +29 -0
package/dist/registry/blocks/ready-gate/ready-gate.html +124 -0
package/dist/registry/blocks/ready-gate/registry-item.json +28 -0
package/dist/registry/blocks/ready-hint/ready-hint.html +104 -0
package/dist/registry/blocks/ready-hint/registry-item.json +29 -0
package/dist/registry/blocks/score-card/registry-item.json +27 -0
package/dist/registry/blocks/score-card/score-card.html +92 -0
package/dist/registry/blocks/timer-ring/registry-item.json +28 -0
package/dist/registry/blocks/timer-ring/timer-ring.html +123 -0
package/dist/registry/registry.json +51 -0
package/dist/registry/schema/registry-item.schema.json +36 -0
package/dist/registry/schema/registry.schema.json +22 -0
package/dist/runtimeVersion.js +10 -0
package/dist/templates/_shared/AGENTS.md +105 -0
package/dist/templates/_shared/CLAUDE.md +105 -0
package/package.json +42 -0

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,3124 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+// src/templates.ts
+var CONTRACT_VERSION, contractHeader, briefTemplate, frogoeJsonTemplate, indexTemplate, gameTemplate, gitignoreTemplate;
+var init_templates = __esm({
+  "src/templates.ts"() {
+    "use strict";
+    CONTRACT_VERSION = "0.1.0";
+    contractHeader = (version) => [
+      `// frogoe contract v${version} (materialized by frogoe init \u2014 do not edit)`,
+      "// frogoe check verifies this marker against frogoe.json; upgrade with: frogoe init --force",
+      ""
+    ].join("\n");
+    briefTemplate = `---
+title: My Game
+verb: tap        # tap | hold | steer | aim \u2014 ONE word, the core action
+mood: TODO \u2014 one phrase: "dawn uplift", "arcade cabinet at midnight"...
+palette:
+  bg: "#101418"  # TODO
+  fg: "#fffdf7"  # TODO
+  accent: "#ffd166" # TODO
+fonts:            # optional display voice; omit for a quiet system stack
+---
+TODO \u2014 two lines: what the player does, and what ends the run.
+`;
+    frogoeJsonTemplate = (version) => `${JSON.stringify({ contract: version }, null, 2)}
+`;
+    indexTemplate = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+  <title>My Game</title>
+  <style>
+    html, body { margin: 0; height: 100%; overflow: hidden; touch-action: none;
+      background: var(--game-bg, #101418);
+      /* phones are the primary device: no long-press selection, no callout */
+      -webkit-user-select: none; user-select: none; -webkit-touch-callout: none; }
+    #c { display: block; width: 100vw; height: 100vh; }
+    /* HUD layer + safe-area-aware placement (frogoe-core \u2192 hud-bindings) */
+    .hud { position: absolute; inset: 0; pointer-events: none; }
+    .hud > * { position: absolute; }
+    .hud [data-pos="top-left"]      { top: calc(env(safe-area-inset-top) + 12px); left: calc(env(safe-area-inset-left) + 12px); }
+    .hud [data-pos="top-center"]    { top: calc(env(safe-area-inset-top) + 12px); left: 50%; translate: -50% 0; }
+    .hud [data-pos="top-right"]     { top: calc(env(safe-area-inset-top) + 12px); right: calc(env(safe-area-inset-right) + 12px); }
+    .hud [data-pos="bottom-left"]   { bottom: calc(env(safe-area-inset-bottom) + 12px); left: calc(env(safe-area-inset-left) + 12px); }
+    .hud [data-pos="bottom-center"] { bottom: calc(env(safe-area-inset-bottom) + 12px); left: 50%; translate: -50% 0; }
+    /* theme every block from the BRIEF palette \u2014 one parent rule */
+    .hud {
+      --block-accent: #ffd166;
+      --block-fg: #fffdf7;
+      --block-outline: #0a0e18;
+    }
+  </style>
+  <script type="importmap">
+  {
+    "imports": {
+      "frogoe": "./.frogoe/contract.js"
+    }
+  }
+  </script>
+</head>
+<body>
+  <canvas id="c"></canvas>
+  <div class="hud">
+    <!-- registry blocks land here (frogoe add score-card) -->
+  </div>
+  <script type="module" src="game.js"></script>
+</body>
+</html>
+`;
+    gameTemplate = `/** My Game \u2014 the whole simulation in one closure. Replace everything
+ *  below with your game; the four nouns are the entire platform. */
+import { defineGame } from "frogoe";
+defineGame(({ stage, input, loop, finish }) => {
+  let t = 0;
+  let x = stage.play.center;
+  input.on("down", () => {
+    finish(0); // stub: replace with your real run end
+  });
+  loop.update = (dt) => {
+    t += dt;
+    x = stage.play.center + Math.sin(t * 2) * (stage.play.width * 0.3);
+  };
+  loop.render = (ctx) => {
+    ctx.clearRect(0, 0, stage.width, stage.height);
+    ctx.fillStyle = "#fffdf7";
+    ctx.beginPath();
+    ctx.arc(x, stage.height / 2, 14 + Math.sin(t * 3) * 3, 0, 7);
+    ctx.fill();
+  };
+});
+`;
+    gitignoreTemplate = `.frogoe/
+dist/
+snapshots/
+node_modules/
+`;
+  }
+});
+// src/init.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var here, CONTRACT_SOURCE, scaffold, registryRoot;
+var init_init = __esm({
+  "src/init.ts"() {
+    "use strict";
+    init_templates();
+    here = path.dirname(fileURLToPath(import.meta.url));
+    CONTRACT_SOURCE = existsSync(path.join(here, "../../contract/src/contract.js")) ? path.join(here, "../../contract/src/contract.js") : path.join(here, "../contract/contract.js");
+    scaffold = (name, options) => {
+      const root = options?.dir ?? process.cwd();
+      const target = path.resolve(root, name);
+      if (existsSync(target)) {
+        const occupied = existsSync(path.join(target, "frogoe.json"));
+        if (occupied && !options?.force) {
+          throw new Error(
+            `frogoe init: ${target} already has a frogoe game (frogoe.json present). Use --force to rematerialize .frogoe/ and scaffolds.`
+          );
+        }
+      }
+      mkdirSync(path.join(target, ".frogoe"), { recursive: true });
+      mkdirSync(path.join(target, "blocks"), { recursive: true });
+      const contract = contractHeader(CONTRACT_VERSION) + readFileSync(CONTRACT_SOURCE, "utf-8");
+      const sharedDir = path.join(here, "templates/_shared");
+      const agentDocs = existsSync(path.join(sharedDir, "CLAUDE.md")) ? readFileSync(path.join(sharedDir, "CLAUDE.md"), "utf-8") : "";
+      const agentsDocs = existsSync(path.join(sharedDir, "AGENTS.md")) ? readFileSync(path.join(sharedDir, "AGENTS.md"), "utf-8") : "";
+      const files = [
+        [".gitignore", gitignoreTemplate, true],
+        ...agentDocs ? [["CLAUDE.md", agentDocs, true]] : [],
+        ...agentsDocs ? [["AGENTS.md", agentsDocs, true]] : [],
+        ["BRIEF.md", briefTemplate, true],
+        ["frogoe.json", frogoeJsonTemplate(CONTRACT_VERSION), true],
+        ["index.html", indexTemplate, false],
+        ["game.js", gameTemplate, false],
+        [".frogoe/contract.js", contract, true],
+        ["blocks/.gitkeep", "", true]
+      ];
+      for (const [rel, body, overwrite] of files) {
+        const dest = path.join(target, rel);
+        if (!overwrite && existsSync(dest)) continue;
+        writeFileSync(dest, body, "utf-8");
+      }
+      return { dir: target, files: files.map(([rel]) => rel) };
+    };
+    registryRoot = () => {
+      const candidates = [
+        path.resolve(here, "../../../registry"),
+        // repo source mode
+        path.resolve(here, "../registry")
+        // dist mode (build:copy)
+      ];
+      for (const candidate of candidates) {
+        if (existsSync(path.join(candidate, "registry.json"))) {
+          return candidate;
+        }
+      }
+      throw new Error(
+        "frogoe: registry not found (expected ../registry or packaged copy). Run from the repo or install @frogoe/cli fully."
+      );
+    };
+  }
+});
+// src/add.ts
+import { cpSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import path2 from "path";
+var STYLE_PATTERN, MARKUP_PATTERN, parseBlock, blockMarker, injectIntoHtml, addBlock;
+var init_add = __esm({
+  "src/add.ts"() {
+    "use strict";
+    init_init();
+    STYLE_PATTERN = /<style>([\s\S]*?)<\/style>/u;
+    MARKUP_PATTERN = /<\/style>\s*([\s\S]*)$/u;
+    parseBlock = (source) => {
+      const styleMatch = STYLE_PATTERN.exec(source);
+      const markupMatch = MARKUP_PATTERN.exec(source);
+      return {
+        css: styleMatch?.[1]?.trim() ?? null,
+        markup: (markupMatch?.[1] ?? "").trim()
+      };
+    };
+    blockMarker = (name) => `<!-- frogoe:block:${name} -->`;
+    injectIntoHtml = (html, name, css, markup, placement) => {
+      if (!css && !markup) return null;
+      const marker = blockMarker(name);
+      let out = html;
+      const firstIdx = out.indexOf(marker);
+      if (firstIdx !== -1) {
+        const lastIdx = out.lastIndexOf(marker);
+        if (lastIdx > firstIdx) {
+          out = out.slice(0, firstIdx).trimEnd() + "\n      " + out.slice(lastIdx + marker.length);
+        }
+      }
+      if (css) {
+        const styleClose = out.lastIndexOf("</style>");
+        if (styleClose === -1) return null;
+        const cssBlock = `
+    /* ===== ${name} (frogoe add) ===== */
+    ${css}
+  `;
+        out = out.slice(0, styleClose) + cssBlock + out.slice(styleClose);
+      }
+      if (markup) {
+        const pos = placement === "overlay-fullscreen" ? "" : ' data-pos="top-left"';
+        const wrapped = `
+      ${marker}
+      <div${pos}>
+${markup.split("\n").map((l) => `        ${l}`).join("\n")}
+      </div>
+      ${marker}`;
+        const hudOpen = out.indexOf('class="hud"');
+        if (hudOpen === -1) return null;
+        const afterHudOpen = out.indexOf(">", hudOpen);
+        if (afterHudOpen === -1) return null;
+        let depth = 1;
+        let searchFrom = afterHudOpen + 1;
+        let hudEnd = -1;
+        while (searchFrom < out.length) {
+          const open = out.indexOf("<div", searchFrom);
+          const close = out.indexOf("</div>", searchFrom);
+          if (close === -1) break;
+          if (open !== -1 && open < close) {
+            depth++;
+            searchFrom = open + 4;
+          } else {
+            depth--;
+            if (depth === 0) {
+              hudEnd = close;
+              break;
+            }
+            searchFrom = close + 6;
+          }
+        }
+        if (hudEnd === -1) return null;
+        out = out.slice(0, hudEnd) + wrapped + out.slice(hudEnd);
+      }
+      return out;
+    };
+    addBlock = (name, options) => {
+      const root = options?.dir ?? process.cwd();
+      const registry = registryRoot();
+      const blockDir = path2.join(registry, "blocks", name);
+      if (!existsSync2(blockDir)) {
+        const available = readFileSync2(path2.join(registry, "registry.json"), "utf-8");
+        const known = JSON.parse(available).items.map((i) => i.name).join(", ");
+        throw new Error(`frogoe add: unknown block "${name}". Available: ${known}`);
+      }
+      const item = JSON.parse(
+        readFileSync2(path2.join(blockDir, "registry-item.json"), "utf-8")
+      );
+      const markupFiles = item.files.filter((f) => f.type === "frogoe:markup").map((f) => path2.join(blockDir, f.path));
+      if (markupFiles.length === 0) {
+        throw new Error(`frogoe add: block "${name}" has no markup file in its manifest.`);
+      }
+      const source = markupFiles.map((f) => readFileSync2(f, "utf-8")).join("\n");
+      for (const binding of item.bindings ?? []) {
+        if (!source.includes(binding)) {
+          throw new Error(
+            `frogoe add: block "${name}" is broken \u2014 manifest binding ${binding} missing from its markup. Report it; nothing was copied.`
+          );
+        }
+      }
+      mkdirSync2(path2.join(root, "blocks"), { recursive: true });
+      cpSync(markupFiles[0] ?? "", path2.join(root, "blocks", `${name}.html`));
+      let injected = false;
+      const placement = item.placement ?? "overlay";
+      if (!options?.noInject) {
+        const indexPath = path2.join(root, "index.html");
+        if (existsSync2(indexPath)) {
+          const html = readFileSync2(indexPath, "utf-8");
+          const { css, markup } = parseBlock(source);
+          const modified = injectIntoHtml(html, name, css, markup, placement);
+          if (modified) {
+            writeFileSync2(indexPath, modified, "utf-8");
+            injected = true;
+          }
+        }
+      }
+      return {
+        bindings: item.bindings ?? [],
+        block: name,
+        injected,
+        placement
+      };
+    };
+  }
+});
+// src/commands/add.ts
+var add_exports = {};
+__export(add_exports, {
+  command: () => command
+});
+import { defineCommand } from "citty";
+var command;
+var init_add2 = __esm({
+  "src/commands/add.ts"() {
+    "use strict";
+    init_add();
+    command = defineCommand({
+      args: {
+        block: { type: "positional", description: "registry block name (e.g. score-card)" }
+      },
+      async run({ args }) {
+        if (!args.block) {
+          throw new Error("frogoe add <block> \u2014 e.g. frogoe add fuel-gauge");
+        }
+        const result = addBlock(String(args.block));
+        console.log(`frogoe add \u2014 ${result.block}`);
+        if (result.injected) {
+          console.log(`  \u2713 styles + markup injected into index.html (idempotent \u2014 re-add replaces)`);
+          console.log(`  \u2713 source copied to blocks/${result.block}.html (for custom edits)`);
+        } else {
+          console.log(`  \u2713 source copied to blocks/${result.block}.html`);
+          console.log(`  \u26A0 could not inject into index.html \u2014 paste markup + styles manually`);
+        }
+        console.log(`  bindings: ${result.bindings.join(", ") || "(none)"}`);
+        console.log(`  drive it from game.js: document.querySelector('[data-block-...]')`);
+      },
+      meta: { description: "copy a registry HUD block into blocks/" }
+    });
+  }
+});
+// src/fetch-policy.ts
+var DEFAULT_FETCH_POLICY, FetchUnavailableError, FetchNotServedError, sleep, fetchWithPolicy;
+var init_fetch_policy = __esm({
+  "src/fetch-policy.ts"() {
+    "use strict";
+    DEFAULT_FETCH_POLICY = {
+      attemptTimeoutMs: 8e3,
+      baseDelayMs: 250,
+      maxAttempts: 2,
+      maxElapsedMs: 2e4
+    };
+    FetchUnavailableError = class extends Error {
+      constructor(url, cause) {
+        super(`frogoe bundle: fetch unavailable: ${url}`);
+        this.url = url;
+        this.cause = cause;
+        this.name = "FetchUnavailableError";
+      }
+      url;
+    };
+    FetchNotServedError = class extends Error {
+      constructor(url, status) {
+        super(`frogoe bundle: not served (${status}): ${url}`);
+        this.url = url;
+        this.status = status;
+        this.name = "FetchNotServedError";
+      }
+      url;
+      status;
+    };
+    sleep = (ms) => new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+    fetchWithPolicy = async (url, options) => {
+      const policy = { ...DEFAULT_FETCH_POLICY, ...options?.policy };
+      const doFetch = options?.fetchImpl ?? fetch;
+      const started = Date.now();
+      for (let attempt = 1; attempt <= policy.maxAttempts; attempt += 1) {
+        if (Date.now() - started > policy.maxElapsedMs) {
+          throw new FetchUnavailableError(url, new Error("wall-clock budget exceeded"));
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+          controller.abort();
+        }, policy.attemptTimeoutMs);
+        try {
+          const res = await doFetch(url, {
+            headers: options?.headers,
+            redirect: "follow",
+            signal: controller.signal
+          });
+          if (res.status >= 500) {
+            throw new FetchUnavailableError(url, new Error(`upstream ${res.status}`));
+          }
+          if (res.status >= 400) {
+            throw new FetchNotServedError(url, res.status);
+          }
+          return await res.text();
+        } catch (error) {
+          const retryable = error instanceof FetchUnavailableError || !(error instanceof FetchNotServedError);
+          if (!retryable || attempt === policy.maxAttempts) {
+            throw error;
+          }
+          await sleep(Math.random() * policy.baseDelayMs * 2 ** (attempt - 1));
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      throw new FetchUnavailableError(url, new Error("unreachable"));
+    };
+  }
+});
+// src/bundle.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import path3 from "path";
+var ALLOWED_HOSTS, PIN_EXEMPT_HOSTS, FONT_UA, MIME, sha256, dataUri, assertAllowedRemote, cdnPlugin, importMapPlugin, inlineFontCss, localDataUri, LEAK_PATTERN, bundle;
+var init_bundle = __esm({
+  "src/bundle.ts"() {
+    "use strict";
+    init_fetch_policy();
+    ALLOWED_HOSTS = /* @__PURE__ */ new Set([
+      "cdn.jsdelivr.net",
+      "esm.sh",
+      "fonts.googleapis.com",
+      "fonts.gstatic.com",
+      "unpkg.com"
+    ]);
+    PIN_EXEMPT_HOSTS = /* @__PURE__ */ new Set([
+      "fonts.googleapis.com",
+      "fonts.gstatic.com",
+      "fonts.googleapis.test",
+      "fonts.gstatic.test"
+    ]);
+    FONT_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0 Safari/537.36";
+    MIME = {
+      gif: "image/gif",
+      jpeg: "image/jpeg",
+      jpg: "image/jpeg",
+      mp3: "audio/mpeg",
+      ogg: "audio/ogg",
+      png: "image/png",
+      svg: "image/svg+xml",
+      wav: "audio/wav",
+      webp: "image/webp",
+      woff2: "font/woff2"
+    };
+    sha256 = (data) => createHash("sha256").update(data).digest("hex");
+    dataUri = (mime, body) => {
+      const base64 = Buffer.from(body, "binary").toString("base64");
+      return `data:${mime};base64,${base64}`;
+    };
+    assertAllowedRemote = (url, extraHosts) => {
+      const host = new URL(url).host;
+      if (!ALLOWED_HOSTS.has(host) && !(extraHosts ?? []).includes(host)) {
+        throw new Error(
+          `bundle/blocked-origin: ${host} is not on the allowlist (${[...ALLOWED_HOSTS].join(", ")}).`
+        );
+      }
+      if (!PIN_EXEMPT_HOSTS.has(host) && !/@v?\d+(\.\d+)+[^/]*\//u.test(url) && !/@\d+\.\d+\.\d+[^/]*$/u.test(url)) {
+        throw new Error(
+          `bundle/unpinned: ${url} \u2014 exact versions only (@latest and bare tags are forbidden; the pin is hashed).`
+        );
+      }
+    };
+    cdnPlugin = (options, assets) => ({
+      name: "frogoe-cdn",
+      setup(build) {
+        build.onResolve({ filter: /^https?:\/\// }, (args) => ({
+          namespace: "frogoe-cdn",
+          path: args.path
+        }));
+        build.onResolve({ filter: /.*/, namespace: "frogoe-cdn" }, (args) => ({
+          namespace: "frogoe-cdn",
+          path: new URL(args.path, args.importer).href
+        }));
+        build.onLoad({ filter: /.*/, namespace: "frogoe-cdn" }, async (args) => {
+          assertAllowedRemote(args.path, options.extraAllowedHosts);
+          const body = await fetchWithPolicy(args.path, {
+            fetchImpl: options.fetchImpl
+          });
+          assets.push({
+            bytes: body.length,
+            kind: "js",
+            sha256: sha256(body),
+            source: args.path
+          });
+          return {
+            contents: body,
+            loader: args.path.endsWith(".css") ? "css" : "js"
+          };
+        });
+      }
+    });
+    importMapPlugin = (dir, imports) => ({
+      name: "frogoe-importmap",
+      setup(build) {
+        const rules = new Map(Object.entries(imports));
+        if (!rules.has("frogoe")) {
+          rules.set("frogoe", "./.frogoe/contract.js");
+        }
+        for (const [name, target] of rules) {
+          const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          build.onResolve({ filter: new RegExp(`^${escaped}$`) }, () => {
+            if (/^https?:\/\//.test(target)) {
+              return { namespace: "frogoe-cdn", path: target };
+            }
+            return { path: path3.resolve(dir, target) };
+          });
+        }
+      }
+    });
+    inlineFontCss = async (cssUrl, options, assets) => {
+      const css = await fetchWithPolicy(cssUrl, {
+        fetchImpl: options.fetchImpl,
+        headers: { "user-agent": FONT_UA }
+      });
+      assets.push({
+        bytes: css.length,
+        kind: "css",
+        sha256: sha256(css),
+        source: cssUrl
+      });
+      const seen = /* @__PURE__ */ new Map();
+      const resolveFont = async (url) => {
+        const cached = seen.get(url);
+        if (cached) {
+          return cached;
+        }
+        assertAllowedRemote(url, options.extraAllowedHosts);
+        const res = options.fetchImpl ? await options.fetchImpl(url, { headers: { "user-agent": FONT_UA } }) : await fetch(url, { headers: { "user-agent": FONT_UA } });
+        const buffer = Buffer.from(await res.arrayBuffer());
+        const uri = `data:font/woff2;base64,${buffer.toString("base64")}`;
+        seen.set(url, uri);
+        assets.push({
+          bytes: buffer.length,
+          kind: "font",
+          sha256: sha256(buffer.toString("binary")),
+          source: url
+        });
+        return uri;
+      };
+      let out = css;
+      const urls = [...css.matchAll(/url\((https:\/\/[^)]+)\)/gu)].map((m) => m[1] ?? "");
+      for (const url of urls) {
+        if (url) {
+          out = out.replaceAll(url, await resolveFont(url));
+        }
+      }
+      return out;
+    };
+    localDataUri = (dir, href) => {
+      const file = path3.resolve(dir, href.replace(/^\.\//u, ""));
+      if (!existsSync3(file)) {
+        throw new Error(`bundle/missing-asset: ${href} not found in the game folder`);
+      }
+      const ext = path3.extname(file).slice(1).toLowerCase();
+      const mime = MIME[ext];
+      if (!mime) {
+        throw new Error(`bundle/unsupported-asset: .${ext} (${href})`);
+      }
+      return dataUri(mime, readFileSync3(file, "binary"));
+    };
+    LEAK_PATTERN = /(?:src|href)\s*=\s*"(https?:\/\/[^"]+)"/gi;
+    bundle = async (options) => {
+      const dir = path3.resolve(options.dir);
+      const indexPath = path3.join(dir, "index.html");
+      if (!existsSync3(indexPath)) {
+        throw new Error("frogoe bundle: no index.html \u2014 run from a game folder");
+      }
+      const html = readFileSync3(indexPath, "utf-8");
+      const assets = [];
+      const warnings = [];
+      let out = html;
+      const importMapMatch = /<script[^>]*type="importmap"[^>]*>([\s\S]*?)<\/script>/iu.exec(html);
+      const entryMatch = /<script[^>]*type="module"[^>]*src="([^"]+)"[^>]*><\/script>/iu.exec(html);
+      let imports = {};
+      if (importMapMatch?.[1]) {
+        try {
+          imports = JSON.parse(importMapMatch[1]).imports ?? {};
+        } catch {
+          throw new Error("frogoe bundle: import map in index.html is not valid JSON");
+        }
+      }
+      let bundled = "";
+      if (entryMatch?.[1]) {
+        const { build } = await import("esbuild");
+        const result = await build({
+          bundle: true,
+          entryPoints: [path3.resolve(dir, entryMatch[1])],
+          format: "esm",
+          logLevel: "silent",
+          plugins: [importMapPlugin(dir, imports), cdnPlugin(options, assets)],
+          target: "es2022",
+          write: false
+        });
+        bundled = result.outputFiles[0]?.text ?? "";
+        out = out.replace(entryMatch[0], `<script type="module">
+${bundled}
+</script>`);
+      }
+      if (importMapMatch) {
+        out = out.replace(importMapMatch[0], "");
+      }
+      for (const match of html.matchAll(/<link[^>]*href="([^"]+)"[^>]*>/giu)) {
+        const href = match[1] ?? "";
+        if (!/rel\s*=\s*"stylesheet"/iu.test(match[0])) {
+          continue;
+        }
+        let replacement;
+        if (href.startsWith("https://")) {
+          assertAllowedRemote(href, options.extraAllowedHosts);
+          const css = await inlineFontCss(href, options, assets);
+          replacement = `<style>
+${css}
+</style>`;
+        } else {
+          const css = readFileSync3(path3.resolve(dir, href), "utf-8");
+          replacement = `<style>
+${css}
+</style>`;
+        }
+        out = out.replace(match[0], replacement);
+      }
+      for (const match of out.matchAll(/(src|href)\s*=\s*"(\.{0,2}\/[^":]+)"/gu)) {
+        const href = match[2] ?? "";
+        if (href.startsWith("data:") || href.startsWith("#")) {
+          continue;
+        }
+        if (href.endsWith(".js") && entryMatch?.[1] === href) {
+          continue;
+        }
+        if (existsSync3(path3.resolve(dir, href))) {
+          out = out.replaceAll(href, localDataUri(dir, href));
+        }
+      }
+      const leaked = [...out.matchAll(LEAK_PATTERN)].map((m) => m[1] ?? "");
+      if (leaked.length > 0) {
+        throw new Error(
+          `bundle/leaked-remote: artifact still references ${[...new Set(leaked)].join(", ")} \u2014 nothing ships half-dissolved.`
+        );
+      }
+      const artifactHash = sha256(out);
+      const banner = `<!-- frogoe bundle | contract 0.1.0 | assets: ${assets.length} | sha256:${artifactHash} -->
+`;
+      const artifact = banner + out;
+      const bytes = Buffer.byteLength(artifact, "utf-8");
+      if (bytes > 3e6) {
+        warnings.push(
+          `bundle/size: ${Math.round(bytes / 1e5) / 10} MB \u2014 feed caching stays sane, but check whether every asset earns its bytes`
+        );
+      }
+      return {
+        artifact,
+        assets,
+        bytes,
+        sha256: sha256(artifact),
+        warnings
+      };
+    };
+  }
+});
+// src/commands/bundle.ts
+var bundle_exports = {};
+__export(bundle_exports, {
+  command: () => command2
+});
+import { defineCommand as defineCommand2 } from "citty";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import path4 from "path";
+var command2;
+var init_bundle2 = __esm({
+  "src/commands/bundle.ts"() {
+    "use strict";
+    init_bundle();
+    command2 = defineCommand2({
+      args: {
+        dir: { type: "positional", required: false, description: "game folder (default: cwd)" },
+        json: { type: "boolean", description: "machine-readable report" },
+        out: { type: "string", description: "output path (default: dist/index.html)" }
+      },
+      async run({ args }) {
+        const dir = args.dir ? String(args.dir) : process.cwd();
+        const report = await bundle({ dir });
+        const outPath = args.out ? path4.resolve(String(args.out)) : path4.join(dir, "dist", "index.html");
+        mkdirSync3(path4.dirname(outPath), { recursive: true });
+        writeFileSync3(outPath, report.artifact, "utf-8");
+        for (const warning of report.warnings) {
+          console.log(`  \u26A0 ${warning}`);
+        }
+        if (args.json) {
+          console.log(
+            JSON.stringify(
+              {
+                artifact: outPath,
+                assets: report.assets,
+                bytes: report.bytes,
+                sha256: report.sha256,
+                warnings: report.warnings
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          console.log(`  frogoe bundle \u2192 ${outPath}`);
+          console.log(
+            `  ${report.bytes} bytes \xB7 ${report.assets.length} dissolved asset(s) \xB7 sha256 ${report.sha256.slice(0, 12)}`
+          );
+          for (const asset of report.assets) {
+            console.log(`    ${asset.kind.padEnd(5)} ${asset.source}`);
+          }
+        }
+      },
+      meta: { description: "dissolve externals into one self-contained HTML" }
+    });
+  }
+});
+// ../lint/src/brief.ts
+var stripComment, parseBrief;
+var init_brief = __esm({
+  "../lint/src/brief.ts"() {
+    "use strict";
+    stripComment = (value) => value.replace(/\s+#.*$/u, "").trim().replace(/^["']|["']$/gu, "");
+    parseBrief = (source) => {
+      const match = /^---\r?\n([\s\S]*?)\r?\n---/u.exec(source);
+      if (!match) {
+        return null;
+      }
+      const brief = {};
+      let section = "";
+      for (const rawLine of match[1]?.split("\n") ?? []) {
+        if (rawLine.trim() === "") {
+          continue;
+        }
+        const nested = /^\s{2,}([a-z-]+):\s*(.*)$/u.exec(rawLine);
+        const top = /^([a-z-]+):\s*(.*)$/u.exec(rawLine);
+        if (nested && section === "palette") {
+          const key = nested[1];
+          brief[key] = stripComment(nested[2] ?? "");
+          continue;
+        }
+        if (top) {
+          section = top[1] ?? "";
+          if (section === "palette") {
+            continue;
+          }
+          const key = section;
+          brief[key] = stripComment(top[2] ?? "");
+        }
+      }
+      return brief;
+    };
+  }
+});
+// ../lint/src/contrast.ts
+var HEX, isHex, contrastRatio;
+var init_contrast = __esm({
+  "../lint/src/contrast.ts"() {
+    "use strict";
+    HEX = /^#[0-9a-fA-F]{3,8}$/u;
+    isHex = (value) => HEX.test(value);
+    contrastRatio = (a, b) => {
+      const lum = (hex) => {
+        const full = hex.length === 4 ? `#${hex.slice(1).replace(/(.)/gu, "$1$1")}` : hex;
+        const n = Number.parseInt(full.slice(1), 16);
+        const rgb = [16, 8, 0].map((shift) => (n >> shift & 255) / 255);
+        const lin = rgb.map((c) => c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
+        return 0.2126 * (lin[0] ?? 0) + 0.7152 * (lin[1] ?? 0) + 0.0722 * (lin[2] ?? 0);
+      };
+      try {
+        const [l1, l2] = [lum(a), lum(b)].sort((x, y) => y - x);
+        return (l1 + 0.05) / (l2 + 0.05);
+      } catch {
+        return 21;
+      }
+    };
+  }
+});
+// ../lint/src/check.ts
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4 } from "fs";
+import path5 from "path";
+var VERBS, read, linesOf, findLine, checkBrief, checkFolder, checkPin, checkProject;
+var init_check = __esm({
+  "../lint/src/check.ts"() {
+    "use strict";
+    init_brief();
+    init_contrast();
+    VERBS = /* @__PURE__ */ new Set(["tap", "hold", "steer", "aim"]);
+    read = (file) => {
+      try {
+        return readFileSync4(file, "utf-8");
+      } catch {
+        return "";
+      }
+    };
+    linesOf = (source) => source.split("\n");
+    findLine = (source, pattern) => {
+      const idx = linesOf(source).findIndex((line) => pattern.test(line));
+      return idx === -1 ? void 0 : idx + 1;
+    };
+    checkBrief = (dir, findings) => {
+      const file = path5.join(dir, "BRIEF.md");
+      if (!existsSync4(file)) {
+        findings.push({
+          code: "brief/missing",
+          file: "BRIEF.md",
+          fix: "frogoe init writes a stub BRIEF.md \u2014 or copy the schema from frogoe-core \u2192 brief-format",
+          message: "feed games declare intent before code",
+          severity: "error"
+        });
+        return;
+      }
+      const source = read(file);
+      const todoLine = findLine(source, /TODO/u);
+      if (todoLine !== void 0) {
+        findings.push({
+          code: "brief/todo",
+          file: "BRIEF.md",
+          fix: "fill every TODO \u2014 the brief is the gate's measuring stick",
+          line: todoLine,
+          message: "BRIEF.md still has TODO markers",
+          severity: "error"
+        });
+      }
+      const brief = parseBrief(source);
+      if (!brief) {
+        findings.push({
+          code: "brief/frontmatter",
+          file: "BRIEF.md",
+          fix: "start the file with a --- frontmatter block (frogoe-core \u2192 brief-format)",
+          message: "no frontmatter block found",
+          severity: "error"
+        });
+        return;
+      }
+      const problems = [];
+      if (!brief.title || brief.title.length < 2 || brief.title.length > 40) {
+        problems.push("title (2\u201340 chars)");
+      }
+      if (!brief.verb || !VERBS.has(brief.verb)) {
+        problems.push("verb \u2208 tap|hold|steer|aim");
+      }
+      if (!brief.mood) {
+        problems.push("mood (one phrase)");
+      }
+      for (const key of ["bg", "fg", "accent"]) {
+        if (!brief[key] || !isHex(brief[key] ?? "")) {
+          problems.push(`palette.${key} (hex)`);
+        }
+      }
+      if (problems.length > 0) {
+        findings.push({
+          code: "brief/frontmatter",
+          file: "BRIEF.md",
+          fix: `missing/invalid: ${problems.join(", ")} \u2014 frogoe-core \u2192 brief-format`,
+          message: "frontmatter is incomplete",
+          severity: "error"
+        });
+      }
+      const outline = typeof brief.outline === "string" ? brief.outline : brief.bg ?? "";
+      if (brief.fg && isHex(brief.fg) && isHex(outline) && outline !== brief.bg) {
+        const ratio = contrastRatio(brief.fg, outline);
+        if (ratio < 3) {
+          findings.push({
+            code: "brief/contrast",
+            file: "BRIEF.md",
+            fix: `fg/outline contrast is ${ratio.toFixed(2)}:1 \u2014 HUD floor is 3:1; the outline is the readability partner in games (not bg); brighten fg or darken outline`,
+            message: "declared palette fails the HUD readability floor",
+            severity: "error"
+          });
+        }
+      } else if (brief.bg && brief.fg && isHex(brief.bg) && isHex(brief.fg)) {
+        const ratio = contrastRatio(brief.fg, brief.bg);
+        if (ratio < 3) {
+          findings.push({
+            code: "brief/contrast",
+            file: "BRIEF.md",
+            fix: `declared fg/bg contrast is ${ratio.toFixed(2)}:1 \u2014 HUD floor is 3:1; games should declare palette.outline (the readability partner) in BRIEF.md`,
+            message: "declared palette fails the HUD readability floor",
+            severity: "error"
+          });
+        }
+      }
+    };
+    checkFolder = (dir, findings) => {
+      const index = read(path5.join(dir, "index.html"));
+      if (!index) {
+        findings.push({
+          code: "folder/index-missing",
+          file: "index.html",
+          fix: "the entry shell: canvas + import map + hud layer (frogoe init writes one)",
+          message: "no index.html",
+          severity: "error"
+        });
+        return;
+      }
+      if (!/<canvas[^>]+id="c"/iu.test(index)) {
+        findings.push({
+          code: "folder/canvas",
+          file: "index.html",
+          fix: 'add <canvas id="c"></canvas> \u2014 the contract boots on that exact element',
+          message: 'missing <canvas id="c">',
+          severity: "error"
+        });
+      }
+      if (!/viewport-fit=cover/u.test(index)) {
+        findings.push({
+          code: "folder/viewport-fit",
+          file: "index.html",
+          fix: "viewport meta must include viewport-fit=cover or safe-area insets read as zero",
+          message: "viewport-fit=cover missing",
+          severity: "error"
+        });
+      }
+      if (!/(?:-webkit-)?user-select:\s*none/u.test(index)) {
+        findings.push({
+          code: "folder/touch-select",
+          file: "index.html",
+          fix: "phones are the primary device \u2014 add `-webkit-user-select: none; user-select: none; -webkit-touch-callout: none;` on html/body or a long-press summons the text-selection UI mid-game on iOS and Android alike (frogoe-core \u2192 references/audio.md)",
+          message: "long-press can summon the phone selection UI",
+          severity: "error"
+        });
+      }
+      const mapMatch = /<script[^>]*type="importmap"[^>]*>([\s\S]*?)<\/script>/u.exec(index);
+      const mapping = mapMatch?.[1];
+      if (!mapping) {
+        findings.push({
+          code: "folder/importmap",
+          file: "index.html",
+          fix: 'add <script type="importmap"> with {"imports":{"frogoe":"./.frogoe/contract.js"}}',
+          message: "no import map",
+          severity: "error"
+        });
+      } else {
+        try {
+          const parsed = JSON.parse(mapping);
+          if (parsed.imports?.frogoe !== "./.frogoe/contract.js") {
+            findings.push({
+              code: "folder/importmap",
+              file: "index.html",
+              fix: 'imports.frogoe must be exactly "./.frogoe/contract.js" \u2014 the pinned contract',
+              message: `frogoe maps to ${parsed.imports?.frogoe ?? "(absent)"}`,
+              severity: "error"
+            });
+          }
+        } catch {
+          findings.push({
+            code: "folder/importmap",
+            file: "index.html",
+            fix: "import map is not valid JSON",
+            message: "import map fails to parse",
+            severity: "error"
+          });
+        }
+      }
+      const game = read(path5.join(dir, "game.js"));
+      if (!game) {
+        findings.push({
+          code: "folder/game-missing",
+          file: "game.js",
+          fix: "the whole simulation: defineGame(({stage,input,loop,finish}) => {...})",
+          message: "no game.js",
+          severity: "error"
+        });
+        return;
+      }
+      if (!/loop\.update\s*=/u.test(game)) {
+        findings.push({
+          code: "game/loop-update",
+          file: "game.js",
+          fix: "fill loop.update = (dt) => {...} inside the closure",
+          message: "loop.update is never assigned",
+          severity: "warning"
+        });
+      }
+      if (!/loop\.render\s*=/u.test(game)) {
+        findings.push({
+          code: "game/loop-render",
+          file: "game.js",
+          fix: "fill loop.render = (ctx) => {...} inside the closure",
+          message: "loop.render is never assigned",
+          severity: "warning"
+        });
+      }
+      const gameLine = (pattern) => findLine(game, pattern);
+      const dragLine = gameLine(/\+=\s*(?:p|pt|pointer)\.(?:dx|dy)\b/u);
+      if (dragLine !== void 0) {
+        findings.push({
+          code: "input/incremental-drag",
+          file: "game.js",
+          fix: "pointer.dx is anchor-relative \u2014 assign absolutely (x = grabX + p.dx) or track your own lastX",
+          line: dragLine,
+          message: "re-adding anchor-relative dx per event rockets the actor into a wall",
+          recipe: "frogoe-core \u2192 contract (drag semantics)",
+          severity: "error"
+        });
+      }
+      const absLine = gameLine(/[=]\s*(?:pointer|p|touch)\.x\b(?!.*(?:dx|anchor|base|last))/u);
+      if (absLine !== void 0) {
+        findings.push({
+          code: "input/absolute-steering",
+          file: "game.js",
+          fix: "steer from relative deltas (p.dx) or your own anchor \u2014 absolute x thumb-ghosts",
+          line: absLine,
+          message: "steering appears to follow absolute pointer x",
+          recipe: "frogoe-core \u2192 contract (drag semantics)",
+          severity: "warning"
+        });
+      }
+      const spawnLine = gameLine(/Math\.random\(\)\s*\*\s*(?:W\b|innerWidth|window\.innerWidth)/u);
+      if (spawnLine !== void 0) {
+        findings.push({
+          code: "layout/innerwidth-spawn",
+          file: "game.js",
+          fix: "spawn inside stage.play (capped centered column) for identical challenge on every screen",
+          line: spawnLine,
+          message: "spawn uses raw innerWidth",
+          recipe: "frogoe-core \u2192 contract",
+          severity: "warning"
+        });
+      }
+      const suspendedLine = gameLine(/\.state\s*(?:===|==)\s*["']suspended["']/u);
+      if (suspendedLine !== void 0 && /AudioContext/u.test(game)) {
+        findings.push({
+          code: "audio/suspended-only",
+          file: "game.js",
+          fix: 'resume when state !== "running" \u2014 iOS reports a non-standard "interrupted" state (lock, call, tab switch) that === "suspended" silently misses (frogoe-core \u2192 references/audio.md)',
+          line: suspendedLine,
+          message: "audio resume gates on suspended only \u2014 interrupted contexts stay silent",
+          recipe: "frogoe-core \u2192 references/audio.md",
+          severity: "warning"
+        });
+      }
+      const blocksDir = path5.join(dir, "blocks");
+      let markup = index;
+      if (existsSync4(blocksDir)) {
+        for (const f of readdirSync(blocksDir)) {
+          if (f.endsWith(".html")) {
+            markup += read(path5.join(blocksDir, f));
+          }
+        }
+      }
+      const wanted = new Set(
+        [...game.matchAll(/\[(data-block-[a-z0-9-]+)\]/gu)].map((m) => m[1] ?? "")
+      );
+      for (const binding of wanted) {
+        if (binding && !markup.includes(binding)) {
+          findings.push({
+            code: "blocks/binding-orphan",
+            file: "game.js",
+            fix: `no element carries ${binding} \u2014 paste the block markup (frogoe add) or drop the selector`,
+            message: `selector ${binding} targets nothing`,
+            severity: "warning"
+          });
+        }
+      }
+    };
+    checkPin = (dir, findings) => {
+      const pinFile = path5.join(dir, "frogoe.json");
+      if (!existsSync4(pinFile)) {
+        findings.push({
+          code: "folder/contract-pin",
+          file: "frogoe.json",
+          fix: '{"contract": "0.1.0"} \u2014 the single version source of truth',
+          message: "no frogoe.json pin",
+          severity: "error"
+        });
+        return;
+      }
+      let pin = "";
+      try {
+        pin = String(JSON.parse(read(pinFile)).contract ?? "");
+      } catch {
+      }
+      const contract = read(path5.join(dir, ".frogoe/contract.js"));
+      const marker = /frogoe contract v([\d.]+)/u.exec(contract.slice(0, 400));
+      if (!contract) {
+        findings.push({
+          code: "folder/contract-pin",
+          file: ".frogoe/contract.js",
+          fix: "run frogoe init --force (rematerializes .frogoe/ from the pin)",
+          message: "contract not materialized",
+          severity: "error"
+        });
+      } else if (!marker || marker[1] !== pin) {
+        findings.push({
+          code: "folder/contract-pin",
+          file: ".frogoe/contract.js",
+          fix: `frogoe.json pins ${pin || "(none)"} but .frogoe carries ${marker?.[1] ?? "no marker"} \u2014 run frogoe init --force`,
+          message: "contract version drift",
+          severity: "error"
+        });
+      }
+    };
+    checkProject = (dir) => {
+      const findings = [];
+      checkBrief(dir, findings);
+      checkFolder(dir, findings);
+      checkPin(dir, findings);
+      findings.sort((a, b) => a.file.localeCompare(b.file) || (a.line ?? 0) - (b.line ?? 0));
+      return {
+        errors: findings.filter((f) => f.severity === "error").length,
+        findings,
+        warnings: findings.filter((f) => f.severity === "warning").length
+      };
+    };
+  }
+});
+// ../lint/src/index.ts
+var init_src = __esm({
+  "../lint/src/index.ts"() {
+    "use strict";
+    init_brief();
+    init_contrast();
+    init_check();
+  }
+});
+// src/check.ts
+var formatFindings;
+var init_check2 = __esm({
+  "src/check.ts"() {
+    "use strict";
+    init_src();
+    init_src();
+    init_src();
+    formatFindings = (result) => result.findings.map((f) => {
+      const at = f.line !== void 0 ? `:${f.line}` : "";
+      const head = `${f.severity === "error" ? "\u2716" : "\u26A0"} ${f.code}  ${f.file}${at}`;
+      return `${head}
+    ${f.message}
+    fix: ${f.fix}`;
+    }).join("\n") || "clean \u2014 0 findings";
+  }
+});
+// src/live/sampler.ts
+var PROBE_SCRIPT, DOM_PROBE_SCRIPT, CANVAS_PAINTED_SCRIPT, CANVAS_HASH_SCRIPT, GAME_STATE_SCRIPT, FINISH_EVENTS_SCRIPT, FPS_MARK_SCRIPT, FPS_SINCE_SCRIPT, fpsSinceScript, HUD_MEASURE_SCRIPT, RETRY_PRESENCE_SCRIPT, INTERRUPT_AUDIO_SCRIPT, AUDIO_STATES_SCRIPT;
+var init_sampler = __esm({
+  "src/live/sampler.ts"() {
+    "use strict";
+    PROBE_SCRIPT = `(() => {
+  if (window.__frogoeProbe) return;
+  const probe = { audioContexts: [], audioEverRan: false, finish: [], fps: [] };
+  Object.defineProperty(window, "__frogoeProbe", { value: probe });
+  document.addEventListener("frogoe:finish", (e) => {
+    const d = e && e.detail;
+    const score = d && typeof d.score === "number" ? d.score : null;
+    probe.finish.push({ at: Math.round(performance.now()), score });
+  });
+  const wrap = (Native) => class extends Native {
+    constructor(...args) {
+      super(...args);
+      probe.audioContexts.push(this);
+      this.addEventListener("statechange", () => {
+        if (this.state === "running") probe.audioEverRan = true;
+      });
+    }
+  };
+  const AC = window.AudioContext;
+  if (AC && !AC.__frogoeHooked) {
+    Object.defineProperty(wrap(AC), "__frogoeHooked", { value: true });
+    window.AudioContext = wrap(AC);
+  }
+  if (window.webkitAudioContext) {
+    window.webkitAudioContext = wrap(window.webkitAudioContext);
+  }
+  let count = 0;
+  let secStart = performance.now();
+  const tick = () => {
+    count++;
+    const now = performance.now();
+    if (now - secStart >= 1000) {
+      probe.fps.push(count);
+      count = 0;
+      secStart = now;
+    }
+    requestAnimationFrame(tick);
+  };
+  requestAnimationFrame(tick);
+})()`;
+    DOM_PROBE_SCRIPT = `(() => {
+  return {
+    canvasPresent: Boolean(document.querySelector("#c")),
+    hudPresent: Boolean(document.querySelector(".hud")),
+    state: window.__frogoe?.state ?? "(missing)",
+  };
+})()`;
+    CANVAS_PAINTED_SCRIPT = `(() => {
+  const c = document.querySelector("#c");
+  if (!c) return false;
+  const g = c.getContext("2d");
+  if (!g) return false;
+  const px = Math.floor(c.width * 0.25), py = Math.floor(c.height * 0.25);
+  const pw = Math.floor(c.width * 0.5), ph = Math.floor(c.height * 0.5);
+  const s = g.getImageData(px, py, pw, ph).data;
+  for (let i = 3; i < s.length; i += 4) { if (s[i] !== 0) return true; }
+  return false;
+})()`;
+    CANVAS_HASH_SCRIPT = `(() => {
+  const c = document.querySelector("#c");
+  if (!c) return null;
+  const g = c.getContext("2d");
+  if (!g) return null;
+  const cx = Math.floor(c.width * 0.25), cy = Math.floor(c.height * 0.25);
+  const cw = Math.floor(c.width * 0.5), ch = Math.floor(c.height * 0.5);
+  const d = g.getImageData(cx, cy, cw, ch).data;
+  let hash = 0;
+  for (let i = 0; i < d.length; i += 4) {
+    hash = (hash * 31 + d[i] + d[i + 1] * 7 + d[i + 2] * 13) | 0;
+  }
+  return hash;
+})()`;
+    GAME_STATE_SCRIPT = `window.__frogoe?.state ?? "(missing)"`;
+    FINISH_EVENTS_SCRIPT = `(() => {
+  const p = window.__frogoeProbe;
+  return p ? p.finish.slice() : [];
+})()`;
+    FPS_MARK_SCRIPT = `window.__frogoeProbe ? window.__frogoeProbe.fps.length : 0`;
+    FPS_SINCE_SCRIPT = `(() => {
+  const p = window.__frogoeProbe;
+  const mark = __MARK__;
+  return p ? p.fps.slice(mark) : [];
+})()`;
+    fpsSinceScript = (mark) => FPS_SINCE_SCRIPT.replaceAll("__MARK__", String(mark));
+    HUD_MEASURE_SCRIPT = `(() => {
+  const out = [];
+  for (const el of document.querySelectorAll(".hud *")) {
+    const own = [...el.childNodes].some((n) => n.nodeType === 3 && n.nodeValue.trim());
+    if (!own) continue;
+    const text = el.textContent ?? "";
+    const s = getComputedStyle(el);
+    const hasOutline =
+      (s.webkitTextStroke && s.webkitTextStrokeWidth !== "0px") ||
+      (s.textShadow && s.textShadow !== "none");
+    const r = el.getBoundingClientRect();
+    out.push({ hasOutline, height: r.height, label: text.trim().slice(0, 24), width: r.width });
+  }
+  return out;
+})()`;
+    RETRY_PRESENCE_SCRIPT = `(() => ({
+  gameover: Boolean(document.querySelector("[data-block-gameover]")),
+  retry: Boolean(document.querySelector("[data-block-retry]")),
+}))()`;
+    INTERRUPT_AUDIO_SCRIPT = `(() => {
+  const p = window.__frogoeProbe;
+  if (!p) return false;
+  for (const c of p.audioContexts) {
+    try { void c.suspend(); } catch (e) {}
+  }
+  return true;
+})()`;
+    AUDIO_STATES_SCRIPT = `(() => {
+  const p = window.__frogoeProbe;
+  if (!p) return { count: 0, everRan: false, running: 0 };
+  let running = 0;
+  for (const c of p.audioContexts) {
+    if (c.state === "running") running++;
+  }
+  return { count: p.audioContexts.length, everRan: p.audioEverRan === true, running };
+})()`;
+  }
+});
+// src/live/driver.ts
+var createPuppeteerDriver;
+var init_driver = __esm({
+  "src/live/driver.ts"() {
+    "use strict";
+    init_sampler();
+    createPuppeteerDriver = ({ page, size }) => {
+      const pageErrors = [];
+      const consoleErrors = [];
+      page.on("pageerror", (error) => {
+        pageErrors.push(String(error));
+      });
+      page.on("console", (message2) => {
+        if (message2.type() === "error") {
+          consoleErrors.push(message2.text());
+        }
+      });
+      page.evaluateOnNewDocument(PROBE_SCRIPT);
+      const read2 = async (script) => await page.evaluate(script);
+      return {
+        errors: () => pageErrors,
+        consoleErrors: () => consoleErrors,
+        async audioStates() {
+          return await read2(AUDIO_STATES_SCRIPT);
+        },
+        async interruptAudio() {
+          await read2(INTERRUPT_AUDIO_SCRIPT);
+        },
+        async domProbe() {
+          return await read2(DOM_PROBE_SCRIPT);
+        },
+        async canvasPainted() {
+          return await read2(CANVAS_PAINTED_SCRIPT);
+        },
+        async canvasHash() {
+          return await read2(CANVAS_HASH_SCRIPT);
+        },
+        async gameState() {
+          return await read2(GAME_STATE_SCRIPT);
+        },
+        async finishEvents() {
+          return await read2(FINISH_EVENTS_SCRIPT);
+        },
+        async fpsMark() {
+          return await read2(FPS_MARK_SCRIPT);
+        },
+        async fpsSince(mark) {
+          return await read2(fpsSinceScript(mark));
+        },
+        async hudMeasures() {
+          return await read2(HUD_MEASURE_SCRIPT);
+        },
+        async retryPresence() {
+          return await read2(RETRY_PRESENCE_SCRIPT);
+        },
+        async tap(x, y) {
+          await page.mouse.click(x, y);
+        },
+        async hold(x, y, ms) {
+          await page.mouse.move(x, y);
+          await page.mouse.down();
+          await new Promise((resolve) => {
+            setTimeout(resolve, ms);
+          });
+          await page.mouse.up();
+        },
+        async drag(x1, y1, x2, y2) {
+          await page.mouse.move(x1, y1);
+          await page.mouse.down();
+          await page.mouse.move(x2, y2, { steps: 6 });
+          await new Promise((resolve) => {
+            setTimeout(resolve, 80);
+          });
+          await page.mouse.up();
+        },
+        async clickRetryAwaitReload(timeoutMs) {
+          const interactable = `(() => {
+        const b = document.querySelector("[data-block-retry]");
+        if (!b) return false;
+        const s = getComputedStyle(b);
+        if (s.pointerEvents === "none" || s.visibility === "hidden" || s.display === "none") {
+          return false;
+        }
+        const r = b.getBoundingClientRect();
+        if (r.width < 4 || r.height < 4) return false;
+        const hit = document.elementFromPoint(r.x + r.width / 2, r.y + r.height / 2);
+        return Boolean(hit && (hit === b || b.contains(hit)));
+      })()`;
+          const grace = 3e3;
+          const started = Date.now();
+          for (; ; ) {
+            if (await page.evaluate(interactable) === true) {
+              break;
+            }
+            if (Date.now() - started > grace) {
+              return false;
+            }
+            await new Promise((resolve) => {
+              setTimeout(resolve, 100);
+            });
+          }
+          const navigated = page.waitForNavigation({ timeout: timeoutMs, waitUntil: "domcontentloaded" }).then(() => true).catch(() => false);
+          const button = await page.$("[data-block-retry]");
+          if (!button) {
+            return false;
+          }
+          await button.click();
+          return await navigated;
+        },
+        async setCpuThrottling(rate) {
+          await page.emulateCPUThrottling(rate === 1 ? null : rate);
+        },
+        async screenshot() {
+          return await page.screenshot({ encoding: "binary" });
+        },
+        viewport: () => size
+      };
+    };
+  }
+});
+// src/live/types.ts
+var finding;
+var init_types = __esm({
+  "src/live/types.ts"() {
+    "use strict";
+    finding = (shape) => shape;
+  }
+});
+// src/live/decisions.ts
+var FPS_FLOOR, FPS_SUSTAINED_WINDOW, FROZEN_STREAK, outlineFinding, collapseFinding, pageErrorFinding, consoleErrorFinding, canvasMissingFinding, canvasUnpaintedFinding, contractMissingFinding, stateStuckFinding, earlyDeathFinding, fpsFinding, fpsSustainedFinding, frozenFrameFinding, pausedFinding, stateCorruptFinding, playabilityFinding, finishEventFinding, neverEndsFinding, audioLockedFinding, noGameoverCardFinding, THROTTLE_RATE, THROTTLED_FPS_FLOOR, fpsThrottledFinding, noRetryFinding, retryDeadFinding, rebootFinding;
+var init_decisions = __esm({
+  "src/live/decisions.ts"() {
+    "use strict";
+    init_types();
+    FPS_FLOOR = 30;
+    FPS_SUSTAINED_WINDOW = 3;
+    FROZEN_STREAK = 3;
+    outlineFinding = (measures) => {
+      const bare = measures.filter((m) => !m.hasOutline);
+      if (bare.length === 0 || !bare[0]) {
+        return null;
+      }
+      return finding({
+        code: "live/hud-outline",
+        file: "index.html",
+        fix: `"${bare[0].label}" has no text-shadow or -webkit-text-stroke \u2014 game HUD text needs an outline to read on ANY background (registry blocks ship one; custom HUD must add it)`,
+        message: `${bare.length} HUD text element(s) have no outline`,
+        phase: "boot",
+        recipe: "frogoe-registry \u2192 block authoring (sticker depth pattern)",
+        severity: "error"
+      });
+    };
+    collapseFinding = (measures) => {
+      const collapsed = measures.filter((m) => m.width < 4 || m.height < 4);
+      if (collapsed.length === 0 || !collapsed[0]) {
+        return null;
+      }
+      const first = collapsed[0];
+      return finding({
+        code: "live/layout-collapse",
+        file: "index.html",
+        fix: `"${first.label}" has content but renders ${Math.round(first.width)}\xD7${Math.round(first.height)} \u2014 an element collapsed to zero (missing display, zero-size font, or an ancestor hiding it)`,
+        message: `${collapsed.length} HUD element(s) collapsed to zero size`,
+        phase: "boot",
+        severity: "error"
+      });
+    };
+    pageErrorFinding = (errors, viewport) => {
+      const first = errors[0];
+      if (first === void 0) {
+        return null;
+      }
+      return finding({
+        code: "live/page-error",
+        file: "game.js",
+        fix: `uncaught: ${first.slice(0, 140)}`,
+        message: `${errors.length} uncaught page error(s) [${viewport}]`,
+        phase: "boot",
+        severity: "error"
+      });
+    };
+    consoleErrorFinding = (entries, pageErrors, viewport) => {
+      const unique = entries.filter((entry) => !pageErrors.some((e) => e.includes(entry.slice(0, 60))));
+      const first = unique[0];
+      if (first === void 0) {
+        return null;
+      }
+      return finding({
+        code: "live/console-error",
+        file: "game.js",
+        fix: `console.error: ${first.slice(0, 140)} \u2014 recoverable failures should be handled, not logged`,
+        message: `${unique.length} console.error(s) [${viewport}]`,
+        phase: "boot",
+        severity: "warning"
+      });
+    };
+    canvasMissingFinding = (viewport) => finding({
+      code: "live/canvas-missing",
+      file: "index.html",
+      fix: 'the contract boots on <canvas id="c">',
+      message: `canvas missing [${viewport}]`,
+      phase: "boot",
+      severity: "error"
+    });
+    canvasUnpaintedFinding = (viewport, phase = "boot") => finding({
+      code: "live/canvas-unpainted",
+      file: "game.js",
+      fix: "loop.render never drew \u2014 fill loop.render = (ctx) => {...}",
+      message: `canvas stayed blank [${viewport}]`,
+      phase,
+      severity: "error"
+    });
+    contractMissingFinding = (viewport) => finding({
+      code: "live/contract-missing",
+      file: "index.html",
+      fix: 'import { defineGame } from "frogoe" \u2014 the runtime publishes window.__frogoe at boot',
+      message: `window.__frogoe absent [${viewport}]`,
+      phase: "boot",
+      severity: "error"
+    });
+    stateStuckFinding = (state, viewport, phase = "boot") => {
+      if (state !== "loading") {
+        return null;
+      }
+      return finding({
+        code: "live/state-stuck",
+        file: "game.js",
+        fix: 'state never left "loading" \u2014 defineGame() threw before start() or start() was never called',
+        message: `state stuck in "loading" [${viewport}]`,
+        phase,
+        severity: "error"
+      });
+    };
+    earlyDeathFinding = (viewport, phase = "boot") => finding({
+      code: "live/early-death",
+      file: "game.js",
+      fix: 'state reached "over" before any input \u2014 the game kills itself on the ready screen; gate death (and the physics that cause it) behind the first input.on("down")',
+      message: `game ended before the first input [${viewport}]`,
+      phase,
+      severity: "error"
+    });
+    fpsFinding = (fps, viewport) => {
+      if (fps === void 0 || fps >= FPS_FLOOR) {
+        return null;
+      }
+      return finding({
+        code: "live/fps",
+        file: "game.js",
+        fix: `${fps.toFixed(0)} fps on ${viewport} (floor ${FPS_FLOOR}) \u2014 heavy per-frame work: cache gradients, cut particle counts, avoid shadowBlur on big shapes`,
+        message: `frame rate below the playability floor [${viewport}]`,
+        phase: "play",
+        recipe: "frogoe-creative \u2192 game-feel (motion rules)",
+        severity: "warning"
+      });
+    };
+    fpsSustainedFinding = (buckets, viewport) => {
+      if (buckets.length < FPS_SUSTAINED_WINDOW) {
+        return null;
+      }
+      let worst = Number.POSITIVE_INFINITY;
+      for (let i = 0; i + FPS_SUSTAINED_WINDOW <= buckets.length; i++) {
+        const window = buckets.slice(i, i + FPS_SUSTAINED_WINDOW);
+        const avg = window.reduce((a, b) => a + b, 0) / window.length;
+        if (avg < worst) {
+          worst = avg;
+        }
+      }
+      if (worst >= FPS_FLOOR) {
+        return null;
+      }
+      const mean = buckets.reduce((a, b) => a + b, 0) / buckets.length;
+      return {
+        finding: finding({
+          code: "live/fps-sustained",
+          file: "game.js",
+          fix: `${worst.toFixed(0)} fps held for ${FPS_SUSTAINED_WINDOW}s+ on ${viewport} (floor ${FPS_FLOOR}) \u2014 the game is consistently slow, not jittering: cut per-frame allocations, shrink offscreen canvases, reduce draw calls`,
+          message: `sustained low frame rate [${viewport}]`,
+          phase: "play",
+          recipe: "frogoe-creative \u2192 game-feel (motion rules)",
+          severity: "error"
+        }),
+        mean
+      };
+    };
+    frozenFrameFinding = (streak) => {
+      if (streak < FROZEN_STREAK) {
+        return null;
+      }
+      return finding({
+        code: "live/frozen-frame",
+        file: "game.js",
+        fix: `canvas held the same frame for ${streak} samples while playing \u2014 loop.render may have stopped or draws a static scene`,
+        message: "canvas froze during play",
+        phase: "play",
+        severity: "warning"
+      });
+    };
+    pausedFinding = () => finding({
+      code: "live/paused",
+      file: "game.js",
+      fix: 'state read "paused" during scripted play \u2014 pause() ran without a matching resume(); check document.hidden handling and blur listeners',
+      message: "game paused itself during play",
+      phase: "play",
+      severity: "warning"
+    });
+    stateCorruptFinding = (state) => finding({
+      code: "live/state-corrupt",
+      file: "game.js",
+      fix: `state read "${state}" \u2014 outside the contract's set (loading/playing/paused/over); game code is mutating window.__frogoe directly`,
+      message: `state left the contract's state machine ("${state}")`,
+      phase: "play",
+      severity: "error"
+    });
+    playabilityFinding = (result) => {
+      if (result === "pass") {
+        return null;
+      }
+      if (result === "no-input") {
+        return finding({
+          code: "live/no-input",
+          file: "game.js",
+          fix: 'the game never registered input.on("down", ...) \u2014 wire the core verb before shipping',
+          message: "game has no input handler",
+          phase: "play",
+          severity: "error"
+        });
+      }
+      return finding({
+        code: "live/not-playable",
+        file: "game.js",
+        fix: "scripted taps produced no canvas change \u2014 loop.update/loop.render may be wired but the game logic never runs",
+        message: "game did not respond to scripted input",
+        phase: "play",
+        severity: "error"
+      });
+    };
+    finishEventFinding = (stateOver, finishCount) => {
+      if (stateOver === finishCount > 0) {
+        return null;
+      }
+      return finding({
+        code: "live/finish-event-missing",
+        file: "game.js",
+        fix: stateOver ? 'state reached "over" but frogoe:finish never fired \u2014 call finish(score) on death, never write __frogoe.state directly' : 'frogoe:finish fired but state is not "over" \u2014 the event was dispatched outside finish()',
+        message: "state/event mismatch at game over",
+        phase: "end",
+        severity: "error"
+      });
+    };
+    neverEndsFinding = (budgetMs) => finding({
+      code: "live/never-ends",
+      file: "game.js",
+      fix: `no death within ${Math.round(budgetMs / 1e3)}s of passive play \u2014 fine for endless/sandbox games, but feed games are short replayable loops; most deaths should arrive in seconds`,
+      message: "game never reached the over state",
+      phase: "end",
+      severity: "warning"
+    });
+    audioLockedFinding = (audio) => {
+      if (audio.count === 0 || audio.running > 0) {
+        return null;
+      }
+      return finding({
+        code: "live/audio-locked",
+        file: "game.js",
+        fix: 'audio contexts exist but stayed suspended after an interruption + real input \u2014 resume inside a user gesture: Sfx.init() in input.on("down") AND ("up"), plus the 1-sample silent-buffer unlock (frogoe-core \u2192 references/audio.md)',
+        message: "audio never recovers \u2014 every phone interruption plays this game silent",
+        phase: "play",
+        recipe: "frogoe-core \u2192 references/audio.md",
+        severity: "error"
+      });
+    };
+    noGameoverCardFinding = () => finding({
+      code: "live/no-gameover-card",
+      file: "index.html",
+      fix: "no [data-block-gameover] overlay when the game ended \u2014 install the game-over-card block so death has a screen",
+      message: "game over has no overlay",
+      phase: "end",
+      recipe: "frogoe-registry \u2192 game-over-card",
+      severity: "warning"
+    });
+    THROTTLE_RATE = 4;
+    THROTTLED_FPS_FLOOR = 15;
+    fpsThrottledFinding = (buckets, viewport) => {
+      if (buckets.length === 0) return null;
+      const mean = buckets.reduce((a, b) => a + b, 0) / buckets.length;
+      if (mean >= THROTTLED_FPS_FLOOR) return null;
+      return finding({
+        code: "live/fps-throttled",
+        file: "game.js",
+        fix: `fps ${mean.toFixed(0)} under ${THROTTLE_RATE}x cpu throttle (${viewport}) \u2014 mid-range phones will feel this: cache gradients/patterns, cut per-frame allocations, shrink offscreen canvases, cap particles`,
+        message: "cpu-bound collapse under phone-class throttle",
+        phase: "play",
+        severity: "warning"
+      });
+    };
+    noRetryFinding = () => finding({
+      code: "live/no-retry",
+      file: "index.html",
+      fix: "no [data-block-retry] button anywhere \u2014 the player is hard-stuck after death; the retry affordance is the loop's exit",
+      message: "no retry affordance after game over",
+      phase: "end",
+      recipe: "frogoe-registry \u2192 game-over-card",
+      severity: "error"
+    });
+    retryDeadFinding = () => finding({
+      code: "live/retry-dead",
+      file: "game.js",
+      fix: 'clicking retry produced no reload \u2014 wire it: retry.addEventListener("click", () => location.reload())',
+      message: "retry button did not reload the page",
+      phase: "retry",
+      severity: "error"
+    });
+    rebootFinding = (state) => {
+      if (state === "playing") {
+        return null;
+      }
+      return finding({
+        code: "live/state-stuck",
+        file: "game.js",
+        fix: `after retry reloaded the page the state read "${state}" \u2014 the second boot is not healthy (check localStorage parsing and one-time init paths)`,
+        message: `retry boot stuck in "${state}"`,
+        phase: "retry",
+        severity: "error"
+      });
+    };
+  }
+});
+// src/live/phases.ts
+var END_BUDGET_MS, RETRY_NAV_MS, PLAY_STEPS, PLAY_STEP_MS, HOLD_STEP_INDEX, DRAG_STEP_INDEX, DRAG_SPAN, HOLD_MS, POLL_MS, GRACE_MS, STABILITY_CYCLES, START_BURST_TAPS, DESKTOP_FPS_MS, sleep2, jitterX, jitterY, hasError, runBootChecks, runDesktopPass, overShotName, retryShotName, waitForOver, runStartBurst, verifyDeath, runLifecycle;
+var init_phases = __esm({
+  "src/live/phases.ts"() {
+    "use strict";
+    init_decisions();
+    END_BUDGET_MS = 45e3;
+    RETRY_NAV_MS = 8e3;
+    PLAY_STEPS = 7;
+    PLAY_STEP_MS = 850;
+    HOLD_STEP_INDEX = 3;
+    DRAG_STEP_INDEX = 5;
+    DRAG_SPAN = 90;
+    HOLD_MS = 400;
+    POLL_MS = 400;
+    GRACE_MS = 150;
+    STABILITY_CYCLES = 2;
+    START_BURST_TAPS = 3;
+    DESKTOP_FPS_MS = 2e3;
+    sleep2 = (ms) => new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+    jitterX = (step) => step * 37 % 121 - 60;
+    jitterY = (step) => step * 53 % 181 - 90;
+    hasError = (findings) => findings.some((f) => f.severity === "error");
+    runBootChecks = async (driver, ctx) => {
+      const findings = [];
+      const name = ctx.viewport.name;
+      const pageErr = pageErrorFinding(driver.errors(), name);
+      if (pageErr) {
+        findings.push(pageErr);
+      }
+      const conErr = consoleErrorFinding(driver.consoleErrors(), driver.errors(), name);
+      if (conErr) {
+        findings.push(conErr);
+      }
+      const probe = await driver.domProbe();
+      if (!probe.canvasPresent) {
+        findings.push(canvasMissingFinding(name));
+      } else if (!await driver.canvasPainted()) {
+        findings.push(canvasUnpaintedFinding(name));
+      }
+      if (probe.state === "(missing)") {
+        findings.push(contractMissingFinding(name));
+      } else if (probe.state === "over") {
+        findings.push(earlyDeathFinding(name));
+      } else {
+        const stuck = stateStuckFinding(probe.state, name);
+        if (stuck) {
+          findings.push(stuck);
+        }
+      }
+      if (probe.hudPresent) {
+        const measures = await driver.hudMeasures();
+        const outline = outlineFinding(measures);
+        if (outline) {
+          findings.push(outline);
+        }
+        const collapse = collapseFinding(measures);
+        if (collapse) {
+          findings.push(collapse);
+        }
+      }
+      return findings;
+    };
+    runDesktopPass = async (driver, ctx) => {
+      const doSleep = ctx.sleep ?? sleep2;
+      const findings = await runBootChecks(driver, ctx);
+      if (hasError(findings)) {
+        return { findings };
+      }
+      const mark = await driver.fpsMark();
+      await doSleep(DESKTOP_FPS_MS);
+      const buckets = await driver.fpsSince(mark);
+      if (buckets.length === 0) {
+        return { findings };
+      }
+      const mean = buckets.reduce((a, b) => a + b, 0) / buckets.length;
+      const warn = fpsFinding(mean, ctx.viewport.name);
+      if (warn) {
+        findings.push(warn);
+      }
+      await ctx.shot?.("live-desktop.png");
+      return { findings, fps: Math.round(mean) };
+    };
+    overShotName = (cycle) => cycle === 0 ? "live-mobile-over.png" : `live-mobile-over-${cycle + 1}.png`;
+    retryShotName = (cycle) => cycle === 0 ? "live-mobile-retry.png" : `live-mobile-retry-${cycle + 1}.png`;
+    waitForOver = async (driver, doSleep) => {
+      for (let waited = 0; waited < END_BUDGET_MS; waited += POLL_MS) {
+        await doSleep(POLL_MS);
+        if (await driver.gameState() === "over") {
+          return true;
+        }
+      }
+      return false;
+    };
+    runStartBurst = async (driver, ctx) => {
+      const doSleep = ctx.sleep ?? sleep2;
+      for (let step = 0; step < START_BURST_TAPS; step++) {
+        const x = Math.round(ctx.viewport.width / 2 + jitterX(step));
+        const y = Math.round(ctx.viewport.height / 2 + jitterY(step));
+        await driver.tap(x, y);
+        await doSleep(PLAY_STEP_MS);
+      }
+    };
+    verifyDeath = async (driver, ctx, findings, cycle) => {
+      const doSleep = ctx.sleep ?? sleep2;
+      let events = await driver.finishEvents();
+      if (events.length === 0) {
+        await doSleep(GRACE_MS);
+        events = await driver.finishEvents();
+      }
+      const mismatch = finishEventFinding(true, events.length);
+      if (mismatch) {
+        findings.push(mismatch);
+      }
+      const presence = await driver.retryPresence();
+      if (!presence.gameover) {
+        findings.push(noGameoverCardFinding());
+      }
+      if (!presence.retry) {
+        findings.push(noRetryFinding());
+      }
+      await ctx.shot?.(overShotName(cycle));
+      return presence.retry;
+    };
+    runLifecycle = async (driver, ctx) => {
+      const doSleep = ctx.sleep ?? sleep2;
+      const settle = ctx.settleMs ?? 2e3;
+      const name = ctx.viewport.name;
+      const findings = [];
+      const boot = await runBootChecks(driver, ctx);
+      findings.push(...boot);
+      await ctx.shot?.("live-mobile.png");
+      if (hasError(boot)) {
+        return { findings, lifecycle: { ends: false, retryReloads: 0 }, playability: "no-input" };
+      }
+      const mark = await driver.fpsMark();
+      const hashes = [];
+      let streak = 0;
+      let maxStreak = 0;
+      let sawOver = false;
+      let sawPaused = false;
+      let sawStuck = false;
+      let corrupt = null;
+      for (let step = 0; step < PLAY_STEPS; step++) {
+        const x = Math.round(ctx.viewport.width / 2 + jitterX(step));
+        const y = Math.round(ctx.viewport.height / 2 + jitterY(step));
+        if (step === HOLD_STEP_INDEX) {
+          await driver.hold(x, y, HOLD_MS);
+        } else if (step === DRAG_STEP_INDEX) {
+          await driver.drag(x - DRAG_SPAN, y, x + DRAG_SPAN, y);
+        } else {
+          await driver.tap(x, y);
+        }
+        await doSleep(PLAY_STEP_MS);
+        const state = await driver.gameState();
+        if (state === "over") {
+          sawOver = true;
+          break;
+        }
+        if (state === "paused") {
+          sawPaused = true;
+        } else if (state === "loading") {
+          sawStuck = true;
+        } else if (state !== "playing" && state !== "(missing)") {
+          corrupt ??= state;
+        }
+        const hash = await driver.canvasHash();
+        if (hash !== null) {
+          if (hashes.length > 0 && hash === hashes[hashes.length - 1] && state === "playing") {
+            streak += 1;
+            maxStreak = Math.max(maxStreak, streak);
+          } else {
+            streak = 0;
+          }
+          hashes.push(hash);
+        }
+      }
+      const buckets = await driver.fpsSince(mark);
+      const mean = buckets.length > 0 ? buckets.reduce((a, b) => a + b, 0) / buckets.length : void 0;
+      if (corrupt !== null) {
+        findings.push(stateCorruptFinding(corrupt));
+      }
+      if (sawStuck) {
+        const stuck = stateStuckFinding("loading", name, "play");
+        if (stuck) {
+          findings.push(stuck);
+        }
+      }
+      if (sawPaused) {
+        findings.push(pausedFinding());
+      }
+      const frozen = frozenFrameFinding(maxStreak);
+      if (frozen) {
+        findings.push(frozen);
+      }
+      const sustained = fpsSustainedFinding(buckets, name);
+      if (sustained) {
+        findings.push(sustained.finding);
+      } else {
+        const warn = fpsFinding(mean, name);
+        if (warn) {
+          findings.push(warn);
+        }
+      }
+      const responded = new Set(hashes).size > 1 || sawOver;
+      const playability = responded ? "pass" : "fail";
+      const play = playabilityFinding(playability);
+      if (play) {
+        findings.push(play);
+      }
+      const audioBefore = await driver.audioStates();
+      if (audioBefore.count > 0) {
+        await driver.interruptAudio();
+        await runStartBurst(driver, ctx);
+        await doSleep(600);
+        const audioFinding = audioLockedFinding(await driver.audioStates());
+        if (audioFinding) {
+          findings.push(audioFinding);
+        }
+      }
+      let ends = false;
+      let retryReloads = 0;
+      if (!sawOver) {
+        sawOver = await waitForOver(driver, doSleep);
+      }
+      if (!sawOver) {
+        findings.push(neverEndsFinding(END_BUDGET_MS));
+      } else {
+        ends = true;
+        let canRetry = await verifyDeath(driver, ctx, findings, 0);
+        for (let cycle = 0; cycle < STABILITY_CYCLES && canRetry; cycle++) {
+          const reloaded = await driver.clickRetryAwaitReload(RETRY_NAV_MS);
+          if (!reloaded) {
+            findings.push(retryDeadFinding());
+            break;
+          }
+          retryReloads += 1;
+          await doSleep(settle);
+          const rebootState = await driver.gameState();
+          if (rebootState === "over") {
+            findings.push(earlyDeathFinding(name, "retry"));
+          } else {
+            const reboot = rebootFinding(rebootState);
+            if (reboot) {
+              findings.push(reboot);
+            }
+          }
+          if (!await driver.canvasPainted()) {
+            findings.push(canvasUnpaintedFinding(name, "retry"));
+          }
+          await ctx.shot?.(retryShotName(cycle));
+          if (cycle < STABILITY_CYCLES - 1) {
+            await runStartBurst(driver, ctx);
+            const overAgain = await waitForOver(driver, doSleep);
+            if (!overAgain) {
+              findings.push(neverEndsFinding(END_BUDGET_MS));
+              break;
+            }
+            canRetry = await verifyDeath(driver, ctx, findings, cycle + 1);
+          }
+        }
+      }
+      const throttleMark = await driver.fpsMark();
+      await driver.setCpuThrottling(THROTTLE_RATE);
+      await runStartBurst(driver, ctx);
+      for (let step = 0; step < PLAY_STEPS; step++) {
+        const x = Math.round(ctx.viewport.width / 2 + jitterX(step));
+        const y = Math.round(ctx.viewport.height / 2 + jitterY(step));
+        if (step === HOLD_STEP_INDEX) {
+          await driver.hold(x, y, HOLD_MS);
+        } else if (step === DRAG_STEP_INDEX) {
+          await driver.drag(x - DRAG_SPAN, y, x + DRAG_SPAN, y);
+        } else {
+          await driver.tap(x, y);
+        }
+        await doSleep(PLAY_STEP_MS);
+      }
+      const throttledBuckets = await driver.fpsSince(throttleMark);
+      await driver.setCpuThrottling(1);
+      const throttled = fpsThrottledFinding(throttledBuckets, name);
+      if (throttled) {
+        findings.push(throttled);
+      }
+      return {
+        findings,
+        lifecycle: { ends, retryReloads },
+        mobileFps: mean !== void 0 ? Math.round(mean) : void 0,
+        playability
+      };
+    };
+  }
+});
+// src/net/ip.ts
+import { execSync } from "child_process";
+import os from "os";
+var VIRTUAL, isPrivateV4, isLoopback, selfAddresses, pickLanIp, interfaceFromRouteOutput, ROUTE_PROBES, routedInterfaceName, resolveLan;
+var init_ip = __esm({
+  "src/net/ip.ts"() {
+    "use strict";
+    VIRTUAL = /^(?:utun|awdl|llw|bridge|vboxnet|veth|docker|zd|zt|tailscale|tap|tun|anpi|ipsec|gif|stf|vethernet|virtualbox|vmware|vmnet|wsl|loopback|bluetooth)/u;
+    isPrivateV4 = (ip) => {
+      const octets = ip.split(".").map(Number);
+      if (octets.length !== 4 || octets.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) {
+        return false;
+      }
+      const [a = -1, b = -1] = octets;
+      if (a === 10) return true;
+      if (a === 172 && b >= 16 && b <= 31) return true;
+      if (a === 192 && b === 168) return true;
+      return false;
+    };
+    isLoopback = (addr) => {
+      if (!addr) return false;
+      return addr === "::1" || addr.startsWith("127.") || addr.startsWith("::ffff:127.");
+    };
+    selfAddresses = (interfaces) => {
+      const own = /* @__PURE__ */ new Set();
+      for (const entries of Object.values(interfaces)) {
+        for (const entry of entries ?? []) {
+          if (entry.family === "IPv4") {
+            own.add(entry.address);
+            own.add(`::ffff:${entry.address}`);
+          } else if (entry.family === "IPv6") {
+            own.add(entry.address);
+          }
+        }
+      }
+      return own;
+    };
+    pickLanIp = (interfaces, routedName) => {
+      const physical = [];
+      const virtual = [];
+      for (const [name, entries] of Object.entries(interfaces)) {
+        for (const entry of entries ?? []) {
+          if (entry.family !== "IPv4" || entry.internal || !isPrivateV4(entry.address)) continue;
+          const item = { ip: entry.address, name };
+          if (VIRTUAL.test(name.toLowerCase())) virtual.push(item);
+          else physical.push(item);
+        }
+      }
+      physical.sort((a, b) => a.name.localeCompare(b.name));
+      virtual.sort((a, b) => a.name.localeCompare(b.name));
+      if (routedName) {
+        const routed = physical.find((p) => p.name === routedName) ?? virtual.find((v) => v.name === routedName);
+        if (routed) {
+          return {
+            candidates: [routed.ip],
+            confidence: "routed",
+            ip: routed.ip,
+            virtual: !physical.includes(routed)
+          };
+        }
+      }
+      const chosen = physical[0] ?? virtual[0];
+      if (!chosen) {
+        return { candidates: [], confidence: "none", virtual: false };
+      }
+      return {
+        candidates: physical.length > 0 ? physical.map((p) => p.ip) : virtual.map((v) => v.ip),
+        confidence: "heuristic",
+        ip: chosen.ip,
+        virtual: !physical.includes(chosen)
+      };
+    };
+    interfaceFromRouteOutput = (output, style) => {
+      if (style === "bsd") return /interface:\s*(\S+)/u.exec(output)?.[1];
+      if (style === "linux") return /dev\s+(\S+)/u.exec(output)?.[1];
+      return output.split(/\r?\n/u).map((line) => line.trim()).find((line) => line.length > 0);
+    };
+    ROUTE_PROBES = [
+      { cmd: "route -n get default", style: "bsd" },
+      // darwin/bsd; usage-errors elsewhere
+      { cmd: "ip route show default", style: "linux" },
+      // linux; absent on darwin/win
+      {
+        cmd: `powershell -NoProfile -Command "(Get-NetRoute -DestinationPrefix '0.0.0.0/0' | Sort-Object RouteMetric | Select-Object -First 1).InterfaceAlias"`,
+        style: "windows"
+      }
+    ];
+    routedInterfaceName = () => {
+      for (const probe of ROUTE_PROBES) {
+        try {
+          const out = execSync(probe.cmd, {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 3e3
+          });
+          const name = interfaceFromRouteOutput(out, probe.style);
+          if (name) return name;
+        } catch {
+        }
+      }
+      return null;
+    };
+    resolveLan = () => pickLanIp(os.networkInterfaces(), routedInterfaceName());
+  }
+});
+// src/telemetry/records.ts
+var FPS_FLOOR2, formatClock, dipSpans, beaconToRecords, summarizeRecords;
+var init_records = __esm({
+  "src/telemetry/records.ts"() {
+    "use strict";
+    FPS_FLOOR2 = 30;
+    formatClock = (wall) => {
+      const d = new Date(wall);
+      const p = (n) => String(n).padStart(2, "0");
+      return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+    };
+    dipSpans = (buckets) => {
+      const spans = [];
+      let start = -1;
+      let worst = 0;
+      for (let i = 0; i <= buckets.length; i++) {
+        const low = i < buckets.length && (buckets[i] ?? 0) > 0 && (buckets[i] ?? 0) < FPS_FLOOR2;
+        if (low && start === -1) {
+          start = i;
+          worst = buckets[i] ?? 0;
+        } else if (low) {
+          worst = Math.min(worst, buckets[i] ?? 0);
+        } else if (start !== -1) {
+          spans.push({ fps: worst, len: i - start, start });
+          start = -1;
+        }
+      }
+      return spans;
+    };
+    beaconToRecords = (payload, arrivalWall) => {
+      const out = [];
+      const arrivalUp = payload.up;
+      const wallAt = (up) => arrivalWall - Math.max(0, arrivalUp - up) * 1e3;
+      const buckets = payload.fps ?? [];
+      const spans = dipSpans(buckets);
+      const spanEnd = new Map(spans.map((s) => [s.start + s.len - 1, s]));
+      for (let i = 0; i < buckets.length; i++) {
+        const fps = buckets[i] ?? 0;
+        const up = Math.max(0, arrivalUp - (buckets.length - 1 - i));
+        const wall = wallAt(up);
+        const time = formatClock(wall);
+        out.push({
+          record: { fps, time, type: "fps", up, wall },
+          text: ""
+        });
+        const span = spanEnd.get(i);
+        if (span) {
+          out.push({
+            record: { fps: span.fps, time, type: "fps", up, wall },
+            text: `\u26A0 ${time}  fps ${span.fps} \u2014 dip ${span.len}s`
+          });
+        }
+      }
+      for (const event of payload.events ?? []) {
+        const wall = wallAt(event.up);
+        const time = formatClock(wall);
+        const type = event.type === "error" || event.type === "rejection" || event.type === "hidden" || event.type === "visible" ? event.type : "error";
+        const msg = (event.msg ?? "").slice(0, 160);
+        const text = type === "hidden" ? `\xB7 ${time}  phone hidden` : type === "visible" ? `\xB7 ${time}  phone visible` : `\u2716 ${time}  ${type === "rejection" ? "unhandled rejection" : "page error"}: ${msg}`;
+        out.push({ record: { msg, time, type, up: event.up, wall }, text });
+      }
+      return out;
+    };
+    summarizeRecords = (records) => {
+      const fps = records.filter((r) => r.type === "fps" && typeof r.fps === "number");
+      const buckets = fps.map((r) => r.fps ?? 0).filter((n) => n > 0);
+      const spans = dipSpans(buckets);
+      const orderKey = (r) => typeof r.wall === "number" ? r.wall : r.up * 1e3;
+      let hiddenS = 0;
+      let pendingHidden;
+      for (const r of records) {
+        if (pendingHidden !== void 0) {
+          hiddenS += Math.max(0, orderKey(r) - pendingHidden) / 1e3;
+          pendingHidden = void 0;
+        }
+        if (r.type === "hidden") {
+          pendingHidden = orderKey(r);
+        }
+      }
+      const worstSpan = spans.reduce(
+        (acc, s) => acc === void 0 || s.len > acc.len ? s : acc,
+        void 0
+      );
+      const worst = worstSpan ? {
+        fps: worstSpan.fps,
+        len: worstSpan.len,
+        time: fps[worstSpan.start + worstSpan.len - 1]?.time ?? "?"
+      } : void 0;
+      let pageLoads = records.length > 0 ? 1 : 0;
+      let prevUp = -1;
+      for (const r of records) {
+        if (prevUp !== -1 && r.up + 2 < prevUp) pageLoads += 1;
+        prevUp = r.up;
+      }
+      const first = records[0];
+      const last = records[records.length - 1];
+      const durationS = first && last && typeof first.wall === "number" && typeof last.wall === "number" ? (
+        // +1s: the first bucket already covers one second of play
+        Math.round((last.wall - first.wall + 1e3) / 1e3)
+      ) : Math.round(last?.up ?? 0);
+      return {
+        buckets: buckets.length,
+        dips: spans.length,
+        durationS,
+        errors: records.filter((r) => r.type === "error" || r.type === "rejection").length,
+        hiddenS: Math.round(hiddenS),
+        meanFps: buckets.length > 0 ? Math.round(buckets.reduce((a, b) => a + b, 0) / buckets.length) : void 0,
+        pageLoads,
+        worst
+      };
+    };
+  }
+});
+// src/telemetry/session.ts
+import { appendFileSync, mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "fs";
+import path6 from "path";
+var pad, sessionStamp, createSessionStore, latestSessionFile;
+var init_session = __esm({
+  "src/telemetry/session.ts"() {
+    "use strict";
+    pad = (n) => String(n).padStart(2, "0");
+    sessionStamp = (wall) => {
+      const d = new Date(wall);
+      return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+    };
+    createSessionStore = (gameDir, startedWall) => {
+      const dir = path6.join(gameDir, ".frogoe", "sessions");
+      let file;
+      return {
+        file: () => file,
+        write: (records) => {
+          if (records.length === 0) return;
+          if (!file) {
+            mkdirSync4(dir, { recursive: true });
+            file = path6.join(dir, `${sessionStamp(startedWall)}.jsonl`);
+          }
+          appendFileSync(file, records.map((r) => JSON.stringify(r)).join("\n") + "\n", "utf-8");
+        }
+      };
+    };
+    latestSessionFile = (gameDir) => {
+      const dir = path6.join(gameDir, ".frogoe", "sessions");
+      try {
+        const files = readdirSync2(dir).filter((f) => f.endsWith(".jsonl")).sort();
+        return files.length > 0 ? path6.join(dir, files[files.length - 1] ?? "") : null;
+      } catch {
+        return null;
+      }
+    };
+  }
+});
+// src/run.ts
+var run_exports = {};
+__export(run_exports, {
+  startServer: () => startServer
+});
+import { existsSync as existsSync5, readFileSync as readFileSync5, statSync, watch } from "fs";
+import os2 from "os";
+import path7 from "path";
+import { createAdaptorServer } from "@hono/node-server";
+import { getConnInfo } from "@hono/node-server/conninfo";
+import { Hono } from "hono";
+var buildDevScript, MIME2, startServer;
+var init_run = __esm({
+  "src/run.ts"() {
+    "use strict";
+    init_ip();
+    init_records();
+    init_session();
+    buildDevScript = (version) => `<script>(function(){var v="${String(version)}";try{var es=new EventSource("/__frogoe/reload");es.onmessage=function(){location.reload()};es.onerror=function(){es.close()};}catch(e){}setInterval(function(){fetch("/__frogoe/version",{cache:"no-store"}).then(function(r){return r.text()}).then(function(t){if(t!==v)location.reload()}).catch(function(){})},2000);var fps=[],cnt=0,sec=performance.now(),evs=[],up0=performance.now();function up(){return (performance.now()-up0)/1000}function tick(){cnt++;var n=performance.now();if(n-sec>=1000){fps.push(cnt);cnt=0;sec=n}requestAnimationFrame(tick)}requestAnimationFrame(tick);addEventListener("error",function(e){evs.push({type:"error",msg:String(e.message||e).slice(0,200),up:up()})});addEventListener("unhandledrejection",function(e){evs.push({type:"rejection",msg:String(e.reason).slice(0,200),up:up()})});document.addEventListener("visibilitychange",function(){evs.push({type:document.hidden?"hidden":"visible",up:up()})});function flush(beacon){var p={v:1,up:up(),fps:fps.splice(0),events:evs.splice(0)};if(performance.memory)p.mem=Math.round(performance.memory.usedJSHeapSize/1048576);var b=JSON.stringify(p);if(beacon&&navigator.sendBeacon){navigator.sendBeacon("/__frogoe/metrics",new Blob([b],{type:"application/json"}));return}fetch("/__frogoe/metrics",{method:"POST",body:b,headers:{"content-type":"application/json"},keepalive:true}).catch(function(){});}document.addEventListener("visibilitychange",function(){if(document.hidden)flush(true)});addEventListener("pagehide",function(){flush(true)});setInterval(function(){flush(false)},5000);})();</script>`;
+    MIME2 = {
+      css: "text/css; charset=utf-8",
+      htm: "text/html; charset=utf-8",
+      html: "text/html; charset=utf-8",
+      ico: "image/x-icon",
+      jpeg: "image/jpeg",
+      js: "text/javascript; charset=utf-8",
+      json: "application/json; charset=utf-8",
+      mjs: "text/javascript; charset=utf-8",
+      png: "image/png",
+      svg: "image/svg+xml",
+      txt: "text/plain; charset=utf-8",
+      webp: "image/webp",
+      woff2: "font/woff2"
+    };
+    startServer = async (dir, requestedPort = 0, telemetry) => {
+      const root = path7.resolve(dir);
+      if (!existsSync5(path7.join(root, "index.html"))) {
+        throw new Error(`frogoe run: no index.html in ${root} \u2014 is this a game folder?`);
+      }
+      const clients = /* @__PURE__ */ new Set();
+      let version = 0;
+      let remoteSeen = false;
+      let lastRemote = "";
+      const own = selfAddresses(os2.networkInterfaces());
+      const session = telemetry ? createSessionStore(root, Date.now()) : void 0;
+      const app = new Hono();
+      app.use("*", async (c, next) => {
+        try {
+          const address2 = getConnInfo(c).remote.address;
+          if (address2 && !isLoopback(address2) && !own.has(address2)) {
+            remoteSeen = true;
+            lastRemote = address2;
+          }
+        } catch {
+        }
+        await next();
+      });
+      app.get("/__frogoe/reload", (c) => {
+        const stream = new ReadableStream({
+          cancel() {
+          },
+          start(controller) {
+            clients.add(controller);
+            controller.enqueue(new TextEncoder().encode("retry: 3000\n\n"));
+          }
+        });
+        return c.body(stream, {
+          headers: {
+            "cache-control": "no-store",
+            connection: "keep-alive",
+            "content-type": "text/event-stream"
+          }
+        });
+      });
+      app.get(
+        "/__frogoe/version",
+        (c) => c.text(String(version), 200, { "cache-control": "no-store" })
+      );
+      app.post("/__frogoe/metrics", async (c) => {
+        try {
+          const payload = JSON.parse(await c.req.text());
+          if (!session) return c.body(null, 204);
+          const lines = beaconToRecords(payload, Date.now());
+          session.write(lines.map((l) => l.record));
+          for (const line of lines) {
+            if (line.text) telemetry?.onEvent?.(line.text);
+          }
+          return c.body(null, 204);
+        } catch {
+          return c.body(null, 400);
+        }
+      });
+      app.get("*", (c) => {
+        const raw = decodeURIComponent(new URL(c.req.url).pathname);
+        const safe = path7.normalize(raw).replaceAll("\\", "/");
+        let file = path7.join(root, safe === "/" ? "index.html" : safe);
+        if (!file.startsWith(root)) {
+          return c.text("forbidden", 403);
+        }
+        if (existsSync5(file) && statSync(file).isDirectory()) {
+          file = path7.join(file, "index.html");
+        }
+        if (!existsSync5(file)) {
+          return c.text(`frogoe run: not found: ${raw}`, 404);
+        }
+        const body = readFileSync5(file);
+        const ext = path7.extname(file).slice(1).toLowerCase();
+        const type = MIME2[ext] ?? "application/octet-stream";
+        if (ext === "html" || ext === "htm") {
+          const html = body.toString("utf-8");
+          const injected = /<\/body>/iu.test(html) ? html.replace(/<\/body>/iu, `${buildDevScript(version)}</body>`) : html + buildDevScript(version);
+          return c.body(injected, 200, {
+            "cache-control": "no-store",
+            "content-type": type
+          });
+        }
+        return c.body(body, 200, { "content-type": type });
+      });
+      const server = createAdaptorServer({ fetch: app.fetch });
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(requestedPort, "0.0.0.0", () => resolve());
+      });
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : 0;
+      if (!port) {
+        server.closeAllConnections?.();
+        server.close();
+        throw new Error("frogoe run: server failed to bind a port");
+      }
+      const local = `http://localhost:${port}`;
+      const lanInfo = resolveLan();
+      const lan = lanInfo.ip ? `http://${lanInfo.ip}:${port}` : void 0;
+      let timer;
+      const watcher = watch(root, { recursive: true }, (_event, file) => {
+        const first = file?.split(path7.sep)[0];
+        if (first === "snapshots" || first === ".frogoe") {
+          return;
+        }
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+          version += 1;
+          const payload = new TextEncoder().encode("data: reload\n\n");
+          for (const client of clients) {
+            try {
+              client.enqueue(payload);
+            } catch {
+              clients.delete(client);
+            }
+          }
+        }, 100);
+      });
+      return {
+        port,
+        sawRemote: () => remoteSeen,
+        remote: () => remoteSeen ? lastRemote : void 0,
+        stop() {
+          clearTimeout(timer);
+          watcher.close();
+          server.closeAllConnections?.();
+          server.close();
+        },
+        urls: { lan, local }
+      };
+    };
+  }
+});
+// src/live/index.ts
+var live_exports = {};
+__export(live_exports, {
+  collectLive: () => collectLive
+});
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
+import path8 from "path";
+var VIEWPORTS, browserPath, ensureBrowser, waitForServer, collectLive;
+var init_live = __esm({
+  "src/live/index.ts"() {
+    "use strict";
+    init_driver();
+    init_phases();
+    VIEWPORTS = [
+      { height: 844, name: "mobile", width: 390 },
+      { height: 800, name: "desktop", width: 1280 }
+    ];
+    ensureBrowser = async () => {
+      if (browserPath) {
+        return browserPath;
+      }
+      const { Browser, getInstalledBrowsers, install } = await import("@puppeteer/browsers");
+      const cacheDir = path8.resolve(process.cwd(), "node_modules/.frogoe-browser");
+      const installed = await getInstalledBrowsers({ cacheDir });
+      const existing = installed.find((b) => b.browser === Browser.CHROMEHEADLESSSHELL);
+      browserPath = existing?.executablePath ?? (await install({
+        browser: Browser.CHROMEHEADLESSSHELL,
+        buildId: "131.0.6778.204",
+        cacheDir,
+        unpack: true
+      })).executablePath;
+      return browserPath;
+    };
+    waitForServer = async (url) => {
+      for (let attempt = 0; attempt < 10; attempt++) {
+        try {
+          const res = await fetch(url, { method: "HEAD" });
+          if (res.ok) {
+            return;
+          }
+        } catch {
+        }
+        await sleep2(500);
+      }
+    };
+    collectLive = async (options) => {
+      const dir = path8.resolve(options.dir);
+      const settle = options.settleMs ?? 2e3;
+      const findings = [];
+      const screenshots = [];
+      const metrics = {
+        lifecycle: { ends: false, retryReloads: 0 },
+        playability: "no-input"
+      };
+      const { startServer: startServer2 } = await Promise.resolve().then(() => (init_run(), run_exports));
+      const server = await startServer2(dir);
+      const snapshotDir = path8.join(dir, "snapshots");
+      mkdirSync5(snapshotDir, { recursive: true });
+      const { default: puppeteer } = await import("puppeteer-core");
+      const executablePath = await ensureBrowser();
+      const browser = await puppeteer.launch({
+        args: ["--no-sandbox", "--disable-gpu"],
+        defaultViewport: null,
+        executablePath,
+        headless: true
+      });
+      try {
+        let serverReady = false;
+        for (const viewport of VIEWPORTS) {
+          const runViewport = async (viewport2) => {
+            const page = await browser.newPage();
+            await page.setViewport({ height: viewport2.height, width: viewport2.width });
+            const driver = createPuppeteerDriver({
+              page,
+              size: { height: viewport2.height, width: viewport2.width }
+            });
+            const shot = async (name) => {
+              writeFileSync4(path8.join(snapshotDir, name), await driver.screenshot());
+              screenshots.push(path8.join("snapshots", name));
+            };
+            if (!serverReady) {
+              await waitForServer(server.urls.local);
+              serverReady = true;
+            }
+            await page.goto(server.urls.local, { timeout: 15e3, waitUntil: "domcontentloaded" });
+            await sleep2(settle);
+            if (viewport2.name === "mobile") {
+              const outcome = await runLifecycle(driver, {
+                settleMs: settle,
+                shot,
+                viewport: viewport2
+              });
+              findings.push(...outcome.findings);
+              metrics.playability = outcome.playability;
+              metrics.lifecycle = outcome.lifecycle;
+              if (outcome.mobileFps !== void 0) {
+                metrics.mobileFps = outcome.mobileFps;
+              }
+            } else {
+              const outcome = await runDesktopPass(driver, { shot, viewport: viewport2 });
+              findings.push(...outcome.findings);
+              if (outcome.fps !== void 0) {
+                metrics.desktopFps = outcome.fps;
+              }
+            }
+            await page.close();
+          };
+          try {
+            await runViewport(viewport);
+          } catch (error) {
+            findings.push({
+              code: "live/runtime-failure",
+              file: "game.js",
+              fix: `the live sandbox crashed on ${viewport.name}: ${String(error).slice(0, 140)}`,
+              message: `live sandbox failure [${viewport.name}]`,
+              phase: "boot",
+              severity: "error"
+            });
+          }
+        }
+      } finally {
+        await browser.close();
+        server.stop();
+      }
+      return { findings, metrics, screenshots };
+    };
+  }
+});
+// src/commands/check.ts
+var check_exports = {};
+__export(check_exports, {
+  command: () => command3
+});
+import { defineCommand as defineCommand3 } from "citty";
+var command3;
+var init_check3 = __esm({
+  "src/commands/check.ts"() {
+    "use strict";
+    init_check2();
+    command3 = defineCommand3({
+      args: {
+        dir: { type: "positional", required: false, description: "game folder (default: cwd)" },
+        json: { type: "boolean", description: "machine-readable findings" },
+        live: { type: "boolean", description: "also run the headless-browser sandbox pass" }
+      },
+      async run({ args }) {
+        const dir = args.dir ? String(args.dir) : process.cwd();
+        const result = checkProject(dir);
+        if (args.live) {
+          const { collectLive: collectLive2 } = await Promise.resolve().then(() => (init_live(), live_exports));
+          console.log("  live pass: boot \u2192 play \u2192 end \u2192 retry (headless chrome)\u2026");
+          const live = await collectLive2({ dir });
+          result.findings = [...result.findings, ...live.findings].sort(
+            (a, b) => a.file.localeCompare(b.file) || (a.line ?? 0) - (b.line ?? 0)
+          );
+          result.errors = result.findings.filter((f) => f.severity === "error").length;
+          result.warnings = result.findings.filter((f) => f.severity === "warning").length;
+          if (live.screenshots.length > 0) {
+            console.log(`  snapshots: ${live.screenshots.join(", ")}`);
+          }
+        }
+        if (args.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(formatFindings(result));
+          console.log(`
+  ${result.errors} error(s), ${result.warnings} warning(s)`);
+        }
+        if (result.errors > 0) {
+          process.exitCode = 1;
+        }
+      },
+      meta: { description: "contract lint with stable finding codes" }
+    });
+  }
+});
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  command: () => command4
+});
+import { defineCommand as defineCommand4 } from "citty";
+var command4;
+var init_init2 = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_init();
+    command4 = defineCommand4({
+      args: {
+        force: { type: "boolean", description: "rematerialize over an existing game" },
+        name: { type: "positional", description: "folder to create" }
+      },
+      async run({ args }) {
+        const name = args.name ?? ".";
+        const result = scaffold(String(name), { force: args.force === true });
+        console.log(`frogoe init \u2014 ${result.dir}`);
+        for (const file of result.files) {
+          console.log(`  + ${file}`);
+        }
+        console.log(`
+  next: cd ${name} && frogoe run`);
+      },
+      meta: { description: "scaffold a runnable game folder" }
+    });
+  }
+});
+// src/commands/report.ts
+var report_exports = {};
+__export(report_exports, {
+  command: () => command5
+});
+import { readFileSync as readFileSync6 } from "fs";
+import { defineCommand as defineCommand5 } from "citty";
+var command5;
+var init_report = __esm({
+  "src/commands/report.ts"() {
+    "use strict";
+    init_records();
+    init_session();
+    command5 = defineCommand5({
+      args: {
+        dir: { type: "positional", required: false, description: "game folder (default: cwd)" }
+      },
+      async run({ args }) {
+        const dir = args.dir ? String(args.dir) : process.cwd();
+        const file = latestSessionFile(dir);
+        if (!file) {
+          console.log(`frogoe report: no sessions in ${dir} \u2014 play a run under \`frogoe run\` first`);
+          return;
+        }
+        const records = readFileSync6(file, "utf-8").split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+        const s = summarizeRecords(records);
+        console.log(`
+  frogoe report \u2014 ${file}`);
+        console.log(
+          `  playtest ${Math.floor(s.durationS / 60)}m ${s.durationS % 60}s \xB7 ${s.pageLoads} page load${s.pageLoads === 1 ? "" : "s"} \xB7 ${s.buckets} fps buckets`
+        );
+        if (s.meanFps !== void 0) {
+          console.log(`  fps mean ${s.meanFps} \xB7 dips < 30: ${s.dips}`);
+        }
+        if (s.worst) {
+          console.log(`  worst dip: ${s.worst.fps} fps for ${s.worst.len}s at ${s.worst.time}`);
+        }
+        console.log(`  errors: ${s.errors} \xB7 hidden: ${s.hiddenS}s`);
+        console.log("");
+      },
+      meta: { description: "summarize the last playtest session (fps dips, errors)" }
+    });
+  }
+});
+// src/net/firewall.ts
+import { execSync as execSync2 } from "child_process";
+var run, binaryBlocked, probeFirewall;
+var init_firewall = __esm({
+  "src/net/firewall.ts"() {
+    "use strict";
+    run = (args) => {
+      try {
+        return execSync2(`/usr/libexec/ApplicationFirewall/socketfilterfw ${args}`, {
+          encoding: "utf-8",
+          stdio: ["ignore", "pipe", "ignore"],
+          timeout: 3e3
+        });
+      } catch {
+        return null;
+      }
+    };
+    binaryBlocked = (path10) => {
+      const out = run(`--getappblocked "${path10}"`);
+      if (out === null) return null;
+      if (/blocked/iu.test(out)) return true;
+      if (/allowed/iu.test(out)) return false;
+      return null;
+    };
+    probeFirewall = () => {
+      if (process.platform !== "darwin") return "unknown";
+      const globalState = run("--getglobalstate");
+      if (globalState === null) return "unknown";
+      const state = /firewall is (enabled|disabled)/iu.exec(globalState)?.[1]?.toLowerCase();
+      if (state === "disabled") return "off";
+      if (state !== "enabled") return "unknown";
+      const blocked = binaryBlocked(process.execPath);
+      if (blocked === null) return "unknown";
+      return blocked ? "blocked" : "open";
+    };
+  }
+});
+// src/net/plan.ts
+var lanRisky, planStartup, planNudge;
+var init_plan = __esm({
+  "src/net/plan.ts"() {
+    "use strict";
+    lanRisky = (lan) => lan.confidence === "none" || lan.virtual || lan.confidence === "heuristic" && lan.candidates.length > 1;
+    planStartup = (lan, firewall, tunnelFlag) => {
+      if (tunnelFlag) return { eagerTunnel: true, notes: [] };
+      if (lan.confidence === "none") {
+        return {
+          eagerTunnel: true,
+          notes: ["no lan address found \u2014 the tunnel is the only phone path"]
+        };
+      }
+      if (firewall === "blocked") {
+        return {
+          eagerTunnel: true,
+          notes: [
+            "macos firewall blocks incoming connections for this runtime \u2014 System Settings \u2192 Network \u2192 Firewall \u2192 Options \u2192 Allow, or rely on the tunnel"
+          ]
+        };
+      }
+      if (lanRisky(lan)) {
+        return {
+          eagerTunnel: true,
+          notes: [
+            "uncertain lan address (vpn or multiple networks) \u2014 if the phone can't load the lan QR, use the tunnel"
+          ]
+        };
+      }
+      return { eagerTunnel: false, notes: [] };
+    };
+    planNudge = (sawRemote, tunnelRunning) => sawRemote || tunnelRunning ? null : "hint";
+  }
+});
+// src/net/tunnel.ts
+import { spawn, spawnSync } from "child_process";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, chmodSync, writeFileSync as writeFileSync5 } from "fs";
+import os3 from "os";
+import path9 from "path";
+import { gunzipSync } from "zlib";
+var URL_PATTERN, parseTunnelUrl, octalAt, extractSingleFile, ENV_PIN, assetName, binaryFileName, cacheBase, resolveLatestTag, mb, downloadWithProgress, binaryEchoes, resolveBinary, startTunnel;
+var init_tunnel = __esm({
+  "src/net/tunnel.ts"() {
+    "use strict";
+    URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/iu;
+    parseTunnelUrl = (chunk) => URL_PATTERN.exec(chunk)?.[0];
+    octalAt = (block, offset, length) => {
+      const raw = block.subarray(offset, offset + length).toString("utf-8");
+      const digits = raw.replace(/[\0 ]/gu, "");
+      return digits.length === 0 ? 0 : Number.parseInt(digits, 8);
+    };
+    extractSingleFile = (tar, wanted) => {
+      for (let offset = 0; offset + 512 <= tar.length; ) {
+        const header = tar.subarray(offset, offset + 512);
+        const name = header.subarray(0, 100).toString("utf-8").replace(/\0.*$/u, "");
+        const size = octalAt(header, 124, 12);
+        const type = header.toString("utf-8").charCodeAt(156);
+        const dataStart = offset + 512;
+        const dataEnd = dataStart + size;
+        if (dataEnd > tar.length) return null;
+        if (name === wanted && (type === 48 || type === 0)) {
+          return tar.subarray(dataStart, dataEnd);
+        }
+        offset = dataStart + Math.ceil(size / 512) * 512;
+      }
+      return null;
+    };
+    ENV_PIN = "FROGOE_CLOUDFLARED_VERSION";
+    assetName = (platform, arch) => {
+      const a = arch === "arm64" ? "arm64" : arch === "x64" ? "amd64" : arch === "ia32" ? "386" : null;
+      if (!a) return null;
+      switch (platform) {
+        case "darwin":
+          return a === "386" ? null : `cloudflared-darwin-${a}.tgz`;
+        case "linux":
+          return `cloudflared-linux-${a}`;
+        // bare binaries
+        case "win32":
+          return a === "arm64" ? null : `cloudflared-windows-${a}.exe`;
+        // bare executables
+        default:
+          return null;
+      }
+    };
+    binaryFileName = (platform) => platform === "win32" ? "cloudflared.exe" : "cloudflared";
+    cacheBase = (platform, env, home) => {
+      if (platform === "darwin") return path9.join(home, "Library", "Caches");
+      if (platform === "win32") return env.LOCALAPPDATA ?? path9.join(home, "AppData", "Local");
+      return path9.join(home, ".cache");
+    };
+    resolveLatestTag = async () => {
+      const res = await fetch("https://api.github.com/repos/cloudflare/cloudflared/releases/latest", {
+        headers: { accept: "application/vnd.github+json" }
+      });
+      if (!res.ok) throw new Error(`github api ${res.status}`);
+      const body = await res.json();
+      if (!body.tag_name) throw new Error("github api returned no tag_name");
+      return body.tag_name;
+    };
+    mb = (bytes) => (bytes / (1024 * 1024)).toFixed(0);
+    downloadWithProgress = async (res, onChunk) => {
+      const total = Number(res.headers.get("content-length") ?? 0);
+      const reader = res.body?.getReader();
+      if (!reader) return Buffer.from(await res.arrayBuffer());
+      const chunks = [];
+      let done = 0;
+      let nextReport = 0;
+      for (; ; ) {
+        const step = await reader.read();
+        if (step.done) break;
+        chunks.push(Buffer.from(step.value));
+        done += step.value.byteLength;
+        if (done >= nextReport) {
+          onChunk(done, total);
+          nextReport = done + 5 * 1024 * 1024;
+        }
+      }
+      return Buffer.concat(chunks);
+    };
+    binaryEchoes = (bin, tag) => {
+      try {
+        const probe = spawnSync(bin, ["--version"], { encoding: "utf-8", timeout: 1e4 });
+        const out = `${probe.stdout ?? ""}${probe.stderr ?? ""}`;
+        return probe.status === 0 && out.includes(tag);
+      } catch {
+        return false;
+      }
+    };
+    resolveBinary = async (onProgress) => {
+      const pathProbe = spawnSync("cloudflared", ["--version"], { stdio: "ignore", timeout: 5e3 });
+      if (pathProbe.status === 0) return { downloaded: false, path: "cloudflared" };
+      const platform = process.platform;
+      const asset = assetName(platform, process.arch);
+      if (!asset) {
+        throw new Error(
+          `cloudflared publishes no build for ${platform}/${process.arch} \u2014 install it and put \`cloudflared\` on PATH`
+        );
+      }
+      const tag = process.env[ENV_PIN] ?? await resolveLatestTag();
+      const root = path9.join(cacheBase(platform, process.env, os3.homedir()), "frogoe", "cloudflared");
+      const dir = path9.join(root, tag);
+      const bin = path9.join(dir, binaryFileName(platform));
+      if (existsSync6(bin) && binaryEchoes(bin, tag)) return { downloaded: false, path: bin };
+      onProgress?.(`downloading cloudflared ${tag} (~25 MB, once)\u2026`);
+      const res = await fetch(
+        `https://github.com/cloudflare/cloudflared/releases/download/${tag}/${asset}`
+      );
+      if (!res.ok) throw new Error(`cloudflared ${tag} download failed (${res.status})`);
+      const raw = await downloadWithProgress(res, (done, total) => {
+        onProgress?.(`downloading cloudflared ${tag} \u2014 ${mb(done)}${total ? `/${mb(total)}` : ""} MB`);
+      });
+      const binary = asset.endsWith(".tgz") ? extractSingleFile(gunzipSync(raw), "cloudflared") : raw;
+      if (!binary) throw new Error("cloudflared archive did not contain the binary");
+      mkdirSync6(dir, { recursive: true });
+      writeFileSync5(bin, binary);
+      if (platform !== "win32") chmodSync(bin, 493);
+      if (!binaryEchoes(bin, tag)) {
+        throw new Error(
+          `cloudflared ${tag} failed its version check \u2014 deleted; set ${ENV_PIN} or install via brew`
+        );
+      }
+      return { downloaded: true, path: bin };
+    };
+    startTunnel = async (port, options) => {
+      const timeoutMs = options?.timeoutMs ?? 2e4;
+      const bin = await resolveBinary(options?.onProgress);
+      return new Promise((resolve, reject) => {
+        const child = spawn(
+          bin.path,
+          ["tunnel", "--url", `http://localhost:${port}`, "--no-autoupdate"],
+          {
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true
+          }
+        );
+        let settled = false;
+        let url;
+        let buffer = "";
+        const exited = new Promise((notify) => {
+          child.once("exit", () => notify());
+        });
+        const killTree = () => {
+          if (process.platform === "win32" || !child.pid) {
+            child.kill("SIGTERM");
+            return;
+          }
+          try {
+            process.kill(-child.pid, "SIGTERM");
+          } catch {
+            child.kill("SIGTERM");
+          }
+        };
+        const finish = (error) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          if (error || !url) {
+            killTree();
+            const tail = buffer.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).slice(-2).join(" | ");
+            const base = error?.message ?? "frogoe tunnel: cloudflared exited before producing a URL";
+            reject(new Error(tail ? `${base} \u2014 ${tail}` : base));
+            return;
+          }
+          resolve({ exited, stop: killTree, url });
+        };
+        const timer = setTimeout(() => {
+          finish(
+            new Error(
+              `frogoe tunnel: no URL from cloudflared within ${timeoutMs / 1e3}s \u2014 check your internet, or brew install cloudflared`
+            )
+          );
+        }, timeoutMs);
+        child.once("exit", (code) => {
+          if (!settled) {
+            finish(new Error(`frogoe tunnel: cloudflared exited early (code ${code ?? "signal"})`));
+          }
+        });
+        const watch2 = (stream) => {
+          stream.on("data", (data) => {
+            if (settled && url) return;
+            buffer += data.toString("utf-8");
+            const found = parseTunnelUrl(buffer);
+            if (found && !url) {
+              url = found;
+              finish();
+            }
+          });
+        };
+        if (child.stderr && child.stdout) {
+          watch2(child.stderr);
+          watch2(child.stdout);
+        }
+      });
+    };
+  }
+});
+// src/commands/run.ts
+var run_exports2 = {};
+__export(run_exports2, {
+  command: () => command6
+});
+import { defineCommand as defineCommand6 } from "citty";
+var NUDGE_MS, printQr, message, command6;
+var init_run2 = __esm({
+  "src/commands/run.ts"() {
+    "use strict";
+    init_firewall();
+    init_ip();
+    init_plan();
+    init_tunnel();
+    init_run();
+    NUDGE_MS = 1e4;
+    printQr = (url) => {
+      void import("qrcode-terminal").then((mod) => {
+        const qrcode = mod.default ?? mod;
+        qrcode.generate(url, { small: true }, (qr) => console.log(qr));
+      }).catch(() => {
+        console.log(`  (qr unavailable \u2014 open ${url} directly)`);
+      });
+    };
+    message = (error) => error instanceof Error ? error.message : String(error);
+    command6 = defineCommand6({
+      args: {
+        dir: { type: "positional", required: false, description: "game folder (default: cwd)" },
+        port: { type: "string", description: "port (default: random free)" },
+        tunnel: {
+          type: "boolean",
+          description: "serve through a public cloudflared quick tunnel (phone on any network)"
+        }
+      },
+      async run({ args }) {
+        const dir = args.dir ? String(args.dir) : process.cwd();
+        const port = args.port ? Number(args.port) : 0;
+        if (!Number.isInteger(port) || port < 0) {
+          throw new Error(`frogoe run: invalid port "${String(args.port)}"`);
+        }
+        const server = await startServer(dir, port, {
+          onEvent: (text) => console.log(`  ${text}`)
+        });
+        const lan = resolveLan();
+        const lanUrl = server.urls.lan;
+        const lanForBanner = args.tunnel === true ? void 0 : lanUrl;
+        const plan = planStartup(lan, probeFirewall(), args.tunnel === true);
+        console.log(`
+  frogoe run \u2014 serving game`);
+        console.log(`  local  ${server.urls.local}`);
+        if (lanForBanner) {
+          console.log(
+            `  lan    ${lanForBanner}   (phone: same wifi \u2014 safe-area only exists on real devices)`
+          );
+          printQr(lanForBanner);
+        }
+        for (const note of plan.notes) {
+          console.log(`  ! ${note}`);
+        }
+        console.log(`  reload on file change \u2014 ctrl+c to stop
+`);
+        let tunnel;
+        let stopping = false;
+        const bringUpTunnel = async (banner) => {
+          if (tunnel || stopping) return;
+          console.log(`
+  ${banner}`);
+          try {
+            tunnel = await startTunnel(server.port, {
+              onProgress: (line) => console.log(`  ${line}`)
+            });
+            console.log(`  tunnel ${tunnel.url}   (phone: any network \u2014 reload \u22642s)`);
+            printQr(tunnel.url);
+            void tunnel.exited.then(() => {
+              if (!stopping) console.log("\n  tunnel disconnected \u2014 lan/local still serving");
+            });
+          } catch (error) {
+            tunnel = void 0;
+            console.log(`  tunnel unavailable: ${message(error)}`);
+            if (!lanUrl) {
+              console.log(
+                "  no lan address and no tunnel \u2014 the page is only reachable on this machine"
+              );
+            }
+          }
+        };
+        if (plan.eagerTunnel) {
+          await bringUpTunnel(
+            args.tunnel === true ? "tunnel: starting\u2026 (first run may download cloudflared)" : "tunnel: starting as a fallback for this network\u2026"
+          );
+        }
+        const tunnelIntent = args.tunnel === true || plan.eagerTunnel;
+        const nudge = setTimeout(() => {
+          if (planNudge(server.sawRemote(), tunnel !== void 0 || tunnelIntent) === "hint") {
+            console.log(
+              "\n  no phone has connected yet \u2014 if the lan QR fails on the phone, restart with: frogoe run --tunnel"
+            );
+          }
+        }, NUDGE_MS);
+        const connectWatch = setInterval(() => {
+          if (!server.sawRemote()) return;
+          clearInterval(connectWatch);
+          const who = server.remote();
+          console.log(`
+  phone connected${who ? ` \u2014 ${who}` : ""} (live reload active)`);
+        }, 1e3);
+        const shutdown = () => {
+          if (stopping) return;
+          stopping = true;
+          clearTimeout(nudge);
+          clearInterval(connectWatch);
+          tunnel?.stop();
+          server.stop();
+          process.exit(0);
+        };
+        process.once("SIGINT", shutdown);
+        process.once("SIGTERM", shutdown);
+        await new Promise(() => {
+        });
+      },
+      meta: { description: "serve with live reload + phone QR" }
+    });
+  }
+});
+// src/cli.ts
+import { defineCommand as defineCommand7, runMain } from "citty";
+// src/version.ts
+var VERSION = "0.1.0";
+// src/cli.ts
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on?.("error", (error) => {
+    if (error.code === "EPIPE") {
+      process.exit(0);
+    }
+  });
+}
+if (process.argv.includes("--version") || process.argv.includes("-v")) {
+  console.log(VERSION);
+  process.exit(0);
+}
+var HELP = `frogoe ${VERSION} \u2014 write a closure, ship a game
+Commands:
+  init [name]   scaffold a runnable game folder
+  add <block>   copy a registry HUD block into blocks/
+  run [dir]     serve with live reload + phone QR (--tunnel: any network)
+  check [dir]   contract lint (stable finding codes; --json)
+  report [dir]  last playtest session: fps dips, errors, when
+  bundle [dir]  dissolve externals \u2192 one self-contained HTML
+Docs: skills/frogoe-core \u2014 the whole contract in five references.`;
+var main = defineCommand7({
+  meta: { description: HELP },
+  subCommands: {
+    add: () => Promise.resolve().then(() => (init_add2(), add_exports)).then((m) => m.command),
+    bundle: () => Promise.resolve().then(() => (init_bundle2(), bundle_exports)).then((m) => m.command),
+    check: () => Promise.resolve().then(() => (init_check3(), check_exports)).then((m) => m.command),
+    init: () => Promise.resolve().then(() => (init_init2(), init_exports)).then((m) => m.command),
+    report: () => Promise.resolve().then(() => (init_report(), report_exports)).then((m) => m.command),
+    run: () => Promise.resolve().then(() => (init_run2(), run_exports2)).then((m) => m.command)
+  }
+});
+await runMain(main);