@pyric/cli 0.1.0-alpha.10 → 0.1.0-alpha.12

package/src/serve/worker/client/handles.ts

@@ -0,0 +1,91 @@
+/**
+ * Worker-client handle types — the opaque, port-carrying references the client
+ * surface hands back to callers. Shared by every API family (firestore, auth,
+ * rtdb, storage), so they live in one leaf module with no runtime dependencies
+ * beyond the wire-protocol descriptor types.
+ */
+import type {
+  DocRef,
+  CollRef,
+  QueryDescriptor,
+  InboundMessage,
+  OutboundMessage,
+} from '../protocol.js';
+
+/** The exact transport contract shared by native MessagePort and SW relay ports. */
+export interface ClientPort {
+  onmessage: ((event: MessageEvent<OutboundMessage>) => void) | null;
+  postMessage(message: InboundMessage): void;
+  start(): void;
+  close(): void;
+}
+
+/** Opaque client-side Firestore handle. Holds the MessagePort to the worker. */
+export interface ClientDb {
+  readonly __kind: 'client-db';
+  readonly port: ClientPort;
+}
+
+export interface ClientRtdb {
+  readonly __kind: 'client-rtdb';
+  readonly port: ClientPort;
+}
+
+export interface RtdbRefHandle {
+  readonly __kind: 'rtdb-ref';
+  readonly port: ClientPort;
+  readonly path: string;
+  readonly key: string | null;
+  readonly parent: RtdbRefHandle | null;
+  readonly root: RtdbRefHandle;
+  toString(): string;
+}
+
+export interface RtdbDataSnapshot {
+  readonly key: string | null;
+  readonly size: number;
+  exists(): boolean;
+  val(): unknown;
+  child(path: string): RtdbDataSnapshot;
+  hasChild(path: string): boolean;
+  hasChildren(): boolean;
+  exportVal(): unknown;
+  toJSON(): unknown;
+  forEach(cb: (child: RtdbDataSnapshot) => boolean | void): boolean;
+  readonly ref: RtdbRefHandle;
+}
+
+/** Client-side document reference — carries a DocRef descriptor + port. */
+export interface DocRefHandle {
+  readonly __kind: 'doc-ref';
+  readonly descriptor: DocRef;
+  readonly port: ClientPort;
+  readonly id: string;
+  readonly path: string;
+}
+
+/** Client-side collection reference. */
+export interface CollRefHandle {
+  readonly __kind: 'coll-ref';
+  readonly descriptor: CollRef;
+  readonly port: ClientPort;
+  readonly id: string;
+  readonly path: string;
+}
+
+/** Client-side query. */
+export interface QueryHandle {
+  readonly __kind: 'query';
+  readonly descriptor: QueryDescriptor;
+  readonly port: ClientPort;
+}
+
+/** Union of all client handles. */
+export type AnyHandle = ClientDb | DocRefHandle | CollRefHandle | QueryHandle;
+
+/** Unsubscribe function returned by every streaming subscription. */
+export type Unsubscribe = () => void;
+
+export function lastSegment(path: string): string {
+  return path.split('/').at(-1) ?? path;
+}

package/src/serve/worker/client/messaging.ts

@@ -0,0 +1,119 @@
+/** Worker-backed Firebase Messaging client/SW receive planes. */
+import type {
+  DeliverSpec,
+  DeliveryResult,
+  GetTokenOptions,
+  MessagePayload,
+  NextFn,
+  Observer,
+  Unsubscribe,
+} from 'pyric/messaging';
+import { closeSubscription, nextId, nextSubId, openSnapshotSubscription, rpc } from './core.js';
+import type { ClientDb, ClientPort } from './handles.js';
+
+type ClientVisibilityState = 'visible' | 'hidden';
+
+const DEFAULT_REGISTRATION_ID = 'swreg-port-default';
+const registrationIds = new WeakMap<object, string>();
+let registrationCounter = 0;
+
+function registrationIdOf(registration: object | undefined): string {
+  if (registration === undefined) return DEFAULT_REGISTRATION_ID;
+  const existing = registrationIds.get(registration);
+  if (existing) return existing;
+  const id = `swreg-page-${++registrationCounter}`;
+  registrationIds.set(registration, id);
+  return id;
+}
+
+export interface ClientMessaging {
+  readonly __kind: 'client-messaging';
+  readonly port: ClientPort;
+  activeRegistrationId: string;
+}
+
+export function messagingGetMessaging(db: ClientDb): ClientMessaging {
+  return {
+    __kind: 'client-messaging',
+    port: db.port,
+    activeRegistrationId: DEFAULT_REGISTRATION_ID,
+  };
+}
+
+export async function messagingGetToken(
+  messaging: ClientMessaging,
+  options?: GetTokenOptions,
+): Promise<string> {
+  const registrationId = registrationIdOf(options?.serviceWorkerRegistration);
+  messaging.activeRegistrationId = registrationId;
+  const result = await rpc(messaging.port, {
+    t: 'op',
+    id: nextId(),
+    method: 'messaging.getToken',
+    registrationId,
+  }) as { token: string };
+  return result.token;
+}
+
+export async function messagingDeleteToken(messaging: ClientMessaging): Promise<boolean> {
+  return await rpc(messaging.port, {
+    t: 'op',
+    id: nextId(),
+    method: 'messaging.deleteToken',
+    registrationId: messaging.activeRegistrationId,
+  }) as boolean;
+}
+
+export async function messagingSetVisibility(
+  messaging: ClientMessaging,
+  state: ClientVisibilityState,
+): Promise<void> {
+  await rpc(messaging.port, {
+    t: 'op',
+    id: nextId(),
+    method: 'messaging.setVisibility',
+    state,
+  });
+}
+
+/**
+ * The worker transport for `pyric/messaging`'s `sandbox.deliver` — injects a
+ * simulated delivery into the app's real (worker-hosted) broker. The full
+ * {@link DeliverSpec} crosses the wire; the host sets this port's client
+ * visibility from `spec.visibilityState` before routing, so `visible` reaches
+ * `onMessage` and `hidden` reaches `onBackgroundMessage`.
+ */
+export async function messagingDeliver(
+  messaging: ClientMessaging,
+  spec: DeliverSpec,
+): Promise<DeliveryResult> {
+  return await rpc(messaging.port, {
+    t: 'op',
+    id: nextId(),
+    method: 'messaging.deliver',
+    spec,
+  }) as DeliveryResult;
+}
+
+export function messagingSubscribe(
+  messaging: ClientMessaging,
+  target: 'messaging.foreground' | 'messaging.background',
+  nextOrObserver: NextFn<MessagePayload> | Observer<MessagePayload>,
+): Unsubscribe {
+  const next = typeof nextOrObserver === 'function'
+    ? nextOrObserver
+    : nextOrObserver.next.bind(nextOrObserver);
+  const error = typeof nextOrObserver === 'function'
+    ? undefined
+    : (value: unknown) => nextOrObserver.error(
+        value instanceof Error ? value : new Error(String(value)),
+      );
+  const subId = nextSubId();
+  openSnapshotSubscription(
+    messaging.port,
+    subId,
+    { port: messaging.port, next: (value) => next(value as MessagePayload), error },
+    { t: 'sub', subId, target },
+  );
+  return () => closeSubscription(messaging.port, subId);
+}

package/src/serve/worker/client/presence.ts

@@ -0,0 +1,174 @@
+/**
+ * Worker-client connected-page presence (#227).
+ *
+ * Each served page (app or Studio) identifies itself with a stable-per-page
+ * `clientId`, registers with the SharedWorker, heartbeats on a bounded
+ * interval, updates route/visibility, and best-effort disconnects on
+ * `pagehide`. Studio also subscribes for live snapshots.
+ *
+ * Presence is independent of auth sessions and Firestore subscriptions.
+ */
+
+import type {
+  InboundMessage,
+  PresenceClientKind,
+  PresenceSnapshot,
+  PresenceVisibility,
+} from '../protocol.js';
+import {
+  PRESENCE_HEARTBEAT_INTERVAL_MS,
+  PRESENCE_STALE_MS,
+} from '../presence-timing.js';
+import { closeSubscription, nextId, nextSubId, openSnapshotSubscription, rpc } from './core.js';
+import type { ClientDb, Unsubscribe } from './handles.js';
+
+export type { PresenceClientKind, PresenceSnapshot, PresenceVisibility };
+export { PRESENCE_HEARTBEAT_INTERVAL_MS, PRESENCE_STALE_MS };
+
+/** Mint a random client id (page-lifetime). */
+export function mintPresenceClientId(): string {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  return `page-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function currentRoute(): string {
+  if (typeof location === 'undefined') return '/';
+  return `${location.pathname}${location.search}${location.hash}`;
+}
+
+function currentVisibility(): PresenceVisibility {
+  if (typeof document === 'undefined') return 'visible';
+  return document.visibilityState === 'hidden' ? 'hidden' : 'visible';
+}
+
+export interface PresenceSession {
+  /** Logical page id — Studio uses this to label "This page". */
+  readonly clientId: string;
+  readonly kind: PresenceClientKind;
+  /** Stop heartbeats, listeners, and send a best-effort disconnect. */
+  stop(): void;
+}
+
+export interface StartPresenceOptions {
+  db: ClientDb;
+  kind: PresenceClientKind;
+  /** Override client id (tests / reconnect). Default: mint a new one. */
+  clientId?: string;
+  /** Heartbeat interval. Default: {@link PRESENCE_HEARTBEAT_INTERVAL_MS}. */
+  heartbeatIntervalMs?: number;
+}
+
+/**
+ * Register this page with the worker and keep the lease alive until
+ * {@link PresenceSession.stop} or `pagehide`.
+ */
+export function startPresence(opts: StartPresenceOptions): PresenceSession {
+  const { db, kind } = opts;
+  const clientId = opts.clientId ?? mintPresenceClientId();
+  const intervalMs = opts.heartbeatIntervalMs ?? PRESENCE_HEARTBEAT_INTERVAL_MS;
+  let stopped = false;
+  let timer: ReturnType<typeof setInterval> | null = null;
+
+  const register = (): void => {
+    void rpc(db.port, {
+      t: 'op',
+      id: nextId(),
+      method: 'presence.register',
+      clientId,
+      kind,
+      route: currentRoute(),
+      visibility: currentVisibility(),
+    }).catch(() => {});
+  };
+
+  const heartbeat = (): void => {
+    void rpc(db.port, {
+      t: 'op',
+      id: nextId(),
+      method: 'presence.heartbeat',
+      clientId,
+    }).catch(() => {});
+  };
+
+  const update = (): void => {
+    void rpc(db.port, {
+      t: 'op',
+      id: nextId(),
+      method: 'presence.update',
+      clientId,
+      route: currentRoute(),
+      visibility: currentVisibility(),
+    }).catch(() => {});
+  };
+
+  const disconnect = (): void => {
+    void rpc(db.port, {
+      t: 'op',
+      id: nextId(),
+      method: 'presence.disconnect',
+      clientId,
+    }).catch(() => {});
+  };
+
+  register();
+
+  if (typeof document !== 'undefined') {
+    document.addEventListener('visibilitychange', update);
+  }
+  if (typeof window !== 'undefined') {
+    window.addEventListener('popstate', update);
+    window.addEventListener('hashchange', update);
+    // Best-effort clean disconnect; lease expiry covers unclean shutdown.
+    window.addEventListener('pagehide', onPageHide);
+    // Heartbeats only in a real page — unit shims have no document lifecycle.
+    timer = setInterval(() => {
+      if (!stopped) heartbeat();
+    }, intervalMs);
+  }
+
+  function onPageHide(): void {
+    stop();
+  }
+
+  function stop(): void {
+    if (stopped) return;
+    stopped = true;
+    if (timer != null) {
+      clearInterval(timer);
+      timer = null;
+    }
+    if (typeof document !== 'undefined') {
+      document.removeEventListener('visibilitychange', update);
+    }
+    if (typeof window !== 'undefined') {
+      window.removeEventListener('popstate', update);
+      window.removeEventListener('hashchange', update);
+      window.removeEventListener('pagehide', onPageHide);
+    }
+    disconnect();
+  }
+
+  return { clientId, kind, stop };
+}
+
+/**
+ * Subscribe to the worker's authoritative presence snapshot. The callback
+ * fires immediately with the current snapshot, then on every change.
+ */
+export function subscribePresence(
+  db: ClientDb,
+  callback: (snapshot: PresenceSnapshot) => void,
+): Unsubscribe {
+  const subId = nextSubId();
+  openSnapshotSubscription(db.port, subId, {
+    port: db.port,
+    next: (value) => {
+      callback(value as PresenceSnapshot);
+    },
+  }, { t: 'sub', subId, target: 'presence' } satisfies InboundMessage);
+  return () => {
+    closeSubscription(db.port, subId);
+  };
+}

package/src/serve/worker/client/rtdb.ts

@@ -0,0 +1,311 @@
+/**
+ * RTDB shared-worker modular subset — refs, push-id generation, value reads,
+ * writes, and `onValue` listeners over the worker port, plus the admin-lens data
+ * ops for the Pyric Studio RTDB viewer.
+ */
+
+import type { InboundMessage } from '../protocol.js';
+import {
+  isDisconnectedPort,
+  closeSubscription,
+  openSnapshotSubscription,
+  nextId,
+  nextSubId,
+  rpc,
+  dataRpc,
+  _snapSubs,
+  _defaultLens,
+  stampIssuer,
+} from './core.js';
+import type {
+  ClientDb,
+  ClientPort,
+  ClientRtdb,
+  RtdbRefHandle,
+  RtdbDataSnapshot,
+  Unsubscribe,
+} from './handles.js';
+import { getFirestore } from './connection.js';
+
+// ─── RTDB shared-worker modular subset ────────────────────────────────────
+
+export function rtdbGetDatabase(source?: ClientDb | string | URL, name?: string): ClientRtdb {
+  if (source && typeof source === 'object' && 'port' in source) {
+    return { __kind: 'client-rtdb', port: (source as ClientDb).port };
+  }
+  const firestore = getFirestore(source ?? '/__pyric/sdk/worker.js', name);
+  return { __kind: 'client-rtdb', port: firestore.port };
+}
+
+function normalizeRtdbPath(path?: string): string {
+  const joined = (path ?? '/').split('/').filter(Boolean).join('/');
+  return joined ? `/${joined}` : '/';
+}
+
+function rtdbKey(path: string): string | null {
+  const parts = path.split('/').filter(Boolean);
+  return parts.at(-1) ?? null;
+}
+
+const RTDB_PUSH_CHARS =
+  '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
+
+let lastRtdbPushTime = 0;
+
+const lastRtdbRandChars: number[] = new Array(12).fill(0);
+
+function generateRtdbPushId(now: number = Date.now()): string {
+  const duplicateTime = now === lastRtdbPushTime;
+  lastRtdbPushTime = now;
+
+  const timeStampChars: string[] = new Array(8);
+  let ts = now;
+  for (let i = 7; i >= 0; i--) {
+    timeStampChars[i] = RTDB_PUSH_CHARS.charAt(ts % 64);
+    ts = Math.floor(ts / 64);
+  }
+  if (ts !== 0) throw new Error('RTDB push-id: timestamp overflow.');
+
+  if (!duplicateTime) {
+    for (let i = 0; i < 12; i++) lastRtdbRandChars[i] = Math.floor(Math.random() * 64);
+  } else {
+    let i: number;
+    for (i = 11; i >= 0 && lastRtdbRandChars[i] === 63; i--) lastRtdbRandChars[i] = 0;
+    if (i < 0) {
+      for (let j = 0; j < 12; j++) lastRtdbRandChars[j] = Math.floor(Math.random() * 64);
+    } else {
+      lastRtdbRandChars[i] = (lastRtdbRandChars[i] ?? 0) + 1;
+    }
+  }
+
+  let id = timeStampChars.join('');
+  for (let i = 0; i < 12; i++) id += RTDB_PUSH_CHARS.charAt(lastRtdbRandChars[i]!);
+  return id;
+}
+
+function makeRtdbRef(port: ClientPort, path: string): RtdbRefHandle {
+  const normalized = normalizeRtdbPath(path);
+  const parts = normalized.split('/').filter(Boolean);
+  const parentPath = parts.length > 0 ? `/${parts.slice(0, -1).join('/')}` : '/';
+  const self: RtdbRefHandle = {
+    __kind: 'rtdb-ref',
+    port,
+    path: normalized,
+    key: rtdbKey(normalized),
+    get parent() {
+      return normalized === '/' ? null : makeRtdbRef(port, parentPath);
+    },
+    get root() {
+      return makeRtdbRef(port, '/');
+    },
+    toString() {
+      return `worker://rtdb${normalized}`;
+    },
+  };
+  return self;
+}
+
+export function rtdbRef(db: ClientRtdb, path?: string): RtdbRefHandle {
+  if (isDisconnectedPort(db.port)) {
+    throw new Error('FIREBASE FATAL ERROR: Cannot call ref on a deleted database. ');
+  }
+  return makeRtdbRef(db.port, path ?? '/');
+}
+
+export function rtdbChild(parent: RtdbRefHandle, path: string): RtdbRefHandle {
+  return makeRtdbRef(parent.port, `${parent.path}/${path}`);
+}
+
+function valueAt(root: unknown, path: string): unknown {
+  let current = root;
+  for (const segment of path.split('/').filter(Boolean)) {
+    if (current === null || typeof current !== 'object') return null;
+    current = (current as Record<string, unknown>)[segment];
+  }
+  return current === undefined ? null : current;
+}
+
+function makeRtdbSnapshot(refHandle: RtdbRefHandle, value: unknown, exists?: boolean): RtdbDataSnapshot {
+  const childValue = (path: string) => valueAt(value, path);
+  const size =
+    value && typeof value === 'object' && !Array.isArray(value)
+      ? Object.keys(value as Record<string, unknown>).length
+      : 0;
+  const snapshot: RtdbDataSnapshot = {
+    key: refHandle.key,
+    size,
+    exists: () => exists ?? (value !== null && value !== undefined),
+    val: () => value ?? null,
+    child: (path) => makeRtdbSnapshot(rtdbChild(refHandle, path), childValue(path)),
+    hasChild: (path) => childValue(path) !== null && childValue(path) !== undefined,
+    hasChildren: () => size > 0,
+    exportVal: () => value ?? null,
+    toJSON: () => value ?? null,
+    forEach: (cb) => {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+      for (const [key, childVal] of Object.entries(value as Record<string, unknown>)) {
+        if (cb(makeRtdbSnapshot(rtdbChild(refHandle, key), childVal)) === true) return true;
+      }
+      return false;
+    },
+    ref: refHandle,
+  };
+  return snapshot;
+}
+
+function hydrateRtdbSnapshot(refHandle: RtdbRefHandle, wire: unknown): RtdbDataSnapshot {
+  const payload = wire as { value?: unknown; exists?: boolean; key?: string | null };
+  return makeRtdbSnapshot(refHandle, payload.value ?? null, payload.exists);
+}
+
+export async function rtdbGet(r: RtdbRefHandle): Promise<RtdbDataSnapshot> {
+  return hydrateRtdbSnapshot(
+    r,
+    await dataRpc(r.port, { t: 'op', id: nextId(), method: 'rtdb.get', path: r.path }),
+  );
+}
+
+export async function adminReadRtdbState(db: ClientDb | ClientRtdb): Promise<unknown> {
+  return rpc(db.port, { t: 'op', id: nextId(), method: 'rtdb.adminSnapshot' });
+}
+
+export async function adminSetRtdbValue(
+  db: ClientDb | ClientRtdb,
+  path: string,
+  value: unknown,
+): Promise<void> {
+  await rpc(db.port, {
+    t: 'op',
+    id: nextId(),
+    method: 'rtdb.set',
+    path,
+    value,
+    actAs: { mode: 'admin' },
+  });
+}
+
+export async function adminUpdateRtdbValue(
+  db: ClientDb | ClientRtdb,
+  path: string,
+  values: Record<string, unknown>,
+): Promise<void> {
+  await rpc(db.port, {
+    t: 'op',
+    id: nextId(),
+    method: 'rtdb.update',
+    path,
+    values,
+    actAs: { mode: 'admin' },
+  });
+}
+
+export async function adminDeleteRtdbValue(
+  db: ClientDb | ClientRtdb,
+  path: string,
+): Promise<void> {
+  await rpc(db.port, {
+    t: 'op',
+    id: nextId(),
+    method: 'rtdb.remove',
+    path,
+    actAs: { mode: 'admin' },
+  });
+}
+
+/**
+ * Subscribe to the raw value at an RTDB path with the ADMIN lens (Pyric Studio
+ * data viewer). Rides the same `{service:'rtdb'}` value-subscription channel as
+ * `rtdbOnValue`, but pins `actAs: {mode:'admin'}` per-sub instead of following
+ * the module default lens, so Studio's viewer stays admin (PRINCIPLES M3) while
+ * the page's own listeners keep their session semantics.
+ *
+ * `next` receives the plain JSON value at `path` (`null` when absent) on
+ * subscribe and again after every write that changes the subtree.
+ */
+export function adminSubscribeRtdbValue(
+  db: ClientDb | ClientRtdb,
+  path: string,
+  next: (value: unknown) => void,
+  error?: (err: unknown) => void,
+): Unsubscribe {
+  const subId = nextSubId();
+  const opened = openSnapshotSubscription(
+    db.port,
+    subId,
+    {
+      port: db.port,
+      next: (wire) => next((wire as { value?: unknown } | null)?.value ?? null),
+      error,
+    },
+    stampIssuer({
+      t: 'sub',
+      subId,
+      target: { service: 'rtdb', path: normalizeRtdbPath(path) },
+      actAs: { mode: 'admin' },
+    } satisfies InboundMessage),
+  );
+  if (!opened && error) {
+    queueMicrotask(() => error(new Error('FIREBASE FATAL ERROR: Database has been deleted.')));
+  }
+  return () => {
+    closeSubscription(db.port, subId);
+  };
+}
+
+export async function rtdbSet(r: RtdbRefHandle, value: unknown): Promise<void> {
+  await dataRpc(r.port, { t: 'op', id: nextId(), method: 'rtdb.set', path: r.path, value });
+}
+
+export async function rtdbUpdate(r: RtdbRefHandle, values: Record<string, unknown>): Promise<void> {
+  await dataRpc(r.port, { t: 'op', id: nextId(), method: 'rtdb.update', path: r.path, values });
+}
+
+export async function rtdbRemove(r: RtdbRefHandle): Promise<void> {
+  await dataRpc(r.port, { t: 'op', id: nextId(), method: 'rtdb.remove', path: r.path });
+}
+
+export function rtdbPush(r: RtdbRefHandle, value?: unknown): RtdbRefHandle & PromiseLike<RtdbRefHandle> {
+  const key = generateRtdbPushId();
+  const pushed = makeRtdbRef(r.port, `${r.path}/${key}`);
+  const settledRef = makeRtdbRef(r.port, pushed.path);
+  const promise = dataRpc(r.port, { t: 'op', id: nextId(), method: 'rtdb.push', path: r.path, key, value })
+    .then(() => settledRef);
+  return Object.assign(pushed, {
+    then: promise.then.bind(promise),
+    catch: promise.catch.bind(promise),
+  });
+}
+
+export function rtdbOnValue(
+  r: RtdbRefHandle,
+  next: (snap: RtdbDataSnapshot) => void,
+  error?: (err: unknown) => void,
+): Unsubscribe {
+  const subId = nextSubId();
+  const msg: InboundMessage = _defaultLens
+    ? { t: 'sub', subId, target: { service: 'rtdb', path: r.path }, actAs: _defaultLens }
+    : { t: 'sub', subId, target: { service: 'rtdb', path: r.path } };
+  const opened = openSnapshotSubscription(r.port, subId, {
+    port: r.port,
+    next: (wire) => next(hydrateRtdbSnapshot(r, wire)),
+    error,
+  }, stampIssuer(msg));
+  if (!opened && error) queueMicrotask(() => error(new Error('FIREBASE FATAL ERROR: Database has been deleted.')));
+  return () => {
+    closeSubscription(r.port, subId);
+  };
+}
+
+export function rtdbOff(_r: RtdbRefHandle, _eventType?: unknown, _callback?: unknown): void {
+  // Firebase's `off` is callback-specific. The worker bridge exposes unsubscribe
+  // functions from `onValue`; this no-op preserves common app code that calls it
+  // defensively during cleanup.
+}
+
+export function rtdbServerTimestamp(): { readonly __rtdbSentinel: 'serverTimestamp' } {
+  return { __rtdbSentinel: 'serverTimestamp' };
+}
+
+export function rtdbConnectDatabaseEmulator(): void {
+  // Shared worker sandbox is already local.
+}