lakesync 0.1.6 → 0.2.0

package/dist/{chunk-IRJ4QRWV.js → chunk-FIIHPQMQ.js}

@@ -1,18 +1,15 @@
-import {
-  isDatabaseAdapter,
-  isMaterialisable
-} from "./chunk-GUJWMK5P.js";
 import {
   buildPartitionSpec,
   lakeSyncTableName,
   tableSchemaToIceberg
-} from "./chunk-UAUQGP3B.js";
+} from "./chunk-U2NV4DUX.js";
 import {
   writeDeltasToParquet
-} from "./chunk-SF7Y6ZUA.js";
+} from "./chunk-ZU7RC7CT.js";
 import {
   AdapterNotFoundError,
   BackpressureError,
+  COLUMN_TYPES,
   Err,
   FlushError,
   HLC,
@@ -21,6 +18,8 @@ import {
   bigintReplacer,
   bigintReviver,
   filterDeltas,
+  isDatabaseAdapter,
+  isMaterialisable,
   listConnectorDescriptors,
   resolveLWW,
   rowKey,
@@ -28,19 +27,84 @@ import {
   validateAction,
   validateConnectorConfig,
   validateSyncRules
-} from "./chunk-P3FT7QCW.js";
+} from "./chunk-4SG66H5K.js";
+
+// ../gateway/src/idempotency-cache.ts
+var DEFAULT_MAX_CACHE_SIZE = 1e4;
+var DEFAULT_CACHE_TTL_MS = 5 * 60 * 1e3;
+var MemoryIdempotencyCache = class {
+  entries = /* @__PURE__ */ new Map();
+  maxSize;
+  ttlMs;
+  constructor(config) {
+    this.maxSize = config?.maxSize ?? DEFAULT_MAX_CACHE_SIZE;
+    this.ttlMs = config?.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+  }
+  /** {@inheritDoc IdempotencyCache.has} */
+  has(actionId) {
+    const entry = this.entries.get(actionId);
+    if (!entry) return false;
+    if (Date.now() - entry.cachedAt > this.ttlMs) {
+      this.entries.delete(actionId);
+      return false;
+    }
+    return true;
+  }
+  /** {@inheritDoc IdempotencyCache.get} */
+  get(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return void 0;
+    if (Date.now() - entry.cachedAt > this.ttlMs) {
+      this.entries.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  /** {@inheritDoc IdempotencyCache.set} */
+  set(actionId, result, idempotencyKey) {
+    this.evictStaleEntries();
+    const entry = { value: result, cachedAt: Date.now() };
+    this.entries.set(actionId, entry);
+    if (idempotencyKey) {
+      this.entries.set(`idem:${idempotencyKey}`, entry);
+    }
+  }
+  /** Evict expired entries and trim to max size (counting only non-idem entries). */
+  evictStaleEntries() {
+    const now = Date.now();
+    for (const [key, entry] of this.entries) {
+      if (now - entry.cachedAt > this.ttlMs) {
+        this.entries.delete(key);
+      }
+    }
+    const actionKeys = [...this.entries.keys()].filter((k) => !k.startsWith("idem:"));
+    if (actionKeys.length > this.maxSize) {
+      const excess = actionKeys.length - this.maxSize;
+      for (let i = 0; i < excess; i++) {
+        this.entries.delete(actionKeys[i]);
+      }
+    }
+  }
+};
 
 // ../gateway/src/action-dispatcher.ts
 var ActionDispatcher = class {
   actionHandlers = /* @__PURE__ */ new Map();
-  executedActions = /* @__PURE__ */ new Set();
-  idempotencyMap = /* @__PURE__ */ new Map();
-  constructor(handlers) {
+  cache;
+  /**
+   * Create an ActionDispatcher.
+   *
+   * @param handlers - Optional map of connector name to action handler.
+   * @param cacheConfig - Optional cache configuration (used when no `cache` is provided).
+   * @param cache - Optional pre-built idempotency cache; defaults to a {@link MemoryIdempotencyCache}.
+   */
+  constructor(handlers, cacheConfig, cache) {
     if (handlers) {
       for (const [name, handler] of Object.entries(handlers)) {
         this.actionHandlers.set(name, handler);
       }
     }
+    this.cache = cache ?? new MemoryIdempotencyCache(cacheConfig);
   }
   /**
    * Dispatch an action push to registered handlers.
@@ -61,8 +125,8 @@ var ActionDispatcher = class {
       if (!validation.ok) {
         return Err(validation.error);
       }
-      if (this.executedActions.has(action.actionId)) {
-        const cached = this.idempotencyMap.get(action.actionId);
+      if (this.cache.has(action.actionId)) {
+        const cached = this.cache.get(action.actionId);
         if (cached) {
           results.push(cached);
           continue;
@@ -70,7 +134,7 @@ var ActionDispatcher = class {
         continue;
       }
       if (action.idempotencyKey) {
-        const cached = this.idempotencyMap.get(`idem:${action.idempotencyKey}`);
+        const cached = this.cache.get(`idem:${action.idempotencyKey}`);
         if (cached) {
           results.push(cached);
           continue;
@@ -85,7 +149,7 @@ var ActionDispatcher = class {
           retryable: false
         };
         results.push(errorResult);
-        this.cacheActionResult(action, errorResult);
+        this.cache.set(action.actionId, errorResult, action.idempotencyKey);
         continue;
       }
       const supported = handler.supportedActions.some((d) => d.actionType === action.actionType);
@@ -97,13 +161,13 @@ var ActionDispatcher = class {
           retryable: false
         };
         results.push(errorResult);
-        this.cacheActionResult(action, errorResult);
+        this.cache.set(action.actionId, errorResult, action.idempotencyKey);
         continue;
       }
       const execResult = await handler.executeAction(action, context);
       if (execResult.ok) {
         results.push(execResult.value);
-        this.cacheActionResult(action, execResult.value);
+        this.cache.set(action.actionId, execResult.value, action.idempotencyKey);
       } else {
         const err = execResult.error;
         const errorResult = {
@@ -114,7 +178,7 @@ var ActionDispatcher = class {
         };
         results.push(errorResult);
         if (!errorResult.retryable) {
-          this.cacheActionResult(action, errorResult);
+          this.cache.set(action.actionId, errorResult, action.idempotencyKey);
         }
       }
     }
@@ -161,14 +225,6 @@ var ActionDispatcher = class {
     }
     return { connectors };
   }
-  /** Cache an action result for idempotency deduplication. */
-  cacheActionResult(action, result) {
-    this.executedActions.add(action.actionId);
-    this.idempotencyMap.set(action.actionId, result);
-    if (action.idempotencyKey) {
-      this.idempotencyMap.set(`idem:${action.idempotencyKey}`, result);
-    }
-  }
 };
 
 // ../gateway/src/buffer.ts
@@ -284,9 +340,18 @@ var DeltaBuffer = class {
     this.tableLog.delete(table);
     return tableDeltas;
   }
-  /** Drain the log for flush. Returns log entries and clears both structures. */
-  drain() {
-    const entries = [...this.log];
+  /**
+   * Snapshot the current buffer state without clearing it.
+   *
+   * Useful for inspecting the buffer contents without draining.
+   * Use {@link clear} separately after a successful flush for
+   * transactional semantics.
+   */
+  snapshot() {
+    return { entries: [...this.log], byteSize: this.estimatedBytes };
+  }
+  /** Clear all buffer state. */
+  clear() {
     this.log = [];
     this.index.clear();
     this.deltaIds.clear();
@@ -294,6 +359,11 @@ var DeltaBuffer = class {
     this.createdAt = Date.now();
     this.tableBytes.clear();
     this.tableLog.clear();
+  }
+  /** Drain the log for flush. Returns log entries and clears both structures. */
+  drain() {
+    const { entries } = this.snapshot();
+    this.clear();
     return entries;
   }
   /** Number of log entries */
@@ -344,7 +414,7 @@ var MAX_PUSH_PAYLOAD_BYTES = 1048576;
 var MAX_DELTAS_PER_PUSH = 1e4;
 var MAX_PULL_LIMIT = 1e4;
 var DEFAULT_PULL_LIMIT = 100;
-var VALID_COLUMN_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "json", "null"]);
+var VALID_COLUMN_TYPES = new Set(COLUMN_TYPES);
 var DEFAULT_MAX_BUFFER_BYTES = 4 * 1024 * 1024;
 var DEFAULT_MAX_BUFFER_AGE_MS = 3e4;
 
@@ -359,26 +429,39 @@ function hlcRange(entries) {
   }
   return { min, max };
 }
-async function flushEntries(entries, byteSize, deps, keyPrefix) {
-  if (isDatabaseAdapter(deps.adapter)) {
+function notifyMaterialisationFailure(entries, error, config) {
+  if (!config.onMaterialisationFailure) return;
+  const tables = new Set(entries.map((e) => e.table));
+  for (const table of tables) {
+    const count = entries.filter((e) => e.table === table).length;
+    config.onMaterialisationFailure(table, count, error);
+  }
+}
+var DatabaseFlushStrategy = class {
+  async flush(entries, _byteSize, deps) {
+    const adapter = deps.adapter;
     try {
-      const result = await deps.adapter.insertDeltas(entries);
+      const result = await adapter.insertDeltas(entries);
       if (!result.ok) {
         deps.restoreEntries(entries);
         return Err(new FlushError(`Database flush failed: ${result.error.message}`));
       }
-      if (deps.schemas && deps.schemas.length > 0 && isMaterialisable(deps.adapter)) {
+      if (deps.schemas && deps.schemas.length > 0 && isMaterialisable(adapter)) {
         try {
-          const matResult = await deps.adapter.materialise(entries, deps.schemas);
+          const matResult = await adapter.materialise(entries, deps.schemas);
           if (!matResult.ok) {
+            const error = new Error(matResult.error.message);
             console.warn(
               `[lakesync] Materialisation failed (${entries.length} deltas): ${matResult.error.message}`
             );
+            notifyMaterialisationFailure(entries, error, deps.config);
           }
         } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
           console.warn(
-            `[lakesync] Materialisation error (${entries.length} deltas): ${error instanceof Error ? error.message : String(error)}`
+            `[lakesync] Materialisation error (${entries.length} deltas): ${err.message}`
           );
+          notifyMaterialisationFailure(entries, err, deps.config);
         }
       }
       return Ok(void 0);
@@ -387,14 +470,14 @@ async function flushEntries(entries, byteSize, deps, keyPrefix) {
       return Err(new FlushError(`Unexpected database flush failure: ${toError(error).message}`));
     }
   }
-  try {
-    const { min, max } = hlcRange(entries);
-    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const prefix = keyPrefix ? `${keyPrefix}-` : "";
-    let objectKey;
-    let data;
-    let contentType;
-    if (deps.config.flushFormat === "json") {
+};
+var LakeJsonFlushStrategy = class {
+  async flush(entries, byteSize, deps, keyPrefix) {
+    const adapter = deps.adapter;
+    try {
+      const { min, max } = hlcRange(entries);
+      const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const prefix = keyPrefix ? `${keyPrefix}-` : "";
       const envelope = {
         version: 1,
         gatewayId: deps.config.gatewayId,
@@ -404,10 +487,33 @@ async function flushEntries(entries, byteSize, deps, keyPrefix) {
         byteSize,
         deltas: entries
       };
-      objectKey = `deltas/${date}/${deps.config.gatewayId}/${prefix}${min.toString()}-${max.toString()}.json`;
-      data = new TextEncoder().encode(JSON.stringify(envelope, bigintReplacer));
-      contentType = "application/json";
-    } else {
+      const objectKey = `deltas/${date}/${deps.config.gatewayId}/${prefix}${min.toString()}-${max.toString()}.json`;
+      const data = new TextEncoder().encode(JSON.stringify(envelope, bigintReplacer));
+      const result = await adapter.putObject(objectKey, data, "application/json");
+      if (!result.ok) {
+        deps.restoreEntries(entries);
+        return Err(new FlushError(`Failed to write flush envelope: ${result.error.message}`));
+      }
+      if (deps.config.catalogue && deps.config.tableSchema) {
+        await commitToCatalogue(
+          objectKey,
+          data.byteLength,
+          entries.length,
+          deps.config.catalogue,
+          deps.config.tableSchema
+        );
+      }
+      return Ok(void 0);
+    } catch (error) {
+      deps.restoreEntries(entries);
+      return Err(new FlushError(`Unexpected flush failure: ${toError(error).message}`));
+    }
+  }
+};
+var LakeParquetFlushStrategy = class {
+  async flush(entries, _byteSize, deps, keyPrefix) {
+    const adapter = deps.adapter;
+    try {
       if (!deps.config.tableSchema) {
         deps.restoreEntries(entries);
         return Err(new FlushError("tableSchema required for Parquet flush"));
@@ -417,29 +523,43 @@ async function flushEntries(entries, byteSize, deps, keyPrefix) {
         deps.restoreEntries(entries);
         return Err(parquetResult.error);
       }
-      objectKey = `deltas/${date}/${deps.config.gatewayId}/${prefix}${min.toString()}-${max.toString()}.parquet`;
-      data = parquetResult.value;
-      contentType = "application/vnd.apache.parquet";
-    }
-    const result = await deps.adapter.putObject(objectKey, data, contentType);
-    if (!result.ok) {
+      const { min, max } = hlcRange(entries);
+      const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const prefix = keyPrefix ? `${keyPrefix}-` : "";
+      const objectKey = `deltas/${date}/${deps.config.gatewayId}/${prefix}${min.toString()}-${max.toString()}.parquet`;
+      const data = parquetResult.value;
+      const result = await adapter.putObject(objectKey, data, "application/vnd.apache.parquet");
+      if (!result.ok) {
+        deps.restoreEntries(entries);
+        return Err(new FlushError(`Failed to write flush envelope: ${result.error.message}`));
+      }
+      if (deps.config.catalogue && deps.config.tableSchema) {
+        await commitToCatalogue(
+          objectKey,
+          data.byteLength,
+          entries.length,
+          deps.config.catalogue,
+          deps.config.tableSchema
+        );
+      }
+      return Ok(void 0);
+    } catch (error) {
       deps.restoreEntries(entries);
-      return Err(new FlushError(`Failed to write flush envelope: ${result.error.message}`));
+      return Err(new FlushError(`Unexpected flush failure: ${toError(error).message}`));
     }
-    if (deps.config.catalogue && deps.config.tableSchema) {
-      await commitToCatalogue(
-        objectKey,
-        data.byteLength,
-        entries.length,
-        deps.config.catalogue,
-        deps.config.tableSchema
-      );
-    }
-    return Ok(void 0);
-  } catch (error) {
-    deps.restoreEntries(entries);
-    return Err(new FlushError(`Unexpected flush failure: ${toError(error).message}`));
   }
+};
+var databaseStrategy = new DatabaseFlushStrategy();
+var lakeJsonStrategy = new LakeJsonFlushStrategy();
+var lakeParquetStrategy = new LakeParquetFlushStrategy();
+function selectFlushStrategy(adapter, format) {
+  if (isDatabaseAdapter(adapter)) return databaseStrategy;
+  if (format === "json") return lakeJsonStrategy;
+  return lakeParquetStrategy;
+}
+async function flushEntries(entries, byteSize, deps, keyPrefix) {
+  const strategy = selectFlushStrategy(deps.adapter, deps.config.flushFormat);
+  return strategy.flush(entries, byteSize, deps, keyPrefix);
 }
 async function commitToCatalogue(objectKey, fileSizeInBytes, recordCount, catalogue, schema) {
   const { namespace, name } = lakeSyncTableName(schema.table);
@@ -463,6 +583,117 @@ async function commitToCatalogue(objectKey, fileSizeInBytes, recordCount, catalo
   }
 }
 
+// ../gateway/src/flush-coordinator.ts
+var FlushCoordinator = class {
+  flushing = false;
+  /** Whether a flush is currently in progress. */
+  get isFlushing() {
+    return this.flushing;
+  }
+  /**
+   * Flush all entries from the buffer to the adapter.
+   *
+   * Drains the buffer first, then writes to the adapter. On failure,
+   * entries are restored to the buffer.
+   */
+  async flush(buffer, adapter, deps) {
+    if (this.flushing) {
+      return Err(new FlushError("Flush already in progress"));
+    }
+    if (buffer.logSize === 0) {
+      return Ok(void 0);
+    }
+    if (!adapter) {
+      return Err(new FlushError("No adapter configured"));
+    }
+    this.flushing = true;
+    const byteSize = isDatabaseAdapter(adapter) ? 0 : buffer.byteSize;
+    const entries = buffer.drain();
+    if (entries.length === 0) {
+      this.flushing = false;
+      return Ok(void 0);
+    }
+    try {
+      return await flushEntries(entries, byteSize, {
+        adapter,
+        config: deps.config,
+        restoreEntries: (e) => this.restoreEntries(buffer, e),
+        schemas: deps.schemas
+      });
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /**
+   * Flush a single table's deltas from the buffer.
+   *
+   * Drains only the specified table's deltas and flushes them,
+   * leaving other tables in the buffer.
+   */
+  async flushTable(table, buffer, adapter, deps) {
+    if (this.flushing) {
+      return Err(new FlushError("Flush already in progress"));
+    }
+    if (!adapter) {
+      return Err(new FlushError("No adapter configured"));
+    }
+    const entries = buffer.drainTable(table);
+    if (entries.length === 0) {
+      return Ok(void 0);
+    }
+    this.flushing = true;
+    try {
+      return await flushEntries(
+        entries,
+        0,
+        {
+          adapter,
+          config: deps.config,
+          restoreEntries: (e) => this.restoreEntries(buffer, e),
+          schemas: deps.schemas
+        },
+        table
+      );
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /** Restore drained entries back to the buffer for retry. */
+  restoreEntries(buffer, entries) {
+    for (const entry of entries) {
+      buffer.append(entry);
+    }
+  }
+};
+
+// ../gateway/src/source-registry.ts
+var SourceRegistry = class {
+  sources = /* @__PURE__ */ new Map();
+  constructor(initial) {
+    if (initial) {
+      for (const [name, adapter] of Object.entries(initial)) {
+        this.sources.set(name, adapter);
+      }
+    }
+  }
+  /** Register a named source adapter. */
+  register(name, adapter) {
+    this.sources.set(name, adapter);
+  }
+  /** Unregister a named source adapter. */
+  unregister(name) {
+    this.sources.delete(name);
+  }
+  /** Get a source adapter by name, or undefined if not registered. */
+  get(name) {
+    return this.sources.get(name);
+  }
+  /** List all registered source adapter names. */
+  list() {
+    return [...this.sources.keys()];
+  }
+};
+
 // ../gateway/src/gateway.ts
 var SyncGateway = class {
   hlc;
@@ -470,20 +701,20 @@ var SyncGateway = class {
   actions;
   config;
   adapter;
-  flushing = false;
+  sources;
+  flushCoordinator;
   constructor(config, adapter) {
     this.config = { sourceAdapters: {}, ...config };
     this.hlc = new HLC();
     this.buffer = new DeltaBuffer();
     this.adapter = this.config.adapter ?? adapter ?? null;
     this.actions = new ActionDispatcher(config.actionHandlers);
+    this.sources = new SourceRegistry(this.config.sourceAdapters);
+    this.flushCoordinator = new FlushCoordinator();
   }
-  /** Restore drained entries back to the buffer for retry. */
-  restoreEntries(entries) {
-    for (const entry of entries) {
-      this.buffer.append(entry);
-    }
-  }
+  // -----------------------------------------------------------------------
+  // Push — pipeline of validation steps then buffer append
+  // -----------------------------------------------------------------------
   /**
    * Handle an incoming push from a client.
    *
@@ -494,14 +725,8 @@ var SyncGateway = class {
    *          or a `ClockDriftError` if the client clock is too far ahead.
    */
   handlePush(msg) {
-    const backpressureLimit = this.config.maxBackpressureBytes ?? this.config.maxBufferBytes * 2;
-    if (this.buffer.byteSize >= backpressureLimit) {
-      return Err(
-        new BackpressureError(
-          `Buffer backpressure exceeded (${this.buffer.byteSize} >= ${backpressureLimit} bytes)`
-        )
-      );
-    }
+    const bpResult = this.checkBackpressure();
+    if (!bpResult.ok) return bpResult;
     let accepted = 0;
     const ingested = [];
     for (const delta of msg.deltas) {
@@ -536,6 +761,18 @@ var SyncGateway = class {
     const serverHlc = this.hlc.now();
     return Ok({ serverHlc, accepted, deltas: ingested });
   }
+  /** Check buffer backpressure. */
+  checkBackpressure() {
+    const backpressureLimit = this.config.maxBackpressureBytes ?? this.config.maxBufferBytes * 2;
+    if (this.buffer.byteSize >= backpressureLimit) {
+      return Err(
+        new BackpressureError(
+          `Buffer backpressure exceeded (${this.buffer.byteSize} >= ${backpressureLimit} bytes)`
+        )
+      );
+    }
+    return Ok(void 0);
+  }
   handlePull(msg, context) {
     if (msg.source) {
       return this.handleAdapterPull(msg, context);
@@ -580,7 +817,7 @@ var SyncGateway = class {
   }
   /** Pull from a named source adapter. */
   async handleAdapterPull(msg, context) {
-    const adapter = this.config.sourceAdapters?.[msg.source];
+    const adapter = this.sources.get(msg.source);
     if (!adapter) {
       return Err(new AdapterNotFoundError(`Source adapter "${msg.source}" not found`));
     }
@@ -598,7 +835,7 @@ var SyncGateway = class {
     return Ok({ deltas: sliced, serverHlc, hasMore });
   }
   // -----------------------------------------------------------------------
-  // Flush — delegates to flush module
+  // Flush — delegates to FlushCoordinator
   // -----------------------------------------------------------------------
   /**
    * Flush the buffer to the configured adapter.
@@ -611,55 +848,15 @@ var SyncGateway = class {
    * @returns A `Result` indicating success or a `FlushError`.
    */
   async flush() {
-    if (this.flushing) {
-      return Err(new FlushError("Flush already in progress"));
-    }
-    if (this.buffer.logSize === 0) {
-      return Ok(void 0);
-    }
-    if (!this.adapter) {
-      return Err(new FlushError("No adapter configured"));
-    }
-    this.flushing = true;
-    if (isDatabaseAdapter(this.adapter)) {
-      const entries2 = this.buffer.drain();
-      if (entries2.length === 0) {
-        this.flushing = false;
-        return Ok(void 0);
-      }
-      try {
-        return await flushEntries(entries2, 0, {
-          adapter: this.adapter,
-          config: {
-            gatewayId: this.config.gatewayId,
-            flushFormat: this.config.flushFormat,
-            tableSchema: this.config.tableSchema,
-            catalogue: this.config.catalogue
-          },
-          restoreEntries: (e) => this.restoreEntries(e),
-          schemas: this.config.schemas
-        });
-      } finally {
-        this.flushing = false;
-      }
-    }
-    const byteSize = this.buffer.byteSize;
-    const entries = this.buffer.drain();
-    try {
-      return await flushEntries(entries, byteSize, {
-        adapter: this.adapter,
-        config: {
-          gatewayId: this.config.gatewayId,
-          flushFormat: this.config.flushFormat,
-          tableSchema: this.config.tableSchema,
-          catalogue: this.config.catalogue
-        },
-        restoreEntries: (e) => this.restoreEntries(e),
-        schemas: this.config.schemas
-      });
-    } finally {
-      this.flushing = false;
-    }
+    return this.flushCoordinator.flush(this.buffer, this.adapter, {
+      config: {
+        gatewayId: this.config.gatewayId,
+        flushFormat: this.config.flushFormat,
+        tableSchema: this.config.tableSchema,
+        catalogue: this.config.catalogue
+      },
+      schemas: this.config.schemas
+    });
   }
   /**
    * Flush a single table's deltas from the buffer.
@@ -668,37 +865,15 @@ var SyncGateway = class {
    * leaving other tables in the buffer.
    */
   async flushTable(table) {
-    if (this.flushing) {
-      return Err(new FlushError("Flush already in progress"));
-    }
-    if (!this.adapter) {
-      return Err(new FlushError("No adapter configured"));
-    }
-    const entries = this.buffer.drainTable(table);
-    if (entries.length === 0) {
-      return Ok(void 0);
-    }
-    this.flushing = true;
-    try {
-      return await flushEntries(
-        entries,
-        0,
-        {
-          adapter: this.adapter,
-          config: {
-            gatewayId: this.config.gatewayId,
-            flushFormat: this.config.flushFormat,
-            tableSchema: this.config.tableSchema,
-            catalogue: this.config.catalogue
-          },
-          restoreEntries: (e) => this.restoreEntries(e),
-          schemas: this.config.schemas
-        },
-        table
-      );
-    } finally {
-      this.flushing = false;
-    }
+    return this.flushCoordinator.flushTable(table, this.buffer, this.adapter, {
+      config: {
+        gatewayId: this.config.gatewayId,
+        flushFormat: this.config.flushFormat,
+        tableSchema: this.config.tableSchema,
+        catalogue: this.config.catalogue
+      },
+      schemas: this.config.schemas
+    });
   }
   // -----------------------------------------------------------------------
   // Actions — delegates to ActionDispatcher
@@ -724,7 +899,7 @@ var SyncGateway = class {
     return this.actions.describe();
   }
   // -----------------------------------------------------------------------
-  // Source adapters
+  // Source adapters — delegates to SourceRegistry
   // -----------------------------------------------------------------------
   /**
    * Register a named source adapter for adapter-sourced pulls.
@@ -733,7 +908,7 @@ var SyncGateway = class {
    * @param adapter - The database adapter to register.
    */
   registerSource(name, adapter) {
-    this.config.sourceAdapters[name] = adapter;
+    this.sources.register(name, adapter);
   }
   /**
    * Unregister a named source adapter.
@@ -741,7 +916,7 @@ var SyncGateway = class {
    * @param name - The source name to remove.
    */
   unregisterSource(name) {
-    delete this.config.sourceAdapters[name];
+    this.sources.unregister(name);
   }
   /**
    * List all registered source adapter names.
@@ -749,7 +924,16 @@ var SyncGateway = class {
    * @returns Array of registered source adapter names.
    */
   listSources() {
-    return Object.keys(this.config.sourceAdapters);
+    return this.sources.list();
+  }
+  // -----------------------------------------------------------------------
+  // Rehydration — restore persisted deltas without push validation
+  // -----------------------------------------------------------------------
+  /** Rehydrate the buffer with persisted deltas (bypasses push validation). */
+  rehydrate(deltas) {
+    for (const delta of deltas) {
+      this.buffer.append(delta);
+    }
   }
   // -----------------------------------------------------------------------
   // Buffer queries
@@ -789,13 +973,17 @@ var SyncGateway = class {
 };
 
 // ../gateway/src/validation.ts
-function validatePushBody(raw, headerClientId) {
-  let body;
+function parseJson(raw, reviver) {
   try {
-    body = JSON.parse(raw, bigintReviver);
+    return Ok(JSON.parse(raw, reviver));
   } catch {
     return Err({ status: 400, message: "Invalid JSON body" });
   }
+}
+function validatePushBody(raw, headerClientId) {
+  const parsed = parseJson(raw, bigintReviver);
+  if (!parsed.ok) return parsed;
+  const body = parsed.value;
   if (!body.clientId || !Array.isArray(body.deltas)) {
     return Err({ status: 400, message: "Missing required fields: clientId, deltas" });
   }
@@ -840,12 +1028,9 @@ function parsePullParams(params) {
   return Ok(msg);
 }
 function validateActionBody(raw, headerClientId) {
-  let body;
-  try {
-    body = JSON.parse(raw, bigintReviver);
-  } catch {
-    return Err({ status: 400, message: "Invalid JSON body" });
-  }
+  const parsed = parseJson(raw, bigintReviver);
+  if (!parsed.ok) return parsed;
+  const body = parsed.value;
   if (!body.clientId || !Array.isArray(body.actions)) {
     return Err({ status: 400, message: "Missing required fields: clientId, actions" });
   }
@@ -858,12 +1043,9 @@ function validateActionBody(raw, headerClientId) {
   return Ok(body);
 }
 function validateSchemaBody(raw) {
-  let schema;
-  try {
-    schema = JSON.parse(raw);
-  } catch {
-    return Err({ status: 400, message: "Invalid JSON body" });
-  }
+  const parsed = parseJson(raw);
+  if (!parsed.ok) return parsed;
+  const schema = parsed.value;
   if (!schema.table || !Array.isArray(schema.columns)) {
     return Err({ status: 400, message: "Missing required fields: table, columns" });
   }
@@ -1000,12 +1182,11 @@ async function handleSaveSchema(raw, store, gatewayId) {
   return { status: 200, body: { saved: true } };
 }
 async function handleSaveSyncRules(raw, store, gatewayId) {
-  let config;
-  try {
-    config = JSON.parse(raw);
-  } catch {
-    return { status: 400, body: { error: "Invalid JSON body" } };
+  const parsed = parseJson(raw);
+  if (!parsed.ok) {
+    return { status: parsed.error.status, body: { error: parsed.error.message } };
   }
+  const config = parsed.value;
   const validation = validateSyncRules(config);
   if (!validation.ok) {
     return { status: 400, body: { error: validation.error.message } };
@@ -1014,12 +1195,11 @@ async function handleSaveSyncRules(raw, store, gatewayId) {
   return { status: 200, body: { saved: true } };
 }
 async function handleRegisterConnector(raw, store) {
-  let body;
-  try {
-    body = JSON.parse(raw);
-  } catch {
-    return { status: 400, body: { error: "Invalid JSON body" } };
+  const parsed = parseJson(raw);
+  if (!parsed.ok) {
+    return { status: parsed.error.status, body: { error: parsed.error.message } };
   }
+  const body = parsed.value;
   const validation = validateConnectorConfig(body);
   if (!validation.ok) {
     return { status: 400, body: { error: validation.error.message } };
@@ -1061,17 +1241,17 @@ function handleMetrics(gateway, extra) {
 
 // ../gateway/src/schema-manager.ts
 var SchemaManager = class {
-  currentSchema;
-  version;
-  allowedColumns;
+  state;
   constructor(schema, version) {
-    this.currentSchema = schema;
-    this.version = version ?? 1;
-    this.allowedColumns = new Set(schema.columns.map((c) => c.name));
+    this.state = {
+      schema,
+      version: version ?? 1,
+      allowedColumns: new Set(schema.columns.map((c) => c.name))
+    };
   }
   /** Get the current schema and version. */
   getSchema() {
-    return { schema: this.currentSchema, version: this.version };
+    return { schema: this.state.schema, version: this.state.version };
   }
   /**
    * Validate that a delta's columns are compatible with the current schema.
@@ -1084,10 +1264,10 @@ var SchemaManager = class {
       return Ok(void 0);
     }
     for (const col of delta.columns) {
-      if (!this.allowedColumns.has(col.column)) {
+      if (!this.state.allowedColumns.has(col.column)) {
         return Err(
           new SchemaError(
-            `Unknown column "${col.column}" in delta for table "${delta.table}". Schema version ${this.version} does not include this column.`
+            `Unknown column "${col.column}" in delta for table "${delta.table}". Schema version ${this.state.version} does not include this column.`
           )
         );
       }
@@ -1101,10 +1281,10 @@ var SchemaManager = class {
    * returns a SchemaError.
    */
   evolveSchema(newSchema) {
-    if (newSchema.table !== this.currentSchema.table) {
+    if (newSchema.table !== this.state.schema.table) {
       return Err(new SchemaError("Cannot evolve schema: table name mismatch"));
     }
-    const oldColumnMap = new Map(this.currentSchema.columns.map((c) => [c.name, c.type]));
+    const oldColumnMap = new Map(this.state.schema.columns.map((c) => [c.name, c.type]));
     const newColumnMap = new Map(newSchema.columns.map((c) => [c.name, c.type]));
     for (const [name] of oldColumnMap) {
       if (!newColumnMap.has(name)) {
@@ -1125,14 +1305,18 @@ var SchemaManager = class {
         );
       }
     }
-    this.currentSchema = newSchema;
-    this.version++;
-    this.allowedColumns = new Set(newSchema.columns.map((c) => c.name));
-    return Ok({ version: this.version });
+    const newVersion = this.state.version + 1;
+    this.state = {
+      schema: newSchema,
+      version: newVersion,
+      allowedColumns: new Set(newSchema.columns.map((c) => c.name))
+    };
+    return Ok({ version: newVersion });
   }
 };
 
 export {
+  MemoryIdempotencyCache,
   ActionDispatcher,
   DeltaBuffer,
   MemoryConfigStore,
@@ -1146,7 +1330,10 @@ export {
   hlcRange,
   flushEntries,
   commitToCatalogue,
+  FlushCoordinator,
+  SourceRegistry,
   SyncGateway,
+  parseJson,
   validatePushBody,
   parsePullParams,
   validateActionBody,
@@ -1166,4 +1353,4 @@ export {
   handleMetrics,
   SchemaManager
 };
-//# sourceMappingURL=chunk-IRJ4QRWV.js.map
+//# sourceMappingURL=chunk-FIIHPQMQ.js.map