lakesync 0.1.6 → 0.2.0

package/dist/adapter-types-DwsQGQS4.d.ts

@@ -0,0 +1,94 @@
+import { R as RowDelta, T as TableSchema } from './types-BdGBv2ba.js';
+import { R as Result, A as AdapterError, H as HLCTimestamp } from './result-CojzlFE2.js';
+
+/** Information about an object in the lake store. */
+interface ObjectInfo {
+    /** S3 object key */
+    key: string;
+    /** Object size in bytes */
+    size: number;
+    /** Last modification date */
+    lastModified: Date;
+}
+/** Abstract interface for lake storage operations. */
+interface LakeAdapter {
+    /** Store an object in the lake. */
+    putObject(path: string, data: Uint8Array, contentType?: string): Promise<Result<void, AdapterError>>;
+    /** Retrieve an object from the lake. */
+    getObject(path: string): Promise<Result<Uint8Array, AdapterError>>;
+    /** Get object metadata without retrieving the body. */
+    headObject(path: string): Promise<Result<{
+        size: number;
+        lastModified: Date;
+    }, AdapterError>>;
+    /** List objects matching a given prefix. */
+    listObjects(prefix: string): Promise<Result<ObjectInfo[], AdapterError>>;
+    /** Delete a single object from the lake. */
+    deleteObject(path: string): Promise<Result<void, AdapterError>>;
+    /** Delete multiple objects from the lake in a single batch operation. */
+    deleteObjects(paths: string[]): Promise<Result<void, AdapterError>>;
+}
+/** Configuration for a database adapter connection. */
+interface DatabaseAdapterConfig {
+    /** Connection string (e.g. postgres://user:pass@host/db) */
+    connectionString: string;
+    /** Maximum number of connections in the pool (default: 10). */
+    poolMax?: number;
+    /** Connection idle timeout in milliseconds (default: 10000). */
+    idleTimeoutMs?: number;
+    /** Connection acquisition timeout in milliseconds (default: 30000). */
+    connectionTimeoutMs?: number;
+    /** Statement timeout in milliseconds (default: 30000). */
+    statementTimeoutMs?: number;
+}
+/**
+ * Abstract interface for SQL database storage operations.
+ * Alternative to LakeAdapter for small-data backends (Postgres, MySQL, etc).
+ */
+interface DatabaseAdapter {
+    /** Insert deltas into the database in a single batch. Idempotent via deltaId uniqueness. */
+    insertDeltas(deltas: RowDelta[]): Promise<Result<void, AdapterError>>;
+    /** Query deltas with HLC greater than the given timestamp, optionally filtered by table. */
+    queryDeltasSince(hlc: HLCTimestamp, tables?: string[]): Promise<Result<RowDelta[], AdapterError>>;
+    /** Get the latest merged state for a specific row. Returns null if the row doesn't exist. */
+    getLatestState(table: string, rowId: string): Promise<Result<Record<string, unknown> | null, AdapterError>>;
+    /** Ensure the database schema matches the given TableSchema. Creates/alters tables as needed. */
+    ensureSchema(schema: TableSchema): Promise<Result<void, AdapterError>>;
+    /** Close the database connection and release resources. */
+    close(): Promise<void>;
+}
+/** Type guard to distinguish DatabaseAdapter from LakeAdapter at runtime. */
+declare function isDatabaseAdapter(adapter: unknown): adapter is DatabaseAdapter;
+/**
+ * Opt-in capability for adapters that can materialise deltas into destination tables.
+ *
+ * Materialisation is a separate concern from delta storage — adapters that store
+ * deltas (via `DatabaseAdapter.insertDeltas`) may also materialise them into
+ * queryable destination tables by implementing this interface.
+ *
+ * Destination tables follow the hybrid column model:
+ * - Synced columns (written by materialiser, derived from `TableSchema.columns`)
+ * - `props JSONB DEFAULT '{}'` — consumer-extensible, never touched by materialiser
+ * - `synced_at` — updated on every materialise cycle
+ */
+interface Materialisable {
+    /**
+     * Materialise deltas into destination tables.
+     *
+     * For each table with a matching schema, merges delta history into the
+     * latest row state and upserts into the destination table. Tombstoned
+     * rows are deleted. The `props` column is never touched.
+     *
+     * @param deltas - The deltas that were just flushed.
+     * @param schemas - Table schemas defining destination tables and column mappings.
+     */
+    materialise(deltas: RowDelta[], schemas: ReadonlyArray<TableSchema>): Promise<Result<void, AdapterError>>;
+}
+/**
+ * Type guard to check if an adapter supports materialisation.
+ *
+ * Uses duck-typing (same pattern as `isDatabaseAdapter`).
+ */
+declare function isMaterialisable(adapter: unknown): adapter is Materialisable;
+
+export { type DatabaseAdapter as D, type LakeAdapter as L, type Materialisable as M, type ObjectInfo as O, type DatabaseAdapterConfig as a, isMaterialisable as b, isDatabaseAdapter as i };

package/dist/adapter.d.ts

@@ -1,44 +1,15 @@
 import { BigQuery } from '@google-cloud/bigquery';
 import { R as Result, A as AdapterError, H as HLCTimestamp } from './result-CojzlFE2.js';
-import { R as RowDelta, T as TableSchema, C as ColumnDelta } from './types-CLlD4XOy.js';
-import { D as DatabaseAdapter, a as DatabaseAdapterConfig } from './db-types-BlN-4KbQ.js';
-export { i as isDatabaseAdapter, l as lakeSyncTypeToBigQuery } from './db-types-BlN-4KbQ.js';
-import { C as ConnectorConfig } from './types-D-E0VrfS.js';
-import { L as LakeAdapter, A as AdapterConfig, O as ObjectInfo } from './types-DSC_EiwR.js';
+import { D as DatabaseAdapter, M as Materialisable, L as LakeAdapter, O as ObjectInfo, a as DatabaseAdapterConfig } from './adapter-types-DwsQGQS4.js';
+export { i as isDatabaseAdapter, b as isMaterialisable } from './adapter-types-DwsQGQS4.js';
+import { T as TableSchema, a as ColumnDelta, R as RowDelta } from './types-BdGBv2ba.js';
+export { A as AdapterFactory, a as AdapterFactoryRegistry, c as createAdapterFactoryRegistry, b as createDatabaseAdapter, d as defaultAdapterFactoryRegistry } from './factory-DFfR-030.js';
 import mysql from 'mysql2/promise';
 import { Pool } from 'pg';
+import { C as ConnectorConfig } from './types-D2C9jTbL.js';
+
+declare function lakeSyncTypeToBigQuery(type: TableSchema["columns"][number]["type"]): string;
 
-/**
- * Opt-in capability for adapters that can materialise deltas into destination tables.
- *
- * Materialisation is a separate concern from delta storage — adapters that store
- * deltas (via `DatabaseAdapter.insertDeltas`) may also materialise them into
- * queryable destination tables by implementing this interface.
- *
- * Destination tables follow the hybrid column model:
- * - Synced columns (written by materialiser, derived from `TableSchema.columns`)
- * - `props JSONB DEFAULT '{}'` — consumer-extensible, never touched by materialiser
- * - `synced_at` — updated on every materialise cycle
- */
-interface Materialisable {
-    /**
-     * Materialise deltas into destination tables.
-     *
-     * For each table with a matching schema, merges delta history into the
-     * latest row state and upserts into the destination table. Tombstoned
-     * rows are deleted. The `props` column is never touched.
-     *
-     * @param deltas - The deltas that were just flushed.
-     * @param schemas - Table schemas defining destination tables and column mappings.
-     */
-    materialise(deltas: RowDelta[], schemas: ReadonlyArray<TableSchema>): Promise<Result<void, AdapterError>>;
-}
-/**
- * Type guard to check if an adapter supports materialisation.
- *
- * Uses duck-typing (same pattern as `isDatabaseAdapter`).
- */
-declare function isMaterialisable(adapter: unknown): adapter is Materialisable;
 /**
  * Resolve the primary key columns for a table schema.
  * Defaults to `["row_id"]` when not explicitly set.
@@ -70,6 +41,56 @@ declare function groupDeltasByTable(deltas: ReadonlyArray<RowDelta>): Map<string
  * @returns A map from source table name to schema.
  */
 declare function buildSchemaIndex(schemas: ReadonlyArray<TableSchema>): Map<string, TableSchema>;
+/** Minimal query interface for executing SQL against a database. */
+interface QueryExecutor {
+    query(sql: string, params: unknown[]): Promise<void>;
+    queryRows(sql: string, params: unknown[]): Promise<Array<{
+        row_id: string;
+        columns: string | ColumnDelta[];
+        op: string;
+    }>>;
+}
+/**
+ * SQL dialect interface — encapsulates the syntactic differences between
+ * Postgres, MySQL, and BigQuery for the materialise algorithm.
+ */
+interface SqlDialect {
+    /** Generate CREATE TABLE IF NOT EXISTS for the destination table. */
+    createDestinationTable(dest: string, schema: TableSchema, pk: string[], softDelete: boolean): {
+        sql: string;
+        params: unknown[];
+    };
+    /** Generate a query to fetch delta history for a set of affected row IDs. */
+    queryDeltaHistory(sourceTable: string, rowIds: string[]): {
+        sql: string;
+        params: unknown[];
+    };
+    /** Generate an upsert statement for the merged row states. */
+    buildUpsert(dest: string, schema: TableSchema, conflictCols: string[], softDelete: boolean, upserts: Array<{
+        rowId: string;
+        state: Record<string, unknown>;
+    }>): {
+        sql: string;
+        params: unknown[];
+    };
+    /** Generate a delete (hard or soft) statement for tombstoned row IDs. */
+    buildDelete(dest: string, deleteIds: string[], softDelete: boolean): {
+        sql: string;
+        params: unknown[];
+    };
+}
+/**
+ * Execute the shared materialise algorithm using the provided dialect and executor.
+ *
+ * Algorithm: group by table -> build schema index -> for each table:
+ * create dest table -> query history -> merge -> upsert -> delete.
+ *
+ * @param executor - Executes SQL statements against the database.
+ * @param dialect - Generates dialect-specific SQL.
+ * @param deltas - The deltas that were just flushed.
+ * @param schemas - Table schemas defining destination tables and column mappings.
+ */
+declare function executeMaterialise(executor: QueryExecutor, dialect: SqlDialect, deltas: RowDelta[], schemas: ReadonlyArray<TableSchema>): Promise<Result<void, AdapterError>>;
 
 /**
  * Configuration for the BigQuery adapter.
@@ -85,6 +106,40 @@ interface BigQueryAdapterConfig {
     /** Dataset location (default: "US"). */
     location?: string;
 }
+/**
+ * BigQuery SQL dialect for the shared materialise algorithm.
+ *
+ * Uses `@name` named parameters, `MERGE` for upserts, `JSON` type,
+ * `TIMESTAMP` types, and `CLUSTER BY` for table creation.
+ *
+ * BigQuery's parameterised query API uses named params in a flat object,
+ * so this dialect encodes params as named keys and returns them as an
+ * array of `[key, value]` pairs that the executor unpacks into a
+ * `Record<string, unknown>`.
+ */
+declare class BigQuerySqlDialect implements SqlDialect {
+    private readonly dataset;
+    constructor(dataset: string);
+    createDestinationTable(dest: string, schema: TableSchema, pk: string[], softDelete: boolean): {
+        sql: string;
+        params: unknown[];
+    };
+    queryDeltaHistory(sourceTable: string, rowIds: string[]): {
+        sql: string;
+        params: unknown[];
+    };
+    buildUpsert(dest: string, schema: TableSchema, conflictCols: string[], softDelete: boolean, upserts: Array<{
+        rowId: string;
+        state: Record<string, unknown>;
+    }>): {
+        sql: string;
+        params: unknown[];
+    };
+    buildDelete(dest: string, deleteIds: string[], softDelete: boolean): {
+        sql: string;
+        params: unknown[];
+    };
+}
 /**
  * BigQuery database adapter for LakeSync.
  *
@@ -103,6 +158,8 @@ declare class BigQueryAdapter implements DatabaseAdapter, Materialisable {
     readonly dataset: string;
     /** @internal */
     readonly location: string;
+    private readonly dialect;
+    private readonly executor;
     constructor(config: BigQueryAdapterConfig);
     /**
      * Insert deltas into the database in a single batch.
@@ -127,10 +184,8 @@ declare class BigQueryAdapter implements DatabaseAdapter, Materialisable {
     /**
      * Materialise deltas into destination tables.
      *
-     * For each affected table, queries the full delta history for touched rows,
-     * merges to latest state via column-level LWW, then upserts live rows and
-     * deletes tombstoned rows. The consumer-owned `props` column is never
-     * touched on UPDATE.
+     * Delegates to the shared `executeMaterialise` algorithm with the
+     * BigQuery SQL dialect.
      */
     materialise(deltas: RowDelta[], schemas: ReadonlyArray<TableSchema>): Promise<Result<void, AdapterError>>;
     /**
@@ -174,18 +229,6 @@ declare class CompositeAdapter implements DatabaseAdapter {
     close(): Promise<void>;
 }
 
-/**
- * Instantiate a {@link DatabaseAdapter} from a {@link ConnectorConfig}.
- *
- * Switches on `config.type` and creates the matching adapter using
- * the type-specific connection configuration. Returns an {@link AdapterError}
- * if the type-specific config is missing or the adapter constructor throws.
- *
- * @param config - Validated connector configuration.
- * @returns The instantiated adapter or an error.
- */
-declare function createDatabaseAdapter(config: ConnectorConfig): Result<DatabaseAdapter, AdapterError>;
-
 /** Configuration for the FanOutAdapter. */
 interface FanOutAdapterConfig {
     /** The primary adapter that handles all reads and authoritative writes. */
@@ -199,8 +242,14 @@ interface FanOutAdapterConfig {
  *
  * Secondary failures are silently caught and never affect the return value.
  * Use case: write to Postgres (fast, operational), replicate to BigQuery (analytics).
+ *
+ * **Materialisation:** This adapter exposes a `materialise()` method for
+ * duck-type compatibility with `isMaterialisable()`. When the primary adapter
+ * is itself materialisable, materialisation is delegated to it; otherwise
+ * the method is a graceful no-op returning `Ok`. Materialisable secondaries
+ * receive fire-and-forget replication.
  */
-declare class FanOutAdapter implements DatabaseAdapter, Materialisable {
+declare class FanOutAdapter implements DatabaseAdapter {
     private readonly primary;
     private readonly secondaries;
     constructor(config: FanOutAdapterConfig);
@@ -241,8 +290,14 @@ interface LifecycleAdapterConfig {
  *
  * Use {@link migrateToTier} as a background job to copy aged-out deltas
  * from hot to cold.
+ *
+ * **Materialisation:** This adapter exposes a `materialise()` method for
+ * duck-type compatibility with `isMaterialisable()`. Materialisation is
+ * delegated to the hot tier only — cold tier stores archived deltas, not
+ * destination tables. When the hot adapter is not materialisable, the
+ * method is a graceful no-op returning `Ok`.
  */
-declare class LifecycleAdapter implements DatabaseAdapter, Materialisable {
+declare class LifecycleAdapter implements DatabaseAdapter {
     private readonly hot;
     private readonly cold;
     private readonly maxAgeMs;
@@ -317,6 +372,21 @@ interface MigrateResult {
  */
 declare function migrateAdapter(opts: MigrateOptions): Promise<Result<MigrateResult, AdapterError>>;
 
+/** Configuration for connecting to the lake store */
+interface AdapterConfig {
+    /** Endpoint URL (e.g. http://localhost:9000) */
+    endpoint: string;
+    /** Bucket name */
+    bucket: string;
+    /** AWS region (defaults to us-east-1) */
+    region?: string;
+    /** Access credentials */
+    credentials: {
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+}
+
 /**
  * MinIO/S3-compatible lake adapter.
  *
@@ -345,6 +415,33 @@ declare class MinIOAdapter implements LakeAdapter {
     deleteObjects(paths: string[]): Promise<Result<void, AdapterError>>;
 }
 
+/**
+ * MySQL SQL dialect for the shared materialise algorithm.
+ *
+ * Uses `?` positional parameters, `ON DUPLICATE KEY UPDATE`,
+ * `JSON` type, and `TIMESTAMP` types.
+ */
+declare class MySqlDialect implements SqlDialect {
+    createDestinationTable(dest: string, schema: TableSchema, pk: string[], softDelete: boolean): {
+        sql: string;
+        params: unknown[];
+    };
+    queryDeltaHistory(sourceTable: string, rowIds: string[]): {
+        sql: string;
+        params: unknown[];
+    };
+    buildUpsert(dest: string, schema: TableSchema, _conflictCols: string[], softDelete: boolean, upserts: Array<{
+        rowId: string;
+        state: Record<string, unknown>;
+    }>): {
+        sql: string;
+        params: unknown[];
+    };
+    buildDelete(dest: string, deleteIds: string[], softDelete: boolean): {
+        sql: string;
+        params: unknown[];
+    };
+}
 /**
  * MySQL database adapter for LakeSync.
  *
@@ -355,7 +452,9 @@ declare class MinIOAdapter implements LakeAdapter {
 declare class MySQLAdapter implements DatabaseAdapter, Materialisable {
     /** @internal */
     readonly pool: mysql.Pool;
+    private readonly dialect;
     constructor(config: DatabaseAdapterConfig);
+    private get executor();
     /**
      * Insert deltas into the database in a single batch.
      * Uses INSERT IGNORE for idempotent writes — duplicate deltaIds are silently skipped.
@@ -379,16 +478,41 @@ declare class MySQLAdapter implements DatabaseAdapter, Materialisable {
     /**
      * Materialise deltas into destination tables.
      *
-     * For each table with a matching schema, merges delta history into the
-     * latest row state and upserts into the destination table. Tombstoned
-     * rows are soft-deleted (default) or hard-deleted. The `props` column
-     * is never touched.
+     * Delegates to the shared `executeMaterialise` algorithm with the
+     * MySQL SQL dialect.
      */
     materialise(deltas: RowDelta[], schemas: ReadonlyArray<TableSchema>): Promise<Result<void, AdapterError>>;
     /** Close the database connection pool and release resources. */
     close(): Promise<void>;
 }
 
+/**
+ * Postgres SQL dialect for the shared materialise algorithm.
+ *
+ * Uses `$N` positional parameters, `ON CONFLICT DO UPDATE`, `JSONB`,
+ * and `TIMESTAMPTZ` types.
+ */
+declare class PostgresSqlDialect implements SqlDialect {
+    createDestinationTable(dest: string, schema: TableSchema, pk: string[], softDelete: boolean): {
+        sql: string;
+        params: unknown[];
+    };
+    queryDeltaHistory(sourceTable: string, rowIds: string[]): {
+        sql: string;
+        params: unknown[];
+    };
+    buildUpsert(dest: string, schema: TableSchema, conflictCols: string[], softDelete: boolean, upserts: Array<{
+        rowId: string;
+        state: Record<string, unknown>;
+    }>): {
+        sql: string;
+        params: unknown[];
+    };
+    buildDelete(dest: string, deleteIds: string[], softDelete: boolean): {
+        sql: string;
+        params: unknown[];
+    };
+}
 /**
  * PostgreSQL database adapter for LakeSync.
  *
@@ -398,7 +522,9 @@ declare class MySQLAdapter implements DatabaseAdapter, Materialisable {
 declare class PostgresAdapter implements DatabaseAdapter, Materialisable {
     /** @internal */
     readonly pool: Pool;
+    private readonly dialect;
     constructor(config: DatabaseAdapterConfig);
+    private get executor();
     /**
      * Insert deltas into the database in a single batch.
      * Idempotent via `ON CONFLICT (delta_id) DO NOTHING`.
@@ -422,9 +548,8 @@ declare class PostgresAdapter implements DatabaseAdapter, Materialisable {
     /**
      * Materialise deltas into destination tables.
      *
-     * For each table with a matching schema, merges delta history into the
-     * latest row state and upserts into the destination table. Tombstoned
-     * rows are deleted. The `props` column is never touched.
+     * Delegates to the shared `executeMaterialise` algorithm with the
+     * Postgres SQL dialect.
      */
     materialise(deltas: RowDelta[], schemas: ReadonlyArray<TableSchema>): Promise<Result<void, AdapterError>>;
     /** Close the database connection pool and release resources. */
@@ -438,13 +563,27 @@ type QueryFn = (sql: string, params?: unknown[]) => Promise<Record<string, unkno
  *
  * Uses dynamic imports so the database drivers (pg, mysql2) are only
  * loaded when actually needed. Returns `null` for connector types that
- * do not support the standard SQL polling model (e.g. BigQuery).
+ * do not support the standard SQL polling model (e.g. BigQuery, Jira, Salesforce).
  *
  * @param config - Validated connector configuration.
  * @returns A query function or `null` if the connector type is unsupported.
  */
 declare function createQueryFn(config: ConnectorConfig): Promise<QueryFn | null>;
 
+/**
+ * Group raw delta rows by row_id, merge to latest state, and partition into upserts and deletes.
+ */
+declare function groupAndMerge(rows: Array<{
+    row_id: string;
+    columns: string | ColumnDelta[];
+    op: string;
+}>): {
+    upserts: Array<{
+        rowId: string;
+        state: Record<string, unknown>;
+    }>;
+    deleteIds: string[];
+};
 /** Normalise a caught value into an Error or undefined. */
 declare function toCause(error: unknown): Error | undefined;
 /** Execute an async operation and wrap errors into an AdapterError Result. */
@@ -459,4 +598,4 @@ declare function mergeLatestState(rows: Array<{
     op: string;
 }>): Record<string, unknown> | null;
 
-export { AdapterConfig, BigQueryAdapter, type BigQueryAdapterConfig, CompositeAdapter, type CompositeAdapterConfig, type CompositeRoute, DatabaseAdapter, DatabaseAdapterConfig, FanOutAdapter, type FanOutAdapterConfig, LakeAdapter, LifecycleAdapter, type LifecycleAdapterConfig, type Materialisable, type MigrateOptions, type MigrateProgress, type MigrateResult, MinIOAdapter, MySQLAdapter, ObjectInfo, PostgresAdapter, type QueryFn, buildSchemaIndex, createDatabaseAdapter, createQueryFn, groupDeltasByTable, isMaterialisable, isSoftDelete, mergeLatestState, migrateAdapter, migrateToTier, resolveConflictColumns, resolvePrimaryKey, toCause, wrapAsync };
+export { type AdapterConfig, BigQueryAdapter, type BigQueryAdapterConfig, BigQuerySqlDialect, CompositeAdapter, type CompositeAdapterConfig, type CompositeRoute, DatabaseAdapter, DatabaseAdapterConfig, FanOutAdapter, type FanOutAdapterConfig, LakeAdapter, LifecycleAdapter, type LifecycleAdapterConfig, Materialisable, type MigrateOptions, type MigrateProgress, type MigrateResult, MinIOAdapter, MySQLAdapter, MySqlDialect, ObjectInfo, PostgresAdapter, PostgresSqlDialect, type QueryExecutor, type QueryFn, type SqlDialect, buildSchemaIndex, createQueryFn, executeMaterialise, groupAndMerge, groupDeltasByTable, isSoftDelete, lakeSyncTypeToBigQuery, mergeLatestState, migrateAdapter, migrateToTier, resolveConflictColumns, resolvePrimaryKey, toCause, wrapAsync };

package/dist/adapter.js

@@ -1,17 +1,22 @@
 import {
   BigQueryAdapter,
+  BigQuerySqlDialect,
   CompositeAdapter,
   FanOutAdapter,
   LifecycleAdapter,
   MinIOAdapter,
   MySQLAdapter,
+  MySqlDialect,
   PostgresAdapter,
+  PostgresSqlDialect,
   buildSchemaIndex,
+  createAdapterFactoryRegistry,
   createDatabaseAdapter,
   createQueryFn,
+  defaultAdapterFactoryRegistry,
+  executeMaterialise,
+  groupAndMerge,
   groupDeltasByTable,
-  isDatabaseAdapter,
-  isMaterialisable,
   isSoftDelete,
   lakeSyncTypeToBigQuery,
   mergeLatestState,
@@ -21,20 +26,30 @@ import {
   resolvePrimaryKey,
   toCause,
   wrapAsync
-} from "./chunk-GUJWMK5P.js";
-import "./chunk-P3FT7QCW.js";
-import "./chunk-7D4SUZUM.js";
+} from "./chunk-C4KD6YKP.js";
+import {
+  isDatabaseAdapter,
+  isMaterialisable
+} from "./chunk-4SG66H5K.js";
+import "./chunk-DGUM43GV.js";
 export {
   BigQueryAdapter,
+  BigQuerySqlDialect,
   CompositeAdapter,
   FanOutAdapter,
   LifecycleAdapter,
   MinIOAdapter,
   MySQLAdapter,
+  MySqlDialect,
   PostgresAdapter,
+  PostgresSqlDialect,
   buildSchemaIndex,
+  createAdapterFactoryRegistry,
   createDatabaseAdapter,
   createQueryFn,
+  defaultAdapterFactoryRegistry,
+  executeMaterialise,
+  groupAndMerge,
   groupDeltasByTable,
   isDatabaseAdapter,
   isMaterialisable,

package/dist/analyst.js

@@ -2,8 +2,8 @@ import {
   Err,
   LakeSyncError,
   Ok
-} from "./chunk-P3FT7QCW.js";
-import "./chunk-7D4SUZUM.js";
+} from "./chunk-4SG66H5K.js";
+import "./chunk-DGUM43GV.js";
 
 // ../analyst/src/duckdb.ts
 var DuckDBClient = class {

package/dist/{base-poller-BpUyuG2R.d.ts → base-poller-Y7ORYgUv.d.ts}

@@ -1,11 +1,78 @@
-import { S as SyncPush, R as RowDelta } from './types-CLlD4XOy.js';
+import { S as SyncPush, R as RowDelta } from './types-BdGBv2ba.js';
 import { H as HLC } from './hlc-DiD8QNG3.js';
 import { R as Result, F as FlushError } from './result-CojzlFE2.js';
 
+/**
+ * Target that supports flush and buffer inspection.
+ * Implemented by SyncGateway so pollers can trigger flushes to relieve memory pressure.
+ */
+interface FlushableTarget {
+    flush(): Promise<Result<void, FlushError>>;
+    shouldFlush(): boolean;
+    readonly bufferStats: {
+        logSize: number;
+        indexSize: number;
+        byteSize: number;
+    };
+}
+/**
+ * Monitors buffer pressure on a {@link FlushableTarget} and triggers
+ * flushes when thresholds are exceeded. Created at construction time
+ * only when the target supports flushing — no runtime type checks needed.
+ */
+declare class PressureManager {
+    private readonly target;
+    private readonly memoryBudgetBytes;
+    private readonly flushThreshold;
+    constructor(config: {
+        target: FlushableTarget;
+        memoryBudgetBytes?: number;
+        flushThreshold?: number;
+    });
+    /** Check buffer pressure and flush if thresholds are exceeded. */
+    checkAndFlush(): Promise<void>;
+    /** Force a flush regardless of current pressure. */
+    forceFlush(): Promise<void>;
+    private shouldFlush;
+}
+
 /** Minimal interface for a push target (avoids depending on @lakesync/gateway). */
 interface PushTarget {
     handlePush(push: SyncPush): unknown;
 }
+/**
+ * Manages chunked pushing of deltas to a {@link PushTarget}.
+ * Handles backpressure retry (flush + retry once) when a
+ * {@link PressureManager} is present.
+ *
+ * No runtime type checks — the PressureManager is either provided
+ * at construction (target supports flush) or null.
+ */
+declare class ChunkedPusher {
+    private readonly target;
+    private readonly clientId;
+    private readonly chunkSize;
+    private readonly pressure;
+    private pendingDeltas;
+    constructor(config: {
+        target: PushTarget;
+        clientId: string;
+        chunkSize: number;
+        pressure: PressureManager | null;
+    });
+    /**
+     * Accumulate a single delta. When `chunkSize` is reached, the pending
+     * deltas are automatically pushed (and flushed if needed).
+     */
+    accumulate(delta: RowDelta): Promise<void>;
+    /** Flush any remaining accumulated deltas. */
+    flush(): Promise<void>;
+    /** Push deltas directly (single-shot, backward compat). */
+    pushImmediate(deltas: RowDelta[]): void;
+    private pushPendingChunk;
+    private pushChunkWithFlush;
+}
+
 /**
  * Extended push target that supports flush and buffer inspection.
  * Implemented by SyncGateway so pollers can trigger flushes to relieve memory pressure.
@@ -32,19 +99,20 @@ interface PollerMemoryConfig {
 }
 /**
  * Base class for source pollers that poll an external API and push deltas
- * to a SyncGateway. Handles lifecycle (start/stop/schedule), and push.
+ * to a SyncGateway.
+ *
+ * Composes {@link PollingScheduler} (lifecycle), {@link ChunkedPusher}
+ * (chunked push with backpressure), and {@link PressureManager}
+ * (memory-budget flush decisions).
  */
 declare abstract class BaseSourcePoller {
     protected readonly gateway: PushTarget;
     protected readonly hlc: HLC;
     protected readonly clientId: string;
-    private readonly intervalMs;
-    private timer;
-    private running;
-    private readonly chunkSize;
-    private readonly memoryBudgetBytes;
-    private readonly flushThreshold;
-    private pendingDeltas;
+    private readonly scheduler;
+    private readonly pusher;
+    /** Optional callback invoked after each poll with the current cursor state. */
+    onCursorUpdate?: (state: Record<string, unknown>) => void;
     constructor(config: {
         name: string;
         intervalMs: number;
@@ -77,15 +145,6 @@ declare abstract class BaseSourcePoller {
     protected accumulateDelta(delta: RowDelta): Promise<void>;
     /** Flush any remaining accumulated deltas. Call at the end of `poll()`. */
     protected flushAccumulator(): Promise<void>;
-    /**
-     * 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.
-     */
-    private pushPendingChunk;
-    private pushChunkWithFlush;
-    private shouldFlushTarget;
-    private schedulePoll;
 }
 
-export { BaseSourcePoller as B, type IngestTarget as I, type PushTarget as P, type PollerMemoryConfig as a, isIngestTarget as i };
+export { BaseSourcePoller as B, ChunkedPusher as C, type FlushableTarget as F, type IngestTarget as I, type PushTarget as P, type PollerMemoryConfig as a, PressureManager as b, isIngestTarget as i };