okengine 0.18.4 → 0.19.0

package/src/elements/clock/declare.ts

@@ -3,9 +3,18 @@
  *
  * Named clocks are reconciled into the Store at boot; the scheduler reads
  * the effective state from the Store (console §5), never the code directly.
+ *
+ * Helpers (`clock.daily` · `cron` · `every` · …) compile to the same
+ * {@link ClockDecl} shape as `clock(name, { cron })`.
  */
 
 import { clockRegistry } from "../../kernel/element-registries.ts";
+import {
+  assertValidCronExpression,
+  buildCronExpression,
+  type CronField,
+  type CronFields,
+} from "./cron-fields.ts";
 
 /** Options for {@link clock}. */
 export interface ClockOptions {
@@ -29,6 +38,51 @@ export interface ClockOptions {
   readonly perTenant?: boolean;
 }
 
+/**
+ * Shared options for convenience helpers (no `cron` / `every` — those are
+ * supplied by the helper).
+ */
+export type ClockHelperOptions = Omit<ClockOptions, "cron" | "every">;
+
+/** Options for {@link clock.daily}. */
+export type ClockDailyOptions = ClockHelperOptions & {
+  /** Wall-clock time (`"06:00"`). Default midnight. */
+  readonly at?: string;
+};
+
+/** Options for {@link clock.hourly}. */
+export type ClockHourlyOptions = ClockHelperOptions & {
+  /** Minute of each hour (default `0`). */
+  readonly minute?: number;
+};
+
+/** Day-of-week token for {@link clock.weekly}. */
+export type ClockWeekday = CronField;
+
+/** Options for {@link clock.weekly}. */
+export type ClockWeeklyOptions = ClockHelperOptions & {
+  /** Day(s) of week (`"mon"` · `1` · `["mon", "fri"]` · `"1-5"`). */
+  readonly on: ClockWeekday;
+  /** Wall-clock time (default `"00:00"`). */
+  readonly at?: string;
+};
+
+/** Options for {@link clock.monthly}. */
+export type ClockMonthlyOptions = ClockHelperOptions & {
+  /** Day(s) of month (`1` · `[1, 15]`). */
+  readonly on: CronField;
+  /** Wall-clock time (default `"00:00"`). */
+  readonly at?: string;
+};
+
+/**
+ * Structured cron bag + shared helper options for {@link clock.cron}.
+ *
+ * Schedule keys (`minute` · `hour` · … · `at`) build the expression;
+ * remaining keys are {@link ClockHelperOptions}.
+ */
+export type ClockCronFieldsOptions = CronFields & ClockHelperOptions;
+
 /**
  * Declared clock handle — reconciled into `oke_crons` at boot.
  */
@@ -41,6 +95,13 @@ export interface ClockDecl {
   readonly every?: string;
   /** IANA timezone. */
   readonly timezone: string;
+  /**
+   * When true, `timezone` was omitted at declare and may be replaced by
+   * `oke({ clock: { timezone } })` / `defineConfig({ clock: { timezone } })`.
+   *
+   * @internal
+   */
+  readonly timezoneDefaulted?: boolean;
   /** Whether Console override is allowed. */
   readonly overridable: boolean;
   /** Optional human description. */
@@ -80,11 +141,16 @@ function declareClock(name: string, options: ClockOptions = {}): ClockDecl {
   if (!options.cron && !options.every) {
     throw new TypeError(`clock("${name}"): require cron or every`);
   }
+  if (options.cron) {
+    assertValidCronExpression(options.cron, `clock("${name}")`);
+  }
+  const timezoneDefaulted = options.timezone === undefined;
   const decl: ClockDecl = {
     name,
     cron: options.cron,
     every: options.every,
     timezone: options.timezone ?? "UTC",
+    ...(timezoneDefaulted ? { timezoneDefaulted: true } : {}),
     overridable: options.overridable ?? false,
     ...(options.description !== undefined ? { description: options.description } : {}),
     ...(options.perTenant === true ? { perTenant: true } : {}),
@@ -93,6 +159,35 @@ function declareClock(name: string, options: ClockOptions = {}): ClockDecl {
   return decl;
 }
 
+/**
+ * Apply an app-wide default timezone to clocks that omitted `timezone`.
+ *
+ * Explicit `timezone: "…"` on a declaration always wins. When `defaultTimezone`
+ * is omitted / empty, defaulted clocks stay on `"UTC"`.
+ *
+ * @param decls - Declared clocks
+ * @param defaultTimezone - IANA zone from `oke({ clock })` / config
+ */
+export function applyClockTimezoneDefaults(
+  decls: readonly ClockDecl[],
+  defaultTimezone: string | undefined,
+): ClockDecl[] {
+  const zone = defaultTimezone?.trim();
+  if (!zone) return decls.slice();
+  return decls.map((d) => {
+    if (!d.timezoneDefaulted) return d;
+    return {
+      name: d.name,
+      ...(d.cron !== undefined ? { cron: d.cron } : {}),
+      ...(d.every !== undefined ? { every: d.every } : {}),
+      timezone: zone,
+      overridable: d.overridable,
+      ...(d.description !== undefined ? { description: d.description } : {}),
+      ...(d.perTenant === true ? { perTenant: true } : {}),
+    };
+  });
+}
+
 /**
  * Per-tenant schedule template — one `oke_crons` row per tenant.
  *
@@ -103,6 +198,134 @@ function declarePerTenantClock(name: string, options: ClockOptions = {}): ClockD
   return declareClock(name, { ...options, perTenant: true });
 }
 
+/**
+ * Interval helper — `clock.every("health.ping", "30s")`.
+ *
+ * @param name - Schedule name
+ * @param duration - Interval (`"30s"`, `"1h"`, …)
+ * @param options - Timezone / overridable / description / perTenant
+ */
+function declareEveryClock(
+  name: string,
+  duration: string,
+  options: ClockHelperOptions = {},
+): ClockDecl {
+  return declareClock(name, { ...options, every: duration });
+}
+
+/**
+ * Split structured cron fields from shared helper options.
+ *
+ * @param bag - Mixed `CronFields` + `ClockHelperOptions`
+ */
+function splitCronBag(bag: ClockCronFieldsOptions): {
+  readonly fields: CronFields;
+  readonly opts: ClockHelperOptions;
+} {
+  const {
+    minute,
+    hour,
+    dayOfMonth,
+    month,
+    dayOfWeek,
+    at,
+    timezone,
+    overridable,
+    description,
+    perTenant,
+  } = bag;
+  return {
+    fields: {
+      ...(minute !== undefined ? { minute } : {}),
+      ...(hour !== undefined ? { hour } : {}),
+      ...(dayOfMonth !== undefined ? { dayOfMonth } : {}),
+      ...(month !== undefined ? { month } : {}),
+      ...(dayOfWeek !== undefined ? { dayOfWeek } : {}),
+      ...(at !== undefined ? { at } : {}),
+    },
+    opts: {
+      ...(timezone !== undefined ? { timezone } : {}),
+      ...(overridable !== undefined ? { overridable } : {}),
+      ...(description !== undefined ? { description } : {}),
+      ...(perTenant !== undefined ? { perTenant } : {}),
+    },
+  };
+}
+
+/**
+ * Cron helper — string expression or structured fields.
+ *
+ * @param name - Schedule name
+ * @param expressionOrFields - Five-field / nickname string, or field bag
+ * @param options - Shared options when the second arg is a string
+ */
+function declareCronClock(
+  name: string,
+  expressionOrFields: string | ClockCronFieldsOptions,
+  options: ClockHelperOptions = {},
+): ClockDecl {
+  if (typeof expressionOrFields === "string") {
+    return declareClock(name, { ...options, cron: expressionOrFields });
+  }
+  const { fields, opts } = splitCronBag(expressionOrFields);
+  const cron = buildCronExpression(fields);
+  return declareClock(name, { ...opts, cron });
+}
+
+/**
+ * Daily preset — midnight unless `at` is set.
+ *
+ * @param name - Schedule name
+ * @param options - `at` + shared options
+ */
+function declareDailyClock(name: string, options: ClockDailyOptions = {}): ClockDecl {
+  const { at, ...opts } = options;
+  const cron = buildCronExpression({ at: at ?? "00:00" });
+  return declareClock(name, { ...opts, cron });
+}
+
+/**
+ * Hourly preset — top of the hour unless `minute` is set.
+ *
+ * @param name - Schedule name
+ * @param options - `minute` + shared options
+ */
+function declareHourlyClock(name: string, options: ClockHourlyOptions = {}): ClockDecl {
+  const { minute, ...opts } = options;
+  const cron = buildCronExpression({ minute: minute ?? 0 });
+  return declareClock(name, { ...opts, cron });
+}
+
+/**
+ * Weekly / multi-weekday preset.
+ *
+ * @param name - Schedule name
+ * @param options - `on` (required) + optional `at`
+ */
+function declareWeeklyClock(name: string, options: ClockWeeklyOptions): ClockDecl {
+  const { on, at, ...opts } = options;
+  const cron = buildCronExpression({
+    at: at ?? "00:00",
+    dayOfWeek: on,
+  });
+  return declareClock(name, { ...opts, cron });
+}
+
+/**
+ * Monthly / multi-DOM preset.
+ *
+ * @param name - Schedule name
+ * @param options - `on` (required) + optional `at`
+ */
+function declareMonthlyClock(name: string, options: ClockMonthlyOptions): ClockDecl {
+  const { on, at, ...opts } = options;
+  const cron = buildCronExpression({
+    at: at ?? "00:00",
+    dayOfMonth: on,
+  });
+  return declareClock(name, { ...opts, cron });
+}
+
 /**
  * Separator between a per-tenant template name and the tenant id.
  */
@@ -137,12 +360,33 @@ export function parsePerTenantCronName(
   return { template, tenantId };
 }
 
+/** Public Clock declaration namespace — callable + convenience helpers. */
+export interface ClockNamespace {
+  (name: string, options?: ClockOptions): ClockDecl;
+  readonly perTenant: typeof declarePerTenantClock;
+  readonly every: typeof declareEveryClock;
+  readonly cron: typeof declareCronClock;
+  readonly daily: typeof declareDailyClock;
+  readonly hourly: typeof declareHourlyClock;
+  readonly weekly: typeof declareWeeklyClock;
+  readonly monthly: typeof declareMonthlyClock;
+}
+
 /**
  * Declare a named clock / cron schedule.
  *
+ * Helpers: `clock.every` · `clock.cron` · `clock.daily` · `clock.hourly` ·
+ * `clock.weekly` · `clock.monthly` · `clock.perTenant`.
+ *
  * @param name - Schedule name
  * @param options - `cron` and/or `every`, timezone, overridable
  */
-export const clock: ((name: string, options?: ClockOptions) => ClockDecl) & {
-  readonly perTenant: typeof declarePerTenantClock;
-} = Object.assign(declareClock, { perTenant: declarePerTenantClock });
+export const clock: ClockNamespace = Object.assign(declareClock, {
+  perTenant: declarePerTenantClock,
+  every: declareEveryClock,
+  cron: declareCronClock,
+  daily: declareDailyClock,
+  hourly: declareHourlyClock,
+  weekly: declareWeeklyClock,
+  monthly: declareMonthlyClock,
+});

package/src/elements/clock.ts

@@ -14,9 +14,29 @@ export {
   clock,
   perTenantCronName,
   parsePerTenantCronName,
+  applyClockTimezoneDefaults,
   PER_TENANT_CRON_SEP,
 } from "./clock/declare.ts";
-export type { ClockDecl, ClockOptions } from "./clock/declare.ts";
+export type {
+  ClockDecl,
+  ClockOptions,
+  ClockHelperOptions,
+  ClockDailyOptions,
+  ClockHourlyOptions,
+  ClockWeeklyOptions,
+  ClockMonthlyOptions,
+  ClockCronFieldsOptions,
+  ClockWeekday,
+  ClockNamespace,
+} from "./clock/declare.ts";
+
+export {
+  buildCronExpression,
+  parseAtTime,
+  serializeCronField,
+  assertValidCronExpression,
+} from "./clock/cron-fields.ts";
+export type { CronField, CronFields } from "./clock/cron-fields.ts";
 
 export { parseDurationMs } from "./clock/duration.ts";
 

package/src/elements/index.ts

@@ -43,7 +43,11 @@ export type {
 export { signal, createSignalRuntime } from "./signal.ts";
 export type {
   SignalDecl,
+  SignalLiveOptions,
+  SignalNamespace,
   SignalOptions,
+  SignalRetention,
+  SignalSharedOptions,
   SignalRuntime,
   CreateSignalRuntimeOptions,
 } from "./signal.ts";
@@ -59,6 +63,17 @@ export {
   parseDurationMs,
 } from "./clock.ts";
 export type { ClockDecl, ClockOptions, ClockRuntime, TimeTravel, DurableResult } from "./clock.ts";
+export type {
+  ClockHelperOptions,
+  ClockDailyOptions,
+  ClockHourlyOptions,
+  ClockWeeklyOptions,
+  ClockMonthlyOptions,
+  ClockCronFieldsOptions,
+  ClockNamespace,
+  CronField,
+  CronFields,
+} from "./clock.ts";
 
 export {
   gate,

package/src/elements/signal/chaos-child.ts

@@ -26,8 +26,7 @@ if (!durablePath) {
   process.exit(2);
 }
 
-const orderPlaced = signal("order-placed", {
-  delivery: "once",
+const orderPlaced = signal.once("order-placed", {
   retries: 3,
   deadLetter: true,
   // Producer-only / cross-process consumer: no local subscriber at emit time.

package/src/elements/signal/declare.ts

@@ -1,8 +1,8 @@
 /**
  * Signal declaration — data in motion.
  *
- * `delivery` is mandatory with no default: queue / pub-sub / stream were
- * always one object with different physics (unified-theory §3).
+ * Delivery physics are chosen by helper name (`signal.once` / `broadcast` /
+ * `live`), matching `http.get` / `http.post` — no default, no options bag for mode.
  */
 
 import type { SignalDelivery } from "../../manifest/types.ts";
@@ -17,8 +17,8 @@ export interface SignalRetention {
   readonly maxCount?: number;
 }
 
-/** Shared options for every {@link signal} delivery mode. */
-interface SignalOptionsBase {
+/** Shared options for every {@link signal} delivery helper. */
+export interface SignalSharedOptions {
   /** Optional human description for Console / docs (falls back to the signal name). */
   readonly description?: string;
   /** Max delivery attempts before dead-letter (once). */
@@ -34,20 +34,16 @@ interface SignalOptionsBase {
   readonly optional?: boolean;
 }
 
+/** Options for {@link signal.live} — shared fields plus optional tape retention. */
+export type SignalLiveOptions = SignalSharedOptions & {
+  readonly retention?: SignalRetention;
+};
+
 /**
- * Options for {@link signal}.
- *
- * `retention` is live-only — a type error on `once` / `broadcast`.
+ * @deprecated Prefer {@link SignalSharedOptions} / {@link SignalLiveOptions}.
+ * Alias kept for type-only imports that still name `SignalOptions`.
  */
-export type SignalOptions =
-  | (SignalOptionsBase & {
-      readonly delivery: "once" | "broadcast";
-      readonly retention?: never;
-    })
-  | (SignalOptionsBase & {
-      readonly delivery: "live";
-      readonly retention?: SignalRetention;
-    });
+export type SignalOptions = SignalSharedOptions | SignalLiveOptions;
 
 /**
  * Declared signal handle — usable as `on(signal, flow)`, `fx.emit(signal, …)`,
@@ -74,8 +70,33 @@ export interface SignalDecl<T = unknown> {
   readonly _payload?: T;
 }
 
+/** Public Signal declaration namespace — `signal.once` / `broadcast` / `live`. */
+export interface SignalNamespace {
+  /**
+   * Competing queue — exactly one subscriber claims each message.
+   *
+   * @param name - Signal name
+   * @param options - Retry / DLQ / schema policy
+   */
+  once<T = unknown>(name: string, options?: SignalSharedOptions): SignalDecl<T>;
+  /**
+   * Pub/sub fan-out — every subscriber receives each message.
+   *
+   * @param name - Signal name
+   * @param options - Schema / optional policy
+   */
+  broadcast<T = unknown>(name: string, options?: SignalSharedOptions): SignalDecl<T>;
+  /**
+   * Live SSE tape — retained stream for `http.live` / `.live(signal)`.
+   *
+   * @param name - Signal name
+   * @param options - Retention / schema / optional policy
+   */
+  live<T = unknown>(name: string, options?: SignalLiveOptions): SignalDecl<T>;
+}
+
 /**
- * `signal()` pushes into the shared {@link signalRegistry}
+ * `signal.*` pushes into the shared {@link signalRegistry}
  * (`src/kernel/element-registries.ts`) so {@link oke} can auto-populate
  * `signals` with zero explicit array — mirrors the {@link on} trigger-drain
  * registry (`src/kernel/on.ts`).
@@ -95,45 +116,52 @@ export function resetSignals(): void {
   signalRegistry.length = 0;
 }
 
-/**
- * Declare a signal. `delivery` is mandatory — omitting it is a type error.
- *
- * @param name - Signal name
- * @param options - Delivery physics and retry / DLQ policy
- */
-export function signal<T = unknown>(name: string, options: SignalOptions): SignalDecl<T> {
-  if (
-    options.delivery !== "once" &&
-    options.delivery !== "broadcast" &&
-    options.delivery !== "live"
-  ) {
-    throw new TypeError(`signal("${name}"): delivery is mandatory (once | broadcast | live)`);
-  }
+function declareSignal<T = unknown>(
+  name: string,
+  delivery: SignalDelivery,
+  options: SignalSharedOptions | SignalLiveOptions = {},
+): SignalDecl<T> {
   const retention = "retention" in options ? options.retention : undefined;
-  if (retention !== undefined && options.delivery !== "live") {
-    throw new TypeError(`signal("${name}"): retention is only valid with delivery: "live"`);
+  if (retention !== undefined && delivery !== "live") {
+    throw new TypeError(`signal.${delivery}("${name}"): retention is only valid with signal.live`);
   }
   if (retention?.maxAge !== undefined && parseDurationMs(retention.maxAge) <= 0) {
     throw new TypeError(
-      `signal("${name}"): retention.maxAge must be a duration like "24h" or "30s"`,
+      `signal.live("${name}"): retention.maxAge must be a duration like "24h" or "30s"`,
     );
   }
   if (
     retention?.maxCount !== undefined &&
     (!Number.isInteger(retention.maxCount) || retention.maxCount < 1)
   ) {
-    throw new TypeError(`signal("${name}"): retention.maxCount must be an integer ≥ 1`);
+    throw new TypeError(`signal.live("${name}"): retention.maxCount must be an integer ≥ 1`);
   }
   const decl: SignalDecl<T> = {
     name,
-    delivery: options.delivery,
+    delivery,
     ...(options.description !== undefined ? { description: options.description } : {}),
     retries: options.retries ?? 3,
     deadLetter: options.deadLetter ?? true,
     schema: options.schema,
     optional: options.optional ?? false,
-    ...(options.delivery === "live" && retention !== undefined ? { retention } : {}),
+    ...(delivery === "live" && retention !== undefined ? { retention } : {}),
   };
   signalRegistry.push(decl as SignalDecl);
   return decl;
 }
+
+/**
+ * Declare a signal. Delivery physics are chosen by helper name —
+ * `signal.once` · `signal.broadcast` · `signal.live`.
+ */
+export const signal: SignalNamespace = {
+  once<T = unknown>(name: string, options?: SignalSharedOptions): SignalDecl<T> {
+    return declareSignal(name, "once", options);
+  },
+  broadcast<T = unknown>(name: string, options?: SignalSharedOptions): SignalDecl<T> {
+    return declareSignal(name, "broadcast", options);
+  },
+  live<T = unknown>(name: string, options?: SignalLiveOptions): SignalDecl<T> {
+    return declareSignal(name, "live", options);
+  },
+};

package/src/elements/signal/delivery-modes.test.ts

@@ -90,11 +90,7 @@ for (const { label, driver, setup } of drivers) {
   describe(`signal delivery modes · ${label}`, () => {
     test("once: one message reaches exactly one of two competing consumers", async () => {
       // Shape matches Linkly linkClicked / Provisions order-placed.
-      const once = signal("link-clicked", {
-        delivery: "once",
-        retries: 3,
-        deadLetter: true,
-      });
+      const once = signal.once("link-clicked", { retries: 3, deadLetter: true });
       const bus = await openBus(driver, [once], setup?.() ?? {});
       const got: string[] = [];
 
@@ -113,11 +109,7 @@ for (const { label, driver, setup } of drivers) {
     });
 
     test("once: retries+1 attempts then dead-letter when deadLetter: true", async () => {
-      const once = signal("flaky", {
-        delivery: "once",
-        retries: 2,
-        deadLetter: true,
-      });
+      const once = signal.once("flaky", { retries: 2, deadLetter: true });
       const bus = await openBus(driver, [once], setup?.() ?? {});
       let attempts = 0;
       await bus.subscribe("flaky", "c1", async () => {
@@ -136,11 +128,7 @@ for (const { label, driver, setup } of drivers) {
     });
 
     test("once: deadLetter: false marks delivered after exhausting retries", async () => {
-      const once = signal("flaky-drop", {
-        delivery: "once",
-        retries: 1,
-        deadLetter: false,
-      });
+      const once = signal.once("flaky-drop", { retries: 1, deadLetter: false });
       const bus = await openBus(driver, [once], setup?.() ?? {});
       let attempts = 0;
       await bus.subscribe("flaky-drop", "c1", async () => {
@@ -159,7 +147,7 @@ for (const { label, driver, setup } of drivers) {
     });
 
     test("broadcast: every subscriber receives its own copy", async () => {
-      const bcast = signal("news", { delivery: "broadcast" });
+      const bcast = signal.broadcast("news");
       const bus = await openBus(driver, [bcast], setup?.() ?? {});
       const a: unknown[] = [];
       const b: unknown[] = [];
@@ -179,7 +167,7 @@ for (const { label, driver, setup } of drivers) {
 
     test("live: late subscriber replays full retained history (unbounded)", async () => {
       // Shape matches Skyport seat-feed.
-      const live = signal("seat-feed", { delivery: "live", optional: true });
+      const live = signal.live("seat-feed", { optional: true });
       const bus = await openBus(driver, [live], setup?.() ?? {});
 
       await bus.emit("seat-feed", { seat: "12A" });
@@ -194,11 +182,7 @@ for (const { label, driver, setup } of drivers) {
     });
 
     test("live: maxCount keeps the newest N", async () => {
-      const live = signal("seat-feed", {
-        delivery: "live",
-        optional: true,
-        retention: { maxCount: 2 },
-      });
+      const live = signal.live("seat-feed", { optional: true, retention: { maxCount: 2 } });
       const bus = await openBus(driver, [live], setup?.() ?? {});
 
       for (const seat of ["12A", "12B", "12C", "12D", "12E"]) {
@@ -212,11 +196,7 @@ for (const { label, driver, setup } of drivers) {
 
     test("live: maxAge prunes on emit and on live() open", async () => {
       let t = 1_000;
-      const live = signal("seat-feed", {
-        delivery: "live",
-        optional: true,
-        retention: { maxAge: "1s" },
-      });
+      const live = signal.live("seat-feed", { optional: true, retention: { maxAge: "1s" } });
       const bus = await openBus(driver, [live], { now: () => t, ...(setup?.() ?? {}) });
 
       await bus.emit("seat-feed", { seat: "old" });
@@ -230,7 +210,7 @@ for (const { label, driver, setup } of drivers) {
     });
 
     test("live: afterId skips already-delivered events", async () => {
-      const live = signal("seat-feed", { delivery: "live", optional: true });
+      const live = signal.live("seat-feed", { optional: true });
       const bus = await openBus(driver, [live], setup?.() ?? {});
 
       await bus.emit("seat-feed", { seat: "12A" });
@@ -248,15 +228,15 @@ for (const { label, driver, setup } of drivers) {
       expect(rest.map((e) => e.payload)).toEqual([{ seat: "12B" }, { seat: "12C" }]);
     });
 
-    test("live: unknown afterId throws OKE1014", async () => {
-      const live = signal("seat-feed", { delivery: "live", optional: true });
+    test("live: unknown afterId throws OKE1210", async () => {
+      const live = signal.live("seat-feed", { optional: true });
       const bus = await openBus(driver, [live], setup?.() ?? {});
       await bus.emit("seat-feed", { seat: "12A" });
       await bus.drain();
 
       const it = bus.live("seat-feed", { afterId: "missing" })[Symbol.asyncIterator]();
       try {
-        await expect(it.next()).rejects.toMatchObject({ code: 1014 });
+        await expect(it.next()).rejects.toMatchObject({ code: 1210 });
       } finally {
         await it.return?.();
       }

package/src/elements/signal/dry-run-replay.test.ts

@@ -23,13 +23,7 @@ describe("signal dry-run replay — external effects stubbed", () => {
     } as unknown as ChannelRuntime;
 
     const runtime = createSignalRuntime({ driver: memorySignalDriver });
-    runtime.register(
-      signal("order-placed", {
-        delivery: "once",
-        retries: 0,
-        deadLetter: true,
-      }),
-    );
+    runtime.register(signal.once("order-placed", { retries: 0, deadLetter: true }));
     const bus = await runtime.start();
 
     // Seed DLQ with a failing consumer, then replace with a send consumer.

package/src/elements/signal/dry-run-write-isolation.test.ts

@@ -18,13 +18,7 @@ describe("signal dry-run replay — write isolation", () => {
     const before = structuredClone(stockRow);
 
     const runtime = createSignalRuntime({ driver: memorySignalDriver });
-    runtime.register(
-      signal("order-placed", {
-        delivery: "once",
-        retries: 0,
-        deadLetter: true,
-      }),
-    );
+    runtime.register(signal.once("order-placed", { retries: 0, deadLetter: true }));
     const bus = await runtime.start();
 
     const unsubFail = await bus.subscribe("order-placed", "flaky", async () => {