lakesync 0.1.5 → 0.1.8

package/dist/gateway.d.ts

@@ -1,47 +1,17 @@
 import { S as SyncRulesConfig, R as ResolvedClaims, b as SyncRulesContext, i as ActionPush } from './types-Bs-QyOe-.js';
 export { d as ActionDiscovery, g as ActionHandler, j as ActionResponse, l as AuthContext } from './types-Bs-QyOe-.js';
-export { I as IngestTarget, i as isIngestTarget } from './base-poller-CBvhdvcj.js';
-import { T as TableSchema, R as RowDelta, b as SyncPull, S as SyncPush } from './types-GGBfZBKQ.js';
-export { c as SyncResponse } from './types-GGBfZBKQ.js';
+export { I as IngestTarget, i as isIngestTarget } from './base-poller-Bj9kX9dv.js';
+import { T as TableSchema, R as RowDelta, e as SyncPull, S as SyncPush } from './types-BdGBv2ba.js';
+export { f as SyncResponse } from './types-BdGBv2ba.js';
 export { b as bigintReplacer, a as bigintReviver } from './json-dYtqiL0F.js';
-import { S as SyncGateway } from './gateway-CvO7Xy3T.js';
-export { A as ActionDispatcher, B as BufferConfig, D as DeltaBuffer, F as FlushEnvelope, G as GatewayConfig, a as GatewayState, H as HandlePushResult, b as SchemaManager } from './gateway-CvO7Xy3T.js';
-import { C as ConnectorConfig } from './types-D-E0VrfS.js';
+import { D as DeltaBuffer } from './request-handler-pUvL7ozF.js';
+export { A as ActionCacheConfig, a as ActionDispatcher, B as BufferConfig, C as ConfigStore, F as FlushEnvelope, G as GatewayConfig, b as GatewayState, H as HandlePushResult, c as HandlerResult, M as MemoryConfigStore, S as SchemaManager, d as SyncGateway, h as handleActionRequest, e as handleFlushRequest, f as handleListConnectorTypes, g as handleListConnectors, i as handleMetrics, j as handlePullRequest, k as handlePushRequest, l as handleRegisterConnector, m as handleSaveSchema, n as handleSaveSyncRules, o as handleUnregisterConnector } from './request-handler-pUvL7ozF.js';
 import { R as Result, F as FlushError, H as HLCTimestamp } from './result-CojzlFE2.js';
-import { D as DatabaseAdapter } from './db-types-B6_JKQWK.js';
+import { D as DatabaseAdapter } from './db-types-CfLMUBfW.js';
 import { L as LakeAdapter } from './types-DSC_EiwR.js';
 import { N as NessieCatalogueClient } from './nessie-client-DrNikVXy.js';
 import './hlc-DiD8QNG3.js';
-
-/**
- * Platform-agnostic configuration storage interface.
- *
- * Implemented by MemoryConfigStore (tests, gateway-server) and
- * DurableStorageConfigStore (gateway-worker).
- */
-interface ConfigStore {
-    getSchema(gatewayId: string): Promise<TableSchema | undefined>;
-    setSchema(gatewayId: string, schema: TableSchema): Promise<void>;
-    getSyncRules(gatewayId: string): Promise<SyncRulesConfig | undefined>;
-    setSyncRules(gatewayId: string, rules: SyncRulesConfig): Promise<void>;
-    getConnectors(): Promise<Record<string, ConnectorConfig>>;
-    setConnectors(connectors: Record<string, ConnectorConfig>): Promise<void>;
-}
-/**
- * In-memory implementation of ConfigStore.
- * Used by tests and gateway-server.
- */
-declare class MemoryConfigStore implements ConfigStore {
-    private schemas;
-    private syncRules;
-    private connectors;
-    getSchema(gatewayId: string): Promise<TableSchema | undefined>;
-    setSchema(gatewayId: string, schema: TableSchema): Promise<void>;
-    getSyncRules(gatewayId: string): Promise<SyncRulesConfig | undefined>;
-    setSyncRules(gatewayId: string, rules: SyncRulesConfig): Promise<void>;
-    getConnectors(): Promise<Record<string, ConnectorConfig>>;
-    setConnectors(connectors: Record<string, ConnectorConfig>): Promise<void>;
-}
+import './types-BrcD1oJg.js';
 
 /** Maximum push payload size (1 MiB). */
 declare const MAX_PUSH_PAYLOAD_BYTES = 1048576;
@@ -51,8 +21,8 @@ declare const MAX_DELTAS_PER_PUSH = 10000;
 declare const MAX_PULL_LIMIT = 10000;
 /** Default number of deltas returned in a pull when no limit is specified. */
 declare const DEFAULT_PULL_LIMIT = 100;
-/** Allowed column types for schema validation. */
-declare const VALID_COLUMN_TYPES: Set<string>;
+/** Allowed column types for schema validation. Derived from core COLUMN_TYPES. */
+declare const VALID_COLUMN_TYPES: ReadonlySet<string>;
 /** Default maximum buffer size before triggering flush (4 MiB). */
 declare const DEFAULT_MAX_BUFFER_BYTES: number;
 /** Default maximum buffer age before triggering flush (30 seconds). */
@@ -92,80 +62,67 @@ declare function flushEntries(entries: RowDelta[], byteSize: number, deps: Flush
  */
 declare function commitToCatalogue(objectKey: string, fileSizeInBytes: number, recordCount: number, catalogue: NessieCatalogueClient, schema: TableSchema): Promise<void>;
 
-/** Result from a request handler, ready for platform-specific serialisation. */
-interface HandlerResult {
-    status: number;
-    body: unknown;
+/** Dependencies for flush operations. */
+interface FlushCoordinatorDeps {
+    /** Gateway configuration for flush. */
+    config: FlushConfig;
+    /** Table schemas for materialisation after flush. */
+    schemas?: ReadonlyArray<TableSchema>;
 }
 /**
- * Handle a push request.
+ * Coordinates flush operations from the buffer to the adapter.
  *
- * @param gateway - The SyncGateway instance.
- * @param raw - The raw request body string.
- * @param headerClientId - Client ID from auth header (for mismatch check).
- * @param opts - Optional callbacks for persistence and broadcast.
- */
-declare function handlePushRequest(gateway: SyncGateway, raw: string, headerClientId?: string | null, opts?: {
-    /** Persist deltas before processing (WAL-style). */
-    persistBatch?: (deltas: RowDelta[]) => void;
-    /** Clear persisted deltas after successful push. */
-    clearPersistence?: () => void;
-    /** Broadcast deltas to connected clients. */
-    broadcastFn?: (deltas: RowDelta[], serverHlc: HLCTimestamp, excludeClientId: string) => void | Promise<void>;
-}): HandlerResult;
-/**
- * Handle a pull request.
- */
-declare function handlePullRequest(gateway: SyncGateway, params: {
-    since: string | null;
-    clientId: string | null;
-    limit: string | null;
-    source: string | null;
-}, claims?: ResolvedClaims, syncRules?: SyncRulesConfig): Promise<HandlerResult>;
-/**
- * Handle an action request.
- */
-declare function handleActionRequest(gateway: SyncGateway, raw: string, headerClientId?: string | null, claims?: ResolvedClaims): Promise<HandlerResult>;
-/**
- * Handle a flush request.
- */
-declare function handleFlushRequest(gateway: SyncGateway, opts?: {
-    clearPersistence?: () => void;
-}): Promise<HandlerResult>;
-/**
- * Handle saving a table schema.
- */
-declare function handleSaveSchema(raw: string, store: ConfigStore, gatewayId: string): Promise<HandlerResult>;
-/**
- * Handle saving sync rules.
- */
-declare function handleSaveSyncRules(raw: string, store: ConfigStore, gatewayId: string): Promise<HandlerResult>;
-/**
- * Handle registering a connector.
- */
-declare function handleRegisterConnector(raw: string, store: ConfigStore): Promise<HandlerResult>;
-/**
- * Handle unregistering a connector.
- */
-declare function handleUnregisterConnector(name: string, store: ConfigStore): Promise<HandlerResult>;
-/**
- * Handle listing connectors.
- */
-declare function handleListConnectors(store: ConfigStore): Promise<HandlerResult>;
-/**
- * Handle listing available connector types (static metadata).
- */
-declare function handleListConnectorTypes(): HandlerResult;
+ * Owns the flushing state to prevent concurrent flushes and handles
+ * entry restoration on failure.
+ */
+declare class FlushCoordinator {
+    private flushing;
+    /** Whether a flush is currently in progress. */
+    get isFlushing(): boolean;
+    /**
+     * 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.
+     */
+    flush(buffer: DeltaBuffer, adapter: LakeAdapter | DatabaseAdapter | null, deps: FlushCoordinatorDeps): Promise<Result<void, FlushError>>;
+    /**
+     * 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.
+     */
+    flushTable(table: string, buffer: DeltaBuffer, adapter: LakeAdapter | DatabaseAdapter | null, deps: FlushCoordinatorDeps): Promise<Result<void, FlushError>>;
+    /** Restore drained entries back to the buffer for retry. */
+    private restoreEntries;
+}
+
 /**
- * Handle metrics request.
- */
-declare function handleMetrics(gateway: SyncGateway, extra?: Record<string, unknown>): HandlerResult;
+ * Registry for named source adapters used in adapter-sourced pulls.
+ *
+ * Manages the mapping of source names to DatabaseAdapter instances,
+ * decoupling source adapter management from the gateway.
+ */
+declare class SourceRegistry {
+    private sources;
+    constructor(initial?: Record<string, DatabaseAdapter>);
+    /** Register a named source adapter. */
+    register(name: string, adapter: DatabaseAdapter): void;
+    /** Unregister a named source adapter. */
+    unregister(name: string): void;
+    /** Get a source adapter by name, or undefined if not registered. */
+    get(name: string): DatabaseAdapter | undefined;
+    /** List all registered source adapter names. */
+    list(): string[];
+}
 
 /** Validation error with HTTP status code. */
 interface RequestError {
     status: number;
     message: string;
 }
+/** Parse a JSON string, returning Err on invalid JSON. */
+declare function parseJson<T>(raw: string, reviver?: (key: string, value: unknown) => unknown): Result<T, RequestError>;
 /**
  * Validate and parse a push request body.
  * Handles JSON parsing with bigint revival.
@@ -198,4 +155,4 @@ declare function pushErrorToStatus(code: string): number;
  */
 declare function buildSyncRulesContext(rules: SyncRulesConfig | undefined, claims: ResolvedClaims): SyncRulesContext | undefined;
 
-export { ActionPush, type ConfigStore, DEFAULT_MAX_BUFFER_AGE_MS, DEFAULT_MAX_BUFFER_BYTES, DEFAULT_PULL_LIMIT, type FlushConfig, type FlushDeps, type HandlerResult, MAX_DELTAS_PER_PUSH, MAX_PULL_LIMIT, MAX_PUSH_PAYLOAD_BYTES, MemoryConfigStore, type RequestError, SyncGateway, SyncPull, SyncPush, VALID_COLUMN_TYPES, buildSyncRulesContext, commitToCatalogue, flushEntries, handleActionRequest, handleFlushRequest, handleListConnectorTypes, handleListConnectors, handleMetrics, handlePullRequest, handlePushRequest, handleRegisterConnector, handleSaveSchema, handleSaveSyncRules, handleUnregisterConnector, hlcRange, parsePullParams, pushErrorToStatus, validateActionBody, validatePushBody, validateSchemaBody };
+export { ActionPush, DEFAULT_MAX_BUFFER_AGE_MS, DEFAULT_MAX_BUFFER_BYTES, DEFAULT_PULL_LIMIT, DeltaBuffer, type FlushConfig, FlushCoordinator, type FlushCoordinatorDeps, type FlushDeps, MAX_DELTAS_PER_PUSH, MAX_PULL_LIMIT, MAX_PUSH_PAYLOAD_BYTES, type RequestError, SourceRegistry, SyncPull, SyncPush, VALID_COLUMN_TYPES, buildSyncRulesContext, commitToCatalogue, flushEntries, hlcRange, parseJson, parsePullParams, pushErrorToStatus, validateActionBody, validatePushBody, validateSchemaBody };

package/dist/gateway.js

@@ -4,11 +4,13 @@ import {
   DEFAULT_MAX_BUFFER_BYTES,
   DEFAULT_PULL_LIMIT,
   DeltaBuffer,
+  FlushCoordinator,
   MAX_DELTAS_PER_PUSH,
   MAX_PULL_LIMIT,
   MAX_PUSH_PAYLOAD_BYTES,
   MemoryConfigStore,
   SchemaManager,
+  SourceRegistry,
   SyncGateway,
   VALID_COLUMN_TYPES,
   buildSyncRulesContext,
@@ -26,32 +28,35 @@ import {
   handleSaveSyncRules,
   handleUnregisterConnector,
   hlcRange,
+  parseJson,
   parsePullParams,
   pushErrorToStatus,
   validateActionBody,
   validatePushBody,
   validateSchemaBody
-} from "./chunk-PWGQ3PXE.js";
-import "./chunk-Z7FGLEQU.js";
-import "./chunk-B3QEUG6E.js";
-import "./chunk-46CKACNC.js";
+} from "./chunk-JI4C4R5H.js";
+import "./chunk-LPWXOYNS.js";
+import "./chunk-TMLG32QV.js";
+import "./chunk-SSICS5KI.js";
 import {
   bigintReplacer,
   bigintReviver,
   isIngestTarget
-} from "./chunk-7UBS6MFH.js";
-import "./chunk-7D4SUZUM.js";
+} from "./chunk-LDFFCG2K.js";
+import "./chunk-DGUM43GV.js";
 export {
   ActionDispatcher,
   DEFAULT_MAX_BUFFER_AGE_MS,
   DEFAULT_MAX_BUFFER_BYTES,
   DEFAULT_PULL_LIMIT,
   DeltaBuffer,
+  FlushCoordinator,
   MAX_DELTAS_PER_PUSH,
   MAX_PULL_LIMIT,
   MAX_PUSH_PAYLOAD_BYTES,
   MemoryConfigStore,
   SchemaManager,
+  SourceRegistry,
   SyncGateway,
   VALID_COLUMN_TYPES,
   bigintReplacer,
@@ -72,6 +77,7 @@ export {
   handleUnregisterConnector,
   hlcRange,
   isIngestTarget,
+  parseJson,
   parsePullParams,
   pushErrorToStatus,
   validateActionBody,

package/dist/index.d.ts

@@ -3,14 +3,14 @@ export { c as ActionDescriptor, d as ActionDiscovery, e as ActionErrorResult, f
 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-CBvhdvcj.js';
-export { I as IngestTarget, a as PollerMemoryConfig, i as isIngestTarget } from './base-poller-CBvhdvcj.js';
-import { S as SyncPush, R as RowDelta, T as TableSchema } from './types-GGBfZBKQ.js';
-export { C as ColumnDelta, D as DeltaOp, a as RowKey, b as SyncPull, c as SyncResponse, r as rowKey } from './types-GGBfZBKQ.js';
-import { C as ConflictResolver } from './resolver-BZURzdlL.js';
-export { C as ConnectorCategory, a as ConnectorDescriptor, g as getConnectorDescriptor, l as listConnectorDescriptors, r as registerConnectorDescriptor, b as registerOutputSchemas } from './registry-BN_9spxE.js';
-import { C as ConnectorConfig } from './types-D-E0VrfS.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-D-E0VrfS.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 { 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 { H as HLC } from './hlc-DiD8QNG3.js';
 export { b as bigintReplacer, a as bigintReviver } from './json-dYtqiL0F.js';
 
@@ -104,6 +104,17 @@ declare function validateConnectorConfig(input: unknown): Result<ConnectorConfig
 
 /** 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
@@ -113,9 +124,12 @@ declare function registerPollerFactory(type: string, factory: PollerFactory): vo
 /**
  * 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): BaseSourcePoller;
+declare function createPoller(config: ConnectorConfig, gateway: PushTarget, registry?: PollerRegistry): BaseSourcePoller;
 
 /**
  * Apply a delta to an existing row, returning the merged result.
@@ -153,6 +167,27 @@ declare function extractDelta(before: Record<string, unknown> | null | undefined
     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.
+ */
+declare class PollingScheduler {
+    private readonly pollFn;
+    private readonly intervalMs;
+    private timer;
+    private running;
+    constructor(pollFn: () => Promise<void>, intervalMs: number);
+    /** Start the polling loop. No-op if already running. */
+    start(): void;
+    /** Stop the polling loop. */
+    stop(): void;
+    /** Whether the scheduler is currently running. */
+    get isRunning(): boolean;
+    /** Execute a single poll cycle without the timer loop. */
+    pollOnce(): Promise<void>;
+    private schedule;
+}
+
 /**
  * Create a pass-all sync rules configuration.
  *
@@ -270,4 +305,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, PushTarget, ResolvedClaims, Result, RowDelta, SchemaError, SyncPush, SyncRuleError, SyncRulesConfig, SyncRulesContext, TableSchema, applyDelta, assertValidIdentifier, createPassAllRules, createPoller, createUserScopedRules, deltaMatchesBucket, extractDelta, filterDeltas, generateActionId, isValidIdentifier, quoteIdentifier, registerPollerFactory, resolveClientBuckets, resolveFilterValue, resolveLWW, validateAction, validateConnectorConfig, validateSyncRules };
+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 };

package/dist/index.js

@@ -7,8 +7,10 @@ import {
   AuthError,
   BackpressureError,
   BaseSourcePoller,
+  COLUMN_TYPES,
   CONNECTOR_TYPES,
   CallbackPushTarget,
+  ChunkedPusher,
   ClockDriftError,
   ConflictError,
   ConnectorValidationError,
@@ -18,14 +20,18 @@ import {
   LWWResolver,
   LakeSyncError,
   Ok,
+  PollingScheduler,
+  PressureManager,
   SchemaError,
   SyncRuleError,
   applyDelta,
   assertValidIdentifier,
   bigintReplacer,
   bigintReviver,
+  createConnectorRegistry,
   createPassAllRules,
   createPoller,
+  createPollerRegistry,
   createUserScopedRules,
   deltaMatchesBucket,
   extractDelta,
@@ -54,8 +60,8 @@ import {
   validateConnectorConfig,
   validateSyncRules,
   verifyToken
-} from "./chunk-7UBS6MFH.js";
-import "./chunk-7D4SUZUM.js";
+} from "./chunk-LDFFCG2K.js";
+import "./chunk-DGUM43GV.js";
 export {
   ActionExecutionError,
   ActionNotSupportedError,
@@ -65,8 +71,10 @@ export {
   AuthError,
   BackpressureError,
   BaseSourcePoller,
+  COLUMN_TYPES,
   CONNECTOR_TYPES,
   CallbackPushTarget,
+  ChunkedPusher,
   ClockDriftError,
   ConflictError,
   ConnectorValidationError,
@@ -76,14 +84,18 @@ export {
   LWWResolver,
   LakeSyncError,
   Ok,
+  PollingScheduler,
+  PressureManager,
   SchemaError,
   SyncRuleError,
   applyDelta,
   assertValidIdentifier,
   bigintReplacer,
   bigintReviver,
+  createConnectorRegistry,
   createPassAllRules,
   createPoller,
+  createPollerRegistry,
   createUserScopedRules,
   deltaMatchesBucket,
   extractDelta,

package/dist/parquet.d.ts

@@ -1,4 +1,4 @@
-import { T as TableSchema, R as RowDelta } from './types-GGBfZBKQ.js';
+import { T as TableSchema, R as RowDelta } from './types-BdGBv2ba.js';
 import * as arrow from 'apache-arrow';
 import { R as Result, F as FlushError } from './result-CojzlFE2.js';
 

package/dist/parquet.js

@@ -3,9 +3,9 @@ import {
   deltasToArrowTable,
   readParquetToDeltas,
   writeDeltasToParquet
-} from "./chunk-46CKACNC.js";
-import "./chunk-7UBS6MFH.js";
-import "./chunk-7D4SUZUM.js";
+} from "./chunk-SSICS5KI.js";
+import "./chunk-LDFFCG2K.js";
+import "./chunk-DGUM43GV.js";
 export {
   buildArrowSchema,
   deltasToArrowTable,

package/dist/proto.d.ts

@@ -1,6 +1,6 @@
 import { H as HLCTimestamp, R as Result } from './result-CojzlFE2.js';
 import { i as ActionPush$1, j as ActionResponse$1 } from './types-Bs-QyOe-.js';
-import { R as RowDelta$1 } from './types-GGBfZBKQ.js';
+import { R as RowDelta$1 } from './types-BdGBv2ba.js';
 import { GenMessage, GenEnum } from '@bufbuild/protobuf/codegenv2';
 import { Message } from '@bufbuild/protobuf';
 

package/dist/proto.js

@@ -29,9 +29,9 @@ import {
   encodeSyncPull,
   encodeSyncPush,
   encodeSyncResponse
-} from "./chunk-L4ZL5JA7.js";
-import "./chunk-7UBS6MFH.js";
-import "./chunk-7D4SUZUM.js";
+} from "./chunk-KVSWLIJR.js";
+import "./chunk-LDFFCG2K.js";
+import "./chunk-DGUM43GV.js";
 export {
   ActionPushSchema,
   ActionResponseSchema,

package/dist/react.d.ts

@@ -1,21 +1,30 @@
 import * as react from 'react';
-import { b as SyncCoordinator, j as SyncTracker, D as DbError } from './coordinator-DN8D8C7W.js';
+import { b as SyncCoordinator, k as SyncTracker, D as DbError } from './coordinator-NXy6tA0h.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-BN_9spxE.js';
+import { a as ConnectorDescriptor } from './registry-BcspAtZI.js';
 import './hlc-DiD8QNG3.js';
-import './types-GGBfZBKQ.js';
-import './types-D-E0VrfS.js';
+import './types-BdGBv2ba.js';
+import './types-BrcD1oJg.js';
 
-/** Internal context value shared across all hooks. */
-interface LakeSyncContextValue {
+/** Stable context value — coordinator and tracker references that never change. */
+interface LakeSyncStableContextValue {
     coordinator: SyncCoordinator;
     tracker: SyncTracker;
+}
+/** Reactive context value — data version that changes on every delta. */
+interface LakeSyncDataContextValue {
     /** Monotonically increasing counter — bumped on every data change. */
     dataVersion: number;
     /** Increment dataVersion to trigger query re-runs. */
     invalidate: () => void;
 }
+/**
+ * Combined context value for backwards compatibility.
+ * @see useLakeSync
+ */
+interface LakeSyncContextValue extends LakeSyncStableContextValue, LakeSyncDataContextValue {
+}
 /** Props for the LakeSyncProvider component. */
 interface LakeSyncProviderProps {
     /** An already-constructed SyncCoordinator instance. */
@@ -28,11 +37,32 @@ interface LakeSyncProviderProps {
  * Subscribes to `onChange` events from the coordinator and maintains a
  * `dataVersion` counter that increments on every remote delta application,
  * triggering reactive query re-runs in `useQuery`.
+ *
+ * Uses a split context pattern: stable refs (coordinator, tracker) are
+ * provided separately from reactive data (dataVersion) so that hooks
+ * like `useSyncStatus` and `useAction` do not re-render on data changes.
+ */
+declare function LakeSyncProvider(props: LakeSyncProviderProps): react.FunctionComponentElement<react.ProviderProps<LakeSyncStableContextValue | null>>;
+/**
+ * Access the stable LakeSync SDK instances from context.
+ *
+ * This hook does NOT cause re-renders when dataVersion changes.
+ * Use {@link useLakeSyncData} for reactive data.
+ *
+ * @throws if called outside a `<LakeSyncProvider>`.
+ */
+declare function useLakeSyncStable(): LakeSyncStableContextValue;
+/**
+ * Access reactive data (dataVersion, invalidate) from context.
+ *
+ * @throws if called outside a `<LakeSyncProvider>`.
  */
-declare function LakeSyncProvider(props: LakeSyncProviderProps): react.FunctionComponentElement<react.ProviderProps<LakeSyncContextValue | null>>;
+declare function useLakeSyncData(): LakeSyncDataContextValue;
 /**
  * Access the raw LakeSync SDK instances from context.
  *
+ * Returns both stable and reactive values for backwards compatibility.
+ *
  * @throws if called outside a `<LakeSyncProvider>`.
  */
 declare function useLakeSync(): LakeSyncContextValue;
@@ -59,6 +89,12 @@ interface UseActionResult {
  * Wraps `SyncCoordinator.executeAction()` and subscribes to
  * `onActionComplete` events to track the latest result.
  *
+ * Uses a `pendingRef` to track whether we are waiting for a completion.
+ * When `execute()` is called, we set the ref to `true` so the next
+ * `onActionComplete` event is captured. This avoids the identity bug
+ * where a stale action completion from a different hook instance would
+ * overwrite state.
+ *
  * ```ts
  * const { execute, lastResult, isPending } = useAction();
  *
@@ -168,9 +204,10 @@ interface UseSyncStatusResult {
 /**
  * Observe the sync lifecycle.
  *
- * Tracks whether a sync is in progress, last successful sync time,
- * outbox queue depth, and the most recent sync error (cleared on success).
+ * Reads `coordinator.state` directly for sync status and subscribes to
+ * events only for invalidation (re-reading the state snapshot).
+ * Uses the stable context so it does not re-render on data version changes.
  */
 declare function useSyncStatus(): UseSyncStatusResult;
 
-export { type ActionParams, type LakeSyncContextValue, LakeSyncProvider, type LakeSyncProviderProps, type UseActionDiscoveryResult, type UseActionResult, type UseConnectorTypesResult, type UseMutationResult, type UseQueryResult, type UseSyncStatusResult, useAction, useActionDiscovery, useConnectorTypes, useLakeSync, useMutation, useQuery, useSyncStatus };
+export { type ActionParams, type LakeSyncContextValue, type LakeSyncDataContextValue, LakeSyncProvider, type LakeSyncProviderProps, type LakeSyncStableContextValue, type UseActionDiscoveryResult, type UseActionResult, type UseConnectorTypesResult, type UseMutationResult, type UseQueryResult, type UseSyncStatusResult, useAction, useActionDiscovery, useConnectorTypes, useLakeSync, useLakeSyncData, useLakeSyncStable, useMutation, useQuery, useSyncStatus };