@wenathlan/extension 1.1.51 → 1.1.53

package/dist/index.js

@@ -335,6 +335,14 @@ function teardowncdpsession(input) {
 
 // workflow.ts
 var workflowkinds = ["composeworkflow", "savetemplate", "runworkflow", "dryrun", "delay", "waitelement", "compute", "extractvars"];
+function nestedparamof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.name !== "string" || !/^[a-z][a-z0-9]*$/.test(candidate.name)) return void 0;
+  if (!variablekinds.includes(candidate.kind)) return void 0;
+  if (candidate.default !== void 0 && !["string", "number", "boolean"].includes(typeof candidate.default) && !Array.isArray(candidate.default)) return void 0;
+  return { name: candidate.name, kind: candidate.kind, ...candidate.default !== void 0 ? { default: candidate.default } : {} };
+}
 function workflowstepof(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   const candidate = value;
@@ -344,6 +352,7 @@ function workflowstepof(value) {
   if (candidate.target !== void 0 && (typeof candidate.target !== "string" || !candidate.target)) return void 0;
   if (candidate.value !== void 0 && typeof candidate.value !== "string") return void 0;
   if (candidate.options !== void 0 && typeof candidate.options !== "string") return void 0;
+  if (candidate.breakpoint !== void 0 && typeof candidate.breakpoint !== "boolean") return void 0;
   const bindings = Array.isArray(candidate.bindings) ? candidate.bindings.flatMap((binding) => bindingof(binding) !== void 0 ? [bindingof(binding)] : []) : void 0;
   if (candidate.bindings !== void 0 && bindings === void 0) return void 0;
   if (Array.isArray(candidate.bindings) && bindings !== void 0 && bindings.length !== candidate.bindings.length) return void 0;
@@ -351,14 +360,20 @@ function workflowstepof(value) {
   if (candidate.expression !== void 0 && expression === void 0) return void 0;
   const extract = candidate.extract === void 0 ? void 0 : regexruleof(candidate.extract);
   if (candidate.extract !== void 0 && extract === void 0) return void 0;
-  return { id: candidate.id, kind: candidate.kind, label: candidate.label, ...candidate.target !== void 0 ? { target: candidate.target } : {}, ...candidate.value !== void 0 ? { value: candidate.value } : {}, ...candidate.options !== void 0 ? { options: candidate.options } : {}, ...bindings !== void 0 && bindings.length > 0 ? { bindings } : {}, ...expression !== void 0 ? { expression } : {}, ...extract !== void 0 ? { extract } : {} };
+  const params = Array.isArray(candidate.params) ? candidate.params.flatMap((param) => nestedparamof(param) !== void 0 ? [nestedparamof(param)] : []) : void 0;
+  if (candidate.params !== void 0 && params === void 0) return void 0;
+  if (Array.isArray(candidate.params) && params !== void 0 && params.length !== candidate.params.length) return void 0;
+  return { id: candidate.id, kind: candidate.kind, label: candidate.label, ...candidate.target !== void 0 ? { target: candidate.target } : {}, ...candidate.value !== void 0 ? { value: candidate.value } : {}, ...candidate.options !== void 0 ? { options: candidate.options } : {}, ...bindings !== void 0 && bindings.length > 0 ? { bindings } : {}, ...expression !== void 0 ? { expression } : {}, ...extract !== void 0 ? { extract } : {}, ...candidate.breakpoint === true ? { breakpoint: true } : {}, ...params !== void 0 && params.length > 0 ? { params } : {} };
 }
 function blockinvocationof(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   const candidate = value;
   if (typeof candidate.block !== "string" || !candidate.block.trim()) return void 0;
   if (typeof candidate.label !== "string" || !candidate.label.trim()) return void 0;
-  return { block: candidate.block, label: candidate.label };
+  const params = Array.isArray(candidate.params) ? candidate.params.flatMap((param) => nestedparamof(param) !== void 0 ? [nestedparamof(param)] : []) : void 0;
+  if (candidate.params !== void 0 && params === void 0) return void 0;
+  if (Array.isArray(candidate.params) && params !== void 0 && params.length !== candidate.params.length) return void 0;
+  return { block: candidate.block, label: candidate.label, ...params !== void 0 && params.length > 0 ? { params } : {} };
 }
 function workflowblockof(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
@@ -437,10 +452,15 @@ function regexruleof(value) {
 function expandblocks(steps, blocks) {
   const byname = new Map(blocks.map((block) => [block.name, block]));
   const expanded = [];
-  const visit = (entries, path, inside) => {
+  const visit = (entries, path, inside, params) => {
+    let stamped = params === void 0;
     for (const entry of entries) {
       if ("kind" in entry && "label" in entry && !("block" in entry)) {
-        expanded.push(inside === void 0 ? entry : { ...entry, block: inside });
+        const marked = inside === void 0 ? entry : { ...entry, block: inside };
+        if (!stamped && params !== void 0) {
+          expanded.push({ ...marked, params });
+          stamped = true;
+        } else expanded.push(marked);
         continue;
       }
       const invocation = blockinvocationof(entry);
@@ -448,7 +468,7 @@ function expandblocks(steps, blocks) {
       if (path.includes(invocation.block)) throw new Error(`The block ${invocation.block} recurs inside itself and cannot expand.`);
       const block = byname.get(invocation.block);
       if (!block) throw new Error(`The block ${invocation.block} is not defined in the workflow.`);
-      visit(block.steps, [...path, invocation.block], invocation.block);
+      visit(block.steps, [...path, invocation.block], invocation.block, invocation.params ?? params);
     }
   };
   visit(steps, [], void 0);
@@ -816,6 +836,17 @@ async function runworkflow(input) {
     if (step.block !== void 0 && step.block !== activeblock) {
       scopes = pushscope(scopes, step.block, scopes[scopes.length - 1].name);
       activeblock = step.block;
+      if (step.params) {
+        try {
+          for (const param of step.params) {
+            if (param.default === void 0) continue;
+            scopes = setvariable(scopes, param.name, param.kind, coercevariable(param.default, param.kind), input.now);
+          }
+        } catch (error) {
+          const reason = error instanceof Error ? error.message : String(error);
+          return { run: { ...run, state: "failed", endedat: Date.now(), failreason: `The nested parameter of block ${step.block} failed: ${reason}` }, scopes, log, outputs };
+        }
+      }
     } else if (step.block === void 0 && activeblock !== void 0) {
       while (scopes.length > 1) scopes = popscope(scopes);
       activeblock = void 0;
@@ -848,6 +879,27 @@ function dryrunworkflow(input) {
   }
   return { run: { ...run, state: "done", cursor: input.record.steps.length, endedat: input.now }, scopes, log };
 }
+function watchdogpass(input) {
+  const verdicts = [];
+  for (const run of input.runs) {
+    if (run.state !== "running") continue;
+    const lastcompletedat = input.lastcompletedat[run.id] ?? run.startedat;
+    const live = input.liveexecutors.includes(run.id);
+    const silence = input.now - lastcompletedat;
+    if (!live && input.config.zombiewindow !== void 0 && silence >= input.config.zombiewindow) {
+      verdicts.push({ runid: run.id, verdict: "zombie", action: "reap", reason: `The run ${run.id} lost its executor ${silence} ms ago and reaps as a zombie of a browser shutdown at its last checkpoint ${run.cursor}.`, ...lastcompletedat !== run.startedat ? { lastcompletedat } : {} });
+      continue;
+    }
+    if (!live) continue;
+    if (silence >= input.config.stallthreshold) {
+      const action = input.config.action;
+      verdicts.push({ runid: run.id, verdict: "stalled", action, reason: `The run ${run.id} completed no step for ${silence} ms past the reviewed threshold and the watchdog recovers it with ${action} at cursor ${run.cursor}.`, ...lastcompletedat !== run.startedat ? { lastcompletedat } : {} });
+      continue;
+    }
+    verdicts.push({ runid: run.id, verdict: "healthy", action: "none", reason: `The run ${run.id} completed its last step ${silence} ms ago and stays healthy.`, ...lastcompletedat !== run.startedat ? { lastcompletedat } : {} });
+  }
+  return verdicts;
+}
 
 // controlflow.ts
 var controlflowkinds = ["condition", "branch", "loop", "repeatuntil", "whileloop", "foreach", "parallel", "trycatch"];
@@ -4363,6 +4415,178 @@ var sessionmemory = class {
     }
     return history;
   }
+  /** Stores one armed trigger rule with its workflow reference; re-arming the same id replaces the rule while the fire history survives. */
+  async addtriggerule(rule) {
+    const rules = (await this.gettriggerules()).filter((entry) => entry.id !== rule.id);
+    await this.adapter.set("triggerules", [rule, ...rules]);
+  }
+  /** Returns every armed trigger rule, newest first. */
+  async gettriggerules() {
+    return await this.adapter.get("triggerules") ?? [];
+  }
+  /** Returns one armed trigger rule by its id. */
+  async gettriggerule(id) {
+    return (await this.gettriggerules()).find((rule) => rule.id === id);
+  }
+  /** Replaces one stored rule after an enable, disable, pause, resume, cooldown or fire bookkeeping change. */
+  async settriggerule(rule) {
+    const rules = await this.gettriggerules();
+    await this.adapter.set("triggerules", rules.map((entry) => entry.id === rule.id ? rule : entry));
+  }
+  /** Replaces every stored rule at once so the session pause and resume suspend and release the whole rule set atomically. */
+  async settriggerules(rules) {
+    return this.adapter.set("triggerules", rules);
+  }
+  /** Removes one armed rule when the user disarms it; the fire history survives for the audit trail. */
+  async removetriggerule(id) {
+    await this.adapter.set("triggerules", (await this.gettriggerules()).filter((rule) => rule.id !== id));
+  }
+  /** Lists every armed rule joined with the name of its composed workflow so the trigger list shows what each rule launches. */
+  async listtriggers() {
+    const rules = await this.gettriggerules();
+    const names = new Map((await this.listworkflows()).map((record2) => [record2.id, record2.name]));
+    return rules.map((rule) => ({ rule, ...names.has(rule.workflowid) ? { workflowname: names.get(rule.workflowid) } : {} }));
+  }
+  /** Records one trigger fire with the reviewed retention window; an absent window keeps every fire record while the rule counters always survive. */
+  async addtriggerfire(fire) {
+    const fires = await this.listtriggerfires();
+    const combined = [fire, ...fires];
+    const retention = (await this.getsettings())?.triggerretention;
+    await this.adapter.set("triggerfires", retention === void 0 ? combined : combined.slice(0, retention));
+  }
+  /** Returns every stored trigger fire record, newest first, optionally filtered to one rule. */
+  async listtriggerfires(ruleid) {
+    const fires = await this.adapter.get("triggerfires") ?? [];
+    return ruleid === void 0 ? fires : fires.filter((fire) => fire.ruleid === ruleid);
+  }
+  /** Stores the pending trigger queue: fires that arrived while the target run was busy or the session paused; the resume drains them through the same gates. */
+  async settriggerqueue(queue) {
+    return this.adapter.set("triggerqueue", queue);
+  }
+  /** Returns the pending trigger queue, oldest first. */
+  async gettriggerqueue() {
+    return await this.adapter.get("triggerqueue") ?? [];
+  }
+  /** Stores one verified webhook payload of a rule; the executor verifies the shared secret and the schema before anything persists. */
+  async addwebhookpayload(ruleid, payload, at) {
+    const stored = await this.adapter.get("webhookpayloads") ?? [];
+    await this.adapter.set("webhookpayloads", [{ ruleid, payload, at }, ...stored]);
+  }
+  /** Returns the stored webhook payloads of one rule, newest first; only secret verified deliveries ever reach this store. */
+  async listwebhookpayloads(ruleid) {
+    const stored = await this.adapter.get("webhookpayloads") ?? [];
+    return stored.filter((entry) => entry.ruleid === ruleid);
+  }
+  /** Stores one manual run preview with its step list so the panel renders it before confirmation. */
+  async addmanualrun(preview) {
+    const runs = (await this.listmanualruns()).filter((entry) => entry.id !== preview.id);
+    await this.adapter.set("manualruns", [preview, ...runs]);
+  }
+  /** Returns every stored manual run preview with its confirmation outcome, newest first. */
+  async listmanualruns() {
+    return await this.adapter.get("manualruns") ?? [];
+  }
+  /** Stores one workflow version record with its change note; saving the same version again replaces its note while older versions survive for the timeline. */
+  async addworkflowversion(version) {
+    const versions = (await this.listworkflowversions()).filter((entry) => !(entry.workflowid === version.workflowid && entry.version === version.version));
+    await this.adapter.set("workflowversions", [version, ...versions]);
+  }
+  /** Returns every stored workflow version record, newest first, optionally filtered to one workflow. */
+  async listworkflowversions(workflowid) {
+    const versions = await this.adapter.get("workflowversions") ?? [];
+    return workflowid === void 0 ? versions : versions.filter((entry) => entry.workflowid === workflowid);
+  }
+  /** Stores one version diff result for the history view. */
+  async addversiondiff(diff) {
+    const diffs = (await this.listversiondiffs()).filter((entry) => !(entry.workflowid === diff.workflowid && entry.from === diff.from && entry.to === diff.to));
+    await this.adapter.set("versiondiffs", [diff, ...diffs]);
+  }
+  /** Returns every stored version diff result, newest first, optionally filtered to one workflow. */
+  async listversiondiffs(workflowid) {
+    const diffs = await this.adapter.get("versiondiffs") ?? [];
+    return workflowid === void 0 ? diffs : diffs.filter((entry) => entry.workflowid === workflowid);
+  }
+  /** Records one run history entry — the outcome, duration and trigger cause of one execution — under the user configured retention window with no code ceiling. */
+  async addrunhistory(entry) {
+    const entries = await this.gethistory();
+    const combined = [entry, ...entries];
+    const retention = (await this.getsettings())?.runhistoryretention;
+    await this.adapter.set("runhistory", retention === void 0 ? combined : combined.slice(0, retention));
+  }
+  /** Returns the stored run history, newest first, filtered by workflow, outcome and time floor; the filters stay user choices. */
+  async gethistory(filter) {
+    const entries = await this.adapter.get("runhistory") ?? [];
+    let filtered = entries;
+    if (filter?.workflowid !== void 0) filtered = filtered.filter((entry) => entry.workflowid === filter.workflowid);
+    if (filter?.outcome !== void 0) filtered = filtered.filter((entry) => entry.outcome === filter.outcome);
+    if (filter?.since !== void 0) filtered = filtered.filter((entry) => entry.endedat >= filter.since);
+    if (filter?.limit !== void 0) filtered = filtered.slice(0, filter.limit);
+    return filtered;
+  }
+  /** Stores the editor layout of one workflow so the canvas reopens exactly as left. */
+  async seteditorlayout(workflowid, layout) {
+    return this.adapter.set(`editorlayout${workflowid}`, layout);
+  }
+  /** Returns the stored editor layout of one workflow. */
+  async geteditorlayout(workflowid) {
+    return await this.adapter.get(`editorlayout${workflowid}`) ?? void 0;
+  }
+  /** Stores the breakpoint step ids of one workflow. */
+  async setworkflowbreakpoints(workflowid, stepids) {
+    return this.adapter.set(`workflowbreakpoints${workflowid}`, stepids);
+  }
+  /** Returns the stored breakpoint step ids of one workflow, oldest first. */
+  async getworkflowbreakpoints(workflowid) {
+    return await this.adapter.get(`workflowbreakpoints${workflowid}`) ?? [];
+  }
+  /** Stores one per site policy override; re-adding the same id replaces its deltas. */
+  async addsiteoverride(override) {
+    const overrides = (await this.listsiteoverrides()).filter((entry) => entry.id !== override.id);
+    await this.adapter.set("siteoverrides", [override, ...overrides]);
+  }
+  /** Returns every stored per site override, newest first, optionally filtered to one workflow. */
+  async listsiteoverrides(workflowid) {
+    const overrides = await this.adapter.get("siteoverrides") ?? [];
+    return workflowid === void 0 ? overrides : overrides.filter((entry) => entry.workflowid === workflowid);
+  }
+  /** Removes one per site override when the user deletes it. */
+  async removesiteoverride(id) {
+    await this.adapter.set("siteoverrides", (await this.listsiteoverrides()).filter((entry) => entry.id !== id));
+  }
+  /** Stores one watchdog event with its recovery outcome; the event history keeps the audit trail of every scan. */
+  async addwatchdogevent(event) {
+    const events = (await this.listwatchdogevents()).filter((entry) => entry.id !== event.id);
+    await this.adapter.set("watchdogevents", [event, ...events]);
+  }
+  /** Returns every stored watchdog event, newest first. */
+  async listwatchdogevents() {
+    return await this.adapter.get("watchdogevents") ?? [];
+  }
+  /** Stores one pending workflow import held for review; approving it later stores the record as runnable. */
+  async addworkflowimport(entry) {
+    const imports = (await this.listworkflowimports()).filter((candidate) => candidate.id !== entry.id);
+    await this.adapter.set("workflowimports", [entry, ...imports]);
+  }
+  /** Returns every pending workflow import, newest first. */
+  async listworkflowimports() {
+    return await this.adapter.get("workflowimports") ?? [];
+  }
+  /** Removes one pending import when the user approves or rejects it. */
+  async removeworkflowimport(id) {
+    await this.adapter.set("workflowimports", (await this.listworkflowimports()).filter((entry) => entry.id !== id));
+  }
+  /** Stores the per workflow background run flags so a workflow keeps running with the panel closed. */
+  async setbackgroundruns(flags) {
+    return this.adapter.set("backgroundruns", flags);
+  }
+  /** Returns the per workflow background run flags. */
+  async getbackgroundruns() {
+    return await this.adapter.get("backgroundruns") ?? {};
+  }
+  /** Removes one stored workflow record version; a rejected import or rollback disappears from the library while every other version survives. */
+  async removeworkflowversion(id, version) {
+    await this.adapter.set("workflowrecords", (await this.getworkflowrecordversions()).filter((entry) => !(entry.id === id && entry.version === version)));
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -4899,193 +5123,399 @@ function extractvalues(body, paths) {
   return fields.map((field) => ({ path: field.path, ...field.value !== void 0 ? { value: field.value } : {}, ...field.missing ? { missing: true } : {} }));
 }
 
-// runtimeline.ts
-var timelinekinds = ["watchconsole", "watcherrors", "watchtasks"];
-var loglevels = ["error", "warn", "info", "log", "debug", "trace"];
-var timelinesources = ["console", "error", "rejection", "resource", "longtask", "network", "cdp"];
-function levelrank(level) {
-  return loglevels.indexOf(level);
+// trigger.ts
+var triggerkinds = ["visitrule", "urlrule", "menurule", "keyrule", "buttonrule", "cronrule", "intervalrule", "urllistrule", "webhookrule", "eventrule"];
+var triggerfamilies = ["visit", "url", "menu", "key", "button", "cron", "interval", "urllist", "webhook", "event"];
+var triggereventcatalog = ["mutate", "focus", "banner", "console", "error", "navigate"];
+var defaulttriggercooldown = 1e4;
+function istriggerkind(kind) {
+  return triggerkinds.includes(kind);
+}
+function triggerfamilyof(kind) {
+  const index = triggerkinds.indexOf(kind);
+  return index >= 0 ? triggerfamilies[index] : void 0;
+}
+function triggerlabel(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function positivewindow(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
 }
-function redactconsoletext(text2, patterns) {
-  let redacted = text2;
-  for (const pattern of patterns) {
-    if (!pattern) continue;
-    while (redacted.includes(pattern)) redacted = redacted.replace(pattern, "[redacted]");
+function jitterwindow(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function httpsorigin(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  try {
+    const parsed = new URL(value.trim());
+    if (parsed.protocol !== "https:") return void 0;
+    return parsed.origin;
+  } catch {
+    return void 0;
   }
-  return redacted;
 }
-function argkind(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  if (value instanceof Error) return "error";
-  switch (typeof value) {
-    case "string":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "bigint":
-      return "bigint";
-    case "symbol":
-      return "symbol";
-    case "function":
-      return "function";
-    case "undefined":
-      return "undefined";
-    default:
-      return "object";
+function webhookfieldof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.name !== "string" || !/^[a-z][a-z0-9]*$/i.test(candidate.name)) return void 0;
+  if (candidate.kind !== "string" && candidate.kind !== "number" && candidate.kind !== "boolean") return void 0;
+  if (candidate.required !== void 0 && typeof candidate.required !== "boolean") return void 0;
+  return { name: candidate.name, kind: candidate.kind, ...candidate.required === true ? { required: true } : {} };
+}
+function triggerpayloadof(family, value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (family === "visit") {
+    if (!Array.isArray(candidate.origins) || candidate.origins.length === 0) return void 0;
+    const origins = candidate.origins.map((origin) => httpsorigin(origin));
+    if (origins.some((origin) => origin === void 0)) return void 0;
+    return { origins: [...new Set(origins)] };
+  }
+  if (family === "url") {
+    if (typeof candidate.pattern !== "string" || !candidate.pattern.trim()) return void 0;
+    if (httpsorigin(candidate.pattern) === void 0) return void 0;
+    return { pattern: candidate.pattern.trim() };
+  }
+  if (family === "menu") {
+    const title = triggerlabel(candidate.title);
+    if (!title) return void 0;
+    return { title };
+  }
+  if (family === "key") {
+    if (typeof candidate.command !== "string" || !/^[a-z][a-z0-9-]*$/.test(candidate.command)) return void 0;
+    if (candidate.key !== void 0 && (typeof candidate.key !== "string" || !candidate.key.trim())) return void 0;
+    return { command: candidate.command, ...candidate.key !== void 0 ? { key: candidate.key } : {} };
+  }
+  if (family === "button") return {};
+  if (family === "cron") {
+    if (typeof candidate.cron !== "string" || !candidate.cron.trim()) return void 0;
+    if (cronparse(candidate.cron) === void 0) return void 0;
+    if (candidate.timezone !== void 0 && (typeof candidate.timezone !== "string" || !timezonevalid(candidate.timezone))) return void 0;
+    return { cron: candidate.cron.trim(), ...candidate.timezone !== void 0 ? { timezone: candidate.timezone } : {} };
+  }
+  if (family === "interval") {
+    const period = positivewindow(candidate.period);
+    if (period === void 0) return void 0;
+    const jitter = jitterwindow(candidate.jitter);
+    if (candidate.jitter !== void 0 && jitter === void 0) return void 0;
+    return { period, ...jitter !== void 0 ? { jitter } : {} };
+  }
+  if (family === "urllist") {
+    if (!Array.isArray(candidate.urls) || candidate.urls.length === 0) return void 0;
+    const urls = candidate.urls.map((url) => httpsorigin(url) === void 0 ? void 0 : url.trim());
+    if (urls.some((url) => url === void 0)) return void 0;
+    return { urls };
+  }
+  if (family === "webhook") {
+    if (typeof candidate.secret !== "string" || !webhooksecretok(candidate.secret)) return void 0;
+    if (!Array.isArray(candidate.schema) || candidate.schema.length === 0) return void 0;
+    const schema = candidate.schema.map((field) => webhookfieldof(field));
+    if (schema.some((field) => field === void 0)) return void 0;
+    const names = schema.map((field) => field.name);
+    if (new Set(names).size !== names.length) return void 0;
+    return { secret: candidate.secret, schema };
+  }
+  const events = candidate.events;
+  if (!Array.isArray(events) || events.length === 0) return void 0;
+  if (!events.every((name) => typeof name === "string" && triggereventcatalog.includes(name))) return void 0;
+  return { events: [...new Set(events)] };
+}
+function webhooksecretok(secret) {
+  if (secret.length < 24) return false;
+  if (/^(.)\1+$/.test(secret)) return false;
+  return /[a-z]/i.test(secret) && /\d/.test(secret);
+}
+function timezonevalid(timezone) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone });
+    return true;
+  } catch {
+    return false;
   }
 }
-function serializearg(value, depth) {
-  const render = (item, remaining) => {
-    if (item instanceof Error) return `${item.name}: ${item.message}`;
-    if (typeof item === "string") return item;
-    if (typeof item === "function") return `[function ${item.name || "anonymous"}]`;
-    if (typeof item === "bigint") return `${item}n`;
-    if (typeof item === "symbol") return item.toString();
-    if (item === null || item === void 0 || typeof item !== "object") return String(item);
-    if (remaining <= 0) {
-      const tag = Array.isArray(item) ? "Array" : item.constructor?.name ?? "Object";
-      return `[${tag}]`;
-    }
-    if (Array.isArray(item)) return `[${item.map((entry) => render(entry, remaining - 1)).join(", ")}]`;
-    const record2 = item;
-    return `{${Object.keys(record2).map((key) => `${key}: ${render(record2[key], remaining - 1)}`).join(", ")}}`;
-  };
-  return render(value, Math.max(0, depth));
+function armrule(input) {
+  if (typeof input.workflowid !== "string" || !input.workflowid.trim()) return void 0;
+  const payload = triggerpayloadof(input.family, input.payload);
+  if (!payload) return void 0;
+  if (input.cooldown !== void 0 && (typeof input.cooldown !== "number" || !Number.isFinite(input.cooldown) || input.cooldown <= 0)) return void 0;
+  const cooldown = input.cooldown ?? (input.family === "webhook" || input.family === "event" ? defaulttriggercooldown : 0);
+  const label = input.label ?? `The ${input.family} rule of ${input.workflowid}`;
+  return { id: input.id ?? crypto.randomUUID(), kind: input.family, workflowid: input.workflowid, label, ...payload, cooldown, state: { enabled: true, cooldown }, stats: { fires: 0, launches: 0, suppressions: 0 }, createdat: input.now };
 }
-function consolecapture(input) {
-  const parts = input.args.map((arg) => serializearg(arg, input.depth));
-  return { level: input.level, text: redactconsoletext(parts.join(" "), input.redact), argkinds: input.args.map((arg) => argkind(arg)), repeat: 1 };
+function updaterule(rule, patch) {
+  return { ...rule, ...patch.state !== void 0 ? { state: { ...rule.state, ...patch.state } } : {}, ...patch.stats !== void 0 ? { stats: { ...rule.stats, ...patch.stats } } : {} };
 }
-function stackframes(stacktext) {
-  const frames = [];
-  for (const row of stacktext.split("\n")) {
-    const trimmed = row.trim();
-    if (!trimmed.startsWith("at ")) continue;
-    const body = trimmed.slice(3).trim();
-    const location = body.match(/\(([^()]*:\d+:\d+)\)$/) ?? body.match(/^(.*:\d+:\d+)$/);
-    const located = location?.[1];
-    if (!located) continue;
-    const segments = located.split(":");
-    const column = Number.parseInt(segments.pop() ?? "", 10);
-    const lineno = Number.parseInt(segments.pop() ?? "", 10);
-    const url = segments.join(":");
-    if (!Number.isFinite(lineno) || lineno < 0) continue;
-    const name = body.endsWith(`(${located})`) ? body.slice(0, body.length - located.length - 2).trim() : "";
-    frames.push({ ...name ? { functionname: name } : {}, url, line: lineno, ...Number.isFinite(column) ? { column } : {} });
+function matchurl(pattern, url) {
+  let parsedpattern;
+  let parsedurl;
+  try {
+    parsedpattern = new URL(pattern);
+    parsedurl = new URL(url);
+  } catch {
+    return false;
   }
-  return frames;
+  if (parsedpattern.protocol !== parsedurl.protocol) return false;
+  if (parsedpattern.hostname !== parsedurl.hostname) return false;
+  if (parsedpattern.port !== "" && parsedpattern.port !== parsedurl.port) return false;
+  return globmatch(`${parsedpattern.pathname}${parsedpattern.search}`, `${parsedurl.pathname}${parsedurl.search}`);
 }
-function errorcapture(input) {
-  return { message: redactconsoletext(input.message, input.redact), frames: input.stacktext !== void 0 ? stackframes(input.stacktext) : [], sourceurl: input.sourceurl, line: input.line };
-}
-function rejectioncapture(input) {
-  return { reason: redactconsoletext(input.reason, input.redact), frames: input.stacktext !== void 0 ? stackframes(input.stacktext) : [] };
+function globmatch(pattern, text2) {
+  const escaped = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const expression = new RegExp(["^", pattern.split("**").map((segment) => segment.split("*").map(escaped).join("[^/]*")).join(".*"), "$"].join(""));
+  return expression.test(text2);
 }
-function longtaskcapture(input) {
-  return input.entries.filter((entry) => entry.duration >= input.threshold).map((entry) => ({ duration: Math.round(entry.duration), starttime: Math.round(entry.starttime), attributions: [...entry.attributions] }));
+function visitmatch(origins, url) {
+  let origin = "";
+  try {
+    origin = new URL(url).origin;
+  } catch {
+    return false;
+  }
+  return origins.includes(origin);
+}
+function cronparse(expression) {
+  const fields = expression.trim().split(/\s+/);
+  if (fields.length !== 5) return void 0;
+  const minutes = cronfield(fields[0] ?? "", 0, 59);
+  const hours = cronfield(fields[1] ?? "", 0, 23);
+  const daysofmonth = cronfield(fields[2] ?? "", 1, 31);
+  const months = cronfield(fields[3] ?? "", 1, 12, monthnames);
+  const daysofweek = cronfield(fields[4] ?? "", 0, 7, weekdaynames, true);
+  if (!minutes || !hours || !daysofmonth || !months || !daysofweek) return void 0;
+  return { minutes, hours, daysofmonth, months, daysofweek: [...new Set(daysofweek.map((day) => day % 7))].sort((left, right) => left - right) };
+}
+var weekdaynames = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 };
+var monthnames = { jan: 1, feb: 2, mar: 3, apr: 4, may: 5, jun: 6, jul: 7, aug: 8, sep: 9, oct: 10, nov: 11, dec: 12 };
+function cronfield(field, min, max, names, sundayseven = false) {
+  const values = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    if (!part) return void 0;
+    const [range, stepstring] = part.split("/");
+    const step = stepstring === void 0 ? 1 : Number(stepstring);
+    if (!Number.isInteger(step) || step < 1) return void 0;
+    let low = min;
+    let high = max;
+    if (range !== void 0 && range !== "*") {
+      const bounds = range.split("-");
+      if (bounds.length > 2) return void 0;
+      const lowvalue = cronvalue(bounds[0] ?? "", min, max, names);
+      if (lowvalue === void 0) return void 0;
+      low = lowvalue;
+      high = lowvalue;
+      if (bounds.length === 2) {
+        const highvalue = cronvalue(bounds[1] ?? "", min, max, names);
+        if (highvalue === void 0 || highvalue < lowvalue) return void 0;
+        high = highvalue;
+      }
+    }
+    for (let value = low; value <= high; value += step) values.add(value);
+  }
+  const list = [...values];
+  if (list.some((value) => value < min || value > max)) return void 0;
+  if (sundayseven && values.has(7)) {
+    values.delete(7);
+    values.add(0);
+  }
+  return [...values].sort((left, right) => left - right);
 }
-function attachtimeline(input) {
-  return { runid: input.runid, origin: input.origin, stepids: [...input.stepids], attachedat: input.now, entries: [] };
+function cronvalue(value, min, max, names) {
+  const candidate = names?.[value.toLowerCase()];
+  if (candidate !== void 0) return candidate;
+  if (!/^\d+$/.test(value)) return void 0;
+  const parsed = Number(value);
+  if (parsed < min || parsed > max) return void 0;
+  return parsed;
 }
-function filterentries(entries, levelset) {
-  return entries.filter((entry) => {
-    const floor = levelset.floors?.[entry.stepid] ?? levelset.floors?.["*"];
-    if (floor !== void 0 && levelrank(entry.level) > levelrank(floor)) return false;
-    if (levelset.sources !== void 0 && levelset.sources.length > 0 && !levelset.sources.includes(entry.source)) return false;
-    return true;
-  });
+function calendarparts(at, timezone) {
+  if (timezone === void 0) {
+    const date = new Date(at);
+    return { minute: date.getUTCMinutes(), hour: date.getUTCHours(), day: date.getUTCDate(), month: date.getUTCMonth() + 1, weekday: date.getUTCDay() };
+  }
+  const parts = new Intl.DateTimeFormat("en-US", { timeZone: timezone, hourCycle: "h23", minute: "numeric", hour: "numeric", day: "numeric", month: "short", weekday: "short" }).formatToParts(new Date(at));
+  const pick = (type) => parts.find((part) => part.type === type)?.value ?? "";
+  const weekday = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(pick("weekday"));
+  const month = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"].indexOf(pick("month")) + 1;
+  return { minute: Number(pick("minute")), hour: Number(pick("hour")), day: Number(pick("day")), month, weekday };
+}
+function crondaymatch(schedule, parts) {
+  if (!schedule.months.includes(parts.month)) return false;
+  const domfull = schedule.daysofmonth.length === 31;
+  const dowfull = schedule.daysofweek.length === 7;
+  const dommatch = schedule.daysofmonth.includes(parts.day);
+  const dowmatch = schedule.daysofweek.includes(parts.weekday);
+  if (!domfull && !dowfull) return dommatch || dowmatch;
+  if (!domfull) return dommatch;
+  if (!dowfull) return dowmatch;
+  return true;
 }
-function spamdetect(entries, rule) {
-  const collapsed = [];
-  const counts = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    if (rule.pattern !== "" && !entry.message.includes(rule.pattern)) {
-      collapsed.push({ ...entry, repeat: 1 });
+function cronnext(expression, from, timezone) {
+  const schedule = cronparse(expression);
+  if (!schedule) return void 0;
+  const minute = 6e4;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+  let candidate = Math.floor(from / minute) * minute + minute;
+  const horizon = from + 4 * 366 * day;
+  while (candidate <= horizon) {
+    const parts = calendarparts(candidate, timezone);
+    if (!crondaymatch(schedule, parts)) {
+      candidate += day - parts.hour * hour - parts.minute * minute;
       continue;
     }
-    const key = `${entry.level}|${entry.source}|${entry.message}`;
-    const previous = collapsed[collapsed.length - 1];
-    if (previous && previous.repeat !== void 0 && `${previous.level}|${previous.source}|${previous.message}` === key && entry.time - previous.time <= rule.windowsize) {
-      previous.repeat += 1;
+    if (!schedule.hours.includes(parts.hour)) {
+      const later = schedule.hours.find((value) => value > parts.hour);
+      candidate += later === void 0 ? day - parts.hour * hour - parts.minute * minute : (later - parts.hour) * hour - parts.minute * minute;
       continue;
     }
-    collapsed.push({ ...entry, repeat: 1 });
+    if (!schedule.minutes.includes(parts.minute)) {
+      const later = schedule.minutes.find((value) => value > parts.minute);
+      candidate += later === void 0 ? (60 - parts.minute) * minute : (later - parts.minute) * minute;
+      continue;
+    }
+    return candidate;
   }
-  for (const entry of collapsed) {
-    if (entry.repeat > 1) counts.set(`${entry.level}|${entry.source}|${entry.message}`, entry.repeat);
+  return void 0;
+}
+function schedulecron(rule, from) {
+  return cronnext(rule.cron, from, rule.timezone);
+}
+function scheduleinterval(rule, lastfire, armedat, seed) {
+  const base = (lastfire ?? armedat) + rule.period;
+  const jitter = rule.jitter ?? 0;
+  if (jitter <= 0) return base;
+  return Math.max(0, Math.round(base - jitter / 2 + seededrandom(seed) * jitter));
+}
+function listdue(rules, now) {
+  return rules.flatMap((rule) => {
+    if (rule.state.nextfireat === void 0 || rule.state.nextfireat > now) return [];
+    if (!rule.state.enabled || rule.state.pausedat !== void 0) return [];
+    return [{ rule, overdueby: now - rule.state.nextfireat }];
+  });
+}
+function applycooldown(rule, now) {
+  const lastfireat = rule.state.lastfireat;
+  if (lastfireat === void 0 || rule.state.cooldown <= 0) return { suppressed: false, remaining: 0 };
+  const remaining = lastfireat + rule.state.cooldown - now;
+  return { suppressed: remaining > 0, remaining: Math.max(0, remaining) };
+}
+function evaluatetrigger(input) {
+  const rule = input.rule;
+  if (!rule.state.enabled) return { fired: false, suppressed: "disabled" };
+  if (rule.state.pausedat !== void 0) return { fired: false, suppressed: "paused" };
+  if (!input.workflowreviewed) return { fired: false, suppressed: "unreviewed" };
+  if (input.runactive) return { fired: false, suppressed: "dedupe" };
+  const cooldown = applycooldown(rule, input.now);
+  if (cooldown.suppressed) return { fired: false, suppressed: "cooldown", remaining: cooldown.remaining };
+  const fire = { id: crypto.randomUUID(), ruleid: rule.id, at: input.now, cause: input.cause, ...input.url !== void 0 ? { url: input.url } : {}, ...input.title !== void 0 ? { title: input.title } : {}, ...input.payload !== void 0 ? { payload: input.payload } : {} };
+  return { fired: true, fire };
+}
+function queuefire(queue, fire) {
+  if (queue.some((pending) => pending.ruleid === fire.ruleid)) return { queue, queued: false, deduped: true };
+  return { queue: [...queue, fire], queued: true, deduped: false };
+}
+async function drainqueue(queue, launch) {
+  let remaining = [...queue];
+  let launched = 0;
+  while (remaining.length > 0) {
+    const fire = remaining[0];
+    try {
+      await launch(fire);
+    } catch {
+      return { launched, remaining };
+    }
+    remaining = remaining.slice(1);
+    launched += 1;
+  }
+  return { launched, remaining };
+}
+function runurllist(rule, now) {
+  const urls = rule.urls ?? [];
+  return urls.map((url) => ({ id: crypto.randomUUID(), ruleid: rule.id, at: now, cause: "urllist", url }));
+}
+function verifywebhook(input) {
+  if (typeof input.rule.secret !== "string" || !input.rule.secret) return { verified: false, reason: "The webhook rule carries no reviewed secret." };
+  if (!secrectsmatch(input.secret, input.rule.secret)) return { verified: false, reason: "The webhook secret does not match the reviewed secret of the rule." };
+  const payload = input.payload;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return { verified: false, reason: "The webhook payload must be a JSON object." };
+  const candidate = payload;
+  for (const field of input.rule.schema ?? []) {
+    const value = candidate[field.name];
+    if (value === void 0) {
+      if (field.required === true) return { verified: false, reason: `The required webhook field ${field.name} is missing.` };
+      continue;
+    }
+    if (typeof value !== field.kind) return { verified: false, reason: `The webhook field ${field.name} is not a ${field.kind}.` };
   }
-  const flagged = [...counts.entries()].filter(([, count]) => count > rule.collapse).map(([key, count]) => ({ message: key.split("|").slice(2).join("|"), count }));
-  return { entries: collapsed, flagged };
+  return { verified: true };
 }
-function rotatelogs(entries, rule) {
-  if (entries.length <= rule.maxentries) return { kept: [...entries], overflow: [] };
-  const kept = entries.slice(entries.length - rule.maxentries);
-  const overflow = entries.slice(0, entries.length - rule.maxentries);
-  return { kept, overflow };
+function secrectsmatch(left, right) {
+  if (left.length !== right.length) return false;
+  let same = true;
+  for (let index = 0; index < left.length; index += 1) if (left.charCodeAt(index) !== right.charCodeAt(index)) same = false;
+  return same;
 }
-function timelinecounts(entries) {
-  const counts = {};
-  for (const level of loglevels) counts[level] = 0;
-  for (const entry of entries) counts[entry.level] = (counts[entry.level] ?? 0) + 1;
-  return counts;
+function eventrulematches(rule, event) {
+  return (rule.events ?? []).includes(event);
 }
-function blockingduration(tasks, stepid, window) {
-  const inside = tasks.filter((task) => task.starttime >= window.startedat && task.starttime <= window.endedat);
-  return { stepid, blocking: inside.reduce((total, task) => total + task.duration, 0), tasks: inside.length };
+function observeevents(rules, event) {
+  if (!triggereventcatalog.includes(event)) return [];
+  return rules.filter((rule) => rule.kind === "event" && rule.state.enabled && rule.state.pausedat === void 0 && eventrulematches(rule, event));
 }
-function netfailureentryof(input) {
-  const exchange = input.exchange;
-  if (exchange.errorclass === void 0 && exchange.status < 400) return null;
-  return { id: input.id, runid: exchange.runid, stepid: exchange.stepid, url: exchange.url, status: exchange.status, errorclass: exchange.errorclass ?? "httperror", correlationid: exchange.correlationid, at: input.at };
+function pauseall(rules, now) {
+  return rules.map((rule) => rule.state.enabled && rule.state.pausedat === void 0 ? updaterule(rule, { state: { pausedat: now } }) : rule);
 }
-function watcherdetached(input) {
-  for (const navigation of input.navigations) {
-    if (navigation >= input.startedat && navigation <= input.startedat + input.lifetime) return { detached: true, at: navigation };
-  }
-  return { detached: false };
+function resumeall(rules) {
+  return rules.map((rule) => {
+    if (rule.state.pausedat === void 0) return rule;
+    const state = { ...rule.state };
+    delete state.pausedat;
+    return { ...rule, state };
+  });
 }
-function consolediff(input) {
-  const base = input.baselines;
-  const target = input.targetlines;
-  const basemap = /* @__PURE__ */ new Map();
-  for (const line of base) basemap.set(line, (basemap.get(line) ?? 0) + 1);
-  const targetmap = /* @__PURE__ */ new Map();
-  for (const line of target) targetmap.set(line, (targetmap.get(line) ?? 0) + 1);
-  const lines = [];
-  const added = [];
-  const removed = [];
-  const repeated = [];
-  for (const [line, count] of targetmap) {
-    const basecount = basemap.get(line) ?? 0;
-    if (basecount === 0) {
-      for (let index = 0; index < count; index += 1) {
-        lines.push({ kind: "added", text: line });
-        added.push(line);
-      }
-      continue;
-    }
-    const share = Math.min(basecount, count);
-    for (let index = 0; index < share; index += 1) {
-      lines.push({ kind: "repeated", text: line, count: share });
-      repeated.push(line);
-    }
-    for (let index = share; index < count; index += 1) {
-      lines.push({ kind: "added", text: line });
-      added.push(line);
-    }
+function manualpreview(record2, now) {
+  return { id: crypto.randomUUID(), workflowid: record2.id, preview: record2.steps.map((step) => ({ stepid: step.id, kind: step.kind, label: step.label, ...step.block !== void 0 ? { block: step.block } : {}, ...controlsummary(step) !== void 0 ? { control: controlsummary(step) } : {} })), at: now };
+}
+function confirmmanualrun(preview, confirmed, now) {
+  return { ...preview, confirmed, decidedat: now };
+}
+function triggersummary(rule) {
+  return {
+    kind: rule.kind,
+    workflowid: rule.workflowid,
+    label: rule.label,
+    ...rule.origins !== void 0 ? { origins: rule.origins } : {},
+    ...rule.pattern !== void 0 ? { pattern: rule.pattern } : {},
+    ...rule.title !== void 0 ? { title: rule.title } : {},
+    ...rule.command !== void 0 ? { command: rule.command } : {},
+    ...rule.key !== void 0 ? { key: rule.key } : {},
+    ...rule.cron !== void 0 ? { cron: rule.cron, ...rule.timezone !== void 0 ? { timezone: rule.timezone } : {} } : {},
+    ...rule.period !== void 0 ? { period: rule.period, ...rule.jitter !== void 0 ? { jitter: rule.jitter } : {} } : {},
+    ...rule.urls !== void 0 ? { urls: rule.urls } : {},
+    ...rule.events !== void 0 ? { events: rule.events } : {},
+    ...rule.schema !== void 0 ? { fields: rule.schema.length } : {},
+    cooldown: rule.state.cooldown,
+    enabled: rule.state.enabled,
+    ...rule.state.nextfireat !== void 0 ? { nextfireat: rule.state.nextfireat } : {}
+  };
+}
+function ruleorigins(rule) {
+  const origins = /* @__PURE__ */ new Set();
+  for (const origin of rule.origins ?? []) origins.add(origin);
+  if (rule.pattern !== void 0) {
+    const origin = httpsorigin(rule.pattern);
+    if (origin !== void 0) origins.add(origin);
   }
-  for (const [line, count] of basemap) {
-    const targetcount = targetmap.get(line) ?? 0;
-    const missing = Math.max(0, count - targetcount);
-    for (let index = 0; index < missing; index += 1) {
-      lines.push({ kind: "removed", text: line });
-      removed.push(line);
-    }
+  for (const url of rule.urls ?? []) {
+    const origin = httpsorigin(url);
+    if (origin !== void 0) origins.add(origin);
   }
-  return { base: input.baseid, target: input.targetid, lines, added: added.length, removed: removed.length, repeated: repeated.length, at: input.now };
+  return [...origins];
+}
+function ruleoriginsgranted(rule, workfloworigins) {
+  const granted = new Set(workfloworigins);
+  return ruleorigins(rule).every((origin) => granted.has(origin));
 }
 
 // socketbus.ts
@@ -5308,38 +5738,228 @@ function polldecision(input) {
   return { continue: true, reason: "The long poll loop continues.", ...value !== void 0 ? { cursor: value } : {}, next: { ...next, wait: input.cursor.interval } };
 }
 
-// policy.ts
-var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts", "recordscreen", "captureaudio", "downloadimages", "callrest", "callgraphql", "sendmessage", "blockrequest", "mockresponse", "rewriteheaders", "setcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles", "attachcdp", "detachcdp", "cdpcmd", "overridescript", "heapshot", "profilecpu", "capturesourcemaps", "emulatedevice", "emulatenetwork", "emulatelocate", "setuseragent", "overridepermission", "restoresession", "exportsessions", "importsessions", "runworkflow"]);
-var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction", "capturebodies", "setbreakpoint", "stepcode", "watchexpr", "loop", "repeatuntil", "whileloop", "foreach", "parallel", "trycatch"]);
-var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures", "shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet", "capturepdf", "captureframe", "readmedia", "readassets", "probestream", "timelapse", "shotcanvas", "convertimage", "makethumbs", "fetchurl", "parsejson", "parsehtml", "opensocket", "waitmessage", "watchrequests", "readheaders", "mapapi", "subscribesse", "longpoll", "extractapi", "readcookies", "watchconsole", "watcherrors", "watchtasks", "watchcdp", "measureflow", "trackmemory", "watchshifts", "traceload", "annotatetrace", "replaytrace", "blackboxscripts", "persiststate", "capturesession", "namedsessions", "diffsessions", "searchsessions", "composeworkflow", "savetemplate", "dryrun", "delay", "waitelement", "compute", "extractvars", "condition", "branch"]);
-var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
-var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus", "watchtab"]);
-var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection", "submitform", "retryform", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "scrapetable", "paginateextract", "shotelement", "captureframe", "shotcanvas"]);
-var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav", "duplicatetab", "pintab", "mutetab", "movetab", "movetabwindow", "searchtabs", "badgetab", "attachmeta", "focuswindow", "maximizewindow", "minimizewindow", "restorewindow", "incognitowindow", "asksubmit", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "pausedownload", "resumedownload", "verifydownload", "writeclipboard", "quarantinedownload", "scanvirus"]);
-var tabscommandactions = /* @__PURE__ */ new Set(["querytabs", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "watchtab", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "savelayout", "restorelayout", "findclones", "searchtabs", "badgetab", "attachmeta", "listaudio", "reopenrun", "snapshotsession"]);
-var formactions = /* @__PURE__ */ new Set(["fillform", "filllabel", "fillplaceholder", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "submitform", "readerrors", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "handoffcaptcha", "fillcard", "fillcode", "consentpassword", "skiphoneypot", "detectlogin", "detecttemplate"]);
-var datasetactions = /* @__PURE__ */ new Set(["scrapetable", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "importcsv", "looprows", "transformvalues", "deduperows", "paginateextract", "mergepages", "stamplerows", "previewgrid", "streamdisk", "resumeextract", "logprovenance"]);
-var exportactions = /* @__PURE__ */ new Set(["exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk"]);
-var filesactions = /* @__PURE__ */ new Set(["batchdownload", "pausedownload", "resumedownload", "verifydownload", "interceptmime", "exportnetlog", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "namecaptures", "cleanupartifacts"]);
-var captureactions = /* @__PURE__ */ new Set(["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"]);
-var mediaactions = /* @__PURE__ */ new Set(["capturepdf", "recordscreen", "captureaudio", "captureframe", "downloadimages", "shotcanvas", "probestream", "readmedia", "readassets", "timelapse", "convertimage", "makethumbs"]);
-var httpactions = /* @__PURE__ */ new Set(["fetchurl", "parsejson", "parsehtml", "callrest", "callgraphql"]);
-var socketactions = /* @__PURE__ */ new Set(["opensocket", "sendmessage", "waitmessage", "subscribesse", "longpoll"]);
-var netwatchactions = /* @__PURE__ */ new Set(["watchrequests", "readheaders", "capturebodies", "mapapi", "extractapi"]);
-var controlactions = /* @__PURE__ */ new Set(["blockrequest", "mockresponse", "rewriteheaders", "setcookies", "readcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles"]);
-var debugactions = /* @__PURE__ */ new Set(["watchconsole", "watcherrors", "watchtasks"]);
-var cdpactions = /* @__PURE__ */ new Set(["attachcdp", "detachcdp", "cdpcmd", "watchcdp", "setbreakpoint", "stepcode", "watchexpr", "overridescript"]);
-var profileractions = /* @__PURE__ */ new Set(["measureflow", "heapshot", "trackmemory", "profilecpu", "watchshifts", "traceload", "annotatetrace", "replaytrace", "capturesourcemaps"]);
-var emulationactions = /* @__PURE__ */ new Set(["emulatedevice", "emulatenetwork", "emulatelocate", "setuseragent", "overridepermission", "blackboxscripts"]);
-var sessionactions = /* @__PURE__ */ new Set(["persiststate", "capturesession", "restoresession", "namedsessions", "diffsessions", "searchsessions", "exportsessions", "importsessions"]);
-var workflowactions = /* @__PURE__ */ new Set(["composeworkflow", "savetemplate", "runworkflow", "dryrun", "delay", "waitelement", "compute", "extractvars", "condition", "branch", "loop", "repeatuntil", "whileloop", "foreach", "parallel", "trycatch"]);
-var credentialheaders = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "cookie", "cookie2", "set-cookie", "api-key", "x-api-key", "x-auth-token", "x-session-token", "proxy-authorization"]);
-var fieldkinds = ["text", "email", "phone", "date", "number", "select", "check", "radio", "file", "password", "card", "code"];
-var layoutmutationactions = /* @__PURE__ */ new Set(["grouptabs", "colorgroup", "collapsegroup", "savelayout", "restorelayout"]);
-var groupcolors = ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"];
-function normalizeendpoint(value) {
-  const endpoint = new URL(value.trim());
-  if (endpoint.protocol !== "https:") throw new Error("Devthink accepts HTTPS endpoints only.");
+// runtimeline.ts
+var timelinekinds = ["watchconsole", "watcherrors", "watchtasks"];
+var loglevels = ["error", "warn", "info", "log", "debug", "trace"];
+var timelinesources = ["console", "error", "rejection", "resource", "longtask", "network", "cdp"];
+function levelrank(level) {
+  return loglevels.indexOf(level);
+}
+function redactconsoletext(text2, patterns) {
+  let redacted = text2;
+  for (const pattern of patterns) {
+    if (!pattern) continue;
+    while (redacted.includes(pattern)) redacted = redacted.replace(pattern, "[redacted]");
+  }
+  return redacted;
+}
+function argkind(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Error) return "error";
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "bigint":
+      return "bigint";
+    case "symbol":
+      return "symbol";
+    case "function":
+      return "function";
+    case "undefined":
+      return "undefined";
+    default:
+      return "object";
+  }
+}
+function serializearg(value, depth) {
+  const render = (item, remaining) => {
+    if (item instanceof Error) return `${item.name}: ${item.message}`;
+    if (typeof item === "string") return item;
+    if (typeof item === "function") return `[function ${item.name || "anonymous"}]`;
+    if (typeof item === "bigint") return `${item}n`;
+    if (typeof item === "symbol") return item.toString();
+    if (item === null || item === void 0 || typeof item !== "object") return String(item);
+    if (remaining <= 0) {
+      const tag = Array.isArray(item) ? "Array" : item.constructor?.name ?? "Object";
+      return `[${tag}]`;
+    }
+    if (Array.isArray(item)) return `[${item.map((entry) => render(entry, remaining - 1)).join(", ")}]`;
+    const record2 = item;
+    return `{${Object.keys(record2).map((key) => `${key}: ${render(record2[key], remaining - 1)}`).join(", ")}}`;
+  };
+  return render(value, Math.max(0, depth));
+}
+function consolecapture(input) {
+  const parts = input.args.map((arg) => serializearg(arg, input.depth));
+  return { level: input.level, text: redactconsoletext(parts.join(" "), input.redact), argkinds: input.args.map((arg) => argkind(arg)), repeat: 1 };
+}
+function stackframes(stacktext) {
+  const frames = [];
+  for (const row of stacktext.split("\n")) {
+    const trimmed = row.trim();
+    if (!trimmed.startsWith("at ")) continue;
+    const body = trimmed.slice(3).trim();
+    const location = body.match(/\(([^()]*:\d+:\d+)\)$/) ?? body.match(/^(.*:\d+:\d+)$/);
+    const located = location?.[1];
+    if (!located) continue;
+    const segments = located.split(":");
+    const column = Number.parseInt(segments.pop() ?? "", 10);
+    const lineno = Number.parseInt(segments.pop() ?? "", 10);
+    const url = segments.join(":");
+    if (!Number.isFinite(lineno) || lineno < 0) continue;
+    const name = body.endsWith(`(${located})`) ? body.slice(0, body.length - located.length - 2).trim() : "";
+    frames.push({ ...name ? { functionname: name } : {}, url, line: lineno, ...Number.isFinite(column) ? { column } : {} });
+  }
+  return frames;
+}
+function errorcapture(input) {
+  return { message: redactconsoletext(input.message, input.redact), frames: input.stacktext !== void 0 ? stackframes(input.stacktext) : [], sourceurl: input.sourceurl, line: input.line };
+}
+function rejectioncapture(input) {
+  return { reason: redactconsoletext(input.reason, input.redact), frames: input.stacktext !== void 0 ? stackframes(input.stacktext) : [] };
+}
+function longtaskcapture(input) {
+  return input.entries.filter((entry) => entry.duration >= input.threshold).map((entry) => ({ duration: Math.round(entry.duration), starttime: Math.round(entry.starttime), attributions: [...entry.attributions] }));
+}
+function attachtimeline(input) {
+  return { runid: input.runid, origin: input.origin, stepids: [...input.stepids], attachedat: input.now, entries: [] };
+}
+function filterentries(entries, levelset) {
+  return entries.filter((entry) => {
+    const floor = levelset.floors?.[entry.stepid] ?? levelset.floors?.["*"];
+    if (floor !== void 0 && levelrank(entry.level) > levelrank(floor)) return false;
+    if (levelset.sources !== void 0 && levelset.sources.length > 0 && !levelset.sources.includes(entry.source)) return false;
+    return true;
+  });
+}
+function spamdetect(entries, rule) {
+  const collapsed = [];
+  const counts = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (rule.pattern !== "" && !entry.message.includes(rule.pattern)) {
+      collapsed.push({ ...entry, repeat: 1 });
+      continue;
+    }
+    const key = `${entry.level}|${entry.source}|${entry.message}`;
+    const previous = collapsed[collapsed.length - 1];
+    if (previous && previous.repeat !== void 0 && `${previous.level}|${previous.source}|${previous.message}` === key && entry.time - previous.time <= rule.windowsize) {
+      previous.repeat += 1;
+      continue;
+    }
+    collapsed.push({ ...entry, repeat: 1 });
+  }
+  for (const entry of collapsed) {
+    if (entry.repeat > 1) counts.set(`${entry.level}|${entry.source}|${entry.message}`, entry.repeat);
+  }
+  const flagged = [...counts.entries()].filter(([, count]) => count > rule.collapse).map(([key, count]) => ({ message: key.split("|").slice(2).join("|"), count }));
+  return { entries: collapsed, flagged };
+}
+function rotatelogs(entries, rule) {
+  if (entries.length <= rule.maxentries) return { kept: [...entries], overflow: [] };
+  const kept = entries.slice(entries.length - rule.maxentries);
+  const overflow = entries.slice(0, entries.length - rule.maxentries);
+  return { kept, overflow };
+}
+function timelinecounts(entries) {
+  const counts = {};
+  for (const level of loglevels) counts[level] = 0;
+  for (const entry of entries) counts[entry.level] = (counts[entry.level] ?? 0) + 1;
+  return counts;
+}
+function blockingduration(tasks, stepid, window) {
+  const inside = tasks.filter((task) => task.starttime >= window.startedat && task.starttime <= window.endedat);
+  return { stepid, blocking: inside.reduce((total, task) => total + task.duration, 0), tasks: inside.length };
+}
+function netfailureentryof(input) {
+  const exchange = input.exchange;
+  if (exchange.errorclass === void 0 && exchange.status < 400) return null;
+  return { id: input.id, runid: exchange.runid, stepid: exchange.stepid, url: exchange.url, status: exchange.status, errorclass: exchange.errorclass ?? "httperror", correlationid: exchange.correlationid, at: input.at };
+}
+function watcherdetached(input) {
+  for (const navigation of input.navigations) {
+    if (navigation >= input.startedat && navigation <= input.startedat + input.lifetime) return { detached: true, at: navigation };
+  }
+  return { detached: false };
+}
+function consolediff(input) {
+  const base = input.baselines;
+  const target = input.targetlines;
+  const basemap = /* @__PURE__ */ new Map();
+  for (const line of base) basemap.set(line, (basemap.get(line) ?? 0) + 1);
+  const targetmap = /* @__PURE__ */ new Map();
+  for (const line of target) targetmap.set(line, (targetmap.get(line) ?? 0) + 1);
+  const lines = [];
+  const added = [];
+  const removed = [];
+  const repeated = [];
+  for (const [line, count] of targetmap) {
+    const basecount = basemap.get(line) ?? 0;
+    if (basecount === 0) {
+      for (let index = 0; index < count; index += 1) {
+        lines.push({ kind: "added", text: line });
+        added.push(line);
+      }
+      continue;
+    }
+    const share = Math.min(basecount, count);
+    for (let index = 0; index < share; index += 1) {
+      lines.push({ kind: "repeated", text: line, count: share });
+      repeated.push(line);
+    }
+    for (let index = share; index < count; index += 1) {
+      lines.push({ kind: "added", text: line });
+      added.push(line);
+    }
+  }
+  for (const [line, count] of basemap) {
+    const targetcount = targetmap.get(line) ?? 0;
+    const missing = Math.max(0, count - targetcount);
+    for (let index = 0; index < missing; index += 1) {
+      lines.push({ kind: "removed", text: line });
+      removed.push(line);
+    }
+  }
+  return { base: input.baseid, target: input.targetid, lines, added: added.length, removed: removed.length, repeated: repeated.length, at: input.now };
+}
+
+// policy.ts
+var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts", "recordscreen", "captureaudio", "downloadimages", "callrest", "callgraphql", "sendmessage", "blockrequest", "mockresponse", "rewriteheaders", "setcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles", "attachcdp", "detachcdp", "cdpcmd", "overridescript", "heapshot", "profilecpu", "capturesourcemaps", "emulatedevice", "emulatenetwork", "emulatelocate", "setuseragent", "overridepermission", "restoresession", "exportsessions", "importsessions", "runworkflow", "visitrule", "urlrule", "menurule", "keyrule", "buttonrule", "cronrule", "intervalrule", "urllistrule", "webhookrule", "eventrule"]);
+var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction", "capturebodies", "setbreakpoint", "stepcode", "watchexpr", "loop", "repeatuntil", "whileloop", "foreach", "parallel", "trycatch"]);
+var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures", "shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet", "capturepdf", "captureframe", "readmedia", "readassets", "probestream", "timelapse", "shotcanvas", "convertimage", "makethumbs", "fetchurl", "parsejson", "parsehtml", "opensocket", "waitmessage", "watchrequests", "readheaders", "mapapi", "subscribesse", "longpoll", "extractapi", "readcookies", "watchconsole", "watcherrors", "watchtasks", "watchcdp", "measureflow", "trackmemory", "watchshifts", "traceload", "annotatetrace", "replaytrace", "blackboxscripts", "persiststate", "capturesession", "namedsessions", "diffsessions", "searchsessions", "composeworkflow", "savetemplate", "dryrun", "delay", "waitelement", "compute", "extractvars", "condition", "branch"]);
+var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
+var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus", "watchtab"]);
+var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection", "submitform", "retryform", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "scrapetable", "paginateextract", "shotelement", "captureframe", "shotcanvas"]);
+var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav", "duplicatetab", "pintab", "mutetab", "movetab", "movetabwindow", "searchtabs", "badgetab", "attachmeta", "focuswindow", "maximizewindow", "minimizewindow", "restorewindow", "incognitowindow", "asksubmit", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "pausedownload", "resumedownload", "verifydownload", "writeclipboard", "quarantinedownload", "scanvirus"]);
+var tabscommandactions = /* @__PURE__ */ new Set(["querytabs", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "watchtab", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "savelayout", "restorelayout", "findclones", "searchtabs", "badgetab", "attachmeta", "listaudio", "reopenrun", "snapshotsession"]);
+var formactions = /* @__PURE__ */ new Set(["fillform", "filllabel", "fillplaceholder", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "submitform", "readerrors", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "handoffcaptcha", "fillcard", "fillcode", "consentpassword", "skiphoneypot", "detectlogin", "detecttemplate"]);
+var datasetactions = /* @__PURE__ */ new Set(["scrapetable", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "importcsv", "looprows", "transformvalues", "deduperows", "paginateextract", "mergepages", "stamplerows", "previewgrid", "streamdisk", "resumeextract", "logprovenance"]);
+var exportactions = /* @__PURE__ */ new Set(["exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk"]);
+var filesactions = /* @__PURE__ */ new Set(["batchdownload", "pausedownload", "resumedownload", "verifydownload", "interceptmime", "exportnetlog", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "namecaptures", "cleanupartifacts"]);
+var captureactions = /* @__PURE__ */ new Set(["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"]);
+var mediaactions = /* @__PURE__ */ new Set(["capturepdf", "recordscreen", "captureaudio", "captureframe", "downloadimages", "shotcanvas", "probestream", "readmedia", "readassets", "timelapse", "convertimage", "makethumbs"]);
+var httpactions = /* @__PURE__ */ new Set(["fetchurl", "parsejson", "parsehtml", "callrest", "callgraphql"]);
+var socketactions = /* @__PURE__ */ new Set(["opensocket", "sendmessage", "waitmessage", "subscribesse", "longpoll"]);
+var netwatchactions = /* @__PURE__ */ new Set(["watchrequests", "readheaders", "capturebodies", "mapapi", "extractapi"]);
+var controlactions = /* @__PURE__ */ new Set(["blockrequest", "mockresponse", "rewriteheaders", "setcookies", "readcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles"]);
+var debugactions = /* @__PURE__ */ new Set(["watchconsole", "watcherrors", "watchtasks"]);
+var cdpactions = /* @__PURE__ */ new Set(["attachcdp", "detachcdp", "cdpcmd", "watchcdp", "setbreakpoint", "stepcode", "watchexpr", "overridescript"]);
+var profileractions = /* @__PURE__ */ new Set(["measureflow", "heapshot", "trackmemory", "profilecpu", "watchshifts", "traceload", "annotatetrace", "replaytrace", "capturesourcemaps"]);
+var emulationactions = /* @__PURE__ */ new Set(["emulatedevice", "emulatenetwork", "emulatelocate", "setuseragent", "overridepermission", "blackboxscripts"]);
+var sessionactions = /* @__PURE__ */ new Set(["persiststate", "capturesession", "restoresession", "namedsessions", "diffsessions", "searchsessions", "exportsessions", "importsessions"]);
+var workflowactions = /* @__PURE__ */ new Set(["composeworkflow", "savetemplate", "runworkflow", "dryrun", "delay", "waitelement", "compute", "extractvars", "condition", "branch", "loop", "repeatuntil", "whileloop", "foreach", "parallel", "trycatch"]);
+var triggeractions = /* @__PURE__ */ new Set(["visitrule", "urlrule", "menurule", "keyrule", "buttonrule", "cronrule", "intervalrule", "urllistrule", "webhookrule", "eventrule"]);
+var credentialheaders = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "cookie", "cookie2", "set-cookie", "api-key", "x-api-key", "x-auth-token", "x-session-token", "proxy-authorization"]);
+var fieldkinds = ["text", "email", "phone", "date", "number", "select", "check", "radio", "file", "password", "card", "code"];
+var layoutmutationactions = /* @__PURE__ */ new Set(["grouptabs", "colorgroup", "collapsegroup", "savelayout", "restorelayout"]);
+var groupcolors = ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"];
+function normalizeendpoint(value) {
+  const endpoint = new URL(value.trim());
+  if (endpoint.protocol !== "https:") throw new Error("Devthink accepts HTTPS endpoints only.");
   if (endpoint.username || endpoint.password) throw new Error("Endpoint credentials are not allowed in the URL.");
   return { endpoint: endpoint.toString(), origin: endpoint.origin, configuredat: Date.now() };
 }
@@ -5354,6 +5974,9 @@ function issessionkind(kind) {
 function isworkflowkind(kind) {
   return workflowactions.has(kind);
 }
+function istriggeraction(kind) {
+  return triggeractions.has(kind);
+}
 function iswatchkind(kind) {
   return watchactions.has(kind);
 }
@@ -7028,6 +7651,79 @@ function workflowgate(input) {
   }
   return { allowed: true };
 }
+function validatetriggergrammar(step, options) {
+  const family = triggerfamilyof(step.kind);
+  if (family === void 0) return { allowed: false, reason: "The trigger step is not a reviewed trigger kind." };
+  if (typeof options.workflowid !== "string" || !options.workflowid.trim()) return { allowed: false, reason: "Every trigger rule needs the reviewed id of the composed workflow it launches." };
+  if (options.reviewed !== true) return { allowed: false, reason: "Every trigger rule needs the explicit arm review with its match fields and bound workflow shown before it arms." };
+  if (options.label !== void 0 && (typeof options.label !== "string" || !options.label.trim())) return { allowed: false, reason: "The reviewed trigger label must be a non-empty string." };
+  if (options.cooldown !== void 0 && (typeof options.cooldown !== "number" || !Number.isFinite(options.cooldown) || options.cooldown <= 0)) return { allowed: false, reason: "The reviewed cooldown window must be a positive number of milliseconds with no code ceiling; the webhook and event families keep the documented default when the review configures none." };
+  const payload = options.rule;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return { allowed: false, reason: `The ${step.kind} step needs its reviewed rule payload in options.` };
+  if (triggerpayloadof(family, payload) === void 0) {
+    if (family === "visit") return { allowed: false, reason: "The visit rule needs a non-empty reviewed list of HTTPS origins it fires on." };
+    if (family === "url") return { allowed: false, reason: "The url rule needs a reviewed HTTPS glob url pattern; `*` spans one path segment and `**` spans across segments." };
+    if (family === "menu") return { allowed: false, reason: "The menu rule needs a reviewed non-empty context menu entry title." };
+    if (family === "key") return { allowed: false, reason: "The keyboard shortcut rule needs a reviewed lowercase command name and an optional suggested key binding." };
+    if (family === "cron") return { allowed: false, reason: "The cron rule needs a reviewed five field cron expression of minutes, hours, days, months and weekdays with named weekdays and months and an optional resolvable timezone; unparseable schedules are refused." };
+    if (family === "interval") return { allowed: false, reason: "The interval rule needs a reviewed positive period in milliseconds with an optional zero or positive jitter window." };
+    if (family === "urllist") return { allowed: false, reason: "The url list rule needs a reviewed non-empty list of HTTPS urls its workflow runs across." };
+    if (family === "webhook") return { allowed: false, reason: `The webhook rule needs a reviewed shared secret of at least twenty four characters mixing letters and digits and a non-empty payload schema of named string, number or boolean fields.` };
+    if (family === "event") return { allowed: false, reason: `The page event rule needs a reviewed non-empty list of event names of the observed event catalog: ${triggereventcatalog.join(", ")}.` };
+    return { allowed: false, reason: "The trigger rule payload does not follow its family grammar." };
+  }
+  if (family === "cron") {
+    const candidate = payload;
+    if (typeof candidate.cron === "string" && cronparse(candidate.cron) === void 0) return { allowed: false, reason: "The cron expression does not parse as a five field schedule and is refused." };
+  }
+  if (family === "webhook") {
+    const candidate = payload;
+    if (typeof candidate.secret === "string" && !webhooksecretok(candidate.secret)) return { allowed: false, reason: "The webhook shared secret must hold at least twenty four characters mixing letters and digits; the entropy floor is a floor, never a cap." };
+  }
+  const armed = armrule({ family, workflowid: options.workflowid, ...typeof options.label === "string" && options.label.trim() ? { label: options.label } : {}, payload, ...typeof options.cooldown === "number" ? { cooldown: options.cooldown } : {}, now: 0 });
+  if (armed === void 0) return { allowed: false, reason: "The trigger rule payload does not arm as a reviewed rule." };
+  return { allowed: true };
+}
+function triggergate(input) {
+  const gate = sessiongate({ session: input.session, tabid: input.tabid, origin: input.origin, now: input.now, action: "arm the trigger rule" });
+  if (!gate.allowed) return gate;
+  if (!input.plan || input.plan.state !== "approved") return { allowed: false, reason: "Trigger rules need the approved plan review before they arm." };
+  let triggeroptions = {};
+  try {
+    triggeroptions = parseoptions(input.step);
+  } catch {
+    triggeroptions = {};
+  }
+  if (triggeroptions.reviewed !== true) return { allowed: false, reason: "Every trigger rule needs the explicit arm review with its match fields and bound workflow shown before it arms." };
+  return { allowed: true };
+}
+function triggerorigins(step) {
+  let triggeroptions = {};
+  try {
+    triggeroptions = parseoptions(step);
+  } catch {
+    return [];
+  }
+  const family = triggerfamilyof(step.kind);
+  if (family === void 0) return [];
+  const armed = armrule({ family, workflowid: typeof triggeroptions.workflowid === "string" ? triggeroptions.workflowid : "", payload: triggeroptions.rule, ...typeof triggeroptions.cooldown === "number" ? { cooldown: triggeroptions.cooldown } : {}, now: 0 });
+  if (armed === void 0) return [];
+  const origins = [];
+  for (const origin of armed.origins ?? []) origins.push(origin);
+  if (armed.pattern !== void 0) {
+    try {
+      origins.push(new URL(armed.pattern).origin);
+    } catch {
+    }
+  }
+  for (const url of armed.urls ?? []) {
+    try {
+      origins.push(new URL(url).origin);
+    } catch {
+    }
+  }
+  return [...new Set(origins)];
+}
 function dryrunprojection(step) {
   if (iscontrolflowkind(step.kind)) {
     for (const child of controlsteps(step)) {
@@ -7624,6 +8320,10 @@ function validatestep(step, origin) {
     const workflowcheck = validateworkflowgrammar(step, options);
     if (!workflowcheck.allowed) return workflowcheck;
   }
+  if (istriggeraction(step.kind)) {
+    const triggercheck = validatetriggergrammar(step, options);
+    if (!triggercheck.allowed) return triggercheck;
+  }
   if (step.kind === "tabcreate") {
     if (options.background !== void 0 && typeof options.background !== "boolean") return { allowed: false, reason: "The reviewed background flag must be a boolean." };
     if (options.window !== void 0 && (typeof options.window !== "number" || !Number.isInteger(options.window) || options.window < 0)) return { allowed: false, reason: "The reviewed target window id must be a non-negative integer." };
@@ -7818,6 +8518,10 @@ function canexecute(input) {
     const workflowgatecheck = workflowgate({ session: input.session, plan: input.plan, step: input.step, tabid: input.tabid, origin: input.origin, now });
     if (!workflowgatecheck.allowed) return workflowgatecheck;
   }
+  if (istriggeraction(input.step.kind)) {
+    const triggergatecheck = triggergate({ session: input.session, plan: input.plan, step: input.step, tabid: input.tabid, origin: input.origin, now });
+    if (!triggergatecheck.allowed) return triggergatecheck;
+  }
   if (iscontrolkind(input.step.kind)) {
     const controlgate = sessiongate({ session: input.session, tabid: input.tabid, origin: input.origin, now, action: "control the network" });
     if (!controlgate.allowed) return controlgate;
@@ -7899,9 +8603,137 @@ function canexecute(input) {
   }
   return validatestep(input.step, input.origin);
 }
+function reviewedkinds() {
+  return [...allowedactions].sort();
+}
+function editorsavegate(input) {
+  const gate = sessiongate({ session: input.session, tabid: input.session?.tabid ?? 0, origin: input.session?.origin ?? "https://example.com", now: input.now, action: "save the workflow editor canvas" });
+  if (!gate.allowed) return gate;
+  if (!input.plan || input.plan.state !== "approved") return { allowed: false, reason: "Editor saves need the approved plan review before a new workflow version composes." };
+  const model = input.model;
+  if (typeof model.name !== "string" || !model.name.trim()) return { allowed: false, reason: "The workflow name of the canvas must be a non-empty string." };
+  if (typeof model.version !== "number" || !Number.isInteger(model.version) || model.version < 1) return { allowed: false, reason: "The workflow version of the canvas must be a positive integer." };
+  if (!Array.isArray(model.origins) || model.origins.length === 0) return { allowed: false, reason: "The canvas needs at least one granted HTTPS origin." };
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of model.nodes) {
+    if (node.step === void 0 === (node.invocation === void 0)) return { allowed: false, reason: "Every canvas node must be exactly one workflow step or one block invocation." };
+    const id = node.id ?? (node.step !== void 0 ? node.step.id : node.invocation.block);
+    if (!id || ids.has(id)) return { allowed: false, reason: `The canvas node id ${id || "(empty)"} must be unique.` };
+    ids.add(id);
+  }
+  const reachable = /* @__PURE__ */ new Set();
+  for (const node of model.nodes) {
+    if (node.step !== void 0) {
+      reachable.add(node.step.id);
+      continue;
+    }
+    const walk = (entries) => {
+      for (const entry of entries) {
+        if (typeof entry.id === "string" && typeof entry.kind === "string") {
+          reachable.add(entry.id);
+          continue;
+        }
+        if (typeof entry.block === "string") {
+          const nested = model.blocks.find((candidate) => candidate.name === entry.block);
+          if (nested) walk(nested.steps);
+        }
+      }
+    };
+    const block = model.blocks.find((candidate) => candidate.name === node.invocation.block);
+    if (!block) return { allowed: false, reason: `The block ${node.invocation.block} of the canvas has no definition.` };
+    walk(block.steps);
+  }
+  let order = 0;
+  const positionof = /* @__PURE__ */ new Map();
+  for (const node of model.nodes) {
+    if (node.step !== void 0) {
+      positionof.set(node.step.id, order);
+      order += 1;
+      continue;
+    }
+    const walk = (entries) => {
+      for (const entry of entries) {
+        if (typeof entry.id === "string" && typeof entry.kind === "string") {
+          positionof.set(entry.id, order);
+          order += 1;
+          continue;
+        }
+        if (typeof entry.block === "string") {
+          const nested = model.blocks.find((candidate) => candidate.name === entry.block);
+          if (nested) walk(nested.steps);
+        }
+      }
+    };
+    walk(model.blocks.find((candidate) => candidate.name === node.invocation.block).steps);
+  }
+  for (const edge of model.edges) {
+    if (!reachable.has(edge.from)) return { allowed: false, reason: `The canvas edge of ${edge.variable} references the unknown source step ${edge.from}.` };
+    if (!reachable.has(edge.to)) return { allowed: false, reason: `The canvas edge of ${edge.variable} references the unknown target step ${edge.to}.` };
+    if ((positionof.get(edge.from) ?? -1) >= (positionof.get(edge.to) ?? -1)) return { allowed: false, reason: `The canvas edge of ${edge.variable} runs backwards and would form a cycle.` };
+  }
+  return { allowed: true };
+}
+function runreviewgranted(record2) {
+  if (record2.reviewstate === "pending") return { allowed: false, reason: "The workflow stays unreviewed: the import or rollback review must approve its expanded step list before any run." };
+  return { allowed: true };
+}
+var overrideknobs = ["loopbound", "stepms", "runms", "waitms", "delaybase"];
+function validatesiteoverride(override) {
+  if (typeof override.pattern !== "string" || !override.pattern.startsWith("https://") || !/[a-z0-9.-]+/i.test(override.pattern.slice(8))) return { allowed: false, reason: "The override pattern must be an https origin or a `*` subdomain glob of one." };
+  if (!override.pattern.includes("*")) {
+    try {
+      if (new URL(override.pattern).origin !== override.pattern) return { allowed: false, reason: "The override pattern must be a bare https origin or a `*` subdomain glob, never a path." };
+    } catch {
+      return { allowed: false, reason: "The override pattern must parse as an https origin or a `*` subdomain glob of one." };
+    }
+  }
+  for (const [knob, delta] of Object.entries(override.deltas)) {
+    if (!overrideknobs.includes(knob)) return { allowed: false, reason: `The override knob ${knob} is not one of the reviewed knobs: ${overrideknobs.join(", ")}.` };
+    if (typeof delta !== "number" || !Number.isFinite(delta) || delta <= 0) return { allowed: false, reason: `The override delta of ${knob} must be a positive user value with no code ceiling.` };
+  }
+  return { allowed: true };
+}
+function exportcontentreview(file) {
+  const secretkeys = /(secret|token|apikey|api_key|password|authorization|credential)/i;
+  const scan = (label, options) => {
+    if (options === void 0) return void 0;
+    let payload;
+    try {
+      payload = JSON.parse(options);
+    } catch {
+      return void 0;
+    }
+    const walk = (value, path) => {
+      if (!value || typeof value !== "object") return void 0;
+      for (const [key, entry] of Object.entries(value)) {
+        if (secretkeys.test(key)) return { allowed: false, reason: `The export of ${label} carries the secret field ${path}${key} and secrets never leave the browser.` };
+        const nested = walk(entry, `${path}${key}.`);
+        if (nested !== void 0) return nested;
+      }
+      return void 0;
+    };
+    return walk(payload, "");
+  };
+  for (const step of file.workflow.steps) {
+    const refusal = scan(`the step ${step.id}`, step.options);
+    if (refusal !== void 0) return refusal;
+  }
+  for (const template of file.templates) {
+    const refusal = scan(`the template ${template.name}`, template.step.options);
+    if (refusal !== void 0) return refusal;
+  }
+  return { allowed: true };
+}
+function watchdogconfigvalid(config) {
+  if (typeof config.enabled !== "boolean") return { allowed: false, reason: "The watchdog enabled flag must be a boolean." };
+  if (typeof config.stallthreshold !== "number" || !Number.isFinite(config.stallthreshold) || config.stallthreshold <= 0) return { allowed: false, reason: "The watchdog stall threshold must be a positive number of milliseconds with no code ceiling." };
+  if (!["retry", "pause", "cancel"].includes(config.action)) return { allowed: false, reason: "The watchdog recovery action must be retry, pause or cancel." };
+  if (config.zombiewindow !== void 0 && (typeof config.zombiewindow !== "number" || !Number.isFinite(config.zombiewindow) || config.zombiewindow <= 0)) return { allowed: false, reason: "The watchdog zombie window, when configured, must be a positive number of milliseconds with no code ceiling." };
+  return { allowed: true };
+}
 
 // version.ts
-var packageversion = "1.1.51";
+var packageversion = "1.1.53";
 
 // types.ts
 var protocolversion = packageversion;
@@ -8140,6 +8972,25 @@ function parseproposal(value, origin, grants) {
       }
       if (step.kind === "runworkflow" && workflowoptions.reviewed !== true) throw new Error("Workflow runs without the explicit run review of the expanded step list are refused.");
     }
+    if (istriggeraction(step.kind)) {
+      let triggeroptions = {};
+      try {
+        triggeroptions = parseoptions(step);
+      } catch {
+        triggeroptions = {};
+      }
+      if (triggeroptions.reviewed !== true) throw new Error("Trigger rules without the explicit arm review of their match fields and bound workflow are refused.");
+      for (const ruleorigin of triggerorigins(step)) {
+        const granted = covered.some((pattern) => {
+          try {
+            return new URL(ruleorigin).origin === new URL(pattern).origin;
+          } catch {
+            return false;
+          }
+        });
+        if (!granted) throw new Error(`The trigger on ${ruleorigin} stays outside the grants.`);
+      }
+    }
     const evaluation = validatestep(step, origin);
     if (!evaluation.allowed) throw new Error(evaluation.reason);
     const target = outboundtarget(step);
@@ -8282,7 +9133,7 @@ function requestbody(input) {
   return JSON.stringify({ version: protocolversion, objective: input.objective, session: input.session, observation: input.observation, capabilities: input.capabilities });
 }
 function outcomeresponse(input) {
-  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {}, ...input.capture ? { capture: input.capture } : {}, ...input.media ? { media: input.media } : {}, ...input.transport ? { transport: input.transport } : {}, ...input.network ? { network: input.network } : {}, ...input.control ? { control: input.control } : {}, ...input.timeline ? { timeline: input.timeline } : {}, ...input.cdp ? { cdp: input.cdp } : {}, ...input.profile ? { profile: input.profile } : {}, ...input.emulation ? { emulation: input.emulation } : {}, ...input.session ? { session: input.session } : {}, ...input.workflow ? { workflow: { runid: input.workflow.runid, state: input.workflow.state, ...input.workflow.dryrun === true ? { dryrun: true } : {}, produced: input.workflow.produced, consumed: input.workflow.consumed, ...input.workflow.timeout !== void 0 ? { timeout: input.workflow.timeout } : {}, ...input.workflow.retry !== void 0 ? { retry: input.workflow.retry } : {} } } : {} });
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {}, ...input.capture ? { capture: input.capture } : {}, ...input.media ? { media: input.media } : {}, ...input.transport ? { transport: input.transport } : {}, ...input.network ? { network: input.network } : {}, ...input.control ? { control: input.control } : {}, ...input.timeline ? { timeline: input.timeline } : {}, ...input.cdp ? { cdp: input.cdp } : {}, ...input.profile ? { profile: input.profile } : {}, ...input.emulation ? { emulation: input.emulation } : {}, ...input.session ? { session: input.session } : {}, ...input.workflow ? { workflow: { runid: input.workflow.runid, state: input.workflow.state, ...input.workflow.dryrun === true ? { dryrun: true } : {}, produced: input.workflow.produced, consumed: input.workflow.consumed, ...input.workflow.timeout !== void 0 ? { timeout: input.workflow.timeout } : {}, ...input.workflow.retry !== void 0 ? { retry: input.workflow.retry } : {} } } : {}, ...input.trigger ? { trigger: { ruleid: input.trigger.ruleid, kind: input.trigger.kind, enabled: input.trigger.enabled, ...input.trigger.nextfireat !== void 0 ? { nextfireat: input.trigger.nextfireat } : {} } } : {} });
 }
 function mapresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
@@ -8434,8 +9285,789 @@ function sessionreport(input) {
 function workflowreport(input) {
   return { version: protocolversion, workflows: input.workflows, runs: input.runs, templates: input.templates, log: input.log ?? [], scopes: input.scopes ?? [], provenance: input.provenance ?? [], control: input.control ?? [] };
 }
+function triggerlist(input) {
+  const names = new Map(input.workflows.map((record2) => [record2.id, record2.name]));
+  const rules = input.rules.map((rule) => {
+    const workflowname = names.get(rule.workflowid);
+    return {
+      id: rule.id,
+      kind: rule.kind,
+      workflowid: rule.workflowid,
+      ...workflowname !== void 0 ? { workflowname } : {},
+      label: rule.label,
+      enabled: rule.state.enabled,
+      ...rule.state.pausedat !== void 0 ? { paused: true } : {},
+      cooldown: rule.state.cooldown,
+      ...rule.state.lastfireat !== void 0 ? { lastfireat: rule.state.lastfireat } : {},
+      ...rule.state.nextfireat !== void 0 ? { nextfireat: rule.state.nextfireat } : {},
+      fires: rule.stats.fires,
+      launches: rule.stats.launches,
+      suppressions: rule.stats.suppressions,
+      summary: triggersummaryof(rule)
+    };
+  });
+  return { version: protocolversion, rules, queued: (input.queue ?? []).length };
+}
+function triggersummaryof(rule) {
+  const summary = { kind: rule.kind, workflowid: rule.workflowid };
+  if (rule.origins !== void 0) summary.origins = rule.origins;
+  if (rule.pattern !== void 0) summary.pattern = rule.pattern;
+  if (rule.title !== void 0) summary.title = rule.title;
+  if (rule.command !== void 0) summary.command = rule.command;
+  if (rule.key !== void 0) summary.key = rule.key;
+  if (rule.cron !== void 0) summary.cron = rule.cron;
+  if (rule.timezone !== void 0) summary.timezone = rule.timezone;
+  if (rule.period !== void 0) summary.period = rule.period;
+  if (rule.jitter !== void 0) summary.jitter = rule.jitter;
+  if (rule.urls !== void 0) summary.urls = rule.urls;
+  if (rule.events !== void 0) summary.events = rule.events;
+  if (rule.schema !== void 0) summary.fields = rule.schema.length;
+  return summary;
+}
+function triggerfired(input) {
+  return { version: protocolversion, triggerfired: { fireid: input.fire.id, ruleid: input.fire.ruleid, workflowid: input.workflowid, at: input.fire.at, cause: input.fire.cause, ...input.fire.url !== void 0 ? { url: input.fire.url } : {}, ...input.fire.title !== void 0 ? { title: input.fire.title } : {}, ...input.runid !== void 0 ? { runid: input.runid } : {} } };
+}
+function manualrunpreview(input) {
+  return { version: protocolversion, manualrun: input.preview, ...input.workflowname !== void 0 ? { workflowname: input.workflowname } : {} };
+}
+var workflowfileversion = 1;
+function editorstate(input) {
+  const editor = { versions: input.versions, diffs: input.diffs ?? [], history: input.history, breakpoints: input.breakpoints ?? [], overrides: input.overrides, imports: input.imports, backgroundruns: input.backgroundruns ?? {}, watchdog: { ...input.watchdog.config !== void 0 ? { config: input.watchdog.config } : {}, events: input.watchdog.events } };
+  return { version: protocolversion, editor, ...input.model !== void 0 ? { model: input.model } : {} };
+}
+function runhistoryquery(value) {
+  if (value === void 0 || value === null) return {};
+  const candidate = record(value);
+  const query = {};
+  if (candidate.workflowid !== void 0) {
+    if (typeof candidate.workflowid !== "string" || !candidate.workflowid.trim()) throw new Error("The run history workflow filter must be a non-empty string.");
+    query.workflowid = candidate.workflowid;
+  }
+  if (candidate.outcome !== void 0) {
+    if (typeof candidate.outcome !== "string" || !candidate.outcome.trim()) throw new Error("The run history outcome filter must be a non-empty string.");
+    query.outcome = candidate.outcome;
+  }
+  if (candidate.since !== void 0) {
+    if (typeof candidate.since !== "number" || !Number.isFinite(candidate.since)) throw new Error("The run history time floor must be a finite timestamp.");
+    query.since = candidate.since;
+  }
+  if (candidate.limit !== void 0) {
+    if (typeof candidate.limit !== "number" || !Number.isInteger(candidate.limit) || candidate.limit < 1) throw new Error("The run history entry count must be a positive integer with no code ceiling.");
+    query.limit = candidate.limit;
+  }
+  return query;
+}
+function runhistoryreport(input) {
+  return { version: protocolversion, entries: input.entries, query: input.query ?? {} };
+}
+
+// workfloweditor.ts
+var palettecategories = ["actions", "controlflow", "waits", "variables", "triggers"];
+var palettenodes = [
+  { kind: "click", label: "Click an element", category: "actions", description: "Clicks the reviewed selector target." },
+  { kind: "type", label: "Type text", category: "actions", description: "Types the reviewed text into the target field." },
+  { kind: "navigate", label: "Navigate", category: "actions", description: "Navigates the tab to the reviewed url." },
+  { kind: "readtext", label: "Read text", category: "actions", description: "Reads the text of the target element." },
+  { kind: "scrapetable", label: "Scrape a table", category: "actions", description: "Extracts the reviewed table into a dataset." },
+  { kind: "fillform", label: "Fill a form", category: "actions", description: "Fills the reviewed form fields from a saved profile." },
+  { kind: "querytabs", label: "Query tabs", category: "actions", description: "Lists the tabs matching the reviewed query." },
+  { kind: "fetchurl", label: "Fetch a url", category: "actions", description: "Fetches the reviewed endpoint behind the call consent." },
+  { kind: "condition", label: "Condition", category: "controlflow", description: "Evaluates one reviewed boolean expression with no page side effect." },
+  { kind: "branch", label: "Branch", category: "controlflow", description: "Chooses one reviewed path by page state with a mandatory else path." },
+  { kind: "loop", label: "Loop a list", category: "controlflow", description: "Iterates a list variable binding the item and index per pass." },
+  { kind: "repeatuntil", label: "Repeat until", category: "controlflow", description: "Reruns the body until the convergence expression holds." },
+  { kind: "whileloop", label: "While loop", category: "controlflow", description: "Loops while the condition holds inside the reviewed bound." },
+  { kind: "foreach", label: "For each element", category: "controlflow", description: "Iterates the elements of the reviewed selector." },
+  { kind: "parallel", label: "Parallel branches", category: "controlflow", description: "Runs branches concurrently and joins them under the reviewed strategy." },
+  { kind: "trycatch", label: "Try catch", category: "controlflow", description: "Wraps fragile steps with a catch handler, retries and timeouts." },
+  { kind: "delay", label: "Delay", category: "waits", description: "Sleeps the reviewed base inside the jitter window." },
+  { kind: "waitelement", label: "Wait for element", category: "waits", description: "Polls the reviewed selector until appearance or timeout." },
+  { kind: "wait", label: "Wait", category: "waits", description: "Waits the reviewed duration." },
+  { kind: "waitfor", label: "Wait for target", category: "waits", description: "Waits until the reviewed target exists." },
+  { kind: "waittext", label: "Wait for text", category: "waits", description: "Waits until the reviewed text appears." },
+  { kind: "waitquiet", label: "Wait for quiet", category: "waits", description: "Waits until the page stops mutating." },
+  { kind: "waitload", label: "Wait for load", category: "waits", description: "Waits until the navigation settles." },
+  { kind: "compute", label: "Compute", category: "variables", description: "Evaluates one reviewed expression into the result variable." },
+  { kind: "extractvars", label: "Extract variables", category: "variables", description: "Applies the reviewed regex and stores the named captures." },
+  { kind: "savetemplate", label: "Save template", category: "variables", description: "Shares the reviewed step as a reusable template." },
+  { kind: "visitrule", label: "Visit rule", category: "triggers", description: "Fires on navigations to the reviewed origins." },
+  { kind: "urlrule", label: "Url rule", category: "triggers", description: "Fires when the url matches the reviewed glob pattern." },
+  { kind: "cronrule", label: "Cron rule", category: "triggers", description: "Fires on the reviewed five field cron schedule." },
+  { kind: "intervalrule", label: "Interval rule", category: "triggers", description: "Fires every reviewed period with the jitter spread." },
+  { kind: "webhookrule", label: "Webhook rule", category: "triggers", description: "Fires on a secret verified webhook delivery." },
+  { kind: "eventrule", label: "Event rule", category: "triggers", description: "Fires on the observed page events of the catalog." }
+];
+var optionschemas = {
+  delay: [{ name: "base", kind: "number", required: true }, { name: "jitter", kind: "number" }],
+  waitelement: [{ name: "timeout", kind: "number" }, { name: "poll", kind: "number" }],
+  compute: [{ name: "expression", kind: "string", required: true }],
+  extractvars: [{ name: "rule", kind: "string", required: true }],
+  composeworkflow: [{ name: "name", kind: "string", required: true }, { name: "version", kind: "number" }],
+  runworkflow: [{ name: "workflowid", kind: "string", required: true }, { name: "reviewed", kind: "boolean", required: true }, { name: "variables", kind: "string" }, { name: "background", kind: "boolean" }],
+  dryrun: [{ name: "workflowid", kind: "string", required: true }],
+  loop: [{ name: "loop", kind: "string", required: true }],
+  repeatuntil: [{ name: "repeatuntil", kind: "string", required: true }],
+  whileloop: [{ name: "whileloop", kind: "string", required: true }],
+  foreach: [{ name: "foreach", kind: "string", required: true }],
+  parallel: [{ name: "parallel", kind: "string", required: true }],
+  trycatch: [{ name: "trycatch", kind: "string", required: true }]
+};
+function stepcategory(kind) {
+  if (triggerkinds.includes(kind)) return "triggers";
+  if (controlflowkinds.includes(kind)) return "controlflow";
+  if (kind.startsWith("wait") || kind === "spawait" || kind === "delay") return "waits";
+  if (kind === "compute" || kind === "extractvars" || kind === "savetemplate") return "variables";
+  return "actions";
+}
+function buildsteplibrary(kinds) {
+  return [...new Set(kinds)].sort().map((kind) => ({ kind, category: stepcategory(kind), optionschema: optionschemas[kind] ?? [] }));
+}
+var noderowheight = 96;
+var blockcolumnwidth = 280;
+var canvasoriginx = 40;
+function snapshotof(model) {
+  const { undo, redo, dirty, ...rest } = model;
+  void undo;
+  void redo;
+  void dirty;
+  return { ...rest, dirty: true };
+}
+function withundo(model, next) {
+  const undo = [...model.undo ?? [], snapshotof(model)];
+  const { redo, ...rest } = next;
+  void redo;
+  return { ...rest, dirty: true, undo };
+}
+function nodeidof(node) {
+  return node.id ?? (node.step !== void 0 ? node.step.id : node.invocation !== void 0 ? node.invocation.block : "");
+}
+function layoutsizeof(nodes) {
+  const width = Math.max(640, ...nodes.map((node) => node.x + blockcolumnwidth)) + 40;
+  const height = Math.max(480, ...nodes.map((node) => node.y + noderowheight)) + 40;
+  return { width, height };
+}
+function loadworkflow(record2, layout) {
+  const blocks = record2.blocks.map((block) => ({ ...block, steps: block.steps.map((entry) => ({ ...entry })) }));
+  const blockcolumn = (blockname) => {
+    const index2 = blocks.findIndex((block) => block.name === blockname);
+    return index2 < 0 ? canvasoriginx : canvasoriginx + (index2 + 1) * blockcolumnwidth;
+  };
+  const invocationcount = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const edges = [];
+  let index = 0;
+  while (index < record2.steps.length) {
+    const step = record2.steps[index];
+    for (const binding of step.bindings ?? []) edges.push({ from: binding.stepid, to: step.id, variable: binding.variable, kind: binding.kind, ...binding.path !== void 0 ? { path: binding.path } : {} });
+    if (step.block === void 0) {
+      const { bindings, block, params: params2, ...rest } = step;
+      void bindings;
+      void block;
+      void params2;
+      nodes.push({ step: { ...rest }, x: canvasoriginx, y: 60 + nodes.length * noderowheight });
+      index += 1;
+      continue;
+    }
+    const blockname = step.block;
+    let end = index;
+    while (end < record2.steps.length && record2.steps[end].block === blockname) end += 1;
+    const region = record2.steps.slice(index, end);
+    const count = (invocationcount.get(blockname) ?? 0) + 1;
+    invocationcount.set(blockname, count);
+    const params = region.flatMap((entry) => entry.params ?? []);
+    nodes.push({ id: count === 1 ? blockname : `${blockname}${count}`, invocation: { block: blockname, label: blockname, ...params.length > 0 ? { params: params.map((param) => ({ ...param })) } : {} }, x: blockcolumn(blockname), y: 60 + nodes.length * noderowheight });
+    index = end;
+  }
+  const size = layouttypeof(nodes, layout);
+  const model = { workflowid: record2.id, name: record2.name, version: record2.version, origins: [...record2.origins], nodes, edges, blocks, layout: size, minimap: emptyminimap(), dirty: false };
+  return { ...model, minimap: renderminimap(model).minimap };
+}
+function layouttypeof(nodes, layout) {
+  const size = layoutsizeof(nodes);
+  if (!layout) return { width: size.width, height: size.height, viewportx: 0, viewporty: 0, zoom: 1 };
+  return { width: Math.max(size.width, layout.width), height: Math.max(size.height, layout.height), viewportx: layout.viewportx, viewporty: layout.viewporty, zoom: layout.zoom };
+}
+function emptyminimap() {
+  return { width: 160, height: 100, scale: 0, zoom: 1, viewport: { x: 0, y: 0, width: 0, height: 0 } };
+}
+function saveworkflow(model, input) {
+  if (typeof model.name !== "string" || !model.name.trim()) throw new Error("The workflow name must be a non-empty string.");
+  if (typeof model.version !== "number" || !Number.isInteger(model.version) || model.version < 1) throw new Error("The workflow version must be a positive integer.");
+  if (!Array.isArray(model.origins) || model.origins.length === 0) throw new Error("A workflow needs at least one granted HTTPS origin.");
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of model.nodes) {
+    if (node.step === void 0 === (node.invocation === void 0)) throw new Error("Every canvas node must be exactly one workflow step or one block invocation.");
+    const id = nodeidof(node);
+    if (!id || ids.has(id)) throw new Error(`The canvas node id ${id || "(empty)"} must be unique.`);
+    ids.add(id);
+  }
+  const positionof = /* @__PURE__ */ new Map();
+  let position = 0;
+  for (const node of model.nodes) {
+    if (node.step !== void 0) {
+      positionof.set(node.step.id, position);
+      position += 1;
+      continue;
+    }
+    const block = model.blocks.find((entry) => entry.name === node.invocation?.block);
+    if (!block) throw new Error(`The block ${node.invocation?.block ?? ""} of the canvas has no definition.`);
+    const walk = (entries2) => {
+      for (const entry of entries2) {
+        if ("kind" in entry && "label" in entry && !("block" in entry)) {
+          positionof.set(entry.id, position);
+          position += 1;
+          continue;
+        }
+        const nested = model.blocks.find((candidate) => candidate.name === entry.block);
+        if (!nested) throw new Error(`The block ${entry.block} of the canvas has no definition.`);
+        walk(nested.steps);
+      }
+    };
+    walk(block.steps);
+  }
+  for (const edge of model.edges) {
+    if (!positionof.has(edge.from)) throw new Error(`The edge of ${edge.variable} references the unknown source step ${edge.from}.`);
+    if (!positionof.has(edge.to)) throw new Error(`The edge of ${edge.variable} references the unknown target step ${edge.to}.`);
+    if (positionof.get(edge.from) >= positionof.get(edge.to)) throw new Error(`The edge of ${edge.variable} runs backwards from ${edge.from} into ${edge.to} and would form a cycle.`);
+  }
+  const bindingsof = (stepid) => model.edges.filter((edge) => edge.to === stepid).map((edge) => ({ variable: edge.variable, kind: edge.kind, stepid: edge.from, ...edge.path !== void 0 ? { path: edge.path } : {} }));
+  const entries = [];
+  const attached = /* @__PURE__ */ new Map();
+  for (const node of model.nodes) {
+    if (node.invocation !== void 0) {
+      entries.push({ ...node.invocation });
+      continue;
+    }
+    const step = node.step;
+    const bindings = bindingsof(step.id);
+    const { block, params, ...rest } = { ...step, ...bindings.length > 0 ? { bindings } : {} };
+    void params;
+    const carried = rest;
+    if (block !== void 0) {
+      if (!model.blocks.some((candidate) => candidate.name === block)) throw new Error(`The step ${step.id} attaches to the unknown block ${block}.`);
+      const list = attached.get(block) ?? [];
+      list.push(carried);
+      attached.set(block, list);
+      continue;
+    }
+    entries.push(carried);
+  }
+  const blocks = model.blocks.map((block) => {
+    const snapped = attached.get(block.name) ?? [];
+    const snappedids = new Set(snapped.map((step) => step.id));
+    const carried = [];
+    for (const entry of block.steps) {
+      if ("kind" in entry && "label" in entry && !("block" in entry) && snappedids.has(entry.id)) continue;
+      carried.push(entry);
+    }
+    const steps = [...carried, ...snapped];
+    const withbindings = [];
+    for (const entry of steps) {
+      if (!("kind" in entry && "label" in entry && !("block" in entry))) {
+        withbindings.push(entry);
+        continue;
+      }
+      const bindings = bindingsof(entry.id);
+      const { block: inner, params, ...rest } = { ...entry, ...bindings.length > 0 ? { bindings } : {} };
+      void inner;
+      void params;
+      withbindings.push(rest);
+    }
+    return { ...block, steps: withbindings };
+  });
+  const composed = composeworkflow({ id: model.workflowid, name: model.name, version: model.version, origins: [...model.origins], steps: entries, blocks: blocks.map((block) => ({ ...block })), now: input.now, ...input.kindallowed !== void 0 ? { kindallowed: input.kindallowed } : {}, ...input.riskof !== void 0 ? { riskof: input.riskof } : {} });
+  const checked = validateworkflow(composed, input.kindallowed !== void 0 ? { kindallowed: input.kindallowed } : {});
+  if (!checked.allowed) throw new Error(checked.reason ?? "The canvas model failed the workflow grammar.");
+  return composed;
+}
+function snapnode(model, nodeid, x, y, grid = 20) {
+  if (!Number.isFinite(grid) || grid <= 0) throw new Error("The snap grid must be a positive number.");
+  const index = model.nodes.findIndex((node2) => nodeidof(node2) === nodeid);
+  if (index < 0) throw new Error(`No canvas node matches ${nodeid}.`);
+  const node = model.nodes[index];
+  if (node.step === void 0) throw new Error("A block invocation node attaches through its own definition, not through snapping.");
+  const snappedx = Math.round(x / grid) * grid;
+  const snappedy = Math.round(y / grid) * grid;
+  let attached;
+  for (const [blockindex, block] of model.blocks.entries()) {
+    const columnx = canvasoriginx + (blockindex + 1) * blockcolumnwidth;
+    if (Math.abs(snappedx - columnx) <= blockcolumnwidth / 2) attached = block.name;
+  }
+  const { block: priorblock, ...rest } = node.step;
+  void priorblock;
+  const step = { ...rest, ...attached !== void 0 ? { block: attached } : {} };
+  const nodes = model.nodes.map((candidate, position) => position === index ? { step, x: snappedx, y: snappedy } : candidate);
+  const size = layouttypeof(nodes, model.layout);
+  const next = { ...model, nodes, layout: size };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function reordersteps(model, nodeid, index) {
+  const current = model.nodes.findIndex((node) => nodeidof(node) === nodeid);
+  if (current < 0) throw new Error(`No canvas node matches ${nodeid}.`);
+  if (!Number.isInteger(index) || index < 0 || index > model.nodes.length - 1) throw new Error("The reorder index must address an existing position of the canvas list.");
+  const nodes = [...model.nodes];
+  const [moved] = nodes.splice(current, 1);
+  if (!moved) throw new Error("The reordered canvas node vanished.");
+  nodes.splice(index, 0, moved);
+  const next = { ...model, nodes };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function groupselect(model, nodeids, blockname) {
+  if (!/^[a-z][a-z0-9]*$/.test(blockname)) throw new Error("The block name must be a unique lowercase word.");
+  if (model.blocks.some((block) => block.name === blockname)) throw new Error(`The block name ${blockname} already exists on the canvas.`);
+  const selected = nodeids.map((id) => {
+    const node = model.nodes.find((candidate) => nodeidof(candidate) === id);
+    if (!node || node.step === void 0) throw new Error(`The grouping selection must address step nodes; ${id} is not one.`);
+    return node;
+  });
+  if (selected.length === 0) throw new Error("The grouping selection needs at least one step node.");
+  const steps = selected.map((node) => node.step);
+  const blocks = [...model.blocks, { name: blockname, label: blockname, steps: steps.map((step) => ({ ...step })) }];
+  const firstindex = model.nodes.findIndex((node) => nodeidof(node) === nodeids[0]);
+  const invocationnode = { id: blockname, invocation: { block: blockname, label: blockname }, x: selected[0].x, y: selected[0].y };
+  const nodes = [];
+  model.nodes.forEach((node, index) => {
+    if (nodeids.includes(nodeidof(node))) {
+      if (index === firstindex) nodes.push(invocationnode);
+      return;
+    }
+    nodes.push(node);
+  });
+  const next = { ...model, nodes, blocks };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function expandtemplate(model, template, params = [], index) {
+  const parsed = steptemplateof(template);
+  if (!parsed) throw new Error("The template does not carry one reviewed workflow step.");
+  let id = parsed.step.id;
+  let suffix = 2;
+  const taken = new Set(model.nodes.map((node) => nodeidof(node)));
+  while (taken.has(id)) {
+    id = `${parsed.step.id}${suffix}`;
+    suffix += 1;
+  }
+  const step = { ...parsed.step, id, ...params.length > 0 ? { params: params.map((param) => ({ ...param })) } : {} };
+  const position = index !== void 0 && Number.isInteger(index) && index >= 0 && index <= model.nodes.length ? index : model.nodes.length;
+  const nodes = [...model.nodes.slice(0, position), { step, x: canvasoriginx, y: 60 + position * noderowheight }, ...model.nodes.slice(position)];
+  const next = { ...model, nodes };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function addnode(model, step, index) {
+  const normalized = workflowstepof(step);
+  if (!normalized) throw new Error("The canvas insertion needs one reviewed workflow step.");
+  let id = normalized.id;
+  let suffix = 2;
+  const taken = new Set(model.nodes.map((node) => nodeidof(node)));
+  while (taken.has(id)) {
+    id = `${normalized.id}${suffix}`;
+    suffix += 1;
+  }
+  const position = index !== void 0 && Number.isInteger(index) && index >= 0 && index <= model.nodes.length ? index : model.nodes.length;
+  const nodes = [...model.nodes.slice(0, position), { step: { ...normalized, id }, x: canvasoriginx, y: 60 + position * noderowheight }, ...model.nodes.slice(position)];
+  const next = { ...model, nodes };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function editstep(model, step) {
+  const normalized = workflowstepof(step);
+  if (!normalized) throw new Error("The step inspector edit needs one reviewed workflow step.");
+  const index = model.nodes.findIndex((node2) => node2.step?.id === normalized.id);
+  if (index < 0) throw new Error(`No canvas step matches ${normalized.id}.`);
+  const node = model.nodes[index];
+  const nodes = model.nodes.map((candidate, position) => position === index ? { step: { ...normalized, ...node.step?.block !== void 0 ? { block: node.step.block } : {}, ...node.step?.breakpoint === true ? { breakpoint: true } : {} }, x: node.x, y: node.y } : candidate);
+  const next = { ...model, nodes };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function renderminimap(model, width = 160, height = 100) {
+  if (!Number.isFinite(width) || width <= 0 || !Number.isFinite(height) || height <= 0) throw new Error("The mini map size must be positive.");
+  const canvaswidth = Math.max(1, model.layout.width);
+  const canvasheight = Math.max(1, model.layout.height);
+  const scale = Math.min(width / canvaswidth, height / canvasheight);
+  const zoom = model.layout.zoom > 0 ? model.layout.zoom : 1;
+  const visiblewidth = canvaswidth / zoom;
+  const visibleheight = canvasheight / zoom;
+  const viewport = {
+    x: Math.max(0, Math.min(model.layout.viewportx, canvaswidth)) * scale,
+    y: Math.max(0, Math.min(model.layout.viewporty, canvasheight)) * scale,
+    width: visiblewidth * scale,
+    height: visibleheight * scale
+  };
+  const nodes = model.nodes.map((node) => ({ id: nodeidof(node), x: node.x * scale, y: node.y * scale }));
+  return { minimap: { width, height, scale, zoom, viewport }, nodes };
+}
+function minimapfocus(model, x, y, width = 160, height = 100) {
+  const projection = renderminimap(model, width, height);
+  if (projection.minimap.scale <= 0) return model;
+  const canvasx = x / projection.minimap.scale;
+  const canvasy = y / projection.minimap.scale;
+  const zoom = model.layout.zoom > 0 ? model.layout.zoom : 1;
+  const visiblewidth = model.layout.width / zoom;
+  const visibleheight = model.layout.height / zoom;
+  const viewportx = Math.max(0, Math.min(canvasx - visiblewidth / 2, Math.max(0, model.layout.width - visiblewidth)));
+  const viewporty = Math.max(0, Math.min(canvasy - visibleheight / 2, Math.max(0, model.layout.height - visibleheight)));
+  const next = { ...model, layout: { ...model.layout, viewportx, viewporty } };
+  return { ...next, minimap: renderminimap(next).minimap };
+}
+function zoomcanvas(model, zoom) {
+  if (!Number.isFinite(zoom) || zoom <= 0) throw new Error("The canvas zoom must be a positive number with no code ceiling.");
+  const next = { ...model, layout: { ...model.layout, zoom } };
+  const labelscale = zoom < 1 ? 1 / zoom : 1;
+  return { model: { ...next, minimap: renderminimap(next).minimap }, labelscale };
+}
+function searchsteps(model, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return [];
+  const results = [];
+  for (const node of model.nodes) {
+    if (node.step === void 0) continue;
+    const matched = [];
+    if (node.step.label.toLowerCase().includes(needle)) matched.push("label");
+    if (node.step.kind.toLowerCase().includes(needle)) matched.push("kind");
+    const variables = [
+      ...model.edges.filter((edge) => edge.to === node.step?.id || edge.from === node.step?.id).map((edge) => edge.variable),
+      ...node.step.expression !== void 0 ? [node.step.expression.result] : [],
+      ...node.step.extract !== void 0 ? node.step.extract.groups : []
+    ];
+    if (variables.some((name) => name.toLowerCase().includes(needle))) matched.push("variable");
+    if (matched.length > 0) results.push({ id: node.step.id, label: node.step.label, kind: node.step.kind, matched });
+  }
+  return results;
+}
+function markbreakpoint(model, stepid) {
+  const toggle = (step) => {
+    const { breakpoint, ...rest } = step;
+    void breakpoint;
+    return breakpoint === true ? rest : { ...rest, breakpoint: true };
+  };
+  const index = model.nodes.findIndex((node) => node.step?.id === stepid);
+  if (index >= 0) {
+    const node = model.nodes[index];
+    const step = node.step;
+    const nodes = model.nodes.map((candidate, position) => position === index ? { step: toggle(step), x: candidate.x, y: candidate.y } : candidate);
+    const next2 = { ...model, nodes };
+    return withundo(model, { ...next2, minimap: renderminimap(next2).minimap });
+  }
+  const blocks = model.blocks.map((block) => {
+    const stepindex = block.steps.findIndex((entry) => "kind" in entry && "label" in entry && !("block" in entry) && entry.id === stepid);
+    if (stepindex < 0) return block;
+    const steps = block.steps.map((entry, position) => position === stepindex ? toggle(entry) : entry);
+    return { ...block, steps };
+  });
+  if (blocks.every((block, position) => block === model.blocks[position])) throw new Error(`No canvas step matches ${stepid}.`);
+  const next = { ...model, blocks };
+  return withundo(model, next);
+}
+function runtobreakpoint(input) {
+  const cursor = input.cursor !== void 0 && Number.isInteger(input.cursor) && input.cursor >= 0 ? input.cursor : 0;
+  const marked = new Set(input.breakpoints);
+  for (let index = cursor; index < input.record.steps.length; index += 1) {
+    const step = input.record.steps[index];
+    if (step.breakpoint === true || marked.has(step.id)) {
+      return { until: index, pausat: step.id, remaining: input.record.steps.length - index };
+    }
+  }
+  return { until: input.record.steps.length, pausat: void 0, remaining: 0 };
+}
+function diffversions(from, to, now) {
+  const fromsteps = new Map(from.steps.map((step) => [step.id, step]));
+  const tosteps = new Map(to.steps.map((step) => [step.id, step]));
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const step of to.steps) {
+    const prior = fromsteps.get(step.id);
+    if (!prior) {
+      added.push({ stepid: step.id, kind: step.kind, label: step.label });
+      continue;
+    }
+    const changes = [];
+    if (prior.label !== step.label) changes.push("label");
+    if (prior.kind !== step.kind) changes.push("kind");
+    if (prior.target !== step.target) changes.push("target");
+    if (prior.value !== step.value) changes.push("value");
+    if (prior.options !== step.options) changes.push("options");
+    if (JSON.stringify(prior.expression) !== JSON.stringify(step.expression)) changes.push("expression");
+    if (JSON.stringify(prior.extract) !== JSON.stringify(step.extract)) changes.push("extract");
+    if (JSON.stringify(prior.bindings) !== JSON.stringify(step.bindings)) changes.push("bindings");
+    if (changes.length > 0) changed.push({ stepid: step.id, kind: step.kind, label: step.label, changes });
+  }
+  for (const step of from.steps) {
+    if (!tosteps.has(step.id)) removed.push({ stepid: step.id, kind: step.kind, label: step.label });
+  }
+  return { workflowid: to.id, from: from.version, to: to.version, added, removed, changed, at: now };
+}
+function exportworkflow(record2, format, note, now) {
+  const file = { format: workflowfileversion, exportedat: now ?? Date.now(), workflow: record2, ...note !== void 0 && note.trim() !== "" ? { note } : {}, templates: [] };
+  return { format, contents: serializefile(file, format), file };
+}
+function shareworkflow(record2, templates, format, note, now) {
+  const file = { format: workflowfileversion, exportedat: now ?? Date.now(), workflow: record2, ...note !== void 0 && note.trim() !== "" ? { note } : {}, templates: templates.map((template) => ({ ...template })) };
+  return { format, contents: serializefile(file, format), file };
+}
+function importworkflow(input) {
+  const format = input.format ?? (input.contents.trimStart().startsWith("{") ? "json" : "yaml");
+  const parsed = parsefile(input.contents, format);
+  if (parsed.format !== workflowfileversion) throw new Error(`The workflow file format ${String(parsed.format)} is not the reviewed format ${workflowfileversion}.`);
+  const candidate = parsed.workflow;
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) throw new Error("The workflow file carries no workflow record.");
+  const fields = candidate;
+  const stepsvalue = fields.steps;
+  if (!Array.isArray(stepsvalue) || stepsvalue.length === 0) throw new Error("An imported workflow needs at least one step.");
+  const steps = [];
+  for (const entry of stepsvalue) {
+    const step = workflowstepof(entry);
+    if (step) {
+      steps.push(step);
+      continue;
+    }
+    throw new Error("Every imported workflow entry must be a reviewed step.");
+  }
+  const composed = composeworkflow({
+    id: typeof fields.id === "string" && fields.id.trim() !== "" ? fields.id : crypto.randomUUID(),
+    name: typeof fields.name === "string" ? fields.name : "",
+    version: typeof fields.version === "number" ? fields.version : 1,
+    origins: Array.isArray(fields.origins) ? fields.origins.filter((origin) => typeof origin === "string") : [],
+    steps,
+    now: input.now ?? Date.now(),
+    ...input.kindallowed !== void 0 ? { kindallowed: input.kindallowed } : {},
+    ...input.riskof !== void 0 ? { riskof: input.riskof } : {}
+  });
+  const templatesvalue = parsed.templates;
+  if (templatesvalue !== void 0 && !Array.isArray(templatesvalue)) throw new Error("The packed templates of the workflow file must be a list.");
+  const templates = [];
+  for (const entry of templatesvalue ?? []) {
+    const template = steptemplateof(entry);
+    if (!template) throw new Error("A packed template of the workflow file does not carry one reviewed step.");
+    templates.push(template);
+  }
+  const record2 = { ...composed, reviewstate: "pending" };
+  return { record: record2, templates, file: { ...parsed, workflow: record2 } };
+}
+function bindparam(model, blockname, param) {
+  if (!/^[a-z][a-z0-9]*$/.test(param.name)) throw new Error("The nested parameter name must be a lowercase word.");
+  const index = model.nodes.findIndex((node2) => node2.invocation?.block === blockname);
+  if (index < 0) throw new Error(`No block invocation of ${blockname} sits on the canvas.`);
+  const node = model.nodes[index];
+  const invocation = node.invocation;
+  const params = [...(invocation.params ?? []).filter((existing) => existing.name !== param.name), { ...param }];
+  const nodes = model.nodes.map((candidate, position) => position === index ? { invocation: { ...invocation, params }, x: candidate.x, y: candidate.y } : candidate);
+  const next = { ...model, nodes };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function originmatches(pattern, origin) {
+  if (pattern === origin) return true;
+  const glob = pattern.replace(/\./g, "\\.").replace(/\*/g, "[^.]+");
+  if (!glob.startsWith("https://")) return false;
+  return new RegExp(`^${glob}$`).test(origin);
+}
+function applyoverride(record2, override) {
+  const matching = record2.origins.filter((origin) => originmatches(override.pattern, origin));
+  if (matching.length === 0) throw new Error(`The override pattern ${override.pattern} matches none of the workflow origins ${record2.origins.join(", ")}.`);
+  const knobs = /* @__PURE__ */ new Set(["loopbound", "stepms", "runms", "waitms", "delaybase"]);
+  for (const knob of Object.keys(override.deltas)) {
+    if (!knobs.has(knob)) throw new Error(`The override knob ${knob} is not one of the reviewed knobs: ${[...knobs].join(", ")}.`);
+    if (typeof override.deltas[knob] !== "number" || !Number.isFinite(override.deltas[knob]) || override.deltas[knob] <= 0) throw new Error(`The override delta of ${knob} must be a positive number with no code ceiling.`);
+  }
+  const apply = (step) => {
+    if (Object.keys(override.deltas).length === 0) return step;
+    let payload = {};
+    try {
+      payload = step.options !== void 0 ? JSON.parse(step.options) : {};
+    } catch {
+      payload = {};
+    }
+    const bodyof = (key) => payload[key] !== void 0 && typeof payload[key] === "object" && !Array.isArray(payload[key]) ? payload[key] : {};
+    if (override.deltas.loopbound !== void 0 && ["loop", "repeatuntil", "whileloop"].includes(step.kind)) {
+      const body = bodyof(step.kind);
+      body.bound = override.deltas.loopbound;
+      payload[step.kind] = body;
+    }
+    if ((override.deltas.stepms !== void 0 || override.deltas.runms !== void 0) && step.kind === "trycatch") {
+      const body = bodyof("trycatch");
+      const timeout = body.timeout !== void 0 && typeof body.timeout === "object" && !Array.isArray(body.timeout) ? body.timeout : {};
+      if (override.deltas.stepms !== void 0) timeout.stepms = override.deltas.stepms;
+      if (override.deltas.runms !== void 0) timeout.runms = override.deltas.runms;
+      body.timeout = timeout;
+      payload.trycatch = body;
+    }
+    if (override.deltas.waitms !== void 0 && step.kind === "waitelement") {
+      payload.timeout = override.deltas.waitms;
+    }
+    if (override.deltas.delaybase !== void 0 && step.kind === "delay") {
+      payload.base = override.deltas.delaybase;
+    }
+    const changed = Object.keys(payload).length > 0;
+    return changed ? { ...step, options: JSON.stringify(payload) } : step;
+  };
+  return { ...record2, steps: record2.steps.map(apply) };
+}
+function addedge(model, edge) {
+  const from = model.nodes.findIndex((node) => nodeidof(node) === edge.from);
+  const to = model.nodes.findIndex((node) => nodeidof(node) === edge.to);
+  if (from < 0) throw new Error(`The canvas edge references the unknown source step ${edge.from}.`);
+  if (to < 0) throw new Error(`The canvas edge references the unknown target step ${edge.to}.`);
+  if (from >= to) throw new Error(`The canvas edge of ${edge.variable} would run backwards from ${edge.from} into ${edge.to} and form a cycle.`);
+  if (!/^[a-z][a-z0-9]*$/.test(edge.variable)) throw new Error("The bound variable name must be a lowercase word.");
+  const edges = [...model.edges.filter((candidate) => !(candidate.from === edge.from && candidate.to === edge.to && candidate.variable === edge.variable)), { ...edge, ...edge.path !== void 0 ? { path: edge.path } : {} }];
+  const next = { ...model, edges };
+  return withundo(model, next);
+}
+function removeedge(model, from, to, variable) {
+  const edges = model.edges.filter((candidate) => !(candidate.from === from && candidate.to === to && candidate.variable === variable));
+  if (edges.length === model.edges.length) throw new Error(`No canvas edge of ${variable} links ${from} into ${to}.`);
+  const next = { ...model, edges };
+  return withundo(model, next);
+}
+function removenode(model, nodeid) {
+  const index = model.nodes.findIndex((node) => nodeidof(node) === nodeid);
+  if (index < 0) throw new Error(`No canvas node matches ${nodeid}.`);
+  const nodes = model.nodes.filter((_, position) => position !== index);
+  const edges = model.edges.filter((edge) => edge.from !== nodeid && edge.to !== nodeid);
+  const next = { ...model, nodes, edges };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function undoedit(model) {
+  const undo = model.undo ?? [];
+  if (undo.length === 0) return model;
+  const previous = undo[undo.length - 1];
+  const current = snapshotof(model);
+  return { ...previous, undo: undo.slice(0, -1), redo: [...model.redo ?? [], current] };
+}
+function redoedit(model) {
+  const redo = model.redo ?? [];
+  if (redo.length === 0) return model;
+  const next = redo[redo.length - 1];
+  const current = snapshotof(model);
+  return { ...next, redo: redo.slice(0, -1), undo: [...model.undo ?? [], current] };
+}
+function serializefile(file, format) {
+  if (format === "json") return JSON.stringify(file, null, 2);
+  return yamlvalue(file, 0).join("\n") + "\n";
+}
+function parsefile(contents, format) {
+  if (format === "json") {
+    const parsed = JSON.parse(contents);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("The workflow file is not a json object.");
+    return parsed;
+  }
+  const lines = contents.split(/\r?\n/).map((line) => line.replace(/\t/g, "  ")).filter((line) => line.trim() !== "" && !line.trim().startsWith("#"));
+  if (lines.length === 0) throw new Error("The yaml workflow file is empty.");
+  const { value, next } = yamlblock(lines, 0, indentof(lines[0]));
+  if (next < lines.length) throw new Error("The yaml workflow file carries content outside the documented subset.");
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("The yaml workflow file is not a mapping.");
+  return value;
+}
+function indentof(line) {
+  const match = /^ */.exec(line);
+  return match ? match[0].length : 0;
+}
+function yamlscalar(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(String(value));
+}
+function yamlvalue(value, indent) {
+  const pad = " ".repeat(indent);
+  if (value === null || value === void 0 || typeof value !== "object") return [`${pad}${yamlscalar(value)}`];
+  if (Array.isArray(value)) {
+    if (value.length === 0) return [`${pad}[]`];
+    const lines2 = [];
+    for (const item of value) {
+      if (item !== null && typeof item === "object") {
+        lines2.push(`${pad}-`);
+        lines2.push(...yamlvalue(item, indent + 2));
+      } else {
+        lines2.push(`${pad}- ${yamlscalar(item)}`);
+      }
+    }
+    return lines2;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) return [`${pad}{}`];
+  const lines = [];
+  for (const [key, entry] of entries) {
+    if (entry !== null && typeof entry === "object") {
+      if (Array.isArray(entry) && entry.length === 0) {
+        lines.push(`${pad}${key}: []`);
+        continue;
+      }
+      if (!Array.isArray(entry) && Object.keys(entry).length === 0) {
+        lines.push(`${pad}${key}: {}`);
+        continue;
+      }
+      lines.push(`${pad}${key}:`);
+      lines.push(...yamlvalue(entry, indent + 2));
+    } else {
+      lines.push(`${pad}${key}: ${yamlscalar(entry)}`);
+    }
+  }
+  return lines;
+}
+function yamlblock(lines, start, indent) {
+  const first = lines[start];
+  if (/^\s*-\s/.test(first) || /^\s*-$/.test(first)) {
+    const items = [];
+    let index2 = start;
+    while (index2 < lines.length) {
+      const line = lines[index2];
+      if (indentof(line) !== indent || !/^\s*-\s?/.test(line)) break;
+      const rest = line.slice(indent + 1).trim();
+      if (rest !== "") {
+        items.push(yamlscalarvalue(rest));
+        index2 += 1;
+        continue;
+      }
+      const nested = yamlblock(lines, index2 + 1, indent + 2);
+      items.push(nested.value);
+      index2 = nested.next;
+    }
+    return { value: items, next: index2 };
+  }
+  const mapping = {};
+  let index = start;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (indentof(line) !== indent) break;
+    const match = /^([A-Za-z][A-Za-z0-9]*):(?:\s(.*))?$/.exec(line.slice(indent));
+    if (!match) break;
+    const key = match[1];
+    const rest = match[2];
+    if (rest !== void 0 && rest !== "") {
+      if (rest === "[]") {
+        mapping[key] = [];
+        index += 1;
+        continue;
+      }
+      if (rest === "{}") {
+        mapping[key] = {};
+        index += 1;
+        continue;
+      }
+      mapping[key] = yamlscalarvalue(rest);
+      index += 1;
+      continue;
+    }
+    const nested = yamlblock(lines, index + 1, indent + 2);
+    mapping[key] = nested.value;
+    index = nested.next;
+  }
+  if (index === start) throw new Error("The yaml workflow file left the documented subset.");
+  return { value: mapping, next: index };
+}
+function yamlscalarvalue(text2) {
+  if (text2.startsWith('"')) {
+    const parsed = JSON.parse(text2);
+    return typeof parsed === "string" ? parsed : text2;
+  }
+  if (text2 === "true") return true;
+  if (text2 === "false") return false;
+  if (text2 === "null") return null;
+  if (/^-?\d+(?:\.\d+)?$/.test(text2)) return Number(text2);
+  return text2;
+}
 export {
   activelayers,
+  addedge,
+  addnode,
   agentgrammarvalid,
   agentpresetof,
   allowlistcovers,
@@ -8445,12 +10077,15 @@ export {
   apientries,
   apikeyconsentgranted,
   apireplayspecof,
+  applycooldown,
   applyheaderules,
   applylayer,
+  applyoverride,
   applyretry,
   applyruntimeout,
   applytimeout,
   argkind,
+  armrule,
   assetentries,
   attachcdpsession,
   attachtargetof,
@@ -8460,6 +10095,7 @@ export {
   authreport,
   autointervalof,
   backoffdelay,
+  bindparam,
   bindvariables,
   blackboxedurls,
   blackboxmatches,
@@ -8479,6 +10115,7 @@ export {
   buildname,
   buildpdf,
   buildsheet,
+  buildsteplibrary,
   buildstitchplan,
   callgraphql,
   callrest,
@@ -8513,6 +10150,7 @@ export {
   collectmessages,
   composeworkflow,
   conditionof,
+  confirmmanualrun,
   consolecapture,
   consoleconsentcovers,
   consolediff,
@@ -8531,6 +10169,8 @@ export {
   correlationid,
   cpusnap,
   crashinterrupted,
+  cronnext,
+  cronparse,
   croprect,
   crossesviewport,
   cursorfrom,
@@ -8540,6 +10180,7 @@ export {
   debugwaitbudgetallowed,
   dedupeimages,
   defaultloopbound,
+  defaulttriggercooldown,
   delayjitter,
   actionrisk as deriveactionrisk,
   detachcdpsession,
@@ -8547,9 +10188,14 @@ export {
   diffresponse,
   diffreviewgrade,
   diffsessionrecords,
+  diffversions,
   downloadreport,
+  drainqueue,
   dryrunprojection,
   dryrunworkflow,
+  editorsavegate,
+  editorstate,
+  editstep,
   emugate,
   emulationkinds,
   emulationreport,
@@ -8559,14 +10205,19 @@ export {
   errorcapture,
   errorreportresponse,
   evaluatecondition,
+  evaluatetrigger,
   eventresponse,
+  eventrulematches,
   exchangesreport,
   expandblocks,
+  expandtemplate,
   expirelayers,
   expireprofilerecords,
   expiresessions,
+  exportcontentreview,
   exportpresetlibrary,
   exportsessionfile,
+  exportworkflow,
   expressioneval,
   expressionof,
   expressionoperators,
@@ -8590,6 +10241,7 @@ export {
   generatedvalueallowed,
   graphqlopenvelope,
   graphqlrequestof,
+  groupselect,
   growsampleof,
   growthtrend,
   headerfilterof,
@@ -8606,6 +10258,7 @@ export {
   imagenames,
   importpresetlibrary,
   importsessionfile,
+  importworkflow,
   iscdpkind,
   iscontrolflowkind,
   iscontrolkind,
@@ -8616,6 +10269,8 @@ export {
   isprofilekind,
   issessionkind,
   issocketkind,
+  istriggeraction,
+  istriggerkind,
   iswatchkind,
   isworkflowkind,
   joinbranches,
@@ -8625,6 +10280,8 @@ export {
   layernames,
   layoutreport,
   levelrank,
+  listdue,
+  loadworkflow,
   locationconsentcovers,
   locationconsentgate,
   locationpresetof,
@@ -8632,9 +10289,13 @@ export {
   loglevels,
   longtaskcapture,
   loopof,
+  manualpreview,
+  manualrunpreview,
   mapresponse,
   mapurlof,
+  markbreakpoint,
   matchmessage,
+  matchurl,
   matchurlpattern,
   measure,
   mediaentries,
@@ -8642,6 +10303,7 @@ export {
   mediareport,
   messagefilterof,
   methoddomain,
+  minimapfocus,
   mockfor,
   mockspecof,
   multipartchunks,
@@ -8665,12 +10327,15 @@ export {
   oauthflowof,
   observationmodeof,
   observationresponse,
+  observeevents,
   openchannel,
   outcomeresponse,
   overrideinputof,
   overridematches,
   pairexchange,
   pairstates,
+  palettecategories,
+  palettenodes,
   parallelof,
   parsehtmlbody,
   parseproposal,
@@ -8679,6 +10344,7 @@ export {
   parseworkflowproposal,
   passwordconsentgranted,
   patternorigin,
+  pauseall,
   pauseretentionwindow,
   pauserun,
   payloadshapeof,
@@ -8710,6 +10376,7 @@ export {
   publishmessage,
   pushscope,
   quarantinereport,
+  queuefire,
   randomid,
   rankapis,
   ratelimitbudgetallowed,
@@ -8723,10 +10390,15 @@ export {
   recordwatchvalue,
   redactconsoletext,
   redactedcookies,
+  redoedit,
   regexextract,
   regexruleof,
   regionsteps,
   rejectioncapture,
+  removeedge,
+  removenode,
+  renderminimap,
+  reordersteps,
   repeatuntilof,
   replaytrace,
   replayurl,
@@ -8738,31 +10410,44 @@ export {
   restoreoriginsgranted,
   restoreplanof,
   restorereviewgranted,
+  resumeall,
   retryafterof,
   revertalllayers,
   revertlayer,
   revertplanof,
   revertrule,
+  reviewedkinds,
   revocationruleof,
   rewritesourcelocation,
   rotatelogs,
   rotationruleof,
+  ruleorigins,
+  ruleoriginsgranted,
   runcatch,
   runcontrolstep,
   runforeach,
+  runhistoryquery,
+  runhistoryreport,
   runloop,
   runparallel,
   runrepeatuntil,
+  runreviewgranted,
   runstep,
+  runtobreakpoint,
   runtry,
+  runurllist,
   runwhile,
   runworkflow,
   safetyresponse,
+  saveworkflow,
   scaledrect,
+  schedulecron,
+  scheduleinterval,
   seamweights,
   searchfields,
   searchqueryof,
   searchsessionrecords,
+  searchsteps,
   seededrandom,
   selectorresponse,
   sendcdpcommand,
@@ -8780,8 +10465,10 @@ export {
   sessionrestoregate,
   sessiontabof,
   setvariable,
+  shareworkflow,
   shiftentryof,
   signalsreport,
+  snapnode,
   snapshotplanof,
   snapshotretentionwindow,
   snapshotsections,
@@ -8818,6 +10505,7 @@ export {
   timelinereport,
   timelineretentionwindow,
   timelinesources,
+  timezonevalid,
   tokenrequest,
   tracecategories,
   traceceilingof,
@@ -8825,30 +10513,50 @@ export {
   tracetofile,
   trailreport,
   transformgrammar,
+  triggereventcatalog,
+  triggerfamilies,
+  triggerfamilyof,
+  triggerfired,
+  triggergate,
+  triggerkinds,
+  triggerlist,
+  triggerorigins,
+  triggerpayloadof,
+  triggersummary,
   tryof,
+  undoedit,
   unwrapgraphql,
+  updaterule,
   urlencodeform,
   validatebreakpointcondition,
   validatecontrolpayload,
   validatefieldmatch,
   validateformrecord,
   validateregexrule,
+  validatesiteoverride,
   validatestep,
   validatetargetref,
   validatevaluegen,
   validateworkflow,
+  verifywebhook,
+  visitmatch,
   waitelementplan,
   watchcdpevents,
+  watchdogconfigvalid,
+  watchdogpass,
   watcherdetached,
   watchexpressionof,
   watchgate,
+  webhooksecretok,
   whileof,
   wizardreport,
   workflowblockof,
+  workflowfileversion,
   workflowgate,
   workflowkinds,
   workflowoutcome,
   workflowreport,
-  workflowstepof
+  workflowstepof,
+  zoomcanvas
 };
 //# sourceMappingURL=index.js.map