@spatialwalk/avatarkit-rtc 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/index14.js

@@ -1,48 +1,29 @@
-import { logger } from "./index7.js";
-function createAnimationReceiverTransform(workerOrUrl, onEvent) {
-  const worker = workerOrUrl instanceof Worker ? workerOrUrl : new Worker(workerOrUrl, { type: "module", name: "animation-receiver" });
-  worker.onmessage = (event) => {
-    const { type } = event.data;
-    if (type === "ready") {
-      onEvent == null ? void 0 : onEvent({ type: "ready", operation: "receiver" });
-    } else if (type === "metadata") {
-      onEvent == null ? void 0 : onEvent(event.data);
-    } else if (type === "animation") {
-      onEvent == null ? void 0 : onEvent({
-        type: "animation",
-        protobufData: event.data.protobufData,
-        flags: event.data.flags,
-        isIdle: event.data.isIdle,
-        isStart: event.data.isStart,
-        isEnd: event.data.isEnd,
-        frameSeq: event.data.frameSeq,
-        isRecovered: event.data.isRecovered
-      });
-    } else if (type === "transition") {
-      onEvent == null ? void 0 : onEvent({
-        type: "transition",
-        protobufData: event.data.protobufData,
-        flags: event.data.flags
-      });
-    } else if (type === "transitionEnd") {
-      onEvent == null ? void 0 : onEvent({
-        type: "transitionEnd",
-        protobufData: event.data.protobufData,
-        flags: event.data.flags
-      });
-    } else if (type === "idleStart") {
-      onEvent == null ? void 0 : onEvent({ type: "idleStart" });
-    } else if (type === "error") {
-      logger.error("AnimationTransform", "Error:", event.data.error);
-      onEvent == null ? void 0 : onEvent(event.data);
-    }
-  };
-  worker.onerror = (event) => {
-    logger.error("AnimationTransform", "Worker error:", event.message);
-  };
-  return new RTCRtpScriptTransform(worker, { operation: "receiver" });
+const jsContent = 'const VP8_FRAME_HEADER_SIZE = 10;\nconst METADATA_FIXED_HEADER_SIZE = 5;\nconst PACKET_FLAG_IDLE = 1;\nconst PACKET_FLAG_START = 2;\nconst PACKET_FLAG_END = 4;\nconst PACKET_FLAG_GZIPPED = 8;\nconst PACKET_FLAG_TRANSITION = 16;\nconst PACKET_FLAG_TRANSITION_END = 32;\nconst PACKET_FLAG_REDUNDANT = 64;\nlet receiverMetaCount = 0;\nlet lastLogTime = 0;\nlet totalFrames = 0;\nlet framesWithMeta = 0;\nlet wasIdle = false;\nlet isInStartTransition = false;\nlet isInEndTransition = false;\nlet lastReceivedTimestamp = null;\nlet framesRecovered = 0;\nlet framesLost = 0;\nconst EXPECTED_TIMESTAMP_INCREMENT = 3600;\nlet lastRenderedSeq = -1;\nlet framesOutOfOrder = 0;\nlet framesDuplicate = 0;\nlet framesDropped = 0;\nlet framesSent = 0;\nfunction parseMetadataHeader(data) {\n  if (data.byteLength < METADATA_FIXED_HEADER_SIZE) return null;\n  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n  const flags = data[0];\n  const msgLen = view.getUint32(1, true);\n  const headerSize = METADATA_FIXED_HEADER_SIZE + msgLen;\n  if (data.byteLength < headerSize) return null;\n  const compressedData = data.slice(\n    METADATA_FIXED_HEADER_SIZE,\n    METADATA_FIXED_HEADER_SIZE + msgLen\n  );\n  const hasRedundant = (flags & PACKET_FLAG_REDUNDANT) !== 0;\n  return {\n    meta: {\n      flags,\n      protobufLength: msgLen,\n      protobufData: compressedData,\n      // This is still compressed at this point\n      hasRedundant,\n      redundantLength: 0,\n      // Will be determined after decompression\n      redundantData: null\n      // Will be extracted after decompression\n    },\n    headerSize\n  };\n}\nfunction isIdlePacket(flags) {\n  return (flags & PACKET_FLAG_IDLE) !== 0;\n}\nfunction isStartPacket(flags) {\n  return (flags & PACKET_FLAG_START) !== 0;\n}\nfunction isEndPacket(flags) {\n  return (flags & PACKET_FLAG_END) !== 0;\n}\nfunction isGzipped(flags) {\n  return (flags & PACKET_FLAG_GZIPPED) !== 0;\n}\nfunction isTransitionPacket(flags) {\n  return (flags & PACKET_FLAG_TRANSITION) !== 0;\n}\nfunction isTransitionEndPacket(flags) {\n  return (flags & PACKET_FLAG_TRANSITION_END) !== 0;\n}\nasync function decompressGzip(data) {\n  const ds = new DecompressionStream("gzip");\n  const writer = ds.writable.getWriter();\n  const copy = new Uint8Array(data);\n  writer.write(copy);\n  writer.close();\n  const reader = ds.readable.getReader();\n  const chunks = [];\n  let totalLength = 0;\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    chunks.push(value);\n    totalLength += value.length;\n  }\n  const result = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.length;\n  }\n  return result;\n}\nlet totalCompressedBytes = 0;\nlet totalUncompressedBytes = 0;\nfunction parseALRPayload(decompressed, hasRedundant) {\n  if (decompressed.byteLength < 4) return null;\n  const view = new DataView(\n    decompressed.buffer,\n    decompressed.byteOffset,\n    decompressed.byteLength\n  );\n  let offset = 0;\n  const frameSeq = view.getUint32(offset, true);\n  offset += 4;\n  if (!hasRedundant) {\n    const currentData2 = decompressed.slice(offset);\n    return { frameSeq, currentData: currentData2, prev1Data: null, prev2Data: null };\n  }\n  if (decompressed.byteLength < offset + 4) return null;\n  const currentLen = view.getUint32(offset, true);\n  offset += 4;\n  if (decompressed.byteLength < offset + currentLen) return null;\n  const currentData = decompressed.slice(offset, offset + currentLen);\n  offset += currentLen;\n  let prev1Data = null;\n  if (decompressed.byteLength >= offset + 4) {\n    const prev1Len = view.getUint32(offset, true);\n    offset += 4;\n    if (prev1Len > 0 && decompressed.byteLength >= offset + prev1Len) {\n      prev1Data = decompressed.slice(offset, offset + prev1Len);\n      offset += prev1Len;\n    }\n  }\n  let prev2Data = null;\n  if (decompressed.byteLength >= offset + 4) {\n    const prev2Len = view.getUint32(offset, true);\n    offset += 4;\n    if (prev2Len > 0 && decompressed.byteLength >= offset + prev2Len) {\n      prev2Data = decompressed.slice(offset, offset + prev2Len);\n    }\n  }\n  return { frameSeq, currentData, prev1Data, prev2Data };\n}\nfunction sendAnimationToMainThread(protobufData, flags, frameSeq, isRecovered = false) {\n  const isIdle = isIdlePacket(flags);\n  const isStart = isStartPacket(flags);\n  const isEnd = isEndPacket(flags);\n  if (frameSeq <= lastRenderedSeq && lastRenderedSeq !== -1 && !isStart) {\n    if (frameSeq === lastRenderedSeq) {\n      framesDuplicate++;\n    } else {\n      framesOutOfOrder++;\n    }\n    return false;\n  }\n  if (lastRenderedSeq !== -1 && frameSeq > lastRenderedSeq + 1 && !isStart) {\n    const gap = frameSeq - lastRenderedSeq - 1;\n    framesDropped += gap;\n  }\n  framesSent++;\n  lastRenderedSeq = frameSeq;\n  const protobufBuffer = new ArrayBuffer(protobufData.byteLength);\n  new Uint8Array(protobufBuffer).set(protobufData);\n  self.postMessage(\n    {\n      type: "animation",\n      flags,\n      isIdle,\n      isStart,\n      isEnd,\n      isRecovered,\n      frameSeq,\n      protobufData: protobufBuffer\n    },\n    { transfer: [protobufBuffer] }\n  );\n  return true;\n}\nfunction receiverTransform(frame, _controller) {\n  totalFrames++;\n  const data = new Uint8Array(frame.data);\n  const currentTimestamp = frame.timestamp;\n  if (data.length <= VP8_FRAME_HEADER_SIZE) {\n    return;\n  }\n  const animData = data.subarray(VP8_FRAME_HEADER_SIZE);\n  const parsed = parseMetadataHeader(animData);\n  if (parsed) {\n    const { meta } = parsed;\n    framesWithMeta++;\n    receiverMetaCount++;\n    const isIdle = isIdlePacket(meta.flags);\n    const isStart = isStartPacket(meta.flags);\n    const isEnd = isEndPacket(meta.flags);\n    if (lastReceivedTimestamp !== null && !isIdle && !isStart) {\n      const timestampDelta = currentTimestamp - lastReceivedTimestamp;\n      if (timestampDelta > EXPECTED_TIMESTAMP_INCREMENT * 1.5) {\n        const missedFrames = Math.round(timestampDelta / EXPECTED_TIMESTAMP_INCREMENT) - 1;\n        framesLost += missedFrames;\n        if (meta.hasRedundant && isGzipped(meta.flags)) {\n          totalCompressedBytes += meta.protobufData.byteLength;\n          decompressGzip(meta.protobufData).then((decompressed) => {\n            totalUncompressedBytes += decompressed.byteLength;\n            const parsed2 = parseALRPayload(decompressed, true);\n            if (parsed2) {\n              const currentSeq = parsed2.frameSeq;\n              const framesToRecover = [];\n              if (missedFrames >= 2 && parsed2.prev2Data) {\n                framesToRecover.push({\n                  data: parsed2.prev2Data,\n                  seq: currentSeq - 2\n                });\n              }\n              if (missedFrames >= 1 && parsed2.prev1Data) {\n                framesToRecover.push({\n                  data: parsed2.prev1Data,\n                  seq: currentSeq - 1\n                });\n              }\n              const recovered = framesToRecover.length;\n              if (recovered > 0) {\n                framesRecovered += recovered;\n                for (const frame2 of framesToRecover) {\n                  sendAnimationToMainThread(\n                    frame2.data,\n                    meta.flags & ~PACKET_FLAG_REDUNDANT,\n                    frame2.seq,\n                    true\n                  );\n                }\n              }\n              sendAnimationToMainThread(\n                parsed2.currentData,\n                meta.flags & ~PACKET_FLAG_REDUNDANT,\n                currentSeq,\n                false\n              );\n            }\n          }).catch((err) => {\n            console.error(`[Animation Worker] ALR decompression error:`, err);\n          });\n          lastReceivedTimestamp = currentTimestamp;\n          return;\n        }\n      }\n    }\n    if (!isIdle) {\n      lastReceivedTimestamp = currentTimestamp;\n    }\n    if (isStart) {\n      lastReceivedTimestamp = currentTimestamp;\n      framesRecovered = 0;\n      framesLost = 0;\n      lastRenderedSeq = -1;\n      framesOutOfOrder = 0;\n      framesDuplicate = 0;\n      framesDropped = 0;\n      framesSent = 0;\n    }\n    const isTransition = isTransitionPacket(meta.flags);\n    const isTransitionEnd = isTransitionEndPacket(meta.flags);\n    if (isIdle) {\n      if (!wasIdle) {\n        self.postMessage({ type: "idleStart" });\n        wasIdle = true;\n      }\n      isInStartTransition = false;\n      isInEndTransition = false;\n    } else if (isTransition && meta.protobufLength > 0) {\n      wasIdle = false;\n      if (!isInStartTransition) {\n        isInStartTransition = true;\n        isInEndTransition = false;\n        const gzipped = isGzipped(meta.flags);\n        if (gzipped) {\n          totalCompressedBytes += meta.protobufData.byteLength;\n          decompressGzip(meta.protobufData).then((decompressed) => {\n            totalUncompressedBytes += decompressed.byteLength;\n            const protobufBuffer = new ArrayBuffer(decompressed.byteLength);\n            new Uint8Array(protobufBuffer).set(decompressed);\n            self.postMessage(\n              {\n                type: "transition",\n                flags: meta.flags,\n                protobufData: protobufBuffer\n              },\n              { transfer: [protobufBuffer] }\n            );\n          }).catch((err) => {\n            console.error(\n              `[Animation Worker] Gzip decompress error (transition):`,\n              err\n            );\n          });\n        } else {\n          const protobufBuffer = new ArrayBuffer(meta.protobufData.byteLength);\n          new Uint8Array(protobufBuffer).set(meta.protobufData);\n          self.postMessage(\n            {\n              type: "transition",\n              flags: meta.flags,\n              protobufData: protobufBuffer\n            },\n            { transfer: [protobufBuffer] }\n          );\n        }\n      }\n    } else if (isTransitionEnd && meta.protobufLength > 0) {\n      if (!isInEndTransition) {\n        isInEndTransition = true;\n        isInStartTransition = false;\n        const gzipped = isGzipped(meta.flags);\n        if (gzipped) {\n          totalCompressedBytes += meta.protobufData.byteLength;\n          decompressGzip(meta.protobufData).then((decompressed) => {\n            totalUncompressedBytes += decompressed.byteLength;\n            const protobufBuffer = new ArrayBuffer(decompressed.byteLength);\n            new Uint8Array(protobufBuffer).set(decompressed);\n            self.postMessage(\n              {\n                type: "transitionEnd",\n                flags: meta.flags,\n                protobufData: protobufBuffer\n              },\n              { transfer: [protobufBuffer] }\n            );\n          }).catch((err) => {\n            console.error(\n              `[Animation Worker] Gzip decompress error (transitionEnd):`,\n              err\n            );\n          });\n        } else {\n          const protobufBuffer = new ArrayBuffer(meta.protobufData.byteLength);\n          new Uint8Array(protobufBuffer).set(meta.protobufData);\n          self.postMessage(\n            {\n              type: "transitionEnd",\n              flags: meta.flags,\n              protobufData: protobufBuffer\n            },\n            { transfer: [protobufBuffer] }\n          );\n        }\n      }\n    } else if (meta.protobufLength > 0) {\n      if (wasIdle) {\n        wasIdle = false;\n      }\n      isInStartTransition = false;\n      isInEndTransition = false;\n      const gzipped = isGzipped(meta.flags);\n      if (gzipped) {\n        totalCompressedBytes += meta.protobufData.byteLength;\n        decompressGzip(meta.protobufData).then((decompressed) => {\n          totalUncompressedBytes += decompressed.byteLength;\n          const parsed2 = parseALRPayload(decompressed, meta.hasRedundant);\n          if (parsed2) {\n            sendAnimationToMainThread(\n              parsed2.currentData,\n              meta.flags & ~PACKET_FLAG_REDUNDANT,\n              parsed2.frameSeq,\n              false\n            );\n          }\n        }).catch(() => {\n        });\n      } else {\n        const protobufBuffer = new ArrayBuffer(meta.protobufData.byteLength);\n        new Uint8Array(protobufBuffer).set(meta.protobufData);\n        self.postMessage(\n          {\n            type: "animation",\n            flags: meta.flags,\n            isIdle: false,\n            isStart,\n            isEnd,\n            frameSeq: -1,\n            // Unknown sequence\n            protobufData: protobufBuffer\n          },\n          { transfer: [protobufBuffer] }\n        );\n      }\n    }\n    const now = performance.now();\n    if (now - lastLogTime > 1e3) {\n      lastLogTime = now;\n      self.postMessage({\n        type: "metadata",\n        protobufLength: meta.protobufLength,\n        framesPerSec: receiverMetaCount,\n        totalFrames,\n        framesWithMeta,\n        framesLost,\n        framesRecovered,\n        totalCompressedBytes,\n        totalUncompressedBytes,\n        framesOutOfOrder,\n        framesDuplicate,\n        framesDropped,\n        framesSent,\n        lastRenderedSeq\n      });\n      receiverMetaCount = 0;\n    }\n  }\n}\nself.onrtctransform = (event) => {\n  const transformer = event.transformer;\n  const options = transformer.options;\n  try {\n    if (options.operation === "receiver") {\n      receiverMetaCount = 0;\n      lastLogTime = 0;\n      totalFrames = 0;\n      framesWithMeta = 0;\n      wasIdle = false;\n      isInStartTransition = false;\n      isInEndTransition = false;\n      lastReceivedTimestamp = null;\n      framesRecovered = 0;\n      framesLost = 0;\n      lastRenderedSeq = -1;\n      framesOutOfOrder = 0;\n      framesDuplicate = 0;\n      framesDropped = 0;\n      framesSent = 0;\n      transformer.readable.pipeThrough(new TransformStream({ transform: receiverTransform })).pipeTo(transformer.writable).catch((err) => {\n        console.error("[Animation Worker] Pipeline error:", err);\n        self.postMessage({\n          type: "error",\n          error: `Animation receiver pipe error: ${err}`\n        });\n      });\n      self.postMessage({ type: "ready", operation: "receiver" });\n    }\n  } catch (err) {\n    console.error("[Animation Worker] Setup error:", err);\n    self.postMessage({\n      type: "error",\n      error: `Animation transform setup error: ${err}`\n    });\n  }\n};\nself.onmessage = (event) => {\n  const { type } = event.data;\n  if (type === "init") {\n    self.postMessage({ type: "initialized" });\n  }\n};\n//# sourceMappingURL=animation-worker-DOGeTjF0.js.map\n';
+const blob = typeof self !== "undefined" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", jsContent], { type: "text/javascript;charset=utf-8" });
+function WorkerWrapper(options) {
+  let objURL;
+  try {
+    objURL = blob && (self.URL || self.webkitURL).createObjectURL(blob);
+    if (!objURL) throw "";
+    const worker = new Worker(objURL, {
+      type: "module",
+      name: options == null ? void 0 : options.name
+    });
+    worker.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(objURL);
+    });
+    return worker;
+  } catch (e) {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(jsContent),
+      {
+        type: "module",
+        name: options == null ? void 0 : options.name
+      }
+    );
+  }
 }
 export {
-  createAnimationReceiverTransform
+  WorkerWrapper as default
 };
 //# sourceMappingURL=index14.js.map

package/dist/index14.js.map

@@ -1 +1 @@
-{"version":3,"file":"index14.js","sources":["../src/providers/livekit/animation-transform.ts"],"sourcesContent":["/**\n * Animation Transform for Video Track.\n *\n * Uses RTCRtpScriptTransform to extract animation data from the video track.\n * The video track carries animation data in binary format (not actual video).\n *\n * @internal\n * @packageDocumentation\n */\n\nimport type { AnimationTransformEvent } from './types';\nimport { logger } from '../../utils';\n\nexport { METADATA_FIXED_HEADER_SIZE, PACKET_FLAGS } from './types';\n\n/**\n * Check if browser supports RTCRtpScriptTransform.\n * @returns true if RTCRtpScriptTransform is available\n * @internal\n */\nexport function supportsScriptTransform(): boolean {\n  return typeof RTCRtpScriptTransform !== 'undefined';\n}\n\n/**\n * Create RTCRtpScriptTransform for animation receiver (video track).\n * @param workerOrUrl - Either a Worker instance or a URL string to the worker script\n * @param onEvent - Optional callback for transform events\n * @returns RTCRtpScriptTransform instance\n * @internal\n */\nexport function createAnimationReceiverTransform(\n  workerOrUrl: Worker | string | URL,\n  onEvent?: (evt: AnimationTransformEvent) => void\n): RTCRtpScriptTransform {\n  // Create worker if URL is provided, otherwise use the provided Worker\n  const worker =\n    workerOrUrl instanceof Worker\n      ? workerOrUrl\n      : new Worker(workerOrUrl, { type: 'module', name: 'animation-receiver' });\n\n  worker.onmessage = (event) => {\n    const { type } = event.data;\n\n    if (type === 'ready') {\n      onEvent?.({ type: 'ready', operation: 'receiver' });\n    } else if (type === 'metadata') {\n      onEvent?.(event.data);\n    } else if (type === 'animation') {\n      onEvent?.({\n        type: 'animation',\n        protobufData: event.data.protobufData,\n        flags: event.data.flags,\n        isIdle: event.data.isIdle,\n        isStart: event.data.isStart,\n        isEnd: event.data.isEnd,\n        frameSeq: event.data.frameSeq,\n        isRecovered: event.data.isRecovered,\n      });\n    } else if (type === 'transition') {\n      onEvent?.({\n        type: 'transition',\n        protobufData: event.data.protobufData,\n        flags: event.data.flags,\n      });\n    } else if (type === 'transitionEnd') {\n      onEvent?.({\n        type: 'transitionEnd',\n        protobufData: event.data.protobufData,\n        flags: event.data.flags,\n      });\n    } else if (type === 'idleStart') {\n      onEvent?.({ type: 'idleStart' });\n    } else if (type === 'error') {\n      logger.error('AnimationTransform', 'Error:', event.data.error);\n      onEvent?.(event.data);\n    }\n  };\n\n  worker.onerror = (event) => {\n    logger.error('AnimationTransform', 'Worker error:', event.message);\n  };\n\n  return new RTCRtpScriptTransform(worker, { operation: 'receiver' });\n}\n"],"names":[],"mappings":";AA+BO,SAAS,iCACd,aACA,SACuB;AAEvB,QAAM,SACJ,uBAAuB,SACnB,cACA,IAAI,OAAO,aAAa,EAAE,MAAM,UAAU,MAAM,qBAAA,CAAsB;AAE5E,SAAO,YAAY,CAAC,UAAU;AAC5B,UAAM,EAAE,SAAS,MAAM;AAEvB,QAAI,SAAS,SAAS;AACpB,yCAAU,EAAE,MAAM,SAAS,WAAW;IACxC,WAAW,SAAS,YAAY;AAC9B,yCAAU,MAAM;AAAA,IAClB,WAAW,SAAS,aAAa;AAC/B,yCAAU;AAAA,QACR,MAAM;AAAA,QACN,cAAc,MAAM,KAAK;AAAA,QACzB,OAAO,MAAM,KAAK;AAAA,QAClB,QAAQ,MAAM,KAAK;AAAA,QACnB,SAAS,MAAM,KAAK;AAAA,QACpB,OAAO,MAAM,KAAK;AAAA,QAClB,UAAU,MAAM,KAAK;AAAA,QACrB,aAAa,MAAM,KAAK;AAAA,MAAA;AAAA,IAE5B,WAAW,SAAS,cAAc;AAChC,yCAAU;AAAA,QACR,MAAM;AAAA,QACN,cAAc,MAAM,KAAK;AAAA,QACzB,OAAO,MAAM,KAAK;AAAA,MAAA;AAAA,IAEtB,WAAW,SAAS,iBAAiB;AACnC,yCAAU;AAAA,QACR,MAAM;AAAA,QACN,cAAc,MAAM,KAAK;AAAA,QACzB,OAAO,MAAM,KAAK;AAAA,MAAA;AAAA,IAEtB,WAAW,SAAS,aAAa;AAC/B,yCAAU,EAAE,MAAM;IACpB,WAAW,SAAS,SAAS;AAC3B,aAAO,MAAM,sBAAsB,UAAU,MAAM,KAAK,KAAK;AAC7D,yCAAU,MAAM;AAAA,IAClB;AAAA,EACF;AAEA,SAAO,UAAU,CAAC,UAAU;AAC1B,WAAO,MAAM,sBAAsB,iBAAiB,MAAM,OAAO;AAAA,EACnE;AAEA,SAAO,IAAI,sBAAsB,QAAQ,EAAE,WAAW,YAAY;AACpE;"}
+{"version":3,"file":"index14.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index2.js

@@ -2,7 +2,8 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { AnimationHandler } from "./index6.js";
-import { configureLogger } from "./index7.js";
+import { configureLogger, logger } from "./index7.js";
+import { initializeTelemetry, trackEvent, flushTelemetry } from "./index8.js";
 class AvatarPlayer {
   /**
    * Create a new AvatarPlayer instance.
@@ -22,14 +23,53 @@ class AvatarPlayer {
     /** @internal */
     __publicField(this, "localAudioTrack", null);
     /** @internal */
-    __publicField(this, "mediaStream", null);
+    __publicField(this, "microphoneStream", null);
+    /** @internal */
+    __publicField(this, "eventHandlers", /* @__PURE__ */ new Map());
+    /** @internal */
+    __publicField(this, "lastConnectionConfig", null);
+    /** @internal */
+    __publicField(this, "isReconnecting", false);
+    /** @internal */
+    __publicField(this, "hasActiveAnimationSession", false);
+    /** @internal */
+    __publicField(this, "isTrackingPrimed", false);
+    /** @internal */
+    __publicField(this, "connectStartTime", 0);
+    /** @internal */
+    __publicField(this, "sessionStartTime", 0);
+    /** @internal */
+    __publicField(this, "stallCount", 0);
+    /** @internal */
+    __publicField(this, "reconnectCount", 0);
+    /** @internal */
+    __publicField(this, "conversationCount", 0);
+    /** @internal */
+    __publicField(this, "providerName", "");
     this.provider = provider;
     this.avatarView = avatarView;
+    this.providerName = provider.name;
     if ((options == null ? void 0 : options.logLevel) !== void 0) {
       configureLogger({ level: options.logLevel });
     }
+    initializeTelemetry({ sdkVersion: "1.0.0-beta.10" });
+    logger.info("AvatarPlayer", `SDK version: ${"1.0.0-beta.10"}`);
     const renderer = this.createRendererAdapter();
-    this.animationHandler = new AnimationHandler(renderer);
+    this.animationHandler = new AnimationHandler(renderer, {
+      enableJitterBuffer: options == null ? void 0 : options.enableJitterBuffer,
+      maxBufferDelayMs: options == null ? void 0 : options.maxBufferDelayMs,
+      providerName: this.providerName,
+      onStreamStalled: () => {
+        this.hasActiveAnimationSession = false;
+        this.isTrackingPrimed = false;
+        this.stallCount++;
+        trackEvent("rtc_stream_stalled", "warning", {
+          provider: this.providerName,
+          session_elapsed: this.sessionStartTime ? Date.now() - this.sessionStartTime : 0
+        });
+        this.emit("stalled");
+      }
+    });
     this.setupProviderEvents();
   }
   /**
@@ -47,9 +87,39 @@ class AvatarPlayer {
     if (this._isConnected) {
       throw new Error("Already connected. Please disconnect first.");
     }
-    await this.setupAnimationCallbacks();
-    await this.provider.connect(config);
-    this._isConnected = true;
+    this.lastConnectionConfig = config;
+    this.connectStartTime = performance.now();
+    trackEvent("rtc_connect_start", "info", {
+      provider: this.providerName
+    });
+    try {
+      await this.setupAnimationCallbacks();
+      await this.provider.connect(config);
+      this._isConnected = true;
+      this.sessionStartTime = Date.now();
+      this.stallCount = 0;
+      this.reconnectCount = 0;
+      this.conversationCount = 0;
+      trackEvent("rtc_connect_success", "info", {
+        provider: this.providerName,
+        duration: Math.round(performance.now() - this.connectStartTime)
+      });
+    } catch (error) {
+      trackEvent("rtc_connect_failed", "error", {
+        provider: this.providerName,
+        reason: error instanceof Error ? error.message : String(error),
+        duration: Math.round(performance.now() - this.connectStartTime)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Pre-warm a future RTC connection when the provider supports it.
+   * This is best-effort and does not change the connected state.
+   */
+  async prepareConnection(config) {
+    var _a, _b;
+    await ((_b = (_a = this.provider).prepareConnection) == null ? void 0 : _b.call(_a, config));
   }
   /**
    * Disconnect from RTC server.
@@ -59,40 +129,132 @@ class AvatarPlayer {
     if (!this._isConnected) {
       return;
     }
-    if (this.localAudioTrack) {
+    if (this.microphoneStream) {
       await this.stopPublishing();
+    } else if (this.localAudioTrack) {
+      await this.unpublishAudio();
     }
+    const sessionSummary = this.animationHandler.getSessionSummary();
     await this.provider.disconnect();
     this.animationHandler.dispose();
     this._isConnected = false;
+    const sessionDuration = this.sessionStartTime ? Date.now() - this.sessionStartTime : 0;
+    trackEvent("rtc_session_summary", "info", {
+      provider: this.providerName,
+      total_duration_ms: sessionDuration,
+      total_frames: sessionSummary.totalFrames,
+      total_lost: sessionSummary.totalLost,
+      total_recovered: sessionSummary.totalRecovered,
+      total_dropped: sessionSummary.totalDropped,
+      avg_fps: sessionSummary.avgFps,
+      stall_count: this.stallCount,
+      reconnect_count: this.reconnectCount,
+      conversation_count: this.conversationCount
+    });
+    trackEvent("rtc_disconnected", "info", {
+      provider: this.providerName,
+      session_duration: sessionDuration
+    });
+    flushTelemetry();
   }
   /**
-   * Start publishing microphone audio to the RTC server.
-   * Requests microphone permission and starts publishing.
-   * @throws Error if permission denied or no microphone found
+   * Publish an audio track to the RTC server.
+   *
+   * The audio source is controlled externally - you can pass any audio track:
+   * - Microphone: `getUserMedia({ audio: true })`
+   * - Browser audio: `audioElement.captureStream()`
+   * - Web Audio API: `audioContext.createMediaStreamDestination().stream`
+   * - Screen share audio: `getDisplayMedia({ audio: true })`
+   *
+   * @param track - MediaStreamTrack to publish (must be an audio track)
+   * @throws Error if not connected or track is invalid
+   *
+   * @example
+   * ```typescript
+   * // Microphone
+   * const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+   * await player.publishAudio(stream.getAudioTracks()[0]);
+   *
+   * // Browser audio element
+   * const audioEl = document.querySelector('audio');
+   * const stream = audioEl.captureStream();
+   * await player.publishAudio(stream.getAudioTracks()[0]);
+   * ```
    */
-  async startPublishing() {
+  async publishAudio(track) {
+    if (!this._isConnected) {
+      throw new Error("Not connected. Please call connect() first.");
+    }
+    if (track.kind !== "audio") {
+      throw new Error("Invalid track: expected audio track");
+    }
     if (this.localAudioTrack) {
-      return;
+      await this.unpublishAudio();
+    }
+    this.localAudioTrack = track;
+    try {
+      await this.provider.publishAudioTrack(track);
+    } catch (error) {
+      this.localAudioTrack = null;
+      trackEvent("rtc_audio_publish_failed", "error", {
+        provider: this.providerName,
+        description: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    this.mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
-    this.localAudioTrack = this.mediaStream.getAudioTracks()[0];
-    await this.provider.publishAudioTrack(this.localAudioTrack);
   }
   /**
-   * Stop publishing microphone audio.
+   * Stop publishing audio.
+   * Note: This does NOT stop the track - the caller is responsible for managing the track lifecycle.
    */
-  async stopPublishing() {
+  async unpublishAudio() {
     if (!this.localAudioTrack) {
       return;
     }
     await this.provider.unpublishAudioTrack();
-    this.localAudioTrack.stop();
     this.localAudioTrack = null;
-    if (this.mediaStream) {
-      this.mediaStream.getTracks().forEach((track) => track.stop());
-      this.mediaStream = null;
+  }
+  /**
+   * Start publishing microphone audio.
+   *
+   * This requests microphone permission and publishes it to the RTC session.
+   * For custom audio sources (e.g., audio files), use `publishAudio(track)` instead.
+   *
+   * @throws Error if not connected, permission denied, or no microphone found
+   *
+   * @example
+   * ```typescript
+   * await player.startPublishing();
+   * // ... later
+   * await player.stopPublishing();
+   * ```
+   */
+  async startPublishing() {
+    if (!this._isConnected) {
+      throw new Error("Not connected. Please call connect() first.");
     }
+    if (this.microphoneStream) {
+      return;
+    }
+    this.microphoneStream = await navigator.mediaDevices.getUserMedia({
+      audio: true
+    });
+    const track = this.microphoneStream.getAudioTracks()[0];
+    await this.publishAudio(track);
+  }
+  /**
+   * Stop publishing microphone audio and release the microphone.
+   *
+   * This stops the microphone track and releases the device.
+   * If you used `publishAudio()` with a custom track, use `unpublishAudio()` instead.
+   */
+  async stopPublishing() {
+    if (!this.microphoneStream) {
+      return;
+    }
+    await this.unpublishAudio();
+    this.microphoneStream.getTracks().forEach((track) => track.stop());
+    this.microphoneStream = null;
   }
   /**
    * Get current connection state.
@@ -103,19 +265,19 @@ class AvatarPlayer {
   }
   /**
    * Get the native RTC client object.
-   * 
+   *
    * Returns the underlying RTC client for advanced use cases:
    * - LiveKit: Returns the Room instance
    * - Agora: Returns the IAgoraRTCClient instance
-   * 
+   *
    * @returns The native RTC client object, or null if not connected
-   * 
+   *
    * @example
    * ```typescript
    * // Access LiveKit Room
    * const room = player.getNativeClient() as Room;
    * console.log('Participants:', room?.remoteParticipants.size);
-   * 
+   *
    * // Access Agora Client
    * const client = player.getNativeClient() as IAgoraRTCClient;
    * console.log('State:', client?.connectionState);
@@ -126,11 +288,18 @@ class AvatarPlayer {
   }
   /**
    * Add event listener.
-   * @param event - Event name ('connected', 'disconnected', 'error', etc.)
+   * @param event - Event name ('connected', 'disconnected', 'error', 'stalled', etc.)
    * @param handler - Event handler function
    */
   on(event, handler) {
-    this.provider.on(event, handler);
+    if (event === "stalled") {
+      if (!this.eventHandlers.has(event)) {
+        this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+      }
+      this.eventHandlers.get(event).add(handler);
+    } else {
+      this.provider.on(event, handler);
+    }
   }
   /**
    * Remove event listener.
@@ -138,7 +307,79 @@ class AvatarPlayer {
    * @param handler - Event handler function (must be same reference as added)
    */
   off(event, handler) {
-    this.provider.off(event, handler);
+    var _a;
+    if (event === "stalled") {
+      (_a = this.eventHandlers.get(event)) == null ? void 0 : _a.delete(handler);
+    } else {
+      this.provider.off(event, handler);
+    }
+  }
+  /**
+   * Emit an event to local listeners.
+   * @internal
+   */
+  emit(event, ...args) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(...args);
+        } catch (e) {
+          logger.error("AvatarPlayer", `Error in ${event} handler:`, e);
+        }
+      });
+    }
+  }
+  /**
+   * Reconnect to RTC server using the last connection configuration.
+   * Useful for recovering from connection issues or stream stalls.
+   *
+   * @example
+   * ```typescript
+   * player.on('stalled', async () => {
+   *   console.log('Stream stalled, attempting reconnection...');
+   *   await player.reconnect();
+   * });
+   * ```
+   *
+   * @throws Error if no previous connection config exists or reconnection fails
+   */
+  async reconnect() {
+    if (this.isReconnecting) {
+      logger.warn("AvatarPlayer", "Already attempting reconnection, skipping");
+      return;
+    }
+    if (!this.lastConnectionConfig) {
+      throw new Error(
+        "Cannot reconnect: no previous connection. Call connect() first."
+      );
+    }
+    this.isReconnecting = true;
+    this.reconnectCount++;
+    logger.info("AvatarPlayer", "Attempting reconnection...");
+    const reconnectStart = performance.now();
+    trackEvent("rtc_reconnect_start", "info", { provider: this.providerName });
+    try {
+      if (this._isConnected) {
+        await this.disconnect();
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      await this.connect(this.lastConnectionConfig);
+      logger.info("AvatarPlayer", "Reconnection successful");
+      trackEvent("rtc_reconnect_success", "info", {
+        provider: this.providerName,
+        duration: Math.round(performance.now() - reconnectStart)
+      });
+    } catch (error) {
+      logger.error("AvatarPlayer", "Reconnection failed:", error);
+      trackEvent("rtc_reconnect_failed", "error", {
+        provider: this.providerName,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    } finally {
+      this.isReconnecting = false;
+    }
   }
   /**
    * Create internal renderer adapter that bridges AnimationHandler to AvatarView.
@@ -147,20 +388,19 @@ class AvatarPlayer {
   createRendererAdapter() {
     const avatarView = this.avatarView;
     return {
-      renderFrame(flame, startIdle) {
+      renderFromProtobuf(protobufData) {
+        avatarView.renderFromProtobuf(protobufData);
+      },
+      renderFrame(frame, startIdle) {
+        const view = avatarView;
         if (startIdle) {
-          avatarView.renderFlame(void 0, true);
-        } else if (flame) {
-          avatarView.renderFlame(flame);
+          view.renderFlame(void 0, true);
+        } else if (frame) {
+          view.renderFlame(frame);
         }
       },
-      async generateTransitionFromIdle(targetFrame, frameCount) {
-        return avatarView.generateTransition({
-          to: targetFrame,
-          frameCount,
-          useLinear: true
-          // Linear interpolation for idle->speaking
-        });
+      async generateTransitionFromProtobuf(protobufData, frameCount) {
+        return avatarView.generateTransitionFromProtobuf(protobufData, frameCount);
       },
       isReady() {
         return true;
@@ -174,9 +414,23 @@ class AvatarPlayer {
   async setupAnimationCallbacks() {
     const callbacks = {
       onAnimationData: (protobufData, metadata) => {
-        if (metadata.isStart) {
-          this.animationHandler.resetTracking();
-          this.provider.playRemoteAudio();
+        if (!this.hasActiveAnimationSession) {
+          if (!this.isTrackingPrimed) {
+            this.animationHandler.resetTracking();
+          }
+          this.hasActiveAnimationSession = true;
+          this.isTrackingPrimed = false;
+          if (!metadata.isStart) {
+            logger.info(
+              "AvatarPlayer",
+              `Session start inferred from frame seq=${metadata.frameSeq ?? "n/a"}`
+            );
+          }
+        } else if (metadata.isStart) {
+          logger.info(
+            "AvatarPlayer",
+            `Ignoring duplicate session start frame seq=${metadata.frameSeq ?? "n/a"}`
+          );
         }
         this.animationHandler.handleAnimationData(
           protobufData,
@@ -185,20 +439,44 @@ class AvatarPlayer {
         );
       },
       onTransition: (protobufData, transitionFrameCount) => {
-        this.provider.pauseRemoteAudio();
-        this.animationHandler.handleTransitionData(protobufData, transitionFrameCount);
+        this.conversationCount++;
+        this.animationHandler.handleTransitionData(
+          protobufData,
+          transitionFrameCount
+        );
       },
       onTransitionEnd: (protobufData, transitionFrameCount) => {
-        this.animationHandler.handleTransitionToIdle(protobufData, transitionFrameCount);
+        this.animationHandler.handleTransitionToIdle(
+          protobufData,
+          transitionFrameCount
+        );
       },
       onSessionStart: () => {
       },
       onSessionEnd: () => {
       },
       onIdleStart: () => {
+        if (this.animationHandler.isInTransition()) {
+          this.hasActiveAnimationSession = false;
+          this.isTrackingPrimed = false;
+          logger.info(
+            "AvatarPlayer",
+            "Deferring idleStart while transition is active"
+          );
+          return;
+        }
+        this.hasActiveAnimationSession = false;
+        this.animationHandler.resetTracking();
+        this.isTrackingPrimed = true;
         this.animationHandler.startIdle();
       },
-      onStreamStats: () => {
+      onStreamStats: (stats) => {
+        if (stats.framesLost > 0 || stats.framesRecovered > 0 || stats.framesDropped > 0) {
+          logger.warn(
+            "AvatarPlayer",
+            `Stream stats: lost=${stats.framesLost}, recovered=${stats.framesRecovered}, dropped=${stats.framesDropped}, fps=${stats.framesPerSec}`
+          );
+        }
       }
     };
     await this.provider.subscribeAnimationTrack(callbacks);
@@ -208,10 +486,21 @@ class AvatarPlayer {
    * @internal
    */
   setupProviderEvents() {
+    this.provider.on("connected", () => {
+      this._isConnected = true;
+    });
     this.provider.on("disconnected", () => {
       this._isConnected = false;
+      this.hasActiveAnimationSession = false;
+      this.isTrackingPrimed = false;
       this.animationHandler.startIdle();
     });
+    this.provider.on("error", (error) => {
+      trackEvent("rtc_error", "error", {
+        provider: this.providerName,
+        description: error instanceof Error ? error.message : String(error)
+      });
+    });
   }
 }
 export {