@wenathlan/extension 1.1.34 → 1.1.36

package/dist/index.js

@@ -238,19 +238,219 @@ var sessionmemory = class {
   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);
+  }
+  /** Stores one named tab layout with its window bounds and group states, replacing the previous layout of that name. */
+  async setlayout(layout) {
+    const records = (await this.getlayouts()).filter((item) => item.name !== layout.name);
+    await this.adapter.set("layouts", [layout, ...records]);
+  }
+  /** Returns one saved tab layout by name with its timestamp. */
+  async getlayout(name) {
+    return (await this.getlayouts()).find((item) => item.name === name);
+  }
+  /** Returns every saved tab layout with its window bounds and group states. */
+  async getlayouts() {
+    return await this.adapter.get("layouts") ?? [];
+  }
+  /** Stores one tab group definition with its color choice and member tabs, replacing the previous definition of that name. */
+  async settabgroup(group) {
+    const records = (await this.gettabgroups()).filter((item) => item.name !== group.name);
+    await this.adapter.set("tabgroups", [...records, group]);
+  }
+  /** Returns every stored tab group definition with its color choice, newest first. */
+  async gettabgroups() {
+    return await this.adapter.get("tabgroups") ?? [];
+  }
+  /** Records one tabmeta record with task provenance, replacing the previous metadata of that tab. */
+  async settabmeta(meta) {
+    const records = (await this.gettabmetas()).filter((item) => item.tabid !== meta.tabid);
+    await this.adapter.set("tabmetas", [...records, meta]);
+  }
+  /** Returns every stored tabmeta record with task provenance. */
+  async gettabmetas() {
+    return await this.adapter.get("tabmetas") ?? [];
+  }
+  /** Records one session snapshot of tabs and windows for later restore. */
+  async addsnapshot(snapshot) {
+    const records = await this.getsnapshots();
+    await this.adapter.set("snapshots", [snapshot, ...records]);
+  }
+  /** Returns every stored session snapshot, newest first. */
+  async getsnapshots() {
+    return await this.adapter.get("snapshots") ?? [];
+  }
+  /** Records one closed tab in the history kept for restoretab and reopenrun. */
+  async addclosedtab(tab) {
+    const records = await this.getclosedtabs();
+    await this.adapter.set("closedtabs", [tab, ...records]);
+  }
+  /** Returns the closed tab history, newest first. */
+  async getclosedtabs() {
+    return await this.adapter.get("closedtabs") ?? [];
+  }
+  /** Stores one badge state per task, replacing the previous badge of that task. */
+  async setbadge(badge) {
+    const records = (await this.getbadges()).filter((item) => item.taskid !== badge.taskid);
+    await this.adapter.set("badges", [...records, badge]);
+  }
+  /** Returns every stored badge state per task. */
+  async getbadges() {
+    return await this.adapter.get("badges") ?? [];
+  }
+  /** Records one tab event observed inside a reviewed watchtab registration. */
+  async addtabwatchevent(event) {
+    const records = await this.gettabwatchevents();
+    await this.adapter.set("tabwatchevents", [event, ...records]);
+  }
+  /** Returns the tab event stream of every reviewed watchtab registration, newest first. */
+  async gettabwatchevents() {
+    return await this.adapter.get("tabwatchevents") ?? [];
+  }
+  /** Returns the ids of the scratch windows opened for split work. */
+  async getscratchwindows() {
+    return await this.adapter.get("scratchwindows") ?? [];
+  }
+  /** Replaces the scratch window id list after one scratch window opens or closes. */
+  async setscratchwindows(ids) {
+    return this.adapter.set("scratchwindows", ids);
+  }
+  /** Returns the pinned control tab state with the live task feed. */
+  async getcontroltab() {
+    return this.adapter.get("controltab");
+  }
+  /** Replaces the pinned control tab state. */
+  async setcontroltab(state) {
+    return this.adapter.set("controltab", 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", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab"]);
 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 readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta"]);
 var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
-var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus"]);
+var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus", "watchtab"]);
 var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection"]);
-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 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", "duplicatetab", "pintab", "mutetab", "movetab", "movetabwindow", "searchtabs", "badgetab", "attachmeta", "focuswindow", "maximizewindow", "minimizewindow", "restorewindow", "incognitowindow"]);
+var tabscommandactions = /* @__PURE__ */ new Set(["querytabs", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "watchtab", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "savelayout", "restorelayout", "findclones", "searchtabs", "badgetab", "attachmeta", "listaudio", "reopenrun", "snapshotsession"]);
+var layoutmutationactions = /* @__PURE__ */ new Set(["grouptabs", "colorgroup", "collapsegroup", "savelayout", "restorelayout"]);
+var groupcolors = ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"];
 function normalizeendpoint(value) {
   const endpoint = new URL(value.trim());
   if (endpoint.protocol !== "https:") throw new Error("Devthink accepts HTTPS endpoints only.");
@@ -286,6 +486,16 @@ function parseoptions(step) {
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Step options must be a JSON object.");
   return parsed;
 }
+function istabscommandkind(kind) {
+  return tabscommandactions.has(kind);
+}
+function islayoutkind(kind) {
+  return layoutmutationactions.has(kind);
+}
+function layoutmutationgranted(session, now) {
+  if (!session || session.stoppedat || session.expiresat <= now) return { allowed: false, reason: "Group and layout mutations stay inside the active session." };
+  return { allowed: true };
+}
 function waitduration(step) {
   const requested = step.value ? Number.parseInt(step.value, 10) : 250;
   if (!Number.isFinite(requested) || requested < 0) throw new Error("Wait duration must be zero or a positive number of milliseconds.");
@@ -338,6 +548,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;
@@ -361,6 +600,166 @@ 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 validatetabquery(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed tabquery with at least one matcher is required in options." };
+  const query = value;
+  const hasmatcher = query.url !== void 0 || query.title !== void 0 || query.id !== void 0 || query.pattern !== void 0;
+  if (!hasmatcher) return { allowed: false, reason: "The reviewed tabquery needs a url, title, id or pattern matcher." };
+  if (query.url !== void 0 && !isnonempty(query.url)) return { allowed: false, reason: "The reviewed tabquery url matcher must be a non-empty string." };
+  if (query.title !== void 0 && !isnonempty(query.title)) return { allowed: false, reason: "The reviewed tabquery title matcher must be a non-empty string." };
+  if (query.pattern !== void 0 && !isnonempty(query.pattern)) return { allowed: false, reason: "The reviewed tabquery pattern matcher must be a non-empty string." };
+  if (query.id !== void 0 && (typeof query.id !== "number" || !Number.isInteger(query.id) || query.id < 0)) return { allowed: false, reason: "The reviewed tabquery id matcher must be a non-negative integer tab id." };
+  return { allowed: true };
+}
+function validategroupcolor(value) {
+  return typeof value === "string" && groupcolors.includes(value);
+}
+function validateidlist(options, key) {
+  const ids = options[key];
+  return Array.isArray(ids) && ids.length > 0 && ids.every((id) => typeof id === "number" && Number.isInteger(id) && id >= 0);
+}
+function validatetabsgrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "querytabs" || kind === "closepattern") {
+    const querycheck = validatetabquery(options.tabquery);
+    if (!querycheck.allowed) return querycheck;
+    if (kind === "closepattern" && options.reviewed !== true) return { allowed: false, reason: "The close pattern needs the explicit reviewed flag before any tab closes." };
+  }
+  if (kind === "duplicatetab" || kind === "pintab" || kind === "mutetab" || kind === "movetab" || kind === "movetabwindow" || kind === "badgetab" || kind === "attachmeta") {
+    if (!isnumericid(step.value)) return { allowed: false, reason: "A numeric browser tab id is required." };
+  }
+  if (kind === "focuswindow" || kind === "maximizewindow" || kind === "minimizewindow" || kind === "restorewindow") {
+    if (!isnumericid(step.value)) return { allowed: false, reason: "A numeric browser window id is required." };
+  }
+  if (kind === "pintab" && typeof options.pinned !== "boolean") return { allowed: false, reason: "A reviewed pinned flag is required in options." };
+  if (kind === "mutetab" && typeof options.muted !== "boolean") return { allowed: false, reason: "A reviewed muted flag is required in options." };
+  if (kind === "movetab") {
+    if (typeof options.index !== "number" || !Number.isInteger(options.index) || options.index < 0) return { allowed: false, reason: "A reviewed non-negative target index is required in options." };
+  }
+  if (kind === "movetabwindow") {
+    if (typeof options.windowid !== "number" || !Number.isInteger(options.windowid) || options.windowid < 0) return { allowed: false, reason: "A reviewed target window id is required in options." };
+  }
+  if (kind === "grouptabs") {
+    const group = options.group;
+    if (!group || typeof group !== "object" || Array.isArray(group)) return { allowed: false, reason: "A reviewed group with a name is required in options." };
+    const spec = group;
+    if (!isnonempty(spec.name)) return { allowed: false, reason: "The reviewed group needs a non-empty name." };
+    if (!validategroupcolor(spec.color)) return { allowed: false, reason: "The reviewed group color must be a Chromium tab group color." };
+    if (!validateidlist(spec, "tabids")) return { allowed: false, reason: "The reviewed group needs a non-empty list of member tab ids." };
+  }
+  if (kind === "colorgroup") {
+    if (!isnonempty(options.name)) return { allowed: false, reason: "A reviewed group name is required in options." };
+    if (!validategroupcolor(options.color)) return { allowed: false, reason: "The reviewed group color must be a Chromium tab group color." };
+  }
+  if (kind === "collapsegroup") {
+    if (!isnonempty(options.name)) return { allowed: false, reason: "A reviewed group name is required in options." };
+    if (typeof options.collapsed !== "boolean") return { allowed: false, reason: "A reviewed collapsed flag is required in options." };
+  }
+  if (kind === "discardtab" || kind === "reloadtabs") {
+    if (!isnumericid(step.value) && !validateidlist(options, "tabs")) return { allowed: false, reason: "A numeric tab id or a reviewed list of tab ids is required." };
+  }
+  if (kind === "zoomin" || kind === "zoomout") {
+    if (options.step !== void 0 && (typeof options.step !== "number" || !Number.isFinite(options.step) || options.step <= 0)) return { allowed: false, reason: "The reviewed zoom step must be a positive number with no code ceiling." };
+    if (step.value !== void 0 && step.value !== "" && !isnumericid(step.value)) return { allowed: false, reason: "The reviewed zoom target must be a numeric tab id." };
+  }
+  if (kind === "switchtab") {
+    if (options.direction !== "next" && options.direction !== "previous") return { allowed: false, reason: "A reviewed switch direction of next or previous is required in options." };
+  }
+  if (kind === "restorewindow") {
+    const bounds = options.bounds;
+    if (bounds !== void 0) {
+      if (!bounds || typeof bounds !== "object" || Array.isArray(bounds)) return { allowed: false, reason: "The reviewed window bounds must be an object." };
+      const shape = bounds;
+      for (const field of ["left", "top", "width", "height"]) {
+        if (typeof shape[field] !== "number" || !Number.isFinite(shape[field])) return { allowed: false, reason: "The reviewed window bounds need numeric left, top, width and height." };
+      }
+    }
+  }
+  if (kind === "scratchwindow") {
+    if (step.value !== void 0 && step.value !== "" && !ishttpsurl(step.value)) return { allowed: false, reason: "The reviewed scratch window url must use HTTPS." };
+  }
+  if (kind === "incognitowindow" && !ishttpsurl(step.value)) return { allowed: false, reason: "A reviewed HTTPS url is required to open an incognito window." };
+  if (kind === "restoretab" && step.value !== void 0 && step.value !== "" && !ishttpsurl(step.value)) return { allowed: false, reason: "The reviewed restore url must use HTTPS." };
+  if (kind === "savelayout" || kind === "restorelayout") {
+    if (!isnonempty(options.name)) return { allowed: false, reason: "A reviewed layout name is required in options." };
+  }
+  if (kind === "badgetab") {
+    if (!isnonempty(options.label)) return { allowed: false, reason: "A reviewed badge label is required in options." };
+    if (options.taskid !== void 0 && !isnonempty(options.taskid)) return { allowed: false, reason: "The reviewed badge task id must be a non-empty string." };
+  }
+  if (kind === "attachmeta") {
+    const labels = options.labels;
+    const taskrefs = options.taskrefs;
+    const haslabels = Array.isArray(labels) && labels.length > 0 && labels.every((label) => isnonempty(label));
+    const hastaskrefs = Array.isArray(taskrefs) && taskrefs.length > 0 && taskrefs.every((ref) => isnonempty(ref));
+    if (!haslabels && !hastaskrefs) return { allowed: false, reason: "Reviewed labels or task refs are required in options to attach metadata." };
+    if (options.provenance !== void 0 && !isnonempty(options.provenance)) return { allowed: false, reason: "The reviewed provenance must be a non-empty string." };
+  }
+  if (kind === "reopenrun" && !isnonempty(options.run)) return { allowed: false, reason: "A reviewed run id is required in options to reopen its tabs." };
+  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." };
@@ -498,6 +897,84 @@ function validatestep(step, origin) {
     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;
+  }
+  if (istabscommandkind(step.kind)) {
+    const tabscheck = validatetabsgrammar(step, options);
+    if (!tabscheck.allowed) return tabscheck;
+  }
+  if (step.kind === "tabcreate") {
+    if (options.background !== void 0 && typeof options.background !== "boolean") return { allowed: false, reason: "The reviewed background flag must be a boolean." };
+    if (options.window !== void 0 && (typeof options.window !== "number" || !Number.isInteger(options.window) || options.window < 0)) return { allowed: false, reason: "The reviewed target window id must be a non-negative integer." };
+  }
+  if (step.kind === "windowcreate") {
+    for (const field of ["left", "top", "width", "height"]) {
+      if (options[field] !== void 0 && (typeof options[field] !== "number" || !Number.isFinite(options[field]))) return { allowed: false, reason: `The reviewed window ${field} must be a number.` };
+    }
+    if (options.state !== void 0 && !["normal", "maximized", "minimized", "fullscreen"].includes(options.state)) return { allowed: false, reason: "The reviewed window state must be normal, maximized, minimized or fullscreen." };
+  }
   return { allowed: true };
 }
 function sessiongate(input) {
@@ -515,11 +992,42 @@ function canexecute(input) {
   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 (islayoutkind(input.step.kind) && !layoutmutationgranted(input.session, now).allowed) return { allowed: false, reason: "Group and layout mutations stay inside the active session." };
+  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.34";
+var packageversion = "1.1.36";
 
 // types.ts
 var protocolversion = packageversion;
@@ -608,6 +1116,21 @@ function signalsreport(input) {
 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 });
+}
+function tabreportresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, report: input.report });
+}
+function layoutreport(input) {
+  return { version: protocolversion, layouts: input.layouts };
+}
 export {
   canexecute,
   actionrisk as deriveactionrisk,
@@ -616,7 +1139,9 @@ export {
   heldkeysreport,
   hostpattern,
   iswatchkind,
+  layoutreport,
   mapresponse,
+  navstateresponse,
   normalizeendpoint,
   observationmodeof,
   observationresponse,
@@ -626,9 +1151,12 @@ export {
   randomid,
   requestbody,
   resolutionverdict,
+  safetyresponse,
   selectorresponse,
   sessionmemory,
   signalsreport,
+  tabreportresponse,
+  trailreport,
   validatestep,
   validatetargetref
 };