@korajs/server 0.1.0

package/dist/index.js

@@ -0,0 +1,1161 @@
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
+
+// src/store/memory-server-store.ts
+import { generateUUIDv7 } from "@korajs/core";
+var MemoryServerStore = class {
+  nodeId;
+  operations = [];
+  operationIndex = /* @__PURE__ */ new Map();
+  versionVector = /* @__PURE__ */ new Map();
+  closed = false;
+  constructor(nodeId) {
+    this.nodeId = nodeId ?? generateUUIDv7();
+  }
+  getVersionVector() {
+    return new Map(this.versionVector);
+  }
+  getNodeId() {
+    return this.nodeId;
+  }
+  async applyRemoteOperation(op) {
+    this.assertOpen();
+    if (this.operationIndex.has(op.id)) {
+      return "duplicate";
+    }
+    this.operations.push(op);
+    this.operationIndex.set(op.id, op);
+    const currentSeq = this.versionVector.get(op.nodeId) ?? 0;
+    if (op.sequenceNumber > currentSeq) {
+      this.versionVector.set(op.nodeId, op.sequenceNumber);
+    }
+    return "applied";
+  }
+  async getOperationRange(nodeId, fromSeq, toSeq) {
+    this.assertOpen();
+    return this.operations.filter(
+      (op) => op.nodeId === nodeId && op.sequenceNumber >= fromSeq && op.sequenceNumber <= toSeq
+    ).sort((a, b) => a.sequenceNumber - b.sequenceNumber);
+  }
+  async getOperationCount() {
+    this.assertOpen();
+    return this.operations.length;
+  }
+  async close() {
+    this.closed = true;
+  }
+  // --- Testing helpers (not on interface) ---
+  /**
+   * Get all stored operations (for test assertions).
+   */
+  getAllOperations() {
+    return [...this.operations];
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new Error("MemoryServerStore is closed");
+    }
+  }
+};
+
+// src/store/postgres-server-store.ts
+import { generateUUIDv7 as generateUUIDv72 } from "@korajs/core";
+import { and, asc, between, count, eq, sql } from "drizzle-orm";
+
+// src/store/drizzle-pg-schema.ts
+import { index, integer, pgTable, text } from "drizzle-orm/pg-core";
+var pgOperations = pgTable(
+  "operations",
+  {
+    id: text("id").primaryKey(),
+    nodeId: text("node_id").notNull(),
+    type: text("type").notNull(),
+    collection: text("collection").notNull(),
+    recordId: text("record_id").notNull(),
+    data: text("data"),
+    // JSON-serialized, null for deletes
+    previousData: text("previous_data"),
+    // JSON-serialized, null for insert/delete
+    wallTime: integer("wall_time").notNull(),
+    logical: integer("logical").notNull(),
+    timestampNodeId: text("timestamp_node_id").notNull(),
+    sequenceNumber: integer("sequence_number").notNull(),
+    causalDeps: text("causal_deps").notNull().default("[]"),
+    // JSON array of op IDs
+    schemaVersion: integer("schema_version").notNull(),
+    receivedAt: integer("received_at").notNull()
+  },
+  (table) => ({
+    nodeSeqIdx: index("idx_pg_node_seq").on(table.nodeId, table.sequenceNumber),
+    collectionIdx: index("idx_pg_collection").on(table.collection),
+    receivedIdx: index("idx_pg_received").on(table.receivedAt)
+  })
+);
+var pgSyncState = pgTable("sync_state", {
+  nodeId: text("node_id").primaryKey(),
+  maxSequenceNumber: integer("max_sequence_number").notNull(),
+  lastSeenAt: integer("last_seen_at").notNull()
+});
+
+// src/store/postgres-server-store.ts
+var PostgresServerStore = class {
+  nodeId;
+  db;
+  versionVector = /* @__PURE__ */ new Map();
+  ready;
+  closed = false;
+  constructor(db, nodeId) {
+    this.db = db;
+    this.nodeId = nodeId ?? generateUUIDv72();
+    this.ready = this.initialize();
+  }
+  getVersionVector() {
+    this.assertOpen();
+    return new Map(this.versionVector);
+  }
+  getNodeId() {
+    return this.nodeId;
+  }
+  async applyRemoteOperation(op) {
+    this.assertOpen();
+    await this.ready;
+    const existing = await this.db.select({ id: pgOperations.id }).from(pgOperations).where(eq(pgOperations.id, op.id)).limit(1);
+    if (existing.length > 0) {
+      return "duplicate";
+    }
+    const now = Date.now();
+    const row = this.serializeOperation(op, now);
+    await this.db.transaction(async (tx) => {
+      await tx.insert(pgOperations).values(row).onConflictDoNothing({ target: pgOperations.id });
+      await tx.insert(pgSyncState).values({
+        nodeId: op.nodeId,
+        maxSequenceNumber: op.sequenceNumber,
+        lastSeenAt: now
+      }).onConflictDoUpdate({
+        target: pgSyncState.nodeId,
+        set: {
+          maxSequenceNumber: sql`GREATEST(${pgSyncState.maxSequenceNumber}, ${op.sequenceNumber})`,
+          lastSeenAt: sql`${now}`
+        }
+      });
+    });
+    const currentMax = this.versionVector.get(op.nodeId) ?? 0;
+    if (op.sequenceNumber > currentMax) {
+      this.versionVector.set(op.nodeId, op.sequenceNumber);
+    }
+    return "applied";
+  }
+  async getOperationRange(nodeId, fromSeq, toSeq) {
+    this.assertOpen();
+    await this.ready;
+    const rows = await this.db.select().from(pgOperations).where(
+      and(
+        eq(pgOperations.nodeId, nodeId),
+        between(pgOperations.sequenceNumber, fromSeq, toSeq)
+      )
+    ).orderBy(asc(pgOperations.sequenceNumber));
+    return rows.map((row) => this.deserializeOperation(row));
+  }
+  async getOperationCount() {
+    this.assertOpen();
+    await this.ready;
+    const result = await this.db.select({ value: count() }).from(pgOperations);
+    return result[0]?.value ?? 0;
+  }
+  async close() {
+    this.closed = true;
+  }
+  async initialize() {
+    await this.ensureTables();
+    const rows = await this.db.select({
+      nodeId: pgSyncState.nodeId,
+      maxSequenceNumber: pgSyncState.maxSequenceNumber
+    }).from(pgSyncState);
+    for (const row of rows) {
+      this.versionVector.set(row.nodeId, row.maxSequenceNumber);
+    }
+  }
+  /**
+   * Create tables if they don't exist.
+   * Uses raw SQL via Drizzle's sql template — standard DDL practice without drizzle-kit.
+   */
+  async ensureTables() {
+    await this.db.execute(sql`
+			CREATE TABLE IF NOT EXISTS operations (
+				id TEXT PRIMARY KEY,
+				node_id TEXT NOT NULL,
+				type TEXT NOT NULL,
+				collection TEXT NOT NULL,
+				record_id TEXT NOT NULL,
+				data TEXT,
+				previous_data TEXT,
+				wall_time INTEGER NOT NULL,
+				logical INTEGER NOT NULL,
+				timestamp_node_id TEXT NOT NULL,
+				sequence_number INTEGER NOT NULL,
+				causal_deps TEXT NOT NULL DEFAULT '[]',
+				schema_version INTEGER NOT NULL,
+				received_at INTEGER NOT NULL
+			)
+		`);
+    await this.db.execute(
+      sql`CREATE INDEX IF NOT EXISTS idx_node_seq ON operations (node_id, sequence_number)`
+    );
+    await this.db.execute(
+      sql`CREATE INDEX IF NOT EXISTS idx_collection ON operations (collection)`
+    );
+    await this.db.execute(
+      sql`CREATE INDEX IF NOT EXISTS idx_received ON operations (received_at)`
+    );
+    await this.db.execute(sql`
+			CREATE TABLE IF NOT EXISTS sync_state (
+				node_id TEXT PRIMARY KEY,
+				max_sequence_number INTEGER NOT NULL,
+				last_seen_at INTEGER NOT NULL
+			)
+		`);
+  }
+  serializeOperation(op, receivedAt) {
+    return {
+      id: op.id,
+      nodeId: op.nodeId,
+      type: op.type,
+      collection: op.collection,
+      recordId: op.recordId,
+      data: op.data !== null ? JSON.stringify(op.data) : null,
+      previousData: op.previousData !== null ? JSON.stringify(op.previousData) : null,
+      wallTime: op.timestamp.wallTime,
+      logical: op.timestamp.logical,
+      timestampNodeId: op.timestamp.nodeId,
+      sequenceNumber: op.sequenceNumber,
+      causalDeps: JSON.stringify(op.causalDeps),
+      schemaVersion: op.schemaVersion,
+      receivedAt
+    };
+  }
+  deserializeOperation(row) {
+    return {
+      id: row.id,
+      nodeId: row.nodeId,
+      type: row.type,
+      collection: row.collection,
+      recordId: row.recordId,
+      data: row.data !== null ? JSON.parse(row.data) : null,
+      previousData: row.previousData !== null ? JSON.parse(row.previousData) : null,
+      timestamp: {
+        wallTime: row.wallTime,
+        logical: row.logical,
+        nodeId: row.timestampNodeId
+      },
+      sequenceNumber: row.sequenceNumber,
+      causalDeps: JSON.parse(row.causalDeps),
+      schemaVersion: row.schemaVersion
+    };
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new Error("PostgresServerStore is closed");
+    }
+  }
+};
+async function createPostgresServerStore(options) {
+  const { postgresClient, drizzleFn } = await loadPostgresDeps();
+  const client = postgresClient(options.connectionString);
+  const db = drizzleFn(client);
+  return new PostgresServerStore(db, options.nodeId);
+}
+async function loadPostgresDeps() {
+  try {
+    const dynamicImport = new Function("specifier", "return import(specifier)");
+    const postgresMod = await dynamicImport("postgres");
+    const drizzleMod = await dynamicImport("drizzle-orm/postgres-js");
+    return {
+      postgresClient: postgresMod.default,
+      drizzleFn: drizzleMod.drizzle
+    };
+  } catch {
+    throw new Error(
+      'PostgreSQL backend requires the "postgres" package. Install it in your project dependencies.'
+    );
+  }
+}
+
+// src/store/sqlite-server-store.ts
+import { generateUUIDv7 as generateUUIDv73 } from "@korajs/core";
+import { and as and2, asc as asc2, between as between2, count as count2, eq as eq2, sql as sql2 } from "drizzle-orm";
+
+// src/store/drizzle-schema.ts
+import { index as index2, integer as integer2, sqliteTable, text as text2 } from "drizzle-orm/sqlite-core";
+var operations = sqliteTable(
+  "operations",
+  {
+    id: text2("id").primaryKey(),
+    nodeId: text2("node_id").notNull(),
+    type: text2("type").notNull(),
+    collection: text2("collection").notNull(),
+    recordId: text2("record_id").notNull(),
+    data: text2("data"),
+    // JSON-serialized, null for deletes
+    previousData: text2("previous_data"),
+    // JSON-serialized, null for insert/delete
+    wallTime: integer2("wall_time").notNull(),
+    logical: integer2("logical").notNull(),
+    timestampNodeId: text2("timestamp_node_id").notNull(),
+    sequenceNumber: integer2("sequence_number").notNull(),
+    causalDeps: text2("causal_deps").notNull().default("[]"),
+    // JSON array of op IDs
+    schemaVersion: integer2("schema_version").notNull(),
+    receivedAt: integer2("received_at").notNull()
+  },
+  (table) => ({
+    nodeSeqIdx: index2("idx_node_seq").on(table.nodeId, table.sequenceNumber),
+    collectionIdx: index2("idx_collection").on(table.collection),
+    receivedIdx: index2("idx_received").on(table.receivedAt)
+  })
+);
+var syncState = sqliteTable("sync_state", {
+  nodeId: text2("node_id").primaryKey(),
+  maxSequenceNumber: integer2("max_sequence_number").notNull(),
+  lastSeenAt: integer2("last_seen_at").notNull()
+});
+
+// src/store/sqlite-server-store.ts
+var SqliteServerStore = class {
+  nodeId;
+  db;
+  closed = false;
+  constructor(db, nodeId) {
+    this.db = db;
+    this.nodeId = nodeId ?? generateUUIDv73();
+    this.ensureTables();
+  }
+  getVersionVector() {
+    this.assertOpen();
+    const rows = this.db.select().from(syncState).all();
+    const vv = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      vv.set(row.nodeId, row.maxSequenceNumber);
+    }
+    return vv;
+  }
+  getNodeId() {
+    return this.nodeId;
+  }
+  async applyRemoteOperation(op) {
+    this.assertOpen();
+    const now = Date.now();
+    const row = this.serializeOperation(op, now);
+    const result = this.db.transaction((tx) => {
+      const insertResult = tx.insert(operations).values(row).onConflictDoNothing({ target: operations.id }).run();
+      if (insertResult.changes === 0) {
+        return "duplicate";
+      }
+      tx.insert(syncState).values({
+        nodeId: op.nodeId,
+        maxSequenceNumber: op.sequenceNumber,
+        lastSeenAt: now
+      }).onConflictDoUpdate({
+        target: syncState.nodeId,
+        set: {
+          maxSequenceNumber: sql2`MAX(${syncState.maxSequenceNumber}, ${op.sequenceNumber})`,
+          lastSeenAt: sql2`${now}`
+        }
+      }).run();
+      return "applied";
+    });
+    return result;
+  }
+  async getOperationRange(nodeId, fromSeq, toSeq) {
+    this.assertOpen();
+    const rows = this.db.select().from(operations).where(and2(eq2(operations.nodeId, nodeId), between2(operations.sequenceNumber, fromSeq, toSeq))).orderBy(asc2(operations.sequenceNumber)).all();
+    return rows.map((row) => this.deserializeOperation(row));
+  }
+  async getOperationCount() {
+    this.assertOpen();
+    const result = this.db.select({ value: count2() }).from(operations).all();
+    return result[0]?.value ?? 0;
+  }
+  async close() {
+    this.closed = true;
+  }
+  /**
+   * Create the operations and sync_state tables if they don't exist.
+   * Uses raw SQL via Drizzle's sql template — standard practice for DDL without drizzle-kit.
+   */
+  ensureTables() {
+    this.db.run(sql2`
+			CREATE TABLE IF NOT EXISTS operations (
+				id TEXT PRIMARY KEY,
+				node_id TEXT NOT NULL,
+				type TEXT NOT NULL,
+				collection TEXT NOT NULL,
+				record_id TEXT NOT NULL,
+				data TEXT,
+				previous_data TEXT,
+				wall_time INTEGER NOT NULL,
+				logical INTEGER NOT NULL,
+				timestamp_node_id TEXT NOT NULL,
+				sequence_number INTEGER NOT NULL,
+				causal_deps TEXT NOT NULL DEFAULT '[]',
+				schema_version INTEGER NOT NULL,
+				received_at INTEGER NOT NULL
+			)
+		`);
+    this.db.run(sql2`
+			CREATE INDEX IF NOT EXISTS idx_node_seq ON operations (node_id, sequence_number)
+		`);
+    this.db.run(sql2`
+			CREATE INDEX IF NOT EXISTS idx_collection ON operations (collection)
+		`);
+    this.db.run(sql2`
+			CREATE INDEX IF NOT EXISTS idx_received ON operations (received_at)
+		`);
+    this.db.run(sql2`
+			CREATE TABLE IF NOT EXISTS sync_state (
+				node_id TEXT PRIMARY KEY,
+				max_sequence_number INTEGER NOT NULL,
+				last_seen_at INTEGER NOT NULL
+			)
+		`);
+  }
+  serializeOperation(op, receivedAt) {
+    return {
+      id: op.id,
+      nodeId: op.nodeId,
+      type: op.type,
+      collection: op.collection,
+      recordId: op.recordId,
+      data: op.data !== null ? JSON.stringify(op.data) : null,
+      previousData: op.previousData !== null ? JSON.stringify(op.previousData) : null,
+      wallTime: op.timestamp.wallTime,
+      logical: op.timestamp.logical,
+      timestampNodeId: op.timestamp.nodeId,
+      sequenceNumber: op.sequenceNumber,
+      causalDeps: JSON.stringify(op.causalDeps),
+      schemaVersion: op.schemaVersion,
+      receivedAt
+    };
+  }
+  deserializeOperation(row) {
+    return {
+      id: row.id,
+      nodeId: row.nodeId,
+      type: row.type,
+      collection: row.collection,
+      recordId: row.recordId,
+      data: row.data !== null ? JSON.parse(row.data) : null,
+      previousData: row.previousData !== null ? JSON.parse(row.previousData) : null,
+      timestamp: {
+        wallTime: row.wallTime,
+        logical: row.logical,
+        nodeId: row.timestampNodeId
+      },
+      sequenceNumber: row.sequenceNumber,
+      causalDeps: JSON.parse(row.causalDeps),
+      schemaVersion: row.schemaVersion
+    };
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new Error("SqliteServerStore is closed");
+    }
+  }
+};
+function createSqliteServerStore(options) {
+  const Database = __require("better-sqlite3");
+  const { drizzle } = __require("drizzle-orm/better-sqlite3");
+  const filename = options.filename ?? ":memory:";
+  const sqlite = new Database(filename);
+  sqlite.pragma("journal_mode = WAL");
+  const db = drizzle(sqlite);
+  return new SqliteServerStore(db, options.nodeId);
+}
+
+// src/transport/http-server-transport.ts
+import { SyncError } from "@korajs/core";
+var HttpServerTransport = class {
+  serializer;
+  messageHandler = null;
+  closeHandler = null;
+  errorHandler = null;
+  connected = true;
+  nextSequence = 1;
+  queue = [];
+  constructor(serializer) {
+    this.serializer = serializer;
+  }
+  send(message) {
+    if (!this.connected) return;
+    const encoded = this.serializer.encode(message);
+    const isBinary = encoded instanceof Uint8Array;
+    this.queue.push({
+      etag: this.makeEtag(this.nextSequence++),
+      contentType: isBinary ? "application/x-protobuf" : "application/json",
+      payload: encoded
+    });
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onClose(handler) {
+    this.closeHandler = handler;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  close(code = 1e3, reason = "transport closed") {
+    if (!this.connected) return;
+    this.connected = false;
+    this.queue.length = 0;
+    this.closeHandler?.(code, reason);
+  }
+  receive(payload) {
+    if (!this.connected) {
+      throw new SyncError("HTTP server transport is closed");
+    }
+    try {
+      const message = this.serializer.decode(payload);
+      this.messageHandler?.(message);
+    } catch (error) {
+      this.errorHandler?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  poll(ifNoneMatch) {
+    if (!this.connected) {
+      return { status: 410 };
+    }
+    const next = this.queue[0];
+    if (!next) {
+      return { status: 204 };
+    }
+    if (ifNoneMatch && ifNoneMatch === next.etag) {
+      return {
+        status: 304,
+        headers: { etag: next.etag }
+      };
+    }
+    this.queue.shift();
+    return {
+      status: 200,
+      body: next.payload,
+      headers: {
+        "content-type": next.contentType,
+        etag: next.etag
+      }
+    };
+  }
+  makeEtag(sequence) {
+    return `W/"${sequence}"`;
+  }
+};
+
+// src/transport/ws-server-transport.ts
+import { SyncError as SyncError2 } from "@korajs/core";
+import { JsonMessageSerializer } from "@korajs/sync";
+var WS_OPEN = 1;
+var WsServerTransport = class {
+  ws;
+  serializer;
+  messageHandler = null;
+  closeHandler = null;
+  errorHandler = null;
+  constructor(ws, options) {
+    this.ws = ws;
+    this.serializer = options?.serializer ?? new JsonMessageSerializer();
+    this.setupListeners();
+  }
+  send(message) {
+    if (this.ws.readyState !== WS_OPEN) {
+      throw new SyncError2("Cannot send message: WebSocket is not open", {
+        readyState: this.ws.readyState,
+        messageType: message.type
+      });
+    }
+    const encoded = this.serializer.encode(message);
+    this.ws.send(encoded);
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onClose(handler) {
+    this.closeHandler = handler;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  isConnected() {
+    return this.ws.readyState === WS_OPEN;
+  }
+  close(code, reason) {
+    this.ws.close(code ?? 1e3, reason ?? "server closing");
+  }
+  setupListeners() {
+    this.ws.on("message", (data) => {
+      try {
+        if (typeof data !== "string" && !(data instanceof Uint8Array) && !(data instanceof ArrayBuffer)) {
+          throw new SyncError2("Unsupported WebSocket payload type", {
+            payloadType: typeof data
+          });
+        }
+        const decoded = this.serializer.decode(data);
+        this.messageHandler?.(decoded);
+      } catch (err) {
+        this.errorHandler?.(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+    this.ws.on("close", (code, reason) => {
+      this.closeHandler?.(Number(code) || 1006, String(reason || "connection closed"));
+    });
+    this.ws.on("error", (err) => {
+      this.errorHandler?.(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+};
+
+// src/session/client-session.ts
+import { generateUUIDv7 as generateUUIDv74 } from "@korajs/core";
+import { topologicalSort } from "@korajs/core/internal";
+import {
+  NegotiatedMessageSerializer,
+  versionVectorToWire,
+  wireToVersionVector
+} from "@korajs/sync";
+
+// src/scopes/server-scope-filter.ts
+function operationMatchesScopes(op, scopes) {
+  if (!scopes) return true;
+  const collectionScope = scopes[op.collection];
+  if (!collectionScope) return false;
+  const snapshot = buildSnapshot(op);
+  if (!snapshot) return false;
+  for (const [field, expected] of Object.entries(collectionScope)) {
+    if (snapshot[field] !== expected) {
+      return false;
+    }
+  }
+  return true;
+}
+function buildSnapshot(op) {
+  const previous = asRecord(op.previousData);
+  const next = asRecord(op.data);
+  if (!previous && !next) return null;
+  return {
+    ...previous ?? {},
+    ...next ?? {}
+  };
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+
+// src/session/client-session.ts
+var DEFAULT_BATCH_SIZE = 100;
+var DEFAULT_SCHEMA_VERSION = 1;
+var ClientSession = class {
+  state = "connected";
+  clientNodeId = null;
+  authContext = null;
+  sessionId;
+  transport;
+  store;
+  auth;
+  serializer;
+  emitter;
+  batchSize;
+  schemaVersion;
+  onRelay;
+  onClose;
+  constructor(options) {
+    this.sessionId = options.sessionId;
+    this.transport = options.transport;
+    this.store = options.store;
+    this.auth = options.auth ?? null;
+    this.serializer = options.serializer ?? new NegotiatedMessageSerializer("json");
+    this.emitter = options.emitter ?? null;
+    this.batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.schemaVersion = options.schemaVersion ?? DEFAULT_SCHEMA_VERSION;
+    this.onRelay = options.onRelay ?? null;
+    this.onClose = options.onClose ?? null;
+  }
+  /**
+   * Start handling messages from the client transport.
+   */
+  start() {
+    this.transport.onMessage((msg) => this.handleMessage(msg));
+    this.transport.onClose((_code, _reason) => this.handleTransportClose());
+    this.transport.onError((_err) => {
+      if (this.state !== "closed") {
+        this.handleTransportClose();
+      }
+    });
+  }
+  /**
+   * Relay operations from another session to this client.
+   * Only relays if the session is in streaming state and transport is connected.
+   */
+  relayOperations(operations2) {
+    if (this.state !== "streaming" || !this.transport.isConnected()) return;
+    if (operations2.length === 0) return;
+    const visibleOperations = operations2.filter(
+      (op) => operationMatchesScopes(op, this.authContext?.scopes)
+    );
+    if (visibleOperations.length === 0) return;
+    const serializedOps = visibleOperations.map((op) => this.serializer.encodeOperation(op));
+    const msg = {
+      type: "operation-batch",
+      messageId: generateUUIDv74(),
+      operations: serializedOps,
+      isFinal: true,
+      batchIndex: 0
+    };
+    this.transport.send(msg);
+  }
+  /**
+   * Close this session.
+   */
+  close(reason) {
+    if (this.state === "closed") return;
+    this.state = "closed";
+    if (this.transport.isConnected()) {
+      this.transport.close(1e3, reason ?? "session closed");
+    }
+    this.onClose?.(this.sessionId);
+  }
+  // --- Getters ---
+  getState() {
+    return this.state;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getClientNodeId() {
+    return this.clientNodeId;
+  }
+  getAuthContext() {
+    return this.authContext;
+  }
+  isStreaming() {
+    return this.state === "streaming";
+  }
+  // --- Private protocol handlers ---
+  handleMessage(message) {
+    switch (message.type) {
+      case "handshake":
+        this.handleHandshake(message);
+        break;
+      case "operation-batch":
+        this.handleOperationBatch(message);
+        break;
+      // Acknowledgments from clients are noted but no action needed on server
+      case "acknowledgment":
+        break;
+      case "error":
+        break;
+    }
+  }
+  async handleHandshake(msg) {
+    if (this.state !== "connected") {
+      this.sendError("DUPLICATE_HANDSHAKE", "Handshake already completed", false);
+      return;
+    }
+    this.clientNodeId = msg.nodeId;
+    if (this.auth) {
+      const token = msg.authToken ?? "";
+      const context = await this.auth.authenticate(token);
+      if (!context) {
+        this.sendError("AUTH_FAILED", "Authentication failed", false);
+        this.close("authentication failed");
+        return;
+      }
+      this.authContext = context;
+      this.state = "authenticated";
+    }
+    const serverVector = this.store.getVersionVector();
+    const selectedWireFormat = selectWireFormat(msg.supportedWireFormats);
+    this.setSerializerWireFormat(selectedWireFormat);
+    const response = {
+      type: "handshake-response",
+      messageId: generateUUIDv74(),
+      nodeId: this.store.getNodeId(),
+      versionVector: versionVectorToWire(serverVector),
+      schemaVersion: this.schemaVersion,
+      accepted: true,
+      selectedWireFormat
+    };
+    this.transport.send(response);
+    this.emitter?.emit({ type: "sync:connected", nodeId: msg.nodeId });
+    this.state = "syncing";
+    const clientVector = wireToVersionVector(msg.versionVector);
+    await this.sendDelta(clientVector);
+    this.state = "streaming";
+  }
+  async handleOperationBatch(msg) {
+    const operations2 = msg.operations.map((s) => this.serializer.decodeOperation(s));
+    const applied = [];
+    for (const op of operations2) {
+      if (!operationMatchesScopes(op, this.authContext?.scopes)) {
+        continue;
+      }
+      const result = await this.store.applyRemoteOperation(op);
+      if (result === "applied") {
+        applied.push(op);
+      }
+    }
+    if (operations2.length > 0) {
+      this.emitter?.emit({
+        type: "sync:received",
+        operations: operations2,
+        batchSize: operations2.length
+      });
+    }
+    const lastOp = operations2[operations2.length - 1];
+    const ack = {
+      type: "acknowledgment",
+      messageId: generateUUIDv74(),
+      acknowledgedMessageId: msg.messageId,
+      lastSequenceNumber: lastOp ? lastOp.sequenceNumber : 0
+    };
+    this.transport.send(ack);
+    if (applied.length > 0) {
+      this.onRelay?.(this.sessionId, applied);
+    }
+  }
+  async sendDelta(clientVector) {
+    const serverVector = this.store.getVersionVector();
+    const missing = [];
+    for (const [nodeId, serverSeq] of serverVector) {
+      const clientSeq = clientVector.get(nodeId) ?? 0;
+      if (serverSeq > clientSeq) {
+        const ops = await this.store.getOperationRange(nodeId, clientSeq + 1, serverSeq);
+        const visible = ops.filter((op) => operationMatchesScopes(op, this.authContext?.scopes));
+        missing.push(...visible);
+      }
+    }
+    if (missing.length === 0) {
+      const emptyBatch = {
+        type: "operation-batch",
+        messageId: generateUUIDv74(),
+        operations: [],
+        isFinal: true,
+        batchIndex: 0
+      };
+      this.transport.send(emptyBatch);
+      return;
+    }
+    const sorted = topologicalSort(missing);
+    const totalBatches = Math.ceil(sorted.length / this.batchSize);
+    for (let i = 0; i < totalBatches; i++) {
+      const start = i * this.batchSize;
+      const batchOps = sorted.slice(start, start + this.batchSize);
+      const serializedOps = batchOps.map((op) => this.serializer.encodeOperation(op));
+      const batchMsg = {
+        type: "operation-batch",
+        messageId: generateUUIDv74(),
+        operations: serializedOps,
+        isFinal: i === totalBatches - 1,
+        batchIndex: i
+      };
+      this.transport.send(batchMsg);
+      this.emitter?.emit({
+        type: "sync:sent",
+        operations: batchOps,
+        batchSize: batchOps.length
+      });
+    }
+  }
+  sendError(code, message, retriable) {
+    const errorMsg = {
+      type: "error",
+      messageId: generateUUIDv74(),
+      code,
+      message,
+      retriable
+    };
+    this.transport.send(errorMsg);
+  }
+  setSerializerWireFormat(format) {
+    if (typeof this.serializer.setWireFormat === "function") {
+      this.serializer.setWireFormat(format);
+    }
+  }
+  handleTransportClose() {
+    if (this.state === "closed") return;
+    this.state = "closed";
+    this.emitter?.emit({ type: "sync:disconnected", reason: "transport closed" });
+    this.onClose?.(this.sessionId);
+  }
+};
+function selectWireFormat(supportedWireFormats) {
+  if (supportedWireFormats?.includes("protobuf")) {
+    return "protobuf";
+  }
+  return "json";
+}
+
+// src/server/kora-sync-server.ts
+import { SyncError as SyncError4, generateUUIDv7 as generateUUIDv75 } from "@korajs/core";
+import { JsonMessageSerializer as JsonMessageSerializer2 } from "@korajs/sync";
+var DEFAULT_MAX_CONNECTIONS = 0;
+var DEFAULT_BATCH_SIZE2 = 100;
+var DEFAULT_SCHEMA_VERSION2 = 1;
+var DEFAULT_HOST = "0.0.0.0";
+var DEFAULT_PATH = "/";
+var KoraSyncServer = class {
+  store;
+  auth;
+  serializer;
+  emitter;
+  maxConnections;
+  batchSize;
+  schemaVersion;
+  port;
+  host;
+  path;
+  sessions = /* @__PURE__ */ new Map();
+  httpClients = /* @__PURE__ */ new Map();
+  httpSessionToClient = /* @__PURE__ */ new Map();
+  wsServer = null;
+  running = false;
+  constructor(config) {
+    this.store = config.store;
+    this.auth = config.auth ?? null;
+    this.serializer = config.serializer ?? new JsonMessageSerializer2();
+    this.emitter = config.emitter ?? null;
+    this.maxConnections = config.maxConnections ?? DEFAULT_MAX_CONNECTIONS;
+    this.batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE2;
+    this.schemaVersion = config.schemaVersion ?? DEFAULT_SCHEMA_VERSION2;
+    this.port = config.port;
+    this.host = config.host ?? DEFAULT_HOST;
+    this.path = config.path ?? DEFAULT_PATH;
+  }
+  /**
+   * Start the WebSocket server in standalone mode.
+   *
+   * @param wsServerImpl - Optional WebSocket server constructor for testing
+   */
+  async start(wsServerImpl) {
+    if (this.running) {
+      throw new SyncError4("Server is already running", { port: this.port });
+    }
+    if (!wsServerImpl && this.port === void 0) {
+      throw new SyncError4(
+        "Port is required for standalone mode. Provide port in config or use handleConnection() for attach mode.",
+        {}
+      );
+    }
+    if (wsServerImpl) {
+      this.wsServer = new wsServerImpl({
+        port: this.port,
+        host: this.host,
+        path: this.path
+      });
+    } else {
+      const { WebSocketServer } = await import("ws");
+      this.wsServer = new WebSocketServer({
+        port: this.port,
+        host: this.host,
+        path: this.path
+      });
+    }
+    this.wsServer.on("connection", (ws) => {
+      const transport = new WsServerTransport(
+        ws,
+        {
+          serializer: this.serializer
+        }
+      );
+      this.handleConnection(transport);
+    });
+    this.running = true;
+  }
+  /**
+   * Stop the server. Closes all sessions and the WebSocket server.
+   */
+  async stop() {
+    for (const session of this.sessions.values()) {
+      session.close("server shutting down");
+    }
+    this.sessions.clear();
+    this.httpClients.clear();
+    this.httpSessionToClient.clear();
+    if (this.wsServer) {
+      await new Promise((resolve) => {
+        this.wsServer?.close(() => resolve());
+      });
+      this.wsServer = null;
+    }
+    this.running = false;
+  }
+  /**
+   * Handle one HTTP sync request for a long-polling client.
+   *
+   * A stable `clientId` identifies the logical connection across requests.
+   */
+  async handleHttpRequest(request) {
+    if (!request.clientId || request.clientId.trim().length === 0) {
+      return { status: 400 };
+    }
+    const client = this.getOrCreateHttpClient(request.clientId);
+    if (request.method === "POST") {
+      if (request.body === void 0) {
+        return { status: 400 };
+      }
+      const payload = normalizeHttpBody(request.body, request.contentType);
+      client.transport.receive(payload);
+      return { status: 202 };
+    }
+    if (request.method === "GET") {
+      const polled = client.transport.poll(request.ifNoneMatch);
+      return {
+        status: polled.status,
+        body: polled.body,
+        headers: polled.headers
+      };
+    }
+    return {
+      status: 405,
+      headers: { allow: "GET, POST" }
+    };
+  }
+  /**
+   * Handle an incoming client connection (attach mode).
+   * Creates a new ClientSession for the transport.
+   *
+   * @param transport - The server transport for the new connection
+   * @returns The session ID
+   */
+  handleConnection(transport) {
+    if (this.maxConnections > 0 && this.sessions.size >= this.maxConnections) {
+      transport.send({
+        type: "error",
+        messageId: generateUUIDv75(),
+        code: "MAX_CONNECTIONS",
+        message: `Server has reached maximum connections (${this.maxConnections})`,
+        retriable: true
+      });
+      transport.close(4029, "max connections reached");
+      throw new SyncError4("Maximum connections reached", {
+        current: this.sessions.size,
+        max: this.maxConnections
+      });
+    }
+    const sessionId = generateUUIDv75();
+    const session = new ClientSession({
+      sessionId,
+      transport,
+      store: this.store,
+      auth: this.auth ?? void 0,
+      serializer: this.serializer,
+      emitter: this.emitter ?? void 0,
+      batchSize: this.batchSize,
+      schemaVersion: this.schemaVersion,
+      onRelay: (sourceSessionId, operations2) => {
+        this.handleRelay(sourceSessionId, operations2);
+      },
+      onClose: (sid) => {
+        this.handleSessionClose(sid);
+      }
+    });
+    this.sessions.set(sessionId, session);
+    session.start();
+    return sessionId;
+  }
+  /**
+   * Get the current server status.
+   */
+  async getStatus() {
+    return {
+      running: this.running,
+      connectedClients: this.sessions.size,
+      port: this.port ?? null,
+      totalOperations: await this.store.getOperationCount()
+    };
+  }
+  /**
+   * Get the number of currently connected clients.
+   */
+  getConnectionCount() {
+    return this.sessions.size;
+  }
+  // --- Private ---
+  handleRelay(sourceSessionId, operations2) {
+    for (const [sessionId, session] of this.sessions) {
+      if (sessionId === sourceSessionId) continue;
+      session.relayOperations(operations2);
+    }
+  }
+  handleSessionClose(sessionId) {
+    this.sessions.delete(sessionId);
+    const clientId = this.httpSessionToClient.get(sessionId);
+    if (clientId) {
+      this.httpSessionToClient.delete(sessionId);
+      this.httpClients.delete(clientId);
+    }
+  }
+  getOrCreateHttpClient(clientId) {
+    const existing = this.httpClients.get(clientId);
+    if (existing) {
+      return existing;
+    }
+    const transport = new HttpServerTransport(this.serializer);
+    const sessionId = this.handleConnection(transport);
+    const client = { sessionId, transport };
+    this.httpClients.set(clientId, client);
+    this.httpSessionToClient.set(sessionId, clientId);
+    return client;
+  }
+};
+function normalizeHttpBody(body, contentType) {
+  if (body instanceof Uint8Array) {
+    return body;
+  }
+  if (contentType?.includes("application/x-protobuf")) {
+    return new TextEncoder().encode(body);
+  }
+  return body;
+}
+
+// src/auth/no-auth.ts
+var NoAuthProvider = class {
+  async authenticate(_token) {
+    return { userId: "anonymous" };
+  }
+};
+
+// src/auth/token-auth.ts
+var TokenAuthProvider = class {
+  validate;
+  constructor(options) {
+    this.validate = options.validate;
+  }
+  async authenticate(token) {
+    return this.validate(token);
+  }
+};
+
+// src/server/create-server.ts
+function createKoraServer(config) {
+  return new KoraSyncServer(config);
+}
+export {
+  ClientSession,
+  HttpServerTransport,
+  KoraSyncServer,
+  MemoryServerStore,
+  NoAuthProvider,
+  PostgresServerStore,
+  SqliteServerStore,
+  TokenAuthProvider,
+  WsServerTransport,
+  createKoraServer,
+  createPostgresServerStore,
+  createSqliteServerStore
+};
+//# sourceMappingURL=index.js.map