@displayxr/inline3d 1.49.0 → 1.49.2

package/js/call/share.js

@@ -14,11 +14,21 @@
 // runtime asks the user on the SENDER's machine, every start ("Share <app> with <browser>?"), when
 // `openAppShare()` opens the device; a Deny rejects it (`code: 'share-denied'`). The track ends
 // (`ended`) when the app exits or the share is stopped from the runtime side.
+//
+// Browsers WITHOUT the app-share device patch (DisplayXR Browser 1.9.x) list an app through their
+// stereo-camera factory as `3D Camera (DisplayXR) - <app>` — and, whenever the runtime lists more
+// than one source, give the real camera the same shape. So when no ADR-form device exists,
+// `listShareableApps()` returns those as CANDIDATES (`legacy: true`), and `openAppShare()` verifies
+// the opened track (`isAppShareHint`: baseline 0 and FOV 0 is an app) — a real camera is closed
+// again with `code: 'not-app-share'`.
 
-import { isAppShareDevice, appNameFromLabel, APP_SHARE_ID_PREFIX, APP_SHARE_LABEL_RE } from '../camera/app-share.js';
+import { isAppShareDevice, isAppShareHint, legacyAppCandidate, appNameFromLabel, APP_SHARE_ID_PREFIX, APP_SHARE_LABEL_RE, APP_SHARE_LEGACY_LABEL_RE } from '../camera/app-share.js';
 import { sanitizeName, CONV_MAX_FRAC } from './wire.js';
 
-export { isAppShareDevice, appNameFromLabel, APP_SHARE_ID_PREFIX, APP_SHARE_LABEL_RE };
+export { isAppShareDevice, isAppShareHint, legacyAppCandidate, appNameFromLabel, APP_SHARE_ID_PREFIX, APP_SHARE_LABEL_RE, APP_SHARE_LEGACY_LABEL_RE };
+
+/** The app name a label carries: the ADR form, else a legacy candidate's `<name>`. */
+const nameOfLabel = (label) => sanitizeName(appNameFromLabel(label)) || sanitizeName((legacyAppCandidate(label) || {}).appName) || null;
 
 /** What `openAppShare` asks for by default: the runtime's default stream (ADR-061 decision 5). */
 const SHARE_CONSTRAINTS = Object.freeze({ width: 2560, height: 720, frameRate: 30 });
@@ -29,6 +39,11 @@ const mdOf = (o) => (o && o.mediaDevices) || (globalThis.navigator && navigator.
  * The running apps this browser offers to share: `[{ deviceId, label, appName }]`, in the
  * browser's order. Empty without camera permission (the browser lists none before it), on any
  * other browser, or when nothing is shareable. Never rejects.
+ *
+ * On a browser without the app-share device patch (no ADR-form device listed), the entries are the
+ * `3D Camera (DisplayXR) - <name>` CANDIDATES instead, marked `legacy: true`. A real camera can be
+ * among them (that browser labels every source that way once there are two); `openAppShare()`
+ * tells them apart and rejects a camera with `not-app-share`.
  * @param {{ mediaDevices?: MediaDevices }} [o]
  */
 export async function listShareableApps(o = {}) {
@@ -40,9 +55,14 @@ export async function listShareableApps(o = {}) {
   } catch {
     return [];
   }
-  return list
-    .filter((d) => d && d.kind === 'videoinput' && isAppShareDevice(d))
+  const videos = list.filter((d) => d && d.kind === 'videoinput');
+  const apps = videos
+    .filter((d) => isAppShareDevice(d))
     .map((d) => Object.freeze({ deviceId: d.deviceId, label: d.label || '', appName: sanitizeName(appNameFromLabel(d.label)) || sanitizeName(d.label) || null }));
+  if (apps.length) return apps;
+  return videos
+    .filter((d) => d.deviceId && legacyAppCandidate(d))
+    .map((d) => Object.freeze({ deviceId: d.deviceId, label: d.label || '', appName: nameOfLabel(d.label), legacy: true }));
 }
 
 /**
@@ -61,7 +81,7 @@ export function watchShareableApps(cb, o = {}) {
     const mine = ++seq;
     const apps = await listShareableApps({ mediaDevices: md });
     if (!live || mine !== seq) return; // a newer read is in flight (devicechange bursts)
-    const key = JSON.stringify(apps.map((a) => [a.deviceId, a.label]));
+    const key = JSON.stringify(apps.map((a) => [a.deviceId, a.label, !!a.legacy]));
     if (key === last) return;
     last = key;
     try {
@@ -97,7 +117,8 @@ export function describeAppShare(track, fallbackLabel = '') {
   const hint = st.displayxrStereo && typeof st.displayxrStereo === 'object' ? st.displayxrStereo : {};
   const z = hint.zeroDisparityShiftFrac;
   const frac = typeof z === 'number' && Number.isFinite(z) ? Math.max(-CONV_MAX_FRAC, Math.min(CONV_MAX_FRAC, z)) : 0;
-  const appName = sanitizeName(hint.appName) || sanitizeName(appNameFromLabel(track && track.label)) || sanitizeName(appNameFromLabel(fallbackLabel)) || null;
+  // The hint's name, else the label's: the ADR form, or a legacy candidate's ` - <name>`.
+  const appName = sanitizeName(hint.appName) || nameOfLabel(track && track.label) || nameOfLabel(fallbackLabel) || null;
   return {
     kind: 'content',
     format: hint.layout && hint.layout !== 'side-by-side' ? 'mono' : 'sbs',
@@ -111,7 +132,9 @@ export function describeAppShare(track, fallbackLabel = '') {
 /**
  * Open one shareable app (a `deviceId` from `listShareableApps`) as a side-by-side track. This is
  * when the runtime asks the user on this machine; Deny rejects with `code: 'share-denied'`. A device
- * that turns out not to be an app share is closed again (`code: 'not-app-share'`). The track is
+ * that turns out not to be an app share is closed again (`code: 'not-app-share'`) — on a browser
+ * without the app-share device patch that is how a `legacy` candidate that is really a camera
+ * (its track's baseline is not 0) is told apart from an app. The track is
  * yours: stop it when you stop sharing (`track.stop()`), or the runtime keeps the share open.
  *
  * @param {string} deviceId
@@ -134,7 +157,16 @@ export async function openAppShare(deviceId, o = {}) {
     throw Object.assign(new Error(`could not share the app: ${(err && err.message) || err}`), { code: denied ? 'share-denied' : 'share-failed', cause: err });
   }
   const track = stream.getVideoTracks()[0] || null;
-  if (!track || !(isAppShareDevice(track) || deviceId.startsWith(APP_SHARE_ID_PREFIX))) {
+  let hint = null;
+  try {
+    hint = track && typeof track.getSettings === 'function' ? (track.getSettings() || {}).displayxrStereo : null;
+  } catch {
+    hint = null;
+  }
+  // A track whose hint describes a camera (a `source` other than 'app', or a real baseline) is not
+  // an app, whatever its label or id; otherwise the label, the id or the hint must say "app".
+  const cameraHint = !!hint && typeof hint === 'object' && !isAppShareHint(hint) && (typeof hint.source === 'string' || hint.baselineMm > 0);
+  if (!track || cameraHint || !(isAppShareDevice(track) || deviceId.startsWith(APP_SHARE_ID_PREFIX))) {
     stream.getTracks().forEach((t) => t.stop());
     throw Object.assign(new Error('that device is not a shared DisplayXR app'), { code: 'not-app-share' });
   }

package/js/camera/app-share.js

@@ -12,6 +12,16 @@
 // `dxr-app:`, and on the opened track `getSettings().displayxrStereo.source === 'app'` (plus
 // `appName`, `zeroDisparityShiftFrac`). Browsers that predate the hint fields still use the label
 // and the id, so any ONE of the three is enough.
+//
+// Browsers WITHOUT the app-share device patch (DisplayXR Browser 1.9.x) list a development-gated
+// app source through their stereo-CAMERA device factory instead: label `3D Camera (DisplayXR) -
+// <app>`, id `dxr-stereo:…`, no `source` in the hint. That label shape proves nothing — such a
+// browser appends ` - <displayName>` to EVERY entry whenever the runtime lists more than one, so
+// the real camera next to the app reads `3D Camera (DisplayXR) - <camera>` too. What does tell
+// them apart is the opened track: an app source advertises `baselineMm: 0` and
+// `horizontalFovDeg: 0` (runtime ADR-061 decision 2); a real camera never has baseline 0. So
+// `isAppShareHint` checks the hint, and `legacyAppCandidate` only ever names a CANDIDATE, which
+// must be opened and verified before anything treats it as an app.
 
 /** `deviceId` prefix of an app-share device (cameras use `dxr-stereo:`). */
 export const APP_SHARE_ID_PREFIX = 'dxr-app:';
@@ -19,6 +29,54 @@ export const APP_SHARE_ID_PREFIX = 'dxr-app:';
 /** The label of an app-share device; group 1 is the app's name. */
 export const APP_SHARE_LABEL_RE = /^DisplayXR: (.+) \(3D\)$/;
 
+/**
+ * The label a browser without the app-share device patch gives EVERY runtime stereo source when
+ * there is more than one (cameras and apps alike); group 1 is the source's display name. A shape,
+ * not an identity: see legacyAppCandidate.
+ */
+export const APP_SHARE_LEGACY_LABEL_RE = /^3D Camera \(DisplayXR\)\s+-\s+(.+)$/;
+
+/**
+ * Does a track's `displayxrStereo` hint describe a running app rather than a camera? True when
+ * `source === 'app'`; with no `source` (browsers without the app-share device patch), when the
+ * layout is side-by-side (or unstated) and BOTH `baselineMm` and `horizontalFovDeg` are exactly 0
+ * — what an app source advertises (ADR-061 decision 2) and no real camera does. A `source` that is
+ * anything else says "not an app". Never throws. Pure.
+ * @param {unknown} hint
+ * @returns {boolean}
+ */
+export function isAppShareHint(hint) {
+  if (!hint || typeof hint !== 'object') return false;
+  try {
+    const h = /** @type {any} */ (hint);
+    if (typeof h.source === 'string') return h.source === 'app';
+    if (h.layout != null && h.layout !== 'side-by-side') return false;
+    return h.baselineMm === 0 && h.horizontalFovDeg === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * On a browser WITHOUT the app-share device patch: is this listed device a CANDIDATE app source
+ * (`3D Camera (DisplayXR) - <name>`)? Returns `{ appName }` or null. A candidate is verified only
+ * after opening (`isAppShareHint` on the track's settings) — the same label shape is given to real
+ * cameras whenever the runtime lists more than one source. Never throws. Pure.
+ * @param {unknown} device  a `MediaDeviceInfo`, `{ label }`, or a label string
+ * @returns {{ appName: string } | null}
+ */
+export function legacyAppCandidate(device) {
+  let label = '';
+  try {
+    label = typeof device === 'string' ? device : device && typeof device === 'object' ? /** @type {any} */ (device).label : '';
+  } catch {
+    return null;
+  }
+  const m = typeof label === 'string' ? APP_SHARE_LEGACY_LABEL_RE.exec(label.trim()) : null;
+  const appName = m ? m[1].trim() : '';
+  return appName ? { appName } : null;
+}
+
 /** The app name an app-share label carries, or null. Pure. */
 export function appNameFromLabel(label) {
   const m = typeof label === 'string' ? APP_SHARE_LABEL_RE.exec(label.trim()) : null;
@@ -29,7 +87,9 @@ export function appNameFromLabel(label) {
  * Is this an app-share device rather than a camera? Takes a `MediaDeviceInfo` (or any
  * `{ label, deviceId }`), a label string, a track's settings (`{ displayxrStereo }`), or a
  * `MediaStreamTrack` (its label and settings). True on ANY of: the label shape, the `dxr-app:` id
- * prefix, or `displayxrStereo.source === 'app'`. Never throws. Pure.
+ * prefix, or a `displayxrStereo` hint that `isAppShareHint` accepts (`source: 'app'`, or baseline
+ * and FOV both 0). The legacy `3D Camera (DisplayXR) - <name>` label alone is NOT enough (cameras
+ * get it too). Never throws. Pure.
  * @param {unknown} x
  * @returns {boolean}
  */
@@ -42,7 +102,7 @@ export function isAppShareDevice(x) {
     if (typeof o.label === 'string' && APP_SHARE_LABEL_RE.test(o.label.trim())) return true;
     if (typeof o.deviceId === 'string' && o.deviceId.startsWith(APP_SHARE_ID_PREFIX)) return true;
     const hint = o.displayxrStereo || (typeof o.getSettings === 'function' ? (o.getSettings() || {}).displayxrStereo : null);
-    if (hint && typeof hint === 'object' && hint.source === 'app') return true;
+    if (isAppShareHint(hint)) return true;
     if (typeof o.getSettings === 'function') {
       const id = (o.getSettings() || {}).deviceId;
       if (typeof id === 'string' && id.startsWith(APP_SHARE_ID_PREFIX)) return true;

package/js/camera/capture.js

@@ -29,6 +29,11 @@
 //    It is a pair, it names itself "3D", and it is NOT a camera: no probe path opens one, whatever
 //    `exclude` says (`exclude: false` included). Each is reported in `skipped` as `excluded` with
 //    `reason: 'app-share'`. `/call`'s `listShareableApps()` / `openAppShare()` are how a page uses them.
+//    A browser WITHOUT the app-share device patch lists such an app as a stereo camera instead
+//    ("3D Camera (DisplayXR) - <app>", no `source` in the hint) and gives the REAL camera the same
+//    label shape whenever there is more than one source — so the label cannot decide. Those are
+//    opened like any named pair, and the opened track's hint decides: baseline 0 and FOV 0 is an
+//    app (ADR-061 decision 2) → closed again, `reason: 'app-share'`, probing goes on.
 //
 // RECTIFICATION is not done here (P2): it needs the camera's calibration (intrinsics/extrinsics
 // for the ACTIVE device), which comes from a plug-in or the runtime. P1 sends the raw pair with
@@ -36,7 +41,7 @@
 // `(stream, info) => MediaStream | Promise<MediaStream>`, returning a rectified SBS stream.
 
 import { looksSbs } from './geometry.js';
-import { isAppShareDevice } from './app-share.js';
+import { isAppShareDevice, isAppShareHint } from './app-share.js';
 
 const MONO_CONSTRAINTS = { width: { ideal: 1280 }, height: { ideal: 720 }, frameRate: { ideal: 30 } };
 // Ask a candidate stereo device for its widest mode; a 2560x720 or 3840x1080 pair comes back as
@@ -44,6 +49,47 @@ const MONO_CONSTRAINTS = { width: { ideal: 1280 }, height: { ideal: 720 }, frame
 const PROBE_CONSTRAINTS = { width: { ideal: 3840 }, height: { ideal: 1080 }, frameRate: { ideal: 30 } };
 export const AUDIO_CONSTRAINTS = Object.freeze({ echoCancellation: true, noiseSuppression: true, autoGainControl: true });
 
+// How long `'auto'` / `'stereo'` waits, in a DisplayXR Browser with labels visible, for the
+// runtime's 3D camera to be listed before it opens any plain lens (see openCamera), and how often
+// it re-reads the list meanwhile (a `devicechange` re-reads at once).
+export const STEREO_WAIT_MS = 2500;
+const STEREO_WAIT_STEP_MS = 500;
+
+/**
+ * The default `stereoWaitMs`: STEREO_WAIT_MS in a DisplayXR Browser (the same test as
+ * inline3DAvailable(): a runtime 3D camera can be listed there), else 0. Pure apart from globals.
+ */
+export function defaultStereoWaitMs() {
+  return inDisplayXRBrowser() ? STEREO_WAIT_MS : 0;
+}
+
+/** The same test as inline3DAvailable() (navigator.xr + XRDisplayLayer), without importing the core. */
+function inDisplayXRBrowser() {
+  return typeof navigator !== 'undefined' && !!navigator.xr && typeof window !== 'undefined' && typeof window.XRDisplayLayer === 'function';
+}
+
+/** Resolves on the next `devicechange` of `md`, or after `ms`, whichever is first. */
+function nextDeviceChange(md, ms) {
+  return new Promise((resolve) => {
+    let timer = 0;
+    const done = () => {
+      clearTimeout(timer);
+      try {
+        md.removeEventListener?.('devicechange', done);
+      } catch {
+        /* no events */
+      }
+      resolve();
+    };
+    timer = setTimeout(done, ms);
+    try {
+      md.addEventListener?.('devicechange', done);
+    } catch {
+      /* no events: the timer alone */
+    }
+  });
+}
+
 /** Errors that mean "the device exists but another process holds it" (an eye tracker, say). */
 export function isBusyError(err) {
   return !!err && (err.name === 'NotReadableError' || err.name === 'TrackStartError' || /in use|busy/i.test(err.message || ''));
@@ -124,9 +170,12 @@ export function stereoLabelHint(label) {
  * @param {'auto'|'stereo'|'mono'|string|MediaStream} want  'auto' | 'stereo' | 'mono' | a
  *        deviceId | a page-supplied MediaStream
  * @param {{ format?: 'sbs'|'mono', calibration?: {baselineMm?: number, hfovDeg?: number, rectified?: boolean},
- *           mediaDevices?: MediaDevices, log?: Function, exclude?: false|Array<string|RegExp> }} [o]
+ *           mediaDevices?: MediaDevices, log?: Function, exclude?: false|Array<string|RegExp>,
+ *           stereoWaitMs?: number }} [o]
  *        `exclude`: devices no probe may open (see cameraExcluder); an explicit deviceId is the
  *        page's own choice and is opened regardless.
+ *        `stereoWaitMs`: with labels visible and no stereo-named device listed, how long to wait
+ *        for one before opening a plain lens (default defaultStereoWaitMs(); 0 = one re-read).
  * @returns {Promise<{ stream: MediaStream, format: 'sbs'|'mono', width: number, height: number,
  *           deviceId: string|null, label: string, owned: boolean, skipped: Array<{label: string, error: string}>,
  *           calibration: object }>}
@@ -160,8 +209,11 @@ export async function openCamera(want = 'auto', o = {}) {
     // eye-tracking camera shared without stealing it) describes itself on the opened track:
     // `displayxrStereo: {layout, rectified, baselineMm, horizontalFovDeg}`.
     const stereo = st.displayxrStereo && st.displayxrStereo.layout === 'side-by-side' ? st.displayxrStereo : null;
-    // A running app's views (3D screen share, ADR-061) describe themselves too: `source: 'app'`.
-    const appShare = isAppShareDevice({ label: t.label || '', deviceId: st.deviceId || '' }) || !!(st.displayxrStereo && st.displayxrStereo.source === 'app');
+    // A running app's views (3D screen share, ADR-061) describe themselves too: `source: 'app'`,
+    // or — on a browser without the app-share device patch, which lists the app as a "3D Camera
+    // (DisplayXR) - <app>" — baseline 0 and FOV 0, which no real camera advertises. Every probe
+    // path checks this on the OPENED track (rejectOpened), since the label cannot tell them apart.
+    const appShare = isAppShareDevice({ label: t.label || '', deviceId: st.deviceId || '' }) || isAppShareHint(st.displayxrStereo);
     return { stream: s, track: t, width: st.width, height: st.height, deviceId: st.deviceId || null, label: t.label || '', stereo, appShare };
   };
   const skip = (label, err) => {
@@ -312,16 +364,38 @@ export async function openCamera(want = 'auto', o = {}) {
     }
     return null;
   };
+  // Re-read the list until a stereo-named device opens or `ms` is up: on each `devicechange` and
+  // every STEREO_WAIT_STEP_MS. `ms` <= 0: one re-read. Stops early once a named pair was listed and
+  // failed to open (busy): waiting longer would not free it.
+  const waitMs = Number.isFinite(o.stereoWaitMs) ? Math.max(0, o.stereoWaitMs) : defaultStereoWaitMs();
+  const waitForNamedPair = async (ms) => {
+    if (!(ms > 0)) return tryNamedPairs(await listCameras());
+    const deadline = Date.now() + ms;
+    log('camera-wait-stereo', { ms });
+    for (;;) {
+      const left = deadline - Date.now();
+      if (left <= 0) break;
+      await nextDeviceChange(md, Math.min(STEREO_WAIT_STEP_MS, left));
+      const list = await listCameras();
+      const r = await tryNamedPairs(list);
+      if (r) return r;
+      if (list.some((d) => stereoLabelHint(d.label) && !isApp(d))) break; // listed, tried, not usable
+    }
+    log('camera-no-stereo-listed', { ms });
+    return null;
+  };
   let mono = null;
   if (want !== 'mono') {
     let listed = await listCameras();
     let pair = await tryNamedPairs(listed);
     if (pair) return result(pair, 'sbs');
     // Labels visible but no stereo-named device: a runtime 3D camera can join the list late (after
-    // a runtime restart), so read it once more before falling back.
+    // a runtime restart; on Android the runtime lists its cameras lazily). In a DisplayXR Browser
+    // wait for it BEFORE any plain lens is opened (stereoWaitMs): on some phones opening a physical
+    // lens while head tracking streams crashes the camera HAL, and the runtime's pair goes down with
+    // it. Elsewhere read the list once more.
     if (listed.some((d) => d.label) && !listed.some((d) => stereoLabelHint(d.label))) {
-      listed = await listCameras();
-      pair = await tryNamedPairs(listed);
+      pair = await waitForNamedPair(waitMs);
       if (pair) return result(pair, 'sbs');
     }
     // No labels yet (no permission). Prime it on the default camera with NO constraints (a facing
@@ -384,9 +458,14 @@ export async function openCamera(want = 'auto', o = {}) {
   }
   // A label that names a pair first; never by list position (see the header).
   devices.sort((a, b) => Number(stereoLabelHint(b.label)) - Number(stereoLabelHint(a.label)));
+  // In a DisplayXR Browser a stereo camera (a USB SBS webcam included) is the runtime's named
+  // "3D Camera", so once a plain lens is in hand no other plain lens is opened to test its shape:
+  // on some phones that extra open crashes the camera HAL.
+  const shapeProbe = !inDisplayXRBrowser();
   for (const d of devices) {
     if (!d.deviceId) continue; // no permission yet: an anonymous entry cannot be opened by id
     if (mono && d.deviceId === mono.deviceId) continue;
+    if (mono && !shapeProbe && !stereoLabelHint(d.label)) continue;
     if (tried.has(d.deviceId) || excludedIds.has(d.deviceId)) continue; // already opened (not a pair, or busy) or left out
     if (listedExcluded(d)) continue; // the last resort never opens a sensor (a hand-tracking camera)
     let r = null;
@@ -406,7 +485,7 @@ export async function openCamera(want = 'auto', o = {}) {
     // No default could be used (excluded, busy): the first plain camera found is the fallback.
     if (!mono && !isPair(r)) {
       mono = await withMode(r, MONO_CONSTRAINTS);
-      if (want === 'mono') return result(mono, 'mono');
+      if (want === 'mono' || !shapeProbe) return result(mono, 'mono');
       continue;
     }
     stop(r);

package/js/inline3d-camera.js

@@ -441,7 +441,11 @@ class StereoCamera {
  * are in `skipped` with `excluded: true`. An explicit `deviceId` or `label:` is the page's choice
  * and is opened regardless.
  *
- * @param {object|string|MediaStream} [opts]  `{ prefer, format, calibration, rectify, exclude, debug }` (or just `prefer`)
+ * In a DisplayXR Browser with labels visible and no 3D camera listed yet, `'auto'` / `'stereo'`
+ * waits up to `stereoWaitMs` (default 2500) for the runtime's 3D camera to be listed before it
+ * opens any plain lens (docs/camera.md, "Waiting for the 3D camera").
+ *
+ * @param {object|string|MediaStream} [opts]  `{ prefer, format, calibration, rectify, exclude, stereoWaitMs, debug }` (or just `prefer`)
  */
 export async function openCamera(opts = {}) {
   const o = typeof opts === 'string' || (opts && typeof opts.getVideoTracks === 'function') ? { prefer: opts } : opts || {};
@@ -451,7 +455,7 @@ export async function openCamera(opts = {}) {
   // `horizontalFovDeg` is the public spelling (RFC 0003 §4); the hello wire field is `hfovDeg`.
   if (cal.horizontalFovDeg > 0 && !(cal.hfovDeg > 0)) cal.hfovDeg = cal.horizontalFovDeg;
   delete cal.horizontalFovDeg;
-  const r = await openDevice(prefer, { format: o.format, calibration: cal, mediaDevices: o.mediaDevices, log: log || undefined, exclude: o.exclude });
+  const r = await openDevice(prefer, { format: o.format, calibration: cal, mediaDevices: o.mediaDevices, log: log || undefined, exclude: o.exclude, stereoWaitMs: o.stereoWaitMs });
   if (r.format === 'sbs' && typeof o.rectify === 'function') {
     // A calibrated rectification step (plug-in or runtime supplied): its output is a rectified
     // SBS stream, and the record then says so. A throwing hook keeps the raw pair.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@displayxr/inline3d",
-  "version": "1.49.0",
+  "version": "1.49.2",
   "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",