pulse-framework 0.1.44__py3-none-any.whl → 0.1.46__py3-none-any.whl

pulse/queries/store.py

@@ -1,10 +1,11 @@
 import datetime as dt
-from collections.abc import Awaitable, Callable
+from collections.abc import Callable
 from typing import Any, TypeVar, cast
 
+from pulse.helpers import MISSING
 from pulse.queries.common import QueryKey
 from pulse.queries.infinite_query import InfiniteQuery, Page
-from pulse.queries.query import RETRY_DELAY_DEFAULT, Query
+from pulse.queries.query import RETRY_DELAY_DEFAULT, KeyedQuery
 
 T = TypeVar("T")
 
@@ -15,26 +16,25 @@ class QueryStore:
 	"""
 
 	def __init__(self):
-		self._entries: dict[QueryKey, Query[Any] | InfiniteQuery[Any, Any]] = {}
+		self._entries: dict[QueryKey, KeyedQuery[Any] | InfiniteQuery[Any, Any]] = {}
 
 	def items(self):
 		"""Iterate over all (key, query) pairs in the store."""
 		return self._entries.items()
 
-	def get_any(self, key: QueryKey) -> Query[Any] | InfiniteQuery[Any, Any] | None:
+	def get_any(self, key: QueryKey):
 		"""Get any query (regular or infinite) by key, or None if not found."""
 		return self._entries.get(key)
 
 	def ensure(
 		self,
 		key: QueryKey,
-		fetch_fn: Callable[[], Awaitable[T]],
-		initial_data: T | None = None,
+		initial_data: T | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		retries: int = 3,
 		retry_delay: float = RETRY_DELAY_DEFAULT,
-	) -> Query[T]:
+	) -> KeyedQuery[T]:
 		# Return existing entry if present
 		existing = self._entries.get(key)
 		if existing:
@@ -42,15 +42,14 @@ class QueryStore:
 				raise TypeError(
 					"Query key is already used for an infinite query; cannot reuse for regular query"
 				)
-			return cast(Query[T], existing)
+			return cast(KeyedQuery[T], existing)
 
-		def _on_dispose(e: Query[Any]) -> None:
+		def _on_dispose(e: KeyedQuery[Any]) -> None:
 			if e.key in self._entries and self._entries[e.key] is e:
 				del self._entries[e.key]
 
-		entry = Query(
+		entry = KeyedQuery(
 			key,
-			fetch_fn,
 			initial_data=initial_data,
 			initial_data_updated_at=initial_data_updated_at,
 			gc_time=gc_time,
@@ -61,7 +60,7 @@ class QueryStore:
 		self._entries[key] = entry
 		return entry
 
-	def get(self, key: QueryKey) -> Query[Any] | None:
+	def get(self, key: QueryKey) -> KeyedQuery[Any] | None:
 		"""
 		Get an existing regular query by key, or None if not found.
 		"""
@@ -82,7 +81,6 @@ class QueryStore:
 	def ensure_infinite(
 		self,
 		key: QueryKey,
-		query_fn: Callable[[Any], Awaitable[Any]],
 		*,
 		initial_page_param: Any,
 		get_next_page_param: Callable[[list[Page[Any, Any]]], Any | None],
@@ -108,7 +106,6 @@ class QueryStore:
 
 		entry = InfiniteQuery(
 			key,
-			query_fn,
 			initial_page_param=initial_page_param,
 			get_next_page_param=get_next_page_param,
 			get_previous_page_param=get_previous_page_param,

pulse/reactive.py

@@ -191,7 +191,8 @@ class Computed(Generic[T_co]):
 				if len(scope.effects) > 0:
 					raise RuntimeError(
 						"An effect was created within a computed variable's function. "
-						+ "This behavior is not allowed, computed variables should be pure calculations."
+						+ "This is most likely unintended. If you need to create an effect here, "
+						+ "wrap the effect creation with Untrack()."
 					)
 			finally:
 				self.on_stack = False
@@ -274,6 +275,7 @@ class Effect(Disposable):
 	_interval_handle: asyncio.TimerHandle | None
 	explicit_deps: bool
 	batch: "Batch | None"
+	paused: bool
 
 	def __init__(
 		self,
@@ -301,6 +303,7 @@ class Effect(Disposable):
 		self._lazy = lazy
 		self._interval = interval
 		self._interval_handle = None
+		self.paused = False
 
 		if immediate and lazy:
 			raise ValueError("An effect cannot be boht immediate and lazy")
@@ -358,7 +361,20 @@ class Effect(Disposable):
 			self._interval_handle.cancel()
 			self._interval_handle = None
 
+	def pause(self):
+		"""Pause the effect - it won't run when dependencies change."""
+		self.paused = True
+		self.cancel(cancel_interval=True)
+
+	def resume(self):
+		"""Resume a paused effect and schedule it to run."""
+		if self.paused:
+			self.paused = False
+			self.schedule()
+
 	def schedule(self):
+		if self.paused:
+			return
 		# Immediate effects run right away when scheduled and do not enter a batch
 		if self.immediate:
 			self.run()
@@ -383,6 +399,8 @@ class Effect(Disposable):
 			self._cancel_interval()
 
 	def push_change(self):
+		if self.paused:
+			return
 		# Short-circuit if already scheduled in a batch.
 		# This avoids redundant schedule() calls and O(n) list checks
 		# when the same effect is reached through multiple dependency paths.

pulse/render_session.py

@@ -43,17 +43,21 @@ class RouteMount:
 	render: "RenderSession"
 	route: RouteContext
 	tree: RenderTree
+	effect: Effect | None
+	_pulse_ctx: PulseContext | None
+	element: Element
+	rendered: bool
 
 	def __init__(
 		self, render: "RenderSession", route: Route | Layout, route_info: RouteInfo
 	) -> None:
 		self.render = render
 		self.route = RouteContext(route_info, route)
-		self.effect: Effect | None = None
-		self._pulse_ctx: PulseContext | None = None
-		self.element: Element = route.render()
+		self.effect = None
+		self._pulse_ctx = None
+		self.element = route.render()
 		self.tree = RenderTree(self.element)
-		self.rendered: bool = False
+		self.rendered = False
 
 
 class RenderSession:
@@ -62,6 +66,13 @@ class RenderSession:
 	channels: "ChannelsManager"
 	forms: "FormRegistry"
 	query_store: QueryStore
+	route_mounts: dict[str, RouteMount]
+	_server_address: str | None
+	_client_address: str | None
+	_send_message: Callable[[ServerMessage], Any] | None
+	_pending_api: dict[str, asyncio.Future[dict[str, Any]]]
+	_global_states: dict[str, State]
+	connected: bool
 
 	def __init__(
 		self,
@@ -76,20 +87,18 @@ class RenderSession:
 
 		self.id = id
 		self.routes = routes
-		self.route_mounts: dict[str, RouteMount] = {}
+		self.route_mounts = {}
 		# Base server address for building absolute API URLs (e.g., http://localhost:8000)
-		self._server_address: str | None = server_address
+		self._server_address = server_address
 		# Best-effort client address, captured at prerender or socket connect time
-		self._client_address: str | None = client_address
-		self._send_message: Callable[[ServerMessage], Any] | None = None
-		# Buffer messages emitted before a connection is established
-		self._message_buffer: list[ServerMessage] = []
-		self._pending_api: dict[str, asyncio.Future[dict[str, Any]]] = {}
+		self._client_address = client_address
+		self._send_message = None
+		self._pending_api = {}
 		# Registry of per-session global singletons (created via ps.global_state without id)
-		self._global_states: dict[str, State] = {}
+		self._global_states = {}
 		self.query_store = QueryStore()
 		# Connection state
-		self.connected: bool = False
+		self.connected = False
 		self.channels = ChannelsManager(self)
 		self.forms = FormRegistry(self)
 
@@ -117,19 +126,22 @@ class RenderSession:
 	def connect(self, send_message: Callable[[ServerMessage], Any]):
 		self._send_message = send_message
 		self.connected = True
-		# Flush any buffered messages now that we can send
-		if self._message_buffer:
-			for msg in self._message_buffer:
-				self._send_message(msg)
-			self._message_buffer.clear()
+		# Don't flush buffer or resume effects here - mount() handles reconnection
+		# by resetting mount.rendered and resuming effects to send fresh vdom_init
+
+	def disconnect(self):
+		"""Called when client disconnects - pause render effects."""
+		self._send_message = None
+		self.connected = False
+		for mount in self.route_mounts.values():
+			if mount.effect:
+				mount.effect.pause()
 
 	def send(self, message: ServerMessage):
 		# If a sender is available (connected or during prerender capture), send immediately.
-		# Otherwise, buffer until a connection is established.
+		# Otherwise, drop the message - we'll send full VDOM state on reconnection.
 		if self._send_message:
 			self._send_message(message)
-		else:
-			self._message_buffer.append(message)
 
 	def report_error(
 		self,
@@ -174,8 +186,6 @@ class RenderSession:
 				self.channels.dispose_channel(channel, reason="render.close")
 		# The effect will be garbage collected, and with it the dependencies
 		self._send_message = None
-		# Discard any buffered messages on close
-		self._message_buffer.clear()
 		self.connected = False
 
 	def execute_callback(self, path: str, key: str, args: list[Any] | tuple[Any, ...]):
@@ -392,8 +402,14 @@ class RenderSession:
 
 	def mount(self, path: str, route_info: RouteInfo):
 		if path in self.route_mounts:
-			# No logging, this is bound to happen with React strict mode
-			# logger.error(f"Route already mounted: '{path}'")
+			# Route already mounted - this is a reconnection case.
+			# Reset rendered flag so effect sends vdom_init, update route info,
+			# and resume the paused effect.
+			mount = self.route_mounts[path]
+			mount.rendered = False
+			mount.route.update(route_info)
+			if mount.effect and mount.effect.paused:
+				mount.effect.resume()
 			return
 
 		mount = self.create_route_mount(path, route_info)

pulse/renderer.py

@@ -527,21 +527,6 @@ class Renderer:
 		unmount_element(node)
 
 
-def extract_key(element: Element) -> str | None:
-	if isinstance(element, ComponentNode):
-		return element.key
-	if isinstance(element, Node):
-		return element.key
-	return None
-
-
-def child_key(element: Element, index: int) -> str:
-	key = extract_key(element)
-	if key is not None:
-		return key
-	return f"__idx__{index}"
-
-
 def normalize_children(children: Sequence[Element] | None) -> list[Element]:
 	if not children:
 		return []
@@ -573,34 +558,6 @@ def same_node(left: Element, right: Element) -> bool:
 	return False
 
 
-def lis(seq: list[int]) -> list[int]:
-	if not seq:
-		return []
-	tails: list[int] = []
-	prev: list[int] = [-1] * len(seq)
-	for i, v in enumerate(seq):
-		lo, hi = 0, len(tails)
-		while lo < hi:
-			mid = (lo + hi) // 2
-			if seq[tails[mid]] < v:
-				lo = mid + 1
-			else:
-				hi = mid
-		if lo > 0:
-			prev[i] = tails[lo - 1]
-		if lo == len(tails):
-			tails.append(i)
-		else:
-			tails[lo] = i
-	lis_indices: list[int] = []
-	k = tails[-1] if tails else -1
-	while k != -1:
-		lis_indices.append(k)
-		k = prev[k]
-	lis_indices.reverse()
-	return lis_indices
-
-
 def _css_ref_token(ref: CssReference) -> str:
 	return f"{ref.module.id}:{ref.name}"
 

pulse/types/event_handler.py

@@ -1,9 +1,10 @@
-from collections.abc import Awaitable, Callable
+from collections.abc import Callable
 from typing import (
+	Any,
 	TypeVar,
 )
 
-EventHandlerResult = None | Awaitable[None]
+EventHandlerResult = Any
 
 T1 = TypeVar("T1", contravariant=True)
 T2 = TypeVar("T2", contravariant=True)

pulse/vdom.py

@@ -6,6 +6,7 @@ the TypeScript UINode format exactly, eliminating the need for translation.
 """
 
 import functools
+import math
 import warnings
 from collections.abc import Callable, Iterable, Sequence
 from inspect import Parameter, signature
@@ -22,9 +23,60 @@ from typing import (
 	override,
 )
 
+from pulse.env import env
 from pulse.hooks.core import HookContext
 from pulse.hooks.init import rewrite_init_blocks
 
+# ============================================================================
+# Validation helpers (dev mode only)
+# ============================================================================
+
+
+def _check_json_safe_float(value: float, context: str) -> None:
+	"""Raise ValueError if a float is NaN or Infinity."""
+	if math.isnan(value):
+		raise ValueError(
+			f"Cannot use nan in {context}. "
+			+ "NaN and Infinity are not supported in Pulse because they cannot be serialized to JSON. "
+			+ "Replace with None or a sentinel value before passing to components."
+		)
+	if math.isinf(value):
+		kind = "inf" if value > 0 else "-inf"
+		raise ValueError(
+			f"Cannot use {kind} in {context}. "
+			+ "NaN and Infinity are not supported in Pulse because they cannot be serialized to JSON. "
+			+ "Replace with None or a sentinel value before passing to components."
+		)
+
+
+def _validate_value(value: Any, context: str) -> None:
+	"""Recursively validate a value for JSON-unsafe floats (NaN, Infinity)."""
+	if isinstance(value, float):
+		_check_json_safe_float(value, context)
+	elif isinstance(value, dict):
+		for v in value.values():
+			_validate_value(v, context)
+	elif isinstance(value, (list, tuple)):
+		for item in value:
+			_validate_value(item, context)
+	# Skip other types - they'll be handled by the serializer
+
+
+def _validate_props(props: dict[str, Any] | None, parent_name: str) -> None:
+	"""Validate all props for JSON-unsafe values."""
+	if not props:
+		return
+	for key, value in props.items():
+		_validate_value(value, f"{parent_name} prop '{key}'")
+
+
+def _validate_children(children: "Sequence[Element]", parent_name: str) -> None:
+	"""Validate primitive children for JSON-unsafe values."""
+	for child in children:
+		if isinstance(child, float):
+			_check_json_safe_float(child, f"{parent_name} children")
+
+
 # ============================================================================
 # Core VDOM
 # ============================================================================
@@ -75,6 +127,12 @@ class Node:
 			raise ValueError("key must be a string or None")
 		if not self.allow_children and children:
 			raise ValueError(f"{self.tag} cannot have children")
+		# Dev-only validation for JSON-unsafe values
+		if env.pulse_env == "dev":
+			parent_name = f"<{self.tag}>"
+			_validate_props(self.props, parent_name)
+			if self.children:
+				_validate_children(self.children, parent_name)
 
 	# --- Pretty printing helpers -------------------------------------------------
 	@override
@@ -199,6 +257,15 @@ class Component(Generic[P]):
 		if key is not None and not isinstance(key, str):
 			raise ValueError("key must be a string or None")
 
+		# Flatten children if component takes children (has *children parameter)
+		if self._takes_children and args:
+			flattened = _flatten_children(
+				args,  # pyright: ignore[reportArgumentType]
+				parent_name=f"<{self.name}>",
+				warn_stacklevel=4,
+			)
+			args = tuple(flattened)  # pyright: ignore[reportAssignmentType]
+
 		return ComponentNode(
 			fn=self.fn,
 			key=key,
@@ -244,6 +311,17 @@ class ComponentNode:
 		# Used for rendering
 		self.contents: Element | None = None
 		self.hooks = HookContext()
+		# Dev-only validation for JSON-unsafe values
+		if env.pulse_env == "dev":
+			parent_name = f"<{self.name}>"
+			# Validate kwargs (props)
+			_validate_props(self.kwargs, parent_name)
+			# Validate args (children passed positionally)
+			for arg in self.args:
+				if isinstance(arg, float):
+					_check_json_safe_float(arg, f"{parent_name} children")
+				elif isinstance(arg, (dict, list, tuple)):
+					_validate_value(arg, f"{parent_name} children")
 
 	def __getitem__(self, children_arg: "Child | tuple[Child, ...]"):
 		if not self.takes_children:
@@ -259,7 +337,7 @@ class ComponentNode:
 			children_arg = (children_arg,)
 		# Flatten children for ComponentNode as well
 		flattened_children = _flatten_children(
-			children_arg, parent_name=f"<{self.name}>"
+			children_arg, parent_name=f"<{self.name}>", warn_stacklevel=4
 		)
 		result = ComponentNode(
 			fn=self.fn,
@@ -315,28 +393,43 @@ Props = dict[str, Any]
 # ----------------------------------------------------------------------------
 
 
-def _flatten_children(children: Children, *, parent_name: str) -> Sequence[Element]:
-	"""Flatten children and emit warnings for unkeyed iterables."""
+def _flatten_children(
+	children: Children, *, parent_name: str, warn_stacklevel: int = 5
+) -> Sequence[Element]:
+	"""Flatten children and emit warnings for unkeyed iterables (dev mode only).
+
+	Args:
+		children: The children sequence to flatten.
+		parent_name: Name of the parent element for error messages.
+		warn_stacklevel: Stack level for warnings. Adjust based on call site:
+			- 5 for Node.__init__ via tag factory (user -> tag factory -> Node.__init__ -> _flatten_children -> visit -> warn)
+			- 4 for ComponentNode.__getitem__ or Component.__call__ (user -> method -> _flatten_children -> visit -> warn)
+	"""
 	flat: list[Element] = []
 	return_tuple = isinstance(children, tuple)
+	is_dev = env.pulse_env == "dev"
 
 	def visit(item: Child) -> None:
 		if isinstance(item, Iterable) and not isinstance(item, str):
 			# If any Node/ComponentNode yielded by this iterable lacks a key,
-			# emit a single warning for this iterable.
+			# emit a single warning for this iterable (dev mode only).
 			missing_key = False
 			for sub in item:
-				if isinstance(sub, (Node, ComponentNode)) and sub.key is None:
+				if (
+					is_dev
+					and isinstance(sub, (Node, ComponentNode))
+					and sub.key is None
+				):
 					missing_key = True
 				visit(sub)
 			if missing_key:
-				# Warn once per iterable without keys on its elements
+				# Warn once per iterable without keys on its elements.
 				warnings.warn(
 					(
 						f"[Pulse] Iterable children of {parent_name} contain elements without 'key'. "
 						"Add a stable 'key' to each element inside iterables to improve reconciliation."
 					),
-					stacklevel=3,
+					stacklevel=warn_stacklevel,
 				)
 		else:
 			# Not an iterable child: must be a Element or primitive

{pulse_framework-0.1.44.dist-info → pulse_framework-0.1.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pulse-framework
-Version: 0.1.44
+Version: 0.1.46
 Summary: Pulse - Full-stack framework for building real-time React applications in Python
 Requires-Dist: websockets>=12.0
 Requires-Dist: fastapi>=0.104.0

{pulse_framework-0.1.44.dist-info → pulse_framework-0.1.46.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pulse/__init__.py,sha256=Acb_t45WP9HsPBRBtKsx5rj-u-pl8gRmdwsKKVPokK4,32721
-pulse/app.py,sha256=cVEqazFcgSnmZSxqqz6HWk2QsI8rnKbO7Y_L88BcHSc,32082
+pulse/__init__.py,sha256=s5J8i92q5Sy4h_FTPhNhirZdx-R573vtKypJiUkBwWk,32724
+pulse/app.py,sha256=-0BWA8YDlm0Hm6mPbsQKPCC_3NrhbHizoAd0WnoG0Rg,32077
 pulse/channel.py,sha256=d9eLxgyB0P9UBVkPkXV7MHkC4LWED1Cq3GKsEu_SYy4,13056
 pulse/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/cli/cmd.py,sha256=UBT7OoqWRU-idLOKkA9TDN8m8ugi1gwRMiUJTUmkVfU,14853
@@ -52,28 +52,29 @@ pulse/plugin.py,sha256=RfGl6Vtr7VRHb8bp4Ob4dOX9dVzvc4Riu7HWnStMPpk,580
 pulse/proxy.py,sha256=zh4v5lmYNg5IBE_xdHHmGPwbMQNSXb2npeLXvw_O1Oc,6591
 pulse/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/queries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pulse/queries/client.py,sha256=hZB3rAfH_fl_6ld_s9z81Vxvt8Cg0gXWU4Gj1qAL0LE,15254
+pulse/queries/client.py,sha256=GGckE0P3YCBO4Mj-08AO_I9eXVC4sIDSNw_xTLrBFuE,15224
 pulse/queries/common.py,sha256=Cr_NV0dWz5DQ7Qg771jvUms1o2-EnTYqjZJe4tVeoVk,1160
-pulse/queries/effect.py,sha256=8U7iAo3B4WB5lIcT6bE7YRnyfEYTLzNESq9KdDQsVYA,835
-pulse/queries/infinite_query.py,sha256=XBMuVApwBnzsB-toQfsyYRziMwtQhQq8wjtBzCq0qv4,36098
-pulse/queries/mutation.py,sha256=_WVRFU4BwkHrHQjEZc2mjyZTUx9Pad73xFWaFPF7I1Y,5315
-pulse/queries/query.py,sha256=MEKV8eKANFQmiWWs12ytgD9szYNbR2226EW_DkoFiNo,22037
-pulse/queries/store.py,sha256=p_WO7X-REytwkEyGjJi6XDv9tlrJX0v6E1sk1bBrPqM,3541
+pulse/queries/effect.py,sha256=7KvV_yK7OHTWhfQbZFGzg_pRhyI2mn25pKIF9AmSmcU,1471
+pulse/queries/infinite_query.py,sha256=oUHWjP2OliB7h8VDJooGocefHm4m9TDy4WaJesSrsdI,40457
+pulse/queries/mutation.py,sha256=px1fprFL-RxNfbRSoRtdsOLkEbjSsMrJxGHKBIPYQTM,4959
+pulse/queries/protocol.py,sha256=R8n238Ex9DbYIAVKB83a8FAPtnCiPNhWar-F01K2fTo,3345
+pulse/queries/query.py,sha256=G8eXCaT5wuvVcstlqWU8VBxuuUUS7K1R5Y-VtDpMIG0,35065
+pulse/queries/store.py,sha256=Ct7a-h1-Cq07zEfe9vw-LM85Fm7jIJx7CLAIlsiznlU,3444
 pulse/react_component.py,sha256=hPibKBEkVdpBKNSpMQ6bZ-7GnJQcNQwcw2SvfY1chHA,26026
-pulse/reactive.py,sha256=0CqzeowZHAENMxM2PFhi_Q6KkDzG844JofzDk0Wxckw,23961
+pulse/reactive.py,sha256=v8a9IttkabeWwYrrHAx33zqzW9WC4WlS4iXbIh2KQkU,24374
 pulse/reactive_extensions.py,sha256=WAx4hlB1ByZLFVpgtRnaWXAQ3N2QQplf647oQXDL5vg,31901
-pulse/render_session.py,sha256=kqLfZ9AxCrB2mIJqegATL1KA7CI-LZSBQwRYr7Uxo9g,14581
-pulse/renderer.py,sha256=dJiX9VeHr9kC1UBw5oaKB8Mv-3OCMGTrHiKgLJ5FL50,16759
+pulse/render_session.py,sha256=G76r9hKHzAJT2x_BWNmy-gNHyDT2NwUbkxQRrDBcKS4,14928
+pulse/renderer.py,sha256=FnfCl7c0n-YAdWfFyrLY1EceBDL2hP85UQv8PLQL20I,15891
 pulse/request.py,sha256=sPsSRWi5KvReSPBLIs_kzqomn1wlRk1BTLZ5s0chQr4,4979
 pulse/routing.py,sha256=RlrGHyK4F28_zUHMYNeKp4pNbvqrt4GY4t5xNdhzunI,13926
 pulse/serializer.py,sha256=8RAITNoSNm5-U38elHpWmkBpcM_rxZFMCluJSfldfk4,5420
 pulse/state.py,sha256=ikQbK4R8PieV96qd4uWREUvs0jXo9sCapawY7i6oCYo,10776
 pulse/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pulse/types/event_handler.py,sha256=tfKa6OEA5XvzuYbllQZJ03ooN7rGSYOtaPBstSL4OLU,1642
+pulse/types/event_handler.py,sha256=psQCydj-WEtBcFU5JU4mDwvyzkW8V2O0g_VFRU2EOHI,1618
 pulse/user_session.py,sha256=FITxLSEl3JU-jod6UWuUYC6EpnPG2rbaLCnIOdkQPtg,7803
-pulse/vdom.py,sha256=1UAjOYSmpdZeSVELqejh47Jer4mA73T_q2HtAogOphs,12514
+pulse/vdom.py,sha256=_quboxfVcUdpn5tiGrL1NESD7730620M4qA7HR9mC20,15950
 pulse/version.py,sha256=711vaM1jVIQPgkisGgKZqwmw019qZIsc_QTae75K2pg,1895
-pulse_framework-0.1.44.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-pulse_framework-0.1.44.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
-pulse_framework-0.1.44.dist-info/METADATA,sha256=MnbisSOFD9QfMar8uD3nDaZBbDe7LSL4z1KO0ZYfCb0,580
-pulse_framework-0.1.44.dist-info/RECORD,,
+pulse_framework-0.1.46.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+pulse_framework-0.1.46.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
+pulse_framework-0.1.46.dist-info/METADATA,sha256=s22qR5YwwOz1eZ3PPQAbW7hSRvZ-lDuliRKjmcp098k,580
+pulse_framework-0.1.46.dist-info/RECORD,,