@absolutejs/absolute 0.19.0-beta.830 → 0.19.0-beta.832

package/dist/svelte/router/Route.svelte

@@ -2,8 +2,7 @@
 	import { getContext, onDestroy, type Snippet } from 'svelte';
 	import type { ExtractRouteParams } from '../../types/svelteRouter';
 	import type { RouterRegistry } from './Router.svelte';
-	import { compilePattern, joinBasepath, matchPattern } from './matchPath';
-	import { page } from './page.js';
+	import { compilePattern, joinBasepath } from './matchPath';
 
 	const ROUTER_CONTEXT_KEY = Symbol.for('absolutejs.svelte-router');
 
@@ -26,18 +25,22 @@
 	const registrationOrder = Number(id.slice(1));
 
 	// Register synchronously at script-body time so SSR (which doesn't
-	// run $effect) sees the registration. On the client, $effect
-	// re-registers when path or basepath changes.
+	// run $effect) sees the registration. The Router itself owns
+	// rendering of the winning route's content — Route emits no DOM and
+	// no hydration markers, so a page with N <Route>s produces ONE
+	// `{#if}` block in the rendered HTML, not N.
 	const initialCompiled = compilePattern(
 		joinBasepath(registry.basepath, path)
 	);
 	registry.register(id, {
+		content: content as Snippet<[Record<string, string | undefined>]>,
 		pattern: initialCompiled,
 		registrationOrder
 	});
 
 	$effect(() => {
 		registry.register(id, {
+			content: content as Snippet<[Record<string, string | undefined>]>,
 			pattern: compilePattern(joinBasepath(registry.basepath, path)),
 			registrationOrder
 		});
@@ -45,11 +48,3 @@
 
 	onDestroy(() => registry.deregister(id));
 </script>
-
-{#if registry.isWinner(id)}
-	{@const compiled = compilePattern(joinBasepath(registry.basepath, path))}
-	{@const match = matchPattern<Path>(compiled, page.url.pathname)}
-	{#if match.matched}
-		{@render content(match.params)}
-	{/if}
-{/if}

package/dist/svelte/router/Router.svelte

@@ -1,23 +1,28 @@
 <script lang="ts" module>
-	type CompiledPatternBox = {
+	import type { Snippet } from 'svelte';
+
+	type RouteEntry = {
 		// reactive — read by the winner-resolver
 		pattern: ReturnType<typeof import('./matchPath').compilePattern>;
 		// stable — assigned at registration time, used as tiebreaker
 		registrationOrder: number;
+		// the snippet the winning Route should render — extraction lives
+		// on the Router so the active branch renders inside ONE if-block
+		// instead of one per Route (one set of hydration markers, not N)
+		content: Snippet<[Record<string, string | undefined>]>;
 	};
 
 	export type RouterRegistry = {
 		basepath: string;
 		mode: import('../../types/svelteRouter').RouterMode;
-		register: (id: string, entry: CompiledPatternBox) => void;
+		register: (id: string, entry: RouteEntry) => void;
 		deregister: (id: string) => void;
-		isWinner: (id: string) => boolean;
 		nextRouteId: () => string;
 	};
 </script>
 
 <script lang="ts">
-	import { getContext, onMount, setContext, type Snippet } from 'svelte';
+	import { getContext, onMount, setContext } from 'svelte';
 	import type { RouterMode } from '../../types/svelteRouter';
 	import { setRouterMode } from './goto';
 	import { hashPathnameOf } from './hashMode';
@@ -59,15 +64,16 @@
 	const isOutermost = parent === undefined;
 
 	// Specificity ranking across siblings: each <Route> registers with
-	// its compiled pattern + a stable mount-order index. The winner is
-	// recomputed eagerly inside `isWinner()` rather than via $derived —
-	// that avoids an SSR timing edge where $derived caches a value from
-	// before later siblings have registered.
-	const routes = $state(new Map<string, CompiledPatternBox>());
+	// its compiled pattern + content snippet + a stable mount-order
+	// index. The winner is computed lazily from the current URL — highest
+	// score wins; ties break by earlier registration order.
+	const routes = $state(new Map<string, RouteEntry>());
 	let routeCounter = 0;
 
-	const computeWinnerId = () => {
+	const computeWinner = () => {
 		let bestId: string | null = null;
+		let bestEntry: RouteEntry | null = null;
+		let bestParams: Record<string, string | undefined> | null = null;
 		let bestScore = -Infinity;
 		let bestOrder = Infinity;
 
@@ -83,10 +89,14 @@
 				bestScore = entry.pattern.score;
 				bestOrder = entry.registrationOrder;
 				bestId = id;
+				bestEntry = entry;
+				bestParams = match.params as Record<string, string | undefined>;
 			}
 		}
 
-		return bestId;
+		return bestId && bestEntry && bestParams
+			? { content: bestEntry.content, params: bestParams }
+			: null;
 	};
 
 	const registry: RouterRegistry = {
@@ -94,7 +104,6 @@
 		deregister: (id) => {
 			routes.delete(id);
 		},
-		isWinner: (id) => computeWinnerId() === id,
 		mode: stackedMode,
 		nextRouteId: () => `r${routeCounter++}`,
 		register: (id, entry) => {
@@ -104,6 +113,10 @@
 
 	setContext<RouterRegistry>(ROUTER_CONTEXT_KEY, registry);
 
+	// Recompute on every page.url change OR routes registry mutation.
+	// Reading $state during $derived auto-tracks both dependencies.
+	const winner = $derived(computeWinner());
+
 	if (isOutermost) {
 		setRouterMode(stackedMode);
 
@@ -163,3 +176,6 @@
 </script>
 
 {@render children?.()}
+{#if winner}
+	{@render winner.content(winner.params)}
+{/if}

package/package.json

@@ -384,5 +384,5 @@
 			]
 		}
 	},
-	"version": "0.19.0-beta.830"
+	"version": "0.19.0-beta.832"
 }