router

func TestShellRerenderKeepsPageBuiltDOM(t *testing.T)

{
	Reset()
	if dom.ByID("app").IsNull() {
		host := dom.CreateElement("div")
		host.SetAttr("id", "app")
		dom.Doc().Body().AppendChild(host)
	}

	shellStore := state.NewStore("shellpreserve", state.WithModule("app"))
	shellStore.Set("nav", []any{map[string]any{"label": "one"}})
	defer state.GlobalStoreManager.UnregisterStore("app", "shellpreserve")

	shell := core.NewHTMLComponent("PreserveShell", []byte(`<root>
@for:it in store:app.shellpreserve.nav
<span class="nav">@prop:it.label</span>
@endfor
@include:outlet
</root>`), nil)
	shell.SetComponent(shell)
	shell.AddDependency("outlet", NewOutlet())
	shell.Init(nil)

	page := core.NewHTMLComponent("PreservePage", []byte(`<root><div data-card></div></root>`), nil)
	page.SetComponent(page)
	page.Init(nil)
	Page("/preserve-test", page)

	MountRoot(shell)
	Navigate("/preserve-test")

	// the page fills its card after mount, the way a fetch callback would
	dom.Query("[data-card]").SetHTML(`<b id="page-built">built</b>`)
	if !strings.Contains(dom.ByID("app").HTML(), "page-built") {
		t.Fatal("card was not injected")
	}

	shellStore.Set("nav", []any{map[string]any{"label": "one"}, map[string]any{"label": "two"}})
	waitForRouterRender()

	html := dom.ByID("app").HTML()
	if !strings.Contains(html, "two") {
		t.Fatalf("shell did not re-render: %s", html)
	}
	if !strings.Contains(html, "page-built") {
		t.Fatalf("shell re-render wiped the DOM the page had built: %s", html)
	}
}

func TestOutletSurvivesShellRerender(t *testing.T)

{
	Reset()
	if dom.ByID("app").IsNull() {
		host := dom.CreateElement("div")
		host.SetAttr("id", "app")
		dom.Doc().Body().AppendChild(host)
	}

	shellStore := state.NewStore("shellrepaint", state.WithModule("app"))
	shellStore.Set("title", "first")
	shellStore.Set("nav", []any{map[string]any{"label": "one"}})
	defer state.GlobalStoreManager.UnregisterStore("app", "shellrepaint")

	// a @for over a store list is the shape that re-renders the whole shell
	shell := core.NewHTMLComponent("RepaintShell", []byte(`<root>
<header>@store:app.shellrepaint.title</header>
@for:it in store:app.shellrepaint.nav
<span class="nav">@prop:it.label</span>
@endfor
@include:outlet
</root>`), nil)
	shell.SetComponent(shell)
	shell.AddDependency("outlet", NewOutlet())
	shell.Init(nil)

	page := core.NewHTMLComponent("RepaintPage", []byte(`<root><main id="routed-page">page</main></root>`), nil)
	page.SetComponent(page)
	page.Init(nil)
	Page("/repaint-test", page)

	MountRoot(shell)
	Navigate("/repaint-test")

	if html := dom.ByID("app").HTML(); !strings.Contains(html, "routed-page") {
		t.Fatalf("page did not render into the outlet: %s", html)
	}

	shellStore.Set("nav", []any{map[string]any{"label": "one"}, map[string]any{"label": "two"}})
	waitForRouterRender()

	html := dom.ByID("app").HTML()
	if !strings.Contains(html, "two") {
		t.Fatalf("shell did not re-render: %s", html)
	}
	if !strings.Contains(html, "routed-page") {
		t.Fatalf("shell re-render dropped the routed page: %s", html)
	}
}

func RevalidateContext(parent context.Context) error

{
	// A caller with no context to give passes none, the way Revalidate does.
	// Normalized here, at the one entry point: a redirect derives its context
	// from this parent, and deriving from a nil one panics.
	if parent == nil {
		parent = context.Background()
	}
	var revalidationErr error
	core.TryNavigate(activePathSig.Get(), func() {
		revalidationErr = revalidateImpl(parent)
	})
	return revalidationErr
}

func revalidateImpl(parent context.Context) error

{
	// Nothing mounted is nothing to revalidate: a navigation that has not
	// committed yet still has its own guards ahead of it, and a refusal already
	// cleared the owner it tore down.
	if currentComponent == nil {
		return nil
	}
	r, guards, params := matchCurrentRoute(activePathSig.Get())
	if r == nil {
		return nil
	}
	// The match only speaks for the route that actually committed what is
	// mounted. It does not when a route is registered for the path the
	// not-found component is sitting on: those guards never ran to put anything
	// there, so they have no say over a component that is not theirs.
	if r.component != currentComponent {
		return nil
	}
	// Taking the navigation generation cancels whatever is in flight: it was
	// authorized under the snapshot this call replaces, so its loader must not
	// come back and commit over the decision made here.
	ctx, _ := beginNavigation(parent)
	if err := ctx.Err(); err != nil {
		return err
	}

	guardResult, guardErr := runGuards(guards, params)
	if guardErr != nil {
		// Every refusal fails closed the same way, a legacy guard that blocks
		// included: the route is mounted, so leaving it there is the one outcome
		// a refusal cannot have. Navigation to a refused destination keeps its
		// own behavior, where nothing was committed to take back.
		revokeMountedRoute(guardErr)
		return guardErr
	}
	switch guardResult.Action {
	case GuardAllow:
		settleRevalidatedRoute()
		return nil
	case GuardHostReplace:
		// The host owns the destination and the browser loads it as a document.
		// Nothing commits and nothing is torn down first: the page the user is
		// on stays exactly as it is until the browser unloads it.
		hostReplace(guardResult.Path)
		return nil
	}

	redirectCtx, err := nextRedirectContext(parent)
	if err != nil {
		failNavigation(err)
		return err
	}
	// The entry the browser is sitting on is the one the guard just refused, so
	// both redirect actions replace it: pushing would leave the refused path
	// behind for back to return to, where the guard refuses it again. From
	// there it is ordinary routing, which unmounts the current owner once.
	return navigateImpl(redirectCtx, guardResult.Path, historyReplace)
}

func revokeMountedRoute(err error)

{
	owner := currentComponent
	// Dropped before the teardown, not after: the outlet repaints whatever
	// currentComponent points at whenever a component around it paints, and
	// unmounting paints.
	currentComponent = nil
	core.Log().Debug("Unmounting revoked component: %s", owner.GetName())
	core.TriggerUnmount(owner)
	// Unmount first, so the component's own cleanup, its scope and its host
	// registrations still see the tree they own.
	owner.Unmount()
	clearRoutedSubtree(owner.GetID())
	revokeCommittedRoute(err)
}

func clearRoutedSubtree(id string)

{
	if content, ok := routedOutletContent(); ok {
		content.SetHTML("")
		return
	}
	root := dom.ComponentRoot(id)
	if root.IsNull() || root.IsUndefined() || root.Attr("data-component-id") != id {
		return
	}
	root.Call("remove")
}

func routedOutletContent() (dom.Element, bool)

{
	if liveOutlet == nil {
		return dom.Element{Value: js.Null()}, false
	}
	root := dom.ComponentRoot(liveOutlet.GetID())
	if root.IsNull() || root.IsUndefined() || root.Attr("data-component-id") != liveOutlet.GetID() {
		return dom.Element{Value: js.Null()}, false
	}
	if target := root.Query("[data-router-outlet]"); !target.IsNull() && !target.IsUndefined() {
		return target, true
	}
	return root, true
}

func buildRouteAt(r Route, parent string) route

{
	fullPath := resolveRoutePath(parent, r.Path)
	segments := strings.Split(strings.Trim(fullPath, "/"), "/")
	regexParts := make([]string, len(segments))
	matchNames := []string{}

	for i, segment := range segments {
		if strings.HasPrefix(segment, ":") {
			name := strings.TrimPrefix(segment, ":")
			matchNames = append(matchNames, name)
			regexParts[i] = "([^/]+)"
		} else {
			regexParts[i] = regexp.QuoteMeta(segment)
		}
	}

	paramNames := []string{}
	for _, segment := range strings.Split(strings.Trim(r.Path, "/"), "/") {
		if strings.HasPrefix(segment, ":") {
			paramNames = append(paramNames, strings.TrimPrefix(segment, ":"))
		}
	}

	pathRegex := strings.Join(regexParts, "/")
	suffix := "/?$"
	if len(r.Children) > 0 {
		suffix = "(?:/|$)"
	}
	if pathRegex == "" {
		if len(r.Children) > 0 {
			suffix = ""
		} else {
			suffix = "$"
		}
	}
	pattern := "^/" + pathRegex + suffix
	var loader func() core.Component
	var singleton bool
	switch c := r.Component.(type) {
	case *types.View:
		comp := c
		loader = func() core.Component { return comp }
		singleton = true
	case func() *types.View:
		loader = func() core.Component { return c() }
	case func() core.Component:
		loader = c
	case core.Component:
		comp := c
		loader = func() core.Component { return comp }
		singleton = true
	}
	rt := route{
		pattern:    r.Path,
		fullPath:   fullPath,
		name:       r.Name,
		regex:      regexp.MustCompile(pattern),
		paramNames: paramNames,
		matchNames: matchNames,
		loader:     loader,
		singleton:  singleton,
		guards:     routeGuardEntries(r.Guards, r.ResultGuards),
		dataLoader: r.Loader,
		redirect:   r.Redirect,
		meta:       cloneMeta(r.Meta),
	}

	for _, child := range r.Children {
		rt.children = append(rt.children, buildRouteAt(child, fullPath))
	}

	return rt
}

func snapshotRoute(r *route, parent string) RegisteredRoute

{
	params := make([]string, len(r.paramNames))
	copy(params, r.paramNames)
	full := resolveRoutePath(parent, r.pattern)
	children := make([]RegisteredRoute, len(r.children))
	for i := range r.children {
		children[i] = snapshotRoute(&r.children[i], full)
	}
	return RegisteredRoute{
		Template: r.pattern,
		Path:     full,
		Name:     r.name,
		Params:   params,
		Children: children,
		Meta:     cloneMeta(r.meta),
	}
}

func resolveRoutePath(parent, path string) string

{
	if path == "" {
		if parent == "" {
			return "/"
		}
		return parent
	}
	if strings.HasPrefix(path, "/") {
		return path
	}
	trimmed := strings.TrimPrefix(path, "/")
	if parent == "" || parent == "/" {
		return "/" + trimmed
	}
	if strings.HasSuffix(parent, "/") {
		return parent + trimmed
	}
	return parent + "/" + trimmed
}

func matchRoute(routes []route, path string) (*route, []guardEntry, map[string]string)

{
	for i := range routes {
		r := &routes[i]
		matches := r.regex.FindStringSubmatch(path)
		if matches == nil {
			if child, guards, params := matchRoute(r.children, path); child != nil {
				return child, joinGuards(r.guards, guards), params
			}
			continue
		}
		params := map[string]string{}
		for i, name := range r.matchNames {
			if i+1 < len(matches) {
				params[name] = decodeRouteParam(matches[i+1])
			}
		}
		if child, guards, childParams := matchRoute(r.children, path); child != nil {
			return child, joinGuards(r.guards, guards), childParams
		}
		matchedPath := strings.TrimSuffix(matches[0], "/")
		if (r.loader != nil || r.redirect != "") && matchedPath == strings.TrimSuffix(path, "/") {
			return r, r.guards, params
		}
	}
	return nil, nil, nil
}

func navigateImpl(parent context.Context, fullPath string, history historyMode) error

{
	ctx, navigation := beginNavigation(parent)
	if err := ctx.Err(); err != nil {
		return err
	}
	path := fullPath
	query := ""
	if idx := strings.Index(fullPath, "?"); idx != -1 {
		path = fullPath[:idx]
		query = fullPath[idx+1:]
	}

	r, guards, params := matchRoute(routes, path)
	if r == nil {
		if NotFoundCallback != nil {
			NotFoundCallback(fullPath)
		} else if NotFoundComponent != nil {
			if currentComponent != nil {
				saveScroll()
				core.Log().Debug("Unmounting current component: %s", currentComponent.GetName())
				core.TriggerUnmount(currentComponent)
				currentComponent.Unmount()
			}
			var c core.Component
			switch nc := NotFoundComponent.(type) {
			case *types.View:
				c = nc
			case func() *types.View:
				c = nc()
			case func() core.Component:
				c = nc()
			}
			if c != nil {
				currentComponent = c
				if liveOutlet != nil {
					liveOutlet.renderChild(c, rendertrace.Cause{Kind: "router"})
				} else {
					renderComponent(c, rendertrace.Cause{Kind: "router"}, "", 0, func(html string) {
						dom.UpdateDOM(c.GetID(), html)
					})
				}
				core.TryMount(c)
				core.TriggerMount(c)
				core.TriggerRouter(fullPath)
				activePathSig.Set(fullPath)
				updateHistory(history, fullPath)
				restoreScroll(fullPath, history, nil)
				commitRouteState(nil, nil)
				return nil
			}
		}
		failNavigation(ErrRouteNotFound)
		return ErrRouteNotFound
	}

	if params == nil {
		params = map[string]string{}
	}
	queryParams, queryValues := routeQuery(query)
	for key, value := range queryParams {
		params[key] = value
	}
	// Guards decide before anything commits: no loader, no component, no
	// unmount, no history entry runs for a destination they refuse.
	guardResult, guardErr := runGuards(guards, params)
	if guardErr != nil {
		if guardErr == ErrNavigationBlocked {
			if currentComponent == nil && path != "/" {
				navigate("/", history)
			}
			return guardErr
		}
		failNavigation(guardErr)
		return guardErr
	}
	if guardResult.Action == GuardHostReplace {
		// The host owns the destination, so the browser loads it as a document
		// instead of the router matching a route for it. Nothing commits: the
		// page the user is on stays exactly as it is until the browser unloads
		// it, and navigation never reenters here.
		hostReplace(guardResult.Path)
		return nil
	}
	if guardResult.Action != GuardAllow {
		redirectCtx, err := nextRedirectContext(parent)
		if err != nil {
			failNavigation(err)
			return err
		}
		// A historyNone navigation (initial load or popstate) is already sitting
		// on the denied entry, so the redirect replaces it whatever the action
		// is: pushing would leave the refused path behind for back to return to,
		// where the guard denies it again and bounces forward.
		mode := historyPush
		if guardResult.Action == GuardReplace || history == historyNone {
			mode = historyReplace
		}
		return navigateImpl(redirectCtx, guardResult.Path, mode)
	}

	if r.redirect != "" {
		destination, err := redirectPath(r.redirect, params)
		if err != nil {
			failNavigation(err)
			return err
		}
		redirectCtx, err := nextRedirectContext(parent)
		if err != nil {
			failNavigation(err)
			return err
		}
		return navigateImpl(redirectCtx, destination, historyReplace)
	}

	var data any
	if r.dataLoader != nil {
		state.Batch(func() {
			navigationError.Set(nil)
			navigationStatus.Set(NavigationLoading)
		})
		loaded, err := r.dataLoader(ctx, LoadContext{
			Path:   path,
			Params: cloneStringMap(params),
			Query:  queryValues,
		})
		if err != nil {
			if navigationIsCurrent(navigation) {
				failNavigation(err)
			}
			return err
		}
		if err := ctx.Err(); err != nil {
			return err
		}
		if !navigationIsCurrent(navigation) {
			return context.Canceled
		}
		data = loaded
	}

	if r.loader != nil && (!r.singleton || r.component == nil) {
		r.component = r.loader()
	}
	if r.component == nil {
		failNavigation(ErrRouteComponent)
		return ErrRouteComponent
	}
	if receiver, ok := r.component.(routeParamReceiver); ok {
		receiver.SetRouteParams(params)
	}
	if receiver, ok := r.component.(RouteDataReceiver); ok {
		receiver.SetRouteData(data)
	}
	// In-place update: when the destination resolves to the component instance
	// already mounted (e.g. the same singleton registered for a base path and
	// its ":id" variant), unmounting and remounting rebuilds an unchanged view.
	// Keep it mounted and just re-run params so it can react (toggle an overlay,
	// load a detail), which also lets browser back/forward between the two paths
	// update in place instead of tearing the view down.
	if currentComponent != nil && r.component == currentComponent {
		r.component.OnParams(params)
		core.TriggerRouter(fullPath)
		activePathSig.Set(fullPath)
		updateHistory(history, fullPath)
		commitRouteState(data, r.meta)
		return nil
	}
	saveScroll()
	if currentComponent != nil {
		core.Log().Debug("Unmounting current component: %s", currentComponent.GetName())
		core.TriggerUnmount(currentComponent)
		currentComponent.Unmount()
	}
	currentComponent = r.component
	if liveOutlet != nil {
		liveOutlet.renderChild(r.component, rendertrace.Cause{Kind: "router"})
	} else {
		renderComponent(r.component, rendertrace.Cause{Kind: "router"}, "", 0, func(html string) {
			dom.UpdateDOM(r.component.GetID(), html)
		})
	}
	r.component.Mount()
	core.TriggerMount(r.component)
	r.component.OnParams(params)
	core.TriggerRouter(fullPath)
	activePathSig.Set(fullPath)
	updateHistory(history, fullPath)
	restoreScroll(fullPath, history, r.meta)
	commitRouteState(data, r.meta)
	return nil
}

func restoreScroll(path string, history historyMode, meta map[string]any)

{
	if !scrollEnabled {
		return
	}
	if preserve, _ := meta["preserveScroll"].(bool); preserve {
		return
	}
	position := [2]int{}
	if history == historyNone {
		position = scrollPositions[path]
	}
	js.Window().Call("scrollTo", position[0], position[1])
}

func ExposeNavigate()

{
	exposeNavigateOnce.Do(func() {
		js.ExposeFunc("goNavigate", func(_ js.Value, args []js.Value) any {
			path := args[0].String()
			Navigate(path)
			return nil
		})

		events.On("click", js.Document(), func(evt js.Value) {
			link := evt.Get("target").Call("closest", "a[href]")
			if !link.Truthy() {
				return
			}
			if t := link.Get("target").String(); t != "" && t != "_self" {
				return
			}
			if link.Get("origin").String() != js.Location().Get("origin").String() {
				return
			}
			path := link.Get("pathname").String() + link.Get("search").String()
			if CanNavigate(path) {
				evt.Call("preventDefault")
				Navigate(path)
			}
		})
	})
}

func InitRouter()

{
	ExposeNavigate()

	// The popstate listener lives for the whole app lifetime; the stop
	// function is intentionally discarded.
	ch, _ := events.Listen("popstate", js.Window())
	go func() {
		for range ch {
			path := js.Location().Get("pathname").String() + js.Location().Get("search").String()
			core.TryNavigate(path, func() { navigate(path, historyNone) })
		}
	}()

	currentPath := js.Location().Get("pathname").String() + js.Location().Get("search").String()
	navigate(currentPath, historyNone)
}

func NavItemsMap() []any

{
	items := make([]any, len(navItems))
	for i, ni := range navItems {
		items[i] = map[string]any{
			"Path":  ni.Path,
			"Label": ni.Label,
			"Meta":  ni.Meta,
		}
	}
	return items
}

func TestNamedRouteURLAndMetadata(t *testing.T)

{
	resetRouter(t)
	RegisterRoute(Route{
		Path: "/teams/:team",
		Children: []Route{{
			Path:      "users/:user",
			Name:      "team-user",
			Component: func() core.Component { return &recordComponent{name: "user"} },
			Meta:      map[string]any{"title": "User"},
		}},
	})

	path, err := URL("team-user", map[string]string{
		"team": "core",
		"user": "Ada Lovelace",
	}, url.Values{"tab": {"activity"}})
	if err != nil {
		t.Fatalf("build URL: %v", err)
	}
	if path != "/teams/core/users/Ada%20Lovelace?tab=activity" {
		t.Fatalf("unexpected URL: %s", path)
	}
	if err := NavigateContext(context.Background(), "/teams/core/users/Ada%20Lovelace"); err != nil {
		t.Fatalf("navigate generated URL: %v", err)
	}
	component := CurrentComponent().(*recordComponent)
	if component.params["user"] != "Ada Lovelace" {
		t.Fatalf("route parameter was not decoded: %#v", component.params)
	}

	definitions := RegisteredRoutes()
	child := definitions[0].Children[0]
	if child.Name != "team-user" || child.Meta["title"] != "User" {
		t.Fatalf("named route metadata missing: %#v", child)
	}
}

func TestRouteLoaderCommitsDataAndMeta(t *testing.T)

{
	resetRouter(t)
	var loadedContext LoadContext
	RegisterRoute(Route{
		Path: "/reports/:id",
		Name: "report",
		Component: func() core.Component {
			return &dataComponent{recordComponent: recordComponent{name: "report"}}
		},
		Loader: func(_ context.Context, loadContext LoadContext) (any, error) {
			loadedContext = loadContext
			return map[string]any{"total": 4}, nil
		},
		Meta: map[string]any{"section": "reports"},
	})

	if err := NavigateContext(context.Background(), "/reports/7?period=week"); err != nil {
		t.Fatalf("navigate: %v", err)
	}
	component := CurrentComponent().(*dataComponent)
	if !reflect.DeepEqual(component.data, map[string]any{"total": 4}) {
		t.Fatalf("loader data missing: %#v", component.data)
	}
	if loadedContext.Params["id"] != "7" || loadedContext.Query.Get("period") != "week" {
		t.Fatalf("loader context incorrect: %#v", loadedContext)
	}
	if Status().Get() != NavigationReady || Error().Get() != nil {
		t.Fatalf("unexpected navigation state: status=%s error=%v", Status().Get(), Error().Get())
	}
	if Meta().Get()["section"] != "reports" {
		t.Fatalf("route metadata missing: %#v", Meta().Get())
	}
}

func TestNewNavigationCancelsPreviousLoader(t *testing.T)

{
	resetRouter(t)
	started := make(chan struct{})
	RegisterRoute(Route{
		Path:      "/slow",
		Component: func() core.Component { return &recordComponent{name: "slow"} },
		Loader: func(ctx context.Context, _ LoadContext) (any, error) {
			close(started)
			<-ctx.Done()
			return nil, ctx.Err()
		},
	})
	RegisterRoute(Route{
		Path:      "/fast",
		Component: func() core.Component { return &recordComponent{name: "fast"} },
	})

	result := make(chan error, 1)
	go func() {
		result <- NavigateContext(context.Background(), "/slow")
	}()
	<-started
	if err := NavigateContext(context.Background(), "/fast"); err != nil {
		t.Fatalf("fast navigation: %v", err)
	}
	if err := <-result; !errors.Is(err, context.Canceled) {
		t.Fatalf("slow loader was not cancelled: %v", err)
	}
	if CurrentComponent().GetName() != "fast" || Status().Get() != NavigationReady {
		t.Fatalf("stale loader replaced current route: component=%v status=%s", CurrentComponent(), Status().Get())
	}
}

func TestRouteRedirectInterpolatesParameters(t *testing.T)

{
	resetRouter(t)
	RegisterRoute(Route{Path: "/legacy/:id", Redirect: "/users/:id"})
	RegisterRoute(Route{
		Path:      "/users/:id",
		Component: func() core.Component { return &dataComponent{recordComponent: recordComponent{name: "user"}} },
		Loader: func(ctx context.Context, load LoadContext) (any, error) {
			if err := ctx.Err(); err != nil {
				return nil, err
			}
			return load.Params["id"], nil
		},
	})

	if err := NavigateContext(context.Background(), "/legacy/42"); err != nil {
		t.Fatalf("redirect: %v", err)
	}
	component := CurrentComponent().(*dataComponent)
	if component.params["id"] != "42" || ActivePath().Get() != "/users/42" {
		t.Fatalf("redirect destination incorrect: component=%#v path=%s", component, ActivePath().Get())
	}
	if component.data != "42" {
		t.Fatalf("redirected loader did not complete: %#v", component.data)
	}
}

func TestCancelledNavigationDoesNotCommit(t *testing.T)

{
	resetRouter(t)
	RegisterRoute(Route{
		Path:      "/cancelled",
		Component: func() core.Component { return &recordComponent{name: "cancelled"} },
	})
	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	if err := NavigateContext(ctx, "/cancelled"); !errors.Is(err, context.Canceled) {
		t.Fatalf("expected cancelled context, got %v", err)
	}
	if CurrentComponent() != nil {
		t.Fatalf("cancelled navigation committed %#v", CurrentComponent())
	}
}

func mountHostShell(t *testing.T, path string) *hostGuardPage

{
	t.Helper()
	if dom.ByID("app").IsNull() {
		host := dom.CreateElement("div")
		host.SetAttr("id", "app")
		dom.Doc().Body().AppendChild(host)
	}
	shell := core.NewHTMLComponent("HostShell", []byte(`<root>@include:outlet</root>`), nil)
	shell.SetComponent(shell)
	shell.AddDependency("outlet", NewOutlet())
	shell.Init(nil)

	page := newHostGuardPage("HostDashboard", "dashboard")
	Page(path, page)
	MountRoot(shell)
	Navigate(path)

	dom.Query("[data-host-page='dashboard']").SetHTML(`<b id="host-built">built</b>`)
	if !strings.Contains(dom.ByID("app").HTML(), "host-built") {
		t.Fatal("the mounted page was not rendered")
	}
	return page
}

func TestHostReplaceHandsOffWithoutCommitting(t *testing.T)

{
	Reset()
	restoreHistoryPath(t)
	calls := captureHostReplace(t)

	dashboard := mountHostShell(t, "/host-dashboard")
	created := 0
	RegisterRoute(Route{
		Path:         "/host-admin",
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return HostReplace("/login") }},
		Component: func() core.Component {
			created++
			return newHostGuardPage("HostAdmin", "admin")
		},
		Loader: func(context.Context, LoadContext) (any, error) {
			t.Error("the protected route ran its loader before the host handoff")
			return nil, nil
		},
		Meta: map[string]any{"section": "admin"},
	})
	NotFoundCallback = func(string) { t.Error("the host handoff went through the not-found callback") }
	NotFoundComponent = func() core.Component {
		t.Error("the host handoff rendered the not-found component")
		return newHostGuardPage("HostNotFound", "not-found")
	}

	historyLength := js.History().Get("length").Int()
	location := js.Location().Get("pathname").String()

	if err := NavigateContext(context.Background(), "/host-admin"); err != nil {
		t.Fatalf("host handoff: %v", err)
	}

	if len(*calls) != 1 || (*calls)[0] != "/login" {
		t.Fatalf("host replace calls = %#v, want one call with /login", *calls)
	}
	if created != 0 {
		t.Fatalf("the protected component was created %d times", created)
	}
	if got := js.History().Get("length").Int(); got != historyLength {
		t.Fatalf("history length changed from %d to %d", historyLength, got)
	}
	if got := js.Location().Get("pathname").String(); got != location {
		t.Fatalf("the SPA moved the location to %q, want %q", got, location)
	}
	if got := ActivePath().Get(); got != "/host-dashboard" {
		t.Fatalf("active path = %q, want /host-dashboard", got)
	}
	if mounted, ok := CurrentComponent().(*hostGuardPage); !ok || mounted != dashboard {
		t.Fatalf("current component changed to %#v", CurrentComponent())
	}
	if dashboard.unmounted != 0 {
		t.Fatalf("the mounted page was unmounted %d times before the handoff", dashboard.unmounted)
	}
	html := dom.ByID("app").HTML()
	if !strings.Contains(html, "host-built") {
		t.Fatalf("the handoff tore down the mounted page: %s", html)
	}
	if strings.Contains(html, `data-host-page="admin"`) {
		t.Fatalf("the protected page reached the DOM: %s", html)
	}
	if Status().Get() != NavigationReady {
		t.Fatalf("navigation status = %s, want the mounted route's ready", Status().Get())
	}
	if Error().Get() != nil {
		t.Fatalf("navigation error = %v, want none", Error().Get())
	}
	if section, ok := Meta().Get()["section"]; ok {
		t.Fatalf("the protected route committed its metadata: %v", section)
	}
}

func TestParentHostReplaceStopsChildGuards(t *testing.T)

{
	Reset()
	restoreHistoryPath(t)
	calls := captureHostReplace(t)

	childRan, created := false, 0
	RegisterRoute(Route{
		Path:         "/host-parent",
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return HostReplace("/login") }},
		Children: []Route{{
			Path: "users",
			ResultGuards: []ResultGuard{func(map[string]string) GuardResult {
				childRan = true
				return Allow()
			}},
			Component: func() core.Component {
				created++
				return routeComponent{}
			},
			Loader: func(context.Context, LoadContext) (any, error) {
				t.Error("a child loader ran after the parent handed off")
				return nil, nil
			},
		}},
	})

	if err := NavigateContext(context.Background(), "/host-parent/users"); err != nil {
		t.Fatalf("host handoff: %v", err)
	}

	if len(*calls) != 1 || (*calls)[0] != "/login" {
		t.Fatalf("host replace calls = %#v, want one call with /login", *calls)
	}
	if childRan {
		t.Fatal("a child guard ran after the parent handed off")
	}
	if created != 0 {
		t.Fatalf("the child component was created %d times", created)
	}
}

func TestSessionGuardHandsOffUnauthenticated(t *testing.T)

{
	Reset()
	t.Cleanup(Reset)
	calls := captureHostReplace(t)

	authenticated, permitted := false, true
	created := sessionGuardedRoute(t, &authenticated, &permitted)

	if err := NavigateContext(context.Background(), "/composed"); err != nil {
		t.Fatalf("host handoff: %v", err)
	}

	if len(*calls) != 1 || (*calls)[0] != "/login" {
		t.Fatalf("host replace calls = %#v, want one call with /login", *calls)
	}
	if *created != 0 || CurrentComponent() != nil {
		t.Fatalf("the handoff committed a route: created=%d component=%#v", *created, CurrentComponent())
	}
}

func TestHostReplaceHandsOffAcceptedTargets(t *testing.T)

{
	for _, target := range hostReplaceAccepts {
		t.Run(target, func(t *testing.T) {
			Reset()
			t.Cleanup(Reset)
			calls := captureHostReplace(t)
			destination := target
			created := guardedRoute(t, "/host-accepted", []ResultGuard{func(map[string]string) GuardResult {
				return HostReplace(destination)
			}})

			if err := NavigateContext(context.Background(), "/host-accepted"); err != nil {
				t.Fatalf("host handoff: %v", err)
			}

			if len(*calls) != 1 || (*calls)[0] != target {
				t.Fatalf("host replace calls = %#v, want one call with %q", *calls, target)
			}
			if *created != 0 {
				t.Fatalf("the protected component was created %d times", *created)
			}
		})
	}
}

func TestHostReplaceRejectedTargetsNeverHandOff(t *testing.T)

{
	for _, tc := range hostReplaceRejects {
		t.Run(tc.name, func(t *testing.T) {
			Reset()
			restoreHistoryPath(t)
			calls := captureHostReplace(t)
			destination := tc.target
			created := guardedRoute(t, "/host-rejected", []ResultGuard{func(map[string]string) GuardResult {
				return HostReplace(destination)
			}})
			location := js.Location().Get("pathname").String()

			err := NavigateContext(context.Background(), "/host-rejected")

			if !errors.Is(err, ErrInvalidGuardResult) {
				t.Fatalf("expected an invalid guard result, got %v", err)
			}
			if len(*calls) != 0 {
				t.Fatalf("a rejected target reached the browser: %#v", *calls)
			}
			if *created != 0 || CurrentComponent() != nil {
				t.Fatalf("a rejected target committed a route: created=%d component=%#v", *created, CurrentComponent())
			}
			if got := js.Location().Get("pathname").String(); got != location {
				t.Fatalf("location moved to %q, want %q", got, location)
			}
		})
	}
}

func TestGuardRedirectsStayInsideTheSPA(t *testing.T)

{
	Reset()
	restoreHistoryPath(t)
	calls := captureHostReplace(t)

	RegisterRoute(Route{Path: "/spa-origin", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{Path: "/spa-offers", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{Path: "/spa-login", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{
		Path:         "/spa-promo",
		Component:    func() core.Component { return routeComponent{} },
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return RedirectTo("/spa-offers") }},
	})
	RegisterRoute(Route{
		Path:         "/spa-account",
		Component:    func() core.Component { return routeComponent{} },
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return ReplaceWith("/spa-login") }},
	})

	Navigate("/spa-origin")
	before := js.History().Get("length").Int()

	Navigate("/spa-promo")

	if got := js.Location().Get("pathname").String(); got != "/spa-offers" {
		t.Fatalf("path after the guard redirect = %q", got)
	}
	if got := js.History().Get("length").Int(); got != before+1 {
		t.Fatalf("history length = %d, want %d", got, before+1)
	}

	before = js.History().Get("length").Int()

	Navigate("/spa-account")

	if got := js.Location().Get("pathname").String(); got != "/spa-login" {
		t.Fatalf("path after the guard replace = %q", got)
	}
	if got := js.History().Get("length").Int(); got != before {
		t.Fatalf("history length changed from %d to %d", before, got)
	}
	if len(*calls) != 0 {
		t.Fatalf("an SPA redirect reached the host handoff: %#v", *calls)
	}
}

func TestNavigateQueryParams(t *testing.T)

{
	Reset()
	RegisterRoute(Route{Path: "/query", Component: func() core.Component { return &testComponent{} }})
	Navigate("/query?key=value")
	tc, ok := currentComponent.(*testComponent)
	if !ok {
		t.Fatalf("expected testComponent, got %T", currentComponent)
	}
	if tc.params["key"] != "value" {
		t.Fatalf("expected query param 'key=value', got %v", tc.params)
	}
}

func routeGuardEntries(legacy []Guard, results []ResultGuard) []guardEntry

{
	if len(legacy) == 0 && len(results) == 0 {
		return nil
	}
	entries := make([]guardEntry, 0, len(legacy)+len(results))
	for _, guard := range legacy {
		entries = append(entries, guardEntry{legacy: guard})
	}
	for _, guard := range results {
		entries = append(entries, guardEntry{result: guard})
	}
	return entries
}

func joinGuards(parent, child []guardEntry) []guardEntry

{
	if len(parent) == 0 {
		return child
	}
	if len(child) == 0 {
		return parent
	}
	joined := make([]guardEntry, 0, len(parent)+len(child))
	joined = append(joined, parent...)
	return append(joined, child...)
}

func runGuards(entries []guardEntry, params map[string]string) (GuardResult, error)

{
	for _, entry := range entries {
		if entry.legacy != nil {
			if entry.legacy(params) {
				continue
			}
			return GuardResult{}, ErrNavigationBlocked
		}
		if entry.result == nil {
			continue
		}
		result := entry.result(params)
		switch result.Action {
		case GuardAllow:
			continue
		case GuardForbid:
			return GuardResult{}, ErrNavigationForbidden
		case GuardRedirect, GuardReplace:
			destination, err := guardRedirectTarget(result.Path)
			if err != nil {
				return GuardResult{}, err
			}
			result.Path = destination
			return result, nil
		case GuardHostReplace:
			destination, err := guardHostReplaceTarget(result.Path)
			if err != nil {
				return GuardResult{}, err
			}
			result.Path = destination
			return result, nil
		default:
			return GuardResult{}, ErrInvalidGuardResult
		}
	}
	return GuardResult{}, nil
}

func guardRedirectTarget(path string) (string, error)

{
	destination := strings.TrimSpace(path)
	if destination == "" || !strings.HasPrefix(destination, "/") {
		return "", ErrInvalidGuardResult
	}
	// "//host" and "/\host" leave the application: browsers read them as
	// protocol-relative URLs, which is an open redirect, not a route.
	if strings.HasPrefix(destination, "//") || strings.HasPrefix(destination, `/\`) {
		return "", ErrInvalidGuardResult
	}
	return destination, nil
}

func guardHostReplaceTarget(path string) (string, error)

{
	if path == "" || !strings.HasPrefix(path, "/") {
		return "", ErrInvalidGuardResult
	}
	// Browsers remove tabs and newlines from anywhere in a URL, so "/<tab>/host"
	// reaches the network as "//host", and they strip C0 characters and spaces
	// from both ends before parsing. Refuse them rather than validate a string
	// the browser will rewrite: a leading one already fails the rooted check
	// above, and a trailing space is the only stripped byte left to catch.
	if strings.ContainsFunc(path, isURLControl) {
		return "", ErrInvalidGuardResult
	}
	if strings.HasSuffix(path, " ") {
		return "", ErrInvalidGuardResult
	}
	// A backslash is read as a slash, which turns "/\host" into a
	// protocol-relative URL pointing somewhere else entirely.
	if strings.ContainsRune(path, '\\') {
		return "", ErrInvalidGuardResult
	}
	if strings.HasPrefix(path, "//") {
		return "", ErrInvalidGuardResult
	}
	parsed, err := url.Parse(path)
	if err != nil {
		return "", ErrInvalidGuardResult
	}
	if parsed.Scheme != "" || parsed.Opaque != "" || parsed.Host != "" || parsed.User != nil {
		return "", ErrInvalidGuardResult
	}
	if !strings.HasPrefix(parsed.Path, "/") {
		return "", ErrInvalidGuardResult
	}
	// Parse keeps the query raw, so a malformed escape there survives it.
	if _, err := url.ParseQuery(parsed.RawQuery); err != nil {
		return "", ErrInvalidGuardResult
	}
	return path, nil
}

func beginNavigation(parent context.Context) (context.Context, uint64)

{
	if parent == nil {
		parent = context.Background()
	}
	navigationMu.Lock()
	if navigationCancel != nil {
		navigationCancel()
	}
	ctx, cancel := context.WithCancel(parent)
	navigationCancel = cancel
	navigationID++
	id := navigationID
	navigationMu.Unlock()
	return ctx, id
}

func resetNavigation()

{
	navigationMu.Lock()
	if navigationCancel != nil {
		navigationCancel()
	}
	navigationCancel = nil
	navigationID++
	navigationMu.Unlock()
	state.Batch(func() {
		navigationStatus.Set(NavigationIdle)
		navigationError.Set(nil)
		currentRouteData.Set(nil)
		currentRouteMeta.Set(map[string]any{})
	})
}

func URL(name string, params map[string]string, query url.Values) (string, error)

{
	template, ok := namedRoutePath(routes, name)
	if !ok {
		return "", errors.New("router: named route not found")
	}
	segments := strings.Split(template, "/")
	for index, segment := range segments {
		if !strings.HasPrefix(segment, ":") {
			continue
		}
		key := strings.TrimPrefix(segment, ":")
		value, exists := params[key]
		if !exists || value == "" {
			return "", errors.New("router: missing route parameter " + key)
		}
		segments[index] = url.PathEscape(value)
	}
	path := strings.Join(segments, "/")
	if encoded := query.Encode(); encoded != "" {
		path += "?" + encoded
	}
	return path, nil
}

func namedRoutePath(list []route, name string) (string, bool)

{
	for index := range list {
		if list[index].name == name {
			return list[index].fullPath, true
		}
		if path, ok := namedRoutePath(list[index].children, name); ok {
			return path, true
		}
	}
	return "", false
}

func routeQuery(raw string) (map[string]string, url.Values)

{
	values, _ := url.ParseQuery(raw)
	params := make(map[string]string, len(values))
	keys := make([]string, 0, len(values))
	for key := range values {
		keys = append(keys, key)
	}
	sort.Strings(keys)
	for _, key := range keys {
		if entries := values[key]; len(entries) > 0 {
			params[key] = entries[0]
		}
	}
	return params, values
}

func matchCurrentRoute(fullPath string) (*route, []guardEntry, map[string]string)

{
	path := fullPath
	query := ""
	if idx := strings.Index(fullPath, "?"); idx != -1 {
		path = fullPath[:idx]
		query = fullPath[idx+1:]
	}
	r, guards, params := matchRoute(routes, path)
	if r == nil {
		return nil, nil, nil
	}
	if params == nil {
		params = map[string]string{}
	}
	queryParams, _ := routeQuery(query)
	for key, value := range queryParams {
		params[key] = value
	}
	return r, guards, params
}

func redirectPath(template string, params map[string]string) (string, error)

{
	segments := strings.Split(template, "/")
	for index, segment := range segments {
		if !strings.HasPrefix(segment, ":") {
			continue
		}
		key := strings.TrimPrefix(segment, ":")
		value, ok := params[key]
		if !ok || value == "" {
			return "", errors.New("router: missing redirect parameter " + key)
		}
		segments[index] = url.PathEscape(value)
	}
	return strings.Join(segments, "/"), nil
}

func installOutletRepaint()

{
	if outletRepaintInstalled {
		return
	}
	outletRepaintInstalled = true
	core.OnTemplate(func(componentID, _ string) {
		if liveOutlet == nil || currentComponent == nil {
			return
		}
		if componentID == currentComponent.GetID() {
			return
		}
		liveOutlet.repaint()
	})
}

func renderComponent(c core.Component, cause rendertrace.Cause, parentID string, depth int, commit func(string))

{
	if !rendertrace.Enabled() {
		commit(core.TryRender(c))
		return
	}
	cause = rendertrace.NormalizeCause(cause)
	batchID := rendertrace.NextBatchID()
	renderID := rendertrace.NextRenderID()
	started := rendertrace.NowMS()
	base := rendertrace.Record{
		BatchID:           batchID,
		RenderID:          renderID,
		ComponentID:       c.GetID(),
		ComponentName:     c.GetName(),
		ParentComponentID: parentID,
		Depth:             depth,
		Cause:             cause,
		Causes:            []rendertrace.Cause{cause},
	}
	startedRecord := base
	startedRecord.Event = "started"
	rendertrace.Emit(startedRecord)

	var templateMS, domMS float64
	phase, phaseStarted := "template", rendertrace.NowMS()
	defer func() {
		if recovered := recover(); recovered != nil {
			now := rendertrace.NowMS()
			switch phase {
			case "template":
				templateMS = now - phaseStarted
			case "dom":
				domMS = now - phaseStarted
			}
			failed := base
			failed.Event = "failed"
			failed.TemplateMS = templateMS
			failed.DOMMS = domMS
			failed.TotalMS = rendertrace.NowMS() - started
			failed.Outcome = "failed"
			failed.Reason = "panic"
			rendertrace.Emit(failed)
			panic(recovered)
		}
	}()

	html := core.TryRender(c)
	templateMS = rendertrace.NowMS() - phaseStarted
	phase, phaseStarted = "dom", rendertrace.NowMS()
	commit(html)
	domMS = rendertrace.NowMS() - phaseStarted
	phase = ""

	completed := base
	completed.Event = "committed"
	completed.TemplateMS = templateMS
	completed.DOMMS = domMS
	completed.TotalMS = rendertrace.NowMS() - started
	completed.Outcome = "committed"
	rendertrace.Emit(completed)
}

func componentDOMDepth(componentID string) int

{
	root := dom.ComponentRoot(componentID)
	if root.IsNull() || root.IsUndefined() || root.Attr("data-component-id") != componentID {
		return 0
	}
	depth := 0
	for parent := root.Get("parentElement"); parent.Truthy(); parent = parent.Get("parentElement") {
		if parent.Call("hasAttribute", "data-component-id").Bool() {
			depth++
		}
	}
	return depth
}

func TestOutletTraceCoversRootMountAndRouteCommit(t *testing.T)

{
	restoreTrace := rendertrace.SetEnabledForTest(true)
	defer restoreTrace()
	var records []routerTraceSnapshot
	callback := js.FuncOf(func(_ js.Value, args []js.Value) any {
		detail := args[0].Get("detail")
		cause := detail.Get("cause")
		record := routerTraceSnapshot{
			event:       detail.Get("event").String(),
			componentID: detail.Get("componentId").String(),
			hasTimings:  detail.Call("hasOwnProperty", "templateMs").Bool() && detail.Call("hasOwnProperty", "domMs").Bool(),
			hasQueue:    detail.Call("hasOwnProperty", "queueDepth").Bool(),
		}
		if value := detail.Get("parentComponentId"); value.Type() == js.TypeString {
			record.parentID = value.String()
		}
		if cause.Type() == js.TypeObject {
			record.cause = cause.Get("kind").String()
		}
		if value := detail.Get("templateMs"); value.Type() == js.TypeNumber {
			record.templateMS = value.Float()
		}
		if value := detail.Get("domMs"); value.Type() == js.TypeNumber {
			record.domMS = value.Float()
		}
		records = append(records, record)
		return nil
	})
	js.Global().Call("addEventListener", "rfw:render-trace", callback)
	defer func() {
		js.Global().Call("removeEventListener", "rfw:render-trace", callback)
		callback.Release()
	}()

	Reset()
	if dom.ByID("app").IsNull() {
		host := dom.CreateElement("div")
		host.SetAttr("id", "app")
		dom.Doc().Body().AppendChild(host)
	}
	outlet := NewOutlet()
	shell := core.NewHTMLComponent("TraceShell", []byte(`<root><aside>shell</aside>@include:outlet</root>`), nil)
	shell.SetComponent(shell)
	shell.AddDependency("outlet", outlet)
	shell.Init(nil)
	page := core.NewHTMLComponent("TracePage", []byte(`<root><main>page</main></root>`), nil)
	page.SetComponent(page)
	page.Init(nil)
	defer page.Unmount()
	defer shell.Unmount()

	Page("/trace-route", page)
	MountRoot(shell)
	Navigate("/trace-route")

	var shellCommit, pageCommit *routerTraceSnapshot
	for index := range records {
		record := &records[index]
		if record.event != "committed" {
			continue
		}
		switch record.componentID {
		case shell.ID:
			shellCommit = record
		case page.ID:
			pageCommit = record
		}
	}
	if shellCommit == nil || shellCommit.cause != "mount" || !shellCommit.hasTimings || shellCommit.hasQueue {
		t.Fatalf("root mount trace = %#v (all=%#v)", shellCommit, records)
	}
	if pageCommit == nil || pageCommit.cause != "router" || pageCommit.parentID != outlet.GetID() || !pageCommit.hasTimings || pageCommit.hasQueue {
		t.Fatalf("route commit trace = %#v (all=%#v)", pageCommit, records)
	}
}

func TestDirectRenderFailureReportsElapsedDOMTime(t *testing.T)

{
	restoreTrace := rendertrace.SetEnabledForTest(true)
	defer restoreTrace()
	var failed routerTraceSnapshot
	callback := js.FuncOf(func(_ js.Value, args []js.Value) any {
		detail := args[0].Get("detail")
		if detail.Get("event").String() != "failed" || detail.Get("componentId").String() != "direct-failure" {
			return nil
		}
		failed = routerTraceSnapshot{
			event:       "failed",
			componentID: "direct-failure",
			hasTimings:  detail.Call("hasOwnProperty", "templateMs").Bool() && detail.Call("hasOwnProperty", "domMs").Bool(),
			hasQueue:    detail.Call("hasOwnProperty", "queueDepth").Bool(),
			templateMS:  detail.Get("templateMs").Float(),
			domMS:       detail.Get("domMs").Float(),
		}
		return nil
	})
	js.Global().Call("addEventListener", "rfw:render-trace", callback)
	defer func() {
		js.Global().Call("removeEventListener", "rfw:render-trace", callback)
		callback.Release()
	}()

	component := core.NewHTMLComponent("DirectFailure", []byte(`<root><main>failure</main></root>`), nil)
	component.ID = "direct-failure"
	component.Init(nil)
	func() {
		defer func() {
			if recover() == nil {
				t.Fatal("direct commit panic was not propagated")
			}
		}()
		renderComponent(component, rendertrace.Cause{Kind: "router"}, "", 0, func(string) {
			time.Sleep(3 * time.Millisecond)
			panic("direct commit failure")
		})
	}()

	if failed.event != "failed" || !failed.hasTimings || failed.hasQueue || failed.domMS < 2 {
		t.Fatalf("direct failure trace = %#v", failed)
	}
}

func TestCanNavigate(t *testing.T)

{
	Reset()
	RegisterRoute(Route{Path: "/can", Component: func() core.Component { return &canNavigateComponent{} }})
	if !CanNavigate("/can") {
		t.Fatalf("expected true for registered route")
	}
	if !CanNavigate("/can?foo=bar") {
		t.Fatalf("expected true for registered route with query")
	}
	if CanNavigate("/missing") {
		t.Fatalf("expected false for unregistered route")
	}
}

func guardedRoute(t *testing.T, path string, guards []ResultGuard, legacy ...Guard) *int

{
	t.Helper()
	created := 0
	RegisterRoute(Route{
		Path:         path,
		Guards:       legacy,
		ResultGuards: guards,
		Component: func() core.Component {
			created++
			return &recordComponent{name: "protected"}
		},
		Loader: func(context.Context, LoadContext) (any, error) {
			t.Error("route loader ran for a guarded destination")
			return nil, nil
		},
	})
	return &created
}

func TestResultGuardForbidsWithoutCommitting(t *testing.T)

{
	resetRouter(t)
	created := guardedRoute(t, "/vault", []ResultGuard{func(map[string]string) GuardResult {
		return Forbid()
	}})

	err := NavigateContext(context.Background(), "/vault")

	if !errors.Is(err, ErrNavigationForbidden) {
		t.Fatalf("expected a forbidden navigation, got %v", err)
	}
	if *created != 0 {
		t.Fatalf("protected component was created %d times", *created)
	}
	if CurrentComponent() != nil {
		t.Fatalf("forbidden navigation committed %#v", CurrentComponent())
	}
	if Status().Get() != NavigationError || !errors.Is(Error().Get(), ErrNavigationForbidden) {
		t.Fatalf("navigation state: status=%s error=%v", Status().Get(), Error().Get())
	}
}

func TestResultGuardsComposeParentBeforeChild(t *testing.T)

{
	resetRouter(t)
	var order []string
	record := func(name string) { order = append(order, name) }
	RegisterRoute(Route{
		Path:   "/app",
		Guards: []Guard{func(map[string]string) bool { record("parent-legacy"); return true }},
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult {
			record("parent-result")
			return Allow()
		}},
		Children: []Route{{
			Path:      "settings",
			Guards:    []Guard{func(map[string]string) bool { record("child-legacy"); return true }},
			Component: func() core.Component { return &recordComponent{name: "settings"} },
			ResultGuards: []ResultGuard{
				func(map[string]string) GuardResult { record("child-result"); return Forbid() },
				func(map[string]string) GuardResult { record("unreachable"); return Allow() },
			},
		}},
	})

	if err := NavigateContext(context.Background(), "/app/settings"); !errors.Is(err, ErrNavigationForbidden) {
		t.Fatalf("expected a forbidden navigation, got %v", err)
	}

	want := []string{"parent-legacy", "parent-result", "child-legacy", "child-result"}
	if !reflect.DeepEqual(order, want) {
		t.Fatalf("guard order = %v, want %v", order, want)
	}
}

func TestParentResultGuardStopsChildGuards(t *testing.T)

{
	resetRouter(t)
	childRan := false
	RegisterRoute(Route{
		Path: "/admin",
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult {
			return ReplaceWith("/login")
		}},
		Children: []Route{{
			Path:      "users",
			Component: func() core.Component { return &recordComponent{name: "users"} },
			ResultGuards: []ResultGuard{func(map[string]string) GuardResult {
				childRan = true
				return Allow()
			}},
		}},
	})
	RegisterRoute(Route{Path: "/login", Component: func() core.Component { return &recordComponent{name: "login"} }})

	if err := NavigateContext(context.Background(), "/admin/users"); err != nil {
		t.Fatalf("guard redirect: %v", err)
	}
	if childRan {
		t.Fatal("a child guard ran after the parent refused")
	}
	if got := mustRecord(t, CurrentComponent()).name; got != "login" {
		t.Fatalf("current component = %q, want login", got)
	}
}

func TestResultGuardRedirectsToLogin(t *testing.T)

{
	resetRouter(t)
	RegisterRoute(Route{Path: "/login", Component: func() core.Component { return &recordComponent{name: "login"} }})
	created := guardedRoute(t, "/account", []ResultGuard{func(map[string]string) GuardResult {
		return ReplaceWith("/login")
	}})

	if err := NavigateContext(context.Background(), "/account"); err != nil {
		t.Fatalf("guard redirect: %v", err)
	}
	if *created != 0 {
		t.Fatalf("protected component was created %d times", *created)
	}
	if got := mustRecord(t, CurrentComponent()).name; got != "login" {
		t.Fatalf("current component = %q, want login", got)
	}
	if ActivePath().Get() != "/login" {
		t.Fatalf("active path = %q, want /login", ActivePath().Get())
	}
	if Status().Get() != NavigationReady {
		t.Fatalf("navigation status = %s, want ready", Status().Get())
	}
}

func TestResultGuardRedirectKeepsRouteParameters(t *testing.T)

{
	resetRouter(t)
	var seen map[string]string
	RegisterRoute(Route{Path: "/denied", Component: func() core.Component { return &recordComponent{name: "denied"} }})
	RegisterRoute(Route{
		Path:      "/orders/:id",
		Component: func() core.Component { return &recordComponent{name: "order"} },
		ResultGuards: []ResultGuard{func(params map[string]string) GuardResult {
			seen = params
			return RedirectTo("/denied")
		}},
	})

	if err := NavigateContext(context.Background(), "/orders/17?ref=mail"); err != nil {
		t.Fatalf("guard redirect: %v", err)
	}
	if seen["id"] != "17" || seen["ref"] != "mail" {
		t.Fatalf("guard parameters = %#v", seen)
	}
	if got := mustRecord(t, CurrentComponent()).name; got != "denied" {
		t.Fatalf("current component = %q, want denied", got)
	}
}

func TestInvalidGuardResultFailsClosed(t *testing.T)

{
	cases := map[string]GuardResult{
		"empty":           RedirectTo(""),
		"blank":           ReplaceWith("   "),
		"relative":        RedirectTo("login"),
		"scheme relative": RedirectTo("//evil.example/login"),
		"unknown action":  {Action: GuardAction(42), Path: "/login"},
	}
	for name, result := range cases {
		t.Run(name, func(t *testing.T) {
			resetRouter(t)
			decision := result
			created := guardedRoute(t, "/secret", []ResultGuard{func(map[string]string) GuardResult {
				return decision
			}})

			err := NavigateContext(context.Background(), "/secret")

			if !errors.Is(err, ErrInvalidGuardResult) {
				t.Fatalf("expected an invalid guard result, got %v", err)
			}
			if *created != 0 || CurrentComponent() != nil {
				t.Fatalf("invalid guard result committed a route: created=%d component=%#v", *created, CurrentComponent())
			}
		})
	}
}

func TestResultGuardRedirectLoopFails(t *testing.T)

{
	resetRouter(t)
	RegisterRoute(Route{
		Path:         "/ping",
		Component:    func() core.Component { return &recordComponent{name: "ping"} },
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return RedirectTo("/pong") }},
	})
	RegisterRoute(Route{
		Path:         "/pong",
		Component:    func() core.Component { return &recordComponent{name: "pong"} },
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return ReplaceWith("/ping") }},
	})

	if err := NavigateContext(context.Background(), "/ping"); !errors.Is(err, ErrRedirectLoop) {
		t.Fatalf("expected a redirect loop error, got %v", err)
	}
	if CurrentComponent() != nil {
		t.Fatalf("redirect loop committed %#v", CurrentComponent())
	}
}

func TestLegacyGuardStillBlocksBeforeResultGuards(t *testing.T)

{
	resetRouter(t)
	resultRan := false
	RegisterRoute(Route{Path: "/", Component: func() core.Component { return &recordComponent{name: "root"} }})
	RegisterRoute(Route{
		Path:      "/legacy",
		Component: func() core.Component { return &recordComponent{name: "legacy"} },
		Guards:    []Guard{func(map[string]string) bool { return false }},
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult {
			resultRan = true
			return Allow()
		}},
	})

	if err := NavigateContext(context.Background(), "/legacy"); !errors.Is(err, ErrNavigationBlocked) {
		t.Fatalf("expected a blocked navigation, got %v", err)
	}
	if resultRan {
		t.Fatal("a result guard ran after a legacy guard blocked")
	}
}

func TestAllowingResultGuardCommitsRoute(t *testing.T)

{
	resetRouter(t)
	loaded := false
	RegisterRoute(Route{
		Path:         "/open",
		Component:    func() core.Component { return &recordComponent{name: "open"} },
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return Allow() }},
		Loader: func(context.Context, LoadContext) (any, error) {
			loaded = true
			return nil, nil
		},
	})

	if err := NavigateContext(context.Background(), "/open"); err != nil {
		t.Fatalf("navigate: %v", err)
	}
	if !loaded {
		t.Fatal("an allowed route did not run its loader")
	}
	if got := mustRecord(t, CurrentComponent()).name; got != "open" {
		t.Fatalf("current component = %q, want open", got)
	}
}

func TestCancelledNavigationSkipsResultGuards(t *testing.T)

{
	resetRouter(t)
	guardRan := false
	RegisterRoute(Route{
		Path:      "/cancelled-guard",
		Component: func() core.Component { return &recordComponent{name: "cancelled"} },
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult {
			guardRan = true
			return Allow()
		}},
	})
	ctx, cancel := context.WithCancel(context.Background())
	cancel()

	if err := NavigateContext(ctx, "/cancelled-guard"); !errors.Is(err, context.Canceled) {
		t.Fatalf("expected a cancelled navigation, got %v", err)
	}
	if guardRan {
		t.Fatal("a guard ran for a cancelled navigation")
	}
}

func TestReplaceKeepsHistoryLength(t *testing.T)

{
	Reset()
	originalPath := js.Location().Get("pathname").String() +
		js.Location().Get("search").String() +
		js.Location().Get("hash").String()
	t.Cleanup(func() {
		js.History().Call("replaceState", nil, "", originalPath)
		Reset()
	})

	RegisterRoute(Route{
		Path:      "/replace-history",
		Component: func() core.Component { return routeComponent{} },
	})
	before := js.History().Get("length").Int()

	Replace("/replace-history")

	if got := js.Location().Get("pathname").String(); got != "/replace-history" {
		t.Fatalf("expected replaced path, got %q", got)
	}
	if got := js.History().Get("length").Int(); got != before {
		t.Fatalf("history length changed from %d to %d", before, got)
	}
}

func travelHistory(t *testing.T, direction string) string

{
	t.Helper()
	popstate, stop := events.Listen("popstate", js.Window())
	defer stop()
	js.History().Call(direction)
	select {
	case <-popstate:
	case <-time.After(2 * time.Second):
		t.Fatalf("history %s did not fire popstate", direction)
	}
	return js.Location().Get("pathname").String()
}

func TestGuardReplaceLeavesNoHistoryEntry(t *testing.T)

{
	Reset()
	restoreHistoryPath(t)

	RegisterRoute(Route{Path: "/guard-base", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{Path: "/guard-entry", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{Path: "/guard-login", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{
		Path:         "/guard-account",
		Component:    func() core.Component { return routeComponent{} },
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return ReplaceWith("/guard-login") }},
	})

	Navigate("/guard-base")
	Navigate("/guard-entry")
	before := js.History().Get("length").Int()

	Navigate("/guard-account")

	if got := js.Location().Get("pathname").String(); got != "/guard-login" {
		t.Fatalf("path after the login redirect = %q", got)
	}
	if got := js.History().Get("length").Int(); got != before {
		t.Fatalf("history length changed from %d to %d", before, got)
	}
	if got := travelHistory(t, "back"); got != "/guard-base" {
		t.Fatalf("back landed on %q, want /guard-base", got)
	}
	if got := travelHistory(t, "forward"); got != "/guard-login" {
		t.Fatalf("forward landed on %q, want /guard-login", got)
	}
}

func TestGuardRedirectPushesHistoryEntry(t *testing.T)

{
	Reset()
	restoreHistoryPath(t)

	RegisterRoute(Route{Path: "/guard-origin", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{Path: "/guard-offers", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{
		Path:         "/guard-promo",
		Component:    func() core.Component { return routeComponent{} },
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return RedirectTo("/guard-offers") }},
	})

	Navigate("/guard-origin")
	before := js.History().Get("length").Int()

	Navigate("/guard-promo")

	if got := js.Location().Get("pathname").String(); got != "/guard-offers" {
		t.Fatalf("path after the guard redirect = %q", got)
	}
	if got := js.History().Get("length").Int(); got != before+1 {
		t.Fatalf("history length = %d, want %d", got, before+1)
	}
	if got := travelHistory(t, "back"); got != "/guard-origin" {
		t.Fatalf("back landed on %q, want /guard-origin", got)
	}
	if got := travelHistory(t, "forward"); got != "/guard-offers" {
		t.Fatalf("forward landed on %q, want /guard-offers", got)
	}
}

func TestGuardRedirectOnHistoryNoneReplacesEntry(t *testing.T)

{
	Reset()
	restoreHistoryPath(t)

	RegisterRoute(Route{Path: "/none-origin", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{Path: "/none-offers", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{
		Path:         "/none-promo",
		Component:    func() core.Component { return routeComponent{} },
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return RedirectTo("/none-offers") }},
	})

	Navigate("/none-origin")
	js.History().Call("pushState", nil, "", "/none-promo")
	before := js.History().Get("length").Int()

	navigate("/none-promo", historyNone)

	if got := js.Location().Get("pathname").String(); got != "/none-offers" {
		t.Fatalf("path after the guard redirect = %q", got)
	}
	if got := js.History().Get("length").Int(); got != before {
		t.Fatalf("history length changed from %d to %d", before, got)
	}
	if got := travelHistory(t, "back"); got != "/none-origin" {
		t.Fatalf("back landed on %q, want /none-origin", got)
	}
	if got := travelHistory(t, "forward"); got != "/none-offers" {
		t.Fatalf("forward landed on %q, want /none-offers", got)
	}
}

func TestGuardReplaceOnDeepLink(t *testing.T)

{
	Reset()
	restoreHistoryPath(t)

	created := 0
	RegisterRoute(Route{Path: "/deep-login", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{
		Path: "/deep-account",
		Component: func() core.Component {
			created++
			return routeComponent{}
		},
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult { return ReplaceWith("/deep-login") }},
	})

	js.History().Call("pushState", nil, "", "/deep-account")
	navigate("/deep-account", historyNone)

	if got := js.Location().Get("pathname").String(); got != "/deep-login" {
		t.Fatalf("deep link path = %q, want /deep-login", got)
	}
	if created != 0 {
		t.Fatalf("protected component was created %d times", created)
	}
}

func TestHistoryNoneGuardFallbackDoesNotPush(t *testing.T)

{
	Reset()
	t.Cleanup(Reset)
	RegisterRoute(Route{
		Path:      "/",
		Component: func() core.Component { return routeComponent{} },
	})
	RegisterRoute(Route{
		Path:      "/protected",
		Component: func() core.Component { return routeComponent{} },
		Guards:    []Guard{func(map[string]string) bool { return false }},
	})
	before := js.History().Get("length").Int()

	navigate("/protected", historyNone)

	if got := js.History().Get("length").Int(); got != before {
		t.Fatalf("history length changed from %d to %d", before, got)
	}
}

func TestSameInstanceRouteUpdatesInPlace(t *testing.T)

{
	Reset()
	if dom.ByID("app").IsNull() {
		host := dom.CreateElement("div")
		host.SetAttr("id", "app")
		dom.Doc().Body().AppendChild(host)
	}

	shell := core.NewHTMLComponent("InplaceShell", []byte(`<root>@include:outlet</root>`), nil)
	shell.SetComponent(shell)
	shell.AddDependency("outlet", NewOutlet())
	shell.Init(nil)

	page := core.NewHTMLComponent("InplacePage", []byte(`<root><div data-inplace></div></root>`), nil)
	page.SetComponent(page)
	page.Init(nil)

	// The same instance backs both the base path and its :id variant.
	Page("/inplace", page)
	Page("/inplace/:id", page)

	MountRoot(shell)

	Navigate("/inplace")
	// The page fills itself after mount, the way a fetch callback would.
	dom.Query("[data-inplace]").SetHTML(`<b id="inplace-built">built</b>`)
	if !strings.Contains(dom.ByID("app").HTML(), "inplace-built") {
		t.Fatal("marker was not injected")
	}

	// Navigate to the :id variant of the same instance.
	Navigate("/inplace/42")
	if got := ActivePath().Get(); got != "/inplace/42" {
		t.Fatalf("active path not updated: %s", got)
	}
	if !strings.Contains(dom.ByID("app").HTML(), "inplace-built") {
		t.Fatalf("navigating to the same-instance :id route remounted the view (marker wiped): %s", dom.ByID("app").HTML())
	}

	// Back to the base path stays in place too.
	Navigate("/inplace")
	if got := ActivePath().Get(); got != "/inplace" {
		t.Fatalf("active path not restored: %s", got)
	}
	if !strings.Contains(dom.ByID("app").HTML(), "inplace-built") {
		t.Fatalf("navigating back remounted the view (marker wiped): %s", dom.ByID("app").HTML())
	}
}

func TestRevalidateHostReplaceReportsHandoff(t *testing.T)

{
	resetRouter(t)
	valid := true
	session := registerSessionRoute(t, "/reval-host", func(map[string]string) GuardResult {
		if !valid {
			return HostReplace("/login?next=%2Freval-host")
		}
		return Allow()
	})

	if err := NavigateContext(context.Background(), "/reval-host"); err != nil {
		t.Fatalf("navigate: %v", err)
	}
	page := mustRevalidatePage(t, CurrentComponent())
	created, loaded := session.created, session.loaded

	valid = false
	err := RevalidateContext(context.Background())

	if got := hostNavigation(t, err); got != "/login?next=%2Freval-host" {
		t.Fatalf("host path = %q", got)
	}
	if page.unmounted != 0 || page.cleanups != 0 {
		t.Fatalf("the handoff tore the mounted page down: unmounted=%d cleanups=%d", page.unmounted, page.cleanups)
	}
	if CurrentComponent() != page {
		t.Fatalf("current component changed to %#v", CurrentComponent())
	}
	if session.created != created || session.loaded != loaded {
		t.Fatalf("the handoff re-ran the route: created=%d loaded=%d", session.created, session.loaded)
	}
	if got := ActivePath().Get(); got != "/reval-host" {
		t.Fatalf("active path = %q", got)
	}
	if Data().Get() != "payload" || Meta().Get()["section"] != "session" {
		t.Fatalf("the handoff changed route state: data=%#v meta=%#v", Data().Get(), Meta().Get())
	}
	if Status().Get() != NavigationError || !errors.Is(Error().Get(), ErrHostNavigation) {
		t.Fatalf("navigation state: status=%s error=%v", Status().Get(), Error().Get())
	}
}

func TestRevalidateInvalidGuardResultFailsClosed(t *testing.T)

{
	for name, decision := range map[string]GuardResult{
		"scheme relative": RedirectTo("//evil.example/login"),
		"relative":        ReplaceWith("login"),
		"off origin host": HostReplace("https://evil.example/login"),
		"unknown action":  {Action: GuardAction(42), Path: "/login"},
	} {
		t.Run(name, func(t *testing.T) {
			resetRouter(t)
			result := decision
			valid := true
			registerSessionRoute(t, "/reval-invalid", func(map[string]string) GuardResult {
				if !valid {
					return result
				}
				return Allow()
			})

			if err := NavigateContext(context.Background(), "/reval-invalid"); err != nil {
				t.Fatalf("navigate: %v", err)
			}
			page := mustRevalidatePage(t, CurrentComponent())

			valid = false
			if err := RevalidateContext(context.Background()); !errors.Is(err, ErrInvalidGuardResult) {
				t.Fatalf("expected an invalid guard result, got %v", err)
			}
			if page.unmounted != 1 || page.cleanups != 1 {
				t.Fatalf("teardown ran %d times (cleanups %d), want 1", page.unmounted, page.cleanups)
			}
			if CurrentComponent() != nil {
				t.Fatalf("the route stayed current: %#v", CurrentComponent())
			}
			// A refusal the router could not even apply revokes like any other.
			if Data().Get() != nil || len(Meta().Get()) != 0 {
				t.Fatalf("the revoked route's state survived: data=%#v meta=%#v", Data().Get(), Meta().Get())
			}
		})
	}
}

func sessionGuardedRoute(t *testing.T, authenticated, permitted *bool) *int

{
	t.Helper()
	created := 0
	RegisterRoute(Route{
		Path: "/composed",
		ResultGuards: []ResultGuard{func(map[string]string) GuardResult {
			switch {
			case !*authenticated:
				return HostReplace("/login")
			case !*permitted:
				return Forbid()
			default:
				return Allow()
			}
		}},
		Component: func() core.Component {
			created++
			return &recordComponent{name: "composed"}
		},
	})
	return &created
}

func TestHostReplaceTargetRejectsOffOriginTargets(t *testing.T)

{
	for _, tc := range hostReplaceRejects {
		t.Run(tc.name, func(t *testing.T) {
			destination, err := guardHostReplaceTarget(tc.target)
			if !errors.Is(err, ErrInvalidGuardResult) {
				t.Fatalf("guardHostReplaceTarget(%q) = %q, %v", tc.target, destination, err)
			}
			if destination != "" {
				t.Fatalf("rejected target returned a destination: %q", destination)
			}
		})
	}
}

func TestHostReplaceTargetAcceptsRootedPaths(t *testing.T)

{
	for _, target := range hostReplaceAccepts {
		t.Run(target, func(t *testing.T) {
			destination, err := guardHostReplaceTarget(target)
			if err != nil {
				t.Fatalf("guardHostReplaceTarget(%q): %v", target, err)
			}
			if destination != target {
				t.Fatalf("destination = %q, want %q", destination, target)
			}
		})
	}
}

func TestHostNavigationErrorIsDistinct(t *testing.T)

{
	var err error = &HostNavigationError{Path: "/login"}
	if !errors.Is(err, ErrHostNavigation) {
		t.Fatalf("host navigation error does not wrap ErrHostNavigation: %v", err)
	}
	if errors.Is(err, ErrNavigationForbidden) || errors.Is(err, ErrRouteNotFound) || errors.Is(err, ErrInvalidGuardResult) {
		t.Fatalf("host navigation error matches another outcome: %v", err)
	}
	var host *HostNavigationError
	if !errors.As(err, &host) || host.Path != "/login" {
		t.Fatalf("host navigation error target = %#v", host)
	}
	if err.Error() != "router: host navigation requested: /login" {
		t.Fatalf("error message = %q", err.Error())
	}
}

func TestSessionGuardAllowsAndForbidsInsideSPA(t *testing.T)

{
	resetRouter(t)
	authenticated, permitted := true, true
	created := sessionGuardedRoute(t, &authenticated, &permitted)

	if err := NavigateContext(context.Background(), "/composed"); err != nil {
		t.Fatalf("navigate: %v", err)
	}
	if got := mustRecord(t, CurrentComponent()).name; got != "composed" {
		t.Fatalf("current component = %q, want composed", got)
	}
	if *created != 1 {
		t.Fatalf("component created %d times, want 1", *created)
	}

	permitted = false
	err := NavigateContext(context.Background(), "/composed")

	if !errors.Is(err, ErrNavigationForbidden) {
		t.Fatalf("expected a forbidden navigation, got %v", err)
	}
	if errors.Is(err, ErrHostNavigation) {
		t.Fatal("an authenticated caller without the permission was sent to the host")
	}
	if *created != 1 {
		t.Fatalf("forbidden navigation created the component again: %d", *created)
	}
}

func TestRegisterRoute_BasicRouting(t *testing.T)

{
	resetRouter(t)

	RegisterRoute(Route{Path: "/a", Component: func() core.Component { return &recordComponent{name: "a"} }})
	RegisterRoute(Route{Path: "/users/:id", Component: func() core.Component { return &recordComponent{name: "user"} }})

	NavigateTo("/a")
	if got := mustRecord(t, CurrentComponent()).name; got != "a" {
		t.Fatalf("expected current component 'a', got %q", got)
	}

	NavigateTo("/users/123")
	rc := mustRecord(t, CurrentComponent())
	if rc.params["id"] != "123" {
		t.Fatalf("expected id=123, got %v", rc.params)
	}

	var gotPath string
	NotFoundCallback = func(p string) { gotPath = p }
	NavigateTo("/missing")
	if gotPath != "/missing" {
		t.Fatalf("expected NotFoundCallback '/missing', got %q", gotPath)
	}
}

func TestNavigateTo_CurrentComponent(t *testing.T)

{
	resetRouter(t)

	NavigateTo("/nothing")
	if CurrentComponent() != nil {
		t.Fatalf("expected nil current component before routes")
	}

	RegisterRoute(Route{Path: "/home", Component: func() core.Component { return &recordComponent{name: "home"} }})
	NavigateTo("/home")
	if got := mustRecord(t, CurrentComponent()).name; got != "home" {
		t.Fatalf("expected 'home', got %q", got)
	}
}

func TestRouteGuards_BlockNavigation(t *testing.T)

{
	resetRouter(t)

	RegisterRoute(Route{Path: "/", Component: func() core.Component { return &recordComponent{name: "root"} }})

	var guardParams map[string]string
	RegisterRoute(Route{
		Path:      "/admin/:id",
		Component: func() core.Component { return &recordComponent{name: "admin"} },
		Guards: []Guard{func(p map[string]string) bool {
			guardParams = map[string]string{}
			for k, v := range p {
				guardParams[k] = v
			}
			return false
		}},
	})

	NavigateTo("/admin/42")
	if guardParams["id"] != "42" {
		t.Fatalf("expected guard to receive id=42, got %v", guardParams)
	}
	if got := mustRecord(t, CurrentComponent()).name; got != "root" {
		t.Fatalf("expected navigation to '/', got %q", got)
	}
}

func TestQueryParams(t *testing.T)

{
	resetRouter(t)

	RegisterRoute(Route{Path: "/search/:kind", Component: func() core.Component { return &recordComponent{name: "search"} }})
	NavigateTo("/search/books?q=go&lang=en")

	rc := mustRecord(t, CurrentComponent())
	want := map[string]string{"kind": "books", "q": "go", "lang": "en"}
	if !reflect.DeepEqual(rc.params, want) {
		t.Fatalf("expected params %v, got %v", want, rc.params)
	}
}

func TestNotFoundComponent(t *testing.T)

{
	resetRouter(t)

	RegisterRoute(Route{Path: "/home", Component: func() core.Component { return &recordComponent{name: "home"} }})
	NavigateTo("/home")
	_ = mustRecord(t, CurrentComponent())

	NotFoundComponent = func() core.Component { return &recordComponent{name: "404"} }
	NavigateTo("/missing")

	nf := mustRecord(t, CurrentComponent())
	if nf.name != "404" {
		t.Fatalf("expected 404 current component, got %q", nf.name)
	}
}

func TestTrailingSlashNormalization(t *testing.T)

{
	resetRouter(t)

	RegisterRoute(Route{Path: "/trail", Component: func() core.Component { return &recordComponent{name: "trail"} }})
	NavigateTo("/trail/")
	if got := mustRecord(t, CurrentComponent()).name; got != "trail" {
		t.Fatalf("expected trailing slash to match, got %q", got)
	}

	var called bool
	NotFoundCallback = func(string) { called = true }
	NavigateTo("/trail/extra")
	if !called {
		t.Fatalf("expected not found for extra segments")
	}
}

func TestNestedRouteNavigation(t *testing.T)

{
	resetRouter(t)

	RegisterRoute(Route{
		Path: "/teams/:team",
		Children: []Route{{
			Path:      "projects/:project",
			Component: func() core.Component { return &recordComponent{name: "project"} },
		}},
	})

	NavigateTo("/teams/acme/projects/rfw?tab=issues")
	rc := mustRecord(t, CurrentComponent())
	want := map[string]string{
		"team":    "acme",
		"project": "rfw",
		"tab":     "issues",
	}
	if !reflect.DeepEqual(rc.params, want) {
		t.Fatalf("expected params %v, got %v", want, rc.params)
	}
	if !CanNavigate("/teams/acme/projects/rfw") {
		t.Fatal("expected nested route to be navigable")
	}
}

func TestNestedRouteChildParamShadowsParent(t *testing.T)

{
	resetRouter(t)

	RegisterRoute(Route{
		Path: "/teams/:id",
		Children: []Route{{
			Path:      "users/:id",
			Component: func() core.Component { return &recordComponent{name: "user"} },
		}},
	})

	NavigateTo("/teams/acme/users/alice")
	rc := mustRecord(t, CurrentComponent())
	if rc.params["id"] != "alice" {
		t.Fatalf("expected child id=alice, got %v", rc.params)
	}
}

func TestParentRouteDoesNotMatchUnknownChild(t *testing.T)

{
	resetRouter(t)

	RegisterRoute(Route{
		Path:      "/docs",
		Component: func() core.Component { return &recordComponent{name: "docs"} },
		Children: []Route{{
			Path:      "page",
			Component: func() core.Component { return &recordComponent{name: "page"} },
		}},
	})
	called := false
	NotFoundCallback = func(string) { called = true }

	NavigateTo("/docs/unknown")

	if !called {
		t.Fatal("expected unknown child path to be not found")
	}
}

func TestAbsoluteNestedRouteNavigation(t *testing.T)

{
	resetRouter(t)
	guardCalled := false
	RegisterRoute(Route{
		Path:   "/admin",
		Guards: []Guard{func(map[string]string) bool { guardCalled = true; return true }},
		Children: []Route{{
			Path:      "/login",
			Component: func() core.Component { return &recordComponent{name: "login"} },
		}},
	})

	NavigateTo("/login")

	if got := mustRecord(t, CurrentComponent()).name; got != "login" {
		t.Fatalf("expected absolute child route, got %q", got)
	}
	if !guardCalled {
		t.Fatal("expected parent guard to run for absolute child")
	}
}

func RevalidateContext(parent context.Context) error

{
	// A caller with no context to give passes none, the way Revalidate does.
	// Normalized here, at the one entry point: a redirect derives its context
	// from this parent, and deriving from a nil one panics.
	if parent == nil {
		parent = context.Background()
	}
	// Nothing mounted is nothing to revalidate: a navigation that has not
	// committed yet still has its own guards ahead of it, and a refusal already
	// cleared the owner it dropped.
	if currentComponent == nil {
		return nil
	}
	r, guards, params := matchCurrentRoute(activePathSig.Get())
	if r == nil {
		return nil
	}
	// The match only speaks for the route that actually committed what is
	// mounted. It does not when a route is registered for the path the
	// not-found component is sitting on: those guards never ran to put anything
	// there, so they have no say over a component that is not theirs.
	if r.component != currentComponent {
		return nil
	}
	// Taking the navigation generation cancels whatever is in flight: it was
	// authorized under the snapshot this call replaces, so its loader must not
	// come back and commit over the decision made here.
	ctx, _ := beginNavigation(parent)
	if err := ctx.Err(); err != nil {
		return err
	}

	guardResult, guardErr := runGuards(guards, params)
	if guardErr != nil {
		// Every refusal fails closed the same way, a legacy guard that blocks
		// included: the route is mounted, so leaving it there is the one outcome
		// a refusal cannot have. Navigation to a refused destination keeps its
		// own behavior, where nothing was committed to take back.
		revokeMountedRoute(guardErr)
		return guardErr
	}
	switch guardResult.Action {
	case GuardAllow:
		settleRevalidatedRoute()
		return nil
	case GuardHostReplace:
		// There is no document to replace here and the host page is not a route
		// this router could load in its place, so the handoff is reported with
		// its target and the mounted route is left alone, exactly as
		// NavigateContext reports it.
		hostErr := &HostNavigationError{Path: guardResult.Path}
		failNavigation(hostErr)
		return hostErr
	}

	redirectCtx, err := nextRedirectContext(parent)
	if err != nil {
		failNavigation(err)
		return err
	}
	// Taken before the redirect, released after it commits: the destination is
	// what decides whether this route is still the one the user owns.
	owner := currentComponent
	// The stub keeps no browser history, so a push and a replace redirect both
	// navigate, as they do for a refused destination.
	if err := NavigateContext(redirectCtx, guardResult.Path); err != nil {
		// The destination refused, failed to load or was cancelled: nothing
		// committed over the route the user is on, so it stays current and keeps
		// everything it holds.
		return err
	}
	releaseReplacedOwner(owner)
	return nil
}