@displayxr/inline3d 1.49.0 → 1.49.1

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
@@ -160,8 +165,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) => {

package/package.json

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