@absolutejs/absolute 0.19.0-beta.837 → 0.19.0-beta.839

package/dist/svelte/router/Route.svelte

@@ -25,26 +25,30 @@
 	const registrationOrder = Number(id.slice(1));
 
 	// Register synchronously at script-body time so SSR (which doesn't
-	// 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)
-	);
+	// run $effect) sees the registration before the template runs.
 	registry.register(id, {
-		content: content as Snippet<[Record<string, string | undefined>]>,
-		pattern: initialCompiled,
+		pattern: compilePattern(joinBasepath(registry.basepath, path)),
 		registrationOrder
 	});
 
 	$effect(() => {
 		registry.register(id, {
-			content: content as Snippet<[Record<string, string | undefined>]>,
 			pattern: compilePattern(joinBasepath(registry.basepath, path)),
 			registrationOrder
 		});
 	});
 
 	onDestroy(() => registry.deregister(id));
+
+	// The Router computes the active match across all registered Routes
+	// (specificity-ranked). Each Route checks if it's the winner and
+	// renders its own content at its own location in the markup. That
+	// way `<Route>` nested inside a layout `<section>` renders inside
+	// that section instead of getting hoisted to the Router's root.
+	const match = $derived(registry.getActiveMatch());
+	const isActive = $derived(match?.id === id);
 </script>
+
+{#if isActive && match}
+	{@render content(match.params as ExtractRouteParams<Path>)}
+{/if}

package/dist/svelte/router/Router.svelte

@@ -1,15 +1,14 @@
 <script lang="ts" module>
-	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>]>;
+	};
+
+	type ActiveMatch = {
+		id: string;
+		params: Record<string, string | undefined>;
 	};
 
 	export type RouterRegistry = {
@@ -18,11 +17,16 @@
 		register: (id: string, entry: RouteEntry) => void;
 		deregister: (id: string) => void;
 		nextRouteId: () => string;
+		// Returns the currently-winning Route's id and matched params, or null
+		// if no Route matches. Routes call this to decide whether to render.
+		// Reads $state internally, so callers using it inside $derived/$effect
+		// auto-subscribe to URL + registration changes.
+		getActiveMatch: () => ActiveMatch | null;
 	};
 </script>
 
 <script lang="ts">
-	import { getContext, onMount, setContext } from 'svelte';
+	import { getContext, onMount, setContext, type Snippet } from 'svelte';
 	import type { RouterMode } from '../../types/svelteRouter';
 	import { setRouterMode } from './goto';
 	import { hashPathnameOf } from './hashMode';
@@ -64,15 +68,17 @@
 	const isOutermost = parent === undefined;
 
 	// Specificity ranking across siblings: each <Route> registers with
-	// 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.
+	// its compiled pattern + a stable mount-order index. The winner is
+	// computed lazily from the current URL — highest score wins; ties
+	// break by earlier registration order. The winning Route then renders
+	// its own content at ITS location in the markup (so a Route nested
+	// inside a layout `<section>` renders inside that section, not at the
+	// Router's root).
 	const routes = $state(new Map<string, RouteEntry>());
 	let routeCounter = 0;
 
-	const computeWinner = () => {
+	const computeWinner = (): ActiveMatch | null => {
 		let bestId: string | null = null;
-		let bestEntry: RouteEntry | null = null;
 		let bestParams: Record<string, string | undefined> | null = null;
 		let bestScore = -Infinity;
 		let bestOrder = Infinity;
@@ -89,21 +95,25 @@
 				bestScore = entry.pattern.score;
 				bestOrder = entry.registrationOrder;
 				bestId = id;
-				bestEntry = entry;
 				bestParams = match.params as Record<string, string | undefined>;
 			}
 		}
 
-		return bestId && bestEntry && bestParams
-			? { content: bestEntry.content, params: bestParams }
+		return bestId && bestParams
+			? { id: bestId, params: bestParams }
 			: null;
 	};
 
+	// Recompute on every page.url change OR routes registry mutation.
+	// Reading $state during $derived auto-tracks both dependencies.
+	const winner = $derived(computeWinner());
+
 	const registry: RouterRegistry = {
 		basepath: stackedBasepath,
 		deregister: (id) => {
 			routes.delete(id);
 		},
+		getActiveMatch: () => winner,
 		mode: stackedMode,
 		nextRouteId: () => `r${routeCounter++}`,
 		register: (id, entry) => {
@@ -113,10 +123,6 @@
 
 	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);
 
@@ -176,6 +182,3 @@
 </script>
 
 {@render children?.()}
-{#if winner}
-	{@render winner.content(winner.params)}
-{/if}

package/dist/svelte/server.js

@@ -2725,11 +2725,26 @@ var restorePrimedStream = (firstChunk, reader) => new ReadableStream({
     pumpLoop();
   }
 });
+var resolveRequestPathname = (request) => {
+  if (!request)
+    return;
+  try {
+    const parsed = new URL(request.url);
+    return `${parsed.pathname}${parsed.search}`;
+  } catch {
+    return;
+  }
+};
 var handleSveltePageRequest = async (input) => {
   const resolvedIndexPath = input.indexPath;
   const resolvedOptions = input;
   const resolvedPagePath = input.pagePath;
-  const resolvedProps = input.props;
+  const userProps = input.props;
+  const requestPathname = resolveRequestPathname(input.request);
+  const resolvedProps = requestPathname !== undefined && (!userProps || !("url" in userProps)) ? {
+    ...userProps ?? {},
+    url: requestPathname
+  } : userProps;
   if (isSsrCacheDirty("svelte")) {
     return buildDirtyResponse(resolvedIndexPath, resolvedProps);
   }
@@ -2797,5 +2812,5 @@ export {
   handleSveltePageRequest
 };
 
-//# debugId=B8C8F2877A6C528964756E2164756E21
+//# debugId=6E5BE74C546EE7C964756E2164756E21
 //# sourceMappingURL=server.js.map