@wenathlan/extension 1.1.41 → 1.1.42

package/dist/index.js

@@ -196,6 +196,292 @@ function annotationplanof(input) {
   return plan;
 }
 
+// httpclient.ts
+var httpkinds = ["fetchurl", "parsejson", "parsehtml", "callrest", "callgraphql"];
+var redirectstatuses = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var bodilessmethods = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+function statusclassof(status) {
+  if (status >= 100 && status < 200) return "informational";
+  if (status >= 200 && status < 300) return "success";
+  if (status >= 300 && status < 400) return "redirect";
+  if (status >= 400 && status < 500) return "clienterror";
+  if (status >= 500 && status < 600) return "servererror";
+  return "unknown";
+}
+function templateurl(template, values) {
+  return template.replace(/\{([a-z0-9_]+)\}/gi, (whole, name) => values[name] === void 0 ? whole : String(values[name]));
+}
+function fetchrequestof(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;
+  const request = { url: options.url.trim() };
+  if (typeof options.method === "string" && options.method.trim()) request.method = options.method.trim().toUpperCase();
+  if (options.headers && typeof options.headers === "object" && !Array.isArray(options.headers)) {
+    const headers = {};
+    for (const [name, headervalue] of Object.entries(options.headers)) {
+      if (typeof headervalue === "string") headers[name] = headervalue;
+    }
+    request.headers = headers;
+  }
+  if (typeof options.body === "string") request.body = options.body;
+  if (options.mode === "cors" || options.mode === "no-cors" || options.mode === "same-origin") request.mode = options.mode;
+  return request;
+}
+function fetchoptionsof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const options = value;
+  const normalized = {};
+  if (typeof options.timeout === "number" && Number.isFinite(options.timeout)) normalized.timeout = options.timeout;
+  if (typeof options.retries === "number" && Number.isFinite(options.retries)) normalized.retries = options.retries;
+  if (typeof options.backoff === "number" && Number.isFinite(options.backoff)) normalized.backoff = options.backoff;
+  if (typeof options.follow === "number" && Number.isFinite(options.follow)) normalized.follow = options.follow;
+  return normalized;
+}
+function streamwindowof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const options = value;
+  const window = {};
+  if (typeof options.budget === "number" && Number.isFinite(options.budget)) window.budget = options.budget;
+  return window;
+}
+function jsonpathrulesof(value) {
+  if (!Array.isArray(value)) return [];
+  const rules = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const entry = item;
+    if (typeof entry.name !== "string" || !entry.name.trim()) continue;
+    if (typeof entry.path !== "string" || !entry.path.trim()) continue;
+    const rule = { name: entry.name.trim(), path: entry.path.trim() };
+    if (entry.kind === "text" || entry.kind === "number" || entry.kind === "boolean" || entry.kind === "json") rule.kind = entry.kind;
+    if (entry.default !== void 0) rule.default = entry.default;
+    rules.push(rule);
+  }
+  return rules;
+}
+function htmlqueriesof(value) {
+  if (!Array.isArray(value)) return [];
+  const queries = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const entry = item;
+    if (typeof entry.selector !== "string" || !entry.selector.trim()) continue;
+    const query = { selector: entry.selector.trim() };
+    if (typeof entry.attribute === "string" && entry.attribute.trim()) query.attribute = entry.attribute.trim();
+    if (entry.multi === true) query.multi = true;
+    queries.push(query);
+  }
+  return queries;
+}
+function graphqlrequestof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (typeof options.query !== "string" || !options.query.trim()) return void 0;
+  if (options.operationkind !== "query" && options.operationkind !== "mutation") return void 0;
+  const request = { query: options.query, operationkind: options.operationkind };
+  if (options.variables && typeof options.variables === "object" && !Array.isArray(options.variables)) request.variables = options.variables;
+  if (typeof options.operationname === "string" && options.operationname.trim()) request.operationname = options.operationname.trim();
+  return request;
+}
+var realsleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, Math.max(0, milliseconds)));
+async function sendfetch(input) {
+  const options = input.options ?? {};
+  const sleep = input.sleep ?? realsleep;
+  const now = input.now ?? Date.now;
+  const attempts = Math.max(1, Math.floor(options.retries ?? 0) + 1);
+  const backoff = options.backoff ?? 0;
+  const follow = options.follow ?? Number.POSITIVE_INFINITY;
+  let url = input.request.url;
+  let method = (input.request.method ?? "GET").toUpperCase();
+  let retries = 0;
+  let redirects = 0;
+  let lastreason = "";
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    let hops = 0;
+    const startedat = now();
+    let response;
+    try {
+      const init = { method, headers: { ...input.request.headers ?? {} }, ...input.request.body !== void 0 && !bodilessmethods.has(method) ? { body: input.request.body } : {}, ...input.request.mode !== void 0 ? { mode: input.request.mode } : {}, redirect: follow <= 0 ? "error" : "follow" };
+      const sent = input.transport(url, init);
+      if (options.timeout !== void 0 && Number.isFinite(options.timeout) && options.timeout >= 0) {
+        let timedout = false;
+        response = await Promise.race([sent, sleep(options.timeout).then(() => {
+          timedout = true;
+          return void 0;
+        })]).then((value) => value ?? (timedout ? (() => {
+          throw new Error(`The request timed out after ${options.timeout} milliseconds.`);
+        })() : value));
+      } else {
+        response = await sent;
+      }
+      while (response !== void 0 && redirectstatuses.has(response.status) && typeof response.location === "string" && response.location) {
+        hops += 1;
+        if (hops > follow) throw new Error(`The redirect chain exceeded the reviewed follow limit of ${follow}.`);
+        url = new URL(response.location, url).toString();
+        if (method === "POST" && [301, 302, 303].includes(response.status)) method = "GET";
+        response = await input.transport(url, { ...init, method });
+      }
+      redirects = hops;
+    } catch (error) {
+      lastreason = error instanceof Error ? error.message : String(error);
+      response = void 0;
+    }
+    if (response !== void 0) {
+      const body = response.body;
+      return { url, status: response.status, statusclass: statusclassof(response.status), headernames: Object.keys(response.headers), body, bytes: body.length, duration: now() - startedat, retries, redirects };
+    }
+    if (attempt < attempts) {
+      const wait = backoff * attempt;
+      if (wait > 0) await sleep(wait);
+      input.onretry?.(attempt, wait, lastreason);
+      retries = attempt;
+    }
+  }
+  throw new Error(`The request failed after ${attempts} attempt${attempts === 1 ? "" : "s"} with ${retries} retr${retries === 1 ? "y" : "ies"}: ${lastreason}`);
+}
+async function readstream(input) {
+  const pull = typeof input.chunks === "function" ? input.chunks : /* @__PURE__ */ ((source) => {
+    let index = 0;
+    return async () => source[index++];
+  })(input.chunks);
+  let count = 0;
+  let total = 0;
+  for (; ; ) {
+    if (input.window.abort?.() === true) return { chunks: count, bytes: total, aborted: true, reason: "The reviewed abort flag stopped the stream." };
+    const chunk = await pull();
+    if (chunk === void 0) return { chunks: count, bytes: total, aborted: false };
+    const next = total + chunk.length;
+    if (input.window.budget !== void 0 && next > input.window.budget) return { chunks: count, bytes: total, aborted: true, reason: `The stream aborted at ${next} bytes past the reviewed byte budget of ${input.window.budget}.` };
+    total = next;
+    count += 1;
+    input.window.onchunk?.(chunk, total);
+  }
+}
+function pathstep(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 coerce(value, kind, fallback) {
+  if (value === void 0 || value === null) return { value: fallback, missing: true };
+  if (kind === "text") return { value: String(value), missing: false };
+  if (kind === "number") {
+    const numeric = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(numeric) ? { value: numeric, missing: false } : { value: fallback, missing: true };
+  }
+  if (kind === "boolean") return { value: value === true || value === "true", missing: false };
+  return { value, missing: false };
+}
+function readpath(parsed, rules) {
+  const fields = [];
+  for (const rule of rules) {
+    const kind = rule.kind ?? "text";
+    let current = parsed;
+    let missing = false;
+    for (const segment of rule.path.split(".")) {
+      const next = pathstep(current, segment);
+      if (next === void 0) {
+        missing = true;
+        break;
+      }
+      current = next;
+    }
+    if (missing) fields.push({ name: rule.name, path: rule.path, kind, ...rule.default !== void 0 ? { value: rule.default } : {}, missing: true });
+    else {
+      const resolved = coerce(current, kind, rule.default);
+      fields.push({ name: rule.name, path: rule.path, kind, ...resolved.value !== void 0 ? { value: resolved.value } : {}, ...resolved.missing ? { missing: true } : {} });
+    }
+  }
+  return fields;
+}
+function defaultparse() {
+  const parser = globalThis.DOMParser;
+  if (!parser) throw new Error("parsehtml needs a domparser seam outside the page context.");
+  return (markup) => {
+    const document = new parser().parseFromString(markup, "text/html");
+    return { query: (selector) => Array.from(document.querySelectorAll(selector)).map((element) => ({ text: element.textContent ?? "", attributes: Object.fromEntries(Array.from(element.attributes).map((attribute) => [attribute.name, attribute.value])) })) };
+  };
+}
+function parsehtmlbody(input) {
+  const parse = input.parse ?? defaultparse();
+  const document = parse(input.body);
+  return input.queries.map((query) => {
+    const matches = document.query(query.selector);
+    const chosen = query.multi === true ? matches : matches.slice(0, 1);
+    const values = chosen.map((match) => query.attribute !== void 0 ? match.attributes[query.attribute] ?? "" : match.text);
+    return { selector: query.selector, ...query.attribute !== void 0 ? { attribute: query.attribute } : {}, multi: query.multi === true, count: matches.length, values };
+  });
+}
+function payloadvalid(payload, schema) {
+  if (!schema) return { ok: false, errors: ["The typed endpoint call needs a reviewed payload schema before it runs."] };
+  const errors = [];
+  for (const field of schema.fields) {
+    const value = payload[field.name];
+    if (value === void 0 || value === null) {
+      if (field.required === true) errors.push(`The required field ${field.name} of kind ${field.kind} is missing.`);
+      continue;
+    }
+    if (field.kind === "string" && typeof value !== "string") errors.push(`The field ${field.name} must be a string.`);
+    if (field.kind === "number" && (typeof value !== "number" || !Number.isFinite(value))) errors.push(`The field ${field.name} must be a finite number.`);
+    if (field.kind === "boolean" && typeof value !== "boolean") errors.push(`The field ${field.name} must be a boolean.`);
+  }
+  return { ok: errors.length === 0, errors };
+}
+function payloadwithdefaults(payload, schema) {
+  if (!schema) return payload;
+  const merged = { ...payload };
+  for (const field of schema.fields) {
+    if (merged[field.name] === void 0 && field.default !== void 0) merged[field.name] = field.default;
+  }
+  return merged;
+}
+function errorsof(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [body];
+    const record2 = parsed;
+    for (const key of ["errors", "messages", "error", "message"]) {
+      const value = record2[key];
+      if (Array.isArray(value)) return value.map((item) => typeof item === "string" ? item : item && typeof item === "object" && typeof item.message === "string" ? item.message : String(item));
+      if (typeof value === "string") return [value];
+    }
+    return [body];
+  } catch {
+    return [body];
+  }
+}
+async function callrest(input) {
+  const check = payloadvalid(input.payload, input.endpoint.schema);
+  if (!check.ok) throw new Error(check.errors.join(" "));
+  const payload = payloadwithdefaults(input.payload, input.endpoint.schema);
+  const url = templateurl(input.endpoint.url, payload);
+  const method = input.endpoint.method.toUpperCase();
+  const request = { url, method, ...input.endpoint.headers !== void 0 ? { headers: input.endpoint.headers } : {}, ...bodilessmethods.has(method) ? {} : { body: JSON.stringify(payload) } };
+  const transport = await sendfetch({ request, ...input.options !== void 0 ? { options: input.options } : {}, transport: input.transport, ...input.sleep !== void 0 ? { sleep: input.sleep } : {}, ...input.onretry !== void 0 ? { onretry: input.onretry } : {}, ...input.now !== void 0 ? { now: input.now } : {} });
+  const ok = input.success !== void 0 ? input.success.includes(transport.status) : transport.statusclass === "success";
+  return { transport, url, payload, ok, errors: ok ? [] : errorsof(transport.body) };
+}
+function graphqlopenvelope(request) {
+  return JSON.stringify({ query: request.query, ...request.variables !== void 0 ? { variables: request.variables } : {}, ...request.operationname !== void 0 ? { operationName: request.operationname } : {} });
+}
+function unwrapgraphql(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { errors: ["The graphql response is not a json object."] };
+  const record2 = value;
+  const errors = Array.isArray(record2.errors) ? record2.errors.map((item) => typeof item === "string" ? item : item && typeof item === "object" && typeof item.message === "string" ? item.message : String(item)) : [];
+  return { ...record2.data !== void 0 ? { data: record2.data } : {}, errors };
+}
+async function callgraphql(input) {
+  const request = { url: input.endpoint.url, method: "POST", ...input.endpoint.headers !== void 0 ? { headers: input.endpoint.headers } : {}, body: graphqlopenvelope(input.request) };
+  const transport = await sendfetch({ request, ...input.options !== void 0 ? { options: input.options } : {}, transport: input.transport, ...input.sleep !== void 0 ? { sleep: input.sleep } : {}, ...input.onretry !== void 0 ? { onretry: input.onretry } : {}, ...input.now !== void 0 ? { now: input.now } : {} });
+  try {
+    const unwrapped = unwrapgraphql(JSON.parse(transport.body));
+    return { transport, ...unwrapped.data !== void 0 ? { data: unwrapped.data } : {}, errors: unwrapped.errors };
+  } catch {
+    return { transport, errors: [transport.body] };
+  }
+}
+
 // media.ts
 var mediakinds = ["capturepdf", "recordscreen", "captureaudio", "captureframe", "downloadimages", "shotcanvas", "probestream", "readmedia", "readassets", "timelapse", "convertimage", "makethumbs"];
 var defaultpaperwidth = 8.5;
@@ -1313,6 +1599,79 @@ var sessionmemory = class {
   async getrecordingconsents() {
     return await this.adapter.get("recordingconsents") ?? [];
   }
+  /** Stores one outbound call record with its transport facts and body, replacing the previous record of that id; the user configured call retention window expires the oldest bodies while the metadata always survives. */
+  async addcall(record2) {
+    const records = await this.getcalls();
+    const retention = (await this.getsettings())?.callretention;
+    const combined = [record2, ...records.filter((item) => item.id !== record2.id)];
+    const stored = retention === void 0 ? combined : combined.map((item, index) => index < retention ? item : expirecallbody(item));
+    await this.adapter.set("calls", stored);
+  }
+  /** Returns every stored outbound call record, newest first. */
+  async getcalls() {
+    return await this.adapter.get("calls") ?? [];
+  }
+  /** Returns one outbound call record with its body by its id. */
+  async getcall(id) {
+    return (await this.getcalls()).find((item) => item.id === id);
+  }
+  /** Returns the outbound call records filtered by run and origin; an absent filter returns every call. */
+  async listcalls(filter) {
+    const records = await this.getcalls();
+    return records.filter((item) => (filter.runid === void 0 || item.runid === filter.runid) && (filter.origin === void 0 || item.origin === filter.origin));
+  }
+  /** Stores one typed endpoint definition version, appending to the version history of that endpoint name. */
+  async setendpoint(record2) {
+    const records = await this.adapter.get("endpoints") ?? [];
+    const prior = records.filter((item) => item.name === record2.name);
+    const version = prior.length > 0 ? Math.max(...prior.map((item) => item.version)) + 1 : 1;
+    await this.adapter.set("endpoints", [{ ...record2, version, at: record2.at }, ...records]);
+  }
+  /** Returns the newest endpointrecord definition of one name with its payload schema and version. */
+  async getendpoint(name) {
+    const records = await this.adapter.get("endpoints") ?? [];
+    return records.find((item) => item.name === name);
+  }
+  /** Returns the newest definition of every typed endpoint name with its schema and version history. */
+  async getendpoints() {
+    const records = await this.adapter.get("endpoints") ?? [];
+    const latest = /* @__PURE__ */ new Map();
+    for (const record2 of records) if (!latest.has(record2.name)) latest.set(record2.name, record2);
+    return [...latest.values()];
+  }
+  /** Stores one fetch consent decision per origin with its reviewed header names and values and its expiry window. */
+  async setfetchconsent(consent) {
+    const records = (await this.adapter.get("fetchconsents") ?? []).filter((item) => item.id !== consent.id);
+    await this.adapter.set("fetchconsents", [consent, ...records]);
+  }
+  /** Returns every fetch consent decision with its origin, header names and expiry window, newest first. */
+  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]);
+  }
+  /** Returns every stored api key reference with its origin scope, header name and storage id; key material never loads here. */
+  async getapikeys() {
+    return await this.adapter.get("apikeys") ?? [];
+  }
+  /** Removes one api key reference and its stored secret together. */
+  async removeapikey(name) {
+    const records = await this.getapikeys();
+    const ref = records.find((item) => item.name === name);
+    if (ref) await this.adapter.set(ref.storageid, void 0);
+    await this.adapter.set("apikeys", records.filter((item) => item.name !== name));
+  }
+  /** Stores one api key secret under its storage id; the value never appears in reports, outcomes or the audit trail. */
+  async setsecret(storageid, value) {
+    return this.adapter.set(storageid, value);
+  }
+  /** Loads one api key secret under its storage id for the executor only. */
+  async getsecret(storageid) {
+    return this.adapter.get(storageid);
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -1342,14 +1701,19 @@ function expirecapturebytes(record2) {
   void bytes;
   return { ...metadata, bytesexpired: true };
 }
+function expirecallbody(record2) {
+  const { body, ...metadata } = record2;
+  void body;
+  return { ...metadata, bodyexpired: true };
+}
 function randomid() {
   return crypto.randomUUID();
 }
 
 // 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"]);
+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"]);
+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 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"]);
@@ -1361,6 +1725,8 @@ var exportactions = /* @__PURE__ */ new Set(["exportcsv", "exportjson", "exporte
 var filesactions = /* @__PURE__ */ new Set(["batchdownload", "pausedownload", "resumedownload", "verifydownload", "interceptmime", "exportnetlog", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "namecaptures", "cleanupartifacts"]);
 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 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"]);
 var groupcolors = ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"];
@@ -2065,6 +2431,171 @@ function validatetabsgrammar(step, options) {
 function ismediakind(kind) {
   return mediaactions.has(kind);
 }
+function ishttpkind(kind) {
+  return httpactions.has(kind);
+}
+function origincheck(session, url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return { allowed: false, reason: "The outbound request needs a valid url before it can be reviewed." };
+  }
+  if (parsed.protocol !== "https:") return { allowed: false, reason: "Outbound requests use HTTPS urls only." };
+  if (parsed.username || parsed.password) return { allowed: false, reason: "Endpoint credentials are not allowed in the url." };
+  if (!origingranted(session, parsed.origin)) return { allowed: false, reason: `The outbound request to ${parsed.origin} stays outside the session origin grants.` };
+  return { allowed: true };
+}
+function credentialheadername(name) {
+  return credentialheaders.has(name.trim().toLowerCase());
+}
+function fetchconsentrefgranted(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const request = options.fetch;
+  const headers = request && typeof request === "object" && !Array.isArray(request) ? request.headers : void 0;
+  const names = headers && typeof headers === "object" && !Array.isArray(headers) ? Object.keys(headers) : [];
+  if (names.length === 0) return { allowed: true };
+  const empty = names.some((name) => !name.trim());
+  if (empty) return { allowed: false, reason: "Header allowlists with empty names are refused." };
+  const credential = names.find((name) => credentialheadername(name));
+  if (credential !== void 0 && !isnonempty(options.consentref)) return { allowed: false, reason: `The credential bearing header ${credential} needs the explicit reviewed consent that names it before it is sent.` };
+  if (!isnonempty(options.consentref)) return { allowed: false, reason: `The ${names.length} reviewed custom header${names.length === 1 ? "" : "s"} need a reviewed consent ref in options before any send.` };
+  return { allowed: true };
+}
+function fetchbudgetallowed(timeout, retries, backoff, wait) {
+  for (const [label, value] of [["timeout", timeout], ["retries", retries], ["backoff", backoff]]) {
+    if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value) || value < 0)) return { allowed: false, reason: `The reviewed fetch ${label} must be zero or a positive number with no code ceiling.` };
+  }
+  if (wait !== void 0 && (typeof wait !== "number" || !Number.isFinite(wait) || wait < 0)) return { allowed: false, reason: "The reviewed fetch wait budget must be zero or a positive number of milliseconds." };
+  if (wait === void 0 || timeout === void 0) return { allowed: true };
+  const attempts = Math.max(1, Math.floor(retries ?? 0) + 1);
+  const waits = (backoff ?? 0) * (attempts * (attempts - 1)) / 2;
+  const worstcase = timeout * attempts + waits;
+  if (worstcase > wait) return { allowed: false, reason: `The fetch worst case of ${worstcase} milliseconds exceeds the reviewed wait budget of ${wait} milliseconds; review a wider budget or fewer retries.` };
+  return { allowed: true };
+}
+function outboundtarget(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const request = options.fetch;
+  if (request && typeof request === "object" && !Array.isArray(request)) {
+    const url = request.url;
+    if (typeof url === "string" && url.trim()) return url.trim();
+  }
+  return void 0;
+}
+function validpath(path) {
+  return path.split(".").every((segment) => /^[A-Za-z0-9_-]+$/.test(segment));
+}
+function validatehttpgrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "fetchurl") {
+    const request = options.fetch;
+    if (!request || typeof request !== "object" || Array.isArray(request)) return { allowed: false, reason: "A reviewed fetch request with a url is required in options.fetch." };
+    const fetchrequest = request;
+    if (typeof fetchrequest.url !== "string" || !fetchrequest.url.trim()) return { allowed: false, reason: "The reviewed fetch request needs a non-empty url." };
+    if (fetchrequest.method !== void 0 && (typeof fetchrequest.method !== "string" || !["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"].includes(fetchrequest.method.trim().toUpperCase()))) return { allowed: false, reason: "The reviewed fetch method must be a known HTTP verb." };
+    if (fetchrequest.headers !== void 0) {
+      if (!fetchrequest.headers || typeof fetchrequest.headers !== "object" || Array.isArray(fetchrequest.headers)) return { allowed: false, reason: "The reviewed header allowlist must be an object of custom headers." };
+      for (const name of Object.keys(fetchrequest.headers)) {
+        if (!name.trim()) return { allowed: false, reason: "Header allowlists with empty names are refused." };
+        if (typeof fetchrequest.headers[name] !== "string") return { allowed: false, reason: `The reviewed header ${name} needs a string value.` };
+      }
+    }
+    if (fetchrequest.body !== void 0 && typeof fetchrequest.body !== "string") return { allowed: false, reason: "The reviewed fetch body must be a string." };
+    if (fetchrequest.mode !== void 0 && fetchrequest.mode !== "cors" && fetchrequest.mode !== "no-cors" && fetchrequest.mode !== "same-origin") return { allowed: false, reason: "The reviewed fetch mode must be cors, no-cors or same-origin." };
+    const consentgate = fetchconsentrefgranted(step);
+    if (!consentgate.allowed) return consentgate;
+    const policycheck = validatefetchoptions(options.fetchoptions);
+    if (!policycheck.allowed) return policycheck;
+    const fetchpolicy = fetchoptionsvalues(options.fetchoptions);
+    const budget = fetchbudgetallowed(fetchpolicy.timeout, fetchpolicy.retries, fetchpolicy.backoff, fetchnumeric(options, "wait"));
+    if (!budget.allowed) return budget;
+    if (options.stream !== void 0) {
+      if (!options.stream || typeof options.stream !== "object" || Array.isArray(options.stream)) return { allowed: false, reason: "The reviewed stream window must be an object with an optional byte budget." };
+      const streambudget = options.stream.budget;
+      if (streambudget !== void 0 && (typeof streambudget !== "number" || !Number.isFinite(streambudget) || streambudget < 0)) return { allowed: false, reason: "The reviewed stream byte budget must be zero or a positive number of bytes with no code ceiling." };
+    }
+  }
+  if (kind === "parsejson") {
+    if (!isnonempty(options.call)) return { allowed: false, reason: "A reviewed stored call id is required in options.call before the body parses." };
+    const fields = options.fields;
+    if (!Array.isArray(fields) || fields.length === 0) return { allowed: false, reason: "A reviewed non-empty list of json path rules is required in options.fields." };
+    for (const item of fields) {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return { allowed: false, reason: "Every json path rule must be an object." };
+      const rule = item;
+      if (!isnonempty(rule.name)) return { allowed: false, reason: "Every json path rule needs a non-empty field name." };
+      if (typeof rule.path !== "string" || !rule.path.trim() || !validpath(rule.path.trim())) return { allowed: false, reason: `The json path of ${rule.name} must be a dotted path of non-empty segments.` };
+      if (rule.kind !== void 0 && rule.kind !== "text" && rule.kind !== "number" && rule.kind !== "boolean" && rule.kind !== "json") return { allowed: false, reason: `The json path kind of ${rule.name} must be text, number, boolean or json.` };
+    }
+  }
+  if (kind === "parsehtml") {
+    if (!isnonempty(options.call)) return { allowed: false, reason: "A reviewed stored call id is required in options.call before the markup parses." };
+    const queries = options.queries;
+    if (!Array.isArray(queries) || queries.length === 0) return { allowed: false, reason: "A reviewed non-empty list of html queries is required in options.queries." };
+    for (const item of queries) {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return { allowed: false, reason: "Every html query must be an object." };
+      const query = item;
+      if (!isnonempty(query.selector)) return { allowed: false, reason: "Every html query needs a selector from the reviewed selector grammar." };
+      if (query.attribute !== void 0 && !isnonempty(query.attribute)) return { allowed: false, reason: "The reviewed html query attribute must be a non-empty attribute name." };
+      if (query.multi !== void 0 && typeof query.multi !== "boolean") return { allowed: false, reason: "The reviewed html query multi flag must be a boolean." };
+    }
+  }
+  if (kind === "callrest" || kind === "callgraphql") {
+    if (!isnonempty(options.endpoint)) return { allowed: false, reason: "A reviewed typed endpoint name is required in options.endpoint." };
+    if (kind === "callrest") {
+      if (options.payload !== void 0 && (!options.payload || typeof options.payload !== "object" || Array.isArray(options.payload))) return { allowed: false, reason: "The reviewed rest payload must be an object of reviewed values." };
+      if (options.method !== void 0 && (typeof options.method !== "string" || !["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"].includes(options.method.trim().toUpperCase()))) return { allowed: false, reason: "The reviewed endpoint method override must be a known HTTP verb." };
+      if (options.success !== void 0 && (!Array.isArray(options.success) || !options.success.every((code) => typeof code === "number" && Number.isInteger(code)))) return { allowed: false, reason: "The reviewed success status list must be a list of integer status codes." };
+    }
+    if (kind === "callgraphql") {
+      const request = options.graphql;
+      if (!request || typeof request !== "object" || Array.isArray(request)) return { allowed: false, reason: "A reviewed graphql request with an operation is required in options.graphql." };
+      const graphql = request;
+      if (typeof graphql.query !== "string" || !graphql.query.trim()) return { allowed: false, reason: "The reviewed graphql operation text must be a non-empty string." };
+      if (graphql.operationkind !== "query" && graphql.operationkind !== "mutation") return { allowed: false, reason: "The reviewed graphql operation kind must be query or mutation; unknown operation kinds are refused." };
+      if (graphql.variables !== void 0 && (!graphql.variables || typeof graphql.variables !== "object" || Array.isArray(graphql.variables))) return { allowed: false, reason: "The reviewed graphql variables must be an object of reviewed values." };
+      if (graphql.operationname !== void 0 && !isnonempty(graphql.operationname)) return { allowed: false, reason: "The reviewed graphql operation name must be a non-empty string." };
+    }
+    if (options.apikeys !== void 0 && (!Array.isArray(options.apikeys) || !options.apikeys.every((name) => isnonempty(name)))) return { allowed: false, reason: "The reviewed api key reference list must be a list of non-empty stored names." };
+    const policycheck = validatefetchoptions(options.fetchoptions);
+    if (!policycheck.allowed) return policycheck;
+    const fetchpolicy = fetchoptionsvalues(options.fetchoptions);
+    const budget = fetchbudgetallowed(fetchpolicy.timeout, fetchpolicy.retries, fetchpolicy.backoff, fetchnumeric(options, "wait"));
+    if (!budget.allowed) return budget;
+  }
+  return { allowed: true };
+}
+function validatefetchoptions(value) {
+  if (value === void 0) return { allowed: true };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "The reviewed fetch options must be an object with timeout, retries, backoff and follow." };
+  const options = value;
+  for (const key of ["timeout", "backoff"]) {
+    if (options[key] !== void 0 && (typeof options[key] !== "number" || !Number.isFinite(options[key]) || options[key] < 0)) return { allowed: false, reason: `The reviewed fetch ${key} must be zero or a positive number with no code ceiling.` };
+  }
+  for (const key of ["retries", "follow"]) {
+    if (options[key] !== void 0 && (typeof options[key] !== "number" || !Number.isInteger(options[key]) || options[key] < 0)) return { allowed: false, reason: `The reviewed fetch ${key} must be zero or a positive integer with no code ceiling.` };
+  }
+  return { allowed: true };
+}
+function fetchoptionsvalues(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const options = value;
+  return { timeout: fetchnumeric(options, "timeout"), retries: fetchnumeric(options, "retries"), backoff: fetchnumeric(options, "backoff") };
+}
+function fetchnumeric(options, key) {
+  const value = options[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
 function isrecordingkind(kind) {
   return kind === "recordscreen" || kind === "captureaudio";
 }
@@ -2421,6 +2952,10 @@ function validatestep(step, origin) {
     const mediacheck = validatemediagrammar(step, options);
     if (!mediacheck.allowed) return mediacheck;
   }
+  if (ishttpkind(step.kind)) {
+    const httpcheck = validatehttpgrammar(step, options);
+    if (!httpcheck.allowed) return httpcheck;
+  }
   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." };
@@ -2500,6 +3035,17 @@ function canexecute(input) {
     const recordinggate = recordingconsentgranted(input.step);
     if (!recordinggate.allowed) return recordinggate;
   }
+  if (ishttpkind(input.step.kind)) {
+    const target = outboundtarget(input.step);
+    if (target !== void 0) {
+      const outboundgate = origincheck(input.session, target);
+      if (!outboundgate.allowed) return outboundgate;
+    }
+    if (input.step.kind === "fetchurl" || input.step.kind === "callrest" || input.step.kind === "callgraphql") {
+      const consentgate = fetchconsentrefgranted(input.step);
+      if (!consentgate.allowed) return consentgate;
+    }
+  }
   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 {
@@ -2521,7 +3067,7 @@ function canexecute(input) {
 }
 
 // version.ts
-var packageversion = "1.1.41";
+var packageversion = "1.1.42";
 
 // types.ts
 var protocolversion = packageversion;
@@ -2535,9 +3081,10 @@ function text(value, field) {
   if (typeof value !== "string" || !value.trim()) throw new Error(`${field} must be a non-empty string.`);
   return value.trim();
 }
-function parseproposal(value, origin) {
+function parseproposal(value, origin, grants) {
   const root = record(value);
   if (root.version !== protocolversion) throw new Error("Unsupported protocol version.");
+  const covered = grants !== void 0 && grants.length > 0 ? grants : [origin];
   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.");
@@ -2555,6 +3102,17 @@ function parseproposal(value, origin) {
     };
     const evaluation = validatestep(step, origin);
     if (!evaluation.allowed) throw new Error(evaluation.reason);
+    const target = outboundtarget(step);
+    if (target !== void 0) {
+      const granted = covered.some((pattern) => {
+        try {
+          return new URL(target).origin === new URL(pattern).origin;
+        } catch {
+          return false;
+        }
+      });
+      if (!granted) throw new Error(`The fetch request to ${target} targets an origin outside the grants.`);
+    }
     return step;
   });
   for (const step of steps) {
@@ -2585,7 +3143,7 @@ function requestbody(input) {
   return JSON.stringify({ version: protocolversion, objective: input.objective, session: input.session, observation: input.observation, capabilities: input.capabilities });
 }
 function outcomeresponse(input) {
-  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {}, ...input.capture ? { capture: input.capture } : {}, ...input.media ? { media: input.media } : {} });
+  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 } : {} });
 }
 function mapresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
@@ -2668,6 +3226,14 @@ function capturereport(input) {
 function mediareport(input) {
   return { version: protocolversion, records: input.records, images: input.images };
 }
+function callsreport(input) {
+  const calls = input.calls.map((call) => {
+    const { body, ...metadata } = call;
+    void body;
+    return metadata;
+  });
+  return { version: protocolversion, calls };
+}
 export {
   annotationplanof,
   assetentries,
@@ -2676,6 +3242,9 @@ export {
   buildpdf,
   buildsheet,
   buildstitchplan,
+  callgraphql,
+  callrest,
+  callsreport,
   canexecute,
   captureelement,
   captureformats,
@@ -2698,18 +3267,25 @@ export {
   errorreportresponse,
   eventresponse,
   extractionreport,
+  fetchoptionsof,
+  fetchrequestof,
   finishrecording,
   fixedheadermatch,
   formreportresponse,
   frameinterval,
   generatedvalueallowed,
+  graphqlopenvelope,
+  graphqlrequestof,
   heldkeysreport,
   hostpattern,
+  htmlqueriesof,
+  httpkinds,
   imagefilterof,
   imagematches,
   imagenames,
   isformkind,
   iswatchkind,
+  jsonpathrulesof,
   lapseframes,
   lapseplanof,
   layoutreport,
@@ -2725,8 +3301,11 @@ export {
   observationresponse,
   outcomeresponse,
   pairstates,
+  parsehtmlbody,
   parseproposal,
   passwordconsentgranted,
+  payloadvalid,
+  payloadwithdefaults,
   pdfoptionsof,
   pdfpagesize,
   pdfsegments,
@@ -2736,6 +3315,8 @@ export {
   provenancereport,
   quarantinereport,
   randomid,
+  readpath,
+  readstream,
   recordingoptionsof,
   regionsteps,
   requestbody,
@@ -2744,15 +3325,20 @@ export {
   scaledrect,
   seamweights,
   selectorresponse,
+  sendfetch,
   sessionmemory,
   signalsreport,
+  statusclassof,
   streamsummaries,
+  streamwindowof,
   submitreviewgranted,
   tabreportresponse,
+  templateurl,
   thumbdirectiveof,
   thumbgeometry,
   trailreport,
   transformgrammar,
+  unwrapgraphql,
   validatefieldmatch,
   validateformrecord,
   validatestep,