@bounded-sh/core 0.0.1

package/dist/client/realtime-store.d.ts

@@ -0,0 +1,89 @@
+export type StorageTier = 'durable' | 'checkpointed' | 'ephemeral';
+export type SubscriptionStatus = 'idle' | 'cached' | 'loading' | 'live' | 'error' | 'reconnecting';
+export type DeltaChange = 'added' | 'modified' | 'removed';
+export interface SubscriptionState<T = any> {
+    data: T[];
+    status: SubscriptionStatus;
+    isStale: boolean;
+    error: Error | null;
+}
+export interface SubscribeOptions {
+    tier?: StorageTier;
+    filter?: Record<string, any>;
+    prompt?: string;
+    includeSubPaths?: boolean;
+    limit?: number;
+    onData?: (data: any) => void;
+    onState?: (state: SubscriptionState) => void;
+    onError?: (error: Error) => void;
+    mode?: 'callback' | 'ref';
+}
+export declare class RealtimeStore {
+    private ws;
+    private wsUrl;
+    private appId;
+    private subscriptions;
+    private pendingRequests;
+    private connectPromise;
+    private reconnectTimer;
+    private reconnectDelay;
+    private maxReconnectDelay;
+    private idbFlushTimer;
+    private idbDirtyKeys;
+    private closed;
+    private authToken;
+    init(): Promise<void>;
+    private isServer;
+    private tokenRefreshTimer;
+    private refreshToken;
+    private startTokenRefresh;
+    private initPromise;
+    private ensureConnected;
+    private connect;
+    private scheduleReconnect;
+    private resubscribeAll;
+    private handleMessage;
+    private handleSnapshot;
+    private handleDelta;
+    private handleLegacyData;
+    private handleResult;
+    private handleError;
+    subscribe(path: string, opts?: SubscribeOptions): Promise<() => Promise<void>>;
+    getRef(path: string, opts?: SubscribeOptions): {
+        current: Map<string, any>;
+    };
+    set(path: string, doc: any): Promise<any>;
+    get(path: string): Promise<any>;
+    getMany(paths: string[]): Promise<Record<string, any>>;
+    delete(path: string): Promise<void>;
+    query(path: string, opts?: {
+        filter?: any;
+        sort?: any;
+        limit?: number;
+        includeSubPaths?: boolean;
+    }): Promise<any[]>;
+    count(path: string): Promise<number>;
+    aggregate(path: string, operation: string, opts?: {
+        field?: string;
+    }): Promise<any>;
+    private sendSubscribe;
+    private sendRequest;
+    private notifySubscription;
+    private notifyState;
+    private getState;
+    private docsToArray;
+    private findSubscriptionById;
+    private findSubscriptionByPath;
+    private getCollectionPath;
+    private getSubKey;
+    private idbKey;
+    private markIdbDirty;
+    private flushIdb;
+    private createUnsubscribe;
+    private resolveOperations;
+    private rejectAllPending;
+    private setAllSubscriptionStatus;
+    close(): void;
+}
+export declare function getRealtimeStore(): RealtimeStore;
+export declare function resetRealtimeStore(): void;

package/dist/client/subscription-v2.d.ts

@@ -0,0 +1,92 @@
+/**
+ * WebSocket v2 Subscription Manager
+ *
+ * This module implements multiplexed subscriptions over a single WebSocket connection.
+ * It maintains the same external API as v1 but uses the new v2 protocol internally.
+ */
+import { SubscriptionOptions } from '../types';
+/**
+ * Subscribe to data at a path using WebSocket v2.
+ * Returns an unsubscribe function.
+ */
+/**
+ * @param roomRoutePath INTERNAL ONLY. A `<sessionCollection>/<roomId>` room path
+ *   used by `live.subscribeView` to route this subscription's connection to the
+ *   per-room DO (where live view fan-out lives). It is NOT part of the public
+ *   subscribe API — app code never passes routing; the worker remains the
+ *   authority on the destination DO (it derives the room from the `?path=` we
+ *   attach). This argument only tells the client which connection to multiplex
+ *   the subscription onto, since a WS connection routes to a single DO.
+ */
+export declare function subscribeV2(path: string, subscriptionOptions: SubscriptionOptions, roomRoutePath?: string): Promise<() => Promise<void>>;
+/**
+ * Close all v2 subscriptions.
+ */
+export declare function closeAllSubscriptionsV2(): Promise<void>;
+/**
+ * Clear the v2 cache.
+ */
+export declare function clearCacheV2(path?: string): void;
+/**
+ * Get cached data for a path (v2).
+ */
+export declare function getCachedDataV2(path: string, prompt?: string): any | null;
+/**
+ * Reconnect all v2 WebSocket connections with fresh authentication.
+ * Call this when the user's auth state changes (login/logout).
+ *
+ * This will:
+ * 1. Close existing connections
+ * 2. Re-establish with new auth token
+ * 3. Re-subscribe to all active paths
+ *
+ * Note: Existing subscriptions will receive new initial data after reconnection.
+ */
+export declare function reconnectWithNewAuthV2(): Promise<void>;
+/**
+ * Force close and reconnect all connections.
+ * This is more aggressive than reconnectWithNewAuthV2() and ensures
+ * a complete teardown and rebuild of connections.
+ */
+export declare function forceReconnectV2(): Promise<void>;
+/**
+ * Returns true if there is an active v2 WebSocket connection open.
+ */
+export declare function hasActiveConnection(): boolean;
+export declare function wsGet(path: string): Promise<any>;
+/**
+ * Send a live-room intent over the EXISTING per-room socket (fire-and-forget).
+ * Returns true if it was sent over an open connection, false if there is no
+ * live socket for this room yet (caller falls back to HTTP). The worker is the
+ * room authority — the connection is already routed to the room DO, so the
+ * client never names a destination.
+ */
+export declare function wsIntent(appId: string, roomRoutePath: string, intent: unknown): boolean;
+/**
+ * Send a live-room intent over the EXISTING per-room socket and AWAIT the server
+ * ack — so a policy/auth denial (401/403/404/503) REJECTS instead of being
+ * silently dropped (the fire-and-forget `wsIntent` discards request-less error
+ * frames). Use for semantically important intents (join/ready/leave). Returns a
+ * Promise that resolves on ack / rejects on error, or `undefined` if no live
+ * socket exists yet (caller falls back to HTTP, which also surfaces errors).
+ */
+export declare function wsIntentReliable(appId: string, roomRoutePath: string, intent: unknown): Promise<{
+    ok: true;
+}> | undefined;
+export declare function wsSet(documents: Array<{
+    destinationPath: string;
+    document: any;
+}>): Promise<any>;
+export declare function wsQuery(path: string, opts?: {
+    filter?: any;
+    sort?: any;
+    limit?: number;
+    includeSubPaths?: boolean;
+}): Promise<any>;
+export declare function wsDelete(path: string): Promise<any>;
+export declare function wsGetMany(paths: string[]): Promise<any>;
+declare global {
+    interface Window {
+        CUSTOM_TAROBASE_APP_ID_HEADER?: string;
+    }
+}

package/dist/client/subscription.d.ts

@@ -0,0 +1,64 @@
+/**
+ * WebSocket Subscription Module
+ *
+ * This module provides real-time data subscriptions using WebSocket v2 protocol
+ * with multiplexed connections (one connection per client, multiple subscriptions).
+ *
+ * The external API remains unchanged - just use subscribe(path, options) as before.
+ */
+import { SubscriptionOptions } from '../types';
+/**
+ * Subscribe to real-time updates for a path.
+ *
+ * @param path - The path to subscribe to (e.g., 'users/123' or 'posts')
+ * @param subscriptionOptions - Options including onData and onError callbacks
+ * @returns A function to unsubscribe
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = await subscribe('users/123', {
+ *   onData: (data) => console.log('User updated:', data),
+ *   onError: (error) => console.error('Subscription error:', error),
+ * });
+ *
+ * // Later, to unsubscribe:
+ * await unsubscribe();
+ * ```
+ */
+export declare function subscribe(path: string, subscriptionOptions: SubscriptionOptions | ((data: any) => void)): Promise<() => Promise<void>>;
+/**
+ * Close all active subscriptions.
+ * Call this when cleaning up (e.g., on logout or component unmount).
+ */
+export declare function closeAllSubscriptions(): Promise<void>;
+/**
+ * Clear the subscription cache.
+ *
+ * @param path - Optional path to clear. If not provided, clears all cached data.
+ */
+export declare function clearCache(path?: string): void;
+/**
+ * Get cached data for a path without making a network request.
+ *
+ * @param path - The path to get cached data for
+ * @param prompt - Optional prompt that was used for the subscription
+ * @returns The cached data, or null if not cached or expired
+ */
+export declare function getCachedData(path: string, prompt?: string): any | null;
+/**
+ * Reconnect all WebSocket connections with fresh authentication.
+ * Call this when the user's auth state changes (login/logout).
+ *
+ * This will:
+ * 1. Close existing connections
+ * 2. Re-establish with new auth token
+ * 3. Re-subscribe to all active paths
+ *
+ * Existing subscriptions will receive new initial data after reconnection.
+ */
+export declare function reconnectWithNewAuth(): Promise<void>;
+declare global {
+    interface Window {
+        CUSTOM_TAROBASE_APP_ID_HEADER?: string;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export { init } from './client/config';
+export { getConfig, ClientConfig } from './client/config';
+export { getWebhookKeysUrl } from './client/config';
+export { get, getMany, set, setMany, setFile, getFiles, search, queryAggregate, runQuery, runQueryMany, runExpression, runExpressionMany, signMessage, signTransaction, signAndSubmitTransaction, count, aggregate, RequestOverrides, SetOptions, GetOptions, SearchOptions, RunQueryOptions, CountOptions, AggregateOptions, AggregateOperation, AggregateResult, AggregateSpec, AggregateRow, QueryAggregateOptions, RunExpressionOptions, RunExpressionResult, InsufficientBalanceError, GetManyResult } from './client/operations';
+export { subscribe, closeAllSubscriptions, clearCache, getCachedData, reconnectWithNewAuth } from './client/subscription';
+export { hasActiveConnection, wsGet, wsSet, wsQuery, wsDelete, wsGetMany } from './client/subscription-v2';
+export * from './types';
+export { increment, serverTimestamp } from './client/field-values';
+export type { FieldOperation } from './client/field-values';
+export { getIdToken, deriveUserIdentityFromIdToken } from './utils/utils';
+export type { UserIdentity } from './utils/utils';
+export { WebSessionManager } from './utils/web-session-manager';
+export { ReactNativeSessionManager } from './utils/rn-session-manager';
+export type { RNStorageAdapter } from './utils/rn-session-manager';
+export { getActiveSessionManager } from './utils/session-manager';
+export type { ClientSessionManager } from './utils/session-manager';
+export { ServerSessionManager } from './utils/server-session-manager';
+export { createSessionWithSignature, refreshSession, revokeSession, signSessionCreateMessage, genAuthNonce } from './utils/auth-api';
+export { Tarobase as Tarobase6 } from './utils/sol/taro6CvKqwrYrDc16ufYgzQ2NZcyyVKStffbtudrhRuDevnet-program';
+export { Tarobase as TarobasePoof } from './utils/sol/poof4b5pk1L9tmThvBmaABjcyjfhFGbMbQP5BXk2QZpMainnet-program';
+export { buildSetDocumentsTransaction, convertRemainingAccounts, RemainingAccount, genSolanaMessage } from './utils/sol/sol-utils';
+export { RealtimeStore, getRealtimeStore, resetRealtimeStore } from './client/realtime-store';
+export type { StorageTier, SubscriptionStatus, SubscriptionState, SubscribeOptions, DeltaChange } from './client/realtime-store';
+export { functions, invoke as invokeFunction, FunctionInvokeError } from './client/functions';
+export type { InvokeOptions } from './client/functions';
+export { live, intent as liveIntent, subscribeView as subscribeLiveView, LiveIntentError } from './client/live';
+export type { LiveIntentOptions, SubscribeViewOptions } from './client/live';
+export { withEffects, isEffectResult, defineLiveModule, EFFECT_INTENT_ADDRESS } from './client/live-effects';
+export type { Effect, EffectKind, EffectResult, LiveIntent, LiveTickResult, LiveModule } from './client/live-effects';