@m4l/gclick 0.24.1-beta-fix-video-playback-lifecycle-beta32.0 → 0.24.1

package/components/CameraStream/defaults/DefaultPhaseStreaming.d.ts

@@ -27,10 +27,6 @@ import { CameraStreamPhaseStreamingSlotProps } from '../types';
  * (pause / mute / fullscreen / snapshot) from outside the slot. The
  * registration is null-safe: if the slot is rendered without a provider (e.g.
  * an isolated test), it simply skips registering.
- *
- * Forwards the provider's suspension flag to the player. A custom
- * `phaseStreaming` slot must do the same, or its clips keep decoding behind a
- * hidden tab.
  */
 export declare function DefaultPhaseStreaming({ playerKey, hlsUrl, ended, onEnded, onReplay, replayLabel, onDurationChange, variant, LiveBadgeSlot, ReplayBadgeSlot, SharedBadgeSlot, attached, endsAt, sharedLabel, sharedRemainingLabel, }: CameraStreamPhaseStreamingSlotProps): import("@emotion/react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=DefaultPhaseStreaming.d.ts.map

package/components/CameraStream/defaults/DefaultPhaseStreaming.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DefaultPhaseStreaming.d.ts","sourceRoot":"","sources":["../../../../../../../packages/gclick/src/components/CameraStream/defaults/DefaultPhaseStreaming.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,UAAU,CAAC;AAcpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,SAAS,EACT,MAAM,EACN,KAAK,EACL,OAAO,EACP,QAAQ,EACR,WAAW,EACX,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,eAAe,EACf,eAAe,EACf,QAAQ,EACR,MAAM,EACN,WAAW,EACX,oBAAoB,GACrB,EAAE,mCAAmC,oDA0GrC"}
+{"version":3,"file":"DefaultPhaseStreaming.d.ts","sourceRoot":"","sources":["../../../../../../../packages/gclick/src/components/CameraStream/defaults/DefaultPhaseStreaming.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,UAAU,CAAC;AAcpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,SAAS,EACT,MAAM,EACN,KAAK,EACL,OAAO,EACP,QAAQ,EACR,WAAW,EACX,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,eAAe,EACf,eAAe,EACf,QAAQ,EACR,MAAM,EACN,WAAW,EACX,oBAAoB,GACrB,EAAE,mCAAmC,oDAqGrC"}

package/components/CameraStream/defaults/DefaultPhaseStreaming.js

@@ -1,15 +1,14 @@
-import { jsxs as j, jsx as c } from "@emotion/react/jsx-runtime";
-import { useState as C, useRef as u, useContext as k, useEffect as l, useCallback as A } from "react";
-import { CameraStreamPlayersContext as v } from "../../CameraStreams/contexts/CameraStreamPlayersContext.js";
-import { useCameraStreamsSuspended as B } from "../../CameraStreams/hooks/useCameraStreamsSuspended.js";
-import { VideoPlayer as V } from "../../VideoPlayer/VideoPlayer.js";
-const U = 3, X = 2, Y = 2500;
-function Q({
+import { jsxs as N, jsx as c } from "@emotion/react/jsx-runtime";
+import { useState as C, useRef as u, useContext as j, useEffect as l, useCallback as E } from "react";
+import { CameraStreamPlayersContext as k } from "../../CameraStreams/contexts/CameraStreamPlayersContext.js";
+import { VideoPlayer as v } from "../../VideoPlayer/VideoPlayer.js";
+const B = 3, V = 2, U = 2500;
+function G({
   playerKey: t,
-  hlsUrl: m,
-  ended: d,
-  onEnded: f,
-  onReplay: E,
+  hlsUrl: f,
+  ended: m,
+  onEnded: d,
+  onReplay: p,
   replayLabel: _,
   onDurationChange: R,
   variant: g,
@@ -21,30 +20,30 @@ function Q({
   sharedLabel: M,
   sharedRemainingLabel: T
 }) {
-  const [b, r] = C(!0), [S, h] = C(0), p = u(null), n = k(v), F = B(), s = u(0), a = u(0), i = u(null);
+  const [b, r] = C(!0), [h, S] = C(0), A = u(null), n = j(k), o = u(0), a = u(0), i = u(null);
   l(() => {
-    r(!0), h(0), s.current = 0, a.current = 0;
-  }, [m]), l(() => () => {
+    r(!0), S(0), o.current = 0, a.current = 0;
+  }, [f]), l(() => () => {
     i.current && clearTimeout(i.current);
   }, []), l(() => {
-    const e = p.current;
+    const e = A.current;
     if (!(!n || !e))
       return n.register(t, e), () => n.unregister(t);
-  }, [n, t, S]);
-  const O = A((e, o) => {
-    r(o), !o && Number.isFinite(e) && (s.current = e), R(e, o);
-  }, [R]), I = A(() => {
-    if (s.current < U && a.current < X) {
+  }, [n, t, h]);
+  const F = E((e, s) => {
+    r(s), !s && Number.isFinite(e) && (o.current = e), R(e, s);
+  }, [R]), O = E(() => {
+    if (o.current < B && a.current < V) {
       a.current += 1, r(!0), i.current = setTimeout(() => {
-        s.current = 0, h((N) => N + 1);
-      }, Y);
+        o.current = 0, S((I) => I + 1);
+      }, U);
       return;
     }
-    r(!1), f();
-  }, [f]);
-  return /* @__PURE__ */ j("div", { "data-stream-player-key": t, style: { width: "100%", height: "100%" }, children: [
-    b && !d && /* @__PURE__ */ c(D, {}),
-    d && /* @__PURE__ */ c(P, { onReplay: E, replayLabel: _ }),
+    r(!1), d();
+  }, [d]);
+  return /* @__PURE__ */ N("div", { "data-stream-player-key": t, style: { width: "100%", height: "100%" }, children: [
+    b && !m && /* @__PURE__ */ c(D, {}),
+    m && /* @__PURE__ */ c(P, { onReplay: p, replayLabel: _ }),
     y && /* @__PURE__ */ c(
       x,
       {
@@ -54,19 +53,18 @@ function Q({
       }
     ),
     /* @__PURE__ */ c(
-      V,
+      v,
       {
-        ref: p,
-        src: m,
-        suspended: F,
+        ref: A,
+        src: f,
         variant: g,
-        onDurationChange: O,
-        onEnded: I
+        onDurationChange: F,
+        onEnded: O
       },
-      S
+      h
     )
   ] });
 }
 export {
-  Q as DefaultPhaseStreaming
+  G as DefaultPhaseStreaming
 };

package/components/CameraStreams/CameraStreamsProvider.d.ts

@@ -12,11 +12,6 @@ import { CameraStreamsProviderProps } from './types';
  * ref-based map of live `VideoPlayerControl`s). The default `phaseStreaming`
  * slot registers into it, so `useCameraStreamPlayers()` can drive the video
  * transport (pause / mute / fullscreen / snapshot) from outside the slot.
- *
- * The third seam is `CameraStreamsSuspensionContext`, which publishes the
- * `suspended` flag so each player synchronizes its own playback instead of
- * being driven through the registry. See that context for why suspension is
- * declared rather than pushed.
  */
 export declare function CameraStreamsProvider(props: CameraStreamsProviderProps): import("@emotion/react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=CameraStreamsProvider.d.ts.map

package/components/CameraStreams/CameraStreamsProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CameraStreamsProvider.d.ts","sourceRoot":"","sources":["../../../../../../packages/gclick/src/components/CameraStreams/CameraStreamsProvider.tsx"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,oDAmCtE"}
+{"version":3,"file":"CameraStreamsProvider.d.ts","sourceRoot":"","sources":["../../../../../../packages/gclick/src/components/CameraStreams/CameraStreamsProvider.tsx"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,oDAkCtE"}

package/components/CameraStreams/CameraStreamsProvider.js

@@ -1,27 +1,28 @@
 import { jsx as t, jsxs as c } from "@emotion/react/jsx-runtime";
 import { useRef as o } from "react";
-import { useModuleDictionary as u } from "@m4l/core";
-import { resolveCameraStreamsDictionaryLabels as f } from "./dictionary.js";
+import { useModuleDictionary as f } from "@m4l/core";
+import { resolveCameraStreamsDictionaryLabels as u } from "./dictionary.js";
 import { CameraStreamsContext as p } from "./contexts/CameraStreamsContext.js";
-import { CameraStreamPlayersContext as d } from "./contexts/CameraStreamPlayersContext.js";
-import { CameraStreamsSuspensionContext as C } from "./contexts/CameraStreamsSuspensionContext.js";
+import { CameraStreamPlayersContext as C } from "./contexts/CameraStreamPlayersContext.js";
 import { createCameraStreamsStore as S } from "./store.js";
-import { createCameraStreamPlayersRegistry as v } from "./helpers/createCameraStreamPlayersRegistry.js";
+import { createCameraStreamPlayersRegistry as d } from "./helpers/createCameraStreamPlayersRegistry.js";
 import { CameraStreamsEngine as y } from "./subcomponents/CameraStreamsEngine.js";
+import { CameraStreamsSuspensionController as v } from "./subcomponents/CameraStreamsSuspensionController.js";
 function M(a) {
-  const { children: m, labels: i, suspended: s = !1, ...n } = a, { getLabel: l } = u(), r = o(null);
+  const { children: m, labels: s, suspended: i = !1, ...n } = a, { getLabel: l } = f(), r = o(null);
   r.current || (r.current = S({
     ...n,
     labels: {
-      ...f(l),
-      ...i ?? {}
+      ...u(l),
+      ...s ?? {}
     }
   }));
   const e = o(null);
-  return e.current || (e.current = v()), /* @__PURE__ */ t(p.Provider, { value: r.current, children: /* @__PURE__ */ t(d.Provider, { value: e.current, children: /* @__PURE__ */ c(C.Provider, { value: s, children: [
+  return e.current || (e.current = d()), /* @__PURE__ */ t(p.Provider, { value: r.current, children: /* @__PURE__ */ c(C.Provider, { value: e.current, children: [
     /* @__PURE__ */ t(y, {}),
+    /* @__PURE__ */ t(v, { suspended: i }),
     m
-  ] }) }) });
+  ] }) });
 }
 export {
   M as CameraStreamsProvider

package/components/CameraStreams/contexts/CameraStreamPlayersContext.d.ts

@@ -24,13 +24,9 @@ export interface CameraStreamPlayersRegistry {
     keys(): PlayerKey[];
     /**
      * Subscribe to registration changes (a control registered or unregistered).
-     * Returns an unsubscribe function, so a consumer holding a snapshot of the
-     * registry can keep it current as players mount and unmount.
-     *
-     * Note that listeners run SYNCHRONOUSLY inside `register` / `unregister`,
-     * which means inside the registering component's own effect. Anything a
-     * listener does then runs against a player that has only just committed —
-     * which is why suspension no longer travels this way.
+     * Returns an unsubscribe function. Lets the suspension coordinator catch
+     * players that start streaming *after* the subtree was already suspended (an
+     * in-flight request resolving while hidden), which a one-shot snapshot misses.
      */
     subscribe(listener: () => void): () => void;
 }

package/components/CameraStreams/contexts/CameraStreamPlayersContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CameraStreamPlayersContext.d.ts","sourceRoot":"","sources":["../../../../../../../packages/gclick/src/components/CameraStreams/contexts/CameraStreamPlayersContext.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,2BAA2B;IAC1C,0DAA0D;IAC1D,QAAQ,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC5D,+DAA+D;IAC/D,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IACjC,2EAA2E;IAC3E,GAAG,CAAC,GAAG,EAAE,SAAS,GAAG,kBAAkB,GAAG,IAAI,CAAC;IAC/C,6CAA6C;IAC7C,IAAI,IAAI,SAAS,EAAE,CAAC;IACpB;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC7C;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,6DACkB,CAAC"}
+{"version":3,"file":"CameraStreamPlayersContext.d.ts","sourceRoot":"","sources":["../../../../../../../packages/gclick/src/components/CameraStreams/contexts/CameraStreamPlayersContext.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,2BAA2B;IAC1C,0DAA0D;IAC1D,QAAQ,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC5D,+DAA+D;IAC/D,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IACjC,2EAA2E;IAC3E,GAAG,CAAC,GAAG,EAAE,SAAS,GAAG,kBAAkB,GAAG,IAAI,CAAC;IAC/C,6CAA6C;IAC7C,IAAI,IAAI,SAAS,EAAE,CAAC;IACpB;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC7C;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,6DACkB,CAAC"}

package/components/CameraStreams/hooks/useStreamPolling.d.ts

@@ -1,6 +1,16 @@
 import { PlayerKey } from '../types';
 interface UseStreamPollingArgs {
     playerKey: PlayerKey;
+    /**
+     * Command to poll for; `undefined` while the player is not `polling` — and
+     * also while it polls a session it joined, which has no command of ours.
+     */
+    commandUuid: string | undefined;
+    /** Command coordinates captured from the POST response. */
+    deviceId: number | null;
+    createdAt: string | null;
+    /** Release the host progress indicator on a terminal transition. */
+    endProgress: () => void;
 }
 /**
  * Poll for one player until its stream settles, publishing both the outcome
@@ -13,6 +23,6 @@ interface UseStreamPollingArgs {
  * owns the wait: they have different lifetimes (the POST fires once, the poll
  * runs for minutes) and different failure modes.
  */
-export declare function useStreamPolling({ playerKey }: UseStreamPollingArgs): void;
+export declare function useStreamPolling({ playerKey, commandUuid, deviceId, createdAt, endProgress, }: UseStreamPollingArgs): void;
 export {};
 //# sourceMappingURL=useStreamPolling.d.ts.map

package/components/CameraStreams/hooks/useStreamPolling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStreamPolling.d.ts","sourceRoot":"","sources":["../../../../../../../packages/gclick/src/components/CameraStreams/hooks/useStreamPolling.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AA4B1C,UAAU,oBAAoB;IAC5B,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,SAAS,EAAE,EAAE,oBAAoB,GAAG,IAAI,CA0T1E"}
+{"version":3,"file":"useStreamPolling.d.ts","sourceRoot":"","sources":["../../../../../../../packages/gclick/src/components/CameraStreams/hooks/useStreamPolling.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AA4B1C,UAAU,oBAAoB;IAC5B,SAAS,EAAE,SAAS,CAAC;IACrB;;;OAGG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,oEAAoE;IACpE,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,SAAS,EACT,WAAW,EACX,QAAQ,EACR,SAAS,EACT,WAAW,GACZ,EAAE,oBAAoB,GAAG,IAAI,CA2T7B"}

package/components/CameraStreams/hooks/useStreamPolling.js

@@ -1,65 +1,67 @@
-import { useRef as R, useEffect as k } from "react";
-import { useQuery as b } from "@tanstack/react-query";
+import { useRef as x, useEffect as k } from "react";
+import { useQuery as A } from "@tanstack/react-query";
 import { useNetwork as D } from "@m4l/core";
-import { extractHlsUrlFromResponse as O, safeParseJson as _, resolveCommandErrorMessage as x, extractErrorMessage as F } from "../helpers/commandError.js";
-import { resolvePollInterval as T } from "../helpers/pollSchedule.js";
-import { pendingStageBoundaries as q } from "../helpers/waitingStages.js";
-import { useCameraStreamsStore as h } from "./useCameraStreamsStore.js";
-import { useCloudFrontCookieManager as B } from "./useCloudFrontCookie.js";
-const M = /* @__PURE__ */ new Set([
+import { extractHlsUrlFromResponse as F, safeParseJson as q, resolveCommandErrorMessage as B, extractErrorMessage as M } from "../helpers/commandError.js";
+import { resolvePollInterval as R } from "../helpers/pollSchedule.js";
+import { pendingStageBoundaries as P } from "../helpers/waitingStages.js";
+import { useCameraStreamsStore as f } from "./useCameraStreamsStore.js";
+import { useCloudFrontCookieManager as N } from "./useCloudFrontCookie.js";
+const G = /* @__PURE__ */ new Set([
   "executed",
   "error",
   "error_retries_max",
   "channel_busy"
 ]);
-function N(t) {
+function V(t) {
   return !!t.hlsUrl || t.status === "error";
 }
-function G({ createdAt: t, requestedDuration: p }) {
-  if (typeof p != "number")
+function W({ createdAt: t, requestedDuration: c }) {
+  if (typeof c != "number")
     return;
-  const i = new Date(t).getTime() + p * 1e3;
-  return Number.isFinite(i) ? new Date(i).toISOString() : void 0;
+  const h = new Date(t).getTime() + c * 1e3;
+  return Number.isFinite(h) ? new Date(h).toISOString() : void 0;
 }
-function y({ playerKey: t }) {
-  const { networkOperation: p } = D(), { ensureCookies: i } = B(), o = h((e) => e.players[t]), c = h((e) => e.labels), C = h((e) => e.config.endpointDevicesCommand), w = h((e) => e.config.endpointVideoStreams), l = h((e) => e.config.pollBudgetSeconds), n = h((e) => e.actions.setPhase), d = R(o);
-  d.current = o;
-  const m = o?.phase.kind === "polling", I = m && o.phase.kind === "polling" ? o.phase.startedAt : null, u = m && o.phase.kind === "polling" ? {
-    uuid: o.phase.commandUuid,
-    deviceId: o.phase.commandDeviceId,
-    createdAt: o.phase.commandCreatedAt
-  } : void 0, S = u?.uuid, v = m && o.phase.kind === "polling" && !S ? o.phase.streamUuid : void 0, { data: E, error: U } = b({
-    queryKey: ["cameraStreamRequest", t, S],
+function X({
+  playerKey: t,
+  commandUuid: c,
+  deviceId: h,
+  createdAt: v,
+  endProgress: o
+}) {
+  const { networkOperation: U } = D(), { ensureCookies: g } = N(), i = f((e) => e.players[t]), u = f((e) => e.labels), O = f((e) => e.config.endpointDevicesCommand), _ = f((e) => e.config.endpointVideoStreams), d = f((e) => e.config.pollBudgetSeconds), n = f((e) => e.actions.setPhase), l = x(i);
+  l.current = i;
+  const S = i?.phase.kind === "polling", I = S && i.phase.kind === "polling" ? i.phase.startedAt : null, E = i?.phase.kind === "polling" && !i.phase.commandUuid ? i.phase.streamUuid : void 0, { data: b, error: T } = A({
+    queryKey: ["cameraStreamRequest", t, c],
     /**
      * Poll `devices/command` until the command associated with this player's
      * `commandUuid` reaches a terminal status.
      */
-    queryFn: async () => !u?.uuid || u.deviceId === void 0 || !u.createdAt ? null : p({
+    queryFn: async () => !c || h === null || !v ? null : U({
       method: "GET",
-      endPoint: C,
+      endPoint: O,
       parms: {
-        deviceId: u.deviceId,
-        createdAt: u.createdAt,
-        uuid: u.uuid
+        deviceId: h,
+        createdAt: v,
+        uuid: c
       },
       toastError: !1,
       toastSuccess: !1,
       responseToCamelCase: !0
     }),
-    enabled: !!S && m,
+    enabled: !!c && S,
     /**
      * Staged interval from `helpers/pollSchedule.ts`. Returns `false` once the
      * backend reports a terminal status or the budget is spent.
      */
     refetchInterval: (e) => {
       const r = e.state.data?.data?.statusId ?? "";
-      if (M.has(r))
+      if (G.has(r))
         return !1;
-      const s = d.current;
+      const s = l.current;
       if (s?.phase.kind !== "polling")
         return !1;
       const a = s.phase.startedAt;
-      return T((Date.now() - a) / 1e3, l);
+      return R((Date.now() - a) / 1e3, d);
     },
     retry: !1,
     refetchOnWindowFocus: !1,
@@ -70,24 +72,24 @@ function y({ playerKey: t }) {
     // and the tile comes back frozen on a stale phase.
     refetchIntervalInBackground: !0,
     staleTime: 1 / 0
-  }), { data: P, error: A } = b({
-    queryKey: ["cameraStreamAttached", t, v],
+  }), { data: w, error: C } = A({
+    queryKey: ["cameraStreamAttached", t, E],
     /** Read the joined stream until it exposes an `hlsUrl` or fails. */
-    queryFn: async () => v ? p({
+    queryFn: async () => E ? U({
       method: "GET",
-      endPoint: `${w}/${v}`,
+      endPoint: `${_}/${E}`,
       toastError: !1,
       toastSuccess: !1,
       responseToCamelCase: !0
     }) : null,
-    enabled: !!v,
+    enabled: !!E,
     /** Same staged cadence and budget cut-off as the command poll. */
     refetchInterval: (e) => {
       const r = e.state.data?.data;
-      if (r && N(r))
+      if (r && V(r))
         return !1;
-      const s = d.current;
-      return s?.phase.kind !== "polling" ? !1 : T((Date.now() - s.phase.startedAt) / 1e3, l);
+      const s = l.current;
+      return s?.phase.kind !== "polling" ? !1 : R((Date.now() - s.phase.startedAt) / 1e3, d);
     },
     retry: !1,
     refetchOnWindowFocus: !1,
@@ -97,115 +99,118 @@ function y({ playerKey: t }) {
     staleTime: 1 / 0
   });
   k(() => {
-    if (!m)
+    if (!S)
       return;
     const e = setTimeout(() => {
-      d.current?.phase.kind === "polling" && n(t, { kind: "timeout" });
-    }, l * 1e3);
+      l.current?.phase.kind === "polling" && (n(t, { kind: "timeout" }), o());
+    }, d * 1e3);
     return () => {
       clearTimeout(e);
     };
-  }, [m, t, l, n]), k(() => {
+  }, [S, t, d, n, o]), k(() => {
     if (I === null)
       return;
-    const e = (Date.now() - I) / 1e3, r = q(e, l).map(
+    const e = (Date.now() - I) / 1e3, r = P(e, d).map(
       ({ stage: s, delayMs: a }) => setTimeout(() => {
-        const f = d.current;
-        f?.phase.kind === "polling" && n(t, { ...f.phase, stage: s });
+        const m = l.current;
+        m?.phase.kind === "polling" && n(t, { ...m.phase, stage: s });
       }, a)
     );
     return () => {
       r.forEach(clearTimeout);
     };
-  }, [I, t, l, n]), k(() => {
-    const e = E?.data;
+  }, [I, t, d, n]), k(() => {
+    const e = b?.data;
     if (!e)
       return;
-    const r = d.current;
+    const r = l.current;
     if (!(!r || r.phase.kind !== "polling")) {
       if (e.statusId === "executed") {
-        const s = O(e.response);
+        const s = F(e.response);
         if (!s) {
-          n(t, { kind: "error", code: "missing-hls-url", message: c.playerErrorPlayback });
+          n(t, { kind: "error", code: "missing-hls-url", message: u.playerErrorPlayback }), o();
           return;
         }
-        const { commandUuid: a, streamUuid: f } = r.phase, g = () => {
+        const { commandUuid: a, streamUuid: m } = r.phase, p = () => {
           n(t, {
             kind: "streaming",
             commandUuid: a,
-            streamUuid: f,
+            streamUuid: m,
             hlsUrl: s
-          });
+          }), o();
         };
-        i().then(g).catch(g);
+        g().then(p).catch(p);
         return;
       }
       if (e.statusId === "channel_busy") {
-        n(t, { kind: "channelBusy" });
+        n(t, { kind: "channelBusy" }), o();
         return;
       }
       if (e.statusId === "error") {
-        const s = _(e.response, {
+        const s = q(e.response, {
           error: { origin: "", message: "", status: 0, agent: "" },
           body: ""
-        }), a = x(s, c.playerErrorPlayback);
+        }), a = B(s, u.playerErrorPlayback);
         n(t, {
           kind: "error",
           code: "remote-error",
           message: a
-        });
+        }), o();
         return;
       }
       if (e.statusId === "error_retries_max") {
-        n(t, { kind: "timeout" });
+        n(t, { kind: "timeout" }), o();
         return;
       }
     }
   }, [
-    E,
+    b,
     t,
-    c.playerErrorPlayback,
-    i,
-    n
+    u.playerErrorPlayback,
+    g,
+    n,
+    o
   ]), k(() => {
-    const e = P?.data;
+    const e = w?.data;
     if (!e)
       return;
-    const r = d.current;
+    const r = l.current;
     if (!(!r || r.phase.kind !== "polling")) {
       if (e.hlsUrl) {
-        const { streamUuid: s } = r.phase, { hlsUrl: a } = e, f = G(e), g = () => {
-          n(t, { kind: "streaming", streamUuid: s, hlsUrl: a, attached: !0, endsAt: f });
+        const { streamUuid: s } = r.phase, { hlsUrl: a } = e, m = W(e), p = () => {
+          n(t, { kind: "streaming", streamUuid: s, hlsUrl: a, attached: !0, endsAt: m }), o();
         };
-        i().then(g).catch(g);
+        g().then(p).catch(p);
         return;
       }
-      e.status === "error" && n(t, {
+      e.status === "error" && (n(t, {
         kind: "error",
         code: "attached-stream-failed",
-        message: c.playerErrorPlayback
-      });
+        message: u.playerErrorPlayback
+      }), o());
     }
   }, [
-    P,
+    w,
     t,
-    c.playerErrorPlayback,
-    i,
-    n
+    u.playerErrorPlayback,
+    g,
+    n,
+    o
   ]), k(() => {
-    const e = U ?? A;
+    const e = T ?? C;
     if (!e)
       return;
-    const r = F(e, c.requestErrorUnknownPolling);
-    n(t, { kind: "error", code: "polling-failed", message: r });
+    const r = M(e, u.requestErrorUnknownPolling);
+    n(t, { kind: "error", code: "polling-failed", message: r }), o();
   }, [
-    U,
-    A,
+    T,
+    C,
     t,
-    c.requestErrorUnknownPolling,
-    n
+    u.requestErrorUnknownPolling,
+    n,
+    o
   ]);
 }
 export {
-  y as useStreamPolling
+  X as useStreamPolling
 };

package/components/CameraStreams/hooks/useStreamRequest.d.ts

@@ -1,4 +1,4 @@
-import { PlayerKey } from '../types';
+import { PlayerKey, StreamPhase } from '../types';
 /**
  * Engine hook that opens a single player's stream lifecycle: POST to obtain
  * the command/stream UUIDs and move the FSM into `polling`, then delegate the
@@ -6,15 +6,16 @@ import { PlayerKey } from '../types';
  * poll budget, mode, and duration are all read from the scoped Zustand store
  * so the hook stays agnostic of any MF-specific config.
  *
- * One instance per `playerKey`, mounted by `<CameraStreamsEngine>` for as long
- * as the player slice exists — including while it sits `idle`. No network work
- * happens outside `requesting` / `polling`.
+ * The request/poll busy indicator is driven through the mounting window's tools
+ * (`useWindowToolsMF`), so the spinner renders inside the owning module panel
+ * (omm / gps_devices) instead of the global host shell. Requires the subtree to
+ * live under a `WindowToolsMFProvider`, which both consumers already mount.
  *
- * It deliberately owns no module-level busy indicator; the tile's own
- * `requesting` / `polling` phases are the wait. See the README gotcha for why
- * an engine-owned indicator cannot be released reliably.
+ * One instance per `playerKey` — mounted by `<CameraStreamsEngine>` only
+ * while the player's `phase.kind === 'requesting'` or `'polling'`.
  */
 export declare function useStreamRequest({ playerKey }: {
     playerKey: PlayerKey;
 }): void;
+export type { StreamPhase };
 //# sourceMappingURL=useStreamRequest.d.ts.map

package/components/CameraStreams/hooks/useStreamRequest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStreamRequest.d.ts","sourceRoot":"","sources":["../../../../../../../packages/gclick/src/components/CameraStreams/hooks/useStreamRequest.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,SAAS,EAAE,EAAE;IAAE,SAAS,EAAE,SAAS,CAAA;CAAE,GAAG,IAAI,CAgI9E"}
+{"version":3,"file":"useStreamRequest.d.ts","sourceRoot":"","sources":["../../../../../../../packages/gclick/src/components/CameraStreams/hooks/useStreamRequest.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,SAAS,EAAE,EAAE;IAAE,SAAS,EAAE,SAAS,CAAA;CAAE,QAqLvE;AAGD,YAAY,EAAE,WAAW,EAAE,CAAC"}