@wenathlan/extension 1.1.32 → 1.1.34

package/README.md

@@ -2,17 +2,20 @@
 
 Devthink is a **consent-first browser-agent bridge** distributed as a TypeScript library and a Chromium Manifest V3 extension. It turns a user-provided browser objective into a bounded, reviewable plan. The user must start the active-tab session and approve the plan before any page action reaches the browser.
 
-Version: **1.1.32**. License: **GPL-3.0-only**. The repository is `wenathlan/extension`; the npm-compatible scoped package identifier is `@wenathlan/extension`.
+Version: **1.1.34**. License: **GPL-3.0-only**. The repository is `wenathlan/extension`; the npm-compatible scoped package identifier is `@wenathlan/extension`.
 
 ## What it does
 
-| Capability | Behavior in 1.1.32 |
+| Capability | Behavior in 1.1.34 |
 | --- | --- |
 | Active-tab session | The user starts a short-lived session for one HTTPS tab and one origin; the session records its origin grants. |
 | Page observation | The extension captures the complete semantic inventory: every interactive element, every form control, every select option and the full page text. |
 | Plan proposal | A local plan can be created immediately; an optional user-configured HTTPS endpoint can return a typed plan proposal of any length. |
 | Review gate | Every remote proposal starts in `pending`; it cannot reach the page bridge before explicit approval. |
-| Browser tools | Reviewed plans cover sixty three action kinds: pointer, keyboard, drag and drop, upload, form control, page movement, a complete read vocabulary, page mutation under review, reviewed evaluation, and browser-level tab, window, zoom, snapshot and download commands. |
+| Browser tools | Reviewed plans cover one hundred eighteen action kinds: pointer paths and coordinate clicks, text, aria, name, xpath, index and point target resolution, timed typing, key holds, sliders, dates, colors, shadow dom piercing, iframe entry, dialog answering, retry rules, a complete read vocabulary with clickable maps and verification reads, page mutation under review, and browser-level tab, window, zoom, snapshot and download commands. |
+| Observation depth | The agent sees the whole page read only: the accessibility tree beside the dom snapshot, reader views, visible text, outlines, selections, open graph and embedded json state, plus detected lists, tables, pagination, infinite scroll, virtualization, lazy images, sticky overlays and scroll locks offered as plan suggestions. |
+| Watch vocabulary | `watchmutate`, `watchfocus` and `watchbanner` observe the page across a reviewed lifetime window with batched event records, `waitquiet` waits for network quiet under a reviewed threshold, `diffsnapshots` diffs two stored observation versions into added, removed and changed rows, and `deriveselector` ranks stable selector candidates with stability scores; registrations persist across service worker restarts. |
+| Target resolution | Steps address elements through reviewed `targetref` modes: css selector, visible text, aria role and name, accessible name, xpath, clickable map index or viewport point; ambiguous matches are refused with candidate lists and every resolution returns a matched element summary for review. |
 | Optional capabilities | `tabs`, `downloads`, `clipboardRead` and `clipboardWrite` are optional permissions; browser kinds check their capability, the review panel can request a grant and every grant is audited. |
 | Unlimited by choice | Wait durations, plan size, plan expiry, audit retention and outcome retention carry no code ceilings; every bound is a user choice. |
 | Structured results | Step results carry structured JSON details, rendered in the side panel beside each reviewed step. |
@@ -45,10 +48,10 @@ The endpoint field intentionally has no default URL. Enter a URL such as `https:
 
 ```json
 {
-  "version": "1.1.32",
+  "version": "1.1.34",
   "objective": "User supplied objective",
   "session": { "id": "uuid", "tabid": 1, "origin": "https://example.com" },
-  "observation": { "schemaversion": 2, "url": "https://example.com/path", "interactive": [] },
+  "observation": { "schemaversion": 3, "url": "https://example.com/path", "interactive": [] },
   "capabilities": { "tabs": false, "downloads": false, "clipboardread": false, "clipboardwrite": false }
 }
 ```

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./memory.js";
-export { actionrisk as deriveactionrisk, canexecute, hostpattern, normalizeendpoint, validatestep } from "./policy.js";
+export { actionrisk as deriveactionrisk, canexecute, hostpattern, iswatchkind, normalizeendpoint, observationmodeof, resolutionverdict, validatestep, validatetargetref } from "./policy.js";
 export * from "./protocol.js";
 export * from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,UAAU,IAAI,gBAAgB,EAAE,UAAU,EAAE,WAAW,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACvH,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,UAAU,IAAI,gBAAgB,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC7L,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/dist/index.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.");
@@ -89,6 +262,14 @@ function hostpattern(origin) {
   if (parsed.protocol !== "https:") throw new Error("Only HTTPS origins can be granted.");
   return `${parsed.origin}/*`;
 }
+function iswatchkind(kind) {
+  return watchactions.has(kind);
+}
+function observationmodeof(kind) {
+  if (watchactions.has(kind) || kind === "waitquiet") return "watching";
+  if (kind === "diffsnapshots") return "diffing";
+  return "passive";
+}
 function actionrisk(kind) {
   if (!allowedactions.has(kind)) throw new Error("Unsupported browser action.");
   if (sensitiveactions.has(kind)) return "sensitive";
@@ -116,19 +297,88 @@ 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 resolutionverdict(count) {
+  if (!Number.isFinite(count) || count <= 0) return "absent";
+  return count === 1 ? "resolved" : "ambiguous";
+}
+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);
@@ -168,6 +418,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) {
@@ -183,11 +513,13 @@ 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);
 }
 
 // version.ts
-var packageversion = "1.1.32";
+var packageversion = "1.1.34";
 
 // types.ts
 var protocolversion = packageversion;
@@ -223,6 +555,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 = {
@@ -241,19 +578,58 @@ 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 });
+  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 eventresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, events: input.events });
+}
+function diffresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, diff: input.diff });
+}
+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 selectorresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, candidates: input.candidates });
 }
 export {
   canexecute,
   actionrisk as deriveactionrisk,
+  diffresponse,
+  eventresponse,
+  heldkeysreport,
   hostpattern,
+  iswatchkind,
+  mapresponse,
   normalizeendpoint,
+  observationmodeof,
+  observationresponse,
   outcomeresponse,
   parseproposal,
   protocolversion,
   randomid,
   requestbody,
+  resolutionverdict,
+  selectorresponse,
   sessionmemory,
-  validatestep
+  signalsreport,
+  validatestep,
+  validatetargetref
 };
 //# sourceMappingURL=index.js.map