@nanobpm/urban 0.9.0 → 0.11.0

package/src/runtime/core/modules/cron.test.ts

@@ -0,0 +1,105 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { cronFiresBetween, cronMatches, nextCronFire, parseCron } from "./cron.ts";
+
+const utc = (s: string) => new Date(s);
+
+test("parseCron rejects malformed specs", () => {
+  assert.throws(() => parseCron("* * * *"), /expected 5 fields/);
+  assert.throws(() => parseCron("* * * * * *"), /expected 5 fields/);
+  assert.throws(() => parseCron("60 * * * *"), /out of range/);
+  assert.throws(() => parseCron("* 24 * * *"), /out of range/);
+  assert.throws(() => parseCron("* * 0 * *"), /out of range/);
+  assert.throws(() => parseCron("*/0 * * * *"), /bad step/);
+  assert.throws(() => parseCron("/5 * * * *"), /missing range before/);
+  assert.throws(() => parseCron("*/ * * * *"), /bad step/);
+  assert.throws(() => parseCron("5-3 * * * *"), /out of range/);
+  assert.throws(() => parseCron("1,,2 * * * *"), /empty term/);
+});
+
+test("parseCron handles wildcards, lists, ranges, steps and names", () => {
+  const daily = parseCron("0 6 * * *");
+  assert.equal(daily.minutes.has(0), true);
+  assert.equal(daily.hours.has(6), true);
+  assert.equal(daily.domWildcard, true);
+  assert.equal(daily.dowWildcard, true);
+
+  const s = parseCron("*/15 9-17 1,15 jan-mar mon-fri");
+  assert.deepEqual([...s.minutes].sort((a, b) => a - b), [0, 15, 30, 45]);
+  assert.deepEqual([...s.hours].sort((a, b) => a - b), [9, 10, 11, 12, 13, 14, 15, 16, 17]);
+  assert.deepEqual([...s.daysOfMonth].sort((a, b) => a - b), [1, 15]);
+  assert.deepEqual([...s.months].sort((a, b) => a - b), [1, 2, 3]);
+  assert.deepEqual([...s.daysOfWeek].sort((a, b) => a - b), [1, 2, 3, 4, 5]);
+  assert.equal(s.domWildcard, false);
+  assert.equal(s.dowWildcard, false);
+});
+
+test("day-of-week 7 normalises to 0 (Sunday)", () => {
+  const s = parseCron("0 0 * * 7");
+  assert.equal(s.daysOfWeek.has(0), true);
+  assert.equal(s.daysOfWeek.has(7), false);
+});
+
+test("cronMatches evaluates in UTC on minute boundaries", () => {
+  const s = parseCron("30 14 * * *");
+  assert.equal(cronMatches(s, utc("2026-08-01T14:30:00Z")), true);
+  assert.equal(cronMatches(s, utc("2026-08-01T14:31:00Z")), false);
+  assert.equal(cronMatches(s, utc("2026-08-01T13:30:00Z")), false);
+});
+
+test("standard cron day rule: both dom+dow restricted → OR", () => {
+  // 15th of the month OR any Monday.
+  const s = parseCron("0 0 15 * 1");
+  assert.equal(cronMatches(s, utc("2026-08-15T00:00:00Z")), true); // the 15th (a Saturday)
+  assert.equal(cronMatches(s, utc("2026-08-17T00:00:00Z")), true); // a Monday
+  assert.equal(cronMatches(s, utc("2026-08-18T00:00:00Z")), false); // Tuesday, not the 15th
+});
+
+test("only dom restricted → dow ignored (AND with wildcard)", () => {
+  const s = parseCron("0 0 1 * *");
+  assert.equal(cronMatches(s, utc("2026-08-01T00:00:00Z")), true);
+  assert.equal(cronMatches(s, utc("2026-08-02T00:00:00Z")), false);
+});
+
+test("a `*/n` day field counts as a wildcard (Vixie rule), so dow alone applies", () => {
+  // dom is `*/1` (a star field) + dow=Monday → only Mondays match, not every day.
+  const s = parseCron("0 0 */1 * 1");
+  assert.equal(s.domWildcard, true);
+  assert.equal(s.dowWildcard, false);
+  assert.equal(cronMatches(s, utc("2026-08-17T00:00:00Z")), true); // Monday
+  assert.equal(cronMatches(s, utc("2026-08-18T00:00:00Z")), false); // Tuesday
+  // An explicit full range is NOT a wildcard: `1-31` stays restricted → OR rule.
+  const r = parseCron("0 0 1-31 * 1");
+  assert.equal(r.domWildcard, false);
+  assert.equal(cronMatches(r, utc("2026-08-18T00:00:00Z")), true); // any dom 1-31
+});
+
+test("nextCronFire returns the first fire strictly after 'after'", () => {
+  const s = parseCron("0 6 * * *");
+  const next = nextCronFire(s, utc("2026-08-01T06:00:00Z"));
+  assert.equal(next?.toISOString(), "2026-08-02T06:00:00.000Z"); // strictly after, so next day
+  const next2 = nextCronFire(s, utc("2026-08-01T05:59:00Z"));
+  assert.equal(next2?.toISOString(), "2026-08-01T06:00:00.000Z");
+});
+
+test("nextCronFire returns undefined for an impossible spec", () => {
+  const s = parseCron("0 0 30 2 *"); // Feb 30 never exists
+  assert.equal(nextCronFire(s, utc("2026-01-01T00:00:00Z")), undefined);
+});
+
+test("cronFiresBetween enumerates due fires in a window", () => {
+  const s = parseCron("0 * * * *"); // top of every hour
+  const fires = cronFiresBetween(
+    s,
+    utc("2026-08-01T00:15:00Z"),
+    utc("2026-08-01T03:00:00Z"),
+  );
+  assert.deepEqual(
+    fires.map((d) => d.toISOString()),
+    [
+      "2026-08-01T01:00:00.000Z",
+      "2026-08-01T02:00:00.000Z",
+      "2026-08-01T03:00:00.000Z",
+    ],
+  );
+});

package/src/runtime/core/modules/cron.ts

@@ -0,0 +1,150 @@
+// A small, dependency-free 5-field crontab evaluator (ADR 0025 §2) — the schedule engine
+// behind `cron` triggers. Specs are evaluated in **UTC**. Fields, in order:
+//
+//   minute (0-59)  hour (0-23)  day-of-month (1-31)  month (1-12)  day-of-week (0-6, 0=Sun)
+//
+// Each field supports `*`, a number, `a-b` ranges, `*/n` and `a-b/n` steps, and comma lists
+// of any of those. Month and day-of-week also accept three-letter names (jan…dec, sun…sat).
+// Day-of-month and day-of-week follow the standard cron rule: when **both** are restricted
+// (neither is `*`), a day matches if it satisfies **either** field.
+
+/** A parsed schedule: the allowed value set per field, plus whether dom/dow are wildcards. */
+export interface CronSchedule {
+  minutes: Set<number>;
+  hours: Set<number>;
+  daysOfMonth: Set<number>;
+  months: Set<number>;
+  daysOfWeek: Set<number>;
+  /** dom / dow were `*` (unrestricted) — controls the OR-vs-AND day rule. */
+  domWildcard: boolean;
+  dowWildcard: boolean;
+}
+
+const MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+const DOWS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+
+function nameToNumber(token: string, names: string[], offset: number): string {
+  const i = names.indexOf(token.toLowerCase());
+  return i >= 0 ? String(i + offset) : token;
+}
+
+/** Parse one field into the set of matching integers in [min,max]. */
+function parseField(field: string, min: number, max: number, names?: string[]): Set<number> {
+  const out = new Set<number>();
+  for (const partRaw of field.split(",")) {
+    const part = partRaw.trim();
+    if (part === "") throw new Error(`cron: empty term in "${field}"`);
+    let step = 1;
+    let range = part;
+    const slash = part.indexOf("/");
+    if (slash >= 0) {
+      range = part.slice(0, slash);
+      if (range === "") throw new Error(`cron: missing range before "/" in "${part}"`);
+      const stepText = part.slice(slash + 1);
+      step = Number(stepText);
+      if (stepText === "" || !Number.isInteger(step) || step <= 0) {
+        throw new Error(`cron: bad step in "${part}"`);
+      }
+    }
+    let lo: number;
+    let hi: number;
+    if (range === "*") {
+      lo = min;
+      hi = max;
+    } else {
+      const dash = range.indexOf("-", range.startsWith("-") ? 1 : 0);
+      if (dash > 0) {
+        lo = Number(names ? nameToNumber(range.slice(0, dash), names, min) : range.slice(0, dash));
+        hi = Number(names ? nameToNumber(range.slice(dash + 1), names, min) : range.slice(dash + 1));
+      } else {
+        lo = hi = Number(names ? nameToNumber(range, names, min) : range);
+      }
+    }
+    if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < min || hi > max || lo > hi) {
+      throw new Error(`cron: value out of range [${min},${max}] in "${part}"`);
+    }
+    for (let v = lo; v <= hi; v += step) out.add(v);
+  }
+  return out;
+}
+
+/** Parse a 5-field crontab spec into a `CronSchedule`. Throws on a malformed spec. */
+export function parseCron(spec: string): CronSchedule {
+  const fields = spec.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(`cron: expected 5 fields, got ${fields.length} in "${spec}"`);
+  }
+  const [min, hr, dom, mon, dow] = fields;
+  // Normalise day-of-week 7 → 0 (both are Sunday in common cron dialects).
+  const daysOfWeek = parseField(dow, 0, 7, DOWS);
+  if (daysOfWeek.delete(7)) daysOfWeek.add(0);
+  return {
+    minutes: parseField(min, 0, 59),
+    hours: parseField(hr, 0, 23),
+    daysOfMonth: parseField(dom, 1, 31),
+    months: parseField(mon, 1, 12, MONTHS),
+    daysOfWeek,
+    // The OR-vs-AND day rule keys off whether dom/dow are "star" fields. Following Vixie
+    // cron, a field counts as a wildcard when it *starts* with `*` (so `*` and `*/n` both
+    // qualify); an explicit full range like `1-31` is a restricted field, not a wildcard.
+    domWildcard: dom.trim().startsWith("*"),
+    dowWildcard: dow.trim().startsWith("*"),
+  };
+}
+
+/** Does `date` (read in UTC) match the schedule? */
+export function cronMatches(s: CronSchedule, date: Date): boolean {
+  if (!s.minutes.has(date.getUTCMinutes())) return false;
+  if (!s.hours.has(date.getUTCHours())) return false;
+  if (!s.months.has(date.getUTCMonth() + 1)) return false;
+  const domHit = s.daysOfMonth.has(date.getUTCDate());
+  const dowHit = s.daysOfWeek.has(date.getUTCDay());
+  // Standard cron day rule: both restricted → OR; otherwise the restricted one(s) must hit.
+  if (!s.domWildcard && !s.dowWildcard) return domHit || dowHit;
+  if (!s.domWildcard) return domHit;
+  if (!s.dowWildcard) return dowHit;
+  return true;
+}
+
+/** Ceiling to the start of the next minute (UTC), so scheduling lands on minute boundaries. */
+function nextMinute(after: Date): Date {
+  const d = new Date(after.getTime());
+  d.setUTCSeconds(0, 0);
+  d.setUTCMinutes(d.getUTCMinutes() + 1);
+  return d;
+}
+
+/**
+ * The first fire strictly after `after`. Scans minute-by-minute (UTC) up to a bounded
+ * horizon; returns `undefined` if nothing matches within ~4 years (an impossible spec,
+ * e.g. Feb 30). The bound keeps a pathological spec from spinning forever.
+ */
+export function nextCronFire(s: CronSchedule, after: Date): Date | undefined {
+  let cur = nextMinute(after);
+  const limit = 4 * 366 * 24 * 60; // minutes in ~4 years
+  for (let i = 0; i < limit; i++) {
+    if (cronMatches(s, cur)) return cur;
+    cur = new Date(cur.getTime() + 60_000);
+  }
+  return undefined;
+}
+
+/**
+ * The fire instants strictly between `after` and `until` (both exclusive on `after`,
+ * inclusive on `until`). Used by the `onMissed` catch-up policy to enumerate fires that
+ * were due while the app was down. Bounded to avoid unbounded output on a huge gap.
+ */
+export function cronFiresBetween(
+  s: CronSchedule,
+  after: Date,
+  until: Date,
+  max = 10_000,
+): Date[] {
+  const fires: Date[] = [];
+  let next = nextCronFire(s, after);
+  while (next && next.getTime() <= until.getTime() && fires.length < max) {
+    fires.push(next);
+    next = nextCronFire(s, next);
+  }
+  return fires;
+}

package/src/runtime/core/modules/triggers.test.ts

@@ -0,0 +1,269 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import type { AppApi, RuntimeContext } from "../context.ts";
+import type { HttpRequest } from "../host.ts";
+import type { TriggerDecl } from "../manifest.ts";
+import { makeRouter } from "../router.ts";
+import { evalCorrelation, mountTriggers, runTriggerAction, type SchedulerDeps } from "./triggers.ts";
+
+interface EngineCall {
+  kind: "start" | "message";
+  target: string;
+  variables?: Record<string, unknown>;
+  correlationKey?: string;
+}
+
+function fakeApp(): { app: AppApi; calls: EngineCall[]; logs: Array<{ level: string; msg: string }> } {
+  const calls: EngineCall[] = [];
+  const logs: Array<{ level: string; msg: string }> = [];
+  const app = {
+    env: () => undefined,
+    log: (level: string, msg: string) => logs.push({ level, msg }),
+    engine: {
+      createInstance: (input: { processDefinitionId: string; variables?: Record<string, unknown> }) => {
+        calls.push({ kind: "start", target: input.processDefinitionId, variables: input.variables });
+        return Promise.resolve({ processInstanceKey: "pi-1" });
+      },
+      publishMessage: (input: { name: string; correlationKey?: string; variables?: Record<string, unknown> }) => {
+        calls.push({ kind: "message", target: input.name, correlationKey: input.correlationKey, variables: input.variables });
+        return Promise.resolve();
+      },
+    },
+  } as unknown as AppApi;
+  return { app, calls, logs };
+}
+
+function fakeCtx(triggers: TriggerDecl[]): { ctx: RuntimeContext; hostLogs: Array<{ level: string; msg: string }> } {
+  const hostLogs: Array<{ level: string; msg: string }> = [];
+  const ctx = {
+    root: "/app",
+    manifest: { schemaVersion: 1, id: "t", name: "T", triggers } as RuntimeContext["manifest"],
+    host: { log: (level: string, msg: string) => hostLogs.push({ level, msg }) },
+  } as unknown as RuntimeContext;
+  return { ctx, hostLogs };
+}
+
+/** A deterministic scheduler: timers fire only when the clock is advanced past their deadline. */
+function fakeScheduler(startMs: number): SchedulerDeps & { advance: (ms: number) => Promise<void>; pending: () => number } {
+  let clock = startMs;
+  let seq = 0;
+  const timers = new Map<number, { at: number; fn: () => void }>();
+  return {
+    now: () => clock,
+    setTimer: (fn, delayMs) => {
+      const id = ++seq;
+      timers.set(id, { at: clock + delayMs, fn });
+      return id;
+    },
+    clearTimer: (h) => {
+      timers.delete(h as number);
+    },
+    pending: () => timers.size,
+    // Advance the clock, firing every timer whose deadline has passed (in order), letting
+    // microtasks (the async action) drain between fires.
+    advance: async (ms) => {
+      const target = clock + ms;
+      // Fire due timers one at a time; a timer's callback may schedule a new one.
+      // deno-lint-ignore no-constant-condition
+      while (true) {
+        let nextId = -1;
+        let nextAt = Infinity;
+        for (const [id, t] of timers) {
+          if (t.at <= target && t.at < nextAt) {
+            nextAt = t.at;
+            nextId = id;
+          }
+        }
+        if (nextId < 0) break;
+        const t = timers.get(nextId)!;
+        timers.delete(nextId);
+        clock = t.at;
+        t.fn();
+        await Promise.resolve();
+        await Promise.resolve();
+      }
+      clock = target;
+    },
+  };
+}
+
+test("evalCorrelation resolves literals and = body paths", () => {
+  const scope = { body: { taskId: 42 }, headers: {}, query: {} };
+  assert.equal(evalCorrelation("lit", scope), "lit");
+  assert.equal(evalCorrelation("= body.taskId", scope), "42");
+  assert.equal(evalCorrelation("= body.missing", scope), undefined);
+  assert.equal(evalCorrelation(undefined, scope), undefined);
+});
+
+test("resolveExpr ignores inherited (prototype-chain) properties", () => {
+  const scope = { body: { id: "x" }, headers: {}, query: {} };
+  // `constructor`/`toString` live on Object.prototype, not the body — must not resolve.
+  assert.equal(evalCorrelation("= body.constructor", scope), undefined);
+  assert.equal(evalCorrelation("= body.toString", scope), undefined);
+  assert.equal(evalCorrelation("= body.__proto__", scope), undefined);
+});
+
+test("evalCorrelation returns undefined for a non-scalar result", () => {
+  const scope = { body: { obj: { a: 1 }, arr: [1, 2], n: 7, flag: false }, headers: {}, query: {} };
+  assert.equal(evalCorrelation("= body.obj", scope), undefined);
+  assert.equal(evalCorrelation("= body.arr", scope), undefined);
+  assert.equal(evalCorrelation("= body.n", scope), "7");
+  assert.equal(evalCorrelation("= body.flag", scope), "false");
+});
+
+test("runTriggerAction starts a process with action.variables", async () => {
+  const { app, calls } = fakeApp();
+  const res = await runTriggerAction(app, { start: "proc-1", variables: { a: 1 } }, {
+    body: { ignored: true },
+    headers: {},
+    query: {},
+  });
+  assert.equal(res.kind, "start");
+  assert.equal(res.target, "proc-1");
+  assert.deepEqual(calls, [{ kind: "start", target: "proc-1", variables: { a: 1 } }]);
+});
+
+test("runTriggerAction publishes a message, defaulting variables to the body", async () => {
+  const { app, calls } = fakeApp();
+  const res = await runTriggerAction(app, { message: "msg-1", correlationKey: "= body.id" }, {
+    body: { id: "k1", v: 9 },
+    headers: {},
+    query: {},
+  });
+  assert.equal(res.kind, "message");
+  assert.equal(res.correlationKey, "k1");
+  assert.deepEqual(calls, [
+    { kind: "message", target: "msg-1", correlationKey: "k1", variables: { id: "k1", v: 9 } },
+  ]);
+});
+
+test("runTriggerAction resolves a FEEL-string action.variables to an object", async () => {
+  const { app, calls } = fakeApp();
+  const res = await runTriggerAction(app, { start: "proc-2", variables: "= body.vars" }, {
+    body: { vars: { a: 1, b: "x" }, other: true },
+    headers: {},
+    query: {},
+  });
+  assert.equal(res.kind, "start");
+  assert.deepEqual(calls, [{ kind: "start", target: "proc-2", variables: { a: 1, b: "x" } }]);
+});
+
+test("runTriggerAction falls back to the body when a FEEL-string variables misses", async () => {
+  const { app, calls } = fakeApp();
+  await runTriggerAction(app, { message: "m", variables: "= body.nope" }, {
+    body: { k: 1 },
+    headers: {},
+    query: {},
+  });
+  assert.deepEqual(calls[0].variables, { k: 1 });
+});
+
+test("cron trigger fires its action on schedule and reschedules", async () => {
+  const { app, calls } = fakeApp();
+  const { ctx } = fakeCtx([
+    { id: "nightly", type: "cron", spec: "0 6 * * *", action: { start: "daily-report" } },
+  ]);
+  // 2026-08-01T05:00:00Z — next 06:00 fire is 1h away.
+  const sched = fakeScheduler(Date.parse("2026-08-01T05:00:00Z"));
+  const handle = mountTriggers(ctx, app, sched);
+  assert.deepEqual(handle.describe?.(), { mounted: [], scheduled: ["nightly@0 6 * * *"] });
+  assert.equal(sched.pending(), 1);
+
+  await sched.advance(60 * 60 * 1000); // advance 1h → 06:00 fires
+  assert.equal(calls.length, 1);
+  assert.deepEqual(calls[0], { kind: "start", target: "daily-report", variables: { firedAt: "2026-08-01T06:00:00.000Z" } });
+  assert.equal(sched.pending(), 1); // rearmed for the next day
+
+  await sched.advance(24 * 60 * 60 * 1000); // next 06:00
+  assert.equal(calls.length, 2);
+  assert.equal(calls[1].variables?.firedAt, "2026-08-02T06:00:00.000Z");
+
+  await handle.stop();
+  assert.equal(sched.pending(), 0);
+  await sched.advance(48 * 60 * 60 * 1000); // no more fires after stop
+  assert.equal(calls.length, 2);
+});
+
+test("cron trigger with onMissed once/all warns and degrades to skip", async () => {
+  const { app, logs } = fakeApp();
+  const { ctx } = fakeCtx([
+    { id: "c", type: "cron", spec: "0 6 * * *", onMissed: "all", action: { start: "p" } },
+  ]);
+  const sched = fakeScheduler(Date.parse("2026-08-01T05:00:00Z"));
+  mountTriggers(ctx, app, sched);
+  const warned = logs.find((l) => l.level === "warn" && /onMissed="all"/.test(l.msg));
+  assert.ok(warned, "expected a warning that onMissed=all degrades to skip");
+});
+
+test("cron trigger with an invalid spec logs an error and does not schedule", () => {
+  const { app, logs } = fakeApp();
+  const { ctx } = fakeCtx([{ id: "bad", type: "cron", spec: "not a cron", action: { start: "p" } }]);
+  const sched = fakeScheduler(0);
+  const handle = mountTriggers(ctx, app, sched);
+  assert.equal(sched.pending(), 0);
+  assert.deepEqual(handle.describe?.(), { mounted: [], scheduled: [] });
+  assert.ok(logs.some((l) => l.level === "error" && /invalid cron spec/.test(l.msg)));
+});
+
+test("cron trigger with no actionable action is not scheduled", () => {
+  const { app, logs } = fakeApp();
+  const { ctx } = fakeCtx([{ id: "noop", type: "cron", spec: "0 6 * * *" }]);
+  const sched = fakeScheduler(0);
+  const handle = mountTriggers(ctx, app, sched);
+  assert.equal(sched.pending(), 0);
+  assert.deepEqual(handle.describe?.(), { mounted: [], scheduled: [] });
+  assert.ok(logs.some((l) => l.level === "warn" && /no action\.start\/message/.test(l.msg)));
+});
+
+test("cron trigger with an impossible spec warns and is not reported as scheduled", () => {
+  const { app, logs } = fakeApp();
+  const { ctx } = fakeCtx([{ id: "feb30", type: "cron", spec: "0 0 30 2 *", action: { start: "p" } }]);
+  const sched = fakeScheduler(Date.parse("2026-01-01T00:00:00Z"));
+  const handle = mountTriggers(ctx, app, sched);
+  assert.equal(sched.pending(), 0);
+  assert.deepEqual(handle.describe?.(), { mounted: [], scheduled: [] });
+  assert.ok(logs.some((l) => l.level === "warn" && /never fires/.test(l.msg)));
+});
+
+test("cron trigger with a far-future fire chunks the wait instead of overflowing setTimeout", async () => {
+  const { app, calls } = fakeApp();
+  // Annual: Jan 1 00:00. Start just after so the next fire is ~1 year away (>> 24.8 days).
+  const { ctx } = fakeCtx([{ id: "annual", type: "cron", spec: "0 0 1 1 *", action: { start: "yr" } }]);
+  const start = Date.parse("2026-01-01T00:01:00Z");
+  const nextFire = Date.parse("2027-01-01T00:00:00Z");
+  const sched = fakeScheduler(start);
+  const handle = mountTriggers(ctx, app, sched);
+  assert.equal(sched.pending(), 1);
+
+  // Advance to just before the deadline: the wait was chunked (re-armed) and never fired.
+  await sched.advance(nextFire - start - 60_000);
+  assert.equal(calls.length, 0);
+  assert.equal(sched.pending(), 1);
+
+  // Cross the deadline: fires exactly once, on the intended instant, then re-arms.
+  await sched.advance(120_000);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].variables?.firedAt, "2027-01-01T00:00:00.000Z");
+  await handle.stop();
+});
+
+test("webhook trigger still routes and publishes", async () => {
+  const { app, calls } = fakeApp();
+  const { ctx } = fakeCtx([
+    { id: "hook", type: "webhook", action: { message: "got-it", correlationKey: "= body.id" } },
+  ]);
+  const handle = mountTriggers(ctx, app);
+  const router = makeRouter(handle.routes) as unknown as (r: HttpRequest) => Promise<{ status?: number; body?: string }>;
+  const res = await router({
+    method: "POST",
+    path: "/hooks/hook",
+    query: new URLSearchParams(""),
+    headers: new Headers(),
+    text: () => Promise.resolve(JSON.stringify({ id: "k9" })),
+  });
+  assert.equal(res.status ?? 200, 200);
+  assert.deepEqual(calls, [
+    { kind: "message", target: "got-it", correlationKey: "k9", variables: { id: "k9" } },
+  ]);
+  await handle.stop();
+});