@spooky-sync/core 0.0.1-canary.13 → 0.0.1-canary.130

package/src/services/database/sqlite-worker.ts

@@ -0,0 +1,116 @@
+/// <reference lib="webworker" />
+/**
+ * Dedicated Web Worker that owns the SQLite-WASM handle. All DB access is
+ * funnelled through here (the main thread never touches the wasm module), which
+ * is also what the OPFS VFS requires — file access must happen off the main
+ * thread. Persistence uses the **OPFS SAHPool VFS**: durable, and (unlike the
+ * classic OPFS VFS) it does NOT require COOP/COEP cross-origin isolation
+ * headers, so host apps embedding the client need no server changes. Falls back
+ * to an in-memory DB when OPFS is unavailable.
+ *
+ * Message protocol (request/response keyed by `id`):
+ *   { id, type: 'open',  payload: { dbName, useOpfs } }
+ *   { id, type: 'exec',  payload: { sql, bind } }  -> { id, ok, rows }
+ *   { id, type: 'run',   payload: { sql, bind } }  -> { id, ok }
+ *   { id, type: 'batch', payload: [{ sql, bind }] } (atomic BEGIN/COMMIT)
+ *   { id, type: 'close' }
+ */
+import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
+
+interface Stmt {
+  sql: string;
+  bind?: unknown[];
+}
+
+let db: {
+  exec: (opts: { sql: string; bind?: unknown[]; rowMode?: string; returnValue?: string }) => unknown;
+  close: () => void;
+} | null = null;
+
+async function open(dbName: string, useOpfs: boolean): Promise<{ persisted: boolean }> {
+  const sqlite3: any = await sqlite3InitModule();
+  let persisted = false;
+  if (useOpfs && sqlite3.installOpfsSAHPoolVfs) {
+    try {
+      const pool = await sqlite3.installOpfsSAHPoolVfs({ name: `sp00ky-${dbName}` });
+      db = new pool.OpfsSAHPoolDb(`/${dbName}.sqlite3`);
+      persisted = true;
+    } catch {
+      // fall through to in-memory
+    }
+  }
+  if (!db) db = new sqlite3.oo1.DB(':memory:', 'c');
+  // Retry (rather than instantly failing with SQLITE_BUSY=5) if a lock is held.
+  // Combined with the engine's single-flight op queue, overlap is avoided.
+  // `cache_size` is negated → KiB (here 32 MiB) so SQLite's page cache can't
+  // grow unbounded and starve a wasm-heavy renderer.
+  try {
+    db!.exec({ sql: 'PRAGMA busy_timeout = 5000; PRAGMA cache_size = -32000;' });
+  } catch {
+    /* pragma best-effort */
+  }
+  return { persisted };
+}
+
+function exec(sql: string, bind?: unknown[]): unknown[] {
+  if (!db) throw new Error('sqlite: DB not open');
+  return db.exec({ sql, bind, rowMode: 'object', returnValue: 'resultRows' }) as unknown[];
+}
+
+function run(sql: string, bind?: unknown[]): void {
+  if (!db) throw new Error('sqlite: DB not open');
+  db.exec({ sql, bind });
+}
+
+function batch(stmts: Stmt[]): void {
+  if (!db) throw new Error('sqlite: DB not open');
+  db.exec({ sql: 'BEGIN' });
+  try {
+    for (const s of stmts) db.exec({ sql: s.sql, bind: s.bind });
+    db.exec({ sql: 'COMMIT' });
+  } catch (e) {
+    try {
+      db.exec({ sql: 'ROLLBACK' });
+    } catch {
+      /* ignore */
+    }
+    throw e;
+  }
+}
+
+self.onmessage = async (ev: MessageEvent) => {
+  const { id, type, payload } = ev.data ?? {};
+  try {
+    let result: unknown;
+    switch (type) {
+      case 'open':
+        result = await open(payload.dbName, payload.useOpfs);
+        break;
+      case 'exec':
+        result = { rows: exec(payload.sql, payload.bind) };
+        break;
+      case 'run':
+        run(payload.sql, payload.bind);
+        result = {};
+        break;
+      case 'batch':
+        batch(payload as Stmt[]);
+        result = {};
+        break;
+      case 'close':
+        db?.close();
+        db = null;
+        result = {};
+        break;
+      default:
+        throw new Error(`sqlite worker: unknown message ${type}`);
+    }
+    (self as unknown as Worker).postMessage({ id, ok: true, ...(result as object) });
+  } catch (err) {
+    (self as unknown as Worker).postMessage({
+      id,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+    });
+  }
+};

package/src/services/database/surql-translate.ts

@@ -0,0 +1,291 @@
+import type { WhereNode } from '@spooky-sync/query-builder';
+import type { OrderBy, Row } from './cache-engine';
+import { stableKey } from './relation-resolver';
+
+/**
+ * Translate the BOUNDED set of SurrealQL statements the client actually emits
+ * into engine-neutral operations the SQLite backend executes. This is NOT a
+ * general SurrealQL parser — it recognizes exactly the shapes produced by the
+ * `surql` helper and the handful of literal queries in the codebase. Anything
+ * unrecognized throws (with the offending SQL) so gaps surface loudly during a
+ * trial rather than silently returning wrong data.
+ *
+ * The arbitrary user SELECT (`config.surql`, with nested `.related()`
+ * subqueries) is intentionally NOT handled here — it flows through
+ * `engine.select(plan)` instead, so the translator never faces an unbounded
+ * query shape.
+ */
+
+export type SqlOp =
+  | { kind: 'getById'; id: unknown; select?: string[]; value?: string }
+  | { kind: 'selectByIds'; ids: unknown[]; select?: string[]; orderBy?: OrderBy; value?: string }
+  | { kind: 'selectTable'; table: string; where?: WhereNode[]; orderBy?: OrderBy; select?: string[]; value?: string }
+  | { kind: 'upsert'; id: unknown; data: Row; mode: 'replace' | 'merge' }
+  | { kind: 'updateSet'; id: unknown; sets: SetClause[]; returnNone: boolean }
+  | { kind: 'delete'; id: unknown }
+  | { kind: 'deleteAll'; table: string }
+  | { kind: 'let'; var: string; inner: SqlOp }
+  | { kind: 'return'; entries: { key: string; var: string }[] }
+  | { kind: 'noop' };
+
+export interface SetClause {
+  path: string;
+  op: '=' | '+=' | '-=';
+  value: unknown;
+}
+
+export interface TranslatedQuery {
+  /** True for a `BEGIN TRANSACTION … COMMIT` block — the engine prepends a
+   *  `null` begin-result so `surql.seal`'s `idx+1` extraction still lines up. */
+  transaction: boolean;
+  ops: SqlOp[];
+}
+
+const rid = (v: unknown): unknown => v;
+
+/** Table name from a record id value (`table:id` string or RecordId). */
+export function tableOf(id: unknown): string {
+  return stableKey(id).split(':')[0];
+}
+
+export function translateSurql(sql: string, vars: Record<string, unknown>): TranslatedQuery {
+  const trimmed = sql.trim().replace(/;\s*$/, '');
+
+  if (/^BEGIN\s+TRANSACTION/i.test(trimmed)) {
+    const inner = trimmed
+      .replace(/^BEGIN\s+TRANSACTION\s*;?/i, '')
+      .replace(/;?\s*COMMIT\s+TRANSACTION\s*$/i, '');
+    const ops = splitStatements(inner).map((s) => translateStatement(s, vars));
+    return { transaction: true, ops };
+  }
+
+  // A plain multi-statement string (e.g. `DEFINE DATABASE x; USE DB x`) — split
+  // and translate each. Single statement is just the one-element case.
+  const parts = splitStatements(trimmed);
+  return { transaction: false, ops: parts.map((s) => translateStatement(s, vars)) };
+}
+
+function splitStatements(block: string): string[] {
+  // Statements in the client's tx blocks never contain a bare `;` inside a
+  // string/paren, so a simple split is sufficient for this bounded vocabulary.
+  return block
+    .split(';')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function translateStatement(stmt: string, vars: Record<string, unknown>): SqlOp {
+  const s = stmt.trim();
+
+  // LET $var = ( <inner statement> ) — bind the inner result into query scope.
+  let mLet = /^LET\s+\$(\w+)\s*=\s*\(([\s\S]+)\)$/i.exec(s);
+  if (mLet) {
+    return { kind: 'let', var: mLet[1], inner: translateStatement(mLet[2].trim(), vars) };
+  }
+
+  // RETURN { key: $var, ... } — build an object from scope/vars.
+  let mRet = /^RETURN\s+\{([\s\S]+)\}$/i.exec(s);
+  if (mRet) {
+    const entries = splitTopLevel(mRet[1], ',').map((pair) => {
+      const c = pair.indexOf(':');
+      const key = pair.slice(0, c).trim();
+      const v = pair.slice(c + 1).trim();
+      return { key, var: v.startsWith('$') ? v.slice(1) : v };
+    });
+    return { kind: 'return', entries };
+  }
+
+  // ---- schema / session DDL: no-ops on a schemaless engine --------------
+  // SQLite creates tables lazily and has no namespaces/DB DDL, so DEFINE /
+  // REMOVE / USE / INFO / RETURN statements are safely ignored.
+  if (/^(DEFINE|REMOVE|USE|INFO|RETURN|CANCEL|COMMIT|BEGIN)\b/i.test(s)) {
+    return { kind: 'noop' };
+  }
+
+  // ---- writes -----------------------------------------------------------
+  let m =
+    /^CREATE\s+ONLY\s+\$(\w+)\s+CONTENT\s+\$(\w+)$/i.exec(s) ||
+    /^UPSERT\s+ONLY\s+\$(\w+)\s+REPLACE\s+\$(\w+)$/i.exec(s);
+  if (m) {
+    return { kind: 'upsert', id: rid(vars[m[1]]), data: asRow(vars[m[2]]), mode: 'replace' };
+  }
+
+  m =
+    /^UPSERT\s+ONLY\s+\$(\w+)\s+MERGE\s+\$(\w+)$/i.exec(s) ||
+    /^UPDATE\s+ONLY\s+\$(\w+)\s+MERGE\s+\$(\w+)$/i.exec(s);
+  if (m) {
+    return { kind: 'upsert', id: rid(vars[m[1]]), data: asRow(vars[m[2]]), mode: 'merge' };
+  }
+
+  // CREATE ONLY $id SET a = ..., b = ...  (createSet / createMutation)
+  m = /^CREATE\s+ONLY\s+\$(\w+)\s+SET\s+(.+)$/i.exec(s);
+  if (m) {
+    const data: Row = {};
+    for (const { path, value } of parseSetClauses(m[2], vars)) setPath(data, path, value);
+    return { kind: 'upsert', id: rid(vars[m[1]]), data, mode: 'replace' };
+  }
+
+  // UPDATE $id SET a.b = $x, c = $y [RETURN NONE]
+  m = /^UPDATE\s+\$(\w+)\s+SET\s+(.+?)(\s+RETURN\s+NONE)?$/i.exec(s);
+  if (m) {
+    return {
+      kind: 'updateSet',
+      id: rid(vars[m[1]]),
+      sets: parseSetClauses(m[2], vars),
+      returnNone: !!m[3],
+    };
+  }
+
+  m = /^DELETE\s+\$(\w+)$/i.exec(s);
+  if (m) return { kind: 'delete', id: rid(vars[m[1]]) };
+
+  m = /^DELETE\s+([A-Za-z_]\w*)$/i.exec(s); // DELETE <table>
+  if (m) return { kind: 'deleteAll', table: m[1] };
+
+  // ---- reads ------------------------------------------------------------
+  // SELECT [VALUE] <proj> FROM ONLY $id
+  m = /^SELECT\s+(VALUE\s+)?(.+?)\s+FROM\s+ONLY\s+\$(\w+)$/i.exec(s);
+  if (m) {
+    const value = m[1] ? m[2].trim() : undefined;
+    return { kind: 'getById', id: rid(vars[m[3]]), select: projFields(m[2], !!m[1]), value };
+  }
+
+  // SELECT [VALUE] <proj> FROM $arrayParam
+  m = /^SELECT\s+(VALUE\s+)?(.+?)\s+FROM\s+\$(\w+)$/i.exec(s);
+  if (m) {
+    const value = m[1] ? m[2].trim() : undefined;
+    return {
+      kind: 'selectByIds',
+      ids: (vars[m[3]] as unknown[]) ?? [],
+      select: projFields(m[2], !!m[1]),
+      value,
+    };
+  }
+
+  // SELECT <proj> FROM <table> [WHERE ...] [ORDER BY ...]
+  m = /^SELECT\s+(VALUE\s+)?(.+?)\s+FROM\s+([A-Za-z_]\w*)(?:\s+WHERE\s+(.+?))?(?:\s+ORDER\s+BY\s+(.+?))?$/i.exec(
+    s
+  );
+  if (m) {
+    return {
+      kind: 'selectTable',
+      table: m[3],
+      where: m[4] ? parseWhere(m[4], vars) : undefined,
+      orderBy: m[5] ? parseOrderBy(m[5]) : undefined,
+      select: projFields(m[2], !!m[1]),
+      value: m[1] ? m[2].trim() : undefined,
+    };
+  }
+
+  throw new Error(`SqliteCacheEngine: unsupported SurrealQL for translation: ${stmt}`);
+}
+
+// ==================== clause parsers ====================
+
+function projFields(proj: string, isValue: boolean): string[] | undefined {
+  const p = proj.trim();
+  if (isValue) return undefined; // VALUE returns a scalar, no projection object
+  if (p === '*') return undefined;
+  return p.split(',').map((f) => f.trim());
+}
+
+function asRow(v: unknown): Row {
+  return (v && typeof v === 'object' ? v : {}) as Row;
+}
+
+/** Parse `a = $x, b.c = 'lit', _00_rv += 1` into path/op/value triples. */
+function parseSetClauses(clause: string, vars: Record<string, unknown>): SetClause[] {
+  return splitTopLevel(clause, ',').map((part) => {
+    const m = /^(.+?)\s*(\+=|-=|=)\s*([\s\S]+)$/.exec(part.trim());
+    if (!m) throw new Error(`SqliteCacheEngine: cannot parse SET clause: ${part}`);
+    return { path: m[1].trim(), op: m[2] as SetClause['op'], value: literalOrVar(m[3], vars) };
+  });
+}
+
+function literalOrVar(token: string, vars: Record<string, unknown>): unknown {
+  const t = token.trim();
+  if (t.startsWith('$')) return vars[t.slice(1)];
+  if (/^'.*'$/.test(t) || /^".*"$/.test(t)) return t.slice(1, -1);
+  if (/^-?\d+(\.\d+)?$/.test(t)) return Number(t);
+  if (t === 'true') return true;
+  if (t === 'false') return false;
+  if (t === 'NONE' || t === 'NULL' || t === 'null') return null;
+  return t;
+}
+
+function parseWhere(clause: string, vars: Record<string, unknown>): WhereNode[] {
+  // Only simple AND-of-equality/comparison is emitted by the client's raw
+  // queries; OR/nested go through plan-based select().
+  return splitTopLevel(clause, 'AND').map((cond) => {
+    const m = /^(\S+)\s*(=|!=|>=|<=|>|<)\s*(.+)$/.exec(cond.trim());
+    if (!m) throw new Error(`SqliteCacheEngine: cannot parse WHERE condition: ${cond}`);
+    return { field: m[1], op: m[2] as WhereComparisonOp, value: literalOrVar(m[3], vars) };
+  });
+}
+
+type WhereComparisonOp = '=' | '!=' | '>=' | '<=' | '>' | '<';
+
+function parseOrderBy(clause: string): OrderBy {
+  return clause.split(',').map((c) => {
+    const [f, dir] = c.trim().split(/\s+/);
+    return [f, (dir ?? 'asc').toLowerCase() === 'desc' ? 'desc' : 'asc'];
+  });
+}
+
+/** Split on a top-level separator, ignoring parens/quotes (bounded inputs). */
+function splitTopLevel(input: string, sep: string): string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let inStr: string | null = null;
+  let cur = '';
+  const isWord = /[A-Za-z]/.test(sep);
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (inStr) {
+      cur += ch;
+      if (ch === inStr) inStr = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      inStr = ch;
+      cur += ch;
+      continue;
+    }
+    if (ch === '(') depth++;
+    if (ch === ')') depth--;
+    const matches = isWord
+      ? depth === 0 && input.slice(i, i + sep.length).toUpperCase() === sep && /\s/.test(input[i - 1] ?? ' ')
+      : depth === 0 && ch === sep;
+    if (matches) {
+      out.push(cur.trim());
+      cur = '';
+      i += sep.length - 1;
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur.trim()) out.push(cur.trim());
+  return out;
+}
+
+/** Read a possibly-dotted path (`a.b.c`) from an object. */
+export function getPath(obj: Row, path: string): unknown {
+  let cur: unknown = obj;
+  for (const k of path.split('.')) {
+    if (cur == null || typeof cur !== 'object') return undefined;
+    cur = (cur as Row)[k];
+  }
+  return cur;
+}
+
+/** Set a possibly-dotted path (`a.b.c`) on an object. */
+export function setPath(obj: Row, path: string, value: unknown): void {
+  const parts = path.split('.');
+  let cur: Row = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const k = parts[i];
+    if (typeof cur[k] !== 'object' || cur[k] === null) cur[k] = {};
+    cur = cur[k] as Row;
+  }
+  cur[parts[parts.length - 1]] = value;
+}

package/src/services/database/surreal-cache-engine.ts

@@ -0,0 +1,122 @@
+import type { QueryPlan } from '@spooky-sync/query-builder';
+import { LocalDatabaseService } from './local';
+import { resolveRelations } from './relation-resolver';
+import {
+  renderBaseSelectSurql,
+  renderRelationFetchSurql,
+} from './plan-render';
+import type {
+  EngineTx,
+  Id,
+  LocalCacheEngine,
+  OrderBy,
+  RelationFetch,
+  Row,
+} from './cache-engine';
+import { stableKey } from './relation-resolver';
+import { surql } from '../../utils/surql';
+
+/**
+ * Default local cache backend: the in-browser SurrealDB-WASM store. Implemented
+ * as a subclass of {@link LocalDatabaseService} so it remains a 100% drop-in for
+ * every existing `this.local.query(...)` / `execute` / `switchStore` / `epoch`
+ * call site (zero behavior change), while adding the engine-neutral verb surface
+ * (`select`/`selectByIds`/`getById`/CRUD) used by the pluggable path.
+ *
+ * Relations are resolved with the SAME shared {@link resolveRelations} as the
+ * SQLite backend, so the two engines decompose `.related()` identically.
+ */
+export class SurrealCacheEngine extends LocalDatabaseService implements LocalCacheEngine {
+  /** SurrealDB needs its SurrealQL schema provisioned locally. */
+  readonly usesSurqlSchema = true;
+
+  /** {@link LocalCacheEngine} alias for {@link LocalDatabaseService.switchStore}. */
+  switchBucket(bucketId: string): Promise<void> {
+    return this.switchStore(bucketId);
+  }
+
+  async fetchRelation(req: RelationFetch): Promise<Row[]> {
+    const { sql, vars } = renderRelationFetchSurql(req);
+    const [rows] = await this.query<[Row[]]>(sql, vars);
+    return rows ?? [];
+  }
+
+  async select(plan: QueryPlan, params: Record<string, unknown> = {}): Promise<Row[]> {
+    // Window materialization: base rows are exactly `plan.ids`, ordered.
+    if (plan.ids) {
+      const result = await this.selectByIds(plan.table, plan.ids, {
+        select: plan.select,
+        orderBy: plan.orderBy,
+      });
+      await resolveRelations(result, plan.relations, this);
+      return result;
+    }
+    const { sql, vars } = renderBaseSelectSurql(plan, params);
+    const [rows] = await this.query<[Row[]]>(sql, vars);
+    const result = rows ?? [];
+    await resolveRelations(result, plan.relations, this);
+    return result;
+  }
+
+  async selectByIds(
+    table: string,
+    ids: Id[],
+    opts?: { select?: string[]; orderBy?: OrderBy }
+  ): Promise<Row[]> {
+    if (ids.length === 0) return [];
+    const projection =
+      opts?.select && opts.select.length > 0 ? ['id', ...opts.select].join(', ') : '*';
+    let sql = `SELECT ${projection} FROM $__ids`;
+    if (opts?.orderBy && opts.orderBy.length > 0) {
+      sql += ` ORDER BY ${opts.orderBy.map(([f, d]) => `${f} ${d}`).join(', ')}`;
+    }
+    const [rows] = await this.query<[Row[]]>(`${sql};`, { __ids: ids });
+    const result = rows ?? [];
+    // Preserve caller's id order when no explicit ORDER BY (SurrealDB does not
+    // guarantee `FROM $ids` order).
+    if (!opts?.orderBy || opts.orderBy.length === 0) {
+      const pos = new Map(ids.map((id, i) => [stableKey(id), i]));
+      result.sort(
+        (a, b) => (pos.get(stableKey(a.id)) ?? 0) - (pos.get(stableKey(b.id)) ?? 0)
+      );
+    }
+    return result;
+  }
+
+  async getById(_table: string, id: Id): Promise<Row | null> {
+    const [row] = await this.query<[Row | null]>('SELECT * FROM ONLY $__id;', { __id: id });
+    return row ?? null;
+  }
+
+  async upsert(_table: string, id: Id, data: Row, mode: 'replace' | 'merge'): Promise<void> {
+    const sql = mode === 'merge' ? surql.upsertMerge('__id', '__data') : surql.upsert('__id', '__data');
+    await this.query(surql.seal(sql), { __id: id, __data: data });
+  }
+
+  async patch(_table: string, id: Id, patches: unknown[]): Promise<void> {
+    await this.query(surql.seal('UPDATE ONLY $__id PATCH $__patches'), {
+      __id: id,
+      __patches: patches,
+    });
+  }
+
+  async delete(_table: string, id: Id): Promise<void> {
+    await this.query(surql.seal(surql.delete('__id')), { __id: id });
+  }
+
+  /**
+   * Serialized (not strictly atomic) transaction: verbs run in order on the
+   * same serialized query queue. The SurrealDB-WASM store already funnels every
+   * `query()` through one queue, so these never interleave with other work;
+   * true multi-statement atomicity is not required by the current call sites
+   * (single-record CRDT / mutation writes).
+   */
+  async transaction<T>(fn: (tx: EngineTx) => Promise<T>): Promise<T> {
+    const tx: EngineTx = {
+      upsert: (t, id, data, mode) => this.upsert(t, id, data, mode),
+      patch: (t, id, patches) => this.patch(t, id, patches),
+      delete: (t, id) => this.delete(t, id),
+    };
+    return fn(tx);
+  }
+}

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;