pulse-framework 0.1.64__py3-none-any.whl → 0.1.66a1__py3-none-any.whl

pulse/queries/client.py

@@ -3,6 +3,7 @@ from collections.abc import Callable
 from typing import Any, TypeVar, overload
 
 from pulse.context import PulseContext
+from pulse.helpers import MISSING
 from pulse.queries.common import ActionResult, QueryKey
 from pulse.queries.infinite_query import InfiniteQuery, Page
 from pulse.queries.query import KeyedQuery
@@ -203,7 +204,10 @@ class QueryClient:
 		query = self.get(key)
 		if query is None:
 			return None
-		return query.data.read()
+		value = query.data.read()
+		if value is MISSING:
+			return None
+		return value
 
 	def get_infinite_data(self, key: QueryKey) -> list[Page[Any, Any]] | None:
 		"""Get the pages for an infinite query by key.

pulse/queries/effect.py

@@ -7,6 +7,7 @@ from typing import (
 	override,
 )
 
+from pulse.helpers import MISSING
 from pulse.reactive import AsyncEffect, Computed, Signal
 
 
@@ -49,7 +50,7 @@ class AsyncQueryEffect(AsyncEffect):
 		# For unkeyed queries on re-run (dependency changed), reset data/status
 		# to behave like keyed queries when key changes (new Query with data=None)
 		if self._is_unkeyed and self.runs > 0:
-			self.fetcher.data.write(None)
+			self.fetcher.data.write(MISSING)
 			self.fetcher.status.write("loading")
 
 		return super().run()

pulse/queries/infinite_query.py

@@ -19,8 +19,8 @@ from pulse.context import PulseContext
 from pulse.helpers import (
 	MISSING,
 	Disposable,
+	Missing,
 	call_flexible,
-	later,
 	maybe_await,
 )
 from pulse.queries.common import (
@@ -36,6 +36,7 @@ from pulse.queries.common import (
 from pulse.queries.query import RETRY_DELAY_DEFAULT, QueryConfig
 from pulse.reactive import Computed, Effect, Signal, Untrack
 from pulse.reactive_extensions import ReactiveList, unwrap
+from pulse.scheduling import TimerHandleLike, create_task, later
 from pulse.state import InitializableProperty, State
 
 T = TypeVar("T")
@@ -225,7 +226,7 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 	_queue_task: asyncio.Task[None] | None
 
 	_observers: "list[InfiniteQueryResult[T, TParam]]"
-	_gc_handle: asyncio.TimerHandle | None
+	_gc_handle: TimerHandleLike | None
 	_interval_effect: Effect | None
 	_interval: float | None
 	_interval_observer: "InfiniteQueryResult[T, TParam] | None"
@@ -242,7 +243,7 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 		max_pages: int = 0,
 		retries: int = 3,
 		retry_delay: float = RETRY_DELAY_DEFAULT,
-		initial_data: list[Page[T, TParam]] | None | Any = MISSING,
+		initial_data: list[Page[T, TParam]] | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		on_dispose: Callable[[Any], None] | None = None,
@@ -266,7 +267,7 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 		if initial_data is MISSING:
 			initial_pages = []
 		else:
-			initial_pages = cast(list[Page[T, TParam]], initial_data) or []
+			initial_pages = cast(list[Page[T, TParam]] | None, initial_data) or []
 
 		self.pages = ReactiveList(initial_pages)
 		self.error = Signal(None, name=f"inf_query.error({key})")
@@ -562,7 +563,7 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 		if self._queue_task is None or self._queue_task.done():
 			# Create task with no reactive scope to avoid inheriting deps from caller
 			with Untrack():
-				self._queue_task = asyncio.create_task(self._process_queue())
+				self._queue_task = create_task(self._process_queue())
 		return self._queue_task
 
 	async def _process_queue(self):
@@ -859,7 +860,7 @@ class InfiniteQueryResult(Generic[T, TParam], Disposable):
 	_on_success: Callable[[list[Page[T, TParam]]], Awaitable[None] | None] | None
 	_on_error: Callable[[Exception], Awaitable[None] | None] | None
 	_observe_effect: Effect
-	_data_computed: Computed[list[Page[T, TParam]] | None]
+	_data_computed: Computed[list[Page[T, TParam]] | None | Missing]
 	_enabled: Signal[bool]
 	_fetch_on_mount: bool
 
@@ -920,7 +921,9 @@ class InfiniteQueryResult(Generic[T, TParam], Disposable):
 			immediate=True,
 		)
 		self._data_computed = Computed(
-			self._data_computed_fn, name=f"inf_query_data({self._query().key})"
+			self._data_computed_fn,
+			name=f"inf_query_data({self._query().key})",
+			initial_value=MISSING,
 		)
 
 	@property
@@ -948,18 +951,19 @@ class InfiniteQueryResult(Generic[T, TParam], Disposable):
 		return self._query().error.read()
 
 	def _data_computed_fn(
-		self, prev: list[Page[T, TParam]] | None
-	) -> list[Page[T, TParam]] | None:
+		self, prev: list[Page[T, TParam]] | None | Missing
+	) -> list[Page[T, TParam]] | None | Missing:
 		query = self._query()
-		if self._keep_previous_data and query.status() != "success":
+		if self._keep_previous_data and query.status() == "loading":
 			return prev
 		# Access pages.version to subscribe to structural changes
-		result = unwrap(query.pages) if len(query.pages) > 0 else None
-		return result
+		if len(query.pages) == 0:
+			return MISSING
+		return unwrap(query.pages)
 
 	@property
 	def data(self) -> list[Page[T, TParam]] | None:
-		return self._data_computed()
+		return none_if_missing(self._data_computed())
 
 	@property
 	def pages(self) -> list[T] | None:
@@ -988,8 +992,6 @@ class InfiniteQueryResult(Generic[T, TParam], Disposable):
 		return isinstance(self._query().current_action(), FetchPrevious)
 
 	def is_stale(self) -> bool:
-		if self._stale_time <= 0:
-			return False
 		query = self._query()
 		return (time.time() - query.last_updated.read()) > self._stale_time
 
@@ -1096,6 +1098,7 @@ class InfiniteQueryProperty(Generic[T, TParam, TState], InitializableProperty):
 
 	Optional decorators:
 		- ``@infinite_query_prop.get_previous_page_param``: For bi-directional pagination.
+		- ``@infinite_query_prop.initial_data``: Provide initial pages.
 		- ``@infinite_query_prop.on_success``: Handle successful fetch.
 		- ``@infinite_query_prop.on_error``: Handle fetch errors.
 
@@ -1131,6 +1134,12 @@ class InfiniteQueryProperty(Generic[T, TParam, TState], InitializableProperty):
 	_refetch_interval: float | None
 	_retries: int
 	_retry_delay: float
+	_initial_data: (
+		list[Page[T, TParam]]
+		| Callable[[TState], list[Page[T, TParam]]]
+		| Missing
+		| None
+	)
 	_initial_page_param: TParam
 	_get_next_page_param: (
 		Callable[[TState, list[Page[T, TParam]]], TParam | None] | None
@@ -1182,6 +1191,7 @@ class InfiniteQueryProperty(Generic[T, TParam, TState], InitializableProperty):
 		self._retry_delay = retry_delay
 		self._on_success_fn = None
 		self._on_error_fn = None
+		self._initial_data = MISSING
 		self._key = key
 		self._initial_data_updated_at = initial_data_updated_at
 		self._enabled = enabled
@@ -1212,6 +1222,16 @@ class InfiniteQueryProperty(Generic[T, TParam, TState], InitializableProperty):
 		self._on_error_fn = fn  # pyright: ignore[reportAttributeAccessIssue]
 		return fn
 
+	def initial_data(
+		self, fn: Callable[[TState], list[Page[T, TParam]]]
+	) -> Callable[[TState], list[Page[T, TParam]]]:
+		if self._initial_data is not MISSING:
+			raise RuntimeError(
+				f"Duplicate initial_data() decorator for infinite query '{self.name}'. Only one is allowed."
+			)
+		self._initial_data = fn
+		return fn
+
 	def get_next_page_param(
 		self,
 		fn: Callable[[TState, list[Page[T, TParam]]], TParam | None],
@@ -1260,8 +1280,23 @@ class InfiniteQueryProperty(Generic[T, TParam, TState], InitializableProperty):
 			raise RuntimeError(
 				f"key is required for infinite query '{self.name}'. Provide a key via @infinite_query(key=...) or @{self.name}.key decorator."
 			)
+		raw_initial = (
+			call_flexible(self._initial_data, state)
+			if callable(self._initial_data)
+			else self._initial_data
+		)
+		initial_data = (
+			MISSING
+			if raw_initial is MISSING
+			else cast(list[Page[T, TParam]] | None, raw_initial)
+		)
 		query = self._resolve_keyed(
-			state, fetch_fn, next_fn, prev_fn, self._initial_data_updated_at
+			state,
+			fetch_fn,
+			next_fn,
+			prev_fn,
+			initial_data,
+			self._initial_data_updated_at,
 		)
 
 		on_success = None
@@ -1297,6 +1332,7 @@ class InfiniteQueryProperty(Generic[T, TParam, TState], InitializableProperty):
 		fetch_fn: Callable[[TParam], Awaitable[T]],
 		next_fn: Callable[[list[Page[T, TParam]]], TParam | None],
 		prev_fn: Callable[[list[Page[T, TParam]]], TParam | None] | None,
+		initial_data: list[Page[T, TParam]] | Missing | None,
 		initial_data_updated_at: float | dt.datetime | None,
 	) -> Computed[InfiniteQuery[T, TParam]]:
 		assert self._key is not None
@@ -1327,6 +1363,7 @@ class InfiniteQueryProperty(Generic[T, TParam, TState], InitializableProperty):
 					get_next_page_param=next_fn,
 					get_previous_page_param=prev_fn,
 					max_pages=self._max_pages,
+					initial_data=initial_data,
 					gc_time=self._gc_time,
 					retries=self._retries,
 					retry_delay=self._retry_delay,
@@ -1420,7 +1457,7 @@ def infinite_query(
 		stale_time: Seconds before data is considered stale (default 0.0).
 		gc_time: Seconds to keep unused query in cache (default 300.0).
 		refetch_interval: Auto-refetch interval in seconds (default None).
-		keep_previous_data: Keep previous data while refetching (default False).
+		keep_previous_data: Keep previous data while loading (default False).
 		retries: Number of retry attempts on failure (default 3).
 		retry_delay: Delay between retries in seconds (default 2.0).
 		initial_data_updated_at: Timestamp for initial data staleness.

pulse/queries/query.py

@@ -18,9 +18,8 @@ from pulse.context import PulseContext
 from pulse.helpers import (
 	MISSING,
 	Disposable,
+	Missing,
 	call_flexible,
-	is_pytest,
-	later,
 	maybe_await,
 )
 from pulse.queries.common import (
@@ -35,6 +34,7 @@ from pulse.queries.common import (
 )
 from pulse.queries.effect import AsyncQueryEffect
 from pulse.reactive import Computed, Effect, Signal, Untrack
+from pulse.scheduling import TimerHandleLike, create_task, is_pytest, later
 from pulse.state import InitializableProperty, State
 
 if TYPE_CHECKING:
@@ -64,7 +64,7 @@ class QueryConfig(Generic[T]):
 
 	retries: int
 	retry_delay: float
-	initial_data: T | Callable[[], T] | None
+	initial_data: T | Callable[[], T] | Missing | None
 	initial_data_updated_at: float | dt.datetime | None
 	gc_time: float
 	on_dispose: Callable[[Any], None] | None
@@ -90,7 +90,7 @@ class QueryState(Generic[T]):
 	cfg: QueryConfig[T]
 
 	# Reactive signals for query state
-	data: Signal[T | None]
+	data: Signal[T | None | Missing]
 	error: Signal[Exception | None]
 	last_updated: Signal[float]
 	status: Signal[QueryStatus]
@@ -103,7 +103,7 @@ class QueryState(Generic[T]):
 		name: str,
 		retries: int = 3,
 		retry_delay: float = RETRY_DELAY_DEFAULT,
-		initial_data: T | None = MISSING,
+		initial_data: T | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		on_dispose: Callable[[Any], None] | None = None,
@@ -119,7 +119,7 @@ class QueryState(Generic[T]):
 
 		# Initialize reactive signals
 		self.data = Signal(
-			None if initial_data is MISSING else initial_data,
+			MISSING if initial_data is MISSING else initial_data,
 			name=f"query.data({name})",
 		)
 		self.error = Signal(None, name=f"query.error({name})")
@@ -147,7 +147,8 @@ class QueryState(Generic[T]):
 	):
 		"""Set data manually, accepting a value or updater function."""
 		current = self.data.read()
-		new_value = cast(T, data(current) if callable(data) else data)
+		current_value = cast(T | None, None if current is MISSING else current)
+		new_value = cast(T, data(current_value) if callable(data) else data)
 		self.set_success(new_value, manual=True)
 		if updated_at is not None:
 			self.set_updated_at(updated_at)
@@ -225,7 +226,7 @@ async def run_fetch_with_retries(
 		on_success: Optional callback on success
 		on_error: Optional callback on error
 		untrack: If True, wrap fetch_fn in Untrack() to prevent dependency tracking.
-		         Use for keyed queries where fetch is triggered via asyncio.create_task.
+		         Use for keyed queries where fetch is triggered via create_task().
 	"""
 	state.reset_retries()
 
@@ -267,7 +268,7 @@ class KeyedQuery(Generic[T], Disposable):
 	observers: "list[KeyedQueryResult[T]]"
 	_task: asyncio.Task[None] | None
 	_task_initiator: "KeyedQueryResult[T] | None"
-	_gc_handle: asyncio.TimerHandle | None
+	_gc_handle: TimerHandleLike | None
 	_interval_effect: Effect | None
 	_interval: float | None
 	_interval_observer: "KeyedQueryResult[T] | None"
@@ -277,7 +278,7 @@ class KeyedQuery(Generic[T], Disposable):
 		key: QueryKey,
 		retries: int = 3,
 		retry_delay: float = RETRY_DELAY_DEFAULT,
-		initial_data: T | None = MISSING,
+		initial_data: T | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		on_dispose: Callable[[Any], None] | None = None,
@@ -302,7 +303,7 @@ class KeyedQuery(Generic[T], Disposable):
 
 	# --- Delegate signal access to state ---
 	@property
-	def data(self) -> Signal[T | None]:
+	def data(self) -> Signal[T | None | Missing]:
 		return self.state.data
 
 	@property
@@ -383,7 +384,7 @@ class KeyedQuery(Generic[T], Disposable):
 			fetch_fn,
 			on_success=on_success,
 			on_error=on_error,
-			untrack=True,  # Keyed queries use asyncio.create_task, need to untrack
+			untrack=True,  # Keyed queries use create_task(), need to untrack
 		)
 
 	def run_fetch(
@@ -407,7 +408,7 @@ class KeyedQuery(Generic[T], Disposable):
 		self.state.is_fetching.write(True)
 		# Capture current observers at fetch start
 		observers = list(self.observers)
-		self._task = asyncio.create_task(self._run_fetch(fetch_fn, observers))
+		self._task = create_task(self._run_fetch(fetch_fn, observers))
 		self._task_initiator = initiator
 		return self._task
 
@@ -427,7 +428,10 @@ class KeyedQuery(Generic[T], Disposable):
 		# Return result based on current state
 		if self.state.status() == "error":
 			return ActionError(cast(Exception, self.state.error.read()))
-		return ActionSuccess(cast(T, self.state.data.read()))
+		data = self.state.data.read()
+		if data is MISSING:
+			return ActionSuccess(cast(T, None))
+		return ActionSuccess(cast(T, data))
 
 	def cancel(self) -> None:
 		"""Cancel the current fetch if running."""
@@ -599,7 +603,7 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 	_keep_previous_data: bool
 	_enabled: Signal[bool]
 	_interval_effect: Effect | None
-	_data_computed: Computed[T | None]
+	_data_computed: Computed[T | None | Missing]
 
 	def __init__(
 		self,
@@ -608,7 +612,7 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 		on_error: Callable[[Exception], Awaitable[None] | None] | None = None,
 		retries: int = 3,
 		retry_delay: float = RETRY_DELAY_DEFAULT,
-		initial_data: T | None = MISSING,
+		initial_data: T | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		stale_time: float = 0.0,
@@ -652,7 +656,9 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 
 		# Computed for keep_previous_data logic
 		self._data_computed = Computed(
-			self._data_computed_fn, name="query_data(unkeyed)"
+			self._data_computed_fn,
+			name="query_data(unkeyed)",
+			initial_value=MISSING,
 		)
 
 		# Schedule initial fetch if stale (untracked to avoid reactive loop)
@@ -679,12 +685,12 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 			immediate=True,
 		)
 
-	def _data_computed_fn(self, prev: T | None) -> T | None:
-		if self._keep_previous_data and self.state.status() != "success":
+	def _data_computed_fn(self, prev: T | None | Missing) -> T | None | Missing:
+		if self._keep_previous_data and self.state.status() == "loading":
 			return prev
 		raw = self.state.data()
-		if raw is None:
-			return None
+		if raw is MISSING:
+			return MISSING
 		return raw
 
 	# --- Status properties ---
@@ -714,7 +720,10 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 
 	@property
 	def data(self) -> T | None:
-		return self._data_computed()
+		value = self._data_computed()
+		if value is MISSING:
+			return None
+		return cast(T | None, value)
 
 	# --- State methods ---
 	def set_data(self, data: T | Callable[[T | None], T]):
@@ -780,7 +789,10 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 		await self._effect.wait()
 		if self.state.status() == "error":
 			return ActionError(cast(Exception, self.state.error.read()))
-		return ActionSuccess(cast(T, self.state.data.read()))
+		data = self.state.data.read()
+		if data is MISSING:
+			return ActionSuccess(cast(T, None))
+		return ActionSuccess(cast(T, data))
 
 	async def ensure(self) -> ActionResult[T]:
 		"""Ensure an initial fetch has started, then wait for completion."""
@@ -820,7 +832,7 @@ class KeyedQueryResult(Generic[T], Disposable):
 	_on_success: Callable[[T], Awaitable[None] | None] | None
 	_on_error: Callable[[Exception], Awaitable[None] | None] | None
 	_observe_effect: Effect
-	_data_computed: Computed[T | None]
+	_data_computed: Computed[T | None | Missing]
 	_enabled: Signal[bool]
 	_fetch_on_mount: bool
 
@@ -877,7 +889,9 @@ class KeyedQueryResult(Generic[T], Disposable):
 			immediate=True,
 		)
 		self._data_computed = Computed(
-			self._data_computed_fn, name=f"query_data({self._query().key})"
+			self._data_computed_fn,
+			name=f"query_data({self._query().key})",
+			initial_value=MISSING,
 		)
 
 	@property
@@ -908,18 +922,18 @@ class KeyedQueryResult(Generic[T], Disposable):
 	def error(self) -> Exception | None:
 		return self._query().error.read()
 
-	def _data_computed_fn(self, prev: T | None) -> T | None:
+	def _data_computed_fn(self, prev: T | None | Missing) -> T | None | Missing:
 		query = self._query()
-		if self._keep_previous_data and query.status() != "success":
+		if self._keep_previous_data and query.status() == "loading":
 			return prev
-		raw = query.data()
-		if raw is None:
-			return None
-		return raw
+		return query.data()
 
 	@property
 	def data(self) -> T | None:
-		return self._data_computed()
+		value = self._data_computed()
+		if value is MISSING:
+			return None
+		return cast(T | None, value)
 
 	def is_stale(self) -> bool:
 		"""Check if the query data is stale based on stale_time."""
@@ -1039,7 +1053,7 @@ class QueryProperty(Generic[T, TState], InitializableProperty):
 	_retry_delay: float
 	_initial_data_updated_at: float | dt.datetime | None
 	_enabled: bool
-	_initial_data: T | Callable[[TState], T] | None
+	_initial_data: T | Callable[[TState], T] | Missing | None
 	_key: QueryKey | Callable[[TState], QueryKey] | None
 	# Not using OnSuccessFn and OnErrorFn since unions of callables are not well
 	# supported in the type system. We just need to be careful to use
@@ -1076,7 +1090,7 @@ class QueryProperty(Generic[T, TState], InitializableProperty):
 		self._retries = retries
 		self._retry_delay = retry_delay
 		self._initial_data_updated_at = initial_data_updated_at
-		self._initial_data = MISSING  # pyright: ignore[reportAttributeAccessIssue]
+		self._initial_data = MISSING
 		self._enabled = enabled
 		self._fetch_on_mount = fetch_on_mount
 		self._priv_result = f"__query_{name}"
@@ -1131,13 +1145,13 @@ class QueryProperty(Generic[T, TState], InitializableProperty):
 
 		# Bind methods to this instance
 		fetch_fn = bind_state(state, self._fetch_fn)
-		initial_data = cast(
-			T | None,
-			(
-				call_flexible(self._initial_data, state)
-				if callable(self._initial_data)
-				else self._initial_data
-			),
+		raw_initial = (
+			call_flexible(self._initial_data, state)
+			if callable(self._initial_data)
+			else self._initial_data
+		)
+		initial_data = (
+			MISSING if raw_initial is MISSING else cast(T | None, raw_initial)
 		)
 
 		if self._key is None:
@@ -1165,7 +1179,7 @@ class QueryProperty(Generic[T, TState], InitializableProperty):
 		self,
 		state: TState,
 		fetch_fn: Callable[[], Awaitable[T]],
-		initial_data: T | None,
+		initial_data: T | Missing | None,
 		initial_data_updated_at: float | dt.datetime | None,
 	) -> KeyedQueryResult[T]:
 		"""Create or get a keyed query from the session store."""
@@ -1220,7 +1234,7 @@ class QueryProperty(Generic[T, TState], InitializableProperty):
 	def _create_unkeyed(
 		self,
 		fetch_fn: Callable[[], Awaitable[T]],
-		initial_data: T | None,
+		initial_data: T | Missing | None,
 		initial_data_updated_at: float | dt.datetime | None,
 		state: TState,
 	) -> UnkeyedQueryResult[T]:
@@ -1313,7 +1327,7 @@ def query(
 		stale_time: Seconds before data is considered stale (default 0.0).
 		gc_time: Seconds to keep unused query in cache (default 300.0, None to disable).
 		refetch_interval: Auto-refetch interval in seconds (default None, disabled).
-		keep_previous_data: Keep previous data while refetching (default False).
+		keep_previous_data: Keep previous data while loading (default False).
 		retries: Number of retry attempts on failure (default 3).
 		retry_delay: Delay between retries in seconds (default 2.0).
 		initial_data_updated_at: Timestamp for initial data staleness calculation.

pulse/queries/store.py

@@ -2,7 +2,7 @@ import datetime as dt
 from collections.abc import Callable
 from typing import Any, TypeVar, cast
 
-from pulse.helpers import MISSING
+from pulse.helpers import MISSING, Missing
 from pulse.queries.common import QueryKey
 from pulse.queries.infinite_query import InfiniteQuery, Page
 from pulse.queries.query import RETRY_DELAY_DEFAULT, KeyedQuery
@@ -29,7 +29,7 @@ class QueryStore:
 	def ensure(
 		self,
 		key: QueryKey,
-		initial_data: T | None = MISSING,
+		initial_data: T | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		retries: int = 3,
@@ -87,6 +87,7 @@ class QueryStore:
 		get_previous_page_param: Callable[[list[Page[Any, Any]]], Any | None]
 		| None = None,
 		max_pages: int = 0,
+		initial_data: list[Page[Any, Any]] | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		retries: int = 3,
@@ -110,6 +111,7 @@ class QueryStore:
 			get_next_page_param=get_next_page_param,
 			get_previous_page_param=get_previous_page_param,
 			max_pages=max_pages,
+			initial_data=initial_data,
 			initial_data_updated_at=initial_data_updated_at,
 			gc_time=gc_time,
 			retries=retries,
@@ -118,3 +120,9 @@ class QueryStore:
 		)
 		self._entries[key] = entry
 		return entry
+
+	def dispose_all(self) -> None:
+		"""Dispose all queries and clear the store."""
+		for entry in list(self._entries.values()):
+			entry.dispose()
+		self._entries.clear()

pulse/reactive.py

@@ -15,11 +15,14 @@ from typing import (
 
 from pulse.helpers import (
 	Disposable,
-	create_task,
 	maybe_await,
-	schedule_on_loop,
 	values_equal,
 )
+from pulse.scheduling import (
+	TimerHandleLike,
+	call_soon,
+	create_task,
+)
 
 T = TypeVar("T")
 T_co = TypeVar("T_co", covariant=True)
@@ -151,6 +154,7 @@ class Computed(Generic[T_co]):
 		fn: Function computing the value. May optionally accept prev_value
 			as first positional argument for incremental computation.
 		name: Debug name for the computed.
+		initial_value: Seed value used as prev_value on first compute.
 
 	Attributes:
 		value: Cached computed value.
@@ -171,13 +175,20 @@ class Computed(Generic[T_co]):
 
 	fn: Callable[..., T_co]
 	name: str | None
+	value: Any
 	dirty: bool
 	on_stack: bool
 	accepts_prev_value: bool
 
-	def __init__(self, fn: Callable[..., T_co], name: str | None = None):
+	def __init__(
+		self,
+		fn: Callable[..., T_co],
+		name: str | None = None,
+		*,
+		initial_value: Any = None,
+	):
 		self.fn = fn
-		self.value: T_co = None  # pyright: ignore[reportAttributeAccessIssue]
+		self.value = initial_value
 		self.name = name
 		self.dirty = False
 		self.on_stack = False
@@ -384,7 +395,7 @@ class Effect(Disposable):
 	immediate: bool
 	_lazy: bool
 	_interval: float | None
-	_interval_handle: asyncio.TimerHandle | None
+	_interval_handle: TimerHandleLike | None
 	update_deps: bool
 	batch: "Batch | None"
 	paused: bool
@@ -461,7 +472,7 @@ class Effect(Disposable):
 	def _schedule_interval(self):
 		"""Schedule the next interval run if interval is set."""
 		if self._interval is not None and self._interval > 0:
-			from pulse.helpers import later
+			from pulse.scheduling import later
 
 			self._interval_handle = later(self._interval, self._on_interval)
 
@@ -995,7 +1006,7 @@ class GlobalBatch(Batch):
 	@override
 	def register_effect(self, effect: Effect):
 		if not self.is_scheduled:
-			schedule_on_loop(self.flush)
+			call_soon(self.flush)
 			self.is_scheduled = True
 		return super().register_effect(effect)