okengine 0.19.1 → 0.19.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okengine",
-  "version": "0.19.1",
+  "version": "0.19.3",
   "description": "One law. Eight elements. One contract. The backend model stays small; operational surfaces are derived from it instead of maintained separately.",
   "license": "MIT",
   "repository": {

package/site/content/docs/elements/clock/index.mdx

@@ -26,7 +26,7 @@ For developers scheduling work on okengine — one handle shape; drivers swap by
 ```typescript title="src/clocks/digest.ts"
 import { clock } from "okengine";
 
-export const digestClock = clock("notes.digest", { every: "1d" });
+export const digestClock = clock.every("notes.digest", "1d");
 ```
 
 </Step>
@@ -73,6 +73,150 @@ Under `drivers.clock.test = "frozen"`, advance time in tests instead of waiting
   separate job runner — see [Consumers · Clock Jobs](/docs/elements/flow/consumers#clock-jobs).
 </Callout>
 
+## Inline or named export
+
+| Style                                         | When                                                              |
+| --------------------------------------------- | ----------------------------------------------------------------- |
+| `on(clock.every("name", "1h"), flow({ do }))` | Self-contained — nothing else needs the Clock handle              |
+| `export const x = clock.every("name", "1h")`  | Another file (or a second `on()`) must reuse the same declaration |
+
+Both styles stamp the same Manifest `flow.trigger`. The choice is where the
+declaration lives, not two runtimes.
+
+What the Flow is called is a separate choice — [Flow name](#flow-name).
+
+<Tabs items={["Inline", "Named"]}>
+
+<Tab value="Inline">
+
+One file — declare and bind together. The scheduler fires it; no other file
+imports the handle:
+
+```typescript title="src/flows/health/ping.ts"
+import { on, flow, clock } from "okengine";
+
+export const pingExternal = on(
+  clock.every("health.pingExternal", "30s"),
+  flow({
+    plane: "operator",
+    do: async (_, fx) => {
+      await fx.call(pingUpstream);
+    },
+  }),
+);
+```
+
+</Tab>
+
+<Tab value="Named">
+
+Export the handle when another file (or a second `on()`) must reuse the same
+declaration:
+
+```typescript title="src/clocks/digest.ts"
+import { clock } from "okengine";
+
+export const digestClock = clock.every("notes.digest", "1d");
+```
+
+```typescript title="src/flows/notes/digest.ts"
+import { on, flow } from "okengine";
+import { digestClock } from "@/clocks/digest";
+
+export const digest = on(
+  digestClock,
+  flow("notes.digest", {
+    plane: "operator",
+    do: async (_, fx) => {
+      await fx.call(buildDigest, { at: fx.clock.now() });
+    },
+  }),
+);
+```
+
+</Tab>
+
+</Tabs>
+
+## Flow name
+
+| Style                     | When                                                             |
+| ------------------------- | ---------------------------------------------------------------- |
+| `flow({ do })`            | No unit folder — Flow name is the Clock name (`metrics.cleanup`) |
+| `flow("ops.sweep")`       | Manifest / `fx.call` name must differ from the Clock             |
+| Tree `export const sweep` | `src/flows/ops/sweep.ts` stamps `ops.sweep` — overwrites inherit |
+
+Explicit `flow("…")` and the file tree overwrite inherit. HTTP does not inherit a
+name from the path — nameless HTTP stays for the tree or fails **OKE1045**. Two
+Flows that land on the same name fail **OKE1070** (`Flow "{flow}" is defined twice.`).
+
+<Tabs items={["Inherit", "Explicit", "Tree"]}>
+
+<Tab value="Inherit">
+
+A file directly in `src/flows/` (no unit folder) has nothing to stamp. The Flow
+is named `metrics.cleanup` — same as the Clock:
+
+```typescript title="src/flows/cleanup.ts"
+import { on, flow, clock } from "okengine";
+
+export const cleanupMetrics = on(
+  clock.every("metrics.cleanup", "1h"),
+  flow({
+    plane: "operator",
+    do: async (_, fx) => {
+      await fx.call(sweepMetrics);
+    },
+  }),
+);
+```
+
+</Tab>
+
+<Tab value="Explicit">
+
+The Clock stays `metrics.cleanup`. The Flow is `ops.sweep` — that is the
+Manifest / `fx.call` name:
+
+```typescript title="src/flows/sweep.ts"
+import { on, flow, clock } from "okengine";
+
+export const sweep = on(
+  clock.every("metrics.cleanup", "1h"),
+  flow("ops.sweep", {
+    plane: "operator",
+    do: async (_, fx) => {
+      await fx.call(sweepMetrics);
+    },
+  }),
+);
+```
+
+</Tab>
+
+<Tab value="Tree">
+
+Unit folder + `export const` stamps `unit.export`. The Flow is `ops.sweep`, not
+the Clock name `cleanup`:
+
+```typescript title="src/flows/ops/sweep.ts"
+import { on, flow, clock } from "okengine";
+
+export const sweep = on(
+  clock.every("cleanup", "10m"),
+  flow({
+    plane: "operator",
+    do: async (_, fx) => {
+      await fx.call(sweepMetrics);
+    },
+  }),
+);
+```
+
+</Tab>
+
+</Tabs>
+
 ## Progressive Patterns
 
 Same `clock` + `fx.clock` from a calendar cron to an interval, a durable pause, and typed offsets:
@@ -114,7 +258,7 @@ Human durations — integer + unit, no weeks: `"200ms"` · `"30s"` · `"5m"` ·
 ```typescript title="src/flows/health/ping.ts"
 import { on, flow, clock } from "okengine";
 
-export const pingClock = clock("health.pingExternal", { every: "30s" });
+export const pingClock = clock.every("health.pingExternal", "30s");
 
 export const pingExternal = on(
   pingClock,
@@ -183,14 +327,14 @@ calendar day. Unknown strings parse as `0`.
 
 ## Capability Reference
 
-| Surface       | Signature                                                | Purpose                         | `do` input |
-| ------------- | -------------------------------------------------------- | ------------------------------- | ---------- |
-| Cron schedule | `clock(name, { cron, timezone? })`                       | Calendar fires in an IANA zone  | none (`_`) |
-| Helpers       | `clock.daily` · `hourly` · `weekly` · `monthly` · `cron` | Same decl; presets + field bags | none (`_`) |
-| Interval      | `clock(name, { every })` / `clock.every`                 | Fixed duration loop             | none (`_`) |
-| Per-tenant    | `clock.perTenant(name, opts)`                            | One Store row per tenant        | none (`_`) |
-| Now / offsets | `fx.clock.now` · `ago` · `fromNow` · `duration`          | Injectable time math            | —          |
-| Durable sleep | `fx.clock.sleep(label, duration)`                        | Park a durable Flow until wake  | —          |
+| Surface       | Signature                                                | Purpose                        | `do` input |
+| ------------- | -------------------------------------------------------- | ------------------------------ | ---------- |
+| Helpers       | `clock.daily` · `hourly` · `weekly` · `monthly` · `cron` | Calendar presets + field bags  | none (`_`) |
+| Interval      | `clock.every(name, duration, opts?)`                     | Fixed duration loop            | none (`_`) |
+| Per-tenant    | `clock.perTenant(name, opts)`                            | One Store row per tenant       | none (`_`) |
+| Bare callable | `clock(name, { cron? \| every?, … })`                    | Same decl; lower-level form    | none (`_`) |
+| Now / offsets | `fx.clock.now` · `ago` · `fromNow` · `duration`          | Injectable time math           | —          |
+| Durable sleep | `fx.clock.sleep(label, duration)`                        | Park a durable Flow until wake | —          |
 
 At least one of `cron` or `every` is required on every declaration.
 
@@ -269,6 +413,12 @@ export default defineConfig({
   declaration in source.
 </Accordion>
 
+<Accordion title="OKE1070 — flow name defined twice">
+  Cause: `Flow "{flow}" is defined twice.` Two nameless consumers inherited the same Clock name, or
+  two explicit `flow("…")` calls collide. Give at least one a distinct `flow("…")` or tree export —
+  [Flow name](#flow-name).
+</Accordion>
+
 </Accordions>
 
 ## Learn more
@@ -278,7 +428,8 @@ export default defineConfig({
 - [Consumers · Clock Jobs](/docs/elements/flow/consumers#clock-jobs) — bind with `on(clockDecl, flow)`
 - [Workflows](/docs/elements/flow/workflows) — `durable: true` + `fx.step` around sleeps
 - [fx](/docs/reference/fx) — full `fx.clock` table
-- [Errors](/docs/reference/errors) — `ScheduleNotOverridableError` · `ClockResourceNotFoundError`
+- [Routing](/docs/elements/flow/routing#names) — tree `unit.export` vs inherit
+- [Errors](/docs/reference/errors) — `ScheduleNotOverridableError` · `ClockResourceNotFoundError` · OKE1070
 
 ## Next
 

package/site/content/docs/elements/clock/schedules.mdx

@@ -99,8 +99,10 @@ export const close = clock.monthly("billing.close", { on: [1, 15], at: "00:00" }
 export const ping = clock.every("health.ping", "30s");
 ```
 
-Raw strings still work: `clock("x", { cron: "0 6 * * *" })`, Bun nicknames (`@hourly`),
-and `clock("x", { every: "30s" })`.
+Prefer the named helpers above for fixed schedules. The bare callable remains fully
+supported for the same `ClockDecl` shape when you need a raw string or a schedule
+chosen programmatically: `clock("x", { cron: "0 6 * * *" })`, Bun nicknames
+(`@hourly`), and `clock("x", { every: "30s" })`.
 
 **Consequence:** Manifest / Store still see `cron: "0 6 * * *"` — helpers are declare-time sugar.
 
@@ -159,7 +161,8 @@ export const runInvoices = on(
 );
 ```
 
-Equivalent: `clock("invoices", { every: "1h", perTenant: true })`.
+Equivalent bare form (same decl; prefer `clock.perTenant` above):
+`clock("invoices", { every: "1h", perTenant: true })`.
 
 **Consequence:** ten tenants → ten leader-elected rows. Catch-up still fires **once per
 row** after downtime — not a burst of missed hours per tenant.

package/site/content/docs/elements/flow/consumers.mdx

@@ -11,15 +11,17 @@ For developers wiring background work on okengine — bind the trigger, keep `do
 
 <Callout title="The one rule">
   Bind with `on(signal)`, `on(clockDecl)`, or `on(db.table(…).changed())`. Delivery physics live on
-  the Signal; `cron` / `every` live on the Clock; CDC input is always `{ before, after }`. World
-  access still goes through `fx`.
+  the Signal; `cron` / `every` live on the Clock; CDC input is `{ before, after }` plus `table` /
+  `action` / `id`. World access still goes through `fx`.
 </Callout>
 
 ## Smallest Example
 
-<Steps>
+<Callout title="Bind and emit are independent">
+  The consumer and the producer share one Signal handle. They can live in different files, written
+  in any order — emit is not "step 2" after bind.
+</Callout>
 
-<Step>
 ### Bind a Signal consumer
 
 ```typescript title="src/flows/notifications/welcome.ts"
@@ -40,9 +42,6 @@ export const sendWelcome = on(
 );
 ```
 
-</Step>
-
-<Step>
 ### Emit from any Flow
 
 ```typescript
@@ -52,10 +51,6 @@ await fx.emit(userSignedUp, { userId: "usr_123", email: "alice@example.com" });
 The compiler records `emits: ["users.signed-up"]` on the producer. The consumer runs after the
 emit commits — the HTTP request does not wait for the welcome mail.
 
-</Step>
-
-</Steps>
-
 <Callout title="Jobs are consumers">
   A named Clock bound with `on(clockDecl, flow)` is the same species — an asynchronous Flow. There
   is no separate job runner. See [Clock jobs](#clock-jobs).
@@ -108,7 +103,7 @@ import { on, flow, clock } from "okengine";
 import { lt } from "drizzle-orm";
 import { db, metricLogs } from "@/schema";
 
-export const cleanupClock = clock("metrics.cleanup", { every: "1h" });
+export const cleanupClock = clock.every("metrics.cleanup", "1h");
 
 export const cleanupMetrics = on(
   cleanupClock,
@@ -127,7 +122,8 @@ export const cleanupMetrics = on(
 
 <Tab value="CDC">
 
-`db.table(handle).changed()` fires on insert, update, and delete. Input is `{ before, after }`:
+`db.table(handle).changed()` fires on insert, update, and delete. Input is `{ before, after }`
+plus `table`, `action`, and `id`:
 
 ```typescript title="src/flows/audit/users.ts"
 import { on, flow } from "okengine";
@@ -137,14 +133,15 @@ import { users, auditLogs } from "@/schema";
 export const onUserWrite = on(
   db.table(users).changed(),
   flow("audit.users", {
-    do: async ({ before, after }, fx) => {
-      const action = !before ? "created" : !after ? "deleted" : "updated";
-      const recordId = String(after?.id ?? before?.id ?? "");
-      await fx.store(db).insert(auditLogs).values({
-        table: "users",
-        recordId,
-        action,
-      });
+    do: async ({ table, action, id }, fx) => {
+      await fx
+        .store(db)
+        .insert(auditLogs)
+        .values({
+          table,
+          recordId: String(id),
+          action,
+        });
     },
   }),
 );
@@ -183,16 +180,20 @@ Omit `key` for competing consumers with no ordering.
 
 ## Trigger Reference
 
-| Trigger    | Signature                              | Purpose                                     | `do` input          |
-| ---------- | -------------------------------------- | ------------------------------------------- | ------------------- |
-| Signal     | `on(signalHandle, flow)`               | Queue (`once`) or fan-out (`broadcast`)     | Payload (`schema`)  |
-| Clock      | `on(clockDecl, flow)`                  | Interval or cron tick                       | none (`_`)          |
-| CDC any    | `on(db.table(t).changed(), flow)`      | Every insert / update / delete              | `{ before, after }` |
-| CDC column | `on(db.table(t).changed("col"), flow)` | Same writes; column stamped on the Manifest | `{ before, after }` |
+| Trigger    | Signature                                           | Purpose                                     | `do` input                             |
+| ---------- | --------------------------------------------------- | ------------------------------------------- | -------------------------------------- |
+| Signal     | `on(signalHandle, flow)` or inline `signal.once(…)` | Queue (`once`) or fan-out (`broadcast`)     | Payload (`schema`)                     |
+| Clock      | `on(clockDecl, flow)` or inline `clock.every(…)`    | Interval or cron tick                       | none (`_`)                             |
+| CDC any    | `on(db.table(t).changed(), flow)`                   | Every insert / update / delete              | `{ before, after, table, action, id }` |
+| CDC column | `on(db.table(t).changed("col"), flow)`              | Same writes; column stamped on the Manifest | `{ before, after, table, action, id }` |
 
 `signal.live` is an HTTP SSE tape — bind it with [`http.live`](/docs/elements/flow/http#live-streams),
 not as a worker. A Flow with no trigger is [call-only](/docs/elements/flow).
 
+One-file inline vs exported handle: [Signal](/docs/elements/signal#inline-or-named-export) ·
+[Clock](/docs/elements/clock#inline-or-named-export). Flow name (inherit / explicit / tree):
+[Signal](/docs/elements/signal#flow-name) · [Clock](/docs/elements/clock#flow-name). Collision is **OKE1070**.
+
 ## Signal Consumers
 
 <Callout title="Detailed section">
@@ -207,8 +208,12 @@ Each emit is handled according to the Signal helper you declared. The Flow is th
 
 <Tab value="Once">
 
-Competing workers — exactly one consumer processes each message. Failed attempts retry, then
-dead-letter when `deadLetter` is true (default):
+Competing workers — exactly one consumer claims each message. Failed attempts retry, then
+dead-letter when `deadLetter` is true (default).
+
+Two different Flows on one `once` signal fail **OKE1071** — see
+[Once · Competing consumers](/docs/elements/signal/once#competing-consumers-once-vs-broadcast).
+For every bound Flow to run, use [`signal.broadcast`](/docs/elements/signal/broadcast).
 
 ```typescript title="src/signals/orders.ts"
 import { signal } from "okengine";
@@ -342,9 +347,11 @@ Broadcast does not use the `once` lease / DLQ path. Live uses the retained tape,
 ## Clock Jobs
 
 <Callout title="Detailed section">
-  If you only need an interval, jump to the example below. `clock(name)` requires `cron` or `every`
-  — missing both throws `clock("name"): require cron or every`. Bind the returned handle with
-  `on(clockDecl, flow)`.
+  Prefer `clock.every` / `clock.daily` / `clock.cron` (and the other named helpers) for fixed
+  schedules — they compile to the same decl as the bare callable. The lower-level bare `clock(name,
+  options)` form still works when you need a raw expression or a schedule chosen programmatically;
+  missing both `cron` and `every` throws `clock("name"): require cron or every`. Bind the returned
+  handle with `on(clockDecl, flow)`.
 </Callout>
 
 Named clocks reconcile into the Store at boot. The scheduler leader-elects so N instances do not
@@ -359,7 +366,7 @@ Human durations: `"200ms"` · `"30s"` · `"5m"` · `"1h"` · `"7d"` (integer + u
 ```typescript title="src/flows/health/ping.ts"
 import { on, flow, clock } from "okengine";
 
-export const pingClock = clock("health.pingExternal", { every: "30s" });
+export const pingClock = clock.every("health.pingExternal", "30s");
 
 export const pingExternal = on(
   pingClock,
@@ -381,8 +388,8 @@ Five-field cron (`m h dom mon dow`) plus an IANA `timezone` (default `"UTC"`):
 ```typescript title="src/flows/reports/daily.ts"
 import { on, flow, clock } from "okengine";
 
-export const dailyReportClock = clock("reports.daily", {
-  cron: "0 6 * * *",
+export const dailyReportClock = clock.daily("reports.daily", {
+  at: "06:00",
   timezone: "Asia/Riyadh",
 });
 
@@ -423,7 +430,8 @@ export const runInvoices = on(
 );
 ```
 
-Equivalent: `clock("invoices", { every: "1h", perTenant: true })`.
+Equivalent bare form (same decl; prefer `clock.perTenant` above):
+`clock("invoices", { every: "1h", perTenant: true })`.
 
 </Tab>
 
@@ -481,19 +489,34 @@ do not fire.
 ## CDC
 
 <Callout title="Detailed section">
-  If you only need any-write, jump to the example below. The handle is
+  If you only need any-write, jump to Bare or enriched below. The handle is
   `db.table(table).changed(column?)` — `db` is a `store.sql` declaration, `table` is a schema
   handle. `changed("insert")` is **not** an op filter; it stamps a column named `insert`.
 </Callout>
 
 SQL writes through `fx.store` notify CDC after commit. The Flow input is always
-`{ before, after }` (`CdcPayload`).
+`{ before, after, table, action, id }` (`CdcPayload`).
+
+### Bare or enriched
+
+| Style                     | When                                                                   |
+| ------------------------- | ---------------------------------------------------------------------- |
+| `({ before, after })`     | Bound to one table — images are enough (search reindex, listing cache) |
+| `({ table, action, id })` | Log, route, or branch — kind of change and which record (audit log)    |
 
-<Tabs items={["Any write", "Column", "Images"]}>
+Both styles receive the same object. There is no second dispatch path, no
+performance difference, and no correctness difference — the choice is which
+fields this handler destructures.
 
-<Tab value="Any write">
+`{ table, action, id }` are always populated; omitting them from `do` does not
+drop them from the payload.
 
-Omit the argument to react to every insert, update, and delete on the table:
+<Tabs items={["Bare", "Enriched", "Images"]}>
+
+<Tab value="Bare">
+
+Bound to `notes` — the table is already in the trigger. Images decide upsert vs
+drop; the row's `id` is on the surviving image:
 
 ```typescript title="src/flows/search/reindex.ts"
 import { on, flow } from "okengine";
@@ -505,13 +528,11 @@ export const reindexNotes = on(
   flow("search.reindexNotes", {
     plane: "operator",
     do: async ({ before, after }, fx) => {
-      const id = String(after?.id ?? before?.id ?? "");
-      if (!id) return;
       if (!after) {
-        await fx.call(dropNoteIndex, { id });
+        await fx.call(dropNoteIndex, { id: String(before?.id ?? "") });
         return;
       }
-      await fx.call(upsertNoteIndex, { id });
+      await fx.call(upsertNoteIndex, { id: String(after.id) });
     },
   }),
 );
@@ -519,29 +540,28 @@ export const reindexNotes = on(
 
 </Tab>
 
-<Tab value="Column">
+<Tab value="Enriched">
 
-`changed("status")` stamps `trigger.cdc.column` on the Manifest (Console, extract). Still
-receive `{ before, after }` — filter in `do` when you only care about that field:
+`table` is the real table name. `action` is `"created"` / `"updated"` / `"deleted"`.
+`id` is the declared primary-key value — not a hardcoded `"id"` column:
 
-```typescript title="src/flows/tasks/on-status.ts"
+```typescript title="src/flows/audit/users.ts"
 import { on, flow } from "okengine";
 import { db } from "@/core";
-import { tasks } from "@/schema";
+import { users, auditLogs } from "@/schema";
 
-export const onStatus = on(
-  db.table(tasks).changed("status"),
-  flow("tasks.onStatus", {
-    plane: "operator",
-    do: async ({ before, after }, fx) => {
-      if (before?.status === after?.status) return;
-      const id = String(after?.id ?? before?.id ?? "");
-      if (!id) return;
-      await fx.emit(taskStatusChanged, {
-        id,
-        from: before?.status ?? null,
-        to: after?.status ?? null,
-      });
+export const onUserWrite = on(
+  db.table(users).changed(),
+  flow("audit.users", {
+    do: async ({ table, action, id }, fx) => {
+      await fx
+        .store(db)
+        .insert(auditLogs)
+        .values({
+          table,
+          recordId: String(id),
+          action,
+        });
     },
   }),
 );
@@ -551,21 +571,21 @@ export const onStatus = on(
 
 <Tab value="Images">
 
-Op is inferred from which image is null:
+Op is inferred from which image is null — the same derivation as `action`:
 
-| Write  | `before`     | `after` |
-| ------ | ------------ | ------- |
-| Insert | `null`       | new row |
-| Update | previous row | new row |
-| Delete | previous row | `null`  |
+| Write  | `before`     | `after` | `action`    |
+| ------ | ------------ | ------- | ----------- |
+| Insert | `null`       | new row | `"created"` |
+| Update | previous row | new row | `"updated"` |
+| Delete | previous row | `null`  | `"deleted"` |
 
 ```typescript
-do: async ({ before, after }, fx) => {
-  if (!before && after) {
+do: async ({ before, after, action }, fx) => {
+  if (action === "created") {
     /* insert */
-  } else if (before && after) {
+  } else if (action === "updated") {
     /* update */
-  } else if (before && !after) {
+  } else {
     /* delete */
   }
 };
@@ -575,11 +595,36 @@ do: async ({ before, after }, fx) => {
 
 </Tabs>
 
+`changed("status")` stamps `trigger.cdc.column` on the Manifest. Still the same
+payload — filter in `do` when you only care about that field:
+
+```typescript title="src/flows/tasks/on-status.ts"
+import { on, flow } from "okengine";
+import { db } from "@/core";
+import { tasks } from "@/schema";
+
+export const onStatus = on(
+  db.table(tasks).changed("status"),
+  flow("tasks.onStatus", {
+    plane: "operator",
+    do: async ({ before, after, id }, fx) => {
+      if (before?.status === after?.status) return;
+      await fx.emit(taskStatusChanged, {
+        id,
+        from: before?.status ?? null,
+        to: after?.status ?? null,
+      });
+    },
+  }),
+);
+```
+
 <Accordions>
 
 <Accordion title="CDC payload">
-  Kernel input is `{ before, after }` — not `{ record }`, not `{ op }`. Read the primary key from
-  `after?.id ?? before?.id`.
+  `{ before, after }` are always present. `{ table, action, id }` are always populated — `id` is
+  the table's declared primary-key value, not a column assumed to be named `"id"`. There is no
+  `record` field and no `{ op }` (that stays on the live-query / outbox path).
 
 Writes must go through `fx.store`. A raw SQL client bypasses the sink, so no consumer runs.
 
@@ -625,7 +670,19 @@ Clock drivers: **postgres** in `dev`/`prod`, **frozen** in `test`. Signal driver
 <Accordion title="TypeError: on() expected a trigger or signal handle">
   The first argument must be a Signal handle, a Clock handle, `db.table(…).changed()`, an HTTP
   trigger, `internal`, or `mcp.tool(…)`. A bare interval string is not a trigger — wrap it in
-  `clock("name", { every: "1h" })`.
+  `clock.every("name", "1h")`.
+</Accordion>
+
+<Accordion title="OKE1070 — flow name defined twice">
+  Cause: `Flow "{flow}" is defined twice.` Two nameless `flow({ do })` bindings inherited the same
+  Signal or Clock name, or two explicit `flow("…")` calls share a name. Give at least one an
+  explicit `flow("…")` or a distinct tree export.
+</Accordion>
+
+<Accordion title="OKE1071 — once signal bound to more than one Flow">
+  Cause: `Once signal "{signal}" is bound to more than one Flow ({flows}).` Use `signal.broadcast`
+  if each Flow should independently receive this event, or bind only one Flow. See [Once · Competing
+  consumers](/docs/elements/signal/once#competing-consumers-once-vs-broadcast).
 </Accordion>
 
 <Accordion title="OKE1240 — emit with no subscriber">
@@ -644,8 +701,9 @@ Clock drivers: **postgres** in `dev`/`prod`, **frozen** in `test`. Signal driver
 </Accordion>
 
 <Accordion title="CDC do never sees record / op">
-  Input is `{ before, after }`. There is no `record` field. Infer insert / update / delete from
-  which image is null.
+  Input is `{ before, after, table, action, id }`. There is no `record` field. `action` is
+  `"created"` / `"updated"` / `"deleted"` from which image is null. `{ op }` is live-query /
+  outbox only.
 </Accordion>
 
 <Accordion title="Cron fired 24 times after overnight downtime">
@@ -678,7 +736,7 @@ Clock drivers: **postgres** in `dev`/`prod`, **frozen** in `test`. Signal driver
 - [Store · SQL](/docs/elements/store/sql) — tables CDC watches
 - [HTTP · Live Streams](/docs/elements/flow/http#live-streams) — `signal.live` SSE
 - [fx](/docs/reference/fx) — `fx.emit`, `fx.deadLetters`, `fx.clock`
-- [Errors](/docs/reference/errors) — OKE1240 · OKE1250
+- [Errors](/docs/reference/errors) — OKE1070 · OKE1071 · OKE1240 · OKE1250
 - [Workflows](/docs/elements/flow/workflows) — `durable: true` + `fx.step` on a consumer
 
 ## Next