@viji-dev/core 0.8.5 → 0.8.7

package/dist/{index-DbnjzNSY.js → index-I8omPYZ-.js}

@@ -1520,7 +1520,7 @@ class lB {
     if (!this.isInitialized)
       return this.initPromise ? this.initPromise : (this.initPromise = (async () => {
         try {
-          const A = await import("./essentia.js-core.es-CC_3Ap1i.js"), B = await import("./essentia-wasm.web-DwSQMYtc.js").then((g) => g.e), I = A.Essentia || A.default?.Essentia || A.default;
+          const A = await import("./essentia.js-core.es-CC_3Ap1i.js"), B = await import("./essentia-wasm.web-CB3NZc0t.js").then((g) => g.e), I = A.Essentia || A.default?.Essentia || A.default;
           let Q = B.default || B.EssentiaWASM || B.default?.EssentiaWASM;
           if (!Q)
             throw new Error("WASM module not found - check essentia-wasm.web.js export");
@@ -6941,7 +6941,9 @@ class K {
   isInitializing = !1;
   instanceId;
   screenRefreshRate = 60;
-  // Will be detected
+  // Sensible default (most common rate); refined asynchronously after init
+  refreshRateRafId = null;
+  // Handle for the non-blocking refresh-rate measurement loop
   debugMode = !1;
   // Debug logging control
   /**
@@ -7001,7 +7003,6 @@ class K {
   eventSourceCore = null;
   frameSourceCores = [];
   eventSourceCleanup = null;
-  resizeSyncEnabled = !1;
   // Interaction state management
   currentInteractionEnabled;
   // Parameter system for Phase 2
@@ -7220,11 +7221,7 @@ class K {
         effectiveWidth: A.width,
         effectiveHeight: A.height,
         displayScale: this.iframeManager.getDisplayScale()
-      }), await this.detectScreenRefreshRate(), this.isDestroyed)
-        throw new S("Initialization cancelled", "INITIALIZATION_CANCELLED");
-      if (this.workerManager.postMessage("refresh-rate-update", {
-        screenRefreshRate: this.screenRefreshRate
-      }), this.config.audioStream && await this.setAudioStream(this.config.audioStream), this.isDestroyed)
+      }), this.detectScreenRefreshRate(), this.config.audioStream && await this.setAudioStream(this.config.audioStream), this.isDestroyed)
         throw new S("Initialization cancelled", "INITIALIZATION_CANCELLED");
       for (let B = 0; B < this.audioStreams.length; B++) {
         const I = K.AUDIO_ADDITIONAL_BASE + B;
@@ -7605,49 +7602,32 @@ class K {
     }, [A]);
   }
   /**
-   * Link this core to receive events from a source core
-   * @param syncResolution Smart default: true for headless, false for visible
+   * Link this core to receive input events (mouse/keyboard/touch) from a
+   * source core. Event forwarding only — resolution and frame-rate are pushed
+   * mixer→sources through the frame-source relationship (see
+   * {@link linkFrameSources}), not here.
    */
-  linkEventSource(A, B) {
+  linkEventSource(A) {
     if (this.eventSourceCore && this.unlinkEventSource(), this.eventSourceCore = A, A.iframeManager) {
-      const Q = A.iframeManager, g = (i) => {
-        this.injectMouseEvent(i);
-      }, E = (i) => {
-        this.injectKeyboardEvent(i);
-      }, C = (i) => {
-        this.injectTouchEvent(i);
+      const B = A.iframeManager, I = (E) => {
+        this.injectMouseEvent(E);
+      }, Q = (E) => {
+        this.injectKeyboardEvent(E);
+      }, g = (E) => {
+        this.injectTouchEvent(E);
       };
-      Q.onInteractionEvent("mouse-update", g), Q.onInteractionEvent("keyboard-update", E), Q.onInteractionEvent("touch-update", C), this.eventSourceCleanup = () => {
-        Q.offInteractionEvent("mouse-update", g), Q.offInteractionEvent("keyboard-update", E), Q.offInteractionEvent("touch-update", C);
+      B.onInteractionEvent("mouse-update", I), B.onInteractionEvent("keyboard-update", Q), B.onInteractionEvent("touch-update", g), this.eventSourceCleanup = () => {
+        B.offInteractionEvent("mouse-update", I), B.offInteractionEvent("keyboard-update", Q), B.offInteractionEvent("touch-update", g);
       };
     } else
       console.warn(`[${this.instanceId}] Cannot link event source - ${A.instanceId} has no iframeManager`);
-    const I = B ?? this.isHeadless;
-    if (this.resizeSyncEnabled = I, I && !A.isHeadless && A.iframeManager) {
-      const Q = A.iframeManager.getEffectiveResolution();
-      Q && (this.setResolution(Q), this.debugLog(`Resolution synced: ${Q.width}x${Q.height}`));
-      const g = () => {
-        if (this.resizeSyncEnabled && A.iframeManager) {
-          const E = A.iframeManager.getEffectiveResolution();
-          E && (this.debugLog(`[ResizeSync] ${A.instanceId} → ${this.instanceId}: ${E.width}x${E.height}`), this.setResolution(E));
-        }
-      };
-      if (A.config.hostContainer) {
-        const E = new ResizeObserver(g);
-        E.observe(A.config.hostContainer);
-        const C = this.eventSourceCleanup;
-        this.eventSourceCleanup = () => {
-          E.disconnect(), C && C();
-        };
-      }
-    }
     this.debugLog(`Linked event source: ${A.instanceId}`);
   }
   /**
    * Unlink from event source
    */
   unlinkEventSource() {
-    this.eventSourceCore && (this.eventSourceCleanup && (this.eventSourceCleanup(), this.eventSourceCleanup = null), this.eventSourceCore = null, this.resizeSyncEnabled = !1);
+    this.eventSourceCore && (this.eventSourceCleanup && (this.eventSourceCleanup(), this.eventSourceCleanup = null), this.eventSourceCore = null);
   }
   /**
    * Link source cores that this core will pull frames from
@@ -7658,7 +7638,7 @@ class K {
     this.debugLog(`[Compositor] Mixer renderer type: ${B}`), A.forEach((I, Q) => {
       const g = I.sceneRenderer, E = B === "shader";
       this.debugLog(`[Compositor] Source ${Q}: ${g} → ${B}, flipY=${E}`), I.enableAutoCapture({ flipY: E });
-    }), this.debugLog(`[Compositor] Linked ${A.length} frame source(s)`);
+    }), this.syncFrameSourceQuality(), this.debugLog(`[Compositor] Linked ${A.length} frame source(s)`);
   }
   /**
    * Unlink all frame sources
@@ -7666,6 +7646,26 @@ class K {
   unlinkFrameSources() {
     this.frameSourceCores.forEach((A) => A.disableAutoCapture()), this.frameSourceCores = [];
   }
+  /**
+   * Push this (mixer) core's effective resolution and frame-rate mode to every
+   * linked frame source, so sources render at exactly the compositor's quality
+   * (no wasted pixels/frames the compositor would discard). No-op unless frame
+   * sources are linked, so normal single-core use is unaffected. Re-invoked on
+   * link and on every `setResolution`/`setFrameRate`/`updateResolution`.
+   *
+   * Each source is guarded on `ready` (a not-yet-initialized or destroyed
+   * source would throw from `setResolution`/`setFrameRate`). `setFrameRate` is
+   * async; its promise is intentionally not awaited (fire-and-forget) with a
+   * catch so a source torn down mid-call cannot raise an unhandled rejection.
+   */
+  syncFrameSourceQuality() {
+    if (this.frameSourceCores.length === 0 || !this.iframeManager) return;
+    const A = this.iframeManager.getEffectiveResolution(), B = this.config.frameRateMode;
+    for (const I of this.frameSourceCores)
+      I.ready && (I.setResolution({ width: A.width, height: A.height }), I.setFrameRate(B).catch(
+        (Q) => this.debugLog(`[Compositor] frame-source setFrameRate failed: ${Q}`)
+      ));
+  }
   /**
    * Get parameter groups filtered by active capabilities
    */
@@ -8022,7 +8022,7 @@ class K {
    * @param mode - render every animation frame (`'full'`), every 2nd (`'half'`), every 4th (`'quarter'`), or every 8th (`'eighth'`)
    */
   async setFrameRate(A) {
-    this.validateReady(), this.config.frameRateMode = A, this.workerManager && this.workerManager.postMessage("frame-rate-update", { mode: A }), this.updateFrameRateStats(), this.debugLog(`Scene frame rate set to ${A} (${this.instanceId})`);
+    this.validateReady(), this.config.frameRateMode = A, this.workerManager && this.workerManager.postMessage("frame-rate-update", { mode: A }), this.updateFrameRateStats(), this.syncFrameSourceQuality(), this.debugLog(`Scene frame rate set to ${A} (${this.instanceId})`);
   }
   /**
    * Sets the CV processing frame rate mode (relative to scene frame rate)
@@ -8042,7 +8042,7 @@ class K {
       effectiveWidth: A.width,
       effectiveHeight: A.height,
       displayScale: this.iframeManager.getDisplayScale()
-    }), this.stats.resolution = A, this.stats.scale = this.iframeManager.getScale(), this.debugLog(`Resolution updated successfully (${this.instanceId})`, A);
+    }), this.stats.resolution = A, this.stats.scale = this.iframeManager.getScale(), this.syncFrameSourceQuality(), this.debugLog(`Resolution updated successfully (${this.instanceId})`, A);
   }
   /**
    * Sets the audio stream for analysis
@@ -8498,22 +8498,33 @@ class K {
       effectiveWidth: B.width,
       effectiveHeight: B.height,
       displayScale: this.iframeManager.getDisplayScale()
-    }), this.stats.resolution = B, this.debugLog(`Resolution: ${B.width}x${B.height}`);
+    }), this.stats.resolution = B, this.syncFrameSourceQuality(), this.debugLog(`Resolution: ${B.width}x${B.height}`);
   }
   /**
-   * Detects the screen refresh rate
+   * Measures the screen refresh rate over 60 animation frames, off the init
+   * critical path. Runs fire-and-forget: it does NOT gate `ready`, so the host
+   * can control a visibly-rendering core immediately. On completion it pushes
+   * the refined value to the worker (refresh-rate-update) and updates host
+   * stats. Until then both sides use the 60 default. Measured once, never
+   * re-run. Cancelled on `destroy()` via `refreshRateRafId`.
    */
-  async detectScreenRefreshRate() {
-    return new Promise((A) => {
-      let B = 0;
-      const I = performance.now(), Q = () => {
-        if (B++, B === 60) {
-          const g = performance.now() - I;
-          this.screenRefreshRate = Math.round(6e4 / g), this.debugLog("Detected screen refresh rate:", this.screenRefreshRate + "Hz"), A();
-        } else B < 60 && requestAnimationFrame(Q);
-      };
-      requestAnimationFrame(Q);
-    });
+  detectScreenRefreshRate() {
+    let A = 0;
+    const B = performance.now(), I = () => {
+      if (this.isDestroyed) {
+        this.refreshRateRafId = null;
+        return;
+      }
+      if (A++, A === 60) {
+        this.refreshRateRafId = null;
+        const Q = performance.now() - B;
+        if (this.screenRefreshRate = Math.round(6e4 / Q), this.debugLog("Detected screen refresh rate:", this.screenRefreshRate + "Hz"), this.isDestroyed || !this.workerManager) return;
+        this.workerManager.postMessage("refresh-rate-update", {
+          screenRefreshRate: this.screenRefreshRate
+        }), this.stats.frameRate.screenRefreshRate = this.screenRefreshRate;
+      } else A < 60 && (this.refreshRateRafId = requestAnimationFrame(I));
+    };
+    this.refreshRateRafId = requestAnimationFrame(I);
   }
   /**
    * Updates frame rate statistics
@@ -8693,7 +8704,7 @@ class K {
    */
   async destroy() {
     if (!this.isDestroyed) {
-      this.isDestroyed = !0, this.parameterGroups.clear(), this.parameterValues.clear(), this.parameterListeners.clear(), this.parameterDefinedListeners.clear(), this.parameterErrorListeners.clear(), this.capabilitiesChangeListeners.clear(), this.stateImportErrorListeners.clear(), this.sceneRuntimeErrorListeners.clear(), this.sceneConsoleListeners.clear(), this.performanceSnapshotListeners.clear(), this.capabilityTransitionListeners.clear(), this.unlinkEventSource(), this.unlinkFrameSources();
+      this.isDestroyed = !0, this.refreshRateRafId !== null && (cancelAnimationFrame(this.refreshRateRafId), this.refreshRateRafId = null), this.parameterGroups.clear(), this.parameterValues.clear(), this.parameterListeners.clear(), this.parameterDefinedListeners.clear(), this.parameterErrorListeners.clear(), this.capabilitiesChangeListeners.clear(), this.stateImportErrorListeners.clear(), this.sceneRuntimeErrorListeners.clear(), this.sceneConsoleListeners.clear(), this.performanceSnapshotListeners.clear(), this.capabilityTransitionListeners.clear(), this.unlinkEventSource(), this.unlinkFrameSources();
       for (const [A] of this.deviceVideoCoordinators)
         await this.clearDeviceVideo(A);
       this.deviceVideoCoordinators.clear(), this.deviceVideoStreamIndices.clear(), this.deviceSensorManager && (this.deviceSensorManager.destroy(), this.deviceSensorManager = null);
@@ -8752,7 +8763,7 @@ function DI(h) {
     expectedVersion: 1
   } : typeof A.senderTime != "number" ? { code: "invalid-field", details: "senderTime must be a number", field: "senderTime" } : null;
 }
-const hI = "0.8.4";
+const hI = "0.8.6";
 export {
   yA as A,
   hI as V,
@@ -8760,4 +8771,4 @@ export {
   S as b,
   PB as g
 };
-//# sourceMappingURL=index-DbnjzNSY.js.map
+//# sourceMappingURL=index-I8omPYZ-.js.map

package/dist/index.d.ts

@@ -1273,14 +1273,16 @@ export declare interface FramePerfSample {
 declare interface FrameRateInfo {
     mode: FrameRateMode;
     /**
-     * Best-effort display refresh rate in Hz, detected once at init by averaging
-     * 60 `requestAnimationFrame` intervals.
+     * Best-effort display refresh rate in Hz, measured once by averaging 60
+     * `requestAnimationFrame` intervals. The measurement runs asynchronously and
+     * does not block `initialize()`, so for the first few seconds after init this
+     * reads the `60` default until the measured value lands.
      *
      * **Not reliable under load** — if the page is already GPU-stressed during
      * initialization, throttled rAFs inflate the interval and deflate the value
      * (e.g. 10 Hz on a 60 Hz monitor), and it is never re-measured. rAF cadence
      * cannot recover the true refresh post-load. **Do not derive performance
-     * thresholds from this** — prefer an absolute FPS target.
+     * thresholds from this** — prefer an absolute FPS target or `effectiveRefreshRate`.
      */
     screenRefreshRate: number;
     effectiveRefreshRate: number;
@@ -2657,7 +2659,7 @@ declare type TrackingState = 'TRACKING' | 'LOCKED' | 'BREAKDOWN' | 'LOST';
 /** Returned by `on*` listener registration calls; invoke to unsubscribe. */
 export declare type Unsubscribe = () => void;
 
-export declare const VERSION = "0.8.4";
+export declare const VERSION = "0.8.6";
 
 /**
  * Real-time video API: drawable frame, dimensions, and the source-side
@@ -3022,6 +3024,7 @@ export declare class VijiCore {
     private isInitializing;
     private instanceId;
     private screenRefreshRate;
+    private refreshRateRafId;
     private debugMode;
     /**
      * Debug logging helper
@@ -3051,7 +3054,6 @@ export declare class VijiCore {
     private eventSourceCore;
     private frameSourceCores;
     private eventSourceCleanup;
-    private resizeSyncEnabled;
     private currentInteractionEnabled;
     private parameterGroups;
     private parameterValues;
@@ -3259,10 +3261,12 @@ export declare class VijiCore {
      */
     injectFrame(bitmap: ImageBitmap, streamIndex: number): void;
     /**
-     * Link this core to receive events from a source core
-     * @param syncResolution Smart default: true for headless, false for visible
+     * Link this core to receive input events (mouse/keyboard/touch) from a
+     * source core. Event forwarding only — resolution and frame-rate are pushed
+     * mixer→sources through the frame-source relationship (see
+     * {@link linkFrameSources}), not here.
      */
-    linkEventSource(sourceCore: VijiCore, syncResolution?: boolean): void;
+    linkEventSource(sourceCore: VijiCore): void;
     /**
      * Unlink from event source
      */
@@ -3275,6 +3279,19 @@ export declare class VijiCore {
      * Unlink all frame sources
      */
     unlinkFrameSources(): void;
+    /**
+     * Push this (mixer) core's effective resolution and frame-rate mode to every
+     * linked frame source, so sources render at exactly the compositor's quality
+     * (no wasted pixels/frames the compositor would discard). No-op unless frame
+     * sources are linked, so normal single-core use is unaffected. Re-invoked on
+     * link and on every `setResolution`/`setFrameRate`/`updateResolution`.
+     *
+     * Each source is guarded on `ready` (a not-yet-initialized or destroyed
+     * source would throw from `setResolution`/`setFrameRate`). `setFrameRate` is
+     * async; its promise is intentionally not awaited (fire-and-forget) with a
+     * catch so a source torn down mid-call cannot raise an unhandled rejection.
+     */
+    private syncFrameSourceQuality;
     /**
      * Get parameter groups filtered by active capabilities
      */
@@ -3804,7 +3821,12 @@ export declare class VijiCore {
         height: number;
     }): void;
     /**
-     * Detects the screen refresh rate
+     * Measures the screen refresh rate over 60 animation frames, off the init
+     * critical path. Runs fire-and-forget: it does NOT gate `ready`, so the host
+     * can control a visibly-rendering core immediately. On completion it pushes
+     * the refined value to the worker (refresh-rate-update) and updates host
+     * stats. Until then both sides use the 60 default. Measured once, never
+     * re-run. Cancelled on `destroy()` via `refreshRateRafId`.
      */
     private detectScreenRefreshRate;
     /**

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as a, V as i, a as s, b as e } from "./index-DbnjzNSY.js";
+import { A as a, V as i, a as s, b as e } from "./index-I8omPYZ-.js";
 export {
   a as AudioSystem,
   i as VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viji-dev/core",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "Universal execution engine for Viji Creative scenes",
   "type": "module",
   "main": "./dist/index.js",