pyric-tools 0.1.0-alpha.7

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

@@ -0,0 +1,71 @@
+/**
+ * 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 KEY = 'pyric:serve:auth-session';
+export class SessionStore {
+    stores;
+    mode = 'LOCAL'; // firebase's default persistence
+    constructor(stores) {
+        this.stores = stores;
+    }
+    /** `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(KEY, JSON.stringify({ uid }));
+    }
+    /** Reads BOTH storages (localStorage first — matches lookup order when a
+     *  prior page used a different mode). */
+    load() {
+        for (const store of [this.stores.local, this.stores.session]) {
+            const raw = store.getItem(KEY);
+            if (!raw)
+                continue;
+            try {
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed.uid === 'string')
+                    return parsed;
+            }
+            catch {
+                store.removeItem(KEY); // corrupt → drop, never throw at page init
+            }
+        }
+        return null;
+    }
+    clear() {
+        this.stores.local.removeItem(KEY);
+        this.stores.session.removeItem(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,GAAG,GAAG,0BAA0B,CAAC;AAWvC,MAAM,OAAO,YAAY;IAGM;IAFrB,IAAI,GAAgB,OAAO,CAAC,CAAC,iCAAiC;IAEtE,YAA6B,MAAqB;QAArB,WAAM,GAAN,MAAM,CAAe;IAAG,CAAC;IAEtD;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,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,EAA0B,CAAC,CAAC,CAAC;IAC/E,CAAC;IAED;6CACyC;IACzC,IAAI;QACF,KAAK,MAAM,KAAK,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7D,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAC/B,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;oBAAE,OAAO,MAAM,CAAC;YAC9D,CAAC;YAAC,MAAM,CAAC;gBACP,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,2CAA2C;YACpE,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IACtC,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,23 @@
+/**
+ * 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';
+export declare function getStorage(app?: unknown, _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 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,EAGL,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAavB,wBAAgB,UAAU,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,eAAe,CAG9E;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;AAErF,eAAO,MAAM,YAAY,wBAAkB,CAAC;AAM5C,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,OAAO,GACjB,IAAI,CAEN;AAqBD,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,49 @@
+/**
+ * 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, getStorageSandbox, } from 'pyric/storage';
+import { getStorage as workerGetStorage, getBlob as workerGetBlob, getBytes as workerGetBytes, getMetadata as workerGetMetadata, listAll as workerListAll, ref as workerRef, uploadBytes as workerUploadBytes, deleteObject as workerDeleteObject, } from '../worker/client.js';
+import { sandbox, useWorker, workerDb } from './runtime.js';
+export function getStorage(app, _bucketUrl) {
+    if (useWorker)
+        return workerGetStorage(workerDb);
+    return app ? pyricGetStorage(app) : getStorageSandbox(sandbox);
+}
+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 StorageError = ip.StorageError;
+function acceptedNoOp(name) {
+    console.info(`[pyric dev] firebase/storage ${name}() is ignored; this page already uses the pyric sandbox.`);
+}
+export function connectStorageEmulator(_storage, _host, _port, _options) {
+    acceptedNoOp('connectStorageEmulator');
+}
+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 now have a worker protocol (base64 `storage.putBytes` /
+// `storage.getBytes` / `storage.deleteObject`), so worker mode routes them to
+// the shared object store instead of throwing. No lens is attached: storage
+// rules apply only when the HOST configured them on the sandbox's storage
+// service — the served worker currently configures none (setRules deploys
+// Firestore/RTDB only), so worker-mode storage is effectively open today.
+// The admin lens matters for embedding/test hosts that pre-open the service
+// with rules. 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/namespace.d.ts

@@ -0,0 +1,93 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type StateStore } from './state-store.js';
+import { type StudioRouteOptions } from './studio/index.js';
+/** Mirrors the runtime entry's `InitPayload` — keep in lockstep with
+ *  `entries/runtime.ts`. */
+export interface InitPayload {
+    rules: string | null;
+    rulesHash: string | null;
+    databaseRules?: {
+        rules: Record<string, unknown>;
+    } | null;
+    databaseRulesHash?: string | null;
+    databaseUrl?: string | null;
+    bridgeUrl: string | null;
+    /** `--seed` documents (path → fields), applied admin-style at page init.
+     *  Null in persist mode once a state file exists — the lived state wins. */
+    seed: Record<string, Record<string, unknown>> | null;
+    /** `--persist`: the page enables sandbox persistence over /__pyric/state. */
+    persist?: boolean;
+    /** Ephemeral fixture restore (`--seed <state-file>` without --persist):
+     *  the controller blob, restored in-page via a read-only backend so
+     *  wrapper types re-hydrate. Null otherwise. */
+    seedState?: unknown | null;
+    /** Persisted auth users (sandbox.exportUsers shape), seeded at page init
+     *  before any session restore. Null when none / persist off. */
+    authUsers?: ReadonlyArray<Record<string, unknown>> | null;
+    /** `--capture`: the page pushes its session fixture to /__pyric/capture
+     *  so `pyric verify` can replay it. Default-on; suppressed by --no-capture. */
+    capture?: boolean;
+}
+/**
+ * Server-sent-events hub for `/__pyric/events` — the hot-reload channel
+ * (P3). The runtime opens an EventSource; the rules watcher broadcasts
+ * `rules-changed` and connected pages re-deploy without a refresh.
+ */
+export interface ServeEventHub {
+    /** Mounted inside the namespace handler. */
+    handle(req: IncomingMessage, res: ServerResponse): void;
+    broadcast(event: string, data: unknown): void;
+    clientCount(): number;
+}
+export declare function createEventHub(): ServeEventHub;
+export interface NamespaceOptions {
+    /** The bundle output dir (`BundleResult.outDir`). */
+    sdkDir: string;
+    /** Producer for `/__pyric/init.json` — a function so hot-reload serves
+     *  the latest rules without server restart. */
+    initPayload: () => InitPayload;
+    /** Hot-reload channel; serves `/__pyric/events` when present. */
+    events?: ServeEventHub;
+    /** `--persist`: mounts GET/POST /__pyric/state (the state channel). */
+    state?: StateStore;
+    /** `--capture`: mounts GET/POST /__pyric/capture. POST — the page/worker
+     *  pushes its session fixture here; the handler writes it verbatim to
+     *  `.pyric/last-session.json` for `pyric verify` to replay. GET — returns the
+     *  current fixture JSON (200) or 404 when nothing is captured yet, so the
+     *  served worker can re-hydrate its event history on boot after a death. */
+    capture?: {
+        write(json: string): void;
+        read(): string | null;
+    };
+    /** `--ui` (Pyric Studio): mounts `/__pyric/workspace` + `/__pyric/projects`
+     *  (disk-backed `WorkspaceStore`/`ProjectStore`, plus the SSE watch stream)
+     *  that `@pyric/studio`'s `local` mode talks to. */
+    studio?: StudioRouteOptions;
+    /** `--ui` (Pyric Studio): the dir of the built Studio app, served under
+     *  `/__pyric/ui/`. Resolved by file path in the CLI (pyric-tools never
+     *  imports `@pyric/studio`). Absent when `--ui` is off or the build is
+     *  missing. */
+    studioUiDir?: string;
+    /** `--ui` (Pyric Studio): the built playground app, mounted under
+     *  `/__pyric/playground/` for Studio's Playground tab. */
+    playgroundUiDir?: string;
+    /** `--ui` (Pyric Studio): the built docs site (site-docs), served so the
+     *  Studio Docs tab has local docs without the hosted site. Built with base
+     *  `/__pyric/ui/`, so its output straddles two subtrees under the mount:
+     *  the pages/twins/index.json live under `/__pyric/ui/docs/`, but the shared
+     *  assets live at `/__pyric/ui/_astro/` (Astro's asset dir, at the base
+     *  root — NOT under `docs/`). Both are served from this one dir. */
+    docsUiDir?: string;
+}
+export declare function createPyricNamespace(opts: NamespaceOptions): (req: IncomingMessage, res: ServerResponse, url: URL) => boolean | Promise<boolean>;
+/** The import-map targets. Spec → served URL. */
+export declare function sdkImportMap(): Record<string, string>;
+/**
+ * Inject the import map + init script into an HTML document. The import map
+ * MUST precede any module script that imports a mapped specifier, so both
+ * tags go at the very start of `<head>` (fallbacks: after `<html>`, else
+ * prepended). Idempotent — a page already carrying the marker is untouched
+ * (matters when transformHtml runs over an SPA fallback repeatedly).
+ */
+export declare function injectServeTags(html: string, importMap?: Record<string, string>, workerVersion?: string, forceInPage?: boolean): string;
+//# sourceMappingURL=namespace.d.ts.map

package/dist/serve/namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../src/serve/namespace.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,EAAqC,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEtF,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAIhF;4BAC4B;AAC5B,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,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;gFAC4E;IAC5E,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IACrD,6EAA6E;IAC7E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;oDAEgD;IAChD,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B;oEACgE;IAChE,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAC1D;mFAC+E;IAC/E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,4CAA4C;IAC5C,MAAM,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,GAAG,IAAI,CAAC;IACxD,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC9C,WAAW,IAAI,MAAM,CAAC;CACvB;AAED,wBAAgB,cAAc,IAAI,aAAa,CA4B9C;AAED,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf;mDAC+C;IAC/C,WAAW,EAAE,MAAM,WAAW,CAAC;IAC/B,iEAAiE;IACjE,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,uEAAuE;IACvE,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB;;;;gFAI4E;IAC5E,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,IAAI,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IAC/D;;wDAEoD;IACpD,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B;;;mBAGe;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;8DAC0D;IAC1D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;wEAKoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAqID,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,IAGjD,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,KAAK,GAAG,KAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CA2HzF;AAID,iDAAiD;AACjD,wBAAgB,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQrD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAkB,EAClD,aAAa,CAAC,EAAE,MAAM,EACtB,WAAW,UAAQ,GAClB,MAAM,CAuDR"}