meridian-server 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1680 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CompactionManager: () => CompactionManager,
+  MergeEngine: () => MergeEngine,
+  MySQLStore: () => MySQLStore,
+  PgStore: () => PgStore,
+  SQLiteStore: () => SQLiteStore,
+  ServerPresenceManager: () => ServerPresenceManager,
+  SnapshotManager: () => SnapshotManager,
+  WsHub: () => WsHub,
+  createServer: () => createServer,
+  createWALStream: () => createWALStream,
+  defineSchema: () => import_meridian_shared5.defineSchema,
+  z: () => import_meridian_shared5.z
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/pg-store.ts
+var import_pg = __toESM(require("pg"), 1);
+var import_meridian_shared = require("meridian-shared");
+var { Pool } = import_pg.default;
+var PgStore = class {
+  pool;
+  config;
+  changeCallbacks = /* @__PURE__ */ new Set();
+  listenClient = null;
+  minSeq = 0;
+  constructor(config) {
+    this.config = config;
+    this.pool = new Pool({ connectionString: config.connectionString });
+  }
+  /**
+   * Initialize the database — create tables, sequences, triggers.
+   */
+  async init() {
+    await this.pool.query(`
+      CREATE SEQUENCE IF NOT EXISTS meridian_seq;
+    `);
+    for (const [name, fields] of Object.entries(this.config.schema.collections)) {
+      await this.createTable(name, fields);
+    }
+    await this.startListening();
+    await this.updateMinSeq();
+  }
+  /**
+   * Get the table name with optional namespace prefix.
+   */
+  tableName(collection) {
+    return this.config.namespace ? `${this.config.namespace}_${collection}` : collection;
+  }
+  /**
+   * Create a table for a collection with Meridian system columns.
+   */
+  async createTable(collection, fields) {
+    const table = this.tableName(collection);
+    const tableExistsResult = await this.pool.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_name = $1
+      );
+    `, [table]);
+    const tableExists = tableExistsResult.rows[0].exists;
+    if (!tableExists) {
+      const columns = ["id TEXT PRIMARY KEY"];
+      for (const [name, def] of Object.entries(fields)) {
+        if (name === "id") continue;
+        const sqlType = (0, import_meridian_shared.fieldTypeToSQL)(def.type);
+        columns.push(`${name} ${sqlType}`);
+      }
+      columns.push(`_meridian_meta JSONB DEFAULT '{}'::jsonb`);
+      columns.push(`_meridian_seq BIGINT DEFAULT nextval('meridian_seq')`);
+      columns.push(`_meridian_deleted BOOLEAN DEFAULT false`);
+      columns.push(`_meridian_updated_at TEXT`);
+      await this.pool.query(`
+        CREATE TABLE ${table} (
+          ${columns.join(",\n          ")}
+        );
+      `);
+      await this.pool.query(`
+        CREATE INDEX idx_${table}_seq ON ${table}(_meridian_seq);
+      `);
+    } else {
+      const colsResult = await this.pool.query(`
+        SELECT column_name 
+        FROM information_schema.columns 
+        WHERE table_name = $1
+      `, [table]);
+      const existingColumns = new Set(colsResult.rows.map((r) => r.column_name));
+      for (const [name, def] of Object.entries(fields)) {
+        if (name === "id" || existingColumns.has(name)) continue;
+        const sqlType = (0, import_meridian_shared.fieldTypeToSQL)(def.type);
+        await this.pool.query(`
+          ALTER TABLE ${table} ADD COLUMN ${name} ${sqlType};
+        `);
+      }
+    }
+    await this.pool.query(`
+      CREATE OR REPLACE FUNCTION meridian_notify_${table}() RETURNS trigger AS $$
+      BEGIN
+        PERFORM pg_notify('meridian_changes', json_build_object(
+          'table', '${collection}',
+          'id', NEW.id,
+          'op', TG_OP
+        )::text);
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    `);
+    await this.pool.query(`
+      DROP TRIGGER IF EXISTS meridian_trigger_${table} ON ${table};
+      CREATE TRIGGER meridian_trigger_${table}
+        AFTER INSERT OR UPDATE ON ${table}
+        FOR EACH ROW EXECUTE FUNCTION meridian_notify_${table}();
+    `);
+  }
+  // ─── CRDT Operations ───────────────────────────────────────────────────────
+  /**
+   * Apply CRDT operations from a client.
+   * Performs field-level LWW merge with existing data.
+   * @returns Array of server changes with assigned sequence numbers and any conflicts
+   */
+  async applyOperations(ops) {
+    const client = await this.pool.connect();
+    const changes = [];
+    const allConflicts = [];
+    try {
+      await client.query("BEGIN");
+      const grouped = /* @__PURE__ */ new Map();
+      for (const op of ops) {
+        const key = `${op.collection}:${op.docId}`;
+        if (!grouped.has(key)) grouped.set(key, []);
+        grouped.get(key).push(op);
+      }
+      for (const [key, docOps] of grouped) {
+        const firstColon = key.indexOf(":");
+        const collection = key.slice(0, firstColon);
+        const docId = key.slice(firstColon + 1);
+        const table = this.tableName(collection);
+        const existing = await client.query(
+          `SELECT * FROM ${table} WHERE id = $1 FOR UPDATE`,
+          [docId]
+        );
+        const remoteMap = {};
+        for (const op of docOps) {
+          remoteMap[op.field] = {
+            value: op.value,
+            hlc: op.hlc,
+            nodeId: op.nodeId
+          };
+        }
+        let finalMap;
+        if (existing.rows.length > 0) {
+          const row = existing.rows[0];
+          const existingMeta = row._meridian_meta || {};
+          const existingMap = (0, import_meridian_shared.reconstructLWWMap)(row, existingMeta);
+          const { merged, conflicts } = (0, import_meridian_shared.mergeLWWMaps)(existingMap, remoteMap);
+          finalMap = merged;
+          if (conflicts.length > 0) {
+            allConflicts.push(...conflicts);
+          }
+        } else {
+          finalMap = remoteMap;
+        }
+        const values = (0, import_meridian_shared.extractValues)(finalMap);
+        const metadata = (0, import_meridian_shared.extractMetadata)(finalMap);
+        const latestHlc = (0, import_meridian_shared.getLatestHLC)(finalMap);
+        const deleted = (0, import_meridian_shared.isDeleted)(finalMap);
+        const fields = Object.keys(this.config.schema.collections[collection] || {}).filter((f) => f !== "id");
+        if (existing.rows.length > 0) {
+          const setClauses = [];
+          const params = [];
+          let paramIdx = 1;
+          for (const field of fields) {
+            if (field in values) {
+              setClauses.push(`${field} = $${paramIdx}`);
+              params.push(values[field]);
+              paramIdx++;
+            }
+          }
+          setClauses.push(`_meridian_meta = $${paramIdx}`);
+          params.push(JSON.stringify(metadata));
+          paramIdx++;
+          setClauses.push(`_meridian_deleted = $${paramIdx}`);
+          params.push(deleted);
+          paramIdx++;
+          setClauses.push(`_meridian_updated_at = $${paramIdx}`);
+          params.push(latestHlc);
+          paramIdx++;
+          setClauses.push(`_meridian_seq = nextval('meridian_seq')`);
+          params.push(docId);
+          const result = await client.query(
+            `UPDATE ${table} SET ${setClauses.join(", ")} WHERE id = $${paramIdx} RETURNING _meridian_seq`,
+            params
+          );
+          const seq = Number(result.rows[0]._meridian_seq);
+          for (const op of docOps) {
+            changes.push({ seq, op });
+          }
+        } else {
+          const insertFields = ["id"];
+          const insertValues = [docId];
+          const placeholders = ["$1"];
+          let paramIdx = 2;
+          for (const field of fields) {
+            if (field in values) {
+              insertFields.push(field);
+              insertValues.push(values[field]);
+              placeholders.push(`$${paramIdx}`);
+              paramIdx++;
+            }
+          }
+          insertFields.push("_meridian_meta");
+          insertValues.push(JSON.stringify(metadata));
+          placeholders.push(`$${paramIdx}`);
+          paramIdx++;
+          insertFields.push("_meridian_deleted");
+          insertValues.push(deleted);
+          placeholders.push(`$${paramIdx}`);
+          paramIdx++;
+          insertFields.push("_meridian_updated_at");
+          insertValues.push(latestHlc);
+          placeholders.push(`$${paramIdx}`);
+          const result = await client.query(
+            `INSERT INTO ${table} (${insertFields.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING _meridian_seq`,
+            insertValues
+          );
+          const seq = Number(result.rows[0]._meridian_seq);
+          for (const op of docOps) {
+            changes.push({ seq, op });
+          }
+        }
+      }
+      await client.query("COMMIT");
+    } catch (e) {
+      await client.query("ROLLBACK");
+      throw e;
+    } finally {
+      client.release();
+    }
+    return { changes, conflicts: allConflicts };
+  }
+  /**
+   * Get all changes since a given sequence number.
+   * Used for pull protocol.
+   *
+   * @returns null if seqNum is below minSeq (compaction gap), otherwise changes
+   */
+  async getChangesSince(since) {
+    if (since > 0 && since < this.minSeq) {
+      return null;
+    }
+    const changes = [];
+    const queries = [];
+    for (const collection of Object.keys(this.config.schema.collections)) {
+      const table = this.tableName(collection);
+      queries.push(`SELECT '${collection}' as _collection, id, _meridian_seq, _meridian_meta, _meridian_deleted, row_to_json(t) as _data FROM ${table} t WHERE _meridian_seq > $1`);
+    }
+    if (queries.length === 0) return changes;
+    const query = queries.join(" UNION ALL ") + " ORDER BY _meridian_seq ASC";
+    const result = await this.pool.query(query, [since]);
+    for (const row of result.rows) {
+      const collection = row._collection;
+      const meta = row._meridian_meta || {};
+      const seq = Number(row._meridian_seq);
+      const data = row._data;
+      const docId = row.id;
+      const fields = Object.keys(this.config.schema.collections[collection] || {}).filter((f) => f !== "id");
+      for (const field of fields) {
+        if (field in data && data[field] !== void 0 && data[field] !== null) {
+          const hlc = meta[field] || `0-0000-server`;
+          changes.push({
+            seq,
+            op: {
+              id: `${docId}-${field}-${hlc}`,
+              collection,
+              docId,
+              field,
+              value: data[field],
+              hlc,
+              nodeId: "server"
+            }
+          });
+        }
+      }
+      if (row._meridian_deleted) {
+        const hlc = meta[import_meridian_shared.DELETED_FIELD] || `0-0000-server`;
+        changes.push({
+          seq,
+          op: {
+            id: `${docId}-${import_meridian_shared.DELETED_FIELD}-${hlc}`,
+            collection,
+            docId,
+            field: import_meridian_shared.DELETED_FIELD,
+            value: true,
+            hlc,
+            nodeId: "server"
+          }
+        });
+      }
+    }
+    return changes;
+  }
+  /**
+   * Get the current minimum available sequence number.
+   */
+  getMinSeq() {
+    return this.minSeq;
+  }
+  // ─── Compaction ─────────────────────────────────────────────────────────────
+  /**
+   * Delete tombstoned rows older than maxAge.
+   * @returns Number of rows deleted
+   */
+  async compact(maxAgeMs) {
+    const client = await this.pool.connect();
+    let totalDeleted = 0;
+    const cutoffTime = Date.now() - maxAgeMs;
+    try {
+      await client.query("BEGIN");
+      for (const collection of Object.keys(this.config.schema.collections)) {
+        const table = this.tableName(collection);
+        const result = await client.query(
+          `DELETE FROM ${table} WHERE _meridian_deleted = true AND 
+           CAST(SPLIT_PART(_meridian_updated_at, '-', 1) AS BIGINT) < $1`,
+          [cutoffTime]
+        );
+        totalDeleted += result.rowCount ?? 0;
+      }
+      await this.updateMinSeqWithClient(client);
+      await client.query("COMMIT");
+    } catch (e) {
+      await client.query("ROLLBACK");
+      throw e;
+    } finally {
+      client.release();
+    }
+    return totalDeleted;
+  }
+  async updateMinSeqWithClient(client) {
+    let minSeq = Infinity;
+    for (const collection of Object.keys(this.config.schema.collections)) {
+      const table = this.tableName(collection);
+      const result = await client.query(
+        `SELECT MIN(_meridian_seq) as min_seq FROM ${table}`
+      );
+      const seq = result.rows[0]?.min_seq ? Number(result.rows[0].min_seq) : Infinity;
+      if (seq < minSeq) {
+        minSeq = seq;
+      }
+    }
+    this.minSeq = minSeq === Infinity ? 0 : minSeq;
+  }
+  async updateMinSeq() {
+    let minSeq = Infinity;
+    for (const collection of Object.keys(this.config.schema.collections)) {
+      const table = this.tableName(collection);
+      try {
+        const result = await this.pool.query(
+          `SELECT MIN(_meridian_seq) as min_seq FROM ${table}`
+        );
+        if (result.rows[0]?.min_seq !== null) {
+          minSeq = Math.min(minSeq, Number(result.rows[0].min_seq));
+        }
+      } catch {
+      }
+    }
+    this.minSeq = minSeq === Infinity ? 0 : minSeq;
+  }
+  // ─── LISTEN/NOTIFY ──────────────────────────────────────────────────────────
+  async startListening() {
+    this.listenClient = await this.pool.connect();
+    this.listenClient.on("notification", (msg) => {
+      if (msg.channel === "meridian_changes" && msg.payload) {
+        try {
+          const data = JSON.parse(msg.payload);
+          for (const cb of this.changeCallbacks) {
+            cb(data.table, data.id);
+          }
+        } catch (e) {
+          console.error("[Meridian PgStore] Failed to parse notification:", e);
+        }
+      }
+    });
+    await this.listenClient.query("LISTEN meridian_changes");
+  }
+  /**
+   * Register a callback for database changes.
+   */
+  onChange(callback) {
+    this.changeCallbacks.add(callback);
+    return () => this.changeCallbacks.delete(callback);
+  }
+  // ─── Cleanup ───────────────────────────────────────────────────────────────
+  /**
+   * Close the database connection pool.
+   */
+  async close() {
+    if (this.listenClient) {
+      this.listenClient.release();
+      this.listenClient = null;
+    }
+    await this.pool.end();
+  }
+};
+
+// src/ws-hub.ts
+var import_ws = require("ws");
+var HEARTBEAT_INTERVAL = 3e4;
+var AUTH_EXPIRY_WARNING = 5 * 60 * 1e3;
+var AUTH_CHECK_INTERVAL = 6e4;
+var WsHub = class {
+  wss = null;
+  config;
+  clients = /* @__PURE__ */ new Map();
+  heartbeatInterval = null;
+  authCheckInterval = null;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Start the WebSocket server.
+   */
+  start() {
+    const { port, path = "/sync" } = this.config;
+    this.wss = new import_ws.WebSocketServer({ port, path });
+    this.wss.on("connection", (ws, req) => {
+      this.handleConnection(ws, req);
+    });
+    this.startHeartbeat();
+    this.startAuthCheck();
+    this.log(`\u{1F50C} WebSocket server listening on ws://localhost:${port}${path}`);
+  }
+  /**
+   * Stop the WebSocket server.
+   */
+  stop() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.authCheckInterval) {
+      clearInterval(this.authCheckInterval);
+      this.authCheckInterval = null;
+    }
+    for (const client of this.clients.values()) {
+      client.ws.close();
+    }
+    this.clients.clear();
+    this.wss?.close();
+    this.wss = null;
+  }
+  // ─── Connection Handling ────────────────────────────────────────────────────
+  handleConnection(ws, req) {
+    const clientId = `client-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const client = {
+      id: clientId,
+      ws,
+      userId: null,
+      namespace: null,
+      subscribedCollections: /* @__PURE__ */ new Set(),
+      authExpiresAt: null,
+      lastActivity: Date.now()
+    };
+    this.clients.set(clientId, client);
+    this.log(`\u{1F517} Client connected: ${clientId}`);
+    ws.on("message", async (data) => {
+      client.lastActivity = Date.now();
+      const raw = data.toString();
+      if (raw === "ping") {
+        ws.send("pong");
+        return;
+      }
+      if (raw === "pong") {
+        return;
+      }
+      try {
+        const msg = JSON.parse(raw);
+        await this.handleClientMessage(clientId, msg, client);
+      } catch (e) {
+        this.sendTo(client, {
+          type: "error",
+          code: "PARSE_ERROR",
+          message: "Failed to parse message"
+        });
+      }
+    });
+    ws.on("close", () => {
+      this.log(`\u{1F50C} Client disconnected: ${clientId}`);
+      this.clients.delete(clientId);
+      this.config.onDisconnect?.(clientId);
+    });
+    ws.on("error", (err) => {
+      this.log(`\u274C Client error (${clientId}):`, err.message);
+    });
+  }
+  async handleClientMessage(clientId, msg, client) {
+    if (msg.type === "auth") {
+      if (this.config.auth) {
+        try {
+          const result = await this.config.auth(msg.token);
+          client.userId = result.userId;
+          client.namespace = result.namespace ?? null;
+          client.authExpiresAt = result.expiresAt ?? null;
+          this.log(`\u{1F511} Client ${clientId} authenticated as ${result.userId}`);
+          this.sendTo(client, { type: "auth-ack" });
+        } catch (e) {
+          this.sendTo(client, {
+            type: "error",
+            code: "AUTH_FAILED",
+            message: e instanceof Error ? e.message : "Authentication failed"
+          });
+          client.ws.close();
+          return;
+        }
+      }
+      return;
+    }
+    if (this.config.auth && !client.userId) {
+      this.sendTo(client, {
+        type: "error",
+        code: "AUTH_REQUIRED",
+        message: "Authentication required. Send an auth message first."
+      });
+      return;
+    }
+    if (msg.type === "subscribe") {
+      for (const collection of msg.collections) {
+        client.subscribedCollections.add(collection);
+      }
+      if (this.config.onSubscribe) {
+        this.config.onSubscribe(clientId, msg.collections, msg.filter);
+      }
+      this.log(`\u{1F4CB} Client ${clientId} subscribed to: ${msg.collections.join(", ")}`);
+      return;
+    }
+    this.config.onMessage(clientId, msg, client);
+  }
+  // ─── Broadcasting ──────────────────────────────────────────────────────────
+  /**
+   * Send a message to a specific client.
+   */
+  sendTo(client, msg) {
+    if (client.ws.readyState === import_ws.WebSocket.OPEN) {
+      client.ws.send(JSON.stringify(msg));
+    }
+  }
+  /**
+   * Send a message to a client by ID.
+   */
+  sendToId(clientId, msg) {
+    const client = this.clients.get(clientId);
+    if (client) {
+      this.sendTo(client, msg);
+    }
+  }
+  /**
+   * Broadcast a message to all clients subscribed to a collection.
+   * Excludes the sender.
+   */
+  broadcastToCollection(collection, msg, excludeClientId, namespace) {
+    for (const [id, client] of this.clients) {
+      if (id === excludeClientId) continue;
+      if (namespace !== void 0 && client.namespace !== namespace) continue;
+      if (client.subscribedCollections.has(collection)) {
+        this.sendTo(client, msg);
+      }
+    }
+  }
+  /**
+   * Broadcast a message to all connected clients.
+   */
+  broadcastToAll(msg, namespace) {
+    for (const client of this.clients.values()) {
+      if (namespace !== void 0 && client.namespace !== namespace) continue;
+      this.sendTo(client, msg);
+    }
+  }
+  /**
+   * Get all connected client IDs.
+   */
+  getClientIds() {
+    return Array.from(this.clients.keys());
+  }
+  /**
+   * Get a connected client by ID.
+   */
+  getClient(clientId) {
+    return this.clients.get(clientId);
+  }
+  // ─── Heartbeat ──────────────────────────────────────────────────────────────
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [id, client] of this.clients) {
+        if (client.ws.readyState !== import_ws.WebSocket.OPEN || now - client.lastActivity > HEARTBEAT_INTERVAL * 2) {
+          this.log(`\u26A0\uFE0F Disconnecting inactive client: ${id}`);
+          client.ws.terminate();
+          this.clients.delete(id);
+          this.config.onDisconnect?.(id);
+        } else {
+          client.ws.send("ping");
+        }
+      }
+    }, HEARTBEAT_INTERVAL);
+  }
+  // ─── Auth Expiry Check ─────────────────────────────────────────────────────
+  startAuthCheck() {
+    if (!this.config.auth) return;
+    this.authCheckInterval = setInterval(() => {
+      const now = Date.now();
+      for (const client of this.clients.values()) {
+        if (!client.authExpiresAt) continue;
+        const timeLeft = client.authExpiresAt - now;
+        if (timeLeft <= 0) {
+          this.sendTo(client, { type: "auth-expired" });
+          client.ws.close();
+        } else if (timeLeft <= AUTH_EXPIRY_WARNING) {
+          this.sendTo(client, {
+            type: "auth-expiring",
+            expiresIn: Math.floor(timeLeft / 1e3)
+          });
+        }
+      }
+    }, AUTH_CHECK_INTERVAL);
+  }
+  // ─── Utilities ──────────────────────────────────────────────────────────────
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[Meridian WsHub]", ...args);
+    }
+  }
+};
+
+// src/merge.ts
+var import_meridian_shared2 = require("meridian-shared");
+var MergeEngine = class {
+  config;
+  conflictLog = [];
+  maxConflictLog = 1e3;
+  /** Per-client subscribe filters: clientId → collection → filter */
+  clientFilters = /* @__PURE__ */ new Map();
+  ruleEvaluator = null;
+  constructor(config) {
+    this.config = config;
+    if (config.permissions) {
+      this.ruleEvaluator = new import_meridian_shared2.RuleEvaluator(config.permissions);
+    }
+  }
+  /** Store a client's subscribe filter for partial sync */
+  setClientFilter(clientId, collections, filter) {
+    const map = /* @__PURE__ */ new Map();
+    if (filter) {
+      for (const [col, f] of Object.entries(filter)) {
+        map.set(col, f);
+      }
+    }
+    for (const col of collections) {
+      if (!map.has(col)) map.set(col, {});
+    }
+    this.clientFilters.set(clientId, map);
+  }
+  /** Remove client filters on disconnect */
+  removeClientFilter(clientId) {
+    this.clientFilters.delete(clientId);
+  }
+  /**
+   * Process a push from a client.
+   * Merges operations with existing state, assigns seqNums, and broadcasts.
+   *
+   * @param clientId - The sending client's ID
+   * @param ops - CRDT operations from the client
+   * @param client - The connected client object
+   */
+  async processPush(clientId, ops, client) {
+    if (ops.length === 0) return;
+    this.log(`\u2B07\uFE0F Processing ${ops.length} ops from ${clientId}`);
+    try {
+      const { changes, conflicts } = await this.config.pgStore.applyOperations(ops);
+      if (changes.length === 0) return;
+      for (const conflict of conflicts) {
+        const op = ops.find((o) => o.field === conflict.field && (o.value === conflict.winnerValue || o.value === conflict.loserValue));
+        if (op) {
+          const conflictRecord = {
+            ...conflict,
+            collection: op.collection,
+            docId: op.docId,
+            timestamp: Date.now()
+          };
+          this.conflictLog.push(conflictRecord);
+          if (this.conflictLog.length > this.maxConflictLog) {
+            this.conflictLog.shift();
+          }
+          if (this.config.onConflict) {
+            this.config.onConflict(conflictRecord);
+          }
+        }
+      }
+      const lastSeq = Math.max(...changes.map((c) => c.seq));
+      const opIds = ops.map((op) => op.id);
+      this.config.wsHub.sendTo(client, {
+        type: "ack",
+        lastSeq,
+        opIds
+      });
+      const collections = new Set(ops.map((op) => op.collection));
+      for (const collection of collections) {
+        const collectionChanges = changes.filter((c) => c.op.collection === collection);
+        if (collectionChanges.length > 0) {
+          this.config.wsHub.broadcastToCollection(
+            collection,
+            { type: "changes", changes: collectionChanges },
+            clientId,
+            client.namespace
+          );
+        }
+      }
+      this.log(`\u2705 Applied ${changes.length} changes, lastSeq=${lastSeq}`);
+    } catch (e) {
+      this.log(`\u274C Merge failed:`, e);
+      for (const op of ops) {
+        this.config.wsHub.sendTo(client, {
+          type: "reject",
+          opId: op.id,
+          code: "VALIDATION",
+          reason: e instanceof Error ? e.message : "Merge failed"
+        });
+      }
+    }
+  }
+  /**
+   * Process a pull request from a client.
+   * Returns changes since the given sequence number.
+   */
+  async processPull(clientId, since, client) {
+    this.log(`\u2B07\uFE0F Pull request from ${clientId}: since=${since}`);
+    const changes = await this.config.pgStore.getChangesSince(since);
+    if (changes === null) {
+      this.config.wsHub.sendTo(client, {
+        type: "full-sync-required",
+        reason: "compaction",
+        minSeq: this.config.pgStore.getMinSeq()
+      });
+      return;
+    }
+    const clientFilter = this.clientFilters.get(clientId);
+    let filtered = changes.filter((c) => {
+      if (client.subscribedCollections.size > 0 && !client.subscribedCollections.has(c.op.collection)) {
+        return false;
+      }
+      if (clientFilter) {
+        const colFilter = clientFilter.get(c.op.collection);
+        if (colFilter && Object.keys(colFilter).length > 0) {
+          return true;
+        }
+      }
+      return true;
+    });
+    if (this.ruleEvaluator && client.userId) {
+      const authCtx = { userId: client.userId };
+      const permissionFiltered = [];
+      for (const change of filtered) {
+        const allowed = await this.ruleEvaluator.check(
+          change.op.collection,
+          "read",
+          authCtx,
+          { existing: null, incoming: null }
+        );
+        if (allowed) permissionFiltered.push(change);
+      }
+      filtered = permissionFiltered;
+    }
+    if (filtered.length > 0) {
+      this.config.wsHub.sendTo(client, {
+        type: "changes",
+        changes: filtered
+      });
+    }
+    this.log(`\u{1F4E4} Sent ${filtered.length} changes to ${clientId}`);
+  }
+  /**
+   * Get the conflict log.
+   */
+  getConflictLog() {
+    return [...this.conflictLog];
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[Meridian Merge]", ...args);
+    }
+  }
+};
+
+// src/presence.ts
+var ServerPresenceManager = class {
+  presence = /* @__PURE__ */ new Map();
+  wsHub;
+  debug;
+  constructor(wsHub, debug = false) {
+    this.wsHub = wsHub;
+    this.debug = debug;
+  }
+  /**
+   * Update presence for a client and broadcast to peers.
+   */
+  update(clientId, data, client) {
+    this.presence.set(clientId, data);
+    if (this.debug) {
+      console.log(`[Meridian Presence] Updated: ${clientId}`, data);
+    }
+    this.broadcastAll(client.namespace);
+  }
+  /**
+   * Remove presence for a disconnected client.
+   */
+  remove(clientId) {
+    const had = this.presence.delete(clientId);
+    if (had && this.debug) {
+      console.log(`[Meridian Presence] Removed: ${clientId}`);
+    }
+    this.broadcastAll(null);
+  }
+  /**
+   * Get all current presence data.
+   */
+  getAll() {
+    return Object.fromEntries(this.presence);
+  }
+  /**
+   * Send current presence state to a specific client (e.g., on reconnect).
+   */
+  sendCurrentState(client) {
+    this.wsHub.sendTo(client, {
+      type: "presence",
+      peers: Object.fromEntries(this.presence)
+    });
+  }
+  broadcastAll(namespace) {
+    this.wsHub.broadcastToAll(
+      {
+        type: "presence",
+        peers: Object.fromEntries(this.presence)
+      },
+      namespace
+    );
+  }
+  /**
+   * Clear all presence data.
+   */
+  clear() {
+    this.presence.clear();
+  }
+};
+
+// src/compaction.ts
+var DEFAULT_MAX_AGE = 30 * 24 * 60 * 60 * 1e3;
+var DEFAULT_INTERVAL = 24 * 60 * 60 * 1e3;
+var CompactionManager = class {
+  pgStore;
+  wsHub;
+  config;
+  timer = null;
+  constructor(pgStore, wsHub, config) {
+    this.pgStore = pgStore;
+    this.wsHub = wsHub;
+    this.config = {
+      tombstoneMaxAge: config?.tombstoneMaxAge ?? DEFAULT_MAX_AGE,
+      interval: config?.interval ?? DEFAULT_INTERVAL,
+      debug: config?.debug ?? false
+    };
+  }
+  /**
+   * Start the compaction scheduler.
+   */
+  start() {
+    this.log(`\u{1F9F9} Compaction scheduler started (interval: ${this.config.interval}ms, maxAge: ${this.config.tombstoneMaxAge}ms)`);
+    setTimeout(() => this.runCompaction(), 5e3);
+    this.timer = setInterval(() => this.runCompaction(), this.config.interval);
+  }
+  /**
+   * Stop the compaction scheduler.
+   */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * Run compaction now.
+   */
+  async runCompaction() {
+    this.log("\u{1F9F9} Running compaction...");
+    try {
+      const deleted = await this.pgStore.compact(this.config.tombstoneMaxAge);
+      const minSeq = this.pgStore.getMinSeq();
+      if (deleted > 0) {
+        this.log(`\u{1F9F9} Compacted ${deleted} tombstones. New minSeq: ${minSeq}`);
+        this.wsHub.broadcastToAll({
+          type: "compaction",
+          minSeq
+        });
+      } else {
+        this.log("\u{1F9F9} No tombstones to compact");
+      }
+      return deleted;
+    } catch (e) {
+      this.log("\u274C Compaction failed:", e);
+      return 0;
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[Meridian Compaction]", ...args);
+    }
+  }
+};
+
+// src/server.ts
+function createServer(config) {
+  const {
+    port,
+    database,
+    schema,
+    path = "/sync",
+    auth,
+    compaction,
+    onConflict,
+    permissions,
+    debug = false
+  } = config;
+  const pgStore = new PgStore({
+    connectionString: database,
+    schema
+  });
+  let mergeEngine;
+  let presenceManager;
+  const wsHub = new WsHub({
+    port,
+    path,
+    auth,
+    debug,
+    onMessage: (clientId, msg, client) => {
+      switch (msg.type) {
+        case "push":
+          mergeEngine.processPush(clientId, msg.ops, client);
+          break;
+        case "pull":
+          mergeEngine.processPull(clientId, msg.since, client);
+          break;
+        case "presence":
+          presenceManager.update(clientId, msg.data, client);
+          break;
+        default:
+          break;
+      }
+    },
+    onDisconnect: (clientId) => {
+      presenceManager.remove(clientId);
+      mergeEngine.removeClientFilter(clientId);
+    },
+    onSubscribe: (clientId, collections, filter) => {
+      mergeEngine.setClientFilter(clientId, collections, filter);
+    }
+  });
+  mergeEngine = new MergeEngine({
+    pgStore,
+    wsHub,
+    debug,
+    onConflict,
+    permissions
+  });
+  presenceManager = new ServerPresenceManager(wsHub, debug);
+  const compactionManager = new CompactionManager(pgStore, wsHub, {
+    tombstoneMaxAge: compaction?.tombstoneMaxAge,
+    interval: compaction?.interval,
+    debug
+  });
+  pgStore.onChange((tableName, docId) => {
+    if (debug) {
+      console.log(`[Meridian Server] \u{1F4E2} DB change: ${tableName}/${docId}`);
+    }
+  });
+  return {
+    async start() {
+      if (debug) {
+        console.log("[Meridian Server] \u{1F680} Starting...");
+        console.log(`[Meridian Server] \u{1F4E6} Schema v${schema.version}: ${Object.keys(schema.collections).join(", ")}`);
+        console.log(`[Meridian Server] \u{1F418} Database: ${database.replace(/\/\/.*@/, "//***@")}`);
+      }
+      await pgStore.init();
+      wsHub.start();
+      compactionManager.start();
+      if (debug) {
+        console.log(`[Meridian Server] \u2705 Ready on ws://localhost:${port}${path}`);
+      }
+    },
+    async stop() {
+      if (debug) {
+        console.log("[Meridian Server] \u{1F6D1} Stopping...");
+      }
+      compactionManager.stop();
+      wsHub.stop();
+      presenceManager.clear();
+      await pgStore.close();
+      if (debug) {
+        console.log("[Meridian Server] \u2705 Stopped");
+      }
+    },
+    async compact() {
+      return compactionManager.runCompaction();
+    },
+    getClientCount() {
+      return wsHub.getClientIds().length;
+    }
+  };
+}
+
+// src/wal-stream.ts
+var import_pg2 = require("pg");
+var NotifyStream = class {
+  client;
+  config;
+  connected = false;
+  constructor(config) {
+    this.config = config;
+    this.client = new import_pg2.Client({ connectionString: config.connectionString });
+  }
+  async start() {
+    await this.client.connect();
+    this.connected = true;
+    const channel = this.config.channel || "meridian_changes";
+    this.client.on("notification", (msg) => {
+      try {
+        const payload = JSON.parse(msg.payload || "{}");
+        if (this.config.debug) {
+          console.log(`[WAL-NOTIFY] ${channel}:`, payload.collection, payload.docId);
+        }
+        this.config.onChange({
+          collection: payload.collection,
+          docId: payload.docId,
+          operation: payload.operation || "UPDATE",
+          fields: payload.fields,
+          seq: payload.seq
+        });
+      } catch (err) {
+        console.error("[WAL-NOTIFY] Failed to parse notification:", err);
+      }
+    });
+    await this.client.query(`LISTEN ${channel}`);
+    if (this.config.debug) {
+      console.log(`[WAL-NOTIFY] Listening on channel "${channel}"`);
+    }
+    await this.createNotifyTriggers();
+  }
+  async createNotifyTriggers() {
+    await this.client.query(`
+      CREATE OR REPLACE FUNCTION meridian_notify() RETURNS trigger AS $$
+      BEGIN
+        PERFORM pg_notify(
+          $1,
+          json_build_object(
+            'collection', TG_TABLE_NAME,
+            'docId', NEW.id,
+            'operation', TG_OP,
+            'seq', NEW._meridian_seq
+          )::text
+        );
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    `, [this.config.channel || "meridian_changes"]);
+  }
+  async stop() {
+    if (!this.connected) return;
+    const channel = this.config.channel || "meridian_changes";
+    await this.client.query(`UNLISTEN ${channel}`);
+    await this.client.end();
+    this.connected = false;
+  }
+};
+var WALStream = class {
+  config;
+  client = null;
+  pollingInterval = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async start() {
+    this.client = new import_pg2.Client({ connectionString: this.config.connectionString });
+    await this.client.connect();
+    const pubName = this.config.publication || "meridian_pub";
+    const slotName = this.config.slot || "meridian_slot";
+    await this.client.query(`CREATE EXTENSION IF NOT EXISTS wal2json`);
+    await this.client.query(`
+      DO $$
+      BEGIN
+        IF NOT EXISTS (SELECT 1 FROM pg_publication WHERE pubname = '${pubName}') THEN
+          CREATE PUBLICATION ${pubName} FOR ALL TABLES;
+        END IF;
+      END $$;
+    `);
+    const { rows: slotRows } = await this.client.query(
+      `SELECT slot_name FROM pg_replication_slots WHERE slot_name = $1`,
+      [slotName]
+    );
+    if (slotRows.length === 0) {
+      await this.client.query(
+        `SELECT pg_create_logical_replication_slot($1, 'wal2json')`,
+        [slotName]
+      );
+    }
+    const POLL_INTERVAL = 100;
+    this.pollingInterval = setInterval(async () => {
+      try {
+        const { rows } = await this.client.query(
+          `SELECT data FROM pg_logical_slot_get_changes($1, NULL, NULL)`,
+          [slotName]
+        );
+        for (const row of rows) {
+          const parsed = this.parsePGOutput(row.data);
+          if (parsed) {
+            this.config.onChange({
+              collection: parsed.collection,
+              docId: parsed.docId,
+              operation: parsed.operation,
+              seq: parsed.seq
+            });
+          }
+        }
+      } catch (err) {
+        console.error("[WAL] Poll error:", err);
+      }
+    }, POLL_INTERVAL);
+    if (this.config.debug) {
+      console.log(`[WAL] Publication "${pubName}", slot "${slotName}", polling every ${POLL_INTERVAL}ms`);
+    }
+  }
+  /** Parse wal2json JSON output into a WALChange */
+  parsePGOutput(data) {
+    try {
+      const parsed = JSON.parse(data);
+      if (!parsed.change || parsed.change.length === 0) return null;
+      const change = parsed.change[0];
+      const table = change.table;
+      const kind = change.kind;
+      let docId;
+      if (change.columnvalues && change.columnnames) {
+        const idIndex = change.columnnames.indexOf("id");
+        docId = idIndex >= 0 ? String(change.columnvalues[idIndex]) : String(change.columnvalues[0]);
+      } else if (change.oldkeys?.keyvalues) {
+        const idIndex = change.oldkeys.keynames.indexOf("id");
+        docId = idIndex >= 0 ? String(change.oldkeys.keyvalues[idIndex]) : String(change.oldkeys.keyvalues[0]);
+      }
+      if (!docId || !table) return null;
+      const operation = kind === "delete" ? "DELETE" : kind === "update" ? "UPDATE" : "INSERT";
+      let seq;
+      if (change.columnnames && change.columnvalues) {
+        const seqIndex = change.columnnames.indexOf("_meridian_seq");
+        if (seqIndex >= 0) seq = parseInt(change.columnvalues[seqIndex], 10);
+      }
+      return { collection: table, docId, operation, seq };
+    } catch {
+      return null;
+    }
+  }
+  async stop() {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+      this.pollingInterval = null;
+    }
+    if (this.client) {
+      await this.client.end();
+      this.client = null;
+    }
+  }
+};
+function createWALStream(config) {
+  const mode = config.mode || "notify";
+  if (mode === "wal") {
+    return new WALStream(config);
+  }
+  return new NotifyStream(config);
+}
+
+// src/sqlite-store.ts
+var import_meridian_shared3 = require("meridian-shared");
+var SQLiteStore = class {
+  driver;
+  config;
+  lastSeq = 0;
+  minSeq = 0;
+  constructor(config) {
+    this.driver = config.driver;
+    this.config = config;
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  async init() {
+    const { schema } = this.config;
+    this.driver.exec(`
+      CREATE TABLE IF NOT EXISTS _meridian_sync (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+    for (const [name, colSchema] of Object.entries(schema.collections)) {
+      this.createTable(name, colSchema);
+    }
+    const row = this.driver.prepare("SELECT value FROM _meridian_sync WHERE key = 'last_seq'").get();
+    this.lastSeq = row ? parseInt(row.value, 10) : 0;
+    if (this.config.debug) {
+      console.log(`[SQLite Store] Initialized. Last seq: ${this.lastSeq}`);
+    }
+  }
+  createTable(name, schema) {
+    const columns = ["id TEXT PRIMARY KEY"];
+    for (const [field, def] of Object.entries(schema)) {
+      if (field === "id") continue;
+      const sqlType = (0, import_meridian_shared3.fieldTypeToSQL)(def.type);
+      const defaultClause = def.defaultValue !== void 0 ? ` DEFAULT ${JSON.stringify(def.defaultValue)}` : "";
+      columns.push(`"${field}" ${sqlType}${defaultClause}`);
+    }
+    columns.push("_meridian_meta TEXT");
+    columns.push("_meridian_seq INTEGER");
+    columns.push("_meridian_deleted INTEGER DEFAULT 0");
+    columns.push("_meridian_updated_at TEXT");
+    this.driver.exec(`CREATE TABLE IF NOT EXISTS "${name}" (${columns.join(", ")})`);
+    this.driver.exec(`CREATE INDEX IF NOT EXISTS idx_${name}_seq ON "${name}" (_meridian_seq)`);
+  }
+  // ─── CRUD ──────────────────────────────────────────────────────────────────
+  async applyOperations(ops) {
+    const changes = [];
+    const conflicts = [];
+    const grouped = /* @__PURE__ */ new Map();
+    for (const op of ops) {
+      const key = `${op.collection}:${op.docId}`;
+      if (!grouped.has(key)) grouped.set(key, []);
+      grouped.get(key).push(op);
+    }
+    for (const [key, docOps] of grouped) {
+      const [collection, docId] = key.split(":");
+      const existing = this.driver.prepare(`SELECT * FROM "${collection}" WHERE id = ?`).get(docId);
+      const existingMeta = existing?._meridian_meta ? JSON.parse(existing._meridian_meta) : null;
+      const remoteMap = {};
+      for (const op of docOps) {
+        remoteMap[op.field] = { value: op.value, hlc: op.hlc, nodeId: op.nodeId };
+      }
+      let finalMap;
+      if (existingMeta) {
+        const { merged, conflicts: fieldConflicts } = (0, import_meridian_shared3.mergeLWWMaps)(existingMeta, remoteMap);
+        finalMap = merged;
+        for (const c of fieldConflicts) {
+          conflicts.push({ collection, docId, ...c });
+        }
+      } else {
+        finalMap = remoteMap;
+        finalMap[import_meridian_shared3.DELETED_FIELD] = { value: false, hlc: docOps[0].hlc, nodeId: docOps[0].nodeId };
+      }
+      if ((0, import_meridian_shared3.isDeleted)(finalMap)) {
+        this.driver.prepare(`DELETE FROM "${collection}" WHERE id = ?`).run(docId);
+      } else {
+        const values = (0, import_meridian_shared3.extractValues)(finalMap);
+        const defaults = (0, import_meridian_shared3.getDefaults)(this.config.schema.collections[collection]);
+        for (const [field, defaultVal] of Object.entries(defaults)) {
+          if (!(field in values)) values[field] = defaultVal;
+        }
+        const meta = JSON.stringify((0, import_meridian_shared3.extractMetadata)(finalMap));
+        this.lastSeq++;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        if (existing) {
+          const setClauses = [];
+          const params = [];
+          for (const [field, value] of Object.entries(values)) {
+            setClauses.push(`"${field}" = ?`);
+            params.push(value);
+          }
+          setClauses.push("_meridian_meta = ?");
+          params.push(meta);
+          setClauses.push("_meridian_seq = ?");
+          params.push(this.lastSeq);
+          setClauses.push("_meridian_updated_at = ?");
+          params.push(now);
+          this.driver.prepare(`UPDATE "${collection}" SET ${setClauses.join(", ")} WHERE id = ?`).run(...params, docId);
+        } else {
+          const fields = Object.keys(values);
+          const placeholders = fields.map(() => "?").join(", ");
+          const params = fields.map((f) => values[f]);
+          params.push(meta, this.lastSeq, 0, now);
+          this.driver.prepare(`INSERT INTO "${collection}" (${fields.map((f) => `"${f}"`).join(", ")}, _meridian_meta, _meridian_seq, _meridian_deleted, _meridian_updated_at) VALUES (${placeholders}, ?, ?, 0, ?)`).run(...params);
+        }
+      }
+      for (const op of docOps) {
+        changes.push({ seq: this.lastSeq, op });
+      }
+    }
+    this.driver.prepare("INSERT OR REPLACE INTO _meridian_sync (key, value) VALUES ('last_seq', ?)").run(this.lastSeq.toString());
+    return { changes, conflicts };
+  }
+  async getChangesSince(since) {
+    if (since < this.minSeq) return null;
+    const changes = [];
+    for (const name of Object.keys(this.config.schema.collections)) {
+      const rows = this.driver.prepare(`SELECT * FROM "${name}" WHERE _meridian_seq > ?`).all(since);
+      for (const row of rows) {
+        const meta = row._meridian_meta ? JSON.parse(row._meridian_meta) : {};
+        for (const [field, hlcStr] of Object.entries(meta)) {
+          changes.push({
+            seq: row._meridian_seq,
+            op: {
+              id: `${row.id}-${field}-${hlcStr}`,
+              collection: name,
+              docId: row.id,
+              field,
+              value: row[field],
+              hlc: hlcStr,
+              nodeId: "server"
+            }
+          });
+        }
+      }
+    }
+    return changes;
+  }
+  getMinSeq() {
+    return this.minSeq;
+  }
+  async compact(maxAgeMs) {
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    let deleted = 0;
+    for (const name of Object.keys(this.config.schema.collections)) {
+      const result = this.driver.prepare(`DELETE FROM "${name}" WHERE _meridian_deleted = 1 AND _meridian_updated_at < ?`).run(cutoff);
+      deleted += result.changes;
+    }
+    this.minSeq = this.lastSeq;
+    if (this.config.debug) {
+      console.log(`[SQLite Store] Compaction: deleted ${deleted} tombstones`);
+    }
+    return deleted;
+  }
+  async close() {
+    this.driver.close();
+  }
+};
+
+// src/mysql-store.ts
+var import_meridian_shared4 = require("meridian-shared");
+function mysqlType(fieldType) {
+  switch (fieldType) {
+    case "string":
+      return "TEXT";
+    case "number":
+      return "DOUBLE";
+    case "boolean":
+      return "TINYINT(1)";
+    case "array":
+    case "object":
+      return "JSON";
+    default:
+      return "TEXT";
+  }
+}
+var MySQLStore = class {
+  pool;
+  config;
+  lastSeq = 0;
+  minSeq = 0;
+  constructor(config) {
+    this.pool = config.pool;
+    this.config = config;
+  }
+  async init() {
+    const { schema } = this.config;
+    await this.pool.execute(`CREATE TABLE IF NOT EXISTS _meridian_sync (
+      \`key\` VARCHAR(255) PRIMARY KEY,
+      \`value\` TEXT NOT NULL
+    ) ENGINE=InnoDB`);
+    for (const [name, colSchema] of Object.entries(schema.collections)) {
+      const columns = ["id VARCHAR(255) PRIMARY KEY"];
+      for (const [field, def] of Object.entries(colSchema)) {
+        if (field === "id") continue;
+        const sqlType = mysqlType(def.type);
+        const defaultVal = def.defaultValue !== void 0 ? ` DEFAULT ${JSON.stringify(def.defaultValue)}` : "";
+        columns.push(`\`${field}\` ${sqlType}${defaultVal}`);
+      }
+      columns.push("_meridian_meta JSON");
+      columns.push("_meridian_seq BIGINT");
+      columns.push("_meridian_deleted TINYINT(1) DEFAULT 0");
+      columns.push("_meridian_updated_at VARCHAR(30)");
+      await this.pool.execute(
+        `CREATE TABLE IF NOT EXISTS \`${name}\` (${columns.join(", ")}) ENGINE=InnoDB`
+      );
+      await this.pool.execute(
+        `CREATE INDEX IF NOT EXISTS idx_${name}_seq ON \`${name}\` (_meridian_seq)`
+      );
+    }
+    const [rows] = await this.pool.query(
+      "SELECT value FROM _meridian_sync WHERE `key` = 'last_seq'"
+    );
+    this.lastSeq = rows.length > 0 ? parseInt(rows[0].value, 10) : 0;
+    if (this.config.debug) {
+      console.log(`[MySQL Store] Initialized. Last seq: ${this.lastSeq}`);
+    }
+  }
+  async applyOperations(ops) {
+    const changes = [];
+    const conflicts = [];
+    const grouped = /* @__PURE__ */ new Map();
+    for (const op of ops) {
+      const key = `${op.collection}:${op.docId}`;
+      if (!grouped.has(key)) grouped.set(key, []);
+      grouped.get(key).push(op);
+    }
+    for (const [key, docOps] of grouped) {
+      const [collection, docId] = key.split(":");
+      const [rows] = await this.pool.query(
+        `SELECT * FROM \`${collection}\` WHERE id = ?`,
+        [docId]
+      );
+      const existing = rows.length > 0 ? rows[0] : null;
+      const existingMeta = existing?._meridian_meta ? JSON.parse(existing._meridian_meta) : null;
+      const remoteMap = {};
+      for (const op of docOps) {
+        remoteMap[op.field] = { value: op.value, hlc: op.hlc, nodeId: op.nodeId };
+      }
+      let finalMap;
+      if (existingMeta) {
+        const { merged, conflicts: fieldConflicts } = (0, import_meridian_shared4.mergeLWWMaps)(existingMeta, remoteMap);
+        finalMap = merged;
+        for (const c of fieldConflicts) {
+          conflicts.push({ collection, docId, ...c });
+        }
+      } else {
+        finalMap = remoteMap;
+        finalMap[import_meridian_shared4.DELETED_FIELD] = { value: false, hlc: docOps[0].hlc, nodeId: docOps[0].nodeId };
+      }
+      this.lastSeq++;
+      const meta = JSON.stringify((0, import_meridian_shared4.extractMetadata)(finalMap));
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      if ((0, import_meridian_shared4.isDeleted)(finalMap)) {
+        await this.pool.execute(`DELETE FROM \`${collection}\` WHERE id = ?`, [docId]);
+      } else {
+        const values = (0, import_meridian_shared4.extractValues)(finalMap);
+        const defaults = (0, import_meridian_shared4.getDefaults)(this.config.schema.collections[collection]);
+        for (const [field, defaultVal] of Object.entries(defaults)) {
+          if (!(field in values)) values[field] = defaultVal;
+        }
+        if (existing) {
+          const setClauses = [];
+          const params = [];
+          for (const [field, value] of Object.entries(values)) {
+            setClauses.push(`\`${field}\` = ?`);
+            params.push(value);
+          }
+          setClauses.push("_meridian_meta = ?");
+          params.push(meta);
+          setClauses.push("_meridian_seq = ?");
+          params.push(this.lastSeq);
+          setClauses.push("_meridian_updated_at = ?");
+          params.push(now);
+          params.push(docId);
+          await this.pool.execute(
+            `UPDATE \`${collection}\` SET ${setClauses.join(", ")} WHERE id = ?`,
+            params
+          );
+        } else {
+          const fields = Object.keys(values).filter((f) => f !== "id");
+          const allFields = [...fields, "_meridian_meta", "_meridian_seq", "_meridian_deleted", "_meridian_updated_at"];
+          const placeholders = allFields.map(() => "?").join(", ");
+          const params = [
+            docId,
+            ...fields.map((f) => values[f]),
+            meta,
+            this.lastSeq,
+            0,
+            now
+          ];
+          await this.pool.execute(
+            `INSERT INTO \`${collection}\` (id, ${fields.map((f) => `\`${f}\``).join(", ")}, _meridian_meta, _meridian_seq, _meridian_deleted, _meridian_updated_at) VALUES (?, ${placeholders})`,
+            params
+          );
+        }
+      }
+      for (const op of docOps) {
+        changes.push({ seq: this.lastSeq, op });
+      }
+    }
+    await this.pool.execute(
+      "INSERT INTO _meridian_sync (`key`, value) VALUES ('last_seq', ?) ON DUPLICATE KEY UPDATE value = ?",
+      [this.lastSeq.toString(), this.lastSeq.toString()]
+    );
+    return { changes, conflicts };
+  }
+  async getChangesSince(since) {
+    if (since < this.minSeq) return null;
+    const changes = [];
+    for (const name of Object.keys(this.config.schema.collections)) {
+      const [rows] = await this.pool.query(
+        `SELECT * FROM \`${name}\` WHERE _meridian_seq > ?`,
+        [since]
+      );
+      for (const row of rows) {
+        const meta = row._meridian_meta ? JSON.parse(row._meridian_meta) : {};
+        for (const [field, hlcStr] of Object.entries(meta)) {
+          changes.push({
+            seq: row._meridian_seq,
+            op: {
+              id: `${row.id}-${field}-${hlcStr}`,
+              collection: name,
+              docId: row.id,
+              field,
+              value: row[field],
+              hlc: hlcStr,
+              nodeId: "server"
+            }
+          });
+        }
+      }
+    }
+    return changes;
+  }
+  getMinSeq() {
+    return this.minSeq;
+  }
+  async compact(maxAgeMs) {
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    let deleted = 0;
+    for (const name of Object.keys(this.config.schema.collections)) {
+      const [result] = await this.pool.execute(
+        `DELETE FROM \`${name}\` WHERE _meridian_deleted = 1 AND _meridian_updated_at < ?`,
+        [cutoff]
+      );
+      deleted += result.affectedRows;
+    }
+    this.minSeq = this.lastSeq;
+    return deleted;
+  }
+  async close() {
+    await this.pool.end();
+  }
+};
+
+// src/snapshot.ts
+var SnapshotManager = class {
+  config;
+  snapshots = /* @__PURE__ */ new Map();
+  opCounter = 0;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Track an operation. Creates a snapshot when the interval is reached.
+   */
+  async trackOp() {
+    this.opCounter++;
+    if (this.opCounter >= this.config.interval) {
+      await this.createSnapshot();
+    }
+  }
+  /**
+   * Create a snapshot of all collections at the current sequence number.
+   */
+  async createSnapshot() {
+    const changes = await this.config.store.getChangesSince(this.config.store.getMinSeq());
+    const seq = changes ? Math.max(...changes.map((c) => c.seq), this.config.store.getMinSeq()) : this.config.store.getMinSeq();
+    const collections = {};
+    for (const name of Object.keys(this.config.schema.collections)) {
+      if (changes) {
+        const docs = changes.filter((c) => c.op.collection === name).reduce((acc, c) => {
+          if (!acc[c.op.docId]) acc[c.op.docId] = { id: c.op.docId };
+          acc[c.op.docId][c.op.field] = c.op.value;
+          return acc;
+        }, {});
+        collections[name] = {
+          name,
+          count: Object.keys(docs).length,
+          documents: Object.values(docs)
+        };
+      }
+    }
+    const snapshot = {
+      seq,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      collections
+    };
+    this.snapshots.set(seq, snapshot);
+    this.opCounter = 0;
+    if (this.snapshots.size > this.config.maxSnapshots) {
+      const oldest = Math.min(...this.snapshots.keys());
+      this.snapshots.delete(oldest);
+    }
+    if (this.config.debug) {
+      let totalDocs = 0;
+      for (const c of Object.values(collections)) totalDocs += c.count;
+      console.log(`[Snapshot] Created at seq=${seq}: ${totalDocs} docs across ${Object.keys(collections).length} collections`);
+    }
+    return snapshot;
+  }
+  /**
+   * Get the most recent snapshot at or before the given sequence number.
+   */
+  getSnapshotForSeq(seq) {
+    let best = null;
+    for (const [snapSeq, snap] of this.snapshots) {
+      if (snapSeq <= seq && (!best || snapSeq > best.seq)) {
+        best = snap;
+      }
+    }
+    return best;
+  }
+  /**
+   * Estimate bandwidth savings from using a snapshot vs full replay.
+   *
+   * @param totalOps - Total operations since seq 0
+   * @param snapshotSeq - Sequence number of the snapshot
+   * @returns Percentage of operations saved
+   */
+  estimateSavings(totalOps, snapshotSeq) {
+    return Math.round((1 - totalOps / (snapshotSeq || 1)) * 100);
+  }
+  /**
+   * Get all stored snapshots (for debugging/management).
+   */
+  getSnapshots() {
+    return Array.from(this.snapshots.values()).sort((a, b) => b.seq - a.seq);
+  }
+  /**
+   * Clear all snapshots (e.g., after schema change).
+   */
+  clear() {
+    this.snapshots.clear();
+    this.opCounter = 0;
+  }
+};
+
+// src/index.ts
+var import_meridian_shared5 = require("meridian-shared");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompactionManager,
+  MergeEngine,
+  MySQLStore,
+  PgStore,
+  SQLiteStore,
+  ServerPresenceManager,
+  SnapshotManager,
+  WsHub,
+  createServer,
+  createWALStream,
+  defineSchema,
+  z
+});