@pie-players/pie-section-player 0.3.16 → 0.3.19

package/dist/index-BRKsQ6Im.js

@@ -0,0 +1,460 @@
+var k = Object.defineProperty;
+var A = (r, t, e) => t in r ? k(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var a = (r, t, e) => A(r, typeof t != "symbol" ? t + "" : t, e);
+const b = (r) => {
+  const e = (r.providerOptions && typeof r.providerOptions == "object" ? r.providerOptions : {}).__pieTelemetry;
+  return typeof e == "function" ? e : void 0;
+}, R = {
+  pie: 3e3,
+  custom: 3e3
+}, v = (r) => r.replace(/\/+$/, ""), I = (r) => {
+  const t = v(r.apiEndpoint), e = (r.provider || "").toLowerCase();
+  return e === "polly" || e === "google" ? `${t}/${e}/voices` : `${t}/voices`;
+}, w = (r) => r.transportMode === "custom" ? "custom" : r.transportMode === "pie" ? "pie" : r.provider === "custom" ? "custom" : "pie", S = (r, t) => r.endpointMode ? r.endpointMode : t === "custom" ? "rootPost" : "synthesizePath", M = (r, t) => r.endpointValidationMode ? r.endpointValidationMode : t === "custom" ? "none" : "voices", E = (r) => {
+  const t = r.providerOptions || {};
+  if (typeof t.speedRate == "string")
+    return t.speedRate;
+  const e = Number(r.rate ?? 1);
+  return !Number.isFinite(e) || e <= 0.95 ? "slow" : e >= 1.5 ? "fast" : "medium";
+}, P = (r) => {
+  const t = [];
+  let e = 0;
+  const o = r.split(`
+`).map((i) => i.trim()).filter(Boolean);
+  for (const i of o)
+    try {
+      const s = JSON.parse(i), d = typeof s.type == "string" ? s.type : "word", n = typeof s.time == "number" && Number.isFinite(s.time) ? s.time : 0, c = typeof s.value == "string" ? s.value : "", l = typeof s.start == "number" && Number.isFinite(s.start) ? s.start : null, u = typeof s.end == "number" && Number.isFinite(s.end) ? s.end : null, m = l ?? e, y = u ?? m + Math.max(1, c.length || String(s.value || "").length);
+      e = Math.max(y + 1, e), t.push({
+        time: n,
+        type: d,
+        start: m,
+        end: y,
+        value: c
+      });
+    } catch {
+    }
+  return t;
+}, O = {
+  id: "pie",
+  resolveSynthesisUrl: (r) => {
+    const t = S(r, "pie"), e = v(r.apiEndpoint);
+    return t === "rootPost" ? e : `${e}/synthesize`;
+  },
+  buildRequestBody: (r, t) => {
+    const e = t.providerOptions || {}, o = typeof t.engine == "string" ? t.engine : typeof e.engine == "string" ? e.engine : void 0, i = typeof e.sampleRate == "number" && Number.isFinite(e.sampleRate) ? e.sampleRate : void 0, s = e.format === "mp3" || e.format === "ogg" || e.format === "pcm" ? e.format : void 0, d = Array.isArray(e.speechMarkTypes) ? e.speechMarkTypes.filter((n) => n === "word" || n === "sentence" || n === "ssml") : void 0;
+    return {
+      text: r,
+      provider: t.provider || "polly",
+      voice: t.voice,
+      language: t.language,
+      rate: t.rate,
+      engine: o,
+      sampleRate: i,
+      format: s,
+      speechMarkTypes: d,
+      includeSpeechMarks: !0
+    };
+  },
+  parseResponse: async (r) => {
+    const t = await r.json();
+    return {
+      audio: {
+        kind: "base64",
+        data: t.audio,
+        contentType: t.contentType
+      },
+      speechMarks: Array.isArray(t.speechMarks) ? t.speechMarks : []
+    };
+  }
+}, C = {
+  id: "custom",
+  resolveSynthesisUrl: (r) => {
+    const t = S(r, "custom"), e = v(r.apiEndpoint);
+    return t === "synthesizePath" ? `${e}/synthesize` : e;
+  },
+  buildRequestBody: (r, t) => {
+    const e = t.providerOptions || {}, o = typeof e.lang_id == "string" ? e.lang_id : t.language || "en-US", i = typeof e.cache == "boolean" ? e.cache : !0;
+    return {
+      text: r,
+      speedRate: E(t),
+      lang_id: o,
+      cache: i
+    };
+  },
+  parseResponse: async (r, t, e, o) => {
+    const i = await r.json(), s = {};
+    if (t.includeAuthOnAssetFetch)
+      for (const [n, c] of Object.entries(e))
+        n.toLowerCase() === "authorization" && (s[n] = c);
+    let d = [];
+    if (typeof i.word == "string" && i.word.length > 0) {
+      const n = await fetch(i.word, {
+        headers: s,
+        signal: o
+      });
+      if (n.ok) {
+        const c = await n.text();
+        d = P(c);
+      }
+    }
+    return {
+      audio: {
+        kind: "url",
+        url: i.audioContent
+      },
+      speechMarks: d
+    };
+  }
+}, B = {
+  pie: O,
+  custom: C
+};
+class z {
+  constructor(t, e) {
+    a(this, "config");
+    a(this, "adapter");
+    a(this, "currentAudio", null);
+    a(this, "pausedState", !1);
+    a(this, "wordTimings", []);
+    a(this, "highlightInterval", null);
+    a(this, "intentionallyStopped", !1);
+    a(this, "activeSynthesisController", null);
+    a(this, "synthesisRunId", 0);
+    a(this, "telemetryReporter");
+    a(this, "onWordBoundary");
+    this.config = t, this.adapter = e, this.telemetryReporter = b(t);
+  }
+  async emitTelemetry(t, e) {
+    try {
+      await this.telemetryReporter?.(t, e);
+    } catch (o) {
+      console.warn("[ServerTTSProvider] telemetry callback failed:", o);
+    }
+  }
+  async speak(t) {
+    this.stop(), this.intentionallyStopped = !1;
+    const e = ++this.synthesisRunId, o = new AbortController();
+    this.activeSynthesisController = o;
+    const { audioUrl: i, wordTimings: s } = await this.synthesizeSpeech(t, o.signal, e);
+    if (e !== this.synthesisRunId) {
+      URL.revokeObjectURL(i);
+      return;
+    }
+    const d = this.config.rate || 1;
+    return this.wordTimings = s.map((n) => ({
+      ...n,
+      time: n.time / d
+    })), new Promise((n, c) => {
+      const l = new Audio(i);
+      this.currentAudio = l, this.config.rate && (l.playbackRate = Math.max(0.25, Math.min(4, this.config.rate))), this.config.volume !== void 0 && (l.volume = Math.max(0, Math.min(1, this.config.volume))), l.onplay = () => {
+        this.pausedState = !1, this.onWordBoundary && this.wordTimings.length > 0 && this.startWordHighlighting();
+      }, l.onended = () => {
+        this.stopWordHighlighting(), URL.revokeObjectURL(i), this.currentAudio = null, this.wordTimings = [], n();
+      }, l.onerror = (u) => {
+        this.stopWordHighlighting(), URL.revokeObjectURL(i), this.currentAudio = null, this.wordTimings = [], this.intentionallyStopped ? n() : c(new Error("Failed to play audio from server"));
+      }, l.onpause = () => {
+        this.stopWordHighlighting(), this.pausedState = !0;
+      }, l.play().catch(c);
+    });
+  }
+  /**
+   * Call server API to synthesize speech
+   */
+  async synthesizeSpeech(t, e, o) {
+    const i = Date.now();
+    await this.emitTelemetry("pie-tool-backend-call-start", {
+      toolId: "tts",
+      backend: this.config.provider || "server",
+      operation: "synthesize-speech"
+    });
+    const s = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+    this.config.authToken && (s.Authorization = `Bearer ${this.config.authToken}`);
+    const d = this.adapter.resolveSynthesisUrl(this.config), n = this.adapter.buildRequestBody(t, this.config), c = await (async () => {
+      try {
+        return await fetch(d, {
+          method: "POST",
+          headers: s,
+          body: JSON.stringify(n),
+          signal: e
+        });
+      } catch (h) {
+        throw await this.emitTelemetry("pie-tool-backend-call-error", {
+          toolId: "tts",
+          backend: this.config.provider || "server",
+          operation: "synthesize-speech",
+          duration: Date.now() - i,
+          errorType: "TTSBackendNetworkError",
+          message: h instanceof Error ? h.message : String(h)
+        }), h;
+      }
+    })();
+    if (!c.ok) {
+      const h = await c.json().catch(() => ({})), p = h.message || h.error?.message || `Server returned ${c.status}`;
+      throw await this.emitTelemetry("pie-tool-backend-call-error", {
+        toolId: "tts",
+        backend: this.config.provider || "server",
+        operation: "synthesize-speech",
+        duration: Date.now() - i,
+        statusCode: c.status,
+        errorType: "TTSBackendRequestError",
+        message: p
+      }), new Error(p);
+    }
+    const l = await this.adapter.parseResponse(c, this.config, s, e);
+    if (o !== this.synthesisRunId || e.aborted)
+      throw new Error("Synthesis superseded by a newer request");
+    let u;
+    if (l.audio.kind === "base64")
+      u = this.base64ToBlob(l.audio.data, l.audio.contentType);
+    else {
+      const h = l.audio.url, p = Date.now();
+      await this.emitTelemetry("pie-tool-backend-call-start", {
+        toolId: "tts",
+        backend: this.config.provider || "server",
+        operation: "fetch-synthesized-audio-asset"
+      });
+      const T = {};
+      this.config.includeAuthOnAssetFetch && this.config.authToken && (T.Authorization = `Bearer ${this.config.authToken}`);
+      const g = await (async () => {
+        try {
+          return await fetch(h, {
+            headers: T,
+            signal: e
+          });
+        } catch (f) {
+          throw await this.emitTelemetry("pie-tool-backend-call-error", {
+            toolId: "tts",
+            backend: this.config.provider || "server",
+            operation: "fetch-synthesized-audio-asset",
+            duration: Date.now() - p,
+            errorType: "TTSAssetNetworkError",
+            message: f instanceof Error ? f.message : String(f)
+          }), f;
+        }
+      })();
+      if (!g.ok)
+        throw await this.emitTelemetry("pie-tool-backend-call-error", {
+          toolId: "tts",
+          backend: this.config.provider || "server",
+          operation: "fetch-synthesized-audio-asset",
+          duration: Date.now() - p,
+          statusCode: g.status,
+          errorType: "TTSAssetFetchError",
+          message: `Failed to download synthesized audio (${g.status})`
+        }), new Error(`Failed to download synthesized audio (${g.status})`);
+      u = await g.blob(), await this.emitTelemetry("pie-tool-backend-call-success", {
+        toolId: "tts",
+        backend: this.config.provider || "server",
+        operation: "fetch-synthesized-audio-asset",
+        duration: Date.now() - p
+      });
+    }
+    const m = URL.createObjectURL(u), y = this.parseSpeechMarks(l.speechMarks);
+    return await this.emitTelemetry("pie-tool-backend-call-success", {
+      toolId: "tts",
+      backend: this.config.provider || "server",
+      operation: "synthesize-speech",
+      duration: Date.now() - i
+    }), { audioUrl: m, wordTimings: y };
+  }
+  /**
+   * Convert base64 to Blob
+   */
+  base64ToBlob(t, e) {
+    const o = atob(t), i = new Array(o.length);
+    for (let d = 0; d < o.length; d++)
+      i[d] = o.charCodeAt(d);
+    const s = new Uint8Array(i);
+    return new Blob([s], { type: e });
+  }
+  /**
+   * Parse speech marks into word timings
+   */
+  parseSpeechMarks(t) {
+    return t.filter((e) => e.type === "word").map((e, o) => ({
+      time: e.time,
+      wordIndex: o,
+      charIndex: e.start,
+      length: e.end - e.start
+    }));
+  }
+  /**
+   * Start word highlighting synchronized with audio playback
+   */
+  startWordHighlighting() {
+    if (this.stopWordHighlighting(), !this.currentAudio || !this.onWordBoundary || this.wordTimings.length === 0) {
+      console.log("[ServerTTSProvider] Cannot start highlighting:", {
+        hasAudio: !!this.currentAudio,
+        hasCallback: !!this.onWordBoundary,
+        wordTimingsCount: this.wordTimings.length
+      });
+      return;
+    }
+    console.log("[ServerTTSProvider] Starting word highlighting with", this.wordTimings.length, "word timings"), console.log("[ServerTTSProvider] Playback rate:", this.currentAudio.playbackRate), console.log("[ServerTTSProvider] First 3 timings:", this.wordTimings.slice(0, 3));
+    let t = -1;
+    this.highlightInterval = window.setInterval(() => {
+      if (!this.currentAudio) {
+        this.stopWordHighlighting();
+        return;
+      }
+      const e = this.currentAudio.currentTime * 1e3;
+      for (let o = 0; o < this.wordTimings.length; o++) {
+        const i = this.wordTimings[o];
+        if (e >= i.time && o > t) {
+          this.onWordBoundary && (console.log("[ServerTTSProvider] Highlighting word at charIndex:", i.charIndex, "length:", i.length, "time:", i.time, "currentTime:", e), this.onWordBoundary("", i.charIndex, i.length)), t = o;
+          break;
+        }
+      }
+    }, 50);
+  }
+  /**
+   * Stop word highlighting
+   */
+  stopWordHighlighting() {
+    this.highlightInterval !== null && (clearInterval(this.highlightInterval), this.highlightInterval = null);
+  }
+  pause() {
+    this.currentAudio && !this.pausedState && (this.currentAudio.pause(), this.stopWordHighlighting(), this.pausedState = !0);
+  }
+  resume() {
+    this.currentAudio && this.pausedState && (this.currentAudio.play(), this.pausedState = !1, this.onWordBoundary && this.wordTimings.length > 0 && this.startWordHighlighting());
+  }
+  stop() {
+    this.synthesisRunId += 1, this.activeSynthesisController && (this.activeSynthesisController.abort(), this.activeSynthesisController = null), this.stopWordHighlighting(), this.currentAudio && (this.intentionallyStopped = !0, this.currentAudio.pause(), this.currentAudio.src && URL.revokeObjectURL(this.currentAudio.src), this.currentAudio.src = "", this.currentAudio = null), this.pausedState = !1, this.wordTimings = [];
+  }
+  isPlaying() {
+    return this.currentAudio !== null && !this.pausedState;
+  }
+  isPaused() {
+    return this.pausedState;
+  }
+  /**
+   * Update settings dynamically (rate, pitch, voice)
+   * Note: Voice changes require resynthesis, so voice updates are stored but
+   * take effect on the next speak() call. Rate can be applied to current playback.
+   */
+  updateSettings(t) {
+    t.rate !== void 0 && (this.config.rate = t.rate, this.currentAudio && (this.currentAudio.playbackRate = Math.max(0.25, Math.min(4, t.rate)))), t.pitch !== void 0 && (this.config.pitch = t.pitch), t.voice !== void 0 && (this.config.voice = t.voice);
+  }
+}
+class W {
+  constructor() {
+    a(this, "providerId", "server-tts");
+    a(this, "providerName", "Server TTS");
+    a(this, "version", "1.0.0");
+    a(this, "config", null);
+    a(this, "adapter", null);
+    a(this, "telemetryReporter");
+  }
+  async emitTelemetry(t, e) {
+    try {
+      await this.telemetryReporter?.(t, e);
+    } catch (o) {
+      console.warn("[ServerTTSProvider] telemetry callback failed:", o);
+    }
+  }
+  /**
+   * Initialize the server TTS provider.
+   *
+   * This is designed to be fast by default (no API calls).
+   * Set validateEndpoint: true in config to test API availability during initialization.
+   *
+   * @performance Default: <10ms, With validation: 100-500ms
+   */
+  async initialize(t) {
+    const e = t;
+    if (!e.apiEndpoint)
+      throw new Error("apiEndpoint is required for ServerTTSProvider");
+    this.config = e, this.telemetryReporter = b(e);
+    const o = w(e);
+    if (this.adapter = B[o], e.validateEndpoint) {
+      const i = Date.now();
+      if (await this.emitTelemetry("pie-tool-backend-call-start", {
+        toolId: "tts",
+        backend: e.provider || "server",
+        operation: "validate-endpoint"
+      }), !await this.testAPIAvailability())
+        throw await this.emitTelemetry("pie-tool-backend-call-error", {
+          toolId: "tts",
+          backend: e.provider || "server",
+          operation: "validate-endpoint",
+          duration: Date.now() - i,
+          errorType: "TTSEndpointValidationError",
+          message: `Server TTS API not available at ${e.apiEndpoint}`
+        }), new Error(`Server TTS API not available at ${e.apiEndpoint}`);
+      await this.emitTelemetry("pie-tool-backend-call-success", {
+        toolId: "tts",
+        backend: e.provider || "server",
+        operation: "validate-endpoint",
+        duration: Date.now() - i
+      });
+    }
+    return new z(e, this.adapter);
+  }
+  /**
+   * Test if API endpoint is available (with timeout).
+   *
+   * @performance 100-500ms depending on network
+   */
+  async testAPIAvailability() {
+    if (!this.config || !this.adapter)
+      return !1;
+    try {
+      const t = { ...this.config.headers };
+      this.config.authToken && (t.Authorization = `Bearer ${this.config.authToken}`);
+      const e = new AbortController(), o = setTimeout(() => e.abort(), 5e3), i = M(this.config, this.adapter.id);
+      if (i === "none")
+        return clearTimeout(o), !0;
+      const s = i === "voices" ? I(this.config) : this.adapter.resolveSynthesisUrl(this.config), d = i === "voices" ? "GET" : "OPTIONS";
+      try {
+        const n = await fetch(s, {
+          method: d,
+          headers: t,
+          signal: e.signal
+        });
+        return clearTimeout(o), n.ok || n.status === 405;
+      } catch {
+        return clearTimeout(o), !1;
+      }
+    } catch {
+      return !1;
+    }
+  }
+  supportsFeature(t) {
+    switch (t) {
+      case "pause":
+      case "resume":
+      case "wordBoundary":
+      case "voiceSelection":
+      case "rateControl":
+        return !0;
+      case "pitchControl":
+        return !1;
+      default:
+        return !1;
+    }
+  }
+  getCapabilities() {
+    const t = this.config ? w(this.config) : "pie";
+    return {
+      supportsPause: !0,
+      supportsResume: !0,
+      supportsWordBoundary: !0,
+      // ✅ Via speech marks from server
+      supportsVoiceSelection: !0,
+      supportsRateControl: !0,
+      supportsPitchControl: !1,
+      // Depends on server provider
+      maxTextLength: R[t]
+    };
+  }
+  destroy() {
+    this.config = null, this.adapter = null, this.telemetryReporter = void 0;
+  }
+}
+export {
+  W as ServerTTSProvider
+};

package/dist/{index-DF-Dk87f-lxErM8bo.js → index-QLtHZ4Yz-B0r-CUMY.js}

@@ -1,11 +1,18 @@
-var n = Object.defineProperty, l = (i, e, t) => e in i ? n(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, o = (i, e, t) => l(i, typeof e != "symbol" ? e + "" : e, t);
+var l = Object.defineProperty, n = (r, e, o) => e in r ? l(r, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : r[e] = o, s = (r, e, o) => n(r, typeof e != "symbol" ? e + "" : e, o);
 class p {
   constructor() {
-    o(this, "providerId", "desmos"), o(this, "providerName", "Desmos"), o(this, "supportedTypes", [
+    s(this, "providerId", "desmos"), s(this, "providerName", "Desmos"), s(this, "supportedTypes", [
       "basic",
       "scientific",
       "graphing"
-    ]), o(this, "version", "1.10"), o(this, "initialized", !1), o(this, "apiKey"), o(this, "proxyEndpoint"), o(this, "isDevelopment", !1);
+    ]), s(this, "version", "1.10"), s(this, "initialized", !1), s(this, "apiKey"), s(this, "proxyEndpoint"), s(this, "isDevelopment", !1), s(this, "onTelemetry");
+  }
+  async emitTelemetry(e, o) {
+    try {
+      await this.onTelemetry?.(e, o);
+    } catch (t) {
+      console.warn("[DesmosProvider] telemetry callback failed:", t);
+    }
   }
   /**
    * Get the configured API key
@@ -19,13 +26,13 @@ class p {
    * @private
    */
   async loadDesmosScript() {
-    return new Promise((e, t) => {
-      const s = document.createElement("script"), r = this.apiKey ? `https://www.desmos.com/api/v1.10/calculator.js?apiKey=${this.apiKey}` : "https://www.desmos.com/api/v1.10/calculator.js";
-      s.src = r, s.async = !0, s.onload = () => {
-        window.Desmos ? (console.log("[DesmosProvider] Desmos API loaded successfully"), e()) : t(new Error("Desmos API loaded but window.Desmos is undefined"));
-      }, s.onerror = () => {
-        t(new Error("Failed to load Desmos API from CDN"));
-      }, document.head.appendChild(s);
+    return new Promise((e, o) => {
+      const t = document.createElement("script"), i = this.apiKey ? `https://www.desmos.com/api/v1.10/calculator.js?apiKey=${this.apiKey}` : "https://www.desmos.com/api/v1.10/calculator.js";
+      t.src = i, t.async = !0, t.onload = () => {
+        window.Desmos ? (console.log("[DesmosProvider] Desmos API loaded successfully"), e()) : o(new Error("Desmos API loaded but window.Desmos is undefined"));
+      }, t.onerror = () => {
+        o(new Error("Failed to load Desmos API from CDN"));
+      }, document.head.appendChild(t);
     });
   }
   /**
@@ -34,34 +41,78 @@ class p {
    */
   async initialize(e) {
     if (!this.initialized) {
-      if (typeof window > "u")
+      if (this.onTelemetry = e?.onTelemetry, typeof window > "u")
         throw new Error("Desmos calculators can only be initialized in the browser");
       if (this.isDevelopment = process.env.NODE_ENV === "development" || typeof process > "u" || !process.env.NODE_ENV, e?.proxyEndpoint) {
         this.proxyEndpoint = e.proxyEndpoint;
+        const o = Date.now();
+        await this.emitTelemetry("pie-tool-backend-call-start", {
+          toolId: "calculator",
+          backend: "desmos",
+          operation: "proxy-auth-fetch"
+        });
         try {
           const t = await fetch(e.proxyEndpoint);
           if (!t.ok)
             throw new Error(`Proxy endpoint returned ${t.status}`);
-          const s = await t.json();
-          this.apiKey = s.apiKey, console.log("[DesmosProvider] Initialized with server-side proxy (SECURE)");
+          const i = await t.json();
+          this.apiKey = i.apiKey, await this.emitTelemetry("pie-tool-backend-call-success", {
+            toolId: "calculator",
+            backend: "desmos",
+            operation: "proxy-auth-fetch",
+            duration: Date.now() - o
+          }), console.log("[DesmosProvider] Initialized with server-side proxy (SECURE)");
         } catch (t) {
-          throw new Error(`[DesmosProvider] Failed to fetch API key from proxy: ${t}`);
+          throw await this.emitTelemetry("pie-tool-backend-call-error", {
+            toolId: "calculator",
+            backend: "desmos",
+            operation: "proxy-auth-fetch",
+            duration: Date.now() - o,
+            errorType: "CalculatorProxyAuthError",
+            message: t instanceof Error ? t.message : String(t)
+          }), new Error(`[DesmosProvider] Failed to fetch API key from proxy: ${t}`);
         }
       } else e?.apiKey ? (this.apiKey = e.apiKey, this.isDevelopment ? console.log("[DesmosProvider] Initialized with direct API key (DEVELOPMENT MODE)") : console.error(`⚠️ [DesmosProvider] SECURITY WARNING: API key exposed in client-side code!
 This is insecure for production. Use proxyEndpoint instead.
 See: https://pie-players.dev/docs/calculator-desmos#security`)) : console.warn(`[DesmosProvider] No API key or proxy endpoint provided.
 Production usage requires authentication. Obtain API key from https://www.desmos.com/api
 Recommended: Use proxyEndpoint for production, apiKey for development only.`);
-      window.Desmos || (console.log("[DesmosProvider] Loading Desmos API library..."), await this.loadDesmosScript()), this.initialized = !0;
+      if (!window.Desmos) {
+        console.log("[DesmosProvider] Loading Desmos API library...");
+        const o = Date.now();
+        await this.emitTelemetry("pie-tool-library-load-start", {
+          toolId: "calculator",
+          backend: "desmos",
+          operation: "desmos-script-load"
+        });
+        try {
+          await this.loadDesmosScript(), await this.emitTelemetry("pie-tool-library-load-success", {
+            toolId: "calculator",
+            backend: "desmos",
+            operation: "desmos-script-load",
+            duration: Date.now() - o
+          });
+        } catch (t) {
+          throw await this.emitTelemetry("pie-tool-library-load-error", {
+            toolId: "calculator",
+            backend: "desmos",
+            operation: "desmos-script-load",
+            duration: Date.now() - o,
+            errorType: "ToolLibraryLoadError",
+            message: t instanceof Error ? t.message : String(t)
+          }), t;
+        }
+      }
+      this.initialized = !0;
     }
   }
   /**
    * Create a calculator instance
    */
-  async createCalculator(e, t, s) {
+  async createCalculator(e, o, t) {
     if (this.initialized || await this.initialize(), !this.supportsType(e))
       throw new Error(`Desmos does not support calculator type: ${e}`);
-    return new c(this, e, t, s, this.apiKey);
+    return new c(this, e, o, t, this.apiKey);
   }
   /**
    * Check if type is supported
@@ -73,7 +124,7 @@ Recommended: Use proxyEndpoint for production, apiKey for development only.`);
    * Cleanup
    */
   destroy() {
-    this.initialized = !1;
+    this.initialized = !1, this.onTelemetry = void 0;
   }
   /**
    * Get provider capabilities
@@ -91,17 +142,17 @@ Recommended: Use proxyEndpoint for production, apiKey for development only.`);
   }
 }
 class c {
-  constructor(e, t, s, r, a) {
-    if (o(this, "provider"), o(this, "type"), o(this, "Desmos"), o(this, "calculator"), o(this, "container"), this.provider = e, this.type = t, this.container = s, this.Desmos = window.Desmos, !this.Desmos)
+  constructor(e, o, t, i, a) {
+    if (s(this, "provider"), s(this, "type"), s(this, "Desmos"), s(this, "calculator"), s(this, "container"), this.provider = e, this.type = o, this.container = t, this.Desmos = window.Desmos, !this.Desmos)
       throw new Error("Desmos API not available");
-    this._initializeCalculator(r, a);
+    this._initializeCalculator(i, a);
   }
-  _initializeCalculator(e, t) {
-    const s = {
+  _initializeCalculator(e, o) {
+    const t = {
       ...e?.desmos || {},
-      apiKey: t || e?.desmos?.apiKey
+      apiKey: o || e?.desmos?.apiKey
     };
-    switch (e?.restrictedMode && Object.assign(s, {
+    switch (e?.restrictedMode && Object.assign(t, {
       expressionsTopbar: !1,
       settingsMenu: !1,
       zoomButtons: !1,
@@ -109,13 +160,13 @@ class c {
       links: !1
     }), this.type) {
       case "graphing":
-        this.calculator = this.Desmos.GraphingCalculator(this.container, s);
+        this.calculator = this.Desmos.GraphingCalculator(this.container, t);
         break;
       case "scientific":
-        this.calculator = this.Desmos.ScientificCalculator(this.container, s);
+        this.calculator = this.Desmos.ScientificCalculator(this.container, t);
         break;
       case "basic":
-        this.calculator = this.Desmos.FourFunctionCalculator(this.container, s);
+        this.calculator = this.Desmos.FourFunctionCalculator(this.container, t);
         break;
       default:
         throw new Error(`Unsupported calculator type: ${this.type}`);
@@ -132,23 +183,23 @@ class c {
   setValue(e) {
     if (this.type === "graphing" && this.calculator.setState)
       try {
-        const t = JSON.parse(e);
-        this.calculator.setState(t);
-      } catch (t) {
-        console.error("[DesmosCalculator] Failed to set state:", t);
+        const o = JSON.parse(e);
+        this.calculator.setState(o);
+      } catch (o) {
+        console.error("[DesmosCalculator] Failed to set state:", o);
       }
   }
   clear() {
     this.calculator.setBlank && this.calculator.setBlank();
   }
   async evaluate(e) {
-    return this.type === "graphing" ? new Promise((t) => {
-      const s = `eval_${Date.now()}`;
-      this.calculator.setExpression({ id: s, latex: e }), setTimeout(() => {
-        const r = this.calculator.HelperExpression({
+    return this.type === "graphing" ? new Promise((o) => {
+      const t = `eval_${Date.now()}`;
+      this.calculator.setExpression({ id: t, latex: e }), setTimeout(() => {
+        const i = this.calculator.HelperExpression({
           latex: e
         }).numericValue || e;
-        this.calculator.removeExpression({ id: s }), t(String(r));
+        this.calculator.removeExpression({ id: t }), o(String(i));
       }, 100);
     }) : e;
   }