okengine 0.19.1 → 0.19.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okengine",
-  "version": "0.19.1",
+  "version": "0.19.2",
   "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,16 @@ 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 |
+
+Nameless `flow({ do })` inherits the Clock's declared name. File-tree `unit.export` and explicit
+`flow("…")` win. Two nameless Flows inheriting the same name fail **OKE1070**.
+
 ## Progressive Patterns
 
 Same `clock` + `fx.clock` from a calendar cron to an interval, a durable pause, and typed offsets:
@@ -114,7 +124,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 +193,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.
 

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,8 +11,8 @@ 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
@@ -108,7 +108,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 +127,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 +138,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 +185,19 @@ 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).
 
+Inline `on(signal.once("…"), flow({ do }))` is supported; export the handle for typed `fx.emit`.
+Nameless `flow({ do })` inherits the trigger name; a second nameless inherit fails **OKE1070**.
+
 ## Signal Consumers
 
 <Callout title="Detailed section">
@@ -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>
 
@@ -487,13 +495,43 @@ do not fire.
 </Callout>
 
 SQL writes through `fx.store` notify CDC after commit. The Flow input is always
-`{ before, after }` (`CdcPayload`).
+`{ before, after }` plus `table`, `action`, and `id` (`CdcPayload`). Destructure
+only `{ before, after }` when that's all you need.
+
+<Tabs items={["Audit log", "Bare", "Images"]}>
+
+<Tab value="Audit log">
+
+`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/audit/users.ts"
+import { on, flow } from "okengine";
+import { db } from "@/core";
+import { users, auditLogs } from "@/schema";
+
+export const onUserWrite = on(
+  db.table(users).changed(),
+  flow("audit.users", {
+    do: async ({ table, action, id, before, after }, fx) => {
+      await fx
+        .store(db)
+        .insert(auditLogs)
+        .values({
+          table,
+          recordId: String(id),
+          action,
+        });
+    },
+  }),
+);
+```
 
-<Tabs items={["Any write", "Column", "Images"]}>
+</Tab>
 
-<Tab value="Any write">
+<Tab value="Bare">
 
-Omit the argument to react to every insert, update, and delete on the table:
+Omit `table` / `action` / `id` when you only need the row images:
 
 ```typescript title="src/flows/search/reindex.ts"
 import { on, flow } from "okengine";
@@ -505,24 +543,18 @@ 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) });
     },
   }),
 );
 ```
 
-</Tab>
-
-<Tab value="Column">
-
-`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:
+`changed("status")` stamps `trigger.cdc.column` on the Manifest. Still receive 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";
@@ -533,10 +565,8 @@ export const onStatus = on(
   db.table(tasks).changed("status"),
   flow("tasks.onStatus", {
     plane: "operator",
-    do: async ({ before, after }, fx) => {
+    do: async ({ before, after, id }, 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,
@@ -551,21 +581,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 */
   }
 };
@@ -578,8 +608,9 @@ do: async ({ before, after }, fx) => {
 <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 +656,13 @@ 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="OKE1240 — emit with no subscriber">
@@ -644,8 +681,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 +716,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 · OKE1240 · OKE1250
 - [Workflows](/docs/elements/flow/workflows) — `durable: true` + `fx.step` on a consumer
 
 ## Next

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

@@ -179,14 +179,14 @@ const { chargeId } = await fx.call(chargeCard, { amount: 50 });
 
 <FlowTriggers />
 
-| Trigger   | Bind                                           | Starts when         | `do` input                 |
-| --------- | ---------------------------------------------- | ------------------- | -------------------------- |
-| HTTP      | `on(http.get(), flow)`                         | A request           | Merged path / query / body |
-| Signal    | `on(signalHandle, flow)`                       | `fx.emit`           | Payload (`schema`)         |
-| Clock     | `on(clockDecl, flow)`                          | Scheduler tick      | none (`_`)                 |
-| CDC       | `on(db.table(t).changed(), flow)`              | Committed SQL write | `{ before, after }`        |
-| Call-only | `call("name", { in, out, do, … })`             | `fx.call`           | Callee `in`                |
-| MCP       | `on(mcp.tool("x", { in, out }).gate(…), flow)` | MCP `tools/call`    | Tool args                  |
+| Trigger   | Bind                                           | Starts when         | `do` input                             |
+| --------- | ---------------------------------------------- | ------------------- | -------------------------------------- |
+| HTTP      | `on(http.get(), flow)`                         | A request           | Merged path / query / body             |
+| Signal    | `on(signalHandle, flow)`                       | `fx.emit`           | Payload (`schema`)                     |
+| Clock     | `on(clockDecl, flow)`                          | Scheduler tick      | none (`_`)                             |
+| CDC       | `on(db.table(t).changed(), flow)`              | Committed SQL write | `{ before, after, table, action, id }` |
+| Call-only | `call("name", { in, out, do, … })`             | `fx.call`           | Callee `in`                            |
+| MCP       | `on(mcp.tool("x", { in, out }).gate(…), flow)` | MCP `tools/call`    | Tool args                              |
 
 `signal.live` is an HTTP SSE tape — bind it with [`http.live`](/docs/elements/flow/http#live-streams), not as a worker.
 
@@ -366,7 +366,7 @@ A bare `404` with body `Not Found` means **no route matched** — not `fx.fail("
 | `fx.ask(prompt, opts)`     | `asks`                     | AI prompt                                     |
 | `fx.vault.get(secret)`     | `secrets`                  | Declared secret (never a raw value in source) |
 | `fx.call(flow, input?)`    | `calls`                    | Another Flow — waits for return               |
-| `fx.id()`                  | —                          | UUID                                          |
+| `fx.id()`                  | —                          | OKID — 21-char native id from `okengine/okid` |
 | `fx.clock.now()`           | —                          | Deterministic time                            |
 | `fx.fail(code, data)`      | —                          | Typed failure value                           |
 | `fx.step(name, fn)`        | journal                    | Durable checkpoint                            |
@@ -524,9 +524,9 @@ Default is `true` once `gate.auth.tenant` is on.
 </Accordion>
 
 <Accordion title="TypeError: on() expected a trigger or signal handle">
-  First argument must be an HTTP trigger, Signal handle, Clock handle,
-  `db.table(…).changed()`, `internal`, or `mcp.tool(…)`. A bare interval string is not
-  a trigger — wrap it in `clock("name", { every: "1h" })`.
+  First argument must be an HTTP trigger, Signal handle, Clock handle, `db.table(…).changed()`,
+  `internal`, or `mcp.tool(…)`. A bare interval string is not a trigger — wrap it in
+  `clock.every("name", "1h")`.
 </Accordion>
 
 <Accordion title="TypeError: on() expected a flow() definition as the second argument">

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

@@ -455,6 +455,10 @@ prefix). Wrong-unit prefixes fail generate.
 Non-HTTP files still join the unit. A signal consumer in `notes/on-created.ts`
 is `api.notes.onCreated` over RPC (`POST /_oke/notes/onCreated`), not HTTP.
 
+Outside the tree, nameless `flow({ do })` inherits a named Signal or Clock trigger.
+File-tree `unit.export` still wins. Two nameless inheritances fail **OKE1070**. HTTP has no
+inherent trigger name — those Flows stay on the tree stamp or **OKE1045**.
+
 HTTP flows that remain nameless after adopt fail **OKE1045**.
 
 ## Runtime Matching
@@ -512,6 +516,11 @@ plus a handwritten `http.get("/notes")`.
   file so the tree can stamp `unit.export`. `export default` is not picked up.
 </Accordion>
 
+<Accordion title="OKE1070 — flow name defined twice">
+  Cause: `Flow "{flow}" is defined twice.` Two nameless Signal/Clock consumers inherited the same
+  name, or two explicit `flow("…")` calls collide. Give at least one a distinct name or tree export.
+</Accordion>
+
 <Accordion title="422 — path param missing from in">
   `[id]` stamps `:id`. `in` must declare `id` (same key). A schema that expects `userId` while the
   path is `:id` fails validation before `do`.
@@ -534,7 +543,7 @@ plus a handwritten `http.get("/notes")`.
 
 - [HTTP](/docs/elements/flow/http) — verbs, envelopes, `http.resource`, live SSE
 - [Client](/docs/client/calling) — `api.notes.get`, REST vs RPC, `$routes`
-- [Errors](/docs/reference/errors) — OKE1040 · OKE1030 · OKE1041 · OKE1045
+- [Errors](/docs/reference/errors) — OKE1040 · OKE1030 · OKE1041 · OKE1045 · OKE1070
 - [The Architecture](/docs/understand/the-architecture) — derived routes, no hand-written table
 - [Gate](/docs/elements/gate) — `.gate(...)` / `.public()` on the same trigger
 

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

@@ -80,6 +80,19 @@ for the worker.
   competing consumer.
 </Callout>
 
+## Inline or named export
+
+| Style                                         | When                                                                        |
+| --------------------------------------------- | --------------------------------------------------------------------------- |
+| `on(signal.once("name", opts), flow({ do }))` | Self-contained — nothing else emits to this Signal                          |
+| `export const x = signal.once<Payload>(…)`    | Another file needs `fx.emit(x, payload)` with compile-time payload checking |
+
+A string `fx.emit("name", payload)` still runs (runtime `schema` still applies) but does not
+type-check the payload.
+
+Nameless `flow({ do })` inherits the Signal name; file-tree `unit.export` and explicit
+`flow("…")` win. Two nameless inheritances of the same name fail **OKE1070**.
+
 ## Progressive Patterns
 
 Same helpers + `fx.emit` from a queue job to a fan-out and a browser feed:

package/site/content/docs/elements/store/sql.mdx

@@ -807,8 +807,8 @@ Default is insert-once; pass `{ onExisting: "update" }` to overwrite.
 </Callout>
 
 `db.table(orders).changed(column?)` builds a CDC trigger for `on(…)`. Input is
-always `{ before, after }`. `changed("status")` stamps a **column** name on the
-Manifest — it is not an op filter.
+`{ before, after }` plus `table` / `action` / `id`. `changed("status")` stamps a
+**column** name on the Manifest — it is not an op filter.
 
 ```typescript title="src/flows/orders/on-status.ts"
 import { on, flow } from "okengine";

package/site/content/docs/plugins/anonymous.mdx

@@ -38,7 +38,7 @@ export const app = oke({
 
 ```typescript
 const { data } = await api.auth.signInAnonymous();
-// data.userId is a fresh UUID; store tokens like any other session
+// data.userId is a fresh OKID; store tokens like any other session
 ```
 
 `POST /auth/sign-in/anonymous` — no body.

package/site/content/docs/plugins/cors.mdx

@@ -71,7 +71,7 @@ const origins = configSource({
   db: { store: db },
   kv: cache,
 });
-const corsSyncClock = clock("cors.sync", { every: "30s" });
+const corsSyncClock = clock.every("cors.sync", "30s");
 on(corsSyncClock, origins.sync());
 export const app = oke({ name: "shop", env: "dev" }).plug(cors(origins));
 ```

package/site/content/docs/plugins/csrf.mdx

@@ -75,7 +75,7 @@ const rules = configSource({
   db: { store: db },
   kv: cache,
 });
-const csrfSyncClock = clock("csrf.sync", { every: "30s" });
+const csrfSyncClock = clock.every("csrf.sync", "30s");
 on(csrfSyncClock, rules.sync());
 export const app = oke({ name: "shop", env: "dev" }).plug(csrf(rules));
 ```

package/site/content/docs/plugins/headers.mdx

@@ -103,7 +103,7 @@ const headerConfig = configSource({
   db: { store: db },
   kv: cache,
 });
-const headerSyncClock = clock("headers.sync", { every: "30s" });
+const headerSyncClock = clock.every("headers.sync", "30s");
 on(headerSyncClock, headerConfig.sync());
 export const app = oke({ name: "shop", env: "dev" }).plug(headers(headerConfig));
 ```

package/site/content/docs/plugins/ip-allowlist.mdx

@@ -69,7 +69,7 @@ const rules = configSource({
   db: { store: db },
   kv: cache,
 });
-const ipRulesSyncClock = clock("ip-allowlist.sync", { every: "30s" });
+const ipRulesSyncClock = clock.every("ip-allowlist.sync", "30s");
 on(ipRulesSyncClock, rules.sync());
 export const app = oke({ name: "shop", env: "dev" }).plug(ipAllowlist(rules));
 ```

package/site/content/docs/plugins/maintenance-mode.mdx

@@ -78,7 +78,7 @@ const maintenance = configSource({
   db: { store: db },
   kv: cache,
 });
-const maintenanceSyncClock = clock("maintenance.sync", { every: "30s" });
+const maintenanceSyncClock = clock.every("maintenance.sync", "30s");
 on(maintenanceSyncClock, maintenance.sync());
 export const app = oke({ name: "shop", env: "dev" }).plug(maintenanceMode(maintenance));
 ```

package/site/content/docs/reference/errors.mdx

@@ -96,6 +96,7 @@ string. Custom app codes stay message-less until registered. Full catalogs:
 | `1045` | HTTP flow unnamed    | Adopted HTTP flow still has no `unit.export`           | Export from `flows/<unit>/` or pass a named `flow`        |
 | `1050` | live exposure dup    | Same signal, gates, and match on two GET routes        | Change the gate or path-param filter                      |
 | `1060` | MCP tool duplicate   | Two MCP tool bindings share the same tool name         | Give each MCP tool exposure a unique name                 |
+| `1070` | flow name duplicate  | Two Flows share the same Manifest / `fx.call` name     | Give at least one an explicit `flow("…")` or tree export  |
 | `1110` | schema missing       | Domain table absent in `prod` — no auto-DDL            | Run `oke db migrate` against this environment             |
 | `1210` | live resume gap      | `Last-Event-ID` is not on the retained tape            | Reconnect without the cursor; remaining tape replays      |
 | `1240` | orphan emit          | Emit with zero subscribers and `optional` false        | Add `on(signal, …)` or declare `optional: true`           |

package/site/content/docs/reference/fx.mdx

@@ -90,11 +90,11 @@ See [Store](/docs/elements/store) for the query-builder surface.
 
 ## Signals
 
-| Signature                             | Records                | Notes                                                                                                                                                                                                     |
-| ------------------------------------- | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `fx.emit(signal, payload?, { key? })` | `emit`                 | Commits the signal outbox when the call resolves; optional `key` serializes `once` per key; stamps producer run id as `parentRunId` for trace chains; throws **OKE1240** (orphan) or **OKE1250** (schema) |
-| `fx.deadLetters(signal)`              | `read` `signal:<name>` | Dead-lettered messages for that signal. Payload typed from `SignalDecl<T>`. Page with `fx.json.withQuery`. Cross-signal throws **OKE1001**.                                                               |
-| `fx.live(signal, { match? })`         | `read` `signal:<name>` | Live tape as SSE. Returns `JsonStreamResult` (object chunks, `id:` on the wire). Cross-signal throws **OKE1001**. Do not wrap with `fx.json.stream`.                                                      |
+| Signature                             | Records                | Notes                                                                                                                                                                                                                                                                                                                            |
+| ------------------------------------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `fx.emit(signal, payload?, { key? })` | `emit`                 | Pass a `SignalDecl<T>` handle to type-check `payload`; a string name stays `unknown` (runtime `schema` still applies). Commits the signal outbox when the call resolves; optional `key` serializes `once` per key; stamps producer run id as `parentRunId` for trace chains; throws **OKE1240** (orphan) or **OKE1250** (schema) |
+| `fx.deadLetters(signal)`              | `read` `signal:<name>` | Dead-lettered messages for that signal. Payload typed from `SignalDecl<T>`. Page with `fx.json.withQuery`. Cross-signal throws **OKE1001**.                                                                                                                                                                                      |
+| `fx.live(signal, { match? })`         | `read` `signal:<name>` | Live tape as SSE. Returns `JsonStreamResult` (object chunks, `id:` on the wire). Cross-signal throws **OKE1001**. Do not wrap with `fx.json.stream`.                                                                                                                                                                             |
 
 ## Runs (observability read)
 
@@ -108,7 +108,7 @@ Declare `effects: { reads: ["runs"] }`. Powers native SLO checkers (Clock + Chan
 | `fx.runs.checkSlo(flow, slo, windowMs?)` | `read` `runs` | Availability / latency breaches                                                          |
 
 ```typescript
-const sloCheckClock = clock("ops.slo-check", { every: "5m" });
+const sloCheckClock = clock.every("ops.slo-check", "5m");
 
 on(
   sloCheckClock,

package/site/content/docs/reference/okid.mdx

@@ -150,7 +150,7 @@ The default alphabet order is not lexicographic; `_` sorts between uppercase and
 ## Learn more
 
 - [Store](/docs/elements/store) — `defaultFn(id)` in table declarations delegates to `okid()`
-- [fx](/docs/reference/fx) — `fx.id()` in the runtime uses `okid()`
+- [fx](/docs/reference/fx) — `fx.id()` returns an OKID; options live here
 - [Clock](/docs/elements/clock) — process `instanceId` (`inst-<okid>`) is an OKID
 
 ## Next

package/site/content/docs/reference/plugins.mdx

@@ -146,7 +146,7 @@ const maintenance = configSource({
   kv: cache, // read-through cache (optional)
 });
 
-const maintenanceSyncClock = clock("maintenance.sync", { every: "30s" });
+const maintenanceSyncClock = clock.every("maintenance.sync", "30s");
 on(maintenanceSyncClock, maintenance.sync()); // one clock flow refreshes the box
 
 export const app = oke({ name: "shop", env: "dev" }).plug(maintenanceMode(maintenance));

package/site/content/docs/understand/the-architecture.mdx

@@ -239,7 +239,7 @@ None of that required new code beyond what's above. It required the four lines t
 | Trigger                                             | Element | Starts When                      |
 | --------------------------------------------------- | ------- | -------------------------------- |
 | `http.post()` (path from file tree)                 | Flow    | A request arrives                |
-| `clock("name", { every: "10m" })`                   | Clock   | A time interval elapses          |
+| `clock.every("name", "10m")`                        | Clock   | A time interval elapses          |
 | `signal.once("name", {…})` / `.broadcast` / `.live` | Signal  | Another flow announces something |
 | `db.table(users).changed("email")`                  | Store   | A database row changes           |
 | `mcp.tool("name")`                                  | AI      | An AI agent calls it             |