@wenathlan/extension 1.1.51 → 1.1.52

package/dist/index.js

@@ -4363,6 +4363,77 @@ 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") ?? [];
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -4899,6 +4970,401 @@ function extractvalues(body, paths) {
   return fields.map((field) => ({ path: field.path, ...field.value !== void 0 ? { value: field.value } : {}, ...field.missing ? { missing: true } : {} }));
 }
 
+// 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 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;
+  }
+}
+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 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 updaterule(rule, patch) {
+  return { ...rule, ...patch.state !== void 0 ? { state: { ...rule.state, ...patch.state } } : {}, ...patch.stats !== void 0 ? { stats: { ...rule.stats, ...patch.stats } } : {} };
+}
+function matchurl(pattern, url) {
+  let parsedpattern;
+  let parsedurl;
+  try {
+    parsedpattern = new URL(pattern);
+    parsedurl = new URL(url);
+  } catch {
+    return false;
+  }
+  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 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 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 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 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 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;
+    }
+    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;
+    }
+    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;
+  }
+  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}.` };
+  }
+  return { verified: true };
+}
+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 eventrulematches(rule, event) {
+  return (rule.events ?? []).includes(event);
+}
+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 pauseall(rules, now) {
+  return rules.map((rule) => rule.state.enabled && rule.state.pausedat === void 0 ? updaterule(rule, { state: { pausedat: now } }) : rule);
+}
+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 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 url of rule.urls ?? []) {
+    const origin = httpsorigin(url);
+    if (origin !== void 0) origins.add(origin);
+  }
+  return [...origins];
+}
+function ruleoriginsgranted(rule, workfloworigins) {
+  const granted = new Set(workfloworigins);
+  return ruleorigins(rule).every((origin) => granted.has(origin));
+}
+
 // runtimeline.ts
 var timelinekinds = ["watchconsole", "watcherrors", "watchtasks"];
 var loglevels = ["error", "warn", "info", "log", "debug", "trace"];
@@ -5309,7 +5775,7 @@ function polldecision(input) {
 }
 
 // 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 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]);
@@ -5333,6 +5799,7 @@ var profileractions = /* @__PURE__ */ new Set(["measureflow", "heapshot", "track
 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"]);
@@ -5354,6 +5821,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 +7498,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 +8167,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 +8365,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;
@@ -7901,7 +8452,7 @@ function canexecute(input) {
 }
 
 // version.ts
-var packageversion = "1.1.51";
+var packageversion = "1.1.52";
 
 // types.ts
 var protocolversion = packageversion;
@@ -8140,6 +8691,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 +8852,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,6 +9004,51 @@ 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 } : {} };
+}
 export {
   activelayers,
   agentgrammarvalid,
@@ -8445,12 +9060,14 @@ export {
   apientries,
   apikeyconsentgranted,
   apireplayspecof,
+  applycooldown,
   applyheaderules,
   applylayer,
   applyretry,
   applyruntimeout,
   applytimeout,
   argkind,
+  armrule,
   assetentries,
   attachcdpsession,
   attachtargetof,
@@ -8513,6 +9130,7 @@ export {
   collectmessages,
   composeworkflow,
   conditionof,
+  confirmmanualrun,
   consolecapture,
   consoleconsentcovers,
   consolediff,
@@ -8531,6 +9149,8 @@ export {
   correlationid,
   cpusnap,
   crashinterrupted,
+  cronnext,
+  cronparse,
   croprect,
   crossesviewport,
   cursorfrom,
@@ -8540,6 +9160,7 @@ export {
   debugwaitbudgetallowed,
   dedupeimages,
   defaultloopbound,
+  defaulttriggercooldown,
   delayjitter,
   actionrisk as deriveactionrisk,
   detachcdpsession,
@@ -8548,6 +9169,7 @@ export {
   diffreviewgrade,
   diffsessionrecords,
   downloadreport,
+  drainqueue,
   dryrunprojection,
   dryrunworkflow,
   emugate,
@@ -8559,7 +9181,9 @@ export {
   errorcapture,
   errorreportresponse,
   evaluatecondition,
+  evaluatetrigger,
   eventresponse,
+  eventrulematches,
   exchangesreport,
   expandblocks,
   expirelayers,
@@ -8616,6 +9240,8 @@ export {
   isprofilekind,
   issessionkind,
   issocketkind,
+  istriggeraction,
+  istriggerkind,
   iswatchkind,
   isworkflowkind,
   joinbranches,
@@ -8625,6 +9251,7 @@ export {
   layernames,
   layoutreport,
   levelrank,
+  listdue,
   locationconsentcovers,
   locationconsentgate,
   locationpresetof,
@@ -8632,9 +9259,12 @@ export {
   loglevels,
   longtaskcapture,
   loopof,
+  manualpreview,
+  manualrunpreview,
   mapresponse,
   mapurlof,
   matchmessage,
+  matchurl,
   matchurlpattern,
   measure,
   mediaentries,
@@ -8665,6 +9295,7 @@ export {
   oauthflowof,
   observationmodeof,
   observationresponse,
+  observeevents,
   openchannel,
   outcomeresponse,
   overrideinputof,
@@ -8679,6 +9310,7 @@ export {
   parseworkflowproposal,
   passwordconsentgranted,
   patternorigin,
+  pauseall,
   pauseretentionwindow,
   pauserun,
   payloadshapeof,
@@ -8710,6 +9342,7 @@ export {
   publishmessage,
   pushscope,
   quarantinereport,
+  queuefire,
   randomid,
   rankapis,
   ratelimitbudgetallowed,
@@ -8738,6 +9371,7 @@ export {
   restoreoriginsgranted,
   restoreplanof,
   restorereviewgranted,
+  resumeall,
   retryafterof,
   revertalllayers,
   revertlayer,
@@ -8747,6 +9381,8 @@ export {
   rewritesourcelocation,
   rotatelogs,
   rotationruleof,
+  ruleorigins,
+  ruleoriginsgranted,
   runcatch,
   runcontrolstep,
   runforeach,
@@ -8755,10 +9391,13 @@ export {
   runrepeatuntil,
   runstep,
   runtry,
+  runurllist,
   runwhile,
   runworkflow,
   safetyresponse,
   scaledrect,
+  schedulecron,
+  scheduleinterval,
   seamweights,
   searchfields,
   searchqueryof,
@@ -8818,6 +9457,7 @@ export {
   timelinereport,
   timelineretentionwindow,
   timelinesources,
+  timezonevalid,
   tokenrequest,
   tracecategories,
   traceceilingof,
@@ -8825,8 +9465,19 @@ export {
   tracetofile,
   trailreport,
   transformgrammar,
+  triggereventcatalog,
+  triggerfamilies,
+  triggerfamilyof,
+  triggerfired,
+  triggergate,
+  triggerkinds,
+  triggerlist,
+  triggerorigins,
+  triggerpayloadof,
+  triggersummary,
   tryof,
   unwrapgraphql,
+  updaterule,
   urlencodeform,
   validatebreakpointcondition,
   validatecontrolpayload,
@@ -8837,11 +9488,14 @@ export {
   validatetargetref,
   validatevaluegen,
   validateworkflow,
+  verifywebhook,
+  visitmatch,
   waitelementplan,
   watchcdpevents,
   watcherdetached,
   watchexpressionof,
   watchgate,
+  webhooksecretok,
   whileof,
   wizardreport,
   workflowblockof,