pulse-framework 0.1.50__py3-none-any.whl → 0.1.52__py3-none-any.whl

pulse/renderer.py

@@ -1,212 +1,159 @@
+from __future__ import annotations
+
 import inspect
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from typing import Any, NamedTuple, TypeAlias, cast
 
 from pulse.helpers import values_equal
-from pulse.transpiler.context import interpreted_mode
-from pulse.transpiler.imports import Import
-from pulse.transpiler.nodes import JSExpr
-from pulse.vdom import (
-	VDOM,
-	Callback,
-	Callbacks,
-	ComponentNode,
+from pulse.hooks.core import HookContext
+from pulse.transpiler import Import
+from pulse.transpiler.function import Constant, JsFunction, JsxFunction
+from pulse.transpiler.nodes import (
+	Child,
+	Children,
 	Element,
+	Expr,
+	Literal,
 	Node,
-	PathDelta,
-	Props,
+	PulseNode,
+	Value,
+)
+from pulse.transpiler.vdom import (
+	VDOM,
 	ReconciliationOperation,
+	RegistryRef,
 	ReplaceOperation,
-	UpdateCallbacksOperation,
-	UpdateJsExprPathsOperation,
 	UpdatePropsDelta,
 	UpdatePropsOperation,
-	UpdateRenderPropsOperation,
+	VDOMElement,
 	VDOMNode,
 	VDOMOperation,
+	VDOMPropValue,
 )
 
+PropValue: TypeAlias = Node | Callable[..., Any]
 
-def is_jsexpr(value: object) -> bool:
-	"""Check if a value is a JSExpr or Import."""
-	return isinstance(value, (JSExpr, Import))
+FRAGMENT_TAG = ""
+MOUNT_PREFIX = "$$"
+CALLBACK_PLACEHOLDER = "$cb"
 
 
-def emit_jsexpr(value: "JSExpr | Import") -> str:
-	"""Emit a JSExpr in interpreted mode (for client-side evaluation)."""
-	with interpreted_mode():
-		if isinstance(value, Import):
-			return value.emit()
-		return value.emit()
+class Callback(NamedTuple):
+	fn: Callable[..., Any]
+	n_args: int
 
 
-RenderPath: TypeAlias = str
+Callbacks = dict[str, Callback]
+
+
+@dataclass(slots=True)
+class DiffPropsResult:
+	normalized: dict[str, PropValue]
+	delta_set: dict[str, VDOMPropValue]
+	delta_remove: set[str]
+	render_prop_reconciles: list["RenderPropTask"]
+	eval_keys: set[str]
+	eval_changed: bool
+
+
+class RenderPropTask(NamedTuple):
+	key: str
+	previous: Element | PulseNode
+	current: Element | PulseNode
+	path: str
 
 
 class RenderTree:
-	root: Element
+	root: Node
 	callbacks: Callbacks
-	render_props: set[str]
-	jsexpr_paths: set[str]  # paths containing JS expressions
+	operations: list[VDOMOperation]
+	_normalized: Node | None
 
-	def __init__(self, root: Element) -> None:
+	def __init__(self, root: Node) -> None:
 		self.root = root
 		self.callbacks = {}
-		self.render_props = set()
-		self.jsexpr_paths = set()
-		self.normalized: Element | None = None
+		self.operations = []
+		self._normalized = None
 
 	def render(self) -> VDOM:
 		renderer = Renderer()
 		vdom, normalized = renderer.render_tree(self.root)
 		self.root = normalized
 		self.callbacks = renderer.callbacks
-		self.render_props = renderer.render_props
-		self.jsexpr_paths = renderer.jsexpr_paths
-		self.normalized = normalized
+		self._normalized = normalized
 		return vdom
 
-	def diff(self, new_tree: Element) -> list[VDOMOperation]:
-		if self.normalized is None:
+	def diff(self, new_tree: Node) -> list[VDOMOperation]:
+		if self._normalized is None:
 			raise RuntimeError("RenderTree.render must be called before diff")
 
 		renderer = Renderer()
-		normalized = renderer.reconcile_tree(self.normalized, new_tree, path="")
-
-		callback_prev = set(self.callbacks.keys())
-		callback_next = set(renderer.callbacks.keys())
-		callback_add = sorted(callback_next - callback_prev)
-		callback_remove = sorted(callback_prev - callback_next)
-
-		render_props_prev = self.render_props
-		render_props_next = renderer.render_props
-		render_props_add = sorted(render_props_next - render_props_prev)
-		render_props_remove = sorted(render_props_prev - render_props_next)
-
-		prefix: list[VDOMOperation] = []
-
-		if callback_add or callback_remove:
-			callback_delta: PathDelta = {}
-			if callback_add:
-				callback_delta["add"] = callback_add
-			if callback_remove:
-				callback_delta["remove"] = callback_remove
-			prefix.append(
-				UpdateCallbacksOperation(
-					type="update_callbacks", path="", data=callback_delta
-				)
-			)
-
-		if render_props_add or render_props_remove:
-			render_props_delta: PathDelta = {}
-			if render_props_add:
-				render_props_delta["add"] = render_props_add
-			if render_props_remove:
-				render_props_delta["remove"] = render_props_remove
-			prefix.append(
-				UpdateRenderPropsOperation(
-					type="update_render_props", path="", data=render_props_delta
-				)
-			)
-
-		jsexpr_prev = self.jsexpr_paths
-		jsexpr_next = renderer.jsexpr_paths
-		jsexpr_add = sorted(jsexpr_next - jsexpr_prev)
-		jsexpr_remove = sorted(jsexpr_prev - jsexpr_next)
-		if jsexpr_add or jsexpr_remove:
-			jsexpr_delta: PathDelta = {}
-			if jsexpr_add:
-				jsexpr_delta["add"] = jsexpr_add
-			if jsexpr_remove:
-				jsexpr_delta["remove"] = jsexpr_remove
-			prefix.append(
-				UpdateJsExprPathsOperation(
-					type="update_jsexpr_paths", path="", data=jsexpr_delta
-				)
-			)
-
-		ops = prefix + renderer.operations if prefix else renderer.operations
+		normalized = renderer.reconcile_tree(self._normalized, new_tree, path="")
 
 		self.callbacks = renderer.callbacks
-		self.render_props = renderer.render_props
-		self.jsexpr_paths = renderer.jsexpr_paths
-		self.normalized = normalized
+		self._normalized = normalized
 		self.root = normalized
 
-		return ops
+		return renderer.operations
 
 	def unmount(self) -> None:
-		if self.normalized is not None:
-			unmount_element(self.normalized)
-			self.normalized = None
+		if self._normalized is not None:
+			unmount_element(self._normalized)
+			self._normalized = None
 		self.callbacks.clear()
-		self.render_props.clear()
-		self.jsexpr_paths.clear()
-
 
-# Prefix for JSExpr values - code is embedded after the colon
-JSEXPR_PREFIX = "$js:"
-
-
-@dataclass(slots=True)
-class DiffPropsResult:
-	normalized: Props
-	delta_set: Props
-	delta_remove: set[str]
-	render_prop_reconciles: list["RenderPropTask"]
-
-
-class RenderPropTask(NamedTuple):
-	key: str
-	previous: Element
-	current: Element
-	path: RenderPath
+	@property
+	def normalized(self) -> Node | None:
+		return self._normalized
 
 
 class Renderer:
 	def __init__(self) -> None:
 		self.callbacks: Callbacks = {}
-		self.render_props: set[str] = set()
-		self.jsexpr_paths: set[str] = set()
 		self.operations: list[VDOMOperation] = []
 
 	# ------------------------------------------------------------------
 	# Rendering helpers
 	# ------------------------------------------------------------------
 
-	def render_tree(self, node: Element, path: RenderPath = "") -> tuple[VDOM, Element]:
-		if isinstance(node, ComponentNode):
+	def render_tree(self, node: Node, path: str = "") -> tuple[Any, Node]:
+		if isinstance(node, PulseNode):
 			return self.render_component(node, path)
-		if isinstance(node, Node):
+		if isinstance(node, Element):
 			return self.render_node(node, path)
-		# Handle JSExpr as children - emit JS code with $js: prefix
-		if is_jsexpr(node):
-			# Safe cast: is_jsexpr() ensures node is JSExpr | Import
-			node_as_jsexpr = cast("JSExpr | Import", cast(object, node))
-			js_code = emit_jsexpr(node_as_jsexpr)
-			self.jsexpr_paths.add(path)
-			return f"{JSEXPR_PREFIX}{js_code}", cast(Element, node)
-		return node, node
+		if isinstance(node, Value):
+			json_value = coerce_json(node.value, path)
+			return json_value, json_value
+		if isinstance(node, Expr):
+			return node.render(), node
+		if is_json_primitive(node):
+			return node, node
+		raise TypeError(f"Unsupported node type: {type(node).__name__}")
 
 	def render_component(
-		self, component: ComponentNode, path: RenderPath
-	) -> tuple[VDOM, ComponentNode]:
+		self, component: PulseNode, path: str
+	) -> tuple[VDOM, PulseNode]:
+		if component.hooks is None:
+			component.hooks = HookContext()
 		with component.hooks:
 			rendered = component.fn(*component.args, **component.kwargs)
 		vdom, normalized_child = self.render_tree(rendered, path)
 		component.contents = normalized_child
 		return vdom, component
 
-	def render_node(self, element: Node, path: RenderPath) -> tuple[VDOMNode, Node]:
-		vdom_node: VDOMNode = {"tag": element.tag}
-		if element.key is not None:
-			vdom_node["key"] = element.key
+	def render_node(self, element: Element, path: str) -> tuple[VDOMNode, Element]:
+		tag = self.render_tag(element.tag)
+		vdom_node: VDOMElement = {"tag": tag}
+		if (key_val := key_value(element)) is not None:
+			vdom_node["key"] = key_val
 
 		props = element.props or {}
-		props_result = self.diff_props({}, props, path)
+		props_result = self.diff_props({}, props, path, prev_eval=set())
 		if props_result.delta_set:
 			vdom_node["props"] = props_result.delta_set
+		if props_result.eval_keys:
+			vdom_node["eval"] = sorted(props_result.eval_keys)
 
 		for task in props_result.render_prop_reconciles:
 			normalized_value = self.reconcile_tree(
@@ -217,7 +164,7 @@ class Renderer:
 		element.props = props_result.normalized or None
 
 		children_vdom: list[VDOM] = []
-		normalized_children: list[Element] = []
+		normalized_children: list[Node] = []
 		for idx, child in enumerate(normalize_children(element.children)):
 			child_path = join_path(path, idx)
 			child_vdom, normalized_child = self.render_tree(child, child_path)
@@ -236,10 +183,14 @@ class Renderer:
 
 	def reconcile_tree(
 		self,
-		previous: Element,
-		current: Element,
-		path: RenderPath = "",
-	) -> Element:
+		previous: Node,
+		current: Node,
+		path: str = "",
+	) -> Node:
+		if isinstance(current, Value):
+			current = coerce_json(current.value, path)
+		if isinstance(previous, Value):
+			previous = coerce_json(previous.value, path)
 		if not same_node(previous, current):
 			unmount_element(previous)
 			new_vdom, normalized = self.render_tree(current, path)
@@ -248,23 +199,26 @@ class Renderer:
 			)
 			return normalized
 
-		if isinstance(previous, ComponentNode) and isinstance(current, ComponentNode):
+		if isinstance(previous, PulseNode) and isinstance(current, PulseNode):
 			return self.reconcile_component(previous, current, path)
 
-		if isinstance(previous, Node) and isinstance(current, Node):
+		if isinstance(previous, Element) and isinstance(current, Element):
 			return self.reconcile_element(previous, current, path)
 
 		return current
 
 	def reconcile_component(
 		self,
-		previous: ComponentNode,
-		current: ComponentNode,
-		path: RenderPath,
-	) -> ComponentNode:
+		previous: PulseNode,
+		current: PulseNode,
+		path: str,
+	) -> PulseNode:
 		current.hooks = previous.hooks
 		current.contents = previous.contents
 
+		if current.hooks is None:
+			current.hooks = HookContext()
+
 		with current.hooks:
 			rendered = current.fn(*current.args, **current.kwargs)
 
@@ -281,20 +235,27 @@ class Renderer:
 
 	def reconcile_element(
 		self,
-		previous: Node,
-		current: Node,
-		path: RenderPath,
-	) -> Node:
+		previous: Element,
+		current: Element,
+		path: str,
+	) -> Element:
 		prev_props = previous.props or {}
 		new_props = current.props or {}
-		props_result = self.diff_props(prev_props, new_props, path)
-
-		if props_result.delta_set or props_result.delta_remove:
+		prev_eval = eval_keys_for_props(prev_props)
+		props_result = self.diff_props(prev_props, new_props, path, prev_eval)
+
+		if (
+			props_result.delta_set
+			or props_result.delta_remove
+			or props_result.eval_changed
+		):
 			delta: UpdatePropsDelta = {}
 			if props_result.delta_set:
 				delta["set"] = props_result.delta_set
 			if props_result.delta_remove:
 				delta["remove"] = sorted(props_result.delta_remove)
+			if props_result.eval_changed:
+				delta["eval"] = sorted(props_result.eval_keys)
 			self.operations.append(
 				UpdatePropsOperation(type="update_props", path=path, data=delta)
 			)
@@ -311,58 +272,50 @@ class Renderer:
 			prev_children, next_children, path
 		)
 
-		# Mutate the current node to avoid allocations
 		current.props = props_result.normalized or None
 		current.children = normalized_children
 		return current
 
 	def reconcile_children(
 		self,
-		c1: list[Element],
-		c2: list[Element],
-		path: RenderPath,
-	) -> list[Element]:
+		c1: list[Node],
+		c2: list[Node],
+		path: str,
+	) -> list[Node]:
 		if not c1 and not c2:
 			return []
 
 		N1 = len(c1)
 		N2 = len(c2)
-		norm: list[Element] = [None] * N2
+		norm: list[Node | None] = [None] * N2
 		N = min(N1, N2)
 		i = 0
-		# Fast path: if elements haven't changed, perform a single pass
 		while i < N:
 			x1 = c1[i]
 			x2 = c2[i]
 			if not same_node(x1, x2):
-				break  # enter keyed reconciliation
+				break
 			norm[i] = self.reconcile_tree(x1, x2, join_path(path, i))
 			i += 1
 
-		# Exits if previous and current children lists are of the same size and
-		# the previous loop did not break. Also works for empty lists.
 		if i == N1 == N2:
 			return norm
 
-		# Enter keyed reconciliation. We emit the reconciliation op in advance,
-		# as further ops will use the post-reconciliation paths.
 		op = ReconciliationOperation(
 			type="reconciliation", path=path, N=len(c2), new=([], []), reuse=([], [])
 		)
 		self.operations.append(op)
 
-		# Build key index
 		keys_to_old_idx: dict[str, int] = {}
 		for j1 in range(i, N1):
-			if key := getattr(c1[j1], "key", None):
+			key = key_value(c1[j1])
+			if key is not None:
 				keys_to_old_idx[key] = j1
 
-		# Build the reconciliation instructions
 		reused = [False] * (N1 - i)
 		for j2 in range(i, N2):
 			x2 = c2[j2]
-			# Case 1: this is a keyed node, try to reuse it if it already existed
-			k = getattr(x2, "key", None)
+			k = key_value(x2)
 			if k is not None:
 				j1 = keys_to_old_idx.get(k)
 				if j1 is not None:
@@ -374,21 +327,18 @@ class Renderer:
 							op["reuse"][0].append(j2)
 							op["reuse"][1].append(j1)
 						continue
-			# Case 2: try to reuse the node at the same position
-			if not k and j2 < N1:
+			if k is None and j2 < N1:
 				x1 = c1[j2]
 				if same_node(x1, x2):
 					reused[j2 - i] = True
 					norm[j2] = self.reconcile_tree(x1, x2, join_path(path, j2))
 					continue
 
-			# Case 3: this is a new node, render it at the new path
 			vdom, el = self.render_tree(x2, join_path(path, j2))
 			op["new"][0].append(j2)
 			op["new"][1].append(vdom)
 			norm[j2] = el
 
-		# Unmount old nodes we haven't reused
 		for j1 in range(i, N1):
 			if not reused[j1 - i]:
 				self.unmount_subtree(c1[j1])
@@ -401,43 +351,26 @@ class Renderer:
 
 	def diff_props(
 		self,
-		previous: Props,
-		current: Props,
-		path: RenderPath,
+		previous: dict[str, PropValue],
+		current: dict[str, PropValue],
+		path: str,
+		prev_eval: set[str],
 	) -> DiffPropsResult:
-		updated: Props = {}
-		normalized: Props | None = None
+		updated: dict[str, VDOMPropValue] = {}
+		normalized: dict[str, PropValue] | None = None
 		render_prop_tasks: list[RenderPropTask] = []
+		eval_keys: set[str] = set()
 		removed_keys = set(previous.keys()) - set(current.keys())
 
 		for key, value in current.items():
 			old_value = previous.get(key)
 			prop_path = join_path(path, key)
 
-			if is_jsexpr(value):
-				if isinstance(old_value, (Node, ComponentNode)):
-					unmount_element(old_value)
-				if normalized is None:
-					normalized = current.copy()
-				normalized[key] = value
-				# Emit the JSExpr with $js: prefix - code is embedded in the value
-				js_code = emit_jsexpr(cast("JSExpr | Import", value))
-				self.jsexpr_paths.add(prop_path)
-				js_value = f"{JSEXPR_PREFIX}{js_code}"
-				old_js_code = (
-					emit_jsexpr(cast("JSExpr | Import", old_value))
-					if is_jsexpr(old_value)
-					else None
-				)
-				if old_js_code != js_code:
-					updated[key] = js_value
-				continue
-
-			if isinstance(value, (Node, ComponentNode)):
-				if normalized is None:
-					normalized = current.copy()
-				self.render_props.add(prop_path)
-				if isinstance(old_value, (Node, ComponentNode)):
+			if isinstance(value, (Element, PulseNode)):
+				eval_keys.add(key)
+				if isinstance(old_value, (Element, PulseNode)):
+					if normalized is None:
+						normalized = current.copy()
 					normalized[key] = old_value
 					render_prop_tasks.append(
 						RenderPropTask(
@@ -449,100 +382,240 @@ class Renderer:
 					)
 				else:
 					vdom_value, normalized_value = self.render_tree(value, prop_path)
+					if normalized is None:
+						normalized = current.copy()
 					normalized[key] = normalized_value
-					updated[key] = vdom_value
+					updated[key] = cast(VDOMPropValue, vdom_value)
+				continue
+
+			if isinstance(value, Value):
+				json_value = coerce_json(value.value, prop_path)
+				if normalized is None:
+					normalized = current.copy()
+				normalized[key] = json_value
+				if isinstance(old_value, (Element, PulseNode)):
+					unmount_element(old_value)
+				if key not in previous or not values_equal(json_value, old_value):
+					updated[key] = cast(VDOMPropValue, json_value)
+				continue
+
+			if isinstance(value, Expr):
+				eval_keys.add(key)
+				if isinstance(old_value, (Element, PulseNode)):
+					unmount_element(old_value)
+				if normalized is None:
+					normalized = current.copy()
+				normalized[key] = value
+				if not (isinstance(old_value, Expr) and values_equal(old_value, value)):
+					updated[key] = value.render()
 				continue
 
 			if callable(value):
-				if isinstance(old_value, (Node, ComponentNode)):
+				eval_keys.add(key)
+				if isinstance(old_value, (Element, PulseNode)):
 					unmount_element(old_value)
 				if normalized is None:
 					normalized = current.copy()
-				normalized[key] = "$cb"
-				register_callback(
-					self.callbacks, prop_path, cast(Callable[..., Any], value)
-				)
-				if old_value != "$cb":
-					updated[key] = "$cb"
+				normalized[key] = value
+				register_callback(self.callbacks, prop_path, value)
+				if not callable(old_value):
+					updated[key] = CALLBACK_PLACEHOLDER
 				continue
 
-			if isinstance(old_value, (Node, ComponentNode)):
+			json_value = coerce_json(value, prop_path)
+			if isinstance(old_value, (Element, PulseNode)):
 				unmount_element(old_value)
-
 			if normalized is not None:
-				normalized[key] = value
-
-			if key not in previous or not values_equal(value, old_value):
-				updated[key] = value
+				normalized[key] = json_value
+			elif json_value is not value:
+				normalized = current.copy()
+				normalized[key] = json_value
+			if key not in previous or not values_equal(json_value, old_value):
+				updated[key] = cast(VDOMPropValue, json_value)
 
 		for key in removed_keys:
 			old_value = previous.get(key)
-			if isinstance(old_value, (Node, ComponentNode)):
+			if isinstance(old_value, (Element, PulseNode)):
 				unmount_element(old_value)
 
 		normalized_props = normalized if normalized is not None else current.copy()
+		eval_changed = eval_keys != prev_eval
 		return DiffPropsResult(
 			normalized=normalized_props,
 			delta_set=updated,
 			delta_remove=removed_keys,
 			render_prop_reconciles=render_prop_tasks,
+			eval_keys=eval_keys,
+			eval_changed=eval_changed,
 		)
 
+	# ------------------------------------------------------------------
+	# Expression + tag rendering
+	# ------------------------------------------------------------------
+
+	def render_tag(self, tag: str | Expr) -> str:
+		if isinstance(tag, str):
+			return tag
+
+		key = self.register_component_expr(tag)
+		return f"{MOUNT_PREFIX}{key}"
+
+	def register_component_expr(self, expr: Expr) -> str:
+		ref = registry_ref(expr)
+		if ref is None:
+			raise TypeError(
+				"Component tag expressions must be registry-backed Expr values "
+				+ "(Import/JsFunction/Constant/JsxFunction)."
+			)
+		return ref["key"]
+
 	# ------------------------------------------------------------------
 	# Unmount helper
 	# ------------------------------------------------------------------
 
-	def unmount_subtree(self, node: Element) -> None:
+	def unmount_subtree(self, node: Node) -> None:
 		unmount_element(node)
 
 
-def normalize_children(children: Sequence[Element] | None) -> list[Element]:
+# ----------------------------------------------------------------------
+# Helpers
+# ----------------------------------------------------------------------
+
+
+def registry_ref(expr: Expr) -> RegistryRef | None:
+	if isinstance(expr, (Import, JsFunction, Constant, JsxFunction)):
+		return {"t": "ref", "key": expr.id}
+	return None
+
+
+def is_json_primitive(value: Any) -> bool:
+	return value is None or isinstance(value, (str, int, float, bool))
+
+
+def coerce_json(value: Any, path: str) -> Any:
+	"""Convert Python value to JSON-compatible structure.
+
+	Performs runtime conversions:
+	- tuple → list
+	- validates dict keys are strings
+	"""
+	if is_json_primitive(value):
+		return value
+	if isinstance(value, (list, tuple)):
+		return [coerce_json(v, path) for v in value]
+	if isinstance(value, dict):
+		out: dict[str, Any] = {}
+		for k, v in value.items():
+			if not isinstance(k, str):
+				raise TypeError(f"Non-string prop key at {path}: {k!r}")
+			out[k] = coerce_json(v, path)
+		return out
+	raise TypeError(f"Unsupported JSON value at {path}: {type(value).__name__}")
+
+
+def prop_requires_eval(value: PropValue) -> bool:
+	if isinstance(value, Value):
+		return False
+	if isinstance(value, (Element, PulseNode)):
+		return True
+	if isinstance(value, Expr):
+		return True
+	return callable(value)
+
+
+def eval_keys_for_props(props: dict[str, PropValue]) -> set[str]:
+	eval_keys: set[str] = set()
+	for key, value in props.items():
+		if prop_requires_eval(value):
+			eval_keys.add(key)
+	return eval_keys
+
+
+def normalize_children(children: Children | None) -> list[Node]:
 	if not children:
 		return []
-	return list(children)
+
+	out: list[Node] = []
+	seen_keys: set[str] = set()
+
+	def register_key(item: Node) -> None:
+		key: str | None = None
+		if isinstance(item, PulseNode):
+			key = item.key
+		elif isinstance(item, Element):
+			key = key_value(item)
+		if key is None:
+			return
+		if key in seen_keys:
+			raise ValueError(f"Duplicate key '{key}'")
+		seen_keys.add(key)
+
+	def visit(item: Child) -> None:
+		if isinstance(item, dict):
+			raise TypeError("Dict is not a valid child; wrap in Value for props")
+		if isinstance(item, Iterable) and not isinstance(item, (str, bytes)):
+			for sub in item:
+				visit(sub)
+		else:
+			node = cast(Node, item)
+			register_key(node)
+			out.append(node)
+
+	for child in children:
+		visit(child)
+
+	return out
 
 
 def register_callback(
 	callbacks: Callbacks,
-	path: RenderPath,
+	path: str,
 	fn: Callable[..., Any],
 ) -> None:
 	n_args = len(inspect.signature(fn).parameters)
 	callbacks[path] = Callback(fn=fn, n_args=n_args)
 
 
-def join_path(prefix: RenderPath, path: str | int) -> RenderPath:
+def join_path(prefix: str, path: str | int) -> str:
 	if prefix:
 		return f"{prefix}.{path}"
 	return str(path)
 
 
-def same_node(left: Element, right: Element) -> bool:
+def same_node(left: Node, right: Node) -> bool:
 	if values_equal(left, right):
 		return True
-	if isinstance(left, Node) and isinstance(right, Node):
-		return left.tag == right.tag and left.key == right.key
-	if isinstance(left, ComponentNode) and isinstance(right, ComponentNode):
-		return left.fn == right.fn and left.key == right.key
+	if isinstance(left, Element) and isinstance(right, Element):
+		return values_equal(left.tag, right.tag) and key_value(left) == key_value(right)
+	if isinstance(left, PulseNode) and isinstance(right, PulseNode):
+		return left.fn == right.fn and key_value(left) == key_value(right)
 	return False
 
 
-def unmount_element(element: Element) -> None:
-	if isinstance(element, ComponentNode):
+def key_value(node: Node | Node) -> str | None:
+	key = getattr(node, "key", None)
+	if isinstance(key, Literal):
+		if not isinstance(key.value, str):
+			raise TypeError("Element key must be a string")
+		return key.value
+	return cast(str | None, key)
+
+
+def unmount_element(element: Node) -> None:
+	if isinstance(element, PulseNode):
 		if element.contents is not None:
 			unmount_element(element.contents)
 			element.contents = None
-		element.hooks.unmount()
+		if element.hooks is not None:
+			element.hooks.unmount()
 		return
 
-	if isinstance(element, Node):
+	if isinstance(element, Element):
 		props = element.props or {}
 		for value in props.values():
-			if isinstance(value, (Node, ComponentNode)):
+			if isinstance(value, (Element, PulseNode)):
 				unmount_element(value)
 		for child in normalize_children(element.children):
 			unmount_element(child)
 		element.children = []
 		return
-
-	# Primitive -> nothing to unmount