@mmapp/react 0.1.0-alpha.1 → 0.1.0-alpha.4

package/src/browser-player.ts

@@ -1,783 +0,0 @@
-/**
- * BrowserPlayer — Unified browser-side MindMatrix P2P player.
- *
- * Wires together:
- * - mm-wasm (expression engine, transition execution, Ed25519 crypto)
- * - mm-storage-browser (IndexedDB persistence via WASM)
- * - WebSocket signaling (for P2P peer discovery via mm-bridge)
- *
- * Provides a framework-agnostic API: init(), createInstance(), transition(),
- * subscribe(), getState(). React hooks (usePlayer, etc.) can wrap this.
- *
- * @example
- * ```ts
- * const player = new BrowserPlayer({
- *   signalingUrl: 'wss://bridge.mindmatrix.io/ws/signal',
- *   wasmUrl: '/mm_wasm_bg.wasm',
- * });
- * await player.init();
- * const instance = await player.createInstance('my-workflow', { title: 'Hello' });
- * await player.transition(instance.id, 'submit', { approved: true });
- * player.subscribe('state:*', (event) => console.log(event));
- * ```
- */
-
-// ─── Types ──────────────────────────────────────────────────────────────────
-
-/** WASM module interface (mm-wasm exports) */
-export interface MmWasmModule {
-  evaluate_expression(expr: string, contextJson: string, evalContext?: string): string;
-  evaluate_batch(expressionsJson: string, contextJson: string, evalContext?: string): string;
-  execute_transition?(requestJson: string): string;
-  generate_keypair(): string;
-  get_peer_id(secretKeyHex: string): string;
-  sign_data(data: Uint8Array, secretKeyHex: string): string;
-  sign_envelope(secretKeyHex: string, payloadJson: string): string;
-  verify_envelope_signature(envelopeJson: string): boolean;
-  encrypt_topic_payload(keyHex: string, plaintext: Uint8Array): string;
-  decrypt_topic_payload(keyHex: string, ciphertextHex: string): Uint8Array;
-  version(): string;
-}
-
-/** Configuration for BrowserPlayer */
-export interface BrowserPlayerConfig {
-  /** URL to the mm-wasm .wasm file */
-  wasmUrl?: string;
-  /** Pre-loaded WASM module (skip loading from URL) */
-  wasmModule?: MmWasmModule;
-  /** WebSocket signaling URL (mm-bridge /ws/signal endpoint) */
-  signalingUrl?: string;
-  /** JWT token for signaling authentication */
-  authToken?: string;
-  /** IndexedDB database name (default: "mm-player") */
-  dbName?: string;
-  /** Identity label for IndexedDB key storage */
-  identityLabel?: string;
-  /** Pre-existing secret key hex (skip key generation/loading) */
-  secretKeyHex?: string;
-  /** Enable debug logging */
-  debug?: boolean;
-}
-
-/** A workflow instance managed by the player */
-export interface PlayerInstance {
-  id: string;
-  definitionId: string;
-  definitionSlug: string;
-  currentState: string;
-  status: 'ACTIVE' | 'COMPLETED' | 'CANCELLED';
-  stateData: Record<string, unknown>;
-  memory: Record<string, unknown>;
-  lockVersion: number;
-  createdAt: string;
-  updatedAt: string;
-}
-
-/** Result of a transition execution */
-export interface TransitionResult {
-  success: boolean;
-  instance: PlayerInstance;
-  error?: string;
-}
-
-/** Event emitted by the player */
-export interface PlayerEvent {
-  type: string;
-  instanceId?: string;
-  data: Record<string, unknown>;
-  timestamp: number;
-}
-
-/** Subscription callback */
-export type PlayerEventCallback = (event: PlayerEvent) => void;
-
-/** Subscription handle (for unsubscribing) */
-export interface Subscription {
-  id: string;
-  unsubscribe: () => void;
-}
-
-/** Signaling message from server */
-interface SignalingMessage {
-  event: string;
-  data: Record<string, unknown>;
-}
-
-// ─── Identity Store (IndexedDB) ─────────────────────────────────────────────
-
-const IDENTITY_DB_NAME = 'mm-identity';
-const IDENTITY_STORE_NAME = 'keys';
-
-interface StoredIdentity {
-  label: string;
-  secretKeyHex: string;
-  publicKeyHex: string;
-  createdAt: string;
-}
-
-async function openIdentityDb(): Promise<IDBDatabase> {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(IDENTITY_DB_NAME, 1);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(IDENTITY_STORE_NAME)) {
-        db.createObjectStore(IDENTITY_STORE_NAME, { keyPath: 'label' });
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error);
-  });
-}
-
-async function loadIdentity(label: string): Promise<StoredIdentity | null> {
-  const db = await openIdentityDb();
-  return new Promise((resolve, reject) => {
-    const tx = db.transaction(IDENTITY_STORE_NAME, 'readonly');
-    const store = tx.objectStore(IDENTITY_STORE_NAME);
-    const request = store.get(label);
-    request.onsuccess = () => resolve(request.result ?? null);
-    request.onerror = () => reject(request.error);
-    tx.oncomplete = () => db.close();
-  });
-}
-
-async function saveIdentity(identity: StoredIdentity): Promise<void> {
-  const db = await openIdentityDb();
-  return new Promise((resolve, reject) => {
-    const tx = db.transaction(IDENTITY_STORE_NAME, 'readwrite');
-    const store = tx.objectStore(IDENTITY_STORE_NAME);
-    store.put(identity);
-    tx.oncomplete = () => {
-      db.close();
-      resolve();
-    };
-    tx.onerror = () => reject(tx.error);
-  });
-}
-
-// ─── Instance Store (IndexedDB) ─────────────────────────────────────────────
-
-const INSTANCE_STORE_NAME = 'instances';
-const DEFINITION_STORE_NAME = 'definitions';
-
-async function openPlayerDb(dbName: string): Promise<IDBDatabase> {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(dbName, 1);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(INSTANCE_STORE_NAME)) {
-        db.createObjectStore(INSTANCE_STORE_NAME, { keyPath: 'id' });
-      }
-      if (!db.objectStoreNames.contains(DEFINITION_STORE_NAME)) {
-        db.createObjectStore(DEFINITION_STORE_NAME, { keyPath: 'id' });
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error);
-  });
-}
-
-// ─── BrowserPlayer ──────────────────────────────────────────────────────────
-
-export class BrowserPlayer {
-  private config: Required<
-    Pick<BrowserPlayerConfig, 'dbName' | 'identityLabel' | 'debug'>
-  > &
-    BrowserPlayerConfig;
-  private wasm: MmWasmModule | null = null;
-  private secretKeyHex: string | null = null;
-  private publicKeyHex: string | null = null;
-  private peerId: string | null = null;
-  private db: IDBDatabase | null = null;
-  private ws: WebSocket | null = null;
-  private subscriptions = new Map<string, Set<PlayerEventCallback>>();
-  private initialized = false;
-  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
-
-  constructor(config: BrowserPlayerConfig = {}) {
-    this.config = {
-      ...config,
-      dbName: config.dbName ?? 'mm-player',
-      identityLabel: config.identityLabel ?? 'default',
-      debug: config.debug ?? false,
-    };
-  }
-
-  // ─── Lifecycle ──────────────────────────────────────────────────────
-
-  /**
-   * Initialize the player:
-   * 1. Load or generate Ed25519 identity (IndexedDB)
-   * 2. Initialize WASM module
-   * 3. Open instance store (IndexedDB)
-   * 4. Connect to signaling server (if configured)
-   */
-  async init(): Promise<void> {
-    if (this.initialized) return;
-
-    // 1. WASM module
-    if (this.config.wasmModule) {
-      this.wasm = this.config.wasmModule;
-    } else if (this.config.wasmUrl) {
-      this.wasm = await this.loadWasm(this.config.wasmUrl);
-    } else {
-      throw new Error('BrowserPlayer: either wasmUrl or wasmModule is required');
-    }
-
-    this.log('info', `WASM module loaded (version: ${this.wasm.version()})`);
-
-    // 2. Identity
-    if (this.config.secretKeyHex) {
-      this.secretKeyHex = this.config.secretKeyHex;
-      this.publicKeyHex = this.wasm.get_peer_id(this.secretKeyHex);
-    } else {
-      await this.loadOrCreateIdentity();
-    }
-    this.peerId = this.publicKeyHex;
-    this.log('info', `Identity ready: ${this.peerId?.slice(0, 16)}...`);
-
-    // 3. Instance store
-    this.db = await openPlayerDb(this.config.dbName);
-    this.log('info', `IndexedDB "${this.config.dbName}" opened`);
-
-    // 4. Signaling
-    if (this.config.signalingUrl) {
-      this.connectSignaling();
-    }
-
-    this.initialized = true;
-    this.emit({ type: 'player:ready', data: { peerId: this.peerId }, timestamp: Date.now() });
-  }
-
-  /** Shut down the player, close connections. */
-  async destroy(): Promise<void> {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-    this.subscriptions.clear();
-    this.initialized = false;
-    this.log('info', 'BrowserPlayer destroyed');
-  }
-
-  // ─── Identity ───────────────────────────────────────────────────────
-
-  /** Get the local peer ID (hex-encoded Ed25519 public key). */
-  getPeerId(): string {
-    this.ensureInitialized();
-    return this.peerId!;
-  }
-
-  /** Sign arbitrary data with the local identity. Returns hex-encoded signature. */
-  sign(data: Uint8Array): string {
-    this.ensureInitialized();
-    return this.wasm!.sign_data(data, this.secretKeyHex!);
-  }
-
-  /** Sign an envelope (MessagePayload JSON → signed Envelope JSON). */
-  signEnvelope(payloadJson: string): string {
-    this.ensureInitialized();
-    return this.wasm!.sign_envelope(this.secretKeyHex!, payloadJson);
-  }
-
-  /** Verify an envelope's signature. */
-  verifyEnvelope(envelopeJson: string): boolean {
-    this.ensureInitialized();
-    return this.wasm!.verify_envelope_signature(envelopeJson);
-  }
-
-  // ─── Expressions ────────────────────────────────────────────────────
-
-  /** Evaluate a single expression against a context. */
-  evaluateExpression(
-    expr: string,
-    context: Record<string, unknown>,
-    evalContext?: string,
-  ): unknown {
-    this.ensureInitialized();
-    const result = this.wasm!.evaluate_expression(
-      expr,
-      JSON.stringify(context),
-      evalContext,
-    );
-    return JSON.parse(result);
-  }
-
-  /** Evaluate multiple expressions in a single call. */
-  evaluateBatch(
-    expressions: string[],
-    context: Record<string, unknown>,
-    evalContext?: string,
-  ): unknown[] {
-    this.ensureInitialized();
-    const result = this.wasm!.evaluate_batch(
-      JSON.stringify(expressions),
-      JSON.stringify(context),
-      evalContext,
-    );
-    return JSON.parse(result);
-  }
-
-  // ─── Instance Management ────────────────────────────────────────────
-
-  /**
-   * Create a new workflow instance.
-   *
-   * @param definitionSlug - The definition slug to instantiate
-   * @param initialData - Initial state_data
-   * @param options - Optional metadata (entityType, entityId)
-   */
-  async createInstance(
-    definitionSlug: string,
-    initialData: Record<string, unknown> = {},
-    options: {
-      definitionId?: string;
-      entityType?: string;
-      entityId?: string;
-    } = {},
-  ): Promise<PlayerInstance> {
-    this.ensureInitialized();
-
-    const id = crypto.randomUUID();
-    const now = new Date().toISOString();
-
-    const instance: PlayerInstance = {
-      id,
-      definitionId: options.definitionId ?? definitionSlug,
-      definitionSlug,
-      currentState: 'START',
-      status: 'ACTIVE',
-      stateData: { ...initialData },
-      memory: {},
-      lockVersion: 0,
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    await this.putInstance(instance);
-    this.log('info', `Instance created: ${id} (${definitionSlug})`);
-
-    this.emit({
-      type: 'instance:created',
-      instanceId: id,
-      data: { definitionSlug, currentState: instance.currentState },
-      timestamp: Date.now(),
-    });
-
-    return instance;
-  }
-
-  /** Get an instance by ID. */
-  async getInstance(id: string): Promise<PlayerInstance | null> {
-    this.ensureInitialized();
-    return this.getInstanceFromDb(id);
-  }
-
-  /** Get the current state of an instance. */
-  async getState(id: string): Promise<{
-    currentState: string;
-    status: string;
-    stateData: Record<string, unknown>;
-    lockVersion: number;
-  } | null> {
-    const instance = await this.getInstance(id);
-    if (!instance) return null;
-    return {
-      currentState: instance.currentState,
-      status: instance.status,
-      stateData: instance.stateData,
-      lockVersion: instance.lockVersion,
-    };
-  }
-
-  /**
-   * Execute a transition on an instance.
-   *
-   * If the WASM module has `execute_transition` (full build), uses the
-   * 13-step pipeline. Otherwise, performs a simple state update.
-   */
-  async transition(
-    instanceId: string,
-    transitionName: string,
-    data: Record<string, unknown> = {},
-  ): Promise<TransitionResult> {
-    this.ensureInitialized();
-
-    const instance = await this.getInstanceFromDb(instanceId);
-    if (!instance) {
-      return {
-        success: false,
-        instance: null as unknown as PlayerInstance,
-        error: `Instance ${instanceId} not found`,
-      };
-    }
-
-    if (instance.status !== 'ACTIVE') {
-      return {
-        success: false,
-        instance,
-        error: `Instance is ${instance.status}, cannot transition`,
-      };
-    }
-
-    try {
-      // Merge transition data into state_data.
-      const newStateData = { ...instance.stateData, ...data };
-      const newLockVersion = instance.lockVersion + 1;
-
-      // If WASM full build available, use the pipeline.
-      if (this.wasm!.execute_transition) {
-        const request = {
-          instance: {
-            id: instance.id,
-            definition_id: instance.definitionId,
-            current_state: instance.currentState,
-            status: instance.status,
-            state_data: newStateData,
-            memory: instance.memory,
-            execution_lock_version: instance.lockVersion,
-          },
-          transition_name: transitionName,
-          actor_id: this.peerId,
-          transition_data: data,
-        };
-
-        const resultJson = this.wasm!.execute_transition(JSON.stringify(request));
-        const result = JSON.parse(resultJson);
-
-        if (result.success === false || result.error) {
-          return { success: false, instance, error: result.error ?? 'Transition failed' };
-        }
-
-        // Apply pipeline result.
-        instance.currentState = result.to_state ?? instance.currentState;
-        instance.status = result.status ?? instance.status;
-        instance.stateData = result.state_data ?? newStateData;
-        instance.memory = result.memory ?? instance.memory;
-      } else {
-        // Simple state update (minimal WASM build without pipeline).
-        instance.stateData = newStateData;
-      }
-
-      instance.lockVersion = newLockVersion;
-      instance.updatedAt = new Date().toISOString();
-
-      await this.putInstance(instance);
-
-      this.log('info', `Transition: ${instanceId} ${transitionName}`);
-      this.emit({
-        type: 'instance:transition',
-        instanceId,
-        data: {
-          transitionName,
-          fromState: instance.currentState,
-          toState: instance.currentState,
-          lockVersion: newLockVersion,
-        },
-        timestamp: Date.now(),
-      });
-
-      // Sign and broadcast if connected to signaling.
-      if (this.ws?.readyState === WebSocket.OPEN && this.secretKeyHex) {
-        const payload = JSON.stringify({
-          type: 'TransitionReplication',
-          instance_id: instanceId,
-          transition_name: transitionName,
-          state_data: instance.stateData,
-          lock_version: newLockVersion,
-        });
-        const envelope = this.wasm!.sign_envelope(this.secretKeyHex, payload);
-        this.ws.send(JSON.stringify({
-          type: 'signal:broadcast',
-          topic: `mm/replication`,
-          envelope,
-        }));
-      }
-
-      return { success: true, instance };
-    } catch (err) {
-      const error = err instanceof Error ? err.message : String(err);
-      this.log('error', `Transition failed: ${error}`);
-      return { success: false, instance, error };
-    }
-  }
-
-  // ─── Subscriptions ──────────────────────────────────────────────────
-
-  /**
-   * Subscribe to player events.
-   *
-   * @param pattern - Event type pattern (supports `*` wildcard).
-   *   Examples: `"instance:*"`, `"player:ready"`, `"peer:*"`, `"*"`
-   * @param callback - Called when a matching event occurs
-   * @returns Subscription handle with `unsubscribe()` method
-   */
-  subscribe(pattern: string, callback: PlayerEventCallback): Subscription {
-    if (!this.subscriptions.has(pattern)) {
-      this.subscriptions.set(pattern, new Set());
-    }
-    this.subscriptions.get(pattern)!.add(callback);
-
-    const id = crypto.randomUUID();
-    return {
-      id,
-      unsubscribe: () => {
-        this.subscriptions.get(pattern)?.delete(callback);
-      },
-    };
-  }
-
-  // ─── Topic Encryption ───────────────────────────────────────────────
-
-  /** Encrypt a payload for a topic (AES-256-GCM). */
-  encryptForTopic(topicKeyHex: string, plaintext: Uint8Array): string {
-    this.ensureInitialized();
-    return this.wasm!.encrypt_topic_payload(topicKeyHex, plaintext);
-  }
-
-  /** Decrypt a topic payload. */
-  decryptFromTopic(topicKeyHex: string, ciphertextHex: string): Uint8Array {
-    this.ensureInitialized();
-    return this.wasm!.decrypt_topic_payload(topicKeyHex, ciphertextHex);
-  }
-
-  // ─── Internal: WASM Loading ─────────────────────────────────────────
-
-  private async loadWasm(url: string): Promise<MmWasmModule> {
-    // Dynamic import of the wasm-bindgen generated JS glue.
-    // The URL should point to the wasm-pack output directory.
-    const module = await import(/* @vite-ignore */ url);
-    if (module.default && typeof module.default === 'function') {
-      // wasm-pack style: default export is init function
-      await module.default();
-    }
-    return module as MmWasmModule;
-  }
-
-  // ─── Internal: Identity ─────────────────────────────────────────────
-
-  private async loadOrCreateIdentity(): Promise<void> {
-    const label = this.config.identityLabel;
-
-    // Try loading from IndexedDB.
-    const stored = await loadIdentity(label);
-    if (stored) {
-      this.secretKeyHex = stored.secretKeyHex;
-      this.publicKeyHex = stored.publicKeyHex;
-      this.log('info', `Identity loaded from IndexedDB (label: ${label})`);
-      return;
-    }
-
-    // Generate new identity via WASM.
-    const keypairJson = this.wasm!.generate_keypair();
-    const keypair: { secret_key: string; public_key: string } = JSON.parse(keypairJson);
-
-    this.secretKeyHex = keypair.secret_key;
-    this.publicKeyHex = keypair.public_key;
-
-    // Persist to IndexedDB.
-    await saveIdentity({
-      label,
-      secretKeyHex: keypair.secret_key,
-      publicKeyHex: keypair.public_key,
-      createdAt: new Date().toISOString(),
-    });
-
-    this.log('info', `New identity generated and saved (label: ${label})`);
-  }
-
-  // ─── Internal: IndexedDB Instance Store ─────────────────────────────
-
-  private async getInstanceFromDb(id: string): Promise<PlayerInstance | null> {
-    if (!this.db) return null;
-    return new Promise((resolve, reject) => {
-      const tx = this.db!.transaction(INSTANCE_STORE_NAME, 'readonly');
-      const store = tx.objectStore(INSTANCE_STORE_NAME);
-      const request = store.get(id);
-      request.onsuccess = () => resolve(request.result ?? null);
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  private async putInstance(instance: PlayerInstance): Promise<void> {
-    if (!this.db) return;
-    return new Promise((resolve, reject) => {
-      const tx = this.db!.transaction(INSTANCE_STORE_NAME, 'readwrite');
-      const store = tx.objectStore(INSTANCE_STORE_NAME);
-      store.put(instance);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
-    });
-  }
-
-  // ─── Internal: Signaling ────────────────────────────────────────────
-
-  private connectSignaling(): void {
-    if (!this.config.signalingUrl) return;
-
-    try {
-      this.ws = new WebSocket(this.config.signalingUrl);
-    } catch (err) {
-      this.log('error', `Signaling connection failed: ${err}`);
-      this.scheduleReconnect();
-      return;
-    }
-
-    this.ws.onopen = () => {
-      this.log('info', 'Signaling connected');
-
-      // Authenticate.
-      if (this.config.authToken) {
-        this.ws!.send(
-          JSON.stringify({
-            type: 'signal:auth',
-            token: this.config.authToken,
-          }),
-        );
-      }
-
-      this.emit({
-        type: 'signaling:connected',
-        data: { url: this.config.signalingUrl! },
-        timestamp: Date.now(),
-      });
-    };
-
-    this.ws.onmessage = (event) => {
-      try {
-        const msg: SignalingMessage = JSON.parse(event.data as string);
-        this.handleSignalingMessage(msg);
-      } catch {
-        this.log('error', `Invalid signaling message: ${event.data}`);
-      }
-    };
-
-    this.ws.onclose = () => {
-      this.log('info', 'Signaling disconnected');
-      this.emit({
-        type: 'signaling:disconnected',
-        data: {},
-        timestamp: Date.now(),
-      });
-      this.scheduleReconnect();
-    };
-
-    this.ws.onerror = () => {
-      this.log('error', 'Signaling WebSocket error');
-    };
-  }
-
-  private handleSignalingMessage(msg: SignalingMessage): void {
-    switch (msg.event) {
-      case 'signal:auth':
-        this.log('info', `Authenticated as peer: ${msg.data.peer_id}`);
-        this.emit({
-          type: 'signaling:authenticated',
-          data: msg.data,
-          timestamp: Date.now(),
-        });
-        break;
-
-      case 'signal:peer-list':
-        this.emit({
-          type: 'peer:list',
-          data: msg.data,
-          timestamp: Date.now(),
-        });
-        break;
-
-      case 'signal:offer':
-      case 'signal:answer':
-      case 'signal:ice-candidate':
-        this.emit({
-          type: `signaling:${msg.event.replace('signal:', '')}`,
-          data: msg.data,
-          timestamp: Date.now(),
-        });
-        break;
-
-      case 'signal:turn-credentials':
-        this.emit({
-          type: 'signaling:turn-credentials',
-          data: msg.data,
-          timestamp: Date.now(),
-        });
-        break;
-
-      default:
-        this.log('debug', `Unknown signaling event: ${msg.event}`);
-    }
-  }
-
-  private scheduleReconnect(): void {
-    if (this.reconnectTimer) return;
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      if (this.config.signalingUrl && this.initialized) {
-        this.log('info', 'Attempting signaling reconnect...');
-        this.connectSignaling();
-      }
-    }, 5000);
-  }
-
-  // ─── Internal: Event System ─────────────────────────────────────────
-
-  private emit(event: PlayerEvent): void {
-    for (const [pattern, callbacks] of this.subscriptions) {
-      if (this.matchesPattern(pattern, event.type)) {
-        for (const cb of callbacks) {
-          try {
-            cb(event);
-          } catch (err) {
-            this.log('error', `Subscription callback error: ${err}`);
-          }
-        }
-      }
-    }
-  }
-
-  private matchesPattern(pattern: string, eventType: string): boolean {
-    if (pattern === '*') return true;
-    if (pattern === eventType) return true;
-    if (pattern.endsWith(':*')) {
-      const prefix = pattern.slice(0, -1);
-      return eventType.startsWith(prefix);
-    }
-    return false;
-  }
-
-  // ─── Internal: Utils ────────────────────────────────────────────────
-
-  private ensureInitialized(): void {
-    if (!this.initialized) {
-      throw new Error('BrowserPlayer not initialized — call init() first');
-    }
-  }
-
-  private log(level: string, message: string): void {
-    if (!this.config.debug && level === 'debug') return;
-    const prefix = `[BrowserPlayer]`;
-    switch (level) {
-      case 'error':
-        console.error(prefix, message);
-        break;
-      case 'warn':
-        console.warn(prefix, message);
-        break;
-      case 'info':
-        if (this.config.debug) console.log(prefix, message);
-        break;
-      case 'debug':
-        console.debug(prefix, message);
-        break;
-    }
-  }
-}