@viji-dev/core 0.4.6 → 0.5.1

package/dist/{index-Oj_9v8r4.js → index-Cqh1k_49.js}

@@ -6,7 +6,7 @@ class VijiCoreError extends Error {
     this.name = "VijiCoreError";
   }
 }
-const inlineScriptCode = '"use strict";\n(() => {\n  // src/iframe/protocol.ts\n  var PROTOCOL_VERSION = 1;\n  function collectTransferables(msg) {\n    switch (msg.type) {\n      case "init": {\n        const m = msg;\n        const out = [];\n        if (m.data?.canvas) out.push(m.data.canvas);\n        const wasm = m.data?.cvWasmFiles;\n        if (wasm) {\n          out.push(\n            wasm.simdLoaderJs,\n            wasm.simdBinary,\n            wasm.nosimdLoaderJs,\n            wasm.nosimdBinary\n          );\n        }\n        return out;\n      }\n      case "video-canvas-setup": {\n        const m = msg;\n        return m.data?.offscreenCanvas ? [m.data.offscreenCanvas] : [];\n      }\n      case "video-frame-update": {\n        const m = msg;\n        return m.data?.imageBitmap ? [m.data.imageBitmap] : [];\n      }\n      case "video-frame-direct": {\n        const m = msg;\n        return m.data?.imageBitmap ? [m.data.imageBitmap] : [];\n      }\n      case "parameter-update": {\n        const m = msg;\n        return m.data?.transferList ?? [];\n      }\n      case "parameter-batch-update": {\n        const m = msg;\n        return m.data?.transferList ?? [];\n      }\n      case "audio-analysis-update": {\n        const m = msg;\n        const out = [];\n        if (m.data?.frequencyData?.buffer) out.push(m.data.frequencyData.buffer);\n        if (m.data?.waveformData?.buffer) out.push(m.data.waveformData.buffer);\n        return out;\n      }\n      case "capture-frame-result":\n      case "auto-capture-result": {\n        const data = msg.data;\n        return data?.bitmap ? [data.bitmap] : [];\n      }\n      default:\n        return [];\n    }\n  }\n\n  // src/iframe/inline-script.ts\n  var hostOrigin = null;\n  var hostWindow = null;\n  var worker = null;\n  var workerBlobUrl = null;\n  var canvas = null;\n  var domHandlersAttached = false;\n  var sensorHandlersAttached = false;\n  function whenDomReady() {\n    if (document.readyState === "loading") {\n      return new Promise((resolve) => {\n        document.addEventListener("DOMContentLoaded", () => resolve(), {\n          once: true\n        });\n      });\n    }\n    return Promise.resolve();\n  }\n  async function announceReady() {\n    await whenDomReady();\n    const msg = {\n      type: "iframe-ready",\n      protocolVersion: PROTOCOL_VERSION,\n      environment: {\n        crossOriginIsolated: window.crossOriginIsolated,\n        isSecureContext: window.isSecureContext,\n        origin: self.origin\n      }\n    };\n    window.parent.postMessage(msg, "*");\n  }\n  function installHostListener() {\n    window.addEventListener("message", (event) => {\n      if (event.source !== window.parent) return;\n      if (hostOrigin === null) {\n        hostOrigin = event.origin;\n        hostWindow = window.parent;\n      } else if (event.origin !== hostOrigin) {\n        return;\n      }\n      handleHostMessage(event.data).catch((err) => {\n        reportError(err);\n      });\n    });\n  }\n  function postToHost(msg, transfer = []) {\n    if (hostOrigin === null || hostWindow === null) {\n      return;\n    }\n    const targetOrigin = hostOrigin === "null" ? "*" : hostOrigin;\n    hostWindow.postMessage(msg, targetOrigin, transfer);\n  }\n  function reportError(err) {\n    const e = err;\n    const msg = e?.stack ? {\n      type: "iframe-error",\n      message: e.message ?? String(err),\n      stack: e.stack\n    } : {\n      type: "iframe-error",\n      message: e?.message ?? String(err)\n    };\n    emitToHost(msg);\n  }\n  function reportWorkerOnError(e) {\n    const msg = {\n      type: "iframe-error",\n      message: e.message ? `Worker error: ${e.message}` : "Worker error: (no detail \\u2014 likely cross-origin opacity)",\n      ...e.error && e.error.stack ? { stack: e.error.stack } : {},\n      ...e.filename ? { filename: e.filename } : {},\n      ...e.lineno ? { lineno: e.lineno } : {},\n      ...e.colno ? { colno: e.colno } : {}\n    };\n    emitToHost(msg);\n  }\n  function emitToHost(msg) {\n    if (hostOrigin && hostWindow) {\n      const targetOrigin = hostOrigin === "null" ? "*" : hostOrigin;\n      hostWindow.postMessage(msg, targetOrigin);\n    } else {\n      window.parent.postMessage(msg, "*");\n    }\n  }\n  async function handleHostMessage(msg) {\n    switch (msg.type) {\n      case "viji-bootstrap":\n        await handleBootstrap(msg);\n        return;\n      case "viji-host-message":\n        relayHostToWorker(msg.payload);\n        return;\n      case "viji-resize":\n        handleResize(msg.width, msg.height);\n        return;\n      case "viji-enable-sensors":\n        setSensorsEnabled(msg.enabled);\n        return;\n      case "viji-enable-interaction":\n        setInteractionEnabled(msg.enabled);\n        return;\n      case "viji-terminate":\n        handleTerminate();\n        return;\n    }\n  }\n  async function handleBootstrap(msg) {\n    if (worker) {\n      return;\n    }\n    canvas = document.createElement("canvas");\n    canvas.id = "viji-canvas";\n    canvas.width = msg.init.canvasWidth;\n    canvas.height = msg.init.canvasHeight;\n    canvas.style.width = "100%";\n    canvas.style.height = "100%";\n    canvas.style.display = "block";\n    canvas.tabIndex = 0;\n    canvas.style.outline = "none";\n    document.body.appendChild(canvas);\n    const offscreen = canvas.transferControlToOffscreen();\n    workerBlobUrl = URL.createObjectURL(\n      new Blob([msg.workerCode], { type: "application/javascript" })\n    );\n    worker = new Worker(workerBlobUrl, { type: "classic" });\n    worker.onerror = (e) => {\n      reportWorkerOnError(e);\n    };\n    worker.onmessage = (event) => {\n      relayWorkerToHost(event.data);\n    };\n    const initId = `init_${Date.now()}`;\n    const initMsg = {\n      type: "init",\n      id: initId,\n      timestamp: Date.now(),\n      data: {\n        canvas: offscreen,\n        isHeadless: msg.init.isHeadless,\n        sc: msg.init.sc,\n        rh: msg.init.rh,\n        cvWasmFiles: msg.wasmFiles\n      }\n    };\n    const initResponse = waitForWorkerMessage((m) => {\n      return m && m.type === "init-response" && m.id === initId;\n    });\n    worker.postMessage(initMsg, [\n      offscreen,\n      msg.wasmFiles.simdLoaderJs,\n      msg.wasmFiles.simdBinary,\n      msg.wasmFiles.nosimdLoaderJs,\n      msg.wasmFiles.nosimdBinary\n    ]);\n    await initResponse;\n    if (msg.init.allowInteraction && !msg.init.isHeadless) {\n      setInteractionEnabled(true);\n    }\n    if (msg.init.allowSensors && !msg.init.isHeadless) {\n      setSensorsEnabled(true);\n    }\n    if (canvas) {\n      canvas.addEventListener("contextmenu", (e) => e.preventDefault());\n    }\n    postToHost({ type: "viji-ready" });\n  }\n  function waitForWorkerMessage(predicate) {\n    return new Promise((resolve, reject) => {\n      if (!worker) {\n        reject(new Error("worker not spawned"));\n        return;\n      }\n      const w = worker;\n      const onceListener = (event) => {\n        if (predicate(event.data)) {\n          w.removeEventListener("message", onceListener);\n          resolve(event.data);\n        }\n      };\n      w.addEventListener("message", onceListener);\n    });\n  }\n  function relayHostToWorker(payload) {\n    if (!worker || !payload) return;\n    try {\n      const transfer = collectTransferables(payload);\n      worker.postMessage(payload, transfer);\n    } catch (err) {\n      reportError(err);\n    }\n  }\n  function relayWorkerToHost(payload) {\n    if (!payload) return;\n    try {\n      const transfer = collectTransferables(payload);\n      postToHost(\n        { type: "worker-message", payload },\n        transfer\n      );\n    } catch (err) {\n      reportError(err);\n    }\n  }\n  function handleResize(width, height) {\n    if (!worker) return;\n    worker.postMessage({\n      type: "resolution-update",\n      id: `resize_${Date.now()}`,\n      timestamp: Date.now(),\n      data: {\n        effectiveWidth: width,\n        effectiveHeight: height,\n        displayScale: 1\n      }\n    });\n  }\n  var isMouseInCanvas = false;\n  function setInteractionEnabled(enabled) {\n    if (enabled === domHandlersAttached) return;\n    if (!canvas) return;\n    if (enabled) {\n      canvas.addEventListener("mousedown", handleMouseEvent, { passive: false });\n      canvas.addEventListener("mousemove", handleMouseEvent, { passive: false });\n      canvas.addEventListener("mouseup", handleMouseEvent, { passive: false });\n      canvas.addEventListener("mouseenter", handleMouseEnter, { passive: false });\n      canvas.addEventListener("mouseleave", handleMouseLeave, { passive: false });\n      canvas.addEventListener("wheel", handleWheelEvent, { passive: false });\n      canvas.addEventListener("touchstart", handleTouchEvent, { passive: false });\n      canvas.addEventListener("touchmove", handleTouchEvent, { passive: false });\n      canvas.addEventListener("touchend", handleTouchEvent, { passive: false });\n      canvas.addEventListener("touchcancel", handleTouchEvent, { passive: false });\n      document.addEventListener("keydown", handleKeyboardEvent, { passive: false });\n      document.addEventListener("keyup", handleKeyboardEvent, { passive: false });\n      canvas.addEventListener("mousedown", focusCanvas);\n      canvas.addEventListener("touchstart", focusCanvas);\n      domHandlersAttached = true;\n    } else {\n      canvas.removeEventListener("mousedown", handleMouseEvent);\n      canvas.removeEventListener("mousemove", handleMouseEvent);\n      canvas.removeEventListener("mouseup", handleMouseEvent);\n      canvas.removeEventListener("mouseenter", handleMouseEnter);\n      canvas.removeEventListener("mouseleave", handleMouseLeave);\n      canvas.removeEventListener("wheel", handleWheelEvent);\n      canvas.removeEventListener("touchstart", handleTouchEvent);\n      canvas.removeEventListener("touchmove", handleTouchEvent);\n      canvas.removeEventListener("touchend", handleTouchEvent);\n      canvas.removeEventListener("touchcancel", handleTouchEvent);\n      document.removeEventListener("keydown", handleKeyboardEvent);\n      document.removeEventListener("keyup", handleKeyboardEvent);\n      canvas.removeEventListener("mousedown", focusCanvas);\n      canvas.removeEventListener("touchstart", focusCanvas);\n      domHandlersAttached = false;\n    }\n  }\n  function focusCanvas() {\n    if (canvas) canvas.focus();\n  }\n  function dualRoute(workerType, data) {\n    if (worker) {\n      worker.postMessage({\n        type: workerType,\n        id: `${workerType}_${Date.now()}`,\n        timestamp: Date.now(),\n        data\n      });\n    }\n    postToHost({\n      type: "interaction-event",\n      kind: workerType,\n      data\n    });\n  }\n  function handleMouseEvent(event) {\n    if (!canvas) return;\n    event.preventDefault();\n    const rect = canvas.getBoundingClientRect();\n    const x = (event.clientX - rect.left) * (canvas.width / rect.width);\n    const y = (event.clientY - rect.top) * (canvas.height / rect.height);\n    dualRoute("mouse-update", {\n      x,\n      y,\n      buttons: event.buttons,\n      deltaX: event.movementX || 0,\n      deltaY: event.movementY || 0,\n      wheelDeltaX: 0,\n      wheelDeltaY: 0,\n      isInCanvas: isMouseInCanvas,\n      timestamp: performance.now()\n    });\n  }\n  function handleMouseEnter(event) {\n    isMouseInCanvas = true;\n    handleMouseEvent(event);\n  }\n  function handleMouseLeave(event) {\n    isMouseInCanvas = false;\n    handleMouseEvent(event);\n  }\n  function handleWheelEvent(event) {\n    if (!canvas) return;\n    event.preventDefault();\n    const rect = canvas.getBoundingClientRect();\n    const x = (event.clientX - rect.left) * (canvas.width / rect.width);\n    const y = (event.clientY - rect.top) * (canvas.height / rect.height);\n    dualRoute("mouse-update", {\n      x,\n      y,\n      buttons: event.buttons,\n      deltaX: 0,\n      deltaY: 0,\n      wheelDeltaX: event.deltaX,\n      wheelDeltaY: event.deltaY,\n      isInCanvas: isMouseInCanvas,\n      timestamp: performance.now()\n    });\n  }\n  var KEY_PASSTHROUGH = /* @__PURE__ */ new Set([\n    "Tab",\n    "F1",\n    "F2",\n    "F3",\n    "F4",\n    "F5",\n    "F11",\n    "F12"\n  ]);\n  function handleKeyboardEvent(event) {\n    if (!KEY_PASSTHROUGH.has(event.key)) {\n      event.preventDefault();\n    }\n    dualRoute("keyboard-update", {\n      type: event.type,\n      key: event.key,\n      code: event.code,\n      keyCode: event.keyCode,\n      shiftKey: event.shiftKey,\n      ctrlKey: event.ctrlKey,\n      altKey: event.altKey,\n      metaKey: event.metaKey,\n      timestamp: performance.now()\n    });\n  }\n  function handleTouchEvent(event) {\n    if (!canvas) return;\n    event.preventDefault();\n    const rect = canvas.getBoundingClientRect();\n    const scaleX = canvas.width / rect.width;\n    const scaleY = canvas.height / rect.height;\n    const canvasW = canvas.width;\n    const canvasH = canvas.height;\n    const mapTouch = (t) => {\n      const cx = (t.clientX - rect.left) * scaleX;\n      const cy = (t.clientY - rect.top) * scaleY;\n      return {\n        identifier: t.identifier,\n        clientX: cx,\n        clientY: cy,\n        radiusX: t.radiusX ?? 0,\n        radiusY: t.radiusY ?? 0,\n        rotationAngle: t.rotationAngle ?? 0,\n        force: t.force ?? 0,\n        isInCanvas: cx >= 0 && cx <= canvasW && cy >= 0 && cy <= canvasH\n      };\n    };\n    const changedMap = /* @__PURE__ */ new Map();\n    for (let i = 0; i < event.changedTouches.length; i++) {\n      const t = event.changedTouches[i];\n      changedMap.set(t.identifier, mapTouch(t));\n    }\n    const touches = Array.from(event.touches).map((t) => {\n      return changedMap.get(t.identifier) ?? mapTouch(t);\n    });\n    if (event.type === "touchend" || event.type === "touchcancel") {\n      const activeIds = new Set(touches.map((t) => t.identifier));\n      for (const [id, mapped] of changedMap) {\n        if (!activeIds.has(id)) {\n          touches.push({ ...mapped, ended: true });\n        }\n      }\n    }\n    dualRoute("touch-update", {\n      type: event.type,\n      touches,\n      timestamp: performance.now()\n    });\n  }\n  function setSensorsEnabled(enabled) {\n    if (enabled === sensorHandlersAttached) return;\n    if (enabled) {\n      window.addEventListener("devicemotion", handleDeviceMotion);\n      window.addEventListener("deviceorientation", handleDeviceOrientation);\n      sensorHandlersAttached = true;\n    } else {\n      window.removeEventListener("devicemotion", handleDeviceMotion);\n      window.removeEventListener("deviceorientation", handleDeviceOrientation);\n      sensorHandlersAttached = false;\n    }\n  }\n  function handleDeviceMotion(event) {\n    if (!event.acceleration && !event.accelerationIncludingGravity && !event.rotationRate) {\n      return;\n    }\n    postToHost({\n      type: "sensor-event",\n      kind: "motion",\n      data: {\n        acceleration: event.acceleration ? {\n          x: event.acceleration.x,\n          y: event.acceleration.y,\n          z: event.acceleration.z\n        } : null,\n        accelerationIncludingGravity: event.accelerationIncludingGravity ? {\n          x: event.accelerationIncludingGravity.x,\n          y: event.accelerationIncludingGravity.y,\n          z: event.accelerationIncludingGravity.z\n        } : null,\n        rotationRate: event.rotationRate ? {\n          alpha: event.rotationRate.alpha,\n          beta: event.rotationRate.beta,\n          gamma: event.rotationRate.gamma\n        } : null,\n        interval: event.interval || 16\n      }\n    });\n  }\n  function handleDeviceOrientation(event) {\n    postToHost({\n      type: "sensor-event",\n      kind: "orientation",\n      data: {\n        alpha: event.alpha,\n        beta: event.beta,\n        gamma: event.gamma,\n        absolute: event.absolute || false\n      }\n    });\n  }\n  function handleTerminate() {\n    setInteractionEnabled(false);\n    setSensorsEnabled(false);\n    if (worker) {\n      worker.terminate();\n      worker = null;\n    }\n    if (workerBlobUrl) {\n      URL.revokeObjectURL(workerBlobUrl);\n      workerBlobUrl = null;\n    }\n  }\n  installHostListener();\n  announceReady().catch((err) => reportError(err));\n  window.addEventListener("error", (e) => {\n    reportError(e.error ?? new Error(e.message));\n  });\n  window.addEventListener("unhandledrejection", (e) => {\n    reportError(e.reason ?? new Error("Unhandled promise rejection"));\n  });\n})();\n';
+const inlineScriptCode = '"use strict";\n(() => {\n  // src/iframe/protocol.ts\n  var PROTOCOL_VERSION = 1;\n  function collectTransferables(msg) {\n    switch (msg.type) {\n      case "init": {\n        const m = msg;\n        const out = [];\n        if (m.data?.canvas) out.push(m.data.canvas);\n        const wasm = m.data?.cvWasmFiles;\n        if (wasm) {\n          out.push(\n            wasm.simdLoaderJs,\n            wasm.simdBinary,\n            wasm.nosimdLoaderJs,\n            wasm.nosimdBinary\n          );\n        }\n        if (m.data?.controlPort) out.push(m.data.controlPort);\n        return out;\n      }\n      case "video-canvas-setup": {\n        const m = msg;\n        return m.data?.offscreenCanvas ? [m.data.offscreenCanvas] : [];\n      }\n      case "video-frame-update": {\n        const m = msg;\n        return m.data?.imageBitmap ? [m.data.imageBitmap] : [];\n      }\n      case "video-frame-direct": {\n        const m = msg;\n        return m.data?.imageBitmap ? [m.data.imageBitmap] : [];\n      }\n      case "parameter-update": {\n        const m = msg;\n        return m.data?.transferList ?? [];\n      }\n      case "parameter-batch-update": {\n        const m = msg;\n        return m.data?.transferList ?? [];\n      }\n      case "audio-analysis-update": {\n        const m = msg;\n        const out = [];\n        if (m.data?.frequencyData?.buffer) out.push(m.data.frequencyData.buffer);\n        if (m.data?.waveformData?.buffer) out.push(m.data.waveformData.buffer);\n        return out;\n      }\n      case "capture-frame-result":\n      case "auto-capture-result": {\n        const data = msg.data;\n        return data?.bitmap ? [data.bitmap] : [];\n      }\n      default:\n        return [];\n    }\n  }\n\n  // src/iframe/inline-script.ts\n  var hostOrigin = null;\n  var hostWindow = null;\n  var worker = null;\n  var workerBlobUrl = null;\n  var canvas = null;\n  var domHandlersAttached = false;\n  var sensorHandlersAttached = false;\n  function whenDomReady() {\n    if (document.readyState === "loading") {\n      return new Promise((resolve) => {\n        document.addEventListener("DOMContentLoaded", () => resolve(), {\n          once: true\n        });\n      });\n    }\n    return Promise.resolve();\n  }\n  async function announceReady() {\n    await whenDomReady();\n    const msg = {\n      type: "iframe-ready",\n      protocolVersion: PROTOCOL_VERSION,\n      environment: {\n        crossOriginIsolated: window.crossOriginIsolated,\n        isSecureContext: window.isSecureContext,\n        origin: self.origin\n      }\n    };\n    window.parent.postMessage(msg, "*");\n  }\n  function installHostListener() {\n    window.addEventListener("message", (event) => {\n      if (event.source !== window.parent) return;\n      if (hostOrigin === null) {\n        hostOrigin = event.origin;\n        hostWindow = window.parent;\n      } else if (event.origin !== hostOrigin) {\n        return;\n      }\n      handleHostMessage(event.data).catch((err) => {\n        reportError(err);\n      });\n    });\n  }\n  function postToHost(msg, transfer = []) {\n    if (hostOrigin === null || hostWindow === null) {\n      return;\n    }\n    const targetOrigin = hostOrigin === "null" ? "*" : hostOrigin;\n    hostWindow.postMessage(msg, targetOrigin, transfer);\n  }\n  function reportError(err) {\n    const e = err;\n    const msg = e?.stack ? {\n      type: "iframe-error",\n      message: e.message ?? String(err),\n      stack: e.stack\n    } : {\n      type: "iframe-error",\n      message: e?.message ?? String(err)\n    };\n    emitToHost(msg);\n  }\n  function reportWorkerOnError(e) {\n    const msg = {\n      type: "iframe-error",\n      message: e.message ? `Worker error: ${e.message}` : "Worker error: (no detail \\u2014 likely cross-origin opacity)",\n      ...e.error && e.error.stack ? { stack: e.error.stack } : {},\n      ...e.filename ? { filename: e.filename } : {},\n      ...e.lineno ? { lineno: e.lineno } : {},\n      ...e.colno ? { colno: e.colno } : {}\n    };\n    emitToHost(msg);\n  }\n  function emitToHost(msg) {\n    if (hostOrigin && hostWindow) {\n      const targetOrigin = hostOrigin === "null" ? "*" : hostOrigin;\n      hostWindow.postMessage(msg, targetOrigin);\n    } else {\n      window.parent.postMessage(msg, "*");\n    }\n  }\n  async function handleHostMessage(msg) {\n    switch (msg.type) {\n      case "viji-bootstrap":\n        await handleBootstrap(msg);\n        return;\n      case "viji-host-message":\n        relayHostToWorker(msg.payload);\n        return;\n      case "viji-resize":\n        handleResize(msg.width, msg.height);\n        return;\n      case "viji-enable-sensors":\n        setSensorsEnabled(msg.enabled);\n        return;\n      case "viji-enable-interaction":\n        setInteractionEnabled(msg.enabled);\n        return;\n      case "viji-terminate":\n        handleTerminate();\n        return;\n    }\n  }\n  async function handleBootstrap(msg) {\n    if (worker) {\n      return;\n    }\n    canvas = document.createElement("canvas");\n    canvas.id = "viji-canvas";\n    canvas.width = msg.init.canvasWidth;\n    canvas.height = msg.init.canvasHeight;\n    canvas.style.width = "100%";\n    canvas.style.height = "100%";\n    canvas.style.display = "block";\n    canvas.tabIndex = 0;\n    canvas.style.outline = "none";\n    document.body.appendChild(canvas);\n    const offscreen = canvas.transferControlToOffscreen();\n    workerBlobUrl = URL.createObjectURL(\n      new Blob([msg.workerCode], { type: "application/javascript" })\n    );\n    worker = new Worker(workerBlobUrl, { type: "classic" });\n    worker.onerror = (e) => {\n      reportWorkerOnError(e);\n    };\n    worker.onmessage = (event) => {\n      relayWorkerToHost(event.data);\n    };\n    const initId = `init_${Date.now()}`;\n    const initMsg = {\n      type: "init",\n      id: initId,\n      timestamp: Date.now(),\n      data: {\n        canvas: offscreen,\n        isHeadless: msg.init.isHeadless,\n        sc: msg.init.sc,\n        rh: msg.init.rh,\n        cvWasmFiles: msg.wasmFiles,\n        controlPort: msg.controlPort\n      }\n    };\n    const initResponse = waitForWorkerMessage((m) => {\n      return m && m.type === "init-response" && m.id === initId;\n    });\n    worker.postMessage(initMsg, [\n      offscreen,\n      msg.wasmFiles.simdLoaderJs,\n      msg.wasmFiles.simdBinary,\n      msg.wasmFiles.nosimdLoaderJs,\n      msg.wasmFiles.nosimdBinary,\n      msg.controlPort\n    ]);\n    await initResponse;\n    if (msg.init.allowInteraction && !msg.init.isHeadless) {\n      setInteractionEnabled(true);\n    }\n    if (msg.init.allowSensors && !msg.init.isHeadless) {\n      setSensorsEnabled(true);\n    }\n    if (canvas) {\n      canvas.addEventListener("contextmenu", (e) => e.preventDefault());\n    }\n    postToHost({ type: "viji-ready" });\n  }\n  function waitForWorkerMessage(predicate) {\n    return new Promise((resolve, reject) => {\n      if (!worker) {\n        reject(new Error("worker not spawned"));\n        return;\n      }\n      const w = worker;\n      const onceListener = (event) => {\n        if (predicate(event.data)) {\n          w.removeEventListener("message", onceListener);\n          resolve(event.data);\n        }\n      };\n      w.addEventListener("message", onceListener);\n    });\n  }\n  function relayHostToWorker(payload) {\n    if (!worker || !payload) return;\n    try {\n      const transfer = collectTransferables(payload);\n      worker.postMessage(payload, transfer);\n    } catch (err) {\n      reportError(err);\n    }\n  }\n  function relayWorkerToHost(payload) {\n    if (!payload) return;\n    try {\n      const transfer = collectTransferables(payload);\n      postToHost(\n        { type: "worker-message", payload },\n        transfer\n      );\n    } catch (err) {\n      reportError(err);\n    }\n  }\n  function handleResize(width, height) {\n    if (!worker) return;\n    worker.postMessage({\n      type: "resolution-update",\n      id: `resize_${Date.now()}`,\n      timestamp: Date.now(),\n      data: {\n        effectiveWidth: width,\n        effectiveHeight: height,\n        displayScale: 1\n      }\n    });\n  }\n  var isMouseInCanvas = false;\n  function setInteractionEnabled(enabled) {\n    if (enabled === domHandlersAttached) return;\n    if (!canvas) return;\n    if (enabled) {\n      canvas.addEventListener("mousedown", handleMouseEvent, { passive: false });\n      canvas.addEventListener("mousemove", handleMouseEvent, { passive: false });\n      canvas.addEventListener("mouseup", handleMouseEvent, { passive: false });\n      canvas.addEventListener("mouseenter", handleMouseEnter, { passive: false });\n      canvas.addEventListener("mouseleave", handleMouseLeave, { passive: false });\n      canvas.addEventListener("wheel", handleWheelEvent, { passive: false });\n      canvas.addEventListener("touchstart", handleTouchEvent, { passive: false });\n      canvas.addEventListener("touchmove", handleTouchEvent, { passive: false });\n      canvas.addEventListener("touchend", handleTouchEvent, { passive: false });\n      canvas.addEventListener("touchcancel", handleTouchEvent, { passive: false });\n      document.addEventListener("keydown", handleKeyboardEvent, { passive: false });\n      document.addEventListener("keyup", handleKeyboardEvent, { passive: false });\n      canvas.addEventListener("mousedown", focusCanvas);\n      canvas.addEventListener("touchstart", focusCanvas);\n      domHandlersAttached = true;\n    } else {\n      canvas.removeEventListener("mousedown", handleMouseEvent);\n      canvas.removeEventListener("mousemove", handleMouseEvent);\n      canvas.removeEventListener("mouseup", handleMouseEvent);\n      canvas.removeEventListener("mouseenter", handleMouseEnter);\n      canvas.removeEventListener("mouseleave", handleMouseLeave);\n      canvas.removeEventListener("wheel", handleWheelEvent);\n      canvas.removeEventListener("touchstart", handleTouchEvent);\n      canvas.removeEventListener("touchmove", handleTouchEvent);\n      canvas.removeEventListener("touchend", handleTouchEvent);\n      canvas.removeEventListener("touchcancel", handleTouchEvent);\n      document.removeEventListener("keydown", handleKeyboardEvent);\n      document.removeEventListener("keyup", handleKeyboardEvent);\n      canvas.removeEventListener("mousedown", focusCanvas);\n      canvas.removeEventListener("touchstart", focusCanvas);\n      domHandlersAttached = false;\n    }\n  }\n  function focusCanvas() {\n    if (canvas) canvas.focus();\n  }\n  function dualRoute(workerType, data) {\n    if (worker) {\n      worker.postMessage({\n        type: workerType,\n        id: `${workerType}_${Date.now()}`,\n        timestamp: Date.now(),\n        data\n      });\n    }\n    postToHost({\n      type: "interaction-event",\n      kind: workerType,\n      data\n    });\n  }\n  function handleMouseEvent(event) {\n    if (!canvas) return;\n    event.preventDefault();\n    const rect = canvas.getBoundingClientRect();\n    const x = (event.clientX - rect.left) * (canvas.width / rect.width);\n    const y = (event.clientY - rect.top) * (canvas.height / rect.height);\n    dualRoute("mouse-update", {\n      x,\n      y,\n      buttons: event.buttons,\n      deltaX: event.movementX || 0,\n      deltaY: event.movementY || 0,\n      wheelDeltaX: 0,\n      wheelDeltaY: 0,\n      isInCanvas: isMouseInCanvas,\n      timestamp: performance.now()\n    });\n  }\n  function handleMouseEnter(event) {\n    isMouseInCanvas = true;\n    handleMouseEvent(event);\n  }\n  function handleMouseLeave(event) {\n    isMouseInCanvas = false;\n    handleMouseEvent(event);\n  }\n  function handleWheelEvent(event) {\n    if (!canvas) return;\n    event.preventDefault();\n    const rect = canvas.getBoundingClientRect();\n    const x = (event.clientX - rect.left) * (canvas.width / rect.width);\n    const y = (event.clientY - rect.top) * (canvas.height / rect.height);\n    dualRoute("mouse-update", {\n      x,\n      y,\n      buttons: event.buttons,\n      deltaX: 0,\n      deltaY: 0,\n      wheelDeltaX: event.deltaX,\n      wheelDeltaY: event.deltaY,\n      isInCanvas: isMouseInCanvas,\n      timestamp: performance.now()\n    });\n  }\n  var KEY_PASSTHROUGH = /* @__PURE__ */ new Set([\n    "Tab",\n    "F1",\n    "F2",\n    "F3",\n    "F4",\n    "F5",\n    "F11",\n    "F12"\n  ]);\n  function handleKeyboardEvent(event) {\n    if (!KEY_PASSTHROUGH.has(event.key)) {\n      event.preventDefault();\n    }\n    dualRoute("keyboard-update", {\n      type: event.type,\n      key: event.key,\n      code: event.code,\n      keyCode: event.keyCode,\n      shiftKey: event.shiftKey,\n      ctrlKey: event.ctrlKey,\n      altKey: event.altKey,\n      metaKey: event.metaKey,\n      timestamp: performance.now()\n    });\n  }\n  function handleTouchEvent(event) {\n    if (!canvas) return;\n    event.preventDefault();\n    const rect = canvas.getBoundingClientRect();\n    const scaleX = canvas.width / rect.width;\n    const scaleY = canvas.height / rect.height;\n    const canvasW = canvas.width;\n    const canvasH = canvas.height;\n    const mapTouch = (t) => {\n      const cx = (t.clientX - rect.left) * scaleX;\n      const cy = (t.clientY - rect.top) * scaleY;\n      return {\n        identifier: t.identifier,\n        clientX: cx,\n        clientY: cy,\n        radiusX: t.radiusX ?? 0,\n        radiusY: t.radiusY ?? 0,\n        rotationAngle: t.rotationAngle ?? 0,\n        force: t.force ?? 0,\n        isInCanvas: cx >= 0 && cx <= canvasW && cy >= 0 && cy <= canvasH\n      };\n    };\n    const changedMap = /* @__PURE__ */ new Map();\n    for (let i = 0; i < event.changedTouches.length; i++) {\n      const t = event.changedTouches[i];\n      changedMap.set(t.identifier, mapTouch(t));\n    }\n    const touches = Array.from(event.touches).map((t) => {\n      return changedMap.get(t.identifier) ?? mapTouch(t);\n    });\n    if (event.type === "touchend" || event.type === "touchcancel") {\n      const activeIds = new Set(touches.map((t) => t.identifier));\n      for (const [id, mapped] of changedMap) {\n        if (!activeIds.has(id)) {\n          touches.push({ ...mapped, ended: true });\n        }\n      }\n    }\n    dualRoute("touch-update", {\n      type: event.type,\n      touches,\n      timestamp: performance.now()\n    });\n  }\n  function setSensorsEnabled(enabled) {\n    if (enabled === sensorHandlersAttached) return;\n    if (enabled) {\n      window.addEventListener("devicemotion", handleDeviceMotion);\n      window.addEventListener("deviceorientation", handleDeviceOrientation);\n      sensorHandlersAttached = true;\n    } else {\n      window.removeEventListener("devicemotion", handleDeviceMotion);\n      window.removeEventListener("deviceorientation", handleDeviceOrientation);\n      sensorHandlersAttached = false;\n    }\n  }\n  function handleDeviceMotion(event) {\n    if (!event.acceleration && !event.accelerationIncludingGravity && !event.rotationRate) {\n      return;\n    }\n    postToHost({\n      type: "sensor-event",\n      kind: "motion",\n      data: {\n        acceleration: event.acceleration ? {\n          x: event.acceleration.x,\n          y: event.acceleration.y,\n          z: event.acceleration.z\n        } : null,\n        accelerationIncludingGravity: event.accelerationIncludingGravity ? {\n          x: event.accelerationIncludingGravity.x,\n          y: event.accelerationIncludingGravity.y,\n          z: event.accelerationIncludingGravity.z\n        } : null,\n        rotationRate: event.rotationRate ? {\n          alpha: event.rotationRate.alpha,\n          beta: event.rotationRate.beta,\n          gamma: event.rotationRate.gamma\n        } : null,\n        interval: event.interval || 16\n      }\n    });\n  }\n  function handleDeviceOrientation(event) {\n    postToHost({\n      type: "sensor-event",\n      kind: "orientation",\n      data: {\n        alpha: event.alpha,\n        beta: event.beta,\n        gamma: event.gamma,\n        absolute: event.absolute || false\n      }\n    });\n  }\n  function handleTerminate() {\n    setInteractionEnabled(false);\n    setSensorsEnabled(false);\n    if (worker) {\n      worker.terminate();\n      worker = null;\n    }\n    if (workerBlobUrl) {\n      URL.revokeObjectURL(workerBlobUrl);\n      workerBlobUrl = null;\n    }\n  }\n  installHostListener();\n  announceReady().catch((err) => reportError(err));\n  window.addEventListener("error", (e) => {\n    reportError(e.error ?? new Error(e.message));\n  });\n  window.addEventListener("unhandledrejection", (e) => {\n    reportError(e.reason ?? new Error("Unhandled promise rejection"));\n  });\n})();\n';
 const IFRAME_ALLOW = "accelerometer; gyroscope; magnetometer; camera; microphone";
 const OPAQUE_ORIGIN = "null";
 function collectTransferables(msg) {
@@ -24,6 +24,7 @@ function collectTransferables(msg) {
           wasm.nosimdBinary
         );
       }
+      if (m.data?.controlPort) out.push(m.data.controlPort);
       return out;
     }
     case "video-canvas-setup": {
@@ -68,7 +69,8 @@ function collectBootstrapTransferables(msg) {
     msg.wasmFiles.simdLoaderJs,
     msg.wasmFiles.simdBinary,
     msg.wasmFiles.nosimdLoaderJs,
-    msg.wasmFiles.nosimdBinary
+    msg.wasmFiles.nosimdBinary,
+    msg.controlPort
   ];
 }
 class IFrameManager {
@@ -103,6 +105,19 @@ class IFrameManager {
   hostMessageListener = null;
   workerMessageHandlers = [];
   vijiReadyHandlers = [];
+  /**
+   * Direct host↔worker control channel. `port1` stays on the host side and is
+   * handed to `WorkerManager` via `getControlPort1()` after `viji-ready`;
+   * `port2` is shipped to the worker through the bootstrap envelope so all
+   * steady-state host↔worker traffic can bypass the per-frame iframe relay
+   * tax. The trust boundary is unchanged — the worker still inherits the
+   * iframe's opaque origin; the port is just a faster transport.
+   *
+   * Single-owner discipline: IFrameManager owns the channel lifecycle and
+   * closes `port1` on destroy. WorkerManager only borrows the port reference
+   * for its own listener (which it detaches without closing).
+   */
+  controlChannel = null;
   initiallyVisible;
   /**
    * Enable or disable debug logging
@@ -260,6 +275,35 @@ class IFrameManager {
   onVijiReady(handler) {
     this.vijiReadyHandlers.push(handler);
   }
+  /**
+   * Create the host↔worker control channel and return the iframe-side end
+   * (`port2`) for inclusion in the bootstrap envelope. Idempotent: a second
+   * call returns the same `port2` (the underlying channel is created once
+   * per IFrameManager lifetime).
+   *
+   * Called by `WorkerManager.createWorker` while assembling the
+   * `HostBootstrapMessage` so the port hops host → iframe → worker as a
+   * transferable. The host-side `port1` is consumed via `getControlPort1()`
+   * after `viji-ready`.
+   */
+  createControlChannel() {
+    if (!this.controlChannel) {
+      this.controlChannel = new MessageChannel();
+    }
+    return this.controlChannel.port2;
+  }
+  /**
+   * Returns the host-side end (`port1`) of the control channel created by
+   * `createControlChannel()`. WorkerManager grabs this after `viji-ready` to
+   * route per-frame traffic directly to the worker.
+   *
+   * Returns `null` if the channel was never created (e.g. legacy bootstrap
+   * shape) or has been torn down by `destroy()`. Callers should treat null
+   * as "stay on the iframe relay path" rather than as an error.
+   */
+  getControlPort1() {
+    return this.controlChannel?.port1 ?? null;
+  }
   // ========================================
   // Host-side message dispatch
   // ========================================
@@ -425,6 +469,13 @@ class IFrameManager {
         } catch {
         }
       }
+      if (this.controlChannel) {
+        try {
+          this.controlChannel.port1.close();
+        } catch {
+        }
+        this.controlChannel = null;
+      }
       if (this.hostMessageListener) {
         window.removeEventListener("message", this.hostMessageListener);
         this.hostMessageListener = null;
@@ -589,7 +640,7 @@ class IFrameManager {
     }
   }
 }
-const workerUrl = "" + new URL("assets/viji.worker-BbzNOVhB.js", import.meta.url).href;
+const workerUrl = "" + new URL("assets/viji.worker-DwYMDyfQ.js", import.meta.url).href;
 const simdLoaderJs = new URL("assets/wasm/vision_wasm_internal.js", import.meta.url).href;
 const simdBinary = new URL("assets/wasm/vision_wasm_internal.wasm", import.meta.url).href;
 const nosimdLoaderJs = new URL("assets/wasm/vision_wasm_nosimd_internal.js", import.meta.url).href;
@@ -606,6 +657,19 @@ class WorkerManager {
   isInitialized = false;
   /** Bound worker-message handler so we can detach on destroy. */
   onWorkerMessageBound = null;
+  /**
+   * Host-side end of the direct host↔worker MessageChannel (created by
+   * `IFrameManager.createControlChannel()` at bootstrap time, handed to us
+   * after `viji-ready`). Once non-null, `relayHostToWorker` posts on this
+   * port instead of through the iframe relay — one cross-process hop
+   * instead of two for every per-frame message.
+   *
+   * Single-owner discipline (docs/14, rule 5): IFrameManager owns the
+   * channel lifecycle and closes `port1` on destroy. WorkerManager only
+   * detaches its `onmessage` listener.
+   */
+  controlPort = null;
+  onControlPortMessageBound = null;
   /**
    * Bootstraps the worker inside the iframe.
    *
@@ -636,6 +700,7 @@ class WorkerManager {
       ]);
       this.setupMessageHandling();
       const res = this.iframeManager.getEffectiveResolution();
+      const controlPort2 = this.iframeManager.createControlChannel();
       const bootstrap = {
         type: "viji-bootstrap",
         workerCode,
@@ -645,6 +710,7 @@ class WorkerManager {
           nosimdLoaderJs: nosimdLoaderJs$1,
           nosimdBinary: nosimdBinary$1
         },
+        controlPort: controlPort2,
         init: {
           canvasWidth: res.width,
           canvasHeight: res.height,
@@ -675,6 +741,14 @@ class WorkerManager {
         collectBootstrapTransferables(bootstrap)
       );
       await vijiReady;
+      this.controlPort = this.iframeManager.getControlPort1();
+      if (this.controlPort && this.onWorkerMessageBound) {
+        const dispatcher = this.onWorkerMessageBound;
+        this.onControlPortMessageBound = (evt) => {
+          dispatcher(evt.data);
+        };
+        this.controlPort.onmessage = this.onControlPortMessageBound;
+      }
       this.postMessage("set-scene-code", { sceneCode: this.sceneCode });
       this.isInitialized = true;
     } catch (error) {
@@ -726,8 +800,17 @@ class WorkerManager {
     this.relayHostToWorker(message);
   }
   /**
-   * Sends a host-to-worker message wrapped in a `viji-host-message`
-   * envelope, with transferables harvested via the centralized helper.
+   * Sends a host-to-worker message. Once the direct control channel is
+   * wired (after `viji-ready`), per-message traffic flows on `port1`
+   * directly to the worker — bypassing the iframe relay's per-frame cost.
+   * During the bootstrap window (before `viji-ready` fires) and any
+   * post-teardown call we fall back to the iframe relay path so init-time
+   * messages still reach the worker.
+   *
+   * Transferables are harvested via the centralized `collectTransferables`
+   * helper either way, and the `transferList` shim added by parameter
+   * messages is stripped before send (the worker has no use for it once
+   * the actual handles have been transferred).
    */
   relayHostToWorker(message) {
     if (!this.iframeManager.ready && !this.isInitialized) {
@@ -739,6 +822,10 @@ class WorkerManager {
     try {
       const transfer = collectTransferables(message);
       const sanitized = stripTransferList(message);
+      if (this.controlPort) {
+        this.controlPort.postMessage(sanitized, transfer);
+        return;
+      }
       this.iframeManager.postEnvelope(
         { type: "viji-host-message", payload: sanitized },
         transfer
@@ -779,6 +866,11 @@ class WorkerManager {
         this.iframeManager.offWorkerMessage(this.onWorkerMessageBound);
         this.onWorkerMessageBound = null;
       }
+      if (this.controlPort && this.onControlPortMessageBound) {
+        this.controlPort.onmessage = null;
+        this.onControlPortMessageBound = null;
+      }
+      this.controlPort = null;
       this.isInitialized = false;
     } catch (error) {
       console.warn("Error during worker cleanup:", error);
@@ -1805,7 +1897,7 @@ class EssentiaOnsetDetection {
     this.initPromise = (async () => {
       try {
         const essentiaModule = await import("./essentia.js-core.es-DnrJE0uR.js");
-        const wasmModule = await import("./essentia-wasm.web-qCUJ8zjr.js").then((n) => n.e);
+        const wasmModule = await import("./essentia-wasm.web-x6zu4Vib.js").then((n) => n.e);
         const EssentiaClass = essentiaModule.Essentia || essentiaModule.default?.Essentia || essentiaModule.default;
         let WASMModule = wasmModule.default || wasmModule.EssentiaWASM || wasmModule.default?.EssentiaWASM;
         if (!WASMModule) {
@@ -3466,10 +3558,20 @@ class TempoInduction {
   setDebugMode(_enabled) {
   }
   /**
-   * Reset tempo detection state
+   * Reset tempo detection state.
+   *
+   * Note on coverage: this clears every mutable runtime field that affects
+   * subsequent detection. Earlier versions of `reset()` missed several fields
+   * (per-band envelopes, onset history, grid-lock, warmup, fpsEstimate); they
+   * are included here for correctness — without them, a re-used instance
+   * could carry stale signal-history into a fresh detection session.
    */
   reset() {
     this.onsetEnvelope = [];
+    this.lowBandEnvelope = [];
+    this.midBandEnvelope = [];
+    this.highBandEnvelope = [];
+    this.fpsEstimate = 60;
     this.currentBPM = 120;
     this.confidence = 0;
     this.method = "autocorr";
@@ -3482,6 +3584,107 @@ class TempoInduction {
     this.bpmDriftHistory = [];
     this.driftRate = 0;
     this.tempoChangeConfirmCount = 0;
+    this.onsetHistory = [];
+    this.gridLockBPM = null;
+    this.gridLockScore = 0;
+    this.gridLockTime = 0;
+    this.gridLockMemoryBPM = null;
+    this.gridLockMemoryTime = 0;
+    this.syncopationLevel = 0;
+    this.warmupStartTimeMs = 0;
+    this.warmupComplete = false;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // State serialization (for VijiCore.exportFullState same-process transfer)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Snapshot continuity-relevant runtime state. Wall-clock fields are in
+   * this instance's `performance.now()` clock space.
+   */
+  exportSessionState() {
+    return {
+      onsetEnvelope: [...this.onsetEnvelope],
+      lowBandEnvelope: [...this.lowBandEnvelope],
+      midBandEnvelope: [...this.midBandEnvelope],
+      highBandEnvelope: [...this.highBandEnvelope],
+      fpsEstimate: this.fpsEstimate,
+      currentBPM: this.currentBPM,
+      confidence: this.confidence,
+      method: this.method,
+      anchorBand: this.anchorBand,
+      methodAgreement: this.methodAgreement,
+      bpmHistory: [...this.bpmHistory],
+      lastUpdateTime: this.lastUpdateTime > 0 ? this.lastUpdateTime : null,
+      hypotheses: this.hypotheses.map((h) => ({
+        bpm: h.bpm,
+        likelihood: h.likelihood,
+        age: h.age,
+        lastEvidence: h.lastEvidence,
+        type: h.type
+      })),
+      inTransition: this.inTransition,
+      bpmDriftHistory: this.bpmDriftHistory.map((e) => ({ time: e.time, bpm: e.bpm })),
+      driftRate: this.driftRate,
+      tempoChangeConfirmCount: this.tempoChangeConfirmCount,
+      onsetHistory: this.onsetHistory.map((e) => ({
+        time: e.time,
+        strength: e.strength,
+        type: e.type
+      })),
+      gridLockBPM: this.gridLockBPM,
+      gridLockScore: this.gridLockScore,
+      gridLockTime: this.gridLockTime,
+      gridLockMemoryBPM: this.gridLockMemoryBPM,
+      gridLockMemoryTime: this.gridLockMemoryTime,
+      syncopationLevel: this.syncopationLevel,
+      warmupStartTimeMs: this.warmupStartTimeMs,
+      warmupComplete: this.warmupComplete
+    };
+  }
+  /**
+   * Replace runtime state from a serialized snapshot. `clockOffset` is added
+   * to all wall-clock fields (zero / null sentinels are left untranslated).
+   */
+  importSessionState(state, clockOffset) {
+    this.onsetEnvelope = [...state.onsetEnvelope];
+    this.lowBandEnvelope = [...state.lowBandEnvelope];
+    this.midBandEnvelope = [...state.midBandEnvelope];
+    this.highBandEnvelope = [...state.highBandEnvelope];
+    this.fpsEstimate = state.fpsEstimate;
+    this.currentBPM = state.currentBPM;
+    this.confidence = state.confidence;
+    this.method = state.method;
+    this.anchorBand = state.anchorBand;
+    this.methodAgreement = state.methodAgreement;
+    this.bpmHistory = [...state.bpmHistory];
+    this.lastUpdateTime = state.lastUpdateTime !== null ? state.lastUpdateTime + clockOffset : 0;
+    this.hypotheses = state.hypotheses.map((h) => ({
+      bpm: h.bpm,
+      likelihood: h.likelihood,
+      age: h.age,
+      lastEvidence: h.lastEvidence + clockOffset,
+      type: h.type
+    }));
+    this.inTransition = state.inTransition;
+    this.bpmDriftHistory = state.bpmDriftHistory.map((e) => ({
+      time: e.time + clockOffset,
+      bpm: e.bpm
+    }));
+    this.driftRate = state.driftRate;
+    this.tempoChangeConfirmCount = state.tempoChangeConfirmCount;
+    this.onsetHistory = state.onsetHistory.map((e) => ({
+      time: e.time + clockOffset,
+      strength: e.strength,
+      type: e.type
+    }));
+    this.gridLockBPM = state.gridLockBPM;
+    this.gridLockScore = state.gridLockScore;
+    this.gridLockTime = state.gridLockTime > 0 ? state.gridLockTime + clockOffset : 0;
+    this.gridLockMemoryBPM = state.gridLockMemoryBPM;
+    this.gridLockMemoryTime = state.gridLockMemoryTime > 0 ? state.gridLockMemoryTime + clockOffset : 0;
+    this.syncopationLevel = state.syncopationLevel;
+    this.warmupStartTimeMs = state.warmupStartTimeMs > 0 ? state.warmupStartTimeMs + clockOffset : 0;
+    this.warmupComplete = state.warmupComplete;
   }
   /**
    * Get detailed debug info for testing/debugging
@@ -4001,6 +4204,75 @@ class PhaseLockedLoop {
     this.phaseOffsetCalibrated = 0;
     this.lastCalibrationTime = 0;
   }
+  // ─────────────────────────────────────────────────────────────────────────
+  // State serialization (for VijiCore.exportFullState same-process transfer)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Snapshot continuity-relevant runtime state. Wall-clock fields are in this
+   * instance's `performance.now()` clock space; receiver translates by
+   * `clockOffset` on import.
+   */
+  exportSessionState() {
+    return {
+      phase: this.phase,
+      lastBeatTime: this.lastBeatTime,
+      periodMs: this.periodMs,
+      trackedBPM: this.trackedBPM,
+      beatCounter: this.beatCounter,
+      lastOnsetTime: this.lastOnsetTime,
+      bpmHistory: this.bpmHistory.map((e) => ({ time: e.time, bpm: e.bpm })),
+      driftRate: this.driftRate,
+      inBreakdown: this.inBreakdown,
+      tempoConfidence: this.tempoConfidence,
+      inTransition: this.inTransition,
+      currentGain: this.currentGain,
+      lastBarAdvanceTime: this.lastBarAdvanceTime,
+      pendingBarAdvance: this.pendingBarAdvance,
+      lastPhaseWrapTime: this.lastPhaseWrapTime,
+      consecutiveAlignedKicks: this.consecutiveAlignedKicks,
+      lastHardSyncTime: this.lastHardSyncTime,
+      trackingStartTime: this.trackingStartTime,
+      kickPhaseHistory: [...this.kickPhaseHistory],
+      phaseOffsetCalibrated: this.phaseOffsetCalibrated,
+      lastCalibrationTime: this.lastCalibrationTime,
+      lastPhaseError: this.lastPhaseError
+    };
+  }
+  /**
+   * Replace runtime state from a serialized snapshot. `clockOffset` is added
+   * to all wall-clock fields (zero values are treated as "never set" sentinels
+   * and left at zero — same convention as `reset()`).
+   */
+  importSessionState(state, clockOffset) {
+    this.phase = state.phase;
+    this.lastBeatTime = translateTimestamp$1(state.lastBeatTime, clockOffset);
+    this.periodMs = state.periodMs;
+    this.trackedBPM = state.trackedBPM;
+    this.beatCounter = state.beatCounter;
+    this.lastOnsetTime = translateTimestamp$1(state.lastOnsetTime, clockOffset);
+    this.bpmHistory = state.bpmHistory.map((e) => ({
+      time: translateTimestamp$1(e.time, clockOffset),
+      bpm: e.bpm
+    }));
+    this.driftRate = state.driftRate;
+    this.inBreakdown = state.inBreakdown;
+    this.tempoConfidence = state.tempoConfidence;
+    this.inTransition = state.inTransition;
+    this.currentGain = state.currentGain;
+    this.lastBarAdvanceTime = translateTimestamp$1(state.lastBarAdvanceTime, clockOffset);
+    this.pendingBarAdvance = state.pendingBarAdvance;
+    this.lastPhaseWrapTime = translateTimestamp$1(state.lastPhaseWrapTime, clockOffset);
+    this.consecutiveAlignedKicks = state.consecutiveAlignedKicks;
+    this.lastHardSyncTime = translateTimestamp$1(state.lastHardSyncTime, clockOffset);
+    this.trackingStartTime = translateTimestamp$1(state.trackingStartTime, clockOffset);
+    this.kickPhaseHistory = [...state.kickPhaseHistory];
+    this.phaseOffsetCalibrated = state.phaseOffsetCalibrated;
+    this.lastCalibrationTime = translateTimestamp$1(state.lastCalibrationTime, clockOffset);
+    this.lastPhaseError = state.lastPhaseError;
+  }
+}
+function translateTimestamp$1(t, clockOffset) {
+  return t > 0 ? t + clockOffset : 0;
 }
 const FAST_WINDOW_MS = 2e3;
 const MEDIUM_WINDOW_MS = 1e4;
@@ -5345,7 +5617,12 @@ class BeatStateManager {
     return this.state === "LOCKED" || this.state === "BREAKDOWN";
   }
   /**
-   * Reset all state
+   * Reset all state.
+   *
+   * Coverage extended over earlier versions to also clear: per-class
+   * cooldown/rate-cap state, kick interval/BPM history, onset-strength
+   * tracking, band-energy history. Without these, a re-used instance
+   * would carry stale signal-history into a fresh detection session.
    */
   reset() {
     this.state = "TRACKING";
@@ -5358,6 +5635,7 @@ class BeatStateManager {
     this.recentGridScores = [];
     this.lockedBPM = 120;
     this.lastOnsetTime = 0;
+    this.lastKickTime = 0;
     this.eventBuffer = [];
     Object.values(this.envelopes).forEach((env) => env.reset());
     this.debugKickCount = 0;
@@ -5368,6 +5646,153 @@ class BeatStateManager {
       snare: { intervals: [], lastOnsetTime: 0 },
       hat: { intervals: [], lastOnsetTime: 0 }
     };
+    this.recentOnsetStrengths = [];
+    this.averageOnsetStrength = 0.5;
+    this.kickIntervals = [];
+    this.bpmHistory = [];
+    this.bandEnergyHistory = { low: [], mid: [], high: [] };
+    this.eventTimestamps = { kick: [], snare: [], hat: [] };
+    this.lastEventTime = { kick: 0, snare: 0, hat: 0 };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // State serialization (for VijiCore.exportFullState same-process transfer)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Snapshot continuity-relevant runtime state. Wall-clock fields are in
+   * this instance's `performance.now()` clock space. Envelope follower state
+   * is intentionally omitted — receiver re-triggers envelopes naturally as
+   * detected events flow.
+   */
+  exportSessionState() {
+    return {
+      state: this.state,
+      stateEnteredTime: this.stateEnteredTime,
+      kickProfile: { ...this.kickProfile },
+      snareProfile: { ...this.snareProfile },
+      hatProfile: { ...this.hatProfile },
+      recentOnsetStrengths: [...this.recentOnsetStrengths],
+      averageOnsetStrength: this.averageOnsetStrength,
+      tempoMethodAgreement: this.tempoMethodAgreement,
+      gridScore: this.gridScore,
+      consistencyScore: this.consistencyScore,
+      anchorClarity: this.anchorClarity,
+      recentGridScores: [...this.recentGridScores],
+      lockedBPM: this.lockedBPM,
+      lastOnsetTime: this.lastOnsetTime,
+      lastKickTime: this.lastKickTime,
+      kickIntervals: [...this.kickIntervals],
+      bpmHistory: [...this.bpmHistory],
+      adaptiveProfiles: {
+        kick: { samples: this.adaptiveProfiles.kick.samples.map((s) => ({ ...s })) },
+        snareIndependent: { samples: this.adaptiveProfiles.snareIndependent.samples.map((s) => ({ ...s })) },
+        snareLayered: { samples: this.adaptiveProfiles.snareLayered.samples.map((s) => ({ ...s })) },
+        hatIndependent: { samples: this.adaptiveProfiles.hatIndependent.samples.map((s) => ({ ...s })) },
+        hatLayered: { samples: this.adaptiveProfiles.hatLayered.samples.map((s) => ({ ...s })) }
+      },
+      adaptiveThresholds: {
+        snareMinMidRatio: this.adaptiveThresholds.snareMinMidRatio,
+        snareMinMidToBass: this.adaptiveThresholds.snareMinMidToBass,
+        kickMaxMidRatio: this.adaptiveThresholds.kickMaxMidRatio,
+        snareIndependent: { ...this.adaptiveThresholds.snareIndependent },
+        snareLayered: { ...this.adaptiveThresholds.snareLayered },
+        hatIndependent: { ...this.adaptiveThresholds.hatIndependent },
+        hatLayered: { ...this.adaptiveThresholds.hatLayered }
+      },
+      ioiTrackers: {
+        kick: { intervals: [...this.ioiTrackers.kick.intervals], lastOnsetTime: this.ioiTrackers.kick.lastOnsetTime },
+        snare: { intervals: [...this.ioiTrackers.snare.intervals], lastOnsetTime: this.ioiTrackers.snare.lastOnsetTime },
+        hat: { intervals: [...this.ioiTrackers.hat.intervals], lastOnsetTime: this.ioiTrackers.hat.lastOnsetTime }
+      },
+      eventBuffer: this.eventBuffer.map((e) => ({
+        event: { ...e.event },
+        expiresAt: e.expiresAt
+      })),
+      bandEnergyHistory: {
+        low: this.bandEnergyHistory.low.map((e) => ({ ...e })),
+        mid: this.bandEnergyHistory.mid.map((e) => ({ ...e })),
+        high: this.bandEnergyHistory.high.map((e) => ({ ...e }))
+      },
+      eventTimestamps: {
+        kick: [...this.eventTimestamps.kick],
+        snare: [...this.eventTimestamps.snare],
+        hat: [...this.eventTimestamps.hat]
+      },
+      lastEventTime: { ...this.lastEventTime }
+    };
+  }
+  /**
+   * Replace runtime state from a serialized snapshot. `clockOffset` is added
+   * to all wall-clock fields (zero values are treated as "never set" sentinels
+   * and left at zero). Envelopes are NOT restored; they re-trigger from
+   * subsequent events.
+   */
+  importSessionState(state, clockOffset) {
+    this.state = state.state;
+    this.stateEnteredTime = translateTimestamp(state.stateEnteredTime, clockOffset);
+    this.kickProfile = { ...state.kickProfile };
+    this.snareProfile = { ...state.snareProfile };
+    this.hatProfile = { ...state.hatProfile };
+    this.recentOnsetStrengths = [...state.recentOnsetStrengths];
+    this.averageOnsetStrength = state.averageOnsetStrength;
+    this.tempoMethodAgreement = state.tempoMethodAgreement;
+    this.gridScore = state.gridScore;
+    this.consistencyScore = state.consistencyScore;
+    this.anchorClarity = state.anchorClarity;
+    this.recentGridScores = [...state.recentGridScores];
+    this.lockedBPM = state.lockedBPM;
+    this.lastOnsetTime = translateTimestamp(state.lastOnsetTime, clockOffset);
+    this.lastKickTime = translateTimestamp(state.lastKickTime, clockOffset);
+    this.kickIntervals = [...state.kickIntervals];
+    this.bpmHistory = [...state.bpmHistory];
+    this.adaptiveProfiles = {
+      kick: { samples: state.adaptiveProfiles.kick.samples.map((s) => ({ ...s, time: s.time + clockOffset })) },
+      snareIndependent: { samples: state.adaptiveProfiles.snareIndependent.samples.map((s) => ({ ...s, time: s.time + clockOffset })) },
+      snareLayered: { samples: state.adaptiveProfiles.snareLayered.samples.map((s) => ({ ...s, time: s.time + clockOffset })) },
+      hatIndependent: { samples: state.adaptiveProfiles.hatIndependent.samples.map((s) => ({ ...s, time: s.time + clockOffset })) },
+      hatLayered: { samples: state.adaptiveProfiles.hatLayered.samples.map((s) => ({ ...s, time: s.time + clockOffset })) }
+    };
+    this.adaptiveThresholds = {
+      snareMinMidRatio: state.adaptiveThresholds.snareMinMidRatio,
+      snareMinMidToBass: state.adaptiveThresholds.snareMinMidToBass,
+      kickMaxMidRatio: state.adaptiveThresholds.kickMaxMidRatio,
+      snareIndependent: { ...state.adaptiveThresholds.snareIndependent },
+      snareLayered: { ...state.adaptiveThresholds.snareLayered },
+      hatIndependent: { ...state.adaptiveThresholds.hatIndependent },
+      hatLayered: { ...state.adaptiveThresholds.hatLayered }
+    };
+    this.ioiTrackers = {
+      kick: {
+        intervals: [...state.ioiTrackers.kick.intervals],
+        lastOnsetTime: translateTimestamp(state.ioiTrackers.kick.lastOnsetTime, clockOffset)
+      },
+      snare: {
+        intervals: [...state.ioiTrackers.snare.intervals],
+        lastOnsetTime: translateTimestamp(state.ioiTrackers.snare.lastOnsetTime, clockOffset)
+      },
+      hat: {
+        intervals: [...state.ioiTrackers.hat.intervals],
+        lastOnsetTime: translateTimestamp(state.ioiTrackers.hat.lastOnsetTime, clockOffset)
+      }
+    };
+    this.eventBuffer = state.eventBuffer.map((e) => ({
+      event: { ...e.event, time: e.event.time + clockOffset },
+      expiresAt: e.expiresAt + clockOffset
+    }));
+    this.bandEnergyHistory = {
+      low: state.bandEnergyHistory.low.map((e) => ({ time: e.time + clockOffset, value: e.value })),
+      mid: state.bandEnergyHistory.mid.map((e) => ({ time: e.time + clockOffset, value: e.value })),
+      high: state.bandEnergyHistory.high.map((e) => ({ time: e.time + clockOffset, value: e.value }))
+    };
+    this.eventTimestamps = {
+      kick: state.eventTimestamps.kick.map((t) => t + clockOffset),
+      snare: state.eventTimestamps.snare.map((t) => t + clockOffset),
+      hat: state.eventTimestamps.hat.map((t) => t + clockOffset)
+    };
+    this.lastEventTime = {
+      kick: translateTimestamp(state.lastEventTime.kick, clockOffset),
+      snare: translateTimestamp(state.lastEventTime.snare, clockOffset),
+      hat: translateTimestamp(state.lastEventTime.hat, clockOffset)
+    };
   }
   /**
    * Enable/disable enhanced debug mode for comprehensive testing
@@ -5382,6 +5807,9 @@ class BeatStateManager {
   printSummary(durationSec) {
   }
 }
+function translateTimestamp(t, clockOffset) {
+  return t > 0 ? t + clockOffset : 0;
+}
 class DiagnosticLogger {
   events = [];
   sessionStart = 0;
@@ -5712,6 +6140,7 @@ Rejection rate: ${(rejections / duration * 60).toFixed(1)} per minute
 const INSTRUMENTS = ["kick", "snare", "hat"];
 const SAMPLE_RATE = 60;
 const TAP_TIMEOUT_MS = 5e3;
+const SESSION_END_IDLE_MS = 500;
 const MAX_CYCLE_LENGTH = 8;
 const FUZZY_TOLERANCE = 0.18;
 const MIN_REPETITIONS = 3;
@@ -5720,6 +6149,7 @@ const MIN_TAP_INTERVAL_MS = 100;
 const MAX_TAP_HISTORY = 64;
 const MIN_EMA_ALPHA = 0.05;
 const PATTERN_SAME_TOLERANCE = 0.15;
+const STATE_SCHEMA_VERSION = 1;
 function createInstrumentState() {
   return {
     mode: "auto",
@@ -5734,7 +6164,10 @@ function createInstrumentState() {
     replayIndex: 0,
     pendingTapEvents: [],
     envelope: new EnvelopeFollower(0, 300, SAMPLE_RATE),
-    envelopeSmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE)
+    envelopeSmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE),
+    sessionActive: false,
+    sessionEndTimer: null,
+    tapTimeoutTimer: null
   };
 }
 class OnsetTapManager {
@@ -5743,6 +6176,9 @@ class OnsetTapManager {
     snare: createInstrumentState(),
     hat: createInstrumentState()
   };
+  modeChangeListeners = /* @__PURE__ */ new Set();
+  sessionEndListeners = /* @__PURE__ */ new Set();
+  suppressEmissions = false;
   tap(instrument) {
     const s = this.state[instrument];
     const now = performance.now();
@@ -5764,8 +6200,10 @@ class OnsetTapManager {
     }
     s.lastTapTime = now;
     s.pendingTapEvents.push(now);
+    s.sessionActive = true;
+    this.scheduleSessionTimers(instrument);
     if (s.mode === "auto") {
-      s.mode = "tapping";
+      this.setMode(instrument, "tapping");
       if (ioi > 0) {
         const pattern = this.tryRecognizePattern(instrument);
         if (pattern) this.applyPattern(instrument, pattern);
@@ -5783,7 +6221,9 @@ class OnsetTapManager {
   }
   clear(instrument) {
     const s = this.state[instrument];
-    s.mode = "auto";
+    this.cancelSessionTimers(s);
+    s.sessionActive = false;
+    this.setMode(instrument, "auto");
     s.muted = false;
     s.mutedAt = 0;
     s.tapIOIs = [];
@@ -5828,11 +6268,103 @@ class OnsetTapManager {
   isMuted(instrument) {
     return this.state[instrument].muted;
   }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Listener registration
+  // ─────────────────────────────────────────────────────────────────────────
+  onModeChange(listener) {
+    this.modeChangeListeners.add(listener);
+    return () => {
+      this.modeChangeListeners.delete(listener);
+    };
+  }
+  onSessionEnd(listener) {
+    this.sessionEndListeners.add(listener);
+    return () => {
+      this.sessionEndListeners.delete(listener);
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // State serialization
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Serialize per-instrument onset state for cross-instance transfer.
+   * Wall-clock fields are in this instance's `performance.now()` clock space.
+   */
+  exportSessionState() {
+    return {
+      version: STATE_SCHEMA_VERSION,
+      senderTime: performance.now(),
+      instruments: {
+        kick: this.serializeInstrument("kick"),
+        snare: this.serializeInstrument("snare"),
+        hat: this.serializeInstrument("hat")
+      }
+    };
+  }
+  /**
+   * Replace per-instrument state from a serialized payload. Wall-clock fields
+   * in the payload are translated by `clockOffset` (added to non-null sender
+   * timestamps to map them into the receiver's `performance.now()` clock).
+   * For same-process transfer, `clockOffset = 0`.
+   *
+   * `replayLastEventTime` is rebased forward by whole pattern cycles to
+   * eliminate the catch-up burst that would otherwise fire if the payload
+   * is older than one pattern period (phase-preserving — events still land on
+   * the original beat positions modulo `patternSum`).
+   *
+   * Mutation is synchronous; no events are emitted (state replacement is not
+   * a transition). Throws nothing — malformed payloads should be filtered by
+   * the caller via the `version` field.
+   */
+  importSessionState(state, clockOffset) {
+    if (state.version !== STATE_SCHEMA_VERSION) return;
+    this.suppressEmissions = true;
+    try {
+      const now = performance.now();
+      for (const inst of INSTRUMENTS) {
+        const payload = state.instruments[inst];
+        if (!payload) continue;
+        this.applyInstrumentPayload(inst, payload, clockOffset, now);
+      }
+    } finally {
+      this.suppressEmissions = false;
+    }
+  }
+  /**
+   * Validate a serialized payload's shape before importing. Returns null on
+   * success or a `StateImportError` describing the first failure.
+   */
+  static validateOnsetPayload(state) {
+    if (state === null || typeof state !== "object") {
+      return { code: "malformed", details: "payload is not an object" };
+    }
+    const s = state;
+    if (s.version !== STATE_SCHEMA_VERSION) {
+      return {
+        code: "version-mismatch",
+        details: `expected version ${STATE_SCHEMA_VERSION}, got ${String(s.version)}`,
+        ...typeof s.version === "number" ? { payloadVersion: s.version } : {},
+        expectedVersion: STATE_SCHEMA_VERSION
+      };
+    }
+    if (typeof s.senderTime !== "number") {
+      return { code: "invalid-field", details: "senderTime must be a number", field: "senderTime" };
+    }
+    if (!s.instruments || typeof s.instruments !== "object") {
+      return { code: "invalid-field", details: "instruments must be an object", field: "instruments" };
+    }
+    return null;
+  }
   /**
    * Post-process a beat state produced by BeatStateManager.
    * For instruments in auto mode, values pass through unchanged.
    * For tapping/pattern instruments, auto events are suppressed and
    * tap/pattern events + envelopes are injected instead.
+   *
+   * Safe to call with an empty `beatState` (no audio frames available) —
+   * the host's idle ticker drives this in the no-audio scenario so the
+   * artist API receives tap-driven envelopes and events without an audio
+   * source.
    */
   processFrame(beatState, now, dtMs) {
     const result = { ...beatState, events: [...beatState.events] };
@@ -5872,11 +6404,11 @@ class OnsetTapManager {
           s.tapIOIs = [];
           s.pendingTapEvents = [];
           if (s.pattern) {
-            s.mode = "pattern";
+            this.setMode(inst, "pattern");
             s.replayLastEventTime = now;
             s.replayIndex = 0;
           } else {
-            s.mode = "auto";
+            this.setMode(inst, "auto");
           }
           continue;
         }
@@ -5931,6 +6463,159 @@ class OnsetTapManager {
   // ---------------------------------------------------------------------------
   // Private helpers
   // ---------------------------------------------------------------------------
+  /**
+   * Single mutation point for `s.mode`. Fires `onModeChange` (when not
+   * suppressed) so listeners stay consistent regardless of which code path
+   * triggered the transition.
+   */
+  setMode(instrument, newMode) {
+    const s = this.state[instrument];
+    const prevMode = s.mode;
+    if (prevMode === newMode) return;
+    s.mode = newMode;
+    if (!this.suppressEmissions) {
+      this.fireModeChange({ instrument, prevMode, newMode });
+    }
+  }
+  fireModeChange(ev) {
+    for (const listener of this.modeChangeListeners) {
+      try {
+        listener(ev);
+      } catch (err) {
+        console.error("Error in onModeChange listener:", err);
+      }
+    }
+  }
+  fireSessionEnd(ev) {
+    for (const listener of this.sessionEndListeners) {
+      try {
+        listener(ev);
+      } catch (err) {
+        console.error("Error in onSessionEnd listener:", err);
+      }
+    }
+  }
+  /**
+   * Schedule (or reschedule) the per-instrument session timers on every tap.
+   * 500ms timer fires `'pattern'` outcome if instrument is in pattern mode at
+   * fire time. 5s timer fires `'cleared'` outcome if a tapping session
+   * never reached pattern recognition. Either timer transitions mode if the
+   * audio-driven `processFrame` hasn't already done so (controller-side has
+   * no audio path).
+   */
+  scheduleSessionTimers(instrument) {
+    const s = this.state[instrument];
+    this.cancelSessionTimers(s);
+    s.sessionEndTimer = setTimeout(() => this.onSessionEndTimer(instrument), SESSION_END_IDLE_MS);
+    s.tapTimeoutTimer = setTimeout(() => this.onTapTimeoutTimer(instrument), TAP_TIMEOUT_MS);
+  }
+  cancelSessionTimers(s) {
+    if (s.sessionEndTimer !== null) {
+      clearTimeout(s.sessionEndTimer);
+      s.sessionEndTimer = null;
+    }
+    if (s.tapTimeoutTimer !== null) {
+      clearTimeout(s.tapTimeoutTimer);
+      s.tapTimeoutTimer = null;
+    }
+  }
+  /**
+   * 500ms idle timer. Fires `'pattern'` outcome iff the instrument is in
+   * `'pattern'` mode (meaning a recognized pattern survived the idle window).
+   * Other modes are handled by the 5s timer.
+   */
+  onSessionEndTimer(instrument) {
+    const s = this.state[instrument];
+    s.sessionEndTimer = null;
+    if (!s.sessionActive) return;
+    if (s.mode === "pattern" && s.pattern) {
+      s.sessionActive = false;
+      this.fireSessionEnd({ instrument, outcome: "pattern" });
+      if (s.tapTimeoutTimer !== null) {
+        clearTimeout(s.tapTimeoutTimer);
+        s.tapTimeoutTimer = null;
+      }
+    }
+  }
+  /**
+   * 5s tap-idle timer. Resolves the `'cleared'` outcome whether or not
+   * `processFrame` has already transitioned the mode (audio-active path can
+   * race ahead and transition `'tapping' → 'auto'` without firing the event;
+   * we detect that case via `sessionActive` and fire here regardless).
+   */
+  onTapTimeoutTimer(instrument) {
+    const s = this.state[instrument];
+    s.tapTimeoutTimer = null;
+    if (!s.sessionActive) return;
+    if (s.mode === "tapping") {
+      s.tapIOIs = [];
+      s.pendingTapEvents = [];
+      if (s.pattern) {
+        this.setMode(instrument, "pattern");
+        s.replayLastEventTime = performance.now();
+        s.replayIndex = 0;
+        s.sessionActive = false;
+        this.fireSessionEnd({ instrument, outcome: "pattern" });
+      } else {
+        this.setMode(instrument, "auto");
+        s.sessionActive = false;
+        this.fireSessionEnd({ instrument, outcome: "cleared" });
+      }
+    } else if (s.mode === "auto") {
+      s.sessionActive = false;
+      this.fireSessionEnd({ instrument, outcome: "cleared" });
+    } else {
+      s.sessionActive = false;
+    }
+  }
+  serializeInstrument(instrument) {
+    const s = this.state[instrument];
+    return {
+      mode: s.mode,
+      muted: s.muted,
+      pattern: s.pattern ? [...s.pattern] : null,
+      replayLastEventTime: s.replayLastEventTime > 0 ? s.replayLastEventTime : null,
+      replayIndex: s.replayIndex,
+      tapIOIs: [...s.tapIOIs],
+      lastTapTime: s.lastTapTime > 0 ? s.lastTapTime : null,
+      mutedAt: s.mutedAt > 0 ? s.mutedAt : null,
+      refinementIndex: s.refinementIndex,
+      refinementCounts: [...s.refinementCounts]
+    };
+  }
+  applyInstrumentPayload(instrument, payload, clockOffset, now) {
+    const s = this.state[instrument];
+    this.cancelSessionTimers(s);
+    s.sessionActive = false;
+    const translatedReplayLast = payload.replayLastEventTime !== null ? payload.replayLastEventTime + clockOffset : 0;
+    const translatedLastTap = payload.lastTapTime !== null ? payload.lastTapTime + clockOffset : 0;
+    const translatedMutedAt = payload.mutedAt !== null ? payload.mutedAt + clockOffset : 0;
+    let rebasedReplayLast = translatedReplayLast;
+    if (payload.pattern && payload.pattern.length > 0 && translatedReplayLast > 0) {
+      const patternSum = payload.pattern.reduce((a, b) => a + b, 0);
+      if (patternSum > 0) {
+        const elapsed = now - translatedReplayLast;
+        if (elapsed > patternSum) {
+          const cycles = Math.floor(elapsed / patternSum);
+          rebasedReplayLast = translatedReplayLast + cycles * patternSum;
+        }
+      }
+    }
+    s.mode;
+    s.mode = payload.mode;
+    s.muted = payload.muted;
+    s.mutedAt = translatedMutedAt;
+    s.tapIOIs = [...payload.tapIOIs];
+    s.lastTapTime = translatedLastTap;
+    s.pattern = payload.pattern ? [...payload.pattern] : null;
+    s.refinementIndex = payload.refinementIndex;
+    s.refinementCounts = [...payload.refinementCounts];
+    s.replayLastEventTime = rebasedReplayLast;
+    s.replayIndex = payload.replayIndex;
+    s.pendingTapEvents = [];
+    s.envelope.reset();
+    s.envelopeSmoothed.reset();
+  }
   /**
    * Handle a tap that arrives while already in pattern mode.
    * Matching taps refine the pattern via EMA and re-anchor phase.
@@ -6039,7 +6724,7 @@ class OnsetTapManager {
   applyPattern(instrument, pattern) {
     const s = this.state[instrument];
     s.pattern = pattern;
-    s.mode = "pattern";
+    this.setMode(instrument, "pattern");
     s.refinementIndex = 0;
     s.refinementCounts = new Array(pattern.length).fill(MIN_REPETITIONS);
     if (s.replayLastEventTime === 0 || s.replayLastEventTime < s.lastTapTime) {
@@ -6748,6 +7433,13 @@ class AudioSystem {
   beatDetectionEnabled = true;
   onsetDetectionEnabled = true;
   autoGainEnabled = true;
+  // Idle ticker — drives `OnsetTapManager.processFrame` via rAF when no audio
+  // is connected, so taps still produce envelope/event output through the
+  // artist API. Paused when audio connects (worklet/analyser path takes over);
+  // resumed on disconnect. See lifecycle methods below for the strict
+  // start-stop ordering invariant.
+  idleTickerHandle = null;
+  idleTickerLastTime = 0;
   /**
    * Enable or disable comprehensive debug logging for all layers
    * Enables enhanced logging in: MultiOnsetDetection, BeatStateManager
@@ -7212,7 +7904,10 @@ class AudioSystem {
   }
   // Analysis configuration
   fftSize = 2048;
-  // Beat state for main channel (not on AudioChannel because it's main-only)
+  // Beat state for main channel (not on AudioChannel because it's main-only).
+  // `bpm: 0` is the documented "no signal" sentinel; `runBeatPipeline`'s
+  // `lastNonZeroBpm` carry-over fills in a meaningful value as soon as audio
+  // is connected and the first BPM hypothesis is formed.
   audioStateBeat = {
     kick: 0,
     snare: 0,
@@ -7223,7 +7918,7 @@ class AudioSystem {
     hatSmoothed: 0,
     anySmoothed: 0,
     events: [],
-    bpm: 120,
+    bpm: 0,
     confidence: 0,
     isLocked: false
   };
@@ -7253,6 +7948,8 @@ class AudioSystem {
       anySmoothed: new EnvelopeFollower(5, 500, sampleRate)
     };
     this.resetEssentiaBandHistories();
+    this.tickIdle = this.tickIdle.bind(this);
+    this.startIdleTicker();
   }
   /**
    * Get the current audio analysis state (for host-side usage)
@@ -7318,8 +8015,17 @@ class AudioSystem {
   /**
    * Connect a channel to Web Audio nodes (source, worklet/analyser).
    * Used for both main and additional channels.
+   *
+   * Lifecycle ordering invariant: when wiring the main channel, the idle
+   * ticker MUST be stopped before the first `await` so that an in-flight
+   * tick cannot race the audio path coming online. The ticker callback
+   * additionally guards on `mainChannel.audioState.isConnected` for
+   * belt-and-braces.
    */
   async connectChannel(ch, audioStream, isMain) {
+    if (isMain) {
+      this.stopIdleTicker();
+    }
     ch.disconnectNodes();
     ch.refreshFFTResources();
     ch.workletFrameCount = 0;
@@ -7328,6 +8034,7 @@ class AudioSystem {
       console.warn(`No audio tracks in stream for channel ${ch.streamIndex}`);
       ch.audioState.isConnected = false;
       this.sendChannelResults(ch, isMain);
+      if (isMain) this.startIdleTicker();
       return;
     }
     try {
@@ -7390,6 +8097,7 @@ class AudioSystem {
       console.error(`Failed to set up audio for channel ${ch.streamIndex}:`, error);
       ch.audioState.isConnected = false;
       ch.disconnectNodes();
+      if (isMain) this.startIdleTicker();
     }
     this.sendChannelResults(ch, isMain);
   }
@@ -7403,17 +8111,30 @@ class AudioSystem {
   }
   /**
    * Disconnect the main audio stream (does NOT close AudioContext -- additional channels may still be active).
+   *
+   * Lifecycle ordering invariant: tear down the audio nodes first, clear any
+   * stale frequency / waveform buffers, then restart the idle ticker. The
+   * ticker callback's defensive `isConnected` guard prevents any stale tick
+   * from observing a half-disconnected state.
    */
   disconnectMainStream() {
     this.mainChannel.disconnectNodes();
     this.mainChannel.audioState.isConnected = false;
     this.mainChannel.isAnalysisRunning = false;
     this.mainChannel.currentStream = null;
+    if (this.mainChannel.frequencyData) {
+      this.mainChannel.frequencyData.fill(0);
+    }
+    if (this.mainChannel.timeDomainData) {
+      this.mainChannel.timeDomainData.fill(0);
+    }
+    this.mainChannel.lastWaveformFrame = null;
     this.resetAudioValues();
     if (this.additionalChannels.size === 0) {
       this.stopAnalysisLoop();
       this.stopStalenessTimer();
     }
+    this.startIdleTicker();
     this.sendChannelResults(this.mainChannel, true);
     this.debugLog("Main audio stream disconnected (host-side)");
   }
@@ -7647,7 +8368,7 @@ class AudioSystem {
       hatSmoothed: 0,
       anySmoothed: 0,
       events: [],
-      bpm: 120,
+      bpm: 0,
       confidence: 0,
       isLocked: false
     };
@@ -7659,6 +8380,7 @@ class AudioSystem {
   resetAudioState() {
     this.stopAnalysisLoop();
     this.stopStalenessTimer();
+    this.stopIdleTicker();
     this.resetEssentiaBandHistories();
     for (const ch of this.additionalChannels.values()) {
       ch.destroy();
@@ -7783,6 +8505,94 @@ class AudioSystem {
   isOnsetMuted(instrument) {
     return this.onsetTapManager.isMuted(instrument);
   }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Onset event subscriptions (forward to OnsetTapManager).
+  // Returned `Unsubscribe` removes the listener.
+  // ─────────────────────────────────────────────────────────────────────────
+  onOnsetModeChange(listener) {
+    return this.onsetTapManager.onModeChange(listener);
+  }
+  onOnsetSessionEnd(listener) {
+    return this.onsetTapManager.onSessionEnd(listener);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // State serialization. Onset-only export is cross-device-safe; the full
+  // audio block is for same-process scene-switch transfer (sender's audio
+  // analysis state would corrupt receiver's tracking on a different source).
+  // ─────────────────────────────────────────────────────────────────────────
+  exportOnsetSessionState() {
+    return this.onsetTapManager.exportSessionState();
+  }
+  importOnsetSessionState(state, clockOffset) {
+    this.onsetTapManager.importSessionState(state, clockOffset);
+  }
+  exportAudioAnalysisState() {
+    return {
+      onset: this.onsetTapManager.exportSessionState().instruments,
+      bpmTracker: this.tempoInduction.exportSessionState(),
+      pll: this.pll.exportSessionState(),
+      beatState: this.stateManager.exportSessionState()
+    };
+  }
+  importAudioAnalysisState(state, clockOffset) {
+    this.onsetTapManager.importSessionState(
+      { version: 1, senderTime: performance.now(), instruments: state.onset },
+      clockOffset
+    );
+    this.tempoInduction.importSessionState(state.bpmTracker, clockOffset);
+    this.pll.importSessionState(state.pll, clockOffset);
+    this.stateManager.importSessionState(state.beatState, clockOffset);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Idle ticker — drives `OnsetTapManager.processFrame` via rAF when no audio
+  // is connected. Constructs an empty `beatState` and reuses the existing
+  // `processFrame` (verified correctness-preserving on empty input), so taps
+  // produce envelope/event output through the artist API the same way they
+  // do when audio is active.
+  // ─────────────────────────────────────────────────────────────────────────
+  startIdleTicker() {
+    if (this.idleTickerHandle !== null) return;
+    if (typeof requestAnimationFrame === "undefined") return;
+    this.idleTickerLastTime = performance.now();
+    this.idleTickerHandle = requestAnimationFrame(this.tickIdle);
+  }
+  stopIdleTicker() {
+    if (this.idleTickerHandle === null) return;
+    if (typeof cancelAnimationFrame !== "undefined") {
+      cancelAnimationFrame(this.idleTickerHandle);
+    }
+    this.idleTickerHandle = null;
+  }
+  tickIdle(now) {
+    this.idleTickerHandle = null;
+    if (this.mainChannel.audioState.isConnected) return;
+    const dtMs = Math.min(100, now - this.idleTickerLastTime);
+    this.idleTickerLastTime = now;
+    if (this.onsetDetectionEnabled && this.beatDetectionEnabled) {
+      const empty = this.makeEmptyBeatState();
+      this.audioStateBeat = this.onsetTapManager.processFrame(empty, now, dtMs);
+      this.sendChannelResults(this.mainChannel, true);
+    }
+    if (typeof requestAnimationFrame !== "undefined") {
+      this.idleTickerHandle = requestAnimationFrame(this.tickIdle);
+    }
+  }
+  makeEmptyBeatState() {
+    return {
+      kick: 0,
+      snare: 0,
+      hat: 0,
+      any: 0,
+      kickSmoothed: 0,
+      snareSmoothed: 0,
+      hatSmoothed: 0,
+      anySmoothed: 0,
+      events: [],
+      bpm: 0,
+      confidence: 0,
+      isLocked: false
+    };
+  }
   /**
    * Get current BPM (manual or auto-detected)
    */
@@ -8821,6 +9631,10 @@ class VijiCore {
   parameterDefinedListeners = /* @__PURE__ */ new Set();
   parameterErrorListeners = /* @__PURE__ */ new Set();
   capabilitiesChangeListeners = /* @__PURE__ */ new Set();
+  // State-import error listeners. Fire on `importFullState` payloads that fail
+  // version or shape validation; consumers surface meaningful UI feedback
+  // rather than relying on console.warn.
+  stateImportErrorListeners = /* @__PURE__ */ new Set();
   // Performance tracking (basic for Phase 1)
   stats = {
     frameTime: 0,
@@ -9793,6 +10607,86 @@ class VijiCore {
   offParameterError(listener) {
     this.parameterErrorListeners.delete(listener);
   }
+  // ─────────────────────────────────────────────────────────────────────────
+  // State serialization (cross-instance transfer)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Snapshot the full audio analysis + onset state for cross-instance
+   * transfer. Use for **same-process scene-switch** continuity (a fresh
+   * `VijiCore` can resume detection where the previous one left off).
+   *
+   * For **cross-device** transfer, prefer `audio.onset.exportSessionState`
+   * — the controller's audio analysis state doesn't apply to the host's
+   * audio source and would corrupt detection.
+   *
+   * Wall-clock fields are in this instance's `performance.now()` clock space.
+   * Receiver applies `clockOffset` on import (use `0` for same-process).
+   *
+   * **Staleness caveat**: the audio block is robust to scene-load gaps under
+   * ~1 second. Longer gaps (>5s, e.g. cold cache + slow network) may cause
+   * stale-timestamp drift in `gridLockMemoryTime` / `warmupStartTimeMs`;
+   * callers should treat that as a degraded path and skip the audio block.
+   */
+  exportFullState() {
+    this.validateReady();
+    const senderTime = performance.now();
+    const out = { version: 1, senderTime };
+    if (this.audioSystem) {
+      const audio = this.audioSystem.exportAudioAnalysisState();
+      out.onset = audio.onset;
+      out.audio = audio;
+    }
+    return out;
+  }
+  /**
+   * Replace the audio analysis + onset state from a serialized payload.
+   * `clockOffset` is added to all sender-clocked fields (`0` for same-process,
+   * NTP-derived for cross-device). Mutation is synchronous; no `onModeChange`
+   * or `onSessionEnd` events are emitted (state replacement is not a transition).
+   *
+   * Validates `version`; on mismatch, fires `onStateImportError` and leaves
+   * existing state intact.
+   */
+  importFullState(state, clockOffset) {
+    this.validateReady();
+    const validation = validateCoreStatePayload(state);
+    if (validation) {
+      this.fireStateImportError(validation);
+      return;
+    }
+    if (!this.audioSystem) return;
+    if (state.audio) {
+      this.audioSystem.importAudioAnalysisState(state.audio, clockOffset);
+    } else if (state.onset) {
+      this.audioSystem.importOnsetSessionState(
+        { version: 1, senderTime: state.senderTime, instruments: state.onset },
+        clockOffset
+      );
+    }
+  }
+  /**
+   * Listen for state-import validation errors. Fires when `importFullState`
+   * or `audio.onset.importSessionState` rejects a payload (version mismatch,
+   * malformed shape, invalid field). Existing state is left intact when
+   * an error fires.
+   *
+   * @returns Unsubscribe function. Call to remove the listener.
+   */
+  onStateImportError(listener) {
+    this.stateImportErrorListeners.add(listener);
+    return () => {
+      this.stateImportErrorListeners.delete(listener);
+    };
+  }
+  fireStateImportError(error) {
+    for (const listener of this.stateImportErrorListeners) {
+      try {
+        listener(error);
+      } catch (err) {
+        console.error("Error in onStateImportError listener:", err);
+      }
+    }
+  }
   /**
    * Notify parameter change listeners
    */
@@ -10221,6 +11115,73 @@ class VijiCore {
       isMuted: (instrument) => {
         this.validateReady();
         return this.audioSystem?.isOnsetMuted(instrument) ?? false;
+      },
+      /**
+       * Listen for instrument mode transitions (`'auto' | 'tapping' | 'pattern'`).
+       * Fires on every transition including the first tap (`'auto' → 'tapping'`)
+       * and pattern recognition (`'tapping' → 'pattern'`). Imported state does
+       * NOT fire mode-change events — state replacement is not a transition.
+       *
+       * @returns Unsubscribe function. Call to remove the listener.
+       */
+      onModeChange: (listener) => {
+        this.validateReady();
+        return this.audioSystem?.onOnsetModeChange(listener) ?? (() => {
+        });
+      },
+      /**
+       * Listen for natural session-end events. Fires when:
+       * - 500ms elapse since last tap with instrument in `'pattern'` mode
+       *   (outcome `'pattern'`), or
+       * - 5s elapse in `'tapping'` mode without a recognized pattern
+       *   (outcome `'cleared'`; instrument transitions to `'auto'`).
+       *
+       * Explicit `clear()` calls do NOT fire this event (caller-initiated;
+       * caller already knows). Imported state does NOT fire either.
+       *
+       * @returns Unsubscribe function. Call to remove the listener.
+       */
+      onSessionEnd: (listener) => {
+        this.validateReady();
+        return this.audioSystem?.onOnsetSessionEnd(listener) ?? (() => {
+        });
+      },
+      /**
+       * Snapshot per-instrument onset state for cross-instance transfer.
+       * Cross-device-safe (no audio analysis state included). Pair with
+       * `importSessionState` on a receiver. Wall-clock fields are in this
+       * instance's `performance.now()` clock space.
+       */
+      exportSessionState: () => {
+        this.validateReady();
+        return this.audioSystem?.exportOnsetSessionState() ?? {
+          version: 1,
+          senderTime: performance.now(),
+          instruments: {}
+        };
+      },
+      /**
+       * Replace per-instrument onset state from a serialized payload.
+       * `clockOffset` is added to all sender-clocked fields during import
+       * (use `0` for same-process transfer; NTP-derived offset for cross-device).
+       * Mutation is synchronous; no events are emitted.
+       *
+       * Patterns are rebased forward by whole pattern cycles to eliminate
+       * the catch-up burst that would otherwise occur on stale payloads
+       * (phase-preserving — events still land on the original beat positions
+       * modulo pattern length).
+       *
+       * Validates `version`; on mismatch, fires `onStateImportError` and
+       * leaves existing state intact.
+       */
+      importSessionState: (state, clockOffset) => {
+        this.validateReady();
+        const validation = OnsetTapManager.validateOnsetPayload(state);
+        if (validation) {
+          this.fireStateImportError(validation);
+          return;
+        }
+        this.audioSystem?.importOnsetSessionState(state, clockOffset);
       }
     },
     /**
@@ -10510,6 +11471,7 @@ class VijiCore {
     this.parameterDefinedListeners.clear();
     this.parameterErrorListeners.clear();
     this.capabilitiesChangeListeners.clear();
+    this.stateImportErrorListeners.clear();
     this.unlinkEventSource();
     this.unlinkFrameSources();
     for (const [deviceId] of this.deviceVideoCoordinators) {
@@ -10601,7 +11563,25 @@ class VijiCore {
     }
   }
 }
-const VERSION = "0.3.29";
+function validateCoreStatePayload(state) {
+  if (state === null || typeof state !== "object") {
+    return { code: "malformed", details: "payload is not an object" };
+  }
+  const s = state;
+  if (s.version !== 1) {
+    return {
+      code: "version-mismatch",
+      details: `expected version 1, got ${String(s.version)}`,
+      ...typeof s.version === "number" ? { payloadVersion: s.version } : {},
+      expectedVersion: 1
+    };
+  }
+  if (typeof s.senderTime !== "number") {
+    return { code: "invalid-field", details: "senderTime must be a number", field: "senderTime" };
+  }
+  return null;
+}
+const VERSION = "0.5.1";
 export {
   AudioSystem as A,
   VERSION as V,
@@ -10609,4 +11589,4 @@ export {
   VijiCoreError as b,
   getDefaultExportFromCjs as g
 };
-//# sourceMappingURL=index-Oj_9v8r4.js.map
+//# sourceMappingURL=index-Cqh1k_49.js.map