@displayxr/inline3d 1.49.2 → 1.49.3

package/js/inline3d-call.js

@@ -2565,7 +2565,7 @@ class SelfTile {
 
   /** For `call.diagnostics().self`: what the self view actually shows. */
   diag() {
-    if (!this.view) return { route: null, woven: false, reason: 'no-camera', firstWoven: null, layerRetries: 0 };
+    if (!this.view) return { route: null, woven: false, reason: 'no-camera', firstWoven: null, layerRetries: 0, frameAgeMs: null };
     return this.view.weaveState();
   }
 

package/js/inline3d-camera.js

@@ -564,6 +564,8 @@ class CameraView {
     this._scratch = null;
     this._luma = null; // the latest grayscale source copy (auto-convergence and the depth cursor read it)
     this.disparityPx = null;
+    this._lastFrameAt = 0; // performance.now() of the last NEW camera frame (0 = none yet)
+    this._lastVideoTime = -1;
     // `cursor: 'depth'` (ADR-046 on a pair): validated now, its module loaded only on opt-in.
     this._cursorOpt = resolvePairCursorOption(o.cursor, '@displayxr/inline3d/camera');
     /** The depth cursor once its module has loaded; null without `cursor: 'depth'`. */
@@ -598,9 +600,28 @@ class CameraView {
       reason: this.fallbackReason,
       firstWoven: this.route === 'woven-sbs' ? (this._fw ? { ...this._fw } : 'pending') : null,
       layerRetries: this._layerFails,
+      frameAgeMs: this.frameAgeMs,
     };
   }
 
+  /**
+   * Milliseconds since the camera last delivered a NEW frame to this view (its video's
+   * `currentTime` moved), or null before the first one. A view whose track stalls (a camera taken
+   * by another app, a suspended capture) keeps painting its last frame; this is how a page tells.
+   */
+  get frameAgeMs() {
+    return this._lastFrameAt ? Math.round(performance.now() - this._lastFrameAt) : null;
+  }
+
+  /** Note a new camera frame (the video's clock moved since the last paint). */
+  _noteFrame(v) {
+    if ((v.readyState || 0) < 2) return;
+    const t = v.currentTime;
+    if (t === this._lastVideoTime) return;
+    this._lastVideoTime = t;
+    this._lastFrameAt = performance.now();
+  }
+
   /** The per-eye convergence shift currently painted, source px. */
   get convergencePx() {
     return this.conv.current;
@@ -658,7 +679,14 @@ class CameraView {
   }
 
   _registerWoven() {
-    if (!this.buffer) this.buffer = document.createElement('canvas');
+    if (!this.buffer) {
+      // Empty until the camera's first frame is painted into it: the wall does not count an empty
+      // buffer as a stereo frame, so firstWoven cannot settle "woven" over a tile that never
+      // showed the camera (a track that delivers no frames).
+      this.buffer = document.createElement('canvas');
+      this.buffer.width = 0;
+      this.buffer.height = 0;
+    }
     this._paintWoven(); // the first frame exists before the layer does
     const handle = this.rectCover === undefined ? this.wall.addImage(this.canvas, this.buffer) : this.wall.addImage(this.canvas, this.buffer, { rectCover: this.rectCover });
     this.handle = handle;
@@ -737,6 +765,7 @@ class CameraView {
     if (this.removed) return;
     const v = this.cam.video;
     if (!v || this.cam.state === 'closed') return;
+    this._noteFrame(v);
     if (this.route === 'woven-sbs') this._paintWoven();
     else this._paintFlat(v);
   }

package/js/inline3d.js

@@ -3345,7 +3345,10 @@ class Inline3D {
         this._paint(win, views);
         // An SBS paint with a real source behind it. Before the image has loaded (or while a
         // video has never had a frame) the tile holds nothing worth revealing yet.
-        if (win.sbs && (win.kind === 'video' ? ((win.video && win.video.readyState) || 0) >= 2 : !!win.img)) {
+        // A canvas source counts once it has pixels: an empty (0x0) buffer is a page that has not
+        // drawn its first frame yet (a camera view before the camera's first frame), and settling
+        // firstWoven on it reported a tile woven that had never shown anything.
+        if (win.sbs && (win.kind === 'video' ? ((win.video && win.video.readyState) || 0) >= 2 : sourceHasPixels(win.img))) {
           win.fwStereo = true;
           win.lfStereo = true;
           if (win.rw) win.rw.stereo = true;
@@ -3867,6 +3870,18 @@ function firstWovenHold(v) {
   return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : FIRST_WOVEN_HOLD_MS;
 }
 
+/**
+ * True when an image source has something to draw: a loaded image, a sized canvas or bitmap. A
+ * source that reports no size at all (a test double) keeps the old rule: present = drawable.
+ */
+function sourceHasPixels(src) {
+  if (!src) return false;
+  const w = src.naturalWidth ?? src.videoWidth ?? src.width;
+  const h = src.naturalHeight ?? src.videoHeight ?? src.height;
+  if (w === undefined && h === undefined) return true;
+  return w > 0 && h > 0;
+}
+
 function loadImage(source) {
   if (typeof source !== 'string') return Promise.resolve(source); // element/bitmap/canvas
   return new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@displayxr/inline3d",
-  "version": "1.49.2",
+  "version": "1.49.3",
   "description": "Turn any HTML <canvas> into a 3D window on a spatial display, inside an ordinary web page, for the DisplayXR Browser. Dependency-free; progressive enhancement (falls back to plain 2D everywhere else).",
   "type": "module",
   "types": "./index.d.ts",