@korajs/server 0.3.0 → 0.3.2

package/dist/index.js

@@ -1,10 +1,154 @@
 // src/store/memory-server-store.ts
 import { generateUUIDv7 } from "@korajs/core";
+
+// src/store/materialization.ts
+function fieldTypeToSql(descriptor, dialect) {
+  switch (descriptor.kind) {
+    case "string":
+      return "TEXT";
+    case "number":
+      return dialect === "postgres" ? "DOUBLE PRECISION" : "REAL";
+    case "boolean":
+      return "INTEGER";
+    case "enum":
+      return "TEXT";
+    case "timestamp":
+      return dialect === "postgres" ? "BIGINT" : "INTEGER";
+    case "array":
+      return dialect === "postgres" ? "JSONB" : "TEXT";
+    case "richtext":
+      return dialect === "postgres" ? "BYTEA" : "BLOB";
+  }
+}
+function sqlDefaultLiteral(value) {
+  if (value === null) return "NULL";
+  if (typeof value === "string") return `'${value}'`;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return `'${JSON.stringify(value)}'`;
+}
+function generateCollectionDDL(name, collection, dialect) {
+  const statements = [];
+  const columns = ["id TEXT PRIMARY KEY NOT NULL"];
+  for (const [fieldName, descriptor] of Object.entries(collection.fields)) {
+    const sqlType = fieldTypeToSql(descriptor, dialect);
+    let colDef = `${fieldName} ${sqlType}`;
+    if (descriptor.defaultValue !== void 0) {
+      colDef += ` DEFAULT ${sqlDefaultLiteral(descriptor.defaultValue)}`;
+    }
+    if (descriptor.kind === "enum" && descriptor.enumValues) {
+      const values = descriptor.enumValues.map((v) => `'${v}'`).join(", ");
+      colDef += ` CHECK (${fieldName} IN (${values}))`;
+    }
+    columns.push(colDef);
+  }
+  const tsType = dialect === "postgres" ? "BIGINT" : "INTEGER";
+  columns.push(`_created_at ${tsType} NOT NULL DEFAULT 0`);
+  columns.push(`_updated_at ${tsType} NOT NULL DEFAULT 0`);
+  columns.push("_deleted INTEGER NOT NULL DEFAULT 0");
+  statements.push(`CREATE TABLE IF NOT EXISTS ${name} (
+  ${columns.join(",\n  ")}
+)`);
+  for (const [fieldName, descriptor] of Object.entries(collection.fields)) {
+    const sqlType = fieldTypeToSql(descriptor, dialect);
+    let colDef = `${fieldName} ${sqlType}`;
+    if (descriptor.defaultValue !== void 0) {
+      colDef += ` DEFAULT ${sqlDefaultLiteral(descriptor.defaultValue)}`;
+    }
+    statements.push(`--kora:safe-alter
+ALTER TABLE ${name} ADD COLUMN ${colDef}`);
+  }
+  for (const indexField of collection.indexes) {
+    statements.push(
+      `CREATE INDEX IF NOT EXISTS idx_${name}_${indexField} ON ${name} (${indexField})`
+    );
+  }
+  statements.push(
+    `CREATE INDEX IF NOT EXISTS idx_${name}__deleted ON ${name} (_deleted)`
+  );
+  return statements;
+}
+function generateAllCollectionDDL(schema, dialect) {
+  const statements = [];
+  for (const [name, collection] of Object.entries(schema.collections)) {
+    statements.push(...generateCollectionDDL(name, collection, dialect));
+  }
+  return statements;
+}
+function replayOperationsForRecord(ops) {
+  let record = null;
+  let deleted = false;
+  for (const op of ops) {
+    switch (op.type) {
+      case "insert":
+        if (op.data) {
+          record = { ...op.data };
+          deleted = false;
+        }
+        break;
+      case "update":
+        if (op.data) {
+          record = { ...record ?? {}, ...op.data };
+          deleted = false;
+        }
+        break;
+      case "delete":
+        deleted = true;
+        break;
+    }
+  }
+  return deleted ? null : record;
+}
+function serializeFieldValue(value, descriptor) {
+  if (value === null || value === void 0) return null;
+  switch (descriptor.kind) {
+    case "array":
+      return typeof value === "string" ? value : JSON.stringify(value);
+    case "boolean":
+      return value ? 1 : 0;
+    default:
+      return value;
+  }
+}
+function deserializeFieldValue(value, descriptor) {
+  if (value === null || value === void 0) return null;
+  switch (descriptor.kind) {
+    case "array":
+      return typeof value === "string" ? JSON.parse(value) : value;
+    case "boolean":
+      return value === 1 || value === true;
+    default:
+      return value;
+  }
+}
+function validateFieldName(collectionName, fieldName, schema) {
+  const collection = schema.collections[collectionName];
+  if (!collection) {
+    throw new Error(`Unknown collection: ${collectionName}`);
+  }
+  const validFields = /* @__PURE__ */ new Set([
+    "id",
+    "_created_at",
+    "_updated_at",
+    "_deleted",
+    ...Object.keys(collection.fields)
+  ]);
+  if (!validFields.has(fieldName)) {
+    throw new Error(
+      `Invalid field name "${fieldName}" for collection "${collectionName}". Valid fields: ${Array.from(validFields).join(", ")}`
+    );
+  }
+}
+
+// src/store/memory-server-store.ts
 var MemoryServerStore = class {
   nodeId;
   operations = [];
   operationIndex = /* @__PURE__ */ new Map();
   versionVector = /* @__PURE__ */ new Map();
+  schema = null;
+  /** Materialized records: collection -> recordId -> record data */
+  materializedRecords = /* @__PURE__ */ new Map();
   closed = false;
   constructor(nodeId) {
     this.nodeId = nodeId ?? generateUUIDv7();
@@ -15,6 +159,16 @@ var MemoryServerStore = class {
   getNodeId() {
     return this.nodeId;
   }
+  async setSchema(schema) {
+    this.assertOpen();
+    this.schema = schema;
+    for (const collectionName of Object.keys(schema.collections)) {
+      if (!this.materializedRecords.has(collectionName)) {
+        this.materializedRecords.set(collectionName, /* @__PURE__ */ new Map());
+      }
+    }
+    this.backfillAllCollections();
+  }
   async applyRemoteOperation(op) {
     this.assertOpen();
     if (this.operationIndex.has(op.id)) {
@@ -26,6 +180,9 @@ var MemoryServerStore = class {
     if (op.sequenceNumber > currentSeq) {
       this.versionVector.set(op.nodeId, op.sequenceNumber);
     }
+    if (this.schema && this.schema.collections[op.collection]) {
+      this.rebuildMaterializedRecord(op.collection, op.recordId);
+    }
     return "applied";
   }
   async getOperationRange(nodeId, fromSeq, toSeq) {
@@ -38,6 +195,114 @@ var MemoryServerStore = class {
     this.assertOpen();
     return this.operations.length;
   }
+  async materializeCollection(collection) {
+    this.assertOpen();
+    if (this.schema && this.schema.collections[collection]) {
+      return this.queryCollection(collection);
+    }
+    return this.materializeFromOps(collection);
+  }
+  async queryCollection(collection, options) {
+    this.assertOpen();
+    this.assertSchema();
+    this.assertCollection(collection);
+    if (options?.where) {
+      for (const key of Object.keys(options.where)) {
+        validateFieldName(collection, key, this.schema);
+      }
+    }
+    if (options?.orderBy) {
+      validateFieldName(collection, options.orderBy, this.schema);
+    }
+    const collectionMap = this.materializedRecords.get(collection);
+    if (!collectionMap) return [];
+    let records = Array.from(collectionMap.values()).filter((r) => {
+      if (!options?.includeDeleted && r._deleted === 1) return false;
+      return true;
+    });
+    if (options?.where) {
+      for (const [key, value] of Object.entries(options.where)) {
+        records = records.filter((r) => r[key] === value);
+      }
+    }
+    if (options?.orderBy) {
+      const field = options.orderBy;
+      const dir = options.orderDirection === "desc" ? -1 : 1;
+      records.sort((a, b) => {
+        const aVal = a[field];
+        const bVal = b[field];
+        if (aVal === bVal) return 0;
+        if (aVal === null || aVal === void 0) return 1;
+        if (bVal === null || bVal === void 0) return -1;
+        return aVal < bVal ? -1 * dir : 1 * dir;
+      });
+    }
+    if (options?.offset !== void 0) {
+      records = records.slice(options.offset);
+    }
+    if (options?.limit !== void 0) {
+      records = records.slice(0, options.limit);
+    }
+    return records.map((r) => {
+      const clean = { id: r.id };
+      const collectionDef = this.schema.collections[collection];
+      for (const fieldName of Object.keys(collectionDef.fields)) {
+        if (fieldName in r) {
+          clean[fieldName] = r[fieldName];
+        }
+      }
+      if ("_created_at" in r) clean._created_at = r._created_at;
+      if ("_updated_at" in r) clean._updated_at = r._updated_at;
+      return clean;
+    });
+  }
+  async findRecord(collection, id) {
+    this.assertOpen();
+    this.assertSchema();
+    this.assertCollection(collection);
+    const collectionMap = this.materializedRecords.get(collection);
+    if (!collectionMap) return null;
+    const record = collectionMap.get(id);
+    if (!record || record._deleted === 1) return null;
+    const clean = { id: record.id };
+    const collectionDef = this.schema.collections[collection];
+    for (const fieldName of Object.keys(collectionDef.fields)) {
+      if (fieldName in record) {
+        clean[fieldName] = record[fieldName];
+      }
+    }
+    if ("_created_at" in record) clean._created_at = record._created_at;
+    if ("_updated_at" in record) clean._updated_at = record._updated_at;
+    return clean;
+  }
+  async countCollection(collection, where) {
+    this.assertOpen();
+    this.assertSchema();
+    this.assertCollection(collection);
+    if (where) {
+      for (const key of Object.keys(where)) {
+        validateFieldName(collection, key, this.schema);
+      }
+    }
+    const collectionMap = this.materializedRecords.get(collection);
+    if (!collectionMap) return 0;
+    let count3 = 0;
+    for (const record of collectionMap.values()) {
+      if (record._deleted === 1) continue;
+      if (where) {
+        let matches = true;
+        for (const [key, value] of Object.entries(where)) {
+          if (record[key] !== value) {
+            matches = false;
+            break;
+          }
+        }
+        if (!matches) continue;
+      }
+      count3++;
+    }
+    return count3;
+  }
   async close() {
     this.closed = true;
   }
@@ -48,11 +313,124 @@ var MemoryServerStore = class {
   getAllOperations() {
     return [...this.operations];
   }
+  // ---------------------------------------------------------------------------
+  // Materialization internals
+  // ---------------------------------------------------------------------------
+  rebuildMaterializedRecord(collection, recordId) {
+    const collectionDef = this.schema.collections[collection];
+    if (!collectionDef) return;
+    let collectionMap = this.materializedRecords.get(collection);
+    if (!collectionMap) {
+      collectionMap = /* @__PURE__ */ new Map();
+      this.materializedRecords.set(collection, collectionMap);
+    }
+    const recordOps = this.operations.filter((op) => op.collection === collection && op.recordId === recordId).sort((a, b) => {
+      if (a.timestamp.wallTime !== b.timestamp.wallTime) return a.timestamp.wallTime - b.timestamp.wallTime;
+      if (a.timestamp.logical !== b.timestamp.logical) return a.timestamp.logical - b.timestamp.logical;
+      return a.sequenceNumber - b.sequenceNumber;
+    });
+    const parsedOps = recordOps.map((op) => ({
+      type: op.type,
+      data: op.data
+    }));
+    const recordData = replayOperationsForRecord(parsedOps);
+    if (recordData) {
+      const createdAt = recordOps.length > 0 ? recordOps[0].timestamp.wallTime : Date.now();
+      const updatedAt = recordOps.length > 0 ? recordOps[recordOps.length - 1].timestamp.wallTime : Date.now();
+      const materialized = {
+        id: recordId,
+        ...recordData,
+        _created_at: createdAt,
+        _updated_at: updatedAt,
+        _deleted: 0
+      };
+      collectionMap.set(recordId, materialized);
+    } else {
+      const existing = collectionMap.get(recordId);
+      if (existing) {
+        existing._deleted = 1;
+        existing._updated_at = Date.now();
+      } else {
+        collectionMap.set(recordId, {
+          id: recordId,
+          _deleted: 1,
+          _created_at: Date.now(),
+          _updated_at: Date.now()
+        });
+      }
+    }
+  }
+  backfillAllCollections() {
+    if (!this.schema) return;
+    const recordKeys = /* @__PURE__ */ new Set();
+    for (const op of this.operations) {
+      if (this.schema.collections[op.collection]) {
+        recordKeys.add(`${op.collection}:::${op.recordId}`);
+      }
+    }
+    for (const key of recordKeys) {
+      const [collection, recordId] = key.split(":::");
+      this.rebuildMaterializedRecord(collection, recordId);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Fallback materialization (no schema)
+  // ---------------------------------------------------------------------------
+  materializeFromOps(collection) {
+    const collectionOps = this.operations.filter((op) => op.collection === collection).sort((a, b) => {
+      if (a.timestamp.wallTime !== b.timestamp.wallTime) return a.timestamp.wallTime - b.timestamp.wallTime;
+      if (a.timestamp.logical !== b.timestamp.logical) return a.timestamp.logical - b.timestamp.logical;
+      return a.sequenceNumber - b.sequenceNumber;
+    });
+    const records = /* @__PURE__ */ new Map();
+    const deleted = /* @__PURE__ */ new Set();
+    for (const op of collectionOps) {
+      switch (op.type) {
+        case "insert":
+          if (op.data) {
+            records.set(op.recordId, { id: op.recordId, ...op.data });
+            deleted.delete(op.recordId);
+          }
+          break;
+        case "update":
+          if (op.data) {
+            const existing = records.get(op.recordId) ?? { id: op.recordId };
+            records.set(op.recordId, { ...existing, ...op.data });
+            deleted.delete(op.recordId);
+          }
+          break;
+        case "delete":
+          deleted.add(op.recordId);
+          break;
+      }
+    }
+    for (const id of deleted) {
+      records.delete(id);
+    }
+    return Array.from(records.values());
+  }
+  // ---------------------------------------------------------------------------
+  // Assertions
+  // ---------------------------------------------------------------------------
   assertOpen() {
     if (this.closed) {
       throw new Error("MemoryServerStore is closed");
     }
   }
+  assertSchema() {
+    if (!this.schema) {
+      throw new Error(
+        "Schema not set. Call setSchema() before using queryCollection/findRecord/countCollection."
+      );
+    }
+  }
+  assertCollection(collection) {
+    if (!this.schema.collections[collection]) {
+      throw new Error(
+        `Unknown collection "${collection}". Available: ${Object.keys(this.schema.collections).join(", ")}`
+      );
+    }
+  }
 };
 
 // src/store/postgres-server-store.ts
@@ -60,7 +438,7 @@ import { generateUUIDv7 as generateUUIDv72 } from "@korajs/core";
 import { and, asc, between, count, eq, sql } from "drizzle-orm";
 
 // src/store/drizzle-pg-schema.ts
-import { index, integer, pgTable, text } from "drizzle-orm/pg-core";
+import { bigint, index, integer, pgTable, text } from "drizzle-orm/pg-core";
 var pgOperations = pgTable(
   "operations",
   {
@@ -73,14 +451,14 @@ var pgOperations = pgTable(
     // JSON-serialized, null for deletes
     previousData: text("previous_data"),
     // JSON-serialized, null for insert/delete
-    wallTime: integer("wall_time").notNull(),
+    wallTime: bigint("wall_time", { mode: "number" }).notNull(),
     logical: integer("logical").notNull(),
     timestampNodeId: text("timestamp_node_id").notNull(),
     sequenceNumber: integer("sequence_number").notNull(),
     causalDeps: text("causal_deps").notNull().default("[]"),
     // JSON array of op IDs
     schemaVersion: integer("schema_version").notNull(),
-    receivedAt: integer("received_at").notNull()
+    receivedAt: bigint("received_at", { mode: "number" }).notNull()
   },
   (table) => ({
     nodeSeqIdx: index("idx_pg_node_seq").on(table.nodeId, table.sequenceNumber),
@@ -91,7 +469,7 @@ var pgOperations = pgTable(
 var pgSyncState = pgTable("sync_state", {
   nodeId: text("node_id").primaryKey(),
   maxSequenceNumber: integer("max_sequence_number").notNull(),
-  lastSeenAt: integer("last_seen_at").notNull()
+  lastSeenAt: bigint("last_seen_at", { mode: "number" }).notNull()
 });
 
 // src/store/postgres-server-store.ts
@@ -100,6 +478,7 @@ var PostgresServerStore = class {
   db;
   versionVector = /* @__PURE__ */ new Map();
   ready;
+  schema = null;
   closed = false;
   constructor(db, nodeId) {
     this.db = db;
@@ -113,6 +492,27 @@ var PostgresServerStore = class {
   getNodeId() {
     return this.nodeId;
   }
+  async setSchema(schema) {
+    this.assertOpen();
+    await this.ready;
+    this.schema = schema;
+    const ddlStatements = generateAllCollectionDDL(schema, "postgres");
+    for (const stmt of ddlStatements) {
+      if (stmt.startsWith("--kora:safe-alter")) {
+        const alterSql = stmt.replace("--kora:safe-alter\n", "");
+        try {
+          await this.db.execute(sql.raw(alterSql));
+        } catch (e) {
+          if (!(e instanceof Error && (e.message.includes("already exists") || e.message.includes("duplicate column")))) {
+            throw e;
+          }
+        }
+      } else {
+        await this.db.execute(sql.raw(stmt));
+      }
+    }
+    await this.backfillAllCollections();
+  }
   async applyRemoteOperation(op) {
     this.assertOpen();
     await this.ready;
@@ -135,6 +535,9 @@ var PostgresServerStore = class {
           lastSeenAt: sql`${now}`
         }
       });
+      if (this.schema && this.schema.collections[op.collection]) {
+        await this.rebuildMaterializedRecord(tx, op.collection, op.recordId);
+      }
     });
     const currentMax = this.versionVector.get(op.nodeId) ?? 0;
     if (op.sequenceNumber > currentMax) {
@@ -159,9 +562,291 @@ var PostgresServerStore = class {
     const result = await this.db.select({ value: count() }).from(pgOperations);
     return result[0]?.value ?? 0;
   }
+  async materializeCollection(collection) {
+    this.assertOpen();
+    await this.ready;
+    if (this.schema && this.schema.collections[collection]) {
+      return this.queryCollection(collection);
+    }
+    return this.materializeFromOpsLog(collection);
+  }
+  async queryCollection(collection, options) {
+    this.assertOpen();
+    await this.ready;
+    this.assertSchema();
+    this.assertCollection(collection);
+    const collectionDef = this.schema.collections[collection];
+    if (options?.where) {
+      for (const key of Object.keys(options.where)) {
+        validateFieldName(collection, key, this.schema);
+      }
+    }
+    if (options?.orderBy) {
+      validateFieldName(collection, options.orderBy, this.schema);
+    }
+    const query = this.buildSelectQuery(collection, options);
+    const rows = await this.db.execute(query);
+    return rows.map((row) => this.deserializeRow(row, collectionDef));
+  }
+  async findRecord(collection, id) {
+    this.assertOpen();
+    await this.ready;
+    this.assertSchema();
+    this.assertCollection(collection);
+    const collectionDef = this.schema.collections[collection];
+    const query = sql`SELECT * FROM ${sql.raw(collection)} WHERE id = ${id} AND _deleted = 0`;
+    const rows = await this.db.execute(query);
+    if (rows.length === 0) return null;
+    return this.deserializeRow(rows[0], collectionDef);
+  }
+  async countCollection(collection, where) {
+    this.assertOpen();
+    await this.ready;
+    this.assertSchema();
+    this.assertCollection(collection);
+    if (where) {
+      for (const key of Object.keys(where)) {
+        validateFieldName(collection, key, this.schema);
+      }
+    }
+    const whereClause = this.buildWhereClause(where ?? {}, false);
+    const query = sql`SELECT COUNT(*) as cnt FROM ${sql.raw(collection)} WHERE ${whereClause}`;
+    const rows = await this.db.execute(query);
+    const cnt = rows[0]?.cnt;
+    return typeof cnt === "string" ? Number.parseInt(cnt, 10) : cnt ?? 0;
+  }
   async close() {
     this.closed = true;
   }
+  // ---------------------------------------------------------------------------
+  // Materialization internals
+  // ---------------------------------------------------------------------------
+  /**
+   * Rebuild a single record in the materialized collection table by replaying
+   * all operations for that record.
+   */
+  async rebuildMaterializedRecord(txOrDb, collection, recordId) {
+    const collectionDef = this.schema.collections[collection];
+    if (!collectionDef) return;
+    const ops = await txOrDb.select({
+      type: pgOperations.type,
+      data: pgOperations.data,
+      wallTime: pgOperations.wallTime
+    }).from(pgOperations).where(
+      and(
+        eq(pgOperations.collection, collection),
+        eq(pgOperations.recordId, recordId)
+      )
+    ).orderBy(
+      asc(pgOperations.wallTime),
+      asc(pgOperations.logical),
+      asc(pgOperations.sequenceNumber)
+    );
+    const parsedOps = ops.map((op) => ({
+      type: op.type,
+      data: op.data !== null ? JSON.parse(op.data) : null
+    }));
+    const recordData = replayOperationsForRecord(parsedOps);
+    const fieldNames = Object.keys(collectionDef.fields);
+    if (recordData) {
+      const createdAt = ops.length > 0 ? ops[0].wallTime : Date.now();
+      const updatedAt = ops.length > 0 ? ops[ops.length - 1].wallTime : Date.now();
+      await this.upsertMaterializedRecord(
+        txOrDb,
+        collection,
+        recordId,
+        recordData,
+        fieldNames,
+        collectionDef,
+        createdAt,
+        updatedAt
+      );
+    } else {
+      await txOrDb.execute(
+        sql`UPDATE ${sql.raw(collection)} SET _deleted = 1, _updated_at = ${Date.now()} WHERE id = ${recordId}`
+      );
+    }
+  }
+  /**
+   * UPSERT a record into the materialized collection table.
+   */
+  async upsertMaterializedRecord(txOrDb, tableName, recordId, recordData, fieldNames, collectionDef, createdAt, updatedAt) {
+    const allColumns = ["id", ...fieldNames, "_created_at", "_updated_at", "_deleted"];
+    const values = [
+      recordId,
+      ...fieldNames.map((f) => {
+        const descriptor = collectionDef.fields[f];
+        return descriptor ? serializeFieldValue(recordData[f] ?? null, descriptor) : null;
+      }),
+      createdAt,
+      updatedAt,
+      0
+    ];
+    const columnsSql = sql.raw(allColumns.join(", "));
+    const valuesSql = sql.join(
+      values.map((v) => sql`${v}`),
+      sql.raw(", ")
+    );
+    const updateSet = sql.raw(
+      allColumns.slice(1).map((c) => `${c} = excluded.${c}`).join(", ")
+    );
+    await txOrDb.execute(
+      sql`INSERT INTO ${sql.raw(tableName)} (${columnsSql}) VALUES (${valuesSql}) ON CONFLICT (id) DO UPDATE SET ${updateSet}`
+    );
+  }
+  /**
+   * Backfill all materialized collection tables from the existing operation log.
+   */
+  async backfillAllCollections() {
+    if (!this.schema) return;
+    for (const collectionName of Object.keys(this.schema.collections)) {
+      await this.backfillCollection(collectionName);
+    }
+  }
+  /**
+   * Backfill a single collection's materialized table from operations.
+   */
+  async backfillCollection(collectionName) {
+    const collectionDef = this.schema.collections[collectionName];
+    if (!collectionDef) return;
+    const allOps = await this.db.select({
+      recordId: pgOperations.recordId,
+      type: pgOperations.type,
+      data: pgOperations.data,
+      wallTime: pgOperations.wallTime
+    }).from(pgOperations).where(eq(pgOperations.collection, collectionName)).orderBy(
+      asc(pgOperations.wallTime),
+      asc(pgOperations.logical),
+      asc(pgOperations.sequenceNumber)
+    );
+    if (allOps.length === 0) return;
+    const grouped = /* @__PURE__ */ new Map();
+    for (const op of allOps) {
+      let group = grouped.get(op.recordId);
+      if (!group) {
+        group = [];
+        grouped.set(op.recordId, group);
+      }
+      group.push(op);
+    }
+    const fieldNames = Object.keys(collectionDef.fields);
+    for (const [recordId, recordOps] of grouped) {
+      const parsedOps = recordOps.map((op) => ({
+        type: op.type,
+        data: op.data !== null ? JSON.parse(op.data) : null
+      }));
+      const recordData = replayOperationsForRecord(parsedOps);
+      if (recordData) {
+        const createdAt = recordOps[0].wallTime;
+        const updatedAt = recordOps[recordOps.length - 1].wallTime;
+        await this.upsertMaterializedRecord(
+          this.db,
+          collectionName,
+          recordId,
+          recordData,
+          fieldNames,
+          collectionDef,
+          createdAt,
+          updatedAt
+        );
+      } else {
+        await this.db.execute(
+          sql`INSERT INTO ${sql.raw(collectionName)} (id, _deleted, _created_at, _updated_at) VALUES (${recordId}, 1, ${Date.now()}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET _deleted = 1, _updated_at = ${Date.now()}`
+        );
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Query building
+  // ---------------------------------------------------------------------------
+  buildSelectQuery(collection, options) {
+    const whereClause = this.buildWhereClause(
+      options?.where ?? {},
+      options?.includeDeleted ?? false
+    );
+    const parts = [
+      sql`SELECT * FROM ${sql.raw(collection)} WHERE ${whereClause}`
+    ];
+    if (options?.orderBy) {
+      const dir = options.orderDirection === "desc" ? "DESC" : "ASC";
+      parts.push(sql.raw(` ORDER BY ${options.orderBy} ${dir}`));
+    }
+    if (options?.limit !== void 0) {
+      parts.push(sql` LIMIT ${options.limit}`);
+    }
+    if (options?.offset !== void 0) {
+      parts.push(sql` OFFSET ${options.offset}`);
+    }
+    return sql.join(parts, sql.raw(""));
+  }
+  buildWhereClause(where, includeDeleted) {
+    const conditions = [];
+    if (!includeDeleted) {
+      conditions.push(sql.raw("_deleted = 0"));
+    }
+    for (const [key, value] of Object.entries(where)) {
+      conditions.push(sql`${sql.raw(key)} = ${value}`);
+    }
+    if (conditions.length === 0) {
+      return sql.raw("1 = 1");
+    }
+    return sql.join(conditions, sql.raw(" AND "));
+  }
+  // ---------------------------------------------------------------------------
+  // Row deserialization
+  // ---------------------------------------------------------------------------
+  deserializeRow(row, collectionDef) {
+    const record = { id: row.id };
+    for (const [fieldName, descriptor] of Object.entries(collectionDef.fields)) {
+      if (fieldName in row) {
+        record[fieldName] = deserializeFieldValue(row[fieldName], descriptor);
+      }
+    }
+    if ("_created_at" in row) record._created_at = row._created_at;
+    if ("_updated_at" in row) record._updated_at = row._updated_at;
+    return record;
+  }
+  // ---------------------------------------------------------------------------
+  // Fallback materialization (operation replay, no schema)
+  // ---------------------------------------------------------------------------
+  async materializeFromOpsLog(collection) {
+    const rows = await this.db.select().from(pgOperations).where(eq(pgOperations.collection, collection)).orderBy(
+      asc(pgOperations.wallTime),
+      asc(pgOperations.logical),
+      asc(pgOperations.sequenceNumber)
+    );
+    const records = /* @__PURE__ */ new Map();
+    const deleted = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      const recordId = row.recordId;
+      const data = row.data !== null ? JSON.parse(row.data) : null;
+      switch (row.type) {
+        case "insert":
+          if (data) {
+            records.set(recordId, { id: recordId, ...data });
+            deleted.delete(recordId);
+          }
+          break;
+        case "update":
+          if (data) {
+            const existing = records.get(recordId) ?? { id: recordId };
+            records.set(recordId, { ...existing, ...data });
+            deleted.delete(recordId);
+          }
+          break;
+        case "delete":
+          deleted.add(recordId);
+          break;
+      }
+    }
+    for (const id of deleted) {
+      records.delete(id);
+    }
+    return Array.from(records.values());
+  }
+  // ---------------------------------------------------------------------------
+  // Initialization
+  // ---------------------------------------------------------------------------
   async initialize() {
     await this.ensureTables();
     const rows = await this.db.select({
@@ -172,10 +857,6 @@ var PostgresServerStore = class {
       this.versionVector.set(row.nodeId, row.maxSequenceNumber);
     }
   }
-  /**
-   * Create tables if they don't exist.
-   * Uses raw SQL via Drizzle's sql template — standard DDL practice without drizzle-kit.
-   */
   async ensureTables() {
     await this.db.execute(sql`
 			CREATE TABLE IF NOT EXISTS operations (
@@ -186,13 +867,13 @@ var PostgresServerStore = class {
 				record_id TEXT NOT NULL,
 				data TEXT,
 				previous_data TEXT,
-				wall_time INTEGER NOT NULL,
+				wall_time BIGINT NOT NULL,
 				logical INTEGER NOT NULL,
 				timestamp_node_id TEXT NOT NULL,
 				sequence_number INTEGER NOT NULL,
 				causal_deps TEXT NOT NULL DEFAULT '[]',
 				schema_version INTEGER NOT NULL,
-				received_at INTEGER NOT NULL
+				received_at BIGINT NOT NULL
 			)
 		`);
     await this.db.execute(
@@ -204,14 +885,20 @@ var PostgresServerStore = class {
     await this.db.execute(
       sql`CREATE INDEX IF NOT EXISTS idx_received ON operations (received_at)`
     );
+    await this.db.execute(
+      sql`CREATE INDEX IF NOT EXISTS idx_collection_record ON operations (collection, record_id)`
+    );
     await this.db.execute(sql`
 			CREATE TABLE IF NOT EXISTS sync_state (
 				node_id TEXT PRIMARY KEY,
 				max_sequence_number INTEGER NOT NULL,
-				last_seen_at INTEGER NOT NULL
+				last_seen_at BIGINT NOT NULL
 			)
 		`);
   }
+  // ---------------------------------------------------------------------------
+  // Operation serialization
+  // ---------------------------------------------------------------------------
   serializeOperation(op, receivedAt) {
     return {
       id: op.id,
@@ -249,11 +936,28 @@ var PostgresServerStore = class {
       schemaVersion: row.schemaVersion
     };
   }
+  // ---------------------------------------------------------------------------
+  // Assertions
+  // ---------------------------------------------------------------------------
   assertOpen() {
     if (this.closed) {
       throw new Error("PostgresServerStore is closed");
     }
   }
+  assertSchema() {
+    if (!this.schema) {
+      throw new Error(
+        "Schema not set. Call setSchema() before using queryCollection/findRecord/countCollection."
+      );
+    }
+  }
+  assertCollection(collection) {
+    if (!this.schema.collections[collection]) {
+      throw new Error(
+        `Unknown collection "${collection}". Available: ${Object.keys(this.schema.collections).join(", ")}`
+      );
+    }
+  }
 };
 async function createPostgresServerStore(options) {
   const { postgresClient, drizzleFn } = await loadPostgresDeps();
@@ -322,6 +1026,7 @@ var esmRequire = createRequire(import.meta.url);
 var SqliteServerStore = class {
   nodeId;
   db;
+  schema = null;
   closed = false;
   constructor(db, nodeId) {
     this.db = db;
@@ -340,6 +1045,28 @@ var SqliteServerStore = class {
   getNodeId() {
     return this.nodeId;
   }
+  async setSchema(schema) {
+    this.assertOpen();
+    this.schema = schema;
+    const ddlStatements = generateAllCollectionDDL(schema, "sqlite");
+    for (const stmt of ddlStatements) {
+      if (stmt.startsWith("--kora:safe-alter")) {
+        const alterSql = stmt.replace("--kora:safe-alter\n", "");
+        try {
+          this.db.run(sql2.raw(alterSql));
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : "";
+          const causeMsg = e instanceof Error && e.cause instanceof Error ? e.cause.message : "";
+          if (!msg.includes("duplicate column") && !causeMsg.includes("duplicate column")) {
+            throw e;
+          }
+        }
+      } else {
+        this.db.run(sql2.raw(stmt));
+      }
+    }
+    await this.backfillAllCollections();
+  }
   async applyRemoteOperation(op) {
     this.assertOpen();
     const now = Date.now();
@@ -360,6 +1087,9 @@ var SqliteServerStore = class {
           lastSeenAt: sql2`${now}`
         }
       }).run();
+      if (this.schema && this.schema.collections[op.collection]) {
+        this.rebuildMaterializedRecord(tx, op.collection, op.recordId);
+      }
       return "applied";
     });
     return result;
@@ -374,12 +1104,282 @@ var SqliteServerStore = class {
     const result = this.db.select({ value: count2() }).from(operations).all();
     return result[0]?.value ?? 0;
   }
+  async materializeCollection(collection) {
+    this.assertOpen();
+    if (this.schema && this.schema.collections[collection]) {
+      return this.queryCollection(collection);
+    }
+    return this.materializeFromOpsLog(collection);
+  }
+  async queryCollection(collection, options) {
+    this.assertOpen();
+    this.assertSchema();
+    this.assertCollection(collection);
+    const collectionDef = this.schema.collections[collection];
+    if (options?.where) {
+      for (const key of Object.keys(options.where)) {
+        validateFieldName(collection, key, this.schema);
+      }
+    }
+    if (options?.orderBy) {
+      validateFieldName(collection, options.orderBy, this.schema);
+    }
+    const query = this.buildSelectQuery(collection, options);
+    const rows = this.db.all(query);
+    return rows.map((row) => this.deserializeRow(row, collectionDef));
+  }
+  async findRecord(collection, id) {
+    this.assertOpen();
+    this.assertSchema();
+    this.assertCollection(collection);
+    const collectionDef = this.schema.collections[collection];
+    const query = sql2`SELECT * FROM ${sql2.raw(collection)} WHERE id = ${id} AND _deleted = 0`;
+    const rows = this.db.all(query);
+    if (rows.length === 0) return null;
+    return this.deserializeRow(rows[0], collectionDef);
+  }
+  async countCollection(collection, where) {
+    this.assertOpen();
+    this.assertSchema();
+    this.assertCollection(collection);
+    if (where) {
+      for (const key of Object.keys(where)) {
+        validateFieldName(collection, key, this.schema);
+      }
+    }
+    const whereClause = this.buildWhereClause(where ?? {}, false);
+    const query = sql2`SELECT COUNT(*) as cnt FROM ${sql2.raw(collection)} WHERE ${whereClause}`;
+    const rows = this.db.all(query);
+    return rows[0]?.cnt ?? 0;
+  }
   async close() {
     this.closed = true;
   }
+  // ---------------------------------------------------------------------------
+  // Materialization internals
+  // ---------------------------------------------------------------------------
+  /**
+   * Rebuild a single record in the materialized collection table by replaying
+   * all operations for that record. Called within the applyRemoteOperation
+   * transaction for atomic dual-write.
+   */
+  rebuildMaterializedRecord(txOrDb, collection, recordId) {
+    const collectionDef = this.schema.collections[collection];
+    if (!collectionDef) return;
+    const ops = txOrDb.select({
+      type: operations.type,
+      data: operations.data,
+      wallTime: operations.wallTime
+    }).from(operations).where(
+      and2(
+        eq2(operations.collection, collection),
+        eq2(operations.recordId, recordId)
+      )
+    ).orderBy(asc2(operations.wallTime), asc2(operations.logical), asc2(operations.sequenceNumber)).all();
+    const parsedOps = ops.map((op) => ({
+      type: op.type,
+      data: op.data !== null ? JSON.parse(op.data) : null
+    }));
+    const recordData = replayOperationsForRecord(parsedOps);
+    const fieldNames = Object.keys(collectionDef.fields);
+    if (recordData) {
+      const createdAt = ops.length > 0 ? ops[0].wallTime : Date.now();
+      const updatedAt = ops.length > 0 ? ops[ops.length - 1].wallTime : Date.now();
+      this.upsertMaterializedRecord(
+        txOrDb,
+        collection,
+        recordId,
+        recordData,
+        fieldNames,
+        collectionDef,
+        createdAt,
+        updatedAt
+      );
+    } else {
+      txOrDb.run(
+        sql2`UPDATE ${sql2.raw(collection)} SET _deleted = 1, _updated_at = ${Date.now()} WHERE id = ${recordId}`
+      );
+    }
+  }
+  /**
+   * UPSERT a record into the materialized collection table.
+   * Uses INSERT ... ON CONFLICT (id) DO UPDATE SET for atomic upsert.
+   */
+  upsertMaterializedRecord(txOrDb, tableName, recordId, recordData, fieldNames, collectionDef, createdAt, updatedAt) {
+    const allColumns = ["id", ...fieldNames, "_created_at", "_updated_at", "_deleted"];
+    const values = [
+      recordId,
+      ...fieldNames.map((f) => {
+        const descriptor = collectionDef.fields[f];
+        return descriptor ? serializeFieldValue(recordData[f] ?? null, descriptor) : null;
+      }),
+      createdAt,
+      updatedAt,
+      0
+      // _deleted = false
+    ];
+    const columnsSql = sql2.raw(allColumns.join(", "));
+    const valuesSql = sql2.join(
+      values.map((v) => sql2`${v}`),
+      sql2.raw(", ")
+    );
+    const updateSet = sql2.raw(
+      allColumns.slice(1).map((c) => `${c} = excluded.${c}`).join(", ")
+    );
+    txOrDb.run(
+      sql2`INSERT INTO ${sql2.raw(tableName)} (${columnsSql}) VALUES (${valuesSql}) ON CONFLICT (id) DO UPDATE SET ${updateSet}`
+    );
+  }
+  /**
+   * Backfill all materialized collection tables from the existing operation log.
+   * Called when setSchema() is invoked and operations already exist.
+   */
+  async backfillAllCollections() {
+    if (!this.schema) return;
+    for (const collectionName of Object.keys(this.schema.collections)) {
+      this.backfillCollection(collectionName);
+    }
+  }
+  /**
+   * Backfill a single collection's materialized table from operations.
+   */
+  backfillCollection(collectionName) {
+    const collectionDef = this.schema.collections[collectionName];
+    if (!collectionDef) return;
+    const allOps = this.db.select({
+      recordId: operations.recordId,
+      type: operations.type,
+      data: operations.data,
+      wallTime: operations.wallTime
+    }).from(operations).where(eq2(operations.collection, collectionName)).orderBy(asc2(operations.wallTime), asc2(operations.logical), asc2(operations.sequenceNumber)).all();
+    if (allOps.length === 0) return;
+    const grouped = /* @__PURE__ */ new Map();
+    for (const op of allOps) {
+      let group = grouped.get(op.recordId);
+      if (!group) {
+        group = [];
+        grouped.set(op.recordId, group);
+      }
+      group.push(op);
+    }
+    const fieldNames = Object.keys(collectionDef.fields);
+    this.db.transaction((tx) => {
+      for (const [recordId, recordOps] of grouped) {
+        const parsedOps = recordOps.map((op) => ({
+          type: op.type,
+          data: op.data !== null ? JSON.parse(op.data) : null
+        }));
+        const recordData = replayOperationsForRecord(parsedOps);
+        if (recordData) {
+          const createdAt = recordOps[0].wallTime;
+          const updatedAt = recordOps[recordOps.length - 1].wallTime;
+          this.upsertMaterializedRecord(
+            tx,
+            collectionName,
+            recordId,
+            recordData,
+            fieldNames,
+            collectionDef,
+            createdAt,
+            updatedAt
+          );
+        } else {
+          tx.run(
+            sql2`INSERT INTO ${sql2.raw(collectionName)} (id, _deleted, _created_at, _updated_at) VALUES (${recordId}, 1, ${Date.now()}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET _deleted = 1, _updated_at = ${Date.now()}`
+          );
+        }
+      }
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Query building
+  // ---------------------------------------------------------------------------
+  buildSelectQuery(collection, options) {
+    const whereClause = this.buildWhereClause(
+      options?.where ?? {},
+      options?.includeDeleted ?? false
+    );
+    const parts = [
+      sql2`SELECT * FROM ${sql2.raw(collection)} WHERE ${whereClause}`
+    ];
+    if (options?.orderBy) {
+      const dir = options.orderDirection === "desc" ? "DESC" : "ASC";
+      parts.push(sql2.raw(` ORDER BY ${options.orderBy} ${dir}`));
+    }
+    if (options?.limit !== void 0) {
+      parts.push(sql2` LIMIT ${options.limit}`);
+    }
+    if (options?.offset !== void 0) {
+      parts.push(sql2` OFFSET ${options.offset}`);
+    }
+    return sql2.join(parts, sql2.raw(""));
+  }
+  buildWhereClause(where, includeDeleted) {
+    const conditions = [];
+    if (!includeDeleted) {
+      conditions.push(sql2.raw("_deleted = 0"));
+    }
+    for (const [key, value] of Object.entries(where)) {
+      conditions.push(sql2`${sql2.raw(key)} = ${value}`);
+    }
+    if (conditions.length === 0) {
+      return sql2.raw("1 = 1");
+    }
+    return sql2.join(conditions, sql2.raw(" AND "));
+  }
+  // ---------------------------------------------------------------------------
+  // Row deserialization
+  // ---------------------------------------------------------------------------
+  deserializeRow(row, collectionDef) {
+    const record = { id: row.id };
+    for (const [fieldName, descriptor] of Object.entries(collectionDef.fields)) {
+      if (fieldName in row) {
+        record[fieldName] = deserializeFieldValue(row[fieldName], descriptor);
+      }
+    }
+    if ("_created_at" in row) record._created_at = row._created_at;
+    if ("_updated_at" in row) record._updated_at = row._updated_at;
+    return record;
+  }
+  // ---------------------------------------------------------------------------
+  // Fallback materialization (operation replay, no schema)
+  // ---------------------------------------------------------------------------
+  materializeFromOpsLog(collection) {
+    const rows = this.db.select().from(operations).where(eq2(operations.collection, collection)).orderBy(asc2(operations.wallTime), asc2(operations.logical), asc2(operations.sequenceNumber)).all();
+    const records = /* @__PURE__ */ new Map();
+    const deleted = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      const recordId = row.recordId;
+      const data = row.data !== null ? JSON.parse(row.data) : null;
+      switch (row.type) {
+        case "insert":
+          if (data) {
+            records.set(recordId, { id: recordId, ...data });
+            deleted.delete(recordId);
+          }
+          break;
+        case "update":
+          if (data) {
+            const existing = records.get(recordId) ?? { id: recordId };
+            records.set(recordId, { ...existing, ...data });
+            deleted.delete(recordId);
+          }
+          break;
+        case "delete":
+          deleted.add(recordId);
+          break;
+      }
+    }
+    for (const id of deleted) {
+      records.delete(id);
+    }
+    return Array.from(records.values());
+  }
+  // ---------------------------------------------------------------------------
+  // Table setup
+  // ---------------------------------------------------------------------------
   /**
    * Create the operations and sync_state tables if they don't exist.
-   * Uses raw SQL via Drizzle's sql template — standard practice for DDL without drizzle-kit.
    */
   ensureTables() {
     this.db.run(sql2`
@@ -409,6 +1409,9 @@ var SqliteServerStore = class {
     this.db.run(sql2`
 			CREATE INDEX IF NOT EXISTS idx_received ON operations (received_at)
 		`);
+    this.db.run(sql2`
+			CREATE INDEX IF NOT EXISTS idx_collection_record ON operations (collection, record_id)
+		`);
     this.db.run(sql2`
 			CREATE TABLE IF NOT EXISTS sync_state (
 				node_id TEXT PRIMARY KEY,
@@ -417,6 +1420,9 @@ var SqliteServerStore = class {
 			)
 		`);
   }
+  // ---------------------------------------------------------------------------
+  // Operation serialization
+  // ---------------------------------------------------------------------------
   serializeOperation(op, receivedAt) {
     return {
       id: op.id,
@@ -454,11 +1460,28 @@ var SqliteServerStore = class {
       schemaVersion: row.schemaVersion
     };
   }
+  // ---------------------------------------------------------------------------
+  // Assertions
+  // ---------------------------------------------------------------------------
   assertOpen() {
     if (this.closed) {
       throw new Error("SqliteServerStore is closed");
     }
   }
+  assertSchema() {
+    if (!this.schema) {
+      throw new Error(
+        "Schema not set. Call setSchema() before using queryCollection/findRecord/countCollection."
+      );
+    }
+  }
+  assertCollection(collection) {
+    if (!this.schema.collections[collection]) {
+      throw new Error(
+        `Unknown collection "${collection}". Available: ${Object.keys(this.schema.collections).join(", ")}`
+      );
+    }
+  }
 };
 function createSqliteServerStore(options) {
   const Database = esmRequire("better-sqlite3");
@@ -1218,6 +2241,11 @@ function createProductionServer(config) {
         res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
         res.setHeader("Cross-Origin-Embedder-Policy", "require-corp");
         const url = new URL(req.url || "/", `http://${req.headers.host}`);
+        if (url.pathname === "/health") {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ status: "ok", timestamp: Date.now() }));
+          return;
+        }
         let filePath = join(distDir, url.pathname);
         if (!extname(filePath)) {
           const indexPath = join(filePath, "index.html");