@wenathlan/extension 1.1.45 → 1.1.47

package/dist/index.js

@@ -196,6 +196,143 @@ function annotationplanof(input) {
   return plan;
 }
 
+// cdpbus.ts
+var cdpkinds = ["attachcdp", "detachcdp", "cdpcmd", "watchcdp", "setbreakpoint", "stepcode", "watchexpr", "overridescript"];
+var cdpdomains = ["Runtime", "Log", "Debugger", "DOM", "Network", "Page"];
+function methoddomain(method) {
+  const match = /^([A-Z][A-Za-z]*)\.([a-zA-Z][A-Za-z0-9]*)$/.exec(method.trim());
+  return match?.[1];
+}
+function cdpallowlistof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const domains = Array.isArray(entry.domains) ? entry.domains.filter((domain) => typeof domain === "string" && cdpdomains.includes(domain)) : [];
+  if (domains.length === 0) return void 0;
+  if (entry.methods === void 0) return { domains };
+  const methods = Array.isArray(entry.methods) ? entry.methods.filter((method) => typeof method === "string" && methoddomain(method) !== void 0 && domains.includes(methoddomain(method))) : [];
+  if (methods.length === 0) return void 0;
+  return { domains, methods };
+}
+function allowlistcovers(allowlist, method) {
+  const domain = methoddomain(method);
+  if (domain === void 0) return false;
+  if (!allowlist.domains.includes(domain)) return false;
+  if (allowlist.methods !== void 0 && !allowlist.methods.includes(method)) return false;
+  return true;
+}
+function attachcdpsession(input) {
+  return { id: input.id, runid: input.runid, stepid: input.stepid, tabid: input.tabid, origin: input.origin, attachedat: input.now, domains: [...new Set(input.domains)], debuggerversion: input.debuggerversion };
+}
+function detachcdpsession(session, at, userdetached = false) {
+  return { ...session, detachedat: at, ...userdetached ? { userdetached: true } : {} };
+}
+function sendcdpcommand(input) {
+  const domain = methoddomain(input.method);
+  if (domain === void 0) return { ...input, method: input.method.trim(), domain: "", duration: input.duration, ...input.errorclass !== void 0 ? { errorclass: input.errorclass } : { errorclass: "malformedmethod" }, at: input.at };
+  return { ...input, method: input.method.trim(), domain, duration: input.duration, ...input.errorclass !== void 0 ? { errorclass: input.errorclass } : {}, at: input.at };
+}
+function serializecdpcommand(queue, command) {
+  return [...queue, command];
+}
+function cdpeventruleof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const domain = typeof entry.domain === "string" && cdpdomains.includes(entry.domain) ? entry.domain : void 0;
+  const event = typeof entry.event === "string" && entry.event.trim() ? entry.event.trim() : void 0;
+  if (domain === void 0 || event === void 0) return void 0;
+  const match = typeof entry.match === "string" && entry.match.trim() ? entry.match.trim() : void 0;
+  return { domain, event, ...match !== void 0 ? { match } : {} };
+}
+function watchcdpevents(rules, events) {
+  const matched = [];
+  const counts = {};
+  for (const domain of cdpdomains) counts[domain] = 0;
+  for (const event of events) {
+    for (const rule of rules) {
+      if (rule.domain !== event.domain || rule.event !== event.event) continue;
+      if (rule.match !== void 0 && !(event.payload ?? "").includes(rule.match)) continue;
+      matched.push({ ruleid: rule.id, domain: event.domain, event: event.event, ...event.payload !== void 0 ? { payload: event.payload } : {} });
+      counts[event.domain] = (counts[event.domain] ?? 0) + 1;
+    }
+  }
+  return { matched, counts };
+}
+function breakpointinputof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const url = typeof entry.url === "string" && entry.url.trim() ? entry.url.trim() : void 0;
+  const line = typeof entry.line === "number" && Number.isInteger(entry.line) && entry.line >= 0 ? entry.line : void 0;
+  if (url === void 0 || line === void 0) return void 0;
+  const column = typeof entry.column === "number" && Number.isInteger(entry.column) && entry.column >= 0 ? entry.column : void 0;
+  const condition = typeof entry.condition === "string" && entry.condition.trim() ? entry.condition.trim() : void 0;
+  return { url, line, ...column !== void 0 ? { column } : {}, ...condition !== void 0 ? { condition } : {} };
+}
+function capturepause(input) {
+  return { id: input.id, runid: input.runid, stepid: input.stepid, reason: input.reason, callframes: [...input.callframes], ...input.hitbreakpoint !== void 0 ? { hitbreakpoint: input.hitbreakpoint } : {}, ...input.domsnapshotid !== void 0 ? { domsnapshotid: input.domsnapshotid } : {}, at: input.at };
+}
+function stepmodeof(value) {
+  const modes = ["stepover", "stepinto", "stepout", "resume"];
+  return typeof value === "string" && modes.includes(value) ? value : void 0;
+}
+function watchexpressionof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const expression = typeof entry.expression === "string" && entry.expression.trim() ? entry.expression.trim() : void 0;
+  if (expression === void 0) return void 0;
+  const scope = typeof entry.scope === "string" && entry.scope.trim() ? entry.scope.trim() : "topframe";
+  return { expression, scope };
+}
+function recordwatchvalue(expression, pauseid, value, at) {
+  return { ...expression, values: [...expression.values, { pauseid, value, at }] };
+}
+function overrideinputof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const urlpattern = typeof entry.urlpattern === "string" && entry.urlpattern.trim() ? entry.urlpattern.trim() : void 0;
+  const source = typeof entry.source === "string" ? entry.source : void 0;
+  if (urlpattern === void 0 || source === void 0 || source.trim().length === 0) return void 0;
+  return { urlpattern, source };
+}
+function overridematches(urlpattern, url) {
+  const patternmatch = /^(https:\/\/[^/]+)(\/.*)?$/.exec(urlpattern);
+  const urlmatch = /^(https:\/\/[^/]+)(\/.*)?$/.exec(url);
+  if (!patternmatch || !urlmatch) return false;
+  if (patternmatch[1] !== urlmatch[1]) return false;
+  const patternpath = (patternmatch[2] ?? "/").split("/").filter((segment) => segment.length > 0);
+  const urlpath = (urlmatch[2] ?? "/").split("/").filter((segment) => segment.length > 0);
+  const walk = (patternindex, urlindex) => {
+    if (patternindex >= patternpath.length) return urlindex >= urlpath.length;
+    const segment = patternpath[patternindex];
+    if (segment === "**") return walk(patternindex + 1, urlindex) || urlindex < urlpath.length && walk(patternindex, urlindex + 1);
+    if (urlindex >= urlpath.length) return false;
+    if (segment !== "*" && segment !== urlpath[urlindex]) return false;
+    return walk(patternindex + 1, urlindex + 1);
+  };
+  return walk(0, 0);
+}
+function teardownplanof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const revertsteps = Array.isArray(entry.revertsteps) ? entry.revertsteps.filter((step) => typeof step === "string" && step.trim().length > 0) : [];
+  const policy = entry.resumepolicy;
+  if (revertsteps.length === 0) return void 0;
+  if (policy !== void 0 && policy !== "resume" && policy !== "pause" && policy !== "ask") return void 0;
+  return { revertsteps, resumepolicy: policy ?? "ask" };
+}
+function teardowncdpsession(input) {
+  const revertedbreakpoints = input.breakpoints.filter((spec) => spec.revertedat === void 0).map((spec) => spec.id);
+  const revertedoverrides = input.overrides.filter((spec) => spec.revertedat === void 0).map((spec) => spec.id);
+  const resumepolicy = input.userdetached ? "pause" : input.plan?.resumepolicy ?? "ask";
+  return {
+    session: detachcdpsession(input.session, input.at, input.userdetached),
+    revertedbreakpoints,
+    revertedoverrides,
+    resumepolicy,
+    paused: input.userdetached || resumepolicy === "pause",
+    keepsalive: input.userdetached
+  };
+}
+
 // httpclient.ts
 var httpkinds = ["fetchurl", "parsejson", "parsehtml", "callrest", "callgraphql"];
 var redirectstatuses = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
@@ -784,6 +921,232 @@ function streamsummaries(raw) {
   });
 }
 
+// profilers.ts
+var profilerkinds = ["measureflow", "heapshot", "trackmemory", "profilecpu", "watchshifts", "traceload", "annotatetrace", "replaytrace", "capturesourcemaps"];
+var flowmetricnames = ["navigation", "paint", "lcp", "fid", "interaction", "blocking"];
+var tracecategories = ["navigation", "scripting", "rendering", "painting", "loading", "network"];
+function attachtargetof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const kinds = ["page", "iframe", "worker", "serviceworker"];
+  const kind = typeof entry.kind === "string" && kinds.includes(entry.kind) ? entry.kind : void 0;
+  const url = typeof entry.url === "string" && entry.url.trim() ? entry.url.trim() : void 0;
+  if (kind === void 0 || url === void 0) return void 0;
+  if (kind !== "page" && !/^https:\/\//.test(url)) return void 0;
+  return { kind, url };
+}
+function flowspecof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const prefix = typeof entry.prefix === "string" && entry.prefix.trim() ? entry.prefix.trim() : void 0;
+  const steps = Array.isArray(entry.steps) ? entry.steps.filter((step) => typeof step === "string" && step.trim().length > 0) : [];
+  const metrics = Array.isArray(entry.metrics) ? entry.metrics.filter((metric) => typeof metric === "string" && flowmetricnames.includes(metric)) : [];
+  if (prefix === void 0 || steps.length === 0 || metrics.length === 0) return void 0;
+  return { prefix, steps, metrics };
+}
+function stepwindows(spec, marks) {
+  const windows = [];
+  for (const stepid of spec.steps) {
+    const start = marks.find((mark) => mark.type === "mark" && mark.name === `${spec.prefix}:${stepid}:start`);
+    const end = marks.find((mark) => mark.type === "mark" && mark.name === `${spec.prefix}:${stepid}:end`);
+    if (start === void 0 || end === void 0) continue;
+    windows.push({ stepid, start: start.start, end: Math.max(end.start, start.start) });
+  }
+  return windows;
+}
+function measure(input) {
+  const metrics = [];
+  const windows = stepwindows(input.spec, input.entries.filter((entry) => entry.type === "mark"));
+  const stepsof = (start, end) => windows.filter((window) => window.end >= start && window.start <= end).map((window) => window.stepid);
+  const push = (name, start, end, steps) => {
+    if (!input.spec.metrics.includes(name)) return;
+    metrics.push({ id: `${input.runid}-${input.stepid}-${name}-${metrics.length}`, runid: input.runid, stepid: input.stepid, name, start, end, duration: Math.max(0, end - start), steps, at: input.now });
+  };
+  const navigation = input.entries.find((entry) => entry.type === "navigation");
+  if (navigation !== void 0) push("navigation", navigation.start, navigation.start + navigation.duration, stepsof(navigation.start, navigation.start + navigation.duration));
+  for (const paint of input.entries.filter((entry) => entry.type === "paint")) {
+    if (!input.spec.metrics.includes("paint")) break;
+    push("paint", paint.start, paint.start + paint.duration, stepsof(paint.start, paint.start + paint.duration));
+  }
+  const lcps = input.entries.filter((entry) => entry.type === "largest-contentful-paint");
+  const lcp = lcps.length > 0 ? lcps.reduce((largest, entry) => entry.start > largest.start ? entry : largest) : void 0;
+  if (lcp !== void 0) push("lcp", lcp.start, lcp.start + lcp.duration, stepsof(lcp.start, lcp.start + lcp.duration));
+  const firstinput = input.entries.find((entry) => entry.type === "first-input");
+  if (firstinput !== void 0) push("fid", firstinput.start, firstinput.start + firstinput.duration, stepsof(firstinput.start, firstinput.start + firstinput.duration));
+  const interactions = input.entries.filter((entry) => entry.type === "event");
+  if (interactions.length > 0) {
+    const start = interactions.reduce((earliest, entry) => entry.start < earliest.start ? entry : earliest).start;
+    const end = interactions.reduce((latest, entry) => entry.start + entry.duration > latest ? entry.start + entry.duration : latest, start);
+    push("interaction", start, end, stepsof(start, end));
+  }
+  for (const window of windows) {
+    if (!input.spec.metrics.includes("blocking")) break;
+    const blocking = input.entries.filter((entry) => entry.type === "longtask" && entry.start >= window.start && entry.start <= window.end).reduce((total, entry) => total + Math.max(0, entry.duration - 50), 0);
+    metrics.push({ id: `${input.runid}-${input.stepid}-blocking-${window.stepid}`, runid: input.runid, stepid: input.stepid, name: "blocking", start: window.start, end: window.end, duration: blocking, steps: [window.stepid], at: input.now });
+  }
+  return metrics;
+}
+function heapintervalallowed(lastcapturedat, interval, now) {
+  if (interval === void 0 || lastcapturedat === void 0) return true;
+  return now - lastcapturedat >= interval;
+}
+function heapsnap(input) {
+  return { id: input.id, runid: input.runid, stepid: input.stepid, origin: input.origin, bytesize: input.usedbytes, nodecount: input.nodecount, capturedat: input.now };
+}
+function growsampleof(input) {
+  return { id: input.id, runid: input.runid, stepid: input.stepid, usedbytes: input.usedbytes, limitbytes: input.limitbytes, at: input.now };
+}
+function growthtrend(input) {
+  const ordered = [...input.samples].sort((left, right) => left.at - right.at);
+  const first = ordered[0];
+  const last = ordered[ordered.length - 1];
+  const computed = first !== void 0 && last !== void 0 && last.at > first.at ? (last.usedbytes - first.usedbytes) / (last.at - first.at) : 0;
+  const flaggedsteps = [];
+  for (let index = 1; index < ordered.length; index += 1) {
+    const previous = ordered[index - 1];
+    const current = ordered[index];
+    if (previous === void 0 || current === void 0) continue;
+    const growth = current.at > previous.at ? (current.usedbytes - previous.usedbytes) / (current.at - previous.at) : 0;
+    if (growth > input.slope && !flaggedsteps.includes(current.stepid)) flaggedsteps.push(current.stepid);
+  }
+  return { runid: input.runid, slope: computed, samples: ordered.length, flaggedsteps, at: input.now };
+}
+function cpusnap(input) {
+  const ranked = /* @__PURE__ */ new Map();
+  for (const sample of input.samples) ranked.set(sample.name, (ranked.get(sample.name) ?? 0) + sample.time);
+  const hotfunctions = [...ranked.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])).map((entry) => entry[0]);
+  return { id: input.id, runid: input.runid, stepid: input.stepid, origin: input.origin, duration: input.duration, samplecount: input.samples.length, hotfunctions, at: input.now };
+}
+function shiftentryof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const score = typeof entry.score === "number" && Number.isFinite(entry.score) && entry.score >= 0 ? entry.score : void 0;
+  const starttime = typeof entry.starttime === "number" && Number.isFinite(entry.starttime) ? entry.starttime : void 0;
+  if (score === void 0 || starttime === void 0) return void 0;
+  const selectors = Array.isArray(entry.selectors) ? entry.selectors.filter((selector) => typeof selector === "string" && selector.trim().length > 0) : [];
+  return { id: typeof entry.id === "string" ? entry.id : "", runid: typeof entry.runid === "string" ? entry.runid : "", stepid: typeof entry.stepid === "string" ? entry.stepid : "", score, starttime, selectors, at: typeof entry.at === "number" ? entry.at : starttime };
+}
+function tracestart(input) {
+  return { id: input.id, runid: input.runid, stepid: input.stepid, origin: input.origin, categories: [...new Set(input.categories)], bytesize: 0, events: 0, annotations: [], startedat: input.now, endedat: input.now };
+}
+function tracetofile(trace, events) {
+  const payload = { devthinktrace: "1.1.47", runid: trace.runid, origin: trace.origin, categories: trace.categories, startedat: trace.startedat, endedat: trace.endedat, annotations: trace.annotations, traceevents: events.map((event) => ({ name: event.name, cat: event.category, offset: event.offset })) };
+  const content = JSON.stringify(payload);
+  return { content, bytesize: content.length, events: events.length };
+}
+function annotationof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const stepid = typeof entry.stepid === "string" && entry.stepid.trim() ? entry.stepid.trim() : void 0;
+  const label = typeof entry.label === "string" && entry.label.trim() ? entry.label.trim() : void 0;
+  if (stepid === void 0 || label === void 0) return void 0;
+  const offset = typeof entry.offset === "number" && Number.isFinite(entry.offset) && entry.offset >= 0 ? entry.offset : 0;
+  return { stepid, label, offset };
+}
+function annotatetrace(input) {
+  const aligned = input.annotations.map((annotation) => {
+    const entry = input.timeline.find((item) => item.stepid === annotation.stepid);
+    if (entry === void 0) return annotation;
+    return { ...annotation, offset: Math.max(0, entry.time - input.trace.startedat) };
+  });
+  return { ...input.trace, annotations: aligned, endedat: Math.max(input.trace.endedat, input.now) };
+}
+function replaytrace(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error("The trace file is not valid json.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("The trace file is not a json object.");
+  const record2 = parsed;
+  const runid = typeof record2.runid === "string" ? record2.runid : "";
+  const annotations = Array.isArray(record2.annotations) ? record2.annotations.flatMap((item) => {
+    const annotation = annotationof(item);
+    return annotation !== void 0 ? [annotation] : [];
+  }) : [];
+  const rawevents = Array.isArray(record2.traceevents) ? record2.traceevents : [];
+  const categories = {};
+  const events = rawevents.flatMap((item) => {
+    if (!item || typeof item !== "object") return [];
+    const entry = item;
+    if (typeof entry.name !== "string" || typeof entry.cat !== "string" || typeof entry.offset !== "number") return [];
+    const offset = entry.offset;
+    categories[entry.cat] = (categories[entry.cat] ?? 0) + 1;
+    const annotation = annotations.find((candidate) => Math.abs(candidate.offset - offset) < 1);
+    return [{ name: entry.name, category: entry.cat, offset, ...annotation !== void 0 ? { stepid: annotation.stepid } : {} }];
+  });
+  return { traceid: typeof record2.id === "string" ? record2.id : "", runid, categories, events, annotations };
+}
+function mapurlof(scripturl, source) {
+  const match = /[#@]\s*sourceMappingURL=(\S+)/.exec(source);
+  if (match === null || match[1] === void 0) return void 0;
+  try {
+    return new URL(match[1], scripturl).toString();
+  } catch {
+    return void 0;
+  }
+}
+function capturesourcemaps(input) {
+  return input.scripts.flatMap((script) => {
+    const mapurl = mapurlof(script.url, script.source);
+    if (mapurl === void 0) return [];
+    return [{ id: `${input.runid}-${script.url}`, runid: input.runid, stepid: input.stepid, origin: input.origin, scripturl: script.url, mapurl, parsed: false, at: input.now }];
+  });
+}
+function decodevlq(segment) {
+  const values = [];
+  let shift = 0;
+  let value = 0;
+  for (const character of segment) {
+    const digit = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".indexOf(character);
+    if (digit < 0) return void 0;
+    value += (digit & 31) << shift;
+    shift += 5;
+    if ((digit & 32) === 0) {
+      const negative = (value & 1) === 1;
+      values.push(negative ? -(value >>> 1) : value >>> 1);
+      value = 0;
+      shift = 0;
+    }
+  }
+  return values.length > 0 ? values : void 0;
+}
+function rewritesourcelocation(input, map) {
+  const sources = Array.isArray(map.sources) ? map.sources.filter((source2) => typeof source2 === "string") : [];
+  if (sources.length === 0 || typeof map.mappings !== "string" || map.mappings.length === 0) return void 0;
+  const lines = map.mappings.split(";");
+  if (input.line >= lines.length) return void 0;
+  let sourceindex = 0;
+  let sourceline = 0;
+  for (let line = 0; line <= input.line; line += 1) {
+    const linemappings = lines[line];
+    if (linemappings === void 0) continue;
+    const first = linemappings.split(",")[0] ?? "";
+    if (first.length === 0) continue;
+    const values = decodevlq(first);
+    if (values === void 0 || values.length < 4) continue;
+    sourceindex = Math.max(0, sourceindex + (values[1] ?? 0));
+    sourceline = Math.max(0, sourceline + (values[2] ?? 0));
+  }
+  const targetmappings = lines[input.line];
+  const target = targetmappings !== void 0 ? targetmappings.split(",")[0] ?? "" : "";
+  if (target.length === 0) return void 0;
+  const source = sources[Math.min(sources.length - 1, sourceindex)];
+  if (source === void 0) return void 0;
+  return { url: source, line: sourceline };
+}
+function expireprofilerecords(input) {
+  const retention = input.retention;
+  if (retention === void 0) return { heaps: input.heaps, profiles: input.profiles, traces: input.traces };
+  const expired = (at) => input.now - at > retention;
+  return {
+    heaps: input.heaps.map((heap) => expired(heap.capturedat) && heap.bytesexpired !== true ? { ...heap, bytesexpired: true } : heap),
+    profiles: input.profiles.map((profile) => expired(profile.at) && profile.samplesexpired !== true ? { ...profile, samplesexpired: true } : profile),
+    traces: input.traces.map((trace) => expired(trace.endedat) && trace.bytesexpired !== true ? { ...trace, bytesexpired: true } : trace)
+  };
+}
+
 // memory.ts
 var sessionmemory = class {
   constructor(adapter) {
@@ -1912,6 +2275,108 @@ var sessionmemory = class {
   async getconsoleconsents() {
     return await this.adapter.get("consoleconsents") ?? [];
   }
+  /** Stores one devtools session record with its enabled domains and detach state, replacing the previous record of its id. */
+  async setcdpsession(session) {
+    const records = (await this.adapter.get("cdpsessions") ?? []).filter((item) => item.id !== session.id);
+    await this.adapter.set("cdpsessions", [session, ...records]);
+  }
+  /** Returns every stored devtools session record, newest first. */
+  async getcdpsessions() {
+    return await this.adapter.get("cdpsessions") ?? [];
+  }
+  /** Stores one raw command outcome with its duration and error class. */
+  async addcdpcommand(command) {
+    const records = await this.adapter.get("cdpcommands") ?? [];
+    await this.adapter.set("cdpcommands", [command, ...records]);
+  }
+  /** Returns every stored raw command outcome, newest first. */
+  async getcdpcommands() {
+    return await this.adapter.get("cdpcommands") ?? [];
+  }
+  /** Stores one domain event rule with its match filter, replacing the previous rule of its id. */
+  async setcdpeventrule(rule) {
+    const records = (await this.adapter.get("cdpeventrules") ?? []).filter((item) => item.id !== rule.id);
+    await this.adapter.set("cdpeventrules", [rule, ...records]);
+  }
+  /** Returns every stored domain event rule, newest first. */
+  async getcdpeventrules() {
+    return await this.adapter.get("cdpeventrules") ?? [];
+  }
+  /** Stores one breakpoint record with its condition and hit counter, replacing the previous record of its id. */
+  async addbreakpoint(spec) {
+    const records = (await this.adapter.get("breakpoints") ?? []).filter((item) => item.id !== spec.id);
+    await this.adapter.set("breakpoints", [spec, ...records]);
+  }
+  /** Returns every stored breakpoint record, newest first. */
+  async getbreakpoints() {
+    return await this.adapter.get("breakpoints") ?? [];
+  }
+  /** Stores one pause state capture; the user configured pause retention window expires the call frames and the dom snapshot reference of the oldest captures while the pause reason and hit breakpoint survive. */
+  async addpause(pause) {
+    const records = await this.getpauses();
+    const combined = [pause, ...records.filter((item) => item.id !== pause.id)];
+    const retention = (await this.getsettings())?.pauseretention;
+    if (retention === void 0) {
+      await this.adapter.set("pauses", combined);
+      return;
+    }
+    const kept = combined.slice(0, retention);
+    const expired = combined.slice(retention).map((item) => {
+      if (item.framesexpired === true) return item;
+      const faded = { ...item, callframes: [], framesexpired: true };
+      delete faded.domsnapshotid;
+      return faded;
+    });
+    await this.adapter.set("pauses", [...kept, ...expired]);
+  }
+  /** Returns every stored pause state capture, newest first. */
+  async getpauses() {
+    return await this.adapter.get("pauses") ?? [];
+  }
+  /** Returns the pause state captures of one run, newest first. */
+  async listpauses(runid) {
+    const records = await this.getpauses();
+    return records.filter((item) => item.runid === runid);
+  }
+  /** Stores one watch expression with its per pause values, replacing the previous expression of its id. */
+  async setwatchexpression(expression) {
+    const records = (await this.adapter.get("watchexpressions") ?? []).filter((item) => item.id !== expression.id);
+    await this.adapter.set("watchexpressions", [expression, ...records]);
+  }
+  /** Returns every stored watch expression, newest first. */
+  async getwatchexpressions() {
+    return await this.adapter.get("watchexpressions") ?? [];
+  }
+  /** Stores one script override with its review provenance, replacing the previous override of its id. */
+  async addscriptoverride(spec) {
+    const records = (await this.adapter.get("scriptoverrides") ?? []).filter((item) => item.id !== spec.id);
+    await this.adapter.set("scriptoverrides", [spec, ...records]);
+  }
+  /** Returns every stored script override, newest first. */
+  async getscriptoverrides() {
+    return await this.adapter.get("scriptoverrides") ?? [];
+  }
+  /** Stores one debugger consent decision per origin with the consented domain list, replacing the previous decision of its id. */
+  async setdebuggergrant(grant) {
+    const records = (await this.adapter.get("debuggergrants") ?? []).filter((item) => item.id !== grant.id);
+    await this.adapter.set("debuggergrants", [grant, ...records]);
+  }
+  /** Returns every debugger consent decision, newest first. */
+  async getdebuggergrants() {
+    return await this.adapter.get("debuggergrants") ?? [];
+  }
+  /** Revokes every approved debugger consent of one origin: the revoke time stamps the records so the next attach needs a new reviewed prompt. */
+  async revokedebuggergrants(origin, at) {
+    const records = await this.getdebuggergrants();
+    let revoked = 0;
+    const updated = records.map((grant) => {
+      if (grant.origin !== origin || grant.revokedat !== void 0) return grant;
+      revoked += 1;
+      return { ...grant, revokedat: at };
+    });
+    await this.adapter.set("debuggergrants", updated);
+    return revoked;
+  }
   /** 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();
@@ -1925,6 +2390,133 @@ var sessionmemory = class {
   async getlevelsummaries() {
     return await this.adapter.get("levelsummaries") ?? [];
   }
+  /** Stores one measured flow metric of the run beside its step span; the flow series stays per run. */
+  async addflowmetric(metric) {
+    const records = await this.getflowmetrics();
+    await this.adapter.set("flowmetrics", [metric, ...records]);
+  }
+  /** Returns every stored flow metric, newest first. */
+  async getflowmetrics() {
+    return await this.adapter.get("flowmetrics") ?? [];
+  }
+  /** Returns the flow metrics of one run, newest first. */
+  async listflowmetrics(runid) {
+    const records = await this.getflowmetrics();
+    return records.filter((metric) => metric.runid === runid);
+  }
+  /** Stores one heap snapshot record with its byte and node counts; the user configured profile retention window expires the heavy snapshot bytes while the counts survive. */
+  async setheaprecord(heap) {
+    const records = (await this.adapter.get("heaprecords") ?? []).filter((item) => item.id !== heap.id);
+    const retention = (await this.getsettings())?.profileretention;
+    const { heaps } = expireprofilerecords({ heaps: [heap, ...records], profiles: [], traces: [], retention, now: Date.now() });
+    await this.adapter.set("heaprecords", heaps);
+  }
+  /** Returns every stored heap snapshot record, newest first. */
+  async getheaprecords() {
+    return await this.adapter.get("heaprecords") ?? [];
+  }
+  /** Stores one heap growth sample taken beside a step. */
+  async addgrowsample(sample) {
+    const records = await this.adapter.get("growsamples") ?? [];
+    await this.adapter.set("growsamples", [sample, ...records]);
+  }
+  /** Returns every stored heap growth sample, newest first. */
+  async getgrowsamples() {
+    return await this.adapter.get("growsamples") ?? [];
+  }
+  /** Returns the heap growth samples of one run, newest first. */
+  async listgrowsamples(runid) {
+    const records = await this.getgrowsamples();
+    return records.filter((sample) => sample.runid === runid);
+  }
+  /** Stores one computed heap growth trend of a run with its slope and flagged steps, replacing the previous trend of the run. */
+  async settrend(trend) {
+    const records = await this.adapter.get("memorytrends") ?? [];
+    await this.adapter.set("memorytrends", [trend, ...records.filter((item) => item.runid !== trend.runid)]);
+  }
+  /** Returns every stored heap growth trend, newest first. */
+  async gettrends() {
+    return await this.adapter.get("memorytrends") ?? [];
+  }
+  /** Stores one cpu profile record with its sample count and hot function list; the profile retention window expires the heavy sample payload while the counts and hot functions survive. */
+  async setcpuprofile(profile) {
+    const records = (await this.adapter.get("cpuprofiles") ?? []).filter((item) => item.id !== profile.id);
+    const retention = (await this.getsettings())?.profileretention;
+    const { profiles } = expireprofilerecords({ heaps: [], profiles: [profile, ...records], traces: [], retention, now: Date.now() });
+    await this.adapter.set("cpuprofiles", profiles);
+  }
+  /** Returns every stored cpu profile record, newest first. */
+  async getcpuprofiles() {
+    return await this.adapter.get("cpuprofiles") ?? [];
+  }
+  /** Stores one layout shift entry with its score and impacted selectors. */
+  async addshiftentry(entry) {
+    const records = await this.adapter.get("shiftentries") ?? [];
+    await this.adapter.set("shiftentries", [entry, ...records]);
+  }
+  /** Returns every stored layout shift entry, newest first. */
+  async getshiftentries() {
+    return await this.adapter.get("shiftentries") ?? [];
+  }
+  /** Stores one trace record with its category list, byte size and step annotations; the profile retention window expires the heavy trace bytes while the metadata and annotations survive. */
+  async settracerecord(trace) {
+    const records = (await this.adapter.get("tracerecords") ?? []).filter((item) => item.id !== trace.id);
+    const retention = (await this.getsettings())?.profileretention;
+    const { traces } = expireprofilerecords({ heaps: [], profiles: [], traces: [trace, ...records], retention, now: Date.now() });
+    await this.adapter.set("tracerecords", traces);
+  }
+  /** Returns every stored trace record, newest first. */
+  async gettracerecords() {
+    return await this.adapter.get("tracerecords") ?? [];
+  }
+  /** Returns the trace records filtered by run and applied categories. */
+  async listtraces(filter) {
+    const records = await this.gettracerecords();
+    return records.filter((trace) => (filter.runid === void 0 || trace.runid === filter.runid) && (filter.categories === void 0 || filter.categories.every((category) => trace.categories.includes(category))));
+  }
+  /** Stores the exported file content of one trace beside its record; the retention window drops the file bytes of expired traces while the record survives. */
+  async settracefile(traceid, content) {
+    const records = (await this.adapter.get("tracefiles") ?? []).filter((item) => item.traceid !== traceid);
+    const trace = (await this.gettracerecords()).find((item) => item.id === traceid);
+    const retention = (await this.getsettings())?.profileretention;
+    const kept = retention === void 0 || trace === void 0 || Date.now() - trace.endedat <= retention ? [{ traceid, content, savedat: Date.now() }, ...records] : records;
+    await this.adapter.set("tracefiles", kept);
+  }
+  /** Returns the exported file content of one trace, or undefined when the retention window dropped the bytes. */
+  async gettracefile(traceid) {
+    const records = await this.adapter.get("tracefiles") ?? [];
+    return records.find((item) => item.traceid === traceid)?.content;
+  }
+  /** Stores one source map reference of a run with its script url, map url and parsed state. */
+  async setsourcemapref(ref) {
+    const records = (await this.adapter.get("sourcemaprefs") ?? []).filter((item) => item.id !== ref.id);
+    await this.adapter.set("sourcemaprefs", [ref, ...records]);
+  }
+  /** Returns every stored source map reference, newest first. */
+  async getsourcemaps() {
+    return await this.adapter.get("sourcemaprefs") ?? [];
+  }
+  /** Stores one source map capture consent decision per origin, replacing the previous decision of its id. */
+  async setsourcemapconsent(consent) {
+    const records = (await this.adapter.get("sourcemapconsents") ?? []).filter((item) => item.id !== consent.id);
+    await this.adapter.set("sourcemapconsents", [consent, ...records]);
+  }
+  /** Returns every source map capture consent decision, newest first. */
+  async getsourcemapconsents() {
+    return await this.adapter.get("sourcemapconsents") ?? [];
+  }
+  /** Revokes every approved source map consent of one origin so the next capture needs a new reviewed prompt. */
+  async revokesourcemapconsents(origin, at) {
+    const records = await this.getsourcemapconsents();
+    let revoked = 0;
+    const updated = records.map((consent) => {
+      if (consent.origin !== origin || consent.revokedat !== void 0) return consent;
+      revoked += 1;
+      return { ...consent, revokedat: at };
+    });
+    await this.adapter.set("sourcemapconsents", updated);
+    return revoked;
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -2464,7 +3056,7 @@ function extractvalues(body, paths) {
 // runtimeline.ts
 var timelinekinds = ["watchconsole", "watcherrors", "watchtasks"];
 var loglevels = ["error", "warn", "info", "log", "debug", "trace"];
-var timelinesources = ["console", "error", "rejection", "resource", "longtask", "network"];
+var timelinesources = ["console", "error", "rejection", "resource", "longtask", "network", "cdp"];
 function levelrank(level) {
   return loglevels.indexOf(level);
 }
@@ -2871,9 +3463,9 @@ function polldecision(input) {
 }
 
 // policy.ts
-var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts", "recordscreen", "captureaudio", "downloadimages", "callrest", "callgraphql", "sendmessage", "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", "watchconsole", "watcherrors", "watchtasks"]);
+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", "attachcdp", "detachcdp", "cdpcmd", "overridescript", "heapshot", "profilecpu", "capturesourcemaps"]);
+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", "setbreakpoint", "stepcode", "watchexpr"]);
+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", "watchcdp", "measureflow", "trackmemory", "watchshifts", "traceload", "annotatetrace", "replaytrace"]);
 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"]);
@@ -2890,6 +3482,8 @@ var socketactions = /* @__PURE__ */ new Set(["opensocket", "sendmessage", "waitm
 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 cdpactions = /* @__PURE__ */ new Set(["attachcdp", "detachcdp", "cdpcmd", "watchcdp", "setbreakpoint", "stepcode", "watchexpr", "overridescript"]);
+var profileractions = /* @__PURE__ */ new Set(["measureflow", "heapshot", "trackmemory", "profilecpu", "watchshifts", "traceload", "annotatetrace", "replaytrace", "capturesourcemaps"]);
 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"]);
@@ -2911,8 +3505,14 @@ function iswatchkind(kind) {
 function isdebugkind(kind) {
   return debugactions.has(kind);
 }
+function iscdpkind(kind) {
+  return cdpactions.has(kind);
+}
+function isprofilekind(kind) {
+  return profileractions.has(kind);
+}
 function observationmodeof(kind) {
-  if (watchactions.has(kind) || debugactions.has(kind) || kind === "waitquiet") return "watching";
+  if (watchactions.has(kind) || debugactions.has(kind) || profileractions.has(kind) && kind !== "heapshot" && kind !== "replaytrace" && kind !== "annotatetrace" && kind !== "capturesourcemaps" && kind !== "profilecpu" || cdpactions.has(kind) && kind === "watchcdp" || kind === "waitquiet") return "watching";
   if (kind === "diffsnapshots") return "diffing";
   return "passive";
 }
@@ -4126,6 +4726,215 @@ function rotationruleof(value) {
   if (maxentries === void 0 || overflowtarget === void 0) return void 0;
   return { maxentries, overflowtarget };
 }
+function debuggate(session, tabid, origin, now) {
+  if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the devtools protocol step." };
+  if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot run a devtools protocol step." };
+  if (session.pausedat) return { allowed: false, reason: "The browser session is paused and cannot run a devtools protocol step." };
+  if (session.tabid !== tabid) return { allowed: false, reason: `The devtools protocol step needs the run tab ${session.tabid} and refuses tab ${tabid}.` };
+  if (!origingranted(session, origin)) return { allowed: false, reason: `The devtools protocol step on ${origin} needs the session origin grants first.` };
+  return { allowed: true };
+}
+function debuggerconsentcovers(origin, domains, grants) {
+  const needed = [...new Set(domains)];
+  const covering = grants.find((grant) => grant.origin === origin && grant.approved === true && grant.revokedat === void 0 && needed.every((domain) => grant.domains.includes(domain)));
+  if (covering) return { allowed: true };
+  if (grants.some((grant) => grant.origin === origin && grant.revokedat !== void 0)) return { allowed: false, reason: `The debugger consent on ${origin} was revoked; approve a new prompt before the devtools protocol runs again.` };
+  return { allowed: false, reason: `The devtools protocol on ${origin} needs the reviewed debugger consent for ${needed.join(", ")} first; approve the prompt with the domain allowlist shown in the review panel.` };
+}
+function targetgate(input) {
+  const base = debuggate(input.session, input.tabid, input.origin, input.now);
+  if (!base.allowed) return base;
+  for (const target of input.targets) {
+    if (target.kind === "page") continue;
+    const origincheckresult = origincheck(input.session, target.url);
+    if (!origincheckresult.allowed) return { allowed: false, reason: `The ${target.kind} target ${target.url} stays outside the granted origins; profiling refuses to attach.` };
+  }
+  if (input.grants === void 0) return { allowed: true };
+  const consent = debuggerconsentcovers(input.origin, [], input.grants);
+  if (!consent.allowed) return { allowed: false, reason: `The profiling step on ${input.origin} needs the reviewed debugger grant of the origin first; approve the prompt with the profiling derivation shown in the review panel.` };
+  return { allowed: true };
+}
+function sourcemapconsentcovers(origin, consents) {
+  const covering = consents.find((consent) => consent.origin === origin && consent.approved === true && consent.revokedat === void 0);
+  if (covering) return { allowed: true };
+  if (consents.some((consent) => consent.origin === origin && consent.revokedat !== void 0)) return { allowed: false, reason: `The source map capture consent on ${origin} was revoked; approve a new prompt before another map file is fetched.` };
+  return { allowed: false, reason: `The source map capture on ${origin} needs the reviewed per origin consent first; approve the prompt shown in the review panel.` };
+}
+function profileretentionwindow(settings) {
+  return settings?.profileretention;
+}
+function traceceilingof(settings) {
+  return settings?.traceceiling;
+}
+function validatebreakpointcondition(condition) {
+  const expression = condition.trim();
+  if (expression.length === 0) return { allowed: false, reason: "The breakpoint condition must not be empty." };
+  if (/(?<![=!<>])=(?!=)/.test(expression)) return { allowed: false, reason: "Breakpoint conditions refuse assignment because the reviewed grammar is comparison only." };
+  if (/[A-Za-z_$][\w$]*\s*\(/.test(expression)) return { allowed: false, reason: "Breakpoint conditions refuse calls because the reviewed grammar is comparison only." };
+  const literal = /^(?:-?\d+(?:\.\d+)?|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|true|false|null)$/;
+  const tokens = expression.match(/(?:[A-Za-z_$][\w$]*|-?\d+(?:\.\d+)?|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|===|!==|==|!=|>=|<=|&&|\|\||[!.<>()+\-*\/%])/g);
+  if (tokens === null || tokens.join("") !== expression.replace(/\s+/g, "")) return { allowed: false, reason: "The breakpoint condition must use the reviewed expression grammar of member chains, literals, comparisons, logic operators, negation and parentheses." };
+  const identifierlike = /^(?:true|false|null)$/;
+  for (const token of tokens) {
+    if (literal.test(token) || identifierlike.test(token)) continue;
+    if (["===", "!==", "==", "!=", ">=", "<=", "&&", "||", "!", ".", "(", ")", "<", ">", "+", "-", "*", "/", "%"].includes(token)) continue;
+    if (/^[A-Za-z_$][\w$]*$/.test(token)) continue;
+    return { allowed: false, reason: `The token ${token} of the breakpoint condition stays outside the reviewed expression grammar.` };
+  }
+  return { allowed: true };
+}
+function breakpointbudgetallowed(active, ceiling) {
+  if (ceiling === void 0) return { allowed: true };
+  if (typeof ceiling !== "number" || !Number.isInteger(ceiling) || ceiling < 0) return { allowed: false, reason: "The reviewed breakpoint ceiling must be zero or a positive integer of user configured value with no code ceiling." };
+  if (active >= ceiling) return { allowed: false, reason: `The run already holds ${active} active breakpoint${active === 1 ? "" : "s"} and the reviewed breakpoint ceiling is ${ceiling}; revert one or review a wider ceiling.` };
+  return { allowed: true };
+}
+function pauseretentionwindow(settings) {
+  return settings?.pauseretention;
+}
+function breakpointceilingof(settings) {
+  return settings?.breakpointceiling;
+}
+function validatecdpgrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "attachcdp") {
+    if (!Array.isArray(options.domains) || options.domains.length === 0 || !options.domains.every((domain) => typeof domain === "string" && cdpdomains.includes(domain))) return { allowed: false, reason: `The attach needs a non-empty enabled domain list of the reviewed domain grammar: ${cdpdomains.join(", ")}.` };
+    if (teardownplanof(options.teardown) === void 0) return { allowed: false, reason: "Every attach needs a reviewed teardown plan with its revert steps and resume policy before approval." };
+    if (options.allowlist !== void 0) {
+      const allowlist = cdpallowlistof(options.allowlist);
+      if (!allowlist || !allowlist.domains.every((domain) => options.domains.includes(domain))) return { allowed: false, reason: "The reviewed method allowlist must stay inside the enabled domains of the attach." };
+    }
+    const budgetcheck = debugwaitbudgetallowed(typeof options.wait === "number" ? options.wait : void 0, void 0);
+    if (!budgetcheck.allowed) return budgetcheck;
+    return { allowed: true };
+  }
+  if (kind === "detachcdp") return { allowed: true };
+  if (kind === "cdpcmd") {
+    const command = options.command && typeof options.command === "object" && !Array.isArray(options.command) ? options.command : void 0;
+    if (!command || typeof command.method !== "string" || methoddomain(command.method) === void 0) return { allowed: false, reason: "The raw command needs a reviewed method of the Domain.method form." };
+    if (command.params !== void 0 && (typeof command.params !== "object" || Array.isArray(command.params))) return { allowed: false, reason: "The raw command params must be a JSON object." };
+    if (command.resultpath !== void 0 && typeof command.resultpath !== "string") return { allowed: false, reason: "The reviewed result path must be a dotted path string." };
+    return { allowed: true };
+  }
+  if (kind === "watchcdp") {
+    if (!Array.isArray(options.events) || options.events.length === 0 || !options.events.every((rule) => cdpeventruleof(rule) !== void 0)) return { allowed: false, reason: "The event watch needs a non-empty reviewed list of domain event rules of the reviewed domain grammar." };
+    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 event 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 event watch window must be zero or a positive number of milliseconds." };
+        watchwindow = reviewed.window;
+      }
+    }
+    if (watchwindow === void 0) return { allowed: false, reason: "The event watch needs a reviewed lifetime window before any domain event is observed." };
+    const budgetcheck = debugwaitbudgetallowed(watchwindow, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budgetcheck.allowed) return budgetcheck;
+    return { allowed: true };
+  }
+  if (kind === "setbreakpoint") {
+    const breakpoint = breakpointinputof(options.breakpoint);
+    if (!breakpoint) return { allowed: false, reason: "The breakpoint needs a reviewed script url and a zero based line." };
+    if (!ishttpsurl(breakpoint.url)) return { allowed: false, reason: "The breakpoint script url must be a reviewed HTTPS url." };
+    if (breakpoint.condition !== void 0) {
+      const conditioncheck = validatebreakpointcondition(breakpoint.condition);
+      if (!conditioncheck.allowed) return conditioncheck;
+    }
+    return { allowed: true };
+  }
+  if (kind === "stepcode") {
+    if (stepmodeof(options.mode) === void 0) return { allowed: false, reason: "The step code mode must be one of stepover, stepinto, stepout or resume." };
+    return { allowed: true };
+  }
+  if (kind === "watchexpr") {
+    if (watchexpressionof(options.expression) === void 0) return { allowed: false, reason: "The watch expression needs the reviewed expression text." };
+    if (options.reviewed !== true) return { allowed: false, reason: "Watch expressions must be reviewed before evaluation; set the explicit reviewed flag on the step." };
+    return { allowed: true };
+  }
+  if (kind === "overridescript") {
+    const override = overrideinputof(options.override);
+    if (!override) return { allowed: false, reason: "The script override needs a reviewed url pattern and its full fixture source." };
+    if (patternorigin(override.urlpattern) === void 0) return { allowed: false, reason: "Script overrides without a named https origin pattern are refused." };
+    if (options.reviewed !== true) return { allowed: false, reason: "The full fixture source must be reviewed before the script override runs; set the explicit reviewed flag on the step." };
+    return { allowed: true };
+  }
+  return { allowed: true };
+}
+function validateprofilegrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "measureflow") {
+    if (flowspecof(options.flow) === void 0) return { allowed: false, reason: `The flow measurement needs a reviewed flow spec with its mark prefix, step window and metric list of the reviewed metric set: navigation, paint, lcp, fid, interaction, blocking.` };
+    const watch = options.watch && typeof options.watch === "object" && !Array.isArray(options.watch) ? options.watch : {};
+    if (typeof watch.window !== "number" || !Number.isFinite(watch.window) || watch.window < 0) return { allowed: false, reason: "The flow measurement needs a reviewed watch window of zero or more milliseconds." };
+    const budgetcheck = debugwaitbudgetallowed(watch.window, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budgetcheck.allowed) return budgetcheck;
+    return { allowed: true };
+  }
+  if (kind === "heapshot") {
+    const heap = options.heap && typeof options.heap === "object" && !Array.isArray(options.heap) ? options.heap : {};
+    if (heap.interval !== void 0 && (typeof heap.interval !== "number" || !Number.isFinite(heap.interval) || heap.interval < 0)) return { allowed: false, reason: "The reviewed heap snapshot interval must be zero or a positive number of milliseconds and stays a user choice with no code ceiling." };
+    return { allowed: true };
+  }
+  if (kind === "trackmemory") {
+    const growth = options.growth && typeof options.growth === "object" && !Array.isArray(options.growth) ? options.growth : void 0;
+    if (!growth || typeof growth.slope !== "number" || !Number.isFinite(growth.slope) || growth.slope < 0) return { allowed: false, reason: "Memory growth tracking needs the reviewed slope in bytes per millisecond before any sample is flagged." };
+    if (growth.interval !== void 0 && (typeof growth.interval !== "number" || !Number.isFinite(growth.interval) || growth.interval < 0)) return { allowed: false, reason: "The reviewed sampling interval must be zero or a positive number of milliseconds and stays a user choice with no code ceiling." };
+    return { allowed: true };
+  }
+  if (kind === "profilecpu") {
+    const profile = options.profile && typeof options.profile === "object" && !Array.isArray(options.profile) ? options.profile : void 0;
+    if (!profile || typeof profile.duration !== "number" || !Number.isFinite(profile.duration) || profile.duration < 0) return { allowed: false, reason: "The cpu profile needs a reviewed duration of zero or more milliseconds." };
+    const budgetcheck = debugwaitbudgetallowed(profile.duration, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budgetcheck.allowed) return budgetcheck;
+    return { allowed: true };
+  }
+  if (kind === "watchshifts") {
+    const watch = options.watch && typeof options.watch === "object" && !Array.isArray(options.watch) ? options.watch : {};
+    if (typeof watch.window !== "number" || !Number.isFinite(watch.window) || watch.window < 0) return { allowed: false, reason: "The layout shift watch needs a reviewed observation window of zero or more milliseconds; the window stays a user choice with no code ceiling." };
+    if (options.threshold !== void 0 && (typeof options.threshold !== "number" || !Number.isFinite(options.threshold) || options.threshold < 0)) return { allowed: false, reason: "The reviewed shift score threshold must be zero or a positive number." };
+    const budgetcheck = debugwaitbudgetallowed(watch.window, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budgetcheck.allowed) return budgetcheck;
+    return { allowed: true };
+  }
+  if (kind === "traceload") {
+    const trace = options.trace && typeof options.trace === "object" && !Array.isArray(options.trace) ? options.trace : void 0;
+    if (!trace || !Array.isArray(trace.categories) || trace.categories.length === 0 || !trace.categories.every((category) => typeof category === "string" && tracecategories.includes(category))) return { allowed: false, reason: `The trace record needs a non-empty reviewed category list of the reviewed category grammar: ${tracecategories.join(", ")}.` };
+    if (typeof trace.window !== "number" || !Number.isFinite(trace.window) || trace.window < 0) return { allowed: false, reason: "The trace record needs a reviewed window of zero or more milliseconds and stops at the reviewed window end." };
+    if (trace.exporttarget !== void 0 && trace.exporttarget !== "memory" && trace.exporttarget !== "download") return { allowed: false, reason: "The trace export target must be memory or download." };
+    const budgetcheck = debugwaitbudgetallowed(trace.window, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budgetcheck.allowed) return budgetcheck;
+    return { allowed: true };
+  }
+  if (kind === "annotatetrace" || kind === "replaytrace") {
+    const trace = options.trace && typeof options.trace === "object" && !Array.isArray(options.trace) ? options.trace : void 0;
+    if (!trace || typeof trace.traceid !== "string" || !trace.traceid.trim()) return { allowed: false, reason: `The ${kind === "annotatetrace" ? "trace annotation" : "trace replay"} needs the stored trace id of a recorded trace.` };
+    if (kind === "replaytrace") return { allowed: true };
+    if (!Array.isArray(options.annotations) || options.annotations.length === 0 || !options.annotations.every((annotation) => annotationof(annotation) !== void 0)) return { allowed: false, reason: "Exported traces carry their step annotations: every annotation needs a step id, a label and an optional offset from the trace start." };
+    return { allowed: true };
+  }
+  if (kind === "capturesourcemaps") {
+    if (options.scripts !== void 0) {
+      if (!Array.isArray(options.scripts) || options.scripts.length === 0 || !options.scripts.every((url) => typeof url === "string" && ishttpsurl(url))) return { allowed: false, reason: "The source map capture scripts must be a non-empty list of reviewed HTTPS urls." };
+    }
+    return { allowed: true };
+  }
+  return { allowed: true };
+}
+function planallowlist(steps) {
+  const attach = steps.find((step) => step.kind === "attachcdp");
+  if (!attach) return void 0;
+  let options = {};
+  try {
+    options = parseoptions(attach);
+  } catch {
+    options = {};
+  }
+  const domains = Array.isArray(options.domains) ? options.domains.filter((domain) => typeof domain === "string" && cdpdomains.includes(domain)) : [];
+  if (domains.length === 0) return void 0;
+  const gated = cdpallowlistof(options.allowlist);
+  return { domains, ...gated?.methods !== void 0 ? { methods: gated.methods } : {} };
+}
 function controltarget(step) {
   let options = {};
   try {
@@ -4535,6 +5344,14 @@ function validatestep(step, origin) {
     const timelinecheck = validatetimelinegrammar(step, options);
     if (!timelinecheck.allowed) return timelinecheck;
   }
+  if (iscdpkind(step.kind)) {
+    const cdpcheck = validatecdpgrammar(step, options);
+    if (!cdpcheck.allowed) return cdpcheck;
+  }
+  if (isprofilekind(step.kind)) {
+    const profilecheck = validateprofilegrammar(step, options);
+    if (!profilecheck.allowed) return profilecheck;
+  }
   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." };
@@ -4640,6 +5457,70 @@ function canexecute(input) {
     const timelinegatecheck = timelinegate(input.session, input.tabid, input.origin, now);
     if (!timelinegatecheck.allowed) return timelinegatecheck;
   }
+  if (iscdpkind(input.step.kind)) {
+    const debuggatecheck = debuggate(input.session, input.tabid, input.origin, now);
+    if (!debuggatecheck.allowed) return debuggatecheck;
+    if (!input.plan) return { allowed: false, reason: "The devtools protocol steps need an approved plan." };
+    const allowlist = planallowlist(input.plan.steps);
+    if (input.step.kind !== "attachcdp") {
+      if (allowlist === void 0) return { allowed: false, reason: "The devtools protocol step needs the attachcdp step of the same plan with its enabled domains first." };
+      if (input.step.kind === "cdpcmd") {
+        let cdpoptions2 = {};
+        try {
+          cdpoptions2 = parseoptions(input.step);
+        } catch {
+          cdpoptions2 = {};
+        }
+        const command = cdpoptions2.command && typeof cdpoptions2.command === "object" && !Array.isArray(cdpoptions2.command) ? cdpoptions2.command : void 0;
+        const method = typeof command?.method === "string" ? command.method : "";
+        if (methoddomain(method) === void 0 || !allowlistcovers(allowlist, method)) return { allowed: false, reason: `The raw command ${method || ""} stays outside the enabled domain allowlist of the plan attach; review the attach domains or the method gates.` };
+      }
+    }
+    let cdpoptions = {};
+    try {
+      cdpoptions = parseoptions(input.step);
+    } catch {
+      cdpoptions = {};
+    }
+    if (input.step.kind === "setbreakpoint") {
+      const breakpoint = breakpointinputof(cdpoptions.breakpoint);
+      if (breakpoint) {
+        const targetgate2 = origincheck(input.session, breakpoint.url);
+        if (!targetgate2.allowed) return targetgate2;
+      }
+    }
+    if (input.step.kind === "overridescript") {
+      const override = overrideinputof(cdpoptions.override);
+      if (override) {
+        const targetgate2 = origincheck(input.session, override.urlpattern);
+        if (!targetgate2.allowed) return targetgate2;
+      }
+    }
+  }
+  if (isprofilekind(input.step.kind)) {
+    let profileoptions = {};
+    try {
+      profileoptions = parseoptions(input.step);
+    } catch {
+      profileoptions = {};
+    }
+    const targets = [
+      ...attachtargetof(profileoptions.target) !== void 0 ? [attachtargetof(profileoptions.target)] : [],
+      ...Array.isArray(profileoptions.attachtargets) ? profileoptions.attachtargets.flatMap((target) => {
+        const parsed = attachtargetof(target);
+        return parsed !== void 0 ? [parsed] : [];
+      }) : []
+    ];
+    const targetgatecheck = targetgate({ session: input.session, tabid: input.tabid, origin: input.origin, targets, grants: void 0, now });
+    if (!targetgatecheck.allowed) return targetgatecheck;
+    if (input.step.kind === "capturesourcemaps") {
+      for (const url of Array.isArray(profileoptions.scripts) ? profileoptions.scripts : []) {
+        if (typeof url !== "string") continue;
+        const scriptgate = origincheck(input.session, url);
+        if (!scriptgate.allowed) return scriptgate;
+      }
+    }
+  }
   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;
@@ -4685,8 +5566,8 @@ function canexecute(input) {
     }
     const target = controltarget(input.step);
     if (target !== void 0) {
-      const targetgate = origincheck(input.session, target);
-      if (!targetgate.allowed) return targetgate;
+      const targetgate2 = origincheck(input.session, target);
+      if (!targetgate2.allowed) return targetgate2;
     }
   }
   if (input.step.kind === "extractapi") {
@@ -4723,7 +5604,7 @@ function canexecute(input) {
 }
 
 // version.ts
-var packageversion = "1.1.45";
+var packageversion = "1.1.47";
 
 // types.ts
 var protocolversion = packageversion;
@@ -4748,6 +5629,20 @@ function parseproposal(value, origin, grants) {
   const expiresat = typeof planinput.expiresat === "number" ? planinput.expiresat : createdat + 10 * 60 * 1e3;
   if (expiresat <= createdat) throw new Error("Plan expiry must be in the future.");
   const planwindow = expiresat - createdat;
+  const attachinput = stepsinput.map((input) => record(input)).find((candidate) => candidate.kind === "attachcdp");
+  let planallowlist2;
+  if (attachinput !== void 0) {
+    const attachoptions = (() => {
+      try {
+        return parseoptions({ id: "attach", kind: "attachcdp", summary: "attach", risk: "sensitive", ...typeof attachinput.options === "string" ? { options: attachinput.options } : {} });
+      } catch {
+        return {};
+      }
+    })();
+    const domains = Array.isArray(attachoptions.domains) ? attachoptions.domains.filter((domain) => typeof domain === "string" && cdpdomains.includes(domain)) : [];
+    const gated = cdpallowlistof(attachoptions.allowlist);
+    planallowlist2 = domains.length > 0 ? { domains, ...gated?.methods !== void 0 ? { methods: gated.methods } : {} } : void 0;
+  }
   const steps = stepsinput.map((input, index) => {
     const candidate = record(input);
     const kind = text(candidate.kind, `step ${index + 1} kind`);
@@ -4798,6 +5693,89 @@ function parseproposal(value, origin, grants) {
       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(", ")}.`);
     }
+    if (iscdpkind(step.kind)) {
+      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} step of ${origin} targets an origin outside the grants.`);
+      let cdpoptions = {};
+      try {
+        cdpoptions = parseoptions(step);
+      } catch {
+        cdpoptions = {};
+      }
+      if (step.kind === "attachcdp") {
+        if (teardownplanof(cdpoptions.teardown) === void 0) throw new Error("Attach steps without a reviewed teardown plan are refused.");
+        const domains = Array.isArray(cdpoptions.domains) ? cdpoptions.domains.filter((domain) => typeof domain === "string" && cdpdomains.includes(domain)) : [];
+        if (domains.length === 0) throw new Error("Attach steps need a non-empty enabled domain list of the reviewed domain grammar.");
+        const gated = cdpallowlistof(cdpoptions.allowlist);
+        if (cdpoptions.allowlist !== void 0 && (!gated || !gated.domains.every((domain) => domains.includes(domain)))) throw new Error("The reviewed method allowlist must stay inside the enabled domains of the attach.");
+      }
+      if (step.kind === "cdpcmd") {
+        const command = cdpoptions.command && typeof cdpoptions.command === "object" && !Array.isArray(cdpoptions.command) ? cdpoptions.command : void 0;
+        const method = typeof command?.method === "string" ? command.method : "";
+        if (methoddomain(method) === void 0) throw new Error("Raw commands need a reviewed method of the Domain.method form.");
+        if (planallowlist2 === void 0) throw new Error("Raw command steps need the attachcdp step of the same plan with its enabled domains first.");
+        if (!allowlistcovers(planallowlist2, method)) throw new Error(`The raw command ${method} stays outside the enabled domain allowlist of the plan attach.`);
+      }
+    }
+    if (isprofilekind(step.kind)) {
+      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} step of ${origin} targets an origin outside the grants.`);
+      let profileoptions = {};
+      try {
+        profileoptions = parseoptions(step);
+      } catch {
+        profileoptions = {};
+      }
+      const targets = [
+        ...attachtargetof(profileoptions.target) !== void 0 ? [attachtargetof(profileoptions.target)] : [],
+        ...Array.isArray(profileoptions.attachtargets) ? profileoptions.attachtargets.flatMap((target2) => {
+          const parsed = attachtargetof(target2);
+          return parsed !== void 0 ? [parsed] : [];
+        }) : []
+      ];
+      for (const target2 of targets) {
+        if (target2.kind === "page") continue;
+        const targetgranted = covered.some((pattern) => {
+          try {
+            return new URL(target2.url).origin === new URL(pattern).origin;
+          } catch {
+            return false;
+          }
+        });
+        if (!targetgranted) throw new Error(`The ${target2.kind} target ${target2.url} of the ${step.kind} step stays outside the granted origins.`);
+      }
+      if (step.kind === "traceload") {
+        const trace = profileoptions.trace && typeof profileoptions.trace === "object" && !Array.isArray(profileoptions.trace) ? profileoptions.trace : void 0;
+        const categories = trace !== void 0 && Array.isArray(trace.categories) ? trace.categories : [];
+        if (categories.some((category) => typeof category !== "string" || !tracecategories.includes(category))) throw new Error(`Trace categories outside the reviewed list are refused: ${tracecategories.join(", ")}.`);
+      }
+      if (step.kind === "capturesourcemaps") {
+        for (const url of Array.isArray(profileoptions.scripts) ? profileoptions.scripts : []) {
+          if (typeof url !== "string") continue;
+          const scriptgranted = covered.some((pattern) => {
+            try {
+              return new URL(url).origin === new URL(pattern).origin;
+            } catch {
+              return false;
+            }
+          });
+          if (!scriptgranted) throw new Error(`The source map capture of ${url} targets an origin outside the grants.`);
+        }
+      }
+      if (step.kind === "annotatetrace" && (!Array.isArray(profileoptions.annotations) || profileoptions.annotations.length === 0 || !profileoptions.annotations.every((annotation) => annotationof(annotation) !== void 0))) throw new Error("Trace annotation steps without reviewed step annotations are refused.");
+    }
     const evaluation = validatestep(step, origin);
     if (!evaluation.allowed) throw new Error(evaluation.reason);
     const target = outboundtarget(step);
@@ -4872,7 +5850,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 } : {}, ...input.timeline ? { timeline: input.timeline } : {} });
+  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 } : {}, ...input.cdp ? { cdp: input.cdp } : {}, ...input.profile ? { profile: input.profile } : {} });
 }
 function mapresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
@@ -4989,7 +5967,31 @@ function timelinereport(input) {
 function consolediffreport(input) {
   return { version: protocolversion, diff: input.diff };
 }
+function cdpreport(input) {
+  const overrides = input.overrides.map((spec) => {
+    const { source, ...metadata } = spec;
+    void source;
+    return metadata;
+  });
+  const grants = input.grants.map((grant) => {
+    const { prompt, ...metadata } = grant;
+    void prompt;
+    return metadata;
+  });
+  return { version: protocolversion, sessions: input.sessions, commands: input.commands, events: input.events, breakpoints: input.breakpoints, pauses: input.pauses, watches: input.watches, overrides, grants };
+}
+function profilereport(input) {
+  const consents = input.consents.map((consent) => {
+    const { prompt, ...metadata } = consent;
+    void prompt;
+    return metadata;
+  });
+  return { version: protocolversion, flows: input.flows, heaps: input.heaps, samples: input.samples, trends: input.trends, profiles: input.profiles, shifts: input.shifts, traces: input.traces, sourcemaps: input.sourcemaps, consents };
+}
 export {
+  allowlistcovers,
+  annotatetrace,
+  annotationof,
   annotationplanof,
   apientries,
   apikeyconsentgranted,
@@ -4997,6 +5999,8 @@ export {
   applyheaderules,
   argkind,
   assetentries,
+  attachcdpsession,
+  attachtargetof,
   attachtimeline,
   authconsentgranted,
   authorizeurl,
@@ -5007,6 +6011,9 @@ export {
   blockruleof,
   bodyfilterof,
   bodymatches,
+  breakpointbudgetallowed,
+  breakpointceilingof,
+  breakpointinputof,
   buildname,
   buildpdf,
   buildsheet,
@@ -5022,12 +6029,19 @@ export {
   captureformats,
   capturekinds,
   captureoptionsof,
+  capturepause,
   captureregion,
   capturereport,
+  capturesourcemaps,
   capturestates,
   capturestitched,
   capturetargets,
   capturevisible,
+  cdpallowlistof,
+  cdpdomains,
+  cdpeventruleof,
+  cdpkinds,
+  cdpreport,
   channeloptionsof,
   channelorigin,
   closechannel,
@@ -5044,13 +6058,17 @@ export {
   cookiegate,
   cookierecordof,
   correlationid,
+  cpusnap,
   croprect,
   crossesviewport,
   cursorfrom,
   datasetresponse,
+  debuggate,
+  debuggerconsentcovers,
   debugwaitbudgetallowed,
   dedupeimages,
   actionrisk as deriveactionrisk,
+  detachcdpsession,
   diffresponse,
   diffreviewgrade,
   downloadreport,
@@ -5058,6 +6076,7 @@ export {
   errorreportresponse,
   eventresponse,
   exchangesreport,
+  expireprofilerecords,
   extractionreport,
   extractvalues,
   failureclass,
@@ -5067,14 +6086,20 @@ export {
   filterexchanges,
   finishrecording,
   fixedheadermatch,
+  flowmetricnames,
+  flowspecof,
   formpayloadof,
   formreportresponse,
   frameinterval,
   generatedvalueallowed,
   graphqlopenvelope,
   graphqlrequestof,
+  growsampleof,
+  growthtrend,
   headerfilterof,
   headeruleof,
+  heapintervalallowed,
+  heapsnap,
   heldkeysreport,
   hostpattern,
   htmlqueriesof,
@@ -5082,10 +6107,12 @@ export {
   imagefilterof,
   imagematches,
   imagenames,
+  iscdpkind,
   iscontrolkind,
   isdebugkind,
   isformkind,
   isnetwatchkind,
+  isprofilekind,
   issocketkind,
   iswatchkind,
   jsonpathrulesof,
@@ -5096,12 +6123,15 @@ export {
   loglevels,
   longtaskcapture,
   mapresponse,
+  mapurlof,
   matchmessage,
   matchurlpattern,
+  measure,
   mediaentries,
   mediakinds,
   mediareport,
   messagefilterof,
+  methoddomain,
   mockfor,
   mockspecof,
   multipartchunks,
@@ -5122,6 +6152,8 @@ export {
   observationresponse,
   openchannel,
   outcomeresponse,
+  overrideinputof,
+  overridematches,
   pairexchange,
   pairstates,
   parsehtmlbody,
@@ -5130,6 +6162,7 @@ export {
   parsetokens,
   passwordconsentgranted,
   patternorigin,
+  pauseretentionwindow,
   payloadshapeof,
   payloadvalid,
   payloadwithdefaults,
@@ -5137,11 +6170,15 @@ export {
   pdfpagesize,
   pdfsegments,
   pdftextlayout,
+  planallowlist,
   pollcursorof,
   polldecision,
   pollurl,
   privatemime,
   profilegrantgranted,
+  profilereport,
+  profileretentionwindow,
+  profilerkinds,
   protocolversion,
   provenancereport,
   proxygate,
@@ -5158,10 +6195,12 @@ export {
   receivemessage,
   reconnectwaits,
   recordingoptionsof,
+  recordwatchvalue,
   redactconsoletext,
   redactedcookies,
   regionsteps,
   rejectioncapture,
+  replaytrace,
   replayurl,
   requestbody,
   resolutionverdict,
@@ -5170,30 +6209,40 @@ export {
   retryafterof,
   revertrule,
   revocationruleof,
+  rewritesourcelocation,
   rotatelogs,
   rotationruleof,
   safetyresponse,
   scaledrect,
   seamweights,
   selectorresponse,
+  sendcdpcommand,
   sendfetch,
   sequenceintegrity,
   serializearg,
+  serializecdpcommand,
   sessionmemory,
+  shiftentryof,
   signalsreport,
   socketgate,
   socketkinds,
+  sourcemapconsentcovers,
   spamdetect,
   spamruleof,
   sserequestheaders,
   stackframes,
   stackgate,
   statusclassof,
+  stepmodeof,
+  stepwindows,
   streamsummaries,
   streamwindowof,
   submitreviewgranted,
   subscriptionoptionsof,
   tabreportresponse,
+  targetgate,
+  teardowncdpsession,
+  teardownplanof,
   templateurl,
   thumbdirectiveof,
   thumbgeometry,
@@ -5204,16 +6253,23 @@ export {
   timelineretentionwindow,
   timelinesources,
   tokenrequest,
+  tracecategories,
+  traceceilingof,
+  tracestart,
+  tracetofile,
   trailreport,
   transformgrammar,
   unwrapgraphql,
   urlencodeform,
+  validatebreakpointcondition,
   validatefieldmatch,
   validateformrecord,
   validatestep,
   validatetargetref,
   validatevaluegen,
+  watchcdpevents,
   watcherdetached,
+  watchexpressionof,
   watchgate,
   wizardreport
 };