router

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 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 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 TestRegisteredRoutes(t *testing.T)

{
	Reset()
	RegisterRoute(Route{Path: "/static", Component: func() core.Component { return routeComponent{} }})
	RegisterRoute(Route{
		Path:      "/users",
		Component: func() core.Component { return routeComponent{} },
		Children: []Route{
			{
				Path:      ":id",
				Component: func() core.Component { return routeComponent{} },
			},
			{
				Path:      ":id/profile",
				Component: func() core.Component { return routeComponent{} },
			},
		},
	})

	defs := RegisteredRoutes()
	if len(defs) != 2 {
		t.Fatalf("expected 2 top level routes, got %d", len(defs))
	}
	if defs[0].Path != "/static" || len(defs[0].Params) != 0 {
		t.Fatalf("unexpected static route: %+v", defs[0])
	}

	users := defs[1]
	if users.Path != "/users" {
		t.Fatalf("expected /users path, got %s", users.Path)
	}
	if len(users.Children) != 2 {
		t.Fatalf("expected two children, got %d", len(users.Children))
	}
	child := users.Children[0]
	if child.Path != "/users/:id" {
		t.Fatalf("expected /users/:id full path, got %s", child.Path)
	}
	if len(child.Params) != 1 || child.Params[0] != "id" {
		t.Fatalf("expected id param, got %+v", child.Params)
	}
	profile := users.Children[1]
	if profile.Path != "/users/:id/profile" {
		t.Fatalf("expected /users/:id/profile path, got %s", profile.Path)
	}
}

func TestNavigateTrailingSlashNotFound(t *testing.T)

{
	Reset()
	RegisterRoute(Route{Path: "/trail", Component: func() core.Component { return &trailingComponent{} }})
	called := false
	NotFoundCallback = func(string) { called = true }
	Navigate("/trail/extra")
	if !called {
		t.Fatalf("expected NotFoundCallback for extra path, got none")
	}
	NotFoundCallback = 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 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 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 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 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 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:     r.Guards,
		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, []Guard, 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, append(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, append(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)
				} else {
					dom.UpdateDOM(c.GetID(), core.TryRender(c))
				}
				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
	}
	for _, g := range guards {
		if !g(params) {
			if currentComponent == nil && path != "/" {
				navigate("/", history)
			}
			return ErrNavigationBlocked
		}
	}

	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)
	} else {
		dom.UpdateDOM(r.component.GetID(), r.component.Render())
	}
	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 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 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:     r.Guards,
		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, []Guard, 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, append(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, append(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 NavigateContext(parent context.Context, fullPath string) 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 {
			switch nc := NotFoundComponent.(type) {
			case *types.View:
				currentComponent = nc
			case func() *types.View:
				currentComponent = nc()
			case func() core.Component:
				currentComponent = nc()
			}
			activePathSig.Set(fullPath)
			commitRouteState(nil, nil)
			return nil
		}
		err := ErrRouteNotFound
		failNavigation(err)
		return err
	}

	if params == nil {
		params = map[string]string{}
	}
	queryParams, queryValues := routeQuery(query)
	for key, value := range queryParams {
		params[key] = value
	}
	for _, g := range guards {
		if !g(params) {
			if currentComponent == nil && path != "/" {
				Navigate("/")
			}
			return ErrNavigationBlocked
		}
	}

	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 NavigateContext(redirectCtx, destination)
	}

	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)
	}

	currentComponent = r.component
	if handler, ok := r.component.(routeParamHandler); ok {
		handler.OnParams(params)
	}
	activePathSig.Set(fullPath)
	commitRouteState(data, r.meta)
	return nil
}

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 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 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 TestNavigateReloadsRouteEachTime(t *testing.T)

{
	Reset()
	count := 0
	RegisterRoute(Route{Path: "/reload", Component: func() core.Component {
		count++
		return &reloadComponent{}
	}})
	Navigate("/reload")
	Navigate("/reload")
	if count != 2 {
		t.Fatalf("expected loader called twice, got %d", count)
	}
}