@withbuddi/buddi 0.1.0-pre.51 → 0.1.0-pre.53

package/extension/background.js

@@ -1,6 +1,670 @@
+// src/downloads.ts
+var DOWNLOAD_GRACE_MS = 15e3;
+var DOWNLOADS_PERMISSION = "downloads";
+function originOf(url) {
+  if (!url) return void 0;
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "blob:") return new URL(parsed.pathname).origin;
+    return parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed.origin : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function basename(file) {
+  return file.split(/[\\/]/).pop() || "download";
+}
+var AgentDownloads = class {
+  #actions = /* @__PURE__ */ new Map();
+  #next = 1;
+  #claimed = /* @__PURE__ */ new Map();
+  #api;
+  #send;
+  #now;
+  constructor(options) {
+    this.#send = options.send;
+    this.#now = options.now ?? (() => Date.now());
+  }
+  /** Chrome's downloads API, once the owner granted it. Listening starts here, once. */
+  attach(api) {
+    if (!api || this.#api) return;
+    this.#api = api;
+    api.onCreated.addListener((item) => this.created(item));
+    api.onChanged.addListener((delta) => {
+      void this.changed(delta).catch(() => void 0);
+    });
+  }
+  get attached() {
+    return this.#api !== void 0;
+  }
+  /** An agent command starts in this session, whose tabs are on these addresses. Returns the command's handle for `end`. */
+  begin(session, urls) {
+    this.#expire();
+    const id = this.#next++;
+    const origins = /* @__PURE__ */ new Set();
+    for (const url of urls) {
+      const origin = originOf(url);
+      if (origin) origins.add(origin);
+    }
+    this.#actions.set(id, { session, origins, running: true, until: 0, at: this.#now() });
+    return id;
+  }
+  /** That command ended; its tabs may have moved on to these. Its downloads still count for a few seconds, its own. */
+  end(id, urls = []) {
+    const action = this.#actions.get(id);
+    if (!action) return;
+    for (const url of urls) {
+      const origin = originOf(url);
+      if (origin) action.origins.add(origin);
+    }
+    action.running = false;
+    action.until = this.#now() + DOWNLOAD_GRACE_MS;
+  }
+  /** Commands whose few seconds are over count for nothing any more. */
+  #expire() {
+    const now = this.#now();
+    for (const [id, action] of this.#actions) if (!action.running && now > action.until) this.#actions.delete(id);
+  }
+  /** The session ended or the socket went: nothing more is its. */
+  forget(session) {
+    if (session === void 0) {
+      this.#actions.clear();
+      this.#claimed.clear();
+      return;
+    }
+    for (const [id, action] of this.#actions) if (action.session === session) this.#actions.delete(id);
+    for (const [id, owner] of this.#claimed) if (owner === session) this.#claimed.delete(id);
+  }
+  /** Which session's command this download belongs to, if any. */
+  #owner(item) {
+    if (item.byExtensionId) return void 0;
+    const origin = originOf(item.referrer) ?? originOf(item.finalUrl ?? item.url);
+    if (!origin) return void 0;
+    this.#expire();
+    let best;
+    for (const action of this.#actions.values()) {
+      if (!action.origins.has(origin)) continue;
+      if (!best || action.at > best.at) best = action;
+    }
+    return best?.session;
+  }
+  created(item) {
+    const session = this.#owner(item);
+    if (session) this.#claimed.set(item.id, session);
+  }
+  async changed(delta) {
+    const session = this.#claimed.get(delta.id);
+    const state = delta.state?.current;
+    if (!session || !state) return;
+    if (state === "interrupted") {
+      this.#claimed.delete(delta.id);
+      return;
+    }
+    if (state !== "complete") return;
+    this.#claimed.delete(delta.id);
+    const [item] = await (this.#api?.search({ id: delta.id }) ?? Promise.resolve([]));
+    if (!item?.filename) return;
+    const url = item.finalUrl || item.url || "";
+    const size = item.fileSize !== void 0 && item.fileSize >= 0 ? item.fileSize : item.totalBytes !== void 0 && item.totalBytes >= 0 ? item.totalBytes : void 0;
+    this.#send({
+      type: "download",
+      session,
+      path: item.filename,
+      filename: basename(item.filename),
+      url,
+      ...item.mime ? { mime: item.mime } : {},
+      ...size !== void 0 ? { size } : {}
+    });
+  }
+};
+
+// src/bar.ts
+var OWNER_WAIT_MS = 3e4;
+var BAR_AFTER_MS = 3e3;
+var BAR_POLL_MS = 500;
+async function waitForOwner(probes, limits = {}) {
+  const waitMs = limits.waitMs ?? OWNER_WAIT_MS;
+  const barAfter = limits.barAfterMs ?? BAR_AFTER_MS;
+  const poll = limits.pollMs ?? BAR_POLL_MS;
+  const start = probes.now();
+  let shown = false;
+  const maxPolls = Math.ceil(waitMs / poll);
+  try {
+    for (let polls = 0; ; polls++) {
+      if (!await probes.watched()) return "left";
+      const elapsed = Math.max(probes.now() - start, polls * poll);
+      if (!shown && elapsed >= barAfter) {
+        shown = true;
+        await probes.show().catch(() => void 0);
+      }
+      if (shown) {
+        const choice = await probes.choice().catch(() => void 0);
+        if (choice) return choice;
+      }
+      if (elapsed >= waitMs || polls >= maxPolls) return "timeout";
+      await probes.wait(poll);
+    }
+  } finally {
+    if (shown) await probes.hide().catch(() => void 0);
+  }
+}
+function showBar(agent) {
+  const holder = globalThis;
+  holder["__buddiBar"] = { choice: void 0 };
+  const doc = globalThis.document;
+  if (!doc || doc.getElementById("buddi-working-bar")) return;
+  const host = doc.createElement("div");
+  host.id = "buddi-working-bar";
+  host.setAttribute("style", "position:fixed;top:0;left:0;right:0;z-index:2147483647;all:initial;");
+  const root = host.attachShadow({ mode: "closed" });
+  const bar = doc.createElement("div");
+  bar.setAttribute("role", "status");
+  bar.setAttribute("style", "position:fixed;top:0;left:0;right:0;display:flex;gap:12px;align-items:center;justify-content:flex-end;padding:6px 16px;font:13px/1.4 system-ui,-apple-system,sans-serif;background:#1f2a44;color:#fff;box-shadow:0 1px 4px rgba(0,0,0,.25);");
+  const label = doc.createElement("span");
+  label.textContent = `${agent || "buddi"} is working here`;
+  label.setAttribute("style", "margin-right:auto;");
+  const button = (text2, choice, primary) => {
+    const b = doc.createElement("button");
+    b.type = "button";
+    b.textContent = text2;
+    b.setAttribute("style", `font:inherit;cursor:pointer;border-radius:6px;padding:3px 10px;border:1px solid #fff;${primary ? "background:#fff;color:#1f2a44;" : "background:transparent;color:#fff;"}`);
+    b.addEventListener("click", () => {
+      holder["__buddiBar"] = { choice };
+    });
+    return b;
+  };
+  bar.append(label, button("Take over", "takeover", false), button("Let it continue", "continue", true));
+  root.append(bar);
+  (doc.documentElement ?? doc.body).append(host);
+}
+function readBar() {
+  const holder = globalThis;
+  const choice = holder["__buddiBar"]?.choice;
+  if (choice) holder["__buddiBar"] = { choice: void 0 };
+  return choice;
+}
+function hideBar() {
+  const doc = globalThis.document;
+  doc?.getElementById("buddi-working-bar")?.remove();
+  const holder = globalThis;
+  delete holder["__buddiBar"];
+}
+var GIVE_BACK_MESSAGE = "buddi-give-back";
+function showHeldBar(session) {
+  const doc = globalThis.document;
+  if (!doc || doc.getElementById("buddi-held-bar")) return;
+  const host = doc.createElement("div");
+  host.id = "buddi-held-bar";
+  host.setAttribute("style", "position:fixed;top:0;left:0;right:0;z-index:2147483647;all:initial;");
+  const root = host.attachShadow({ mode: "closed" });
+  const bar = doc.createElement("div");
+  bar.setAttribute("role", "status");
+  bar.setAttribute("style", "position:fixed;top:0;left:0;right:0;display:flex;gap:12px;align-items:center;justify-content:flex-end;padding:6px 16px;font:13px/1.4 system-ui,-apple-system,sans-serif;background:#1f2a44;color:#fff;box-shadow:0 1px 4px rgba(0,0,0,.25);");
+  const label = doc.createElement("span");
+  label.textContent = "buddi is waiting";
+  label.setAttribute("style", "margin-right:auto;");
+  const give = doc.createElement("button");
+  give.type = "button";
+  give.textContent = "Give it back";
+  give.setAttribute("style", "font:inherit;cursor:pointer;border-radius:6px;padding:3px 10px;border:1px solid #fff;background:#fff;color:#1f2a44;");
+  give.addEventListener("click", () => {
+    const runtime = globalThis.chrome?.runtime;
+    void runtime?.sendMessage({ type: "buddi-give-back", session })?.catch?.(() => void 0);
+    host.remove();
+  });
+  bar.append(label, give);
+  root.append(bar);
+  (doc.documentElement ?? doc.body).append(host);
+  const asking = [];
+  const restore = () => {
+    for (const button of asking.splice(0)) button.remove();
+    label.textContent = "buddi is waiting";
+    give.style.display = "";
+  };
+  globalThis["__buddiHeldAsk"] = (question, choices) => {
+    restore();
+    label.textContent = question;
+    give.style.display = "none";
+    for (const choice of choices) {
+      const b = doc.createElement("button");
+      b.type = "button";
+      b.textContent = choice.label;
+      b.setAttribute("style", `font:inherit;cursor:pointer;border-radius:6px;padding:3px 10px;border:1px solid #fff;${choice.primary ? "background:#fff;color:#1f2a44;" : "background:transparent;color:#fff;"}`);
+      b.addEventListener("click", () => {
+        restore();
+        choice.pick();
+      });
+      asking.push(b);
+      bar.insertBefore(b, give);
+    }
+    return restore;
+  };
+}
+function hideHeldBar() {
+  const doc = globalThis.document;
+  doc?.getElementById("buddi-held-bar")?.remove();
+  delete globalThis["__buddiHeldAsk"];
+}
+var LOGIN_MESSAGE = "buddi-login";
+var LOGIN_PROMPT_MS = 2 * 6e4;
+function watchHeldLogins(session, facts) {
+  const holder = globalThis;
+  const known = { never: [...facts?.never ?? []], saved: [...facts?.saved ?? []] };
+  const existing = holder["__buddiHeldLogins"];
+  if (existing) {
+    existing.session = session;
+    existing.facts = known;
+    return;
+  }
+  const doc = globalThis.document;
+  if (!doc) return;
+  const state = { session, facts: known, last: "", lastAt: 0, typedAt: 0, cached: void 0, timer: void 0, drop: void 0 };
+  holder["__buddiHeldLogins"] = state;
+  const runtime = () => globalThis.chrome?.runtime;
+  const call = async (message) => {
+    try {
+      return await runtime()?.sendMessage(message);
+    } catch {
+      return void 0;
+    }
+  };
+  const site = () => (globalThis.location?.hostname ?? "").toLowerCase().replace(/^www\./, "");
+  const listed = (where) => state.facts.never.some((entry) => {
+    const bare = entry.toLowerCase().replace(/^www\./, "");
+    return where === bare || where.endsWith(`.${bare}`);
+  });
+  const bar = () => {
+    const question = holder["__buddiHeldAsk"];
+    return typeof question === "function" ? question : void 0;
+  };
+  const prompt = (where, update) => {
+    const question = bar();
+    if (!question) return;
+    if (state.drop) clearTimeout(state.drop);
+    let answered = false;
+    const save = () => {
+      if (answered) return;
+      answered = true;
+      const asking = bar();
+      asking?.(update ? "Updating\u2026" : "Saving\u2026", []);
+      void call({ type: "buddi-login", session: state.session, decision: "save" }).then((reply) => {
+        const answer = reply;
+        const now = bar();
+        if (!now) return;
+        if (answer?.saved === true) {
+          const restore2 = now(update ? `Updated the login for ${where}` : `Saved the login for ${where}`, []);
+          if (state.drop) clearTimeout(state.drop);
+          state.drop = setTimeout(restore2, 2e3);
+          return;
+        }
+        const reason = typeof answer?.reason === "string" && answer.reason !== "" ? answer.reason : "buddi did not answer. Try again.";
+        now(reason, [
+          { label: "Try again", primary: true, pick: () => {
+            answered = false;
+            save();
+          } },
+          { label: "Not now", pick: () => {
+            void call({ type: "buddi-login", session: state.session, decision: "later" });
+          } }
+        ]);
+      });
+    };
+    const restore = question(update ? `Update the login for ${where}?` : `Save this login for ${where}?`, [
+      { label: update ? "Update" : "Save", primary: true, pick: save },
+      { label: "Not now", pick: () => {
+        answered = true;
+        void call({ type: "buddi-login", session: state.session, decision: "later" });
+      } },
+      { label: "Never for this site", pick: () => {
+        answered = true;
+        state.facts.never.push(where);
+        void call({ type: "buddi-login", session: state.session, decision: "never" });
+      } }
+    ]);
+    state.drop = setTimeout(() => {
+      if (!answered) restore();
+    }, 2 * 6e4);
+  };
+  const ask = (found) => {
+    const where = site();
+    if (where === "" || listed(where) || !bar()) return;
+    const update = state.facts.saved.some((login) => login.site === where && login.username === found.username);
+    void call({ type: "buddi-login-seen", session: state.session, username: found.username, password: found.password, update }).then((reply) => {
+      const asked2 = reply;
+      if (holder["__buddiHeldLogins"] !== state || !asked2 || typeof asked2 !== "object") return;
+      prompt(where, asked2.update === true);
+    });
+  };
+  void call({ type: "buddi-login-pending", session: state.session }).then((reply) => {
+    const waiting = reply;
+    if (holder["__buddiHeldLogins"] !== state || !waiting || typeof waiting.site !== "string") return;
+    prompt(waiting.site, waiting.update === true);
+  });
+  const NOT_SUBMIT = /\b(show|hide|reveal|toggle|eye|forgot|reset|cancel|back|close|sign ?up|register|create)\b/i;
+  const USER = /user|email|login|account|ident|phone|mail/i;
+  const passwords = (root) => Array.from(root.querySelectorAll('input[type="password" i]'));
+  const usernameFor = (password) => {
+    const scope = password.form ?? doc;
+    const inputs = Array.from(scope.querySelectorAll("input")).filter((input) => ["text", "email", "tel", ""].includes((input.getAttribute("type") ?? "").toLowerCase()) && input.value.trim() !== "");
+    const marked = inputs.find((input) => (input.getAttribute("autocomplete") ?? "").toLowerCase().includes("username") || (input.getAttribute("type") ?? "").toLowerCase() === "email");
+    if (marked) return marked.value.trim();
+    const before = inputs.filter((input) => (input.compareDocumentPosition(password) & 4) !== 0);
+    const pick = before[before.length - 1] ?? inputs.find((input) => USER.test(`${input.name} ${input.id} ${input.getAttribute("autocomplete") ?? ""}`));
+    return pick ? pick.value.trim() : "";
+  };
+  const read = (scope) => {
+    const field = passwords(scope ?? doc).find((input) => input.value !== "");
+    return field ? { username: usernameFor(field), password: field.value } : void 0;
+  };
+  const send = (found) => {
+    if (holder["__buddiHeldLogins"] !== state) return;
+    if (!found || found.password === "") return;
+    const key = `${found.username}\0${found.password}`;
+    const now = Date.now();
+    if (key === state.last && now - state.lastAt < 5e3) return;
+    state.last = key;
+    state.lastAt = now;
+    state.cached = void 0;
+    ask(found);
+  };
+  doc.addEventListener("submit", (event) => {
+    send(read(event.target) ?? state.cached);
+  }, true);
+  doc.addEventListener("keydown", (event) => {
+    if (event.key !== "Enter") return;
+    const target = event.target;
+    if (!target || target.tagName !== "INPUT") return;
+    send(read(target.form ?? doc));
+  }, true);
+  doc.addEventListener("click", (event) => {
+    const target = event.target;
+    const button = target?.closest?.('button, input[type="submit" i], input[type="image" i], input[type="button" i], [role="button"]');
+    if (!button) return;
+    const words = `${button.textContent ?? ""} ${button.getAttribute("aria-label") ?? ""} ${button.getAttribute("value") ?? ""} ${button.getAttribute("title") ?? ""}`;
+    if (NOT_SUBMIT.test(words)) return;
+    send(read(button.form ?? doc));
+  }, true);
+  doc.addEventListener("input", (event) => {
+    const target = event.target;
+    if ((target?.getAttribute?.("type") ?? "").toLowerCase() !== "password") return;
+    state.typedAt = Date.now();
+    state.cached = read(target.form ?? doc);
+  }, true);
+  const Observer = globalThis.PerformanceObserver;
+  if (typeof Observer === "function") {
+    try {
+      new Observer((list) => {
+        if (!state.cached || Date.now() - state.typedAt > 1e4) return;
+        const fetched = list.getEntries().some((entry) => ["fetch", "xmlhttprequest"].includes(entry.initiatorType));
+        if (!fetched) return;
+        if (state.timer) clearTimeout(state.timer);
+        state.timer = setTimeout(() => {
+          const still = passwords(doc).some((input) => input.isConnected && input.value !== "" && input.getClientRects().length > 0);
+          if (!still) send(state.cached);
+        }, 1500);
+      }).observe({ type: "resource", buffered: false });
+    } catch {
+    }
+  }
+}
+var LOGIN_SEEN_MESSAGE = "buddi-login-seen";
+var LOGIN_PENDING_MESSAGE = "buddi-login-pending";
+function heldLoginRequest(message, sender, heldTab) {
+  const request = message;
+  if (!request || typeof request.session !== "string" || request.session === "") return void 0;
+  if (heldTab === void 0 || sender?.tab?.id !== heldTab) return void 0;
+  const session = request.session;
+  const url = sender.url ?? "";
+  if (request.type === LOGIN_SEEN_MESSAGE) {
+    if (typeof request.password !== "string" || request.password === "" || request.password.length > 1024) return void 0;
+    const username = typeof request.username === "string" ? request.username.slice(0, 200) : "";
+    return { kind: "seen", session, tabId: heldTab, url, username, password: request.password, update: request.update === true };
+  }
+  if (request.type === LOGIN_PENDING_MESSAGE) return { kind: "pending", session, tabId: heldTab, url };
+  if (request.type === LOGIN_MESSAGE && (request.decision === "save" || request.decision === "later" || request.decision === "never")) {
+    return { kind: "answer", session, tabId: heldTab, decision: request.decision };
+  }
+  return void 0;
+}
+
+// src/pairings.ts
+var COLOURS = ["blue", "purple", "green", "orange", "pink", "cyan", "red", "yellow", "grey"];
+var DEFAULT_GATEWAY = "http://127.0.0.1:4317";
+var PAIRINGS_KEY = "pairings";
+var LEGACY_GATEWAY = "gateway";
+var LEGACY_TOKEN = "token";
+var LOOPBACK = ["127.0.0.1", "localhost", "[::1]", "::1"];
+function originOf2(address) {
+  let parsed;
+  try {
+    parsed = new URL(address.trim());
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+  if (!LOOPBACK.includes(parsed.hostname)) return null;
+  return parsed.origin;
+}
+function portOf(url) {
+  return url.port || (url.protocol === "https:" ? "443" : "80");
+}
+function sameBuddi(a, b) {
+  let x, y;
+  try {
+    x = new URL(a);
+    y = new URL(b);
+  } catch {
+    return false;
+  }
+  if (!LOOPBACK.includes(x.hostname) || !LOOPBACK.includes(y.hostname)) return false;
+  return x.protocol === y.protocol && portOf(x) === portOf(y);
+}
+function hostOf(origin) {
+  try {
+    return new URL(origin).host;
+  } catch {
+    return origin;
+  }
+}
+function displayName(entry, all) {
+  const own = entry.name.trim();
+  if (!own) return hostOf(entry.origin);
+  const twin = all.some((other) => other.id !== entry.id && other.name.trim().toLowerCase() === own.toLowerCase());
+  if (!twin) return own;
+  try {
+    return `${own} :${portOf(new URL(entry.origin))}`;
+  } catch {
+    return own;
+  }
+}
+function nextColour(all) {
+  const taken = new Set(all.map((entry) => entry.colour));
+  return COLOURS.find((colour) => !taken.has(colour)) ?? COLOURS[all.length % COLOURS.length];
+}
+function freshId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function readEntry(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const value = raw;
+  const origin = typeof value["origin"] === "string" ? originOf2(value["origin"]) : null;
+  if (!origin || typeof value["id"] !== "string" || value["id"] === "") return null;
+  const colour = COLOURS.includes(String(value["colour"])) ? value["colour"] : "grey";
+  const token = typeof value["token"] === "string" && value["token"] !== "" ? value["token"] : void 0;
+  return {
+    id: value["id"],
+    origin,
+    ...token ? { token } : {},
+    name: typeof value["name"] === "string" ? value["name"].slice(0, 60) : "",
+    colour,
+    enabled: value["enabled"] !== false
+  };
+}
+var PairingStore = class {
+  #storage;
+  #tail = Promise.resolve();
+  #newId;
+  constructor(storage, options = {}) {
+    this.#storage = storage;
+    this.#newId = options.id ?? freshId;
+  }
+  /**
+   * Every entry, after the one-time move from the single pairing.
+   *
+   * An extension that held `gateway` and `token` keeps exactly that buddi, as
+   * the first entry, switched on. One that held nothing gets the default
+   * address, switched on and unpaired, so a fresh install still knocks on the
+   * buddi at 4317 by itself and the dashboard in this browser can pair it
+   * without the owner typing anything.
+   */
+  list() {
+    return this.#queue(async () => this.#load());
+  }
+  async #load() {
+    const stored = await this.#storage.get([PAIRINGS_KEY, LEGACY_GATEWAY, LEGACY_TOKEN]);
+    const raw = stored[PAIRINGS_KEY];
+    if (Array.isArray(raw)) return raw.map(readEntry).filter((entry) => entry !== null);
+    const address = typeof stored[LEGACY_GATEWAY] === "string" ? originOf2(stored[LEGACY_GATEWAY]) : null;
+    const token = typeof stored[LEGACY_TOKEN] === "string" && stored[LEGACY_TOKEN] !== "" ? stored[LEGACY_TOKEN] : void 0;
+    const first = { id: this.#newId(), origin: address ?? DEFAULT_GATEWAY, ...token ? { token } : {}, name: "", colour: COLOURS[0], enabled: true };
+    await this.#storage.set({ [PAIRINGS_KEY]: [first] });
+    await this.#storage.remove([LEGACY_GATEWAY, LEGACY_TOKEN]);
+    return [first];
+  }
+  async #save(entries2) {
+    await this.#storage.set({ [PAIRINGS_KEY]: entries2 });
+  }
+  #queue(work) {
+    const next = this.#tail.then(work, work);
+    this.#tail = next.catch(() => void 0);
+    return next;
+  }
+  /**
+   * Add a buddi by its address, or hand back the entry that already has it
+   * (switched on again). Throws the sentence the popup shows for an address
+   * that is not on this machine.
+   */
+  add(address) {
+    return this.#queue(async () => {
+      const origin = originOf2(address);
+      if (!origin) throw new Error(/^\s*https?:\/\//i.test(address) ? "A buddi address has to be on this machine." : "A buddi address starts with http.");
+      const entries2 = await this.#load();
+      const existing = entries2.find((entry2) => sameBuddi(entry2.origin, origin));
+      if (existing) {
+        existing.enabled = true;
+        await this.#save(entries2);
+        return existing;
+      }
+      const entry = { id: this.#newId(), origin, name: "", colour: nextColour(entries2), enabled: true };
+      entries2.push(entry);
+      await this.#save(entries2);
+      return entry;
+    });
+  }
+  /** Change one entry in place; nothing happens to an entry that is gone. */
+  update(id, patch) {
+    return this.#queue(async () => {
+      const entries2 = await this.#load();
+      const entry = entries2.find((candidate) => candidate.id === id);
+      if (!entry) return void 0;
+      if ("token" in patch) {
+        if (patch.token) entry.token = patch.token;
+        else delete entry.token;
+      }
+      if (patch.name !== void 0) entry.name = patch.name.slice(0, 60);
+      if (patch.enabled !== void 0) entry.enabled = patch.enabled;
+      await this.#save(entries2);
+      return entry;
+    });
+  }
+  /** Forget a buddi: its entry and its token go; its tabs stay, because they are the owner's. */
+  remove(id) {
+    return this.#queue(async () => {
+      const entries2 = await this.#load();
+      await this.#save(entries2.filter((entry) => entry.id !== id));
+    });
+  }
+  /** The token seam `Protocol` reads and writes, for one entry. */
+  tokens(id) {
+    return {
+      read: async () => (await this.list()).find((entry) => entry.id === id)?.token ?? null,
+      write: async (token) => {
+        await this.update(id, { token });
+      },
+      clear: async () => {
+        await this.update(id, { token: void 0 });
+      }
+    };
+  }
+};
+var GroupRegistry = class {
+  #owners = /* @__PURE__ */ new Map();
+  /** Record that `instance` made (or re-joined) this group. */
+  claim(groupId, instance) {
+    if (groupId >= 0) this.#owners.set(groupId, instance);
+  }
+  /** Whose group this is, or undefined for a group no buddi made (the owner's own). */
+  ownerOf(groupId) {
+    return groupId === void 0 || groupId < 0 ? void 0 : this.#owners.get(groupId);
+  }
+  /** May `instance` act in a tab that sits in this group? Only in its own, or in no group at all. */
+  allows(groupId, instance) {
+    const owner = this.ownerOf(groupId);
+    return owner === void 0 || owner === instance;
+  }
+  /** A buddi was removed: its groups belong to nobody now (the tabs are the owner's). */
+  release(instance) {
+    for (const [groupId, owner] of this.#owners) if (owner === instance) this.#owners.delete(groupId);
+  }
+  groupsOf(instance) {
+    return [...this.#owners].filter(([, owner]) => owner === instance).map(([groupId]) => groupId);
+  }
+};
+
+// src/external.ts
+function isLoopbackOrigin(origin) {
+  if (!origin) return false;
+  let parsed;
+  try {
+    parsed = new URL(origin);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+  return ["127.0.0.1", "localhost", "[::1]", "::1"].includes(parsed.hostname);
+}
+function named(state) {
+  return state.connection === "paired" ? "paired" : state.connection === "pairing" ? "pairing" : "disconnected";
+}
+function describe(state, gateway, version2) {
+  const status = { installed: true, version: version2, state: named(state), gateway };
+  if (status.state === "pairing" && state.code) status.code = state.code;
+  return status;
+}
+function describeFor(origin, known, version2) {
+  const mine = known.find((entry) => sameBuddi(entry.origin, origin));
+  const status = mine ? describe(mine.state, mine.origin, version2) : describe({ connection: "offline", code: null, installation: null, error: null }, known[0]?.origin ?? origin, version2);
+  status.pairings = known.map((entry) => ({ origin: entry.origin, name: entry.name, state: named(entry.state), enabled: entry.enabled }));
+  return status;
+}
+function handleExternal(message, context, respond) {
+  if (!isLoopbackOrigin(context.origin)) return false;
+  const request = message;
+  if (!request || request.type !== "buddi.status") return false;
+  const origin = context.origin;
+  void context.known().then((known) => {
+    if (!known.some((entry) => sameBuddi(entry.origin, origin))) context.unknown?.(origin);
+    respond(describeFor(origin, known, context.version));
+  });
+  return true;
+}
+
 // src/protocol.ts
 var COMMAND_NAMES = ["navigate", "observe", "click", "fill", "select", "press", "scroll", "tab", "close", "fieldInfo", "secretFill"];
-var HAND_COMMANDS = ["screencast.start", "screencast.stop", "input", "hold", "unhold"];
+var HAND_COMMANDS = ["screencast.start", "screencast.stop", "input", "hold", "unhold", "capture", "copy"];
+var EXTENSION_FEATURES = ["live"];
 var PreconditionError = class extends Error {
 };
 var OpenedError = class extends Error {
@@ -33,6 +697,7 @@ var Cancellation = class {
 };
 var TOKEN_KEY = "token";
 var BAD_PROOF = "That buddi could not prove it is the one this browser was paired with.";
+var PAIR_AGAIN = "pair-again";
 var encoder = new TextEncoder();
 var hex = (buffer) => Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
 async function sha256Hex(text2) {
@@ -85,24 +750,48 @@ var Protocol = class {
     const stored = await this.#token();
     this.#nonce = nonce();
     this.#authenticated = false;
-    this.#set({ connection: "connecting", code: null, error: null });
-    this.#options.send({ type: "hello", extension: this.#options.version, nonce: this.#nonce, paired: stored !== null });
+    this.#set({ connection: "connecting", code: null, error: null, features: [], refused: false });
+    this.#options.send({ type: "hello", extension: this.#options.version, nonce: this.#nonce, paired: stored !== null, features: [...EXTENSION_FEATURES] });
   }
-  closed(reason) {
+  closed(reason, options = {}) {
     this.#authenticated = false;
     for (const cancel of this.#running.values()) cancel.cancel();
     this.#running.clear();
     this.#options.onReset?.();
-    this.#set({ connection: "offline", code: null, error: reason ?? null });
+    this.#set({ connection: "offline", code: null, error: reason ?? null, refused: options.refused === true });
+  }
+  /** The token this browser held is no use at that buddi: forget it, so the next hello asks for a code. */
+  async dropToken() {
+    if (this.#options.tokens) await this.#options.tokens.clear();
+    else await this.#options.chrome?.storage.local.remove([TOKEN_KEY]);
   }
   async #token() {
-    const stored = await this.#options.chrome.storage.local.get([TOKEN_KEY]);
+    if (this.#options.tokens) return this.#options.tokens.read();
+    const stored = await this.#options.chrome?.storage.local.get([TOKEN_KEY]) ?? {};
     const token = stored[TOKEN_KEY];
     return typeof token === "string" && token.length > 0 ? token : null;
   }
+  async #keep(token) {
+    if (this.#options.tokens) {
+      await this.#options.tokens.write(token);
+      return;
+    }
+    await this.#options.chrome?.storage.local.set({ [TOKEN_KEY]: token });
+  }
+  /** What a handshake frame says about the buddi: its name and what it reads. */
+  #about(message) {
+    const patch = {};
+    const name = message["name"];
+    if (typeof name === "string" && name.trim() !== "") patch.name = name.trim().slice(0, 60);
+    const features = message["features"];
+    patch.features = Array.isArray(features) ? features.filter((item) => typeof item === "string" && item.length <= 40).slice(0, 20) : [];
+    patch.older = !patch.features.includes("frames.binary");
+    return patch;
+  }
   /** Drops the token and asks for a new socket, which starts the pairing dance again. */
   async forget() {
-    await this.#options.chrome.storage.local.remove([TOKEN_KEY]);
+    if (this.#options.tokens) await this.#options.tokens.clear();
+    else await this.#options.chrome?.storage.local.remove([TOKEN_KEY]);
     this.#authenticated = false;
     this.#set({ connection: "offline", code: null, installation: null, error: null });
     this.#options.disconnect?.("The owner forgot this buddi.");
@@ -137,10 +826,11 @@ var Protocol = class {
           connection: "paired",
           code: null,
           error: null,
+          ...this.#about(message),
           installation: typeof installation === "string" ? installation : this.#state.installation
         });
         const token = message["token"];
-        if (typeof token === "string" && token.length > 0) await this.#options.chrome.storage.local.set({ [TOKEN_KEY]: token });
+        if (typeof token === "string" && token.length > 0) await this.#keep(token);
         return;
       }
       case "rehello":
@@ -169,398 +859,90 @@ var Protocol = class {
       default:
         return;
     }
-  }
-  /**
-   * The gateway signed our nonce. Check it before the token leaves this browser.
-   *
-   * The key is the token's hash, which is all the gateway keeps, so a gateway
-   * that cannot produce this signature is not the one this browser paired with
-   * and never gets to see the token.
-   */
-  async #challenge(message) {
-    const token = await this.#token();
-    const claimed = typeof message["proof"] === "string" ? message["proof"] : "";
-    if (!token) {
-      this.#options.disconnect?.("This browser has no token for that buddi.");
-      return;
-    }
-    const expected = await proofFor(await sha256Hex(token), this.#nonce);
-    if (!sameProof(expected, claimed)) {
-      this.#authenticated = false;
-      this.#set({ connection: "offline", code: null, error: BAD_PROOF });
-      this.#options.disconnect?.(BAD_PROOF);
-      return;
-    }
-    const installation = message["installation"];
-    if (typeof installation === "string") this.#set({ installation });
-    this.#options.send({ type: "auth", token });
-  }
-  async #command(message) {
-    const id = typeof message["id"] === "string" ? message["id"] : null;
-    if (!id) return;
-    if (!this.#authenticated) {
-      this.#options.send({ type: "result", id, ok: false, error: "This browser is not paired with you.", precondition: true });
-      return;
-    }
-    const name = message["name"];
-    const session = message["session"];
-    if (typeof name !== "string" || !isCommandName(name)) {
-      this.#options.send({ type: "result", id, ok: false, error: `This buddi extension does not know the command ${String(name)}.`, precondition: true });
-      return;
-    }
-    if (typeof session !== "string" || session.length === 0) {
-      this.#options.send({ type: "result", id, ok: false, error: "The command arrived without a session.", precondition: true });
-      return;
-    }
-    const args = message["args"];
-    const command = {
-      id,
-      name,
-      session,
-      args: args && typeof args === "object" ? args : {},
-      owner: message["owner"] === true
-    };
-    const cancel = new Cancellation();
-    this.#running.set(id, cancel);
-    try {
-      const result = await this.#options.execute(command, cancel);
-      cancel.check();
-      this.#options.send({ type: "result", id, ok: true, observation: result.observation ?? null, screenshot: result.screenshot ?? null });
-    } catch (error) {
-      if (error instanceof CancelledError) {
-        this.#options.send({ type: "result", id, ok: false, error: "cancelled", precondition: !cancel.dispatched });
-      } else {
-        this.#options.send({
-          type: "result",
-          id,
-          ok: false,
-          error: sentence(error),
-          precondition: error instanceof PreconditionError,
-          ...error instanceof OpenedError ? { page: error.page } : {}
-        });
-      }
-    } finally {
-      this.#running.delete(id);
-    }
-  }
-};
-function isCommandName(name) {
-  return name === "screenshot" || COMMAND_NAMES.includes(name) || HAND_COMMANDS.includes(name);
-}
-function sentence(error) {
-  const text2 = error instanceof Error ? error.message : String(error);
-  const trimmed = text2.replace(/\s+/g, " ").trim().slice(0, 300);
-  if (!trimmed) return "The browser extension could not run that command.";
-  return /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
-}
-
-// src/bar.ts
-var OWNER_WAIT_MS = 3e4;
-var BAR_AFTER_MS = 3e3;
-var BAR_POLL_MS = 500;
-async function waitForOwner(probes, limits = {}) {
-  const waitMs = limits.waitMs ?? OWNER_WAIT_MS;
-  const barAfter = limits.barAfterMs ?? BAR_AFTER_MS;
-  const poll = limits.pollMs ?? BAR_POLL_MS;
-  const start = probes.now();
-  let shown = false;
-  const maxPolls = Math.ceil(waitMs / poll);
-  try {
-    for (let polls = 0; ; polls++) {
-      if (!await probes.watched()) return "left";
-      const elapsed = Math.max(probes.now() - start, polls * poll);
-      if (!shown && elapsed >= barAfter) {
-        shown = true;
-        await probes.show().catch(() => void 0);
-      }
-      if (shown) {
-        const choice = await probes.choice().catch(() => void 0);
-        if (choice) return choice;
-      }
-      if (elapsed >= waitMs || polls >= maxPolls) return "timeout";
-      await probes.wait(poll);
-    }
-  } finally {
-    if (shown) await probes.hide().catch(() => void 0);
-  }
-}
-function showBar(agent) {
-  const holder = globalThis;
-  holder["__buddiBar"] = { choice: void 0 };
-  const doc = globalThis.document;
-  if (!doc || doc.getElementById("buddi-working-bar")) return;
-  const host = doc.createElement("div");
-  host.id = "buddi-working-bar";
-  host.setAttribute("style", "position:fixed;top:0;left:0;right:0;z-index:2147483647;all:initial;");
-  const root = host.attachShadow({ mode: "closed" });
-  const bar = doc.createElement("div");
-  bar.setAttribute("role", "status");
-  bar.setAttribute("style", "position:fixed;top:0;left:0;right:0;display:flex;gap:12px;align-items:center;justify-content:flex-end;padding:6px 16px;font:13px/1.4 system-ui,-apple-system,sans-serif;background:#1f2a44;color:#fff;box-shadow:0 1px 4px rgba(0,0,0,.25);");
-  const label = doc.createElement("span");
-  label.textContent = `${agent || "buddi"} is working here`;
-  label.setAttribute("style", "margin-right:auto;");
-  const button = (text2, choice, primary) => {
-    const b = doc.createElement("button");
-    b.type = "button";
-    b.textContent = text2;
-    b.setAttribute("style", `font:inherit;cursor:pointer;border-radius:6px;padding:3px 10px;border:1px solid #fff;${primary ? "background:#fff;color:#1f2a44;" : "background:transparent;color:#fff;"}`);
-    b.addEventListener("click", () => {
-      holder["__buddiBar"] = { choice };
-    });
-    return b;
-  };
-  bar.append(label, button("Take over", "takeover", false), button("Let it continue", "continue", true));
-  root.append(bar);
-  (doc.documentElement ?? doc.body).append(host);
-}
-function readBar() {
-  const holder = globalThis;
-  const choice = holder["__buddiBar"]?.choice;
-  if (choice) holder["__buddiBar"] = { choice: void 0 };
-  return choice;
-}
-function hideBar() {
-  const doc = globalThis.document;
-  doc?.getElementById("buddi-working-bar")?.remove();
-  const holder = globalThis;
-  delete holder["__buddiBar"];
-}
-var GIVE_BACK_MESSAGE = "buddi-give-back";
-function showHeldBar(session) {
-  const doc = globalThis.document;
-  if (!doc || doc.getElementById("buddi-held-bar")) return;
-  const host = doc.createElement("div");
-  host.id = "buddi-held-bar";
-  host.setAttribute("style", "position:fixed;top:0;left:0;right:0;z-index:2147483647;all:initial;");
-  const root = host.attachShadow({ mode: "closed" });
-  const bar = doc.createElement("div");
-  bar.setAttribute("role", "status");
-  bar.setAttribute("style", "position:fixed;top:0;left:0;right:0;display:flex;gap:12px;align-items:center;justify-content:flex-end;padding:6px 16px;font:13px/1.4 system-ui,-apple-system,sans-serif;background:#1f2a44;color:#fff;box-shadow:0 1px 4px rgba(0,0,0,.25);");
-  const label = doc.createElement("span");
-  label.textContent = "buddi is waiting";
-  label.setAttribute("style", "margin-right:auto;");
-  const give = doc.createElement("button");
-  give.type = "button";
-  give.textContent = "Give it back";
-  give.setAttribute("style", "font:inherit;cursor:pointer;border-radius:6px;padding:3px 10px;border:1px solid #fff;background:#fff;color:#1f2a44;");
-  give.addEventListener("click", () => {
-    const runtime = globalThis.chrome?.runtime;
-    void runtime?.sendMessage({ type: "buddi-give-back", session })?.catch?.(() => void 0);
-    host.remove();
-  });
-  bar.append(label, give);
-  root.append(bar);
-  (doc.documentElement ?? doc.body).append(host);
-  const asking = [];
-  const restore = () => {
-    for (const button of asking.splice(0)) button.remove();
-    label.textContent = "buddi is waiting";
-    give.style.display = "";
-  };
-  globalThis["__buddiHeldAsk"] = (question, choices) => {
-    restore();
-    label.textContent = question;
-    give.style.display = "none";
-    for (const choice of choices) {
-      const b = doc.createElement("button");
-      b.type = "button";
-      b.textContent = choice.label;
-      b.setAttribute("style", `font:inherit;cursor:pointer;border-radius:6px;padding:3px 10px;border:1px solid #fff;${choice.primary ? "background:#fff;color:#1f2a44;" : "background:transparent;color:#fff;"}`);
-      b.addEventListener("click", () => {
-        restore();
-        choice.pick();
-      });
-      asking.push(b);
-      bar.insertBefore(b, give);
+  }
+  /**
+   * The gateway signed our nonce. Check it before the token leaves this browser.
+   *
+   * The key is the token's hash, which is all the gateway keeps, so a gateway
+   * that cannot produce this signature is not the one this browser paired with
+   * and never gets to see the token.
+   */
+  async #challenge(message) {
+    const token = await this.#token();
+    const claimed = typeof message["proof"] === "string" ? message["proof"] : "";
+    if (!token) {
+      this.#options.disconnect?.("This browser has no token for that buddi.");
+      return;
     }
-    return restore;
-  };
-}
-function hideHeldBar() {
-  const doc = globalThis.document;
-  doc?.getElementById("buddi-held-bar")?.remove();
-  delete globalThis["__buddiHeldAsk"];
-}
-var LOGIN_MESSAGE = "buddi-login";
-var LOGIN_PROMPT_MS = 2 * 6e4;
-function watchHeldLogins(session, facts) {
-  const holder = globalThis;
-  const known = { never: [...facts?.never ?? []], saved: [...facts?.saved ?? []] };
-  const existing = holder["__buddiHeldLogins"];
-  if (existing) {
-    existing.session = session;
-    existing.facts = known;
-    return;
+    const expected = await proofFor(await sha256Hex(token), this.#nonce);
+    if (!sameProof(expected, claimed)) {
+      this.#authenticated = false;
+      await this.dropToken();
+      this.#set({ connection: "offline", code: null, error: BAD_PROOF });
+      this.#options.disconnect?.(PAIR_AGAIN);
+      return;
+    }
+    const installation = message["installation"];
+    this.#set({ ...this.#about(message), ...typeof installation === "string" ? { installation } : {} });
+    this.#options.send({ type: "auth", token });
   }
-  const doc = globalThis.document;
-  if (!doc) return;
-  const state = { session, facts: known, last: "", lastAt: 0, typedAt: 0, cached: void 0, timer: void 0, drop: void 0 };
-  holder["__buddiHeldLogins"] = state;
-  const runtime = () => globalThis.chrome?.runtime;
-  const call = async (message) => {
-    try {
-      return await runtime()?.sendMessage(message);
-    } catch {
-      return void 0;
+  async #command(message) {
+    const id = typeof message["id"] === "string" ? message["id"] : null;
+    if (!id) return;
+    if (!this.#authenticated) {
+      this.#options.send({ type: "result", id, ok: false, error: "This browser is not paired with you.", precondition: true });
+      return;
     }
-  };
-  const site = () => (globalThis.location?.hostname ?? "").toLowerCase().replace(/^www\./, "");
-  const listed = (where) => state.facts.never.some((entry) => {
-    const bare = entry.toLowerCase().replace(/^www\./, "");
-    return where === bare || where.endsWith(`.${bare}`);
-  });
-  const bar = () => {
-    const question = holder["__buddiHeldAsk"];
-    return typeof question === "function" ? question : void 0;
-  };
-  const prompt = (where, update) => {
-    const question = bar();
-    if (!question) return;
-    if (state.drop) clearTimeout(state.drop);
-    let answered = false;
-    const save = () => {
-      if (answered) return;
-      answered = true;
-      const asking = bar();
-      asking?.(update ? "Updating\u2026" : "Saving\u2026", []);
-      void call({ type: "buddi-login", session: state.session, decision: "save" }).then((reply) => {
-        const answer = reply;
-        const now = bar();
-        if (!now) return;
-        if (answer?.saved === true) {
-          const restore2 = now(update ? `Updated the login for ${where}` : `Saved the login for ${where}`, []);
-          if (state.drop) clearTimeout(state.drop);
-          state.drop = setTimeout(restore2, 2e3);
-          return;
-        }
-        const reason = typeof answer?.reason === "string" && answer.reason !== "" ? answer.reason : "buddi did not answer. Try again.";
-        now(reason, [
-          { label: "Try again", primary: true, pick: () => {
-            answered = false;
-            save();
-          } },
-          { label: "Not now", pick: () => {
-            void call({ type: "buddi-login", session: state.session, decision: "later" });
-          } }
-        ]);
-      });
+    const name = message["name"];
+    const session = message["session"];
+    if (typeof name !== "string" || !isCommandName(name)) {
+      this.#options.send({ type: "result", id, ok: false, error: `This buddi extension does not know the command ${String(name)}.`, precondition: true });
+      return;
+    }
+    if (typeof session !== "string" || session.length === 0) {
+      this.#options.send({ type: "result", id, ok: false, error: "The command arrived without a session.", precondition: true });
+      return;
+    }
+    const args = message["args"];
+    const command = {
+      id,
+      name,
+      session,
+      args: args && typeof args === "object" ? args : {},
+      owner: message["owner"] === true
     };
-    const restore = question(update ? `Update the login for ${where}?` : `Save this login for ${where}?`, [
-      { label: update ? "Update" : "Save", primary: true, pick: save },
-      { label: "Not now", pick: () => {
-        answered = true;
-        void call({ type: "buddi-login", session: state.session, decision: "later" });
-      } },
-      { label: "Never for this site", pick: () => {
-        answered = true;
-        state.facts.never.push(where);
-        void call({ type: "buddi-login", session: state.session, decision: "never" });
-      } }
-    ]);
-    state.drop = setTimeout(() => {
-      if (!answered) restore();
-    }, 2 * 6e4);
-  };
-  const ask = (found) => {
-    const where = site();
-    if (where === "" || listed(where) || !bar()) return;
-    const update = state.facts.saved.some((login) => login.site === where && login.username === found.username);
-    void call({ type: "buddi-login-seen", session: state.session, username: found.username, password: found.password, update }).then((reply) => {
-      const asked = reply;
-      if (holder["__buddiHeldLogins"] !== state || !asked || typeof asked !== "object") return;
-      prompt(where, asked.update === true);
-    });
-  };
-  void call({ type: "buddi-login-pending", session: state.session }).then((reply) => {
-    const waiting = reply;
-    if (holder["__buddiHeldLogins"] !== state || !waiting || typeof waiting.site !== "string") return;
-    prompt(waiting.site, waiting.update === true);
-  });
-  const NOT_SUBMIT = /\b(show|hide|reveal|toggle|eye|forgot|reset|cancel|back|close|sign ?up|register|create)\b/i;
-  const USER = /user|email|login|account|ident|phone|mail/i;
-  const passwords = (root) => Array.from(root.querySelectorAll('input[type="password" i]'));
-  const usernameFor = (password) => {
-    const scope = password.form ?? doc;
-    const inputs = Array.from(scope.querySelectorAll("input")).filter((input) => ["text", "email", "tel", ""].includes((input.getAttribute("type") ?? "").toLowerCase()) && input.value.trim() !== "");
-    const marked = inputs.find((input) => (input.getAttribute("autocomplete") ?? "").toLowerCase().includes("username") || (input.getAttribute("type") ?? "").toLowerCase() === "email");
-    if (marked) return marked.value.trim();
-    const before = inputs.filter((input) => (input.compareDocumentPosition(password) & 4) !== 0);
-    const pick = before[before.length - 1] ?? inputs.find((input) => USER.test(`${input.name} ${input.id} ${input.getAttribute("autocomplete") ?? ""}`));
-    return pick ? pick.value.trim() : "";
-  };
-  const read = (scope) => {
-    const field = passwords(scope ?? doc).find((input) => input.value !== "");
-    return field ? { username: usernameFor(field), password: field.value } : void 0;
-  };
-  const send2 = (found) => {
-    if (holder["__buddiHeldLogins"] !== state) return;
-    if (!found || found.password === "") return;
-    const key = `${found.username}\0${found.password}`;
-    const now = Date.now();
-    if (key === state.last && now - state.lastAt < 5e3) return;
-    state.last = key;
-    state.lastAt = now;
-    state.cached = void 0;
-    ask(found);
-  };
-  doc.addEventListener("submit", (event) => {
-    send2(read(event.target) ?? state.cached);
-  }, true);
-  doc.addEventListener("keydown", (event) => {
-    if (event.key !== "Enter") return;
-    const target = event.target;
-    if (!target || target.tagName !== "INPUT") return;
-    send2(read(target.form ?? doc));
-  }, true);
-  doc.addEventListener("click", (event) => {
-    const target = event.target;
-    const button = target?.closest?.('button, input[type="submit" i], input[type="image" i], input[type="button" i], [role="button"]');
-    if (!button) return;
-    const words = `${button.textContent ?? ""} ${button.getAttribute("aria-label") ?? ""} ${button.getAttribute("value") ?? ""} ${button.getAttribute("title") ?? ""}`;
-    if (NOT_SUBMIT.test(words)) return;
-    send2(read(button.form ?? doc));
-  }, true);
-  doc.addEventListener("input", (event) => {
-    const target = event.target;
-    if ((target?.getAttribute?.("type") ?? "").toLowerCase() !== "password") return;
-    state.typedAt = Date.now();
-    state.cached = read(target.form ?? doc);
-  }, true);
-  const Observer = globalThis.PerformanceObserver;
-  if (typeof Observer === "function") {
+    const cancel = new Cancellation();
+    this.#running.set(id, cancel);
     try {
-      new Observer((list) => {
-        if (!state.cached || Date.now() - state.typedAt > 1e4) return;
-        const fetched = list.getEntries().some((entry) => ["fetch", "xmlhttprequest"].includes(entry.initiatorType));
-        if (!fetched) return;
-        if (state.timer) clearTimeout(state.timer);
-        state.timer = setTimeout(() => {
-          const still = passwords(doc).some((input) => input.isConnected && input.value !== "" && input.getClientRects().length > 0);
-          if (!still) send2(state.cached);
-        }, 1500);
-      }).observe({ type: "resource", buffered: false });
-    } catch {
+      const result = await this.#options.execute(command, cancel);
+      cancel.check();
+      this.#options.send({ type: "result", id, ok: true, observation: result.observation ?? null, screenshot: result.screenshot ?? null });
+    } catch (error) {
+      if (error instanceof CancelledError) {
+        this.#options.send({ type: "result", id, ok: false, error: "cancelled", precondition: !cancel.dispatched });
+      } else {
+        this.#options.send({
+          type: "result",
+          id,
+          ok: false,
+          error: sentence(error),
+          precondition: error instanceof PreconditionError,
+          ...error instanceof OpenedError ? { page: error.page } : {}
+        });
+      }
+    } finally {
+      this.#running.delete(id);
     }
   }
+};
+function isCommandName(name) {
+  return name === "screenshot" || COMMAND_NAMES.includes(name) || HAND_COMMANDS.includes(name);
 }
-var LOGIN_SEEN_MESSAGE = "buddi-login-seen";
-var LOGIN_PENDING_MESSAGE = "buddi-login-pending";
-function heldLoginRequest(message, sender, heldTab) {
-  const request = message;
-  if (!request || typeof request.session !== "string" || request.session === "") return void 0;
-  if (heldTab === void 0 || sender?.tab?.id !== heldTab) return void 0;
-  const session = request.session;
-  const url = sender.url ?? "";
-  if (request.type === LOGIN_SEEN_MESSAGE) {
-    if (typeof request.password !== "string" || request.password === "" || request.password.length > 1024) return void 0;
-    const username = typeof request.username === "string" ? request.username.slice(0, 200) : "";
-    return { kind: "seen", session, tabId: heldTab, url, username, password: request.password, update: request.update === true };
-  }
-  if (request.type === LOGIN_PENDING_MESSAGE) return { kind: "pending", session, tabId: heldTab, url };
-  if (request.type === LOGIN_MESSAGE && (request.decision === "save" || request.decision === "later" || request.decision === "never")) {
-    return { kind: "answer", session, tabId: heldTab, decision: request.decision };
-  }
-  return void 0;
+function sentence(error) {
+  const text2 = error instanceof Error ? error.message : String(error);
+  const trimmed = text2.replace(/\s+/g, " ").trim().slice(0, 300);
+  if (!trimmed) return "The browser extension could not run that command.";
+  return /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
 }
 
 // src/held-logins.ts
@@ -588,8 +970,8 @@ function webOrigin(url) {
   }
 }
 var HeldLogins = class {
-  constructor(send2, options = {}) {
-    this.send = send2;
+  constructor(send, options = {}) {
+    this.send = send;
     this.options = options;
   }
   #byTab = /* @__PURE__ */ new Map();
@@ -602,11 +984,11 @@ var HeldLogins = class {
   #ask(tabId, frame, ms) {
     const id = this.#id();
     return new Promise((resolve) => {
-      const timer2 = setTimeout(() => {
+      const timer = setTimeout(() => {
         this.#waiting.delete(id);
         resolve(void 0);
       }, ms);
-      this.#waiting.set(id, { tabId, resolve, timer: timer2 });
+      this.#waiting.set(id, { tabId, resolve, timer });
       this.send({ ...frame, id });
     });
   }
@@ -733,6 +1115,9 @@ var SETTLE_MS = 600;
 var SETTLE_STEP_MS = 50;
 var OBSERVE_RETRY_MS = [500, 1e3, 2e3];
 var MIN_FRAME_MS = 100;
+var WATCH_FRAME_MS = 500;
+var MAX_FRAME_MS = 2e3;
+var MAX_COPY = 4e3;
 var MAX_CAST_SIDE = 4096;
 var MAX_COORDINATE = 2e4;
 var MAX_DELTA = 1e4;
@@ -757,13 +1142,13 @@ function num(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function side(value, fallback) {
-  const asked = num(value) ?? fallback;
-  return Math.min(MAX_CAST_SIDE, Math.max(1, Math.round(asked)));
+  const asked2 = num(value) ?? fallback;
+  return Math.min(MAX_CAST_SIDE, Math.max(1, Math.round(asked2)));
 }
 function clamp(value, limit, fallback = 0) {
-  const asked = num(value);
-  if (asked === void 0) return fallback;
-  return Math.min(limit, Math.max(-limit, asked));
+  const asked2 = num(value);
+  if (asked2 === void 0) return fallback;
+  return Math.min(limit, Math.max(-limit, asked2));
 }
 function metadataOf(value) {
   const source = value ?? {};
@@ -813,8 +1198,8 @@ var VIRTUAL_KEYS = {
   F12: 123
 };
 function virtualKey(key) {
-  const named = VIRTUAL_KEYS[key];
-  if (named !== void 0) return named;
+  const named2 = VIRTUAL_KEYS[key];
+  if (named2 !== void 0) return named2;
   return key.length === 1 ? key.toUpperCase().charCodeAt(0) : 0;
 }
 function text(value, limit) {
@@ -935,8 +1320,17 @@ var BrowserCommands = class {
   #casts = /* @__PURE__ */ new Map();
   #castsByTab = /* @__PURE__ */ new Map();
   #ownerWaitMs;
+  /** Which buddi these commands belong to, and the registry that says whose each group is. */
+  #instance;
+  #groups;
+  #groupTitle;
+  #groupColour;
   constructor(chrome2, options = {}) {
     this.#chrome = chrome2;
+    this.#instance = options.instance ?? "buddi";
+    this.#groups = options.groups;
+    this.#groupTitle = options.groupTitle ?? (() => GROUP_TITLE);
+    this.#groupColour = options.groupColour ?? (() => void 0);
     this.downloads = options.downloads;
     this.logins = new HeldLogins(options.onLogin ?? (() => void 0));
     chrome2.tabs.onRemoved?.addListener((tabId) => this.logins.clearTab(tabId));
@@ -949,11 +1343,17 @@ var BrowserCommands = class {
     chrome2.debugger.onDetach.addListener((source) => {
       const tabId = source.tabId;
       if (tabId === void 0) return;
+      if (!this.#attached.has(tabId) && !this.#castsByTab.has(tabId)) return;
       this.#attached.delete(tabId);
       const cast = this.#castsByTab.get(tabId);
-      if (cast) this.#forgetCast(cast);
+      if (cast) {
+        this.#forgetCast(cast);
+        this.#onEvent({ type: "event", name: "castended", session: cast.session });
+      }
     });
-    chrome2.tabs.onUpdated?.addListener((tabId, change) => {
+    chrome2.tabs.onUpdated?.addListener((tabId, change, tab) => {
+      const cast = this.#castsByTab.get(tabId);
+      if (cast && tab?.url) cast.url = tab.url;
       if (change.status !== "complete" || ![...this.#held.values()].includes(tabId)) return;
       const session = [...this.#held].find(([, held]) => held === tabId)?.[0];
       if (session) void this.#drawHeld(tabId, session);
@@ -963,6 +1363,26 @@ var BrowserCommands = class {
   }
   /** Downloads an agent's command starts, noticed while it runs (and a few seconds after). */
   downloads;
+  /** How many tabs this buddi is working in right now, for the popup. */
+  async tabCount() {
+    let count = 0;
+    for (const session of this.#sessions.values()) {
+      for (const tabId of session.tabs.values()) {
+        const tab = await this.#chrome.tabs.get(tabId).catch(() => void 0);
+        if (tab && !this.#taken(session, tab)) count += 1;
+      }
+    }
+    return count;
+  }
+  /** A buddi's name changed (its handshake said one): its groups take it. */
+  async retitle() {
+    const title = this.#groupTitle();
+    const color = this.#groupColour();
+    for (const session of this.#sessions.values()) {
+      if (session.groupId < 0) continue;
+      await this.#chrome.tabGroups.update(session.groupId, { title, ...color ? { color } : {} }).catch(() => void 0);
+    }
+  }
   /** The addresses of a session's tabs, for telling its downloads from the owner's. */
   async #tabUrls(name) {
     const session = this.#sessions.get(name);
@@ -1022,6 +1442,10 @@ var BrowserCommands = class {
         return this.#hold(command, cancel);
       case "unhold":
         return this.#unhold(command.session);
+      case "capture":
+        return this.#capture(command.session, cancel);
+      case "copy":
+        return this.#copy(command.session);
       case "close":
         return this.#close(command, cancel);
       default:
@@ -1090,8 +1514,8 @@ var BrowserCommands = class {
     const session = message?.session;
     const request = heldLoginRequest(message, sender, typeof session === "string" ? this.#held.get(session) : void 0);
     if (!request) return void 0;
-    if (request.kind === "seen") return this.logins.capture(request.tabId, request.session, request.url, request).then((asked) => asked ?? null);
-    if (request.kind === "pending") return this.logins.pending(request.tabId, request.session, request.url).then((asked) => asked ?? null);
+    if (request.kind === "seen") return this.logins.capture(request.tabId, request.session, request.url, request).then((asked2) => asked2 ?? null);
+    if (request.kind === "pending") return this.logins.pending(request.tabId, request.session, request.url).then((asked2) => asked2 ?? null);
     if (request.decision === "save") return this.logins.save(request.tabId, request.session);
     if (request.decision === "never") return Promise.resolve({ ok: this.logins.never(request.tabId, request.session) });
     this.logins.dismiss(request.tabId, request.session);
@@ -1162,6 +1586,7 @@ var BrowserCommands = class {
   /** The owner dragged this tab out of the session's group. A tab that never made it into the group cannot have been. */
   #taken(session, tab) {
     if (tab.id !== void 0 && session.ungrouped.has(tab.id)) return false;
+    if (this.#groups && !this.#groups.allows(tab.groupId, this.#instance)) return true;
     return session.groupId >= 0 && tab.groupId !== session.groupId;
   }
   #activeKey(session) {
@@ -1238,8 +1663,8 @@ var BrowserCommands = class {
         if (normal(found)) return found.id;
       }
     }
-    const last2 = await windows.getLastFocused?.({ windowTypes: ["normal"] }).catch(() => void 0);
-    if (normal(last2)) return last2.id;
+    const last = await windows.getLastFocused?.({ windowTypes: ["normal"] }).catch(() => void 0);
+    if (normal(last)) return last.id;
     const all = await windows.getAll?.({ windowTypes: ["normal"] }).catch(() => void 0);
     return all?.find(normal)?.id ?? null;
   }
@@ -1277,9 +1702,11 @@ var BrowserCommands = class {
     if (groupable) {
       try {
         const groupId = await this.#chrome.tabs.group(session.groupId >= 0 ? { tabIds: [tabId], groupId: session.groupId } : { tabIds: [tabId] });
+        this.#groups?.claim(groupId, this.#instance);
         if (session.groupId !== groupId) {
           session.groupId = groupId;
-          await this.#chrome.tabGroups.update(groupId, { title: GROUP_TITLE, collapsed: false }).catch(() => void 0);
+          const color = this.#groupColour();
+          await this.#chrome.tabGroups.update(groupId, { title: this.#groupTitle(), collapsed: false, ...color ? { color } : {} }).catch(() => void 0);
         }
       } catch {
         session.ungrouped.add(tabId);
@@ -1358,6 +1785,7 @@ var BrowserCommands = class {
     this.#refs.delete(command.session);
     cancel.check();
     const note = await this.#reuseOrOpen(session, url, cancel);
+    await this.#followWatch(command.session);
     return note ? { observation: { note } } : {};
   }
   async #tab(command) {
@@ -1368,11 +1796,13 @@ var BrowserCommands = class {
       throw error instanceof PreconditionError ? error : new PreconditionError("No such tab in this conversation.");
     });
     session.active = wanted;
+    await this.#followWatch(command.session);
     return {};
   }
   /** Closes this session's own tabs, and only the ones still in its group. */
   async #close(command, cancel) {
     this.#inView.delete(command.session);
+    await this.#stopScreencast(command.session).catch(() => void 0);
     const session = this.#sessions.get(command.session);
     if (!session) return {};
     const ids = [];
@@ -1425,7 +1855,7 @@ var BrowserCommands = class {
    * with growing waits, before telling the model the page is not answering.
    */
   async #readFrames(tabId, cancel) {
-    for (let attempt2 = 0; ; attempt2 += 1) {
+    for (let attempt = 0; ; attempt += 1) {
       await this.#inject(tabId);
       const frames = await this.#chrome.scripting.executeScript({
         target: { tabId, allFrames: true },
@@ -1433,7 +1863,7 @@ var BrowserCommands = class {
       }).catch(() => []);
       const top = frames.find((frame) => frame.frameId === 0);
       if (top?.result) return { frames, top: { frameId: top.frameId, result: top.result } };
-      const wait = OBSERVE_RETRY_MS[attempt2];
+      const wait = OBSERVE_RETRY_MS[attempt];
       if (wait === void 0) break;
       await this.#wait(wait);
       cancel.check();
@@ -1620,36 +2050,53 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
       await this.#releaseDebugger(tabId);
     }
   }
-  /* ---- the owner's own hand: a screencast out, input in ---- */
+  /* ---- the picture out, and the owner's own hand in ---- */
   /**
-   * Start painting this session's tab to the dashboard.
+   * Start painting this session's tab to buddi.
    *
-   * The debugger is claimed for the screencast's whole life rather than per
-   * frame: frames arrive as events, not as answers, and a detach between them
-   * would end the stream. Starting twice on the same session restarts it,
-   * which is what a reconnecting dashboard does.
+   * Two kinds, one per session at a time. `watch: true` is the Canvas's
+   * picture while the agent works: it follows the session's active tab, sends
+   * at most two frames a second, takes no input, and asking for it again with
+   * the same bounds on the same tab changes nothing. Without it, this is the
+   * owner's take-over: pinned to the tab it starts on, ten frames a second,
+   * and the only cast input reaches. Starting either replaces whatever cast
+   * the session had, which is also what a re-tune and a reconnecting
+   * dashboard do.
+   *
+   * The debugger is claimed for the cast's whole life rather than per frame:
+   * frames arrive as events, not as answers, and a detach between them would
+   * end the stream. And focus is emulated on the tab first: a tab in the
+   * background, or in a window that is minimised or behind another, is
+   * "hidden" to Chrome, and a hidden page paints nothing at all for a
+   * screencast. With focus emulated the page renders as if it were in front
+   * (it is told it is visible), and stays where it is.
    */
   async #startScreencast(command, cancel) {
     const session = await this.#session(command.session);
     const tab = await this.#ownTab(session, this.#activeKey(session));
     this.#liveUrl(tab);
     const tabId = tab.id;
+    const mode = command.args["watch"] === true ? "watch" : "hand";
+    const params = {
+      // Smaller and cheaper than a screenshot on purpose: this is a picture
+      // for a phone on someone else's network, not evidence for a model.
+      quality: Math.min(90, Math.max(20, Math.trunc(num(command.args["quality"]) ?? 50))),
+      maxWidth: side(command.args["maxWidth"], 960),
+      maxHeight: side(command.args["maxHeight"], 600),
+      everyNthFrame: Math.min(10, Math.max(1, Math.trunc(num(command.args["everyNthFrame"]) ?? 1)))
+    };
+    const interval = Math.min(MAX_FRAME_MS, Math.max(MIN_FRAME_MS, Math.trunc(num(command.args["interval"]) ?? (mode === "watch" ? WATCH_FRAME_MS : MIN_FRAME_MS))));
+    const running = this.#casts.get(command.session);
+    if (running && !running.stopped && mode === "watch" && running.mode === "watch" && running.tabId === tabId && running.interval === interval && JSON.stringify(running.params) === JSON.stringify(params)) return {};
     cancel.check();
-    await this.#stopScreencast(command.session);
     await this.#claimDebugger(tabId);
-    const cast = { session: command.session, tabId, lastSentAt: 0, stopped: false };
+    await this.#stopScreencast(command.session);
+    const cast = { session: command.session, tabId, mode, interval, params, url: tab.url, lastSentAt: 0, stopped: false };
     this.#casts.set(command.session, cast);
     this.#castsByTab.set(tabId, cast);
     try {
-      await this.#send(tabId, "Page.startScreencast", {
-        format: "jpeg",
-        // Smaller and cheaper than a screenshot on purpose: this is a picture
-        // for a phone on someone else's network, not evidence for a model.
-        quality: Math.min(90, Math.max(20, Math.trunc(num(command.args["quality"]) ?? 50))),
-        maxWidth: side(command.args["maxWidth"], 960),
-        maxHeight: side(command.args["maxHeight"], 600),
-        everyNthFrame: Math.min(10, Math.max(1, Math.trunc(num(command.args["everyNthFrame"]) ?? 1)))
-      });
+      await this.#send(tabId, "Emulation.setFocusEmulationEnabled", { enabled: true }).catch(() => void 0);
+      await this.#send(tabId, "Page.startScreencast", { format: "jpeg", ...params });
       cancel.check();
     } catch (error) {
       await this.#stopScreencast(command.session);
@@ -1657,12 +2104,27 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
     }
     return {};
   }
+  /**
+   * The agent moved to another tab, or opened one: a watching picture moves
+   * with it. The owner's own take-over never moves; that is their tab.
+   */
+  async #followWatch(sessionName) {
+    const cast = this.#casts.get(sessionName);
+    if (!cast || cast.mode !== "watch") return;
+    const session = this.#sessions.get(sessionName);
+    const key = session?.active;
+    const tabId = key ? session?.tabs.get(key) : void 0;
+    if (tabId === void 0 || tabId === cast.tabId) return;
+    const { params, interval } = cast;
+    await this.#startScreencast({ id: "follow", name: "screencast.start", session: sessionName, args: { ...params, interval, watch: true } }, new Cancellation()).catch(() => void 0);
+  }
   /** Idempotent: a stop for a session with no screencast is an answer, not a failure. */
   async #stopScreencast(session) {
     const cast = this.#casts.get(session);
     if (!cast) return;
     this.#forgetCast(cast);
     await this.#send(cast.tabId, "Page.stopScreencast").catch(() => void 0);
+    await this.#send(cast.tabId, "Emulation.setFocusEmulationEnabled", { enabled: false }).catch(() => void 0);
     await this.#releaseDebugger(cast.tabId);
   }
   /** Drop every trace of a screencast without touching the debugger, for when Chrome already has. */
@@ -1687,7 +2149,8 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
     this.#offer(cast, { data, metadata: metadataOf(message["metadata"]), sessionId });
   }
   /**
-   * One painted frame, acked at once and sent at most ten times a second.
+   * One painted frame, acked at once and sent at most once per interval (ten
+   * a second for the owner's hand, two for the Canvas's picture).
    *
    * The ack comes first, always, and before the throttle rather than after it.
    * Chrome paints nothing more until the frame it sent is acknowledged, so a
@@ -1702,7 +2165,7 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
    */
   #offer(cast, frame) {
     this.#ack(cast, frame.sessionId);
-    const wait = cast.lastSentAt + MIN_FRAME_MS - this.#now();
+    const wait = cast.lastSentAt + cast.interval - this.#now();
     if (wait <= 0) {
       this.#emit(cast, frame);
       return;
@@ -1718,7 +2181,8 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
   }
   #emit(cast, frame) {
     cast.lastSentAt = this.#now();
-    this.#onFrame({ type: "frame", session: cast.session, data: frame.data, metadata: frame.metadata, sessionId: frame.sessionId });
+    const url = cast.url && /^https?:/i.test(cast.url) ? cast.url.slice(0, 2048) : void 0;
+    this.#onFrame({ type: "frame", session: cast.session, data: frame.data, metadata: frame.metadata, sessionId: frame.sessionId, ...url ? { url } : {} });
   }
   #ack(cast, sessionId) {
     void this.#send(cast.tabId, "Page.screencastFrameAck", { sessionId }).catch(() => void 0);
@@ -1726,14 +2190,15 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
   /**
    * A pointer or a key from the owner's hand.
    *
-   * Only while a screencast is running for that session: input with nothing
-   * painting it is an agent reaching for coordinates, which this backend does
-   * not do. The tab is the screencast's, not the session's active one, so a
-   * click cannot land somewhere the owner is not looking at.
+   * Only while the owner's own screencast is running for that session: input
+   * with nothing painting it is an agent reaching for coordinates, which this
+   * backend does not do, and the Canvas's watching picture is not a hand. The
+   * tab is the screencast's, not the session's active one, so a click cannot
+   * land somewhere the owner is not looking at.
    */
   async #input(command, cancel) {
     const cast = this.#casts.get(command.session);
-    if (!cast) throw new PreconditionError(NO_CAST);
+    if (!cast || cast.mode !== "hand") throw new PreconditionError(NO_CAST);
     const session = await this.#session(command.session);
     const tab = await this.#chrome.tabs.get(cast.tabId).catch(() => void 0);
     if (!tab) {
@@ -1745,12 +2210,89 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
       throw new PreconditionError(TAKEN);
     }
     await this.#background(tab, command);
+    if (str(command.args, "kind") === "nav") {
+      cancel.check();
+      cancel.dispatch();
+      await this.#nav(cast.tabId, command.args);
+      return {};
+    }
     const event = inputEvent(command.args);
     cancel.check();
     cancel.dispatch();
     await this.#send(cast.tabId, event.method, event.params);
     return {};
   }
+  /**
+   * The window's own buttons while the owner holds the page from the
+   * dashboard: back, forward, reload, or an address they typed (http and
+   * https only; buddi checked it against the allowed sites before it came).
+   */
+  async #nav(tabId, args) {
+    const action = str(args, "action");
+    if (action === "reload") {
+      await this.#send(tabId, "Page.reload", {});
+      return;
+    }
+    if (action === "back" || action === "forward") {
+      const history = await this.#send(tabId, "Page.getNavigationHistory");
+      const index = (history?.currentIndex ?? 0) + (action === "back" ? -1 : 1);
+      const entry = history?.entries?.[index];
+      if (!entry) return;
+      await this.#send(tabId, "Page.navigateToHistoryEntry", { entryId: entry.id });
+      return;
+    }
+    if (action === "navigate") {
+      const url = checkUrl(str(args, "url") ?? "");
+      await this.#send(tabId, "Page.navigate", { url });
+      return;
+    }
+    throw new PreconditionError("That is not a button this window has.");
+  }
+  /**
+   * The owner's Cmd/Ctrl+C on the page they hold: the page's selection, or
+   * the selected part of the focused field, read with `Runtime.evaluate` in
+   * the page's own world. A password field is never read; its selection is
+   * nothing. The text goes back to buddi as the answer and is kept by nothing.
+   */
+  async #copy(session) {
+    const cast = this.#casts.get(session);
+    if (!cast || cast.mode !== "hand") throw new PreconditionError(NO_CAST);
+    const answer = await this.#send(cast.tabId, "Runtime.evaluate", { expression: SELECTION_SOURCE, returnByValue: true }).catch(() => void 0);
+    const value = answer?.result?.value;
+    const text2 = typeof value === "string" ? value.slice(0, MAX_COPY) : "";
+    return { observation: { copied: text2 } };
+  }
+  /**
+   * Capture, for the owner's Files: the tab's viewport as a PNG, at its own
+   * size, with every password field painted over first and uncovered after.
+   * Whoever holds the page; not one of the agent's steps, and nothing about it
+   * is evidence.
+   */
+  async #capture(sessionName, cancel) {
+    const session = await this.#session(sessionName);
+    const cast = this.#casts.get(sessionName);
+    const tabId = cast?.tabId ?? (await this.#ownTab(session, this.#activeKey(session))).id;
+    const tab = await this.#chrome.tabs.get(tabId).catch(() => void 0);
+    if (!tab) throw new PreconditionError("That tab is gone.");
+    this.#liveUrl(tab);
+    cancel.check();
+    await this.#chrome.scripting.executeScript({ target: { tabId, allFrames: true }, func: maskPasswords, args: [true] }).catch(() => void 0);
+    try {
+      const png = await this.#withDebugger(tabId, async (send) => {
+        await send("Emulation.setFocusEmulationEnabled", { enabled: true }).catch(() => void 0);
+        try {
+          const shot = await send("Page.captureScreenshot", { format: "png", captureBeyondViewport: false });
+          return shot?.data ?? null;
+        } finally {
+          if (!this.#castsByTab.has(tabId)) await send("Emulation.setFocusEmulationEnabled", { enabled: false }).catch(() => void 0);
+        }
+      });
+      if (!png) throw new Error("Chrome did not hand over a picture of that tab.");
+      return { screenshot: png, observation: { url: tab.url ?? "", title: tab.title ?? "" } };
+    } finally {
+      await this.#chrome.scripting.executeScript({ target: { tabId, allFrames: true }, func: maskPasswords, args: [false] }).catch(() => void 0);
+    }
+  }
   async #click(command, cancel) {
     const { ref, tab } = await this.#aim(command, cancel);
     const { point } = await this.#locate(ref);
@@ -1760,11 +2302,11 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
       await this.#chrome.scripting.executeScript({ target: { tabId: ref.tabId, frameIds: [ref.frameId] }, func: clickRef, args: [ref.local] });
       return {};
     }
-    await this.#withDebugger(ref.tabId, async (send2) => {
+    await this.#withDebugger(ref.tabId, async (send) => {
       const base = { x: point.x, y: point.y, button: "left", clickCount: 1, buttons: 1 };
-      await send2("Input.dispatchMouseEvent", { ...base, type: "mouseMoved", buttons: 0 });
-      await send2("Input.dispatchMouseEvent", { ...base, type: "mousePressed" });
-      await send2("Input.dispatchMouseEvent", { ...base, type: "mouseReleased" });
+      await send("Input.dispatchMouseEvent", { ...base, type: "mouseMoved", buttons: 0 });
+      await send("Input.dispatchMouseEvent", { ...base, type: "mousePressed" });
+      await send("Input.dispatchMouseEvent", { ...base, type: "mouseReleased" });
     });
     await this.#settle(ref.tabId, tab);
     return {};
@@ -1779,7 +2321,7 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
       await this.#chrome.scripting.executeScript({ target: { tabId: ref.tabId, frameIds: [ref.frameId] }, func: typeRef, args: [ref.local, value] });
       return {};
     }
-    await this.#withDebugger(ref.tabId, (send2) => send2("Input.insertText", { text: value }));
+    await this.#withDebugger(ref.tabId, (send) => send("Input.insertText", { text: value }));
     return {};
   }
   /* ---- the owner's secret: one read to aim it, one write that delivers it ---- */
@@ -1841,7 +2383,7 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
       await this.#chrome.scripting.executeScript({ target: { tabId: ref.tabId, frameIds: [ref.frameId] }, func: typeRef, args: [ref.local, value] });
       return {};
     }
-    await this.#withDebugger(ref.tabId, (send2) => send2("Input.insertText", { text: value }));
+    await this.#withDebugger(ref.tabId, (send) => send("Input.insertText", { text: value }));
     return {};
   }
   async #press(command, cancel) {
@@ -1856,10 +2398,10 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
       await this.#chrome.scripting.executeScript({ target: { tabId: ref.tabId, frameIds: [ref.frameId] }, func: pressRef, args: [ref.local, descriptor.key, descriptor.code, descriptor.keyCode] });
       return {};
     }
-    await this.#withDebugger(ref.tabId, async (send2) => {
+    await this.#withDebugger(ref.tabId, async (send) => {
       const common = { key: descriptor.key, code: descriptor.code, windowsVirtualKeyCode: descriptor.keyCode, nativeVirtualKeyCode: descriptor.keyCode };
-      await send2("Input.dispatchKeyEvent", { ...common, type: descriptor.text ? "keyDown" : "rawKeyDown", ...descriptor.text ? { text: descriptor.text } : {} });
-      await send2("Input.dispatchKeyEvent", { ...common, type: "keyUp" });
+      await send("Input.dispatchKeyEvent", { ...common, type: descriptor.text ? "keyDown" : "rawKeyDown", ...descriptor.text ? { text: descriptor.text } : {} });
+      await send("Input.dispatchKeyEvent", { ...common, type: "keyUp" });
     });
     await this.#settle(ref.tabId, tab);
     return {};
@@ -1873,264 +2415,173 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
       func: chooseRef,
       args: [ref.local, value]
     });
-    if (!frame?.result?.ok) throw new PreconditionError(frame?.result?.reason ?? "That option is not in the list.");
-    return {};
-  }
-  /**
-   * Scroll names no element, so what it checks instead is the observation: the
-   * page the model is reading has to be the page still in the tab.
-   */
-  async #scroll(command, cancel) {
-    const session = await this.#session(command.session);
-    const observed = session.observed;
-    if (!observed || observed.generation !== session.generation) throw new PreconditionError("Stale page observation. Observe again before scrolling.");
-    const tab = await this.#ownTab(session, observed.tabKey);
-    if (this.#liveUrl(tab) !== observed.url) throw new PreconditionError(MOVED);
-    await this.#background(tab, command);
-    const tabId = tab.id;
-    const direction = str(command.args, "direction") === "up" ? "up" : "down";
-    cancel.check();
-    await this.#inject(tabId);
-    cancel.check();
-    cancel.dispatch();
-    await this.#chrome.scripting.executeScript({ target: { tabId }, func: scrollPage, args: [direction] });
-    return {};
-  }
-  async #screenshot(sessionId, cancel) {
-    const session = await this.#session(sessionId);
-    const tab = await this.#ownTab(session, this.#activeKey(session));
-    this.#liveUrl(tab);
-    const tabId = tab.id;
-    cancel.check();
-    return this.#withDebugger(tabId, async (send2) => {
-      const shot = await send2("Page.captureScreenshot", { format: "png", captureBeyondViewport: false });
-      return shot?.data ?? null;
-    }).catch(() => null);
-  }
-};
-function readReadyState() {
-  return document.readyState;
-}
-function readObservation() {
-  const api = globalThis["__buddiBrowser"];
-  return api ? api.observe() : null;
-}
-function locateRef(ref, options) {
-  const api = globalThis["__buddiBrowser"];
-  return api ? api.locate(ref, options) : { ok: false, reason: "The page was reloaded. Observe again." };
-}
-function chooseRef(ref, value) {
-  const api = globalThis["__buddiBrowser"];
-  return api ? api.choose(ref, value) : { ok: false, reason: "The page was reloaded. Observe again." };
-}
-function scrollPage(direction) {
-  const api = globalThis["__buddiBrowser"];
-  api?.scroll(direction);
-}
-function clickRef(ref) {
-  const api = globalThis["__buddiBrowser"];
-  api?.locate(ref, {});
-  const holder = globalThis["__buddiBrowserRegistry"];
-  const element = holder?.refs.get(ref)?.deref();
-  element?.click();
-}
-function typeRef(ref, value) {
-  const holder = globalThis["__buddiBrowserRegistry"];
-  const element = holder?.refs.get(ref)?.deref();
-  if (!element) return;
-  element.value = value;
-  element.dispatchEvent(new Event("input", { bubbles: true }));
-  element.dispatchEvent(new Event("change", { bubbles: true }));
-}
-function readFieldRef(ref) {
-  const api = globalThis["__buddiBrowser"];
-  const located = api?.locate(ref, {});
-  if (!located?.ok) return { ok: false, reason: located?.reason ?? "The referenced element changed or disappeared." };
-  return { ok: true, origin: location.origin, password: located.password === true, name: located.name ?? "" };
-}
-function prepareSecretRef(ref, expectedOrigin) {
-  const api = globalThis["__buddiBrowser"];
-  const located = api?.locate(ref, {});
-  if (!located?.ok) return { ok: false, reason: located?.reason ?? "The referenced element changed or disappeared." };
-  const origin = location.origin;
-  if (origin !== expectedOrigin) return { ok: false, reason: "The page moved since the owner approved this fill. Nothing was entered." };
-  const holder = globalThis["__buddiBrowserRegistry"];
-  const element = holder?.refs.get(ref)?.deref();
-  if (!element || !element.isConnected) return { ok: false, reason: "The referenced element changed or disappeared." };
-  if ("focus" in element) element.focus();
-  const input = element;
-  if ("value" in input) {
-    input.value = "";
-    input.dispatchEvent(new Event("input", { bubbles: true }));
-  }
-  return { ok: true, origin, password: located.password === true };
-}
-function pressRef(ref, key, code, keyCode) {
-  const holder = globalThis["__buddiBrowserRegistry"];
-  const element = holder?.refs.get(ref)?.deref();
-  if (!element) return;
-  for (const type of ["keydown", "keypress", "keyup"]) {
-    element.dispatchEvent(new KeyboardEvent(type, { key, code, keyCode, bubbles: true, cancelable: true }));
-  }
-}
-function heldLoginFacts(raw) {
-  if (!raw || typeof raw !== "object") return void 0;
-  const { never, saved } = raw;
-  const sites = Array.isArray(never) ? never.filter((site) => typeof site === "string" && site.length <= 253).slice(0, 500) : [];
-  const kept = Array.isArray(saved) ? saved.filter((login) => typeof login?.site === "string" && typeof login?.username === "string").slice(0, 500).map(({ site, username }) => ({ site, username })) : [];
-  return { never: sites, saved: kept };
-}
-
-// src/downloads.ts
-var DOWNLOAD_GRACE_MS = 15e3;
-var DOWNLOADS_PERMISSION = "downloads";
-function originOf(url) {
-  if (!url) return void 0;
-  try {
-    const parsed = new URL(url);
-    if (parsed.protocol === "blob:") return new URL(parsed.pathname).origin;
-    return parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed.origin : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function basename(file) {
-  return file.split(/[\\/]/).pop() || "download";
-}
-var AgentDownloads = class {
-  #actions = /* @__PURE__ */ new Map();
-  #next = 1;
-  #claimed = /* @__PURE__ */ new Map();
-  #api;
-  #send;
-  #now;
-  constructor(options) {
-    this.#send = options.send;
-    this.#now = options.now ?? (() => Date.now());
-  }
-  /** Chrome's downloads API, once the owner granted it. Listening starts here, once. */
-  attach(api) {
-    if (!api || this.#api) return;
-    this.#api = api;
-    api.onCreated.addListener((item) => this.created(item));
-    api.onChanged.addListener((delta) => {
-      void this.changed(delta).catch(() => void 0);
-    });
-  }
-  get attached() {
-    return this.#api !== void 0;
-  }
-  /** An agent command starts in this session, whose tabs are on these addresses. Returns the command's handle for `end`. */
-  begin(session, urls) {
-    this.#expire();
-    const id = this.#next++;
-    const origins = /* @__PURE__ */ new Set();
-    for (const url of urls) {
-      const origin = originOf(url);
-      if (origin) origins.add(origin);
-    }
-    this.#actions.set(id, { session, origins, running: true, until: 0, at: this.#now() });
-    return id;
-  }
-  /** That command ended; its tabs may have moved on to these. Its downloads still count for a few seconds, its own. */
-  end(id, urls = []) {
-    const action = this.#actions.get(id);
-    if (!action) return;
-    for (const url of urls) {
-      const origin = originOf(url);
-      if (origin) action.origins.add(origin);
-    }
-    action.running = false;
-    action.until = this.#now() + DOWNLOAD_GRACE_MS;
-  }
-  /** Commands whose few seconds are over count for nothing any more. */
-  #expire() {
-    const now = this.#now();
-    for (const [id, action] of this.#actions) if (!action.running && now > action.until) this.#actions.delete(id);
-  }
-  /** The session ended or the socket went: nothing more is its. */
-  forget(session) {
-    if (session === void 0) {
-      this.#actions.clear();
-      this.#claimed.clear();
-      return;
-    }
-    for (const [id, action] of this.#actions) if (action.session === session) this.#actions.delete(id);
-    for (const [id, owner] of this.#claimed) if (owner === session) this.#claimed.delete(id);
-  }
-  /** Which session's command this download belongs to, if any. */
-  #owner(item) {
-    if (item.byExtensionId) return void 0;
-    const origin = originOf(item.referrer) ?? originOf(item.finalUrl ?? item.url);
-    if (!origin) return void 0;
-    this.#expire();
-    let best;
-    for (const action of this.#actions.values()) {
-      if (!action.origins.has(origin)) continue;
-      if (!best || action.at > best.at) best = action;
-    }
-    return best?.session;
-  }
-  created(item) {
-    const session = this.#owner(item);
-    if (session) this.#claimed.set(item.id, session);
-  }
-  async changed(delta) {
-    const session = this.#claimed.get(delta.id);
-    const state = delta.state?.current;
-    if (!session || !state) return;
-    if (state === "interrupted") {
-      this.#claimed.delete(delta.id);
-      return;
-    }
-    if (state !== "complete") return;
-    this.#claimed.delete(delta.id);
-    const [item] = await (this.#api?.search({ id: delta.id }) ?? Promise.resolve([]));
-    if (!item?.filename) return;
-    const url = item.finalUrl || item.url || "";
-    const size = item.fileSize !== void 0 && item.fileSize >= 0 ? item.fileSize : item.totalBytes !== void 0 && item.totalBytes >= 0 ? item.totalBytes : void 0;
-    this.#send({
-      type: "download",
-      session,
-      path: item.filename,
-      filename: basename(item.filename),
-      url,
-      ...item.mime ? { mime: item.mime } : {},
-      ...size !== void 0 ? { size } : {}
-    });
+    if (!frame?.result?.ok) throw new PreconditionError(frame?.result?.reason ?? "That option is not in the list.");
+    return {};
+  }
+  /**
+   * Scroll names no element, so what it checks instead is the observation: the
+   * page the model is reading has to be the page still in the tab.
+   */
+  async #scroll(command, cancel) {
+    const session = await this.#session(command.session);
+    const observed = session.observed;
+    if (!observed || observed.generation !== session.generation) throw new PreconditionError("Stale page observation. Observe again before scrolling.");
+    const tab = await this.#ownTab(session, observed.tabKey);
+    if (this.#liveUrl(tab) !== observed.url) throw new PreconditionError(MOVED);
+    await this.#background(tab, command);
+    const tabId = tab.id;
+    const direction = str(command.args, "direction") === "up" ? "up" : "down";
+    cancel.check();
+    await this.#inject(tabId);
+    cancel.check();
+    cancel.dispatch();
+    await this.#chrome.scripting.executeScript({ target: { tabId }, func: scrollPage, args: [direction] });
+    return {};
+  }
+  async #screenshot(sessionId, cancel) {
+    const session = await this.#session(sessionId);
+    const tab = await this.#ownTab(session, this.#activeKey(session));
+    this.#liveUrl(tab);
+    const tabId = tab.id;
+    cancel.check();
+    return this.#withDebugger(tabId, async (send) => {
+      const shot = await send("Page.captureScreenshot", { format: "png", captureBeyondViewport: false });
+      return shot?.data ?? null;
+    }).catch(() => null);
   }
 };
-
-// src/external.ts
-function isLoopbackOrigin(origin) {
-  if (!origin) return false;
-  let parsed;
-  try {
-    parsed = new URL(origin);
-  } catch {
-    return false;
+var SELECTION_SOURCE = `(() => {
+  const active = document.activeElement;
+  if (active && (active.tagName === 'INPUT' || active.tagName === 'TEXTAREA')) {
+    if (active.tagName === 'INPUT' && String(active.type).toLowerCase() === 'password') return '';
+    const start = active.selectionStart, end = active.selectionEnd;
+    if (typeof start === 'number' && typeof end === 'number' && end > start) return String(active.value).slice(start, end).slice(0, ${MAX_COPY});
+  }
+  const selection = window.getSelection();
+  return selection ? String(selection).slice(0, ${MAX_COPY}) : '';
+})()`;
+function maskPasswords(on) {
+  const id = "buddi-capture-mask";
+  document.getElementById(id)?.remove();
+  if (!on) return;
+  const style = document.createElement("style");
+  style.id = id;
+  style.textContent = "input[type=password]{background:#c3d0e3 !important;color:transparent !important;-webkit-text-fill-color:transparent !important;text-shadow:none !important;caret-color:transparent !important;}";
+  (document.head ?? document.documentElement).appendChild(style);
+}
+function readReadyState() {
+  return document.readyState;
+}
+function readObservation() {
+  const api = globalThis["__buddiBrowser"];
+  return api ? api.observe() : null;
+}
+function locateRef(ref, options) {
+  const api = globalThis["__buddiBrowser"];
+  return api ? api.locate(ref, options) : { ok: false, reason: "The page was reloaded. Observe again." };
+}
+function chooseRef(ref, value) {
+  const api = globalThis["__buddiBrowser"];
+  return api ? api.choose(ref, value) : { ok: false, reason: "The page was reloaded. Observe again." };
+}
+function scrollPage(direction) {
+  const api = globalThis["__buddiBrowser"];
+  api?.scroll(direction);
+}
+function clickRef(ref) {
+  const api = globalThis["__buddiBrowser"];
+  api?.locate(ref, {});
+  const holder = globalThis["__buddiBrowserRegistry"];
+  const element = holder?.refs.get(ref)?.deref();
+  element?.click();
+}
+function typeRef(ref, value) {
+  const holder = globalThis["__buddiBrowserRegistry"];
+  const element = holder?.refs.get(ref)?.deref();
+  if (!element) return;
+  element.value = value;
+  element.dispatchEvent(new Event("input", { bubbles: true }));
+  element.dispatchEvent(new Event("change", { bubbles: true }));
+}
+function readFieldRef(ref) {
+  const api = globalThis["__buddiBrowser"];
+  const located = api?.locate(ref, {});
+  if (!located?.ok) return { ok: false, reason: located?.reason ?? "The referenced element changed or disappeared." };
+  return { ok: true, origin: location.origin, password: located.password === true, name: located.name ?? "" };
+}
+function prepareSecretRef(ref, expectedOrigin) {
+  const api = globalThis["__buddiBrowser"];
+  const located = api?.locate(ref, {});
+  if (!located?.ok) return { ok: false, reason: located?.reason ?? "The referenced element changed or disappeared." };
+  const origin = location.origin;
+  if (origin !== expectedOrigin) return { ok: false, reason: "The page moved since the owner approved this fill. Nothing was entered." };
+  const holder = globalThis["__buddiBrowserRegistry"];
+  const element = holder?.refs.get(ref)?.deref();
+  if (!element || !element.isConnected) return { ok: false, reason: "The referenced element changed or disappeared." };
+  if ("focus" in element) element.focus();
+  const input = element;
+  if ("value" in input) {
+    input.value = "";
+    input.dispatchEvent(new Event("input", { bubbles: true }));
   }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
-  return ["127.0.0.1", "localhost", "[::1]", "::1"].includes(parsed.hostname);
+  return { ok: true, origin, password: located.password === true };
 }
-function describe(state, gateway2, version) {
-  const named = state.connection === "paired" ? "paired" : state.connection === "pairing" ? "pairing" : "disconnected";
-  const status = { installed: true, version, state: named, gateway: gateway2 };
-  if (named === "pairing" && state.code) status.code = state.code;
-  return status;
+function pressRef(ref, key, code, keyCode) {
+  const holder = globalThis["__buddiBrowserRegistry"];
+  const element = holder?.refs.get(ref)?.deref();
+  if (!element) return;
+  for (const type of ["keydown", "keypress", "keyup"]) {
+    element.dispatchEvent(new KeyboardEvent(type, { key, code, keyCode, bubbles: true, cancelable: true }));
+  }
 }
-function handleExternal(message, context, respond) {
-  if (!isLoopbackOrigin(context.origin)) return false;
-  const request = message;
-  if (!request || request.type !== "buddi.status") return false;
-  void context.gateway().then((address) => respond(describe(context.state(), address, context.version)));
-  return true;
+function heldLoginFacts(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const { never, saved } = raw;
+  const sites = Array.isArray(never) ? never.filter((site) => typeof site === "string" && site.length <= 253).slice(0, 500) : [];
+  const kept = Array.isArray(saved) ? saved.filter((login) => typeof login?.site === "string" && typeof login?.username === "string").slice(0, 500).map(({ site, username }) => ({ site, username })) : [];
+  return { never: sites, saved: kept };
 }
 
-// src/background.ts
-var DEFAULT_GATEWAY = "http://127.0.0.1:4317";
-var GATEWAY_KEY = "gateway";
-var MAX_BACKOFF = 3e4;
+// src/frames.ts
+var BINARY_FRAMES = "frames.binary";
+var VERSION = 1;
+var MAX_HEADER = 8 * 1024;
+var encoder2 = new TextEncoder();
+var decoder = new TextDecoder();
+function base64Bytes(data) {
+  const binary = atob(data);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function packFrame(header, jpeg) {
+  const head = encoder2.encode(JSON.stringify(header));
+  if (head.length > MAX_HEADER) throw new Error("A frame header that long is not a frame header.");
+  const out = new Uint8Array(3 + head.length + jpeg.length);
+  out[0] = VERSION;
+  out[1] = head.length >> 8 & 255;
+  out[2] = head.length & 255;
+  out.set(head, 3);
+  out.set(jpeg, 3 + head.length);
+  return out;
+}
+
+// src/link.ts
+var BACKOFF_MS = [1e3, 2e3, 5e3, 1e4, 2e4, 3e4];
+var REPAIR_GAP_MS = 3e4;
+var NO_ANSWER2 = "buddi did not answer at this address. Is it running?";
+var OTHER_BROWSER = "This buddi is paired with another copy of the extension (the Chrome Web Store one, or another unpacked one). In its Settings \u2192 Browser & apps choose Pair again, then press Try again here.";
+var TURNED_AWAY = "buddi is running at this address but turned this browser away. Update buddi, then press Try again.";
+function readClose(code, reason) {
+  const said = reason.trim();
+  if (/paired with another browser/i.test(said)) return { kind: "refused", message: OTHER_BROWSER };
+  if (/token is not this buddi/i.test(said)) return { kind: "repair", message: "This buddi no longer knows this browser. Asking it for a new code." };
+  if (/forgot its browser/i.test(said)) return { kind: "repair", message: "This buddi forgot this browser. Asking it for a new code." };
+  if (code === 1008 && !/too many pairing requests|one hello per connection/i.test(said)) {
+    return { kind: "refused", message: said ? `This buddi turned this browser away: ${said}. Press Try again.` : TURNED_AWAY };
+  }
+  return { kind: "retry", message: said ? `buddi closed the connection (${said}). Trying again shortly.` : "buddi closed the connection. Trying again shortly." };
+}
 var KNOCK_MS = 3e3;
 var SILENCE = 7e4;
 var KEEPALIVE_MS = 2e4;
@@ -2148,136 +2599,321 @@ function safely(work) {
     console.warn(LOST);
   }
 }
-var socket;
 var DURABLE = /* @__PURE__ */ new Set(["hello", "auth", "result"]);
-var pending = [];
 var frameType = (frame) => frame && typeof frame === "object" ? String(frame.type ?? "") : "";
-var send = (frame) => {
-  const live = socket;
-  const text2 = JSON.stringify(frame);
-  if (live && live.readyState === WebSocket.OPEN) {
+var Link = class {
+  id;
+  origin;
+  commands;
+  protocol;
+  downloads;
+  #options;
+  #socket;
+  /** Text frames waiting for the socket that is still connecting; discarded if it never opens. */
+  #pending = [];
+  #attempt = 0;
+  #timer;
+  #silence;
+  #keepalive;
+  #last = { connection: "offline", code: null, installation: null, error: null };
+  /** The tail of the frame queue: every frame waits for the one before it. */
+  #incoming = Promise.resolve();
+  /** Switched off or removed: no reconnects, nothing sent. */
+  #disposed = false;
+  /** Turned away by the buddi: no reconnects until the owner presses Try again (or pairs again). */
+  #halted = false;
+  /** Why this side closed the socket, when it did. */
+  #closing;
+  #lastRepair = -Infinity;
+  constructor(options) {
+    this.#options = options;
+    this.id = options.id;
+    this.origin = options.origin;
+    this.downloads = new AgentDownloads({ send: (frame) => this.send(frame) });
+    this.commands = new BrowserCommands(options.chrome, {
+      // Screencast frames are not answers to anything: they arrive while the
+      // agent or the owner is driving and go straight out, outside the
+      // command/result pairing.
+      onFrame: (frame) => this.sendFrame(frame),
+      onEvent: (event) => this.send(event),
+      onLogin: (frame) => this.send(frame),
+      downloads: this.downloads,
+      instance: options.id,
+      groups: options.groups,
+      groupTitle: options.title,
+      groupColour: options.colour
+    });
+    this.protocol = new Protocol({
+      tokens: options.store.tokens(options.id),
+      version: options.version,
+      send: (frame) => this.send(frame),
+      execute: (command, cancel) => this.commands.run(command, cancel),
+      // The socket ended: sessions and refs go with it. The tabs do not.
+      onReset: () => this.commands.reset(),
+      onLoginAck: (id, answer) => this.commands.logins.ack(id, answer),
+      onState: (state) => {
+        if (state.connection === "paired") this.#attempt = 0;
+        const named2 = state.name && state.name !== this.#last.name ? state.name : null;
+        this.#last = state;
+        if (named2) {
+          this.#options.onName?.(this.id, named2);
+          safely(() => this.commands.retitle());
+        }
+        this.#options.onState?.(this.id, state);
+      },
+      disconnect: (reason) => {
+        this.#closing = reason;
+        this.#socket?.close();
+      }
+    });
+  }
+  state() {
+    return { ...this.#last };
+  }
+  attachDownloads(api) {
+    if (api) this.downloads.attach(api);
+  }
+  get #WebSocket() {
+    return this.#options.WebSocket ?? WebSocket;
+  }
+  /**
+   * One way out for everything this link says, so a frame and a result travel
+   * the same socket.
+   *
+   * A socket that is still CONNECTING throws on `send`, and the worker reconnects
+   * often enough — an alarm, a pong, a screencast that outlived the last socket —
+   * that something always arrives early. So this is the only place that decides:
+   * send it, queue it, or let it go.
+   */
+  send(frame) {
+    const live = this.#socket;
+    const text2 = JSON.stringify(frame);
+    const Socket = this.#WebSocket;
+    if (live && live.readyState === Socket.OPEN) {
+      try {
+        live.send(text2);
+      } catch {
+      }
+      return;
+    }
+    if (live && live.readyState === Socket.CONNECTING && DURABLE.has(frameType(frame))) this.#pending.push(text2);
+  }
+  /**
+   * A screencast frame: as bytes to a gateway that said it reads them (the
+   * picture, without base64 inside JSON), as the old JSON frame otherwise.
+   * Never queued: a frame that missed its socket is stale.
+   */
+  sendFrame(frame) {
+    const live = this.#socket;
+    if (!live || live.readyState !== this.#WebSocket.OPEN) return;
+    if (!(this.#last.features ?? []).includes(BINARY_FRAMES)) {
+      this.send(frame);
+      return;
+    }
     try {
-      live.send(text2);
+      const bytes = packFrame({ session: frame.session, ...frame.metadata, ...frame.url ? { url: frame.url } : {} }, base64Bytes(frame.data));
+      live.send(bytes);
     } catch {
     }
-    return;
   }
-  if (live && live.readyState === WebSocket.CONNECTING && DURABLE.has(frameType(frame))) pending.push(text2);
-};
-function flush(open) {
-  const queued = pending;
-  pending = [];
-  for (const text2 of queued) {
-    if (open.readyState !== WebSocket.OPEN) return;
+  /** Everything that waited for this socket, in the order it was said. */
+  #flush(open) {
+    const queued = this.#pending;
+    this.#pending = [];
+    for (const text2 of queued) {
+      if (open.readyState !== this.#WebSocket.OPEN) return;
+      try {
+        open.send(text2);
+      } catch {
+        return;
+      }
+    }
+  }
+  #quiet() {
+    if (this.#silence) clearTimeout(this.#silence);
+    this.#silence = setTimeout(() => this.#socket?.close(), SILENCE);
+  }
+  /** Connect now, unless a socket is already open or opening. */
+  async connect() {
+    if (this.#disposed || this.#halted) return;
+    const Socket = this.#WebSocket;
+    const socket = this.#socket;
+    if (socket && (socket.readyState === Socket.OPEN || socket.readyState === Socket.CONNECTING)) return;
+    if (this.#timer) {
+      clearTimeout(this.#timer);
+      this.#timer = void 0;
+    }
+    this.#socket = void 0;
+    this.#pending = [];
+    this.commands.reset();
+    let url;
     try {
-      open.send(text2);
-    } catch {
+      url = socketUrl(this.origin);
+    } catch (error) {
+      this.protocol.closed(error instanceof Error ? error.message : String(error));
+      return;
+    }
+    if (this.#attempt > 0 && !await answering(url)) {
+      if (this.#disposed) return;
+      this.protocol.closed(NO_ANSWER2);
+      this.#schedule();
       return;
     }
+    if (this.#disposed) return;
+    let opened = false;
+    this.#closing = void 0;
+    const opening = new Socket(url);
+    opening.binaryType = "arraybuffer";
+    this.#socket = opening;
+    opening.addEventListener("open", () => {
+      opened = true;
+      this.#quiet();
+      this.#flush(opening);
+      if (this.#keepalive) clearInterval(this.#keepalive);
+      this.#keepalive = setInterval(() => {
+        if (this.#socket === opening) this.send({ type: "keepalive" });
+      }, KEEPALIVE_MS);
+      safely(() => this.protocol.open());
+    });
+    opening.addEventListener("message", (event) => {
+      this.#quiet();
+      const text2 = String(event.data);
+      this.#incoming = this.#incoming.then(() => this.protocol.receive(text2)).catch(() => {
+        console.warn(LOST);
+      });
+    });
+    opening.addEventListener("error", () => {
+      if (this.#socket === opening) this.#pending = [];
+    });
+    opening.addEventListener("close", (event) => {
+      if (this.#socket !== opening) return;
+      this.#socket = void 0;
+      this.#pending = [];
+      if (this.#keepalive) {
+        clearInterval(this.#keepalive);
+        this.#keepalive = void 0;
+      }
+      if (this.#silence) {
+        clearTimeout(this.#silence);
+        this.#silence = void 0;
+      }
+      if (this.#disposed) return;
+      const closing = this.#closing;
+      this.#closing = void 0;
+      const { code = 1005, reason = "" } = event ?? {};
+      safely(() => this.#closed(opened, closing, code, reason));
+    });
   }
-}
-var downloads = new AgentDownloads({ send });
-var attachDownloads = () => {
-  if (chrome.downloads) downloads.attach(chrome.downloads);
-};
-attachDownloads();
-chrome.permissions?.onAdded?.addListener((added) => {
-  if (added.permissions?.includes(DOWNLOADS_PERMISSION)) attachDownloads();
-});
-var commands = new BrowserCommands(chrome, { onFrame: send, onEvent: send, onLogin: send, downloads });
-var attempt = 0;
-var timer;
-var silence;
-var keepalive;
-var last = { connection: "offline", code: null, installation: null, error: null };
-var incoming = Promise.resolve();
-var protocol = new Protocol({
-  chrome,
-  version: chrome.runtime.getManifest().version,
-  send,
-  execute: (command, cancel) => commands.run(command, cancel),
-  // The socket ended: sessions and refs go with it. The tabs do not.
-  onReset: () => commands.reset(),
-  onLoginAck: (id, answer) => commands.logins.ack(id, answer),
-  onState: (state) => {
-    last = state;
-    safely(() => chrome.runtime.sendMessage({ type: "buddi-state", state }).catch(() => void 0));
-  },
-  disconnect: () => socket?.close()
-});
-async function gateway() {
-  const stored = await chrome.storage.local.get([GATEWAY_KEY]);
-  const address = stored[GATEWAY_KEY];
-  return typeof address === "string" && address ? address : DEFAULT_GATEWAY;
-}
-function quiet() {
-  if (silence) clearTimeout(silence);
-  silence = setTimeout(() => socket?.close(), SILENCE);
-}
-async function connect() {
-  if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) return;
-  if (timer) {
-    clearTimeout(timer);
-    timer = void 0;
-  }
-  socket = void 0;
-  pending = [];
-  commands.reset();
-  let url;
-  try {
-    url = socketUrl(await gateway());
-  } catch (error) {
-    protocol.closed(error instanceof Error ? error.message : String(error));
-    return;
+  /**
+   * What a closed socket means, said once, and what happens next. A socket
+   * that never opened is a buddi that did not answer, unless something on
+   * that port did answer the knock and turned the socket away. One that
+   * opened was answered: the buddi's own close reason decides.
+   */
+  async #closed(opened, closing, code, reason) {
+    if (this.#socket) return;
+    if (closing === PAIR_AGAIN) {
+      await this.#repair("That buddi does not know this browser any more. Asking it for a new code.");
+      return;
+    }
+    if (!opened) {
+      const knocked = await answering(socketUrl(this.origin)).catch(() => false);
+      if (this.#disposed || this.#socket) return;
+      if (knocked) {
+        this.#halt(TURNED_AWAY);
+        return;
+      }
+      this.protocol.closed(NO_ANSWER2);
+      this.#schedule();
+      return;
+    }
+    const read = readClose(code, reason);
+    if (read.kind === "refused") {
+      this.#halt(read.message);
+      return;
+    }
+    if (read.kind === "repair") {
+      await this.protocol.dropToken().catch(() => void 0);
+      await this.#repair(read.message);
+      return;
+    }
+    this.protocol.closed(read.message);
+    this.#schedule();
+  }
+  /** Stop knocking and say why, until the owner presses Try again. */
+  #halt(message) {
+    this.#halted = true;
+    if (this.#timer) {
+      clearTimeout(this.#timer);
+      this.#timer = void 0;
+    }
+    this.protocol.closed(message, { refused: true });
   }
-  if (attempt > 0 && !await answering(url)) {
-    protocol.closed("buddi did not answer at this address. Is it running?");
-    schedule();
-    return;
+  /** Start over at once with no token, which asks the buddi for a code; at most once in a while. */
+  async #repair(message) {
+    const now = Date.now();
+    this.protocol.closed(message);
+    if (now - this.#lastRepair < REPAIR_GAP_MS) {
+      this.#schedule();
+      return;
+    }
+    this.#lastRepair = now;
+    this.#attempt = 0;
+    await this.connect();
   }
-  const opening = new WebSocket(url);
-  socket = opening;
-  opening.addEventListener("open", () => {
-    attempt = 0;
-    quiet();
-    flush(opening);
-    if (keepalive) clearInterval(keepalive);
-    keepalive = setInterval(() => {
-      if (socket === opening) send({ type: "keepalive" });
-    }, KEEPALIVE_MS);
-    safely(() => protocol.open());
-  });
-  opening.addEventListener("message", (event) => {
-    quiet();
-    const text2 = String(event.data);
-    incoming = incoming.then(() => protocol.receive(text2)).catch(() => {
-      console.warn(LOST);
-    });
-  });
-  opening.addEventListener("error", () => {
-    if (socket === opening) pending = [];
-  });
-  opening.addEventListener("close", () => {
-    if (socket === opening) {
-      socket = void 0;
-      pending = [];
-      if (keepalive) {
-        clearInterval(keepalive);
-        keepalive = void 0;
-      }
+  /** The owner pressed Connect or Try again: start over at once. */
+  async retry() {
+    this.#halted = false;
+    this.#attempt = 0;
+    this.#socket?.close();
+    await this.connect();
+  }
+  /** Drop the token and pair again from a fresh code. */
+  forget() {
+    return this.protocol.forget();
+  }
+  /**
+   * Switched off or removed in the popup: the socket closes and stays closed,
+   * the sessions and their refs go. The tabs stay; they are the owner's.
+   */
+  dispose() {
+    this.#disposed = true;
+    if (this.#timer) {
+      clearTimeout(this.#timer);
+      this.#timer = void 0;
     }
-    if (silence) {
-      clearTimeout(silence);
-      silence = void 0;
+    if (this.#keepalive) {
+      clearInterval(this.#keepalive);
+      this.#keepalive = void 0;
     }
-    protocol.closed("buddi did not answer at this address. Is it running?");
-    schedule();
-  });
-}
-async function answering(socket2) {
+    if (this.#silence) {
+      clearTimeout(this.#silence);
+      this.#silence = void 0;
+    }
+    const socket = this.#socket;
+    this.#socket = void 0;
+    this.#pending = [];
+    try {
+      socket?.close();
+    } catch {
+    }
+    this.protocol.closed();
+    this.commands.reset();
+  }
+  #schedule() {
+    if (this.#timer || this.#disposed || this.#halted) return;
+    const wait = BACKOFF_MS[Math.min(this.#attempt, BACKOFF_MS.length - 1)];
+    this.#attempt += 1;
+    this.#timer = setTimeout(() => {
+      this.#timer = void 0;
+      safely(() => this.connect());
+    }, wait);
+  }
+};
+async function answering(socket) {
   let http;
   try {
-    http = new URL(socket2);
+    http = new URL(socket);
     http.protocol = http.protocol === "wss:" ? "https:" : "http:";
     http.pathname = "/api/version";
     http.search = "";
@@ -2291,25 +2927,109 @@ async function answering(socket2) {
     return false;
   }
 }
-function schedule() {
-  if (timer) return;
-  const wait = Math.min(MAX_BACKOFF, 1e3 * 2 ** Math.min(attempt, 5));
-  attempt += 1;
-  timer = setTimeout(() => {
-    timer = void 0;
-    safely(() => connect());
-  }, wait);
+
+// src/background.ts
+var store = new PairingStore(chrome.storage.local);
+var groups = new GroupRegistry();
+var links = /* @__PURE__ */ new Map();
+var entries = [];
+var asked = null;
+var version = chrome.runtime.getManifest().version;
+function entryOf(id) {
+  return entries.find((entry) => entry.id === id);
+}
+function pushState() {
+  safely(() => chrome.runtime.sendMessage({ type: "buddi-state" }).catch(() => void 0));
+}
+function linkFor(entry) {
+  const link = new Link({
+    chrome,
+    id: entry.id,
+    origin: entry.origin,
+    store,
+    groups,
+    version,
+    title: () => {
+      const current = entryOf(entry.id);
+      return current ? displayName(current, entries) : "buddi";
+    },
+    colour: () => entryOf(entry.id)?.colour,
+    onState: () => pushState(),
+    onName: (id, name) => safely(async () => {
+      await store.update(id, { name });
+      entries = await store.list();
+      pushState();
+    })
+  });
+  if (chrome.downloads) link.attachDownloads(chrome.downloads);
+  return link;
+}
+async function sync() {
+  entries = await store.list();
+  for (const [id, link] of links) {
+    const entry = entryOf(id);
+    if (!entry || !entry.enabled || !sameBuddi(entry.origin, link.origin)) {
+      link.dispose();
+      links.delete(id);
+      if (!entry) groups.release(id);
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.enabled) continue;
+    let link = links.get(entry.id);
+    if (!link) {
+      link = linkFor(entry);
+      links.set(entry.id, link);
+    }
+    await link.connect();
+  }
+}
+async function views() {
+  entries = await store.list();
+  const out = [];
+  for (const entry of entries) {
+    const link = links.get(entry.id);
+    const state = link?.state() ?? { connection: "offline", code: null, installation: null, error: null };
+    out.push({
+      id: entry.id,
+      origin: entry.origin,
+      name: displayName(entry, entries),
+      colour: entry.colour,
+      enabled: entry.enabled,
+      state,
+      tabs: link && state.connection === "paired" ? await link.commands.tabCount().catch(() => null) : null
+    });
+  }
+  return out;
+}
+function firstLink() {
+  return links.values().next().value;
+}
+chrome.permissions?.onAdded?.addListener((added) => {
+  if (added.permissions?.includes(DOWNLOADS_PERMISSION) && chrome.downloads) for (const link of links.values()) link.attachDownloads(chrome.downloads);
+});
+function holders(session) {
+  const holding = [...links.values()].filter((link) => link.commands.heldTab(session) !== void 0);
+  return holding.length > 0 ? holding : [...links.values()];
 }
 chrome.runtime.onMessage.addListener((message, sender, respond) => {
   const request = message;
   if (!request || typeof request.type !== "string") return;
   if (request.type === GIVE_BACK_MESSAGE) {
     const tabId = sender?.tab?.id;
-    if (typeof request.session === "string") safely(() => commands.giveBack(request.session, tabId).then(() => void 0));
+    const session = request.session;
+    if (typeof session === "string") safely(async () => {
+      for (const link of holders(session)) await link.commands.giveBack(session, tabId);
+    });
     return;
   }
   if (request.type === LOGIN_MESSAGE || request.type === LOGIN_SEEN_MESSAGE || request.type === LOGIN_PENDING_MESSAGE) {
-    const reply = commands.loginMessage(message, sender);
+    const from = sender;
+    let reply;
+    for (const link of links.values()) {
+      reply = link.commands.loginMessage(message, from);
+      if (reply) break;
+    }
     if (!reply) {
       respond(null);
       return;
@@ -2318,50 +3038,87 @@ chrome.runtime.onMessage.addListener((message, sender, respond) => {
     return true;
   }
   if (request.type === "buddi-get-state") {
-    respond({ state: last });
-    return;
+    safely(async () => respond({ pairings: await views(), asked }));
+    return true;
   }
-  if (request.type === "buddi-connect") {
+  if (request.type === "buddi-add" || request.type === "buddi-connect") {
     safely(async () => {
-      if (request.gateway) {
-        try {
-          socketUrl(request.gateway);
-        } catch (error) {
-          respond({ error: error instanceof Error ? error.message : String(error) });
-          return;
-        }
-        await chrome.storage.local.set({ [GATEWAY_KEY]: request.gateway });
+      let entry;
+      const before = new Set(links.keys());
+      try {
+        entry = await store.add(request.gateway?.trim() || DEFAULT_GATEWAY);
+      } catch (error) {
+        respond({ error: error instanceof Error ? error.message : String(error) });
+        return;
       }
-      attempt = 0;
-      socket?.close();
-      await connect();
-      respond({ state: last });
+      if (asked && sameBuddi(asked, entry.origin)) asked = null;
+      await sync();
+      if (before.has(entry.id)) await links.get(entry.id)?.retry();
+      respond({ pairings: await views(), added: entry.id });
+    });
+    return true;
+  }
+  if (request.type === "buddi-enable" && typeof request.id === "string") {
+    safely(async () => {
+      await store.update(request.id, { enabled: request.enabled !== false });
+      await sync();
+      respond({ pairings: await views() });
+    });
+    return true;
+  }
+  if (request.type === "buddi-retry" && typeof request.id === "string") {
+    safely(async () => {
+      await links.get(request.id)?.retry();
+      respond({ pairings: await views() });
     });
     return true;
   }
   if (request.type === "buddi-forget") {
-    safely(() => protocol.forget().then(() => respond({ state: last })));
+    safely(async () => {
+      const link = typeof request.id === "string" ? links.get(request.id) : firstLink();
+      await link?.forget();
+      respond({ pairings: await views() });
+    });
     return true;
   }
-  if (request.type === "buddi-gateway") {
-    safely(() => gateway().then((address) => respond({ gateway: address })));
+  if (request.type === "buddi-remove" && typeof request.id === "string") {
+    safely(async () => {
+      await store.remove(request.id);
+      await sync();
+      respond({ pairings: await views() });
+    });
     return true;
   }
   return;
 });
-chrome.runtime.onMessageExternal.addListener((message, sender, respond) => handleExternal(message, { origin: sender.origin, state: () => last, gateway, version: chrome.runtime.getManifest().version }, respond));
-chrome.runtime.onInstalled.addListener(() => safely(() => connect()));
-chrome.runtime.onStartup.addListener(() => safely(() => connect()));
+chrome.runtime.onMessageExternal.addListener((message, sender, respond) => handleExternal(message, {
+  origin: sender.origin,
+  version,
+  known: async () => {
+    entries = await store.list().catch(() => entries);
+    return entries.map((entry) => ({
+      origin: entry.origin,
+      name: displayName(entry, entries),
+      enabled: entry.enabled,
+      state: links.get(entry.id)?.state() ?? { connection: "offline", code: null, installation: null, error: null }
+    }));
+  },
+  unknown: (origin) => {
+    asked = origin;
+  }
+}, respond));
+chrome.runtime.onInstalled.addListener(() => safely(() => sync()));
+chrome.runtime.onStartup.addListener(() => safely(() => sync()));
 var RECONNECT_ALARM = "buddi-reconnect";
 chrome.alarms.create(RECONNECT_ALARM, { periodInMinutes: 1 });
 chrome.alarms.onAlarm.addListener((alarm) => {
-  if (alarm.name === RECONNECT_ALARM) safely(() => connect());
+  if (alarm.name === RECONNECT_ALARM) safely(() => sync());
 });
-safely(() => connect());
+safely(() => sync());
 export {
   DEFAULT_GATEWAY,
   KEEPALIVE_MS,
-  connect,
-  send,
-  socketUrl
+  socketUrl,
+  sync,
+  views
 };