@wenathlan/extension 1.1.38 → 1.1.40

package/dist/index.js

@@ -1,3 +1,201 @@
+// capture.ts
+var captureformats = ["png", "jpeg", "webp"];
+var capturetargets = ["memory", "download", "clipboard"];
+var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
+function captureoptionsof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const options = value;
+  const normalized = {};
+  if (options.format === "png" || options.format === "jpeg" || options.format === "webp") normalized.format = options.format;
+  if (typeof options.quality === "number" && Number.isFinite(options.quality)) normalized.quality = options.quality;
+  if (typeof options.pixelratio === "number" && Number.isFinite(options.pixelratio)) normalized.pixelratio = options.pixelratio;
+  if (typeof options.annotate === "boolean") normalized.annotate = options.annotate;
+  if (options.exporttarget === "memory" || options.exporttarget === "download" || options.exporttarget === "clipboard") normalized.exporttarget = options.exporttarget;
+  return normalized;
+}
+function capturevisible(input) {
+  const ratio = input.options.pixelratio ?? 1;
+  return {
+    id: input.id,
+    runid: input.runid,
+    stepid: input.stepid,
+    kind: "shotview",
+    format: input.options.format ?? "png",
+    width: Math.round(input.viewport.width * ratio),
+    height: Math.round(input.viewport.height * ratio),
+    capturedat: input.at,
+    bytes: input.dataurl,
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.options.annotate === true ? { annotated: true } : {},
+    ...input.options.exporttarget !== void 0 ? { exporttarget: input.options.exporttarget } : {},
+    ...input.target !== void 0 ? { target: input.target } : {}
+  };
+}
+function capturestitched(input) {
+  const ratio = input.options.pixelratio ?? 1;
+  return {
+    id: input.id,
+    runid: input.runid,
+    stepid: input.stepid,
+    kind: "shotfullpage",
+    format: input.options.format ?? "png",
+    width: Math.round(input.plan.scrollwidth * ratio),
+    height: Math.round(input.plan.scrollheight * ratio),
+    capturedat: input.at,
+    bytes: input.dataurl,
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.options.annotate === true ? { annotated: true } : {},
+    ...input.options.exporttarget !== void 0 ? { exporttarget: input.options.exporttarget } : {}
+  };
+}
+function captureelement(input) {
+  const ratio = input.options.pixelratio ?? 1;
+  const scaled = scaledrect(input.rect, ratio);
+  return {
+    id: input.id,
+    runid: input.runid,
+    stepid: input.stepid,
+    kind: "shotelement",
+    format: input.options.format ?? "png",
+    width: scaled.width,
+    height: scaled.height,
+    capturedat: input.at,
+    bytes: input.dataurl,
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.options.annotate === true ? { annotated: true } : {},
+    ...input.options.exporttarget !== void 0 ? { exporttarget: input.options.exporttarget } : {},
+    ...input.target !== void 0 ? { target: input.target } : {}
+  };
+}
+function captureregion(input) {
+  const ratio = input.options.pixelratio ?? 1;
+  const scaled = scaledrect(input.rect, ratio);
+  return {
+    id: input.id,
+    runid: input.runid,
+    stepid: input.stepid,
+    kind: "shotregion",
+    format: input.options.format ?? "png",
+    width: scaled.width,
+    height: scaled.height,
+    capturedat: input.at,
+    bytes: input.dataurl,
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.options.annotate === true ? { annotated: true } : {},
+    ...input.options.exporttarget !== void 0 ? { exporttarget: input.options.exporttarget } : {},
+    ...input.target !== void 0 ? { target: input.target } : {}
+  };
+}
+function pairstates(before, after, action, at, id) {
+  if (!before) return { skipped: "before", reason: "The before shot was not captured, so no state pair exists." };
+  if (!after) return { skipped: "after", reason: `The action of kind ${action.kind} failed before the after shot, so the state pair is skipped.` };
+  return {
+    pair: {
+      id,
+      beforeid: before.id,
+      afterid: after.id,
+      actionkind: action.kind,
+      ...action.target !== void 0 ? { target: action.target } : {},
+      ...action.domsnapshotid !== void 0 ? { domsnapshotid: action.domsnapshotid } : {},
+      at
+    },
+    reason: `Paired the before shot ${before.id} with the after shot ${after.id} around the ${action.kind} action.`
+  };
+}
+function capturestates(input) {
+  if (input.policy !== "beforeafter") return { reason: `The ${input.policy} capture policy takes no state pair around the ${input.actionkind} action.` };
+  return pairstates(input.before, input.after, { kind: input.actionkind, ...input.target !== void 0 ? { target: input.target } : {}, ...input.domsnapshotid !== void 0 ? { domsnapshotid: input.domsnapshotid } : {} }, input.at, input.id);
+}
+function buildstitchplan(input) {
+  const overlap = Math.max(0, Math.round(input.overlap ?? 0));
+  const stepy = Math.max(1, input.viewportheight - overlap);
+  const columns = Math.max(1, Math.ceil(input.scrollwidth / input.viewportwidth));
+  const rows = input.scrollheight <= input.viewportheight ? 1 : Math.max(1, Math.ceil((input.scrollheight - overlap) / stepy));
+  const tiles = [];
+  for (let column = 0; column < columns; column += 1) {
+    for (let row = 0; row < rows; row += 1) {
+      const x = Math.min(column * input.viewportwidth, Math.max(0, input.scrollwidth - input.viewportwidth));
+      const y = rows === 1 ? 0 : Math.min(row * stepy, Math.max(0, input.scrollheight - input.viewportheight));
+      tiles.push({ x: Math.round(x), y: Math.round(y) });
+    }
+  }
+  return { columns, rows, tiles, overlap, scrollwidth: Math.round(input.scrollwidth), scrollheight: Math.round(input.scrollheight), viewportwidth: Math.round(input.viewportwidth), viewportheight: Math.round(input.viewportheight) };
+}
+function seamweights(overlap) {
+  if (overlap <= 0) return [];
+  const weights = [];
+  for (let index = 0; index < overlap; index += 1) weights.push((index + 1) / (overlap + 1));
+  return weights;
+}
+function blendrows(upper, lower) {
+  const weights = seamweights(upper.length);
+  return upper.map((value, index) => {
+    const weight = weights[index] ?? 1;
+    return value * (1 - weight) + (lower[index] ?? value) * weight;
+  });
+}
+function fixedheadermatch(band, firstband) {
+  if (band.length === 0 || band.length !== firstband.length) return false;
+  return band.every((value, index) => value === firstband[index]);
+}
+function scaledrect(rect, pixelratio) {
+  const ratio = pixelratio >= 1 ? pixelratio : 1;
+  return { x: Math.round(rect.x * ratio), y: Math.round(rect.y * ratio), width: Math.round(rect.width * ratio), height: Math.round(rect.height * ratio) };
+}
+function croprect(rect, viewport) {
+  const x = Math.max(0, rect.x);
+  const y = Math.max(0, rect.y);
+  return { x: Math.round(x), y: Math.round(y), width: Math.round(Math.max(0, Math.min(rect.width, viewport.width - x))), height: Math.round(Math.max(0, Math.min(rect.height, viewport.height - y))) };
+}
+function crossesviewport(rect, viewport) {
+  return rect.x < 0 || rect.y < 0 || rect.x + rect.width > viewport.width || rect.y + rect.height > viewport.height;
+}
+function regionsteps(containerheight, viewportstep) {
+  if (containerheight <= 0 || viewportstep <= 0) return [0];
+  const steps = [];
+  for (let top = 0; top < containerheight; top += viewportstep) {
+    const clamped = Math.min(top, Math.max(0, containerheight - viewportstep));
+    if (!steps.includes(clamped)) steps.push(clamped);
+  }
+  return steps;
+}
+function buildsheet(cells, layout) {
+  const columns = Math.max(1, Math.round(layout.columns));
+  const rows = Math.max(1, Math.ceil(cells.length / columns));
+  const placed = cells.map((cell, index) => {
+    const column = index % columns;
+    const row = Math.floor(index / columns);
+    const label = cell.label ?? "";
+    const caption = layout.label === "none" ? "" : layout.label === "index" ? `${index + 1}` : layout.label === "selector" ? cell.selector : label ? `${index + 1} \xB7 ${cell.selector} \xB7 ${label}` : `${index + 1} \xB7 ${cell.selector}`;
+    return { index, column, row, selector: cell.selector, label, caption };
+  });
+  return { columns, rows, cells: placed };
+}
+function capturepart(value) {
+  return value.replace(/[^a-z0-9-]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase() || "capture";
+}
+function buildname(rule, parts, extension) {
+  const segments = [];
+  if (rule.run) segments.push(capturepart(parts.run));
+  if (rule.step) segments.push(capturepart(parts.step));
+  if (rule.sequence) segments.push(String(Math.max(0, Math.round(parts.sequence))));
+  if (rule.kind) segments.push(capturepart(parts.kind));
+  const safeextension = extension.replace(/^\.+/, "").toLowerCase() || "png";
+  return `${(segments.length > 0 ? segments : ["capture"]).join("-")}.${safeextension}`;
+}
+function annotationplanof(input) {
+  const inset = Math.min(24, Math.max(8, Math.round(Math.min(input.width, input.height) / 12)));
+  const plan = {
+    marker: { x: inset, y: inset, number: Math.max(1, Math.round(input.step)) },
+    footer: `${new Date(input.at).toISOString()} \xB7 ${input.url}`
+  };
+  if (input.rect !== void 0) {
+    const expansion = 2;
+    plan.outline = { x: Math.round(input.rect.x - expansion), y: Math.round(input.rect.y - expansion), width: Math.round(input.rect.width + expansion * 2), height: Math.round(input.rect.height + expansion * 2) };
+  }
+  return plan;
+}
+
 // memory.ts
 var sessionmemory = class {
   constructor(adapter) {
@@ -619,23 +817,176 @@ var sessionmemory = class {
   async getexports() {
     return await this.adapter.get("exports") ?? [];
   }
+  /** Removes one exported data artifact by id and reports whether it existed. */
+  async removeexport(id) {
+    const records = await this.getexports();
+    const remaining = records.filter((item) => item.id !== id);
+    await this.adapter.set("exports", remaining);
+    return remaining.length !== records.length;
+  }
+  /** Removes one run store artifact by id and reports whether it existed. */
+  async removeartifact(id) {
+    const records = await this.getartifacts();
+    const remaining = records.filter((item) => item.id !== id);
+    await this.adapter.set("artifacts", remaining);
+    return remaining.length !== records.length;
+  }
+  /** Stores one batch download file record with its state, path and checksum, replacing the previous record of that id. */
+  async setdownload(record2) {
+    const records = (await this.adapter.get("downloads") ?? []).filter((item) => item.id !== record2.id);
+    await this.adapter.set("downloads", [record2, ...records]);
+  }
+  /** Returns every batch download file record with its state, path and checksum, newest first. */
+  async getdownloads() {
+    return await this.adapter.get("downloads") ?? [];
+  }
+  /** Records one captured network log record; netlog retention is a user setting and an absent value keeps every record. */
+  async addnetlog(record2) {
+    const records = await this.getnetlog();
+    const combined = [record2, ...records];
+    const retention = (await this.getsettings())?.netlogretention;
+    await this.adapter.set("netlog", retention === void 0 ? combined : combined.slice(0, retention));
+  }
+  /** Returns the captured network log of the run with its step correlation, newest first. */
+  async getnetlog() {
+    return await this.adapter.get("netlog") ?? [];
+  }
+  /** Stores one clipboard consent record with its prompt and origin, replacing the previous record of that id. */
+  async setclipconsent(record2) {
+    const records = (await this.adapter.get("clipconsents") ?? []).filter((item) => item.id !== record2.id);
+    await this.adapter.set("clipconsents", [record2, ...records]);
+  }
+  /** Returns every clipboard consent record with its prompt and origin, newest first. */
+  async getclipconsents() {
+    return await this.adapter.get("clipconsents") ?? [];
+  }
+  /** Records one clipboard entry hash with its origin provenance; the payload text itself never persists. */
+  async addclip(entry) {
+    const records = await this.getclips();
+    await this.adapter.set("clips", [entry, ...records]);
+  }
+  /** Returns every clipboard entry hash with its kind and origin provenance, newest first. */
+  async getclips() {
+    return await this.adapter.get("clips") ?? [];
+  }
+  /** Stores one quarantine entry with its scan verdict, replacing the previous entry of that id. */
+  async setquarantine(entry) {
+    const records = (await this.adapter.get("quarantines") ?? []).filter((item) => item.id !== entry.id);
+    await this.adapter.set("quarantines", [entry, ...records]);
+  }
+  /** Returns every quarantine entry with its scan verdict and release ref, newest first. */
+  async getquarantines() {
+    return await this.adapter.get("quarantines") ?? [];
+  }
+  /** Stores the reviewed cleanup rule set of the run, replacing the previous set. */
+  async setcleanuprules(rules) {
+    return this.adapter.set("cleanuprules", rules);
+  }
+  /** Returns the reviewed cleanup rule set of the run. */
+  async getcleanuprules() {
+    return await this.adapter.get("cleanuprules") ?? [];
+  }
+  /** Records one cleanup run in the run history. */
+  async addcleanuprun(run) {
+    const records = await this.getcleanupruns();
+    await this.adapter.set("cleanupruns", [run, ...records]);
+  }
+  /** Returns every cleanup run history record with removed and kept counts, newest first. */
+  async getcleanupruns() {
+    return await this.adapter.get("cleanupruns") ?? [];
+  }
+  /** Stores the capture naming counters of one task, replacing the previous counters of that task. */
+  async setcapturecounter(counter) {
+    const records = (await this.adapter.get("capturecounters") ?? []).filter((item) => item.taskid !== counter.taskid);
+    await this.adapter.set("capturecounters", [counter, ...records]);
+  }
+  /** Returns every stored capture naming counter per task, newest first. */
+  async getcapturecounters() {
+    return await this.adapter.get("capturecounters") ?? [];
+  }
+  /** Replaces the artifact inventory the cleanup sweeper plans against. */
+  async setinventory(entries) {
+    return this.adapter.set("inventory", entries);
+  }
+  /** Returns the artifact inventory with sizes and ages for the cleanup sweeper. */
+  async getinventory() {
+    return await this.adapter.get("inventory") ?? [];
+  }
+  /** Stores one user configured virus scanning hook, replacing the previous hook of that scanner name. */
+  async setscanhook(config) {
+    const records = (await this.adapter.get("scanhooks") ?? []).filter((item) => item.scanner !== config.scanner);
+    await this.adapter.set("scanhooks", [config, ...records]);
+  }
+  /** Returns every configured virus scanning hook, newest first. */
+  async getscanhooks() {
+    return await this.adapter.get("scanhooks") ?? [];
+  }
+  /** Stores the armed mime interception filters of the run, newest first. */
+  async setmimefilters(filters) {
+    return this.adapter.set("mimefilters", filters);
+  }
+  /** Returns the armed mime interception filters of the run, newest first. */
+  async getmimefilters() {
+    return await this.adapter.get("mimefilters") ?? [];
+  }
+  /** Stores one capture record with its bytes and step linkage, replacing the previous record of that id; the user configured capture retention window expires the oldest bytes while the metadata always survives for the audit trail. */
+  async addcapture(record2) {
+    const records = await this.getcaptures();
+    const retention = (await this.getsettings())?.captureretention;
+    const combined = [record2, ...records.filter((item) => item.id !== record2.id)];
+    const stored = retention === void 0 ? combined : combined.map((item, index) => index < retention ? item : expirecapturebytes(item));
+    await this.adapter.set("captures", stored);
+  }
+  /** Returns every stored capture record with its metadata, newest first. */
+  async getcaptures() {
+    return await this.adapter.get("captures") ?? [];
+  }
+  /** Returns one capture record with its bytes by its id. */
+  async getcapture(id) {
+    return (await this.getcaptures()).find((item) => item.id === id);
+  }
+  /** Returns the capture records filtered by run, step and kind. */
+  async listcaptures(filter) {
+    const records = await this.getcaptures();
+    return records.filter((item) => (filter.runid === void 0 || item.runid === filter.runid) && (filter.stepid === void 0 || item.stepid === filter.stepid) && (filter.kind === void 0 || item.kind === filter.kind));
+  }
+  /** Records one before and after shotpair of the run with its action context. */
+  async addpair(pair) {
+    const records = await this.getpairs();
+    await this.adapter.set("capturepairs", [pair, ...records.filter((item) => item.id !== pair.id)]);
+  }
+  /** Returns the shotpairs of one run resolved through their before records, newest first; an absent run returns every pair. */
+  async getpairs(runid) {
+    const records = await this.adapter.get("capturepairs") ?? [];
+    if (runid === void 0) return records;
+    const runs = /* @__PURE__ */ new Map();
+    for (const capture of await this.getcaptures()) runs.set(capture.id, capture.runid);
+    return records.filter((item) => runs.get(item.beforeid) === runid);
+  }
 };
+function expirecapturebytes(record2) {
+  const { bytes, ...metadata } = record2;
+  void bytes;
+  return { ...metadata, bytesexpired: 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"]);
+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"]);
 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"]);
+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"]);
 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"]);
-var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav", "duplicatetab", "pintab", "mutetab", "movetab", "movetabwindow", "searchtabs", "badgetab", "attachmeta", "focuswindow", "maximizewindow", "minimizewindow", "restorewindow", "incognitowindow", "asksubmit", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword"]);
+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"]);
+var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav", "duplicatetab", "pintab", "mutetab", "movetab", "movetabwindow", "searchtabs", "badgetab", "attachmeta", "focuswindow", "maximizewindow", "minimizewindow", "restorewindow", "incognitowindow", "asksubmit", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "pausedownload", "resumedownload", "verifydownload", "writeclipboard", "quarantinedownload", "scanvirus"]);
 var tabscommandactions = /* @__PURE__ */ new Set(["querytabs", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "watchtab", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "savelayout", "restorelayout", "findclones", "searchtabs", "badgetab", "attachmeta", "listaudio", "reopenrun", "snapshotsession"]);
 var formactions = /* @__PURE__ */ new Set(["fillform", "filllabel", "fillplaceholder", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "submitform", "readerrors", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "handoffcaptcha", "fillcard", "fillcode", "consentpassword", "skiphoneypot", "detectlogin", "detecttemplate"]);
 var datasetactions = /* @__PURE__ */ new Set(["scrapetable", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "importcsv", "looprows", "transformvalues", "deduperows", "paginateextract", "mergepages", "stamplerows", "previewgrid", "streamdisk", "resumeextract", "logprovenance"]);
 var exportactions = /* @__PURE__ */ new Set(["exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk"]);
+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 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"];
@@ -689,6 +1040,86 @@ function isdatasetkind(kind) {
 function isexportkind(kind) {
   return exportactions.has(kind);
 }
+function isfileskind(kind) {
+  return filesactions.has(kind);
+}
+function iscapturekind(kind) {
+  return captureactions.has(kind);
+}
+function capturegate(session, tabid, origin, now) {
+  if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the capture." };
+  if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot capture." };
+  if (session.pausedat) return { allowed: false, reason: "The browser session is paused and cannot capture." };
+  if (session.tabid !== tabid) return { allowed: false, reason: `The capture needs the active tab grant of session tab ${session.tabid} and refuses tab ${tabid}.` };
+  if (!origingranted(session, origin)) return { allowed: false, reason: `The capture of ${origin} needs the session origin grants first.` };
+  return { allowed: true };
+}
+function validatecaptureoptions(value) {
+  if (value === void 0) return { allowed: true };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "The reviewed capture options must be an object in options.capture." };
+  const options = value;
+  if (options.format !== void 0 && options.format !== "png" && options.format !== "jpeg" && options.format !== "webp") return { allowed: false, reason: "The reviewed capture format must be png, jpeg or webp." };
+  if (options.quality !== void 0 && (typeof options.quality !== "number" || !Number.isFinite(options.quality) || options.quality < 0 || options.quality > 100)) return { allowed: false, reason: "The reviewed capture quality must stay between zero and one hundred; any value in that range is the user choice with no code cap." };
+  if (options.pixelratio !== void 0 && (typeof options.pixelratio !== "number" || !Number.isFinite(options.pixelratio) || options.pixelratio < 1)) return { allowed: false, reason: "The reviewed pixel ratio starts at one and climbs to any user configured ceiling with no code ceiling." };
+  if (options.annotate !== void 0 && typeof options.annotate !== "boolean") return { allowed: false, reason: "The reviewed capture annotation flag must be a boolean." };
+  if (options.exporttarget !== void 0 && options.exporttarget !== "memory" && options.exporttarget !== "download" && options.exporttarget !== "clipboard") return { allowed: false, reason: "The reviewed capture export target must be memory, download or clipboard." };
+  return { allowed: true };
+}
+function validateregionrect(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed regionrect with x, y, width and height in css pixels is required in options." };
+  const rect = value;
+  for (const field of ["x", "y", "width", "height"]) {
+    if (typeof rect[field] !== "number" || !Number.isFinite(rect[field])) return { allowed: false, reason: `The reviewed regionrect needs a numeric ${field} in css pixels.` };
+  }
+  if (rect.x < 0 || rect.y < 0) return { allowed: false, reason: "The reviewed regionrect refuses negative coordinates." };
+  if (rect.width <= 0 || rect.height <= 0) return { allowed: false, reason: "The reviewed regionrect needs positive width and height values." };
+  return { allowed: true };
+}
+function validatecapturenaming(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed capturenaming rule with run, step, sequence and kind flags is required." };
+  const rule = value;
+  const segments = ["run", "step", "sequence", "kind"];
+  for (const key of Object.keys(rule)) {
+    if (!segments.includes(key)) return { allowed: false, reason: `The reviewed capturenaming rule refuses the unknown ${key} segment; only run, step, sequence and kind participate.` };
+  }
+  for (const segment of segments) {
+    if (rule[segment] !== void 0 && typeof rule[segment] !== "boolean") return { allowed: false, reason: `The reviewed capturenaming ${segment} flag must be a boolean.` };
+  }
+  if (!segments.some((segment) => rule[segment] === true)) return { allowed: false, reason: "The reviewed capturenaming rule needs at least one enabled segment of run, step, sequence and kind." };
+  return { allowed: true };
+}
+function validatecapturegrammar(step, options) {
+  const kind = step.kind;
+  const optioncheck = validatecaptureoptions(options.capture);
+  if (!optioncheck.allowed) return optioncheck;
+  if (options.settle !== void 0 && (typeof options.settle !== "number" || !Number.isFinite(options.settle) || options.settle < 0)) return { allowed: false, reason: "The reviewed capture settle window must be zero or a positive number of milliseconds." };
+  if (options.overlap !== void 0 && (typeof options.overlap !== "number" || !Number.isInteger(options.overlap) || options.overlap < 0)) return { allowed: false, reason: "The reviewed stitch overlap must be zero or a positive number of rows." };
+  if (options.wait !== void 0 && (typeof options.wait !== "number" || !Number.isFinite(options.wait) || options.wait < 0)) return { allowed: false, reason: "The reviewed capture wait window must be zero or a positive number of milliseconds." };
+  if (options.naming !== void 0) {
+    const namingcheck = validatecapturenaming(options.naming);
+    if (!namingcheck.allowed) return namingcheck;
+  }
+  if (kind === "shotregion") {
+    const rectcheck = validateregionrect(options.regionrect);
+    if (!rectcheck.allowed) return rectcheck;
+    if (options.reviewed !== true) return { allowed: false, reason: "Every reviewed regionrect needs the explicit reviewed flag before shotregion runs." };
+    if (options.container !== void 0 && !isnonempty(options.container)) return { allowed: false, reason: "The reviewed scrollable container selector must be a non-empty string." };
+    if (options.steps !== void 0 && (typeof options.steps !== "number" || !Number.isInteger(options.steps) || options.steps < 1)) return { allowed: false, reason: "The reviewed container scroll steps must be a positive integer with no code ceiling." };
+  }
+  if (kind === "contactsheet") {
+    const elements = options.elements;
+    if (!Array.isArray(elements) || elements.length === 0 || !elements.every((item) => isnonempty(item))) return { allowed: false, reason: "A reviewed non-empty list of element selectors is required in options for the contact sheet; the cell count stays the user choice." };
+    const layout = options.sheet;
+    if (layout !== void 0) {
+      if (!layout || typeof layout !== "object" || Array.isArray(layout)) return { allowed: false, reason: "The reviewed sheetlayout must be an object with cellsize, columns and label." };
+      const sheet = layout;
+      if (typeof sheet.cellsize !== "number" || !Number.isFinite(sheet.cellsize) || sheet.cellsize <= 0) return { allowed: false, reason: "The reviewed contact sheet cell size must be a positive number of pixels." };
+      if (typeof sheet.columns !== "number" || !Number.isInteger(sheet.columns) || sheet.columns < 1) return { allowed: false, reason: "The reviewed contact sheet column count must be a positive integer with no code ceiling." };
+      if (sheet.label !== void 0 && sheet.label !== "none" && sheet.label !== "index" && sheet.label !== "selector" && sheet.label !== "both") return { allowed: false, reason: "The reviewed contact sheet label style must be none, index, selector or both." };
+    }
+  }
+  return { allowed: true };
+}
 function exportgranted(session, origin) {
   if (!origingranted(session, origin)) return { allowed: false, reason: `The export of extracted data from ${origin} needs the session origin grants before it leaves local memory.` };
   return { allowed: true };
@@ -873,6 +1304,81 @@ function validatedatagrammar(step, options, origin) {
   if (kind === "logprovenance" && !isnonempty(options.artifact)) return { allowed: false, reason: "A reviewed artifact id or name is required in options." };
   return { allowed: true };
 }
+function validatedownloadspec(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed downloadspec with a url list is required in options." };
+  const spec = value;
+  if (!Array.isArray(spec.urls) || spec.urls.length === 0 || !spec.urls.every((url) => ishttpsurl(url))) return { allowed: false, reason: "The reviewed downloadspec needs a non-empty list of HTTPS urls." };
+  if (spec.filename !== void 0 && !isnonempty(spec.filename)) return { allowed: false, reason: "The reviewed downloadspec filename rule must be a non-empty string." };
+  if (spec.complete !== void 0 && spec.complete !== "size" && spec.complete !== "checksum") return { allowed: false, reason: "The reviewed downloadspec completion criterion must be size or checksum." };
+  return { allowed: true };
+}
+function validatemimefilter(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed mimefilter with include and exclude patterns is required in options." };
+  const filter = value;
+  if (!Array.isArray(filter.include) || filter.include.length === 0 || !filter.include.every((pattern) => isnonempty(pattern))) return { allowed: false, reason: "The reviewed mimefilter needs a non-empty list of include patterns." };
+  if (filter.exclude !== void 0 && (!Array.isArray(filter.exclude) || !filter.exclude.every((pattern) => isnonempty(pattern)))) return { allowed: false, reason: "The reviewed mimefilter exclude patterns must be a list of non-empty strings." };
+  if (filter.default !== "deny" && filter.default !== "allow") return { allowed: false, reason: "The reviewed mimefilter needs the deny or allow default for unlisted mime types." };
+  return { allowed: true };
+}
+function validatecleanuprule(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed cleanuprule with an age, a kind and a keep policy is required." };
+  const rule = value;
+  if (typeof rule.age !== "number" || !Number.isFinite(rule.age) || rule.age <= 0) return { allowed: false, reason: "The reviewed cleanup age window must be a positive number of milliseconds with no code ceiling." };
+  if (!isnonempty(rule.kind)) return { allowed: false, reason: "The reviewed cleanup rule needs a non-empty artifact kind, or any to match every kind." };
+  if (rule.keep !== "none" && rule.keep !== "latest" && rule.keep !== "all") return { allowed: false, reason: "The reviewed cleanup keep policy must be none, latest or all." };
+  return { allowed: true };
+}
+function validatefilesgrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "batchdownload") {
+    const speccheck = validatedownloadspec(options.downloadspec);
+    if (!speccheck.allowed) return speccheck;
+    if (options.concurrent !== void 0 && (typeof options.concurrent !== "number" || !Number.isInteger(options.concurrent) || options.concurrent < 1)) return { allowed: false, reason: "The reviewed concurrent download window must be a positive integer with no code ceiling." };
+  }
+  if (kind === "pausedownload" || kind === "resumedownload" || kind === "verifydownload" || kind === "quarantinedownload" || kind === "scanvirus") {
+    if (!isnonempty(step.value)) return { allowed: false, reason: "A reviewed download or quarantine reference is required." };
+    if (kind === "verifydownload") {
+      if (options.checksum !== void 0 && !isnonempty(options.checksum)) return { allowed: false, reason: "The reviewed expected checksum must be a non-empty string." };
+      if (options.bytes !== void 0 && (typeof options.bytes !== "number" || !Number.isFinite(options.bytes) || options.bytes < 0)) return { allowed: false, reason: "The reviewed expected size must be zero or a positive number of bytes." };
+    }
+    if (kind === "scanvirus" && options.scanner !== void 0 && !isnonempty(options.scanner)) return { allowed: false, reason: "The reviewed scanner name must be a non-empty string." };
+    if (kind === "quarantinedownload" && options.reason !== void 0 && !isnonempty(options.reason)) return { allowed: false, reason: "The reviewed quarantine reason must be a non-empty string." };
+  }
+  if (kind === "interceptmime") {
+    const filtercheck = validatemimefilter(options.mimefilter);
+    if (!filtercheck.allowed) return filtercheck;
+  }
+  if (kind === "readclipboard") {
+    if (!isnonempty(options.consentref)) return { allowed: false, reason: "A clipboard read requires a reviewed consent ref of an approved consent prompt in options." };
+    if (options.prompt !== void 0 && !isnonempty(options.prompt)) return { allowed: false, reason: "The reviewed clipboard consent prompt must be a non-empty string." };
+  }
+  if (kind === "exportnetlog" && options.stepid !== void 0 && !isnonempty(options.stepid)) return { allowed: false, reason: "The reviewed netlog step filter must be a non-empty step id." };
+  if (kind === "namecaptures") {
+    if (!isnonempty(options.task)) return { allowed: false, reason: "A reviewed task id is required in options for capture naming." };
+    if (options.steps !== void 0 && (!Array.isArray(options.steps) || options.steps.length === 0 || !options.steps.every((item) => isnonempty(item)))) return { allowed: false, reason: "The reviewed capture steps must be a non-empty list of step ids when present." };
+    if (options.extension !== void 0 && !isnonempty(options.extension)) return { allowed: false, reason: "The reviewed capture extension must be a non-empty string." };
+  }
+  if (kind === "cleanupartifacts" && options.rules !== void 0) {
+    const rules = options.rules;
+    if (!Array.isArray(rules) || rules.length === 0) return { allowed: false, reason: "The reviewed cleanup rules must be a non-empty list when present." };
+    for (const item of rules) {
+      const rulecheck = validatecleanuprule(item);
+      if (!rulecheck.allowed) return rulecheck;
+    }
+  }
+  return { allowed: true };
+}
+function clipboardconsentgranted(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const consentref = options.consentref;
+  if (typeof consentref !== "string" || !consentref.trim()) return { allowed: false, reason: "A clipboard read requires a reviewed consent ref in options." };
+  return { allowed: true };
+}
 function submitreviewgranted(steps, submitid) {
   const position = steps.findIndex((candidate) => candidate.id === submitid);
   const asked = steps.some((candidate, index) => candidate.kind === "asksubmit" && (position === -1 || index < position));
@@ -1395,6 +1901,14 @@ function validatestep(step, origin) {
     const datacheck = validatedatagrammar(step, options, origin);
     if (!datacheck.allowed) return datacheck;
   }
+  if (isfileskind(step.kind)) {
+    const filescheck = validatefilesgrammar(step, options);
+    if (!filescheck.allowed) return filescheck;
+  }
+  if (iscapturekind(step.kind)) {
+    const capturecheck = validatecapturegrammar(step, options);
+    if (!capturecheck.allowed) return capturecheck;
+  }
   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." };
@@ -1449,6 +1963,23 @@ function canexecute(input) {
     const consentgate = passwordconsentgranted(input.step);
     if (!consentgate.allowed) return consentgate;
   }
+  if (input.step.kind === "readclipboard") {
+    const clipgate = clipboardconsentgranted(input.step);
+    if (!clipgate.allowed) return clipgate;
+  }
+  if (input.step.kind === "interceptmime" && !origingranted(input.session, input.origin)) return { allowed: false, reason: "The download interception is outside the session origin grants." };
+  if (iscapturekind(input.step.kind)) {
+    const capturegatecheck = capturegate(input.session, input.tabid, input.origin, now);
+    if (!capturegatecheck.allowed) return capturegatecheck;
+    let captureoptions = {};
+    try {
+      captureoptions = parseoptions(input.step);
+    } catch {
+      captureoptions = {};
+    }
+    const target = captureoptions.capture?.exporttarget;
+    if (target !== void 0 && target !== "memory" && target !== "download" && target !== "clipboard") return { allowed: false, reason: "The capture export target must be memory, download or clipboard." };
+  }
   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 {
@@ -1470,7 +2001,7 @@ function canexecute(input) {
 }
 
 // version.ts
-var packageversion = "1.1.38";
+var packageversion = "1.1.40";
 
 // types.ts
 var protocolversion = packageversion;
@@ -1534,7 +2065,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 } : {} });
+  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 } : {} });
 }
 function mapresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
@@ -1602,14 +2133,45 @@ function provenancereport(input) {
 function transformgrammar(rules) {
   return JSON.stringify({ rules: rules.map((rule) => ({ expression: rule.expression, sources: rule.sources, target: rule.target })) });
 }
+function downloadreport(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, downloads: input.downloads });
+}
+function netlogreport(input) {
+  return { version: protocolversion, records: input.records };
+}
+function quarantinereport(input) {
+  return { version: protocolversion, entries: input.entries };
+}
+function capturereport(input) {
+  return { version: protocolversion, records: input.records, pairs: input.pairs };
+}
 export {
+  annotationplanof,
+  blendrows,
+  buildname,
+  buildsheet,
+  buildstitchplan,
   canexecute,
+  captureelement,
+  captureformats,
+  capturekinds,
+  captureoptionsof,
+  captureregion,
+  capturereport,
+  capturestates,
+  capturestitched,
+  capturetargets,
+  capturevisible,
+  croprect,
+  crossesviewport,
   datasetresponse,
   actionrisk as deriveactionrisk,
   diffresponse,
+  downloadreport,
   errorreportresponse,
   eventresponse,
   extractionreport,
+  fixedheadermatch,
   formreportresponse,
   generatedvalueallowed,
   heldkeysreport,
@@ -1619,19 +2181,25 @@ export {
   layoutreport,
   mapresponse,
   navstateresponse,
+  netlogreport,
   normalizeendpoint,
   observationmodeof,
   observationresponse,
   outcomeresponse,
+  pairstates,
   parseproposal,
   passwordconsentgranted,
   profilegrantgranted,
   protocolversion,
   provenancereport,
+  quarantinereport,
   randomid,
+  regionsteps,
   requestbody,
   resolutionverdict,
   safetyresponse,
+  scaledrect,
+  seamweights,
   selectorresponse,
   sessionmemory,
   signalsreport,