@darajs/core 1.29.6 → 1.29.8

package/dist/shared/interactivity/polling.js

@@ -0,0 +1,723 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Poller_instances, _Poller_clearTimeout, _Poller_entries, _Poller_getVisibilityState, _Poller_jitterRatio, _Poller_now, _Poller_random, _Poller_setTimeout, _Poller_visibilityTarget, _Poller_owners, _Poller_listeningForVisibility, _Poller_start, _Poller_createRunHandle, _Poller_runWork, _Poller_finishRun, _Poller_waitForNewer, _Poller_getIntervalMs, _Poller_getOrCreateEntry, _Poller_getSubscriber, _Poller_getOrCreateOwner, _Poller_dropOwnedKey, _Poller_dropOwner, _Poller_hasClaimForKey, _Poller_hasHookForKey, _Poller_ownerHasKey, _Poller_schedulePoll, _Poller_schedule, _Poller_clearTimer, _Poller_withJitter, _Poller_handleVisibilityChange, _Poller_startVisibilityListener, _Poller_stopVisibilityListenerIfIdle;
+import { useEffect, useId, useLayoutEffect } from 'react';
+import { useLatestRef } from '@darajs/ui-utils';
+const DEFAULT_JITTER_RATIO = 0.1;
+const MAX_BACKOFF_MS = 60000;
+const POLL_FORCE_KEY_PREFIX = '__dara_poll__:';
+const retryAfterByError = new WeakMap();
+/** Throw an AbortError when an old run attempts to publish a result. */
+function assertCurrentRun(handle) {
+    if (!handle.isCurrent() || handle.signal.aborted) {
+        throw new DOMException('The request was superseded', 'AbortError');
+    }
+}
+/** Check whether an error represents intentional request cancellation. */
+export function isAbortError(error) {
+    return ((error instanceof DOMException && error.name === 'AbortError') ||
+        (typeof error === 'object' && error !== null && 'name' in error && error.name === 'AbortError'));
+}
+/** Read Retry-After saved at the HTTP response seam. */
+function getRetryAfterMs(error) {
+    return typeof error === 'object' && error !== null ? retryAfterByError.get(error) : undefined;
+}
+/**
+ * Coordinates non-overlapping, fixed-delay polling for request identities.
+ *
+ * A request identity includes the rendered variable/component identity and its
+ * serialized request extras. Multiple React consumers of the same identity
+ * share one timer and one active request generation.
+ */
+export class Poller {
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        _Poller_instances.add(this);
+        _Poller_clearTimeout.set(this, void 0);
+        _Poller_entries.set(this, new Map());
+        _Poller_getVisibilityState.set(this, void 0);
+        _Poller_jitterRatio.set(this, void 0);
+        _Poller_now.set(this, void 0);
+        _Poller_random.set(this, void 0);
+        _Poller_setTimeout.set(this, void 0);
+        _Poller_visibilityTarget.set(this, void 0);
+        _Poller_owners.set(this, new Map());
+        _Poller_listeningForVisibility.set(this, false);
+        _Poller_handleVisibilityChange.set(this, () => {
+            var _a;
+            const hidden = __classPrivateFieldGet(this, _Poller_getVisibilityState, "f").call(this) === 'hidden';
+            for (const [key, entry] of __classPrivateFieldGet(this, _Poller_entries, "f")) {
+                if (hidden) {
+                    entry.runOnShow = entry.subscribers.size > 0;
+                    if (entry.timer !== undefined) {
+                        __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_clearTimer).call(this, entry, entry.failureCount === 0);
+                    }
+                    continue;
+                }
+                if (!entry.runOnShow || entry.subscribers.size === 0) {
+                    continue;
+                }
+                entry.runOnShow = false;
+                const delay = Math.max(0, ((_a = entry.nextRunAt) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _Poller_now, "f").call(this)) - __classPrivateFieldGet(this, _Poller_now, "f").call(this));
+                if (delay > 0) {
+                    __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_schedule).call(this, key, entry, delay);
+                }
+                else {
+                    this.runNow(key);
+                }
+            }
+        });
+        __classPrivateFieldSet(this, _Poller_clearTimeout, (_a = options.clearTimeout) !== null && _a !== void 0 ? _a : ((timer) => clearTimeout(timer)), "f");
+        __classPrivateFieldSet(this, _Poller_getVisibilityState, (_b = options.getVisibilityState) !== null && _b !== void 0 ? _b : (() => (typeof document === 'undefined' ? 'visible' : document.visibilityState)), "f");
+        __classPrivateFieldSet(this, _Poller_jitterRatio, (_c = options.jitterRatio) !== null && _c !== void 0 ? _c : DEFAULT_JITTER_RATIO, "f");
+        __classPrivateFieldSet(this, _Poller_now, (_d = options.now) !== null && _d !== void 0 ? _d : (() => Date.now()), "f");
+        __classPrivateFieldSet(this, _Poller_random, (_e = options.random) !== null && _e !== void 0 ? _e : (() => Math.random()), "f");
+        __classPrivateFieldSet(this, _Poller_setTimeout, (_f = options.setTimeout) !== null && _f !== void 0 ? _f : ((callback, delay) => setTimeout(callback, delay)), "f");
+        __classPrivateFieldSet(this, _Poller_visibilityTarget, (_g = options.visibilityTarget) !== null && _g !== void 0 ? _g : (typeof document === 'undefined' ? undefined : document), "f");
+    }
+    /**
+     * Register one rendered polling consumer.
+     *
+     * The returned cleanup releases the consumer. The final cleanup aborts the
+     * owned request on the next macrotask so React StrictMode can immediately
+     * reacquire the same identity without cancelling useful work.
+     */
+    subscribe(key, intervalSeconds, refresh) {
+        var _a;
+        const intervalMs = (intervalSeconds !== null && intervalSeconds !== void 0 ? intervalSeconds : 0) * 1000;
+        if (!Number.isFinite(intervalMs) || !(intervalMs > 0)) {
+            return () => { };
+        }
+        const entry = __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getOrCreateEntry).call(this, key);
+        const oldIntervalMs = entry.subscribers.size > 0 ? __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getIntervalMs).call(this, entry) : undefined;
+        if (entry.disposeTimer !== undefined) {
+            __classPrivateFieldGet(this, _Poller_clearTimeout, "f").call(this, entry.disposeTimer);
+            entry.disposeTimer = undefined;
+        }
+        const subscriberId = Symbol(key);
+        entry.subscribers.set(subscriberId, { intervalMs, refresh });
+        __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_startVisibilityListener).call(this);
+        if (entry.subscribers.size === 1 && entry.state.kind === 'idle' && entry.timer === undefined) {
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_schedulePoll).call(this, key, entry);
+        }
+        else if (entry.timer !== undefined &&
+            entry.failureCount === 0 &&
+            oldIntervalMs !== undefined &&
+            intervalMs < oldIntervalMs) {
+            const remaining = Math.max(0, ((_a = entry.nextRunAt) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _Poller_now, "f").call(this)) - __classPrivateFieldGet(this, _Poller_now, "f").call(this));
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_schedule).call(this, key, entry, Math.min(remaining, __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_withJitter).call(this, intervalMs)));
+        }
+        return () => {
+            const removedIntervalMs = __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getIntervalMs).call(this, entry);
+            entry.subscribers.delete(subscriberId);
+            if (entry.subscribers.size > 0) {
+                if (entry.timer !== undefined &&
+                    entry.failureCount === 0 &&
+                    __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getIntervalMs).call(this, entry) > removedIntervalMs) {
+                    __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_schedulePoll).call(this, key, entry);
+                }
+                return;
+            }
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_clearTimer).call(this, entry);
+            entry.disposeTimer = __classPrivateFieldGet(this, _Poller_setTimeout, "f").call(this, () => {
+                var _a, _b;
+                entry.disposeTimer = undefined;
+                if (entry.subscribers.size > 0) {
+                    return;
+                }
+                if (entry.owners.size > 0) {
+                    return;
+                }
+                if (__classPrivateFieldGet(this, _Poller_entries, "f").get(key) !== entry) {
+                    return;
+                }
+                if (entry.state.kind === 'running') {
+                    entry.state.run.controller.abort();
+                    (_b = (_a = entry.state.run).detachExternalSignal) === null || _b === void 0 ? void 0 : _b.call(_a);
+                    entry.state.run.end();
+                }
+                __classPrivateFieldGet(this, _Poller_entries, "f").delete(key);
+                __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_stopVisibilityListenerIfIdle).call(this);
+            }, 0);
+        };
+    }
+    /**
+     * Claim a key during render so Suspense cannot skip its ownership effect.
+     *
+     * A later owner commit prunes claims left by an abandoned render.
+     */
+    claimKey(ownerId, hookId, key) {
+        const owner = __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getOrCreateOwner).call(this, ownerId);
+        if (owner.hooks.get(hookId) === key) {
+            return;
+        }
+        const oldKey = owner.claims.get(hookId);
+        owner.claims.set(hookId, key);
+        __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getOrCreateEntry).call(this, key).owners.add(ownerId);
+        if (oldKey !== undefined && oldKey !== key && !__classPrivateFieldGet(this, _Poller_instances, "m", _Poller_ownerHasKey).call(this, owner, oldKey)) {
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_dropOwnedKey).call(this, ownerId, oldKey);
+        }
+    }
+    /** Apply the hook claims collected by one committed owner render. */
+    commitOwner(ownerId, claims) {
+        const owner = __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getOrCreateOwner).call(this, ownerId);
+        if (owner.disposeTimer !== undefined) {
+            __classPrivateFieldGet(this, _Poller_clearTimeout, "f").call(this, owner.disposeTimer);
+            owner.disposeTimer = undefined;
+        }
+        const droppedClaims = new Set();
+        for (const [hookId, key] of owner.claims) {
+            if (claims.get(hookId) !== key) {
+                owner.claims.delete(hookId);
+                droppedClaims.add(key);
+            }
+        }
+        // Add the new render before dropping the old one. A rerender must not
+        // leave a live request without an owner between layout effects.
+        const nextRenderKeys = new Set();
+        for (const key of new Set(claims.values())) {
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getOrCreateEntry).call(this, key).owners.add(ownerId);
+            if (!__classPrivateFieldGet(this, _Poller_instances, "m", _Poller_hasHookForKey).call(this, owner, key) && !__classPrivateFieldGet(this, _Poller_instances, "m", _Poller_hasClaimForKey).call(this, owner, key)) {
+                nextRenderKeys.add(key);
+            }
+        }
+        const oldRenderKeys = owner.renderKeys;
+        owner.renderKeys = nextRenderKeys;
+        for (const key of oldRenderKeys) {
+            if (!nextRenderKeys.has(key) && !__classPrivateFieldGet(this, _Poller_instances, "m", _Poller_hasHookForKey).call(this, owner, key)) {
+                __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_dropOwnedKey).call(this, ownerId, key);
+            }
+        }
+        for (const key of droppedClaims) {
+            if (!__classPrivateFieldGet(this, _Poller_instances, "m", _Poller_ownerHasKey).call(this, owner, key)) {
+                __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_dropOwnedKey).call(this, ownerId, key);
+            }
+        }
+    }
+    /** Keep one key after its hook commits. */
+    mountKey(ownerId, hookId, key) {
+        const owner = __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getOrCreateOwner).call(this, ownerId);
+        if (owner.disposeTimer !== undefined) {
+            __classPrivateFieldGet(this, _Poller_clearTimeout, "f").call(this, owner.disposeTimer);
+            owner.disposeTimer = undefined;
+        }
+        const timer = owner.timers.get(hookId);
+        if (timer !== undefined) {
+            __classPrivateFieldGet(this, _Poller_clearTimeout, "f").call(this, timer);
+            owner.timers.delete(hookId);
+        }
+        const oldKey = owner.hooks.get(hookId);
+        owner.hooks.set(hookId, key);
+        owner.claims.delete(hookId);
+        owner.renderKeys.delete(key);
+        __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getOrCreateEntry).call(this, key).owners.add(ownerId);
+        if (oldKey !== undefined && oldKey !== key && !__classPrivateFieldGet(this, _Poller_instances, "m", _Poller_ownerHasKey).call(this, owner, oldKey)) {
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_dropOwnedKey).call(this, ownerId, oldKey);
+        }
+    }
+    /** Drop a committed hook key after the StrictMode remount window. */
+    unmountKey(ownerId, hookId, key) {
+        const owner = __classPrivateFieldGet(this, _Poller_owners, "f").get(ownerId);
+        if (!owner || owner.timers.has(hookId)) {
+            return;
+        }
+        const timer = __classPrivateFieldGet(this, _Poller_setTimeout, "f").call(this, () => {
+            owner.timers.delete(hookId);
+            if (owner.hooks.get(hookId) !== key) {
+                return;
+            }
+            owner.hooks.delete(hookId);
+            if (!__classPrivateFieldGet(this, _Poller_instances, "m", _Poller_ownerHasKey).call(this, owner, key)) {
+                __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_dropOwnedKey).call(this, ownerId, key);
+            }
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_stopVisibilityListenerIfIdle).call(this);
+        }, 0);
+        owner.timers.set(hookId, timer);
+    }
+    /** Release a rendered owner after the StrictMode remount window. */
+    releaseOwner(ownerId) {
+        const owner = __classPrivateFieldGet(this, _Poller_owners, "f").get(ownerId);
+        if (!owner || owner.disposeTimer !== undefined) {
+            return;
+        }
+        owner.disposeTimer = __classPrivateFieldGet(this, _Poller_setTimeout, "f").call(this, () => __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_dropOwner).call(this, ownerId, owner), 0);
+    }
+    /**
+     * Run one request for a polling identity.
+     *
+     * Matching callers share one promise. Dependency runs replace older work,
+     * while a poll that arrives during a run leaves one follow-up refresh.
+     */
+    run({ cause, inputKey, key, read, signal, work, write }) {
+        var _a;
+        const entry = __classPrivateFieldGet(this, _Poller_entries, "f").get(key);
+        const running = (entry === null || entry === void 0 ? void 0 : entry.state.kind) === 'running' ? entry.state.run : undefined;
+        if ((running === null || running === void 0 ? void 0 : running.cause) === cause && running.inputKey === inputKey && running.result) {
+            return running.result;
+        }
+        const handle = __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_start).call(this, key, cause, signal, inputKey);
+        const result = __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_runWork).call(this, { cause, handle, read, work, write });
+        const state = (_a = __classPrivateFieldGet(this, _Poller_entries, "f").get(key)) === null || _a === void 0 ? void 0 : _a.state;
+        if ((state === null || state === void 0 ? void 0 : state.kind) === 'running' && handle.isCurrent()) {
+            state.run.result = result;
+        }
+        return result;
+    }
+    /** Refresh now, or keep one refresh while busy. */
+    runNow(key) {
+        var _a;
+        const entry = __classPrivateFieldGet(this, _Poller_entries, "f").get(key);
+        if (!entry || entry.subscribers.size === 0) {
+            return;
+        }
+        if (__classPrivateFieldGet(this, _Poller_getVisibilityState, "f").call(this) === 'hidden') {
+            entry.runOnShow = true;
+            return;
+        }
+        if (entry.state.kind !== 'idle') {
+            entry.runAgain = true;
+            return;
+        }
+        __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_clearTimer).call(this, entry);
+        entry.state = { kind: 'starting' };
+        (_a = __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getSubscriber).call(this, entry)) === null || _a === void 0 ? void 0 : _a.refresh();
+    }
+    /** Abort and remove every polling identity. Intended for test isolation. */
+    clear() {
+        var _a, _b;
+        for (const entry of __classPrivateFieldGet(this, _Poller_entries, "f").values()) {
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_clearTimer).call(this, entry);
+            if (entry.disposeTimer !== undefined) {
+                __classPrivateFieldGet(this, _Poller_clearTimeout, "f").call(this, entry.disposeTimer);
+            }
+            if (entry.state.kind === 'running') {
+                entry.state.run.controller.abort();
+                (_b = (_a = entry.state.run).detachExternalSignal) === null || _b === void 0 ? void 0 : _b.call(_a);
+                entry.state.run.end();
+            }
+        }
+        for (const owner of __classPrivateFieldGet(this, _Poller_owners, "f").values()) {
+            if (owner.disposeTimer !== undefined) {
+                __classPrivateFieldGet(this, _Poller_clearTimeout, "f").call(this, owner.disposeTimer);
+            }
+            for (const timer of owner.timers.values()) {
+                __classPrivateFieldGet(this, _Poller_clearTimeout, "f").call(this, timer);
+            }
+        }
+        __classPrivateFieldGet(this, _Poller_owners, "f").clear();
+        __classPrivateFieldGet(this, _Poller_entries, "f").clear();
+        __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_stopVisibilityListenerIfIdle).call(this);
+    }
+    /** Current time according to the injected clock. */
+    now() {
+        return __classPrivateFieldGet(this, _Poller_now, "f").call(this);
+    }
+}
+_Poller_clearTimeout = new WeakMap(), _Poller_entries = new WeakMap(), _Poller_getVisibilityState = new WeakMap(), _Poller_jitterRatio = new WeakMap(), _Poller_now = new WeakMap(), _Poller_random = new WeakMap(), _Poller_setTimeout = new WeakMap(), _Poller_visibilityTarget = new WeakMap(), _Poller_owners = new WeakMap(), _Poller_listeningForVisibility = new WeakMap(), _Poller_handleVisibilityChange = new WeakMap(), _Poller_instances = new WeakSet(), _Poller_start = function _Poller_start(key, cause, externalSignal, inputKey) {
+    var _a;
+    const entry = __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getOrCreateEntry).call(this, key);
+    if (entry.state.kind === 'running') {
+        const running = entry.state.run;
+        if (cause === 'poll') {
+            // A slow poll must finish. Keep one later run instead of
+            // stopping work on every tick.
+            entry.runAgain = true;
+            const abortedController = new AbortController();
+            abortedController.abort();
+            return {
+                signal: abortedController.signal,
+                finish: () => { },
+                isCurrent: () => false,
+                waitForNewer: () => __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_waitForNewer).call(this, key, entry.generation),
+            };
+        }
+        running.controller.abort();
+        (_a = running.detachExternalSignal) === null || _a === void 0 ? void 0 : _a.call(running);
+        running.end();
+    }
+    __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_clearTimer).call(this, entry);
+    const generation = ++entry.generation;
+    const controller = new AbortController();
+    let end = () => { };
+    const done = new Promise((resolve) => {
+        end = resolve;
+    });
+    const activeRun = {
+        cause,
+        controller,
+        done,
+        end,
+        generation,
+        inputKey,
+    };
+    entry.state = { kind: 'running', run: activeRun };
+    if (externalSignal && typeof externalSignal.addEventListener === 'function') {
+        if (externalSignal.aborted) {
+            controller.abort(externalSignal.reason);
+        }
+        else {
+            const abortFromExternalSignal = () => controller.abort(externalSignal.reason);
+            externalSignal.addEventListener('abort', abortFromExternalSignal, { once: true });
+            activeRun.detachExternalSignal = () => externalSignal.removeEventListener('abort', abortFromExternalSignal);
+        }
+    }
+    return __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_createRunHandle).call(this, key, activeRun);
+}, _Poller_createRunHandle = function _Poller_createRunHandle(key, activeRun) {
+    let finished = false;
+    return {
+        signal: activeRun.controller.signal,
+        finish: (outcome) => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_finishRun).call(this, key, activeRun.generation, outcome);
+        },
+        isCurrent: () => {
+            var _a;
+            const state = (_a = __classPrivateFieldGet(this, _Poller_entries, "f").get(key)) === null || _a === void 0 ? void 0 : _a.state;
+            return (state === null || state === void 0 ? void 0 : state.kind) === 'running' && state.run.generation === activeRun.generation;
+        },
+        waitForNewer: () => __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_waitForNewer).call(this, key, activeRun.generation),
+    };
+}, _Poller_runWork = function _Poller_runWork(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ cause, handle, read, work, write, }) {
+        let outcome = { status: 'success' };
+        try {
+            assertCurrentRun(handle);
+            const value = yield work(handle.signal);
+            assertCurrentRun(handle);
+            write(value);
+            return value;
+        }
+        catch (error) {
+            outcome = isAbortError(error)
+                ? { status: 'aborted' }
+                : { status: 'error', retryAfterMs: getRetryAfterMs(error) };
+            const previous = read === null || read === void 0 ? void 0 : read();
+            if (isAbortError(error) && (previous === null || previous === void 0 ? void 0 : previous.found)) {
+                // A replaced selector still owns a Recoil promise. Wait until
+                // every newer run publishes before returning its value.
+                yield handle.waitForNewer();
+                const latest = read === null || read === void 0 ? void 0 : read();
+                return (latest === null || latest === void 0 ? void 0 : latest.found) ? latest.value : previous.value;
+            }
+            if (cause === 'poll' && (previous === null || previous === void 0 ? void 0 : previous.found)) {
+                return previous.value;
+            }
+            throw error;
+        }
+        finally {
+            handle.finish(outcome);
+        }
+    });
+}, _Poller_finishRun = function _Poller_finishRun(key, generation, outcome) {
+    var _a, _b;
+    var _c;
+    const entry = __classPrivateFieldGet(this, _Poller_entries, "f").get(key);
+    if (!entry || entry.state.kind !== 'running' || entry.state.run.generation !== generation) {
+        return;
+    }
+    (_b = (_a = entry.state.run).detachExternalSignal) === null || _b === void 0 ? void 0 : _b.call(_a);
+    entry.state.run.end();
+    entry.state = { kind: 'idle' };
+    if (entry.subscribers.size === 0) {
+        if (entry.owners.size === 0) {
+            __classPrivateFieldGet(this, _Poller_entries, "f").delete(key);
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_stopVisibilityListenerIfIdle).call(this);
+        }
+        return;
+    }
+    if (outcome.status === 'success') {
+        entry.failureCount = 0;
+        entry.nextRunAt = undefined;
+    }
+    else if (outcome.status === 'error') {
+        entry.failureCount += 1;
+        entry.runAgain = false;
+        const baseDelay = __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getIntervalMs).call(this, entry);
+        const exponentialDelay = Math.min(baseDelay * Math.pow(2, (entry.failureCount - 1)), MAX_BACKOFF_MS);
+        const jitteredDelay = Math.min(__classPrivateFieldGet(this, _Poller_instances, "m", _Poller_withJitter).call(this, exponentialDelay), MAX_BACKOFF_MS);
+        const backoffDelay = Math.max(jitteredDelay, (_c = outcome.retryAfterMs) !== null && _c !== void 0 ? _c : 0);
+        __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_schedule).call(this, key, entry, backoffDelay);
+    }
+    if (__classPrivateFieldGet(this, _Poller_getVisibilityState, "f").call(this) === 'hidden') {
+        // Keep the due time so Retry-After and backoff still hold when the
+        // tab becomes visible.
+        entry.runOnShow = true;
+        return;
+    }
+    if (outcome.status === 'success') {
+        if (entry.runAgain || entry.runOnShow) {
+            entry.runAgain = false;
+            entry.runOnShow = false;
+            this.runNow(key);
+            return;
+        }
+        __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_schedulePoll).call(this, key, entry);
+        return;
+    }
+    if (outcome.status === 'aborted') {
+        if (entry.runAgain) {
+            entry.runAgain = false;
+            this.runNow(key);
+        }
+        else {
+            __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_schedulePoll).call(this, key, entry);
+        }
+    }
+}, _Poller_waitForNewer = function _Poller_waitForNewer(key, generation) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let seenGeneration = generation;
+        while (true) {
+            const state = (_a = __classPrivateFieldGet(this, _Poller_entries, "f").get(key)) === null || _a === void 0 ? void 0 : _a.state;
+            const activeRun = (state === null || state === void 0 ? void 0 : state.kind) === 'running' ? state.run : undefined;
+            if (!activeRun || activeRun.generation <= seenGeneration) {
+                return;
+            }
+            seenGeneration = activeRun.generation;
+            yield activeRun.done;
+        }
+    });
+}, _Poller_getIntervalMs = function _Poller_getIntervalMs(entry) {
+    return Math.min(...Array.from(entry.subscribers.values(), (subscriber) => subscriber.intervalMs));
+}, _Poller_getOrCreateEntry = function _Poller_getOrCreateEntry(key) {
+    let entry = __classPrivateFieldGet(this, _Poller_entries, "f").get(key);
+    if (!entry) {
+        entry = {
+            failureCount: 0,
+            generation: 0,
+            owners: new Set(),
+            runAgain: false,
+            runOnShow: false,
+            state: { kind: 'idle' },
+            subscribers: new Map(),
+        };
+        __classPrivateFieldGet(this, _Poller_entries, "f").set(key, entry);
+    }
+    return entry;
+}, _Poller_getSubscriber = function _Poller_getSubscriber(entry) {
+    return Array.from(entry.subscribers.values()).sort((a, b) => a.intervalMs - b.intervalMs)[0];
+}, _Poller_getOrCreateOwner = function _Poller_getOrCreateOwner(ownerId) {
+    let owner = __classPrivateFieldGet(this, _Poller_owners, "f").get(ownerId);
+    if (!owner) {
+        const newOwner = {
+            claims: new Map(),
+            hooks: new Map(),
+            renderKeys: new Set(),
+            timers: new Map(),
+        };
+        owner = newOwner;
+        __classPrivateFieldGet(this, _Poller_owners, "f").set(ownerId, newOwner);
+    }
+    return owner;
+}, _Poller_dropOwnedKey = function _Poller_dropOwnedKey(ownerId, key) {
+    var _a, _b;
+    const entry = __classPrivateFieldGet(this, _Poller_entries, "f").get(key);
+    if (!entry) {
+        return;
+    }
+    entry.owners.delete(ownerId);
+    if (entry.owners.size > 0 || entry.subscribers.size > 0) {
+        return;
+    }
+    __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_clearTimer).call(this, entry);
+    if (entry.state.kind === 'running') {
+        entry.state.run.controller.abort();
+        (_b = (_a = entry.state.run).detachExternalSignal) === null || _b === void 0 ? void 0 : _b.call(_a);
+        entry.state.run.end();
+    }
+    __classPrivateFieldGet(this, _Poller_entries, "f").delete(key);
+}, _Poller_dropOwner = function _Poller_dropOwner(ownerId, owner) {
+    if (__classPrivateFieldGet(this, _Poller_owners, "f").get(ownerId) !== owner) {
+        return;
+    }
+    __classPrivateFieldGet(this, _Poller_owners, "f").delete(ownerId);
+    for (const timer of owner.timers.values()) {
+        __classPrivateFieldGet(this, _Poller_clearTimeout, "f").call(this, timer);
+    }
+    const keys = new Set([...owner.claims.values(), ...owner.renderKeys, ...owner.hooks.values()]);
+    for (const key of keys) {
+        __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_dropOwnedKey).call(this, ownerId, key);
+    }
+    __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_stopVisibilityListenerIfIdle).call(this);
+}, _Poller_hasClaimForKey = function _Poller_hasClaimForKey(owner, key) {
+    return Array.from(owner.claims.values()).some((claimKey) => claimKey === key);
+}, _Poller_hasHookForKey = function _Poller_hasHookForKey(owner, key) {
+    return Array.from(owner.hooks.values()).some((hookKey) => hookKey === key);
+}, _Poller_ownerHasKey = function _Poller_ownerHasKey(owner, key) {
+    return owner.renderKeys.has(key) || __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_hasHookForKey).call(this, owner, key) || __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_hasClaimForKey).call(this, owner, key);
+}, _Poller_schedulePoll = function _Poller_schedulePoll(key, entry) {
+    __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_schedule).call(this, key, entry, __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_withJitter).call(this, __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_getIntervalMs).call(this, entry)));
+}, _Poller_schedule = function _Poller_schedule(key, entry, delay) {
+    __classPrivateFieldGet(this, _Poller_instances, "m", _Poller_clearTimer).call(this, entry);
+    entry.nextRunAt = __classPrivateFieldGet(this, _Poller_now, "f").call(this) + delay;
+    if (__classPrivateFieldGet(this, _Poller_getVisibilityState, "f").call(this) === 'hidden') {
+        entry.runOnShow = true;
+        return;
+    }
+    entry.timer = __classPrivateFieldGet(this, _Poller_setTimeout, "f").call(this, () => {
+        entry.timer = undefined;
+        entry.nextRunAt = undefined;
+        this.runNow(key);
+    }, delay);
+}, _Poller_clearTimer = function _Poller_clearTimer(entry, clearNextRun = true) {
+    if (entry.timer !== undefined) {
+        __classPrivateFieldGet(this, _Poller_clearTimeout, "f").call(this, entry.timer);
+        entry.timer = undefined;
+    }
+    if (clearNextRun) {
+        entry.nextRunAt = undefined;
+    }
+}, _Poller_withJitter = function _Poller_withJitter(delay) {
+    const multiplier = 1 - __classPrivateFieldGet(this, _Poller_jitterRatio, "f") + __classPrivateFieldGet(this, _Poller_random, "f").call(this) * __classPrivateFieldGet(this, _Poller_jitterRatio, "f") * 2;
+    return Math.max(0, delay * multiplier);
+}, _Poller_startVisibilityListener = function _Poller_startVisibilityListener() {
+    if (__classPrivateFieldGet(this, _Poller_listeningForVisibility, "f") || !__classPrivateFieldGet(this, _Poller_visibilityTarget, "f")) {
+        return;
+    }
+    __classPrivateFieldGet(this, _Poller_visibilityTarget, "f").addEventListener('visibilitychange', __classPrivateFieldGet(this, _Poller_handleVisibilityChange, "f"));
+    __classPrivateFieldSet(this, _Poller_listeningForVisibility, true, "f");
+}, _Poller_stopVisibilityListenerIfIdle = function _Poller_stopVisibilityListenerIfIdle() {
+    if (!__classPrivateFieldGet(this, _Poller_listeningForVisibility, "f") || __classPrivateFieldGet(this, _Poller_entries, "f").size > 0 || !__classPrivateFieldGet(this, _Poller_visibilityTarget, "f")) {
+        return;
+    }
+    __classPrivateFieldGet(this, _Poller_visibilityTarget, "f").removeEventListener('visibilitychange', __classPrivateFieldGet(this, _Poller_handleVisibilityChange, "f"));
+    __classPrivateFieldSet(this, _Poller_listeningForVisibility, false, "f");
+};
+const poller = new Poller();
+/**
+ * Register fixed-delay polling for a request identity.
+ *
+ * `refresh` only invalidates the corresponding selector. Request lifecycle,
+ * backpressure, retries, and cancellation remain owned by the poller.
+ */
+export function usePolling(key, intervalSeconds, refresh) {
+    const refreshRef = useLatestRef(refresh);
+    useEffect(() => poller.subscribe(key, intervalSeconds, () => refreshRef.current()), [intervalSeconds, key, refreshRef]);
+}
+/**
+ * Create a render-local map of hooks to polling keys.
+ *
+ * The commit drops claims left by hooks that did not render.
+ */
+export function usePollScope() {
+    const id = useId();
+    const claims = new Map();
+    useLayoutEffect(() => {
+        poller.commitOwner(id, claims);
+    });
+    useLayoutEffect(() => () => poller.releaseOwner(id), [id]);
+    return { claims, id };
+}
+/**
+ * Keep one request key for a rendered hook.
+ *
+ * The hook must claim the key during render because an initial suspended render
+ * runs no effect. The claim only marks ownership; it starts no work. The passive
+ * effect keeps the claim after commit and stays mounted when Suspense hides an
+ * existing tree.
+ */
+export function usePollKey(scope, key) {
+    const hookId = useId();
+    scope === null || scope === void 0 ? void 0 : scope.claims.set(hookId, key);
+    const ownerId = scope === null || scope === void 0 ? void 0 : scope.id;
+    if (ownerId) {
+        poller.claimKey(ownerId, hookId, key);
+    }
+    useEffect(() => {
+        if (!ownerId) {
+            return;
+        }
+        poller.mountKey(ownerId, hookId, key);
+        return () => poller.unmountKey(ownerId, hookId, key);
+    }, [hookId, key, ownerId]);
+}
+/** Run one request using the production poller. */
+export function runPoll(run) {
+    return poller.run(run);
+}
+/** Create a force key that identifies a poller-owned refresh. */
+export function createPollForceKey() {
+    var _a, _b;
+    var _c;
+    return `${POLL_FORCE_KEY_PREFIX}${(_c = (_b = (_a = globalThis.crypto) === null || _a === void 0 ? void 0 : _a.randomUUID) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : String(Math.random())}`;
+}
+/** Check whether a selector force key originated from the poller. */
+export function isPollForceKey(forceKey) {
+    var _a;
+    return (_a = forceKey === null || forceKey === void 0 ? void 0 : forceKey.startsWith(POLL_FORCE_KEY_PREFIX)) !== null && _a !== void 0 ? _a : false;
+}
+/** Extract Retry-After as a non-negative delay in milliseconds. */
+export function parseRetryAfter(response, now = poller.now()) {
+    const value = response.headers.get('Retry-After');
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return seconds * 1000;
+    }
+    const retryAt = Date.parse(value);
+    if (Number.isNaN(retryAt)) {
+        return undefined;
+    }
+    return Math.max(0, retryAt - now);
+}
+/** Keep Retry-After beside an error without changing the error object. */
+export function markRetryAfter(error, response) {
+    const delay = parseRetryAfter(response);
+    if (delay !== undefined && typeof error === 'object' && error !== null) {
+        retryAfterByError.set(error, delay);
+    }
+    return error;
+}
+/** Await a promise while preserving ownership of request cancellation. */
+export function waitOrAbort(promise, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!signal) {
+            return promise;
+        }
+        if (signal.aborted) {
+            throw new DOMException('The request was aborted', 'AbortError');
+        }
+        return new Promise((resolve, reject) => {
+            const abort = () => {
+                signal.removeEventListener('abort', abort);
+                reject(new DOMException('The request was aborted', 'AbortError'));
+            };
+            signal.addEventListener('abort', abort, { once: true });
+            promise.then((value) => {
+                signal.removeEventListener('abort', abort);
+                resolve(value);
+            }, (error) => {
+                signal.removeEventListener('abort', abort);
+                reject(error);
+            });
+        });
+    });
+}
+/** Clear production polling state. Intended for test isolation. */
+export function clearPolling_TEST() {
+    poller.clear();
+}
+//# sourceMappingURL=polling.js.map