@wenathlan/extension 1.1.32 → 1.1.34

package/extension/dist/background.js

@@ -66,18 +66,191 @@ var sessionmemory = class {
     const retention = (await this.getsettings())?.outcomeretention;
     await this.adapter.set("outcomes", retention === void 0 ? combined : combined.slice(0, retention));
   }
+  /** Stores one clickable map under its observation version so every captured map stays available. */
+  async setmap(map) {
+    return this.adapter.set(`map${map.version}`, map);
+  }
+  /** Returns one stored clickable map by its observation version. */
+  async getmap(version) {
+    return this.adapter.get(`map${version}`);
+  }
+  /** Advances and persists the observation version counter used to stamp clickable maps. */
+  async nextobservationversion() {
+    const current = await this.adapter.get("observationversion") ?? 0;
+    const next = current + 1;
+    await this.adapter.set("observationversion", next);
+    return next;
+  }
+  /** Returns the latest observation version used to stamp a clickable map. */
+  async getobservationversion() {
+    return this.adapter.get("observationversion");
+  }
+  /** Returns the key hold registry, persisted so holds survive service worker restarts. */
+  async getholds() {
+    return await this.adapter.get("holds") ?? [];
+  }
+  /** Replaces the key hold registry after one press or release transition. */
+  async setholds(holds) {
+    return this.adapter.set("holds", holds);
+  }
+  /** Returns every dialog decision recorded for the audit trail. */
+  async getdialogs() {
+    return await this.adapter.get("dialogs") ?? [];
+  }
+  /** Records one dialog decision with the reviewed answer and the observed dialog text. */
+  async adddialog(decision) {
+    const records = await this.getdialogs();
+    await this.adapter.set("dialogs", [decision, ...records]);
+  }
+  /** Returns every retry outcome recorded with attempts and movement deltas. */
+  async getretries() {
+    return await this.adapter.get("retries") ?? [];
+  }
+  /** Records one retry outcome with the attempts made and the movement delta observed. */
+  async addretry(outcome) {
+    const records = await this.getretries();
+    await this.adapter.set("retries", [outcome, ...records]);
+  }
+  /** Returns every resolution summary stored per target mode. */
+  async getresolutions() {
+    return await this.adapter.get("resolutions") ?? [];
+  }
+  /** Records one resolution summary for later selector derivation. */
+  async addresolution(summary) {
+    const records = await this.getresolutions();
+    await this.adapter.set("resolutions", [summary, ...records]);
+  }
+  /** Returns the reviewed default dialog policy kept for the session auto handler. */
+  async getdialogpolicy() {
+    return this.adapter.get("dialogpolicy");
+  }
+  /** Stores the reviewed default dialog policy of the latest approved plan. */
+  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);
+  }
 };
 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"]);
-var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset"]);
-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"]);
+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 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", "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"]);
 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"]);
-var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile"]);
+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"]);
 function normalizeendpoint(value) {
   const endpoint = new URL(value.trim());
   if (endpoint.protocol !== "https:") throw new Error("Devthink accepts HTTPS endpoints only.");
@@ -121,19 +294,84 @@ function isnumericid(value) {
 function numericoption(options, key) {
   return options[key] === void 0 || typeof options[key] === "number" && Number.isFinite(options[key]);
 }
+function nonnegativeoption(options, key) {
+  return numericoption(options, key) && !(typeof options[key] === "number" && options[key] < 0);
+}
+function isnonempty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function ispoint(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const point = value;
+  return typeof point.x === "number" && Number.isFinite(point.x) && typeof point.y === "number" && Number.isFinite(point.y);
+}
+function validatetargetref(reference) {
+  if (!reference || typeof reference !== "object" || Array.isArray(reference)) return { allowed: false, reason: "The reviewed target reference must be an object." };
+  const ref = reference;
+  if (ref.mode === "selector") return isnonempty(ref.selector) ? { allowed: true } : { allowed: false, reason: "The selector target reference needs a non-empty selector." };
+  if (ref.mode === "text") return isnonempty(ref.text) ? { allowed: true } : { allowed: false, reason: "The text target reference needs non-empty text." };
+  if (ref.mode === "aria") {
+    if (!isnonempty(ref.role)) return { allowed: false, reason: "The aria target reference needs a non-empty role." };
+    return isnonempty(ref.name) ? { allowed: true } : { allowed: false, reason: "The aria target reference needs a non-empty name." };
+  }
+  if (ref.mode === "name") return isnonempty(ref.name) ? { allowed: true } : { allowed: false, reason: "The name target reference needs a non-empty name." };
+  if (ref.mode === "xpath") return isnonempty(ref.xpath) ? { allowed: true } : { allowed: false, reason: "The xpath target reference needs a non-empty expression." };
+  if (ref.mode === "index") {
+    const index = ref.index;
+    return typeof index === "number" && Number.isInteger(index) && index >= 1 ? { allowed: true } : { allowed: false, reason: "The index target reference needs a positive integer map number." };
+  }
+  if (ref.mode === "point") {
+    const pointok = typeof ref.x === "number" && Number.isFinite(ref.x) && typeof ref.y === "number" && Number.isFinite(ref.y);
+    return pointok ? { allowed: true } : { allowed: false, reason: "The point target reference needs numeric x and y coordinates." };
+  }
+  return { allowed: false, reason: "The target reference mode must be selector, text, aria, name, xpath, index or point." };
+}
+function origingranted(session, origin) {
+  if (!session) return false;
+  const grants = session.grants ?? [session.origin];
+  return grants.includes(origin);
+}
+function validateinnerstep(options, origin) {
+  const stepid = options.stepid;
+  const kind = options.kind;
+  if (isnonempty(stepid)) {
+    if (kind !== void 0) return { allowed: false, reason: "The reviewed wrapper must reference a step id or an inline step, not both." };
+    return { allowed: true };
+  }
+  if (typeof kind !== "string" || !kind.trim()) return { allowed: false, reason: "A reviewed step id or inline step kind is required in options." };
+  if (kind === "retryaction" || kind === "enterframe") return { allowed: false, reason: "The reviewed inner step cannot be another wrapper kind." };
+  if (!allowedactions.has(kind)) return { allowed: false, reason: "The reviewed inner step kind is unsupported." };
+  const inneroptions = options.options;
+  if (inneroptions !== void 0 && (!inneroptions || typeof inneroptions !== "object" || Array.isArray(inneroptions))) return { allowed: false, reason: "The reviewed inner step options must be an object." };
+  const inner = {
+    id: "inner",
+    kind,
+    summary: "Reviewed inner step.",
+    risk: actionrisk(kind),
+    ...isnonempty(options.target) ? { target: options.target } : {},
+    ...isnonempty(options.value) ? { value: options.value } : {},
+    ...inneroptions !== void 0 ? { options: JSON.stringify(inneroptions) } : {}
+  };
+  return validatestep(inner, origin);
+}
 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." };
-  if (targetactions.has(step.kind) && !step.target?.trim()) return { allowed: false, reason: "A page target is required." };
-  if (valueactions.has(step.kind) && !step.value?.trim()) return { allowed: false, reason: "A reviewed value is required." };
-  if (step.kind === "select" && !step.value?.trim()) return { allowed: false, reason: "A reviewed option value is required." };
-  if (step.kind === "navigate" && !step.value) return { allowed: false, reason: "A navigation URL is required." };
   let options;
   try {
     options = parseoptions(step);
   } catch {
     return { allowed: false, reason: "Step options must be a JSON object." };
   }
+  const hastargetref = options.targetref !== void 0;
+  if (targetactions.has(step.kind) && !step.target?.trim() && !hastargetref) return { allowed: false, reason: "A page target is required." };
+  if (valueactions.has(step.kind) && !step.value?.trim()) return { allowed: false, reason: "A reviewed value is required." };
+  if (step.kind === "select" && !step.value?.trim()) return { allowed: false, reason: "A reviewed option value is required." };
+  if (step.kind === "navigate" && !step.value) return { allowed: false, reason: "A navigation URL is required." };
+  if (hastargetref) {
+    const reference = validatetargetref(options.targetref);
+    if (!reference.allowed) return reference;
+  }
   if (step.kind === "wait") {
     try {
       waitduration(step);
@@ -173,6 +411,86 @@ function validatestep(step, origin) {
   }
   if ((step.kind === "scrollpage" || step.kind === "scrollby") && (!numericoption(options, "x") || !numericoption(options, "y"))) return { allowed: false, reason: "Scroll amounts must be numbers in options." };
   if (step.kind === "waitfor" && options.timeout !== void 0 && (typeof options.timeout !== "number" || options.timeout < 0)) return { allowed: false, reason: "The waitfor timeout must be zero or a positive number of milliseconds." };
+  if (step.kind === "movepointer") {
+    const path = options.pointpath;
+    if (!path || typeof path !== "object" || Array.isArray(path)) return { allowed: false, reason: "A reviewed pointpath with start and end points is required in options." };
+    const points = path;
+    if (!ispoint(points.start) || !ispoint(points.end)) return { allowed: false, reason: "The reviewed pointpath needs numeric start and end points." };
+    if (points.waypoints !== void 0 && (!Array.isArray(points.waypoints) || !points.waypoints.every((waypoint) => ispoint(waypoint)))) return { allowed: false, reason: "The reviewed pointpath waypoints must be numeric points." };
+    if (!nonnegativeoption(points, "duration")) return { allowed: false, reason: "The reviewed pointpath duration must be zero or a positive number of milliseconds." };
+    const speed = options.speedprofile;
+    if (speed !== void 0) {
+      if (!speed || typeof speed !== "object" || Array.isArray(speed)) return { allowed: false, reason: "The reviewed speed profile must be an object." };
+      const profile = speed;
+      if (profile.easing !== void 0 && profile.easing !== "linear" && profile.easing !== "easeinout") return { allowed: false, reason: "The reviewed easing must be linear or easeinout." };
+      if (!nonnegativeoption(profile, "peak")) return { allowed: false, reason: "The reviewed peak velocity must be zero or a positive number." };
+      if (!nonnegativeoption(profile, "jitter")) return { allowed: false, reason: "The reviewed jitter window must be zero or a positive number of milliseconds." };
+    }
+  }
+  if (step.kind === "clickpoint" && (!hastargetref || options.targetref.mode !== "point")) return { allowed: false, reason: "A reviewed point target reference is required in options." };
+  if (step.kind === "clicktext" && (!hastargetref || options.targetref.mode !== "text")) return { allowed: false, reason: "A reviewed text target reference is required in options." };
+  if (step.kind === "clickaria" && (!hastargetref || options.targetref.mode !== "aria")) return { allowed: false, reason: "A reviewed aria target reference is required in options." };
+  if (step.kind === "clickname" && (!hastargetref || options.targetref.mode !== "name")) return { allowed: false, reason: "A reviewed name target reference is required in options." };
+  if (step.kind === "resolvexpath" && (!hastargetref || options.targetref.mode !== "xpath")) return { allowed: false, reason: "A reviewed xpath target reference is required in options." };
+  if (step.kind === "typetime" && options.delay !== void 0 && (typeof options.delay !== "number" || !Number.isFinite(options.delay) || options.delay < 0)) return { allowed: false, reason: "The reviewed per keystroke delay must be zero or a positive number of milliseconds." };
+  if (step.kind === "submitsearch") {
+    if (!isnonempty(options.results)) return { allowed: false, reason: "A reviewed results region selector is required in options." };
+    if (options.timeout !== void 0 && (typeof options.timeout !== "number" || !Number.isFinite(options.timeout) || options.timeout < 0)) return { allowed: false, reason: "The submitsearch timeout must be zero or a positive number of milliseconds." };
+  }
+  if (step.kind === "selectmulti") {
+    const values = options.values;
+    if (!Array.isArray(values) || values.length === 0 || !values.every((value) => isnonempty(value))) return { allowed: false, reason: "A reviewed list of option values is required in options." };
+  }
+  if (step.kind === "setslider") {
+    const slider = Number(step.value);
+    if (!Number.isFinite(slider)) return { allowed: false, reason: "The reviewed slider value must be a number." };
+  }
+  if (step.kind === "setdate" && !/^\d{4}-\d{2}-\d{2}$/.test(step.value ?? "")) return { allowed: false, reason: "The reviewed date must use the yyyy-mm-dd form." };
+  if (step.kind === "setcolor" && !/^#[0-9a-fA-F]{6}$/.test(step.value ?? "")) return { allowed: false, reason: "The reviewed color must use the #rrggbb form." };
+  if (step.kind === "keyhold" && options.holdid !== void 0 && !isnonempty(options.holdid)) return { allowed: false, reason: "The reviewed hold id must be a non-empty string." };
+  if (step.kind === "dismissdialog") {
+    const accept = options.accept;
+    const answer = options.answer;
+    if (accept === void 0 && !isnonempty(answer)) return { allowed: false, reason: "A reviewed accept flag or prompt answer is required in options." };
+    if (accept !== void 0 && typeof accept !== "boolean") return { allowed: false, reason: "The reviewed dialog accept flag must be a boolean." };
+    if (answer !== void 0 && !isnonempty(answer)) return { allowed: false, reason: "The reviewed prompt answer must be a non-empty string." };
+  }
+  if (step.kind === "pierceshadow" && options.shadow !== void 0) {
+    if (!Array.isArray(options.shadow) || !options.shadow.every((item) => isnonempty(item))) return { allowed: false, reason: "The reviewed shadow path must be a list of non-empty selectors." };
+  }
+  if (step.kind === "enterframe") {
+    const path = options.framepath;
+    if (!Array.isArray(path) || path.length === 0 || !path.every((item) => typeof item === "number" && Number.isInteger(item) && item >= 0)) return { allowed: false, reason: "A reviewed frame path of frame indexes is required in options." };
+    return validateinnerstep(options, origin);
+  }
+  if (step.kind === "retryaction") {
+    const inner = validateinnerstep(options, origin);
+    if (!inner.allowed) return inner;
+    const rule = options.retryrule;
+    if (!rule || typeof rule !== "object" || Array.isArray(rule)) return { allowed: false, reason: "A reviewed retry rule with attempts is required in options." };
+    const retry = rule;
+    if (typeof retry.attempts !== "number" || !Number.isInteger(retry.attempts) || retry.attempts < 1) return { allowed: false, reason: "The reviewed retry attempts must be a positive integer with no code ceiling." };
+    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." };
+  }
   return { allowed: true };
 }
 function sessiongate(input) {
@@ -188,6 +506,8 @@ function canexecute(input) {
   if (!gate.allowed) return gate;
   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." };
   return validatestep(input.step, input.origin);
 }
 function canpreview(input) {
@@ -196,7 +516,13 @@ function canpreview(input) {
   if (!gate.allowed) return gate;
   if (!input.plan || !["pending", "approved"].includes(input.plan.state)) return { allowed: false, reason: "Only a reviewed pending or approved plan can be previewed." };
   if (input.plan.expiresat <= now) return { allowed: false, reason: "The reviewed plan has expired." };
-  if (!targetactions.has(input.step.kind)) return { allowed: false, reason: "Only a target-based action can be previewed." };
+  let options = {};
+  try {
+    options = parseoptions(input.step);
+  } catch {
+    options = {};
+  }
+  if (!targetactions.has(input.step.kind) && options.targetref === void 0) return { allowed: false, reason: "Only a target-based action can be previewed." };
   return validatestep(input.step, input.origin);
 }
 
@@ -224,9 +550,17 @@ 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);
+}
 
 // version.ts
-var packageversion = "1.1.32";
+var packageversion = "1.1.34";
 
 // types.ts
 var protocolversion = packageversion;
@@ -262,6 +596,11 @@ function parseproposal(value, origin) {
     if (!evaluation.allowed) throw new Error(evaluation.reason);
     return step;
   });
+  for (const step of steps) {
+    if (step.kind !== "retryaction" && step.kind !== "enterframe") continue;
+    const options = parseoptions(step);
+    if (typeof options.stepid === "string" && !steps.some((candidate) => candidate.id === options.stepid)) throw new Error("A retry or frame wrapper references an unknown step id.");
+  }
   const createdat = Date.now();
   const expiresat = typeof planinput.expiresat === "number" ? planinput.expiresat : createdat + 10 * 60 * 1e3;
   const plan = {
@@ -279,6 +618,28 @@ function parseproposal(value, origin) {
 function requestbody(input) {
   return JSON.stringify({ version: protocolversion, objective: input.objective, session: input.session, observation: input.observation, capabilities: input.capabilities });
 }
+function outcomeresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {} });
+}
+function mapresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
+}
+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 } : {}
+  };
+}
 
 // extension/browsertabs.ts
 var browserkinds = /* @__PURE__ */ new Set(["tablist", "tabcreate", "tabactivate", "tabclose", "tabreload", "tabsnapshot", "windowlist", "windowcreate", "windowclose", "zoomset", "windowresize", "downloadfile"]);
@@ -363,9 +724,145 @@ async function runbrowseraction(step, sessiontabid, windowid) {
   }
 }
 
+// extension/pagedialogs.ts
+function parsedialogpolicy(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    return null;
+  }
+  const accept = options.accept;
+  const answer = options.answer;
+  if (typeof accept !== "boolean" && typeof answer !== "string") return null;
+  return { accept: accept === true, ...typeof answer === "string" && answer.trim() ? { answer } : {} };
+}
+function dialoganswer(policy, dialog) {
+  if (dialog === "prompt") {
+    if (policy.answer === void 0 || policy.answer === "") return { accept: false };
+    return { accept: policy.accept !== false, ...policy.answer !== void 0 ? { answer: policy.answer } : {} };
+  }
+  return { accept: policy.accept };
+}
+function installdialoghandler(accept, answer, persistent) {
+  const world = globalThis;
+  const originals = world.devthinkoriginaldialogs ?? { confirm: window.confirm.bind(window), alert: window.alert.bind(window), prompt: window.prompt.bind(window) };
+  world.devthinkoriginaldialogs = originals;
+  const decide = (dialog) => {
+    if (dialog === "prompt") return answer ? { accept: true, answer } : { accept: false, answer: null };
+    return { accept, answer: null };
+  };
+  const record2 = (dialog, text2, result) => {
+    try {
+      const root = document.documentElement;
+      const log = JSON.parse(root.dataset.devthinkdialoglog ?? "[]");
+      log.push({ dialog, text: text2, result, at: Date.now() });
+      root.dataset.devthinkdialoglog = JSON.stringify(log);
+    } catch {
+    }
+  };
+  window.confirm = (text2) => {
+    const decision = decide("confirm");
+    record2("confirm", text2 ?? "", decision.accept);
+    if (!persistent) window.confirm = originals.confirm;
+    return decision.accept;
+  };
+  window.alert = (text2) => {
+    record2("alert", text2 ?? "", true);
+    if (!persistent) window.alert = originals.alert;
+  };
+  window.prompt = (text2, defaultvalue) => {
+    const decision = decide("prompt");
+    const outcome = decision.accept ? decision.answer ?? defaultvalue ?? "" : null;
+    record2("prompt", text2 ?? "", outcome);
+    if (!persistent) window.prompt = originals.prompt;
+    return outcome;
+  };
+}
+
+// extension/pageinteract.ts
+function optionsof(step) {
+  try {
+    return parseoptions(step);
+  } catch {
+    return {};
+  }
+}
+function innerstep(step) {
+  const options = optionsof(step);
+  const kind = options.kind;
+  if (typeof kind !== "string" || !kind.trim()) return null;
+  const inneroptions = options.options;
+  return {
+    id: `${step.id}inner`,
+    kind,
+    summary: step.summary,
+    risk: step.risk,
+    ...typeof options.target === "string" ? { target: options.target } : {},
+    ...typeof options.value === "string" ? { value: options.value } : {},
+    ...inneroptions && typeof inneroptions === "object" && !Array.isArray(inneroptions) ? { options: JSON.stringify(inneroptions) } : {}
+  };
+}
+function pointdistance(a, b) {
+  return Math.hypot(b.x - a.x, b.y - a.y);
+}
+function settle(delay) {
+  return new Promise((resolve) => setTimeout(resolve, delay));
+}
+async function runretries(rule, probe, execute) {
+  const attempts = Math.max(1, Number.isFinite(rule.attempts) ? Math.floor(rule.attempts) : 1);
+  const tolerance = typeof rule.tolerance === "number" && Number.isFinite(rule.tolerance) ? rule.tolerance : 0;
+  const settles = typeof rule.settle === "number" && Number.isFinite(rule.settle) ? rule.settle : 0;
+  let previous = await probe();
+  let movement = 0;
+  let made = 0;
+  let last = "";
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    made = attempt;
+    const result = await execute(attempt);
+    last = result.summary;
+    if (result.ok) return { ok: true, attempts: made, movement, summary: `Retry interaction succeeded on attempt ${made} after ${movement.toFixed(1)} pixels of observed movement.` };
+    if (attempt >= attempts) break;
+    if (settles > 0) await settle(settles);
+    const current = await probe();
+    if (!current) {
+      previous = null;
+      continue;
+    }
+    if (previous) {
+      const delta = pointdistance(previous, current);
+      movement = Math.max(movement, delta);
+      if (delta <= tolerance) return { ok: false, attempts: made, movement, summary: `The target stayed within the reviewed tolerance of ${tolerance} pixels; retry stopped after attempt ${made}. ${last}` };
+    }
+    previous = current;
+  }
+  return { ok: false, attempts: made, movement, summary: `Retry interaction failed after ${made} attempt${made === 1 ? "" : "s"} with ${movement.toFixed(1)} pixels of observed movement. ${last}` };
+}
+
+// extension/pagecontrols.ts
+function presshold(holds, hold) {
+  if (holds.some((existing) => existing.holdid === hold.holdid && existing.releasedat === void 0)) return { holds, ok: false };
+  return { holds: [...holds, hold], ok: true };
+}
+function releasehold(holds, holdid, releasedat) {
+  let released;
+  const next = holds.map((hold) => {
+    if (hold.holdid !== holdid || hold.releasedat !== void 0) return hold;
+    released = { ...hold, releasedat };
+    return released;
+  });
+  return { holds: next, ...released ? { released } : {} };
+}
+function heldkeys(holds, tabid2) {
+  return holds.filter((hold) => hold.releasedat === void 0 && (tabid2 === void 0 || hold.tabid === void 0 || hold.tabid === tabid2));
+}
+
 // 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 chromestorage = {
   async get(key) {
     return (await chrome.storage.local.get(key))[key];
@@ -381,6 +878,13 @@ function extensionpage(sender) {
 async function audit(kind, summary, extra = {}) {
   await memory.addaudi({ id: randomid(), kind, at: Date.now(), summary, ...extra });
 }
+function stepoptions2(step) {
+  try {
+    return parseoptions(step);
+  } catch {
+    return {};
+  }
+}
 async function refreshcapabilities() {
   const report = await readcapabilities();
   await memory.setcapabilities(report);
@@ -402,13 +906,82 @@ 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");
+  return step ? parsedialogpolicy(step) : null;
+}
+async function installdialogpolicy(tabid2, policy, persistent) {
+  await chrome.scripting.executeScript({
+    target: { tabId: tabid2 },
+    world: "MAIN",
+    func: installdialoghandler,
+    args: [policy.accept, policy.answer ?? "", persistent]
+  });
+}
+async function ensuredialoghandler(plan, tabid2) {
+  const policy = plandialogpolicy(plan) ?? await memory.getdialogpolicy();
+  if (!policy) return;
+  try {
+    await installdialogpolicy(tabid2, policy, true);
+  } catch {
+  }
+}
+async function harvestdialogs(session, plan, stepid, tabid2) {
+  const policy = plandialogpolicy(plan) ?? await memory.getdialogpolicy();
+  let observed = [];
+  try {
+    const result = await chrome.scripting.executeScript({ target: { tabId: tabid2 }, func: () => {
+      const bridge = globalThis.devthinkbridge;
+      return bridge?.readdialogs ? bridge.readdialogs() : [];
+    } });
+    const value = result[0]?.result;
+    if (Array.isArray(value)) observed = value;
+  } catch {
+  }
+  for (const entry of observed) {
+    const reviewed = policy ? dialoganswer(policy, ["confirm", "alert", "prompt"].includes(entry.dialog) ? entry.dialog : "confirm") : void 0;
+    const decision = {
+      id: randomid(),
+      dialog: entry.dialog,
+      text: entry.text,
+      accept: reviewed ? reviewed.accept : entry.result !== null && entry.result !== false,
+      ...reviewed?.answer !== void 0 ? { answer: reviewed.answer } : {},
+      ...session ? { sessionid: session.id } : {},
+      at: Number.isFinite(entry.at) ? entry.at : Date.now()
+    };
+    await memory.adddialog(decision);
+    await audit("dialog", `Dialog ${decision.dialog} answered ${decision.accept ? "accept" : "dismiss"}${decision.answer ? ` with the reviewed answer "${decision.answer}"` : ""} for dialog text "${decision.text.slice(0, 120)}".`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid });
+  }
+}
+async function dispatchpagestep(step, tabid2, origin, plan) {
+  const session = await memory.getsession();
+  const activeplan = plan ?? await memory.getplan();
+  await ensuredialoghandler(activeplan, tabid2);
+  const result = await chrome.scripting.executeScript({ target: { tabId: tabid2 }, func: (action, expectedorigin) => {
+    const bridge = globalThis.devthinkbridge;
+    if (!bridge) throw new Error("Devthink page bridge is unavailable.");
+    return bridge.performstep(action, expectedorigin);
+  }, args: [step, origin] });
+  await harvestdialogs(session, activeplan, step.id, tabid2);
+  return result[0]?.result;
 }
 async function startsession() {
   const { tab, origin } = await activecontext();
   const session = { id: randomid(), tabid: tab.id, origin, startedat: Date.now(), expiresat: Date.now() + sessionduration, grants: [origin] };
   await memory.setsession(session);
   await audit("session", `Session started for ${origin}.`, { sessionid: session.id });
+  const policy = await memory.getdialogpolicy();
+  if (policy) {
+    try {
+      await installdialogpolicy(session.tabid, policy, true);
+    } catch {
+    }
+  }
   return session;
 }
 async function diagnostic() {
@@ -451,6 +1024,236 @@ function browserauditkind(step) {
   if (step.kind.startsWith("window")) return "window";
   return "tab";
 }
+function stepauditkind(step, ok) {
+  if (isbrowserkind(step.kind)) return browserauditkind(step);
+  if (step.kind === "dismissdialog") return "dialog";
+  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 (observationstepkinds.has(step.kind)) return "observation";
+  return ok ? "action" : "error";
+}
+function resolvedinnerstep(step, plan) {
+  const options = stepoptions2(step);
+  if (typeof options.stepid === "string" && options.stepid.trim()) {
+    return plan.steps.find((candidate) => candidate.id === options.stepid) ?? null;
+  }
+  return innerstep(step);
+}
+async function executekeyhold(step, session, plan, tabid2, origin) {
+  const output = await dispatchpagestep(step, tabid2, origin, plan);
+  if (!output?.ok) return output ?? { ok: false, summary: "The key hold was not delivered." };
+  const options = stepoptions2(step);
+  const holdid = typeof options.holdid === "string" && options.holdid.trim() ? options.holdid : randomid();
+  const modifiers = Array.isArray(options.modifiers) ? options.modifiers.filter((item) => typeof item === "string") : [];
+  const hold = { holdid, key: step.value ?? "", ...modifiers.length > 0 ? { modifiers } : {}, tabid: tabid2, stepid: step.id, pressedat: Date.now() };
+  const next = presshold(await memory.getholds(), hold);
+  if (!next.ok) return { ok: false, summary: `Hold id ${holdid} is already held.` };
+  await memory.setholds(next.holds);
+  await audit("hold", `Key ${hold.key} held under hold id ${holdid} pressed at ${new Date(hold.pressedat).toISOString()}.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  return { ok: true, summary: `Key ${hold.key} held under hold id ${holdid}.`, details: { holdid } };
+}
+async function executekeyrelease(step, session, plan, tabid2, origin) {
+  const holdid = step.value ?? "";
+  const holds = await memory.getholds();
+  const held = holds.find((candidate) => candidate.holdid === holdid && candidate.releasedat === void 0);
+  if (!held) throw new Error(`No held key matches hold id ${holdid}.`);
+  const modifiers = held.modifiers ?? [];
+  const dispatchstep = { ...step, value: held.key, options: JSON.stringify({ ...modifiers.length > 0 ? { modifiers } : {} }) };
+  const output = await dispatchpagestep(dispatchstep, tabid2, origin, plan);
+  const releasedat = Date.now();
+  const transition = releasehold(holds, holdid, releasedat);
+  await memory.setholds(transition.holds);
+  await audit("hold", `Key ${held.key} released from hold id ${holdid} at ${new Date(releasedat).toISOString()} after ${Math.max(0, releasedat - held.pressedat)} milliseconds.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  return { ok: output?.ok ?? false, summary: output?.summary ?? "Key release delivered.", details: { holdid } };
+}
+async function executedismissdialog(step, session, plan, tabid2, origin) {
+  const policy = parsedialogpolicy(step);
+  if (!policy) throw new Error("A reviewed dialog policy is required.");
+  await installdialogpolicy(tabid2, policy, false);
+  await harvestdialogs(session, plan, step.id, tabid2);
+  const answer = policy.answer !== void 0 ? ` with the reviewed answer "${policy.answer}"` : "";
+  return { ok: true, summary: `Dialog handler armed${answer} for the next confirm, alert or prompt.` };
+}
+async function executeretryaction(step, session, plan, tabid2, origin) {
+  const rule = stepoptions2(step).retryrule;
+  const inner = resolvedinnerstep(step, plan);
+  if (!inner) throw new Error("The reviewed wrapper step could not be resolved.");
+  const innergate = validatestep(inner, origin);
+  if (!innergate.allowed) throw new Error(`The wrapped step is not allowed: ${innergate.reason}`);
+  const probe = async () => {
+    const probestep = { id: `${step.id}probe`, kind: "readgeometry", summary: step.summary, risk: "read", ...inner.target ? { target: inner.target } : {}, ...inner.options ? { options: inner.options } : {} };
+    const output = await dispatchpagestep(probestep, tabid2, origin, plan);
+    const geometry = output?.details?.geometry;
+    if (!geometry || typeof geometry.x !== "number" || typeof geometry.y !== "number" || !Number.isFinite(geometry.x) || !Number.isFinite(geometry.y)) return null;
+    return { x: geometry.x, y: geometry.y };
+  };
+  const execute = async () => {
+    const output = await dispatchpagestep(inner, tabid2, origin, plan);
+    return { ok: Boolean(output?.ok), summary: output?.summary ?? "The wrapped step returned no result." };
+  };
+  const outcome = await runretries(rule ?? { attempts: 1 }, probe, execute);
+  const record2 = { stepid: step.id, attempts: outcome.attempts, movement: outcome.movement, ok: outcome.ok, at: Date.now() };
+  await memory.addretry(record2);
+  await audit("retry", outcome.summary, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  return { ok: outcome.ok, summary: outcome.summary, details: { attempts: outcome.attempts, movement: outcome.movement } };
+}
+async function executemapclicks(step, plan, tabid2, origin) {
+  const output = await dispatchpagestep(step, tabid2, origin, plan);
+  if (!output?.ok) return output ?? { ok: false, summary: "The clickable map was not captured." };
+  const entries = Array.isArray(output.details?.entries) ? output.details?.entries : [];
+  const version = await memory.nextobservationversion();
+  const map = { version, entries, builtat: Date.now() };
+  await memory.setmap(map);
+  return { ok: true, summary: output.summary, details: { entries, mapversion: version } };
+}
+async function executeenterframe(step, plan, tabid2, origin) {
+  const inner = resolvedinnerstep(step, plan);
+  if (!inner) throw new Error("The reviewed frame wrapper step could not be resolved.");
+  const innergate = validatestep(inner, origin);
+  if (!innergate.allowed) throw new Error(`The wrapped step is not allowed: ${innergate.reason}`);
+  const options = stepoptions2(step);
+  const inneroptions = inner.options ? stepoptions2(inner) : void 0;
+  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);
+}
 async function executestep(stepid) {
   const session = await memory.getsession();
   const plan = await memory.getplan();
@@ -460,6 +1263,7 @@ async function executestep(stepid) {
   const gate = canexecute({ session, plan, step, tabid: tab.id, origin });
   if (!gate.allowed) throw new Error(gate.reason);
   let output;
+  let watchwindow;
   if (isbrowserkind(step.kind)) {
     const capability = requiredcapability(step.kind);
     if (capability) {
@@ -467,25 +1271,45 @@ async function executestep(stepid) {
       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);
+  } else if (step.kind === "keyrelease") {
+    output = await executekeyrelease(step, session, plan, tab.id, origin);
+  } else if (step.kind === "dismissdialog") {
+    output = await executedismissdialog(step, session, plan, tab.id, origin);
+  } else if (step.kind === "retryaction") {
+    output = await executeretryaction(step, session, plan, tab.id, origin);
+  } else if (step.kind === "mapclicks") {
+    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 (step.target && freshcheckkinds.has(step.kind)) {
       const fresh = await snapshot(tab.id);
       if (!fresh.interactive.some((item) => item.selector === step.target)) throw new Error("The page changed and the target must be reviewed again.");
     }
-    const result = await chrome.scripting.executeScript({ target: { tabId: tab.id }, func: (action, expectedorigin) => {
-      const bridge = globalThis.devthinkbridge;
-      if (!bridge) throw new Error("Devthink page bridge is unavailable.");
-      return bridge.performstep(action, expectedorigin);
-    }, args: [step, origin] });
-    output = result[0]?.result;
+    output = await dispatchpagestep(step, tab.id, origin, plan);
   }
+  await recordevidence(step, output, session, plan, origin);
   const summary = output?.summary ?? "The page action returned no result.";
+  const resolved = output?.details?.resolvedtarget;
+  if (resolved) {
+    await memory.addresolution({ stepid, mode: resolved.mode, selector: resolved.selector, label: resolved.label, at: Date.now() });
+  }
   const outcome = { stepid, ok: Boolean(output?.ok), summary, ...output?.details ? { details: output.details } : {}, at: Date.now() };
-  const auditkind = isbrowserkind(step.kind) ? browserauditkind(step) : output?.ok ? "action" : "error";
+  const auditkind = stepauditkind(step, Boolean(output?.ok));
   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") {
@@ -504,12 +1328,12 @@ async function previewstep(stepid) {
   if (!step) throw new Error("Reviewed step was not found.");
   const gate = canpreview({ session, plan, step, tabid: tab.id, origin });
   if (!gate.allowed) throw new Error(gate.reason);
-  if (!step.target) throw new Error("Only a target-based step can be previewed.");
-  const result = await chrome.scripting.executeScript({ target: { tabId: tab.id }, func: (target, expectedorigin) => {
+  if (!step.target && !stepoptions2(step).targetref) throw new Error("Only a target-based step can be previewed.");
+  const result = await chrome.scripting.executeScript({ target: { tabId: tab.id }, func: (action, expectedorigin) => {
     const bridge = globalThis.devthinkbridge;
     if (!bridge) throw new Error("Devthink page bridge is unavailable.");
-    return bridge.previewtarget(target, expectedorigin);
-  }, args: [step.target, origin] });
+    return bridge.previewtarget(action, expectedorigin);
+  }, args: [step, origin] });
   const output = result[0]?.result;
   const summary = output?.summary ?? "The target preview returned no result.";
   await audit(output?.ok ? "observe" : "error", summary, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid });
@@ -559,7 +1383,14 @@ async function handlerequest(message, sender) {
     case "context": {
       const plan = await memory.getplan();
       const progress = await memory.getprogress();
-      return { config: await memory.getconfig(), session: await memory.getsession(), 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() };
+      const session = await memory.getsession();
+      const holds = heldkeys(await memory.getholds());
+      const observationversion = await memory.getobservationversion();
+      const map = observationversion !== void 0 && observationversion > 0 ? await memory.getmap(observationversion) : void 0;
+      const a11y = (await memory.geta11ytrees())[0];
+      const reader = (await memory.getreaderarticles())[0];
+      const signals = await memory.getsignals();
+      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 } : {} };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -576,6 +1407,8 @@ async function handlerequest(message, sender) {
       if (!plan || plan.state !== "pending") throw new Error("Only a pending plan can be approved.");
       const approved = { ...plan, state: "approved", approvedat: Date.now() };
       await memory.setplan(approved);
+      const policy = plandialogpolicy(approved);
+      if (policy) await memory.setdialogpolicy(policy);
       const current = await memory.getsession();
       await audit("approval", "The user approved the reviewed plan.", { ...current ? { sessionid: current.id } : {}, planid: approved.id });
       return approved;
@@ -593,6 +1426,30 @@ async function handlerequest(message, sender) {
       return previewstep(input.stepid ?? "");
     case "execute":
       return executestep(input.stepid ?? "");
+    case "outcome": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for an outcome envelope.");
+      const outcome = (await memory.getoutcomes()).find((candidate) => candidate.stepid === (input.stepid ?? ""));
+      if (!outcome) throw new Error("No outcome exists for the reviewed step.");
+      const resolved = outcome.details?.resolvedtarget;
+      return JSON.parse(outcomeresponse({ outcome, plan, ...resolved ? { resolvedtarget: resolved } : {} }));
+    }
+    case "map": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for a map envelope.");
+      const version = await memory.getobservationversion();
+      const map = version !== void 0 ? await memory.getmap(version) : void 0;
+      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":
@@ -613,6 +1470,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) => {