okengine 0.19.0 → 0.19.2

package/site/content/docs/elements/gate/tenancy.mdx

@@ -267,9 +267,12 @@ import { z } from "zod";
 import { member } from "@/core/gate";
 
 export const switchTenant = on(
-  http.post().gate(member),
+  http
+    .post({
+      in: z.object({ tenantId: z.string() }),
+    })
+    .gate(member),
   flow({
-    in: z.object({ tenantId: z.string() }),
     do: async ({ tenantId }, fx) => fx.auth.switchTenant(tenantId),
   }),
 );

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

@@ -65,9 +65,10 @@ import { z } from "zod";
 import { cacheInvalidated } from "@/signals/cache";
 
 export const update = on(
-  http.patch(),
-  flow({
+  http.patch({
     in: z.object({ sku: z.string(), title: z.string().min(1) }),
+  }),
+  flow({
     do: async ({ sku, title }, fx) => {
       // … persist the change …
       await fx.emit(cacheInvalidated, { key: `sku:${sku}` });
@@ -284,9 +285,10 @@ import { z } from "zod";
 import { catalogChanged } from "@/signals/catalog";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ sku: z.string(), title: z.string().min(1) }),
+  }),
+  flow({
     do: async ({ sku, title }, fx) => {
       // … write …
       await fx.emit(catalogChanged, { sku });

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:
@@ -347,6 +360,6 @@ export default defineConfig({
   <Card
     title="The Model"
     description="Eight elements overview."
-    href="/docs/understand/the-model"
+    href="/docs/understand/the-architecture"
   />
 </Cards>

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

@@ -342,9 +342,10 @@ import { z } from "zod";
 import { orderStatus } from "@/signals/orders";
 
 export const ship = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ id: z.string() }),
+  }),
+  flow({
     do: async ({ id }, fx) => {
       await fx.emit(orderStatus, { orderId: id, status: "shipped" });
       return { id, status: "shipped" };

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

@@ -311,9 +311,10 @@ import { z } from "zod";
 import { orderPlaced } from "@/signals/orders";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ userId: z.string(), amount: z.number() }),
+  }),
+  flow({
     do: async ({ userId, amount }, fx) => {
       const orderId = fx.id();
       await fx.emit(orderPlaced, { orderId, amount, userId }, { key: userId });

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

@@ -38,13 +38,14 @@ import { z } from "zod";
 import { uploads } from "@/core";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({
       name: z.string().min(1),
       bytes: z.string(), // base64 for the demo
     }),
     out: z.object({ key: z.string() }),
+  }),
+  flow({
     do: async ({ name, bytes }, fx) => {
       const key = `uploads/${fx.id()}-${name}`;
       const data = Uint8Array.from(atob(bytes), (c) => c.charCodeAt(0));
@@ -123,9 +124,10 @@ import { z } from "zod";
 import { uploads } from "@/core";
 
 export const cleanup = on(
-  http.delete(),
-  flow({
+  http.delete({
     in: z.object({ prefix: z.string().default("avatars/") }),
+  }),
+  flow({
     do: async ({ prefix }, fx) => {
       const keys = await fx.store(uploads).list(prefix);
       let removed = 0;
@@ -154,9 +156,10 @@ import { z } from "zod";
 import { uploads } from "@/core";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ bytes: z.string() }),
+  }),
+  flow({
     do: async ({ bytes }, fx) => {
       const key = `photos/${fx.id()}.jpg`;
       const data = Uint8Array.from(atob(bytes), (c) => c.charCodeAt(0));
@@ -195,9 +198,10 @@ import { z } from "zod";
 import { uploads } from "@/core";
 
 export const card = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ sourceKey: z.string() }),
+  }),
+  flow({
     do: async ({ sourceKey }, fx) => {
       const outKey = sourceKey.replace(/\.[^.]+$/, ".card.webp");
       await fx
@@ -282,13 +286,14 @@ import { z } from "zod";
 import { uploads } from "@/core";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({
       id: z.string(),
       name: z.string().min(1),
       bytes: z.string(),
     }),
+  }),
+  flow({
     do: async ({ id, name, bytes }, fx) => {
       const key = `notes/${id}/${name}`;
       const data = Uint8Array.from(atob(bytes), (c) => c.charCodeAt(0));
@@ -311,10 +316,11 @@ import { z } from "zod";
 import { uploads } from "@/core";
 
 export const get = on(
-  http.get(),
-  flow({
+  http.get({
     in: z.object({ id: z.string(), name: z.string() }),
     errors: { NotFound: z.object({ key: z.string() }) },
+  }),
+  flow({
     do: async ({ id, name }, fx) => {
       const key = `notes/${id}/${name}`;
       const bytes = await fx.store(uploads).get(key);
@@ -337,9 +343,10 @@ import { z } from "zod";
 import { uploads } from "@/core";
 
 export const remove = on(
-  http.delete(),
-  flow({
+  http.delete({
     in: z.object({ id: z.string(), name: z.string() }),
+  }),
+  flow({
     do: async ({ id, name }, fx) => {
       const key = `notes/${id}/${name}`;
       const removed = await fx.store(uploads).delete(key);
@@ -362,9 +369,10 @@ import { z } from "zod";
 import { uploads } from "@/core";
 
 export const attachments = on(
-  http.get(),
-  flow({
+  http.get({
     in: z.object({ id: z.string() }),
+  }),
+  flow({
     do: async ({ id }, fx) => {
       const keys = await fx.store(uploads).list(`notes/${id}/`);
       return { keys };

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

@@ -47,9 +47,10 @@ import { z } from "zod";
 import { db, notes } from "@/schema";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ title: z.string().min(1) }),
+  }),
+  flow({
     do: async ({ title }, fx) => {
       const id = fx.id();
       await fx.store(db).insert(notes).values({ id, title });
@@ -106,10 +107,11 @@ import { eq } from "drizzle-orm";
 import { db, notes } from "@/schema";
 
 export const get = on(
-  http.get(),
-  flow({
+  http.get({
     in: z.object({ id: z.string() }),
     errors: { NotFound: z.object({ id: z.string() }) },
+  }),
+  flow({
     do: async ({ id }, fx) => {
       const [note] = await fx.store(db).select().from(notes).where(eq(notes.id, id));
       if (!note) return fx.fail("NotFound", { id });
@@ -128,11 +130,11 @@ Prefer [`store.resource`](/docs/elements/store/sql#resources) when you want five
 Pass the **declaration** into `fx.store` — there is no `fx.store.kv` namespace. TTL is a duration string:
 
 ```typescript title="src/flows/sessions/put.ts"
-import { flow } from "okengine";
+import { call } from "okengine";
 import { z } from "zod";
 import { sessions } from "@/core";
 
-export const putSession = flow("sessions.put", {
+export const putSession = call("sessions.put", {
   in: z.object({ token: z.string(), userId: z.string() }),
   do: async ({ token, userId }, fx) => {
     await fx.store(sessions).set(`session:${token}`, userId, "1h");
@@ -159,9 +161,10 @@ import { z } from "zod";
 import { uploads } from "@/core";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ bytes: z.string() }),
+  }),
+  flow({
     do: async ({ bytes }, fx) => {
       const key = `avatars/${fx.id()}.png`;
       const data = Uint8Array.from(atob(bytes), (c) => c.charCodeAt(0));

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

@@ -39,9 +39,10 @@ import { z } from "zod";
 import { sessions } from "@/core";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ token: z.string(), userId: z.string() }),
+  }),
+  flow({
     do: async ({ token, userId }, fx) => {
       await fx.store(sessions).set(`session:${token}`, userId, "1h");
       const cached = await fx.store(sessions).get(`session:${token}`);
@@ -97,9 +98,10 @@ import { z } from "zod";
 import { sessions } from "@/core";
 
 export const get = on(
-  http.get(),
-  flow({
+  http.get({
     in: z.object({ userId: z.string() }),
+  }),
+  flow({
     do: async ({ userId }, fx) => {
       const prefs = await fx.store(sessions).get(`user:${userId}:prefs`);
       return { prefs: prefs ?? null };
@@ -122,9 +124,10 @@ import { z } from "zod";
 import { sessions } from "@/core";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ userId: z.string() }),
+  }),
+  flow({
     do: async ({ userId }, fx) => {
       const code = "482193";
       await fx.store(sessions).set(`otp:${userId}`, code, "5m");
@@ -251,10 +254,11 @@ import { z } from "zod";
 import { sessions } from "@/core";
 
 export const get = on(
-  http.get(),
-  flow({
+  http.get({
     in: z.object({ token: z.string() }),
     errors: { NotFound: z.object({ token: z.string() }) },
+  }),
+  flow({
     do: async ({ token }, fx) => {
       const userId = await fx.store(sessions).get(`session:${token}`);
       if (userId === undefined || userId === null) {
@@ -278,9 +282,10 @@ import { z } from "zod";
 import { sessions } from "@/core";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ token: z.string(), userId: z.string() }),
+  }),
+  flow({
     do: async ({ token, userId }, fx) => {
       await fx.store(sessions).set(`session:${token}`, userId, "1h");
       return { ok: true as const };
@@ -304,9 +309,10 @@ import { z } from "zod";
 import { sessions } from "@/core";
 
 export const remove = on(
-  http.delete(),
-  flow({
+  http.delete({
     in: z.object({ token: z.string() }),
+  }),
+  flow({
     do: async ({ token }, fx) => {
       const removed = await fx.store(sessions).delete(`session:${token}`);
       return { removed };
@@ -358,9 +364,10 @@ import { z } from "zod";
 import { sessions } from "@/core";
 
 export const ttl = on(
-  http.get(),
-  flow({
+  http.get({
     in: z.object({ userId: z.string() }),
+  }),
+  flow({
     do: async ({ userId }, fx) => {
       const ttlMs = await fx.store(sessions).ttlMs(`otp:${userId}`);
       return { ttlMs };
@@ -409,13 +416,14 @@ import { z } from "zod";
 import { drafts } from "@/core";
 
 export const save = on(
-  http.put("/drafts/:id"),
-  flow({
+  http.put("/drafts/:id", {
     in: z.object({
       id: z.string().min(1),
       title: z.string().min(1),
       body: z.string().optional(),
     }),
+  }),
+  flow({
     do: async ({ id, title, body }, fx) => {
       await fx.store(drafts).set(id, { title, body: body ?? "" }, "7d");
       return { id };

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

@@ -42,9 +42,10 @@ import { z } from "zod";
 import { articles, db } from "@/schema";
 
 export const search = on(
-  http.get(),
-  flow({
+  http.get({
     in: z.object({ q: z.string() }),
+  }),
+  flow({
     do: async ({ q }, fx) => {
       const result = await fx.store(db).search(articles, {
         query: q,
@@ -399,9 +400,10 @@ import { z } from "zod";
 import { articles, db } from "@/schema";
 
 export const search = on(
-  http.get(),
-  flow({
+  http.get({
     in: z.object({ q: z.string().min(1) }),
+  }),
+  flow({
     do: async ({ q }, fx) => {
       const result = await fx.store(db).search(articles, {
         query: q,
@@ -430,12 +432,13 @@ import { z } from "zod";
 import { articles, db } from "@/schema";
 
 export const search = on(
-  http.get(),
-  flow({
+  http.get({
     in: z.object({
       q: z.string().min(1),
       status: z.string().optional(),
     }),
+  }),
+  flow({
     do: async ({ q, status }, fx) => {
       const result = await fx.store(db).search(articles, {
         query: q,
@@ -539,7 +542,7 @@ intentional. Do not poll `fx.embed` from the writer to “close” it.
 | ------------------------------------- | ---------------------------------------------------------- |
 | Generated `tsvector` + GIN            | BM25 candidate retrieval (`plainto_tsquery('english', …)`) |
 | `real[]` embedding column             | Stored vector per `.embed()` field                         |
-| `bigint` LSH column + B-tree          | Bucket lookup (Hamming-1 neighbors included)               |
+| `bigint` LSH column + B-tree          | Stored SimHash pack (query ranks by Hamming, not equality) |
 | Corpus stats / DF / hyperplane tables | IDF, average length, stable LSH planes                     |
 
 Hyperplanes insert once (`ON CONFLICT DO NOTHING`) and are **never** regenerated.
@@ -619,8 +622,9 @@ await fx.store(db).search(articles, {
   BM25F uses Robertson–Zaragoza saturation: **k1 = 1.2**, **b = 0.75**. Field
   `weight` multiplies term frequency *before* that saturation.
 
-LSH uses **64** hyperplanes (fits a `bigint` bit pack). Query-time lookup includes
-the exact bucket and Hamming-1 neighbors.
+LSH uses **64** hyperplanes packed into a `bigint`. Query-time retrieval ranks
+rows by Hamming distance (`bit_count` of XOR) and keeps the oversampled nearest
+(`max(limit × 5, 50)`, cap 500), then cosine-reranks in process.
 
 </Accordion>
 
@@ -800,13 +804,13 @@ Headline numbers from the live-Postgres G17 gate (`OKE_TEST_POSTGRES=1`, Bun 1.4
 
 | Corpus size | BM25 (text) p50 | LSH/hybrid p50 | LSH precision@10 vs exact cosine | Guidance                                                                                 |
 | ----------- | --------------- | -------------- | -------------------------------- | ---------------------------------------------------------------------------------------- |
-| ≤10k        | ~1–4 ms         | ~1–6 ms        | ≈0 on this gate                  | Built-in hybrid is fine for ranking UX; do not market LSH recall                         |
-| ~100k       | ~40 ms          | ~50–60 ms      | ≈0                               | Expect tens of ms; re-`EXPLAIN` after `ANALYZE`                                          |
-| ~1M         | ~0.6–1.2 s      | ~0.6–1.2 s     | ≈0                               | Prefer external `store.index` (pgvector / Meilisearch) for semantic recall at this scale |
+| ≤10k        | ~1–5 ms         | ~1–9 ms        | 0.10–0.17 vector                 | Built-in hybrid is fine for ranking UX; LSH is not HNSW                                  |
+| ~100k       | ~21 ms          | ~31–34 ms      | 0.017 vector                     | Expect tens of ms; re-`EXPLAIN` after `ANALYZE`                                          |
+| ~1M         | ~0.3 s          | ~0.4 s         | 0.017 vector / 0 hybrid          | Prefer external `store.index` (pgvector / Meilisearch) for semantic recall at this scale |
 
-**Honest LSH note:** random-hyperplane LSH (K=64, Hamming-1, ≤50 candidates) did **not** match exact brute-force cosine top-10 on the G17 corpus (precision@10 mostly **0**). Same class of honesty as earlier LSH-vs-HNSW design notes — use LSH as a cheap candidate hint inside RRF, not as a recall guarantee. BM25-only needs no AI and remains the smallest path.
+**Honest LSH note:** after the Hamming-rank fix (2026-09-11), vector precision@10 vs exact cosine is 0.17 at 1k, 0.10 at 10k, ~0.02 at 100k–1M on the G17 hash-bag corpus — a smooth drop, not the v0.19.0 zero collapse. Still **not** HNSW. Prefer BM25-only or `store.index` when semantic recall matters.
 
-**Query plan:** at N=100k, `EXPLAIN (ANALYZE, BUFFERS)` showed a **Seq Scan** with a tsvector/LSH Filter — not BitmapOr — despite GIN + B-tree indexes. Capture your own plan on production data before assuming an index path.
+**Query plan:** at N=100k, `EXPLAIN (ANALYZE, BUFFERS)` is a UNION of GIN **Bitmap Index Scan** and a **Parallel Seq Scan** + top-N heapsort on Hamming distance (~15 ms). Hamming-rank cannot use the LSH B-tree. Capture your own plan on production data.
 
 **Backfill:** `oke db search-backfill` is interrupt-safe to re-run (G17 killed at 2k/50k embeds, resumed to completion in ~29 s on that table).
 

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

@@ -291,11 +291,12 @@ import { eq } from "drizzle-orm";
 import { db, notes } from "@/schema";
 
 export const get = on(
-  http.get(),
-  flow({
+  http.get({
     in: z.object({ id: z.string() }),
     out: z.object({ id: z.string(), title: z.string() }),
     errors: { NotFound: z.object({ id: z.string() }) },
+  }),
+  flow({
     do: async ({ id }, fx) => {
       const [note] = await fx.store(db).select().from(notes).where(eq(notes.id, id));
       if (!note) return fx.fail("NotFound", { id });
@@ -317,10 +318,11 @@ import { z } from "zod";
 import { db, notes } from "@/schema";
 
 export const create = on(
-  http.post(),
-  flow({
+  http.post({
     in: z.object({ title: z.string().min(1) }),
     out: z.object({ id: z.string(), title: z.string() }),
+  }),
+  flow({
     do: async ({ title }, fx) => {
       const id = fx.id();
       const [row] = await fx.store(db).insert(notes).values({ id, title }).returning();
@@ -344,13 +346,14 @@ import { eq } from "drizzle-orm";
 import { db, notes } from "@/schema";
 
 export const update = on(
-  http.patch(),
-  flow({
+  http.patch({
     in: z.object({
       id: z.string(),
       title: z.string().min(1).optional(),
     }),
     errors: { NotFound: z.object({ id: z.string() }) },
+  }),
+  flow({
     do: async ({ id, title }, fx) => {
       if (title !== undefined) {
         await fx.store(db).update(notes).set({ title }).where(eq(notes.id, id));
@@ -376,9 +379,10 @@ import { z } from "zod";
 import { db, notes } from "@/schema";
 
 export const remove = on(
-  http.delete(),
-  flow({
+  http.delete({
     in: z.object({ id: z.string() }),
+  }),
+  flow({
     do: async ({ id }, fx) => {
       await fx.store(db).delete(notes, id);
       return fx.json.empty();
@@ -422,11 +426,11 @@ prefer them for live feeds. Offset is fine for admin tables.
 Default is insert-once. Pass `{ onExisting: "update" }` to overwrite a match:
 
 ```typescript title="src/flows/notes/ensure.ts"
-import { flow } from "okengine";
+import { call } from "okengine";
 import { z } from "zod";
 import { db, notes } from "@/schema";
 
-export const ensureWelcome = flow("notes.ensureWelcome", {
+export const ensureWelcome = call("notes.ensureWelcome", {
   in: z.object({ title: z.string() }),
   do: async ({ title }, fx) => {
     const result = await fx.store(db).upsert(
@@ -803,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/elements/vault/config.mdx

@@ -48,9 +48,12 @@ import { member } from "@/core/gate";
 import { publicAppUrl, noteCreatedMail } from "@/core";
 
 export const create = on(
-  http.post().gate(member),
+  http
+    .post({
+      in: z.object({ email: z.string().email() }),
+    })
+    .gate(member),
   flow({
-    in: z.object({ email: z.string().email() }),
     do: async ({ email }, fx) => {
       const origin = await fx.vault.get(publicAppUrl);
       await fx.send(noteCreatedMail, {

package/site/content/docs/elements/vault/rotation.mdx

@@ -93,10 +93,13 @@ import { gate } from "okengine";
 const operator = gate.policy("operator", ({ operator: op }) => !!op);
 
 export const rotateStripe = on(
-  http.post().gate(operator),
+  http
+    .post({
+      in: z.object({ value: z.string().min(1) }),
+    })
+    .gate(operator),
   flow({
     plane: "operator",
-    in: z.object({ value: z.string().min(1) }),
     effects: { secrets: ["STRIPE_KEY"] },
     do: async ({ value }, fx) => {
       const result = await fx.vault.rotate("STRIPE_KEY", value);

package/site/content/docs/elements/vault/secrets.mdx

@@ -51,9 +51,12 @@ import { member } from "@/core/gate";
 import { stripeKey } from "@/core/vault";
 
 export const charge = on(
-  http.post().gate(member),
+  http
+    .post({
+      in: z.object({ amount: z.number().int().positive() }),
+    })
+    .gate(member),
   flow({
-    in: z.object({ amount: z.number().int().positive() }),
     do: async ({ amount }, fx) => {
       const key = await fx.vault.get(stripeKey);
       const stripe = new Stripe(key.reveal());

package/site/content/docs/index.mdx

@@ -23,29 +23,14 @@ Master the mental model before exploring features:
 
 <Cards>
   <Card
-    title="The Problem"
-    description="Three unrelated features that hit the exact same wall, and the timeline that shows why."
-    href="/docs/understand/the-problem"
-  />
-  <Card
-    title="The Model"
-    description="The one rule that removes the disagreement between systems — stated plainly, in two parts."
-    href="/docs/understand/the-model"
-  />
-  <Card
-    title="The Vocabulary"
-    description="The eight things the door recognizes — what each one replaces, and why nothing else made the cut."
-    href="/docs/understand/the-vocabulary"
-  />
-  <Card
-    title="The Anatomy"
-    description="The five pieces behind on(trigger, flow) — on, trigger, flow, do, and fx — explained one at a time."
-    href="/docs/understand/the-anatomy"
+    title="The Architecture"
+    description="Why backends drift apart, the one rule that stops it, and the five pieces behind every Flow."
+    href="/docs/understand/the-architecture"
   />
   <Card
     title="Try It"
     description="From an empty folder to a Flow running in the Console — one sitting, minimal detour."
-    href="/docs/ai/try-it"
+    href="/docs/understand/try-it"
   />
 </Cards>
 

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));
 ```