pyric-tools 0.1.0-alpha.7

package/dist/serve/worker/serve-init.js

@@ -0,0 +1,555 @@
+/**
+ * Worker-side serve init (Phase 3c.B) — apply `pyric dev`'s init payload
+ * INSIDE the SharedWorker.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * On the in-page path, `entries/runtime.ts` is the whole backend: it fetches
+ * `/__pyric/init.json` and deploys rules, seeds users + docs, and (when
+ * `--capture` is on, which is the default) pushes the session fixture to
+ * `/__pyric/capture` so `pyric verify` can replay. When `pyric dev` routes
+ * `firebase/*` to the SharedWorker instead (the default-on flip, 3c.E), the
+ * sandbox lives in the worker — so the worker must subsume that same init, or
+ * those features silently no-op on every modern browser.
+ *
+ * This module is the worker's mirror of `runtime.ts`'s init block, factored so
+ * it is unit-testable WITHOUT a browser: it takes a real `HostCtx` (sandbox +
+ * db) and an injected `fetch`, exactly like `host.ts`. `entry.ts` wires the
+ * real `fetch` on first connect.
+ *
+ * SCOPE (3c.B): rules → authUsers → seed docs → capture. The `--persist`
+ * server-file tier and the `seedState` ephemeral-fixture restore are state-blob
+ * concerns handled in 3c.D (the worker already attaches its own IDB durable
+ * store; persist adds the committable server-file tier on top).
+ *
+ * CAPTURE FIDELITY: the worker's sandbox accumulates EVERY tab's events, so a
+ * single capture reflects the unified backend — strictly better for the verify
+ * loop than the per-tab in-page capture it replaces.
+ */
+import { getFirestore, sandbox as sandboxOps } from 'pyric/firestore';
+import { getDatabase, sandbox as rtdbSandbox } from 'pyric/database/modular';
+import { getAuth, sandbox as authOps } from 'pyric/auth';
+import { initializeSandbox, serializeToBuckets, bundleRecords, parseBundle } from 'pyric/sandbox';
+import { primeEventHistory } from 'pyric/sandbox/internal';
+import { ensureAuth, getOrCreateInstanceId } from './host.js';
+import { buildVerifyFixture } from '../../verify/fixture.js';
+/**
+ * Re-deploy rules to the worker's sandbox when `pyric dev` hot-reloads
+ * `firestore.rules`. On the worker path the SharedWorker owns ONE
+ * `/__pyric/events` connection for the whole origin — so tabs open ZERO SSE
+ * connections (avoiding Chrome's ~6-per-origin HTTP/1.1 cap, which multi-tab
+ * pages otherwise hit) AND a single rules-change deploys once, not once per
+ * tab. The `EventSource` is injected so this is testable without a browser.
+ *
+ * Returns a teardown that closes the stream.
+ */
+export function setupWorkerHotReload(ctx, makeEventSource) {
+    const events = makeEventSource('/__pyric/events');
+    events.addEventListener('rules-changed', (ev) => {
+        try {
+            const { rules } = JSON.parse(ev.data);
+            const lint = sandboxOps.setRules(ctx.db, rules);
+            if (lint.parseError)
+                throw new Error(JSON.stringify(lint.parseError));
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.error('[pyric worker] rules hot-reload failed:', err instanceof Error ? err.message : String(err));
+        }
+    });
+    return () => events.close();
+}
+/**
+ * A seed fixture applies ONLY into an empty home. `buildWorkerCtx` calls
+ * `sandbox.enablePersistence` (restoring from IDB — and, with `--persist`,
+ * priming from the committable server file — see `createWorkerDurableBackend`)
+ * BEFORE `applyServeInit` runs, so by the time this check runs any restored
+ * data is already visible on `ctx`. If the sandbox holds ANY Firestore
+ * document or auth user at this point, that's lived/restored state, not a
+ * blank slate — a `--seed` fixture must never stomp it. This is the fix for
+ * the worst persistence bug: without it, `--seed` (map form) re-applies on
+ * EVERY boot because default (no `--persist`) mode never has a state.json
+ * file to gate on, silently reverting whatever IndexedDB persistence just
+ * restored.
+ */
+function sandboxHasExistingData(ctx) {
+    const docs = sandboxOps.snapshotState(ctx.db);
+    if (Object.keys(docs).length > 0)
+        return true;
+    const auth = ensureAuth(ctx);
+    return authOps.exportUsers(auth).length > 0;
+}
+/**
+ * Apply the init payload to the worker's sandbox.
+ *
+ * Ordering mirrors `runtime.ts`: rules first (so the first write is governed),
+ * then authUsers (so restored docs' owner uids resolve in rules), then seed
+ * docs, then capture wiring. Synchronous except for capture's fire-and-forget
+ * POSTs — the caller (`entry.ts`) does not need to await anything here.
+ */
+export function applyServeInit(ctx, payload, env) {
+    const result = {
+        rulesDeployed: false,
+        seededDocs: 0,
+        seededUsers: 0,
+        captureEnabled: false,
+        rulesParseError: null,
+        seedSkipped: null,
+        dispose: () => { },
+    };
+    // 1. Rules — deploy the project's ruleset, replacing the permissive starter
+    //    `entry.ts` deployed at bootstrap. A parse error is defensive (the server
+    //    lints before serving): keep the default rules, surface loudly.
+    if (payload.rules) {
+        const lint = sandboxOps.setRules(ctx.db, payload.rules);
+        if (lint.parseError) {
+            result.rulesParseError = JSON.stringify(lint.parseError);
+            console.error('[pyric worker] firestore.rules failed to parse — running WITHOUT your rules:', result.rulesParseError);
+        }
+        else {
+            result.rulesDeployed = true;
+        }
+    }
+    if (payload.databaseRules) {
+        const rtdb = ctx.rtdb ??= getDatabase(ctx.sandbox);
+        rtdbSandbox.setRules(rtdb, payload.databaseRules);
+        ctx.activeRules ??= {};
+        ctx.activeRules.database = {
+            source: payload.databaseRules,
+            updatedAt: Date.now(),
+            status: 'active',
+            messages: [],
+        };
+    }
+    // A seed fixture applies only into an empty home — checked ONCE, before
+    // either seed step, so step 2's own writes can't make step 3's check look
+    // non-empty (see sandboxHasExistingData).
+    const hasExistingData = ((payload.seed && Object.keys(payload.seed).length > 0) ||
+        (payload.authUsers && payload.authUsers.length > 0)) &&
+        sandboxHasExistingData(ctx);
+    if (hasExistingData) {
+        result.seedSkipped = 'existing-data';
+        console.info('[pyric worker] --seed skipped: the sandbox already has restored data (persisted state or ' +
+            'an earlier session in this browser) — the fixture would have overwritten it. Use ' +
+            '`--persist --fresh` to discard existing state and re-seed from scratch.');
+    }
+    // 2. Auth users — seed BEFORE docs so any owner-uid the rules reference
+    //    resolves, and before session restore so there is a DB to restore into.
+    if (!hasExistingData && payload.authUsers && payload.authUsers.length > 0) {
+        const auth = ensureAuth(ctx);
+        authOps.seedUsers(auth, payload.authUsers);
+        result.seededUsers = payload.authUsers.length;
+    }
+    // 3. Seed docs — admin-style fixture load (bypasses rules).
+    if (!hasExistingData && payload.seed && Object.keys(payload.seed).length > 0) {
+        sandboxOps.seedDocuments(ctx.db, payload.seed);
+        result.seededDocs = Object.keys(payload.seed).length;
+    }
+    // 4. Capture — the write side of the `pyric verify` loop. On every sandbox
+    //    event, debounce-POST the full session fixture (rules + history + state)
+    //    to `/__pyric/capture`. The server writes it verbatim to
+    //    `.pyric/last-session.json`. Independent of --persist.
+    if (payload.capture) {
+        const debounceMs = payload.capture ? (env.captureDebounceMs ?? 400) : 0;
+        let timer = null;
+        const flush = () => {
+            const rtdb = ctx.rtdb ??= getDatabase(ctx.sandbox);
+            const rtdbState = payload.databaseRules || ctx.sandbox.history().some((event) => event.service === 'rtdb')
+                ? rtdbSandbox.snapshotState(rtdb)
+                : undefined;
+            const auth = ensureAuth(ctx);
+            const body = JSON.stringify(buildVerifyFixture({
+                sandbox: ctx.sandbox,
+                firestoreRules: payload.rules,
+                rtdbRules: payload.databaseRules ?? null,
+                rtdbState,
+                rtdbDatabaseUrl: payload.databaseUrl ?? null,
+                authState: {
+                    users: authOps.exportUsers(auth),
+                    currentUser: ctx.sandbox.currentUser,
+                },
+                // Stamp WHO produced this capture so a booting worker only re-hydrates
+                // its OWN session (see hydrateEventHistory's identity guard).
+                capturedBy: ctx.instanceId,
+            }));
+            // Relative URL resolves against the worker script's origin (same origin
+            // as the page). Fire-and-forget — capture failures never break ops.
+            env
+                .fetch('/__pyric/capture', {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body,
+            })
+                .catch(() => { });
+        };
+        const unsub = ctx.sandbox.onEvent(() => {
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(flush, debounceMs);
+        });
+        result.captureEnabled = true;
+        result.dispose = () => {
+            if (timer)
+                clearTimeout(timer);
+            unsub();
+        };
+    }
+    return result;
+}
+// ─── Event-history hydration: survive worker death (served mode) ─────────────
+/**
+ * Cap on the number of events primed on boot. A long-lived session can
+ * accumulate a large capture; a fresh worker only needs enough recent history
+ * for Traffic / activity / metrics to feel continuous, so we prime the most
+ * recent N and drop older events rather than balloon worker memory with the
+ * whole log. The full log still lives on disk for `pyric verify`.
+ */
+export const MAX_PRIMED_EVENTS = 2000;
+/**
+ * Re-hydrate the worker's in-memory event history from the served capture
+ * file on boot — the fix for "worker death zeroes Traffic / activity / metrics
+ * even though the data restored from IDB".
+ *
+ * The SERVER already holds the complete event log (`.pyric/last-session.json`,
+ * written continuously by the capture flush). On a fresh worker we GET it back
+ * and REPLAY `events[]` into the sandbox's `history()` via the
+ * {@link primeEventHistory} seam — append-only, NO re-execution of ops and NO
+ * dispatch to live `onEvent` subscribers. Studio subscribes AFTER boot and
+ * reads history-first, so append-only-no-dispatch gives every consumer
+ * continuity for free with zero Studio changes.
+ *
+ * GUARD RAILS:
+ *  - Only primes when history is EMPTY (the {@link primeEventHistory} seam
+ *    enforces this) — a warm sandbox is never disturbed and primed events can
+ *    never interleave after live boot events. Call this BEFORE applyServeInit.
+ *  - Caps at {@link MAX_PRIMED_EVENTS} (most recent) so a huge capture can't
+ *    balloon worker memory.
+ *  - IDENTITY: skips when the capture was produced by a DIFFERENT instance
+ *    (`capturedBy !== ctx.instanceId`) — another browser profile sharing one
+ *    `pyric dev` shouldn't see someone else's session as its own. A capture
+ *    with no `capturedBy` (older / standalone) primes best-effort.
+ *  - Skips cleanly when the endpoint 404s (capture off / nothing captured) or
+ *    the fetch throws (standalone worker, no `pyric dev` behind it).
+ *
+ * FRESHNESS: the capture lags the last pre-death moments by up to the debounce
+ * window (~400ms), so the final events before a worker death may be missing.
+ * That is acceptable — the data itself is durable via IDB; this only restores
+ * the activity RECORD, and near-perfect is enough for Traffic/feed continuity.
+ *
+ * Returns the number of events primed (0 when skipped).
+ */
+export async function hydrateEventHistory(ctx, env) {
+    let res;
+    try {
+        res = await env.fetch('/__pyric/capture');
+    }
+    catch {
+        return 0; // standalone / no capture endpoint.
+    }
+    if (res.status !== 200)
+        return 0; // 404 → capture off or nothing captured.
+    let fixture;
+    try {
+        fixture = JSON.parse(await res.text());
+    }
+    catch {
+        return 0; // corrupt capture — never brick boot over the activity log.
+    }
+    const events = fixture.events;
+    if (!Array.isArray(events) || events.length === 0)
+        return 0;
+    // Identity: don't show a neighbor profile's session as ours.
+    if (fixture.capturedBy && fixture.capturedBy !== ctx.instanceId)
+        return 0;
+    const capped = events.length > MAX_PRIMED_EVENTS ? events.slice(-MAX_PRIMED_EVENTS) : events;
+    return primeEventHistory(ctx.sandbox, capped);
+}
+// ─── Durable persistence: the --persist server-file tier + seedState (3c.D) ─
+/**
+ * Stable writer id the worker sends on every `/__pyric/state` POST. There is
+ * exactly ONE worker per origin, so it is the sole writer — the multi-tab
+ * 423 / writer-lock contention the in-page path fights does not arise. The id
+ * is constant so the server's lock recognizes the same holder across writes;
+ * if the worker dies (all tabs closed) the server frees the stale lock and the
+ * next worker reclaims it.
+ */
+const WORKER_WRITER_ID = 'pyric-shared-worker';
+const stateSection = (name) => `/__pyric/state?section=${name}`;
+/**
+ * Build the worker's DURABLE backend for the persistence controller.
+ *
+ *  - **default** (no `--persist`, no `seedState`): the injected IDB backend,
+ *    untouched — IDB is the durable store and the multi-tab sync point.
+ *  - **`--persist`**: a composite over IDB that ALSO mirrors the controller
+ *    blob to the committable server file (`/__pyric/state?section=firestore`).
+ *    On a fresh worker (IDB empty) it PRIMES from the server file, so a
+ *    committed `.pyric/state` restores. The blob the controller hands `write`
+ *    is the SAME `serializeSnapshot(firestore, services)` the in-page path
+ *    posts there, so the on-disk format is byte-identical — and auth rides it
+ *    via `services` (the #629 registry).
+ *  - **`seedState`** (a `--seed <state-file>` fixture WITHOUT `--persist`):
+ *    primes IDB once from the fixture blob, then lives in IDB. No server file.
+ *
+ * IMPORTANT: this wraps ONLY the persistence-controller backend. The worker's
+ * session record (`SESSION_RECORD_KEY`) is local-only and must NOT reach the
+ * server file, so `entry.ts` keeps the RAW IDB backend as `ctx.sessionBackend`.
+ *
+ * Local IDB always wins on read: we never clobber live local state with a
+ * stale server file — pyric is a single local backend (no two-source
+ * reconciliation), so the server file is a prime-once source + an export sink.
+ */
+export function createWorkerDurableBackend(idb, payload, env) {
+    const persist = Boolean(payload.persist);
+    const seed = (payload.seedState ?? null);
+    // Fixture (seedState without --persist): the seed docs as v3 records, primed
+    // once into IDB. The committable v3 BUNDLE the file holds and the records IDB
+    // holds are the same data in two shapes.
+    const fixtureRecords = !persist && seed != null
+        ? serializeToBuckets(seed.firestore ?? {}, seed.services ?? {}, 0)
+        : null;
+    // Plain IDB — nothing to layer on.
+    if (!persist && fixtureRecords === null)
+        return idb;
+    // Prime IDB once from the export source (committable file / fixture) on a
+    // fresh worker. Local IDB always wins: never clobber live local state.
+    let primed = false;
+    const primeOnce = async (key) => {
+        if (primed)
+            return;
+        primed = true;
+        if ((await idb.listRecords(key)).length > 0)
+            return;
+        if (persist) {
+            const res = await env.fetch(stateSection('firestore'));
+            if (res.status === 200) {
+                const records = parseBundle(await res.text());
+                if (records.size > 0)
+                    await idb.putRecords(key, records);
+            }
+        }
+        else if (fixtureRecords !== null) {
+            await idb.putRecords(key, fixtureRecords);
+        }
+    };
+    // Mirror the FULL current record set to the committable server file as one v3
+    // bundle. Fire-and-forget: a flaky export must never block a local write.
+    const mirror = async (key) => {
+        if (!persist)
+            return;
+        try {
+            const ids = await idb.listRecords(key);
+            const all = new Map();
+            for (const id of ids) {
+                const r = await idb.getRecord(key, id);
+                if (r != null)
+                    all.set(id, r);
+            }
+            const res = await env.fetch(stateSection('firestore'), {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', 'x-pyric-writer': WORKER_WRITER_ID },
+                body: bundleRecords(all),
+            });
+            if (res.status === 423) {
+                console.warn('[pyric worker] --persist: server file is held by another writer; export skipped.');
+            }
+        }
+        catch {
+            /* export sink offline; local IDB is unaffected. */
+        }
+    };
+    return {
+        async getRecord(key, recordId) {
+            await primeOnce(key);
+            return idb.getRecord(key, recordId);
+        },
+        async listRecords(key) {
+            await primeOnce(key);
+            return idb.listRecords(key);
+        },
+        async putRecords(key, records) {
+            await idb.putRecords(key, records); // IDB is the live durable store.
+            await mirror(key);
+        },
+        async deleteRecords(key, recordIds) {
+            await idb.deleteRecords(key, recordIds);
+            await mirror(key);
+        },
+        async clear(key) {
+            await idb.clear(key);
+            if (!persist)
+                return;
+            try {
+                await env.fetch(stateSection('firestore'), {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json', 'x-pyric-writer': WORKER_WRITER_ID },
+                    body: 'null',
+                });
+            }
+            catch {
+                /* ignore */
+            }
+        },
+    };
+}
+/**
+ * Mirror the auth user DB to the committable server file's `auth` section
+ * (`--persist` only), matching the in-page path so a worker-written
+ * `.pyric/state` is format-identical (and `pyric dev`'s init payload, which
+ * reads `section=auth` for `authUsers`, stays populated). Auth ALSO rides the
+ * firestore controller blob via `services`; this separate mirror is the
+ * belt-and-suspenders the in-page path keeps.
+ *
+ * Returns a teardown that stops the subscription.
+ */
+export function setupServerAuthFlush(ctx, payload, env) {
+    if (!payload.persist)
+        return () => { };
+    const auth = ensureAuth(ctx);
+    const debounceMs = env.captureDebounceMs ?? 400;
+    let timer = null;
+    const flush = () => {
+        const body = JSON.stringify({ users: authOps.exportUsers(auth) });
+        env
+            .fetch(stateSection('auth'), {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', 'x-pyric-writer': WORKER_WRITER_ID },
+            body,
+        })
+            .catch(() => { });
+    };
+    const unsub = authOps.subscribeUsers(auth, () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(flush, debounceMs);
+    });
+    return () => {
+        if (timer)
+            clearTimeout(timer);
+        unsub();
+    };
+}
+// ─── Worker boot: build the ONE shared HostCtx ──────────────────────────────
+/** Default persistence key — also the IndexedDB database name. Package-level
+ *  default; stable across reloads (never derived from the page path, so every
+ *  boot on an origin opens the SAME database). */
+export const WORKER_PERSISTENCE_KEY = 'pyric-shared-worker';
+const PERMISSIVE_RULES = `
+  rules_version = '2';
+  service cloud.firestore {
+    match /databases/{database}/documents {
+      match /{document=**} {
+        allow read, write: if true;
+      }
+    }
+  }
+`;
+/**
+ * Build the ONE shared sandbox + Firestore handle — the SharedWorker's boot
+ * path, extracted from `entry.ts` so it is testable without a SharedWorker
+ * runtime (the reload-durability regression tests boot it twice over one
+ * fake-IDB factory).
+ *
+ * DURABILITY CONTRACT: persistence is wired via `sandbox.enablePersistence`
+ * (NOT the raw `attachPersistence` helper) so the controller registers on the
+ * sandbox and `sandbox.flush()` works. The worker host awaits that flush —
+ * which awaits the IndexedDB transaction's `oncomplete` — before acking every
+ * mutating op. That is the worker's ONLY durability mechanism: a SharedWorker
+ * gets no beforeunload/beforeterminate, so anything not committed to IDB when
+ * the last tab closes is lost.
+ */
+export async function buildWorkerCtx(env) {
+    const sandbox = initializeSandbox();
+    // Deploy permissive starter rules via admin-firestore.
+    // Callers override at runtime via the setRules op.
+    const { getFirestore: getAdminFirestore } = await import('pyric/sandbox/admin-firestore');
+    const adminDb = getAdminFirestore(sandbox.withAuth(null));
+    adminDb.setRules(PERMISSIVE_RULES);
+    // Fetch serve's init payload FIRST — it decides the DURABLE strategy before
+    // we attach: `--persist` mirrors the controller blob to the committable
+    // server file (and primes from it on a fresh worker); a `seedState` fixture
+    // primes IDB once. Null when standalone (no `pyric dev` behind us).
+    const payload = await fetchInitPayload(env.fetch);
+    // The persistence-controller backend. `--persist`/`seedState` wrap IDB (see
+    // createWorkerDurableBackend); plain IDB otherwise. The session record stays
+    // on the RAW idb (local-only — it must NEVER reach the committable server
+    // file), so that is what we hand the host as `sessionBackend`.
+    const durable = payload ? createWorkerDurableBackend(env.idb, payload, env) : env.idb;
+    await sandbox.enablePersistence({
+        key: env.persistenceKey ?? WORKER_PERSISTENCE_KEY,
+        injectedBackend: durable,
+    });
+    // Register the auth service with the persistence registry BEFORE we read
+    // back any session: `getAuth(sandbox)` makes the user DB ride the snapshot
+    // (the #629 mechanism). One auth per worker — one shared user pool across
+    // all tabs (sessions are per-port; see host-auth.ts).
+    getAuth(sandbox);
+    // Register RTDB with the persistence registry EAGERLY, same reasoning as
+    // auth above: `getDatabase(sandbox)` calls `registerPersistableService`,
+    // which makes the persisted tree ride the controller blob AND (via the
+    // controller's late-registration hook) applies the restored tree NOW. The
+    // worker otherwise creates RTDB handles lazily (`ctx.rtdb ??= ...`), so a
+    // Studio RTDB-tab read that arrives before any RTDB op would see an empty
+    // tree even though a prior session's data was persisted. Eager registration
+    // makes the restored tree queryable immediately.
+    getDatabase(sandbox);
+    // Sandbox-live Firestore: `getFirestore(sandbox)` reads
+    // `sandbox.currentUser` per operation, so auth changes propagate
+    // to subsequent Firestore ops without rebuilding the handle.
+    const db = getFirestore(sandbox);
+    const ctx = {
+        db,
+        sandbox,
+        // Stable per-SharedWorker identity (raw idb, local-only). Two browser
+        // profiles on the same port get two ids — how the UI tells them apart.
+        instanceId: await getOrCreateInstanceId(env.idb),
+        subs: new Map(),
+        sessionBackend: env.idb,
+        sessionMode: 'LOCAL',
+    };
+    // Re-hydrate the event history from the served capture BEFORE applyServeInit
+    // runs — history is empty here (fresh sandbox, persistence restore emits no
+    // sandbox events), so primed events land first and any live boot events
+    // (seed, first ops) follow. This is what makes Traffic / activity / metrics
+    // survive a worker death: the DATA came back from IDB above, this restores
+    // the RECORD of it. Best-effort — a failure never blocks boot.
+    if (payload?.capture) {
+        try {
+            await hydrateEventHistory(ctx, env);
+        }
+        catch {
+            /* activity-log hydration is non-essential; never brick boot over it. */
+        }
+    }
+    // Apply rules / seed / authUsers / capture BEFORE any port op runs (so
+    // seeded users exist and project rules govern the first write), then mirror
+    // auth to the committable server file (`--persist` only).
+    if (payload) {
+        applyServeInit(ctx, payload, env);
+        setupServerAuthFlush(ctx, payload, env);
+    }
+    // The worker owns the SINGLE hot-reload stream for the origin (tabs open
+    // none) — so a rules change deploys once and multi-tab pages never exhaust
+    // the per-origin connection cap.
+    if (env.makeEventSource) {
+        setupWorkerHotReload(ctx, env.makeEventSource);
+    }
+    return ctx;
+}
+/**
+ * Fetch + parse `/__pyric/init.json`. The URL is relative to the worker
+ * script's origin (same origin as the page). Returns null on any failure: a
+ * worker opened outside `pyric dev` has no init endpoint and simply keeps
+ * the permissive starter rules + a plain-IDB durable store.
+ */
+async function fetchInitPayload(fetchFn) {
+    try {
+        const res = await fetchFn('/__pyric/init.json');
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=serve-init.js.map

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

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

package/dist/serve/writer-lock.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Single-writer lock for `--persist` (pre-mortem #3).
+ *
+ * Two tabs = two sandboxes, each flushing its WHOLE world view — so the
+ * second tab's flush doesn't merge, it ERASES everything the first wrote.
+ * "last-writer-wins" undersold it: last-tab's-universe wins, visibly, on the
+ * loser's next reload.
+ *
+ * The conflict only exists at WRITE time, so the lock is resolved there: the
+ * first page to flush claims the writer role (carried in the
+ * `x-pyric-writer` header); a different page's flush is refused (409) and
+ * that page drops to read-only persistence + a loud console line. A reader
+ * that never mutates never conflicts.
+ *
+ * Liveness: the holder refreshes `lastSeen` on every accepted write and via
+ * a periodic heartbeat. A holder that goes quiet for `staleMs` (crash, or an
+ * idle tab whose heartbeat also stopped) is considered gone, so a fresh page
+ * can claim the role — no permanent wedge. The small overlap window where a
+ * stale-but-alive holder and a new claimer both think they're the writer is
+ * an accepted dev-tool race (documented), kept rare by a generous staleMs.
+ */
+export interface WriterLock {
+    /** Claim/refresh for `id`. Granted when free, already held by `id`, or the
+     *  current holder is stale. Returns whether `id` now holds the lock. */
+    claim(id: string, now: number): boolean;
+    /** Release if `id` is the holder (no-op otherwise). */
+    release(id: string): void;
+    /** Current holder, or null. */
+    holder(): string | null;
+}
+export declare function createWriterLock(staleMs?: number): WriterLock;
+//# sourceMappingURL=writer-lock.d.ts.map

package/dist/serve/writer-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer-lock.d.ts","sourceRoot":"","sources":["../../src/serve/writer-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,UAAU;IACzB;4EACwE;IACxE,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACxC,uDAAuD;IACvD,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,+BAA+B;IAC/B,MAAM,IAAI,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,GAAG,UAAU,CAoB7D"}

package/dist/serve/writer-lock.js

@@ -0,0 +1,43 @@
+/**
+ * Single-writer lock for `--persist` (pre-mortem #3).
+ *
+ * Two tabs = two sandboxes, each flushing its WHOLE world view — so the
+ * second tab's flush doesn't merge, it ERASES everything the first wrote.
+ * "last-writer-wins" undersold it: last-tab's-universe wins, visibly, on the
+ * loser's next reload.
+ *
+ * The conflict only exists at WRITE time, so the lock is resolved there: the
+ * first page to flush claims the writer role (carried in the
+ * `x-pyric-writer` header); a different page's flush is refused (409) and
+ * that page drops to read-only persistence + a loud console line. A reader
+ * that never mutates never conflicts.
+ *
+ * Liveness: the holder refreshes `lastSeen` on every accepted write and via
+ * a periodic heartbeat. A holder that goes quiet for `staleMs` (crash, or an
+ * idle tab whose heartbeat also stopped) is considered gone, so a fresh page
+ * can claim the role — no permanent wedge. The small overlap window where a
+ * stale-but-alive holder and a new claimer both think they're the writer is
+ * an accepted dev-tool race (documented), kept rare by a generous staleMs.
+ */
+export function createWriterLock(staleMs = 60_000) {
+    let holder = null;
+    let lastSeen = 0;
+    return {
+        claim(id, now) {
+            if (holder === null || holder === id || now - lastSeen > staleMs) {
+                holder = id;
+                lastSeen = now;
+                return true;
+            }
+            return false;
+        },
+        release(id) {
+            if (holder === id) {
+                holder = null;
+                lastSeen = 0;
+            }
+        },
+        holder: () => holder,
+    };
+}
+//# sourceMappingURL=writer-lock.js.map

package/dist/serve/writer-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer-lock.js","sourceRoot":"","sources":["../../src/serve/writer-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAYH,MAAM,UAAU,gBAAgB,CAAC,OAAO,GAAG,MAAM;IAC/C,IAAI,MAAM,GAAkB,IAAI,CAAC;IACjC,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,OAAO;QACL,KAAK,CAAC,EAAE,EAAE,GAAG;YACX,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,EAAE,IAAI,GAAG,GAAG,QAAQ,GAAG,OAAO,EAAE,CAAC;gBACjE,MAAM,GAAG,EAAE,CAAC;gBACZ,QAAQ,GAAG,GAAG,CAAC;gBACf,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,CAAC,EAAE;YACR,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;gBAClB,MAAM,GAAG,IAAI,CAAC;gBACd,QAAQ,GAAG,CAAC,CAAC;YACf,CAAC;QACH,CAAC;QACD,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM;KACrB,CAAC;AACJ,CAAC"}