@wenathlan/extension 1.1.33 → 1.1.35

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.33**. License: **GPL-3.0-only**. The repository is `wenathlan/extension`; the npm-compatible scoped package identifier is `@wenathlan/extension`.
+Version: **1.1.35**. 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.33 |
+| Capability | Behavior in 1.1.35 |
 | --- | --- |
 | 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 ninety 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. |
+| Browser tools | Reviewed plans cover one hundred forty seven 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. |
+| Navigation mastery | The agent moves anywhere with review: `openlink`, `openprivate`, `reopentab`, `deeplink` and `openclipboard` open reviewed targets in resolved containers, `followlink`, `spanav`, `spawait`, `waitload` and `waiturl` navigate pages and single page app routes, `rewritequery` and `setfragment` edit the current url, `navlist` walks a reviewed url list with per entry progress, `navprofile` applies per site wait profiles, `checksafe` verifies urls before unreviewed origins open, `batchopen` opens curated lists with per url safety states, `navrate` enforces per domain rate limits with user configured windows and ceilings, and the navigation trail, redirect chains and final urls stay recorded for audit. |
+| 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. |
@@ -46,10 +49,10 @@ The endpoint field intentionally has no default URL. Enter a URL such as `https:
 
 ```json
 {
-  "version": "1.1.33",
+  "version": "1.1.35",
   "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, resolutionverdict, validatestep, validatetargetref } 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,iBAAiB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC7J,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

@@ -128,18 +128,243 @@ var sessionmemory = class {
   async setdialogpolicy(policy) {
     return this.adapter.set("dialogpolicy", policy);
   }
+  /** Stores one observation capture under its version so every observation version stays available. */
+  async setobservation(record2) {
+    return this.adapter.set(`observation${record2.version}`, record2);
+  }
+  /** Returns one stored observation version. */
+  async getobservation(version) {
+    return this.adapter.get(`observation${version}`);
+  }
+  /** Returns the observation retention window; an absent setting keeps every capture. */
+  async observationretention() {
+    return (await this.getsettings())?.observationretention;
+  }
+  /** Stores one accessibility tree capture; retention is a user setting and an absent setting keeps every tree. */
+  async adda11ytree(capture) {
+    const records = await this.geta11ytrees();
+    const combined = [capture, ...records];
+    const retention = await this.observationretention();
+    await this.adapter.set("a11ytrees", retention === void 0 ? combined : combined.slice(0, retention));
+  }
+  /** Returns every stored accessibility tree capture, newest first. */
+  async geta11ytrees() {
+    return await this.adapter.get("a11ytrees") ?? [];
+  }
+  /** Stores one reader article capture; retention is a user setting and an absent setting keeps every article. */
+  async addreaderarticle(capture) {
+    const records = await this.getreaderarticles();
+    const combined = [capture, ...records];
+    const retention = await this.observationretention();
+    await this.adapter.set("readerarticles", retention === void 0 ? combined : combined.slice(0, retention));
+  }
+  /** Returns every stored reader article capture, newest first. */
+  async getreaderarticles() {
+    return await this.adapter.get("readerarticles") ?? [];
+  }
+  /** Records one dom mutation observed inside a reviewed watch. */
+  async addmutationevent(event) {
+    const records = await this.getmutationevents();
+    await this.adapter.set("mutationevents", [event, ...records]);
+  }
+  /** Returns the mutation event stream of every reviewed watch. */
+  async getmutationevents() {
+    return await this.adapter.get("mutationevents") ?? [];
+  }
+  /** Records one focus change observed inside a reviewed watch. */
+  async addfocusevent(event) {
+    const records = await this.getfocusevents();
+    await this.adapter.set("focusevents", [event, ...records]);
+  }
+  /** Returns the focus event stream of every reviewed watch. */
+  async getfocusevents() {
+    return await this.adapter.get("focusevents") ?? [];
+  }
+  /** Records one consent banner observed by a reviewed banner watch. */
+  async addbanner(event) {
+    const records = await this.getbanners();
+    await this.adapter.set("banners", [event, ...records]);
+  }
+  /** Returns every consent banner report observed so far. */
+  async getbanners() {
+    return await this.adapter.get("banners") ?? [];
+  }
+  /** Records one snapshot diff between two observation versions. */
+  async adddiff(diff) {
+    const records = await this.getdiffs();
+    await this.adapter.set("diffs", [diff, ...records]);
+  }
+  /** Returns every stored snapshot diff, newest first. */
+  async getdiffs() {
+    return await this.adapter.get("diffs") ?? [];
+  }
+  /** Records one derived selector with its stability score for reuse. */
+  async addselector(selector) {
+    const records = await this.getselectors();
+    await this.adapter.set("selectors", [selector, ...records]);
+  }
+  /** Returns every stored derived selector with its stability score, newest first. */
+  async getselectors() {
+    return await this.adapter.get("selectors") ?? [];
+  }
+  /** Records one detected template class or section fingerprint for its origin. */
+  async addtemplate(profile) {
+    const records = await this.gettemplates();
+    await this.adapter.set("templates", [profile, ...records]);
+  }
+  /** Returns every stored template class and section fingerprint, newest first. */
+  async gettemplates() {
+    return await this.adapter.get("templates") ?? [];
+  }
+  /** Records one watch registration so it survives service worker restarts. */
+  async addwatch(watch) {
+    const records = await this.getwatches();
+    await this.adapter.set("watches", [watch, ...records]);
+  }
+  /** Returns every watch registration, newest first, including closed windows. */
+  async getwatches() {
+    return await this.adapter.get("watches") ?? [];
+  }
+  /** Closes one watch registration by watch id once its reviewed lifetime window ends. */
+  async closewatch(watchid, closedat) {
+    const records = await this.getwatches();
+    await this.adapter.set("watches", records.map((watch) => watch.watchid === watchid && watch.closedat === void 0 ? { ...watch, closedat } : watch));
+  }
+  /** Returns the live page signals of language, template, scroll lock and banner state. */
+  async getsignals() {
+    return this.adapter.get("signals");
+  }
+  /** Replaces the live page signals after an observation step refreshes them. */
+  async setsignals(signals) {
+    return this.adapter.set("signals", signals);
+  }
+  /** Appends one navigation trail entry of a session with its url, title, step ref and timestamp. */
+  async addtrailentry(sessionid, entry) {
+    const records = await this.gettrail(sessionid);
+    await this.adapter.set(`trail${sessionid}`, [...records, entry]);
+  }
+  /** Returns the navigation trail of a session, oldest first. */
+  async gettrail(sessionid) {
+    return await this.adapter.get(`trail${sessionid}`) ?? [];
+  }
+  /** Stores one wait profile for an origin with user configured values, replacing the previous profile of that origin. */
+  async setwaitprofile(record2) {
+    const records = (await this.getwaitprofiles()).filter((item) => item.origin !== record2.origin);
+    await this.adapter.set("waitprofiles", [...records, record2]);
+  }
+  /** Returns every stored wait profile with its origin and user configured values, newest first. */
+  async getwaitprofiles() {
+    return await this.adapter.get("waitprofiles") ?? [];
+  }
+  /** Records one navigation step with its redirect chain and final url. */
+  async addnavrecord(record2) {
+    const records = await this.getnavrecords();
+    await this.adapter.set("navrecords", [record2, ...records]);
+  }
+  /** Returns every stored navigation record with redirect chains and final urls, newest first. */
+  async getnavrecords() {
+    return await this.adapter.get("navrecords") ?? [];
+  }
+  /** Records one navigation intent detected from a plan for audit review. */
+  async addnavintent(record2) {
+    const records = await this.getnavintents();
+    await this.adapter.set("navintents", [record2, ...records]);
+  }
+  /** Returns every stored navigation intent record, newest first. */
+  async getnavintents() {
+    return await this.adapter.get("navintents") ?? [];
+  }
+  /** Replaces the rate limit window state of one domain. */
+  async setratestate(state) {
+    const records = (await this.getratestates()).filter((item) => item.domain !== state.domain);
+    await this.adapter.set("ratestates", [...records, state]);
+  }
+  /** Returns every rate limit window state per domain. */
+  async getratestates() {
+    return await this.adapter.get("ratestates") ?? [];
+  }
+  /** Records one curated link list with its review state before batch opening. */
+  async addcurated(list) {
+    const records = await this.getcurateds();
+    await this.adapter.set("curated", [list, ...records]);
+  }
+  /** Returns every stored curated link list, newest first. */
+  async getcurateds() {
+    return await this.adapter.get("curated") ?? [];
+  }
+  /** Stores reviewed basic auth credentials for one origin, replacing the previous record of that origin. */
+  async setauth(record2) {
+    const records = (await this.getauths()).filter((item) => item.origin !== record2.origin);
+    await this.adapter.set("auths", [...records, record2]);
+  }
+  /** Returns every stored reviewed basic auth record per origin. */
+  async getauths() {
+    return await this.adapter.get("auths") ?? [];
+  }
+  /** Records one task artifact routed into the artifact store. */
+  async addartifact(record2) {
+    const records = await this.getartifacts();
+    await this.adapter.set("artifacts", [record2, ...records]);
+  }
+  /** Returns every stored task artifact, newest first. */
+  async getartifacts() {
+    return await this.adapter.get("artifacts") ?? [];
+  }
+  /** Returns the navigation control state of paused navigation. */
+  async getnavcontrol() {
+    return this.adapter.get("navcontrol");
+  }
+  /** Replaces the navigation control state after a pause or resume transition. */
+  async setnavcontrol(control) {
+    return this.adapter.set("navcontrol", control);
+  }
+  /** Records one url safety verdict produced by a checksafe verification. */
+  async addsafety(verdict) {
+    const records = await this.getsafeties();
+    await this.adapter.set("safeties", [verdict, ...records]);
+  }
+  /** Returns every stored url safety verdict, newest first. */
+  async getsafeties() {
+    return await this.adapter.get("safeties") ?? [];
+  }
+  /** Records one recently closed tab so a reopentab step can restore it. */
+  async addrecenttab(tab) {
+    const records = await this.getrecenttabs();
+    await this.adapter.set("recenttabs", [tab, ...records]);
+  }
+  /** Returns every recently closed tab, newest first. */
+  async getrecenttabs() {
+    return await this.adapter.get("recenttabs") ?? [];
+  }
+  /** Returns the queued prefetch and batch open target counts shown in the popup badge. */
+  async getnavqueues() {
+    return this.adapter.get("navqueues");
+  }
+  /** Replaces the queued prefetch and batch open target counts. */
+  async setnavqueues(queues) {
+    return this.adapter.set("navqueues", queues);
+  }
+  /** Returns the last known navigation state of a tab, kept across service worker restarts. */
+  async getnavstate(tabid) {
+    return this.adapter.get(`navstate${tabid}`);
+  }
+  /** Replaces the last known navigation state of a tab. */
+  async setnavstate(tabid, state) {
+    return this.adapter.set(`navstate${tabid}`, state);
+  }
 };
 function randomid() {
   return crypto.randomUUID();
 }
 
 // policy.ts
-var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor"]);
+var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen"]);
 var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction"]);
-var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath"]);
+var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe"]);
 var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
-var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow"]);
-var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor"]);
+var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus"]);
+var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection"]);
+var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav"]);
 function normalizeendpoint(value) {
   const endpoint = new URL(value.trim());
   if (endpoint.protocol !== "https:") throw new Error("Devthink accepts HTTPS endpoints only.");
@@ -151,6 +376,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";
@@ -219,6 +452,35 @@ function origingranted(session, origin) {
   const grants = session.grants ?? [session.origin];
   return grants.includes(origin);
 }
+function originverified(url, grants, verdicts) {
+  let origin = "";
+  try {
+    origin = new URL(url).origin;
+  } catch {
+    return { allowed: false, reason: "The reviewed navigation URL is invalid." };
+  }
+  if (grants.includes(origin)) return { allowed: true };
+  const covered = verdicts.find((verdict) => verdict.safe && (verdict.url === url || safeorigin(verdict.url) === origin));
+  if (covered) return { allowed: true };
+  return { allowed: false, reason: `The origin ${origin} is outside the session grants and has no safe checksafe verdict; run checksafe and review it first.` };
+}
+function safeorigin(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return "";
+  }
+}
+function navigationgranted(session, url) {
+  let origin = "";
+  try {
+    origin = new URL(url).origin;
+  } catch {
+    return { allowed: false, reason: "The reviewed navigation URL is invalid." };
+  }
+  if (origingranted(session, origin)) return { allowed: true };
+  return { allowed: false, reason: `Navigation to ${origin} leaves the task tab origins and needs the user consent of a session grant first.` };
+}
 function validateinnerstep(options, origin) {
   const stepid = options.stepid;
   const kind = options.kind;
@@ -242,6 +504,68 @@ function validateinnerstep(options, origin) {
   };
   return validatestep(inner, origin);
 }
+function ishttpsurl(value) {
+  if (typeof value !== "string" || !value.trim()) return false;
+  try {
+    return new URL(value).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function validatenavtarget(value, kind) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed navtarget with a url is required in options." };
+  const target = value;
+  if (!ishttpsurl(target.url)) return { allowed: false, reason: "The reviewed navtarget url must use HTTPS." };
+  const container = target.container ?? "tab";
+  if (container !== "current" && container !== "tab" && container !== "window" && container !== "private") return { allowed: false, reason: "The reviewed navtarget container must be current, tab, window or private." };
+  if (target.position !== void 0 && target.position !== "adjacent" && target.position !== "end") return { allowed: false, reason: "The reviewed navtarget position must be adjacent or end." };
+  if (kind === "openprivate" && container !== "private") return { allowed: false, reason: "The openprivate step requires the private container." };
+  if (kind === "openlink" && container === "private") return { allowed: false, reason: "The openlink step cannot open the private container; use openprivate." };
+  return { allowed: true };
+}
+function validatewaitprofile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed waitprofile with load signals is required in options." };
+  const profile = value;
+  if (!Array.isArray(profile.signals) || profile.signals.length === 0 || !profile.signals.every((signal) => isnonempty(signal))) return { allowed: false, reason: "The reviewed waitprofile needs a non-empty list of load signals." };
+  if (!nonnegativeoption(profile, "idle")) return { allowed: false, reason: "The reviewed waitprofile idle threshold must be zero or a positive number of milliseconds." };
+  if (!nonnegativeoption(profile, "timeout")) return { allowed: false, reason: "The reviewed waitprofile timeout must be zero or a positive number of milliseconds." };
+  if (profile.overrides !== void 0) {
+    if (!Array.isArray(profile.overrides) || profile.overrides.length === 0) return { allowed: false, reason: "The reviewed waitprofile overrides must be a non-empty list when present." };
+    for (const entry of profile.overrides) {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) return { allowed: false, reason: "Every reviewed waitprofile override must be an object with an origin." };
+      const override = entry;
+      if (!ishttpsurl(override.origin)) return { allowed: false, reason: "Every reviewed waitprofile override origin must use HTTPS." };
+      if (override.signals !== void 0 && (!Array.isArray(override.signals) || !override.signals.every((signal) => isnonempty(signal)))) return { allowed: false, reason: "The reviewed waitprofile override signals must be a list of non-empty strings." };
+      if (!nonnegativeoption(override, "idle") || !nonnegativeoption(override, "timeout")) return { allowed: false, reason: "The reviewed waitprofile override thresholds must be zero or positive numbers." };
+    }
+  }
+  return { allowed: true };
+}
+function validateurlpattern(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed urlpattern is required in options." };
+  const pattern = value;
+  if (pattern.mode !== "exact" && pattern.mode !== "prefix" && pattern.mode !== "host" && pattern.mode !== "pattern") return { allowed: false, reason: "The reviewed urlpattern mode must be exact, prefix, host or pattern." };
+  if (!ishttpsurl(pattern.url)) return { allowed: false, reason: "The reviewed urlpattern url must use HTTPS." };
+  if (pattern.query !== void 0) {
+    if (!pattern.query || typeof pattern.query !== "object" || Array.isArray(pattern.query)) return { allowed: false, reason: "The reviewed urlpattern query part must be an object of parameter names and values." };
+    for (const item of Object.values(pattern.query)) if (typeof item !== "string") return { allowed: false, reason: "The reviewed urlpattern query values must be strings." };
+  }
+  if (pattern.fragment !== void 0 && !isnonempty(pattern.fragment)) return { allowed: false, reason: "The reviewed urlpattern fragment must be a non-empty string." };
+  return { allowed: true };
+}
+function validateurllist(options, key) {
+  const urls = options[key];
+  if (!Array.isArray(urls) || urls.length === 0 || !urls.every((url) => ishttpsurl(url))) return { allowed: false, reason: `A reviewed non-empty list of HTTPS urls is required in options as ${key}.` };
+  return { allowed: true };
+}
+function validateratelimit(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed ratelimit with a window and a ceiling is required in options." };
+  const limit = value;
+  if (limit.domain !== void 0 && !isnonempty(limit.domain)) return { allowed: false, reason: "The reviewed ratelimit domain must be a non-empty string." };
+  if (typeof limit.window !== "number" || !Number.isFinite(limit.window) || limit.window <= 0) return { allowed: false, reason: "The reviewed ratelimit window must be a positive number of milliseconds with no code ceiling." };
+  if (typeof limit.ceiling !== "number" || !Number.isInteger(limit.ceiling) || limit.ceiling < 1) return { allowed: false, reason: "The reviewed ratelimit ceiling must be a positive integer with no code ceiling." };
+  return { allowed: true };
+}
 function validatestep(step, origin) {
   if (!allowedactions.has(step.kind)) return { allowed: false, reason: "Unsupported action kind." };
   if (!step.summary.trim()) return { allowed: false, reason: "A human-readable action summary is required." };
@@ -361,6 +685,88 @@ function validatestep(step, origin) {
     if (!nonnegativeoption(retry, "settle")) return { allowed: false, reason: "The reviewed retry settle window must be zero or a positive number of milliseconds." };
     if (!nonnegativeoption(retry, "tolerance")) return { allowed: false, reason: "The reviewed retry movement tolerance must be zero or a positive number of pixels." };
   }
+  if (watchactions.has(step.kind)) {
+    if (typeof options.lifetime !== "number" || !Number.isFinite(options.lifetime) || options.lifetime <= 0) return { allowed: false, reason: "A reviewed watch lifetime window in milliseconds is required in options." };
+    if (options.scopes !== void 0 && (!Array.isArray(options.scopes) || !options.scopes.every((scope) => isnonempty(scope)))) return { allowed: false, reason: "The reviewed watch scopes must be a list of non-empty selectors." };
+    if (options.events !== void 0 && (!Array.isArray(options.events) || !options.events.every((event) => isnonempty(event)))) return { allowed: false, reason: "The reviewed watch event kinds must be a list of non-empty strings." };
+    if (!nonnegativeoption(options, "poll")) return { allowed: false, reason: "The reviewed watch poll interval must be zero or a positive number of milliseconds." };
+  }
+  if (step.kind === "waitquiet") {
+    const rule = options.quietrule;
+    if (!rule || typeof rule !== "object" || Array.isArray(rule)) return { allowed: false, reason: "A reviewed quietrule with an idle threshold is required in options." };
+    const quiet = rule;
+    if (typeof quiet.idle !== "number" || !Number.isFinite(quiet.idle) || quiet.idle <= 0) return { allowed: false, reason: "The reviewed quiet idle threshold must be a positive number of milliseconds with no code ceiling." };
+    if (!nonnegativeoption(quiet, "poll")) return { allowed: false, reason: "The reviewed quiet poll interval must be zero or a positive number of milliseconds." };
+    if (!nonnegativeoption(quiet, "timeout")) return { allowed: false, reason: "The reviewed quiet timeout must be zero or a positive number of milliseconds." };
+  }
+  if (step.kind === "diffsnapshots") {
+    const versions = options.versions;
+    if (!Array.isArray(versions) || versions.length !== 2 || !versions.every((version) => typeof version === "number" && Number.isInteger(version) && version >= 1)) return { allowed: false, reason: "Two reviewed observation version numbers are required in options." };
+  }
+  if (step.kind === "openlink" || step.kind === "openprivate" || step.kind === "deeplink") {
+    const targetcheck = validatenavtarget(options.navtarget, step.kind);
+    if (!targetcheck.allowed) return targetcheck;
+    if (step.kind === "deeplink") {
+      const app = options.app;
+      if (!isnonempty(app)) return { allowed: false, reason: "A reviewed deep link app pattern is required in options." };
+      const params = options.params;
+      if (params !== void 0 && (!params || typeof params !== "object" || Array.isArray(params) || !Object.values(params).every((item) => typeof item === "string"))) return { allowed: false, reason: "The reviewed deep link params must be an object of string values." };
+    }
+  }
+  if (step.kind === "waitload" && !nonnegativeoption(options, "timeout")) return { allowed: false, reason: "The waitload timeout must be zero or a positive number of milliseconds." };
+  if (step.kind === "waiturl" || step.kind === "spawait") {
+    if (step.kind === "waiturl") {
+      const patterncheck = validateurlpattern(options.urlpattern);
+      if (!patterncheck.allowed) return patterncheck;
+    }
+    if (!nonnegativeoption(options, "timeout")) return { allowed: false, reason: "The wait timeout must be zero or a positive number of milliseconds." };
+    if (!nonnegativeoption(options, "poll")) return { allowed: false, reason: "The wait poll interval must be zero or a positive number of milliseconds." };
+  }
+  if (step.kind === "followlink") {
+    if (options.fragment !== void 0 && typeof options.fragment !== "boolean") return { allowed: false, reason: "The reviewed followlink fragment flag must be a boolean." };
+  }
+  if (step.kind === "spanav") {
+    if (options.routepattern !== void 0) {
+      const routecheck = validateurlpattern(options.routepattern);
+      if (!routecheck.allowed) return routecheck;
+    }
+    if (!nonnegativeoption(options, "timeout")) return { allowed: false, reason: "The spanav route timeout must be zero or a positive number of milliseconds." };
+  }
+  if (step.kind === "rewritequery") {
+    const set = options.set;
+    const remove = options.remove;
+    if (set === void 0 && remove === void 0) return { allowed: false, reason: "Reviewed query parameters to set or remove are required in options." };
+    if (set !== void 0 && (!set || typeof set !== "object" || Array.isArray(set) || !Object.values(set).every((item) => typeof item === "string"))) return { allowed: false, reason: "The reviewed query parameters to set must be an object of string values." };
+    if (remove !== void 0 && (!Array.isArray(remove) || !remove.every((item) => isnonempty(item)))) return { allowed: false, reason: "The reviewed query parameters to remove must be a list of non-empty names." };
+  }
+  if (step.kind === "navlist") {
+    const listcheck = validateurllist(options, "urls");
+    if (!listcheck.allowed) return listcheck;
+  }
+  if (step.kind === "navprofile") {
+    const profilecheck = validatewaitprofile(options.waitprofile);
+    if (!profilecheck.allowed) return profilecheck;
+  }
+  if (step.kind === "handleauth" && !ishttpsurl(step.value)) return { allowed: false, reason: "A reviewed HTTPS origin or url is required as the auth target." };
+  if (step.kind === "printpdf" && options.name !== void 0 && !isnonempty(options.name)) return { allowed: false, reason: "The reviewed artifact name must be a non-empty string." };
+  if (step.kind === "prefetch") {
+    const listcheck = validateurllist(options, "urls");
+    if (!listcheck.allowed) return listcheck;
+  }
+  if (step.kind === "preconnect") {
+    const origins = options.origins;
+    if (!Array.isArray(origins) || origins.length === 0 || !origins.every((originurl) => ishttpsurl(originurl))) return { allowed: false, reason: "A reviewed non-empty list of HTTPS origins is required in options." };
+  }
+  if (step.kind === "reopentab" && step.value !== void 0 && !ishttpsurl(step.value)) return { allowed: false, reason: "The reviewed reopen url must use HTTPS." };
+  if (step.kind === "navrate") {
+    const limitcheck = validateratelimit(options.ratelimit);
+    if (!limitcheck.allowed) return limitcheck;
+  }
+  if (step.kind === "checksafe" && !ishttpsurl(step.value)) return { allowed: false, reason: "A reviewed HTTPS url is required for the safety check." };
+  if (step.kind === "batchopen") {
+    const listcheck = validateurllist(options, "urls");
+    if (!listcheck.allowed) return listcheck;
+  }
   return { allowed: true };
 }
 function sessiongate(input) {
@@ -377,11 +783,42 @@ function canexecute(input) {
   if (!input.plan || input.plan.state !== "approved") return { allowed: false, reason: "The plan has not received explicit approval." };
   if (input.plan.expiresat <= now) return { allowed: false, reason: "The approved plan has expired." };
   if ((input.step.kind === "pierceshadow" || input.step.kind === "enterframe") && !origingranted(input.session, input.origin)) return { allowed: false, reason: "The shadow or frame step is outside the session origin grants." };
+  if (input.step.kind === "readjson" && !origingranted(input.session, input.origin)) return { allowed: false, reason: "The json state read is outside the session origin grants." };
+  if (input.step.kind === "navlist") {
+    let options = {};
+    try {
+      options = parseoptions(input.step);
+    } catch {
+      options = {};
+    }
+    for (const url of Array.isArray(options.urls) ? options.urls : []) {
+      if (typeof url !== "string") continue;
+      const navigation = navigationgranted(input.session, url);
+      if (!navigation.allowed) return navigation;
+    }
+  }
+  if (input.step.kind === "openlink" || input.step.kind === "openprivate" || input.step.kind === "batchopen" || input.step.kind === "prefetch" || input.step.kind === "deeplink" || input.step.kind === "reopentab") {
+    let options = {};
+    try {
+      options = parseoptions(input.step);
+    } catch {
+      options = {};
+    }
+    const grammar = validatestep(input.step, input.origin);
+    if (!grammar.allowed) return grammar;
+    const grants = input.session?.grants ?? [input.session?.origin ?? input.origin];
+    const targets = input.step.kind === "batchopen" || input.step.kind === "prefetch" ? Array.isArray(options.urls) ? options.urls : [] : input.step.kind === "reopentab" ? [input.step.value] : [options.navtarget?.url];
+    for (const target of targets) {
+      if (typeof target !== "string" || !target) continue;
+      const verified = originverified(target, grants, input.verdicts ?? []);
+      if (!verified.allowed) return verified;
+    }
+  }
   return validatestep(input.step, input.origin);
 }
 
 // version.ts
-var packageversion = "1.1.33";
+var packageversion = "1.1.35";
 
 // types.ts
 var protocolversion = packageversion;
@@ -448,20 +885,61 @@ function mapresponse(input) {
 function heldkeysreport(input) {
   return { version: protocolversion, tabid: input.tabid, heldkeys: input.holds };
 }
+function observationresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, observation: input.observation });
+}
+function 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 });
+}
+function navstateresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, navstate: input.navstate });
+}
+function trailreport(input) {
+  return { version: protocolversion, ...input.sessionid ? { sessionid: input.sessionid } : {}, trail: input.trail };
+}
+function safetyresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, verdicts: input.verdicts });
+}
 export {
   canexecute,
   actionrisk as deriveactionrisk,
+  diffresponse,
+  eventresponse,
   heldkeysreport,
   hostpattern,
+  iswatchkind,
   mapresponse,
+  navstateresponse,
   normalizeendpoint,
+  observationmodeof,
+  observationresponse,
   outcomeresponse,
   parseproposal,
   protocolversion,
   randomid,
   requestbody,
   resolutionverdict,
+  safetyresponse,
+  selectorresponse,
   sessionmemory,
+  signalsreport,
+  trailreport,
   validatestep,
   validatetargetref
 };