@wenathlan/extension 1.1.47 → 1.1.49

package/dist/index.js

@@ -333,6 +333,190 @@ function teardowncdpsession(input) {
   };
 }
 
+// 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 revertlayer(state, layerid, at) {
+  const layers = state.layers.map((layer) => layer.id === layerid && layer.revertedat === void 0 ? { ...layer, revertedat: at } : 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 stackedcount(state) {
+  return activelayers(state).length;
+}
+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 blackboxmatches(urlpattern, url) {
+  const patternmatch = /^(https:\/\/[^/]+)(\/.*)?$/.exec(urlpattern);
+  const urlmatch = /^(https:\/\/[^/]+)(\/.*)?$/.exec(url);
+  if (!patternmatch || !urlmatch) return false;
+  if (patternmatch[1] !== urlmatch[1]) return false;
+  const patternpath = (patternmatch[2] ?? "/").split("/").filter((segment) => segment.length > 0);
+  const urlpath = (urlmatch[2] ?? "/").split("/").filter((segment) => segment.length > 0);
+  const walk = (patternindex, urlindex) => {
+    if (patternindex >= patternpath.length) return urlindex >= urlpath.length;
+    const segment = patternpath[patternindex];
+    if (segment === void 0) return false;
+    if (segment === "**") return walk(patternindex + 1, urlindex) || urlindex < urlpath.length && walk(patternindex, urlindex + 1);
+    if (urlindex >= urlpath.length) return false;
+    if (segment !== "*" && segment !== urlpath[urlindex]) return false;
+    return walk(patternindex + 1, urlindex + 1);
+  };
+  return walk(0, 0);
+}
+function hideblackboxedframes(rules, frames) {
+  const patterns = rules.filter((rule) => rule.tracescope === "traces" || rule.tracescope === "both").flatMap((rule) => rule.urlpatterns);
+  if (patterns.length === 0) return frames;
+  return frames.filter((frame) => !patterns.some((pattern) => blackboxmatches(pattern, frame.url)));
+}
+function blackboxedurls(rules, urls) {
+  const patterns = rules.flatMap((rule) => rule.urlpatterns);
+  return urls.filter((url) => patterns.some((pattern) => blackboxmatches(pattern, url)));
+}
+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);
+}
+
 // httpclient.ts
 var httpkinds = ["fetchurl", "parsejson", "parsehtml", "callrest", "callgraphql"];
 var redirectstatuses = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
@@ -1147,6 +1331,212 @@ function expireprofilerecords(input) {
   };
 }
 
+// sessions.ts
+var sessionkinds = ["persiststate", "capturesession", "restoresession", "namedsessions", "diffsessions", "searchsessions", "exportsessions", "importsessions"];
+var sessionfileversion = 1;
+var snapshotsections = ["tabs", "scroll", "forms", "storage", "cookies"];
+var searchfields = ["urls", "titles", "names", "text"];
+function checksumtext(payload) {
+  let hash = 2166136261;
+  for (let index = 0; index < payload.length; index += 1) {
+    hash ^= payload.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function taskstatechecksum(runid, stepcursor, outputs) {
+  return checksumtext(`${runid}:${stepcursor}:${outputs.length}:${outputs.map((output) => `${output.stepid}:${output.ok}:${output.summary.length}`).join("|")}`);
+}
+function taskstateof(input) {
+  return { runid: input.runid, stepcursor: input.stepcursor, outputs: input.outputs, checkpointat: input.checkpointat, checksum: taskstatechecksum(input.runid, input.stepcursor, input.outputs) };
+}
+function taskstatevalid(state) {
+  if (!state || typeof state.runid !== "string" || !state.runid.trim()) return false;
+  if (typeof state.stepcursor !== "number" || !Number.isInteger(state.stepcursor) || state.stepcursor < 0) return false;
+  if (typeof state.checkpointat !== "number" || !Number.isFinite(state.checkpointat)) return false;
+  if (!Array.isArray(state.outputs)) return false;
+  return state.checksum === taskstatechecksum(state.runid, state.stepcursor, state.outputs);
+}
+function sessiontabof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.url !== "string" || !candidate.url.trim()) return void 0;
+  if (typeof candidate.title !== "string") return void 0;
+  if (typeof candidate.index !== "number" || !Number.isInteger(candidate.index) || candidate.index < 0) return void 0;
+  const scrollx = typeof candidate.scrollx === "number" && Number.isFinite(candidate.scrollx) ? candidate.scrollx : 0;
+  const scrolly = typeof candidate.scrolly === "number" && Number.isFinite(candidate.scrolly) ? candidate.scrolly : 0;
+  const forms = Array.isArray(candidate.forms) ? candidate.forms.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
+    const form = entry;
+    if (typeof form.selector !== "string" || !form.selector.trim()) return [];
+    return [{ selector: form.selector, value: typeof form.value === "string" ? form.value : "" }];
+  }) : [];
+  return { url: candidate.url, title: candidate.title, index: candidate.index, scrollx, scrolly, forms };
+}
+function autointervalof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.period !== "number" || !Number.isFinite(candidate.period) || candidate.period <= 0) return void 0;
+  if (typeof candidate.maxsnapshots !== "number" || !Number.isInteger(candidate.maxsnapshots) || candidate.maxsnapshots < 1) return void 0;
+  if (typeof candidate.expiry !== "number" || !Number.isFinite(candidate.expiry) || candidate.expiry < 0) return void 0;
+  return { period: candidate.period, maxsnapshots: candidate.maxsnapshots, expiry: candidate.expiry };
+}
+function snapshotplanof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (candidate.scope !== "tab" && candidate.scope !== "run" && candidate.scope !== "all") return void 0;
+  const sections = Array.isArray(candidate.sections) ? candidate.sections.flatMap((section) => typeof section === "string" && snapshotsections.includes(section) ? [section] : []) : [];
+  if (sections.length === 0) return void 0;
+  if (typeof candidate.captures !== "boolean") return void 0;
+  const auto = candidate.auto === void 0 ? void 0 : autointervalof(candidate.auto);
+  if (candidate.auto !== void 0 && auto === void 0) return void 0;
+  return { scope: candidate.scope, sections, captures: candidate.captures, ...auto !== void 0 ? { auto } : {} };
+}
+function restoreplanof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (candidate.tabpolicy !== "reopen" && candidate.tabpolicy !== "skip") return void 0;
+  if (candidate.formpolicy !== "restore" && candidate.formpolicy !== "skip") return void 0;
+  if (candidate.capturepolicy !== "link" && candidate.capturepolicy !== "skip") return void 0;
+  return { tabpolicy: candidate.tabpolicy, formpolicy: candidate.formpolicy, capturepolicy: candidate.capturepolicy };
+}
+function searchqueryof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  const terms = Array.isArray(candidate.terms) ? candidate.terms.flatMap((term) => typeof term === "string" && term.trim() ? [term.trim()] : []) : [];
+  if (terms.length === 0) return void 0;
+  const fields = Array.isArray(candidate.fields) ? candidate.fields.flatMap((field) => typeof field === "string" && searchfields.includes(field) ? [field] : []) : [...searchfields];
+  if (fields.length === 0) return void 0;
+  const from = typeof candidate.from === "number" && Number.isFinite(candidate.from) ? candidate.from : void 0;
+  const to = typeof candidate.to === "number" && Number.isFinite(candidate.to) ? candidate.to : void 0;
+  if (from !== void 0 && to !== void 0 && from > to) return void 0;
+  return { terms, fields, ...from !== void 0 ? { from } : {}, ...to !== void 0 ? { to } : {} };
+}
+function sessionfolderof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.name !== "string" || !candidate.name.trim()) return void 0;
+  const parent = typeof candidate.parent === "string" && candidate.parent.trim() ? candidate.parent : void 0;
+  const tags = Array.isArray(candidate.tags) ? candidate.tags.flatMap((tag) => typeof tag === "string" && tag.trim() ? [tag] : []) : [];
+  return { name: candidate.name, ...parent !== void 0 ? { parent } : {}, tags };
+}
+function newsessionrecord(input) {
+  return { id: input.id, name: input.name, createdat: input.createdat, tabs: input.tabs, captures: input.captures, storage: input.storage, cookies: input.cookies, ...input.folder !== void 0 ? { folder: input.folder } : {}, tags: input.tags ?? [], ...input.auto === true ? { auto: true } : {} };
+}
+function diffsessionrecords(left, right) {
+  const changes = [];
+  const leftbyindex = new Map(left.tabs.map((tab) => [tab.index, tab]));
+  const rightbyindex = new Map(right.tabs.map((tab) => [tab.index, tab]));
+  for (const tab of right.tabs) {
+    const prior = leftbyindex.get(tab.index);
+    if (!prior) {
+      changes.push({ class: "added", subject: "tab", detail: `Tab ${tab.index} added: ${tab.url}` });
+      continue;
+    }
+    if (prior.url !== tab.url) changes.push({ class: "changed", subject: "url", detail: `Tab ${tab.index} moved from ${prior.url} to ${tab.url}` });
+    if (prior.title !== tab.title) changes.push({ class: "changed", subject: "tab", detail: `Tab ${tab.index} title changed from "${prior.title}" to "${tab.title}"` });
+    const priorforms = new Map(prior.forms.map((form) => [form.selector, form.value]));
+    for (const form of tab.forms) {
+      const before = priorforms.get(form.selector);
+      if (before === void 0) {
+        changes.push({ class: "added", subject: "form", detail: `Form field ${form.selector} of tab ${tab.index} added with a value` });
+        continue;
+      }
+      if (before !== form.value) changes.push({ class: "changed", subject: "form", detail: `Form field ${form.selector} of tab ${tab.index} changed its captured value` });
+    }
+    for (const form of prior.forms) if (!tab.forms.some((entry) => entry.selector === form.selector)) changes.push({ class: "removed", subject: "form", detail: `Form field ${form.selector} of tab ${tab.index} removed` });
+  }
+  for (const tab of left.tabs) if (!rightbyindex.has(tab.index)) changes.push({ class: "removed", subject: "tab", detail: `Tab ${tab.index} removed: ${tab.url}` });
+  const leftstorage = new Map(left.storage.map((entry) => [entry.origin, entry]));
+  for (const entry of right.storage) {
+    const prior = leftstorage.get(entry.origin);
+    if (!prior) {
+      changes.push({ class: "added", subject: "storage", detail: `Local storage of ${entry.origin} captured with ${entry.keys.length} keys` });
+      continue;
+    }
+    if (prior.keys.join("|") !== entry.keys.join("|") || prior.values.join("|") !== entry.values.join("|")) changes.push({ class: "changed", subject: "storage", detail: `Local storage of ${entry.origin} changed its captured keys or values` });
+  }
+  for (const entry of left.storage) if (!right.storage.some((candidate) => candidate.origin === entry.origin)) changes.push({ class: "removed", subject: "storage", detail: `Local storage of ${entry.origin} left the capture` });
+  return changes;
+}
+function newsessiondiff(input) {
+  return { id: input.id, leftid: input.left.id, rightid: input.right.id, changes: diffsessionrecords(input.left, input.right), at: input.at };
+}
+function searchsessionrecords(query, records) {
+  const matches = [];
+  for (const record2 of records) {
+    if (query.from !== void 0 && record2.createdat < query.from) continue;
+    if (query.to !== void 0 && record2.createdat > query.to) continue;
+    const haystacks = [
+      { field: "urls", text: record2.tabs.map((tab) => tab.url).join(" ") },
+      { field: "titles", text: record2.tabs.map((tab) => tab.title).join(" ") },
+      { field: "names", text: [record2.name, record2.folder ?? "", ...record2.tags].join(" ") },
+      { field: "text", text: record2.tabs.flatMap((tab) => tab.forms.map((form) => form.value)).join(" ") }
+    ];
+    for (const haystack of haystacks) {
+      if (!query.fields.includes(haystack.field)) continue;
+      const lower = haystack.text.toLowerCase();
+      for (const term of query.terms) {
+        const at = lower.indexOf(term.toLowerCase());
+        if (at < 0) continue;
+        const start = Math.max(0, at - 30);
+        matches.push({ sessionid: record2.id, field: haystack.field, term, at: record2.createdat, excerpt: haystack.text.slice(start, start + 80).trim() });
+      }
+    }
+  }
+  return matches;
+}
+function exportsessionfile(records, now) {
+  const recordids = records.map((record2) => record2.id);
+  const payload = JSON.stringify(records);
+  return { formatversion: sessionfileversion, records, recordids, bytesize: payload.length, checksum: checksumtext(`${sessionfileversion}:${recordids.join(",")}:${payload.length}`), exportedat: now };
+}
+function importsessionfile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (candidate.formatversion !== sessionfileversion) return void 0;
+  const records = Array.isArray(candidate.records) ? candidate.records.flatMap((record2) => sessionrecordvalid(record2) ? [record2] : []) : [];
+  if (records.length === 0) return void 0;
+  if (!Array.isArray(candidate.recordids) || candidate.recordids.length !== records.length || !candidate.recordids.every((id, index) => id === records[index]?.id)) return void 0;
+  const bytesize = typeof candidate.bytesize === "number" && Number.isFinite(candidate.bytesize) ? candidate.bytesize : -1;
+  if (bytesize < 0) return void 0;
+  const checksum = typeof candidate.checksum === "string" ? candidate.checksum : "";
+  if (checksum !== checksumtext(`${sessionfileversion}:${candidate.recordids.join(",")}:${bytesize}`)) return void 0;
+  return { formatversion: sessionfileversion, records, recordids: candidate.recordids, bytesize, checksum, exportedat: typeof candidate.exportedat === "number" && Number.isFinite(candidate.exportedat) ? candidate.exportedat : 0 };
+}
+function sessionrecordvalid(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value;
+  if (typeof candidate.id !== "string" || !candidate.id.trim()) return false;
+  if (typeof candidate.name !== "string" || !candidate.name.trim()) return false;
+  if (typeof candidate.createdat !== "number" || !Number.isFinite(candidate.createdat)) return false;
+  if (!Array.isArray(candidate.tabs) || !candidate.tabs.every((tab) => sessiontabof(tab) !== void 0)) return false;
+  if (!Array.isArray(candidate.captures) || !candidate.captures.every((id) => typeof id === "string")) return false;
+  if (!Array.isArray(candidate.tags) || !candidate.tags.every((tag) => typeof tag === "string")) return false;
+  return true;
+}
+function expiresessions(records, retention, now) {
+  if (retention === void 0 || !Number.isFinite(retention)) return records;
+  return records.map((record2) => {
+    if (record2.sectionsexpired || now - record2.createdat < retention) return record2;
+    return { id: record2.id, name: record2.name, createdat: record2.createdat, tabs: [], captures: record2.captures, storage: [], cookies: [], ...record2.folder !== void 0 ? { folder: record2.folder } : {}, tags: record2.tags, ...record2.auto === true ? { auto: true } : {}, ...record2.restoredat !== void 0 ? { restoredat: record2.restoredat } : {}, sectionsexpired: true };
+  });
+}
+function filteredsessions(records, filter) {
+  return records.filter((record2) => {
+    if (filter.name !== void 0 && !record2.name.toLowerCase().includes(filter.name.toLowerCase())) return false;
+    if (filter.folder !== void 0 && record2.folder !== filter.folder) return false;
+    if (filter.from !== void 0 && record2.createdat < filter.from) return false;
+    if (filter.to !== void 0 && record2.createdat > filter.to) return false;
+    return true;
+  });
+}
+function crashinterrupted(state, plansteps, now) {
+  if (!state) return void 0;
+  if (state.stepcursor >= plansteps) return state;
+  return { ...state, interrupted: true, crashat: state.crashat ?? now };
+}
+
 // memory.ts
 var sessionmemory = class {
   constructor(adapter) {
@@ -2517,6 +2907,169 @@ var sessionmemory = class {
     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") ?? [];
+  }
+  /** Returns the persisted task state checkpoint of one run so the run resumes after a service worker restart. */
+  async gettaskstate(runid) {
+    return this.adapter.get(`taskstate${runid}`);
+  }
+  /** Persists one task state checkpoint per run with its corruption checksum. */
+  async settaskstate(state) {
+    return this.adapter.set(`taskstate${state.runid}`, state);
+  }
+  /** Returns the session event history with timestamps, newest first. */
+  async getsessionevents() {
+    return await this.adapter.get("sessionevents") ?? [];
+  }
+  /** Records one session event of the run with its timestamp and detail. */
+  async addsessionevent(event) {
+    const records = await this.getsessionevents();
+    await this.adapter.set("sessionevents", [event, ...records]);
+  }
+  /** Returns every saved session record with its sections, newest first. */
+  async getsessionrecords() {
+    return await this.adapter.get("sessionrecords") ?? [];
+  }
+  /** Adds one saved session record to the library. */
+  async addsessionrecord(record2) {
+    const records = await this.getsessionrecords();
+    await this.adapter.set("sessionrecords", [record2, ...records]);
+  }
+  /** Replaces one saved session record by its id after a filing or restore touches it. */
+  async updatesessionrecord(record2) {
+    const records = await this.getsessionrecords();
+    await this.adapter.set("sessionrecords", records.map((item) => item.id === record2.id ? record2 : item));
+  }
+  /** Lists saved sessions filtered by name substring, folder and time window; the filter stays a user choice with no result cap. */
+  async listsessions(filter) {
+    return filteredsessions(await this.getsessionrecords(), filter);
+  }
+  /** Returns one saved session with every section; an expired record carries its metadata only. */
+  async getsessionrecord(id) {
+    return (await this.getsessionrecords()).find((record2) => record2.id === id);
+  }
+  /** Runs the reviewed search query across every stored session and returns the matches with their session ids and time windows. */
+  async searchmemory(query) {
+    return searchsessionrecords(query, await this.getsessionrecords());
+  }
+  /** Returns the folder tree of the session library. */
+  async getsessionfolders() {
+    return await this.adapter.get("sessionfolders") ?? [];
+  }
+  /** Replaces the folder tree after a reviewed filing adds or moves one folder. */
+  async setsessionfolders(folders) {
+    return this.adapter.set("sessionfolders", folders);
+  }
+  /** Returns every stored session diff result, newest first. */
+  async getsessiondiffs() {
+    return await this.adapter.get("sessiondiffs") ?? [];
+  }
+  /** Stores one session diff result for later review. */
+  async addsessiondiff(diff) {
+    const records = await this.getsessiondiffs();
+    await this.adapter.set("sessiondiffs", [diff, ...records]);
+  }
+  /** Returns the persisted auto snapshot state with the reviewed interval, the last snapshot time and the snapshot count. */
+  async getautosnapshot() {
+    return await this.adapter.get("autosnapshot") ?? void 0;
+  }
+  /** Stores the auto snapshot state of the reviewed interval. */
+  async setautosnapshot(state) {
+    return this.adapter.set("autosnapshot", state);
+  }
+  /** Clears the auto snapshot interval so on demand captures stay the only source of records. */
+  async clearautosnapshot() {
+    return this.adapter.set("autosnapshot", null);
+  }
+  /** Expires the heavy sections of saved sessions after the reviewed retention window while the record metadata survives. */
+  async applysessionexpiry(retention, now) {
+    const records = expiresessions(await this.getsessionrecords(), retention, now);
+    await this.adapter.set("sessionrecords", records);
+    return records;
+  }
+  /** Returns the crash marker of a run interrupted by a browser restart. */
+  async getcrashflag() {
+    return await this.adapter.get("crashed") ?? false;
+  }
+  /** Sets the crash marker so the sessions view offers the crash restore inside the consent model. */
+  async setcrashflag(value) {
+    return this.adapter.set("crashed", value);
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -3463,9 +4016,9 @@ function polldecision(input) {
 }
 
 // policy.ts
-var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts", "recordscreen", "captureaudio", "downloadimages", "callrest", "callgraphql", "sendmessage", "blockrequest", "mockresponse", "rewriteheaders", "setcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles", "attachcdp", "detachcdp", "cdpcmd", "overridescript", "heapshot", "profilecpu", "capturesourcemaps"]);
+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", "restoresession", "exportsessions", "importsessions"]);
 var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction", "capturebodies", "setbreakpoint", "stepcode", "watchexpr"]);
-var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures", "shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet", "capturepdf", "captureframe", "readmedia", "readassets", "probestream", "timelapse", "shotcanvas", "convertimage", "makethumbs", "fetchurl", "parsejson", "parsehtml", "opensocket", "waitmessage", "watchrequests", "readheaders", "mapapi", "subscribesse", "longpoll", "extractapi", "readcookies", "watchconsole", "watcherrors", "watchtasks", "watchcdp", "measureflow", "trackmemory", "watchshifts", "traceload", "annotatetrace", "replaytrace"]);
+var 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", "persiststate", "capturesession", "namedsessions", "diffsessions", "searchsessions"]);
 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"]);
@@ -3484,6 +4037,8 @@ var controlactions = /* @__PURE__ */ new Set(["blockrequest", "mockresponse", "r
 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 sessionactions = /* @__PURE__ */ new Set(["persiststate", "capturesession", "restoresession", "namedsessions", "diffsessions", "searchsessions", "exportsessions", "importsessions"]);
 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"]);
@@ -3499,6 +4054,9 @@ function hostpattern(origin) {
   if (parsed.protocol !== "https:") throw new Error("Only HTTPS origins can be granted.");
   return `${parsed.origin}/*`;
 }
+function issessionkind(kind) {
+  return sessionactions.has(kind);
+}
 function iswatchkind(kind) {
   return watchactions.has(kind);
 }
@@ -3511,6 +4069,9 @@ function iscdpkind(kind) {
 function isprofilekind(kind) {
   return profileractions.has(kind);
 }
+function isemulationkind(kind) {
+  return emulationactions.has(kind);
+}
 function observationmodeof(kind) {
   if (watchactions.has(kind) || debugactions.has(kind) || profileractions.has(kind) && kind !== "heapshot" && kind !== "replaytrace" && kind !== "annotatetrace" && kind !== "capturesourcemaps" && kind !== "profilecpu" || cdpactions.has(kind) && kind === "watchcdp" || kind === "waitquiet") return "watching";
   if (kind === "diffsnapshots") return "diffing";
@@ -4795,6 +5356,176 @@ function pauseretentionwindow(settings) {
 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 emulationretentionwindow(settings) {
+  return settings?.emulationretention;
+}
+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 permissionnamevalid(name) {
+  if (!browserpermissions.includes(name)) return { allowed: false, reason: `The permission ${name} stays outside the reviewed browser permission set: ${browserpermissions.join(", ")}.` };
+  return { allowed: true };
+}
+function validatesessiongrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "persiststate") {
+    if (options.resume !== void 0 && typeof options.resume !== "boolean") return { allowed: false, reason: "The reviewed resume flag must be a boolean." };
+    return { allowed: true };
+  }
+  if (kind === "capturesession") {
+    const plan = snapshotplanof(options.snapshot);
+    if (!plan) return { allowed: false, reason: "The session capture needs a reviewed snapshot plan with its scope, a non-empty section list of the reviewed grammar (tabs, scroll, forms, storage, cookies) and the capture link flag." };
+    if (plan.auto !== void 0) {
+      const interval = autointervalof(options.snapshot.auto);
+      if (interval === void 0) return { allowed: false, reason: "The reviewed auto snapshot interval needs a positive period, a positive maximum snapshot count and a zero or positive expiry window with no code ceiling." };
+    }
+    return { allowed: true };
+  }
+  if (kind === "restoresession") {
+    if (typeof options.sessionid !== "string" || !options.sessionid.trim()) return { allowed: false, reason: "The session restore needs the reviewed session id of the saved record." };
+    if (restoreplanof(options.restore) === void 0) return { allowed: false, reason: "The session restore needs a reviewed restore plan with its tab, form and capture policies." };
+    if (options.reviewed !== true) return { allowed: false, reason: "Every session restore needs the explicit restore review with its tabs, form state and captures listed before it reopens anything." };
+    return { allowed: true };
+  }
+  if (kind === "namedsessions") {
+    if (typeof options.sessionid !== "string" || !options.sessionid.trim()) return { allowed: false, reason: "The session filing needs the reviewed session id of the saved record." };
+    if (typeof options.name !== "string" || !options.name.trim()) return { allowed: false, reason: "The session filing needs a reviewed non-empty session name." };
+    if (options.folder !== void 0 && (typeof options.folder !== "string" || !options.folder.trim())) return { allowed: false, reason: "The reviewed folder name must be a non-empty string." };
+    if (options.tags !== void 0 && (!Array.isArray(options.tags) || !options.tags.every((tag) => typeof tag === "string" && tag.trim()))) return { allowed: false, reason: "The reviewed tag list must be a list of non-empty strings." };
+    return { allowed: true };
+  }
+  if (kind === "diffsessions") {
+    if (typeof options.left !== "string" || !options.left.trim() || typeof options.right !== "string" || !options.right.trim()) return { allowed: false, reason: "The session diff needs the reviewed ids of both saved sessions." };
+    return { allowed: true };
+  }
+  if (kind === "searchsessions") {
+    if (searchqueryof(options.query) === void 0) return { allowed: false, reason: "The session search needs a reviewed query with a non-empty term list, fields of the reviewed grammar (urls, titles, names, text) and an optional time window." };
+    return { allowed: true };
+  }
+  if (kind === "exportsessions") {
+    if (options.reviewed !== true) return { allowed: false, reason: "Session exports need the explicit export review before any session file leaves the device." };
+    if (options.ids !== void 0 && (!Array.isArray(options.ids) || options.ids.length === 0 || !options.ids.every((id) => typeof id === "string" && id.trim()))) return { allowed: false, reason: "The reviewed export id list must be a non-empty list of saved session ids." };
+    return { allowed: true };
+  }
+  if (kind === "importsessions") {
+    if (options.reviewed !== true) return { allowed: false, reason: "Session imports need the explicit full record review before any record joins the library." };
+    if (importsessionfile(options.file) === void 0) return { allowed: false, reason: "The session import needs a reviewed file of the known format version with an intact checksum." };
+    return { allowed: true };
+  }
+  return { allowed: true };
+}
+function restorereviewgranted(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  if (restoreplanof(options.restore) === void 0) return { allowed: false, reason: "Every session restore needs a reviewed restore plan with its tab, form and capture policies." };
+  if (options.reviewed !== true) return { allowed: false, reason: "The session restore needs the explicit restore review of its tabs, form state and captures before it reopens anything." };
+  return { allowed: true };
+}
+function sessionrestoregate(input) {
+  const gate = sessiongate({ session: input.session, tabid: input.tabid, origin: input.origin, now: input.now, action: "run the session memory step" });
+  if (!gate.allowed) return gate;
+  if (!input.plan || input.plan.state !== "approved") return { allowed: false, reason: "Session memory steps need an approved plan before they run." };
+  if (input.step.kind === "restoresession") return restorereviewgranted(input.step);
+  return { allowed: true };
+}
+function restoreoriginsgranted(urls, grants) {
+  const covered = new Set(grants);
+  const skippedorigins = [];
+  for (const url of urls) {
+    let origin = "";
+    try {
+      origin = new URL(url).origin;
+    } catch {
+      origin = "";
+    }
+    if (!origin || !covered.has(origin)) skippedorigins.push(origin || url);
+  }
+  return { allowed: skippedorigins.length === 0, skippedorigins: [...new Set(skippedorigins)] };
+}
+function sessionnameunique(name, records, recordid) {
+  if (records.some((record2) => record2.name === name && record2.id !== recordid)) return { allowed: false, reason: `The session name ${name} already exists in the library; review a unique name.` };
+  return { allowed: true };
+}
+function sessionfolderunique(name, folders) {
+  if (folders.some((folder) => folder.name === name)) return { allowed: false, reason: `The folder name ${name} already exists in the library; review a unique folder name.` };
+  return { allowed: true };
+}
+function snapshotretentionwindow(settings) {
+  return settings?.sessionretention;
+}
+function permissionstatevalid(state) {
+  if (!permissionstates.includes(state)) return { allowed: false, reason: `The reviewed permission state must be one of ${permissionstates.join(", ")}.` };
+  return { allowed: true };
+}
 function validatecdpgrammar(step, options) {
   const kind = step.kind;
   if (kind === "attachcdp") {
@@ -5352,6 +6083,14 @@ function validatestep(step, origin) {
     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 (issessionkind(step.kind)) {
+    const sessioncheck = validatesessiongrammar(step, options);
+    if (!sessioncheck.allowed) return sessioncheck;
+  }
   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." };
@@ -5521,6 +6260,27 @@ function canexecute(input) {
       }
     }
   }
+  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 (issessionkind(input.step.kind)) {
+    const sessiongatecheck = sessionrestoregate({ session: input.session, plan: input.plan, step: input.step, tabid: input.tabid, origin: input.origin, now });
+    if (!sessiongatecheck.allowed) return sessiongatecheck;
+    if (input.step.kind === "restoresession") {
+      let restoreoptions = {};
+      try {
+        restoreoptions = parseoptions(input.step);
+      } catch {
+        restoreoptions = {};
+      }
+      for (const url of Array.isArray(restoreoptions.origins) ? restoreoptions.origins : []) {
+        if (typeof url !== "string" || !url) continue;
+        const origingate = origincheck(input.session, url);
+        if (!origingate.allowed) return { allowed: false, reason: `The session restore reopens ${url} outside the session origin grants; review the restore record or grant the origin.` };
+      }
+    }
+  }
   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;
@@ -5604,7 +6364,7 @@ function canexecute(input) {
 }
 
 // version.ts
-var packageversion = "1.1.47";
+var packageversion = "1.1.49";
 
 // types.ts
 var protocolversion = packageversion;
@@ -5776,6 +6536,50 @@ function parseproposal(value, origin, 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.");
+    }
+    if (issessionkind(step.kind)) {
+      let sessionoptions = {};
+      try {
+        sessionoptions = parseoptions(step);
+      } catch {
+        sessionoptions = {};
+      }
+      if (step.kind === "restoresession") {
+        for (const url of Array.isArray(sessionoptions.origins) ? sessionoptions.origins : []) {
+          if (typeof url !== "string" || !url) continue;
+          const granted = covered.some((pattern) => {
+            try {
+              return new URL(url).origin === new URL(pattern).origin;
+            } catch {
+              return false;
+            }
+          });
+          if (!granted) throw new Error(`The session restore reopens ${url} outside the grants.`);
+        }
+      }
+      if (step.kind === "importsessions" && importsessionfile(sessionoptions.file) === void 0) throw new Error("Session import files of unknown format versions are refused.");
+    }
     const evaluation = validatestep(step, origin);
     if (!evaluation.allowed) throw new Error(evaluation.reason);
     const target = outboundtarget(step);
@@ -5850,7 +6654,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 } : {}, ...input.profile ? { profile: input.profile } : {} });
+  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 } : {}, ...input.session ? { session: input.session } : {} });
 }
 function mapresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
@@ -5988,7 +6792,21 @@ function profilereport(input) {
   });
   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 };
+}
+function sessionreport(input) {
+  return { version: protocolversion, records: input.records, events: input.events, folders: input.folders, diffs: input.diffs, ...input.auto !== void 0 ? { auto: input.auto } : {}, ...input.crashed === true ? { crashed: true } : {} };
+}
 export {
+  activelayers,
+  agentgrammarvalid,
+  agentpresetof,
   allowlistcovers,
   annotatetrace,
   annotationof,
@@ -5997,6 +6815,7 @@ export {
   apikeyconsentgranted,
   apireplayspecof,
   applyheaderules,
+  applylayer,
   argkind,
   assetentries,
   attachcdpsession,
@@ -6005,6 +6824,10 @@ export {
   authconsentgranted,
   authorizeurl,
   authreport,
+  autointervalof,
+  blackboxedurls,
+  blackboxmatches,
+  blackboxruleof,
   blendrows,
   blockgate,
   blockingduration,
@@ -6014,6 +6837,7 @@ export {
   breakpointbudgetallowed,
   breakpointceilingof,
   breakpointinputof,
+  browserpermissions,
   buildname,
   buildpdf,
   buildsheet,
@@ -6059,6 +6883,7 @@ export {
   cookierecordof,
   correlationid,
   cpusnap,
+  crashinterrupted,
   croprect,
   crossesviewport,
   cursorfrom,
@@ -6069,19 +6894,33 @@ export {
   dedupeimages,
   actionrisk as deriveactionrisk,
   detachcdpsession,
+  devicepresetof,
   diffresponse,
   diffreviewgrade,
+  diffsessionrecords,
   downloadreport,
+  emugate,
+  emulationkinds,
+  emulationreport,
+  emulationretentionwindow,
+  emulationstackallowed,
+  emulationstateof,
   errorcapture,
   errorreportresponse,
   eventresponse,
   exchangesreport,
+  expirelayers,
   expireprofilerecords,
+  expiresessions,
+  exportpresetlibrary,
+  exportsessionfile,
   extractionreport,
   extractvalues,
   failureclass,
+  familyofkind,
   fetchoptionsof,
   fetchrequestof,
+  filteredsessions,
   filterentries,
   filterexchanges,
   finishrecording,
@@ -6101,25 +6940,35 @@ export {
   heapintervalallowed,
   heapsnap,
   heldkeysreport,
+  hideblackboxedframes,
   hostpattern,
   htmlqueriesof,
   httpkinds,
   imagefilterof,
   imagematches,
   imagenames,
+  importpresetlibrary,
+  importsessionfile,
   iscdpkind,
   iscontrolkind,
   isdebugkind,
+  isemulationkind,
   isformkind,
   isnetwatchkind,
   isprofilekind,
+  issessionkind,
   issocketkind,
   iswatchkind,
   jsonpathrulesof,
   lapseframes,
   lapseplanof,
+  layernames,
   layoutreport,
   levelrank,
+  locationconsentcovers,
+  locationconsentgate,
+  locationpresetof,
+  locationrangevalid,
   loglevels,
   longtaskcapture,
   mapresponse,
@@ -6140,12 +6989,16 @@ export {
   netfailureentryof,
   netlogreport,
   netwatchkinds,
+  networkpresetof,
   newblockrule,
   newchannel,
   newexchange,
   newheaderule,
+  newlayer,
   newmockspec,
   newrecording,
+  newsessiondiff,
+  newsessionrecord,
   normalizeendpoint,
   oauthflowof,
   observationmodeof,
@@ -6170,6 +7023,11 @@ export {
   pdfpagesize,
   pdfsegments,
   pdftextlayout,
+  permissiongrade,
+  permissiongrantof,
+  permissionnamevalid,
+  permissionstates,
+  permissionstatevalid,
   planallowlist,
   pollcursorof,
   polldecision,
@@ -6206,7 +7064,13 @@ export {
   resolutionverdict,
   resolvedrisk,
   resourcefacts,
+  restoreoriginsgranted,
+  restoreplanof,
+  restorereviewgranted,
   retryafterof,
+  revertalllayers,
+  revertlayer,
+  revertplanof,
   revertrule,
   revocationruleof,
   rewritesourcelocation,
@@ -6215,21 +7079,36 @@ export {
   safetyresponse,
   scaledrect,
   seamweights,
+  searchfields,
+  searchqueryof,
+  searchsessionrecords,
   selectorresponse,
   sendcdpcommand,
   sendfetch,
   sequenceintegrity,
   serializearg,
   serializecdpcommand,
+  sessionfileversion,
+  sessionfolderof,
+  sessionfolderunique,
+  sessionkinds,
   sessionmemory,
+  sessionnameunique,
+  sessionreport,
+  sessionrestoregate,
+  sessiontabof,
   shiftentryof,
   signalsreport,
+  snapshotplanof,
+  snapshotretentionwindow,
+  snapshotsections,
   socketgate,
   socketkinds,
   sourcemapconsentcovers,
   spamdetect,
   spamruleof,
   sserequestheaders,
+  stackedcount,
   stackframes,
   stackgate,
   statusclassof,
@@ -6241,6 +7120,9 @@ export {
   subscriptionoptionsof,
   tabreportresponse,
   targetgate,
+  taskstatechecksum,
+  taskstateof,
+  taskstatevalid,
   teardowncdpsession,
   teardownplanof,
   templateurl,