@darajs/core 1.29.6 → 1.29.8

package/dist/umd/dara.core.umd.cjs

@@ -2992,7 +2992,7 @@
 	var { applyAtomValueWrites: applyAtomValueWrites$1 } = Recoil_RecoilValueInterface;
 	var { releaseScheduledRetainablesNow: releaseScheduledRetainablesNow$1 } = Recoil_Retention;
 	var { freshSnapshot: freshSnapshot$1 } = Recoil_Snapshot$1;
-	var { useCallback: useCallback$27, useContext: useContext$16, useEffect: useEffect$54, useMemo: useMemo$32, useRef: useRef$1$2, useState: useState$48 } = react.default;
+	var { useCallback: useCallback$27, useContext: useContext$16, useEffect: useEffect$55, useMemo: useMemo$32, useRef: useRef$1$2, useState: useState$48 } = react.default;
 	function notInAContext() {
 		throw Recoil_err$2("This component must be used inside a <RecoilRoot> component.");
 	}
@@ -3079,13 +3079,13 @@
 		const storeRef = useStoreRef();
 		const [, setState] = useState$48([]);
 		setNotifyBatcherOfChange(() => setState({}));
-		useEffect$54(() => {
+		useEffect$55(() => {
 			setNotifyBatcherOfChange(() => setState({}));
 			return () => {
 				setNotifyBatcherOfChange(() => {});
 			};
 		}, [setNotifyBatcherOfChange]);
-		useEffect$54(() => {
+		useEffect$55(() => {
 			Recoil_Queue.enqueueExecution("Batcher", () => {
 				endBatch(storeRef.current);
 			});
@@ -3190,7 +3190,7 @@
 		if (storeProp != null) storeRef.current = storeProp;
 		storeStateRef = Recoil_useRefInitOnce(() => initializeState_DEPRECATED != null ? initialStoreState_DEPRECATED(storeRef.current, initializeState_DEPRECATED) : initializeState != null ? initialStoreState(initializeState) : makeEmptyStoreState$2());
 		const mutableSource = useMemo$32(() => createMutableSource$1 === null || createMutableSource$1 === void 0 ? void 0 : createMutableSource$1(storeStateRef, () => storeStateRef.current.currentTree.version), [storeStateRef]);
-		useEffect$54(() => {
+		useEffect$55(() => {
 			const store = storeRef.current;
 			for (const atomKey of new Set(store.getState().knownAtoms)) initializeNode$2(store, atomKey, "get");
 			return () => {
@@ -11932,48 +11932,6 @@
 		return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
 	}
 	//#endregion
-	//#region ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/esm5/internal/operators/debounceTime.js
-	function debounceTime(dueTime, scheduler) {
-		if (scheduler === void 0) scheduler = asyncScheduler;
-		return operate(function(source, subscriber) {
-			var activeTask = null;
-			var lastValue = null;
-			var lastTime = null;
-			var emit = function() {
-				if (activeTask) {
-					activeTask.unsubscribe();
-					activeTask = null;
-					var value = lastValue;
-					lastValue = null;
-					subscriber.next(value);
-				}
-			};
-			function emitWhenIdle() {
-				var targetTime = lastTime + dueTime;
-				var now = scheduler.now();
-				if (now < targetTime) {
-					activeTask = this.schedule(void 0, targetTime - now);
-					subscriber.add(activeTask);
-					return;
-				}
-				emit();
-			}
-			source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-				lastValue = value;
-				lastTime = scheduler.now();
-				if (!activeTask) {
-					activeTask = scheduler.schedule(emitWhenIdle, dueTime);
-					subscriber.add(activeTask);
-				}
-			}, function() {
-				emit();
-				subscriber.complete();
-			}, void 0, function() {
-				lastValue = activeTask = null;
-			}));
-		});
-	}
-	//#endregion
 	//#region ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/esm5/internal/operators/take.js
 	function take(count) {
 		return count <= 0 ? function() {
@@ -12022,106 +11980,6 @@
 		});
 	}
 	//#endregion
-	//#region ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/esm5/internal/operators/share.js
-	function share(options) {
-		if (options === void 0) options = {};
-		var _a = options.connector, connector = _a === void 0 ? function() {
-			return new Subject();
-		} : _a, _b = options.resetOnError, resetOnError = _b === void 0 ? true : _b, _c = options.resetOnComplete, resetOnComplete = _c === void 0 ? true : _c, _d = options.resetOnRefCountZero, resetOnRefCountZero = _d === void 0 ? true : _d;
-		return function(wrapperSource) {
-			var connection;
-			var resetConnection;
-			var subject;
-			var refCount = 0;
-			var hasCompleted = false;
-			var hasErrored = false;
-			var cancelReset = function() {
-				resetConnection === null || resetConnection === void 0 || resetConnection.unsubscribe();
-				resetConnection = void 0;
-			};
-			var reset = function() {
-				cancelReset();
-				connection = subject = void 0;
-				hasCompleted = hasErrored = false;
-			};
-			var resetAndUnsubscribe = function() {
-				var conn = connection;
-				reset();
-				conn === null || conn === void 0 || conn.unsubscribe();
-			};
-			return operate(function(source, subscriber) {
-				refCount++;
-				if (!hasErrored && !hasCompleted) cancelReset();
-				var dest = subject = subject !== null && subject !== void 0 ? subject : connector();
-				subscriber.add(function() {
-					refCount--;
-					if (refCount === 0 && !hasErrored && !hasCompleted) resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
-				});
-				dest.subscribe(subscriber);
-				if (!connection && refCount > 0) {
-					connection = new SafeSubscriber({
-						next: function(value) {
-							return dest.next(value);
-						},
-						error: function(err) {
-							hasErrored = true;
-							cancelReset();
-							resetConnection = handleReset(reset, resetOnError, err);
-							dest.error(err);
-						},
-						complete: function() {
-							hasCompleted = true;
-							cancelReset();
-							resetConnection = handleReset(reset, resetOnComplete);
-							dest.complete();
-						}
-					});
-					innerFrom(source).subscribe(connection);
-				}
-			})(wrapperSource);
-		};
-	}
-	function handleReset(reset, on) {
-		var args = [];
-		for (var _i = 2; _i < arguments.length; _i++) args[_i - 2] = arguments[_i];
-		if (on === true) {
-			reset();
-			return;
-		}
-		if (on === false) return;
-		var onSubscriber = new SafeSubscriber({ next: function() {
-			onSubscriber.unsubscribe();
-			reset();
-		} });
-		return innerFrom(on.apply(void 0, __spreadArray([], __read(args)))).subscribe(onSubscriber);
-	}
-	//#endregion
-	//#region ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/esm5/internal/operators/switchMap.js
-	function switchMap(project, resultSelector) {
-		return operate(function(source, subscriber) {
-			var innerSubscriber = null;
-			var index = 0;
-			var isComplete = false;
-			var checkComplete = function() {
-				return isComplete && !innerSubscriber && subscriber.complete();
-			};
-			source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-				innerSubscriber === null || innerSubscriber === void 0 || innerSubscriber.unsubscribe();
-				var innerIndex = 0;
-				var outerIndex = index++;
-				innerFrom(project(value, outerIndex)).subscribe(innerSubscriber = createOperatorSubscriber(subscriber, function(innerValue) {
-					return subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue);
-				}, function() {
-					innerSubscriber = null;
-					checkComplete();
-				}));
-			}, function() {
-				isComplete = true;
-				checkComplete();
-			}));
-		});
-	}
-	//#endregion
 	//#region ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/esm5/internal/operators/takeWhile.js
 	function takeWhile(predicate, inclusive) {
 		if (inclusive === void 0) inclusive = false;
@@ -17646,14 +17504,14 @@
 	* earlier React versions.
 	* @see https://floating-ui.com/docs/react-utils#useid
 	*/
-	var useId$1 = SafeReact.useId || useFloatingId;
+	var useId$2 = SafeReact.useId || useFloatingId;
 	/**
 	* Renders a pointing arrow triangle.
 	* @see https://floating-ui.com/docs/FloatingArrow
 	*/
 	var FloatingArrow = /*#__PURE__*/ react$3.forwardRef(function FloatingArrow(props, ref) {
 		const { context: { placement, elements: { floating }, middlewareData: { arrow, shift } }, width = 14, height = 7, tipRadius = 0, strokeWidth = 0, staticOffset, stroke, d, style: { transform, ...restStyle } = {}, ...rest } = props;
-		const clipPathId = useId$1();
+		const clipPathId = useId$2();
 		const [isRTL, setIsRTL] = react$3.useState(false);
 		index(() => {
 			if (!floating) return;
@@ -18142,7 +18000,7 @@
 	function useFloatingPortalNode(props) {
 		if (props === void 0) props = {};
 		const { id, root } = props;
-		const uniqueId = useId$1();
+		const uniqueId = useId$2();
 		const portalContext = usePortalContext();
 		const [portalNode, setPortalNode] = react$3.useState(null);
 		const portalNodeRef = react$3.useRef(null);
@@ -18571,7 +18429,7 @@
 	}
 	function useFloatingRootContext(options) {
 		const { open = false, onOpenChange: onOpenChangeProp, elements: elementsProp } = options;
-		const floatingId = useId$1();
+		const floatingId = useId$2();
 		const dataRef = react$3.useRef({});
 		const [events] = react$3.useState(() => createPubSub());
 		const nested = useFloatingParentNodeId() != null;
@@ -18874,7 +18732,7 @@
 		const { open, floatingId } = context;
 		const { enabled = true, role = "dialog" } = props;
 		const ariaRole = (_componentRoleToAriaR = componentRoleToAriaRoleMap.get(role)) != null ? _componentRoleToAriaR : role;
-		const referenceId = useId$1();
+		const referenceId = useId$2();
 		const isNested = useFloatingParentNodeId() != null;
 		const reference = react$3.useMemo(() => {
 			if (ariaRole === "tooltip" || role === "label") return { ["aria-" + (role === "label" ? "labelledby" : "describedby")]: open ? floatingId : void 0 };
@@ -51835,6 +51693,17 @@
 	//#endregion
 	//#region js/api/http.tsx
 	var import_cloneDeep = /* @__PURE__ */ __toESM(require_cloneDeep(), 1);
+	var signalIds = /* @__PURE__ */ new WeakMap();
+	var nextSignalId = 1;
+	function getSignalId(signal) {
+		let id = signalIds.get(signal);
+		if (id === void 0) {
+			id = nextSignalId;
+			nextSignalId += 1;
+			signalIds.set(signal, id);
+		}
+		return id;
+	}
 	/**
 	* Serializable form of RequestExtras.
 	* Required to use for e.g. recoil params as they need to be serializable.
@@ -51863,6 +51732,10 @@
 		toJSON() {
 			const serializable = this.toSerializable();
 			if (!serializable) return null;
+			if (this.extras.signal) return JSON.stringify({
+				...serializable,
+				signal: getSignalId(this.extras.signal)
+			});
 			return JSON.stringify(serializable);
 		}
 	};
@@ -69856,11 +69729,611 @@
 		return identifier;
 	}
 	//#endregion
+	//#region js/shared/interactivity/polling.tsx
+	var DEFAULT_JITTER_RATIO = .1;
+	var MAX_BACKOFF_MS = 6e4;
+	var POLL_FORCE_KEY_PREFIX = "__dara_poll__:";
+	var retryAfterByError = /* @__PURE__ */ 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. */
+	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) : void 0;
+	}
+	/**
+	* 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.
+	*/
+	var Poller = class {
+		#clearTimeout;
+		#entries = /* @__PURE__ */ new Map();
+		#getVisibilityState;
+		#jitterRatio;
+		#now;
+		#random;
+		#setTimeout;
+		#visibilityTarget;
+		#owners = /* @__PURE__ */ new Map();
+		#listeningForVisibility = false;
+		constructor(options = {}) {
+			this.#clearTimeout = options.clearTimeout ?? ((timer) => clearTimeout(timer));
+			this.#getVisibilityState = options.getVisibilityState ?? (() => typeof document === "undefined" ? "visible" : document.visibilityState);
+			this.#jitterRatio = options.jitterRatio ?? DEFAULT_JITTER_RATIO;
+			this.#now = options.now ?? (() => Date.now());
+			this.#random = options.random ?? (() => Math.random());
+			this.#setTimeout = options.setTimeout ?? ((callback, delay) => setTimeout(callback, delay));
+			this.#visibilityTarget = options.visibilityTarget ?? (typeof document === "undefined" ? void 0 : document);
+		}
+		/**
+		* 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) {
+			const intervalMs = (intervalSeconds ?? 0) * 1e3;
+			if (!Number.isFinite(intervalMs) || !(intervalMs > 0)) return () => {};
+			const entry = this.#getOrCreateEntry(key);
+			const oldIntervalMs = entry.subscribers.size > 0 ? this.#getIntervalMs(entry) : void 0;
+			if (entry.disposeTimer !== void 0) {
+				this.#clearTimeout(entry.disposeTimer);
+				entry.disposeTimer = void 0;
+			}
+			const subscriberId = Symbol(key);
+			entry.subscribers.set(subscriberId, {
+				intervalMs,
+				refresh
+			});
+			this.#startVisibilityListener();
+			if (entry.subscribers.size === 1 && entry.state.kind === "idle" && entry.timer === void 0) this.#schedulePoll(key, entry);
+			else if (entry.timer !== void 0 && entry.failureCount === 0 && oldIntervalMs !== void 0 && intervalMs < oldIntervalMs) {
+				const remaining = Math.max(0, (entry.nextRunAt ?? this.#now()) - this.#now());
+				this.#schedule(key, entry, Math.min(remaining, this.#withJitter(intervalMs)));
+			}
+			return () => {
+				const removedIntervalMs = this.#getIntervalMs(entry);
+				entry.subscribers.delete(subscriberId);
+				if (entry.subscribers.size > 0) {
+					if (entry.timer !== void 0 && entry.failureCount === 0 && this.#getIntervalMs(entry) > removedIntervalMs) this.#schedulePoll(key, entry);
+					return;
+				}
+				this.#clearTimer(entry);
+				entry.disposeTimer = this.#setTimeout(() => {
+					entry.disposeTimer = void 0;
+					if (entry.subscribers.size > 0) return;
+					if (entry.owners.size > 0) return;
+					if (this.#entries.get(key) !== entry) return;
+					if (entry.state.kind === "running") {
+						entry.state.run.controller.abort();
+						entry.state.run.detachExternalSignal?.();
+						entry.state.run.end();
+					}
+					this.#entries.delete(key);
+					this.#stopVisibilityListenerIfIdle();
+				}, 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 = this.#getOrCreateOwner(ownerId);
+			if (owner.hooks.get(hookId) === key) return;
+			const oldKey = owner.claims.get(hookId);
+			owner.claims.set(hookId, key);
+			this.#getOrCreateEntry(key).owners.add(ownerId);
+			if (oldKey !== void 0 && oldKey !== key && !this.#ownerHasKey(owner, oldKey)) this.#dropOwnedKey(ownerId, oldKey);
+		}
+		/** Apply the hook claims collected by one committed owner render. */
+		commitOwner(ownerId, claims) {
+			const owner = this.#getOrCreateOwner(ownerId);
+			if (owner.disposeTimer !== void 0) {
+				this.#clearTimeout(owner.disposeTimer);
+				owner.disposeTimer = void 0;
+			}
+			const droppedClaims = /* @__PURE__ */ new Set();
+			for (const [hookId, key] of owner.claims) if (claims.get(hookId) !== key) {
+				owner.claims.delete(hookId);
+				droppedClaims.add(key);
+			}
+			const nextRenderKeys = /* @__PURE__ */ new Set();
+			for (const key of new Set(claims.values())) {
+				this.#getOrCreateEntry(key).owners.add(ownerId);
+				if (!this.#hasHookForKey(owner, key) && !this.#hasClaimForKey(owner, key)) nextRenderKeys.add(key);
+			}
+			const oldRenderKeys = owner.renderKeys;
+			owner.renderKeys = nextRenderKeys;
+			for (const key of oldRenderKeys) if (!nextRenderKeys.has(key) && !this.#hasHookForKey(owner, key)) this.#dropOwnedKey(ownerId, key);
+			for (const key of droppedClaims) if (!this.#ownerHasKey(owner, key)) this.#dropOwnedKey(ownerId, key);
+		}
+		/** Keep one key after its hook commits. */
+		mountKey(ownerId, hookId, key) {
+			const owner = this.#getOrCreateOwner(ownerId);
+			if (owner.disposeTimer !== void 0) {
+				this.#clearTimeout(owner.disposeTimer);
+				owner.disposeTimer = void 0;
+			}
+			const timer = owner.timers.get(hookId);
+			if (timer !== void 0) {
+				this.#clearTimeout(timer);
+				owner.timers.delete(hookId);
+			}
+			const oldKey = owner.hooks.get(hookId);
+			owner.hooks.set(hookId, key);
+			owner.claims.delete(hookId);
+			owner.renderKeys.delete(key);
+			this.#getOrCreateEntry(key).owners.add(ownerId);
+			if (oldKey !== void 0 && oldKey !== key && !this.#ownerHasKey(owner, oldKey)) this.#dropOwnedKey(ownerId, oldKey);
+		}
+		/** Drop a committed hook key after the StrictMode remount window. */
+		unmountKey(ownerId, hookId, key) {
+			const owner = this.#owners.get(ownerId);
+			if (!owner || owner.timers.has(hookId)) return;
+			const timer = this.#setTimeout(() => {
+				owner.timers.delete(hookId);
+				if (owner.hooks.get(hookId) !== key) return;
+				owner.hooks.delete(hookId);
+				if (!this.#ownerHasKey(owner, key)) this.#dropOwnedKey(ownerId, key);
+				this.#stopVisibilityListenerIfIdle();
+			}, 0);
+			owner.timers.set(hookId, timer);
+		}
+		/** Release a rendered owner after the StrictMode remount window. */
+		releaseOwner(ownerId) {
+			const owner = this.#owners.get(ownerId);
+			if (!owner || owner.disposeTimer !== void 0) return;
+			owner.disposeTimer = this.#setTimeout(() => this.#dropOwner(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 }) {
+			const entry = this.#entries.get(key);
+			const running = entry?.state.kind === "running" ? entry.state.run : void 0;
+			if (running?.cause === cause && running.inputKey === inputKey && running.result) return running.result;
+			const handle = this.#start(key, cause, signal, inputKey);
+			const result = this.#runWork({
+				cause,
+				handle,
+				read,
+				work,
+				write
+			});
+			const state = this.#entries.get(key)?.state;
+			if (state?.kind === "running" && handle.isCurrent()) state.run.result = result;
+			return result;
+		}
+		#start(key, cause, externalSignal, inputKey) {
+			const entry = this.#getOrCreateEntry(key);
+			if (entry.state.kind === "running") {
+				const running = entry.state.run;
+				if (cause === "poll") {
+					entry.runAgain = true;
+					const abortedController = new AbortController();
+					abortedController.abort();
+					return {
+						signal: abortedController.signal,
+						finish: () => {},
+						isCurrent: () => false,
+						waitForNewer: () => this.#waitForNewer(key, entry.generation)
+					};
+				}
+				running.controller.abort();
+				running.detachExternalSignal?.();
+				running.end();
+			}
+			this.#clearTimer(entry);
+			const generation = ++entry.generation;
+			const controller = new AbortController();
+			let end = () => {};
+			const activeRun = {
+				cause,
+				controller,
+				done: new Promise((resolve) => {
+					end = resolve;
+				}),
+				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 this.#createRunHandle(key, activeRun);
+		}
+		#createRunHandle(key, activeRun) {
+			let finished = false;
+			return {
+				signal: activeRun.controller.signal,
+				finish: (outcome) => {
+					if (finished) return;
+					finished = true;
+					this.#finishRun(key, activeRun.generation, outcome);
+				},
+				isCurrent: () => {
+					const state = this.#entries.get(key)?.state;
+					return state?.kind === "running" && state.run.generation === activeRun.generation;
+				},
+				waitForNewer: () => this.#waitForNewer(key, activeRun.generation)
+			};
+		}
+		async #runWork({ cause, handle, read, work, write }) {
+			let outcome = { status: "success" };
+			try {
+				assertCurrentRun(handle);
+				const value = await work(handle.signal);
+				assertCurrentRun(handle);
+				write(value);
+				return value;
+			} catch (error) {
+				outcome = isAbortError(error) ? { status: "aborted" } : {
+					status: "error",
+					retryAfterMs: getRetryAfterMs(error)
+				};
+				const previous = read?.();
+				if (isAbortError(error) && previous?.found) {
+					await handle.waitForNewer();
+					const latest = read?.();
+					return latest?.found ? latest.value : previous.value;
+				}
+				if (cause === "poll" && previous?.found) return previous.value;
+				throw error;
+			} finally {
+				handle.finish(outcome);
+			}
+		}
+		/** Refresh now, or keep one refresh while busy. */
+		runNow(key) {
+			const entry = this.#entries.get(key);
+			if (!entry || entry.subscribers.size === 0) return;
+			if (this.#getVisibilityState() === "hidden") {
+				entry.runOnShow = true;
+				return;
+			}
+			if (entry.state.kind !== "idle") {
+				entry.runAgain = true;
+				return;
+			}
+			this.#clearTimer(entry);
+			entry.state = { kind: "starting" };
+			this.#getSubscriber(entry)?.refresh();
+		}
+		/** Abort and remove every polling identity. Intended for test isolation. */
+		clear() {
+			for (const entry of this.#entries.values()) {
+				this.#clearTimer(entry);
+				if (entry.disposeTimer !== void 0) this.#clearTimeout(entry.disposeTimer);
+				if (entry.state.kind === "running") {
+					entry.state.run.controller.abort();
+					entry.state.run.detachExternalSignal?.();
+					entry.state.run.end();
+				}
+			}
+			for (const owner of this.#owners.values()) {
+				if (owner.disposeTimer !== void 0) this.#clearTimeout(owner.disposeTimer);
+				for (const timer of owner.timers.values()) this.#clearTimeout(timer);
+			}
+			this.#owners.clear();
+			this.#entries.clear();
+			this.#stopVisibilityListenerIfIdle();
+		}
+		/** Current time according to the injected clock. */
+		now() {
+			return this.#now();
+		}
+		#finishRun(key, generation, outcome) {
+			const entry = this.#entries.get(key);
+			if (!entry || entry.state.kind !== "running" || entry.state.run.generation !== generation) return;
+			entry.state.run.detachExternalSignal?.();
+			entry.state.run.end();
+			entry.state = { kind: "idle" };
+			if (entry.subscribers.size === 0) {
+				if (entry.owners.size === 0) {
+					this.#entries.delete(key);
+					this.#stopVisibilityListenerIfIdle();
+				}
+				return;
+			}
+			if (outcome.status === "success") {
+				entry.failureCount = 0;
+				entry.nextRunAt = void 0;
+			} else if (outcome.status === "error") {
+				entry.failureCount += 1;
+				entry.runAgain = false;
+				const baseDelay = this.#getIntervalMs(entry);
+				const exponentialDelay = Math.min(baseDelay * 2 ** (entry.failureCount - 1), MAX_BACKOFF_MS);
+				const jitteredDelay = Math.min(this.#withJitter(exponentialDelay), MAX_BACKOFF_MS);
+				const backoffDelay = Math.max(jitteredDelay, outcome.retryAfterMs ?? 0);
+				this.#schedule(key, entry, backoffDelay);
+			}
+			if (this.#getVisibilityState() === "hidden") {
+				entry.runOnShow = true;
+				return;
+			}
+			if (outcome.status === "success") {
+				if (entry.runAgain || entry.runOnShow) {
+					entry.runAgain = false;
+					entry.runOnShow = false;
+					this.runNow(key);
+					return;
+				}
+				this.#schedulePoll(key, entry);
+				return;
+			}
+			if (outcome.status === "aborted") if (entry.runAgain) {
+				entry.runAgain = false;
+				this.runNow(key);
+			} else this.#schedulePoll(key, entry);
+		}
+		async #waitForNewer(key, generation) {
+			let seenGeneration = generation;
+			while (true) {
+				const state = this.#entries.get(key)?.state;
+				const activeRun = state?.kind === "running" ? state.run : void 0;
+				if (!activeRun || activeRun.generation <= seenGeneration) return;
+				seenGeneration = activeRun.generation;
+				await activeRun.done;
+			}
+		}
+		#getIntervalMs(entry) {
+			return Math.min(...Array.from(entry.subscribers.values(), (subscriber) => subscriber.intervalMs));
+		}
+		#getOrCreateEntry(key) {
+			let entry = this.#entries.get(key);
+			if (!entry) {
+				entry = {
+					failureCount: 0,
+					generation: 0,
+					owners: /* @__PURE__ */ new Set(),
+					runAgain: false,
+					runOnShow: false,
+					state: { kind: "idle" },
+					subscribers: /* @__PURE__ */ new Map()
+				};
+				this.#entries.set(key, entry);
+			}
+			return entry;
+		}
+		#getSubscriber(entry) {
+			return Array.from(entry.subscribers.values()).sort((a, b) => a.intervalMs - b.intervalMs)[0];
+		}
+		#getOrCreateOwner(ownerId) {
+			let owner = this.#owners.get(ownerId);
+			if (!owner) {
+				const newOwner = {
+					claims: /* @__PURE__ */ new Map(),
+					hooks: /* @__PURE__ */ new Map(),
+					renderKeys: /* @__PURE__ */ new Set(),
+					timers: /* @__PURE__ */ new Map()
+				};
+				owner = newOwner;
+				this.#owners.set(ownerId, newOwner);
+			}
+			return owner;
+		}
+		#dropOwnedKey(ownerId, key) {
+			const entry = this.#entries.get(key);
+			if (!entry) return;
+			entry.owners.delete(ownerId);
+			if (entry.owners.size > 0 || entry.subscribers.size > 0) return;
+			this.#clearTimer(entry);
+			if (entry.state.kind === "running") {
+				entry.state.run.controller.abort();
+				entry.state.run.detachExternalSignal?.();
+				entry.state.run.end();
+			}
+			this.#entries.delete(key);
+		}
+		#dropOwner(ownerId, owner) {
+			if (this.#owners.get(ownerId) !== owner) return;
+			this.#owners.delete(ownerId);
+			for (const timer of owner.timers.values()) this.#clearTimeout(timer);
+			const keys = /* @__PURE__ */ new Set([
+				...owner.claims.values(),
+				...owner.renderKeys,
+				...owner.hooks.values()
+			]);
+			for (const key of keys) this.#dropOwnedKey(ownerId, key);
+			this.#stopVisibilityListenerIfIdle();
+		}
+		#hasClaimForKey(owner, key) {
+			return Array.from(owner.claims.values()).some((claimKey) => claimKey === key);
+		}
+		#hasHookForKey(owner, key) {
+			return Array.from(owner.hooks.values()).some((hookKey) => hookKey === key);
+		}
+		#ownerHasKey(owner, key) {
+			return owner.renderKeys.has(key) || this.#hasHookForKey(owner, key) || this.#hasClaimForKey(owner, key);
+		}
+		#schedulePoll(key, entry) {
+			this.#schedule(key, entry, this.#withJitter(this.#getIntervalMs(entry)));
+		}
+		#schedule(key, entry, delay) {
+			this.#clearTimer(entry);
+			entry.nextRunAt = this.#now() + delay;
+			if (this.#getVisibilityState() === "hidden") {
+				entry.runOnShow = true;
+				return;
+			}
+			entry.timer = this.#setTimeout(() => {
+				entry.timer = void 0;
+				entry.nextRunAt = void 0;
+				this.runNow(key);
+			}, delay);
+		}
+		#clearTimer(entry, clearNextRun = true) {
+			if (entry.timer !== void 0) {
+				this.#clearTimeout(entry.timer);
+				entry.timer = void 0;
+			}
+			if (clearNextRun) entry.nextRunAt = void 0;
+		}
+		#withJitter(delay) {
+			const multiplier = 1 - this.#jitterRatio + this.#random() * this.#jitterRatio * 2;
+			return Math.max(0, delay * multiplier);
+		}
+		#handleVisibilityChange = () => {
+			const hidden = this.#getVisibilityState() === "hidden";
+			for (const [key, entry] of this.#entries) {
+				if (hidden) {
+					entry.runOnShow = entry.subscribers.size > 0;
+					if (entry.timer !== void 0) this.#clearTimer(entry, entry.failureCount === 0);
+					continue;
+				}
+				if (!entry.runOnShow || entry.subscribers.size === 0) continue;
+				entry.runOnShow = false;
+				const delay = Math.max(0, (entry.nextRunAt ?? this.#now()) - this.#now());
+				if (delay > 0) this.#schedule(key, entry, delay);
+				else this.runNow(key);
+			}
+		};
+		#startVisibilityListener() {
+			if (this.#listeningForVisibility || !this.#visibilityTarget) return;
+			this.#visibilityTarget.addEventListener("visibilitychange", this.#handleVisibilityChange);
+			this.#listeningForVisibility = true;
+		}
+		#stopVisibilityListenerIfIdle() {
+			if (!this.#listeningForVisibility || this.#entries.size > 0 || !this.#visibilityTarget) return;
+			this.#visibilityTarget.removeEventListener("visibilitychange", this.#handleVisibilityChange);
+			this.#listeningForVisibility = false;
+		}
+	};
+	var 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.
+	*/
+	function usePolling(key, intervalSeconds, refresh) {
+		const refreshRef = useLatestRef$3(refresh);
+		(0, react$3.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.
+	*/
+	function usePollScope() {
+		const id = (0, react$3.useId)();
+		const claims = /* @__PURE__ */ new Map();
+		(0, react$3.useLayoutEffect)(() => {
+			poller.commitOwner(id, claims);
+		});
+		(0, react$3.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.
+	*/
+	function usePollKey(scope, key) {
+		const hookId = (0, react$3.useId)();
+		scope?.claims.set(hookId, key);
+		const ownerId = scope?.id;
+		if (ownerId) poller.claimKey(ownerId, hookId, key);
+		(0, react$3.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. */
+	function runPoll(run) {
+		return poller.run(run);
+	}
+	/** Create a force key that identifies a poller-owned refresh. */
+	function createPollForceKey() {
+		return `${POLL_FORCE_KEY_PREFIX}${globalThis.crypto?.randomUUID?.() ?? String(Math.random())}`;
+	}
+	/** Check whether a selector force key originated from the poller. */
+	function isPollForceKey(forceKey) {
+		return forceKey?.startsWith(POLL_FORCE_KEY_PREFIX) ?? false;
+	}
+	/** Extract Retry-After as a non-negative delay in milliseconds. */
+	function parseRetryAfter(response, now = poller.now()) {
+		const value = response.headers.get("Retry-After");
+		if (!value) return;
+		const seconds = Number(value);
+		if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+		const retryAt = Date.parse(value);
+		if (Number.isNaN(retryAt)) return;
+		return Math.max(0, retryAt - now);
+	}
+	/** Keep Retry-After beside an error without changing the error object. */
+	function markRetryAfter(error, response) {
+		const delay = parseRetryAfter(response);
+		if (delay !== void 0 && typeof error === "object" && error !== null) retryAfterByError.set(error, delay);
+		return error;
+	}
+	/** Await a promise while preserving ownership of request cancellation. */
+	async function waitOrAbort(promise, signal) {
+		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. */
+	function clearPolling_TEST() {
+		poller.clear();
+	}
+	//#endregion
 	//#region js/shared/interactivity/store.tsx
 	/**
 	* Key -> atom
 	*/
 	var atomRegistry = /* @__PURE__ */ new Map();
+	/** Request identity -> polling-only trigger atom. */
+	var pollingTriggerRegistry = /* @__PURE__ */ new Map();
 	/**
 	* Key -> atom family
 	*/
@@ -69896,6 +70369,19 @@
 	*/
 	var depsRegistry = /* @__PURE__ */ new Map();
 	/**
+	* Get the trigger used to refresh exactly one selector/request-extras identity.
+	*/
+	function getOrRegisterPollingTrigger(requestKey) {
+		if (!pollingTriggerRegistry.has(requestKey)) pollingTriggerRegistry.set(requestKey, Recoil_index_8({
+			default: {
+				force_key: null,
+				inc: 0
+			},
+			key: `_POLLING_TRIGGER_${requestKey}`
+		}));
+		return pollingTriggerRegistry.get(requestKey);
+	}
+	/**
 	* Registry key types that do not use 'nested' in their key
 	*/
 	var SHARED_KEY_TYPES = ["result-selector", "derived-selector"];
@@ -69914,8 +70400,10 @@
 	* Clear registries - to be used in tests only.
 	*/
 	function clearRegistries_TEST() {
+		clearPolling_TEST();
 		for (const registry of [
 			atomRegistry,
+			pollingTriggerRegistry,
 			atomFamilyRegistry,
 			atomFamilyMembersRegistry,
 			selectorRegistry,
@@ -86223,24 +86711,8 @@ ${String(error)}`;
 		module.exports = set;
 	}));
 	//#endregion
-	//#region js/shared/utils/use-interval.tsx
-	var import_set = /* @__PURE__ */ __toESM(require_set(), 1);
-	/**
-	* Helper hook that runs a function after given intervals
-	*
-	* @param callback the function to run after each interval
-	* @param delay the delay in seconds between each interval
-	*/
-	function useInterval(callback, delay) {
-		(0, react$3.useEffect)(() => {
-			if (delay) {
-				const id = setInterval(callback, delay * 1e3);
-				return () => clearInterval(id);
-			}
-		}, useDeepCompare([delay, callback]));
-	}
-	//#endregion
 	//#region js/shared/utils/deferred.tsx
+	var import_set = /* @__PURE__ */ __toESM(require_set(), 1);
 	var DeferredImpl = class {
 		#resolve;
 		#reject;
@@ -86382,7 +86854,7 @@ ${String(error)}`;
 	* - `values`, values to pass in the request
 	* - `wsClient`, websocket client
 	*/
-	async function fetchDerivedVariable({ cache, extras, force_key, variableUid, values, wsClient }) {
+	async function fetchDerivedVariable({ cache, extras, force_key, signal, variableUid, values, wsClient }) {
 		const cacheControl = cache === null ? { "cache-control": "none" } : void 0;
 		const ws_channel = await wsClient.getChannel();
 		const res = await request(`/api/core/derived-variable/${variableUid}`, {
@@ -86393,34 +86865,50 @@ ${String(error)}`;
 			}),
 			headers: { ...cacheControl },
 			method: HTTP_METHOD.POST
-		}, extras);
+		}, extras, { signal });
 		await handleAuthErrors(res, { authenticationFailureRedirect: "login" });
-		await validateResponse(res, `Failed to fetch the derived variable with uid: ${variableUid}`);
+		try {
+			await validateResponse(res, `Failed to fetch the derived variable with uid: ${variableUid}`);
+		} catch (error) {
+			throw markRetryAfter(error, res);
+		}
 		return res.json();
 	}
+	var pendingFetches = /* @__PURE__ */ new Map();
 	/**
-	* Add a debounced version of the fetch so as to not overload the backend on startup. This needs to be cached per uid
-	* so that we only debounce calls to the same DerivedVariable. Debouncing is done with rxjs as everything here is
-	* promise based and async
+	* Wait 10 ms so matching selector reads share one fetch. A running fetch stays separate.
 	*/
-	var debouncedFetchSubjects = {};
-	var debouncedFetchCache = {};
-	async function debouncedFetchDerivedVariable({ variableUid, selectorKey, values, wsClient, extras, cache, force_key }) {
-		if (!debouncedFetchSubjects[selectorKey]) {
-			debouncedFetchSubjects[selectorKey] = new BehaviorSubject(null);
-			debouncedFetchCache[selectorKey] = debouncedFetchSubjects[selectorKey].pipe(filter((args) => !!args), debounceTime(10), switchMap((args) => from(fetchDerivedVariable(args))), share());
-		}
-		debouncedFetchSubjects[selectorKey].next({
-			cache,
-			extras,
-			force_key,
-			selectorKey,
-			values,
-			variableUid,
-			wsClient
+	function startPendingFetch(selectorKey, pending) {
+		if (pendingFetches.get(selectorKey) !== pending) return;
+		pendingFetches.delete(selectorKey);
+		fetchDerivedVariable(pending.args).then((response) => {
+			for (const waiter of pending.waiters) waiter.resolve(response);
+		}, (error) => {
+			for (const waiter of pending.waiters) waiter.reject(error);
 		});
+	}
+	async function debouncedFetchDerivedVariable(args) {
 		return new Promise((resolve, reject) => {
-			debouncedFetchCache[selectorKey].pipe(take(1)).subscribe(resolve, reject);
+			const pending = pendingFetches.get(args.selectorKey);
+			if (pending) {
+				if (pending.timer !== void 0) clearTimeout(pending.timer);
+				pending.args = args;
+				pending.waiters.push({
+					reject,
+					resolve
+				});
+				pending.timer = setTimeout(() => startPendingFetch(args.selectorKey, pending), 10);
+				return;
+			}
+			const next = {
+				args,
+				waiters: [{
+					reject,
+					resolve
+				}]
+			};
+			next.timer = setTimeout(() => startPendingFetch(args.selectorKey, next), 10);
+			pendingFetches.set(args.selectorKey, next);
 		});
 	}
 	/**
@@ -86502,9 +86990,11 @@ ${String(error)}`;
 	* @param resolvedVariables resolved values of dependant variables - turned into primitives and Resolved forms
 	* @param get getter function to resolve atoms to values
 	* @param triggerList list of trigger info objects
-	* @param triggers list of triggers to register as dependencies; first one is expected to be the self-trigger
+	* @param selfTriggers triggers owned by this request identity
+	* @param childTriggers triggers owned by nested variables
 	*/
-	function resolveDerivedValue({ key, variables, deps, resolvedVariables, resolutionStrategy, triggerList, triggers }) {
+	function resolveDerivedValue({ key, variables, deps, resolvedVariables, resolutionStrategy, triggerList, selfTriggers, childTriggers }) {
+		const triggers = [...selfTriggers, ...childTriggers];
 		/**
 		* Array of values:
 		* - primitive values are resolved to themselves
@@ -86565,16 +87055,17 @@ ${String(error)}`;
 				};
 			}
 			const previousTriggerCounters = previousEntry.args.slice(previousEntry.args.length - triggers.length);
+			const dependenciesChanged = !(0, import_isEqual.default)(previousEntry.args.slice(0, -triggers.length), relevantValues.slice(0, -triggers.length));
 			let selfTriggerForceKey = null;
-			for (const [idx, triggerValue] of triggers.entries())
+			for (const [idx, triggerValue] of dependenciesChanged ? [] : triggers.entries())
  /**
 			*  If any of the nested trigger value has changed (this execution was caused by a trigger)
 			*  handle the force_key appropriately
 			*/
 			if (triggerValue.inc !== previousTriggerCounters[idx]) {
-				if (idx === 0) selfTriggerForceKey = triggerValue.force_key;
+				if (idx < selfTriggers.length) selfTriggerForceKey = triggerValue.force_key;
 				else if (triggerValue.force_key) {
-					const triggerInfo = triggerList[idx - 1];
+					const triggerInfo = triggerList[idx - selfTriggers.length];
 					if (triggerInfo.path.length === 0) selfTriggerForceKey = triggerValue.force_key;
 					else (0, import_set.default)(values, [...triggerInfo.path, "force_key"], triggerValue.force_key);
 				}
@@ -86622,9 +87113,9 @@ ${String(error)}`;
 					}));
 					const selfTrigger = get(getOrRegisterTrigger(variable));
 					const selectorKey = key + extrasSerializable.toJSON();
+					const pollingTrigger = get(getOrRegisterPollingTrigger(getRegistryKey(variable, "derived-selector") + extrasSerializable.toJSON()));
 					const triggerList = buildTriggerList(variable.variables);
-					const triggers = registerChildTriggers(triggerList, get);
-					triggers.unshift(selfTrigger);
+					const childTriggers = registerChildTriggers(triggerList, get);
 					return resolveDerivedValue({
 						key: selectorKey,
 						variables: variable.variables,
@@ -86635,7 +87126,8 @@ ${String(error)}`;
 							get
 						},
 						triggerList,
-						triggers
+						selfTriggers: [selfTrigger, pollingTrigger],
+						childTriggers
 					});
 				},
 				key: nanoid$1()
@@ -86669,68 +87161,104 @@ ${String(error)}`;
 						error.selectorExtras = extrasSerializable.toJSON();
 						throw error;
 					};
-					const handleError = (func) => {
-						try {
-							return func();
-						} catch (e) {
-							throwError(e);
-						}
-					};
 					let derivedResult = get(getOrRegisterDerivedVariableResult(variable, wsClient, taskContext, extrasSerializable.extras));
 					if (derivedResult.type === "previous") return derivedResult.entry.result;
 					const { extras } = extrasSerializable;
-					let variableResponse = null;
-					let shouldFetchTask = false;
-					if (derivedResult.type === "cached") try {
-						const response = await derivedResult.response.getValue();
-						shouldFetchTask = true;
-						if (!response.ok) throwError(new Error(response.value));
-						variableResponse = response.value;
-						derivedResult = derivedResult.currentResult;
-					} catch (e) {
-						throwError(e);
-					}
-					else variableResponse = await handleError(() => debouncedFetchDerivedVariable({
-						cache: variable.cache,
-						extras,
-						force_key: derivedResult.selfTriggerForceKey,
-						selectorKey,
-						values: normalizeRequest(cleanArgs(derivedResult.values), variable.variables),
-						variableUid: variable.uid,
-						wsClient
-					}));
-					let variableValue = NOT_SET$1;
-					taskContext.cleanupRunningTasks(variable.uid);
-					if (isTaskResponse(variableResponse)) {
-						const taskId = variableResponse.task_id;
-						if (shouldFetchTask) try {
-							const taskResult = await fetchTaskResult(taskId, extras);
-							if (taskResult.status === "ok") variableValue = taskResult.result;
-						} catch (e) {
-							throwError(e);
+					const currentResult = derivedResult.type === "current" ? derivedResult : void 0;
+					const pollRequest = isPollForceKey(currentResult?.selfTriggerForceKey);
+					const inputKey = currentResult ? JSON.stringify({
+						forceKey: currentResult.selfTriggerForceKey,
+						values: currentResult.values
+					}) : void 0;
+					const fetchValue = async (signal) => {
+						let variableResponse = null;
+						let shouldFetchTask = false;
+						if (derivedResult.type === "cached") {
+							const response = await derivedResult.response.getValue();
+							shouldFetchTask = true;
+							if (!response.ok) throwError(new Error(response.value));
+							variableResponse = response.value;
+							derivedResult = derivedResult.currentResult;
+						} else {
+							signal.addEventListener("abort", () => taskContext.cleanupRunningTasks(variable.uid), { once: true });
+							variableResponse = await debouncedFetchDerivedVariable({
+								cache: variable.cache,
+								extras,
+								force_key: currentResult.selfTriggerForceKey,
+								selectorKey,
+								signal,
+								values: normalizeRequest(cleanArgs(currentResult.values), variable.variables),
+								variableUid: variable.uid,
+								wsClient
+							});
 						}
-						if (variableValue === NOT_SET$1) {
-							taskContext.startTask(taskId, variable.uid, getRegistryKey(variable, "trigger"));
-							try {
-								await wsClient.waitForTask(taskId);
-							} catch (e) {
-								if (e instanceof TaskError) throwError(e);
-								return null;
-							} finally {
-								taskContext.endTask(taskId);
+						signal?.throwIfAborted();
+						let variableValue = NOT_SET$1;
+						taskContext.cleanupRunningTasks(variable.uid);
+						if (isTaskResponse(variableResponse)) {
+							const taskId = variableResponse.task_id;
+							if (shouldFetchTask) {
+								const taskResult = await fetchTaskResult(taskId, {
+									...extras,
+									signal
+								});
+								if (taskResult.status === "ok") variableValue = taskResult.result;
 							}
-							variableValue = await handleError(async () => {
-								const result = await fetchTaskResult(taskId, extras);
+							if (variableValue === NOT_SET$1) {
+								taskContext.startTask(taskId, variable.uid, getRegistryKey(variable, "trigger"));
+								try {
+									await waitOrAbort(wsClient.waitForTask(taskId), signal);
+								} catch (e) {
+									if (e instanceof TaskError || isAbortError(e)) throw e;
+									return null;
+								} finally {
+									taskContext.endTask(taskId);
+								}
+								const result = await fetchTaskResult(taskId, {
+									...extras,
+									signal
+								});
 								if (result.status === "not_found") throw new Error("Task result not found");
-								return result.result;
-							});
-						}
-					} else variableValue = variableResponse.value;
-					depsRegistry.set(derivedResult.depsKey, {
-						args: derivedResult.relevantValues,
-						result: variableValue
-					});
-					return variableValue;
+								variableValue = result.result;
+							}
+						} else variableValue = variableResponse.value;
+						return variableValue;
+					};
+					if (!currentResult) try {
+						const variableValue = await fetchValue();
+						depsRegistry.set(derivedResult.depsKey, {
+							args: derivedResult.relevantValues,
+							result: variableValue
+						});
+						return variableValue;
+					} catch (error) {
+						return throwError(error);
+					}
+					const runResult = currentResult;
+					try {
+						return await runPoll({
+							cause: pollRequest ? "poll" : "dependency",
+							inputKey,
+							key: selectorKey,
+							read: () => {
+								const saved = depsRegistry.get(runResult.depsKey);
+								return saved ? {
+									found: true,
+									value: saved.result
+								} : { found: false };
+							},
+							signal: extras.signal ?? void 0,
+							work: fetchValue,
+							write: (variableValue) => {
+								depsRegistry.set(runResult.depsKey, {
+									args: runResult.relevantValues,
+									result: variableValue
+								});
+							}
+						});
+					} catch (error) {
+						return throwError(error);
+					}
 				},
 				key: nanoid$1()
 			}));
@@ -86782,7 +87310,7 @@ ${String(error)}`;
 	* Otherwise, returns an object with values so be sent to the backend
 	* and handles to resolve the cached promise to the result.
 	*/
-	function preloadDerivedValue({ key, variables, deps, triggerList, triggers, snapshot, params }) {
+	function preloadDerivedValue({ key, variables, deps, triggerList, selfTriggers, childTriggers, snapshot, params }) {
 		const derivedResult = resolveDerivedValue({
 			key,
 			variables,
@@ -86794,7 +87322,8 @@ ${String(error)}`;
 				params
 			},
 			triggerList,
-			triggers
+			selfTriggers,
+			childTriggers
 		});
 		if (derivedResult.type === "previous") return null;
 		return {
@@ -86807,16 +87336,16 @@ ${String(error)}`;
 	*/
 	function preloadDerivedVariable(variable, snapshot, params) {
 		const key = getRegistryKey(variable, "result-selector") + new RequestExtrasSerializable({}).toJSON();
-		const triggerList = [...buildTriggerList(variable.variables), {
-			path: [],
-			variable
-		}];
-		const triggers = triggerList.map((ti) => resolveTriggerStatic(getOrRegisterTrigger(ti.variable), snapshot));
+		const requestKey = getRegistryKey(variable, "derived-selector") + new RequestExtrasSerializable({}).toJSON();
+		const triggerList = buildTriggerList(variable.variables);
+		const selfTriggers = [resolveTriggerStatic(getOrRegisterTrigger(variable), snapshot), resolveTriggerStatic(getOrRegisterPollingTrigger(requestKey), snapshot)];
+		const childTriggers = triggerList.map((ti) => resolveTriggerStatic(getOrRegisterTrigger(ti.variable), snapshot));
 		return preloadDerivedValue({
 			key,
 			variables: variable.variables,
 			deps: variable.deps,
-			triggers,
+			selfTriggers,
+			childTriggers,
 			triggerList,
 			snapshot,
 			params
@@ -86830,14 +87359,17 @@ ${String(error)}`;
 	* @param taskContext global task context
 	* @param search search query
 	* @param extras request extras to be merged into the options
+	* @param pollScope render-local scope for requests started before commit
 	*/
-	function useDerivedVariable(variable, WsClient, taskContext, extras, pollingInterval) {
+	function useDerivedVariable(variable, WsClient, taskContext, extras, pollingInterval, pollScope) {
 		const dvSelector = getOrRegisterDerivedVariable(variable, WsClient, taskContext, extras);
-		const triggerUpdates = Recoil_index_24((0, react$3.useMemo)(() => getOrRegisterTrigger(variable), []));
-		useInterval((0, react$3.useCallback)((force = true) => triggerUpdates((val) => ({
-			force_key: force ? nanoid$1() : null,
+		const pollingKey = getRegistryKey(variable, "derived-selector") + new RequestExtrasSerializable(extras).toJSON();
+		usePollKey(pollScope, pollingKey);
+		const triggerUpdates = Recoil_index_24((0, react$3.useMemo)(() => getOrRegisterPollingTrigger(pollingKey), [pollingKey]));
+		usePolling(pollingKey, pollingInterval, (0, react$3.useCallback)(() => triggerUpdates((val) => ({
+			force_key: createPollForceKey(),
 			inc: val.inc + 1
-		})), [triggerUpdates]), pollingInterval);
+		})), [triggerUpdates]));
 		return dvSelector;
 	}
 	//#endregion
@@ -87856,6 +88388,37 @@ ${String(error)}`;
 	* This allows Recoil to properly release instances when components unmount.
 	*/
 	var streamSelectorFamilyRegistry = /* @__PURE__ */ new Map();
+	var STREAM_EVENT_TYPES = /* @__PURE__ */ new Set([
+		"add",
+		"remove",
+		"clear",
+		"replace",
+		"json_snapshot",
+		"json_patch",
+		"reconnect",
+		"error"
+	]);
+	/**
+	* Parse an SSE message into a supported StreamEvent.
+	*
+	* Comment-only SSE frames are delivered by fetch-event-source as messages with
+	* empty data. They are transport heartbeats rather than application events.
+	*/
+	function parseStreamEventMessage(message) {
+		if (message.data.trim() === "") return null;
+		let parsed;
+		try {
+			parsed = JSON.parse(message.data);
+		} catch (parseError) {
+			console.error("Failed to parse SSE event:", parseError, message.data);
+			return null;
+		}
+		if (parsed === null || typeof parsed !== "object" || !("type" in parsed) || typeof parsed.type !== "string" || !STREAM_EVENT_TYPES.has(parsed.type)) {
+			console.error("Unsupported SSE event:", parsed);
+			return null;
+		}
+		return parsed;
+	}
 	/**
 	* Extract a key from an item using the key_accessor path.
 	*
@@ -87997,12 +88560,17 @@ ${String(error)}`;
 	* @returns The value to expose to components
 	*/
 	function getStreamValue(state, keyAccessor) {
+		if (state.status === "error") throw new UserError(state.error ?? "Stream failed");
 		if (keyAccessor !== null && state.data !== null && typeof state.data === "object" && !Array.isArray(state.data)) return Object.values(state.data);
 		return state.data;
 	}
 	var MAX_RETRIES = 5;
 	var BASE_DELAY_MS = 1e3;
 	var MAX_DELAY_MS = 3e4;
+	/** Error that should stop the SSE connection rather than be retried. */
+	var FatalStreamError = class extends Error {};
+	/** Error that should be handled by the SSE retry policy. */
+	var RetriableStreamError = class extends Error {};
 	/**
 	* Calculate exponential backoff delay.
 	*/
@@ -88032,52 +88600,62 @@ ${String(error)}`;
 		let retryCount = 0;
 		let isFirstMessage = true;
 		let currentState = INITIAL_CONNECTED_STATE;
+		let terminalErrorReported = false;
 		const normalizedValues = normalizeRequest(params.resolvedValues, params.variables);
+		const reportTerminalError = (error) => {
+			if (terminalErrorReported) return;
+			terminalErrorReported = true;
+			callbacks.onError(error instanceof Error ? error.message : String(error));
+		};
 		fetchEventSource(`/api/core/stream/${params.uid}`, {
+			...params.extras,
 			method: HTTP_METHOD.POST,
 			body: JSON.stringify({ values: normalizedValues }),
 			signal: controller.signal,
 			onopen: async (response) => {
-				if (response.ok) {
-					retryCount = 0;
-					return;
-				}
+				if (response.ok) return;
 				if (await handleAuthErrors(response, { authenticationFailureRedirect: "login" })) controller.abort();
 				throw /* @__PURE__ */ new Error(`Stream request failed: ${response.status} ${response.statusText}`);
 			},
 			onmessage: (msg) => {
-				let event;
-				try {
-					event = JSON.parse(msg.data);
-				} catch (parseError) {
-					console.error("Failed to parse SSE event:", parseError, msg.data);
-					return;
-				}
+				const event = parseStreamEventMessage(msg);
+				if (event === null) return;
 				if (event.type === "reconnect") {
 					console.info("StreamVariable: Server requested reconnect, reconnecting...");
-					throw new Error("Server requested reconnect");
+					throw new RetriableStreamError("Server requested reconnect");
 				}
-				currentState = applyStreamEvent(currentState, event, params.keyAccessor);
+				if (event.type === "error") throw new FatalStreamError(typeof event.data === "string" ? event.data : "Unknown error");
+				const nextState = applyStreamEvent(currentState, event, params.keyAccessor);
+				if (nextState === currentState || nextState.status === "error") throw new FatalStreamError(nextState.error ?? `Stream event "${event.type}" could not be applied`);
+				retryCount = 0;
+				currentState = nextState;
 				if (isFirstMessage) {
 					isFirstMessage = false;
 					callbacks.onFirstData(currentState);
 				} else callbacks.onUpdate(currentState);
 			},
 			onerror: (err) => {
-				if (controller.signal.aborted) return;
+				if (controller.signal.aborted) throw err;
+				if (err instanceof FatalStreamError) {
+					reportTerminalError(err);
+					throw err;
+				}
 				retryCount++;
 				if (retryCount > MAX_RETRIES) {
-					callbacks.onError(err instanceof Error ? err.message : String(err));
-					return;
+					reportTerminalError(err);
+					throw err;
 				}
 				const delay = getBackoffDelay(retryCount - 1);
 				console.warn(`Stream connection failed, retrying in ${delay}ms (attempt ${retryCount}/${MAX_RETRIES})...`);
 				return delay;
 			},
-			onclose: () => {},
+			onclose: () => {
+				throw new RetriableStreamError("Stream closed unexpectedly");
+			},
 			fetch: request,
-			...params.extras,
 			headers: params.extras.headers
+		}).catch((error) => {
+			if (!controller.signal.aborted) reportTerminalError(error);
 		});
 		return {
 			cleanup: () => {
@@ -88098,10 +88676,8 @@ ${String(error)}`;
 		return ({ setSelf }) => {
 			const params = deserializeAtomParams(atomKey);
 			let resolveInitialData = null;
-			let rejectInitialData = null;
-			setSelf(new Promise((resolve, reject) => {
+			setSelf(new Promise((resolve) => {
 				resolveInitialData = resolve;
-				rejectInitialData = reject;
 			}));
 			const startConnection = () => {
 				return startStreamConnection(params, {
@@ -88109,7 +88685,6 @@ ${String(error)}`;
 						if (resolveInitialData) {
 							resolveInitialData(state);
 							resolveInitialData = null;
-							rejectInitialData = null;
 						}
 						setSelf(state);
 					},
@@ -88117,15 +88692,16 @@ ${String(error)}`;
 						setSelf(state);
 					},
 					onError: (error) => {
-						if (rejectInitialData) {
-							rejectInitialData(new Error(error));
-							resolveInitialData = null;
-							rejectInitialData = null;
-						} else setSelf({
+						const errorState = {
 							data: void 0,
 							status: "error",
 							error
-						});
+						};
+						if (resolveInitialData) {
+							resolveInitialData(errorState);
+							resolveInitialData = null;
+						}
+						setSelf(errorState);
 					}
 				});
 			};
@@ -89599,6 +90175,22 @@ ${String(error)}`;
 		return theme;
 	}
 	//#endregion
+	//#region js/shared/utils/use-interval.tsx
+	/**
+	* Helper hook that runs a function after given intervals
+	*
+	* @param callback the function to run after each interval
+	* @param delay the delay in seconds between each interval
+	*/
+	function useInterval(callback, delay) {
+		(0, react$3.useEffect)(() => {
+			if (delay) {
+				const id = setInterval(callback, delay * 1e3);
+				return () => clearInterval(id);
+			}
+		}, useDeepCompare([delay, callback]));
+	}
+	//#endregion
 	//#region js/shared/utils/use-previous.tsx
 	/**
 	* A helper hook to keep track of the previous value of a variable.
@@ -90571,6 +91163,12 @@ ${String(error)}`;
 		return key;
 	}
 	/**
+	* Generate the request identity used for polling and cancellation.
+	*/
+	function getServerComponentRequestKey(uid, loopInstanceUid, extras) {
+		return getComponentRegistryKey(uid, false, loopInstanceUid) + new RequestExtrasSerializable(extras).toJSON();
+	}
+	/**
 	* Fetch a component from the backend, expects a component instance to be returned.
 	*
 	* @param component the component to fetch
@@ -90579,7 +91177,7 @@ ${String(error)}`;
 	* @param extras request extras to be merged into the options
 	* @param wsClient websocket client
 	*/
-	async function fetchFunctionComponent(component, values, uid, extras, wsClient) {
+	async function fetchFunctionComponent(component, values, uid, extras, wsClient, signal) {
 		const ws_channel = await wsClient.getChannel();
 		const res = await request(`/api/core/components/${component}`, {
 			body: JSON.stringify({
@@ -90588,9 +91186,13 @@ ${String(error)}`;
 				ws_channel
 			}),
 			method: HTTP_METHOD.POST
-		}, extras);
+		}, extras, { signal });
 		await handleAuthErrors(res, { authenticationFailureRedirect: "login" });
-		await validateResponse(res, `Failed to fetch the component: ${component}`);
+		try {
+			await validateResponse(res, `Failed to fetch the component: ${component}`);
+		} catch (error) {
+			throw markRetryAfter(error, res);
+		}
 		return await res.json();
 	}
 	function getOrRegisterComponentTrigger(uid, loop_instance_uid) {
@@ -90626,25 +91228,19 @@ ${String(error)}`;
 					error.selectorExtras = extrasSerializable.toJSON();
 					throw error;
 				};
-				const handleError = (func) => {
-					try {
-						return func();
-					} catch (e) {
-						throwError(e);
-					}
-				};
+				const selectorKey = key + extrasSerializable.toJSON();
 				const resolvedKwargs = await Promise.all(Object.entries(dynamicKwargs).map(async ([k, value]) => {
 					return [k, isVariable(value) ? await resolveVariable(value, wsClient, taskContext, currentExtras) : value];
 				})).then((entries) => Object.fromEntries(entries));
 				const resolvedKwargsList = Object.values(resolvedKwargs);
 				const kwargsList = Object.values(dynamicKwargs);
 				const selfTrigger = get(getOrRegisterComponentTrigger(uid, loop_instance_uid));
+				const pollingTrigger = get(getOrRegisterPollingTrigger(selectorKey));
 				const triggerList = buildTriggerList(kwargsList);
-				const triggers = registerChildTriggers(triggerList, get);
-				triggers.unshift(selfTrigger);
+				const childTriggers = registerChildTriggers(triggerList, get);
 				const { extras } = extrasSerializable;
 				let derivedResult = resolveDerivedValue({
-					key,
+					key: selectorKey,
 					variables: kwargsList,
 					deps: kwargsList,
 					resolvedVariables: resolvedKwargsList,
@@ -90653,59 +91249,97 @@ ${String(error)}`;
 						get
 					},
 					triggerList,
-					triggers
+					selfTriggers: [selfTrigger, pollingTrigger],
+					childTriggers
 				});
 				if (derivedResult.type === "previous") return derivedResult.entry.result;
-				let result = NOT_SET;
-				let shouldFetchTask = false;
-				if (derivedResult.type === "cached") try {
-					const response = await derivedResult.response.getValue();
-					shouldFetchTask = true;
-					if (!response.ok) throwError(new Error(response.value));
-					result = response.value;
-					derivedResult = derivedResult.currentResult;
-				} catch (e) {
-					throwError(e);
-				}
-				else {
-					const kwargValues = cleanKwargs(Object.keys(dynamicKwargs).reduce((acc, k, idx) => {
-						acc[k] = derivedResult.values[idx];
-						return acc;
-					}, {}));
-					result = await handleError(() => fetchFunctionComponent(name, normalizeRequest(kwargValues, dynamicKwargs), uid, extras, wsClient));
-				}
-				taskContext.cleanupRunningTasks(key);
-				if (isTaskResponse$1(result)) {
-					const taskId = result.task_id;
-					result = NOT_SET;
-					if (shouldFetchTask) try {
-						const taskResult = await fetchTaskResult(taskId, extras);
-						if (taskResult.status === "ok") result = taskResult.result;
-					} catch (e) {
-						throwError(e);
-					}
-					if (result === NOT_SET) {
-						taskContext.startTask(taskId, key, getComponentRegistryKey(uid, true));
-						try {
-							await wsClient.waitForTask(taskId);
-						} catch (e) {
-							throwError(e);
-						} finally {
-							taskContext.endTask(taskId);
+				const currentResult = derivedResult.type === "current" ? derivedResult : void 0;
+				const pollRequest = isPollForceKey(currentResult?.selfTriggerForceKey);
+				const inputKey = currentResult ? JSON.stringify({
+					forceKey: currentResult.selfTriggerForceKey,
+					values: currentResult.values
+				}) : void 0;
+				const fetchComponent = async (signal) => {
+					let result = NOT_SET;
+					let shouldFetchTask = false;
+					if (derivedResult.type === "cached") {
+						const response = await derivedResult.response.getValue();
+						shouldFetchTask = true;
+						if (!response.ok) throwError(new Error(response.value));
+						result = response.value;
+						derivedResult = derivedResult.currentResult;
+					} else {
+						signal.addEventListener("abort", () => taskContext.cleanupRunningTasks(key), { once: true });
+						result = await fetchFunctionComponent(name, normalizeRequest(cleanKwargs(Object.keys(dynamicKwargs).reduce((acc, k, idx) => {
+							acc[k] = currentResult.values[idx];
+							return acc;
+						}, {})), dynamicKwargs), uid, extras, wsClient, signal);
+					}
+					signal?.throwIfAborted();
+					taskContext.cleanupRunningTasks(key);
+					if (isTaskResponse$1(result)) {
+						const taskId = result.task_id;
+						result = NOT_SET;
+						if (shouldFetchTask) {
+							const taskResult = await fetchTaskResult(taskId, {
+								...extras,
+								signal
+							});
+							if (taskResult.status === "ok") result = taskResult.result;
+						}
+						if (result === NOT_SET) {
+							taskContext.startTask(taskId, key, getComponentRegistryKey(uid, true));
+							try {
+								await waitOrAbort(wsClient.waitForTask(taskId), signal);
+							} finally {
+								taskContext.endTask(taskId);
+							}
+							const response = await fetchTaskResult(taskId, {
+								...extras,
+								signal
+							});
+							if (response.status === "not_found") throw new Error("Task result not found");
+							result = response.result;
 						}
-						result = await handleError(async () => {
-							const res = await fetchTaskResult(taskId, extras);
-							if (res.status === "not_found") throw new Error("Task result not found");
-							return res.result;
-						});
 					}
+					if (result !== NOT_SET && result !== null) result = denormalize(result.data, result.lookup);
+					return result;
+				};
+				if (!currentResult) try {
+					const result = await fetchComponent();
+					depsRegistry.set(derivedResult.depsKey, {
+						args: derivedResult.relevantValues,
+						result
+					});
+					return result;
+				} catch (error) {
+					return throwError(error);
+				}
+				const runResult = currentResult;
+				try {
+					return await runPoll({
+						cause: pollRequest ? "poll" : "dependency",
+						inputKey,
+						key: selectorKey,
+						read: () => {
+							const saved = depsRegistry.get(runResult.depsKey);
+							return saved ? {
+								found: true,
+								value: saved.result
+							} : { found: false };
+						},
+						signal: extras.signal ?? void 0,
+						work: fetchComponent,
+						write: (result) => {
+							depsRegistry.set(runResult.depsKey, {
+								args: runResult.relevantValues,
+								result
+							});
+						}
+					});
+				} catch (error) {
+					return throwError(error);
 				}
-				if (result !== NOT_SET && result !== null) result = denormalize(result.data, result.lookup);
-				depsRegistry.set(key, {
-					args: derivedResult.relevantValues,
-					result
-				});
-				return result;
 			},
 			key
 		}));
@@ -90717,7 +91351,7 @@ ${String(error)}`;
 		return selectorInstance;
 	}
 	function preloadServerComponent(component, snapshot, params) {
-		const key = getComponentRegistryKey(component.uid, false, component.loop_instance_uid);
+		const key = getServerComponentRequestKey(component.uid, component.loop_instance_uid, {});
 		const kwargsList = Object.values(component.props.dynamic_kwargs);
 		const triggerList = buildTriggerList(kwargsList);
 		return preloadDerivedValue({
@@ -90725,7 +91359,8 @@ ${String(error)}`;
 			variables: kwargsList,
 			deps: kwargsList,
 			triggerList,
-			triggers: [...triggerList.map((ti) => resolveTriggerStatic(getOrRegisterTrigger(ti.variable), snapshot)), resolveTriggerStatic(getOrRegisterComponentTrigger(component.uid), snapshot)],
+			selfTriggers: [resolveTriggerStatic(getOrRegisterComponentTrigger(component.uid, component.loop_instance_uid), snapshot), resolveTriggerStatic(getOrRegisterPollingTrigger(key), snapshot)],
+			childTriggers: triggerList.map((ti) => resolveTriggerStatic(getOrRegisterTrigger(ti.variable), snapshot)),
 			snapshot,
 			params
 		});
@@ -90743,6 +91378,8 @@ ${String(error)}`;
 		const { client: wsClient } = (0, react$3.useContext)(websocketCtx);
 		const taskContext = useTaskContext();
 		const variablesContext = (0, react$3.useContext)(variablesCtx);
+		const requestKey = getServerComponentRequestKey(uid, loop_instance_uid, extras);
+		usePollKey(variablesContext?.pollScope, requestKey);
 		const bus = useEventBus();
 		variablesContext?.variables.current.add(getComponentRegistryKey(uid));
 		(0, react$3.useEffect)(() => {
@@ -90782,6 +91419,18 @@ ${String(error)}`;
 			}));
 		}, [uid]);
 	}
+	/**
+	* Refresh one server-component/request-extras identity for polling.
+	*/
+	function usePollServerComponent(uid, loopInstanceUid, extras) {
+		const requestKey = getServerComponentRequestKey(uid, loopInstanceUid, extras);
+		return Recoil_index_31(({ set }) => () => {
+			set(getOrRegisterPollingTrigger(requestKey), (triggerIndexValue) => ({
+				force_key: createPollForceKey(),
+				inc: triggerIndexValue.inc + 1
+			}));
+		}, [requestKey]);
+	}
 	//#endregion
 	//#region js/shared/center/center.tsx
 	var Center = dist_default.div`
@@ -91477,6 +92126,10 @@ ${String(error)}`;
 		}
 		const { hasRunningTasks, cleanupRunningTasks } = useTaskContext();
 		const variables = (0, react$3.useRef)(/* @__PURE__ */ new Set());
+		const variableContext = {
+			pollScope: usePollScope(),
+			variables
+		};
 		(0, react$3.useEffect)(() => {
 			return () => {
 				if (variables.current.size > 0 && hasRunningTasks()) cleanupRunningTasks(...variables.current.values());
@@ -91491,7 +92144,7 @@ ${String(error)}`;
 				...fallbackProps
 			}),
 			onReset: onResetErrorBoundary
-		}, /* @__PURE__ */ React.createElement(fallbackCtx.Provider, { value: { suspend } }, /* @__PURE__ */ React.createElement(variablesCtx.Provider, { value: { variables } }, /* @__PURE__ */ React.createElement(react$3.Suspense, { fallback }, component))));
+		}, /* @__PURE__ */ React.createElement(fallbackCtx.Provider, { value: { suspend } }, /* @__PURE__ */ React.createElement(variablesCtx.Provider, { value: variableContext }, /* @__PURE__ */ React.createElement(react$3.Suspense, { fallback }, component))));
 	}
 	function useResolveDynamicKwargPollingIntervals(dynamicKwargs) {
 		return (0, react$3.useMemo)(() => {
@@ -91516,9 +92169,12 @@ ${String(error)}`;
 	function PythonWrapper(props) {
 		const component = useServerComponent(props.name, props.uid, props.dynamic_kwargs, props.component.loop_instance_uid);
 		const refresh = useRefreshServerComponent(props.uid, props.component.loop_instance_uid);
+		const extras = useRequestExtras();
+		const poll = usePollServerComponent(props.uid, props.component.loop_instance_uid, extras);
 		const [componentPollingInterval] = useVariable(props.polling_interval ?? null);
 		const resolvedKwargPollingIntervals = useResolveDynamicKwargPollingIntervals(props.dynamic_kwargs);
-		useInterval(refresh, (0, react$3.useMemo)(() => computePollingInterval(resolvedKwargPollingIntervals, componentPollingInterval), [resolvedKwargPollingIntervals, componentPollingInterval]));
+		const pollingInterval = (0, react$3.useMemo)(() => computePollingInterval(resolvedKwargPollingIntervals, componentPollingInterval), [resolvedKwargPollingIntervals, componentPollingInterval]);
+		usePolling(getServerComponentRequestKey(props.uid, props.component.loop_instance_uid, extras), pollingInterval, poll);
 		if (component === null) return null;
 		if (isRawString(component)) return /* @__PURE__ */ React.createElement(React.Fragment, null, component.props.content);
 		if (isInvalidComponent(component)) return /* @__PURE__ */ React.createElement(ErrorDisplay$1, {
@@ -92289,24 +92945,49 @@ ${String(error)}`;
 	* @param signal AbortSignal to abort the generator
 	*/
 	async function* ndjson(response, signal) {
+		if (!response.body) throw new Error("Route response body is missing");
 		const reader = response.body.getReader();
 		const newline = /\r?\n/;
 		const decoder = new TextDecoder();
 		let buffer = "";
-		while (true) {
-			if (signal?.aborted) throw new DOMException("The operation was aborted", "AbortError");
-			const { done, value } = await reader.read();
-			if (done) {
-				if (buffer.length > 0) yield JSON.parse(buffer);
-				return;
+		let cancelPromise;
+		const abortError = () => new DOMException("The operation was aborted", "AbortError");
+		const cancel = (reason) => {
+			cancelPromise ??= reader.cancel(reason).catch(() => void 0);
+			return cancelPromise;
+		};
+		const abort = () => {
+			cancel(signal?.reason ?? abortError());
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		try {
+			while (true) {
+				if (signal?.aborted) throw abortError();
+				const { done, value } = await reader.read();
+				if (signal?.aborted) throw abortError();
+				if (done) {
+					if (buffer.length > 0) yield JSON.parse(buffer);
+					return;
+				}
+				const chunk = decoder.decode(value, { stream: true });
+				buffer += chunk;
+				const parts = buffer.split(newline);
+				buffer = parts.pop();
+				for (const part of parts) yield JSON.parse(part);
 			}
-			const chunk = decoder.decode(value, { stream: true });
-			buffer += chunk;
-			const parts = buffer.split(newline);
-			buffer = parts.pop();
-			for (const part of parts) yield JSON.parse(part);
+		} catch (error) {
+			await cancel(error);
+			throw error;
+		} finally {
+			signal?.removeEventListener("abort", abort);
+			reader.releaseLock();
 		}
 	}
+	function rejectPending(handle, error) {
+		if (handle.status !== "pending") return;
+		handle.getValue().catch(() => void 0);
+		handle.reject(error);
+	}
 	/**
 	* Fetch route data from the server.
 	*
@@ -92394,8 +93075,6 @@ ${String(error)}`;
 		if (!response.ok) throw new LoaderError((await response.json()).detail);
 		const template = deferred();
 		const onLoadActions = deferred();
-		const resolvedDvs = /* @__PURE__ */ new Set();
-		const resolvedPyComponents = /* @__PURE__ */ new Set();
 		queueMicrotask(async () => {
 			try {
 				for await (const data of ndjson(response, signal)) {
@@ -92405,20 +93084,14 @@ ${String(error)}`;
 						template.resolve(component);
 					}
 					if (chunk.type === "actions") onLoadActions.resolve(actions.flatMap((a) => isAnnotatedAction(a) ? chunk.actions[a.uid] : a));
-					if (chunk.type === "derived_variable") {
-						dvHandlesByUid[chunk.uid]?.handle.resolve(chunk.result);
-						resolvedDvs.add(chunk.uid);
-					}
-					if (chunk.type === "py_component") {
-						pyHandlesByUid[chunk.uid]?.handle.resolve(chunk.result);
-						resolvedPyComponents.add(chunk.uid);
-					}
+					if (chunk.type === "derived_variable") dvHandlesByUid[chunk.uid]?.handle.resolve(chunk.result);
+					if (chunk.type === "py_component") pyHandlesByUid[chunk.uid]?.handle.resolve(chunk.result);
 				}
 			} catch (e) {
-				template.reject(e);
-				onLoadActions.reject(e);
-				for (const [uid, handle] of Object.entries(dvHandlesByUid)) if (!resolvedDvs.has(uid)) handle.handle.reject(e);
-				for (const [uid, handle] of Object.entries(pyHandlesByUid)) if (!resolvedPyComponents.has(uid)) handle.handle.reject(e);
+				rejectPending(template, e);
+				rejectPending(onLoadActions, e);
+				for (const handle of Object.values(dvHandlesByUid)) rejectPending(handle.handle, e);
+				for (const handle of Object.values(pyHandlesByUid)) rejectPending(handle.handle, e);
 			}
 		});
 		const [templateValue, onLoadActionsValue] = await Promise.all([template.getValue(), onLoadActions.getValue()]);
@@ -92951,7 +93624,7 @@ ${String(error)}`;
 		useStreamSubscription((0, react$3.useMemo)(() => findStreamVariables(variable).map((s) => s.uid), [variable.uid]), extras);
 		if (isDerivedVariable(variable)) {
 			const [pollingInterval] = useVariable(variable.polling_interval ?? null, { suspend: false });
-			const selectorLoadable = Recoil_index_28(useDerivedVariable(variable, wsClient, taskContext, extras, pollingInterval ?? void 0));
+			const selectorLoadable = Recoil_index_28(useDerivedVariable(variable, wsClient, taskContext, extras, pollingInterval ?? void 0, variablesContext?.pollScope));
 			(0, react$3.useEffect)(() => {
 				if (selectorLoadable.state !== "loading") bus.publish("DERIVED_VARIABLE_LOADED", {
 					variable,
@@ -92962,7 +93635,7 @@ ${String(error)}`;
 		}
 		if (isSwitchVariable(variable)) return [useSwitchVariable(variable), warnUpdateOnDerivedState];
 		if (isStateVariable(variable)) {
-			const parentLoadable = Recoil_index_28(useDerivedVariable(variable.parent_variable, wsClient, taskContext, extras));
+			const parentLoadable = Recoil_index_28(useDerivedVariable(variable.parent_variable, wsClient, taskContext, extras, void 0, variablesContext?.pollScope));
 			let stateValue;
 			switch (variable.property_name) {
 				case "loading":
@@ -128015,8 +128688,10 @@ while (n === a[++i] && n === a[++i] && n === a[++i] && n === a[++i] && n === a[+
 	exports.getOrRegisterDerivedVariable = getOrRegisterDerivedVariable;
 	exports.getOrRegisterDerivedVariableResult = getOrRegisterDerivedVariableResult;
 	exports.getOrRegisterDerivedVariableValue = getOrRegisterDerivedVariableValue;
+	exports.getOrRegisterPollingTrigger = getOrRegisterPollingTrigger;
 	exports.getOrRegisterServerVariable = getOrRegisterServerVariable;
 	exports.getRegistryKey = getRegistryKey;
+	exports.getServerComponentRequestKey = getServerComponentRequestKey;
 	exports.getSessionIdentifier = getSessionIdentifier;
 	exports.getTabularVariableValue = getTabularVariableValue;
 	exports.getVariableHookSignature = getVariableHookSignature;
@@ -128053,6 +128728,7 @@ while (n === a[++i] && n === a[++i] && n === a[++i] && n === a[++i] && n === a[+
 	exports.onSessionIdChange = onSessionIdChange;
 	exports.parseLoginReferrer = parseLoginReferrer;
 	exports.parseRawCss = parseRawCss;
+	exports.pollingTriggerRegistry = pollingTriggerRegistry;
 	exports.preloadDerivedValue = preloadDerivedValue;
 	exports.preloadDerivedVariable = preloadDerivedVariable;
 	exports.preloadServerComponent = preloadServerComponent;
@@ -128086,6 +128762,7 @@ while (n === a[++i] && n === a[++i] && n === a[++i] && n === a[++i] && n === a[+
 	exports.useFetchTabularDerivedVariable = useFetchTabularDerivedVariable;
 	exports.useFetchTabularServerVariable = useFetchTabularServerVariable;
 	exports.useInterval = useInterval;
+	exports.usePollServerComponent = usePollServerComponent;
 	exports.usePreloadRoute = usePreloadRoute;
 	exports.usePrevious = usePrevious;
 	exports.useRefreshSelector = useRefreshSelector;