@wenathlan/extension 1.1.46 → 1.1.48

package/extension/dist/background.js

@@ -1,3 +1,379 @@
+// 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((window2) => window2.end >= start && window2.start <= end).map((window2) => window2.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 window2 of windows) {
+    if (!input.spec.metrics.includes("blocking")) break;
+    const blocking = input.entries.filter((entry) => entry.type === "longtask" && entry.start >= window2.start && entry.start <= window2.end).reduce((total, entry) => total + Math.max(0, entry.duration - 50), 0);
+    metrics.push({ id: `${input.runid}-${input.stepid}-blocking-${window2.stepid}`, runid: input.runid, stepid: input.stepid, name: "blocking", start: window2.start, end: window2.end, duration: blocking, steps: [window2.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)
+  };
+}
+
+// emulation.ts
+var emulationkinds = ["emulatedevice", "emulatenetwork", "emulatelocate", "setuseragent", "overridepermission", "blackboxscripts"];
+var browserpermissions = ["geolocation", "notifications", "camera", "microphone", "clipboard-read", "clipboard-write", "midi", "persistent-storage"];
+var permissionstates = ["granted", "denied", "prompt"];
+function familyofkind(kind) {
+  if (kind === "emulatedevice") return "device";
+  if (kind === "emulatenetwork") return "network";
+  if (kind === "emulatelocate") return "location";
+  if (kind === "setuseragent") return "agent";
+  if (kind === "overridepermission") return "permission";
+  if (kind === "blackboxscripts") return "blackbox";
+  return void 0;
+}
+function devicepresetof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const name = typeof entry.name === "string" && entry.name.trim() ? entry.name.trim() : void 0;
+  const width = typeof entry.width === "number" && Number.isInteger(entry.width) && entry.width > 0 ? entry.width : void 0;
+  const height = typeof entry.height === "number" && Number.isInteger(entry.height) && entry.height > 0 ? entry.height : void 0;
+  const pixelratio = typeof entry.pixelratio === "number" && Number.isFinite(entry.pixelratio) && entry.pixelratio > 0 ? entry.pixelratio : void 0;
+  if (name === void 0 || width === void 0 || height === void 0 || pixelratio === void 0) return void 0;
+  return { name, width, height, pixelratio, mobile: entry.mobile === true };
+}
+function networkpresetof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const name = typeof entry.name === "string" && entry.name.trim() ? entry.name.trim() : void 0;
+  const latency = typeof entry.latency === "number" && Number.isFinite(entry.latency) && entry.latency >= 0 ? entry.latency : void 0;
+  const download = typeof entry.download === "number" && Number.isFinite(entry.download) && entry.download >= 0 ? entry.download : void 0;
+  const upload = typeof entry.upload === "number" && Number.isFinite(entry.upload) && entry.upload >= 0 ? entry.upload : void 0;
+  if (name === void 0 || latency === void 0 || download === void 0 || upload === void 0) return void 0;
+  return { name, latency, download, upload, offline: entry.offline === true };
+}
+function locationpresetof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const name = typeof entry.name === "string" && entry.name.trim() ? entry.name.trim() : void 0;
+  const latitude = typeof entry.latitude === "number" && Number.isFinite(entry.latitude) ? entry.latitude : void 0;
+  const longitude = typeof entry.longitude === "number" && Number.isFinite(entry.longitude) ? entry.longitude : void 0;
+  const accuracy = typeof entry.accuracy === "number" && Number.isFinite(entry.accuracy) && entry.accuracy >= 0 ? entry.accuracy : void 0;
+  if (name === void 0 || latitude === void 0 || longitude === void 0 || accuracy === void 0) return void 0;
+  if (!locationrangevalid(latitude, longitude)) return void 0;
+  return { name, latitude, longitude, accuracy };
+}
+function agentpresetof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const name = typeof entry.name === "string" && entry.name.trim() ? entry.name.trim() : void 0;
+  const useragent = typeof entry.useragent === "string" ? entry.useragent : void 0;
+  const platform = typeof entry.platform === "string" && entry.platform.trim() ? entry.platform.trim() : void 0;
+  const brands = Array.isArray(entry.brands) ? entry.brands.filter((brand) => typeof brand === "string" && brand.trim().length > 0) : [];
+  if (name === void 0 || useragent === void 0 || platform === void 0 || brands.length === 0) return void 0;
+  if (!agentgrammarvalid(useragent)) return void 0;
+  return { name, useragent, platform, brands: [...new Set(brands)] };
+}
+function permissiongrantof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const name = typeof entry.name === "string" && browserpermissions.includes(entry.name) ? entry.name : void 0;
+  const state = typeof entry.state === "string" && permissionstates.includes(entry.state) ? entry.state : void 0;
+  if (name === void 0 || state === void 0) return void 0;
+  return { name, state, runscope: entry.runscope !== false };
+}
+function blackboxruleof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const urlpatterns = Array.isArray(entry.urlpatterns) ? entry.urlpatterns.filter((pattern) => typeof pattern === "string" && /^https:\/\//.test(pattern)) : [];
+  const tracescope = entry.tracescope;
+  if (urlpatterns.length === 0) return void 0;
+  if (tracescope !== "profiles" && tracescope !== "traces" && tracescope !== "both") return void 0;
+  return { urlpatterns: [...new Set(urlpatterns)], tracescope };
+}
+function revertplanof(value) {
+  const steps = Array.isArray(value) ? value.filter((step) => typeof step === "string" && step.trim().length > 0) : [];
+  return steps.length > 0 ? steps : void 0;
+}
+function newlayer(input) {
+  return { id: input.id, runid: input.runid, stepid: input.stepid, family: input.family, name: input.name, originscope: input.originscope, appliedat: input.at, ...input.prior !== void 0 ? { prior: input.prior } : {}, revertplan: [...input.revertplan] };
+}
+function emulationstateof(input) {
+  return { runid: input.runid, tabid: input.tabid, origin: input.origin, layers: [], updatedat: input.now };
+}
+function applylayer(state, layer, at) {
+  const layers = [...state.layers.filter((item) => item.id !== layer.id), layer];
+  return { ...state, layers, updatedat: at };
+}
+function revertalllayers(state, at) {
+  const reverted = [...state.layers].reverse().filter((layer) => layer.revertedat === void 0);
+  const layers = state.layers.map((layer) => layer.revertedat === void 0 ? { ...layer, revertedat: at } : layer);
+  return { state: { ...state, layers, updatedat: at }, reverted };
+}
+function activelayers(state) {
+  return state ? state.layers.filter((layer) => layer.revertedat === void 0) : [];
+}
+function layernames(state) {
+  return activelayers(state).map((layer) => layer.name);
+}
+function locationrangevalid(latitude, longitude) {
+  return Number.isFinite(latitude) && Number.isFinite(longitude) && latitude >= -90 && latitude <= 90 && longitude >= -180 && longitude <= 180;
+}
+function agentgrammarvalid(useragent) {
+  const text2 = useragent.trim();
+  if (text2.length === 0 || text2.length > 512) return false;
+  if (/[\r\n]/.test(text2)) return false;
+  if (!/^[A-Za-z0-9][A-Za-z0-9._+\-()/:; ,]*$/.test(text2)) return false;
+  return /\/\d/.test(text2) || /\d+\.\d+/.test(text2);
+}
+function permissiongrade(name) {
+  return name === "geolocation" || name === "camera" || name === "microphone" || name === "notifications" ? "powerful" : "standard";
+}
+function expirelayers(state, retention, now) {
+  if (retention === void 0) return state;
+  const layers = state.layers.map((layer) => {
+    if (layer.revertedat === void 0 || layer.prior === void 0 || layer.priorexpired === true) return layer;
+    if (now - layer.revertedat <= retention) return layer;
+    const { prior, ...metadata } = layer;
+    void prior;
+    return { ...metadata, priorexpired: true };
+  });
+  return { ...state, layers, updatedat: now };
+}
+function exportpresetlibrary(input) {
+  return { version: 1, devices: [...input.devices], networks: [...input.networks], locations: [...input.locations], agents: [...input.agents], exportedat: input.now };
+}
+function importpresetlibrary(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entry = value;
+  const devices = (Array.isArray(entry.devices) ? entry.devices : []).flatMap((preset) => {
+    const parsed = devicepresetof(preset);
+    return parsed !== void 0 ? [parsed] : [];
+  });
+  const networks = (Array.isArray(entry.networks) ? entry.networks : []).flatMap((preset) => {
+    const parsed = networkpresetof(preset);
+    return parsed !== void 0 ? [parsed] : [];
+  });
+  const locations = (Array.isArray(entry.locations) ? entry.locations : []).flatMap((preset) => {
+    const parsed = locationpresetof(preset);
+    return parsed !== void 0 ? [parsed] : [];
+  });
+  const agents = (Array.isArray(entry.agents) ? entry.agents : []).flatMap((preset) => {
+    const parsed = agentpresetof(preset);
+    return parsed !== void 0 ? [parsed] : [];
+  });
+  if (devices.length + networks.length + locations.length + agents.length === 0) return void 0;
+  return { version: typeof entry.version === "number" && Number.isInteger(entry.version) && entry.version >= 1 ? entry.version : 1, devices, networks, locations, agents, exportedat: typeof entry.exportedat === "number" ? entry.exportedat : Date.now() };
+}
+function locationconsentcovers(origin, latitude, longitude, consents) {
+  return consents.some((consent) => consent.origin === origin && consent.approved === true && consent.revokedat === void 0 && consent.latitude === latitude && consent.longitude === longitude);
+}
+
 // memory.ts
 var sessionmemory = class {
   constructor(adapter) {
@@ -1241,6 +1617,210 @@ 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;
+  }
+  /** Stores the emulation state of one run keyed by its run id; the reverted layer prior states expire after the user configured retention window while the layer history always survives. */
+  async setemulationstate(state) {
+    const retention = (await this.getsettings())?.emulationretention;
+    await this.adapter.set(`emulationstate${state.runid}`, expirelayers(state, retention, Date.now()));
+  }
+  /** Returns the persisted emulation state of one run so the layers survive service worker restarts. */
+  async getemulationstate(runid) {
+    return this.adapter.get(`emulationstate${runid}`);
+  }
+  /** Returns the active and past layers of one run, newest last in apply order; the listlayers accessor of the emulation memory. */
+  async listlayers(runid) {
+    const state = await this.getemulationstate(runid);
+    return state?.layers ?? [];
+  }
+  /** Stores one user curated device preset by its name so the preset library stays user data instead of a hardcoded list. */
+  async setdevicepreset(preset) {
+    const records = (await this.adapter.get("devicepresets") ?? []).filter((item) => item.name !== preset.name);
+    await this.adapter.set("devicepresets", [...records, preset]);
+  }
+  /** Returns every user curated device preset. */
+  async getdevicepresets() {
+    return await this.adapter.get("devicepresets") ?? [];
+  }
+  /** Stores one user curated network preset by its name with editable values. */
+  async setnetworkpreset(preset) {
+    const records = (await this.adapter.get("networkpresets") ?? []).filter((item) => item.name !== preset.name);
+    await this.adapter.set("networkpresets", [...records, preset]);
+  }
+  /** Returns every user curated network preset. */
+  async getnetworkpresets() {
+    return await this.adapter.get("networkpresets") ?? [];
+  }
+  /** Stores one user curated location preset by its name. */
+  async setlocationpreset(preset) {
+    const records = (await this.adapter.get("locationpresets") ?? []).filter((item) => item.name !== preset.name);
+    await this.adapter.set("locationpresets", [...records, preset]);
+  }
+  /** Returns every user curated location preset. */
+  async getlocationpresets() {
+    return await this.adapter.get("locationpresets") ?? [];
+  }
+  /** Stores one user curated agent preset by its name. */
+  async setagentpreset(preset) {
+    const records = (await this.adapter.get("agentpresets") ?? []).filter((item) => item.name !== preset.name);
+    await this.adapter.set("agentpresets", [...records, preset]);
+  }
+  /** Returns every user curated agent preset. */
+  async getagentpresets() {
+    return await this.adapter.get("agentpresets") ?? [];
+  }
+  /** Replaces the blackbox rule set of one origin so third party script blackboxing stays scoped per origin. */
+  async setblackboxrules(origin, rules) {
+    const records = (await this.adapter.get("blackboxrules") ?? []).filter((item) => item.origin !== origin);
+    await this.adapter.set("blackboxrules", [...records, { origin, rules }]);
+  }
+  /** Returns every stored blackbox rule set with its origin. */
+  async getblackboxrules() {
+    return await this.adapter.get("blackboxrules") ?? [];
+  }
+  /** Records one permission override of a run with its prior state captured for the exact restore. */
+  async addpermissionoverride(record2) {
+    const records = (await this.adapter.get("permissionoverrides") ?? []).filter((item) => item.id !== record2.id);
+    await this.adapter.set("permissionoverrides", [record2, ...records]);
+  }
+  /** Returns the permission override history with restore states, newest first. */
+  async getpermissionoverrides() {
+    return await this.adapter.get("permissionoverrides") ?? [];
+  }
+  /** Stores one location consent decision per origin, replacing the previous decision of its id. */
+  async setlocationconsent(consent) {
+    const records = (await this.adapter.get("locationconsents") ?? []).filter((item) => item.id !== consent.id);
+    await this.adapter.set("locationconsents", [consent, ...records]);
+  }
+  /** Returns every location consent decision, newest first. */
+  async getlocationconsents() {
+    return await this.adapter.get("locationconsents") ?? [];
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -2460,9 +3040,9 @@ function consolediff(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", "attachcdp", "detachcdp", "cdpcmd", "overridescript"]);
+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", "emulatedevice", "emulatenetwork", "emulatelocate", "setuseragent", "overridepermission"]);
 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"]);
+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", "blackboxscripts"]);
 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"]);
@@ -2480,6 +3060,8 @@ var netwatchactions = /* @__PURE__ */ new Set(["watchrequests", "readheaders", "
 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 emulationactions = /* @__PURE__ */ new Set(["emulatedevice", "emulatenetwork", "emulatelocate", "setuseragent", "overridepermission", "blackboxscripts"]);
 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"]);
@@ -2501,6 +3083,12 @@ function isdebugkind(kind) {
 function iscdpkind(kind) {
   return cdpactions.has(kind);
 }
+function isprofilekind(kind) {
+  return profileractions.has(kind);
+}
+function isemulationkind(kind) {
+  return emulationactions.has(kind);
+}
 function actionrisk(kind) {
   if (!allowedactions.has(kind)) throw new Error("Unsupported browser action.");
   if (sensitiveactions.has(kind)) return "sensitive";
@@ -3816,6 +4404,28 @@ function debuggerconsentcovers(origin, domains, grants) {
   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 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." };
@@ -3842,6 +4452,74 @@ function breakpointbudgetallowed(active, ceiling) {
 function breakpointceilingof(settings) {
   return settings?.breakpointceiling;
 }
+function emugate(input) {
+  const gate = sessiongate({ session: input.session, tabid: input.tabid, origin: input.origin, now: input.now, action: "emulate the run tab" });
+  if (!gate.allowed) return gate;
+  if (!input.plan || input.plan.state !== "approved") return { allowed: false, reason: "Emulation layers need an approved plan before they apply." };
+  let options = {};
+  try {
+    options = parseoptions(input.step);
+  } catch {
+    options = {};
+  }
+  if (options.reviewed !== true) return { allowed: false, reason: `The ${input.step.kind} layer needs the explicit reviewed flag before any mask applies.` };
+  if (revertplanof(options.revertplan) === void 0) return { allowed: false, reason: `Every ${input.step.kind} layer needs a reviewed revert plan beside it before any mask applies.` };
+  return { allowed: true };
+}
+function emulationstackallowed(plan, kind, active) {
+  if (!plan) return { allowed: false, reason: "Layer stacking needs the reviewed plan first." };
+  const listed = plan.steps.filter((step) => step.kind === kind).length;
+  if (active >= listed) return { allowed: false, reason: `The plan lists ${listed} reviewed ${kind} step${listed === 1 ? "" : "s"} and ${active} layer${active === 1 ? "" : "s"} of that family are already active; stacking beyond the reviewed plan is refused.` };
+  return { allowed: true };
+}
+function locationconsentgate(origin, latitude, longitude, consents) {
+  if (consents.some((consent) => consent.origin === origin && consent.revokedat !== void 0)) return { allowed: false, reason: `The location consent on ${origin} was revoked; approve a new prompt before the location override runs again.` };
+  if (locationconsentcovers(origin, latitude, longitude, consents)) return { allowed: true };
+  return { allowed: false, reason: `The location override of ${latitude}, ${longitude} on ${origin} needs the reviewed location consent first; approve the prompt with the coordinates shown in the review panel.` };
+}
+function validateemulationgrammar(step, options) {
+  const kind = step.kind;
+  if (revertplanof(options.revertplan) === void 0) return { allowed: false, reason: `Every ${kind} layer needs a reviewed revert plan before any mask applies.` };
+  if (kind === "emulatedevice") {
+    const preset = devicepresetof(options.device);
+    if (!preset) return { allowed: false, reason: "The device layer needs a reviewed preset with a name, positive integer width and height and a positive pixel ratio." };
+    if (options.reload !== void 0 && typeof options.reload !== "boolean") return { allowed: false, reason: "The reviewed reload flag must be a boolean; the page reloads only when the reviewed plan asks." };
+    return { allowed: true };
+  }
+  if (kind === "emulatenetwork") {
+    const preset = networkpresetof(options.network);
+    if (!preset) return { allowed: false, reason: "The network layer needs a reviewed preset with a name and zero or positive latency, download and upload bounds." };
+    if (options.window !== void 0 && (typeof options.window !== "number" || !Number.isFinite(options.window) || options.window < 0)) return { allowed: false, reason: "The reviewed offline window must be zero or a positive number of milliseconds with no code ceiling." };
+    return { allowed: true };
+  }
+  if (kind === "emulatelocate") {
+    const preset = locationpresetof(options.location);
+    if (!preset) return { allowed: false, reason: "The location layer needs a reviewed preset with a name, a latitude inside -90 and 90, a longitude inside -180 and 180 and a zero or positive accuracy radius." };
+    if (!locationrangevalid(preset.latitude, preset.longitude)) return { allowed: false, reason: "The reviewed latitude must stay inside -90 and 90 degrees and the longitude inside -180 and 180 degrees." };
+    return { allowed: true };
+  }
+  if (kind === "setuseragent") {
+    const preset = agentpresetof(options.agent);
+    if (!preset) return { allowed: false, reason: "The agent layer needs a reviewed preset with a user agent string of the reviewed grammar, a platform and a non-empty brand list." };
+    if (!agentgrammarvalid(preset.useragent)) return { allowed: false, reason: "The reviewed user agent string must use the reviewed grammar of tokens, separators and version marks without line breaks." };
+    return { allowed: true };
+  }
+  if (kind === "overridepermission") {
+    const grant = permissiongrantof(options.permission);
+    if (!grant) return { allowed: false, reason: `The permission override needs a reviewed name of the browser permission set (${browserpermissions.join(", ")}) and a state of ${permissionstates.join(", ")}.` };
+    void permissiongrade(grant.name);
+    return { allowed: true };
+  }
+  if (kind === "blackboxscripts") {
+    const rules = Array.isArray(options.rules) ? options.rules.flatMap((rule) => {
+      const parsed = blackboxruleof(rule);
+      return parsed !== void 0 ? [parsed] : [];
+    }) : [];
+    if (rules.length === 0) return { allowed: false, reason: "The blackbox layer needs a reviewed non-empty rule list where every pattern names its origin explicitly and carries a trace scope." };
+    return { allowed: true };
+  }
+  return { allowed: true };
+}
 function validatecdpgrammar(step, options) {
   const kind = step.kind;
   if (kind === "attachcdp") {
@@ -3908,6 +4586,66 @@ function validatecdpgrammar(step, options) {
   }
   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;
@@ -4339,6 +5077,14 @@ function validatestep(step, origin) {
     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 (isemulationkind(step.kind)) {
+    const emulationcheck = validateemulationgrammar(step, options);
+    if (!emulationcheck.allowed) return emulationcheck;
+  }
   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." };
@@ -4472,18 +5218,46 @@ function canexecute(input) {
     if (input.step.kind === "setbreakpoint") {
       const breakpoint = breakpointinputof(cdpoptions.breakpoint);
       if (breakpoint) {
-        const targetgate = origincheck(input.session, breakpoint.url);
-        if (!targetgate.allowed) return targetgate;
+        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 targetgate = origincheck(input.session, override.urlpattern);
-        if (!targetgate.allowed) return targetgate;
+        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 (isemulationkind(input.step.kind)) {
+    const emugatecheck = emugate({ session: input.session, plan: input.plan, step: input.step, tabid: input.tabid, origin: input.origin, now });
+    if (!emugatecheck.allowed) return emugatecheck;
+  }
   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;
@@ -4529,8 +5303,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,9 +5497,20 @@ function recordcdp(progress, planid, stepid, entry, now) {
   const outcome = { stepid, ok: entry.errorclass === void 0, summary, details: { cdp: entry }, at: now };
   return recordoutcome(base, planid, outcome, now);
 }
+function recordprofile(progress, planid, stepid, entry, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  const counts = `${entry.metrics !== void 0 ? `${entry.metrics} metric${entry.metrics === 1 ? "" : "s"}, ` : ""}${entry.samples !== void 0 ? `${entry.samples} sample${entry.samples === 1 ? "" : "s"}, ` : ""}${entry.nodes !== void 0 ? `${entry.nodes} node${entry.nodes === 1 ? "" : "s"}, ` : ""}${entry.events !== void 0 ? `${entry.events} event${entry.events === 1 ? "" : "s"}, ` : ""}${entry.bytes !== void 0 ? `${entry.bytes} byte${entry.bytes === 1 ? "" : "s"}, ` : ""}${entry.flagged !== void 0 ? `${entry.flagged} flagged step${entry.flagged === 1 ? "" : "s"}, ` : ""}`.replace(/, $/, "");
+  const outcome = { stepid, ok: true, summary: `The profiling ${entry.family} capture ran${counts.length > 0 ? ` with ${counts}` : ""}.`, details: { profile: entry }, at: now };
+  return recordoutcome(base, planid, outcome, now);
+}
+function recordemulation(progress, planid, stepid, entry, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  const outcome = { stepid, ok: true, summary: `${entry.reason}: ${entry.applied.length} applied layer${entry.applied.length === 1 ? "" : "s"}${entry.applied.length > 0 ? ` (${entry.applied.join(", ")})` : ""} and ${entry.reverted.length} reverted layer${entry.reverted.length === 1 ? "" : "s"}${entry.reverted.length > 0 ? ` (${entry.reverted.join(", ")})` : ""}.`, details: { emulation: entry }, at: now };
+  return recordoutcome(base, planid, outcome, now);
+}
 
 // version.ts
-var packageversion = "1.1.46";
+var packageversion = "1.1.48";
 
 // types.ts
 var protocolversion = packageversion;
@@ -4844,6 +5629,81 @@ function parseproposal(value, origin, grants) {
         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.");
+    }
+    if (isemulationkind(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 emulationoptions = {};
+      try {
+        emulationoptions = parseoptions(step);
+      } catch {
+        emulationoptions = {};
+      }
+      if (revertplanof(emulationoptions.revertplan) === void 0) throw new Error("Emulation steps without a reviewed revert plan are refused.");
+      if (step.kind === "emulatelocate") {
+        const preset = locationpresetof(emulationoptions.location);
+        if (preset === void 0) throw new Error("Location emulation needs a reviewed preset with coordinates inside the latitude and longitude ranges.");
+      }
+      if (step.kind === "overridepermission" && permissiongrantof(emulationoptions.permission) === void 0) throw new Error("Permission overrides of unknown permission names are refused.");
+    }
     const evaluation = validatestep(step, origin);
     if (!evaluation.allowed) throw new Error(evaluation.reason);
     const target = outboundtarget(step);
@@ -4918,7 +5778,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 } : {}, ...input.cdp ? { cdp: input.cdp } : {} });
+  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 } : {}, ...input.emulation ? { emulation: input.emulation } : {} });
 }
 function mapresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
@@ -5033,6 +5893,22 @@ function cdpreport(input) {
   });
   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 };
+}
+function emulationreport(input) {
+  const consents = input.consents.map((consent) => {
+    const { prompt, ...metadata } = consent;
+    void prompt;
+    return metadata;
+  });
+  return { version: protocolversion, ...input.state !== void 0 ? { state: input.state } : {}, layers: input.state?.layers ?? [], devices: input.devices, networks: input.networks, locations: input.locations, agents: input.agents, blackbox: input.blackbox, permissions: input.permissions, consents };
+}
 
 // capture.ts
 var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
@@ -6721,7 +7597,7 @@ function stepoptions2(step) {
 }
 async function refreshcapabilities() {
   const report = await readcapabilities();
-  const withmedia = { ...report, captures: [...capturekinds], media: [...mediakinds], http: [...httpkinds], netwatch: [...socketkinds, ...netwatchkinds], control: [...controlkinds], debug: [...timelinekinds, ...cdpkinds] };
+  const withmedia = { ...report, captures: [...capturekinds], media: [...mediakinds], http: [...httpkinds], netwatch: [...socketkinds, ...netwatchkinds], control: [...controlkinds], debug: [...timelinekinds, ...cdpkinds], profile: [...profilerkinds], emulation: [...emulationkinds] };
   await memory.setcapabilities(withmedia);
   return withmedia;
 }
@@ -6877,6 +7753,7 @@ function stepauditkind(step, ok) {
   if (step.kind === "consentpassword") return "consent";
   if (step.kind === "handoffcaptcha") return "handoff";
   if (iscapturekind(step.kind)) return "capture";
+  if (isprofilekind(step.kind)) return "profile";
   if (ismediakind(step.kind)) return "media";
   if (isfileskind(step.kind)) {
     if (step.kind === "interceptmime") return "intercept";
@@ -7159,6 +8036,10 @@ async function tracktabupdate(tabid2, changeinfo) {
       if (active.session.detachedat !== void 0 || active.session.tabid !== tabid2) continue;
       await detachcdpforrun(runid, `the run tab navigated to ${url}`).catch(() => {
       });
+      await stopprofileinstrumentsforrun(runid, `the run tab navigated to ${url}`).catch(() => {
+      });
+      await revertemulationforrun(runid, `the run tab navigated to ${url}`).catch(() => {
+      });
     }
     return;
   }
@@ -7184,6 +8065,10 @@ chrome.tabs.onActivated.addListener((activeinfo) => {
   void recordtabwatchevent("activated", activeinfo.tabId);
 });
 chrome.tabs.onRemoved.addListener((tabid2) => {
+  for (const [runid, state] of [...activeemulation.entries()]) {
+    if (state.tabid === tabid2) void revertemulationforrun(runid, `the run tab ${tabid2} dropped`, tabid2).catch(() => {
+    });
+  }
   const url = lastknownurls.get(tabid2);
   const title = lastknowntitles.get(tabid2) ?? "";
   const windowid = 0;
@@ -10001,11 +10886,24 @@ async function executecdpstep(step, session, plan, tabid2, origin) {
     if (!output.ok) return output;
     const record2 = attachcdpsession({ id: sessionid, runid: plan.id, stepid: step.id, tabid: tabid2, origin, domains, now: Date.now(), debuggerversion: cdpderivation });
     cdpstateof(plan.id, record2, teardown);
+    const attachtargets = profiletargetsof(options);
+    const flattened = [];
+    if (attachtargets.length > 0) {
+      const targetgatecheck = targetgate({ session, tabid: tabid2, origin, targets: attachtargets, grants, now: Date.now() });
+      if (!targetgatecheck.allowed) throw new Error(targetgatecheck.reason ?? "The attach target stays outside the profiling target gate.");
+      attachtargets.forEach((target, index) => {
+        flattened.push({ kind: target.kind, url: target.url, sessionid: `${sessionid}-${index + 1}`, attachedat: Date.now() });
+        if (target.kind === "serviceworker") {
+          void memory.addtimelineentry({ id: randomid(), runid: plan.id, stepid: step.id, time: Date.now(), level: "info", source: "cdp", message: `Service worker target ${target.url} attached through the page controller state; the worker console and network flow into the run timeline as derived entries because no debugger permission exists in the manifest.` });
+        }
+      });
+      activeprofiletargets.set(plan.id, { runid: plan.id, targets: flattened });
+    }
     await memory.setcdpsession(record2);
     await memory.setprogress(recordcdp(await memory.getprogress(), plan.id, step.id, { family: "attach", domains: domains.length }, Date.now()));
-    await audit("debugger", `Attached the devtools session ${sessionid} to the run tab ${tabid2} of ${origin} with the reviewed domains ${domains.join(", ")} enabled and the debugger version ${cdpderivation}; the teardown plan reverts ${teardown?.revertsteps.length ?? 0} step${(teardown?.revertsteps.length ?? 0) === 1 ? "" : "s"} with the ${teardown?.resumepolicy ?? "ask"} resume policy.`, extra);
+    await audit("debugger", `Attached the devtools session ${sessionid} to the run tab ${tabid2} of ${origin} with the reviewed domains ${domains.join(", ")} enabled and the debugger version ${cdpderivation}; the teardown plan reverts ${teardown?.revertsteps.length ?? 0} step${(teardown?.revertsteps.length ?? 0) === 1 ? "" : "s"} with the ${teardown?.resumepolicy ?? "ask"} resume policy.${flattened.length > 0 ? ` The attach flattened ${flattened.length} sub session${flattened.length === 1 ? "" : "s"} for nested target access of ${flattened.map((target) => `${target.kind} ${target.url}`).join(", ")}.` : ""}`, extra);
     await refreshbadge();
-    return { ok: true, summary: output.summary, details: { ...output.details ?? {}, session: record2, cdp: { sessionid, state: "attached", commandids: [] } } };
+    return { ok: true, summary: output.summary, details: { ...output.details ?? {}, session: record2, ...flattened.length > 0 ? { targets: flattened } : {}, cdp: { sessionid, state: "attached", commandids: [] } } };
   }
   if (step.kind === "detachcdp") {
     if (!active) throw new Error("No attached devtools session covers this run.");
@@ -10147,6 +11045,275 @@ async function executecdpstep(step, session, plan, tabid2, origin) {
   }
   return { ok: false, summary: "The devtools step is not part of the instrumented family." };
 }
+var activeprofiletargets = /* @__PURE__ */ new Map();
+var activememorytrackers = /* @__PURE__ */ new Map();
+var lastheapshots = /* @__PURE__ */ new Map();
+function profiletargetsof(options) {
+  const single = attachtargetof(options.target);
+  const listed = Array.isArray(options.attachtargets) ? options.attachtargets.flatMap((target) => {
+    const parsed = attachtargetof(target);
+    return parsed !== void 0 ? [parsed] : [];
+  }) : [];
+  return [...single !== void 0 ? [single] : [], ...listed];
+}
+async function stopprofileinstrumentsforrun(runid, reason) {
+  const targets = activeprofiletargets.get(runid);
+  if (targets) {
+    activeprofiletargets.delete(runid);
+    await audit("profile", `Detached ${targets.targets.length} profiling target${targets.targets.length === 1 ? "" : "s"} at ${reason}; the flattened sub sessions close with the parent session.`, { planid: runid }).catch(() => void 0);
+  }
+  const tracker = activememorytrackers.get(runid);
+  if (tracker) {
+    activememorytrackers.delete(runid);
+    const samples = await memory.listgrowsamples(runid).catch(() => []);
+    if (samples.length > 0) {
+      const trend = growthtrend({ runid, samples, slope: tracker.slope, now: Date.now() });
+      await memory.settrend(trend).catch(() => void 0);
+    }
+    await audit("profile", `Closed the memory growth tracker of ${samples.length} sample${samples.length === 1 ? "" : "s"} at ${reason}; the computed trend stays stored with its flagged steps.`, { planid: runid }).catch(() => void 0);
+  }
+  lastheapshots.delete(runid);
+}
+async function sampleheapforstep(tracker, stepid, tabid2, origin, plan) {
+  const now = Date.now();
+  if (now - tracker.lastsampleat < tracker.interval) return;
+  const samplestep = { id: stepid, kind: "heapshot", summary: "Heap sample beside the step", risk: "read" };
+  const output = await dispatchpagestep(samplestep, tabid2, origin, plan);
+  const details = output?.details;
+  if (!output?.ok || typeof details?.usedbytes !== "number") return;
+  const sample = growsampleof({ id: randomid(), runid: tracker.runid, stepid, usedbytes: details.usedbytes, limitbytes: typeof details.limitbytes === "number" ? details.limitbytes : 0, now });
+  await memory.addgrowsample(sample);
+  tracker.lastsampleat = now;
+  const samples = await memory.listgrowsamples(tracker.runid);
+  const trend = growthtrend({ runid: tracker.runid, samples, slope: tracker.slope, now });
+  await memory.settrend(trend);
+  if (trend.flaggedsteps.includes(stepid)) await memory.addtimelineentry({ id: randomid(), runid: tracker.runid, stepid, time: now, level: "warn", source: "longtask", message: `Heap growth of step ${stepid} exceeds the reviewed slope of ${tracker.slope} bytes per millisecond; the step is flagged in the memory trend.` });
+}
+async function executeprofilestep(step, session, plan, tabid2, origin) {
+  const options = stepoptions2(step);
+  const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
+  const targets = profiletargetsof(options);
+  const grants = await memory.getdebuggergrants();
+  const targetgatecheck = targetgate({ session, tabid: tabid2, origin, targets, grants, now: Date.now() });
+  if (!targetgatecheck.allowed) {
+    const consent = debuggerconsentcovers(origin, [], grants);
+    if (!consent.allowed) {
+      const pending = grants.find((grant) => grant.origin === origin && grant.approved === void 0);
+      if (!pending) {
+        const record2 = { id: randomid(), prompt: `Profiling instrumentation on ${origin} for run ${plan.id} through the performance timeline buffers and the injected probes of the page bridge.`, origin, domains: [], consentedat: Date.now() };
+        await memory.setdebuggergrant(record2);
+        await refreshbadge();
+      }
+      throw new Error(`${consent.reason} The prompt is open in the review panel with the profiling derivation shown; approve it and run the step again.`);
+    }
+    throw new Error(targetgatecheck.reason ?? "The profiling step stays outside the profiling target gate.");
+  }
+  if (step.kind === "measureflow") {
+    const spec = flowspecof(options.flow);
+    if (!spec) throw new Error("A reviewed flow spec is required.");
+    const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The flow measurement returned no result." };
+    if (!output.ok) return output;
+    const entries = detailarray(output.details, "entries").flatMap((entry) => {
+      if (!entry || typeof entry !== "object") return [];
+      const record2 = entry;
+      if (typeof record2.name !== "string" || typeof record2.type !== "string" || typeof record2.start !== "number" || typeof record2.duration !== "number") return [];
+      return [{ name: record2.name, type: record2.type, start: record2.start, duration: record2.duration }];
+    });
+    const metrics = measure({ runid: plan.id, stepid: step.id, spec, entries, now: Date.now() });
+    for (const metric of metrics) await memory.addflowmetric(metric);
+    await memory.setprogress(recordprofile(await memory.getprogress(), plan.id, step.id, { family: "flow", metrics: metrics.length, recordids: metrics.map((metric) => metric.id) }, Date.now()));
+    await audit("profile", `Measured the flow ${spec.prefix} of ${origin} over ${spec.steps.length} step${spec.steps.length === 1 ? "" : "s"} with ${metrics.length} metric${metrics.length === 1 ? "" : "s"} of the reviewed set ${spec.metrics.join(", ")}; the marks and performance buffers derive the durations because no debugger permission exists in the manifest.`, extra);
+    return { ok: true, summary: output.summary, details: { ...output.details ?? {}, flow: { metrics: metrics.map((metric) => ({ name: metric.name, duration: metric.duration, steps: metric.steps })) }, profile: { metrics: metrics.length, samples: 0 } } };
+  }
+  if (step.kind === "heapshot") {
+    const heap = options.heap && typeof options.heap === "object" && !Array.isArray(options.heap) ? options.heap : {};
+    const interval = typeof heap.interval === "number" ? heap.interval : void 0;
+    if (!heapintervalallowed(lastheapshots.get(plan.id), interval, Date.now())) throw new Error(`The reviewed heap snapshot interval of ${interval} milliseconds has not elapsed since the last snapshot of this run; the frequency bound stays the user choice only.`);
+    const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The heap snapshot returned no result." };
+    if (!output.ok) return output;
+    const details = output.details;
+    const record2 = heapsnap({ id: randomid(), runid: plan.id, stepid: step.id, origin, usedbytes: typeof details.usedbytes === "number" ? details.usedbytes : 0, limitbytes: typeof details.limitbytes === "number" ? details.limitbytes : 0, nodecount: typeof details.nodecount === "number" ? details.nodecount : 0, now: Date.now() });
+    lastheapshots.set(plan.id, record2.capturedat);
+    await memory.setheaprecord(record2);
+    await memory.setprogress(recordprofile(await memory.getprogress(), plan.id, step.id, { family: "heap", nodes: record2.nodecount, bytes: record2.bytesize, recordids: [record2.id] }, Date.now()));
+    await audit("profile", `Captured the on demand heap snapshot ${record2.id} of ${origin} with ${record2.bytesize} used bytes and ${record2.nodecount} dom nodes${interval !== void 0 ? ` under the user chosen interval of ${interval} milliseconds` : ""}; the bytes derive from the page performance memory buffer because no heap profiler exists without the debugger permission.`, extra);
+    return { ok: true, summary: output.summary, details: { ...output.details ?? {}, heapid: record2.id, heap: record2, profile: { metrics: 0, samples: 0 } } };
+  }
+  if (step.kind === "trackmemory") {
+    const growth = options.growth && typeof options.growth === "object" && !Array.isArray(options.growth) ? options.growth : void 0;
+    const slope = typeof growth?.slope === "number" ? growth.slope : void 0;
+    if (growth === void 0 || slope === void 0) throw new Error("The reviewed growth slope is required.");
+    const interval = typeof growth.interval === "number" ? growth.interval : 0;
+    const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The memory sample returned no result." };
+    if (!output.ok) return output;
+    const details = output.details;
+    const sample = growsampleof({ id: randomid(), runid: plan.id, stepid: step.id, usedbytes: typeof details.usedbytes === "number" ? details.usedbytes : 0, limitbytes: typeof details.limitbytes === "number" ? details.limitbytes : 0, now: Date.now() });
+    await memory.addgrowsample(sample);
+    activememorytrackers.set(plan.id, { runid: plan.id, slope, interval, lastsampleat: sample.at });
+    const samples = await memory.listgrowsamples(plan.id);
+    const trend = growthtrend({ runid: plan.id, samples, slope, now: Date.now() });
+    await memory.settrend(trend);
+    if (trend.flaggedsteps.length > 0) await memory.addtimelineentry({ id: randomid(), runid: plan.id, stepid: step.id, time: Date.now(), level: "warn", source: "longtask", message: `Memory growth tracking flagged ${trend.flaggedsteps.length} step${trend.flaggedsteps.length === 1 ? "" : "s"} above the reviewed slope of ${slope} bytes per millisecond: ${trend.flaggedsteps.join(", ")}.` });
+    await memory.setprogress(recordprofile(await memory.getprogress(), plan.id, step.id, { family: "memory", samples: trend.samples, flagged: trend.flaggedsteps.length, recordids: [sample.id] }, Date.now()));
+    await audit("profile", `Started the memory growth tracking of ${origin} with the reviewed slope of ${slope} bytes per millisecond and ${trend.samples} stored sample${trend.samples === 1 ? "" : "s"}${trend.flaggedsteps.length > 0 ? `; the steps ${trend.flaggedsteps.join(", ")} exceed the slope` : ""}; a sample is taken beside every following step of the run.`, extra);
+    return { ok: true, summary: output.summary, details: { ...output.details ?? {}, trend, profile: { metrics: 0, samples: trend.samples } } };
+  }
+  if (step.kind === "profilecpu") {
+    const duration = options.profile && typeof options.profile === "object" && !Array.isArray(options.profile) ? options.profile.duration : void 0;
+    if (typeof duration !== "number") throw new Error("The reviewed cpu profile duration is required.");
+    const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The cpu profile returned no result." };
+    if (!output.ok) return output;
+    const samples = detailarray(output.details, "samples").flatMap((sample) => {
+      if (!sample || typeof sample !== "object") return [];
+      const record3 = sample;
+      if (typeof record3.name !== "string" || typeof record3.time !== "number") return [];
+      return [{ name: record3.name, time: record3.time }];
+    });
+    const record2 = cpusnap({ id: randomid(), runid: plan.id, stepid: step.id, origin, duration, samples, now: Date.now() });
+    await memory.setcpuprofile(record2);
+    await memory.setprogress(recordprofile(await memory.getprogress(), plan.id, step.id, { family: "cpu", samples: record2.samplecount, recordids: [record2.id] }, Date.now()));
+    await audit("profile", `Profiled the cpu window of ${duration} milliseconds of ${origin} with ${record2.samplecount} sample${record2.samplecount === 1 ? "" : "s"} and ${record2.hotfunctions.length} hot function${record2.hotfunctions.length === 1 ? "" : "s"}${record2.hotfunctions.length > 0 ? ` led by ${record2.hotfunctions[0]}` : ""}; the samples derive from the long task attribution and event timing buffers because no sampling profiler exists without the debugger permission.`, extra);
+    return { ok: true, summary: output.summary, details: { ...output.details ?? {}, profileid: record2.id, cpu: { duration: record2.duration, samplecount: record2.samplecount, hotfunctions: record2.hotfunctions }, profile: { metrics: 0, samples: record2.samplecount } } };
+  }
+  if (step.kind === "watchshifts") {
+    const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The layout shift watch returned no result." };
+    if (!output.ok) return output;
+    const entries = [];
+    for (const shift of detailarray(output.details, "shifts")) {
+      const parsed = shiftentryof({ ...shift && typeof shift === "object" && !Array.isArray(shift) ? shift : {}, id: randomid(), runid: plan.id, stepid: step.id, at: Date.now() });
+      if (parsed !== void 0) entries.push(parsed);
+    }
+    for (const entry of entries) await memory.addshiftentry(entry);
+    await memory.setprogress(recordprofile(await memory.getprogress(), plan.id, step.id, { family: "shift", events: entries.length, recordids: entries.map((entry) => entry.id) }, Date.now()));
+    await audit("profile", `Watched the layout shifts of ${origin} for the reviewed window and recorded ${entries.length} shift${entries.length === 1 ? "" : "s"} with scores and impacted selectors from the performance layout-shift buffer.`, extra);
+    return { ok: true, summary: output.summary, details: { ...output.details ?? {}, shifts: entries, profile: { metrics: 0, samples: 0 } } };
+  }
+  if (step.kind === "traceload") {
+    const trace = options.trace && typeof options.trace === "object" && !Array.isArray(options.trace) ? options.trace : void 0;
+    const categories = trace !== void 0 && Array.isArray(trace.categories) ? trace.categories.filter((category) => typeof category === "string") : [];
+    if (trace === void 0 || categories.length === 0) throw new Error("The reviewed trace categories are required.");
+    const exporttarget = trace.exporttarget === "download" ? "download" : "memory";
+    const started = Date.now();
+    const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The trace record returned no result." };
+    if (!output.ok) return output;
+    const events = detailarray(output.details, "events").flatMap((event) => {
+      if (!event || typeof event !== "object") return [];
+      const record3 = event;
+      if (typeof record3.name !== "string" || typeof record3.category !== "string" || typeof record3.offset !== "number") return [];
+      return [{ name: record3.name, category: record3.category, offset: record3.offset }];
+    });
+    const record2 = tracestart({ id: randomid(), runid: plan.id, stepid: step.id, origin, categories, now: started });
+    const file = tracetofile(record2, events);
+    const ceiling = traceceilingof(await memory.getsettings());
+    if (ceiling !== void 0 && file.bytesize > ceiling) throw new Error(`The derived trace file of ${file.bytesize} bytes exceeds the user configured trace byte ceiling of ${ceiling} bytes; review a wider ceiling or a narrower category list.`);
+    const ended = { ...record2, endedat: Date.now(), bytesize: file.bytesize, events: file.events };
+    await memory.settracerecord(ended);
+    await memory.settracefile(record2.id, file.content);
+    let exported = false;
+    if (exporttarget === "download") {
+      const granted = await chrome.permissions.contains({ permissions: ["downloads"] }).catch(() => false);
+      if (!granted) throw new Error("The trace export needs the downloads capability; request it from the review panel.");
+      const dataurl = `data:application/json;base64,${btoa(file.content)}`;
+      await chrome.downloads.download({ url: dataurl, filename: `devthink-trace-${record2.id}.json` });
+      exported = true;
+      await memory.settracerecord({ ...ended, exportedat: Date.now() });
+    }
+    await memory.setprogress(recordprofile(await memory.getprogress(), plan.id, step.id, { family: "trace", events: file.events, bytes: file.bytesize, recordids: [record2.id] }, Date.now()));
+    await audit("profile", `Recorded the trace ${record2.id} of ${origin} with the reviewed categories ${categories.join(", ")} over ${file.events} event${file.events === 1 ? "" : "s"} and ${file.bytesize} bytes${exported ? " exported through the reviewed download flow" : " kept in memory"}; the file derives from the performance timeline entries and is not the devtools binary trace format.`, extra);
+    return { ok: true, summary: output.summary, details: { ...output.details ?? {}, traceid: record2.id, trace: { categories, events: file.events, bytesize: file.bytesize, exported }, profile: { metrics: 0, samples: 0 } } };
+  }
+  if (step.kind === "annotatetrace") {
+    const trace = options.trace && typeof options.trace === "object" && !Array.isArray(options.trace) ? options.trace : void 0;
+    const traceid = typeof trace?.traceid === "string" ? trace.traceid : "";
+    const stored = traceid ? (await memory.gettracerecords()).find((item) => item.id === traceid && item.runid === plan.id) : void 0;
+    if (!stored) throw new Error(`No stored trace of this run matches ${traceid || "the given id"}.`);
+    const annotations = (Array.isArray(options.annotations) ? options.annotations : []).flatMap((input) => {
+      const parsed = annotationof(input);
+      return parsed !== void 0 ? [parsed] : [];
+    });
+    if (annotations.length === 0) throw new Error("Exported traces carry their step annotations: at least one reviewed annotation is required.");
+    const timeline = await memory.listtimeline({ runid: plan.id });
+    const annotated = annotatetrace({ trace: stored, annotations, timeline: timeline.map((entry) => ({ stepid: entry.stepid, time: entry.time })), now: Date.now() });
+    await memory.settracerecord(annotated);
+    const content = await memory.gettracefile(traceid);
+    if (content !== void 0) {
+      try {
+        const replay = replaytrace(content);
+        const updated = tracetofile(annotated, replay.events.map((event) => ({ name: event.name, category: event.category, offset: event.offset })));
+        await memory.settracefile(traceid, updated.content);
+        await memory.settracerecord({ ...annotated, bytesize: updated.bytesize });
+      } catch {
+      }
+    }
+    await memory.setprogress(recordprofile(await memory.getprogress(), plan.id, step.id, { family: "annotate", events: annotated.annotations.length, recordids: [traceid] }, Date.now()));
+    await audit("profile", `Annotated the trace ${traceid} with ${annotated.annotations.length} step annotation${annotated.annotations.length === 1 ? "" : "s"} aligned with the run timeline entries of steps ${annotated.annotations.map((annotation) => annotation.stepid).join(", ")}.`, extra);
+    return { ok: true, summary: `Annotated the stored trace ${traceid} with ${annotated.annotations.length} step annotation${annotated.annotations.length === 1 ? "" : "s"} aligned with the run timeline.`, details: { traceid, annotations: annotated.annotations, profile: { metrics: 0, samples: 0 } } };
+  }
+  if (step.kind === "replaytrace") {
+    const trace = options.trace && typeof options.trace === "object" && !Array.isArray(options.trace) ? options.trace : void 0;
+    const traceid = typeof trace?.traceid === "string" ? trace.traceid : "";
+    const stored = traceid ? (await memory.gettracerecords()).find((item) => item.id === traceid) : void 0;
+    if (!stored) throw new Error(`No stored trace matches ${traceid || "the given id"}.`);
+    const content = await memory.gettracefile(traceid);
+    const replay = content !== void 0 ? replaytrace(content) : { traceid, runid: stored.runid, categories: Object.fromEntries(stored.categories.map((category) => [category, 0])), events: [], annotations: stored.annotations };
+    await memory.setprogress(recordprofile(await memory.getprogress(), plan.id, step.id, { family: "replay", events: replay.events.length, recordids: [traceid] }, Date.now()));
+    await audit("profile", `Replayed the stored trace ${traceid} of ${stored.runid} offline with ${replay.events.length} event${replay.events.length === 1 ? "" : "s"} grouped by category and step${content === void 0 ? "; the heavy file bytes had expired after the retention window so the replay renders the surviving metadata and annotations only" : ""}.`, extra);
+    return { ok: true, summary: `Replayed the stored trace ${traceid} offline with ${replay.events.length} event${replay.events.length === 1 ? "" : "s"} grouped by category and step.`, details: { traceid, replay, ...content === void 0 ? { fileexpired: true } : {}, profile: { metrics: 0, samples: 0 } } };
+  }
+  if (step.kind === "capturesourcemaps") {
+    const consents = await memory.getsourcemapconsents();
+    const consent = sourcemapconsentcovers(origin, consents);
+    if (!consent.allowed) {
+      const pending = consents.find((item) => item.origin === origin && item.approved === void 0);
+      if (!pending) {
+        const record2 = { id: randomid(), prompt: `Source map capture on ${origin} for run ${plan.id}: the map files of the loaded same origin scripts are fetched and parsed locally.`, origin, consentedat: Date.now() };
+        await memory.setsourcemapconsent(record2);
+        await refreshbadge();
+      }
+      throw new Error(`${consent.reason} The prompt is open in the review panel; approve it and run the step again.`);
+    }
+    const approved = consents.find((item) => item.origin === origin && item.approved === true && item.revokedat === void 0);
+    if (approved) await memory.setsourcemapconsent({ ...approved, usedat: Date.now() });
+    const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The source map capture returned no result." };
+    if (!output.ok) return output;
+    const scripts = detailarray(output.details, "scripts").flatMap((script) => {
+      if (!script || typeof script !== "object") return [];
+      const record2 = script;
+      if (typeof record2.url !== "string" || typeof record2.mapurl !== "string") return [];
+      return [{ url: record2.url, source: `//# sourceMappingURL=${record2.mapurl}` }];
+    });
+    const refs = capturesourcemaps({ runid: plan.id, stepid: step.id, origin, scripts, now: Date.now() });
+    const parsedmaps = /* @__PURE__ */ new Map();
+    for (const ref of refs) {
+      let parsed = false;
+      try {
+        const response = await fetch(ref.mapurl, { credentials: "omit" });
+        if (response.ok) {
+          const map = await response.json();
+          if (Array.isArray(map.sources) && typeof map.mappings === "string") {
+            parsed = true;
+            parsedmaps.set(ref.scripturl, { sources: map.sources.filter((source) => typeof source === "string"), mappings: map.mappings });
+          }
+        }
+      } catch {
+      }
+      await memory.setsourcemapref({ ...ref, parsed });
+    }
+    const stack = (Array.isArray(options.stack) ? options.stack : []).flatMap((location2) => {
+      if (!location2 || typeof location2 !== "object") return [];
+      const record2 = location2;
+      if (typeof record2.url !== "string" || typeof record2.line !== "number") return [];
+      const map = parsedmaps.get(record2.url);
+      if (map === void 0) return [];
+      const rewritten = rewritesourcelocation({ url: record2.url, line: record2.line, ...typeof record2.column === "number" ? { column: record2.column } : {} }, map);
+      return rewritten !== void 0 ? [{ from: `${record2.url}:${record2.line}`, to: `${rewritten.url}:${rewritten.line}` }] : [];
+    });
+    await memory.setprogress(recordprofile(await memory.getprogress(), plan.id, step.id, { family: "sourcemap", events: refs.length, recordids: refs.map((ref) => ref.id) }, Date.now()));
+    await audit("profile", `Captured ${refs.length} source map reference${refs.length === 1 ? "" : "s"} of ${origin} with ${[...parsedmaps.keys()].length} parsed map${[...parsedmaps.keys()].length === 1 ? "" : "s"}${stack.length > 0 ? ` and rewrote ${stack.length} stack location${stack.length === 1 ? "" : "s"}` : ""}; the script sources stayed in the page bridge and only the map urls and parsed state entered the record.`, extra);
+    return { ok: true, summary: output.summary, details: { ...output.details ?? {}, sourcemaps: refs.map((ref) => ({ scripturl: ref.scripturl, mapurl: ref.mapurl, parsed: ref.parsed })), ...stack.length > 0 ? { rewritten: stack } : {}, profile: { metrics: 0, samples: 0 } } };
+  }
+  return { ok: false, summary: "The profiling step is not part of the instrumented family." };
+}
 var activerules = /* @__PURE__ */ new Map();
 var activeauthflows = /* @__PURE__ */ new Map();
 function rulesetof(runid) {
@@ -10541,11 +11708,116 @@ async function refreshbadge() {
   const observedrequests = (await memory.getexchanges()).length;
   const livechannels = (await memory.getchannels()).filter((channel) => channel.state === "open" || channel.state === "connecting").length;
   const activerulescount = [...activerules.values()].reduce((total2, ruleset) => total2 + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0);
+  const locationprompts = (await memory.getlocationconsents()).filter((consent) => consent.approved === void 0).length;
+  const emulatedlayers = [...activeemulation.values()].reduce((total2, state) => total2 + activelayers(state).length, 0);
   const tasktabs2 = new Set(badges.map((badge) => badge.tabid)).size;
-  const total = (queues?.prefetch ?? 0) + (queues?.batchopen ?? 0) + tasktabs2 + prompts + consents + quarantined + datasets + captures + media + recordingprompts + fetchprompts + consoleprompts + debuggerprompts + observedrequests + livechannels + activerulescount;
+  const total = (queues?.prefetch ?? 0) + (queues?.batchopen ?? 0) + tasktabs2 + prompts + consents + quarantined + datasets + captures + media + recordingprompts + fetchprompts + consoleprompts + debuggerprompts + locationprompts + emulatedlayers + observedrequests + livechannels + activerulescount;
   await chrome.action.setBadgeText({ text: total > 0 ? String(total) : "" }).catch(() => {
   });
 }
+var activeemulation = /* @__PURE__ */ new Map();
+async function loademulationstate(runid) {
+  const existing = activeemulation.get(runid);
+  if (existing) return existing;
+  const stored = await memory.getemulationstate(runid);
+  if (stored) activeemulation.set(runid, stored);
+  return stored;
+}
+async function revertemulationforrun(runid, reason, tabid2) {
+  const state = await loademulationstate(runid);
+  if (!state) return;
+  const now = Date.now();
+  const outcome = revertalllayers(state, now);
+  const target = tabid2 ?? state.tabid;
+  if (outcome.reverted.length > 0 && target !== void 0) {
+    for (const layer of outcome.reverted) {
+      await chrome.scripting.executeScript({ target: { tabId: target }, func: (family, prior) => {
+        const bridge = globalThis.devthinkbridge;
+        if (bridge) bridge.revertemulationlayer(family, prior);
+      }, args: [layer.family, layer.prior] }).catch(() => {
+      });
+    }
+  }
+  activeemulation.set(runid, outcome.state);
+  await memory.setemulationstate(outcome.state);
+  const session = await memory.getsession();
+  for (const layer of outcome.reverted) {
+    await audit("emulation", `Reverted the ${layer.family} layer ${layer.name} of run ${runid} on ${reason}; the prior state${layer.prior !== void 0 ? " restored exactly" : " needed no page state"} through the revert plan of ${layer.revertplan.join(", ")}.`, { ...session ? { sessionid: session.id } : {}, planid: runid, stepid: layer.stepid });
+  }
+  if (outcome.reverted.length > 0) {
+    const plan = await memory.getplan();
+    if (plan) await memory.setprogress(recordemulation(await memory.getprogress(), plan.id, outcome.reverted[0]?.stepid ?? "", { applied: [], reverted: outcome.reverted.map((layer) => layer.name), reason: `Emulation reverted on ${reason}` }, now));
+    await refreshbadge();
+  }
+}
+async function executeemulationstep(step, session, plan, tabid2, origin) {
+  const options = stepoptions2(step);
+  const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
+  const revertplan = revertplanof(options.revertplan) ?? [];
+  const family = familyofkind(step.kind) ?? "device";
+  const state = await loademulationstate(plan.id) ?? emulationstateof({ runid: plan.id, tabid: tabid2, origin, now: Date.now() });
+  const stacked = activelayers(state).filter((layer2) => layer2.family === family).length;
+  const stackgate2 = emulationstackallowed(plan, step.kind, stacked);
+  if (!stackgate2.allowed) throw new Error(stackgate2.reason);
+  if (step.kind === "emulatelocate") {
+    const preset = locationpresetof(options.location);
+    if (!preset) throw new Error("A reviewed location preset is required before the location override applies.");
+    const consents = await memory.getlocationconsents();
+    const consentgate = locationconsentgate(origin, preset.latitude, preset.longitude, consents);
+    if (!consentgate.allowed) {
+      const pending = consents.find((consent) => consent.origin === origin && consent.approved === void 0 && consent.latitude === preset.latitude && consent.longitude === preset.longitude);
+      if (!pending) {
+        await memory.setlocationconsent({ id: randomid(), prompt: `Location override of ${preset.latitude}, ${preset.longitude} on ${origin} for run ${plan.id} through a page-injected geolocation override; the true browser location stays untouched.`, origin, latitude: preset.latitude, longitude: preset.longitude, consentedat: Date.now() });
+        await refreshbadge();
+      }
+      throw new Error(`${consentgate.reason} The prompt is open in the review panel with the coordinates shown; approve it and run the step again.`);
+    }
+  }
+  if (step.kind === "blackboxscripts") {
+    const rules = (Array.isArray(options.rules) ? options.rules : []).flatMap((rule) => {
+      const parsed = blackboxruleof(rule);
+      return parsed !== void 0 ? [parsed] : [];
+    });
+    if (rules.length === 0) throw new Error("A reviewed non-empty blackbox rule list is required.");
+    const output2 = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The blackbox registration returned no result." };
+    if (!output2.ok) return output2;
+    await memory.setblackboxrules(origin, rules);
+    const name2 = `${rules.length} blackbox rule${rules.length === 1 ? "" : "s"}`;
+    const layer2 = newlayer({ id: randomid(), runid: plan.id, stepid: step.id, family: "blackbox", name: name2, originscope: origin, revertplan, at: Date.now() });
+    const updated2 = applylayer(state, layer2, Date.now());
+    activeemulation.set(plan.id, updated2);
+    await memory.setemulationstate(updated2);
+    await memory.setprogress(recordemulation(await memory.getprogress(), plan.id, step.id, { applied: [name2], reverted: [], reason: "Blackbox rules registered" }, Date.now()));
+    await audit("emulation", `Marked ${rules.flatMap((rule) => rule.urlpatterns).length} third party url pattern${rules.flatMap((rule) => rule.urlpatterns).length === 1 ? "" : "s"} as blackboxed in the traces of ${origin} with the ${rules.map((rule) => rule.tracescope).join(", ")} scope${revertplan.length > 0 ? ` and the revert plan of ${revertplan.join(", ")}` : ""}; the rules stay read only trace shaping.`, extra);
+    await refreshbadge();
+    return { ok: true, summary: output2.summary, details: { ...output2.details ?? {}, emulation: { applied: [name2], reverted: [] } } };
+  }
+  const priorpermission = step.kind === "overridepermission" ? await chrome.scripting.executeScript({ target: { tabId: tabid2 }, func: (name2) => navigator.permissions?.query({ name: name2 }).then((status) => status.state).catch(() => "prompt"), args: [permissiongrantof(options.permission)?.name ?? ""] }).then((result) => result[0]?.result).catch(() => "prompt") : void 0;
+  const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The emulation step returned no result." };
+  if (!output.ok) return output;
+  const prior = output.details?.prior;
+  let name = family;
+  if (step.kind === "emulatedevice") name = devicepresetof(options.device)?.name ?? "device";
+  if (step.kind === "emulatenetwork") name = networkpresetof(options.network)?.name ?? "network";
+  if (step.kind === "emulatelocate") name = locationpresetof(options.location)?.name ?? "location";
+  if (step.kind === "setuseragent") name = agentpresetof(options.agent)?.name ?? "agent";
+  if (step.kind === "overridepermission") name = `${permissiongrantof(options.permission)?.name ?? "permission"} ${permissiongrantof(options.permission)?.state ?? ""}`.trim();
+  const layer = newlayer({ id: randomid(), runid: plan.id, stepid: step.id, family, name, originscope: origin, revertplan, ...prior !== void 0 ? { prior } : {}, at: Date.now() });
+  const updated = applylayer(state, layer, Date.now());
+  activeemulation.set(plan.id, updated);
+  await memory.setemulationstate(updated);
+  if (step.kind === "overridepermission") {
+    const grant = permissiongrantof(options.permission);
+    if (grant) await memory.addpermissionoverride({ id: layer.id, runid: plan.id, stepid: step.id, origin, name: grant.name, state: grant.state, priorstate: priorpermission === "granted" || priorpermission === "denied" || priorpermission === "prompt" ? priorpermission : "prompt", appliedat: Date.now() });
+  }
+  if (step.kind === "emulatedevice" && options.reload === true) await chrome.tabs.reload(tabid2).catch(() => {
+  });
+  const grade = step.kind === "overridepermission" ? ` graded ${permissiongrade(permissiongrantof(options.permission)?.name ?? "")} by the reviewed permission name` : "";
+  await memory.setprogress(recordemulation(await memory.getprogress(), plan.id, step.id, { applied: [name], reverted: [], reason: `Emulation layer applied${grade}` }, Date.now()));
+  await audit("emulation", `Applied the ${family} layer ${name} of run ${plan.id} on ${origin}${grade}${prior !== void 0 ? " with the prior page state captured for the exact revert" : ""} and the revert plan of ${revertplan.join(", ")}; the mask is a page-injected override through the scripting api because no debugger or platform permission exists in the manifest.`, extra);
+  await refreshbadge();
+  return { ok: true, summary: output.summary, details: { ...output.details ?? {}, emulation: { applied: [name], reverted: [] } } };
+}
 async function executestep(stepid) {
   const session = await memory.getsession();
   const plan = await memory.getplan();
@@ -10616,6 +11888,12 @@ async function executestep(stepid) {
     } else if (iscdpkind(step.kind)) {
       if (!session || !plan || plan.state !== "approved") throw new Error("Devtools protocol kinds refuse to run outside an approved session plan.");
       output = await executecdpstep(step, session, plan, tab.id, origin);
+    } else if (isprofilekind(step.kind)) {
+      if (!session || !plan || plan.state !== "approved") throw new Error("Profiling kinds refuse to run outside an approved session plan.");
+      output = await executeprofilestep(step, session, plan, tab.id, origin);
+    } else if (isemulationkind(step.kind)) {
+      if (!session || !plan || plan.state !== "approved") throw new Error("Emulation kinds refuse to run outside an approved session plan.");
+      output = await executeemulationstep(step, session, plan, tab.id, origin);
     } else {
       if (step.target && freshcheckkinds.has(step.kind)) {
         const fresh = await snapshot(tab.id);
@@ -10662,6 +11940,9 @@ async function executestep(stepid) {
     const completed = watchwindow ? recordwatchcompletion(base, plan.id, stepid, watchwindow.startedat, watchwindow.lifetime, Date.now()) : recordstep(base, plan.id, stepid, Date.now());
     const tracked = recordoutcome(completed, plan.id, outcome, Date.now());
     await memory.setprogress(tracked);
+    const tracker = activememorytrackers.get(plan.id);
+    if (tracker) await sampleheapforstep(tracker, stepid, tab.id, origin, plan).catch(() => {
+    });
     await updatetaskbadges(plan, tracked);
     await refreshbadge();
     if (iscomplete(tracked, plan) && plan.state === "approved") {
@@ -10675,6 +11956,10 @@ async function executestep(stepid) {
       });
       await detachcdpforrun(plan.id, "plan completion").catch(() => {
       });
+      await stopprofileinstrumentsforrun(plan.id, "plan completion").catch(() => {
+      });
+      await revertemulationforrun(plan.id, "plan completion").catch(() => {
+      });
       const done = { ...plan, state: "completed", completedat: Date.now() };
       await memory.setplan(done);
       await audit("complete", "Every reviewed step of the approved plan has executed.", { ...session ? { sessionid: session.id } : {}, planid: done.id });
@@ -10851,7 +12136,7 @@ async function handlerequest(message, sender) {
       const livetab = session ? await chrome.tabs.get(session.tabid).catch(() => void 0) : void 0;
       const waitprofile = session ? waitprofiles.find((record2) => record2.origin === session.origin) : void 0;
       const livestate = { phase: livetab?.status === "loading" ? "loading" : "complete", ...navrecords[0] ? { finalurl: navrecords[0].finalurl, redirects: navrecords[0].chain } : {} };
-      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, socketsactive: activesockets.size, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {} };
+      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, profileretention: runsettings?.profileretention, traceceiling: runsettings?.traceceiling, profile: profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() }), profileactive: activememorytrackers.size + activeprofiletargets.size, profiletargets: [...activeprofiletargets.values()].flatMap((entry) => entry.targets), socketsactive: activesockets.size, emulation: emulationreport({ ...plan && await loademulationstate(plan.id) !== void 0 ? { state: await loademulationstate(plan.id) } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() }), emulatedlayers: plan ? layernames(await loademulationstate(plan.id)) : [], emulationretention: runsettings?.emulationretention, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {} };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -11569,6 +12854,103 @@ async function handlerequest(message, sender) {
       await refreshbadge();
       return { revoked, tokenids };
     }
+    case "emulationreport": {
+      const plan = await memory.getplan();
+      const storedemulation = plan ? await loademulationstate(plan.id) : void 0;
+      return emulationreport({ ...storedemulation !== void 0 ? { state: storedemulation } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() });
+    }
+    case "revertemulation": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for an emulation revert.");
+      const state = await loademulationstate(plan.id);
+      if (!state || activelayers(state).length === 0) throw new Error("No active emulation layer covers this run.");
+      await revertemulationforrun(plan.id, "review panel demand");
+      return { reverted: true, layers: await memory.listlayers(plan.id) };
+    }
+    case "restoreemulation": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for an emulation restore.");
+      const stored = await memory.getemulationstate(plan.id);
+      if (!stored || stored.layers.length === 0) throw new Error("No stored emulation layer history covers this run.");
+      activeemulation.set(plan.id, stored);
+      await refreshbadge();
+      await audit("emulation", `Restored the stored emulation state of run ${plan.id} with ${activelayers(stored).length} active layer${activelayers(stored).length === 1 ? "" : "s"} on user demand after the service worker restart; the layer history stayed persisted through the run record.`, { planid: plan.id });
+      return { restored: true, layers: stored.layers };
+    }
+    case "approvelocationconsent": {
+      const inputapprove = message;
+      const records = await memory.getlocationconsents();
+      const record2 = records.find((item) => item.id === inputapprove.id);
+      if (!record2) throw new Error("No location consent prompt matches the id.");
+      const decided = { ...record2, approved: true, usedat: Date.now() };
+      await memory.setlocationconsent(decided);
+      await audit("consent", `Location override consent on ${record2.origin} for ${record2.latitude}, ${record2.longitude} approved from the review panel; the decision persists for those coordinates of that origin.`, { planid: record2.id });
+      await refreshbadge();
+      return { approved: true, origin: record2.origin, latitude: record2.latitude, longitude: record2.longitude };
+    }
+    case "setdevicepreset": {
+      const inputpreset = message;
+      const preset = devicepresetof(inputpreset.device);
+      if (!preset) throw new Error("A reviewed device preset needs a name, positive integer width and height and a positive pixel ratio.");
+      await memory.setdevicepreset(preset);
+      await audit("emulation", `Stored the device preset ${preset.name} of ${preset.width} by ${preset.height} css pixels with pixel ratio ${preset.pixelratio} and the ${preset.mobile ? "mobile" : "desktop"} hint in the user curated library.`, {});
+      return preset;
+    }
+    case "setnetworkpreset": {
+      const inputpreset = message;
+      const preset = networkpresetof(inputpreset.network);
+      if (!preset) throw new Error("A reviewed network preset needs a name and zero or positive latency, download and upload bounds.");
+      await memory.setnetworkpreset(preset);
+      await audit("emulation", `Stored the network preset ${preset.name} with ${preset.latency} milliseconds latency, ${preset.download} and ${preset.upload} kilobit per second bounds${preset.offline ? " and the offline flag" : ""} in the user curated library.`, {});
+      return preset;
+    }
+    case "setlocationpreset": {
+      const inputpreset = message;
+      const preset = locationpresetof(inputpreset.location);
+      if (!preset) throw new Error("A reviewed location preset needs a name, a latitude inside -90 and 90, a longitude inside -180 and 180 and a zero or positive accuracy radius.");
+      await memory.setlocationpreset(preset);
+      await audit("emulation", `Stored the location preset ${preset.name} of ${preset.latitude}, ${preset.longitude} with the ${preset.accuracy} meter accuracy radius in the user curated library.`, {});
+      return preset;
+    }
+    case "setagentpreset": {
+      const inputpreset = message;
+      const preset = agentpresetof(inputpreset.agent);
+      if (!preset) throw new Error("A reviewed agent preset needs a user agent string of the reviewed grammar, a platform and a non-empty brand list.");
+      await memory.setagentpreset(preset);
+      await audit("emulation", `Stored the agent preset ${preset.name} with platform ${preset.platform} and ${preset.brands.length} brand${preset.brands.length === 1 ? "" : "s"} in the user curated library.`, {});
+      return preset;
+    }
+    case "exportpresets": {
+      const session = await memory.getsession();
+      if (!session || session.stoppedat || session.expiresat <= Date.now()) throw new Error("Preset exports stay behind the consent gate of an active session.");
+      const granted = await chrome.permissions.contains({ permissions: ["downloads"] }).catch(() => false);
+      if (!granted) throw new Error("The preset export needs the downloads capability; request it from the review panel.");
+      const file = exportpresetlibrary({ devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), now: Date.now() });
+      const dataurl = `data:application/json;base64,${btoa(JSON.stringify(file, null, 2))}`;
+      await chrome.downloads.download({ url: dataurl, filename: `devthink-presets-${Date.now()}.json` });
+      await audit("emulation", `The review panel exported the versioned preset library of ${file.devices.length + file.networks.length + file.locations.length + file.agents.length} preset${file.devices.length + file.networks.length + file.locations.length + file.agents.length === 1 ? "" : "s"} through the reviewed download flow.`, { sessionid: session.id });
+      return { exported: file.devices.length + file.networks.length + file.locations.length + file.agents.length, version: file.version };
+    }
+    case "importpresets": {
+      const inputimport = message;
+      const library = importpresetlibrary(inputimport.file);
+      if (!library) throw new Error("The reviewed preset file carries no valid preset of any family; the import is refused.");
+      for (const preset of library.devices) await memory.setdevicepreset(preset);
+      for (const preset of library.networks) await memory.setnetworkpreset(preset);
+      for (const preset of library.locations) await memory.setlocationpreset(preset);
+      for (const preset of library.agents) await memory.setagentpreset(preset);
+      const session = await memory.getsession();
+      await audit("emulation", `Imported the reviewed preset library version ${library.version} with ${library.devices.length} device, ${library.networks.length} network, ${library.locations.length} location and ${library.agents.length} agent preset${library.devices.length + library.networks.length + library.locations.length + library.agents.length === 1 ? "" : "s"} through review.`, { ...session ? { sessionid: session.id } : {} });
+      return { imported: library.devices.length + library.networks.length + library.locations.length + library.agents.length, version: library.version };
+    }
+    case "setemulationretention": {
+      const inputretention = message;
+      const settings = await memory.getsettings();
+      const retention = typeof inputretention.retention === "number" && Number.isInteger(inputretention.retention) && inputretention.retention >= 0 ? inputretention.retention : void 0;
+      await memory.setsettings({ ...settings, ...retention !== void 0 ? { emulationretention: retention } : {} });
+      await audit("configure", `The user set the reverted emulation layer state retention to ${retention === void 0 ? "keep every prior state" : retention} layer${retention === 1 ? "" : "s"}; the layer history itself always survives.`);
+      return { emulationretention: retention };
+    }
     case "revertproxyroute": {
       const inputrevert = message;
       const plan = await memory.getplan();
@@ -11687,6 +13069,74 @@ async function handlerequest(message, sender) {
       if (!plan) throw new Error("No plan is available for a devtools protocol envelope.");
       return cdpreport({ sessions: await memory.getcdpsessions(), commands: await memory.getcdpcommands(), events: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watches: await memory.getwatchexpressions(), overrides: await memory.getscriptoverrides(), grants: await memory.getdebuggergrants() });
     }
+    case "profilereport": {
+      return profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() });
+    }
+    case "approvesourcemapconsent": {
+      const inputapprove = message;
+      const records = await memory.getsourcemapconsents();
+      const record2 = records.find((item) => item.id === inputapprove.id);
+      if (!record2) throw new Error("No source map capture prompt matches the id.");
+      const decided = { ...record2, approved: true, usedat: Date.now() };
+      await memory.setsourcemapconsent(decided);
+      await audit("consent", `Source map capture on ${record2.origin} approved from the review panel; the decision covers the map files of that origin only.`, { stepid: record2.id });
+      await refreshbadge();
+      return { approved: true, origin: record2.origin };
+    }
+    case "revokesourcemapconsent": {
+      const session = await memory.getsession();
+      const origin = session?.origin;
+      if (!origin) throw new Error("No active session origin covers a source map consent revoke.");
+      const revoked = await memory.revokesourcemapconsents(origin, Date.now());
+      await audit("consent", `The user revoked ${revoked} source map capture consent record${revoked === 1 ? "" : "s"} of ${origin}; the next capture needs a new reviewed prompt.`, { ...session ? { sessionid: session.id } : {} });
+      await refreshbadge();
+      return { revoked };
+    }
+    case "exporttrace": {
+      const session = await memory.getsession();
+      if (!session || session.stoppedat || session.expiresat <= Date.now()) throw new Error("Trace exports stay behind the consent gate of an active session.");
+      const inputtrace = message;
+      const traceid = inputtrace.traceid?.trim();
+      if (!traceid) throw new Error("Trace exports need the stored trace id.");
+      const content = await memory.gettracefile(traceid);
+      if (content === void 0) throw new Error("The trace file bytes expired after the retention window; only the metadata survives.");
+      const granted = await chrome.permissions.contains({ permissions: ["downloads"] }).catch(() => false);
+      if (!granted) throw new Error("The trace export needs the downloads capability; request it from the review panel.");
+      const dataurl = `data:application/json;base64,${btoa(content)}`;
+      await chrome.downloads.download({ url: dataurl, filename: `devthink-trace-${traceid}.json` });
+      const stored = (await memory.gettracerecords()).find((trace) => trace.id === traceid);
+      if (stored) await memory.settracerecord({ ...stored, exportedat: Date.now() });
+      await audit("export", `The review panel exported the trace ${traceid} through the reviewed download flow with its ${stored?.annotations.length ?? 0} step annotation${(stored?.annotations.length ?? 0) === 1 ? "" : "s"}.`, { ...session ? { sessionid: session.id } : {} });
+      return { exported: true, traceid };
+    }
+    case "tracereplay": {
+      const inputreplay = message;
+      const traceid = inputreplay.traceid?.trim();
+      if (!traceid) throw new Error("The trace replay needs the stored trace id.");
+      const stored = (await memory.gettracerecords()).find((trace) => trace.id === traceid);
+      if (!stored) throw new Error(`No stored trace matches ${traceid}.`);
+      const content = await memory.gettracefile(traceid);
+      if (content === void 0) throw new Error("The trace file bytes expired after the retention window; only the metadata survives.");
+      const replay = replaytrace(content);
+      await audit("profile", `The review panel replayed the stored trace ${traceid} offline with ${replay.events.length} event${replay.events.length === 1 ? "" : "s"} grouped by category and step.`, { planid: stored.runid });
+      return replay;
+    }
+    case "setprofileretention": {
+      const inputretention = message;
+      const settings = await memory.getsettings();
+      const retention = typeof inputretention.retention === "number" && Number.isInteger(inputretention.retention) && inputretention.retention >= 0 ? inputretention.retention : void 0;
+      await memory.setsettings({ ...settings, ...retention !== void 0 ? { profileretention: retention } : {} });
+      await audit("configure", `The user set the profile retention to ${retention === void 0 ? "keep every heavy artifact" : `${retention} millisecond${retention === 1 ? "" : "s"}`}; the byte and node counts, sample counts, hot functions and step annotations always survive.`);
+      return { profileretention: retention };
+    }
+    case "settraceceiling": {
+      const inputceiling = message;
+      const settings = await memory.getsettings();
+      const ceiling = typeof inputceiling.ceiling === "number" && Number.isInteger(inputceiling.ceiling) && inputceiling.ceiling >= 0 ? inputceiling.ceiling : void 0;
+      await memory.setsettings({ ...settings, ...ceiling !== void 0 ? { traceceiling: ceiling } : {} });
+      await audit("configure", `The user set the trace byte ceiling to ${ceiling === void 0 ? "no ceiling" : `${ceiling} byte${ceiling === 1 ? "" : "s"}`}; an absent value never refuses a trace export.`);
+      return { traceceiling: ceiling };
+    }
     case "stop": {
       const session = await memory.getsession();
       for (const [id, controller] of [...activefetches.entries()]) {
@@ -11710,16 +13160,28 @@ async function handlerequest(message, sender) {
         });
         await detachcdpforrun(stoppedplan.id, "run cancel").catch(() => {
         });
+        await stopprofileinstrumentsforrun(stoppedplan.id, "run cancel").catch(() => {
+        });
+        await revertemulationforrun(stoppedplan.id, "run cancel").catch(() => {
+        });
       } else {
         await closechannelsforrun("none").catch(() => {
         });
         await revertcontrolsforrun("none", "run cancel").catch(() => {
         });
+        await revertemulationforrun("none", "run cancel").catch(() => {
+        });
       }
       for (const [runid, active] of [...activecdpsessions.entries()]) {
         active.cancelled = true;
         await detachcdpforrun(runid, "run cancel").catch(() => {
         });
+        await stopprofileinstrumentsforrun(runid, "run cancel").catch(() => {
+        });
+      }
+      for (const runid of [...activeemulation.keys()]) {
+        await revertemulationforrun(runid, "run cancel").catch(() => {
+        });
       }
       for (const [id, active] of [...activerecordings.entries()]) {
         const finished = finishrecording(active.record, Date.now());
@@ -11751,6 +13213,12 @@ async function reconcilewatches() {
 }
 reconcilewatches().catch(() => {
 });
+async function restoreemulationstate() {
+  const plan = await memory.getplan();
+  if (plan) await loademulationstate(plan.id);
+}
+restoreemulationstate().catch(() => {
+});
 chrome.runtime.onConnect.addListener((port) => {
   if (port.name !== "devthinksidepanel" || port.sender?.id !== chrome.runtime.id || !port.sender.url?.startsWith(chrome.runtime.getURL(""))) return port.disconnect();
   port.onMessage.addListener((message) => {