wield-mcp 0.0.0-stage → 0.1.2

package/dist/extension/sw.js

@@ -0,0 +1,1907 @@
+// <define:__WIELD_DEV_KEYS__>
+var define_WIELD_DEV_KEYS_default = {};
+
+// packages/recipe/src/html.ts
+var MAX_JSON_VALUE = 256 * 1024;
+
+// packages/recipe/src/interpreter.ts
+var LIMITS = {
+  steps: 12,
+  foreach: 20,
+  requests: 40,
+  responseBytes: 5 * 1024 * 1024,
+  runMs: 6e4,
+  redirects: 3,
+  confirmMs: 13e4
+};
+
+// packages/recipe/src/lint.ts
+var OPERAND = String.raw`(?<![\w$.@])(§S|params\s*\.\s*[A-Za-z_]\w*|\$[A-Za-z_]\w*)`;
+var COMPARISON = new RegExp(String.raw`${OPERAND}\s*(<=|>=|<|>)|(<=|>=|<|>)\s*${OPERAND}`, "g");
+
+// packages/recipe/src/canonical.ts
+function canonicalJson(v) {
+  return JSON.stringify(sortKeys(v));
+}
+function sortKeys(v) {
+  if (Array.isArray(v)) return v.map(sortKeys);
+  if (v && typeof v === "object") {
+    const out = {};
+    for (const k of Object.keys(v).sort()) {
+      const x = v[k];
+      if (x !== void 0) out[k] = sortKeys(x);
+    }
+    return out;
+  }
+  return v;
+}
+
+// packages/recipe/src/signature.ts
+var enc = new TextEncoder();
+function wieldSigMessage(ctx, scope, sha256hex) {
+  return enc.encode(`wield-sig/v1
+${ctx}
+${scope}
+${sha256hex}`);
+}
+function b64decode(s) {
+  const t = s.replace(/-/g, "+").replace(/_/g, "/");
+  const bin = atob(t + "===".slice((t.length + 3) % 4));
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function hex(b) {
+  let s = "";
+  for (const x of b) s += x.toString(16).padStart(2, "0");
+  return s;
+}
+async function sha256HexWeb(data) {
+  const bytes = typeof data === "string" ? enc.encode(data) : data;
+  return hex(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes)));
+}
+var webCryptoVerify = async (pub, message, sig) => {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new Error("WebCrypto is not available");
+  const key = await subtle.importKey("raw", pub, { name: "Ed25519" }, false, ["verify"]);
+  return subtle.verify({ name: "Ed25519" }, key, sig, message);
+};
+async function verifySignature(keyring, sig, expect, verify = webCryptoVerify) {
+  if (!sig) return { ok: false, reason: "missing" };
+  if (typeof sig.kid !== "string" || typeof sig.ctx !== "string" || typeof sig.sig !== "string") return { ok: false, reason: "malformed" };
+  if (sig.ctx !== expect.ctx) return { ok: false, reason: "wrong_context", kid: sig.kid };
+  const pub = keyring[sig.kid];
+  if (!pub) return { ok: false, reason: "unknown_key", kid: sig.kid };
+  let pk, raw;
+  try {
+    pk = b64decode(pub);
+    raw = b64decode(sig.sig);
+  } catch {
+    return { ok: false, reason: "malformed", kid: sig.kid };
+  }
+  if (pk.length !== 32 || raw.length !== 64) return { ok: false, reason: "malformed", kid: sig.kid };
+  let good = false;
+  try {
+    good = await verify(pk, wieldSigMessage(expect.ctx, expect.scope, expect.sha256), raw);
+  } catch (e) {
+    if (/not available|not supported|Unrecognized|NotSupported/i.test(String(e?.message ?? e))) throw e;
+    good = false;
+  }
+  return good ? { ok: true, kid: sig.kid } : { ok: false, reason: "bad_signature", kid: sig.kid };
+}
+function describeSignatureFailure(what, reason) {
+  switch (reason) {
+    case "missing":
+      return `${what} is not signed`;
+    case "malformed":
+      return `${what} has a malformed signature`;
+    case "unknown_key":
+      return `${what} is signed with a key this version of Wield does not trust`;
+    case "wrong_context":
+      return `${what} carries a signature made for something else`;
+    case "bad_signature":
+      return `${what} does not match its signature (it was changed after signing)`;
+  }
+}
+
+// packages/recipe/src/keys.ts
+var REGISTRY_KEYS = {
+  // wield.run production registry key (CHANGES 18:40 · C3; also GET /api/v1/keys). Verified against the live index,
+  // all 31 recipes and a pinned version on 2026-11-07 before pinning.
+  "wield-2026-11": "qYB97SDzBjuHUZOIzEUKFHo3zlHD6YmI1iAQpXsyTaM"
+};
+
+// packages/recipe/src/features.ts
+var INTERPRETER_FEATURES = [
+  /** extract.html / html_items fields with parse: "json" (and path): per-element JSON attributes (CHANGES 2026-11-07 C1). */
+  "html_json",
+  /** page.host / page.origin in templates and context expressions: the language host the run landed on (CHANGES 22:39 C4). */
+  "page_context"
+];
+
+// apps/extension/src/shared/types.ts
+var PROTOCOL_VERSION = 1;
+var BUILD_ID = "0.1.15+20261107220223.8c74";
+var RELOAD_HINT = "Reload the Wield extension once: open chrome://extensions (vivaldi://extensions in Vivaldi) and click the reload arrow on the Wield card, then try again.";
+var LIMITS2 = {
+  steps: 12,
+  foreach: 20,
+  requests: 40,
+  responseBytes: 5 * 1024 * 1024,
+  runMs: 6e4,
+  confirmMs: 12e4,
+  /** How long the "quick human check" note waits for a click in the site tab. */
+  humanCheckMs: 6e4,
+  tabLoadMs: 3e4,
+  /** Settle time after a tab we opened reaches `complete`, so anti-bot sensor scripts can post (tests/e2e/SPIKE.md). */
+  tabSettleMs: 1500
+};
+
+// apps/extension/src/sw/ask.ts
+var pending = /* @__PURE__ */ new Map();
+function answerAsk(id, allow) {
+  const done = pending.get(id);
+  if (!done) return false;
+  done(allow ? "allow" : "deny");
+  return true;
+}
+async function askUser(ask, signal) {
+  const id = crypto.randomUUID();
+  const full = { ...ask, id, expires_at: Date.now() + LIMITS2.confirmMs };
+  await chrome.storage.session.set({ [`ask:${id}`]: full });
+  const win = await chrome.windows.create({
+    url: chrome.runtime.getURL(`confirm.html#${id}`),
+    type: "popup",
+    width: 460,
+    height: ask.kind === "write" || ask.kind === "draft" ? 620 : 420,
+    focused: true
+  });
+  return new Promise((resolve) => {
+    const finish2 = (outcome) => {
+      if (!pending.has(id)) return;
+      pending.delete(id);
+      clearTimeout(timer);
+      chrome.windows.onRemoved.removeListener(onRemoved);
+      signal.removeEventListener("abort", onAbort);
+      chrome.storage.session.remove(`ask:${id}`).catch(() => {
+      });
+      if (win?.id !== void 0) chrome.windows.remove(win.id).catch(() => {
+      });
+      resolve(outcome);
+    };
+    const onRemoved = (windowId) => windowId === win?.id && finish2("closed");
+    const onAbort = () => finish2("cancelled");
+    const timer = setTimeout(() => finish2("timeout"), LIMITS2.confirmMs);
+    pending.set(id, finish2);
+    chrome.windows.onRemoved.addListener(onRemoved);
+    signal.addEventListener("abort", onAbort);
+  });
+}
+
+// apps/extension/src/sw/native.ts
+var NATIVE_HOST = "run.wield.bridge";
+var ALIVE_AFTER_MS = 800;
+var NativeLink = class {
+  constructor(onMessage, onState) {
+    this.onMessage = onMessage;
+    this.onState = onState;
+  }
+  port = null;
+  retry = 0;
+  retryTimer;
+  state = { state: "disconnected", last_error: null, since: null };
+  ensure() {
+    if (this.port || this.retryTimer) return;
+    this.connect();
+  }
+  connect() {
+    clearTimeout(this.retryTimer);
+    this.retryTimer = void 0;
+    this.set({ state: "connecting", last_error: this.state.last_error, since: (/* @__PURE__ */ new Date()).toISOString() });
+    let port;
+    try {
+      port = chrome.runtime.connectNative(NATIVE_HOST);
+    } catch (e) {
+      this.fail(String(e));
+      return;
+    }
+    this.port = port;
+    const alive = setTimeout(() => this.port === port && this.up(), ALIVE_AFTER_MS);
+    port.onMessage.addListener((m) => {
+      if (this.port !== port) return;
+      this.up();
+      this.onMessage(m);
+    });
+    port.onDisconnect.addListener(() => {
+      clearTimeout(alive);
+      if (this.port !== port) return;
+      this.port = null;
+      this.fail(chrome.runtime.lastError?.message ?? "The bridge exited");
+    });
+  }
+  send(msg) {
+    if (!this.port) return false;
+    try {
+      this.port.postMessage(msg);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  get connected() {
+    return this.state.state === "connected";
+  }
+  up() {
+    if (this.state.state === "connected") return;
+    this.retry = 0;
+    this.set({ state: "connected", last_error: null, since: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  fail(err) {
+    const delay = Math.min(3e4, 1e3 * 2 ** this.retry++);
+    this.set({ state: "disconnected", last_error: err, since: (/* @__PURE__ */ new Date()).toISOString() });
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      this.connect();
+    }, delay);
+  }
+  set(s) {
+    this.state = s;
+    this.onState(s);
+  }
+};
+
+// apps/extension/src/sw/errors.ts
+var ExecError = class extends Error {
+  constructor(code, message, step) {
+    super(message);
+    this.code = code;
+    this.step = step;
+    this.name = "ExecError";
+  }
+};
+var CODES = /* @__PURE__ */ new Set([
+  "invalid_params",
+  "login_required",
+  "confirmation_denied",
+  "expect_failed",
+  "origin_blocked",
+  "timeout",
+  "tab_error",
+  "cancelled",
+  "limit_exceeded",
+  "executor_offline",
+  "recipe_invalid",
+  "site_challenge",
+  "recipe_unsigned"
+]);
+function toRunError(e, fallback = "tab_error") {
+  const any = e;
+  const code = any?.code && CODES.has(any.code) ? any.code : fallback;
+  const out = { code, message: String(any?.message ?? e).slice(0, 500) };
+  if (any?.step) out.step = any.step;
+  return out;
+}
+var UnresponsiveTab = class extends ExecError {
+  unresponsive = true;
+  constructor(message) {
+    super("tab_error", message);
+  }
+};
+
+// apps/extension/src/sw/store.ts
+var MAX_RUNS = 30;
+async function recordRun(run) {
+  const { runs = [] } = await chrome.storage.local.get("runs");
+  runs.unshift(run);
+  await chrome.storage.local.set({ runs: runs.slice(0, MAX_RUNS) });
+}
+async function recordSites(sites) {
+  const { sites: prev = {} } = await chrome.storage.local.get("sites");
+  for (const s of sites) prev[s.site_id] = s;
+  await chrome.storage.local.set({ sites: prev });
+}
+async function recordBridge(state) {
+  await chrome.storage.session.set({ bridge: state });
+}
+
+// apps/extension/src/sw/pacing.ts
+var STRICT = { burst: 3, everyMs: 2e3, perHour: 30 };
+var WATCHED = { burst: 4, everyMs: 1e3, perHour: 60 };
+var PROTECTED = {
+  "bahn.de": STRICT,
+  // Akamai, gates fahrplan (403 OPS_BLOCKED on 7 Nov)
+  "idealo.de": STRICT,
+  // Akamai
+  "zalando.de": STRICT,
+  // Akamai
+  "mobile.de": STRICT,
+  // Akamai on suchen.mobile.de
+  "eventim.de": STRICT,
+  // Akamai
+  "eventim.com": STRICT,
+  // Akamai on public-api.eventim.com
+  "immobilienscout24.de": STRICT,
+  // AWS WAF Bot Control
+  "kleinanzeigen.de": WATCHED,
+  // Akamai sensor present; logged-in messaging
+  "doctolib.de": WATCHED,
+  // Cloudflare / DataDome; logged-in booking
+  "jameda.de": WATCHED,
+  // PerimeterX / DataDome
+  ...false ? { "pace.localhost": { burst: 2, everyMs: 1e3, perHour: 6 } } : {}
+};
+var DEFAULT_RULE = { burst: 6, everyMs: 500, perHour: 300 };
+function siteKey(origin) {
+  return new URL(origin).hostname.split(".").slice(-2).join(".");
+}
+function ruleFor(key) {
+  const r = PROTECTED[key] ?? DEFAULT_RULE;
+  return false ? { ...r, perHour: r.perHour * 20 } : r;
+}
+var chains = /* @__PURE__ */ new Map();
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function acquire(origin) {
+  const key = siteKey(origin);
+  const rule = ruleFor(key);
+  const run = async () => {
+    const storeKey = `pace:${key}`;
+    const now = Date.now();
+    const st = (await chrome.storage.session.get(storeKey))[storeKey] ?? { tokens: rule.burst, at: now, hour: [] };
+    st.hour = st.hour.filter((t) => t > now - 36e5);
+    if (st.hour.length >= rule.perHour) {
+      const freeIn = Math.ceil((st.hour[0] + 36e5 - now) / 6e4);
+      return {
+        ok: false,
+        message: `Wield paused ${key}: ${rule.perHour} requests in the last hour is its limit, to keep your session with the site in good standing. Try again in about ${freeIn} min.`
+      };
+    }
+    let tokens = Math.min(rule.burst, st.tokens + (now - st.at) / rule.everyMs);
+    let waited = 0;
+    if (tokens < 1) {
+      waited = Math.ceil((1 - tokens) * rule.everyMs);
+      await sleep(waited);
+      tokens = 1;
+    }
+    const at = now + waited;
+    st.tokens = tokens - 1;
+    st.at = at;
+    st.hour.push(at);
+    await chrome.storage.session.set({ [storeKey]: st });
+    return { ok: true, waited_ms: waited };
+  };
+  const next = (chains.get(key) ?? Promise.resolve()).then(run, run);
+  chains.set(key, next.catch(() => void 0));
+  return next;
+}
+async function paceSnapshot() {
+  const all = await chrome.storage.session.get(null);
+  const out = {};
+  const now = Date.now();
+  for (const [k, v] of Object.entries(all)) {
+    if (!k.startsWith("pace:")) continue;
+    const key = k.slice(5);
+    out[key] = { last_hour: v.hour.filter((t) => t > now - 36e5).length, per_hour: ruleFor(key).perHour };
+  }
+  return out;
+}
+
+// apps/extension/src/shared/keys.ts
+function registryKeyring() {
+  return { ...REGISTRY_KEYS, ...typeof define_WIELD_DEV_KEYS_default === "undefined" ? {} : define_WIELD_DEV_KEYS_default };
+}
+function signaturesRequired() {
+  return Object.keys(REGISTRY_KEYS).length > 0;
+}
+
+// apps/extension/src/sw/policy.ts
+var KEY = "policies2";
+var DOMAIN = /^(\*\.)?[a-z0-9-]+(\.[a-z0-9-]+)*\.[a-z]{2,}$/i;
+async function storedPolicies() {
+  return (await chrome.storage.local.get(KEY))[KEY] ?? {};
+}
+function badShape(d) {
+  if (!d || typeof d !== "object") return "policy missing";
+  if (typeof d.org_id !== "string" || !d.org_id) return "policy needs org_id";
+  if (typeof d.issued_at !== "string" || Number.isNaN(Date.parse(d.issued_at))) return "policy needs issued_at";
+  if (d.allowed_sites != null && (!Array.isArray(d.allowed_sites) || !d.allowed_sites.every((s) => typeof s === "string" && DOMAIN.test(s)))) return "allowed_sites must be site ids like bahn.de";
+  if (d.writes !== void 0 && d.writes !== "allow" && d.writes !== "deny") return "writes must be allow or deny";
+  if (d.telemetry !== void 0 && !["off", "user", "allowed"].includes(d.telemetry)) return "telemetry must be off or user";
+  if (d.org_key !== void 0 && (typeof d.org_key?.kid !== "string" || typeof d.org_key?.public_key !== "string")) return "org_key must be {kid, public_key}";
+  return null;
+}
+function isOlder(a, b) {
+  if (typeof a.version === "number" && typeof b.version === "number" && a.version !== b.version) return a.version < b.version;
+  return Date.parse(a.issued_at) < Date.parse(b.issued_at);
+}
+async function acceptPolicy(doc) {
+  const raw = doc;
+  if (!raw || typeof raw !== "object") return { ok: false, error: "policy document missing" };
+  let body;
+  let signedText;
+  if (typeof raw.body === "string") {
+    try {
+      body = JSON.parse(raw.body);
+    } catch {
+      return { ok: false, error: "the signed policy body is not JSON" };
+    }
+    if (raw.policy && canonicalJson(raw.policy) !== canonicalJson(body)) return { ok: false, error: "the policy differs from its signed body" };
+    signedText = raw.body;
+  } else {
+    if (raw.policy && typeof raw.policy === "object") body = raw.policy;
+    else {
+      const { signature: _s, ...rest } = raw;
+      body = rest;
+    }
+    signedText = canonicalJson(body);
+  }
+  const bad = badShape(body);
+  if (bad) return { ok: false, error: bad };
+  const check = await verifySignature(registryKeyring(), raw.signature, { ctx: "policy", scope: body.org_id, sha256: await sha256HexWeb(signedText) });
+  if (!check.ok) return { ok: false, error: describeSignatureFailure("The organization policy", check.reason) };
+  const all = await storedPolicies();
+  const prev = all[body.org_id];
+  if (prev && isOlder(body, prev.policy)) return { ok: false, error: "an older policy cannot replace a newer one" };
+  if (!prev || canonicalJson(prev.policy) !== canonicalJson(body)) {
+    all[body.org_id] = { policy: body, received_at: (/* @__PURE__ */ new Date()).toISOString() };
+    await chrome.storage.local.set({ [KEY]: all });
+  }
+  return { ok: true, org_id: body.org_id };
+}
+async function managedPolicy() {
+  try {
+    const m = await chrome.storage.managed.get(null);
+    return m && Object.keys(m).length ? m : null;
+  } catch {
+    return null;
+  }
+}
+async function effectivePolicy() {
+  const eff = { allowLists: [], writesDenied: null, telemetryOff: false, requireSigned: false, orgKeys: /* @__PURE__ */ new Map(), sources: [] };
+  const now = Date.now();
+  const apply = (name, kind, p, expired) => {
+    eff.sources.push({ name, kind, expired, ...p.issued_at ? { issued_at: p.issued_at } : {} });
+    if (Array.isArray(p.allowed_sites) && p.allowed_sites.length) eff.allowLists.push({ source: name, sites: p.allowed_sites });
+    if (p.writes === "deny" && !eff.writesDenied) eff.writesDenied = name;
+    if (p.telemetry === "off") eff.telemetryOff = true;
+    if (p.require_signed === true) eff.requireSigned = true;
+  };
+  for (const s of Object.values(await storedPolicies())) {
+    const p = s.policy;
+    apply(p.org_name || p.org_slug || p.org_id, "signed", p, !!p.expires_at && Date.parse(p.expires_at) < now);
+    if (p.org_key) eff.orgKeys.set(p.org_id, p.org_key);
+  }
+  const m = await managedPolicy();
+  if (m) apply(typeof m.org_name === "string" && m.org_name ? m.org_name : "your administrator", "managed", m, false);
+  return eff;
+}
+function siteMatches(pattern, host) {
+  const p = pattern.toLowerCase();
+  const h = host.toLowerCase();
+  if (p.startsWith("*.")) return h.endsWith(p.slice(1));
+  return h === p || h.endsWith(`.${p}`);
+}
+function blockedBy(eff, host) {
+  for (const l of eff.allowLists) if (!l.sites.some((s) => siteMatches(s, host))) return l.source;
+  return null;
+}
+function policySummary(eff) {
+  if (!eff.sources.length) return null;
+  return {
+    orgs: eff.sources.map((s) => ({ name: s.name, kind: s.kind, expired: s.expired })),
+    allowed_sites: eff.allowLists.length ? eff.allowLists.map((l) => l.sites) : null,
+    writes: eff.writesDenied ? "deny" : "allow",
+    telemetry: eff.telemetryOff ? "off" : "user",
+    require_signed: eff.requireSigned
+  };
+}
+
+// apps/extension/src/sw/signing.ts
+async function developerMode() {
+  return (await chrome.storage.local.get("dev_mode")).dev_mode === true;
+}
+async function checkRecipeSignature(recipe, signature, policy, source, draft, bundled = false) {
+  if (bundled) return { status: "unsigned", why: "bundled" };
+  if (signature === void 0 || signature === null) {
+    if (policy.requireSigned) throw new ExecError("recipe_unsigned", "This recipe is not signed, and your organization requires signed recipes. Nothing was sent.");
+    if (source === "local") {
+      if (!await developerMode()) throw new ExecError("recipe_unsigned", "This is an unsigned local recipe. Wield runs those only with Developer mode on (Wield popup \u2192 Developer). Nothing was sent.");
+      return { status: "unsigned", why: "local" };
+    }
+    if (draft === true) return { status: "unsigned", why: "draft" };
+    if (signaturesRequired()) throw new ExecError("recipe_unsigned", "This recipe is not signed. Wield only runs signed registry recipes; nothing was sent.");
+    return { status: "unsigned", why: "not required" };
+  }
+  const s = signature;
+  const isPrivate = s.ctx === "private-recipe";
+  const scope = isPrivate ? String(s.scope ?? "") : "public";
+  const orgKey = isPrivate ? policy.orgKeys.get(scope) : void 0;
+  const keyring = isPrivate ? orgKey ? { [orgKey.kid]: orgKey.public_key } : {} : registryKeyring();
+  const ctx = isPrivate ? "private-recipe" : "recipe";
+  const check = await verifySignature(keyring, s, { ctx, scope, sha256: await sha256HexWeb(canonicalJson(recipe)) });
+  if (!check.ok) throw new ExecError("recipe_unsigned", `${describeSignatureFailure("This recipe", check.reason)}: refusing to run it. Nothing was sent.`);
+  return { status: "verified", kid: check.kid, scope };
+}
+
+// apps/extension/src/sw/withdrawn.ts
+var KEY2 = "withdrawn_index";
+async function acceptIndex(doc) {
+  const d = doc;
+  if (!d || typeof d.body !== "string") return { ok: false, error: "the index body (exact signed text) is missing" };
+  const check = await verifySignature(registryKeyring(), d.signature, { ctx: "index", scope: "public", sha256: await sha256HexWeb(d.body) });
+  if (!check.ok) return { ok: false, error: describeSignatureFailure("The registry index", check.reason) };
+  let idx;
+  try {
+    idx = JSON.parse(d.body);
+  } catch {
+    return { ok: false, error: "the signed index is not JSON" };
+  }
+  const generated_at = String(idx.generated_at ?? "");
+  if (!Number.isFinite(Date.parse(generated_at))) return { ok: false, error: "the index has no generated_at" };
+  if (Date.parse(generated_at) > Date.now() + 24 * 60 * 6e4) return { ok: false, error: "the index is dated more than a day in the future" };
+  const prev = await stored();
+  if (prev && Date.parse(prev.generated_at) > Date.parse(generated_at)) return { ok: false, error: "an older registry index cannot replace a newer one" };
+  const map = {};
+  for (const r of Array.isArray(idx.recipes) ? idx.recipes : []) {
+    if (!r || typeof r.id !== "string") continue;
+    const min = Number.isInteger(r.min_version) ? r.min_version : 1;
+    const withdrawn = Array.isArray(r.withdrawn_versions) ? r.withdrawn_versions.filter((v) => Number.isInteger(v)) : [];
+    if (min > 1 || withdrawn.length) map[r.id] = { min, withdrawn };
+  }
+  await chrome.storage.local.set({ [KEY2]: { generated_at, map } });
+  return { ok: true, generated_at, withdrawn: Object.keys(map).length };
+}
+async function stored() {
+  return (await chrome.storage.local.get(KEY2))[KEY2] ?? null;
+}
+async function withdrawnReason(id, version) {
+  const w = (await stored())?.map[id];
+  if (!w) return null;
+  if (version < w.min) return `${id} v${version} is below the registry's minimum version ${w.min}`;
+  if (w.withdrawn.includes(version)) return `${id} v${version} was withdrawn by the registry`;
+  return null;
+}
+
+// packages/builder/src/classify.ts
+var JWT = /^eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+var ISO_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?$/;
+var DE_DATE = /^\d{1,2}\.\d{1,2}\.(\d{2}|\d{4})$/;
+var TIME = /^\d{1,2}:\d{2}(:\d{2})?$/;
+var URN = /^(?:[a-z][a-z0-9-]{1,15}:(?:[a-z][a-z0-9_-]{0,30})?:+|gid:\/\/[a-z]+\/[A-Za-z]+\/)(?=\S)/;
+var SECRET_KEY = /(^|[_-])(token|csrf|xsrf|auth|authorization|session|sess|sid|ssid|esid|secret|password|passwd|pwd|otp|nonce|signature|sig|apikey|api_key|access_key|private|cookie|bearer|jwt|hash_?key|device_?id|fingerprint|captcha|recaptcha|cf_clearance)([_-]|$)|token|csrf|xsrf|secret|password|session|signature|apikey|captcha/i;
+function looksLikeToken(v) {
+  if (typeof v !== "string") return false;
+  const s = v.trim();
+  if (s.length < 16) return false;
+  if (JWT.test(s)) return true;
+  if (UUID.test(s)) return true;
+  if (/\s/.test(s)) return false;
+  if (/^[0-9]+$/.test(s)) return false;
+  if (ISO_DATETIME.test(s) || ISO_DATE.test(s) || DE_DATE.test(s) || TIME.test(s)) return false;
+  if (/^https?:\/\//.test(s)) return false;
+  if (/^[\w.+-]+\/[\w.+*-]+(\s*;.*)?$/.test(s)) return false;
+  if (/^[a-z]+(?:[-_][a-z]+){1,}$/i.test(s)) return false;
+  if (/[,;|]/.test(s) && s.split(/\s*[,;|]\s*/).every((p) => /^[A-Za-z][A-Za-z0-9_.-]{0,40}$/.test(p) && !/\d{4,}/.test(p))) return false;
+  if (URN.test(s)) return false;
+  if (/^[a-z]+(?:[A-Z][a-z]*)+\d{0,2}$|^(?:[A-Z][a-z]+){2,}[A-Z]?\d{0,2}$/.test(s)) return false;
+  const parts = s.split(/[-_]+/).filter(Boolean);
+  if (parts.length >= 3 && parts.every((p) => /^[a-z0-9]+$/.test(p)) && parts.filter((p) => /^[a-z]{2,}$/.test(p)).length >= parts.length / 2) return false;
+  if (/^\/?[A-Za-z_$][\w$-]*(?:[./:][A-Za-z_$][\w$-]*)+\/?$/.test(s)) return false;
+  if (s.includes("/") && s.split("/").every((seg) => seg === "" || seg.length < 16 || /^[A-Za-z][a-z]+(?:[A-Z][a-z]+)*$/.test(seg))) return false;
+  const classes = [/[a-z]/, /[A-Z]/, /[0-9]/, /[^A-Za-z0-9]/].filter((r) => r.test(s)).length;
+  return s.length >= 24 || classes >= 3;
+}
+
+// packages/builder/src/trace.ts
+var TRACE_FORMAT = "wield-trace/1";
+var MULTI_PART_TLDS = /* @__PURE__ */ new Set([
+  "co.uk",
+  "org.uk",
+  "ac.uk",
+  "gov.uk",
+  "com.au",
+  "net.au",
+  "org.au",
+  "co.nz",
+  "co.jp",
+  "ne.jp",
+  "or.jp",
+  "com.br",
+  "com.mx",
+  "com.ar",
+  "com.tr",
+  "co.za",
+  "com.sg",
+  "com.hk",
+  "com.tw",
+  "co.kr",
+  "co.in",
+  "co.il",
+  "com.cn",
+  "com.pl",
+  "co.at",
+  "or.at",
+  "gv.at",
+  "com.ua",
+  "com.es",
+  "com.pt",
+  "com.ph",
+  "com.my",
+  "co.id",
+  "co.th",
+  "com.vn",
+  "com.sa",
+  "com.eg",
+  "com.co",
+  "com.pe",
+  "com.cl"
+]);
+function registrableDomain(host) {
+  const h = host.toLowerCase().replace(/\.$/, "");
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(h) || !h.includes(".")) return h;
+  const parts = h.split(".");
+  const last2 = parts.slice(-2).join(".");
+  if (parts.length >= 3 && MULTI_PART_TLDS.has(last2)) return parts.slice(-3).join(".");
+  return last2;
+}
+function validateTrace(t) {
+  const p = [];
+  const err = (path, message) => p.push({ path, message });
+  if (!t || typeof t !== "object") return [{ path: "/", message: "trace must be an object" }];
+  const x = t;
+  if (x.format !== TRACE_FORMAT) err("/format", `must be "${TRACE_FORMAT}"`);
+  if (typeof x.task !== "string" || !x.task.trim() || x.task.length > 300) err("/task", "a task of 1\u2013300 characters is required");
+  try {
+    if (!x.site || new URL(x.site.origin).origin !== x.site.origin || !x.site.origin.startsWith("https://")) err("/site/origin", "must be an https origin");
+  } catch {
+    err("/site/origin", "must be an https origin");
+  }
+  if (!Array.isArray(x.inputs)) err("/inputs", "must be an array");
+  if (!Array.isArray(x.calls) || x.calls.length === 0) err("/calls", "at least one call is required");
+  else if (x.calls.length > 200) err("/calls", "at most 200 calls");
+  const size = JSON.stringify(t).length;
+  if (size > 15e5) err("/", `trace is ${Math.round(size / 1024)} KB; the limit is 1.5 MB`);
+  const walk = (v, path, key) => {
+    if (p.length > 20) return;
+    if (typeof v === "string") {
+      if (v.startsWith("\xAB") || /\{\{in\d+\}\}/.test(v)) return;
+      if (/^(Bearer|Basic)\s+[A-Za-z0-9._~+/-]{12,}/.test(v)) err(path, "an Authorization value was not redacted");
+      else if (key !== "html" && /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\./.test(v)) err(path, "a JWT was not redacted");
+      else if (SECRET_KEY.test(key) && looksLikeToken(v) && !/^sha256Hash$/i.test(key)) err(path, `value under "${key}" looks like an unredacted secret`);
+      return;
+    }
+    if (Array.isArray(v)) {
+      if (v.length === 2 && typeof v[0] === "string" && typeof v[1] === "string" && /^(cookie|cookie2|authorization|proxy-authorization)$/i.test(v[0]) && !/«secret[^»]*»/.test(v[1])) err(path, `${v[0]} header value must be redacted`);
+      v.forEach((e, i) => walk(e, `${path}/${i}`, Array.isArray(e) ? key : typeof v[0] === "string" && i === 1 ? String(v[0]) : key));
+      return;
+    }
+    if (v && typeof v === "object") for (const [k, val] of Object.entries(v)) walk(val, `${path}/${k}`, k);
+  };
+  walk(t, "", "");
+  return p;
+}
+
+// apps/extension/src/sw/sites.ts
+var PAUSED = "paused_sites";
+async function pausedHosts() {
+  return (await chrome.storage.local.get(PAUSED))[PAUSED] ?? [];
+}
+async function setPaused(host, paused) {
+  const list = new Set(await pausedHosts());
+  if (paused) list.add(host);
+  else list.delete(host);
+  await chrome.storage.local.set({ [PAUSED]: [...list] });
+}
+async function isPaused(host) {
+  return (await pausedHosts()).includes(host);
+}
+var originOf = (pattern) => pattern.replace(/\/\*$/, "");
+function patternCovers(pattern, origin) {
+  const m = /^(https?|\*):\/\/([^/]+)\/\*$/.exec(pattern);
+  if (!m) return pattern === "<all_urls>";
+  const u = new URL(origin);
+  if (m[1] !== "*" && `${m[1]}:` !== u.protocol) return false;
+  const host = m[2];
+  if (host === "*") return true;
+  if (host.startsWith("*.")) return u.hostname === host.slice(2) || u.hostname.endsWith(host.slice(1));
+  return u.hostname === host;
+}
+async function sitesOverview(runs, states) {
+  const manifestPatterns = chrome.runtime.getManifest().host_permissions ?? [];
+  const builtIn = new Set(manifestPatterns.filter((p) => /^https:\/\/[a-z0-9.-]+\/\*$/.test(p)).map(originOf));
+  const grantedPatterns = ((await chrome.permissions.getAll()).origins ?? []).filter((p) => !manifestPatterns.includes(p));
+  const granted = new Set(grantedPatterns.map(originOf).filter((o) => /^https:\/\/[a-z0-9.-]+$/.test(o)));
+  const accessOf = (origin) => manifestPatterns.some((p) => patternCovers(p, origin)) ? "built-in" : grantedPatterns.some((p) => patternCovers(p, origin)) ? "granted" : "none";
+  const paused = new Set(await pausedHosts());
+  const pace = await paceSnapshot();
+  const policy = await effectivePolicy();
+  const rows = /* @__PURE__ */ new Map();
+  const row = (origin) => {
+    let r = rows.get(origin);
+    if (!r) {
+      const host = new URL(origin).hostname;
+      r = {
+        origin,
+        host,
+        access: accessOf(origin),
+        paused: paused.has(host),
+        policy_blocked_by: blockedBy(policy, host),
+        logged_in: null,
+        tab_open: false,
+        last_run: null,
+        pace: pace[siteKey(origin)] ?? null,
+        active: false
+      };
+      rows.set(origin, r);
+    }
+    return r;
+  };
+  for (const o of builtIn) row(o);
+  for (const o of granted) row(o).active = true;
+  for (const s of states) {
+    if (!s.origin) continue;
+    const r = row(s.origin);
+    r.logged_in = s.logged_in;
+    r.tab_open = s.tab_open;
+    r.active = true;
+  }
+  for (const run of runs) {
+    const origin = run.origin ?? run.requests[0]?.origin;
+    if (run.kind !== "run" || !origin) continue;
+    const r = row(origin);
+    r.active = true;
+    if (!r.last_run) r.last_run = { ok: run.ok, ...run.error_code ? { error_code: run.error_code } : {}, at: run.started_at, recipe_id: run.recipe_id };
+  }
+  for (const h of paused) {
+    const existing = [...rows.values()].find((x) => x.host === h);
+    if (existing) existing.active = true;
+    else row(`https://${h}`).active = true;
+  }
+  return [...rows.values()].sort((a, b) => Number(b.active) - Number(a.active) || a.host.replace(/^www\./, "").localeCompare(b.host.replace(/^www\./, "")));
+}
+
+// apps/extension/src/sw/tabs.ts
+var OWNED_KEY = "ownedTabs";
+async function ownedTabs() {
+  const r = await chrome.storage.session.get(OWNED_KEY);
+  return new Set(r[OWNED_KEY] ?? []);
+}
+async function setOwned(ids) {
+  await chrome.storage.session.set({ [OWNED_KEY]: [...ids] });
+}
+chrome.tabs.onRemoved.addListener(async (tabId) => {
+  const owned = await ownedTabs();
+  if (owned.delete(tabId)) await setOwned(owned);
+  unmarkStale(tabId);
+});
+var STALE_KEY = "staleTabs";
+async function staleTabs() {
+  const r = await chrome.storage.session.get(STALE_KEY);
+  return new Set(r[STALE_KEY] ?? []);
+}
+async function markStale(tabId) {
+  const s = await staleTabs();
+  s.add(tabId);
+  await chrome.storage.session.set({ [STALE_KEY]: [...s] });
+}
+function unmarkStale(tabId) {
+  void staleTabs().then(async (s) => {
+    if (s.delete(tabId)) await chrome.storage.session.set({ [STALE_KEY]: [...s] });
+  });
+}
+chrome.tabs.onUpdated.addListener((tabId, info) => {
+  if (info.status === "loading") unmarkStale(tabId);
+});
+function originPattern(origin) {
+  return `${origin}/*`;
+}
+function siteOrigins(origin, localeHosts = []) {
+  const port = new URL(origin).port;
+  return [origin, ...localeHosts.map((h) => `https://${h}${port ? `:${port}` : ""}`)];
+}
+async function tabsForOrigin(origin, localeHosts = []) {
+  const origins = siteOrigins(origin, localeHosts);
+  const tabs = await chrome.tabs.query({ url: origins.map(originPattern) });
+  return tabs.filter((t) => t.id !== void 0 && t.url && origins.includes(new URL(t.url).origin));
+}
+function waitComplete(tabId, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish2 = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      chrome.tabs.onUpdated.removeListener(onUpdated);
+      chrome.tabs.onRemoved.removeListener(onRemoved);
+      fn();
+    };
+    const onUpdated = (id, info, tab) => {
+      if (id === tabId && info.status === "complete") finish2(() => resolve(tab));
+    };
+    const onRemoved = (id) => {
+      if (id === tabId) finish2(() => reject(new ExecError("tab_error", "The site tab was closed while loading")));
+    };
+    const timer = setTimeout(
+      () => finish2(() => reject(new ExecError("tab_error", `The site tab did not finish loading within ${timeoutMs / 1e3} s`))),
+      timeoutMs
+    );
+    chrome.tabs.onUpdated.addListener(onUpdated);
+    chrome.tabs.onRemoved.addListener(onRemoved);
+    chrome.tabs.get(tabId).then(
+      (t) => t.status === "complete" && finish2(() => resolve(t)),
+      () => finish2(() => reject(new ExecError("tab_error", "The site tab is gone")))
+    );
+  });
+}
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+function startUrl(origin, startPath) {
+  if (!startPath) return `${origin}/`;
+  if (!startPath.startsWith("/") || startPath.startsWith("//")) throw new ExecError("recipe_invalid", 'site.start_path must be a path starting with "/"');
+  const u = new URL(startPath, origin);
+  if (u.origin !== origin) throw new ExecError("recipe_invalid", "site.start_path must stay on site.origin");
+  return u.toString();
+}
+async function acquireTab(origin, signal, startPath, opts = {}) {
+  const url = startUrl(origin, startPath);
+  const owned = await ownedTabs();
+  const stale = await staleTabs();
+  const accepted = siteOrigins(origin, opts.localeHosts);
+  const candidates = (await tabsForOrigin(origin, opts.localeHosts)).filter((t) => !t.discarded && !stale.has(t.id)).sort((a, b) => score(b, owned) - score(a, owned));
+  const pick = opts.forceNew ? void 0 : candidates[0];
+  if (pick?.id !== void 0) {
+    if (pick.status !== "complete") await waitComplete(pick.id, LIMITS2.tabLoadMs);
+    return { tabId: pick.id, opened: false, owned: owned.has(pick.id), ...pick.url ? { host: new URL(pick.url).host } : {} };
+  }
+  let tab;
+  try {
+    tab = await chrome.tabs.create({ url, active: false });
+  } catch {
+    const win = await chrome.windows.create({ url, focused: false });
+    tab = win.tabs[0];
+  }
+  const tabId = tab.id;
+  owned.add(tabId);
+  await setOwned(owned);
+  chrome.tabs.update(tabId, { autoDiscardable: false }).catch(() => {
+  });
+  const done = await waitComplete(tabId, LIMITS2.tabLoadMs);
+  const finalOrigin = done.url ? new URL(done.url).origin : "";
+  if (!accepted.includes(finalOrigin)) {
+    throw new ExecError("tab_error", `${origin} redirected the tab to ${finalOrigin || "a site Wield has no access to"}; the recipe's site.origin needs updating`);
+  }
+  if (!signal.aborted) await sleep2(LIMITS2.tabSettleMs);
+  return { tabId, opened: true, owned: true, ...done.url ? { host: new URL(done.url).host } : {} };
+}
+function score(t, owned) {
+  let s = 0;
+  if (t.status === "complete") s += 4;
+  if (!owned.has(t.id)) s += 2;
+  s += (t.lastAccessed ?? 0) / 1e13;
+  return s;
+}
+var MAX_WARM_TABS = 4;
+var WARM_KEY = "warmTabs";
+async function warmTab(origin, startPath) {
+  const open = (await tabsForOrigin(origin)).filter((t) => !t.discarded);
+  if (open.length) return "open";
+  const warmed = new Set((await chrome.storage.session.get(WARM_KEY))[WARM_KEY] ?? []);
+  for (const id of [...warmed]) await chrome.tabs.get(id).catch(() => warmed.delete(id));
+  if (warmed.size >= MAX_WARM_TABS) return "skipped";
+  const owned = await ownedTabs();
+  let tab;
+  try {
+    tab = await chrome.tabs.create({ url: startUrl(origin, startPath), active: false });
+  } catch {
+    return "skipped";
+  }
+  owned.add(tab.id);
+  await setOwned(owned);
+  warmed.add(tab.id);
+  await chrome.storage.session.set({ [WARM_KEY]: [...warmed] });
+  chrome.tabs.update(tab.id, { autoDiscardable: false }).catch(() => {
+  });
+  return "opened";
+}
+
+// apps/extension/src/sw/runs.ts
+var ORIGIN_RE = /^https:\/\/[^/]+$/;
+var FORBIDDEN_HEADERS = /* @__PURE__ */ new Set(["cookie", "cookie2", "host", "set-cookie"]);
+function isAllowedOrigin(o) {
+  return typeof o === "string" && ORIGIN_RE.test(o);
+}
+function checkHeaders(s) {
+  for (const h of Object.keys(s.request?.headers ?? {})) {
+    if (FORBIDDEN_HEADERS.has(h.toLowerCase())) throw new ExecError("recipe_invalid", `step ${s.id} sets the ${h} header; the browser sends cookies itself`, s.id);
+  }
+}
+function post(port, m) {
+  try {
+    port?.postMessage(m);
+  } catch {
+  }
+}
+function checkRecipe(r) {
+  const bad = (m) => {
+    throw new ExecError("recipe_invalid", m);
+  };
+  const recipe = r;
+  if (!recipe || typeof recipe !== "object") bad("recipe missing");
+  if (typeof recipe.id !== "string" || typeof recipe.version !== "number") bad("recipe.id/version missing");
+  const site = recipe.site;
+  if (!site || !isAllowedOrigin(site.origin)) bad("site.origin must be https://host");
+  if (!Array.isArray(site.origins) || site.origins.length === 0 || !site.origins.every(isAllowedOrigin)) bad("site.origins must list https origins");
+  if (site.locale_hosts !== void 0) {
+    if (!Array.isArray(site.locale_hosts) || site.locale_hosts.length > 20) bad("site.locale_hosts must be a list of up to 20 host names");
+    for (const h of site.locale_hosts) {
+      if (typeof h !== "string" || !/^[a-z0-9-]+(\.[a-z0-9-]+)+$/.test(h) || !(h === site.id || h.endsWith(`.${site.id}`))) bad(`site.locale_hosts: "${String(h)}" must be an exact host name under ${site.id}`);
+    }
+  }
+  if (!Array.isArray(recipe.steps) || recipe.steps.length < 1) bad("recipe has no steps");
+  if (recipe.steps.length > LIMITS2.steps) throw new ExecError("limit_exceeded", `recipe has ${recipe.steps.length} steps; the limit is ${LIMITS2.steps}`);
+  for (const s of [...recipe.steps, ...recipe.login_check ? [recipe.login_check] : []]) {
+    if (!s?.request?.url || !s.request.method) bad(`step ${s?.id ?? "?"} has no request`);
+    if ((s.foreach?.max ?? 0) > LIMITS2.foreach) throw new ExecError("limit_exceeded", `step ${s.id}: foreach.max is above ${LIMITS2.foreach}`, s.id);
+    checkHeaders(s);
+  }
+  return recipe;
+}
+var Budget = class {
+  constructor(ms, onExpire) {
+    this.onExpire = onExpire;
+    this.remaining = ms;
+    this.resume();
+  }
+  remaining;
+  startedAt = 0;
+  timer;
+  pause() {
+    if (!this.timer) return;
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    this.remaining -= Date.now() - this.startedAt;
+  }
+  resume() {
+    if (this.timer) return;
+    this.startedAt = Date.now();
+    this.timer = setTimeout(this.onExpire, Math.max(0, this.remaining));
+  }
+  stop() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+  left() {
+    return Math.max(1, this.remaining - (this.timer ? Date.now() - this.startedAt : 0));
+  }
+};
+var active = /* @__PURE__ */ new Map();
+var runAborts = /* @__PURE__ */ new Map();
+function cancelRun(run_id) {
+  runAborts.get(run_id)?.abort();
+  const run = active.get(run_id);
+  if (!run) return runAborts.has(run_id);
+  post(run.port, { type: "cancel" });
+  run.finish({ ok: false, error: { code: "cancelled", message: "Cancelled by the client" } });
+  return true;
+}
+function activeRuns() {
+  return active.size;
+}
+var newerBuild = null;
+async function buildOnDisk() {
+  try {
+    const r = await fetch(chrome.runtime.getURL("build-id.json"), { cache: "no-store" });
+    return (await r.json()).build ?? null;
+  } catch {
+    return null;
+  }
+}
+async function checkForNewBuild() {
+  const disk = await buildOnDisk();
+  const changed = !!disk && disk !== BUILD_ID;
+  if (changed !== (newerBuild !== null)) {
+    chrome.action.setBadgeText({ text: changed ? "\u21BB" : "" }).catch(() => {
+    });
+    if (changed) chrome.action.setBadgeBackgroundColor({ color: "#121311" }).catch(() => {
+    });
+    chrome.action.setTitle({ title: changed ? "Wield was rebuilt: reload it (open this popup)" : "Wield" }).catch(() => {
+    });
+  }
+  newerBuild = changed ? disk : null;
+  return changed;
+}
+function pendingBuild() {
+  return newerBuild;
+}
+var OUTCOME_MSG = {
+  allow: "allowed by the user",
+  deny: "denied by the user",
+  closed: "denied: the window was closed",
+  timeout: `denied: no answer in ${Math.round(LIMITS2.confirmMs / 1e3)} s`,
+  cancelled: "cancelled before an answer"
+};
+var DENIED_ERROR = {
+  deny: "The user clicked Deny in the browser. Nothing was sent.",
+  closed: "The user closed the Allow window. Nothing was sent.",
+  timeout: `No answer in the Allow window within ${Math.round(LIMITS2.confirmMs / 1e3)} s. Nothing was sent; ask the user to try again while at the computer.`,
+  cancelled: "The run was cancelled before the user answered. Nothing was sent."
+};
+async function ensureHostAccess(recipe, run_id, budget, signal, emit) {
+  const pattern = originPattern(recipe.site.origin);
+  if (await chrome.permissions.contains({ origins: [pattern] })) return;
+  emit({ level: "info", kind: "confirm", msg: `asking for access to ${new URL(recipe.site.origin).host}` });
+  budget?.pause();
+  const outcome = await askUser({ kind: "permission", run_id, site: { id: recipe.site.id, name: recipe.site.name, origin: recipe.site.origin }, task: recipe.task }, signal);
+  budget?.resume();
+  emit({ level: outcome === "allow" ? "info" : "warn", kind: "confirm", msg: outcome === "allow" ? `access to ${new URL(recipe.site.origin).host} granted by the user` : `site access ${OUTCOME_MSG[outcome]}` });
+  if (outcome !== "allow" || !await chrome.permissions.contains({ origins: [pattern] })) {
+    throw new ExecError("origin_blocked", `Access to ${recipe.site.origin} was not granted in the browser (${OUTCOME_MSG[outcome]})`);
+  }
+}
+var INJECT_TIMEOUT_MS = 5e3;
+var ACK_TIMEOUT_MS = 2e3;
+async function inject(tabId) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await Promise.race([
+        chrome.scripting.executeScript({ target: { tabId }, files: ["content.js"] }),
+        new Promise((_, reject) => setTimeout(() => reject(new UnresponsiveTab(`The site tab did not take Wield's script within ${INJECT_TIMEOUT_MS / 1e3} s`)), INJECT_TIMEOUT_MS))
+      ]);
+      return;
+    } catch (e) {
+      if (e instanceof UnresponsiveTab) throw e;
+      const msg = e.message ?? String(e);
+      if (attempt === 0 && /Could not load file/i.test(msg)) {
+        await new Promise((r) => setTimeout(r, 300));
+        continue;
+      }
+      throw new ExecError("tab_error", `Could not run in the site tab: ${msg}`);
+    }
+  }
+}
+function execute(opts) {
+  const abort = new AbortController();
+  let resolveDone;
+  const done = new Promise((r) => resolveDone = r);
+  let finished = false;
+  const budget = new Budget(opts.budgetMs, () => {
+    post(run.port, { type: "cancel" });
+    run.finish({ ok: false, error: { code: "timeout", message: `Run exceeded ${Math.round(opts.budgetMs / 1e3)} s` } });
+  });
+  const run = {
+    run_id: opts.run_id,
+    abort,
+    finish: (r) => {
+      if (finished) return;
+      finished = true;
+      budget.stop();
+      abort.abort();
+      active.delete(opts.run_id);
+      try {
+        run.port?.disconnect();
+      } catch {
+      }
+      resolveDone(r);
+    }
+  };
+  active.set(opts.run_id, run);
+  let deniedBy;
+  (async () => {
+    const { recipe } = opts;
+    let tabId = opts.tabId;
+    if (tabId === void 0) {
+      await ensureHostAccess(recipe, opts.run_id, budget, abort.signal, opts.emit);
+      const t0 = Date.now();
+      const tab = await acquireTab(recipe.site.origin, abort.signal, recipe.site.start_path, { forceNew: opts.forceNewTab, localeHosts: recipe.site.locale_hosts ?? [] });
+      tabId = tab.tabId;
+      if (opts.meta) {
+        opts.meta.owned = tab.owned;
+        if (tab.opened) opts.meta.openedTabId = tab.tabId;
+      }
+      const host = tab.host ?? new URL(recipe.site.origin).host;
+      opts.emit({ level: "info", kind: "tab", msg: tab.opened ? `opened background tab ${host} (${Date.now() - t0} ms)` : `using open tab ${host}` });
+    }
+    if (opts.meta) opts.meta.tabId = tabId;
+    if (finished) return;
+    await inject(tabId);
+    if (finished) return;
+    const port = chrome.tabs.connect(tabId, { name: `wield-run:${opts.run_id}` });
+    run.port = port;
+    port.onDisconnect.addListener(() => {
+      run.finish({ ok: false, error: { code: "tab_error", message: "The site tab closed or navigated away during the run" } });
+    });
+    let acked = false;
+    port.onMessage.addListener(async (m) => {
+      acked = true;
+      if (finished) return;
+      if (m.type === "ack") return;
+      if (m.type === "event") {
+        if (m.kind === "done" || m.kind === "confirm") return;
+        opts.emit({ level: m.level, kind: m.kind, msg: m.msg, data: m.data });
+      } else if (m.type === "confirm") {
+        const n = m.info.writes.length;
+        opts.emit({ level: "info", kind: "confirm", msg: `waiting for Allow in the browser: ${n} write request${n === 1 ? "" : "s"}` });
+        budget.pause();
+        const outcome = await askUser(
+          { kind: "write", run_id: opts.run_id, site: { id: recipe.site.id, name: recipe.site.name, origin: recipe.site.origin }, task: recipe.task, info: m.info },
+          abort.signal
+        );
+        budget.resume();
+        if (outcome !== "allow") deniedBy = outcome;
+        opts.emit({ level: outcome === "allow" ? "info" : "warn", kind: "confirm", msg: OUTCOME_MSG[outcome] });
+        post(port, { type: "confirm_result", id: m.id, allow: outcome === "allow" });
+      } else if (m.type === "pace") {
+        const r = await acquire(m.origin);
+        if (r.ok && r.waited_ms >= 250) opts.emit({ level: "info", kind: "step", msg: `pacing: waited ${(r.waited_ms / 1e3).toFixed(1)} s before the next ${new URL(m.origin).host} request` });
+        if (!r.ok) opts.emit({ level: "warn", kind: "step", msg: r.message });
+        post(port, { type: "pace_result", id: m.id, ok: r.ok, ...r.ok ? { waited_ms: r.waited_ms } : { message: r.message } });
+      } else if (m.type === "result") {
+        if (!m.ok && m.error.code === "confirmation_denied" && deniedBy) m.error.message = DENIED_ERROR[deniedBy];
+        run.finish(m.ok ? { ok: true, output: m.output } : { ok: false, error: m.error, ...m.challenge ? { challenge: m.challenge } : {} });
+      }
+    });
+    post(port, { type: "run", run_id: opts.run_id, recipe, params: opts.params, mode: opts.mode, timeout_ms: budget.left(), build: BUILD_ID, ...opts.trust === "registry" ? { trust: "registry" } : {} });
+    setTimeout(() => {
+      if (acked || finished) return;
+      try {
+        port.disconnect();
+      } catch {
+      }
+      run.finish({ ok: false, unresponsive: true, error: { code: "tab_error", message: `Wield's script in the ${new URL(recipe.site.origin).host} tab did not answer within ${ACK_TIMEOUT_MS / 1e3} s` } });
+    }, ACK_TIMEOUT_MS);
+  })().catch((e) => run.finish({ ok: false, error: toRunError(e), ...e instanceof UnresponsiveTab ? { unresponsive: true } : {} }));
+  return { done, active: run };
+}
+var EVENT_FIELDS = ["method", "origin", "path", "status", "ms", "bytes"];
+function sanitize(e) {
+  const out = { level: e.level, kind: e.kind, msg: String(e.msg).slice(0, 300) };
+  if (e.data) {
+    const d = {};
+    for (const k of EVENT_FIELDS) if (e.data[k] !== void 0) d[k] = e.data[k];
+    out.data = d;
+  }
+  return out;
+}
+async function recoverUnresponsive(recipe, meta, attempt, emit) {
+  const tabId = meta.tabId;
+  const host = new URL(recipe.site.origin).host;
+  if (meta.owned) {
+    emit({ level: "warn", kind: "tab", msg: `Wield's script in its own ${host} tab did not answer (the extension was probably reloaded since); reloading that tab and retrying` });
+    try {
+      await chrome.tabs.reload(tabId);
+      await new Promise((r) => setTimeout(r, 300));
+      await waitComplete(tabId, LIMITS2.tabLoadMs);
+      await new Promise((r) => setTimeout(r, LIMITS2.tabSettleMs));
+    } catch {
+      return attempt(void 0, true);
+    }
+    return attempt(tabId);
+  }
+  await markStale(tabId);
+  emit({ level: "warn", kind: "tab", msg: `Wield's script in your ${host} tab did not answer (the extension was probably reloaded since that tab opened); running in a fresh background tab instead. Reload your tab to use it again.` });
+  return attempt(void 0, true);
+}
+var CANCELLED = { ok: false, error: { code: "cancelled", message: "Cancelled by the client" } };
+function isWrite(recipe) {
+  return recipe.effect === "write" || recipe.steps.some((s) => s.write);
+}
+var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+var nonGet = (s) => !SAFE_METHODS.has(String(s.request.method).toUpperCase());
+function hardenUnsigned(r, emit) {
+  if (r.login_check && nonGet(r.login_check)) throw new ExecError("recipe_invalid", "login_check must be a GET in a recipe the registry did not sign. Nothing was sent.", r.login_check.id);
+  const marked = r.steps.filter((s) => nonGet(s) && !s.write);
+  if (!marked.length) return r;
+  emit?.({ level: "warn", kind: "step", msg: `not signed by the registry: ${marked.map((s) => `${String(s.request.method).toUpperCase()} step ${s.id}`).join(", ")} treated as a change (Allow first)` });
+  return { ...r, effect: "write", steps: r.steps.map((s) => nonGet(s) && !s.write ? { ...s, write: true } : s) };
+}
+async function askDraft(r, run_id, signal) {
+  const domain = registrableDomain(new URL(r.site.origin).hostname);
+  const origins = [.../* @__PURE__ */ new Set([r.site.origin, ...r.site.origins ?? []])].map((o) => ({ origin: o, foreign: registrableDomain(new URL(o).hostname) !== domain }));
+  const steps = [...r.login_check ? [r.login_check] : [], ...r.steps].map((s) => ({ method: String(s.request.method).toUpperCase(), url: String(s.request.url).slice(0, 300) }));
+  const host = new URL(r.site.origin).hostname;
+  const outcome = await askUser({ kind: "draft", run_id, site: { id: r.site.id ?? host, name: r.site.name ?? host, origin: r.site.origin }, task: r.task ?? r.id, draft: { domain, origins, steps } }, signal);
+  if (outcome !== "allow") throw new ExecError("confirmation_denied", `The new recipe was not tested: ${outcome === "deny" ? "you denied it" : outcome === "timeout" ? "no answer in time" : "the window was closed"}. Nothing was sent.`);
+}
+function sleep3(ms, signal) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => (clearTimeout(t), resolve()), { once: true });
+  });
+}
+var RELOAD_SETTLE_MS = 3e3;
+var HUMAN_SETTLE_MS = 2e3;
+var CHECK_EVENT = {
+  interacted: "the user touched the page; retrying once",
+  dismissed: 'the user chose "Not now" on the check',
+  timeout: `no one touched the page within ${Math.round(LIMITS2.humanCheckMs / 1e3)} s`,
+  closed: "the site tab was closed during the check",
+  cancelled: "check cancelled"
+};
+async function humanCheck(tabId, siteName, host, signal) {
+  try {
+    const tab = await chrome.tabs.update(tabId, { active: true });
+    if (tab?.windowId !== void 0) await chrome.windows.update(tab.windowId, { focused: true, drawAttention: true }).catch(() => {
+    });
+    await inject(tabId);
+  } catch {
+    return "closed";
+  }
+  const port = chrome.tabs.connect(tabId, { name: `wield-check:${crypto.randomUUID()}` });
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish2 = (o) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        port.postMessage({ type: "hide" });
+        port.disconnect();
+      } catch {
+      }
+      resolve(o);
+    };
+    const timer = setTimeout(() => finish2("timeout"), LIMITS2.humanCheckMs);
+    signal.addEventListener("abort", () => finish2("cancelled"), { once: true });
+    port.onMessage.addListener((m) => finish2(m.type === "interacted" ? "interacted" : "dismissed"));
+    port.onDisconnect.addListener(() => {
+      chrome.tabs.get(tabId).then(() => finish2("interacted"), () => finish2("closed"));
+    });
+    port.postMessage({ type: "show", host, site_name: siteName, timeout_ms: LIMITS2.humanCheckMs });
+  });
+}
+async function recoverFromChallenge(c) {
+  const first = c.first;
+  const ch = first.challenge;
+  const host = ch?.host ?? new URL(c.recipe.site.origin).host;
+  const tabId = c.meta.tabId;
+  const fail = (why) => ({
+    ok: false,
+    error: {
+      code: "site_challenge",
+      message: `${host} answered with a bot check${ch ? ` (${ch.vendor}, HTTP ${ch.status})` : ""} instead of data. ${why}`,
+      ...first.error.step ? { step: first.error.step } : {}
+    }
+  });
+  const askUserHint = `Ask the user to open ${host} in their browser, click once on the page, then try again.`;
+  if (isWrite(c.recipe)) return fail(`Nothing was changed. ${askUserHint}`);
+  if (ch?.status === 429 || /HTTP 429/.test(first.error.message)) {
+    return { ok: false, error: { code: "site_challenge", message: `${host} is rate-limiting requests (HTTP 429). Wait a few minutes before trying again.`, ...first.error.step ? { step: first.error.step } : {} } };
+  }
+  if (c.meta.owned && c.left() > RELOAD_SETTLE_MS + 1e4) {
+    if (c.meta.openedTabId === tabId) {
+      c.emit({ level: "warn", kind: "tab", msg: `the ${host} tab was just opened; waiting ${COLD_RETRY_WAIT_MS / 1e3} s for it to settle, then retrying once` });
+      await sleep3(COLD_RETRY_WAIT_MS, c.signal);
+    } else {
+      c.emit({ level: "warn", kind: "tab", msg: `reloading the ${host} tab Wield opened, waiting ${RELOAD_SETTLE_MS / 1e3} s, then retrying once` });
+      try {
+        await chrome.tabs.reload(tabId);
+        await new Promise((r3) => setTimeout(r3, 300));
+        await waitComplete(tabId, LIMITS2.tabLoadMs);
+      } catch {
+        return fail(askUserHint);
+      }
+      await sleep3(RELOAD_SETTLE_MS, c.signal);
+    }
+    if (c.signal.aborted) return CANCELLED;
+    const r2 = await c.attempt(tabId);
+    if (r2.ok || r2.error.code !== "site_challenge") return r2;
+  }
+  if (c.left() < 1e4) return fail(askUserHint);
+  c.emit({ level: "warn", kind: "confirm", msg: `asking the user for a quick check in the ${host} tab (up to ${Math.round(LIMITS2.humanCheckMs / 1e3)} s)` });
+  const t = Date.now();
+  const outcome = await humanCheck(tabId, c.recipe.site.name, host, c.signal);
+  c.paused(Date.now() - t);
+  c.emit({ level: outcome === "interacted" ? "info" : "warn", kind: "confirm", msg: CHECK_EVENT[outcome] });
+  if (outcome === "cancelled") return CANCELLED;
+  if (outcome === "dismissed") return fail(`The user chose "Not now". ${askUserHint}`);
+  if (outcome === "timeout") return fail(`Wield showed a note in the ${host} tab for ${Math.round(LIMITS2.humanCheckMs / 1e3)} s, but no one touched the page. ${askUserHint}`);
+  if (outcome === "closed") return fail(`The ${host} tab was closed during the check.`);
+  await sleep3(HUMAN_SETTLE_MS, c.signal);
+  if (c.signal.aborted) return CANCELLED;
+  try {
+    await waitComplete(tabId, LIMITS2.tabLoadMs);
+  } catch {
+    return fail(`The ${host} tab was closed.`);
+  }
+  const r = await c.attempt(tabId);
+  if (!r.ok && r.error.code === "site_challenge") return fail("It was still blocked after the page was touched. Wait several minutes before trying again: repeated tries make it worse.");
+  return r;
+}
+var COLD_RETRY_WAIT_MS = 4e3;
+function shouldRetryCold(recipe, result, meta, budgetLeftMs) {
+  const writes = isWrite(recipe);
+  return !result.ok && result.error.code === "expect_failed" && !writes && meta.openedTabId !== void 0 && budgetLeftMs > COLD_RETRY_WAIT_MS + 8e3;
+}
+async function handleRun(msg, out, internal = {}) {
+  const run_id = msg.run_id;
+  if (typeof run_id !== "string" || !run_id) {
+    out.send({ type: "error", code: "bad_message", message: "run needs a run_id" });
+    return;
+  }
+  if (active.has(run_id)) return;
+  const t0 = Date.now();
+  const requests = [];
+  let recipe;
+  const emit = (e) => {
+    const ev = sanitize(e);
+    if (ev.kind === "request" && ev.data?.method && ev.data.origin) {
+      requests.push({ method: ev.data.method, origin: ev.data.origin, path: ev.data.path ?? "/", status: ev.data.status ?? 0, ms: ev.data.ms ?? 0 });
+    }
+    out.send({ type: "event", run_id, ts: (/* @__PURE__ */ new Date()).toISOString(), ...ev });
+  };
+  let result;
+  const runAbort = new AbortController();
+  if (await checkForNewBuild()) {
+    result = { ok: false, error: { code: "tab_error", message: `Wield was rebuilt on disk (${pendingBuild()}) but is still running ${BUILD_ID}. ${RELOAD_HINT}` } };
+    emit({ level: "error", kind: "done", msg: `tab_error: ${result.error.message}` });
+    out.send({ type: "result", run_id, ok: false, error: result.error, duration_ms: Date.now() - t0, requests: 0 });
+    return;
+  }
+  runAborts.set(run_id, runAbort);
+  try {
+    let rec = recipe = checkRecipe(msg.recipe);
+    const params = msg.params && typeof msg.params === "object" ? msg.params : {};
+    const budgetMs = Math.min(typeof msg.timeout_ms === "number" && msg.timeout_ms > 0 ? msg.timeout_ms : LIMITS2.runMs, LIMITS2.runMs);
+    emit({ level: "info", kind: "step", msg: `run ${rec.id} v${rec.version}` });
+    if (msg.policy !== void 0 && msg.policy !== null) {
+      const acc = await acceptPolicy(msg.policy);
+      if (!acc.ok) throw new ExecError("origin_blocked", `${acc.error}. Nothing was sent.`);
+    }
+    const policy = await effectivePolicy();
+    const host = new URL(rec.site.origin).host;
+    const by = blockedBy(policy, new URL(rec.site.origin).hostname);
+    if (by) throw new ExecError("origin_blocked", `Your organization's policy (${by}) doesn't allow ${host}. Nothing was sent.`);
+    if (await isPaused(new URL(rec.site.origin).hostname)) {
+      throw new ExecError("origin_blocked", `You paused ${host} in Wield. Resume it in the Wield popup to let your agent use it. Nothing was sent.`);
+    }
+    const sig = await checkRecipeSignature(msg.recipe, msg.signature, policy, msg.source, msg.draft, internal.bundled === true);
+    emit(
+      sig.status === "verified" ? { level: "info", kind: "step", msg: `recipe signature ok (${sig.kid}, ${sig.scope})` } : { level: "warn", kind: "step", msg: sig.why === "draft" ? "unsigned builder draft, run once to verify it" : sig.why === "local" ? "unsigned local recipe (developer folder)" : sig.why === "bundled" ? "the sample recipe packaged with Wield" : "recipe is unsigned" }
+    );
+    const trust = sig.status === "verified" && sig.scope === "public" ? "registry" : void 0;
+    if (trust) {
+      const why = await withdrawnReason(rec.id, rec.version);
+      if (why) throw new ExecError("recipe_invalid", `${why}. Nothing was sent.`);
+    }
+    if (!trust) rec = recipe = hardenUnsigned(rec, emit);
+    if (policy.writesDenied && isWrite(rec)) {
+      throw new ExecError("confirmation_denied", `Your organization's policy (${policy.writesDenied}) doesn't allow actions that change something on a site. Nothing was sent.`);
+    }
+    if (sig.status === "unsigned" && sig.why === "draft") await askDraft(rec, run_id, runAbort.signal);
+    let pausedMs = 0;
+    const left = () => budgetMs - (Date.now() - t0 - pausedMs);
+    const meta = {};
+    const attempt = (tabId, forceNewTab = false) => execute({ run_id, recipe: rec, params, mode: "run", budgetMs: Math.max(1e3, left()), emit, meta, tabId, forceNewTab, ...trust ? { trust } : {} }).done;
+    result = await attempt();
+    if (!result.ok && result.unresponsive && meta.tabId !== void 0 && !runAbort.signal.aborted) {
+      result = await recoverUnresponsive(rec, meta, attempt, emit);
+    }
+    if (shouldRetryCold(rec, result, meta, left())) {
+      emit({ level: "warn", kind: "step", msg: `the site tab was just opened; waiting ${COLD_RETRY_WAIT_MS / 1e3} s for it to settle, then retrying once` });
+      await sleep3(COLD_RETRY_WAIT_MS, runAbort.signal);
+      result = runAbort.signal.aborted ? CANCELLED : await attempt(meta.openedTabId);
+    }
+    if (!result.ok && result.error.code === "site_challenge" && meta.tabId !== void 0 && !runAbort.signal.aborted) {
+      result = await recoverFromChallenge({ recipe: rec, first: result, meta, attempt, emit, signal: runAbort.signal, left, paused: (ms) => pausedMs += ms });
+    }
+  } catch (e) {
+    result = { ok: false, error: toRunError(e, "recipe_invalid") };
+  } finally {
+    runAborts.delete(run_id);
+  }
+  const duration_ms = Date.now() - t0;
+  emit({
+    level: result.ok ? "info" : "error",
+    kind: "done",
+    msg: result.ok ? `ok in ${duration_ms} ms, ${requests.length} requests` : `${result.error.code}: ${result.error.message}`
+  });
+  out.send(
+    result.ok ? { type: "result", run_id, ok: true, output: result.output, duration_ms, requests: requests.length } : { type: "result", run_id, ok: false, error: result.error, duration_ms, requests: requests.length }
+    // challenge details stay local
+  );
+  await recordRun({
+    run_id,
+    recipe_id: recipe?.id ?? (typeof msg.recipe?.id === "string" ? String(msg.recipe.id).slice(0, 80) : "(invalid recipe)"),
+    version: recipe?.version ?? 0,
+    site_id: recipe?.site?.id ?? "",
+    ...recipe?.site?.origin ? { origin: recipe.site.origin } : {},
+    kind: "run",
+    started_at: new Date(t0).toISOString(),
+    duration_ms,
+    ok: result.ok,
+    ...result.ok ? {} : { error_code: result.error.code },
+    requests
+  }).catch(() => {
+  });
+}
+async function handleStatus(msg, out, version) {
+  const req_id = typeof msg.req_id === "string" ? msg.req_id : "";
+  const sites = Array.isArray(msg.sites) ? msg.sites.slice(0, 40) : [];
+  const results = await Promise.all(sites.map((s) => checkSite(s, req_id, out)));
+  out.send({ type: "status_result", req_id, extension_version: version, sites: results.map(({ site_id, logged_in, tab_open }) => ({ site_id, logged_in, tab_open })) });
+  await recordSites(results).catch(() => {
+  });
+}
+async function checkSite(s, req_id, out) {
+  const site_id = String(s.site_id ?? "");
+  const origin = isAllowedOrigin(s.origin) ? s.origin : "";
+  const base = { site_id, origin, logged_in: null, tab_open: false, checked_at: (/* @__PURE__ */ new Date()).toISOString() };
+  if (!origin) return base;
+  const tabs = (await tabsForOrigin(origin)).filter((t) => t.status === "complete" && !t.discarded);
+  base.tab_open = tabs.length > 0;
+  if (!tabs.length || !s.login_check || !await chrome.permissions.contains({ origins: [originPattern(origin)] })) return base;
+  if (blockedBy(await effectivePolicy(), new URL(origin).hostname) || await isPaused(new URL(origin).hostname)) return base;
+  const lc = s.login_check;
+  const recipe = {
+    id: `${site_id}/login-check`,
+    version: 1,
+    task: "Check login state",
+    effect: "read",
+    requires_login: true,
+    site: { id: site_id, name: site_id, origin, origins: [origin] },
+    steps: [],
+    login_check: { ...lc, id: lc?.id ?? "login_check" },
+    // status.sites[].auth (CHANGES 11:58, C1): a login check may need a derived token.
+    ...s.auth && typeof s.auth === "object" ? { auth: s.auth } : {}
+  };
+  const run_id = `${req_id}:${site_id}`;
+  const t0 = Date.now();
+  const requests = [];
+  try {
+    if (!lc?.request?.url) throw new ExecError("recipe_invalid", "login_check has no request");
+    checkHeaders(lc);
+    const r = await execute({
+      run_id,
+      recipe,
+      params: {},
+      mode: "login_check",
+      budgetMs: 1e4,
+      tabId: tabs[0].id,
+      emit: (e) => {
+        const ev = sanitize(e);
+        if (ev.kind !== "request") return;
+        if (ev.data?.method) requests.push({ method: ev.data.method, origin: ev.data.origin ?? origin, path: ev.data.path ?? "/", status: ev.data.status ?? 0, ms: ev.data.ms ?? 0 });
+        out.send({ type: "event", run_id: req_id, ts: (/* @__PURE__ */ new Date()).toISOString(), ...ev });
+      }
+    }).done;
+    base.logged_in = r.ok && typeof r.output === "boolean" ? r.output : null;
+  } catch {
+    base.logged_in = null;
+  }
+  await recordRun({ run_id, recipe_id: recipe.id, version: 1, site_id, kind: "status", started_at: new Date(t0).toISOString(), duration_ms: Date.now() - t0, ok: base.logged_in !== null, requests }).catch(() => {
+  });
+  return base;
+}
+
+// apps/extension/src/sw/recorder.ts
+var MAX_ENTRIES = 400;
+var MAX_BODY = 1e6;
+var MAX_TOTAL_BODY = 8e6;
+var MAX_RECORDING_MS = 10 * 6e4;
+var REVIEW_TIMEOUT_MS = 15 * 6e4;
+var REC_SCRIPT_ID = "wield-rec-main";
+var NONCE_KEY = "__wield_rec__";
+var NAV_KEY = "__wield_rec_nav__";
+var COOKIE_STANDIN = "sent by the browser (not visible to the recorder)";
+var current = null;
+var recId = () => `rec_${crypto.randomUUID().replace(/-/g, "").slice(0, 16)}`;
+function progress(r, msg, level = "info") {
+  if (r.req_id) r.out?.send({ type: "event", run_id: r.req_id, ts: (/* @__PURE__ */ new Date()).toISOString(), level, kind: "step", msg });
+}
+function recordingState() {
+  if (!current) return null;
+  return { rec_id: current.rec_id, origin: current.origin, task: current.task, state: current.state, requests: current.entries.size, started_at: current.started_at };
+}
+async function startRecording(opts, out) {
+  if (current) return { ok: false, error: `A recording is already running on ${new URL(current.origin).host}. Finish or cancel it first.` };
+  let origin;
+  try {
+    origin = new URL(opts.origin).origin;
+  } catch {
+    return { ok: false, error: "origin must be a URL like https://www.example.de" };
+  }
+  if (!origin.startsWith("https://")) return { ok: false, error: "Wield records only https sites." };
+  const host = new URL(origin).hostname;
+  const by = blockedBy(await effectivePolicy(), host);
+  if (by) return { ok: false, error: `Your organization's policy (${by}) doesn't allow ${host}.` };
+  if (!opts.fromPopup) {
+    const outcome = await askUser({ kind: "record", run_id: opts.req_id ?? "record", site: { id: host, name: host, origin }, task: opts.task }, new AbortController().signal);
+    if (outcome !== "allow") return { ok: false, error: "The user did not allow recording." };
+  }
+  if (!await chrome.permissions.contains({ origins: [originPattern(origin)] })) {
+    const outcome = await askUser({ kind: "permission", run_id: opts.req_id ?? "record", site: { id: host, name: host, origin }, task: opts.task || "Record a task" }, new AbortController().signal);
+    if (outcome !== "allow" || !await chrome.permissions.contains({ origins: [originPattern(origin)] })) return { ok: false, error: `Access to ${host} was not granted.` };
+  }
+  let tabId = opts.tabId;
+  if (tabId === void 0) {
+    try {
+      tabId = (await acquireTab(origin, new AbortController().signal)).tabId;
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  }
+  const tab = await chrome.tabs.update(tabId, { active: true });
+  if (tab?.windowId !== void 0) await chrome.windows.update(tab.windowId, { focused: true }).catch(() => {
+  });
+  const r = {
+    rec_id: recId(),
+    ...opts.req_id ? { req_id: opts.req_id } : {},
+    origin,
+    task: (opts.task ?? "").slice(0, 300),
+    tabId,
+    nonce: crypto.randomUUID(),
+    started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    t0: Date.now(),
+    entries: /* @__PURE__ */ new Map(),
+    bodyBytes: 0,
+    typedPages: /* @__PURE__ */ new Map(),
+    state: "recording",
+    ...out ? { out } : {}
+  };
+  try {
+    await startCapture(r);
+  } catch (e) {
+    await stopCapture(r);
+    return { ok: false, error: `Could not start recording in that tab: ${e.message}` };
+  }
+  current = r;
+  r.timer = setTimeout(() => void finish(r, "done"), MAX_RECORDING_MS);
+  await attachBar(r);
+  progress(r, `recording on ${new URL(origin).host}: waiting for the user to do the task and click Done`);
+  return { ok: true, rec_id: r.rec_id };
+}
+async function startCapture(r) {
+  await chrome.storage.session.set({ rec_active: { tabId: r.tabId } });
+  await chrome.scripting.executeScript({ target: { tabId: r.tabId }, func: (k, n) => sessionStorage.setItem(k, n), args: [NONCE_KEY, r.nonce] });
+  await chrome.scripting.unregisterContentScripts({ ids: [REC_SCRIPT_ID] }).catch(() => {
+  });
+  await chrome.scripting.registerContentScripts([
+    { id: REC_SCRIPT_ID, js: ["recmain.js"], matches: [originPattern(r.origin)], runAt: "document_start", world: "MAIN", allFrames: false, persistAcrossSessions: false }
+  ]);
+  await chrome.scripting.executeScript({ target: { tabId: r.tabId }, files: ["recmain.js"], world: "MAIN" });
+}
+async function stopCapture(r) {
+  await chrome.scripting.unregisterContentScripts({ ids: [REC_SCRIPT_ID] }).catch(() => {
+  });
+  await chrome.scripting.executeScript({
+    target: { tabId: r.tabId },
+    func: (keys) => {
+      for (const k of keys) {
+        try {
+          sessionStorage.removeItem(k);
+        } catch {
+        }
+      }
+    },
+    args: [[NONCE_KEY, NAV_KEY]]
+  }).catch(() => {
+  });
+  await chrome.storage.session.remove("rec_active").catch(() => {
+  });
+}
+void (async () => {
+  const { rec_active } = await chrome.storage.session.get("rec_active").catch(() => ({}));
+  if (rec_active && !current) await stopCapture(rec_active);
+})();
+chrome.tabs.onRemoved.addListener((tabId) => {
+  if (current && current.tabId === tabId && current.state === "recording") void finish(current, "done", true);
+});
+async function attachBar(r) {
+  if (current !== r || r.state !== "recording") return;
+  try {
+    await chrome.scripting.executeScript({ target: { tabId: r.tabId }, files: ["content.js"] });
+    const port = chrome.tabs.connect(r.tabId, { name: `wield-rec:${r.rec_id}` });
+    r.port = port;
+    port.onMessage.addListener((m) => {
+      if (current !== r) return;
+      if (m.type === "entry" && m.entry && typeof m.entry === "object") addEntry(r, m.entry);
+      else if (m.type === "typed" && Array.isArray(m.typed) && r.typedPages.size < 50) r.typedPages.set(String(m.page ?? "page").slice(0, 20), cleanTyped(m.typed));
+      else if (m.type === "done") void finish(r, "done");
+      else if (m.type === "cancel") void finish(r, "cancel");
+    });
+    port.onDisconnect.addListener(() => current === r && r.state === "recording" && setTimeout(() => void attachBar(r), 300));
+    port.postMessage({ type: "show", host: new URL(r.origin).host, task: r.task, started_at: r.t0, max_ms: MAX_RECORDING_MS, requests: r.entries.size, nonce: r.nonce });
+  } catch {
+  }
+}
+function cleanTyped(list) {
+  return list.filter((t) => !!t && typeof t.value === "string" && typeof t.label === "string").slice(0, 50).map((t) => ({ label: t.label.slice(0, 80), ...typeof t.name === "string" ? { name: t.name.slice(0, 80) } : {}, input_type: String(t.input_type ?? "text").slice(0, 30), value: t.value.slice(0, 200) }));
+}
+function typedValues(r) {
+  const all = [];
+  for (const list of r.typedPages.values()) for (const t of list) if (!all.some((p) => p.value === t.value && p.label === t.label)) all.push(t);
+  return all.slice(0, 50);
+}
+function headerMap(h) {
+  const out = {};
+  if (!h || typeof h !== "object") return out;
+  for (const [k, v] of Object.entries(h).slice(0, 60)) if (typeof v === "string") out[k.slice(0, 100)] = v.slice(0, 4096);
+  return out;
+}
+function addEntry(r, e) {
+  if (r.state !== "recording" || r.entries.size >= MAX_ENTRIES) return;
+  if (typeof e.url !== "string" || !/^https?:\/\//.test(e.url)) return;
+  let body = typeof e.body === "string" ? e.body : void 0;
+  let truncated = e.body_truncated === true;
+  if (body !== void 0) {
+    if (r.bodyBytes >= MAX_TOTAL_BODY) {
+      body = void 0;
+      truncated = true;
+    } else {
+      if (body.length > MAX_BODY) {
+        body = body.slice(0, MAX_BODY);
+        truncated = true;
+      }
+      r.bodyBytes += body.length;
+    }
+  }
+  const request_headers = headerMap(e.request_headers);
+  if (e.sends_cookies === true && !Object.keys(request_headers).some((k) => k.toLowerCase() === "cookie")) request_headers.cookie = COOKIE_STANDIN;
+  const seq = r.entries.size + 1;
+  r.entries.set(String(seq), {
+    seq,
+    t_ms: Math.max(0, Math.round(Number(e.started) - r.t0) || 0),
+    method: String(e.method ?? "GET").toUpperCase().slice(0, 10),
+    url: e.url.slice(0, 4096),
+    resource_type: e.kind === "document" ? "Document" : e.kind === "xhr" ? "XHR" : "Fetch",
+    request_headers,
+    ...typeof e.post_data === "string" ? { post_data: e.post_data.slice(0, 65536) } : {},
+    ...typeof e.status === "number" ? { status: e.status } : {},
+    ...typeof e.mime === "string" && e.mime ? { mime: e.mime.split(";")[0].trim().slice(0, 100) } : {},
+    response_headers: headerMap(e.response_headers),
+    ...body !== void 0 ? { body, body_bytes: body.length } : {},
+    ...truncated ? { body_truncated: true } : {},
+    ...typeof e.failed === "string" ? { failed: e.failed.slice(0, 200) } : {}
+  });
+}
+async function finish(r, how, tabGone = false) {
+  if (current !== r || r.state !== "recording") return;
+  clearTimeout(r.timer);
+  await new Promise((res) => setTimeout(res, how === "done" && !tabGone ? 600 : 0));
+  await stopCapture(r);
+  try {
+    r.port?.postMessage({ type: "hide" });
+    r.port?.disconnect();
+  } catch {
+  }
+  if (how === "cancel") {
+    progress(r, "the user cancelled the recording", "warn");
+    if (r.req_id) r.out?.send({ type: "recording", req_id: r.req_id, rec_id: r.rec_id, ok: false, discarded: true, error: { code: "cancelled", message: "The user cancelled the recording. Nothing was sent." } });
+    current = null;
+    return;
+  }
+  r.state = "review";
+  const raw = {
+    rec_id: r.rec_id,
+    origin: r.origin,
+    task: r.task,
+    started_at: r.started_at,
+    duration_ms: Date.now() - r.t0,
+    extension_version: chrome.runtime.getManifest().version,
+    entries: [...r.entries.values()].sort((a, b) => a.t_ms - b.t_ms || a.seq - b.seq).map((e, i) => ({ ...e, seq: i + 1 })),
+    typed: typedValues(r)
+  };
+  await chrome.storage.session.set({ [`rec:${r.rec_id}`]: raw });
+  r.entries.clear();
+  progress(r, `the user clicked Done (${raw.entries.length} requests captured); waiting for them to review what would be sent`);
+  await chrome.tabs.create({ url: chrome.runtime.getURL(`record.html#${r.rec_id}`), active: true });
+  r.timer = setTimeout(() => void discard(r.rec_id, "No answer on the review page within 15 minutes. Nothing was sent."), REVIEW_TIMEOUT_MS);
+}
+async function stopRecording(how) {
+  if (!current || current.state !== "recording") return false;
+  await finish(current, how);
+  return true;
+}
+async function sendRecording(rec_id, trace) {
+  const problems = validateTrace(trace);
+  if (problems.length) return { ok: false, delivered: "refused", message: `Not sent: ${problems[0].message}. Nothing left your browser.` };
+  const r = current;
+  await chrome.storage.session.remove(`rec:${rec_id}`);
+  await saveTrace(trace);
+  if (r && r.rec_id === rec_id) {
+    clearTimeout(r.timer);
+    current = null;
+    if (r.req_id && r.out?.send({ type: "recording", req_id: r.req_id, rec_id, ok: true, trace })) {
+      return { ok: true, delivered: "agent", message: "Sent to your agent. It builds the recipe next." };
+    }
+    if (!r.req_id && r.out?.send({ type: "recording", rec_id, ok: true, trace })) {
+      return { ok: true, delivered: "saved", message: `Saved on this computer for your agent (recording ${rec_id}). Ask your agent to build a recipe from it.` };
+    }
+  }
+  return { ok: true, delivered: "saved", message: "Kept in this browser only (Wield\u2019s helper isn\u2019t connected). Download it from here, or connect Wield and record again." };
+}
+async function discard(rec_id, why = "The user discarded the recording. Nothing was sent.") {
+  await chrome.storage.session.remove(`rec:${rec_id}`);
+  const r = current;
+  if (r && r.rec_id === rec_id) {
+    clearTimeout(r.timer);
+    current = null;
+    if (r.req_id) r.out?.send({ type: "recording", req_id: r.req_id, rec_id, ok: false, discarded: true, error: { code: "cancelled", message: why } });
+  }
+}
+async function saveTrace(trace) {
+  const { saved_traces = [] } = await chrome.storage.local.get("saved_traces");
+  saved_traces.unshift(trace);
+  await chrome.storage.local.set({ saved_traces: saved_traces.slice(0, 5) });
+}
+
+// apps/extension/src/sw/index.ts
+var VERSION = chrome.runtime.getManifest().version;
+var CAPABILITIES = ["policy", "signed_recipes", "warm", "record", "index", ...INTERPRETER_FEATURES];
+function browserName() {
+  const brands = navigator.userAgentData?.brands ?? [];
+  const b = brands.find((x) => /Chrome|Chromium|Edge|Brave|Opera/.test(x.brand) && !/Not/.test(x.brand));
+  if (b) return `${b.brand.replace("Google ", "")} ${b.version}`;
+  const m = navigator.userAgent.match(/Chrome\/(\d+)/);
+  return m ? `Chrome ${m[1]}` : "Chromium";
+}
+var link = new NativeLink(
+  (msg) => void onBridgeMessage(msg),
+  (s) => void recordBridge(s)
+);
+async function onBridgeMessage(raw) {
+  const msg = raw;
+  switch (msg?.type) {
+    case "hello":
+      link.send({
+        type: "hello_ack",
+        extension_version: VERSION,
+        browser: browserName(),
+        protocol: PROTOCOL_VERSION,
+        capabilities: CAPABILITIES,
+        policy: policySummary(await effectivePolicy())
+      });
+      return;
+    case "record_start":
+    case "record": {
+      const m = msg;
+      if (!m.req_id) return void link.send({ type: "error", code: "bad_message", message: "record needs req_id" });
+      const r = await startRecording({ origin: String(m.origin ?? ""), task: String(m.task ?? ""), req_id: m.req_id }, link);
+      if (!r.ok) {
+        const code = /policy/.test(r.error) ? "origin_blocked" : /not allow|not granted/.test(r.error) ? "confirmation_denied" : "tab_error";
+        link.send({ type: "recording", req_id: m.req_id, ok: false, error: { code, message: r.error } });
+      }
+      return;
+    }
+    case "warm": {
+      const m = msg;
+      if (!isAllowedOrigin(m.origin)) return;
+      if (blockedBy(await effectivePolicy(), new URL(m.origin).hostname) || await isPaused(new URL(m.origin).hostname)) return;
+      if (!await chrome.permissions.contains({ origins: [originPattern(m.origin)] })) return;
+      await warmTab(m.origin, typeof m.start_path === "string" ? m.start_path : void 0).catch(() => "skipped");
+      return;
+    }
+    case "index": {
+      const r = await acceptIndex(msg.document);
+      link.send({ type: "index_ack", ...msg.req_id ? { req_id: msg.req_id } : {}, ...r });
+      return;
+    }
+    case "policy": {
+      const r = await acceptPolicy(msg.document);
+      link.send({ type: "policy_ack", ...msg.req_id ? { req_id: msg.req_id } : {}, ...r });
+      return;
+    }
+    case "run":
+      await handleRun(msg, link);
+      return;
+    case "cancel":
+      if (typeof msg.run_id === "string") cancelRun(msg.run_id);
+      return;
+    case "status":
+      await handleStatus(msg, link, VERSION);
+      return;
+    default:
+      link.send({
+        type: "error",
+        code: "bad_message",
+        message: `Unknown message type: ${String(msg?.type).slice(0, 40)}`,
+        ...msg?.run_id ? { run_id: msg.run_id } : {},
+        ...msg?.req_id ? { req_id: msg.req_id } : {}
+      });
+  }
+}
+chrome.runtime.onMessageExternal.addListener((m, sender, reply) => {
+  let host = "";
+  try {
+    host = new URL(sender.origin ?? sender.url ?? "").hostname;
+  } catch {
+    return false;
+  }
+  const allowed = host === "wield.run" || false;
+  if (!allowed || sender.origin && !sender.origin.startsWith("https://")) return false;
+  if (m?.type !== "ping") reply({ type: "error", message: 'Only {type: "ping"} is supported.' });
+  else reply({ type: "pong", product: "wield", version: VERSION, bridge: link.connected ? "connected" : "offline" });
+  return false;
+});
+var OWN_PAGES = chrome.runtime.getURL("");
+chrome.runtime.onMessage.addListener((m, sender, reply) => {
+  if (sender.id !== chrome.runtime.id || !sender.url?.startsWith(OWN_PAGES)) return false;
+  if (m?.type === "ask_answer" && typeof m.id === "string") {
+    reply({ ok: answerAsk(m.id, m.allow === true) });
+    return false;
+  }
+  if (m?.type === "popup_state") {
+    link.ensure();
+    void checkForNewBuild();
+    Promise.all([chrome.storage.local.get(["runs", "sites"]), paceSnapshot()]).then(async ([local, pace]) => {
+      reply({
+        version: VERSION,
+        browser: browserName(),
+        bridge: link.state,
+        active_runs: activeRuns(),
+        runs: local.runs ?? [],
+        sites: Object.values(local.sites ?? {}),
+        sites_overview: await sitesOverview(local.runs ?? [], Object.values(local.sites ?? {})),
+        pace,
+        policy: policySummary(await effectivePolicy()),
+        build: BUILD_ID,
+        recording: recordingState(),
+        pending_build: pendingBuild()
+      });
+    });
+    return true;
+  }
+  if (m?.type === "record_begin" && typeof m.tabId === "number") {
+    chrome.tabs.get(m.tabId).then(async (tab) => {
+      const origin = tab.url ? new URL(tab.url).origin : "";
+      reply(await startRecording({ origin, task: String(m.task ?? ""), tabId: m.tabId, fromPopup: true }, link));
+    }, () => reply({ ok: false, error: "That tab is gone." }));
+    return true;
+  }
+  if (m?.type === "record_stop") {
+    stopRecording(m.how === "cancel" ? "cancel" : "done").then((ok) => reply({ ok }));
+    return true;
+  }
+  if (m?.type === "record_send" && typeof m.rec_id === "string" && m.trace) {
+    sendRecording(m.rec_id, m.trace).then(reply);
+    return true;
+  }
+  if (m?.type === "record_discard" && typeof m.rec_id === "string") {
+    discard(m.rec_id).then(() => reply({ ok: true }));
+    return true;
+  }
+  if (m?.type === "sample_run") {
+    (async () => {
+      const recipe = await (await fetch(chrome.runtime.getURL("sample-recipe.json"))).json();
+      const run_id = `sample_${crypto.randomUUID().slice(0, 8)}`;
+      let resolve;
+      const result = new Promise((r) => resolve = r);
+      const capture = { send: (msg) => (msg.type === "result" && resolve(msg), true) };
+      await handleRun({ run_id, recipe, params: recipe.verify?.example_params ?? {}, timeout_ms: 3e4 }, capture, { bundled: true });
+      reply(await result);
+    })().catch((e) => reply({ ok: false, error: { code: "tab_error", message: String(e?.message ?? e) } }));
+    return true;
+  }
+  if (m?.type === "site_pause" && typeof m.host === "string") {
+    setPaused(m.host, m.paused === true).then(() => reply({ ok: true }));
+    return true;
+  }
+  if (m?.type === "site_revoke" && typeof m.origin === "string" && /^https:\/\/[a-z0-9.-]+$/.test(m.origin)) {
+    chrome.permissions.remove({ origins: [`${m.origin}/*`] }).then((ok) => reply({ ok }), () => reply({ ok: false }));
+    return true;
+  }
+  if (m?.type === "reload_extension") {
+    reply({ ok: true });
+    setTimeout(() => chrome.runtime.reload(), 100);
+    return false;
+  }
+  if (m?.type === "reconnect") {
+    link.connect();
+    void checkForNewBuild();
+    setInterval(() => void checkForNewBuild(), 15e3);
+    reply({ ok: true });
+    return false;
+  }
+  return false;
+});
+chrome.runtime.onStartup.addListener(() => link.ensure());
+chrome.runtime.onInstalled.addListener((d) => {
+  link.ensure();
+  if (d.reason === "install") void chrome.tabs.create({ url: chrome.runtime.getURL("welcome.html") });
+});
+chrome.tabs.onUpdated.addListener(() => link.ensure());
+chrome.tabs.onActivated.addListener(() => link.ensure());
+link.connect();
+void checkForNewBuild();
+setInterval(() => void checkForNewBuild(), 15e3);
+globalThis.wield = { link, version: VERSION, build: BUILD_ID, buildOnDisk };