@wenathlan/extension 1.1.31 → 1.1.33

package/README.md

@@ -2,28 +2,32 @@
 
 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.31**. License: **GPL-3.0-only**. The repository is `wenathlan/extension`; the npm-compatible scoped package identifier is `@wenathlan/extension`.
+Version: **1.1.33**. 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.31 |
+| Capability | Behavior in 1.1.33 |
 | --- | --- |
-| Active-tab session | The user starts a short-lived session for one HTTPS tab and one origin. |
-| Page observation | The extension captures a bounded semantic inventory of interactive elements and form labels. |
-| Plan proposal | A local plan can be created immediately; an optional user-configured HTTPS endpoint can return a typed plan proposal. |
+| 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 may observe, inspect, focus, click, type approved text, scroll, select an existing option, hover, extract bounded text or links, wait a bounded pause or navigate within the same approved origin. |
+| 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. |
+| 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. |
 | Session pause | The user can pause and resume the active session; a paused session blocks every execution and preview while keeping the reviewed plan alive. |
-| Plan progress | Each reviewed step is tracked, completed steps are marked in the side panel and the approved plan closes automatically once every step has executed. |
+| Plan progress | Each reviewed step is tracked with its outcome history, completed steps are marked, plans close automatically once every step has executed, and prior history survives plan replacement. |
 | Stop and audit | The user can stop the session at any time. Configuration, proposals, decisions and results remain in local extension storage. |
 
 The project is deliberately **not** a hosted control platform. It does not depend on a provider-specific sandbox, server URL or browser profile. A configured endpoint is optional, has to use HTTPS and receives only the session record and bounded observation required to produce a plan.
 
 ## Security boundary
 
-> Devthink never requests broad host access at installation. The user can grant a single HTTPS origin only after entering it in the extension popup.
+> Devthink never requests broad host access at installation. The user can grant a single HTTPS origin only after entering it in the extension popup, and privileged browser capabilities only as optional permissions requested from the review panel.
 
-The default manifest requests `activeTab`, `storage`, `scripting` and `sidePanel`. It does not request debugger, cookies, history, downloads, proxy control, native messaging, web requests, full-time host permissions or credentials. A service worker cannot be relied on for unattended 24-hour agent computation; any such system must be designed, installed and governed separately. [1] [2]
+The default manifest requests `activeTab`, `storage`, `scripting` and `sidePanel`, plus optional permissions for `tabs`, `downloads`, `clipboardRead` and `clipboardWrite` that stay dormant until the user grants them at runtime. It does not request debugger, cookies, history, proxy control, native messaging, web requests, full-time host permissions or credentials. A service worker cannot be relied on for unattended 24-hour agent computation; any such system must be designed, installed and governed separately. [1] [2]
 
 Browser actions remain blocked if the session is missing, stopped or expired; the tab or origin changed; the plan was not approved; the plan expired; or the tool proposal is not in the local allowlist. The page bridge checks the origin again immediately before it acts.
 
@@ -42,14 +46,15 @@ The endpoint field intentionally has no default URL. Enter a URL such as `https:
 
 ```json
 {
-  "version": "1.1.31",
+  "version": "1.1.33",
   "objective": "User supplied objective",
   "session": { "id": "uuid", "tabid": 1, "origin": "https://example.com" },
-  "observation": { "url": "https://example.com/path", "interactive": [] }
+  "observation": { "schemaversion": 2, "url": "https://example.com/path", "interactive": [] },
+  "capabilities": { "tabs": false, "downloads": false, "clipboardread": false, "clipboardwrite": false }
 }
 ```
 
-It must return a plan proposal using the same version. Every step needs a human-readable summary. Navigation is restricted to the active session origin, and any unknown or malformed proposal is rejected locally. The endpoint is a planner, not an authority to control the browser.
+It must return a plan proposal using the same version. Every step needs a human-readable summary and may carry a reviewed JSON `options` field. Navigation is restricted to the active session origin, and any unknown or malformed proposal is rejected locally. The endpoint is a planner, not an authority to control the browser.
 
 ## Library use
 

package/dist/cli.js

@@ -2,19 +2,40 @@
 
 // cli/devthink.ts
 import { readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
 import { resolve } from "node:path";
-var forbidden = /* @__PURE__ */ new Set(["debugger", "cookies", "webRequest", "history", "bookmarks", "downloads", "nativeMessaging", "proxy", "management"]);
+var forbidden = /* @__PURE__ */ new Set(["debugger", "cookies", "webRequest", "history", "bookmarks", "nativeMessaging", "proxy", "management"]);
+var allowedoptional = /* @__PURE__ */ new Set(["tabs", "downloads", "clipboardRead", "clipboardWrite"]);
+var pinnedidentitykey = "58e21373cec5ade3e6698da5b36ecc2bf7e7e2f755c6fb5e3a6605b535b93985";
+function decodeidentitykey(key) {
+  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(key)) throw new Error("The manifest key must be strict base64 without whitespace.");
+  if (key.length % 4 !== 0) throw new Error(`The manifest key length ${key.length} is not a multiple of four, so it is not valid base64.`);
+  const der = Buffer.from(key, "base64");
+  if (der.length < 150 || der.length > 600) throw new Error(`The manifest key decodes to ${der.length} bytes, outside the RSA subject public key range.`);
+  if (!der.subarray(0, 2).equals(Buffer.from([48, 130]))) throw new Error("The manifest key does not decode to a DER subject public key sequence.");
+  const declared = der.readUInt16BE(2);
+  if (declared !== der.length - 4) throw new Error(`The manifest key DER length ${declared} does not match the decoded ${der.length - 4} bytes.`);
+  return der;
+}
 async function main() {
   const command = process.argv[2] ?? "help";
   if (command === "manifest") {
     const manifest = JSON.parse(await readFile(resolve("extension/manifest.json"), "utf8"));
     const packagejson = JSON.parse(await readFile(resolve("package.json"), "utf8"));
     const permissions = manifest.permissions ?? [];
+    const optional = manifest.optional_permissions ?? [];
     const denied = permissions.filter((permission) => forbidden.has(permission));
+    const deniedoptional = optional.filter((permission) => !allowedoptional.has(permission));
     if (manifest.version !== packagejson.version) throw new Error("Manifest version must match package.json.");
+    if (!manifest.key) throw new Error("A stable manifest key is required for the extension identity.");
+    const identitykey = decodeidentitykey(manifest.key);
+    if (identitykey.length !== 294) throw new Error(`The manifest key decodes to ${identitykey.length} bytes; the published Devthink identity key decodes to 294.`);
+    const digest = createHash("sha256").update(identitykey).digest("hex");
+    if (digest !== pinnedidentitykey) throw new Error(`The manifest identity key digest ${digest} does not match the pinned published key; changing the extension identity must be a reviewed decision.`);
     if ((manifest.host_permissions ?? []).length) throw new Error("Mandatory host permissions are not allowed.");
     if (denied.length) throw new Error(`Forbidden permissions: ${denied.join(", ")}`);
-    console.log(JSON.stringify({ valid: true, version: manifest.version, permissions }, null, 2));
+    if (deniedoptional.length) throw new Error(`Forbidden optional permissions: ${deniedoptional.join(", ")}`);
+    console.log(JSON.stringify({ valid: true, version: manifest.version, identitykeybytes: identitykey.length, permissions, optionalpermissions: optional }, null, 2));
     return;
   }
   console.log("Usage: devthink manifest");

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, normalizeendpoint, 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,iBAAiB,EAAE,iBAAiB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC7J,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -34,12 +34,99 @@ var sessionmemory = class {
   async setprogress(value) {
     return this.adapter.set("progress", value);
   }
+  async getcapabilities() {
+    return this.adapter.get("capabilities");
+  }
+  async setcapabilities(value) {
+    return this.adapter.set("capabilities", value);
+  }
+  async getsettings() {
+    return this.adapter.get("settings");
+  }
+  async setsettings(value) {
+    return this.adapter.set("settings", value);
+  }
   async getaudit() {
     return await this.adapter.get("audit") ?? [];
   }
+  async getoutcomes() {
+    return await this.adapter.get("outcomes") ?? [];
+  }
+  /** Records one audit event; retention is a user setting and an absent setting keeps every event. */
   async addaudi(event) {
     const records = await this.getaudit();
-    await this.adapter.set("audit", [event, ...records].slice(0, 100));
+    const combined = [event, ...records];
+    const retention = (await this.getsettings())?.auditretention;
+    await this.adapter.set("audit", retention === void 0 ? combined : combined.slice(0, retention));
+  }
+  /** Records one step outcome; retention is a user setting and an absent setting keeps every outcome. */
+  async addoutcome(outcome) {
+    const records = await this.getoutcomes();
+    const combined = [outcome, ...records];
+    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);
   }
 };
 function randomid() {
@@ -47,10 +134,12 @@ function randomid() {
 }
 
 // policy.ts
-var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select"]);
-var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover"]);
-var allowedactions = /* @__PURE__ */ new Set(["observe", "inspect", "focus", "click", "type", "navigate", "scroll", "select", "hover", "extract", "wait"]);
-var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover"]);
+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"]);
+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"]);
 function normalizeendpoint(value) {
   const endpoint = new URL(value.trim());
   if (endpoint.protocol !== "https:") throw new Error("Devthink accepts HTTPS endpoints only.");
@@ -67,16 +156,110 @@ function actionrisk(kind) {
   if (sensitiveactions.has(kind)) return "sensitive";
   return interactionactions.has(kind) ? "interaction" : "read";
 }
+function parseoptions(step) {
+  if (step.options === void 0) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(step.options);
+  } catch {
+    throw new Error("Step options must be a JSON object.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Step options must be a JSON object.");
+  return parsed;
+}
 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.");
-  return Math.min(requested, 1e4);
+  return requested;
+}
+function isnumericid(value) {
+  return typeof value === "string" && /^\d+$/.test(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." };
+  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);
@@ -85,13 +268,99 @@ function validatestep(step, origin) {
     }
   }
   if (step.kind === "navigate") {
-    if (!step.value) return { allowed: false, reason: "A navigation URL is required." };
     try {
-      if (new URL(step.value).origin !== origin) return { allowed: false, reason: "Navigation must remain within the approved origin." };
+      if (new URL(step.value ?? "").origin !== origin) return { allowed: false, reason: "Navigation must remain within the approved origin." };
     } catch {
       return { allowed: false, reason: "Navigation URL is invalid." };
     }
   }
+  if (step.kind === "tabcreate" || step.kind === "windowcreate" || step.kind === "downloadfile") {
+    try {
+      const url = new URL(step.value ?? "");
+      if (url.protocol !== "https:") return { allowed: false, reason: "The reviewed URL must use HTTPS." };
+    } catch {
+      return { allowed: false, reason: "The reviewed URL is invalid." };
+    }
+  }
+  if (step.kind === "tabactivate" || step.kind === "tabclose" || step.kind === "tabreload" || step.kind === "windowclose" || step.kind === "windowresize") {
+    if (!isnumericid(step.value)) return { allowed: false, reason: "A numeric browser id is required." };
+  }
+  if (step.kind === "zoomset") {
+    const zoom = Number(step.value);
+    if (!Number.isFinite(zoom) || zoom <= 0) return { allowed: false, reason: "The reviewed zoom must be a positive number." };
+  }
+  if (step.kind === "setattribute" || step.kind === "writestorage") {
+    const keyname = step.kind === "setattribute" ? "name" : "key";
+    if (typeof options[keyname] !== "string" || !options[keyname].trim()) return { allowed: false, reason: `A reviewed ${keyname} is required in options.` };
+    if (typeof options.value !== "string") return { allowed: false, reason: "A reviewed value is required in options." };
+  }
+  if (step.kind === "windowresize") {
+    if (typeof options.width !== "number" || typeof options.height !== "number" || !Number.isFinite(options.width) || !Number.isFinite(options.height)) return { allowed: false, reason: "Reviewed width and height numbers are required in options." };
+  }
+  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." };
+  }
   return { allowed: true };
 }
 function sessiongate(input) {
@@ -107,11 +376,12 @@ 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." };
   return validatestep(input.step, input.origin);
 }
 
 // version.ts
-var packageversion = "1.1.31";
+var packageversion = "1.1.33";
 
 // types.ts
 var protocolversion = packageversion;
@@ -130,7 +400,7 @@ function parseproposal(value, origin) {
   if (root.version !== protocolversion) throw new Error("Unsupported protocol version.");
   const planinput = record(root.plan);
   const stepsinput = planinput.steps;
-  if (!Array.isArray(stepsinput) || stepsinput.length === 0 || stepsinput.length > 50) throw new Error("A plan needs between one and fifty steps.");
+  if (!Array.isArray(stepsinput) || stepsinput.length === 0) throw new Error("A plan needs at least one step.");
   const steps = stepsinput.map((input, index) => {
     const candidate = record(input);
     const kind = text(candidate.kind, `step ${index + 1} kind`);
@@ -140,38 +410,59 @@ function parseproposal(value, origin) {
       summary: text(candidate.summary, `step ${index + 1} summary`),
       risk: actionrisk(kind),
       ...typeof candidate.target === "string" ? { target: candidate.target } : {},
-      ...typeof candidate.value === "string" ? { value: candidate.value } : {}
+      ...typeof candidate.value === "string" ? { value: candidate.value } : {},
+      ...typeof candidate.options === "string" ? { options: candidate.options } : {}
     };
     const evaluation = validatestep(step, 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 = {
     id: typeof planinput.id === "string" ? planinput.id : crypto.randomUUID(),
     objective: text(planinput.objective, "objective"),
     origin,
     steps,
     createdat,
-    expiresat: Math.min(typeof planinput.expiresat === "number" ? planinput.expiresat : createdat + 10 * 60 * 1e3, createdat + 30 * 60 * 1e3),
+    expiresat,
     state: "pending"
   };
   if (plan.expiresat <= createdat) throw new Error("Plan expiry must be in the future.");
   return { version: protocolversion, plan };
 }
 function requestbody(input) {
-  return JSON.stringify({ version: protocolversion, objective: input.objective, session: input.session, observation: input.observation });
+  return JSON.stringify({ version: protocolversion, objective: input.objective, session: input.session, observation: input.observation, capabilities: input.capabilities });
+}
+function outcomeresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {} });
+}
+function mapresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
+}
+function heldkeysreport(input) {
+  return { version: protocolversion, tabid: input.tabid, heldkeys: input.holds };
 }
 export {
   canexecute,
   actionrisk as deriveactionrisk,
+  heldkeysreport,
   hostpattern,
+  mapresponse,
   normalizeendpoint,
+  outcomeresponse,
   parseproposal,
   protocolversion,
   randomid,
   requestbody,
+  resolutionverdict,
   sessionmemory,
-  validatestep
+  validatestep,
+  validatetargetref
 };
 //# sourceMappingURL=index.js.map