@nanobpm/bojtos-kit 0.6.0 → 0.8.0

package/README.md

@@ -27,6 +27,40 @@ Every command returns the post-run `Snapshot`: `activeElementIds` /
 For React, use [`@nanobpm/bojtos-react`](../bojtos-react), which owns the session
 lifecycle and reactive state on top of this kit.
 
+## Engine variants — `lean` (default) and `readmodel`
+
+`@nanobpm/engine-wasm` ships two binaries; a session picks one via `variant`:
+
+- **`lean`** (default) — primary state only. Read it through `snapshot()` /
+  `events()`. Loaded statically, so every consumer bundles it.
+- **`readmodel`** — the lean surface **plus** the gateway's Camunda-parity REST
+  read channel. Loaded via a **dynamic import**, so a lean-only page never
+  downloads the heavier read-model binary (wasm can't be tree-shaken out of a
+  single build — code-splitting is the only lever).
+
+```ts
+import {
+  createBojtosSession,
+  type UserTaskSearchQueryResult,
+} from "@nanobpm/bojtos-kit";
+
+// `variant: "readmodel"` widens the return type to `ReadModelBojtosSession`:
+const session = await createBojtosSession({ variant: "readmodel" });
+session.deploy(bpmnXml);
+session.createInstance("review", "{}");
+
+// Typed against @nanobpm/engine-wasm/readmodel-types (re-exported here):
+const open: UserTaskSearchQueryResult = session.searchUserTasks(
+  JSON.stringify({ state: "CREATED" }),
+);
+const form = session.getFormByKey("2251799813685250"); // FormResult | null
+```
+
+The read methods — `searchUserTasks`, `searchProcessInstances`,
+`searchVariables`, `getFormByKey`, `getResourceByKey` — return DTOs re-exported
+from `@nanobpm/engine-wasm/readmodel-types`, which are **derived** from the
+Camunda-parity REST OpenAPI (one source of truth, not a hand-copy).
+
 ## Trace model
 
 The kit also holds the framework-agnostic **trace model** the shared

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export { ensureWasm, createBojtosSession, type BojtosSession, type WasmSource, } from "./session.js";
+export { ensureWasm, ensureReadModelWasm, createBojtosSession, type BojtosSession, type ReadModelBojtosSession, type EngineVariant, type WasmSource, } from "./session.js";
 export { dispatchWorkers, dispatchRound, settleReason, unhandledJobTypes, JobFailure, type JobHandler, type JobResult, type AgentHandler, type DispatchOptions, type DispatchResult, type RoundResult, type SettleReason, } from "./worker.js";
 export { buildTraceItems, isTraceTurnGroup, foldEngineEvents, traceEntriesToRows, } from "./trace.js";
 export type { TraceRowKind, TraceEntry, TraceRow, TraceTurnGroup, TraceItem, TraceAdapter, } from "./trace.js";
 export type { Snapshot, InstanceDto, JobDto, ActivatedJob, IncidentDto, TimerDto, UserTaskDto, MessageSubscriptionDto, SignalSubscriptionDto, ElementStatDto, SequenceFlowDto, DecisionInstanceDto, ActiveEl, ActivateInstruction, AgentActivation, AgentResult, WasmEvent, } from "./types.js";
+export type { UserTaskSearchQueryResult, UserTaskResult, ProcessInstanceSearchQueryResult, ProcessInstanceResult, VariableSearchQueryResult, VariableResult, FormResult, ResourceResult, SearchQueryResponse, SearchQueryPageResponse, } from "@nanobpm/engine-wasm/readmodel-types";

package/dist/index.js

@@ -1,7 +1,7 @@
 // @nanobpm/bojtos-kit — the framework-agnostic core of the Bojtos demo
 // framework (ADR 0043). Wraps the in-browser wasm engine as a single scenario
 // runner and re-exports the engine's snapshot/event contract types.
-export { ensureWasm, createBojtosSession, } from "./session.js";
+export { ensureWasm, ensureReadModelWasm, createBojtosSession, } from "./session.js";
 export { dispatchWorkers, dispatchRound, settleReason, unhandledJobTypes, JobFailure, } from "./worker.js";
 // The shared trace model + both adapters (engine-event fold and handler-emitted
 // `TraceEntry`) that retired the two forked `TraceTimeline` copies (#9). Pure and

package/dist/session.d.ts

@@ -1,5 +1,23 @@
 import { type InitInput } from "@nanobpm/engine-wasm";
+import type { FormResult, ProcessInstanceSearchQueryResult, ResourceResult, UserTaskSearchQueryResult, VariableSearchQueryResult } from "@nanobpm/engine-wasm/readmodel-types";
 import type { ActivatedJob, ActivateInstruction, AgentResult, Snapshot, WasmEvent } from "./types.js";
+/**
+ * Which engine binary backs a session. The two are separate wasm builds
+ * (engine-wasm ships them at distinct subpaths, ADR 0043 §3 / engine-wasm
+ * README):
+ *
+ * - `"lean"` (default) — primary state only; the binary demos/the modeler use.
+ *   Loaded via the static `@nanobpm/engine-wasm` import, so a bundler emits it
+ *   for every bojtos-kit consumer.
+ * - `"readmodel"` — the lean surface **plus** the gateway's Camunda-parity REST
+ *   read channel (`searchUserTasks`/`searchProcessInstances`/`searchVariables`/
+ *   `getFormByKey`/`getResourceByKey`). It carries an in-memory wasm SQLite read
+ *   model (~2× the wire size), so it is loaded via a **dynamic import** — a
+ *   lean-only page never bundles it (wasm can't be tree-shaken out of a fat
+ *   build; code-splitting is the only lever).
+ */
+export type EngineVariant = "lean" | "readmodel";
+type ReadModelModule = typeof import("@nanobpm/engine-wasm/readmodel");
 /**
  * The source of the engine wasm binary. Under a bundler that understands
  * `new URL(..., import.meta.url)` (e.g. Vite) the default loader needs no
@@ -20,6 +38,15 @@ export type WasmSource = InitInput;
  * the binary — can retry rather than being stuck on the first rejection.
  */
 export declare function ensureWasm(source?: WasmSource): Promise<void>;
+/**
+ * Load **and** initialise the read-model engine variant (idempotent; once per
+ * page). Unlike {@link ensureWasm} this also code-splits the binary in via a
+ * dynamic `import("@nanobpm/engine-wasm/readmodel")`, so a page that only ever
+ * calls {@link ensureWasm} never downloads the heavier read-model wasm. Same
+ * first-call-wins / retry-on-failure semantics as {@link ensureWasm}. Returns
+ * the module namespace so the caller can construct its `TestEngine`.
+ */
+export declare function ensureReadModelWasm(source?: WasmSource): Promise<ReadModelModule>;
 /**
  * A headless handle to one in-browser engine instance: deploy a diagram, start
  * instances, complete/fail jobs, advance the virtual clock, and read the event
@@ -141,12 +168,66 @@ export interface BojtosSession {
     free(): void;
 }
 /**
- * Create a fresh headless engine session. Ensures the wasm module is loaded
- * (once per page), then constructs a new {@link TestEngine}. The virtual clock
+ * A {@link BojtosSession} backed by the **read-model** engine variant: the full
+ * lean command surface **plus** the gateway's Camunda-parity REST read channel.
+ * Each read method delegates to the in-memory read model (kept current after
+ * every command, cleared by {@link BojtosSession.reset}) and returns the parsed
+ * DTO — typed against `@nanobpm/engine-wasm/readmodel-types`, which is derived
+ * from the same Camunda REST OpenAPI the wasm mirrors, so these stay in lockstep
+ * with the engine instead of being hand-copied. Obtain one via
+ * `createBojtosSession({ variant: "readmodel" })`.
+ */
+export interface ReadModelBojtosSession extends BojtosSession {
+    /**
+     * Search user tasks through the read model. Honours an optional `{ state? }`
+     * filter (e.g. `"CREATED"`). Mirrors `POST /user-tasks/search`.
+     */
+    searchUserTasks(filterJson?: string): UserTaskSearchQueryResult;
+    /**
+     * Search process instances through the read model. Body is shape-validated;
+     * filter/sort/page fields are not yet honoured (returns every instance).
+     * Mirrors `POST /process-instances/search`.
+     */
+    searchProcessInstances(filterJson?: string): ProcessInstanceSearchQueryResult;
+    /**
+     * Search variables through the read model. Long values are truncated with
+     * `isTruncated: true`. Mirrors `POST /variables/search`.
+     */
+    searchVariables(filterJson?: string): VariableSearchQueryResult;
+    /**
+     * The latest deployed form for `formKey`, or `null` if none. Mirrors
+     * `GET /forms/{formKey}`.
+     */
+    getFormByKey(formKey: string): FormResult | null;
+    /**
+     * The generic resource for `resourceKey`, or `null` if none. Mirrors
+     * `GET /resources/{resourceKey}`.
+     */
+    getResourceByKey(resourceKey: string): ResourceResult | null;
+}
+/**
+ * Create a fresh headless engine session. Ensures the chosen wasm variant is
+ * loaded (once per page), then constructs a new `TestEngine`. The virtual clock
  * starts at 0; deploy a diagram before starting instances. Pass a `wasm` source
  * in environments where the default `import.meta.url` loader can't resolve the
  * binary (Node/Jest, or the external-`.wasm` mode — ADR 0043 §3).
+ *
+ * With `variant: "readmodel"` the returned session also exposes the gateway's
+ * REST read channel (typed {@link ReadModelBojtosSession}); the default `"lean"`
+ * variant is state-only and never downloads the heavier read-model binary. A
+ * statically-`"readmodel"` variant widens the return type; a value only known as
+ * the `EngineVariant` union resolves to the base {@link BojtosSession}.
  */
 export declare function createBojtosSession(opts?: {
     wasm?: WasmSource;
+    variant?: "lean";
+}): Promise<BojtosSession>;
+export declare function createBojtosSession(opts: {
+    wasm?: WasmSource;
+    variant: "readmodel";
+}): Promise<ReadModelBojtosSession>;
+export declare function createBojtosSession(opts: {
+    wasm?: WasmSource;
+    variant: EngineVariant;
 }): Promise<BojtosSession>;
+export {};

package/dist/session.js

@@ -1,7 +1,9 @@
 import init, { TestEngine } from "@nanobpm/engine-wasm";
 // Lazily initialise the wasm module exactly once per page, no matter how many
-// sessions are created. Mirrors the console's original `ensureWasm`.
+// sessions are created. Mirrors the console's original `ensureWasm`. The two
+// variants init independently (a page may use either or both).
 let wasmReady = null;
+let readModelReady = null;
 /**
  * Initialise the wasm engine module (idempotent; safe to call repeatedly). The
  * first successful call wins: a `source` passed to a later call is ignored once
@@ -24,6 +26,28 @@ export function ensureWasm(source) {
     }
     return wasmReady;
 }
+/**
+ * Load **and** initialise the read-model engine variant (idempotent; once per
+ * page). Unlike {@link ensureWasm} this also code-splits the binary in via a
+ * dynamic `import("@nanobpm/engine-wasm/readmodel")`, so a page that only ever
+ * calls {@link ensureWasm} never downloads the heavier read-model wasm. Same
+ * first-call-wins / retry-on-failure semantics as {@link ensureWasm}. Returns
+ * the module namespace so the caller can construct its `TestEngine`.
+ */
+export function ensureReadModelWasm(source) {
+    if (!readModelReady) {
+        readModelReady = import("@nanobpm/engine-wasm/readmodel")
+            .then(async (mod) => {
+            await mod.default(source === undefined ? undefined : { module_or_path: source });
+            return mod;
+        })
+            .catch((e) => {
+            readModelReady = null;
+            throw e;
+        });
+    }
+    return readModelReady;
+}
 function parseSnapshot(json) {
     // The wasm engine is the schema authority; its JSON is the contract boundary.
     return JSON.parse(json);
@@ -104,14 +128,38 @@ class WasmBojtosSession {
         this.engine.free();
     }
 }
-/**
- * Create a fresh headless engine session. Ensures the wasm module is loaded
- * (once per page), then constructs a new {@link TestEngine}. The virtual clock
- * starts at 0; deploy a diagram before starting instances. Pass a `wasm` source
- * in environments where the default `import.meta.url` loader can't resolve the
- * binary (Node/Jest, or the external-`.wasm` mode — ADR 0043 §3).
- */
+class WasmReadModelSession extends WasmBojtosSession {
+    // The read-model engine is a structural superset of the lean `TestEngine`
+    // (identical command surface + the 5 read methods), so it satisfies the base
+    // constructor while we keep our own read-model-typed reference for the read
+    // channel — no casts, so a future divergence in the shared surface is a
+    // compile error rather than a runtime one.
+    rm;
+    constructor(engine) {
+        super(engine);
+        this.rm = engine;
+    }
+    searchUserTasks(filterJson = "{}") {
+        return JSON.parse(this.rm.searchUserTasks(filterJson || "{}"));
+    }
+    searchProcessInstances(filterJson = "{}") {
+        return JSON.parse(this.rm.searchProcessInstances(filterJson || "{}"));
+    }
+    searchVariables(filterJson = "{}") {
+        return JSON.parse(this.rm.searchVariables(filterJson || "{}"));
+    }
+    getFormByKey(formKey) {
+        return JSON.parse(this.rm.getFormByKey(formKey));
+    }
+    getResourceByKey(resourceKey) {
+        return JSON.parse(this.rm.getResourceByKey(resourceKey));
+    }
+}
 export async function createBojtosSession(opts) {
+    if (opts?.variant === "readmodel") {
+        const mod = await ensureReadModelWasm(opts.wasm);
+        return new WasmReadModelSession(new mod.TestEngine());
+    }
     await ensureWasm(opts?.wasm);
     return new WasmBojtosSession(new TestEngine());
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/bojtos-kit",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Framework-agnostic core of the Bojtos in-browser BPMN demo framework (ADR 0043): a single scenario runner over the @nanobpm/engine-wasm engine (deploy, start instances, complete/fail jobs, advance the clock, read snapshots and the event log), plus the engine's snapshot/event contract types. Consumed by @nanobpm/bojtos-react and the console test-run panel.",
   "type": "module",
   "license": "Apache-2.0",
@@ -32,7 +32,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@nanobpm/engine-wasm": "^0.3.0"
+    "@nanobpm/engine-wasm": "^0.7.0"
   },
   "devDependencies": {
     "typescript": "^5.6.3"

package/src/index.ts

@@ -4,8 +4,11 @@
 
 export {
   ensureWasm,
+  ensureReadModelWasm,
   createBojtosSession,
   type BojtosSession,
+  type ReadModelBojtosSession,
+  type EngineVariant,
   type WasmSource,
 } from "./session.js";
 export {
@@ -61,3 +64,20 @@ export type {
   AgentResult,
   WasmEvent,
 } from "./types.js";
+// The read-model query-result DTOs, re-exported from
+// `@nanobpm/engine-wasm/readmodel-types` (derived from the Camunda-parity REST
+// OpenAPI — a single source of truth, not a hand-copy). A consumer that reads a
+// `ReadModelBojtosSession`'s `searchUserTasks()` / `getFormByKey()` return must
+// be able to name these to write helpers over them.
+export type {
+  UserTaskSearchQueryResult,
+  UserTaskResult,
+  ProcessInstanceSearchQueryResult,
+  ProcessInstanceResult,
+  VariableSearchQueryResult,
+  VariableResult,
+  FormResult,
+  ResourceResult,
+  SearchQueryResponse,
+  SearchQueryPageResponse,
+} from "@nanobpm/engine-wasm/readmodel-types";

package/src/session.ts

@@ -1,4 +1,11 @@
 import init, { type InitInput, TestEngine } from "@nanobpm/engine-wasm";
+import type {
+  FormResult,
+  ProcessInstanceSearchQueryResult,
+  ResourceResult,
+  UserTaskSearchQueryResult,
+  VariableSearchQueryResult,
+} from "@nanobpm/engine-wasm/readmodel-types";
 import type {
   ActivatedJob,
   ActivateInstruction,
@@ -7,9 +14,35 @@ import type {
   WasmEvent,
 } from "./types.js";
 
+/**
+ * Which engine binary backs a session. The two are separate wasm builds
+ * (engine-wasm ships them at distinct subpaths, ADR 0043 §3 / engine-wasm
+ * README):
+ *
+ * - `"lean"` (default) — primary state only; the binary demos/the modeler use.
+ *   Loaded via the static `@nanobpm/engine-wasm` import, so a bundler emits it
+ *   for every bojtos-kit consumer.
+ * - `"readmodel"` — the lean surface **plus** the gateway's Camunda-parity REST
+ *   read channel (`searchUserTasks`/`searchProcessInstances`/`searchVariables`/
+ *   `getFormByKey`/`getResourceByKey`). It carries an in-memory wasm SQLite read
+ *   model (~2× the wire size), so it is loaded via a **dynamic import** — a
+ *   lean-only page never bundles it (wasm can't be tree-shaken out of a fat
+ *   build; code-splitting is the only lever).
+ */
+export type EngineVariant = "lean" | "readmodel";
+
+// Type-only view of the read-model module so we can name its `TestEngine`
+// (a distinct wasm-bindgen class from lean's, with the +5 read methods) without
+// statically importing the heavy binary — the runtime handle is fetched lazily
+// by `ensureReadModelWasm`'s dynamic `import()`.
+type ReadModelModule = typeof import("@nanobpm/engine-wasm/readmodel");
+type ReadModelEngine = InstanceType<ReadModelModule["TestEngine"]>;
+
 // Lazily initialise the wasm module exactly once per page, no matter how many
-// sessions are created. Mirrors the console's original `ensureWasm`.
+// sessions are created. Mirrors the console's original `ensureWasm`. The two
+// variants init independently (a page may use either or both).
 let wasmReady: Promise<void> | null = null;
+let readModelReady: Promise<ReadModelModule> | null = null;
 
 /**
  * The source of the engine wasm binary. Under a bundler that understands
@@ -45,6 +78,33 @@ export function ensureWasm(source?: WasmSource): Promise<void> {
   return wasmReady;
 }
 
+/**
+ * Load **and** initialise the read-model engine variant (idempotent; once per
+ * page). Unlike {@link ensureWasm} this also code-splits the binary in via a
+ * dynamic `import("@nanobpm/engine-wasm/readmodel")`, so a page that only ever
+ * calls {@link ensureWasm} never downloads the heavier read-model wasm. Same
+ * first-call-wins / retry-on-failure semantics as {@link ensureWasm}. Returns
+ * the module namespace so the caller can construct its `TestEngine`.
+ */
+export function ensureReadModelWasm(
+  source?: WasmSource,
+): Promise<ReadModelModule> {
+  if (!readModelReady) {
+    readModelReady = import("@nanobpm/engine-wasm/readmodel")
+      .then(async (mod) => {
+        await mod.default(
+          source === undefined ? undefined : { module_or_path: source },
+        );
+        return mod;
+      })
+      .catch((e) => {
+        readModelReady = null;
+        throw e;
+      });
+  }
+  return readModelReady;
+}
+
 /**
  * A headless handle to one in-browser engine instance: deploy a diagram, start
  * instances, complete/fail jobs, advance the virtual clock, and read the event
@@ -185,13 +245,52 @@ export interface BojtosSession {
   free(): void;
 }
 
+/**
+ * A {@link BojtosSession} backed by the **read-model** engine variant: the full
+ * lean command surface **plus** the gateway's Camunda-parity REST read channel.
+ * Each read method delegates to the in-memory read model (kept current after
+ * every command, cleared by {@link BojtosSession.reset}) and returns the parsed
+ * DTO — typed against `@nanobpm/engine-wasm/readmodel-types`, which is derived
+ * from the same Camunda REST OpenAPI the wasm mirrors, so these stay in lockstep
+ * with the engine instead of being hand-copied. Obtain one via
+ * `createBojtosSession({ variant: "readmodel" })`.
+ */
+export interface ReadModelBojtosSession extends BojtosSession {
+  /**
+   * Search user tasks through the read model. Honours an optional `{ state? }`
+   * filter (e.g. `"CREATED"`). Mirrors `POST /user-tasks/search`.
+   */
+  searchUserTasks(filterJson?: string): UserTaskSearchQueryResult;
+  /**
+   * Search process instances through the read model. Body is shape-validated;
+   * filter/sort/page fields are not yet honoured (returns every instance).
+   * Mirrors `POST /process-instances/search`.
+   */
+  searchProcessInstances(filterJson?: string): ProcessInstanceSearchQueryResult;
+  /**
+   * Search variables through the read model. Long values are truncated with
+   * `isTruncated: true`. Mirrors `POST /variables/search`.
+   */
+  searchVariables(filterJson?: string): VariableSearchQueryResult;
+  /**
+   * The latest deployed form for `formKey`, or `null` if none. Mirrors
+   * `GET /forms/{formKey}`.
+   */
+  getFormByKey(formKey: string): FormResult | null;
+  /**
+   * The generic resource for `resourceKey`, or `null` if none. Mirrors
+   * `GET /resources/{resourceKey}`.
+   */
+  getResourceByKey(resourceKey: string): ResourceResult | null;
+}
+
 function parseSnapshot(json: string): Snapshot {
   // The wasm engine is the schema authority; its JSON is the contract boundary.
   return JSON.parse(json) as Snapshot;
 }
 
 class WasmBojtosSession implements BojtosSession {
-  private readonly engine: TestEngine;
+  protected readonly engine: TestEngine;
 
   constructor(engine: TestEngine) {
     this.engine = engine;
@@ -350,16 +449,84 @@ class WasmBojtosSession implements BojtosSession {
   }
 }
 
+class WasmReadModelSession
+  extends WasmBojtosSession
+  implements ReadModelBojtosSession
+{
+  // The read-model engine is a structural superset of the lean `TestEngine`
+  // (identical command surface + the 5 read methods), so it satisfies the base
+  // constructor while we keep our own read-model-typed reference for the read
+  // channel — no casts, so a future divergence in the shared surface is a
+  // compile error rather than a runtime one.
+  private readonly rm: ReadModelEngine;
+
+  constructor(engine: ReadModelEngine) {
+    super(engine);
+    this.rm = engine;
+  }
+
+  searchUserTasks(filterJson = "{}"): UserTaskSearchQueryResult {
+    return JSON.parse(
+      this.rm.searchUserTasks(filterJson || "{}"),
+    ) as UserTaskSearchQueryResult;
+  }
+
+  searchProcessInstances(filterJson = "{}"): ProcessInstanceSearchQueryResult {
+    return JSON.parse(
+      this.rm.searchProcessInstances(filterJson || "{}"),
+    ) as ProcessInstanceSearchQueryResult;
+  }
+
+  searchVariables(filterJson = "{}"): VariableSearchQueryResult {
+    return JSON.parse(
+      this.rm.searchVariables(filterJson || "{}"),
+    ) as VariableSearchQueryResult;
+  }
+
+  getFormByKey(formKey: string): FormResult | null {
+    return JSON.parse(this.rm.getFormByKey(formKey)) as FormResult | null;
+  }
+
+  getResourceByKey(resourceKey: string): ResourceResult | null {
+    return JSON.parse(
+      this.rm.getResourceByKey(resourceKey),
+    ) as ResourceResult | null;
+  }
+}
+
 /**
- * Create a fresh headless engine session. Ensures the wasm module is loaded
- * (once per page), then constructs a new {@link TestEngine}. The virtual clock
+ * Create a fresh headless engine session. Ensures the chosen wasm variant is
+ * loaded (once per page), then constructs a new `TestEngine`. The virtual clock
  * starts at 0; deploy a diagram before starting instances. Pass a `wasm` source
  * in environments where the default `import.meta.url` loader can't resolve the
  * binary (Node/Jest, or the external-`.wasm` mode — ADR 0043 §3).
+ *
+ * With `variant: "readmodel"` the returned session also exposes the gateway's
+ * REST read channel (typed {@link ReadModelBojtosSession}); the default `"lean"`
+ * variant is state-only and never downloads the heavier read-model binary. A
+ * statically-`"readmodel"` variant widens the return type; a value only known as
+ * the `EngineVariant` union resolves to the base {@link BojtosSession}.
  */
 export async function createBojtosSession(opts?: {
   wasm?: WasmSource;
+  variant?: "lean";
+}): Promise<BojtosSession>;
+export async function createBojtosSession(opts: {
+  wasm?: WasmSource;
+  variant: "readmodel";
+}): Promise<ReadModelBojtosSession>;
+export async function createBojtosSession(opts: {
+  wasm?: WasmSource;
+  variant: EngineVariant;
+}): Promise<BojtosSession>;
+export async function createBojtosSession(opts?: {
+  wasm?: WasmSource;
+  variant?: EngineVariant;
 }): Promise<BojtosSession> {
+  if (opts?.variant === "readmodel") {
+    const mod = await ensureReadModelWasm(opts.wasm);
+    return new WasmReadModelSession(new mod.TestEngine());
+  }
   await ensureWasm(opts?.wasm);
   return new WasmBojtosSession(new TestEngine());
 }