pyric 0.0.1 → 0.1.0-alpha.7

package/dist/sandbox/persistence/controller.js

@@ -0,0 +1,605 @@
+/**
+ * Persistence controller — wires a `PersistenceBackend` into a
+ * `SandboxImpl`. Owns the debounced auto-flush, the `beforeunload`
+ * safety flush, and the restore-on-attach pass.
+ *
+ * Conceptually orthogonal to the sandbox: the sandbox doesn't know
+ * persistence exists until `enablePersistence` constructs a controller
+ * and hands it the live sandbox. Disposing the controller detaches
+ * every side effect and leaves the sandbox unchanged.
+ */
+import { SandboxImpl } from '../internal/sandbox-impl.js';
+import { createIndexedDBBackend, createMemoryBackend } from './backends.js';
+import { serializeToBuckets, deserializeFromBuckets, migrateV2ToRecords, } from './chunk-format.js';
+const DEFAULT_FLUSH_INTERVAL_MS = 250;
+/**
+ * Storage key for the persisted auth session uid. One key used across
+ * both `local` and `session` stores — the controller reads both (mode-
+ * agnostic load) and writes only one (based on the current mode). This
+ * mirrors how `pyric dev`'s `SessionStore` worked before the session
+ * logic moved here.
+ *
+ * Prefixed `pyric:sandbox:` so it's immediately grepable and doesn't
+ * collide with serve's `pyric:serve:` entries or app-level keys.
+ */
+const SESSION_STORAGE_KEY = 'pyric:sandbox:auth-session';
+/**
+ * Stable 32-bit FNV-1a content hash of a bucket record, for detecting which
+ * buckets changed between flushes. A genuinely changed record almost never
+ * hashes equal to its prior content; in the astronomically rare event of a
+ * collision the bucket simply re-persists on its next change. Bucket key order
+ * is stable across flushes (snapshot iteration order), so an UNCHANGED bucket
+ * always hashes identically.
+ */
+function hashRecord(record) {
+    const s = JSON.stringify(record);
+    let h = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619) >>> 0;
+    }
+    return h;
+}
+/** Detect a storage-quota-exceeded error across environments (the DOMException
+ *  name in browsers, a message fallback elsewhere). */
+function isQuotaExceeded(e) {
+    if (e && typeof e === 'object') {
+        if (e.name === 'QuotaExceededError')
+            return true;
+        const msg = e.message;
+        if (typeof msg === 'string' && /quota/i.test(msg))
+            return true;
+    }
+    return false;
+}
+function pickBackend(options) {
+    if (options.injectedBackend)
+        return options.injectedBackend;
+    const requested = options.backend ?? 'indexedDB';
+    if (requested === 'memory')
+        return createMemoryBackend();
+    // `indexedDB` requested. In non-browser hosts we transparently fall
+    // back to memory so calling code paths can share an `enablePersistence`
+    // call across browser + test environments without branching.
+    if (typeof indexedDB === 'undefined')
+        return createMemoryBackend();
+    return createIndexedDBBackend();
+}
+/**
+ * Construct a controller, restore any prior snapshot, and wire the
+ * auto-flush subscription. Returns once restore has completed (callers
+ * can `await sandbox.enablePersistence(...)` and be sure the in-memory
+ * state reflects the persisted blob).
+ *
+ * Late service registration: services (e.g. auth) may register with the
+ * sandbox AFTER this call returns (the user calls `enablePersistence`
+ * then later `getAuth(sandbox)` which triggers `registerPersistableService`).
+ * We handle this in two parts:
+ *   1. `restore()` returns the raw `services` blob map so the controller
+ *      can apply it to late-arriving services.
+ *   2. `setServiceRegistrationHook` fires on each registration — we
+ *      immediately apply the saved blob data (if any) AND subscribe the
+ *      service's change notifier for future flushes.
+ */
+export async function attachPersistence(sandbox, rawOptions) {
+    const options = {
+        ...rawOptions,
+        flushIntervalMs: rawOptions.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
+        backend: rawOptions.backend ?? 'indexedDB',
+    };
+    const backend = pickBackend(options);
+    // Content hash of each persisted bucket, so a flush writes only the buckets
+    // whose content actually changed. restore() seeds it from the records it reads,
+    // so the just-restored state is not redundantly re-written on the first flush.
+    const lastHashes = new Map();
+    // `restore()` returns the raw services blob — the controller keeps this
+    // so late-registering services can still receive their saved state even
+    // though they weren't in the registry when `restore()` ran.
+    const restoredServices = await restore(sandbox, backend, options.key, lastHashes);
+    let pendingFlush = null;
+    let disposed = false;
+    // Track unsubscribers for service change-notification hooks so we can
+    // clean up in dispose(). Keyed by service name (not strictly needed,
+    // but makes debugging easier).
+    const serviceUnsubs = new Map();
+    // The actual flush. Reads CURRENT state each time it runs.
+    const realFlush = async () => {
+        if (disposed)
+            return;
+        // `sandbox.snapshot()` now includes `{ firestore, services }` — the
+        // services map is built live from the registry, so services registered
+        // after enablePersistence (late registration) are naturally included.
+        const snap = sandbox.snapshot();
+        const records = serializeToBuckets(snap.firestore, snap.services, Date.now());
+        // Incremental flush: write ONLY the buckets whose content changed since the
+        // last flush, and delete buckets that disappeared. Comparison is by content
+        // hash, so it is safe by construction: a changed bucket cannot hash equal to
+        // its prior content, so no write is ever skipped (no write-site dirty-set to
+        // keep in sync). Put changed buckets BEFORE deleting removed ones, and adopt
+        // the new hashes only AFTER both land, so a crash mid-flush never loses live
+        // data and the next flush simply retries against the unchanged hash state.
+        const changed = new Map();
+        const nextHashes = new Map();
+        for (const [id, rec] of records) {
+            const h = hashRecord(rec);
+            nextHashes.set(id, h);
+            if (lastHashes.get(id) !== h)
+                changed.set(id, rec);
+        }
+        const removed = [...lastHashes.keys()].filter((id) => !records.has(id));
+        if (changed.size > 0)
+            await backend.putRecords(options.key, changed);
+        if (removed.length > 0)
+            await backend.deleteRecords(options.key, removed);
+        lastHashes.clear();
+        for (const [id, h] of nextHashes)
+            lastHashes.set(id, h);
+    };
+    // Serialize flushes on a single chain so two never overlap. Without this, a
+    // newer flush that fails while an older one succeeds could adopt a stale
+    // snapshot's hashes and silently drop the newer write. Each run waits for the
+    // previous (success OR failure) and re-derives changes from current state.
+    let flushChain = Promise.resolve();
+    const flushNow = () => {
+        if (pendingFlush) {
+            clearTimeout(pendingFlush);
+            pendingFlush = null;
+        }
+        flushChain = flushChain.then(realFlush, realFlush);
+        return flushChain;
+    };
+    const scheduleFlush = () => {
+        if (disposed)
+            return;
+        if (pendingFlush)
+            return;
+        pendingFlush = setTimeout(() => {
+            pendingFlush = null;
+            void flushNow().catch((e) => {
+                if (isQuotaExceeded(e)) {
+                    // Storage is full: retrying will not help until space is freed, so
+                    // warn loudly instead of busy-looping. The unpersisted changes stay in
+                    // memory; the next successful flush (after space frees) re-detects them.
+                    console.warn('[sandbox/persistence] storage quota exceeded; recent changes are kept ' +
+                        'in memory only. Free storage or reduce sandbox data to persist them.');
+                    return;
+                }
+                console.warn('[sandbox/persistence] auto-flush failed, will retry:', e);
+                // A failed flush did not adopt its hashes, so the change is still
+                // unpersisted. Re-arm rather than waiting for the next write event, so
+                // an idle-after-failure does not leave the change permanently in memory.
+                scheduleFlush();
+            });
+        }, options.flushIntervalMs);
+    };
+    /**
+     * Wire up a service's optional change-notification hook. When a
+     * service provides `subscribe`, we call it here so auth-user edits
+     * trigger a debounced flush — not only the next Firestore write.
+     */
+    const attachServiceSubscription = (name, hooks) => {
+        if (!hooks.subscribe || serviceUnsubs.has(name))
+            return;
+        const unsub = hooks.subscribe(() => {
+            scheduleFlush();
+        });
+        serviceUnsubs.set(name, unsub);
+    };
+    // ─── Session persistence setup ─────────────────────────────────────
+    //
+    // Session persistence is ONLY active when `options.sessionStorage` is
+    // provided. When omitted, the user DB still persists (Phase 1) but the
+    // CURRENT SESSION is not restored — no fake durability (Decision 2).
+    //
+    // The session controller reads/writes a single uid JSON blob to the
+    // appropriate web-storage slot based on the auth mode. It discovers
+    // the auth service's session hooks by scanning the service registry
+    // (and via the late-registration hook for services registered after
+    // enablePersistence). Only one session provider is supported today
+    // (auth); a second service would need to add its own hooks.
+    /** Unsubscribers for session-change hooks; cleared in dispose(). */
+    const sessionUnsubs = new Map();
+    /**
+     * Save the current session uid to the appropriate web-storage slot,
+     * or clear both slots on sign-out or NONE mode.
+     *
+     * Called on every session-change event (sign-in, sign-out, mode change).
+     * Reads the CURRENT mode and uid at call time so stale closures can't
+     * cause incorrect slot choices (important for mode-migration: a mode
+     * change fires a session-change event, and we read the already-updated
+     * mode here).
+     */
+    const saveSession = (sessionHooks) => {
+        if (!options.sessionStorage)
+            return;
+        const { local, session } = options.sessionStorage;
+        const uid = sessionHooks.currentUid();
+        const mode = sessionHooks.mode();
+        if (uid === null || mode === 'NONE') {
+            // Signed out, or mode is NONE — clear both stores so no uid lingers
+            // across a sign-out or a mode downgrade to NONE.
+            local.removeItem(SESSION_STORAGE_KEY);
+            session.removeItem(SESSION_STORAGE_KEY);
+            return;
+        }
+        // A session lives in EXACTLY ONE store at any time — clear the other
+        // first, then write to the target. This prevents a stale entry in the
+        // other store from being picked up on a future reload with a different
+        // mode (which would look like the earlier mode's session resuming).
+        const payload = JSON.stringify({ uid });
+        if (mode === 'LOCAL') {
+            session.removeItem(SESSION_STORAGE_KEY); // clear the other slot
+            local.setItem(SESSION_STORAGE_KEY, payload);
+        }
+        else {
+            // SESSION
+            local.removeItem(SESSION_STORAGE_KEY); // clear the other slot
+            session.setItem(SESSION_STORAGE_KEY, payload);
+        }
+    };
+    /**
+     * Read back the stored uid from EITHER web-storage slot.
+     * Mode-agnostic: reads local then session (same order as serve's
+     * `SessionStore.load`). Returns null when nothing is stored or the
+     * blob is unparseable (corrupt bytes → silently drop).
+     */
+    const loadStoredUid = () => {
+        if (!options.sessionStorage)
+            return null;
+        const { local, session } = options.sessionStorage;
+        for (const store of [local, session]) {
+            const raw = store.getItem(SESSION_STORAGE_KEY);
+            if (!raw)
+                continue;
+            try {
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed.uid === 'string')
+                    return parsed.uid;
+            }
+            catch {
+                // Corrupt value — remove it so it doesn't confuse a future load.
+                store.removeItem(SESSION_STORAGE_KEY);
+            }
+        }
+        return null;
+    };
+    /**
+     * Clear the stored session from BOTH web-storage slots. Used when a
+     * restore fails (user deleted / disabled between sessions) so the
+     * stale entry doesn't re-surface on the next reload.
+     */
+    const clearStoredSession = () => {
+        if (!options.sessionStorage)
+            return;
+        options.sessionStorage.local.removeItem(SESSION_STORAGE_KEY);
+        options.sessionStorage.session.removeItem(SESSION_STORAGE_KEY);
+    };
+    /**
+     * Wire up the session-change subscription for a service that provides
+     * session hooks. On each fire, re-saves the session uid to the
+     * appropriate web-storage slot (handling mode changes transparently —
+     * mode changes emit a session-change event, so the controller picks up
+     * the new mode without a dedicated migration path).
+     *
+     * Guarded by `sessionUnsubs.has(name)` so it's idempotent; only the
+     * first registration per service name installs the subscription.
+     */
+    const attachSessionSubscription = (name, hooks) => {
+        if (!options.sessionStorage)
+            return;
+        if (!hooks.session || sessionUnsubs.has(name))
+            return;
+        const sessionHooks = hooks.session;
+        const unsub = sessionHooks.subscribe(() => {
+            saveSession(sessionHooks);
+        });
+        sessionUnsubs.set(name, unsub);
+    };
+    // Wire up any services already in the registry at attach time
+    // (the case where the user called getAuth before enablePersistence).
+    if (sandbox instanceof SandboxImpl) {
+        for (const [name, hooks] of sandbox.getServiceRegistry()) {
+            attachServiceSubscription(name, hooks);
+            attachSessionSubscription(name, hooks);
+        }
+        // Install the late-registration hook so services that register
+        // AFTER this point (user calls enablePersistence then getAuth) are
+        // also subscribed and their changes flush promptly.
+        //
+        // Crucially: if there's a saved blob entry for this service name, we
+        // apply it now (late restore). Without this, a user who calls
+        // `enablePersistence` then `getAuth` would lose their saved users
+        // because `restore()` ran before auth was in the registry.
+        sandbox.setServiceRegistrationHook((name, hooks) => {
+            // Late restore: if the blob had data for this service and it
+            // wasn't applied during the initial restore pass (because the
+            // service wasn't registered then), apply it now. The user DB
+            // must be restored BEFORE the session restore below, so it
+            // resolves the uid to an existing record.
+            if (restoredServices !== null && name in restoredServices) {
+                try {
+                    hooks.restore(restoredServices[name]);
+                }
+                catch (e) {
+                    console.warn(`[sandbox/persistence] late-restore for service '${name}' failed:`, e);
+                }
+            }
+            // Late session restore: if a stored uid was found during attach
+            // but no service with session hooks was registered at that time
+            // (the common "reload" pattern where getAuth is called after
+            // enablePersistence), restore the session now that the service
+            // is available. The user DB restore above ran first, so the uid
+            // will resolve correctly.
+            if (pendingSessionUid !== null && hooks.session) {
+                tryRestoreSession(pendingSessionUid, hooks);
+            }
+            attachServiceSubscription(name, hooks);
+            attachSessionSubscription(name, hooks);
+            // Schedule a flush so the newly registered service's initial state
+            // is captured in the next blob — important for the early-registration
+            // case where the service had existing data before enablePersistence.
+            scheduleFlush();
+        });
+    }
+    // ─── Session restore ──────────────────────────────────────────────
+    //
+    // Restore the signed-in session AFTER the user DB / services have been
+    // restored (so the uid resolves to an existing record). We do this by
+    // reading the stored uid from web-storage and calling `session.restore`
+    // on each registered service that provides session hooks.
+    //
+    // The restore runs in TWO possible paths:
+    //   1. Early-registration (getAuth called BEFORE enablePersistence):
+    //      the auth service is already in the registry when attachPersistence
+    //      runs, so we can restore here synchronously.
+    //   2. Late-registration (getAuth called AFTER enablePersistence, the
+    //      common "reload" pattern): the registry is empty here, so we store
+    //      the pending uid in `pendingSessionUid` and restore when the auth
+    //      service registers via the late-registration hook below.
+    //
+    // Both paths call `tryRestoreSession` which handles the
+    // user-not-found/user-disabled throw + session clear idiom.
+    //
+    // The session restore must happen AFTER the user DB is restored (so
+    // `restoreSession(uid)` can look up the uid), which is why path 2 hangs
+    // off the late-registration hook (that hook already applies the user DB
+    // restore first — `hooks.restore(restoredServices[name])` runs before
+    // we attempt the session).
+    /** Uid read from web-storage that still needs a session restore.
+     *  Non-null only while a service with session hooks hasn't registered yet. */
+    let pendingSessionUid = null;
+    /** Attempt to restore the session for `uid` via `hooks.session`. On
+     *  success, the session fires `onAuthStateChanged`. On
+     *  user-not-found/user-disabled, clears the stored session and logs. */
+    const tryRestoreSession = (uid, hooks) => {
+        if (!hooks.session)
+            return;
+        try {
+            hooks.session.restore(uid);
+            // Session restored — clear the pending marker so we don't retry.
+            pendingSessionUid = null;
+        }
+        catch (e) {
+            // `restoreSession` throws `auth/user-not-found` or `auth/user-disabled`
+            // when the uid no longer exists or the account was disabled between
+            // sessions. Clear the stored session so this stale uid doesn't
+            // re-surface on the next reload. Log at warn level so developers
+            // see it in the console (matching serve's behavior for the same case).
+            console.warn(`[sandbox/persistence] session restore for uid '${uid}' failed — ` +
+                `clearing stored session:`, e);
+            clearStoredSession();
+            pendingSessionUid = null;
+        }
+    };
+    if (options.sessionStorage) {
+        const storedUid = loadStoredUid();
+        if (storedUid !== null) {
+            if (sandbox instanceof SandboxImpl) {
+                const registry = sandbox.getServiceRegistry();
+                let restored = false;
+                for (const [, hooks] of registry) {
+                    if (!hooks.session)
+                        continue;
+                    tryRestoreSession(storedUid, hooks);
+                    restored = true;
+                    break; // only one session provider (auth) expected
+                }
+                if (!restored) {
+                    // No service with session hooks in the registry yet — stash the uid
+                    // so the late-registration hook can pick it up when auth registers.
+                    pendingSessionUid = storedUid;
+                }
+            }
+        }
+    }
+    const unsubscribe = sandbox.onEvent((event) => {
+        if (isPersistableEvent(event))
+            scheduleFlush();
+    });
+    const beforeUnload = () => {
+        // Run synchronously on `beforeunload` — the page is leaving and we
+        // can't await an async backend write. Memory backend is sync; the
+        // IndexedDB backend won't finish in time, but kicking the request
+        // off gives it a chance to land in the IndexedDB write queue
+        // before tab close. Best-effort; the debounced auto-flush is the
+        // primary safety net.
+        void flushNow().catch(() => {
+            /* swallow — page is leaving */
+        });
+    };
+    if (typeof window !== 'undefined') {
+        window.addEventListener('beforeunload', beforeUnload);
+    }
+    return {
+        options,
+        flush: flushNow,
+        async clear() {
+            if (pendingFlush) {
+                clearTimeout(pendingFlush);
+                pendingFlush = null;
+            }
+            await backend.clear(options.key);
+            // Reset the diff baseline: the backend is now empty, so the next flush
+            // must treat every bucket as changed and re-persist the full in-memory
+            // state (otherwise untouched buckets stay suppressed and are lost).
+            lastHashes.clear();
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            if (pendingFlush) {
+                clearTimeout(pendingFlush);
+                pendingFlush = null;
+            }
+            unsubscribe();
+            // Detach service change-notification subscriptions.
+            for (const unsub of serviceUnsubs.values())
+                unsub();
+            serviceUnsubs.clear();
+            // Detach session-change subscriptions.
+            for (const unsub of sessionUnsubs.values())
+                unsub();
+            sessionUnsubs.clear();
+            // Detach the late-registration hook.
+            if (sandbox instanceof SandboxImpl) {
+                sandbox.setServiceRegistrationHook(null);
+            }
+            if (typeof window !== 'undefined') {
+                window.removeEventListener('beforeunload', beforeUnload);
+            }
+        },
+    };
+}
+/**
+ * Read the persisted blob for `key` and hydrate every document into
+ * the sandbox via the admin write surface, then restore any registered
+ * service state from the `services` map.
+ *
+ * Returns the raw `services` blob map (or `null` if no blob existed)
+ * so the controller can apply it to services that register AFTER this
+ * call returns (the late-registration case).
+ *
+ * Restore order: Firestore first, then services. Auth users need to
+ * land after Firestore is ready, not before — matches the natural
+ * initialization order.
+ *
+ * Unreadable blobs (parse failure, schema mismatch) are QUARANTINED,
+ * not destroyed: the raw blob moves to `<key>:corrupt` and the live
+ * key is cleared so the next flush starts fresh. Silent data loss is
+ * the worst failure mode for a persistence layer — parking the bytes
+ * under a side key keeps a serialization bug debuggable after the
+ * fact. Each new corrupt blob overwrites the previous quarantine
+ * record (one forensic slot per key is enough).
+ *
+ * Listeners attached to the sandbox before restore will see each
+ * hydrated doc as a fresh notification — intentional. The natural
+ * place to call `enablePersistence` is right after `initializeSandbox`,
+ * before any listeners attach, so this rarely matters in practice.
+ *
+ * Each service restore is wrapped in try/catch — a failing service
+ * restore must not abort Firestore restore (the core data is more
+ * critical). A warning is logged but the sandbox stays usable.
+ */
+async function restore(sandbox, backend, key, lastHashes) {
+    let ids;
+    try {
+        ids = await backend.listRecords(key);
+    }
+    catch (e) {
+        console.warn('[sandbox/persistence] backend list failed:', e);
+        return null;
+    }
+    if (ids.length === 0)
+        return null;
+    const records = [];
+    for (const id of ids) {
+        try {
+            const rec = await backend.getRecord(key, id);
+            if (rec !== null)
+                records.push([id, rec]);
+        }
+        catch (e) {
+            console.warn(`[sandbox/persistence] failed to read persisted record '${id}':`, e);
+        }
+    }
+    // C4 migrate-on-open: a legacy v2 record is the old single JSON blob (a
+    // string); v3 records are objects. Convert any v2 blob to v3 buckets in place,
+    // then delete the legacy record so the next open is pure v3.
+    const v3Records = [];
+    const legacyIds = [];
+    let migrated = null;
+    for (const [id, rec] of records) {
+        if (typeof rec === 'string') {
+            const m = migrateV2ToRecords(rec);
+            if (m) {
+                legacyIds.push(id);
+                migrated = m;
+            }
+            // a string that is not a recognizable v2 blob is unrecognized: skip it.
+        }
+        else {
+            v3Records.push([id, rec]);
+        }
+    }
+    if (migrated) {
+        try {
+            await backend.putRecords(key, migrated);
+            if (legacyIds.length > 0)
+                await backend.deleteRecords(key, legacyIds);
+        }
+        catch (e) {
+            console.warn('[sandbox/persistence] v2 migration write failed:', e);
+        }
+        for (const [id, rec] of migrated)
+            v3Records.push([id, rec]);
+    }
+    // Seed the flush hash state from the effective v3 records, so the first flush
+    // does not redundantly re-write the just-restored (or just-migrated) buckets.
+    for (const [id, rec] of v3Records)
+        lastHashes.set(id, hashRecord(rec));
+    const parsed = deserializeFromBuckets(v3Records);
+    // 1. Restore Firestore documents first. These are the structural data
+    //    that services (auth) may depend on being present.
+    for (const [path, data] of Object.entries(parsed.firestore)) {
+        sandbox.admin.setDocument(path, data);
+    }
+    // 2. Restore registered service state. Only services that are BOTH in
+    //    the blob AND currently registered are restored here. Services not
+    //    yet registered (late registration: enablePersistence before getAuth)
+    //    receive their data when they register via the hook installed by
+    //    attachPersistence. Each service restore is isolated so a broken
+    //    service doesn't kill the entire restore.
+    if (sandbox instanceof SandboxImpl) {
+        const registry = sandbox.getServiceRegistry();
+        for (const [name, data] of Object.entries(parsed.services)) {
+            const svc = registry.get(name);
+            if (!svc)
+                continue; // not yet registered; will be applied via late-restore hook
+            try {
+                svc.restore(data);
+            }
+            catch (e) {
+                console.warn(`[sandbox/persistence] service '${name}' restore failed — ` +
+                    `Firestore state is intact; auth users may need to be re-created:`, e);
+            }
+        }
+    }
+    // Return the services blob so the controller can apply it to services
+    // that register after this call (the late-registration case).
+    return parsed.services;
+}
+/**
+ * Which SandboxEvents move us toward a "dirty" state worth flushing?
+ *
+ * Writes (`kind: 'write'`) are the obvious ones. We also flush on
+ * `session_boundary` so a `reset()` snapshots the now-empty env — the
+ * persisted state then matches the in-memory state instead of holding
+ * stale pre-reset data.
+ *
+ * Read/listener events do not change state and don't trigger a flush.
+ */
+function isPersistableEvent(event) {
+    return event.kind === 'write' || event.kind === 'session_boundary';
+}
+//# sourceMappingURL=controller.js.map

package/dist/sandbox/persistence/controller.js.map

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

package/dist/sandbox/persistence/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Persistence module barrel — public surface re-exported from the
+ * package root. Backends are exposed so hosts that need a custom
+ * adapter (filesystem, remote KV) can compose against the same
+ * contract.
+ */
+export type { PersistenceBackend, SandboxPersistenceOptions, WebStorageLike } from './types.js';
+export { createIndexedDBBackend, createMemoryBackend, recordBackendOverBlob } from './backends.js';
+export { serializeToBuckets, deserializeFromBuckets, bundleRecords, parseBundle } from './chunk-format.js';
+export { PersistenceSchemaError, rehydrateDocValue } from './serialize.js';
+export type { PersistenceController } from './controller.js';
+export { attachPersistence } from './controller.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/sandbox/persistence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sandbox/persistence/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,YAAY,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAChG,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACnG,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3G,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,YAAY,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/sandbox/persistence/index.js

@@ -0,0 +1,5 @@
+export { createIndexedDBBackend, createMemoryBackend, recordBackendOverBlob } from './backends.js';
+export { serializeToBuckets, deserializeFromBuckets, bundleRecords, parseBundle } from './chunk-format.js';
+export { PersistenceSchemaError, rehydrateDocValue } from './serialize.js';
+export { attachPersistence } from './controller.js';
+//# sourceMappingURL=index.js.map

package/dist/sandbox/persistence/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/sandbox/persistence/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACnG,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3G,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC"}