@azure-id/orc 1.0.0 → 1.2.0

package/bin/webui/fixtures/wait.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * fixtures/wait.js — canned `orc usage check` / `orc wait …` responses.
+ *
+ * ONE OF EVERY STATE, including the ugly ones. You cannot design an `unknown`
+ * chip on a project whose statusline is happily writing a reading every second,
+ * and `unknown` is the state that matters most here: it is what every install
+ * on Claude Code before v2.1.80 sees, forever.
+ */
+
+// LOW, and low on the WORST window rather than the obvious one. The 5-hour
+// window is the one people watch; this fixture has it comfortable and the
+// weekly one nearly gone, which is the case a panel gets wrong.
+const usage = {
+  ok: true,
+  state: "low",
+  five_hour: {
+    window: "5h",
+    used_percentage: 62,
+    remaining_percentage: 38,
+    resets_at: new Date(Date.now() + 96 * 60000).toISOString(),
+    resets_in_minutes: 96,
+    low: false,
+  },
+  seven_day: {
+    window: "wk",
+    used_percentage: 94,
+    remaining_percentage: 6,
+    resets_at: new Date(Date.now() + 2 * 86400000).toISOString(),
+    resets_in_minutes: 2880,
+    low: true,
+  },
+  worst: "wk",
+  context: 81,
+  stop_pct: 10,
+  gate: "wait",
+  reading_age_minutes: 2,
+  note: "read BEFORE a wave; the wave then spends tokens, so this is a reading and not a promise.",
+};
+
+// The state a fresh install on older Claude Code sits in permanently.
+const usageUnknown = {
+  ok: true,
+  state: "unknown",
+  reason: "no reading in the last 30 minutes",
+  five_hour: null,
+  seven_day: null,
+  context: null,
+  stop_pct: 10,
+  gate: "warn",
+  note: "unknown is not low — a run is never stopped on a missing reading. Claude Code before v2.1.80 sends no usage headers.",
+};
+
+const waitLanes = {
+  ok: true,
+  modes: ["safe", "soft", "hard"],
+  checkpoints: ["full", "docset", "entry", "cycle", "snapshot", "none"],
+  lanes: [
+    { lane: "/orc", checkpoint: "full", safe_point: "wave or phase edge", modes: ["safe", "soft", "hard"], modes_differ: true, detail: "soft forces the full checkpoint before it stops; hard writes RESUME.md only and can lose an in-flight return." },
+    { lane: "/orc-doc", checkpoint: "full", safe_point: "wave edge", modes: ["safe", "soft", "hard"], modes_differ: true, detail: "soft forces the full checkpoint before it stops; hard writes RESUME.md only and can lose an in-flight return." },
+    { lane: "/orc-quick", checkpoint: "entry", safe_point: "after an entry closes", modes: ["safe", "soft", "hard"], modes_differ: true, detail: "soft forces the entry checkpoint before it stops; hard writes RESUME.md only and can lose an in-flight return." },
+    { lane: "/orc-brainstorm", checkpoint: "snapshot", safe_point: "phase edge", modes: ["safe", "soft", "hard"], modes_differ: true, detail: "soft forces the snapshot checkpoint before it stops; hard writes RESUME.md only and can lose an in-flight return." },
+    // A `none` row KEEPS ITS SLOT. Filtering it out would make "this lane has
+    // nothing to checkpoint" and "this lane does not support a wait" identical.
+    { lane: "/orc-explain", checkpoint: "none", safe_point: "read-only, seconds long", modes: ["safe", "soft", "hard"], modes_differ: false, detail: "nothing to checkpoint — one dispatch, or a read. safe, soft and hard behave identically here." },
+    { lane: "/orc-verify", checkpoint: "none", safe_point: "single dispatch", modes: ["safe", "soft", "hard"], modes_differ: false, detail: "nothing to checkpoint — one dispatch, or a read. safe, soft and hard behave identically here." },
+  ],
+  note: "A lane not in this list does not support a wait.",
+};
+
+// Blocked AND waiting at once — the busiest the card ever gets.
+const waitStatus = {
+  ok: true,
+  run: "rate-limit-api",
+  waiting: true,
+  mode: "soft",
+  hop: 30,
+  hops_done: 2,
+  hops_planned: 4,
+  ends_at: new Date(Date.now() + 44 * 60000).toISOString(),
+  cancel_requested: false,
+  blocked: true,
+  block_reason: "window resets in 5m, task needs 10",
+  blocked_at: new Date(Date.now() - 12 * 60000).toISOString(),
+  block_age_minutes: 12,
+};
+
+// No run in flight. An empty result is an ANSWER, so it still carries an object.
+const waitStatusNone = {
+  ok: true,
+  run: null,
+  waiting: false,
+  blocked: false,
+  note: "no run is in flight",
+};
+
+module.exports = { usage, usageUnknown, waitLanes, waitStatus, waitStatusNone };

package/bin/webui/i18n/en/nav.json

@@ -1,20 +1,21 @@
-{
-  "nav.overview": "Overview",
-  "nav.settings": "Settings",
-  "nav.lanes": "Lanes",
-  "nav.runs": "Runs",
-  "nav.knowledge": "Knowledge",
-  "nav.stats": "Stats",
-  "nav.flow": "Flow",
-  "nav.crosslink": "Crosslink",
-  "nav.learn": "Learn",
-  "nav.mockrun": "Mocked Skill Use",
-  "nav.experiment": "Experiment",
-  "nav.maintenance": "Maintenance",
-  "nav.pact": "Promises",
-  "nav.boundary": "Boundary",
-  "nav.handoff": "Self-serve",
-  "nav.challenge": "Challenge",
-  "nav.extra": "Extra",
-  "nav.docs": "Docs"
-}
+{
+  "nav.overview": "Overview",
+  "nav.settings": "Settings",
+  "nav.lanes": "Lanes",
+  "nav.runs": "Runs",
+  "nav.knowledge": "Knowledge",
+  "nav.stats": "Stats",
+  "nav.flow": "Flow",
+  "nav.crosslink": "Crosslink",
+  "nav.learn": "Learn",
+  "nav.mockrun": "Mocked Skill Use",
+  "nav.experiment": "Experiment",
+  "nav.maintenance": "Maintenance",
+  "nav.pact": "Promises",
+  "nav.boundary": "Boundary",
+  "nav.handoff": "Self-serve",
+  "nav.challenge": "Challenge",
+  "nav.extra": "Extra",
+  "nav.wait": "Wait",
+  "nav.docs": "Docs"
+}

package/bin/webui/i18n/en/wait.json

@@ -0,0 +1,41 @@
+{
+  "wait.title": "Wait",
+  "wait.sub": "How full your usage windows are, and the wait that answers it. A wait costs no tokens - a detached command does it, and no model runs.",
+  "wait.window": "Your windows",
+  "wait.worst": "worst: {w}",
+  "wait.age": "read 1 minute ago",
+  "wait.agePlural": "read {n} minutes ago",
+  "wait.left": "{n}% left",
+  "wait.resets": "resets in {t}",
+  "wait.context": "This conversation uses {n}% of its context.",
+  "wait.contextUnknown": "Context use: not measured.",
+  "wait.contextLarge": "The context is large. After a wait of more than one hour, start a new session and run `orc resume` - it costs less than continuing here.",
+  "wait.gateOff": "usage_gate is off, so ORC never stops a run for you. Nothing here happens until you turn it on.",
+  "wait.gateOn": "usage_gate is `{gate}`. A wave needs {pct}% of a window to remain before it starts.",
+  "wait.run": "This run",
+  "wait.noRun": "No run is in flight",
+  "wait.noRunHint": "A wait belongs to a run. With no run, `/orc-wait` simply waits, and there is nothing to hand back.",
+  "wait.startWhy": "The panel cannot start a wait. A wait lives in your Claude Code session, and this panel never runs a lane.",
+  "wait.waiting": "waiting",
+  "wait.blocked": "blocked",
+  "wait.idle": "no wait",
+  "wait.hops": "Mode `{mode}` - hop {done} of {planned}, ends {ends}.",
+  "wait.zeroTokens": "A detached command does the waiting. No model runs, and no tokens are spent.",
+  "wait.cancel": "Stop waiting",
+  "wait.cancelWhy": "The wait ends at the next hop. The hand-back is already on disk, so nothing is lost either way.",
+  "wait.cancelPending": "A stop is pending. The wait ends at the next hop.",
+  "wait.blockHead": "You blocked the gate",
+  "wait.blockAge": "Set 1 minute ago.",
+  "wait.blockAgePlural": "Set {n} minutes ago.",
+  "wait.blockRisk": "ORC does not stop this run. The risk is yours: if a window empties during a wave, the wave stops in the middle. A wait you type yourself still runs.",
+  "wait.unblock": "Restore the gate",
+  "wait.unblockWhy": "ORC can stop this run again when a window is nearly full.",
+  "wait.blockWhy": "To block the gate, type this in Claude Code. A block needs a reason, and a reason must be written at the moment you decide - that record is what makes the risk yours.",
+  "wait.lanes": "Which lanes support a wait",
+  "wait.lanesWhy": "Each lane saves different work before it stops. `full` writes a checkpoint; `none` has nothing to write, because the lane is one dispatch or a read.",
+  "wait.settings": "Settings",
+  "wait.settingsWhy": "These keys are edited on the Settings page, with every other key. Two editors for one key is one editor too many.",
+  "wait.openSettings": "Open Settings",
+  "wait.done": "Done",
+  "wait.failed": "That did not work"
+}

package/bin/webui/i18n/id/nav.json

@@ -1,20 +1,21 @@
-{
-  "nav.overview": "Ringkasan",
-  "nav.settings": "Pengaturan",
-  "nav.lanes": "Lane",
-  "nav.runs": "Run",
-  "nav.knowledge": "Pengetahuan",
-  "nav.stats": "Statistik",
-  "nav.flow": "Flow",
-  "nav.crosslink": "Crosslink",
-  "nav.learn": "Belajar",
-  "nav.mockrun": "Contoh Penggunaan Skill",
-  "nav.experiment": "Eksperimen",
-  "nav.maintenance": "Pemeliharaan",
-  "nav.pact": "Janji",
-  "nav.boundary": "Batas",
-  "nav.handoff": "Ubah Sendiri",
-  "nav.challenge": "Challenge",
-  "nav.extra": "Extra",
-  "nav.docs": "Dokumen"
-}
+{
+  "nav.overview": "Ringkasan",
+  "nav.settings": "Pengaturan",
+  "nav.lanes": "Lane",
+  "nav.runs": "Run",
+  "nav.knowledge": "Pengetahuan",
+  "nav.stats": "Statistik",
+  "nav.flow": "Flow",
+  "nav.crosslink": "Crosslink",
+  "nav.learn": "Belajar",
+  "nav.mockrun": "Contoh Penggunaan Skill",
+  "nav.experiment": "Eksperimen",
+  "nav.maintenance": "Pemeliharaan",
+  "nav.pact": "Janji",
+  "nav.boundary": "Batas",
+  "nav.handoff": "Ubah Sendiri",
+  "nav.challenge": "Challenge",
+  "nav.extra": "Extra",
+  "nav.wait": "Tunggu",
+  "nav.docs": "Dokumen"
+}

package/bin/webui/i18n/id/wait.json

@@ -0,0 +1,41 @@
+{
+  "wait.title": "Tunggu",
+  "wait.sub": "Seberapa penuh jendela pemakaian Anda, dan penantian yang menjawabnya. Menunggu tidak memakai token - sebuah perintah terpisah yang menunggu, dan tidak ada model yang berjalan.",
+  "wait.window": "Jendela Anda",
+  "wait.worst": "terburuk: {w}",
+  "wait.age": "dibaca 1 menit lalu",
+  "wait.agePlural": "dibaca {n} menit lalu",
+  "wait.left": "sisa {n}%",
+  "wait.resets": "reset dalam {t}",
+  "wait.context": "Percakapan ini memakai {n}% konteksnya.",
+  "wait.contextUnknown": "Pemakaian konteks: tidak terukur.",
+  "wait.contextLarge": "Konteksnya besar. Setelah menunggu lebih dari satu jam, mulai sesi baru dan jalankan `orc resume` - biayanya lebih kecil daripada melanjutkan di sini.",
+  "wait.gateOff": "usage_gate mati, jadi ORC tidak pernah menghentikan run untuk Anda. Tidak ada yang terjadi sampai Anda menyalakannya.",
+  "wait.gateOn": "usage_gate adalah `{gate}`. Sebuah wave perlu sisa {pct}% dari satu jendela sebelum mulai.",
+  "wait.run": "Run ini",
+  "wait.noRun": "Tidak ada run yang berjalan",
+  "wait.noRunHint": "Penantian milik sebuah run. Tanpa run, `/orc-wait` hanya menunggu, dan tidak ada yang perlu diserahkan kembali.",
+  "wait.startWhy": "Panel tidak bisa memulai penantian. Penantian hidup di sesi Claude Code Anda, dan panel ini tidak pernah menjalankan lane.",
+  "wait.waiting": "menunggu",
+  "wait.blocked": "diblokir",
+  "wait.idle": "tidak menunggu",
+  "wait.hops": "Mode `{mode}` - hop {done} dari {planned}, selesai {ends}.",
+  "wait.zeroTokens": "Sebuah perintah terpisah yang menunggu. Tidak ada model yang berjalan, dan tidak ada token yang terpakai.",
+  "wait.cancel": "Berhenti menunggu",
+  "wait.cancelWhy": "Penantian berakhir pada hop berikutnya. Serah-terima sudah ada di disk, jadi tidak ada yang hilang.",
+  "wait.cancelPending": "Permintaan berhenti tertunda. Penantian berakhir pada hop berikutnya.",
+  "wait.blockHead": "Anda memblokir gerbangnya",
+  "wait.blockAge": "Dipasang 1 menit lalu.",
+  "wait.blockAgePlural": "Dipasang {n} menit lalu.",
+  "wait.blockRisk": "ORC tidak menghentikan run ini. Risikonya milik Anda: jika sebuah jendela habis saat wave berjalan, wave berhenti di tengah. Penantian yang Anda ketik sendiri tetap berjalan.",
+  "wait.unblock": "Pulihkan gerbangnya",
+  "wait.unblockWhy": "ORC boleh menghentikan run ini lagi saat sebuah jendela hampir penuh.",
+  "wait.blockWhy": "Untuk memblokir gerbangnya, ketik ini di Claude Code. Blokir perlu alasan, dan alasan harus ditulis saat Anda memutuskan - catatan itulah yang membuat risikonya milik Anda.",
+  "wait.lanes": "Lane mana yang mendukung penantian",
+  "wait.lanesWhy": "Tiap lane menyimpan pekerjaan yang berbeda sebelum berhenti. `full` menulis checkpoint; `none` tidak punya yang perlu ditulis, karena lane itu satu dispatch atau satu bacaan.",
+  "wait.settings": "Pengaturan",
+  "wait.settingsWhy": "Kunci-kunci ini diubah di halaman Pengaturan, bersama kunci lainnya. Dua editor untuk satu kunci adalah satu editor terlalu banyak.",
+  "wait.openSettings": "Buka Pengaturan",
+  "wait.done": "Selesai",
+  "wait.failed": "Tidak berhasil"
+}

package/bin/webui/js/01-i18n.js

@@ -1,150 +1,151 @@
-"use strict";
-/* 01-i18n.js — orc ui client
-   LANGS, loadLang, setLang, t, applyStaticText, cycleLang.
-   
-   Keys are written out IN FULL, never assembled from a fragment. The v0.48.1
-   file split is by key PREFIX only; `docs.ship.confirm` is still spelled
-   `docs.ship.confirm` at every call site.
-
-   Loaded by app.html in the order its numeric prefix names. Classic
-   script, no import/export: an ES module import carries no query string,
-   and every static request here needs the per-launch session token. */
-
-/* ------------------------------------------------------------------- i18n -- */
-/*
-   THE SCOPE RULE, and it is deliberately narrow: only the panel's OWN prose is
-   translated. Everything that arrives from `bin/cli.js --json` stays exactly as
-   the CLI wrote it — config keys and their descriptions, values, agent names,
-   model ids, file paths, commands, `orc doctor` messages, command output. Those
-   are identifiers, not sentences: a translated config key is a key that does not
-   exist, and a translated command is a command you cannot type. So `t()` is
-   never applied to a value read out of a payload, and neither string table
-   contains a single ORC key name.
-
-   The tables are plain JSON served as static assets. Adding a language is a
-   FOLDER in i18n/ plus one row in LANGS — no build step, no library, no
-   dependency, and no server change (serve.js walks i18n/ at boot).
-*/
-const LANGS = [
-  { code: "en", label: "English" },
-  { code: "id", label: "Bahasa Indonesia" },
-];
-const LANG_KEY = "orc-ui-lang";
-
-// v0.48.1 — one file per namespace instead of one 53 KB table, so changing the
-// Docs panel's wording means opening i18n/en/docs.json rather than paging
-// through every string in the panel.
-//
-// A plain array, and deliberately NOT an index file to fetch: an index would be
-// one more round trip and one more thing to forget to update. A namespace owns
-// one or more key PREFIXES (`stats` owns `stats.*` and `cost.*`), which the
-// test suite asserts — a key whose prefix belongs to no namespace would load
-// nowhere and render as a raw dotted string.
-const NAMESPACES = [
-  "common",
-  "nav",
-  "banner",
-  "overview",
-  "settings",
-  "lanes",
-  "runs",
-  "knowledge",
-  "stats",
-  "flow",
-  "crosslink",
-  "learn",
-  "mockrun",
-  "maintenance",
-  "pact",
-  "boundary",
-  "handoff",
-  "challenge",
-  "docs",
-  "extra",
-  "experiment",
-  "tour",
-];
-
-let lang = "en";
-// English is loaded first and kept as the FALLBACK table: a key the other
-// language has not translated yet renders in English rather than as a raw
-// dotted key. A half-finished translation degrades to mixed prose, never to
-// debug output on somebody's screen.
-let DICT = {};
-let DICT_EN = {};
-
-// The namespaces are fetched in parallel and merged into ONE flat table, so
-// `t()` is unchanged and no call site knows the split happened.
-//
-// A namespace that fails to load falls back to ENGLISH for its keys rather than
-// rejecting the whole language: a network hiccup on one file should cost that
-// file's prose, not the entire panel. English itself has no fallback below it,
-// so a failure there rejects and boot() lands on raw keys — ugly, never blank.
-function loadLang(code) {
-  return Promise.all(
-    NAMESPACES.map((ns) =>
-      fetch(`/i18n/${code}/${ns}.json`, { headers: { "x-orc-token": TOKEN }, cache: "no-store" })
-        .then((r) => {
-          if (!r.ok) throw new Error(`i18n ${code}/${ns} ${r.status}`);
-          return r.json();
-        })
-        .catch((e) => {
-          if (code === "en") throw e;
-          return null;
-        })
-    )
-  ).then((parts) => Object.assign({}, ...parts.filter(Boolean)));
-}
-
-// A missing or broken table must never blank the UI. Every failure path here
-// lands on English, so the worst case is untranslated text — never empty text.
-async function setLang(code, opts) {
-  const rerender = !opts || opts.rerender !== false;
-  const want = LANGS.some((l) => l.code === code) ? code : "en";
-  try {
-    DICT = want === "en" ? DICT_EN : await loadLang(want);
-    lang = want;
-  } catch (_) {
-    DICT = DICT_EN;
-    lang = "en";
-  }
-  try {
-    localStorage.setItem(LANG_KEY, lang);
-  } catch (_) {}
-  document.documentElement.setAttribute("lang", lang);
-  applyStaticText();
-  if (rerender) route();
-}
-
-function t(key, vars) {
-  let s = DICT[key];
-  if (s === undefined) s = DICT_EN[key];
-  if (s === undefined) s = key;
-  if (vars) for (const k of Object.keys(vars)) s = s.split("{" + k + "}").join(String(vars[k]));
-  return s;
-}
-
-// English has one plural form and Indonesian has none, so count-aware lookup is
-// a second key rather than a plural-rules engine: `n === 1` picks the singular.
-const tn = (n, key, vars) => t(n === 1 ? key : key + "Plural", Object.assign({ n }, vars || {}));
-
-// The parts of the shell that are markup rather than a render function. Called
-// on every language change; panels re-render themselves through `route()`.
-function applyStaticText() {
-  for (const node of document.querySelectorAll("[data-i18n]")) node.textContent = t(node.dataset.i18n);
-  const tt = $("#theme-toggle");
-  if (tt) tt.textContent = document.documentElement.getAttribute("data-theme") === "light" ? t("rail.dark") : t("rail.light");
-  const hint = $("#shortcut-hint");
-  if (hint) hint.title = t("rail.shortcuts");
-  const label = $("#lang-label");
-  if (label) label.textContent = (LANGS.find((l) => l.code === lang) || LANGS[0]).label;
-  const btn = $("#lang-toggle");
-  if (btn) btn.title = t("lang.title");
-}
-
-// Two languages, so the control is a TOGGLE rather than a menu: one click, no
-// dropdown to open. A third language would make this a <select>; two do not.
-function cycleLang() {
-  const i = LANGS.findIndex((l) => l.code === lang);
-  setLang(LANGS[(i + 1) % LANGS.length].code);
-}
+"use strict";
+/* 01-i18n.js — orc ui client
+   LANGS, loadLang, setLang, t, applyStaticText, cycleLang.
+   
+   Keys are written out IN FULL, never assembled from a fragment. The v0.48.1
+   file split is by key PREFIX only; `docs.ship.confirm` is still spelled
+   `docs.ship.confirm` at every call site.
+
+   Loaded by app.html in the order its numeric prefix names. Classic
+   script, no import/export: an ES module import carries no query string,
+   and every static request here needs the per-launch session token. */
+
+/* ------------------------------------------------------------------- i18n -- */
+/*
+   THE SCOPE RULE, and it is deliberately narrow: only the panel's OWN prose is
+   translated. Everything that arrives from `bin/cli.js --json` stays exactly as
+   the CLI wrote it — config keys and their descriptions, values, agent names,
+   model ids, file paths, commands, `orc doctor` messages, command output. Those
+   are identifiers, not sentences: a translated config key is a key that does not
+   exist, and a translated command is a command you cannot type. So `t()` is
+   never applied to a value read out of a payload, and neither string table
+   contains a single ORC key name.
+
+   The tables are plain JSON served as static assets. Adding a language is a
+   FOLDER in i18n/ plus one row in LANGS — no build step, no library, no
+   dependency, and no server change (serve.js walks i18n/ at boot).
+*/
+const LANGS = [
+  { code: "en", label: "English" },
+  { code: "id", label: "Bahasa Indonesia" },
+];
+const LANG_KEY = "orc-ui-lang";
+
+// v0.48.1 — one file per namespace instead of one 53 KB table, so changing the
+// Docs panel's wording means opening i18n/en/docs.json rather than paging
+// through every string in the panel.
+//
+// A plain array, and deliberately NOT an index file to fetch: an index would be
+// one more round trip and one more thing to forget to update. A namespace owns
+// one or more key PREFIXES (`stats` owns `stats.*` and `cost.*`), which the
+// test suite asserts — a key whose prefix belongs to no namespace would load
+// nowhere and render as a raw dotted string.
+const NAMESPACES = [
+  "common",
+  "nav",
+  "banner",
+  "overview",
+  "settings",
+  "lanes",
+  "runs",
+  "knowledge",
+  "stats",
+  "flow",
+  "crosslink",
+  "learn",
+  "mockrun",
+  "maintenance",
+  "pact",
+  "boundary",
+  "wait",
+  "handoff",
+  "challenge",
+  "docs",
+  "extra",
+  "experiment",
+  "tour",
+];
+
+let lang = "en";
+// English is loaded first and kept as the FALLBACK table: a key the other
+// language has not translated yet renders in English rather than as a raw
+// dotted key. A half-finished translation degrades to mixed prose, never to
+// debug output on somebody's screen.
+let DICT = {};
+let DICT_EN = {};
+
+// The namespaces are fetched in parallel and merged into ONE flat table, so
+// `t()` is unchanged and no call site knows the split happened.
+//
+// A namespace that fails to load falls back to ENGLISH for its keys rather than
+// rejecting the whole language: a network hiccup on one file should cost that
+// file's prose, not the entire panel. English itself has no fallback below it,
+// so a failure there rejects and boot() lands on raw keys — ugly, never blank.
+function loadLang(code) {
+  return Promise.all(
+    NAMESPACES.map((ns) =>
+      fetch(`/i18n/${code}/${ns}.json`, { headers: { "x-orc-token": TOKEN }, cache: "no-store" })
+        .then((r) => {
+          if (!r.ok) throw new Error(`i18n ${code}/${ns} ${r.status}`);
+          return r.json();
+        })
+        .catch((e) => {
+          if (code === "en") throw e;
+          return null;
+        })
+    )
+  ).then((parts) => Object.assign({}, ...parts.filter(Boolean)));
+}
+
+// A missing or broken table must never blank the UI. Every failure path here
+// lands on English, so the worst case is untranslated text — never empty text.
+async function setLang(code, opts) {
+  const rerender = !opts || opts.rerender !== false;
+  const want = LANGS.some((l) => l.code === code) ? code : "en";
+  try {
+    DICT = want === "en" ? DICT_EN : await loadLang(want);
+    lang = want;
+  } catch (_) {
+    DICT = DICT_EN;
+    lang = "en";
+  }
+  try {
+    localStorage.setItem(LANG_KEY, lang);
+  } catch (_) {}
+  document.documentElement.setAttribute("lang", lang);
+  applyStaticText();
+  if (rerender) route();
+}
+
+function t(key, vars) {
+  let s = DICT[key];
+  if (s === undefined) s = DICT_EN[key];
+  if (s === undefined) s = key;
+  if (vars) for (const k of Object.keys(vars)) s = s.split("{" + k + "}").join(String(vars[k]));
+  return s;
+}
+
+// English has one plural form and Indonesian has none, so count-aware lookup is
+// a second key rather than a plural-rules engine: `n === 1` picks the singular.
+const tn = (n, key, vars) => t(n === 1 ? key : key + "Plural", Object.assign({ n }, vars || {}));
+
+// The parts of the shell that are markup rather than a render function. Called
+// on every language change; panels re-render themselves through `route()`.
+function applyStaticText() {
+  for (const node of document.querySelectorAll("[data-i18n]")) node.textContent = t(node.dataset.i18n);
+  const tt = $("#theme-toggle");
+  if (tt) tt.textContent = document.documentElement.getAttribute("data-theme") === "light" ? t("rail.dark") : t("rail.light");
+  const hint = $("#shortcut-hint");
+  if (hint) hint.title = t("rail.shortcuts");
+  const label = $("#lang-label");
+  if (label) label.textContent = (LANGS.find((l) => l.code === lang) || LANGS[0]).label;
+  const btn = $("#lang-toggle");
+  if (btn) btn.title = t("lang.title");
+}
+
+// Two languages, so the control is a TOGGLE rather than a menu: one click, no
+// dropdown to open. A third language would make this a <select>; two do not.
+function cycleLang() {
+  const i = LANGS.findIndex((l) => l.code === lang);
+  setLang(LANGS[(i + 1) % LANGS.length].code);
+}