@wenathlan/extension 1.1.48 → 1.1.49

package/extension/dist/background.js

@@ -374,6 +374,212 @@ 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);
 }
 
+// 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 checksum2 = typeof candidate.checksum === "string" ? candidate.checksum : "";
+  if (checksum2 !== checksumtext(`${sessionfileversion}:${candidate.recordids.join(",")}:${bytesize}`)) return void 0;
+  return { formatversion: sessionfileversion, records, recordids: candidate.recordids, bytesize, checksum: checksum2, 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) {
@@ -1821,6 +2027,92 @@ var sessionmemory = class {
   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";
@@ -3040,9 +3332,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", "heapshot", "profilecpu", "capturesourcemaps", "emulatedevice", "emulatenetwork", "emulatelocate", "setuseragent", "overridepermission"]);
+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", "blackboxscripts"]);
+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"]);
@@ -3062,6 +3354,7 @@ var debugactions = /* @__PURE__ */ new Set(["watchconsole", "watcherrors", "watc
 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"]);
@@ -3077,6 +3370,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 isdebugkind(kind) {
   return debugactions.has(kind);
 }
@@ -3115,6 +3411,8 @@ function requiredcapability(kind) {
   if (kind === "writeclipboard" || kind === "copyscreen") return "clipboardWrite";
   if (kind === "downloadimages") return "downloads";
   if (kind === "authflow") return "tabs";
+  if (kind === "capturesession" || kind === "restoresession") return "tabs";
+  if (kind === "exportsessions") return "downloads";
   if (kind === "openlink" || kind === "openprivate" || kind === "navlist" || kind === "batchopen" || kind === "reopentab" || kind === "deeplink") return "tabs";
   if (tabscommandactions.has(kind)) return "tabs";
   return void 0;
@@ -4520,6 +4818,97 @@ function validateemulationgrammar(step, options) {
   }
   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 validatecdpgrammar(step, options) {
   const kind = step.kind;
   if (kind === "attachcdp") {
@@ -5085,6 +5474,10 @@ function validatestep(step, origin) {
     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." };
@@ -5258,6 +5651,23 @@ function canexecute(input) {
     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;
@@ -5508,9 +5918,15 @@ function recordemulation(progress, planid, stepid, entry, 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);
 }
+function recordsession(progress, planid, stepid, entry, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  const counts = `${entry.sections !== void 0 ? `${entry.sections} section${entry.sections === 1 ? "" : "s"}, ` : ""}${entry.matches !== void 0 ? `${entry.matches} match${entry.matches === 1 ? "" : "es"}, ` : ""}${entry.restored !== void 0 ? `${entry.restored} restored tab${entry.restored === 1 ? "" : "s"}, ` : ""}${entry.skipped !== void 0 ? `${entry.skipped} skipped origin${entry.skipped === 1 ? "" : "s"}, ` : ""}${entry.cursor !== void 0 ? `cursor ${entry.cursor}, ` : ""}${entry.bytes !== void 0 ? `${entry.bytes} byte${entry.bytes === 1 ? "" : "s"}, ` : ""}`.replace(/, $/, "");
+  const outcome = { stepid, ok: true, summary: `${entry.detail}${counts.length > 0 ? ` with ${counts}` : ""}.`, details: { session: entry }, at: now };
+  return recordoutcome(base, planid, outcome, now);
+}
 
 // version.ts
-var packageversion = "1.1.48";
+var packageversion = "1.1.49";
 
 // types.ts
 var protocolversion = packageversion;
@@ -5704,6 +6120,28 @@ function parseproposal(value, origin, grants) {
       }
       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);
@@ -5778,7 +6216,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 } : {}, ...input.emulation ? { emulation: input.emulation } : {} });
+  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 });
@@ -5909,6 +6347,9 @@ function emulationreport(input) {
   });
   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 } : {} };
+}
 
 // capture.ts
 var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
@@ -6485,6 +6926,46 @@ async function runbrowseraction(step, sessiontabid, windowid) {
   }
 }
 
+// extension/pagesession.ts
+function capturepagestate(sections) {
+  const wants = (section) => sections.includes(section);
+  const forms = [];
+  if (wants("forms")) {
+    const elements = Array.from(document.querySelectorAll("input, textarea, select"));
+    elements.forEach((element, index) => {
+      if (element.type === "password") return;
+      const selector = element.id ? `#${element.id}` : element.name ? `[name="${element.name}"]` : `${element.tagName.toLowerCase()}:nth-of-type(${index + 1})`;
+      forms.push({ selector, value: element.value });
+    });
+  }
+  const storagekeys = [];
+  const storagevalues = [];
+  if (wants("storage")) {
+    for (let index = 0; index < localStorage.length; index += 1) {
+      const key = localStorage.key(index);
+      if (key === null) continue;
+      storagekeys.push(key);
+      storagevalues.push(localStorage.getItem(key) ?? "");
+    }
+  }
+  const cookienames = wants("cookies") ? document.cookie.split(";").map((part) => part.split("=")[0]?.trim() ?? "").filter((name) => name.length > 0) : [];
+  return { scrollx: window.scrollX, scrolly: window.scrollY, forms, storagekeys, storagevalues, cookienames };
+}
+function restorepagestate(state) {
+  window.scrollTo(state.scrollx, state.scrolly);
+  let restored = 0;
+  for (const form of Array.isArray(state.forms) ? state.forms : []) {
+    const element = document.querySelector(form.selector);
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) {
+      element.value = form.value;
+      element.dispatchEvent(new Event("input", { bubbles: true }));
+      element.dispatchEvent(new Event("change", { bubbles: true }));
+      restored += 1;
+    }
+  }
+  return { restored, summary: `Restored the scroll position and ${restored} form field${restored === 1 ? "" : "s"} of the reopened tab.` };
+}
+
 // extension/tabscommand.ts
 function parsetabquery(step) {
   let options = {};
@@ -7597,7 +8078,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], profile: [...profilerkinds], emulation: [...emulationkinds] };
+  const withmedia = { ...report, captures: [...capturekinds], media: [...mediakinds], http: [...httpkinds], netwatch: [...socketkinds, ...netwatchkinds], control: [...controlkinds], debug: [...timelinekinds, ...cdpkinds], profile: [...profilerkinds], emulation: [...emulationkinds], sessions: [...sessionkinds] };
   await memory.setcapabilities(withmedia);
   return withmedia;
 }
@@ -7736,6 +8217,7 @@ function browserauditkind(step) {
   return "tab";
 }
 function stepauditkind(step, ok) {
+  if (issessionkind(step.kind)) return "session";
   if (isbrowserkind(step.kind)) return browserauditkind(step);
   if (istabscommandkind(step.kind)) {
     if (step.kind === "grouptabs" || step.kind === "colorgroup" || step.kind === "collapsegroup") return "group";
@@ -11818,6 +12300,183 @@ async function executeemulationstep(step, session, plan, tabid2, origin) {
   await refreshbadge();
   return { ok: true, summary: output.summary, details: { ...output.details ?? {}, emulation: { applied: [name], reverted: [] } } };
 }
+var restoreloadwindow = 4e3;
+var restorepollstep = 200;
+async function waittabloaded(tabid2) {
+  const started = Date.now();
+  while (Date.now() - started < restoreloadwindow) {
+    const tab = await chrome.tabs.get(tabid2).catch(() => void 0);
+    if (!tab || tab.status === "complete") return;
+    await new Promise((resolve) => setTimeout(resolve, restorepollstep));
+  }
+}
+async function capturesessionrecord(plan, session, runid) {
+  const grants = session.grants ?? [session.origin];
+  const query = plan.scope === "all" ? {} : plan.scope === "run" ? { currentWindow: true } : { active: true, currentWindow: true };
+  const tabs = await chrome.tabs.query(query).catch(() => []);
+  const capturedtabs = [];
+  const storage = [];
+  const cookies = [];
+  for (const tab of tabs) {
+    const url = tab.url ?? "";
+    if (!url.startsWith("http")) continue;
+    let taborigin = "";
+    try {
+      taborigin = new URL(url).origin;
+    } catch {
+      taborigin = "";
+    }
+    let state;
+    if (tab.id !== void 0 && (plan.sections.includes("scroll") || plan.sections.includes("forms") || plan.sections.includes("storage") || plan.sections.includes("cookies"))) {
+      state = await chrome.scripting.executeScript({ target: { tabId: tab.id }, func: capturepagestate, args: [plan.sections] }).then((result) => result[0]?.result).catch(() => void 0);
+    }
+    capturedtabs.push({ url, title: tab.title ?? "", index: tab.index ?? 0, scrollx: state?.scrollx ?? 0, scrolly: state?.scrolly ?? 0, forms: plan.sections.includes("forms") ? state?.forms ?? [] : [] });
+    if (state && taborigin && grants.includes(taborigin)) {
+      if (plan.sections.includes("storage") && state.storagekeys.length > 0) storage.push({ origin: taborigin, keys: state.storagekeys, values: state.storagevalues });
+      if (plan.sections.includes("cookies") && state.cookienames.length > 0) cookies.push({ origin: taborigin, names: state.cookienames });
+    }
+  }
+  const captures = plan.captures ? (await memory.getcaptures()).filter((record2) => record2.runid === runid).map((record2) => record2.id) : [];
+  return newsessionrecord({ id: randomid(), name: `session ${new Date(Date.now()).toISOString()}`, createdat: Date.now(), tabs: capturedtabs.sort((left, right) => left.index - right.index), captures, storage, cookies });
+}
+async function performrestore(record2, restore, session) {
+  const grants = session.grants ?? [session.origin];
+  const grantscheck = restoreoriginsgranted(record2.tabs.map((tab) => tab.url), grants);
+  const restored = [];
+  for (const tab of [...record2.tabs].sort((left, right) => left.index - right.index)) {
+    if (restore.tabpolicy !== "reopen") break;
+    let taborigin = "";
+    try {
+      taborigin = new URL(tab.url).origin;
+    } catch {
+      taborigin = "";
+    }
+    if (!taborigin || !grants.includes(taborigin)) continue;
+    const created = await chrome.tabs.create({ url: tab.url, index: tab.index, active: false }).catch(() => void 0);
+    if (!created?.id) continue;
+    await waittabloaded(created.id);
+    if (restore.formpolicy === "restore") {
+      await chrome.scripting.executeScript({ target: { tabId: created.id }, func: restorepagestate, args: [{ scrollx: tab.scrollx, scrolly: tab.scrolly, forms: tab.forms }] }).catch(() => {
+      });
+    }
+    restored.push(tab);
+  }
+  await memory.updatesessionrecord({ ...record2, restoredat: Date.now() });
+  return { restored, skippedorigins: grantscheck.skippedorigins };
+}
+async function executesessionstep(step, session, plan, tabid2, origin) {
+  const options = stepoptions2(step);
+  const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
+  if (step.kind === "persiststate") {
+    const progress = await memory.getprogress();
+    const tracked = progress && progress.planid === plan.id ? progress : void 0;
+    const state = taskstateof({ runid: plan.id, stepcursor: tracked?.completedsteps.length ?? 0, outputs: tracked?.outcomes ?? [], checkpointat: Date.now() });
+    await memory.settaskstate(state);
+    await memory.addsessionevent({ id: randomid(), kind: "persist", at: Date.now(), tabid: tabid2, detail: `Checkpointed the run at step cursor ${state.stepcursor} of ${plan.steps.length}.` });
+    await memory.setprogress(recordsession(await memory.getprogress(), plan.id, step.id, { family: "persist", detail: "Checkpointed the task state of the run", cursor: state.stepcursor }, Date.now()));
+    await audit("session", `Persisted the task state checkpoint of run ${plan.id} at step cursor ${state.stepcursor} of ${plan.steps.length}; the checksum detects corruption before any resume and the run resumes from it after a service worker restart.`, extra);
+    return { ok: true, summary: `Task state checkpointed at step cursor ${state.stepcursor}.`, details: { session: { family: "persist", detail: "Task state checkpoint", cursor: state.stepcursor } } };
+  }
+  if (step.kind === "capturesession") {
+    const snapshot2 = snapshotplanof(options.snapshot);
+    if (!snapshot2) throw new Error("A reviewed snapshot plan is required before the session capture runs.");
+    const record2 = await capturesessionrecord(snapshot2, session, plan.id);
+    await memory.addsessionrecord(record2);
+    if (snapshot2.auto) {
+      const current = await memory.getautosnapshot();
+      await memory.setautosnapshot({ interval: snapshot2.auto, lastat: Date.now(), count: current?.count ?? 0 });
+    }
+    await memory.addsessionevent({ id: randomid(), kind: "capture", at: Date.now(), tabid: tabid2, detail: `Captured ${record2.tabs.length} tabs with the ${snapshot2.sections.join(", ")} sections into record ${record2.id}.` });
+    await memory.setprogress(recordsession(await memory.getprogress(), plan.id, step.id, { family: "capture", detail: `Captured the browsing session record ${record2.id}`, recordid: record2.id, sections: snapshot2.sections.length }, Date.now()));
+    await audit("session", `Captured the browsing session record ${record2.id} of ${record2.tabs.length} tab${record2.tabs.length === 1 ? "" : "s"} with the ${snapshot2.sections.join(", ")} sections${snapshot2.captures ? ` linking ${record2.captures.length} capture record${record2.captures.length === 1 ? "" : "s"}` : ""}${snapshot2.auto ? ` and the reviewed auto interval of ${snapshot2.auto.period} milliseconds with at most ${snapshot2.auto.maxsnapshots} snapshot${snapshot2.auto.maxsnapshots === 1 ? "" : "s"}` : ""}; the local storage and cookie names of ungranted origins stayed out of the capture.`, extra);
+    return { ok: true, summary: `Captured ${record2.tabs.length} tabs into the session record ${record2.id}.`, details: { snapshotid: record2.id, session: { family: "capture", detail: `Session record ${record2.id}`, recordid: record2.id, sections: snapshot2.sections.length } } };
+  }
+  if (step.kind === "restoresession") {
+    const restore = restoreplanof(options.restore);
+    if (!restore) throw new Error("A reviewed restore plan is required before the session restore runs.");
+    const record2 = await memory.getsessionrecord(String(options.sessionid ?? ""));
+    if (!record2) throw new Error(`No saved session matches ${String(options.sessionid ?? "")}.`);
+    if (record2.sectionsexpired) throw new Error("The saved session sections expired after the retention window; only the record metadata survives for review.");
+    const outcome = await performrestore(record2, restore, session);
+    await memory.addsessionevent({ id: randomid(), kind: "restore", at: Date.now(), tabid: tabid2, detail: `Restored ${outcome.restored.length} tabs of record ${record2.id}${outcome.skippedorigins.length > 0 ? ` and skipped ${outcome.skippedorigins.join(", ")}` : ""}.` });
+    await memory.setprogress(recordsession(await memory.getprogress(), plan.id, step.id, { family: "restore", detail: `Restored the session record ${record2.id}`, recordid: record2.id, sections: record2.tabs.length, restored: outcome.restored.length, skipped: outcome.skippedorigins.length }, Date.now()));
+    await audit("session", `Restored the saved session ${record2.id} on demand: ${outcome.restored.length} tab${outcome.restored.length === 1 ? "" : "s"} reopened in their recorded order with the ${restore.formpolicy} form policy and the ${restore.capturepolicy} capture policy${outcome.skippedorigins.length > 0 ? ` while ${outcome.skippedorigins.join(", ")} stayed skipped because their grants expired` : ""}.`, extra);
+    return { ok: true, summary: `Restored ${outcome.restored.length} of ${record2.tabs.length} tabs${outcome.skippedorigins.length > 0 ? `; skipped ${outcome.skippedorigins.join(", ")} outside the grants` : ""}.`, details: { restoreid: record2.id, skippedorigins: outcome.skippedorigins, session: { family: "restore", detail: `Session restore of ${record2.id}`, recordid: record2.id, sections: record2.tabs.length, restored: outcome.restored.length, skipped: outcome.skippedorigins.length } } };
+  }
+  if (step.kind === "namedsessions") {
+    const record2 = await memory.getsessionrecord(String(options.sessionid ?? ""));
+    if (!record2) throw new Error(`No saved session matches ${String(options.sessionid ?? "")}.`);
+    const name = String(options.name ?? "");
+    const records = await memory.getsessionrecords();
+    const unique = sessionnameunique(name, records, record2.id);
+    if (!unique.allowed) throw new Error(unique.reason);
+    const folder = typeof options.folder === "string" && options.folder.trim() ? options.folder : record2.folder;
+    const tags = Array.isArray(options.tags) ? options.tags.filter((tag) => typeof tag === "string" && tag.trim()) : record2.tags;
+    await memory.updatesessionrecord({ ...record2, name, ...folder !== void 0 ? { folder } : {}, tags });
+    if (folder !== void 0) {
+      const folders = await memory.getsessionfolders();
+      if (sessionfolderunique(folder, folders).allowed) await memory.setsessionfolders([...folders, ...sessionfolderof({ name: folder, tags }) !== void 0 ? [sessionfolderof({ name: folder, tags })] : []]);
+    }
+    await memory.addsessionevent({ id: randomid(), kind: "name", at: Date.now(), tabid: tabid2, detail: `Filed the session record ${record2.id} as ${name}${folder !== void 0 ? ` under ${folder}` : ""}.` });
+    await memory.setprogress(recordsession(await memory.getprogress(), plan.id, step.id, { family: "name", detail: `Filed the session record ${record2.id} as ${name}`, recordid: record2.id }, Date.now()));
+    await audit("session", `Filed the saved session ${record2.id} under the reviewed name ${name}${folder !== void 0 ? ` inside the ${folder} folder` : ""}${tags.length > 0 ? ` with the tags ${tags.join(", ")}` : ""}; the filing stays read only organization.`, extra);
+    return { ok: true, summary: `Filed the session record ${record2.id} as ${name}.`, details: { session: { family: "name", detail: `Session filed as ${name}`, recordid: record2.id } } };
+  }
+  if (step.kind === "diffsessions") {
+    const left = await memory.getsessionrecord(String(options.left ?? ""));
+    const right = await memory.getsessionrecord(String(options.right ?? ""));
+    if (!left || !right) throw new Error("The session diff needs both saved sessions in the library.");
+    const diff = newsessiondiff({ id: randomid(), left, right, at: Date.now() });
+    await memory.addsessiondiff(diff);
+    await memory.addsessionevent({ id: randomid(), kind: "diff", at: Date.now(), tabid: tabid2, detail: `Diffed ${left.id} and ${right.id} with ${diff.changes.length} changes.` });
+    await memory.setprogress(recordsession(await memory.getprogress(), plan.id, step.id, { family: "diff", detail: `Diffed the sessions ${left.id} and ${right.id}`, recordid: diff.id, sections: diff.changes.length }, Date.now()));
+    await audit("session", `Compared the saved sessions ${left.id} and ${right.id}: ${diff.changes.length} tab, url, form and storage change${diff.changes.length === 1 ? "" : "s"} classified as read only comparison evidence.`, extra);
+    return { ok: true, summary: `Diffed the sessions: ${diff.changes.length} change${diff.changes.length === 1 ? "" : "s"}.`, details: { diffid: diff.id, changes: diff.changes, session: { family: "diff", detail: `Session diff ${diff.id}`, recordid: diff.id, sections: diff.changes.length } } };
+  }
+  if (step.kind === "searchsessions") {
+    const query = searchqueryof(options.query);
+    if (!query) throw new Error("A reviewed search query is required before the session search runs.");
+    const matches = await memory.searchmemory(query);
+    await memory.addsessionevent({ id: randomid(), kind: "search", at: Date.now(), tabid: tabid2, detail: `Searched ${query.terms.join(", ")} across the saved sessions with ${matches.length} matches.` });
+    await memory.setprogress(recordsession(await memory.getprogress(), plan.id, step.id, { family: "search", detail: `Searched ${query.terms.join(", ")} across the saved sessions`, matches: matches.length }, Date.now()));
+    await audit("session", `Searched the terms ${query.terms.join(", ")} across the saved sessions on the ${query.fields.join(", ")} fields${query.from !== void 0 || query.to !== void 0 ? ` inside the reviewed time window` : ""}: ${matches.length} match${matches.length === 1 ? "" : "es"} returned with their session ids.`, extra);
+    return { ok: true, summary: `Found ${matches.length} match${matches.length === 1 ? "" : "es"} across the saved sessions.`, details: { matches, matchcount: matches.length, session: { family: "search", detail: `Session search of ${query.terms.join(", ")}`, matches: matches.length } } };
+  }
+  if (step.kind === "exportsessions") {
+    if (options.reviewed !== true) throw new Error("Session exports need the explicit export review before any session file leaves the device.");
+    const records = await memory.getsessionrecords();
+    const selected = Array.isArray(options.ids) && options.ids.length > 0 ? records.filter((record2) => options.ids.includes(record2.id)) : records;
+    if (selected.length === 0) throw new Error("No saved session matches the reviewed export ids.");
+    const file = exportsessionfile(selected, Date.now());
+    const payload = JSON.stringify(file);
+    await chrome.downloads.download({ url: `data:application/json;charset=utf-8,${encodeURIComponent(payload)}`, filename: `devthink-sessions-${Date.now()}.json` }).catch(() => {
+      throw new Error("The session file download was refused by the browser.");
+    });
+    await memory.addsessionevent({ id: randomid(), kind: "export", at: Date.now(), tabid: tabid2, detail: `Exported ${file.records.length} session records as a ${file.bytesize} byte file.` });
+    await memory.setprogress(recordsession(await memory.getprogress(), plan.id, step.id, { family: "export", detail: `Exported ${file.records.length} session records`, bytes: file.bytesize }, Date.now()));
+    await audit("export", `Exported ${file.records.length} saved session record${file.records.length === 1 ? "" : "s"} as one ${file.bytesize} byte session file of format version ${file.formatversion} with its checksum, through the reviewed download flow.`, extra);
+    return { ok: true, summary: `Exported ${file.records.length} session record${file.records.length === 1 ? "" : "s"} as a ${file.bytesize} byte file.`, details: { session: { family: "export", detail: `Session export of ${file.records.length} records`, bytes: file.bytesize } } };
+  }
+  if (step.kind === "importsessions") {
+    if (options.reviewed !== true) throw new Error("Session imports need the explicit full record review before any record joins the library.");
+    const file = importsessionfile(options.file);
+    if (!file) throw new Error(`The reviewed session file failed its format version or checksum validation; only format version ${sessionfileversion} imports.`);
+    const records = await memory.getsessionrecords();
+    let added = 0;
+    for (const record2 of file.records) {
+      if (records.some((existing) => existing.id === record2.id)) continue;
+      const unique = sessionnameunique(record2.name, [...records, ...file.records.filter((candidate) => candidate.id !== record2.id).map((candidate) => ({ id: candidate.id, name: candidate.name }))]);
+      const name = unique.allowed ? record2.name : `${record2.name} (${record2.id.slice(0, 6)})`;
+      await memory.addsessionrecord({ ...record2, name });
+      added += 1;
+    }
+    await memory.addsessionevent({ id: randomid(), kind: "import", at: Date.now(), tabid: tabid2, detail: `Imported ${added} session records from a reviewed file of format version ${file.formatversion}.` });
+    await memory.setprogress(recordsession(await memory.getprogress(), plan.id, step.id, { family: "import", detail: `Imported ${added} session records`, sections: added }, Date.now()));
+    await audit("session", `Imported ${added} of ${file.records.length} reviewed session record${file.records.length === 1 ? "" : "s"} from a session file of format version ${file.formatversion}; every record was listed in the full record review before it joined the library.`, extra);
+    return { ok: true, summary: `Imported ${added} session record${added === 1 ? "" : "s"} after review.`, details: { session: { family: "import", detail: `Session import of ${added} records`, sections: added } } };
+  }
+  throw new Error(`The ${step.kind} step has no session memory executor.`);
+}
 async function executestep(stepid) {
   const session = await memory.getsession();
   const plan = await memory.getplan();
@@ -11894,6 +12553,9 @@ async function executestep(stepid) {
     } 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 (issessionkind(step.kind)) {
+      if (!session || !plan || plan.state !== "approved") throw new Error("Session memory kinds refuse to run outside an approved session plan.");
+      output = await executesessionstep(step, session, plan, tab.id, origin);
     } else {
       if (step.target && freshcheckkinds.has(step.kind)) {
         const fresh = await snapshot(tab.id);
@@ -11940,6 +12602,7 @@ 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);
+    await memory.settaskstate(taskstateof({ runid: plan.id, stepcursor: tracked.completedsteps.length, outputs: tracked.outcomes ?? [], checkpointat: Date.now() }));
     const tracker = activememorytrackers.get(plan.id);
     if (tracker) await sampleheapforstep(tracker, stepid, tab.id, origin, plan).catch(() => {
     });
@@ -12133,10 +12796,14 @@ async function handlerequest(message, sender) {
       const clones = clonetabs(tabs);
       const taskgauge = tasktabgauge(tabs.filter((tab) => badges.some((badge) => badge.tabid === tab.tabid)).length, tasktabceiling(await memory.getsettings()));
       const report = await buildtabreport(tabs);
+      const autosnapshot = await memory.getautosnapshot();
+      const crashed = await memory.getcrashflag();
+      const sessionrecords = await memory.applysessionexpiry(snapshotretentionwindow(runsettings), Date.now());
+      const taskstate = plan ? await memory.gettaskstate(plan.id) : void 0;
       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, 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()] } : {} };
+      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), sessionmemory: sessionreport({ records: sessionrecords, events: await memory.getsessionevents(), folders: await memory.getsessionfolders(), diffs: await memory.getsessiondiffs(), ...autosnapshot !== void 0 ? { auto: autosnapshot.interval } : {}, ...crashed ? { crashed: true } : {} }), autosnapshotstate: autosnapshot, sessionretention: runsettings?.sessionretention, ...taskstate !== void 0 ? { taskstate } : {}, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {} };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -12182,7 +12849,8 @@ async function handlerequest(message, sender) {
       const media = outcome.details?.media;
       const network = outcome.details?.network;
       const timeline = outcome.details?.timeline;
-      return JSON.parse(outcomeresponse({ outcome, plan, ...resolved ? { resolvedtarget: resolved } : {}, ...capture ? { capture } : {}, ...media ? { media } : {}, ...network ? { network } : {}, ...timeline ? { timeline } : {} }));
+      const sessionblock = outcome.details?.session;
+      return JSON.parse(outcomeresponse({ outcome, plan, ...resolved ? { resolvedtarget: resolved } : {}, ...capture ? { capture } : {}, ...media ? { media } : {}, ...network ? { network } : {}, ...timeline ? { timeline } : {}, ...sessionblock !== void 0 ? { session: { recordid: sessionblock.recordid ?? "", sections: sessionblock.sections ?? 0, ...sessionblock.matches !== void 0 ? { matches: sessionblock.matches } : {}, ...sessionblock.restored !== void 0 ? { restored: sessionblock.restored } : {}, ...sessionblock.skipped !== void 0 ? { skipped: sessionblock.skipped } : {}, ...sessionblock.cursor !== void 0 ? { cursor: sessionblock.cursor } : {}, ...sessionblock.bytes !== void 0 ? { bytes: sessionblock.bytes } : {} } } : {} }));
     }
     case "map": {
       const plan = await memory.getplan();
@@ -13195,6 +13863,113 @@ async function handlerequest(message, sender) {
       await audit("stop", "The user stopped the browser session.", { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {} });
       return { stopped: true };
     }
+    case "sessionreview": {
+      const inputreview = message;
+      const record2 = await memory.getsessionrecord(inputreview.sessionid?.trim() ?? "");
+      if (!record2) throw new Error(`No saved session matches ${inputreview.sessionid ?? ""}.`);
+      return { record: record2, tabs: record2.tabs.map((tab) => ({ url: tab.url, title: tab.title, index: tab.index, forms: tab.forms.length })), captures: record2.captures, storage: record2.storage.map((entry) => ({ origin: entry.origin, keys: entry.keys.length })), cookies: record2.cookies };
+    }
+    case "approverestore": {
+      const inputrestore = message;
+      const session = await memory.getsession();
+      if (!session || session.stoppedat || session.expiresat <= Date.now()) throw new Error("The crash restore needs an active browser session before it reopens anything.");
+      const record2 = await memory.getsessionrecord(inputrestore.sessionid?.trim() ?? "");
+      if (!record2) throw new Error(`No saved session matches ${inputrestore.sessionid ?? ""}.`);
+      if (record2.sectionsexpired) throw new Error("The saved session sections expired after the retention window; only the record metadata survives for review.");
+      const restore = { tabpolicy: "reopen", formpolicy: "restore", capturepolicy: "link" };
+      const outcome = await performrestore(record2, restore, session);
+      await memory.addsessionevent({ id: randomid(), kind: "restore", at: Date.now(), tabid: session.tabid, detail: `Crash restore reopened ${outcome.restored.length} tabs of record ${record2.id}${outcome.skippedorigins.length > 0 ? ` and skipped ${outcome.skippedorigins.join(", ")}` : ""}.` });
+      await audit("session", `The user approved the crash restore of the saved session ${record2.id}: ${outcome.restored.length} tab${outcome.restored.length === 1 ? "" : "s"} reopened in their recorded order with the scroll and form state restored${outcome.skippedorigins.length > 0 ? ` while ${outcome.skippedorigins.join(", ")} stayed skipped because their grants expired` : ""}.`, { sessionid: session.id });
+      await refreshbadge();
+      return { restored: outcome.restored.length, skippedorigins: outcome.skippedorigins };
+    }
+    case "sessiondiff": {
+      const inputdiff = message;
+      const left = await memory.getsessionrecord(inputdiff.left?.trim() ?? "");
+      const right = await memory.getsessionrecord(inputdiff.right?.trim() ?? "");
+      if (!left || !right) throw new Error("The session diff needs both saved sessions in the library.");
+      return { changes: diffsessionrecords(left, right), leftid: left.id, rightid: right.id };
+    }
+    case "loadsessionfile": {
+      const inputfile = message;
+      let parsed;
+      try {
+        parsed = JSON.parse(inputfile.content ?? "");
+      } catch {
+        throw new Error("The selected file is not a valid session file.");
+      }
+      const file = importsessionfile(parsed);
+      if (!file) throw new Error(`The selected session file failed its format version or checksum validation; only format version ${sessionfileversion} imports.`);
+      return { formatversion: file.formatversion, records: file.records.map((record2) => ({ id: record2.id, name: record2.name, tabs: record2.tabs.length, folder: record2.folder, tags: record2.tags })), bytesize: file.bytesize };
+    }
+    case "importsessionrecords": {
+      const session = await memory.getsession();
+      if (!session || session.stoppedat || session.expiresat <= Date.now()) throw new Error("Session imports need an active browser session behind the consent gates.");
+      const inputimport = message;
+      const file = importsessionfile(inputimport.file);
+      if (!file) throw new Error(`The reviewed session file failed its format version or checksum validation; only format version ${sessionfileversion} imports.`);
+      const records = await memory.getsessionrecords();
+      let added = 0;
+      for (const record2 of file.records) {
+        if (records.some((existing) => existing.id === record2.id)) continue;
+        const unique = sessionnameunique(record2.name, [...records, ...file.records.filter((candidate) => candidate.id !== record2.id).map((candidate) => ({ id: candidate.id, name: candidate.name }))]);
+        const name = unique.allowed ? record2.name : `${record2.name} (${record2.id.slice(0, 6)})`;
+        await memory.addsessionrecord({ ...record2, name });
+        added += 1;
+      }
+      await memory.addsessionevent({ id: randomid(), kind: "import", at: Date.now(), tabid: session.tabid, detail: `Imported ${added} session records from a reviewed file of format version ${file.formatversion}.` });
+      await audit("session", `The review panel imported ${added} of ${file.records.length} reviewed session record${file.records.length === 1 ? "" : "s"} from a session file of format version ${file.formatversion}; every record was listed before it joined the library.`, { sessionid: session.id });
+      return { imported: added };
+    }
+    case "resumerun": {
+      const plan = await memory.getplan();
+      const session = await memory.getsession();
+      if (!session || session.stoppedat || session.expiresat <= Date.now()) throw new Error("The run resume needs an active browser session.");
+      if (!plan || plan.state !== "approved") throw new Error("The run resume needs the approved plan of the interrupted run.");
+      const state = await memory.gettaskstate(plan.id);
+      if (!state || !taskstatevalid(state)) throw new Error("The persisted task state is missing or corrupted; the checksum refused the resume.");
+      const remaining = plan.steps.slice(state.stepcursor);
+      await memory.addsessionevent({ id: randomid(), kind: "resume", at: Date.now(), tabid: session.tabid, detail: `Resumed the run ${plan.id} from step cursor ${state.stepcursor} with ${remaining.length} remaining reviewed steps.` });
+      await audit("resume", `Resumed the run ${plan.id} from the persisted task state checkpoint at step cursor ${state.stepcursor}; ${remaining.length} reviewed step${remaining.length === 1 ? "" : "s"} remain and every one still passes the consent gates.`, { sessionid: session.id, planid: plan.id });
+      await memory.setcrashflag(false);
+      let executed = 0;
+      for (const step of remaining) {
+        const output = await executestep(step.id).catch(() => void 0);
+        if (output === void 0) break;
+        executed += 1;
+      }
+      return { resumed: true, stepcursor: state.stepcursor, remaining: remaining.length, executed };
+    }
+    case "setsessionretention": {
+      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 ? { sessionretention: retention } : {} });
+      await memory.applysessionexpiry(retention, Date.now());
+      await audit("configure", `The user set the session retention to ${retention === void 0 ? "keep every section" : `${retention} millisecond${retention === 1 ? "" : "s"}`}; the record metadata always survives and no code ceiling applies.`);
+      return { sessionretention: retention };
+    }
+    case "exportsessionfile": {
+      const session = await memory.getsession();
+      if (!session || session.stoppedat || session.expiresat <= Date.now()) throw new Error("Session exports need an active browser session behind the consent gates.");
+      const inputexport = message;
+      const records = await memory.getsessionrecords();
+      const selected = Array.isArray(inputexport.ids) && inputexport.ids.length > 0 ? records.filter((record2) => inputexport.ids.includes(record2.id)) : records;
+      if (selected.length === 0) throw new Error("No saved session matches the reviewed export ids.");
+      const file = exportsessionfile(selected, Date.now());
+      const payload = JSON.stringify(file);
+      await chrome.downloads.download({ url: `data:application/json;charset=utf-8,${encodeURIComponent(payload)}`, filename: `devthink-sessions-${Date.now()}.json` }).catch(() => {
+        throw new Error("The session file download was refused by the browser.");
+      });
+      await memory.addsessionevent({ id: randomid(), kind: "export", at: Date.now(), tabid: session.tabid, detail: `The review panel exported ${file.records.length} session records as a ${file.bytesize} byte file.` });
+      await audit("export", `The review panel exported ${file.records.length} saved session record${file.records.length === 1 ? "" : "s"} as one ${file.bytesize} byte session file of format version ${file.formatversion} after the explicit export review.`, { sessionid: session.id });
+      return { exported: file.records.length, bytes: file.bytesize };
+    }
+    case "clearautosnapshot": {
+      await memory.clearautosnapshot();
+      await audit("session", "The user cleared the reviewed auto snapshot interval; on demand captures stay the only source of session records.");
+      return { cleared: true };
+    }
     default:
       throw new Error("Unknown Devthink request.");
   }
@@ -13203,6 +13978,67 @@ chrome.runtime.onMessage.addListener((message, sender, sendresponse) => {
   handlerequest(message, sender).then((value) => sendresponse({ ok: true, value })).catch((error) => sendresponse({ ok: false, error: error instanceof Error ? error.message : String(error) }));
   return true;
 });
+async function detectcrash() {
+  const plan = await memory.getplan();
+  if (!plan || plan.state !== "approved") return;
+  const state = await memory.gettaskstate(plan.id);
+  if (!state || !taskstatevalid(state)) return;
+  const marked = crashinterrupted(state, plan.steps.length, Date.now());
+  if (marked === state || marked === void 0) return;
+  await memory.settaskstate(marked);
+  await memory.setcrashflag(true);
+  await memory.addsessionevent({ id: randomid(), kind: "crash", at: Date.now(), detail: `Run ${plan.id} was interrupted by a browser restart at step cursor ${state.stepcursor} of ${plan.steps.length}.` });
+  await audit("session", `The crash detector marked the run ${plan.id} interrupted by a browser restart at step cursor ${state.stepcursor} of ${plan.steps.length}; the crash restore prompt stays inside the session consent model.`, { planid: plan.id });
+  await refreshbadge().catch(() => {
+  });
+}
+chrome.runtime.onStartup.addListener(() => {
+  void detectcrash();
+});
+async function maybeautosnapshot() {
+  const state = await memory.getautosnapshot();
+  if (!state || !Number.isFinite(state.interval.period)) return;
+  const now = Date.now();
+  if (now - state.lastat < state.interval.period) return;
+  const session = await memory.getsession();
+  const plan = await memory.getplan();
+  if (!session || session.stoppedat || session.expiresat <= now || session.pausedat || !plan || plan.state !== "approved") return;
+  const step = plan.steps.find((candidate) => candidate.kind === "capturesession");
+  if (!step) return;
+  const autorecords = (await memory.getsessionrecords()).filter((record3) => record3.auto);
+  if (autorecords.length >= state.interval.maxsnapshots) {
+    await memory.clearautosnapshot();
+    await audit("session", `The reviewed auto snapshot interval stopped after ${state.interval.maxsnapshots} snapshot${state.interval.maxsnapshots === 1 ? "" : "s"}; the retention window of ${state.interval.expiry} millisecond${state.interval.expiry === 1 ? "" : "s"} expires them by user choice.`, { sessionid: session.id, planid: plan.id });
+    return;
+  }
+  const options = stepoptions2(step);
+  const snapshot2 = snapshotplanof(options.snapshot);
+  if (!snapshot2) return;
+  const record2 = await capturesessionrecord({ ...snapshot2, ...snapshot2.auto !== void 0 ? { auto: snapshot2.auto } : {} }, session, plan.id).catch(() => void 0);
+  if (!record2) return;
+  const auto = { ...record2, auto: true };
+  await memory.addsessionrecord(auto);
+  await memory.setautosnapshot({ interval: state.interval, lastat: now, count: state.count + 1 });
+  await memory.addsessionevent({ id: randomid(), kind: "auto", at: now, tabid: session.tabid, detail: `Auto snapshot ${record2.id} captured ${record2.tabs.length} tabs on the reviewed interval.` });
+  await memory.applysessionexpiry(state.interval.expiry > 0 ? state.interval.expiry : snapshotretentionwindow(await memory.getsettings()), now);
+  await audit("session", `The reviewed auto snapshot interval of ${state.interval.period} milliseconds captured the session record ${record2.id} of ${record2.tabs.length} tab${record2.tabs.length === 1 ? "" : "s"}; snapshot ${state.count + 1} of the reviewed maximum of ${state.interval.maxsnapshots}.`, { sessionid: session.id, planid: plan.id });
+}
+setInterval(() => {
+  void maybeautosnapshot().catch(() => {
+  });
+}, 3e4);
+function schedulewakes() {
+  const alarms = chrome.alarms;
+  try {
+    alarms?.create("devthinkautosnapshot", { periodInMinutes: 1 });
+    alarms?.onAlarm?.addListener(() => {
+      void maybeautosnapshot().catch(() => {
+      });
+    });
+  } catch {
+  }
+}
+schedulewakes();
 async function reconcilewatches() {
   for (const watch of await memory.getwatches()) {
     if (watch.closedat !== void 0) continue;