@wenathlan/extension 1.1.59 → 1.1.60

package/extension/dist/background.js

@@ -1914,6 +1914,170 @@ function swarmoverview(input) {
   };
 }
 
+// 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 [tabid2, count] of counts) if (count > 1) shared.add(tabid2);
+  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) {
@@ -4258,6 +4422,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(window2, now) {
+    if (window2 === 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 > window2 && 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";
@@ -4301,6 +4580,121 @@ function randomid() {
   return crypto.randomUUID();
 }
 
+// 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 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 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 };
+}
+
 // toolcatalog.ts
 var toolcatalogversion = 1;
 var toolnamespaces = ["browser", "workflow", "memory", "system"];
@@ -9127,6 +9521,48 @@ function mergeegressgrade(input) {
   if (input.carriespagecontent) return { allowed: true, reason: `The export of the report ${input.report.title} carries page content from the sources ${input.report.sources.join(", ")} and grades as a data egress event in the audit trail.` };
   return { allowed: true, reason: `The export of the report ${input.report.title} carries no page content and stays a plain report export.` };
 }
+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]);
+}
 
 // progress.ts
 function emptyprogress(planid, now) {
@@ -9141,6 +9577,14 @@ function recordoutcome(progress, planid, outcome, now) {
   const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
   return { ...base, outcomes: [...base.outcomes ?? [], outcome], updatedat: now };
 }
+function recordenvironment2(progress, planid, stepid, environment, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  return { ...base, environments: { ...base.environments ?? {}, [stepid]: environment }, updatedat: now };
+}
+function recordturnaround2(progress, planid, stepid, milliseconds, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  return { ...base, turnarounds: { ...base.turnarounds ?? {}, [stepid]: milliseconds }, updatedat: now };
+}
 function iscomplete(progress, plan) {
   if (!progress || progress.planid !== plan.id) return false;
   const required = plan.steps.map((step) => step.id);
@@ -9306,7 +9750,7 @@ function recordtoolcall(progress, planid, stepid, entry, now) {
 }
 
 // version.ts
-var packageversion = "1.1.59";
+var packageversion = "1.1.60";
 
 // types.ts
 var protocolversion = packageversion;
@@ -10270,6 +10714,16 @@ function runhistoryquery(value) {
 function runhistoryreport(input) {
   return { version: protocolversion, entries: input.entries, query: input.query ?? {} };
 }
+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 } : {}
+  };
+}
 
 // capture.ts
 var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
@@ -12211,6 +12665,41 @@ function unreadcount(mailboxes, agentid) {
   return mailboxof(mailboxes, agentid).unread;
 }
 
+// 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.` };
+}
+
 // modelroute.ts
 function routevalid(route) {
   if (route.kind.trim() === "") return { allowed: false, reason: "The model route needs its task kind." };
@@ -13516,6 +14005,260 @@ async function dispatchpagestep(step, tabid2, origin, plan) {
   await harvestdialogs(session, activeplan, step.id, tabid2);
   return result[0]?.result;
 }
+var roadmapheartbeat = 3e4;
+var roadmapzombieintervals = 3;
+var runstateprofile = "default";
+var keepaliveport;
+var workerpoolcounts = /* @__PURE__ */ new Map();
+async function offscreengranted() {
+  try {
+    return await chrome.permissions.contains({ permissions: ["offscreen"] });
+  } catch {
+    return false;
+  }
+}
+async function offscreendeclaration() {
+  try {
+    const response = await fetch(chrome.runtime.getURL("manifest.json"));
+    const manifest = await response.json();
+    if (!manifest.offscreen?.document || !manifest.offscreen.reasons?.length || !manifest.offscreen.justification?.trim()) return void 0;
+    return { document: manifest.offscreen.document, reasons: manifest.offscreen.reasons, justification: manifest.offscreen.justification };
+  } catch {
+    return void 0;
+  }
+}
+async function requestoffscreengrant() {
+  try {
+    return await chrome.permissions.request({ permissions: ["offscreen"] });
+  } catch {
+    return false;
+  }
+}
+async function ensureoffscreendocument(runid) {
+  const offscreen = chrome.offscreen;
+  if (!offscreen) return false;
+  const declaration = await offscreendeclaration();
+  if (!declaration) return false;
+  const opened = openoffscreen({ registry: await memory.getoffscreenentries(), document: declaration.document, runid, reasons: declaration.reasons, justification: declaration.justification, now: Date.now() });
+  if (!opened.reused) {
+    await memory.addoffscreenentry(opened.entry);
+    await audit("worker", `The offscreen document ${declaration.document} spawned for the run ${runid} under the reasons ${declaration.reasons.join(", ")} with the reviewed justification.`, {});
+  }
+  try {
+    if (!await offscreen.hasDocument()) await offscreen.createDocument({ url: chrome.runtime.getURL(declaration.document), reasons: declaration.reasons, justification: declaration.justification });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function closeoffscreendocument(runid) {
+  const offscreen = chrome.offscreen;
+  const outcome = closeoffscreen(await memory.getoffscreenentries(), runid, Date.now());
+  if (!outcome.closed) return;
+  const entry = outcome.registry.find((candidate) => candidate.runid === runid && candidate.closedat !== void 0);
+  if (entry) await memory.updateoffscreenentry(entry);
+  try {
+    if (offscreen && await offscreen.hasDocument()) await offscreen.closeDocument();
+  } catch {
+  }
+  await audit("worker", `The offscreen document of the run ${runid} closed with its worker pool; the registry keeps the reasons and justification of the spawn for the audit.`, {});
+}
+function startkeepaliveport(runid) {
+  if (keepaliveport) return;
+  try {
+    keepaliveport = chrome.runtime.connect({ name: `devthinkkeepalive:${runid}` });
+    keepaliveport.onDisconnect.addListener(() => {
+      keepaliveport = void 0;
+    });
+  } catch {
+  }
+}
+async function openplanrun(session, plan) {
+  const settings = await memory.getsettings();
+  const interval = settings?.keepaliveinterval ?? roadmapheartbeat;
+  const gate = keepalivegate({ session, plan, now: Date.now() });
+  if (!gate.allowed) return;
+  const existing = await memory.getrunstate(runstateprofile);
+  if (existing && existing.keepalive.state === "active") return;
+  const state = openrun({ runid: plan.id, sessionid: session.id, planid: plan.id, profileid: runstateprofile, interval, now: Date.now() });
+  await memory.setrunstate(runstateprofile, state);
+  const lock = acquirerunlock({ locks: await memory.getrunlocks(), sessionid: session.id, runid: plan.id, holder: "planrun", now: Date.now() });
+  if (lock.acquired) await memory.setrunlocks(lock.locks);
+  startkeepaliveport(plan.id);
+  await audit("environment", `The run state of the plan ${plan.id} opened with its keepalive port beating every ${interval} milliseconds${lock.acquired ? " and the session locked against concurrent runs" : ""}.`, { sessionid: session.id, planid: plan.id });
+}
+async function markpendingstep(plan, stepid) {
+  const state = await memory.getrunstate(runstateprofile);
+  if (!state || state.runid !== plan.id || state.keepalive.state !== "active") return;
+  await memory.setrunstate(runstateprofile, markpending(state, stepid, Date.now()));
+}
+async function recordstepenvironment(step, environment, session, plan, origin, turnaround) {
+  if (session && plan) {
+    await memory.setprogress(recordenvironment2(await memory.getprogress(), plan.id, step.id, environment, Date.now()));
+    const state = await memory.getrunstate(runstateprofile);
+    if (state && state.runid === plan.id) {
+      let next = recordenvironment(state, { stepid: step.id, environment, origin, now: Date.now() });
+      if (turnaround !== void 0) next = recordturnaround(next, { stepid: step.id, milliseconds: turnaround, now: Date.now() });
+      if (["navigate", "openlink", "followlink", "back", "forward"].includes(step.kind) && step.value) next = recordurl(next, { url: step.value, stepid: step.id, now: Date.now() });
+      await memory.setrunstate(runstateprofile, next);
+    }
+  }
+  if (plan && turnaround !== void 0) await memory.setprogress(recordturnaround2(await memory.getprogress(), plan.id, step.id, turnaround, Date.now()));
+}
+async function closeplanrun(planid, sessionid) {
+  const state = await memory.getrunstate(runstateprofile);
+  if (!state || state.runid !== planid || state.keepalive.state !== "active") return;
+  await memory.setrunstate(runstateprofile, closerun(state, Date.now()));
+  const release = releaserunlock({ locks: await memory.getrunlocks(), sessionid, runid: planid, now: Date.now() });
+  if (release.released) await memory.setrunlocks(release.locks);
+  try {
+    keepaliveport?.disconnect();
+  } catch {
+  }
+  keepaliveport = void 0;
+  await closeoffscreendocument(planid);
+  await audit("environment", `The run state of the plan ${planid} closed at its terminal state and the keepalive port released.`, { ...sessionid !== "" ? { sessionid } : {}, planid });
+}
+async function executeisolatedevaluate(step, tabid2, origin) {
+  const injection = isolatedinjection(step);
+  const result = await chrome.scripting.executeScript({ target: { tabId: tabid2 }, world: "ISOLATED", func: (code, args, expectedorigin) => {
+    if (location.origin !== expectedorigin) return { ok: false, summary: "Page origin changed before the evaluate step ran." };
+    try {
+      let outcome;
+      try {
+        outcome = new Function(`"use strict"; return (${code});`)(...args);
+      } catch {
+        outcome = new Function(`"use strict"; ${code}`)(...args);
+      }
+      return { ok: true, summary: `Reviewed expression returned ${outcome === void 0 ? "no value" : "a value"} inside the isolated world.`, details: { result: String(outcome) } };
+    } catch (error) {
+      return { ok: false, summary: `Reviewed expression failed inside the isolated world: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }, args: [injection.code, injection.args, origin] });
+  return result[0]?.result ?? { ok: false, summary: "The isolated world returned no result." };
+}
+async function executesandboxrender(step, session, plan, origin) {
+  const options = stepoptions2(step);
+  const markup = typeof options.markup === "string" ? options.markup : "";
+  const sourceorigin = typeof options.sourceorigin === "string" ? options.sourceorigin : origin;
+  const settings = await memory.getsettings();
+  const origingate = sandboxorigingate({ origin: sourceorigin, allowed: settings?.sandboxorigins ?? [] });
+  if (!origingate.allowed) throw new Error(origingate.reason);
+  const render = sandboxrenderof({ id: randomid(), markup, sourceorigin, stepid: step.id, now: Date.now() });
+  await memory.addsandboxrender(render);
+  const hostready = await ensureoffscreendocument(plan?.id ?? step.id);
+  let answer;
+  if (hostready) {
+    try {
+      answer = await chrome.runtime.sendMessage({ kind: "offscreen", action: "sandboxrender", render: { id: render.id, nonce: render.nonce, markup: render.markup, sourceorigin: render.sourceorigin, stepid: render.stepid } });
+    } catch {
+    }
+  }
+  if (!answer) {
+    try {
+      answer = await chrome.runtime.sendMessage({ kind: "environments", action: "sandboxhost", render: rendermessage(render) });
+    } catch {
+    }
+  }
+  if (!answer) throw new Error("The sandbox frame needs an open host surface: grant the offscreen capability or keep the review panel open so the sandboxed page can render the untrusted markup.");
+  const accepted = acceptrenderresult({ renders: [render], message: { channel: "devthinksandbox", type: "renderresult", nonce: render.nonce, ok: answer.ok, ...answer.text !== void 0 ? { text: answer.text } : {}, summary: answer.summary }, now: Date.now() });
+  if (!accepted.accepted || !accepted.result) throw new Error(accepted.reason);
+  await audit("sandbox", `The step ${step.id} rendered untrusted markup from ${sourceorigin} inside the sandbox frame under the nonce ${render.nonce}; scripts and handlers were stripped before the render and the text never reentered the dom outside the frame.`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
+  await recordstepenvironment(step, "sandboxframe", session, plan, sourceorigin, void 0);
+  return { ok: accepted.result.ok, summary: accepted.result.summary, details: { text: accepted.result.text, nonce: render.nonce, sourceorigin } };
+}
+async function offloadparsetoworker(step, output, session, plan, origin) {
+  const runid = plan?.id ?? step.id;
+  const ready = await ensureoffscreendocument(runid);
+  if (!ready) return { output, turnaround: void 0 };
+  const payload = JSON.stringify({ summary: output?.summary ?? "", details: output?.details ?? {} });
+  const request = workerrequestof({ id: randomid(), runid, stepid: step.id, kind: step.kind, payload, options: stepoptions2(step), sentat: Date.now() });
+  const started = Date.now();
+  let answer;
+  try {
+    answer = await chrome.runtime.sendMessage({ kind: "offscreen", action: "parse", request: { id: request.id, runid: request.runid, stepid: request.stepid, task: request.task, payload: request.payload, transferables: request.transferables } });
+  } catch {
+  }
+  const turnaround = Date.now() - started;
+  if (!answer) return { output, turnaround: void 0 };
+  const provenance = { origin, stepid: step.id, environment: "offscreenworker" };
+  await memory.addworkerevent({ id: randomid(), runid, kind: "spawn", workers: workerpoolcounts.get(runid) ?? 1, reason: `The ${request.task} parse of the step ${step.id} ran inside the offscreen worker pool with the transferable keys ${request.transferables.length > 0 ? request.transferables.join(", ") : "none"}.`, provenance, at: Date.now() });
+  await audit("worker", `The ${request.task} parse of the step ${step.id} ran inside the offscreen worker pool and answered in ${turnaround} milliseconds${answer.ok === false ? " with a refusal the inline parse covers" : ""}.`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
+  const parsed = { ok: answer.ok !== false && (output?.ok ?? true), summary: answer.summary ?? output?.summary ?? "The offscreen worker answered the parse.", details: { ...output?.details ?? {}, workerparse: answer.result ?? "", task: request.task, turnaround } };
+  return { output: parsed, turnaround };
+}
+async function environmentviewof() {
+  const session = await memory.getsession();
+  const settings = await memory.getsettings();
+  const states = await memory.listrunstates();
+  const swept = zombiesweep({ states, now: Date.now(), interval: settings?.keepaliveinterval ?? roadmapheartbeat, missedlimit: settings?.zombieintervals ?? roadmapzombieintervals });
+  const open = states.find((state) => state.keepalive.state === "active") ?? states[0];
+  const workers = (await chrome.runtime.sendMessage({ kind: "offscreen", action: "pool" }).catch(() => void 0))?.workers ?? 0;
+  return {
+    report: environmentreport({ environments: open?.environments ?? {}, turnarounds: open?.turnarounds ?? {}, offscreen: await memory.getoffscreenentries(), workers, ...open !== void 0 ? { keepalive: { runid: open.keepalive.runid, state: open.keepalive.state, beats: open.keepalive.beats, lastbeatat: open.keepalive.lastbeatat, portopen: open.keepalive.portopen } } : {} }),
+    ...session?.environmentgrants !== void 0 ? { grants: session.environmentgrants } : {},
+    requirements: environmentrequirements(),
+    registry: executorregistry(),
+    offscreengranted: await offscreengranted(),
+    parseoffload: settings?.parseoffload === true,
+    ...settings?.workerpoolsize !== void 0 ? { workerpoolsize: settings.workerpoolsize } : {},
+    ...settings?.sandboxorigins !== void 0 ? { sandboxorigins: settings.sandboxorigins } : {},
+    workerevents: (await memory.getworkerevents()).map((event) => ({ id: event.id, runid: event.runid, kind: event.kind, workers: event.workers, reason: event.reason, at: event.at })),
+    runstates: states.map((state) => ({ runid: state.runid, sessionid: state.sessionid, state: state.state, beats: state.keepalive.beats, lastbeatat: state.keepalive.lastbeatat, ...state.pendingstepid !== void 0 ? { pendingstepid: state.pendingstepid } : {}, urls: state.urlhistory.length })),
+    locks: await memory.getrunlocks(),
+    zombies: swept.reaped,
+    urls: (open?.urlhistory ?? []).slice(-50),
+    ...open !== void 0 ? { recovery: recoveryplan(open) } : {},
+    ...open !== void 0 && open.state === "recovered" ? { restartnotice: `The service worker restarted and the run ${open.runid} reattached from its persisted run state; the pending step ${open.pendingstepid ?? "none"} waits for the user.` } : {}
+  };
+}
+async function keepalivetick() {
+  const settings = await memory.getsettings();
+  const interval = settings?.keepaliveinterval ?? roadmapheartbeat;
+  const tolerance = settings?.zombieintervals ?? roadmapzombieintervals;
+  for (const state of await memory.listrunstates()) {
+    if (state.keepalive.state !== "active") continue;
+    await memory.setrunstate(state.profileid, beatrun(state, Date.now()));
+    startkeepaliveport(state.runid);
+  }
+  const swept = zombiesweep({ states: await memory.listrunstates(), now: Date.now(), interval, missedlimit: tolerance });
+  for (const runid of swept.reaped) {
+    await closeoffscreendocument(runid);
+    await audit("environment", `The zombie reaper closed the run ${runid} whose heartbeat fell silent past the ${tolerance} tolerated interval${tolerance === 1 ? "" : "s"}; the popup offers the reap action.`, {});
+  }
+  for (const state of swept.states) await memory.setrunstate(state.profileid, state);
+  await memory.expirerunstates(settings?.runstateretention, Date.now());
+  const locks = expirerunlocks(await memory.getrunlocks(), Date.now());
+  if (locks.expired.length > 0) await memory.setrunlocks(locks.locks);
+  try {
+    const estimate = await navigator.storage.estimate();
+    if (estimate.usage !== void 0) await memory.trackrunstatequota(estimate.usage);
+    if (settings?.runstatebytes !== void 0) {
+      const quota = await memory.getrunstatequota();
+      if (quota && quota.used > settings.runstatebytes) {
+        const pruned = prunerunstates({ states: await memory.listrunstates(), used: quota.used, ceiling: settings.runstatebytes });
+        for (const runid of pruned.pruned) {
+          const state = await memory.listrunstates();
+          const target = state.find((entry) => entry.runid === runid);
+          if (target) await memory.removerunstate(target.profileid);
+        }
+        if (pruned.pruned.length > 0) await audit("environment", pruned.reason, {});
+      }
+    }
+  } catch {
+  }
+}
+async function restorerunstates() {
+  const settings = await memory.getsettings();
+  const states = await memory.listrunstates();
+  for (const state of states) {
+    if (state.keepalive.state !== "active") continue;
+    await memory.setrunstate(state.profileid, reattachrun(state, Date.now()));
+    startkeepaliveport(state.runid);
+    await audit("environment", `The service worker restarted and the run ${state.runid} reattached its keepalive port from the persisted run state; ${recoveryplan(state).reason}`, {});
+  }
+  void settings;
+}
 async function startsession() {
   const { tab, origin } = await activecontext();
   const session = { id: randomid(), tabid: tab.id, origin, startedat: Date.now(), expiresat: Date.now() + sessionduration, grants: [origin] };
@@ -18394,6 +19137,18 @@ async function executestep(stepid) {
 async function executeaction(step, session, plan, tabid2, origin, settings, verdicts, mode) {
   const gate = canexecute({ session, plan, step, tabid: tabid2, origin, ...verdicts !== void 0 && verdicts.length > 0 ? { verdicts } : {}, ...settings !== void 0 ? { settings } : {} });
   if (!gate.allowed) throw new Error(gate.reason);
+  const environmentverdict = stepenvironmentvalid(step);
+  if (!environmentverdict.allowed) throw new Error(environmentverdict.reason);
+  const environmentgrantverdict = environmentgrantgate(step, session?.environmentgrants);
+  if (!environmentgrantverdict.allowed) throw new Error(environmentgrantverdict.reason);
+  const offgranted = await offscreengranted();
+  const routing = routeenvironment(step, { offload: settings?.parseoffload === true, granted: offgranted });
+  const capabilityverdict = offscreencapabilitygate({ environment: routing.environment, granted: offgranted });
+  if (!capabilityverdict.allowed) throw new Error(capabilityverdict.reason);
+  if (routing.fallback && plan) await audit("environment", `The ${step.kind} step ${step.id} fell back to inline parsing inside the page because the offscreen capability grant stays absent.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  if (session && plan && plan.state === "approved" && mode === "plan") await openplanrun(session, plan);
+  if (plan && plan.state === "approved") await markpendingstep(plan, step.id);
+  if (routing.environment === "sandboxframe") return executesandboxrender(step, session, plan, origin);
   const capability = requiredcapability(step.kind);
   if (capability) {
     const granted = await chrome.permissions.contains({ permissions: [capability] });
@@ -18481,8 +19236,12 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
     return output;
   };
   const runplan = plan;
+  const isolatedresult = routing.environment === "isolatedworld" ? await executeisolatedevaluate(step, tabid2, origin) : void 0;
+  let workerturnaround;
   const capturepolicystate = await runcapturepolicy();
-  if (capturepolicystate === "beforeafter" && session && step.risk !== "read" && beforeafterwrapallowed(step.kind)) {
+  if (isolatedresult !== void 0) {
+    output = isolatedresult;
+  } else if (capturepolicystate === "beforeafter" && session && step.risk !== "read" && beforeafterwrapallowed(step.kind)) {
     const before = await grabstateshot(step, session, runplan, tabid2, "before");
     output = await dispatchreviewedstep();
     if (output?.ok) {
@@ -18498,8 +19257,14 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
   } else {
     output = await dispatchreviewedstep();
   }
+  if (routing.environment === "offscreenworker" && workerturnaround === void 0) {
+    const offloaded = await offloadparsetoworker(step, output, session, plan, origin);
+    output = offloaded.output ?? output;
+    workerturnaround = offloaded.turnaround;
+  }
   if (["navigate", "back", "forward"].includes(step.kind)) await recordnavigation(step, session, tabid2);
   await recordevidence(step, output, session, plan, origin);
+  await recordstepenvironment(step, routing.environment, session, plan, origin, workerturnaround);
   if (output?.ok && plan && typeof output.details?.tabid === "number") {
     await memory.setprogress(assigntasktab(await memory.getprogress(), plan.id, output.details.tabid, Date.now()));
   }
@@ -18508,7 +19273,7 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
   if (resolved) {
     await memory.addresolution({ stepid: step.id, mode: resolved.mode, selector: resolved.selector, label: resolved.label, at: Date.now() });
   }
-  const outcome = { stepid: step.id, ok: Boolean(output?.ok), summary, ...output?.details ? { details: output.details } : {}, at: Date.now() };
+  const outcome = { stepid: step.id, ok: Boolean(output?.ok), summary, environment: routing.environment, ...output?.details ? { details: output.details } : {}, at: Date.now() };
   const auditkind = stepauditkind(step, Boolean(output?.ok));
   await audit(auditkind, summary, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
   await memory.addoutcome(outcome);
@@ -18540,6 +19305,7 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
       });
       const done = { ...plan, state: "completed", completedat: Date.now() };
       await memory.setplan(done);
+      await closeplanrun(done.id, session?.id ?? "");
       await audit("complete", "Every reviewed step of the approved plan has executed.", { ...session ? { sessionid: session.id } : {}, planid: done.id });
     }
   }
@@ -18725,7 +19491,7 @@ async function handlerequest(message, sender) {
       const livetab = session ? await chrome.tabs.get(session.tabid).catch(() => void 0) : void 0;
       const waitprofile = session ? waitprofiles.find((record2) => record2.origin === session.origin) : void 0;
       const livestate = { phase: livetab?.status === "loading" ? "loading" : "complete", ...navrecords[0] ? { finalurl: navrecords[0].finalurl, redirects: navrecords[0].chain } : {} };
-      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, profileretention: runsettings?.profileretention, traceceiling: runsettings?.traceceiling, profile: profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() }), profileactive: activememorytrackers.size + activeprofiletargets.size, profiletargets: [...activeprofiletargets.values()].flatMap((entry) => entry.targets), socketsactive: activesockets.size, emulation: emulationreport({ ...plan && await loademulationstate(plan.id) !== void 0 ? { state: await loademulationstate(plan.id) } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() }), emulatedlayers: plan ? layernames(await loademulationstate(plan.id)) : [], emulationretention: runsettings?.emulationretention, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), sessionmemory: sessionreport({ records: sessionrecords, events: await memory.getsessionevents(), folders: await memory.getsessionfolders(), diffs: await memory.getsessiondiffs(), ...autosnapshot !== void 0 ? { auto: autosnapshot.interval } : {}, ...crashed ? { crashed: true } : {} }), autosnapshotstate: autosnapshot, sessionretention: runsettings?.sessionretention, trigger: triggerlist({ rules: await memory.gettriggerules(), workflows: await memory.listworkflows(), queue: await memory.gettriggerqueue() }), triggerretention: runsettings?.triggerretention, workflow: workflowreport({ workflows: await memory.listworkflows(), runs: await memory.listworkflowruns(), templates: await memory.getsteptemplates(), ...newestworkflowrun !== void 0 ? { log: await memory.getrunlog(newestworkflowrun.id), scopes: await memory.getrunscopes(newestworkflowrun.id), provenance: await memory.getworkflowprovenance(newestworkflowrun.id), control: await memory.listcontroldecisions(newestworkflowrun.id) } : {} }), runlogretention: runsettings?.runlogretention, runhistoryretention: runsettings?.runhistoryretention, editor: editorstate({ versions: await memory.listworkflowversions(), diffs: await memory.listversiondiffs(), history: await memory.gethistory(), overrides: await memory.listsiteoverrides(), imports: (await memory.listworkflowimports()).map((entry) => ({ id: entry.id, workflowid: entry.record.id, name: entry.record.name, version: entry.record.version, steps: entry.record.steps.length, risk: entry.record.risk, importedat: entry.importedat, ...entry.filename !== void 0 ? { filename: entry.filename } : {} })), backgroundruns: await memory.getbackgroundruns(), watchdog: { ...runsettings?.watchdog !== void 0 ? { config: runsettings.watchdog } : {}, events: await memory.listwatchdogevents() } }), ...taskstate !== void 0 ? { taskstate } : {}, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {}, mcp: await mcpstateof(), llm: await llmstateof(), swarm: await swarmstateof() };
+      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, profileretention: runsettings?.profileretention, traceceiling: runsettings?.traceceiling, profile: profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() }), profileactive: activememorytrackers.size + activeprofiletargets.size, profiletargets: [...activeprofiletargets.values()].flatMap((entry) => entry.targets), socketsactive: activesockets.size, emulation: emulationreport({ ...plan && await loademulationstate(plan.id) !== void 0 ? { state: await loademulationstate(plan.id) } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() }), emulatedlayers: plan ? layernames(await loademulationstate(plan.id)) : [], emulationretention: runsettings?.emulationretention, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), sessionmemory: sessionreport({ records: sessionrecords, events: await memory.getsessionevents(), folders: await memory.getsessionfolders(), diffs: await memory.getsessiondiffs(), ...autosnapshot !== void 0 ? { auto: autosnapshot.interval } : {}, ...crashed ? { crashed: true } : {} }), autosnapshotstate: autosnapshot, sessionretention: runsettings?.sessionretention, trigger: triggerlist({ rules: await memory.gettriggerules(), workflows: await memory.listworkflows(), queue: await memory.gettriggerqueue() }), triggerretention: runsettings?.triggerretention, workflow: workflowreport({ workflows: await memory.listworkflows(), runs: await memory.listworkflowruns(), templates: await memory.getsteptemplates(), ...newestworkflowrun !== void 0 ? { log: await memory.getrunlog(newestworkflowrun.id), scopes: await memory.getrunscopes(newestworkflowrun.id), provenance: await memory.getworkflowprovenance(newestworkflowrun.id), control: await memory.listcontroldecisions(newestworkflowrun.id) } : {} }), runlogretention: runsettings?.runlogretention, runhistoryretention: runsettings?.runhistoryretention, editor: editorstate({ versions: await memory.listworkflowversions(), diffs: await memory.listversiondiffs(), history: await memory.gethistory(), overrides: await memory.listsiteoverrides(), imports: (await memory.listworkflowimports()).map((entry) => ({ id: entry.id, workflowid: entry.record.id, name: entry.record.name, version: entry.record.version, steps: entry.record.steps.length, risk: entry.record.risk, importedat: entry.importedat, ...entry.filename !== void 0 ? { filename: entry.filename } : {} })), backgroundruns: await memory.getbackgroundruns(), watchdog: { ...runsettings?.watchdog !== void 0 ? { config: runsettings.watchdog } : {}, events: await memory.listwatchdogevents() } }), ...taskstate !== void 0 ? { taskstate } : {}, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {}, mcp: await mcpstateof(), llm: await llmstateof(), swarm: await swarmstateof(), environments: await environmentviewof() };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -21772,6 +22538,149 @@ async function handlerequest(message, sender) {
       }
       throw new Error("The swarm merge request carries no merge, report, export, compare, lesson, costs, timeline, replay or snapshot action.");
     }
+    case "environments": {
+      const input2 = message;
+      const now = Date.now();
+      const session = await memory.getsession();
+      const settings = await memory.getsettings();
+      if (input2.requestcapability === true) {
+        const granted = await requestoffscreengrant();
+        await audit("environment", granted ? "The user granted the optional offscreen capability through the permissions api; the worker pool may spawn under the manifest declaration." : "The offscreen capability request stayed refused; the parse offload keeps its inline fallback inside the page.", { ...session ? { sessionid: session.id } : {} });
+        return { ...await environmentviewof(), requested: granted };
+      }
+      if (input2.grants !== void 0) {
+        if (!session) throw new Error("The environment grants need an active session to join.");
+        const valid = /* @__PURE__ */ new Set(["pagecontext", "isolatedworld", "offscreenworker", "sandboxframe"]);
+        const requested = input2.grants.filter((environment) => valid.has(environment));
+        const unknown = input2.grants.filter((environment) => !valid.has(environment));
+        if (unknown.length > 0) throw new Error(`The environments ${unknown.join(", ")} sit outside the four execution environments.`);
+        await memory.setenvironmentgrants(requested);
+        await audit("environment", `The user set the environment grants of the session to ${requested.length > 0 ? requested.join(", ") : "the documented default posture"}; no step ever widens them.`, { sessionid: session.id });
+        return environmentviewof();
+      }
+      if (input2.pool !== void 0) {
+        const sizegate = workerpoolsizevalid(input2.pool.size ?? settings?.workerpoolsize);
+        if (!sizegate.allowed) throw new Error(sizegate.reason);
+        const runid = (await memory.getplan())?.id ?? "pool";
+        const current = workerpoolcounts.get(runid) ?? 0;
+        const plan = poolplan({ pending: input2.pool.pending ?? 0, current, ...input2.pool.size !== void 0 ? { size: input2.pool.size } : {} });
+        workerpoolcounts.set(runid, plan.workers);
+        const provenance = { origin: session?.origin ?? "", stepid: "", environment: "offscreenworker" };
+        await memory.addworkerevent({ id: randomid(), runid, kind: plan.added > 0 ? "spawn" : "teardown", workers: plan.workers, reason: plan.reason, provenance, at: now });
+        await audit("worker", `The worker pool of the run ${runid} holds ${plan.workers} worker${plan.workers === 1 ? "" : "s"}: ${plan.reason}`, { ...session ? { sessionid: session.id } : {} });
+        return { ...await environmentviewof(), pool: plan };
+      }
+      if (input2.offscreenclose === true) {
+        const runid = (await memory.getplan())?.id ?? "pool";
+        await closeoffscreendocument(runid);
+        return environmentviewof();
+      }
+      if (input2.settings !== void 0) {
+        const patch = { ...settings };
+        if (input2.settings.parseoffload !== void 0) patch.parseoffload = input2.settings.parseoffload === true;
+        if (input2.settings.workerpoolsize !== void 0) {
+          const sizegate = workerpoolsizevalid(input2.settings.workerpoolsize);
+          if (!sizegate.allowed) throw new Error(sizegate.reason);
+          patch.workerpoolsize = input2.settings.workerpoolsize;
+        }
+        if (input2.settings.sandboxorigins !== void 0) patch.sandboxorigins = input2.settings.sandboxorigins.map((origin) => origin.trim()).filter((origin) => origin !== "");
+        if (input2.settings.keepaliveinterval !== void 0) {
+          const intervalgate = keepaliveintervalvalid(input2.settings.keepaliveinterval);
+          if (!intervalgate.allowed) throw new Error(intervalgate.reason);
+          patch.keepaliveinterval = input2.settings.keepaliveinterval;
+        }
+        if (input2.settings.zombieintervals !== void 0) patch.zombieintervals = input2.settings.zombieintervals;
+        if (input2.settings.runstateretention !== void 0) patch.runstateretention = input2.settings.runstateretention;
+        if (input2.settings.runstatebytes !== void 0) patch.runstatebytes = input2.settings.runstatebytes;
+        await memory.setsettings(patch);
+        await audit("environment", `The user updated the environment settings: parse offload ${patch.parseoffload === true ? "on" : "off"}, worker pool size ${patch.workerpoolsize ?? "queue driven"}, sandbox origins ${patch.sandboxorigins?.length ?? 0} configured, keepalive interval ${patch.keepaliveinterval ?? "the roadmap thirty seconds"}, zombie tolerance ${patch.zombieintervals ?? "the roadmap three intervals"}.`, {});
+        return environmentviewof();
+      }
+      if (input2.render !== void 0) {
+        const result = await executesandboxrender({ id: input2.render.stepid ?? randomid(), kind: "setattribute", summary: "Render untrusted markup inside the sandbox frame.", risk: "sensitive", ...input2.render.markup !== void 0 ? { value: input2.render.markup } : {}, options: JSON.stringify({ markup: input2.render.markup ?? "", ...input2.render.origin !== void 0 ? { sourceorigin: input2.render.origin } : {} }) }, session, await memory.getplan(), input2.render.origin ?? session?.origin ?? "");
+        return { ...await environmentviewof(), render: result };
+      }
+      return environmentviewof();
+    }
+    case "runstate": {
+      const input2 = message;
+      const now = Date.now();
+      const session = await memory.getsession();
+      const plan = await memory.getplan();
+      const settings = await memory.getsettings();
+      const states = await memory.listrunstates();
+      if (input2.start === true) {
+        if (!session || !plan) throw new Error("The run state opens behind an active session with an approved plan.");
+        const gate = keepalivegate({ session, plan, now });
+        if (!gate.allowed) throw new Error(gate.reason);
+        await openplanrun(session, plan);
+        return { ...await environmentviewof(), opened: plan.id };
+      }
+      if (input2.stop === true) {
+        const open = states.find((state) => state.keepalive.state === "active");
+        if (open) await closeplanrun(open.runid, open.sessionid);
+        return environmentviewof();
+      }
+      if (input2.beat === true) {
+        await keepalivetick();
+        return environmentviewof();
+      }
+      if (input2.recover === true) {
+        const open = states.find((state) => state.keepalive.state === "active" || state.state === "recovered");
+        if (!open) throw new Error("No interrupted run waits for its recovery.");
+        const recovery = recoveryplan(open);
+        await memory.setrunstate(open.profileid, reattachrun(open, now));
+        await audit("environment", recovery.reason, { sessionid: open.sessionid });
+        if (recovery.recoverable && recovery.pendingstepid !== void 0 && plan && plan.id === open.planid && plan.state === "approved") {
+          const outcome = await executestep(recovery.pendingstepid);
+          return { ...await environmentviewof(), recovery, resumed: outcome.summary };
+        }
+        return { ...await environmentviewof(), recovery };
+      }
+      if (input2.reap === true) {
+        const swept = zombiesweep({ states, now, interval: settings?.keepaliveinterval ?? roadmapheartbeat, missedlimit: settings?.zombieintervals ?? roadmapzombieintervals });
+        for (const state of swept.states) await memory.setrunstate(state.profileid, state);
+        for (const runid of swept.reaped) await closeoffscreendocument(runid);
+        if (swept.reaped.length > 0) await audit("environment", `The user reaped the zombie run${swept.reaped.length === 1 ? "" : "s"} ${swept.reaped.join(", ")} from the popup warning.`, {});
+        return { ...await environmentviewof(), reaped: swept.reaped };
+      }
+      if (input2.lock !== void 0) {
+        if (input2.lock.acquire !== void 0) {
+          if (!session) throw new Error("The run lock needs its active session.");
+          const runid = input2.lock.acquire.runid?.trim() ?? plan?.id ?? "";
+          const outcome = acquirerunlock({ locks: await memory.getrunlocks(), sessionid: session.id, runid, holder: input2.lock.acquire.holder?.trim() ?? "user", ...input2.lock.acquire.expiresat !== void 0 ? { expiresat: input2.lock.acquire.expiresat } : {}, now });
+          if (!outcome.acquired) throw new Error(outcome.reason);
+          await memory.setrunlocks(outcome.locks);
+          await audit("environment", outcome.reason, { sessionid: session.id });
+          return { ...await environmentviewof(), lock: outcome.reason };
+        }
+        if (input2.lock.release !== void 0) {
+          if (!session) throw new Error("The run lock release needs its active session.");
+          const outcome = releaserunlock({ locks: await memory.getrunlocks(), sessionid: session.id, runid: input2.lock.release.runid?.trim() ?? plan?.id ?? "", now });
+          if (!outcome.released) throw new Error(outcome.reason);
+          await memory.setrunlocks(outcome.locks);
+          await audit("environment", outcome.reason, { sessionid: session.id });
+          return { ...await environmentviewof(), lock: outcome.reason };
+        }
+      }
+      if (input2.serialize !== void 0) {
+        const branches = (input2.serialize.branches ?? []).map((branch) => ({ branchid: branch.branchid?.trim() ?? "", steps: (branch.steps ?? []).filter((step) => step.stepid !== void 0 && step.tabid !== void 0).map((step) => ({ stepid: step.stepid, tabid: step.tabid })) })).filter((branch) => branch.branchid !== "");
+        const order = serializesteps({ branches });
+        await audit("environment", `The executor serialized ${order.length} step${order.length === 1 ? "" : "s"} across parallel branches so steps sharing one tab never run inside the same beat; every other step keeps its branch order.`, {});
+        return { order };
+      }
+      if (input2.export === true) {
+        const exported = await memory.exportrunstates();
+        await audit("environment", `The run states were exported as one audit record: ${exported.runs} run${exported.runs === 1 ? "" : "s"}, ${exported.urls} url entr${exported.urls === 1 ? "y" : "ies"}, ${exported.environments} environment record${exported.environments === 1 ? "" : "s"} and ${exported.offloaded} worker turnaround${exported.offloaded === 1 ? "" : "s"}.`, {});
+        return { export: exported, states: states.map((state) => ({ runid: state.runid, sessionid: state.sessionid, state: state.state, beats: state.keepalive.beats, lastbeatat: state.keepalive.lastbeatat, pendingstepid: state.pendingstepid, urlhistory: state.urlhistory, environments: state.environments, turnarounds: state.turnarounds })) };
+      }
+      if (input2.profileid !== void 0) {
+        const state = await memory.getrunstate(input2.profileid);
+        if (!state) throw new Error(`No run state exists for the profile ${input2.profileid}.`);
+        return { state };
+      }
+      return environmentviewof();
+    }
     default:
       throw new Error("Unknown Devthink request.");
   }
@@ -22565,6 +23474,10 @@ setInterval(() => {
   void evaluatelistedtriggers().then(() => draintriggerqueue()).then(() => runwatchdog()).then(() => restorebackgroundruns()).catch(() => {
   });
 }, 3e4);
+setInterval(() => {
+  void keepalivetick().catch(() => {
+  });
+}, roadmapheartbeat);
 async function restoretriggers() {
   await registermenurules();
   await evaluatelistedtriggers();
@@ -22576,4 +23489,6 @@ async function restoretriggers() {
 }
 restoretriggers().catch(() => {
 });
+restorerunstates().catch(() => {
+});
 //# sourceMappingURL=background.js.map