@viji-dev/core 0.10.0 → 0.11.0

package/dist/index.d.ts

@@ -463,6 +463,41 @@ export declare class AudioSystem {
      * context alive in `Pending activities` and leaks ~4 MB per cycle.
      */
     resetAudioState(): Promise<void>;
+    private sourceFedIndices;
+    /**
+     * Register a source-fed device channel (no MediaStream). Emits the
+     * `audio-stream-setup` identity to all sinks and starts the staleness
+     * timer. Idempotent.
+     */
+    addDeviceAnalysisChannel(streamIndex: number, deviceId: string): void;
+    /**
+     * Feed a controller analysis packet into a source-fed channel. Instant
+     * values pass through; the smoothed companions are derived host-side via
+     * the channel's envelope followers to absorb network packet bunching
+     * (§3.9 light smoothing). Missing `frequencyData`/`waveform` surface as
+     * empty arrays (the controller omits them unless the scene reads them).
+     */
+    feedDeviceAnalysis(streamIndex: number, payload: {
+        volume?: {
+            current?: number;
+            peak?: number;
+        };
+        bands?: {
+            low?: number;
+            lowMid?: number;
+            mid?: number;
+            highMid?: number;
+            high?: number;
+        };
+        spectral?: {
+            brightness?: number;
+            flatness?: number;
+        };
+        frequencyData?: Uint8Array;
+        waveformData?: Float32Array;
+    }): void;
+    /** Remove a source-fed device channel (sends a disconnected state). */
+    removeDeviceAnalysisChannel(streamIndex: number): void;
     /**
      * Add an additional audio stream (lightweight analysis, no beat detection).
      * When `meta` is provided, the stream identity is recorded and an
@@ -1006,6 +1041,59 @@ export declare type CVFeatureKey = typeof CV_FEATURE_KEYS[number];
  */
 declare type CVFrameRateMode = 'full' | 'half' | 'quarter' | 'eighth';
 
+/**
+ * A controller-produced analysis packet ingested via
+ * {@link VijiCore.setDeviceAnalysis} (remote analysis, Phase 3). The
+ * controller analyzes its own device's audio/camera and ships results — no
+ * media track for the analyzed signal crosses the wire.
+ *
+ * - `kind: 'audio'` — surfaces on `viji.devices[n].audio`. `payload` carries
+ *   instant `volume`/`bands`/`spectral`; the host derives the smoothed
+ *   companions and absorbs network jitter. Omit `frequencyData`/`waveform`
+ *   unless the device scene reads them (they are ~9 KB each).
+ * - `kind: 'cv'` — surfaces on `viji.devices[n].video.cv` (requires the
+ *   device video track to be sent for display — the CV surface carrier).
+ *   `payload` carries dequantized `faces`/`hands`/`pose` in the same shapes
+ *   as `viji.video.cv`. Segmentation is excluded in v1.
+ *
+ * `seq` is a monotonic per-(device,kind) counter for latest-wins ordering on
+ * an unreliable channel (every packet carries absolute values, so drops are
+ * harmless). `captureTs` is the capture timestamp of the analyzed media.
+ */
+export declare type DeviceAnalysisPacket = {
+    kind: 'audio';
+    seq?: number;
+    captureTs?: number;
+    payload: {
+        volume?: {
+            current?: number;
+            peak?: number;
+        };
+        bands?: {
+            low?: number;
+            lowMid?: number;
+            mid?: number;
+            highMid?: number;
+            high?: number;
+        };
+        spectral?: {
+            brightness?: number;
+            flatness?: number;
+        };
+        frequencyData?: Uint8Array;
+        waveformData?: Float32Array;
+    };
+} | {
+    kind: 'cv';
+    seq?: number;
+    captureTs?: number;
+    payload: {
+        faces?: FaceData[];
+        hands?: HandData[];
+        pose?: PoseData | null;
+    };
+};
+
 /**
  * Device motion data sourced from the platform's `DeviceMotionEvent`. All
  * accelerations are in metres per second squared (m/s²); rotation rates are
@@ -2702,7 +2790,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.10.0";
+export declare const VERSION = "0.11.0";
 
 /**
  * Real-time video API: drawable frame, dimensions, and the source-side
@@ -3100,6 +3188,7 @@ export declare class VijiCore {
     private stateImportErrorListeners;
     private sceneRuntimeErrorListeners;
     private sceneConsoleListeners;
+    private deviceCVRequestListeners;
     private stats;
     private performanceSnapshotListeners;
     private capabilityTransitionListeners;
@@ -4061,7 +4150,8 @@ export declare class VijiCore {
      */
     removeExternalDevice(deviceId: string): void;
     /**
-     * Get list of connected external devices (for host UI)
+     * Get list of connected external devices (for host UI). Engine-scoped:
+     * identical for every core sharing this core's media engines.
      * @returns Array of device metadata with id, name, and array index
      */
     getConnectedDevices(): Array<{
@@ -4069,6 +4159,32 @@ export declare class VijiCore {
         name: string;
         index: number;
     }>;
+    /**
+     * Ingest a controller-produced analysis packet for a registered device
+     * (remote analysis, Phase 3). `kind:'audio'` surfaces on
+     * `viji.devices[n].audio`; `kind:'cv'` surfaces on
+     * `viji.devices[n].video.cv` (requires the device video track to be sent
+     * for display — the CV surface carrier). Latest-wins by `seq`; unknown
+     * devices / malformed packets are dropped silently. Engine-level: visible
+     * to all cores sharing this core's media engines.
+     *
+     * @param deviceId Registered device identifier
+     * @param packet `{ kind, seq?, captureTs?, payload }`
+     */
+    setDeviceAnalysis(deviceId: string, packet: DeviceAnalysisPacket): void;
+    /**
+     * Listen for device CV feature requests. Fires when a host scene toggles a
+     * CV feature on a device stream (`viji.devices[n].video.cv.enableX`) —
+     * device CV is always remote, so the app must relay this to the device's
+     * controller over its own transport (the controller runs the inference and
+     * ships results back via {@link setDeviceAnalysis}). The core never owns
+     * the transport.
+     *
+     * Engine-level: one registry per shared engine group — subscribe once.
+     * @returns Unsubscribe function.
+     */
+    onDeviceCVRequest(listener: (deviceId: string, feature: CVFeature, enabled: boolean) => void): Unsubscribe;
+    private fireDeviceCVRequest;
     /**
      * Set video stream for an external device
      * Device camera will appear in viji.devices[].video

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as s, C as o, I as E, V as i, a as A, b as C } from "./index-C-CGSJSn.js";
+import { A as s, C as o, I as E, V as i, a as A, b as C } from "./index-Dfhuv8fL.js";
 export {
   s as AudioSystem,
   o as CV_FEATURE_KEYS,

package/package.json

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