@pyric/cli 0.1.0-alpha.9

package/dist/serve/entries/session-store.js

@@ -0,0 +1,82 @@
+/**
+ * Auth session persistence for `pyric dev` — the one genuine
+ * client-fidelity item in the persistence model (flow doc section 3c): real
+ * Firebase keeps you signed in across reloads by DEFAULT
+ * (`browserLocalPersistence`), so the served sandbox does too.
+ *
+ * The user *database* persists with the substrate (`--persist`); the
+ * *session* persists like the real client — independent of data mode, in
+ * web storage, honoring `setPersistence` semantics:
+ *
+ *   LOCAL  (default) → localStorage     (survives reload + browser restart)
+ *   SESSION          → sessionStorage   (survives reload, not the tab)
+ *   NONE             → nothing stored
+ *
+ * A restored session only resolves when the referenced uid still exists in
+ * the sandbox user DB — so ephemeral mode drops helper-created sessions on
+ * reload, consistently (`sandbox.restoreSession` throws, we clear).
+ *
+ * Pure over injected Storage objects so the logic is bun-testable; the
+ * browser wiring (real storages, `onAuthStateChanged` recording, restore at
+ * init) lives in the entries that import this.
+ */
+const DEFAULT_KEY = 'pyric:serve:auth-session';
+export class SessionStore {
+    stores;
+    mode = 'LOCAL'; // firebase's default persistence
+    key;
+    constructor(stores, appName = '[DEFAULT]') {
+        this.stores = stores;
+        this.key = appName === '[DEFAULT]'
+            ? DEFAULT_KEY
+            : `${DEFAULT_KEY}:${encodeURIComponent(appName)}`;
+    }
+    /** `setPersistence` parity: switch the backing store and MIGRATE any
+     *  current session into it (the real SDK carries the session over). */
+    setMode(mode) {
+        const current = this.load();
+        this.clear();
+        this.mode = mode;
+        if (current)
+            this.save(current.uid);
+    }
+    save(uid) {
+        this.clear(); // a session lives in exactly one store
+        if (this.mode === 'NONE')
+            return;
+        this.backing().setItem(this.key, JSON.stringify({ uid }));
+    }
+    /** Reads BOTH storages (localStorage first — matches lookup order when a
+     *  prior page used a different mode). Restoring also restores the mode:
+     *  the initial Auth observer resaves the user, and must not migrate a
+     *  SESSION record into the default LOCAL slot. */
+    load() {
+        for (const [mode, store] of [
+            ['LOCAL', this.stores.local],
+            ['SESSION', this.stores.session],
+        ]) {
+            const raw = store.getItem(this.key);
+            if (!raw)
+                continue;
+            try {
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed.uid === 'string') {
+                    this.mode = mode;
+                    return parsed;
+                }
+            }
+            catch {
+                store.removeItem(this.key); // corrupt → drop, never throw at page init
+            }
+        }
+        return null;
+    }
+    clear() {
+        this.stores.local.removeItem(this.key);
+        this.stores.session.removeItem(this.key);
+    }
+    backing() {
+        return this.mode === 'SESSION' ? this.stores.session : this.stores.local;
+    }
+}
+//# sourceMappingURL=session-store.js.map

package/dist/serve/entries/session-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.js","sourceRoot":"","sources":["../../../src/serve/entries/session-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,MAAM,WAAW,GAAG,0BAA0B,CAAC;AAW/C,MAAM,OAAO,YAAY;IAKJ;IAJX,IAAI,GAAgB,OAAO,CAAC,CAAC,iCAAiC;IACrD,GAAG,CAAS;IAE7B,YACmB,MAAqB,EACtC,OAAO,GAAG,WAAW;QADJ,WAAM,GAAN,MAAM,CAAe;QAGtC,IAAI,CAAC,GAAG,GAAG,OAAO,KAAK,WAAW;YAChC,CAAC,CAAC,WAAW;YACb,CAAC,CAAC,GAAG,WAAW,IAAI,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC;IACtD,CAAC;IAED;2EACuE;IACvE,OAAO,CAAC,IAAiB;QACvB,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC5B,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,OAAO;YAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACtC,CAAC;IAED,IAAI,CAAC,GAAW;QACd,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,uCAAuC;QACrD,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO;QACjC,IAAI,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,EAA0B,CAAC,CAAC,CAAC;IACpF,CAAC;IAED;;;sDAGkD;IAClD,IAAI;QACF,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI;YAC1B,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;YAC5B,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;SACxB,EAAE,CAAC;YACX,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACpC,IAAI,CAAC,GAAG;gBAAE,SAAS;YACnB,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAkB,CAAC;gBAChD,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;oBAC7C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;oBACjB,OAAO,MAAM,CAAC;gBAChB,CAAC;YACH,CAAC;YAAC,MAAM,CAAC;gBACP,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,2CAA2C;YACzE,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3C,CAAC;IAEO,OAAO;QACb,OAAO,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;IAC3E,CAAC;CACF"}

package/dist/serve/entries/storage.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The bundle the import map serves for `firebase/storage`.
+ *
+ * Served apps keep their normal Firebase Storage imports. In worker mode, browse
+ * and metadata reads use the shared worker-hosted object store; operations that
+ * still lack a worker protocol fail loudly. In in-page fallback mode, the entry
+ * delegates to `pyric/storage` against the page sandbox.
+ */
+import * as ip from 'pyric/storage';
+import { type FirebaseStorage } from 'pyric/storage';
+import { type FirebaseApp } from 'pyric/app';
+export declare function getStorage(app?: FirebaseApp, _bucketUrl?: string): FirebaseStorage;
+export declare const ref: typeof ip.ref;
+export declare const listAll: typeof ip.listAll;
+export declare const getMetadata: typeof ip.getMetadata;
+export declare const getBlob: typeof ip.getBlob;
+export declare const getDownloadURL: typeof ip.getDownloadURL;
+export declare const StorageError: typeof ip.StorageError;
+export declare function connectStorageEmulator(storage: unknown, _host: string, _port: number, _options?: unknown): void;
+export declare const uploadBytes: typeof ip.uploadBytes;
+export declare const getBytes: typeof ip.getBytes;
+export declare const deleteObject: typeof ip.deleteObject;
+export declare const uploadString: typeof ip.uploadString;
+export declare const updateMetadata: typeof ip.updateMetadata;
+//# sourceMappingURL=storage.d.ts.map

package/dist/serve/entries/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/serve/entries/storage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAavB,OAAO,EAAU,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAKrD,wBAAgB,UAAU,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,eAAe,CASlF;AAED,eAAO,MAAM,GAAG,EAAuC,OAAO,EAAE,CAAC,GAAG,CAAC;AACrE,eAAO,MAAM,OAAO,EAA+C,OAAO,EAAE,CAAC,OAAO,CAAC;AACrF,eAAO,MAAM,WAAW,EAEnB,OAAO,EAAE,CAAC,WAAW,CAAC;AAC3B,eAAO,MAAM,OAAO,EAA+C,OAAO,EAAE,CAAC,OAAO,CAAC;AACrF,eAAO,MAAM,cAAc,EAEtB,OAAO,EAAE,CAAC,cAAc,CAAC;AAE9B,eAAO,MAAM,YAAY,wBAAkB,CAAC;AAO5C,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,OAAO,GACjB,IAAI,CAKN;AAkBD,eAAO,MAAM,WAAW,EAAuD,OAAO,EAAE,CAAC,WAAW,CAAC;AACrG,eAAO,MAAM,QAAQ,EAAiD,OAAO,EAAE,CAAC,QAAQ,CAAC;AACzF,eAAO,MAAM,YAAY,EAAyD,OAAO,EAAE,CAAC,YAAY,CAAC;AAEzG,eAAO,MAAM,YAAY,wBAAkD,CAAC;AAC5E,eAAO,MAAM,cAAc,0BAAsD,CAAC"}

package/dist/serve/entries/storage.js

@@ -0,0 +1,61 @@
+/**
+ * The bundle the import map serves for `firebase/storage`.
+ *
+ * Served apps keep their normal Firebase Storage imports. In worker mode, browse
+ * and metadata reads use the shared worker-hosted object store; operations that
+ * still lack a worker protocol fail loudly. In in-page fallback mode, the entry
+ * delegates to `pyric/storage` against the page sandbox.
+ */
+import * as ip from 'pyric/storage';
+import { getStorage as pyricGetStorage, } from 'pyric/storage';
+import { getStorage as workerGetStorage, getBlob as workerGetBlob, getBytes as workerGetBytes, getDownloadURL as workerGetDownloadURL, getMetadata as workerGetMetadata, listAll as workerListAll, ref as workerRef, uploadBytes as workerUploadBytes, deleteObject as workerDeleteObject, } from '../worker/client.js';
+import { useWorker } from './worker-runtime.js';
+import { getApp } from 'pyric/app';
+import { workerClientForApp } from './app-client.js';
+const workerStorageByApp = new WeakMap();
+export function getStorage(app, _bucketUrl) {
+    const resolved = app ?? getApp();
+    if (!useWorker)
+        return pyricGetStorage(resolved, _bucketUrl);
+    const existing = workerStorageByApp.get(resolved);
+    if (existing)
+        return existing;
+    const client = workerClientForApp(resolved);
+    const handle = Object.assign(workerGetStorage(client), { app: resolved });
+    workerStorageByApp.set(resolved, handle);
+    return handle;
+}
+export const ref = (useWorker ? workerRef : ip.ref);
+export const listAll = (useWorker ? workerListAll : ip.listAll);
+export const getMetadata = (useWorker ? workerGetMetadata : ip.getMetadata);
+export const getBlob = (useWorker ? workerGetBlob : ip.getBlob);
+export const getDownloadURL = (useWorker ? workerGetDownloadURL : ip.getDownloadURL);
+export const StorageError = ip.StorageError;
+// pyric replaces the Firebase emulator; connectStorageEmulator is a
+// no-op. Served apps are already talking to the pyric sandbox (or the
+// SharedWorker's shared store), which IS the local emulator — pointing
+// it at a `firebase-tools` emulator host would be a step backward, not
+// forward, so the call is logged and swallowed rather than forwarded.
+export function connectStorageEmulator(storage, _host, _port, _options) {
+    console.info('[pyric dev] pyric replaces the Firebase emulator; connectStorageEmulator is a no-op.');
+    if (!useWorker)
+        ip.connectStorageEmulator(storage, _host, _port, _options);
+}
+function unsupportedWorkerApi(name) {
+    throw new Error(`firebase/storage ${name}() is not supported over the pyric SharedWorker yet. ` +
+        'Use the in-page fallback for this operation.');
+}
+function workerOrInPage(name, fn) {
+    return (useWorker ? (() => unsupportedWorkerApi(name)) : fn);
+}
+// Byte ops use the worker protocol (base64 `storage.putBytes` /
+// `storage.getBytes` / `storage.deleteObject`) and the initiating app port's
+// authenticated session. All app ports reach the same object store and
+// ruleset; only their active Auth sessions differ. Payloads are capped at
+// 8 MiB per op.
+export const uploadBytes = (useWorker ? workerUploadBytes : ip.uploadBytes);
+export const getBytes = (useWorker ? workerGetBytes : ip.getBytes);
+export const deleteObject = (useWorker ? workerDeleteObject : ip.deleteObject);
+export const uploadString = workerOrInPage('uploadString', ip.uploadString);
+export const updateMetadata = workerOrInPage('updateMetadata', ip.updateMetadata);
+//# sourceMappingURL=storage.js.map

package/dist/serve/entries/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../../src/serve/entries/storage.ts"],"names":[],"mappings":"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"}

package/dist/serve/entries/tab-sync-wiring.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Cross-tab realtime sync wiring for `pyric dev`.
+ *
+ * Two independent channels carry two independent kinds of state:
+ *
+ *   1. Firestore data   — delegated entirely to `sandbox.enableTabSync()`.
+ *      That call attaches a BroadcastChannel-based write-propagation and
+ *      late-join handshake (hello/state) internally; we just supply the
+ *      channel so the name is under our control.
+ *
+ *   2. Auth state       — `enableTabSync` only carries Firestore write events;
+ *      auth sign-in / sign-out lives entirely outside the Firestore environment.
+ *      We bridge it on a SECOND channel using a simple full-state protocol:
+ *      any auth change broadcasts the complete user DB + current UID; a new tab
+ *      announces itself with `hello` and receives the current state in reply.
+ *
+ * Why full-state instead of deltas?
+ *   Auth payloads are tiny (a handful of users). Broadcasting the entire user DB
+ *   + current UID on every change avoids ordering bugs where a `seedUsers` arrives
+ *   before a `restoreSession` (or vice versa) and leaves the receiving tab in an
+ *   inconsistent partial state. One atomic message = one safe apply.
+ *
+ * Echo-loop prevention (load-bearing):
+ *   Applying a received auth state calls `seedUsers` + `restoreSession`, which
+ *   fire `subscribeUsers` / `onAuthStateChanged` callbacks — the same callbacks
+ *   that trigger outbound broadcasts. Without a guard this creates an infinite
+ *   cross-tab loop. The `applyingRemoteAuth` boolean breaks it: set to `true`
+ *   immediately before the apply and `false` in the `finally` block; both
+ *   broadcast callbacks check the flag and no-op while it is set.
+ *   JavaScript is single-threaded, and `seedUsers` + `restoreSession` are
+ *   synchronous (they resolve before any pending microtask can enter), so the
+ *   boolean is collision-free.
+ *
+ * Late-join (hello/state):
+ *   A tab that opens AFTER others have already signed in broadcasts `hello` on
+ *   init. Any peer that receives it replies with `state` (full user DB +
+ *   currentUid). The joining tab receives that `state` and calls
+ *   `seedUsers` + `restoreSession` to catch up — same as if those ops had
+ *   happened locally. The existing tabs' `onAuthStateChanged` listeners in the
+ *   joining tab fire as a result, exactly as they would in production.
+ *
+ * Origin tagging:
+ *   Every message carries an `origin` equal to the sending tab's random ID.
+ *   Receiving tabs drop messages whose `origin` equals their own ID — both to
+ *   comply with the echo guard and to be correct on injected test channels that
+ *   may deliver messages back to the sender (the real BroadcastChannel spec does
+ *   NOT deliver to the sender, but test stubs may differ).
+ */
+import type { Auth, SeedUser } from 'pyric/auth';
+/**
+ * The subset of `pyric/auth`'s `sandbox` namespace that we need.
+ * Injected so tests can stub without a real sandbox.
+ */
+export interface AuthOps {
+    exportUsers(auth: Auth): SeedUser[];
+    seedUsers(auth: Auth, users: ReadonlyArray<SeedUser>): void;
+    restoreSession(auth: Auth, uid: string): void;
+    subscribeUsers(auth: Auth, callback: () => void): () => void;
+}
+/**
+ * Wire cross-tab auth synchronization.
+ *
+ * Call once, after the sandbox and auth are initialised, near the END of
+ * `runtime.ts` init. The function is a no-op when `BroadcastChannel` is
+ * not available (SSR / old Node environments stay inert).
+ *
+ * @param auth        The `Auth` handle for this page (from `getAuth(sandbox)`).
+ * @param authOps     The `sandbox` namespace from `pyric/auth`.
+ * @param onAuthStateChanged  `onAuthStateChanged` from `pyric/auth`.
+ * @param signOut     `signOut` from `pyric/auth`.
+ * @param channel     Optional injected channel (omit in production — a real
+ *                    `BroadcastChannel('pyric:serve:auth-sync')` is created).
+ * @param originId    Optional injected origin ID (omit in production).
+ *
+ * @returns A disable function that removes all listeners and closes the channel.
+ *          Safe to ignore in `pyric dev` — the tab is the lifetime.
+ */
+export declare function wireAuthTabSync(auth: Auth, authOps: AuthOps, onAuthStateChanged: (auth: Auth, cb: (user: unknown) => void) => () => void, signOut: (auth: Auth) => Promise<void>, channel?: {
+    postMessage(msg: unknown): void;
+    addEventListener(type: 'message', l: (ev: {
+        data: unknown;
+    }) => void): void;
+    removeEventListener(type: 'message', l: (ev: {
+        data: unknown;
+    }) => void): void;
+    close(): void;
+}, originId?: string): () => void;
+//# sourceMappingURL=tab-sync-wiring.d.ts.map

package/dist/serve/entries/tab-sync-wiring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-sync-wiring.d.ts","sourceRoot":"","sources":["../../../src/serve/entries/tab-sync-wiring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAoCjD;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,QAAQ,EAAE,CAAC;IACpC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;IAC5D,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC9D;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,EAChB,kBAAkB,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,KAAK,MAAM,IAAI,EAC3E,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,EACtC,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IAAC,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAAC,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAAC,KAAK,IAAI,IAAI,CAAA;CAAE,EACzN,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,IAAI,CAsJZ"}

package/dist/serve/entries/tab-sync-wiring.js

@@ -0,0 +1,217 @@
+/**
+ * Cross-tab realtime sync wiring for `pyric dev`.
+ *
+ * Two independent channels carry two independent kinds of state:
+ *
+ *   1. Firestore data   — delegated entirely to `sandbox.enableTabSync()`.
+ *      That call attaches a BroadcastChannel-based write-propagation and
+ *      late-join handshake (hello/state) internally; we just supply the
+ *      channel so the name is under our control.
+ *
+ *   2. Auth state       — `enableTabSync` only carries Firestore write events;
+ *      auth sign-in / sign-out lives entirely outside the Firestore environment.
+ *      We bridge it on a SECOND channel using a simple full-state protocol:
+ *      any auth change broadcasts the complete user DB + current UID; a new tab
+ *      announces itself with `hello` and receives the current state in reply.
+ *
+ * Why full-state instead of deltas?
+ *   Auth payloads are tiny (a handful of users). Broadcasting the entire user DB
+ *   + current UID on every change avoids ordering bugs where a `seedUsers` arrives
+ *   before a `restoreSession` (or vice versa) and leaves the receiving tab in an
+ *   inconsistent partial state. One atomic message = one safe apply.
+ *
+ * Echo-loop prevention (load-bearing):
+ *   Applying a received auth state calls `seedUsers` + `restoreSession`, which
+ *   fire `subscribeUsers` / `onAuthStateChanged` callbacks — the same callbacks
+ *   that trigger outbound broadcasts. Without a guard this creates an infinite
+ *   cross-tab loop. The `applyingRemoteAuth` boolean breaks it: set to `true`
+ *   immediately before the apply and `false` in the `finally` block; both
+ *   broadcast callbacks check the flag and no-op while it is set.
+ *   JavaScript is single-threaded, and `seedUsers` + `restoreSession` are
+ *   synchronous (they resolve before any pending microtask can enter), so the
+ *   boolean is collision-free.
+ *
+ * Late-join (hello/state):
+ *   A tab that opens AFTER others have already signed in broadcasts `hello` on
+ *   init. Any peer that receives it replies with `state` (full user DB +
+ *   currentUid). The joining tab receives that `state` and calls
+ *   `seedUsers` + `restoreSession` to catch up — same as if those ops had
+ *   happened locally. The existing tabs' `onAuthStateChanged` listeners in the
+ *   joining tab fire as a result, exactly as they would in production.
+ *
+ * Origin tagging:
+ *   Every message carries an `origin` equal to the sending tab's random ID.
+ *   Receiving tabs drop messages whose `origin` equals their own ID — both to
+ *   comply with the echo guard and to be correct on injected test channels that
+ *   may deliver messages back to the sender (the real BroadcastChannel spec does
+ *   NOT deliver to the sender, but test stubs may differ).
+ */
+/** Loose type guard — checks the discriminant fields only. */
+function isAuthSyncMessage(v) {
+    return (typeof v === 'object' &&
+        v !== null &&
+        typeof v.kind === 'string' &&
+        typeof v.origin === 'string');
+}
+// ─── Public entry point ───────────────────────────────────────────────────────
+/**
+ * Wire cross-tab auth synchronization.
+ *
+ * Call once, after the sandbox and auth are initialised, near the END of
+ * `runtime.ts` init. The function is a no-op when `BroadcastChannel` is
+ * not available (SSR / old Node environments stay inert).
+ *
+ * @param auth        The `Auth` handle for this page (from `getAuth(sandbox)`).
+ * @param authOps     The `sandbox` namespace from `pyric/auth`.
+ * @param onAuthStateChanged  `onAuthStateChanged` from `pyric/auth`.
+ * @param signOut     `signOut` from `pyric/auth`.
+ * @param channel     Optional injected channel (omit in production — a real
+ *                    `BroadcastChannel('pyric:serve:auth-sync')` is created).
+ * @param originId    Optional injected origin ID (omit in production).
+ *
+ * @returns A disable function that removes all listeners and closes the channel.
+ *          Safe to ignore in `pyric dev` — the tab is the lifetime.
+ */
+export function wireAuthTabSync(auth, authOps, onAuthStateChanged, signOut, channel, originId) {
+    // Guard: BroadcastChannel is browser-only. Non-browser imports (SSR, bundler
+    // tree-shaking analysis) must stay inert.
+    if (!channel && typeof BroadcastChannel === 'undefined') {
+        return () => { };
+    }
+    const bc = channel ?? new BroadcastChannel('pyric:serve:auth-sync');
+    const ownedByUs = !channel;
+    const origin = originId ??
+        (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+            ? crypto.randomUUID()
+            : `auth-tab-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    // ── Echo / loop guard ────────────────────────────────────────────────────
+    //
+    // WHY: applying a received `state` calls `seedUsers` (fires `subscribeUsers`
+    // callbacks) and `restoreSession` (fires `onAuthStateChanged` callbacks).
+    // Both of those callbacks are hooked to broadcast the current state outward.
+    // Without this guard, the sequence would loop: Tab A signs in → broadcasts →
+    // Tab B receives → applies → subscribeUsers/onAuthStateChanged fire in Tab B
+    // → Tab B broadcasts → Tab A receives → applies → loops.
+    //
+    // Setting this flag to `true` around the synchronous apply block prevents
+    // the outbound broadcast callbacks from posting. Both `seedUsers` and
+    // `restoreSession` are synchronous; JS is single-threaded — the flag is
+    // reset to `false` before any micro/macrotask can re-enter.
+    let applyingRemoteAuth = false;
+    // ── Debounced outbound broadcast ─────────────────────────────────────────
+    //
+    // We debounce (~100ms) to coalesce a `seedUsers` + `restoreSession` pair
+    // (which fires both subscribeUsers AND onAuthStateChanged in quick succession)
+    // into a single outbound message. Without debounce the two callbacks could
+    // send two rapid-fire broadcasts to peers, causing redundant double-applies.
+    let broadcastTimer = null;
+    function scheduleBroadcast() {
+        // Skip if we're currently applying a remote state — that would echo.
+        if (applyingRemoteAuth)
+            return;
+        if (broadcastTimer !== null)
+            clearTimeout(broadcastTimer);
+        broadcastTimer = setTimeout(() => {
+            broadcastTimer = null;
+            if (applyingRemoteAuth)
+                return; // double-check after the debounce delay
+            broadcastCurrentState();
+        }, 100);
+    }
+    function broadcastCurrentState() {
+        const msg = {
+            kind: 'state',
+            origin,
+            users: authOps.exportUsers(auth),
+            currentUid: auth.currentUser?.uid ?? null,
+        };
+        bc.postMessage(msg);
+    }
+    // ── Subscribe to local auth changes ──────────────────────────────────────
+    //
+    // Two hooks cover the two dimensions of auth state:
+    //   - `subscribeUsers` fires when the user DB changes (new user created,
+    //     user properties changed, user deleted). This carries the FULL user DB.
+    //   - `onAuthStateChanged` fires when the signed-in session changes (sign in,
+    //     sign out, session swap). This carries `currentUid`.
+    //
+    // Broadcasting on BOTH ensures sign-in (changes currentUid without touching
+    // users DB), sign-up (creates a user AND changes currentUid), and user-DB
+    // edits all propagate. They share the debounce so a sign-up that fires
+    // subscribeUsers first and onAuthStateChanged second sends one message, not two.
+    const unsubUsers = authOps.subscribeUsers(auth, scheduleBroadcast);
+    const unsubAuthState = onAuthStateChanged(auth, scheduleBroadcast);
+    // ── Receive remote auth state ─────────────────────────────────────────────
+    const handleMessage = async (ev) => {
+        if (!isAuthSyncMessage(ev.data))
+            return;
+        const msg = ev.data;
+        // Echo suppression: ignore messages from ourselves.
+        if (msg.origin === origin)
+            return;
+        if (msg.kind === 'hello') {
+            // A new tab joined and wants the current state. Reply immediately (no
+            // debounce — this is a direct reply to a single event, not a user write).
+            broadcastCurrentState();
+            return;
+        }
+        if (msg.kind === 'state') {
+            // Apply received full auth state under the echo guard.
+            //
+            // Order is critical:
+            //   1. seedUsers FIRST — ensures the uid in `currentUid` exists in the DB.
+            //      restoreSession throws 'user-not-found' if the uid is absent, which
+            //      would leave the tab signed out even though the peer is signed in.
+            //   2. restoreSession SECOND — re-establishes the signed-in session.
+            //      If `currentUid` is null, sign out instead (sign-out in Tab A must
+            //      flow through to Tab B).
+            applyingRemoteAuth = true;
+            try {
+                authOps.seedUsers(auth, msg.users);
+                if (msg.currentUid) {
+                    try {
+                        authOps.restoreSession(auth, msg.currentUid);
+                    }
+                    catch {
+                        // uid was in the exported list but restoreSession still failed
+                        // (e.g. user disabled between export and apply). Sign out to stay
+                        // consistent with the peer's next broadcast rather than silently
+                        // leaving the tab in a stale signed-in state.
+                        await signOut(auth).catch(() => { });
+                    }
+                }
+                else {
+                    // Peer signed out — mirror that here.
+                    await signOut(auth).catch(() => { });
+                }
+            }
+            finally {
+                applyingRemoteAuth = false;
+            }
+        }
+    };
+    bc.addEventListener('message', handleMessage);
+    // ── Late-join hello ───────────────────────────────────────────────────────
+    //
+    // Post a `hello` AFTER wiring the message listener so we don't miss a `state`
+    // reply that arrives while still setting up (relevant on injected synchronous
+    // test channels). Peers reply with their current auth state; we apply it in
+    // `handleMessage` above. This lets a freshly-opened tab immediately inherit
+    // the signed-in user from an already-open tab without waiting for the next
+    // user-driven auth change.
+    const helloMsg = { kind: 'hello', origin };
+    bc.postMessage(helloMsg);
+    // ── Disable ───────────────────────────────────────────────────────────────
+    return () => {
+        if (broadcastTimer !== null) {
+            clearTimeout(broadcastTimer);
+            broadcastTimer = null;
+        }
+        unsubUsers();
+        unsubAuthState();
+        bc.removeEventListener('message', handleMessage);
+        if (ownedByUs)
+            bc.close();
+    };
+}
+//# sourceMappingURL=tab-sync-wiring.js.map

package/dist/serve/entries/tab-sync-wiring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-sync-wiring.js","sourceRoot":"","sources":["../../../src/serve/entries/tab-sync-wiring.ts"],"names":[],"mappings":"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"}

package/dist/serve/entries/worker-runtime.d.ts

@@ -0,0 +1,10 @@
+/** SharedWorker availability, control-port ownership, presence, and staleness. */
+import { type ClientDb } from '../worker/client.js';
+export declare const useWorker: boolean;
+export declare const WORKER_URL = "/__pyric/sdk/worker.js";
+export declare const WORKER_NAME = "pyric-shared-worker";
+/** Control traffic only; Firebase apps receive independent app-owned ports. */
+export declare const workerDb: ClientDb | null;
+export declare function openWorkerDb(appName: string): ClientDb;
+export declare const presenceSession: import("../worker/client.js").PresenceSession | null;
+//# sourceMappingURL=worker-runtime.d.ts.map

package/dist/serve/entries/worker-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-runtime.d.ts","sourceRoot":"","sources":["../../../src/serve/entries/worker-runtime.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,qBAAqB,CAAC;AAM7B,eAAO,MAAM,SAAS,SAE2D,CAAC;AAElF,eAAO,MAAM,UAAU,2BAA2B,CAAC;AACnD,eAAO,MAAM,WAAW,wBAAwB,CAAC;AAEjD,+EAA+E;AAC/E,eAAO,MAAM,QAAQ,EAAE,QAAQ,GAAG,IAI1B,CAAC;AAET,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAItD;AAED,eAAO,MAAM,eAAe,sDAEpB,CAAC"}

package/dist/serve/entries/worker-runtime.js

@@ -0,0 +1,59 @@
+/** SharedWorker availability, control-port ownership, presence, and staleness. */
+import { getFirestore, getWorkerVersion, startPresence, subscribePresence, } from '../worker/client.js';
+import { getServiceWorkerFirestore } from '../worker/client/service-worker-connection.js';
+import { isServiceWorkerRealm } from '../worker/service-worker-channel.js';
+const hasSharedWorker = typeof SharedWorker !== 'undefined';
+export const useWorker = (hasSharedWorker || (isServiceWorkerRealm() && typeof BroadcastChannel !== 'undefined'))
+    && !globalThis.__PYRIC_FORCE_INPAGE__;
+export const WORKER_URL = '/__pyric/sdk/worker.js';
+export const WORKER_NAME = 'pyric-shared-worker';
+/** Control traffic only; Firebase apps receive independent app-owned ports. */
+export const workerDb = useWorker
+    ? hasSharedWorker
+        ? getFirestore(WORKER_URL, WORKER_NAME)
+        : null
+    : null;
+export function openWorkerDb(appName) {
+    if (hasSharedWorker)
+        return getFirestore(WORKER_URL, WORKER_NAME);
+    if (isServiceWorkerRealm())
+        return getServiceWorkerFirestore(appName);
+    throw new Error('No Pyric worker transport is available in this browser context.');
+}
+export const presenceSession = useWorker && workerDb
+    ? startPresence({ db: workerDb, kind: 'app' })
+    : null;
+if (useWorker && typeof document !== 'undefined') {
+    const servedVersion = document
+        .querySelector('meta[name="pyric-worker-v"]')
+        ?.getAttribute('content');
+    void getWorkerVersion(workerDb)
+        .then(async (runningVersion) => {
+        if (!servedVersion
+            || !runningVersion
+            || runningVersion === 'dev'
+            || servedVersion === runningVersion)
+            return;
+        const otherPages = await new Promise((resolve) => {
+            const unsubscribe = subscribePresence(workerDb, (snapshot) => {
+                unsubscribe();
+                resolve(snapshot.clients.filter((client) => client.clientId !== presenceSession?.clientId).length);
+            });
+            setTimeout(() => {
+                unsubscribe();
+                resolve(-1);
+            }, 2_000);
+        });
+        const othersHint = otherPages > 0
+            ? ` ${otherPages} other page${otherPages === 1 ? '' : 's'} must disconnect before the worker can restart.`
+            : otherPages === 0
+                ? ' This is the only connected page — reload it to pick up the new worker.'
+                : '';
+        console.warn(`[pyric dev] the SharedWorker is running OLDER code (build ${runningVersion}) than what is now `
+            + `served (build ${servedVersion}). A SharedWorker can't hot-update — CLOSE ALL TABS of this origin `
+            + 'and reopen to load the new worker. (All tabs share one worker, so a partial reload leaves '
+            + `the old code running for everyone.)${othersHint}`);
+    })
+        .catch(() => { });
+}
+//# sourceMappingURL=worker-runtime.js.map

package/dist/serve/entries/worker-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-runtime.js","sourceRoot":"","sources":["../../../src/serve/entries/worker-runtime.ts"],"names":[],"mappings":"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"}

package/dist/serve/init-payload.d.ts

@@ -0,0 +1,21 @@
+/** Browser-safe wire contract served by `/__pyric/init.json`. */
+export interface InitPayload {
+    rules: string | null;
+    rulesHash: string | null;
+    databaseRules?: {
+        rules: Record<string, unknown>;
+    } | null;
+    databaseRulesHash?: string | null;
+    databaseUrl?: string | null;
+    /** Storage rules are installed once, before the first Storage operation. */
+    storageRules: string | null;
+    storageRulesHash: string | null;
+    bridgeUrl: string | null;
+    seed: Record<string, Record<string, unknown>> | null;
+    persist?: boolean;
+    seedState?: unknown | null;
+    authUsers?: ReadonlyArray<Record<string, unknown>> | null;
+    capture?: boolean;
+    messaging?: boolean;
+}
+//# sourceMappingURL=init-payload.d.ts.map

package/dist/serve/init-payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-payload.d.ts","sourceRoot":"","sources":["../../src/serve/init-payload.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,aAAa,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC;IAC1D,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,4EAA4E;IAC5E,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IACrD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAC1D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB"}

package/dist/serve/init-payload.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init-payload.js.map

package/dist/serve/init-payload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-payload.js","sourceRoot":"","sources":["../../src/serve/init-payload.ts"],"names":[],"mappings":""}