@wenathlan/extension 1.1.42 → 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();
@@ -1672,6 +1679,155 @@ var sessionmemory = class {
   async getsecret(storageid) {
     return this.adapter.get(storageid);
   }
+  /** Stores one channel record of a socket or event stream, replacing the previous record of that id. */
+  async addchannel(record2) {
+    const records = (await this.adapter.get("channels") ?? []).filter((item) => item.id !== record2.id);
+    await this.adapter.set("channels", [record2, ...records]);
+  }
+  /** Returns every stored channel record, newest first. */
+  async getchannels() {
+    return await this.adapter.get("channels") ?? [];
+  }
+  /** Returns one channel record by its id. */
+  async getchannel(id) {
+    return (await this.getchannels()).find((item) => item.id === id);
+  }
+  /** Queues one message envelope of a channel stream, keeping the arrival order for the waitmessage matchers. */
+  async addmessage(envelope) {
+    const records = (await this.adapter.get("messages") ?? []).filter((item) => !(item.channelid === envelope.channelid && item.sequence === envelope.sequence));
+    await this.adapter.set("messages", [...records, envelope]);
+  }
+  /** Returns every queued message envelope, oldest first, optionally filtered by channel and stream. */
+  async getmessages(channelid, stream) {
+    const records = await this.adapter.get("messages") ?? [];
+    return records.filter((item) => (channelid === void 0 || item.channelid === channelid) && (stream === void 0 || item.stream === stream));
+  }
+  /** Drops the matched message envelopes of one channel from the queue once a waitmessage step consumed them. */
+  async drainmessages(sequences) {
+    const records = await this.adapter.get("messages") ?? [];
+    const kept = records.filter((item) => !sequences.some((match) => match.channelid === item.channelid && match.sequence === item.sequence));
+    await this.adapter.set("messages", kept);
+  }
+  /** Stores one observed exchange record, replacing the previous record of that id. */
+  async addexchange(record2) {
+    const records = (await this.adapter.get("exchanges") ?? []).filter((item) => item.id !== record2.id);
+    await this.adapter.set("exchanges", [record2, ...records]);
+  }
+  /** Returns every stored exchange record, newest first. */
+  async getexchanges() {
+    return await this.adapter.get("exchanges") ?? [];
+  }
+  /** Returns one exchange record by its id. */
+  async getexchange(id) {
+    return (await this.getexchanges()).find((item) => item.id === id);
+  }
+  /** Returns the exchange records filtered by run, origin and status; the status filter accepts one code or the failed class of every exchange with an error class. */
+  async listexchanges(filter) {
+    const records = await this.getexchanges();
+    return records.filter((item) => (filter.runid === void 0 || item.runid === filter.runid) && (filter.origin === void 0 || item.origin === filter.origin) && (filter.status === void 0 || (filter.status === "failed" ? item.errorclass !== void 0 : item.status === filter.status)));
+  }
+  /** Stores one captured response body with its mime type and byte size; the user configured body retention window expires the oldest bodies while the exchange metadata always survives. */
+  async addbody(record2) {
+    const records = await this.getbodies();
+    const retention = (await this.getsettings())?.bodyretention;
+    const combined = [record2, ...records.filter((item) => item.ref !== record2.ref)];
+    const stored = retention === void 0 ? combined : combined.map((item, index) => index < retention ? item : expirebodybytes(item));
+    await this.adapter.set("bodies", stored);
+  }
+  /** Returns every captured body record, newest first. */
+  async getbodies() {
+    return await this.adapter.get("bodies") ?? [];
+  }
+  /** Returns one captured body record with its stored text by its reference. */
+  async getbody(ref) {
+    return (await this.getbodies()).find((item) => item.ref === ref);
+  }
+  /** Stores the page api map of one origin, replacing the previous map of that origin. */
+  async setapimap(origin, entries) {
+    const records = (await this.adapter.get("apimap") ?? []).filter((item) => item.origin !== origin);
+    await this.adapter.set("apimap", [...entries, ...records]);
+  }
+  /** Returns every stored page api map entry, newest first. */
+  async getapimap() {
+    return await this.adapter.get("apimap") ?? [];
+  }
+  /** Stores one event stream subscription record, replacing the previous record of that id. */
+  async setsubscription(record2) {
+    const records = (await this.adapter.get("subscriptions") ?? []).filter((item) => item.id !== record2.id);
+    await this.adapter.set("subscriptions", [record2, ...records]);
+  }
+  /** Returns every stored event stream subscription, newest first. */
+  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";
@@ -1706,14 +1862,732 @@ function expirecallbody(record2) {
   void body;
   return { ...metadata, bodyexpired: true };
 }
+function expirebodybytes(record2) {
+  const { body, ...metadata } = record2;
+  void body;
+  return { ...metadata, bodyexpired: true };
+}
 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) {
+  const facts = [];
+  for (const entry of entries) {
+    const url = typeof entry.name === "string" ? entry.name : "";
+    if (!url) continue;
+    const entrytype = typeof entry.entryType === "string" ? entry.entryType : "resource";
+    if (entrytype !== "resource" && entrytype !== "navigation") continue;
+    facts.push({
+      url,
+      initiator: typeof entry.initiatorType === "string" ? entry.initiatorType : "",
+      entrytype,
+      start: typeof entry.startTime === "number" && Number.isFinite(entry.startTime) ? entry.startTime : 0,
+      duration: typeof entry.duration === "number" && Number.isFinite(entry.duration) ? entry.duration : 0,
+      transfer: typeof entry.transferSize === "number" && Number.isFinite(entry.transferSize) ? entry.transferSize : 0,
+      protocol: typeof entry.nextHopProtocol === "string" ? entry.nextHopProtocol : "",
+      ...typeof entry.responseStatus === "number" && Number.isInteger(entry.responseStatus) ? { status: entry.responseStatus } : {},
+      ...entry.failed === true ? { failed: true } : {}
+    });
+  }
+  return facts;
+}
+function failureclass(fact) {
+  if (fact.status !== void 0 && fact.status >= 400) return { errorclass: "httperror", status: fact.status };
+  if (fact.failed === true) return { errorclass: "networkerror", status: 0 };
+  if ((fact.initiator === "fetch" || fact.initiator === "xmlhttprequest") && fact.duration > 0 && fact.transfer === 0 && fact.protocol === "") return { errorclass: "networkerror", status: 0 };
+  return { status: fact.status ?? 0 };
+}
+function correlationid(runid, index) {
+  return `${runid}-${index + 1}`;
+}
+function newexchange(input) {
+  const verdict = failureclass(input.fact);
+  let origin = "";
+  try {
+    origin = new URL(input.fact.url).origin;
+  } catch {
+    origin = "";
+  }
+  const method = input.fact.initiator === "fetch" || input.fact.initiator === "xmlhttprequest" ? "?" : "GET";
+  const statusclass = verdict.status >= 100 && verdict.status < 600 ? verdict.status >= 200 && verdict.status < 300 ? "success" : verdict.status >= 300 && verdict.status < 400 ? "redirect" : verdict.status >= 400 && verdict.status < 500 ? "clienterror" : verdict.status >= 500 ? "servererror" : "informational" : "unknown";
+  return { id: input.id, runid: input.runid, stepid: input.stepid, correlationid: input.correlationid, url: input.fact.url, origin, method, status: verdict.status, statusclass, ...verdict.errorclass !== void 0 ? { errorclass: verdict.errorclass } : {}, source: "page", ...input.fact.initiator ? { initiator: input.fact.initiator } : {}, timing: Math.round(input.fact.duration), bytes: input.fact.transfer, at: input.at };
+}
+function pairexchange(exchange, response) {
+  if (exchange.correlationid !== response.correlationid) throw new Error(`The response ${response.correlationid} does not pair with the exchange ${exchange.correlationid}.`);
+  return { ...exchange, status: response.status, statusclass: response.status >= 200 && response.status < 300 ? "success" : response.status >= 400 && response.status < 500 ? "clienterror" : response.status >= 500 ? "servererror" : response.status >= 300 && response.status < 400 ? "redirect" : "unknown", bytes: response.bytes, ...response.mime !== void 0 ? { mime: response.mime } : {}, ...response.bodyref !== void 0 ? { bodyref: response.bodyref } : {}, ...Object.keys(response.headers).length > 0 ? { responseheaders: response.headers } : {} };
+}
+function filterexchanges(exchanges, filter) {
+  return exchanges.filter((exchange) => (filter.runid === void 0 || exchange.runid === filter.runid) && (filter.origin === void 0 || exchange.origin === filter.origin) && (filter.status === void 0 || (filter.status === "failed" ? exchange.errorclass !== void 0 : exchange.status === filter.status)));
+}
+function headerfilterof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allow: [], redact: [] };
+  const entry = value;
+  const names = (source) => Array.isArray(source) ? source.filter((name) => typeof name === "string" && name.trim().length > 0).map((name) => name.trim().toLowerCase()) : [];
+  return { allow: names(entry.allow), redact: names(entry.redact) };
+}
+function capturedheaders(headers, filter) {
+  const result = {};
+  for (const [name, value] of Object.entries(headers)) {
+    const key = name.trim().toLowerCase();
+    if (filter.allow.length > 0 && !filter.allow.includes(key)) continue;
+    result[key] = filter.redact.includes(key) ? "[redacted]" : value;
+  }
+  return result;
+}
+function bodyfilterof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const entry = value;
+  const filter = {};
+  if (typeof entry.urlpattern === "string" && entry.urlpattern.trim()) filter.urlpattern = entry.urlpattern.trim();
+  if (Array.isArray(entry.mimes)) filter.mimes = entry.mimes.filter((mime) => typeof mime === "string" && mime.trim().length > 0).map((mime) => mime.trim().toLowerCase());
+  if (typeof entry.ceiling === "number" && Number.isFinite(entry.ceiling) && entry.ceiling >= 0) filter.ceiling = entry.ceiling;
+  return filter;
+}
+function bodymatches(filter, exchange) {
+  if (filter.urlpattern !== void 0 && !exchange.url.includes(filter.urlpattern)) return false;
+  if (filter.mimes !== void 0 && filter.mimes.length > 0) {
+    const mime = ((exchange.mime ?? "").split(";")[0] ?? "").trim().toLowerCase();
+    if (!filter.mimes.includes(mime)) return false;
+  }
+  return true;
+}
+var privatemimes = /* @__PURE__ */ new Set(["text/html", "text/plain", "text/xml", "application/xml", "application/json", "text/json", "application/x-www-form-urlencoded", "application/graphql", "multipart/form-data"]);
+function privatemime(mime) {
+  return privatemimes.has((mime.split(";")[0] ?? "").trim().toLowerCase());
+}
+function capturebody(input) {
+  if (!bodymatches(input.filter, input.exchange)) return { refused: `The exchange ${input.exchange.correlationid} does not match the reviewed body filter.` };
+  const ceiling = input.filter.ceiling;
+  const stored = ceiling !== void 0 && input.body.length > ceiling ? input.body.slice(0, ceiling) : input.body;
+  return { record: { ref: input.ref, runid: input.runid, correlationid: input.exchange.correlationid, url: input.exchange.url, mime: input.mime, bytes: stored.length, body: stored, at: input.at }, truncated: stored.length < input.body.length };
+}
+function payloadshapeof(body) {
+  if (body === void 0) return [];
+  try {
+    const parsed = JSON.parse(body);
+    const shape = (value) => value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value) : [];
+    if (Array.isArray(parsed)) return parsed.length > 0 ? shape(parsed[0]) : [];
+    return shape(parsed);
+  } catch {
+    return [];
+  }
+}
+function isapicandidate(exchange) {
+  if (exchange.initiator === "fetch" || exchange.initiator === "xmlhttprequest") return true;
+  if (exchange.bodyref !== void 0) return true;
+  try {
+    return /\/api\/|\/graphql|\.json($|\?)|\/v\d+\//i.test(new URL(exchange.url).pathname);
+  } catch {
+    return false;
+  }
+}
+function apientries(exchanges, bodies) {
+  const bodybyref = new Map(bodies.map((body) => [body.correlationid, body]));
+  const groups = /* @__PURE__ */ new Map();
+  for (const exchange of exchanges) {
+    if (!isapicandidate(exchange)) continue;
+    let endpoint = exchange.url;
+    let origin = exchange.origin;
+    try {
+      const parsed = new URL(exchange.url);
+      endpoint = `${parsed.origin}${parsed.pathname}`;
+      origin = parsed.origin;
+    } catch {
+    }
+    const key = `${exchange.method} ${endpoint}`;
+    const group = groups.get(key) ?? { endpoint, method: exchange.method, origin, mimes: /* @__PURE__ */ new Map(), frequency: 0, json: 0, captured: 0, shapes: /* @__PURE__ */ new Map(), correlationids: [] };
+    group.frequency += 1;
+    group.correlationids.push(exchange.correlationid);
+    const body = exchange.bodyref !== void 0 ? bodybyref.get(exchange.correlationid) : void 0;
+    const mime = body?.mime ?? exchange.mime ?? "";
+    group.mimes.set(mime, (group.mimes.get(mime) ?? 0) + 1);
+    if (body !== void 0) {
+      group.captured += 1;
+      const shape = payloadshapeof(body.body);
+      if (shape.length > 0) group.json += 1;
+      const shapekey = shape.join(",");
+      group.shapes.set(shapekey, (group.shapes.get(shapekey) ?? 0) + 1);
+    }
+    groups.set(key, group);
+  }
+  return [...groups.values()].map((group) => {
+    const mime = [...group.mimes.entries()].sort((left, right) => right[1] - left[1])[0]?.[0] ?? "";
+    const modalshape = [...group.shapes.entries()].sort((left, right) => right[1] - left[1])[0];
+    return { endpoint: group.endpoint, method: group.method, mime, frequency: group.frequency, payloadshape: (modalshape?.[0] ?? "").split(",").filter(Boolean), jsonshare: group.captured > 0 ? group.json / group.captured : 0, stability: group.captured > 0 ? (modalshape?.[1] ?? 0) / group.captured : 0, origin: group.origin, correlationids: group.correlationids };
+  });
+}
+function rankapis(entries) {
+  const score = (entry) => entry.frequency * (1 + entry.jsonshare + entry.stability);
+  return [...entries].sort((left, right) => score(right) - score(left) || right.frequency - left.frequency);
+}
+function apireplayspecof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  if (typeof entry.endpoint !== "string" || !entry.endpoint.trim()) return void 0;
+  const spec = { endpoint: entry.endpoint.trim() };
+  if (typeof entry.verb === "string" && entry.verb.trim()) spec.verb = entry.verb.trim().toUpperCase();
+  if (entry.overrides !== void 0 && entry.overrides !== null && typeof entry.overrides === "object" && !Array.isArray(entry.overrides)) {
+    const overrides = {};
+    for (const [name, override] of Object.entries(entry.overrides)) {
+      if (typeof override === "string") overrides[name] = override;
+    }
+    spec.overrides = overrides;
+  }
+  if (Array.isArray(entry.paths)) spec.paths = entry.paths.filter((path) => typeof path === "string" && path.trim().length > 0);
+  return spec;
+}
+function replayurl(spec) {
+  const url = new URL(spec.endpoint);
+  for (const [name, value] of Object.entries(spec.overrides ?? {})) url.searchParams.set(name, value);
+  return url.toString();
+}
+function extractvalues(body, paths) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return paths.map((path) => ({ path, missing: true }));
+  }
+  const fields = readpath(parsed, paths.map((path) => ({ name: path, path, kind: "json" })));
+  return fields.map((field) => ({ path: field.path, ...field.value !== void 0 ? { value: field.value } : {}, ...field.missing ? { missing: true } : {} }));
+}
+
+// socketbus.ts
+var socketkinds = ["opensocket", "sendmessage", "waitmessage", "subscribesse", "longpoll"];
+function channelorigin(url) {
+  try {
+    const parsed = new URL(url);
+    const protocol = parsed.protocol === "wss:" ? "https:" : parsed.protocol === "ws:" ? "http:" : parsed.protocol;
+    return `${protocol}//${parsed.host}`;
+  } catch {
+    return "";
+  }
+}
+function channeloptionsof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  if (typeof entry.url !== "string" || !entry.url.trim()) return void 0;
+  const options = {};
+  if (Array.isArray(entry.protocols)) options.protocols = entry.protocols.filter((item) => typeof item === "string" && item.trim().length > 0);
+  if (typeof entry.reconnect === "number" && Number.isFinite(entry.reconnect)) options.reconnect = entry.reconnect;
+  if (typeof entry.backoff === "number" && Number.isFinite(entry.backoff)) options.backoff = entry.backoff;
+  if (typeof entry.backoffceiling === "number" && Number.isFinite(entry.backoffceiling)) options.backoffceiling = entry.backoffceiling;
+  if (typeof entry.lifetime === "number" && Number.isFinite(entry.lifetime)) options.lifetime = entry.lifetime;
+  return { url: entry.url.trim(), options };
+}
+function newchannel(input) {
+  return { id: input.id, runid: input.runid, stepid: input.stepid, kind: input.kind, url: input.url, origin: channelorigin(input.url), state: "connecting", openedat: input.at, sent: 0, received: 0, reconnects: 0, ...input.protocols !== void 0 && input.protocols.length > 0 ? { protocols: [...input.protocols] } : {} };
+}
+function reconnectwaits(attempts, base, ceiling) {
+  const count = Math.max(0, Math.floor(attempts));
+  const waits = [];
+  let wait = Math.max(0, base);
+  for (let index = 0; index < count; index += 1) {
+    waits.push(wait);
+    const next = wait * 2;
+    wait = ceiling !== void 0 && Number.isFinite(ceiling) && ceiling >= 0 ? Math.min(next, ceiling) : next;
+  }
+  return waits;
+}
+async function openchannel(input) {
+  const sleep = input.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, Math.max(0, milliseconds))));
+  const now = input.now ?? Date.now;
+  const attempts = Math.max(1, Math.floor(input.options.reconnect ?? 0) + 1);
+  const waits = reconnectwaits(attempts - 1, input.options.backoff ?? 0, input.options.backoffceiling);
+  let record2 = { ...input.record, state: "connecting" };
+  let lasterror = "";
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      const result = await input.connect(record2.url, record2.protocols ?? []);
+      if (result.open) return { ...record2, state: "open", openedat: now() };
+      lasterror = result.error ?? `closed with code ${result.code ?? 0}`;
+    } catch (error) {
+      lasterror = error instanceof Error ? error.message : String(error);
+    }
+    if (attempt < attempts - 1) {
+      const wait = waits[attempt] ?? 0;
+      if (wait > 0) await sleep(wait);
+      record2 = { ...record2, reconnects: record2.reconnects + 1 };
+    }
+  }
+  return { ...record2, state: "failed", error: lasterror };
+}
+function closechannel(record2, at, error) {
+  const state = error !== void 0 ? "failed" : "closed";
+  return { ...record2, state, closedat: at, ...error !== void 0 ? { error } : {} };
+}
+function tagmessage(state, channelid, stream, payload, at) {
+  const sequence = (state.sequences[channelid] ?? 0) + 1;
+  const envelope = { channelid, stream, payload, sequence, at };
+  return { state: { sequences: { ...state.sequences, [channelid]: sequence }, queue: state.queue }, envelope };
+}
+function publishmessage(state, channelid, stream, payload, at) {
+  return tagmessage(state, channelid, stream, payload, at);
+}
+function receivemessage(state, channelid, stream, payload, at) {
+  const tagged = tagmessage(state, channelid, stream, payload, at);
+  return { state: { ...tagged.state, queue: [...state.queue, tagged.envelope] }, envelope: tagged.envelope };
+}
+function pathstep2(current, segment) {
+  if (Array.isArray(current) && /^\d+$/.test(segment)) return current[Number.parseInt(segment, 10)];
+  if (current && typeof current === "object" && !Array.isArray(current)) return current[segment];
+  return void 0;
+}
+function matchmessage(filter, envelope) {
+  if (!filter) return true;
+  if (filter.stream !== void 0 && filter.stream !== envelope.stream) return false;
+  if (filter.path !== void 0) {
+    try {
+      const parsed = JSON.parse(envelope.payload);
+      let current = parsed;
+      let missing = false;
+      for (const segment of filter.path.split(".")) {
+        const next = pathstep2(current, segment);
+        if (next === void 0) {
+          missing = true;
+          break;
+        }
+        current = next;
+      }
+      if (missing) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function collectmessages(state, channelid, filter) {
+  const limit = filter?.limit !== void 0 && Number.isFinite(filter.limit) && filter.limit >= 1 ? Math.floor(filter.limit) : Number.POSITIVE_INFINITY;
+  const matched = [];
+  const queue = [];
+  for (const envelope of state.queue) {
+    if (envelope.channelid === channelid && matched.length < limit && matchmessage(filter, envelope)) matched.push(envelope);
+    else queue.push(envelope);
+  }
+  return { state: { sequences: state.sequences, queue }, matched };
+}
+function sequenceintegrity(envelopes) {
+  const last = /* @__PURE__ */ new Map();
+  const gaps = [];
+  for (const envelope of envelopes) {
+    const expected = (last.get(envelope.channelid) ?? 0) + 1;
+    if (envelope.sequence !== expected) gaps.push({ channelid: envelope.channelid, expected, found: envelope.sequence });
+    last.set(envelope.channelid, Math.max(envelope.sequence, expected));
+  }
+  return { ok: gaps.length === 0, gaps };
+}
+function messagefilterof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const entry = value;
+  const filter = {};
+  if (typeof entry.stream === "string" && entry.stream.trim()) filter.stream = entry.stream.trim();
+  if (typeof entry.path === "string" && entry.path.trim()) filter.path = entry.path.trim();
+  if (typeof entry.limit === "number" && Number.isFinite(entry.limit) && entry.limit >= 1) filter.limit = Math.floor(entry.limit);
+  return filter;
+}
+function parsessetext(text2) {
+  const separator = text2.lastIndexOf("\n\n");
+  const complete = separator === -1 ? "" : text2.slice(0, separator + 2);
+  const rest = separator === -1 ? text2 : text2.slice(separator + 2);
+  const events = [];
+  for (const block of complete.split(/\n\n/)) {
+    const id = [];
+    const names = [];
+    const data = [];
+    let retry;
+    for (const line of block.split("\n")) {
+      if (line === "" || line.startsWith(":")) continue;
+      const colon = line.indexOf(":");
+      const field = colon === -1 ? line : line.slice(0, colon);
+      let value = colon === -1 ? "" : line.slice(colon + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+      if (field === "id" && value !== "") id.push(value);
+      if (field === "event" && value !== "") names.push(value);
+      if (field === "data") data.push(value);
+      if (field === "retry" && /^\d+$/.test(value)) retry = Number.parseInt(value, 10);
+    }
+    if (id.length === 0 && names.length === 0 && data.length === 0) continue;
+    events.push({ ...id.length > 0 ? { id: id[id.length - 1] } : {}, ...names.length > 0 ? { event: names[names.length - 1] } : {}, data: data.join("\n"), ...retry !== void 0 ? { retry } : {} });
+  }
+  return { events, rest };
+}
+function sserequestheaders(record2) {
+  return { accept: "text/event-stream", ...record2.lasteventid !== void 0 && record2.lasteventid !== "" ? { "last-event-id": record2.lasteventid } : {} };
+}
+function subscriptionoptionsof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  if (typeof entry.url !== "string" || !entry.url.trim()) return void 0;
+  const cancel = entry.cancel;
+  if (!cancel || typeof cancel !== "object" || Array.isArray(cancel)) return void 0;
+  const cancelrecord = cancel;
+  if (cancelrecord.kind !== "stop" && cancelrecord.kind !== "lifetime") return void 0;
+  if (typeof cancelrecord.value !== "string" && typeof cancelrecord.value !== "number") return void 0;
+  const result = { url: entry.url.trim(), cancel: { kind: cancelrecord.kind, value: cancelrecord.value } };
+  if (typeof entry.lifetime === "number" && Number.isFinite(entry.lifetime) && entry.lifetime > 0) result.lifetime = entry.lifetime;
+  if (typeof entry.lasteventid === "string" && entry.lasteventid.trim()) result.lasteventid = entry.lasteventid.trim();
+  return result;
+}
+function pollcursorof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  if (typeof entry.url !== "string" || !entry.url.trim()) return void 0;
+  if (typeof entry.cursorfield !== "string" || !entry.cursorfield.trim()) return void 0;
+  if (typeof entry.interval !== "number" || !Number.isFinite(entry.interval) || entry.interval <= 0) return void 0;
+  const stop = entry.stop;
+  if (!stop || typeof stop !== "object" || Array.isArray(stop)) return void 0;
+  const stoprecord = stop;
+  if (typeof stoprecord.field !== "string" || !stoprecord.field.trim()) return void 0;
+  if (typeof stoprecord.equals !== "string") return void 0;
+  const cursor = { url: entry.url.trim(), cursorfield: entry.cursorfield.trim(), interval: entry.interval, stop: { field: stoprecord.field.trim(), equals: stoprecord.equals } };
+  if (typeof entry.maxpolls === "number" && Number.isFinite(entry.maxpolls) && entry.maxpolls >= 1) cursor.maxpolls = Math.floor(entry.maxpolls);
+  if (typeof entry.param === "string" && entry.param.trim()) cursor.param = entry.param.trim();
+  return cursor;
+}
+function cursorfrom(response, field) {
+  let current = response;
+  for (const segment of field.split(".")) {
+    const next = pathstep2(current, segment);
+    if (next === void 0) return void 0;
+    current = next;
+  }
+  return current === void 0 || current === null ? void 0 : String(current);
+}
+function pollurl(cursor, value) {
+  if (cursor.param === void 0 || value === void 0) {
+    return { url: cursor.url, ...value !== void 0 ? { body: JSON.stringify({ [cursor.cursorfield]: value }) } : {} };
+  }
+  const url = new URL(cursor.url);
+  url.searchParams.set(cursor.param, value);
+  return { url: url.toString() };
+}
+function polldecision(input) {
+  if (input.cancelled?.() === true) return { continue: false, reason: "The long poll loop was cancelled." };
+  if (input.expiresat !== void 0 && input.now >= input.expiresat) return { continue: false, reason: "The long poll loop stopped at the reviewed plan expiry." };
+  const stopvalue = cursorfrom(input.response, input.cursor.stop.field);
+  if (stopvalue !== void 0 && stopvalue === input.cursor.stop.equals) return { continue: false, reason: `The stop condition matched ${input.cursor.stop.field} ${stopvalue}.` };
+  if (input.cursor.maxpolls !== void 0 && input.polls + 1 >= input.cursor.maxpolls) return { continue: false, reason: `The long poll loop reached the reviewed poll ceiling of ${input.cursor.maxpolls}.` };
+  const value = cursorfrom(input.response, input.cursor.cursorfield);
+  const next = pollurl(input.cursor, value);
+  return { continue: true, reason: "The long poll loop continues.", ...value !== void 0 ? { cursor: value } : {}, next: { ...next, wait: input.cursor.interval } };
+}
+
 // 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"]);
-var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction"]);
-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"]);
+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", "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"]);
@@ -1726,6 +2600,9 @@ var filesactions = /* @__PURE__ */ new Set(["batchdownload", "pausedownload", "r
 var captureactions = /* @__PURE__ */ new Set(["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"]);
 var mediaactions = /* @__PURE__ */ new Set(["capturepdf", "recordscreen", "captureaudio", "captureframe", "downloadimages", "shotcanvas", "probestream", "readmedia", "readassets", "timelapse", "convertimage", "makethumbs"]);
 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"]);
@@ -2434,6 +3311,62 @@ function ismediakind(kind) {
 function ishttpkind(kind) {
   return httpactions.has(kind);
 }
+function issocketkind(kind) {
+  return socketactions.has(kind);
+}
+function isnetwatchkind(kind) {
+  return netwatchactions.has(kind);
+}
+function iscontrolkind(kind) {
+  return controlactions.has(kind);
+}
+function resolvedrisk(step) {
+  if (step.kind === "capturebodies") {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    const body = options.body;
+    const mimes = body && typeof body === "object" && !Array.isArray(body) ? body.mimes : void 0;
+    if (Array.isArray(mimes) && mimes.some((mime) => typeof mime === "string" && privatemime(mime))) return "sensitive";
+    return "interaction";
+  }
+  if (step.kind === "extractapi") {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    const replay = options.replay;
+    const verb = replay && typeof replay === "object" && !Array.isArray(replay) ? replay.verb : void 0;
+    if (typeof verb === "string" && !["GET", "HEAD", "OPTIONS"].includes(verb.trim().toUpperCase())) return "sensitive";
+    return "read";
+  }
+  return actionrisk(step.kind);
+}
+function socketgate(session, url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return { allowed: false, reason: "The channel needs a valid url before it can be reviewed." };
+  }
+  if (parsed.protocol !== "wss:" && parsed.protocol !== "https:") return { allowed: false, reason: "Channels use wss websocket urls or https event stream urls only." };
+  if (parsed.username || parsed.password) return { allowed: false, reason: "Channel credentials are not allowed in the url." };
+  const origin = channelorigin(url);
+  if (!origingranted(session, origin)) return { allowed: false, reason: `The channel to ${origin} stays outside the session origin grants.` };
+  return { allowed: true };
+}
+function watchgate(session, settings, now) {
+  if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the request watch." };
+  if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot watch requests." };
+  if (session.pausedat) return { allowed: false, reason: "The browser session is paused and cannot watch requests." };
+  if (settings?.webrequestgrant !== true) return { allowed: false, reason: "Request watching needs the webrequest grant in the review panel first; the observation derives from the page timing buffers and adds no manifest permission." };
+  return { allowed: true };
+}
 function origincheck(session, url) {
   let parsed;
   try {
@@ -2599,6 +3532,265 @@ function fetchnumeric(options, key) {
 function isrecordingkind(kind) {
   return kind === "recordscreen" || kind === "captureaudio";
 }
+function validatesocketgrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "opensocket") {
+    const channel = channeloptionsof(options.socket);
+    if (!channel) return { allowed: false, reason: "A reviewed socket with a url is required in options.socket." };
+    if (channel.options.reconnect !== void 0 && !Number.isInteger(channel.options.reconnect)) return { allowed: false, reason: "The reviewed socket reconnect budget must be an integer attempt count with no code ceiling." };
+    for (const label of ["backoff", "backoffceiling"]) {
+      const value = channel.options[label];
+      if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value) || value < 0)) return { allowed: false, reason: `The reviewed socket ${label} must be zero or a positive number of milliseconds with no code ceiling.` };
+    }
+    if (channel.options.lifetime !== void 0 && (typeof channel.options.lifetime !== "number" || !Number.isFinite(channel.options.lifetime) || channel.options.lifetime <= 0)) return { allowed: false, reason: "The reviewed socket lifetime window must be a positive number of milliseconds." };
+  }
+  if (kind === "sendmessage") {
+    const message = options.message;
+    if (!message || typeof message !== "object" || Array.isArray(message)) return { allowed: false, reason: "A reviewed message with a channel, stream and payload is required in options.message." };
+    const envelope = message;
+    if (!isnonempty(envelope.channel)) return { allowed: false, reason: "The reviewed message needs the open channel id in options.message.channel." };
+    if (envelope.stream !== void 0 && !isnonempty(envelope.stream)) return { allowed: false, reason: "The reviewed message stream name must be a non-empty string." };
+    if (typeof envelope.payload !== "string") return { allowed: false, reason: "The reviewed message payload must be a string." };
+  }
+  if (kind === "waitmessage") {
+    if (options.filter !== void 0) {
+      const filter = options.filter;
+      if (!filter || typeof filter !== "object" || Array.isArray(filter)) return { allowed: false, reason: "The reviewed message filter must be an object of stream, path and limit." };
+      const reviewed = filter;
+      if (reviewed.stream !== void 0 && !isnonempty(reviewed.stream)) return { allowed: false, reason: "The reviewed message filter stream name must be a non-empty string." };
+      if (reviewed.path !== void 0 && (typeof reviewed.path !== "string" || !validpath(reviewed.path.trim()))) return { allowed: false, reason: "The reviewed message filter path must be a dotted path of non-empty segments." };
+      if (reviewed.limit !== void 0 && (typeof reviewed.limit !== "number" || !Number.isInteger(reviewed.limit) || reviewed.limit < 1)) return { allowed: false, reason: "The reviewed message match limit must be a positive integer with no code ceiling." };
+    }
+    if (options.wait !== void 0 && (typeof options.wait !== "number" || !Number.isFinite(options.wait) || options.wait < 0)) return { allowed: false, reason: "The reviewed message wait budget must be zero or a positive number of milliseconds." };
+  }
+  if (kind === "subscribesse") {
+    const subscription = subscriptionoptionsof(options.subscription);
+    if (!subscription) return { allowed: false, reason: "A reviewed subscription with an event stream url and a cancellation path is required in options.subscription." };
+    const rawlifetime = options.subscription && typeof options.subscription === "object" && !Array.isArray(options.subscription) ? options.subscription.lifetime : void 0;
+    if (rawlifetime !== void 0 && (typeof rawlifetime !== "number" || !Number.isFinite(rawlifetime) || rawlifetime <= 0)) return { allowed: false, reason: "The reviewed subscription lifetime window must be a positive number of milliseconds." };
+  }
+  if (kind === "longpoll") {
+    const cursor = pollcursorof(options.poll);
+    if (!cursor) return { allowed: false, reason: "A reviewed poll cursor with a url, cursor field, interval and stop condition is required in options.poll." };
+    const wait = options.wait;
+    if (wait !== void 0 && (typeof wait !== "number" || !Number.isFinite(wait) || wait < 0)) return { allowed: false, reason: "The reviewed long poll wait budget must be zero or a positive number of milliseconds." };
+    if (wait !== void 0 && cursor.interval > wait) return { allowed: false, reason: `The long poll interval of ${cursor.interval} milliseconds exceeds the reviewed wait budget of ${wait} milliseconds; review a wider budget or a shorter interval.` };
+  }
+  return { allowed: true };
+}
+function validatenetwatchgrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "watchrequests") {
+    if (options.watch !== void 0) {
+      const watch = options.watch;
+      if (!watch || typeof watch !== "object" || Array.isArray(watch)) return { allowed: false, reason: "The reviewed watch window must be an object." };
+      const reviewed = watch;
+      if (reviewed.window !== void 0 && (typeof reviewed.window !== "number" || !Number.isFinite(reviewed.window) || reviewed.window < 0)) return { allowed: false, reason: "The reviewed watch window must be zero or a positive number of milliseconds." };
+    }
+    if (options.limit !== void 0 && (typeof options.limit !== "number" || !Number.isInteger(options.limit) || options.limit < 1)) return { allowed: false, reason: "The reviewed watch match limit must be a positive integer with no code ceiling." };
+  }
+  if (kind === "readheaders") {
+    const headers = options.headers;
+    if (!headers || typeof headers !== "object" || Array.isArray(headers)) return { allowed: false, reason: "A reviewed header filter with a name allowlist and a redaction list is required in options.headers." };
+    const reviewed = headers;
+    if (!Array.isArray(reviewed.allow) || reviewed.allow.length === 0 || !reviewed.allow.every((name) => isnonempty(name))) return { allowed: false, reason: "The reviewed header allowlist must be a non-empty list of header names." };
+    if (!Array.isArray(reviewed.redact) || reviewed.redact.length === 0 || !reviewed.redact.every((name) => isnonempty(name))) return { allowed: false, reason: "Header capture requires a reviewed redaction list before any header value is stored." };
+  }
+  if (kind === "capturebodies") {
+    const body = options.body;
+    if (!body || typeof body !== "object" || Array.isArray(body)) return { allowed: false, reason: "A reviewed body filter with a url pattern, mime list and byte ceiling is required in options.body." };
+    const reviewed = body;
+    if (reviewed.urlpattern !== void 0 && !isnonempty(reviewed.urlpattern)) return { allowed: false, reason: "The reviewed body url pattern must be a non-empty string." };
+    if (reviewed.mimes !== void 0 && (!Array.isArray(reviewed.mimes) || reviewed.mimes.length === 0 || !reviewed.mimes.every((mime) => isnonempty(mime)))) return { allowed: false, reason: "The reviewed body mime list must be a non-empty list of mime types." };
+    if (reviewed.ceiling !== void 0 && (typeof reviewed.ceiling !== "number" || !Number.isFinite(reviewed.ceiling) || reviewed.ceiling < 0)) return { allowed: false, reason: "The reviewed body byte ceiling must be zero or a positive number of bytes with no code ceiling." };
+  }
+  if (kind === "mapapi") {
+    if (options.limit !== void 0 && (typeof options.limit !== "number" || !Number.isInteger(options.limit) || options.limit < 1)) return { allowed: false, reason: "The reviewed mapapi match limit must be a positive integer with no code ceiling." };
+  }
+  if (kind === "extractapi") {
+    const replay = apireplayspecof(options.replay);
+    if (!replay) return { allowed: false, reason: "A reviewed replay spec with an endpoint is required in options.replay." };
+    if (!ishttpsurl(replay.endpoint)) return { allowed: false, reason: "The reviewed replay endpoint must be an HTTPS url." };
+    if (replay.verb !== void 0 && !["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"].includes(replay.verb)) return { allowed: false, reason: "The reviewed replay verb must be a known HTTP verb." };
+    for (const path of replay.paths ?? []) {
+      if (!validpath(path.trim())) return { allowed: false, reason: `The reviewed replay extraction path ${path} must be a dotted path of non-empty segments.` };
+    }
+  }
+  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 {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  for (const key of ["socket", "subscription", "poll"]) {
+    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();
+    }
+  }
+  return void 0;
+}
 function mediagate(session, tabid, origin, now) {
   if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the media capture." };
   if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot capture media." };
@@ -2956,6 +4148,18 @@ function validatestep(step, origin) {
     const httpcheck = validatehttpgrammar(step, options);
     if (!httpcheck.allowed) return httpcheck;
   }
+  if (issocketkind(step.kind)) {
+    const socketcheck = validatesocketgrammar(step, options);
+    if (!socketcheck.allowed) return socketcheck;
+  }
+  if (isnetwatchkind(step.kind)) {
+    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." };
@@ -3046,6 +4250,79 @@ function canexecute(input) {
       if (!consentgate.allowed) return consentgate;
     }
   }
+  if (issocketkind(input.step.kind)) {
+    const channelurl = sockettarget(input.step);
+    if (channelurl !== void 0) {
+      const channelgate = socketgate(input.session, channelurl);
+      if (!channelgate.allowed) return channelgate;
+    }
+  }
+  if (input.step.kind === "watchrequests") {
+    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 {
+      replayoptions = parseoptions(input.step);
+    } catch {
+      replayoptions = {};
+    }
+    const replay = apireplayspecof(replayoptions.replay);
+    if (replay !== void 0) {
+      const replaygate = origincheck(input.session, replay.endpoint);
+      if (!replaygate.allowed) return replaygate;
+    }
+  }
   if (input.step.kind === "openlink" || input.step.kind === "openprivate" || input.step.kind === "batchopen" || input.step.kind === "prefetch" || input.step.kind === "deeplink" || input.step.kind === "reopentab") {
     let options = {};
     try {
@@ -3067,7 +4344,7 @@ function canexecute(input) {
 }
 
 // version.ts
-var packageversion = "1.1.42";
+var packageversion = "1.1.44";
 
 // types.ts
 var protocolversion = packageversion;
@@ -3088,6 +4365,10 @@ function parseproposal(value, origin, grants) {
   const planinput = record(root.plan);
   const stepsinput = planinput.steps;
   if (!Array.isArray(stepsinput) || stepsinput.length === 0) throw new Error("A plan needs at least one step.");
+  const createdat = Date.now();
+  const expiresat = typeof planinput.expiresat === "number" ? planinput.expiresat : createdat + 10 * 60 * 1e3;
+  if (expiresat <= createdat) throw new Error("Plan expiry must be in the future.");
+  const planwindow = expiresat - createdat;
   const steps = stepsinput.map((input, index) => {
     const candidate = record(input);
     const kind = text(candidate.kind, `step ${index + 1} kind`);
@@ -3095,11 +4376,32 @@ function parseproposal(value, origin, grants) {
       id: typeof candidate.id === "string" ? candidate.id : crypto.randomUUID(),
       kind,
       summary: text(candidate.summary, `step ${index + 1} summary`),
-      risk: actionrisk(kind),
+      risk: resolvedrisk(stepof(kind, candidate, index)),
       ...typeof candidate.target === "string" ? { target: candidate.target } : {},
       ...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);
@@ -3113,6 +4415,29 @@ function parseproposal(value, origin, grants) {
       });
       if (!granted) throw new Error(`The fetch request to ${target} targets an origin outside the grants.`);
     }
+    const channelurl = sockettarget(step);
+    if (channelurl !== void 0) {
+      const channeloriginvalue = channeloriginof(channelurl);
+      const granted = covered.some((pattern) => {
+        try {
+          return new URL(channelurl).origin === new URL(pattern).origin || channeloriginvalue === new URL(pattern).origin;
+        } catch {
+          return false;
+        }
+      });
+      if (!granted) throw new Error(`The channel to ${channelurl} targets an origin outside the grants.`);
+    }
+    let lifetime;
+    try {
+      const options = parseoptions(step);
+      for (const key of ["socket", "subscription"]) {
+        const value2 = options[key];
+        if (value2 && typeof value2 === "object" && !Array.isArray(value2) && typeof value2.lifetime === "number") lifetime = value2.lifetime;
+      }
+    } catch {
+      lifetime = void 0;
+    }
+    if (lifetime !== void 0 && lifetime > planwindow) throw new Error(`The channel lifetime of ${lifetime} milliseconds exceeds the reviewed plan window of ${planwindow} milliseconds.`);
     return step;
   });
   for (const step of steps) {
@@ -3125,8 +4450,6 @@ function parseproposal(value, origin, grants) {
     const review = submitreviewgranted(steps, step.id);
     if (!review.allowed) throw new Error(review.reason);
   }
-  const createdat = Date.now();
-  const expiresat = typeof planinput.expiresat === "number" ? planinput.expiresat : createdat + 10 * 60 * 1e3;
   const plan = {
     id: typeof planinput.id === "string" ? planinput.id : crypto.randomUUID(),
     objective: text(planinput.objective, "objective"),
@@ -3136,14 +4459,24 @@ function parseproposal(value, origin, grants) {
     expiresat,
     state: "pending"
   };
-  if (plan.expiresat <= createdat) throw new Error("Plan expiry must be in the future.");
   return { version: protocolversion, plan };
 }
+function stepof(kind, candidate, index) {
+  return { id: typeof candidate.id === "string" ? candidate.id : `candidate${index + 1}`, kind, summary: typeof candidate.summary === "string" ? candidate.summary : "", risk: "read", ...typeof candidate.options === "string" ? { options: candidate.options } : {} };
+}
+function channeloriginof(url) {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.protocol === "wss:" ? "https:" : parsed.protocol}//${parsed.host}`;
+  } catch {
+    return "";
+  }
+}
 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 } : {} });
+  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 });
@@ -3234,10 +4567,41 @@ function callsreport(input) {
   });
   return { version: protocolversion, calls };
 }
+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,
   buildpdf,
   buildsheet,
@@ -3246,6 +4610,9 @@ export {
   callrest,
   callsreport,
   canexecute,
+  capturebody,
+  capturecode,
+  capturedheaders,
   captureelement,
   captureformats,
   capturekinds,
@@ -3256,9 +4623,21 @@ export {
   capturestitched,
   capturetargets,
   capturevisible,
+  channeloptionsof,
+  channelorigin,
+  closechannel,
+  collectmessages,
+  controlkinds,
+  controlreport,
+  controltarget,
   convertdirectiveof,
+  cookiedomaingranted,
+  cookiegate,
+  cookierecordof,
+  correlationid,
   croprect,
   crossesviewport,
+  cursorfrom,
   datasetresponse,
   dedupeimages,
   actionrisk as deriveactionrisk,
@@ -3266,16 +4645,23 @@ export {
   downloadreport,
   errorreportresponse,
   eventresponse,
+  exchangesreport,
   extractionreport,
+  extractvalues,
+  failureclass,
   fetchoptionsof,
   fetchrequestof,
+  filterexchanges,
   finishrecording,
   fixedheadermatch,
+  formpayloadof,
   formreportresponse,
   frameinterval,
   generatedvalueallowed,
   graphqlopenvelope,
   graphqlrequestof,
+  headerfilterof,
+  headeruleof,
   heldkeysreport,
   hostpattern,
   htmlqueriesof,
@@ -3283,67 +4669,118 @@ export {
   imagefilterof,
   imagematches,
   imagenames,
+  iscontrolkind,
   isformkind,
+  isnetwatchkind,
+  issocketkind,
   iswatchkind,
   jsonpathrulesof,
   lapseframes,
   lapseplanof,
   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,
   outcomeresponse,
+  pairexchange,
   pairstates,
   parsehtmlbody,
   parseproposal,
+  parsessetext,
+  parsetokens,
   passwordconsentgranted,
+  patternorigin,
+  payloadshapeof,
   payloadvalid,
   payloadwithdefaults,
   pdfoptionsof,
   pdfpagesize,
   pdfsegments,
   pdftextlayout,
+  pollcursorof,
+  polldecision,
+  pollurl,
+  privatemime,
   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,
   selectorresponse,
   sendfetch,
+  sequenceintegrity,
   sessionmemory,
   signalsreport,
+  socketgate,
+  socketkinds,
+  sserequestheaders,
   statusclassof,
   streamsummaries,
   streamwindowof,
   submitreviewgranted,
+  subscriptionoptionsof,
   tabreportresponse,
   templateurl,
   thumbdirectiveof,
   thumbgeometry,
+  tokenrequest,
   trailreport,
   transformgrammar,
   unwrapgraphql,
+  urlencodeform,
   validatefieldmatch,
   validateformrecord,
   validatestep,
   validatetargetref,
   validatevaluegen,
+  watchgate,
   wizardreport
 };
 //# sourceMappingURL=index.js.map