@oharness/server 0.7.0 → 0.8.0

package/dist/page/client/artifacts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.js","sourceRoot":"","sources":["../../../src/page/client/artifacts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuvB/B,CAAC"}

package/dist/page/client/base.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The preamble: the token, the desktop flag, the phone query, the string
+ * table and the locale, the icon set, and the handles to the elements the
+ * rest of the script paints into.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export declare const BASE: string;

package/dist/page/client/base.js

@@ -0,0 +1,400 @@
+/**
+ * The preamble: the token, the desktop flag, the phone query, the string
+ * table and the locale, the icon set, and the handles to the elements the
+ * rest of the script paints into.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export const BASE = String.raw `
+const STRINGS = window.__STRINGS;
+/**
+ * The token, from the desktop bridge when there is one.
+ *
+ * The browser gets it in the query string because that is the only channel a
+ * bare URL has. The desktop shell hands it over through a preload instead: a
+ * token in the address bar lands in history, in the window title, and in every
+ * screenshot of a bug report.
+ */
+const token =
+  (window.oharness && window.oharness.token) ||
+  new URLSearchParams(location.search).get("token") ||
+  "";
+
+// Only the shell knows whether the window has a title bar of its own; in a
+// browser tab the reserved strip would be a gap with nothing in it.
+if (window.oharness && window.oharness.insetTitlebar) {
+  document.body.classList.add("inset-titlebar");
+}
+
+/** Whether this page is the desktop window rather than a browser tab. */
+const IS_DESKTOP = Boolean(window.oharness && window.oharness.desktop);
+
+/**
+ * Whether this page is inside the browser extension's side panel.
+ *
+ * The panel is about as wide as a phone, so the phone layout serves it; what
+ * it drops is the built-in browser, which beside the person's own browser
+ * would be a browser inside the browser. The server lets this page be framed
+ * by the extension and by nothing else.
+ */
+const IS_EMBED = new URLSearchParams(location.search).get("embed") === "sidepanel";
+if (IS_EMBED) document.documentElement.classList.add("embed");
+
+/**
+ * Tell the side panel around this page something. The frame's parent is the
+ * extension, the only origin allowed to embed this page; outside a panel this
+ * says nothing to anyone.
+ */
+function embedTell(message) {
+  if (!IS_EMBED || window.parent === window) return;
+  const parentOrigin = (location.ancestorOrigins && location.ancestorOrigins[0]) || "*";
+  window.parent.postMessage(message, parentOrigin);
+}
+
+/** Whether the page is laid out for a phone right now; the stylesheet's breakpoint. */
+const PHONE_QUERY = window.matchMedia("(max-width:760px)");
+const isPhone = () => PHONE_QUERY.matches;
+
+// --- language --------------------------------------------------------------
+
+/**
+ * An inline icon, built as SVG nodes.
+ *
+ * Unicode glyphs come from whichever font happens to carry them, so a row of
+ * them arrives at inconsistent weights and optical sizes. These share one
+ * viewBox and one stroke width with the icons in the markup.
+ */
+const ICON_PATHS = {
+  // A padlock: the shackle as a path, the body as a rect.
+  lock: ["M5.33 7.33V5.33a2.67 2.67 0 0 1 5.34 0v2"],
+  lockRects: [[3.33, 7.33, 9.34, 6.67, 1.6]],
+  // Same drawing as the Settings item in the nav, so the model picker's
+  // "manage" link and the place it leads to are recognisably one thing.
+  settings: ["M12.67 4.67h-6", "M9.33 11.33H3.33"],
+  settingsCircles: [[4.67, 4.67, 2], [11.33, 11.33, 2]],
+  // Shut and open, drawn on the same body so the swap reads as one folder
+  // moving rather than as two icons trading places: the back panel, the left
+  // edge and the bottom hold still, and only the front flap tips forward.
+  //
+  // Two things were wrong with the pair this replaces. It sat on a 1.33–14.67
+  // box while every icon beside it sits on 2–14, so the folder was the widest
+  // mark in the menu and read as the heaviest. And its tab was 1.8 units deep
+  // out of ten: under two pixels at the size this is actually drawn, which
+  // left a rounded rectangle with a nick in it rather than a folder.
+  folder: [
+    "M3.33 3h2.87a1.33 1.33 0 0 1 1.09.57l.85 1.22a1.33 1.33 0 0 0 1.09.57H12.67" +
+      "A1.33 1.33 0 0 1 14 6.7v4.97A1.33 1.33 0 0 1 12.67 13H3.33" +
+      "A1.33 1.33 0 0 1 2 11.67V4.33A1.33 1.33 0 0 1 3.33 3Z",
+  ],
+  folderOpen: [
+    "M4.4 10.3l.87-1.71a1.33 1.33 0 0 1 1.19-.72H12.8a1.33 1.33 0 0 1 1.2 1.6" +
+      "l-.8 2.7a1.33 1.33 0 0 1-1.42.83H3.33A1.33 1.33 0 0 1 2 11.67V4.33" +
+      "A1.33 1.33 0 0 1 3.33 3h2.87a1.33 1.33 0 0 1 1.09.57l.85 1.22" +
+      "a1.33 1.33 0 0 0 1.09.57H11.6a1.33 1.33 0 0 1 1.33 1.33v1.18",
+  ],
+  moreDots: [[3.2, 8], [8, 8], [12.8, 8]],
+  // The same chevron the composer's pickers draw, and pointing the same way:
+  // both menus open upward, and both mark themselves with a caret that reads as
+  // "there is a list here" rather than one that promises a direction.
+  caret: ["M4.5 6.5 8 10l3.5-3.5"],
+  // The account control can both open and close its menu, so it uses the
+  // familiar paired chevrons instead of borrowing a one-way dropdown caret.
+  chevronsVertical: ["M5.5 6.5 8 4l2.5 2.5", "M5.5 9.5 8 12l2.5-2.5"],
+  // The three themes, drawn the same way the site draws them so the two
+  // controls are recognisably the same control.
+  themeSystem: ["M6 13.4h4"],
+  themeLight: ["M8 1.4v1.4M8 13.2v1.4M1.4 8h1.4M13.2 8h1.4M3.4 3.4l1 1M11.6 11.6l1 1M12.6 3.4l-1 1M4.4 11.6l-1 1"],
+  themeDark: ["M13.2 9.6A5.6 5.6 0 0 1 6.4 2.8a5.6 5.6 0 1 0 6.8 6.8Z"],
+  themeSystemRects: [[1.8, 2.6, 12.4, 8.6, 1.6]],
+  themeLightCircles: [[8, 8, 3.1]],
+  // A page with its corner turned back, which is the one mark that reads as
+  // "file" at thirteen pixels without any lines of text inside it.
+  file: [
+    "M9.33 1.33H4a1.33 1.33 0 0 0-1.33 1.34v10.66A1.33 1.33 0 0 0 4 14.67h8" +
+      "a1.33 1.33 0 0 0 1.33-1.34V5.33Z",
+    "M9.33 1.33v4h4",
+  ],
+  // Two pins and a body: a connector is the thing something else plugs into.
+  plug: ["M6 1.33v3.34", "M10 1.33v3.34", "M4 4.67h8v3.33a4 4 0 0 1-8 0Z", "M8 12v2.67"],
+  // Stacked plates, because a plugin arrives as a bundle of contributions
+  // rather than as one thing.
+  plugin: ["M8 1.33 1.33 4.67 8 8l6.67-3.33Z", "M1.33 11.33 8 14.67l6.67-3.34", "M1.33 8 8 11.33 14.67 8"],
+  /* A bookmark: one path, and the only shape in this menu that is neither a
+     sheet nor a folder. The open book it replaced was two mirrored paths
+     meeting at a spine, which at the 13px these rows use closed into a blob —
+     two strokes a pixel apart read as one thick one. */
+  skill: ["M4.5 2.5h7v11l-3.5-2.6-3.5 2.6Z"],
+  /* A prompt caret: what a command line looks like anywhere else. */
+  command: ["M4 5.5 6.5 8 4 10.5", "M8.5 10.5H12"],
+  /* A bare chevron. The other back arrow has a shaft, which is right on a
+     page header and heavy on a menu row sitting one line above the thing it
+     returns to. */
+  chevronLeft: ["M9.5 4.5 6 8l3.5 3.5"],
+  /* Two strokes, for the corner of a dialog. */
+  close: ["M4.5 4.5l7 7", "M11.5 4.5l-7 7"],
+  /* Its counterpart, for adding one. */
+  plus: ["M8 3.5v9", "M3.5 8h9"],
+  search: ["M11.5 11.5 14 14"],
+  searchCircles: [[7.3, 7.3, 4.6]],
+  // A shopfront: an awning over a counter, for the list of what is on offer.
+  market: ["M2 6.67h12", "M3.33 6.67 4.67 2.67h6.66l1.34 4", "M2.67 6.67v6.66h10.67V6.67"],
+  // An arrow pointing back the way the menu came in.
+  back: ["M12.67 8H3.33", "M7.33 12 3.33 8l4-4"],
+  // An arrow leaving a tray, for the upload that still goes to this machine.
+  upload: ["M8 10.67V2", "M4.67 5.33 8 2l3.33 3.33", "M2 10.67v2A1.33 1.33 0 0 0 3.33 14h9.34A1.33 1.33 0 0 0 14 12.67v-2"],
+  // A trunk with a branch leaving it, which is what forking a turn does to the
+  // transcript: the arc lands on the new node rather than crossing it.
+  fork: ["M5 2.6v7.7", "M11 6a5.7 5.7 0 0 1-4.3 6"],
+  forkCircles: [[11, 4.3], [5, 12]],
+  copy: [
+    "M6.67 5.33h6.66a1.33 1.33 0 0 1 1.34 1.34v6.66a1.33 1.33 0 0 1-1.34 1.34" +
+      "H6.67a1.33 1.33 0 0 1-1.34-1.34V6.67a1.33 1.33 0 0 1 1.34-1.34Z",
+    "M2.67 10.67a1.33 1.33 0 0 1-1.34-1.34V2.67a1.33 1.33 0 0 1 1.34-1.34h6.66" +
+      "a1.33 1.33 0 0 1 1.34 1.34",
+  ],
+  // A pin seen from the side: head, shaft, and the point going into the page.
+  pin: [
+    "M9.5 2.5 13.5 6.5",
+    "M10.2 3.2 7.6 5a2.7 2.7 0 0 1-1.7.5l-1.6-.1a.6.6 0 0 0-.45 1.03l5.72 5.72a.6.6 0 0 0 1.03-.45l-.1-1.6A2.7 2.7 0 0 1 11 8.4l1.8-2.6",
+    "M6.2 9.8 2.8 13.2",
+  ],
+  // The product's own mark: two open arcs around a centre, the same glyph the
+  // application icon draws, at half its scale. Drawn rather than fetched,
+  // because the official plan's rows have to have a mark on a machine that
+  // has never reached the network.
+  oharness: ["M10 3H6a3 3 0 0 0-3 3v4", "M6 13h4a3 3 0 0 0 3-3V6"],
+  oharnessDots: [[8, 8]],
+  // A speech bubble with a tail: what a session is, before it has a title.
+  chat: [
+    "M14 10a1.33 1.33 0 0 1-1.33 1.33H4.67L2 14V3.33A1.33 1.33 0 0 1 3.33 2h9.34" +
+      "A1.33 1.33 0 0 1 14 3.33Z",
+  ],
+  // The five permission modes. Five short words in a column look alike until
+  // they are read; a glyph in front of each lets the one in use be found by
+  // shape from the bar, the way the vendor mark does for the model.
+  //
+  // Manual is by hand, and a raised palm is also the sign for "wait": three
+  // fingers, a thumb, and the heel of the hand in one sweep. Four fingers
+  // would be the honest count, but at fifteen pixels the fourth turns the
+  // top edge into a comb.
+  modeAsk: [
+    "M12 7.4V4a1.33 1.33 0 0 0-2.67 0",
+    "M9.33 6.7V2.7a1.33 1.33 0 0 0-2.66 0v1.3",
+    "M6.67 7V4A1.33 1.33 0 0 0 4 4v5.33",
+    "M12 5.33a1.33 1.33 0 1 1 2.67 0v4a5.33 5.33 0 0 1-5.34 5.34H8" +
+      "c-1.87 0-3-.58-4-1.56l-2.4-2.4a1.33 1.33 0 0 1 1.89-1.89L4.67 10",
+  ],
+  // Accept edits lets the pencil through.
+  modeEdits: ["M11.3 2.7 13.3 4.7 5.3 12.7H3.3v-2Z", "M9.8 4.2l2 2"],
+  // Plan is read-only: an eye, which looks and does not touch.
+  modePlan: ["M1.6 8s2.4-4.4 6.4-4.4S14.4 8 14.4 8s-2.4 4.4-6.4 4.4S1.6 8 1.6 8Z"],
+  modePlanCircles: [[8, 8, 2.1]],
+  // Auto waves the routine through: a bolt.
+  modeAuto: ["M8.8 1.6 3.6 9h4l-.7 5.4L12.4 7h-4Z"],
+  // Bypass leaves the gate open: a padlock with its shackle swung clear.
+  modeBypass: ["M5.4 7.4V5.2a2.6 2.6 0 0 1 5-1"],
+  modeBypassRects: [[3.2, 7.4, 9.6, 6.2, 1.6]],
+  // The date picker's trigger and its month arrows. The same marks the site's
+  // picker draws, because it is the same control.
+  calendar: ["M2 6.5h12M5.5 1.5v3M10.5 1.5v3"],
+  calendarRects: [[2, 3, 12, 11, 2.5]],
+  chevronLeft: ["M10 3.5 5.5 8l4.5 4.5"],
+  chevronRight: ["M6 3.5 10.5 8 6 12.5"],
+};
+
+function svgIcon(name, extra) {
+  const NS = "http://www.w3.org/2000/svg";
+  const svg = document.createElementNS(NS, "svg");
+  svg.setAttribute("viewBox", "0 0 16 16");
+  svg.setAttribute("fill", "none");
+  svg.setAttribute("stroke", "currentColor");
+  svg.setAttribute("stroke-width", "1.5");
+  svg.setAttribute("stroke-linecap", "round");
+  svg.setAttribute("stroke-linejoin", "round");
+  svg.setAttribute("class", "ico-sm" + (extra ? " " + extra : ""));
+  for (const d of ICON_PATHS[name] || []) {
+    const path = document.createElementNS(NS, "path");
+    path.setAttribute("d", d);
+    svg.appendChild(path);
+  }
+  // The radius is per-circle because the icons it serves disagree: a fork's
+  // node is a dot, a settings knob is a ring you look through.
+  for (const [x, y, w, h, rx] of ICON_PATHS[name + "Rects"] || []) {
+    const rect = document.createElementNS(NS, "rect");
+    rect.setAttribute("x", String(x));
+    rect.setAttribute("y", String(y));
+    rect.setAttribute("width", String(w));
+    rect.setAttribute("height", String(h));
+    rect.setAttribute("rx", String(rx ?? 1.6));
+    svg.appendChild(rect);
+  }
+  for (const [cx, cy, r] of ICON_PATHS[name + "Circles"] || []) {
+    const circle = document.createElementNS(NS, "circle");
+    circle.setAttribute("cx", String(cx));
+    circle.setAttribute("cy", String(cy));
+    circle.setAttribute("r", String(r ?? 1.7));
+    svg.appendChild(circle);
+  }
+  // Solid, not stroked: a ring that small reads as a smudge, and three of them
+  // in a row read as a chain rather than an ellipsis.
+  for (const [cx, cy] of ICON_PATHS[name + "Dots"] || []) {
+    const dot = document.createElementNS(NS, "circle");
+    dot.setAttribute("cx", String(cx));
+    dot.setAttribute("cy", String(cy));
+    dot.setAttribute("r", "1.35");
+    dot.setAttribute("fill", "currentColor");
+    dot.setAttribute("stroke", "none");
+    svg.appendChild(dot);
+  }
+  return svg;
+}
+
+const LOCALE = (() => {
+  const asked = new URLSearchParams(location.search).get("lang");
+  if (asked && STRINGS[asked]) return asked;
+  // The browser's list, most preferred first; the base language is enough to
+  // match, so zh-Hans-CN finds zh.
+  for (const tag of navigator.languages || [navigator.language || "en"]) {
+    const base = String(tag).toLowerCase().split("-")[0];
+    if (STRINGS[base]) return base;
+  }
+  return "en";
+})();
+
+/**
+ * A translated string.
+ *
+ * Falls back to English rather than to the key: a missing translation should
+ * still read as a sentence. Placeholders are named so a translation can move
+ * them, which positional ones cannot survive.
+ */
+function t(key, vars) {
+  const text = (STRINGS[LOCALE] && STRINGS[LOCALE][key]) || STRINGS.en[key] || key;
+  if (!vars) return text;
+  return text.replace(/\{([a-z]+)\}/g, (whole, name) =>
+    vars[name] === undefined ? whole : String(vars[name]),
+  );
+}
+/**
+ * The same string, in the shell that is reading it.
+ *
+ * This page is both a desktop window and a tab in someone's browser, and a
+ * few lines can only be true in one of them — "no browser on this machine"
+ * is nonsense read inside a browser, and the sign-in column called itself an
+ * app to a reader looking at a web page. The browser wording lives under the
+ * same key with .web on the end; a key with no such sibling is shell-neutral
+ * and answers the same either way, which is nearly all of them.
+ */
+function ts(key, vars) {
+  const web = key + ".web";
+  const known = (STRINGS[LOCALE] && STRINGS[LOCALE][web]) || STRINGS.en[web];
+  return t(!IS_DESKTOP && known ? web : key, vars);
+}
+/*
+ * A path that already carries a query needs an ampersand, not a second "?".
+ * With one, /history?session=<id>?token=<t> sent the token as part of the
+ * session id and the server answered 401 — so resuming a session showed the
+ * empty invitation instead of its transcript, on every request that passes a
+ * parameter of its own.
+ */
+const q = (path) =>
+  path + (path.includes("?") ? "&" : "?") + "token=" + encodeURIComponent(token);
+/**
+ * A GET that reports why it failed.
+ *
+ * The panels used to swallow errors into an empty object, which rendered as a
+ * page of em-dashes with no hint that anything had gone wrong — a 401 from a
+ * stale token looked exactly like a working directory that is somehow blank.
+ */
+async function getJson(path) {
+  try {
+    const response = await fetch(q(path), { signal: AbortSignal.timeout(20000) });
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      return { error: body.error || "HTTP " + response.status + " from " + path };
+    }
+    return body;
+  } catch (err) {
+    return { error: err.name === "TimeoutError" ? path + " timed out" : String(err.message || err) };
+  }
+}
+
+/** A banner for a panel that could not load, in place of blank fields. */
+/**
+ * A memory error in this page's language. The engine sends a code and its
+ * values with the English message; the page says it in its own words when it
+ * has them, and passes the message through when it does not.
+ */
+function memoryText(failure) {
+  const key = failure && failure.code ? "memory.err." + failure.code : "";
+  if (key && (STRINGS.en[key] || (STRINGS[LOCALE] && STRINGS[LOCALE][key]))) return t(key, failure.params || {});
+  return (failure && failure.message) || t("memory.failed");
+}
+
+/** Stands in while a panel fetches, so a click never lands on a blank page. */
+function panelLoading() {
+  const panel = el("div", "panel panel-loading");
+  panel.appendChild(el("span", "spinner"));
+  panel.appendChild(el("span", "working-label", t("market.loading")));
+  return panel;
+}
+
+function panelError(message) {
+  const panel = el("div", "panel");
+  const box = el("div", "row-card");
+  box.appendChild(el("div", "row-title", t("error.title")));
+  box.appendChild(el("div", "muted small", message));
+  box.appendChild(el("div", "muted small", t("error.stale")));
+  panel.appendChild(box);
+  return panel;
+}
+
+const api = (path, body, timeoutMs) =>
+  fetch(q(path), {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body || {}),
+    // Every button that flips to a busy label needs the promise to settle, or
+    // it stays busy forever when the server does not answer.
+    signal: AbortSignal.timeout(timeoutMs || 30000),
+  })
+    .then((r) => r.json().catch(() => ({})))
+    .catch((err) => ({ error: err.name === "TimeoutError" ? "timed out" : String(err.message || err) }));
+
+/**
+ * Record that a feature was used. Does nothing unless analytics are on.
+ *
+ * window.__TRACK exists only when the server was started with a PostHog key —
+ * see analytics.ts — so the calls below read the same either way and nobody
+ * has to remember which branch they are writing in.
+ *
+ * There is deliberately no way to send text through here: every caller passes
+ * an event name and a handful of enumerable properties — which panel, whether
+ * a permission was allowed, which model — and never anything the user typed.
+ */
+function track(event, props) {
+  if (window.__TRACK) window.__TRACK(event, props);
+}
+
+const log = document.getElementById("log");
+const panelView = document.getElementById("panel-view");
+const panelBody = document.getElementById("panel-body");
+const panelNotes = document.getElementById("panel-notes");
+const input = document.getElementById("input");
+const sendBtn = document.getElementById("send");
+const stopBtn = document.getElementById("stop");
+const jumpBtn = document.getElementById("jump");
+const metaEl = document.getElementById("cost");
+const tokensEl = document.getElementById("tokens");
+const cacheEl = document.getElementById("cache");
+const ctxBar = document.querySelector("#ctx i");
+const ctxText = document.getElementById("ctxtext");
+const sessionList = document.getElementById("sessions");
+const sidebarEl = document.querySelector("body > aside");
+const ask = document.getElementById("ask");
+
+let pendingId = null;
+let atBottom = true;
+
+`;
+//# sourceMappingURL=base.js.map

package/dist/page/client/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../src/page/client/base.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuY7B,CAAC"}

package/dist/page/client/browser.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The browser pane: what the agent's browser is looking at, live, and a way to
+ * take the mouse off it.
+ *
+ * A column beside the transcript, not a panel over it. Watching what the model
+ * does is only useful next to what it is saying, and the layout already had the
+ * shape for that — the diff pane is a sibling of the main column and slides in
+ * the same way, so this is built the same way rather than inventing a second
+ * kind of side surface.
+ *
+ * The picture is an img pointed at an MJPEG stream, so the browser decodes the
+ * frames and this file never touches one. The element is created once and kept:
+ * the pane closes by collapsing to zero width, which leaves the stream running
+ * rather than tearing it down and reconnecting on the next toggle.
+ *
+ * Taking over sends the same input events the tools send, through the same
+ * call, so a person and the model reach the page identically.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export declare const BROWSER: string;