@m4l/gclick 0.24.1 → 0.25.0

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

@@ -27,6 +27,10 @@ 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":"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"}
+{"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"}

package/components/CameraStream/defaults/DefaultPhaseStreaming.js

@@ -1,14 +1,15 @@
-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({
+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({
   playerKey: t,
-  hlsUrl: f,
-  ended: m,
-  onEnded: d,
-  onReplay: p,
+  hlsUrl: m,
+  ended: d,
+  onEnded: f,
+  onReplay: E,
   replayLabel: _,
   onDurationChange: R,
   variant: g,
@@ -20,30 +21,30 @@ function G({
   sharedLabel: M,
   sharedRemainingLabel: T
 }) {
-  const [b, r] = C(!0), [h, S] = C(0), A = u(null), n = j(k), o = u(0), a = u(0), i = u(null);
+  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);
   l(() => {
-    r(!0), S(0), o.current = 0, a.current = 0;
-  }, [f]), l(() => () => {
+    r(!0), h(0), s.current = 0, a.current = 0;
+  }, [m]), l(() => () => {
     i.current && clearTimeout(i.current);
   }, []), l(() => {
-    const e = A.current;
+    const e = p.current;
     if (!(!n || !e))
       return n.register(t, e), () => n.unregister(t);
-  }, [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) {
+  }, [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) {
       a.current += 1, r(!0), i.current = setTimeout(() => {
-        o.current = 0, S((I) => I + 1);
-      }, U);
+        s.current = 0, h((N) => N + 1);
+      }, Y);
       return;
     }
-    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: _ }),
+    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: _ }),
     y && /* @__PURE__ */ c(
       x,
       {
@@ -53,18 +54,19 @@ function G({
       }
     ),
     /* @__PURE__ */ c(
-      v,
+      V,
       {
-        ref: A,
-        src: f,
+        ref: p,
+        src: m,
+        suspended: F,
         variant: g,
-        onDurationChange: F,
-        onEnded: O
+        onDurationChange: O,
+        onEnded: I
       },
-      h
+      S
     )
   ] });
 }
 export {
-  G as DefaultPhaseStreaming
+  Q as DefaultPhaseStreaming
 };

package/components/CameraStreams/CameraStreamsProvider.d.ts

@@ -12,6 +12,11 @@ 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;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,oDAkCtE"}
+{"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"}

package/components/CameraStreams/CameraStreamsProvider.js

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

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

@@ -24,9 +24,13 @@ export interface CameraStreamPlayersRegistry {
     keys(): PlayerKey[];
     /**
      * Subscribe to registration changes (a control registered or unregistered).
-     * 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.
+     * 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.
      */
     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;;;;;OAKG;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;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC7C;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,6DACkB,CAAC"}

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

@@ -0,0 +1,15 @@
+/**
+ * Context carrying the provider's soft-suspension flag down to the streaming
+ * slots.
+ *
+ * Deliberately separate from {@link CameraStreamPlayersContext}: this is desired
+ * STATE, not an imperative seam. A slot reads it and lets its own player
+ * synchronize, instead of being handed a `pause()` it may not be able to honour
+ * yet — the v10 store has no media element attached on its first commit, so an
+ * order pushed in at registration time is both a crash and a no-op.
+ *
+ * Defaults to `false` so a slot rendered outside a provider (an isolated test,
+ * a story) still plays normally.
+ */
+export declare const CameraStreamsSuspensionContext: import('react').Context<boolean>;
+//# sourceMappingURL=CameraStreamsSuspensionContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CameraStreamsSuspensionContext.d.ts","sourceRoot":"","sources":["../../../../../../../packages/gclick/src/components/CameraStreams/contexts/CameraStreamsSuspensionContext.tsx"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,8BAA8B,kCAAuB,CAAC"}

package/components/CameraStreams/contexts/CameraStreamsSuspensionContext.js

@@ -0,0 +1,5 @@
+import { createContext as e } from "react";
+const o = e(!1);
+export {
+  o as CameraStreamsSuspensionContext
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Read whether the enclosing `<CameraStreamsProvider>` is currently suspended.
+ * A custom `phaseStreaming` slot must forward this to its `<VideoPlayer>` to
+ * keep the suspension semantics.
+ */
+export declare function useCameraStreamsSuspended(): boolean;
+//# sourceMappingURL=useCameraStreamsSuspended.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCameraStreamsSuspended.d.ts","sourceRoot":"","sources":["../../../../../../../packages/gclick/src/components/CameraStreams/hooks/useCameraStreamsSuspended.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAEnD"}

package/components/CameraStreams/hooks/useCameraStreamsSuspended.js

@@ -0,0 +1,8 @@
+import { useContext as e } from "react";
+import { CameraStreamsSuspensionContext as r } from "../contexts/CameraStreamsSuspensionContext.js";
+function m() {
+  return e(r);
+}
+export {
+  m as useCameraStreamsSuspended
+};

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

@@ -1,16 +1,6 @@
 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
@@ -23,6 +13,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, commandUuid, deviceId, createdAt, endProgress, }: UseStreamPollingArgs): void;
+export declare function useStreamPolling({ playerKey }: 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;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"}
+{"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"}

package/components/CameraStreams/hooks/useStreamPolling.js

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

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

@@ -1,4 +1,4 @@
-import { PlayerKey, StreamPhase } from '../types';
+import { PlayerKey } 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,16 +6,15 @@ import { PlayerKey, StreamPhase } 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.
  *
- * 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.
+ * 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`.
  *
- * One instance per `playerKey` — mounted by `<CameraStreamsEngine>` only
- * while the player's `phase.kind === 'requesting'` or `'polling'`.
+ * 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.
  */
 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":"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"}
+{"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"}