@firtoz/collection-sync 4.0.0 → 6.0.0

package/dist/react/range-conditions-expression.d.ts

@@ -0,0 +1,49 @@
+import { Ref } from '@tanstack/db';
+import { PartialSyncRowShape } from '../partial-sync-row-key.js';
+import { RangeCondition } from '../sync-protocol.js';
+import '@firtoz/db-helpers';
+import 'zod';
+
+declare abstract class BaseExpression<T = any> {
+    abstract type: string;
+    /** @internal - Type brand for TypeScript inference */
+    readonly __returnType: T;
+}
+declare class PropRef<T = any> extends BaseExpression<T> {
+    path: Array<string>;
+    type: "ref";
+    constructor(path: Array<string>);
+}
+declare class Value<T = any> extends BaseExpression<T> {
+    value: T;
+    type: "val";
+    constructor(value: T);
+}
+declare class Func<T = any> extends BaseExpression<T> {
+    name: string;
+    args: Array<BasicExpression>;
+    type: "func";
+    constructor(name: string, // such as eq, gt, lt, upper, lower, etc.
+    args: Array<BasicExpression>);
+}
+type BasicExpression<T = any> = PropRef<T> | Value<T> | Func<T>;
+
+/**
+ * Row ref from `q.from({ items: collection }).where(({ items }) => …)`.
+ * Column access must match {@link RangeCondition.column} names on the stored row shape.
+ *
+ * Uses TanStack {@link Ref} so column reads are `ExpressionLike` (e.g. for `inArray`), not `unknown`.
+ */
+type PredicateRowRef = Ref<PartialSyncRowShape & Record<string, unknown>>;
+/**
+ * Row accepted by {@link buildRangeConditionsAndExpression}: live query refs or plain objects (e.g. tests).
+ * Dynamic `column` access yields `unknown`, which TanStack comparison helpers still accept.
+ */
+type PredicateRangeBuildRow = PredicateRowRef | Record<string, unknown>;
+/**
+ * Builds a TanStack DB `where` expression AND-ing all conditions (same semantics as
+ * {@link matchesPredicate} for plain property rows).
+ */
+declare function buildRangeConditionsAndExpression(row: PredicateRangeBuildRow, conditions: RangeCondition[]): BasicExpression<boolean>;
+
+export { type PredicateRangeBuildRow, type PredicateRowRef, buildRangeConditionsAndExpression };

package/dist/react/range-conditions-expression.js

@@ -0,0 +1,4 @@
+export { buildRangeConditionsAndExpression } from '../chunk-43KYAIKY.js';
+import '../chunk-HMLY7DHA.js';
+//# sourceMappingURL=range-conditions-expression.js.map
+//# sourceMappingURL=range-conditions-expression.js.map

package/dist/react/range-conditions-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"range-conditions-expression.js"}

package/dist/react/types.d.ts

@@ -0,0 +1,196 @@
+import { UtilsRecord, Collection } from '@tanstack/db';
+import { CacheManager } from '../cache-manager.js';
+import { PartialSyncClientBridge, PartialSyncState, PartialSyncReconcileResult } from '../partial-sync-client-bridge.js';
+import { PartialSyncViewportAdapter } from './partial-sync-adapter.js';
+import { ConnectPartialSyncTransport } from '../connect-partial-sync.js';
+import { SyncClientBridge } from '../sync-client-bridge.js';
+import { PartialSyncRowShape } from '../partial-sync-row-key.js';
+export { PartialSyncRowRef, PartialSyncRowVersion } from '../partial-sync-row-key.js';
+import { SyncClientMessage, RangeCondition } from '../sync-protocol.js';
+import '@firtoz/db-helpers';
+import '../partial-sync-interest.js';
+import 'zod';
+
+/** Row shape for partial-sync React hooks (mandatory `updatedAt` for fingerprints / reconciliation). */
+type PartialSyncItem = PartialSyncRowShape;
+/**
+ * Minimal collection surface for partial-sync window hooks (TanStack `Collection` satisfies this
+ * when `get` / `entries` are typed consistently).
+ */
+type PartialSyncCollection<TItem extends PartialSyncItem> = {
+    get(key: string | number): TItem | undefined;
+    subscribeChanges(callback: (changes: unknown[]) => void, options?: {
+        includeInitialState?: boolean;
+    }): {
+        unsubscribe: () => void;
+    };
+    entries(): IterableIterator<[string | number, TItem]>;
+    /** TanStack collections use `UtilsRecord`; runtime must include `receiveSync` / `truncate`. */
+    utils: UtilsRecord;
+};
+type ViewportInfo = {
+    firstVisibleIndex: number;
+    lastVisibleIndex: number;
+};
+/** Per global row index: where the cell’s data comes from (for UI / debugging). */
+type PartialSyncRowSlot = "ready" | "ready_global" | "stale_map" | "server" | "none";
+type PartialSyncRowSlotView<TItem extends PartialSyncItem> = {
+    row: TItem | undefined;
+    slot: PartialSyncRowSlot;
+};
+type UsePartialSyncWindowOptions<TItem extends PartialSyncItem, TSortColumn extends keyof TItem & string = keyof TItem & string> = {
+    collection: PartialSyncCollection<TItem>;
+    sort: {
+        column: TSortColumn;
+        direction: "asc" | "desc";
+    };
+    getSortValue: (row: TItem, column: TSortColumn) => unknown;
+    wsUrl: string;
+    wsTransport?: ConnectPartialSyncTransport;
+    /** Use a module-level function or `useCallback`; inline arrows are a new reference every render. */
+    serializeJson?: (value: unknown) => string;
+    /** Use a module-level function or `useCallback`; inline arrows are a new reference every render. */
+    deserializeJson?: (raw: string) => unknown;
+    getVersionMs?: (row: TItem) => number;
+    getSortPositions?: (row: TItem) => Record<string, unknown>;
+    pageLimit?: number;
+    seekCooldownMs?: number;
+    /**
+     * Stable id for the **logical** collection instance (e.g. `${backend}-${roomId}`). The partial
+     * window resets (truncate + index map) when this or {@link sort} changes — **not** when the
+     * TanStack `collection` reference churns. Omit only if the collection instance is stable for the
+     * hook lifetime; otherwise local edits can spuriously reset the window.
+     */
+    partialWindowResetKey?: string;
+    /**
+     * When set, `mutateBatch` / ack / `syncBatch` route through this bridge; `clientId` matches
+     * {@link PartialSyncClientBridge}. Use with {@link createPartialSyncedCollection} / {@link withSync}.
+     */
+    mutationBridge?: SyncClientBridge<TItem>;
+    /**
+     * Called once when the WebSocket transport `send` is ready (same function {@link withSync} / mutation bridge use).
+     */
+    mergeTransportSend?: (send: (msg: SyncClientMessage) => void) => void;
+    /**
+     * Must match the server's partial-sync {@link PartialSyncServerBridgeOptions.collectionId} and align with
+     * {@link SyncClientBridgeOptions.collectionId} on {@link mutationBridge}.
+     */
+    collectionId?: string;
+    /**
+     * `confirmed` filters dense `rows` to {@link PartialSyncClientBridge.serverConfirmedKeys} only
+     * (same semantics as {@link UsePartialSyncViewportOptions.cacheDisplayMode}).
+     */
+    cacheDisplayMode?: CacheDisplayMode;
+};
+type UsePartialSyncWindowResult<TItem extends PartialSyncItem> = {
+    rows: TItem[];
+    windowStartIndex: number;
+    totalCount: number;
+    /**
+     * True while a server `requestRangeQuery` is in flight (cursor append or offset seek).
+     * False for cache-only window moves (`tryIds` / fingerprint `upToDate` without a round-trip).
+     */
+    rangeRequestInFlight: boolean;
+    hasMore: boolean;
+    bridgeState: PartialSyncState;
+    bridge: PartialSyncClientBridge<TItem>;
+    cacheManager: CacheManager<TItem>;
+    fetchNext: () => Promise<void>;
+    seekToViewport: (firstVisibleIndex: number, opts?: {
+        scrollSettled?: boolean;
+        lastVisibleIndex?: number;
+        /** Skip density/cooldown short-circuits (e.g. index map out of sync with collection). */
+        force?: boolean;
+    }) => void;
+    seekAfterScrollSettled: (firstVisibleIndex: number, lastVisibleIndex?: number) => void;
+    viewportInfo: ViewportInfo;
+    setViewportInfo: (info: ViewportInfo) => void;
+    lastSeekMeta: {
+        offset: number;
+        reason: "scroll" | "scrollSettled";
+    } | null;
+    /**
+     * Resolve one global index via index map + collection, and classify the cell.
+     * Use this for row UI so cached rows still render when the dense `rows` window has not caught up.
+     */
+    getRowSlot: (globalIndex: number) => PartialSyncRowSlotView<TItem>;
+};
+/** Collection usable with {@link useLiveQuery} and partial-sync helpers. */
+type PartialSyncLiveCollection<TItem extends PartialSyncItem> = PartialSyncCollection<TItem> & Collection<TItem, string | number, UtilsRecord>;
+type CacheDisplayMode = "immediate" | "confirmed";
+type UsePredicateFilteredRowsOptions<TItem extends PartialSyncItem, TSortColumn extends keyof TItem & string = keyof TItem & string> = {
+    collection: PartialSyncLiveCollection<TItem>;
+    conditions: RangeCondition[];
+    sort: {
+        column: TSortColumn;
+        direction: "asc" | "desc";
+    };
+    getSortValue: (row: TItem, column: TSortColumn) => unknown;
+    /**
+     * For predicate `column` strings when using a custom row shape; the live-query path reads
+     * properties named in {@link RangeCondition.column} on each row (same as default column read).
+     */
+    getColumnValue?: (row: TItem, column: string) => unknown;
+    limit?: number;
+    /**
+     * `immediate`: show all rows matching the predicate (including cache-only).
+     * `confirmed`: only rows whose keys appear in {@link confirmedRowKeys} (from the bridge).
+     */
+    cacheDisplayMode?: CacheDisplayMode;
+    /** Required when `cacheDisplayMode` is `"confirmed"`; typically `bridge.serverConfirmedKeys`. */
+    confirmedRowKeys?: ReadonlySet<string | number>;
+    /** Pass `bridge.serverConfirmedKeysRevision` so React re-runs the query when the set mutates. */
+    confirmedKeysRevision?: number;
+    /**
+     * Row ids that stay visible even when they no longer match the viewport predicate (union with
+     * predicate hits). Useful for in-progress drags or pinned selections. Rows must already exist
+     * in the local collection.
+     */
+    alwaysIncludeRowIds?: readonly string[];
+};
+type UsePartialSyncCollectionOptions<TItem extends PartialSyncItem> = {
+    collection: PartialSyncCollection<TItem>;
+    mutationBridge: SyncClientBridge<TItem>;
+    wsUrl: string;
+    wsTransport?: ConnectPartialSyncTransport;
+    serializeJson?: (value: unknown) => string;
+    deserializeJson?: (raw: string) => unknown;
+    mergeTransportSend?: (send: (msg: SyncClientMessage) => void) => void;
+    collectionId?: string;
+    beforeApplyRows?: (rows: TItem[]) => Promise<void>;
+};
+type UsePartialSyncCollectionResult<TItem extends PartialSyncItem> = {
+    bridge: PartialSyncClientBridge<TItem>;
+    bridgeState: PartialSyncState;
+};
+type UsePartialSyncViewportOptions<TItem extends PartialSyncItem, TViewport, TSortColumn extends keyof TItem & string> = {
+    bridge: PartialSyncClientBridge<TItem>;
+    /** From {@link usePartialSyncCollection}; drives {@link UsePartialSyncViewportResult.totalCount}. */
+    bridgeState: PartialSyncState;
+    collection: PartialSyncLiveCollection<TItem>;
+    adapter: PartialSyncViewportAdapter<TItem, TViewport, TSortColumn>;
+    viewport: TViewport;
+    predicateLimit: number;
+    prefetchPad?: number;
+    quietMs?: number;
+    maxWaitMs?: number;
+    /**
+     * Used when the bridge has not yet reported `totalCount` (e.g. world size for sparse grids).
+     */
+    totalCountFallback?: number;
+    getColumnValue?: (row: TItem, column: string) => unknown;
+    cacheDisplayMode?: CacheDisplayMode;
+    /**
+     * Ids to always include in {@link UsePartialSyncViewportResult.viewportRows} in addition to
+     * rows matching the viewport predicate (see {@link UsePredicateFilteredRowsOptions.alwaysIncludeRowIds}).
+     */
+    alwaysIncludeRowIds?: readonly string[];
+    /** After a successful manifest reconcile (re-entry with cached keys), receive `movedHints` etc. */
+    onRangeReconcile?: (result: PartialSyncReconcileResult<TItem>) => void;
+};
+type UsePartialSyncViewportResult<TItem extends PartialSyncItem> = {
+    viewportRows: TItem[];
+    totalCount: number;
+};
+
+export { type CacheDisplayMode, type PartialSyncCollection, type PartialSyncItem, type PartialSyncLiveCollection, PartialSyncRowShape, type PartialSyncRowSlot, type PartialSyncRowSlotView, type UsePartialSyncCollectionOptions, type UsePartialSyncCollectionResult, type UsePartialSyncViewportOptions, type UsePartialSyncViewportResult, type UsePartialSyncWindowOptions, type UsePartialSyncWindowResult, type UsePredicateFilteredRowsOptions, type ViewportInfo };

package/dist/react/types.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/react/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}

package/dist/react/usePartialSyncCollection.d.ts

@@ -0,0 +1,20 @@
+import { PartialSyncItem, UsePartialSyncCollectionOptions, UsePartialSyncCollectionResult } from './types.js';
+import '@tanstack/db';
+import '../cache-manager.js';
+import '../partial-sync-row-key.js';
+import '../partial-sync-client-bridge.js';
+import '@firtoz/db-helpers';
+import '../sync-protocol.js';
+import 'zod';
+import '../partial-sync-interest.js';
+import './partial-sync-adapter.js';
+import '../connect-partial-sync.js';
+import '../sync-client-bridge.js';
+
+/**
+ * WebSocket + {@link PartialSyncClientBridge} wiring shared by predicate viewports and custom UIs.
+ * Pair with {@link usePartialSyncViewport} for N-dimensional `rangeQuery` + local predicate rows.
+ */
+declare function usePartialSyncCollection<TItem extends PartialSyncItem>({ collection, mutationBridge, wsUrl, wsTransport, serializeJson, deserializeJson, mergeTransportSend, collectionId, beforeApplyRows, }: UsePartialSyncCollectionOptions<TItem>): UsePartialSyncCollectionResult<TItem>;
+
+export { usePartialSyncCollection };

package/dist/react/usePartialSyncCollection.js

@@ -0,0 +1,10 @@
+export { usePartialSyncCollection } from '../chunk-I6RJWBGF.js';
+import '../chunk-4BEXLBCH.js';
+import '../chunk-XC4QNFSQ.js';
+import '../chunk-P3JOTUAB.js';
+import '../chunk-BJJEAKXL.js';
+import '../chunk-3EHHMLSV.js';
+import '../chunk-UJ24XW52.js';
+import '../chunk-HMLY7DHA.js';
+//# sourceMappingURL=usePartialSyncCollection.js.map
+//# sourceMappingURL=usePartialSyncCollection.js.map

package/dist/react/usePartialSyncCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"usePartialSyncCollection.js"}

package/dist/react/usePartialSyncViewport.d.ts

@@ -0,0 +1,20 @@
+import { PartialSyncItem, UsePartialSyncViewportOptions, UsePartialSyncViewportResult } from './types.js';
+import '@tanstack/db';
+import '../cache-manager.js';
+import '../partial-sync-row-key.js';
+import '../partial-sync-client-bridge.js';
+import '@firtoz/db-helpers';
+import '../sync-protocol.js';
+import 'zod';
+import '../partial-sync-interest.js';
+import './partial-sync-adapter.js';
+import '../connect-partial-sync.js';
+import '../sync-client-bridge.js';
+
+/**
+ * Predicate viewport sync: debounced server `rangeQuery` for a moving logical viewport plus
+ * {@link usePredicateFilteredRows} for the visible rows already in the local collection.
+ */
+declare function usePartialSyncViewport<TItem extends PartialSyncItem, TViewport, TSortColumn extends keyof TItem & string>({ bridge, bridgeState, collection, adapter, viewport, predicateLimit, prefetchPad, quietMs, maxWaitMs, totalCountFallback, getColumnValue, cacheDisplayMode, alwaysIncludeRowIds, onRangeReconcile, }: UsePartialSyncViewportOptions<TItem, TViewport, TSortColumn>): UsePartialSyncViewportResult<TItem>;
+
+export { usePartialSyncViewport };

package/dist/react/usePartialSyncViewport.js

@@ -0,0 +1,7 @@
+export { usePartialSyncViewport } from '../chunk-BGJH6PH2.js';
+import '../chunk-YD5LVGWX.js';
+import '../chunk-43KYAIKY.js';
+import '../chunk-M5MJHS6A.js';
+import '../chunk-HMLY7DHA.js';
+//# sourceMappingURL=usePartialSyncViewport.js.map
+//# sourceMappingURL=usePartialSyncViewport.js.map

package/dist/react/usePartialSyncViewport.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"usePartialSyncViewport.js"}

package/dist/react/usePartialSyncWindow.d.ts

@@ -0,0 +1,17 @@
+import { PartialSyncItem, UsePartialSyncWindowOptions, UsePartialSyncWindowResult } from './types.js';
+export { DEFAULT_PAGE_LIMIT, DEFAULT_SEEK_COOLDOWN_MS, DEFAULT_SEEK_ROW_GAP, DEFAULT_VIEWPORT_RANGE_MAX_WAIT_MS, DEFAULT_VIEWPORT_RANGE_QUIET_MS } from './constants.js';
+import '@tanstack/db';
+import '../cache-manager.js';
+import '../partial-sync-row-key.js';
+import '../partial-sync-client-bridge.js';
+import '@firtoz/db-helpers';
+import '../sync-protocol.js';
+import 'zod';
+import '../partial-sync-interest.js';
+import './partial-sync-adapter.js';
+import '../connect-partial-sync.js';
+import '../sync-client-bridge.js';
+
+declare function usePartialSyncWindow<TItem extends PartialSyncItem, TSortColumn extends keyof TItem & string>({ collection, sort, getSortValue, wsUrl, wsTransport, serializeJson, deserializeJson, getVersionMs, getSortPositions, pageLimit, seekCooldownMs, partialWindowResetKey, mutationBridge, mergeTransportSend, collectionId, cacheDisplayMode, }: UsePartialSyncWindowOptions<TItem, TSortColumn>): UsePartialSyncWindowResult<TItem>;
+
+export { usePartialSyncWindow };

package/dist/react/usePartialSyncWindow.js

@@ -0,0 +1,12 @@
+export { usePartialSyncWindow } from '../chunk-O3KBDCEI.js';
+export { DEFAULT_PAGE_LIMIT, DEFAULT_SEEK_COOLDOWN_MS, DEFAULT_SEEK_ROW_GAP, DEFAULT_VIEWPORT_RANGE_MAX_WAIT_MS, DEFAULT_VIEWPORT_RANGE_QUIET_MS } from '../chunk-M5MJHS6A.js';
+import '../chunk-4BEXLBCH.js';
+import '../chunk-5V6BSQAB.js';
+import '../chunk-XC4QNFSQ.js';
+import '../chunk-P3JOTUAB.js';
+import '../chunk-BJJEAKXL.js';
+import '../chunk-3EHHMLSV.js';
+import '../chunk-UJ24XW52.js';
+import '../chunk-HMLY7DHA.js';
+//# sourceMappingURL=usePartialSyncWindow.js.map
+//# sourceMappingURL=usePartialSyncWindow.js.map

package/dist/react/usePartialSyncWindow.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"usePartialSyncWindow.js"}

package/dist/react/usePredicateFilteredRows.d.ts

@@ -0,0 +1,20 @@
+import { PartialSyncItem, UsePredicateFilteredRowsOptions } from './types.js';
+import '@tanstack/db';
+import '../cache-manager.js';
+import '../partial-sync-row-key.js';
+import '../partial-sync-client-bridge.js';
+import '@firtoz/db-helpers';
+import '../sync-protocol.js';
+import 'zod';
+import '../partial-sync-interest.js';
+import './partial-sync-adapter.js';
+import '../connect-partial-sync.js';
+import '../sync-client-bridge.js';
+
+/**
+ * Reactive predicate filter + sort + limit via TanStack DB `useLiveQuery` (IVM), instead of
+ * scanning the whole collection on each change.
+ */
+declare function usePredicateFilteredRows<TItem extends PartialSyncItem, TSortColumn extends keyof TItem & string>({ collection, conditions, sort, getSortValue, getColumnValue: _getColumnValue, limit, cacheDisplayMode, confirmedRowKeys, confirmedKeysRevision, alwaysIncludeRowIds, }: UsePredicateFilteredRowsOptions<TItem, TSortColumn>): TItem[];
+
+export { usePredicateFilteredRows };

package/dist/react/usePredicateFilteredRows.js

@@ -0,0 +1,6 @@
+export { usePredicateFilteredRows } from '../chunk-YD5LVGWX.js';
+import '../chunk-43KYAIKY.js';
+import '../chunk-M5MJHS6A.js';
+import '../chunk-HMLY7DHA.js';
+//# sourceMappingURL=usePredicateFilteredRows.js.map
+//# sourceMappingURL=usePredicateFilteredRows.js.map

package/dist/react/usePredicateFilteredRows.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"usePredicateFilteredRows.js"}

package/dist/sync-client-bridge.d.ts

@@ -0,0 +1,48 @@
+import { SyncMessage } from '@firtoz/db-helpers';
+import { PartialSyncRowShape } from './partial-sync-row-key.js';
+import { SyncClientMessage, SyncServerMessage } from './sync-protocol.js';
+import 'zod';
+
+type CollectionWithReceiveSync<TItem> = {
+    utils: {
+        receiveSync: (messages: SyncMessage<TItem>[]) => Promise<void>;
+    };
+};
+type SendFn = (msg: SyncClientMessage) => void;
+interface SyncClientBridgeOptions<TItem extends PartialSyncRowShape> {
+    clientId: string;
+    /** Must match the server's {@link SyncServerBridgeOptions.collectionId}. */
+    collectionId?: string;
+    collection: CollectionWithReceiveSync<TItem>;
+    send: SendFn;
+    initialLastAckedServerVersion?: number;
+    onLastAckedServerVersionChange?: (version: number) => void;
+    onRejectedMutation?: (reason: string, mutationId: string) => void;
+    /**
+     * When `false`, `setConnected(true)` does not send `syncHello` (partial-sync + `mutateBatch` only).
+     * Default `true` for full sync.
+     */
+    sendSyncHelloOnConnect?: boolean;
+}
+declare class SyncClientBridge<TItem extends PartialSyncRowShape> {
+    #private;
+    private readonly options;
+    readonly clientId: string;
+    readonly collectionId: string;
+    constructor(options: SyncClientBridgeOptions<TItem>);
+    get pendingCount(): number;
+    setConnected(connected: boolean): void;
+    /**
+     * Wire `collection.get` after the TanStack collection exists so mutation-path `receiveSync` can
+     * coerce duplicate `insert` echoes to `update` (partial sync + `mutateBatch`).
+     */
+    setRowGet(get: ((key: string | number) => TItem | undefined) | undefined): void;
+    sendHello(): void;
+    onLocalMutation(changes: SyncMessage<TItem>[]): void;
+    sendInsert(value: TItem): string;
+    sendUpdate(updated: TItem, previousValue: TItem): string;
+    sendDelete(key: string | number): string;
+    handleServerMessage(message: SyncServerMessage<TItem>): Promise<void>;
+}
+
+export { SyncClientBridge, type SyncClientBridgeOptions };

package/dist/sync-client-bridge.js

@@ -0,0 +1,6 @@
+export { SyncClientBridge } from './chunk-QJP4GSJH.js';
+import './chunk-BJJEAKXL.js';
+import './chunk-UJ24XW52.js';
+import './chunk-HMLY7DHA.js';
+//# sourceMappingURL=sync-client-bridge.js.map
+//# sourceMappingURL=sync-client-bridge.js.map

package/dist/sync-client-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"sync-client-bridge.js"}