@spooky-sync/core 0.0.1-canary.7 → 0.0.1-canary.71

package/src/services/database/local-migrator.ts

@@ -1,6 +1,6 @@
-import type { Surreal } from 'surrealdb';
-import { Logger, createLogger } from '../logger/index';
-import { LocalDatabaseService } from './local';
+import type { Logger} from '../logger/index';
+import { createLogger } from '../logger/index';
+import type { LocalDatabaseService } from './local';
 
 export interface SchemaRecord {
   hash: string;
@@ -23,8 +23,8 @@ export class LocalMigrator {
     logger: Logger
   ) {
     this.logger = logger.child({ service: 'LocalMigrator' });
-    logger?.child({ service: 'LocalMigrator' }) ??
-      createLogger('info').child({ service: 'LocalMigrator' });
+    void (logger?.child({ service: 'LocalMigrator' }) ??
+      createLogger('info').child({ service: 'LocalMigrator' }));
   }
 
   async provision(schemaSurql: string): Promise<void> {
@@ -34,7 +34,7 @@ export class LocalMigrator {
 
     if (await this.isSchemaUpToDate(hash)) {
       this.logger.info(
-        { Category: 'spooky-client::LocalMigrator::provision' },
+        { Category: 'sp00ky-client::LocalMigrator::provision' },
         '[Provisioning] Schema is up to date, skipping migration'
       );
       return;
@@ -43,10 +43,10 @@ export class LocalMigrator {
     await this.recreateDatabase(database);
 
     const systemSchema = `
-      DEFINE TABLE IF NOT EXISTS _spooky_stream_processor_state SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
-      DEFINE TABLE IF NOT EXISTS _spooky_query SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
-      DEFINE TABLE IF NOT EXISTS _spooky_schema SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
-      DEFINE TABLE IF NOT EXISTS _spooky_pending_mutations SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
+      DEFINE TABLE IF NOT EXISTS _00_stream_processor_state SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
+      DEFINE TABLE IF NOT EXISTS _00_query SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
+      DEFINE TABLE IF NOT EXISTS _00_schema SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
+      DEFINE TABLE IF NOT EXISTS _00_pending_mutations SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
     `;
     const fullSchema = schemaSurql + '\n' + systemSchema;
 
@@ -60,7 +60,7 @@ export class LocalMigrator {
       // SKIP INDEXES: WASM engine hangs on DEFINE INDEX (confirmed)
       if (cleanStatement.toUpperCase().startsWith('DEFINE INDEX')) {
         this.logger.warn(
-          { Category: 'spooky-client::LocalMigrator::provision' },
+          { Category: 'sp00ky-client::LocalMigrator::provision' },
           `[Provisioning] Skipping index definition (WASM hang avoidance): ${cleanStatement.substring(0, 50)}...`
         );
         continue;
@@ -68,17 +68,17 @@ export class LocalMigrator {
 
       try {
         this.logger.info(
-          { Category: 'spooky-client::LocalMigrator::provision' },
+          { Category: 'sp00ky-client::LocalMigrator::provision' },
           `[Provisioning] (${i + 1}/${statements.length}) Executing: ${statement.substring(0, 50)}...`
         );
         await this.localDb.query(statement);
         this.logger.info(
-          { Category: 'spooky-client::LocalMigrator::provision' },
+          { Category: 'sp00ky-client::LocalMigrator::provision' },
           `[Provisioning] (${i + 1}/${statements.length}) Done`
         );
       } catch (e) {
         this.logger.error(
-          { Category: 'spooky-client::LocalMigrator::provision' },
+          { Category: 'sp00ky-client::LocalMigrator::provision' },
           `[Provisioning] (${i + 1}/${statements.length}) Error executing statement: ${statement}`
         );
         throw e;
@@ -91,27 +91,27 @@ export class LocalMigrator {
   private async isSchemaUpToDate(hash: string): Promise<boolean> {
     try {
       const [lastSchemaRecord] = await this.localDb.query<any>(
-        `SELECT hash, created_at FROM ONLY _spooky_schema ORDER BY created_at DESC LIMIT 1;`
+        `SELECT hash, created_at FROM ONLY _00_schema ORDER BY created_at DESC LIMIT 1;`
       );
       return lastSchemaRecord?.hash === hash;
-    } catch (error) {
+    } catch (_error) {
       return false;
     }
   }
 
   private async recreateDatabase(database: string) {
     try {
-      await this.localDb.query(`DEFINE DATABASE _spooky_temp;`);
-    } catch (e) {
+      await this.localDb.query(`DEFINE DATABASE _00_temp;`);
+    } catch (_e) {
       // Ignore if exists
     }
 
     try {
       await this.localDb.query(`
-        USE DB _spooky_temp;
+        USE DB _00_temp;
         REMOVE DATABASE ${database};
       `);
-    } catch (e) {
+    } catch (_e) {
       // Ignore error if database doesn't exist
     }
 
@@ -196,7 +196,7 @@ export class LocalMigrator {
 
   private async createHashRecord(hash: string) {
     await this.localDb.query(
-      `UPSERT _spooky_schema SET hash = $hash, created_at = time::now() WHERE hash = $hash;`,
+      `UPSERT _00_schema SET hash = $hash, created_at = time::now() WHERE hash = $hash;`,
       { hash }
     );
   }

package/src/services/database/local.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { isLocalStoreOpenError } from './local';
+
+// `LocalDatabaseService.connect` recovers (drops the store + reconnects, falling
+// back to in-memory) only when the failure is the SurrealDB-WASM IndexedDB
+// open/transaction error — NOT for unrelated errors. This pins the message match
+// against the real error the engine throws so a recovery path doesn't silently
+// stop triggering (or start swallowing unrelated failures).
+describe('isLocalStoreOpenError', () => {
+  it('matches the real SurrealDB-WASM IndexedDB key-value store error', () => {
+    const real = new Error(
+      'There was a problem with the key-value store: There was a problem with a ' +
+        'transaction: An IndexedDB error occured: idb error'
+    );
+    expect(isLocalStoreOpenError(real)).toBe(true);
+  });
+
+  it('matches on the individual signals (indexeddb / idb error / key-value store)', () => {
+    expect(isLocalStoreOpenError(new Error('IndexedDB is not available'))).toBe(true);
+    expect(isLocalStoreOpenError(new Error('idb error'))).toBe(true);
+    expect(isLocalStoreOpenError(new Error('problem with the key-value store'))).toBe(true);
+    // Non-Error inputs are stringified.
+    expect(isLocalStoreOpenError('An IndexedDB error occured')).toBe(true);
+  });
+
+  it('does NOT match unrelated errors (so we never clear the store spuriously)', () => {
+    expect(isLocalStoreOpenError(new Error('WebSocket connection refused'))).toBe(false);
+    expect(isLocalStoreOpenError(new Error('Parse error: unexpected token'))).toBe(false);
+    expect(isLocalStoreOpenError(new Error('permission denied'))).toBe(false);
+    expect(isLocalStoreOpenError(null)).toBe(false);
+    expect(isLocalStoreOpenError(undefined)).toBe(false);
+  });
+});

package/src/services/database/local.ts

@@ -1,16 +1,17 @@
-import { applyDiagnostics, DateTime, Diagnostic, RecordId, Surreal } from 'surrealdb';
+import type { Diagnostic} from 'surrealdb';
+import { applyDiagnostics, DateTime, RecordId, Surreal } from 'surrealdb';
 import { createWasmWorkerEngines } from '@surrealdb/wasm';
-import { SpookyConfig } from '../../types';
-import { Logger } from '../logger/index';
+import type { Sp00kyConfig } from '../../types';
+import type { Logger } from '../logger/index';
 import { AbstractDatabaseService } from './database';
 import { createDatabaseEventSystem, DatabaseEventTypes } from './events/index';
-import { encodeRecordId, parseRecordIdString, surql } from '../../utils/index';
+import { encodeRecordId } from '../../utils/index';
 
 export class LocalDatabaseService extends AbstractDatabaseService {
-  private config: SpookyConfig<any>['database'];
+  private config: Sp00kyConfig<any>['database'];
   protected eventType = DatabaseEventTypes.LocalQuery;
 
-  constructor(config: SpookyConfig<any>['database'], logger: Logger) {
+  constructor(config: Sp00kyConfig<any>['database'], logger: Logger) {
     const events = createDatabaseEventSystem();
     super(
       new Surreal({
@@ -38,7 +39,7 @@ export class LocalDatabaseService extends AbstractDatabaseService {
                   type,
                   phase,
                   service: 'surrealdb:local',
-                  Category: 'spooky-client::LocalDatabaseService::diagnostics',
+                  Category: 'sp00ky-client::LocalDatabaseService::diagnostics',
                 },
                 `Local SurrealDB diagnostics captured ${type}:${phase}`
               );
@@ -52,48 +53,207 @@ export class LocalDatabaseService extends AbstractDatabaseService {
     this.config = config;
   }
 
-  getConfig(): SpookyConfig<any>['database'] {
+  getConfig(): Sp00kyConfig<any>['database'] {
     return this.config;
   }
 
   async connect(): Promise<void> {
     const { namespace, database } = this.getConfig();
+    const store = this.getConfig().store ?? 'memory';
+    const storeUrl = store === 'memory' ? 'mem://' : 'indxdb://sp00ky';
     this.logger.info(
-      { namespace, database, Category: 'spooky-client::LocalDatabaseService::connect' },
+      { namespace, database, storeUrl, Category: 'sp00ky-client::LocalDatabaseService::connect' },
       'Connecting to local database'
     );
+
+    this.registerUnloadClose();
+
     try {
-      const store = this.getConfig().store ?? 'memory';
-      const storeUrl = store === 'memory' ? 'mem://' : 'indxdb://spooky';
-      this.logger.debug(
-        { storeUrl, Category: 'spooky-client::LocalDatabaseService::connect' },
-        '[LocalDatabaseService] Calling client.connect'
+      await this.openStore(storeUrl, namespace, database);
+      this.logger.info(
+        { Category: 'sp00ky-client::LocalDatabaseService::connect' },
+        'Connected to local database'
       );
-      await this.client.connect(storeUrl, {});
-      this.logger.debug(
-        { namespace, database, Category: 'spooky-client::LocalDatabaseService::connect' },
-        '[LocalDatabaseService] client.connect returned. Calling client.use'
+      return;
+    } catch (err) {
+      // A persistent (IndexedDB) local store can fail to open if it was left
+      // corrupt or version-incompatible by a prior session/crash/engine bump.
+      // The local store is only a cache (everything re-syncs from the server),
+      // so recover by dropping it and reconnecting rather than bricking startup.
+      if (store === 'memory' || !isLocalStoreOpenError(err)) {
+        this.logger.error(
+          { err, Category: 'sp00ky-client::LocalDatabaseService::connect' },
+          'Failed to connect to local database'
+        );
+        throw err;
+      }
+      this.logger.warn(
+        { err, Category: 'sp00ky-client::LocalDatabaseService::connect' },
+        'Local IndexedDB store failed to open; retrying before clearing'
       );
+    }
 
-      await this.client.use({
-        namespace,
-        database,
-      });
-      this.logger.debug(
-        { Category: 'spooky-client::LocalDatabaseService::connect' },
-        '[LocalDatabaseService] client.use returned'
-      );
+    // Tier 1 — RETRY the SAME store WITHOUT dropping. The idb open/`use` failure
+    // is often transient (a not-yet-released handle from the previous page, or a
+    // first-open WAL-recovery race), not real corruption. Closing and reopening
+    // frequently succeeds — and crucially PRESERVES the cache, so a warm load
+    // stays warm. Dropping the store every time (the old behavior) silently wiped
+    // the cache on every reload, making warm loads as slow as cold ones.
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      try {
+        await this.client.close();
+      } catch {
+        /* ignore */
+      }
+      await delay(150 * attempt);
+      try {
+        await this.openStore(storeUrl, namespace, database);
+        this.logger.info(
+          { attempt, Category: 'sp00ky-client::LocalDatabaseService::connect' },
+          'Connected to local database on retry (cache preserved)'
+        );
+        return;
+      } catch (retryErr) {
+        this.logger.warn(
+          { err: retryErr, attempt, Category: 'sp00ky-client::LocalDatabaseService::connect' },
+          'Local store retry failed'
+        );
+      }
+    }
 
+    // Tier 2 — the store is genuinely unopenable; drop it and reconnect fresh.
+    // This loses the cache (re-syncs from the server), so it's the last resort
+    // before in-memory.
+    try {
+      await this.client.close();
+    } catch {
+      /* ignore — closing a half-open connection is best-effort */
+    }
+    await dropLocalIndexedDbStores(this.logger);
+
+    try {
+      await this.openStore(storeUrl, namespace, database);
       this.logger.info(
-        { Category: 'spooky-client::LocalDatabaseService::connect' },
-        'Connected to local database'
+        { Category: 'sp00ky-client::LocalDatabaseService::connect' },
+        'Reconnected to local database after clearing the corrupt store'
       );
-    } catch (err) {
+    } catch (retryErr) {
+      // Last resort: run in-memory so the app still loads. No local persistence
+      // this session; the freshly-dropped IndexedDB is recreated cleanly next
+      // load, and all data re-syncs from the server regardless.
       this.logger.error(
-        { err, Category: 'spooky-client::LocalDatabaseService::connect' },
-        'Failed to connect to local database'
+        { err: retryErr, Category: 'sp00ky-client::LocalDatabaseService::connect' },
+        'Local store still failing after clear; falling back to in-memory'
+      );
+      try {
+        await this.client.close();
+      } catch {
+        /* ignore */
+      }
+      await this.openStore('mem://', namespace, database);
+      this.logger.warn(
+        { Category: 'sp00ky-client::LocalDatabaseService::connect' },
+        'Connected to local database (in-memory fallback)'
       );
-      throw err;
     }
   }
+
+  private unloadCloseRegistered = false;
+
+  /**
+   * Close the local DB on page unload so the SurrealDB-WASM worker releases its
+   * IndexedDB connection cleanly. Without this, the previous page's connection
+   * lingers; the next load's `client.connect` opens the store but the first
+   * write transaction in `client.use` hits an "IndexedDB error" — which then
+   * (mis)triggered the corrupt-store recovery and WIPED the cache on every
+   * reload, making warm loads as slow as cold ones. `pagehide` is the reliable
+   * unload signal (fires on bfcache + normal navigation); `close()` is async but
+   * the WASM worker initiates the IndexedDB connection teardown synchronously.
+   */
+  private registerUnloadClose(): void {
+    if (this.unloadCloseRegistered || typeof window === 'undefined') return;
+    this.unloadCloseRegistered = true;
+    const close = () => {
+      try {
+        void this.client.close();
+      } catch {
+        /* best-effort */
+      }
+    };
+    window.addEventListener('pagehide', close);
+    window.addEventListener('beforeunload', close);
+  }
+
+  private async openStore(storeUrl: string, namespace: string, database: string): Promise<void> {
+    this.logger.debug(
+      { storeUrl, Category: 'sp00ky-client::LocalDatabaseService::connect' },
+      '[LocalDatabaseService] Calling client.connect'
+    );
+    await this.client.connect(storeUrl, {});
+    this.logger.debug(
+      { namespace, database, Category: 'sp00ky-client::LocalDatabaseService::connect' },
+      '[LocalDatabaseService] client.connect returned. Calling client.use'
+    );
+    await this.client.use({ namespace, database });
+    this.logger.debug(
+      { Category: 'sp00ky-client::LocalDatabaseService::connect' },
+      '[LocalDatabaseService] client.use returned'
+    );
+  }
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** True for the SurrealDB-WASM error raised when its IndexedDB-backed key-value
+ *  store can't be opened (corrupt / version-incompatible / blocked). Exported
+ *  for unit testing the error-message match. */
+export function isLocalStoreOpenError(err: unknown): boolean {
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  return (
+    msg.includes('indexeddb') ||
+    msg.includes('idb error') ||
+    msg.includes('key-value store')
+  );
+}
+
+/** Best-effort delete of this client's IndexedDB store(s). The persistent local
+ *  DB lives at `indxdb://sp00ky`; SurrealDB-WASM backs it with one or more
+ *  IndexedDB databases whose names include `sp00ky`. Resolves even on
+ *  error/blocked so startup can proceed. No-op outside a browser. */
+async function dropLocalIndexedDbStores(logger: Logger): Promise<void> {
+  if (typeof indexedDB === 'undefined') return;
+  const remove = (name: string): Promise<void> =>
+    new Promise((resolve) => {
+      try {
+        const req = indexedDB.deleteDatabase(name);
+        req.onsuccess = () => resolve();
+        req.onerror = () => resolve();
+        req.onblocked = () => resolve();
+      } catch {
+        resolve();
+      }
+    });
+  try {
+    let names: string[] = [];
+    if (typeof indexedDB.databases === 'function') {
+      const dbs = await indexedDB.databases();
+      names = dbs
+        .map((d) => d.name)
+        .filter((n): n is string => !!n && n.toLowerCase().includes('sp00ky'));
+    }
+    // Fall back to the known store name if enumeration is unavailable/empty.
+    if (names.length === 0) names = ['sp00ky'];
+    await Promise.all(names.map(remove));
+    logger.info(
+      { names, Category: 'sp00ky-client::LocalDatabaseService::connect' },
+      'Cleared local IndexedDB store(s)'
+    );
+  } catch (e) {
+    logger.warn(
+      { err: e, Category: 'sp00ky-client::LocalDatabaseService::connect' },
+      'Failed to enumerate/clear IndexedDB; proceeding anyway'
+    );
+  }
 }

package/src/services/database/remote.ts

@@ -1,20 +1,20 @@
+import type {
+  Diagnostic} from 'surrealdb';
 import {
   applyDiagnostics,
   createRemoteEngines,
-  Diagnostic,
   Surreal,
-  SurrealTransaction,
 } from 'surrealdb';
-import { SpookyConfig } from '../../types';
-import { Logger } from '../logger/index';
+import type { Sp00kyConfig } from '../../types';
+import type { Logger } from '../logger/index';
 import { AbstractDatabaseService } from './database';
 import { createDatabaseEventSystem, DatabaseEventTypes } from './events/index';
 
 export class RemoteDatabaseService extends AbstractDatabaseService {
-  private config: SpookyConfig<any>['database'];
+  private config: Sp00kyConfig<any>['database'];
   protected eventType = DatabaseEventTypes.RemoteQuery;
 
-  constructor(config: SpookyConfig<any>['database'], logger: Logger) {
+  constructor(config: Sp00kyConfig<any>['database'], logger: Logger) {
     const events = createDatabaseEventSystem();
     super(
       new Surreal({
@@ -29,7 +29,7 @@ export class RemoteDatabaseService extends AbstractDatabaseService {
                   type,
                   phase,
                   service: 'surrealdb:remote',
-                  Category: 'spooky-client::RemoteDatabaseService::diagnostics',
+                  Category: 'sp00ky-client::RemoteDatabaseService::diagnostics',
                 },
                 `Remote SurrealDB diagnostics captured ${type}:${phase}`
               );
@@ -43,7 +43,7 @@ export class RemoteDatabaseService extends AbstractDatabaseService {
     this.config = config;
   }
 
-  getConfig(): SpookyConfig<any>['database'] {
+  getConfig(): Sp00kyConfig<any>['database'] {
     return this.config;
   }
 
@@ -55,7 +55,7 @@ export class RemoteDatabaseService extends AbstractDatabaseService {
           endpoint,
           namespace,
           database,
-          Category: 'spooky-client::RemoteDatabaseService::connect',
+          Category: 'sp00ky-client::RemoteDatabaseService::connect',
         },
         'Connecting to remote database'
       );
@@ -68,25 +68,25 @@ export class RemoteDatabaseService extends AbstractDatabaseService {
 
         if (token) {
           this.logger.debug(
-            { Category: 'spooky-client::RemoteDatabaseService::connect' },
+            { Category: 'sp00ky-client::RemoteDatabaseService::connect' },
             'Authenticating with token'
           );
           await this.client.authenticate(token);
         }
         this.logger.info(
-          { Category: 'spooky-client::RemoteDatabaseService::connect' },
+          { Category: 'sp00ky-client::RemoteDatabaseService::connect' },
           'Connected to remote database'
         );
       } catch (err) {
         this.logger.error(
-          { err, Category: 'spooky-client::RemoteDatabaseService::connect' },
+          { err, Category: 'sp00ky-client::RemoteDatabaseService::connect' },
           'Failed to connect to remote database'
         );
         throw err;
       }
     } else {
       this.logger.warn(
-        { Category: 'spooky-client::RemoteDatabaseService::connect' },
+        { Category: 'sp00ky-client::RemoteDatabaseService::connect' },
         'No endpoint configured for remote database'
       );
     }

package/src/services/logger/index.ts

@@ -1,114 +1,19 @@
-import pino, { Level, type Logger as PinoLogger, type LoggerOptions } from 'pino';
-import { LoggerProvider, BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
-import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-proto';
-import { resourceFromAttributes } from '@opentelemetry/resources';
-import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import { createContextKey } from '@opentelemetry/api';
-
-const CATEGORY_KEY = createContextKey('Category');
+import pino, { type Level, type Logger as PinoLogger, type LoggerOptions } from 'pino';
+import type { PinoTransmit } from '../../types';
 
 export type Logger = PinoLogger;
 
-// Map pino levels to OTEL severity numbers
-// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#severity-fields
-function mapLevelToSeverityNumber(level: string): number {
-  switch (level) {
-    case 'trace':
-      return 1;
-    case 'debug':
-      return 5;
-    case 'info':
-      return 9;
-    case 'warn':
-      return 13;
-    case 'error':
-      return 17;
-    case 'fatal':
-      return 21;
-    default:
-      return 9;
-  }
-}
-
-export function createLogger(level: Level = 'info', otelEndpoint?: string): Logger {
+export function createLogger(level: Level = 'info', transmit?: PinoTransmit): Logger {
   const browserConfig: LoggerOptions['browser'] = {
     asObject: true,
     write: (o: any) => {
+      // oxlint-disable-next-line no-console
       console.log(JSON.stringify(o));
     },
   };
 
-  if (otelEndpoint) {
-    // Initialize OTEL LoggerProvider
-    const resource = resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: 'spooky-client',
-    });
-
-    const exporter = new OTLPLogExporter({
-      url: otelEndpoint,
-    });
-
-    // Pass processors in constructor as this SDK version requires it
-    const loggerProvider = new LoggerProvider({
-      resource,
-      processors: [new BatchLogRecordProcessor(exporter)],
-    });
-
-    const otelLogger: Record<string, ReturnType<typeof loggerProvider.getLogger>> = {};
-
-    const getOtelLogger = (category: string) => {
-      if (!otelLogger[category]) {
-        otelLogger[category] = loggerProvider.getLogger(category);
-      }
-      return otelLogger[category];
-    };
-
-    browserConfig.transmit = {
-      level: level,
-      send: (levelLabel: string, logEvent: any) => {
-        try {
-          const messages = [...logEvent.messages];
-          const severityNumber = mapLevelToSeverityNumber(levelLabel);
-
-          // Construct the message body
-          let body = '';
-          const msg = messages.pop();
-
-          if (typeof msg === 'string') {
-            body = msg;
-          } else if (msg) {
-            body = JSON.stringify(msg);
-          }
-
-          let category = 'spooky-client::unknown';
-
-          const attributes = {};
-          for (const msg of messages) {
-            if (typeof msg === 'object') {
-              if (msg.Category) {
-                category = msg.Category;
-                delete msg.Category;
-              }
-              Object.assign(attributes, msg);
-            }
-          }
-
-          // Emit to OTEL SDK
-          getOtelLogger(category).emit({
-            severityNumber: severityNumber,
-            severityText: levelLabel.toUpperCase(),
-            body: body,
-            attributes: {
-              ...logEvent.bindings[0],
-              ...attributes,
-            },
-            timestamp: new Date(logEvent.ts),
-          });
-        } catch (e) {
-          console.warn('Failed to transmit log to OTEL endpoint', e);
-        }
-      },
-    };
+  if (transmit) {
+    browserConfig.transmit = transmit;
   }
 
   return pino({

package/src/services/persistence/localstorage.ts

@@ -1,5 +1,5 @@
-import { Logger } from 'pino';
-import { PersistenceClient } from '../../types';
+import type { Logger } from 'pino';
+import type { PersistenceClient } from '../../types';
 
 export class LocalStoragePersistenceClient implements PersistenceClient {
   private logger: Logger;

package/src/services/persistence/resilient.ts

@@ -0,0 +1,41 @@
+import type { Logger } from 'pino';
+import type { PersistenceClient } from '../../types';
+
+export class ResilientPersistenceClient implements PersistenceClient {
+  private logger: Logger;
+
+  constructor(
+    private inner: PersistenceClient,
+    logger: Logger
+  ) {
+    this.logger = logger.child({ service: 'ResilientPersistenceClient' });
+  }
+
+  set<T>(key: string, value: T): Promise<void> {
+    return this.inner.set(key, value);
+  }
+
+  async get<T>(key: string): Promise<T | null> {
+    try {
+      return await this.inner.get<T>(key);
+    } catch (e) {
+      this.logger.warn(
+        { key, error: e, Category: 'sp00ky-client::ResilientPersistenceClient::get' },
+        'Persistence read failed, dropping key'
+      );
+      // Best-effort cleanup of the corrupt key; if removal also fails, the key
+      // just gets dropped again on the next failed read, so the failure is safe.
+      await this.inner.remove(key).catch((removeErr) => {
+        this.logger.debug(
+          { key, error: removeErr, Category: 'sp00ky-client::ResilientPersistenceClient::get' },
+          'Failed to drop corrupt persistence key'
+        );
+      });
+      return null;
+    }
+  }
+
+  remove(key: string): Promise<void> {
+    return this.inner.remove(key);
+  }
+}