@rebasepro/client 0.10.0 → 0.10.1-canary.14e53ae

package/dist/offline-codec.d.ts

@@ -0,0 +1,4 @@
+/** Prepare a row for the store. */
+export declare function dehydrateRow<T extends Record<string, unknown>>(row: T): Record<string, unknown>;
+/** Restore a row read back from the store. */
+export declare function hydrateRow<T extends Record<string, unknown>>(row: Record<string, unknown>): T;

package/dist/offline-connectivity.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Whether the network is worth trying, and when to try again after it wasn't.
+ *
+ * `navigator.onLine` is necessary but not sufficient: it reports the state of
+ * the network interface, so it stays `true` behind a captive portal, on a
+ * connection that resolves DNS but reaches nothing, and while the API itself
+ * is down. This tracks what actually happened to requests as well, so the
+ * first failure is the only one an app pays for — everything after it inside
+ * the backoff window skips the doomed round trip and answers from the local
+ * store immediately, which is the difference between an app that freezes when
+ * the wifi drops and one that does not.
+ */
+/** The request never reached the server, so nothing was decided by it. */
+export declare function isNetworkError(error: unknown): boolean;
+/** Is this failure worth another attempt later? */
+export declare function isRetryableError(error: unknown): boolean;
+export interface ConnectivityOptions {
+    /** First retry delay after a failure. Defaults to 1 000 ms. */
+    initialBackoffMs?: number;
+    /** Ceiling for the doubling retry delay. Defaults to 60 000 ms. */
+    maxBackoffMs?: number;
+    /**
+     * Let a known-failed connection suppress further attempts until the
+     * backoff window opens. On by default — it is what makes a read or write
+     * during an outage instant instead of a timeout. Turn it off when nothing
+     * will ever wake the client up again (no retry timer, no `online` event),
+     * where suppressing attempts would mean never recovering.
+     */
+    respectBackoff?: boolean;
+    /** Injected for tests. */
+    now?: () => number;
+    /** Injected for tests; must return a handle `clearTimeout` accepts. */
+    setTimer?: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>;
+    clearTimer?: (handle: ReturnType<typeof setTimeout>) => void;
+}
+export declare class ConnectivityMonitor {
+    private state;
+    private backoffMs;
+    private readonly initialBackoffMs;
+    private readonly maxBackoffMs;
+    private retryAt;
+    private timer?;
+    private listeners;
+    private readonly respectBackoff;
+    private readonly now;
+    private readonly setTimer;
+    private readonly clearTimer;
+    /** Called when the backoff window expires, to drive an automatic retry. */
+    onRetryDue?: () => void;
+    private readonly handleOnline;
+    private readonly handleOffline;
+    constructor(options?: ConnectivityOptions);
+    /** What the app should be told: are we connected? */
+    isOnline(): boolean;
+    /**
+     * Should this request even be sent? False means "answer from the local
+     * store instead" — the request would only burn a timeout to reach the same
+     * conclusion the last one already did.
+     */
+    shouldAttempt(): boolean;
+    /** A request reached the server. */
+    markSuccess(): void;
+    /** A request did not reach the server: we are offline until proven otherwise. */
+    markFailure(): void;
+    /**
+     * Back off and try again later without claiming the connection is gone.
+     * This is what a 429 or a 503 deserves — the server answered, so the app
+     * is demonstrably online; it just should not hammer.
+     */
+    deferRetry(): void;
+    /** Milliseconds until the next attempt is allowed; 0 when one is allowed now. */
+    msUntilRetry(): number;
+    onChange(listener: (online: boolean) => void): () => void;
+    dispose(): void;
+    private scheduleRetry;
+    private clearPendingTimer;
+    private setState;
+}

package/dist/offline-query.d.ts

@@ -0,0 +1,51 @@
+import { FilterValues, FindResult, LogicalCondition, FilterCondition, OrderByTuple, WhereFilterOp } from "@rebasepro/types";
+import { FindParams } from "./transport";
+/** The server's page size when the caller does not ask for one. */
+export declare const DEFAULT_PAGE_SIZE = 20;
+/**
+ * Three-way compare with SQL's type coercion but not its collation. Returns
+ * `undefined` when the two values are not ordered relative to each other,
+ * which is how NULL propagates through a comparison.
+ */
+export declare function compareValues(a: unknown, b: unknown): number | undefined;
+/** Equality with the wire's type erasure allowed for, but never across NULL. */
+export declare function looseEquals(a: unknown, b: unknown): boolean;
+/** Evaluate one canonical operator against one row value. */
+export declare function matchesOperator(rowValue: unknown, op: WhereFilterOp, filterValue: unknown): boolean;
+/** Evaluate a `where` clause: every field, and every tuple on a field, AND-ed. */
+export declare function matchesWhere(row: Record<string, unknown>, where: FilterValues<string> | undefined): boolean;
+/** Evaluate a nested and/or tree. */
+export declare function matchesLogical(row: Record<string, unknown>, condition: LogicalCondition | FilterCondition | undefined): boolean;
+/**
+ * Approximate the server's full-text search with a case-insensitive substring
+ * scan over the row's own string fields. Narrower than the real thing (no
+ * stemming, no configured search columns), and it never matches a field the
+ * cached row does not carry — a local list may therefore be missing rows the
+ * server would have returned, which is why {@link isExactlyEvaluable} refuses
+ * to call a search query exact.
+ */
+export declare function matchesSearch(row: Record<string, unknown>, searchString: string | undefined): boolean;
+/** Does this row belong in the result set for `params`, ignoring pagination? */
+export declare function matchesParams(row: Record<string, unknown>, params?: FindParams): boolean;
+/**
+ * Sort in place, Postgres-style: nulls last ascending, first descending, with
+ * the row id as a tiebreak so paging through an unsorted-but-equal run does
+ * not shuffle rows between pages.
+ */
+export declare function sortRows<M extends Record<string, unknown>>(rows: M[], orderBy?: OrderByTuple): M[];
+/** Resolve `page`/`offset`/`limit` the way the server does. */
+export declare function resolvePagination(params?: FindParams): {
+    limit: number;
+    offset: number;
+};
+/**
+ * Can a locally evaluated answer to `params` be trusted to match the server's,
+ * assuming the cache holds every row of the collection?
+ *
+ * `include` pulls in rows from other collections that this evaluator never
+ * sees, and `searchString` is only approximated — both make the local answer a
+ * best effort rather than an equivalent one.
+ */
+export declare function isExactlyEvaluable(params?: FindParams): boolean;
+/** Run a full query — filter, sort, paginate — over a set of rows. */
+export declare function runLocalQuery<M extends Record<string, unknown>>(rows: M[], params?: FindParams): FindResult<M>;

package/dist/offline-store.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Persistence backends for the SDK's offline support.
+ *
+ * The store is a dumb, namespaced key/value surface with two areas: a read
+ * cache (normalized rows, query snapshots and sync bookkeeping) and a mutation
+ * queue (local writes waiting to reach the server). All structure — per-user
+ * prefixes, the `row|`/`q|`/`meta|` namespaces, mutation ordering — is owned by
+ * the {@link OfflineManager}; the store only promises that a prefix listing
+ * comes back in lexicographic key order, which is what makes the queue a FIFO.
+ *
+ * Two implementations ship with the SDK:
+ * - {@link IndexedDBOfflineStore} — the browser default; survives reloads.
+ * - {@link MemoryOfflineStore} — the fallback everywhere IndexedDB does not
+ *   exist (Node, React Native, tests); survives only the process.
+ *
+ * Environments with neither (React Native + AsyncStorage, Electron main, …)
+ * implement this interface and pass it via `offline.store`.
+ */
+/** A cached value plus the moment it was written, for LRU eviction. */
+export interface OfflineCacheEntry {
+    value: unknown;
+    cachedAt: number;
+}
+/** A cache entry with its key, as returned by prefix listings. */
+export interface OfflineCacheRecord extends OfflineCacheEntry {
+    key: string;
+}
+/** What a mutation has to put back if the server rejects it. */
+export interface MutationRollback {
+    /**
+     * The rows as they were locally *before* this mutation was applied, keyed
+     * by id. A `null` value means "the row did not exist" — restoring it is a
+     * delete, not a write.
+     */
+    rows: Record<string, Record<string, unknown> | null>;
+}
+/**
+ * A local write waiting to be replayed against the server.
+ *
+ * `mutationId` orders the queue globally (not per collection): a create in one
+ * collection may be the parent a later insert in another references, so replay
+ * must preserve the order the app issued the writes in. It is lexicographically
+ * time-ordered and carries a random suffix, so two browser tabs writing in the
+ * same millisecond produce distinct, still-roughly-ordered ids instead of
+ * silently overwriting each other's queue entry.
+ */
+export interface PendingMutation {
+    /** Unique, lexicographically sortable identity — also the queue key suffix. */
+    mutationId: string;
+    collection: string;
+    type: "create" | "createMany" | "update" | "delete";
+    /** Target row id for update/delete, and the (client-generated) id of an offline create. */
+    id?: string | number;
+    /**
+     * True when the SDK minted this create's id itself. Only such creates may
+     * cancel out against a later offline delete: a freshly generated UUID
+     * cannot name a row the server already has, while a caller-supplied id
+     * can — and there the delete must still replay to remove the server row.
+     */
+    generatedId?: boolean;
+    /** The payload: a row for create/update, an array of rows for createMany. */
+    data?: Record<string, unknown> | Record<string, unknown>[];
+    upsert?: boolean;
+    queuedAt: number;
+    /** How many times replay has been attempted (diagnostics for a stuck queue). */
+    attempts?: number;
+    /** The last replay failure's message, when there was one. */
+    lastError?: string;
+    /** Local state to restore if the server rejects this mutation. */
+    rollback?: MutationRollback;
+}
+export interface OfflineStore {
+    getCache(key: string): Promise<OfflineCacheEntry | undefined>;
+    setCache(key: string, entry: OfflineCacheEntry): Promise<void>;
+    /** Write many entries at once — one transaction where the backend has them. */
+    setCacheMany(entries: {
+        key: string;
+        entry: OfflineCacheEntry;
+    }[]): Promise<void>;
+    deleteCache(keys: string[]): Promise<void>;
+    /** Every cache key starting with `prefix`, with its write time (for eviction). */
+    listCache(prefix: string): Promise<{
+        key: string;
+        cachedAt: number;
+    }[]>;
+    /** As {@link listCache}, but with the values — the local query engine's input. */
+    listCacheEntries(prefix: string): Promise<OfflineCacheRecord[]>;
+    enqueue(key: string, mutation: PendingMutation): Promise<void>;
+    dequeue(key: string): Promise<void>;
+    /** Queued mutations whose key starts with `prefix`, in lexicographic key order. */
+    listQueue(prefix: string): Promise<PendingMutation[]>;
+    /** Remove every cache entry and queued mutation whose key starts with `prefix`. */
+    clear(prefix: string): Promise<void>;
+}
+export declare function createMutationId(now?: number): string;
+/**
+ * In-memory store: the default outside the browser and the workhorse of the
+ * test suite. Values are deep-copied on the way in and out so a caller
+ * mutating a returned row cannot silently edit the "persisted" copy — the
+ * IndexedDB implementation gets the same guarantee for free from structured
+ * cloning, and the two must not differ in aliasing behaviour.
+ */
+export declare class MemoryOfflineStore implements OfflineStore {
+    private cache;
+    private queue;
+    getCache(key: string): Promise<OfflineCacheEntry | undefined>;
+    setCache(key: string, entry: OfflineCacheEntry): Promise<void>;
+    setCacheMany(entries: {
+        key: string;
+        entry: OfflineCacheEntry;
+    }[]): Promise<void>;
+    deleteCache(keys: string[]): Promise<void>;
+    listCache(prefix: string): Promise<{
+        key: string;
+        cachedAt: number;
+    }[]>;
+    listCacheEntries(prefix: string): Promise<OfflineCacheRecord[]>;
+    enqueue(key: string, mutation: PendingMutation): Promise<void>;
+    dequeue(key: string): Promise<void>;
+    listQueue(prefix: string): Promise<PendingMutation[]>;
+    clear(prefix: string): Promise<void>;
+}
+/**
+ * IndexedDB-backed store — the browser default, so cached rows and queued
+ * writes survive a reload or a browser restart. Everything lives in one
+ * database with two object stores; keys are the manager's full prefixed
+ * strings, so multiple users (scopes) share the database without ever
+ * sharing entries.
+ */
+export declare class IndexedDBOfflineStore implements OfflineStore {
+    private dbPromise?;
+    private open;
+    private store;
+    getCache(key: string): Promise<OfflineCacheEntry | undefined>;
+    setCache(key: string, entry: OfflineCacheEntry): Promise<void>;
+    setCacheMany(entries: {
+        key: string;
+        entry: OfflineCacheEntry;
+    }[]): Promise<void>;
+    deleteCache(keys: string[]): Promise<void>;
+    listCache(prefix: string): Promise<{
+        key: string;
+        cachedAt: number;
+    }[]>;
+    listCacheEntries(prefix: string): Promise<OfflineCacheRecord[]>;
+    enqueue(key: string, mutation: PendingMutation): Promise<void>;
+    dequeue(key: string): Promise<void>;
+    listQueue(prefix: string): Promise<PendingMutation[]>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/offline.d.ts

@@ -0,0 +1,306 @@
+import { SDKCollectionClient } from "@rebasepro/types";
+import { CollectionClient } from "./collection";
+import { OfflineStore, PendingMutation } from "./offline-store";
+/**
+ * The SDK's local-first sync engine.
+ *
+ * The design goal is that the network is never in the way of the interface.
+ * That comes from three properties, and everything in this file exists to
+ * serve one of them:
+ *
+ * 1. **A local database, not a response cache.** Rows are stored normalized,
+ *    by id, and queries are answered by evaluating them
+ *    ({@link ./offline-query}) against those rows. A row written offline
+ *    therefore appears in *every* list it belongs to, a row edited in one view
+ *    updates in all of them, and `findById` answers for a row only ever seen
+ *    inside a `find`. Server responses are merged into this database rather
+ *    than replacing it, and a row with unsynced local writes keeps them: the
+ *    user's own change never flickers away underneath them.
+ *
+ * 2. **Writes are decided locally.** A write made while offline is applied to
+ *    the local database and queued — with the state it replaced, so a server
+ *    rejection can be undone — and the call returns immediately. When
+ *    connectivity is known to be gone the request is not even attempted, so
+ *    an offline write costs nothing instead of a timeout.
+ *
+ * 3. **Reads are reactive.** {@link OfflineManager.observe} emits from the
+ *    local database synchronously-ish, revalidates in the background, and
+ *    re-emits whenever anything touches the rows it covers — a local write,
+ *    a replay landing, a rollback, a realtime event, or another browser tab.
+ *
+ * What it deliberately is not: a full replica. Only rows the app has actually
+ * read or written are local, so a query the cache cannot fully answer is
+ * flagged `partial` rather than silently reported as complete.
+ */
+export interface OfflineConfig {
+    /**
+     * Persistence backend. Defaults to IndexedDB in the browser and an
+     * in-memory store elsewhere; pass a custom implementation (e.g. backed by
+     * AsyncStorage in React Native) to persist in other environments.
+     */
+    store?: OfflineStore;
+    /**
+     * Cached query snapshots kept per collection; the least recently written
+     * are evicted beyond this. Defaults to 50.
+     */
+    maxCachedQueriesPerCollection?: number;
+    /**
+     * Cached rows kept per collection. Rows with unsynced local writes are
+     * never evicted. Defaults to 5 000.
+     */
+    maxCachedRowsPerCollection?: number;
+    /**
+     * Ceiling for the exponential retry backoff, in milliseconds. Replay
+     * retries start at one second and double up to this. `0` disables
+     * automatic retries entirely — `client.offline.sync()`, a sign-in, and the
+     * browser's `online` event still trigger one. Defaults to 60 000.
+     */
+    syncIntervalMs?: number;
+    /**
+     * Keep several tabs of the same app in step over a `BroadcastChannel`: a
+     * write in one appears in the others, and only one of them replays the
+     * shared queue. Defaults to on for the IndexedDB store (a real shared
+     * database) and off for the in-memory one, which no other tab can see.
+     */
+    crossTab?: boolean;
+    /**
+     * How many times a mutation rejected with a *retryable* status (429, 503,
+     * …) is replayed before it is given up on and rolled back. Network
+     * failures do not count against this: being offline is not an attempt.
+     * Defaults to 5.
+     */
+    maxRetries?: number;
+    /**
+     * Called when the server *rejects* a queued mutation (a 4xx/5xx that will
+     * not resolve on its own — validation, RLS, a since-deleted row). The
+     * local rows it wrote are rolled back to the state they had before it, and
+     * any later queued writes to the same rows are discarded with it — they
+     * were built on a change that never happened. Each discarded mutation is
+     * reported here.
+     *
+     * Network failures are not errors: those mutations stay queued.
+     */
+    onSyncError?: (error: Error, mutation: PendingMutation) => void;
+}
+/** A snapshot of the engine's state, for a status indicator. */
+export interface OfflineStatus {
+    /** False once a request has failed to reach the server, until one does. */
+    online: boolean;
+    /** True while the queue is being replayed. */
+    syncing: boolean;
+    /** Local writes not yet accepted by the server. */
+    pending: number;
+    /** When the queue was last fully drained. */
+    lastSyncedAt?: number;
+    /** The last replay rejection, if any. */
+    lastError?: string;
+}
+export type { LiveResult, ObserveOptions, RowSnapshotMeta } from "./collection";
+/** What `client.offline` exposes to the app. */
+export interface OfflineApi {
+    /** Replay the queue now. Resolves with what was flushed and what remains. */
+    sync(): Promise<{
+        flushed: number;
+        remaining: number;
+    }>;
+    /** The queued mutations for the current user, oldest first. */
+    pending(): Promise<PendingMutation[]>;
+    /** The current engine state — connectivity, queue depth, last sync. */
+    status(): OfflineStatus;
+    /** Subscribe to {@link OfflineStatus} changes (for a sync indicator). */
+    onStatusChange(listener: (status: OfflineStatus) => void): () => void;
+    /**
+     * Drop the current user's queued mutations AND their local rows.
+     * Destructive: queued writes are lost, not replayed. For "discard my
+     * offline changes" flows, not for sign-out (scoping already isolates
+     * users).
+     */
+    clear(): Promise<void>;
+    /** Subscribe to queue-size changes (for a "pending changes" badge). */
+    onQueueChange(listener: (count: number) => void): () => void;
+}
+/** True when a read failed because there was neither network nor local data. */
+export declare function isOfflineError(error: unknown): boolean;
+type AnyRow = Record<string, unknown>;
+type InnerFactory = (slug: string) => SDKCollectionClient<AnyRow>;
+export declare class OfflineManager {
+    private readonly store;
+    private readonly maxCachedQueries;
+    private readonly maxCachedRows;
+    private readonly maxRetries;
+    private readonly onSyncError?;
+    private readonly createInner;
+    private readonly inners;
+    private readonly connectivity;
+    private scope;
+    /** The local database: normalized rows and query snapshots per collection. */
+    private collections;
+    /** In-memory mirror of the current scope's queue, in replay order. */
+    private queue;
+    private queueLoad?;
+    /** Serializes enqueues so concurrent writes keep the order the app made them. */
+    private enqueueChain;
+    private flushPromise?;
+    private queueListeners;
+    private statusListeners;
+    private observers;
+    private refreshPending;
+    private revCounter;
+    private disposed;
+    private currentStatus;
+    private readonly channel?;
+    private readonly tabId;
+    readonly api: OfflineApi;
+    constructor(config: OfflineConfig, createInner: InnerFactory);
+    /**
+     * Cache and queue are partitioned per signed-in user: cached rows are
+     * RLS-filtered for the user who fetched them, and queued writes must
+     * replay under the credentials that made them — so neither may ever leak
+     * across a sign-out/sign-in on a shared browser.
+     */
+    setScope(uid: string | undefined): void;
+    /**
+     * Throw away every local row, for a scope change or an explicit clear.
+     *
+     * The state objects are replaced rather than emptied, so a load still in
+     * flight for the previous user fails its identity check and discards what
+     * it read instead of grafting it onto the new one. The replacements are
+     * marked ready: nothing needs loading until something asks, and observers
+     * have to be told *now* that the rows they are showing are gone.
+     */
+    private resetCollections;
+    /** Release listeners, timers and the cross-tab channel (client.close()). */
+    dispose(): void;
+    wrap<M extends AnyRow>(slug: string, inner: CollectionClient<M>): CollectionClient<M>;
+    private observe;
+    private observeById;
+    private observersFor;
+    /** Cheap change detection: which rows, in what order, at which revision. */
+    private signature;
+    private notifyCollection;
+    /** Connectivity came back (or the user changed): re-read everything live. */
+    private revalidateAll;
+    private collectionState;
+    private ensureCollection;
+    private snapshotFor;
+    private hasLocalAnswer;
+    /**
+     * Answer a query from the local database.
+     *
+     * With a snapshot, the server's own page — its ids, order and total — is
+     * the skeleton, and the local rows fill it in: rows deleted locally drop
+     * out, rows edited locally show the edit, and rows *created* locally join
+     * the first page if they match. Without one, the query is evaluated
+     * outright over every cached row, which is the best that can be done for a
+     * query the server has never answered here.
+     */
+    private answer;
+    private localFind;
+    private rawLocalRow;
+    private localRow;
+    private setLocalRow;
+    /**
+     * Drop a row and, when the server is the one saying it is gone, remember
+     * that. "I looked it up and it does not exist" is real knowledge: without
+     * it, opening a deleted row while offline would report a missing local
+     * database instead of a missing row.
+     */
+    private removeLocalRow;
+    private forgetTombstone;
+    /**
+     * Merge server rows into the local database. A row with unsynced local
+     * writes keeps them: the server's copy is the base the queued mutations
+     * are re-applied to, not a replacement for what the user did.
+     *
+     * Rows that came back unchanged keep their identity and revision, so a
+     * refetch that changed nothing does not re-render every live query that
+     * touches them — or rewrite them all to disk.
+     */
+    private ingest;
+    /**
+     * Fold the queued mutations for one row over a base, newest last.
+     * `afterMutationId` skips everything up to and including that mutation,
+     * which is how a just-replayed write avoids being applied on top of the
+     * server's response to it.
+     */
+    private applyPendingToRow;
+    private recordSnapshot;
+    /**
+     * A write changed which rows belong in a list, and only the server can say
+     * how — a row it generated is in no cached page, and the totals moved.
+     * Re-run every live query on the collection; queries nobody is watching
+     * are corrected by their next `find`.
+     *
+     * Coalesced per microtask so a burst of writes costs one round trip, and
+     * skipped entirely while offline, where the local database is already the
+     * best answer available.
+     */
+    private scheduleRefresh;
+    private evictRows;
+    private evictSnapshots;
+    private ensureQueueLoaded;
+    private enqueue;
+    private hasPending;
+    /** Is this row one the server has never been told about? */
+    private isLocallyCreated;
+    /** How many rows the queue adds to (or removes from) a server-side count. */
+    private pendingDelta;
+    sync(): Promise<{
+        flushed: number;
+        remaining: number;
+    }>;
+    private flush;
+    private replay;
+    /**
+     * Take the server's version of a row the client created offline.
+     *
+     * The server may have assigned a different id — a serial column ignores
+     * the id we invented — in which case every local trace of the temporary id
+     * has to move with it, including queued writes that were made against it
+     * before it was ever sent.
+     */
+    private adoptServerRow;
+    /**
+     * Write a server row over the local one, ignoring the mutation that just
+     * produced it — re-applying that would put the pre-server values back on
+     * top of the server's answer — but keeping every write queued *after* it.
+     * Those are still unsent, and dropping them here would make the row snap
+     * back to the server's version in front of the user, only to change again
+     * when they replay a moment later.
+     */
+    private ingestReplaced;
+    /**
+     * The server refused a mutation. Put back what it changed, and discard the
+     * queued writes that were built on top of it: an edit to a row whose
+     * creation was rejected can only fail the same way, and applying it would
+     * leave the local database claiming a row the server does not have.
+     *
+     * The cascade stops the moment a later write stops *depending* on the
+     * rejected one. An `update` reads the row it edits, so it is doomed with
+     * it; a `create` overwrites the row outright and a `delete` needs nothing
+     * of it, so both stand on their own and are kept — dropping them would
+     * silently lose writes the server would have accepted.
+     */
+    private rejectMutation;
+    /** Every row id a mutation writes to. */
+    private idsOf;
+    private drop;
+    /** Replay uses unwrapped clients: a failure must never re-enqueue itself. */
+    private innerFor;
+    private withLock;
+    private broadcast;
+    private onBroadcast;
+    /** Re-read one collection from the store, replacing what is in memory. */
+    private reloadCollection;
+    private reloadQueue;
+    private afterQueueChange;
+    private notifyQueue;
+    private patchStatus;
+    private countKey;
+    private rowKey;
+    private absentKey;
+    private queueKey;
+    private readCache;
+    private writeCache;
+    private deleteCache;
+}

package/dist/transport.d.ts

@@ -26,6 +26,20 @@ export interface RebaseClientConfig {
      * Defaults to `"/api"`; override only if the server mounts it elsewhere.
      */
     apiPath?: string;
+    /**
+     * Origin to use instead of {@link baseUrl} for URLs that are handed to the
+     * browser to fetch on its own — storage file downloads and previews.
+     *
+     * API *requests* always go to `baseUrl`; this only changes URLs the SDK
+     * *returns* (e.g. `storage.getSignedUrl`). It exists for proxied setups:
+     * when `baseUrl` routes through an authenticated middleman (the Rebase
+     * console's Studio proxy), a plain `<img src>` or a copied link cannot
+     * satisfy the middleman's auth — but the file route itself is reachable
+     * directly at the origin server and secured by its own scoped `?token=`.
+     * Set this to that server's public origin (no path; {@link apiPath} is
+     * appended) and returned file URLs point straight at it.
+     */
+    storageUrlOrigin?: string;
     fetch?: typeof globalThis.fetch;
     onUnauthorized?: () => Promise<boolean>;
     websocketUrl?: string;
@@ -56,6 +70,8 @@ export interface Transport {
     setOnUnauthorized: (handler: () => Promise<boolean>) => void;
     readonly baseUrl: string;
     readonly apiPath: string;
+    /** See {@link RebaseClientConfig.storageUrlOrigin}. Undefined = use `baseUrl`. */
+    readonly storageUrlOrigin?: string;
     readonly fetchFn: typeof globalThis.fetch;
     getHeaders: (init?: RequestInit) => Record<string, string>;
     resolveToken: () => Promise<string | null>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/client",
   "type": "module",
-  "version": "0.10.0",
+  "version": "0.10.1-canary.14e53ae",
   "description": "HTTP SDK client for the Rebase custom backend",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -29,9 +29,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/utils": "0.10.0",
-    "@rebasepro/types": "0.10.0",
-    "@rebasepro/common": "0.10.0"
+    "@rebasepro/common": "0.10.1-canary.14e53ae",
+    "@rebasepro/types": "0.10.1-canary.14e53ae",
+    "@rebasepro/utils": "0.10.1-canary.14e53ae"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",
@@ -39,6 +39,7 @@
     "@types/node": "^25.9.3",
     "@types/ws": "^8.18.1",
     "cross-env": "^10.1.0",
+    "fake-indexeddb": "^6.2.5",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11",
     "tsd": "^0.33.0",