@wenathlan/extension 1.1.43 → 1.1.45

package/extension/dist/background.js

@@ -862,15 +862,22 @@ var sessionmemory = class {
   async getfetchconsents() {
     return await this.adapter.get("fetchconsents") ?? [];
   }
-  /** Stores one api key reference record without any key material; the secret value stays behind its storage id. */
-  async setapikey(ref) {
-    const records = (await this.adapter.get("apikeys") ?? []).filter((item) => item.name !== ref.name);
-    await this.adapter.set("apikeys", [ref, ...records]);
+  /** Stores one api key entry with its origin scope and created time, replacing the previous entry of that name; the key material stays behind its storage id. */
+  async setapikey(entry) {
+    const records = (await this.adapter.get("apikeys") ?? []).filter((item) => item.name !== entry.name);
+    await this.adapter.set("apikeys", [entry, ...records]);
   }
-  /** Returns every stored api key reference with its origin scope, header name and storage id; key material never loads here. */
+  /** Returns every stored api key entry with its origin scope, header name, storage id and last use timestamp; key material never loads here. */
   async getapikeys() {
     return await this.adapter.get("apikeys") ?? [];
   }
+  /** Stamps the last use timestamp of one stored api key entry without ever loading the key material. */
+  async touchapikey(name, at) {
+    const records = await this.getapikeys();
+    const entry = records.find((item) => item.name === name);
+    if (!entry) return;
+    await this.adapter.set("apikeys", [{ ...entry, lastuse: at }, ...records.filter((item) => item.name !== name)]);
+  }
   /** Removes one api key reference and its stored secret together. */
   async removeapikey(name) {
     const records = await this.getapikeys();
@@ -967,6 +974,171 @@ var sessionmemory = class {
   async getsubscriptions() {
     return await this.adapter.get("subscriptions") ?? [];
   }
+  /** Stores one registered request block rule of a run, replacing the previous rule of that id; every rule reverts and stays auditable after the run ends. */
+  async addblockrule(rule) {
+    const records = (await this.adapter.get("blockrules") ?? []).filter((item) => item.id !== rule.id);
+    await this.adapter.set("blockrules", [rule, ...records]);
+  }
+  /** Returns every stored block rule, newest first. */
+  async getblockrules() {
+    return await this.adapter.get("blockrules") ?? [];
+  }
+  /** Stores one registered response mock fixture of a run, replacing the previous fixture of that id; the fixture body stays out of every audit trail. */
+  async addmockspec(spec) {
+    const records = (await this.adapter.get("mockspecs") ?? []).filter((item) => item.id !== spec.id);
+    await this.adapter.set("mockspecs", [spec, ...records]);
+  }
+  /** Returns every stored mock fixture, newest first. */
+  async getmockspecs() {
+    return await this.adapter.get("mockspecs") ?? [];
+  }
+  /** Stores one registered header rewrite rule of a run, replacing the previous rule of that id; the provenance of every applied rule stays auditable. */
+  async addheaderule(rule) {
+    const records = (await this.adapter.get("headerules") ?? []).filter((item) => item.id !== rule.id);
+    await this.adapter.set("headerules", [rule, ...records]);
+  }
+  /** Returns every stored header rewrite rule, newest first. */
+  async getheaderules() {
+    return await this.adapter.get("headerules") ?? [];
+  }
+  /** Stores one cookie operation of a run per domain with its timestamp; cookie values never enter the operation record. */
+  async addcookieop(operation) {
+    const records = await this.adapter.get("cookieops") ?? [];
+    await this.adapter.set("cookieops", [operation, ...records]);
+  }
+  /** Returns every stored cookie operation, newest first, optionally filtered by domain. */
+  async getcookieops(domain) {
+    const records = await this.adapter.get("cookieops") ?? [];
+    return records.filter((item) => domain === void 0 || item.domain === domain);
+  }
+  /** Stores one token record of a provider with scopes, origin scope and expiry; the token values stay behind their storage ids. */
+  async addtoken(record2) {
+    const records = (await this.adapter.get("tokens") ?? []).filter((item) => item.id !== record2.id);
+    await this.adapter.set("tokens", [record2, ...records]);
+  }
+  /** Returns every stored token record, newest first, optionally filtered by provider; token values never load here. */
+  async listtokens(provider) {
+    const records = await this.adapter.get("tokens") ?? [];
+    return records.filter((item) => provider === void 0 || item.provider === provider);
+  }
+  /** Stores one applied proxy route of a run with its apply time, replacing the previous route of that id; the history keeps the revert times. */
+  async addproxyroute(route) {
+    const records = (await this.adapter.get("proxyroutes") ?? []).filter((item) => item.id !== route.id);
+    await this.adapter.set("proxyroutes", [route, ...records]);
+  }
+  /** Returns every stored proxy route with apply and revert times, newest first. */
+  async getproxyroutes() {
+    return await this.adapter.get("proxyroutes") ?? [];
+  }
+  /** Stores one parsed rate limit read per origin, replacing the previous read of that origin. */
+  async setratelimit(read) {
+    const records = (await this.adapter.get("ratelimits") ?? []).filter((item) => item.origin !== read.origin);
+    await this.adapter.set("ratelimits", [read, ...records]);
+  }
+  /** Returns every stored rate limit read whose reset window has not passed yet; expired states drop out at their reset windows. */
+  async getratelimits(now) {
+    const records = await this.adapter.get("ratelimits") ?? [];
+    const live = records.filter((item) => item.resetat > now);
+    if (live.length !== records.length) await this.adapter.set("ratelimits", live);
+    return live;
+  }
+  /** Stores one run timeline entry; the user configured timeline retention window expires the oldest entries while their level counts survive in the per run level summaries. */
+  async addtimelineentry(entry) {
+    const records = await this.gettimeline();
+    const combined = [entry, ...records];
+    const retention = (await this.getsettings())?.timelineretention;
+    if (retention === void 0) {
+      await this.adapter.set("timelineentries", combined);
+      return;
+    }
+    const kept = combined.slice(0, retention);
+    const expired = combined.slice(retention);
+    if (expired.length > 0) {
+      const expiredcounts = /* @__PURE__ */ new Map();
+      for (const item of expired) {
+        const counts = expiredcounts.get(item.runid) ?? {};
+        counts[item.level] = (counts[item.level] ?? 0) + 1;
+        expiredcounts.set(item.runid, counts);
+      }
+      for (const [runid, counts] of expiredcounts) await this.mergelevelsummary(runid, counts, Date.now());
+    }
+    await this.adapter.set("timelineentries", kept);
+  }
+  /** Returns every stored run timeline entry, newest first. */
+  async gettimeline() {
+    return await this.adapter.get("timelineentries") ?? [];
+  }
+  /** Returns the run timeline entries filtered by run, level and step id. */
+  async listtimeline(filter) {
+    const records = await this.gettimeline();
+    return records.filter((item) => (filter.runid === void 0 || item.runid === filter.runid) && (filter.level === void 0 || item.level === filter.level) && (filter.stepid === void 0 || item.stepid === filter.stepid));
+  }
+  /** Stores one captured javascript error record with its stack frames, source url and line. */
+  async adderrorrecord(record2) {
+    const records = await this.adapter.get("errorrecords") ?? [];
+    await this.adapter.set("errorrecords", [record2, ...records]);
+  }
+  /** Returns every stored error record, newest first. */
+  async geterrorrecords() {
+    return await this.adapter.get("errorrecords") ?? [];
+  }
+  /** Stores one captured unhandled rejection record with its reason and stack frames. */
+  async addrejectionrecord(record2) {
+    const records = await this.adapter.get("rejectionrecords") ?? [];
+    await this.adapter.set("rejectionrecords", [record2, ...records]);
+  }
+  /** Returns every stored rejection record, newest first. */
+  async getrejectionrecords() {
+    return await this.adapter.get("rejectionrecords") ?? [];
+  }
+  /** Stores one captured long task entry with its duration, start time and attribution names. */
+  async addlongtask(record2) {
+    const records = await this.adapter.get("longtasks") ?? [];
+    await this.adapter.set("longtasks", [record2, ...records]);
+  }
+  /** Returns every stored long task entry, newest first. */
+  async getlongtasks() {
+    return await this.adapter.get("longtasks") ?? [];
+  }
+  /** Stores one console diff result between two runs, replacing the previous one. */
+  async addconsolediff(diff) {
+    return this.adapter.set("consolediff", diff);
+  }
+  /** Returns the one stored console diff result. */
+  async getdiff() {
+    return this.adapter.get("consolediff");
+  }
+  /** Stores one log rotation target record with its overflow entry counts, replacing the previous record of that target and run. */
+  async addrotationtarget(record2) {
+    const records = (await this.adapter.get("rotationtargets") ?? []).filter((item) => !(item.target === record2.target && item.runid === record2.runid));
+    await this.adapter.set("rotationtargets", [record2, ...records]);
+  }
+  /** Returns every stored rotation target record with its overflow entry counts, newest first. */
+  async getrotationtargets() {
+    return await this.adapter.get("rotationtargets") ?? [];
+  }
+  /** Stores one console capture consent decision per origin; the approved decision persists so console watching on that origin prompts once. */
+  async setconsoleconsent(consent) {
+    const records = (await this.adapter.get("consoleconsents") ?? []).filter((item) => item.id !== consent.id);
+    await this.adapter.set("consoleconsents", [consent, ...records]);
+  }
+  /** Returns every console capture consent decision, newest first. */
+  async getconsoleconsents() {
+    return await this.adapter.get("consoleconsents") ?? [];
+  }
+  /** Merges expired entry counts into the per run level count summary that survives the retention window. */
+  async mergelevelsummary(runid, counts, now) {
+    const records = await this.getlevelsummaries();
+    const existing = records.find((item) => item.runid === runid);
+    const merged = { ...existing?.counts ?? {} };
+    for (const [level, count] of Object.entries(counts)) merged[level] = (merged[level] ?? 0) + count;
+    const updated = { runid, counts: merged, at: now };
+    await this.adapter.set("levelsummaries", [updated, ...records.filter((item) => item.runid !== runid)]);
+  }
+  /** Returns every per run level count summary, newest first. */
+  async getlevelsummaries() {
+    return await this.adapter.get("levelsummaries") ?? [];
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -1659,10 +1831,416 @@ function extractvalues(body, paths) {
   return fields.map((field) => ({ path: field.path, ...field.value !== void 0 ? { value: field.value } : {}, ...field.missing ? { missing: true } : {} }));
 }
 
+// netcontrol.ts
+var controlkinds = ["blockrequest", "mockresponse", "rewriteheaders", "setcookies", "readcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles"];
+function patternorigin(pattern) {
+  const trimmed = pattern.trim();
+  if (!trimmed.startsWith("https://")) return void 0;
+  const rest = trimmed.slice("https://".length);
+  const host = rest.split("/")[0] ?? "";
+  if (!host.trim()) return void 0;
+  return `https://${host.toLowerCase()}`;
+}
+function matchurlpattern(pattern, url) {
+  const origin = patternorigin(pattern);
+  if (!origin) return false;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (parsed.origin !== origin) return false;
+  const patternpath = pattern.trim().slice(origin.length);
+  if (patternpath === "" || patternpath === "/") return true;
+  const segments = patternpath.split("/").filter((segment) => segment !== "");
+  if (segments.includes("**")) return true;
+  const pathsegments = parsed.pathname.split("/").filter((segment) => segment !== "");
+  if (segments.length !== pathsegments.length) return false;
+  return segments.every((segment, index) => segment === pathsegments[index] || segment.includes("*") && new RegExp(`^${segment.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`).test(pathsegments[index] ?? ""));
+}
+function blockruleof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (typeof options.urlpattern !== "string" || !options.urlpattern.trim()) return void 0;
+  const rule = { urlpattern: options.urlpattern.trim() };
+  if (Array.isArray(options.resourcetypes)) {
+    const types = options.resourcetypes.filter((item) => typeof item === "string" && item.trim().length > 0);
+    if (types.length === 0) return void 0;
+    rule.resourcetypes = types;
+  }
+  return rule;
+}
+function newblockrule(input) {
+  return { id: input.id, runid: input.runid, stepid: input.stepid, urlpattern: input.urlpattern, ...input.resourcetypes !== void 0 ? { resourcetypes: input.resourcetypes } : {}, hits: 0, registeredat: input.at };
+}
+function mockspecof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (typeof options.urlpattern !== "string" || !options.urlpattern.trim()) return void 0;
+  if (typeof options.status !== "number" || !Number.isInteger(options.status) || options.status < 100 || options.status > 599) return void 0;
+  const hasbody = typeof options.body === "string";
+  const bodyref = typeof options.bodyref === "string" ? options.bodyref.trim() : "";
+  if (!hasbody && bodyref === "") return void 0;
+  const spec = { urlpattern: options.urlpattern.trim(), status: options.status };
+  if (hasbody) spec.body = options.body;
+  if (bodyref !== "") spec.bodyref = bodyref;
+  if (options.headers && typeof options.headers === "object" && !Array.isArray(options.headers)) spec.headers = options.headers;
+  if (options.reviewed === true) spec.reviewed = true;
+  return spec;
+}
+function newmockspec(input) {
+  return { id: input.id, runid: input.runid, stepid: input.stepid, urlpattern: input.urlpattern, status: input.status, ...input.headers !== void 0 ? { headers: input.headers } : {}, ...input.body !== void 0 ? { body: input.body } : {}, ...input.bodyref !== void 0 ? { bodyref: input.bodyref } : {}, reviewed: input.reviewed, hits: 0, registeredat: input.at };
+}
+function mockfor(url, specs) {
+  return specs.find((spec) => spec.revertedat === void 0 && matchurlpattern(spec.urlpattern, url));
+}
+function headeruleof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (typeof options.urlpattern !== "string" || !options.urlpattern.trim()) return void 0;
+  if (typeof options.name !== "string" || !options.name.trim()) return void 0;
+  if (options.operation !== "set" && options.operation !== "append" && options.operation !== "remove") return void 0;
+  if (options.operation === "remove" && options.value !== void 0) return void 0;
+  if (options.operation !== "remove" && typeof options.value !== "string") return void 0;
+  const rule = { urlpattern: options.urlpattern.trim(), name: options.name.trim(), operation: options.operation };
+  if (options.operation !== "remove") rule.value = typeof options.value === "string" ? options.value : "";
+  return rule;
+}
+function newheaderule(input) {
+  return { id: input.id, runid: input.runid, stepid: input.stepid, urlpattern: input.urlpattern, name: input.name, operation: input.operation, ...input.value !== void 0 ? { value: input.value } : {}, hits: 0, registeredat: input.at };
+}
+function applyheaderules(url, headers, rules) {
+  const rewritten = { ...headers };
+  const applied = [];
+  for (const rule of rules) {
+    if (rule.revertedat !== void 0) continue;
+    if (!matchurlpattern(rule.urlpattern, url)) continue;
+    const name = rule.name;
+    if (rule.operation === "remove") {
+      delete rewritten[name];
+      applied.push(rule);
+      continue;
+    }
+    const value = rule.value ?? "";
+    if (rule.operation === "set") rewritten[name] = value;
+    else rewritten[name] = rewritten[name] !== void 0 ? `${rewritten[name]}, ${value}` : value;
+    applied.push(rule);
+  }
+  return { headers: rewritten, applied };
+}
+function revertrule(rule, at) {
+  if (rule.revertedat !== void 0) return rule;
+  return { ...rule, revertedat: at };
+}
+function cookierecordof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (typeof options.name !== "string" || !options.name.trim()) return void 0;
+  if (typeof options.domain !== "string" || !options.domain.trim()) return void 0;
+  if (typeof options.path !== "string" || !options.path.trim()) return void 0;
+  if (typeof options.value !== "string") return void 0;
+  const record2 = { name: options.name.trim(), domain: options.domain.trim().toLowerCase(), path: options.path.trim(), value: options.value };
+  if (typeof options.expiresat === "number" && Number.isFinite(options.expiresat)) record2.expiresat = options.expiresat;
+  return record2;
+}
+function cookiedomaingranted(domain, grants) {
+  const host = domain.trim().toLowerCase().replace(/^\./, "");
+  return grants.some((grant) => {
+    let granthost = "";
+    try {
+      granthost = new URL(grant).hostname.toLowerCase();
+    } catch {
+      return false;
+    }
+    return host === granthost || host.endsWith(`.${granthost}`);
+  });
+}
+function redactedcookies(records) {
+  return records.map((record2) => ({ name: record2.name, domain: record2.domain, path: record2.path, ...record2.expiresat !== void 0 ? { expiresat: record2.expiresat } : {} }));
+}
+function proxyrouteof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (options.scheme !== "http" && options.scheme !== "https" && options.scheme !== "socks4" && options.scheme !== "socks5") return void 0;
+  if (typeof options.host !== "string" || !options.host.trim()) return void 0;
+  if (typeof options.port !== "number" || !Number.isInteger(options.port) || options.port < 1 || options.port > 65535) return void 0;
+  if (!Array.isArray(options.bypass) || options.bypass.length === 0 || !options.bypass.every((item) => typeof item === "string" && item.trim().length > 0)) return void 0;
+  return { scheme: options.scheme, host: options.host.trim(), port: options.port, bypass: options.bypass.map((item) => item.trim()) };
+}
+function ratelimitreadof(headers, origin, now) {
+  const pick = (name) => {
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() !== name) continue;
+      const value = Number(headers[key]);
+      return Number.isFinite(value) && value >= 0 ? value : void 0;
+    }
+    return void 0;
+  };
+  const remaining = pick("x-ratelimit-remaining");
+  const limit = pick("x-ratelimit-limit");
+  const reset = pick("x-ratelimit-reset");
+  if (remaining === void 0 && limit === void 0 && reset === void 0) return void 0;
+  const read = { origin, ...remaining !== void 0 ? { remaining } : {}, ...limit !== void 0 ? { limit } : {}, resetat: now, at: now };
+  if (reset !== void 0) read.resetat = reset > Math.floor(now / 1e3) ? reset * 1e3 : now + reset * 1e3;
+  return read;
+}
+function retryafterof(status, headers) {
+  if (status !== 429 && status !== 503) return void 0;
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() !== "retry-after") continue;
+    const raw = headers[key];
+    if (raw === void 0) continue;
+    const value = raw.trim();
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+    const date = Date.parse(value);
+    if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+    return void 0;
+  }
+  return void 0;
+}
+function ratelimitwait(state, now) {
+  if (!state) return 0;
+  return Math.max(0, state.resetat - now);
+}
+
+// netauth.ts
+function oauthflowof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (typeof options.provider !== "string" || !options.provider.trim()) return void 0;
+  if (typeof options.authorizeurl !== "string" || !options.authorizeurl.trim()) return void 0;
+  if (typeof options.tokenurl !== "string" || !options.tokenurl.trim()) return void 0;
+  if (!Array.isArray(options.scopes) || options.scopes.length === 0 || !options.scopes.every((item) => typeof item === "string" && item.trim().length > 0)) return void 0;
+  if (typeof options.redirectorigin !== "string" || !options.redirectorigin.trim()) return void 0;
+  return { provider: options.provider.trim(), authorizeurl: options.authorizeurl.trim(), tokenurl: options.tokenurl.trim(), scopes: options.scopes.map((item) => item.trim()), redirectorigin: options.redirectorigin.trim() };
+}
+function authorizeurl(flow, state) {
+  const url = new URL(flow.authorizeurl);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("redirect_uri", flow.redirectorigin);
+  url.searchParams.set("scope", flow.scopes.join(" "));
+  url.searchParams.set("state", state);
+  return url.toString();
+}
+function capturecode(url, redirectorigin, state) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return { error: "The redirect url does not parse for the code capture." };
+  }
+  const granted = redirectorigin.includes("/", redirectorigin.indexOf("://") + 3) ? `${parsed.origin}${parsed.pathname}`.startsWith(redirectorigin) : parsed.origin === redirectorigin;
+  if (!granted) return { error: `The redirect landed on ${parsed.origin} outside the granted redirect origin ${redirectorigin}.` };
+  const returned = parsed.searchParams.get("state");
+  if (returned !== state) return { error: "The redirect state token does not match the reviewed flow." };
+  const error = parsed.searchParams.get("error");
+  if (error) return { error: `The provider refused the flow: ${error}.` };
+  const code = parsed.searchParams.get("code");
+  if (!code) return { error: "The redirect carries no authorization code." };
+  return { code };
+}
+function parsetokens(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+  const record2 = parsed;
+  const tokens = {};
+  if (typeof record2.access_token === "string" && record2.access_token) tokens.accesstoken = record2.access_token;
+  if (typeof record2.refresh_token === "string" && record2.refresh_token) tokens.refreshtoken = record2.refresh_token;
+  if (typeof record2.expires_in === "number" && Number.isFinite(record2.expires_in) && record2.expires_in >= 0) tokens.expiresin = record2.expires_in;
+  if (typeof record2.scope === "string" && record2.scope.trim()) tokens.scopes = record2.scope.trim().split(/\s+/);
+  if (tokens.accesstoken === void 0 && tokens.refreshtoken === void 0) return void 0;
+  return tokens;
+}
+function tokenrequest(flow, input) {
+  if (input.refreshtoken !== void 0) return { url: flow.tokenurl, body: urlencodeform([{ name: "grant_type", value: "refresh_token" }, { name: "refresh_token", value: input.refreshtoken }]) };
+  return { url: flow.tokenurl, body: urlencodeform([{ name: "grant_type", value: "authorization_code" }, { name: "code", value: input.code ?? "" }, { name: "redirect_uri", value: flow.redirectorigin }]) };
+}
+function revocationruleof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (!Array.isArray(options.tokenids) || options.tokenids.length === 0 || !options.tokenids.every((item) => typeof item === "string" && item.trim().length > 0)) return void 0;
+  if (typeof options.reason !== "string" || !options.reason.trim()) return void 0;
+  return { tokenids: options.tokenids.map((item) => item.trim()), reason: options.reason.trim(), revokedat: Date.now() };
+}
+function formpayloadof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (typeof options.url !== "string" || !options.url.trim()) return void 0;
+  if (!Array.isArray(options.fields) || options.fields.length === 0) return void 0;
+  const fields = [];
+  for (const item of options.fields) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return void 0;
+    const field = item;
+    if (typeof field.name !== "string" || !field.name.trim()) return void 0;
+    if (typeof field.value !== "string") return void 0;
+    fields.push({ name: field.name.trim(), value: field.value });
+  }
+  return { url: options.url.trim(), fields };
+}
+function urlencodeform(fields) {
+  return fields.map((field) => `${formencode(field.name)}=${formencode(field.value)}`).join("&");
+}
+function formencode(value) {
+  const bytes = [...new TextEncoder().encode(value)];
+  return bytes.map((byte) => byte >= 65 && byte <= 90 || byte >= 97 && byte <= 122 || byte >= 48 && byte <= 57 || byte === 45 || byte === 95 || byte === 46 || byte === 126 ? String.fromCharCode(byte) : `%${byte.toString(16).toUpperCase().padStart(2, "0")}`).join("");
+}
+function multipartpayloadof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (typeof options.url !== "string" || !options.url.trim()) return void 0;
+  if (!Array.isArray(options.files) || options.files.length === 0) return void 0;
+  const fields = [];
+  for (const item of Array.isArray(options.fields) ? options.fields : []) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return void 0;
+    const field = item;
+    if (typeof field.name !== "string" || !field.name.trim()) return void 0;
+    if (typeof field.value !== "string") return void 0;
+    fields.push({ name: field.name.trim(), value: field.value });
+  }
+  const files = [];
+  for (const item of options.files) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return void 0;
+    const file = item;
+    if (typeof file.name !== "string" || !file.name.trim()) return void 0;
+    if (typeof file.filename !== "string" || !file.filename.trim()) return void 0;
+    if (typeof file.mime !== "string" || !file.mime.trim()) return void 0;
+    if (typeof file.content !== "string") return void 0;
+    if (file.reviewed !== true) return void 0;
+    files.push({ name: file.name.trim(), filename: file.filename.trim(), mime: file.mime.trim(), content: file.content, reviewed: true });
+  }
+  const payload = { url: options.url.trim(), fields, files, ...typeof options.boundary === "string" && options.boundary.trim() ? { boundary: options.boundary.trim() } : {} };
+  return payload;
+}
+function newboundary() {
+  return `----devthink${Math.random().toString(16).slice(2)}${Date.now().toString(16)}`;
+}
+function multipartchunks(payload) {
+  const boundary = payload.boundary ?? newboundary();
+  const chunks = [];
+  for (const field of payload.fields) chunks.push(`--${boundary}\r
+content-disposition: form-data; name="${field.name}"\r
+\r
+${field.value}\r
+`);
+  for (const file of payload.files) chunks.push(`--${boundary}\r
+content-disposition: form-data; name="${file.name}"; filename="${file.filename}"\r
+content-type: ${file.mime}\r
+\r
+${file.content}\r
+`);
+  chunks.push(`--${boundary}--\r
+`);
+  return { chunks, boundary, bytes: chunks.reduce((total, chunk) => total + chunk.length, 0) };
+}
+
+// runtimeline.ts
+var timelinekinds = ["watchconsole", "watcherrors", "watchtasks"];
+var loglevels = ["error", "warn", "info", "log", "debug", "trace"];
+var timelinesources = ["console", "error", "rejection", "resource", "longtask", "network"];
+function attachtimeline(input) {
+  return { runid: input.runid, origin: input.origin, stepids: [...input.stepids], attachedat: input.now, entries: [] };
+}
+function spamdetect(entries, rule) {
+  const collapsed = [];
+  const counts = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (rule.pattern !== "" && !entry.message.includes(rule.pattern)) {
+      collapsed.push({ ...entry, repeat: 1 });
+      continue;
+    }
+    const key = `${entry.level}|${entry.source}|${entry.message}`;
+    const previous = collapsed[collapsed.length - 1];
+    if (previous && previous.repeat !== void 0 && `${previous.level}|${previous.source}|${previous.message}` === key && entry.time - previous.time <= rule.windowsize) {
+      previous.repeat += 1;
+      continue;
+    }
+    collapsed.push({ ...entry, repeat: 1 });
+  }
+  for (const entry of collapsed) {
+    if (entry.repeat > 1) counts.set(`${entry.level}|${entry.source}|${entry.message}`, entry.repeat);
+  }
+  const flagged = [...counts.entries()].filter(([, count]) => count > rule.collapse).map(([key, count]) => ({ message: key.split("|").slice(2).join("|"), count }));
+  return { entries: collapsed, flagged };
+}
+function rotatelogs(entries, rule) {
+  if (entries.length <= rule.maxentries) return { kept: [...entries], overflow: [] };
+  const kept = entries.slice(entries.length - rule.maxentries);
+  const overflow = entries.slice(0, entries.length - rule.maxentries);
+  return { kept, overflow };
+}
+function timelinecounts(entries) {
+  const counts = {};
+  for (const level of loglevels) counts[level] = 0;
+  for (const entry of entries) counts[entry.level] = (counts[entry.level] ?? 0) + 1;
+  return counts;
+}
+function blockingduration(tasks, stepid, window2) {
+  const inside = tasks.filter((task) => task.starttime >= window2.startedat && task.starttime <= window2.endedat);
+  return { stepid, blocking: inside.reduce((total, task) => total + task.duration, 0), tasks: inside.length };
+}
+function netfailureentryof(input) {
+  const exchange = input.exchange;
+  if (exchange.errorclass === void 0 && exchange.status < 400) return null;
+  return { id: input.id, runid: exchange.runid, stepid: exchange.stepid, url: exchange.url, status: exchange.status, errorclass: exchange.errorclass ?? "httperror", correlationid: exchange.correlationid, at: input.at };
+}
+function watcherdetached(input) {
+  for (const navigation of input.navigations) {
+    if (navigation >= input.startedat && navigation <= input.startedat + input.lifetime) return { detached: true, at: navigation };
+  }
+  return { detached: false };
+}
+function consolediff(input) {
+  const base = input.baselines;
+  const target = input.targetlines;
+  const basemap = /* @__PURE__ */ new Map();
+  for (const line of base) basemap.set(line, (basemap.get(line) ?? 0) + 1);
+  const targetmap = /* @__PURE__ */ new Map();
+  for (const line of target) targetmap.set(line, (targetmap.get(line) ?? 0) + 1);
+  const lines = [];
+  const added = [];
+  const removed = [];
+  const repeated = [];
+  for (const [line, count] of targetmap) {
+    const basecount = basemap.get(line) ?? 0;
+    if (basecount === 0) {
+      for (let index = 0; index < count; index += 1) {
+        lines.push({ kind: "added", text: line });
+        added.push(line);
+      }
+      continue;
+    }
+    const share = Math.min(basecount, count);
+    for (let index = 0; index < share; index += 1) {
+      lines.push({ kind: "repeated", text: line, count: share });
+      repeated.push(line);
+    }
+    for (let index = share; index < count; index += 1) {
+      lines.push({ kind: "added", text: line });
+      added.push(line);
+    }
+  }
+  for (const [line, count] of basemap) {
+    const targetcount = targetmap.get(line) ?? 0;
+    const missing = Math.max(0, count - targetcount);
+    for (let index = 0; index < missing; index += 1) {
+      lines.push({ kind: "removed", text: line });
+      removed.push(line);
+    }
+  }
+  return { base: input.baseid, target: input.targetid, lines, added: added.length, removed: removed.length, repeated: repeated.length, at: input.now };
+}
+
 // policy.ts
-var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts", "recordscreen", "captureaudio", "downloadimages", "callrest", "callgraphql", "sendmessage"]);
+var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts", "recordscreen", "captureaudio", "downloadimages", "callrest", "callgraphql", "sendmessage", "blockrequest", "mockresponse", "rewriteheaders", "setcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles"]);
 var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction", "capturebodies"]);
-var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures", "shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet", "capturepdf", "captureframe", "readmedia", "readassets", "probestream", "timelapse", "shotcanvas", "convertimage", "makethumbs", "fetchurl", "parsejson", "parsehtml", "opensocket", "waitmessage", "watchrequests", "readheaders", "mapapi", "subscribesse", "longpoll", "extractapi"]);
+var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures", "shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet", "capturepdf", "captureframe", "readmedia", "readassets", "probestream", "timelapse", "shotcanvas", "convertimage", "makethumbs", "fetchurl", "parsejson", "parsehtml", "opensocket", "waitmessage", "watchrequests", "readheaders", "mapapi", "subscribesse", "longpoll", "extractapi", "readcookies", "watchconsole", "watcherrors", "watchtasks"]);
 var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
 var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus", "watchtab"]);
 var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection", "submitform", "retryform", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "scrapetable", "paginateextract", "shotelement", "captureframe", "shotcanvas"]);
@@ -1677,6 +2255,8 @@ var mediaactions = /* @__PURE__ */ new Set(["capturepdf", "recordscreen", "captu
 var httpactions = /* @__PURE__ */ new Set(["fetchurl", "parsejson", "parsehtml", "callrest", "callgraphql"]);
 var socketactions = /* @__PURE__ */ new Set(["opensocket", "sendmessage", "waitmessage", "subscribesse", "longpoll"]);
 var netwatchactions = /* @__PURE__ */ new Set(["watchrequests", "readheaders", "capturebodies", "mapapi", "extractapi"]);
+var controlactions = /* @__PURE__ */ new Set(["blockrequest", "mockresponse", "rewriteheaders", "setcookies", "readcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles"]);
+var debugactions = /* @__PURE__ */ new Set(["watchconsole", "watcherrors", "watchtasks"]);
 var credentialheaders = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "cookie", "cookie2", "set-cookie", "api-key", "x-api-key", "x-auth-token", "x-session-token", "proxy-authorization"]);
 var fieldkinds = ["text", "email", "phone", "date", "number", "select", "check", "radio", "file", "password", "card", "code"];
 var layoutmutationactions = /* @__PURE__ */ new Set(["grouptabs", "colorgroup", "collapsegroup", "savelayout", "restorelayout"]);
@@ -1692,6 +2272,9 @@ function hostpattern(origin) {
   if (parsed.protocol !== "https:") throw new Error("Only HTTPS origins can be granted.");
   return `${parsed.origin}/*`;
 }
+function isdebugkind(kind) {
+  return debugactions.has(kind);
+}
 function actionrisk(kind) {
   if (!allowedactions.has(kind)) throw new Error("Unsupported browser action.");
   if (sensitiveactions.has(kind)) return "sensitive";
@@ -1717,6 +2300,7 @@ function requiredcapability(kind) {
   if (kind === "readclipboard") return "clipboardRead";
   if (kind === "writeclipboard" || kind === "copyscreen") return "clipboardWrite";
   if (kind === "downloadimages") return "downloads";
+  if (kind === "authflow") return "tabs";
   if (kind === "openlink" || kind === "openprivate" || kind === "navlist" || kind === "batchopen" || kind === "reopentab" || kind === "deeplink") return "tabs";
   if (tabscommandactions.has(kind)) return "tabs";
   return void 0;
@@ -2416,6 +3000,9 @@ function issocketkind(kind) {
 function isnetwatchkind(kind) {
   return netwatchactions.has(kind);
 }
+function iscontrolkind(kind) {
+  return controlactions.has(kind);
+}
 function resolvedrisk(step) {
   if (step.kind === "capturebodies") {
     let options = {};
@@ -2776,6 +3363,238 @@ function validatenetwatchgrammar(step, options) {
   }
   return { allowed: true };
 }
+function validatecontrolgrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "blockrequest") {
+    const rule = blockruleof(options.block);
+    if (!rule) return { allowed: false, reason: "A reviewed block rule with a url pattern is required in options.block." };
+    if (patternorigin(rule.urlpattern) === void 0) return { allowed: false, reason: "Block rules need an https origin pattern; patterns without a named origin are refused." };
+    if (options.block.reviewed !== true) return { allowed: false, reason: "The block rule carries the explicit reviewed flag before any request is blocked." };
+  }
+  if (kind === "mockresponse") {
+    const spec = mockspecof(options.mock);
+    if (!spec) return { allowed: false, reason: "A reviewed mock fixture with a url pattern, status and its reviewed body or a captured body ref is required in options.mock." };
+    if (patternorigin(spec.urlpattern) === void 0) return { allowed: false, reason: "Mock fixtures need an https origin pattern; patterns without a named origin are refused." };
+    if (spec.reviewed !== true) return { allowed: false, reason: "Every mock fixture is reviewed with its full body or the referenced captured body through the explicit reviewed flag before it serves." };
+  }
+  if (kind === "rewriteheaders") {
+    const rules = options.rules;
+    if (!Array.isArray(rules) || rules.length === 0) return { allowed: false, reason: "A reviewed non-empty list of header rewrite rules is required in options.rules." };
+    for (const item of rules) {
+      const rule = headeruleof(item);
+      if (!rule) return { allowed: false, reason: "Every header rewrite rule needs a url pattern, header name, a set, append or remove operation and its value." };
+      if (patternorigin(rule.urlpattern) === void 0) return { allowed: false, reason: "Header rewrite rules must name their origin pattern explicitly; patterns without a named origin are refused." };
+    }
+  }
+  if (kind === "setcookies") {
+    const cookies = options.cookies;
+    if (!Array.isArray(cookies) || cookies.length === 0) return { allowed: false, reason: "A reviewed non-empty list of cookie records is required in options.cookies." };
+    for (const item of cookies) {
+      if (!cookierecordof(item)) return { allowed: false, reason: "Every cookie record needs a name, domain, path and reviewed string value with an optional expiry." };
+    }
+  }
+  if (kind === "readcookies" && options.domain !== void 0 && !isnonempty(options.domain)) return { allowed: false, reason: "The reviewed cookie read domain must be a non-empty host." };
+  if (kind === "clearcookies") {
+    if (!isnonempty(options.domain)) return { allowed: false, reason: "A reviewed cookie domain is required before cookies are cleared." };
+    if (options.names !== void 0 && (!Array.isArray(options.names) || options.names.length === 0 || !options.names.every((name) => isnonempty(name)))) return { allowed: false, reason: "The reviewed cookie clear list must be a non-empty list of cookie names when present." };
+  }
+  if (kind === "authflow") {
+    const flow = oauthflowof(options.oauth);
+    if (!flow) return { allowed: false, reason: "A reviewed oauth flow with provider, authorize url, token url, scopes and redirect origin is required in options.oauth." };
+    if (!ishttpsurl(flow.authorizeurl) || !ishttpsurl(flow.tokenurl)) return { allowed: false, reason: "The oauth authorize and token urls must use HTTPS." };
+    if (!ishttpsurl(flow.redirectorigin) && !/^https:\/\/[^/]+\/?$/.test(flow.redirectorigin)) return { allowed: false, reason: "The oauth redirect origin must be an HTTPS origin inside the grants." };
+    const consent = authconsentgranted(step);
+    if (!consent.allowed) return consent;
+  }
+  if (kind === "saveapikey") {
+    const key = options.key;
+    if (!key || typeof key !== "object" || Array.isArray(key)) return { allowed: false, reason: "A reviewed api key entry with name, origin scopes and header is required in options.key." };
+    const entry = key;
+    if (!isnonempty(entry.name)) return { allowed: false, reason: "The api key entry needs a reviewed non-empty name." };
+    if (!Array.isArray(entry.origins) || entry.origins.length === 0 || !entry.origins.every((item) => ishttpsurl(item))) return { allowed: false, reason: "The api key needs a reviewed non-empty list of HTTPS origin scopes." };
+    if (!isnonempty(entry.header)) return { allowed: false, reason: "The api key entry needs a reviewed non-empty header name." };
+    if (typeof entry.value !== "string" || !entry.value) return { allowed: false, reason: "The api key needs its secret value in the reviewed options; it never enters the audit trail." };
+    const consent = apikeyconsentgranted(step);
+    if (!consent.allowed) return consent;
+  }
+  if (kind === "routeproxy") {
+    if (!proxyrouteof(options.proxy)) return { allowed: false, reason: "A reviewed proxy route with scheme, host, port and a non-empty bypass list is required in options.proxy." };
+    if (!isnonempty(options.consentref)) return { allowed: false, reason: "Proxy routing needs the explicit reviewed consent ref before any route applies." };
+  }
+  if (kind === "postform") {
+    const form = formpayloadof(options.form);
+    if (!form) return { allowed: false, reason: "A reviewed form payload with a url and a non-empty field list is required in options.form." };
+    if (!ishttpsurl(form.url)) return { allowed: false, reason: "The form submission target must use HTTPS." };
+    if (options.wait !== void 0 && (typeof options.wait !== "number" || !Number.isFinite(options.wait) || options.wait < 0)) return { allowed: false, reason: "The reviewed rate limit wait budget must be zero or a positive number of milliseconds." };
+  }
+  if (kind === "postfiles") {
+    const upload = multipartpayloadof(options.upload);
+    if (!upload) return { allowed: false, reason: "A reviewed multipart upload with a url and reviewed files is required in options.upload; every file carries the explicit reviewed flag." };
+    if (!ishttpsurl(upload.url)) return { allowed: false, reason: "The multipart upload target must use HTTPS." };
+    if (options.wait !== void 0 && (typeof options.wait !== "number" || !Number.isFinite(options.wait) || options.wait < 0)) return { allowed: false, reason: "The reviewed rate limit wait budget must be zero or a positive number of milliseconds." };
+  }
+  return { allowed: true };
+}
+function blockgate(session, step, now) {
+  if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the request block." };
+  if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot block requests." };
+  if (session.pausedat) return { allowed: false, reason: "The browser session is paused and cannot block requests." };
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const rule = options.block;
+  if (!rule || typeof rule !== "object" || Array.isArray(rule) || rule.reviewed !== true) return { allowed: false, reason: "Request blocking needs its reviewed block rule with the explicit reviewed flag before any rule applies." };
+  if (!blockruleof(rule)) return { allowed: false, reason: "The block rule needs a url pattern and an optional resource type list." };
+  return { allowed: true };
+}
+function cookiegate(session, domain, now) {
+  if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the cookie operation." };
+  if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot touch cookies." };
+  if (session.pausedat) return { allowed: false, reason: "The browser session is paused and cannot touch cookies." };
+  const grants = session.grants ?? [session.origin];
+  if (!cookiedomaingranted(domain, grants)) return { allowed: false, reason: `The cookie domain ${domain} stays outside the session origin grants; cookie control refuses domains beyond the grants.` };
+  return { allowed: true };
+}
+function proxygate(session, step, now) {
+  if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the proxy route." };
+  if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot change routing." };
+  if (session.pausedat) return { allowed: false, reason: "The browser session is paused and cannot change routing." };
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  if (!isnonempty(options.consentref)) return { allowed: false, reason: "Proxy routing needs the explicit reviewed consent ref before any route applies." };
+  if (!proxyrouteof(options.proxy)) return { allowed: false, reason: "The proxy route needs a scheme, host, port and a non-empty bypass list of origins that stay direct." };
+  return { allowed: true };
+}
+function authconsentgranted(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const consentref = options.consentref;
+  if (typeof consentref !== "string" || !consentref.trim()) return { allowed: false, reason: "An oauth flow requires the reviewed provider consent prompt ref in options before it starts." };
+  return { allowed: true };
+}
+function apikeyconsentgranted(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const consentref = options.consentref;
+  if (typeof consentref !== "string" || !consentref.trim()) return { allowed: false, reason: "Storing an api key requires the explicit reviewed consent prompt ref in options before anything is stored." };
+  return { allowed: true };
+}
+function ratelimitbudgetallowed(wait, budget) {
+  if (wait !== void 0 && (typeof wait !== "number" || !Number.isFinite(wait) || wait < 0)) return { allowed: false, reason: "The rate limit wait must be zero or a positive number of milliseconds." };
+  if (budget !== void 0 && (typeof budget !== "number" || !Number.isFinite(budget) || budget < 0)) return { allowed: false, reason: "The reviewed rate limit budget must be zero or a positive number of milliseconds." };
+  if (wait !== void 0 && budget !== void 0 && wait > budget) return { allowed: false, reason: `The rate limit wait of ${wait} milliseconds exceeds the reviewed budget of ${budget} milliseconds; review a wider budget or submit later.` };
+  return { allowed: true };
+}
+function timelinegate(session, tabid2, origin, now) {
+  if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the timeline capture." };
+  if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot capture the timeline." };
+  if (session.pausedat) return { allowed: false, reason: "The browser session is paused and cannot capture the timeline." };
+  if (session.tabid !== tabid2) return { allowed: false, reason: `The timeline capture needs the run tab ${session.tabid} and refuses tab ${tabid2}.` };
+  if (!origingranted(session, origin)) return { allowed: false, reason: `The timeline capture of ${origin} needs the session origin grants first.` };
+  return { allowed: true };
+}
+function consoleconsentcovers(origin, consents) {
+  if (consents.some((consent) => consent.origin === origin && consent.approved === true)) return { allowed: true };
+  return { allowed: false, reason: `Console capture on ${origin} needs the reviewed console consent first; approve the prompt in the review panel.` };
+}
+function stackgate(session, origin) {
+  if (!origingranted(session, origin)) return { allowed: false, reason: `Stack capture of ${origin} stays outside the session origin grants.` };
+  return { allowed: true };
+}
+function debugwaitbudgetallowed(watchwindow, wait) {
+  if (watchwindow !== void 0 && (typeof watchwindow !== "number" || !Number.isFinite(watchwindow) || watchwindow < 0)) return { allowed: false, reason: "The debug watch window must be zero or a positive number of milliseconds." };
+  if (wait !== void 0 && (typeof wait !== "number" || !Number.isFinite(wait) || wait < 0)) return { allowed: false, reason: "The reviewed debug wait budget must be zero or a positive number of milliseconds." };
+  if (watchwindow !== void 0 && wait !== void 0 && watchwindow > wait) return { allowed: false, reason: `The debug watch window of ${watchwindow} milliseconds exceeds the reviewed wait budget of ${wait} milliseconds; review a wider budget or a shorter window.` };
+  return { allowed: true };
+}
+function validatetimelinegrammar(step, options) {
+  const kind = step.kind;
+  let watchwindow;
+  if (options.watch !== void 0) {
+    const watch = options.watch;
+    if (!watch || typeof watch !== "object" || Array.isArray(watch)) return { allowed: false, reason: "The reviewed debug watch window must be an object." };
+    const reviewed = watch;
+    if (reviewed.window !== void 0) {
+      if (typeof reviewed.window !== "number" || !Number.isFinite(reviewed.window) || reviewed.window < 0) return { allowed: false, reason: "The reviewed debug watch window must be zero or a positive number of milliseconds." };
+      watchwindow = reviewed.window;
+    }
+  }
+  const budgetcheck = debugwaitbudgetallowed(watchwindow, typeof options.wait === "number" ? options.wait : void 0);
+  if (!budgetcheck.allowed) return budgetcheck;
+  if (options.level !== void 0 && !loglevels.includes(options.level)) return { allowed: false, reason: `The reviewed level floor must be one of ${loglevels.join(", ")}.` };
+  if (options.sources !== void 0) {
+    if (!Array.isArray(options.sources) || options.sources.length === 0 || !options.sources.every((source) => timelinesources.includes(source))) return { allowed: false, reason: `The reviewed source filters must be a non-empty list of the reviewed timeline sources: ${timelinesources.join(", ")}.` };
+  }
+  if (kind === "watchconsole") {
+    if (options.redact === void 0 || !Array.isArray(options.redact) || options.redact.length === 0 || !options.redact.every((pattern) => isnonempty(pattern))) return { allowed: false, reason: "Console capture requires a reviewed non-empty redaction pattern list before any console text is captured." };
+    if (options.depth !== void 0 && (typeof options.depth !== "number" || !Number.isInteger(options.depth) || options.depth < 1)) return { allowed: false, reason: "The reviewed serialization depth bound must be a positive integer with no code ceiling." };
+    if (options.spam !== void 0) {
+      const rule = spamruleof(options.spam);
+      if (!rule) return { allowed: false, reason: "The reviewed spam rule needs a pattern, a window size and a collapse threshold." };
+      if (rule.collapse < 1) return { allowed: false, reason: "The reviewed spam collapse threshold must be a positive integer of user configured value with no code ceiling." };
+    }
+    if (options.rotation !== void 0) {
+      const rule = rotationruleof(options.rotation);
+      if (!rule) return { allowed: false, reason: "The reviewed rotation rule needs a max entry count and an overflow target." };
+    }
+  }
+  if (kind === "watchtasks") {
+    if (options.threshold !== void 0 && (typeof options.threshold !== "number" || !Number.isFinite(options.threshold) || options.threshold < 0)) return { allowed: false, reason: "The reviewed long task threshold must be zero or a positive number of milliseconds with no code ceiling." };
+  }
+  return { allowed: true };
+}
+function spamruleof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const pattern = typeof entry.pattern === "string" ? entry.pattern : "";
+  const windowsize = typeof entry.windowsize === "number" && Number.isFinite(entry.windowsize) && entry.windowsize >= 0 ? entry.windowsize : void 0;
+  const collapse = typeof entry.collapse === "number" && Number.isInteger(entry.collapse) ? entry.collapse : void 0;
+  if (windowsize === void 0 || collapse === void 0) return void 0;
+  return { pattern, windowsize, collapse };
+}
+function rotationruleof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const maxentries = typeof entry.maxentries === "number" && Number.isInteger(entry.maxentries) && entry.maxentries >= 1 ? entry.maxentries : void 0;
+  const overflowtarget = typeof entry.overflowtarget === "string" && entry.overflowtarget.trim() ? entry.overflowtarget.trim() : void 0;
+  if (maxentries === void 0 || overflowtarget === void 0) return void 0;
+  return { maxentries, overflowtarget };
+}
+function controltarget(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  for (const key of ["form", "upload"]) {
+    const value = options[key];
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const url = value.url;
+      if (typeof url === "string" && url.trim()) return url.trim();
+    }
+  }
+  if (step.kind === "authflow") {
+    const flow = oauthflowof(options.oauth);
+    if (flow) return flow.tokenurl;
+  }
+  return void 0;
+}
 function sockettarget(step) {
   let options = {};
   try {
@@ -3161,6 +3980,14 @@ function validatestep(step, origin) {
     const netwatchcheck = validatenetwatchgrammar(step, options);
     if (!netwatchcheck.allowed) return netwatchcheck;
   }
+  if (iscontrolkind(step.kind)) {
+    const controlcheck = validatecontrolgrammar(step, options);
+    if (!controlcheck.allowed) return controlcheck;
+  }
+  if (isdebugkind(step.kind)) {
+    const timelinecheck = validatetimelinegrammar(step, options);
+    if (!timelinecheck.allowed) return timelinecheck;
+  }
   if (step.kind === "tabcreate") {
     if (options.background !== void 0 && typeof options.background !== "boolean") return { allowed: false, reason: "The reviewed background flag must be a boolean." };
     if (options.window !== void 0 && (typeof options.window !== "number" || !Number.isInteger(options.window) || options.window < 0)) return { allowed: false, reason: "The reviewed target window id must be a non-negative integer." };
@@ -3262,6 +4089,59 @@ function canexecute(input) {
     const watchgatecheck = watchgate(input.session, input.settings, now);
     if (!watchgatecheck.allowed) return watchgatecheck;
   }
+  if (isdebugkind(input.step.kind)) {
+    const timelinegatecheck = timelinegate(input.session, input.tabid, input.origin, now);
+    if (!timelinegatecheck.allowed) return timelinegatecheck;
+  }
+  if (iscontrolkind(input.step.kind)) {
+    const controlgate = sessiongate({ session: input.session, tabid: input.tabid, origin: input.origin, now, action: "control the network" });
+    if (!controlgate.allowed) return controlgate;
+    let controloptions = {};
+    try {
+      controloptions = parseoptions(input.step);
+    } catch {
+      controloptions = {};
+    }
+    if (input.step.kind === "blockrequest") {
+      const blockgatecheck = blockgate(input.session, input.step, now);
+      if (!blockgatecheck.allowed) return blockgatecheck;
+      const rule = blockruleof(controloptions.block);
+      if (rule) {
+        const blockorigin = origincheck(input.session, rule.urlpattern);
+        if (!blockorigin.allowed) return blockorigin;
+      }
+    }
+    if (input.step.kind === "mockresponse" || input.step.kind === "rewriteheaders") {
+      const patterns = input.step.kind === "mockresponse" ? [mockspecof(controloptions.mock)?.urlpattern ?? ""] : Array.isArray(controloptions.rules) ? controloptions.rules.map((item) => item && typeof item === "object" && !Array.isArray(item) ? String(item.urlpattern ?? "") : "") : [];
+      for (const pattern of patterns) {
+        const patterngate = origincheck(input.session, pattern);
+        if (!patterngate.allowed) return patterngate;
+      }
+    }
+    if (input.step.kind === "setcookies" || input.step.kind === "readcookies" || input.step.kind === "clearcookies") {
+      const domain = typeof controloptions.domain === "string" && controloptions.domain.trim() ? controloptions.domain : Array.isArray(controloptions.cookies) ? String(controloptions.cookies[0]?.domain ?? "") : "";
+      if (!domain) return { allowed: false, reason: "A reviewed cookie domain is required before cookie control runs." };
+      const cookiegatecheck = cookiegate(input.session, domain, now);
+      if (!cookiegatecheck.allowed) return cookiegatecheck;
+    }
+    if (input.step.kind === "authflow") {
+      const authconsent = authconsentgranted(input.step);
+      if (!authconsent.allowed) return authconsent;
+    }
+    if (input.step.kind === "saveapikey") {
+      const keyconsent = apikeyconsentgranted(input.step);
+      if (!keyconsent.allowed) return keyconsent;
+    }
+    if (input.step.kind === "routeproxy") {
+      const proxygatecheck = proxygate(input.session, input.step, now);
+      if (!proxygatecheck.allowed) return proxygatecheck;
+    }
+    const target = controltarget(input.step);
+    if (target !== void 0) {
+      const targetgate = origincheck(input.session, target);
+      if (!targetgate.allowed) return targetgate;
+    }
+  }
   if (input.step.kind === "extractapi") {
     let replayoptions = {};
     try {
@@ -3431,9 +4311,24 @@ function recordpoll(progress, planid, stepid, entry, now) {
   const outcome = { stepid, ok: true, summary: `Long poll ${entry.poll} returned the ${entry.status} status${entry.cursor !== void 0 ? ` at cursor ${entry.cursor}` : ""} and ${entry.stopped ? `stopped: ${entry.reason}` : "continues"}.`, details: { poll: entry }, at: now };
   return recordoutcome(base, planid, outcome, now);
 }
+function recordcontrol(progress, planid, stepid, entry, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  const outcome = { stepid, ok: true, summary: `${entry.reason}: ${entry.applied} applied rule${entry.applied === 1 ? "" : "s"}, ${entry.blocked} blocked request${entry.blocked === 1 ? "" : "s"}, ${entry.mocked} mocked response${entry.mocked === 1 ? "" : "s"} and ${entry.reverts} reverted rule${entry.reverts === 1 ? "" : "s"}.`, details: { control: entry }, at: now };
+  return recordoutcome(base, planid, outcome, now);
+}
+function recordupload(progress, planid, stepid, entry, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  const outcome = { stepid, ok: true, summary: `The multipart upload moved chunk ${entry.chunk} of ${entry.chunks} with ${entry.uploaded} of ${entry.bytes} bytes sent.`, details: { upload: entry }, at: now };
+  return recordoutcome(base, planid, outcome, now);
+}
+function recordtimeline(progress, planid, stepid, entry, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  const outcome = { stepid, ok: true, summary: `Captured ${entry.entries} timeline entr${entry.entries === 1 ? "y" : "ies"} with ${entry.collapsed} collapsed repeat${entry.collapsed === 1 ? "" : "s"}, ${entry.errors} error${entry.errors === 1 ? "" : "s"}, ${entry.rejections} rejection${entry.rejections === 1 ? "" : "s"} and ${entry.longtasks} long task${entry.longtasks === 1 ? "" : "s"}.`, details: { timeline: entry }, at: now };
+  return recordoutcome(base, planid, outcome, now);
+}
 
 // version.ts
-var packageversion = "1.1.43";
+var packageversion = "1.1.45";
 
 // types.ts
 var protocolversion = packageversion;
@@ -3470,6 +4365,44 @@ function parseproposal(value, origin, grants) {
       ...typeof candidate.value === "string" ? { value: candidate.value } : {},
       ...typeof candidate.options === "string" ? { options: candidate.options } : {}
     };
+    if (step.kind === "blockrequest") {
+      let blockoptions = {};
+      try {
+        blockoptions = parseoptions(step);
+      } catch {
+        blockoptions = {};
+      }
+      const rule = blockruleof(blockoptions.block);
+      if (rule && patternorigin(rule.urlpattern) === void 0) throw new Error("Block rules without a named origin pattern are refused.");
+    }
+    if (step.kind === "routeproxy") {
+      let proxyoptions = {};
+      try {
+        proxyoptions = parseoptions(step);
+      } catch {
+        proxyoptions = {};
+      }
+      const proxy = proxyoptions.proxy;
+      const bypass = proxy && typeof proxy === "object" && !Array.isArray(proxy) ? proxy.bypass : void 0;
+      if (!Array.isArray(bypass) || bypass.length === 0) throw new Error("Proxy routes without a bypass list are refused.");
+    }
+    if (step.kind === "watchconsole" || step.kind === "watcherrors" || step.kind === "watchtasks") {
+      let debugoptions = {};
+      try {
+        debugoptions = parseoptions(step);
+      } catch {
+        debugoptions = {};
+      }
+      const granted = covered.some((pattern) => {
+        try {
+          return new URL(origin).origin === new URL(pattern).origin;
+        } catch {
+          return false;
+        }
+      });
+      if (!granted) throw new Error(`The ${step.kind} capture of ${origin} targets an origin outside the grants.`);
+      if (debugoptions.level !== void 0 && !loglevels.includes(debugoptions.level)) throw new Error(`The reviewed level floor must be one of ${loglevels.join(", ")}.`);
+    }
     const evaluation = validatestep(step, origin);
     if (!evaluation.allowed) throw new Error(evaluation.reason);
     const target = outboundtarget(step);
@@ -3544,7 +4477,7 @@ function requestbody(input) {
   return JSON.stringify({ version: protocolversion, objective: input.objective, session: input.session, observation: input.observation, capabilities: input.capabilities });
 }
 function outcomeresponse(input) {
-  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {}, ...input.capture ? { capture: input.capture } : {}, ...input.media ? { media: input.media } : {}, ...input.transport ? { transport: input.transport } : {}, ...input.network ? { network: input.network } : {} });
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {}, ...input.capture ? { capture: input.capture } : {}, ...input.media ? { media: input.media } : {}, ...input.transport ? { transport: input.transport } : {}, ...input.network ? { network: input.network } : {}, ...input.control ? { control: input.control } : {}, ...input.timeline ? { timeline: input.timeline } : {} });
 }
 function mapresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
@@ -3623,6 +4556,29 @@ function callsreport(input) {
 function exchangesreport(input) {
   return { version: protocolversion, exchanges: input.exchanges, channels: input.channels, subscriptions: input.subscriptions, apimap: input.apimap };
 }
+function authreport(input) {
+  const tokens = input.tokens.map((token) => {
+    const { accessstorageid, refreshstorageid, ...metadata } = token;
+    void accessstorageid;
+    void refreshstorageid;
+    return metadata;
+  });
+  return { version: protocolversion, tokens };
+}
+function controlreport(input) {
+  const mocks = input.mocks.map((spec) => {
+    const { body, ...metadata } = spec;
+    void body;
+    return metadata;
+  });
+  return { version: protocolversion, blocks: input.blocks, mocks, rewrites: input.rewrites, cookies: input.cookies, proxies: input.proxies, ratelimits: input.ratelimits };
+}
+function timelinereport(input) {
+  return { version: protocolversion, entries: input.entries, errors: input.errors, rejections: input.rejections, longtasks: input.longtasks, levelcounts: input.levelcounts };
+}
+function consolediffreport(input) {
+  return { version: protocolversion, diff: input.diff };
+}
 
 // capture.ts
 var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
@@ -5311,7 +6267,7 @@ function stepoptions2(step) {
 }
 async function refreshcapabilities() {
   const report = await readcapabilities();
-  const withmedia = { ...report, captures: [...capturekinds], media: [...mediakinds], http: [...httpkinds], netwatch: [...socketkinds, ...netwatchkinds] };
+  const withmedia = { ...report, captures: [...capturekinds], media: [...mediakinds], http: [...httpkinds], netwatch: [...socketkinds, ...netwatchkinds], control: [...controlkinds], debug: [...timelinekinds] };
   await memory.setcapabilities(withmedia);
   return withmedia;
 }
@@ -5734,6 +6690,17 @@ async function tracktabupdate(tabid2, changeinfo) {
   if (status === "loading" && url) {
     navbuffers.set(tabid2, [{ event: "beforenavigate", url, timestamp: now }]);
     lastknownurls.set(tabid2, url);
+    for (const [id, watcher] of [...activetimelinewatchers.entries()]) {
+      const detached = watcherdetached({ startedat: watcher.startedat, lifetime: watcher.lifetime, navigations: [now] });
+      if (!detached.detached) continue;
+      const session = await memory.getsession();
+      if (!session || session.tabid !== tabid2) continue;
+      watcher.cancelled = true;
+      await memory.closewatch(id, now).catch(() => {
+      });
+      await audit("timeline", `Watcher ${id} detached when the run tab navigated to ${url} at ${detached.at}; every page hook of the destroyed context is gone with it.`, { sessionid: session.id });
+      activetimelinewatchers.delete(id);
+    }
     return;
   }
   const buffer = navbuffers.get(tabid2) ?? [];
@@ -7876,7 +8843,7 @@ async function executehttpstep(step, session, plan, tabid2, origin) {
       streamstate.bytes = total;
     } } : void 0;
     try {
-      const transport = (url, init) => livefetch(url, init, controller, window2, streamstate);
+      const transport = (url, init) => controlledfetch(plan.id, url, init, controller, window2, streamstate);
       const result = await sendfetch({ request, ...policy !== void 0 && Object.keys(policy).length > 0 ? { options: policy } : {}, transport, onretry: (attempt, wait, reason) => {
         void (async () => {
           await memory.setprogress(recordfetchretry(await memory.getprogress(), plan.id, step.id, { attempt, url: request.url, wait, reason }, Date.now()));
@@ -7932,7 +8899,7 @@ async function executehttpstep(step, session, plan, tabid2, origin) {
     const controller = new AbortController();
     activefetches.set(callid, controller);
     try {
-      const transport = (url, init) => livefetch(url, init, controller);
+      const transport = (url, init) => controlledfetch(plan.id, url, init, controller);
       const keynames = Array.isArray(options.apikeys) ? options.apikeys.filter((name) => typeof name === "string" && name.trim().length > 0) : [];
       if (step.kind === "callrest") {
         const methodoverride = typeof options.method === "string" ? options.method.trim().toUpperCase() : void 0;
@@ -8262,6 +9229,11 @@ async function executenetwatchstep(step, session, plan, tabid2, origin) {
       observed.push(exchange);
     }
     const failed = observed.filter((exchange) => exchange.errorclass !== void 0).length;
+    for (const exchange of observed) {
+      const failure = netfailureentryof({ id: randomid(), exchange, at: Date.now() });
+      if (!failure) continue;
+      await memory.addtimelineentry({ id: failure.id, runid: failure.runid, stepid: failure.stepid, time: failure.at, level: "error", source: "network", message: `Request ${failure.correlationid} of ${failure.url} failed with the ${failure.errorclass} class${failure.status > 0 ? ` at status ${failure.status}` : ""}.` });
+    }
     await refreshbadge();
     await audit("watch", `Observed ${observed.length} request${observed.length === 1 ? "" : "s"} of the run tab over the reviewed ${window2} millisecond window, derived from the page timing buffers with ${failed} marked failed; headers and bodies stay out of this observation.`, extra);
     return { ok: true, summary: `Observed ${observed.length} request${observed.length === 1 ? "" : "s"} of the run tab${failed > 0 ? ` with ${failed} failed` : ""}.`, details: { network: { exchanges: observed.length, channelstate: "none", messages: 0 }, observed: observed.map((exchange) => ({ correlationid: exchange.correlationid, method: exchange.method, url: exchange.url, status: exchange.status, statusclass: exchange.statusclass, ...exchange.errorclass !== void 0 ? { errorclass: exchange.errorclass } : {}, bytes: exchange.bytes, duration: exchange.timing })), derivation: "The request lifecycle derives from the page performance and navigation buffers; the timing buffers expose no header names, body bytes or subresource status codes." } };
@@ -8379,6 +9351,462 @@ async function executenetwatchstep(step, session, plan, tabid2, origin) {
   void origin;
   throw new Error("Unsupported request observation kind.");
 }
+var activetimelinewatchers = /* @__PURE__ */ new Map();
+function timelinedetail(entry, runid) {
+  if (!entry || typeof entry !== "object") return null;
+  const record2 = entry;
+  if (typeof record2.stepid !== "string" || typeof record2.time !== "number" || typeof record2.message !== "string") return null;
+  if (typeof record2.level !== "string" || !loglevels.includes(record2.level)) return null;
+  if (typeof record2.source !== "string" || !timelinesources.includes(record2.source)) return null;
+  return { id: randomid(), runid, stepid: record2.stepid, time: record2.time, level: record2.level, source: record2.source, message: record2.message };
+}
+async function executetimelinestep(step, session, plan, tabid2, origin) {
+  const options = stepoptions2(step);
+  const watch = options.watch && typeof options.watch === "object" && !Array.isArray(options.watch) ? options.watch : {};
+  const watchwindow = typeof watch.window === "number" && Number.isFinite(watch.window) && watch.window >= 0 ? watch.window : 0;
+  const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
+  if (step.kind === "watchconsole") {
+    const consents = await memory.getconsoleconsents();
+    const consent = consoleconsentcovers(origin, consents);
+    if (!consent.allowed) {
+      const record2 = { id: randomid(), prompt: `Console capture on ${origin} for the reviewed ${watchwindow} millisecond window of step ${step.id}.`, origin, stepid: step.id, at: Date.now() };
+      await memory.setconsoleconsent(record2);
+      await refreshbadge();
+      throw new Error(`${consent.reason} The prompt is open in the review panel; approve it and run the step again.`);
+    }
+  }
+  if (step.kind === "watcherrors") {
+    const stackgatecheck = stackgate(session, origin);
+    if (!stackgatecheck.allowed) throw new Error(stackgatecheck.reason ?? "Stack capture stays outside the session origin grants.");
+  }
+  const startedat = Date.now();
+  const bound = attachtimeline({ runid: plan.id, origin, stepids: plan.steps.map((item) => item.id), now: startedat });
+  const watchid = randomid();
+  const registration = { watchid, kind: step.kind, stepid: step.id, sessionid: session.id, origin, scopes: [], events: [], startedat, lifetime: watchwindow };
+  await memory.addwatch(registration);
+  await audit("timeline", `Watcher ${step.kind} attached under id ${watchid} on ${origin} for the reviewed window of ${watchwindow} milliseconds inside the run tab ${tabid2}.`, extra);
+  activetimelinewatchers.set(watchid, { runid: plan.id, startedat, lifetime: watchwindow, cancelled: false });
+  let output;
+  try {
+    output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The watch returned no result." };
+  } catch (error) {
+    activetimelinewatchers.delete(watchid);
+    await memory.closewatch(watchid, Date.now());
+    await audit("timeline", `Watcher ${watchid} detached when the run tab navigated or closed inside the reviewed window of ${watchwindow} milliseconds.`, extra);
+    return { ok: false, summary: `The ${step.kind} watcher detached when the tab navigated or closed inside the reviewed window; run it again on the settled page (${error instanceof Error ? error.message : String(error)}).` };
+  }
+  const watcherstate = activetimelinewatchers.get(watchid);
+  activetimelinewatchers.delete(watchid);
+  await memory.closewatch(watchid, Date.now());
+  await audit("timeline", `Watcher ${watchid} detached cleanly after its reviewed window of ${watchwindow} milliseconds.`, extra);
+  if (watcherstate?.cancelled) {
+    await audit("timeline", `Watcher ${watchid} cancelled on run cancel or the killswitch; the captured window is discarded.`, extra);
+    return { ok: false, summary: `The ${step.kind} watcher was cancelled with the run; the captured window is discarded.` };
+  }
+  const captured = detailarray(output.details, "entries").map((entry) => timelinedetail(entry, plan.id)).filter((entry) => entry !== null);
+  bound.entries.push(...captured);
+  let collapsed = 0;
+  let flagged = [];
+  let stored = bound.entries;
+  if (step.kind === "watchconsole") {
+    const rule = spamruleof(options.spam);
+    if (rule) {
+      const outcome = spamdetect(bound.entries, rule);
+      stored = outcome.entries;
+      collapsed = bound.entries.length - stored.length;
+      flagged = outcome.flagged;
+    }
+  }
+  const rotation = rotationruleof(options.rotation);
+  let rotationtarget;
+  if (rotation) {
+    const rotated = rotatelogs(stored, rotation);
+    stored = rotated.kept;
+    rotationtarget = { target: rotation.overflowtarget, runid: plan.id, entries: rotated.overflow.length, at: Date.now() };
+  }
+  const errorids = [];
+  const rejectionids = [];
+  const longtasks = [];
+  for (const entry of detailarray(output.details, "errors")) {
+    if (!entry || typeof entry !== "object") continue;
+    const record2 = entry;
+    const id = randomid();
+    errorids.push(id);
+    const capturederror = { id, runid: plan.id, stepid: step.id, message: typeof record2.message === "string" ? record2.message : "", frames: Array.isArray(record2.frames) ? record2.frames : [], sourceurl: typeof record2.sourceurl === "string" ? record2.sourceurl : "", line: typeof record2.line === "number" ? record2.line : 0, at: Date.now() };
+    await memory.adderrorrecord(capturederror);
+  }
+  for (const entry of detailarray(output.details, "rejections")) {
+    if (!entry || typeof entry !== "object") continue;
+    const record2 = entry;
+    const id = randomid();
+    rejectionids.push(id);
+    const capturedrejection = { id, runid: plan.id, stepid: step.id, reason: typeof record2.reason === "string" ? record2.reason : "", frames: Array.isArray(record2.frames) ? record2.frames : [], at: Date.now() };
+    await memory.addrejectionrecord(capturedrejection);
+  }
+  for (const entry of detailarray(output.details, "longtasks")) {
+    if (!entry || typeof entry !== "object") continue;
+    const record2 = entry;
+    const capturedtask = { id: randomid(), runid: plan.id, stepid: step.id, duration: typeof record2.duration === "number" ? record2.duration : 0, starttime: typeof record2.starttime === "number" ? record2.starttime : 0, attributions: Array.isArray(record2.attributions) ? record2.attributions.filter((name) => typeof name === "string") : [], at: Date.now() };
+    longtasks.push(capturedtask);
+    await memory.addlongtask(capturedtask);
+  }
+  for (const entry of stored) await memory.addtimelineentry(entry);
+  if (rotationtarget) await memory.addrotationtarget(rotationtarget);
+  const blocking = blockingduration(longtasks, step.id, { startedat, endedat: Date.now() });
+  const evidence = { entries: stored.length, collapsed, errors: errorids.length, rejections: rejectionids.length, longtasks: longtasks.length };
+  await memory.setprogress(recordtimeline(await memory.getprogress(), plan.id, step.id, evidence, Date.now()));
+  await refreshbadge();
+  const counts = timelinecounts(stored);
+  await audit("timeline", `Captured ${stored.length} timeline entr${stored.length === 1 ? "y" : "ies"} of ${origin} for the reviewed window of ${watchwindow} milliseconds${collapsed > 0 ? ` with ${collapsed} collapsed repeat${collapsed === 1 ? "" : "s"}` : ""}${errorids.length > 0 ? `, ${errorids.length} error${errorids.length === 1 ? "" : "s"}` : ""}${rejectionids.length > 0 ? `, ${rejectionids.length} rejection${rejectionids.length === 1 ? "" : "s"}` : ""}${longtasks.length > 0 ? ` and ${longtasks.length} long task${longtasks.length === 1 ? "" : "s"}` : ""}; console, error and task watching derives from page-injected listeners and the performance buffers.`, extra);
+  return { ok: Boolean(output.ok), summary: output.summary, details: { ...output.details ?? {}, timeline: { entries: stored.length, levels: counts, collapsed }, entries: stored, errorids, rejectionids, longtasks: longtasks.map((task) => ({ ...task, blocking: blocking.blocking })), ...flagged.length > 0 ? { flagged } : {}, ...rotationtarget ? { rotation: rotationtarget } : {} } };
+}
+var activerules = /* @__PURE__ */ new Map();
+var activeauthflows = /* @__PURE__ */ new Map();
+function rulesetof(runid) {
+  const existing = activerules.get(runid);
+  if (existing) return existing;
+  const created = { blocks: [], mocks: [], rewrites: [] };
+  activerules.set(runid, created);
+  return created;
+}
+async function revertcontrolsforrun(runid, reason) {
+  const ruleset = activerules.get(runid);
+  if (!ruleset) return;
+  const at = Date.now();
+  let reverted = 0;
+  for (const rule of ruleset.blocks) {
+    if (rule.revertedat !== void 0) continue;
+    await memory.addblockrule(revertrule(rule, at)).catch(() => void 0);
+    await audit("control", `Reverted the block rule ${rule.id} of ${rule.urlpattern} with ${rule.hits} blocked request${rule.hits === 1 ? "" : "s"} at ${reason}.`, { stepid: rule.stepid }).catch(() => void 0);
+    reverted += 1;
+  }
+  for (const spec of ruleset.mocks) {
+    if (spec.revertedat !== void 0) continue;
+    await memory.addmockspec(revertrule(spec, at)).catch(() => void 0);
+    await audit("control", `Reverted the mock fixture ${spec.id} of ${spec.urlpattern} with ${spec.hits} served response${spec.hits === 1 ? "" : "s"} at ${reason}.`, { stepid: spec.stepid }).catch(() => void 0);
+    reverted += 1;
+  }
+  for (const rule of ruleset.rewrites) {
+    if (rule.revertedat !== void 0) continue;
+    await memory.addheaderule(revertrule(rule, at)).catch(() => void 0);
+    await audit("control", `Reverted the header rewrite rule ${rule.id} of ${rule.urlpattern} with ${rule.hits} applied request${rule.hits === 1 ? "" : "s"} at ${reason}.`, { stepid: rule.stepid }).catch(() => void 0);
+    reverted += 1;
+  }
+  if (ruleset.proxy && ruleset.proxy.revertedat === void 0) {
+    await memory.addproxyroute(revertrule(ruleset.proxy, at)).catch(() => void 0);
+    await audit("control", `Reverted the proxy route ${ruleset.proxy.id} of ${ruleset.proxy.scheme}://${ruleset.proxy.host}:${ruleset.proxy.port} at ${reason}; the previous routing state is restored.`, { stepid: ruleset.proxy.stepid }).catch(() => void 0);
+    reverted += 1;
+  }
+  activerules.delete(runid);
+  if (reverted > 0) {
+    await memory.setprogress(recordcontrol(await memory.getprogress(), runid, ruleset.blocks[0]?.stepid ?? ruleset.rewrites[0]?.stepid ?? ruleset.mocks[0]?.stepid ?? ruleset.proxy?.stepid ?? "control", { applied: 0, blocked: 0, mocked: 0, reverts: reverted, reason: `The traffic rules reverted at ${reason}` }, at)).catch(() => void 0);
+    await refreshbadge().catch(() => void 0);
+  }
+}
+async function cancelauthflowsforrun(runid, reason) {
+  for (const [state, active] of [...activeauthflows.entries()]) {
+    if (active.runid !== runid) continue;
+    active.cancelled = true;
+    if (active.tabid) await chrome.tabs.remove(active.tabid).catch(() => void 0);
+    activeauthflows.delete(state);
+    await audit("auth", `Cancelled the oauth flow of provider ${active.flow.provider} at ${reason} before any token was exchanged.`, { stepid: active.stepid }).catch(() => void 0);
+  }
+}
+async function controlledfetch(runid, url, init, controller, window2, streamstate) {
+  const ruleset = activerules.get(runid);
+  if (ruleset) {
+    for (const rule of ruleset.blocks) {
+      if (rule.revertedat !== void 0) continue;
+      if (!matchurlpattern(rule.urlpattern, url)) continue;
+      rule.hits += 1;
+      await memory.addblockrule(rule).catch(() => void 0);
+      await audit("control", `Blocked the ${init.method} request to ${url} by the reviewed rule ${rule.id} of ${rule.urlpattern}; blocking applies to extension initiated traffic and page requests stay visible in the watch buffers.`, { stepid: rule.stepid }).catch(() => void 0);
+      throw new Error(`The request to ${url} was blocked by the reviewed block rule ${rule.id}.`);
+    }
+    const fixture = mockfor(url, ruleset.mocks);
+    if (fixture) {
+      fixture.hits += 1;
+      await memory.addmockspec(fixture).catch(() => void 0);
+      await audit("control", `Served the reviewed mock fixture ${fixture.id} with the ${fixture.status} status for ${url} instead of the network; the fixture body stays out of the audit trail.`, { stepid: fixture.stepid }).catch(() => void 0);
+      return { status: fixture.status, headers: fixture.headers ?? {}, body: fixture.body ?? "" };
+    }
+    const rewritten = applyheaderules(url, init.headers, ruleset.rewrites);
+    if (rewritten.applied.length > 0) {
+      for (const rule of rewritten.applied) {
+        rule.hits += 1;
+        await memory.addheaderule(rule).catch(() => void 0);
+        await audit("control", `Applied the header rewrite rule ${rule.id} of ${rule.operation} ${rule.name} on ${url} from step ${rule.stepid}; the provenance of every applied rule is recorded here.`, { stepid: rule.stepid }).catch(() => void 0);
+      }
+      init = { ...init, headers: rewritten.headers };
+    }
+    if (ruleset.proxy && ruleset.proxy.revertedat === void 0) {
+      const targetorigin = new URL(url).origin;
+      const bypassed = ruleset.proxy.bypass.some((pattern) => {
+        try {
+          return new URL(pattern).origin === targetorigin;
+        } catch {
+          return false;
+        }
+      });
+      if (!bypassed) {
+        const config = await memory.getconfig();
+        if (config?.endpoint) {
+          await audit("control", `Routed the ${init.method} request to ${url} through the reviewed proxy route ${ruleset.proxy.id} of ${ruleset.proxy.scheme}://${ruleset.proxy.host}:${ruleset.proxy.port} via the reviewed relay endpoint ${config.endpoint}.`, { stepid: ruleset.proxy.stepid }).catch(() => void 0);
+          const relayed = await livefetch(config.endpoint, { ...init, headers: { ...init.headers, "x-devthink-target": url } }, controller, window2, streamstate);
+          return relayed;
+        }
+        await audit("control", `The proxy route ${ruleset.proxy.id} of ${ruleset.proxy.host}:${ruleset.proxy.port} covers ${url} but no reviewed relay endpoint is configured, so the request sends direct; the route stays recorded for review.`, { stepid: ruleset.proxy.stepid }).catch(() => void 0);
+      }
+    }
+  }
+  const response = await livefetch(url, init, controller, window2, streamstate);
+  const read = ratelimitreadof(response.headers, new URL(url).origin, Date.now());
+  if (read) await memory.setratelimit(read).catch(() => void 0);
+  return response;
+}
+async function executenetcontrolstep(step, session, plan, tabid2, origin) {
+  const options = stepoptions2(step);
+  const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
+  const ruleset = rulesetof(plan.id);
+  if (step.kind === "blockrequest") {
+    const rule = blockruleof(options.block);
+    if (!rule) throw new Error("A reviewed block rule with a url pattern is required in options.block.");
+    const registered = newblockrule({ id: randomid(), runid: plan.id, stepid: step.id, urlpattern: rule.urlpattern, ...rule.resourcetypes !== void 0 ? { resourcetypes: rule.resourcetypes } : {}, at: Date.now() });
+    ruleset.blocks = [...ruleset.blocks.filter((item) => item.urlpattern !== registered.urlpattern), registered];
+    await memory.addblockrule(registered);
+    await audit("control", `Registered the reviewed block rule ${registered.id} of ${registered.urlpattern}${registered.resourcetypes !== void 0 ? ` for the resource types ${registered.resourcetypes.join(", ")}` : ""} for the run only; every rule reverts at run end and blocking applies to extension initiated traffic.`, extra);
+    await refreshbadge();
+    return { ok: true, summary: `The block rule of ${registered.urlpattern} applies for this run; matched extension requests are refused.`, details: { control: { applied: ruleset.blocks.filter((item) => item.revertedat === void 0).length, blocked: ruleset.blocks.reduce((total, item) => total + item.hits, 0), mocked: ruleset.mocks.reduce((total, item) => total + item.hits, 0) }, rule: { id: registered.id, urlpattern: registered.urlpattern, ...registered.resourcetypes !== void 0 ? { resourcetypes: registered.resourcetypes } : {} }, derivation: "The manifest keeps webRequest out, so blocking refuses extension initiated requests to the pattern and page requests stay visible in the watch buffers." } };
+  }
+  if (step.kind === "mockresponse") {
+    const spec = mockspecof(options.mock);
+    if (!spec || spec.reviewed !== true) throw new Error("A reviewed mock fixture with its full body or captured body ref reviewed is required in options.mock.");
+    let fixturebody = spec.body ?? "";
+    let bodyref;
+    if (spec.bodyref !== void 0) {
+      const captured = await memory.getbody(spec.bodyref);
+      if (!captured) throw new Error(`No captured body matches ${spec.bodyref}; capture it again before the fixture replays it.`);
+      if (captured.body === void 0 || captured.bodyexpired) throw new Error(`The captured body ${spec.bodyref} expired from the retention window; capture it again before the fixture replays it.`);
+      fixturebody = captured.body;
+      bodyref = spec.bodyref;
+    }
+    const registered = newmockspec({ id: randomid(), runid: plan.id, stepid: step.id, urlpattern: spec.urlpattern, status: spec.status, ...spec.headers !== void 0 ? { headers: spec.headers } : {}, body: fixturebody, ...bodyref !== void 0 ? { bodyref } : {}, reviewed: true, at: Date.now() });
+    ruleset.mocks = [...ruleset.mocks.filter((item) => item.urlpattern !== registered.urlpattern), registered];
+    await memory.addmockspec(registered);
+    await audit("control", `Registered the reviewed mock fixture ${registered.id} of ${registered.urlpattern} serving the ${registered.status} status for the run only${bodyref !== void 0 ? ` replaying the captured body ${bodyref} of the body store` : ""}; the fixture body stays out of the audit trail.`, extra);
+    await refreshbadge();
+    return { ok: true, summary: `The mock fixture of ${registered.urlpattern} serves the ${registered.status} status for this run.`, details: { control: { applied: ruleset.mocks.filter((item) => item.revertedat === void 0).length, blocked: ruleset.blocks.reduce((total, item) => total + item.hits, 0), mocked: ruleset.mocks.reduce((total, item) => total + item.hits, 0) }, mock: { id: registered.id, urlpattern: registered.urlpattern, status: registered.status, bytes: fixturebody.length } } };
+  }
+  if (step.kind === "rewriteheaders") {
+    const rules = Array.isArray(options.rules) ? options.rules : [];
+    const registered = [];
+    for (const item of rules) {
+      const rule = headeruleof(item);
+      if (!rule) throw new Error("Every header rewrite rule needs a url pattern, header name, operation and value.");
+      const record2 = newheaderule({ id: randomid(), runid: plan.id, stepid: step.id, urlpattern: rule.urlpattern, name: rule.name, operation: rule.operation, ...rule.value !== void 0 ? { value: rule.value } : {}, at: Date.now() });
+      registered.push(record2);
+    }
+    ruleset.rewrites = [...ruleset.rewrites.filter((item) => !registered.some((record2) => record2.urlpattern === item.urlpattern && record2.name === item.name)), ...registered];
+    for (const record2 of registered) await memory.addheaderule(record2);
+    await audit("control", `Registered ${registered.length} reviewed header rewrite rule${registered.length === 1 ? "" : "s"} of ${registered.map((rule) => `${rule.operation} ${rule.name} on ${rule.urlpattern}`).join("; ")} for the run only; the provenance of every applied rule is audited per request.`, extra);
+    await refreshbadge();
+    return { ok: true, summary: `${registered.length} header rewrite rule${registered.length === 1 ? "" : "s"} apply for this run.`, details: { control: { applied: ruleset.rewrites.filter((item) => item.revertedat === void 0).length, blocked: ruleset.blocks.reduce((total, item) => total + item.hits, 0), mocked: ruleset.mocks.reduce((total, item) => total + item.hits, 0) }, rules: registered.map((rule) => ({ id: rule.id, urlpattern: rule.urlpattern, name: rule.name, operation: rule.operation })) } };
+  }
+  if (step.kind === "setcookies" || step.kind === "readcookies" || step.kind === "clearcookies") {
+    const domain = typeof options.domain === "string" && options.domain.trim() ? options.domain.trim() : step.kind === "setcookies" && Array.isArray(options.cookies) ? String(options.cookies[0]?.domain ?? "") : origin;
+    const gate = cookiegate(session, domain, Date.now());
+    if (!gate.allowed) throw new Error(gate.reason ?? "The cookie domain stays outside the session origin grants.");
+    const pageorigin = `https://${domain.replace(/^\./, "")}`;
+    if (step.kind === "setcookies") {
+      const records = (Array.isArray(options.cookies) ? options.cookies : []).map((item) => cookierecordof(item)).filter((item) => item !== void 0);
+      if (records.length === 0) throw new Error("A reviewed non-empty list of cookie records is required in options.cookies.");
+      const written = await bridgecall(tabid2, "writecookies", records.map((record2) => ({ name: record2.name, value: record2.value, path: record2.path, ...record2.expiresat !== void 0 ? { expiresat: record2.expiresat } : {} })));
+      const operation2 = { id: randomid(), runid: plan.id, stepid: step.id, kind: "write", domain, names: records.map((record2) => record2.name), at: Date.now() };
+      await memory.addcookieop(operation2);
+      await audit("control", `Wrote ${written.written} reviewed cookie${written.written === 1 ? "" : "s"} for the granted domain ${domain} through the page cookie jar; cookie values stay out of the audit trail.`, extra);
+      return { ok: true, summary: `Wrote ${written.written} cookie${written.written === 1 ? "" : "s"} for ${domain}.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, cookies: redactedcookies(records), domain } };
+    }
+    if (step.kind === "readcookies") {
+      const jar = await bridgecall(tabid2, "readcookies");
+      const operation2 = { id: randomid(), runid: plan.id, stepid: step.id, kind: "read", domain, names: jar.map((cookie) => cookie.name), at: Date.now() };
+      await memory.addcookieop(operation2);
+      await audit("control", `Read ${jar.length} cookie${jar.length === 1 ? "" : "s"} of the granted domain ${domain} through the page cookie jar; the values return to the step result and stay out of the audit trail.`, extra);
+      return { ok: true, summary: `Read ${jar.length} cookie${jar.length === 1 ? "" : "s"} of ${domain}.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, cookies: jar, domain } };
+    }
+    const names = Array.isArray(options.names) ? options.names.filter((name) => typeof name === "string" && name.trim().length > 0) : void 0;
+    const cleared = await bridgecall(tabid2, "clearcookies", names);
+    const operation = { id: randomid(), runid: plan.id, stepid: step.id, kind: "clear", domain, names: names ?? [], at: Date.now() };
+    await memory.addcookieop(operation);
+    await audit("control", `Cleared ${cleared.cleared} cookie${cleared.cleared === 1 ? "" : "s"} of the granted domain ${domain} through the page cookie jar.`, extra);
+    return { ok: true, summary: `Cleared ${cleared.cleared} cookie${cleared.cleared === 1 ? "" : "s"} of ${domain}.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, cleared: cleared.cleared, domain, ...names !== void 0 ? { names } : {} } };
+  }
+  if (step.kind === "authflow") {
+    const flow = oauthflowof(options.oauth);
+    if (!flow) throw new Error("A reviewed oauth flow with provider, authorize url, token url, scopes and redirect origin is required in options.oauth.");
+    const tokenorigin = new URL(flow.tokenurl).origin;
+    const tokenorigincheck = origincheck(session, tokenorigin);
+    if (!tokenorigincheck.allowed) throw new Error(tokenorigincheck.reason ?? "The token endpoint stays outside the session origin grants.");
+    const redirectcheck = origincheck(session, flow.redirectorigin);
+    if (!redirectcheck.allowed) throw new Error(redirectcheck.reason ?? "The redirect origin stays outside the session origin grants.");
+    if (options.refresh === true) {
+      const tokenid = typeof options.token === "string" ? options.token : "";
+      const stored = (await memory.listtokens()).find((token) => token.id === tokenid && token.revokedat === void 0);
+      if (!stored) throw new Error(`No stored token record matches ${tokenid}.`);
+      const refreshsecret = await memory.getsecret(stored.refreshstorageid ?? "");
+      if (!refreshsecret) throw new Error("The stored token has no refresh secret; run the flow again.");
+      const controller = new AbortController();
+      activefetches.set(step.id, controller);
+      try {
+        const request = tokenrequest(flow, { refreshtoken: refreshsecret });
+        const response = await controlledfetch(plan.id, request.url, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body: request.body, redirect: "error" }, controller);
+        const tokens = parsetokens(response.body);
+        if (!tokens?.accesstoken) throw new Error(`The token refresh failed with the ${response.status} status.`);
+        const expiresat = Date.now() + (tokens.expiresin !== void 0 ? tokens.expiresin * 1e3 : 3600 * 1e3);
+        await memory.setsecret(stored.accessstorageid, tokens.accesstoken);
+        await memory.addtoken({ ...stored, expiresat, refreshedat: Date.now(), ...tokens.refreshtoken !== void 0 ? { refreshstorageid: stored.refreshstorageid } : {} });
+        await audit("auth", `Refreshed the token of provider ${stored.provider} scoped to ${stored.origin} for the scopes ${stored.scopes.join(", ")} through the reviewed refresh flow; token values never enter the audit trail.`, extra);
+        return { ok: true, summary: `Refreshed the token of ${stored.provider} expiring at ${new Date(expiresat).toISOString()}.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, token: { id: stored.id, provider: stored.provider, scopes: stored.scopes, origin: stored.origin, expiresat, refreshed: true } } };
+      } finally {
+        controller.abort();
+        activefetches.delete(step.id);
+      }
+    }
+    if (options.revoke === true) {
+      const rule = revocationruleof(options.revocation);
+      const tokenids = rule ? rule.tokenids : Array.isArray(options.tokenids) ? options.tokenids.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+      if (tokenids.length === 0) throw new Error("Token revocation needs reviewed token ids in options.");
+      const records = await memory.listtokens();
+      let revoked = 0;
+      for (const tokenid of tokenids) {
+        const stored = records.find((token) => token.id === tokenid);
+        if (!stored || stored.revokedat !== void 0) continue;
+        await memory.setsecret(stored.accessstorageid, "");
+        if (stored.refreshstorageid) await memory.setsecret(stored.refreshstorageid, "");
+        await memory.addtoken({ ...stored, revokedat: Date.now() });
+        revoked += 1;
+      }
+      await audit("auth", `Revoked ${revoked} stored token record${revoked === 1 ? "" : "s"} of the run${rule ? ` with the reason ${rule.reason}` : ""}; the token material is dropped from storage.`, extra);
+      return { ok: true, summary: `Revoked ${revoked} token record${revoked === 1 ? "" : "s"}.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, revoked, tokenids } };
+    }
+    const open = [...activeauthflows.entries()].find(([, active]) => active.runid === plan.id && active.stepid === step.id && !active.cancelled);
+    if (open) {
+      const [state2, active] = open;
+      if (active.tabid) {
+        const tab = await chrome.tabs.get(active.tabid).catch(() => void 0);
+        const redirected = tab?.url;
+        if (redirected) {
+          const captured = capturecode(redirected, active.flow.redirectorigin, state2);
+          if ("code" in captured) {
+            activeauthflows.delete(state2);
+            const controller = new AbortController();
+            activefetches.set(step.id, controller);
+            try {
+              const request = tokenrequest(active.flow, { code: captured.code });
+              const response = await controlledfetch(plan.id, request.url, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body: request.body, redirect: "error" }, controller);
+              const tokens = parsetokens(response.body);
+              if (!tokens?.accesstoken) throw new Error(`The token exchange failed with the ${response.status} status.`);
+              const tokenid = randomid();
+              const expiresat = Date.now() + (tokens.expiresin !== void 0 ? tokens.expiresin * 1e3 : 3600 * 1e3);
+              const accessstorageid = `token-${tokenid}-access`;
+              await memory.setsecret(accessstorageid, tokens.accesstoken);
+              const record2 = { id: tokenid, provider: active.flow.provider, origin: new URL(active.flow.tokenurl).origin, scopes: tokens.scopes ?? active.flow.scopes, accessstorageid, ...tokens.refreshtoken !== void 0 ? { refreshstorageid: `token-${tokenid}-refresh` } : {}, expiresat, at: Date.now() };
+              if (tokens.refreshtoken !== void 0) await memory.setsecret(record2.refreshstorageid ?? "", tokens.refreshtoken);
+              await memory.addtoken(record2);
+              await chrome.tabs.remove(active.tabid).catch(() => void 0);
+              await audit("auth", `Exchanged the captured code of provider ${active.flow.provider} for a token scoped to ${record2.origin} with the scopes ${record2.scopes.join(", ")} expiring at ${new Date(expiresat).toISOString()}; token values stay behind storage ids and never enter the audit trail.`, extra);
+              return { ok: true, summary: `The oauth flow of ${active.flow.provider} captured the redirect code and exchanged it for a token expiring at ${new Date(expiresat).toISOString()}.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, token: { id: record2.id, provider: record2.provider, scopes: record2.scopes, origin: record2.origin, expiresat }, auth: { provider: record2.provider, state: state2, redirectorigin: active.flow.redirectorigin, scopes: record2.scopes, stage: "exchanged" } } };
+            } finally {
+              controller.abort();
+              activefetches.delete(step.id);
+            }
+          }
+          if (captured.error) {
+            activeauthflows.delete(state2);
+            if (active.tabid) await chrome.tabs.remove(active.tabid).catch(() => void 0);
+            return { ok: false, summary: `The oauth flow of ${active.flow.provider} failed: ${captured.error}`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, auth: { provider: active.flow.provider, state: state2, redirectorigin: active.flow.redirectorigin, scopes: active.flow.scopes, stage: "failed" }, error: captured.error } };
+          }
+        }
+      }
+      return { ok: true, summary: `The oauth flow of ${active.flow.provider} still waits for the redirect on ${active.flow.redirectorigin}; finish the provider consent and rerun the step.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, auth: { provider: active.flow.provider, state: state2, redirectorigin: active.flow.redirectorigin, scopes: active.flow.scopes, stage: "consent" } } };
+    }
+    const state = `run-${plan.id.slice(0, 8)}-${randomid().slice(0, 8)}`;
+    const consent = authorizeurl(flow, state);
+    const opened = await chrome.tabs.create({ url: consent, active: true });
+    activeauthflows.set(state, { runid: plan.id, stepid: step.id, flow, ...opened?.id !== void 0 ? { tabid: opened.id } : {}, cancelled: false });
+    await audit("auth", `Opened the provider consent page of ${flow.provider} in reviewed tab ${opened?.id ?? 0} for the scopes ${flow.scopes.join(", ")} with the redirect origin ${flow.redirectorigin}; the extension captures the code on the granted redirect origin only and run cancel closes the flow.`, extra);
+    return { ok: true, summary: `The oauth flow of ${flow.provider} waits for your consent in the opened tab; the code capture watches the granted redirect origin.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, auth: { provider: flow.provider, state, redirectorigin: flow.redirectorigin, scopes: flow.scopes, tabid: opened?.id ?? 0, stage: "consent" }, consenturl: consent, hint: "Finish the provider consent, then rerun the step to capture the redirect code through the granted redirect origin." } };
+  }
+  if (step.kind === "saveapikey") {
+    const key = options.key;
+    if (!key || typeof key !== "object" || Array.isArray(key)) throw new Error("A reviewed api key entry with name, origin scopes, header and value is required in options.key.");
+    const entry = key;
+    const ref = { name: String(entry.name ?? "").trim(), origins: Array.isArray(entry.origins) ? entry.origins.map((item) => String(item)) : [], header: String(entry.header ?? "").trim(), storageid: `apikey-${String(entry.name ?? "").trim()}`, createdat: Date.now() };
+    await memory.setapikey(ref);
+    await memory.setsecret(ref.storageid, String(entry.value ?? ""));
+    await audit("control", `Stored the api key entry ${ref.name} for ${ref.origins.join(", ")} attaching header ${ref.header} behind the reviewed consent; the platform exposes no extension key store, so the material stays behind its storage id and never enters the audit trail.`, extra);
+    return { ok: true, summary: `Stored the api key ${ref.name} for ${ref.origins.join(", ")}.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, apikey: { name: ref.name, origins: ref.origins, header: ref.header, createdat: ref.createdat } } };
+  }
+  if (step.kind === "routeproxy") {
+    const route = proxyrouteof(options.proxy);
+    if (!route) throw new Error("A reviewed proxy route with scheme, host, port and bypass list is required in options.proxy.");
+    const registered = { id: randomid(), runid: plan.id, stepid: step.id, scheme: route.scheme, host: route.host, port: route.port, bypass: route.bypass, appliedat: Date.now() };
+    ruleset.proxy = registered;
+    await memory.addproxyroute(registered);
+    const config = await memory.getconfig();
+    await audit("control", `Applied the reviewed proxy route ${registered.id} of ${registered.scheme}://${registered.host}:${registered.port} for the run only with the bypassed origins ${registered.bypass.join(", ")}; non bypassed extension traffic routes through the reviewed relay endpoint${config?.endpoint ? ` ${config.endpoint}` : " once one is configured"} and the route reverts at run end.`, extra);
+    await refreshbadge();
+    return { ok: true, summary: `The proxy route of ${registered.host}:${registered.port} applies for this run with ${registered.bypass.length} bypassed origin${registered.bypass.length === 1 ? "" : "s"}.`, details: { control: { applied: 1, blocked: 0, mocked: 0 }, proxy: { id: registered.id, scheme: registered.scheme, host: registered.host, port: registered.port, bypass: registered.bypass, appliedat: registered.appliedat }, relay: config?.endpoint ?? "", derivation: "The manifest keeps proxy control out, so the route steers extension initiated traffic through the reviewed relay endpoint pattern and reverts at run end." } };
+  }
+  if (step.kind === "postform" || step.kind === "postfiles") {
+    const payload = step.kind === "postform" ? formpayloadof(options.form) : void 0;
+    const upload = step.kind === "postfiles" ? multipartpayloadof(options.upload) : void 0;
+    const url = payload?.url ?? upload?.url;
+    if (!url) throw new Error("A reviewed payload with a url is required in options.");
+    const urlgate = origincheck(session, url);
+    if (!urlgate.allowed) throw new Error(urlgate.reason ?? "The submission target stays outside the session origin grants.");
+    const budget = typeof options.wait === "number" ? options.wait : void 0;
+    const limits = await memory.getratelimits(Date.now());
+    const limit = limits.find((item) => item.origin === new URL(url).origin);
+    const wait = ratelimitwait(limit, Date.now());
+    const budgetcheck = ratelimitbudgetallowed(wait, budget);
+    if (!budgetcheck.allowed) throw new Error(budgetcheck.reason ?? "The rate limit wait exceeds the reviewed budget.");
+    if (wait > 0) {
+      await audit("control", `The rate limiter waits ${wait} milliseconds until the reset window of ${new URL(url).origin} passes before the submission.`, extra);
+      await new Promise((resolve) => setTimeout(resolve, wait));
+    }
+    const controller = new AbortController();
+    activefetches.set(step.id, controller);
+    try {
+      const started = Date.now();
+      let response;
+      if (payload) {
+        const body2 = urlencodeform(payload.fields);
+        response = await controlledfetch(plan.id, url, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body: body2, redirect: "error" }, controller);
+        await audit("control", `Posted the reviewed urlencoded form of ${payload.fields.length} field${payload.fields.length === 1 ? "" : "s"} to ${url} ending in the ${response.status} class after the rate limiter pass; field values stay out of the audit trail.`, extra);
+        const retryafter2 = retryafterof(response.status, response.headers);
+        if (retryafter2 !== void 0) await audit("control", `The submission endpoint answered ${response.status} with a retry after window of ${retryafter2} milliseconds; the next submission waits for it.`, extra);
+        return { ok: response.status >= 200 && response.status < 300, summary: `The form post to ${url} ended in the ${response.status} class.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, transport: { status: response.status, headers: Object.keys(response.headers), bytes: response.body.length, duration: Date.now() - started }, fields: payload.fields.map((field) => field.name), ...retryafter2 !== void 0 ? { retryafter: retryafter2 } : {} } };
+      }
+      const streamed = multipartchunks(upload ?? { url, fields: [], files: [] });
+      let uploaded = 0;
+      for (let index = 0; index < streamed.chunks.length; index += 1) {
+        uploaded += streamed.chunks[index]?.length ?? 0;
+        await memory.setprogress(recordupload(await memory.getprogress(), plan.id, step.id, { chunk: index + 1, chunks: streamed.chunks.length, uploaded, bytes: streamed.bytes }, Date.now())).catch(() => void 0);
+      }
+      const body = streamed.chunks.join("");
+      response = await controlledfetch(plan.id, url, { method: "POST", headers: { "content-type": `multipart/form-data; boundary=${streamed.boundary}` }, body, redirect: "error" }, controller);
+      await audit("control", `Streamed the reviewed multipart upload of ${(upload?.files ?? []).length} reviewed file${(upload?.files ?? []).length === 1 ? "" : "s"} in ${streamed.chunks.length} chunk${streamed.chunks.length === 1 ? "" : "s"} of ${streamed.bytes} bytes to ${url} ending in the ${response.status} class; file contents stay out of the audit trail.`, extra);
+      const retryafter = retryafterof(response.status, response.headers);
+      if (retryafter !== void 0) await audit("control", `The upload endpoint answered ${response.status} with a retry after window of ${retryafter} milliseconds; the next submission waits for it.`, extra);
+      return { ok: response.status >= 200 && response.status < 300, summary: `The multipart upload to ${url} ended in the ${response.status} class.`, details: { control: { applied: 0, blocked: 0, mocked: 0 }, transport: { status: response.status, headers: Object.keys(response.headers), bytes: response.body.length, duration: Date.now() - started }, upload: { chunks: streamed.chunks.length, bytes: streamed.bytes, files: (upload?.files ?? []).map((file) => file.filename) }, ...retryafter !== void 0 ? { retryafter } : {} } };
+    } finally {
+      controller.abort();
+      activefetches.delete(step.id);
+    }
+  }
+  void tabid2;
+  throw new Error("Unsupported network control kind.");
+}
 async function enforcewindowreview(step, session, plan) {
   const windowid = step.value && /^\d+$/.test(step.value) ? Number.parseInt(step.value, 10) : 0;
   const progress = plan ? await memory.getprogress() : void 0;
@@ -8421,10 +9849,12 @@ async function refreshbadge() {
   const media = (await memory.getmediarecords()).length + (await memory.getimagebatches()).length;
   const recordingprompts = (await memory.getrecordingconsents()).filter((record2) => record2.approved === void 0).length;
   const fetchprompts = (await memory.getfetchconsents()).filter((consent) => consent.approved === void 0).length;
+  const consoleprompts = (await memory.getconsoleconsents()).filter((consent) => consent.approved === void 0).length;
   const observedrequests = (await memory.getexchanges()).length;
   const livechannels = (await memory.getchannels()).filter((channel) => channel.state === "open" || channel.state === "connecting").length;
+  const activerulescount = [...activerules.values()].reduce((total2, ruleset) => total2 + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0);
   const tasktabs2 = new Set(badges.map((badge) => badge.tabid)).size;
-  const total = (queues?.prefetch ?? 0) + (queues?.batchopen ?? 0) + tasktabs2 + prompts + consents + quarantined + datasets + captures + media + recordingprompts + fetchprompts + observedrequests + livechannels;
+  const total = (queues?.prefetch ?? 0) + (queues?.batchopen ?? 0) + tasktabs2 + prompts + consents + quarantined + datasets + captures + media + recordingprompts + fetchprompts + consoleprompts + observedrequests + livechannels + activerulescount;
   await chrome.action.setBadgeText({ text: total > 0 ? String(total) : "" }).catch(() => {
   });
 }
@@ -8490,6 +9920,11 @@ async function executestep(stepid) {
       output = await executesocketstep(step, session, plan, tab.id, origin);
     } else if (isnetwatchkind(step.kind)) {
       output = await executenetwatchstep(step, session, plan, tab.id, origin);
+    } else if (iscontrolkind(step.kind)) {
+      output = await executenetcontrolstep(step, session, plan, tab.id, origin);
+    } else if (isdebugkind(step.kind)) {
+      if (!session || !plan || plan.state !== "approved") throw new Error("Debugging kinds refuse to run outside an approved session plan.");
+      output = await executetimelinestep(step, session, plan, tab.id, origin);
     } else {
       if (step.target && freshcheckkinds.has(step.kind)) {
         const fresh = await snapshot(tab.id);
@@ -8543,6 +9978,10 @@ async function executestep(stepid) {
       });
       await closechannelsforrun(plan.id).catch(() => {
       });
+      await cancelauthflowsforrun(plan.id, "plan completion").catch(() => {
+      });
+      await revertcontrolsforrun(plan.id, "plan completion").catch(() => {
+      });
       const done = { ...plan, state: "completed", completedat: Date.now() };
       await memory.setplan(done);
       await audit("complete", "Every reviewed step of the approved plan has executed.", { ...session ? { sessionid: session.id } : {}, planid: done.id });
@@ -8702,7 +10141,12 @@ async function handlerequest(message, sender) {
       const messagecount = (await memory.getmessages()).length;
       const endpoints = await memory.getendpoints();
       const fetchconsents = await memory.getfetchconsents();
-      const apikeys = (await memory.getapikeys()).map((ref) => ({ name: ref.name, origins: ref.origins, header: ref.header, configuredat: ref.configuredat }));
+      const apikeys = (await memory.getapikeys()).map((ref) => ({ name: ref.name, origins: ref.origins, header: ref.header, createdat: ref.createdat, ...ref.lastuse !== void 0 ? { lastuse: ref.lastuse } : {} }));
+      const traffic = controlreport({ blocks: await memory.getblockrules(), mocks: await memory.getmockspecs(), rewrites: await memory.getheaderules(), cookies: await memory.getcookieops(), proxies: await memory.getproxyroutes(), ratelimits: await memory.getratelimits(Date.now()) });
+      const tokens = authreport({ tokens: await memory.listtokens() });
+      const timelineentries = await memory.gettimeline();
+      const timeline = timelinereport({ entries: timelineentries, errors: await memory.geterrorrecords(), rejections: await memory.getrejectionrecords(), longtasks: await memory.getlongtasks(), levelcounts: timelinecounts(timelineentries) });
+      const authflows = [...activeauthflows.values()].map((active) => ({ provider: active.flow.provider, redirectorigin: active.flow.redirectorigin, scopes: active.flow.scopes, stepid: active.stepid, tabid: active.tabid ?? 0, stage: active.cancelled ? "cancelled" : "consent" }));
       const runsettings = await memory.getsettings();
       const scanhooks = [];
       for (const hook of await memory.getscanhooks()) {
@@ -8714,7 +10158,7 @@ async function handlerequest(message, sender) {
       const livetab = session ? await chrome.tabs.get(session.tabid).catch(() => void 0) : void 0;
       const waitprofile = session ? waitprofiles.find((record2) => record2.origin === session.origin) : void 0;
       const livestate = { phase: livetab?.status === "loading" ? "loading" : "complete", ...navrecords[0] ? { finalurl: navrecords[0].finalurl, redirects: navrecords[0].chain } : {} };
-      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, socketsactive: activesockets.size, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {} };
+      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), socketsactive: activesockets.size, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {} };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -8759,7 +10203,8 @@ async function handlerequest(message, sender) {
       const capture = outcome.details?.capture;
       const media = outcome.details?.media;
       const network = outcome.details?.network;
-      return JSON.parse(outcomeresponse({ outcome, plan, ...resolved ? { resolvedtarget: resolved } : {}, ...capture ? { capture } : {}, ...media ? { media } : {}, ...network ? { network } : {} }));
+      const timeline = outcome.details?.timeline;
+      return JSON.parse(outcomeresponse({ outcome, plan, ...resolved ? { resolvedtarget: resolved } : {}, ...capture ? { capture } : {}, ...media ? { media } : {}, ...network ? { network } : {}, ...timeline ? { timeline } : {} }));
     }
     case "map": {
       const plan = await memory.getplan();
@@ -9327,12 +10772,12 @@ async function handlerequest(message, sender) {
       if (!Array.isArray(inputkey.origins) || inputkey.origins.length === 0 || !inputkey.origins.every((item) => typeof item === "string" && /^https:\/\//.test(item))) throw new Error("The api key needs a reviewed non-empty list of HTTPS origin scopes.");
       if (!inputkey.header?.trim()) throw new Error("A reviewed header name is required for the api key.");
       if (typeof inputkey.value !== "string" || !inputkey.value) throw new Error("The api key needs its secret value; it stays out of every audit trail.");
-      const ref = { name: inputkey.name.trim(), origins: inputkey.origins, header: inputkey.header.trim(), storageid: `apikey-${inputkey.name.trim()}`, configuredat: Date.now() };
-      await memory.setapikey(ref);
-      await memory.setsecret(ref.storageid, inputkey.value);
+      const entry = { name: inputkey.name.trim(), origins: inputkey.origins, header: inputkey.header.trim(), storageid: `apikey-${inputkey.name.trim()}`, createdat: Date.now() };
+      await memory.setapikey(entry);
+      await memory.setsecret(entry.storageid, inputkey.value);
       const session = await memory.getsession();
-      await audit("call", `Stored the api key reference ${ref.name} for ${ref.origins.join(", ")} attaching header ${ref.header}; the key material itself never enters the audit trail.`, { ...session ? { sessionid: session.id } : {} });
-      return { name: ref.name, origins: ref.origins, header: ref.header, configuredat: ref.configuredat };
+      await audit("call", `Stored the api key entry ${entry.name} for ${entry.origins.join(", ")} attaching header ${entry.header}; the key material itself never enters the audit trail.`, { ...session ? { sessionid: session.id } : {} });
+      return { name: entry.name, origins: entry.origins, header: entry.header, createdat: entry.createdat };
     }
     case "deleteapikey": {
       const inputdeletekey = message;
@@ -9370,6 +10815,87 @@ async function handlerequest(message, sender) {
       await audit("configure", `The user set the captured body retention to ${retention === void 0 ? "keep every body" : retention} record${retention === 1 ? "" : "s"}; the exchange metadata always survives.`);
       return { bodyretention: retention };
     }
+    case "settimelineretention": {
+      const inputretention = message;
+      const settings = await memory.getsettings();
+      const retention = typeof inputretention.retention === "number" && Number.isInteger(inputretention.retention) && inputretention.retention >= 0 ? inputretention.retention : void 0;
+      await memory.setsettings({ ...settings, ...retention !== void 0 ? { timelineretention: retention } : {} });
+      await audit("configure", `The user set the timeline retention to ${retention === void 0 ? "keep every entry" : retention} entr${retention === 1 ? "y" : "ies"}; the level count summaries always survive.`);
+      return { timelineretention: retention };
+    }
+    case "approveconsoleconsent": {
+      const inputapprove = message;
+      const records = await memory.getconsoleconsents();
+      const record2 = records.find((item) => item.id === inputapprove.id);
+      if (!record2) throw new Error("No console capture prompt matches the id.");
+      const decided = { ...record2, approved: true, usedat: Date.now() };
+      await memory.setconsoleconsent(decided);
+      await audit("consent", `Console capture on ${record2.origin} approved from the review panel; the decision persists for that origin.`, { stepid: record2.stepid });
+      await refreshbadge();
+      return { approved: true, origin: record2.origin };
+    }
+    case "consolediff": {
+      const inputdiff = message;
+      const base = inputdiff.base?.trim();
+      const target = inputdiff.target?.trim();
+      if (!base || !target) throw new Error("Console diffing needs the two reviewed run ids.");
+      if (base === target) throw new Error("Console diffing needs two different run ids.");
+      const baselines = (await memory.listtimeline({ runid: base })).filter((entry) => entry.source === "console").map((entry) => entry.message);
+      const targetlines = (await memory.listtimeline({ runid: target })).filter((entry) => entry.source === "console").map((entry) => entry.message);
+      if (baselines.length === 0 && targetlines.length === 0) throw new Error("Neither run stored console output yet; run watchconsole on both runs first.");
+      const diff = consolediff({ baseid: base, targetid: target, baselines, targetlines, now: Date.now() });
+      await memory.addconsolediff(diff);
+      await audit("diff", `Diffed the console output of runs ${base} and ${target}: ${diff.added} added, ${diff.removed} removed and ${diff.repeated} repeated line${diff.added + diff.removed + diff.repeated === 1 ? "" : "s"}.`);
+      return consolediffreport({ diff });
+    }
+    case "trafficreport": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for a traffic control envelope.");
+      return controlreport({ blocks: await memory.getblockrules(), mocks: await memory.getmockspecs(), rewrites: await memory.getheaderules(), cookies: await memory.getcookieops(), proxies: await memory.getproxyroutes(), ratelimits: await memory.getratelimits(Date.now()) });
+    }
+    case "authreport": {
+      return authreport({ tokens: await memory.listtokens() });
+    }
+    case "revoketokens": {
+      const inputrevoke = message;
+      const tokenids = Array.isArray(inputrevoke.tokenids) ? inputrevoke.tokenids.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+      if (tokenids.length === 0) throw new Error("Token revocation needs the reviewed token ids.");
+      const reason = inputrevoke.reason?.trim() || "user demand from the review panel";
+      const records = await memory.listtokens();
+      let revoked = 0;
+      for (const tokenid of tokenids) {
+        const stored = records.find((token) => token.id === tokenid);
+        if (!stored || stored.revokedat !== void 0) continue;
+        await memory.setsecret(stored.accessstorageid, "");
+        if (stored.refreshstorageid) await memory.setsecret(stored.refreshstorageid, "");
+        await memory.addtoken({ ...stored, revokedat: Date.now() });
+        revoked += 1;
+      }
+      const session = await memory.getsession();
+      await audit("auth", `Revoked ${revoked} stored token record${revoked === 1 ? "" : "s"} on ${reason}; the token material is dropped from storage.`, { ...session ? { sessionid: session.id } : {} });
+      await refreshbadge();
+      return { revoked, tokenids };
+    }
+    case "revertproxyroute": {
+      const inputrevert = message;
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for a proxy revert.");
+      const ruleset = activerules.get(plan.id);
+      if (!ruleset?.proxy) throw new Error("No active proxy route covers this run.");
+      if (inputrevert.id && ruleset.proxy.id !== inputrevert.id) throw new Error(`No active proxy route matches ${inputrevert.id}.`);
+      const reverted = revertrule(ruleset.proxy, Date.now());
+      ruleset.proxy = reverted;
+      await memory.addproxyroute(reverted);
+      await audit("control", `Reverted the proxy route ${reverted.id} of ${reverted.scheme}://${reverted.host}:${reverted.port} from the review panel; the previous routing state is restored.`, { planid: plan.id, stepid: reverted.stepid });
+      await refreshbadge();
+      return { reverted: true, id: reverted.id };
+    }
+    case "revertcontrols": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for a traffic rule revert.");
+      await revertcontrolsforrun(plan.id, "review panel demand");
+      return { reverted: true };
+    }
     case "netreport": {
       const plan = await memory.getplan();
       if (!plan) throw new Error("No plan is available for a network envelope.");
@@ -9412,11 +10938,27 @@ async function handlerequest(message, sender) {
         controller.abort();
         activefetches.delete(id);
       }
+      for (const [id, watcher] of [...activetimelinewatchers.entries()]) {
+        watcher.cancelled = true;
+        await memory.closewatch(id, Date.now()).catch(() => {
+        });
+        await audit("timeline", `Watcher ${id} cancelled on run cancel or the killswitch; the captured window is discarded.`, { ...session ? { sessionid: session.id } : {}, ...watcher.runid ? { planid: watcher.runid } : {} });
+        activetimelinewatchers.delete(id);
+      }
       const stoppedplan = await memory.getplan();
-      if (stoppedplan) await closechannelsforrun(stoppedplan.id).catch(() => {
-      });
-      else await closechannelsforrun("none").catch(() => {
-      });
+      if (stoppedplan) {
+        await closechannelsforrun(stoppedplan.id).catch(() => {
+        });
+        await cancelauthflowsforrun(stoppedplan.id, "run cancel").catch(() => {
+        });
+        await revertcontrolsforrun(stoppedplan.id, "run cancel").catch(() => {
+        });
+      } else {
+        await closechannelsforrun("none").catch(() => {
+        });
+        await revertcontrolsforrun("none", "run cancel").catch(() => {
+        });
+      }
       for (const [id, active] of [...activerecordings.entries()]) {
         const finished = finishrecording(active.record, Date.now());
         await memory.addmedia(finished).catch(() => {