@3dsource/angular-unreal-module 0.0.146-dev.8 → 0.0.146-dev.9

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

@@ -3589,8 +3589,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.2", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
 
-// How often to re-check `window.__stream.state` while a prefetch is connecting.
+// Legacy fallback only: poll interval for head-scripts that predate the
+// `onSettled` hook. The event-driven path (preferred) carries no such latency.
 const ADOPT_POLL_MS = 100;
+// Safety-net re-check for the event path — covers the (unexpected) case where
+// `onSettled` never fires. Coarse on purpose: it's a backstop, not the hot
+// path, so it adds no latency to a healthy adoption.
+const ADOPT_EVENT_SAFETY_MS = 1000;
 /**
  * Adopts a WebRTC connection prefetched by the `stream-prefetch.js` head-script
  * and parked on `window.__stream`, instead of running `connectToSignaling` from
@@ -3609,7 +3614,9 @@ class StreamAdoptionService {
      *
      * - nothing parked → emit `false` at once (caller connects normally).
      * - already settled (`ready`/`failed`/`adopted`) → adopt-if-ready at once.
-     * - still `connecting` → poll until the script settles it, then adopt-if-ready.
+     * - still `connecting` → wait for the script's `onSettled` callback (no
+     *   polling latency) and adopt-if-ready the instant it fires; on older
+     *   scripts without the hook, fall back to a `timer` poll.
      *
      * Deliberately NO time budget: for DIRECT orchestration the prefetch holds
      * the socket open while the orchestrator provisions a machine, which can take
@@ -3639,12 +3646,48 @@ class StreamAdoptionService {
                 return of(this.tryAdopt());
             }
             Logger.info('[Adoption] Prefetch in progress — waiting before connecting');
+            // Preferred path: the script fires `onSettled` the moment it parks
+            // `ready`/`failed`, so we adopt with zero polling lag.
+            if (typeof parked.onSettled === 'function') {
+                return this.awaitSettled$(parked);
+            }
+            // Legacy fallback: older head-script without the hook — poll its state.
             return timer(0, ADOPT_POLL_MS).pipe(map$1(() => window.__stream?.state ?? 'failed'), 
             // Keep polling while still connecting; the `true` (inclusive) emits the
             // settling value (`ready`/`failed`) that ends the wait.
             takeWhile((state) => state === 'connecting', true), last(), map$1(() => this.tryAdopt()));
         });
     }
+    /**
+     * Event-driven wait: resolve the instant the script's `onSettled` callback
+     * fires (ready/failed), then adopt-if-ready. Emits exactly once.
+     *
+     * A coarse {@link ADOPT_EVENT_SAFETY_MS} interval is a backstop only — if
+     * `onSettled` somehow never fires it still settles, without adding latency to
+     * the normal case. Teardown (route change → unsubscribe) sets `done`, so a
+     * late callback after cancel can't trigger a stray adoption.
+     */
+    awaitSettled$(parked) {
+        return new Observable((subscriber) => {
+            let done = false;
+            const finish = () => {
+                if (done)
+                    return;
+                done = true;
+                subscriber.next(this.tryAdopt());
+                subscriber.complete();
+            };
+            parked.onSettled?.(() => finish());
+            const safety = setInterval(() => {
+                if ((window.__stream?.state ?? 'failed') !== 'connecting')
+                    finish();
+            }, ADOPT_EVENT_SAFETY_MS);
+            return () => {
+                done = true;
+                clearInterval(safety);
+            };
+        });
+    }
     /**
      * @returns `true` if a ready parked stream was adopted (caller must NOT
      *          start a fresh connection), `false` otherwise.