lakesync 0.1.0

package/dist/react.js

@@ -0,0 +1,224 @@
+import "./chunk-7D4SUZUM.js";
+
+// ../react/src/context.ts
+import {
+  createContext,
+  createElement,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState
+} from "react";
+var LakeSyncContext = createContext(null);
+function LakeSyncProvider(props) {
+  const { coordinator, children } = props;
+  const [dataVersion, setDataVersion] = useState(0);
+  const invalidate = useCallback(() => {
+    setDataVersion((v) => v + 1);
+  }, []);
+  useEffect(() => {
+    const handleChange = () => {
+      setDataVersion((v) => v + 1);
+    };
+    coordinator.on("onChange", handleChange);
+    return () => {
+      coordinator.off("onChange", handleChange);
+    };
+  }, [coordinator]);
+  const value = useMemo(
+    () => ({
+      coordinator,
+      tracker: coordinator.tracker,
+      dataVersion,
+      invalidate
+    }),
+    [coordinator, dataVersion, invalidate]
+  );
+  return createElement(LakeSyncContext.Provider, { value }, children);
+}
+function useLakeSync() {
+  const ctx = useContext(LakeSyncContext);
+  if (!ctx) {
+    throw new Error("useLakeSync must be used within a <LakeSyncProvider>");
+  }
+  return ctx;
+}
+
+// ../react/src/use-action.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useState as useState2 } from "react";
+function useAction() {
+  const { coordinator } = useLakeSync();
+  const [lastResult, setLastResult] = useState2(null);
+  const [isPending, setIsPending] = useState2(false);
+  useEffect2(() => {
+    const handleComplete = (_actionId, result) => {
+      setLastResult(result);
+      setIsPending(false);
+    };
+    coordinator.on("onActionComplete", handleComplete);
+    return () => {
+      coordinator.off("onActionComplete", handleComplete);
+    };
+  }, [coordinator]);
+  const execute = useCallback2(
+    async (params) => {
+      setIsPending(true);
+      await coordinator.executeAction(params);
+    },
+    [coordinator]
+  );
+  return { execute, lastResult, isPending };
+}
+function useActionDiscovery() {
+  const { coordinator } = useLakeSync();
+  const [connectors, setConnectors] = useState2({});
+  const [isLoading, setIsLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const [trigger, setTrigger] = useState2(0);
+  const refetch = useCallback2(() => {
+    setTrigger((v) => v + 1);
+  }, []);
+  useEffect2(() => {
+    void trigger;
+    let cancelled = false;
+    const run = async () => {
+      setIsLoading(true);
+      const result = await coordinator.describeActions();
+      if (cancelled) return;
+      if (result.ok) {
+        setConnectors(result.value.connectors);
+        setError(null);
+      } else {
+        setError(result.error);
+      }
+      setIsLoading(false);
+    };
+    run();
+    return () => {
+      cancelled = true;
+    };
+  }, [coordinator, trigger]);
+  return { connectors, isLoading, error, refetch };
+}
+
+// ../react/src/use-mutation.ts
+import { useCallback as useCallback3 } from "react";
+function useMutation() {
+  const { tracker, invalidate } = useLakeSync();
+  const insert = useCallback3(
+    async (table, rowId, data) => {
+      const result = await tracker.insert(table, rowId, data);
+      if (result.ok) invalidate();
+      return result;
+    },
+    [tracker, invalidate]
+  );
+  const update = useCallback3(
+    async (table, rowId, data) => {
+      const result = await tracker.update(table, rowId, data);
+      if (result.ok) invalidate();
+      return result;
+    },
+    [tracker, invalidate]
+  );
+  const remove = useCallback3(
+    async (table, rowId) => {
+      const result = await tracker.delete(table, rowId);
+      if (result.ok) invalidate();
+      return result;
+    },
+    [tracker, invalidate]
+  );
+  return { insert, update, remove };
+}
+
+// ../react/src/use-query.ts
+import { useCallback as useCallback4, useEffect as useEffect3, useRef, useState as useState3 } from "react";
+function useQuery(sql, params) {
+  const { tracker, dataVersion } = useLakeSync();
+  const [data, setData] = useState3([]);
+  const [error, setError] = useState3(null);
+  const [isLoading, setIsLoading] = useState3(true);
+  const [manualTrigger, setManualTrigger] = useState3(0);
+  const paramsKey = JSON.stringify(params ?? []);
+  const paramsRef = useRef(params);
+  paramsRef.current = params;
+  const refetch = useCallback4(() => {
+    setManualTrigger((v) => v + 1);
+  }, []);
+  const version = `${dataVersion}:${manualTrigger}:${paramsKey}`;
+  useEffect3(() => {
+    void version;
+    let cancelled = false;
+    const run = async () => {
+      const result = await tracker.query(sql, paramsRef.current);
+      if (cancelled) return;
+      if (result.ok) {
+        setData(result.value);
+        setError(null);
+      } else {
+        setError(result.error);
+      }
+      setIsLoading(false);
+    };
+    run();
+    return () => {
+      cancelled = true;
+    };
+  }, [tracker, sql, version]);
+  return { data, error, isLoading, refetch };
+}
+
+// ../react/src/use-sync-status.ts
+import { useCallback as useCallback5, useEffect as useEffect4, useState as useState4 } from "react";
+function useSyncStatus() {
+  const { coordinator, dataVersion } = useLakeSync();
+  const [isSyncing, setIsSyncing] = useState4(false);
+  const [lastSyncTime, setLastSyncTime] = useState4(null);
+  const [queueDepth, setQueueDepth] = useState4(0);
+  const [error, setError] = useState4(null);
+  const refreshQueueDepth = useCallback5(async () => {
+    const depth = await coordinator.queueDepth();
+    setQueueDepth(depth);
+  }, [coordinator]);
+  useEffect4(() => {
+    const handleSyncComplete = () => {
+      setIsSyncing(false);
+      setLastSyncTime(coordinator.lastSyncTime);
+      setError(null);
+      refreshQueueDepth();
+    };
+    const handleError = (err) => {
+      setIsSyncing(false);
+      setError(err);
+    };
+    const handleChange = () => {
+      refreshQueueDepth();
+    };
+    coordinator.on("onSyncComplete", handleSyncComplete);
+    coordinator.on("onError", handleError);
+    coordinator.on("onChange", handleChange);
+    refreshQueueDepth();
+    return () => {
+      coordinator.off("onSyncComplete", handleSyncComplete);
+      coordinator.off("onError", handleError);
+      coordinator.off("onChange", handleChange);
+    };
+  }, [coordinator, refreshQueueDepth]);
+  useEffect4(() => {
+    void dataVersion;
+    refreshQueueDepth();
+  }, [dataVersion, refreshQueueDepth]);
+  return { isSyncing, lastSyncTime, queueDepth, error };
+}
+export {
+  LakeSyncProvider,
+  useAction,
+  useActionDiscovery,
+  useLakeSync,
+  useMutation,
+  useQuery,
+  useSyncStatus
+};
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../react/src/context.ts","../../react/src/use-action.ts","../../react/src/use-mutation.ts","../../react/src/use-query.ts","../../react/src/use-sync-status.ts"],"sourcesContent":["import type { SyncCoordinator, SyncTracker } from \"@lakesync/client\";\nimport {\n\tcreateContext,\n\tcreateElement,\n\tuseCallback,\n\tuseContext,\n\tuseEffect,\n\tuseMemo,\n\tuseState,\n} from \"react\";\n\n/** Internal context value shared across all hooks. */\nexport interface LakeSyncContextValue {\n\tcoordinator: SyncCoordinator;\n\ttracker: SyncTracker;\n\t/** Monotonically increasing counter — bumped on every data change. */\n\tdataVersion: number;\n\t/** Increment dataVersion to trigger query re-runs. */\n\tinvalidate: () => void;\n}\n\nconst LakeSyncContext = createContext<LakeSyncContextValue | null>(null);\n\n/** Props for the LakeSyncProvider component. */\nexport interface LakeSyncProviderProps {\n\t/** An already-constructed SyncCoordinator instance. */\n\tcoordinator: SyncCoordinator;\n\tchildren: React.ReactNode;\n}\n\n/**\n * Provides LakeSync context to the component tree.\n *\n * Subscribes to `onChange` events from the coordinator and maintains a\n * `dataVersion` counter that increments on every remote delta application,\n * triggering reactive query re-runs in `useQuery`.\n */\nexport function LakeSyncProvider(props: LakeSyncProviderProps) {\n\tconst { coordinator, children } = props;\n\tconst [dataVersion, setDataVersion] = useState(0);\n\n\tconst invalidate = useCallback(() => {\n\t\tsetDataVersion((v) => v + 1);\n\t}, []);\n\n\tuseEffect(() => {\n\t\tconst handleChange = () => {\n\t\t\tsetDataVersion((v) => v + 1);\n\t\t};\n\t\tcoordinator.on(\"onChange\", handleChange);\n\t\treturn () => {\n\t\t\tcoordinator.off(\"onChange\", handleChange);\n\t\t};\n\t}, [coordinator]);\n\n\tconst value = useMemo<LakeSyncContextValue>(\n\t\t() => ({\n\t\t\tcoordinator,\n\t\t\ttracker: coordinator.tracker,\n\t\t\tdataVersion,\n\t\t\tinvalidate,\n\t\t}),\n\t\t[coordinator, dataVersion, invalidate],\n\t);\n\n\treturn createElement(LakeSyncContext.Provider, { value }, children);\n}\n\n/**\n * Access the raw LakeSync SDK instances from context.\n *\n * @throws if called outside a `<LakeSyncProvider>`.\n */\nexport function useLakeSync(): LakeSyncContextValue {\n\tconst ctx = useContext(LakeSyncContext);\n\tif (!ctx) {\n\t\tthrow new Error(\"useLakeSync must be used within a <LakeSyncProvider>\");\n\t}\n\treturn ctx;\n}\n","import type {\n\tActionDescriptor,\n\tActionErrorResult,\n\tActionResult,\n\tLakeSyncError,\n} from \"@lakesync/core\";\nimport { useCallback, useEffect, useState } from \"react\";\nimport { useLakeSync } from \"./context\";\n\n/** Parameters for a single action execution. */\nexport interface ActionParams {\n\tconnector: string;\n\tactionType: string;\n\tparams: Record<string, unknown>;\n\tidempotencyKey?: string;\n}\n\n/** Return type of `useAction`. */\nexport interface UseActionResult {\n\t/** Execute an action against a connector via the gateway. */\n\texecute: (params: ActionParams) => Promise<void>;\n\t/** Last action result (success or error). Null before first execution. */\n\tlastResult: ActionResult | ActionErrorResult | null;\n\t/** Whether an action is currently in flight. */\n\tisPending: boolean;\n}\n\n/**\n * Execute imperative actions against external systems via the gateway.\n *\n * Wraps `SyncCoordinator.executeAction()` and subscribes to\n * `onActionComplete` events to track the latest result.\n *\n * ```ts\n * const { execute, lastResult, isPending } = useAction();\n *\n * await execute({\n *   connector: \"slack\",\n *   actionType: \"send_message\",\n *   params: { channel: \"#general\", text: \"Hello\" },\n * });\n * ```\n */\nexport function useAction(): UseActionResult {\n\tconst { coordinator } = useLakeSync();\n\tconst [lastResult, setLastResult] = useState<ActionResult | ActionErrorResult | null>(null);\n\tconst [isPending, setIsPending] = useState(false);\n\n\tuseEffect(() => {\n\t\tconst handleComplete = (_actionId: string, result: ActionResult | ActionErrorResult) => {\n\t\t\tsetLastResult(result);\n\t\t\tsetIsPending(false);\n\t\t};\n\n\t\tcoordinator.on(\"onActionComplete\", handleComplete);\n\t\treturn () => {\n\t\t\tcoordinator.off(\"onActionComplete\", handleComplete);\n\t\t};\n\t}, [coordinator]);\n\n\tconst execute = useCallback(\n\t\tasync (params: ActionParams): Promise<void> => {\n\t\t\tsetIsPending(true);\n\t\t\tawait coordinator.executeAction(params);\n\t\t},\n\t\t[coordinator],\n\t);\n\n\treturn { execute, lastResult, isPending };\n}\n\n/** Return type of `useActionDiscovery`. */\nexport interface UseActionDiscoveryResult {\n\t/** Map of connector name to supported action descriptors. */\n\tconnectors: Record<string, ActionDescriptor[]>;\n\t/** Whether discovery is loading. */\n\tisLoading: boolean;\n\t/** Error from the last fetch, or null. */\n\terror: LakeSyncError | null;\n\t/** Manually re-fetch available actions. */\n\trefetch: () => void;\n}\n\n/**\n * Discover available connectors and their supported action types.\n *\n * Calls `transport.describeActions()` on mount and returns the result\n * reactively. Use this to build dynamic UI based on available actions.\n *\n * ```ts\n * const { connectors, isLoading } = useActionDiscovery();\n *\n * for (const [name, actions] of Object.entries(connectors)) {\n *   console.log(name, actions.map(a => a.actionType));\n * }\n * ```\n */\nexport function useActionDiscovery(): UseActionDiscoveryResult {\n\tconst { coordinator } = useLakeSync();\n\tconst [connectors, setConnectors] = useState<Record<string, ActionDescriptor[]>>({});\n\tconst [isLoading, setIsLoading] = useState(true);\n\tconst [error, setError] = useState<LakeSyncError | null>(null);\n\tconst [trigger, setTrigger] = useState(0);\n\n\tconst refetch = useCallback(() => {\n\t\tsetTrigger((v) => v + 1);\n\t}, []);\n\n\tuseEffect(() => {\n\t\tvoid trigger;\n\t\tlet cancelled = false;\n\n\t\tconst run = async () => {\n\t\t\tsetIsLoading(true);\n\t\t\tconst result = await coordinator.describeActions();\n\t\t\tif (cancelled) return;\n\n\t\t\tif (result.ok) {\n\t\t\t\tsetConnectors(result.value.connectors);\n\t\t\t\tsetError(null);\n\t\t\t} else {\n\t\t\t\tsetError(result.error);\n\t\t\t}\n\t\t\tsetIsLoading(false);\n\t\t};\n\n\t\trun();\n\n\t\treturn () => {\n\t\t\tcancelled = true;\n\t\t};\n\t}, [coordinator, trigger]);\n\n\treturn { connectors, isLoading, error, refetch };\n}\n","import type { LakeSyncError, Result } from \"@lakesync/core\";\nimport { useCallback } from \"react\";\nimport { useLakeSync } from \"./context\";\n\n/** Return type of `useMutation`. */\nexport interface UseMutationResult {\n\tinsert: (\n\t\ttable: string,\n\t\trowId: string,\n\t\tdata: Record<string, unknown>,\n\t) => Promise<Result<void, LakeSyncError>>;\n\tupdate: (\n\t\ttable: string,\n\t\trowId: string,\n\t\tdata: Record<string, unknown>,\n\t) => Promise<Result<void, LakeSyncError>>;\n\tremove: (table: string, rowId: string) => Promise<Result<void, LakeSyncError>>;\n}\n\n/**\n * Wraps SyncTracker mutations with automatic query invalidation.\n *\n * After each successful mutation, `dataVersion` is incremented so all\n * active `useQuery` hooks re-run.\n */\nexport function useMutation(): UseMutationResult {\n\tconst { tracker, invalidate } = useLakeSync();\n\n\tconst insert = useCallback(\n\t\tasync (\n\t\t\ttable: string,\n\t\t\trowId: string,\n\t\t\tdata: Record<string, unknown>,\n\t\t): Promise<Result<void, LakeSyncError>> => {\n\t\t\tconst result = await tracker.insert(table, rowId, data);\n\t\t\tif (result.ok) invalidate();\n\t\t\treturn result;\n\t\t},\n\t\t[tracker, invalidate],\n\t);\n\n\tconst update = useCallback(\n\t\tasync (\n\t\t\ttable: string,\n\t\t\trowId: string,\n\t\t\tdata: Record<string, unknown>,\n\t\t): Promise<Result<void, LakeSyncError>> => {\n\t\t\tconst result = await tracker.update(table, rowId, data);\n\t\t\tif (result.ok) invalidate();\n\t\t\treturn result;\n\t\t},\n\t\t[tracker, invalidate],\n\t);\n\n\tconst remove = useCallback(\n\t\tasync (table: string, rowId: string): Promise<Result<void, LakeSyncError>> => {\n\t\t\tconst result = await tracker.delete(table, rowId);\n\t\t\tif (result.ok) invalidate();\n\t\t\treturn result;\n\t\t},\n\t\t[tracker, invalidate],\n\t);\n\n\treturn { insert, update, remove };\n}\n","import type { DbError } from \"@lakesync/client\";\nimport { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useLakeSync } from \"./context\";\n\n/** Return type of `useQuery`. */\nexport interface UseQueryResult<T> {\n\tdata: T[];\n\terror: DbError | null;\n\tisLoading: boolean;\n\trefetch: () => void;\n}\n\n/**\n * Reactive SQL query hook.\n *\n * Re-runs automatically when:\n * - Remote deltas are applied (via `onChange`)\n * - A local mutation completes (via `invalidate()`)\n * - The `sql` or `params` arguments change\n *\n * @param sql - SQL query string\n * @param params - Optional bind parameters\n */\nexport function useQuery<T>(sql: string, params?: unknown[]): UseQueryResult<T> {\n\tconst { tracker, dataVersion } = useLakeSync();\n\tconst [data, setData] = useState<T[]>([]);\n\tconst [error, setError] = useState<DbError | null>(null);\n\tconst [isLoading, setIsLoading] = useState(true);\n\tconst [manualTrigger, setManualTrigger] = useState(0);\n\n\t// Stable serialisation of params for dependency comparison\n\tconst paramsKey = JSON.stringify(params ?? []);\n\tconst paramsRef = useRef(params);\n\tparamsRef.current = params;\n\n\tconst refetch = useCallback(() => {\n\t\tsetManualTrigger((v) => v + 1);\n\t}, []);\n\n\t// Combine all trigger values into a single version for the effect.\n\t// This satisfies exhaustive-deps: the effect reads `version` directly.\n\tconst version = `${dataVersion}:${manualTrigger}:${paramsKey}`;\n\n\tuseEffect(() => {\n\t\t// Read version to establish dependency\n\t\tvoid version;\n\t\tlet cancelled = false;\n\n\t\tconst run = async () => {\n\t\t\tconst result = await tracker.query<T>(sql, paramsRef.current);\n\t\t\tif (cancelled) return;\n\n\t\t\tif (result.ok) {\n\t\t\t\tsetData(result.value);\n\t\t\t\tsetError(null);\n\t\t\t} else {\n\t\t\t\tsetError(result.error);\n\t\t\t}\n\t\t\tsetIsLoading(false);\n\t\t};\n\n\t\trun();\n\n\t\treturn () => {\n\t\t\tcancelled = true;\n\t\t};\n\t}, [tracker, sql, version]);\n\n\treturn { data, error, isLoading, refetch };\n}\n","import { useCallback, useEffect, useState } from \"react\";\nimport { useLakeSync } from \"./context\";\n\n/** Return type of `useSyncStatus`. */\nexport interface UseSyncStatusResult {\n\tisSyncing: boolean;\n\tlastSyncTime: Date | null;\n\tqueueDepth: number;\n\terror: Error | null;\n}\n\n/**\n * Observe the sync lifecycle.\n *\n * Tracks whether a sync is in progress, last successful sync time,\n * outbox queue depth, and the most recent sync error (cleared on success).\n */\nexport function useSyncStatus(): UseSyncStatusResult {\n\tconst { coordinator, dataVersion } = useLakeSync();\n\tconst [isSyncing, setIsSyncing] = useState(false);\n\tconst [lastSyncTime, setLastSyncTime] = useState<Date | null>(null);\n\tconst [queueDepth, setQueueDepth] = useState(0);\n\tconst [error, setError] = useState<Error | null>(null);\n\n\tconst refreshQueueDepth = useCallback(async () => {\n\t\tconst depth = await coordinator.queueDepth();\n\t\tsetQueueDepth(depth);\n\t}, [coordinator]);\n\n\tuseEffect(() => {\n\t\tconst handleSyncComplete = () => {\n\t\t\tsetIsSyncing(false);\n\t\t\tsetLastSyncTime(coordinator.lastSyncTime);\n\t\t\tsetError(null);\n\t\t\trefreshQueueDepth();\n\t\t};\n\n\t\tconst handleError = (err: Error) => {\n\t\t\tsetIsSyncing(false);\n\t\t\tsetError(err);\n\t\t};\n\n\t\tconst handleChange = () => {\n\t\t\trefreshQueueDepth();\n\t\t};\n\n\t\tcoordinator.on(\"onSyncComplete\", handleSyncComplete);\n\t\tcoordinator.on(\"onError\", handleError);\n\t\tcoordinator.on(\"onChange\", handleChange);\n\n\t\t// Initial queue depth\n\t\trefreshQueueDepth();\n\n\t\treturn () => {\n\t\t\tcoordinator.off(\"onSyncComplete\", handleSyncComplete);\n\t\t\tcoordinator.off(\"onError\", handleError);\n\t\t\tcoordinator.off(\"onChange\", handleChange);\n\t\t};\n\t}, [coordinator, refreshQueueDepth]);\n\n\t// Also refresh queue depth when dataVersion changes (local mutations)\n\tuseEffect(() => {\n\t\tvoid dataVersion;\n\t\trefreshQueueDepth();\n\t}, [dataVersion, refreshQueueDepth]);\n\n\treturn { isSyncing, lastSyncTime, queueDepth, error };\n}\n"],"mappings":"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","names":["useCallback","useEffect","useState","useState","useEffect","useCallback","useCallback","useCallback","useCallback","useEffect","useState","useState","useCallback","useEffect","useCallback","useEffect","useState","useState","useCallback","useEffect"]}

package/dist/resolver-C3Wphi6O.d.ts

@@ -0,0 +1,10 @@
+import { R as RowDelta } from './types-V_jVu2sA.js';
+import { R as Result, C as ConflictError } from './result-CojzlFE2.js';
+
+/** Strategy for resolving conflicting row deltas */
+interface ConflictResolver {
+    /** Resolve two conflicting deltas for the same row, returning the merged result */
+    resolve(local: RowDelta, remote: RowDelta): Result<RowDelta, ConflictError>;
+}
+
+export type { ConflictResolver as C };

package/dist/result-CojzlFE2.d.ts

@@ -0,0 +1,64 @@
+/** Base error class for all LakeSync errors */
+declare class LakeSyncError extends Error {
+    readonly code: string;
+    readonly cause?: Error;
+    constructor(message: string, code: string, cause?: Error);
+}
+/** Clock drift exceeds maximum allowed threshold */
+declare class ClockDriftError extends LakeSyncError {
+    constructor(message: string, cause?: Error);
+}
+/** Conflict resolution failure */
+declare class ConflictError extends LakeSyncError {
+    constructor(message: string, cause?: Error);
+}
+/** Flush operation failure */
+declare class FlushError extends LakeSyncError {
+    constructor(message: string, cause?: Error);
+}
+/** Schema mismatch or validation failure */
+declare class SchemaError extends LakeSyncError {
+    constructor(message: string, cause?: Error);
+}
+/** Lake adapter operation failure */
+declare class AdapterError extends LakeSyncError {
+    constructor(message: string, cause?: Error);
+}
+/** Named source adapter not found in gateway configuration */
+declare class AdapterNotFoundError extends LakeSyncError {
+    constructor(message: string, cause?: Error);
+}
+/** Buffer backpressure limit exceeded — push rejected to prevent OOM. */
+declare class BackpressureError extends LakeSyncError {
+    constructor(message: string, cause?: Error);
+}
+/** Coerce an unknown thrown value into an Error instance. */
+declare function toError(err: unknown): Error;
+
+/** HLC timestamp: 64-bit value with [48-bit wall clock ms][16-bit logical counter] */
+type HLCTimestamp = bigint & {
+    readonly __brand: "HLCTimestamp";
+};
+
+/** Discriminated union representing either success or failure */
+type Result<T, E = LakeSyncError> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+/** Create a successful Result */
+declare function Ok<T>(value: T): Result<T, never>;
+/** Create a failed Result */
+declare function Err<E>(error: E): Result<never, E>;
+/** Transform the success value of a Result */
+declare function mapResult<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+/** Chain Result-returning operations */
+declare function flatMapResult<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
+/** Extract the value from a Result or throw the error */
+declare function unwrapOrThrow<T, E>(result: Result<T, E>): T;
+/** Wrap a Promise into a Result */
+declare function fromPromise<T>(promise: Promise<T>): Promise<Result<T, Error>>;
+
+export { AdapterError as A, BackpressureError as B, ConflictError as C, Err as E, FlushError as F, type HLCTimestamp as H, LakeSyncError as L, Ok as O, type Result as R, SchemaError as S, AdapterNotFoundError as a, ClockDriftError as b, fromPromise as c, flatMapResult as f, mapResult as m, toError as t, unwrapOrThrow as u };