@wenathlan/extension 1.1.59 → 1.1.60

package/dist/index.js

@@ -2014,6 +2014,170 @@ function swarmstateof(input) {
   return { agents: input.agents, queue: input.queue, mailboxes: input.mailboxes, killswitch: input.killswitch };
 }
 
+// runstate.ts
+function openrun(input) {
+  if (input.runid.trim() === "" || input.sessionid.trim() === "") throw new Error("The run state needs its run and session ids.");
+  if (!Number.isFinite(input.interval) || input.interval <= 0) throw new Error("The keepalive heartbeat interval stays a positive user value in milliseconds.");
+  return {
+    runid: input.runid,
+    sessionid: input.sessionid,
+    planid: input.planid,
+    profileid: input.profileid,
+    state: "active",
+    urlhistory: [],
+    environments: {},
+    turnarounds: {},
+    keepalive: { runid: input.runid, sessionid: input.sessionid, state: "active", startedat: input.now, interval: input.interval, beats: 0, lastbeatat: input.now, portopen: true, events: [{ kind: "start", at: input.now, detail: `The keepalive port opens for the run ${input.runid} and beats every ${input.interval} milliseconds.` }] },
+    updatedat: input.now
+  };
+}
+function beatrun(state, now) {
+  if (state.keepalive.state !== "active") throw new Error(`The run ${state.runid} is ${state.keepalive.state}; a stopped run emits no heartbeat.`);
+  return {
+    ...state,
+    keepalive: { ...state.keepalive, beats: state.keepalive.beats + 1, lastbeatat: now, events: [...state.keepalive.events, { kind: "heartbeat", at: now }].slice(-200) },
+    updatedat: now
+  };
+}
+function closerun(state, now) {
+  if (state.keepalive.state === "stopped") throw new Error(`The run ${state.runid} already stopped its keepalive port.`);
+  return {
+    ...state,
+    state: "completed",
+    keepalive: { ...state.keepalive, state: "stopped", stoppedat: now, portopen: false, events: [...state.keepalive.events, { kind: "stop", at: now, detail: "The run reached a terminal state and the keepalive port closed." }].slice(-200) },
+    updatedat: now
+  };
+}
+function reattachrun(state, now) {
+  if (state.keepalive.state !== "active") throw new Error(`The run ${state.runid} is ${state.keepalive.state}; a stopped run never reattaches.`);
+  return {
+    ...state,
+    state: "recovered",
+    keepalive: { ...state.keepalive, portopen: true, events: [...state.keepalive.events, { kind: "reattach", at: now, detail: "The service worker restarted and the keepalive port reattached from the persisted run state." }].slice(-200) },
+    updatedat: now
+  };
+}
+function recordurl(state, entry) {
+  if (entry.url.trim() === "") throw new Error("The url history entry needs its url.");
+  const record2 = { url: entry.url, stepid: entry.stepid, at: entry.now };
+  return { ...state, urlhistory: [...state.urlhistory.filter((item) => !(item.url === record2.url && item.stepid === record2.stepid)), record2], updatedat: entry.now };
+}
+function recordenvironment(state, input) {
+  if (input.stepid.trim() === "") throw new Error("The environment record needs its step id.");
+  const provenance = { origin: input.origin, stepid: input.stepid, environment: input.environment };
+  return { ...state, environments: { ...state.environments, [input.stepid]: input.environment }, lastprovenance: provenance, updatedat: input.now };
+}
+function recordturnaround(state, input) {
+  if (input.stepid.trim() === "") throw new Error("The turnaround record needs its step id.");
+  if (!Number.isFinite(input.milliseconds) || input.milliseconds < 0) throw new Error("The worker turnaround stays a non-negative duration in milliseconds.");
+  return { ...state, turnarounds: { ...state.turnarounds, [input.stepid]: input.milliseconds }, updatedat: input.now };
+}
+function markpending(state, stepid, now) {
+  return { ...state, ...stepid !== void 0 && stepid.trim() !== "" ? { pendingstepid: stepid } : {}, updatedat: now };
+}
+function recoveryplan(state) {
+  if (state.state === "completed") return { runid: state.runid, recoverable: false, reason: `The run ${state.runid} completed before the restart; nothing resumes.` };
+  if (state.state === "reaped") return { runid: state.runid, recoverable: false, reason: `The run ${state.runid} was reaped as a zombie; the user starts a fresh reviewed run.` };
+  if (state.pendingstepid === void 0 || state.pendingstepid.trim() === "") return { runid: state.runid, recoverable: false, reason: `The run ${state.runid} carries no pending step; a fresh reviewed run starts over instead of guessing.` };
+  return { runid: state.runid, pendingstepid: state.pendingstepid, recoverable: true, reason: `The executor resumes the pending step ${state.pendingstepid} of the run ${state.runid} from the persisted run state.` };
+}
+function zombiesweep(input) {
+  if (!Number.isFinite(input.interval) || input.interval <= 0) throw new Error("The zombie sweep needs its heartbeat interval as a positive user value.");
+  if (!Number.isInteger(input.missedlimit) || input.missedlimit < 1) throw new Error("The zombie tolerance stays a positive whole number of silent intervals.");
+  const silentfor = input.interval * input.missedlimit;
+  const zombies = input.states.filter((state) => state.keepalive.state === "active" && input.now - state.keepalive.lastbeatat > silentfor);
+  if (zombies.length === 0) return { states: input.states, reaped: [] };
+  const ids = new Set(zombies.map((state) => state.runid));
+  return { states: input.states.map((state) => ids.has(state.runid) ? { ...state, state: "reaped", keepalive: { ...state.keepalive, state: "stopped", portopen: false, ...state.keepalive.stoppedat === void 0 ? { stoppedat: input.now } : {}, events: [...state.keepalive.events, { kind: "stop", at: input.now, detail: "The zombie reaper closed the silent run." }] } } : state), reaped: [...ids] };
+}
+function acquirerunlock(input) {
+  if (input.sessionid.trim() === "" || input.runid.trim() === "") throw new Error("The run lock needs its session and run ids.");
+  const live = input.locks.filter((lock2) => lock2.sessionid === input.sessionid && (lock2.expiresat === void 0 || lock2.expiresat > input.now));
+  const held = live.find((lock2) => lock2.runid !== input.runid);
+  if (held) return { locks: input.locks, acquired: false, reason: `The session ${input.sessionid} already holds the run ${held.runid}; a session never carries two concurrent runs.` };
+  const own = input.locks.find((lock2) => lock2.sessionid === input.sessionid && lock2.runid === input.runid);
+  if (own) return { locks: input.locks, acquired: true, reason: `The run ${input.runid} of the session ${input.sessionid} already holds its lock.` };
+  const lock = { sessionid: input.sessionid, runid: input.runid, holder: input.holder, acquiredat: input.now, ...input.expiresat !== void 0 ? { expiresat: input.expiresat } : {} };
+  return { locks: [...input.locks.filter((entry) => entry.sessionid !== input.sessionid), lock], acquired: true, reason: `The run ${input.runid} locked the session ${input.sessionid} against concurrent runs.` };
+}
+function releaserunlock(input) {
+  const lock = input.locks.find((entry) => entry.sessionid === input.sessionid);
+  if (!lock || lock.runid !== input.runid) return { locks: input.locks, released: false, reason: `The run ${input.runid} holds no lock of the session ${input.sessionid}.` };
+  return { locks: input.locks.filter((entry) => entry.sessionid !== input.sessionid), released: true, reason: `The run ${input.runid} released the run lock of the session ${input.sessionid}.` };
+}
+function expirerunlocks(locks, now) {
+  const expired = locks.filter((lock) => lock.expiresat !== void 0 && now > lock.expiresat);
+  if (expired.length === 0) return { locks, expired: [] };
+  const ids = new Set(expired.map((lock) => lock.sessionid));
+  return { locks: locks.filter((lock) => !ids.has(lock.sessionid)), expired: [...ids] };
+}
+function serializesteps(input) {
+  const shared = /* @__PURE__ */ new Set();
+  const counts = /* @__PURE__ */ new Map();
+  for (const branch of input.branches) for (const step of branch.steps) counts.set(step.tabid, (counts.get(step.tabid) ?? 0) + 1);
+  for (const [tabid, count] of counts) if (count > 1) shared.add(tabid);
+  const order = [];
+  let cursor = 0;
+  for (const branch of input.branches) {
+    for (const step of branch.steps) {
+      if (shared.has(step.tabid)) {
+        order.push({ branchid: branch.branchid, stepid: step.stepid, tabid: step.tabid, order: cursor });
+        cursor += 1;
+      }
+    }
+  }
+  for (const branch of input.branches) {
+    for (const step of branch.steps) {
+      if (!shared.has(step.tabid)) {
+        order.push({ branchid: branch.branchid, stepid: step.stepid, tabid: step.tabid, order: cursor });
+        cursor += 1;
+      }
+    }
+  }
+  return order;
+}
+async function sealrunstate(state) {
+  const payload = JSON.stringify(state);
+  const digest = await sha256(payload);
+  return { payload, algorithm: "sha-256", digest, sealedat: state.updatedat };
+}
+async function openseal(sealed) {
+  const digest = await sha256(sealed.payload);
+  if (digest !== sealed.digest) throw new Error("The sealed run state fails its integrity digest; a tampered run state never reaches the recovery.");
+  const parsed = JSON.parse(sealed.payload);
+  if (typeof parsed.runid !== "string" || typeof parsed.sessionid !== "string") throw new Error("The sealed run state carries no run record.");
+  return parsed;
+}
+async function sha256(value) {
+  const bytes = new TextEncoder().encode(value);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function prunerunstates(input) {
+  if (!Number.isFinite(input.ceiling) || input.ceiling <= 0) return { states: input.states, pruned: [], reason: "No storage ceiling is configured, so the run states stay under the user choice alone." };
+  if (input.used <= input.ceiling) return { states: input.states, pruned: [], reason: `The run state storage sits at ${input.used} of the ${input.ceiling} bytes the user configured; no pressure exists.` };
+  const removable = input.states.filter((state) => state.state === "completed" || state.state === "reaped").sort((one, two) => one.updatedat - two.updatedat);
+  const states = [...input.states];
+  const pruned = [];
+  for (const candidate of removable) {
+    pruned.push(candidate.runid);
+    const index = states.findIndex((state) => state.runid === candidate.runid);
+    if (index >= 0) states.splice(index, 1);
+    if (pruned.length >= Math.max(1, Math.ceil(input.states.length / 2))) break;
+  }
+  return { states, pruned, reason: `The storage pressure at ${input.used} of ${input.ceiling} bytes pruned the ${pruned.length} oldest finished run state${pruned.length === 1 ? "" : "s"} while every active run keeps its state.` };
+}
+function exportrunstate(states, now) {
+  return {
+    runs: states.length,
+    urls: states.reduce((total, state) => total + state.urlhistory.length, 0),
+    environments: states.reduce((total, state) => total + Object.keys(state.environments).length, 0),
+    offloaded: states.reduce((total, state) => total + Object.values(state.turnarounds).length, 0),
+    beats: states.reduce((total, state) => total + state.keepalive.beats, 0),
+    exportedat: now
+  };
+}
+
 // memory.ts
 var sessionmemory = class {
   constructor(adapter) {
@@ -4358,6 +4522,121 @@ var sessionmemory = class {
   async getswarmcosts() {
     return await this.adapter.get("swarmcosts") ?? [];
   }
+  /**
+   * Execution environment persistence of the 1.1.60 family.
+   * The run state store seals every persisted run state with its sha-256 integrity digest through the storage api (the browser offers no at-rest encryption for its storage areas, so the honest derivation is the integrity seal that makes tampering detectable before any recovery uses the record), scopes every run state per profile so parallel profiles never share it, expires stale run state past the user configured window while the keepalive summaries survive, tracks the storage quota usage of the run state and prunes the oldest finished run states under pressure.
+   * The adapter seam keeps every accessor a one line storage delegation so a future worker state backend replaces the adapter only.
+   */
+  /** Returns the environment grant list of the active session; an absent list keeps the documented default posture. */
+  async getenvironmentgrants() {
+    return (await this.getsession())?.environmentgrants;
+  }
+  /** Replaces the environment grant list of the active session so the environment grants join the origin grants in the session record. */
+  async setenvironmentgrants(grants) {
+    const session = await this.getsession();
+    if (!session) throw new Error("The environment grants need an active session to join.");
+    await this.setsession({ ...session, environmentgrants: grants });
+  }
+  /** Seals and stores the run state of one profile: the payload travels beside its sha-256 digest so a tampered record at rest stays detectable before any recovery uses it. */
+  async setrunstate(profileid, state) {
+    const sealed = await sealrunstate(state);
+    const index = await this.adapter.get("runstateindex") ?? [];
+    await this.adapter.set(`runstate:${profileid}`, sealed);
+    if (!index.includes(profileid)) await this.adapter.set("runstateindex", [...index, profileid]);
+  }
+  /** Opens the sealed run state of one profile; a missing or tampered seal returns undefined so the recovery never trusts a broken record. */
+  async getrunstate(profileid) {
+    const sealed = await this.adapter.get(`runstate:${profileid}`);
+    if (!sealed) return void 0;
+    try {
+      return await openseal(sealed);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Removes the run state of one profile from the store and the index: the per profile key takes an empty seal that never opens, so the quota pruning drops the pruned records whole. */
+  async removerunstate(profileid) {
+    const index = await this.adapter.get("runstateindex") ?? [];
+    await this.adapter.set("runstateindex", index.filter((entry) => entry !== profileid));
+    await this.adapter.set(`runstate:${profileid}`, { payload: "", algorithm: "sha-256", digest: "", sealedat: 0 });
+  }
+  /** Lists the stored run state records of every profile, oldest update first. */
+  async listrunstates() {
+    const index = await this.adapter.get("runstateindex") ?? [];
+    const states = [];
+    for (const profileid of index) {
+      const state = await this.getrunstate(profileid);
+      if (state) states.push(state);
+    }
+    return states.sort((one, two) => one.updatedat - two.updatedat);
+  }
+  /** Expires the stale run states past the user configured window: the expired records reduce to their keepalive summaries while an absent window keeps every run state whole. */
+  async expirerunstates(window, now) {
+    if (window === void 0) return await this.listrunstates();
+    const index = await this.adapter.get("runstateindex") ?? [];
+    const kept = [];
+    for (const profileid of index) {
+      const state = await this.getrunstate(profileid);
+      if (!state) continue;
+      if (now - state.updatedat > window && state.keepalive.state === "stopped") {
+        const summary = { runid: state.runid, sessionid: state.sessionid, planid: state.planid, profileid: state.profileid, state: "expired", urlhistory: [], environments: {}, turnarounds: {}, keepalive: state.keepalive, updatedat: now };
+        const sealed = await sealrunstate(summary);
+        await this.adapter.set(`runstate:${profileid}`, sealed);
+      } else {
+        kept.push(state);
+      }
+    }
+    return kept;
+  }
+  /** Records one worker spawn or teardown event with its provenance beside the step outcomes. */
+  async addworkerevent(event) {
+    await this.adapter.set("workerevents", [event, ...await this.adapter.get("workerevents") ?? []].slice(0, 500));
+  }
+  /** Returns the recorded worker spawn and teardown events, newest first. */
+  async getworkerevents() {
+    return await this.adapter.get("workerevents") ?? [];
+  }
+  /** Records one spawned offscreen document with its reasons and justification in the registry. */
+  async addoffscreenentry(entry) {
+    await this.adapter.set("offscreenregistry", [entry, ...await this.adapter.get("offscreenregistry") ?? []]);
+  }
+  /** Replaces one registry entry after its offscreen document closes. */
+  async updateoffscreenentry(entry) {
+    await this.adapter.set("offscreenregistry", (await this.adapter.get("offscreenregistry") ?? []).map((candidate) => candidate.runid === entry.runid ? entry : candidate));
+  }
+  /** Returns the offscreen document registry with the reasons and justification of every spawn. */
+  async getoffscreenentries() {
+    return await this.adapter.get("offscreenregistry") ?? [];
+  }
+  /** Records one sandbox render with its provenance, source origin and nonce. */
+  async addsandboxrender(render) {
+    await this.adapter.set("sandboxrenders", [render, ...await this.adapter.get("sandboxrenders") ?? []].slice(0, 500));
+  }
+  /** Returns the recorded sandbox renders with their provenance, newest first. */
+  async getsandboxrenders() {
+    return await this.adapter.get("sandboxrenders") ?? [];
+  }
+  /** Replaces the stored run locks after one acquisition, release or expiry sweep. */
+  async setrunlocks(locks) {
+    return this.adapter.set("runlocks", locks);
+  }
+  /** Returns the held run locks with their sessions, runs and expiries. */
+  async getrunlocks() {
+    return await this.adapter.get("runlocks") ?? [];
+  }
+  /** Tracks the storage quota usage of the run state: the last measured bytes stay beside the user configured ceiling so the pruning reads both. */
+  async trackrunstatequota(used) {
+    const settings = await this.getsettings();
+    await this.adapter.set("runstatequota", { used, ...settings?.runstatebytes !== void 0 ? { ceiling: settings.runstatebytes } : {}, trackedat: Date.now() });
+  }
+  /** Returns the last tracked storage quota usage of the run state with its ceiling when the user configured one. */
+  async getrunstatequota() {
+    return this.adapter.get("runstatequota");
+  }
+  /** Exports every stored run state as one single audit record through the runstate export envelope. */
+  async exportrunstates() {
+    return exportrunstate(await this.listrunstates(), Date.now());
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -5147,6 +5426,133 @@ function replayagentrun(input) {
   return interleavetimeline(input.events.filter((event) => event.agentid === input.agentid).map((event) => ({ id: event.id, kind: event.kind, summary: event.summary, at: event.at, ...event.agentid !== void 0 ? { agentid: event.agentid } : {} })));
 }
 
+// environments.ts
+var offloadfamilies = [
+  { task: "htmlsnapshot", kinds: ["readhtml", "parsehtml", "readertree", "readoutline", "classifypage"] },
+  { task: "jsonpayload", kinds: ["readjson", "parsejson"] },
+  { task: "tablerows", kinds: ["readtable", "scrapetable", "detecttables", "deduperows", "transformvalues"] },
+  { task: "a11ytree", kinds: ["a11ytree"] },
+  { task: "complexselector", kinds: ["resolvexpath", "deriveselector", "detectvirtual"] },
+  { task: "stitchshots", kinds: ["contactsheet", "timelapse", "makethumbs"] }
+];
+function offfamilyof(kind) {
+  return offloadfamilies.find((family) => family.kinds.includes(kind))?.task;
+}
+function environmentsof(step) {
+  if (markuprenderstep(step)) return ["sandboxframe"];
+  if (step.kind === "evaluate") return ["isolatedworld"];
+  if (offfamilyof(step.kind) !== void 0) return ["pagecontext", "offscreenworker"];
+  return ["pagecontext"];
+}
+function defaultenvironment(step) {
+  if (markuprenderstep(step)) return "sandboxframe";
+  if (step.kind === "evaluate") return "isolatedworld";
+  return "pagecontext";
+}
+function offamilyeligible(kind) {
+  return offloadfamilies.some((family) => family.kinds.includes(kind));
+}
+function offloadkinds() {
+  return offloadfamilies.map((family) => ({ task: family.task, kinds: [...family.kinds] }));
+}
+function markuprenderstep(step) {
+  if (!step.options) return false;
+  try {
+    const parsed = JSON.parse(step.options);
+    return Boolean(parsed && typeof parsed === "object" && !Array.isArray(parsed) && typeof parsed.markup === "string" && parsed.markup.trim() !== "");
+  } catch {
+    return false;
+  }
+}
+function environmentrequirementsof(kinds) {
+  return kinds.map((kind) => {
+    const bare = { kind };
+    const environments = environmentsof(bare);
+    return { kind, environments, defaultenvironment: defaultenvironment(bare) };
+  });
+}
+function executorregistry() {
+  return [
+    { environment: "pagecontext", adapter: "pagebridge", description: "The page bridge executes dom actions inside the live page because page events only fire there." },
+    { environment: "isolatedworld", adapter: "scriptingapi", description: "The scripting api injects step logic inside the isolated world where page globals stay unreachable from step code." },
+    { environment: "offscreenworker", adapter: "offscreendocument", description: "The offscreen document hosts the worker pool that parses heavy payloads away from the page; the capability gate keeps it behind the optional offscreen grant with an inline fallback." },
+    { environment: "sandboxframe", adapter: "sandboxpage", description: "The sandboxed page renders untrusted markup with scripts and handlers stripped before render and posts its result back through a per render nonce." }
+  ];
+}
+function routeenvironment(step, input) {
+  const allowed = environmentsof(step);
+  const named = step.environment;
+  if (named !== void 0) {
+    if (!allowed.includes(named)) return { environment: defaultenvironment(step), fallback: false, reason: `The ${named} environment sits outside the ${allowed.join(", ")} the ${step.kind} kind permits, so the executor routes to the ${defaultenvironment(step)} default.` };
+    return { environment: named, fallback: false, reason: `The reviewed step names its ${named} environment and the ${step.kind} kind permits it.` };
+  }
+  if (markuprenderstep(step)) return { environment: "sandboxframe", fallback: false, reason: `The ${step.kind} step carries untrusted markup, so it renders inside the sandboxframe only.` };
+  if (step.kind === "evaluate") return { environment: "isolatedworld", fallback: false, reason: "The evaluate kind runs inside the isolated world where page globals stay unreachable from step code." };
+  if (offamilyeligible(step.kind)) {
+    if (!input.offload) return { environment: "pagecontext", fallback: false, reason: `The ${step.kind} step stays inside the page because the user keeps the parse offload off.` };
+    if (!input.granted) return { environment: "pagecontext", fallback: true, reason: `The ${step.kind} step falls back to inline parsing inside the page because the offscreen capability grant stays absent.` };
+    return { environment: "offscreenworker", fallback: false, reason: `The ${step.kind} step offloads into the offscreen worker pool under the granted capability.` };
+  }
+  return { environment: "pagecontext", fallback: false, reason: `The ${step.kind} step keeps the pagecontext because page events only fire inside the live page.` };
+}
+function workerrequestof(input) {
+  const task = offfamilyof(input.kind);
+  if (task === void 0) throw new Error(`The ${input.kind} kind stays outside the offscreen worker pool families.`);
+  if (input.payload.trim() === "") throw new Error("The worker request needs its payload reference.");
+  return { id: input.id, runid: input.runid, stepid: input.stepid, task, payload: input.payload, transferables: transferablekeys(input.options ?? {}), sentat: input.sentat };
+}
+function transferablekeys(options) {
+  return Object.keys(options).filter((key) => options[key] instanceof ArrayBuffer);
+}
+function workerresponseof(input) {
+  if (input.summary.trim() === "") throw new Error("The worker answer needs its summary in plain language.");
+  return { id: input.id, requestid: input.requestid, ok: input.ok, ...input.result !== void 0 ? { result: input.result } : {}, ...input.partial !== void 0 ? { partial: input.partial } : {}, summary: input.summary, receivedat: input.receivedat };
+}
+function acceptworkerresponse(response) {
+  if (!response.ok) return { done: true, partial: false, reason: `The worker refused the request ${response.requestid}: ${response.summary}` };
+  if (response.partial !== void 0) return { done: false, partial: true, reason: `The partial ${response.partial} of the request ${response.requestid} streams back to the executor.` };
+  return { done: true, partial: false, ...response.result !== void 0 ? { result: response.result } : {}, reason: `The request ${response.requestid} completed inside the offscreen worker pool.` };
+}
+function poolplan(input) {
+  if (input.size !== void 0) {
+    if (!Number.isFinite(input.size) || input.size < 1 || !Number.isInteger(input.size)) return { workers: input.current, added: 0, retired: 0, reason: "The configured pool size stays a positive whole number the user chose; the pool keeps its current workers." };
+    const target = input.size;
+    if (target > input.current) return { workers: target, added: target - input.current, retired: 0, reason: `The user configured pool size ${target} adds ${target - input.current} worker${target - input.current === 1 ? "" : "s"} to the pool.` };
+    if (target < input.current) return { workers: target, added: 0, retired: input.current - target, reason: `The user configured pool size ${target} retires ${input.current - target} worker${input.current - target === 1 ? "" : "s"} from the pool.` };
+    return { workers: target, added: 0, retired: 0, reason: `The pool holds the ${target} workers the user configured.` };
+  }
+  if (input.pending > input.current) return { workers: input.pending, added: input.pending - input.current, retired: 0, reason: `The ${input.pending} pending parses grow the pool by ${input.pending - input.current} worker${input.pending - input.current === 1 ? "" : "s"}; no engine cap exists.` };
+  if (input.current > input.pending) return { workers: input.pending, added: 0, retired: input.current - input.pending, reason: `The ${input.current - input.pending} idle worker${input.current - input.pending === 1 ? "" : "s"} retire down to the ${input.pending} pending parse${input.pending === 1 ? "" : "s"}.` };
+  return { workers: input.current, added: 0, retired: 0, reason: `The ${input.current} workers match the ${input.pending} pending parses; the pool stays unchanged.` };
+}
+function openoffscreen(input) {
+  if (input.document.trim() === "") throw new Error("The offscreen document needs its user configured path.");
+  if (input.reasons.length === 0) throw new Error("The offscreen document needs the reasons the user reviewed.");
+  if (input.justification.trim() === "") throw new Error("The offscreen document needs its justification in plain language.");
+  const open = input.registry.find((entry2) => entry2.runid === input.runid && entry2.closedat === void 0);
+  if (open) return { registry: input.registry, entry: open, reused: true };
+  const entry = { document: input.document, runid: input.runid, reasons: [...input.reasons], justification: input.justification, createdat: input.now };
+  return { registry: [entry, ...input.registry], entry, reused: false };
+}
+function closeoffscreen(registry, runid, now) {
+  const open = registry.find((entry) => entry.runid === runid && entry.closedat === void 0);
+  if (!open) return { registry, closed: false };
+  return { registry: registry.map((entry) => entry === open ? { ...entry, closedat: now } : entry), closed: true };
+}
+function isolatedinjection(step) {
+  if (step.kind !== "evaluate") throw new Error("The isolated world injection serves the evaluate kind only.");
+  if (!step.value || step.value.trim() === "") throw new Error("The evaluate step needs its reviewed expression.");
+  let args = [];
+  if (step.options) {
+    try {
+      const parsed = JSON.parse(step.options);
+      if (Array.isArray(parsed)) args = parsed.filter((item) => typeof item === "string");
+    } catch {
+    }
+  }
+  return { world: "ISOLATED", code: step.value, args };
+}
+
 // httpclient.ts
 var httpkinds = ["fetchurl", "parsejson", "parsehtml", "callrest", "callgraphql"];
 var redirectstatuses = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
@@ -9769,6 +10175,48 @@ function blackboardconsentgrade(entry) {
   if (entry.consentclass === "sensitive") return { allowed: true, reason: `The blackboard entry ${entry.key} inherits the sensitive class of its source extraction; every agent reads the class beside the value.` };
   return { allowed: true, reason: `The blackboard entry ${entry.key} inherits the ${entry.consentclass} class of its source extraction; every agent reads the class beside the value.` };
 }
+function stepenvironmentvalid(step) {
+  if (step.environment !== void 0 && step.environment !== "pagecontext" && step.environment !== "isolatedworld" && step.environment !== "offscreenworker" && step.environment !== "sandboxframe") return { allowed: false, reason: "The step environment stays one of pagecontext, isolatedworld, offscreenworker and sandboxframe." };
+  const allowed = environmentsof(step);
+  if (step.environment !== void 0 && !allowed.includes(step.environment)) return { allowed: false, reason: `The ${step.environment} environment sits outside the ${allowed.join(", ")} the ${step.kind} kind permits; the review sees the environment of every step.` };
+  return { allowed: true, reason: step.environment === void 0 ? `The ${step.kind} step carries no environment field and routes to its ${defaultenvironment(step)} default.` : `The ${step.environment} environment of the ${step.kind} step sits inside the ${allowed.join(", ")} the kind permits.` };
+}
+function environmentgrantgate(step, grants) {
+  if (grants === void 0 || grants.length === 0) return { allowed: true, reason: `The session carries no environment grant list, so the ${defaultenvironment(step)} default of the ${step.kind} step stays the documented posture behind the same review.` };
+  const environment = step.environment ?? defaultenvironment(step);
+  if (!grants.includes(environment)) return { allowed: false, reason: `The ${environment} environment sits outside the ${grants.join(", ")} the session granted; no step ever widens the environment grants.` };
+  return { allowed: true, reason: `The ${environment} environment of the ${step.kind} step sits inside the ${grants.join(", ")} the session granted.` };
+}
+function offscreencapabilitygate(input) {
+  if (input.environment !== "offscreenworker") return { allowed: true, reason: `The ${input.environment} environment needs no offscreen capability grant.` };
+  if (!input.granted) return { allowed: false, reason: "The offscreen worker pool runs only under the user granted offscreen capability; the step falls back to inline parsing inside the page." };
+  return { allowed: true, reason: "The offscreen worker pool runs under the user granted offscreen capability." };
+}
+function keepalivegate(input) {
+  if (!input.session) return { allowed: false, reason: "The keepalive port opens only inside an active session." };
+  if (input.session.stoppedat !== void 0) return { allowed: false, reason: "The keepalive port stays closed for a stopped session." };
+  if (input.session.pausedat !== void 0) return { allowed: false, reason: "The keepalive port stays closed while the session pauses; a resumed run reattaches it." };
+  if (input.now > input.session.expiresat) return { allowed: false, reason: "The keepalive port stays closed for an expired session." };
+  if (!input.plan || input.plan.state !== "approved") return { allowed: false, reason: "The keepalive port opens only behind an active reviewed plan; unreviewed work never holds the service worker alive." };
+  return { allowed: true, reason: `The approved plan ${input.plan.id} of the active session holds the keepalive port open for its whole run.` };
+}
+function keepaliveintervalvalid(interval) {
+  if (!Number.isFinite(interval) || interval <= 0) return { allowed: false, reason: "The keepalive heartbeat interval stays a positive user value in milliseconds." };
+  return { allowed: true, reason: `The keepalive heartbeat interval ${interval} milliseconds stays the user configured value; the roadmap documents thirty seconds while the choice stays the user's.` };
+}
+function workerpoolsizevalid(size) {
+  if (size === void 0) return { allowed: true, reason: "No worker pool size is configured, so the pool follows the pending parse queue alone with no engine cap." };
+  if (!Number.isInteger(size) || size < 1) return { allowed: false, reason: "The worker pool size stays a positive whole number the user configured; no engine cap exists." };
+  return { allowed: true, reason: `The worker pool size ${size} stays the user configured value; no engine cap exists.` };
+}
+function sandboxorigingate(input) {
+  if (input.origin.trim() === "") return { allowed: false, reason: "The sandbox render needs the source origin of its untrusted markup." };
+  if (input.allowed.length > 0 && !input.allowed.includes(input.origin)) return { allowed: false, reason: `The origin ${input.origin} sits outside the origins the user allows to render untrusted markup: ${input.allowed.join(", ")}.` };
+  return { allowed: true, reason: input.allowed.length === 0 ? `The origin ${input.origin} renders untrusted markup under the documented open origin list the user chose not to narrow.` : `The origin ${input.origin} sits inside the origins the user allows to render untrusted markup.` };
+}
+function environmentrequirements() {
+  return environmentrequirementsof([...allowedactions]);
+}
 
 // llm.ts
 var defaultrefusalmarkers = ["i cannot", "i can't", "i'm unable", "refusal:", "cannot comply"];
@@ -10129,7 +10577,7 @@ function budgetcheck(input) {
 }
 
 // version.ts
-var packageversion = "1.1.59";
+var packageversion = "1.1.60";
 
 // types.ts
 var protocolversion = packageversion;
@@ -10980,6 +11428,44 @@ function removetemplate(templates, name) {
   return templates.filter((template) => template.name !== name);
 }
 
+// sandboxframe.ts
+function stripscripts(markup) {
+  return markup.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<script\b[^>]*\/>/gi, "").replace(/\son[a-z]+\s*=\s*"[^"]*"/gi, "").replace(/\son[a-z]+\s*=\s*'[^']*'/gi, "").replace(/\son[a-z]+\s*=\s*[^\s>]+/gi, "").replace(/javascript:/gi, "").trim();
+}
+function nonceof(seed) {
+  const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let hash = 0;
+  for (let index = 0; index < seed.length; index += 1) hash = hash * 31 + seed.charCodeAt(index) >>> 0;
+  let nonce = "";
+  let state = hash === 0 ? 2654435769 : hash;
+  for (let index = 0; index < 16; index += 1) {
+    state = state * 1664525 + 1013904223 >>> 0;
+    nonce += alphabet[state % alphabet.length];
+  }
+  return nonce;
+}
+function sandboxrenderof(input) {
+  if (input.markup.trim() === "") throw new Error("The sandbox render needs its untrusted markup.");
+  if (input.sourceorigin.trim() === "") throw new Error("The sandbox render needs the source origin of its untrusted markup.");
+  if (input.stepid.trim() === "") throw new Error("The sandbox render names the reviewed step it renders for.");
+  return { id: input.id, nonce: nonceof(`${input.id}:${input.now}`), markup: stripscripts(input.markup), sourceorigin: input.sourceorigin, stepid: input.stepid, renderedat: input.now };
+}
+function rendermessage(render) {
+  return { channel: "devthinksandbox", type: "render", nonce: render.nonce, markup: render.markup };
+}
+function acceptrenderresult(input) {
+  if (input.message.channel !== "devthinksandbox") return { accepted: false, reason: "The sandbox message travels the devthinksandbox channel only." };
+  if (input.message.type !== "renderresult") return { accepted: false, reason: "The sandbox message answers with the renderresult type only." };
+  const render = input.renders.find((entry) => entry.nonce === input.message.nonce && entry.renderedat <= input.now);
+  if (!render) return { accepted: false, reason: "The sandbox message carries no nonce of a known render; a stale or replayed message never passes." };
+  const text2 = (input.message.text ?? "").replace(/<[^>]*>/g, "");
+  const result = { nonce: render.nonce, ok: input.message.ok !== false, text: text2, summary: input.message.summary?.trim() || `The sandbox frame rendered the markup of the step ${render.stepid} and returned its inert text.`, at: input.now };
+  return { accepted: true, result, reason: `The render result of the step ${render.stepid} answers the nonce of its render; the text stays inside the frame.` };
+}
+function renderprovenance(render) {
+  return { origin: render.sourceorigin, stepid: render.stepid, environment: "sandboxframe" };
+}
+
 // taskqueue.ts
 function emptyqueue(input = {}) {
   return { lanes: input.lanes ?? [], priorities: input.priorities ?? [], completionpolicy: input.completionpolicy ?? "all", items: [], claims: [] };
@@ -11852,6 +12338,28 @@ function reviewframe(input) {
     }
   };
 }
+function environmentgrammar() {
+  return {
+    version: protocolversion,
+    kinds: environmentrequirements(),
+    notes: [
+      "The evaluate kind runs inside the isolated world only where page globals stay unreachable from step code.",
+      "A step whose reviewed options carry untrusted markup renders inside the sandboxframe only, with scripts and event handlers stripped before the render.",
+      "The parse heavy read kinds offload into the offscreen worker pool only under the user granted offscreen capability and the parse offload toggle, with an inline fallback inside the page.",
+      "Every environment executes only reviewed steps against granted origins; the session environment grant list narrows the steps of one session and no environment ever bypasses the human review."
+    ]
+  };
+}
+function environmentreport(input) {
+  return {
+    version: protocolversion,
+    environments: Object.entries(input.environments).map(([stepid, environment]) => ({ stepid, environment })),
+    turnarounds: Object.entries(input.turnarounds ?? {}).map(([stepid, milliseconds]) => ({ stepid, milliseconds })),
+    offscreen: input.offscreen ?? [],
+    workers: input.workers ?? 0,
+    ...input.keepalive !== void 0 ? { keepalive: input.keepalive } : {}
+  };
+}
 
 // workfloweditor.ts
 var palettecategories = ["actions", "controlflow", "waits", "variables", "triggers"];
@@ -12557,8 +13065,11 @@ function yamlscalarvalue(text2) {
   return text2;
 }
 export {
+  acceptrenderresult,
+  acceptworkerresponse,
   ackreview,
   acquirelock,
+  acquirerunlock,
   activelayers,
   addedge,
   addnode,
@@ -12607,6 +13118,7 @@ export {
   autointervalof,
   backoffdelay,
   batchreport,
+  beatrun,
   bindlocalhost,
   bindparam,
   bindvariables,
@@ -12683,6 +13195,8 @@ export {
   classifyintent,
   closechannel,
   closeidlechannels,
+  closeoffscreen,
+  closerun,
   collectmessages,
   collectresults,
   commandguard,
@@ -12724,6 +13238,7 @@ export {
   dedupeimages,
   defaultapprovalwindowms,
   defaultchallengelifetimems,
+  defaultenvironment,
   defaultheartbeatms,
   defaulthttpstream,
   defaultidlewindowms,
@@ -12769,6 +13284,12 @@ export {
   enqueue,
   enqueuerequest,
   entryfresh,
+  environmentgrammar,
+  environmentgrantgate,
+  environmentreport,
+  environmentrequirements,
+  environmentrequirementsof,
+  environmentsof,
   errorcapture,
   errorreportresponse,
   escalate,
@@ -12778,16 +13299,19 @@ export {
   eventresponse,
   eventrulematches,
   exchangesreport,
+  executorregistry,
   expandblocks,
   expandtemplate,
   expireapprovals,
   expirelayers,
   expirelocks,
   expireprofilerecords,
+  expirerunlocks,
   expiresessions,
   expiretokens,
   exportcontentreview,
   exportpresetlibrary,
+  exportrunstate,
   exportsessionfile,
   exportworkflow,
   expressioneval,
@@ -12856,6 +13380,7 @@ export {
   isformkind,
   islocalorigin,
   isnetwatchkind,
+  isolatedinjection,
   isprofilekind,
   issessionkind,
   issocketkind,
@@ -12868,6 +13393,8 @@ export {
   isworkflowkind,
   joinbranches,
   jsonpathrulesof,
+  keepalivegate,
+  keepaliveintervalvalid,
   killall,
   killswitchgate,
   lanereport,
@@ -12899,7 +13426,9 @@ export {
   mapresponse,
   mapurlof,
   markbreakpoint,
+  markpending,
   markprovider,
+  markuprenderstep,
   matchmessage,
   matchurl,
   matchurlpattern,
@@ -12938,13 +13467,20 @@ export {
   newsessionrecord,
   newworkflowrun,
   nextrequest,
+  nonceof,
   normalizeendpoint,
   oauthflowof,
   observationmodeof,
   observationresponse,
   observeevents,
+  offfamilyof,
+  offloadkinds,
+  offscreencapabilitygate,
   openchannel,
   openconsensus,
+  openoffscreen,
+  openrun,
+  openseal,
   openstreamchannel,
   opentabagent,
   outcomeresponse,
@@ -12994,6 +13530,7 @@ export {
   pollcursorof,
   polldecision,
   pollurl,
+  poolplan,
   popscope,
   postentry,
   preparehandoff,
@@ -13011,6 +13548,7 @@ export {
   providervalid,
   proxygate,
   proxyrouteof,
+  prunerunstates,
   publishmessage,
   pushscope,
   quarantinereport,
@@ -13026,12 +13564,17 @@ export {
   readentries,
   readpath,
   readstream,
+  reattachrun,
   receivemessage,
   receivemessages,
   reconnectwaits,
   recordagentusage,
+  recordenvironment,
   recordingoptionsof,
+  recordturnaround,
+  recordurl,
   recordwatchvalue,
+  recoveryplan,
   redactconsoletext,
   redactedcookies,
   redactparams,
@@ -13046,10 +13589,13 @@ export {
   rejectioncapture,
   relayframe,
   releaselock,
+  releaserunlock,
   removeedge,
   removenode,
   removetemplate,
+  rendermessage,
   renderminimap,
+  renderprovenance,
   rendertemplate,
   rendertoolbriefs,
   reordersteps,
@@ -13098,6 +13644,7 @@ export {
   roledefaults,
   rotatelogs,
   rotationruleof,
+  routeenvironment,
   routesfor,
   routevalid,
   rpcerrorcodeof,
@@ -13122,6 +13669,8 @@ export {
   runworkflow,
   safetyresponse,
   samplingframes,
+  sandboxorigingate,
+  sandboxrenderof,
   savetemplate,
   saveworkflow,
   scaledrect,
@@ -13131,6 +13680,7 @@ export {
   scheduleinterval,
   scopecheck,
   scopegate,
+  sealrunstate,
   seamweights,
   searchfields,
   searchqueryof,
@@ -13146,6 +13696,7 @@ export {
   serializearg,
   serializecdpcommand,
   serializeframe,
+  serializesteps,
   serverbindgate,
   servercapabilities,
   serverenablementgate,
@@ -13182,6 +13733,7 @@ export {
   starttls,
   statusclassof,
   steal,
+  stepenvironmentvalid,
   stepmodeof,
   steptemplateof,
   stepwindows,
@@ -13192,6 +13744,7 @@ export {
   streamsummaries,
   streamwindowof,
   stripguardrails,
+  stripscripts,
   structurederrorreport,
   submitreviewgranted,
   subscriptionframes,
@@ -13246,6 +13799,7 @@ export {
   tracestart,
   tracetofile,
   trailreport,
+  transferablekeys,
   transferhandoff,
   transformgrammar,
   triggereventcatalog,
@@ -13292,6 +13846,9 @@ export {
   whileof,
   wireformat,
   wizardreport,
+  workerpoolsizevalid,
+  workerrequestof,
+  workerresponseof,
   workflowblockof,
   workflowfileversion,
   workflowgate,
@@ -13300,6 +13857,7 @@ export {
   workflowreport,
   workflowstepof,
   workstealgrade,
+  zombiesweep,
   zoomcanvas
 };
 //# sourceMappingURL=index.js.map