@wenathlan/extension 1.1.43 → 1.1.44

package/dist/index.js

@@ -1648,15 +1648,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();
@@ -1753,6 +1760,74 @@ 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;
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -1796,6 +1871,315 @@ function randomid() {
   return crypto.randomUUID();
 }
 
+// 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) };
+}
+
+// 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);
+}
+
 // netwatch.ts
 var netwatchkinds = ["watchrequests", "readheaders", "capturebodies", "mapapi", "extractapi"];
 function resourcefacts(entries) {
@@ -2201,9 +2585,9 @@ function polldecision(input) {
 }
 
 // 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"]);
 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"]);
@@ -2218,6 +2602,7 @@ 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 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"]);
@@ -2932,6 +3317,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 = {};
@@ -3230,6 +3618,163 @@ 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 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 {
@@ -3611,6 +4156,10 @@ 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 (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." };
@@ -3712,6 +4261,55 @@ function canexecute(input) {
     const watchgatecheck = watchgate(input.session, input.settings, now);
     if (!watchgatecheck.allowed) return watchgatecheck;
   }
+  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 {
@@ -3746,7 +4344,7 @@ function canexecute(input) {
 }
 
 // version.ts
-var packageversion = "1.1.43";
+var packageversion = "1.1.44";
 
 // types.ts
 var protocolversion = packageversion;
@@ -3783,6 +4381,27 @@ 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.");
+    }
     const evaluation = validatestep(step, origin);
     if (!evaluation.allowed) throw new Error(evaluation.reason);
     const target = outboundtarget(step);
@@ -3857,7 +4476,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 } : {} });
 }
 function mapresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
@@ -3951,12 +4570,36 @@ 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 };
+}
 export {
   annotationplanof,
   apientries,
+  apikeyconsentgranted,
   apireplayspecof,
+  applyheaderules,
   assetentries,
+  authconsentgranted,
+  authorizeurl,
+  authreport,
   blendrows,
+  blockgate,
+  blockruleof,
   bodyfilterof,
   bodymatches,
   buildname,
@@ -3968,6 +4611,7 @@ export {
   callsreport,
   canexecute,
   capturebody,
+  capturecode,
   capturedheaders,
   captureelement,
   captureformats,
@@ -3983,7 +4627,13 @@ export {
   channelorigin,
   closechannel,
   collectmessages,
+  controlkinds,
+  controlreport,
+  controltarget,
   convertdirectiveof,
+  cookiedomaingranted,
+  cookiegate,
+  cookierecordof,
   correlationid,
   croprect,
   crossesviewport,
@@ -4004,12 +4654,14 @@ export {
   filterexchanges,
   finishrecording,
   fixedheadermatch,
+  formpayloadof,
   formreportresponse,
   frameinterval,
   generatedvalueallowed,
   graphqlopenvelope,
   graphqlrequestof,
   headerfilterof,
+  headeruleof,
   heldkeysreport,
   hostpattern,
   htmlqueriesof,
@@ -4017,6 +4669,7 @@ export {
   imagefilterof,
   imagematches,
   imagenames,
+  iscontrolkind,
   isformkind,
   isnetwatchkind,
   issocketkind,
@@ -4027,17 +4680,26 @@ export {
   layoutreport,
   mapresponse,
   matchmessage,
+  matchurlpattern,
   mediaentries,
   mediakinds,
   mediareport,
   messagefilterof,
+  mockfor,
+  mockspecof,
+  multipartchunks,
+  multipartpayloadof,
   navstateresponse,
   netlogreport,
   netwatchkinds,
+  newblockrule,
   newchannel,
   newexchange,
+  newheaderule,
+  newmockspec,
   newrecording,
   normalizeendpoint,
+  oauthflowof,
   observationmodeof,
   observationresponse,
   openchannel,
@@ -4047,7 +4709,9 @@ export {
   parsehtmlbody,
   parseproposal,
   parsessetext,
+  parsetokens,
   passwordconsentgranted,
+  patternorigin,
   payloadshapeof,
   payloadvalid,
   payloadwithdefaults,
@@ -4062,21 +4726,30 @@ export {
   profilegrantgranted,
   protocolversion,
   provenancereport,
+  proxygate,
+  proxyrouteof,
   publishmessage,
   quarantinereport,
   randomid,
   rankapis,
+  ratelimitbudgetallowed,
+  ratelimitreadof,
+  ratelimitwait,
   readpath,
   readstream,
   receivemessage,
   reconnectwaits,
   recordingoptionsof,
+  redactedcookies,
   regionsteps,
   replayurl,
   requestbody,
   resolutionverdict,
   resolvedrisk,
   resourcefacts,
+  retryafterof,
+  revertrule,
+  revocationruleof,
   safetyresponse,
   scaledrect,
   seamweights,
@@ -4097,9 +4770,11 @@ export {
   templateurl,
   thumbdirectiveof,
   thumbgeometry,
+  tokenrequest,
   trailreport,
   transformgrammar,
   unwrapgraphql,
+  urlencodeform,
   validatefieldmatch,
   validateformrecord,
   validatestep,