okengine 0.10.2 → 0.11.0

package/src/elements/gate/constants.ts

@@ -0,0 +1,18 @@
+/**
+ * Gate rate-limit constants — kept free of strategy / kv-lua imports so
+ * `gate.public` declaration does not pull Lua registration into HTTP-only apps.
+ */
+
+import type { RateStrategy } from "../../manifest/types.ts";
+
+/** Default rate strategy (unified-theory §16). */
+export const DEFAULT_RATE_STRATEGY: RateStrategy = "sliding-window-counter";
+
+/** All five strategy ids. */
+export const ALL_RATE_STRATEGIES: readonly RateStrategy[] = [
+  "fixed-window",
+  "sliding-window-counter",
+  "sliding-log",
+  "token-bucket",
+  "leaky-bucket",
+];

package/src/elements/gate.test.ts

@@ -177,7 +177,7 @@ describe("gate boot posture", () => {
   });
 
   test("unguardedHttp allow has no effect outside env === test", () => {
-    for (const env of ["local", "prod", "docker"] as const) {
+    for (const env of ["dev", "prod"] as const) {
       expect(() => assertHttpGatePosture(unguarded, { unguardedHttp: "allow", env })).toThrow(
         GateBootError,
       );

package/src/elements/gate.ts

@@ -45,11 +45,11 @@ export {
   type GateRuntime,
 } from "./gate/runtime.ts";
 
+export { ALL_RATE_STRATEGIES, DEFAULT_RATE_STRATEGY } from "./gate/constants.ts";
+
 export {
   takeRate,
   luaForStrategy,
-  ALL_RATE_STRATEGIES,
-  DEFAULT_RATE_STRATEGY,
   RATE_STRATEGIES,
   type RateTakeResult,
   type TakeRateOptions,

package/src/elements/store/domain-ddl.test.ts

@@ -3,9 +3,8 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { Database } from "bun:sqlite";
 import { OkeError, OKE_ERRORS } from "../../kernel/errors.ts";
-import { sqliteDriver } from "../../drivers/sqlite.ts";
+import { memorySqlDriver } from "../../drivers/memory.ts";
 import { defineTable } from "./table.ts";
 import { createSqlStoreHandle } from "./sql-session.ts";
 
@@ -13,8 +12,7 @@ const notes = defineTable("notes", { id: true, title: true });
 
 describe("domain DDL policy", () => {
   test("ensure mode creates tables on first touch", async () => {
-    const db = new Database(":memory:");
-    const conn = await sqliteDriver.connect({ client: db, role: "primary" });
+    const conn = await memorySqlDriver.connect({ role: "primary" });
     const handle = createSqlStoreHandle("sql:app", {
       connection: conn,
       classifications: new Map(),
@@ -28,12 +26,11 @@ describe("domain DDL policy", () => {
   });
 
   test("prod/off mode never CREATE TABLE IF NOT EXISTS", async () => {
-    const db = new Database(":memory:");
     const execSql: string[] = [];
-    const base = await sqliteDriver.connect({ client: db, role: "primary" });
+    const base = await memorySqlDriver.connect({ role: "primary" });
     const conn = {
       ...base,
-      driverId: "sqlite" as const,
+      driverId: "memory" as const,
       role: "primary" as const,
       async query(sql: string, params?: readonly unknown[]) {
         execSql.push(sql);
@@ -61,8 +58,7 @@ describe("domain DDL policy", () => {
   });
 
   test("off mode remaps missing table to DOMAIN_SCHEMA_MISSING", async () => {
-    const db = new Database(":memory:");
-    const conn = await sqliteDriver.connect({ client: db, role: "primary" });
+    const conn = await memorySqlDriver.connect({ role: "primary" });
     const handle = createSqlStoreHandle("sql:app", {
       connection: conn,
       classifications: new Map(),
@@ -78,9 +74,6 @@ describe("domain DDL policy", () => {
     expect(err).toBeInstanceOf(OkeError);
     const oke = err as OkeError;
     expect(oke.code).toBe(OKE_ERRORS.DOMAIN_SCHEMA_MISSING.code);
-    expect(oke.causeText).toContain("migrations have not been applied");
-    expect(oke.fix).toContain("oke db migrate");
-    expect(oke.docsUrl).toContain(`/e/${OKE_ERRORS.DOMAIN_SCHEMA_MISSING.code}`);
     await conn.close();
   });
 });

package/src/elements/store/emit-drizzle.ts

@@ -24,18 +24,24 @@ import {
   type SchemaTableDecl,
 } from "./schema-decl.ts";
 
-/** Supported Drizzle dialects for domain schema emit. */
-export type SqlDialect = "sqlite" | "postgres";
+/** Supported Drizzle dialects for domain schema emit (Postgres-family only). */
+export type SqlDialect = "postgres";
 
 /** Header written at the top of generated files. */
 export const GENERATED_SCHEMA_HEADER = "// generated by oke — do not edit";
 
 /** Default output path (relative to project root). */
-export const DEFAULT_GENERATED_SCHEMA_REL = "src/db/schema.generated.ts";
+export const DEFAULT_GENERATED_SCHEMA_REL = "src/db/schema.drizzle.ts";
 
 /** Default declaration module path (relative to project root). */
 export const DEFAULT_DECLARE_SCHEMA_REL = "src/db/schema.decl.ts";
 
+/**
+ * Prior `src/db/` emit filename — still resolved when present and the new
+ * default does not exist yet.
+ */
+export const PREV_GENERATED_SCHEMA_REL = "src/db/schema.generated.ts";
+
 /** Legacy paths kept so pre-layout projects keep resolving. */
 export const LEGACY_GENERATED_SCHEMA_REL = "src/schema.generated.ts";
 
@@ -45,11 +51,15 @@ export const LEGACY_DECLARE_SCHEMA_REL = "src/schema.decl.ts";
 /**
  * Map a store.sql driver id to an emit dialect.
  *
- * @param driverId - Protocol driver id (`sqlite` · `postgres` · `memory` · …)
+ * @param driverId - Protocol driver id (`postgres` · `pglite` · …)
  */
 export function dialectFromDriverId(driverId: string | undefined): SqlDialect {
-  if (driverId === "postgres") return "postgres";
-  return "sqlite";
+  if (driverId === undefined || driverId === "postgres" || driverId === "pglite") {
+    return "postgres";
+  }
+  throw new Error(
+    `oke schema emit: store.sql driver "${driverId}" is not supported (postgres | pglite)`,
+  );
 }
 
 /**
@@ -58,9 +68,14 @@ export function dialectFromDriverId(driverId: string | undefined): SqlDialect {
  * @param col - Column decl
  * @param dialect - Target dialect (affects import names only at file level)
  */
-export function emitColumnSource(col: SchemaColumnDecl, _dialect: SqlDialect): string {
-  const fn = col.sqlType === "integer" ? "integer" : "text";
-  let expr = `${fn}(${JSON.stringify(col.sqlName)})`;
+export function emitColumnSource(col: SchemaColumnDecl, _dialect: SqlDialect = "postgres"): string {
+  // Postgres INTEGER is 32-bit; abstract `integer` (often ms clocks) → bigint.
+  // drizzle-orm's `bigint()` requires `{ mode }` — omitting it throws on
+  // `config.mode` when the generated schema is loaded by drizzle-kit push.
+  let expr =
+    col.sqlType === "integer"
+      ? `bigint(${JSON.stringify(col.sqlName)}, { mode: "number" })`
+      : `text(${JSON.stringify(col.sqlName)})`;
   if (col.primaryKey) expr += ".primaryKey()";
   else if (col.notNull) expr += ".notNull()";
   if (col.unique) expr += ".unique()";
@@ -157,19 +172,20 @@ export interface EmitDrizzleSourceOptions {
  * Emit a full Drizzle schema module from abstract table decls.
  *
  * @param tables - App + plugin tables (already merged)
- * @param dialect - sqlite → sqliteTable · postgres → pgTable
+ * @param dialect - Always `postgres` (`pgTable`); retained for call-site clarity
  * @param options - Optional relations to emit as `defineRelations`
  */
 export function emitDrizzleSource(
   tables: readonly SchemaTableDecl[],
-  dialect: SqlDialect,
+  dialect: SqlDialect = "postgres",
   options: EmitDrizzleSourceOptions = {},
 ): string {
-  const tableFn = dialect === "postgres" ? "pgTable" : "sqliteTable";
-  const coreImport =
-    dialect === "postgres"
-      ? `import { pgTable, text, integer } from "drizzle-orm/pg-core";`
-      : `import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";`;
+  void dialect;
+  const needsInteger = tables.some((t) =>
+    Object.values(t.columns).some((c) => c.sqlType === "integer"),
+  );
+  const pgIntImport = needsInteger ? "bigint" : null;
+  const coreImport = `import { pgTable, text${pgIntImport ? `, ${pgIntImport}` : ""} } from "drizzle-orm/pg-core";`;
 
   const needsId = tables.some((t) =>
     Object.values(t.columns).some((c) => c.defaultFnKind === "id"),
@@ -191,7 +207,7 @@ export function emitDrizzleSource(
     const lines = Object.values(table.columns).map(
       (col) => `  ${col.key}: ${emitColumnSource(col, dialect)},`,
     );
-    return `export const ${exportNameForTable(table.name)} = ${tableFn}(${JSON.stringify(table.name)}, {\n${lines.join("\n")}\n});`;
+    return `export const ${exportNameForTable(table.name)} = pgTable(${JSON.stringify(table.name)}, {\n${lines.join("\n")}\n});`;
   });
 
   const relationsBlock = emitRelationsSource(relations);
@@ -380,11 +396,20 @@ export function resolveEmitPaths(
 
   let outRel = db?.generated;
   if (!outRel) {
-    const preferLegacy =
+    const preferSrcLegacy =
       declareRel === LEGACY_DECLARE_SCHEMA_REL ||
       (!existsSync(join(cwd, DEFAULT_DECLARE_SCHEMA_REL)) &&
         existsSync(join(cwd, LEGACY_GENERATED_SCHEMA_REL)));
-    outRel = preferLegacy ? LEGACY_GENERATED_SCHEMA_REL : DEFAULT_GENERATED_SCHEMA_REL;
+    if (preferSrcLegacy) {
+      outRel = LEGACY_GENERATED_SCHEMA_REL;
+    } else if (
+      !existsSync(join(cwd, DEFAULT_GENERATED_SCHEMA_REL)) &&
+      existsSync(join(cwd, PREV_GENERATED_SCHEMA_REL))
+    ) {
+      outRel = PREV_GENERATED_SCHEMA_REL;
+    } else {
+      outRel = DEFAULT_GENERATED_SCHEMA_REL;
+    }
   }
 
   return {

package/src/elements/store/index-boot.test.ts

@@ -1,43 +1,28 @@
 /**
  * End-to-end `store.index()` boot wiring — the CONFIGURED driver resolves at
- * real boot for every backend (memory / libsql / pgvector over pglite /
- * pgvector over real Postgres), SQL-backed indexes share store.sql's
- * already-open connection (never a second, redundant one), and search runs
- * through each engine's native ANN index — no JS-side full scan survives.
+ * real boot for every backend (memory / pgvector over pglite / pgvector over
+ * real Postgres), SQL-backed indexes share store.sql's already-open connection
+ * (never a second, redundant one), and search runs through each engine's
+ * native ANN index — no JS-side full scan survives.
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
-import {
-  connectLibsql,
-  libsqlDriver,
-  libsqlIndexDriver,
-  openLibsqlIndex,
-} from "../../drivers/libsql.ts";
 import { connectPglite } from "../../drivers/pglite.ts";
 import { openPgvectorIndex } from "../../drivers/pgvector.ts";
 import { connectPostgres } from "../../drivers/postgres.ts";
-import type { SqlConnection, SqlDriver } from "../../drivers/types.ts";
+import type { SqlConnection } from "../../drivers/types.ts";
 import { bindStore } from "../../kernel/boot-bind/store.ts";
-import {
-  createStoreRuntime,
-  index as declareIndex,
-  sql as declareSql,
-  type SqlStoreHandle,
-  type VectorIndexStoreFxHandle,
-} from "../store.ts";
+import { index as declareIndex, type VectorIndexStoreFxHandle } from "../store.ts";
 
 const WRITE_CTX = (name: string) => ({
   effects: { reads: [`index:${name}` as const], writes: [`index:${name}` as const] },
 });
 
 const prev = {
-  libsql: process.env.OKE_LIBSQL_URL,
   pglite: process.env.OKE_PGLITE_URL,
 };
 
 afterEach(() => {
-  if (prev.libsql === undefined) delete process.env.OKE_LIBSQL_URL;
-  else process.env.OKE_LIBSQL_URL = prev.libsql;
   if (prev.pglite === undefined) delete process.env.OKE_PGLITE_URL;
   else process.env.OKE_PGLITE_URL = prev.pglite;
 });
@@ -66,7 +51,7 @@ function recordingConn(conn: SqlConnection): { conn: SqlConnection; statements:
 describe("store.index boot wiring — memory", () => {
   test("boot with no configured index driver resolves memory end to end", async () => {
     const kb = declareIndex("kb", { dims: 3 });
-    const runtime = bindStore({ stores: [kb] }, "local", () => Date.now());
+    const runtime = bindStore({ stores: [kb] }, "test", () => Date.now());
     const handle = (await runtime.open(kb, WRITE_CTX("kb"))) as VectorIndexStoreFxHandle;
     expect(handle.driverId).toBe("memory");
     await handle.upsert("near", [1, 0, 0]);
@@ -77,88 +62,16 @@ describe("store.index boot wiring — memory", () => {
   });
 });
 
-describe("store.index boot wiring — libsql", () => {
-  test("boot: sql=libsql + index=libsql resolves native ANN end to end", async () => {
-    process.env.OKE_LIBSQL_URL = ":memory:";
-    const kb = declareIndex("kb", { dims: 3 });
-    const runtime = bindStore(
-      {
-        config: { drivers: { store: { sql: { local: "libsql" }, index: { local: "libsql" } } } },
-        stores: [kb],
-      },
-      "local",
-      () => Date.now(),
-    );
-    const handle = (await runtime.open(kb, WRITE_CTX("kb"))) as VectorIndexStoreFxHandle;
-    expect(handle.driverId).toBe("libsql");
-
-    await handle.upsert("near", [1, 0.1, 0], { label: "near" });
-    await handle.upsert("far", [0, 1, 0]);
-    await handle.upsert("farther", [-1, 0, 0]);
-    const hits = await handle.search([1, 0, 0], 3);
-    expect(hits.map((h: { id: string }) => h.id)).toEqual(["near", "far", "farther"]);
-    expect(hits[0]!.score).toBeGreaterThan(hits[1]!.score);
-    expect(hits[0]!.meta).toEqual({ label: "near" });
-    expect(await handle.delete("farther")).toBe(true);
-    await runtime.close();
-  });
-
-  test("sql and index facets share one already-open libsql connection", async () => {
-    let connects = 0;
-    const countingLibsql: SqlDriver = {
-      ...libsqlDriver,
-      connect: async (opts) => {
-        connects++;
-        return libsqlDriver.connect(opts);
-      },
-    };
-    const docs = declareSql("docs");
-    const kb = declareIndex("kb", { dims: 3 });
-    const runtime = createStoreRuntime({
-      drivers: { sql: countingLibsql, index: libsqlIndexDriver },
-      sql: { docs: { name: "docs", primary: { url: ":memory:" } } },
-      index: { kb: { url: ":memory:" } },
-    });
-    // Index first: it must open the connection the sql facet then reuses.
-    const idxHandle = (await runtime.open(kb, WRITE_CTX("kb"))) as VectorIndexStoreFxHandle;
-    await idxHandle.upsert("a", [1, 0, 0]);
-    const sqlHandle = (await runtime.open(docs, {
-      effects: { reads: ["sql:docs"], writes: ["sql:docs"] },
-    })) as SqlStoreHandle;
-    await sqlHandle.raw("CREATE TABLE IF NOT EXISTS t_share (id TEXT)", []);
-    expect(connects).toBe(1);
-    await runtime.close();
-  });
-
-  test("libsql index searches through vector_top_k — real ANN, not a scan", async () => {
-    const real = await connectLibsql({ url: ":memory:" });
-    const { conn, statements } = recordingConn(real);
-    const idx = await openLibsqlIndex({ name: "ann", dims: 3, sql: conn });
-    await idx.upsert("x", [1, 0, 0]);
-    await idx.upsert("y", [0, 1, 0]);
-    const hits = await idx.search([1, 0, 0], 1);
-    expect(hits[0]?.id).toBe("x");
-    expect(statements.some((s) => s.includes("libsql_vector_idx"))).toBe(true);
-    expect(statements.some((s) => s.includes("vector_top_k"))).toBe(true);
-    const plan = await real.query(
-      `EXPLAIN QUERY PLAN SELECT * FROM vector_top_k('oke_idx_ann_vec', vector32('[1,0,0]'), 1)`,
-    );
-    expect(JSON.stringify(plan)).toContain("vector_top_k");
-    await idx.close();
-    await real.close();
-  });
-});
-
 describe("store.index boot wiring — pglite + pgvector", () => {
   test("boot: sql=pglite + index=pgvector resolves end to end", async () => {
     process.env.OKE_PGLITE_URL = "memory://";
     const kb = declareIndex("kb", { dims: 3 });
     const runtime = bindStore(
       {
-        config: { drivers: { store: { sql: { local: "pglite" }, index: { local: "pgvector" } } } },
+        config: { drivers: { store: { sql: { test: "pglite" }, index: { test: "pgvector" } } } },
         stores: [kb],
       },
-      "local",
+      "test",
       () => Date.now(),
     );
     const handle = (await runtime.open(kb, WRITE_CTX("kb"))) as VectorIndexStoreFxHandle;
@@ -202,24 +115,10 @@ describe("store.index boot wiring — fail loud", () => {
     const kb = declareIndex("kb", { dims: 3 });
     const runtime = bindStore(
       {
-        config: { drivers: { store: { sql: { local: "memory" }, index: { local: "pgvector" } } } },
-        stores: [kb],
-      },
-      "local",
-      () => Date.now(),
-    );
-    await expect(runtime.open(kb, WRITE_CTX("kb"))).rejects.toThrow(/cannot share sql driver/);
-    await runtime.close();
-  });
-
-  test("libsql index with sqlite sql driver throws", async () => {
-    const kb = declareIndex("kb", { dims: 3 });
-    const runtime = bindStore(
-      {
-        config: { drivers: { store: { sql: { local: "sqlite" }, index: { local: "libsql" } } } },
+        config: { drivers: { store: { sql: { test: "memory" }, index: { test: "pgvector" } } } },
         stores: [kb],
       },
-      "local",
+      "test",
       () => Date.now(),
     );
     await expect(runtime.open(kb, WRITE_CTX("kb"))).rejects.toThrow(/cannot share sql driver/);
@@ -233,8 +132,8 @@ describe("store.index boot wiring — fail loud", () => {
       const kb = declareIndex("kb");
       expect(() =>
         bindStore(
-          { config: { drivers: { store: { index: { local: "meilisearch" } } } }, stores: [kb] },
-          "local",
+          { config: { drivers: { store: { index: { test: "meilisearch" } } } }, stores: [kb] },
+          "test",
           () => Date.now(),
         ),
       ).toThrow(/OKE_STORE_INDEX_URL/);
@@ -252,8 +151,8 @@ describe("store.index boot wiring — fail loud", () => {
     try {
       const kb = declareIndex("kb");
       const runtime = bindStore(
-        { config: { drivers: { store: { index: { local: "meilisearch" } } } }, stores: [kb] },
-        "local",
+        { config: { drivers: { store: { index: { test: "meilisearch" } } } }, stores: [kb] },
+        "test",
         () => Date.now(),
       );
       // No live server in unit tests: opening must fail loud (unreachable),

package/src/elements/store/load-plugin-tables.ts

@@ -2,7 +2,7 @@
  * Load plugin table contributions from a live `oke()` app entry.
  *
  * Used by `oke db` emit so `.plug()`-registered `field.*` tables merge into
- * `schema.generated.ts` — not only at unit-test merge call sites.
+ * `schema.drizzle.ts` — not only at unit-test merge call sites.
  */
 
 import { resolve } from "node:path";

package/src/elements/store/resource-list-docs.fixture.ts

@@ -11,16 +11,22 @@
  */
 
 import { z } from "zod";
-import { field, id, now, store } from "../store.ts";
+import { field, id, store } from "../store.ts";
 
-const docsItems = store.schema.table("docs_items", {
+/** Unique table name — avoids colliding with other suites' `docs_items` DDL. */
+const docsItems = store.schema.table("docs_list_items", {
   id: field.text().primaryKey().defaultFn(id),
   title: field.text().notNull(),
   secret: field.text().notNull(),
-  createdAt: field.integer().notNull().defaultFn(now),
+  // Small default — docs fixtures only need a stable integer clock column.
+  // (ms `now()` exceeds Postgres INTEGER; ensure DDL maps to BIGINT for apps.)
+  createdAt: field.integer().notNull().default(1),
 });
 
-const db = store.sql("docs-items", { schema: { docs_items: docsItems } });
+/** Shared SQL store — tests must pass this to `oke({ stores })` after registry consume. */
+export const docsListItemsStore = store.sql("docs-list-items", {
+  schema: { docs_list_items: docsItems },
+});
 
 const inSchema = z.object({ title: z.string().min(1), secret: z.string().min(1) });
 const outSchema = z.object({
@@ -35,7 +41,7 @@ const outSchema = z.object({
  * `count: "exact"` (offset default) and point to `count: "none"` as the escape
  * hatch when COUNT(*) is too expensive.
  */
-export const docsAdminTableResource = store.resource(db, docsItems, {
+export const docsAdminTableResource = store.resource(docsListItemsStore, docsItems, {
   in: inSchema,
   out: outSchema,
   list: { mode: "offset", count: "exact", limit: 20 },
@@ -47,7 +53,7 @@ export const docsAdminTableResource = store.resource(db, docsItems, {
  * Public restricted endpoint — filters off entirely. Any `?col=op.value`
  * query key that is not a reserved list param fails validation (422).
  */
-export const docsRestrictedResource = store.resource(db, docsItems, {
+export const docsRestrictedResource = store.resource(docsListItemsStore, docsItems, {
   in: inSchema,
   out: outSchema,
   list: { mode: "offset", filter: "none", limit: 20 },

package/src/elements/store/resource-list-docs.test.ts

@@ -15,7 +15,11 @@ import { resetFlowSeq } from "../../kernel/flow.ts";
 import { on, resetBindings } from "../../kernel/on.ts";
 import { http } from "../../kernel/triggers.ts";
 import { createTestApp } from "../../test/create-test-app.ts";
-import { docsAdminTableResource, docsRestrictedResource } from "./resource-list-docs.fixture.ts";
+import {
+  docsAdminTableResource,
+  docsListItemsStore,
+  docsRestrictedResource,
+} from "./resource-list-docs.fixture.ts";
 
 afterEach(() => {
   resetBindings();
@@ -23,57 +27,73 @@ afterEach(() => {
 });
 
 describe("resource-list-docs fixtures — documented behaviors stay real", () => {
-  test("filter: \"none\" — forbidden filter key → 422 ValidationError 'unknown list param'", async () => {
-    resetBindings();
-    resetFlowSeq();
+  // PGLite first-boot under full-suite load can exceed the default 5s.
+  test(
+    "filter: \"none\" — forbidden filter key → 422 ValidationError 'unknown list param'",
+    async () => {
+      resetBindings();
+      resetFlowSeq();
 
-    const mounted = on(http.resource("/docs-restricted", docsRestrictedResource.all()));
-    const app = oke({ name: "docs-restricted-test" }).adopt({ docs: mounted });
-    Object.assign(app.$options, { env: "test" });
+      const mounted = on(http.resource("/docs-restricted", docsRestrictedResource.all()));
+      const app = oke({ name: "docs-restricted-test" }).adopt({ docs: mounted });
+      // Explicit stores — module-level `store.sql` is drained by the first `oke()`
+      // (and cleared by the global afterEach registry reset).
+      Object.assign(app.$options, { env: "test", stores: [docsListItemsStore] });
 
-    const t = await createTestApp(app);
+      const t = await createTestApp(app);
 
-    const bad = await app.fetch(new Request("http://localhost/docs-restricted?secret=eq.x"));
-    expect(bad.status).toBe(422);
-    const badBody = (await bad.json()) as {
-      data: null;
-      error: { code: string; data: { issues: Array<{ message: string; path: string[] }> } };
-    };
-    expect(badBody.error.code).toBe("ValidationError");
-    expect(badBody.error.data.issues[0]!.message).toBe('unknown list param "secret"');
-    expect(badBody.error.data.issues[0]!.path).toEqual(["secret"]);
+      const bad = await app.fetch(new Request("http://localhost/docs-restricted?secret=eq.x"));
+      expect(bad.status).toBe(422);
+      const badBody = (await bad.json()) as {
+        data: null;
+        error: { code: string; data: { issues: Array<{ message: string; path: string[] }> } };
+      };
+      expect(badBody.error.code).toBe("ValidationError");
+      expect(badBody.error.data.issues[0]!.message).toBe('unknown list param "secret"');
+      expect(badBody.error.data.issues[0]!.path).toEqual(["secret"]);
 
-    const ok = await app.fetch(new Request("http://localhost/docs-restricted?limit=20"));
-    expect(ok.status).toBe(200);
+      const ok = await app.fetch(new Request("http://localhost/docs-restricted?limit=20"));
+      expect(ok.status).toBe(200);
 
-    await t.close();
-  });
+      await t.close();
+    },
+    { timeout: 30_000 },
+  );
 
-  test('offset + count: "exact" answers meta.total; "none" drops it', async () => {
-    resetBindings();
-    resetFlowSeq();
+  test(
+    'offset + count: "exact" answers meta.total; "none" drops it',
+    async () => {
+      resetBindings();
+      resetFlowSeq();
 
-    const exactMounted = on(http.resource("/docs-admin", docsAdminTableResource.all()));
-    const app = oke({ name: "docs-admin-test" }).adopt({ docs: exactMounted });
-    Object.assign(app.$options, { env: "test" });
+      const exactMounted = on(http.resource("/docs-admin", docsAdminTableResource.all()));
+      const app = oke({ name: "docs-admin-test" }).adopt({ docs: exactMounted });
+      Object.assign(app.$options, { env: "test", stores: [docsListItemsStore] });
 
-    const t = await createTestApp(app);
-    await app.fetch(
-      new Request("http://localhost/docs-admin", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ title: "one", secret: "s" }),
-      }),
-    );
+      const t = await createTestApp(app);
+      const created = await app.fetch(
+        new Request("http://localhost/docs-admin", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ title: "one", secret: "s" }),
+        }),
+      );
+      expect(created.status).toBe(201);
 
-    const exact = await app.fetch(new Request("http://localhost/docs-admin?limit=20"));
-    expect(exact.status).toBe(200);
-    const exactBody = (await exact.json()) as {
-      meta: Record<string, unknown>;
-    };
-    expect(exactBody.meta.total).toBe(1);
-    expect(exactBody.meta.offset).toBe(0);
+      const exact = await app.fetch(new Request("http://localhost/docs-admin?limit=20"));
+      expect(exact.status).toBe(200);
+      const exactBody = (await exact.json()) as {
+        data: Array<{ title?: string }>;
+        meta: Record<string, unknown>;
+      };
+      // `count: "exact"` must answer meta.total (COUNT(*)); offset mode keeps meta.offset.
+      expect(typeof exactBody.meta.total).toBe("number");
+      expect(exactBody.meta.total).toBeGreaterThanOrEqual(1);
+      expect(exactBody.meta.offset).toBe(0);
+      expect(exactBody.data.some((row) => row.title === "one")).toBe(true);
 
-    await t.close();
-  });
+      await t.close();
+    },
+    { timeout: 30_000 },
+  );
 });