cross-tab-worker-databus 0.1.0

package/dist/core/data-bus.d.ts

@@ -0,0 +1,133 @@
+import type { WorkerClusterOptions } from './cluster';
+import type { DataBusErrorHandler, DataBusMessageHandler, DataBusStatusHandler, DataBusTransport, WorkerStatus } from './types';
+import type { DataBusTraceOptions } from './trace';
+export interface CrossTabDataBusOptions<TConfig, TData> extends Omit<WorkerClusterOptions, 'handlers'> {
+    transport: DataBusTransport<TConfig, TData>;
+    initialConfig?: TConfig;
+    autoStart?: boolean;
+    trace?: DataBusTraceOptions;
+}
+/**
+ * High-level cross-tab pub/sub client.
+ *
+ * Orchestrates a transport (e.g. Centrifuge WebSocket inside a Worker) and a
+ * WorkerClusterRuntime for cross-tab coordination. Messages arriving from the
+ * transport are fanned out to all tabs in the cluster and dispatched locally
+ * to registered handlers.
+ */
+export declare class CrossTabDataBus<TConfig = unknown, TData = unknown> {
+    private readonly transport;
+    private readonly cluster;
+    private readonly topicHandlers;
+    private readonly transportSubscribedTopics;
+    private readonly statusHandlers;
+    private readonly errorHandlers;
+    private readonly initialConfig;
+    private readonly hasInitialConfig;
+    private readonly trace;
+    private activeConfig;
+    private status;
+    private started;
+    private stopping;
+    private transportReady;
+    private lastError;
+    private startPromise;
+    private lastRecoveryAt;
+    private suspended;
+    private pendingStop;
+    private static readonly RECOVERY_COOLDOWN_MS;
+    constructor(options: CrossTabDataBusOptions<TConfig, TData>);
+    /**
+     * Start the DataBus with the given transport config.
+     *
+     * The first call starts the cluster and opens the transport. Concurrent calls
+     * during an in-flight start return the same promise. Once the operation
+     * settles (success or failure) the promise gate is cleared so a subsequent
+     * start() or resumeTransport() can open a fresh lifecycle.
+     */
+    start(config: TConfig): Promise<void>;
+    /**
+     * Open the transport, chained after `before` to ensure lifecycle ordering.
+     * When `stopClusterOnFailure` is true (initial start), a transport failure
+     * tears down the cluster as well.
+     */
+    private openTransport;
+    /**
+     * Await the DataBus to be fully started (lazy init when using initialConfig).
+     * Returns a rejected promise when the transport has failed and no start is in
+     * flight — the caller can retry by calling start() or ready() again.
+     */
+    ready(): Promise<void>;
+    /**
+     * Register a handler for `topic`. The handler fires on every publication
+     * delivered to this tab, regardless of which tab published it. Returns an
+     * unsubscribe function for convenience.
+     */
+    subscribe(topic: string, handler: DataBusMessageHandler<TData>): () => void;
+    /** Remove a specific handler, or all handlers for `topic`. */
+    unsubscribe(topic: string, handler?: DataBusMessageHandler<TData>): void;
+    /** Publish a message to `topic`. The owning Worker delivers it to the transport. */
+    publish(topic: string, data: unknown): void;
+    /** Register a handler that fires on every transport status change. Immediately invoked with the current status. */
+    onStatus(handler: DataBusStatusHandler): () => void;
+    /** Register a handler for transport errors. */
+    onError(handler: DataBusErrorHandler): () => void;
+    /** Current transport connection status. */
+    getStatus(): WorkerStatus;
+    /** Snapshot of the cluster state (workers, routes, assignments). */
+    getClusterSnapshot(): import("./cluster").WorkerClusterSnapshot;
+    /**
+     * Gracefully stop the DataBus: unsubscribe all topics, stop the cluster,
+     * and close the transport. Idempotent.
+     */
+    stop(): Promise<void>;
+    /**
+     * Incoming message from the transport.
+     * Records metrics, checks ownership via the cluster, broadcasts to other tabs,
+     * and dispatches locally.
+     */
+    private handleTransportMessage;
+    /** Deliver a message to every local handler registered for its topic. */
+    private dispatch;
+    /**
+     * Propagate a status change to the cluster, trace, and all registered
+     * status handlers. On reconnect, re-subscribe any topics assigned to us.
+     */
+    private updateStatus;
+    private reportError;
+    private traceSubscription;
+    /** Ask the transport to subscribe to a topic (idempotent). */
+    private subscribeTransport;
+    private unsubscribeTransport;
+    /**
+     * Suspend the transport when the tab goes hidden. Stops the transport and
+     * clears subscription state so it will be re-established on resume.
+     */
+    private suspendTransport;
+    /**
+     * Resume the transport when the tab becomes visible again, or recover from a
+     * runtime transport failure. Re-opens the transport with the stored active
+     * config, chained after any pending operation so an async transport stop
+     * completes before the new start. Returns the opening promise.
+     */
+    private resumeTransport;
+    /**
+     * Re-open the transport with the previously stored active config. Chains
+     * after any in-flight lifecycle operation (e.g. a suspend stop), swallowing
+     * its rejection so the reopen is not blocked. Returns the opening promise so
+     * callers can queue operations behind it.
+     */
+    private reopenTransport;
+    /**
+     * Run a transport operation now if the transport is ready, otherwise queue
+     * it behind the start promise. This ensures subscribe/unsubscribe calls made
+     * during startup are not lost.
+     */
+    private runTransport;
+    /**
+     * Ensure the DataBus is started, throwing if no initialConfig was provided.
+     * Called automatically by subscribe/publish/ready when autoStart is true.
+     */
+    private ensureStarted;
+}
+//# sourceMappingURL=data-bus.d.ts.map

package/dist/core/data-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-bus.d.ts","sourceRoot":"","sources":["../../src/core/data-bus.ts"],"names":[],"mappings":"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"}

package/dist/core/environment.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Browser environment adapters — storage, BroadcastChannel, timers, lifecycle.
+ *
+ * Separates platform-specific APIs from the core coordination logic so the
+ * same Runtime can run in a browser, in a test, or in an embedded context
+ * with custom adapters injected via `ClusterEnvironment`.
+ */
+import type { TabVisibilityState, WorkerClusterMessage } from './types';
+/** Minimal storage interface compatible with both localStorage and MemoryStorage. */
+export interface StorageLike {
+    readonly length: number;
+    clear(): void;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
+    removeItem(key: string): void;
+    setItem(key: string, value: string): void;
+}
+/** Minimal BroadcastChannel interface. The cluster uses it for control messages and event fan-out. */
+export interface ClusterChannel {
+    addEventListener(type: 'message', listener: (event: MessageEvent<WorkerClusterMessage>) => void): void;
+    removeEventListener(type: 'message', listener: (event: MessageEvent<WorkerClusterMessage>) => void): void;
+    postMessage(message: WorkerClusterMessage): void;
+    close(): void;
+}
+/**
+ * Environment abstraction that lets the cluster operate in Node, SSR, or
+ * test environments without touching browser globals directly.
+ * Tests inject a fake environment to control timing, storage, and lifecycle.
+ */
+export interface ClusterEnvironment {
+    /** localStorage (or null if unavailable). */
+    storage: StorageLike | null;
+    /** sessionStorage (or null if unavailable). Used for stable tab IDs. */
+    sessionStorage: StorageLike | null;
+    now: () => number;
+    randomId: () => string;
+    createChannel: (name: string) => ClusterChannel | null;
+    setInterval: (callback: () => void, intervalMs: number) => unknown;
+    clearInterval: (handle: unknown) => void;
+    getVisibilityState: () => TabVisibilityState;
+    addVisibilityChangeListener: (listener: () => void) => void;
+    removeVisibilityChangeListener: (listener: () => void) => void;
+    addPageHideListener: (listener: () => void) => void;
+    removePageHideListener: (listener: () => void) => void;
+    addPageShowListener: (listener: () => void) => void;
+    removePageShowListener: (listener: () => void) => void;
+}
+/**
+ * Default environment adapter for browser runtimes.
+ * Probes for localStorage, BroadcastChannel, document, and window APIs
+ * and gracefully returns null / no-ops when they are absent (SSR, Node).
+ */
+export declare function createBrowserEnvironment(): ClusterEnvironment;
+/**
+ * Probe a storage instance with a write-read-delete round-trip.
+ * Returns a type guard so the caller can narrow the type after a successful check.
+ * Catches quota errors, disabled-storage, or opaque exceptions.
+ */
+export declare function canUseStorage(storage: StorageLike | null, probeKey: string): storage is StorageLike;
+/**
+ * Get-or-create a stable tab ID stored in sessionStorage.
+ * sessionStorage is scoped to the tab and survives refresh, so the same tab
+ * retains its identity across the page lifecycle without coordination overhead.
+ * Falls back to a random ID when sessionStorage is unavailable.
+ */
+export declare function getOrCreateTabId(environment: ClusterEnvironment, key?: string): string;
+//# sourceMappingURL=environment.d.ts.map

package/dist/core/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/core/environment.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAExE,qFAAqF;AACrF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,KAAK,IAAI,IAAI,CAAC;IACd,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACpC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAClC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C;AAED,sGAAsG;AACtG,MAAM,WAAW,cAAc;IAC7B,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,oBAAoB,CAAC,KAAK,IAAI,GAAG,IAAI,CAAC;IACvG,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,oBAAoB,CAAC,KAAK,IAAI,GAAG,IAAI,CAAC;IAC1G,WAAW,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACjD,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,6CAA6C;IAC7C,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5B,wEAAwE;IACxE,cAAc,EAAE,WAAW,GAAG,IAAI,CAAC;IACnC,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,MAAM,CAAC;IACvB,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,cAAc,GAAG,IAAI,CAAC;IACvD,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IACnE,aAAa,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACzC,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;IAC7C,2BAA2B,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IAC5D,8BAA8B,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IAC/D,mBAAmB,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACpD,sBAAsB,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACvD,mBAAmB,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACpD,sBAAsB,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;CACxD;AAuBD;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,kBAAkB,CAoC7D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,IAAI,WAAW,CASnG;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,kBAAkB,EAC/B,GAAG,SAAoC,GACtC,MAAM,CAqBR"}

package/dist/core/hash.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Derives a stable 128-bit hex key from a string.
+ *
+ * This is a non-cryptographic four-way hash (inspired by MurmurHash-style
+ * mixing). It exists so connection URLs and topic plaintext never touch
+ * localStorage or BroadcastChannel namespaces — consumers only ever see the
+ * opaque key. It trades collision resistance for speed and zero dependencies:
+ * use `crypto.subtle.digest` if you need a cryptographic hash.
+ */
+export declare function createOpaqueKey(value: string): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/core/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/core/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAyBrD"}

package/dist/core/routing.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Routing primitives for topic-owner selection and rebalancing.
+ *
+ * Pure functions that select candidate Workers, compute the least-loaded
+ * owner, and decide when to migrate a topic. All side-effect-free, making
+ * them straightforward to test and reason about.
+ */
+import type { WorkerRecord, WorkerRoute } from './types';
+/** Default cap on the number of Workers that can own topics concurrently. */
+export declare const DEFAULT_MAX_ACTIVE_WORKERS = 3;
+/**
+ * Pick the Worker with the fewest owned topics, optionally preferring a
+ * specific sticky owner when it is still in the candidate set.
+ * Uses a single reduce pass instead of a full sort — O(n) — and breaks
+ * load ties by workerId for deterministic routing across tabs.
+ */
+export declare function selectLeastLoadedWorker(workers: readonly WorkerRecord[], preferredWorkerId?: string): WorkerRecord | undefined;
+/**
+ * Select the (up to `maxActiveWorkers`) Workers eligible to own topics.
+ *
+ * Eligibility cascade:
+ * 1. Only `connecting` / `connected` workers are candidates.
+ * 2. If any candidate is visible, prefer visible tabs (hidden tabs yield as owner).
+ * 3. Fall back to all available workers when none is visible, so the cluster
+ *    does not stall when every tab is in the background.
+ * 4. Tie-break by registration time, then workerId, for determinism.
+ */
+export declare function selectActiveWorkers(workers: readonly WorkerRecord[], maxActiveWorkers?: number): WorkerRecord[];
+/**
+ * Decide whether `currentWorkerId` should hand one topic to a less-loaded peer.
+ * Returns the target Worker only when its load gap is significant (more than
+ * one topic lighter), so the cluster does not churn over a single-topic
+ * imbalance. One topic is migrated per reconciliation round to avoid thrashing.
+ *
+ * This remains exported as a standalone routing utility for API compatibility.
+ * WorkerClusterRuntime intentionally does not use it: established routes are
+ * sticky and load balancing applies only when selecting a new owner.
+ */
+export declare function selectRebalanceTarget(workers: readonly WorkerRecord[], currentWorkerId: string): WorkerRecord | null;
+/** True when a route's owner is still a live, active Worker in the given set. */
+export declare function hasActiveOwner(route: WorkerRoute | null, workers: readonly WorkerRecord[]): boolean;
+//# sourceMappingURL=routing.d.ts.map

package/dist/core/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/core/routing.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEzD,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,iBAAiB,CAAC,EAAE,MAAM,GACzB,YAAY,GAAG,SAAS,CAS1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,gBAAgB,SAA6B,GAC5C,YAAY,EAAE,CAWhB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,eAAe,EAAE,MAAM,GACtB,YAAY,GAAG,IAAI,CAYrB;AAED,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,EAAE,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAEnG"}

package/dist/core/storage-batch.d.ts

@@ -0,0 +1,35 @@
+/**
+ * BatchingStorageWriter — coalesced, resilient localStorage writes.
+ *
+ * Decorates a StorageLike with write coalescing: mutations within the same task
+ * are merged by key and flushed once via a microtask, with exponential backoff
+ * on quota/failure. Keeps the coordination metadata writes off the hot path.
+ */
+import type { StorageLike } from './environment';
+/**
+ * Coalesces synchronous storage writes and applies them in one pass, with
+ * exponential backoff when the underlying storage rejects a write.
+ */
+export declare class BatchingStorageWriter implements StorageLike {
+    private readonly storage;
+    /** Coalesced write set. A `null` value represents a pending delete. */
+    private readonly pending;
+    private flushScheduled;
+    private retryHandle;
+    private retryDelayMs;
+    constructor(storage: StorageLike);
+    get pendingSize(): number;
+    get length(): number;
+    clear(): void;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
+    removeItem(key: string): void;
+    setItem(key: string, value: string): void;
+    flush(): void;
+    /** Union of persisted keys and pending writes, minus pending deletes. */
+    private keys;
+    private scheduleFlush;
+    private scheduleRetry;
+    private cancelRetry;
+}
+//# sourceMappingURL=storage-batch.d.ts.map

package/dist/core/storage-batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-batch.d.ts","sourceRoot":"","sources":["../../src/core/storage-batch.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAKjD;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,WAAW;IAO3C,OAAO,CAAC,QAAQ,CAAC,OAAO;IANpC,uEAAuE;IACvE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAC5D,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,WAAW,CAA8C;IACjE,OAAO,CAAC,YAAY,CAA0B;gBAEjB,OAAO,EAAE,WAAW;IAEjD,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,KAAK,IAAI,IAAI;IAYb,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAKnC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIjC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAK7B,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAKzC,KAAK,IAAI,IAAI;IAoBb,yEAAyE;IACzE,OAAO,CAAC,IAAI;IAeZ,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,WAAW;CAMpB"}

package/dist/core/trace.d.ts

@@ -0,0 +1,126 @@
+/**
+ * DataBusTraceReporter — optional diagnostics, metrics, and delivery latency.
+ *
+ * Aggregates message throughput and dispatch latency over configurable windows,
+ * emitting structured events (lifecycle, status, subscription, coordination,
+ * error) and periodic metrics summaries. The sink is decoupled from the hot
+ * message path — errors in the sink are isolated to console.warn.
+ */
+import type { WorkerStatus } from './types';
+/** Trace reporting mode: record only events, only metrics, or both. */
+export type DataBusTraceMode = 'events' | 'metrics' | 'all';
+/** Emitted when the DataBus starts, stops, suspends, or resumes. */
+export interface DataBusLifecycleTraceEvent {
+    type: 'lifecycle';
+    action: 'start' | 'stop' | 'suspend' | 'resume';
+    timestamp: number;
+}
+/** Emitted when the transport connection status changes. */
+export interface DataBusStatusTraceEvent {
+    type: 'status';
+    status: WorkerStatus;
+    timestamp: number;
+}
+/** Emitted when a topic subscription is added or removed. */
+export interface DataBusSubscriptionTraceEvent {
+    type: 'subscription';
+    action: 'subscribe' | 'unsubscribe';
+    topic: string;
+    activeTopics: number;
+    timestamp: number;
+}
+/** Emitted on each reconciliation round to record whether the cluster coordinated. */
+export interface DataBusCoordinationTraceEvent {
+    type: 'coordination';
+    coordinated: boolean;
+    activeWorkers: number;
+    workers: string[];
+    routes: string[];
+    timestamp: number;
+}
+/** Emitted when a transport or operation error occurs. */
+export interface DataBusErrorTraceEvent {
+    type: 'error';
+    source: 'transport' | 'operation';
+    timestamp: number;
+}
+/**
+ * Periodic metrics snapshot: message throughput, dispatch latency percentiles,
+ * and active topic count. Aggregated over the interval and emitted every
+ * `metricsIntervalMs`.
+ */
+export interface DataBusMetricsTraceEvent {
+    type: 'message_metrics';
+    durationMs: number;
+    received: number;
+    dispatched: number;
+    topics: number;
+    dispatchSamples: number;
+    dispatchAvgMs: number;
+    dispatchP50Ms: number;
+    dispatchP95Ms: number;
+    dispatchMaxMs: number;
+    timestamp: number;
+}
+export type DataBusTraceEvent = DataBusLifecycleTraceEvent | DataBusStatusTraceEvent | DataBusSubscriptionTraceEvent | DataBusCoordinationTraceEvent | DataBusErrorTraceEvent | DataBusMetricsTraceEvent;
+/** Distributive-conditional type: given a trace event union, derive the same shape minus `timestamp`. */
+type DataBusTraceEventInput = DataBusTraceEvent extends infer TEvent ? TEvent extends DataBusTraceEvent ? Omit<TEvent, 'timestamp'> : never : never;
+export interface DataBusTraceOptions {
+    enabled?: boolean;
+    mode?: DataBusTraceMode;
+    metricsIntervalMs?: number;
+    sink: (event: DataBusTraceEvent) => void;
+}
+/**
+ * Aggregates DataBus diagnostics — lifecycle events, status changes, and
+ * periodic latency histograms — and forwards them to a user-supplied sink.
+ *
+ * Latency is measured in a bucketed histogram (20 buckets × 50ms) rather than
+ * storing every sample, keeping memory bounded even under high throughput.
+ */
+export declare class DataBusTraceReporter {
+    private readonly enabled;
+    private readonly mode;
+    private readonly metricsIntervalMs;
+    private readonly sink;
+    private readonly now;
+    private intervalHandle;
+    private intervalStartedAt;
+    private received;
+    private dispatched;
+    private latencySamples;
+    private readonly topics;
+    private readonly receivedAt;
+    private readonly latencyBuckets;
+    private latencySumMs;
+    constructor(options?: DataBusTraceOptions, now?: () => number);
+    /** Start the periodic metrics flush interval. No-op when mode is 'events'. */
+    start(): void;
+    /** Pause the metrics interval and reset accumulated counters. */
+    pause(): void;
+    stop(): void;
+    /** Record an instantaneous trace event (lifecycle, status, error, etc.). */
+    event(event: DataBusTraceEventInput): void;
+    /** Record that a message was received on `topic`; stores its timestamp for latency tracking. */
+    recordReceived(topic: string): void;
+    /**
+     * Record that a received message will never be dispatched locally. Pops the
+     * matching FIFO slot so a later dispatch on the same topic does not pair
+     * with a stale receive timestamp.
+     */
+    recordDiscarded(topic: string): void;
+    /**
+     * Record that a message was dispatched on `topic`. Pops the oldest receive
+     * timestamp (FIFO) and increments the latency histogram. Dispatches without
+     * a matching receive (e.g. broadcast fan-out from another tab) still count
+     * as dispatched but do not produce a latency sample.
+     */
+    recordDispatched(topic: string): void;
+    /** Emit the accumulated metrics snapshot if the interval is active. */
+    flush(): void;
+    private flushNow;
+    private resetMetrics;
+    private emit;
+}
+export {};
+//# sourceMappingURL=trace.d.ts.map

package/dist/core/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/core/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,uEAAuE;AACvE,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,CAAC;AAE5D,oEAAoE;AACpE,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;IAChD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,4DAA4D;AAC5D,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,YAAY,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,6DAA6D;AAC7D,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,WAAW,GAAG,aAAa,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,sFAAsF;AACtF,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,cAAc,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,0DAA0D;AAC1D,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,WAAW,GAAG,WAAW,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,iBAAiB,GACzB,0BAA0B,GAC1B,uBAAuB,GACvB,6BAA6B,GAC7B,6BAA6B,GAC7B,sBAAsB,GACtB,wBAAwB,CAAC;AAE7B,yGAAyG;AACzG,KAAK,sBAAsB,GAAG,iBAAiB,SAAS,MAAM,MAAM,GAChE,MAAM,SAAS,iBAAiB,GAC9B,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,GACzB,KAAK,GACP,KAAK,CAAC;AAEV,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC1C;AAUD;;;;;;GAMG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAmB;IACxC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqC;IAC1D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,cAAc,CAA+C;IACrE,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAE5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA+B;IAE1D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmD;IAClF,OAAO,CAAC,YAAY,CAAK;gBAEb,OAAO,CAAC,EAAE,mBAAmB,EAAE,GAAG,GAAE,MAAM,MAAiB;IAQvE,8EAA8E;IAC9E,KAAK,IAAI,IAAI;IAMb,iEAAiE;IACjE,KAAK,IAAI,IAAI;IAMb,IAAI,IAAI,IAAI;IAIZ,4EAA4E;IAC5E,KAAK,CAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI;IAK1C,gGAAgG;IAChG,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAgBnC;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQpC;;;;;OAKG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAgBrC,uEAAuE;IACvE,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,QAAQ;IAuBhB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,IAAI;CAWb"}

package/dist/core/types.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Core type definitions for the cross-tab DataBus.
+ *
+ * Defines the shapes of Worker records, topic routes, control messages,
+ * transport interfaces, trace events, and all supporting types used across
+ * the cluster coordination, DataBus public API, and diagnostics layers.
+ */
+/** Convenience alias for values that may be synchronously returned or Promise. */
+export type MaybePromise<T> = T | Promise<T>;
+/** Whether this Worker can act as a Topic owner. */
+export type WorkerRole = 'active' | 'standby';
+/** Connection-level status of the transport. */
+export type WorkerStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
+/** Control-plane actions routed between Workers via BroadcastChannel. */
+export type WorkerControlAction = 'SUBSCRIBE' | 'UNSUBSCRIBE' | 'PUBLISH';
+/** Whether the tab is currently visible to the user. */
+export type TabVisibilityState = 'visible' | 'hidden';
+/**
+ * A Worker's self-published registration record, written to localStorage
+ * so sibling tabs can discover and route to it.
+ */
+export interface WorkerRecord {
+    workerId: string;
+    tabId: string;
+    /** Number of topics this Worker owns. Not a CPU load. */
+    load: number;
+    role: WorkerRole;
+    status: WorkerStatus;
+    visibilityState: TabVisibilityState;
+    /** Last heartbeat write timestamp (ms). */
+    heartbeatAt: number;
+    /** First registration timestamp (ms). Used for deterministic ordering. */
+    registeredAt: number;
+}
+/**
+ * A topic-to-Worker mapping stored in localStorage. The route is written
+ * by the subscriber's Runtime and confirmed by the owner once it processes
+ * the SUBSCRIBE control message.
+ */
+export interface WorkerRoute {
+    topicKey: string;
+    workerId: string;
+    tabId: string;
+    updatedAt: number;
+    /** Monotonic route generation; handoff acknowledgements must match it. */
+    generation: number;
+    /** Previous owner must release its transport subscription before takeover. */
+    handoffFromWorkerId?: string;
+    /** Set by the owner when it has processed the SUBSCRIBE. Absent → subscriber will retry. */
+    confirmedAt?: number;
+}
+/** Per-tab-per-topic marker stored in localStorage so the cluster knows which tabs still need a topic. */
+export interface TopicSubscriberRecord {
+    tabId: string;
+    updatedAt: number;
+}
+/**
+ * Messages exchanged over the BroadcastChannel. Three types:
+ * - CONTROL: direct peer-to-peer actions (SUBSCRIBE / UNSUBSCRIBE / PUBLISH)
+ * - EVENT: fan-out publications from the owning Worker to all tabs
+ * - REGISTRY: heartbeat signal that triggers reconciliation on other tabs
+ */
+export type WorkerClusterMessage<TEvent = unknown> = {
+    type: 'CONTROL';
+    sourceWorkerId: string;
+    targetWorkerId: string;
+    action: WorkerControlAction;
+    topic: string;
+    topicKey: string;
+    data?: unknown;
+} | {
+    type: 'EVENT';
+    sourceWorkerId: string;
+    eventType: string;
+    payload: TEvent;
+} | {
+    type: 'REGISTRY';
+    sourceWorkerId: string;
+} | {
+    type: 'ROUTE_RELEASED';
+    sourceWorkerId: string;
+    targetWorkerId: string;
+    topic: string;
+    topicKey: string;
+    generation: number;
+};
+export interface DataBusMessage<TData = unknown> {
+    topic: string;
+    data: TData;
+}
+/** Callbacks the transport calls to notify the DataBus of events. */
+export interface DataBusTransportHandlers<TData = unknown> {
+    onMessage: (message: DataBusMessage<TData>) => void;
+    onStatus: (status: WorkerStatus) => void;
+    onError: (error: unknown) => void;
+}
+/**
+ * Transport abstraction that the DataBus delegates to for real I/O.
+ * Implementations may wrap a WebSocket library, a Worker, or a mock.
+ * subscribe / unsubscribe MUST be idempotent.
+ */
+export interface DataBusTransport<TConfig = unknown, TData = unknown> {
+    start(config: TConfig, handlers: DataBusTransportHandlers<TData>): MaybePromise<void>;
+    subscribe(topic: string): MaybePromise<void>;
+    unsubscribe(topic: string): MaybePromise<void>;
+    publish(topic: string, data: unknown): MaybePromise<void>;
+    stop(): MaybePromise<void>;
+}
+export type DataBusMessageHandler<TData = unknown> = (message: DataBusMessage<TData>) => void;
+export type DataBusStatusHandler = (status: WorkerStatus) => void;
+export type DataBusErrorHandler = (error: unknown) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,kFAAkF;AAClF,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAE7C,oDAAoD;AACpD,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;AAC9C,gDAAgD;AAChD,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,GAAG,OAAO,CAAC;AACjF,yEAAyE;AACzE,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,CAAC;AAC1E,wDAAwD;AACxD,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEtD;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,YAAY,CAAC;IACrB,eAAe,EAAE,kBAAkB,CAAC;IACpC,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB,8EAA8E;IAC9E,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,4FAA4F;IAC5F,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,0GAA0G;AAC1G,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,CAAC,MAAM,GAAG,OAAO,IAC7C;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,GACD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;CACxB,GACD;IACE,IAAI,EAAE,gBAAgB,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEN,MAAM,WAAW,cAAc,CAAC,KAAK,GAAG,OAAO;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,CAAC;CACb;AAED,qEAAqE;AACrE,MAAM,WAAW,wBAAwB,CAAC,KAAK,GAAG,OAAO;IACvD,SAAS,EAAE,CAAC,OAAO,EAAE,cAAc,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IACpD,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IACzC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACnC;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB,CAAC,OAAO,GAAG,OAAO,EAAE,KAAK,GAAG,OAAO;IAClE,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,wBAAwB,CAAC,KAAK,CAAC,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IACtF,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IAC7C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IAC/C,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IAC1D,IAAI,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED,MAAM,MAAM,qBAAqB,CAAC,KAAK,GAAG,OAAO,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;AAC9F,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * cross-tab-worker-databus — public API barrel export.
+ *
+ * Re-exports every type and class consumers need from the library's
+ * internal modules. Consumers import from the package root:
+ *
+ * ```ts
+ * import { CrossTabDataBus, createOpaqueKey } from 'cross-tab-worker-databus';
+ * ```
+ */
+export { CrossTabDataBus } from './core/data-bus';
+export type { CrossTabDataBusOptions } from './core/data-bus';
+export type { DataBusCoordinationTraceEvent, DataBusErrorTraceEvent, DataBusLifecycleTraceEvent, DataBusMetricsTraceEvent, DataBusStatusTraceEvent, DataBusSubscriptionTraceEvent, DataBusTraceEvent, DataBusTraceMode, DataBusTraceOptions } from './core/trace';
+export { WorkerClusterRuntime } from './core/cluster';
+export type { WorkerClusterHandlers, WorkerClusterOptions, WorkerClusterSnapshot } from './core/cluster';
+export { createBrowserEnvironment, getOrCreateTabId } from './core/environment';
+export type { ClusterChannel, ClusterEnvironment, StorageLike } from './core/environment';
+export { createOpaqueKey } from './core/hash';
+export { selectWorkerBackend } from './worker-mode';
+export type { WorkerBackend, WorkerMode } from './worker-mode';
+export { DEFAULT_MAX_ACTIVE_WORKERS, hasActiveOwner, selectActiveWorkers, selectLeastLoadedWorker, selectRebalanceTarget } from './core/routing';
+export type { DataBusErrorHandler, DataBusMessage, DataBusMessageHandler, DataBusStatusHandler, DataBusTransport, DataBusTransportHandlers, MaybePromise, TabVisibilityState, TopicSubscriberRecord, WorkerClusterMessage, WorkerControlAction, WorkerRecord, WorkerRole, WorkerRoute, WorkerStatus } from './core/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,YAAY,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAC9D,YAAY,EACV,6BAA6B,EAC7B,sBAAsB,EACtB,0BAA0B,EAC1B,wBAAwB,EACxB,uBAAuB,EACvB,6BAA6B,EAC7B,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAChF,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAC1F,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EACL,0BAA0B,EAC1B,cAAc,EACd,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,mBAAmB,EACnB,cAAc,EACd,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,EAChB,wBAAwB,EACxB,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,UAAU,EACV,WAAW,EACX,YAAY,EACb,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,27 @@
+import {
+  CrossTabDataBus,
+  DEFAULT_MAX_ACTIVE_WORKERS,
+  WorkerClusterRuntime,
+  createBrowserEnvironment,
+  createOpaqueKey,
+  getOrCreateTabId,
+  hasActiveOwner,
+  selectActiveWorkers,
+  selectLeastLoadedWorker,
+  selectRebalanceTarget,
+  selectWorkerBackend
+} from "./chunk-GABYBK7I.js";
+export {
+  CrossTabDataBus,
+  DEFAULT_MAX_ACTIVE_WORKERS,
+  WorkerClusterRuntime,
+  createBrowserEnvironment,
+  createOpaqueKey,
+  getOrCreateTabId,
+  hasActiveOwner,
+  selectActiveWorkers,
+  selectLeastLoadedWorker,
+  selectRebalanceTarget,
+  selectWorkerBackend
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}