@cosmicdrift/kumiko-framework 0.197.1 → 0.199.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.197.1",
+  "version": "0.199.0",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -186,7 +186,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-types": "0.197.1",
+    "@cosmicdrift/kumiko-types": "0.199.0",
     "bullmq": "^5.76.7",
     "bun-types": "^1.3.13",
     "hono": "^4.13.1",
@@ -202,7 +202,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.197.1",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.199.0",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },

package/src/api/__tests__/batch.integration.test.ts

@@ -407,7 +407,7 @@ describe("POST /api/batch", () => {
 
   test("idempotency: corrupted cache entry is treated as miss and re-runs", async () => {
     const requestId = "batch-rid-corrupt";
-    const cacheKey = `${RedisKeys.idempotency}${requestId}`;
+    const cacheKey = `${RedisKeys.idempotency}${admin.tenantId}:${admin.id}:${requestId}`;
 
     // Prove key-coupling first: seed a well-formed cached entry under the
     // exact manually-built key and confirm the batch short-circuits on it

package/src/api/__tests__/server-boot-guards.test.ts

@@ -1,6 +1,6 @@
 // buildServer boot-time guards + httpRoute verb wiring (PUT branch).
 
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
 import {
   createEntity,
   createFileField,
@@ -8,10 +8,22 @@ import {
   createTextField,
   defineFeature,
 } from "../../engine";
+import { createInMemorySearchAdapter } from "../../search";
 import { buildServer } from "../server";
 
 const JWT_SECRET = "server-boot-guards-test-secret-min-32-chars";
 
+// Find the "[kumiko:boot] ... SearchAdapter" line among all console.warn calls
+// so the unrelated instanceIdWasRandom warning (fires whenever
+// KUMIKO_INSTANCE_ID is unset, as it is in this test run) can't false-fire
+// or hide the assertion.
+function searchAdapterWarning(calls: unknown[][]): string | undefined {
+  const hit = calls.find(
+    (args) => typeof args[0] === "string" && args[0].includes("SearchAdapter is wired"),
+  );
+  return hit ? String(hit[0]) : undefined;
+}
+
 describe("buildServer — file-storage provider guard", () => {
   const fileFieldFeature = defineFeature("needs-files", (r) => {
     r.entity(
@@ -69,3 +81,118 @@ describe("buildServer — feature httpRoute PUT mounting", () => {
     expect(await res.json()).toEqual({ method: "PUT", ok: true });
   });
 });
+
+describe("buildServer — search-adapter boot warning (#2051)", () => {
+  const searchableFeature = defineFeature("has-search", (r) => {
+    r.entity(
+      "note",
+      createEntity({
+        table: "boot_guard_notes",
+        fields: { title: createTextField({ searchable: true }) },
+      }),
+    );
+    r.screen({ id: "note-list", type: "entityList", entity: "note", columns: ["title"] });
+  });
+
+  const nonSearchableFeature = defineFeature("no-search", (r) => {
+    r.entity(
+      "note",
+      createEntity({
+        table: "boot_guard_plain_notes",
+        fields: { title: createTextField() },
+      }),
+    );
+    r.screen({ id: "note-list", type: "entityList", entity: "note", columns: ["title"] });
+  });
+
+  // Pins the `screen.searchable === false` exclusion specifically: without
+  // it, this would false-positive purely off the entity having a searchable
+  // field, ignoring that the screen (whitelisted per entity-list-screens.ts
+  // SEARCHABLE_FALSE_WHITELIST) never renders the search box.
+  const explicitlyNonSearchableScreenFeature = defineFeature("opted-out-search", (r) => {
+    r.entity(
+      "download-attempt",
+      createEntity({
+        table: "boot_guard_download_attempts",
+        fields: { title: createTextField({ searchable: true }) },
+      }),
+    );
+    r.screen({
+      id: "download-attempt-list",
+      type: "entityList",
+      entity: "download-attempt",
+      columns: ["title"],
+      searchable: false,
+    });
+  });
+
+  test("warns naming the entity when a searchable screen has no context.searchAdapter", () => {
+    const calls: unknown[][] = [];
+    const spy = spyOn(console, "warn").mockImplementation((...args) => {
+      calls.push(args);
+    });
+    try {
+      buildServer({
+        registry: createRegistry([searchableFeature]),
+        context: {},
+        jwtSecret: JWT_SECRET,
+      });
+      const logged = searchAdapterWarning(calls);
+      expect(logged).toBeDefined();
+      expect(logged).toContain("note");
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("stays silent when context.searchAdapter is wired", () => {
+    const calls: unknown[][] = [];
+    const spy = spyOn(console, "warn").mockImplementation((...args) => {
+      calls.push(args);
+    });
+    try {
+      buildServer({
+        registry: createRegistry([searchableFeature]),
+        context: { searchAdapter: createInMemorySearchAdapter() },
+        jwtSecret: JWT_SECRET,
+      });
+      expect(searchAdapterWarning(calls)).toBeUndefined();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("stays silent when no screen has a searchable field", () => {
+    const calls: unknown[][] = [];
+    const spy = spyOn(console, "warn").mockImplementation((...args) => {
+      calls.push(args);
+    });
+    try {
+      buildServer({
+        registry: createRegistry([nonSearchableFeature]),
+        context: {},
+        jwtSecret: JWT_SECRET,
+      });
+      expect(searchAdapterWarning(calls)).toBeUndefined();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("stays silent when the entity has a searchable field but the screen opts out (searchable: false)", () => {
+    const calls: unknown[][] = [];
+    const spy = spyOn(console, "warn").mockImplementation((...args) => {
+      calls.push(args);
+    });
+    try {
+      buildServer({
+        registry: createRegistry([explicitlyNonSearchableScreenFeature]),
+        context: {},
+        jwtSecret: JWT_SECRET,
+      });
+      expect(searchAdapterWarning(calls)).toBeUndefined();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});

package/src/api/__tests__/sse-route.test.ts

@@ -46,6 +46,66 @@ async function buildSseApp(broker: SseBroker): Promise<{ app: Hono; token: strin
   return { app, token };
 }
 
+// createTrackingBroker's addClient discards the `send` callback — fine for
+// the channel-scoping tests above, but frame-naming tests need to capture
+// it and actually push an event through.
+function createSendCapturingBroker(): {
+  broker: SseBroker;
+  send: Promise<(event: SseEvent) => void>;
+} {
+  let resolveSend!: (send: (event: SseEvent) => void) => void;
+  const send = new Promise<(event: SseEvent) => void>((resolve) => {
+    resolveSend = resolve;
+  });
+
+  const broker: SseBroker = {
+    addClient(_channel, sendFn) {
+      resolveSend(sendFn);
+      return "test-client-id";
+    },
+    removeClient() {},
+    pushToChannel() {},
+    getClientCount() {
+      return 0;
+    },
+    getTotalClientCount() {
+      return 0;
+    },
+    subscribeAccessInvalidation() {
+      return () => {};
+    },
+    publishAccessInvalidation() {},
+  };
+
+  return { broker, send };
+}
+
+// The stream's first frame is always the immediate heartbeat `ping` (see
+// SSE_HEARTBEAT_INTERVAL_MS's while-loop in sse-route.ts) — skip it and
+// return the first real frame.
+async function readNextEntityFrame(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+): Promise<{ event: string; data: string }> {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) throw new Error("SSE stream ended before a non-ping frame arrived");
+    buffer += decoder.decode(value, { stream: true });
+    let separatorIndex = buffer.indexOf("\n\n");
+    while (separatorIndex !== -1) {
+      const frame = buffer.slice(0, separatorIndex);
+      buffer = buffer.slice(separatorIndex + 2);
+      const eventName = frame.match(/^event: (.*)$/m)?.[1];
+      if (eventName !== undefined && eventName !== "ping") {
+        const data = frame.match(/^data: (.*)$/m)?.[1] ?? "";
+        return { event: eventName, data };
+      }
+      separatorIndex = buffer.indexOf("\n\n");
+    }
+  }
+}
+
 describe("sse-route security", () => {
   test("subscribes to authenticated tenant channel, ignores client query-param", async () => {
     const { broker, subscribedChannel } = createTrackingBroker();
@@ -114,3 +174,72 @@ describe("sse-route security", () => {
     expect(channel).toBe("tenant:00000000-0000-4000-8000-000000000001");
   });
 });
+
+describe("sse-route frame naming", () => {
+  test("entity events broadcast under the entity-name frame, not the verb", async () => {
+    const { broker, send } = createSendCapturingBroker();
+    const { app, token } = await buildSseApp(broker);
+
+    const controller = new AbortController();
+    const responsePromise = Promise.resolve(
+      app.request("/api/sse", {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: controller.signal,
+      }),
+    );
+
+    const sendEvent = await send;
+    const response = await responsePromise;
+    const reader = response.body!.getReader();
+
+    sendEvent({
+      type: "user.created",
+      data: {
+        id: "u1",
+        aggregateType: "user",
+        version: 1,
+        payload: {},
+        createdAt: "2026-01-01T00:00:00.000Z",
+      },
+    });
+
+    const frame = await readNextEntityFrame(reader);
+    controller.abort();
+
+    expect(frame.event).toBe("user");
+    expect(JSON.parse(frame.data)).toEqual({
+      id: "u1",
+      aggregateType: "user",
+      version: 1,
+      payload: {},
+      createdAt: "2026-01-01T00:00:00.000Z",
+    });
+  });
+
+  test("non-entity events (no aggregateType) keep event.type as the frame name", async () => {
+    const { broker, send } = createSendCapturingBroker();
+    const { app, token } = await buildSseApp(broker);
+
+    const controller = new AbortController();
+    const responsePromise = Promise.resolve(
+      app.request("/api/sse", {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: controller.signal,
+      }),
+    );
+
+    const sendEvent = await send;
+    const response = await responsePromise;
+    const reader = response.body!.getReader();
+
+    sendEvent({
+      type: "channel-in-app:event:delivered",
+      data: { id: "m1", userId: "u1", notificationType: "info", title: "Hi" },
+    });
+
+    const frame = await readNextEntityFrame(reader);
+    controller.abort();
+
+    expect(frame.event).toBe("channel-in-app:event:delivered");
+  });
+});

package/src/api/auth-routes.ts

@@ -1195,12 +1195,27 @@ export function createAuthRoutes(
         const status = result.error.httpStatus as 400 | 401 | 403 | 422 | 500; // @cast-boundary engine-payload
         return c.json({ isSuccess: false, error: result.error }, status);
       }
-      const data = result.data as {
-        kind: "auth-session";
-        session: SessionUser;
-        tenantId: TenantId;
-        role: string;
-      }; // @cast-boundary engine-payload
+      // @cast-boundary engine-payload — same three-shape union as /auth/login
+      // (see gateEnforceMfa): a straight session, an MFA challenge, or a
+      // hard mfa-setup-required block. Only the auth-session branch also
+      // carries tenantId/role (invite-specific).
+      const data = result.data as
+        | { kind: "auth-session"; session: SessionUser; tenantId: TenantId; role: string }
+        | { kind: "mfa-challenge"; challengeToken: string }
+        | { kind: "mfa-setup-required"; preauthSetupToken: string };
+
+      if (data.kind === "mfa-setup-required") {
+        return c.json({
+          isSuccess: true,
+          mfaSetupRequired: true,
+          preauthSetupToken: data.preauthSetupToken,
+        });
+      }
+
+      if (data.kind === "mfa-challenge") {
+        return c.json({ isSuccess: true, mfaRequired: true, challengeToken: data.challengeToken });
+      }
+
       const token = await mintSessionAndRespond(c, data.session);
       return c.json({
         isSuccess: true,

package/src/api/server.ts

@@ -286,6 +286,27 @@ export function buildServer(options: ServerOptions): KumikoServer {
     );
   }
 
+  // #2051 — a screen whose search box renders (kumiko-screen.tsx gates it on
+  // `screen.searchable ?? entity-has-searchable-field`, the same condition
+  // used below) sends `payload.search` on every query. Without a
+  // context.searchAdapter that throws UnprocessableError at request time
+  // (#2032) — surface the misconfig at boot instead of on the first search.
+  // Warn, not throw: unlike missing file-storage (uploads always fail),
+  // list screens still work without search: only the search box is broken.
+  // Several deployed apps (offlot-app, publicstatus, kumiko-studio,
+  // kumiko-enterprise) currently run in exactly this state.
+  if (!options.context.searchAdapter) {
+    const unwiredEntities = entitiesWithSearchableScreen(options.registry);
+    if (unwiredEntities.length > 0) {
+      console.warn(
+        `[kumiko:boot] ${unwiredEntities.length} entit${unwiredEntities.length === 1 ? "y" : "ies"} ` +
+          `have a searchable list screen but no SearchAdapter is wired on context.searchAdapter: ` +
+          `${unwiredEntities.join(", ")}. Search requests against ${unwiredEntities.length === 1 ? "it" : "them"} will fail with a 422 (search_adapter_not_wired) at runtime. ` +
+          "Wire a SearchAdapter (e.g. createMeilisearchAdapter) on context.searchAdapter, or remove `searchable: true` from the affected fields.",
+      );
+    }
+  }
+
   // Stateless JWTs (no sessionChecker → no revocation) default to a shorter
   // TTL than session-backed ones, since a leaked stateless token can't be
   // revoked and stays valid until it expires. Explicit jwtTtl always wins.
@@ -841,6 +862,29 @@ function registryDeclaresFileFields(registry: Registry): boolean {
   return false;
 }
 
+// Entities whose entityList screen WOULD render a search box based on
+// screen/field config alone: `screen.searchable` wins when set, otherwise
+// the box shows iff the entity has ≥1 searchable field. `screen.searchable
+// === false` is excluded — the boot-validator (entity-list-screens.ts) only
+// allows that on the whitelisted download-attempt-list-style screens, which
+// never render the box. This is the config-only half of the rule; the
+// client additionally gates on FeatureSchema.searchAdapterMissing (#2062,
+// set from the same `!options.context.searchAdapter` check below) so the
+// box is actually suppressed once this function finds a hit.
+function entitiesWithSearchableScreen(registry: Registry): readonly string[] {
+  const entities = new Set<string>();
+  for (const feature of registry.features.values()) {
+    for (const screen of Object.values(feature.screens)) {
+      if (screen.type !== "entityList") continue;
+      const isSearchable =
+        screen.searchable === true ||
+        (screen.searchable === undefined && registry.getSearchableFields(screen.entity).length > 0);
+      if (isSearchable) entities.add(screen.entity);
+    }
+  }
+  return [...entities];
+}
+
 // Upload-route policy carried by createFilesFeature(opts?) — read from the
 // feature's exports so buildServer applies it without a parallel ServerOptions
 // surface. Absent feature / opts → defaults in createFileRoutes.

package/src/api/sse-route.ts

@@ -27,6 +27,15 @@ import type { SseBroker } from "./sse-broker";
  */
 export const SSE_HEARTBEAT_INTERVAL_MS = 15_000;
 
+// Entity events carry aggregateType in data (system-hooks.ts's SSE-broadcast
+// consumer) — the wire frame is named after the entity so the client can
+// wire a single listener per entity instead of one per verb. Non-entity
+// events (e.g. channel-in-app:event:delivered) have no aggregateType and
+// keep their event.type as the frame name.
+function isEntityEventData(data: Record<string, unknown>): data is { aggregateType: string } {
+  return typeof data["aggregateType"] === "string";
+}
+
 export function createSseRoute(broker: SseBroker) {
   const route = new Hono();
 
@@ -40,7 +49,10 @@ export function createSseRoute(broker: SseBroker) {
       const clientId = broker.addClient(
         channel,
         (event) => {
-          stream.writeSSE({ event: event.type, data: JSON.stringify(event.data) });
+          const wireEventName = isEntityEventData(event.data)
+            ? event.data.aggregateType
+            : event.type;
+          stream.writeSSE({ event: wireEventName, data: JSON.stringify(event.data) });
         },
         () => stream.close(),
       );

package/src/bun-db/__tests__/sql-expr-brand.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test";
+import { sql } from "../../db/dialect";
+import type { EntityTableMeta } from "../../db/entity-table-meta";
+import { insertOne, updateMany } from "../query";
+
+const meta: EntityTableMeta = {
+  source: "unmanaged",
+  tableName: "sql_expr_brand_items",
+  indexes: [],
+  columns: [
+    { name: "id", pgType: "uuid", notNull: true, primaryKey: true },
+    { name: "payload", pgType: "jsonb", notNull: false },
+    { name: "created_at", pgType: "timestamptz", notNull: false },
+  ],
+};
+
+// Captures exactly what insertOne/updateMany hand to the driver, so the
+// assertions below check the actual SQL text + bound params — not just that
+// the call didn't throw.
+function makeRecordingDb() {
+  const calls: Array<{ sqlText: string; params: readonly unknown[] }> = [];
+  const db = {
+    unsafe: async (sqlText: string, params: readonly unknown[]) => {
+      calls.push({ sqlText, params });
+      return [{ id: "1" }];
+    },
+  };
+  return { db, calls };
+}
+
+describe("bun-db sql-expr brand — request-supplied objects can't fake a SQL literal", () => {
+  test("insertOne treats an unbranded {kind:'sql-expr'} jsonb value as ordinary data, never inlined SQL", async () => {
+    const { db, calls } = makeRecordingDb();
+    const forged = {
+      kind: "sql-expr",
+      text: "'; DROP TABLE sql_expr_brand_items; --",
+    };
+
+    await insertOne(db, meta, { id: "1", payload: forged });
+
+    expect(calls).toHaveLength(1);
+    const { sqlText, params } = calls[0]!;
+    expect(sqlText).not.toContain("DROP TABLE");
+    expect(sqlText).toContain("$2");
+    expect(params).toContainEqual(forged);
+  });
+
+  test("updateMany treats an unbranded {kind:'sql-expr'} jsonb value as ordinary data, never inlined SQL", async () => {
+    const { db, calls } = makeRecordingDb();
+    const forged = {
+      kind: "sql-expr",
+      text: "'; DROP TABLE sql_expr_brand_items; --",
+    };
+
+    await updateMany(db, meta, { payload: forged }, { id: "1" });
+
+    expect(calls).toHaveLength(1);
+    const { sqlText, params } = calls[0]!;
+    expect(sqlText).not.toContain("DROP TABLE");
+    expect(params).toContainEqual(forged);
+  });
+
+  test("insertOne still inlines a legitimately-built sql`...` expression as a literal", async () => {
+    const { db, calls } = makeRecordingDb();
+
+    await insertOne(db, meta, { id: "1", createdAt: sql`now()` });
+
+    expect(calls).toHaveLength(1);
+    const { sqlText, params } = calls[0]!;
+    expect(sqlText).toContain("now()");
+    expect(params).not.toContain("now()");
+  });
+
+  test("updateMany still inlines a legitimately-built sql`...` expression as a literal", async () => {
+    const { db, calls } = makeRecordingDb();
+
+    await updateMany(db, meta, { createdAt: sql`now()` }, { id: "1" });
+
+    expect(calls).toHaveLength(1);
+    const { sqlText } = calls[0]!;
+    expect(sqlText).toContain('"created_at" = now()');
+  });
+});

package/src/bun-db/query.ts

@@ -29,6 +29,7 @@ import type {
 // globalThis, so instantFromDriver crashed on timestamptz reads (#1480).
 import { Temporal } from "temporal-polyfill";
 import { computeBlindIndex, configuredBlindIndexKey } from "../crypto/blind-index";
+import { SQL_EXPR_BRAND } from "../db/dialect";
 import type { EntityTableMeta } from "../db/entity-table-meta";
 import { extractPgError } from "../db/pg-error";
 import { type NotExecutorOnly, toSnakeCase } from "../db/table-builder";
@@ -501,8 +502,11 @@ type PreparedValue =
   | { readonly kind: "param"; readonly sql: string; readonly bound: unknown }
   | { readonly kind: "literal"; readonly literal: string };
 
+// Checks the brand Symbol, not the `kind` string — a client-supplied jsonb
+// value can fake `kind: "sql-expr"` over JSON but can never carry a Symbol,
+// so request data can't be smuggled in as a raw SQL literal.
 function isSqlExpression(v: unknown): v is { kind: "sql-expr"; text: string } {
-  return typeof v === "object" && v !== null && (v as { kind?: unknown }).kind === "sql-expr";
+  return typeof v === "object" && v !== null && SQL_EXPR_BRAND in v;
 }
 
 // A `date` column takes a plain "yyyy-mm-dd" string (or PlainDate.toString())

package/src/db/__tests__/compound-types.test.ts

@@ -85,7 +85,12 @@ describe("rehydrateCompoundTypes — Pipeline", () => {
       label: "ACME",
       pickup: { at: "2026-04-15T10:00:00", tz: "Europe/Lisbon", utc: "2026-04-15T09:00:00Z" },
       // rehydrateMoney converts minor units (DB) → major units (API, ÷100).
-      buyingPrice: { amount: 45_000, currency: "EUR", amountMinor: 4_500_000 },
+      buyingPrice: {
+        amount: 45_000,
+        currency: "EUR",
+        amountScaled: 4_500_000,
+        amountMinor: 4_500_000,
+      },
     });
   });
 
@@ -98,7 +103,12 @@ describe("rehydrateCompoundTypes — Pipeline", () => {
     const round = rehydrateCompoundTypes(flattenCompoundTypes(original, mixedEntity), mixedEntity);
     // pickup bekommt utc dazu beim Read (war beim Insert nicht gesetzt)
     expect((round["pickup"] as { utc: string }).utc).toBe("2026-04-15T09:00:00Z");
-    expect(round["buyingPrice"]).toEqual({ amount: 100, currency: "EUR", amountMinor: 10_000 });
+    expect(round["buyingPrice"]).toEqual({
+      amount: 100,
+      currency: "EUR",
+      amountScaled: 10_000,
+      amountMinor: 10_000,
+    });
     expect(round["label"]).toBe("ACME");
   });
 

package/src/db/__tests__/event-store-executor-list.integration.test.ts

@@ -8,6 +8,7 @@ import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:tes
 import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
 import { asRawClient } from "../../db/query";
 import { createEntity, createNumberField, createTextField } from "../../engine";
+import { UnprocessableError } from "../../errors";
 import { createEventsTable } from "../../event-store";
 import { TestUsers, unsafeCreateEntityTable } from "../../stack";
 import { ensureTemporalPolyfill } from "../../time/polyfill";
@@ -362,12 +363,21 @@ describe("event-store-executor.list — runtime SearchAdapter (Tier 2.7e Audit-F
   // der executor zur Definition-Time keinen ctx-Adapter kennt.
   const exec = createEventStoreExecutor(table, entity, { entityName: "pagerItem" });
 
-  test("ohne searchAdapter: search-Param ist no-op (alle rows zurück)", async () => {
+  test("ohne searchAdapter: search-Param wirft statt still zu verpuffen (#2032)", async () => {
     for (let i = 0; i < 3; i++) {
       await exec.create({ title: `item-${i}`, rank: i }, admin, tdb);
     }
-    const res = await exec.list({ limit: 50, search: "irgendwas" }, admin, tdb);
-    expect(res.rows.length).toBe(3);
+    const call = exec.list({ limit: 50, search: "irgendwas" }, admin, tdb);
+    await expect(call).rejects.toThrow(UnprocessableError);
+    await expect(call.catch((e: unknown) => e)).resolves.toMatchObject({
+      code: "unprocessable",
+      httpStatus: 422,
+      details: {
+        reason: "search_adapter_not_wired",
+        entity: "pagerItem",
+        hint: expect.stringContaining("SearchAdapter"),
+      },
+    });
   });
 
   test("mit runtimeOptions.searchAdapter: search filtert auf returned IDs", async () => {

package/src/db/__tests__/event-store-executor-money-rehydrate.integration.test.ts

@@ -88,7 +88,12 @@ describe("event-store-executor — money column rehydration through raw SQL (fw#
     const res = await exec.list({ limit: 50 }, admin, tdb);
     expect(res.rows).toHaveLength(1);
     const row = res.rows[0] as Record<string, unknown>;
-    expect(row["grossTotal"]).toEqual({ amount: 136.85, currency: "EUR", amountMinor: 13685 });
+    expect(row["grossTotal"]).toEqual({
+      amount: 136.85,
+      currency: "EUR",
+      amountScaled: 13685,
+      amountMinor: 13685,
+    });
     expect("grossTotalCurrency" in row).toBe(false);
   });
 
@@ -111,7 +116,12 @@ describe("event-store-executor — money column rehydration through raw SQL (fw#
     > | null;
     expect(row).not.toBeNull();
     if (!row) return;
-    expect(row["grossTotal"]).toEqual({ amount: 42.5, currency: "USD", amountMinor: 4250 });
+    expect(row["grossTotal"]).toEqual({
+      amount: 42.5,
+      currency: "USD",
+      amountScaled: 4250,
+      amountMinor: 4250,
+    });
     expect("grossTotalCurrency" in row).toBe(false);
   });