lakesync 0.1.6 → 0.1.8

package/dist/{chunk-P3FT7QCW.js → chunk-LDFFCG2K.js}

@@ -387,88 +387,45 @@ var HLC = class _HLC {
   }
 };
 
-// ../core/src/base-poller.ts
-function isIngestTarget(target) {
-  return typeof target.flush === "function" && typeof target.shouldFlush === "function" && "bufferStats" in target;
-}
-var DEFAULT_CHUNK_SIZE = 500;
-var DEFAULT_FLUSH_THRESHOLD = 0.7;
-var BaseSourcePoller = class {
-  gateway;
-  hlc;
+// ../core/src/polling/chunked-pusher.ts
+var ChunkedPusher = class {
+  target;
   clientId;
-  intervalMs;
-  timer = null;
-  running = false;
   chunkSize;
-  memoryBudgetBytes;
-  flushThreshold;
+  pressure;
   pendingDeltas = [];
   constructor(config) {
-    this.gateway = config.gateway;
-    this.hlc = new HLC();
-    this.clientId = `ingest:${config.name}`;
-    this.intervalMs = config.intervalMs;
-    this.chunkSize = config.memory?.chunkSize ?? DEFAULT_CHUNK_SIZE;
-    this.memoryBudgetBytes = config.memory?.memoryBudgetBytes;
-    this.flushThreshold = config.memory?.flushThreshold ?? DEFAULT_FLUSH_THRESHOLD;
-  }
-  /** Start the polling loop. */
-  start() {
-    if (this.running) return;
-    this.running = true;
-    this.schedulePoll();
-  }
-  /** Stop the polling loop. */
-  stop() {
-    this.running = false;
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-  }
-  /** Whether the poller is currently running. */
-  get isRunning() {
-    return this.running;
-  }
-  /**
-   * Execute a single poll cycle without the timer loop.
-   * Convenience for serverless consumers who trigger polls manually.
-   */
-  async pollOnce() {
-    return this.poll();
-  }
-  /** Push collected deltas to the gateway (single-shot, backward compat). */
-  pushDeltas(deltas) {
-    if (deltas.length === 0) return;
-    const push = {
-      clientId: this.clientId,
-      deltas,
-      lastSeenHlc: 0n
-    };
-    this.gateway.handlePush(push);
+    this.target = config.target;
+    this.clientId = config.clientId;
+    this.chunkSize = config.chunkSize;
+    this.pressure = config.pressure;
   }
   /**
    * Accumulate a single delta. When `chunkSize` is reached, the pending
    * deltas are automatically pushed (and flushed if needed).
    */
-  async accumulateDelta(delta) {
+  async accumulate(delta) {
     this.pendingDeltas.push(delta);
     if (this.pendingDeltas.length >= this.chunkSize) {
       await this.pushPendingChunk();
     }
   }
-  /** Flush any remaining accumulated deltas. Call at the end of `poll()`. */
-  async flushAccumulator() {
+  /** Flush any remaining accumulated deltas. */
+  async flush() {
     if (this.pendingDeltas.length > 0) {
       await this.pushPendingChunk();
     }
   }
-  /**
-   * Push a chunk of pending deltas. If the gateway is an IngestTarget,
-   * checks memory pressure and flushes before/after push when needed.
-   * On backpressure, flushes once and retries.
-   */
+  /** Push deltas directly (single-shot, backward compat). */
+  pushImmediate(deltas) {
+    if (deltas.length === 0) return;
+    const push = {
+      clientId: this.clientId,
+      deltas,
+      lastSeenHlc: 0n
+    };
+    this.target.handlePush(push);
+  }
   async pushPendingChunk() {
     const chunk = this.pendingDeltas;
     this.pendingDeltas = [];
@@ -476,45 +433,162 @@ var BaseSourcePoller = class {
   }
   async pushChunkWithFlush(chunk) {
     if (chunk.length === 0) return;
-    const target = this.gateway;
-    if (isIngestTarget(target)) {
-      if (this.shouldFlushTarget(target)) {
-        await target.flush();
-      }
+    if (this.pressure) {
+      await this.pressure.checkAndFlush();
     }
     const push = {
       clientId: this.clientId,
       deltas: chunk,
       lastSeenHlc: 0n
     };
-    const result = target.handlePush(push);
+    const result = this.target.handlePush(push);
     if (result && typeof result === "object" && "ok" in result && !result.ok) {
-      if (isIngestTarget(target)) {
-        await target.flush();
-        target.handlePush(push);
+      if (this.pressure) {
+        await this.pressure.forceFlush();
+        this.target.handlePush(push);
       }
     }
   }
-  shouldFlushTarget(target) {
-    if (target.shouldFlush()) return true;
+};
+
+// ../core/src/polling/pressure-manager.ts
+var PressureManager = class {
+  target;
+  memoryBudgetBytes;
+  flushThreshold;
+  constructor(config) {
+    this.target = config.target;
+    this.memoryBudgetBytes = config.memoryBudgetBytes;
+    this.flushThreshold = config.flushThreshold ?? 0.7;
+  }
+  /** Check buffer pressure and flush if thresholds are exceeded. */
+  async checkAndFlush() {
+    if (this.shouldFlush()) {
+      await this.target.flush();
+    }
+  }
+  /** Force a flush regardless of current pressure. */
+  async forceFlush() {
+    await this.target.flush();
+  }
+  shouldFlush() {
+    if (this.target.shouldFlush()) return true;
     if (this.memoryBudgetBytes != null) {
       const threshold = Math.floor(this.memoryBudgetBytes * this.flushThreshold);
-      if (target.bufferStats.byteSize >= threshold) return true;
+      if (this.target.bufferStats.byteSize >= threshold) return true;
     }
     return false;
   }
-  schedulePoll() {
+};
+
+// ../core/src/polling/scheduler.ts
+var PollingScheduler = class {
+  pollFn;
+  intervalMs;
+  timer = null;
+  running = false;
+  constructor(pollFn, intervalMs) {
+    this.pollFn = pollFn;
+    this.intervalMs = intervalMs;
+  }
+  /** Start the polling loop. No-op if already running. */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.schedule();
+  }
+  /** Stop the polling loop. */
+  stop() {
+    this.running = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  /** Whether the scheduler is currently running. */
+  get isRunning() {
+    return this.running;
+  }
+  /** Execute a single poll cycle without the timer loop. */
+  async pollOnce() {
+    return this.pollFn();
+  }
+  schedule() {
     if (!this.running) return;
     this.timer = setTimeout(async () => {
       try {
-        await this.poll();
+        await this.pollFn();
       } catch {
       }
-      this.schedulePoll();
+      this.schedule();
     }, this.intervalMs);
   }
 };
 
+// ../core/src/base-poller.ts
+function isIngestTarget(target) {
+  return typeof target.flush === "function" && typeof target.shouldFlush === "function" && "bufferStats" in target;
+}
+var DEFAULT_CHUNK_SIZE = 500;
+var BaseSourcePoller = class {
+  gateway;
+  hlc;
+  clientId;
+  scheduler;
+  pusher;
+  constructor(config) {
+    this.gateway = config.gateway;
+    this.hlc = new HLC();
+    this.clientId = `ingest:${config.name}`;
+    const pressure = isIngestTarget(config.gateway) ? new PressureManager({
+      target: config.gateway,
+      memoryBudgetBytes: config.memory?.memoryBudgetBytes,
+      flushThreshold: config.memory?.flushThreshold
+    }) : null;
+    this.pusher = new ChunkedPusher({
+      target: config.gateway,
+      clientId: this.clientId,
+      chunkSize: config.memory?.chunkSize ?? DEFAULT_CHUNK_SIZE,
+      pressure
+    });
+    this.scheduler = new PollingScheduler(() => this.poll(), config.intervalMs);
+  }
+  /** Start the polling loop. */
+  start() {
+    this.scheduler.start();
+  }
+  /** Stop the polling loop. */
+  stop() {
+    this.scheduler.stop();
+  }
+  /** Whether the poller is currently running. */
+  get isRunning() {
+    return this.scheduler.isRunning;
+  }
+  /**
+   * Execute a single poll cycle without the timer loop.
+   * Convenience for serverless consumers who trigger polls manually.
+   */
+  async pollOnce() {
+    return this.scheduler.pollOnce();
+  }
+  /** Push collected deltas to the gateway (single-shot, backward compat). */
+  pushDeltas(deltas) {
+    this.pusher.pushImmediate(deltas);
+  }
+  /**
+   * Accumulate a single delta. When `chunkSize` is reached, the pending
+   * deltas are automatically pushed (and flushed if needed).
+   */
+  async accumulateDelta(delta) {
+    await this.pusher.accumulate(delta);
+  }
+  /** Flush any remaining accumulated deltas. Call at the end of `poll()`. */
+  async flushAccumulator() {
+    await this.pusher.flush();
+  }
+};
+
 // ../core/src/callback-push-target.ts
 var CallbackPushTarget = class {
   onPush;
@@ -621,6 +695,35 @@ var ConnectorValidationError = class extends LakeSyncError {
 };
 
 // ../core/src/connector/registry.ts
+function createConnectorRegistry(descriptors2) {
+  const map = /* @__PURE__ */ new Map();
+  for (const d of descriptors2) {
+    map.set(d.type, d);
+  }
+  return buildRegistry(map);
+}
+function buildRegistry(map) {
+  return {
+    get(type) {
+      return map.get(type);
+    },
+    list() {
+      return [...map.values()].sort((a, b) => a.type.localeCompare(b.type));
+    },
+    with(descriptor) {
+      const next = new Map(map);
+      next.set(descriptor.type, descriptor);
+      return buildRegistry(next);
+    },
+    withOutputSchemas(type, schemas) {
+      const existing = map.get(type);
+      if (!existing) return buildRegistry(map);
+      const next = new Map(map);
+      next.set(type, { ...existing, outputTables: schemas });
+      return buildRegistry(next);
+    }
+  };
+}
 var descriptors = /* @__PURE__ */ new Map();
 function registerConnectorDescriptor(descriptor) {
   descriptors.set(descriptor.type, descriptor);
@@ -642,6 +745,162 @@ var CONNECTOR_TYPES = ["postgres", "mysql", "bigquery", "jira", "salesforce"];
 
 // ../core/src/connector/validate.ts
 var VALID_STRATEGIES = /* @__PURE__ */ new Set(["cursor", "diff"]);
+function validatePostgresConfig(obj) {
+  const pg = obj.postgres;
+  if (typeof pg !== "object" || pg === null) {
+    return Err(
+      new ConnectorValidationError('Connector type "postgres" requires a postgres config object')
+    );
+  }
+  const pgObj = pg;
+  if (typeof pgObj.connectionString !== "string" || pgObj.connectionString.length === 0) {
+    return Err(
+      new ConnectorValidationError("Postgres connector requires a non-empty connectionString")
+    );
+  }
+  return Ok(void 0);
+}
+function validateMySQLConfig(obj) {
+  const my = obj.mysql;
+  if (typeof my !== "object" || my === null) {
+    return Err(
+      new ConnectorValidationError('Connector type "mysql" requires a mysql config object')
+    );
+  }
+  const myObj = my;
+  if (typeof myObj.connectionString !== "string" || myObj.connectionString.length === 0) {
+    return Err(
+      new ConnectorValidationError("MySQL connector requires a non-empty connectionString")
+    );
+  }
+  return Ok(void 0);
+}
+function validateBigQueryConfig(obj) {
+  const bq = obj.bigquery;
+  if (typeof bq !== "object" || bq === null) {
+    return Err(
+      new ConnectorValidationError('Connector type "bigquery" requires a bigquery config object')
+    );
+  }
+  const bqObj = bq;
+  if (typeof bqObj.projectId !== "string" || bqObj.projectId.length === 0) {
+    return Err(new ConnectorValidationError("BigQuery connector requires a non-empty projectId"));
+  }
+  if (typeof bqObj.dataset !== "string" || bqObj.dataset.length === 0) {
+    return Err(new ConnectorValidationError("BigQuery connector requires a non-empty dataset"));
+  }
+  return Ok(void 0);
+}
+function validateJiraConfig(obj) {
+  const jira = obj.jira;
+  if (typeof jira !== "object" || jira === null) {
+    return Err(new ConnectorValidationError('Connector type "jira" requires a jira config object'));
+  }
+  const jiraObj = jira;
+  if (typeof jiraObj.domain !== "string" || jiraObj.domain.length === 0) {
+    return Err(new ConnectorValidationError("Jira connector requires a non-empty domain"));
+  }
+  if (typeof jiraObj.email !== "string" || jiraObj.email.length === 0) {
+    return Err(new ConnectorValidationError("Jira connector requires a non-empty email"));
+  }
+  if (typeof jiraObj.apiToken !== "string" || jiraObj.apiToken.length === 0) {
+    return Err(new ConnectorValidationError("Jira connector requires a non-empty apiToken"));
+  }
+  return Ok(void 0);
+}
+function validateSalesforceConfig(obj) {
+  const sf = obj.salesforce;
+  if (typeof sf !== "object" || sf === null) {
+    return Err(
+      new ConnectorValidationError(
+        'Connector type "salesforce" requires a salesforce config object'
+      )
+    );
+  }
+  const sfObj = sf;
+  if (typeof sfObj.instanceUrl !== "string" || sfObj.instanceUrl.length === 0) {
+    return Err(
+      new ConnectorValidationError("Salesforce connector requires a non-empty instanceUrl")
+    );
+  }
+  if (typeof sfObj.clientId !== "string" || sfObj.clientId.length === 0) {
+    return Err(new ConnectorValidationError("Salesforce connector requires a non-empty clientId"));
+  }
+  if (typeof sfObj.clientSecret !== "string" || sfObj.clientSecret.length === 0) {
+    return Err(
+      new ConnectorValidationError("Salesforce connector requires a non-empty clientSecret")
+    );
+  }
+  if (typeof sfObj.username !== "string" || sfObj.username.length === 0) {
+    return Err(new ConnectorValidationError("Salesforce connector requires a non-empty username"));
+  }
+  if (typeof sfObj.password !== "string" || sfObj.password.length === 0) {
+    return Err(new ConnectorValidationError("Salesforce connector requires a non-empty password"));
+  }
+  return Ok(void 0);
+}
+function validateIngestConfig(obj, connectorType) {
+  if (obj.ingest === void 0) return Ok(void 0);
+  if (typeof obj.ingest !== "object" || obj.ingest === null) {
+    return Err(new ConnectorValidationError("Ingest config must be an object"));
+  }
+  const ingest = obj.ingest;
+  if (connectorType === "jira" || connectorType === "salesforce") {
+    if (ingest.intervalMs !== void 0) {
+      if (typeof ingest.intervalMs !== "number" || ingest.intervalMs < 1) {
+        return Err(new ConnectorValidationError("Ingest intervalMs must be a positive number"));
+      }
+    }
+    return Ok(void 0);
+  }
+  if (!Array.isArray(ingest.tables) || ingest.tables.length === 0) {
+    return Err(new ConnectorValidationError("Ingest config must have a non-empty tables array"));
+  }
+  for (let i = 0; i < ingest.tables.length; i++) {
+    const table = ingest.tables[i];
+    if (typeof table !== "object" || table === null) {
+      return Err(new ConnectorValidationError(`Ingest table at index ${i} must be an object`));
+    }
+    if (typeof table.table !== "string" || table.table.length === 0) {
+      return Err(
+        new ConnectorValidationError(`Ingest table at index ${i} must have a non-empty table name`)
+      );
+    }
+    if (typeof table.query !== "string" || table.query.length === 0) {
+      return Err(
+        new ConnectorValidationError(`Ingest table at index ${i} must have a non-empty query`)
+      );
+    }
+    if (typeof table.strategy !== "object" || table.strategy === null) {
+      return Err(
+        new ConnectorValidationError(`Ingest table at index ${i} must have a strategy object`)
+      );
+    }
+    const strategy = table.strategy;
+    if (!VALID_STRATEGIES.has(strategy.type)) {
+      return Err(
+        new ConnectorValidationError(
+          `Ingest table at index ${i} strategy type must be "cursor" or "diff"`
+        )
+      );
+    }
+    if (strategy.type === "cursor") {
+      if (typeof strategy.cursorColumn !== "string" || strategy.cursorColumn.length === 0) {
+        return Err(
+          new ConnectorValidationError(
+            `Ingest table at index ${i} cursor strategy requires a non-empty cursorColumn`
+          )
+        );
+      }
+    }
+  }
+  if (ingest.intervalMs !== void 0) {
+    if (typeof ingest.intervalMs !== "number" || ingest.intervalMs < 1) {
+      return Err(new ConnectorValidationError("Ingest intervalMs must be a positive number"));
+    }
+  }
+  return Ok(void 0);
+}
 function validateConnectorConfig(input) {
   if (typeof input !== "object" || input === null) {
     return Err(new ConnectorValidationError("Connector config must be an object"));
@@ -656,178 +915,27 @@ function validateConnectorConfig(input) {
     );
   }
   const connectorType = obj.type;
+  let typeResult;
   switch (connectorType) {
-    case "postgres": {
-      const pg = obj.postgres;
-      if (typeof pg !== "object" || pg === null) {
-        return Err(
-          new ConnectorValidationError(
-            'Connector type "postgres" requires a postgres config object'
-          )
-        );
-      }
-      const pgObj = pg;
-      if (typeof pgObj.connectionString !== "string" || pgObj.connectionString.length === 0) {
-        return Err(
-          new ConnectorValidationError("Postgres connector requires a non-empty connectionString")
-        );
-      }
+    case "postgres":
+      typeResult = validatePostgresConfig(obj);
       break;
-    }
-    case "mysql": {
-      const my = obj.mysql;
-      if (typeof my !== "object" || my === null) {
-        return Err(
-          new ConnectorValidationError('Connector type "mysql" requires a mysql config object')
-        );
-      }
-      const myObj = my;
-      if (typeof myObj.connectionString !== "string" || myObj.connectionString.length === 0) {
-        return Err(
-          new ConnectorValidationError("MySQL connector requires a non-empty connectionString")
-        );
-      }
+    case "mysql":
+      typeResult = validateMySQLConfig(obj);
       break;
-    }
-    case "bigquery": {
-      const bq = obj.bigquery;
-      if (typeof bq !== "object" || bq === null) {
-        return Err(
-          new ConnectorValidationError(
-            'Connector type "bigquery" requires a bigquery config object'
-          )
-        );
-      }
-      const bqObj = bq;
-      if (typeof bqObj.projectId !== "string" || bqObj.projectId.length === 0) {
-        return Err(
-          new ConnectorValidationError("BigQuery connector requires a non-empty projectId")
-        );
-      }
-      if (typeof bqObj.dataset !== "string" || bqObj.dataset.length === 0) {
-        return Err(new ConnectorValidationError("BigQuery connector requires a non-empty dataset"));
-      }
+    case "bigquery":
+      typeResult = validateBigQueryConfig(obj);
       break;
-    }
-    case "jira": {
-      const jira = obj.jira;
-      if (typeof jira !== "object" || jira === null) {
-        return Err(
-          new ConnectorValidationError('Connector type "jira" requires a jira config object')
-        );
-      }
-      const jiraObj = jira;
-      if (typeof jiraObj.domain !== "string" || jiraObj.domain.length === 0) {
-        return Err(new ConnectorValidationError("Jira connector requires a non-empty domain"));
-      }
-      if (typeof jiraObj.email !== "string" || jiraObj.email.length === 0) {
-        return Err(new ConnectorValidationError("Jira connector requires a non-empty email"));
-      }
-      if (typeof jiraObj.apiToken !== "string" || jiraObj.apiToken.length === 0) {
-        return Err(new ConnectorValidationError("Jira connector requires a non-empty apiToken"));
-      }
+    case "jira":
+      typeResult = validateJiraConfig(obj);
       break;
-    }
-    case "salesforce": {
-      const sf = obj.salesforce;
-      if (typeof sf !== "object" || sf === null) {
-        return Err(
-          new ConnectorValidationError(
-            'Connector type "salesforce" requires a salesforce config object'
-          )
-        );
-      }
-      const sfObj = sf;
-      if (typeof sfObj.instanceUrl !== "string" || sfObj.instanceUrl.length === 0) {
-        return Err(
-          new ConnectorValidationError("Salesforce connector requires a non-empty instanceUrl")
-        );
-      }
-      if (typeof sfObj.clientId !== "string" || sfObj.clientId.length === 0) {
-        return Err(
-          new ConnectorValidationError("Salesforce connector requires a non-empty clientId")
-        );
-      }
-      if (typeof sfObj.clientSecret !== "string" || sfObj.clientSecret.length === 0) {
-        return Err(
-          new ConnectorValidationError("Salesforce connector requires a non-empty clientSecret")
-        );
-      }
-      if (typeof sfObj.username !== "string" || sfObj.username.length === 0) {
-        return Err(
-          new ConnectorValidationError("Salesforce connector requires a non-empty username")
-        );
-      }
-      if (typeof sfObj.password !== "string" || sfObj.password.length === 0) {
-        return Err(
-          new ConnectorValidationError("Salesforce connector requires a non-empty password")
-        );
-      }
+    case "salesforce":
+      typeResult = validateSalesforceConfig(obj);
       break;
-    }
-  }
-  if (obj.ingest !== void 0) {
-    if (typeof obj.ingest !== "object" || obj.ingest === null) {
-      return Err(new ConnectorValidationError("Ingest config must be an object"));
-    }
-    const ingest = obj.ingest;
-    if (connectorType === "jira" || connectorType === "salesforce") {
-      if (ingest.intervalMs !== void 0) {
-        if (typeof ingest.intervalMs !== "number" || ingest.intervalMs < 1) {
-          return Err(new ConnectorValidationError("Ingest intervalMs must be a positive number"));
-        }
-      }
-      return Ok(input);
-    }
-    if (!Array.isArray(ingest.tables) || ingest.tables.length === 0) {
-      return Err(new ConnectorValidationError("Ingest config must have a non-empty tables array"));
-    }
-    for (let i = 0; i < ingest.tables.length; i++) {
-      const table = ingest.tables[i];
-      if (typeof table !== "object" || table === null) {
-        return Err(new ConnectorValidationError(`Ingest table at index ${i} must be an object`));
-      }
-      if (typeof table.table !== "string" || table.table.length === 0) {
-        return Err(
-          new ConnectorValidationError(
-            `Ingest table at index ${i} must have a non-empty table name`
-          )
-        );
-      }
-      if (typeof table.query !== "string" || table.query.length === 0) {
-        return Err(
-          new ConnectorValidationError(`Ingest table at index ${i} must have a non-empty query`)
-        );
-      }
-      if (typeof table.strategy !== "object" || table.strategy === null) {
-        return Err(
-          new ConnectorValidationError(`Ingest table at index ${i} must have a strategy object`)
-        );
-      }
-      const strategy = table.strategy;
-      if (!VALID_STRATEGIES.has(strategy.type)) {
-        return Err(
-          new ConnectorValidationError(
-            `Ingest table at index ${i} strategy type must be "cursor" or "diff"`
-          )
-        );
-      }
-      if (strategy.type === "cursor") {
-        if (typeof strategy.cursorColumn !== "string" || strategy.cursorColumn.length === 0) {
-          return Err(
-            new ConnectorValidationError(
-              `Ingest table at index ${i} cursor strategy requires a non-empty cursorColumn`
-            )
-          );
-        }
-      }
-    }
-    if (ingest.intervalMs !== void 0) {
-      if (typeof ingest.intervalMs !== "number" || ingest.intervalMs < 1) {
-        return Err(new ConnectorValidationError("Ingest intervalMs must be a positive number"));
-      }
-    }
   }
+  if (!typeResult.ok) return typeResult;
+  const ingestResult = validateIngestConfig(obj, connectorType);
+  if (!ingestResult.ok) return ingestResult;
   return Ok(input);
 }
 
@@ -1105,12 +1213,27 @@ registerConnectorDescriptor({
 });
 
 // ../core/src/create-poller.ts
+function createPollerRegistry(factories = /* @__PURE__ */ new Map()) {
+  return buildPollerRegistry(new Map(factories));
+}
+function buildPollerRegistry(map) {
+  return {
+    get(type) {
+      return map.get(type);
+    },
+    with(type, factory) {
+      const next = new Map(map);
+      next.set(type, factory);
+      return buildPollerRegistry(next);
+    }
+  };
+}
 var pollerFactories = /* @__PURE__ */ new Map();
 function registerPollerFactory(type, factory) {
   pollerFactories.set(type, factory);
 }
-function createPoller(config, gateway) {
-  const factory = pollerFactories.get(config.type);
+function createPoller(config, gateway, registry) {
+  const factory = registry ? registry.get(config.type) : pollerFactories.get(config.type);
   if (!factory) {
     throw new Error(
       `No poller factory registered for connector type "${config.type}". Did you import the connector package (e.g. "@lakesync/connector-${config.type}")?`
@@ -1209,6 +1332,7 @@ async function generateDeltaId(params) {
 }
 
 // ../core/src/delta/types.ts
+var COLUMN_TYPES = ["string", "number", "boolean", "json", "null"];
 function rowKey(table, rowId) {
   return `${table}:${rowId}`;
 }
@@ -1475,6 +1599,9 @@ export {
   AuthError,
   verifyToken,
   HLC,
+  ChunkedPusher,
+  PressureManager,
+  PollingScheduler,
   isIngestTarget,
   BaseSourcePoller,
   CallbackPushTarget,
@@ -1482,16 +1609,19 @@ export {
   resolveLWW,
   isActionHandler,
   ConnectorValidationError,
+  createConnectorRegistry,
   registerConnectorDescriptor,
   registerOutputSchemas,
   getConnectorDescriptor,
   listConnectorDescriptors,
   CONNECTOR_TYPES,
   validateConnectorConfig,
+  createPollerRegistry,
   registerPollerFactory,
   createPoller,
   applyDelta,
   extractDelta,
+  COLUMN_TYPES,
   rowKey,
   bigintReplacer,
   bigintReviver,
@@ -1507,4 +1637,4 @@ export {
   assertValidIdentifier,
   quoteIdentifier
 };
-//# sourceMappingURL=chunk-P3FT7QCW.js.map
+//# sourceMappingURL=chunk-LDFFCG2K.js.map