superdario 1.6.0

package/dist/main.js

@@ -0,0 +1,4591 @@
+// src/agents/agent_hooks_installer.ts
+import { existsSync as existsSync2 } from "node:fs";
+
+// src/config/paths.ts
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+var IS_BUNDLED = basename(import.meta.dirname) === "dist";
+var ROOT_DIR = IS_BUNDLED ? resolve(import.meta.dirname, "..") : resolve(import.meta.dirname, "..", "..");
+var CONFIG_DIR = join(homedir(), ".config", "dario");
+var CLAUDE_DIR = join(homedir(), ".claude");
+var CODEX_DIR = process.env.CODEX_HOME ?? join(homedir(), ".codex");
+var GROK_DIR = process.env.GROK_HOME ?? join(homedir(), ".grok");
+var DARIO_PATHS = {
+  rootDir: ROOT_DIR,
+  entryFile: IS_BUNDLED ? join(ROOT_DIR, "dist", "main.js") : join(ROOT_DIR, "src", "main.ts"),
+  binFile: join(ROOT_DIR, "bin", "dario"),
+  hooksDir: join(ROOT_DIR, "hooks"),
+  skillDir: join(ROOT_DIR, "skills", "dario"),
+  configDir: CONFIG_DIR,
+  configFile: join(CONFIG_DIR, "config.json"),
+  scoresFile: join(CONFIG_DIR, "scores.json"),
+  pidFile: join(CONFIG_DIR, "dario.pid"),
+  claudeStatusFile: join(CONFIG_DIR, "claude_status.json"),
+  authFile: join(CONFIG_DIR, "auth.json"),
+  sponsorsCacheFile: join(CONFIG_DIR, "sponsors.json"),
+  claudeSettingsFile: join(CLAUDE_DIR, "settings.json"),
+  claudeSkillLink: join(CLAUDE_DIR, "skills", "dario"),
+  codexDir: CODEX_DIR,
+  codexHooksFile: join(CODEX_DIR, "hooks.json"),
+  grokDir: GROK_DIR,
+  grokHooksFile: join(GROK_DIR, "hooks", "dario.json"),
+  localBinLink: join(homedir(), ".local", "bin", "dario"),
+  vsixFile: join(CONFIG_DIR, "dario-launcher.vsix"),
+  warpTabConfig: join(homedir(), ".warp", "tab_configs", "dario.toml")
+};
+
+// src/agents/agent_hook_definitions.ts
+var AGENT_SCRIPT = "agent_hook.sh";
+var GROK_ATTENTION_MATCHER = "permission_prompt|idle_prompt";
+function bind(agent, event, matcher) {
+  const script = `${AGENT_SCRIPT} ${agent} ${event}`;
+  return matcher === void 0 ? { script } : { script, matcher };
+}
+var AGENT_HOOK_DEFINITIONS = {
+  codex: {
+    kind: "codex",
+    label: "Codex CLI",
+    configDir: DARIO_PATHS.codexDir,
+    hooksFile: DARIO_PATHS.codexHooksFile,
+    bindings: {
+      UserPromptSubmit: bind("codex", "user_prompt_submit"),
+      Stop: bind("codex", "stop"),
+      PermissionRequest: bind("codex", "attention"),
+      PreToolUse: bind("codex", "pre_tool_use"),
+      PostToolUse: bind("codex", "post_tool_use")
+    },
+    afterInstallNote: "Codex only runs hooks you have trusted: open Codex, type /hooks and approve the Dario entries once."
+  },
+  grok: {
+    kind: "grok",
+    label: "Grok Build",
+    configDir: DARIO_PATHS.grokDir,
+    hooksFile: DARIO_PATHS.grokHooksFile,
+    bindings: {
+      UserPromptSubmit: bind("grok", "user_prompt_submit"),
+      Stop: bind("grok", "stop"),
+      Notification: bind("grok", "attention", GROK_ATTENTION_MATCHER),
+      PreToolUse: bind("grok", "pre_tool_use"),
+      PostToolUse: bind("grok", "post_tool_use")
+    },
+    afterInstallNote: "Grok Build reloads hooks on its next start (or press r on the /hooks tab)."
+  }
+};
+
+// src/agents/hook_settings_installer.ts
+import { join as join2 } from "node:path";
+
+// src/store/json_file.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+var JSON_INDENT = 2;
+var JsonFile = class {
+  path;
+  fallback;
+  constructor({ path, fallback }) {
+    this.path = path;
+    this.fallback = fallback;
+  }
+  exists() {
+    return existsSync(this.path);
+  }
+  read() {
+    try {
+      return JSON.parse(readFileSync(this.path, "utf8"));
+    } catch {
+      return this.fallback;
+    }
+  }
+  write(value) {
+    mkdirSync(dirname(this.path), { recursive: true });
+    writeFileSync(this.path, `${JSON.stringify(value, null, JSON_INDENT)}
+`);
+  }
+};
+
+// src/agents/hook_settings_installer.ts
+var HOOK_TIMEOUT_SECONDS = 10;
+var HOOKS_DIR_MARKER = "/hooks/";
+var HookSettingsInstaller = class {
+  file;
+  hooksDir;
+  bindings;
+  constructor({ settingsPath, hooksDir, bindings }) {
+    this.file = new JsonFile({ path: settingsPath, fallback: {} });
+    this.hooksDir = hooksDir;
+    this.bindings = bindings;
+  }
+  isInstalled() {
+    const hooks = { ...this.file.read().hooks };
+    return Object.keys(this.bindings).every((event) => (hooks[event] ?? []).some((group) => this.isOurs(group)));
+  }
+  install() {
+    const settings = this.file.read();
+    const hooks = this.withoutOurs({ ...settings.hooks });
+    Object.entries(this.bindings).forEach(([event, binding]) => {
+      hooks[event] = [...hooks[event] ?? [], this.createGroup(binding)];
+    });
+    this.file.write({ ...settings, hooks });
+  }
+  uninstall() {
+    const settings = this.file.read();
+    const hooks = this.withoutOurs({ ...settings.hooks });
+    const remaining = Object.fromEntries(Object.entries(hooks).filter(([, groups]) => groups.length > 0));
+    this.file.write({ ...settings, hooks: remaining });
+  }
+  /** Ours: a command inside a `hooks/` folder ending with one of our scripts (works for git checkouts and ~/.dario/app). */
+  isOurs(group) {
+    const scripts = Object.values(this.bindings).map((binding) => binding.script);
+    return group.hooks.some((hook) => hook.command.includes(HOOKS_DIR_MARKER) && scripts.some((script) => hook.command.endsWith(`/${script}`)));
+  }
+  withoutOurs(hooks) {
+    return Object.fromEntries(Object.entries(hooks).map(([event, groups]) => [event, groups.filter((group) => !this.isOurs(group))]));
+  }
+  createGroup(binding) {
+    const command = join2(this.hooksDir, binding.script);
+    const entry = { hooks: [{ type: "command", command, timeout: HOOK_TIMEOUT_SECONDS }] };
+    return binding.matcher === void 0 ? entry : { matcher: binding.matcher, ...entry };
+  }
+};
+
+// src/agents/agent_hooks_installer.ts
+var AgentHooksInstaller = class {
+  hooksDir;
+  definitions;
+  constructor({ hooksDir = DARIO_PATHS.hooksDir, definitions = AGENT_HOOK_DEFINITIONS } = {}) {
+    this.hooksDir = hooksDir;
+    this.definitions = definitions;
+  }
+  listKinds() {
+    return Object.keys(this.definitions);
+  }
+  /** The agent has been used on this machine, so its hook file is worth writing. */
+  isAvailable(kind) {
+    return existsSync2(this.definitions[kind].configDir);
+  }
+  isInstalled(kind) {
+    return this.createInstaller(kind).isInstalled();
+  }
+  describe(kind) {
+    const definition = this.definitions[kind];
+    const state = this.isInstalled(kind) ? "installed" : this.isAvailable(kind) ? "not installed" : "agent not found";
+    return { kind, label: definition.label, state, hooksFile: definition.hooksFile };
+  }
+  install(kind) {
+    this.createInstaller(kind).install();
+    return this.describe(kind);
+  }
+  uninstall(kind) {
+    if (existsSync2(this.definitions[kind].hooksFile)) this.createInstaller(kind).uninstall();
+    return this.describe(kind);
+  }
+  /** Installs into every agent found on this machine and removes from every agent, used by `dario install` / `dario uninstall`. */
+  installAvailable() {
+    return this.listKinds().map((kind) => this.isAvailable(kind) ? this.install(kind) : this.describe(kind));
+  }
+  uninstallAll() {
+    return this.listKinds().map((kind) => this.uninstall(kind));
+  }
+  getNote(kind) {
+    return this.definitions[kind].afterInstallNote;
+  }
+  createInstaller(kind) {
+    const definition = this.definitions[kind];
+    return new HookSettingsInstaller({ settingsPath: definition.hooksFile, hooksDir: this.hooksDir, bindings: definition.bindings });
+  }
+};
+
+// src/cli/describe_agent_reports.ts
+var LABEL_WIDTH = 15;
+function describeAgentReports(reports) {
+  return reports.map((report) => {
+    const detail = report.state === "agent not found" ? `not found (${report.label} is not on this Mac)` : `${report.state} (${report.hooksFile})`;
+    return `  ${`${report.kind} hooks`.padEnd(LABEL_WIDTH)}${detail}`;
+  });
+}
+
+// src/cli/commands/agents_command.ts
+var OFF = "off";
+function isHookedAgent(value, installer) {
+  return installer.listKinds().includes(value);
+}
+var AGENTS_COMMAND = {
+  name: "agents",
+  aliases: ["integrations"],
+  usage: "dario agents [codex|grok] [off]",
+  description: 'Show or wire the Codex CLI / Grok Build hooks so their prompts open the game too (Claude Code is wired by "dario install").',
+  async execute(args) {
+    const installer = new AgentHooksInstaller();
+    const value = (args[0] ?? "").toLowerCase();
+    if (value.length === 0) {
+      describeAgentReports(installer.listKinds().map((kind) => installer.describe(kind))).forEach((line) => console.log(line));
+      return 0;
+    }
+    if (!isHookedAgent(value, installer)) {
+      console.error(`Unknown agent "${value}". Options: ${installer.listKinds().join(", ")}`);
+      return 1;
+    }
+    const isRemoval = (args[1] ?? "").toLowerCase() === OFF;
+    const report = isRemoval ? installer.uninstall(value) : installer.install(value);
+    describeAgentReports([report]).forEach((line) => console.log(line));
+    if (!isRemoval) console.log(`  ${installer.getNote(value)}`);
+    return 0;
+  }
+};
+
+// src/store/config_store.ts
+var DEFAULT_CONFIG = { autoLaunch: true, returnFocus: true, terminal: "auto", playerName: "", character: "auto", mode: "vibe", isSetupDone: false };
+var ConfigStore = class {
+  file;
+  constructor({ path }) {
+    this.file = new JsonFile({ path, fallback: {} });
+  }
+  load() {
+    return { ...DEFAULT_CONFIG, ...this.file.read() };
+  }
+  update(patch) {
+    const next = { ...this.load(), ...patch };
+    this.file.write(next);
+    return next;
+  }
+};
+
+// src/cli/commands/create_toggle_command.ts
+var ON_WORDS = /* @__PURE__ */ new Set(["on", "enable", "true", "1"]);
+var OFF_WORDS = /* @__PURE__ */ new Set(["off", "disable", "false", "0"]);
+function createToggleCommand({ name, aliases, usage, description, key, label }) {
+  return {
+    name,
+    aliases,
+    usage,
+    description,
+    async execute(args) {
+      const word = (args[0] ?? "").toLowerCase();
+      const store = new ConfigStore({ path: DARIO_PATHS.configFile });
+      if (!ON_WORDS.has(word) && !OFF_WORDS.has(word)) {
+        console.log(`${label} is ${store.load()[key] ? "ON" : "OFF"}. Use "${usage}".`);
+        return 0;
+      }
+      const config = store.update({ [key]: ON_WORDS.has(word) });
+      console.log(`${label} is now ${config[key] ? "ON" : "OFF"}.`);
+      return 0;
+    }
+  };
+}
+
+// src/cli/commands/auto_launch_command.ts
+var AUTO_LAUNCH_COMMAND = createToggleCommand({
+  name: "auto",
+  aliases: ["on", "off", "enable", "disable"],
+  usage: "dario on | dario off",
+  description: 'Turn the "open Dario on every Claude prompt" behaviour on or off.',
+  key: "autoLaunch",
+  label: "Auto-launch"
+});
+
+// src/cli/commands/focus_command.ts
+var FOCUS_COMMAND = createToggleCommand({
+  name: "focus",
+  aliases: [],
+  usage: "dario focus <on|off>",
+  description: "When Claude finishes or needs input: pause the game and jump back to the app you prompted from.",
+  key: "returnFocus",
+  label: "Return-focus"
+});
+
+// src/player/resolve_agent.ts
+var AGENT_KINDS = ["claude", "codex", "grok"];
+var AS_FLAG = "--as";
+function isAgentKind(value) {
+  return AGENT_KINDS.includes(value);
+}
+function readFlag(args) {
+  const index = args.indexOf(AS_FLAG);
+  const value = index >= 0 ? args[index + 1] : args.find((arg) => arg.startsWith(`${AS_FLAG}=`))?.slice(AS_FLAG.length + 1);
+  return isAgentKind(value) ? value : null;
+}
+function detectFromEnvironment(env) {
+  if (env.CLAUDECODE !== void 0 || env.CLAUDE_CODE_ENTRYPOINT !== void 0) return "claude";
+  if (env.CODEX_SANDBOX !== void 0 || env.CODEX_HOME !== void 0 || env.CODEX_CLI !== void 0) return "codex";
+  if (env.GROK_CLI !== void 0 || env.GROK_API_KEY !== void 0) return "grok";
+  return null;
+}
+function resolveAgent({ args, configured, env }) {
+  return readFlag(args) ?? (configured === "auto" ? null : configured) ?? detectFromEnvironment(env) ?? "claude";
+}
+
+// src/cli/commands/character_command.ts
+var OPTIONS = ["auto", ...AGENT_KINDS];
+var CHARACTER_COMMAND = {
+  name: "character",
+  aliases: ["as", "agent"],
+  usage: `dario character <${OPTIONS.join("|")}>`,
+  description: "Choose who you play as; the other agents become the enemies (auto = detect Claude/Codex/Grok).",
+  async execute(args) {
+    const store = new ConfigStore({ path: DARIO_PATHS.configFile });
+    const value = (args[0] ?? "").toLowerCase();
+    if (value.length === 0) {
+      console.log(`Character: ${store.load().character}`);
+      return 0;
+    }
+    if (value !== "auto" && !isAgentKind(value)) {
+      console.error(`Unknown character "${value}". Options: ${OPTIONS.join(", ")}`);
+      return 1;
+    }
+    console.log(`Character is now ${store.update({ character: value }).character}.`);
+    return 0;
+  }
+};
+
+// src/cli/commands/help_command.ts
+var USAGE_WIDTH = 34;
+function createHelpCommand({ commands }) {
+  return {
+    name: "help",
+    aliases: ["--help", "-h"],
+    usage: "dario help",
+    description: "Show this help.",
+    async execute() {
+      const lines = commands().map((command) => `  ${command.usage.padEnd(USAGE_WIDTH)} ${command.description}`);
+      console.log(["Dario - Claude's mascot endless runner", "", "Usage: dario [command]   (no command = play)", "", ...lines].join("\n"));
+      return 0;
+    }
+  };
+}
+
+// src/render/ansi.ts
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var OSC = `${ESC}]`;
+var STRING_TERMINATOR = `${ESC}\\`;
+var ANSI = {
+  reset: `${CSI}0m`,
+  bold: `${CSI}1m`,
+  dim: `${CSI}2m`,
+  hideCursor: `${CSI}?25l`,
+  showCursor: `${CSI}?25h`,
+  enterAltScreen: `${CSI}?1049h`,
+  exitAltScreen: `${CSI}?1049l`,
+  home: `${CSI}H`,
+  /** DECCKM application cursor keys: arrows arrive as ESC O A..D and are never echoed by the terminal. */
+  applicationCursorKeysOn: `${CSI}?1h`,
+  applicationCursorKeysOff: `${CSI}?1l`,
+  /** Kitty keyboard protocol: disambiguate keys (1) + report press/repeat/release (2). Ignored by terminals without it. */
+  kittyKeyboardOn: `${CSI}>3u`,
+  kittyKeyboardOff: `${CSI}<u`,
+  kittyKeyboardQuery: `${CSI}?u`,
+  clearScreen: `${CSI}2J`,
+  fg: (color) => `${CSI}38;2;${color.r};${color.g};${color.b}m`,
+  bg: (color) => `${CSI}48;2;${color.r};${color.g};${color.b}m`,
+  /** OSC 8 hyperlink: supported by Warp, iTerm2, VS Code, kitty, WezTerm; ignored elsewhere. */
+  linkOpen: (url) => `${OSC}8;;${url}${STRING_TERMINATOR}`,
+  linkClose: `${OSC}8;;${STRING_TERMINATOR}`
+};
+
+// src/cli/commands/keys_command.ts
+var PROBE_SECONDS = 8;
+var MS_PER_SECOND = 1e3;
+var KEYS_COMMAND = {
+  name: "keys",
+  aliases: ["probe"],
+  usage: "dario keys",
+  description: `Print raw key events for ${PROBE_SECONDS} seconds (to debug arrow keys / key release support).`,
+  async execute() {
+    if (!process.stdin.isTTY) {
+      console.error("dario keys needs an interactive terminal.");
+      return 1;
+    }
+    process.stdout.write(`${ANSI.kittyKeyboardOn}${ANSI.kittyKeyboardQuery}Press and hold RIGHT, release, then SPACE. Listening for ${PROBE_SECONDS}s...
+`);
+    process.stdin.setRawMode(true);
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => process.stdout.write(`${JSON.stringify(chunk)}\r
+`));
+    process.stdin.resume();
+    await new Promise((resolve2) => setTimeout(resolve2, PROBE_SECONDS * MS_PER_SECOND));
+    process.stdout.write(ANSI.kittyKeyboardOff);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    return 0;
+  }
+};
+
+// src/launcher/detect_terminal.ts
+import { existsSync as existsSync4 } from "node:fs";
+
+// src/ide/ide_definitions.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+var APPLICATIONS_DIR = "/Applications";
+function define({ kind, appName, scheme, cli, homeDir }) {
+  const appBundle = join3(APPLICATIONS_DIR, `${appName}.app`);
+  return {
+    kind,
+    appName,
+    scheme,
+    cliCandidates: [cli, join3(appBundle, "Contents", "Resources", "app", "bin", cli)],
+    extensionsDir: join3(homedir2(), homeDir, "extensions"),
+    appBundle
+  };
+}
+var IDE_DEFINITIONS = {
+  cursor: define({ kind: "cursor", appName: "Cursor", scheme: "cursor", cli: "cursor", homeDir: ".cursor" }),
+  vscode: define({ kind: "vscode", appName: "Visual Studio Code", scheme: "vscode", cli: "code", homeDir: ".vscode" }),
+  vscode_insiders: define({ kind: "vscode_insiders", appName: "Visual Studio Code - Insiders", scheme: "vscode-insiders", cli: "code-insiders", homeDir: ".vscode-insiders" }),
+  vscodium: define({ kind: "vscodium", appName: "VSCodium", scheme: "vscodium", cli: "codium", homeDir: ".vscode-oss" }),
+  windsurf: define({ kind: "windsurf", appName: "Windsurf", scheme: "windsurf", cli: "windsurf", homeDir: ".windsurf" }),
+  kiro: define({ kind: "kiro", appName: "Kiro", scheme: "kiro", cli: "kiro", homeDir: ".kiro" }),
+  trae: define({ kind: "trae", appName: "Trae", scheme: "trae", cli: "trae", homeDir: ".trae" })
+};
+var IDE_KINDS = Object.keys(IDE_DEFINITIONS);
+
+// src/ide/is_ide_kind.ts
+function isIdeKind(value) {
+  return IDE_KINDS.includes(value);
+}
+
+// src/ide/is_ide_launcher_installed.ts
+import { existsSync as existsSync3, readdirSync } from "node:fs";
+
+// src/ide/extension_files.ts
+var EXTENSION_PUBLISHER = "eventually";
+var EXTENSION_NAME = "dario-launcher";
+var EXTENSION_VERSION = "1.0.0";
+function createExtensionFiles({ binPath }) {
+  const packageJson = {
+    name: EXTENSION_NAME,
+    displayName: "Dario Launcher",
+    description: "Opens the Dario terminal game in an integrated terminal (vscode://eventually.dario-launcher/play).",
+    version: EXTENSION_VERSION,
+    publisher: EXTENSION_PUBLISHER,
+    engines: { vscode: "^1.80.0" },
+    categories: ["Other"],
+    activationEvents: ["onUri", "onCommand:dario.play"],
+    main: "./extension.js",
+    contributes: { commands: [{ command: "dario.play", title: "Dario: Play" }] }
+  };
+  const extensionJs = [
+    "const vscode = require('vscode');",
+    `const BIN = ${JSON.stringify(binPath)};`,
+    "let terminal = null;",
+    "function play(agent) {",
+    "  const args = agent ? ` --as ${agent}` : '';",
+    "  if (terminal === null || terminal.exitStatus !== undefined) terminal = vscode.window.createTerminal({ name: 'Dario' });",
+    "  terminal.show(true);",
+    "  terminal.sendText(`'${BIN}' play${args}`);",
+    "}",
+    "exports.activate = (context) => {",
+    "  context.subscriptions.push(vscode.window.registerUriHandler({ handleUri(uri) { if (uri.path === '/play') play(new URLSearchParams(uri.query).get('as')); } }));",
+    "  context.subscriptions.push(vscode.commands.registerCommand('dario.play', () => play(null)));",
+    "};",
+    "exports.deactivate = () => {};",
+    ""
+  ].join("\n");
+  const manifest = [
+    '<?xml version="1.0" encoding="utf-8"?>',
+    '<PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">',
+    `  <Metadata><Identity Language="en-US" Id="${EXTENSION_NAME}" Version="${EXTENSION_VERSION}" Publisher="${EXTENSION_PUBLISHER}"/><DisplayName>Dario Launcher</DisplayName><Description xml:space="preserve">Opens the Dario terminal game in an integrated terminal.</Description><Categories>Other</Categories></Metadata>`,
+    '  <Installation><InstallationTarget Id="Microsoft.VisualStudio.Code"/></Installation>',
+    "  <Dependencies/>",
+    '  <Assets><Asset Type="Microsoft.VisualStudio.Code.Manifest" Path="extension/package.json" Addressable="true"/></Assets>',
+    "</PackageManifest>",
+    ""
+  ].join("\n");
+  const contentTypes = '<?xml version="1.0" encoding="utf-8"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="json" ContentType="application/json"/><Default Extension="vsixmanifest" ContentType="text/xml"/><Default Extension="js" ContentType="application/javascript"/></Types>\n';
+  return [
+    { path: "extension.vsixmanifest", content: manifest },
+    { path: "[Content_Types].xml", content: contentTypes },
+    { path: "extension/package.json", content: `${JSON.stringify(packageJson, null, 2)}
+` },
+    { path: "extension/extension.js", content: extensionJs }
+  ];
+}
+
+// src/ide/is_ide_launcher_installed.ts
+function isIdeLauncherInstalled(kind) {
+  const dir = IDE_DEFINITIONS[kind].extensionsDir;
+  if (!existsSync3(dir)) return false;
+  const prefix = `${EXTENSION_PUBLISHER}.${EXTENSION_NAME}-`;
+  return readdirSync(dir).some((entry) => entry.startsWith(prefix));
+}
+
+// src/launcher/terminal_app_bundles.ts
+var TERMINAL_APP_BUNDLES = {
+  warp: "/Applications/Warp.app",
+  iterm: "/Applications/iTerm.app",
+  ghostty: "/Applications/Ghostty.app",
+  wezterm: "/Applications/WezTerm.app",
+  kitty: "/Applications/kitty.app",
+  alacritty: "/Applications/Alacritty.app",
+  tabby: "/Applications/Tabby.app",
+  rio: "/Applications/Rio.app"
+};
+
+// src/launcher/detect_terminal.ts
+var TERM_PROGRAM_KINDS = {
+  WarpTerminal: "warp",
+  "iTerm.app": "iterm",
+  Apple_Terminal: "apple_terminal",
+  ghostty: "ghostty",
+  WezTerm: "wezterm",
+  Tabby: "tabby",
+  rio: "rio"
+};
+var INSTALL_PREFERENCE = ["warp", "iterm", "ghostty", "wezterm", "kitty", "alacritty", "tabby", "rio"];
+function isBundleInstalled(kind) {
+  if (kind === "apple_terminal") return true;
+  if (isIdeKind(kind)) return isIdeLauncherInstalled(kind);
+  return existsSync4(TERMINAL_APP_BUNDLES[kind]);
+}
+function detectTerminal({ env, preferred, isInstalled = isBundleInstalled }) {
+  if (preferred !== "auto" && isInstalled(preferred)) return preferred;
+  const fromProgram = TERM_PROGRAM_KINDS[env.TERM_PROGRAM ?? ""];
+  if (fromProgram !== void 0) return fromProgram;
+  if (env.KITTY_WINDOW_ID !== void 0) return "kitty";
+  if (env.ALACRITTY_WINDOW_ID !== void 0) return "alacritty";
+  return INSTALL_PREFERENCE.find(isInstalled) ?? "apple_terminal";
+}
+
+// src/launcher/sleep_sync.ts
+function sleepSync(milliseconds) {
+  if (milliseconds <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+
+// src/claude/describe_tool_use.ts
+import { basename as basename2 } from "node:path";
+var MAX_DETAIL = 34;
+var SEPARATOR = " \xB7 ";
+function firstString(input, keys) {
+  const found = keys.map((key) => input[key]).find((value) => typeof value === "string" && value.length > 0);
+  return typeof found === "string" ? found : "";
+}
+function shorten(text) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > MAX_DETAIL ? `${oneLine.slice(0, MAX_DETAIL - 1)}\u2026` : oneLine;
+}
+function describeToolUse({ toolName, toolInput }) {
+  const path = firstString(toolInput, ["file_path", "notebook_path", "path"]);
+  const detail = path.length > 0 ? basename2(path) : firstString(toolInput, ["command", "description", "pattern", "query", "url", "prompt", "skill"]);
+  return detail.length === 0 ? toolName : `${toolName}${SEPARATOR}${shorten(detail)}`;
+}
+
+// src/claude/claude_hook_service.ts
+var ATTENTION_NOTIFICATIONS = /* @__PURE__ */ new Set(["permission_prompt", "idle_prompt", "elicitation_dialog"]);
+var SUPPORTED_PLATFORM = "darwin";
+var NO_ORIGIN = { bundleId: "", name: "" };
+var DEFAULT_FOCUS_DELAY_MS = 350;
+var DEFAULT_AGENT = "claude";
+var NOTHING_DONE = { statusWritten: false, launched: false, shown: false, focusReturned: false };
+var ClaudeHookService = class {
+  statusWriter;
+  configStore;
+  lock;
+  launcher;
+  focus;
+  platform;
+  env;
+  focusDelayMs;
+  constructor({ statusWriter, configStore, lock, launcher, focus, platform = process.platform, env = process.env, focusDelayMs = DEFAULT_FOCUS_DELAY_MS }) {
+    this.statusWriter = statusWriter;
+    this.configStore = configStore;
+    this.lock = lock;
+    this.launcher = launcher;
+    this.focus = focus;
+    this.platform = platform;
+    this.env = env;
+    this.focusDelayMs = focusDelayMs;
+  }
+  handle({ event, payload, agent = DEFAULT_AGENT }) {
+    if (event === "user_prompt_submit") return this.handlePromptSubmit({ payload, agent });
+    if (event === "pre_tool_use") return this.handleActivity({ message: describeToolUse({ toolName: payload.tool_name ?? payload.toolName ?? "tool", toolInput: payload.tool_input ?? payload.toolInput ?? {} }), agent });
+    if (event === "post_tool_use") return this.handleActivity({ message: "", agent });
+    if (event === "stop") return this.handleUserNeeded({ status: "done", payload, agent });
+    if (event === "attention") return this.handleUserNeeded({ status: "attention", payload, agent });
+    const isAttention = ATTENTION_NOTIFICATIONS.has(payload.notification_type ?? payload.notificationType ?? "");
+    return isAttention ? this.handleUserNeeded({ status: "attention", payload, agent }) : NOTHING_DONE;
+  }
+  get isMac() {
+    return this.platform === SUPPORTED_PLATFORM;
+  }
+  /** New prompt: remember where it came from, then open the game (as the prompting agent) or bring the running one forward. */
+  handlePromptSubmit({ payload, agent }) {
+    const origin = this.isMac ? this.focus.capture() : NO_ORIGIN;
+    this.statusWriter.write({ status: "working", cwd: payload.cwd ?? "", message: payload.message ?? "", origin, agent });
+    const config = this.configStore.load();
+    if (!config.autoLaunch || !this.isMac) return { ...NOTHING_DONE, statusWritten: true };
+    if (!this.lock.isHeld()) {
+      this.launcher.launch({ preferred: config.terminal, agent, lock: this.lock });
+      return { ...NOTHING_DONE, statusWritten: true, launched: true };
+    }
+    this.focus.showTerminal({ kind: detectTerminal({ env: this.env, preferred: config.terminal }), current: origin });
+    return { ...NOTHING_DONE, statusWritten: true, shown: true };
+  }
+  /** A tool started or finished: refresh the "working" line without touching launch or focus. */
+  handleActivity({ message, agent }) {
+    const previous = this.statusWriter.read();
+    this.statusWriter.write({ status: "working", cwd: previous?.cwd ?? "", message, origin: previous?.origin ?? NO_ORIGIN, agent });
+    return { ...NOTHING_DONE, statusWritten: true };
+  }
+  /** The agent is done or blocked: keep the origin app on record, then bring it back if the game is up. */
+  handleUserNeeded({ status, payload, agent }) {
+    const origin = this.statusWriter.read()?.origin ?? NO_ORIGIN;
+    this.statusWriter.write({ status, cwd: payload.cwd ?? "", message: payload.message ?? "", origin, agent });
+    const canReturn = this.configStore.load().returnFocus && this.isMac && this.lock.isHeld();
+    if (!canReturn) return { ...NOTHING_DONE, statusWritten: true };
+    sleepSync(this.focusDelayMs);
+    this.focus.restore(origin);
+    return { ...NOTHING_DONE, statusWritten: true, focusReturned: true };
+  }
+};
+
+// src/claude/claude_status_writer.ts
+var NO_ORIGIN2 = { bundleId: "", name: "" };
+var DEFAULT_AGENT2 = "claude";
+var ClaudeStatusWriter = class {
+  file;
+  constructor({ path }) {
+    this.file = new JsonFile({ path, fallback: null });
+  }
+  read() {
+    const record = this.file.read();
+    return record === null ? null : { ...record, origin: record.origin ?? NO_ORIGIN2, agent: record.agent ?? DEFAULT_AGENT2 };
+  }
+  write({ status, cwd = "", message = "", origin = NO_ORIGIN2, agent = DEFAULT_AGENT2 }) {
+    const record = { status, cwd, message, origin, agent, updatedAt: Date.now() };
+    this.file.write(record);
+    return record;
+  }
+};
+
+// src/launcher/app_focus.ts
+import { spawnSync } from "node:child_process";
+
+// src/launcher/terminal_app_names.ts
+var TERMINAL_APP_NAMES = {
+  warp: "Warp",
+  iterm: "iTerm",
+  apple_terminal: "Terminal",
+  ghostty: "Ghostty",
+  wezterm: "WezTerm",
+  kitty: "kitty",
+  alacritty: "Alacritty",
+  tabby: "Tabby",
+  rio: "Rio",
+  cursor: "Cursor",
+  vscode: "Visual Studio Code",
+  vscode_insiders: "Visual Studio Code - Insiders",
+  vscodium: "VSCodium",
+  windsurf: "Windsurf",
+  kiro: "Kiro",
+  trae: "Trae"
+};
+
+// src/launcher/app_focus.ts
+var SCRIPT_TIMEOUT_MS = 3e3;
+var WARP_BUNDLE_PREFIX = "dev.warp.";
+var NO_TARGET = { bundleId: "", name: "" };
+var CAPTURE_SCRIPT = [
+  'tell application "System Events"',
+  "  set frontApp to first application process whose frontmost is true",
+  "  return (bundle identifier of frontApp) & linefeed & (name of frontApp)",
+  "end tell"
+].join("\n");
+var PREVIOUS_TAB_SCRIPT = 'tell application "System Events" to keystroke "[" using {command down, shift down}';
+var NEXT_TAB_SCRIPT = 'tell application "System Events" to keystroke "]" using {command down, shift down}';
+function runOsascript(script) {
+  const result = spawnSync("osascript", ["-e", script], { encoding: "utf8", timeout: SCRIPT_TIMEOUT_MS });
+  return result.status === 0 ? result.stdout.trim() : "";
+}
+function escapeAppleScript(text) {
+  return text.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function isWarp(target) {
+  return target.bundleId.startsWith(WARP_BUNDLE_PREFIX);
+}
+var AppFocus = class {
+  runScript;
+  constructor({ runScript = runOsascript } = {}) {
+    this.runScript = runScript;
+  }
+  capture() {
+    const [bundleId = "", name = ""] = this.runScript(CAPTURE_SCRIPT).split("\n");
+    if (bundleId.length === 0) return NO_TARGET;
+    return { bundleId, name };
+  }
+  /** Back to where the prompt was typed; from Warp that means the tab before the game tab. */
+  restore(target) {
+    if (target.bundleId.length === 0) return;
+    this.runScript(`tell application id "${escapeAppleScript(target.bundleId)}" to activate`);
+    if (isWarp(target)) this.runScript(PREVIOUS_TAB_SCRIPT);
+  }
+  /** Bring the running game forward; when the user is already inside Warp, step to the game tab. */
+  showTerminal({ kind, current }) {
+    this.runScript(`tell application "${TERMINAL_APP_NAMES[kind]}" to activate`);
+    if (kind === "warp" && isWarp(current)) this.runScript(NEXT_TAB_SCRIPT);
+  }
+};
+
+// src/launcher/process_lock.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var PROBE_SIGNAL = 0;
+var ProcessLock = class {
+  path;
+  constructor({ path }) {
+    this.path = path;
+  }
+  readPid() {
+    if (!existsSync5(this.path)) return null;
+    const pid = Number.parseInt(readFileSync2(this.path, "utf8").trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  }
+  isHeld() {
+    const pid = this.readPid();
+    if (pid === null) return false;
+    return isProcessAlive(pid);
+  }
+  acquire() {
+    if (this.isHeld()) return false;
+    mkdirSync2(dirname2(this.path), { recursive: true });
+    writeFileSync2(this.path, `${process.pid}
+`);
+    return true;
+  }
+  release() {
+    if (this.readPid() !== process.pid) return;
+    unlinkSync(this.path);
+  }
+};
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, PROBE_SIGNAL);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/launcher/terminal_launcher.ts
+import { spawn } from "node:child_process";
+
+// src/launcher/quote_for_shell.ts
+function quoteForShell(parts) {
+  return parts.map((part) => /^[A-Za-z0-9_./=:-]+$/.test(part) ? part : `'${part.replaceAll("'", "'\\''")}'`).join(" ");
+}
+
+// src/launcher/warp_tab_config.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+var CONFIG_NAME = "dario";
+var EXIT_COMMAND = "exit";
+var WarpTabConfig = class {
+  path;
+  command;
+  cwd;
+  constructor({ path, command, cwd }) {
+    this.path = path;
+    this.command = command;
+    this.cwd = cwd;
+  }
+  getUri() {
+    return `warp://tab_config/${CONFIG_NAME}`;
+  }
+  write() {
+    mkdirSync3(dirname3(this.path), { recursive: true });
+    writeFileSync3(this.path, this.render());
+  }
+  render() {
+    return [
+      'name = "Dario"',
+      'title = "Dario"',
+      'color = "yellow"',
+      "",
+      "[[panes]]",
+      'id = "main"',
+      'type = "terminal"',
+      `directory = ${JSON.stringify(this.cwd)}`,
+      `commands = [${JSON.stringify(this.command)}, ${JSON.stringify(EXIT_COMMAND)}]`,
+      ""
+    ].join("\n");
+  }
+};
+
+// src/launcher/build_launch_spec.ts
+function buildIdeSpec({ kind, agent }) {
+  const query = agent === null ? "" : `?as=${agent}`;
+  return { executable: "open", args: [`${IDE_DEFINITIONS[kind].scheme}://${EXTENSION_PUBLISHER}.${EXTENSION_NAME}/play${query}`] };
+}
+var APPLE_TERMINAL_COLUMNS = 140;
+var APPLE_TERMINAL_ROWS = 42;
+function escapeAppleScript2(text) {
+  return text.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function buildItermScript(command) {
+  const quoted = escapeAppleScript2(command);
+  return [
+    'tell application "iTerm"',
+    "  activate",
+    "  if (count of windows) = 0 then",
+    `    create window with default profile command "${quoted}"`,
+    "  else",
+    `    tell current window to create tab with default profile command "${quoted}"`,
+    "  end if",
+    "end tell"
+  ].join("\n");
+}
+function buildAppleTerminalScript(command) {
+  const quoted = escapeAppleScript2(`${command}; exit`);
+  return [
+    'tell application "Terminal"',
+    "  activate",
+    `  set gameTab to do script "${quoted}"`,
+    `  set number of columns of gameTab to ${APPLE_TERMINAL_COLUMNS}`,
+    `  set number of rows of gameTab to ${APPLE_TERMINAL_ROWS}`,
+    "end tell"
+  ].join("\n");
+}
+function buildWarpSpec(command) {
+  const config = new WarpTabConfig({ path: DARIO_PATHS.warpTabConfig, command, cwd: DARIO_PATHS.rootDir });
+  config.write();
+  return { executable: "open", args: [config.getUri()] };
+}
+function buildOpenSpec({ kind, flags, commandParts }) {
+  return { executable: "open", args: ["-na", TERMINAL_APP_NAMES[kind], "--args", ...flags, ...commandParts] };
+}
+function buildLaunchSpec({ kind, commandParts, agent = null }) {
+  if (isIdeKind(kind)) return buildIdeSpec({ kind, agent });
+  const command = quoteForShell(commandParts);
+  const strategies = {
+    warp: () => buildWarpSpec(command),
+    iterm: () => ({ executable: "osascript", args: ["-e", buildItermScript(command)] }),
+    apple_terminal: () => ({ executable: "osascript", args: ["-e", buildAppleTerminalScript(command)] }),
+    ghostty: () => buildOpenSpec({ kind, flags: ["-e"], commandParts }),
+    wezterm: () => buildOpenSpec({ kind, flags: ["start", "--"], commandParts }),
+    kitty: () => buildOpenSpec({ kind, flags: [], commandParts }),
+    alacritty: () => buildOpenSpec({ kind, flags: ["-e"], commandParts }),
+    tabby: () => buildOpenSpec({ kind, flags: ["run"], commandParts }),
+    rio: () => buildOpenSpec({ kind, flags: ["-e"], commandParts })
+  };
+  return strategies[kind]();
+}
+
+// src/launcher/terminal_launcher.ts
+var NODE_FLAGS = ["--no-warnings=ExperimentalWarning"];
+var DEFAULT_IDE_GRACE_MS = 3e3;
+var TerminalLauncher = class {
+  run;
+  ideGraceMs;
+  constructor({ run = runDetached, ideGraceMs = DEFAULT_IDE_GRACE_MS } = {}) {
+    this.run = run;
+    this.ideGraceMs = ideGraceMs;
+  }
+  launch({ preferred, agent = null, env = process.env, lock = null }) {
+    const kind = detectTerminal({ env, preferred });
+    const agentArgs = agent === null ? [] : ["--as", agent];
+    const command = [process.execPath, ...NODE_FLAGS, DARIO_PATHS.entryFile, "play", ...agentArgs];
+    this.run(buildLaunchSpec({ kind, commandParts: command, agent }));
+    if (!isIdeKind(kind) || lock === null) return { kind, command };
+    sleepSync(this.ideGraceMs);
+    if (lock.isHeld()) return { kind, command };
+    const fallback = detectTerminal({ env, preferred: "auto" });
+    this.run(buildLaunchSpec({ kind: fallback, commandParts: command, agent }));
+    return { kind: fallback, command };
+  }
+};
+function runDetached(spec) {
+  const child = spawn(spec.executable, [...spec.args], { detached: true, stdio: "ignore" });
+  child.unref();
+}
+
+// src/cli/read_stdin_json.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+var STDIN_FD = 0;
+function readStdinJson(fallback) {
+  if (process.stdin.isTTY) return fallback;
+  try {
+    const raw = readFileSync3(STDIN_FD, "utf8").trim();
+    return raw.length === 0 ? fallback : JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+// src/cli/commands/hook_command.ts
+var HOOK_EVENTS = ["user_prompt_submit", "stop", "notification", "attention", "pre_tool_use", "post_tool_use"];
+var AGENT_FLAG = "--agent";
+function isHookEvent(value) {
+  return HOOK_EVENTS.includes(value);
+}
+function readHookAgent(args) {
+  const value = args[args.indexOf(AGENT_FLAG) + 1];
+  return args.includes(AGENT_FLAG) && isAgentKind(value) ? value : "claude";
+}
+var HOOK_COMMAND = {
+  name: "hook",
+  aliases: [],
+  usage: `dario hook <${HOOK_EVENTS.join("|")}> [--agent claude|codex|grok]`,
+  description: "Internal entry point called by the Claude Code / Codex / Grok hook scripts (hook JSON on stdin).",
+  async execute(args) {
+    const event = args[0] ?? "";
+    if (!isHookEvent(event)) {
+      console.error(`Unknown hook event "${event}". Expected one of: ${HOOK_EVENTS.join(", ")}`);
+      return 1;
+    }
+    const payload = readStdinJson({});
+    const service = new ClaudeHookService({
+      statusWriter: new ClaudeStatusWriter({ path: DARIO_PATHS.claudeStatusFile }),
+      configStore: new ConfigStore({ path: DARIO_PATHS.configFile }),
+      lock: new ProcessLock({ path: DARIO_PATHS.pidFile }),
+      launcher: new TerminalLauncher(),
+      focus: new AppFocus()
+    });
+    service.handle({ event, payload, agent: readHookAgent(args) });
+    return 0;
+  }
+};
+
+// src/cli/commands/ide_command.ts
+import { existsSync as existsSync7 } from "node:fs";
+
+// src/ide/ide_installer.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+
+// src/ide/build_vsix.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { mkdirSync as mkdirSync4, mkdtempSync, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname4, join as join4 } from "node:path";
+function buildVsix({ binPath, outputPath }) {
+  const stage = mkdtempSync(join4(tmpdir(), "dario-vsix-"));
+  createExtensionFiles({ binPath }).forEach((file) => {
+    mkdirSync4(dirname4(join4(stage, file.path)), { recursive: true });
+    writeFileSync4(join4(stage, file.path), file.content);
+  });
+  mkdirSync4(dirname4(outputPath), { recursive: true });
+  rmSync(outputPath, { force: true });
+  const result = spawnSync2("zip", ["-q", "-r", outputPath, "."], { cwd: stage, encoding: "utf8" });
+  rmSync(stage, { recursive: true, force: true });
+  if (result.status !== 0) throw new Error(`zip failed: ${result.stderr}`);
+  return outputPath;
+}
+
+// src/ide/ide_installer.ts
+var INSTALL_TIMEOUT_MS = 12e4;
+function findCli(kind) {
+  return IDE_DEFINITIONS[kind].cliCandidates.find((candidate) => candidate.includes("/") ? existsSync6(candidate) : spawnSync3("which", [candidate]).status === 0) ?? null;
+}
+var IdeInstaller = class {
+  isInstalled(kind) {
+    return isIdeLauncherInstalled(kind);
+  }
+  install(kind) {
+    const cli = findCli(kind);
+    if (cli === null) throw new Error(`${IDE_DEFINITIONS[kind].appName} command line tool not found; install it from the IDE's command palette ("Shell Command: Install ... command").`);
+    const vsix = buildVsix({ binPath: DARIO_PATHS.binFile, outputPath: DARIO_PATHS.vsixFile });
+    const result = spawnSync3(cli, ["--install-extension", vsix, "--force"], { encoding: "utf8", timeout: INSTALL_TIMEOUT_MS });
+    if (result.status !== 0) throw new Error(`${cli} --install-extension failed: ${result.stderr || result.stdout}`);
+    return { vsix, cli };
+  }
+};
+
+// src/cli/commands/ide_command.ts
+var KIND_WIDTH = 17;
+function describeIde(kind, installer) {
+  const definition = IDE_DEFINITIONS[kind];
+  const state = installer.isInstalled(kind) ? "launcher installed" : existsSync7(definition.appBundle) ? "not installed" : "app not found";
+  return `  ${kind.padEnd(KIND_WIDTH)} ${definition.appName.padEnd(30)} ${state}`;
+}
+var IDE_COMMAND = {
+  name: "ide",
+  aliases: ["editor"],
+  usage: `dario ide <${IDE_KINDS.join("|")}>`,
+  description: "Install the launcher extension into a VS Code-style IDE and open the game in its integrated terminal from now on.",
+  async execute(args) {
+    const installer = new IdeInstaller();
+    const value = (args[0] ?? "").toLowerCase().replaceAll("-", "_");
+    if (value.length === 0) {
+      IDE_KINDS.forEach((kind) => console.log(describeIde(kind, installer)));
+      return 0;
+    }
+    if (!isIdeKind(value)) {
+      console.error(`Unknown IDE "${value}". Options: ${IDE_KINDS.join(", ")}`);
+      return 1;
+    }
+    try {
+      const report = installer.install(value);
+      new ConfigStore({ path: DARIO_PATHS.configFile }).update({ terminal: value });
+      console.log(`Installed ${report.vsix} into ${IDE_DEFINITIONS[value].appName} via ${report.cli}.
+Terminal preference is now "${value}": the game opens in ${IDE_DEFINITIONS[value].appName}'s integrated terminal.`);
+      return 0;
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      return 1;
+    }
+  }
+};
+
+// src/claude/claude_hooks_installer.ts
+var CLAUDE_HOOK_BINDINGS = {
+  UserPromptSubmit: { script: "user_prompt_submit.sh" },
+  Stop: { script: "stop.sh" },
+  Notification: { script: "notification.sh" },
+  PreToolUse: { script: "pre_tool_use.sh" },
+  PostToolUse: { script: "post_tool_use.sh" }
+};
+var ClaudeHooksInstaller = class extends HookSettingsInstaller {
+  constructor({ settingsPath, hooksDir }) {
+    super({ settingsPath, hooksDir, bindings: CLAUDE_HOOK_BINDINGS });
+  }
+};
+
+// src/install/symlink_installer.ts
+import { existsSync as existsSync8, lstatSync, mkdirSync as mkdirSync5, readlinkSync, symlinkSync, unlinkSync as unlinkSync2 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+var SymlinkInstaller = class {
+  install({ linkPath, target }) {
+    if (this.pointsTo({ linkPath, target })) return "already_linked";
+    if (this.isSymlink(linkPath)) unlinkSync2(linkPath);
+    else if (existsSync8(linkPath)) return "skipped_existing_path";
+    mkdirSync5(dirname5(linkPath), { recursive: true });
+    symlinkSync(target, linkPath);
+    return "created";
+  }
+  uninstall({ linkPath, target }) {
+    if (!this.pointsTo({ linkPath, target })) return "absent";
+    unlinkSync2(linkPath);
+    return "removed";
+  }
+  isSymlink(path) {
+    try {
+      return lstatSync(path).isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }
+  pointsTo({ linkPath, target }) {
+    if (!this.isSymlink(linkPath)) return false;
+    return readlinkSync(linkPath) === target;
+  }
+};
+
+// src/install/dario_installer.ts
+var DarioInstaller = class {
+  hooks;
+  agents = new AgentHooksInstaller();
+  symlinks = new SymlinkInstaller();
+  constructor() {
+    this.hooks = new ClaudeHooksInstaller({ settingsPath: DARIO_PATHS.claudeSettingsFile, hooksDir: DARIO_PATHS.hooksDir });
+  }
+  isInstalled() {
+    return this.hooks.isInstalled();
+  }
+  install() {
+    this.hooks.install();
+    return {
+      hooks: "installed",
+      agents: this.agents.installAvailable(),
+      skill: this.symlinks.install({ linkPath: DARIO_PATHS.claudeSkillLink, target: DARIO_PATHS.skillDir }),
+      bin: this.symlinks.install({ linkPath: DARIO_PATHS.localBinLink, target: DARIO_PATHS.binFile })
+    };
+  }
+  uninstall() {
+    this.hooks.uninstall();
+    return {
+      hooks: "removed",
+      agents: this.agents.uninstallAll(),
+      skill: this.symlinks.uninstall({ linkPath: DARIO_PATHS.claudeSkillLink, target: DARIO_PATHS.skillDir }),
+      bin: this.symlinks.uninstall({ linkPath: DARIO_PATHS.localBinLink, target: DARIO_PATHS.binFile })
+    };
+  }
+};
+
+// src/install/relocate_npx_install.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { cpSync, mkdirSync as mkdirSync6, rmSync as rmSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join5 } from "node:path";
+var NPX_CACHE_MARKER = "/_npx/";
+var STABLE_HOME = join5(homedir3(), ".dario", "app");
+function isNpxCacheInstall(rootDir = DARIO_PATHS.rootDir) {
+  return rootDir.includes(NPX_CACHE_MARKER);
+}
+function relocateNpxInstall({ args }) {
+  const staging = `${STABLE_HOME}.new`;
+  rmSync2(staging, { recursive: true, force: true });
+  mkdirSync6(staging, { recursive: true });
+  cpSync(DARIO_PATHS.rootDir, staging, { recursive: true, dereference: true });
+  rmSync2(STABLE_HOME, { recursive: true, force: true });
+  cpSync(staging, STABLE_HOME, { recursive: true });
+  rmSync2(staging, { recursive: true, force: true });
+  console.log(`Copied Dario to ${STABLE_HOME} (npx runs from a cache that gets pruned).`);
+  const result = spawnSync4(join5(STABLE_HOME, "bin", "dario"), ["install", ...args], { stdio: "inherit" });
+  return result.status ?? 1;
+}
+
+// src/player/ask_launch_target.ts
+import { createInterface } from "node:readline/promises";
+
+// src/launcher/launch_targets.ts
+import { existsSync as existsSync9 } from "node:fs";
+var NEW_TAB_TERMINALS = /* @__PURE__ */ new Set(["warp", "iterm"]);
+var IDE_HOW = "integrated terminal";
+function describeHow(kind, isIde) {
+  if (isIde) return IDE_HOW;
+  return NEW_TAB_TERMINALS.has(kind) ? "new tab" : "new window";
+}
+function listLaunchTargets({ env = process.env } = {}) {
+  const detected = detectTerminal({ env, preferred: "auto" });
+  const terminals = [...INSTALL_PREFERENCE.filter(isBundleInstalled), "apple_terminal"];
+  const ides = IDE_KINDS.filter((kind) => existsSync9(IDE_DEFINITIONS[kind].appBundle));
+  const describe = (kind, isIde, needsExtension) => ({
+    kind,
+    label: `${TERMINAL_APP_NAMES[kind]} (${describeHow(kind, isIde)}${needsExtension ? ", installs a tiny extension" : ""})`,
+    isDetected: kind === detected,
+    needsExtension
+  });
+  return [...terminals.map((kind) => describe(kind, false, false)), ...ides.map((kind) => describe(kind, true, !isIdeLauncherInstalled(kind)))];
+}
+
+// src/render/palette.ts
+var PALETTE = {
+  claudeOrange: { r: 217, g: 119, b: 87 },
+  mascotDead: { r: 120, g: 120, b: 125 },
+  token: { r: 245, g: 196, b: 66 },
+  tokenShine: { r: 255, g: 240, b: 180 },
+  tokenDark: { r: 190, g: 140, b: 30 },
+  bug: { r: 226, g: 75, b: 74 },
+  bugDark: { r: 120, g: 30, b: 30 },
+  wall: { r: 150, g: 150, b: 160 },
+  wallMortar: { r: 85, g: 85, b: 95 },
+  ghost: { r: 168, g: 120, b: 230 },
+  ghostEye: { r: 245, g: 245, b: 255 },
+  ground: { r: 110, g: 110, b: 120 },
+  speck: { r: 65, g: 65, b: 75 },
+  brick: { r: 158, g: 78, b: 46 },
+  brickMortar: { r: 74, g: 32, b: 22 },
+  blockYellow: { r: 245, g: 196, b: 66 },
+  blockYellowDim: { r: 200, g: 150, b: 40 },
+  blockYellowBright: { r: 255, g: 230, b: 150 },
+  blockShadow: { r: 176, g: 112, b: 28 },
+  blockUsed: { r: 140, g: 92, b: 60 },
+  blockUsedEdge: { r: 82, g: 48, b: 30 },
+  pipeGreen: { r: 72, g: 180, b: 72 },
+  pipeDark: { r: 28, g: 96, b: 32 },
+  pipeLight: { r: 150, g: 230, b: 150 },
+  cloud: { r: 236, g: 238, b: 246 },
+  cloudShade: { r: 168, g: 174, b: 192 },
+  hill: { r: 60, g: 150, b: 70 },
+  hillDark: { r: 34, g: 98, b: 46 },
+  mushroomRed: { r: 226, g: 60, b: 60 },
+  mushroomStem: { r: 245, g: 222, b: 184 },
+  heartLight: { r: 255, g: 160, b: 170 },
+  titlePanel: { r: 200, g: 76, b: 12 },
+  titleInk: { r: 252, g: 188, b: 176 },
+  titleShadow: { r: 24, g: 12, b: 8 },
+  text: { r: 205, g: 205, b: 215 },
+  textDim: { r: 120, g: 120, b: 130 },
+  success: { r: 90, g: 200, b: 120 },
+  warning: { r: 245, g: 196, b: 66 },
+  working: { r: 120, g: 170, b: 255 },
+  danger: { r: 226, g: 75, b: 74 }
+};
+
+// src/player/ask_launch_target.ts
+function createTerminalQuestion() {
+  const readline = createInterface({ input: process.stdin, output: process.stdout });
+  return { ask: (prompt) => readline.question(prompt), close: () => readline.close() };
+}
+function renderMenu(targets) {
+  const lines = targets.map((target, i) => {
+    const marker = target.isDetected ? `  ${ANSI.fg(PALETTE.success)}\u2190 detected${ANSI.reset}` : "";
+    return `  ${ANSI.bold}${i + 1})${ANSI.reset} ${target.label}${marker}`;
+  });
+  return [`${ANSI.fg(PALETTE.claudeOrange)}${ANSI.bold}Where should Dario open when you send a prompt?${ANSI.reset}`, ...lines].join("\n");
+}
+function pickDefault(targets) {
+  const detected = targets.findIndex((target) => target.isDetected);
+  return detected >= 0 ? detected : 0;
+}
+async function askLaunchTarget(question = null, targets = listLaunchTargets()) {
+  const terminal = question === null ? createTerminalQuestion() : { ask: question, close: () => {
+  } };
+  try {
+    console.log(renderMenu(targets));
+    const fallback = pickDefault(targets);
+    const answer = (await terminal.ask(`Choice [${fallback + 1}]: `)).trim();
+    const index = answer.length === 0 ? fallback : Number.parseInt(answer, 10) - 1;
+    const chosen = targets[index] ?? targets[fallback] ?? { kind: "apple_terminal", label: "", isDetected: false, needsExtension: false };
+    if (chosen.needsExtension && isIdeKind(chosen.kind)) new IdeInstaller().install(chosen.kind);
+    console.log(`Dario will open in ${chosen.label.split(" (")[0]}. Change it any time with "dario terminal <name>" or the in-game settings (C).`);
+    return chosen.kind;
+  } finally {
+    terminal.close();
+  }
+}
+
+// src/player/ask_player_name.ts
+import { createInterface as createInterface2 } from "node:readline/promises";
+
+// src/player/player_name.ts
+var MIN_LENGTH = 2;
+var MAX_LENGTH = 20;
+var ALLOWED_PATTERN = /^[\p{L}\p{N} _.-]+$/u;
+var PlayerName = class _PlayerName {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  static create(raw) {
+    const trimmed = raw.trim().replace(/\s+/g, " ");
+    if (trimmed.length < MIN_LENGTH || trimmed.length > MAX_LENGTH) throw new Error(`Name must be ${MIN_LENGTH}-${MAX_LENGTH} characters.`);
+    if (!ALLOWED_PATTERN.test(trimmed)) throw new Error('Name may only contain letters, digits, spaces, "_", "." or "-".');
+    return new _PlayerName(trimmed);
+  }
+  static isValid(raw) {
+    try {
+      _PlayerName.create(raw);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/player/ask_player_name.ts
+var YES_ANSWERS = /* @__PURE__ */ new Set(["", "y", "yes", "e", "evet"]);
+var SOURCE_LABELS = {
+  github: "GitHub",
+  git: "git config",
+  system: "system user"
+};
+function createTerminalQuestion2() {
+  const readline = createInterface2({ input: process.stdin, output: process.stdout });
+  return { ask: (prompt) => readline.question(prompt), close: () => readline.close() };
+}
+async function askUntilValid(ask) {
+  const answer = await ask("Your name: ");
+  if (PlayerName.isValid(answer)) return PlayerName.create(answer);
+  console.log(`${ANSI.fg(PALETTE.danger)}2-20 characters: letters, digits, spaces, "_", "." or "-".${ANSI.reset}`);
+  return askUntilValid(ask);
+}
+async function askPlayerName(detected, question = null) {
+  const terminal = question === null ? createTerminalQuestion2() : { ask: question, close: () => {
+  } };
+  try {
+    const highlighted = `${ANSI.fg(PALETTE.claudeOrange)}${ANSI.bold}${detected.name}${ANSI.reset}`;
+    const answer = await terminal.ask(`Play as (${highlighted}) from ${SOURCE_LABELS[detected.source]}? [Y/n] `);
+    if (YES_ANSWERS.has(answer.trim().toLowerCase())) return PlayerName.create(detected.name);
+    return askUntilValid(terminal.ask);
+  } finally {
+    terminal.close();
+  }
+}
+
+// src/player/detect_player_name.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { userInfo } from "node:os";
+var COMMAND_TIMEOUT_MS = 3e3;
+function runCommand(executable, args) {
+  const result = spawnSync5(executable, [...args], { encoding: "utf8", timeout: COMMAND_TIMEOUT_MS });
+  return result.status === 0 ? result.stdout.trim() : "";
+}
+function detectPlayerName(run = runCommand) {
+  const candidates = [
+    { name: run("gh", ["api", "user", "--jq", ".login"]), source: "github" },
+    { name: run("git", ["config", "--global", "user.name"]), source: "git" },
+    { name: userInfo().username, source: "system" }
+  ];
+  const found = candidates.find((candidate) => PlayerName.isValid(candidate.name));
+  return found ?? { name: "player", source: "system" };
+}
+
+// src/player/run_first_run_setup.ts
+async function runFirstRunSetup({ force = false } = {}) {
+  const store = new ConfigStore({ path: DARIO_PATHS.configFile });
+  const config = store.load();
+  if (config.isSetupDone && !force || !process.stdin.isTTY) return;
+  const name = PlayerName.isValid(config.playerName) && !force ? PlayerName.create(config.playerName) : await askPlayerName(detectPlayerName());
+  const terminal = await askLaunchTarget();
+  store.update({ playerName: name.value, terminal, isSetupDone: true });
+}
+
+// src/cli/commands/install_command.ts
+function describeReport(report) {
+  return [
+    `  claude hooks   ${report.hooks} (${DARIO_PATHS.claudeSettingsFile})`,
+    ...describeAgentReports(report.agents),
+    `  skill link     ${report.skill} (${DARIO_PATHS.claudeSkillLink})`,
+    `  dario command  ${report.bin} (${DARIO_PATHS.localBinLink})`
+  ].join("\n");
+}
+function describeNotes(reports) {
+  const agents = new AgentHooksInstaller();
+  return reports.filter((report) => report.state === "installed").map((report) => `  ${report.label}: ${agents.getNote(report.kind)}`);
+}
+var INSTALL_COMMAND = {
+  name: "install",
+  aliases: ["setup"],
+  usage: "dario install [--setup]",
+  description: "Install the Claude Code hooks (plus Codex / Grok hooks when found), the /dario skill and the dario command.",
+  async execute(args) {
+    if (isNpxCacheInstall()) return relocateNpxInstall({ args });
+    const report = new DarioInstaller().install();
+    console.log(`Dario installed
+${describeReport(report)}`);
+    describeNotes(report.agents).forEach((note) => console.log(note));
+    await runFirstRunSetup({ force: args.includes("--setup") });
+    console.log('\nFrom now on every prompt you send to Claude Code opens Dario in a new terminal. Use "dario off" to pause that, "dario agents" for Codex / Grok.');
+    return 0;
+  }
+};
+
+// src/cli/commands/launch_command.ts
+var LAUNCH_COMMAND = {
+  name: "launch",
+  aliases: ["open", "new"],
+  usage: "dario launch [--as claude|codex|grok]",
+  description: "Open Dario in a new terminal tab/window and start playing.",
+  async execute(args) {
+    const lock = new ProcessLock({ path: DARIO_PATHS.pidFile });
+    if (lock.isHeld()) {
+      console.log(`Dario is already running (pid ${lock.readPid()}).`);
+      return 0;
+    }
+    const config = new ConfigStore({ path: DARIO_PATHS.configFile }).load();
+    const agent = resolveAgent({ args, configured: config.character, env: process.env });
+    const result = new TerminalLauncher().launch({ preferred: config.terminal, agent, lock });
+    const note = result.kind !== config.terminal && config.terminal !== "auto" ? ` (${config.terminal} did not open the game; reload the IDE window and allow the Dario Launcher URI)` : "";
+    console.log(`Opened Dario in ${result.kind}${note}.`);
+    return 0;
+  }
+};
+
+// src/game/game_mode_labels.ts
+var GAME_MODE_LABELS = { vibe: "VIBE CODER", pro: "PRO CODER" };
+
+// src/cli/commands/mode_command.ts
+var MODES = ["vibe", "pro"];
+function isGameMode(value) {
+  return MODES.includes(value);
+}
+var MODE_COMMAND = {
+  name: "mode",
+  aliases: [],
+  usage: `dario mode <${MODES.join("|")}>`,
+  description: `Game mode: ${GAME_MODE_LABELS.vibe} plays any time (default), ${GAME_MODE_LABELS.pro} only while Claude/Codex/Grok is working.`,
+  async execute(args) {
+    const store = new ConfigStore({ path: DARIO_PATHS.configFile });
+    const value = (args[0] ?? "").toLowerCase();
+    if (value.length === 0) {
+      console.log(`Mode: ${GAME_MODE_LABELS[store.load().mode]}`);
+      return 0;
+    }
+    if (!isGameMode(value)) {
+      console.error(`Unknown mode "${value}". Options: ${MODES.join(", ")}`);
+      return 1;
+    }
+    console.log(`Mode is now ${GAME_MODE_LABELS[store.update({ mode: value }).mode]}.`);
+    return 0;
+  }
+};
+
+// src/cli/commands/name_command.ts
+var DETECT_FLAG = "--detect";
+async function chooseName(args) {
+  if (args[0] === DETECT_FLAG) return askPlayerName(detectPlayerName());
+  return PlayerName.create(args.join(" "));
+}
+var NAME_COMMAND = {
+  name: "name",
+  aliases: ["player", "whoami"],
+  usage: "dario name [<new name> | --detect]",
+  description: "Show or change the name used on the leaderboard (--detect re-reads GitHub/git).",
+  async execute(args) {
+    const store = new ConfigStore({ path: DARIO_PATHS.configFile });
+    if (args.length === 0) {
+      const current = store.load().playerName;
+      console.log(current.length === 0 ? 'No name yet: it will be asked on the first "dario play".' : `Playing as ${current}.`);
+      return 0;
+    }
+    try {
+      const chosen = await chooseName(args);
+      store.update({ playerName: chosen.value });
+      console.log(`Playing as ${chosen.value}.`);
+      return 0;
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      return 1;
+    }
+  }
+};
+
+// src/claude/claude_status_watcher.ts
+var ClaudeStatusWatcher = class {
+  file;
+  current;
+  lastSeenAt;
+  constructor({ path }) {
+    this.file = new JsonFile({ path, fallback: null });
+    this.current = this.file.read();
+    this.lastSeenAt = this.current?.updatedAt ?? 0;
+  }
+  getCurrent() {
+    return this.current;
+  }
+  pollChange() {
+    const record = this.file.read();
+    if (record === null || record.updatedAt === this.lastSeenAt) return null;
+    this.lastSeenAt = record.updatedAt;
+    this.current = record;
+    return record;
+  }
+};
+
+// src/input/composite_input.ts
+var CompositeInput = class {
+  sources;
+  constructor(sources) {
+    this.sources = sources;
+  }
+  start(handler) {
+    this.sources.forEach((source) => source.start(handler));
+  }
+  stop() {
+    this.sources.forEach((source) => source.stop());
+  }
+};
+
+// src/input/key_state_watcher.ts
+import { spawn as spawn2 } from "node:child_process";
+
+// src/input/key_state_script.ts
+var KEY_STATE_SCRIPT = [
+  "import ctypes, os, sys, time",
+  "cg = ctypes.cdll.LoadLibrary('/System/Library/Frameworks/CoreGraphics.framework/CoreGraphics')",
+  "cg.CGEventSourceKeyState.restype = ctypes.c_bool",
+  "cg.CGEventSourceKeyState.argtypes = [ctypes.c_int32, ctypes.c_uint16]",
+  "KEYS = {'R': (124, 2), 'L': (123, 0)}",
+  "prev = {k: False for k in KEYS}",
+  "parent = os.getppid()",
+  "tick = 0",
+  "while True:",
+  "    for name, codes in KEYS.items():",
+  "        down = any(cg.CGEventSourceKeyState(1, c) for c in codes)",
+  "        if down != prev[name]:",
+  "            prev[name] = down",
+  "            sys.stdout.write(f'{name}{1 if down else 0}\\n')",
+  "            sys.stdout.flush()",
+  "    tick += 1",
+  "    if tick % 60 == 0 and os.getppid() != parent:",
+  "        sys.exit(0)",
+  "    time.sleep(0.016)"
+].join("\n");
+
+// src/input/parse_key_state_line.ts
+var RELEASE_BY_KEY = { R: "right_release", L: "left_release" };
+function parseKeyStateLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.length !== 2 || trimmed.charAt(1) !== "0") return null;
+  return RELEASE_BY_KEY[trimmed.charAt(0)] ?? null;
+}
+
+// src/input/key_state_watcher.ts
+var PYTHON = "python3";
+var KeyStateWatcher = class {
+  child = null;
+  handler = null;
+  hasAnnounced = false;
+  buffer = "";
+  start(handler) {
+    this.handler = handler;
+    try {
+      this.child = spawn2(PYTHON, ["-c", KEY_STATE_SCRIPT], { stdio: ["ignore", "pipe", "ignore"] });
+      this.child.stdout?.setEncoding("utf8");
+      this.child.stdout?.on("data", (chunk) => this.consume(chunk));
+      this.child.on("error", () => {
+        this.child = null;
+      });
+    } catch {
+      this.child = null;
+    }
+  }
+  stop() {
+    this.handler = null;
+    this.child?.kill();
+    this.child = null;
+  }
+  consume(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    lines.forEach((line) => this.emitLine(line));
+  }
+  emitLine(line) {
+    const action = parseKeyStateLine(line);
+    if (action === null || this.handler === null) return;
+    if (!this.hasAnnounced) {
+      this.hasAnnounced = true;
+      this.handler("hold_reliable");
+    }
+    this.handler(action);
+  }
+};
+
+// src/input/keyboard.ts
+var ESCAPE = "\x1B";
+var CONTROL_C = "";
+var RELEASE_EVENT = 3;
+var TOKEN_PATTERN = /\u001b\[[0-9;:?]*[A-Za-z~]|\u001bO[A-Za-z]|[\s\S]/gu;
+var CSI_PATTERN = /^\u001b\[([0-9;:?]*)([A-Za-z~])$/u;
+var INCOMPLETE_PATTERN = /(?:\u001bO|\u001b\[[0-9;:?]*|\u001b)$/u;
+var INCOMPLETE_FLUSH_MS = 40;
+var KEY_BY_CHAR = {
+  " ": "jump",
+  w: "jump",
+  k: "jump",
+  s: "duck",
+  j: "duck",
+  d: "right",
+  l: "right",
+  a: "left",
+  h: "left",
+  p: "pause",
+  r: "restart",
+  q: "quit",
+  c: "settings",
+  [ESCAPE]: "quit",
+  [CONTROL_C]: "quit"
+};
+var KEY_BY_ARROW = { A: "up", B: "down", C: "right", D: "left" };
+var RELEASE_BY_ACTION = { left: "left_release", right: "right_release" };
+function parseCsi(params, final) {
+  if (params.startsWith("?") && final === "u") return null;
+  const [, modifiersAndEvent = ""] = params.split(";");
+  const isRelease = Number.parseInt(modifiersAndEvent.split(":")[1] ?? "1", 10) === RELEASE_EVENT;
+  if (final === "u") {
+    const code = Number.parseInt(params, 10);
+    const action = KEY_BY_CHAR[String.fromCodePoint(Number.isNaN(code) ? 0 : code)];
+    return action === void 0 ? null : { action, isRelease };
+  }
+  const arrow = KEY_BY_ARROW[final];
+  return arrow === void 0 ? null : { action: arrow, isRelease };
+}
+function parseToken(token) {
+  const csi = CSI_PATTERN.exec(token);
+  if (csi !== null) return parseCsi(csi[1] ?? "", csi[2] ?? "");
+  if (token.startsWith(`${ESCAPE}O`)) return parseCsi("", token.slice(2));
+  const action = KEY_BY_CHAR[token] ?? KEY_BY_CHAR[token.toLowerCase()];
+  return action === void 0 ? null : { action, isRelease: false };
+}
+var Keyboard = class {
+  input;
+  handler = null;
+  pending = "";
+  flushTimer = null;
+  hasSeenRelease = false;
+  onData = (chunk) => this.dispatch(chunk);
+  constructor(input = process.stdin) {
+    this.input = input;
+  }
+  start(handler) {
+    this.handler = handler;
+    if (this.input.isTTY) this.input.setRawMode(true);
+    this.input.setEncoding("utf8");
+    this.input.on("data", this.onData);
+    this.input.resume();
+  }
+  stop() {
+    this.handler = null;
+    if (this.flushTimer !== null) clearTimeout(this.flushTimer);
+    this.input.off("data", this.onData);
+    if (this.input.isTTY) this.input.setRawMode(false);
+    this.input.pause();
+  }
+  /** Feed raw terminal bytes; an unfinished escape at the end waits briefly for the rest (so ESC alone still quits). */
+  dispatch(chunk) {
+    if (this.flushTimer !== null) clearTimeout(this.flushTimer);
+    const data = this.pending + chunk;
+    const incomplete = INCOMPLETE_PATTERN.exec(data);
+    const complete = incomplete === null ? data : data.slice(0, incomplete.index);
+    this.pending = incomplete === null ? "" : incomplete[0];
+    this.emitTokens(complete);
+    if (this.pending.length > 0) this.flushTimer = setTimeout(() => this.flush(), INCOMPLETE_FLUSH_MS);
+  }
+  /** Give up waiting for a continuation: whatever is buffered is parsed as-is. */
+  flush() {
+    const data = this.pending;
+    this.pending = "";
+    this.flushTimer = null;
+    this.emitTokens(data);
+  }
+  emitTokens(data) {
+    const tokens = data.match(TOKEN_PATTERN) ?? [];
+    tokens.forEach((token) => this.emitParsed(parseToken(token)));
+  }
+  emitParsed(parsed) {
+    if (parsed === null) return;
+    if (parsed === "hold_support") return this.emit("hold_support");
+    if (!parsed.isRelease) return this.emit(parsed.action);
+    this.announceReleaseSupport();
+    const release = RELEASE_BY_ACTION[parsed.action];
+    if (release !== void 0) this.emit(release);
+  }
+  /** Hold mode is enabled by proof, not promise: the first real release event we see. */
+  announceReleaseSupport() {
+    if (this.hasSeenRelease) return;
+    this.hasSeenRelease = true;
+    this.emit("hold_support");
+  }
+  emit(action) {
+    if (this.handler !== null) this.handler(action);
+  }
+};
+
+// src/config/firebase_config.ts
+var FIREBASE_CONFIG = {
+  projectId: "dario-xxx",
+  apiKey: "AIzaSyBt3-mnnah4A8CSIlt2fw0kJ0MveRurJq0",
+  playersCollection: "players",
+  sponsorsCollection: "sponsors",
+  siteUrl: "https://dario-xxx.web.app",
+  requestTimeoutMs: 6e3
+};
+
+// src/ranking/http_json.ts
+async function httpJson({ url, method, body, token, timeoutMs, fetchFn = fetch }) {
+  const headers = { "Content-Type": "application/json" };
+  if (token !== void 0) headers.Authorization = `Bearer ${token}`;
+  const response = await fetchFn(url, { method, headers, body: body === void 0 ? void 0 : JSON.stringify(body), signal: AbortSignal.timeout(timeoutMs) });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(payload.error?.message ?? `HTTP ${response.status}`);
+  return payload;
+}
+
+// src/ranking/firebase_anonymous_auth.ts
+var SIGN_UP_URL = "https://identitytoolkit.googleapis.com/v1/accounts:signUp";
+var REFRESH_URL = "https://securetoken.googleapis.com/v1/token";
+var EXPIRY_MARGIN_MS = 6e4;
+var MS_PER_SECOND2 = 1e3;
+var FirebaseAnonymousAuth = class {
+  apiKey;
+  file;
+  timeoutMs;
+  fetchFn;
+  now;
+  constructor({ apiKey, file, timeoutMs, fetchFn = fetch, now = Date.now }) {
+    this.apiKey = apiKey;
+    this.file = file;
+    this.timeoutMs = timeoutMs;
+    this.fetchFn = fetchFn;
+    this.now = now;
+  }
+  getUid() {
+    return this.file.read()?.uid ?? null;
+  }
+  async getSession() {
+    const saved = this.file.read();
+    if (saved === null) return this.signUp();
+    if (saved.expiresAt - EXPIRY_MARGIN_MS > this.now()) return saved;
+    return this.refresh(saved);
+  }
+  async signUp() {
+    const url = `${SIGN_UP_URL}?key=${this.apiKey}`;
+    const response = await httpJson({ url, method: "POST", body: { returnSecureToken: true }, timeoutMs: this.timeoutMs, fetchFn: this.fetchFn });
+    return this.save({ uid: response.localId, idToken: response.idToken, refreshToken: response.refreshToken, expiresIn: response.expiresIn });
+  }
+  async refresh(saved) {
+    const url = `${REFRESH_URL}?key=${this.apiKey}`;
+    const body = { grant_type: "refresh_token", refresh_token: saved.refreshToken };
+    const response = await httpJson({ url, method: "POST", body, timeoutMs: this.timeoutMs, fetchFn: this.fetchFn });
+    return this.save({ uid: response.user_id, idToken: response.id_token, refreshToken: response.refresh_token, expiresIn: response.expires_in });
+  }
+  save({ uid, idToken, refreshToken, expiresIn }) {
+    const record = { uid, idToken, refreshToken, expiresAt: this.now() + Number.parseInt(expiresIn, 10) * MS_PER_SECOND2 };
+    this.file.write(record);
+    return record;
+  }
+};
+
+// src/ranking/decode_firestore_fields.ts
+function decodeValue(value) {
+  if ("integerValue" in value) return Number.parseInt(value.integerValue, 10);
+  if ("doubleValue" in value) return value.doubleValue;
+  if ("booleanValue" in value) return value.booleanValue;
+  if ("timestampValue" in value) return value.timestampValue;
+  if ("nullValue" in value) return null;
+  if ("arrayValue" in value) return (value.arrayValue.values ?? []).map(decodeValue);
+  if ("mapValue" in value) return decodeFirestoreFields(value.mapValue.fields);
+  return value.stringValue;
+}
+function decodeFirestoreFields(fields) {
+  return Object.fromEntries(Object.entries(fields ?? {}).map(([key, value]) => [key, decodeValue(value)]));
+}
+
+// src/ranking/encode_firestore_fields.ts
+function encodeValue(value) {
+  if (value instanceof Date) return { timestampValue: value.toISOString() };
+  if (typeof value === "boolean") return { booleanValue: value };
+  if (typeof value === "number") return { integerValue: String(Math.trunc(value)) };
+  return { stringValue: value };
+}
+function encodeFirestoreFields(data) {
+  return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, encodeValue(value)]));
+}
+
+// src/ranking/firestore_client.ts
+var BASE_URL = "https://firestore.googleapis.com/v1";
+function buildStructuredQuery({ collection, where, orderByDescending, limit }) {
+  return {
+    from: [{ collectionId: collection }],
+    ...where === void 0 ? {} : { where: { fieldFilter: { field: { fieldPath: where.field }, op: "EQUAL", value: { stringValue: where.equals } } } },
+    ...orderByDescending === void 0 ? {} : { orderBy: [{ field: { fieldPath: orderByDescending }, direction: "DESCENDING" }] },
+    limit
+  };
+}
+var FirestoreClient = class {
+  documentsUrl;
+  timeoutMs;
+  fetchFn;
+  constructor({ projectId, timeoutMs, fetchFn = fetch }) {
+    this.documentsUrl = `${BASE_URL}/projects/${projectId}/databases/(default)/documents`;
+    this.timeoutMs = timeoutMs;
+    this.fetchFn = fetchFn;
+  }
+  /** PATCH with an update mask both creates and updates, so security rules see the merged document. */
+  async upsert({ collection, documentId, data, token }) {
+    const mask = Object.keys(data).map((key) => `updateMask.fieldPaths=${encodeURIComponent(key)}`).join("&");
+    const url = `${this.documentsUrl}/${collection}/${encodeURIComponent(documentId)}?${mask}`;
+    await httpJson({ url, method: "PATCH", body: { fields: encodeFirestoreFields(data) }, token, timeoutMs: this.timeoutMs, fetchFn: this.fetchFn });
+  }
+  async query(input) {
+    const structuredQuery = buildStructuredQuery(input);
+    const rows = await httpJson({ url: `${this.documentsUrl}:runQuery`, method: "POST", body: { structuredQuery }, timeoutMs: this.timeoutMs, fetchFn: this.fetchFn });
+    return rows.filter((row) => row.document !== void 0).map((row) => toDocument(row.document));
+  }
+  async top({ collection, orderBy, limit }) {
+    return this.query({ collection, orderByDescending: orderBy, limit });
+  }
+  async countAbove({ collection, field, value }) {
+    const where = { fieldFilter: { field: { fieldPath: field }, op: "GREATER_THAN", value: { integerValue: String(Math.trunc(value)) } } };
+    const structuredAggregationQuery = { structuredQuery: { from: [{ collectionId: collection }], where }, aggregations: [{ count: {}, alias: "above" }] };
+    const rows = await httpJson({ url: `${this.documentsUrl}:runAggregationQuery`, method: "POST", body: { structuredAggregationQuery }, timeoutMs: this.timeoutMs, fetchFn: this.fetchFn });
+    const aggregate = rows[0]?.result?.aggregateFields?.above;
+    return aggregate !== void 0 && "integerValue" in aggregate ? Number.parseInt(aggregate.integerValue, 10) : 0;
+  }
+};
+function toDocument(raw) {
+  return { id: raw.name.slice(raw.name.lastIndexOf("/") + 1), data: decodeFirestoreFields(raw.fields) };
+}
+
+// src/ranking/leaderboard_service.ts
+var SCORE_FIELDS = { vibe: "highScore", pro: "proHighScore" };
+var DEFAULT_TOP_LIMIT = 10;
+var DEFAULT_MODE = "vibe";
+function toEntry({ document, mode }) {
+  return {
+    uid: document.id,
+    name: String(document.data.name ?? "?"),
+    highScore: Number(document.data[SCORE_FIELDS[mode]] ?? 0),
+    bestTokens: Number(document.data.bestTokens ?? 0),
+    gamesPlayed: Number(document.data.gamesPlayed ?? 0)
+  };
+}
+var LeaderboardService = class {
+  auth;
+  firestore;
+  collection;
+  constructor({ auth, firestore, collection }) {
+    this.auth = auth;
+    this.firestore = firestore;
+    this.collection = collection;
+  }
+  async submit({ name, record, mode = DEFAULT_MODE }) {
+    const session = await this.auth.getSession();
+    const data = { name, highScore: record.highScore, proHighScore: record.proHighScore, bestTokens: record.bestTokens, gamesPlayed: record.gamesPlayed, updatedAt: /* @__PURE__ */ new Date() };
+    await this.firestore.upsert({ collection: this.collection, documentId: session.uid, data, token: session.idToken });
+    const score = mode === "pro" ? record.proHighScore : record.highScore;
+    return this.buildResult({ limit: DEFAULT_TOP_LIMIT, uid: session.uid, score, mode });
+  }
+  /** Rank inside the top list is its position; outside it (with a known score) it is "players above me" + 1. */
+  async fetchRanking({ limit, mode = DEFAULT_MODE, score = 0 }) {
+    const uid = this.auth.getUid() ?? "";
+    const top = await this.fetchTop({ limit, mode });
+    const mine = top.find((entry) => entry.uid === uid);
+    if (mine !== void 0) return { top, uid, rank: top.indexOf(mine) + 1 };
+    if (uid.length === 0 || score <= 0) return { top, uid, rank: null };
+    const above = await this.firestore.countAbove({ collection: this.collection, field: SCORE_FIELDS[mode], value: score });
+    return { top, uid, rank: above + 1 };
+  }
+  async buildResult({ limit, uid, score, mode }) {
+    const [top, above] = await Promise.all([this.fetchTop({ limit, mode }), this.firestore.countAbove({ collection: this.collection, field: SCORE_FIELDS[mode], value: score })]);
+    return { top, uid, rank: above + 1 };
+  }
+  async fetchTop({ limit, mode }) {
+    const documents = await this.firestore.top({ collection: this.collection, orderBy: SCORE_FIELDS[mode], limit });
+    return documents.map((document) => toEntry({ document, mode }));
+  }
+};
+
+// src/ranking/create_leaderboard.ts
+function createLeaderboard() {
+  const auth = new FirebaseAnonymousAuth({
+    apiKey: FIREBASE_CONFIG.apiKey,
+    file: new JsonFile({ path: DARIO_PATHS.authFile, fallback: null }),
+    timeoutMs: FIREBASE_CONFIG.requestTimeoutMs
+  });
+  const firestore = new FirestoreClient({ projectId: FIREBASE_CONFIG.projectId, timeoutMs: FIREBASE_CONFIG.requestTimeoutMs });
+  return new LeaderboardService({ auth, firestore, collection: FIREBASE_CONFIG.playersCollection });
+}
+
+// src/sponsors/parse_sponsor.ts
+var HEX_PATTERN = /^#[0-9a-f]{6}$/i;
+var URL_PATTERN = /^https?:\/\//i;
+var LABEL_MAX = 16;
+var DEFAULT_FG = "#ffffff";
+var DEFAULT_BG = "#d97757";
+var LEGACY_TIERS = { token: "mystery", billboard: "banner" };
+function readTier(value) {
+  if (value === "mystery" || value === "banner" || value === "ranking") return value;
+  return LEGACY_TIERS[String(value)] ?? null;
+}
+function readRows(value) {
+  if (!Array.isArray(value) || value.length === 0) return null;
+  const rows = value.filter((row) => typeof row === "string");
+  const width = rows[0]?.length ?? 0;
+  return rows.length === value.length && width > 0 && rows.every((row) => row.length === width) ? rows : null;
+}
+function readPalette(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+  const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string" && HEX_PATTERN.test(entry[1]));
+  return entries.length > 0 ? Object.fromEntries(entries) : null;
+}
+function readDays(value) {
+  return Array.isArray(value) ? value.filter((day) => typeof day === "string") : [];
+}
+function parseSponsor(document) {
+  const { data } = document;
+  const style = data.style === "text" ? "text" : "pixel";
+  const tier = readTier(data.tier);
+  const hasNoLogo = style === "text" || tier === "ranking";
+  const rows = readRows(data.rows) ?? (hasNoLogo ? [] : null);
+  const palette = readPalette(data.palette) ?? (hasNoLogo ? {} : null);
+  const url = String(data.url ?? "");
+  const name = String(data.name ?? "").trim();
+  const label = String(data.label ?? name).trim().slice(0, LABEL_MAX);
+  const fg = HEX_PATTERN.test(String(data.fg)) ? String(data.fg) : DEFAULT_FG;
+  const bg = HEX_PATTERN.test(String(data.bg)) ? String(data.bg) : DEFAULT_BG;
+  if (rows === null || palette === null || tier === null || !URL_PATTERN.test(url) || name.length === 0) return null;
+  if (style === "text" && label.length === 0) return null;
+  return { id: document.id, name, url, tier, rows, palette, expiresAt: Number(data.expiresAt ?? 0), style, label, fg, bg, priority: Number(data.priority ?? 0), paidAt: Number(data.paidAt ?? 0), days: readDays(data.days) };
+}
+
+// src/sponsors/sort_sponsors.ts
+function sortSponsors(sponsors) {
+  return [...sponsors].sort((a, b) => b.priority - a.priority || a.paidAt - b.paidAt || a.name.localeCompare(b.name));
+}
+
+// src/sponsors/sponsor_service.ts
+var ACTIVE_STATUS = "active";
+var MAX_SPONSORS = 24;
+var SponsorService = class {
+  firestore;
+  collection;
+  cache;
+  cacheTtlMs;
+  now;
+  constructor({ firestore, collection, cache, cacheTtlMs, now = Date.now }) {
+    this.firestore = firestore;
+    this.collection = collection;
+    this.cache = cache;
+    this.cacheTtlMs = cacheTtlMs;
+    this.now = now;
+  }
+  async loadSponsors() {
+    const cached = this.cache.read();
+    if (cached !== null && this.now() - cached.fetchedAt < this.cacheTtlMs) return this.dropExpired(cached.sponsors);
+    try {
+      const sponsors = await this.fetchActive();
+      this.cache.write({ fetchedAt: this.now(), sponsors });
+      return this.dropExpired(sponsors);
+    } catch {
+      return this.dropExpired(cached?.sponsors ?? []);
+    }
+  }
+  async fetchActive() {
+    const documents = await this.firestore.query({ collection: this.collection, where: { field: "status", equals: ACTIVE_STATUS }, limit: MAX_SPONSORS });
+    return documents.map(parseSponsor).filter((sponsor) => sponsor !== null);
+  }
+  /** Live sponsors in display order: the first token sponsor owns the most blocks, the first banner sits closest to the title. */
+  dropExpired(sponsors) {
+    return sortSponsors(sponsors.filter((sponsor) => sponsor.expiresAt > this.now()));
+  }
+};
+
+// src/sponsors/create_sponsor_service.ts
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+function createSponsorService() {
+  return new SponsorService({
+    firestore: new FirestoreClient({ projectId: FIREBASE_CONFIG.projectId, timeoutMs: FIREBASE_CONFIG.requestTimeoutMs }),
+    collection: FIREBASE_CONFIG.sponsorsCollection,
+    cache: new JsonFile({ path: DARIO_PATHS.sponsorsCacheFile, fallback: null }),
+    cacheTtlMs: CACHE_TTL_MS
+  });
+}
+
+// src/render/terminal_screen.ts
+var FALLBACK_SIZE = { columns: 80, rows: 24 };
+var TerminalScreen = class {
+  output;
+  isActive = false;
+  constructor(output = process.stdout) {
+    this.output = output;
+  }
+  getSize() {
+    return {
+      columns: this.output.columns ?? FALLBACK_SIZE.columns,
+      rows: this.output.rows ?? FALLBACK_SIZE.rows
+    };
+  }
+  enter() {
+    if (this.isActive) return;
+    this.isActive = true;
+    this.output.write(ANSI.enterAltScreen + ANSI.kittyKeyboardOn + ANSI.hideCursor + ANSI.clearScreen + ANSI.home);
+  }
+  exit() {
+    if (!this.isActive) return;
+    this.isActive = false;
+    this.output.write(ANSI.reset + ANSI.showCursor + ANSI.kittyKeyboardOff + ANSI.exitAltScreen);
+  }
+  render(lines) {
+    this.output.write(ANSI.home + lines.join("\r\n"));
+  }
+  onResize(handler) {
+    this.output.on("resize", handler);
+  }
+};
+
+// src/store/score_store.ts
+var EMPTY_RECORD = { highScore: 0, proHighScore: 0, bestTokens: 0, totalTokens: 0, gamesPlayed: 0, lastScore: 0, updatedAt: 0 };
+var ScoreStore = class {
+  file;
+  constructor({ path }) {
+    this.file = new JsonFile({ path, fallback: EMPTY_RECORD });
+  }
+  load() {
+    return { ...EMPTY_RECORD, ...this.file.read() };
+  }
+  /** Each mode keeps its own high score; the rest of the record is shared. */
+  recordGame({ score, tokens, mode = "vibe" }) {
+    const previous = this.load();
+    const next = {
+      highScore: mode === "vibe" ? Math.max(previous.highScore, score) : previous.highScore,
+      proHighScore: mode === "pro" ? Math.max(previous.proHighScore, score) : previous.proHighScore,
+      bestTokens: Math.max(previous.bestTokens, tokens),
+      totalTokens: previous.totalTokens + tokens,
+      gamesPlayed: previous.gamesPlayed + 1,
+      lastScore: score,
+      updatedAt: Date.now()
+    };
+    this.file.write(next);
+    return next;
+  }
+};
+
+// src/config/constants.ts
+var GAME_CONSTANTS = {
+  tickMs: 33,
+  minColumns: 50,
+  minRows: 14,
+  hudRows: 1,
+  groundMarginRows: 2,
+  footerRows: 1,
+  playerX: 28,
+  playerMinX: 2,
+  walkSpeed: 0.8,
+  moveHoldTicks: 14,
+  moveRepeatTicks: 6,
+  moveRepeatWindowTicks: 10,
+  holdHeartbeatTicks: 90,
+  bugWalkSpeed: 0.35,
+  ghostFlySpeed: 0.55,
+  powerUpWalkSpeed: 0.3,
+  rankingPanelColumn: 1,
+  rankingPanelLimit: 10,
+  gravity: 0.4,
+  jumpVelocity: 5,
+  fastFallVelocity: -3,
+  baseSpeed: 0.9,
+  maxSpeed: 2.6,
+  speedGainPerColumn: 25e-5,
+  duckTicks: 12,
+  runFrameTicks: 5,
+  scorePerColumn: 0.5,
+  coinPoints: 25,
+  minGapColumns: 28,
+  maxGapColumns: 60,
+  gapPerSpeed: 10,
+  tokenSpawnChance: 0.65,
+  tokenRowCount: 3,
+  tokenSpacing: 5,
+  tokenAltitudes: [9, 14, 18],
+  tokenArc: [0, 4, 0],
+  bugPairChance: 0.35,
+  bugPairMinDistance: 250,
+  pipeMinDistance: 350,
+  ghostMinDistance: 700,
+  ghostChance: 0.22,
+  pipeChance: 0.45,
+  ghostMidAltitude: 6,
+  ghostHighAltitude: 11,
+  squishTicks: 12,
+  stompTolerance: 5,
+  stompBonus: 100,
+  bounceVelocity: 3.6,
+  blockAltitude: 16,
+  blockSize: 8,
+  /** Logos drawn with sextant glyphs pack 2×3 sub-pixels per cell: a block face is 16 wide × 12 tall. */
+  logoWidth: 16,
+  logoHeight: 12,
+  blockGroupChance: 0.5,
+  /** Block group sizes and their weights; the question-block slots per size are fixed Mario-style. */
+  blockGroupSizes: [1, 2, 3, 5],
+  blockGroupWeights: [0.2, 0.2, 0.35, 0.25],
+  singleBlockQuestionChance: 0.6,
+  brickBonus: 50,
+  debrisTicks: 30,
+  blockHitTolerance: 4,
+  landingTolerance: 3,
+  powerUpBonus: 200,
+  sponsorBonusStart: 300,
+  sponsorBonusStep: 100,
+  powerUpEmergeSpeed: 1,
+  /** Lives: the run starts with three; some ? blocks pop a heart (1-UP) instead of the logo; a hit costs one and grants a short blink of invulnerability. */
+  startLives: 3,
+  maxLives: 9,
+  oneUpChance: 0.3,
+  hurtInvulnerableTicks: 60,
+  hurtBlinkTicks: 4,
+  floatingTextTicks: 40,
+  floatingTextRise: 0.35,
+  cloudInterval: 70,
+  cloudParallax: 0.35,
+  cloudMinAltitude: 30,
+  cloudAltitudeSpread: 10,
+  hillInterval: 130,
+  hillParallax: 0.5,
+  groundBrickRows: 4,
+  collisionSideInset: 2,
+  collisionTopInset: 1,
+  claudePollTicks: 2,
+  bannerTicks: 150,
+  bannerBlinkTicks: 8,
+  claudeStaleMs: 2 * 60 * 60 * 1e3
+};
+
+// src/render/build_ranking_lines.ts
+function buildRankingLines(view) {
+  if (view.state === "off") return [];
+  if (view.state === "pending") return [[{ text: "submitting score...", color: PALETTE.textDim }]];
+  if (view.state === "failed" || view.result === null) return [[{ text: "ranking unavailable (offline?)", color: PALETTE.textDim }]];
+  const rank = view.result.rank;
+  return [[{ text: rank === null ? "not ranked yet" : `your global rank: #${rank}`, color: PALETTE.token, isBold: true }]];
+}
+
+// src/render/build_sponsor_line.ts
+var SEPARATOR2 = "  \xB7  ";
+var MAX_NAMES = 4;
+function buildSponsorLine(sponsors) {
+  if (sponsors.length === 0) return [];
+  const names = sponsors.slice(0, MAX_NAMES).flatMap((sponsor, i) => [
+    ...i === 0 ? [] : [{ text: SEPARATOR2, color: PALETTE.textDim }],
+    { text: sponsor.name, color: PALETTE.token, isBold: true, link: sponsor.url }
+  ]);
+  return [{ text: "sponsored by ", color: PALETTE.textDim }, ...names];
+}
+
+// src/render/join_segments.ts
+function encodeSegment(segment) {
+  const bold = segment.isBold === true ? ANSI.bold : "";
+  const dim = segment.isDim === true ? ANSI.dim : "";
+  const color = segment.color === void 0 ? "" : ANSI.fg(segment.color);
+  const styled = `${bold}${dim}${color}${segment.text}${ANSI.reset}`;
+  return segment.link === void 0 ? styled : `${ANSI.linkOpen(segment.link)}${styled}${ANSI.linkClose}`;
+}
+function joinSegments(segments) {
+  const text = segments.map(encodeSegment).join("");
+  const visibleLength = segments.reduce((sum, segment) => sum + segment.text.length, 0);
+  return { text, visibleLength };
+}
+
+// src/render/fit_line.ts
+function computeLeftPadding({ free, align }) {
+  if (align === "left") return 0;
+  if (align === "right") return free;
+  return Math.floor(free / 2);
+}
+function fitLine({ segments, columns, align = "left" }) {
+  const joined = joinSegments(segments);
+  if (joined.visibleLength > columns) return fitLine({ segments: [{ text: " ".repeat(columns) }], columns, align });
+  const free = columns - joined.visibleLength;
+  const left = computeLeftPadding({ free, align });
+  return " ".repeat(left) + joined.text + " ".repeat(free - left);
+}
+
+// src/render/create_sprite.ts
+function createSprite({ rows, palette }) {
+  const width = rows.reduce((max, row) => Math.max(max, row.length), 0);
+  return { rows, palette, width, height: rows.length };
+}
+
+// src/render/sprites/pixel_font.ts
+var PIXEL_FONT = {
+  S: [".####", "#....", "#....", ".###.", "....#", "....#", "####."],
+  U: ["#...#", "#...#", "#...#", "#...#", "#...#", "#...#", ".###."],
+  P: ["####.", "#...#", "#...#", "####.", "#....", "#....", "#...."],
+  E: ["#####", "#....", "#....", "####.", "#....", "#....", "#####"],
+  R: ["####.", "#...#", "#...#", "####.", "#.#..", "#..#.", "#...#"],
+  D: ["####.", "#...#", "#...#", "#...#", "#...#", "#...#", "####."],
+  A: [".###.", "#...#", "#...#", "#####", "#...#", "#...#", "#...#"],
+  I: ["#####", "..#..", "..#..", "..#..", "..#..", "..#..", "#####"],
+  O: [".###.", "#...#", "#...#", "#...#", "#...#", "#...#", ".###."],
+  B: ["####.", "#...#", "#...#", "####.", "#...#", "#...#", "####."],
+  ".": [".", ".", ".", ".", ".", ".", "#"],
+  " ": [".", ".", ".", ".", ".", ".", "."]
+};
+
+// src/render/sprites/title_card.ts
+var LETTER_HEIGHT = 7;
+var LETTER_GAP = 1;
+var PADDING_X = 4;
+var PADDING_Y = 2;
+var LINE_GAP = 1;
+var SHADOW_OFFSET = 1;
+var PANEL = "p";
+var INK = "w";
+var SHADOW = "k";
+var RIVET = "r";
+var EMPTY = ".";
+function measureLine(text) {
+  return [...text].reduce((width, char) => width + (PIXEL_FONT[char]?.[0]?.length ?? 1) + LETTER_GAP, -LETTER_GAP);
+}
+function stampLine({ grid, text, x, y }) {
+  let cursor = x;
+  [...text].forEach((char) => {
+    const glyph = PIXEL_FONT[char] ?? PIXEL_FONT[" "] ?? [];
+    glyph.forEach((row, gy) => [...row].forEach((cell, gx) => {
+      if (cell !== "#") return;
+      const shadowRow = grid[y + gy + SHADOW_OFFSET];
+      if (shadowRow !== void 0) shadowRow[cursor + gx + SHADOW_OFFSET] = SHADOW;
+    }));
+    glyph.forEach((row, gy) => [...row].forEach((cell, gx) => {
+      const inkRow = grid[y + gy];
+      if (cell === "#" && inkRow !== void 0) inkRow[cursor + gx] = INK;
+    }));
+    cursor += (glyph[0]?.length ?? 1) + LETTER_GAP;
+  });
+}
+function createTitleCard(lines) {
+  const textWidth = Math.max(...lines.map(measureLine));
+  const width = textWidth + PADDING_X * 2 + SHADOW_OFFSET;
+  const height = PADDING_Y * 2 + lines.length * LETTER_HEIGHT + (lines.length - 1) * LINE_GAP + SHADOW_OFFSET;
+  const grid = Array.from({ length: height }, () => Array(width).fill(PANEL));
+  [[0, 0], [0, width - 1], [height - 1, 0], [height - 1, width - 1]].forEach(([y, x]) => {
+    if (y !== void 0 && x !== void 0) grid[y][x] = EMPTY;
+  });
+  [[1, 1], [1, width - 2], [height - 2, 1], [height - 2, width - 2]].forEach(([y, x]) => {
+    if (y !== void 0 && x !== void 0) grid[y][x] = RIVET;
+  });
+  lines.forEach((text, i) => stampLine({ grid, text, x: PADDING_X, y: PADDING_Y + i * (LETTER_HEIGHT + LINE_GAP) }));
+  return createSprite({
+    rows: grid.map((row) => row.join("")),
+    palette: { [PANEL]: PALETTE.titlePanel, [INK]: PALETTE.titleInk, [SHADOW]: PALETTE.titleShadow, [RIVET]: PALETTE.titleInk }
+  });
+}
+var TITLE_CARD = createTitleCard(["SUPER", "DARIO BROS."]);
+var TITLE_CARD_TOP_ROW = 2;
+var TITLE_CARD_ROWS = Math.ceil(TITLE_CARD.height / 2);
+
+// src/player/agent_labels.ts
+var AGENT_LABELS = { claude: "CLAUDE", codex: "CODEX", grok: "GROK" };
+
+// src/render/build_overlay.ts
+var BANNER_ROW = 0;
+var TITLE_OFFSET = -3;
+var SETTINGS_LABEL_WIDTH = 24;
+function buildSettingsLines(view) {
+  const rows = view.items.map((item, i) => {
+    const isSelected = i === view.selected;
+    const marker = isSelected ? "> " : "  ";
+    return [{ text: `${marker}${item.label.padEnd(SETTINGS_LABEL_WIDTH)}${isSelected ? "< " : "  "}${item.value}${isSelected ? " >" : "  "}`, color: isSelected ? PALETTE.claudeOrange : PALETTE.text, isBold: isSelected }];
+  });
+  return [[{ text: "SETTINGS", color: PALETTE.token, isBold: true }], [], ...rows, [], [{ text: "\u2191 \u2193 pick    \u2190 \u2192 / SPACE change    C close", color: PALETTE.textDim }]];
+}
+function describeMatchup(agent) {
+  const rivals = Object.keys(AGENT_LABELS).filter((kind) => kind !== agent).map((kind) => AGENT_LABELS[kind]).join(" & ");
+  return `you are ${AGENT_LABELS[agent]}   \xB7   stomp ${rivals}`;
+}
+function withSponsorLine({ lines, sponsors }) {
+  const sponsorLine = buildSponsorLine(sponsors);
+  return sponsorLine.length === 0 ? lines : [...lines, [], sponsorLine];
+}
+function buildHint({ hint, lockMessage }) {
+  if (lockMessage === null) return [{ text: hint, color: PALETTE.textDim }];
+  return [{ text: lockMessage, color: PALETTE.warning, isBold: true }];
+}
+function buildPhaseLines({ phase, score, highScore, ranking, sponsors, agent, lockMessage }) {
+  if (phase === "ready") {
+    return withSponsorLine({ sponsors, lines: [
+      [{ text: "\xA92026 EVENTUALLY SOLUTIONS", color: PALETTE.titleInk }],
+      [{ text: describeMatchup(agent), color: PALETTE.text }],
+      buildHint({ hint: "press SPACE to start", lockMessage })
+    ] });
+  }
+  if (phase === "paused") return [[{ text: "PAUSED", color: PALETTE.warning, isBold: true }], buildHint({ hint: "press P or SPACE to resume", lockMessage })];
+  if (phase === "over") {
+    return withSponsorLine({ sponsors, lines: [
+      [{ text: "GAME OVER", color: PALETTE.danger, isBold: true }],
+      [{ text: `score ${score}   best ${highScore}`, color: PALETTE.text }],
+      ...buildRankingLines(ranking),
+      buildHint({ hint: "R play again   Q quit", lockMessage })
+    ] });
+  }
+  return [];
+}
+function isBannerVisible({ banner, tickCount }) {
+  if (banner === null || banner.ticksLeft <= 0) return false;
+  const isSteadyPhase = banner.ticksLeft > GAME_CONSTANTS.bannerTicks / 2;
+  const isBlinkOn = Math.floor(tickCount / GAME_CONSTANTS.bannerBlinkTicks) % 2 === 0;
+  return isSteadyPhase || isBlinkOn;
+}
+function buildOverlay(input) {
+  const lines = /* @__PURE__ */ new Map();
+  const isTitleScreen = input.phase === "ready" && input.settings === null;
+  const naturalRow = isTitleScreen ? TITLE_CARD_TOP_ROW + TITLE_CARD_ROWS : input.settings !== null ? TITLE_CARD_TOP_ROW : Math.max(0, Math.floor(input.layout.playRows / 2) + TITLE_OFFSET);
+  const startRow = Math.max(naturalRow, input.minTextRow ?? 0);
+  const phaseLines = input.settings === null ? buildPhaseLines(input) : buildSettingsLines(input.settings);
+  phaseLines.forEach((segments, i) => lines.set(startRow + i, segments));
+  if (isBannerVisible(input) && input.banner !== null) lines.set(BANNER_ROW, [{ text: ` ${input.banner.text} `, color: input.banner.color, isBold: true }]);
+  return renderLines({ lines, columns: input.layout.columns });
+}
+function renderLines({ lines, columns }) {
+  const rendered = /* @__PURE__ */ new Map();
+  lines.forEach((segments, row) => rendered.set(row, fitLine({ segments, columns, align: "center" })));
+  return rendered;
+}
+
+// src/render/compute_layout.ts
+var PIXELS_PER_ROW = 2;
+function computeLayout(size) {
+  const columns = Math.max(size.columns, GAME_CONSTANTS.minColumns);
+  const rows = Math.max(size.rows, GAME_CONSTANTS.minRows);
+  const playRows = rows - GAME_CONSTANTS.hudRows - GAME_CONSTANTS.footerRows;
+  const pixelHeight = playRows * PIXELS_PER_ROW;
+  const groundY = pixelHeight - GAME_CONSTANTS.groundMarginRows * PIXELS_PER_ROW;
+  return { columns, rows, playRows, pixelHeight, groundY };
+}
+
+// src/render/draw_ranking_panel.ts
+var NAME_WIDTH = 12;
+var SCORE_WIDTH = 6;
+var RANK_WIDTH = 3;
+var HEADERS = { vibe: "RANKINGS", pro: "PRO RANKINGS" };
+var GAP_LINE = "...";
+var PANEL_TOP_ROW = 1;
+var SPONSOR_PREFIX = " \xB7 sponsored by ";
+function formatEntry({ entry, index, uid }) {
+  const rank = `#${index + 1}`.padEnd(RANK_WIDTH);
+  const name = entry.name.slice(0, NAME_WIDTH).padEnd(NAME_WIDTH);
+  const isMe = entry.uid === uid;
+  return { text: `${rank} ${name} ${String(entry.highScore).padStart(SCORE_WIDTH)}`, color: isMe ? PALETTE.claudeOrange : PALETTE.text };
+}
+function buildHeader({ sponsor, mode }) {
+  const header = { text: HEADERS[mode], color: mode === "pro" ? PALETTE.warning : PALETTE.textDim };
+  if (sponsor === null) return [header];
+  return [header, { text: SPONSOR_PREFIX, color: PALETTE.textDim }, { text: sponsor.name.toUpperCase(), color: PALETTE.token, link: sponsor.url }];
+}
+function buildMyLine({ view, me }) {
+  const rank = view.result?.rank ?? null;
+  if (me === null || rank === null || rank <= (view.result?.top.length ?? 0)) return [];
+  const rankText = `#${rank}`.padEnd(RANK_WIDTH);
+  return [{ text: GAP_LINE, color: PALETTE.textDim }, { text: `${rankText} ${me.name.slice(0, NAME_WIDTH).padEnd(NAME_WIDTH)} ${String(me.score).padStart(SCORE_WIDTH)}`, color: PALETTE.claudeOrange }];
+}
+function buildLines({ view, me }) {
+  if (view.result === null) return [{ text: view.state === "failed" ? "offline" : "loading...", color: PALETTE.textDim }];
+  const top = view.result.top.map((entry, index) => formatEntry({ entry, index, uid: view.result?.uid ?? "" }));
+  return [...top, ...buildMyLine({ view, me })];
+}
+function drawRankingPanel({ buffer, view, mode = "vibe", sponsor = null, me = null }) {
+  if (view.state === "off") return;
+  let column = GAME_CONSTANTS.rankingPanelColumn;
+  buildHeader({ sponsor, mode }).forEach((segment) => {
+    buffer.setText({ column, row: PANEL_TOP_ROW, text: segment.text, color: segment.color, link: segment.link ?? null });
+    column += segment.text.length;
+  });
+  buildLines({ view, me }).forEach((line, index) => buffer.setText({ column: GAME_CONSTANTS.rankingPanelColumn, row: PANEL_TOP_ROW + index + 1, text: line.text, color: line.color }));
+}
+
+// src/render/draw_text_face.ts
+var PIXELS_PER_ROW2 = 2;
+function drawTextFace({ buffer, face, x, y, link = null }) {
+  const size = GAME_CONSTANTS.blockSize;
+  const column = Math.round(x);
+  const topRow = Math.round(y / PIXELS_PER_ROW2);
+  const rows = size / PIXELS_PER_ROW2;
+  const firstTextRow = topRow + Math.floor((rows - face.lines.length) / 2);
+  for (let row = topRow; row < topRow + rows; row++) {
+    const line = face.lines[row - firstTextRow];
+    const text = (line ?? "").slice(0, size);
+    const pad = Math.floor((size - text.length) / 2);
+    buffer.setText({ column, row, text: " ".repeat(pad) + text + " ".repeat(size - pad - text.length), color: face.fg, bg: face.bg, link });
+  }
+}
+
+// src/render/is_same_color.ts
+function isSameColor(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  return a.r === b.r && a.g === b.g && a.b === b.b;
+}
+
+// src/render/ansi_row_encoder.ts
+var AnsiRowEncoder = class {
+  parts = [];
+  currentFg = null;
+  currentBg = null;
+  currentLink = null;
+  push(cell) {
+    if (cell.link !== this.currentLink) this.setLink(cell.link);
+    if (this.needsReset(cell)) this.reset();
+    if (cell.fg !== null && !isSameColor(cell.fg, this.currentFg)) this.setForeground(cell.fg);
+    if (cell.bg !== null && !isSameColor(cell.bg, this.currentBg)) this.setBackground(cell.bg);
+    this.parts.push(cell.glyph);
+  }
+  finish() {
+    if (this.currentLink !== null) this.setLink(null);
+    if (this.currentFg !== null || this.currentBg !== null) this.reset();
+    return this.parts.join("");
+  }
+  needsReset(cell) {
+    const dropsFg = cell.fg === null && this.currentFg !== null;
+    const dropsBg = cell.bg === null && this.currentBg !== null;
+    return dropsFg || dropsBg;
+  }
+  reset() {
+    this.parts.push(ANSI.reset);
+    this.currentFg = null;
+    this.currentBg = null;
+  }
+  setForeground(color) {
+    this.parts.push(ANSI.fg(color));
+    this.currentFg = color;
+  }
+  setBackground(color) {
+    this.parts.push(ANSI.bg(color));
+    this.currentBg = color;
+  }
+  setLink(link) {
+    this.parts.push(link === null ? ANSI.linkClose : ANSI.linkOpen(link));
+    this.currentLink = link;
+  }
+};
+
+// src/render/encode_pixel_cell.ts
+var UPPER_HALF = "\u2580";
+var LOWER_HALF = "\u2584";
+var FULL_BLOCK = "\u2588";
+function encodePixelCell({ top, bottom, link = null }) {
+  if (top === null && bottom === null) return { glyph: " ", fg: null, bg: null, link: null };
+  if (top === null) return { glyph: LOWER_HALF, fg: bottom, bg: null, link };
+  if (bottom === null) return { glyph: UPPER_HALF, fg: top, bg: null, link };
+  if (isSameColor(top, bottom)) return { glyph: FULL_BLOCK, fg: top, bg: null, link };
+  return { glyph: UPPER_HALF, fg: top, bg: bottom, link };
+}
+
+// src/render/encode_dense_cell.ts
+var DENSE_COLUMNS = 2;
+var DENSE_ROWS = 3;
+var SLOT_COUNT = DENSE_COLUMNS * DENSE_ROWS;
+var SEXTANT_BASE = 129792;
+var LEFT_HALF_MASK = 21;
+var RIGHT_HALF_MASK = 42;
+var FULL_MASK = 63;
+function sextantGlyph(mask) {
+  if (mask === 0) return " ";
+  if (mask === LEFT_HALF_MASK) return "\u258C";
+  if (mask === RIGHT_HALF_MASK) return "\u2590";
+  if (mask === FULL_MASK) return "\u2588";
+  const skipped = (mask > LEFT_HALF_MASK ? 1 : 0) + (mask > RIGHT_HALF_MASK ? 1 : 0);
+  return String.fromCodePoint(SEXTANT_BASE + mask - 1 - skipped);
+}
+function distance(a, b) {
+  return (a.r - b.r) ** 2 + (a.g - b.g) ** 2 + (a.b - b.b) ** 2;
+}
+function rankColors(colors) {
+  const ranked = [];
+  colors.forEach((color) => {
+    if (color === null) return;
+    const found = ranked.find((entry) => isSameColor(entry.color, color));
+    if (found === void 0) ranked.push({ color, count: 1 });
+    else found.count++;
+  });
+  return ranked.sort((a, b) => b.count - a.count).map((entry) => entry.color);
+}
+function buildMask(colors, isOn) {
+  return colors.slice(0, SLOT_COUNT).reduce((mask, color, i) => color !== null && isOn(color) ? mask | 1 << i : mask, 0);
+}
+function encodeDenseCell({ colors, link = null }) {
+  const [primary, secondary] = rankColors(colors);
+  if (primary === void 0) return { glyph: " ", fg: null, bg: null, link: null };
+  const hasTransparent = colors.slice(0, SLOT_COUNT).some((color) => color === null);
+  if (secondary === void 0 || hasTransparent) return { glyph: sextantGlyph(buildMask(colors, () => true)), fg: primary, bg: null, link };
+  const mask = buildMask(colors, (color) => distance(color, primary) <= distance(color, secondary));
+  return { glyph: sextantGlyph(mask), fg: primary, bg: secondary, link };
+}
+
+// src/render/pixel_buffer.ts
+var TRANSPARENT_CHAR = ".";
+var PixelBuffer = class {
+  width;
+  height;
+  pixels;
+  links;
+  /** Text layer keyed by terminal cell (row * width + column); text always wins over pixels. */
+  textCells = /* @__PURE__ */ new Map();
+  /** High-density layer: 2×3 sub-pixels per cell, drawn with sextant glyphs (sits above pixels, below text). */
+  denseCells = /* @__PURE__ */ new Map();
+  constructor({ width, height }) {
+    this.width = width;
+    this.height = height;
+    this.pixels = new Array(width * height).fill(null);
+    this.links = new Array(width * height).fill(null);
+  }
+  clear() {
+    this.pixels.fill(null);
+    this.links.fill(null);
+    this.textCells.clear();
+    this.denseCells.clear();
+  }
+  setPixel({ x, y, color, link = null }) {
+    if (!this.isInside({ x, y })) return;
+    this.pixels[y * this.width + x] = color;
+    this.links[y * this.width + x] = link;
+  }
+  getPixel({ x, y }) {
+    if (!this.isInside({ x, y })) return null;
+    return this.pixels[y * this.width + x] ?? null;
+  }
+  setText({ column, row, text, color, bg = null, link = null }) {
+    const rowCount = Math.floor(this.height / 2);
+    if (row < 0 || row >= rowCount) return;
+    [...text].forEach((glyph, i) => {
+      const x = column + i;
+      if (x >= 0 && x < this.width) this.textCells.set(row * this.width + x, { glyph, fg: color, bg, link });
+    });
+  }
+  /**
+   * Draws a sprite at sextant density: two sprite columns per terminal column, three sprite rows per
+   * terminal row. `x` is in terminal columns, `y` in pixel rows (rounded to a terminal row).
+   */
+  drawDenseSprite({ sprite, x, y, link = null }) {
+    const originColumn = Math.round(x);
+    const originRow = Math.round(y / 2);
+    sprite.rows.forEach((row, sy) => {
+      [...row].forEach((char, sx) => {
+        const color = char === TRANSPARENT_CHAR ? void 0 : sprite.palette[char];
+        const slot = sy % DENSE_ROWS * DENSE_COLUMNS + sx % DENSE_COLUMNS;
+        if (color !== void 0) this.setDensePixel({ column: originColumn + Math.floor(sx / DENSE_COLUMNS), row: originRow + Math.floor(sy / DENSE_ROWS), slot, color, link });
+      });
+    });
+  }
+  drawSprite({ sprite, x, y, link = null }) {
+    const originX = Math.round(x);
+    const originY = Math.round(y);
+    sprite.rows.forEach((row, rowIndex) => this.drawSpriteRow({ sprite, row, x: originX, y: originY + rowIndex, link }));
+  }
+  toAnsiRows() {
+    const rowCount = Math.floor(this.height / 2);
+    return Array.from({ length: rowCount }, (_, row) => this.encodeRow(row));
+  }
+  setDensePixel({ column, row, slot, color, link }) {
+    const rowCount = Math.floor(this.height / 2);
+    if (column < 0 || column >= this.width || row < 0 || row >= rowCount) return;
+    const key = row * this.width + column;
+    const cell = this.denseCells.get(key) ?? { colors: new Array(DENSE_COLUMNS * DENSE_ROWS).fill(null), link };
+    cell.colors[slot] = color;
+    this.denseCells.set(key, { colors: cell.colors, link: link ?? cell.link });
+  }
+  drawSpriteRow({ sprite, row, x, y, link }) {
+    for (let i = 0; i < row.length; i++) {
+      const char = row.charAt(i);
+      if (char === TRANSPARENT_CHAR) continue;
+      const color = sprite.palette[char];
+      if (color !== void 0) this.setPixel({ x: x + i, y, color, link });
+    }
+  }
+  encodeRow(row) {
+    const encoder = new AnsiRowEncoder();
+    for (let x = 0; x < this.width; x++) {
+      const text = this.textCells.get(row * this.width + x);
+      const dense = this.denseCells.get(row * this.width + x);
+      if (text === void 0 && dense !== void 0) {
+        encoder.push(encodeDenseCell({ colors: dense.colors, link: dense.link }));
+        continue;
+      }
+      const topIndex = row * 2 * this.width + x;
+      const bottomIndex = topIndex + this.width;
+      const link = this.links[topIndex] ?? this.links[bottomIndex] ?? null;
+      encoder.push(text ?? encodePixelCell({ top: this.pixels[topIndex] ?? null, bottom: this.pixels[bottomIndex] ?? null, link }));
+    }
+    return encoder.finish();
+  }
+  isInside({ x, y }) {
+    return x >= 0 && y >= 0 && x < this.width && y < this.height;
+  }
+};
+
+// src/render/render_footer.ts
+var LABEL = "CONTROLS";
+var GAP = "    ";
+var ARROWS = "\u2190 \u2192 \u2191 \u2193";
+var CONTROLS_BY_PHASE = {
+  ready: [[ARROWS, ""], ["SPACE", "jump"], ["C", "settings"], ["Q", "quit"]],
+  running: [[ARROWS, ""], ["SPACE", "jump"], ["P", "pause"], ["Q", "quit"]],
+  paused: [["P / SPACE", "resume"], ["C", "settings"], ["R", "restart"], ["Q", "quit"]],
+  over: [["R / SPACE", "play again"], ["Q", "quit"]]
+};
+function toSegments(phase) {
+  const pairs = CONTROLS_BY_PHASE[phase];
+  const keys = pairs.flatMap(([key, action], i) => [
+    { text: i === 0 ? "" : GAP },
+    { text: key, color: PALETTE.text, isBold: true },
+    { text: action.length === 0 ? "" : ` ${action}`, color: PALETTE.textDim }
+  ]);
+  const hasArrows = pairs[0]?.[0] === ARROWS;
+  return hasArrows ? [{ text: LABEL, color: PALETTE.claudeOrange, isBold: true }, { text: GAP }, ...keys] : keys;
+}
+function renderFooter({ columns, phase }) {
+  return fitLine({ segments: toSegments(phase), columns, align: "center" });
+}
+
+// src/render/thinking_verbs.ts
+var THINKING_VERBS = [
+  "Thinking",
+  "Considering",
+  "Pondering",
+  "Synthesizing",
+  "Forging",
+  "Herding",
+  "Brewing",
+  "Cogitating",
+  "Musing",
+  "Scheming",
+  "Percolating",
+  "Marinating",
+  "Noodling",
+  "Simmering",
+  "Crunching",
+  "Wrangling",
+  "Ruminating",
+  "Deliberating",
+  "Composing",
+  "Tinkering",
+  "Untangling",
+  "Weaving",
+  "Puzzling",
+  "Ideating"
+];
+
+// src/render/describe_claude_status.ts
+var VERB_TICKS = 60;
+var DOT_TICKS = 10;
+var MAX_DOTS = 3;
+var STATUS_VIEWS = {
+  idle: { label: "idle", color: PALETTE.textDim },
+  working: { label: "working...", color: PALETTE.working },
+  done: { label: "DONE!", color: PALETTE.success },
+  attention: { label: "NEEDS YOU!", color: PALETTE.warning }
+};
+function describeWorking({ record, tickCount }) {
+  if (record.message.length > 0) return record.message;
+  const verb = THINKING_VERBS[Math.floor(record.updatedAt / 1e3 + tickCount / VERB_TICKS) % THINKING_VERBS.length] ?? "Thinking";
+  const dots = Math.floor(tickCount / DOT_TICKS) % (MAX_DOTS + 1);
+  return `${verb}${".".repeat(dots)}${" ".repeat(MAX_DOTS - dots)}`;
+}
+function describeClaudeStatus({ record, now = Date.now(), tickCount = 0 }) {
+  if (record === null) return STATUS_VIEWS.idle;
+  const isStale = now - record.updatedAt > GAME_CONSTANTS.claudeStaleMs;
+  if (isStale) return STATUS_VIEWS.idle;
+  if (record.status === "working") return { label: describeWorking({ record, tickCount }), color: PALETTE.working };
+  return STATUS_VIEWS[record.status] ?? STATUS_VIEWS.idle;
+}
+
+// src/render/render_hud.ts
+var SCORE_DIGITS = 5;
+var HEART = "\u2665";
+var LOST_HEART = "\xB7";
+function renderHearts(lives) {
+  const lost = Math.min(GAME_CONSTANTS.startLives, Math.max(0, GAME_CONSTANTS.startLives - lives));
+  return [
+    { text: ` ${HEART.repeat(Math.max(0, lives))}`, color: PALETTE.mushroomRed, isBold: true },
+    { text: LOST_HEART.repeat(lost), color: PALETTE.textDim }
+  ];
+}
+function formatScore(value) {
+  return String(Math.floor(value)).padStart(SCORE_DIGITS, "0");
+}
+function renderHud({ columns, playerName, score, highScore, lives, mode, claude, tickCount }) {
+  const status = describeClaudeStatus({ record: claude, tickCount });
+  const leftSegments = [
+    { text: " SUPER DARIO ", color: PALETTE.claudeOrange, isBold: true },
+    { text: ` ${playerName}`, color: PALETTE.text },
+    { text: "  SCORE ", color: PALETTE.textDim },
+    { text: formatScore(score), color: PALETTE.text, isBold: true },
+    { text: "  HI ", color: PALETTE.textDim },
+    { text: formatScore(highScore), color: PALETTE.text },
+    { text: "  LIVES", color: PALETTE.textDim },
+    ...renderHearts(lives),
+    ...mode === "pro" ? [{ text: `  ${GAME_MODE_LABELS.pro}`, color: PALETTE.warning, isBold: true }] : []
+  ];
+  const rightSegments = [
+    { text: `${AGENT_LABELS[claude?.agent ?? "claude"] ?? AGENT_LABELS.claude}: `, color: PALETTE.textDim },
+    { text: `${status.label} `, color: status.color, isBold: true }
+  ];
+  const left = joinSegments(leftSegments);
+  const right = joinSegments(rightSegments);
+  const gap = columns - left.visibleLength - right.visibleLength;
+  if (gap < 1) return left.text + " ".repeat(Math.max(0, columns - left.visibleLength));
+  return left.text + " ".repeat(gap) + right.text;
+}
+
+// src/sponsors/to_sponsor_sprite.ts
+var HEX_RADIX = 16;
+function hexToRgb(hex) {
+  return {
+    r: Number.parseInt(hex.slice(1, 3), HEX_RADIX),
+    g: Number.parseInt(hex.slice(3, 5), HEX_RADIX),
+    b: Number.parseInt(hex.slice(5, 7), HEX_RADIX)
+  };
+}
+function toSponsorSprite(sponsor) {
+  const palette = Object.fromEntries(Object.entries(sponsor.palette).map(([key, hex]) => [key, hexToRgb(hex)]));
+  return createSprite({ rows: sponsor.rows, palette });
+}
+
+// src/sponsors/find_day_sponsor.ts
+function toUtcDay(timestamp) {
+  return new Date(timestamp).toISOString().slice(0, 10);
+}
+function findDaySponsor({ sponsors, tier, now = Date.now() }) {
+  const today = toUtcDay(now);
+  const candidates = sponsors.filter((sponsor) => sponsor.tier === tier);
+  return candidates.find((sponsor) => sponsor.days.includes(today)) ?? candidates.find((sponsor) => sponsor.days.length === 0) ?? null;
+}
+
+// src/render/is_hi_res_logo.ts
+function isHiResLogo(sprite) {
+  return sprite.width === GAME_CONSTANTS.logoWidth && sprite.height === GAME_CONSTANTS.logoHeight;
+}
+
+// src/render/game_renderer.ts
+var BRICK_WIDTH = 8;
+var BANNER_GAP = 3;
+var BANNER_PHASES = /* @__PURE__ */ new Set(["ready", "running", "paused", "over"]);
+var TITLE_PINNED_PHASES = /* @__PURE__ */ new Set(["ready", "running"]);
+var BANNER_LABEL_ROWS = 2;
+var MENU_TEXT_ROWS = 4;
+var PIXELS_PER_ROW3 = 2;
+var GameRenderer = class {
+  layout;
+  buffer;
+  constructor({ size }) {
+    this.layout = computeLayout(size);
+    this.buffer = new PixelBuffer({ width: this.layout.columns, height: this.layout.pixelHeight });
+  }
+  getLayout() {
+    return this.layout;
+  }
+  resize({ size }) {
+    this.layout = computeLayout(size);
+    this.buffer = new PixelBuffer({ width: this.layout.columns, height: this.layout.pixelHeight });
+  }
+  render(frame) {
+    this.buffer.clear();
+    this.drawWorld(frame.world);
+    if (frame.settings === null) this.drawTitleCard(frame.world.getTitleX());
+    const minTextRow = frame.settings === null ? this.drawSponsorBanner(frame) : 0;
+    const myScore = frame.mode === "pro" ? frame.scores.proHighScore : frame.scores.highScore;
+    drawRankingPanel({ buffer: this.buffer, view: frame.ranking, mode: frame.mode, sponsor: findDaySponsor({ sponsors: frame.sponsors, tier: "ranking" }), me: { name: frame.playerName, score: myScore } });
+    const overlay = buildOverlay({ layout: this.layout, phase: frame.phase, score: frame.world.score, tokens: frame.world.getTokensCollected(), highScore: frame.scores.highScore, banner: frame.banner, ranking: frame.ranking, sponsors: frame.sponsors, agent: frame.agent, lockMessage: frame.lockMessage, settings: frame.settings, tickCount: frame.tickCount, minTextRow });
+    const playfield = this.buffer.toAnsiRows().map((row, i) => overlay.get(i) ?? row);
+    const hud = renderHud({ columns: this.layout.columns, playerName: frame.playerName, score: frame.world.score, highScore: frame.mode === "pro" ? frame.scores.proHighScore : frame.scores.highScore, lives: frame.world.getLives(), mode: frame.mode, claude: frame.claude, tickCount: frame.tickCount });
+    return [hud, ...playfield, renderFooter({ columns: this.layout.columns, phase: frame.phase })];
+  }
+  /** The Super Mario Bros. style plate lives in the level: it stays put on the title screen and scrolls off as you run. */
+  drawTitleCard(x) {
+    if (x === null) return;
+    this.buffer.drawSprite({ sprite: TITLE_CARD, x, y: TITLE_CARD_TOP_ROW * PIXELS_PER_ROW3 });
+  }
+  /**
+   * The single banner sponsor (top of the ranking): a plate the size of the title card with "sponsored by" above it.
+   * Start screen: pinned next to the title (under it on narrower terminals) and scrolling away with it once the run
+   * starts; pause and game over: centered on top.
+   */
+  drawSponsorBanner(frame) {
+    const sponsor = findDaySponsor({ sponsors: frame.sponsors, tier: "banner" });
+    if (sponsor === null || !BANNER_PHASES.has(frame.phase)) return 0;
+    const sprite = toSponsorSprite(sponsor);
+    const titleX = TITLE_PINNED_PHASES.has(frame.phase) ? frame.world.getTitleX() : null;
+    if (frame.phase === "running" && titleX === null) return 0;
+    const placement = this.placeBanner({ sprite, titleX });
+    if (placement === null) return 0;
+    this.buffer.setText({ column: Math.round(placement.x), row: placement.y / PIXELS_PER_ROW3 - 1, text: `sponsored by ${sponsor.name.toUpperCase()}`, color: PALETTE.textDim, link: sponsor.url });
+    this.buffer.drawSprite({ sprite, x: placement.x, y: placement.y, link: sponsor.url });
+    return Math.ceil((placement.y + sprite.height) / PIXELS_PER_ROW3) + 1;
+  }
+  /** Null when the terminal is too small to show the banner and still leave room for the menu text under it. */
+  placeBanner({ sprite, titleX }) {
+    const cardTop = TITLE_CARD_TOP_ROW * PIXELS_PER_ROW3;
+    const centered = Math.max(0, Math.floor((this.layout.columns - sprite.width) / 2));
+    const fits = (placement) => (placement.y + sprite.height) / PIXELS_PER_ROW3 + MENU_TEXT_ROWS <= this.layout.playRows ? placement : null;
+    if (titleX === null) return fits({ x: centered, y: cardTop });
+    const besideX = titleX + TITLE_CARD.width + BANNER_GAP;
+    if (besideX + sprite.width <= this.layout.columns) return fits({ x: besideX, y: cardTop });
+    return fits({ x: titleX + Math.floor((TITLE_CARD.width - sprite.width) / 2), y: cardTop + TITLE_CARD.height + BANNER_LABEL_ROWS * PIXELS_PER_ROW3 });
+  }
+  /** Back to front: scenery, ground, blocks  /** Back to front: scenery, ground, blocks, pickups, enemies, the mascot, popups. */
+  drawWorld(world) {
+    world.getScenery().forEach((item) => this.drawAtAltitude({ sprite: item.sprite, x: item.x, altitude: item.altitude }));
+    this.drawGround(world.getDistance());
+    world.getBlocks().forEach((block) => this.drawBlock(block));
+    world.getTokens().forEach((token) => this.drawAtAltitude({ sprite: token.sprite, x: token.getX(), altitude: token.getAltitude(), link: token.link }));
+    world.getPowerUps().forEach((powerUp) => this.drawPowerUp(powerUp));
+    world.getObstacles().forEach((obstacle) => this.drawAtAltitude({ sprite: obstacle.sprite, x: obstacle.getX(), altitude: obstacle.getAltitude() }));
+    if (this.isPlayerVisible(world)) this.drawAtAltitude({ sprite: world.player.getSprite(), x: world.player.getScreenX(), altitude: world.player.getAltitude() });
+    world.getDebris().forEach((piece) => this.drawAtAltitude({ sprite: piece.sprite, x: piece.getX(), altitude: piece.getAltitude() }));
+    world.getTexts().forEach((text) => this.drawText(text));
+  }
+  /** After losing a life the mascot blinks for the invulnerable stretch. */
+  isPlayerVisible(world) {
+    if (!world.isInvulnerable) return true;
+    return Math.floor(world.getInvulnerableTicks() / GAME_CONSTANTS.hurtBlinkTicks) % 2 === 0;
+  }
+  drawBlock(block) {
+    this.drawAtAltitude({ sprite: block.sprite, x: block.getX(), altitude: block.getAltitude() });
+  }
+  drawPowerUp(powerUp) {
+    if (powerUp.textFace !== null) return this.drawTextFaceAt({ face: powerUp.textFace, x: powerUp.getX(), altitude: powerUp.getAltitude(), link: powerUp.link });
+    this.drawAtAltitude({ sprite: powerUp.sprite, x: powerUp.getX(), altitude: powerUp.getAltitude(), link: powerUp.link });
+  }
+  drawTextFaceAt({ face, x, altitude, link }) {
+    drawTextFace({ buffer: this.buffer, face, x, y: this.layout.groundY - altitude - GAME_CONSTANTS.blockSize, link });
+  }
+  /** Sponsor logos come as 16×12 high-density sprites: they are drawn with sextant glyphs into an 8×8 pixel area. */
+  drawAtAltitude({ sprite, x, altitude, link = null }) {
+    if (isHiResLogo(sprite)) {
+      const y2 = this.layout.groundY - altitude - GAME_CONSTANTS.blockSize;
+      return this.buffer.drawDenseSprite({ sprite, x, y: y2, link });
+    }
+    const y = this.layout.groundY - altitude - sprite.height;
+    this.buffer.drawSprite({ sprite, x, y, link });
+  }
+  drawText(text) {
+    const row = Math.floor((this.layout.groundY - text.getAltitude()) / PIXELS_PER_ROW3);
+    this.buffer.setText({ column: Math.round(text.getX()), row, text: text.text, color: PALETTE.token });
+  }
+  /** A brick floor that scrolls with the world: a mortar line on top, vertical joints every brick. */
+  drawGround(distance2) {
+    const scroll = Math.floor(distance2);
+    for (let x = 0; x < this.layout.columns; x++) {
+      for (let dy = 0; dy < GAME_CONSTANTS.groundBrickRows; dy++) {
+        const isMortar = dy === 0 || (x + scroll) % BRICK_WIDTH === 0;
+        this.buffer.setPixel({ x, y: this.layout.groundY + dy, color: isMortar ? PALETTE.brickMortar : PALETTE.brick });
+      }
+    }
+  }
+};
+
+// src/game/create_banner.ts
+function toTitleCase(label) {
+  return label.charAt(0) + label.slice(1).toLowerCase();
+}
+var BANNER_BY_STATUS = {
+  working: { build: (agent) => `${toTitleCase(agent)} is working... keep running!`, color: PALETTE.working },
+  done: { build: (agent) => `${agent} IS DONE - go check your prompt!`, color: PALETTE.success },
+  attention: { build: (agent) => `${agent} NEEDS YOUR INPUT - head back!`, color: PALETTE.warning }
+};
+function createBanner(record) {
+  const template = BANNER_BY_STATUS[record.status];
+  if (template === void 0) return null;
+  return { text: template.build(AGENT_LABELS[record.agent] ?? AGENT_LABELS.claude), color: template.color, ticksLeft: GAME_CONSTANTS.bannerTicks };
+}
+
+// src/game/is_agent_working.ts
+function isAgentWorking({ record, now = Date.now() }) {
+  if (record === null || record.status !== "working") return false;
+  return now - record.updatedAt <= GAME_CONSTANTS.claudeStaleMs;
+}
+
+// src/launcher/installed_terminals.ts
+function listInstalledTerminals() {
+  const ides = IDE_KINDS.filter(isBundleInstalled);
+  return [...ides, ...INSTALL_PREFERENCE.filter(isBundleInstalled), "apple_terminal"];
+}
+
+// src/game/settings_menu.ts
+var CHARACTERS = ["auto", ...AGENT_KINDS];
+var TERMINALS = ["auto", ...listInstalledTerminals()];
+var MODES2 = ["vibe", "pro"];
+function cycle(options, current, direction) {
+  const index = Math.max(0, options.indexOf(current));
+  return options[(index + direction + options.length) % options.length] ?? current;
+}
+function onOff(value) {
+  return value ? "ON" : "OFF";
+}
+var ITEMS = [
+  { label: "open on every prompt", read: (config) => onOff(config.autoLaunch), change: (config) => ({ autoLaunch: !config.autoLaunch }) },
+  { label: "switch back when done", read: (config) => onOff(config.returnFocus), change: (config) => ({ returnFocus: !config.returnFocus }) },
+  { label: "character", read: (config) => config.character.toUpperCase(), change: (config, direction) => ({ character: cycle(CHARACTERS, config.character, direction) }) },
+  { label: "terminal", read: (config) => config.terminal, change: (config, direction) => ({ terminal: cycle(TERMINALS, config.terminal, direction) }) },
+  { label: "mode", read: (config) => GAME_MODE_LABELS[config.mode], change: (config, direction) => ({ mode: cycle(MODES2, config.mode, direction) }) }
+];
+var SettingsMenu = class {
+  store;
+  selected = 0;
+  isOpenFlag = false;
+  constructor({ store }) {
+    this.store = store;
+  }
+  get isOpen() {
+    return this.isOpenFlag;
+  }
+  toggle() {
+    this.isOpenFlag = !this.isOpenFlag;
+  }
+  close() {
+    this.isOpenFlag = false;
+  }
+  moveSelection(delta) {
+    this.selected = (this.selected + delta + ITEMS.length) % ITEMS.length;
+  }
+  /** Applies the change for the highlighted row and returns the new config. */
+  change(direction) {
+    const item = ITEMS[this.selected];
+    if (item === void 0) return this.store.load();
+    return this.store.update(item.change(this.store.load(), direction));
+  }
+  getView() {
+    const config = this.store.load();
+    return { items: ITEMS.map((item) => ({ label: item.label, value: item.read(config) })), selected: this.selected };
+  }
+};
+
+// src/render/sprites/mascot_sprites.ts
+var ALIVE = { "#": PALETTE.claudeOrange };
+var DEAD = { "#": PALETTE.mascotDead, x: PALETTE.danger };
+var BODY = [
+  ".########.",
+  ".########.",
+  "##.####.##",
+  "##########",
+  ".########.",
+  ".########."
+];
+var DUCK_BODY = [
+  "..##########..",
+  "###.######.###",
+  ".############."
+];
+var MASCOT_SPRITES = {
+  runA: createSprite({ rows: [...BODY, ".#.#..#.#.", ".#.#..#.#."], palette: ALIVE }),
+  runB: createSprite({ rows: [...BODY, "..##..##..", "..##..##.."], palette: ALIVE }),
+  jump: createSprite({ rows: [...BODY, ".#.#..#.#.", ".........."], palette: ALIVE }),
+  duckA: createSprite({ rows: [...DUCK_BODY, ".#..#....#..#.", ".#..#....#..#."], palette: ALIVE }),
+  duckB: createSprite({ rows: [...DUCK_BODY, "..#..#..#..#..", "..#..#..#..#.."], palette: ALIVE }),
+  dead: createSprite({
+    rows: [".########.", ".########.", "##x####x##", "##########", ".########.", ".########.", ".#.#..#.#.", ".#.#..#.#."],
+    palette: DEAD
+  })
+};
+
+// src/render/sprites/agent_sprites.ts
+var GROK = { w: PALETTE.cloud };
+var GROK_DEAD = { w: PALETTE.cloudShade, x: PALETTE.danger };
+var CRAB = { "#": PALETTE.bug, d: PALETTE.bugDark };
+var CRAB_DEAD = { "#": PALETTE.mascotDead, d: PALETTE.bugDark };
+var GROK_SPRITES = {
+  runA: createSprite({ rows: ["...wwww...", "..wwwwww..", ".wwwwwwww.", ".ww.ww.ww.", ".ww.ww.ww.", ".wwwwwwww.", "..wwwwww..", "...wwww..."], palette: GROK }),
+  runB: createSprite({ rows: ["...wwww...", "..wwwwww..", ".wwwwwwww.", ".wwwwwwww.", ".ww.ww.ww.", ".ww.ww.ww.", "..wwwwww..", "...wwww..."], palette: GROK }),
+  jump: createSprite({ rows: ["...wwww...", "..wwwwww..", ".ww.ww.ww.", ".ww.ww.ww.", ".wwwwwwww.", ".wwwwwwww.", "..wwwwww..", "...wwww..."], palette: GROK }),
+  duckA: createSprite({ rows: ["....wwwwww....", "..wwwwwwwwww..", ".www.wwww.www.", "..wwwwwwwwww..", "....wwwwww...."], palette: GROK }),
+  duckB: createSprite({ rows: ["....wwwwww....", "..wwwwwwwwww..", ".wwwwwwwwwwww.", "..ww.wwww.ww..", "....wwwwww...."], palette: GROK }),
+  dead: createSprite({ rows: ["...wwww...", "..wwwwww..", ".wwwwwwww.", ".wwxwwxww.", ".wwwwwwww.", ".wwwwwwww.", "..wwwwww..", "...wwww..."], palette: GROK_DEAD }),
+  squished: createSprite({ rows: ["..wwwwww..", ".ww.ww.ww.", "wwwwwwwwww"], palette: GROK })
+};
+var CRAB_BODY = [".#......#.", "..#....#..", "...####...", "..#d##d#..", ".########.", "##########", ".########."];
+var CODEX_SPRITES = {
+  runA: createSprite({ rows: [...CRAB_BODY, "#.#.#..#.#"], palette: CRAB }),
+  runB: createSprite({ rows: [...CRAB_BODY, ".#.#.##.#."], palette: CRAB }),
+  jump: createSprite({ rows: [...CRAB_BODY, ".#.#..#.#."], palette: CRAB }),
+  duckA: createSprite({ rows: [".#..........#.", "..#..####..#..", "..##d####d##..", ".############.", "#.#.#....#.#.#"], palette: CRAB }),
+  duckB: createSprite({ rows: [".#..........#.", "..#..####..#..", "..##d####d##..", ".############.", ".#.#.#..#.#.#."], palette: CRAB }),
+  dead: createSprite({ rows: [...CRAB_BODY, "#.#.#..#.#"], palette: CRAB_DEAD }),
+  squished: createSprite({ rows: ["..#d##d#..", ".########.", "##########"], palette: CRAB })
+};
+var CLAUDE_SPRITES = {
+  ...MASCOT_SPRITES,
+  squished: createSprite({ rows: [".########.", "##.####.##", "##########"], palette: { "#": PALETTE.claudeOrange } })
+};
+var AGENT_SPRITES = {
+  claude: CLAUDE_SPRITES,
+  codex: CODEX_SPRITES,
+  grok: GROK_SPRITES
+};
+
+// src/render/sprites/world_sprites.ts
+var QUESTION_ROWS = ["oooooooo", "oyddddyo", "oydyydyo", "oyyyydyo", "oyyddyyo", "oyyyyyyo", "oyyddyyo", "oooooooo"];
+var WORLD_SPRITES = {
+  questionBlock: createSprite({
+    rows: QUESTION_ROWS,
+    palette: { o: PALETTE.blockShadow, y: PALETTE.blockYellow, d: PALETTE.brickMortar }
+  }),
+  questionBlockDim: createSprite({
+    rows: QUESTION_ROWS,
+    palette: { o: PALETTE.blockShadow, y: PALETTE.blockYellowDim, d: PALETTE.brickMortar }
+  }),
+  questionBlockBright: createSprite({
+    rows: QUESTION_ROWS,
+    palette: { o: PALETTE.blockYellow, y: PALETTE.blockYellowBright, d: PALETTE.brickMortar }
+  }),
+  brick: createSprite({
+    rows: ["mmmmmmmm", "bbbmbbbb", "bbbmbbbb", "mmmmmmmm", "bbbbbbbm", "bbbbbbbm", "mmmmmmmm", "bbbmbbbb"],
+    palette: { b: PALETTE.brick, m: PALETTE.brickMortar }
+  }),
+  brickChunk: createSprite({ rows: ["bb", "bm"], palette: { b: PALETTE.brick, m: PALETTE.brickMortar } }),
+  usedBlock: createSprite({
+    rows: ["mmmmmmmm", "mbbbbbbm", "mbbbbbbm", "mbbbbbbm", "mbbbbbbm", "mbbbbbbm", "mbbbbbbm", "mmmmmmmm"],
+    palette: { m: PALETTE.blockUsedEdge, b: PALETTE.blockUsed }
+  }),
+  mushroom: createSprite({
+    rows: ["..rrrr..", ".rwrrwr.", "rrrrrrrr", "rwrrrrwr", "rrrrrrrr", ".ssssss.", ".sessse.", "..ssss.."],
+    palette: { r: PALETTE.mushroomRed, w: PALETTE.cloud, s: PALETTE.mushroomStem, e: PALETTE.brickMortar }
+  }),
+  /** The 1-UP: a red heart that pops out of some ? blocks and adds a life. */
+  heart: createSprite({
+    rows: [".rr..rr.", "rpprrrrr", "rprrrrrr", "rrrrrrrr", ".rrrrrr.", "..rrrr..", "...rr...", "........"],
+    palette: { r: PALETTE.mushroomRed, p: PALETTE.heartLight }
+  }),
+  cloud: createSprite({
+    rows: [".....wwwww......", "...wwwwwwwww....", ".wwwwwwwwwwwwww.", "wwwwwwwwwwwwwwww", ".llllllllllllll."],
+    palette: { w: PALETTE.cloud, l: PALETTE.cloudShade }
+  }),
+  hill: createSprite({
+    rows: ["..........gg..........", ".......gggggggg.......", ".....gggggggggggg.....", "...ggggggggdggggggg...", "..ggggggggggggggdggg..", ".gggggggggggggggggggg.", "gggggggggggggggggggggg"],
+    palette: { g: PALETTE.hill, d: PALETTE.hillDark }
+  })
+};
+
+// src/sponsors/to_text_face.ts
+var HEX_RADIX2 = 16;
+var MAX_LINES = 2;
+function hexToRgb2(hex) {
+  return { r: Number.parseInt(hex.slice(1, 3), HEX_RADIX2), g: Number.parseInt(hex.slice(3, 5), HEX_RADIX2), b: Number.parseInt(hex.slice(5, 7), HEX_RADIX2) };
+}
+function splitLabel(label) {
+  const width = GAME_CONSTANTS.blockSize;
+  const trimmed = label.trim();
+  if (trimmed.length <= width) return [trimmed];
+  const space = trimmed.lastIndexOf(" ", width);
+  const cut = space > 0 ? space : width;
+  const rest = trimmed.slice(cut).trim().slice(0, width);
+  return [trimmed.slice(0, cut).trim(), rest].slice(0, MAX_LINES);
+}
+function toTextFace(sponsor) {
+  return { lines: splitLabel(sponsor.label), fg: hexToRgb2(sponsor.fg), bg: hexToRgb2(sponsor.bg) };
+}
+
+// src/game/compute_speed.ts
+function computeSpeed({ distance: distance2 }) {
+  const ramped = GAME_CONSTANTS.baseSpeed + distance2 * GAME_CONSTANTS.speedGainPerColumn;
+  return Math.min(GAME_CONSTANTS.maxSpeed, ramped);
+}
+
+// src/game/debris.ts
+var Debris = class {
+  sprite = WORLD_SPRITES.brickChunk;
+  x;
+  altitude;
+  velocityX;
+  velocityY;
+  ticksLeft = GAME_CONSTANTS.debrisTicks;
+  constructor({ x, altitude, velocityX, velocityY }) {
+    this.x = x;
+    this.altitude = altitude;
+    this.velocityX = velocityX;
+    this.velocityY = velocityY;
+  }
+  get isGone() {
+    return this.ticksLeft <= 0 || this.altitude < -this.sprite.height;
+  }
+  update({ scroll }) {
+    this.ticksLeft--;
+    this.velocityY -= GAME_CONSTANTS.gravity;
+    this.x += this.velocityX - scroll;
+    this.altitude += this.velocityY;
+  }
+  getX() {
+    return this.x;
+  }
+  getAltitude() {
+    return this.altitude;
+  }
+};
+
+// src/game/floating_text.ts
+var FloatingText = class {
+  text;
+  x;
+  altitude;
+  ticksLeft = GAME_CONSTANTS.floatingTextTicks;
+  constructor({ text, x, altitude }) {
+    this.text = text;
+    this.x = x;
+    this.altitude = altitude;
+  }
+  get isGone() {
+    return this.ticksLeft <= 0;
+  }
+  update({ scroll }) {
+    this.ticksLeft--;
+    this.x -= scroll;
+    this.altitude += GAME_CONSTANTS.floatingTextRise;
+  }
+  getX() {
+    return this.x;
+  }
+  getAltitude() {
+    return this.altitude;
+  }
+};
+
+// src/game/has_collision.ts
+function hasCollision({ a, b }) {
+  const overlapsX2 = a.x < b.x + b.width && a.x + a.width > b.x;
+  const overlapsY = a.y < b.y + b.height && a.y + a.height > b.y;
+  return overlapsX2 && overlapsY;
+}
+
+// src/render/sprites/crab_sprites.ts
+var CRAB_BODY2 = [".#...#.", "..###..", ".#d#d#.", "#######", ".#####."];
+var CRAB_PALETTE = { "#": PALETTE.bug, d: PALETTE.bugDark };
+var RED_CRAB = {
+  runA: createSprite({ rows: [...CRAB_BODY2, "#.#.#.#"], palette: CRAB_PALETTE }),
+  runB: createSprite({ rows: [...CRAB_BODY2, ".#.#.#."], palette: CRAB_PALETTE }),
+  squished: createSprite({ rows: [".#d#d#.", "#######"], palette: CRAB_PALETTE })
+};
+var CRAB_SPRITES = {
+  claude: AGENT_SPRITES.claude,
+  codex: RED_CRAB,
+  grok: AGENT_SPRITES.grok
+};
+
+// src/render/sprites/obstacle_sprites.ts
+var PIPE_PALETTE = { d: PALETTE.pipeDark, g: PALETTE.pipeGreen, l: PALETTE.pipeLight };
+var PIPE_BODY_ROW = ".dlgggggggd.";
+var OBSTACLE_SPRITES = {
+  pipe: createSprite({
+    rows: ["dddddddddddd", "dlggggggggld", "dddddddddddd", ...Array.from({ length: 9 }, () => PIPE_BODY_ROW)],
+    palette: PIPE_PALETTE
+  }),
+  ghost: createSprite({
+    rows: ["..####..", ".######.", "##e##e##", "########", "########", "#.#..#.#"],
+    palette: { "#": PALETTE.ghost, e: PALETTE.ghostEye }
+  })
+};
+
+// src/game/obstacle.ts
+var BOB_PERIOD_TICKS = 6;
+var BOB_AMPLITUDE = 1;
+var WALK_FRAME_TICKS = 6;
+var Obstacle = class {
+  kind;
+  enemy;
+  baseAltitude;
+  ownSpeed;
+  x;
+  walkDirection = -1;
+  age = 0;
+  squishedTicksLeft = -1;
+  constructor({ kind, x, altitude = 0, ownSpeed = 0, enemy = CRAB_SPRITES.codex }) {
+    this.kind = kind;
+    this.enemy = enemy;
+    this.x = x;
+    this.baseAltitude = altitude;
+    this.ownSpeed = ownSpeed;
+  }
+  get sprite() {
+    if (this.kind === "pipe") return OBSTACLE_SPRITES.pipe;
+    if (this.kind === "ghost") return OBSTACLE_SPRITES.ghost;
+    if (this.isSquished) return this.enemy.squished;
+    return Math.floor(this.age / WALK_FRAME_TICKS) % 2 === 0 ? this.enemy.runA : this.enemy.runB;
+  }
+  get isStompable() {
+    return this.kind === "bug" && !this.isSquished;
+  }
+  get isSquished() {
+    return this.squishedTicksLeft >= 0;
+  }
+  get isGone() {
+    return this.squishedTicksLeft === 0;
+  }
+  get isOffscreen() {
+    return this.x + this.sprite.width < 0;
+  }
+  /** Enemies walk on their own (left at first); the scroll is the player's running. */
+  update({ scroll }) {
+    this.age++;
+    if (this.squishedTicksLeft > 0) this.squishedTicksLeft--;
+    this.x += (this.isSquished ? 0 : this.ownSpeed * this.walkDirection) - scroll;
+  }
+  /** Pipes are walls for walkers too: step out of the pipe and turn around. */
+  bounceOff(barrier) {
+    const isLeftOfBarrier = this.x + this.sprite.width / 2 < barrier.x + barrier.width / 2;
+    this.x = isLeftOfBarrier ? barrier.x - this.sprite.width : barrier.x + barrier.width;
+    this.walkDirection = isLeftOfBarrier ? -1 : 1;
+  }
+  squish() {
+    this.squishedTicksLeft = GAME_CONSTANTS.squishTicks;
+  }
+  getBounds() {
+    return { x: this.x, y: this.getAltitude(), width: this.sprite.width, height: this.sprite.height };
+  }
+  getX() {
+    return this.x;
+  }
+  /** Flying obstacles bob up and down; grounded ones stay put. */
+  getAltitude() {
+    if (this.baseAltitude === 0) return 0;
+    return this.baseAltitude + Math.round(Math.sin(this.age / BOB_PERIOD_TICKS) * BOB_AMPLITUDE);
+  }
+};
+
+// src/game/player.ts
+var FRAME_COUNT = 2;
+var RESTING_EPSILON = 0.01;
+var NO_PRESS = -1e3;
+var Player = class {
+  sprites = AGENT_SPRITES.claude;
+  altitude = 0;
+  velocity = 0;
+  floor = 0;
+  screenX = GAME_CONSTANTS.playerX;
+  direction = 0;
+  moveTicksLeft = 0;
+  isHeldRight = false;
+  isHeldLeft = false;
+  hasHoldMode = false;
+  hasReliableRelease = false;
+  hasAirMomentum = false;
+  isStickyAfterJump = false;
+  lastPressTick = NO_PRESS;
+  duckTicksLeft = 0;
+  animationTick = 0;
+  isDead = false;
+  reset() {
+    this.altitude = 0;
+    this.velocity = 0;
+    this.floor = 0;
+    this.screenX = GAME_CONSTANTS.playerX;
+    this.direction = 0;
+    this.moveTicksLeft = 0;
+    this.isHeldRight = false;
+    this.isHeldLeft = false;
+    this.hasAirMomentum = false;
+    this.isStickyAfterJump = false;
+    this.lastPressTick = NO_PRESS;
+    this.duckTicksLeft = 0;
+    this.animationTick = 0;
+    this.isDead = false;
+  }
+  setSprites(sprites) {
+    this.sprites = sprites;
+  }
+  get isOnGround() {
+    return this.velocity === 0 && this.altitude <= this.floor + RESTING_EPSILON;
+  }
+  get isDucking() {
+    return this.duckTicksLeft > 0 && this.isOnGround;
+  }
+  get isFalling() {
+    return this.velocity < 0;
+  }
+  /** With key-release reports (Kitty protocol) a held key moves; otherwise key repeats keep a short timer alive. */
+  get isMoving() {
+    if (this.isDead) return false;
+    if (this.hasHoldMode) return this.isHeldNow && !this.isHeartbeatLost;
+    return this.moveTicksLeft > 0 || this.hasAirMomentum && !this.isOnGround || this.isStickyAfterJump;
+  }
+  get isHeldNow() {
+    return this.direction > 0 ? this.isHeldRight : this.direction < 0 && this.isHeldLeft;
+  }
+  /** Safety net: a "held" key that has sent nothing for seconds was released without a report. */
+  get isHeartbeatLost() {
+    if (this.hasReliableRelease) return false;
+    return this.animationTick - this.lastPressTick > GAME_CONSTANTS.holdHeartbeatTicks;
+  }
+  /** Releases will be reported; `reliable` (the OS key-state watcher) switches the heartbeat safety net off. */
+  enableHoldMode({ reliable = false } = {}) {
+    this.hasHoldMode = true;
+    this.hasReliableRelease = this.hasReliableRelease || reliable;
+  }
+  jump() {
+    if (!this.isOnGround || this.isDead) return;
+    this.duckTicksLeft = 0;
+    this.hasAirMomentum = this.isMoving;
+    this.velocity = GAME_CONSTANTS.jumpVelocity;
+  }
+  duck() {
+    if (this.isDead) return;
+    this.duckTicksLeft = GAME_CONSTANTS.duckTicks;
+    if (!this.isOnGround) this.velocity = Math.min(this.velocity, GAME_CONSTANTS.fastFallVelocity);
+  }
+  moveRight() {
+    this.isHeldRight = true;
+    this.press(1);
+  }
+  moveLeft() {
+    this.isHeldLeft = true;
+    this.press(-1);
+  }
+  releaseRight() {
+    this.isHeldRight = false;
+    if (this.isHeldLeft) this.direction = -1;
+  }
+  releaseLeft() {
+    this.isHeldLeft = false;
+    if (this.isHeldRight) this.direction = 1;
+  }
+  /** Stomp rebound: a small hop off the enemy's back. */
+  bounce() {
+    this.velocity = GAME_CONSTANTS.bounceVelocity;
+  }
+  /** Head hit a block: stop rising immediately and fall back down. */
+  bonk() {
+    this.velocity = Math.min(this.velocity, 0);
+  }
+  /** The altitude the player can stand on right now (ground or a block top under them). */
+  setFloor(altitude) {
+    this.floor = altitude;
+  }
+  markDead() {
+    this.isDead = true;
+  }
+  /**
+   * Horizontal step for this tick. Walking left or catching up to the home column moves the mascot on
+   * screen; running right past the home column scrolls the world instead, and that scroll is returned.
+   */
+  advanceHorizontal({ runSpeed }) {
+    if (!this.isMoving) return 0;
+    this.moveTicksLeft = Math.max(0, this.moveTicksLeft - 1);
+    if (this.direction < 0) {
+      this.screenX = Math.max(GAME_CONSTANTS.playerMinX, this.screenX - GAME_CONSTANTS.walkSpeed);
+      return 0;
+    }
+    if (this.screenX < GAME_CONSTANTS.playerX) {
+      this.screenX = Math.min(GAME_CONSTANTS.playerX, this.screenX + GAME_CONSTANTS.walkSpeed);
+      return 0;
+    }
+    return runSpeed;
+  }
+  update() {
+    this.animationTick++;
+    if (this.duckTicksLeft > 0) this.duckTicksLeft--;
+    if (this.isOnGround) return;
+    this.velocity -= GAME_CONSTANTS.gravity;
+    this.altitude += this.velocity;
+    if (this.altitude > this.floor || this.velocity > 0) return;
+    this.altitude = this.floor;
+    this.velocity = 0;
+    this.land();
+  }
+  /** Without release reports the OS never resumes the arrow's repeats after a jump, so the run stays on until the next press. */
+  land() {
+    if (!this.hasAirMomentum) return;
+    this.hasAirMomentum = false;
+    if (!this.hasHoldMode) this.isStickyAfterJump = this.direction > 0;
+  }
+  getSprite() {
+    if (this.isDead) return this.sprites.dead;
+    if (!this.isOnGround) return this.sprites.jump;
+    const frame = this.isMoving ? Math.floor(this.animationTick / GAME_CONSTANTS.runFrameTicks) % FRAME_COUNT : 0;
+    if (this.isDucking) return frame === 0 ? this.sprites.duckA : this.sprites.duckB;
+    return frame === 0 ? this.sprites.runA : this.sprites.runB;
+  }
+  /** World-space hit box, slightly inset on the sides and top so near misses feel fair. */
+  getBounds() {
+    const sprite = this.getSprite();
+    return {
+      x: this.screenX + GAME_CONSTANTS.collisionSideInset,
+      y: this.altitude,
+      width: sprite.width - GAME_CONSTANTS.collisionSideInset * 2,
+      height: sprite.height - GAME_CONSTANTS.collisionTopInset
+    };
+  }
+  getScreenX() {
+    return this.screenX;
+  }
+  getAltitude() {
+    return this.altitude;
+  }
+  getVelocity() {
+    return this.velocity;
+  }
+  /** Terminals have no key-up: a fresh press holds longer, key-repeat presses only top the timer up. */
+  press(direction) {
+    if (this.isDead) return;
+    this.isStickyAfterJump = false;
+    const isRepeat = this.animationTick - this.lastPressTick < GAME_CONSTANTS.moveRepeatWindowTicks;
+    this.moveTicksLeft = isRepeat ? GAME_CONSTANTS.moveRepeatTicks : GAME_CONSTANTS.moveHoldTicks;
+    this.lastPressTick = this.animationTick;
+    this.direction = direction;
+  }
+};
+
+// src/game/power_up.ts
+var PowerUp = class {
+  sprite;
+  link;
+  label;
+  textFace;
+  kind;
+  emergeTarget;
+  x;
+  altitude;
+  velocity = 0;
+  walkDirection = 1;
+  phase = "emerging";
+  constructor({ sprite, link, label, x, altitude, textFace = null, kind = "bonus" }) {
+    this.sprite = sprite;
+    this.kind = kind;
+    this.textFace = textFace;
+    this.link = link;
+    this.label = label;
+    this.x = x;
+    this.altitude = altitude;
+    this.emergeTarget = altitude + this.getHeight();
+  }
+  /** Still rising out of the block: not collectible yet, so a bonk does not instantly eat it. */
+  get isEmerging() {
+    return this.phase === "emerging";
+  }
+  get isOffscreen() {
+    return this.x + this.getWidth() < 0;
+  }
+  /** On-screen footprint: a high-density logo occupies one block cell (8×8 pixels). */
+  getWidth() {
+    return isHiResLogo(this.sprite) || this.textFace !== null ? GAME_CONSTANTS.blockSize : this.sprite.width;
+  }
+  getHeight() {
+    return isHiResLogo(this.sprite) || this.textFace !== null ? GAME_CONSTANTS.blockSize : this.sprite.height;
+  }
+  /** After emerging it walks right on its own, so it drifts toward the player even while they stand still. */
+  update({ scroll }) {
+    if (this.phase === "emerging") return this.emerge({ scroll });
+    this.x += GAME_CONSTANTS.powerUpWalkSpeed * this.walkDirection - scroll;
+    this.velocity -= GAME_CONSTANTS.gravity;
+    this.altitude = Math.max(0, this.altitude + this.velocity);
+    if (this.altitude === 0) this.velocity = 0;
+  }
+  /** Like a Mario mushroom it turns around at pipes. */
+  bounceOff(barrier) {
+    const isLeftOfBarrier = this.x + this.getWidth() / 2 < barrier.x + barrier.width / 2;
+    this.x = isLeftOfBarrier ? barrier.x - this.getWidth() : barrier.x + barrier.width;
+    this.walkDirection = isLeftOfBarrier ? -1 : 1;
+  }
+  getBounds() {
+    return { x: this.x, y: this.altitude, width: this.getWidth(), height: this.getHeight() };
+  }
+  getX() {
+    return this.x;
+  }
+  getAltitude() {
+    return this.altitude;
+  }
+  emerge({ scroll }) {
+    this.x -= scroll;
+    this.altitude = Math.min(this.emergeTarget, this.altitude + GAME_CONSTANTS.powerUpEmergeSpeed);
+    if (this.altitude >= this.emergeTarget) this.phase = "moving";
+  }
+};
+
+// src/game/question_block.ts
+var BLINK_FRAME_TICKS = 7;
+var BLINK_CYCLE = [
+  WORLD_SPRITES.questionBlock,
+  WORLD_SPRITES.questionBlock,
+  WORLD_SPRITES.questionBlock,
+  WORLD_SPRITES.questionBlockDim,
+  WORLD_SPRITES.questionBlockBright,
+  WORLD_SPRITES.questionBlock
+];
+var QuestionBlock = class {
+  kind;
+  sponsor;
+  x;
+  age = 0;
+  isUsed = false;
+  constructor({ x, sponsor, kind = "question" }) {
+    this.x = x;
+    this.sponsor = sponsor;
+    this.kind = kind;
+  }
+  get sprite() {
+    if (this.kind === "brick") return WORLD_SPRITES.brick;
+    if (this.isUsed) return WORLD_SPRITES.usedBlock;
+    return BLINK_CYCLE[Math.floor(this.age / BLINK_FRAME_TICKS) % BLINK_CYCLE.length] ?? WORLD_SPRITES.questionBlock;
+  }
+  get isFresh() {
+    return !this.isUsed;
+  }
+  /** A smashed brick leaves the world entirely. */
+  get isGone() {
+    return this.kind === "brick" && this.isUsed;
+  }
+  get isOffscreen() {
+    return this.x + GAME_CONSTANTS.blockSize < 0;
+  }
+  update({ scroll }) {
+    this.x -= scroll;
+    this.age++;
+  }
+  hit() {
+    this.isUsed = true;
+  }
+  getX() {
+    return this.x;
+  }
+  getAltitude() {
+    return GAME_CONSTANTS.blockAltitude;
+  }
+  getTop() {
+    return GAME_CONSTANTS.blockAltitude + GAME_CONSTANTS.blockSize;
+  }
+  getBounds() {
+    return { x: this.x, y: this.getAltitude(), width: GAME_CONSTANTS.blockSize, height: GAME_CONSTANTS.blockSize };
+  }
+};
+
+// src/game/scenery.ts
+var Scenery = class {
+  random;
+  items = [];
+  untilCloud = 0;
+  untilHill = GAME_CONSTANTS.hillInterval / 2;
+  constructor({ random = Math.random } = {}) {
+    this.random = random;
+  }
+  reset() {
+    this.items = [];
+    this.untilCloud = 0;
+    this.untilHill = GAME_CONSTANTS.hillInterval / 2;
+  }
+  getItems() {
+    return this.items;
+  }
+  update({ scroll, screenWidth }) {
+    this.items.forEach((item) => {
+      item.x -= scroll * item.parallax;
+    });
+    this.items = this.items.filter((item) => item.x + item.sprite.width >= 0);
+    this.untilCloud -= scroll;
+    this.untilHill -= scroll;
+    if (this.untilCloud <= 0) this.spawnCloud(screenWidth);
+    if (this.untilHill <= 0) this.spawnHill(screenWidth);
+  }
+  spawnCloud(screenWidth) {
+    const altitude = GAME_CONSTANTS.cloudMinAltitude + Math.floor(this.random() * GAME_CONSTANTS.cloudAltitudeSpread);
+    this.items.push({ sprite: WORLD_SPRITES.cloud, parallax: GAME_CONSTANTS.cloudParallax, x: screenWidth, altitude });
+    this.untilCloud = GAME_CONSTANTS.cloudInterval * (0.6 + this.random() * 0.8);
+  }
+  spawnHill(screenWidth) {
+    this.items.push({ sprite: WORLD_SPRITES.hill, parallax: GAME_CONSTANTS.hillParallax, x: screenWidth, altitude: 0 });
+    this.untilHill = GAME_CONSTANTS.hillInterval * (0.7 + this.random() * 0.6);
+  }
+};
+
+// src/render/sprites/token_sprite.ts
+var TOKEN_SPRITE = createSprite({
+  rows: [".gggg.", "gsggdg", "gsggdg", "gsggdg", "gsggdg", ".gggg."],
+  palette: { g: PALETTE.token, s: PALETTE.tokenShine, d: PALETTE.tokenDark }
+});
+
+// src/sponsors/pick_ranked_sponsor.ts
+function pickRankedSponsor({ sponsors, roll }) {
+  const count = sponsors.length;
+  if (count === 0) return null;
+  const totalShares = count * (count + 1) / 2;
+  let remaining = roll * totalShares;
+  for (let i = 0; i < count; i++) {
+    const shares = count - i;
+    if (remaining < shares) return sponsors[i] ?? null;
+    remaining -= shares;
+  }
+  return sponsors[0] ?? null;
+}
+
+// src/game/token.ts
+var BOB_PERIOD_TICKS2 = 8;
+var BOB_AMPLITUDE2 = 1.5;
+var Token = class {
+  sprite;
+  link;
+  baseAltitude;
+  x;
+  age = 0;
+  isCollectedFlag = false;
+  constructor({ x, altitude, sprite = TOKEN_SPRITE, link = null }) {
+    this.x = x;
+    this.baseAltitude = altitude;
+    this.sprite = sprite;
+    this.link = link;
+  }
+  get isCollected() {
+    return this.isCollectedFlag;
+  }
+  get isOffscreen() {
+    return this.x + this.sprite.width < 0;
+  }
+  update({ scroll }) {
+    this.x -= scroll;
+    this.age++;
+  }
+  collect() {
+    this.isCollectedFlag = true;
+  }
+  getBounds() {
+    return { x: this.x, y: this.getAltitude(), width: this.sprite.width, height: this.sprite.height };
+  }
+  getX() {
+    return this.x;
+  }
+  getAltitude() {
+    return this.baseAltitude + Math.round(Math.sin(this.age / BOB_PERIOD_TICKS2) * BOB_AMPLITUDE2);
+  }
+};
+
+// src/game/spawner.ts
+var SPAWN_MARGIN = 2;
+var BUG_PAIR_OFFSET = 9;
+var GAP_FRACTION = 0.45;
+var HIGH_GHOST_CHANCE = 0.5;
+var PREVIEW_ENEMY_OFFSET = 30;
+var PREVIEW_ENEMY_SPACING = 14;
+var PREVIEW_COIN_OFFSET = 26;
+var PREVIEW_COIN_ALTITUDE = 10;
+var PREVIEW_BLOCK_OFFSET = 0;
+var PREVIEW_CARD_CLEARANCE = 2;
+var EMPTY_RESULT = { obstacles: [], tokens: [], blocks: [] };
+var Spawner = class {
+  random;
+  distanceUntilNext = GAME_CONSTANTS.minGapColumns;
+  mysterySponsors = [];
+  isFirstBlockOfRun = true;
+  rivals = ["codex", "grok"];
+  rivalIndex = 0;
+  constructor({ random = Math.random } = {}) {
+    this.random = random;
+  }
+  reset() {
+    this.distanceUntilNext = GAME_CONSTANTS.minGapColumns;
+    this.isFirstBlockOfRun = true;
+  }
+  /** The agents that walk toward the player; they alternate. */
+  setRivals(rivals) {
+    this.rivals = rivals;
+  }
+  /** Mystery sponsors pop out of the ? boxes (logo or heart); banner and ranking sponsors are drawn by the renderer. Coins stay gold. */
+  setSponsors({ mysterySponsors }) {
+    this.mysterySponsors = mysterySponsors;
+  }
+  /** What the title screen shows on the right: one of each rival, a coin arc and a ? block. */
+  createPreview({ screenWidth }) {
+    const enemyX = screenWidth - PREVIEW_ENEMY_OFFSET;
+    const obstacles = this.rivals.map((rival, i) => new Obstacle({ kind: "bug", x: enemyX + i * PREVIEW_ENEMY_SPACING, ownSpeed: GAME_CONSTANTS.bugWalkSpeed, enemy: CRAB_SPRITES[rival] }));
+    const coins = GAME_CONSTANTS.tokenArc.map((lift, i) => new Token({ x: enemyX - PREVIEW_COIN_OFFSET + i * (TOKEN_SPRITE.width + 1), altitude: PREVIEW_COIN_ALTITUDE + lift }));
+    const sponsor = this.mysterySponsors[0] ?? null;
+    const cardRight = Math.floor((screenWidth + TITLE_CARD.width) / 2);
+    const blockX = enemyX - PREVIEW_BLOCK_OFFSET;
+    if (blockX < cardRight + PREVIEW_CARD_CLEARANCE) return { obstacles, tokens: coins, blocks: [] };
+    const brick = (offset) => new QuestionBlock({ x: blockX + offset * BLOCK_WIDTH, sponsor: null, kind: "brick" });
+    const blocks = [brick(0), new QuestionBlock({ x: blockX + BLOCK_WIDTH, sponsor }), brick(2)];
+    return { obstacles, tokens: coins, blocks };
+  }
+  update({ scroll, runSpeed, distance: distance2, screenWidth }) {
+    this.distanceUntilNext -= scroll;
+    if (this.distanceUntilNext > 0) return EMPTY_RESULT;
+    const spawnX = screenWidth + SPAWN_MARGIN;
+    const obstacles = this.createGroup({ x: spawnX, distance: distance2 });
+    const gap = this.pickGap({ speed: runSpeed });
+    const groupEndX = Math.max(...obstacles.map((obstacle) => obstacle.getX() + obstacle.sprite.width));
+    const rewardX = groupEndX + Math.floor(gap * GAP_FRACTION);
+    this.distanceUntilNext = gap;
+    if (this.random() < GAME_CONSTANTS.blockGroupChance) return { obstacles, tokens: [], blocks: this.createBlocks({ x: rewardX }) };
+    return { obstacles, tokens: this.createTokens({ x: rewardX }), blocks: [] };
+  }
+  pickGap({ speed }) {
+    const spread = GAME_CONSTANTS.maxGapColumns - GAME_CONSTANTS.minGapColumns;
+    return GAME_CONSTANTS.minGapColumns + this.random() * spread + speed * GAME_CONSTANTS.gapPerSpeed;
+  }
+  pickKind({ distance: distance2 }) {
+    const roll = this.random();
+    if (distance2 > GAME_CONSTANTS.ghostMinDistance && roll < GAME_CONSTANTS.ghostChance) return "ghost";
+    if (distance2 > GAME_CONSTANTS.pipeMinDistance && roll < GAME_CONSTANTS.pipeChance) return "pipe";
+    return "bug";
+  }
+  createGroup({ x, distance: distance2 }) {
+    const kind = this.pickKind({ distance: distance2 });
+    if (kind === "ghost") return [this.createGhost({ x })];
+    if (kind === "pipe") return [new Obstacle({ kind, x })];
+    const isPair = distance2 > GAME_CONSTANTS.bugPairMinDistance && this.random() < GAME_CONSTANTS.bugPairChance;
+    const bug = (bugX) => new Obstacle({ kind, x: bugX, ownSpeed: GAME_CONSTANTS.bugWalkSpeed, enemy: CRAB_SPRITES[this.nextRival()] });
+    return isPair ? [bug(x), bug(x + BUG_PAIR_OFFSET)] : [bug(x)];
+  }
+  createGhost({ x }) {
+    const isHigh = this.random() < HIGH_GHOST_CHANCE;
+    const altitude = isHigh ? GAME_CONSTANTS.ghostHighAltitude : GAME_CONSTANTS.ghostMidAltitude;
+    return new Obstacle({ kind: "ghost", x, altitude, ownSpeed: GAME_CONSTANTS.ghostFlySpeed });
+  }
+  nextRival() {
+    const rival = this.rivals[this.rivalIndex % Math.max(1, this.rivals.length)] ?? "codex";
+    this.rivalIndex++;
+    return rival;
+  }
+  /** The very first ? block of a run belongs to the top sponsor; after that blocks are shared by rank. */
+  nextBlockSponsor() {
+    if (!this.isFirstBlockOfRun) return pickRankedSponsor({ sponsors: this.mysterySponsors, roll: this.random() });
+    this.isFirstBlockOfRun = false;
+    return this.mysterySponsors[0] ?? null;
+  }
+  /** Groups of 1, 2, 3 or 5: a 3 has one ? block in the middle, a 5 has two, singles/doubles sometimes one; the rest are bricks. */
+  createBlocks({ x }) {
+    const count = this.pickBlockCount();
+    const questionSlots = this.pickQuestionSlots(count);
+    return Array.from({ length: count }, (_, i) => {
+      if (!questionSlots.has(i)) return new QuestionBlock({ x: x + i * BLOCK_WIDTH, sponsor: null, kind: "brick" });
+      return new QuestionBlock({ x: x + i * BLOCK_WIDTH, sponsor: this.nextBlockSponsor() });
+    });
+  }
+  pickBlockCount() {
+    let roll = this.random();
+    for (let i = 0; i < GAME_CONSTANTS.blockGroupSizes.length; i++) {
+      roll -= GAME_CONSTANTS.blockGroupWeights[i] ?? 0;
+      if (roll <= 0) return GAME_CONSTANTS.blockGroupSizes[i] ?? 1;
+    }
+    return GAME_CONSTANTS.blockGroupSizes[GAME_CONSTANTS.blockGroupSizes.length - 1] ?? 1;
+  }
+  pickQuestionSlots(count) {
+    if (count >= 5) return /* @__PURE__ */ new Set([1, 3]);
+    if (count === 3) return /* @__PURE__ */ new Set([1]);
+    if (count === 2) return /* @__PURE__ */ new Set([this.random() < 0.5 ? 0 : 1]);
+    return this.random() < GAME_CONSTANTS.singleBlockQuestionChance ? /* @__PURE__ */ new Set([0]) : /* @__PURE__ */ new Set();
+  }
+  createTokens({ x }) {
+    if (this.random() > GAME_CONSTANTS.tokenSpawnChance) return [];
+    const altitudes = GAME_CONSTANTS.tokenAltitudes;
+    const base = altitudes[Math.floor(this.random() * altitudes.length)] ?? 0;
+    const spacing = Math.max(GAME_CONSTANTS.tokenSpacing, TOKEN_SPRITE.width + 1);
+    return Array.from({ length: GAME_CONSTANTS.tokenRowCount }, (_, i) => {
+      const lift = GAME_CONSTANTS.tokenArc[i] ?? 0;
+      return new Token({ x: x + i * spacing, altitude: base + lift });
+    });
+  }
+};
+var BLOCK_WIDTH = GAME_CONSTANTS.blockSize;
+
+// src/game/game_world.ts
+var OFFSCREEN_RIGHT_MARGIN = 60;
+var TITLE_SCROLL_EXTENT = TITLE_CARD.width * 2 + 3;
+function overlapsX(a, b) {
+  return a.x < b.x + b.width && a.x + a.width > b.x;
+}
+var GameWorld = class {
+  player = new Player();
+  spawner;
+  scenery;
+  obstacles = [];
+  tokens = [];
+  blocks = [];
+  powerUps = [];
+  texts = [];
+  debris = [];
+  /** Column of the title plate; it sits in the level and scrolls away once the run starts. */
+  titleX = null;
+  screenWidth;
+  distance = 0;
+  speed = GAME_CONSTANTS.baseSpeed;
+  tokensCollected = 0;
+  bonus = 0;
+  sponsorPickups = 0;
+  lives = GAME_CONSTANTS.startLives;
+  invulnerableTicks = 0;
+  random;
+  constructor({ screenWidth, random = Math.random }) {
+    this.screenWidth = screenWidth;
+    this.random = random;
+    this.spawner = new Spawner({ random });
+    this.scenery = new Scenery({ random });
+    this.reset();
+  }
+  reset() {
+    this.player.reset();
+    this.spawner.reset();
+    this.scenery.reset();
+    this.obstacles = [];
+    this.tokens = [];
+    this.blocks = [];
+    this.powerUps = [];
+    this.texts = [];
+    this.debris = [];
+    this.titleX = Math.floor((this.screenWidth - TITLE_CARD.width) / 2);
+    this.distance = 0;
+    this.speed = GAME_CONSTANTS.baseSpeed;
+    this.tokensCollected = 0;
+    this.bonus = 0;
+    this.sponsorPickups = 0;
+    this.lives = GAME_CONSTANTS.startLives;
+    this.invulnerableTicks = 0;
+    this.seedPreview();
+  }
+  /** Populate the right side so the title screen already shows enemies, coins and a block. */
+  seedPreview() {
+    const preview = this.spawner.createPreview({ screenWidth: this.screenWidth });
+    this.obstacles.push(...preview.obstacles);
+    this.tokens.push(...preview.tokens);
+    this.blocks.push(...preview.blocks);
+  }
+  /** Play as one agent; the other two walk in as enemies. */
+  setAgent(agent) {
+    this.player.setSprites(AGENT_SPRITES[agent]);
+    this.spawner.setRivals(AGENT_KINDS.filter((kind) => kind !== agent));
+    this.reset();
+  }
+  setSponsors(sponsors) {
+    this.spawner.setSponsors({ mysterySponsors: sponsors.filter((sponsor) => sponsor.tier === "mystery") });
+  }
+  get score() {
+    return Math.floor(this.distance * GAME_CONSTANTS.scorePerColumn) + this.tokensCollected * GAME_CONSTANTS.coinPoints + this.bonus;
+  }
+  getDistance() {
+    return this.distance;
+  }
+  getSpeed() {
+    return this.speed;
+  }
+  getTokensCollected() {
+    return this.tokensCollected;
+  }
+  getBonus() {
+    return this.bonus;
+  }
+  getLives() {
+    return this.lives;
+  }
+  /** Just lost a life: enemies pass through and the mascot blinks. */
+  get isInvulnerable() {
+    return this.invulnerableTicks > 0;
+  }
+  getInvulnerableTicks() {
+    return this.invulnerableTicks;
+  }
+  getObstacles() {
+    return this.obstacles;
+  }
+  getTokens() {
+    return this.tokens;
+  }
+  getBlocks() {
+    return this.blocks;
+  }
+  getPowerUps() {
+    return this.powerUps;
+  }
+  getTexts() {
+    return this.texts;
+  }
+  getDebris() {
+    return this.debris;
+  }
+  getTitleX() {
+    return this.titleX;
+  }
+  getScenery() {
+    return this.scenery.getItems();
+  }
+  setScreenWidth(screenWidth) {
+    this.screenWidth = screenWidth;
+  }
+  /** Direct placement, used by tests and scripted moments. */
+  addObstacle(obstacle) {
+    this.obstacles.push(obstacle);
+  }
+  addBlock(block) {
+    this.blocks.push(block);
+  }
+  step() {
+    const runSpeed = computeSpeed({ distance: this.distance });
+    this.speed = this.clampToPipes(this.player.advanceHorizontal({ runSpeed }));
+    this.distance += this.speed;
+    this.advanceEntities();
+    this.spawnEntities();
+    this.player.setFloor(this.computeFloor());
+    this.hitBlocks();
+    this.player.update();
+    const collectedNow = this.collectTokens();
+    this.collectPowerUps();
+    if (this.invulnerableTicks > 0) this.invulnerableTicks--;
+    const hasCollided = this.resolveEnemies();
+    const isGameOver = hasCollided && this.loseLife();
+    if (isGameOver) this.player.markDead();
+    return { hasCollided, isGameOver, collectedNow };
+  }
+  /** Costs one life; with lives left the mascot hops back and blinks for a moment. Returns true when none remain. */
+  loseLife() {
+    this.lives = Math.max(0, this.lives - 1);
+    if (this.lives <= 0) return true;
+    this.invulnerableTicks = GAME_CONSTANTS.hurtInvulnerableTicks;
+    this.player.bounce();
+    this.texts.push(new FloatingText({ text: "-1 LIFE", x: this.player.getScreenX(), altitude: this.player.getAltitude() + 10 }));
+    return false;
+  }
+  advanceEntities() {
+    const scroll = this.speed;
+    this.obstacles.forEach((obstacle) => obstacle.update({ scroll }));
+    this.tokens.forEach((token) => token.update({ scroll }));
+    this.blocks.forEach((block) => block.update({ scroll }));
+    this.powerUps.forEach((powerUp) => powerUp.update({ scroll }));
+    this.texts.forEach((text) => text.update({ scroll }));
+    this.debris.forEach((piece) => piece.update({ scroll }));
+    if (this.titleX !== null) this.titleX = this.titleX + TITLE_SCROLL_EXTENT < 0 ? null : this.titleX - scroll;
+    this.scenery.update({ scroll, screenWidth: this.screenWidth });
+    this.bounceOffPipes();
+    this.obstacles = this.obstacles.filter((obstacle) => !obstacle.isOffscreen && !obstacle.isGone && obstacle.getX() < this.screenWidth + OFFSCREEN_RIGHT_MARGIN);
+    this.tokens = this.tokens.filter((token) => !token.isOffscreen && !token.isCollected);
+    this.blocks = this.blocks.filter((block) => !block.isOffscreen && !block.isGone);
+    this.debris = this.debris.filter((piece) => !piece.isGone);
+    this.powerUps = this.powerUps.filter((powerUp) => !powerUp.isOffscreen);
+    this.texts = this.texts.filter((text) => !text.isGone);
+  }
+  spawnEntities() {
+    const spawned = this.spawner.update({ scroll: this.speed, runSpeed: computeSpeed({ distance: this.distance }), distance: this.distance, screenWidth: this.screenWidth });
+    this.obstacles.push(...spawned.obstacles);
+    this.tokens.push(...spawned.tokens);
+    this.blocks.push(...spawned.blocks);
+  }
+  /** Highest block top under the player that they are above (within landing tolerance), else the ground. */
+  computeFloor() {
+    const bounds = this.player.getBounds();
+    const altitude = this.player.getAltitude();
+    const platforms = [...this.blocks.map((block) => block.getBounds()), ...this.pipes().map((pipe) => pipe.getBounds())];
+    const tops = platforms.filter((platform) => overlapsX(bounds, platform) && altitude >= platform.y + platform.height - GAME_CONSTANTS.landingTolerance).map((platform) => platform.y + platform.height);
+    return Math.max(0, ...tops);
+  }
+  /** Walkers and mushrooms stay between the pipes, pacing back and forth. */
+  bounceOffPipes() {
+    const pipes = this.pipes().map((pipe) => pipe.getBounds());
+    const walkers = this.obstacles.filter((obstacle) => obstacle.kind !== "pipe" && !obstacle.isSquished);
+    pipes.forEach((pipe) => {
+      walkers.filter((walker) => hasCollision({ a: walker.getBounds(), b: pipe })).forEach((walker) => walker.bounceOff(pipe));
+      this.powerUps.filter((powerUp) => hasCollision({ a: powerUp.getBounds(), b: pipe })).forEach((powerUp) => powerUp.bounceOff(pipe));
+    });
+  }
+  pipes() {
+    return this.obstacles.filter((obstacle) => obstacle.kind === "pipe");
+  }
+  /** Pipes are solid: running into one just stops the scroll (Mario bumps into the pipe), it never hurts. */
+  clampToPipes(scroll) {
+    if (scroll <= 0) return scroll;
+    const bounds = this.player.getBounds();
+    const playerRight = bounds.x + bounds.width;
+    const gaps = this.pipes().map((pipe) => pipe.getBounds()).filter((pipe) => bounds.y < pipe.height - GAME_CONSTANTS.landingTolerance && pipe.x + pipe.width > bounds.x).map((pipe) => Math.max(0, pipe.x - playerRight));
+    return Math.min(scroll, ...gaps);
+  }
+  hitBlocks() {
+    if (this.player.getVelocity() <= 0) return;
+    const bounds = this.player.getBounds();
+    const top = bounds.y + bounds.height;
+    const hit = this.blocks.find((block) => {
+      const isUnder = top >= block.getAltitude() - 1 && top <= block.getAltitude() + GAME_CONSTANTS.blockHitTolerance;
+      return block.isFresh && isUnder && overlapsX(bounds, block.getBounds());
+    });
+    if (hit === void 0) return;
+    hit.hit();
+    this.player.bonk();
+    if (hit.kind === "brick") return this.smashBrick(hit);
+    this.powerUps.push(this.createPowerUp(hit));
+  }
+  /** A bonked brick bursts into four chunks and pays a small bonus. */
+  smashBrick(brick) {
+    const bounds = brick.getBounds();
+    const corners = [
+      { dx: 0, vx: -0.7, vy: 3.2 },
+      { dx: bounds.width - 2, vx: 0.7, vy: 3.2 },
+      { dx: 1, vx: -0.4, vy: 2.2 },
+      { dx: bounds.width - 3, vx: 0.4, vy: 2.2 }
+    ];
+    corners.forEach(({ dx, vx, vy }) => this.debris.push(new Debris({ x: bounds.x + dx, altitude: bounds.y + bounds.height / 2, velocityX: vx, velocityY: vy })));
+    this.bonus += GAME_CONSTANTS.brickBonus;
+  }
+  createPowerUp(block) {
+    const sponsor = block.sponsor;
+    if (this.random() < GAME_CONSTANTS.oneUpChance) return this.createOneUp(block);
+    const isText = sponsor !== null && sponsor.style === "text";
+    return new PowerUp({
+      sprite: sponsor === null || isText ? WORLD_SPRITES.mushroom : toSponsorSprite(sponsor),
+      textFace: isText && sponsor !== null ? toTextFace(sponsor) : null,
+      link: sponsor?.url ?? null,
+      label: sponsor?.name ?? "mushroom",
+      x: block.getX(),
+      altitude: block.getAltitude()
+    });
+  }
+  /** Some blocks drop a heart (1-UP) instead; a sponsor's block still gets the credit and the link. */
+  createOneUp(block) {
+    return new PowerUp({
+      kind: "life",
+      sprite: WORLD_SPRITES.heart,
+      link: block.sponsor?.url ?? null,
+      label: block.sponsor?.name ?? "1UP",
+      x: block.getX(),
+      altitude: block.getAltitude()
+    });
+  }
+  collectTokens() {
+    const bounds = this.player.getBounds();
+    const touched = this.tokens.filter((token) => hasCollision({ a: bounds, b: token.getBounds() }));
+    touched.forEach((token) => token.collect());
+    this.tokensCollected += touched.length;
+    return touched.length;
+  }
+  collectPowerUps() {
+    const bounds = this.player.getBounds();
+    const touched = this.powerUps.filter((powerUp) => !powerUp.isEmerging && hasCollision({ a: bounds, b: powerUp.getBounds() }));
+    if (touched.length === 0) return;
+    this.powerUps = this.powerUps.filter((powerUp) => !touched.includes(powerUp));
+    touched.forEach((powerUp) => this.collectPowerUp(powerUp));
+  }
+  /** A sponsor logo pays a growing bonus (+300, +400, ...) shown as "+300 by FIGMA"; a plain mushroom pays +200. */
+  collectPowerUp(powerUp) {
+    if (powerUp.kind === "life") return this.gainLife(powerUp);
+    if (powerUp.link === null) return this.reward({ points: GAME_CONSTANTS.powerUpBonus, label: "" });
+    const points = GAME_CONSTANTS.sponsorBonusStart + GAME_CONSTANTS.sponsorBonusStep * this.sponsorPickups;
+    this.sponsorPickups++;
+    this.reward({ points, label: `by ${powerUp.label.toUpperCase()}` });
+  }
+  gainLife(powerUp) {
+    this.lives = Math.min(GAME_CONSTANTS.maxLives, this.lives + 1);
+    const credit = powerUp.link === null ? "" : ` by ${powerUp.label.toUpperCase()}`;
+    this.texts.push(new FloatingText({ text: `+1 LIFE${credit}`, x: this.player.getScreenX(), altitude: this.player.getAltitude() + 10 }));
+  }
+  /** Falling onto a bug squishes it for a bonus; any other contact ends the run. */
+  resolveEnemies() {
+    const bounds = this.player.getBounds();
+    const touching = this.obstacles.filter((obstacle) => obstacle.kind !== "pipe" && !obstacle.isSquished && hasCollision({ a: bounds, b: obstacle.getBounds() }));
+    const stomped = touching.filter((obstacle) => this.isStomping({ bounds, obstacle }));
+    stomped.forEach((obstacle) => {
+      obstacle.squish();
+      this.reward({ points: GAME_CONSTANTS.stompBonus, label: "" });
+    });
+    if (stomped.length > 0) this.player.bounce();
+    return !this.isInvulnerable && touching.length > stomped.length;
+  }
+  isStomping({ bounds, obstacle }) {
+    const enemyTop = obstacle.getBounds().y + obstacle.getBounds().height;
+    return obstacle.isStompable && this.player.isFalling && bounds.y >= enemyTop - GAME_CONSTANTS.stompTolerance;
+  }
+  reward({ points, label }) {
+    this.bonus += points;
+    const text = label.length === 0 ? `+${points}` : `+${points} ${label}`;
+    this.texts.push(new FloatingText({ text, x: this.player.getScreenX(), altitude: this.player.getAltitude() + 10 }));
+  }
+};
+
+// src/game/game.ts
+var RANKING_OFF = { state: "off", result: null };
+var Game = class {
+  screen;
+  input;
+  scoreStore;
+  claudeWatcher;
+  onQuit;
+  playerName;
+  agent;
+  leaderboard;
+  sponsorSource;
+  menu;
+  renderer;
+  ranking = RANKING_OFF;
+  sponsors = [];
+  world;
+  phase = "ready";
+  mode;
+  scores;
+  banner = null;
+  isPausedByClaude = false;
+  lastClaudeStatus = "";
+  tickCount = 0;
+  timer = null;
+  isStopped = false;
+  constructor({ screen, input, scoreStore, claudeWatcher, onQuit, playerName, agent = "claude", leaderboard = null, sponsorSource = null, settings = null, random = Math.random }) {
+    this.screen = screen;
+    this.input = input;
+    this.scoreStore = scoreStore;
+    this.claudeWatcher = claudeWatcher;
+    this.onQuit = onQuit;
+    this.playerName = playerName;
+    this.agent = agent;
+    this.leaderboard = leaderboard;
+    this.sponsorSource = sponsorSource;
+    this.menu = settings === null ? null : new SettingsMenu({ store: settings });
+    this.mode = settings === null ? "vibe" : settings.load().mode;
+    const size = screen.getSize();
+    this.renderer = new GameRenderer({ size });
+    this.world = new GameWorld({ screenWidth: this.renderer.getLayout().columns, random });
+    this.world.setAgent(agent);
+    this.scores = scoreStore.load();
+  }
+  getPhase() {
+    return this.phase;
+  }
+  getWorld() {
+    return this.world;
+  }
+  getMode() {
+    return this.mode;
+  }
+  /** PRO CODER only lets the mascot run while the agent is busy with a prompt. */
+  get canPlay() {
+    return this.mode === "vibe" || isAgentWorking({ record: this.claudeWatcher.getCurrent() });
+  }
+  /** The line the overlay shows instead of "press SPACE" while PRO CODER is waiting for the agent. */
+  get lockMessage() {
+    if (this.canPlay) return null;
+    const agent = AGENT_LABELS[this.claudeWatcher.getCurrent()?.agent ?? this.agent];
+    return `${GAME_MODE_LABELS.pro}: plays only while ${agent} is working`;
+  }
+  start() {
+    this.screen.enter();
+    this.input.start(this.handleAction);
+    this.screen.onResize(this.handleResize);
+    this.timer = setInterval(() => this.tick(), GAME_CONSTANTS.tickMs);
+    this.loadRanking();
+    this.loadSponsors();
+    this.render();
+  }
+  loadSponsors() {
+    if (this.sponsorSource === null) return;
+    this.sponsorSource.loadSponsors().then((sponsors) => {
+      this.sponsors = sponsors;
+      this.world.setSponsors(sponsors);
+    }).catch(() => {
+      this.sponsors = [];
+    });
+  }
+  loadRanking() {
+    if (this.leaderboard === null) return;
+    this.ranking = { state: "pending", result: null };
+    this.leaderboard.fetchRanking({ limit: GAME_CONSTANTS.rankingPanelLimit, mode: this.mode, score: this.mode === "pro" ? this.scores.proHighScore : this.scores.highScore }).then((result) => {
+      this.ranking = { state: "ready", result };
+    }).catch(() => {
+      this.ranking = { state: "failed", result: null };
+    });
+  }
+  stop() {
+    if (this.isStopped) return;
+    this.isStopped = true;
+    if (this.timer !== null) clearInterval(this.timer);
+    this.input.stop();
+    this.screen.exit();
+  }
+  tick() {
+    this.tickCount++;
+    this.pollClaude();
+    this.updateBanner();
+    if (this.phase === "running") this.stepWorld();
+    this.render();
+  }
+  handleAction = (action) => {
+    if (action === "quit") return this.quit();
+    if (action === "settings") return this.toggleSettings();
+    if (this.menu !== null && this.menu.isOpen) return this.handleMenuAction(action);
+    if (action === "up") return this.handleAction("jump");
+    if (action === "down") return this.handleAction("duck");
+    if (action === "pause") return this.togglePause();
+    if (action === "restart") return this.restart();
+    if (action === "duck" && this.phase === "running") return this.world.player.duck();
+    if (action === "hold_support") return this.world.player.enableHoldMode();
+    if (action === "hold_reliable") return this.world.player.enableHoldMode({ reliable: true });
+    if (action === "left_release") return this.world.player.releaseLeft();
+    if (action === "right_release") return this.world.player.releaseRight();
+    if (action === "left" && this.phase === "running") return this.world.player.moveLeft();
+    if (action === "right" && this.phase === "running") return this.world.player.moveRight();
+    if (action === "right" && this.phase === "ready") return this.beginRun();
+    if (action !== "jump") return;
+    if (this.phase === "paused") return this.togglePause();
+    if (this.phase === "ready") return this.beginRun();
+    if (this.phase === "over") return this.restart();
+    if (this.phase === "running") this.world.player.jump();
+  };
+  /** The settings panel replaces the title plate on the start and pause screens. */
+  toggleSettings() {
+    if (this.menu === null || this.phase !== "ready" && this.phase !== "paused") return;
+    this.menu.toggle();
+  }
+  handleMenuAction(action) {
+    if (this.menu === null) return;
+    if (action === "up") return this.menu.moveSelection(-1);
+    if (action === "down") return this.menu.moveSelection(1);
+    if (action === "left") return this.applySetting(-1);
+    if (action === "right" || action === "jump") return this.applySetting(1);
+  }
+  applySetting(direction) {
+    if (this.menu === null) return;
+    const config = this.menu.change(direction);
+    if (config.mode !== this.mode) {
+      this.mode = config.mode;
+      this.loadRanking();
+    }
+    if (config.character !== "auto") this.world.setAgent(config.character);
+  }
+  handleResize = () => {
+    const size = this.screen.getSize();
+    this.renderer.resize({ size });
+    this.world.setScreenWidth(this.renderer.getLayout().columns);
+    this.render();
+  };
+  stepWorld() {
+    const result = this.world.step();
+    if (!result.isGameOver) return;
+    this.phase = "over";
+    this.scores = this.scoreStore.recordGame({ score: this.world.score, tokens: this.world.getTokensCollected(), mode: this.mode });
+    this.submitScore();
+  }
+  /** Fire-and-forget: the loop never waits on the network, the overlay reflects whatever came back. */
+  submitScore() {
+    if (this.leaderboard === null) return;
+    this.ranking = { state: "pending", result: this.ranking.result };
+    this.leaderboard.submit({ name: this.playerName, record: this.scores, mode: this.mode }).then((result) => {
+      this.ranking = { state: "ready", result };
+    }).catch(() => {
+      this.ranking = { state: "failed", result: null };
+    });
+  }
+  pollClaude() {
+    if (this.tickCount % GAME_CONSTANTS.claudePollTicks !== 0) return;
+    const change = this.claudeWatcher.pollChange();
+    if (change === null) return;
+    if (change.status !== this.lastClaudeStatus) this.banner = createBanner(change);
+    this.lastClaudeStatus = change.status;
+    const needsUser = change.status !== "working";
+    if (needsUser && this.phase === "running") this.pauseForClaude();
+    if (change.status === "working" && this.isPausedByClaude) this.togglePause();
+  }
+  pauseForClaude() {
+    this.phase = "paused";
+    this.isPausedByClaude = true;
+  }
+  updateBanner() {
+    if (this.banner === null) return;
+    const ticksLeft = this.banner.ticksLeft - 1;
+    this.banner = ticksLeft > 0 ? { ...this.banner, ticksLeft } : null;
+  }
+  beginRun() {
+    if (!this.canPlay) return;
+    this.world.reset();
+    this.phase = "running";
+  }
+  restart() {
+    if (this.phase === "ready") return;
+    this.beginRun();
+  }
+  togglePause() {
+    if (this.phase === "paused" && !this.canPlay) return;
+    this.isPausedByClaude = false;
+    if (this.phase === "running") this.phase = "paused";
+    else if (this.phase === "paused") this.phase = "running";
+  }
+  quit() {
+    this.stop();
+    this.onQuit();
+  }
+  render() {
+    if (this.isStopped) return;
+    const lines = this.renderer.render({
+      world: this.world,
+      phase: this.phase,
+      scores: this.scores,
+      playerName: this.playerName,
+      agent: this.agent,
+      mode: this.mode,
+      lockMessage: this.lockMessage,
+      ranking: this.ranking,
+      sponsors: this.sponsors,
+      settings: this.menu !== null && this.menu.isOpen ? this.menu.getView() : null,
+      claude: this.claudeWatcher.getCurrent(),
+      banner: this.banner,
+      tickCount: this.tickCount
+    });
+    this.screen.render(lines);
+  }
+};
+
+// src/game/create_game.ts
+function createGame({ onQuit, playerName, agent }) {
+  return new Game({
+    playerName,
+    agent,
+    screen: new TerminalScreen(),
+    input: new CompositeInput(process.platform === "darwin" ? [new Keyboard(), new KeyStateWatcher()] : [new Keyboard()]),
+    scoreStore: new ScoreStore({ path: DARIO_PATHS.scoresFile }),
+    claudeWatcher: new ClaudeStatusWatcher({ path: DARIO_PATHS.claudeStatusFile }),
+    leaderboard: createLeaderboard(),
+    sponsorSource: createSponsorService(),
+    settings: new ConfigStore({ path: DARIO_PATHS.configFile }),
+    onQuit
+  });
+}
+
+// src/player/ensure_player_name.ts
+async function ensurePlayerName() {
+  const store = new ConfigStore({ path: DARIO_PATHS.configFile });
+  const saved = store.load().playerName;
+  if (PlayerName.isValid(saved)) return saved;
+  const chosen = await askPlayerName(detectPlayerName());
+  store.update({ playerName: chosen.value });
+  console.log(`Welcome, ${chosen.value}! Change it any time with "dario name <new name>".`);
+  return chosen.value;
+}
+
+// src/cli/commands/play_command.ts
+var EXIT_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function registerCleanup({ game, lock }) {
+  const cleanup = () => {
+    game.stop();
+    lock.release();
+  };
+  EXIT_SIGNALS.forEach((signal) => process.on(signal, () => {
+    cleanup();
+    process.exit(0);
+  }));
+  process.on("exit", cleanup);
+}
+function runGame({ lock, playerName, agent }) {
+  return new Promise((resolve2) => {
+    const game = createGame({ playerName, agent, onQuit: () => {
+      lock.release();
+      resolve2(0);
+    } });
+    registerCleanup({ game, lock });
+    game.start();
+  });
+}
+var PLAY_COMMAND = {
+  name: "play",
+  aliases: ["run", "start"],
+  usage: "dario play [--as claude|codex|grok]",
+  description: "Play Dario in the current terminal (needs an interactive TTY).",
+  async execute(args) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      console.error('dario play needs an interactive terminal. Use "dario launch" to open one.');
+      return 1;
+    }
+    const lock = new ProcessLock({ path: DARIO_PATHS.pidFile });
+    if (!lock.acquire()) {
+      console.error(`Dario is already running (pid ${lock.readPid()}). Run "dario stop" first.`);
+      return 1;
+    }
+    await runFirstRunSetup();
+    const playerName = await ensurePlayerName();
+    const configured = new ConfigStore({ path: DARIO_PATHS.configFile }).load().character;
+    const agent = resolveAgent({ args, configured, env: process.env });
+    return runGame({ lock, playerName, agent });
+  }
+};
+
+// src/cli/commands/ranking_command.ts
+var DEFAULT_LIMIT = 20;
+var NAME_WIDTH2 = 22;
+function renderRow({ entry, index, uid }) {
+  const marker = entry.uid === uid ? ">" : " ";
+  return `${marker} #${String(index + 1).padEnd(3)} ${entry.name.padEnd(NAME_WIDTH2)} ${String(entry.highScore).padStart(6)}  tokens ${entry.bestTokens}`;
+}
+function renderRanking({ result, playerName }) {
+  const rows = result.top.map((entry, index) => renderRow({ entry, index, uid: result.uid }));
+  const mine = result.rank === null ? `${playerName}: no score submitted yet, play a game!` : `${playerName}: rank #${result.rank}`;
+  return ["Dario global ranking", ...rows, "", mine].join("\n");
+}
+var RANKING_COMMAND = {
+  name: "ranking",
+  aliases: ["rank", "leaderboard", "top"],
+  usage: "dario ranking [--pro] [--json]",
+  description: "Show the global leaderboard (VIBE, or PRO with --pro) and your rank.",
+  async execute(args) {
+    const playerName = new ConfigStore({ path: DARIO_PATHS.configFile }).load().playerName || "you";
+    try {
+      const result = await createLeaderboard().fetchRanking({ limit: DEFAULT_LIMIT, mode: args.includes("--pro") ? "pro" : "vibe" });
+      console.log(args.includes("--json") ? JSON.stringify(result) : renderRanking({ result, playerName }));
+      return 0;
+    } catch (err) {
+      console.error(`Could not load the ranking: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+  }
+};
+
+// src/cli/commands/scores_command.ts
+function formatDate(timestamp) {
+  return timestamp === 0 ? "never" : new Date(timestamp).toLocaleString();
+}
+function renderScores(record) {
+  return [
+    "Dario scores",
+    `  high score    ${record.highScore}`,
+    `  pro high score ${record.proHighScore}`,
+    `  last score    ${record.lastScore}`,
+    `  best tokens   ${record.bestTokens}`,
+    `  total tokens  ${record.totalTokens}`,
+    `  games played  ${record.gamesPlayed}`,
+    `  last game     ${formatDate(record.updatedAt)}`
+  ].join("\n");
+}
+var SCORES_COMMAND = {
+  name: "scores",
+  aliases: ["score", "hi", "highscore"],
+  usage: "dario scores [--json]",
+  description: "Show high score, token totals and games played.",
+  async execute(args) {
+    const record = new ScoreStore({ path: DARIO_PATHS.scoresFile }).load();
+    console.log(args.includes("--json") ? JSON.stringify(record) : renderScores(record));
+    return 0;
+  }
+};
+
+// src/cli/commands/sponsors_command.ts
+var NAME_WIDTH3 = 20;
+function renderSponsor(sponsor) {
+  return `  ${sponsor.name.padEnd(NAME_WIDTH3)} ${sponsor.tier.padEnd(9)} ${sponsor.url}   until ${new Date(sponsor.expiresAt).toLocaleDateString()}`;
+}
+var SPONSORS_COMMAND = {
+  name: "sponsors",
+  aliases: ["sponsor"],
+  usage: "dario sponsors [--json]",
+  description: "List the active sponsors whose logos appear in the game.",
+  async execute(args) {
+    const sponsors = await createSponsorService().loadSponsors();
+    if (args.includes("--json")) {
+      console.log(JSON.stringify(sponsors));
+      return 0;
+    }
+    const lines = sponsors.length === 0 ? ["  no active sponsors yet"] : sponsors.map(renderSponsor);
+    console.log(["Dario sponsors", ...lines, "", `Become one: ${FIREBASE_CONFIG.siteUrl}/sponsor`].join("\n"));
+    return 0;
+  }
+};
+
+// src/cli/commands/status_command.ts
+var STATUS_COMMAND = {
+  name: "status",
+  aliases: ["info"],
+  usage: "dario status",
+  description: "Show whether Dario is running, hook installation, auto-launch and Claude state.",
+  async execute() {
+    const lock = new ProcessLock({ path: DARIO_PATHS.pidFile });
+    const config = new ConfigStore({ path: DARIO_PATHS.configFile }).load();
+    const claude = new ClaudeStatusWriter({ path: DARIO_PATHS.claudeStatusFile }).read();
+    const scores = new ScoreStore({ path: DARIO_PATHS.scoresFile }).load();
+    const agents = new AgentHooksInstaller();
+    const lines = [
+      "Dario status",
+      `  running         ${lock.isHeld() ? `yes (pid ${lock.readPid()})` : "no"}`,
+      `  claude hooks    ${new DarioInstaller().isInstalled() ? "installed" : 'not installed (run "dario install")'}`,
+      ...describeAgentReports(agents.listKinds().map((kind) => agents.describe(kind))).map((line) => line.replace(/^ {2}(\S+ hooks)\s*/, (_match, label) => `  ${label.padEnd(16)}`)),
+      `  player          ${config.playerName.length === 0 ? "(asked on first play)" : config.playerName}`,
+      `  character       ${config.character}`,
+      `  mode            ${GAME_MODE_LABELS[config.mode]}`,
+      `  auto-launch     ${config.autoLaunch ? "on" : "off"}`,
+      `  return-focus    ${config.returnFocus ? "on" : "off"}`,
+      `  terminal        ${config.terminal}`,
+      `  agent state     ${claude === null ? "unknown" : `${claude.agent} ${claude.status} (${new Date(claude.updatedAt).toLocaleTimeString()})`}`,
+      `  high score      ${scores.highScore}`,
+      `  project         ${DARIO_PATHS.rootDir}`
+    ];
+    console.log(lines.join("\n"));
+    return 0;
+  }
+};
+
+// src/cli/commands/stop_command.ts
+var STOP_COMMAND = {
+  name: "stop",
+  aliases: ["kill"],
+  usage: "dario stop",
+  description: "Close the running Dario window.",
+  async execute() {
+    const lock = new ProcessLock({ path: DARIO_PATHS.pidFile });
+    const pid = lock.readPid();
+    if (pid === null || !lock.isHeld()) {
+      console.log("Dario is not running.");
+      return 0;
+    }
+    process.kill(pid, "SIGTERM");
+    console.log(`Stopped Dario (pid ${pid}).`);
+    return 0;
+  }
+};
+
+// src/cli/commands/terminal_command.ts
+var TERMINAL_KINDS = ["auto", ...INSTALL_PREFERENCE, "apple_terminal", ...IDE_KINDS];
+var KIND_WIDTH2 = 17;
+var LIST_FLAG = "--list";
+function isTerminalKind(value) {
+  return TERMINAL_KINDS.includes(value);
+}
+var TERMINAL_COMMAND = {
+  name: "terminal",
+  aliases: ["term"],
+  usage: "dario terminal <auto|name> | --list",
+  description: `Choose which terminal app or IDE "dario launch" and the hooks open (${TERMINAL_KINDS.join(", ")}).`,
+  async execute(args) {
+    const store = new ConfigStore({ path: DARIO_PATHS.configFile });
+    const raw = (args[0] ?? "").toLowerCase();
+    if (raw === LIST_FLAG) {
+      listLaunchTargets().forEach((target) => console.log(`  ${target.kind.padEnd(KIND_WIDTH2)} ${target.label}${target.isDetected ? "  (detected)" : ""}`));
+      return 0;
+    }
+    const value = raw.replaceAll("-", "_");
+    if (value.length === 0) {
+      console.log(`Terminal preference: ${store.load().terminal}`);
+      return 0;
+    }
+    if (!isTerminalKind(value)) {
+      console.error(`Unknown terminal "${value}". Options: ${TERMINAL_KINDS.join(", ")}`);
+      return 1;
+    }
+    console.log(`Terminal preference is now ${store.update({ terminal: value }).terminal}.`);
+    return 0;
+  }
+};
+
+// src/cli/commands/uninstall_command.ts
+var UNINSTALL_COMMAND = {
+  name: "uninstall",
+  aliases: ["remove"],
+  usage: "dario uninstall",
+  description: "Remove the Claude Code / Codex / Grok hooks, the skill link and the dario command.",
+  async execute() {
+    const report = new DarioInstaller().uninstall();
+    const lines = [
+      "Dario uninstalled",
+      `  claude hooks   ${report.hooks}`,
+      ...describeAgentReports(report.agents),
+      `  skill link     ${report.skill}`,
+      `  dario command  ${report.bin}`
+    ];
+    console.log(lines.join("\n"));
+    return 0;
+  }
+};
+
+// src/cli/commands/update_command.ts
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join6 } from "node:path";
+var TIMEOUT_MS = 8e3;
+function readLocalVersion() {
+  return JSON.parse(readFileSync4(join6(DARIO_PATHS.rootDir, "package.json"), "utf8")).version;
+}
+async function fetchRelease() {
+  const response = await fetch(`${FIREBASE_CONFIG.siteUrl}/dl/version.json`, { signal: AbortSignal.timeout(TIMEOUT_MS) });
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  return await response.json();
+}
+function runInstaller() {
+  const result = spawnSync6("sh", ["-c", `curl -fsSL ${FIREBASE_CONFIG.siteUrl}/install.sh | sh`], { stdio: "inherit" });
+  return result.status ?? 1;
+}
+var UPDATE_COMMAND = {
+  name: "update",
+  aliases: ["upgrade"],
+  usage: "dario update [--check]",
+  description: "Check the website for a newer release and install it.",
+  async execute(args) {
+    const local = readLocalVersion();
+    let release;
+    try {
+      release = await fetchRelease();
+    } catch (err) {
+      console.error(`Could not check for updates: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+    console.log(`installed ${local}, latest ${release.version} (${release.publishedAt})`);
+    if (release.version === local || args.includes("--check")) return 0;
+    if (DARIO_PATHS.rootDir.includes("/node_modules/")) {
+      console.log('This copy was installed with npm: run "npm install -g superdario@latest" to update.');
+      return 0;
+    }
+    if (!DARIO_PATHS.rootDir.includes("/.dario/")) {
+      console.log("This copy is a source checkout, not the website install; update it with git instead.");
+      return 0;
+    }
+    return runInstaller();
+  }
+};
+
+// src/cli/command_registry.ts
+var HELP_COMMAND = createHelpCommand({ commands: () => COMMANDS });
+var COMMANDS = [
+  PLAY_COMMAND,
+  LAUNCH_COMMAND,
+  STOP_COMMAND,
+  SCORES_COMMAND,
+  RANKING_COMMAND,
+  SPONSORS_COMMAND,
+  NAME_COMMAND,
+  CHARACTER_COMMAND,
+  MODE_COMMAND,
+  STATUS_COMMAND,
+  AUTO_LAUNCH_COMMAND,
+  FOCUS_COMMAND,
+  TERMINAL_COMMAND,
+  IDE_COMMAND,
+  AGENTS_COMMAND,
+  INSTALL_COMMAND,
+  UNINSTALL_COMMAND,
+  UPDATE_COMMAND,
+  HOOK_COMMAND,
+  KEYS_COMMAND,
+  HELP_COMMAND
+];
+
+// src/cli/run_cli.ts
+var DEFAULT_COMMAND = "play";
+function findCommand(name) {
+  return COMMANDS.find((command) => command.name === name || command.aliases.includes(name));
+}
+async function runCli(argv) {
+  const [name = DEFAULT_COMMAND, ...rest] = argv;
+  const command = findCommand(name);
+  if (command === void 0) {
+    console.error(`Unknown command "${name}". Try "dario help".`);
+    return 1;
+  }
+  const isAliasArgument = command.name !== name && command.aliases.includes(name) && command.name === "auto";
+  return command.execute(isAliasArgument ? [name, ...rest] : rest);
+}
+
+// src/main.ts
+runCli(process.argv.slice(2)).then((code) => process.exit(code)).catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});