okengine 0.18.5 → 0.19.0

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

@@ -1,1099 +0,0 @@
----
-title: "Store"
-description: "Data at rest behind one handle and four independent facets — sql · kv · files · index — swapped per environment by driver."
-icon: "Database"
-source: "docs/spec/unified-theory.md"
----
-
-Store is one handle, four independent facets — **sql · kv · files · index**. Each has its own shape; nothing forces you to use more than one. Flow code stays the same across environments; only the driver changes. Every facet accepts an optional `description` — a human title in the Console (falls back to the store name) — and auto-registers when its declaring module is imported before `oke()` (`oke({ stores })` is still valid and additive).
-
-<Callout title="The one rule">
-  Drivers are named after **protocols**, not vendors (`postgres`, `redis`, `s3` — never `neon` or
-  `minio`). Vendor choice lives in the `images` map of `oke.config.ts`.
-</Callout>
-
-<StoreFacets />
-
-## Quick start
-
-<Steps>
-
-<Step>
-### Declare a table
-
-In `src/schema.decl.ts`, describe your tables with plain field builders — no ORM syntax:
-
-```typescript title="src/schema.decl.ts"
-import { store, field } from "okengine";
-
-export const notes = store.schema.table("notes", {
-  id: field.id().primaryKey(),
-  title: field.text().notNull(),
-  body: field.text().notNull(),
-  createdAt: field.integer().notNull().now(),
-});
-```
-
-</Step>
-
-<Step>
-### Declare the store and push the schema
-
-Bind the schema to a SQL store in `src/core.ts`. `oke dev` auto-pushes on save — or run it by hand:
-
-```typescript title="src/core.ts"
-import { store } from "okengine";
-import { notes } from "./schema.decl";
-
-export const db = store.sql("notes", { schema: { notes } });
-```
-
-```bash
-oke db push   # dev — applies the schema to your local database
-```
-
-</Step>
-
-<Step>
-### Read and write in a Flow
-
-All data access goes through `fx.store(db)` — a typed session, one table at a time:
-
-```typescript title="src/flows/notes/create.ts"
-export const createNote = on(
-  http.post("/notes"),
-  flow("notes.create", {
-    in: z.object({ title: z.string(), body: z.string() }),
-    out: z.object({ id: z.string() }),
-    do: async (input, fx) => {
-      const id = fx.id();
-      await fx
-        .store(db)
-        .insert(notes)
-        .values({ id, ...input, createdAt: Date.now() });
-      return { id };
-    },
-  }),
-);
-```
-
-</Step>
-
-</Steps>
-
-## SQL
-
-<StoreFacetMark facet="sql" />
-
-The relational facet: tables, schema, and typed single-table sessions through `fx.store`.
-
-### Resource routes — `store.resource`
-
-Five conventional endpoints (list, create, get, update, remove) expand from one declaration. Each is an ordinary Flow underneath — same contracts, same `fx`:
-
-```typescript
-const notesR = store.resource(db, notes, {
-  in: NewNote, // create/update input schema
-  out: Note, // response schema
-  update: NewNote.partial(),
-  list: {
-    cursor: [notes.createdAt, notes.id], // keyset pagination columns
-    direction: "desc",
-    search: [notes.title], // ?search= / ?q=
-    filter: "all", // ?col=op.value — "all" | Column[] | "none"
-    order: "all", // ?order=col.desc
-  },
-});
-
-const mounted = on(http.resource("/notes", notesR.all()).public());
-```
-
-`.gate(...)` / `.public()` chain like `http.get` — gates on every verb. Passing `live: true` also mounts an SSE `GET <path>/live`; see Live queries below.
-
-The list endpoint's URL is the whole query language:
-
-| Param                               | Meaning                                                   | Example                               |
-| ----------------------------------- | --------------------------------------------------------- | ------------------------------------- |
-| `?cursor=` / `?offset=` / `?limit=` | paginate (keyset when `cursor` columns are set)           | `?limit=20&cursor=eyJ…`               |
-| `?search=` (`?q=`)                  | substring match over `search` columns                     | `?q=invoice`                          |
-| `?col=op.value`                     | filter — `eq neq gt gte lt lte like ilike in is` + `not.` | `?title=like.*draft*`                 |
-| `?or=(…)` / `?and=(…)`              | grouped filters, nested `not.and` / `not.or`              | `?or=(a.eq.1,not.and(b.gt.2,c.lt.9))` |
-| `?order=`                           | sort (`col.desc`, comma-separated)                        | `?order=createdAt.desc`               |
-| `?select=`                          | project columns                                           | `?select=id,title`                    |
-
-Responses follow the Stripe-style envelope: `{ data, meta, error }`. Clients page with `page.next()` or `for await (const page of api.notes.list({ limit: 20 }))` — `meta.next` / `meta.prev` are the next request (`{ cursor }`), not flags. `mode` is diagnostic. `create` answers **201**, `remove` answers **204**, and a missing row is a typed `NotFound` — never a crash.
-
-**Consequence:** `count: "exact"` (the offset default) runs `COUNT(*)` per page. Set `count: "none"` to return only `meta.offset`. Keyset (cursor) paging is the default when `cursor` columns are set — pages stay stable while new rows are inserted, where offset pages would shift and show duplicates.
-
-A request that filters on a forbidden column — `?secret=eq.x` — fails with **422** and the exact message `unknown list param "secret"`. Filterable columns are a whitelist, never an accident.
-
-### Live queries — `live: true` and `.live(table)`
-
-> **Realtime did not introduce a new subsystem. It composed existing Store, Signal, Gate/RLS, Flow, and Manifest semantics.**
-
-Pass `live: true` to also mount `GET <path>/live` — an SSE feed of per-subscriber classified events (`upsert` / `revoked` / `delete`), gated the same way as the CRUD verbs:
-
-```typescript
-const notesR = store.resource(db, notes, {
-  in: NewNote,
-  out: Note,
-  live: true, // synthesizes GET /notes/live + internal live signal
-});
-
-const mounted = on(http.resource("/notes", notesR.all()).gate(member));
-```
-
-The live route re-checks RLS for every CDC event under the subscriber's stamped identity. A row that leaves the caller's visibility window arrives as `{ kind: "revoked", id, reason: "rls" | "query" }` — never as a silent stale upsert. `"rls"` means the row no longer passes the subscriber's policies; `"query"` means RLS still allows it but it fell out of the filter or search window. Clients consume it with `useLiveQuery` from `okengine/client-react`.
-
-`store.resource` is optional. A hand-written flow declares the same live surface with the `.live(table)` trigger modifier and the `liveQuery` helper — identical stream, guardrails, and per-subscriber classification:
-
-```typescript
-import { liveQuery } from "okengine";
-
-export const live = on(
-  http.get("/tasks/live").gate(member).live(tasks),
-  flow("tasks.live", {
-    in: { unknown: true },
-    do: async (input, fx) =>
-      liveQuery(fx, tasks, input, {
-        search: [tasks.title],
-        filter: [tasks.status], // same list grammar as store.resource
-        order: "all",
-      }),
-  }),
-);
-```
-
-`.live(tasks)` stamps the internal `oke/live/sql:tasks` signal at extract and enforces the same guardrails as `live: true` (PK required; `updatedAt` / RLS warnings). The flow body parses the request's query params with the exact list grammar, then opens the classified CDC stream.
-
-- `?status=eq.open` filters the live window the same way it filters `GET /tasks`.
-- A flow that also writes other tables (an activity log alongside the main write) never leaks those tables into the stream: classification is per-table.
-
-#### The project-wide default — `oke({ store: { live: true } })`
-
-Live remains **explicitly per-table** (`live: true` / `.live(table)`) unless you flip the whole project. Pass `store: { live: true }` to `oke()` to make every **new** `store.schema.table()` declaration live-by-default — the same automatic CDC + RLS-per-event stream `live: true` provides, without writing it on each declaration:
-
-```typescript
-const app = oke({
-  name: "shop",
-  store: { live: true }, // new tables are live by default from here on
-});
-```
-
-```typescript
-// No explicit live needed — this table is live by default.
-export const notes = store.schema.table(
-  "notes",
-  {
-    id: field.text().primaryKey(),
-    updatedAt: field.integer().notNull(),
-  },
-  [store.schema.policy.owner("owner")],
-);
-
-const notesR = store.resource(db, notes, {}); // GET /notes/live synthesized
-const mounted = on(http.resource("/notes", notesR.all()).gate(member));
-```
-
-Three rules keep the flip predictable:
-
-- **Default `false`** — today's explicit-only behavior is unchanged. An app that never sets `store.live` pays zero: no signals synthesized, no `/live` routes, no bundle or runtime difference.
-- **Per-table opt-out** — a specific table stays NOT live under the project flag by declaring `store.schema.live(false)` in its extras array (the same third-argument slot as `store.schema.unscoped()` / `rls()` / policies). `store.resource(db, table, { live: false })` is the equivalent opt-out at the resource layer.
-- **Explicit still wins** — `live: true` on a resource or `.live(table)` on a flow opts a specific surface back in even under an opt-out, matching today's behavior.
-
-```typescript
-export const archive = store.schema.table(
-  "archive",
-  {
-    id: field.text().primaryKey(),
-  },
-  [
-    store.schema.policy.owner("owner"),
-    store.schema.live(false), // exempt from the project-wide default
-  ],
-);
-```
-
-**This flag changes declaration defaults only — never the runtime cost model.** Live-by-default consumes the exact same per-event RLS stamping as an explicit `live: true`. The guardrails below (PK required; `updatedAt` / RLS warnings) fire identically whether a table became live explicitly or via the default flip — there is no separate, weaker code path. What you are trading against is the fan-out profile of the writes below.
-
-#### Live fan-out latency — the real cost model
-
-Every live write fans out one **stamped RLS visibility check per subscriber** (per-event, per-connection): p50 fan-out for one CDC event to `S` subscribers grows linearly with `S` (default Postgres pool concurrency ~16–32, `stamp_p50` ≈ 0.5–1 ms):
-
-```
-p50_fanout ≈ ceil(S / pool_concurrency) × stamp_p50
-```
-
-Measured from the benchmark sweep (G8a / G8c):
-
-| Active subscribers (same table/query) | Estimated p50 fan-out | UX                                            |
-| ------------------------------------- | --------------------- | --------------------------------------------- |
-| **1–30**                              | 1–15 ms               | Instant                                       |
-| **30–80**                             | 15–50 ms              | Instant to snappy                             |
-| **80–150**                            | 50–100 ms             | Snappy; power users may notice on hot tables  |
-| **150–300**                           | 100–200 ms            | **Perceptible lag** — updates arrive in waves |
-| **300+**                              | 200 ms+ linear        | **Not instant** — capacity planning required  |
-
-So before you flip `store.live` project-wide on a large application, weigh it against how many concurrent subscribers each hot table is likely to hold. **>150 concurrent live subscribers on the same resource starts to feel like perceptible lag; >300 is the soft ceiling** for the "real-time feel" without an architectural change. Same cost either way — explicit `live: true` or the default flip — this table is the tradeoff you are enabling. (PGlite dev serializes stamping behind a lock; treat fan-out numbers there as correctness-only, never prod latency.)
-
-`live: true` carries compile-time guardrails at extract, plus durable delivery and runtime watchtowers:
-
-- A table with **no primary key fails extract loud** — upsert/revoked/delete address rows by PK.
-- Missing `updatedAt` / `updated_at` warns (no `rowVersion` LWW guard; races rely on `X-Oke-Mutation-Id` echo dedupe), missing RLS policies warns (every gated subscriber would see every row).
-- CDC events ride the durable `oke_cdc_outbox`; delivered rows prune on retention defaults (24h / 50k) so the outbox never grows unbounded.
-- `oke doctor` findings watch the runtime side: `cdc_outbox_backlog`, `cdc_outbox_retention`, `live_subscriber_pressure` (~150 subs/table in v1), and `live_fanout_queue_saturated`.
-
-### Handwritten HTTP lists
-
-`store.resource` is the usual CRUD path. When you write the list Flow yourself, prefer the same Stripe envelope — `out` is the item array, pagination sits on `meta`:
-
-```typescript
-export const list = on(
-  http.get("/notes").public(),
-  flow("notes.list", {
-    out: z.array(Note),
-    do: async (input, fx) => {
-      const rows = await fx.store(db).select().from(notes);
-      return fx.json.withQuery(rows, input);
-    },
-  }),
-);
-```
-
-`list.ts` + `http.get()` fills `GET /notes` named `notes.list` — explicit strings still win. See [Project structure](/docs/get-started/project-structure).
-
-Zero-config: `?q=` searches every string field, extra keys auto-eq except path `id`, and PostgREST `?col=op.value` / `?order=` / `?select=` are open. Nested lists filter the parent in the load — `input.id` is not a column eq.
-
-<Callout title="Preferred, not required">
-  Any declared `out` is valid — `{ notes: […] }` still works. The array + `fx.json.withQuery`
-  shape matches `store.resource` and the typed client (`data` is the page, `meta` is the pager).
-</Callout>
-
-### Querying by hand
-
-When the list is not conventional CRUD, `fx.store(db)` is the full single-table session:
-
-```typescript
-// select — chain where / orderBy / limit / offset in any order
-const latest = await fx
-  .store(db)
-  .select()
-  .from(notes)
-  .where(like(notes.title, `%${input.q}%`))
-  .orderBy(desc(notes.createdAt))
-  .limit(20);
-
-// findById, insert, update, delete
-const one = await fx.store(db).findById(notes, input.id);
-await fx.store(db).update(notes).set({ title: input.title }).where(eq(notes.id, input.id));
-await fx.store(db).delete(notes).where(lt(notes.createdAt, cutoff));
-```
-
-`select().from(notes)` infers the declared row (`string` / `number` / `null` from `field.*`). A `select({ title: notes.title })` projection stays untyped.
-
-<Callout title="One table per call — no relational with:">
-  `fx.store` is deliberately **single-table**: Drizzle's relational `findMany({ with: … })` is not
-  available through `fx`. Compose joins as separate single-table reads (or `fx.call`) so every
-  table shows up explicitly in the Manifest's `reads` / `writes` — powering caching and PII masking.
-</Callout>
-
-### Schema — declare once, generate per dialect
-
-The recommended path: declare tables ORM-agnostically, then let `oke db` emit real Drizzle (`pgTable` for Postgres / PGLite) into `src/db/schema.drizzle.ts`.
-
-| Field API                                                    | Meaning                                                                                                                                                                                 |
-| ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `field.text({ enum })`                                       | text; enum narrows to a literal union                                                                                                                                                   |
-| `field.id()`                                                 | id column with the default generation id (currently OK ID) minted on insert                                                                                                             |
-| `field.okid()`                                               | id column explicitly generated with OK ID                                                                                                                                               |
-| `field.varchar({ length })` · `field.char`                   | bounded strings (same enum support)                                                                                                                                                     |
-| `field.boolean()`                                            | boolean                                                                                                                                                                                 |
-| `field.smallint()` · `field.integer()`                       | ints (abstract integer emits as Drizzle `bigint`)                                                                                                                                       |
-| `field.bigint({ mode })`                                     | int8 — JS `number` (default) / `bigint` / `string`                                                                                                                                      |
-| `field.serial()` · `smallserial` · `bigserial`               | auto-increment — NOT NULL by SQL physics                                                                                                                                                |
-| `field.numeric({ precision, scale })`                        | exact decimals — infers `string`; `{ mode }` opts into `number` / `bigint`                                                                                                              |
-| `field.real()` · `doublePrecision()`                         | floats (~6 / ~15 significant digits)                                                                                                                                                    |
-| `field.json<T>()` · `jsonb<T>()`                             | JSON payloads with a generic type                                                                                                                                                       |
-| `field.uuid()`                                               | UUID strings                                                                                                                                                                            |
-| `field.time()` · `timestamp()` · `date()`                    | temporals — `Date` by default; `{ mode: "string" }` opts into ISO `string`                                                                                                              |
-| `field.interval({ fields })`                                 | time spans                                                                                                                                                                              |
-| `field.point({ mode })` · `line()`                           | geometric tuples or objects                                                                                                                                                             |
-| `field.bytea()`                                              | binary (`Buffer`)                                                                                                                                                                       |
-| `field.inet()` · `cidr` · `macaddr8`                         | network addresses as strings                                                                                                                                                            |
-| `.primaryKey()` · `.notNull()` · `.unique()`                 | constraints                                                                                                                                                                             |
-| `.default(v)` · `.defaultFn(id \| now \| nowIso \| nowDate)` | defaults — typed against the column's JS type                                                                                                                                           |
-| `.okid()` · `.now()`                                         | prepared defaults — fresh OKID / current instant. `.now()` resolves by column: epoch-ms on numbers, ISO-8601 on string-mode temporals, `Date` on default / `{ mode: "date" }` temporals |
-| `.type<T>()`                                                 | override the inferred JS type (mirrors Drizzle `$type<T>`)                                                                                                                              |
-| `.pii()` · `.sensitive()` · `.retain("30d")`                 | privacy classification                                                                                                                                                                  |
-| `.as("sql_name")`                                            | override the automatic `camelCase → snake_case`                                                                                                                                         |
-| `.describe("…")`                                             | human title in the Console (falls back to key)                                                                                                                                          |
-| `.references(() => col, { onDelete })`                       | foreign key                                                                                                                                                                             |
-| `store.schema.rls()`                                         | `pgTable.withRLS` when there are no policies                                                                                                                                            |
-| `store.schema.policy.gate/owner/scope/tenant`                | happy-path RLS (`oke.gate()` / `oke.user()` / `oke.has_scope()` / `oke.tenant()`)                                                                                                       |
-| `store.schema.unscoped()`                                    | Shared table — required when tenancy is on and there is no tenant policy                                                                                                                |
-| `store.schema.live(false)`                                   | Per-table opt-out from the project-wide `store.live` default — not live-by-default, no synthesized `/live` surface                                                                      |
-
-#### Foreign keys and relations
-
-Declare FKs on fields, and relation metadata once per schema:
-
-```typescript
-export const daily = store.schema.table("daily", {
-  id: field.text().primaryKey(),
-  code: field
-    .text()
-    .notNull()
-    .references(() => links.code),
-  day: field.text().notNull(),
-  clicks: field.integer().notNull().default(0),
-});
-
-export const relations = store.schema.relations({ links, daily }, (r) => ({
-  links: { daily: r.many.daily({ from: r.links.code, to: r.daily.code }) },
-  daily: { link: r.one.links({ from: r.daily.code, to: r.links.code, optional: false }) },
-}));
-```
-
-<Callout title="Many-to-many">
-  A junction table with two foreign keys plus two `one` / `many` relations composes many-to-many.
-  There is no separate API and no `.through()` — the junction is an ordinary table.
-</Callout>
-
-#### Syncing the schema
-
-| Command           | When                                                           |
-| ----------------- | -------------------------------------------------------------- |
-| `oke db push`     | Dev — apply directly to the live local DB (no migration files) |
-| `oke db generate` | Write versioned SQL under `drizzle/` for review                |
-| `oke db migrate`  | Apply those files — human or CI, **never** at boot             |
-
-`oke dev` auto-pushes on schema _inputs_ (`schema.decl.ts`, hand-written `schema.ts`, `app.ts` plugin tables, `drizzle.config.ts`) — not when emit rewrites `schema.drizzle.ts`. A `schema.decl.ts` error prints `schema.decl.ts has an error — …` (red ●) and keeps running.
-
-Opt out with `--no-db-push` or `db: { autoPush: false }`. `prod` **never** auto-applies DDL; a missing table fails as **OKE1101** (`oke db migrate`).
-
-#### Multiple environments
-
-| Environment    | Sync                                                           |
-| -------------- | -------------------------------------------------------------- |
-| `dev`          | `oke db push` (or auto-push from `oke dev`)                    |
-| Staging / prod | `oke db generate` → review files → `oke db migrate` on that DB |
-
-<Callout title="Connection pooling is infrastructure, not app code" type="info">
-  One shared Bun.SQL pool (**8** connections) per URL. `dev`/`prod` put **PgDog** in front
-  (`DATABASE_URL` → port `6432`, `pool_size` 20). RLS stamps `reserve` one slot, then `SET LOCAL` in
-  that transaction — a leaked `BEGIN` exhausts checkout.
-</Callout>
-
-**Why PgDog (not PgBouncer as the default).** Transaction pooling fixes the math; naive poolers can leak session state (`SET`, RLS vars, `LISTEN`/`NOTIFY`) across clients. PgDog re-applies those under transaction mode (PgBouncer is fine — not shipped).
-
-**Read replicas later, zero app changes.** Add `role = "replica"` in `pgdog.toml` later: `BEGIN READ ONLY` → replica, failover on promotion. Not wired this round — readiness only.
-
-#### Seeding
-
-`oke db seed` loads `defineSeed` from `src/db/seed/index.ts` — a separate command, never at boot. Not every project has a seed. In `oke dev`, `s` runs the same command. `name` is this app's seed (template or example).
-
-<StoreSeeding />
-
-| env    | `essential` | `dev` | `prod` |
-| ------ | ----------- | ----- | ------ |
-| `dev`  | yes         | yes   | no     |
-| `test` | yes         | no    | no     |
-| `prod` | yes         | no    | yes    |
-
-Outside `test`, exactly one of seed-category `dev` / `prod` runs with `essential`.
-
-**Simple form** — everything inline:
-
-```ts
-import { defineSeed, type Fx } from "okengine";
-import { db } from "../core";
-import { notes } from "../schema.decl";
-
-export default defineSeed({
-  name: "notes",
-  description: "Welcome + sample notes",
-  essential: async (fx: Fx) => {
-    await fx
-      .store(db)
-      .upsert(
-        notes,
-        { id: "welcome" },
-        { id: "welcome", title: "Welcome", body: "…", createdAt: 1 },
-      );
-  },
-  dev: async (fx: Fx) => {
-    await fx
-      .store(db)
-      .upsert(
-        notes,
-        { id: "sample-ideas" },
-        { id: "sample-ideas", title: "Ideas", body: "…", createdAt: 2 },
-      );
-  },
-  // prod: async (fx) => { /* e.g. register a real external webhook URL */ },
-});
-```
-
-**Complex form** — one function per file, compose with arrays (order = run order):
-
-```ts
-import { defineSeed } from "okengine";
-import { seedWelcome } from "./essential/welcome";
-import { seedSamples } from "./dev/samples";
-import { seedWebhook } from "./prod/webhook";
-
-export default defineSeed({
-  name: "notes",
-  description: "Welcome + sample notes",
-  essential: [seedWelcome],
-  dev: [seedSamples],
-  prod: [seedWebhook],
-});
-```
-
-| `upsert` outcome  | When                                       |
-| ----------------- | ------------------------------------------ |
-| `upserted`        | no row matched `matchOn` — insert          |
-| `already-existed` | match found; default leaves it alone       |
-| `changed`         | match found and `{ onExisting: "update" }` |
-
-Default upsert is **insert-if-missing**. Pass `{ onExisting: "update" }` only when this call should also rewrite other columns on a match — opt-in per call, never global.
-
-```ts
-// Safe bootstrap — second seed run leaves the row alone
-await fx
-  .store(db)
-  .upsert(
-    notes,
-    { id: "welcome" },
-    { id: "welcome", title: "Welcome", body: "Your Notes API is ready.", createdAt: 1 },
-  );
-
-// Refresh copy on every seed — match stays; title/body are rewritten
-await fx
-  .store(db)
-  .upsert(
-    notes,
-    { id: "welcome" },
-    { id: "welcome", title: "Welcome (updated)", body: "New bootstrap copy.", createdAt: 1 },
-    { onExisting: "update" },
-  );
-```
-
-Default keeps operator edits safe across re-seeds; `onExisting: "update"` is for seed-owned rows you intentionally overwrite. Schema-wide data fixes still belong in migrations, not seed.
-
-| Env            | Confirm                                               |
-| -------------- | ----------------------------------------------------- |
-| `test`         | none                                                  |
-| `dev` / `prod` | print DB target; type the env name (`--force` for CI) |
-
-```bash
-oke db seed                 # resolve env like other oke db commands
-oke db seed --env dev       # explicit override
-oke db seed --env prod --force
-```
-
-<Callout title="Seed vs migrate">
-  Permanent reference-data corrections go through `oke db generate` → `migrate`, not repeated seed.
-  Optional `drizzle-seed` may be used inside a `dev` function body only — never as the seed system
-  backbone.
-</Callout>
-
-<Callout title="Escape hatch">
-  Hand-written Drizzle in `src/schema.ts` stays supported — if there is nothing to emit, the emit
-  step is skipped and your file is used as-is. Plugins may contribute **whole new tables**;
-  extending an app-owned table with plugin columns is not supported in v1.
-</Callout>
-
-### Access policies — owner, tenant, scope
-
-Row-level security is declared per table as the third argument to `store.schema.table` — the policy list is Drizzle-shaped extras:
-
-```typescript
-export const bookings = store.schema.table(
-  "bookings",
-  {
-    id: field.text().primaryKey(),
-    owner: field.text().notNull(),
-  },
-  [
-    store.schema.policy.gate("member", { for: "select" }),
-    store.schema.policy.owner("owner", { for: "all" }),
-    store.schema.policy.scope("booking:create", { for: "insert" }),
-    store.schema.policy.tenant("tenant_id"),
-  ],
-);
-```
-
-Helpers emit stable names (`gate_member_select`). Raw `store.schema.policy("name", { as, to, for, using, withCheck })` is the escape hatch — predicates use `oke.*`, never `current_setting`. `policy.scope` takes a scope name or the `gate.scope("…")` declaration, so you can reuse the same scope in both the gate and the policy instead of repeating the string.
-
-<Callout title="User-plane fx.store applies RLS">
-  HTTP / resource flows stamp Gate identity (`SET LOCAL ROLE oke_app` + `set_config`). Operator /
-  cron / CDC / signal stay unstamped. Tenancy on: also `oke.tenant()`; tables need `policy.tenant`
-  or `unscoped()`.
-</Callout>
-
-### Per-environment SQL drivers
-
-Same flow code, different backends — configured once in `oke.config.ts`:
-
-| Facet | `dev` / `prod` | `test`   | Runs as                                       |
-| ----- | -------------- | -------- | --------------------------------------------- |
-| `sql` | `postgres`     | `pglite` | Compose / deploy Postgres → in-process PGLite |
-
-Defaults: `postgres` for `dev`/`prod`, `pglite` for `test`. SQLite-family drivers (`sqlite`, `libsql`) are removed. Container images come from the `images` map — change the vendor by changing the pin, never the driver id.
-
-#### Opt-in SQL drivers
-
-| Driver   | Install                                                  | Wire dialect | Choose for                                                |
-| -------- | -------------------------------------------------------- | ------------ | --------------------------------------------------------- |
-| `pglite` | `@electric-sql/pglite` + `@electric-sql/pglite-pgvector` | postgresql   | **required** for `store.sql.test`; also usable in-process |
-
-<Callout title="PGlite is the test SQL driver">
-  `defineConfig` requires `drivers.store.sql.test` to be `pglite` when set. Use `oke test` (sets
-  `OKE_PGLITE_URL=memory://`). Choose PGLite for Postgres correctness in tests — not as a Compose
-  substitute for `oke dev`.
-</Callout>
-
-SQL-backed index driver `pgvector` shares this facet's connection — see [Advanced — composing facets together](#advanced--composing-facets-together).
-
-## KV
-
-<StoreFacetMark facet="kv" />
-
-The key-value facet: short-lived cache and session data behind `fx.store`. One namespace per declaration; drivers swap `memory` ↔ `redis` per environment.
-
-The Console KV band opens a query console for `list`, `get`, `set`, `delete`, and `ttl`. Prettify rewrites commands to call form and indents `set` JSON.
-
-The same band's **Performance** control opens engine telemetry on the `redis` driver. In-process `memory` is unsupported (`KvStatsUnsupported`).
-
-### Quick start
-
-<Steps>
-
-<Step>
-### Declare a namespace
-
-```typescript
-import { store } from "okengine";
-
-export const sessions = store.kv("sessions", { description: "Session cache" });
-// ref → kv:sessions
-```
-
-</Step>
-
-<Step>
-### Read and write in a Flow
-
-```typescript
-do: async ({ userId, data }, fx) => {
-  const kv = fx.store(sessions);
-  await kv.set(`user:${userId}`, data, "30m");
-  return await kv.get(`user:${userId}`);
-},
-```
-
-</Step>
-
-</Steps>
-
-### Handle API
-
-| Call                    | Effect  | Returns          | Notes                                                                    |
-| ----------------------- | ------- | ---------------- | ------------------------------------------------------------------------ |
-| `get(key)`              | `read`  | `unknown`        | Missing keys resolve per driver                                          |
-| `set(key, value, ttl?)` | `write` | `void`           | Values should be JSON-serializable                                       |
-| `delete(key)`           | `write` | `boolean`        | Whether a key was removed                                                |
-| `list(prefix?)`         | `read`  | `string[]`       | Prefix filter; Console browse shows TTL and size                         |
-| `ttlMs(key)`            | `read`  | `number \| null` | Remaining expiry; `null` when the key has none. Console command is `ttl` |
-
-### TTL
-
-Optional third argument on `set` is a duration string: `(\d+)(ms|s|m|h|d)` — e.g. `"30m"`, `"1h"`, `"5000ms"`. Same call — opposite physics under each driver. Console KV browse edits that TTL (empty clears expiry) and can add a key through the same `set` path.
-
-<StoreKvTtl />
-
-**Consequence:** a TTL you rely on in prod does nothing under the `test` `memory` driver. Exercise expiry against `redis` under `oke dev` when lifetime matters.
-
-### Durable KV
-
-Default `store.kv("sessions")` is cache-shaped — a Redis recreate drops keys.
-
-`{ durable: true }` persists that namespace in your SQL database (`oke_kv` JSONB on `DATABASE_URL`). Not a per-key Redis flag, not Flow `durable`, not tier-1 auto-cache.
-
-```typescript
-export const sessions = store.kv("sessions", { description: "Session cache" });
-export const ledger = store.kv("ledger", { durable: true, description: "Idempotency keys" });
-export const drafts = store.kv("drafts", { durable: true, description: "Compose drafts" });
-```
-
-**Consequence:** `oke db seed` into cache Redis looks fine until compose recreates the container — Console Store then shows **No rows.** Seeded namespaces need `{ durable: true }`.
-
-With `gate.auth.tenant` on, KV keys are prefixed `{tenantId}:` (logical keys in `do` stay unprefixed). Missing `fx.tenant.id` throws **OKE1015**. Opt out with `store.kv("sessions", { tenantScoped: false })`.
-
-Gate rates and Signal stay on `REDIS_URL`. Missing `DATABASE_URL` with the postgres driver fails boot: `oke boot: durable store.kv needs DATABASE_URL`.
-
-<Callout title="Not per-key, not Flow durable, not auto-cache">
-  Durable KV is a JSONB table on the same Postgres as `store.sql`. Flow `durable` journals steps.
-  Tier-1 auto-cache is an in-process Map and never reads `store.kv`.
-</Callout>
-
-Driver id stays `redis` for every image below — same `REDIS_URL`, zero Flow changes. Redis is the default because it is the most mature and battle-tested; Valkey and Dragonfly are equally legitimate opt-in pins.
-
-| Image         | Pin                                           | Why pick it                       | License                                                                                                                                           |
-| ------------- | --------------------------------------------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Redis**     | `redis:8-alpine` (default)                    | Most mature / battle-tested       | RSALv2 / SSPLv1 / AGPLv3 (Redis ≥8) — service limits under RSAL/SSPL apply if you offer Redis as a managed service to third parties               |
-| **Valkey**    | `valkey/valkey:8-alpine`                      | BSD fork (Linux Foundation)       | BSD-3-Clause — permissive; no managed-service restriction                                                                                         |
-| **Dragonfly** | `docker.dragonflydb.io/dragonflydb/dragonfly` | Multi-threaded Redis-wire runtime | BSL 1.1 (converts to Apache 2.0 on a published change date) — free for self-hosting; restricts offering Dragonfly as a commercial managed service |
-
-<Callout title="Licenses bite managed-service resellers — read this once" type="warn">
-  RSAL, SSPL, and BSL service restrictions apply when you offer that specific datastore **as a
-  service** to third parties — not when you run it for your own app. Pick for your situation; OKE
-  does not pick a "safer" default for you.
-</Callout>
-
-<Callout title="Dry-run refuses KV writes">
-  `set` and `delete` throw `DryRunWriteIsolationError` during dry-run — the runtime will not risk a
-  double-write against a shared Redis. Reads (`get` / `list`) still run.
-</Callout>
-
-### Per-environment KV drivers
-
-```typescript title="oke.config.ts"
-drivers: {
-  store: {
-    kv: { dev: "redis", test: "memory", prod: "redis" },
-  },
-},
-images: {
-  store: { kv: "redis:8-alpine" },
-  // or: "valkey/valkey:8-alpine"
-  // or: "docker.dragonflydb.io/dragonflydb/dragonfly"
-},
-```
-
-| Facet | `dev` / `prod` | `test`   | Runs as                |
-| ----- | -------------- | -------- | ---------------------- |
-| `kv`  | `redis`        | `memory` | container → in-process |
-
-| Variable           | When                             |
-| ------------------ | -------------------------------- |
-| `REDIS_URL`        | Required for the `redis` driver  |
-| `OKE_STORE_KV_URL` | Override if `REDIS_URL` is unset |
-| `OKE_KV_DRIVER`    | Force a driver id                |
-
-Missing Redis URL fails boot loudly: `oke boot: redis driver needs REDIS_URL`.
-
-## Files
-
-<StoreFacetMark facet="files" />
-
-The blob facet: opaque objects (`Uint8Array` or string) on the same handle as the optional image pipeline. Drivers swap `fs` ↔ `s3` (plus `memory` for tests). The Console Files band is a folder browser — upload, download, delete — not a signed-URL mint.
-
-### Quick start
-
-<Steps>
-
-<Step>
-### Declare a bucket
-
-```typescript
-import { store } from "okengine";
-
-export const uploads = store.files("attachments", {
-  description: "User uploads",
-});
-// ref → files:attachments
-```
-
-</Step>
-
-<Step>
-### Put and get in a Flow
-
-```typescript
-do: async ({ key, body }, fx) => {
-  const files = fx.store(uploads);
-  await files.put(key, body);
-  return await files.get(key); // Uint8Array | null
-},
-```
-
-</Step>
-
-</Steps>
-
-### Blob CRUD — `put` / `get` / `delete` / `list`
-
-| Call             | Effect  | Returns              | Notes                                        |
-| ---------------- | ------- | -------------------- | -------------------------------------------- |
-| `put(key, data)` | `write` | `void`               | `data` is `Uint8Array` or `string`           |
-| `get(key)`       | `read`  | `Uint8Array \| null` | Missing key → `null`                         |
-| `delete(key)`    | `write` | `boolean`            | Whether an object was removed                |
-| `list(prefix?)`  | `read`  | `string[]`           | Prefix filter; Console folder browser source |
-
-```typescript
-const files = fx.store(uploads);
-await files.put("docs/readme.txt", "hello");
-const bytes = await files.get("docs/readme.txt");
-const keys = await files.list("docs/");
-await files.delete("docs/readme.txt");
-```
-
-### Keys
-
-Keys are opaque strings the driver stores as-is. Prefer path-like prefixes (`photos/`, `exports/`).
-
-| Helper / rule                      | Meaning                                                                                                                                                  |
-| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `contentAddressedKey(data)`        | From `okengine/store` — stable sha256 hex of the bytes (dedupe-friendly)                                                                                 |
-| `safeFileObjectKey(name, prefix?)` | URL-safe ASCII key (`file-a1b2c3d4.pdf`). Keep the original name in the catalog.                                                                         |
-| Leading `/` or `..`                | Rejected by the `fs` driver (`Invalid object key`)                                                                                                       |
-| Non-ASCII keys                     | Console warns `non_ascii_key`. Console puts rewrite the key and store `originalName` in `.oke/catalog.json` (and `file_objects` when that table exists). |
-
-### Per-environment Files drivers
-
-```typescript title="oke.config.ts"
-drivers: {
-  store: {
-    files: { dev: "s3", test: "memory", prod: "s3" },
-  },
-},
-images: {
-  store: { files: "rustfs/rustfs:1.0.0-rc.2" },
-},
-```
-
-| Facet   | `dev` / `prod` | `test`   | Runs as                  |
-| ------- | -------------- | -------- | ------------------------ |
-| `files` | `s3`           | `memory` | RustFS / S3 → in-process |
-
-| Variable                      | When                                   |
-| ----------------------------- | -------------------------------------- |
-| `S3_BUCKET`                   | Required bucket for the `s3` driver    |
-| `OKE_STORE_FILES_DB`          | Override bucket name                   |
-| `S3_ENDPOINT` · keys · region | S3-compatible endpoint and credentials |
-| `OKE_FILES_DRIVER`            | Force a driver id                      |
-
-`memory` is the test default. Local `fs` writes under a temp root when no binding `root` is set.
-
-**Known limit:** `fs` is single-host. Under horizontal scale each replica sees its own filesystem (silently inconsistent object views). Boot prints a one-shot warning when `drivers.store.files` is `fs`. Use `s3` for `dev`/`prod` (create-oke templates already do).
-
-<Callout title="Console Files is a folder browser">
-  Inspect the **bucket**. Click a file to preview in a sheet. Uploads use a URL-safe key; the
-  original name lives in the object catalog. Bytes live on `memory`, `fs`, or `s3`.
-</Callout>
-
-### Images — `image` / `putImage`
-
-For photos, use Bun's built-in `Bun.Image` pipeline on the same handle (requires Bun `>=1.4.0`). `putImage` is one write that fans into several keys:
-
-<StoreFilesVariants />
-
-```typescript
-const meta = await fx.store(uploads).image(key).metadata();
-// → { width, height, format }
-
-await fx
-  .store(uploads)
-  .image(key)
-  .resize(400, 400, { fit: "inside" })
-  .webp({ quality: 80 })
-  .put(`thumbs/${key}.webp`);
-
-const result = await fx.store(uploads).putImage("photos/x.jpg", bytes, {
-  variants: {
-    thumb: { resize: [128, 128, { fit: "inside" }], webp: { quality: 80 } },
-    medium: { resize: [800], webp: { quality: 85 } },
-  },
-  placeholder: true, // ThumbHash LQIP data URL
-});
-// variants: photos/x.thumb.webp, photos/x.medium.webp
-```
-
-| Call                                                                    | Effect                        | Notes                                                                                                                                                             |
-| ----------------------------------------------------------------------- | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `image(key\|bytes).metadata()` / `bytes()` / `blob()` / `placeholder()` | `read` when source is a key   | Chain `resize` · `rotate` · `flip` · `flop` · `modulate`, then `jpeg` / `png` / `webp` (portable); `heic` / `avif` fall back to WebP when the OS codec is missing |
-| `image(…).put(outKey)`                                                  | `read` + `write` (key source) | Persist the encoded result                                                                                                                                        |
-| `putImage(key, data, opts?)`                                            | `write`                       | Original + named variants; keys are `{stem}.{variant}.{ext}`                                                                                                      |
-
-#### Image options
-
-| Option        | Default                 | Meaning                                              |
-| ------------- | ----------------------- | ---------------------------------------------------- |
-| `maxPixels`   | **16 MP** (`4096×4096`) | Decode ceiling — raise it or pass `false` to opt out |
-| `autoOrient`  | `true`                  | Apply JPEG EXIF orientation before transforms        |
-| `variants`    | —                       | Named `{ resize?, jpeg\|png\|webp\|… }` specs        |
-| `placeholder` | —                       | When `true`, return a ThumbHash LQIP data URL        |
-
-`putImage` returns `{ key, meta, variants, placeholder? }` — `variants` maps name → object key.
-
-## Index
-
-<StoreFacetMark facet="index" />
-
-The search / similarity facet: vector ANN and opt-in full-text, both behind `store.index`. The handle is a **discriminated union** on `driverId` — vector methods and text methods never mix.
-
-### Quick start
-
-<Steps>
-
-<Step>
-### Declare a vector index
-
-```typescript
-import { store } from "okengine";
-
-export const embeddings = store.index("docs", {
-  dims: 1536,
-  description: "Document embeddings",
-});
-// ref → index:docs
-```
-
-`dims` defaults to `3` at open if omitted — set it to match your embedder.
-
-</Step>
-
-<Step>
-### Upsert and search in a Flow
-
-```typescript
-do: async ({ id, vector, query }, fx) => {
-  const idx = fx.store(embeddings);
-  await idx.upsert(id, vector, { title: "Intro" });
-  return await idx.search(query, 5);
-  // → [{ id, score, meta? }, …]  score = cosine similarity
-},
-```
-
-</Step>
-
-</Steps>
-
-### Handle API — vector vs text
-
-One declaration shape — two search physics. The handle is a **discriminated union** on `driverId`:
-
-<StoreIndexModes />
-
-| Call (both)    | Effect  | Returns               |
-| -------------- | ------- | --------------------- |
-| `upsert(…)`    | `write` | `void`                |
-| `search(…)`    | `read`  | hits / result         |
-| `list(limit?)` | `read`  | documents (id + meta) |
-| `delete(id)`   | `write` | `boolean`             |
-
-<Callout title="Console Index is a search box">
-  Type a phrase to find documents by id and stored meta. A comma-separated vector still runs an ANN
-  probe. Meilisearch uses full-text `q`.
-</Callout>
-
-TypeScript rejects a vector query against a text index (and vice versa) at compile time — never at runtime.
-
-### Vector ANN
-
-| `store.index` id | Shares connection from     | Real ANN via            |
-| ---------------- | -------------------------- | ----------------------- |
-| `memory`         | — (in-process, default)    | Full scan cosine        |
-| `pgvector`       | `postgres` or `pglite` sql | HNSW + `cosineDistance` |
-
-**Consequence:** a configured SQL-backed index that cannot reach its engine — missing peer, missing `vector` extension, wrong sql driver — fails loudly at first use. It never silently falls back to `memory`. A vector whose length ≠ `dims` throws `vector dims X !== index dims Y`.
-
-Pair SQL + index under [Advanced — composing facets together](#advanced--composing-facets-together).
-
-### Full-text search — `meilisearch` (opt-in)
-
-`meilisearch` is a fourth `store.index` backend, opt-in only — `memory` stays the default when `drivers.store.index` is unset. Typo-tolerant, faceted full-text relevance — not cosine similarity.
-
-```typescript
-export const kb = store.index("kb", { description: "Help articles" });
-
-do: async ({ id, doc, q }, fx) => {
-  const idx = fx.store(kb); // driverId: "meilisearch"
-  await idx.upsert(id, { id, ...doc });
-  return await idx.search(q, {
-    topK: 10,
-    filter: "category = guides",
-    facets: ["category"],
-  });
-  // → { hits, facetDistribution? }
-},
-```
-
-| Search option | Meaning                                          |
-| ------------- | ------------------------------------------------ |
-| `topK`        | Max hits (Meilisearch `limit`, default 10)       |
-| `filter`      | Filter expression — attribute must be filterable |
-| `facets`      | Attributes to aggregate into `facetDistribution` |
-
-```typescript title="oke.config.ts"
-drivers: {
-  store: {
-    index: { dev: "meilisearch", test: "memory", prod: "meilisearch" },
-  },
-},
-images: {
-  store: { index: "getmeili/meilisearch:v1.53" },
-},
-```
-
-- **`oke dev` / prod** use the image recipe; the app gets `OKE_STORE_INDEX_URL` + `OKE_STORE_INDEX_KEY` from Compose — a standalone HTTP service, never the shared `sqlUrl`.
-- **Fail-loud:** a configured meilisearch that is unreachable or unhealthy throws `MeilisearchUnavailableError` — never a silent memory fallback.
-- **Not for vectors:** `ai.embed` / `fx.search` stay vector-only; pointing an embed `into` a meilisearch index fails loud (embeddings don't apply).
-
-### Per-environment Index drivers
-
-Unlike KV/Files, an unset `drivers.store.index` map stays **`memory` in every environment** — there is no automatic fallback to `pgvector`. Opt in explicitly:
-
-```typescript title="oke.config.ts"
-drivers: {
-  store: {
-    sql: { dev: "postgres", test: "pglite", prod: "postgres" },
-    index: { dev: "pgvector", test: "memory", prod: "pgvector" },
-  },
-},
-```
-
-| Variable              | When                                              |
-| --------------------- | ------------------------------------------------- |
-| `OKE_INDEX_DRIVER`    | Force a driver id                                 |
-| `OKE_STORE_INDEX_URL` | Required for `meilisearch`                        |
-| `OKE_STORE_INDEX_KEY` | Meilisearch API key (`MEILI_MASTER_KEY` fallback) |
-
-### With AI embeddings
-
-`ai.embed` writes into a vector `store.index`; Flows search it with `fx.search` (or `fx.store(index).search`). See [AI](/docs/elements/ai) — this path is vector-only and will not target meilisearch.
-
-## Advanced — composing facets together
-
-Facets are independent declarations. A Flow may touch several in one `do` — for example store a files key on a SQL row, or `upsert` into an index after a SQL write. There is no special sync API: `store.resource` `search:` is SQL substring match, not meilisearch.
-
-One real coupling: `pgvector` shares the sql facet's already-open connection, so configure the pair together:
-
-```typescript title="oke.config.ts"
-drivers: {
-  store: {
-    sql: { dev: "postgres", test: "pglite", prod: "postgres" },
-    index: { dev: "pgvector", test: "memory", prod: "pgvector" },
-  },
-},
-```
-
-The full per-environment map looks like this:
-
-```typescript title="oke.config.ts"
-drivers: {
-  store: {
-    sql:   { dev: "postgres", test: "pglite", prod: "postgres" },
-    kv:    { dev: "redis",    test: "memory", prod: "redis" },
-    files: { dev: "s3",       test: "memory", prod: "s3" },
-  },
-},
-```
-
-Container images come from the `images` map — change the vendor by changing the pin, never the driver id.
-
-## Advanced — with other elements
-
-Columns tagged `.pii()` or `.sensitive()` are masked at the store boundary — flows, logs, and the Console see a mask, not the value. Revealing cleartext PII requires an explicit `pii:reveal` gate on the flow, so access is a permission, not a convention.
-
-Optional `description` on a store (and `.describe("…")` on fields) becomes its human title in operator tools. Single-table `reads` / `writes` in the Manifest power cache invalidation and that same PII masking — see the Callout under [Querying by hand](#querying-by-hand).
-
-## Troubleshooting
-
-<Accordions>
-
-<Accordion title="Unable to resolve table name from value">
-  A `store.schema.table` column named `name` used to shadow the SQL table name. Inserts and selects
-  now resolve it from the declaration. Keep the `name` column.
-</Accordion>
-
-<Accordion title="OKE1101 — missing table in prod">
-  Schema DDL never runs automatically in `prod`. Under `oke dev`, `db.autoPush` (default `true`)
-  runs `oke db push`. For production use `oke db generate` + `oke db migrate`.
-</Accordion>
-
-<Accordion title="oke db push: missing_hints">
-  New tables are created automatically. Push only manages `public` — it will not drop schema `oke`
-  (RLS helpers) or `oke_console`. Remaining `missing_hints` are destructive (drop a non-empty public
-  table, type change). Review with `oke db generate`.
-</Accordion>
-
-<Accordion title="I need a join — with: is not supported">
-  `fx.store` is one table per call by design. Read each table separately and compose in the flow (or
-  extract a shared flow and `fx.call` it). Every table then appears explicitly in the Manifest's
-  effect graph — which is what powers cache invalidation and PII masking.
-</Accordion>
-
-<Accordion title="Pagination shows duplicates when rows are inserted">
-  You are on offset paging. Switch `list` to keyset by setting `cursor` columns with a stable order
-  (e.g. `[createdAt, id]`) — the page boundary becomes a row predicate, not a row count.
-</Accordion>
-
-<Accordion title="meta.total is slow on a big table">
-  `count: "exact"` runs `COUNT(*)` per page. Set `count: "none"` in the `list` options to skip it,
-  or use keyset mode where totals are rarely needed.
-</Accordion>
-
-<Accordion title="List data is { items, count } instead of an array">
-Success already wraps `{ data, error: null }`. Returning a page object from `do` nests the pager inside `data`. Prefer `out: z.array(Item)` and `return fx.json.withQuery(rows, input)`. Any other declared `out` is still valid.
-</Accordion>
-
-<Accordion title="KV TTL never expires in tests">
-  The `test` default is `memory`, which ignores TTL on `set`. Under `oke dev`, KV is `redis` by
-  default — use that when you need real expiry.
-</Accordion>
-
-<Accordion title="oke boot: redis / meilisearch / S3 URL missing">
-  Driver-backed facets fail boot when their URL is absent — Redis needs `REDIS_URL`, meilisearch
-  needs `OKE_STORE_INDEX_URL`, S3 needs `S3_BUCKET`. `oke dev` writes these into the Compose env.
-</Accordion>
-
-<Accordion title="vector dims X !== index dims Y">
-  The vector length must match `store.index(…, {dims})` (runtime default `3` if unset). Align `dims`
-  with your embedder, or fix the vector you pass to `upsert` / `search`.
-</Accordion>
-
-<Accordion title="Index stays on memory under oke dev">
-  Unlike KV/Files, unset `drivers.store.index` does **not** promote to `pgvector` in `dev` — it
-  stays `memory`. Set the map explicitly (and pair SQL for `pgvector`).
-</Accordion>
-
-<Accordion title="Console warns Non-ASCII object key">
-  `fx.store(files).put` stores the key as-is. Console uploads mint an ASCII key and keep the
-  original name in `.oke/catalog.json`. Re-upload to rewrite an existing object.
-</Accordion>
-
-<Accordion title="oke dev skipped the seed prompt">
-  `.oke/state.json` stores `seededAt` plus this app's `defineSeed({name})` — notes vs keel are
-  different ids. A new name re-asks. Clear those keys to prompt again.
-</Accordion>
-
-<Accordion title="Console KV shows No rows after oke db seed">
-Default `store.kv` is cache Redis with no AOF — a recreate drops keys. SQL seed still looks full. Mark seeded namespaces `{ durable: true }` so they live in `oke_kv`, then restart and seed again.
-</Accordion>
-
-</Accordions>
-
-## Learn more
-
-- [Project structure](/docs/get-started/project-structure) — `list.ts` + `http.get()` is `GET /notes` named `notes.list`
-- [Flow](/docs/elements/flow) — the `fx.store` session inside `do`
-- [AI](/docs/elements/ai) — `ai.embed` into a vector `store.index`, searched via `fx.search`
-- [Gate](/docs/elements/gate) — `pii:reveal`, `gate.auth.tenant`, and `oke.tenant()`
-- [CLI Reference](/docs/reference/cli) — `oke db push` · `generate` · `migrate`
-- [Configuration](/docs/reference/configuration) — `drivers.store` maps and `images` pins
-- [Environment variables](/docs/reference/environment-variables) — Redis · S3 · meilisearch URLs
-
-## Next
-
-<Cards>
-  <Card title="Clock" description="Continue to Clock." href="/docs/elements/clock" />
-  <Card
-    title="Introduction"
-    description="Eight elements overview."
-    href="/docs/get-started/introduction"
-  />
-</Cards>