@sekiban/create-dcb 0.0.0-stage → 0.1.1

package/template/migrations/mv/0007_g69_ordering_quarantine.sql

@@ -0,0 +1,21 @@
+-- SDT-G69 consultation-003: an ordering detector quarantines only the
+-- affected active generation. A rebuild/promote moves the active pointer and
+-- resolves the old generation's quarantine without weakening frontier rules.
+CREATE TABLE mv_ordering_quarantines (
+  service_id TEXT NOT NULL,
+  view_id TEXT NOT NULL COLLATE BINARY,
+  generation INTEGER NOT NULL,
+  checkpoint_suid TEXT NOT NULL COLLATE BINARY,
+  late_suid TEXT NOT NULL COLLATE BINARY,
+  event_id TEXT NOT NULL COLLATE BINARY,
+  classification TEXT NOT NULL CHECK (classification IN ('LATE_LOWER_SUID', 'ORDER_VIOLATION')),
+  status TEXT NOT NULL DEFAULT 'open' CHECK (status IN ('open', 'resolved')),
+  observed_at INTEGER NOT NULL,
+  resolved_at INTEGER,
+  PRIMARY KEY (service_id, view_id, generation),
+  FOREIGN KEY (service_id, view_id, generation)
+    REFERENCES mv_instances (service_id, view_id, generation)
+    ON DELETE CASCADE
+);
+CREATE INDEX mv_ordering_quarantines_active_idx
+  ON mv_ordering_quarantines (service_id, view_id, status, generation);

package/template/migrations/mv/0008_g69_rebuild_verification.sql

@@ -0,0 +1,4 @@
+-- SDT-G69 F3: promotion may resolve an ordering quarantine only after the
+-- candidate has a durable, explicit rebuild proof. Existing generations are
+-- intentionally unverified until a complete catch-up records the marker.
+ALTER TABLE mv_instances ADD COLUMN rebuild_verified_at INTEGER;

package/template/migrations/mv/0009_g69_rebuild_proof.sql

@@ -0,0 +1,11 @@
+-- SDT-G69 F3: a rebuild proof is durable, generation-bound, and tied to the
+-- open ordering incident it repairs. The fields are populated only by the
+-- real MaterializedViewCatchUpRuntime rebuild path.
+ALTER TABLE mv_instances ADD COLUMN rebuild_recovery_id TEXT;
+ALTER TABLE mv_instances ADD COLUMN rebuild_incident_identity TEXT;
+ALTER TABLE mv_instances ADD COLUMN rebuild_incident_generation INTEGER;
+ALTER TABLE mv_instances ADD COLUMN rebuild_source_event_count INTEGER;
+ALTER TABLE mv_instances ADD COLUMN rebuild_source_max_suid TEXT;
+ALTER TABLE mv_instances ADD COLUMN rebuild_source_history_digest TEXT;
+
+ALTER TABLE mv_ordering_quarantines ADD COLUMN incident_identity TEXT;

package/template/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "private": true,
+  "description": "A named Sekiban Cloudflare booking starter.",
+  "type": "module",
+  "scripts": {
+    "migrate": "dcb-cloudflare migrate --config wrangler.jsonc",
+    "deploy": "dcb-cloudflare deploy --config wrangler.jsonc",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@sekiban/dcb-client": "0.2.0",
+    "@sekiban/dcb-core": "0.2.0",
+    "@sekiban/dcb-domain": "0.2.0",
+    "@sekiban/dcb-runtime": "0.2.0",
+    "@sekiban/dcb-cloudflare": "^0.1.0",
+    "wrangler": "4.125.0"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3",
+    "@cloudflare/workers-types": "5.20260820.1"
+  }
+}

package/template/public/.assetsignore

@@ -0,0 +1,2 @@
+cloudflare.config.ts
+wrangler.config.ts

package/template/public/app.js

@@ -0,0 +1,40 @@
+/* global document, fetch, FormData */
+
+const result = document.querySelector("#result");
+
+function show(value) {
+  result.textContent = JSON.stringify(value, null, 2);
+}
+
+async function request(path, init) {
+  const response = await fetch(path, init);
+  const body = await response.json().catch(() => ({ error: response.statusText }));
+  show(body);
+}
+
+for (const form of document.querySelectorAll("form[data-command]")) {
+  form.addEventListener("submit", async (event) => {
+    event.preventDefault();
+    const input = Object.fromEntries(new FormData(form).entries());
+    await request(`/api/commands/${form.dataset.command}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ input }),
+    });
+  });
+}
+
+for (const button of document.querySelectorAll("button[data-read]")) {
+  button.addEventListener("click", async () => {
+    const kind = button.dataset.read;
+    if (kind === "room") {
+      const id = document.querySelector("#room-read-id").value;
+      await request(`/api/read/room?roomId=${encodeURIComponent(id)}`);
+    } else if (kind === "reservation") {
+      const id = document.querySelector("#reservation-read-id").value;
+      await request(`/api/read/reservation?reservationId=${encodeURIComponent(id)}`);
+    } else {
+      await request("/api/read/reservations");
+    }
+  });
+}

package/template/public/index.html

@@ -0,0 +1,58 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>{{PROJECT_NAME}} booking</title>
+    <link rel="stylesheet" href="/styles.css">
+  </head>
+  <body>
+    <main class="shell">
+      <header>
+        <p class="eyebrow">{{PROJECT_NAME}}</p>
+        <h1>Book a room</h1>
+        <p>Create a room, reserve it, inspect its state, and release it. The small demo is intentionally easy to replace.</p>
+      </header>
+
+      <section class="grid">
+        <form data-command="create-room">
+          <h2>Create room</h2>
+          <label>Room ID <input name="roomId" required placeholder="room-1"></label>
+          <label>Name <input name="name" placeholder="North studio"></label>
+          <button>Create room</button>
+        </form>
+        <form data-command="reserve-room">
+          <h2>Reserve room</h2>
+          <label>Room ID <input name="roomId" required placeholder="room-1"></label>
+          <label>Reservation ID <input name="reservationId" required placeholder="reservation-1"></label>
+          <label>User ID <input name="userId" placeholder="alex"></label>
+          <button>Reserve</button>
+        </form>
+        <form data-command="cancel-reservation">
+          <h2>Cancel reservation</h2>
+          <label>Reservation ID <input name="reservationId" required placeholder="reservation-1"></label>
+          <button>Cancel</button>
+        </form>
+        <form data-command="release-room">
+          <h2>Release room</h2>
+          <label>Room ID <input name="roomId" required placeholder="room-1"></label>
+          <button>Release</button>
+        </form>
+      </section>
+
+      <section class="reads">
+        <h2>Reads</h2>
+        <div class="read-row">
+          <input id="room-read-id" placeholder="room ID">
+          <button data-read="room">Read room</button>
+          <input id="reservation-read-id" placeholder="reservation ID">
+          <button data-read="reservation">Read reservation</button>
+          <button data-read="reservations">List reservations</button>
+        </div>
+      </section>
+
+      <pre id="result" aria-live="polite">Ready.</pre>
+    </main>
+    <script type="module" src="/app.js"></script>
+  </body>
+</html>

package/template/public/styles.css

@@ -0,0 +1,20 @@
+:root {
+  color-scheme: light;
+  font-family: Inter, ui-sans-serif, system-ui, sans-serif;
+  background: #f3f5f8;
+  color: #172033;
+}
+
+body { margin: 0; }
+.shell { max-width: 980px; margin: 0 auto; padding: 48px 20px 72px; }
+.eyebrow { color: #5b61d6; font-size: .8rem; font-weight: 700; letter-spacing: .12em; text-transform: uppercase; }
+h1 { margin: 0 0 8px; font-size: clamp(2.2rem, 6vw, 4rem); }
+h2 { margin-top: 0; font-size: 1.1rem; }
+.grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(210px, 1fr)); gap: 16px; margin: 32px 0; }
+form, .reads { background: white; border: 1px solid #e2e6ef; border-radius: 14px; box-shadow: 0 8px 24px #1720330b; padding: 18px; }
+label { display: grid; gap: 6px; margin: 12px 0; font-size: .9rem; }
+input { border: 1px solid #cfd5e2; border-radius: 8px; box-sizing: border-box; padding: 10px; width: 100%; }
+button { background: #5b61d6; border: 0; border-radius: 8px; color: white; cursor: pointer; font: inherit; padding: 10px 14px; }
+.read-row { align-items: center; display: flex; flex-wrap: wrap; gap: 8px; }
+.read-row input { flex: 1 1 140px; width: auto; }
+pre { background: #172033; border-radius: 14px; color: #e8ecf5; margin-top: 24px; min-height: 100px; overflow: auto; padding: 18px; }

package/template/scripts/deploy.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "${BASH_SOURCE[0]}")/.."
+exec dcb-cloudflare deploy --config wrangler.jsonc

package/template/scripts/migrate.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "${BASH_SOURCE[0]}")/.."
+exec dcb-cloudflare migrate --config wrangler.jsonc

package/template/src/booking-domain.ts

@@ -0,0 +1,285 @@
+import { z } from "zod";
+import {
+  command,
+  done,
+  domain,
+  event,
+  evolve,
+  none,
+  projector,
+  read,
+  readSet,
+  reject,
+  stateUnion,
+  tagFamily,
+  toRuntimeDomain,
+  validate,
+  validationReject,
+  type DomainViewDefinition,
+  type ProjectorDefinition,
+  type ProjectorEvent,
+  type RejectKind,
+  type RuntimeDomainDefinition,
+} from "@sekiban/dcb-domain";
+
+const room = tagFamily("room");
+const reservation = tagFamily("reservation");
+
+export const roomTag = (roomId: string) => room.of(roomId);
+export const reservationTag = (reservationId: string) => reservation.of(reservationId);
+
+const roomInput = z.object({ roomId: z.string().min(1), name: z.string().optional() });
+const reservationInput = z.object({
+  roomId: z.string().min(1),
+  reservationId: z.string().min(1),
+  userId: z.string().optional(),
+});
+const reservationOnlyInput = z.object({ reservationId: z.string().min(1) });
+
+export type RoomInput = z.infer<typeof roomInput>;
+export type ReservationInput = z.infer<typeof reservationInput>;
+export type ReservationOnlyInput = z.infer<typeof reservationOnlyInput>;
+
+const roomCreated = event("RoomCreated", z.object({
+  roomId: z.string().min(1),
+  name: z.string(),
+}), { tags: (payload) => [room.of(payload.roomId)] });
+
+const roomReserved = event("RoomReserved", z.object({
+  roomId: z.string().min(1),
+  reservationId: z.string().min(1),
+  userId: z.string(),
+}), { tags: (payload) => [room.of(payload.roomId), reservation.of(payload.reservationId)] });
+
+const reservationCancelled = event("ReservationCancelled", z.object({
+  reservationId: z.string().min(1),
+  roomId: z.string().min(1).optional(),
+}), { tags: (payload) => [reservation.of(payload.reservationId)] });
+
+const roomReleased = event("RoomReleased", z.object({
+  roomId: z.string().min(1),
+}), { tags: (payload) => [room.of(payload.roomId)] });
+
+type RoomState =
+  | { readonly status: "empty"; readonly version: number; readonly roomId: null; readonly name: string }
+  | { readonly status: "created"; readonly version: number; readonly roomId: string; readonly name: string }
+  | { readonly status: "released"; readonly version: number; readonly roomId: string; readonly name: string };
+
+type ReservationState =
+  | { readonly status: "empty"; readonly version: number; readonly reservationId: null; readonly roomId: null }
+  | { readonly status: "reserved"; readonly version: number; readonly reservationId: string; readonly roomId: string }
+  | { readonly status: "cancelled"; readonly version: number; readonly reservationId: string; readonly roomId: string | null };
+
+const roomState = stateUnion(z.discriminatedUnion("status", [
+  z.object({ status: z.literal("empty"), version: z.number().int().nonnegative(), roomId: z.null(), name: z.string() }),
+  z.object({ status: z.literal("created"), version: z.number().int().nonnegative(), roomId: z.string(), name: z.string() }),
+  z.object({ status: z.literal("released"), version: z.number().int().nonnegative(), roomId: z.string(), name: z.string() }),
+]), { initial: { status: "empty", version: 0, roomId: null, name: "" } });
+
+const reservationState = stateUnion(z.discriminatedUnion("status", [
+  z.object({ status: z.literal("empty"), version: z.number().int().nonnegative(), reservationId: z.null(), roomId: z.null() }),
+  z.object({ status: z.literal("reserved"), version: z.number().int().nonnegative(), reservationId: z.string(), roomId: z.string() }),
+  z.object({ status: z.literal("cancelled"), version: z.number().int().nonnegative(), reservationId: z.string(), roomId: z.string().nullable() }),
+]), { initial: { status: "empty", version: 0, reservationId: null, roomId: null } });
+
+type RoomEvent = typeof roomCreated | typeof roomReleased;
+type ReservationEvent = typeof roomReserved | typeof reservationCancelled;
+
+function roomCreatedEvent(value: ProjectorEvent<RoomEvent>): ProjectorEvent<typeof roomCreated> {
+  return { definition: roomCreated, eventType: roomCreated.eventType, payload: roomCreated.make(value.payload), tags: value.tags };
+}
+
+function roomReleasedEvent(value: ProjectorEvent<RoomEvent>): ProjectorEvent<typeof roomReleased> {
+  return { definition: roomReleased, eventType: roomReleased.eventType, payload: roomReleased.make(value.payload), tags: value.tags };
+}
+
+function roomReservedEvent(value: ProjectorEvent<ReservationEvent>): ProjectorEvent<typeof roomReserved> {
+  return { definition: roomReserved, eventType: roomReserved.eventType, payload: roomReserved.make(value.payload), tags: value.tags };
+}
+
+function reservationCancelledEvent(value: ProjectorEvent<ReservationEvent>): ProjectorEvent<typeof reservationCancelled> {
+  return { definition: reservationCancelled, eventType: reservationCancelled.eventType, payload: reservationCancelled.make(value.payload), tags: value.tags };
+}
+
+export const validateCreateRoom = validate<RoomState, RoomInput, RejectKind>((state) =>
+  state.status === "empty" ? undefined : validationReject("conflict", "room already exists", "room_exists"));
+
+export const validateReserveRoom = validate<RoomState, ReservationInput, RejectKind>((state) =>
+  state.status === "empty" ? validationReject("not-found", "room does not exist", "room_missing") : undefined);
+
+export const validateCancelReservation = validate<ReservationState, ReservationOnlyInput, RejectKind>((state) =>
+  state.status === "empty" ? validationReject("not-found", "reservation does not exist", "reservation_missing") : undefined);
+
+export const validateReleaseRoom = validate<RoomState, RoomInput, RejectKind>((state) =>
+  state.status === "empty" ? validationReject("not-found", "room does not exist", "room_missing") : undefined);
+
+export const evolveRoomCreated = evolve<RoomState, typeof roomCreated>((state, value) => {
+  const payload = roomCreated.parse(value.payload);
+  return { status: "created", version: state.version + 1, roomId: payload.roomId, name: payload.name };
+});
+
+export const evolveRoomReleased = evolve<RoomState, typeof roomReleased>((state) => {
+  if (state.status === "empty") return state;
+  return { status: "released", version: state.version + 1, roomId: state.roomId, name: state.name };
+});
+
+export const evolveRoomReserved = evolve<ReservationState, typeof roomReserved>((state, value) => {
+  const payload = roomReserved.parse(value.payload);
+  return { status: "reserved", version: state.version + 1, reservationId: payload.reservationId, roomId: payload.roomId };
+});
+
+export const evolveReservationCancelled = evolve<ReservationState, typeof reservationCancelled>((state) => {
+  if (state.status === "empty") return state;
+  return { status: "cancelled", version: state.version + 1, reservationId: state.reservationId, roomId: state.roomId };
+});
+
+const roomProjector: ProjectorDefinition<RoomState, "room", [typeof roomCreated, typeof roomReleased]> = projector({
+  id: "RoomProjector",
+  version: 1,
+  tag: room,
+  state: roomState,
+  events: [roomCreated, roomReleased],
+  handlers: {
+    RoomCreated: (state, value) => evolveRoomCreated(state, roomCreatedEvent(value)),
+    RoomReleased: (state, value) => evolveRoomReleased(state, roomReleasedEvent(value)),
+  },
+});
+
+const reservationProjector: ProjectorDefinition<ReservationState, "reservation", [typeof roomReserved, typeof reservationCancelled]> = projector({
+  id: "ReservationProjector",
+  version: 1,
+  tag: reservation,
+  state: reservationState,
+  events: [roomReserved, reservationCancelled],
+  handlers: {
+    RoomReserved: (state, value) => evolveRoomReserved(state, roomReservedEvent(value)),
+    ReservationCancelled: (state, value) => evolveReservationCancelled(state, reservationCancelledEvent(value)),
+  },
+});
+
+function validationDecision(result: {
+  readonly kind: "reject";
+  readonly rejectKind: RejectKind;
+  readonly reason: string;
+  readonly details?: unknown;
+} | undefined) {
+  return result === undefined ? undefined : reject(result.rejectKind, result.reason, result.details);
+}
+
+export const createRoomCommand = command({
+  id: "create-room",
+  input: roomInput,
+  reads: (input) => read(roomProjector, roomTag(input.roomId)),
+  handle: async (input, context) => {
+    const state = await context.state(roomProjector, roomTag(input.roomId));
+    const invalid = validationDecision(validateCreateRoom(state, input));
+    if (invalid !== undefined) return invalid;
+    context.append(roomCreated, roomCreated.make({ roomId: input.roomId, name: input.name ?? "" }));
+    return done({ roomId: input.roomId, name: input.name ?? "" });
+  },
+});
+
+export const reserveRoomCommand = command({
+  id: "reserve-room",
+  input: reservationInput,
+  reads: (input) => readSet(
+    read(roomProjector, roomTag(input.roomId)),
+    read(reservationProjector, reservationTag(input.reservationId)),
+  ),
+  handle: async (input, context) => {
+    const roomValue = await context.state(roomProjector, roomTag(input.roomId));
+    const invalid = validationDecision(validateReserveRoom(roomValue, input));
+    if (invalid !== undefined) return invalid;
+    const reservationValue = await context.state(reservationProjector, reservationTag(input.reservationId));
+    if (reservationValue.status !== "empty") return reject("conflict", "reservation already exists", "reservation_exists");
+    context.append(roomReserved, roomReserved.make({
+      roomId: input.roomId,
+      reservationId: input.reservationId,
+      userId: input.userId ?? "",
+    }));
+    return done({ roomId: input.roomId, reservationId: input.reservationId });
+  },
+});
+
+export const cancelReservationCommand = command({
+  id: "cancel-reservation",
+  input: reservationOnlyInput,
+  reads: (input) => read(reservationProjector, reservationTag(input.reservationId)),
+  handle: async (input, context) => {
+    const state = await context.state(reservationProjector, reservationTag(input.reservationId));
+    const invalid = validationDecision(validateCancelReservation(state, input));
+    if (invalid !== undefined) return invalid;
+    const roomId = state.status === "empty" ? undefined : state.roomId;
+    context.append(reservationCancelled, reservationCancelled.make({
+      reservationId: input.reservationId,
+      ...(roomId === null || roomId === undefined ? {} : { roomId }),
+    }));
+    return done({ reservationId: input.reservationId });
+  },
+});
+
+export const releaseRoomCommand = command({
+  id: "release-room",
+  input: roomInput,
+  reads: (input) => read(roomProjector, roomTag(input.roomId)),
+  handle: async (input, context) => {
+    const state = await context.state(roomProjector, roomTag(input.roomId));
+    const invalid = validationDecision(validateReleaseRoom(state, input));
+    if (invalid !== undefined) return invalid;
+    if (state.status === "released") return none("room is already released");
+    context.append(roomReleased, roomReleased.make({ roomId: input.roomId }));
+    return done({ roomId: input.roomId });
+  },
+});
+
+const roomQuery = {
+  id: "GetRoomStateQuery",
+  version: 1,
+  queryType: "GetRoomStateQuery",
+  endpoint: "query",
+  tagGroup: "room",
+  tagProjector: "RoomProjector",
+} satisfies { readonly id: string; readonly version: number; readonly queryType: string; readonly endpoint: "query"; readonly tagGroup: string; readonly tagProjector: string };
+
+const reservationQuery = {
+  id: "GetReservationListQuery",
+  version: 1,
+  queryType: "GetReservationListQuery",
+  endpoint: "list-query",
+  tagGroup: "reservation",
+  tagProjector: "ReservationProjector",
+} satisfies { readonly id: string; readonly version: number; readonly queryType: string; readonly endpoint: "list-query"; readonly tagGroup: string; readonly tagProjector: string };
+
+export const bookingViews = Object.freeze([
+  { id: "RoomProjector", source: "RoomProjector", projector: "RoomProjector", deliveryClass: "immediate-preferred" },
+  { id: "ReservationProjector", source: "ReservationProjector", projector: "ReservationProjector", deliveryClass: "immediate-preferred" },
+] satisfies readonly DomainViewDefinition[]);
+
+export const bookingAuthoringDomain = domain({
+  events: [roomCreated, roomReserved, reservationCancelled, roomReleased],
+  commands: [createRoomCommand, reserveRoomCommand, cancelReservationCommand, releaseRoomCommand],
+  projectors: [roomProjector, reservationProjector],
+  views: bookingViews,
+});
+
+export const bookingDomain: RuntimeDomainDefinition = toRuntimeDomain(bookingAuthoringDomain);
+
+export const bookingRuntimeConfig = {
+  deliveryClass: "immediate-preferred",
+  projectorPayloadNames: { RoomProjector: "RoomState", ReservationProjector: "ReservationState" },
+  queries: [roomQuery, reservationQuery],
+} satisfies {
+  readonly deliveryClass: "immediate-preferred" | "queued";
+  readonly projectorPayloadNames: Readonly<Record<string, string>>;
+  readonly queries: readonly {
+    readonly id: string;
+    readonly version: number;
+    readonly queryType: string;
+    readonly endpoint: "query" | "list-query";
+    readonly tagGroup: string;
+    readonly tagProjector: string;
+  }[];
+};
+
+export const bookingProjectors = { roomProjector, reservationProjector };
+export const bookingCommands = { createRoomCommand, reserveRoomCommand, cancelReservationCommand, releaseRoomCommand };

package/template/src/booking-mv.ts

@@ -0,0 +1,166 @@
+import { defineRowMaterializer } from "@sekiban/dcb-core";
+import { createD1StoreProvider } from "@sekiban/dcb-runtime/d1";
+import {
+  D1MaterializedViewStore,
+  MaterializedViewCatchUpRuntime,
+  type DeliveryViewFailureClass,
+  type DeliveryViewHandler,
+  type StoredEvent,
+} from "@sekiban/dcb-runtime/d1-mv";
+
+export interface BookingDataEnvironment {
+  readonly D1?: D1Database;
+  readonly D1_MV?: D1Database;
+  readonly SDT_SERVICE_ID?: string;
+}
+
+function objectPayload(event: StoredEvent): Record<string, unknown> {
+  const value: unknown = JSON.parse(event.payload);
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function stringField(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+export const reservationMaterializer = defineRowMaterializer<StoredEvent>({
+  id: "ReservationProjector",
+  version: 1,
+  indexDescriptors: [{ id: "reservation-id", valueType: "text", value: (row) => (row as { reservationId?: unknown }).reservationId }],
+  materialize: (event) => {
+    if (!event.eventTags.some((tag) => tag.startsWith("reservation:"))) return {};
+    const payload = objectPayload(event);
+    const reservationId = stringField(payload.reservationId);
+    if (reservationId === undefined) return {};
+    if (event.eventType === "ReservationCancelled") {
+      return {
+        rowPatches: [{
+          kind: "json_patch" as const,
+          rowKey: reservationId,
+          patch: { status: "cancelled" },
+          rowVersion: 2,
+        }],
+      };
+    }
+    if (event.eventType !== "RoomReserved") return {};
+    return {
+      rowUpserts: [{
+        rowKey: reservationId,
+        value: {
+          reservationId,
+          roomId: stringField(payload.roomId) ?? "",
+          userId: stringField(payload.userId) ?? "",
+          status: "reserved",
+          version: 1,
+        },
+      }],
+    };
+  },
+});
+
+export const roomMaterializer = defineRowMaterializer<StoredEvent>({
+  id: "RoomProjector",
+  version: 1,
+  indexDescriptors: [{ id: "room-id", valueType: "text", value: (row) => (row as { roomId?: unknown }).roomId }],
+  materialize: (event) => {
+    if (!event.eventTags.some((tag) => tag.startsWith("room:"))) return {};
+    const payload = objectPayload(event);
+    const roomId = stringField(payload.roomId);
+    if (roomId === undefined || (event.eventType !== "RoomCreated" && event.eventType !== "RoomReleased")) return {};
+    return {
+      rowUpserts: [{
+        rowKey: roomId,
+        value: {
+          roomId,
+          name: stringField(payload.name) ?? "",
+          status: event.eventType === "RoomCreated" ? "created" : "released",
+          version: event.eventType === "RoomCreated" ? 1 : 2,
+        },
+      }],
+    };
+  },
+});
+
+const materializers = [reservationMaterializer, roomMaterializer] as const;
+
+function requiredEnvironment(env: BookingDataEnvironment): { readonly D1: D1Database; readonly D1_MV: D1Database } {
+  if (env.D1 === undefined || env.D1_MV === undefined) throw new Error("Booking materializers require D1 and D1_MV bindings");
+  return { D1: env.D1, D1_MV: env.D1_MV };
+}
+
+async function open(env: BookingDataEnvironment): Promise<{
+  readonly views: D1MaterializedViewStore;
+  readonly runtime: MaterializedViewCatchUpRuntime;
+}> {
+  const bindings = requiredEnvironment(env);
+  const provider = createD1StoreProvider();
+  const source = provider.create(bindings);
+  await source.initialize();
+  const views = new D1MaterializedViewStore(bindings.D1_MV);
+  await views.initialize();
+  return { views, runtime: new MaterializedViewCatchUpRuntime(source, views) };
+}
+
+export async function ensureBookingViews(env: BookingDataEnvironment, serviceId: string): Promise<void> {
+  const opened = await open(env);
+  for (const materializer of materializers) {
+    if (await opened.views.readActive(serviceId, materializer.id) === undefined) {
+      await opened.runtime.build(serviceId, materializer, Date.now());
+    }
+  }
+}
+
+export async function catchUpBookingViews(env: BookingDataEnvironment, serviceId: string): Promise<void> {
+  const opened = await open(env);
+  for (const materializer of materializers) {
+    if (await opened.views.readActive(serviceId, materializer.id) === undefined) {
+      await opened.runtime.build(serviceId, materializer, Date.now());
+    } else {
+      await opened.runtime.follow(serviceId, materializer, Date.now());
+    }
+  }
+}
+
+export function bookingDeliveryViews(env: BookingDataEnvironment): readonly DeliveryViewHandler[] {
+  let opened: Promise<Awaited<ReturnType<typeof open>>> | undefined;
+  const context = async () => {
+    opened ??= (async () => {
+      const value = await open(env);
+      const serviceId = env.SDT_SERVICE_ID;
+      if (serviceId === undefined || serviceId.length === 0) throw new Error("SDT_SERVICE_ID is required");
+      await ensureBookingViews(env, serviceId);
+      return value;
+    })();
+    return opened;
+  };
+  return materializers.map((materializer) => ({
+    id: materializer.id,
+    admission: "independent-unsafe" as const,
+    apply: async ({ event, arrivedAt }) => {
+      const value = await context();
+      const serviceId = env.SDT_SERVICE_ID;
+      if (serviceId === undefined || serviceId.length === 0) throw new Error("SDT_SERVICE_ID is required");
+      const active = await value.views.readActive(serviceId, materializer.id);
+      if (active === undefined) throw new Error(`Materialized view ${materializer.id} is not initialized`);
+      const result = await value.views.unsafeWindow().apply({
+        serviceId,
+        viewId: materializer.id,
+        generation: active.generation,
+        eventId: event.eventId,
+        suid: event.suid,
+        safeHead: active.lastSuid,
+        updatedAt: arrivedAt,
+        recordArrival: true,
+        mutations: materializer.plan(event),
+        targetSuid: event.suid,
+      });
+      return result.duplicate ? "duplicate-race" : "applied";
+    },
+    classifyError: (error: unknown): DeliveryViewFailureClass => {
+      const typed = error as { readonly code?: unknown; readonly retryable?: unknown };
+      if (typed.code === "UNSAFE_DUPLICATE_RACE") return "duplicate-race";
+      if (typed.retryable === false) return "nonretryable-definition-poison";
+      return "retryable-transient";
+    },
+  }));
+}