@wenathlan/extension 1.1.44 → 1.1.45

package/dist/index.js

@@ -1828,6 +1828,103 @@ var sessionmemory = class {
     if (live.length !== records.length) await this.adapter.set("ratelimits", live);
     return live;
   }
+  /** Stores one run timeline entry; the user configured timeline retention window expires the oldest entries while their level counts survive in the per run level summaries. */
+  async addtimelineentry(entry) {
+    const records = await this.gettimeline();
+    const combined = [entry, ...records];
+    const retention = (await this.getsettings())?.timelineretention;
+    if (retention === void 0) {
+      await this.adapter.set("timelineentries", combined);
+      return;
+    }
+    const kept = combined.slice(0, retention);
+    const expired = combined.slice(retention);
+    if (expired.length > 0) {
+      const expiredcounts = /* @__PURE__ */ new Map();
+      for (const item of expired) {
+        const counts = expiredcounts.get(item.runid) ?? {};
+        counts[item.level] = (counts[item.level] ?? 0) + 1;
+        expiredcounts.set(item.runid, counts);
+      }
+      for (const [runid, counts] of expiredcounts) await this.mergelevelsummary(runid, counts, Date.now());
+    }
+    await this.adapter.set("timelineentries", kept);
+  }
+  /** Returns every stored run timeline entry, newest first. */
+  async gettimeline() {
+    return await this.adapter.get("timelineentries") ?? [];
+  }
+  /** Returns the run timeline entries filtered by run, level and step id. */
+  async listtimeline(filter) {
+    const records = await this.gettimeline();
+    return records.filter((item) => (filter.runid === void 0 || item.runid === filter.runid) && (filter.level === void 0 || item.level === filter.level) && (filter.stepid === void 0 || item.stepid === filter.stepid));
+  }
+  /** Stores one captured javascript error record with its stack frames, source url and line. */
+  async adderrorrecord(record2) {
+    const records = await this.adapter.get("errorrecords") ?? [];
+    await this.adapter.set("errorrecords", [record2, ...records]);
+  }
+  /** Returns every stored error record, newest first. */
+  async geterrorrecords() {
+    return await this.adapter.get("errorrecords") ?? [];
+  }
+  /** Stores one captured unhandled rejection record with its reason and stack frames. */
+  async addrejectionrecord(record2) {
+    const records = await this.adapter.get("rejectionrecords") ?? [];
+    await this.adapter.set("rejectionrecords", [record2, ...records]);
+  }
+  /** Returns every stored rejection record, newest first. */
+  async getrejectionrecords() {
+    return await this.adapter.get("rejectionrecords") ?? [];
+  }
+  /** Stores one captured long task entry with its duration, start time and attribution names. */
+  async addlongtask(record2) {
+    const records = await this.adapter.get("longtasks") ?? [];
+    await this.adapter.set("longtasks", [record2, ...records]);
+  }
+  /** Returns every stored long task entry, newest first. */
+  async getlongtasks() {
+    return await this.adapter.get("longtasks") ?? [];
+  }
+  /** Stores one console diff result between two runs, replacing the previous one. */
+  async addconsolediff(diff) {
+    return this.adapter.set("consolediff", diff);
+  }
+  /** Returns the one stored console diff result. */
+  async getdiff() {
+    return this.adapter.get("consolediff");
+  }
+  /** Stores one log rotation target record with its overflow entry counts, replacing the previous record of that target and run. */
+  async addrotationtarget(record2) {
+    const records = (await this.adapter.get("rotationtargets") ?? []).filter((item) => !(item.target === record2.target && item.runid === record2.runid));
+    await this.adapter.set("rotationtargets", [record2, ...records]);
+  }
+  /** Returns every stored rotation target record with its overflow entry counts, newest first. */
+  async getrotationtargets() {
+    return await this.adapter.get("rotationtargets") ?? [];
+  }
+  /** Stores one console capture consent decision per origin; the approved decision persists so console watching on that origin prompts once. */
+  async setconsoleconsent(consent) {
+    const records = (await this.adapter.get("consoleconsents") ?? []).filter((item) => item.id !== consent.id);
+    await this.adapter.set("consoleconsents", [consent, ...records]);
+  }
+  /** Returns every console capture consent decision, newest first. */
+  async getconsoleconsents() {
+    return await this.adapter.get("consoleconsents") ?? [];
+  }
+  /** Merges expired entry counts into the per run level count summary that survives the retention window. */
+  async mergelevelsummary(runid, counts, now) {
+    const records = await this.getlevelsummaries();
+    const existing = records.find((item) => item.runid === runid);
+    const merged = { ...existing?.counts ?? {} };
+    for (const [level, count] of Object.entries(counts)) merged[level] = (merged[level] ?? 0) + count;
+    const updated = { runid, counts: merged, at: now };
+    await this.adapter.set("levelsummaries", [updated, ...records.filter((item) => item.runid !== runid)]);
+  }
+  /** Returns every per run level count summary, newest first. */
+  async getlevelsummaries() {
+    return await this.adapter.get("levelsummaries") ?? [];
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -2364,6 +2461,195 @@ function extractvalues(body, paths) {
   return fields.map((field) => ({ path: field.path, ...field.value !== void 0 ? { value: field.value } : {}, ...field.missing ? { missing: true } : {} }));
 }
 
+// runtimeline.ts
+var timelinekinds = ["watchconsole", "watcherrors", "watchtasks"];
+var loglevels = ["error", "warn", "info", "log", "debug", "trace"];
+var timelinesources = ["console", "error", "rejection", "resource", "longtask", "network"];
+function levelrank(level) {
+  return loglevels.indexOf(level);
+}
+function redactconsoletext(text2, patterns) {
+  let redacted = text2;
+  for (const pattern of patterns) {
+    if (!pattern) continue;
+    while (redacted.includes(pattern)) redacted = redacted.replace(pattern, "[redacted]");
+  }
+  return redacted;
+}
+function argkind(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Error) return "error";
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "bigint":
+      return "bigint";
+    case "symbol":
+      return "symbol";
+    case "function":
+      return "function";
+    case "undefined":
+      return "undefined";
+    default:
+      return "object";
+  }
+}
+function serializearg(value, depth) {
+  const render = (item, remaining) => {
+    if (item instanceof Error) return `${item.name}: ${item.message}`;
+    if (typeof item === "string") return item;
+    if (typeof item === "function") return `[function ${item.name || "anonymous"}]`;
+    if (typeof item === "bigint") return `${item}n`;
+    if (typeof item === "symbol") return item.toString();
+    if (item === null || item === void 0 || typeof item !== "object") return String(item);
+    if (remaining <= 0) {
+      const tag = Array.isArray(item) ? "Array" : item.constructor?.name ?? "Object";
+      return `[${tag}]`;
+    }
+    if (Array.isArray(item)) return `[${item.map((entry) => render(entry, remaining - 1)).join(", ")}]`;
+    const record2 = item;
+    return `{${Object.keys(record2).map((key) => `${key}: ${render(record2[key], remaining - 1)}`).join(", ")}}`;
+  };
+  return render(value, Math.max(0, depth));
+}
+function consolecapture(input) {
+  const parts = input.args.map((arg) => serializearg(arg, input.depth));
+  return { level: input.level, text: redactconsoletext(parts.join(" "), input.redact), argkinds: input.args.map((arg) => argkind(arg)), repeat: 1 };
+}
+function stackframes(stacktext) {
+  const frames = [];
+  for (const row of stacktext.split("\n")) {
+    const trimmed = row.trim();
+    if (!trimmed.startsWith("at ")) continue;
+    const body = trimmed.slice(3).trim();
+    const location = body.match(/\(([^()]*:\d+:\d+)\)$/) ?? body.match(/^(.*:\d+:\d+)$/);
+    const located = location?.[1];
+    if (!located) continue;
+    const segments = located.split(":");
+    const column = Number.parseInt(segments.pop() ?? "", 10);
+    const lineno = Number.parseInt(segments.pop() ?? "", 10);
+    const url = segments.join(":");
+    if (!Number.isFinite(lineno) || lineno < 0) continue;
+    const name = body.endsWith(`(${located})`) ? body.slice(0, body.length - located.length - 2).trim() : "";
+    frames.push({ ...name ? { functionname: name } : {}, url, line: lineno, ...Number.isFinite(column) ? { column } : {} });
+  }
+  return frames;
+}
+function errorcapture(input) {
+  return { message: redactconsoletext(input.message, input.redact), frames: input.stacktext !== void 0 ? stackframes(input.stacktext) : [], sourceurl: input.sourceurl, line: input.line };
+}
+function rejectioncapture(input) {
+  return { reason: redactconsoletext(input.reason, input.redact), frames: input.stacktext !== void 0 ? stackframes(input.stacktext) : [] };
+}
+function longtaskcapture(input) {
+  return input.entries.filter((entry) => entry.duration >= input.threshold).map((entry) => ({ duration: Math.round(entry.duration), starttime: Math.round(entry.starttime), attributions: [...entry.attributions] }));
+}
+function attachtimeline(input) {
+  return { runid: input.runid, origin: input.origin, stepids: [...input.stepids], attachedat: input.now, entries: [] };
+}
+function filterentries(entries, levelset) {
+  return entries.filter((entry) => {
+    const floor = levelset.floors?.[entry.stepid] ?? levelset.floors?.["*"];
+    if (floor !== void 0 && levelrank(entry.level) > levelrank(floor)) return false;
+    if (levelset.sources !== void 0 && levelset.sources.length > 0 && !levelset.sources.includes(entry.source)) return false;
+    return true;
+  });
+}
+function spamdetect(entries, rule) {
+  const collapsed = [];
+  const counts = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (rule.pattern !== "" && !entry.message.includes(rule.pattern)) {
+      collapsed.push({ ...entry, repeat: 1 });
+      continue;
+    }
+    const key = `${entry.level}|${entry.source}|${entry.message}`;
+    const previous = collapsed[collapsed.length - 1];
+    if (previous && previous.repeat !== void 0 && `${previous.level}|${previous.source}|${previous.message}` === key && entry.time - previous.time <= rule.windowsize) {
+      previous.repeat += 1;
+      continue;
+    }
+    collapsed.push({ ...entry, repeat: 1 });
+  }
+  for (const entry of collapsed) {
+    if (entry.repeat > 1) counts.set(`${entry.level}|${entry.source}|${entry.message}`, entry.repeat);
+  }
+  const flagged = [...counts.entries()].filter(([, count]) => count > rule.collapse).map(([key, count]) => ({ message: key.split("|").slice(2).join("|"), count }));
+  return { entries: collapsed, flagged };
+}
+function rotatelogs(entries, rule) {
+  if (entries.length <= rule.maxentries) return { kept: [...entries], overflow: [] };
+  const kept = entries.slice(entries.length - rule.maxentries);
+  const overflow = entries.slice(0, entries.length - rule.maxentries);
+  return { kept, overflow };
+}
+function timelinecounts(entries) {
+  const counts = {};
+  for (const level of loglevels) counts[level] = 0;
+  for (const entry of entries) counts[entry.level] = (counts[entry.level] ?? 0) + 1;
+  return counts;
+}
+function blockingduration(tasks, stepid, window) {
+  const inside = tasks.filter((task) => task.starttime >= window.startedat && task.starttime <= window.endedat);
+  return { stepid, blocking: inside.reduce((total, task) => total + task.duration, 0), tasks: inside.length };
+}
+function netfailureentryof(input) {
+  const exchange = input.exchange;
+  if (exchange.errorclass === void 0 && exchange.status < 400) return null;
+  return { id: input.id, runid: exchange.runid, stepid: exchange.stepid, url: exchange.url, status: exchange.status, errorclass: exchange.errorclass ?? "httperror", correlationid: exchange.correlationid, at: input.at };
+}
+function watcherdetached(input) {
+  for (const navigation of input.navigations) {
+    if (navigation >= input.startedat && navigation <= input.startedat + input.lifetime) return { detached: true, at: navigation };
+  }
+  return { detached: false };
+}
+function consolediff(input) {
+  const base = input.baselines;
+  const target = input.targetlines;
+  const basemap = /* @__PURE__ */ new Map();
+  for (const line of base) basemap.set(line, (basemap.get(line) ?? 0) + 1);
+  const targetmap = /* @__PURE__ */ new Map();
+  for (const line of target) targetmap.set(line, (targetmap.get(line) ?? 0) + 1);
+  const lines = [];
+  const added = [];
+  const removed = [];
+  const repeated = [];
+  for (const [line, count] of targetmap) {
+    const basecount = basemap.get(line) ?? 0;
+    if (basecount === 0) {
+      for (let index = 0; index < count; index += 1) {
+        lines.push({ kind: "added", text: line });
+        added.push(line);
+      }
+      continue;
+    }
+    const share = Math.min(basecount, count);
+    for (let index = 0; index < share; index += 1) {
+      lines.push({ kind: "repeated", text: line, count: share });
+      repeated.push(line);
+    }
+    for (let index = share; index < count; index += 1) {
+      lines.push({ kind: "added", text: line });
+      added.push(line);
+    }
+  }
+  for (const [line, count] of basemap) {
+    const targetcount = targetmap.get(line) ?? 0;
+    const missing = Math.max(0, count - targetcount);
+    for (let index = 0; index < missing; index += 1) {
+      lines.push({ kind: "removed", text: line });
+      removed.push(line);
+    }
+  }
+  return { base: input.baseid, target: input.targetid, lines, added: added.length, removed: removed.length, repeated: repeated.length, at: input.now };
+}
+
 // socketbus.ts
 var socketkinds = ["opensocket", "sendmessage", "waitmessage", "subscribesse", "longpoll"];
 function channelorigin(url) {
@@ -2587,7 +2873,7 @@ function polldecision(input) {
 // policy.ts
 var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts", "recordscreen", "captureaudio", "downloadimages", "callrest", "callgraphql", "sendmessage", "blockrequest", "mockresponse", "rewriteheaders", "setcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles"]);
 var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction", "capturebodies"]);
-var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures", "shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet", "capturepdf", "captureframe", "readmedia", "readassets", "probestream", "timelapse", "shotcanvas", "convertimage", "makethumbs", "fetchurl", "parsejson", "parsehtml", "opensocket", "waitmessage", "watchrequests", "readheaders", "mapapi", "subscribesse", "longpoll", "extractapi", "readcookies"]);
+var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures", "shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet", "capturepdf", "captureframe", "readmedia", "readassets", "probestream", "timelapse", "shotcanvas", "convertimage", "makethumbs", "fetchurl", "parsejson", "parsehtml", "opensocket", "waitmessage", "watchrequests", "readheaders", "mapapi", "subscribesse", "longpoll", "extractapi", "readcookies", "watchconsole", "watcherrors", "watchtasks"]);
 var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
 var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus", "watchtab"]);
 var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection", "submitform", "retryform", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "scrapetable", "paginateextract", "shotelement", "captureframe", "shotcanvas"]);
@@ -2603,6 +2889,7 @@ var httpactions = /* @__PURE__ */ new Set(["fetchurl", "parsejson", "parsehtml",
 var socketactions = /* @__PURE__ */ new Set(["opensocket", "sendmessage", "waitmessage", "subscribesse", "longpoll"]);
 var netwatchactions = /* @__PURE__ */ new Set(["watchrequests", "readheaders", "capturebodies", "mapapi", "extractapi"]);
 var controlactions = /* @__PURE__ */ new Set(["blockrequest", "mockresponse", "rewriteheaders", "setcookies", "readcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles"]);
+var debugactions = /* @__PURE__ */ new Set(["watchconsole", "watcherrors", "watchtasks"]);
 var credentialheaders = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "cookie", "cookie2", "set-cookie", "api-key", "x-api-key", "x-auth-token", "x-session-token", "proxy-authorization"]);
 var fieldkinds = ["text", "email", "phone", "date", "number", "select", "check", "radio", "file", "password", "card", "code"];
 var layoutmutationactions = /* @__PURE__ */ new Set(["grouptabs", "colorgroup", "collapsegroup", "savelayout", "restorelayout"]);
@@ -2621,8 +2908,11 @@ function hostpattern(origin) {
 function iswatchkind(kind) {
   return watchactions.has(kind);
 }
+function isdebugkind(kind) {
+  return debugactions.has(kind);
+}
 function observationmodeof(kind) {
-  if (watchactions.has(kind) || kind === "waitquiet") return "watching";
+  if (watchactions.has(kind) || debugactions.has(kind) || kind === "waitquiet") return "watching";
   if (kind === "diffsnapshots") return "diffing";
   return "passive";
 }
@@ -3755,6 +4045,87 @@ function ratelimitbudgetallowed(wait, budget) {
   if (wait !== void 0 && budget !== void 0 && wait > budget) return { allowed: false, reason: `The rate limit wait of ${wait} milliseconds exceeds the reviewed budget of ${budget} milliseconds; review a wider budget or submit later.` };
   return { allowed: true };
 }
+function timelinegate(session, tabid, origin, now) {
+  if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the timeline capture." };
+  if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot capture the timeline." };
+  if (session.pausedat) return { allowed: false, reason: "The browser session is paused and cannot capture the timeline." };
+  if (session.tabid !== tabid) return { allowed: false, reason: `The timeline capture needs the run tab ${session.tabid} and refuses tab ${tabid}.` };
+  if (!origingranted(session, origin)) return { allowed: false, reason: `The timeline capture of ${origin} needs the session origin grants first.` };
+  return { allowed: true };
+}
+function consoleconsentcovers(origin, consents) {
+  if (consents.some((consent) => consent.origin === origin && consent.approved === true)) return { allowed: true };
+  return { allowed: false, reason: `Console capture on ${origin} needs the reviewed console consent first; approve the prompt in the review panel.` };
+}
+function stackgate(session, origin) {
+  if (!origingranted(session, origin)) return { allowed: false, reason: `Stack capture of ${origin} stays outside the session origin grants.` };
+  return { allowed: true };
+}
+function debugwaitbudgetallowed(watchwindow, wait) {
+  if (watchwindow !== void 0 && (typeof watchwindow !== "number" || !Number.isFinite(watchwindow) || watchwindow < 0)) return { allowed: false, reason: "The debug watch window must be zero or a positive number of milliseconds." };
+  if (wait !== void 0 && (typeof wait !== "number" || !Number.isFinite(wait) || wait < 0)) return { allowed: false, reason: "The reviewed debug wait budget must be zero or a positive number of milliseconds." };
+  if (watchwindow !== void 0 && wait !== void 0 && watchwindow > wait) return { allowed: false, reason: `The debug watch window of ${watchwindow} milliseconds exceeds the reviewed wait budget of ${wait} milliseconds; review a wider budget or a shorter window.` };
+  return { allowed: true };
+}
+function timelineretentionwindow(settings) {
+  return settings?.timelineretention;
+}
+function diffreviewgrade() {
+  return { risk: "read", mode: "diffing", evidence: "comparison" };
+}
+function validatetimelinegrammar(step, options) {
+  const kind = step.kind;
+  let watchwindow;
+  if (options.watch !== void 0) {
+    const watch = options.watch;
+    if (!watch || typeof watch !== "object" || Array.isArray(watch)) return { allowed: false, reason: "The reviewed debug watch window must be an object." };
+    const reviewed = watch;
+    if (reviewed.window !== void 0) {
+      if (typeof reviewed.window !== "number" || !Number.isFinite(reviewed.window) || reviewed.window < 0) return { allowed: false, reason: "The reviewed debug watch window must be zero or a positive number of milliseconds." };
+      watchwindow = reviewed.window;
+    }
+  }
+  const budgetcheck = debugwaitbudgetallowed(watchwindow, typeof options.wait === "number" ? options.wait : void 0);
+  if (!budgetcheck.allowed) return budgetcheck;
+  if (options.level !== void 0 && !loglevels.includes(options.level)) return { allowed: false, reason: `The reviewed level floor must be one of ${loglevels.join(", ")}.` };
+  if (options.sources !== void 0) {
+    if (!Array.isArray(options.sources) || options.sources.length === 0 || !options.sources.every((source) => timelinesources.includes(source))) return { allowed: false, reason: `The reviewed source filters must be a non-empty list of the reviewed timeline sources: ${timelinesources.join(", ")}.` };
+  }
+  if (kind === "watchconsole") {
+    if (options.redact === void 0 || !Array.isArray(options.redact) || options.redact.length === 0 || !options.redact.every((pattern) => isnonempty(pattern))) return { allowed: false, reason: "Console capture requires a reviewed non-empty redaction pattern list before any console text is captured." };
+    if (options.depth !== void 0 && (typeof options.depth !== "number" || !Number.isInteger(options.depth) || options.depth < 1)) return { allowed: false, reason: "The reviewed serialization depth bound must be a positive integer with no code ceiling." };
+    if (options.spam !== void 0) {
+      const rule = spamruleof(options.spam);
+      if (!rule) return { allowed: false, reason: "The reviewed spam rule needs a pattern, a window size and a collapse threshold." };
+      if (rule.collapse < 1) return { allowed: false, reason: "The reviewed spam collapse threshold must be a positive integer of user configured value with no code ceiling." };
+    }
+    if (options.rotation !== void 0) {
+      const rule = rotationruleof(options.rotation);
+      if (!rule) return { allowed: false, reason: "The reviewed rotation rule needs a max entry count and an overflow target." };
+    }
+  }
+  if (kind === "watchtasks") {
+    if (options.threshold !== void 0 && (typeof options.threshold !== "number" || !Number.isFinite(options.threshold) || options.threshold < 0)) return { allowed: false, reason: "The reviewed long task threshold must be zero or a positive number of milliseconds with no code ceiling." };
+  }
+  return { allowed: true };
+}
+function spamruleof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const pattern = typeof entry.pattern === "string" ? entry.pattern : "";
+  const windowsize = typeof entry.windowsize === "number" && Number.isFinite(entry.windowsize) && entry.windowsize >= 0 ? entry.windowsize : void 0;
+  const collapse = typeof entry.collapse === "number" && Number.isInteger(entry.collapse) ? entry.collapse : void 0;
+  if (windowsize === void 0 || collapse === void 0) return void 0;
+  return { pattern, windowsize, collapse };
+}
+function rotationruleof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const maxentries = typeof entry.maxentries === "number" && Number.isInteger(entry.maxentries) && entry.maxentries >= 1 ? entry.maxentries : void 0;
+  const overflowtarget = typeof entry.overflowtarget === "string" && entry.overflowtarget.trim() ? entry.overflowtarget.trim() : void 0;
+  if (maxentries === void 0 || overflowtarget === void 0) return void 0;
+  return { maxentries, overflowtarget };
+}
 function controltarget(step) {
   let options = {};
   try {
@@ -4160,6 +4531,10 @@ function validatestep(step, origin) {
     const controlcheck = validatecontrolgrammar(step, options);
     if (!controlcheck.allowed) return controlcheck;
   }
+  if (isdebugkind(step.kind)) {
+    const timelinecheck = validatetimelinegrammar(step, options);
+    if (!timelinecheck.allowed) return timelinecheck;
+  }
   if (step.kind === "tabcreate") {
     if (options.background !== void 0 && typeof options.background !== "boolean") return { allowed: false, reason: "The reviewed background flag must be a boolean." };
     if (options.window !== void 0 && (typeof options.window !== "number" || !Number.isInteger(options.window) || options.window < 0)) return { allowed: false, reason: "The reviewed target window id must be a non-negative integer." };
@@ -4261,6 +4636,10 @@ function canexecute(input) {
     const watchgatecheck = watchgate(input.session, input.settings, now);
     if (!watchgatecheck.allowed) return watchgatecheck;
   }
+  if (isdebugkind(input.step.kind)) {
+    const timelinegatecheck = timelinegate(input.session, input.tabid, input.origin, now);
+    if (!timelinegatecheck.allowed) return timelinegatecheck;
+  }
   if (iscontrolkind(input.step.kind)) {
     const controlgate = sessiongate({ session: input.session, tabid: input.tabid, origin: input.origin, now, action: "control the network" });
     if (!controlgate.allowed) return controlgate;
@@ -4344,7 +4723,7 @@ function canexecute(input) {
 }
 
 // version.ts
-var packageversion = "1.1.44";
+var packageversion = "1.1.45";
 
 // types.ts
 var protocolversion = packageversion;
@@ -4402,6 +4781,23 @@ function parseproposal(value, origin, grants) {
       const bypass = proxy && typeof proxy === "object" && !Array.isArray(proxy) ? proxy.bypass : void 0;
       if (!Array.isArray(bypass) || bypass.length === 0) throw new Error("Proxy routes without a bypass list are refused.");
     }
+    if (step.kind === "watchconsole" || step.kind === "watcherrors" || step.kind === "watchtasks") {
+      let debugoptions = {};
+      try {
+        debugoptions = parseoptions(step);
+      } catch {
+        debugoptions = {};
+      }
+      const granted = covered.some((pattern) => {
+        try {
+          return new URL(origin).origin === new URL(pattern).origin;
+        } catch {
+          return false;
+        }
+      });
+      if (!granted) throw new Error(`The ${step.kind} capture of ${origin} targets an origin outside the grants.`);
+      if (debugoptions.level !== void 0 && !loglevels.includes(debugoptions.level)) throw new Error(`The reviewed level floor must be one of ${loglevels.join(", ")}.`);
+    }
     const evaluation = validatestep(step, origin);
     if (!evaluation.allowed) throw new Error(evaluation.reason);
     const target = outboundtarget(step);
@@ -4476,7 +4872,7 @@ function requestbody(input) {
   return JSON.stringify({ version: protocolversion, objective: input.objective, session: input.session, observation: input.observation, capabilities: input.capabilities });
 }
 function outcomeresponse(input) {
-  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {}, ...input.capture ? { capture: input.capture } : {}, ...input.media ? { media: input.media } : {}, ...input.transport ? { transport: input.transport } : {}, ...input.network ? { network: input.network } : {}, ...input.control ? { control: input.control } : {} });
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {}, ...input.capture ? { capture: input.capture } : {}, ...input.media ? { media: input.media } : {}, ...input.transport ? { transport: input.transport } : {}, ...input.network ? { network: input.network } : {}, ...input.control ? { control: input.control } : {}, ...input.timeline ? { timeline: input.timeline } : {} });
 }
 function mapresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
@@ -4587,18 +4983,27 @@ function controlreport(input) {
   });
   return { version: protocolversion, blocks: input.blocks, mocks, rewrites: input.rewrites, cookies: input.cookies, proxies: input.proxies, ratelimits: input.ratelimits };
 }
+function timelinereport(input) {
+  return { version: protocolversion, entries: input.entries, errors: input.errors, rejections: input.rejections, longtasks: input.longtasks, levelcounts: input.levelcounts };
+}
+function consolediffreport(input) {
+  return { version: protocolversion, diff: input.diff };
+}
 export {
   annotationplanof,
   apientries,
   apikeyconsentgranted,
   apireplayspecof,
   applyheaderules,
+  argkind,
   assetentries,
+  attachtimeline,
   authconsentgranted,
   authorizeurl,
   authreport,
   blendrows,
   blockgate,
+  blockingduration,
   blockruleof,
   bodyfilterof,
   bodymatches,
@@ -4627,6 +5032,10 @@ export {
   channelorigin,
   closechannel,
   collectmessages,
+  consolecapture,
+  consoleconsentcovers,
+  consolediff,
+  consolediffreport,
   controlkinds,
   controlreport,
   controltarget,
@@ -4639,10 +5048,13 @@ export {
   crossesviewport,
   cursorfrom,
   datasetresponse,
+  debugwaitbudgetallowed,
   dedupeimages,
   actionrisk as deriveactionrisk,
   diffresponse,
+  diffreviewgrade,
   downloadreport,
+  errorcapture,
   errorreportresponse,
   eventresponse,
   exchangesreport,
@@ -4651,6 +5063,7 @@ export {
   failureclass,
   fetchoptionsof,
   fetchrequestof,
+  filterentries,
   filterexchanges,
   finishrecording,
   fixedheadermatch,
@@ -4670,6 +5083,7 @@ export {
   imagematches,
   imagenames,
   iscontrolkind,
+  isdebugkind,
   isformkind,
   isnetwatchkind,
   issocketkind,
@@ -4678,6 +5092,9 @@ export {
   lapseframes,
   lapseplanof,
   layoutreport,
+  levelrank,
+  loglevels,
+  longtaskcapture,
   mapresponse,
   matchmessage,
   matchurlpattern,
@@ -4690,6 +5107,7 @@ export {
   multipartchunks,
   multipartpayloadof,
   navstateresponse,
+  netfailureentryof,
   netlogreport,
   netwatchkinds,
   newblockrule,
@@ -4740,8 +5158,10 @@ export {
   receivemessage,
   reconnectwaits,
   recordingoptionsof,
+  redactconsoletext,
   redactedcookies,
   regionsteps,
+  rejectioncapture,
   replayurl,
   requestbody,
   resolutionverdict,
@@ -4750,17 +5170,24 @@ export {
   retryafterof,
   revertrule,
   revocationruleof,
+  rotatelogs,
+  rotationruleof,
   safetyresponse,
   scaledrect,
   seamweights,
   selectorresponse,
   sendfetch,
   sequenceintegrity,
+  serializearg,
   sessionmemory,
   signalsreport,
   socketgate,
   socketkinds,
+  spamdetect,
+  spamruleof,
   sserequestheaders,
+  stackframes,
+  stackgate,
   statusclassof,
   streamsummaries,
   streamwindowof,
@@ -4770,6 +5197,12 @@ export {
   templateurl,
   thumbdirectiveof,
   thumbgeometry,
+  timelinecounts,
+  timelinegate,
+  timelinekinds,
+  timelinereport,
+  timelineretentionwindow,
+  timelinesources,
   tokenrequest,
   trailreport,
   transformgrammar,
@@ -4780,6 +5213,7 @@ export {
   validatestep,
   validatetargetref,
   validatevaluegen,
+  watcherdetached,
   watchgate,
   wizardreport
 };