reflectdb 0.1.0

package/dist/cjs/server/index.cjs

@@ -0,0 +1,4486 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core/types.ts
+var exports_types = {};
+__export(exports_types, {
+  reasonFromError: () => reasonFromError,
+  isErrorReason: () => isErrorReason,
+  TransportSendError: () => TransportSendError,
+  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
+  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  MutationError: () => MutationError,
+  MAX_CLOCK_DRIFT_MS: () => MAX_CLOCK_DRIFT_MS,
+  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE
+});
+function isErrorReason(value) {
+  return typeof value === "string" && VALID_ERROR_REASONS.has(value);
+}
+function reasonFromError(err) {
+  if (err instanceof MutationError && isErrorReason(err.reason)) {
+    return err.reason;
+  }
+  return "server_error";
+}
+var TransportSendError, PROTOCOL_VERSION = 1, SUPPORTED_PROTOCOL_VERSIONS, MAX_CLOCK_DRIFT_MS, MAX_BATCH_SIZE = 100, TOMBSTONE_RETENTION_MS, SERVER_TOMBSTONE_RETENTION_MS, MutationError, VALID_ERROR_REASONS;
+var init_types = __esm(() => {
+  TransportSendError = class TransportSendError extends Error {
+    clientId;
+    cause;
+    constructor(clientId, message, cause) {
+      super(message);
+      this.clientId = clientId;
+      this.cause = cause;
+      this.name = "TransportSendError";
+    }
+  };
+  SUPPORTED_PROTOCOL_VERSIONS = [1];
+  MAX_CLOCK_DRIFT_MS = 5 * 60 * 1000;
+  TOMBSTONE_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+  SERVER_TOMBSTONE_RETENTION_MS = 90 * 24 * 60 * 60 * 1000;
+  MutationError = class MutationError extends Error {
+    reason;
+    constructor(reason, message) {
+      super(message ?? reason);
+      this.reason = reason;
+    }
+  };
+  VALID_ERROR_REASONS = new Set([
+    "outside_shape",
+    "readonly_query",
+    "rate_limited",
+    "buffer_full",
+    "server_conflict",
+    "custom_conflict",
+    "merge_stale",
+    "clock_drift",
+    "replay",
+    "batch_too_large",
+    "schema_outdated",
+    "auth_revoked",
+    "compacted",
+    "mutation_rejected",
+    "server_error",
+    "unknown_query"
+  ]);
+});
+
+// src/server/drizzle.ts
+var exports_drizzle = {};
+__export(exports_drizzle, {
+  drizzleTxAtomic: () => drizzleTxAtomic,
+  drizzleTable: () => drizzleTable
+});
+module.exports = __toCommonJS(exports_drizzle);
+var import_node_module2 = require("node:module");
+
+// src/server/factory.ts
+function getByDottedPath(root, path) {
+  const parts = path.split(".");
+  let cur = root;
+  for (const p of parts) {
+    if (cur == null || typeof cur !== "object")
+      return;
+    cur = cur[p];
+  }
+  return cur;
+}
+function renderTemplate(template, ctx) {
+  return template.replace(/\$\{([^}]+)\}/g, (_m, expr) => {
+    const trimmed = expr.trim();
+    const path = trimmed.includes(".") ? trimmed : `params.${trimmed}`;
+    const v = getByDottedPath(ctx, path);
+    return v == null ? "" : String(v);
+  });
+}
+function resolveStamp(source, ctx) {
+  if (typeof source === "function")
+    return source(ctx);
+  if (source === "auth.userId")
+    return ctx.auth.userId;
+  if (source === "auth.name")
+    return ctx.auth.name;
+  if (typeof source === "string" && source.includes(".")) {
+    return getByDottedPath(ctx, source);
+  }
+  return source;
+}
+function buildScopeFilter(scope, ctx) {
+  if (!scope)
+    return;
+  if (typeof scope === "function")
+    return;
+  if (typeof scope === "string") {
+    const val2 = ctx.params[scope];
+    if (val2 === undefined) {
+      throw new Error(`params.${scope} required for scoped query`);
+    }
+    return { kind: "params", column: scope, value: val2 };
+  }
+  const { auth: authKey, column } = scope;
+  const val = ctx.auth[authKey];
+  if (val === undefined) {
+    throw new Error(`auth.${authKey} required for scoped query`);
+  }
+  return { kind: "auth", column, value: val };
+}
+function defineTable(adapter, opts = {}) {
+  const pkName = opts.pk ?? adapter.pk ?? "id";
+  const query = opts.query ? opts.query : (ctx, db) => {
+    if (typeof opts.scope === "function") {
+      throw new Error("function-form scope requires opts.query override on defineTable (no SQL fragment to pass to adapter)");
+    }
+    const scope = buildScopeFilter(opts.scope, ctx);
+    return adapter.list({ db, scope });
+  };
+  const authorize = async (action, ctx, _db) => {
+    if (action.type === "read" && opts.policy?.read) {
+      const ok = await opts.policy.read({ ctx });
+      if (!ok)
+        throw new Error("policy denied read");
+    }
+  };
+  const mutate = async (op, rawCtx, db) => {
+    const ctx = rawCtx;
+    const payload = op.payload ? { ...op.payload } : {};
+    if (op.type !== "delete")
+      delete payload[pkName];
+    if (opts.rowId) {
+      const expected = renderTemplate(opts.rowId, {
+        auth: ctx.auth,
+        params: ctx.params
+      });
+      if (op.rowId !== expected) {
+        throw new Error("rowId mismatch");
+      }
+    }
+    if (opts.scope && typeof opts.scope === "string" && op.type === "insert") {
+      const col = opts.scope;
+      const paramVal = ctx.params[col];
+      if (paramVal === undefined) {
+        throw new Error(`params.${col} required for scoped mutation`);
+      }
+      if (payload[col] !== paramVal) {
+        throw new Error(`${col} mismatch`);
+      }
+    }
+    if (opts.scope && typeof opts.scope === "object" && !Array.isArray(opts.scope) && "auth" in opts.scope && op.type === "insert") {
+      const { auth: authKey, column } = opts.scope;
+      const authVal = ctx.auth[authKey];
+      if (authVal === undefined) {
+        throw new Error(`auth.${authKey} required for scoped mutation`);
+      }
+      if (payload[column] !== authVal) {
+        throw new Error(`${column} mismatch`);
+      }
+    }
+    const existing = op.type !== "insert" ? await Promise.resolve(adapter.find({ db, rowId: op.rowId })) : null;
+    if (op.type !== "insert" && existing) {
+      if (opts.scope && typeof opts.scope === "string") {
+        const col = opts.scope;
+        const paramVal = ctx.params[col];
+        if (paramVal === undefined) {
+          throw new Error(`params.${col} required for scoped mutation`);
+        }
+        if (existing[col] !== paramVal) {
+          throw new Error(`${col} mismatch`);
+        }
+      }
+      if (opts.scope && typeof opts.scope === "object" && !Array.isArray(opts.scope) && "auth" in opts.scope) {
+        const { auth: authKey, column } = opts.scope;
+        const authVal = ctx.auth[authKey];
+        if (authVal === undefined) {
+          throw new Error(`auth.${authKey} required for scoped mutation`);
+        }
+        if (existing[column] !== authVal) {
+          throw new Error(`${column} mismatch`);
+        }
+      }
+    }
+    if (op.type === "insert" && opts.policy?.insert) {
+      const ok = await opts.policy.insert({ ctx, payload });
+      if (!ok)
+        throw new Error("policy denied insert");
+    } else if (op.type === "update" && opts.policy?.update) {
+      const ok = await opts.policy.update({
+        ctx,
+        existing: existing ?? {},
+        payload
+      });
+      if (!ok)
+        throw new Error("policy denied update");
+    } else if (op.type === "delete" && opts.policy?.delete) {
+      const ok = await opts.policy.delete({ ctx, existing: existing ?? {} });
+      if (!ok)
+        throw new Error("policy denied delete");
+    }
+    if (opts.policy?.fields && op.type !== "delete") {
+      for (const [field, rule] of Object.entries(opts.policy.fields)) {
+        if (rule === "server-only") {
+          delete payload[field];
+        } else if (rule === "insert-only") {
+          if (op.type === "update")
+            delete payload[field];
+        } else if (typeof rule === "object" && rule && "write" in rule) {
+          const allow = await rule.write({
+            ctx,
+            existing: existing ?? null,
+            payload
+          });
+          if (!allow)
+            delete payload[field];
+        }
+      }
+    }
+    if (op.type === "insert" && opts.ownerStamp) {
+      for (const [field, source] of Object.entries(opts.ownerStamp)) {
+        if (source === undefined)
+          continue;
+        payload[field] = resolveStamp(source, ctx);
+      }
+    }
+    if (op.type !== "delete" && opts.serverSet) {
+      for (const [field, val] of Object.entries(opts.serverSet)) {
+        if (val === undefined)
+          continue;
+        payload[field] = typeof val === "function" ? val(ctx) : val;
+      }
+    }
+    if (op.type === "insert") {
+      await opts.hooks?.beforeInsert?.({ payload, ctx, db });
+    } else if (op.type === "update") {
+      await opts.hooks?.beforeUpdate?.({
+        payload,
+        existing: existing ?? {},
+        ctx,
+        db
+      });
+    } else if (op.type === "delete") {
+      await opts.hooks?.beforeDelete?.({ existing: existing ?? {}, ctx, db });
+    }
+    if (op.type === "delete") {
+      if (opts.delete) {
+        await opts.delete({ rowId: op.rowId, existing, ctx, db });
+      } else {
+        await Promise.resolve(adapter.delete({ db, rowId: op.rowId }));
+      }
+    } else if (op.type === "insert" && opts.insert) {
+      await opts.insert({ payload, existing, ctx, db });
+    } else if (op.type === "update" && opts.update) {
+      await opts.update({ payload, existing: existing ?? {}, ctx, db });
+    } else if (op.type === "update") {
+      if (Object.keys(payload).length > 0) {
+        await Promise.resolve(adapter.update({ db, rowId: op.rowId, payload }));
+      }
+    } else {
+      await Promise.resolve(adapter.insert({ db, rowId: op.rowId, payload }));
+    }
+    if (op.type === "delete") {
+      await opts.hooks?.afterDelete?.({ rowId: op.rowId, ctx, db });
+    } else {
+      const hookName = op.type === "insert" ? "afterInsert" : "afterUpdate";
+      const after = opts.hooks?.[hookName];
+      if (after) {
+        const row = await Promise.resolve(adapter.find({ db, rowId: op.rowId })) ?? {};
+        if (op.type === "insert") {
+          await opts.hooks?.afterInsert?.({ row, ctx, db });
+        } else {
+          await opts.hooks?.afterUpdate?.({
+            row,
+            previous: existing ?? {},
+            ctx,
+            db
+          });
+        }
+      }
+    }
+  };
+  return { query, mutate, authorize };
+}
+
+// src/server/drizzle.ts
+var requireFn = import_node_module2.createRequire(module.filename);
+var cachedDrizzle;
+function loadDrizzleSync() {
+  if (cachedDrizzle === undefined) {
+    try {
+      const mod = requireFn("drizzle-orm");
+      cachedDrizzle = { eq: mod.eq, sql: mod.sql, getTableName: mod.getTableName };
+    } catch {
+      cachedDrizzle = null;
+    }
+  }
+  if (!cachedDrizzle) {
+    throw new Error("drizzleTable / drizzleTxAtomic require drizzle-orm to be installed. Add it to your dependencies, or use defineTable with a custom TableAdapter.");
+  }
+  return cachedDrizzle;
+}
+async function execAll(query) {
+  const q = query;
+  if (q && typeof q.all === "function") {
+    return await Promise.resolve(q.all());
+  }
+  const res = await Promise.resolve(query);
+  return Array.isArray(res) ? res : [];
+}
+function drizzleAdapter(table, pk) {
+  const pkName = pk ?? "id";
+  const pkCol = table[pkName];
+  let cachedName = "";
+  const adapter = {
+    get name() {
+      return cachedName;
+    },
+    pk: pkName,
+    async list({ db, scope }) {
+      const { eq, getTableName } = loadDrizzleSync();
+      if (!cachedName)
+        cachedName = getTableName(table);
+      if (!scope) {
+        return await execAll(db.select().from(table));
+      }
+      const col = table[scope.column];
+      return await execAll(db.select().from(table).where(eq(col, scope.value)));
+    },
+    async find({ db, rowId }) {
+      const { eq, getTableName } = loadDrizzleSync();
+      if (!cachedName)
+        cachedName = getTableName(table);
+      const rows = await execAll(db.select().from(table).where(eq(pkCol, rowId)));
+      return rows[0] ?? null;
+    },
+    async insert({ db, rowId, payload }) {
+      const { getTableName } = loadDrizzleSync();
+      if (!cachedName)
+        cachedName = getTableName(table);
+      const values = { ...payload, [pkName]: rowId };
+      if (Object.keys(payload).length > 0) {
+        await Promise.resolve(db.insert(table).values(values).onConflictDoUpdate({ target: pkCol, set: payload }));
+      } else {
+        await Promise.resolve(db.insert(table).values(values).onConflictDoNothing());
+      }
+    },
+    async update({ db, rowId, payload }) {
+      const { eq, getTableName } = loadDrizzleSync();
+      if (!cachedName)
+        cachedName = getTableName(table);
+      await Promise.resolve(db.update(table).set(payload).where(eq(pkCol, rowId)));
+    },
+    async delete({ db, rowId }) {
+      const { eq, getTableName } = loadDrizzleSync();
+      if (!cachedName)
+        cachedName = getTableName(table);
+      await Promise.resolve(db.delete(table).where(eq(pkCol, rowId)));
+    }
+  };
+  return adapter;
+}
+function drizzleQueryFn(table, opts) {
+  if (opts.query)
+    return opts.query;
+  return (ctx, db) => {
+    const where = buildDrizzleScopeWhere(opts.scope, ctx, table);
+    return where ? db.select().from(table).where(where) : db.select().from(table);
+  };
+}
+function buildDrizzleScopeWhere(scope, ctx, table) {
+  if (!scope)
+    return;
+  if (typeof scope === "function")
+    return scope(ctx);
+  const { eq } = loadDrizzleSync();
+  if (typeof scope === "string") {
+    const col2 = table[scope];
+    const val2 = ctx.params[scope];
+    if (val2 === undefined) {
+      throw new Error(`params.${String(scope)} required for scoped query`);
+    }
+    return eq(col2, val2);
+  }
+  const col = table[scope.column];
+  const val = ctx.auth[scope.auth];
+  if (val === undefined) {
+    throw new Error(`auth.${String(scope.auth)} required for scoped query`);
+  }
+  return eq(col, val);
+}
+function drizzleTable(table, opts = {}) {
+  const adapter = drizzleAdapter(table, opts.pk);
+  const query = drizzleQueryFn(table, opts);
+  return defineTable(adapter, {
+    ...opts,
+    query
+  });
+}
+var drizzleTxAtomic = {
+  async begin(db) {
+    const { sql } = loadDrizzleSync();
+    const handle = db;
+    if (typeof handle?.run !== "function") {
+      throw new Error("drizzleTxAtomic.begin requires a drizzle db with a run() method");
+    }
+    await Promise.resolve(handle.run(sql`BEGIN`));
+  },
+  async commit(db) {
+    const { sql } = loadDrizzleSync();
+    const handle = db;
+    if (typeof handle?.run !== "function") {
+      throw new Error("drizzleTxAtomic.commit requires a drizzle db with a run() method");
+    }
+    await Promise.resolve(handle.run(sql`COMMIT`));
+  },
+  async rollback(db) {
+    const { sql } = loadDrizzleSync();
+    const handle = db;
+    if (typeof handle?.run !== "function") {
+      throw new Error("drizzleTxAtomic.rollback requires a drizzle db with a run() method");
+    }
+    await Promise.resolve(handle.run(sql`ROLLBACK`));
+  }
+};
+
+// src/server/index.ts
+var exports_server = {};
+__export(exports_server, {
+  stableStringify: () => stableStringify,
+  resolveRoomKey: () => resolveRoomKey,
+  resolveConflict: () => resolveConflict,
+  processOp: () => processOp,
+  enforceServerSet: () => enforceServerSet,
+  enforceReadonly: () => enforceReadonly,
+  enforceClockDrift: () => enforceClockDrift,
+  enforceBatchSize: () => enforceBatchSize,
+  drizzleTxAtomic: () => drizzleTxAtomic,
+  drizzleTable: () => drizzleTable,
+  defineTable: () => defineTable,
+  createSyncServer: () => createSyncServer,
+  createSqliteStorage: () => createSqliteStorage,
+  createServer: () => createServer,
+  createRateLimiter: () => createRateLimiter,
+  createPostgresStorage: () => createPostgresStorage,
+  SessionManager: () => SessionManager,
+  ServerClock: () => ServerClock,
+  SERVER_HLC_META_KEY: () => SERVER_HLC_META_KEY,
+  ResultCache: () => ResultCache,
+  OpProcessor: () => OpProcessor,
+  MutationError: () => MutationError,
+  MessageHandler: () => MessageHandler,
+  BroadcastEngine: () => BroadcastEngine
+});
+module.exports = __toCommonJS(exports_server);
+
+// src/server/enforcement.ts
+init_types();
+
+// src/core/hlc.ts
+init_types();
+var MS_PAD = 19;
+var COUNTER_PAD = 4;
+var COUNTER_MAX = 9999;
+function createHlc(nodeId) {
+  return { ms: 0, counter: 0, nodeId };
+}
+function normalize(ms, counter, nodeId) {
+  if (counter > COUNTER_MAX) {
+    return { ms: ms + 1, counter: 0, nodeId };
+  }
+  return { ms, counter, nodeId };
+}
+function sendHlc(local) {
+  const wall = Date.now();
+  const ms = Math.max(wall, local.ms);
+  const counter = ms === local.ms ? local.counter + 1 : 0;
+  return normalize(ms, counter, local.nodeId);
+}
+function receiveHlc(local, remote) {
+  const wall = Date.now();
+  const clampedRemoteMs = Math.min(remote.ms, wall + MAX_CLOCK_DRIFT_MS);
+  const ms = Math.max(wall, local.ms, clampedRemoteMs);
+  const counter = ms === local.ms && ms === clampedRemoteMs ? Math.max(local.counter, remote.counter) + 1 : ms === local.ms ? local.counter + 1 : ms === clampedRemoteMs ? remote.counter + 1 : 0;
+  return normalize(ms, counter, local.nodeId);
+}
+function packHlc(hlc) {
+  const ms = String(hlc.ms).padStart(MS_PAD, "0");
+  const counter = String(hlc.counter).padStart(COUNTER_PAD, "0");
+  return `${ms}.${counter}.${hlc.nodeId}`;
+}
+function unpackHlc(packed) {
+  const firstDot = packed.indexOf(".");
+  const secondDot = firstDot < 0 ? -1 : packed.indexOf(".", firstDot + 1);
+  if (firstDot < 0 || secondDot < 0) {
+    throw new Error(`Malformed HLC: ${packed}`);
+  }
+  const ms = Number(packed.slice(0, firstDot));
+  const counter = Number(packed.slice(firstDot + 1, secondDot));
+  const nodeId = packed.slice(secondDot + 1);
+  if (!Number.isFinite(ms) || !Number.isFinite(counter) || nodeId.length === 0) {
+    throw new Error(`Malformed HLC: ${packed}`);
+  }
+  return { ms, counter, nodeId };
+}
+function compareHlc(a, b) {
+  if (a < b)
+    return -1;
+  if (a > b)
+    return 1;
+  return 0;
+}
+
+// src/server/enforcement.ts
+function enforceClockDrift(hlc) {
+  let parsed;
+  try {
+    parsed = unpackHlc(hlc);
+  } catch {
+    return { ok: false, reason: "clock_drift" };
+  }
+  const drift = parsed.ms - Date.now();
+  if (drift > MAX_CLOCK_DRIFT_MS) {
+    return { ok: false, reason: "clock_drift" };
+  }
+  return { ok: true };
+}
+function enforceReadonly(op, options) {
+  if (op.op === "delete" || op.op === "insert" || !op.payload || !options.readonly?.length) {
+    return op;
+  }
+  const cleaned = { ...op.payload };
+  for (const field of options.readonly) {
+    delete cleaned[field];
+  }
+  return { ...op, payload: cleaned };
+}
+function enforceServerSet(op, options) {
+  if (op.op === "delete" || !options.serverSet) {
+    return op;
+  }
+  const payload = { ...op.payload, ...options.serverSet };
+  return { ...op, payload };
+}
+function enforceBatchSize(batchSize, maxBatchSize) {
+  if (batchSize !== undefined && batchSize > maxBatchSize) {
+    return { ok: false, reason: "batch_too_large" };
+  }
+  return { ok: true };
+}
+function createRateLimiter(config) {
+  const secondBuckets = new Map;
+  const minuteBuckets = new Map;
+  function globalKey(userId, clientId) {
+    return `${userId}:${clientId}`;
+  }
+  function tableKey(userId, clientId, table) {
+    return `${userId}:${clientId}:${table}`;
+  }
+  let lastCleanup = Date.now();
+  function cleanupStale(now) {
+    if (now - lastCleanup < 60000)
+      return;
+    lastCleanup = now;
+    for (const [k, bucket] of secondBuckets) {
+      if (now >= bucket.resetAt)
+        secondBuckets.delete(k);
+    }
+    for (const [k, bucket] of minuteBuckets) {
+      if (now >= bucket.resetAt)
+        minuteBuckets.delete(k);
+    }
+  }
+  function checkBucket(buckets, k, limit, now) {
+    if (!limit)
+      return true;
+    const bucket = buckets.get(k);
+    return !(bucket && now < bucket.resetAt && bucket.count >= limit);
+  }
+  function recordBucket(buckets, k, limit, windowMs, now) {
+    if (!limit)
+      return;
+    const bucket = buckets.get(k);
+    if (!bucket || now >= bucket.resetAt) {
+      buckets.set(k, { count: 1, resetAt: now + windowMs });
+    } else {
+      bucket.count++;
+    }
+  }
+  return {
+    check(userId, clientId, table) {
+      const now = Date.now();
+      cleanupStale(now);
+      const gk = globalKey(userId, clientId);
+      if (!checkBucket(secondBuckets, gk, config.opsPerSecond, now)) {
+        return { ok: false, reason: "rate_limited" };
+      }
+      if (!checkBucket(minuteBuckets, gk, config.opsPerMinute, now)) {
+        return { ok: false, reason: "rate_limited" };
+      }
+      const tableCfg = table ? config.perTable?.[table] : undefined;
+      if (tableCfg && table) {
+        const tk = tableKey(userId, clientId, table);
+        if (!checkBucket(secondBuckets, tk, tableCfg.opsPerSecond, now)) {
+          return { ok: false, reason: "rate_limited" };
+        }
+        if (!checkBucket(minuteBuckets, tk, tableCfg.opsPerMinute, now)) {
+          return { ok: false, reason: "rate_limited" };
+        }
+      }
+      return { ok: true };
+    },
+    record(userId, clientId, table) {
+      const now = Date.now();
+      const gk = globalKey(userId, clientId);
+      recordBucket(secondBuckets, gk, config.opsPerSecond, 1000, now);
+      recordBucket(minuteBuckets, gk, config.opsPerMinute, 60000, now);
+      const tableCfg = table ? config.perTable?.[table] : undefined;
+      if (tableCfg && table) {
+        const tk = tableKey(userId, clientId, table);
+        recordBucket(secondBuckets, tk, tableCfg.opsPerSecond, 1000, now);
+        recordBucket(minuteBuckets, tk, tableCfg.opsPerMinute, 60000, now);
+      }
+      cleanupStale(now);
+    }
+  };
+}
+
+// src/server/handler.ts
+init_types();
+
+// src/server/server-clock.ts
+var SERVER_HLC_META_KEY = "serverHlcWatermark";
+var HLC_PERSIST_INTERVAL_MS = 1000;
+var HLC_PERSIST_LEASE_MS = 5000;
+
+class ServerClock {
+  hlc;
+  storage = null;
+  load = null;
+  persistTimer = null;
+  persistPending = false;
+  constructor(nodeId) {
+    this.hlc = createHlc(nodeId);
+  }
+  setStorage(storage) {
+    this.storage = storage;
+    this.load = null;
+    this.ensureLoaded();
+  }
+  current() {
+    return this.hlc;
+  }
+  ensureLoaded() {
+    if (!this.storage)
+      return Promise.resolve();
+    if (this.load)
+      return this.load;
+    const storage = this.storage;
+    this.load = (async () => {
+      try {
+        const stored = await storage.getMeta(SERVER_HLC_META_KEY);
+        if (stored)
+          this.hlc = receiveHlc(this.hlc, unpackHlc(stored));
+      } catch (err) {
+        console.error("[reflectdb] Failed to load persisted server HLC watermark:", err);
+      }
+    })();
+    return this.load;
+  }
+  async refresh() {
+    if (!this.storage)
+      return;
+    try {
+      const stored = await this.storage.getMeta(SERVER_HLC_META_KEY);
+      if (stored)
+        this.hlc = receiveHlc(this.hlc, unpackHlc(stored));
+    } catch (err) {
+      console.error("[reflectdb] Failed to refresh server HLC watermark:", err);
+    }
+  }
+  stamp() {
+    this.hlc = sendHlc(this.hlc);
+    this.schedulePersist();
+    return packHlc(this.hlc);
+  }
+  peekNext() {
+    return packHlc(sendHlc(this.hlc));
+  }
+  packed() {
+    return packHlc(this.hlc);
+  }
+  receive(packedRemote) {
+    try {
+      this.hlc = receiveHlc(this.hlc, unpackHlc(packedRemote));
+      this.schedulePersist();
+    } catch {}
+  }
+  async close() {
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+    await this.flush();
+  }
+  schedulePersist() {
+    if (!this.storage)
+      return;
+    this.persistPending = true;
+    if (this.persistTimer)
+      return;
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      this.flush();
+    }, HLC_PERSIST_INTERVAL_MS);
+    if (typeof this.persistTimer.unref === "function") {
+      this.persistTimer.unref();
+    }
+  }
+  async flush() {
+    if (!this.storage || !this.persistPending)
+      return;
+    this.persistPending = false;
+    await this.refresh();
+    const watermark = packHlc({
+      ms: this.hlc.ms + HLC_PERSIST_LEASE_MS,
+      counter: 0,
+      nodeId: this.hlc.nodeId
+    });
+    try {
+      await this.storage.setMeta(SERVER_HLC_META_KEY, watermark);
+    } catch (err) {
+      console.error("[reflectdb] Failed to persist server HLC watermark:", err);
+    }
+  }
+}
+
+// src/server/session.ts
+class SessionManager {
+  sessions = new Map;
+  querySubscribers = new Map;
+  userSessions = new Map;
+  connect(clientId) {
+    const session = {
+      clientId,
+      auth: null,
+      subscriptions: new Map,
+      watermark: null,
+      connectedAt: Date.now()
+    };
+    this.sessions.set(clientId, session);
+    return session;
+  }
+  disconnect(clientId) {
+    const session = this.sessions.get(clientId);
+    if (session) {
+      for (const queryName of session.subscriptions.keys()) {
+        const subs = this.querySubscribers.get(queryName);
+        if (subs) {
+          subs.delete(clientId);
+          if (subs.size === 0)
+            this.querySubscribers.delete(queryName);
+        }
+      }
+      if (session.auth) {
+        const userId = session.auth.userId;
+        const set = this.userSessions.get(userId);
+        if (set) {
+          set.delete(clientId);
+          if (set.size === 0)
+            this.userSessions.delete(userId);
+        }
+      }
+    }
+    this.sessions.delete(clientId);
+  }
+  countForUser(userId) {
+    return this.userSessions.get(userId)?.size ?? 0;
+  }
+  oldestForUser(userId) {
+    const ids = this.userSessions.get(userId);
+    if (!ids || ids.size === 0)
+      return null;
+    let oldest = null;
+    for (const id of ids) {
+      const s = this.sessions.get(id);
+      if (!s)
+        continue;
+      if (!oldest || s.connectedAt < oldest.connectedAt)
+        oldest = s;
+    }
+    return oldest;
+  }
+  get(clientId) {
+    return this.sessions.get(clientId);
+  }
+  setAuth(clientId, auth) {
+    const session = this.sessions.get(clientId);
+    if (session) {
+      if (session.auth && session.auth.userId !== auth.userId) {
+        const prev = this.userSessions.get(session.auth.userId);
+        if (prev) {
+          prev.delete(clientId);
+          if (prev.size === 0)
+            this.userSessions.delete(session.auth.userId);
+        }
+      }
+      session.auth = auth;
+      let set = this.userSessions.get(auth.userId);
+      if (!set) {
+        set = new Set;
+        this.userSessions.set(auth.userId, set);
+      }
+      set.add(clientId);
+    }
+  }
+  subscribe(clientId, queryName, params, options, roomKey = null, windowSize = null) {
+    const session = this.sessions.get(clientId);
+    if (session) {
+      const effectiveWindow = windowSize != null && windowSize > 0 ? windowSize : null;
+      session.subscriptions.set(queryName, {
+        queryName,
+        params,
+        options,
+        roomKey,
+        windowSize: effectiveWindow,
+        windowLimit: effectiveWindow ?? 0,
+        loadedCount: 0,
+        lastTotalCount: null,
+        bootstrapped: false
+      });
+      let subs = this.querySubscribers.get(queryName);
+      if (!subs) {
+        subs = new Set;
+        this.querySubscribers.set(queryName, subs);
+      }
+      subs.add(clientId);
+    }
+  }
+  unsubscribe(clientId, queryName) {
+    const session = this.sessions.get(clientId);
+    if (session) {
+      session.subscriptions.delete(queryName);
+      const subs = this.querySubscribers.get(queryName);
+      if (subs) {
+        subs.delete(clientId);
+        if (subs.size === 0)
+          this.querySubscribers.delete(queryName);
+      }
+    }
+  }
+  updateWatermark(clientId, hlc) {
+    const session = this.sessions.get(clientId);
+    if (session) {
+      if (!session.watermark || hlc > session.watermark) {
+        session.watermark = hlc;
+      }
+    }
+  }
+  getSubscribersForQuery(queryName, roomKey) {
+    const clientIds = this.querySubscribers.get(queryName);
+    if (!clientIds)
+      return [];
+    const result = [];
+    for (const clientId of clientIds) {
+      const session = this.sessions.get(clientId);
+      if (!session)
+        continue;
+      if (roomKey !== undefined && roomKey !== null) {
+        const sub = session.subscriptions.get(queryName);
+        if (!sub || sub.roomKey !== roomKey)
+          continue;
+      }
+      result.push(session);
+    }
+    return result;
+  }
+  getSubscribersForTableDependency(tableDependencyIndex, tableName) {
+    const affectedQueries = tableDependencyIndex.get(tableName);
+    if (!affectedQueries)
+      return [];
+    const result = [];
+    for (const queryName of affectedQueries) {
+      const clientIds = this.querySubscribers.get(queryName);
+      if (!clientIds)
+        continue;
+      for (const clientId of clientIds) {
+        const session = this.sessions.get(clientId);
+        if (session) {
+          result.push({ session, queryName });
+        }
+      }
+    }
+    return result;
+  }
+  getAll() {
+    return Array.from(this.sessions.values());
+  }
+  size() {
+    return this.sessions.size;
+  }
+}
+
+// src/server/result-cache.ts
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a !== "object")
+    return false;
+  if (a instanceof Date || b instanceof Date) {
+    return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+  }
+  const aIsArray = Array.isArray(a);
+  const bIsArray = Array.isArray(b);
+  if (aIsArray !== bIsArray)
+    return false;
+  if (aIsArray) {
+    const aArr = a;
+    const bArr = b;
+    if (aArr.length !== bArr.length)
+      return false;
+    for (let i = 0;i < aArr.length; i++) {
+      if (!deepEqual(aArr[i], bArr[i]))
+        return false;
+    }
+    return true;
+  }
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  for (const key of aKeys) {
+    if (!Object.prototype.hasOwnProperty.call(bObj, key))
+      return false;
+    if (!deepEqual(aObj[key], bObj[key]))
+      return false;
+  }
+  return true;
+}
+
+class ResultCache {
+  cache = new Map;
+  set(clientId, queryName, rows, idField = "id") {
+    const clientCache = this.getOrCreateClientCache(clientId);
+    const oldRows = clientCache.get(queryName) ?? new Map;
+    const newRows = new Map;
+    for (const row of rows) {
+      const rowId = String(row[idField] ?? "");
+      if (rowId) {
+        newRows.set(rowId, row);
+      }
+    }
+    const diff = this.diff(oldRows, newRows);
+    clientCache.set(queryName, newRows);
+    return diff;
+  }
+  get(clientId, queryName) {
+    return this.cache.get(clientId)?.get(queryName) ?? new Map;
+  }
+  diffOnly(clientId, queryName, rows, idField = "id") {
+    const oldRows = this.cache.get(clientId)?.get(queryName) ?? new Map;
+    const newRows = new Map;
+    for (const row of rows) {
+      const rowId = String(row[idField] ?? "");
+      if (rowId)
+        newRows.set(rowId, row);
+    }
+    return this.diff(oldRows, newRows);
+  }
+  clear(clientId, queryName) {
+    this.cache.get(clientId)?.delete(queryName);
+  }
+  clearClient(clientId) {
+    this.cache.delete(clientId);
+  }
+  getOrCreateClientCache(clientId) {
+    let clientCache = this.cache.get(clientId);
+    if (!clientCache) {
+      clientCache = new Map;
+      this.cache.set(clientId, clientCache);
+    }
+    return clientCache;
+  }
+  diff(oldRows, newRows) {
+    const inserted = [];
+    const updated = [];
+    const deleted = [];
+    for (const [rowId, newRow] of newRows) {
+      const oldRow = oldRows.get(rowId);
+      if (!oldRow) {
+        inserted.push({ rowId, data: newRow });
+      } else {
+        const changed = this.fieldDiff(oldRow, newRow);
+        if (changed) {
+          updated.push({ rowId, changed });
+        }
+      }
+    }
+    for (const rowId of oldRows.keys()) {
+      if (!newRows.has(rowId)) {
+        deleted.push(rowId);
+      }
+    }
+    return { inserted, updated, deleted };
+  }
+  fieldDiff(oldRow, newRow) {
+    const changed = {};
+    let hasChanges = false;
+    for (const [key, newValue] of Object.entries(newRow)) {
+      const oldValue = oldRow[key];
+      const equal = deepEqual(oldValue, newValue);
+      if (!equal) {
+        changed[key] = newValue;
+        hasChanges = true;
+      }
+    }
+    for (const key of Object.keys(oldRow)) {
+      if (!(key in newRow)) {
+        changed[key] = null;
+        hasChanges = true;
+      }
+    }
+    return hasChanges ? changed : null;
+  }
+}
+
+// src/server/broadcast-engine.ts
+function stableStringify(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value))
+    return `[${value.map(stableStringify).join(",")}]`;
+  if (value instanceof Date)
+    return JSON.stringify(value.toISOString());
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  const parts = [];
+  for (const key of keys) {
+    if (obj[key] === undefined)
+      continue;
+    parts.push(`${JSON.stringify(key)}:${stableStringify(obj[key])}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+
+class BroadcastEngine {
+  deps;
+  locks = new Map;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  withLock(clientId, queryName, fn) {
+    const key = `${clientId.length}:${clientId}:${queryName}`;
+    const prev = this.locks.get(key) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    const stored = next.then(() => {
+      if (this.locks.get(key) === stored)
+        this.locks.delete(key);
+    }, () => {
+      if (this.locks.get(key) === stored)
+        this.locks.delete(key);
+    });
+    this.locks.set(key, stored);
+    return next;
+  }
+  async executeWithTimeout(reg, session, limit) {
+    const timeoutMs = this.deps.queryTimeoutMs;
+    if (timeoutMs <= 0)
+      return this.deps.executeQuery(reg, session, limit);
+    let timer;
+    try {
+      return await Promise.race([
+        this.deps.executeQuery(reg, session, limit),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error(`[reflectdb] Query "${reg.name}" exceeded queryTimeoutMs (${timeoutMs}ms)`)), timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  async broadcastChanges(tableName, excludeClientId, overrideRoomKey) {
+    const affectedQueries = this.deps.tableDependencyIndex.get(tableName);
+    if (!affectedQueries)
+      return;
+    const hlcStr = this.deps.nextHlc();
+    for (const queryName of affectedQueries) {
+      const queryReg = this.deps.queries.get(queryName);
+      if (!queryReg)
+        continue;
+      const groups = this.buildGroups(queryReg, excludeClientId, overrideRoomKey);
+      if (groups.length === 0)
+        continue;
+      await this.runBounded(groups, (group) => this.broadcastGroup(queryReg, group, hlcStr));
+    }
+  }
+  buildGroups(queryReg, excludeClientId, overrideRoomKey) {
+    const queryName = queryReg.name;
+    let senderRoomKey;
+    if (overrideRoomKey !== undefined) {
+      senderRoomKey = overrideRoomKey;
+    } else {
+      const senderSession = this.deps.sessions.get(excludeClientId);
+      const senderSub = senderSession?.subscriptions.get(queryName);
+      senderRoomKey = senderSub ? senderSub.roomKey : undefined;
+    }
+    const subscribers = this.deps.sessions.getSubscribersForQuery(queryName, senderRoomKey);
+    const groups = new Map;
+    for (const session of subscribers) {
+      if (session.clientId === excludeClientId)
+        continue;
+      const sub = session.subscriptions.get(queryName);
+      if (!sub)
+        continue;
+      if (sub.windowSize != null && !sub.bootstrapped)
+        continue;
+      const key = this.groupKeyFor(queryReg, session, sub);
+      let group = groups.get(key);
+      if (!group) {
+        group = [];
+        groups.set(key, group);
+      }
+      group.push({ session, sub });
+    }
+    return [...groups.values()];
+  }
+  groupKeyFor(queryReg, session, sub) {
+    const custom = queryReg.options.groupBy;
+    if (custom) {
+      try {
+        return `custom:${custom({ auth: session.auth, params: sub.params })}|${sub.roomKey ?? ""}`;
+      } catch (err) {
+        console.error(`[reflectdb] Query "${queryReg.name}" groupBy threw; falling back to per-identity grouping:`, err);
+      }
+    }
+    return stableStringify({
+      auth: session.auth,
+      params: sub.params,
+      roomKey: sub.roomKey
+    });
+  }
+  limitFor(queryReg, group) {
+    let maxWindow = 0;
+    for (const { sub } of group) {
+      if (sub.windowSize == null)
+        return;
+      maxWindow = Math.max(maxWindow, sub.windowLimit);
+    }
+    if (queryReg.options.countHints && !queryReg.options.count)
+      return;
+    return maxWindow > 0 ? maxWindow : undefined;
+  }
+  async broadcastGroup(queryReg, group, hlcStr) {
+    const queryName = queryReg.name;
+    const representative = group[0];
+    const limit = this.limitFor(queryReg, group);
+    let fullRows;
+    try {
+      fullRows = await this.executeWithTimeout(queryReg, representative.session, limit);
+    } catch (err) {
+      console.error(`[reflectdb] Query "${queryName}" failed for group (client ${representative.session.clientId}), skipping broadcast:`, err);
+      this.deps.emit({
+        type: "query_error",
+        clientId: representative.session.clientId,
+        queryName,
+        phase: "broadcast",
+        error: err
+      });
+      return;
+    }
+    let totalCount = null;
+    if (queryReg.options.countHints) {
+      try {
+        totalCount = queryReg.options.count ? await this.deps.countQuery(queryReg, representative.session) : fullRows.length;
+      } catch (err) {
+        console.error(`[reflectdb] Query "${queryName}" count callback failed:`, err);
+      }
+    }
+    const results = await Promise.allSettled(group.map(({ session, sub }) => this.sendToSubscriber(queryReg, session, sub, fullRows, totalCount, hlcStr)));
+    for (let i = 0;i < results.length; i++) {
+      const r = results[i];
+      if (r.status === "rejected") {
+        console.error(`[reflectdb] Broadcast to client ${group[i].session.clientId} for query "${queryName}" failed, skipping:`, r.reason);
+      }
+    }
+  }
+  sendToSubscriber(queryReg, session, sub, fullRows, totalCount, hlcStr) {
+    const queryName = queryReg.name;
+    const pk = queryReg.options.pk ?? "id";
+    const isWindowed = sub.windowSize != null;
+    return this.withLock(session.clientId, queryName, async () => {
+      const newRows = isWindowed ? fullRows.slice(0, sub.windowLimit) : fullRows;
+      const diff = this.deps.resultCache.diffOnly(session.clientId, queryName, newRows, pk);
+      const sendPromises = [];
+      for (const ins of diff.inserted) {
+        sendPromises.push(this.deps.send(session.clientId, {
+          type: "delta",
+          table: queryName,
+          op: "insert",
+          rowId: ins.rowId,
+          payload: ins.data,
+          hlc: hlcStr
+        }));
+      }
+      for (const upd of diff.updated) {
+        sendPromises.push(this.deps.send(session.clientId, {
+          type: "delta",
+          table: queryName,
+          op: "update",
+          rowId: upd.rowId,
+          payload: upd.changed,
+          hlc: hlcStr,
+          colClocks: Object.fromEntries(Object.keys(upd.changed).map((k) => [k, hlcStr]))
+        }));
+      }
+      for (const deletedRowId of diff.deleted) {
+        sendPromises.push(this.deps.send(session.clientId, {
+          type: "delta",
+          table: queryName,
+          op: "delete",
+          rowId: deletedRowId,
+          payload: null,
+          hlc: hlcStr
+        }));
+      }
+      let countToCommit = null;
+      if (isWindowed && queryReg.options.countHints && totalCount != null) {
+        if (totalCount !== sub.lastTotalCount) {
+          countToCommit = totalCount;
+          sendPromises.push(this.deps.send(session.clientId, {
+            type: "count_changed",
+            table: queryName,
+            totalCount
+          }));
+        }
+      }
+      if (sendPromises.length === 0) {
+        this.commit(session, queryName, newRows, pk);
+        return;
+      }
+      await Promise.all(sendPromises);
+      if (this.commit(session, queryName, newRows, pk) && countToCommit != null) {
+        sub.lastTotalCount = countToCommit;
+      }
+    });
+  }
+  commit(session, queryName, rows, pk) {
+    if (this.deps.sessions.get(session.clientId) !== session)
+      return false;
+    this.deps.resultCache.set(session.clientId, queryName, rows, pk);
+    return true;
+  }
+  async runBounded(items, fn) {
+    const limit = Math.max(1, this.deps.maxGroupConcurrency);
+    if (items.length === 1 || limit === 1) {
+      for (const item of items) {
+        try {
+          await fn(item);
+        } catch (err) {
+          console.error("[reflectdb] broadcast group failed:", err);
+        }
+      }
+      return;
+    }
+    let cursor = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+      while (cursor < items.length) {
+        const item = items[cursor++];
+        try {
+          await fn(item);
+        } catch (err) {
+          console.error("[reflectdb] broadcast group failed:", err);
+        }
+      }
+    });
+    await Promise.all(workers);
+  }
+}
+
+// src/server/op-processor.ts
+init_types();
+
+// src/server/conflict.ts
+init_types();
+function resolveConflict(policy, incoming, existing) {
+  if (typeof policy === "object" && policy.policy === "custom") {
+    return resolveCustom(policy.resolve, incoming, existing);
+  }
+  switch (policy) {
+    case "lww":
+      return resolveLww(incoming, existing);
+    case "merge":
+      return resolveMerge(incoming, existing);
+    case "server":
+      return resolveServer(incoming, existing);
+    default:
+      return resolveLww(incoming, existing);
+  }
+}
+function resolveLww(incoming, existing) {
+  if (!existing.row || !existing.rowHlc) {
+    return {
+      accepted: true,
+      resolvedRow: incoming.op === "delete" ? null : incoming.payload,
+      updatedColClocks: buildColClocks(incoming)
+    };
+  }
+  if (compareHlc(incoming.hlc, existing.rowHlc) > 0) {
+    if (incoming.op === "delete") {
+      return {
+        accepted: true,
+        resolvedRow: null,
+        updatedColClocks: { ...existing.colClocks, _row: incoming.hlc }
+      };
+    }
+    const resolvedRow = incoming.op === "update" ? { ...existing.row, ...incoming.payload } : incoming.payload;
+    const clocks = { ...existing.colClocks, _row: incoming.hlc };
+    if (incoming.payload) {
+      for (const col of Object.keys(incoming.payload)) {
+        clocks[col] = incoming.hlc;
+      }
+    }
+    if (incoming.op === "insert" && incoming.payload) {
+      for (const col of Object.keys(incoming.payload)) {
+        clocks[col] = incoming.hlc;
+      }
+    }
+    return {
+      accepted: true,
+      resolvedRow,
+      updatedColClocks: clocks
+    };
+  }
+  return {
+    accepted: false,
+    resolvedRow: existing.row,
+    updatedColClocks: existing.colClocks
+  };
+}
+function resolveMerge(incoming, existing) {
+  if (!existing.row || !existing.rowHlc) {
+    return {
+      accepted: true,
+      resolvedRow: incoming.op === "delete" ? null : incoming.payload,
+      updatedColClocks: buildColClocks(incoming)
+    };
+  }
+  if (incoming.op === "delete") {
+    if (compareHlc(incoming.hlc, existing.rowHlc) > 0) {
+      return {
+        accepted: true,
+        resolvedRow: null,
+        updatedColClocks: { ...existing.colClocks, _row: incoming.hlc }
+      };
+    }
+    return {
+      accepted: false,
+      resolvedRow: existing.row,
+      updatedColClocks: existing.colClocks,
+      reason: "merge_stale"
+    };
+  }
+  const payload = incoming.payload ?? {};
+  const merged = { ...existing.row };
+  const clocks = { ...existing.colClocks };
+  let anyAccepted = false;
+  for (const [col, value] of Object.entries(payload)) {
+    const existingClock = clocks[col];
+    if (!existingClock || compareHlc(incoming.hlc, existingClock) > 0) {
+      merged[col] = value;
+      clocks[col] = incoming.hlc;
+      anyAccepted = true;
+    }
+  }
+  if (anyAccepted && (!clocks["_row"] || compareHlc(incoming.hlc, clocks["_row"]) > 0)) {
+    clocks["_row"] = incoming.hlc;
+  }
+  if (!anyAccepted) {
+    return {
+      accepted: false,
+      resolvedRow: existing.row,
+      updatedColClocks: existing.colClocks,
+      reason: "merge_stale"
+    };
+  }
+  return {
+    accepted: true,
+    resolvedRow: merged,
+    updatedColClocks: clocks
+  };
+}
+function resolveServer(incoming, existing) {
+  if (!existing.row) {
+    return {
+      accepted: true,
+      resolvedRow: incoming.op === "delete" ? null : incoming.payload,
+      updatedColClocks: buildColClocks(incoming)
+    };
+  }
+  return {
+    accepted: false,
+    resolvedRow: existing.row,
+    updatedColClocks: existing.colClocks,
+    reason: "server_conflict"
+  };
+}
+function resolveCustom(resolve, incoming, existing) {
+  if (!existing.row) {
+    return {
+      accepted: true,
+      resolvedRow: incoming.op === "delete" ? null : incoming.payload,
+      updatedColClocks: buildColClocks(incoming)
+    };
+  }
+  let result;
+  try {
+    result = resolve({ op: incoming.op, payload: incoming.payload, hlc: incoming.hlc }, { row: existing.row, colClocks: existing.colClocks }, {
+      table: incoming.tableName,
+      rowId: incoming.rowId,
+      userId: incoming.userId
+    });
+  } catch (err) {
+    if (err instanceof MutationError) {
+      return {
+        accepted: false,
+        resolvedRow: existing.row,
+        updatedColClocks: existing.colClocks,
+        reason: err.reason
+      };
+    }
+    console.error(`[reflectdb] Custom conflict resolver threw for ${incoming.tableName}/${incoming.rowId}:`, err);
+    return {
+      accepted: false,
+      resolvedRow: existing.row,
+      updatedColClocks: existing.colClocks,
+      reason: "server_error"
+    };
+  }
+  const clocks = { ...existing.colClocks };
+  let anyChanged = false;
+  for (const [col, value] of Object.entries(result.row)) {
+    if (existing.row[col] !== value) {
+      clocks[col] = incoming.hlc;
+      anyChanged = true;
+    }
+  }
+  if (anyChanged) {
+    clocks["_row"] = incoming.hlc;
+  }
+  return {
+    accepted: true,
+    resolvedRow: result.row,
+    updatedColClocks: clocks
+  };
+}
+function buildColClocks(incoming) {
+  const clocks = { _row: incoming.hlc };
+  if (incoming.payload) {
+    for (const col of Object.keys(incoming.payload)) {
+      clocks[col] = incoming.hlc;
+    }
+  }
+  return clocks;
+}
+
+// src/server/pipeline.ts
+function processOp(op, existing, ctx) {
+  const drift = enforceClockDrift(op.hlc);
+  if (!drift.ok) {
+    return reject(op, existing, drift.reason);
+  }
+  if (ctx.rateLimiter) {
+    try {
+      const rate = ctx.rateLimiter.check(ctx.userId, ctx.nodeId, op.table);
+      if (!rate.ok) {
+        return reject(op, existing, rate.reason);
+      }
+      ctx.rateLimiter.record(ctx.userId, ctx.nodeId, op.table);
+    } catch (err) {
+      console.error("[reflectdb] Rate limiter error (fail-open):", err);
+    }
+  }
+  if (ctx.maxBatchSize !== undefined) {
+    const batch = enforceBatchSize(op.batchSize, ctx.maxBatchSize);
+    if (!batch.ok) {
+      return reject(op, existing, batch.reason);
+    }
+  }
+  op = enforceReadonly(op, ctx.options);
+  op = enforceServerSet(op, ctx.options);
+  const conflict = resolveConflict(ctx.conflict, {
+    op: op.op,
+    payload: op.payload,
+    hlc: op.hlc,
+    rowId: op.rowId,
+    tableName: op.table,
+    userId: ctx.userId
+  }, existing);
+  return {
+    accepted: conflict.accepted,
+    op,
+    resolvedRow: conflict.resolvedRow,
+    updatedColClocks: conflict.updatedColClocks,
+    reason: conflict.reason
+  };
+}
+function reject(op, existing, reason) {
+  return {
+    accepted: false,
+    op,
+    resolvedRow: existing.row,
+    updatedColClocks: existing.colClocks,
+    reason
+  };
+}
+
+// src/server/op-processor.ts
+class OpProcessor {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get storage() {
+    return this.deps.getStorage();
+  }
+  get rateLimiter() {
+    return this.deps.getRateLimiter();
+  }
+  get maxBatchSize() {
+    return this.deps.getMaxBatchSize();
+  }
+  get db() {
+    return this.deps.db;
+  }
+  get queries() {
+    return this.deps.queries;
+  }
+  get sessions() {
+    return this.deps.sessions;
+  }
+  get eagerBuffer() {
+    return this.deps.eagerBuffer;
+  }
+  get replay() {
+    return this.deps.replay;
+  }
+  static rowKey(table, rowId) {
+    return `${table.length}:${table}:${rowId}`;
+  }
+  async prefetchBatch(ops) {
+    const freshOpIds = new Set;
+    const rows = new Map;
+    const reservable = ops.filter((op) => {
+      const reg = this.queries.get(op.table);
+      return reg != null && reg.options.mutate != null;
+    });
+    if (this.storage?.reserveOps) {
+      for (const id of await this.storage.reserveOps(reservable.map((o) => o.id))) {
+        freshOpIds.add(id);
+      }
+    } else {
+      for (const op of reservable) {
+        if (await this.replay.reserve(op.id))
+          freshOpIds.add(op.id);
+      }
+    }
+    if (this.storage?.getRowsByIds) {
+      const byTable = new Map;
+      for (const op of ops) {
+        if (!freshOpIds.has(op.id))
+          continue;
+        let ids = byTable.get(op.table);
+        if (!ids) {
+          ids = new Set;
+          byTable.set(op.table, ids);
+        }
+        ids.add(op.rowId);
+      }
+      const reads = [...byTable].map(async ([table, ids]) => {
+        const found = await this.storage.getRowsByIds(table, [...ids]);
+        for (const rowId of ids) {
+          rows.set(OpProcessor.rowKey(table, rowId), found[rowId] ?? { row: null, rowHlc: null, colClocks: {} });
+        }
+      });
+      const results = await Promise.allSettled(reads);
+      for (const r of results) {
+        if (r.status === "rejected") {
+          console.warn("[reflectdb] batch row prefetch failed, falling back to getRow:", r.reason);
+        }
+      }
+    }
+    return { freshOpIds, rows };
+  }
+  async readRow(table, rowId, batchCtx) {
+    const cached = batchCtx?.rows.get(OpProcessor.rowKey(table, rowId));
+    if (cached)
+      return cached;
+    if (!this.storage)
+      return { row: null, rowHlc: null, colClocks: {} };
+    const existing = await this.storage.getRow(table, rowId);
+    batchCtx?.rows.set(OpProcessor.rowKey(table, rowId), existing);
+    return existing;
+  }
+  recordBatchWrite(batchCtx, table, rowId, row, colClocks, hlc) {
+    batchCtx?.rows.set(OpProcessor.rowKey(table, rowId), {
+      row,
+      rowHlc: hlc,
+      colClocks
+    });
+  }
+  async processClientOp(op, session, deferredBroadcastTables, batchCtx) {
+    const queryReg = this.queries.get(op.table);
+    if (!queryReg) {
+      return { accepted: false, reason: "outside_shape" };
+    }
+    if (!queryReg.options.mutate) {
+      return { accepted: false, reason: "readonly_query" };
+    }
+    const fresh = batchCtx ? batchCtx.freshOpIds.delete(op.id) : await this.replay.reserve(op.id);
+    if (!fresh) {
+      return { accepted: true };
+    }
+    this.deps.receiveClientHlc(op.hlc);
+    if (queryReg.options.broadcast === "eager" || queryReg.options.broadcast === "eager-durable") {
+      if (deferredBroadcastTables && deferredBroadcastTables.size > 0) {
+        const pending = [...deferredBroadcastTables];
+        deferredBroadcastTables.clear();
+        for (const table of pending) {
+          await this.deps.broadcastChanges(table, session.clientId);
+        }
+      }
+      return this.processEagerOp(op, queryReg, session, batchCtx);
+    }
+    return this.processConsistentOp(op, queryReg, session, deferredBroadcastTables, batchCtx);
+  }
+  async processEagerOp(op, queryReg, session, batchCtx) {
+    const drift = enforceClockDrift(op.hlc);
+    if (!drift.ok) {
+      return { accepted: false, reason: drift.reason };
+    }
+    const batch = enforceBatchSize(op.batchSize, this.maxBatchSize);
+    if (!batch.ok) {
+      return { accepted: false, reason: batch.reason };
+    }
+    if (this.rateLimiter) {
+      try {
+        const result = this.rateLimiter.check(session.auth.userId, session.clientId, op.table);
+        if (!result.ok) {
+          return { accepted: false, reason: "rate_limited" };
+        }
+        this.rateLimiter.record(session.auth.userId, session.clientId, op.table);
+      } catch (err) {
+        console.error("[reflectdb] Rate limiter error (fail-open):", err);
+      }
+    }
+    const enforceSub = session.subscriptions.get(op.table);
+    let enforcedOptions = queryReg.options;
+    if (enforcedOptions.serverSet && Object.keys(enforcedOptions.serverSet).length > 0) {
+      const serverSetCtx = { auth: session.auth, params: enforceSub?.params ?? {} };
+      const resolvedServerSet = {};
+      for (const [key, value] of Object.entries(enforcedOptions.serverSet)) {
+        resolvedServerSet[key] = typeof value === "function" ? value(serverSetCtx) : value;
+      }
+      enforcedOptions = { ...enforcedOptions, serverSet: resolvedServerSet };
+    }
+    op = enforceServerSet(enforceReadonly(op, enforcedOptions), enforcedOptions);
+    const hlcStr = this.deps.stampHlc();
+    const payload = op.payload;
+    let mergedRow = payload;
+    const colClocks = {};
+    if (payload) {
+      for (const key of Object.keys(payload)) {
+        colClocks[key] = hlcStr;
+      }
+    }
+    colClocks._row = hlcStr;
+    if (op.op === "update" && payload && this.storage) {
+      try {
+        const existing = await this.readRow(op.table, op.rowId, batchCtx);
+        if (existing.row) {
+          mergedRow = { ...existing.row, ...payload };
+          const merged = { ...existing.colClocks };
+          for (const k of Object.keys(payload))
+            merged[k] = hlcStr;
+          merged._row = hlcStr;
+          Object.assign(colClocks, merged);
+        }
+      } catch (err) {
+        console.error("[reflectdb] eager update: getRow failed, applying payload as-is:", err);
+      }
+    }
+    const resolvedOp = {
+      type: op.op,
+      table: op.table,
+      rowId: op.rowId,
+      payload,
+      hlc: hlcStr
+    };
+    const sub = session.subscriptions.get(op.table);
+    const mutCtx = {
+      auth: session.auth,
+      params: sub?.params ?? {}
+    };
+    if (queryReg.options.authorize) {
+      try {
+        await queryReg.options.authorize({ type: "write", table: op.table, op: resolvedOp }, mutCtx, this.db);
+      } catch (err) {
+        const reason = reasonFromError(err);
+        return { accepted: false, reason };
+      }
+    }
+    const bufferEntry = {
+      entry: {
+        table: op.table,
+        op: op.op,
+        rowId: op.rowId,
+        payload,
+        hlc: hlcStr,
+        colClocks
+      },
+      row: mergedRow
+    };
+    if (!this.eagerBuffer.hasCapacity(op.table, queryReg.options.maxBufferSize)) {
+      return { accepted: false, reason: "buffer_full" };
+    }
+    let mutateResult;
+    if (queryReg.options.mutate) {
+      try {
+        const result = await queryReg.options.mutate(resolvedOp, mutCtx, this.db);
+        if (result)
+          mutateResult = result;
+      } catch (err) {
+        const reason = reasonFromError(err);
+        return { accepted: false, reason };
+      }
+    }
+    if (queryReg.options.broadcast === "eager-durable" && this.storage) {
+      await this.storage.applyOp(op.table, op.rowId, mergedRow, colClocks, hlcStr, op.op, payload);
+      this.recordBatchWrite(batchCtx, op.table, op.rowId, mergedRow, colClocks, hlcStr);
+    } else {
+      const pushed = this.eagerBuffer.push(op.table, bufferEntry, queryReg.options.maxBufferSize);
+      this.recordBatchWrite(batchCtx, op.table, op.rowId, mergedRow, colClocks, hlcStr);
+      if (!pushed && this.storage) {
+        try {
+          await this.storage.applyOp(op.table, op.rowId, mergedRow, colClocks, hlcStr, op.op, payload);
+        } catch (err) {
+          console.error("[reflectdb] eager fallback applyOp after buffer overflow failed:", err);
+        }
+      }
+    }
+    const senderSession = this.sessions.get(session.clientId);
+    const senderSub = senderSession?.subscriptions.get(op.table);
+    const senderRoomKey = senderSub ? senderSub.roomKey : undefined;
+    const subscribers = this.sessions.getSubscribersForQuery(op.table, senderRoomKey);
+    const eagerSendPromises = [];
+    for (const sub2 of subscribers) {
+      if (sub2.clientId === session.clientId)
+        continue;
+      eagerSendPromises.push(this.deps.send(sub2.clientId, {
+        type: "delta",
+        table: op.table,
+        op: op.op,
+        rowId: op.rowId,
+        payload,
+        hlc: hlcStr,
+        colClocks
+      }));
+    }
+    const eagerResults = await Promise.allSettled(eagerSendPromises);
+    for (const r of eagerResults) {
+      if (r.status === "rejected") {
+        console.error("[reflectdb] eager broadcast send failed:", r.reason);
+      }
+    }
+    if (mutateResult?.affected) {
+      for (const affectedTable of mutateResult.affected) {
+        await this.deps.broadcastChanges(affectedTable, session.clientId);
+      }
+    }
+    return { accepted: true };
+  }
+  async processConsistentOp(op, queryReg, session, deferredBroadcastTables, batchCtx) {
+    let options = queryReg.options;
+    if (options.serverSet && Object.keys(options.serverSet).length > 0) {
+      const sub = session.subscriptions.get(op.table);
+      const mutCtx = { auth: session.auth, params: sub?.params ?? {} };
+      const resolvedServerSet = {};
+      for (const [key, value] of Object.entries(options.serverSet)) {
+        resolvedServerSet[key] = typeof value === "function" ? value(mutCtx) : value;
+      }
+      options = { ...options, serverSet: resolvedServerSet };
+    }
+    let existing = { row: null, rowHlc: null, colClocks: {} };
+    if (this.storage) {
+      existing = await this.readRow(op.table, op.rowId, batchCtx);
+    }
+    const ctx = {
+      userId: session.auth.userId,
+      nodeId: session.clientId,
+      options,
+      conflict: options.conflict ?? "lww",
+      rateLimiter: this.rateLimiter ?? undefined,
+      maxBatchSize: this.maxBatchSize
+    };
+    const result = processOp(op, existing, ctx);
+    if (result.accepted) {
+      const resolvedOp = {
+        type: op.op,
+        table: op.table,
+        rowId: op.rowId,
+        payload: result.resolvedRow,
+        hlc: op.hlc
+      };
+      const sub = session.subscriptions.get(op.table);
+      const mutCtx = {
+        auth: session.auth,
+        params: sub?.params ?? {}
+      };
+      if (queryReg.options.authorize) {
+        try {
+          await queryReg.options.authorize({ type: "write", table: op.table, op: resolvedOp }, mutCtx, this.db);
+        } catch (err) {
+          const reason = reasonFromError(err);
+          return { accepted: false, reason, serverRow: existing.row };
+        }
+      }
+      let mutateResult = undefined;
+      if (queryReg.options.mutate) {
+        try {
+          mutateResult = await queryReg.options.mutate(resolvedOp, mutCtx, this.db);
+        } catch (err) {
+          const reason = reasonFromError(err);
+          return { accepted: false, reason, serverRow: existing.row };
+        }
+      }
+      if (this.storage) {
+        await this.storage.applyOp(op.table, op.rowId, result.resolvedRow, result.updatedColClocks, op.hlc, op.op, result.resolvedRow);
+        this.recordBatchWrite(batchCtx, op.table, op.rowId, result.resolvedRow, result.updatedColClocks, op.hlc);
+      }
+      if (deferredBroadcastTables) {
+        deferredBroadcastTables.add(op.table);
+        if (mutateResult?.affected) {
+          for (const affectedTable of mutateResult.affected) {
+            deferredBroadcastTables.add(affectedTable);
+          }
+        }
+      } else {
+        const tablesToBroadcast = new Set([op.table]);
+        if (mutateResult?.affected) {
+          for (const affectedTable of mutateResult.affected) {
+            tablesToBroadcast.add(affectedTable);
+          }
+        }
+        for (const table of tablesToBroadcast) {
+          await this.deps.broadcastChanges(table, session.clientId);
+        }
+      }
+    }
+    return {
+      accepted: result.accepted,
+      reason: result.reason,
+      serverRow: result.accepted ? undefined : existing.row
+    };
+  }
+}
+
+// src/server/ephemeral-manager.ts
+var DEFAULT_MAX_ENTRIES = 1e4;
+function indexKey(room, key, userId) {
+  return `${room}\x00${key}\x00${userId}`;
+}
+function parseIndexKey(packed) {
+  const [room, key, userId] = packed.split("\x00");
+  return { room, key, userId };
+}
+
+class EphemeralManager {
+  store = new Map;
+  clientIndex = new Map;
+  entryCount = 0;
+  maxEntries;
+  constructor(maxEntries) {
+    this.maxEntries = maxEntries ?? DEFAULT_MAX_ENTRIES;
+  }
+  set(room, key, clientId, userId, data, ttlMs) {
+    const roomMap = this.store.get(room) ?? new Map;
+    const keyMap = roomMap.get(key) ?? new Map;
+    const isUpdate = keyMap.has(userId);
+    if (!isUpdate && this.entryCount >= this.maxEntries) {
+      return false;
+    }
+    const state = {
+      clientId,
+      userId,
+      key,
+      data,
+      updatedAt: Date.now(),
+      ttlMs
+    };
+    keyMap.set(userId, state);
+    roomMap.set(key, keyMap);
+    this.store.set(room, roomMap);
+    if (!isUpdate) {
+      this.entryCount++;
+      const clientSet = this.clientIndex.get(clientId) ?? new Set;
+      clientSet.add(indexKey(room, key, userId));
+      this.clientIndex.set(clientId, clientSet);
+    }
+    return true;
+  }
+  get(room, key) {
+    const roomMap = this.store.get(room);
+    if (!roomMap)
+      return {};
+    const keyMap = roomMap.get(key);
+    if (!keyMap)
+      return {};
+    return Object.fromEntries(keyMap.entries());
+  }
+  remove(room, key, userId) {
+    const roomMap = this.store.get(room);
+    if (!roomMap)
+      return;
+    const keyMap = roomMap.get(key);
+    if (!keyMap)
+      return;
+    if (keyMap.has(userId)) {
+      keyMap.delete(userId);
+      this.entryCount--;
+    }
+    if (keyMap.size === 0) {
+      roomMap.delete(key);
+    }
+    if (roomMap.size === 0) {
+      this.store.delete(room);
+    }
+  }
+  removeClient(clientId) {
+    const indices = this.clientIndex.get(clientId);
+    if (!indices)
+      return;
+    const entries = [...indices];
+    for (const packed of entries) {
+      const { room, key, userId } = parseIndexKey(packed);
+      this.remove(room, key, userId);
+    }
+    this.clientIndex.delete(clientId);
+  }
+  cleanupExpired() {
+    const now = Date.now();
+    const toRemove = [];
+    for (const [room, roomMap] of this.store) {
+      for (const [key, keyMap] of roomMap) {
+        for (const [userId, state] of keyMap) {
+          if (state.ttlMs && now - state.updatedAt > state.ttlMs) {
+            toRemove.push({ room, key, userId, clientId: state.clientId });
+          }
+        }
+      }
+    }
+    for (const { room, key, userId, clientId } of toRemove) {
+      this.remove(room, key, userId);
+      const clientSet = this.clientIndex.get(clientId);
+      if (clientSet) {
+        clientSet.delete(indexKey(room, key, userId));
+        if (clientSet.size === 0) {
+          this.clientIndex.delete(clientId);
+        }
+      }
+    }
+  }
+  get size() {
+    return this.entryCount;
+  }
+  destroy() {
+    this.store.clear();
+    this.clientIndex.clear();
+    this.entryCount = 0;
+  }
+}
+
+// src/server/eager-buffer.ts
+var DEFAULT_FLUSH_INTERVAL = 200;
+var DEFAULT_MAX_BUFFER_SIZE = 1000;
+
+class EagerBuffer {
+  buffers = new Map;
+  flushInterval;
+  maxBufferSize;
+  timer = null;
+  storage = null;
+  flushPromise = null;
+  onFlushError = null;
+  constructor(config) {
+    this.flushInterval = config?.flushInterval ?? DEFAULT_FLUSH_INTERVAL;
+    this.maxBufferSize = config?.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE;
+    this.onFlushError = config?.onFlushError ?? null;
+  }
+  setOnFlushError(handler) {
+    this.onFlushError = handler;
+  }
+  setStorage(storage) {
+    this.storage = ensureAtomicApplyOp(storage);
+  }
+  start(interval) {
+    const requested = interval ?? this.flushInterval;
+    const newInterval = Math.max(1, Math.min(this.flushInterval, requested));
+    if (this.timer) {
+      if (newInterval < this.flushInterval) {
+        clearInterval(this.timer);
+        this.flushInterval = newInterval;
+        this.timer = setInterval(() => {
+          this.flush();
+        }, this.flushInterval);
+      }
+      return;
+    }
+    this.flushInterval = newInterval;
+    this.timer = setInterval(() => {
+      this.flush();
+    }, this.flushInterval);
+  }
+  hasCapacity(queryName, maxSize) {
+    const buffer = this.buffers.get(queryName);
+    if (!buffer)
+      return true;
+    return buffer.length < (maxSize ?? this.maxBufferSize);
+  }
+  push(queryName, op, maxSize) {
+    let buffer = this.buffers.get(queryName);
+    if (!buffer) {
+      buffer = [];
+      this.buffers.set(queryName, buffer);
+    }
+    if (buffer.length >= (maxSize ?? this.maxBufferSize)) {
+      return false;
+    }
+    buffer.push(op);
+    return true;
+  }
+  async flush() {
+    if (this.flushPromise) {
+      return this.flushPromise;
+    }
+    this.flushPromise = this.doFlush();
+    try {
+      return await this.flushPromise;
+    } finally {
+      this.flushPromise = null;
+    }
+  }
+  async doFlush() {
+    let flushed = 0;
+    for (const [name, buffer] of this.buffers) {
+      if (buffer.length === 0)
+        continue;
+      const ops = buffer.splice(0, buffer.length);
+      if (this.storage) {
+        const storage = this.storage;
+        const results = await Promise.allSettled(ops.map((op) => storage.applyOp(op.entry.table, op.entry.rowId, op.row !== undefined ? op.row : op.entry.payload, op.entry.colClocks, op.entry.hlc, op.entry.op, op.entry.payload)));
+        const failedOps = [];
+        for (let i = 0;i < results.length; i++) {
+          const r = results[i];
+          if (r.status === "fulfilled") {
+            flushed++;
+          } else {
+            console.error("[reflectdb] EagerBuffer: failed to persist op:", r.reason);
+            failedOps.push(ops[i]);
+            if (this.onFlushError) {
+              try {
+                this.onFlushError(r.reason, ops[i]);
+              } catch (handlerErr) {
+                console.error("[reflectdb] EagerBuffer: onFlushError threw:", handlerErr);
+              }
+            }
+          }
+        }
+        if (failedOps.length > 0) {
+          buffer.unshift(...failedOps);
+        }
+      } else {
+        flushed += ops.length;
+      }
+    }
+    return flushed;
+  }
+  get pendingCount() {
+    let count = 0;
+    for (const buffer of this.buffers.values()) {
+      count += buffer.length;
+    }
+    return count;
+  }
+  queryPendingCount(queryName) {
+    return this.buffers.get(queryName)?.length ?? 0;
+  }
+  async close() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.flushPromise) {
+      await this.flushPromise;
+    }
+    await this.flush();
+  }
+}
+
+// src/server/message-validator.ts
+var VALID_CLIENT_MESSAGE_TYPES = new Set([
+  "hello",
+  "bootstrap",
+  "resume",
+  "ops",
+  "sync_declare",
+  "load_more",
+  "unsync",
+  "auth",
+  "ephemeral"
+]);
+var VALID_OP_TYPES = new Set(["insert", "update", "delete"]);
+var MAX_OPS_ARRAY = 1e4;
+var MAX_LOAD_MORE_COUNT = 1e5;
+function validateClientMessage(msg) {
+  if (msg == null || typeof msg !== "object") {
+    return { valid: false, error: "message is not an object" };
+  }
+  const m = msg;
+  if (typeof m.type !== "string" || !VALID_CLIENT_MESSAGE_TYPES.has(m.type)) {
+    return { valid: false, error: `invalid message type: ${JSON.stringify(m.type)}` };
+  }
+  switch (m.type) {
+    case "hello":
+      if (typeof m.protocolVersion !== "number")
+        return { valid: false, error: "hello: missing protocolVersion" };
+      if (typeof m.clientId !== "string")
+        return { valid: false, error: "hello: missing clientId" };
+      if (m.clientId.length === 0 || m.clientId.length > 256)
+        return { valid: false, error: "hello: clientId length out of range" };
+      if (typeof m.token !== "string")
+        return { valid: false, error: "hello: missing token" };
+      if (m.token.length > 16384)
+        return { valid: false, error: "hello: token too long" };
+      if (m.supportedVersions !== undefined) {
+        if (!Array.isArray(m.supportedVersions))
+          return { valid: false, error: "hello: supportedVersions must be array" };
+        if (m.supportedVersions.length > 32)
+          return { valid: false, error: "hello: supportedVersions too long" };
+      }
+      break;
+    case "resume":
+      if (typeof m.since !== "string")
+        return { valid: false, error: "resume: missing since" };
+      break;
+    case "ops":
+      if (!Array.isArray(m.ops))
+        return { valid: false, error: "ops: missing ops array" };
+      if (typeof m.token !== "string")
+        return { valid: false, error: "ops: missing token" };
+      if (m.ops.length > MAX_OPS_ARRAY)
+        return { valid: false, error: `ops: array length ${m.ops.length} exceeds ${MAX_OPS_ARRAY}` };
+      for (let i = 0;i < m.ops.length; i++) {
+        const op = m.ops[i];
+        if (typeof op?.id !== "string")
+          return { valid: false, error: `ops[${i}]: missing id` };
+        if (typeof op.table !== "string")
+          return { valid: false, error: `ops[${i}]: missing table` };
+        if (typeof op.op !== "string" || !VALID_OP_TYPES.has(op.op))
+          return { valid: false, error: `ops[${i}]: invalid op type` };
+        if (typeof op.rowId !== "string")
+          return { valid: false, error: `ops[${i}]: missing rowId` };
+        if (typeof op.hlc !== "string")
+          return { valid: false, error: `ops[${i}]: missing hlc` };
+        if (op.payload !== null && op.payload !== undefined) {
+          if (typeof op.payload !== "object" || Array.isArray(op.payload)) {
+            return { valid: false, error: `ops[${i}]: payload must be object or null` };
+          }
+        }
+      }
+      break;
+    case "sync_declare":
+      if (typeof m.table !== "string")
+        return { valid: false, error: "sync_declare: missing table" };
+      break;
+    case "load_more":
+      if (typeof m.table !== "string")
+        return { valid: false, error: "load_more: missing table" };
+      if (typeof m.count !== "number" || m.count <= 0 || m.count > MAX_LOAD_MORE_COUNT)
+        return { valid: false, error: "load_more: invalid count" };
+      break;
+    case "unsync":
+      if (typeof m.table !== "string")
+        return { valid: false, error: "unsync: missing table" };
+      break;
+    case "auth":
+      if (typeof m.token !== "string")
+        return { valid: false, error: "auth: missing token" };
+      break;
+    case "ephemeral":
+      if (typeof m.key !== "string")
+        return { valid: false, error: "ephemeral: missing key" };
+      if (typeof m.data !== "object" || m.data == null)
+        return { valid: false, error: "ephemeral: missing data" };
+      break;
+    case "bootstrap":
+      break;
+  }
+  return { valid: true, message: m };
+}
+
+// src/server/compaction-manager.ts
+class CompactionManager {
+  storage;
+  emit;
+  static MIN_COMPACTION_AGE_MS = 30000;
+  cutoffHlc = null;
+  cutoffLoaded = false;
+  constructor(storage, emit) {
+    this.storage = storage;
+    this.emit = emit;
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  getCutoff() {
+    return this.cutoffHlc;
+  }
+  async ensureCutoffLoaded() {
+    if (this.cutoffLoaded || !this.storage)
+      return;
+    this.cutoffLoaded = true;
+    const cutoff = await this.storage.getMeta("compactionCutoff");
+    if (cutoff) {
+      this.cutoffHlc = cutoff;
+    }
+  }
+  async runCompaction(minOpAge) {
+    if (!this.storage)
+      return 0;
+    const safeMinAge = Math.max(minOpAge, CompactionManager.MIN_COMPACTION_AGE_MS);
+    const lockKey = "compaction";
+    let acquired = true;
+    if (this.storage.tryLock) {
+      acquired = await this.storage.tryLock(lockKey);
+      if (!acquired) {
+        this.emit({ type: "compaction", deletedOps: 0 });
+        return 0;
+      }
+    }
+    try {
+      await this.ensureCutoffLoaded();
+      const cutoffMs = Date.now() - safeMinAge;
+      const cutoffHlc = String(cutoffMs).padStart(19, "0") + ".9999.compaction";
+      if (this.cutoffHlc && cutoffHlc <= this.cutoffHlc) {
+        this.emit({ type: "compaction", deletedOps: 0 });
+        return 0;
+      }
+      this.cutoffHlc = cutoffHlc;
+      await this.storage.setMeta("compactionCutoff", cutoffHlc);
+      const deleted = await this.storage.deleteOpsBefore(cutoffHlc);
+      if (deleted > 0) {
+        this.emit({ type: "compaction", deletedOps: deleted });
+      }
+      return deleted;
+    } finally {
+      if (acquired && this.storage.unlock) {
+        await this.storage.unlock(lockKey);
+      }
+    }
+  }
+}
+
+// src/server/replay-detector.ts
+class ReplayDetector {
+  storage;
+  static TTL_MS = 5 * 60000;
+  static MAX_ENTRIES = 1e4;
+  inMemory = new Map;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  async reserve(opId) {
+    if (this.storage) {
+      return this.storage.reserveOp(opId);
+    }
+    const now = Date.now();
+    const cutoff = now - ReplayDetector.TTL_MS;
+    if (this.inMemory.has(opId)) {
+      this.inMemory.set(opId, now);
+      return false;
+    }
+    if (this.inMemory.size >= ReplayDetector.MAX_ENTRIES) {
+      for (const [k, ts] of this.inMemory) {
+        if (ts < cutoff)
+          this.inMemory.delete(k);
+      }
+      if (this.inMemory.size >= ReplayDetector.MAX_ENTRIES) {
+        const iter = this.inMemory.keys();
+        const drop = Math.ceil(ReplayDetector.MAX_ENTRIES / 2);
+        for (let i = 0;i < drop; i++) {
+          const k = iter.next().value;
+          if (k === undefined)
+            break;
+          this.inMemory.delete(k);
+        }
+      }
+    }
+    this.inMemory.set(opId, now);
+    return true;
+  }
+}
+
+// src/server/rooms.ts
+function resolveRoomKey(rooms, params, requiredPattern) {
+  if (rooms.length === 0) {
+    if (requiredPattern) {
+      return {
+        ok: false,
+        reason: `Query requires room "${requiredPattern}" but no rooms are registered`
+      };
+    }
+    return { ok: true, roomKey: null };
+  }
+  for (const room of rooms) {
+    if (requiredPattern && room.pattern !== requiredPattern)
+      continue;
+    if (room.paramNames.length === 0) {
+      return { ok: true, roomKey: room.pattern };
+    }
+    const provided = room.paramNames.filter((name) => params[name] !== undefined && params[name] !== null);
+    if (provided.length === 0)
+      continue;
+    if (provided.length < room.paramNames.length) {
+      const missing = room.paramNames.filter((n) => !provided.includes(n));
+      return {
+        ok: false,
+        reason: `Room "${room.pattern}" is missing param(s): ${missing.join(", ")}`
+      };
+    }
+    const key = room.pattern.replace(/:(\w+)/g, (_, name) => String(params[name]));
+    if (!room.regex.test(key)) {
+      return {
+        ok: false,
+        reason: `Room "${room.pattern}" params do not form a valid room key`
+      };
+    }
+    return { ok: true, roomKey: key };
+  }
+  if (requiredPattern) {
+    return {
+      ok: false,
+      reason: `Query requires room "${requiredPattern}" but params do not resolve it`
+    };
+  }
+  return { ok: true, roomKey: null };
+}
+
+// src/server/handler.ts
+var DEFAULT_EPHEMERAL_PER_SECOND = 60;
+var applyOpShimWarned = new WeakSet;
+function ensureAtomicApplyOp(adapter) {
+  if (adapter.applyOp)
+    return adapter;
+  if (!applyOpShimWarned.has(adapter)) {
+    applyOpShimWarned.add(adapter);
+    console.warn("[reflectdb] StorageAdapter lacks atomic applyOp; using non-atomic shim. " + "Crash between putRow and appendOp can diverge. " + "Implement StorageAdapter.applyOp for crash safety.");
+  }
+  const wrapper = {
+    getRow: (...args) => adapter.getRow(...args),
+    putRow: (...args) => adapter.putRow(...args),
+    getRows: (...args) => adapter.getRows(...args),
+    appendOp: (...args) => adapter.appendOp(...args),
+    getOpsSince: (...args) => adapter.getOpsSince(...args),
+    deleteOpsBefore: (...args) => adapter.deleteOpsBefore(...args),
+    reserveOp: (...args) => adapter.reserveOp(...args),
+    getMeta: (...args) => adapter.getMeta(...args),
+    setMeta: (...args) => adapter.setMeta(...args),
+    applyOp: async (table, rowId, row, colClocks, hlc, opType, payload) => {
+      await adapter.putRow(table, rowId, row, colClocks, hlc);
+      await adapter.appendOp({ table, op: opType, rowId, payload, hlc, colClocks });
+    }
+  };
+  if (adapter.getRowsByIds) {
+    wrapper.getRowsByIds = (...args) => adapter.getRowsByIds(...args);
+  }
+  if (adapter.getChangedTablesSince) {
+    wrapper.getChangedTablesSince = (...args) => adapter.getChangedTablesSince(...args);
+  }
+  if (adapter.getOplogHead) {
+    wrapper.getOplogHead = (...args) => adapter.getOplogHead(...args);
+  }
+  if (adapter.reserveOps) {
+    wrapper.reserveOps = (...args) => adapter.reserveOps(...args);
+  }
+  if (adapter.tryLock) {
+    wrapper.tryLock = (...args) => adapter.tryLock(...args);
+  }
+  if (adapter.unlock) {
+    wrapper.unlock = (...args) => adapter.unlock(...args);
+  }
+  return wrapper;
+}
+
+class MessageHandler {
+  transport;
+  serverId;
+  db;
+  clock;
+  sessions;
+  authCallback = null;
+  queries = new Map;
+  rooms = [];
+  rateLimiter = null;
+  maxBatchSize = MAX_BATCH_SIZE;
+  storage = null;
+  minSchemaVersion = 0;
+  messageQueues = new Map;
+  resultCache = new ResultCache;
+  broadcast;
+  ops;
+  ephemeralManager = new EphemeralManager;
+  ephemeralCleanupTimer = null;
+  eagerBuffer = new EagerBuffer;
+  replay;
+  static MAX_EPHEMERAL_TTL_MS = 24 * 60 * 60 * 1000;
+  static AUTH_CACHE_TTL_MS = 5000;
+  authCache = new Map;
+  compaction;
+  messageQueueDepths = new Map;
+  static MAX_QUEUE_DEPTH = 100;
+  static eagerWarned = false;
+  static missingAuthWarned = false;
+  pollWatermark = null;
+  onEvent = null;
+  maxConnectionsPerUser = null;
+  allowAnonymous = false;
+  queryTimeoutMs = 0;
+  ephemeralPerSecond = DEFAULT_EPHEMERAL_PER_SECOND;
+  ephemeralBuckets = new Map;
+  tableDependencyIndex = new Map;
+  emit(event) {
+    try {
+      this.onEvent?.(event);
+    } catch {}
+  }
+  async trySend(clientId, message) {
+    try {
+      await this.transport.send(clientId, message);
+      return true;
+    } catch (err) {
+      console.warn(`[reflectdb] send to ${clientId} failed (${message.type}):`, err instanceof Error ? err.message : err);
+      return false;
+    }
+  }
+  constructor(config) {
+    this.transport = config.transport;
+    this.serverId = config.serverId;
+    this.db = config.db;
+    this.onEvent = config.onEvent ?? null;
+    this.maxConnectionsPerUser = config.maxConnectionsPerUser ?? null;
+    this.allowAnonymous = config.allowAnonymous ?? false;
+    this.queryTimeoutMs = config.queryTimeoutMs ?? 0;
+    this.clock = new ServerClock(`server:${config.serverId}`);
+    this.sessions = new SessionManager;
+    this.compaction = new CompactionManager(null, (e) => this.emit(e));
+    this.replay = new ReplayDetector(null);
+    this.broadcast = new BroadcastEngine({
+      sessions: this.sessions,
+      queries: this.queries,
+      tableDependencyIndex: this.tableDependencyIndex,
+      resultCache: this.resultCache,
+      send: (clientId, message) => this.transport.send(clientId, message),
+      executeQuery: (reg, session, limit) => this.executeQuery(reg, session, limit),
+      countQuery: (reg, session) => this.countQuery(reg, session),
+      nextHlc: () => this.clock.stamp(),
+      emit: (event) => this.emit(event),
+      queryTimeoutMs: this.queryTimeoutMs,
+      maxGroupConcurrency: config.maxBroadcastConcurrency ?? 8
+    });
+    this.ops = new OpProcessor({
+      db: this.db,
+      queries: this.queries,
+      sessions: this.sessions,
+      eagerBuffer: this.eagerBuffer,
+      replay: this.replay,
+      getStorage: () => this.storage,
+      getRateLimiter: () => this.rateLimiter,
+      getMaxBatchSize: () => this.maxBatchSize,
+      stampHlc: () => this.clock.stamp(),
+      receiveClientHlc: (hlc) => this.clock.receive(hlc),
+      send: (clientId, message) => this.transport.send(clientId, message),
+      broadcastChanges: (table, excludeClientId) => this.broadcastChanges(table, excludeClientId)
+    });
+    this.transport.onConnect((clientId) => {
+      this.sessions.connect(clientId);
+      this.emit({ type: "client_connected", clientId });
+    });
+    this.transport.onDisconnect((clientId) => {
+      this.sessions.disconnect(clientId);
+      this.messageQueues.delete(clientId);
+      this.messageQueueDepths.delete(clientId);
+      this.resultCache.clearClient(clientId);
+      this.ephemeralManager.removeClient(clientId);
+      this.ephemeralBuckets.delete(clientId);
+      this.emit({ type: "client_disconnected", clientId });
+    });
+    this.transport.onMessage((clientId, rawMessage) => {
+      const validation = validateClientMessage(rawMessage);
+      if (!validation.valid) {
+        console.warn(`[reflectdb] Invalid message from ${clientId}: ${validation.error}`);
+        this.emit({ type: "message_invalid", clientId, error: validation.error });
+        return;
+      }
+      const message = validation.message;
+      const depth = this.messageQueueDepths.get(clientId) ?? 0;
+      if (depth >= MessageHandler.MAX_QUEUE_DEPTH) {
+        this.emit({ type: "queue_overflow", clientId, depth });
+        const inflight = this.messageQueues.get(clientId) ?? Promise.resolve();
+        inflight.catch(() => {}).then(() => this.transport.send(clientId, {
+          type: "disconnect",
+          reason: "Message queue overflow"
+        }).catch(() => {})).then(() => this.transport.disconnect?.(clientId)).finally(() => {
+          this.sessions.disconnect(clientId);
+          this.messageQueues.delete(clientId);
+          this.messageQueueDepths.delete(clientId);
+          this.resultCache.clearClient(clientId);
+          this.ephemeralBuckets.delete(clientId);
+        });
+        return;
+      }
+      this.messageQueueDepths.set(clientId, depth + 1);
+      const prev = this.messageQueues.get(clientId) ?? Promise.resolve();
+      const next = prev.then(() => this.handleMessage(clientId, message).catch((err) => {
+        console.error(`Error handling message from ${clientId}:`, err);
+      })).finally(() => {
+        const current = this.messageQueueDepths.get(clientId);
+        if (current !== undefined) {
+          this.messageQueueDepths.set(clientId, current - 1);
+        }
+      });
+      this.messageQueues.set(clientId, next);
+    });
+    this.ephemeralCleanupTimer = setInterval(() => {
+      this.ephemeralManager.cleanupExpired();
+    }, 5000);
+    this.eagerBuffer.setOnFlushError((err, op) => {
+      this.emit({
+        type: "eager_flush_failed",
+        table: op.entry.table,
+        rowId: op.entry.rowId,
+        error: err
+      });
+    });
+  }
+  setAuth(callback) {
+    this.authCallback = callback;
+  }
+  setQuery(name, registration) {
+    if (typeof registration.callback !== "function") {
+      throw new TypeError(`[reflectdb] Query "${name}": callback must be a function`);
+    }
+    const opts = registration.options;
+    if (opts.mutate !== undefined && typeof opts.mutate !== "function") {
+      throw new TypeError(`[reflectdb] Query "${name}": options.mutate must be a function or undefined`);
+    }
+    if (opts.authorize !== undefined && typeof opts.authorize !== "function") {
+      throw new TypeError(`[reflectdb] Query "${name}": options.authorize must be a function or undefined`);
+    }
+    this.queries.set(name, registration);
+    for (const tableName of registration.tableDependencies) {
+      let queryNames = this.tableDependencyIndex.get(tableName);
+      if (!queryNames) {
+        queryNames = new Set;
+        this.tableDependencyIndex.set(tableName, queryNames);
+      }
+      queryNames.add(name);
+    }
+    if (registration.options.broadcast === "eager") {
+      this.eagerBuffer.start(registration.options.flushInterval);
+      if (!MessageHandler.eagerWarned) {
+        MessageHandler.eagerWarned = true;
+        console.warn(`[reflectdb] Query "${name}" uses broadcast: "eager" — at-most-once across server crash for the oplog. ` + `Use "eager-durable" unless your mutate hook writes durably to the user DB and you can tolerate resume-via-snapshot.`);
+      }
+    }
+  }
+  setRoom(registration) {
+    this.rooms.push(registration);
+  }
+  setRateLimiter(limiter) {
+    this.rateLimiter = limiter;
+  }
+  setEphemeralRateLimit(perSecond) {
+    this.ephemeralPerSecond = perSecond;
+  }
+  setMaxBatchSize(size) {
+    this.maxBatchSize = size;
+  }
+  setMaxEphemeralEntries(max) {
+    this.ephemeralManager = new EphemeralManager(max);
+  }
+  setMinSchemaVersion(version) {
+    this.minSchemaVersion = version;
+  }
+  setMaxConnectionsPerUser(max) {
+    this.maxConnectionsPerUser = max;
+  }
+  async enforceConnectionCap(userId, newClientId) {
+    if (!this.maxConnectionsPerUser || this.maxConnectionsPerUser <= 0)
+      return;
+    while (this.sessions.countForUser(userId) > this.maxConnectionsPerUser) {
+      const oldest = this.sessions.oldestForUser(userId);
+      if (!oldest || oldest.clientId === newClientId)
+        break;
+      await this.trySend(oldest.clientId, {
+        type: "disconnect",
+        reason: "Connection limit exceeded"
+      });
+      try {
+        await this.transport.disconnect?.(oldest.clientId);
+      } catch {}
+      this.sessions.disconnect(oldest.clientId);
+      this.messageQueues.delete(oldest.clientId);
+      this.messageQueueDepths.delete(oldest.clientId);
+      this.resultCache.clearClient(oldest.clientId);
+      this.ephemeralManager.removeClient(oldest.clientId);
+      this.ephemeralBuckets.delete(oldest.clientId);
+    }
+  }
+  setStorage(adapter) {
+    this.storage = ensureAtomicApplyOp(adapter);
+    this.eagerBuffer.setStorage(this.storage);
+    this.compaction.setStorage(this.storage);
+    this.replay.setStorage(this.storage);
+    this.clock.setStorage(this.storage);
+  }
+  async syncClockWatermark() {
+    await this.clock.refresh();
+  }
+  getSessions() {
+    return this.sessions;
+  }
+  getResultCache() {
+    return this.resultCache;
+  }
+  async handleMessage(clientId, message) {
+    await this.clock.ensureLoaded();
+    if (message.type !== "hello" && message.type !== "auth") {
+      const session = this.sessions.get(clientId);
+      if (!session || !session.auth) {
+        await this.trySend(clientId, {
+          type: "disconnect",
+          reason: "Not authenticated"
+        });
+        await this.transport.disconnect?.(clientId);
+        return;
+      }
+    }
+    switch (message.type) {
+      case "hello":
+        await this.handleHello(clientId, message);
+        break;
+      case "auth":
+        await this.handleAuth(clientId, message);
+        break;
+      case "bootstrap":
+        await this.handleBootstrap(clientId, message);
+        break;
+      case "resume":
+        await this.handleResume(clientId, message);
+        break;
+      case "ops":
+        await this.handleOps(clientId, message);
+        break;
+      case "sync_declare":
+        await this.handleSyncDeclare(clientId, message);
+        break;
+      case "load_more":
+        await this.handleLoadMore(clientId, message);
+        break;
+      case "unsync":
+        await this.handleUnsync(clientId, message);
+        break;
+      case "ephemeral":
+        await this.handleEphemeral(clientId, message);
+        break;
+    }
+  }
+  async handleHello(clientId, message) {
+    const clientVersions = message.supportedVersions ?? [message.protocolVersion];
+    const negotiated = [...SUPPORTED_PROTOCOL_VERSIONS].sort((a, b) => b - a).find((v) => clientVersions.includes(v));
+    if (negotiated == null) {
+      await this.trySend(clientId, {
+        type: "hello_reject",
+        reason: `Unsupported protocol version: ${message.protocolVersion}`,
+        supported: [...SUPPORTED_PROTOCOL_VERSIONS]
+      });
+      return;
+    }
+    if (!this.authCallback && !this.allowAnonymous) {
+      if (!MessageHandler.missingAuthWarned) {
+        MessageHandler.missingAuthWarned = true;
+        console.error("[reflectdb] No auth() callback registered. Every message after `hello` " + "would be rejected as unauthenticated. Call server.auth(fn), or pass " + "`allowAnonymous: true` to createServer for an unauthenticated server.");
+      }
+      await this.trySend(clientId, {
+        type: "hello_reject",
+        reason: "Server has no auth() configured",
+        supported: [...SUPPORTED_PROTOCOL_VERSIONS]
+      });
+      await this.transport.disconnect?.(clientId);
+      return;
+    }
+    if (this.authCallback) {
+      try {
+        const req = new Request("https://sync/hello", {
+          headers: { authorization: `Bearer ${message.token}` }
+        });
+        const auth = await this.authCallback(req);
+        this.sessions.setAuth(clientId, auth);
+        await this.enforceConnectionCap(auth.userId, clientId);
+      } catch (err) {
+        console.error(`[reflectdb] Auth callback failed for client ${clientId}:`, err);
+        this.emit({ type: "auth_failed", clientId, error: err });
+        await this.trySend(clientId, {
+          type: "hello_reject",
+          reason: "Authentication failed",
+          supported: [PROTOCOL_VERSION]
+        });
+        return;
+      }
+    } else {
+      this.sessions.setAuth(clientId, { userId: `anon:${clientId}` });
+    }
+    await this.trySend(clientId, {
+      type: "hello_ack",
+      protocolVersion: negotiated,
+      serverId: this.serverId
+    });
+  }
+  async handleAuth(clientId, message) {
+    if (!this.authCallback)
+      return;
+    try {
+      const req = new Request("https://sync/auth", {
+        headers: { authorization: `Bearer ${message.token}` }
+      });
+      const auth = await this.authCallback(req);
+      this.sessions.setAuth(clientId, auth);
+      await this.enforceConnectionCap(auth.userId, clientId);
+    } catch (err) {
+      console.error(`[reflectdb] Auth callback failed for client ${clientId} (re-auth):`, err);
+      this.emit({ type: "auth_failed", clientId, error: err });
+      await this.trySend(clientId, {
+        type: "disconnect",
+        reason: "Authentication failed"
+      });
+      await this.transport.disconnect?.(clientId);
+    }
+  }
+  async handleBootstrap(clientId, _message) {
+    const session = this.sessions.get(clientId);
+    if (!session)
+      return;
+    await this.eagerBuffer.flush();
+    for (const [queryName, sub] of session.subscriptions) {
+      const queryReg = this.queries.get(queryName);
+      if (!queryReg)
+        continue;
+      const isWindowed = sub.windowSize != null && sub.windowSize > 0;
+      let rows;
+      let totalCount;
+      try {
+        if (isWindowed) {
+          const windowed = await this.fetchWindow(queryReg, session, sub.windowLimit);
+          rows = windowed.rows;
+          totalCount = windowed.totalCount;
+          sub.loadedCount = rows.length;
+          sub.lastTotalCount = totalCount;
+        } else {
+          rows = await this.executeQuery(queryReg, session);
+        }
+      } catch (err) {
+        console.error(`[reflectdb] Query "${queryName}" failed during bootstrap for client ${clientId}:`, err);
+        rows = [];
+      }
+      const pk = queryReg.options.pk ?? "id";
+      const colClocks = {};
+      const hlcStr2 = this.clock.packed();
+      for (const row of rows) {
+        const rowId = String(row[pk] ?? "");
+        if (rowId) {
+          colClocks[rowId] = { _row: hlcStr2 };
+        }
+      }
+      const delivered = await this.trySend(clientId, {
+        type: "snapshot",
+        table: queryName,
+        rows,
+        colClocks,
+        totalCount,
+        pk
+      });
+      if (delivered) {
+        this.resultCache.set(clientId, queryName, rows, pk);
+        sub.bootstrapped = true;
+      }
+    }
+    const tableMeta = {};
+    for (const [queryName] of session.subscriptions) {
+      const queryReg = this.queries.get(queryName);
+      tableMeta[queryName] = {
+        serverSet: queryReg?.options.serverSet ? Object.keys(queryReg.options.serverSet) : [],
+        readonly: queryReg?.options.readonly ?? [],
+        broadcast: queryReg?.options.broadcast ?? "consistent",
+        pk: queryReg?.options.pk ?? "id"
+      };
+    }
+    const hlcStr = this.clock.stamp();
+    this.sessions.updateWatermark(clientId, hlcStr);
+    this.emit({ type: "bootstrap", clientId, queries: session.subscriptions.size });
+    await this.trySend(clientId, {
+      type: "bootstrap_complete",
+      serverHlc: hlcStr,
+      tableMeta
+    });
+  }
+  async executeQuery(queryReg, session, limit) {
+    let rows;
+    if (this.db) {
+      const sub = session.subscriptions.get(queryReg.name);
+      const ctx = { auth: session.auth, params: sub?.params ?? {}, limit };
+      const query = queryReg.callback(ctx, this.db);
+      const result = await query;
+      rows = Array.isArray(result) ? result : [];
+    } else {
+      rows = [];
+    }
+    if (limit != null && rows.length > limit) {
+      return rows.slice(0, limit);
+    }
+    return rows;
+  }
+  async countQuery(queryReg, session) {
+    const countFn = queryReg.options.count;
+    if (!countFn || !this.db)
+      return null;
+    const sub = session.subscriptions.get(queryReg.name);
+    const ctx = { auth: session.auth, params: sub?.params ?? {} };
+    return await countFn(ctx, this.db);
+  }
+  async fetchWindow(queryReg, session, windowSize) {
+    if (queryReg.options.count) {
+      const [rows, counted] = await Promise.all([
+        this.executeQuery(queryReg, session, windowSize),
+        this.countQuery(queryReg, session)
+      ]);
+      return { rows, totalCount: counted ?? rows.length };
+    }
+    const allRows = await this.executeQuery(queryReg, session);
+    return { rows: allRows.slice(0, windowSize), totalCount: allRows.length };
+  }
+  async handleResume(clientId, message) {
+    const session = this.sessions.get(clientId);
+    if (!session)
+      return;
+    await this.eagerBuffer.flush();
+    await this.compaction.ensureCutoffLoaded();
+    const cutoffHlc = this.compaction.getCutoff();
+    if (cutoffHlc && message.since < cutoffHlc) {
+      await this.trySend(clientId, {
+        type: "resume_rejected",
+        reason: "compacted",
+        serverHlc: this.clock.peekNext()
+      });
+      return;
+    }
+    const changedDbTables = new Set;
+    if (this.storage) {
+      const allDepTablesSet = new Set;
+      for (const [queryName] of session.subscriptions) {
+        const reg = this.queries.get(queryName);
+        if (reg) {
+          for (const dep of reg.tableDependencies) {
+            allDepTablesSet.add(dep);
+          }
+        }
+      }
+      const allDepTables = [...allDepTablesSet];
+      try {
+        if (this.storage.getChangedTablesSince) {
+          const tables = await this.storage.getChangedTablesSince(message.since, allDepTables);
+          for (const t of tables)
+            changedDbTables.add(t);
+        } else {
+          const ops = await this.storage.getOpsSince(message.since, allDepTables);
+          for (const op of ops)
+            changedDbTables.add(op.table);
+        }
+      } catch {
+        for (const t of allDepTables)
+          changedDbTables.add(t);
+      }
+    }
+    const hlcStr = this.clock.packed();
+    for (const [queryName, sub] of session.subscriptions) {
+      const queryReg = this.queries.get(queryName);
+      if (!queryReg)
+        continue;
+      const hasChanges = changedDbTables.size === 0 || [...queryReg.tableDependencies].some((t) => changedDbTables.has(t));
+      if (!hasChanges)
+        continue;
+      const isWindowed = sub.windowSize != null && sub.windowSize > 0;
+      try {
+        let rows;
+        let totalCount;
+        if (isWindowed) {
+          const windowed = await this.fetchWindow(queryReg, session, sub.windowLimit);
+          rows = windowed.rows;
+          totalCount = windowed.totalCount;
+          sub.loadedCount = rows.length;
+          sub.lastTotalCount = totalCount;
+        } else {
+          rows = await this.executeQuery(queryReg, session);
+        }
+        const pk = queryReg.options.pk ?? "id";
+        const colClocks = {};
+        for (const row of rows) {
+          const rowId = String(row[pk] ?? "");
+          if (rowId)
+            colClocks[rowId] = { _row: hlcStr };
+        }
+        const delivered = await this.trySend(clientId, {
+          type: "snapshot",
+          table: queryName,
+          rows,
+          colClocks,
+          totalCount,
+          pk
+        });
+        if (delivered) {
+          this.resultCache.set(clientId, queryName, rows, pk);
+          sub.bootstrapped = true;
+        }
+      } catch (err) {
+        console.error(`[reflectdb] Query "${queryName}" failed during resume for client ${clientId}:`, err);
+      }
+    }
+    const resumeHlc = this.clock.stamp();
+    this.sessions.updateWatermark(clientId, resumeHlc);
+    this.emit({
+      type: "resume",
+      clientId,
+      queries: session.subscriptions.size,
+      tablesChanged: changedDbTables.size
+    });
+    await this.trySend(clientId, {
+      type: "resume_complete",
+      serverHlc: resumeHlc
+    });
+  }
+  async handleOps(clientId, message) {
+    const session = this.sessions.get(clientId);
+    if (!session)
+      return;
+    if (this.authCallback) {
+      try {
+        const cached = this.authCache.get(message.token);
+        let auth;
+        const now = Date.now();
+        if (cached && cached.expiresAt > now) {
+          auth = cached.auth;
+        } else {
+          const req = new Request("https://sync/ops", {
+            headers: { authorization: `Bearer ${message.token}` }
+          });
+          auth = await this.authCallback(req);
+          this.authCache.set(message.token, {
+            auth,
+            expiresAt: now + MessageHandler.AUTH_CACHE_TTL_MS
+          });
+          if (this.authCache.size > 1000) {
+            for (const [k, v] of this.authCache) {
+              if (v.expiresAt <= now)
+                this.authCache.delete(k);
+            }
+            if (this.authCache.size > 1000) {
+              const drop = this.authCache.size - 1000;
+              const iter = this.authCache.keys();
+              for (let n = 0;n < drop; n++) {
+                const k = iter.next().value;
+                if (k === undefined)
+                  break;
+                this.authCache.delete(k);
+              }
+            }
+          }
+        }
+        this.sessions.setAuth(clientId, auth);
+      } catch (err) {
+        console.error(`[reflectdb] Auth callback failed for client ${clientId} (ops push):`, err);
+        this.emit({ type: "auth_failed", clientId, error: err });
+        await this.trySend(clientId, {
+          type: "reauth"
+        });
+        return;
+      }
+    }
+    const accepted = [];
+    const rejected = [];
+    const failedBatchIds = new Map;
+    const deferredBroadcastTables = new Set;
+    const batch = await this.ops.prefetchBatch(message.ops);
+    for (const op of message.ops) {
+      if (op.batchId && failedBatchIds.has(op.batchId)) {
+        rejected.push({
+          opId: op.id,
+          batchId: op.batchId,
+          reason: failedBatchIds.get(op.batchId)
+        });
+        continue;
+      }
+      const result = await this.ops.processClientOp(op, session, deferredBroadcastTables, batch);
+      if (result.accepted) {
+        accepted.push(op.id);
+      } else {
+        const reason = result.reason ?? "server_error";
+        rejected.push({
+          opId: op.id,
+          batchId: op.batchId,
+          reason,
+          serverRow: result.serverRow
+        });
+        if (op.batchId) {
+          failedBatchIds.set(op.batchId, reason);
+        }
+      }
+    }
+    for (const table of deferredBroadcastTables) {
+      await this.broadcastChanges(table, session.clientId);
+    }
+    this.emit({
+      type: "ops_processed",
+      clientId,
+      accepted: accepted.length,
+      rejected: rejected.length
+    });
+    if (accepted.length > 0) {
+      await this.trySend(clientId, {
+        type: "ack",
+        opIds: accepted
+      });
+    }
+    if (rejected.length > 0) {
+      await Promise.all(rejected.map((rej) => this.trySend(clientId, {
+        type: "reject",
+        opId: rej.opId,
+        batchId: rej.batchId,
+        reason: rej.reason,
+        serverRow: rej.serverRow ?? undefined
+      })));
+    }
+  }
+  async broadcastChanges(tableName, excludeClientId, overrideRoomKey) {
+    await this.broadcast.broadcastChanges(tableName, excludeClientId, overrideRoomKey);
+  }
+  async handleSyncDeclare(clientId, message) {
+    const session = this.sessions.get(clientId);
+    if (!session)
+      return;
+    const queryReg = this.queries.get(message.table);
+    if (!queryReg) {
+      await this.trySend(clientId, {
+        type: "reject",
+        opId: `sync_declare:${message.table}`,
+        reason: "unknown_query"
+      });
+      return;
+    }
+    const resolved = resolveRoomKey(this.rooms, message.params ?? {}, queryReg.options.room);
+    if (!resolved.ok) {
+      console.warn(`[reflectdb] sync_declare for "${message.table}" from ${clientId} rejected: ${resolved.reason}`);
+      await this.trySend(clientId, {
+        type: "reject",
+        opId: `sync_declare:${message.table}`,
+        reason: "outside_shape"
+      });
+      return;
+    }
+    const roomKey = resolved.roomKey;
+    if (roomKey) {
+      for (const room of this.rooms) {
+        const match = room.regex.exec(roomKey);
+        if (match) {
+          const params = {};
+          for (let i = 0;i < room.paramNames.length; i++) {
+            params[room.paramNames[i]] = match[i + 1];
+          }
+          const cbResult = await room.callback({ params, auth: session.auth });
+          if (cbResult && !cbResult.ok) {
+            await this.trySend(clientId, {
+              type: "disconnect",
+              reason: cbResult.reason ?? "Room access denied"
+            });
+            await this.transport.disconnect?.(clientId);
+            return;
+          }
+          break;
+        }
+      }
+    }
+    if (queryReg.options.authorize) {
+      const ctx = {
+        auth: session.auth,
+        params: message.params ?? {}
+      };
+      try {
+        await queryReg.options.authorize({ type: "read", table: message.table, params: message.params ?? {} }, ctx, this.db);
+      } catch (err) {
+        const reason = reasonFromError(err);
+        await this.trySend(clientId, {
+          type: "reject",
+          opId: `sync_declare:${message.table}`,
+          reason
+        });
+        return;
+      }
+    }
+    this.sessions.subscribe(clientId, message.table, message.params ?? {}, queryReg.options, roomKey, message.window ?? null);
+  }
+  async handleLoadMore(clientId, message) {
+    const session = this.sessions.get(clientId);
+    if (!session)
+      return;
+    const sub = session.subscriptions.get(message.table);
+    if (!sub || sub.windowSize == null)
+      return;
+    const queryReg = this.queries.get(message.table);
+    if (!queryReg)
+      return;
+    const prevLoaded = sub.loadedCount;
+    const newLimit = sub.windowLimit + message.count;
+    let totalCount = 0;
+    let rows;
+    try {
+      if (queryReg.options.countHints && !queryReg.options.count) {
+        const allRows = await this.executeQuery(queryReg, session);
+        rows = allRows.slice(0, newLimit);
+        totalCount = allRows.length;
+      } else {
+        rows = await this.executeQuery(queryReg, session, newLimit);
+        if (queryReg.options.countHints) {
+          totalCount = await this.countQuery(queryReg, session) ?? rows.length;
+        }
+      }
+    } catch (err) {
+      console.error(`[reflectdb] Query "${message.table}" failed during loadMore for client ${clientId}:`, err);
+      return;
+    }
+    const newRows = rows.slice(prevLoaded);
+    const pk = queryReg.options.pk ?? "id";
+    let delivered = true;
+    if (newRows.length > 0) {
+      const colClocks = {};
+      const hlcStr = this.clock.packed();
+      for (const row of newRows) {
+        const rowId = String(row[pk] ?? "");
+        if (rowId) {
+          colClocks[rowId] = { _row: hlcStr };
+        }
+      }
+      delivered = await this.trySend(clientId, {
+        type: "snapshot",
+        table: message.table,
+        rows: newRows,
+        colClocks,
+        append: true,
+        pk
+      });
+    }
+    if (delivered) {
+      this.resultCache.set(clientId, message.table, rows, pk);
+      sub.loadedCount = rows.length;
+      sub.windowLimit = newLimit;
+    }
+    if (queryReg.options.countHints) {
+      if (totalCount !== sub.lastTotalCount) {
+        const countDelivered = await this.trySend(clientId, {
+          type: "count_changed",
+          table: message.table,
+          totalCount
+        });
+        if (countDelivered)
+          sub.lastTotalCount = totalCount;
+      }
+    }
+  }
+  async handleUnsync(clientId, message) {
+    this.sessions.unsubscribe(clientId, message.table);
+    this.resultCache.clear(clientId, message.table);
+  }
+  allowEphemeral(clientId) {
+    if (this.ephemeralPerSecond <= 0)
+      return true;
+    const now = Date.now();
+    const bucket = this.ephemeralBuckets.get(clientId);
+    if (!bucket || now >= bucket.resetAt) {
+      this.ephemeralBuckets.set(clientId, { count: 1, resetAt: now + 1000 });
+      return true;
+    }
+    if (bucket.count >= this.ephemeralPerSecond)
+      return false;
+    bucket.count++;
+    return true;
+  }
+  async handleEphemeral(clientId, message) {
+    const session = this.sessions.get(clientId);
+    if (!session)
+      return;
+    if (!this.allowEphemeral(clientId)) {
+      this.emit({ type: "ephemeral_rate_limited", clientId });
+      return;
+    }
+    const { key, data } = message;
+    const ttlMs = typeof message.ttlMs === "number" && message.ttlMs > 0 ? Math.min(message.ttlMs, MessageHandler.MAX_EPHEMERAL_TTL_MS) : undefined;
+    const userId = session.auth.userId;
+    const roomKeys = new Set;
+    const queryNames = new Set;
+    for (const [queryName, sub] of session.subscriptions) {
+      queryNames.add(queryName);
+      if (sub.roomKey) {
+        roomKeys.add(sub.roomKey);
+      }
+    }
+    const event = {
+      type: "ephemeral",
+      key,
+      clientId,
+      userId,
+      data,
+      ttlMs
+    };
+    const sent = new Set;
+    const recipients = [];
+    for (const roomKey of roomKeys) {
+      const accepted = this.ephemeralManager.set(roomKey, key, clientId, userId, data, ttlMs);
+      if (!accepted) {
+        this.emit({ type: "ephemeral_full", currentSize: this.ephemeralManager.size });
+        return;
+      }
+    }
+    for (const queryName of queryNames) {
+      const senderSub = session.subscriptions.get(queryName);
+      const senderRoomKey = senderSub?.roomKey ?? null;
+      const subscribers = this.sessions.getSubscribersForQuery(queryName, senderRoomKey);
+      for (const sub of subscribers) {
+        if (sub.clientId !== clientId && !sent.has(sub.clientId)) {
+          sent.add(sub.clientId);
+          recipients.push(sub.clientId);
+        }
+      }
+    }
+    await Promise.all(recipients.map((recipient) => this.trySend(recipient, event)));
+  }
+  async reserveOpId(opId) {
+    return this.replay.reserve(opId);
+  }
+  async runCompaction(minOpAge) {
+    return this.compaction.runCompaction(minOpAge);
+  }
+  getEagerBuffer() {
+    return this.eagerBuffer;
+  }
+  getTrackedTables() {
+    return [...this.tableDependencyIndex.keys()];
+  }
+  async pollRemoteChanges() {
+    await this.clock.refresh();
+    const tables = this.getTrackedTables();
+    if (tables.length === 0)
+      return;
+    const storage = this.storage;
+    if (!storage?.getOplogHead || !storage.getChangedTablesSince) {
+      await this.notifyAll(tables);
+      return;
+    }
+    const head = await storage.getOplogHead(tables);
+    if (this.pollWatermark === null) {
+      this.pollWatermark = head ?? "";
+      return;
+    }
+    if (head === null || head <= this.pollWatermark)
+      return;
+    const changed = await storage.getChangedTablesSince(this.pollWatermark, tables);
+    this.pollWatermark = head;
+    await this.notifyAll(changed);
+  }
+  async notifyAll(tables) {
+    const results = await Promise.allSettled(tables.map((table) => this.notifyChange(table)));
+    for (let i = 0;i < results.length; i++) {
+      const r = results[i];
+      if (r.status === "rejected") {
+        console.error(`[reflectdb] poll notifyChange for "${tables[i]}" failed:`, r.reason);
+      }
+    }
+  }
+  async notifyChange(tableName, roomKey) {
+    await this.clock.ensureLoaded();
+    await this.broadcastChanges(tableName, "", roomKey);
+  }
+  async applyServerOp(op, execute, options) {
+    await this.clock.ensureLoaded();
+    let hlcStr = this.clock.stamp();
+    let resolvedRow;
+    const colClocks = {};
+    let existingRow = null;
+    let existingColClocks = {};
+    if (this.storage) {
+      const existing = await this.storage.getRow(op.table, op.rowId);
+      existingRow = existing.row;
+      existingColClocks = existing.colClocks;
+      if (existing.rowHlc && hlcStr <= existing.rowHlc) {
+        try {
+          this.clock.receive(existing.rowHlc);
+          hlcStr = this.clock.packed();
+        } catch {}
+      }
+    }
+    if (op.type === "delete" || op.payload === null) {
+      resolvedRow = null;
+      for (const key of Object.keys(existingColClocks)) {
+        colClocks[key] = hlcStr;
+      }
+    } else if (op.type === "insert") {
+      resolvedRow = { ...op.payload };
+      for (const key of Object.keys(op.payload)) {
+        colClocks[key] = hlcStr;
+      }
+    } else {
+      const base = existingRow ?? {};
+      resolvedRow = { ...base, ...op.payload };
+      for (const [k, v] of Object.entries(existingColClocks)) {
+        if (k !== "_row")
+          colClocks[k] = v;
+      }
+      for (const key of Object.keys(op.payload)) {
+        colClocks[key] = hlcStr;
+      }
+    }
+    colClocks._row = hlcStr;
+    if (execute) {
+      await execute({ ...op, hlc: hlcStr });
+    }
+    if (this.storage) {
+      await this.storage.applyOp(op.table, op.rowId, resolvedRow, colClocks, hlcStr, op.type, op.payload);
+    }
+    await this.broadcastChanges(op.table, "", options?.roomKey);
+    return { hlc: hlcStr, resolvedRow };
+  }
+  async close() {
+    if (this.ephemeralCleanupTimer) {
+      clearInterval(this.ephemeralCleanupTimer);
+    }
+    await this.clock.close();
+    const inflight = [...this.messageQueues.values()];
+    if (inflight.length > 0) {
+      await Promise.allSettled(inflight);
+    }
+    this.messageQueues.clear();
+    this.messageQueueDepths.clear();
+    this.ephemeralManager.destroy();
+    await this.eagerBuffer.close();
+  }
+}
+
+// src/server/server.ts
+var drizzleHelpersPromise;
+function loadDrizzleHelpers() {
+  if (drizzleHelpersPromise)
+    return drizzleHelpersPromise;
+  drizzleHelpersPromise = (async () => {
+    try {
+      const mod = await import("drizzle-orm");
+      return {
+        getTableName: mod.getTableName,
+        sql: mod.sql
+      };
+    } catch {
+      return null;
+    }
+  })();
+  return drizzleHelpersPromise;
+}
+function makeDrizzleFallbackAtomic(helpers) {
+  return {
+    async begin(db) {
+      const handle = db;
+      if (typeof handle?.run !== "function") {
+        throw new Error("server.tx({ atomic: true }) requires either a drizzle db with run() or a `txAtomic` adapter on server config");
+      }
+      await Promise.resolve(handle.run(helpers.sql`BEGIN`));
+    },
+    async commit(db) {
+      const handle = db;
+      await Promise.resolve(handle.run(helpers.sql`COMMIT`));
+    },
+    async rollback(db) {
+      const handle = db;
+      await Promise.resolve(handle.run(helpers.sql`ROLLBACK`));
+    }
+  };
+}
+function buildRoomRegex(pattern) {
+  const paramNames = [];
+  let regexStr = "";
+  let lastIndex = 0;
+  const paramPattern = /:(\w+)/g;
+  let match = paramPattern.exec(pattern);
+  while (match !== null) {
+    regexStr += escapeRegex(pattern.slice(lastIndex, match.index));
+    paramNames.push(match[1]);
+    regexStr += "([^/]+)";
+    lastIndex = match.index + match[0].length;
+    match = paramPattern.exec(pattern);
+  }
+  regexStr += escapeRegex(pattern.slice(lastIndex));
+  return { regex: new RegExp(`^${regexStr}$`), paramNames };
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createServer(config) {
+  const handler = new MessageHandler({
+    transport: config.transport,
+    serverId: config.serverId ?? crypto.randomUUID(),
+    db: config.db,
+    onEvent: config.onEvent,
+    maxConnectionsPerUser: config.maxConnectionsPerUser,
+    allowAnonymous: config.allowAnonymous,
+    queryTimeoutMs: config.queryTimeoutMs,
+    maxBroadcastConcurrency: config.maxBroadcastConcurrency
+  });
+  if (config.storage) {
+    handler.setStorage(config.storage);
+  }
+  let compactionConfig = null;
+  let pollTimer = null;
+  const lockChains = new Map;
+  const activeTimers = new Set;
+  if (config.poll && config.poll > 0) {
+    let polling = false;
+    pollTimer = setInterval(() => {
+      if (polling)
+        return;
+      polling = true;
+      (async () => {
+        try {
+          await handler.pollRemoteChanges();
+        } catch (err) {
+          console.error("[reflectdb] poll failed:", err);
+        } finally {
+          polling = false;
+        }
+      })();
+    }, config.poll);
+  }
+  const server = {
+    auth(callback) {
+      handler.setAuth(callback);
+    },
+    query(name, callback, options) {
+      const tableDependencies = new Set(options.tables);
+      if (options?.broadcast === "eager" || options?.broadcast === "eager-durable") {
+        if (options.conflict) {
+          console.warn(`[reflectdb] Query "${name}" has broadcast: "${options.broadcast}" — conflict: "${typeof options.conflict === "string" ? options.conflict : "custom"}" will be ignored (conflict resolution is skipped for eager queries; writes apply last-writer-wins)`);
+        }
+      }
+      handler.setQuery(name, {
+        name,
+        callback,
+        tableDependencies,
+        options
+      });
+    },
+    room(pattern, callback) {
+      const { regex, paramNames } = buildRoomRegex(pattern);
+      handler.setRoom({
+        pattern,
+        regex,
+        paramNames,
+        callback
+      });
+    },
+    rateLimit(cfg) {
+      handler.setRateLimiter(createRateLimiter(cfg));
+      if (cfg.ephemeralPerSecond !== undefined) {
+        handler.setEphemeralRateLimit(cfg.ephemeralPerSecond);
+      }
+    },
+    compaction(cfg) {
+      compactionConfig = cfg;
+    },
+    minSchemaVersion(version) {
+      handler.setMinSchemaVersion(version);
+    },
+    async runCompaction() {
+      if (!compactionConfig)
+        return;
+      const minOpAge = parseDuration(compactionConfig.minOpAge);
+      await handler.runCompaction(minOpAge);
+    },
+    async notifyChange(tableName, roomKey) {
+      await handler.notifyChange(tableName, roomKey);
+    },
+    async reserveOpId(opId) {
+      return handler.reserveOpId(opId);
+    },
+    async applyServerOp(op, execute, options) {
+      return handler.applyServerOp(op, execute, options);
+    },
+    async emit(table, payload, options) {
+      const type = options?.type ?? "insert";
+      const rowId = options?.rowId ?? (payload.id ?? crypto.randomUUID());
+      const result = await handler.applyServerOp({ type, table, rowId, payload }, undefined, options?.roomKey !== undefined ? { roomKey: options.roomKey } : undefined);
+      return { hlc: result.hlc, rowId };
+    },
+    tx(arg1, arg2) {
+      const rawOpts = typeof arg1 === "function" ? {} : arg1;
+      const opts = { atomic: true, ...rawOpts };
+      const fn = typeof arg1 === "function" ? arg1 : arg2;
+      if (config.db == null) {
+        return Promise.reject(new Error("server.tx requires a db on the server config"));
+      }
+      const touched = new Set;
+      const wrap = (target, getTableNameFn) => new Proxy(target, {
+        get(t, prop, receiver) {
+          if (prop === "touch") {
+            return (name) => {
+              touched.add(name);
+            };
+          }
+          const value = Reflect.get(t, prop, receiver);
+          if ((prop === "insert" || prop === "update" || prop === "delete") && typeof value === "function") {
+            return (table, ...rest) => {
+              if (getTableNameFn) {
+                try {
+                  touched.add(getTableNameFn(table));
+                } catch {}
+              }
+              return value.call(t, table, ...rest);
+            };
+          }
+          return typeof value === "function" ? value.bind(t) : value;
+        }
+      });
+      const run = async () => {
+        const drizzleHelpers = await loadDrizzleHelpers();
+        const getTableNameFn = drizzleHelpers?.getTableName;
+        let atomicAdapter;
+        if (opts.atomic && typeof opts.atomic === "object") {
+          atomicAdapter = opts.atomic;
+        } else if (opts.atomic === true) {
+          if (config.txAtomic) {
+            atomicAdapter = config.txAtomic;
+          } else if (drizzleHelpers) {
+            atomicAdapter = makeDrizzleFallbackAtomic(drizzleHelpers);
+          } else {
+            throw new Error("server.tx({ atomic: true }) requires either a drizzle db (install `drizzle-orm`) or a `txAtomic` adapter on server config");
+          }
+        }
+        let result;
+        if (atomicAdapter) {
+          await atomicAdapter.begin(config.db);
+          try {
+            result = await fn(wrap(config.db, getTableNameFn));
+            await atomicAdapter.commit(config.db);
+          } catch (err) {
+            await atomicAdapter.rollback(config.db);
+            throw err;
+          }
+        } else {
+          result = await fn(wrap(config.db, getTableNameFn));
+        }
+        for (const t of touched) {
+          await server.notifyChange(t);
+        }
+        return result;
+      };
+      return run();
+    },
+    lock(key, fn) {
+      const prev = lockChains.get(key) ?? Promise.resolve();
+      const next = prev.then(() => fn(), () => fn());
+      const stored = next.then(() => {
+        if (lockChains.get(key) === stored)
+          lockChains.delete(key);
+      }, () => {
+        if (lockChains.get(key) === stored)
+          lockChains.delete(key);
+      });
+      lockChains.set(key, stored);
+      return next;
+    },
+    tryLock(key, fn) {
+      if (lockChains.has(key)) {
+        return Promise.resolve(null);
+      }
+      return server.lock(key, fn);
+    },
+    interval(ms, fn) {
+      const handle = setInterval(() => {
+        try {
+          const result = fn();
+          if (result && typeof result.then === "function") {
+            result.catch((err) => {
+              console.error("[reflectdb] interval error:", err);
+            });
+          }
+        } catch (err) {
+          console.error("[reflectdb] interval error:", err);
+        }
+      }, ms);
+      activeTimers.add(handle);
+      const ctrl = {
+        clear() {
+          clearInterval(handle);
+          activeTimers.delete(handle);
+        }
+      };
+      registerHotDispose(() => ctrl.clear());
+      return ctrl;
+    },
+    timeout(ms, fn) {
+      let done = false;
+      const handle = setTimeout(() => {
+        done = true;
+        activeTimers.delete(handle);
+        try {
+          const result = fn();
+          if (result && typeof result.then === "function") {
+            result.catch((err) => {
+              console.error("[reflectdb] timeout error:", err);
+            });
+          }
+        } catch (err) {
+          console.error("[reflectdb] timeout error:", err);
+        }
+      }, ms);
+      activeTimers.add(handle);
+      const ctrl = {
+        clear() {
+          if (done)
+            return;
+          clearTimeout(handle);
+          activeTimers.delete(handle);
+        }
+      };
+      registerHotDispose(() => ctrl.clear());
+      return ctrl;
+    },
+    async close() {
+      if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+      }
+      for (const t of activeTimers) {
+        clearTimeout(t);
+        clearInterval(t);
+      }
+      activeTimers.clear();
+      await handler.close();
+      await config.transport.close();
+    }
+  };
+  return server;
+}
+function registerHotDispose(fn) {
+  if (true) {
+    const hot = {}.hot;
+    if (hot && typeof hot.dispose === "function") {
+      hot.dispose(fn);
+    }
+  }
+}
+function parseDuration(str) {
+  const match = str.match(/^(\d+)(ms|s|m|h|d)$/);
+  if (!match)
+    throw new Error(`Invalid duration: "${str}". Expected format: <number><unit> (e.g., "1h", "30m", "500ms")`);
+  const value = Number(match[1]);
+  switch (match[2]) {
+    case "ms":
+      return value;
+    case "s":
+      return value * 1000;
+    case "m":
+      return value * 60 * 1000;
+    case "h":
+      return value * 60 * 60 * 1000;
+    case "d":
+      return value * 24 * 60 * 60 * 1000;
+    default:
+      return 0;
+  }
+}
+
+// src/server/index.ts
+init_types();
+
+// src/server/storage/sqlite.ts
+var import_node_module3 = require("node:module");
+var requireFn2 = import_node_module3.createRequire(module.filename);
+function loadDatabase() {
+  try {
+    return requireFn2("bun:sqlite").Database;
+  } catch {
+    throw new Error("createSqliteStorage requires the Bun runtime (bun:sqlite is unavailable). Use createPostgresStorage on Node.");
+  }
+}
+var OP_ID_RETENTION_MS = 24 * 60 * 60 * 1000;
+function createSqliteStorage(config = {}) {
+  const db = config.db ?? new (loadDatabase())(config.path ?? ":memory:");
+  db.run("PRAGMA journal_mode = WAL");
+  db.run("PRAGMA synchronous = NORMAL");
+  db.run(`
+		CREATE TABLE IF NOT EXISTS _reflectdb_rows (
+			tbl TEXT NOT NULL,
+			row_id TEXT NOT NULL,
+			data TEXT NOT NULL,
+			col_clocks TEXT NOT NULL,
+			hlc TEXT NOT NULL,
+			PRIMARY KEY (tbl, row_id)
+		)
+	`);
+  db.run(`
+		CREATE TABLE IF NOT EXISTS _reflectdb_oplog (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			tbl TEXT NOT NULL,
+			op TEXT NOT NULL,
+			row_id TEXT NOT NULL,
+			payload TEXT,
+			hlc TEXT NOT NULL,
+			col_clocks TEXT NOT NULL
+		)
+	`);
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_oplog_hlc ON _reflectdb_oplog (hlc)
+	`);
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_oplog_tbl_hlc ON _reflectdb_oplog (tbl, hlc)
+	`);
+  db.run(`
+		CREATE TABLE IF NOT EXISTS _reflectdb_processed_ops (
+			op_id TEXT PRIMARY KEY,
+			created_at INTEGER NOT NULL
+		)
+	`);
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_processed_ops_created_at ON _reflectdb_processed_ops (created_at)
+	`);
+  db.run(`
+		CREATE TABLE IF NOT EXISTS _reflectdb_meta (
+			key TEXT PRIMARY KEY,
+			value TEXT NOT NULL
+		)
+	`);
+  const getRowStmt = db.prepare("SELECT data, col_clocks, hlc FROM _reflectdb_rows WHERE tbl = ? AND row_id = ?");
+  const putRowStmt = db.prepare("INSERT OR REPLACE INTO _reflectdb_rows (tbl, row_id, data, col_clocks, hlc) VALUES (?, ?, ?, ?, ?)");
+  const deleteRowStmt = db.prepare("DELETE FROM _reflectdb_rows WHERE tbl = ? AND row_id = ?");
+  const getRowsStmt = db.prepare("SELECT row_id, data, col_clocks FROM _reflectdb_rows WHERE tbl = ?");
+  const appendOpStmt = db.prepare("INSERT INTO _reflectdb_oplog (tbl, op, row_id, payload, hlc, col_clocks) VALUES (?, ?, ?, ?, ?, ?)");
+  const deleteOpsStmt = db.prepare("DELETE FROM _reflectdb_oplog WHERE hlc < ?");
+  const reserveOpStmt = db.prepare("INSERT OR IGNORE INTO _reflectdb_processed_ops (op_id, created_at) VALUES (?, ?)");
+  const cleanupOpsStmt = db.prepare("DELETE FROM _reflectdb_processed_ops WHERE created_at < ?");
+  const getMetaStmt = db.prepare("SELECT value FROM _reflectdb_meta WHERE key = ?");
+  const setMetaStmt = db.prepare("INSERT OR REPLACE INTO _reflectdb_meta (key, value) VALUES (?, ?)");
+  return {
+    async getRow(table, rowId) {
+      const result = getRowStmt.get(table, rowId);
+      if (!result) {
+        return { row: null, rowHlc: null, colClocks: {} };
+      }
+      return {
+        row: JSON.parse(result.data),
+        rowHlc: result.hlc,
+        colClocks: JSON.parse(result.col_clocks)
+      };
+    },
+    async getRowsByIds(table, rowIds) {
+      if (rowIds.length === 0)
+        return {};
+      const placeholders = rowIds.map(() => "?").join(", ");
+      const stmt = db.prepare(`SELECT row_id, data, col_clocks, hlc FROM _reflectdb_rows WHERE tbl = ? AND row_id IN (${placeholders})`);
+      const out = {};
+      for (const r of stmt.all(table, ...rowIds)) {
+        out[r.row_id] = {
+          row: JSON.parse(r.data),
+          rowHlc: r.hlc,
+          colClocks: JSON.parse(r.col_clocks)
+        };
+      }
+      return out;
+    },
+    async putRow(table, rowId, row, colClocks, hlc) {
+      if (row === null) {
+        deleteRowStmt.run(table, rowId);
+      } else {
+        putRowStmt.run(table, rowId, JSON.stringify(row), JSON.stringify(colClocks), hlc);
+      }
+    },
+    async getRows(table) {
+      const results = getRowsStmt.all(table);
+      const rows = [];
+      const colClocks = {};
+      for (const result of results) {
+        const data = JSON.parse(result.data);
+        rows.push(data);
+        colClocks[result.row_id] = JSON.parse(result.col_clocks);
+      }
+      return { rows, colClocks };
+    },
+    async appendOp(entry) {
+      appendOpStmt.run(entry.table, entry.op, entry.rowId, entry.payload ? JSON.stringify(entry.payload) : null, entry.hlc, JSON.stringify(entry.colClocks));
+    },
+    async applyOp(table, rowId, row, colClocks, hlc, opType, payload) {
+      const tx = db.transaction(() => {
+        if (row === null) {
+          deleteRowStmt.run(table, rowId);
+        } else {
+          putRowStmt.run(table, rowId, JSON.stringify(row), JSON.stringify(colClocks), hlc);
+        }
+        appendOpStmt.run(table, opType, rowId, payload ? JSON.stringify(payload) : null, hlc, JSON.stringify(colClocks));
+      });
+      tx();
+    },
+    async getOpsSince(since, tables) {
+      if (tables.length === 0)
+        return [];
+      const placeholders = tables.map(() => "?").join(", ");
+      const stmt = db.prepare(`SELECT tbl, op, row_id, payload, hlc, col_clocks FROM _reflectdb_oplog WHERE hlc > ? AND tbl IN (${placeholders}) ORDER BY hlc ASC`);
+      const results = stmt.all(since, ...tables);
+      return results.map((r) => ({
+        table: r.tbl,
+        op: r.op,
+        rowId: r.row_id,
+        payload: r.payload ? JSON.parse(r.payload) : null,
+        hlc: r.hlc,
+        colClocks: JSON.parse(r.col_clocks)
+      }));
+    },
+    async getChangedTablesSince(since, tables) {
+      if (tables.length === 0)
+        return [];
+      const placeholders = tables.map(() => "?").join(", ");
+      const stmt = db.prepare(`SELECT DISTINCT tbl FROM _reflectdb_oplog WHERE hlc > ? AND tbl IN (${placeholders})`);
+      return stmt.all(since, ...tables).map((r) => r.tbl);
+    },
+    async getOplogHead(tables) {
+      if (tables.length === 0)
+        return null;
+      const placeholders = tables.map(() => "?").join(", ");
+      const stmt = db.prepare(`SELECT MAX(hlc) AS head FROM _reflectdb_oplog WHERE tbl IN (${placeholders})`);
+      return stmt.get(...tables)?.head ?? null;
+    },
+    async deleteOpsBefore(hlc) {
+      const result = deleteOpsStmt.run(hlc);
+      return result.changes;
+    },
+    async reserveOp(opId) {
+      const now = Date.now();
+      const result = reserveOpStmt.run(opId, now);
+      if (Math.random() < 0.01) {
+        cleanupOpsStmt.run(now - OP_ID_RETENTION_MS);
+      }
+      return result.changes > 0;
+    },
+    async reserveOps(opIds) {
+      if (opIds.length === 0)
+        return [];
+      const now = Date.now();
+      const fresh = [];
+      const tx = db.transaction(() => {
+        for (const opId of opIds) {
+          if (reserveOpStmt.run(opId, now).changes > 0)
+            fresh.push(opId);
+        }
+      });
+      tx();
+      if (Math.random() < 0.01) {
+        cleanupOpsStmt.run(now - OP_ID_RETENTION_MS);
+      }
+      return fresh;
+    },
+    async getMeta(key) {
+      const result = getMetaStmt.get(key);
+      return result?.value ?? null;
+    },
+    async setMeta(key, value) {
+      setMetaStmt.run(key, value);
+    },
+    async tryLock(key) {
+      const lockKey = `lock:${key}`;
+      const now = Date.now();
+      const ttlMs = 60000;
+      const expiry = now - ttlMs;
+      const result = db.run(`INSERT INTO _reflectdb_meta (key, value) VALUES (?, ?)
+				 ON CONFLICT(key) DO UPDATE SET value = excluded.value
+				 WHERE CAST(_reflectdb_meta.value AS INTEGER) < ?`, [lockKey, String(now), String(expiry)]);
+      return result.changes > 0;
+    },
+    async unlock(key) {
+      db.run("DELETE FROM _reflectdb_meta WHERE key = ?", [`lock:${key}`]);
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+// src/server/storage/postgres.ts
+var OP_ID_RETENTION_MS2 = 24 * 60 * 60 * 1000;
+var OP_ID_GC_BATCH = 1e4;
+function hashKey(key) {
+  let hash = 0xcbf29ce484222325n;
+  for (let i = 0;i < key.length; i++) {
+    hash ^= BigInt(key.charCodeAt(i));
+    hash = hash * 0x100000001b3n & 0xffffffffffffffffn;
+  }
+  return (hash & 0x7fffffffffffffffn).toString();
+}
+function createPostgresStorage(clientOrConfig) {
+  const config = "query" in clientOrConfig ? { client: clientOrConfig } : clientOrConfig;
+  const client = config.client;
+  const p = config.tablePrefix ?? "_reflectdb";
+  let schemaReady = false;
+  let schemaPromise = null;
+  async function ensureSchema() {
+    if (schemaReady)
+      return;
+    if (schemaPromise)
+      return schemaPromise;
+    schemaPromise = initSchema();
+    await schemaPromise;
+    schemaReady = true;
+  }
+  async function initSchema() {
+    await client.query(`
+			CREATE TABLE IF NOT EXISTS ${p}_rows (
+				tbl TEXT NOT NULL,
+				row_id TEXT NOT NULL,
+				data JSONB NOT NULL,
+				col_clocks JSONB NOT NULL,
+				hlc TEXT NOT NULL,
+				PRIMARY KEY (tbl, row_id)
+			)
+		`);
+    await client.query(`
+			CREATE TABLE IF NOT EXISTS ${p}_oplog (
+				id BIGSERIAL PRIMARY KEY,
+				tbl TEXT NOT NULL,
+				op TEXT NOT NULL,
+				row_id TEXT NOT NULL,
+				payload JSONB,
+				hlc TEXT NOT NULL,
+				col_clocks JSONB NOT NULL
+			)
+		`);
+    await client.query(`CREATE INDEX IF NOT EXISTS idx_${p}_oplog_hlc ON ${p}_oplog (hlc)`);
+    await client.query(`CREATE INDEX IF NOT EXISTS idx_${p}_oplog_tbl_hlc ON ${p}_oplog (tbl, hlc)`);
+    await client.query(`
+			CREATE TABLE IF NOT EXISTS ${p}_processed_ops (
+				op_id TEXT PRIMARY KEY,
+				created_at BIGINT NOT NULL
+			)
+		`);
+    await client.query(`CREATE INDEX IF NOT EXISTS idx_${p}_processed_ops_created_at ON ${p}_processed_ops (created_at)`);
+    await client.query(`
+			CREATE TABLE IF NOT EXISTS ${p}_meta (
+				key TEXT PRIMARY KEY,
+				value TEXT NOT NULL
+			)
+		`);
+  }
+  async function maybeGcProcessedOps(now) {
+    if (Math.random() >= 0.01)
+      return;
+    try {
+      await client.query(`DELETE FROM ${p}_processed_ops
+				 WHERE ctid IN (
+					SELECT ctid FROM ${p}_processed_ops WHERE created_at < $1 LIMIT ${OP_ID_GC_BATCH}
+				 )`, [now - OP_ID_RETENTION_MS2]);
+    } catch (err) {
+      console.warn("[reflectdb] processed_ops retention sweep failed:", err);
+    }
+  }
+  return {
+    async ensureSchema() {
+      await ensureSchema();
+    },
+    async getRow(table, rowId) {
+      await ensureSchema();
+      const { rows } = await client.query(`SELECT data, col_clocks, hlc FROM ${p}_rows WHERE tbl = $1 AND row_id = $2`, [table, rowId]);
+      if (rows.length === 0) {
+        return { row: null, rowHlc: null, colClocks: {} };
+      }
+      const r = rows[0];
+      return {
+        row: typeof r.data === "string" ? JSON.parse(r.data) : r.data,
+        rowHlc: r.hlc,
+        colClocks: typeof r.col_clocks === "string" ? JSON.parse(r.col_clocks) : r.col_clocks
+      };
+    },
+    async getRowsByIds(table, rowIds) {
+      await ensureSchema();
+      if (rowIds.length === 0)
+        return {};
+      const placeholders = rowIds.map((_, i) => `$${i + 2}`).join(", ");
+      const { rows } = await client.query(`SELECT row_id, data, col_clocks, hlc FROM ${p}_rows WHERE tbl = $1 AND row_id IN (${placeholders})`, [table, ...rowIds]);
+      const out = {};
+      for (const r of rows) {
+        out[r.row_id] = {
+          row: typeof r.data === "string" ? JSON.parse(r.data) : r.data,
+          rowHlc: r.hlc,
+          colClocks: typeof r.col_clocks === "string" ? JSON.parse(r.col_clocks) : r.col_clocks
+        };
+      }
+      return out;
+    },
+    async putRow(table, rowId, row, colClocks, hlc) {
+      await ensureSchema();
+      if (row === null) {
+        await client.query(`DELETE FROM ${p}_rows WHERE tbl = $1 AND row_id = $2`, [table, rowId]);
+      } else {
+        await client.query(`INSERT INTO ${p}_rows (tbl, row_id, data, col_clocks, hlc)
+					 VALUES ($1, $2, $3, $4, $5)
+					 ON CONFLICT (tbl, row_id)
+					 DO UPDATE SET data = $3, col_clocks = $4, hlc = $5`, [table, rowId, JSON.stringify(row), JSON.stringify(colClocks), hlc]);
+      }
+    },
+    async getRows(table) {
+      await ensureSchema();
+      const { rows: results } = await client.query(`SELECT row_id, data, col_clocks FROM ${p}_rows WHERE tbl = $1`, [table]);
+      const rows = [];
+      const colClocks = {};
+      for (const r of results) {
+        rows.push(typeof r.data === "string" ? JSON.parse(r.data) : r.data);
+        colClocks[r.row_id] = typeof r.col_clocks === "string" ? JSON.parse(r.col_clocks) : r.col_clocks;
+      }
+      return { rows, colClocks };
+    },
+    async appendOp(entry) {
+      await ensureSchema();
+      await client.query(`INSERT INTO ${p}_oplog (tbl, op, row_id, payload, hlc, col_clocks)
+				 VALUES ($1, $2, $3, $4, $5, $6)`, [
+        entry.table,
+        entry.op,
+        entry.rowId,
+        entry.payload ? JSON.stringify(entry.payload) : null,
+        entry.hlc,
+        JSON.stringify(entry.colClocks)
+      ]);
+    },
+    async applyOp(table, rowId, row, colClocks, hlc, opType, payload) {
+      await ensureSchema();
+      const colClocksJson = JSON.stringify(colClocks);
+      const payloadJson = payload ? JSON.stringify(payload) : null;
+      if (row === null) {
+        await client.query(`WITH row_delete AS (
+						DELETE FROM ${p}_rows WHERE tbl = $1 AND row_id = $2
+					)
+					INSERT INTO ${p}_oplog (tbl, op, row_id, payload, hlc, col_clocks)
+					VALUES ($1, $6, $2, $7, $5, $4)`, [table, rowId, null, colClocksJson, hlc, opType, payloadJson]);
+      } else {
+        await client.query(`WITH row_upsert AS (
+						INSERT INTO ${p}_rows (tbl, row_id, data, col_clocks, hlc)
+						VALUES ($1, $2, $3, $4, $5)
+						ON CONFLICT (tbl, row_id)
+						DO UPDATE SET data = $3, col_clocks = $4, hlc = $5
+					)
+					INSERT INTO ${p}_oplog (tbl, op, row_id, payload, hlc, col_clocks)
+					VALUES ($1, $6, $2, $7, $5, $4)`, [table, rowId, JSON.stringify(row), colClocksJson, hlc, opType, payloadJson]);
+      }
+    },
+    async tryLock(key) {
+      await ensureSchema();
+      const keyHash = hashKey(key);
+      const { rows } = await client.query(`SELECT pg_try_advisory_lock($1) AS locked`, [keyHash]);
+      return rows[0]?.locked === true;
+    },
+    async unlock(key) {
+      const keyHash = hashKey(key);
+      await client.query(`SELECT pg_advisory_unlock($1)`, [keyHash]);
+    },
+    async getOpsSince(since, tables) {
+      await ensureSchema();
+      if (tables.length === 0)
+        return [];
+      const placeholders = tables.map((_, i) => `$${i + 2}`).join(", ");
+      const { rows } = await client.query(`SELECT tbl, op, row_id, payload, hlc, col_clocks
+				 FROM ${p}_oplog
+				 WHERE hlc > $1 AND tbl IN (${placeholders})
+				 ORDER BY hlc ASC`, [since, ...tables]);
+      return rows.map((r) => ({
+        table: r.tbl,
+        op: r.op,
+        rowId: r.row_id,
+        payload: typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload,
+        hlc: r.hlc,
+        colClocks: typeof r.col_clocks === "string" ? JSON.parse(r.col_clocks) : r.col_clocks
+      }));
+    },
+    async getChangedTablesSince(since, tables) {
+      await ensureSchema();
+      if (tables.length === 0)
+        return [];
+      const placeholders = tables.map((_, i) => `$${i + 2}`).join(", ");
+      const { rows } = await client.query(`SELECT DISTINCT tbl FROM ${p}_oplog WHERE hlc > $1 AND tbl IN (${placeholders})`, [since, ...tables]);
+      return rows.map((r) => r.tbl);
+    },
+    async getOplogHead(tables) {
+      await ensureSchema();
+      if (tables.length === 0)
+        return null;
+      const placeholders = tables.map((_, i) => `$${i + 1}`).join(", ");
+      const { rows } = await client.query(`SELECT MAX(hlc) AS head FROM ${p}_oplog WHERE tbl IN (${placeholders})`, tables);
+      return rows[0]?.head ?? null;
+    },
+    async deleteOpsBefore(hlc) {
+      await ensureSchema();
+      const { rows } = await client.query(`WITH deleted AS (
+					DELETE FROM ${p}_oplog WHERE hlc < $1 RETURNING 1
+				) SELECT COUNT(*)::text AS count FROM deleted`, [hlc]);
+      return parseInt(rows[0]?.count ?? "0", 10);
+    },
+    async reserveOp(opId) {
+      await ensureSchema();
+      const now = Date.now();
+      const { rows } = await client.query(`INSERT INTO ${p}_processed_ops (op_id, created_at)
+				 VALUES ($1, $2)
+				 ON CONFLICT (op_id) DO NOTHING
+				 RETURNING 1 AS inserted`, [opId, now]);
+      await maybeGcProcessedOps(now);
+      return rows.length > 0;
+    },
+    async reserveOps(opIds) {
+      await ensureSchema();
+      if (opIds.length === 0)
+        return [];
+      const now = Date.now();
+      const values = opIds.map((_, i) => `($${i * 2 + 1}, $${i * 2 + 2})`).join(", ");
+      const params = [];
+      for (const id of opIds)
+        params.push(id, now);
+      const { rows } = await client.query(`INSERT INTO ${p}_processed_ops (op_id, created_at)
+				 VALUES ${values}
+				 ON CONFLICT (op_id) DO NOTHING
+				 RETURNING op_id`, params);
+      await maybeGcProcessedOps(now);
+      return rows.map((r) => r.op_id);
+    },
+    async getMeta(key) {
+      await ensureSchema();
+      const { rows } = await client.query(`SELECT value FROM ${p}_meta WHERE key = $1`, [key]);
+      return rows[0]?.value ?? null;
+    },
+    async setMeta(key, value) {
+      await ensureSchema();
+      await client.query(`INSERT INTO ${p}_meta (key, value)
+				 VALUES ($1, $2)
+				 ON CONFLICT (key)
+				 DO UPDATE SET value = $2`, [key, value]);
+    },
+    close() {}
+  };
+}
+// src/server/typed-server.ts
+function createSyncServer(config) {
+  const server = createServer({
+    db: config.db,
+    transport: config.transport,
+    serverId: config.serverId,
+    storage: config.storage,
+    onEvent: config.onEvent,
+    poll: config.poll,
+    maxConnectionsPerUser: config.maxConnectionsPerUser,
+    allowAnonymous: config.allowAnonymous,
+    queryTimeoutMs: config.queryTimeoutMs,
+    maxBroadcastConcurrency: config.maxBroadcastConcurrency,
+    txAtomic: config.txAtomic
+  });
+  const implementations = new Map;
+  let authCallback = null;
+  return {
+    auth(callback) {
+      authCallback = callback;
+      server.auth(callback);
+    },
+    implement(name, impl) {
+      const def = config.queries[name];
+      if (!def) {
+        throw new Error(`Unknown query "${name}"`);
+      }
+      if (def.__view) {
+        throw new Error(`use server.view("${name}", ...) for view queries`);
+      }
+      if (def.__presence) {
+        throw new Error(`"${name}" is a presence channel, not a writable query`);
+      }
+      const o = impl;
+      const tables = o.tables ?? def.tables ?? [name];
+      const pk = def.pk ?? "id";
+      const conflict = def.conflict;
+      const readonly = def.readonly;
+      const countHints = def.countHints;
+      const defServerSet = def.serverSet;
+      const schemaServerSet = defServerSet && !Array.isArray(defServerSet) ? defServerSet : undefined;
+      const implServerSet = o.serverSet;
+      const mergedServerSet = schemaServerSet || implServerSet ? { ...schemaServerSet ?? {}, ...implServerSet ?? {} } : undefined;
+      implementations.set(name, {
+        query: o.query,
+        mutate: o.mutate,
+        authorize: o.authorize,
+        serverSet: mergedServerSet,
+        readonlyFields: readonly ? new Set(readonly) : undefined,
+        tables,
+        pk
+      });
+      server.query(name, o.query, {
+        tables,
+        pk,
+        conflict,
+        readonly: readonly ? [...readonly] : undefined,
+        serverSet: mergedServerSet,
+        countHints,
+        count: o.count,
+        groupBy: o.groupBy,
+        room: o.room,
+        broadcast: o.broadcast,
+        flushInterval: o.flushInterval,
+        maxBufferSize: o.maxBufferSize,
+        authorize: o.authorize,
+        mutate: o.mutate
+      });
+    },
+    view(name, fn) {
+      const def = config.queries[name];
+      if (!def || !def.__view) {
+        throw new Error(`"${name}" is not declared as a view in defineSyncQueries`);
+      }
+      const tables = def.deps ?? def.tables ?? [name];
+      server.query(name, fn, {
+        tables,
+        mutate: async () => {
+          const { MutationError: MutationError2 } = await Promise.resolve().then(() => (init_types(), exports_types));
+          throw new MutationError2("readonly_query", `"${name}" is a view and is read-only`);
+        }
+      });
+    },
+    rest(restConfig) {
+      const prefix = restConfig?.prefix ?? "/api";
+      const runOp = (type, queryName, rowId, payload, impl, ctx) => server.applyServerOp({ type, table: queryName, rowId, payload }, async (stamped) => {
+        const op = { ...stamped, type };
+        if (impl.authorize) {
+          await impl.authorize({ type: "write", table: queryName, op }, ctx, config.db);
+        }
+        await impl.mutate(op, ctx, config.db);
+      });
+      return async (req) => {
+        const url = new URL(req.url);
+        const path = url.pathname.slice(prefix.length);
+        const segments = path.split("/").filter(Boolean);
+        const queryName = segments[0];
+        const rowId = segments[1];
+        if (!queryName) {
+          return Response.json({ queries: [...implementations.keys()] });
+        }
+        const impl = implementations.get(queryName);
+        if (!impl) {
+          return Response.json({ error: "not_found" }, { status: 404 });
+        }
+        let auth;
+        try {
+          if (!authCallback) {
+            auth = { userId: "anonymous" };
+          } else {
+            auth = await authCallback(req);
+          }
+        } catch {
+          return Response.json({ error: "unauthorized" }, { status: 401 });
+        }
+        const params = Object.fromEntries(url.searchParams);
+        const ctx = { auth, params };
+        const idempotencyKey = req.headers.get("Idempotency-Key") ?? req.headers.get("idempotency-key");
+        const isMutation = req.method !== "GET";
+        if (isMutation && idempotencyKey) {
+          const fresh = await server.reserveOpId(`rest:${queryName}:${idempotencyKey}`);
+          if (!fresh) {
+            return Response.json({ ok: true, replayed: true });
+          }
+        }
+        try {
+          switch (req.method) {
+            case "GET": {
+              if (impl.authorize) {
+                try {
+                  await impl.authorize({ type: "read", table: queryName, params }, ctx, config.db);
+                } catch {
+                  return Response.json({ error: "forbidden" }, { status: 403 });
+                }
+              }
+              const result = impl.query(ctx, config.db);
+              const resolved = result && typeof result.then === "function" ? await result : result;
+              const rows = Array.isArray(resolved) ? resolved : [];
+              if (rowId) {
+                const row = rows.find((r) => r[impl.pk] === rowId);
+                return row ? Response.json(row) : Response.json({ error: "not_found" }, { status: 404 });
+              }
+              return Response.json(rows);
+            }
+            case "POST": {
+              if (!impl.mutate) {
+                return Response.json({ error: "readonly" }, { status: 405 });
+              }
+              const raw = await req.json();
+              if (Array.isArray(raw)) {
+                const results = [];
+                let anyFailed = false;
+                for (const item of raw) {
+                  const id2 = item[impl.pk] ?? crypto.randomUUID();
+                  const payload2 = { ...item };
+                  delete payload2[impl.pk];
+                  stripReadonly(payload2, impl.readonlyFields);
+                  applyServerSet(payload2, impl.serverSet, ctx);
+                  try {
+                    await runOp("insert", queryName, id2, payload2, impl, ctx);
+                    results.push({ ok: true, id: id2 });
+                  } catch (err) {
+                    anyFailed = true;
+                    results.push({
+                      ok: false,
+                      id: id2,
+                      error: err instanceof Error ? err.message : String(err)
+                    });
+                  }
+                }
+                const ids = results.filter((r) => r.ok).map((r) => r.id);
+                return Response.json({ ids, results }, { status: anyFailed ? 207 : 201 });
+              }
+              const body = raw;
+              const id = body[impl.pk] ?? crypto.randomUUID();
+              const payload = { ...body };
+              delete payload[impl.pk];
+              stripReadonly(payload, impl.readonlyFields);
+              applyServerSet(payload, impl.serverSet, ctx);
+              await runOp("insert", queryName, id, payload, impl, ctx);
+              return Response.json({ id }, { status: 201 });
+            }
+            case "PUT":
+            case "PATCH": {
+              if (!impl.mutate) {
+                return Response.json({ error: "readonly" }, { status: 405 });
+              }
+              if (!rowId) {
+                return Response.json({ error: "missing_id" }, { status: 400 });
+              }
+              const body = await req.json();
+              const payload = { ...body };
+              delete payload[impl.pk];
+              stripReadonly(payload, impl.readonlyFields);
+              applyServerSet(payload, impl.serverSet, ctx);
+              await runOp("update", queryName, rowId, payload, impl, ctx);
+              return Response.json({ ok: true });
+            }
+            case "DELETE": {
+              if (!impl.mutate) {
+                return Response.json({ error: "readonly" }, { status: 405 });
+              }
+              if (!rowId) {
+                return Response.json({ error: "missing_id" }, { status: 400 });
+              }
+              await runOp("delete", queryName, rowId, null, impl, ctx);
+              return Response.json({ ok: true });
+            }
+            default:
+              return Response.json({ error: "method_not_allowed" }, { status: 405 });
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          if (message.includes("forbidden") || message.includes("unauthorized")) {
+            return Response.json({ error: message }, { status: 403 });
+          }
+          return Response.json({ error: message }, { status: 500 });
+        }
+      };
+    },
+    room: server.room,
+    rateLimit: server.rateLimit,
+    compaction: server.compaction,
+    minSchemaVersion: server.minSchemaVersion,
+    runCompaction: server.runCompaction,
+    notifyChange: server.notifyChange,
+    reserveOpId: server.reserveOpId,
+    applyServerOp: server.applyServerOp,
+    emit: server.emit,
+    tx: server.tx,
+    lock: server.lock,
+    tryLock: server.tryLock,
+    interval: server.interval,
+    timeout: server.timeout,
+    close: server.close
+  };
+}
+function stripReadonly(payload, readonlyFields) {
+  if (!readonlyFields)
+    return;
+  for (const key of readonlyFields) {
+    delete payload[key];
+  }
+}
+function applyServerSet(payload, serverSet, ctx) {
+  if (!serverSet)
+    return;
+  for (const [key, val] of Object.entries(serverSet)) {
+    payload[key] = typeof val === "function" ? val(ctx) : val;
+  }
+}