@storystick/preview 0.0.0-stage → 0.2.0-rc.0

package/dist/runtime/schema-store.js

@@ -0,0 +1,667 @@
+/**
+ * ADR-131 Amendment 002 — iframe-side schema store.
+ *
+ * Caches the project schema fetched via the existing
+ * `/api/q/schemas/current` HTTP route. Two storage layers :
+ *
+ *   1. In-memory `inMemory` cell (sync read for the resolver hot path).
+ *   2. IndexedDB cache, keyed by
+ *      `(projectId, codeVersion, wireFormatVersion)`, TTL 5 min.
+ *
+ * Hot path (`peekSchema`) is synchronous — returns the in-memory record
+ * or `null`. The async `bootSchema` is idempotent : concurrent callers
+ * share a single in-flight promise ; tag mismatches (different
+ * projectId or codeVersion) invalidate the fast path and refetch ;
+ * TTL expiry triggers refetch ; network failures preserve the last
+ * good record (degraded mode).
+ *
+ * Race contracts :
+ *   - Provider mounts AFTER iframe runtime starts → bootSchema returns
+ *     `null` until `previewRuntime.httpClient` is set. Resolver retries
+ *     next rAF cycle. Cost : ~1-2 rAF (~32 ms).
+ *   - codeVersion drift mid-session → resolver detects mismatch, calls
+ *     `resetSchemaStore()` then `bootSchema()` ; null SnapshotItems for
+ *     the cycle, fresh fetch next.
+ *   - Concurrent callers → `inflight` promise serialises ; IDB + HTTP
+ *     caches absorb the rare double-fetch.
+ *
+ * TTL+codeVersion tradeoff (amendment §6.3) : a `storystick push`
+ * without code rebuild leaves the codeVersion unchanged. The iframe
+ * may serve a stale schema for up to 5 min in that edge case. The
+ * normal dev workflow (push → generate types → rebuild → bundle hash
+ * changes → codeVersion bumps) invalidates immediately.
+ */
+import { fetchCurrentSchema, isSchemaFormatUnsupportedError, } from '@storystick/client/adapter';
+import { StorystickError } from '@storystick/client';
+import { STORY_SCHEMA_FORMAT_VERSION } from '@storystick/types';
+import { previewRuntime } from './store.js';
+import { emitRuntimeError, emitRuntimeRecovered, } from './emit-runtime-error.js';
+const IDB_NAME = 'storystick-preview-schema';
+const IDB_STORE = 'schemas';
+const IDB_VERSION = 2;
+const TTL_MS = 5 * 60 * 1000;
+/**
+ * ADR-134 §9.T7 — retry orchestrator backoff array.
+ *
+ * Interpretation : every attempt is preceded by a delay from this array
+ * (attempt 1 by index 0, attempt 2 by index 1, …). attempt 1 runs at
+ * t=1s, attempt 5 at t=31s — matching the spec's "Attempt 1 fails
+ * (~1s elapsed)" / "Attempt 5 fails (~31s elapsed)" numbers exactly.
+ *
+ * The 1s grace before attempt 1 is intentional : it lets the IDB
+ * cache + boot-time `bootSchema()` resolve fast paths without a UI
+ * blip. If schema is already in cache when attempt 1 fires, bootSchema
+ * returns the cached record and the orchestrator resets without
+ * emitting anything.
+ */
+const RETRY_BACKOFF_INTERVALS_MS = [1_000, 2_000, 4_000, 8_000, 16_000];
+const RETRY_MAX_ATTEMPTS = RETRY_BACKOFF_INTERVALS_MS.length;
+let inMemory = null;
+let inflight = null;
+let lastFailure = null;
+const activeSchemaDiagnostics = new Set();
+/**
+ * Synchronous accessor — the resolver §D6.1 calls this every rAF cycle.
+ * Returns `null` until `bootSchema()` has resolved at least once with
+ * a non-null gateway response.
+ *
+ * Tag-aware (codex R3 P1) : returns the in-memory record only when its
+ * tags still match the current `(projectId, codeVersion)`. Without
+ * this gate, an identity Replace or codeVersion bump would leak the
+ * prior tenant's / prior bundle's schema to the resolver hot path
+ * until `bootSchema()` has had a chance to overwrite or null-out the
+ * slot. Returning `null` under stale tags is the same surface the
+ * resolver already handles (degraded mode, retry next rAF).
+ */
+export function peekSchema() {
+    if (inMemory === null)
+        return null;
+    const currentProjectId = previewRuntime.getState().identity?.projectId ?? null;
+    const currentCodeVersion = readCodeVersionFromWindow();
+    if (inMemory.projectId !== currentProjectId ||
+        inMemory.codeVersion !== currentCodeVersion) {
+        return null;
+    }
+    return inMemory;
+}
+/**
+ * Boot or refresh the iframe-side schema cache. Returns the in-memory
+ * record (possibly stale, if a refetch failed) OR `null` if no record
+ * has ever been established AND the current attempt cannot proceed
+ * (missing httpClient / identity / codeVersion / network failure).
+ *
+ * Idempotent : concurrent callers await the same `inflight` promise.
+ *
+ * Tag-stability invariant (codex R1 fix) : we re-read the current
+ * projectId + codeVersion AFTER each await and discard the result
+ * if the tags drifted. Without this, an identity Replace mid-flight
+ * could install a wrong-tenant schema OR keep a stale prior record
+ * referenced under the wrong tags.
+ */
+export async function bootSchema() {
+    const initialState = previewRuntime.getState();
+    const projectIdAtEntry = initialState.identity?.projectId ?? null;
+    const codeVersionAtEntry = readCodeVersionFromWindow();
+    const httpClientAtEntry = initialState.httpClient;
+    // Fast path : in-memory record still matches the current tags AND
+    // is within TTL. Tags-check is critical — without it a stale
+    // schema persists across projectId / codeVersion changes (codex R4).
+    if (inMemory !== null &&
+        inMemory.projectId === projectIdAtEntry &&
+        inMemory.codeVersion === codeVersionAtEntry &&
+        !_isStale(inMemory)) {
+        _recoverSchemaDiagnostics();
+        return inMemory;
+    }
+    // Codex R3 P1 — preconditions checked BEFORE entering the `inflight`
+    // slot. Otherwise an early-return IIFE that runs without awaiting
+    // would (a) sync-execute finally → clear `inflight`, then (b) get
+    // the resolved promise re-assigned into `inflight` after the IIFE
+    // returns, leaving `inflight` permanently pinned to a null-resolved
+    // promise. Subsequent re-fires (e.g. from boot.ts's httpClient
+    // arrival subscription) would short-circuit to the latched null.
+    if (httpClientAtEntry === null) {
+        return _onlyIfTagsMatch(projectIdAtEntry, codeVersionAtEntry);
+    }
+    if (projectIdAtEntry === null)
+        return null;
+    if (codeVersionAtEntry === null)
+        return null;
+    if (lastFailure?.retryable === false &&
+        lastFailure.projectId === projectIdAtEntry &&
+        lastFailure.codeVersion === codeVersionAtEntry &&
+        lastFailure.httpClient === httpClientAtEntry) {
+        return null;
+    }
+    if (inflight !== null)
+        return inflight;
+    const bypassCache = lastFailure?.kind === 'incompatible' &&
+        lastFailure.projectId === projectIdAtEntry &&
+        lastFailure.codeVersion === codeVersionAtEntry;
+    inflight = (async () => {
+        try {
+            const cached = bypassCache
+                ? null
+                : await _loadFromIdb(projectIdAtEntry, codeVersionAtEntry);
+            if (cached !== null && !_isStale(cached)) {
+                // Re-read tags before install — async windows let identity
+                // Replace and codeVersion drift slip in.
+                if (!_tagsStable(projectIdAtEntry, codeVersionAtEntry)) {
+                    return _onlyIfTagsMatch(projectIdAtEntry, codeVersionAtEntry);
+                }
+                inMemory = cached;
+                lastFailure = null;
+                _recoverSchemaDiagnostics();
+                return cached;
+            }
+            const row = await fetchCurrentSchema(httpClientAtEntry);
+            if (row === null) {
+                // Backend returned null — no schema pushed yet for tenant.
+                // Stay in degraded mode ; do NOT overwrite a prior good record.
+                lastFailure = {
+                    kind: 'transient',
+                    code: 'storystick/SCHEMA_NOT_AVAILABLE',
+                    message: 'The schema endpoint returned no schema for this project.',
+                    retryable: true,
+                    projectId: projectIdAtEntry,
+                    codeVersion: codeVersionAtEntry,
+                    httpClient: httpClientAtEntry,
+                };
+                return _onlyIfTagsMatch(projectIdAtEntry, codeVersionAtEntry);
+            }
+            // Re-read tags before install — same race window as the IDB
+            // branch above.
+            if (!_tagsStable(projectIdAtEntry, codeVersionAtEntry)) {
+                return _onlyIfTagsMatch(projectIdAtEntry, codeVersionAtEntry);
+            }
+            const record = {
+                projectId: projectIdAtEntry,
+                codeVersion: codeVersionAtEntry,
+                schema: row,
+                fetchedAt: Date.now(),
+            };
+            // Persist + install. Persist failure is logged-silent (degraded
+            // IDB) ; install still happens — UNLESS tags drifted during the
+            // IDB save await (codex R2 P1 — close the hole). The IDB row is
+            // already written under the entry-tags composite key, which is
+            // harmless ; we just don't install it into the in-memory slot
+            // under stale tags.
+            await _saveToIdb(record);
+            if (!_tagsStable(projectIdAtEntry, codeVersionAtEntry)) {
+                return _onlyIfTagsMatch(projectIdAtEntry, codeVersionAtEntry);
+            }
+            inMemory = record;
+            lastFailure = null;
+            _recoverSchemaDiagnostics();
+            return record;
+        }
+        catch (error) {
+            lastFailure = _classifyFailure(error, {
+                projectId: projectIdAtEntry,
+                codeVersion: codeVersionAtEntry,
+                httpClient: httpClientAtEntry,
+            });
+            if (lastFailure.kind === 'incompatible') {
+                inMemory = null;
+                return null;
+            }
+            // Network / auth / IDB error → fall back to stale cache only if
+            // its tags still match the entry tags. A failed refetch must not
+            // resurrect a record under tags that no longer apply.
+            return _onlyIfTagsMatch(projectIdAtEntry, codeVersionAtEntry);
+        }
+        finally {
+            inflight = null;
+        }
+    })();
+    return inflight;
+}
+function _tagsStable(projectId, codeVersion) {
+    const currentProjectId = previewRuntime.getState().identity?.projectId ?? null;
+    const currentCodeVersion = readCodeVersionFromWindow();
+    return projectId === currentProjectId && codeVersion === currentCodeVersion;
+}
+function _onlyIfTagsMatch(projectId, codeVersion) {
+    // Return the current in-memory record only if it matches the entry
+    // tags AND the current tags. Drops the record if a drift happened
+    // mid-flight — the caller will retry under the new tags.
+    if (inMemory === null)
+        return null;
+    if (inMemory.projectId !== projectId || inMemory.codeVersion !== codeVersion) {
+        return null;
+    }
+    if (!_tagsStable(projectId, codeVersion))
+        return null;
+    return inMemory;
+}
+/**
+ * Drop the in-memory record. Used by the resolver when it detects a
+ * codeVersion drift — the next `bootSchema()` refetches against the
+ * new tag. Does NOT clear IDB ; the IDB entry under the new tag is
+ * separate and the old tag's row is harmless until it ages out.
+ */
+export function invalidateSchema() {
+    inMemory = null;
+    lastFailure = null;
+}
+/**
+ * Test hook — clears in-memory, in-flight, AND IDB. Never invoked in
+ * production code.
+ */
+export async function _resetSchemaStoreForTestsOnly() {
+    inMemory = null;
+    inflight = null;
+    lastFailure = null;
+    activeSchemaDiagnostics.clear();
+    _resetRetryCycle();
+    await _clearIdb();
+}
+/**
+ * Test hook — expose the current in-flight promise so tests can assert
+ * concurrent callers share it. Returns null when no fetch is pending.
+ */
+export function _peekInflightForTestsOnly() {
+    return inflight;
+}
+export function _peekSchemaFailureForTestsOnly() {
+    return lastFailure;
+}
+function _classifyFailure(error, tags) {
+    if (isSchemaFormatUnsupportedError(error)) {
+        return {
+            kind: 'incompatible',
+            code: error.code,
+            message: error.message,
+            retryable: false,
+            ...tags,
+        };
+    }
+    const code = error instanceof StorystickError && typeof error.code === 'string'
+        ? error.code
+        : error instanceof Error
+            ? error.name
+            : 'storystick/UNKNOWN_SCHEMA_DELIVERY_FAILURE';
+    const message = error instanceof Error
+        ? error.message
+        : 'Schema delivery failed with an unknown error.';
+    return {
+        kind: 'transient',
+        code,
+        message,
+        retryable: error instanceof StorystickError ? error.retryable !== false : true,
+        ...tags,
+    };
+}
+function _failureMessage(failure) {
+    if (failure === null)
+        return 'Schema delivery returned no usable result.';
+    return `${failure.code}: ${failure.message}`;
+}
+function _emitSchemaDiagnosticSafe(input) {
+    try {
+        emitRuntimeError(input);
+        activeSchemaDiagnostics.add(input.code);
+    }
+    catch {
+        /* Diagnostics must not interrupt schema delivery. */
+    }
+}
+function _recoverSchemaDiagnostics() {
+    for (const code of activeSchemaDiagnostics) {
+        try {
+            emitRuntimeRecovered(code);
+        }
+        catch {
+            /* Diagnostics must not interrupt schema delivery. */
+        }
+    }
+    activeSchemaDiagnostics.clear();
+}
+// ─────────────────────────────────────────────
+// ADR-134 §9.T7 — retry orchestrator
+// ─────────────────────────────────────────────
+//
+// A bounded retry loop on top of `bootSchema`. Stages two visible
+// signals via `emitRuntimeError` :
+//
+//   - attempt 1 fail → `runtime.schema_sync_delayed` (severity:warning)
+//   - attempts 2-4 silent
+//   - attempt 5 fail → `runtime.schema_delivery_failed` (severity:error)
+//     then stops retrying for the current cycle.
+//
+// "Cycle" = one (httpClient, projectId) tuple. When either changes
+// (token refresh, project switch) the counter resets to zero and a
+// fresh attempt cycle begins. boot.ts wires the orchestrator on once
+// per runtime boot ; teardown clears all timers.
+//
+// All state below is module-scoped + singleton ; this module is
+// already a singleton against `previewRuntime` so adding a parallel
+// singleton for the retry counter is consistent.
+let retryTimer = null;
+let retryAttempt = 0;
+let retryWarningEmitted = false;
+let retryErrorEmitted = false;
+let retryOrchestratorActive = false;
+let retryUnsubscribe = null;
+/**
+ * Cycle generation counter. Incremented every time the cycle resets
+ * (identity change, teardown). Each `_runAttempt` captures the
+ * generation at entry and checks it AFTER the bootSchema await ; a
+ * stale attempt that survived a reset bails before emitting
+ * envelopes or scheduling the next attempt (codex review P1 fix).
+ *
+ * Without this, a slow bootSchema fetch under a soon-to-be-stale
+ * (httpClient, projectId) tuple could land its `null` result after
+ * a token-refresh-driven cycle reset, then incorrectly emit
+ * `runtime.schema_delivery_failed` against the NEW identity, and
+ * even schedule a new attempt that the new cycle's own scheduler
+ * doesn't know about (leaking timer + double-scheduling).
+ */
+let retryCycleGeneration = 0;
+function _emitRetryWarningSafe() {
+    _emitSchemaDiagnosticSafe({
+        code: 'runtime.schema_sync_delayed',
+        message: `Loading schema is taking longer than usual. ${_failureMessage(lastFailure)}`,
+        severity: 'warning',
+        retryable: true,
+        persistence: 'transient',
+    });
+}
+function _emitRetryErrorSafe() {
+    _emitSchemaDiagnosticSafe({
+        code: 'runtime.schema_delivery_failed',
+        message: `Schema delivery failed after 5 attempts. ${_failureMessage(lastFailure)}`,
+        severity: 'error',
+        retryable: lastFailure?.retryable ?? true,
+        persistence: 'until-recovered',
+    });
+}
+function _emitSchemaUpgradeRequiredSafe() {
+    _emitSchemaDiagnosticSafe({
+        code: 'runtime.schema_upgrade_required',
+        message: 'Schema upgrade required. Content remains available without field-level overlays. ' +
+            _failureMessage(lastFailure),
+        severity: 'warning',
+        retryable: false,
+        persistence: 'until-recovered',
+    });
+}
+function _resetRetryCycle() {
+    if (retryTimer !== null) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+    }
+    retryAttempt = 0;
+    retryWarningEmitted = false;
+    retryErrorEmitted = false;
+    // Bump the generation so any in-flight `_runAttempt` that survived
+    // the await will see the mismatch and bail (codex review P1 fix).
+    retryCycleGeneration += 1;
+}
+function _scheduleAttempt(attempt, generation) {
+    if (attempt > RETRY_MAX_ATTEMPTS)
+        return;
+    const delayMs = RETRY_BACKOFF_INTERVALS_MS[attempt - 1];
+    if (delayMs === undefined)
+        return;
+    retryTimer = setTimeout(() => {
+        retryTimer = null;
+        // Cross-cycle late-fire guard : the scheduling cycle may have been
+        // reset by an identity change OR by teardown after the timer was
+        // queued but before it fired. Bail before consuming bootSchema in
+        // the wrong cycle's context.
+        if (generation !== retryCycleGeneration)
+            return;
+        void _runAttempt(attempt, generation);
+    }, delayMs);
+}
+async function _runAttempt(attempt, generation) {
+    retryAttempt = attempt;
+    // Re-check preconditions. They might have lapsed (httpClient torn
+    // down, identity cleared) between scheduling and firing — in that
+    // case we stay silent and the runtime subscriber below will reschedule
+    // once preconditions are met again.
+    const state = previewRuntime.getState();
+    if (state.httpClient === null)
+        return;
+    if (state.identity?.projectId == null)
+        return;
+    const result = await bootSchema();
+    // Post-await cycle check (codex review P1 fix) : if the cycle was
+    // reset DURING the await (token refresh, project switch, teardown)
+    // this attempt is now stale. Bail without emitting envelopes or
+    // scheduling the next attempt — the new cycle owns its own
+    // scheduling and any signals it needs to emit.
+    if (generation !== retryCycleGeneration)
+        return;
+    if (result !== null) {
+        // Success — schema is loaded. Reset the cycle for any future
+        // identity changes that might trigger a fresh attempt cycle.
+        _resetRetryCycle();
+        return;
+    }
+    if (lastFailure?.kind === 'incompatible') {
+        if (!retryWarningEmitted) {
+            retryWarningEmitted = true;
+            _emitSchemaUpgradeRequiredSafe();
+        }
+        return;
+    }
+    if (lastFailure !== null && !lastFailure.retryable) {
+        if (!retryErrorEmitted) {
+            retryErrorEmitted = true;
+            _emitRetryErrorSafe();
+        }
+        return;
+    }
+    // Failure. Stage the two signals per §9.T7.
+    if (attempt === 1 && !retryWarningEmitted) {
+        retryWarningEmitted = true;
+        _emitRetryWarningSafe();
+    }
+    if (attempt >= RETRY_MAX_ATTEMPTS) {
+        if (!retryErrorEmitted) {
+            retryErrorEmitted = true;
+            _emitRetryErrorSafe();
+        }
+        // Stop retrying — counter stays at MAX_ATTEMPTS so the next
+        // identity change resets cleanly.
+        return;
+    }
+    _scheduleAttempt(attempt + 1, generation);
+}
+/**
+ * Start the schema-retry orchestrator. Idempotent — calling a second
+ * time before stop returns the same teardown. Wired by `boot.ts` once
+ * per runtime boot.
+ *
+ * Behaviour per §9.T7 :
+ *   - Subscribes to `previewRuntime` ; resets the cycle whenever
+ *     `httpClient` or `identity.projectId` changes ; kicks off attempt
+ *     1 (after the 1s grace delay) when both preconditions are met.
+ *   - If preconditions are ALREADY met at start, schedules attempt 1
+ *     immediately via the same delay path (no fast-track).
+ *   - On success at any attempt, resets the counter ; on attempt 5
+ *     failure, emits the error envelope and stops retrying for the
+ *     current cycle (waiting for the next identity change to rearm).
+ */
+export function startSchemaRetryLoop() {
+    if (retryOrchestratorActive)
+        return stopSchemaRetryLoop;
+    retryOrchestratorActive = true;
+    const initialState = previewRuntime.getState();
+    let prevHttpClient = initialState.httpClient;
+    let prevProjectId = initialState.identity?.projectId ?? null;
+    retryUnsubscribe = previewRuntime.subscribe(() => {
+        const s = previewRuntime.getState();
+        const nextHttpClient = s.httpClient;
+        const nextProjectId = s.identity?.projectId ?? null;
+        const httpClientChanged = nextHttpClient !== prevHttpClient;
+        const projectIdChanged = nextProjectId !== prevProjectId;
+        if (!httpClientChanged && !projectIdChanged)
+            return;
+        if (projectIdChanged) {
+            // Drop the in-memory record proactively — peekSchema is now
+            // tag-aware so this is belt-and-suspenders, but explicit
+            // invalidation also resets the IDB tag-stability fast path.
+            invalidateSchema();
+        }
+        _resetRetryCycle();
+        prevHttpClient = nextHttpClient;
+        prevProjectId = nextProjectId;
+        // Rearm if preconditions are now met. Stamp the schedule with the
+        // CURRENT generation (post-reset, post-bump) so any in-flight
+        // attempt from the prior cycle bails on the post-await check.
+        if (nextHttpClient !== null && nextProjectId !== null) {
+            _scheduleAttempt(1, retryCycleGeneration);
+        }
+    });
+    // Initial kick — schedule attempt 1 if preconditions are already met.
+    if (prevHttpClient !== null && prevProjectId !== null) {
+        _scheduleAttempt(1, retryCycleGeneration);
+    }
+    return stopSchemaRetryLoop;
+}
+export function stopSchemaRetryLoop() {
+    if (!retryOrchestratorActive)
+        return;
+    retryOrchestratorActive = false;
+    retryUnsubscribe?.();
+    retryUnsubscribe = null;
+    _resetRetryCycle();
+}
+/** Test hook — read the current attempt count. */
+export function _peekRetryAttemptForTestsOnly() {
+    return retryAttempt;
+}
+/**
+ * Test hook — directly install an in-memory schema record. Used by
+ * orchestrator tests that need `bootSchema()` to return a record via
+ * the fast path without going through the IDB+transport stack (which
+ * doesn't compose with `vi.useFakeTimers`).
+ */
+export function _setInMemoryForTestsOnly(record) {
+    inMemory = record;
+}
+// ─────────────────────────────────────────────
+// Internals
+// ─────────────────────────────────────────────
+function readCodeVersionFromWindow() {
+    if (typeof window === 'undefined')
+        return null;
+    const raw = window
+        .__STORYSTICK_CODE_VERSION__;
+    return typeof raw === 'string' && raw.length > 0 ? raw : null;
+}
+function _isStale(record) {
+    return Date.now() - record.fetchedAt > TTL_MS;
+}
+function _keyFor(projectId, codeVersion) {
+    return `${projectId}/${codeVersion}/schema-v${STORY_SCHEMA_FORMAT_VERSION}`;
+}
+function _isCachedSchemaRecord(value, projectId, codeVersion) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    const schema = record.schema;
+    return record.projectId === projectId &&
+        record.codeVersion === codeVersion &&
+        typeof record.fetchedAt === 'number' &&
+        Number.isFinite(record.fetchedAt) &&
+        schema !== null &&
+        typeof schema === 'object' &&
+        !Array.isArray(schema) &&
+        typeof schema.projectId === 'string' &&
+        schema.projectId.length > 0 &&
+        schema.formatVersion === STORY_SCHEMA_FORMAT_VERSION &&
+        typeof schema.version === 'string' &&
+        schema.version.length > 0 &&
+        typeof schema.storyCount === 'number' &&
+        Number.isInteger(schema.storyCount) &&
+        typeof schema.pushedAt === 'number' &&
+        Number.isFinite(schema.pushedAt);
+}
+// ── IndexedDB — minimal wrapper. Separate DB from Layer1Cache so each
+//    has its own lifecycle (amendment §8.8). ──────────────────────────
+function _openDb() {
+    if (typeof indexedDB === 'undefined') {
+        return Promise.resolve(null);
+    }
+    return new Promise((resolve) => {
+        let req;
+        try {
+            req = indexedDB.open(IDB_NAME, IDB_VERSION);
+        }
+        catch {
+            resolve(null);
+            return;
+        }
+        req.onupgradeneeded = () => {
+            const db = req.result;
+            if (db.objectStoreNames.contains(IDB_STORE)) {
+                db.deleteObjectStore(IDB_STORE);
+            }
+            db.createObjectStore(IDB_STORE);
+        };
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => resolve(null);
+        req.onblocked = () => resolve(null);
+    });
+}
+async function _loadFromIdb(projectId, codeVersion) {
+    const db = await _openDb();
+    if (db === null)
+        return null;
+    try {
+        return await new Promise((resolve) => {
+            const tx = db.transaction(IDB_STORE, 'readonly');
+            const store = tx.objectStore(IDB_STORE);
+            const req = store.get(_keyFor(projectId, codeVersion));
+            req.onsuccess = () => {
+                const value = req.result;
+                resolve(_isCachedSchemaRecord(value, projectId, codeVersion) ? value : null);
+            };
+            req.onerror = () => resolve(null);
+        });
+    }
+    finally {
+        db.close();
+    }
+}
+async function _saveToIdb(record) {
+    const db = await _openDb();
+    if (db === null)
+        return;
+    try {
+        await new Promise((resolve) => {
+            const tx = db.transaction(IDB_STORE, 'readwrite');
+            const store = tx.objectStore(IDB_STORE);
+            store.put(record, _keyFor(record.projectId, record.codeVersion));
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => resolve();
+            tx.onabort = () => resolve();
+        });
+    }
+    finally {
+        db.close();
+    }
+}
+async function _clearIdb() {
+    const db = await _openDb();
+    if (db === null)
+        return;
+    try {
+        await new Promise((resolve) => {
+            const tx = db.transaction(IDB_STORE, 'readwrite');
+            const store = tx.objectStore(IDB_STORE);
+            store.clear();
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => resolve();
+            tx.onabort = () => resolve();
+        });
+    }
+    finally {
+        db.close();
+    }
+}