lakesync 0.1.8 → 0.2.0

package/dist/gateway-server.js

@@ -1,3 +1,9 @@
+import {
+  jiraPollerFactory
+} from "./chunk-ZNY4DSFU.js";
+import {
+  salesforcePollerFactory
+} from "./chunk-XVP5DJJ7.js";
 import {
   DEFAULT_MAX_BUFFER_AGE_MS,
   DEFAULT_MAX_BUFFER_BYTES,
@@ -15,12 +21,13 @@ import {
   handleSaveSchema,
   handleSaveSyncRules,
   handleUnregisterConnector
-} from "./chunk-JI4C4R5H.js";
+} from "./chunk-FIIHPQMQ.js";
 import {
   createDatabaseAdapter,
-  createQueryFn
-} from "./chunk-LPWXOYNS.js";
-import "./chunk-TMLG32QV.js";
+  createQueryFn,
+  defaultAdapterFactoryRegistry
+} from "./chunk-C4KD6YKP.js";
+import "./chunk-U2NV4DUX.js";
 import {
   TAG_SYNC_PULL,
   TAG_SYNC_PUSH,
@@ -28,18 +35,23 @@ import {
   decodeSyncPush,
   encodeBroadcastFrame,
   encodeSyncResponse
-} from "./chunk-KVSWLIJR.js";
-import "./chunk-SSICS5KI.js";
+} from "./chunk-YHYBLU6W.js";
+import "./chunk-ZU7RC7CT.js";
 import {
   AuthError,
+  Err,
   HLC,
+  Ok,
   bigintReplacer,
   bigintReviver,
+  createPoller,
+  createPollerRegistry,
   extractDelta,
   filterDeltas,
   isActionHandler,
+  isDatabaseAdapter,
   verifyToken
-} from "./chunk-LDFFCG2K.js";
+} from "./chunk-4SG66H5K.js";
 import {
   __require
 } from "./chunk-DGUM43GV.js";
@@ -158,6 +170,8 @@ var SourcePoller = class {
   cursorStates = /* @__PURE__ */ new Map();
   /** Diff snapshot per table (keyed by table name). */
   diffStates = /* @__PURE__ */ new Map();
+  /** Optional callback invoked after each poll with the current cursor state. */
+  onCursorUpdate;
   constructor(config, gateway) {
     this.config = config;
     this.gateway = gateway;
@@ -195,6 +209,22 @@ var SourcePoller = class {
       this.schedulePoll();
     }, this.config.intervalMs ?? DEFAULT_INTERVAL_MS);
   }
+  /** Export cursor state as a JSON-serialisable object for external persistence. */
+  getCursorState() {
+    const cursors = {};
+    for (const [table, state] of this.cursorStates) {
+      cursors[table] = state.lastCursor;
+    }
+    return { cursorStates: cursors };
+  }
+  /** Restore cursor state from a previously exported snapshot. */
+  setCursorState(state) {
+    const cursors = state.cursorStates;
+    if (!cursors) return;
+    for (const [table, cursor] of Object.entries(cursors)) {
+      this.cursorStates.set(table, { lastCursor: cursor });
+    }
+  }
   /** Execute a single poll cycle across all configured tables. */
   async poll() {
     const allDeltas = [];
@@ -204,13 +234,21 @@ var SourcePoller = class {
         allDeltas.push(d);
       }
     }
-    if (allDeltas.length === 0) return;
+    if (allDeltas.length === 0) {
+      if (this.onCursorUpdate) {
+        this.onCursorUpdate(this.getCursorState());
+      }
+      return;
+    }
     const push = {
       clientId: this.clientId,
       deltas: allDeltas,
       lastSeenHlc: 0n
     };
     this.gateway.handlePush(push);
+    if (this.onCursorUpdate) {
+      this.onCursorUpdate(this.getCursorState());
+    }
   }
   // -----------------------------------------------------------------------
   // Cursor strategy
@@ -321,17 +359,24 @@ var SourcePoller = class {
 
 // ../gateway-server/src/connector-manager.ts
 var ConnectorManager = class {
-  constructor(configStore, gateway) {
+  constructor(configStore, gateway, options) {
     this.configStore = configStore;
     this.gateway = gateway;
+    this.pollerRegistry = options?.pollerRegistry ?? createPollerRegistry();
+    this.adapterRegistry = options?.adapterRegistry ?? defaultAdapterFactoryRegistry();
+    this.persistence = options?.persistence ?? null;
   }
   adapters = /* @__PURE__ */ new Map();
   pollers = /* @__PURE__ */ new Map();
+  pollerRegistry;
+  adapterRegistry;
+  persistence;
   /**
    * Register a connector from raw JSON body.
    *
-   * Validates via shared handler, creates adapter/poller as appropriate,
-   * registers with the gateway.
+   * Validates via shared handler, then dispatches to the appropriate
+   * registry: poller registry for API-based connectors, adapter registry
+   * for database-based connectors.
    */
   async register(raw) {
     const result = await handleRegisterConnector(raw, this.configStore);
@@ -344,30 +389,19 @@ var ConnectorManager = class {
     if (!config) {
       return result;
     }
-    if (config.type === "jira") {
+    const pollerFactory = this.pollerRegistry.get(config.type);
+    if (pollerFactory) {
       try {
-        const { JiraSourcePoller } = await import("./src-ZRHKG42A.js");
-        const ingestConfig = config.ingest ? { intervalMs: config.ingest.intervalMs } : void 0;
-        const poller = new JiraSourcePoller(config.jira, ingestConfig, config.name, this.gateway);
-        poller.start();
-        this.pollers.set(config.name, poller);
-        return result;
-      } catch (err) {
-        await this.rollbackRegistration(connectors, registeredName);
-        const message = err instanceof Error ? err.message : String(err);
-        return { status: 500, body: { error: `Failed to load Jira connector: ${message}` } };
-      }
-    }
-    if (config.type === "salesforce") {
-      try {
-        const { SalesforceSourcePoller } = await import("./src-B6NLV3FP.js");
-        const ingestConfig = config.ingest ? { intervalMs: config.ingest.intervalMs } : void 0;
-        const poller = new SalesforceSourcePoller(
-          config.salesforce,
-          ingestConfig,
-          config.name,
-          this.gateway
-        );
+        const poller = createPoller(config, this.gateway, this.pollerRegistry);
+        if (this.persistence) {
+          const saved = this.persistence.loadCursor(config.name);
+          if (saved) {
+            poller.setCursorState(JSON.parse(saved));
+          }
+          poller.onCursorUpdate = (state) => {
+            this.persistence.saveCursor(config.name, JSON.stringify(state));
+          };
+        }
         poller.start();
         this.pollers.set(config.name, poller);
         return result;
@@ -376,11 +410,11 @@ var ConnectorManager = class {
         const message = err instanceof Error ? err.message : String(err);
         return {
           status: 500,
-          body: { error: `Failed to load Salesforce connector: ${message}` }
+          body: { error: `Failed to create poller for "${config.type}": ${message}` }
         };
       }
     }
-    const adapterResult = createDatabaseAdapter(config);
+    const adapterResult = createDatabaseAdapter(config, this.adapterRegistry);
     if (!adapterResult.ok) {
       await this.rollbackRegistration(connectors, registeredName);
       return { status: 500, body: { error: adapterResult.error.message } };
@@ -406,6 +440,15 @@ var ConnectorManager = class {
           intervalMs: config.ingest.intervalMs
         };
         const poller = new SourcePoller(pollerConfig, this.gateway);
+        if (this.persistence) {
+          const saved = this.persistence.loadCursor(config.name);
+          if (saved) {
+            poller.setCursorState(JSON.parse(saved));
+          }
+          poller.onCursorUpdate = (state) => {
+            this.persistence.saveCursor(config.name, JSON.stringify(state));
+          };
+        }
         poller.start();
         this.pollers.set(config.name, poller);
       }
@@ -498,9 +541,264 @@ function handlePreflight(method, res, corsH) {
   return true;
 }
 
+// ../gateway-server/src/logger.ts
+var LEVEL_VALUE = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class _Logger {
+  minLevelValue;
+  bindings;
+  /** Output function — defaults to stdout, overridable for testing. */
+  writeFn;
+  constructor(minLevel = "info", bindings = {}, writeFn) {
+    this.minLevelValue = LEVEL_VALUE[minLevel];
+    this.bindings = bindings;
+    this.writeFn = writeFn ?? ((line) => process.stdout.write(`${line}
+`));
+  }
+  /** Log at debug level. */
+  debug(msg, data) {
+    this.log("debug", msg, data);
+  }
+  /** Log at info level. */
+  info(msg, data) {
+    this.log("info", msg, data);
+  }
+  /** Log at warn level. */
+  warn(msg, data) {
+    this.log("warn", msg, data);
+  }
+  /** Log at error level. */
+  error(msg, data) {
+    this.log("error", msg, data);
+  }
+  /**
+   * Create a child logger with additional bound context.
+   *
+   * The child inherits the parent's level and write function, plus
+   * merges any parent bindings with the new ones.
+   */
+  child(bindings) {
+    return new _Logger(this.minLevelName(), { ...this.bindings, ...bindings }, this.writeFn);
+  }
+  // -----------------------------------------------------------------------
+  // Internal
+  // -----------------------------------------------------------------------
+  log(level, msg, data) {
+    if (LEVEL_VALUE[level] < this.minLevelValue) return;
+    const entry = {
+      level,
+      msg,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      ...this.bindings,
+      ...data
+    };
+    this.writeFn(JSON.stringify(entry));
+  }
+  minLevelName() {
+    for (const [name, val] of Object.entries(LEVEL_VALUE)) {
+      if (val === this.minLevelValue) return name;
+    }
+    return "info";
+  }
+};
+
+// ../gateway-server/src/metrics.ts
+var Counter = class {
+  constructor(name, help) {
+    this.name = name;
+    this.help = help;
+  }
+  values = /* @__PURE__ */ new Map();
+  /** Increment the counter by `n` (default 1). */
+  inc(labels = {}, n = 1) {
+    const key = labelKey(labels);
+    this.values.set(key, (this.values.get(key) ?? 0) + n);
+  }
+  /** Return the current value for the given labels. */
+  get(labels = {}) {
+    return this.values.get(labelKey(labels)) ?? 0;
+  }
+  /** Reset all values. */
+  reset() {
+    this.values.clear();
+  }
+  /** Serialise to Prometheus text exposition format. */
+  expose() {
+    const lines = [];
+    lines.push(`# HELP ${this.name} ${this.help}`);
+    lines.push(`# TYPE ${this.name} counter`);
+    for (const [key, val] of this.values) {
+      lines.push(`${this.name}${key} ${val}`);
+    }
+    return lines.join("\n");
+  }
+};
+var Gauge = class {
+  constructor(name, help) {
+    this.name = name;
+    this.help = help;
+  }
+  values = /* @__PURE__ */ new Map();
+  /** Set to an absolute value. */
+  set(labels = {}, value = 0) {
+    this.values.set(labelKey(labels), value);
+  }
+  /** Increment by `n` (default 1). */
+  inc(labels = {}, n = 1) {
+    const key = labelKey(labels);
+    this.values.set(key, (this.values.get(key) ?? 0) + n);
+  }
+  /** Decrement by `n` (default 1). */
+  dec(labels = {}, n = 1) {
+    const key = labelKey(labels);
+    this.values.set(key, (this.values.get(key) ?? 0) - n);
+  }
+  /** Return the current value for the given labels. */
+  get(labels = {}) {
+    return this.values.get(labelKey(labels)) ?? 0;
+  }
+  /** Reset all values. */
+  reset() {
+    this.values.clear();
+  }
+  /** Serialise to Prometheus text exposition format. */
+  expose() {
+    const lines = [];
+    lines.push(`# HELP ${this.name} ${this.help}`);
+    lines.push(`# TYPE ${this.name} gauge`);
+    for (const [key, val] of this.values) {
+      lines.push(`${this.name}${key} ${val}`);
+    }
+    return lines.join("\n");
+  }
+};
+var Histogram = class {
+  constructor(name, help, buckets) {
+    this.name = name;
+    this.help = help;
+    this.buckets = buckets;
+    this.buckets = [...buckets].sort((a, b) => a - b);
+  }
+  data = /* @__PURE__ */ new Map();
+  /** Record an observation. */
+  observe(labels = {}, value = 0) {
+    const key = labelKey(labels);
+    let bucket = this.data.get(key);
+    if (!bucket) {
+      bucket = {
+        bucketCounts: new Array(this.buckets.length + 1).fill(0),
+        sum: 0,
+        count: 0
+      };
+      this.data.set(key, bucket);
+    }
+    bucket.sum += value;
+    bucket.count += 1;
+    for (let i = 0; i < this.buckets.length; i++) {
+      if (value <= this.buckets[i]) {
+        bucket.bucketCounts[i]++;
+      }
+    }
+    bucket.bucketCounts[this.buckets.length]++;
+  }
+  /** Return the count of observations for the given labels. */
+  getCount(labels = {}) {
+    return this.data.get(labelKey(labels))?.count ?? 0;
+  }
+  /** Return the sum of observations for the given labels. */
+  getSum(labels = {}) {
+    return this.data.get(labelKey(labels))?.sum ?? 0;
+  }
+  /** Reset all values. */
+  reset() {
+    this.data.clear();
+  }
+  /** Serialise to Prometheus text exposition format. */
+  expose() {
+    const lines = [];
+    lines.push(`# HELP ${this.name} ${this.help}`);
+    lines.push(`# TYPE ${this.name} histogram`);
+    for (const [key, bucket] of this.data) {
+      const labelStr = key === "" ? "" : key;
+      const separator = labelStr === "" ? "{" : `${labelStr.slice(0, -1)},`;
+      const closeBrace = "}";
+      for (let i = 0; i < this.buckets.length; i++) {
+        const le = this.buckets[i];
+        lines.push(
+          `${this.name}_bucket${separator}le="${le}"${closeBrace} ${bucket.bucketCounts[i]}`
+        );
+      }
+      lines.push(
+        `${this.name}_bucket${separator}le="+Inf"${closeBrace} ${bucket.bucketCounts[this.buckets.length]}`
+      );
+      lines.push(`${this.name}_sum${labelStr} ${bucket.sum}`);
+      lines.push(`${this.name}_count${labelStr} ${bucket.count}`);
+    }
+    return lines.join("\n");
+  }
+};
+var MetricsRegistry = class {
+  pushTotal = new Counter("lakesync_push_total", "Total push requests");
+  pullTotal = new Counter("lakesync_pull_total", "Total pull requests");
+  flushTotal = new Counter("lakesync_flush_total", "Total flush operations");
+  flushDuration = new Histogram(
+    "lakesync_flush_duration_ms",
+    "Flush duration in milliseconds",
+    [10, 50, 100, 500, 1e3, 5e3]
+  );
+  pushLatency = new Histogram(
+    "lakesync_push_latency_ms",
+    "Push request latency in milliseconds",
+    [1, 5, 10, 50, 100, 500]
+  );
+  bufferBytes = new Gauge("lakesync_buffer_bytes", "Current buffer size in bytes");
+  bufferDeltas = new Gauge("lakesync_buffer_deltas", "Current number of buffered deltas");
+  wsConnections = new Gauge("lakesync_ws_connections", "Active WebSocket connections");
+  activeRequests = new Gauge("lakesync_active_requests", "In-flight HTTP requests");
+  /** Return the full Prometheus text exposition payload. */
+  expose() {
+    const sections = [
+      this.pushTotal.expose(),
+      this.pullTotal.expose(),
+      this.flushTotal.expose(),
+      this.flushDuration.expose(),
+      this.pushLatency.expose(),
+      this.bufferBytes.expose(),
+      this.bufferDeltas.expose(),
+      this.wsConnections.expose(),
+      this.activeRequests.expose()
+    ];
+    return `${sections.join("\n\n")}
+`;
+  }
+  /** Reset all metrics. */
+  reset() {
+    this.pushTotal.reset();
+    this.pullTotal.reset();
+    this.flushTotal.reset();
+    this.flushDuration.reset();
+    this.pushLatency.reset();
+    this.bufferBytes.reset();
+    this.bufferDeltas.reset();
+    this.wsConnections.reset();
+    this.activeRequests.reset();
+  }
+};
+function labelKey(labels) {
+  const entries = Object.entries(labels);
+  if (entries.length === 0) return "";
+  const parts = entries.map(([k, v]) => `${k}="${v}"`).join(",");
+  return `{${parts}}`;
+}
+
 // ../gateway-server/src/persistence.ts
 var MemoryPersistence = class {
   buffer = [];
+  cursors = /* @__PURE__ */ new Map();
   appendBatch(deltas) {
     this.buffer.push(...deltas);
   }
@@ -512,6 +810,13 @@ var MemoryPersistence = class {
   }
   close() {
     this.buffer = [];
+    this.cursors.clear();
+  }
+  saveCursor(connectorName, cursor) {
+    this.cursors.set(connectorName, cursor);
+  }
+  loadCursor(connectorName) {
+    return this.cursors.get(connectorName) ?? null;
   }
 };
 var SqlitePersistence = class {
@@ -523,6 +828,9 @@ var SqlitePersistence = class {
     this.db.exec(
       "CREATE TABLE IF NOT EXISTS unflushed_deltas (id INTEGER PRIMARY KEY AUTOINCREMENT, data TEXT NOT NULL)"
     );
+    this.db.exec(
+      "CREATE TABLE IF NOT EXISTS connector_cursors (name TEXT PRIMARY KEY, cursor TEXT NOT NULL)"
+    );
   }
   appendBatch(deltas) {
     const stmt = this.db.prepare("INSERT INTO unflushed_deltas (data) VALUES (?)");
@@ -540,11 +848,89 @@ var SqlitePersistence = class {
   clear() {
     this.db.exec("DELETE FROM unflushed_deltas");
   }
+  saveCursor(connectorName, cursor) {
+    this.db.prepare(
+      "INSERT INTO connector_cursors (name, cursor) VALUES (?, ?) ON CONFLICT(name) DO UPDATE SET cursor = excluded.cursor"
+    ).run(connectorName, cursor);
+  }
+  loadCursor(connectorName) {
+    const row = this.db.prepare("SELECT cursor FROM connector_cursors WHERE name = ?").get(connectorName);
+    return row?.cursor ?? null;
+  }
   close() {
     this.db.close();
   }
 };
 
+// ../gateway-server/src/rate-limiter.ts
+var DEFAULT_MAX_REQUESTS = 100;
+var DEFAULT_WINDOW_MS = 6e4;
+var CLEANUP_INTERVAL_MS = 6e4;
+var RateLimiter = class {
+  maxRequests;
+  windowMs;
+  clients = /* @__PURE__ */ new Map();
+  cleanupTimer = null;
+  constructor(config = {}) {
+    this.maxRequests = config.maxRequests ?? DEFAULT_MAX_REQUESTS;
+    this.windowMs = config.windowMs ?? DEFAULT_WINDOW_MS;
+    this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
+    if (this.cleanupTimer.unref) {
+      this.cleanupTimer.unref();
+    }
+  }
+  /**
+   * Attempt to consume one request token for the given client.
+   *
+   * @returns `true` if the request is allowed, `false` if rate-limited.
+   */
+  tryConsume(clientId) {
+    const now = Date.now();
+    const entry = this.clients.get(clientId);
+    if (!entry || now - entry.windowStart >= this.windowMs) {
+      this.clients.set(clientId, { count: 1, windowStart: now });
+      return true;
+    }
+    if (entry.count >= this.maxRequests) {
+      return false;
+    }
+    entry.count++;
+    return true;
+  }
+  /**
+   * Calculate the number of seconds until the current window resets
+   * for a given client. Used for the Retry-After header.
+   */
+  retryAfterSeconds(clientId) {
+    const entry = this.clients.get(clientId);
+    if (!entry) return 0;
+    const elapsed = Date.now() - entry.windowStart;
+    const remaining = Math.max(0, this.windowMs - elapsed);
+    return Math.ceil(remaining / 1e3);
+  }
+  /** Remove all tracked clients and reset state. */
+  reset() {
+    this.clients.clear();
+  }
+  /** Stop the periodic cleanup timer. */
+  dispose() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    this.clients.clear();
+  }
+  /** Remove stale entries whose window has expired. */
+  cleanup() {
+    const now = Date.now();
+    for (const [clientId, entry] of this.clients) {
+      if (now - entry.windowStart >= this.windowMs) {
+        this.clients.delete(clientId);
+      }
+    }
+  }
+};
+
 // ../gateway-server/src/router.ts
 var ROUTES = [
   ["POST", /^\/sync\/([^/]+)\/push$/, "push"],
@@ -579,19 +965,40 @@ import { createServer } from "http";
 
 // ../gateway-server/src/shared-buffer.ts
 var SharedBuffer = class {
-  constructor(sharedAdapter) {
+  constructor(sharedAdapter, config) {
     this.sharedAdapter = sharedAdapter;
+    this.consistencyMode = config?.consistencyMode ?? "eventual";
   }
+  consistencyMode;
   /**
    * Write-through push: write to shared adapter for cross-instance visibility.
    *
-   * Gateway buffer handles fast reads; shared adapter handles
-   * cross-instance visibility and durability.
+   * In "eventual" mode (default), failures are logged but do not fail the push.
+   * In "strong" mode, failures are returned as errors.
    */
   async writeThroughPush(deltas) {
     try {
-      await this.sharedAdapter.insertDeltas(deltas);
-    } catch {
+      const result = await this.sharedAdapter.insertDeltas(deltas);
+      if (!result.ok) {
+        if (this.consistencyMode === "strong") {
+          return Err({ code: "SHARED_WRITE_FAILED", message: result.error.message });
+        }
+        console.warn(
+          `[lakesync] Shared buffer write failed (eventual mode): ${result.error.message}`
+        );
+      }
+      return Ok(void 0);
+    } catch (error) {
+      if (this.consistencyMode === "strong") {
+        return Err({
+          code: "SHARED_WRITE_FAILED",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+      console.warn(
+        `[lakesync] Shared buffer write error (eventual mode): ${error instanceof Error ? error.message : String(error)}`
+      );
+      return Ok(void 0);
     }
   }
   /**
@@ -626,15 +1033,31 @@ var SharedBuffer = class {
 // ../gateway-server/src/ws-manager.ts
 import { WebSocketServer } from "ws";
 var WebSocketManager = class {
-  constructor(gateway, configStore, gatewayId, jwtSecret) {
+  constructor(gateway, configStore, gatewayId, jwtSecret, limits) {
     this.gateway = gateway;
     this.configStore = configStore;
     this.gatewayId = gatewayId;
     this.jwtSecret = jwtSecret;
     this.wss = new WebSocketServer({ noServer: true });
+    this.maxConnections = limits?.maxConnections ?? 1e3;
+    this.maxMessagesPerSecond = limits?.maxMessagesPerSecond ?? 50;
+    this.rateResetTimer = setInterval(() => {
+      this.messageRates.clear();
+    }, 1e3);
+    if (this.rateResetTimer.unref) {
+      this.rateResetTimer.unref();
+    }
   }
   wss;
   clients = /* @__PURE__ */ new Map();
+  maxConnections;
+  maxMessagesPerSecond;
+  messageRates = /* @__PURE__ */ new Map();
+  rateResetTimer = null;
+  /** The current number of connected clients. */
+  get connectionCount() {
+    return this.clients.size;
+  }
   /** Attach upgrade listener to an HTTP server. */
   attach(httpServer) {
     httpServer.on("upgrade", (req, socket, head) => {
@@ -650,6 +1073,11 @@ var WebSocketManager = class {
   }
   /** Close all connections and shut down the WebSocket server. */
   close() {
+    if (this.rateResetTimer) {
+      clearInterval(this.rateResetTimer);
+      this.rateResetTimer = null;
+    }
+    this.messageRates.clear();
     for (const ws of this.clients.keys()) {
       try {
         ws.close(1001, "Server shutting down");
@@ -663,6 +1091,11 @@ var WebSocketManager = class {
   // Upgrade handling
   // -----------------------------------------------------------------------
   async handleUpgrade(req, socket, head) {
+    if (this.clients.size >= this.maxConnections) {
+      socket.write("HTTP/1.1 503 Service Unavailable\r\n\r\n");
+      socket.destroy();
+      return;
+    }
     const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
     let token = extractBearerToken(req);
     if (!token) {
@@ -694,17 +1127,43 @@ var WebSocketManager = class {
       const claims = auth?.customClaims ?? {};
       this.clients.set(ws, { clientId, claims });
       ws.on("message", (data) => {
+        if (!this.checkMessageRate(ws)) {
+          ws.close(1008, "Rate limit exceeded");
+          return;
+        }
         void this.handleMessage(ws, data, clientId, claims);
       });
       ws.on("close", () => {
         this.clients.delete(ws);
+        this.messageRates.delete(ws);
       });
       ws.on("error", () => {
         this.clients.delete(ws);
+        this.messageRates.delete(ws);
       });
     });
   }
   // -----------------------------------------------------------------------
+  // Message rate limiting
+  // -----------------------------------------------------------------------
+  /**
+   * Check and increment the message rate for a client.
+   * @returns `true` if the message is allowed, `false` if rate-limited.
+   */
+  checkMessageRate(ws) {
+    const now = Date.now();
+    const entry = this.messageRates.get(ws);
+    if (!entry || now - entry.windowStart >= 1e3) {
+      this.messageRates.set(ws, { count: 1, windowStart: now });
+      return true;
+    }
+    if (entry.count >= this.maxMessagesPerSecond) {
+      return false;
+    }
+    entry.count++;
+    return true;
+  }
+  // -----------------------------------------------------------------------
   // Message handling
   // -----------------------------------------------------------------------
   async handleMessage(ws, data, clientId, claims) {
@@ -801,6 +1260,10 @@ var WebSocketManager = class {
 // ../gateway-server/src/server.ts
 var DEFAULT_PORT = 3e3;
 var DEFAULT_FLUSH_INTERVAL_MS = 3e4;
+var DEFAULT_DRAIN_TIMEOUT_MS = 1e4;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_FLUSH_TIMEOUT_MS = 6e4;
+var DEFAULT_ADAPTER_HEALTH_TIMEOUT_MS = 5e3;
 function readBody(req) {
   return new Promise((resolve, reject) => {
     const chunks = [];
@@ -830,11 +1293,20 @@ var GatewayServer = class {
   persistence;
   connectors;
   sharedBuffer;
+  rateLimiter;
+  logger;
+  metrics;
   httpServer = null;
   wsManager = null;
   flushTimer = null;
   resolvedPort = 0;
   pollers = [];
+  /** Whether the server is draining (rejecting new requests during shutdown). */
+  draining = false;
+  /** Number of in-flight requests currently being handled. */
+  activeRequests = 0;
+  /** Signal handler cleanup functions. */
+  signalCleanup = null;
   constructor(config) {
     this.config = {
       port: config.port ?? DEFAULT_PORT,
@@ -851,8 +1323,16 @@ var GatewayServer = class {
     );
     this.configStore = new MemoryConfigStore();
     this.persistence = config.persistence === "sqlite" ? new SqlitePersistence(config.sqlitePath ?? "./lakesync-buffer.sqlite") : new MemoryPersistence();
-    this.sharedBuffer = config.cluster ? new SharedBuffer(config.cluster.sharedAdapter) : null;
-    this.connectors = new ConnectorManager(this.configStore, this.gateway);
+    this.sharedBuffer = config.cluster ? new SharedBuffer(config.cluster.sharedAdapter, config.cluster.sharedBufferConfig) : null;
+    const pollerRegistry = config.pollerRegistry ?? createPollerRegistry().with("jira", jiraPollerFactory).with("salesforce", salesforcePollerFactory);
+    this.connectors = new ConnectorManager(this.configStore, this.gateway, {
+      pollerRegistry,
+      adapterRegistry: config.adapterRegistry,
+      persistence: this.persistence
+    });
+    this.rateLimiter = config.rateLimiter ? new RateLimiter(config.rateLimiter) : null;
+    this.logger = new Logger(config.logLevel ?? "info");
+    this.metrics = new MetricsRegistry();
   }
   /**
    * Start the HTTP server and periodic flush timer.
@@ -864,9 +1344,7 @@ var GatewayServer = class {
   async start() {
     const persisted = this.persistence.loadAll();
     if (persisted.length > 0) {
-      for (const delta of persisted) {
-        this.gateway.buffer.append(delta);
-      }
+      this.gateway.rehydrate(persisted);
       this.persistence.clear();
     }
     this.httpServer = createServer((req, res) => {
@@ -885,7 +1363,8 @@ var GatewayServer = class {
       this.gateway,
       this.configStore,
       this.config.gatewayId,
-      this.config.jwtSecret
+      this.config.jwtSecret,
+      this.config.wsLimits
     );
     this.wsManager.attach(this.httpServer);
     this.flushTimer = setInterval(() => {
@@ -894,13 +1373,25 @@ var GatewayServer = class {
     if (this.config.ingestSources) {
       for (const source of this.config.ingestSources) {
         const poller = new SourcePoller(source, this.gateway);
+        const saved = this.persistence.loadCursor(source.name);
+        if (saved) {
+          poller.setCursorState(JSON.parse(saved));
+        }
+        poller.onCursorUpdate = (state) => {
+          this.persistence.saveCursor(source.name, JSON.stringify(state));
+        };
         poller.start();
         this.pollers.push(poller);
       }
     }
+    this.setupSignalHandlers();
   }
   /** Stop the server, pollers, connectors, and WebSocket connections. */
   async stop() {
+    if (this.signalCleanup) {
+      this.signalCleanup();
+      this.signalCleanup = null;
+    }
     await this.connectors.stopAll();
     for (const poller of this.pollers) {
       poller.stop();
@@ -920,8 +1411,15 @@ var GatewayServer = class {
       });
       this.httpServer = null;
     }
+    if (this.rateLimiter) {
+      this.rateLimiter.dispose();
+    }
     this.persistence.close();
   }
+  /** Whether the server is currently draining connections. */
+  get isDraining() {
+    return this.draining;
+  }
   /** The port the server is listening on (available after start). */
   get port() {
     return this.resolvedPort || this.config.port;
@@ -930,6 +1428,10 @@ var GatewayServer = class {
   get gatewayInstance() {
     return this.gateway;
   }
+  /** The Prometheus metrics registry. */
+  get metricsRegistry() {
+    return this.metrics;
+  }
   // -----------------------------------------------------------------------
   // Request handling — cors -> auth -> route -> handler
   // -----------------------------------------------------------------------
@@ -939,17 +1441,56 @@ var GatewayServer = class {
     const url = new URL(rawUrl, `http://${req.headers.host ?? "localhost"}`);
     const pathname = url.pathname;
     const origin = req.headers.origin ?? null;
+    const requestId = crypto.randomUUID();
+    const reqLogger = this.logger.child({ requestId, method, path: pathname });
+    this.metrics.activeRequests.inc();
+    res.on("close", () => {
+      this.metrics.activeRequests.dec();
+    });
     const corsH = corsHeaders(origin, { allowedOrigins: this.config.allowedOrigins });
     if (handlePreflight(method, res, corsH)) return;
     if (pathname === "/health" && method === "GET") {
       sendJson(res, { status: "ok" }, 200, corsH);
       return;
     }
+    if (pathname === "/ready" && method === "GET") {
+      await this.handleReady(res, corsH);
+      return;
+    }
+    if (pathname === "/metrics" && method === "GET") {
+      this.updateBufferGauges();
+      const body = this.metrics.expose();
+      res.writeHead(200, {
+        "Content-Type": "text/plain; version=0.0.4; charset=utf-8",
+        ...corsH
+      });
+      res.end(body);
+      return;
+    }
     if (pathname === "/connectors/types" && method === "GET") {
       const result = handleListConnectorTypes();
       sendResult(res, result, corsH);
       return;
     }
+    if (this.draining) {
+      sendError(res, "Service is shutting down", 503, corsH);
+      return;
+    }
+    const timeoutMs = this.config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    res.setTimeout(timeoutMs, () => {
+      if (!res.writableEnded) {
+        sendError(res, "Request timeout", 504, corsH);
+      }
+    });
+    this.activeRequests++;
+    try {
+      await this.dispatchRoute(req, res, method, url, pathname, corsH, reqLogger);
+    } finally {
+      this.activeRequests--;
+    }
+  }
+  /** Dispatch an authenticated request to the correct route handler. */
+  async dispatchRoute(req, res, method, url, pathname, corsH, reqLogger) {
     const route = matchRoute(pathname, method);
     if (!route) {
       sendError(res, "Not found", 404, corsH);
@@ -970,12 +1511,23 @@ var GatewayServer = class {
       return;
     }
     const auth = this.config.jwtSecret ? authResult.claims : void 0;
+    if (this.rateLimiter) {
+      const clientKey = auth?.clientId ?? req.socket.remoteAddress ?? "unknown";
+      if (!this.rateLimiter.tryConsume(clientKey)) {
+        const retryAfter = this.rateLimiter.retryAfterSeconds(clientKey);
+        sendError(res, "Too many requests", 429, {
+          ...corsH,
+          "Retry-After": String(retryAfter)
+        });
+        return;
+      }
+    }
     switch (route.action) {
       case "push":
-        await this.handlePush(req, res, corsH, auth);
+        await this.handlePush(req, res, corsH, auth, reqLogger);
         break;
       case "pull":
-        await this.handlePull(url, res, corsH, auth);
+        await this.handlePull(url, res, corsH, auth, reqLogger);
         break;
       case "action":
         await this.handleAction(req, res, corsH, auth);
@@ -984,7 +1536,7 @@ var GatewayServer = class {
         this.handleDescribeActions(res, corsH);
         break;
       case "flush":
-        await this.handleFlush(res, corsH);
+        await this.handleFlush(res, corsH, reqLogger);
         break;
       case "schema":
         await this.handleSaveSchemaRoute(req, res, corsH);
@@ -1011,9 +1563,11 @@ var GatewayServer = class {
   // -----------------------------------------------------------------------
   // Route handlers — thin wrappers delegating to shared handlers or modules
   // -----------------------------------------------------------------------
-  async handlePush(req, res, corsH, auth) {
+  async handlePush(req, res, corsH, auth, reqLogger) {
+    const start = performance.now();
     const contentLength = Number(req.headers["content-length"] ?? "0");
     if (contentLength > MAX_PUSH_PAYLOAD_BYTES) {
+      this.metrics.pushTotal.inc({ status: "error" });
       sendError(res, "Payload too large (max 1 MiB)", 413, corsH);
       return;
     }
@@ -1026,12 +1580,23 @@ var GatewayServer = class {
     if (result.status === 200 && this.sharedBuffer) {
       const pushResult = result.body;
       if (pushResult.deltas.length > 0) {
-        await this.sharedBuffer.writeThroughPush(pushResult.deltas);
+        const writeResult = await this.sharedBuffer.writeThroughPush(pushResult.deltas);
+        if (!writeResult.ok) {
+          this.metrics.pushTotal.inc({ status: "error" });
+          sendError(res, writeResult.error.message, 502, corsH);
+          return;
+        }
       }
     }
+    const status = result.status === 200 ? "ok" : "error";
+    const durationMs = Math.round(performance.now() - start);
+    this.metrics.pushTotal.inc({ status });
+    this.metrics.pushLatency.observe({}, performance.now() - start);
+    this.updateBufferGauges();
+    reqLogger?.info("push completed", { status: result.status, durationMs });
     sendResult(res, result, corsH);
   }
-  async handlePull(url, res, corsH, auth) {
+  async handlePull(url, res, corsH, auth, reqLogger) {
     const syncRules = await this.configStore.getSyncRules(this.config.gatewayId);
     const result = await handlePullRequest(
       this.gateway,
@@ -1055,6 +1620,9 @@ var GatewayServer = class {
         }
       }
     }
+    const pullStatus = result.status === 200 ? "ok" : "error";
+    this.metrics.pullTotal.inc({ status: pullStatus });
+    reqLogger?.info("pull completed", { status: result.status });
     sendJson(res, body, result.status, corsH);
   }
   async handleAction(req, res, corsH, auth) {
@@ -1065,10 +1633,17 @@ var GatewayServer = class {
   handleDescribeActions(res, corsH) {
     sendJson(res, this.gateway.describeActions(), 200, corsH);
   }
-  async handleFlush(res, corsH) {
+  async handleFlush(res, corsH, reqLogger) {
+    const start = performance.now();
     const result = await handleFlushRequest(this.gateway, {
       clearPersistence: () => this.persistence.clear()
     });
+    const durationMs = Math.round(performance.now() - start);
+    const status = result.status === 200 ? "ok" : "error";
+    this.metrics.flushTotal.inc({ status });
+    this.metrics.flushDuration.observe({}, performance.now() - start);
+    this.updateBufferGauges();
+    reqLogger?.info("flush completed", { status: result.status, durationMs });
     sendResult(res, result, corsH);
   }
   async handleSaveSchemaRoute(req, res, corsH) {
@@ -1102,6 +1677,91 @@ var GatewayServer = class {
     sendResult(res, result, corsH);
   }
   // -----------------------------------------------------------------------
+  // Buffer gauge helpers
+  // -----------------------------------------------------------------------
+  /** Synchronise buffer gauge metrics with the current buffer state. */
+  updateBufferGauges() {
+    const stats = this.gateway.bufferStats;
+    this.metrics.bufferBytes.set({}, stats.byteSize);
+    this.metrics.bufferDeltas.set({}, stats.logSize);
+  }
+  // -----------------------------------------------------------------------
+  // Readiness probe
+  // -----------------------------------------------------------------------
+  /** Handle GET /ready — checks draining status and adapter health. */
+  async handleReady(res, corsH) {
+    if (this.draining) {
+      sendJson(res, { status: "not_ready", reason: "draining" }, 503, corsH);
+      return;
+    }
+    const adapterHealthy = await this.checkAdapterHealth();
+    if (!adapterHealthy) {
+      sendJson(res, { status: "not_ready", reason: "adapter unreachable" }, 503, corsH);
+      return;
+    }
+    sendJson(res, { status: "ready" }, 200, corsH);
+  }
+  /**
+   * Check whether the configured adapter is reachable.
+   *
+   * For a DatabaseAdapter, attempts a lightweight query with a timeout.
+   * For a LakeAdapter, attempts a headObject call (404 still means reachable).
+   * Returns true when no adapter is configured (stateless mode).
+   */
+  async checkAdapterHealth() {
+    const adapter = this.config.adapter;
+    if (!adapter) return true;
+    const timeoutMs = DEFAULT_ADAPTER_HEALTH_TIMEOUT_MS;
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => resolve(false), timeoutMs);
+    });
+    try {
+      if (isDatabaseAdapter(adapter)) {
+        const healthCheck2 = adapter.queryDeltasSince(0n, []).then((result) => result.ok);
+        return await Promise.race([healthCheck2, timeoutPromise]);
+      }
+      const healthCheck = adapter.headObject("__health__").then(() => true).catch(() => true);
+      return await Promise.race([healthCheck, timeoutPromise]);
+    } catch {
+      return false;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Graceful shutdown — signal handlers
+  // -----------------------------------------------------------------------
+  /** Register SIGTERM/SIGINT handlers for graceful shutdown. */
+  setupSignalHandlers() {
+    const shutdown = () => {
+      void this.gracefulShutdown();
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    this.signalCleanup = () => {
+      process.off("SIGTERM", shutdown);
+      process.off("SIGINT", shutdown);
+    };
+  }
+  /** Graceful shutdown: stop accepting, drain, flush, exit. */
+  async gracefulShutdown() {
+    if (this.draining) return;
+    this.draining = true;
+    this.logger.info("Graceful shutdown initiated, draining requests...");
+    if (this.httpServer) {
+      this.httpServer.close();
+    }
+    const drainTimeout = this.config.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
+    const start = Date.now();
+    while (this.activeRequests > 0 && Date.now() - start < drainTimeout) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    try {
+      await this.gateway.flush();
+    } catch {
+    }
+    await this.stop();
+    process.exit(0);
+  }
+  // -----------------------------------------------------------------------
   // Periodic flush
   // -----------------------------------------------------------------------
   async periodicFlush() {
@@ -1116,11 +1776,32 @@ var GatewayServer = class {
         return;
       }
     }
+    const flushTimeoutMs = this.config.flushTimeoutMs ?? DEFAULT_FLUSH_TIMEOUT_MS;
+    const start = performance.now();
     try {
-      const result = await this.gateway.flush();
+      const flushPromise = this.gateway.flush();
+      const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => resolve({ ok: false, timedOut: true }), flushTimeoutMs);
+      });
+      const result = await Promise.race([flushPromise, timeoutPromise]);
+      if ("timedOut" in result) {
+        this.logger.warn(`Periodic flush timed out after ${flushTimeoutMs}ms`);
+        this.metrics.flushTotal.inc({ status: "error" });
+        return;
+      }
       if (result.ok) {
         this.persistence.clear();
+        this.metrics.flushTotal.inc({ status: "ok" });
+      } else {
+        this.metrics.flushTotal.inc({ status: "error" });
       }
+      this.metrics.flushDuration.observe({}, performance.now() - start);
+      this.updateBufferGauges();
+    } catch (err) {
+      this.metrics.flushTotal.inc({ status: "error" });
+      this.logger.error("periodic flush failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
     } finally {
       if (lock) {
         await lock.release(lockKey);
@@ -1132,8 +1813,14 @@ export {
   AdapterBasedLock,
   AuthError,
   ConnectorManager,
+  Counter,
   GatewayServer,
+  Gauge,
+  Histogram,
+  Logger,
   MemoryPersistence,
+  MetricsRegistry,
+  RateLimiter,
   SharedBuffer,
   SourcePoller,
   SqlitePersistence,