lakesync 0.1.8 → 0.2.0

package/dist/index.d.ts

@@ -2,15 +2,16 @@ import { A as Action, a as ActionValidationError, S as SyncRulesConfig, B as Buc
 export { c as ActionDescriptor, d as ActionDiscovery, e as ActionErrorResult, f as ActionExecutionError, g as ActionHandler, h as ActionNotSupportedError, i as ActionPush, j as ActionResponse, k as ActionResult, l as AuthContext, m as SyncRuleFilter, n as SyncRuleOp, o as isActionError, p as isActionHandler } from './types-Bs-QyOe-.js';
 import { H as HLCTimestamp, R as Result, C as ConflictError, L as LakeSyncError, S as SchemaError } from './result-CojzlFE2.js';
 export { A as AdapterError, a as AdapterNotFoundError, B as BackpressureError, b as ClockDriftError, E as Err, F as FlushError, O as Ok, f as flatMapResult, c as fromPromise, m as mapResult, t as toError, u as unwrapOrThrow } from './result-CojzlFE2.js';
-export { A as AuthClaims, a as AuthError, v as verifyToken } from './auth-CAVutXzx.js';
-import { P as PushTarget, B as BaseSourcePoller } from './base-poller-Bj9kX9dv.js';
-export { C as ChunkedPusher, F as FlushableTarget, I as IngestTarget, a as PollerMemoryConfig, b as PressureManager, i as isIngestTarget } from './base-poller-Bj9kX9dv.js';
-import { S as SyncPush, R as RowDelta, T as TableSchema } from './types-BdGBv2ba.js';
+export { D as DatabaseAdapter, a as DatabaseAdapterConfig, L as LakeAdapter, M as Materialisable, O as ObjectInfo, i as isDatabaseAdapter, b as isMaterialisable } from './adapter-types-DwsQGQS4.js';
+export { A as AuthClaims, a as AuthError, P as PollerFactory, b as PollerRegistry, c as createPoller, d as createPollerRegistry, v as verifyToken } from './create-poller-Cc2MGfhh.js';
+import { P as PushTarget } from './base-poller-Y7ORYgUv.js';
+export { B as BaseSourcePoller, C as ChunkedPusher, F as FlushableTarget, I as IngestTarget, a as PollerMemoryConfig, b as PressureManager, i as isIngestTarget } from './base-poller-Y7ORYgUv.js';
+import { R as RowDelta, T as TableSchema, S as SyncPush } from './types-BdGBv2ba.js';
 export { C as COLUMN_TYPES, a as ColumnDelta, b as ColumnReference, c as ColumnType, D as DeltaOp, d as RowKey, e as SyncPull, f as SyncResponse, r as rowKey } from './types-BdGBv2ba.js';
 import { C as ConflictResolver } from './resolver-CXxmC0jR.js';
-export { C as ConnectorCategory, a as ConnectorDescriptor, b as ConnectorRegistry, c as createConnectorRegistry, g as getConnectorDescriptor, l as listConnectorDescriptors, r as registerConnectorDescriptor, d as registerOutputSchemas } from './registry-BcspAtZI.js';
-import { C as ConnectorConfig } from './types-BrcD1oJg.js';
-export { B as BigQueryConnectorConfig, a as CONNECTOR_TYPES, b as ConnectorIngestConfig, c as ConnectorIngestTable, d as ConnectorType, J as JiraConnectorConfig, M as MySQLConnectorConfig, P as PostgresConnectorConfig, S as SalesforceConnectorConfig } from './types-BrcD1oJg.js';
+export { C as ConnectorCategory, a as ConnectorDescriptor, b as ConnectorRegistry, c as createConnectorRegistry, g as getConnectorDescriptor, l as listConnectorDescriptors, r as registerConnectorDescriptor, d as registerOutputSchemas } from './registry-Dd8JuW8T.js';
+import { C as ConnectorConfig } from './types-D2C9jTbL.js';
+export { B as BigQueryConnectorConfig, a as BigQueryConnectorConfigFull, b as CONNECTOR_TYPES, c as ConnectorConfigBase, d as ConnectorIngestConfig, e as ConnectorIngestTable, f as ConnectorType, J as JiraConnectorConfig, g as JiraConnectorConfigFull, M as MySQLConnectorConfig, h as MySQLConnectorConfigFull, P as PostgresConnectorConfig, i as PostgresConnectorConfigFull, S as SalesforceConnectorConfig, j as SalesforceConnectorConfigFull } from './types-D2C9jTbL.js';
 export { H as HLC } from './hlc-DiD8QNG3.js';
 export { b as bigintReplacer, a as bigintReviver } from './json-dYtqiL0F.js';
 
@@ -36,6 +37,42 @@ declare function generateActionId(params: {
  */
 declare function validateAction(action: unknown): Result<Action, ActionValidationError>;
 
+/**
+ * Apply a delta to an existing row, returning the merged result.
+ *
+ * - DELETE → returns null
+ * - INSERT → creates a new row from delta columns
+ * - UPDATE → merges delta columns onto existing row (immutable — returns a new object)
+ *
+ * @param row - The current row state, or null if no row exists
+ * @param delta - The delta to apply
+ * @returns The merged row, or null for DELETE operations
+ */
+declare function applyDelta(row: Record<string, unknown> | null, delta: RowDelta): Record<string, unknown> | null;
+
+/**
+ * Extract a column-level delta between two row states.
+ *
+ * - `before` null/undefined + `after` present -> INSERT (all columns)
+ * - `before` present + `after` null/undefined -> DELETE (empty columns)
+ * - Both present -> compare each column, emit only changed columns as UPDATE
+ * - No columns changed -> returns null (no-op)
+ *
+ * If `schema` is provided, only columns listed in the schema are considered.
+ *
+ * @param before - The previous row state, or null/undefined for a new row
+ * @param after - The current row state, or null/undefined for a deleted row
+ * @param opts - Table name, row ID, client ID, HLC timestamp, and optional schema
+ * @returns The extracted RowDelta, or null if nothing changed
+ */
+declare function extractDelta(before: Record<string, unknown> | null | undefined, after: Record<string, unknown> | null | undefined, opts: {
+    table: string;
+    rowId: string;
+    clientId: string;
+    hlc: HLCTimestamp;
+    schema?: TableSchema;
+}): Promise<RowDelta | null>;
+
 /**
  * A simple PushTarget implementation that forwards every push to a
  * user-supplied callback. Useful for testing, logging, or lightweight
@@ -102,71 +139,6 @@ declare class ConnectorValidationError extends LakeSyncError {
  */
 declare function validateConnectorConfig(input: unknown): Result<ConnectorConfig, ConnectorValidationError>;
 
-/** Factory function that creates a poller from a ConnectorConfig. */
-type PollerFactory = (config: ConnectorConfig, gateway: PushTarget) => BaseSourcePoller;
-/** Immutable registry of poller factories keyed by connector type. */
-interface PollerRegistry {
-    /** Look up a factory by type. */
-    get(type: string): PollerFactory | undefined;
-    /** Create a new registry with an additional or replaced factory. */
-    with(type: string, factory: PollerFactory): PollerRegistry;
-}
-/**
- * Create an immutable {@link PollerRegistry} from a Map of factories.
- */
-declare function createPollerRegistry(factories?: Map<string, PollerFactory>): PollerRegistry;
-/**
- * Register a poller factory for a connector type.
- * Connector packages call this at module load time so that
- * `createPoller()` can instantiate the correct poller.
- */
-declare function registerPollerFactory(type: string, factory: PollerFactory): void;
-/**
- * Create a poller from a {@link ConnectorConfig}.
- *
- * @param config - Connector configuration.
- * @param gateway - Push target for the poller.
- * @param registry - Optional explicit registry. Defaults to the global registry.
- * @throws If no factory has been registered for the config's `type`.
- */
-declare function createPoller(config: ConnectorConfig, gateway: PushTarget, registry?: PollerRegistry): BaseSourcePoller;
-
-/**
- * Apply a delta to an existing row, returning the merged result.
- *
- * - DELETE → returns null
- * - INSERT → creates a new row from delta columns
- * - UPDATE → merges delta columns onto existing row (immutable — returns a new object)
- *
- * @param row - The current row state, or null if no row exists
- * @param delta - The delta to apply
- * @returns The merged row, or null for DELETE operations
- */
-declare function applyDelta(row: Record<string, unknown> | null, delta: RowDelta): Record<string, unknown> | null;
-
-/**
- * Extract a column-level delta between two row states.
- *
- * - `before` null/undefined + `after` present -> INSERT (all columns)
- * - `before` present + `after` null/undefined -> DELETE (empty columns)
- * - Both present -> compare each column, emit only changed columns as UPDATE
- * - No columns changed -> returns null (no-op)
- *
- * If `schema` is provided, only columns listed in the schema are considered.
- *
- * @param before - The previous row state, or null/undefined for a new row
- * @param after - The current row state, or null/undefined for a deleted row
- * @param opts - Table name, row ID, client ID, HLC timestamp, and optional schema
- * @returns The extracted RowDelta, or null if nothing changed
- */
-declare function extractDelta(before: Record<string, unknown> | null | undefined, after: Record<string, unknown> | null | undefined, opts: {
-    table: string;
-    rowId: string;
-    clientId: string;
-    hlc: HLCTimestamp;
-    schema?: TableSchema;
-}): Promise<RowDelta | null>;
-
 /**
  * Manages the start/stop lifecycle and timer scheduling for a poll function.
  * Has no knowledge of deltas, gateways, or sync protocol.
@@ -305,4 +277,4 @@ declare function assertValidIdentifier(name: string): Result<void, SchemaError>;
  */
 declare function quoteIdentifier(name: string): string;
 
-export { Action, ActionValidationError, BaseSourcePoller, BucketDefinition, CallbackPushTarget, ConflictError, ConflictResolver, ConnectorConfig, ConnectorValidationError, HLCTimestamp, LWWResolver, LakeSyncError, type PollerFactory, type PollerRegistry, PollingScheduler, PushTarget, ResolvedClaims, Result, RowDelta, SchemaError, SyncPush, SyncRuleError, SyncRulesConfig, SyncRulesContext, TableSchema, applyDelta, assertValidIdentifier, createPassAllRules, createPoller, createPollerRegistry, createUserScopedRules, deltaMatchesBucket, extractDelta, filterDeltas, generateActionId, isValidIdentifier, quoteIdentifier, registerPollerFactory, resolveClientBuckets, resolveFilterValue, resolveLWW, validateAction, validateConnectorConfig, validateSyncRules };
+export { Action, ActionValidationError, BucketDefinition, CallbackPushTarget, ConflictError, ConflictResolver, ConnectorConfig, ConnectorValidationError, HLCTimestamp, LWWResolver, LakeSyncError, PollingScheduler, PushTarget, ResolvedClaims, Result, RowDelta, SchemaError, SyncPush, SyncRuleError, SyncRulesConfig, SyncRulesContext, TableSchema, applyDelta, assertValidIdentifier, createPassAllRules, createUserScopedRules, deltaMatchesBucket, extractDelta, filterDeltas, generateActionId, isValidIdentifier, quoteIdentifier, resolveClientBuckets, resolveFilterValue, resolveLWW, validateAction, validateConnectorConfig, validateSyncRules };

package/dist/index.js

@@ -42,14 +42,15 @@ import {
   getConnectorDescriptor,
   isActionError,
   isActionHandler,
+  isDatabaseAdapter,
   isIngestTarget,
+  isMaterialisable,
   isValidIdentifier,
   listConnectorDescriptors,
   mapResult,
   quoteIdentifier,
   registerConnectorDescriptor,
   registerOutputSchemas,
-  registerPollerFactory,
   resolveClientBuckets,
   resolveFilterValue,
   resolveLWW,
@@ -60,7 +61,7 @@ import {
   validateConnectorConfig,
   validateSyncRules,
   verifyToken
-} from "./chunk-LDFFCG2K.js";
+} from "./chunk-4SG66H5K.js";
 import "./chunk-DGUM43GV.js";
 export {
   ActionExecutionError,
@@ -106,14 +107,15 @@ export {
   getConnectorDescriptor,
   isActionError,
   isActionHandler,
+  isDatabaseAdapter,
   isIngestTarget,
+  isMaterialisable,
   isValidIdentifier,
   listConnectorDescriptors,
   mapResult,
   quoteIdentifier,
   registerConnectorDescriptor,
   registerOutputSchemas,
-  registerPollerFactory,
   resolveClientBuckets,
   resolveFilterValue,
   resolveLWW,

package/dist/parquet.js

@@ -3,8 +3,8 @@ import {
   deltasToArrowTable,
   readParquetToDeltas,
   writeDeltasToParquet
-} from "./chunk-SSICS5KI.js";
-import "./chunk-LDFFCG2K.js";
+} from "./chunk-ZU7RC7CT.js";
+import "./chunk-4SG66H5K.js";
 import "./chunk-DGUM43GV.js";
 export {
   buildArrowSchema,

package/dist/proto.js

@@ -29,8 +29,8 @@ import {
   encodeSyncPull,
   encodeSyncPush,
   encodeSyncResponse
-} from "./chunk-KVSWLIJR.js";
-import "./chunk-LDFFCG2K.js";
+} from "./chunk-YHYBLU6W.js";
+import "./chunk-4SG66H5K.js";
 import "./chunk-DGUM43GV.js";
 export {
   ActionPushSchema,

package/dist/react.d.ts

@@ -1,11 +1,11 @@
 import * as react from 'react';
-import { b as SyncCoordinator, k as SyncTracker, D as DbError } from './coordinator-NXy6tA0h.js';
+import { b as SyncCoordinator, p as SyncTracker, D as DbError } from './coordinator-eGmZMnJ_.js';
 import { L as LakeSyncError, R as Result } from './result-CojzlFE2.js';
 import { c as ActionDescriptor, k as ActionResult, e as ActionErrorResult } from './types-Bs-QyOe-.js';
-import { a as ConnectorDescriptor } from './registry-BcspAtZI.js';
+import { a as ConnectorDescriptor } from './registry-Dd8JuW8T.js';
 import './hlc-DiD8QNG3.js';
 import './types-BdGBv2ba.js';
-import './types-BrcD1oJg.js';
+import './types-D2C9jTbL.js';
 
 /** Stable context value — coordinator and tracker references that never change. */
 interface LakeSyncStableContextValue {

package/dist/{registry-BcspAtZI.d.ts → registry-Dd8JuW8T.d.ts}

@@ -1,5 +1,5 @@
 import { T as TableSchema } from './types-BdGBv2ba.js';
-import { d as ConnectorType } from './types-BrcD1oJg.js';
+import { f as ConnectorType } from './types-D2C9jTbL.js';
 
 /** Connector category — determines the ingest model. */
 type ConnectorCategory = "database" | "api";

package/dist/{request-handler-pUvL7ozF.d.ts → request-handler-B1I5xDOx.d.ts}

@@ -1,33 +1,81 @@
 import { H as HLCTimestamp, R as Result, S as SchemaError, b as ClockDriftError, B as BackpressureError, a as AdapterNotFoundError, A as AdapterError, F as FlushError } from './result-CojzlFE2.js';
-import { g as ActionHandler, i as ActionPush, l as AuthContext, j as ActionResponse, a as ActionValidationError, d as ActionDiscovery, S as SyncRulesConfig, b as SyncRulesContext, R as ResolvedClaims } from './types-Bs-QyOe-.js';
+import { k as ActionResult, g as ActionHandler, i as ActionPush, l as AuthContext, j as ActionResponse, a as ActionValidationError, d as ActionDiscovery, S as SyncRulesConfig, b as SyncRulesContext, R as ResolvedClaims } from './types-Bs-QyOe-.js';
 import { R as RowDelta, d as RowKey, T as TableSchema, S as SyncPush, e as SyncPull, f as SyncResponse } from './types-BdGBv2ba.js';
-import { C as ConnectorConfig } from './types-BrcD1oJg.js';
-import { I as IngestTarget } from './base-poller-Bj9kX9dv.js';
-import { D as DatabaseAdapter } from './db-types-CfLMUBfW.js';
-import { L as LakeAdapter } from './types-DSC_EiwR.js';
+import { C as ConnectorConfig } from './types-D2C9jTbL.js';
+import { L as LakeAdapter, D as DatabaseAdapter } from './adapter-types-DwsQGQS4.js';
+import { I as IngestTarget } from './base-poller-Y7ORYgUv.js';
 import { N as NessieCatalogueClient } from './nessie-client-DrNikVXy.js';
 
-/** Configuration for ActionDispatcher caches. */
-interface ActionCacheConfig {
-    /** Maximum number of entries in the executed actions set and idempotency map. */
+/** Cached action result — either a successful result or an error descriptor. */
+type CachedActionResult = ActionResult | {
+    actionId: string;
+    code: string;
+    message: string;
+    retryable: boolean;
+};
+/**
+ * Interface for idempotency caching of action results.
+ *
+ * Implementations store action results keyed by actionId and optional
+ * idempotencyKey, enabling deduplication of repeated action dispatches.
+ */
+interface IdempotencyCache {
+    /** Check whether an action ID has been executed. */
+    has(actionId: string): boolean;
+    /** Get a cached result by action ID or idempotency key. Returns `undefined` if not found or expired. */
+    get(key: string): CachedActionResult | undefined;
+    /** Cache an action result. Also stores by idempotencyKey if provided. */
+    set(actionId: string, result: CachedActionResult, idempotencyKey?: string): void;
+}
+/** Configuration for {@link MemoryIdempotencyCache}. */
+interface IdempotencyCacheConfig {
+    /** Maximum number of entries in the cache. */
     maxSize?: number;
-    /** Time-to-live for idempotency entries in milliseconds. */
+    /** Time-to-live for cache entries in milliseconds. */
     ttlMs?: number;
 }
+/**
+ * In-memory idempotency cache with TTL expiration and bounded size.
+ *
+ * All state lives in a single Map keyed by actionId or `idem:{idempotencyKey}`.
+ * Stale entries are evicted on every `set()` call and the cache is
+ * trimmed to the configured max size (counting only non-idem entries).
+ */
+declare class MemoryIdempotencyCache implements IdempotencyCache {
+    private readonly entries;
+    private readonly maxSize;
+    private readonly ttlMs;
+    constructor(config?: IdempotencyCacheConfig);
+    /** {@inheritDoc IdempotencyCache.has} */
+    has(actionId: string): boolean;
+    /** {@inheritDoc IdempotencyCache.get} */
+    get(key: string): CachedActionResult | undefined;
+    /** {@inheritDoc IdempotencyCache.set} */
+    set(actionId: string, result: CachedActionResult, idempotencyKey?: string): void;
+    /** Evict expired entries and trim to max size (counting only non-idem entries). */
+    private evictStaleEntries;
+}
+
+/** @deprecated Use {@link IdempotencyCacheConfig} instead. */
+type ActionCacheConfig = IdempotencyCacheConfig;
 /**
  * Dispatches imperative actions to registered handlers.
  *
- * Manages idempotency via actionId deduplication and idempotencyKey mapping.
- * Caches are bounded by max size and TTL to prevent unbounded growth.
+ * Routing and handler management are separated from idempotency caching,
+ * which is delegated to an {@link IdempotencyCache} instance.
  * Completely decoupled from the HLC clock — takes a callback for timestamp generation.
  */
 declare class ActionDispatcher {
     private actionHandlers;
-    private executedActions;
-    private idempotencyMap;
-    private readonly maxCacheSize;
-    private readonly cacheTtlMs;
-    constructor(handlers?: Record<string, ActionHandler>, cacheConfig?: ActionCacheConfig);
+    private readonly 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?: Record<string, ActionHandler>, cacheConfig?: ActionCacheConfig, cache?: IdempotencyCache);
     /**
      * Dispatch an action push to registered handlers.
      *
@@ -69,12 +117,6 @@ declare class ActionDispatcher {
      * @returns An {@link ActionDiscovery} object listing connectors and their actions.
      */
     describe(): ActionDiscovery;
-    /** Cache an action result for idempotency deduplication. */
-    private cacheActionResult;
-    /** Get a cached result if it exists and hasn't expired. */
-    private getCachedResult;
-    /** Evict expired entries and trim to max size. */
-    private evictStaleEntries;
 }
 
 /**
@@ -174,12 +216,12 @@ declare class MemoryConfigStore implements ConfigStore {
  * Manages schema versioning and validation for the gateway.
  *
  * Validates incoming deltas against the current schema and supports
- * safe schema evolution (adding nullable columns only).
+ * safe schema evolution (adding nullable columns only). Schema, version,
+ * and allowed columns are held in a single {@link SchemaSnapshot} that
+ * is swapped atomically — no intermediate inconsistent state is possible.
  */
 declare class SchemaManager {
-    private currentSchema;
-    private version;
-    private allowedColumns;
+    private state;
     constructor(schema: TableSchema, version?: number);
     /** Get the current schema and version. */
     getSchema(): {
@@ -376,6 +418,8 @@ declare class SyncGateway implements IngestTarget {
      * @returns Array of registered source adapter names.
      */
     listSources(): string[];
+    /** Rehydrate the buffer with persisted deltas (bypasses push validation). */
+    rehydrate(deltas: ReadonlyArray<RowDelta>): void;
     /** Get per-table buffer statistics. */
     get tableStats(): Array<{
         table: string;
@@ -465,4 +509,4 @@ declare function handleListConnectorTypes(): HandlerResult;
  */
 declare function handleMetrics(gateway: SyncGateway, extra?: Record<string, unknown>): HandlerResult;
 
-export { type ActionCacheConfig as A, type BufferConfig as B, type ConfigStore as C, DeltaBuffer as D, type FlushEnvelope as F, type GatewayConfig as G, type HandlePushResult as H, MemoryConfigStore as M, SchemaManager as S, ActionDispatcher as a, type GatewayState as b, type HandlerResult as c, SyncGateway as d, handleFlushRequest as e, handleListConnectorTypes as f, handleListConnectors as g, handleActionRequest as h, handleMetrics as i, handlePullRequest as j, handlePushRequest as k, handleRegisterConnector as l, handleSaveSchema as m, handleSaveSyncRules as n, handleUnregisterConnector as o };
+export { type ActionCacheConfig as A, type BufferConfig as B, type CachedActionResult as C, DeltaBuffer as D, type FlushEnvelope as F, type GatewayConfig as G, type HandlePushResult as H, type IdempotencyCache as I, MemoryConfigStore as M, SchemaManager as S, ActionDispatcher as a, type ConfigStore as b, type GatewayState as c, type HandlerResult as d, type IdempotencyCacheConfig as e, MemoryIdempotencyCache as f, SyncGateway as g, handleActionRequest as h, handleFlushRequest as i, handleListConnectorTypes as j, handleListConnectors as k, handleMetrics as l, handlePullRequest as m, handlePushRequest as n, handleRegisterConnector as o, handleSaveSchema as p, handleSaveSyncRules as q, handleUnregisterConnector as r };

package/dist/{src-ROW4XLO7.js → src-WU7IBVC4.js}

@@ -42,14 +42,15 @@ import {
   getConnectorDescriptor,
   isActionError,
   isActionHandler,
+  isDatabaseAdapter,
   isIngestTarget,
+  isMaterialisable,
   isValidIdentifier,
   listConnectorDescriptors,
   mapResult,
   quoteIdentifier,
   registerConnectorDescriptor,
   registerOutputSchemas,
-  registerPollerFactory,
   resolveClientBuckets,
   resolveFilterValue,
   resolveLWW,
@@ -60,7 +61,7 @@ import {
   validateConnectorConfig,
   validateSyncRules,
   verifyToken
-} from "./chunk-LDFFCG2K.js";
+} from "./chunk-4SG66H5K.js";
 import "./chunk-DGUM43GV.js";
 export {
   ActionExecutionError,
@@ -106,14 +107,15 @@ export {
   getConnectorDescriptor,
   isActionError,
   isActionHandler,
+  isDatabaseAdapter,
   isIngestTarget,
+  isMaterialisable,
   isValidIdentifier,
   listConnectorDescriptors,
   mapResult,
   quoteIdentifier,
   registerConnectorDescriptor,
   registerOutputSchemas,
-  registerPollerFactory,
   resolveClientBuckets,
   resolveFilterValue,
   resolveLWW,
@@ -125,4 +127,4 @@ export {
   validateSyncRules,
   verifyToken
 };
-//# sourceMappingURL=src-ROW4XLO7.js.map
+//# sourceMappingURL=src-WU7IBVC4.js.map

package/dist/{types-BrcD1oJg.d.ts → types-D2C9jTbL.d.ts}

@@ -93,37 +93,47 @@ interface ConnectorIngestConfig {
     /** Approximate memory budget in bytes — triggers flush at 70%. */
     memoryBudgetBytes?: number;
 }
-/**
- * Configuration for a dynamically registered connector (data source).
- *
- * Discriminated union keyed on `type` — each variant carries exactly
- * its own connection config. No optional fields from other types.
- */
-type ConnectorConfig = {
-    type: "postgres";
+/** Base configuration shared by all connectors. */
+interface ConnectorConfigBase {
+    /** Connector type identifier. */
+    type: string;
+    /** Unique connector name. */
     name: string;
-    postgres: PostgresConnectorConfig;
+    /** Optional ingest polling configuration. */
     ingest?: ConnectorIngestConfig;
-} | {
+}
+/** Typed connector config for PostgreSQL. */
+interface PostgresConnectorConfigFull extends ConnectorConfigBase {
+    type: "postgres";
+    postgres: PostgresConnectorConfig;
+}
+/** Typed connector config for MySQL. */
+interface MySQLConnectorConfigFull extends ConnectorConfigBase {
     type: "mysql";
-    name: string;
     mysql: MySQLConnectorConfig;
-    ingest?: ConnectorIngestConfig;
-} | {
+}
+/** Typed connector config for BigQuery. */
+interface BigQueryConnectorConfigFull extends ConnectorConfigBase {
     type: "bigquery";
-    name: string;
     bigquery: BigQueryConnectorConfig;
-    ingest?: ConnectorIngestConfig;
-} | {
+}
+/** Typed connector config for Jira Cloud. */
+interface JiraConnectorConfigFull extends ConnectorConfigBase {
     type: "jira";
-    name: string;
     jira: JiraConnectorConfig;
-    ingest?: ConnectorIngestConfig;
-} | {
+}
+/** Typed connector config for Salesforce. */
+interface SalesforceConnectorConfigFull extends ConnectorConfigBase {
     type: "salesforce";
-    name: string;
     salesforce: SalesforceConnectorConfig;
-    ingest?: ConnectorIngestConfig;
-};
+}
+/**
+ * Configuration for a dynamically registered connector (data source).
+ *
+ * Union of known connector configs plus an open base for extensibility.
+ * Existing switch statements still work for known types; unknown types
+ * can pass through via the open base.
+ */
+type ConnectorConfig = PostgresConnectorConfigFull | MySQLConnectorConfigFull | BigQueryConnectorConfigFull | JiraConnectorConfigFull | SalesforceConnectorConfigFull | (ConnectorConfigBase & Record<string, unknown>);
 
-export { type BigQueryConnectorConfig as B, type ConnectorConfig as C, type JiraConnectorConfig as J, type MySQLConnectorConfig as M, type PostgresConnectorConfig as P, type SalesforceConnectorConfig as S, CONNECTOR_TYPES as a, type ConnectorIngestConfig as b, type ConnectorIngestTable as c, type ConnectorType as d };
+export { type BigQueryConnectorConfig as B, type ConnectorConfig as C, type JiraConnectorConfig as J, type MySQLConnectorConfig as M, type PostgresConnectorConfig as P, type SalesforceConnectorConfig as S, type BigQueryConnectorConfigFull as a, CONNECTOR_TYPES as b, type ConnectorConfigBase as c, type ConnectorIngestConfig as d, type ConnectorIngestTable as e, type ConnectorType as f, type JiraConnectorConfigFull as g, type MySQLConnectorConfigFull as h, type PostgresConnectorConfigFull as i, type SalesforceConnectorConfigFull as j };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "lakesync",
-	"version": "0.1.8",
+	"version": "0.2.0",
 	"type": "module",
 	"description": "Local-first sync engine with pluggable backends — Postgres, MySQL, BigQuery, S3/R2 via Apache Iceberg",
 	"license": "Apache-2.0",

package/dist/auth-CAVutXzx.d.ts

@@ -1,30 +0,0 @@
-import { R as Result } from './result-CojzlFE2.js';
-
-/** Claims extracted from a verified JWT token */
-interface AuthClaims {
-    /** Client identifier (from JWT `sub` claim) */
-    clientId: string;
-    /** Authorised gateway ID (from JWT `gw` claim) */
-    gatewayId: string;
-    /** Role for route-level access control (from JWT `role` claim, defaults to "client") */
-    role: string;
-    /** Non-standard JWT claims for sync rule evaluation */
-    customClaims: Record<string, string | string[]>;
-}
-/** Authentication error returned when JWT verification fails */
-declare class AuthError extends Error {
-    constructor(message: string);
-}
-/**
- * Verify a JWT token signed with HMAC-SHA256 and extract authentication claims.
- *
- * Uses the Web Crypto API exclusively (no external dependencies), making it
- * suitable for Cloudflare Workers and other edge runtimes.
- *
- * @param token - The raw JWT string (header.payload.signature)
- * @param secret - The HMAC-SHA256 secret key
- * @returns A Result containing AuthClaims on success, or AuthError on failure
- */
-declare function verifyToken(token: string, secret: string): Promise<Result<AuthClaims, AuthError>>;
-
-export { type AuthClaims as A, AuthError as a, verifyToken as v };