@pyric/cli 0.1.0-alpha.13 → 0.1.0-alpha.15

package/src/serve/worker/entry.ts

@@ -55,7 +55,7 @@ import { createIndexedDBBackend } from 'pyric/sandbox';
 
 import {
   handleMessage,
-  cleanupPort,
+  cleanupPortWithDisconnect,
   type HostCtx,
   type PortLike,
 } from './host.js';
@@ -188,7 +188,7 @@ workerScope.onconnect = (e: MessageEvent) => {
   // best-effort; subscriptions also GC when the worker itself dies.
   port.addEventListener('close', () => {
     retirement.disconnect(port);
-    if (_ctx) cleanupPort(_ctx, port as unknown as PortLike);
+    if (_ctx) void cleanupPortWithDisconnect(_ctx, port as unknown as PortLike).catch(() => undefined);
   });
 };
 

package/src/serve/worker/host/dispatch.ts

@@ -61,7 +61,7 @@ import { isFirestoreReadOp, handleFirestoreReadOp } from './firestore-reads.js';
 import { isFirestoreWriteOp, handleFirestoreWriteOp } from './firestore-writes.js';
 import { isRulesOp, handleRulesOp } from './rules.js';
 import { isAdminFirestoreOp, handleAdminFirestoreOp } from './admin-firestore.js';
-import { isRtdbOp, handleRtdbOp } from './rtdb.js';
+import { isRtdbOp, handleRtdbOp, drainPortRtdbDisconnects, forgetPortRtdbConnection } from './rtdb.js';
 import { isStorageOp, handleStorageOp } from './storage.js';
 import { isConnectionOp, handleConnectionOp } from './connection.js';
 import { isStudioOp, handleStudioOp } from './studio.js';
@@ -256,7 +256,7 @@ async function dispatchMessage(
     }
   } else if (msg.t === 'disconnect') {
     try {
-      cleanupPort(ctx, port);
+      await cleanupPortWithDisconnect(ctx, port);
       ok(port, msg.id, undefined);
     } catch (error) {
       fail(port, msg.id, error);
@@ -266,6 +266,25 @@ async function dispatchMessage(
   }
 }
 
+/** Best-effort close path: drain queued RTDB work before session teardown. */
+export async function cleanupPortWithDisconnect(ctx: HostCtx, port: PortLike): Promise<void> {
+  let drainFailure: unknown;
+  try {
+    await drainPortRtdbDisconnects(ctx, port);
+  } catch (error) {
+    drainFailure = error;
+  }
+  try {
+    cleanupPort(ctx, port);
+  } catch (error) {
+    if (drainFailure !== undefined) {
+      throw new AggregateError([drainFailure, error], 'Multiple SharedWorker port resources failed to tear down');
+    }
+    throw error;
+  }
+  if (drainFailure !== undefined) throw drainFailure;
+}
+
 // ─── Port cleanup ─────────────────────────────────────────────────────────
 
 /**
@@ -303,6 +322,7 @@ export function cleanupPort(ctx: HostCtx, port: PortLike): void {
   // Presence: best-effort remove this port's logical client when it was the
   // last association (lease expiry remains the correctness path).
   attempt(() => { cleanupPortPresence(ctx, port); });
+  attempt(() => { forgetPortRtdbConnection(ctx, port); });
 
   const portSubs = ctx.subs.get(port);
   if (portSubs) {

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

@@ -14,23 +14,71 @@ import {
   ref as rtdbRef,
   get as rtdbGet,
   set as rtdbSet,
+  setPriority as rtdbSetPriority,
+  setWithPriority as rtdbSetWithPriority,
   update as rtdbUpdate,
   remove as rtdbRemove,
+  onDisconnect as rtdbOnDisconnect,
   serverTimestamp as rtdbServerTimestamp,
+  runTransaction as rtdbRunTransaction,
+  QUERY_SYMBOL,
   sandbox as rtdbSandbox,
   type DataSnapshot,
+  type DatabaseReference,
+  type Query,
 } from 'pyric/database';
+import {
+  DisconnectOperationQueue,
+  type DisconnectOperation,
+} from 'pyric/database/internal';
 
-import type { OpMessage } from '../protocol.js';
+import type { OpMessage, RtdbQuerySpec } from '../protocol.js';
 import { type HostCtx, type PortLike, ok, fail, bestEffortFlush } from '../host-context.js';
 import { lensRtdb } from './core.js';
+import { sameRtdbValue } from '../rtdb-value-equality.js';
 
 export function rtdbSnapToWire(snap: DataSnapshot): unknown {
+  const entries: Array<{
+    key: string;
+    value: unknown;
+    priority: string | number | null;
+    exportValue: unknown;
+  }> = [];
+  snap.forEach((child) => {
+    if (child.key !== null) {
+      entries.push({
+        key: child.key,
+        value: child.val(),
+        priority: child.priority,
+        exportValue: child.exportVal(),
+      });
+    }
+  });
   return {
     key: snap.key,
     exists: snap.exists(),
     value: snap.val(),
     size: snap.size,
+    priority: snap.priority,
+    exportValue: snap.exportVal(),
+    entries,
+  };
+}
+
+export function rtdbTarget(
+  db: Parameters<typeof rtdbRef>[0],
+  path: string,
+  spec?: RtdbQuerySpec,
+): DatabaseReference | Query {
+  const targetRef = rtdbRef(db, path);
+  if (!spec) return targetRef;
+  return {
+    ref: targetRef,
+    _spec: spec,
+    [QUERY_SYMBOL]: true,
+    isEqual: (other) => other === null ? false : other.ref === targetRef && other._spec === spec,
+    toJSON: () => targetRef.toString(),
+    toString: () => targetRef.toString(),
   };
 }
 
@@ -50,12 +98,102 @@ function resolveRtdbSentinels(value: unknown): unknown {
 const RTDB_METHODS = new Set<string>([
   'rtdb.get',
   'rtdb.set',
+  'rtdb.setPriority',
+  'rtdb.setWithPriority',
   'rtdb.update',
   'rtdb.remove',
   'rtdb.push',
   'rtdb.adminSnapshot',
+  'rtdb.onDisconnectSet',
+  'rtdb.onDisconnectUpdate',
+  'rtdb.onDisconnectRemove',
+  'rtdb.onDisconnectCancel',
+  'rtdb.goOffline',
+  'rtdb.goOnline',
+  'rtdb.transactionCommit',
 ]);
 
+interface PortDisconnectMetadata {
+  actAs?: OpMessage['actAs'];
+}
+
+type PortDisconnectOperation = DisconnectOperation<PortDisconnectMetadata>;
+
+const disconnectQueues = new WeakMap<HostCtx, Map<PortLike, DisconnectOperationQueue<PortDisconnectMetadata>>>();
+const offlinePorts = new WeakMap<HostCtx, Set<PortLike>>();
+
+function offlinePortSet(ctx: HostCtx): Set<PortLike> {
+  let ports = offlinePorts.get(ctx);
+  if (!ports) offlinePorts.set(ctx, ports = new Set());
+  return ports;
+}
+
+function portQueue(ctx: HostCtx, port: PortLike): DisconnectOperationQueue<PortDisconnectMetadata> {
+  let ports = disconnectQueues.get(ctx);
+  if (!ports) disconnectQueues.set(ctx, ports = new Map());
+  let queue = ports.get(port);
+  if (!queue) ports.set(port, queue = new DisconnectOperationQueue());
+  return queue;
+}
+
+async function validateDisconnectOperation(ctx: HostCtx, port: PortLike, operation: PortDisconnectOperation): Promise<void> {
+  const db = lensRtdb(ctx, operation.actAs, port);
+  const handle = rtdbOnDisconnect(rtdbRef(db, operation.path));
+  if (operation.kind === 'update') await handle.update(operation.values);
+  else if (operation.kind === 'remove') await handle.remove();
+  else if (operation.priority !== undefined) await handle.setWithPriority(operation.value, operation.priority);
+  else await handle.set(operation.value as never);
+  await handle.cancel();
+}
+
+async function queueDisconnectOperation(ctx: HostCtx, port: PortLike, operation: PortDisconnectOperation): Promise<void> {
+  await validateDisconnectOperation(ctx, port, operation);
+  const queue = portQueue(ctx, port);
+  queue.set(operation);
+}
+
+export async function drainPortRtdbDisconnects(ctx: HostCtx, port: PortLike): Promise<void> {
+  const ports = disconnectQueues.get(ctx);
+  const queue = ports?.get(port);
+  if (!queue) return;
+  ports!.delete(port);
+  const failures: unknown[] = [];
+  for (const operation of queue.takeAll()) {
+    try {
+      const db = lensRtdb(ctx, operation.actAs, port);
+      const target = rtdbRef(db, operation.path);
+      if (operation.kind === 'update') await rtdbUpdate(target, resolveRtdbSentinels(operation.values) as Record<string, unknown>);
+      else if (operation.kind === 'remove') await rtdbRemove(target);
+      else if (
+        operation.mergeAfterChildRegistration && operation.value !== null &&
+        typeof operation.value === 'object' && !Array.isArray(operation.value)
+      ) await rtdbUpdate(target, resolveRtdbSentinels(operation.value) as Record<string, unknown>);
+      else if (operation.priority !== undefined) {
+        await rtdbSetWithPriority(
+          target,
+          resolveRtdbSentinels(operation.value) as never,
+          operation.priority,
+        );
+      } else await rtdbSet(target, resolveRtdbSentinels(operation.value) as never);
+    } catch (error) {
+      failures.push(error);
+    }
+  }
+  await bestEffortFlush(ctx);
+  if (failures.length === 1) throw failures[0];
+  if (failures.length > 1) throw new AggregateError(failures, 'Multiple SharedWorker onDisconnect operations failed');
+}
+
+export function clearAllRtdbDisconnects(ctx: HostCtx): void {
+  disconnectQueues.get(ctx)?.clear();
+  offlinePorts.get(ctx)?.clear();
+}
+
+export function forgetPortRtdbConnection(ctx: HostCtx, port: PortLike): void {
+  disconnectQueues.get(ctx)?.delete(port);
+  offlinePorts.get(ctx)?.delete(port);
+}
+
 export function isRtdbOp(method: OpMessage['method']): boolean {
   return RTDB_METHODS.has(method);
 }
@@ -69,7 +207,7 @@ export async function handleRtdbOp(
     case 'rtdb.get': {
       try {
         const db = lensRtdb(ctx, msg.actAs, port);
-        ok(port, msg.id, rtdbSnapToWire(await rtdbGet(rtdbRef(db, msg.path))));
+        ok(port, msg.id, rtdbSnapToWire(await rtdbGet(rtdbTarget(db, msg.path, msg.query))));
       } catch (e) { fail(port, msg.id, e); }
       break;
     }
@@ -85,6 +223,30 @@ export async function handleRtdbOp(
       break;
     }
 
+    case 'rtdb.setPriority': {
+      try {
+        const db = lensRtdb(ctx, msg.actAs, port);
+        await rtdbSetPriority(rtdbRef(db, msg.path), msg.priority);
+        await bestEffortFlush(ctx);
+        ok(port, msg.id, null);
+      } catch (e) { fail(port, msg.id, e); }
+      break;
+    }
+
+    case 'rtdb.setWithPriority': {
+      try {
+        const db = lensRtdb(ctx, msg.actAs, port);
+        await rtdbSetWithPriority(
+          rtdbRef(db, msg.path),
+          resolveRtdbSentinels(msg.value) as never,
+          msg.priority,
+        );
+        await bestEffortFlush(ctx);
+        ok(port, msg.id, null);
+      } catch (e) { fail(port, msg.id, e); }
+      break;
+    }
+
     case 'rtdb.update': {
       try {
         const db = lensRtdb(ctx, msg.actAs, port);
@@ -129,6 +291,85 @@ export async function handleRtdbOp(
       break;
     }
 
+    case 'rtdb.onDisconnectSet': {
+      try {
+        await queueDisconnectOperation(ctx, port, {
+          kind: 'set', path: msg.path, value: resolveRtdbSentinels(msg.value), priority: msg.priority, actAs: msg.actAs,
+        });
+        ok(port, msg.id, null);
+      } catch (e) { fail(port, msg.id, e); }
+      break;
+    }
+
+    case 'rtdb.onDisconnectUpdate': {
+      try {
+        await queueDisconnectOperation(ctx, port, {
+          kind: 'update', path: msg.path, values: resolveRtdbSentinels(msg.values) as Record<string, unknown>, actAs: msg.actAs,
+        });
+        ok(port, msg.id, null);
+      } catch (e) { fail(port, msg.id, e); }
+      break;
+    }
+
+    case 'rtdb.onDisconnectRemove': {
+      try {
+        await queueDisconnectOperation(ctx, port, { kind: 'remove', path: msg.path, actAs: msg.actAs });
+        ok(port, msg.id, null);
+      } catch (e) { fail(port, msg.id, e); }
+      break;
+    }
+
+    case 'rtdb.onDisconnectCancel': {
+      const queue = portQueue(ctx, port);
+      queue.cancel(msg.path);
+      ok(port, msg.id, null);
+      break;
+    }
+
+    case 'rtdb.goOffline': {
+      try {
+        const offline = offlinePortSet(ctx);
+        if (!offline.has(port)) {
+          offline.add(port);
+          await drainPortRtdbDisconnects(ctx, port);
+        }
+        ok(port, msg.id, null);
+      } catch (e) { fail(port, msg.id, e); }
+      break;
+    }
+
+    case 'rtdb.goOnline': {
+      offlinePortSet(ctx).delete(port);
+      ok(port, msg.id, null);
+      break;
+    }
+
+    case 'rtdb.transactionCommit': {
+      try {
+        const db = lensRtdb(ctx, msg.actAs, port);
+        const target = rtdbRef(db, msg.path);
+        let retry = false;
+        const result = await rtdbRunTransaction(
+          target,
+          (current) => {
+            if (!sameRtdbValue(current, msg.expected)) {
+              retry = true;
+              return undefined;
+            }
+            return resolveRtdbSentinels(msg.value) as never;
+          },
+          { applyLocally: msg.applyLocally },
+        );
+        await bestEffortFlush(ctx);
+        ok(port, msg.id, {
+          retry,
+          committed: result.committed,
+          snapshot: rtdbSnapToWire(result.snapshot),
+        });
+      } catch (e) { fail(port, msg.id, e); }
+      break;
+    }
+
     default: {
       fail(port, msg.id, new Error(`Unknown method: ${String((msg as { method: unknown }).method)}`));
     }

package/src/serve/worker/host/studio.ts

@@ -11,6 +11,7 @@ import { setRules } from 'pyric/sandbox/firestore';
 
 import type { OpMessage } from '../protocol.js';
 import { type HostCtx, type PortLike, ok, fail } from '../host-context.js';
+import { clearAllRtdbDisconnects } from './rtdb.js';
 
 /** The Studio control op methods routed to {@link handleStudioOp}. */
 const STUDIO_METHODS = new Set<string>([
@@ -45,6 +46,7 @@ export async function handleStudioOp(
       // payload's `errors` so Studio can surface a half-clear instead of
       // reporting a clean reset.
       try {
+        clearAllRtdbDisconnects(ctx);
         const { errors } = await ctx.sandbox.resetAll();
         // `resetAll` swapped the env, wiping env-owned FIRESTORE rules (RTDB /
         // storage rules live on their service objects and survive). Re-deploy

package/src/serve/worker/host/subscriptions.ts

@@ -18,9 +18,9 @@ import {
   type Query,
 } from 'pyric/firestore';
 import {
-  ref as rtdbRef,
   onValue as rtdbOnValue,
   type DatabaseReference,
+  type Query as RtdbQuery,
 } from 'pyric/database';
 
 import type { FirestoreSubMessage, RtdbValueSubMessage, UnsubMessage } from '../protocol.js';
@@ -34,7 +34,7 @@ import {
   resolveTarget,
   serializeDocSnap,
 } from './core.js';
-import { rtdbSnapToWire } from './rtdb.js';
+import { rtdbSnapToWire, rtdbTarget } from './rtdb.js';
 
 /**
  * Session-bound sub registry (#754): the original sub message for every
@@ -155,9 +155,13 @@ export function handleRtdbSub(ctx: HostCtx, port: PortLike, msg: RtdbValueSubMes
   }
 
   try {
-    const ref = rtdbRef(lensRtdb(ctx, msg.actAs, port), msg.target.path);
+    const ref = rtdbTarget(
+      lensRtdb(ctx, msg.actAs, port),
+      msg.target.path,
+      msg.target.query,
+    );
     const unsub = rtdbOnValue(
-      ref as DatabaseReference,
+      ref as DatabaseReference | RtdbQuery,
       (snap) => post(port, { t: 'snap', subId: msg.subId, value: rtdbSnapToWire(snap) }),
     );
     portSubs.set(msg.subId, unsub);

package/src/serve/worker/host.ts

@@ -44,4 +44,4 @@ export {
   listBranchNames,
 } from './host/connection.js';
 // The message dispatcher seam (entry.ts + tests) and per-port teardown.
-export { handleMessage, cleanupPort } from './host/dispatch.js';
+export { handleMessage, cleanupPort, cleanupPortWithDisconnect } from './host/dispatch.js';

package/src/serve/worker/index.ts

@@ -19,6 +19,32 @@
  * '@pyric/cli/serve/worker'` and reach the live SharedWorker backend.
  */
 
+export {
+  PYRIC_WORKER_NAME,
+  PYRIC_WORKER_URL,
+  readPyricRuntimeManifest,
+  type PyricRuntimeManifest,
+} from '../runtime/manifest.js';
+export {
+  PYRIC_WORKER_GENERATION_KEY,
+  preflightWorkerEpochStorage,
+  rememberWorkerEpoch,
+  workerNameForEpoch,
+} from '../runtime/worker-generation.js';
+export {
+  createWorkerReplacement,
+  type WorkerReplacement,
+} from '../runtime/worker-replacement.js';
+export {
+  onWorkerRuntimeReload,
+  retireWorkerRuntime,
+} from './client/runtime-control.js';
+export {
+  disconnectClient,
+  type DisconnectClientOptions,
+} from './client/disconnect.js';
+export { ownClientUntilPagehide } from './client/pagehide.js';
+
 export {
   // Bridge-peer relay seams (leaf-safe: ids are re-minted in-page, frames go
   // over the worker port). The served page wires these into `connectBridge`'s
@@ -163,29 +189,51 @@ export {
   getSnapshot,
   // Sandbox-owned full reset (issue #359): Firestore + every registered service
   resetAll,
-  // RTDB shared-worker preview bridge. Aliased to avoid colliding with Storage
-  // `ref` and Firestore sentinels in this worker barrel.
-  rtdbGetDatabase,
-  rtdbRef,
-  rtdbChild,
-  rtdbGet,
+} from './client.js';
+
+// RTDB bridge families are exported directly from their owning modules. This
+// public package index is the sole aggregation point for the worker surface.
+export { rtdbGetDatabase, rtdbRef, rtdbChild } from './client/rtdb-references.js';
+export { rtdbGet } from './client/rtdb-reads.js';
+export {
   rtdbSet,
+  rtdbSetPriority,
+  rtdbSetWithPriority,
   rtdbUpdate,
   rtdbRemove,
   rtdbPush,
+} from './client/rtdb-writes.js';
+export {
   rtdbOnValue,
+  rtdbOnChildAdded,
+  rtdbOnChildChanged,
+  rtdbOnChildMoved,
+  rtdbOnChildRemoved,
   rtdbOff,
+} from './client/rtdb-listeners.js';
+export { rtdbRunTransaction } from './client/rtdb-transactions.js';
+export {
+  rtdbOnDisconnect,
+  rtdbGoOffline,
+  rtdbGoOnline,
+  RtdbOnDisconnect,
+} from './client/rtdb-connection-lifecycle.js';
+export {
   rtdbServerTimestamp,
   rtdbConnectDatabaseEmulator,
+} from './client/rtdb-controls.js';
+export {
   adminReadRtdbState,
   adminSetRtdbValue,
   adminUpdateRtdbValue,
   adminDeleteRtdbValue,
   adminSubscribeRtdbValue,
-  type ClientRtdb,
-  type RtdbRefHandle,
-  type RtdbDataSnapshot,
-} from './client.js';
+} from './client/rtdb-admin.js';
+export type {
+  ClientRtdb,
+  RtdbRefHandle,
+  RtdbDataSnapshot,
+} from './client/handles.js';
 
 export type {
   AuthPersistenceMode,

package/src/serve/worker/protocol.ts

@@ -53,6 +53,7 @@ import { rehydrateDocValue } from 'pyric/firestore/internal/value-codec';
 // The auth-lens contract and the cross-service event envelope are shared with
 // the sandbox's event provenance — Studio's Action Center folds these verbatim.
 import type { AuthLens, SandboxEvent, DenialContext } from 'pyric/sandbox';
+import type { Query as RtdbQuery } from 'pyric/database';
 // TYPE-ONLY (same rationale): the broker's own wire shapes for the
 // `messaging.*` ops — all plain JSON, structured-clone-safe by construction.
 import type {
@@ -401,12 +402,29 @@ export type OpMessage = (
   | { t: 'op'; id: string; method: 'admin.setDocument'; path: string; data: unknown }
   | { t: 'op'; id: string; method: 'admin.deleteDocument'; path: string }
   | { t: 'op'; id: string; method: 'admin.readState'; path?: string; maxDepth?: number }
-  | { t: 'op'; id: string; method: 'rtdb.get'; path: string }
+  | { t: 'op'; id: string; method: 'rtdb.get'; path: string; query?: RtdbQuerySpec }
   | { t: 'op'; id: string; method: 'rtdb.set'; path: string; value: unknown }
+  | { t: 'op'; id: string; method: 'rtdb.setPriority'; path: string; priority: string | number | null }
+  | { t: 'op'; id: string; method: 'rtdb.setWithPriority'; path: string; value: unknown; priority: string | number | null }
   | { t: 'op'; id: string; method: 'rtdb.update'; path: string; values: Record<string, unknown> }
   | { t: 'op'; id: string; method: 'rtdb.remove'; path: string }
   | { t: 'op'; id: string; method: 'rtdb.push'; path: string; key: string; value?: unknown }
   | { t: 'op'; id: string; method: 'rtdb.adminSnapshot' }
+  | { t: 'op'; id: string; method: 'rtdb.onDisconnectSet'; path: string; value: unknown; priority?: string | number | null }
+  | { t: 'op'; id: string; method: 'rtdb.onDisconnectUpdate'; path: string; values: Record<string, unknown> }
+  | { t: 'op'; id: string; method: 'rtdb.onDisconnectRemove'; path: string }
+  | { t: 'op'; id: string; method: 'rtdb.onDisconnectCancel'; path: string }
+  | { t: 'op'; id: string; method: 'rtdb.goOffline' }
+  | { t: 'op'; id: string; method: 'rtdb.goOnline' }
+  | {
+      t: 'op';
+      id: string;
+      method: 'rtdb.transactionCommit';
+      path: string;
+      expected: unknown;
+      value: unknown;
+      applyLocally?: boolean;
+    }
   // Collection enumeration (Pyric Studio data browse): the modular SDK has no
   // client `listCollections`, so the host enumerates the sandbox keyspace via
   // `getInternalEnv(sandbox)`. Reply: `{ ids: string[] }`.
@@ -681,7 +699,7 @@ export interface EventSubMessage {
 export interface RtdbValueSubMessage {
   t: 'sub';
   subId: string;
-  target: { service: 'rtdb'; path: string };
+  target: { service: 'rtdb'; path: string; query?: RtdbQuerySpec };
   /** Mirrors Firestore subscriptions: absent/app-session uses this port's session. */
   actAs?: AuthLens;
   /** Mechanical op provenance — see the field's doc on {@link OpMessage}. */
@@ -690,6 +708,9 @@ export interface RtdbValueSubMessage {
   relaySource?: 'remote';
 }
 
+/** Structured-clone-safe query plan carried by `pyric/database` Query values. */
+export type RtdbQuerySpec = RtdbQuery['_spec'];
+
 /**
  * Stream a `generateContent` call as a SUBSCRIPTION (cdd-deltas #98.3:
  * "chunks over the existing subscription/event mechanism"). Unlike the

package/src/serve/worker/rtdb-value-equality.ts

@@ -0,0 +1,17 @@
+/** Browser-safe structural equality for values crossing the RTDB worker wire. */
+export function sameRtdbValue(left: unknown, right: unknown): boolean {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right)
+      && left.length === right.length
+      && left.every((value, index) => sameRtdbValue(value, right[index]));
+  }
+  if (!left || !right || typeof left !== 'object' || typeof right !== 'object') return false;
+  const leftRecord = left as Record<string, unknown>;
+  const rightRecord = right as Record<string, unknown>;
+  const leftKeys = Object.keys(leftRecord).sort();
+  const rightKeys = Object.keys(rightRecord).sort();
+  return leftKeys.length === rightKeys.length && leftKeys.every(
+    (key, index) => key === rightKeys[index] && sameRtdbValue(leftRecord[key], rightRecord[key]),
+  );
+}

package/src/serve/worker/serve-init.ts

@@ -33,7 +33,7 @@ import { getDatabase, sandbox as rtdbSandbox } from 'pyric/database';
 import { getAuth, sandbox as authOps, type SeedUser } from 'pyric/auth';
 import { getStorageSandbox } from 'pyric/storage';
 import type { PersistenceBackend } from 'pyric/sandbox';
-import { initializeSandbox } from 'pyric/sandbox';
+import { createSandboxRoot } from 'pyric/sandbox/internal';
 import {
   primeEventHistory,
 } from 'pyric/sandbox/internal';
@@ -485,7 +485,7 @@ export async function buildWorkerCtx(bootEnv: WorkerBootEnv): Promise<HostCtx> {
     // plain-call wrapper doesn't need (nothing in this module uses it).
     fetch: ((...args: Parameters<typeof fetch>) => ambientFetch(...args)) as typeof fetch,
   };
-  const sandbox = initializeSandbox();
+  const sandbox = createSandboxRoot();
 
   // Deploy permissive starter rules via admin-firestore.
   // Callers override at runtime via the setRules op.

package/src/serve/worker/service-worker-relay.ts

@@ -1,6 +1,6 @@
 /** Session-aware Service Worker relay over the authoritative SharedWorker host. */
 import {
-  cleanupPort,
+  cleanupPortWithDisconnect,
   handleMessage,
   type HostCtx,
   type PortLike,
@@ -53,7 +53,7 @@ export function createServiceWorkerRelay(options: {
             if (!previous) return;
             try {
               const ctx = await options.getCtx();
-              cleanupPort(ctx, previous.port);
+              await cleanupPortWithDisconnect(ctx, previous.port);
             } catch (error) {
               options.onError?.(error, envelope);
             }

package/dist/serve/docs-ui/_astro/_slug_.DUci-duz.css

@@ -1 +0,0 @@
-.prose .conformance-flow{display:flex;flex-wrap:wrap;align-items:stretch;gap:var(--space-2)}.prose .flow-step{flex:1 1 0;min-width:92px;display:flex;flex-direction:column;justify-content:center;gap:var(--space-1);padding:var(--space-3);text-align:center;background:var(--panel);border:1px solid var(--line);border-radius:8px;font-size:.9rem;font-weight:550;line-height:1.3;color:var(--ink)}.prose .flow-sub{font-size:var(--fs-caption);font-weight:400;color:var(--muted)}.prose .flow-arrow{display:flex;align-items:center;color:var(--faint);font-size:1.1rem}.prose .compat-stat{display:flex;flex-direction:column;gap:var(--space-3);padding-top:var(--space-4);border-top:1px solid var(--line)}.prose .compat-stat-surface{font-size:.85rem;color:var(--muted);font-variant-numeric:tabular-nums}.prose .compat-stat-surface strong,.prose .compat-stat-item strong{color:var(--ink)}.prose .compat-stat-figure{display:flex;align-items:baseline;flex-wrap:wrap;gap:var(--space-3);line-height:1}.prose .compat-stat-pct{font-size:2.75rem;font-weight:750;line-height:1;letter-spacing:-.02em;color:var(--ink);font-variant-numeric:tabular-nums}.prose .compat-stat-label{font-size:1rem;color:var(--muted)}.prose .compat-stat-denom{font-size:.85rem;color:var(--faint);font-variant-numeric:tabular-nums}.prose .compat-stat-bar{display:flex;gap:2px;width:100%;height:10px;border-radius:5px;overflow:hidden}.prose .compat-stat-seg{flex-basis:0;min-width:0;background:var(--muted)}.prose .compat-stat-seg[data-status=ok]{background:var(--diff-add)}.prose .compat-stat-seg[data-status=unsupported]{background:var(--line-2)}.prose .compat-stat-seg[data-status=unverified]{background:transparent;box-shadow:inset 0 0 0 1px var(--faint)}.prose .compat-stat-seg[data-status=diverged]{background:repeating-linear-gradient(135deg,var(--accent) 0 4px,color-mix(in srgb,var(--accent) 45%,transparent) 4px 7px)}.prose .compat-stat-seg[data-status=bug]{background:repeating-linear-gradient(45deg,var(--diff-remove) 0 3px,color-mix(in srgb,var(--diff-remove) 40%,transparent) 3px 6px)}.prose .compat-stat-key{padding:0;display:flex;flex-wrap:wrap;gap:var(--space-2) var(--space-4);list-style:none}.prose .compat-stat-item{display:inline-flex;align-items:center;gap:var(--space-2);font-size:var(--fs-caption);color:var(--muted);font-variant-numeric:tabular-nums}.prose .compat-stat-note{font-size:var(--fs-caption);color:var(--muted)}.prose .compat-meters{display:flex;flex-direction:column;gap:var(--space-2)}.prose .compat-meter{display:grid;grid-template-columns:minmax(9rem,auto) 1fr auto;align-items:center;gap:var(--space-3);font-size:var(--fs-caption);color:var(--muted);font-variant-numeric:tabular-nums}.prose .compat-meter-label{color:var(--muted)}.prose .compat-meter-value{color:var(--ink);font-weight:600;text-align:right}.prose .compat-meter-track{display:block;width:100%;height:8px;border-radius:4px;background:var(--line-2);overflow:hidden}.prose .compat-meter-fill{display:block;height:100%;border-radius:4px;background:var(--diff-add)}.prose .compat-meter-track--mini{height:5px;margin-top:var(--space-1)}.prose .compat-score-table{width:100%;border-collapse:collapse;font-size:.875rem}.prose .compat-score-table thead th{text-align:left;font-size:.6875rem;font-weight:600;text-transform:uppercase;letter-spacing:.06em;color:var(--ink-3, #667);padding:var(--space-2) var(--space-3);border-bottom:1px solid var(--line)}.prose .compat-score-table td,.prose .compat-score-table th[scope=row]{padding:var(--space-2) var(--space-3);border-bottom:1px solid var(--line);vertical-align:middle;text-align:left}.prose .compat-score-table th[scope=row]{font-weight:600;white-space:nowrap}.prose .compat-score-cell{white-space:nowrap}.prose .compat-score-cell .compat-score-pct{font-variant-numeric:tabular-nums;font-weight:600;margin-right:var(--space-2)}.prose .compat-score-cell .compat-meter-track--mini{display:inline-block;width:8rem;vertical-align:middle}.prose .compat-score-detail{color:var(--ink-3, #667);font-size:.8125rem;white-space:nowrap}.prose .compat-score-row--overall th[scope=row],.prose .compat-score-row--overall td{border-top:2px solid var(--line);border-bottom:0}} .prose .compat-score-tbd{color:var(--ink-3, #667);font-size:.8125rem;font-style:italic}.prose .compat-score-stack{display:grid;gap:var(--space-1)}.prose .compat-score-bar{display:flex;align-items:center;gap:var(--space-2)}.prose .compat-score-bar .compat-meter-track{flex:1 1 auto}.prose .compat-score-basis{font-size:.8125rem;color:var(--ink-3, #667)}:root{--rhythm-para: .875rem;--rhythm-group: 1.5rem;--rhythm-subsection: 2.25rem;--rhythm-section: 3.25rem;--rhythm-list: calc(var(--rhythm-para) * .75)}.prose>*,.prose blockquote>*,.prose li>*,.prose .compat-stat>*{margin-block:0}.prose>*+*{margin-block-start:var(--rhythm-group)}.prose>*+h2{margin-block-start:var(--rhythm-section)}.prose>*+h3,.prose>*+h4{margin-block-start:var(--rhythm-subsection)}.prose>h1+*,.prose>h2+*,.prose>h3+*,.prose>h4+*{margin-block-start:var(--rhythm-para)}.prose>p+p{margin-block-start:var(--rhythm-para)}.prose>p+ul,.prose>p+ol,.prose>p+blockquote{margin-block-start:var(--rhythm-para)}.prose li+li{margin-block-start:var(--rhythm-list)}.prose li>ul,.prose li>ol{margin-block-start:var(--rhythm-list)}.prose li>*+*,.prose blockquote>*+*{margin-block-start:var(--rhythm-para)}.api-reference-header{margin:0 0 2.5rem;padding:0 0 2rem;border-bottom:1px solid var(--line)}.api-reference-kicker{margin:0 0 .65rem;color:var(--muted);font-size:var(--fs-micro);font-weight:600;letter-spacing:var(--tracking-micro);text-transform:uppercase}.api-reference-header h1{margin:0;color:var(--ink);font-size:clamp(1.7rem,4vw,2.45rem);font-weight:600;letter-spacing:-.035em}.api-reference-header h1 code{padding:0;color:inherit;background:transparent;font:inherit}.api-reference-meta,.api-reference-source{margin:.7rem 0 0;color:var(--muted);font-size:var(--fs-body)}.api-reference-source{margin-top:.3rem}.api-reference-evidence{display:inline-block;margin-top:1rem;color:var(--ink);font-size:var(--fs-label);font-weight:600;text-underline-offset:.18em}.api-reference-body>h2{margin-top:3.75rem;padding-bottom:.65rem;border-bottom:1px solid var(--line)}.api-reference-body>h3{margin-top:2.75rem}.api-reference-body>h3 code{font-size:inherit}.api-reference-body h4{margin-top:1.8rem}.api-reference-body h5,.api-reference-body h6{margin-top:1.35rem}.api-reference-body pre{overflow-x:auto}.api-reference-body table{display:block;max-width:100%;overflow-x:auto;white-space:nowrap}.api-symbols{max-height:calc(100vh - 5rem);overflow:auto;scrollbar-width:thin}.api-symbol-filter{width:100%;margin:.2rem 0 1rem;padding:.5rem .6rem;border:1px solid var(--line);border-radius:.35rem;color:var(--ink);background:var(--panel);font:inherit;font-size:var(--fs-caption)}.api-symbol-filter:focus{border-color:var(--muted);outline:none}.api-symbol-group+.api-symbol-group{margin-top:1rem}.api-symbol-kind{display:block;margin-bottom:.35rem;color:var(--muted);font-size:var(--fs-micro);font-weight:600;letter-spacing:var(--tracking-micro);text-transform:uppercase}.api-symbol-group ul{margin:0;padding:0;list-style:none}.api-symbol-group li+li{margin-top:.22rem}.api-symbol-group li a{display:block;overflow:hidden;color:var(--muted);font-family:var(--font-mono);font-size:var(--fs-caption);text-overflow:ellipsis;white-space:nowrap}.api-symbol-group li a:hover,.api-symbol-kind:hover{color:var(--ink)}.api-symbol-empty{color:var(--muted);font-size:var(--fs-caption)}