@fireflydb/expo-driver 0.0.6

package/src/drivers/secureStorage.ts

@@ -0,0 +1,83 @@
+// Expo secure-storage driver. Wraps expo-secure-store, which is iOS Keychain /
+// Android EncryptedSharedPreferences under the hood. Stores the 32-byte
+// Ed25519 device seed (and any future binary secrets) by base64-encoding at
+// the boundary, since SecureStore's value type is string.
+
+import * as SecureStore from 'expo-secure-store';
+import type { SecureStorageDriver } from '@fireflydb/core';
+
+export interface ExpoSecureStorageOptions {
+  /**
+   * Optional namespace prefix for all keys. Useful when multiple FireflyDB
+   * databases coexist in one app — pass e.g. `firefly.<dbName>`. Defaults to
+   * an empty prefix; callers are responsible for collision avoidance.
+   */
+  prefix?: string;
+
+  /**
+   * Forwarded to SecureStore.setItemAsync. Defaults to
+   * WHEN_UNLOCKED_THIS_DEVICE_ONLY (iOS) / no biometric prompt (Android).
+   */
+  keychainAccessible?: SecureStore.KeychainAccessibilityConstant;
+}
+
+export class ExpoSecureStorageDriver implements SecureStorageDriver {
+  private readonly prefix: string;
+  private readonly storeOpts: SecureStore.SecureStoreOptions;
+
+  constructor(opts: ExpoSecureStorageOptions = {}) {
+    this.prefix = opts.prefix ?? '';
+    this.storeOpts = {};
+    if (opts.keychainAccessible !== undefined) {
+      this.storeOpts.keychainAccessible = opts.keychainAccessible;
+    }
+  }
+
+  async get(key: string): Promise<Uint8Array | null> {
+    const raw = await SecureStore.getItemAsync(this.namespaced(key), this.storeOpts);
+    if (raw === null) return null;
+    return base64Decode(raw);
+  }
+
+  async set(key: string, value: Uint8Array): Promise<void> {
+    await SecureStore.setItemAsync(
+      this.namespaced(key),
+      base64Encode(value),
+      this.storeOpts,
+    );
+  }
+
+  async delete(key: string): Promise<void> {
+    await SecureStore.deleteItemAsync(this.namespaced(key), this.storeOpts);
+  }
+
+  private namespaced(key: string): string {
+    // SecureStore allows alphanumerics + . - _; replace anything else.
+    const safe = `${this.prefix}${this.prefix ? '.' : ''}${key}`.replace(
+      /[^A-Za-z0-9._-]/g,
+      '_',
+    );
+    return safe;
+  }
+}
+
+function base64Encode(bytes: Uint8Array): string {
+  // RN runtimes (Hermes, JSC) all expose globalThis.btoa via core-js polyfills
+  // since RN 0.74. We avoid Buffer to stay platform-portable.
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]!);
+  }
+  // eslint-disable-next-line no-undef
+  return btoa(binary);
+}
+
+function base64Decode(s: string): Uint8Array {
+  // eslint-disable-next-line no-undef
+  const binary = atob(s);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    out[i] = binary.charCodeAt(i);
+  }
+  return out;
+}

package/src/drivers/sqlite.ts

@@ -0,0 +1,322 @@
+// Expo SQLite driver. Wires an APP-OWNED expo-sqlite connection into
+// FireflyDB, with libfirefly loaded as a SQLite extension.
+//
+// The app opens the connection and passes it in: libfirefly's CRDT triggers
+// and per-connection device_id live on that ONE connection, and the app's own
+// reads/writes must run on the SAME handle to be captured and synced — a
+// second connection to the file would lack the extension, so the
+// trigger-invoked firefly_* functions wouldn't exist there. The driver
+// borrows the handle for the client's lifetime and never closes it (matches
+// the Node driver's SetMaxOpenConns(1) discipline).
+//
+// SQL strings and call patterns mirror NodeSqliteDb in @fireflydb/node-test-driver.
+
+import type * as SQLite from 'expo-sqlite';
+import type {
+  ApplyResult,
+  ChangeSubscription,
+  OpenOpts,
+  PeerStatus,
+  SqliteDb,
+  SqliteDriver,
+} from '@fireflydb/core';
+import { encodeKeysU32 } from '@fireflydb/core';
+
+import FireflyClientModule, { subscribeToChanges } from '../FireflyClientModule';
+
+export interface ExpoSqliteDriverOptions {
+  /**
+   * The app-opened expo-sqlite connection (e.g. `await
+   * SQLite.openDatabaseAsync('app.db')`). The driver enforces its setup
+   * invariants on it — WAL + foreign_keys pragmas, loading libfirefly (don't
+   * load it yourself) — but ownership stays with the app: `client.close()`
+   * detaches without closing, so the connection survives the client (sign-out
+   * teardown, per-user client swaps). Closing it is the app's job.
+   *
+   * `FireflyClientConfig.dbPath` is not used to open and may be omitted —
+   * the handle already knows its file. If supplied, it must name the same
+   * database file; the driver throws on a mismatch.
+   */
+  db: SQLite.SQLiteDatabase;
+  /**
+   * Override the libfirefly path. If absent we ask the native module, which
+   * resolves to the bundled libfirefly.dylib (iOS) / libfirefly.so (Android).
+   */
+  extensionPath?: string;
+}
+
+// Handles this module has already loaded libfirefly onto. The same handle can
+// pass through open() more than once (a new FireflyClient over the same
+// connection after close()); re-running the extension init is not something
+// we rely on being safe, so load exactly once per handle.
+const extensionLoaded = new WeakSet<SQLite.SQLiteDatabase>();
+
+export class ExpoSqliteDriver implements SqliteDriver {
+  constructor(private readonly opts: ExpoSqliteDriverOptions) {}
+
+  async open(opts: OpenOpts): Promise<SqliteDb> {
+    const extPath =
+      opts.extensionPath ??
+      this.opts.extensionPath ??
+      FireflyClientModule.getLibraryPath();
+    const entryPoint = FireflyClientModule.getEntryPoint();
+
+    const db = this.opts.db;
+    assertSameDatabase(opts.path, db);
+
+    // Ensure WAL for concurrent readers; mirrors NodeSqliteDriver. Idempotent,
+    // so safe to re-apply on the app's connection.
+    await db.execAsync('PRAGMA journal_mode = WAL');
+    await db.execAsync('PRAGMA foreign_keys = ON');
+    if (!extensionLoaded.has(db)) {
+      // expo-sqlite exposes loadExtensionAsync on the database handle. It calls
+      // exsqlite3_enable_load_extension + exsqlite3_load_extension under the
+      // hood — Apple bans this on the system SQLite, but expo-sqlite ships its
+      // own bundled SQLite where it's allowed.
+      await db.loadExtensionAsync(extPath, entryPoint);
+      extensionLoaded.add(db);
+    }
+    return new ExpoSqliteDb(db);
+  }
+}
+
+/** Row alias for `SELECT firefly_xxx(?) AS v`. */
+type ScalarRow<T> = { v: T };
+
+class ExpoSqliteDb implements SqliteDb {
+  constructor(private readonly db: SQLite.SQLiteDatabase) {}
+
+  subscribeToChanges(handler: (blob: Uint8Array) => void): ChangeSubscription {
+    // expo-sqlite resolves the (possibly relative) name passed to
+    // openDatabaseAsync to an absolute filesystem path; libfirefly's
+    // listener registry keys by canonical path, so we hand it the
+    // resolved one.
+    return subscribeToChanges(this.db.databasePath, handler);
+  }
+
+  // The libfirefly scalar functions all return BLOB; we alias the result as
+  // `v` so we can read by name instead of by the stringified call expression.
+  private async callScalarBlob(sql: string, params: unknown[]): Promise<Uint8Array> {
+    const aliased = aliasScalar(sql);
+    const row = await this.db.getFirstAsync<ScalarRow<Uint8Array | null>>(
+      aliased,
+      ...(params as SQLite.SQLiteBindValue[]),
+    );
+    if (!row || row.v === null || row.v === undefined) return new Uint8Array(0);
+    return ensureUint8Array(row.v);
+  }
+
+  private async callScalarBlobOrNull(
+    sql: string,
+    params: unknown[],
+  ): Promise<Uint8Array | null> {
+    const aliased = aliasScalar(sql);
+    const row = await this.db.getFirstAsync<ScalarRow<Uint8Array | null>>(
+      aliased,
+      ...(params as SQLite.SQLiteBindValue[]),
+    );
+    if (!row || row.v === null || row.v === undefined) return null;
+    return ensureUint8Array(row.v);
+  }
+
+  private async callScalarString(sql: string, params: unknown[]): Promise<string> {
+    const aliased = aliasScalar(sql);
+    const row = await this.db.getFirstAsync<ScalarRow<string>>(
+      aliased,
+      ...(params as SQLite.SQLiteBindValue[]),
+    );
+    if (!row || typeof row.v !== 'string') {
+      throw new Error(`expected string scalar from: ${sql}`);
+    }
+    return row.v;
+  }
+
+  private async callVoid(sql: string, params: unknown[]): Promise<void> {
+    if (params.length === 0) {
+      await this.db.execAsync(sql);
+      return;
+    }
+    await this.db.runAsync(sql, ...(params as SQLite.SQLiteBindValue[]));
+  }
+
+  // --- lifecycle -----------------------------------------------------------
+
+  async init(dbName: string, seed: Uint8Array): Promise<void> {
+    await this.callVoid('SELECT firefly_init(?, ?)', [dbName, seed]);
+  }
+
+  async trackTable(name: string): Promise<void> {
+    // 2nd arg is the "infer schema" flag (0 = explicit). Mirrors execTrack in
+    // the Go test harness.
+    await this.callVoid('SELECT firefly_track_table(?, 0)', [name]);
+  }
+
+  async close(): Promise<void> {
+    // Whoever opened the connection closes it: the handle belongs to the app
+    // and survives the client — this detaches without closing.
+  }
+
+  // --- peer management -----------------------------------------------------
+
+  async registerPeer(
+    peerID: string,
+    publicKey: Uint8Array,
+    kind: string,
+  ): Promise<void> {
+    await this.callVoid('SELECT firefly_register_peer(?, ?, ?)', [
+      peerID,
+      publicKey,
+      kind,
+    ]);
+  }
+
+  async setPeerStatus(peerID: string, status: PeerStatus): Promise<void> {
+    await this.callVoid('SELECT firefly_set_peer_status(?, ?)', [peerID, status]);
+  }
+
+  // --- MST drilldown -------------------------------------------------------
+
+  async syncStart(): Promise<string> {
+    return this.callScalarString('SELECT firefly_sync_start()', []);
+  }
+
+  async syncGossip(label: string): Promise<Uint8Array> {
+    return this.callScalarBlob('SELECT firefly_sync_gossip(?)', [label]);
+  }
+
+  async syncGetPages(label: string, request: Uint8Array): Promise<Uint8Array> {
+    return this.callScalarBlob('SELECT firefly_sync_get_pages(?, ?)', [
+      label,
+      request,
+    ]);
+  }
+
+  async syncEnd(label: string): Promise<void> {
+    await this.callVoid('SELECT firefly_sync_end(?)', [label]);
+  }
+
+  async reconcileStart(gossip: Uint8Array): Promise<Uint8Array | null> {
+    return this.callScalarBlobOrNull('SELECT firefly_reconcile_start(?)', [gossip]);
+  }
+
+  async reconcileRequestPages(session: Uint8Array): Promise<Uint8Array> {
+    return this.callScalarBlob('SELECT firefly_reconcile_request_pages(?)', [
+      session,
+    ]);
+  }
+
+  async reconcileContinue(
+    session: Uint8Array,
+    pages: Uint8Array,
+  ): Promise<Uint8Array> {
+    return this.callScalarBlob('SELECT firefly_reconcile_continue(?, ?)', [
+      session,
+      pages,
+    ]);
+  }
+
+  async reconcileResult(session: Uint8Array): Promise<Uint8Array> {
+    return this.callScalarBlob('SELECT firefly_reconcile_result(?)', [session]);
+  }
+
+  // --- bulk push/pull ------------------------------------------------------
+
+  async changes(keys: readonly bigint[]): Promise<Uint8Array> {
+    const blob = encodeKeysU32(keys);
+    return this.callScalarBlob('SELECT firefly_changes(?)', [blob]);
+  }
+
+  async apply(blob: Uint8Array): Promise<ApplyResult> {
+    const raw = await this.callScalarBlob('SELECT firefly_apply(?)', [blob]);
+    // firefly_apply's blob layout isn't parsed here — callers treat it as
+    // opaque (the relay's PushAck reports applied/conflict counts).
+    return { applied: 0, raw };
+  }
+
+  // --- signed-migration chain ---------------------------------------------
+
+  async migrationChainHead(): Promise<{ seq: number; hash: Uint8Array } | null> {
+    const row = await this.db.getFirstAsync<{
+      seq: number;
+      envelope_hash: Uint8Array | ArrayBuffer | null;
+    }>(
+      'SELECT seq, envelope_hash FROM firefly_migration_chain ORDER BY seq DESC LIMIT 1',
+    );
+    if (!row || row.envelope_hash === null) return null;
+    return { seq: row.seq, hash: ensureUint8Array(row.envelope_hash) };
+  }
+
+  async applySignedMigration(envelope: Uint8Array): Promise<number> {
+    const aliased = aliasScalar('SELECT firefly_apply_signed_migration(?)');
+    const row = await this.db.getFirstAsync<ScalarRow<number>>(aliased, envelope);
+    if (!row || typeof row.v !== 'number') {
+      throw new Error('firefly_apply_signed_migration returned non-number');
+    }
+    return row.v;
+  }
+
+  // --- app-level CRUD ------------------------------------------------------
+
+  async exec(sql: string, params: readonly unknown[] = []): Promise<void> {
+    if (params.length === 0) {
+      await this.db.execAsync(sql);
+      return;
+    }
+    await this.db.runAsync(sql, ...(params as SQLite.SQLiteBindValue[]));
+  }
+
+  async query<T = Record<string, unknown>>(
+    sql: string,
+    params: readonly unknown[] = [],
+  ): Promise<T[]> {
+    const rows = await this.db.getAllAsync<T>(
+      sql,
+      ...(params as SQLite.SQLiteBindValue[]),
+    );
+    return rows;
+  }
+}
+
+/**
+ * When the client config names a database file, the provided connection must
+ * be open on that file — dbName/secure-storage scoping and the change-listener
+ * registry all assume config and connection agree. Compares basenames (the
+ * config path may be a bare name while expo-sqlite reports the resolved
+ * absolute path); skipped when the config omits dbPath (the handle is the
+ * source of truth) and for in-memory / pathless handles, which have nothing
+ * to compare.
+ */
+function assertSameDatabase(
+  path: string | undefined,
+  db: SQLite.SQLiteDatabase,
+): void {
+  if (path === undefined || path === '' || path === ':memory:') return;
+  const actual = db.databasePath;
+  if (!actual || actual === ':memory:') return;
+  const expected = path.slice(path.lastIndexOf('/') + 1);
+  const actualName = actual.slice(actual.lastIndexOf('/') + 1);
+  if (actualName !== expected) {
+    throw new Error(
+      `ExpoSqliteDriver: the provided connection is open on "${actual}", but ` +
+        `the client config names "${path}" — these must be the same database file`,
+    );
+  }
+}
+
+/**
+ * Rewrite `SELECT firefly_xxx(?, ?)` to `SELECT firefly_xxx(?, ?) AS v` so
+ * getFirstAsync's row object has a stable column key. We only ever do this on
+ * pre-known SQL strings written inside this file, so no parser is needed —
+ * append before any trailing semicolon.
+ */
+function aliasScalar(sql: string): string {
+  const trimmed = sql.replace(/;\s*$/, '');
+  return `${trimmed} AS v`;
+}
+
+function ensureUint8Array(v: unknown): Uint8Array {
+  if (v instanceof Uint8Array) return v;
+  if (v instanceof ArrayBuffer) return new Uint8Array(v);
+  if (typeof v === 'string') return new TextEncoder().encode(v);
+  throw new Error(`expected blob scalar, got ${typeof v}`);
+}

package/src/drivers/websocket.ts

@@ -0,0 +1,166 @@
+// Expo / React Native WebSocket driver. Wraps the global WebSocket exposed by
+// React Native, which accepts a 3rd-arg options object containing `headers`
+// (the spec WebSocket constructor doesn't, but RN's polyfill does — that's
+// how we pass the JWT bearer to the relay).
+//
+// Mirrors NodeWebSocketDriver from @fireflydb/node-test-driver.
+
+import type { WebSocketDriver, WsConn } from '@fireflydb/core';
+import { WsCloseError } from '@fireflydb/core';
+
+export class ExpoWebSocketDriver implements WebSocketDriver {
+  async connect(url: string, headers: Record<string, string>): Promise<WsConn> {
+    // RN's WebSocket constructor: new WebSocket(url, protocols?, options?)
+    // where options.headers is forwarded to the upgrade request. Standard DOM
+    // WebSocket has no such overload — this is RN-specific. We cast through
+    // `any` to express the third arg.
+    const ws = new (WebSocket as unknown as RNWebSocketCtor)(url, undefined, {
+      headers,
+    });
+    ws.binaryType = 'arraybuffer';
+    await new Promise<void>((resolve, reject) => {
+      const onOpen = () => {
+        ws.removeEventListener('error', onErr as EventListener);
+        resolve();
+      };
+      const onErr = (ev: Event) => {
+        ws.removeEventListener('open', onOpen);
+        const err = (ev as ErrorEvent).message
+          ? new Error((ev as ErrorEvent).message)
+          : new Error('WebSocket error before open');
+        reject(err);
+      };
+      ws.addEventListener('open', onOpen, { once: true });
+      ws.addEventListener('error', onErr as EventListener, { once: true });
+    });
+    return new ExpoWsConn(ws);
+  }
+}
+
+interface RNWebSocketCtor {
+  new (
+    url: string,
+    protocols?: string | string[] | undefined,
+    options?: { headers?: Record<string, string> },
+  ): WebSocket;
+}
+
+class ExpoWsConn implements WsConn {
+  private readonly queue: Uint8Array[] = [];
+  private waiter: ((value: IteratorResult<Uint8Array>) => void) | null = null;
+  private rejecter: ((err: Error) => void) | null = null;
+  private closed = false;
+  private closeErr: Error | null = null;
+
+  constructor(private readonly ws: WebSocket) {
+    ws.addEventListener('message', (ev) => {
+      const data = (ev as MessageEvent).data;
+      // binaryType=arraybuffer means binary frames arrive as ArrayBuffer; text
+      // frames come as string. Protocol is binary-only; ignore strings.
+      if (typeof data === 'string') return;
+      if (data instanceof ArrayBuffer) {
+        this.deliver(new Uint8Array(data));
+      } else if (data instanceof Uint8Array) {
+        this.deliver(data);
+      }
+    });
+    ws.addEventListener('close', (ev) => {
+      const ce = ev as CloseEvent;
+      // Clean close (1000 / 1005 = no code) ends the iterator without error.
+      if (ce.code === 1000 || ce.code === 1005) {
+        this.finishClean();
+      } else {
+        this.finishError(new WsCloseError(ce.code, ce.reason ?? ''));
+      }
+    });
+    ws.addEventListener('error', () => {
+      // RN error events don't carry a useful message; surface a generic err.
+      // The close event that follows usually carries the real reason.
+      if (!this.closed) {
+        this.finishError(new Error('WebSocket error'));
+      }
+    });
+  }
+
+  private deliver(buf: Uint8Array): void {
+    if (this.waiter) {
+      const w = this.waiter;
+      this.waiter = null;
+      this.rejecter = null;
+      w({ value: buf, done: false });
+      return;
+    }
+    this.queue.push(buf);
+  }
+
+  private finishClean(): void {
+    this.closed = true;
+    if (this.waiter) {
+      const w = this.waiter;
+      this.waiter = null;
+      this.rejecter = null;
+      w({ value: undefined, done: true });
+    }
+  }
+
+  private finishError(err: Error): void {
+    this.closed = true;
+    this.closeErr = err;
+    if (this.rejecter) {
+      const r = this.rejecter;
+      this.waiter = null;
+      this.rejecter = null;
+      r(err);
+    }
+  }
+
+  async send(bytes: Uint8Array): Promise<void> {
+    // RN's WebSocket.send accepts ArrayBuffer / Blob / string. Hermes treats
+    // Uint8Array.buffer as ArrayBuffer, but we slice to be safe in case the
+    // view doesn't span the whole buffer.
+    const ab =
+      bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+        ? bytes.buffer
+        : bytes.slice().buffer;
+    this.ws.send(ab as ArrayBuffer);
+  }
+
+  recv(): AsyncIterableIterator<Uint8Array> {
+    const self = this;
+    return {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      next(): Promise<IteratorResult<Uint8Array>> {
+        if (self.queue.length > 0) {
+          return Promise.resolve({ value: self.queue.shift()!, done: false });
+        }
+        if (self.closed) {
+          if (self.closeErr) return Promise.reject(self.closeErr);
+          return Promise.resolve({ value: undefined, done: true });
+        }
+        return new Promise<IteratorResult<Uint8Array>>((resolve, reject) => {
+          self.waiter = resolve;
+          self.rejecter = reject;
+        });
+      },
+      return(): Promise<IteratorResult<Uint8Array>> {
+        return Promise.resolve({ value: undefined, done: true });
+      },
+    };
+  }
+
+  async close(code?: number, reason?: string): Promise<void> {
+    if (this.ws.readyState === 3 /* CLOSED */) return;
+    return new Promise<void>((resolve) => {
+      const onClose = () => resolve();
+      this.ws.addEventListener('close', onClose, { once: true });
+      try {
+        this.ws.close(code ?? 1000, reason ?? '');
+      } catch {
+        this.ws.removeEventListener('close', onClose);
+        resolve();
+      }
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,120 @@
+// Public API of @fireflydb/expo.
+//
+// `createFireflyClient(config)` returns a FireflyClient pre-wired with the
+// Expo drivers (expo-sqlite, expo-secure-store, RN WebSocket). Apps still need
+// to provide a TokenProvider (their OIDC flow) since auth is app-specific.
+
+// Side-effect import: installs globalThis.crypto.getRandomValues using
+// expo-crypto. Required because Hermes doesn't ship Web Crypto and
+// @noble/ed25519 needs getRandomValues for device key generation. See
+// polyfill.ts for details.
+import './polyfill';
+
+import {
+  FireflyClient,
+  type FireflyClientConfig,
+  type TokenProvider,
+} from '@fireflydb/core';
+
+import {
+  ExpoSqliteDriver,
+  type ExpoSqliteDriverOptions,
+} from './drivers/sqlite';
+import {
+  ExpoSecureStorageDriver,
+  type ExpoSecureStorageOptions,
+} from './drivers/secureStorage';
+import { ExpoWebSocketDriver } from './drivers/websocket';
+
+export interface CreateFireflyClientConfig
+  extends Omit<FireflyClientConfig, 'drivers'> {
+  /** Provides JWTs to the relay; integrators bring their own OIDC flow. */
+  token: TokenProvider;
+  /**
+   * SQLite driver options. `db` (required) is the app-opened expo-sqlite
+   * connection the client runs on — the app's own queries must use the same
+   * handle so they hit libfirefly's CRDT triggers and sync. `extensionPath`
+   * optionally overrides the libfirefly binary (rare).
+   */
+  sqliteOptions: ExpoSqliteDriverOptions;
+  /** Forwarded to expo-secure-store. */
+  secureStorageOptions?: ExpoSecureStorageOptions;
+}
+
+/**
+ * Build a FireflyClient pre-wired with Expo drivers. Call `init()` on the
+ * returned client before `sync()`.
+ */
+export function createFireflyClient(
+  cfg: CreateFireflyClientConfig,
+): FireflyClient {
+  const {
+    token,
+    sqliteOptions,
+    secureStorageOptions,
+    ...rest
+  } = cfg;
+  return new FireflyClient({
+    ...rest,
+    drivers: {
+      sqlite: new ExpoSqliteDriver(sqliteOptions),
+      websocket: new ExpoWebSocketDriver(),
+      secureStorage: new ExpoSecureStorageDriver(secureStorageOptions ?? {}),
+      token,
+    },
+  });
+}
+
+export {
+  subscribeToChanges,
+  type FireflyChangePayload,
+} from './FireflyClientModule';
+
+export {
+  ExpoSqliteDriver,
+  type ExpoSqliteDriverOptions,
+} from './drivers/sqlite';
+export {
+  ExpoSecureStorageDriver,
+  type ExpoSecureStorageOptions,
+} from './drivers/secureStorage';
+export { ExpoWebSocketDriver } from './drivers/websocket';
+
+// Re-export everything app code typically needs from @fireflydb/core so
+// consumers don't need a separate dependency on it.
+export {
+  FireflyClient,
+  type FireflyClientConfig,
+  type TokenProvider,
+  type SecureStorageDriver,
+  type SqliteDriver,
+  type SqliteDb,
+  type ApplyResult,
+  type PeerStatus,
+  type WebSocketDriver,
+  type WsConn,
+  WsCloseError,
+  WS_CLOSE_TRY_AGAIN_LATER,
+  isTryAgainLater,
+  type SyncResult,
+  type TrustedPeer,
+  type ChangeEvent,
+  type ChangeHandler,
+  type ChangeSubscription,
+  loadOrCreateDeviceKey,
+  deriveDeviceKey,
+  generateDeviceKey,
+  type DeviceKeyPair,
+} from '@fireflydb/core';
+
+// Multi-pod routing surface, for apps that drive the cross-pod 307 follow over HTTP themselves.
+export {
+  NotOwnerRedirect,
+  OwnerRouter,
+  RedirectLoopError,
+  FireflySqlClient,
+  RestoringError,
+  decodeNotOwner,
+  type NotOwner,
+  type SqlClientConfig,
+} from '@fireflydb/core';