@tiledev/sdk-apptile-live-selling 0.8.0 → 0.9.0

package/dist/react/useLiveSession.js

@@ -6,9 +6,17 @@ exports.LiveSessionProvider = LiveSessionProvider;
  * `LiveSessionProvider` / `useLiveSession` — the assembled session.
  *
  * This is the layer that turns the engine's event stream plus the polled record into one renderable
- * state. It owns the two clocks (the elapsed/prune tick and the faster auction tick), the
- * picture-in-picture mode machine, product resolution through the commerce adapter, and every action
- * a live screen fires.
+ * state. It owns the picture-in-picture mode machine, product resolution through the commerce adapter,
+ * and every action a live screen fires.
+ *
+ * **It never ticks.** The session changes only when something happens — a room event, a record read,
+ * an action's answer — and is the same object until one of its fields changes. It holds moments, not
+ * clocks: when the round closes (`auction.closesAt`) and when the show started (`stream.startedAtMs`).
+ * A component that shows a clock counts to one of them itself (`useAuctionCountdown`, `useShowClock`,
+ * in `clocks.ts`), so only that component is drawn as the clock moves. Before 0.9.0 the session held
+ * both clocks, and every reader — every screen in the app, since the session is app-wide — was drawn
+ * five times a second during an auction round. Its own timers are timeouts to the moment they are for:
+ * the round's fallback close, and the next card or reaction to run out.
  *
  * **Mount it above your navigator.** The Zego engine holds exactly one room, and two places usually
  * render the same stream — a home-screen card and the full-screen player. Owning the session per
@@ -22,18 +30,17 @@ const react_1 = require("react");
 const react_native_1 = require("react-native");
 const cartAttributes_1 = require("../cartAttributes");
 const client_1 = require("../client");
+const auctionRules_1 = require("../auctionRules");
+const giveawayRoster_1 = require("../giveawayRoster");
+const showNames_1 = require("../showNames");
+const showLots_1 = require("../showLots");
+const heldComments_1 = require("../heldComments");
 const liveSelling_1 = require("../liveSelling");
 const sdk_apptile_live_selling_native_1 = require("@tiledev/sdk-apptile-live-selling-native");
+const pipWindow_1 = require("../pipWindow");
 const session_1 = require("../session");
 const useStreamInfo_1 = require("./useStreamInfo");
 const videoTargets_1 = require("./videoTargets");
-/** The elapsed timer and the transient-card pruning share one tick. */
-const TICK_MS = 1000;
-/**
- * The auction clock runs faster than the session tick. Seconds are the unit a bidder acts on, and a
- * 1s tick aliases against the deadline badly enough to show the same second twice and skip another.
- */
-const AUCTION_TICK_MS = 200;
 /**
  * How long past the deadline to wait before closing the round ourselves.
  *
@@ -42,6 +49,8 @@ const AUCTION_TICK_MS = 200;
  * already given up.
  */
 const AUCTION_GRACE_MS = 1000;
+/** The longest wait a JavaScript timer can hold (2^31 − 1 ms, about 24 days); a longer one fires at once. */
+const LONGEST_TIMER_MS = 2147483647;
 /**
  * How long the OS is given to actually put a picture-in-picture window up after the app goes away.
  *
@@ -51,6 +60,11 @@ const AUCTION_GRACE_MS = 1000;
  * means the host is talking to nobody from inside a backgrounded app.
  */
 const PIP_GRANT_MS = 1200;
+/**
+ * The device said it has no picture-in-picture (L21). Module state, because it is a fact about the
+ * device rather than about one session: once heard, arming stops and the error is not reported again.
+ */
+let pipUnavailableOnDevice = false;
 const LiveSessionContext = (0, react_1.createContext)(null);
 /**
  * Reads the shared live session.
@@ -68,12 +82,11 @@ function useLiveSession() {
 /* Everything but the stream hold, which belongs to the provider component: it owns which stream this
    hook is watching, so it is the only thing that can pin it. */
 function useSessionValue(props) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
     const { streamingId, viewerName: viewerNameInput, onPipRestore } = props;
     const [state, dispatch] = (0, react_1.useReducer)(session_1.sessionReducer, session_1.initialSessionState);
     const [joining, setJoining] = (0, react_1.useState)(false);
     const [error, setError] = (0, react_1.useState)(null);
-    const [now, setNow] = (0, react_1.useState)(() => Date.now());
     const [muted, setMuted] = (0, react_1.useState)(false);
     const [pipMode, setPipMode] = (0, react_1.useState)('none');
     /**
@@ -88,6 +101,24 @@ function useSessionValue(props) {
     pipModeRef.current = pipMode;
     /** Read inside the PIP listeners, which subscribe once and would otherwise close over a stale value. */
     const handoverRef = (0, react_1.useRef)(false);
+    /**
+     * Where the picture was when the system window took it: the in-app bubble (`'inapp'`) or a
+     * full-screen player (`'none'`). Coming back puts it there again (`whereTheWindowCameFrom`).
+     */
+    const windowCameFromRef = (0, react_1.useRef)('none');
+    /**
+     * The session is taking the window down itself (iOS: the app came back with it still up), so the
+     * `onPipStop` that follows is not the shopper closing it.
+     */
+    const takingWindowDownRef = (0, react_1.useRef)(false);
+    /**
+     * The show was stopped because the app is away: no window came (`PIP_GRANT_MS`), or the shopper
+     * closed the window. Until the app is back in the foreground, a surface taking the picture does not
+     * start it again (`bindVideoView`). Without this, closing a window opened from the full-screen
+     * player handed the picture straight back to that player, still focused behind the window, and the
+     * show played on with sound behind an app nobody was looking at.
+     */
+    const stoppedWhileAwayRef = (0, react_1.useRef)(false);
     const viewerIdRef = (0, react_1.useRef)(null);
     const logger = (0, client_1.getLogger)();
     const identity = (0, client_1.getIdentity)();
@@ -100,7 +131,8 @@ function useSessionValue(props) {
      * name is consulted at all so a signed-in bidder is never asked to invent one.
      */
     const [chosenName, setChosenName] = (0, react_1.useState)(() => liveSelling_1.liveSelling.viewer.cachedName());
-    const accountName = (viewerNameInput === null || viewerNameInput === void 0 ? void 0 : viewerNameInput.trim()) || null;
+    // Every name here is published to the whole room, so none may be an email (`publicName`, 0.9.0).
+    const accountName = (0, showNames_1.publicName)(viewerNameInput);
     (0, react_1.useEffect)(() => {
         if (accountName || chosenName)
             return;
@@ -113,31 +145,70 @@ function useSessionValue(props) {
             alive = false;
         };
     }, [accountName, chosenName]);
-    const customerName = (_b = (_a = identity === null || identity === void 0 ? void 0 : identity.customerName) === null || _a === void 0 ? void 0 : _a.call(identity)) !== null && _b !== void 0 ? _b : null;
-    const namedBy = (_c = accountName !== null && accountName !== void 0 ? accountName : chosenName) !== null && _c !== void 0 ? _c : ((customerName === null || customerName === void 0 ? void 0 : customerName.trim()) || null);
+    const customerName = (0, showNames_1.publicName)((_a = identity === null || identity === void 0 ? void 0 : identity.customerName) === null || _a === void 0 ? void 0 : _a.call(identity));
+    const namedBy = (_b = accountName !== null && accountName !== void 0 ? accountName : (0, showNames_1.publicName)(chosenName)) !== null && _b !== void 0 ? _b : customerName;
     const viewerName = namedBy !== null && namedBy !== void 0 ? namedBy : 'Anonymous';
+    const bidderId = (_d = (_c = identity === null || identity === void 0 ? void 0 : identity.bidderId) === null || _c === void 0 ? void 0 : _c.call(identity)) !== null && _d !== void 0 ? _d : null;
+    /**
+     * A signed-in shopper whose name has not loaded yet. They are never asked for one — the session
+     * uses the customer's own — so a comment sent now is held until it lands (L6).
+     */
+    const nameResolving = !namedBy && !!bidderId;
+    const accountNameRef = (0, react_1.useRef)(accountName);
+    accountNameRef.current = accountName;
+    const namedByRef = (0, react_1.useRef)(namedBy);
+    namedByRef.current = namedBy;
+    const nameResolvingRef = (0, react_1.useRef)(nameResolving);
+    nameResolvingRef.current = nameResolving;
     /**
      * Pushed to the engine rather than passed at join: the room is entered once, and a name given
      * mid-show must not cost a rejoin — that interrupts the video for everyone watching on this device.
      * Comments and reactions carry the author in their own payload.
+     *
+     * This effect alone is too late for the FIRST comment after a name is chosen, which is why
+     * `chooseViewerName` also sets it directly — see there.
      */
     (0, react_1.useEffect)(() => {
         liveSelling_1.liveSelling.engine.setViewerName(namedBy);
     }, [namedBy]);
-    /**
-     * The auction clock, separate from `now` so a 200ms tick does not redraw the comment pane five
-     * times a second on an ordinary live stream. This one only runs while a round is open.
-     */
-    const [auctionNow, setAuctionNow] = (0, react_1.useState)(() => Date.now());
     // Poll so a stream ending (or the host swapping the product set) is noticed without a manual
     // refresh. The engine's channels cover in-stream changes; this covers the record itself. With no
     // `streamingId` it follows whichever stream is on air.
-    const { stream, refresh: refreshStreamInfo } = (0, useStreamInfo_1.useStreamInfo)(streamingId);
+    const { stream, refresh: refreshStreamInfo, hasRead, forcedReadAt } = (0, useStreamInfo_1.useStreamInfo)(streamingId);
     const watching = streamingId !== null && streamingId !== void 0 ? streamingId : stream === null || stream === void 0 ? void 0 : stream.streamingId;
+    /** The comment pipeline; `heldComments` uses it, so it is defined before the show reset below. */
+    const deliverComment = (0, react_1.useCallback)(async (text, options) => {
+        var _a;
+        try {
+            // The host mutes by device; a per-install viewer id is the same granularity.
+            const deviceId = (_a = viewerIdRef.current) !== null && _a !== void 0 ? _a : (await liveSelling_1.liveSelling.viewer.id());
+            const own = await liveSelling_1.liveSelling.engine.sendComment(text, deviceId, options);
+            if (own)
+                dispatch({ kind: 'ownComment', comment: own });
+        }
+        catch (caught) {
+            (0, client_1.getLogger)().error(caught, { at: 'liveSession.sendComment' });
+        }
+    }, []);
+    const heldCommentsRef = (0, react_1.useRef)(null);
+    if (!heldCommentsRef.current) {
+        heldCommentsRef.current = new heldComments_1.HeldComments(({ text, options }) => deliverComment(text, options));
+    }
     (0, react_1.useEffect)(() => {
+        var _a;
         dispatch({ kind: 'reset' });
         setError(null);
+        // A comment held for the last show's room must not be said in this one.
+        (_a = heldCommentsRef.current) === null || _a === void 0 ? void 0 : _a.drop();
     }, [watching]);
+    /** The name arrived: say it to the engine first, then send what was waiting for it, in order. */
+    (0, react_1.useEffect)(() => {
+        var _a;
+        if (!namedBy || !((_a = heldCommentsRef.current) === null || _a === void 0 ? void 0 : _a.size))
+            return;
+        liveSelling_1.liveSelling.engine.setViewerName(namedBy);
+        void heldCommentsRef.current.release();
+    }, [namedBy]);
     (0, react_1.useEffect)(() => liveSelling_1.liveSelling.engine.subscribe((event) => {
         dispatch({ kind: 'event', event, at: Date.now() });
     }), []);
@@ -208,14 +279,42 @@ function useSessionValue(props) {
      * importantly an *unmute*, which is otherwise invisible until the app restarts. Keyed on the joined
      * ids because the array is a fresh object on every poll.
      */
-    const mutedKey = ((_d = stream === null || stream === void 0 ? void 0 : stream.mutedDeviceIds) !== null && _d !== void 0 ? _d : []).join(',');
+    const mutedKey = ((_e = stream === null || stream === void 0 ? void 0 : stream.mutedDeviceIds) !== null && _e !== void 0 ? _e : []).join(',');
     (0, react_1.useEffect)(() => {
         if (!stream)
             return;
         liveSelling_1.liveSelling.engine.setMutedDeviceIds(mutedKey ? mutedKey.split(',') : []);
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [mutedKey]);
-    const status = (0, session_1.deriveStatus)(state, !!stream, joining, error, (stream === null || stream === void 0 ? void 0 : stream.status) === 'live');
+    /** The room's and the record's view, before the off-air wait below has its say. */
+    const derivedStatus = (0, session_1.deriveStatus)(state, !!stream, joining, error, (stream === null || stream === void 0 ? void 0 : stream.status) === 'live');
+    /**
+     * Nothing on air, settled — Freckled Poppy's `NOTHING_ON_AIR_MS`, moved here.
+     *
+     * With no record at all `deriveStatus` says `loading`, and keeps saying it: a deep link to a show
+     * that has gone, or a session with nothing live, spun for ever. After `offAirGraceMs` (4 s) with a
+     * read finished, nothing live in it, and the room not reconnecting, the status becomes `ended`.
+     *
+     * Every forced read (`refreshStreamRecords()`, which a screen calls on focus) starts the wait again.
+     * That is the guard against a stale record: a push tap lands on a screen whose last read predates
+     * the show, and without the restart the show would be declared over before the fresh read came
+     * back.
+     */
+    const nothingOnAir = (0, session_1.isNothingOnAir)({
+        hasRead,
+        streamStatus: (_f = stream === null || stream === void 0 ? void 0 : stream.status) !== null && _f !== void 0 ? _f : null,
+        status: derivedStatus,
+    });
+    const graceMs = (0, client_1.offAirGraceMs)();
+    const [settledOffAir, setSettledOffAir] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        setSettledOffAir(false);
+        if (!nothingOnAir)
+            return;
+        const timer = setTimeout(() => setSettledOffAir(true), graceMs);
+        return () => clearTimeout(timer);
+    }, [nothingOnAir, forcedReadAt, graceMs]);
+    const status = (0, session_1.withOffAirSettled)(derivedStatus, settledOffAir);
     // A PIP surface outlives the screen that opened it, so nothing else would take it down when the
     // host ends the stream — it would sit there over the app showing a frozen last frame.
     (0, react_1.useEffect)(() => {
@@ -227,15 +326,19 @@ function useSessionValue(props) {
     // The host's end broadcast reaches us long before the polled record catches up. Stop the picture,
     // then force a refetch so every poll-driven surface drops the stream instead of waiting out the
     // interval.
+    //
+    // Keyed on the status BEFORE the off-air wait: an end the wait declared has no record to catch up
+    // with, and its forced read would restart the wait — which would end the show again four seconds
+    // later, for ever.
     (0, react_1.useEffect)(() => {
-        if (status !== 'ended')
+        if (derivedStatus !== 'ended')
             return;
         liveSelling_1.liveSelling.engine
             .stopPlayback()
             .catch((caught) => logger.error(caught, { at: 'liveSession.stopOnEnd' }));
         (0, useStreamInfo_1.refreshStreamRecords)();
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [status]);
+    }, [derivedStatus]);
     /**
      * Whether a mounted surface has asked to hand over to a system window.
      *
@@ -253,16 +356,29 @@ function useSessionValue(props) {
     // `pipMode !== 'none'` covers the in-app bubble; `handoverWanted` is what lets the FULL-SCREEN
     // player hand over too. Without it, minimising from the player armed nothing, no window opened,
     // and the audio played on behind the app because the plugin declares the `audio` background mode.
+    //
+    // What was last armed, and when it was last disarmed, are what decide on Android whether a window
+    // that opens is ours — see `ownsSystemPipWindow`.
+    //
+    // Only while the show is `playing` (`shouldArmSystemWindow`): joining, a host off camera and an ended
+    // show have no picture to put in a window. A window already up stays armed whatever the status does.
+    const armedRef = (0, react_1.useRef)(false);
+    const disarmedAtRef = (0, react_1.useRef)(0);
     (0, react_1.useEffect)(() => {
         if (!sdk_apptile_live_selling_native_1.isLivePipSupported)
             return;
-        const armed = pipMode !== 'none' || handoverWanted;
-        void sdk_apptile_live_selling_native_1.livePip.setArmed(armed);
+        const armed = (0, pipWindow_1.shouldArmSystemWindow)({ pipMode, handoverWanted, status });
+        if (armedRef.current && !armed)
+            disarmedAtRef.current = Date.now();
+        armedRef.current = armed;
+        // A device without picture-in-picture answers every arming with an error (L21); stop asking.
+        if (!(armed && pipUnavailableOnDevice))
+            void sdk_apptile_live_selling_native_1.livePip.setArmed(armed);
         liveSelling_1.liveSelling.engine
             .setBackgroundVideoEnabled(armed)
             .catch((caught) => logger.error(caught, { at: 'liveSession.backgroundVideo' }));
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [pipMode, handoverWanted]);
+    }, [pipMode, handoverWanted, status]);
     /**
      * The sound must not outlive the app when no window follows.
      *
@@ -271,11 +387,16 @@ function useSessionValue(props) {
      * declared. So a backgrounded session gives the OS `PIP_GRANT_MS` to produce a window and stops
      * playback if none arrived. `pipModeRef` rather than `pipMode`, because this subscribes once and
      * the answer is only knowable when the timer fires.
+     *
+     * A show stopped here stays stopped until the app is back (`stoppedWhileAwayRef`): a surface that
+     * re-claims meanwhile — its status changed, a window was closed — would otherwise start it again
+     * behind the app. Back in the foreground, `LiveVideoTarget` takes the picture again by itself.
      */
     (0, react_1.useEffect)(() => {
         let grant = null;
         const subscription = react_native_1.AppState.addEventListener('change', (next) => {
             if (next === 'active') {
+                stoppedWhileAwayRef.current = false;
                 if (grant)
                     clearTimeout(grant);
                 grant = null;
@@ -289,6 +410,7 @@ function useSessionValue(props) {
                 grant = null;
                 if (pipModeRef.current === 'system')
                     return;
+                stoppedWhileAwayRef.current = true;
                 liveSelling_1.liveSelling.engine
                     .stopPlayback()
                     .catch((caught) => logger.error(caught, { at: 'liveSession.noPipWindow' }));
@@ -306,22 +428,52 @@ function useSessionValue(props) {
             return;
         /**
          * Only ours if this session had a surface up first — either the in-app bubble, or the full-screen
-         * player having asked for the handover. Anything else minimising into a system window raises the
-         * same event, and taking it means the live session believes it is in a PIP window it never
-         * opened.
+         * player having asked for the handover — or, on Android, if this session armed the window the OS
+         * just opened. Anything else minimising into a system window raises the same event, and taking it
+         * means the live session believes it is in a PIP window it never opened. See `ownsSystemPipWindow`
+         * for why Android cannot go by the handover alone.
          */
         const offStart = sdk_apptile_live_selling_native_1.livePip.addListener('onPipStart', () => {
-            if (pipModeRef.current !== 'inapp' && !handoverRef.current)
+            const ours = (0, pipWindow_1.ownsSystemPipWindow)({
+                platform: react_native_1.Platform.OS,
+                pipMode: pipModeRef.current,
+                handoverWanted: handoverRef.current,
+                armed: armedRef.current,
+                disarmedAt: disarmedAtRef.current,
+                now: Date.now(),
+            });
+            if (!ours)
                 return;
+            windowCameFromRef.current = (0, pipWindow_1.whereTheWindowCameFrom)(pipModeRef.current, windowCameFromRef.current);
+            takingWindowDownRef.current = false;
             setPipMode('system');
         });
+        /**
+         * Coming back: the picture goes back to where the window took it from. The in-app bubble is the
+         * app's own surface and is still mounted, so `'inapp'` is all it takes; a full-screen player is a
+         * route only the app can navigate to, so it hears `onPipRestore`. Set in the same event as the
+         * window's end, so no render ever sees `'none'` on the way back to the bubble: a card that claims
+         * on `'none'` would take the picture for one frame and leave a black one behind.
+         */
+        const giveThePictureBack = () => {
+            const place = windowCameFromRef.current;
+            setPipMode(place);
+            if (place === 'none')
+                onPipRestore === null || onPipRestore === void 0 ? void 0 : onPipRestore(watching);
+        };
         // Expanding and closing both end in `onPipStop`; `restored` is the only thing that tells them
-        // apart, and the expand path is handled by `onPipRestore` instead.
+        // apart, and the expand path is handled by `onPipRestore` instead. Closing stops the show, and it
+        // stays stopped until the app is back in the foreground (`stoppedWhileAwayRef`).
         const offStop = sdk_apptile_live_selling_native_1.livePip.addListener('onPipStop', ({ restored }) => {
+            if (takingWindowDownRef.current) {
+                takingWindowDownRef.current = false;
+                return;
+            }
             if (restored)
                 return;
             if (pipModeRef.current !== 'system')
                 return;
+            stoppedWhileAwayRef.current = true;
             setPipMode('none');
             liveSelling_1.liveSelling.engine
                 .stopPlayback()
@@ -330,14 +482,35 @@ function useSessionValue(props) {
         const offRestore = sdk_apptile_live_selling_native_1.livePip.addListener('onPipRestore', () => {
             if (pipModeRef.current !== 'system')
                 return;
-            setPipMode('none');
-            onPipRestore === null || onPipRestore === void 0 ? void 0 : onPipRestore(watching);
+            giveThePictureBack();
+        });
+        /* iOS: back in the app with the window still up (see `isWindowStillUpOnReturn`). The picture goes
+           back where it was, then the window is taken down; its `onPipStop` is ours, not a close. */
+        const offReturn = react_native_1.AppState.addEventListener('change', (next) => {
+            if (next !== 'active')
+                return;
+            if (!(0, pipWindow_1.isWindowStillUpOnReturn)(react_native_1.Platform.OS, pipModeRef.current))
+                return;
+            takingWindowDownRef.current = true;
+            giveThePictureBack();
+            void sdk_apptile_live_selling_native_1.livePip.stop();
+        });
+        /* "Not available on this device" is a fact about the device, reported once as a warning — not an
+           error filed every time the bubble opens (L21). */
+        const offError = sdk_apptile_live_selling_native_1.livePip.addListener('onPipError', ({ message }) => {
+            if ((0, pipWindow_1.isPipUnavailableMessage)(message)) {
+                if (!pipUnavailableOnDevice)
+                    (0, client_1.logWarning)(new Error(message), { at: 'liveSession.pipUnavailable' });
+                pipUnavailableOnDevice = true;
+                return;
+            }
+            logger.error(new Error(message), { at: 'liveSession.pipError' });
         });
-        const offError = sdk_apptile_live_selling_native_1.livePip.addListener('onPipError', ({ message }) => logger.error(new Error(message), { at: 'liveSession.pipError' }));
         return () => {
             offStart === null || offStart === void 0 ? void 0 : offStart();
             offStop === null || offStop === void 0 ? void 0 : offStop();
             offRestore === null || offRestore === void 0 ? void 0 : offRestore();
+            offReturn.remove();
             offError === null || offError === void 0 ? void 0 : offError();
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -355,39 +528,45 @@ function useSessionValue(props) {
         return () => subscription.remove();
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
+    /**
+     * Sold cards, cart cards and reactions leave when their time is up (`SOLD_CARD_MS`, `CART_CARD_MS`,
+     * `REACTION_MS`): one timer, to the moment the next one runs out (`nextExpiryAt`), set again whenever
+     * that moment changes. Nothing runs with none on screen.
+     *
+     * The prune is told it is that moment even if the timer fires a millisecond early, so the card it
+     * was set for is always the one that goes — otherwise nothing would change, the moment would stay
+     * the same, and no timer would be set again.
+     */
+    const nextExpiry = (0, session_1.nextExpiryAt)(state);
     (0, react_1.useEffect)(() => {
-        if (status !== 'playing' &&
-            state.sold.length === 0 &&
-            state.cartAnnouncements.length === 0 &&
-            state.reactions.length === 0) {
+        if (nextExpiry === null)
             return;
-        }
-        const timer = setInterval(() => {
-            const at = Date.now();
-            setNow(at);
-            dispatch({ kind: 'prune', now: at });
-        }, TICK_MS);
-        return () => clearInterval(timer);
-    }, [status, state.sold.length, state.cartAnnouncements.length, state.reactions.length]);
+        const timer = setTimeout(() => {
+            dispatch({ kind: 'prune', now: Math.max(Date.now(), nextExpiry) });
+        }, Math.max(0, nextExpiry - Date.now()));
+        return () => clearTimeout(timer);
+    }, [nextExpiry]);
     /**
-     * The auction clock. Only runs while a round is open, so it costs nothing on a normal live stream.
-     * It also owns the fallback close: past the deadline plus the grace period with no word from the
-     * host, the round is over as far as this device is concerned.
+     * The round's fallback close. The host normally closes the round; when nothing arrives by the
+     * deadline plus the grace period, the round is over as far as this device is concerned. One timer to
+     * that moment, set again when a late bid moves the deadline, and gone when the round closes.
+     *
+     * Destructured rather than read off `state`, so the timer is keyed on exactly the three things that
+     * move the moment. An open round with no deadline yet (a bid heard before the opening, carrying
+     * none) closes at once, as it did on the old 200 ms clock: there is nothing to wait for.
      */
     const { biddingOpen, endsAtMs, serverOffsetMs } = state;
     (0, react_1.useEffect)(() => {
         if (!biddingOpen)
             return;
-        const timer = setInterval(() => {
-            const at = Date.now();
-            setAuctionNow(at);
-            // Destructured rather than read off `state`, so the closure cannot go stale against a deadline
-            // a late bid has already moved — the deps re-arm it when one does.
-            if (endsAtMs - (at + serverOffsetMs) < -AUCTION_GRACE_MS) {
-                dispatch({ kind: 'auctionExpired' });
-            }
-        }, AUCTION_TICK_MS);
-        return () => clearInterval(timer);
+        const closeAt = endsAtMs - serverOffsetMs + AUCTION_GRACE_MS;
+        const wait = Math.max(0, closeAt - Date.now());
+        // A timer holds at most 2^31 − 1 ms (about 24 days) and fires at once past that. A deadline that
+        // far away is bad data, and the old clock never closed it early either.
+        if (wait > LONGEST_TIMER_MS)
+            return;
+        const timer = setTimeout(() => dispatch({ kind: 'auctionExpired' }), wait);
+        return () => clearTimeout(timer);
     }, [biddingOpen, endsAtMs, serverOffsetMs]);
     /**
      * Giveaway state off the polled record.
@@ -397,7 +576,6 @@ function useSessionValue(props) {
      * enter a giveaway they are already in.
      */
     const activeGiveaway = (0, react_1.useMemo)(() => { var _a; return (_a = stream === null || stream === void 0 ? void 0 : stream.giveaways.find((giveaway) => giveaway.status === 'active')) !== null && _a !== void 0 ? _a : null; }, [stream]);
-    const bidderId = (_f = (_e = identity === null || identity === void 0 ? void 0 : identity.bidderId) === null || _e === void 0 ? void 0 : _e.call(identity)) !== null && _f !== void 0 ? _f : null;
     const customerRef = (_h = (_g = identity === null || identity === void 0 ? void 0 : identity.customerRef) === null || _g === void 0 ? void 0 : _g.call(identity)) !== null && _h !== void 0 ? _h : null;
     /**
      * Closes the gap between the realtime giveaway start and the polled record it depends on.
@@ -414,6 +592,7 @@ function useSessionValue(props) {
         void refreshStreamInfo();
     }, [giveawayKnown, refreshStreamInfo]);
     (0, react_1.useEffect)(() => {
+        var _a;
         if (!activeGiveaway)
             return;
         const entries = activeGiveaway.entries.filter((entry) => entry.active);
@@ -423,8 +602,37 @@ function useSessionValue(props) {
             entryCount: entries.length,
             registered: !!bidderId && entries.some((entry) => entry.userId === bidderId),
             bidderId,
+            entrantNames: activeGiveaway.entrantNames,
+            startedAtMs: (_a = activeGiveaway.startedAtMs) !== null && _a !== void 0 ? _a : null,
         });
     }, [activeGiveaway, bidderId]);
+    /**
+     * The draw's roster — ENG-705, moved here from Freckled Poppy's Live screen.
+     *
+     * `giveaway_end` names the winner and nobody else, and reaches the room before the gateway has
+     * written the entrants onto the record. When the roster latched while the lot was open is empty
+     * too, the record is asked again every 700 ms for up to 5 s; the first read with names is taken and
+     * kept (`giveawayRoster`), and running out of time lets the reveal go ahead without one.
+     */
+    const rosterWait = state.giveawayResult && !state.giveawayResult.entrantNamesReady
+        ? `${state.giveawayResult.storeProductId}\u0000${state.giveawayResult.winnerName}`
+        : null;
+    (0, react_1.useEffect)(() => {
+        if (!rosterWait)
+            return;
+        return (0, giveawayRoster_1.waitForGiveawayRoster)({
+            readRecord: () => void refreshStreamInfo(),
+            onGiveUp: () => dispatch({ kind: 'giveawayRosterTimedOut' }),
+        });
+    }, [rosterWait, refreshStreamInfo]);
+    (0, react_1.useEffect)(() => {
+        const result = state.giveawayResult;
+        if (!result || result.entrantNamesReady || !stream)
+            return;
+        const names = (0, giveawayRoster_1.rosterFromRecord)(stream.giveaways, result.storeProductId);
+        if (names.length)
+            dispatch({ kind: 'giveawayRoster', storeProductId: result.storeProductId, names });
+    }, [state.giveawayResult, stream]);
     /**
      * The poll off the RECORD, for one this device never heard open — DEL-2769.
      *
@@ -483,29 +691,93 @@ function useSessionValue(props) {
         }));
     }, [stream, state.removedStoreProductIds]);
     /**
-     * A lot the host featured that this record has never heard of.
+     * The host featured a lot (`PRODUCT_CHANGE`): read the record again, once per change.
+     *
+     * Two things live only on the record and change at exactly this moment:
      *
-     * `productChange` adds the id to the extras, so a CATALOGUE lot survives: the id goes to
-     * `productsByIds` and the storefront answers for it immediately. A LINK lot cannot — everything
-     * it has to show (name, thumbnail, URL) lives only on the stream record, which is polled on a
-     * five-minute timer. So a link lot added and featured mid-stream resolved to nothing, and
-     * `activeProduct` fell back to `products[0]` — showing the room a different product entirely.
+     * - **The lot number.** On a company with show-gated products the gateway issues `sell_id` when the
+     *   host SHOWS the lot (DEL-2885), and nothing re-reads the record mid-watch — so `sellId` stayed
+     *   null for the whole session. Freckled Poppy forced this read from its Live screen; it lives here
+     *   now, for every app.
+     * - **A link lot added mid-stream.** Its name, thumbnail and URL exist nowhere else, so without the
+     *   read it resolved to nothing and `activeProduct` fell back to a different product.
      *
-     * Re-reading the record is what makes it appear. Once per id: an id that is genuinely absent
-     * must not turn into a poll every render.
+     * Skipped when the record already lists the lot with its number: the read would bring nothing new.
      */
-    const chasedRecordFor = (0, react_1.useRef)(null);
     (0, react_1.useEffect)(() => {
+        var _a;
         const active = state.activeStoreProductId;
-        if (!active || !stream)
+        if (!active)
+            return;
+        const row = (_a = streamRef.current) === null || _a === void 0 ? void 0 : _a.products.find((product) => product.storeProductId === active);
+        if (row === null || row === void 0 ? void 0 : row.sellId)
             return;
-        if (stream.products.some((product) => product.storeProductId === active))
+        void refreshStreamInfo();
+    }, [state.activeStoreProductId, refreshStreamInfo]);
+    /**
+     * What the room said before this device arrived, put in front of the comments — once per show.
+     *
+     * Read when the show is known to be live, and dropped if the show changed while it was in flight.
+     * `mergeCommentHistory` (in the reducer) leaves out anything the room has already delivered and
+     * renames the host's stored "You" to the host.
+     */
+    const liveStreamingId = (stream === null || stream === void 0 ? void 0 : stream.status) === 'live' ? stream.streamingId : null;
+    (0, react_1.useEffect)(() => {
+        if (!liveStreamingId || react_native_1.Platform.OS === 'web')
+            return;
+        let cancelled = false;
+        liveSelling_1.liveSelling.streams
+            .commentHistory(liveStreamingId)
+            .then((history) => {
+            var _a, _b;
+            if (cancelled || !history.length)
+                return;
+            dispatch({
+                kind: 'commentHistory',
+                history,
+                hostName: (_b = (_a = streamRef.current) === null || _a === void 0 ? void 0 : _a.hostName) !== null && _b !== void 0 ? _b : null,
+                ownName: namedByRef.current,
+            });
+        })
+            .catch((caught) => logger.error(caught, { at: 'liveSession.commentHistory', streamingId: liveStreamingId }));
+        return () => {
+            cancelled = true;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [liveStreamingId]);
+    /**
+     * The pinned comment, off the RECORD — for arrival, and for every reconnect.
+     *
+     * The room's `PINNED_COMMENT_CHANGED` reaches the reducer directly and wins until the record's own
+     * pin changes. Dispatched only when the record's pin CHANGES (keyed with the show), so a read
+     * taken before an unpin cannot bring the old pin back — the same precedence the record's poll has.
+     *
+     * A broadcast sent while the room was down never arrives, so a reconnect re-reads the record and
+     * the first record after it is taken whatever it says. Joining counts as a reconnect, so arriving
+     * costs one extra read.
+     */
+    const recordPin = (_j = stream === null || stream === void 0 ? void 0 : stream.pinnedComment) !== null && _j !== void 0 ? _j : null;
+    const recordPinKey = `${watching !== null && watching !== void 0 ? watching : ''}\u0000${(_k = recordPin === null || recordPin === void 0 ? void 0 : recordPin.id) !== null && _k !== void 0 ? _k : ''}\u0000${(_l = recordPin === null || recordPin === void 0 ? void 0 : recordPin.text) !== null && _l !== void 0 ? _l : ''}`;
+    const lastRecordPinKey = (0, react_1.useRef)(null);
+    const takeNextRecordPin = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(() => {
+        if (!stream)
             return;
-        if (chasedRecordFor.current === active)
+        if (recordPinKey === lastRecordPinKey.current && !takeNextRecordPin.current)
             return;
-        chasedRecordFor.current = active;
-        refreshStreamInfo();
-    }, [state.activeStoreProductId, stream, refreshStreamInfo]);
+        lastRecordPinKey.current = recordPinKey;
+        takeNextRecordPin.current = false;
+        dispatch({ kind: 'pinnedCommentSynced', comment: recordPin });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [stream, recordPinKey]);
+    const wasConnected = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(() => {
+        if (state.connected && !wasConnected.current) {
+            takeNextRecordPin.current = true;
+            void refreshStreamInfo();
+        }
+        wasConnected.current = state.connected;
+    }, [state.connected, refreshStreamInfo]);
     /**
      * Resolved through the commerce adapter, keyed on the joined ids so a mid-stream product add
      * refetches and an unchanged set does not. Link lots are held out: they have no id the catalogue
@@ -559,27 +831,15 @@ function useSessionValue(props) {
             return ordered;
         };
         /*
-         * Sell codes live on the stream record, not in the catalogue — the commerce adapter is asked for
-         * products by id and has no idea a lot carries one. Joined on here so a call site reads
-         * `product.sellId` instead of holding both lists and matching them itself.
+         * Sell codes and opening bids live on the stream record, not in the catalogue — the commerce
+         * adapter is asked for products by id and has no idea a lot carries either. Joined on here so a
+         * call site reads `product.sellId` and `product.baseBidPrice` instead of holding both lists and
+         * matching them itself (`withLotFieldsFromRecord`; the opening bid since 0.9.0).
          *
-         * A new array only when at least one code exists, so an app on a gateway that issues none keeps
-         * the adapter's own objects and the identity the memo already promised.
+         * A new array only when the record has either for some lot, so an app on a gateway that issues
+         * none keeps the adapter's own objects and the identity the memo already promised.
          */
-        const base = merge();
-        const codes = new Map();
-        for (const row of (_a = stream === null || stream === void 0 ? void 0 : stream.products) !== null && _a !== void 0 ? _a : []) {
-            if (row.sellId)
-                codes.set(row.storeProductId, row.sellId);
-        }
-        if (!codes.size)
-            return base;
-        return base.map((product) => {
-            var _a;
-            return codes.has(product.storeProductId)
-                ? { ...product, sellId: (_a = codes.get(product.storeProductId)) !== null && _a !== void 0 ? _a : null }
-                : product;
-        });
+        return (0, showLots_1.withLotFieldsFromRecord)(merge(), (_a = stream === null || stream === void 0 ? void 0 : stream.products) !== null && _a !== void 0 ? _a : []);
     }, [catalogueProducts, externalProducts, storeProductIds, stream]);
     const activeProduct = (0, react_1.useMemo)(() => {
         var _a, _b, _c, _d, _e, _f;
@@ -607,11 +867,10 @@ function useSessionValue(props) {
             return null;
         return (_f = products[0]) !== null && _f !== void 0 ? _f : null;
     }, [products, state.activeStoreProductId, stream]);
-    const multiplier = (_k = (_j = state.multiplierOverride) !== null && _j !== void 0 ? _j : stream === null || stream === void 0 ? void 0 : stream.viewerMultiplier) !== null && _k !== void 0 ? _k : 1;
+    const multiplier = (_o = (_m = state.multiplierOverride) !== null && _m !== void 0 ? _m : stream === null || stream === void 0 ? void 0 : stream.viewerMultiplier) !== null && _o !== void 0 ? _o : 1;
     /* Same precedence as the multiplier: the host's live word wins, the record stands until they
        give one. Both fall back rather than throw, so a stream row missing `meta` still renders. */
-    const reactionStyle = (_m = (_l = state.reactionModeOverride) !== null && _l !== void 0 ? _l : stream === null || stream === void 0 ? void 0 : stream.reactionStyle) !== null && _m !== void 0 ? _m : 'single';
-    const elapsedMs = (stream === null || stream === void 0 ? void 0 : stream.startedAtMs) ? Math.max(0, now - stream.startedAtMs) : 0;
+    const reactionStyle = (_q = (_p = state.reactionModeOverride) !== null && _p !== void 0 ? _p : stream === null || stream === void 0 ? void 0 : stream.reactionStyle) !== null && _q !== void 0 ? _q : 'single';
     /**
      * Percentages come off the raw counts, so the multiplier cannot skew them — it inflates only the
      * total on display, exactly as the host's own dashboard does.
@@ -689,27 +948,28 @@ function useSessionValue(props) {
             alive = false;
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [(_o = state.poll) === null || _o === void 0 ? void 0 : _o.pollUuid]);
+    }, [(_r = state.poll) === null || _r === void 0 ? void 0 : _r.pollUuid]);
     const bindVideoView = (0, react_1.useCallback)((reactTag, force = false) => {
+        // Stopped because the app is away: a claim now would start it behind the app, with sound. The
+        // surface claims again once the app is back (`LiveVideoTarget`'s foreground re-claim).
+        if (stoppedWhileAwayRef.current)
+            return;
         liveSelling_1.liveSelling.engine
             .bindView(reactTag, force)
             .catch((caught) => (0, client_1.getLogger)().error(caught, { at: 'liveSession.bindView' }));
     }, []);
+    /**
+     * Sends now — or, for a signed-in shopper whose name has not loaded, holds it until the name lands
+     * (L6) and resolves once it has gone out. See `HeldComments`.
+     */
     const sendComment = (0, react_1.useCallback)(async (text, options) => {
-        var _a;
         if (!text.trim())
             return;
-        try {
-            // The host mutes by device; a per-install viewer id is the same granularity.
-            const deviceId = (_a = viewerIdRef.current) !== null && _a !== void 0 ? _a : (await liveSelling_1.liveSelling.viewer.id());
-            const own = await liveSelling_1.liveSelling.engine.sendComment(text, deviceId, options);
-            if (own)
-                dispatch({ kind: 'ownComment', comment: own });
-        }
-        catch (caught) {
-            (0, client_1.getLogger)().error(caught, { at: 'liveSession.sendComment' });
-        }
-    }, []);
+        const held = heldCommentsRef.current;
+        if (nameResolvingRef.current && held)
+            return held.hold({ text, options });
+        await deliverComment(text, options);
+    }, [deliverComment]);
     const sendReaction = (0, react_1.useCallback)(async (reactionUrl) => {
         try {
             await liveSelling_1.liveSelling.engine.sendReaction(reactionUrl);
@@ -820,10 +1080,22 @@ function useSessionValue(props) {
             .bindGuestHostView(reactTag)
             .catch((caught) => (0, client_1.getLogger)().error(caught, { at: 'liveSession.bindGuestHostView' }));
     }, []);
+    /**
+     * Saves the name and gives it to the engine NOW, not in the effect (L6).
+     *
+     * The caller's next line is the comment that prompted for the name. The effect that pushes the name
+     * belongs to this provider, a parent of that caller, and React runs parents' effects after
+     * children's — so the comment went out under the join-time name, usually "Anonymous", into the
+     * room and the stored history. Freckled Poppy set the engine's name itself to get round it. A name
+     * passed as the `viewerName` prop still wins, as it does everywhere else.
+     */
     const chooseViewerName = (0, react_1.useCallback)(async (raw) => {
+        var _a;
         const saved = await liveSelling_1.liveSelling.viewer.saveName(raw);
-        if (saved)
+        if (saved) {
+            liveSelling_1.liveSelling.engine.setViewerName((_a = accountNameRef.current) !== null && _a !== void 0 ? _a : saved);
             setChosenName(saved);
+        }
         return saved;
     }, []);
     /** The speaker button, and nothing else. See `setOutputMuted` below for the other half. */
@@ -922,38 +1194,51 @@ function useSessionValue(props) {
      * into a cart. It is also what comes back on the host's broadcast, so `isLeading` compares like
      * with like. Null when signed out, which is exactly when bidding is not offered.
      */
-    const bidderEmail = (_q = (_p = identity === null || identity === void 0 ? void 0 : identity.customerEmail) === null || _p === void 0 ? void 0 : _p.call(identity)) !== null && _q !== void 0 ? _q : null;
+    const bidderEmail = (_t = (_s = identity === null || identity === void 0 ? void 0 : identity.customerEmail) === null || _s === void 0 ? void 0 : _s.call(identity)) !== null && _t !== void 0 ? _t : null;
     const bidder = (0, react_1.useMemo)(() => (bidderId ? { userId: bidderId, userName: viewerName, email: bidderEmail } : null), [bidderId, viewerName, bidderEmail]);
+    /**
+     * The hammer, with whether it is this shopper's (0.9.0): they led the round as it closed and the
+     * winning bid is theirs (`isYourWin`). Its own memo, so it is a new object only when the win, the
+     * round's last leader or the bidder change, never on a comment.
+     */
+    const lastWin = (0, react_1.useMemo)(() => state.lastWin
+        ? { ...state.lastWin, isYou: (0, auctionRules_1.isYourWin)(state.lastWin, state.leaderWhenRoundClosed, bidderId) }
+        : null, [state.lastWin, state.leaderWhenRoundClosed, bidderId]);
     const auction = (0, react_1.useMemo)(() => {
         var _a, _b, _c, _d, _e, _f, _g;
-        // Falls back to the lot's opening price: until the first bid lands the host sends no next bid,
-        // and a slide-to-bid showing zero is worse than useless.
-        const nextBid = state.nextBid || (biddingLot === null || biddingLot === void 0 ? void 0 : biddingLot.baseBidPrice) || 0;
+        // Falls back to the lot's opening bid, else its bid step, else the show's (`openingBidFor`): until
+        // the first bid lands the host sends no next bid, and a slide-to-bid showing zero is worse than useless.
+        const nextBid = state.nextBid || (0, auctionRules_1.openingBidFor)(biddingLot, stream);
         return {
             biddingOpen: state.biddingOpen,
             highestBid: state.highestBid,
             nextBid,
-            timeLeftMs: (0, session_1.timeLeftMs)(state, auctionNow),
+            // A moment, not a countdown: it changes only when the host moves the deadline, so the session
+            // never ticks. A component counts down to it itself (`useAuctionCountdown`).
+            closesAt: (0, session_1.roundClosesAt)(state),
             isLeading: !!bidder && ((_a = state.bidLeader) === null || _a === void 0 ? void 0 : _a.userId) === bidder.userId,
             leaderName: (_c = (_b = state.bidLeader) === null || _b === void 0 ? void 0 : _b.userName) !== null && _c !== void 0 ? _c : null,
             extended: state.auctionExtended,
             storeProductId: (_e = (_d = state.biddingStoreProductId) !== null && _d !== void 0 ? _d : biddingLot === null || biddingLot === void 0 ? void 0 : biddingLot.storeProductId) !== null && _e !== void 0 ? _e : null,
-            lastWin: state.lastWin,
+            lastWin,
             bidCap: (_f = stream === null || stream === void 0 ? void 0 : stream.bidCap) !== null && _f !== void 0 ? _f : null,
             extendedBiddingMs: (_g = stream === null || stream === void 0 ? void 0 : stream.extendedBiddingMs) !== null && _g !== void 0 ? _g : 0,
+            wonLotIds: state.wonLotIds,
         };
-    }, [state, auctionNow, biddingLot, bidder, stream]);
+    }, [state, biddingLot, bidder, stream, lastWin]);
     const giveaway = (0, react_1.useMemo)(() => {
-        var _a, _b;
-        const result = state.giveawayResult;
-        // Entrant names come off the record's roster rather than the event, which carries only the
-        // winner. A draw the record has not caught up with still celebrates, with fewer names in it.
-        const settled = result
-            ? stream === null || stream === void 0 ? void 0 : stream.giveaways.find((item) => item.storeProductId === result.storeProductId && item.status === 'ended')
-            : undefined;
+        const drawn = state.giveawayResult;
+        /**
+         * The draw, with this shopper's part in it (0.9.0): whether they had entered (kept past the draw,
+         * as `registered` goes when it lands) and whether they won: by the customer id the record names on
+         * this draw's giveaway when a read has it, else by name among those who entered.
+         */
+        const youEntered = !!drawn && !!bidderId && drawn.enteredBy === bidderId;
+        const winnerId = drawn && stream ? (0, giveawayRoster_1.winnerIdFromRecord)(stream.giveaways, drawn.storeProductId, drawn.startedAtMs) : null;
         return {
-            active: state.giveawayStoreProductId
-                ? ((_a = stream === null || stream === void 0 ? void 0 : stream.giveaways.find((item) => item.storeProductId === state.giveawayStoreProductId)) !== null && _a !== void 0 ? _a : null)
+            // The open giveaway for the lot, not an earlier one of the same product (`giveawayForLot`).
+            active: state.giveawayStoreProductId && stream
+                ? (0, giveawayRoster_1.giveawayForLot)(stream.giveaways, state.giveawayStoreProductId)
                 : null,
             // Inflated by the host's multiplier, exactly as `viewerCount` and poll totals are. State keeps
             // the raw count; only the read out of the session multiplies.
@@ -964,8 +1249,21 @@ function useSessionValue(props) {
              * still active and a re-render to fire.
              */
             registered: !!bidderId && state.giveawayRegisteredBy === bidderId,
-            result: result
-                ? { winnerName: result.winnerName, entrantNames: (_b = settled === null || settled === void 0 ? void 0 : settled.entrantNames) !== null && _b !== void 0 ? _b : [] }
+            /* The roster is held in the reducer once known, so a later read cannot change it mid-reveal. */
+            result: drawn
+                ? {
+                    winnerName: drawn.winnerName,
+                    entrantNames: drawn.entrantNames,
+                    entrantNamesReady: drawn.entrantNamesReady,
+                    youEntered,
+                    isYou: (0, giveawayRoster_1.isYourGiveawayWin)({
+                        winnerId,
+                        winnerName: drawn.winnerName,
+                        youEntered,
+                        bidderId,
+                        viewerName: namedBy,
+                    }),
+                }
                 : null,
         };
     }, [
@@ -976,6 +1274,7 @@ function useSessionValue(props) {
         state.giveawayResult,
         stream,
         multiplier,
+        namedBy,
     ]);
     /**
      * The round, the stream and the bidder, for the actions to read when they fire.
@@ -1012,11 +1311,13 @@ function useSessionValue(props) {
         const round = roundRef.current;
         const current = streamRef.current;
         const who = bidderRef.current;
-        if (!current || !who)
-            return;
+        if (!current)
+            return { sent: false, reason: 'noShow' };
+        if (!who)
+            return { sent: false, reason: 'signedOut' };
         const amount = (_a = options === null || options === void 0 ? void 0 : options.amount) !== null && _a !== void 0 ? _a : round.auction.nextBid;
         if (!amount || amount <= 0)
-            return;
+            return { sent: false, reason: 'noAmount' };
         /**
          * The lot's only variant, for a bid that names none.
          *
@@ -1033,6 +1334,20 @@ function useSessionValue(props) {
          */
         const lot = productsRef.current.find((product) => product.storeProductId === round.auction.storeProductId);
         const soleVariantId = (lot === null || lot === void 0 ? void 0 : lot.variants.length) === 1 ? ((_c = (_b = lot.variants[0]) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : null) : null;
+        /**
+         * No moderator, no bid (L3). Bids go to the moderator in charge and to nobody else, and a viewer
+         * who missed the round's opening may not know one — see `lastModeratorId`. Said rather than
+         * swallowed, and the ledger is left alone: before 0.9.0 the REST record still went out, for a bid
+         * that never entered the round.
+         */
+        if (!round.moderatorId) {
+            (0, client_1.logWarning)(new Error('No moderator is known for this round, so the bid was not sent'), {
+                at: 'liveSession.placeBid',
+                amount,
+            });
+            return { sent: false, reason: 'noModerator' };
+        }
+        let result = { sent: true };
         try {
             await liveSelling_1.liveSelling.engine.sendBid({
                 bidAmount: amount,
@@ -1046,6 +1361,7 @@ function useSessionValue(props) {
         }
         catch (caught) {
             (0, client_1.getLogger)().error(caught, { at: 'liveSession.placeBid', amount });
+            result = { sent: false, reason: 'sendFailed' };
         }
         try {
             await liveSelling_1.liveSelling.auctions.recordBid({
@@ -1059,14 +1375,17 @@ function useSessionValue(props) {
         catch (caught) {
             (0, client_1.getLogger)().error(caught, { at: 'liveSession.recordBid', amount });
         }
+        return result;
     }, []);
     const enterGiveaway = (0, react_1.useCallback)(async (cartId) => {
         var _a, _b, _c;
         const lot = giveawayLotRef.current;
         const current = streamRef.current;
         const customer = customerRefRef.current;
-        if (!current || !lot || !customer)
-            return;
+        if (!current || !lot)
+            return { entered: false, reason: 'noGiveaway' };
+        if (!customer)
+            return { entered: false, reason: 'signedOut' };
         try {
             const viewerId = (_a = viewerIdRef.current) !== null && _a !== void 0 ? _a : (await liveSelling_1.liveSelling.viewer.id());
             const entered = await liveSelling_1.liveSelling.auctions.enterGiveaway({
@@ -1079,11 +1398,14 @@ function useSessionValue(props) {
             });
             // Only on the host's confirmation. The entry count follows from its own push, so nothing here
             // guesses at it.
-            if (entered)
-                dispatch({ kind: 'giveawayRegistered', bidderId: (_c = (_b = bidderRef.current) === null || _b === void 0 ? void 0 : _b.userId) !== null && _c !== void 0 ? _c : null });
+            if (!entered)
+                return { entered: false, reason: 'refused' };
+            dispatch({ kind: 'giveawayRegistered', bidderId: (_c = (_b = bidderRef.current) === null || _b === void 0 ? void 0 : _b.userId) !== null && _c !== void 0 ? _c : null });
+            return { entered: true };
         }
         catch (caught) {
             (0, client_1.getLogger)().error(caught, { at: 'liveSession.enterGiveaway' });
+            return { entered: false, reason: 'failed' };
         }
     }, []);
     const dismissAuctionWin = (0, react_1.useCallback)(() => dispatch({ kind: 'dismissWin' }), []);
@@ -1140,10 +1462,35 @@ function useSessionValue(props) {
         dismissAuctionWin,
         dismissGiveawayResult,
     ]);
-    return {
+    const guest = (0, react_1.useMemo)(() => ({
+        mode: state.guestMode,
+        status: state.guestStatus,
+        slot: state.guestSlot,
+        mutedByHost: state.guestMutedByHost,
+        cameraOffByHost: state.guestCameraOffByHost,
+        mixerLayout: state.mixerLayout,
+    }), [
+        state.guestMode,
+        state.guestStatus,
+        state.guestSlot,
+        state.guestMutedByHost,
+        state.guestCameraOffByHost,
+        state.mixerLayout,
+    ]);
+    const viewerCount = Math.round(state.rawViewerCount * multiplier);
+    const pinnedComment = status === 'ended' ? null : state.pinnedComment;
+    /**
+     * The same object until one of its fields changes.
+     *
+     * Every component that reads the session is drawn again when this object changes, and the session is
+     * app-wide. Built fresh on every render, it changed whenever the provider was drawn for any reason —
+     * its parent passing the same props again, a record read that changed nothing a reader sees — and
+     * drew every reader with it. Field by field, so a new object means something in it is new.
+     */
+    return (0, react_1.useMemo)(() => ({
         status,
         stream: stream !== null && stream !== void 0 ? stream : null,
-        viewerCount: Math.round(state.rawViewerCount * multiplier),
+        viewerCount,
         rawViewerCount: state.rawViewerCount,
         reactionStyle,
         comments: state.comments,
@@ -1154,23 +1501,39 @@ function useSessionValue(props) {
         reactions: state.reactions,
         poll,
         viewerName: namedBy,
-        guest: {
-            mode: state.guestMode,
-            status: state.guestStatus,
-            slot: state.guestSlot,
-            mutedByHost: state.guestMutedByHost,
-            cameraOffByHost: state.guestCameraOffByHost,
-            mixerLayout: state.mixerLayout,
-        },
+        guest,
         muted,
         videoTag: state.videoTag,
-        elapsedMs,
         pipMode,
         auction,
         giveaway,
+        pinnedComment,
         error,
         actions,
-    };
+    }), [
+        status,
+        stream,
+        viewerCount,
+        state.rawViewerCount,
+        reactionStyle,
+        state.comments,
+        activeProduct,
+        products,
+        state.sold,
+        state.cartAnnouncements,
+        state.reactions,
+        poll,
+        namedBy,
+        guest,
+        muted,
+        state.videoTag,
+        pipMode,
+        auction,
+        giveaway,
+        pinnedComment,
+        error,
+        actions,
+    ]);
 }
 /**
  * Holds one live session for the whole app. Nothing is joined while no stream is live, so the engine
@@ -1198,18 +1561,20 @@ function LiveSessionProvider({ children, ...props }) {
        the video — see the note on `actions` in `useSessionValue`. */
     const watchedRef = (0, react_1.useRef)(undefined);
     watchedRef.current = (_d = (_c = props.streamingId) !== null && _c !== void 0 ? _c : heldId) !== null && _d !== void 0 ? _d : (_e = session.stream) === null || _e === void 0 ? void 0 : _e.streamingId;
-    const holdStream = (0, react_1.useCallback)(() => {
-        /* Nothing to pin yet — the caller retries when a stream id arrives, so a player opened before
-           the read resolved is not left following whatever turns up next. */
-        const id = watchedRef.current;
+    const holdStream = (0, react_1.useCallback)((streamingId) => {
+        /* A named show wins over whatever is on screen — see `holdStream` in `LiveSessionActions`. With
+           none named and nothing to pin yet, the caller retries when a stream id arrives, so a player
+           opened before the read resolved is not left following whatever turns up next. */
+        const id = streamingId || watchedRef.current;
         if (id)
             setHeldId(id);
     }, []);
     const releaseStream = (0, react_1.useCallback)(() => setHeldId(null), []);
-    /* Two memos, and the split matters: `session` is a fresh object every render, so folding the
-       actions into the same one would rebuild `actions` every render too — the exact thing the note in
+    /* Two memos, and the split matters: `session` changes with every event, so folding the actions into
+       the same one would rebuild `actions` on every event too — the exact thing the note in
        `useSessionValue` warns about, and it live-locks a player that calls `holdStream` from an effect
-       keyed on `actions`. `session.actions` is stable, so keyed on that this one is as well. */
+       keyed on `actions`. `session.actions` is stable, so keyed on that this one is as well. `session`
+       is the same object while nothing in it changed, so `value` is too: no reader is drawn for nothing. */
     const actions = (0, react_1.useMemo)(() => ({ ...session.actions, holdStream, releaseStream }), [session.actions, holdStream, releaseStream]);
     const value = (0, react_1.useMemo)(() => ({ ...session, actions }), [session, actions]);
     return (0, react_1.createElement)(LiveSessionContext.Provider, { value }, children);