thurview 0.1.4

package/dist/ui/app.js

@@ -0,0 +1,2303 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __esm = (fn, res, err) => function __init() {
+    if (err) throw err[0];
+    try {
+      return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+    } catch (e) {
+      throw err = [e], e;
+    }
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/ui/dom.ts
+  var dom_exports = {};
+  __export(dom_exports, {
+    append: () => append,
+    clear: () => clear,
+    closePopover: () => closePopover,
+    dialog: () => dialog,
+    escapeHtml: () => escapeHtml,
+    h: () => h,
+    popover: () => popover,
+    svg: () => svg,
+    timeAgo: () => timeAgo
+  });
+  function h(tag, attrs = null, ...children) {
+    const el = document.createElement(tag);
+    if (attrs) {
+      for (const [k, v] of Object.entries(attrs)) {
+        if (v === null || v === void 0 || v === false) continue;
+        if (k === "class") el.className = String(v);
+        else if (k === "html") el.innerHTML = String(v);
+        else if (k.startsWith("on") && typeof v === "function")
+          el.addEventListener(k.slice(2).toLowerCase(), v);
+        else if (k === "style" && typeof v === "object") Object.assign(el.style, v);
+        else if (k in el && typeof v !== "string" && k !== "title")
+          el[k] = v;
+        else el.setAttribute(k, String(v));
+      }
+    }
+    append(el, children);
+    return el;
+  }
+  function append(el, children) {
+    for (const c of children) {
+      if (c === null || c === void 0 || c === false) continue;
+      if (Array.isArray(c)) append(el, c);
+      else
+        el.appendChild(
+          typeof c === "string" || typeof c === "number" ? document.createTextNode(String(c)) : c
+        );
+    }
+  }
+  function svg(tag, attrs = {}, ...children) {
+    const el = document.createElementNS("http://www.w3.org/2000/svg", tag);
+    for (const [k, v] of Object.entries(attrs)) {
+      if (k.startsWith("on") && typeof v === "function")
+        el.addEventListener(k.slice(2).toLowerCase(), v);
+      else el.setAttribute(k, String(v));
+    }
+    for (const c of children) el.appendChild(typeof c === "string" ? document.createTextNode(c) : c);
+    return el;
+  }
+  function clear(el) {
+    while (el.firstChild) el.removeChild(el.firstChild);
+  }
+  function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+  function timeAgo(iso) {
+    const d = (Date.now() - new Date(iso).getTime()) / 1e3;
+    if (d < 60) return "just now";
+    if (d < 3600) return `${Math.floor(d / 60)} min ago`;
+    if (d < 86400) return `${Math.floor(d / 3600)} h ago`;
+    return `${Math.floor(d / 86400)} d ago`;
+  }
+  function popover(el, at) {
+    closePopover();
+    el.style.position = "absolute";
+    document.body.appendChild(el);
+    const w = el.offsetWidth;
+    const hgt = el.offsetHeight;
+    const x = Math.min(at.x, window.innerWidth - w - 12);
+    const y = at.y + hgt > window.scrollY + window.innerHeight - 12 ? at.y - hgt - 8 : at.y;
+    el.style.left = `${Math.max(8, x)}px`;
+    el.style.top = `${Math.max(8, y)}px`;
+    openPopover = el;
+    setTimeout(() => {
+      document.addEventListener("mousedown", onDoc);
+      document.addEventListener("keydown", onKey);
+    });
+    return el;
+  }
+  function onDoc(e) {
+    if (openPopover && !openPopover.contains(e.target)) closePopover();
+  }
+  function onKey(e) {
+    if (e.key === "Escape") closePopover();
+  }
+  function closePopover() {
+    if (openPopover) openPopover.remove();
+    openPopover = null;
+    document.removeEventListener("mousedown", onDoc);
+    document.removeEventListener("keydown", onKey);
+  }
+  function dialog(content) {
+    const overlay = h("div", { class: "overlay" }, h("div", { class: "dialog" }, content));
+    overlay.addEventListener("mousedown", (e) => {
+      if (e.target === overlay) overlay.remove();
+    });
+    document.body.appendChild(overlay);
+    return { close: () => overlay.remove() };
+  }
+  var openPopover;
+  var init_dom = __esm({
+    "src/ui/dom.ts"() {
+      "use strict";
+      openPopover = null;
+    }
+  });
+
+  // src/ui/api.ts
+  async function j(url, init) {
+    const r = await fetch(url, init);
+    const body = await r.json();
+    if (!r.ok) throw new Error(body.error ?? r.statusText);
+    return body;
+  }
+  function post(url, body) {
+    return j(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  }
+  var api = {
+    reviews: () => j("/api/reviews"),
+    review: (id, revision) => j(`/api/reviews/${id}${revision ? `?revision=${revision}` : ""}`),
+    revisions: (id) => j(`/api/reviews/${id}/revisions`),
+    commits: (id) => j(`/api/reviews/${id}/commits`),
+    diff: (id, path) => j(`/api/reviews/${id}/diff?path=${encodeURIComponent(path)}`),
+    file: (id, path, graph, from, to) => j(
+      `/api/reviews/${id}/file?path=${encodeURIComponent(path)}&graph=${graph}${from ? `&from=${from}` : ""}${to ? `&to=${to}` : ""}`
+    ),
+    symbols: (id, name, graph) => j(`/api/reviews/${id}/symbols?name=${encodeURIComponent(name)}&graph=${graph}`),
+    createThread: (id, input) => post(`/api/reviews/${id}/threads`, input),
+    reply: (id, tid, body) => post(`/api/reviews/${id}/threads/${tid}/reply`, { body, role: "reviewer" }),
+    resolve: (id, tid) => post(`/api/reviews/${id}/threads/${tid}/resolve`, {}),
+    reopen: (id, tid) => post(`/api/reviews/${id}/threads/${tid}/reopen`, {}),
+    deleteThread: (id, tid) => post(`/api/reviews/${id}/threads/${tid}/delete`, {}),
+    submit: (id, decision, body) => post(`/api/reviews/${id}/submit`, { decision, body }),
+    dismiss: (id, dismissed) => post(`/api/reviews/${id}/dismiss`, { dismissed }),
+    remove: (id) => j(`/api/reviews/${id}`, { method: "DELETE" })
+  };
+
+  // src/ui/app.ts
+  init_dom();
+
+  // src/ui/state.ts
+  var state = {
+    id: "",
+    data: null,
+    view: "review",
+    params: new URLSearchParams(),
+    side: { kind: "none" },
+    viewingRevision: null,
+    latestRevision: null,
+    splitDiff: localStorage.getItem("thurview.split") !== "0"
+  };
+  var listeners = {};
+  function on(event, fn) {
+    (listeners[event] ??= []).push(fn);
+  }
+  function emit(event) {
+    for (const fn of listeners[event] ?? []) fn();
+  }
+  function threadsFor(target) {
+    return (state.data?.threads ?? []).filter((t) => target(t.target));
+  }
+  function describeTarget(t) {
+    if (t.type === "document") return "document";
+    if (t.type === "file") {
+      if (!t.line) return `${t.path} (file)`;
+      const range = t.endLine && t.endLine > t.line ? `${t.line}-${t.endLine}` : String(t.line);
+      return `${t.path}:${range}${t.side === "base" ? " (base)" : ""}`;
+    }
+    if (t.type === "map") return `map \xB7 ${t.node}`;
+    return "review";
+  }
+  function navigate(view, params = {}) {
+    const p = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) if (v !== void 0 && v !== "") p.set(k, String(v));
+    const q = p.toString();
+    location.hash = `#/${view}${q ? `?${q}` : ""}`;
+  }
+  function readHash() {
+    const m2 = /^#\/(\w+)(?:\?(.*))?$/.exec(location.hash);
+    const view = m2?.[1] ?? "review";
+    state.view = ["review", "commits", "files", "map"].includes(view) ? view : "review";
+    state.params = new URLSearchParams(m2?.[2] ?? "");
+  }
+  function isTerminal() {
+    const s = state.data?.review.status;
+    return s === "accepted" || s === "rejected";
+  }
+  function readOnly() {
+    return isTerminal() || state.viewingRevision !== null;
+  }
+
+  // src/ui/code.ts
+  init_dom();
+
+  // src/ui/threads.ts
+  init_dom();
+  async function reload() {
+    state.data = await api.review(state.id, state.viewingRevision ?? void 0);
+    emit("threads");
+  }
+  function commentPopover(target, quote) {
+    const ta = h("textarea", { placeholder: "Comment, or a question for the agent\u2026" });
+    let mode = "review";
+    const modeBtns = h("div", { class: "row" });
+    const b1 = h("button", { class: "small primary", onclick: () => set("review") }, "Add to review");
+    const b2 = h("button", { class: "small", onclick: () => set("ask") }, "Ask now");
+    const set = (m2) => {
+      mode = m2;
+      b1.className = `small ${m2 === "review" ? "primary" : ""}`;
+      b2.className = `small ${m2 === "ask" ? "primary" : ""}`;
+      hint.textContent = m2 === "review" ? "Held until you submit the review." : "Sent to the agent at once; it answers in this thread.";
+    };
+    const hint = h(
+      "span",
+      { class: "muted", style: { fontSize: "12px" } },
+      "Held until you submit the review."
+    );
+    modeBtns.append(b1, b2, hint);
+    const submit = async () => {
+      const body = ta.value.trim();
+      if (!body) return;
+      await api.createThread(state.id, {
+        kind: mode === "ask" ? "question" : "comment",
+        mode,
+        target: quote ? { ...target, quote } : target,
+        body
+      });
+      closePopover();
+      await reload();
+    };
+    ta.addEventListener("keydown", (e) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === "Enter") void submit();
+    });
+    const el = h(
+      "div",
+      { class: "comment-popover" },
+      quote ? h("div", { class: "quote" }, quote) : null,
+      h(
+        "div",
+        { class: "muted", style: { fontSize: "12px", marginBottom: "4px" } },
+        describeTarget(target)
+      ),
+      ta,
+      modeBtns,
+      h(
+        "div",
+        { class: "row", style: { justifyContent: "flex-end" } },
+        h("button", { class: "small ghost", onclick: () => closePopover() }, "Cancel"),
+        h("button", { class: "small ok", onclick: submit }, "Save ", h("kbd", null, "\u2318\u21B5"))
+      )
+    );
+    setTimeout(() => ta.focus());
+    return el;
+  }
+  function threadPinRow(t) {
+    const first = t.messages[0];
+    const last = t.messages[t.messages.length - 1];
+    return h(
+      "div",
+      {
+        class: `thread-pin ${t.status === "resolved" ? "resolved" : ""}`,
+        onclick: () => focusThread(t.id)
+      },
+      h(
+        "span",
+        { class: `badge ${t.kind === "question" ? "accent" : ""}` },
+        t.kind === "question" ? "Q" : t.submitted ? "C" : "draft"
+      ),
+      h("span", { class: "who" }, first?.role === "agent" ? "agent" : "you"),
+      h(
+        "span",
+        {
+          style: {
+            flex: "1",
+            minWidth: "0",
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap"
+          }
+        },
+        first?.body ?? ""
+      ),
+      t.messages.length > 1 ? h(
+        "span",
+        { class: "muted" },
+        `${t.messages.length - 1} repl${t.messages.length > 2 ? "ies" : "y"} \xB7 ${last?.role}`
+      ) : null,
+      t.status === "resolved" ? h("span", { class: "badge ok" }, "resolved") : null
+    );
+  }
+  function focusThread(id) {
+    state.side = { kind: "threads", activeThread: id };
+    emit("side");
+  }
+  function goToTarget(t) {
+    const tg = t.target;
+    if (tg.type === "document") {
+      navigate("review", { block: tg.blockId });
+    } else if (tg.type === "file") {
+      navigate("files", { path: tg.path, line: tg.line, side: tg.side });
+    } else if (tg.type === "map") {
+      navigate("map", { node: tg.node });
+    }
+  }
+  function renderThreadsPanel(container) {
+    const threads = state.data?.threads ?? [];
+    const pending = threads.filter((t) => !t.submitted);
+    let showResolved = false;
+    const head = h(
+      "div",
+      { class: "side-head" },
+      h(
+        "div",
+        { style: { flex: "1" } },
+        h("b", null, "Threads"),
+        " ",
+        h("span", { class: "muted" }, `${threads.filter((t) => t.status === "open").length} open`)
+      ),
+      h(
+        "label",
+        { style: { fontSize: "12px" } },
+        h("input", {
+          type: "checkbox",
+          onchange: (e) => {
+            showResolved = e.target.checked;
+            draw();
+          }
+        }),
+        " resolved"
+      ),
+      h(
+        "button",
+        {
+          class: "small ghost",
+          onclick: () => {
+            state.side = { kind: "none" };
+            emit("side");
+          }
+        },
+        "\u2715"
+      )
+    );
+    const body = h("div", { class: "side-body" });
+    const draw = () => {
+      body.innerHTML = "";
+      if (pending.length && !readOnly()) {
+        body.appendChild(
+          h(
+            "div",
+            { class: "banner" },
+            `${pending.length} comment${pending.length > 1 ? "s" : ""} pending`,
+            h("span", { style: { flex: "1" } }),
+            h("button", { class: "small primary", onclick: () => submitDialog() }, "Submit review")
+          )
+        );
+      }
+      const list = h("div", { class: "threads" });
+      const shown = threads.filter(
+        (t) => showResolved || t.status === "open" || t.id === state.side.activeThread
+      );
+      if (!shown.length)
+        list.appendChild(
+          h(
+            "div",
+            { class: "empty-state" },
+            "No threads yet. Select text, click a line number, or use the + next to a paragraph."
+          )
+        );
+      for (const t of shown.slice().sort((a, b) => a.updatedAt < b.updatedAt ? 1 : -1))
+        list.appendChild(threadCard(t));
+      body.appendChild(list);
+    };
+    draw();
+    container.append(head, body);
+    if (state.side.activeThread)
+      setTimeout(() => body.querySelector(".thread.active")?.scrollIntoView({ block: "center" }));
+  }
+  function threadCard(t) {
+    const ta = h("textarea", { placeholder: "Reply\u2026", rows: 2 });
+    const send = async () => {
+      const v = ta.value.trim();
+      if (!v) return;
+      await api.reply(state.id, t.id, v);
+      await reload();
+    };
+    ta.addEventListener("keydown", (e) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === "Enter") void send();
+    });
+    const quote = t.target.type === "document" || t.target.type === "file" ? t.target.quote : void 0;
+    return h(
+      "div",
+      { class: `thread ${state.side.activeThread === t.id ? "active" : ""}` },
+      h(
+        "div",
+        { class: "thead" },
+        h(
+          "span",
+          { class: `badge ${t.kind === "question" ? "accent" : ""}` },
+          t.kind === "question" ? "question" : t.submitted ? "comment" : "pending"
+        ),
+        h("span", { class: "target", onclick: () => goToTarget(t) }, describeTarget(t.target)),
+        h("span", { class: `badge ${t.status === "resolved" ? "ok" : ""}` }, t.status)
+      ),
+      quote ? h("div", { class: "quote" }, `\u201C${quote.length > 160 ? quote.slice(0, 160) + "\u2026" : quote}\u201D`) : null,
+      t.messages.map(
+        (m2) => h(
+          "div",
+          { class: `msg ${m2.role}` },
+          h("span", { class: "who" }, m2.role === "agent" ? "Agent" : "You"),
+          h("span", { class: "muted", style: { fontSize: "11px" } }, timeAgo(m2.at)),
+          h("div", null, m2.body)
+        )
+      ),
+      readOnly() ? null : h(
+        "div",
+        { class: "reply" },
+        ta,
+        h(
+          "div",
+          { class: "row" },
+          !t.submitted ? h(
+            "button",
+            {
+              class: "small ghost",
+              onclick: async () => {
+                await api.deleteThread(state.id, t.id);
+                await reload();
+              }
+            },
+            "Delete"
+          ) : null,
+          t.status === "open" ? h(
+            "button",
+            {
+              class: "small",
+              onclick: async () => {
+                await api.resolve(state.id, t.id);
+                await reload();
+              }
+            },
+            "Resolve"
+          ) : h(
+            "button",
+            {
+              class: "small",
+              onclick: async () => {
+                await api.reopen(state.id, t.id);
+                await reload();
+              }
+            },
+            "Reopen"
+          ),
+          h("button", { class: "small primary", onclick: send }, "Reply")
+        )
+      )
+    );
+  }
+  function submitDialog() {
+    const pending = (state.data?.threads ?? []).filter((t) => !t.submitted).length;
+    const ta = h("textarea", { rows: 4, placeholder: "Summary for the agent (optional)" });
+    const d = dialog(
+      h(
+        "div",
+        null,
+        h("h3", null, "Submit review"),
+        h(
+          "p",
+          { class: "muted" },
+          pending ? `${pending} pending comment${pending > 1 ? "s" : ""} will be sent to the agent.` : "No pending comments."
+        ),
+        ta,
+        h(
+          "div",
+          { class: "row" },
+          h("button", { class: "ghost", onclick: () => d.close() }, "Cancel"),
+          h("button", { onclick: () => decide("request-changes") }, "Request changes"),
+          h("button", { class: "ok", onclick: () => decide("approve") }, "Approve")
+        )
+      )
+    );
+    const decide = async (decision) => {
+      await api.submit(state.id, decision, ta.value.trim());
+      d.close();
+      await reload();
+      emit("data");
+    };
+  }
+
+  // src/ui/code.ts
+  function codeTable(o) {
+    const table = h("table");
+    const threads = o.commentable ? threadsFor((t) => t.type === "file" && t.path === o.path && t.side === o.graph) : [];
+    const endOf = (t) => t.target.type === "file" ? t.target.endLine ?? t.target.line : 0;
+    o.lines.forEach((html, i) => {
+      const n = o.startLine + i;
+      const hl = o.highlight && n >= o.highlight[0] && n <= o.highlight[1];
+      const lineThreads = threads.filter((t) => endOf(t) === n);
+      const tr = h(
+        "tr",
+        { class: `${hl ? "hl" : ""} ${lineThreads.length ? "commented" : ""}`, "data-line": n },
+        h(
+          "td",
+          {
+            class: "ln",
+            title: o.commentable ? "Comment on this line (shift-click for a range)" : "",
+            onclick: (e) => o.commentable && lineClick(e, o.path, o.graph, n, table)
+          },
+          String(n)
+        ),
+        h("td", { class: "src", html: html || " " })
+      );
+      table.appendChild(tr);
+      for (const t of lineThreads)
+        table.appendChild(h("tr", { class: "thread-row" }, h("td", { colspan: 2 }, threadPinRow(t))));
+    });
+    attachDefinitions(table, o.graph);
+    return table;
+  }
+  function startLineComment(e, target, quote) {
+    if (state.viewingRevision !== null) return;
+    const el = commentPopover(target, quote?.trim() ? quote.trim() : void 0);
+    popover(el, { x: e.pageX + 8, y: e.pageY + 8 });
+  }
+  var rangeStart = null;
+  function lineClick(e, path, side2, line, table) {
+    if (state.viewingRevision !== null) return;
+    if (e.shiftKey && rangeStart && rangeStart.path === path && rangeStart.side === side2) {
+      const from = Math.min(rangeStart.line, line);
+      const to = Math.max(rangeStart.line, line);
+      const quote = rowsText(table, side2, from, to);
+      clearRangeMarks(table);
+      for (let n = from; n <= to; n++)
+        table.querySelector(`tr[data-${side2}="${n}"]`)?.classList.add("range-sel");
+      rangeStart = null;
+      startLineComment(e, { type: "file", path, side: side2, line: from, endLine: to }, quote);
+      return;
+    }
+    rangeStart = { path, side: side2, line, table };
+    clearRangeMarks(table);
+    table.querySelector(`tr[data-${side2}="${line}"]`)?.classList.add("range-sel");
+    startLineComment(e, { type: "file", path, side: side2, line }, rowsText(table, side2, line, line));
+  }
+  function clearRangeMarks(table) {
+    table.querySelectorAll("tr.range-sel").forEach((tr) => tr.classList.remove("range-sel"));
+  }
+  function rowsText(table, side2, from, to) {
+    const parts = [];
+    for (let n = from; n <= to; n++) {
+      const td = table.querySelector(`tr[data-${side2}="${n}"] td.src`);
+      if (td) parts.push((td.textContent ?? "").replace(/^[+\- ]/, ""));
+    }
+    return parts.join("\n").slice(0, 400);
+  }
+  function codeSelectionHandler(root) {
+    let btn = null;
+    const remove = () => {
+      btn?.remove();
+      btn = null;
+    };
+    const onChange = () => {
+      const sel = window.getSelection();
+      if (!sel || sel.isCollapsed || !sel.rangeCount || !root.isConnected) return remove();
+      const range = sel.getRangeAt(0);
+      const rowOf = (node) => (node instanceof Element ? node : node.parentElement)?.closest(
+        "tr[data-head], tr[data-base]"
+      );
+      const a = rowOf(range.startContainer);
+      const b = rowOf(range.endContainer);
+      if (!a || !b || !root.contains(a) || !root.contains(b) || state.viewingRevision !== null)
+        return remove();
+      const table = a.closest("table");
+      if (!table || table !== b.closest("table")) return remove();
+      const path = root.closest("[data-path]")?.dataset["path"] ?? "";
+      const side2 = a.dataset["head"] && b.dataset["head"] ? "head" : "base";
+      const la = Number(a.dataset[side2]);
+      const lb = Number(b.dataset[side2]);
+      if (!la || !lb) return remove();
+      const from = Math.min(la, lb);
+      const to = Math.max(la, lb);
+      const quote = sel.toString().trim().slice(0, 400);
+      remove();
+      const rect = range.getBoundingClientRect();
+      btn = h(
+        "button",
+        {
+          class: "small primary selection-btn",
+          onmousedown: (e) => e.preventDefault(),
+          onclick: (e) => {
+            remove();
+            window.getSelection()?.removeAllRanges();
+            startLineComment(
+              e,
+              { type: "file", path, side: side2, line: from, ...to > from ? { endLine: to } : {} },
+              quote
+            );
+          }
+        },
+        to > from ? `Comment on lines ${from}-${to}` : `Comment on line ${from}`
+      );
+      btn.style.left = `${rect.left + window.scrollX}px`;
+      btn.style.top = `${rect.bottom + window.scrollY + 6}px`;
+      document.body.appendChild(btn);
+    };
+    document.addEventListener("selectionchange", onChange);
+  }
+  function attachDefinitions(root, graph) {
+    root.addEventListener("click", async (e) => {
+      const td = e.target.closest("td.src");
+      if (!td) return;
+      const sel = window.getSelection();
+      if (sel && !sel.isCollapsed) return;
+      const word = wordAt(e);
+      if (!word) return;
+      const defs = await api.symbols(state.id, word, graph);
+      if (e.ctrlKey || e.metaKey) {
+        const d = defs[0];
+        if (d) openPeekAt(d.path, graph, d.line, `${d.kind} ${d.name}`);
+        return;
+      }
+      const box = h("div", { class: "def-popover" });
+      if (!defs.length)
+        box.appendChild(
+          h(
+            "div",
+            { class: "empty" },
+            `No definition of `,
+            h("code", null, word),
+            ` found at ${graph}`
+          )
+        );
+      for (const d of defs) {
+        box.appendChild(
+          h(
+            "div",
+            {
+              class: "item",
+              onclick: () => {
+                closePopover();
+                openPeekAt(d.path, graph, d.line, `${d.kind} ${d.name}`);
+              }
+            },
+            h("span", { class: "kind" }, d.kind),
+            h("span", { class: "mono" }, `${d.path}:${d.line}`)
+          )
+        );
+      }
+      popover(box, { x: e.pageX + 6, y: e.pageY + 10 });
+    });
+  }
+  function wordAt(e) {
+    const doc = document;
+    let node = null;
+    let offset = 0;
+    if (doc.caretPositionFromPoint) {
+      const p = doc.caretPositionFromPoint(e.clientX, e.clientY);
+      if (p) {
+        node = p.offsetNode;
+        offset = p.offset;
+      }
+    } else if (document.caretRangeFromPoint) {
+      const r = document.caretRangeFromPoint(e.clientX, e.clientY);
+      if (r) {
+        node = r.startContainer;
+        offset = r.startOffset;
+      }
+    }
+    if (!node || node.nodeType !== Node.TEXT_NODE) return null;
+    const text = node.textContent ?? "";
+    const re = /[A-Za-z_$][\w$]*/g;
+    let m2;
+    while (m2 = re.exec(text)) if (m2.index <= offset && offset <= m2.index + m2[0].length) return m2[0];
+    return null;
+  }
+  var current = null;
+  function openAnchorPeek(a) {
+    if (!a.peek) return;
+    current = {
+      title: a.title,
+      detail: a.detail,
+      path: a.peek.file,
+      graph: a.peek.graph,
+      from: a.peek.from,
+      to: a.peek.to,
+      lines: a.peek.lines,
+      total: a.peek.total,
+      anchorId: a.id
+    };
+    state.side = { kind: "peek", anchor: a.id };
+    emit("side");
+    location.hash = location.hash.replace(/&?anchor=[^&]*/, "");
+  }
+  async function openPeekAt(path, graph, line, title) {
+    const from = Math.max(1, line - 5);
+    const f = await api.file(state.id, path, graph, from, line + 12);
+    current = {
+      title: title ?? path,
+      path,
+      graph,
+      from: f.from,
+      to: f.to,
+      lines: f.lines,
+      total: f.total
+    };
+    current.highlightLine = line;
+    state.side = { kind: "peek" };
+    emit("side");
+  }
+  function renderPeek(container) {
+    const p = current;
+    if (!p) return;
+    const inChanges = !!state.data?.changes.some((c) => c.path === p.path);
+    const head = h(
+      "div",
+      { class: "side-head" },
+      h(
+        "div",
+        { style: { flex: "1", minWidth: "0" } },
+        h("div", { style: { fontWeight: "600" } }, p.title),
+        h(
+          "div",
+          {
+            class: "path",
+            title: p.path,
+            onclick: () => navigate("files", { path: p.path, line: p.highlightLine ?? p.from, side: p.graph })
+          },
+          `${p.path}:${p.from}-${p.to}`,
+          " ",
+          h("span", { class: `badge ${p.graph === "base" ? "del" : ""}` }, p.graph)
+        )
+      ),
+      h(
+        "button",
+        {
+          class: "small",
+          onclick: () => navigate("files", { path: p.path, line: p.highlightLine ?? p.from, side: p.graph })
+        },
+        inChanges ? "Open in Files" : "Open file"
+      ),
+      h(
+        "button",
+        {
+          class: "small ghost",
+          onclick: () => {
+            state.side = { kind: "none" };
+            emit("side");
+          }
+        },
+        "\u2715"
+      )
+    );
+    const body = h("div", { class: "side-body" });
+    if (p.detail)
+      body.appendChild(
+        h("div", { class: "muted", style: { padding: "8px 12px", fontSize: "13px" } }, p.detail)
+      );
+    const frame = h("div", { class: "code" });
+    const draw = () => {
+      frame.innerHTML = "";
+      const bar = (dir) => {
+        const can = dir === "up" ? p.from > 1 : p.to < p.total;
+        return h(
+          "div",
+          { class: "expand-bar" },
+          can ? h(
+            "button",
+            { class: "small ghost", onclick: () => expand(dir) },
+            dir === "up" ? "\u2191 20 more lines" : "\u2193 20 more lines"
+          ) : h("span", { class: "muted" }, dir === "up" ? "start of file" : "end of file")
+        );
+      };
+      frame.appendChild(bar("up"));
+      frame.appendChild(
+        codeTable({
+          path: p.path,
+          graph: p.graph,
+          startLine: p.from,
+          lines: p.lines,
+          highlight: p.highlightLine ? [p.highlightLine, p.highlightLine] : p.anchorId ? [p.from, p.to] : void 0,
+          commentable: true
+        })
+      );
+      frame.appendChild(bar("down"));
+    };
+    const expand = async (dir) => {
+      if (dir === "up") {
+        const from = Math.max(1, p.from - 20);
+        const f = await api.file(state.id, p.path, p.graph, from, p.from - 1);
+        p.lines = [...f.lines, ...p.lines];
+        p.from = from;
+      } else {
+        const to = Math.min(p.total, p.to + 20);
+        const f = await api.file(state.id, p.path, p.graph, p.to + 1, to);
+        p.lines = [...p.lines, ...f.lines];
+        p.to = to;
+      }
+      if (p.anchorId) {
+        const a = state.data?.document?.anchors[p.anchorId];
+        if (a?.peek) p.highlightRange = [a.peek.from, a.peek.to];
+      }
+      draw();
+    };
+    draw();
+    body.appendChild(frame);
+    container.appendChild(head);
+    container.appendChild(body);
+  }
+
+  // src/ui/views/review.ts
+  init_dom();
+
+  // src/ui/diagrams.ts
+  init_dom();
+  init_dom();
+  function openAnchor(id) {
+    const a = state.data?.document?.anchors[id];
+    if (a) openAnchorPeek(a);
+  }
+  function sequenceDiagram(b) {
+    const colW = 170;
+    const top = 44;
+    const rowH = 34;
+    const n = b.actors.length;
+    const width = Math.max(colW * n, 320);
+    const height = top + rowH * (b.messages.length + 1) + 10;
+    const el = svg("svg", { viewBox: `0 0 ${width} ${height}`, class: "seq" });
+    el.appendChild(
+      svg(
+        "defs",
+        {},
+        svg(
+          "marker",
+          {
+            id: "arr",
+            viewBox: "0 0 10 10",
+            refX: "9",
+            refY: "5",
+            markerWidth: "7",
+            markerHeight: "7",
+            orient: "auto"
+          },
+          svg("path", { d: "M0,0 L10,5 L0,10 z", fill: "currentColor" })
+        )
+      )
+    );
+    const x = (id) => b.actors.findIndex((a) => a.id === id) * colW + colW / 2;
+    b.actors.forEach((a, i) => {
+      const cx = i * colW + colW / 2;
+      const g = svg("g", { class: "actor" });
+      g.appendChild(svg("rect", { x: cx - 70, y: 6, width: 140, height: 28, rx: 6 }));
+      g.appendChild(svg("text", { x: cx, y: 25, "text-anchor": "middle" }, a.label));
+      g.appendChild(svg("line", { class: "life", x1: cx, y1: 34, x2: cx, y2: height - 6 }));
+      el.appendChild(g);
+    });
+    b.messages.forEach((m2, i) => {
+      const y = top + rowH * (i + 1);
+      const x1 = x(m2.from);
+      const x2 = x(m2.to);
+      const g = svg("g", { class: "msg" });
+      const self = x1 === x2;
+      if (self) {
+        g.appendChild(
+          svg("path", {
+            d: `M${x1},${y - 10} h30 v20 h-30`,
+            fill: "none",
+            stroke: "currentColor",
+            "marker-end": "url(#arr)"
+          })
+        );
+      } else {
+        g.appendChild(svg("line", { x1, y1: y, x2: x2 + (x2 > x1 ? -4 : 4), y2: y }));
+      }
+      const label = svg(
+        "text",
+        { x: self ? x1 + 36 : (x1 + x2) / 2, y: y - 6, "text-anchor": self ? "start" : "middle" },
+        `${i + 1}. ${m2.label}`
+      );
+      label.addEventListener("click", (e) => {
+        if (m2.anchor) openAnchor(m2.anchor);
+        else if (m2.code)
+          popover(
+            h(
+              "div",
+              { class: "def-popover" },
+              h("pre", { style: { margin: "0", border: "none" } }, m2.code.text)
+            ),
+            { x: e.pageX, y: e.pageY + 8 }
+          );
+      });
+      g.appendChild(label);
+      el.appendChild(g);
+    });
+    return h("div", { class: "diagram" }, h("div", { class: "dhead" }, b.label), el);
+  }
+  function callstackDiff(b, doc) {
+    const rows = b.rows.map((r, i) => {
+      const a = doc.anchors[r.anchor];
+      return h(
+        "div",
+        { class: `row ${r.kind}`, title: r.reason ?? "", onclick: () => openAnchor(r.anchor) },
+        h("span", { class: "sign" }, r.kind === "add" ? "+" : r.kind === "del" ? "\u2212" : " "),
+        h("span", { style: { width: `${i * 14}px`, display: "inline-block" } }),
+        r.calls ? h("span", { class: "calls" }, "\u2248 ") : null,
+        h("span", null, a?.title ?? r.anchor),
+        a?.peek ? h(
+          "span",
+          { class: "muted", style: { marginLeft: "auto" } },
+          `${a.peek.file}:${a.peek.from}`
+        ) : null
+      );
+    });
+    return h(
+      "div",
+      { class: "diagram callstack" },
+      h("div", { class: "dhead" }, b.title ?? "Call stack"),
+      h("div", { style: { padding: "6px 0" } }, rows)
+    );
+  }
+  function databaseLens(b, doc) {
+    let active = 0;
+    const tabs = h("div", { class: "uc-tabs" });
+    const body = h("div", { class: "body" });
+    const draw = () => {
+      tabs.innerHTML = "";
+      b.usecases.forEach(
+        (uc2, i) => tabs.appendChild(
+          h(
+            "button",
+            {
+              class: `small ${i === active ? "active" : ""}`,
+              onclick: () => {
+                active = i;
+                draw();
+              }
+            },
+            uc2.label
+          )
+        )
+      );
+      const uc = b.usecases[active];
+      body.innerHTML = "";
+      const touched = /* @__PURE__ */ new Map();
+      for (const op of uc.ops) {
+        const [s, c, f] = op.store.split(".");
+        const key = `${s}.${c}`;
+        if (!touched.has(key)) touched.set(key, /* @__PURE__ */ new Set());
+        if (f) touched.get(key).add(f);
+      }
+      const actorIds = [...new Set(uc.ops.map((o) => o.actor))];
+      body.appendChild(
+        h(
+          "div",
+          { class: "actors" },
+          actorIds.map((id) => h("div", { class: "actor" }, doc.actors[id]?.label ?? id))
+        )
+      );
+      const stores = h("div", null);
+      for (const sid of b.stores) {
+        const s = doc.stores[sid];
+        if (!s) continue;
+        const colls = s.tables ?? s.documents ?? {};
+        stores.appendChild(
+          h(
+            "div",
+            { class: "store" },
+            h("div", { class: "sname" }, s.label, " ", h("span", { class: "badge" }, s.kind)),
+            Object.entries(colls).map(([cid, c]) => {
+              const hit = touched.get(`${sid}.${cid}`);
+              return h(
+                "div",
+                { class: `table ${hit ? "hit" : ""}` },
+                h("div", { class: "tname" }, c.label ?? cid),
+                h(
+                  "div",
+                  { class: "cols" },
+                  Object.entries(c.schema).map(
+                    ([f, def]) => h(
+                      "span",
+                      { class: hit?.has(f) ? "hit" : "" },
+                      `${f}${def.pk ? "*" : ""}:${def.type} `
+                    )
+                  )
+                )
+              );
+            })
+          )
+        );
+      }
+      body.appendChild(stores);
+    };
+    draw();
+    const ops = h("div", { class: "ops" });
+    const drawOps = () => {
+      ops.innerHTML = "";
+      const uc = b.usecases[active];
+      if (uc.summary) ops.appendChild(h("div", { class: "muted" }, uc.summary));
+      for (const op of uc.ops) {
+        ops.appendChild(
+          h(
+            "div",
+            { class: `op ${op.op}`, onclick: () => openAnchor(op.anchor) },
+            h(
+              "span",
+              { class: "dir" },
+              op.op === "read" ? `${op.store} \u2192 ${doc.actors[op.actor]?.label ?? op.actor}` : `${doc.actors[op.actor]?.label ?? op.actor} \u2192 ${op.store}`
+            ),
+            h("span", null, op.label)
+          )
+        );
+      }
+    };
+    drawOps();
+    tabs.addEventListener("click", drawOps);
+    return h(
+      "div",
+      { class: "diagram dblens" },
+      h("div", { class: "dhead" }, b.title ?? "Storage"),
+      tabs,
+      body,
+      ops
+    );
+  }
+
+  // src/ui/views/review.ts
+  function renderReview(root) {
+    const doc = state.data?.document;
+    if (!doc) {
+      root.appendChild(
+        h(
+          "div",
+          { class: "empty-state" },
+          "Nothing published yet. The agent publishes a revision with ",
+          h("code", null, "thurview publish"),
+          "."
+        )
+      );
+      return;
+    }
+    const layout = h("div", { class: "doc-layout" });
+    const toc = h(
+      "nav",
+      { class: "toc" },
+      doc.toc.map(
+        (t) => h(
+          "a",
+          {
+            href: `#/review?block=${t.id}`,
+            class: `l${t.level}`,
+            "data-block": t.id,
+            onclick: (e) => {
+              e.preventDefault();
+              scrollToBlock(t.id);
+            }
+          },
+          t.text
+        )
+      )
+    );
+    const docEl = h("article", { class: "doc" });
+    let section = null;
+    const sectionLevel = 2;
+    for (const b of doc.blocks) {
+      const el = renderBlock(b);
+      if (b.type === "heading" && b.level === sectionLevel) {
+        section = h("div", { class: `section ${b.collapsed ? "section-collapsed" : ""}` });
+        docEl.appendChild(section);
+        const toggle = h("span", { class: "heading-toggle" }, b.collapsed ? "show" : "hide");
+        toggle.addEventListener("click", () => {
+          const s = toggle.closest(".section");
+          s.classList.toggle("section-collapsed");
+          toggle.textContent = s.classList.contains("section-collapsed") ? "show" : "hide";
+        });
+        el.querySelector("h2,h1,h3")?.appendChild(toggle);
+        el.classList.add("heading");
+        section.appendChild(el);
+      } else (section ?? docEl).appendChild(el);
+    }
+    layout.append(toc, docEl);
+    root.appendChild(layout);
+    selectionHandler(docEl);
+    docEl.addEventListener("click", (e) => {
+      const a = e.target.closest("a.anchor-link");
+      if (!a) return;
+      e.preventDefault();
+      const id = a.dataset["anchor"];
+      const anchor = doc.anchors[id];
+      if (anchor) {
+        docEl.querySelectorAll("a.anchor-link.active").forEach((x) => x.classList.remove("active"));
+        a.classList.add("active");
+        openAnchorPeek(anchor);
+      }
+    });
+    const target = state.params.get("block");
+    if (target) setTimeout(() => scrollToBlock(target), 50);
+    const anchorParam = state.params.get("anchor");
+    if (anchorParam && doc.anchors[anchorParam] && state.side.kind !== "peek")
+      openAnchorPeek(doc.anchors[anchorParam]);
+    const io = new IntersectionObserver(
+      (entries) => {
+        for (const en of entries) {
+          if (!en.isIntersecting) continue;
+          const id = en.target.dataset["block"];
+          toc.querySelectorAll("a").forEach((a) => a.classList.toggle("active", a.dataset["block"] === id));
+        }
+      },
+      { rootMargin: "-10% 0px -80% 0px" }
+    );
+    docEl.querySelectorAll(".block.heading").forEach((el) => io.observe(el));
+  }
+  function scrollToBlock(id) {
+    const el = document.querySelector(`[data-block="${id}"]`);
+    if (!el) return;
+    el.closest(".section")?.classList.remove("section-collapsed");
+    el.scrollIntoView({ block: "start", behavior: "smooth" });
+    el.style.transition = "background .8s";
+    el.style.background = "var(--sel)";
+    setTimeout(() => el.style.background = "", 1200);
+  }
+  function renderBlock(b) {
+    const doc = state.data.document;
+    const wrap = h("div", { class: "block", "data-block": b.id });
+    const threads = threadsFor((t) => t.type === "document" && t.blockId === b.id);
+    if (threads.length) wrap.classList.add("has-threads");
+    const actions = h(
+      "div",
+      { class: "block-actions" },
+      h(
+        "button",
+        {
+          class: threads.length ? "count" : "",
+          title: "Comment on this block",
+          onclick: (e) => {
+            if (state.viewingRevision !== null) return;
+            popover(commentPopover({ type: "document", blockId: b.id }), {
+              x: e.pageX + 10,
+              y: e.pageY
+            });
+          }
+        },
+        threads.length ? String(threads.length) : "+"
+      )
+    );
+    wrap.appendChild(actions);
+    switch (b.type) {
+      case "html":
+      case "heading":
+        wrap.appendChild(h("div", { html: b.html }));
+        break;
+      case "peek": {
+        const a = doc.anchors[b.anchor];
+        if (a?.peek) {
+          wrap.appendChild(
+            h(
+              "div",
+              { class: "code-frame" },
+              h(
+                "div",
+                { class: "frame-head" },
+                h("span", { class: "title" }, a.title),
+                h(
+                  "span",
+                  {
+                    class: "path",
+                    title: "Open in Files",
+                    onclick: () => navigate("files", {
+                      path: a.peek.file,
+                      line: a.peek.from,
+                      side: a.peek.graph
+                    })
+                  },
+                  `${a.peek.file}:${a.peek.from}-${a.peek.to}`
+                ),
+                h("span", { class: `badge ${a.peek.graph === "base" ? "del" : ""}` }, a.peek.graph),
+                h("button", { class: "small ghost", onclick: () => openAnchorPeek(a) }, "peek \u25B8")
+              ),
+              a.detail ? h(
+                "div",
+                { class: "muted", style: { padding: "4px 10px", fontSize: "12.5px" } },
+                a.detail
+              ) : null,
+              h(
+                "div",
+                { class: "code" },
+                codeTable({
+                  path: a.peek.file,
+                  graph: a.peek.graph,
+                  startLine: a.peek.from,
+                  lines: a.peek.lines,
+                  commentable: true
+                })
+              )
+            )
+          );
+        }
+        break;
+      }
+      case "sequence":
+        wrap.appendChild(sequenceDiagram(b));
+        break;
+      case "callstack":
+        wrap.appendChild(callstackDiff(b, doc));
+        break;
+      case "database":
+        wrap.appendChild(databaseLens(b, doc));
+        break;
+    }
+    if (threads.length)
+      wrap.appendChild(h("div", { class: "thread-pins" }, threads.map(threadPinRow)));
+    return wrap;
+  }
+  function selectionHandler(docEl) {
+    let btn = null;
+    const remove = () => {
+      btn?.remove();
+      btn = null;
+    };
+    document.addEventListener("selectionchange", () => {
+      const sel = window.getSelection();
+      if (!sel || sel.isCollapsed || !sel.rangeCount) return remove();
+      const range = sel.getRangeAt(0);
+      const block = (range.commonAncestorContainer instanceof Element ? range.commonAncestorContainer : range.commonAncestorContainer.parentElement)?.closest(".block");
+      if (!block || !docEl.contains(block) || state.viewingRevision !== null) return remove();
+      const quote = sel.toString().trim();
+      if (!quote) return remove();
+      const rect = range.getBoundingClientRect();
+      remove();
+      btn = h(
+        "button",
+        {
+          class: "small primary selection-btn",
+          onmousedown: (e) => e.preventDefault(),
+          onclick: (e) => {
+            const id = block.dataset["block"];
+            remove();
+            popover(commentPopover({ type: "document", blockId: id }, quote), {
+              x: e.pageX,
+              y: e.pageY + 8
+            });
+            window.getSelection()?.removeAllRanges();
+          }
+        },
+        "Comment / Ask"
+      );
+      btn.style.left = `${rect.left + window.scrollX}px`;
+      btn.style.top = `${rect.bottom + window.scrollY + 6}px`;
+      document.body.appendChild(btn);
+    });
+  }
+
+  // src/ui/views/files.ts
+  init_dom();
+  function renderFiles(root) {
+    const changes = state.data?.changes ?? [];
+    const path = state.params.get("path") ?? changes[0]?.path ?? "";
+    const list = h("div", { class: "file-list" });
+    for (const c of changes) {
+      const n = (state.data?.threads ?? []).filter(
+        (t) => t.target.type === "file" && t.target.path === c.path && t.status === "open"
+      ).length;
+      list.appendChild(
+        h(
+          "div",
+          {
+            class: `item ${c.path === path ? "active" : ""}`,
+            onclick: () => navigate("files", { path: c.path })
+          },
+          h(
+            "span",
+            {
+              class: `badge ${c.status === "A" ? "ok" : c.status === "D" ? "del" : ""}`,
+              style: { minWidth: "20px", textAlign: "center" }
+            },
+            c.status
+          ),
+          h("span", { class: "name", title: c.path }, c.path),
+          n ? h("span", { class: "badge accent" }, String(n)) : null,
+          h(
+            "span",
+            { class: "stat" },
+            h("span", { class: "a" }, `+${c.additions}`),
+            " ",
+            h("span", { class: "d" }, `\u2212${c.deletions}`)
+          )
+        )
+      );
+    }
+    if (!changes.length)
+      list.appendChild(
+        h("div", { class: "empty-state" }, "No changed files: base and head are the same commit.")
+      );
+    const view = h("div", { class: "file-view", "data-path": path });
+    root.appendChild(h("div", { class: "files-layout" }, list, view));
+    if (path) void renderDiff(view, path);
+  }
+  async function renderDiff(view, path) {
+    const inChanges = state.data?.changes.some((c) => c.path === path);
+    const line = Number(state.params.get("line") ?? 0);
+    const side2 = state.params.get("side") === "base" ? "base" : "head";
+    view.appendChild(h("div", { class: "muted", style: { padding: "12px" } }, "Loading\u2026"));
+    let d;
+    try {
+      if (inChanges) d = await api.diff(state.id, path);
+      else {
+        const f = await api.file(state.id, path, side2);
+        d = {
+          path,
+          lang: f.lang,
+          binary: false,
+          oldTotal: 0,
+          newTotal: f.total,
+          hunks: [
+            {
+              oldStart: 1,
+              oldLines: 0,
+              newStart: 1,
+              newLines: f.total,
+              rows: f.lines.map((html, i) => ({
+                type: "context",
+                newLine: i + 1,
+                oldLine: i + 1,
+                html
+              }))
+            }
+          ]
+        };
+      }
+    } catch (e) {
+      view.innerHTML = "";
+      view.appendChild(h("div", { class: "empty-state" }, e.message));
+      return;
+    }
+    view.innerHTML = "";
+    const toggle = h(
+      "button",
+      {
+        class: "small",
+        onclick: () => {
+          state.splitDiff = !state.splitDiff;
+          localStorage.setItem("thurview.split", state.splitDiff ? "1" : "0");
+          view.innerHTML = "";
+          void renderDiff(view, path);
+        }
+      },
+      state.splitDiff ? "Unified" : "Split"
+    );
+    const fileThreads = (state.data?.threads ?? []).filter(
+      (t) => t.target.type === "file" && t.target.path === path && t.target.line === 0
+    );
+    view.appendChild(
+      h(
+        "div",
+        { class: "file-head" },
+        h("span", { class: "path" }, d.oldPath ? `${d.oldPath} \u2192 ${path}` : path),
+        h(
+          "span",
+          { class: "muted" },
+          `${d.hunks.reduce((n, hk) => n + hk.rows.filter((r) => r.type === "add").length, 0)} added \xB7 ${d.hunks.reduce((n, hk) => n + hk.rows.filter((r) => r.type === "del").length, 0)} deleted`
+        ),
+        h(
+          "span",
+          { class: "muted hint" },
+          "click a line number to comment \xB7 shift-click or select text for a range"
+        ),
+        state.viewingRevision === null ? h(
+          "button",
+          {
+            class: "small",
+            onclick: (e) => startLineComment(e, { type: "file", path, side: "head", line: 0 })
+          },
+          fileThreads.length ? `File comments (${fileThreads.length})` : "Comment on file"
+        ) : null,
+        inChanges ? toggle : h("span", { class: "badge" }, `full file at ${side2}`)
+      )
+    );
+    if (fileThreads.length)
+      view.appendChild(
+        h(
+          "div",
+          { class: "thread-pins", style: { margin: "8px 14px" } },
+          fileThreads.map(threadPinRow)
+        )
+      );
+    if (d.binary) {
+      view.appendChild(h("div", { class: "empty-state" }, "Binary file"));
+      return;
+    }
+    const threads = (state.data?.threads ?? []).filter(
+      (t) => t.target.type === "file" && t.target.path === path
+    );
+    const el = state.splitDiff && inChanges ? splitView(d, threads) : unifiedView(d, threads);
+    view.appendChild(el);
+    codeSelectionHandler(view);
+    if (line) {
+      const tr = el.querySelector(`tr[data-${side2}="${line}"]`);
+      if (tr) {
+        tr.classList.add("hl");
+        tr.scrollIntoView({ block: "center" });
+      }
+    }
+  }
+  function lineCell(path, side2, n, _text) {
+    return h(
+      "td",
+      {
+        class: "ln",
+        title: n ? "Comment on this line (shift-click for a range)" : "",
+        onclick: (e) => {
+          const table = e.currentTarget.closest("table");
+          if (n && table) lineClick(e, path, side2, n, table);
+        }
+      },
+      n ? String(n) : ""
+    );
+  }
+  function threadRows(threads, side2, n, colspan) {
+    if (!n) return [];
+    return threads.filter((t) => t.target.side === side2 && (t.target.endLine ?? t.target.line) === n).map((t) => h("tr", { class: "thread-row" }, h("td", { colspan }, threadPinRow(t))));
+  }
+  function gapRow(d, from, to, colspan, onExpand) {
+    if (to < from) return null;
+    const count = to - from + 1;
+    return h(
+      "tr",
+      { class: "gap" },
+      h(
+        "td",
+        {
+          colspan,
+          onclick: async () => {
+            const f = await api.file(state.id, d.path, "head", from, to);
+            onExpand(
+              f.lines.map((html, i) => ({
+                type: "context",
+                newLine: from + i,
+                oldLine: from + i - (gapOffset(d, from) ?? 0),
+                html
+              }))
+            );
+          }
+        },
+        `\u22EF ${count} unchanged line${count > 1 ? "s" : ""}`
+      )
+    );
+  }
+  function gapOffset(d, newLine) {
+    let off = 0;
+    for (const hk of d.hunks) {
+      if (hk.newStart > newLine) break;
+      off = hk.newStart + hk.newLines - (hk.oldStart + hk.oldLines);
+    }
+    return off;
+  }
+  function unifiedView(d, threads) {
+    const table = h("table");
+    const text = (html) => {
+      const x = document.createElement("div");
+      x.innerHTML = html;
+      return x.textContent ?? "";
+    };
+    const rowEl = (r) => {
+      const tr = h(
+        "tr",
+        { class: r.type, "data-head": r.newLine ?? "", "data-base": r.oldLine ?? "" },
+        lineCell(d.path, "base", r.oldLine, text(r.html)),
+        lineCell(d.path, "head", r.newLine, text(r.html)),
+        h("td", {
+          class: "src",
+          html: (r.type === "add" ? "+" : r.type === "del" ? "-" : " ") + (r.html || " ")
+        })
+      );
+      return [
+        tr,
+        ...threadRows(
+          threads,
+          r.type === "del" ? "base" : "head",
+          r.type === "del" ? r.oldLine : r.newLine,
+          3
+        )
+      ];
+    };
+    let prevEnd = 0;
+    d.hunks.forEach((hk, i) => {
+      const gap = gapRow(d, prevEnd + 1, hk.newStart - 1, 3, (rows) => {
+        const g = table.querySelector(`tr.gap[data-i="${i}"]`);
+        if (!g) return;
+        rows.flatMap(rowEl).forEach((r) => table.insertBefore(r, g));
+        g.remove();
+      });
+      if (gap) {
+        gap.dataset["i"] = String(i);
+        table.appendChild(gap);
+      }
+      for (const r of hk.rows) rowEl(r).forEach((x) => table.appendChild(x));
+      prevEnd = hk.newStart + hk.newLines - 1;
+    });
+    if (d.newTotal > prevEnd) {
+      const gap = gapRow(d, prevEnd + 1, d.newTotal, 3, (rows) => {
+        const g = table.querySelector("tr.gap.tail");
+        if (!g) return;
+        rows.flatMap(rowEl).forEach((r) => table.insertBefore(r, g));
+        g.remove();
+      });
+      if (gap) {
+        gap.classList.add("tail");
+        table.appendChild(gap);
+      }
+    }
+    const wrap = h("div", { class: "code" }, table);
+    attachDefinitions(wrap, "head");
+    return wrap;
+  }
+  function splitView(d, threads) {
+    const left = h("table");
+    const right = h("table");
+    const text = (html) => {
+      const x = document.createElement("div");
+      x.innerHTML = html;
+      return x.textContent ?? "";
+    };
+    const pair = (l2, r2) => {
+      const ltr = l2 ? h(
+        "tr",
+        { class: l2.type === "del" ? "del" : "", "data-base": l2.oldLine ?? "" },
+        lineCell(d.path, "base", l2.oldLine, text(l2.html)),
+        h("td", { class: "src", html: l2.html || " " })
+      ) : h("tr", null, h("td", { class: "ln empty" }), h("td", { class: "src empty" }, " "));
+      const rtr = r2 ? h(
+        "tr",
+        { class: r2.type === "add" ? "add" : "", "data-head": r2.newLine ?? "" },
+        lineCell(d.path, "head", r2.newLine, text(r2.html)),
+        h("td", { class: "src", html: r2.html || " " })
+      ) : h("tr", null, h("td", { class: "ln empty" }), h("td", { class: "src empty" }, " "));
+      left.appendChild(ltr);
+      right.appendChild(rtr);
+      const lt = threadRows(threads, "base", l2?.oldLine, 2);
+      const rt = threadRows(threads, "head", r2?.newLine, 2);
+      const n = Math.max(lt.length, rt.length);
+      for (let i = 0; i < n; i++) {
+        left.appendChild(lt[i] ?? h("tr", { class: "thread-row" }, h("td", { colspan: 2 }, " ")));
+        right.appendChild(rt[i] ?? h("tr", { class: "thread-row" }, h("td", { colspan: 2 }, " ")));
+      }
+    };
+    const emitRows = (rows) => {
+      let i = 0;
+      while (i < rows.length) {
+        const r2 = rows[i];
+        if (r2.type === "context") {
+          pair(r2, r2);
+          i++;
+          continue;
+        }
+        const dels = [];
+        const adds = [];
+        while (i < rows.length && rows[i].type === "del") dels.push(rows[i++]);
+        while (i < rows.length && rows[i].type === "add") adds.push(rows[i++]);
+        const n = Math.max(dels.length, adds.length);
+        for (let k = 0; k < n; k++) pair(dels[k] ?? null, adds[k] ?? null);
+      }
+    };
+    let prevEnd = 0;
+    const gapBoth = (from, to) => {
+      if (to < from) return;
+      const count = to - from + 1;
+      const lg = h("tr", { class: "gap" }, h("td", { colspan: 2 }, `\u22EF ${count} unchanged`));
+      const rg = h("tr", { class: "gap" }, h("td", { colspan: 2 }, `\u22EF ${count} unchanged`));
+      const expand = async () => {
+        const f = await api.file(state.id, d.path, "head", from, to);
+        const off = gapOffset(d, from) ?? 0;
+        const rows = f.lines.map((html, k) => ({
+          type: "context",
+          newLine: from + k,
+          oldLine: from + k - off,
+          html
+        }));
+        const lAnchor = lg.nextSibling;
+        const rAnchor = rg.nextSibling;
+        lg.remove();
+        rg.remove();
+        const tmpL = left;
+        const tmpR = right;
+        const fragL = document.createDocumentFragment();
+        const fragR = document.createDocumentFragment();
+        for (const r2 of rows) {
+          fragL.appendChild(
+            h(
+              "tr",
+              { "data-base": r2.oldLine ?? "" },
+              lineCell(d.path, "base", r2.oldLine, text(r2.html)),
+              h("td", { class: "src", html: r2.html || " " })
+            )
+          );
+          fragR.appendChild(
+            h(
+              "tr",
+              { "data-head": r2.newLine ?? "" },
+              lineCell(d.path, "head", r2.newLine, text(r2.html)),
+              h("td", { class: "src", html: r2.html || " " })
+            )
+          );
+        }
+        tmpL.insertBefore(fragL, lAnchor);
+        tmpR.insertBefore(fragR, rAnchor);
+      };
+      lg.addEventListener("click", expand);
+      rg.addEventListener("click", expand);
+      left.appendChild(lg);
+      right.appendChild(rg);
+    };
+    for (const hk of d.hunks) {
+      gapBoth(prevEnd + 1, hk.newStart - 1);
+      emitRows(hk.rows);
+      prevEnd = hk.newStart + hk.newLines - 1;
+    }
+    gapBoth(prevEnd + 1, d.newTotal);
+    const l = h("div", { class: "code" }, left);
+    const r = h("div", { class: "code" }, right);
+    attachDefinitions(l, "base");
+    attachDefinitions(r, "head");
+    l.addEventListener("scroll", () => r.scrollLeft = l.scrollLeft);
+    r.addEventListener("scroll", () => l.scrollLeft = r.scrollLeft);
+    return h("div", { class: "split" }, l, r);
+  }
+
+  // src/ui/views/commits.ts
+  init_dom();
+  async function renderCommits(root) {
+    const el = h("div", { class: "commits" }, h("div", { class: "muted" }, "Loading\u2026"));
+    root.appendChild(el);
+    const commits = await api.commits(state.id);
+    el.innerHTML = "";
+    const r = state.data.review;
+    el.appendChild(
+      h(
+        "p",
+        { class: "muted" },
+        `${commits.length} commit${commits.length === 1 ? "" : "s"} from `,
+        h("code", null, r.pins.base.slice(0, 12)),
+        " to ",
+        h("code", null, r.pins.head.slice(0, 12))
+      )
+    );
+    if (!commits.length)
+      el.appendChild(h("div", { class: "empty-state" }, "No commits between base and head."));
+    for (const c of commits) {
+      el.appendChild(
+        h(
+          "div",
+          { class: "commit" },
+          h(
+            "div",
+            null,
+            h("span", { class: "subject" }, c.subject),
+            " ",
+            h("code", null, c.shortSha),
+            " ",
+            h("span", { class: "muted" }, `${c.author} \xB7 ${new Date(c.date).toLocaleString()}`)
+          ),
+          c.body ? h("pre", null, c.body) : null,
+          h(
+            "div",
+            { class: "files" },
+            c.files.map((f) => h("span", { onclick: () => navigate("files", { path: f }) }, f))
+          )
+        )
+      );
+    }
+  }
+
+  // src/ui/views/map.ts
+  init_dom();
+  function renderMap(root) {
+    const map = state.data?.map;
+    if (!map) {
+      root.appendChild(
+        h(
+          "div",
+          { class: "empty-state" },
+          "No software map in this revision. The agent authors ",
+          h("code", null, "map.yaml"),
+          " and publishes again."
+        )
+      );
+      return;
+    }
+    const headNodes = new Map(map.head.nodes.map((n) => [n.id, n]));
+    const baseNodes = new Map((map.base?.nodes ?? []).map((n) => [n.id, n]));
+    const all = /* @__PURE__ */ new Map();
+    for (const n of map.head.nodes)
+      all.set(n.id, {
+        ...n,
+        status: map.diff.added.includes(n.id) ? "added" : map.diff.changed.includes(n.id) ? "changed" : ""
+      });
+    for (const id of map.diff.removed) {
+      const n = baseNodes.get(id);
+      if (n) all.set(id, { ...n, status: "removed" });
+    }
+    const edges = [...map.head.edges];
+    for (const e of map.base?.edges ?? [])
+      if (!edges.some((x) => x.from === e.from && x.to === e.to)) edges.push(e);
+    const selected = state.params.get("node") ?? "";
+    const parentOf = (id) => id.includes(".") ? id.slice(0, id.lastIndexOf(".")) : "";
+    let level = selected && all.has(selected) ? childrenOf(selected).length ? selected : parentOf(selected) : "";
+    function childrenOf(p) {
+      return [...all.values()].filter((n) => parentOf(n.id) === p);
+    }
+    function descendantsChanged(id) {
+      return [...all.values()].filter((n) => n.id.startsWith(id + ".") && n.status).length;
+    }
+    const canvas = h("div", { class: "map-canvas" });
+    const side2 = h("div", { class: "map-side" });
+    root.appendChild(h("div", { class: "map-layout" }, canvas, side2));
+    const draw = () => {
+      canvas.innerHTML = "";
+      const crumbs = h("div", { class: "crumbs" });
+      const parts = level ? level.split(".") : [];
+      crumbs.appendChild(
+        h(
+          "span",
+          {
+            onclick: () => {
+              level = "";
+              draw();
+            }
+          },
+          "System"
+        )
+      );
+      parts.forEach((_, i) => {
+        const id = parts.slice(0, i + 1).join(".");
+        crumbs.appendChild(document.createTextNode(" \u203A "));
+        crumbs.appendChild(
+          h(
+            "span",
+            {
+              onclick: () => {
+                level = id;
+                draw();
+              }
+            },
+            all.get(id)?.label ?? id
+          )
+        );
+      });
+      canvas.appendChild(crumbs);
+      const kids = childrenOf(level);
+      const legend = h(
+        "div",
+        { class: "muted", style: { fontSize: "12px", marginBottom: "10px" } },
+        h("span", { class: "badge ok" }, `${map.diff.added.length} added`),
+        " ",
+        h("span", { class: "badge del" }, `${map.diff.removed.length} removed`),
+        " ",
+        h("span", { class: "badge warn" }, `${map.diff.changed.length} changed`),
+        map.base ? "" : "  (no base map: changed = touched by the diff)"
+      );
+      canvas.appendChild(legend);
+      const grid = h("div", { class: "map-grid" });
+      for (const n of kids) {
+        const nk = childrenOf(n.id).length;
+        const files = map.filesByNode[n.id]?.length ?? 0;
+        grid.appendChild(
+          h(
+            "div",
+            {
+              class: `map-node ${n.status} ${n.id === selected ? "selected" : ""}`,
+              onclick: () => {
+                navigate("map", { node: n.id });
+              },
+              ondblclick: () => {
+                if (nk) {
+                  level = n.id;
+                  draw();
+                }
+              }
+            },
+            n.status ? h(
+              "span",
+              {
+                class: `status badge ${n.status === "added" ? "ok" : n.status === "removed" ? "del" : "warn"}`
+              },
+              n.status
+            ) : null,
+            h("div", { class: "kind" }, n.kind),
+            h("div", { class: "label" }, n.label),
+            n.description ? h("div", { class: "desc" }, n.description) : null,
+            h(
+              "div",
+              { class: "children" },
+              nk ? `${nk} inside \xB7 dbl-click to open` : "",
+              nk && descendantsChanged(n.id) ? ` \xB7 ${descendantsChanged(n.id)} changed` : "",
+              files ? ` \xB7 ${files} changed file${files > 1 ? "s" : ""}` : ""
+            )
+          )
+        );
+      }
+      if (!kids.length)
+        grid.appendChild(h("div", { class: "empty-state" }, "Nothing at this level."));
+      canvas.appendChild(grid);
+      const here = new Set(kids.map((k) => k.id));
+      const top = (id) => {
+        let x = id;
+        while (x && !here.has(x)) x = parentOf(x);
+        return x;
+      };
+      const shown = edges.filter((e) => here.has(top(e.from)) || here.has(top(e.to)));
+      if (shown.length) {
+        canvas.appendChild(
+          h(
+            "div",
+            { class: "map-edges" },
+            h("div", { class: "muted", style: { marginBottom: "4px" } }, "Relationships"),
+            shown.map(
+              (e) => h(
+                "div",
+                { class: "edge" },
+                h(
+                  "b",
+                  { onclick: () => navigate("map", { node: e.from }) },
+                  all.get(e.from)?.label ?? e.from
+                ),
+                "\u2192",
+                h(
+                  "b",
+                  { onclick: () => navigate("map", { node: e.to }) },
+                  all.get(e.to)?.label ?? e.to
+                ),
+                h("span", { class: "muted" }, e.label ?? "")
+              )
+            )
+          )
+        );
+      }
+      drawSide();
+    };
+    const drawSide = () => {
+      side2.innerHTML = "";
+      const n = selected ? all.get(selected) : null;
+      if (!n) {
+        side2.appendChild(
+          h(
+            "div",
+            { class: "muted" },
+            "Select a node to see its files, code and relationships. Double-click to drill in."
+          )
+        );
+        return;
+      }
+      const anchor = n.anchor ? state.data?.document?.anchors[n.anchor] : null;
+      const files = map.filesByNode[n.id] ?? [];
+      const threads = threadsFor((t) => t.type === "map" && t.node === n.id);
+      append(side2, [
+        h(
+          "div",
+          { class: "kind muted", style: { fontSize: "11px", textTransform: "uppercase" } },
+          n.kind,
+          " ",
+          n.status ? h(
+            "span",
+            {
+              class: `badge ${n.status === "added" ? "ok" : n.status === "removed" ? "del" : "warn"}`
+            },
+            n.status
+          ) : ""
+        ),
+        h("h3", { style: { margin: "2px 0 6px" } }, n.label),
+        h("div", { class: "mono muted", style: { fontSize: "11px" } }, n.id),
+        n.description ? h("p", null, n.description) : null,
+        anchor?.peek ? h(
+          "p",
+          null,
+          h("button", { class: "small", onclick: () => openAnchorPeek(anchor) }, "Peek code \u25B8"),
+          " ",
+          h("span", { class: "mono muted" }, `${anchor.peek.file}:${anchor.peek.from}`)
+        ) : null,
+        n.files?.length ? h(
+          "div",
+          { class: "muted", style: { marginTop: "8px" } },
+          "Owns: ",
+          n.files.map((g) => h("code", null, g + " "))
+        ) : null,
+        files.length ? h(
+          "div",
+          { style: { marginTop: "8px" } },
+          h("b", null, "Changed files"),
+          files.map(
+            (f) => h("span", { class: "file", onclick: () => navigate("files", { path: f }) }, f)
+          )
+        ) : null,
+        h(
+          "div",
+          { style: { marginTop: "12px" } },
+          h(
+            "button",
+            {
+              class: "small",
+              onclick: (e) => popover(commentPopover({ type: "map", node: n.id }), { x: e.pageX, y: e.pageY + 8 })
+            },
+            "Comment on this node"
+          )
+        ),
+        threads.length ? h(
+          "div",
+          { class: "thread-pins", style: { marginTop: "10px" } },
+          threads.map(threadPinRow)
+        ) : null
+      ]);
+      if (n.status === "changed" && baseNodes.has(n.id) && headNodes.has(n.id)) {
+        const b = baseNodes.get(n.id);
+        const hh = headNodes.get(n.id);
+        const diffs = [];
+        if (b.label !== hh.label) diffs.push(`label: ${b.label} \u2192 ${hh.label}`);
+        if (b.description !== hh.description) diffs.push(`description changed`);
+        if (JSON.stringify(b.files) !== JSON.stringify(hh.files))
+          diffs.push(`files: ${(b.files ?? []).join(", ")} \u2192 ${(hh.files ?? []).join(", ")}`);
+        if (diffs.length)
+          side2.appendChild(
+            h(
+              "div",
+              { style: { marginTop: "10px" } },
+              h("b", null, "Base \u2192 head"),
+              diffs.map((d) => h("div", { class: "muted" }, d))
+            )
+          );
+      }
+    };
+    draw();
+  }
+
+  // src/ui/app.ts
+  var app = document.getElementById("app");
+  async function home() {
+    clear(app);
+    const reviews = await api.reviews();
+    const el = h("div", { class: "home" }, h("h2", null, "Reviews"));
+    const active = reviews.filter((r) => !r.dismissed);
+    const dismissed = reviews.filter((r) => r.dismissed);
+    const item = (r) => h(
+      "div",
+      { class: "item", onclick: () => location.href = `/review/${r.id}` },
+      h("span", { class: "t" }, r.title),
+      h("span", { class: `badge ${statusClass(r.status)}` }, r.status),
+      r.openThreads ? h("span", { class: "badge accent" }, `${r.openThreads} open`) : null,
+      h(
+        "span",
+        { class: "muted mono", style: { fontSize: "12px" } },
+        r.binding.kind === "pr" ? `PR #${r.binding.name}` : r.binding.name
+      ),
+      h("span", { class: "muted", style: { fontSize: "12px" } }, timeAgo(r.updatedAt))
+    );
+    if (!active.length)
+      el.appendChild(
+        h("div", { class: "empty-state" }, "No reviews. Ask your agent to scaffold and publish one.")
+      );
+    active.forEach((r) => el.appendChild(item(r)));
+    if (dismissed.length) {
+      el.appendChild(h("h3", { class: "muted" }, "Dismissed"));
+      dismissed.forEach((r) => el.appendChild(item(r)));
+    }
+    app.appendChild(el);
+  }
+  function statusClass(s) {
+    return s === "accepted" ? "ok" : s === "awaiting-agent-updates" ? "warn" : s === "rejected" ? "del" : s === "awaiting-review" ? "accent" : "";
+  }
+  var center;
+  var side;
+  var topbar;
+  var banner;
+  function shell() {
+    clear(app);
+    topbar = h("div", { class: "topbar" });
+    banner = h("div", { class: "banner", hidden: true });
+    center = h("div", { class: "center" });
+    side = h("div", { class: "side hidden" });
+    const resizer = h("div", { class: "resizer" });
+    let drag = false;
+    resizer.addEventListener("mousedown", () => drag = true);
+    window.addEventListener("mouseup", () => drag = false);
+    window.addEventListener("mousemove", (e) => {
+      if (!drag) return;
+      const w = Math.max(320, window.innerWidth - e.clientX);
+      document.documentElement.style.setProperty("--side-w", `${w}px`);
+    });
+    app.append(topbar, banner, h("div", { class: "main" }, center, resizer, side));
+  }
+  function applyTheme() {
+    let style = document.getElementById("review-theme");
+    if (!style) {
+      style = document.createElement("style");
+      style.id = "review-theme";
+      document.head.appendChild(style);
+    }
+    style.textContent = state.data?.theme?.css ?? "";
+  }
+  function renderTopbar() {
+    clear(topbar);
+    const d = state.data;
+    const r = d.review;
+    const pending = d.threads.filter((t) => !t.submitted).length;
+    const open = d.threads.filter((t) => t.status === "open").length;
+    const tabs = [
+      ["review", "Review"],
+      ["commits", "Commits"],
+      ["files", `Files${d.changes.length ? ` (${d.changes.length})` : ""}`],
+      ["map", "Map"]
+    ];
+    const revSel = h("select", {
+      class: "small",
+      style: { font: "inherit", fontSize: "12px" },
+      onchange: async (e) => {
+        const n = Number(e.target.value);
+        state.viewingRevision = n === r.revision ? null : n;
+        state.data = await api.review(state.id, n);
+        emit("data");
+      }
+    });
+    for (let n = r.revision; n >= 1; n--)
+      revSel.appendChild(
+        h(
+          "option",
+          { value: n, selected: (state.viewingRevision ?? r.revision) === n },
+          `rev ${n}${n === r.revision ? " (current)" : ""}`
+        )
+      );
+    append(topbar, [
+      h("a", { href: "/", class: "brand", title: "All reviews" }, "thurview"),
+      h("span", { class: "title" }, r.title),
+      h("span", { class: `badge ${statusClass(r.status)}` }, r.status),
+      r.revision > 1 ? revSel : h("span", { class: "badge" }, `rev ${r.revision}`),
+      h(
+        "span",
+        {
+          class: "muted mono",
+          style: { fontSize: "12px" },
+          title: `${r.pins.base} \u2192 ${r.pins.head}`
+        },
+        r.binding.kind === "pr" ? `PR #${r.binding.name}` : r.binding.name
+      ),
+      h(
+        "div",
+        { class: "tabs" },
+        tabs.map(
+          ([v, label]) => h("button", { class: v === state.view ? "active" : "", onclick: () => navigate(v) }, label)
+        )
+      ),
+      h("span", { class: "spacer" }),
+      h(
+        "button",
+        {
+          class: state.side.kind === "threads" ? "primary" : "",
+          onclick: () => {
+            state.side = state.side.kind === "threads" ? { kind: "none" } : { kind: "threads" };
+            emit("side");
+          }
+        },
+        `Threads${open ? ` \xB7 ${open}` : ""}`
+      ),
+      isTerminal() || state.viewingRevision !== null ? null : h(
+        "button",
+        { class: pending ? "primary" : "ok", onclick: () => submitDialog() },
+        pending ? `Submit review (${pending})` : "Approve / Request changes"
+      ),
+      h("button", { class: "ghost", title: "More", onclick: (e) => moreMenu(e) }, "\u22EF")
+    ]);
+  }
+  function moreMenu(e) {
+    const r = state.data.review;
+    const box = h(
+      "div",
+      { class: "def-popover" },
+      h(
+        "div",
+        {
+          class: "item",
+          onclick: async () => {
+            await api.dismiss(state.id, !r.dismissed);
+            await reload();
+            emit("data");
+          }
+        },
+        r.dismissed ? "Restore review" : "Dismiss review"
+      ),
+      h(
+        "div",
+        {
+          class: "item",
+          onclick: () => {
+            const d = dialog(
+              h(
+                "div",
+                null,
+                h("h3", null, "Delete this review?"),
+                h(
+                  "p",
+                  { class: "muted" },
+                  "Removes the document, revisions and threads. The code is untouched."
+                ),
+                h(
+                  "div",
+                  { class: "row" },
+                  h("button", { class: "ghost", onclick: () => d.close() }, "Cancel"),
+                  h(
+                    "button",
+                    {
+                      style: { background: "var(--del)", color: "#fff" },
+                      onclick: async () => {
+                        await api.remove(state.id);
+                        location.href = "/";
+                      }
+                    },
+                    "Delete"
+                  )
+                )
+              )
+            );
+          }
+        },
+        "Delete review"
+      ),
+      h(
+        "div",
+        { class: "item muted" },
+        `base ${r.pins.base.slice(0, 12)} \xB7 head ${r.pins.head.slice(0, 12)}`
+      ),
+      h(
+        "div",
+        { class: "item muted" },
+        `theme: ${state.data.theme?.name ?? "default"}${state.data.theme?.source ? ` (${state.data.theme.source})` : ""}`
+      )
+    );
+    Promise.resolve().then(() => (init_dom(), dom_exports)).then(({ popover: popover2 }) => popover2(box, { x: e.pageX - 200, y: e.pageY + 10 }));
+  }
+  function renderCenter() {
+    const scroll = center.scrollTop;
+    clear(center);
+    switch (state.view) {
+      case "review":
+        renderReview(center);
+        break;
+      case "files":
+        renderFiles(center);
+        break;
+      case "commits":
+        void renderCommits(center);
+        break;
+      case "map":
+        renderMap(center);
+        break;
+    }
+    center.scrollTop = scroll;
+  }
+  function renderSide() {
+    clear(side);
+    side.classList.toggle("hidden", state.side.kind === "none");
+    if (state.side.kind === "peek") renderPeek(side);
+    else if (state.side.kind === "threads") renderThreadsPanel(side);
+  }
+  function renderBanner() {
+    banner.hidden = true;
+    clear(banner);
+    const d = state.data;
+    if (state.viewingRevision !== null) {
+      banner.hidden = false;
+      banner.append(
+        `Viewing revision ${state.viewingRevision} of ${d.review.revision}. Read only.`,
+        h("span", { style: { flex: "1" } }),
+        h(
+          "button",
+          {
+            class: "small",
+            onclick: async () => {
+              state.viewingRevision = null;
+              state.data = await api.review(state.id);
+              emit("data");
+            }
+          },
+          "Back to current"
+        )
+      );
+    } else if (state.latestRevision !== null && state.latestRevision > d.review.revision) {
+      banner.hidden = false;
+      banner.append(
+        `Revision ${state.latestRevision} was published.`,
+        h("span", { style: { flex: "1" } }),
+        h(
+          "button",
+          {
+            class: "small primary",
+            onclick: async () => {
+              state.latestRevision = null;
+              state.data = await api.review(state.id);
+              emit("data");
+            }
+          },
+          "Load it"
+        )
+      );
+    } else if (d.review.status === "awaiting-agent-updates") {
+      banner.hidden = false;
+      banner.append(
+        "Changes requested. The agent is working on your comments; a new revision will appear here."
+      );
+    } else if (d.review.status === "accepted") {
+      banner.hidden = false;
+      banner.append("Approved. This review is complete.");
+    }
+  }
+  function connectEvents() {
+    const es = new EventSource(`/api/reviews/${state.id}/events`);
+    es.onmessage = async (ev) => {
+      const msg = JSON.parse(ev.data);
+      if (msg.type !== "change") return;
+      const fresh = await api.review(state.id, state.viewingRevision ?? void 0);
+      const cur = state.data;
+      if (fresh.review.revision > cur.review.revision && state.viewingRevision === null) {
+        state.latestRevision = fresh.review.revision;
+        state.data = {
+          ...cur,
+          threads: fresh.threads,
+          decisions: fresh.decisions,
+          review: { ...fresh.review, revision: cur.review.revision }
+        };
+      } else {
+        state.data = fresh;
+      }
+      emit("threads");
+    };
+  }
+  async function reviewPage(id) {
+    state.id = id;
+    shell();
+    readHash();
+    try {
+      state.data = await api.review(id);
+    } catch (e) {
+      clear(app);
+      app.appendChild(
+        h(
+          "div",
+          { class: "empty-state" },
+          e.message,
+          " ",
+          h("a", { href: "/" }, "All reviews")
+        )
+      );
+      return;
+    }
+    document.title = `${state.data.review.title} \xB7 thurview`;
+    if (state.params.get("side") === "threads") state.side = { kind: "threads" };
+    on("data", () => {
+      applyTheme();
+      renderTopbar();
+      renderBanner();
+      renderCenter();
+      renderSide();
+    });
+    on("threads", () => {
+      renderTopbar();
+      renderBanner();
+      renderCenter();
+      renderSide();
+    });
+    on("view", () => {
+      renderTopbar();
+      renderCenter();
+    });
+    on("side", () => {
+      renderTopbar();
+      renderSide();
+    });
+    window.addEventListener("hashchange", () => {
+      readHash();
+      emit("view");
+    });
+    emit("data");
+    connectEvents();
+  }
+  var m = /^\/review\/([^/]+)/.exec(location.pathname);
+  if (m) void reviewPage(m[1]);
+  else void home();
+})();
+//# sourceMappingURL=app.js.map