@wenathlan/extension 1.1.33 → 1.1.35

package/extension/dist/background.js

@@ -128,18 +128,243 @@ var sessionmemory = class {
   async setdialogpolicy(policy) {
     return this.adapter.set("dialogpolicy", policy);
   }
+  /** Stores one observation capture under its version so every observation version stays available. */
+  async setobservation(record2) {
+    return this.adapter.set(`observation${record2.version}`, record2);
+  }
+  /** Returns one stored observation version. */
+  async getobservation(version) {
+    return this.adapter.get(`observation${version}`);
+  }
+  /** Returns the observation retention window; an absent setting keeps every capture. */
+  async observationretention() {
+    return (await this.getsettings())?.observationretention;
+  }
+  /** Stores one accessibility tree capture; retention is a user setting and an absent setting keeps every tree. */
+  async adda11ytree(capture) {
+    const records = await this.geta11ytrees();
+    const combined = [capture, ...records];
+    const retention = await this.observationretention();
+    await this.adapter.set("a11ytrees", retention === void 0 ? combined : combined.slice(0, retention));
+  }
+  /** Returns every stored accessibility tree capture, newest first. */
+  async geta11ytrees() {
+    return await this.adapter.get("a11ytrees") ?? [];
+  }
+  /** Stores one reader article capture; retention is a user setting and an absent setting keeps every article. */
+  async addreaderarticle(capture) {
+    const records = await this.getreaderarticles();
+    const combined = [capture, ...records];
+    const retention = await this.observationretention();
+    await this.adapter.set("readerarticles", retention === void 0 ? combined : combined.slice(0, retention));
+  }
+  /** Returns every stored reader article capture, newest first. */
+  async getreaderarticles() {
+    return await this.adapter.get("readerarticles") ?? [];
+  }
+  /** Records one dom mutation observed inside a reviewed watch. */
+  async addmutationevent(event) {
+    const records = await this.getmutationevents();
+    await this.adapter.set("mutationevents", [event, ...records]);
+  }
+  /** Returns the mutation event stream of every reviewed watch. */
+  async getmutationevents() {
+    return await this.adapter.get("mutationevents") ?? [];
+  }
+  /** Records one focus change observed inside a reviewed watch. */
+  async addfocusevent(event) {
+    const records = await this.getfocusevents();
+    await this.adapter.set("focusevents", [event, ...records]);
+  }
+  /** Returns the focus event stream of every reviewed watch. */
+  async getfocusevents() {
+    return await this.adapter.get("focusevents") ?? [];
+  }
+  /** Records one consent banner observed by a reviewed banner watch. */
+  async addbanner(event) {
+    const records = await this.getbanners();
+    await this.adapter.set("banners", [event, ...records]);
+  }
+  /** Returns every consent banner report observed so far. */
+  async getbanners() {
+    return await this.adapter.get("banners") ?? [];
+  }
+  /** Records one snapshot diff between two observation versions. */
+  async adddiff(diff) {
+    const records = await this.getdiffs();
+    await this.adapter.set("diffs", [diff, ...records]);
+  }
+  /** Returns every stored snapshot diff, newest first. */
+  async getdiffs() {
+    return await this.adapter.get("diffs") ?? [];
+  }
+  /** Records one derived selector with its stability score for reuse. */
+  async addselector(selector) {
+    const records = await this.getselectors();
+    await this.adapter.set("selectors", [selector, ...records]);
+  }
+  /** Returns every stored derived selector with its stability score, newest first. */
+  async getselectors() {
+    return await this.adapter.get("selectors") ?? [];
+  }
+  /** Records one detected template class or section fingerprint for its origin. */
+  async addtemplate(profile) {
+    const records = await this.gettemplates();
+    await this.adapter.set("templates", [profile, ...records]);
+  }
+  /** Returns every stored template class and section fingerprint, newest first. */
+  async gettemplates() {
+    return await this.adapter.get("templates") ?? [];
+  }
+  /** Records one watch registration so it survives service worker restarts. */
+  async addwatch(watch) {
+    const records = await this.getwatches();
+    await this.adapter.set("watches", [watch, ...records]);
+  }
+  /** Returns every watch registration, newest first, including closed windows. */
+  async getwatches() {
+    return await this.adapter.get("watches") ?? [];
+  }
+  /** Closes one watch registration by watch id once its reviewed lifetime window ends. */
+  async closewatch(watchid, closedat) {
+    const records = await this.getwatches();
+    await this.adapter.set("watches", records.map((watch) => watch.watchid === watchid && watch.closedat === void 0 ? { ...watch, closedat } : watch));
+  }
+  /** Returns the live page signals of language, template, scroll lock and banner state. */
+  async getsignals() {
+    return this.adapter.get("signals");
+  }
+  /** Replaces the live page signals after an observation step refreshes them. */
+  async setsignals(signals) {
+    return this.adapter.set("signals", signals);
+  }
+  /** Appends one navigation trail entry of a session with its url, title, step ref and timestamp. */
+  async addtrailentry(sessionid, entry) {
+    const records = await this.gettrail(sessionid);
+    await this.adapter.set(`trail${sessionid}`, [...records, entry]);
+  }
+  /** Returns the navigation trail of a session, oldest first. */
+  async gettrail(sessionid) {
+    return await this.adapter.get(`trail${sessionid}`) ?? [];
+  }
+  /** Stores one wait profile for an origin with user configured values, replacing the previous profile of that origin. */
+  async setwaitprofile(record2) {
+    const records = (await this.getwaitprofiles()).filter((item) => item.origin !== record2.origin);
+    await this.adapter.set("waitprofiles", [...records, record2]);
+  }
+  /** Returns every stored wait profile with its origin and user configured values, newest first. */
+  async getwaitprofiles() {
+    return await this.adapter.get("waitprofiles") ?? [];
+  }
+  /** Records one navigation step with its redirect chain and final url. */
+  async addnavrecord(record2) {
+    const records = await this.getnavrecords();
+    await this.adapter.set("navrecords", [record2, ...records]);
+  }
+  /** Returns every stored navigation record with redirect chains and final urls, newest first. */
+  async getnavrecords() {
+    return await this.adapter.get("navrecords") ?? [];
+  }
+  /** Records one navigation intent detected from a plan for audit review. */
+  async addnavintent(record2) {
+    const records = await this.getnavintents();
+    await this.adapter.set("navintents", [record2, ...records]);
+  }
+  /** Returns every stored navigation intent record, newest first. */
+  async getnavintents() {
+    return await this.adapter.get("navintents") ?? [];
+  }
+  /** Replaces the rate limit window state of one domain. */
+  async setratestate(state) {
+    const records = (await this.getratestates()).filter((item) => item.domain !== state.domain);
+    await this.adapter.set("ratestates", [...records, state]);
+  }
+  /** Returns every rate limit window state per domain. */
+  async getratestates() {
+    return await this.adapter.get("ratestates") ?? [];
+  }
+  /** Records one curated link list with its review state before batch opening. */
+  async addcurated(list) {
+    const records = await this.getcurateds();
+    await this.adapter.set("curated", [list, ...records]);
+  }
+  /** Returns every stored curated link list, newest first. */
+  async getcurateds() {
+    return await this.adapter.get("curated") ?? [];
+  }
+  /** Stores reviewed basic auth credentials for one origin, replacing the previous record of that origin. */
+  async setauth(record2) {
+    const records = (await this.getauths()).filter((item) => item.origin !== record2.origin);
+    await this.adapter.set("auths", [...records, record2]);
+  }
+  /** Returns every stored reviewed basic auth record per origin. */
+  async getauths() {
+    return await this.adapter.get("auths") ?? [];
+  }
+  /** Records one task artifact routed into the artifact store. */
+  async addartifact(record2) {
+    const records = await this.getartifacts();
+    await this.adapter.set("artifacts", [record2, ...records]);
+  }
+  /** Returns every stored task artifact, newest first. */
+  async getartifacts() {
+    return await this.adapter.get("artifacts") ?? [];
+  }
+  /** Returns the navigation control state of paused navigation. */
+  async getnavcontrol() {
+    return this.adapter.get("navcontrol");
+  }
+  /** Replaces the navigation control state after a pause or resume transition. */
+  async setnavcontrol(control) {
+    return this.adapter.set("navcontrol", control);
+  }
+  /** Records one url safety verdict produced by a checksafe verification. */
+  async addsafety(verdict) {
+    const records = await this.getsafeties();
+    await this.adapter.set("safeties", [verdict, ...records]);
+  }
+  /** Returns every stored url safety verdict, newest first. */
+  async getsafeties() {
+    return await this.adapter.get("safeties") ?? [];
+  }
+  /** Records one recently closed tab so a reopentab step can restore it. */
+  async addrecenttab(tab) {
+    const records = await this.getrecenttabs();
+    await this.adapter.set("recenttabs", [tab, ...records]);
+  }
+  /** Returns every recently closed tab, newest first. */
+  async getrecenttabs() {
+    return await this.adapter.get("recenttabs") ?? [];
+  }
+  /** Returns the queued prefetch and batch open target counts shown in the popup badge. */
+  async getnavqueues() {
+    return this.adapter.get("navqueues");
+  }
+  /** Replaces the queued prefetch and batch open target counts. */
+  async setnavqueues(queues) {
+    return this.adapter.set("navqueues", queues);
+  }
+  /** Returns the last known navigation state of a tab, kept across service worker restarts. */
+  async getnavstate(tabid2) {
+    return this.adapter.get(`navstate${tabid2}`);
+  }
+  /** Replaces the last known navigation state of a tab. */
+  async setnavstate(tabid2, state) {
+    return this.adapter.set(`navstate${tabid2}`, state);
+  }
 };
 function randomid() {
   return crypto.randomUUID();
 }
 
 // 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"]);
+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"]);
 var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction"]);
-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"]);
+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"]);
 var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
-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"]);
-var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor"]);
+var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus"]);
+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"]);
+var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav"]);
 function normalizeendpoint(value) {
   const endpoint = new URL(value.trim());
   if (endpoint.protocol !== "https:") throw new Error("Devthink accepts HTTPS endpoints only.");
@@ -170,6 +395,8 @@ function parseoptions(step) {
 function requiredcapability(kind) {
   if (kind === "tablist") return "tabs";
   if (kind === "downloadfile") return "downloads";
+  if (kind === "openclipboard") return "clipboardRead";
+  if (kind === "openlink" || kind === "openprivate" || kind === "navlist" || kind === "batchopen" || kind === "reopentab" || kind === "deeplink") return "tabs";
   return void 0;
 }
 function waitduration(step) {
@@ -220,6 +447,35 @@ function origingranted(session, origin) {
   const grants = session.grants ?? [session.origin];
   return grants.includes(origin);
 }
+function originverified(url, grants, verdicts) {
+  let origin = "";
+  try {
+    origin = new URL(url).origin;
+  } catch {
+    return { allowed: false, reason: "The reviewed navigation URL is invalid." };
+  }
+  if (grants.includes(origin)) return { allowed: true };
+  const covered = verdicts.find((verdict) => verdict.safe && (verdict.url === url || safeorigin(verdict.url) === origin));
+  if (covered) return { allowed: true };
+  return { allowed: false, reason: `The origin ${origin} is outside the session grants and has no safe checksafe verdict; run checksafe and review it first.` };
+}
+function safeorigin(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return "";
+  }
+}
+function navigationgranted(session, url) {
+  let origin = "";
+  try {
+    origin = new URL(url).origin;
+  } catch {
+    return { allowed: false, reason: "The reviewed navigation URL is invalid." };
+  }
+  if (origingranted(session, origin)) return { allowed: true };
+  return { allowed: false, reason: `Navigation to ${origin} leaves the task tab origins and needs the user consent of a session grant first.` };
+}
 function validateinnerstep(options, origin) {
   const stepid = options.stepid;
   const kind = options.kind;
@@ -243,6 +499,68 @@ function validateinnerstep(options, origin) {
   };
   return validatestep(inner, origin);
 }
+function ishttpsurl(value) {
+  if (typeof value !== "string" || !value.trim()) return false;
+  try {
+    return new URL(value).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function validatenavtarget(value, kind) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed navtarget with a url is required in options." };
+  const target = value;
+  if (!ishttpsurl(target.url)) return { allowed: false, reason: "The reviewed navtarget url must use HTTPS." };
+  const container = target.container ?? "tab";
+  if (container !== "current" && container !== "tab" && container !== "window" && container !== "private") return { allowed: false, reason: "The reviewed navtarget container must be current, tab, window or private." };
+  if (target.position !== void 0 && target.position !== "adjacent" && target.position !== "end") return { allowed: false, reason: "The reviewed navtarget position must be adjacent or end." };
+  if (kind === "openprivate" && container !== "private") return { allowed: false, reason: "The openprivate step requires the private container." };
+  if (kind === "openlink" && container === "private") return { allowed: false, reason: "The openlink step cannot open the private container; use openprivate." };
+  return { allowed: true };
+}
+function validatewaitprofile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed waitprofile with load signals is required in options." };
+  const profile = value;
+  if (!Array.isArray(profile.signals) || profile.signals.length === 0 || !profile.signals.every((signal) => isnonempty(signal))) return { allowed: false, reason: "The reviewed waitprofile needs a non-empty list of load signals." };
+  if (!nonnegativeoption(profile, "idle")) return { allowed: false, reason: "The reviewed waitprofile idle threshold must be zero or a positive number of milliseconds." };
+  if (!nonnegativeoption(profile, "timeout")) return { allowed: false, reason: "The reviewed waitprofile timeout must be zero or a positive number of milliseconds." };
+  if (profile.overrides !== void 0) {
+    if (!Array.isArray(profile.overrides) || profile.overrides.length === 0) return { allowed: false, reason: "The reviewed waitprofile overrides must be a non-empty list when present." };
+    for (const entry of profile.overrides) {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) return { allowed: false, reason: "Every reviewed waitprofile override must be an object with an origin." };
+      const override = entry;
+      if (!ishttpsurl(override.origin)) return { allowed: false, reason: "Every reviewed waitprofile override origin must use HTTPS." };
+      if (override.signals !== void 0 && (!Array.isArray(override.signals) || !override.signals.every((signal) => isnonempty(signal)))) return { allowed: false, reason: "The reviewed waitprofile override signals must be a list of non-empty strings." };
+      if (!nonnegativeoption(override, "idle") || !nonnegativeoption(override, "timeout")) return { allowed: false, reason: "The reviewed waitprofile override thresholds must be zero or positive numbers." };
+    }
+  }
+  return { allowed: true };
+}
+function validateurlpattern(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed urlpattern is required in options." };
+  const pattern = value;
+  if (pattern.mode !== "exact" && pattern.mode !== "prefix" && pattern.mode !== "host" && pattern.mode !== "pattern") return { allowed: false, reason: "The reviewed urlpattern mode must be exact, prefix, host or pattern." };
+  if (!ishttpsurl(pattern.url)) return { allowed: false, reason: "The reviewed urlpattern url must use HTTPS." };
+  if (pattern.query !== void 0) {
+    if (!pattern.query || typeof pattern.query !== "object" || Array.isArray(pattern.query)) return { allowed: false, reason: "The reviewed urlpattern query part must be an object of parameter names and values." };
+    for (const item of Object.values(pattern.query)) if (typeof item !== "string") return { allowed: false, reason: "The reviewed urlpattern query values must be strings." };
+  }
+  if (pattern.fragment !== void 0 && !isnonempty(pattern.fragment)) return { allowed: false, reason: "The reviewed urlpattern fragment must be a non-empty string." };
+  return { allowed: true };
+}
+function validateurllist(options, key) {
+  const urls = options[key];
+  if (!Array.isArray(urls) || urls.length === 0 || !urls.every((url) => ishttpsurl(url))) return { allowed: false, reason: `A reviewed non-empty list of HTTPS urls is required in options as ${key}.` };
+  return { allowed: true };
+}
+function validateratelimit(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed ratelimit with a window and a ceiling is required in options." };
+  const limit = value;
+  if (limit.domain !== void 0 && !isnonempty(limit.domain)) return { allowed: false, reason: "The reviewed ratelimit domain must be a non-empty string." };
+  if (typeof limit.window !== "number" || !Number.isFinite(limit.window) || limit.window <= 0) return { allowed: false, reason: "The reviewed ratelimit window must be a positive number of milliseconds with no code ceiling." };
+  if (typeof limit.ceiling !== "number" || !Number.isInteger(limit.ceiling) || limit.ceiling < 1) return { allowed: false, reason: "The reviewed ratelimit ceiling must be a positive integer with no code ceiling." };
+  return { allowed: true };
+}
 function validatestep(step, origin) {
   if (!allowedactions.has(step.kind)) return { allowed: false, reason: "Unsupported action kind." };
   if (!step.summary.trim()) return { allowed: false, reason: "A human-readable action summary is required." };
@@ -362,6 +680,88 @@ function validatestep(step, origin) {
     if (!nonnegativeoption(retry, "settle")) return { allowed: false, reason: "The reviewed retry settle window must be zero or a positive number of milliseconds." };
     if (!nonnegativeoption(retry, "tolerance")) return { allowed: false, reason: "The reviewed retry movement tolerance must be zero or a positive number of pixels." };
   }
+  if (watchactions.has(step.kind)) {
+    if (typeof options.lifetime !== "number" || !Number.isFinite(options.lifetime) || options.lifetime <= 0) return { allowed: false, reason: "A reviewed watch lifetime window in milliseconds is required in options." };
+    if (options.scopes !== void 0 && (!Array.isArray(options.scopes) || !options.scopes.every((scope) => isnonempty(scope)))) return { allowed: false, reason: "The reviewed watch scopes must be a list of non-empty selectors." };
+    if (options.events !== void 0 && (!Array.isArray(options.events) || !options.events.every((event) => isnonempty(event)))) return { allowed: false, reason: "The reviewed watch event kinds must be a list of non-empty strings." };
+    if (!nonnegativeoption(options, "poll")) return { allowed: false, reason: "The reviewed watch poll interval must be zero or a positive number of milliseconds." };
+  }
+  if (step.kind === "waitquiet") {
+    const rule = options.quietrule;
+    if (!rule || typeof rule !== "object" || Array.isArray(rule)) return { allowed: false, reason: "A reviewed quietrule with an idle threshold is required in options." };
+    const quiet = rule;
+    if (typeof quiet.idle !== "number" || !Number.isFinite(quiet.idle) || quiet.idle <= 0) return { allowed: false, reason: "The reviewed quiet idle threshold must be a positive number of milliseconds with no code ceiling." };
+    if (!nonnegativeoption(quiet, "poll")) return { allowed: false, reason: "The reviewed quiet poll interval must be zero or a positive number of milliseconds." };
+    if (!nonnegativeoption(quiet, "timeout")) return { allowed: false, reason: "The reviewed quiet timeout must be zero or a positive number of milliseconds." };
+  }
+  if (step.kind === "diffsnapshots") {
+    const versions = options.versions;
+    if (!Array.isArray(versions) || versions.length !== 2 || !versions.every((version) => typeof version === "number" && Number.isInteger(version) && version >= 1)) return { allowed: false, reason: "Two reviewed observation version numbers are required in options." };
+  }
+  if (step.kind === "openlink" || step.kind === "openprivate" || step.kind === "deeplink") {
+    const targetcheck = validatenavtarget(options.navtarget, step.kind);
+    if (!targetcheck.allowed) return targetcheck;
+    if (step.kind === "deeplink") {
+      const app = options.app;
+      if (!isnonempty(app)) return { allowed: false, reason: "A reviewed deep link app pattern is required in options." };
+      const params = options.params;
+      if (params !== void 0 && (!params || typeof params !== "object" || Array.isArray(params) || !Object.values(params).every((item) => typeof item === "string"))) return { allowed: false, reason: "The reviewed deep link params must be an object of string values." };
+    }
+  }
+  if (step.kind === "waitload" && !nonnegativeoption(options, "timeout")) return { allowed: false, reason: "The waitload timeout must be zero or a positive number of milliseconds." };
+  if (step.kind === "waiturl" || step.kind === "spawait") {
+    if (step.kind === "waiturl") {
+      const patterncheck = validateurlpattern(options.urlpattern);
+      if (!patterncheck.allowed) return patterncheck;
+    }
+    if (!nonnegativeoption(options, "timeout")) return { allowed: false, reason: "The wait timeout must be zero or a positive number of milliseconds." };
+    if (!nonnegativeoption(options, "poll")) return { allowed: false, reason: "The wait poll interval must be zero or a positive number of milliseconds." };
+  }
+  if (step.kind === "followlink") {
+    if (options.fragment !== void 0 && typeof options.fragment !== "boolean") return { allowed: false, reason: "The reviewed followlink fragment flag must be a boolean." };
+  }
+  if (step.kind === "spanav") {
+    if (options.routepattern !== void 0) {
+      const routecheck = validateurlpattern(options.routepattern);
+      if (!routecheck.allowed) return routecheck;
+    }
+    if (!nonnegativeoption(options, "timeout")) return { allowed: false, reason: "The spanav route timeout must be zero or a positive number of milliseconds." };
+  }
+  if (step.kind === "rewritequery") {
+    const set = options.set;
+    const remove = options.remove;
+    if (set === void 0 && remove === void 0) return { allowed: false, reason: "Reviewed query parameters to set or remove are required in options." };
+    if (set !== void 0 && (!set || typeof set !== "object" || Array.isArray(set) || !Object.values(set).every((item) => typeof item === "string"))) return { allowed: false, reason: "The reviewed query parameters to set must be an object of string values." };
+    if (remove !== void 0 && (!Array.isArray(remove) || !remove.every((item) => isnonempty(item)))) return { allowed: false, reason: "The reviewed query parameters to remove must be a list of non-empty names." };
+  }
+  if (step.kind === "navlist") {
+    const listcheck = validateurllist(options, "urls");
+    if (!listcheck.allowed) return listcheck;
+  }
+  if (step.kind === "navprofile") {
+    const profilecheck = validatewaitprofile(options.waitprofile);
+    if (!profilecheck.allowed) return profilecheck;
+  }
+  if (step.kind === "handleauth" && !ishttpsurl(step.value)) return { allowed: false, reason: "A reviewed HTTPS origin or url is required as the auth target." };
+  if (step.kind === "printpdf" && options.name !== void 0 && !isnonempty(options.name)) return { allowed: false, reason: "The reviewed artifact name must be a non-empty string." };
+  if (step.kind === "prefetch") {
+    const listcheck = validateurllist(options, "urls");
+    if (!listcheck.allowed) return listcheck;
+  }
+  if (step.kind === "preconnect") {
+    const origins = options.origins;
+    if (!Array.isArray(origins) || origins.length === 0 || !origins.every((originurl) => ishttpsurl(originurl))) return { allowed: false, reason: "A reviewed non-empty list of HTTPS origins is required in options." };
+  }
+  if (step.kind === "reopentab" && step.value !== void 0 && !ishttpsurl(step.value)) return { allowed: false, reason: "The reviewed reopen url must use HTTPS." };
+  if (step.kind === "navrate") {
+    const limitcheck = validateratelimit(options.ratelimit);
+    if (!limitcheck.allowed) return limitcheck;
+  }
+  if (step.kind === "checksafe" && !ishttpsurl(step.value)) return { allowed: false, reason: "A reviewed HTTPS url is required for the safety check." };
+  if (step.kind === "batchopen") {
+    const listcheck = validateurllist(options, "urls");
+    if (!listcheck.allowed) return listcheck;
+  }
   return { allowed: true };
 }
 function sessiongate(input) {
@@ -378,6 +778,37 @@ function canexecute(input) {
   if (!input.plan || input.plan.state !== "approved") return { allowed: false, reason: "The plan has not received explicit approval." };
   if (input.plan.expiresat <= now) return { allowed: false, reason: "The approved plan has expired." };
   if ((input.step.kind === "pierceshadow" || input.step.kind === "enterframe") && !origingranted(input.session, input.origin)) return { allowed: false, reason: "The shadow or frame step is outside the session origin grants." };
+  if (input.step.kind === "readjson" && !origingranted(input.session, input.origin)) return { allowed: false, reason: "The json state read is outside the session origin grants." };
+  if (input.step.kind === "navlist") {
+    let options = {};
+    try {
+      options = parseoptions(input.step);
+    } catch {
+      options = {};
+    }
+    for (const url of Array.isArray(options.urls) ? options.urls : []) {
+      if (typeof url !== "string") continue;
+      const navigation = navigationgranted(input.session, url);
+      if (!navigation.allowed) return navigation;
+    }
+  }
+  if (input.step.kind === "openlink" || input.step.kind === "openprivate" || input.step.kind === "batchopen" || input.step.kind === "prefetch" || input.step.kind === "deeplink" || input.step.kind === "reopentab") {
+    let options = {};
+    try {
+      options = parseoptions(input.step);
+    } catch {
+      options = {};
+    }
+    const grammar = validatestep(input.step, input.origin);
+    if (!grammar.allowed) return grammar;
+    const grants = input.session?.grants ?? [input.session?.origin ?? input.origin];
+    const targets = input.step.kind === "batchopen" || input.step.kind === "prefetch" ? Array.isArray(options.urls) ? options.urls : [] : input.step.kind === "reopentab" ? [input.step.value] : [options.navtarget?.url];
+    for (const target of targets) {
+      if (typeof target !== "string" || !target) continue;
+      const verified = originverified(target, grants, input.verdicts ?? []);
+      if (!verified.allowed) return verified;
+    }
+  }
   return validatestep(input.step, input.origin);
 }
 function canpreview(input) {
@@ -420,9 +851,22 @@ function resetforplan(progress, plan, now) {
   const snapshot2 = { planid: progress.planid, completedsteps: progress.completedsteps, ...progress.outcomes ? { outcomes: progress.outcomes } : {}, updatedat: progress.updatedat };
   return { planid: plan.id, completedsteps: [], outcomes: [], prior: [...progress.prior ?? [], snapshot2], updatedat: now };
 }
+function watchclosed(startedat, lifetime, now) {
+  return now >= startedat + lifetime;
+}
+function recordwatchcompletion(progress, planid, stepid, startedat, lifetime, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  if (!watchclosed(startedat, lifetime, now)) return base;
+  return recordstep(base, planid, stepid, now);
+}
+function recordnaventry(progress, planid, stepid, entry, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  const outcome = { stepid, ok: entry.ok, summary: `Navigation list entry ${entry.index + 1} of ${entry.url} ${entry.ok ? "completed" : "failed"}.`, details: { naventry: entry }, at: now };
+  return recordoutcome(base, planid, outcome, now);
+}
 
 // version.ts
-var packageversion = "1.1.33";
+var packageversion = "1.1.35";
 
 // types.ts
 var protocolversion = packageversion;
@@ -489,6 +933,28 @@ function mapresponse(input) {
 function heldkeysreport(input) {
   return { version: protocolversion, tabid: input.tabid, heldkeys: input.holds };
 }
+function observationresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, observation: input.observation });
+}
+function signalsreport(input) {
+  const signals = input.signals;
+  return {
+    version: protocolversion,
+    ...signals && signals.language !== void 0 ? { language: signals.language } : {},
+    ...signals && signals.template !== void 0 ? { template: signals.template } : {},
+    ...signals && signals.scrolllocked !== void 0 ? { scrolllocked: signals.scrolllocked } : {},
+    ...signals && signals.banner !== void 0 ? { banner: signals.banner } : {}
+  };
+}
+function navstateresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, navstate: input.navstate });
+}
+function trailreport(input) {
+  return { version: protocolversion, ...input.sessionid ? { sessionid: input.sessionid } : {}, trail: input.trail };
+}
+function safetyresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, verdicts: input.verdicts });
+}
 
 // extension/browsertabs.ts
 var browserkinds = /* @__PURE__ */ new Set(["tablist", "tabcreate", "tabactivate", "tabclose", "tabreload", "tabsnapshot", "windowlist", "windowcreate", "windowclose", "zoomset", "windowresize", "downloadfile"]);
@@ -706,10 +1172,332 @@ function heldkeys(holds, tabid2) {
   return holds.filter((hold) => hold.releasedat === void 0 && (tabid2 === void 0 || hold.tabid === void 0 || hold.tabid === tabid2));
 }
 
+// extension/pagenav.ts
+function parsenavtarget(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const value = options.navtarget;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const target = value;
+  if (typeof target.url !== "string" || !target.url) return null;
+  const container = target.container === "current" || target.container === "window" || target.container === "private" ? target.container : "tab";
+  return {
+    url: target.url,
+    container,
+    ...target.position === "end" ? { position: "end" } : { position: "adjacent" },
+    private: container === "private" || target.private === true
+  };
+}
+function resolvecontainer(target, windows) {
+  if (target.container === "current") return { kind: "current", incognito: false, position: target.position ?? "adjacent" };
+  if (target.container === "private" || target.private) return { kind: "private", incognito: true, position: target.position ?? "adjacent" };
+  if (target.container === "window") {
+    const focused = windows.find((item) => item.focused);
+    return { kind: "window", incognito: false, ...focused ? { windowid: focused.id } : {}, position: target.position ?? "adjacent" };
+  }
+  const normal = windows.find((item) => !item.incognito && item.focused) ?? windows.find((item) => !item.incognito);
+  return { kind: "tab", incognito: false, ...normal ? { windowid: normal.id } : {}, position: target.position ?? "adjacent" };
+}
+function parsewaitprofile(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const value = options.waitprofile;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const profile = value;
+  const signals = Array.isArray(profile.signals) ? profile.signals.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  if (signals.length === 0) return null;
+  const overrides = [];
+  if (Array.isArray(profile.overrides)) {
+    for (const item of profile.overrides) {
+      if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+      const override = item;
+      if (typeof override.origin !== "string" || !override.origin) continue;
+      const overridesignals = Array.isArray(override.signals) ? override.signals.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : void 0;
+      overrides.push({
+        origin: override.origin,
+        ...overridesignals && overridesignals.length > 0 ? { signals: overridesignals } : {},
+        ...typeof override.idle === "number" && Number.isFinite(override.idle) && override.idle >= 0 ? { idle: override.idle } : {},
+        ...typeof override.timeout === "number" && Number.isFinite(override.timeout) && override.timeout >= 0 ? { timeout: override.timeout } : {}
+      });
+    }
+  }
+  return {
+    signals,
+    ...typeof profile.idle === "number" && Number.isFinite(profile.idle) && profile.idle >= 0 ? { idle: profile.idle } : {},
+    ...typeof profile.timeout === "number" && Number.isFinite(profile.timeout) && profile.timeout >= 0 ? { timeout: profile.timeout } : {},
+    ...overrides.length > 0 ? { overrides } : {}
+  };
+}
+function profilefororigin(profile, origin) {
+  let signals = [...profile.signals];
+  let idle = profile.idle ?? 0;
+  let timeout = profile.timeout ?? 0;
+  for (const override of profile.overrides ?? []) {
+    if (!override.origin || new URL(override.origin).origin !== origin) continue;
+    if (override.signals && override.signals.length > 0) signals = [...override.signals];
+    if (override.idle !== void 0) idle = override.idle;
+    if (override.timeout !== void 0) timeout = override.timeout;
+  }
+  return { signals, idle, timeout };
+}
+function deeplinkurl(app, params) {
+  const value = (name) => {
+    const item = params[name];
+    return typeof item === "string" && item.trim() ? item.trim() : void 0;
+  };
+  switch (app.trim().toLowerCase()) {
+    case "github": {
+      const owner = value("owner");
+      const repo = value("repo");
+      if (!owner || !repo) return null;
+      const path = value("path");
+      return `https://github.com/${owner}/${repo}${path ? `/${path.replace(/^\/+/, "")}` : ""}`;
+    }
+    case "youtube": {
+      const id = value("id");
+      if (id) return `https://www.youtube.com/watch?v=${encodeURIComponent(id)}`;
+      const search = value("search");
+      if (search) return `https://www.youtube.com/results?search_query=${encodeURIComponent(search)}`;
+      return null;
+    }
+    case "maps": {
+      const query = value("query");
+      if (!query) return null;
+      return `https://www.google.com/maps/search/${encodeURIComponent(query)}`;
+    }
+    case "wikipedia": {
+      const title = value("title");
+      if (!title) return null;
+      const language = value("language") ?? "en";
+      return `https://${language}.wikipedia.org/wiki/${encodeURIComponent(title.replace(/\s+/g, "_"))}`;
+    }
+    case "amazon": {
+      const search = value("search");
+      if (!search) return null;
+      return `https://www.amazon.com/s?k=${encodeURIComponent(search)}`;
+    }
+    case "x": {
+      const user = value("user");
+      if (!user) return null;
+      return `https://x.com/${user.replace(/^@/, "")}`;
+    }
+    default:
+      return null;
+  }
+}
+function pickrecenttab(recenttabs, openurls) {
+  return recenttabs.find((tab) => !openurls.includes(tab.url)) ?? null;
+}
+
+// extension/pagenet.ts
+function buildredirectchain(events) {
+  const hops = [];
+  let startedat = 0;
+  let endedat = 0;
+  let open = false;
+  for (const event of events) {
+    if (event.event === "beforenavigate") {
+      hops.length = 0;
+      startedat = event.timestamp;
+      endedat = event.timestamp;
+      open = true;
+      hops.push({ url: event.url, status: event.status ?? 0, at: event.timestamp });
+      continue;
+    }
+    if (!open) continue;
+    endedat = event.timestamp;
+    if (event.event === "urlchange" || event.redirect || event.event === "committed" && hops[hops.length - 1]?.url !== event.url) {
+      if (hops[hops.length - 1]?.url === event.url && typeof event.status === "number") hops[hops.length - 1] = { url: event.url, status: event.status, at: event.timestamp };
+      else hops.push({ url: event.url, status: event.status ?? 0, at: event.timestamp });
+      continue;
+    }
+    if (event.event === "committed" && typeof event.status === "number" && hops[hops.length - 1]) {
+      hops[hops.length - 1] = { url: event.url, status: event.status, at: event.timestamp };
+      continue;
+    }
+    if (event.event === "completed" || event.event === "error") {
+      if (event.event === "completed" && hops[hops.length - 1] && hops[hops.length - 1]?.url !== event.url) hops.push({ url: event.url, status: event.status ?? 200, at: event.timestamp });
+      if (event.event === "completed" && typeof event.status === "number" && hops[hops.length - 1]) hops[hops.length - 1] = { url: event.url, status: event.status, at: event.timestamp };
+      open = false;
+    }
+  }
+  return { hops, startedat, endedat: endedat || startedat };
+}
+function finalurl(chain) {
+  return chain.hops[chain.hops.length - 1]?.url ?? "";
+}
+function classifynavchange(previousurl, currenturl, status) {
+  if (previousurl === currenturl) return status === "loading" ? "reload" : "none";
+  try {
+    if (new URL(previousurl).origin !== new URL(currenturl).origin) return "load";
+  } catch {
+    return "load";
+  }
+  return status === "loading" ? "load" : "route";
+}
+function detecthttpstate(input) {
+  const reasons = [];
+  let httperror = false;
+  let certificate = false;
+  const errors = input.errors ?? [];
+  const statuses = input.statuses ?? [];
+  for (const error of errors) {
+    if (/CERT|SSL|TLS|privacy bad|your connection is not private/i.test(error)) {
+      certificate = true;
+      httperror = true;
+      reasons.push(`certificate interstitial: ${error}`);
+      continue;
+    }
+    if (/ERR_NAME_NOT_RESOLVED|ERR_CONNECTION|ERR_TIMED_OUT|ERR_INTERNET_DISCONNECTED|ERR_ADDRESS_UNREACHABLE|ERR_NETWORK/i.test(error)) {
+      httperror = true;
+      reasons.push(`network error: ${error}`);
+      continue;
+    }
+    httperror = true;
+    reasons.push(`navigation error: ${error}`);
+  }
+  for (const status of statuses) {
+    if (status >= 400 && status < 600) {
+      httperror = true;
+      reasons.push(`http status ${status}`);
+    }
+  }
+  if (input.offline) reasons.push("browser reports offline");
+  return { httperror, offline: input.offline, certificate, reasons };
+}
+function interstitialpolicy(state) {
+  if (state.certificate) return { interstitial: true, bypass: false, guidance: "A certificate interstitial was detected; Devthink reports it for review and never bypasses it." };
+  if (state.httperror) return { interstitial: true, bypass: false, guidance: "An http error state was detected and is reported for review." };
+  return { interstitial: false, bypass: false, guidance: "No interstitial was detected." };
+}
+function parseratelimit(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const value = options.ratelimit;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const limit = value;
+  const window2 = typeof limit.window === "number" && Number.isFinite(limit.window) && limit.window > 0 ? limit.window : 0;
+  const ceiling = typeof limit.ceiling === "number" && Number.isInteger(limit.ceiling) && limit.ceiling >= 1 ? limit.ceiling : 0;
+  if (window2 <= 0 || ceiling < 1) return null;
+  const domain = typeof limit.domain === "string" && limit.domain.trim() ? limit.domain.trim() : "";
+  return { domain, window: window2, ceiling };
+}
+function domainof(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+function ratewindow(state, limit, now) {
+  if (state && state.domain === limit.domain && state.limit.window === limit.window && state.limit.ceiling === limit.ceiling && now < state.openedat + limit.window) return state;
+  return { domain: limit.domain, limit, openedat: now, count: 0 };
+}
+function rateallows(state, now) {
+  const elapsed = now - state.openedat;
+  const remaining = Math.max(0, state.limit.ceiling - state.count);
+  const retryafter = Math.max(0, state.limit.window - elapsed);
+  return { allowed: remaining > 0, remaining, retryafter };
+}
+function recordratehit(state, now) {
+  return { ...state, count: state.count + 1, ...state.count + 1 === 1 ? { openedat: now } : {} };
+}
+function checksafe(url) {
+  const reasons = [];
+  let safe = true;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return { url, safe: false, reasons: ["the url does not parse"], at: 0 };
+  }
+  if (parsed.protocol !== "https:") {
+    safe = false;
+    reasons.push("the url must use HTTPS");
+  }
+  if (parsed.username || parsed.password) {
+    safe = false;
+    reasons.push("the url carries embedded credentials");
+  }
+  const host = parsed.hostname.toLowerCase();
+  const privatelist = ["localhost", "127.0.0.1", "0.0.0.0", "::1", "[::1]"];
+  if (privatelist.includes(host) || /^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host) || /^169\.254\./.test(host)) {
+    safe = false;
+    reasons.push(`the host ${host} is a private network target`);
+  }
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(host) || /^\[?[0-9a-f:]+\]?$/i.test(host)) {
+    safe = false;
+    reasons.push(`the host ${host} is a raw address without a domain`);
+  }
+  return { url, safe, reasons, at: 0 };
+}
+function curatelinks(urls, verifier) {
+  return urls.map((url) => {
+    const verdict = verifier(url);
+    return { url, verdict: verdict.safe ? "safe" : "unsafe", reasons: verdict.reasons };
+  });
+}
+function batchopenset(links) {
+  const open = [];
+  const refused = [];
+  for (const link of links) {
+    if (link.verdict === "safe") open.push(link.url);
+    else refused.push({ url: link.url, reasons: link.reasons });
+  }
+  return { open, refused };
+}
+function prefetchcandidates(urls, grants) {
+  const allowed = [];
+  const refused = [];
+  for (const url of urls) {
+    let origin = "";
+    try {
+      origin = new URL(url).origin;
+    } catch {
+      refused.push(url);
+      continue;
+    }
+    if (grants.includes(origin)) allowed.push(url);
+    else refused.push(url);
+  }
+  return { allowed, refused };
+}
+function preconnectorigins(origins) {
+  return [...new Set(origins.map((origin) => origin.trim()).filter(Boolean))];
+}
+function authfor(auths, url) {
+  let origin = "";
+  try {
+    origin = new URL(url).origin;
+  } catch {
+    return void 0;
+  }
+  return auths.find((record2) => record2.origin === origin);
+}
+
 // extension/background.ts
 var sessionduration = 15 * 60 * 1e3;
 var freshcheckkinds = /* @__PURE__ */ new Set(["focus", "inspect", "click", "type", "scroll", "select", "hover"]);
 var pointerkinds = /* @__PURE__ */ new Set(["movepointer", "clickpoint", "shiftclick", "clicktext", "clickaria", "clickname", "pierceshadow"]);
+var watchstepkinds = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus"]);
+var observationstepkinds = /* @__PURE__ */ new Set(["a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "readselection", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector"]);
+var navigationstepkinds = /* @__PURE__ */ new Set(["openlink", "openprivate", "reloadcache", "stopnav", "waitload", "waiturl", "followlink", "spanav", "spawait", "rewritequery", "setfragment", "navlist", "navprofile", "detecthttp", "readredirects", "readfinalurl", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "trailaudit", "pausenav", "navintent", "navrate", "openclipboard", "checksafe", "batchopen"]);
+var pausenavkinds = /* @__PURE__ */ new Set(["openlink", "openprivate", "followlink", "spanav", "navlist", "openclipboard", "batchopen", "prefetch", "preconnect", "deeplink", "reopentab"]);
+var ratecheckedkinds = /* @__PURE__ */ new Set(["openlink", "openprivate", "followlink", "spanav", "navlist", "openclipboard", "batchopen", "deeplink", "reopentab"]);
+var evidencepoll = 100;
+var evidencesettle = 5e3;
 var chromestorage = {
   async get(key) {
     return (await chrome.storage.local.get(key))[key];
@@ -753,7 +1541,10 @@ async function snapshot(tabid2) {
   } });
   const value = result[0]?.result;
   if (!value) throw new Error("The page did not return an observation.");
-  return value;
+  const observationcapture = value;
+  const version = await memory.nextobservationversion();
+  await memory.setobservation({ version, observation: observationcapture });
+  return observationcapture;
 }
 function plandialogpolicy(plan) {
   const step = plan?.steps.find((candidate) => candidate.kind === "dismissdialog");
@@ -874,6 +1665,14 @@ function stepauditkind(step, ok) {
   if (step.kind === "keyhold" || step.kind === "keyrelease") return "hold";
   if (step.kind === "retryaction") return "retry";
   if (pointerkinds.has(step.kind)) return "pointer";
+  if (watchstepkinds.has(step.kind)) return "watch";
+  if (step.kind === "diffsnapshots") return "diff";
+  if (step.kind === "readredirects" || step.kind === "readfinalurl" || step.kind === "detecthttp") return "redirect";
+  if (step.kind === "handleauth") return "auth";
+  if (step.kind === "prefetch" || step.kind === "preconnect") return "prefetch";
+  if (step.kind === "navrate") return "rate";
+  if (navigationstepkinds.has(step.kind)) return "navigation";
+  if (observationstepkinds.has(step.kind)) return "observation";
   return ok ? "action" : "error";
 }
 function resolvedinnerstep(step, plan) {
@@ -960,21 +1759,620 @@ async function executeenterframe(step, plan, tabid2, origin) {
   const derived = { ...step, options: JSON.stringify({ ...options, kind: inner.kind, ...inner.target ? { target: inner.target } : {}, ...inner.value ? { value: inner.value } : {}, ...inneroptions ? { options: inneroptions } : {} }) };
   return dispatchpagestep(derived, tabid2, origin, plan);
 }
+function observationnodes(observationcapture) {
+  return observationcapture.interactive.map((entry) => ({ selector: entry.selector, tag: entry.role, text: entry.label, attributes: {} }));
+}
+function detailarray(details, key) {
+  const value = details?.[key];
+  return Array.isArray(value) ? value : [];
+}
+async function executediffsnapshots(step, session, plan, tabid2, origin) {
+  const options = stepoptions2(step);
+  const versions = Array.isArray(options.versions) ? options.versions.filter((item) => typeof item === "number") : [];
+  const baseversion = versions[0];
+  const targetversion = versions[1];
+  if (baseversion === void 0 || targetversion === void 0) throw new Error("Two reviewed observation versions are required.");
+  const base = await memory.getobservation(baseversion);
+  const target = await memory.getobservation(targetversion);
+  if (!base || !target) throw new Error("A reviewed observation version has not been captured yet.");
+  const derived = { ...step, options: JSON.stringify({ ...options, base: observationnodes(base.observation), target: observationnodes(target.observation) }) };
+  const output = await dispatchpagestep(derived, tabid2, origin, plan) ?? { ok: false, summary: "The snapshot diff returned no result." };
+  const diff = {
+    baseversion,
+    targetversion,
+    added: detailarray(output.details, "added"),
+    removed: detailarray(output.details, "removed"),
+    changed: detailarray(output.details, "changed"),
+    at: Date.now()
+  };
+  await memory.adddiff(diff);
+  await audit("diff", `Diffed observation versions ${baseversion} and ${targetversion}: ${diff.added.length} added, ${diff.removed.length} removed and ${diff.changed.length} changed nodes.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  return { ok: Boolean(output.ok), summary: output.summary, details: { ...output.details ?? {}, versions: [baseversion, targetversion] } };
+}
+async function executewatchstep(step, session, plan, tabid2, origin) {
+  const options = stepoptions2(step);
+  const watchid = typeof options.watchid === "string" && options.watchid.trim() ? options.watchid : randomid();
+  const scopes = Array.isArray(options.scopes) ? options.scopes.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  const events = Array.isArray(options.events) ? options.events.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  const lifetime = typeof options.lifetime === "number" && Number.isFinite(options.lifetime) && options.lifetime > 0 ? options.lifetime : 0;
+  const watch = { watchid, kind: step.kind, stepid: step.id, sessionid: session.id, origin, scopes, events, startedat: Date.now(), lifetime };
+  await memory.addwatch(watch);
+  await audit("watch", `Watch ${step.kind} registered under id ${watchid} for the reviewed lifetime of ${lifetime} milliseconds inside ${scopes.length > 0 ? `scopes ${scopes.join(", ")}` : "the whole document"}.`, { sessionid: session.id, planid: plan.id, stepid: step.id });
+  const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The watch returned no result." };
+  await memory.closewatch(watchid, Date.now());
+  if (step.kind === "watchmutate") {
+    for (const entry of detailarray(output.details, "events")) {
+      if (!entry || typeof entry !== "object") continue;
+      const record2 = entry;
+      await memory.addmutationevent({ ...record2, sessionid: session.id });
+    }
+  }
+  if (step.kind === "watchfocus") {
+    for (const entry of detailarray(output.details, "events")) {
+      if (!entry || typeof entry !== "object") continue;
+      const record2 = entry;
+      await memory.addfocusevent({ ...record2, sessionid: session.id });
+    }
+  }
+  if (step.kind === "watchbanner") {
+    for (const entry of detailarray(output.details, "banners")) {
+      if (!entry || typeof entry !== "object") continue;
+      const record2 = entry;
+      await memory.addbanner({ ...record2, sessionid: session.id });
+    }
+  }
+  await audit("watch", `Watch ${watchid} closed after its reviewed lifetime of ${lifetime} milliseconds.`, { sessionid: session.id, planid: plan.id, stepid: step.id });
+  return { output, watch };
+}
+async function refreshsignals(step, output) {
+  const current = await memory.getsignals();
+  const next = current ? { ...current, refreshedat: Date.now() } : { refreshedat: Date.now() };
+  let changed = false;
+  if (step.kind === "readlang" || step.kind === "detectlanguage") {
+    const language = output?.details?.language;
+    if (typeof language === "string" && language) {
+      next.language = language;
+      changed = true;
+    }
+  }
+  if (step.kind === "classifypage") {
+    const template = output?.details?.template;
+    if (typeof template === "string" && template) {
+      next.template = template;
+      changed = true;
+    }
+  }
+  if (step.kind === "detectscrolllock") {
+    const locked = output?.details?.locked;
+    if (typeof locked === "boolean") {
+      next.scrolllocked = locked;
+      changed = true;
+    }
+  }
+  if (step.kind === "watchbanner") {
+    const banners = detailarray(output?.details, "banners");
+    const first = banners[0];
+    if (first && typeof first.kind === "string") {
+      next.banner = first.kind;
+      changed = true;
+    }
+  }
+  if (changed) await memory.setsignals(next);
+}
+async function recordevidence(step, output, session, plan, origin) {
+  const extra = { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id };
+  if (step.kind === "a11ytree" && output?.details?.tree && typeof output.details.tree === "object") {
+    const version = await memory.nextobservationversion();
+    await memory.adda11ytree({ version, tree: output.details.tree, capturedat: Date.now() });
+    await audit("observation", `Accessibility tree captured under observation version ${version} with ${output.details.nodecount ?? "an unknown count of"} nodes.`, extra);
+  }
+  if (step.kind === "readertree" && output?.details?.article && typeof output.details.article === "object") {
+    const version = await memory.nextobservationversion();
+    const article = output.details.article;
+    await memory.addreaderarticle({ version, article, capturedat: Date.now() });
+    await audit("observation", `Reader article captured under observation version ${version} with ${article.blocks.length} blocks and ${article.words} words.`, extra);
+  }
+  if (step.kind === "classifypage" && typeof output?.details?.template === "string") {
+    const fingerprint = typeof output.details.fingerprint === "string" ? output.details.fingerprint : "";
+    const profile = { origin, template: output.details.template, fingerprint, at: Date.now() };
+    await memory.addtemplate(profile);
+    await audit("observation", `Page template ${profile.template} classified for ${origin}${fingerprint ? ` with fingerprint ${fingerprint}` : ""}.`, extra);
+  }
+  if (step.kind === "fingerprintsection" && typeof output?.details?.fingerprint === "string") {
+    const profile = { origin, template: "", fingerprint: output.details.fingerprint, ...typeof output.details.section === "string" ? { section: output.details.section } : {}, at: Date.now() };
+    await memory.addtemplate(profile);
+    await audit("observation", `Section fingerprint ${profile.fingerprint} computed for ${origin}.`, extra);
+  }
+  if (step.kind === "deriveselector") {
+    const candidates = detailarray(output?.details, "candidates");
+    const best = candidates[0];
+    if (best && typeof best.selector === "string" && best.selector) {
+      const record2 = { stepid: step.id, selector: best.selector, strategy: best.strategy, score: best.score, at: Date.now() };
+      await memory.addselector(record2);
+      await audit("observation", `Derived selector ${record2.selector} through the ${record2.strategy} strategy with stability ${record2.score}.`, extra);
+    }
+  }
+  await refreshsignals(step, output);
+}
+var navbuffers = /* @__PURE__ */ new Map();
+var lastknownurls = /* @__PURE__ */ new Map();
+async function tracktabupdate(tabid2, changeinfo) {
+  const now = Date.now();
+  const url = typeof changeinfo.url === "string" ? changeinfo.url : void 0;
+  const status = changeinfo.status;
+  const previous = lastknownurls.get(tabid2);
+  if (status === "loading" && url) {
+    navbuffers.set(tabid2, [{ event: "beforenavigate", url, timestamp: now }]);
+    lastknownurls.set(tabid2, url);
+    return;
+  }
+  const buffer = navbuffers.get(tabid2) ?? [];
+  if (url) {
+    const kind = classifynavchange(previous ?? url, url, status);
+    buffer.push({ event: kind === "route" ? "urlchange" : "committed", url, timestamp: now, redirect: kind === "route" });
+    if (kind === "route" && previous) {
+      const session = await memory.getsession();
+      if (session && !session.stoppedat && session.tabid === tabid2) {
+        await memory.addtrailentry(session.id, { url, title: "", at: now });
+      }
+    }
+    lastknownurls.set(tabid2, url);
+  }
+  if (status === "complete") buffer.push({ event: "completed", url: lastknownurls.get(tabid2) ?? "", timestamp: now, status: 200 });
+  navbuffers.set(tabid2, buffer);
+}
+chrome.tabs.onUpdated.addListener((tabid2, changeinfo) => {
+  void tracktabupdate(tabid2, changeinfo);
+});
+chrome.tabs.onRemoved.addListener((tabid2) => {
+  const url = lastknownurls.get(tabid2);
+  if (url) void memory.addrecenttab({ url, tabid: tabid2, closedat: Date.now() });
+  lastknownurls.delete(tabid2);
+  navbuffers.delete(tabid2);
+});
+async function recordnavigation(step, session, tabid2) {
+  const started = Date.now();
+  let tab = await chrome.tabs.get(tabid2).catch(() => void 0);
+  while (tab && tab.status !== "complete" && Date.now() - started < evidencesettle) {
+    await new Promise((resolve) => setTimeout(resolve, evidencepoll));
+    tab = await chrome.tabs.get(tabid2).catch(() => void 0);
+  }
+  const url = tab?.url ?? lastknownurls.get(tabid2) ?? "";
+  const title = tab?.title ?? "";
+  const chain = buildredirectchain(navbuffers.get(tabid2) ?? []);
+  const record2 = {
+    stepid: step.id,
+    ...session ? { sessionid: session.id } : {},
+    origin: session?.origin ?? (url ? new URL(url).origin : ""),
+    finalurl: finalurl(chain) || url,
+    chain,
+    at: Date.now()
+  };
+  await memory.addnavrecord(record2);
+  await memory.setnavstate(tabid2, record2);
+  if (session && url) await memory.addtrailentry(session.id, { url, title, stepid: step.id, at: Date.now() });
+  return record2;
+}
+function injectallowedorigins(step, session) {
+  const allowedorigins = session?.grants ?? (session ? [session.origin] : []);
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  return { ...step, options: JSON.stringify({ ...options, allowedorigins }) };
+}
+async function enforceratelimit(url, stepid, sessionid) {
+  const domain = domainof(url);
+  if (!domain) return;
+  const states = await memory.getratestates();
+  const stored = states.find((item) => item.domain === domain);
+  if (!stored) return;
+  const live = ratewindow(stored, stored.limit, Date.now());
+  const decision = rateallows(live, Date.now());
+  if (!decision.allowed) {
+    await audit("rate", `The navigation rate limit of ${live.limit.ceiling} per ${live.limit.window} milliseconds for ${domain} was exceeded; the navigation was refused.`, { ...sessionid ? { sessionid } : {}, stepid });
+    throw new Error(`The navigation rate limit for ${domain} has been reached; retry after ${Math.ceil(decision.retryafter / 1e3)} seconds.`);
+  }
+  await memory.setratestate(recordratehit(live, Date.now()));
+  await audit("rate", `Navigation to ${url} counted against the reviewed rate limit of ${live.limit.ceiling} per ${live.limit.window} milliseconds for ${domain}; ${decision.remaining - 1} remaining.`, { ...sessionid ? { sessionid } : {}, stepid });
+}
+async function refusenavpause(step) {
+  if (!pausenavkinds.has(step.kind)) return;
+  const control = await memory.getnavcontrol();
+  if (control?.pausedat) throw new Error(control.reason ? `Navigation is paused: ${control.reason}` : "Navigation is paused while a consent prompt is open; resume navigation first.");
+}
+async function opencontainer(step, session, url, container, position) {
+  const windows = await chrome.windows.getAll().catch(() => []);
+  const plan = resolvecontainer({ url, container, position, private: container === "private" }, windows.map((item) => ({ id: item.id ?? 0, incognito: item.incognito ?? false, focused: item.focused ?? false })));
+  const extra = { ...session ? { sessionid: session.id } : {}, stepid: step.id };
+  if (plan.kind === "current" && session) {
+    const tabid2 = session.tabid;
+    await chrome.tabs.update(tabid2, { url });
+    const record2 = await recordnavigation(step, session, tabid2);
+    await audit("navigation", `Navigated the task tab to ${url}.`, extra);
+    return { ok: true, summary: `Navigated the task tab to ${url}.`, details: { container: plan.kind, url, finalurl: record2.finalurl, hops: record2.chain.hops.length } };
+  }
+  if (plan.kind === "private" || plan.kind === "window") {
+    const created2 = await chrome.windows.create({ url, incognito: plan.incognito });
+    await audit("navigation", `Opened ${plan.kind === "private" ? "a private window" : "a new window"} for ${url}${plan.kind === "private" ? " separated from normal windows" : ""}.`, extra);
+    return { ok: true, summary: `Opened ${plan.kind === "private" ? "a private window" : "a new window"} for ${url}.`, details: { container: plan.kind, url, windowid: created2?.id ?? 0, incognito: plan.incognito } };
+  }
+  const created = await chrome.tabs.create({ url, ...plan.windowid !== void 0 ? { windowId: plan.windowid } : {}, active: true });
+  await audit("navigation", `Opened a new tab for ${url} without leaving the current page.`, extra);
+  return { ok: true, summary: `Opened a new tab for ${url}.`, details: { container: "tab", url, tabid: created?.id ?? 0, position: plan.position } };
+}
+async function verifyopenurl(url, session) {
+  const grants = session?.grants ?? (session ? [session.origin] : []);
+  const verified = originverified(url, grants, await memory.getsafeties());
+  if (!verified.allowed) throw new Error(verified.reason);
+}
+async function executeopenlink(step, session) {
+  const target = parsenavtarget(step);
+  if (!target) throw new Error("A reviewed navtarget is required.");
+  await refusenavpause(step);
+  await enforceratelimit(target.url, step.id, session?.id);
+  await verifyopenurl(target.url, session);
+  return opencontainer(step, session, target.url, target.container, target.position ?? "adjacent");
+}
+async function executedeeplink(step, session) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const params = {};
+  if (options.params && typeof options.params === "object" && !Array.isArray(options.params)) {
+    for (const [name, value] of Object.entries(options.params)) if (typeof value === "string") params[name] = value;
+  }
+  const url = deeplinkurl(typeof options.app === "string" ? options.app : "", params);
+  if (!url) throw new Error("The reviewed deep link pattern is not a known web app.");
+  await refusenavpause(step);
+  await enforceratelimit(url, step.id, session?.id);
+  await verifyopenurl(url, session);
+  const target = parsenavtarget(step);
+  const container = target?.container === "window" ? "window" : target?.container === "private" ? "private" : target?.container === "current" ? "current" : "tab";
+  const output = await opencontainer(step, session, url, container, target?.position ?? "adjacent");
+  return { ...output, details: { ...output.details ?? {}, app: options.app, deeplink: url } };
+}
+async function executereopentab(step, session) {
+  await refusenavpause(step);
+  let url = step.value;
+  if (!url) {
+    const tabs = await chrome.tabs.query({}).catch(() => []);
+    const openurls = tabs.map((tab) => tab.url ?? "").filter(Boolean);
+    const recent = pickrecenttab(await memory.getrecenttabs(), openurls);
+    if (!recent) throw new Error("No recently closed tab is available to reopen.");
+    url = recent.url;
+  }
+  await enforceratelimit(url, step.id, session?.id);
+  await verifyopenurl(url, session);
+  const created = await chrome.tabs.create({ url, active: true });
+  await audit("navigation", `Reopened the recently closed tab ${url}.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ok: true, summary: `Reopened ${url} in a new tab.`, details: { url, tabid: created?.id ?? 0 } };
+}
+async function waitforcomplete(tabid2) {
+  const started = Date.now();
+  for (; ; ) {
+    const tab = await chrome.tabs.get(tabid2).catch(() => void 0);
+    if (!tab) return false;
+    if (tab.status === "complete") return true;
+    if (Date.now() - started >= evidencesettle) return false;
+    await new Promise((resolve) => setTimeout(resolve, evidencepoll));
+  }
+}
+async function recordnaventryoutcome(step, plan, entry) {
+  const base = await memory.getprogress();
+  await memory.setprogress(recordnaventry(base, plan.id, step.id, entry, Date.now()));
+}
+async function executenavlist(step, session, plan, tabid2) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const urls = Array.isArray(options.urls) ? options.urls.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  if (urls.length === 0) throw new Error("A reviewed list of navigation urls is required.");
+  await refusenavpause(step);
+  let completed = 0;
+  let failed = "";
+  for (let index = 0; index < urls.length; index += 1) {
+    const url = urls[index];
+    const entrygate = navigationgranted(session, url);
+    if (!entrygate.allowed) {
+      failed = entrygate.reason ?? "The navigation list entry was refused.";
+      await recordnaventryoutcome(step, plan, { index, url, ok: false });
+      break;
+    }
+    try {
+      await enforceratelimit(url, step.id, session?.id);
+      await refusenavpause(step);
+      await chrome.tabs.update(tabid2, { url });
+      await waitforcomplete(tabid2);
+      await recordnavigation(step, session, tabid2);
+      completed += 1;
+      await recordnaventryoutcome(step, plan, { index, url, ok: true });
+    } catch (error) {
+      failed = error instanceof Error ? error.message : String(error);
+      await recordnaventryoutcome(step, plan, { index, url, ok: false });
+      break;
+    }
+  }
+  const remaining = urls.length - completed;
+  const ok = failed === "" && completed === urls.length;
+  return {
+    ok,
+    summary: ok ? `Navigated the reviewed list of ${urls.length} url${urls.length === 1 ? "" : "s"} sequentially.` : `The navigation list stopped after ${completed} of ${urls.length} entries: ${failed}`,
+    details: { completed, remaining, urls }
+  };
+}
+async function executenavprofile(step, session, origin) {
+  const profile = parsewaitprofile(step);
+  if (!profile) throw new Error("A reviewed waitprofile is required.");
+  const record2 = { origin, profile, at: Date.now() };
+  await memory.setwaitprofile(record2);
+  const effective = profilefororigin(profile, origin);
+  await audit("navigation", `Wait profile applied for ${origin} with signals ${effective.signals.join(", ")}${effective.idle > 0 ? `, idle ${effective.idle}ms` : ""}${effective.timeout > 0 ? ` and timeout ${effective.timeout}ms` : ""}.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ok: true, summary: `Applied the reviewed wait profile for ${origin} during navigation.`, details: { origin, signals: effective.signals, idle: effective.idle, timeout: effective.timeout, overrides: (profile.overrides ?? []).map((override) => override.origin) } };
+}
+async function executedetecthttp(session, tabid2) {
+  const records = await memory.getnavrecords();
+  const buffer = navbuffers.get(tabid2) ?? [];
+  const errors = buffer.filter((event) => event.error !== void 0).map((event) => event.error);
+  const statuses = (records[0]?.chain.hops ?? []).map((hop) => hop.status).filter((status) => status > 0);
+  const state = detecthttpstate({ offline: !navigator.onLine, errors, statuses });
+  const policy = interstitialpolicy(state);
+  return {
+    ok: true,
+    summary: state.httperror || state.offline ? `Detected ${state.reasons.length} navigation problem${state.reasons.length === 1 ? "" : "s"}: ${state.reasons.join("; ")}.` : "No http error, offline state or certificate interstitial was detected.",
+    details: { httperror: state.httperror, offline: state.offline, certificate: state.certificate, reasons: state.reasons, interstitial: policy.interstitial, bypass: policy.bypass, guidance: policy.guidance }
+  };
+}
+async function executereadredirects(session) {
+  const record2 = (await memory.getnavrecords()).find((item) => !session || item.sessionid === session.id);
+  if (!record2) return { ok: false, summary: "No navigation has been recorded yet.", details: { chain: { hops: [], startedat: 0, endedat: 0 } } };
+  return { ok: true, summary: `The latest navigation travelled ${Math.max(0, record2.chain.hops.length - 1)} redirect${record2.chain.hops.length - 1 === 1 ? "" : "s"} to ${record2.finalurl}.`, details: { chain: record2.chain, finalurl: record2.finalurl, duration: record2.chain.endedat - record2.chain.startedat } };
+}
+async function executereadfinalurl(session) {
+  const record2 = (await memory.getnavrecords()).find((item) => !session || item.sessionid === session.id);
+  if (!record2) return { ok: false, summary: "No navigation has been recorded yet.", details: { finalurl: "" } };
+  return { ok: true, summary: `The final url after redirects is ${record2.finalurl}.`, details: { finalurl: record2.finalurl, hops: record2.chain.hops } };
+}
+async function executehandleauth(step, session) {
+  const auths = await memory.getauths();
+  const record2 = authfor(auths, step.value ?? "");
+  if (!record2) throw new Error(`No reviewed basic auth credentials are stored for ${step.value ?? ""}; store them from the side panel first.`);
+  await audit("auth", `Basic auth credentials for ${record2.origin} reviewed as ${record2.username} were armed for the auth prompt; the password stays out of every step detail.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ok: true, summary: `Armed the reviewed basic auth credentials of ${record2.username} for ${record2.origin}.`, details: { origin: record2.origin, username: record2.username, reviewedat: record2.reviewedat, armed: true } };
+}
+async function executeprintpdf(step, session, plan, tabid2, origin) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const output = await dispatchpagestep(step, tabid2, origin, plan);
+  const name = typeof options.name === "string" && options.name ? options.name : `${step.id}.pdf`;
+  const artifact = { id: randomid(), kind: "printpdf", name, stepid: step.id, at: Date.now() };
+  await memory.addartifact(artifact);
+  await audit("navigation", `Printed the page to pdf through the browser print pipeline and routed the artifact ${name} into the task artifact store.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ok: output?.ok ?? false, summary: output?.summary ?? "The print pipeline returned no result.", details: { ...output?.details ?? {}, artifact } };
+}
+async function executeprefetch(step, session, plan, tabid2, origin) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const urls = Array.isArray(options.urls) ? options.urls.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  const grants = session?.grants ?? (session ? [session.origin] : []);
+  const verdict = prefetchcandidates(urls, grants);
+  if (verdict.allowed.length === 0) throw new Error("No prefetch candidate is covered by the session grants.");
+  await refusenavpause(step);
+  const derived = { ...step, options: JSON.stringify({ ...options, urls: verdict.allowed }) };
+  const output = await dispatchpagestep(derived, tabid2, origin, plan);
+  await memory.setnavqueues({ prefetch: verdict.allowed.length, batchopen: (await memory.getnavqueues())?.batchopen ?? 0, updatedat: Date.now() });
+  await refreshbadge();
+  await audit("prefetch", `Prefetched ${verdict.allowed.length} predicted next page${verdict.allowed.length === 1 ? "" : "s"} verified against the session grants${verdict.refused.length > 0 ? ` and refused ${verdict.refused.length} candidate${verdict.refused.length === 1 ? "" : "s"} outside the grants` : ""}.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ok: Boolean(output?.ok), summary: output?.summary ?? "The prefetch step returned no result.", details: { ...output?.details ?? {}, allowed: verdict.allowed, refused: verdict.refused } };
+}
+async function executepreconnect(step, session, plan, tabid2, origin) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const origins = preconnectorigins(Array.isArray(options.origins) ? options.origins.filter((item) => typeof item === "string") : []);
+  await refusenavpause(step);
+  const output = await dispatchpagestep({ ...step, options: JSON.stringify({ ...options, origins }) }, tabid2, origin, plan);
+  await audit("prefetch", `Preconnected to ${origins.length} expected origin${origins.length === 1 ? "" : "s"}: ${origins.join(", ")}.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ok: Boolean(output?.ok), summary: output?.summary ?? "The preconnect step returned no result.", details: { ...output?.details ?? {}, origins } };
+}
+async function executeopenclipboard(step, session) {
+  await refusenavpause(step);
+  const text2 = await navigator.clipboard.readText();
+  let url = "";
+  try {
+    url = new URL(text2.trim()).toString();
+  } catch {
+    throw new Error("The clipboard does not hold a valid url.");
+  }
+  if (!url.startsWith("https://")) throw new Error("The clipboard url must use HTTPS.");
+  await enforceratelimit(url, step.id, session?.id);
+  await verifyopenurl(url, session);
+  const output = await opencontainer(step, session, url, "tab", "adjacent");
+  await audit("navigation", `Opened the clipboard url ${url} on the explicit consent of the reviewed step.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ...output, details: { ...output.details ?? {}, url } };
+}
+async function executechecksafe(step, session, planid) {
+  const verdict = { ...checksafe(step.value ?? ""), at: Date.now() };
+  await memory.addsafety(verdict);
+  await audit("navigation", `Safety check of ${verdict.url} returned ${verdict.safe ? "safe" : "unsafe"}${verdict.reasons.length > 0 ? `: ${verdict.reasons.join("; ")}` : ""}.`, { ...session ? { sessionid: session.id } : {}, ...planid ? { planid } : {}, stepid: step.id });
+  return { ok: true, summary: verdict.safe ? `The url ${verdict.url} passed every safety check.` : `The url ${verdict.url} is unsafe: ${verdict.reasons.join("; ")}.`, details: { verdict } };
+}
+async function executebatchopen(step, session) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const urls = Array.isArray(options.urls) ? options.urls.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  const links = curatelinks(urls, (url) => ({ ...checksafe(url), at: Date.now() }));
+  const curated = { id: randomid(), links, at: Date.now() };
+  await memory.addcurated(curated);
+  const set = batchopenset(links);
+  if (set.refused.length > 0) {
+    await memory.setnavqueues({ prefetch: (await memory.getnavqueues())?.prefetch ?? 0, batchopen: set.refused.length, updatedat: Date.now() });
+    await refreshbadge();
+    await audit("navigation", `Batch open refused for ${set.refused.length} unsafe url${set.refused.length === 1 ? "" : "s"}; the curated list waits for review.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+    return { ok: false, summary: `The batch was refused because ${set.refused.length} of ${links.length} urls are unsafe; review the curated list before opening.`, details: { curated, refused: set.refused } };
+  }
+  await refusenavpause(step);
+  const opened = [];
+  for (const url of set.open) {
+    await enforceratelimit(url, step.id, session?.id);
+    const created = await chrome.tabs.create({ url, active: opened.length === 0 });
+    opened.push(created?.id ?? 0);
+    if (session) await memory.addtrailentry(session.id, { url, title: "", stepid: step.id, at: Date.now() });
+  }
+  await memory.addcurated({ ...curated, reviewedat: Date.now() });
+  await memory.setnavqueues({ prefetch: (await memory.getnavqueues())?.prefetch ?? 0, batchopen: 0, updatedat: Date.now() });
+  await refreshbadge();
+  await audit("navigation", `Batch opened ${set.open.length} curated url${set.open.length === 1 ? "" : "s"} after per url safety checks.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ok: true, summary: `Opened ${set.open.length} curated url${set.open.length === 1 ? "" : "s"} after per url safety checks.`, details: { curated, tabids: opened } };
+}
+async function executepausenav(step, session) {
+  const control = await memory.getnavcontrol();
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  if (control?.pausedat) {
+    await memory.setnavcontrol({ updatedat: Date.now() });
+    await audit("resume", `Navigation resumed after ${Date.now() - control.pausedat} milliseconds of pause.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+    return { ok: true, summary: "Navigation resumed; reviewed navigation steps can run again.", details: { paused: false } };
+  }
+  const reason = typeof options.reason === "string" && options.reason ? options.reason : "a consent prompt is open";
+  await memory.setnavcontrol({ pausedat: Date.now(), reason, updatedat: Date.now() });
+  await audit("pause", `Navigation paused while ${reason}.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ok: true, summary: `Navigation paused while ${reason}.`, details: { paused: true, reason } };
+}
+async function executenavintent(step, session, origin) {
+  const record2 = { id: randomid(), intent: step.value ?? "", origin, ...session ? { sessionid: session.id } : {}, stepid: step.id, at: Date.now() };
+  await memory.addnavintent(record2);
+  await audit("navigation", `Navigation intent "${record2.intent}" recorded for ${origin}.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ok: true, summary: `Recorded the navigation intent "${record2.intent}".`, details: { intent: record2.intent, origin, at: record2.at } };
+}
+async function executenavrate(step, session, origin) {
+  const limit = parseratelimit(step);
+  if (!limit) throw new Error("A reviewed ratelimit is required.");
+  if (!limit.domain) limit.domain = domainof(origin) || origin;
+  const states = await memory.getratestates();
+  const stored = states.find((item) => item.domain === limit.domain);
+  const live = ratewindow(stored, limit, Date.now());
+  const decision = rateallows(live, Date.now());
+  await memory.setratestate(live);
+  await audit("rate", `Navigation rate limit of ${limit.ceiling} per ${limit.window} milliseconds applied for ${limit.domain}; ${decision.remaining} navigation${decision.remaining === 1 ? "" : "s"} remaining in the window.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+  return { ok: true, summary: `Applied the reviewed navigation rate limit for ${limit.domain}.`, details: { domain: limit.domain, window: limit.window, ceiling: limit.ceiling, count: live.count, remaining: decision.remaining, retryafter: decision.retryafter } };
+}
+async function executetrailaudit(session) {
+  if (!session) throw new Error("No active browser session exists.");
+  const trail = await memory.gettrail(session.id);
+  return { ok: true, summary: `The navigation trail of the session holds ${trail.length} visited url${trail.length === 1 ? "" : "s"}.`, details: { trail } };
+}
+async function executenavigationkind(step, session, plan, tabid2, origin) {
+  switch (step.kind) {
+    case "openlink":
+      return executeopenlink(step, session);
+    case "openprivate":
+      return executeopenlink(step, session);
+    case "deeplink":
+      return executedeeplink(step, session);
+    case "reopentab":
+      return executereopentab(step, session);
+    case "reloadcache": {
+      await refusenavpause(step);
+      await chrome.tabs.reload(tabid2, { bypassCache: true });
+      const record2 = await recordnavigation(step, session, tabid2);
+      await audit("navigation", `Reloaded the page bypassing the cache.`, { ...session ? { sessionid: session.id } : {}, stepid: step.id });
+      return { ok: true, summary: "Reloaded the page bypassing the cache.", details: { bypasscache: true, finalurl: record2.finalurl } };
+    }
+    case "navlist":
+      return executenavlist(step, session, plan, tabid2);
+    case "navprofile":
+      return executenavprofile(step, session, origin);
+    case "detecthttp":
+      return executedetecthttp(session, tabid2);
+    case "readredirects":
+      return executereadredirects(session);
+    case "readfinalurl":
+      return executereadfinalurl(session);
+    case "handleauth":
+      return executehandleauth(step, session);
+    case "printpdf":
+      return executeprintpdf(step, session, plan, tabid2, origin);
+    case "prefetch":
+      return executeprefetch(step, session, plan, tabid2, origin);
+    case "preconnect":
+      return executepreconnect(step, session, plan, tabid2, origin);
+    case "checksafe":
+      return executechecksafe(step, session, plan.id);
+    case "batchopen":
+      return executebatchopen(step, session);
+    case "pausenav":
+      return executepausenav(step, session);
+    case "navintent":
+      return executenavintent(step, session, origin);
+    case "navrate":
+      return executenavrate(step, session, origin);
+    case "trailaudit":
+      return executetrailaudit(session);
+    case "openclipboard":
+      return executeopenclipboard(step, session);
+    default: {
+      await refusenavpause(step);
+      if (ratecheckedkinds.has(step.kind)) await enforceratelimit(origin, step.id, session?.id);
+      const derived = injectallowedorigins(step, session);
+      const output = await dispatchpagestep(derived, tabid2, origin, plan);
+      if (step.kind === "followlink" || step.kind === "spanav") {
+        const record2 = await recordnavigation(step, session, tabid2);
+        return { ...output ?? { ok: false, summary: "The navigation step returned no result." }, details: { ...(output ?? {}).details ?? {}, finalurl: record2.finalurl, hops: record2.chain.hops.length } };
+      }
+      return output ?? { ok: false, summary: "The navigation step returned no result." };
+    }
+  }
+}
+async function refreshbadge() {
+  const queues = await memory.getnavqueues();
+  const total = (queues?.prefetch ?? 0) + (queues?.batchopen ?? 0);
+  await chrome.action.setBadgeText({ text: total > 0 ? String(total) : "" }).catch(() => {
+  });
+}
 async function executestep(stepid) {
   const session = await memory.getsession();
   const plan = await memory.getplan();
   const { tab, origin } = await activecontext();
   const step = plan?.steps.find((candidate) => candidate.id === stepid);
   if (!step) throw new Error("Reviewed step was not found.");
-  const gate = canexecute({ session, plan, step, tabid: tab.id, origin });
+  const gate = canexecute({ session, plan, step, tabid: tab.id, origin, verdicts: await memory.getsafeties() });
   if (!gate.allowed) throw new Error(gate.reason);
+  const capability = requiredcapability(step.kind);
+  if (capability) {
+    const granted = await chrome.permissions.contains({ permissions: [capability] });
+    if (!granted) throw new Error(`The ${capability} capability has not been granted; request it from the review panel.`);
+  }
   let output;
+  let watchwindow;
   if (isbrowserkind(step.kind)) {
-    const capability = requiredcapability(step.kind);
-    if (capability) {
-      const granted = await chrome.permissions.contains({ permissions: [capability] });
-      if (!granted) throw new Error(`The ${capability} capability has not been granted; request it from the review panel.`);
-    }
     output = await runbrowseraction(step, tab.id, tab.windowId ?? chrome.windows.WINDOW_ID_CURRENT);
   } else if (step.kind === "keyhold") {
     output = await executekeyhold(step, session, plan, tab.id, origin);
@@ -988,6 +2386,15 @@ async function executestep(stepid) {
     output = await executemapclicks(step, plan, tab.id, origin);
   } else if (step.kind === "enterframe") {
     output = await executeenterframe(step, plan, tab.id, origin);
+  } else if (watchstepkinds.has(step.kind)) {
+    if (!session || !plan || plan.state !== "approved") throw new Error("Watch kinds refuse to run outside an approved session plan.");
+    const watched = await executewatchstep(step, session, plan, tab.id, origin);
+    output = watched.output;
+    watchwindow = { startedat: watched.watch.startedat, lifetime: watched.watch.lifetime };
+  } else if (step.kind === "diffsnapshots") {
+    output = await executediffsnapshots(step, session, plan, tab.id, origin);
+  } else if (navigationstepkinds.has(step.kind)) {
+    output = await executenavigationkind(step, session, plan, tab.id, origin);
   } else {
     if (step.target && freshcheckkinds.has(step.kind)) {
       const fresh = await snapshot(tab.id);
@@ -995,6 +2402,8 @@ async function executestep(stepid) {
     }
     output = await dispatchpagestep(step, tab.id, origin, plan);
   }
+  if (["navigate", "back", "forward"].includes(step.kind)) await recordnavigation(step, session, tab.id);
+  await recordevidence(step, output, session, plan, origin);
   const summary = output?.summary ?? "The page action returned no result.";
   const resolved = output?.details?.resolvedtarget;
   if (resolved) {
@@ -1005,7 +2414,8 @@ async function executestep(stepid) {
   await audit(auditkind, summary, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid });
   await memory.addoutcome(outcome);
   if (output?.ok && plan) {
-    const completed = recordstep(await memory.getprogress(), plan.id, stepid, Date.now());
+    const base = await memory.getprogress();
+    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);
     if (iscomplete(tracked, plan) && plan.state === "approved") {
@@ -1083,7 +2493,23 @@ async function handlerequest(message, sender) {
       const holds = heldkeys(await memory.getholds());
       const observationversion = await memory.getobservationversion();
       const map = observationversion !== void 0 && observationversion > 0 ? await memory.getmap(observationversion) : void 0;
-      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(), ...map ? { map } : {} };
+      const a11y = (await memory.geta11ytrees())[0];
+      const reader = (await memory.getreaderarticles())[0];
+      const signals = await memory.getsignals();
+      const trail = session ? await memory.gettrail(session.id) : [];
+      const navrecords = await memory.getnavrecords();
+      const ratestates = await memory.getratestates();
+      const safeties = await memory.getsafeties();
+      const curated = await memory.getcurateds();
+      const waitprofiles = await memory.getwaitprofiles();
+      const auths = (await memory.getauths()).map((record2) => ({ origin: record2.origin, username: record2.username, reviewedat: record2.reviewedat }));
+      const navcontrol = await memory.getnavcontrol();
+      const navqueues = await memory.getnavqueues();
+      const artifacts = await memory.getartifacts();
+      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 };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -1135,10 +2561,52 @@ async function handlerequest(message, sender) {
       if (!map) throw new Error("No clickable map has been captured yet.");
       return JSON.parse(mapresponse({ map, plan }));
     }
+    case "observation": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for an observation envelope.");
+      const version = await memory.getobservationversion();
+      const record2 = version !== void 0 ? await memory.getobservation(version) : void 0;
+      if (!record2) throw new Error("No observation has been captured yet.");
+      return JSON.parse(observationresponse({ observation: record2.observation, plan }));
+    }
     case "pausesession":
       return pausesession();
     case "resumesession":
       return resumesession();
+    case "storeauth": {
+      const session = await memory.getsession();
+      if (!session || session.stoppedat || session.expiresat <= Date.now()) throw new Error("Basic auth credentials are stored only behind the consent gate of an active session.");
+      const inputauth = message;
+      const origin = new URL(inputauth.origin ?? "").origin;
+      if (!origin.startsWith("https://")) throw new Error("Basic auth credentials need an HTTPS origin.");
+      if (!inputauth.username?.trim() || !inputauth.password) throw new Error("Basic auth credentials need a username and a password.");
+      const record2 = { origin, username: inputauth.username.trim(), password: inputauth.password, reviewedat: Date.now() };
+      await memory.setauth(record2);
+      await audit("auth", `Basic auth credentials for ${origin} stored after explicit review; the password never leaves local storage.`, { sessionid: session.id });
+      return { origin: record2.origin, username: record2.username, reviewedat: record2.reviewedat };
+    }
+    case "checksafe": {
+      const inputurl = message;
+      const verdict = { ...checksafe(inputurl.url ?? ""), at: Date.now() };
+      await memory.addsafety(verdict);
+      const session = await memory.getsession();
+      await audit("navigation", `Safety check of ${verdict.url} returned ${verdict.safe ? "safe" : "unsafe"}${verdict.reasons.length > 0 ? `: ${verdict.reasons.join("; ")}` : ""}.`, { ...session ? { sessionid: session.id } : {} });
+      return verdict;
+    }
+    case "navstate": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for a navstate envelope.");
+      const record2 = (await memory.getnavrecords())[0];
+      const session = await memory.getsession();
+      const livetab = session ? await chrome.tabs.get(session.tabid).catch(() => void 0) : void 0;
+      const state = { phase: livetab?.status === "loading" ? "loading" : "complete", ...record2 ? { finalurl: record2.finalurl, redirects: record2.chain } : {} };
+      return JSON.parse(navstateresponse({ navstate: state, plan }));
+    }
+    case "safeties": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for a safety envelope.");
+      return JSON.parse(safetyresponse({ verdicts: await memory.getsafeties(), plan }));
+    }
     case "stop": {
       const session = await memory.getsession();
       if (session) await memory.setsession({ ...session, stoppedat: Date.now() });
@@ -1155,6 +2623,16 @@ 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 reconcilewatches() {
+  for (const watch of await memory.getwatches()) {
+    if (watch.closedat !== void 0) continue;
+    if (!watchclosed(watch.startedat, watch.lifetime, Date.now())) continue;
+    await memory.closewatch(watch.watchid, Date.now());
+    await audit("watch", `Watch ${watch.watchid} of ${watch.kind} closed on service worker restart after its reviewed lifetime of ${watch.lifetime} milliseconds.`, { sessionid: watch.sessionid, stepid: watch.stepid });
+  }
+}
+reconcilewatches().catch(() => {
+});
 chrome.runtime.onConnect.addListener((port) => {
   if (port.name !== "devthinksidepanel" || port.sender?.id !== chrome.runtime.id || !port.sender.url?.startsWith(chrome.runtime.getURL(""))) return port.disconnect();
   port.onMessage.addListener((message) => {