@3dsource/angular-unreal-module 0.0.162 → 0.0.163

package/README.md

@@ -183,6 +183,9 @@ The package publishes two dependency-free scripts for use in the document
 `stream-prefetch.js` runs by default only on
 `metabox-configurator/{modular|basic}/...` routes. It reads the same-origin
 `assets/config.json`; override that path with `data-config-url` when needed.
+It also forwards the orchestration-issued `streamRequestId` from the polling
+response to Cirrus on the WebSocket URL (the session `connectionId`) and parks it
+for the Angular side to adopt.
 Pin an exact package version in production when deterministic CDN assets are
 required.
 

package/fesm2022/3dsource-angular-unreal-module.mjs

@@ -479,7 +479,7 @@ const initialState = {
 };
 const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScene, (state, { isVideoPlaying }) => {
     return { ...state, isVideoPlaying };
-}), on(setAwsInstance, (state, { instanceName, wsUrl, pollingUrl }) => {
+}), on(setAwsInstance, (state, { instanceName, wsUrl, pollingUrl, streamRequestId }) => {
     return {
         ...state,
         awsInstance: {
@@ -487,6 +487,7 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
             instanceName,
             wsUrl,
             pollingUrl,
+            streamRequestId,
             progressComplete: 0,
         },
     };
@@ -642,7 +643,7 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
     return { ...state, analyticsEvent: event };
 }), on(setCirrusConnected, (state) => {
     return { ...state, cirrusConnected: true };
-}), on(streamAdopted, (state, { machineId, ssData }) => {
+}), on(streamAdopted, (state, { machineId, ssData, streamRequestId }) => {
     return {
         ...state,
         cirrusConnected: true,
@@ -653,6 +654,7 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
             wsUrl: machineId,
             pollingUrl: null,
             instanceName: 'Adopted Connection',
+            streamRequestId: streamRequestId ?? state.awsInstance.streamRequestId,
             progressComplete: 0,
         },
     };
@@ -782,8 +784,9 @@ function InstanceReadyHandler(msg) {
     this.store.dispatch(instanceReady(payload));
     // Open the SECOND socket directly to the stream machine and route the whole
     // WebRTC signalling through it. The orchestration socket stays open for
-    // control/lifecycle.
-    this.connectToStreamMachine(payload.originInstanceUri);
+    // control/lifecycle. `streamRequestId` is handed over so the stream machine's
+    // Cirrus reuses the orchestration-issued connection id.
+    this.connectToStreamMachine(payload.originInstanceUri, payload.streamRequestId);
 }
 
 function InstanceReservedHandler(msg) {
@@ -1223,8 +1226,19 @@ const selectTotalProgress = createSelector(unrealFeature.selectStatusPercentSign
     const progressRest = lerp(0, 1 - splitPoint, commandProgress);
     return clampf(0, 1, progressSignaling + progressRest);
 });
-/** Used by external consumers (e.g., metabox). Do not remove. */
-const selectCirrusConnectionId = createSelector(unrealFeature.selectSsData, (data) => data?.connectionId);
+/**
+ * The connection id of the current stream session.
+ *
+ * Primary source is the orchestration, which issues it as `streamRequestId` —
+ * in the polling response (legacy flow) or in `instanceReserved`/`instanceReady`
+ * (new orchestration) — and the browser hands it to Cirrus on the WS upgrade
+ * URL. `ssData.connectionId` (the `ssInfo` message) is the fallback for
+ * backends that don't issue one yet: Cirrus then generates it itself and
+ * reports it back here.
+ *
+ * Used by external consumers (e.g., metabox). Do not remove.
+ */
+const selectCirrusConnectionId = createSelector(unrealFeature.selectAwsInstance, unrealFeature.selectSsData, (awsInstance, ssData) => awsInstance?.streamRequestId ?? ssData?.connectionId);
 /** Used by external consumers (e.g., metabox). Do not remove. */
 const selectUserInactivityDetected = createSelector(unrealFeature.selectAfkCountdown, unrealFeature.selectIsAfkTimerVisible, (remainingSecondsToDisconnect, countdownVisible) => ({
     remainingSecondsToDisconnect,
@@ -1835,6 +1849,27 @@ function httpUrlToWs(url) {
     return url.replace('http://', 'ws://').replace('https://', 'wss://');
 }
 
+/**
+ * Append the orchestration-issued connection id to a signalling WS URL as
+ * `?streamRequestId=…`.
+ *
+ * Cirrus reads it in its `onConnection` upgrade handler and uses it as the
+ * player's `connectionId` instead of generating one (both the legacy Cirrus and
+ * the new Cirrus-WS keep their `guid()` generator as a fallback). A missing id
+ * is a no-op, so the URL stays byte-identical for backends that don't issue one.
+ *
+ * Only used at the moment of connecting — the URL kept in the store stays clean
+ * (it is rendered in the debug overlay and pattern-matched by
+ * `selectTotalProgress`).
+ */
+function withStreamRequestId(wsUrl, streamRequestId) {
+    if (!wsUrl || !streamRequestId) {
+        return wsUrl;
+    }
+    const separator = wsUrl.includes('?') ? '&' : '?';
+    return `${wsUrl}${separator}streamRequestId=${encodeURIComponent(streamRequestId)}`;
+}
+
 /**
  * Factory that creates a WebSocket connection and wraps it in an RxJS Observable.
  *
@@ -2169,7 +2204,7 @@ class SignallingService extends SubService {
      */
     connectAttempt(urls) {
         const urlGen = getActiveUrl(urls);
-        return defer(() => this.getAwsInstance(`${urlGen.next().value}`)).pipe(tap((awsInstance) => this.store.dispatch(setAwsInstance(awsInstance))), switchMap(({ wsUrl }) => 
+        return defer(() => this.getAwsInstance(`${urlGen.next().value}`)).pipe(tap((awsInstance) => this.store.dispatch(setAwsInstance(awsInstance))), switchMap(({ wsUrl, streamRequestId }) => 
         // ── WS-only retry tier ─────────────────────────────────────────────
         // Tries the SAME `wsUrl` up to `WS_RETRY_PER_INSTANCE` extra times
         // before letting the error bubble up to the outer (URL-rotating)
@@ -2183,7 +2218,14 @@ class SignallingService extends SubService {
         // burning a second reservation. If WS still fails after these
         // extra attempts, the instance is genuinely unusable and we
         // accept the cost of rotating.
-        this.connectToCirrus(wsUrl ?? '').pipe(filter(Truthy), take(1), retry({
+        // POLLING flow only: the polled `signallingServer` IS Cirrus (single
+        // socket), so the orchestration-issued connection id rides on this
+        // upgrade URL. In the new WS flow this socket is orchestration-only
+        // control and `streamRequestId` is still unknown here (it arrives later
+        // in `instanceReserved`/`instanceReady`) → no-op, URL unchanged; the id
+        // is attached to the machine address instead, see
+        // `connectToStreamMachine`.
+        this.connectToCirrus(withStreamRequestId(wsUrl ?? '', streamRequestId)).pipe(filter(Truthy), take(1), retry({
             count: WS_RETRY_PER_INSTANCE,
             delay: (err, attempt) => {
                 this.store.dispatch(signalingRetryAttempted({
@@ -2279,6 +2321,9 @@ class SignallingService extends SubService {
                 wsUrl: httpUrlToWs(`${location.protocol}//${data.signallingServer}`),
                 pollingUrl: url,
                 instanceName: data.signallingServer ?? '',
+                // The orchestration issues the connection id here; it is handed to
+                // Cirrus on the WS upgrade URL (see `connectAttempt`).
+                streamRequestId: data.streamRequestId,
             })), finalize(() => {
                 this.commandTelemetryService.trackStopCommand('EXT-getSignaling', true, { ...(lastResp ?? {}), multi: true });
                 this.store.dispatch(pollingEnded());
@@ -2396,8 +2441,15 @@ class SignallingService extends SubService {
      *
      * "Just connect" — nothing is sent on open (the machine is already reserved
      * for this session): Cirrus pushes `config` and Unreal sends the `offer`.
+     *
+     * The orchestration-issued `streamRequestId` (from the same `instanceReady`
+     * payload) rides on this upgrade URL: in the new flow THIS is the Cirrus
+     * socket, so it is the one that must carry the id (the first socket is
+     * orchestration-only control and needs nothing). Without it the stream
+     * machine's Cirrus falls back to its own `guid()` and the session can no
+     * longer be correlated. Absent id → URL unchanged.
      */
-    connectToStreamMachine(originInstanceUri) {
+    connectToStreamMachine(originInstanceUri, streamRequestId) {
         if (!originInstanceUri) {
             Logger.warn('instanceReady without originInstanceUri — stream socket not opened');
             return;
@@ -2412,7 +2464,7 @@ class SignallingService extends SubService {
         // before a fresh attempt — e.g. a retry that resolved to a different machine
         // or two instanceReady messages before the first connect resolves.
         this.teardownStreamWs();
-        this.streamWsSub = createWebSocket(originInstanceUri)
+        this.streamWsSub = createWebSocket(withStreamRequestId(originInstanceUri, streamRequestId))
             .pipe(takeUntil(this.abort$), takeUntil(this.destroy$), take(1))
             .subscribe({
             next: (ws) => {
@@ -3788,6 +3840,7 @@ class StreamAdoptionService {
         this.store.dispatch(streamAdopted({
             machineId: parked.machineId ?? null,
             ssData: parked.ssData ?? null,
+            streamRequestId: parked.ids?.streamRequestId || null,
             timings: parked.timings ?? null,
         }));
         // Hand the live socket over without re-sending `requestStream`, reusing the
@@ -4089,9 +4142,12 @@ class UnrealEffects {
             return this.actions$.pipe(ofType(setAwsInstance), 
             // require wsUrl present on the action payload
             filter((action) => !!action.wsUrl), 
-            // for each awsInstance action capture one ssData snapshot, then wait for dataChannelConnected
+            // for each awsInstance action capture one connectionId snapshot, then wait
+            // for dataChannelConnected. The gate stays on `ssInfo` (unchanged timing);
+            // the id itself now comes from the orchestration when it issued one, and
+            // falls back to the `ssInfo` value otherwise.
             switchMap((awsInstance) => {
-                return this.actions$.pipe(ofType(updateCirrusInfo), take(1), switchMap(({ ssData }) => {
+                return this.actions$.pipe(ofType(updateCirrusInfo), take(1), withLatestFrom(this.store.select(selectCirrusConnectionId)), switchMap(([, connectionId]) => {
                     const abort$ = this.actions$.pipe(ofType(setCirrusDisconnected, // ← "Cirrus closed" action — direct,
                     //                        no fan-in tick delay
                     abortEstablishingConnection), take(1));
@@ -4108,7 +4164,7 @@ class UnrealEffects {
                         Logger.error(error);
                         const body = {
                             awsInstance,
-                            connectionId: ssData?.connectionId,
+                            connectionId,
                             href: location.href,
                             userAgent: navigator.userAgent,
                             error,