core

func requestScheduledRender(job renderJob)

{
	if job.id == "" || job.active == nil || job.render == nil || !job.active() {
		return
	}
	componentRenderScheduler.Lock()
	componentRenderScheduler.pending[job.id] = job
	if componentRenderScheduler.scheduled {
		componentRenderScheduler.Unlock()
		return
	}
	componentRenderScheduler.scheduled = true
	componentRenderScheduler.Unlock()

	var callback js.Func
	callback = js.SafeFuncOf(func(js.Value, []js.Value) any {
		defer callback.Release()
		flushComponentRenders()
		return nil
	})
	queueMicrotask := js.Global().Get("queueMicrotask")
	if queueMicrotask.Type() == js.TypeFunction {
		queueMicrotask.Invoke(callback.Value)
		return
	}
	js.Global().Call("setTimeout", callback.Value, 0)
}

func flushComponentRenders()

{
	componentRenderScheduler.Lock()
	pending := make([]renderJob, 0, len(componentRenderScheduler.pending))
	for _, job := range componentRenderScheduler.pending {
		pending = append(pending, job)
	}
	clear(componentRenderScheduler.pending)
	componentRenderScheduler.scheduled = false
	componentRenderScheduler.Unlock()

	// Parents commit before descendants. Ownership boundaries keep a parent from
	// touching child internals; the ordering makes both renders deterministic.
	sort.Slice(pending, func(i, j int) bool {
		if pending[i].depth != pending[j].depth {
			return pending[i].depth < pending[j].depth
		}
		return pending[i].id < pending[j].id
	})
	for _, job := range pending {
		if !job.active() {
			continue
		}
		job.render()
	}
}

func mountedComponentDepth(componentID string) int

{
	root := dom.ComponentRoot(componentID)
	if root.IsNull() || root.IsUndefined() {
		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 TestGoldenIncludeDirective(t *testing.T)

{
	child := NewHTMLComponent("GoldenIncChild", []byte(`<root><em>child</em></root>`), nil)
	tpl := `<root>@include:child</root>`
	c := NewHTMLComponent("GoldenInc", []byte(tpl), nil)
	c.Init(nil)
	c.AddDependency("child", child)
	got := c.Render()
	want := fmt.Sprintf(`<root data-component-id="%s"><root data-component-id="%s"><em>child</em></root>
</root>
`, c.ID, child.ID)
	expectGolden(t, got, want)
}

func TestGoldenSlotDirective(t *testing.T)

{
	tpl := `<root><div>@slot:header fallback@endslot</div></root>`
	c := NewHTMLComponent("GoldenSlot", []byte(tpl), nil)
	c.Init(nil)
	c.SetSlots(map[string]any{"header": "provided"})
	got := c.Render()
	want := fmt.Sprintf(`<root data-component-id="%s"><div>provided</div></root>
`, c.ID)
	expectGolden(t, got, want)

	// Without provided content the inline fallback is rendered.
	c2 := NewHTMLComponent("GoldenSlotFallback", []byte(tpl), nil)
	c2.Init(nil)
	got2 := c2.Render()
	want2 := fmt.Sprintf(`<root data-component-id="%s"><div> fallback</div></root>
`, c2.ID)
	expectGolden(t, got2, want2)
}

func TestGoldenConditionalDirective(t *testing.T)

{
	tpl := "<root>\n@if:prop:v==\"1\"\nOne\n@else-if:prop:v==\"2\"\nTwo\n@else\nOther\n@endif\n</root>"
	got, c := renderGolden(t, "GoldenIf", tpl, map[string]any{"v": "2"})
	conds := []string{`@if:prop:v=="1"`, `@else-if:prop:v=="2"`, ""}
	// the trailing index numbers the block within the render pass: two @if
	// blocks with the same condition are distinct blocks
	condHash := sha256.Sum256([]byte(strings.Join(conds, "|")))
	condID := fmt.Sprintf("cond-%x-0", condHash[:20])
	want := fmt.Sprintf("<root data-component-id=\"%s\">\n<div data-condition=\"%s\" data-condition-branch=\"1\">Two\n</div></root>\n", c.ID, condID)
	expectGolden(t, got, want)
}

func TestGoldenRtIsDirective(t *testing.T)

{
	if err := RegisterComponent("GoldenRtIsChild", func() Component {
		return NewHTMLComponent("GoldenRtIsChild", []byte(`<root><em>dyn</em></root>`), nil)
	}); err != nil && !strings.Contains(err.Error(), "already registered") {
		t.Fatalf("register: %v", err)
	}
	tpl := `<root><div rt-is="GoldenRtIsChild"></div></root>`
	got, c := renderGolden(t, "GoldenRtIs", tpl, nil)
	child := c.Dependencies["rtis-GoldenRtIsChild-0"].(*HTMLComponent)
	want := fmt.Sprintf(`<root data-component-id="%s"><root data-component-id="%s"><em>dyn</em></root>
</div></root>
`, c.ID, child.ID)
	expectGolden(t, got, want)
}

func TestElseIfRendering(t *testing.T)

{
	c := &HTMLComponent{Props: map[string]any{"val": "2"}, conditionContents: make(map[string]ConditionContent)}
	template := `
@if:prop:val=="1"
One
@else-if:prop:val=="2"
Two
@else
Other
@endif`

	out := replaceConditionals(template, c)
	if strings.Contains(out, "One") || strings.Contains(out, "Other") {
		t.Fatalf("unexpected branches rendered: %s", out)
	}
	if !strings.Contains(out, "Two") {
		t.Fatalf("expected 'Two' branch, got %s", out)
	}
}

func TestNestedConditionals(t *testing.T)

{
	props := map[string]any{"outer": "yes", "inner": "maybe"}
	c := &HTMLComponent{Props: props, conditionContents: make(map[string]ConditionContent)}
	template := `
@if:prop:outer=="yes"
Start
    @if:prop:inner=="yes"
        InnerYes
    @else-if:prop:inner=="maybe"
        InnerMaybe
    @else
        InnerNo
    @endif
@else
    OuterNo
@endif`

	out := replaceConditionals(template, c)
	if !strings.Contains(out, "Start") || !strings.Contains(out, "InnerMaybe") {
		t.Fatalf("nested conditions not rendered as expected: %s", out)
	}
	if strings.Contains(out, "InnerYes") || strings.Contains(out, "InnerNo") || strings.Contains(out, "OuterNo") {
		t.Fatalf("unexpected branches present: %s", out)
	}
}

func TestReplaceConstructors(t *testing.T)

{
	tpl := `<div [header] class="box"></div>`
	out := replaceConstructors(tpl)
	if !strings.Contains(out, `data-ref="header"`) || !strings.Contains(out, `class="box"`) {
		t.Fatalf("unexpected constructor replacement: %s", out)
	}

	tpl = `<li [key {item.ID}]></li>`
	out = replaceConstructors(tpl)
	if out != `<li data-key="{item.ID}"></li>` {
		t.Fatalf("expected data-key constructor, got %s", out)
	}
}

func TestPluginPlaceholders(t *testing.T)

{
	RegisterPluginVar("soccer", "team", "lions")
	tpl := `<div @plugin:soccer.init>{plugin:soccer.team}</div>`
	out := replacePluginPlaceholders(tpl)
	if !strings.Contains(out, "lions") {
		t.Fatalf("plugin variable not replaced: %s", out)
	}
	if !strings.Contains(out, `data-plugin-cmd="soccer.init"`) {
		t.Fatalf("plugin command not replaced: %s", out)
	}

	tpl = `<span [plugin:soccer.badge]></span>`
	out = replaceConstructors(tpl)
	if !strings.Contains(out, `data-plugin="soccer.badge"`) {
		t.Fatalf("plugin constructor not replaced: %s", out)
	}
}

func TestForUnsetStoreKeyRendersNothing(t *testing.T)

{
	state.NewStore("fornil", state.WithModule("app"))
	tpl := []byte(`<root><div>@for:i in store:app.fornil.items
<span data-key="x">@prop:i.title</span>
@endfor</div></root>`)
	c := NewHTMLComponent("ForNil", tpl, nil)
	c.Init(nil)
	html := c.Render()
	if strings.Contains(html, "@prop") || strings.Contains(html, "@for") {
		t.Fatalf("unset store key leaked template markup: %s", html)
	}
}

func TestForFieldsEscapedByDefault(t *testing.T)

{
	st := state.NewStore("escfor", state.WithModule("app"))
	st.Set("items", []any{map[string]any{"txt": "<img src=x>", "markup": "<b>ok</b>"}})
	tpl := []byte(`<root><div>@for:i in store:app.escfor.items
<span data-key="k">@prop:i.txt|@rawprop:i.markup</span>
@endfor</div></root>`)
	c := NewHTMLComponent("EscFor", tpl, nil)
	c.Init(nil)
	html := c.Render()
	if !strings.Contains(html, "&lt;img src=x&gt;") {
		t.Fatalf("field not escaped: %s", html)
	}
	if !strings.Contains(html, "<b>ok</b>") {
		t.Fatalf("rawprop escaped: %s", html)
	}
}

func TestSignalEscapedByDefault(t *testing.T)

{
	sig := state.NewSignal("<img src=x onerror=alert(1)>")
	tpl := []byte(`<root><div>@signal:v</div></root>`)
	c := NewHTMLComponent("EscSignal", tpl, map[string]any{"v": sig})
	c.Init(nil)
	html := c.Render()
	if !strings.Contains(html, "&lt;img src=x onerror=alert(1)&gt;") {
		t.Fatalf("signal not escaped: %s", html)
	}
	if strings.Contains(html, "<img") {
		t.Fatalf("signal injected markup: %s", html)
	}
}

func TestExprEscapedByDefault(t *testing.T)

{
	tpl := []byte(`<root><div>@expr:msg</div></root>`)
	c := NewHTMLComponent("EscExpr", tpl, map[string]any{"msg": "<b>bad</b>"})
	c.Init(nil)
	html := c.Render()
	if !strings.Contains(html, "&lt;b&gt;bad&lt;/b&gt;") {
		t.Fatalf("expr not escaped: %s", html)
	}
	if strings.Contains(html, "<b>bad</b>") {
		t.Fatalf("expr injected markup: %s", html)
	}
}

func TestSignalUpdateUsesTextContent(t *testing.T)

{
	sig := state.NewSignal("safe")
	tpl := []byte(`<root><div>@signal:v</div></root>`)
	c := NewHTMLComponent("EscSignalUpdate", tpl, map[string]any{"v": sig})
	c.Init(nil)
	html := c.Render()
	container := dom.Doc().CreateElement("div")
	container.Set("innerHTML", html)
	dom.Doc().Get("body").Call("appendChild", container.Value)
	defer container.Call("remove")
	sig.Set("<img src=x onerror=alert(1)>")
	root := dom.ComponentRoot(c.ID)
	node := root.Query(`[data-signal="v"]`)
	if node.IsNull() || node.IsUndefined() {
		t.Fatalf("signal binding not found")
	}
	inner := node.Get("innerHTML").String()
	if !strings.Contains(inner, "&lt;img") {
		t.Fatalf("signal update not applied as text: %s", inner)
	}
}

func TestCurlyPropEscapedByDefault(t *testing.T)

{
	tpl := []byte(`<root><div>{{msg}}|@rawprop:markup</div></root>`)
	c := NewHTMLComponent("EscCurly", tpl, map[string]any{
		"msg":    "<script>alert(1)</script>",
		"markup": "<b>ok</b>",
	})
	c.Init(nil)
	html := c.Render()
	if !strings.Contains(html, "&lt;script&gt;alert(1)&lt;/script&gt;") {
		t.Fatalf("curly prop not escaped: %s", html)
	}
	if !strings.Contains(html, "<b>ok</b>") {
		t.Fatalf("rawprop escaped: %s", html)
	}
}

func TestForMapFieldsEscapedByDefault(t *testing.T)

{
	st := state.NewStore("escformap", state.WithModule("app"))
	st.Set("items", map[string]any{
		"<key>": map[string]any{"txt": "<img src=x>", "markup": "<b>ok</b>"},
	})
	tpl := []byte(`<root><div>@for:k,v in store:app.escformap.items
<span data-key="m">@prop:k|@prop:v.txt|@rawprop:v.markup</span>
@endfor</div></root>`)
	c := NewHTMLComponent("EscForMap", tpl, nil)
	c.Init(nil)
	html := c.Render()
	if !strings.Contains(html, "&lt;key&gt;") {
		t.Fatalf("map key not escaped: %s", html)
	}
	if !strings.Contains(html, "&lt;img src=x&gt;") {
		t.Fatalf("map field not escaped: %s", html)
	}
	if !strings.Contains(html, "<b>ok</b>") {
		t.Fatalf("rawprop escaped: %s", html)
	}
}

func TestForMapScalarsEscapedByDefault(t *testing.T)

{
	st := state.NewStore("escformapscalar", state.WithModule("app"))
	st.Set("items", map[string]any{"a": "<i>x</i>"})
	tpl := []byte(`<root><div>@for:k,v in store:app.escformapscalar.items
<span data-key="s">@prop:v</span>
@endfor</div></root>`)
	c := NewHTMLComponent("EscForMapScalar", tpl, nil)
	c.Init(nil)
	html := c.Render()
	if !strings.Contains(html, "&lt;i&gt;x&lt;/i&gt;") {
		t.Fatalf("map scalar not escaped: %s", html)
	}
}

func TestStoreEscapedByDefault(t *testing.T)

{
	st := state.NewStore("escstore", state.WithModule("app"))
	st.Set("v", "<i>x</i>")
	st.Set("m", "<i>y</i>")
	tpl := []byte(`<root><div>@store:app.escstore.v @rawstore:app.escstore.m</div></root>`)
	c := NewHTMLComponent("EscStore", tpl, nil)
	c.Init(nil)
	html := c.Render()
	if !strings.Contains(html, "&lt;i&gt;x&lt;/i&gt;") {
		t.Fatalf("store not escaped: %s", html)
	}
	if !strings.Contains(html, "<i>y</i>") {
		t.Fatalf("rawstore escaped: %s", html)
	}
}

func TestHyphenatedStorePathsResolve(t *testing.T)

{
	st := state.NewStore("hyphen-store", state.WithModule("app"))
	defer state.GlobalStoreManager.UnregisterStore("app", "hyphen-store")
	st.Set("first-name", "Mirko")
	st.Set("markup", "<i>y</i>")

	tpl := []byte(`<root>
@if:store:app.hyphen-store.first-name == "Mirko"
<div data-hyphen>@store:app.hyphen-store.first-name @rawstore:app.hyphen-store.markup</div>
@endif
</root>`)
	c := NewHTMLComponent("HyphenStore", tpl, nil)
	c.Init(nil)
	html := c.Render()

	if strings.Contains(html, "@store:") || strings.Contains(html, "@rawstore:") {
		t.Fatalf("hyphenated store path left in the markup: %s", html)
	}
	if !strings.Contains(html, "data-hyphen") {
		t.Fatalf("condition on a hyphenated store did not select the branch: %s", html)
	}
	if !strings.Contains(html, "Mirko") {
		t.Fatalf("hyphenated store value missing: %s", html)
	}
	if !strings.Contains(html, "<i>y</i>") {
		t.Fatalf("hyphenated rawstore escaped: %s", html)
	}
}

func TestHyphenatedStoreWriteBindingUpdatesStore(t *testing.T)

{
	st := state.NewStore("hyphen-write", state.WithModule("app"))
	defer state.GlobalStoreManager.UnregisterStore("app", "hyphen-write")
	st.Set("query-text", "")

	tpl := []byte(`<root><input data-hyphen-input value="@store:app.hyphen-write.query-text:w"></root>`)
	c := mountForComponent(t, "HyphenWrite", tpl)
	defer c.Unmount()

	input := dom.Query("[data-hyphen-input]")
	input.Set("value", "typed")
	input.Call("dispatchEvent", js.CustomEvent().New("input"))

	if got := st.Get("query-text"); got != "typed" {
		t.Fatalf("store key = %v, want %q", got, "typed")
	}
}

func TestConditionOnHyphenatedStoreReacts(t *testing.T)

{
	st := state.NewStore("hyphen-cond", state.WithModule("app"))
	defer state.GlobalStoreManager.UnregisterStore("app", "hyphen-cond")
	st.Set("chrome-state", "on")

	tpl := []byte(`<root>
@if:store:app.hyphen-cond.chrome-state == "on"
<header data-hyphen-header>shown</header>
@endif
</root>`)
	c := mountForComponent(t, "HyphenCond", tpl)
	defer c.Unmount()

	if dom.Query("[data-hyphen-header]").IsNull() {
		t.Fatal("header not rendered while the condition holds")
	}

	st.Set("chrome-state", "off")
	waitForRenderFlush()
	if el := dom.Query("[data-hyphen-header]"); !el.IsNull() {
		t.Fatal("header stayed after the hyphenated store key changed")
	}
}

func DefaultTransitionConfig() TransitionConfig

{
	return TransitionConfig{
		EnterFrom:   "rfw-enter-from",
		EnterActive: "rfw-enter-active",
		EnterTo:     "rfw-enter-to",
		LeaveFrom:   "rfw-leave-from",
		LeaveActive: "rfw-leave-active",
		LeaveTo:     "rfw-leave-to",
		Duration:    200 * time.Millisecond,
	}
}

func NewTransition(child Component, config TransitionConfig) *Transition

{
	defaults := DefaultTransitionConfig()
	if config.EnterFrom == "" {
		config.EnterFrom = defaults.EnterFrom
	}
	if config.EnterActive == "" {
		config.EnterActive = defaults.EnterActive
	}
	if config.EnterTo == "" {
		config.EnterTo = defaults.EnterTo
	}
	if config.LeaveFrom == "" {
		config.LeaveFrom = defaults.LeaveFrom
	}
	if config.LeaveActive == "" {
		config.LeaveActive = defaults.LeaveActive
	}
	if config.LeaveTo == "" {
		config.LeaveTo = defaults.LeaveTo
	}
	if config.Duration == 0 {
		config.Duration = defaults.Duration
	}
	return &Transition{
		id:     generateComponentID("Transition", nil),
		child:  child,
		config: config,
	}
}

func TestMountedDependencyConditionUpdatesDOM(t *testing.T)

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

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

	child := NewHTMLComponent("DomChild", []byte(`<root>
@if:store:app.depdom.chrome == "on"
<span id="dep-block">visible</span>
@endif
</root>`), nil)
	child.SetComponent(child)
	child.Init(nil)

	parent := NewHTMLComponent("DomParent", []byte(`<root>
@for:it in store:app.depdom.nav
<span class="nav">@prop:it.label</span>
@endfor
@include:child
</root>`), nil)
	parent.SetComponent(parent)
	parent.AddDependency("child", child)
	parent.Init(nil)

	dom.UpdateDOM(parent.GetID(), parent.Render())
	parent.Mount()
	defer parent.Unmount()

	if html := dom.ComponentRoot(parent.GetID()).HTML(); !strings.Contains(html, "dep-block") {
		t.Fatalf("dependency did not render: %s", html)
	}

	store.Set("chrome", "off")
	store.Set("nav", []any{map[string]any{"label": "one"}, map[string]any{"label": "two"}})
	waitForRenderFlush()

	html := dom.ComponentRoot(parent.GetID()).HTML()
	if !strings.Contains(html, "two") {
		t.Fatalf("parent did not re-render: %s", html)
	}
	if strings.Contains(html, "dep-block") {
		t.Fatalf("dependency kept its stale markup after the store changed: %s", html)
	}
}

func TestComponentDOMHookLifecycle(t *testing.T)

{
	if dom.ByID("app").IsNull() {
		host := dom.CreateElement("div")
		host.SetAttr("id", "app")
		dom.Doc().Body().AppendChild(host)
	}
	component := NewHTMLComponent("Hooked", []byte("<root><p>hooked</p></root>"), nil)
	component.SetComponent(component)
	component.Init(nil)

	mounted := 0
	updated := 0
	unmounted := 0
	cleaned := 0
	component.DOMHook(dom.LifecycleHook{
		Mounted: func(root dom.Element) func() {
			if root.Attr("data-component-id") != component.ID {
				t.Fatalf("hook received wrong root: %q", root.Attr("data-component-id"))
			}
			mounted++
			return func() { cleaned++ }
		},
		Updated: func(dom.Element) {
			updated++
		},
		Unmounted: func(dom.Element) {
			unmounted++
		},
	})

	dom.UpdateDOM(component.ID, component.Render())
	component.Mount()
	dom.UpdateMountedDOM(component.ID, component.RenderFresh())
	component.Unmount()

	if mounted != 1 || updated != 1 || unmounted != 1 || cleaned != 1 {
		t.Fatalf("unexpected hook counts: mount=%d update=%d unmount=%d cleanup=%d", mounted, updated, unmounted, cleaned)
	}
}

func TestUnmountCleanupContinuesAfterLifecyclePanic(t *testing.T)

{
	if dom.ByID("app").IsNull() {
		host := dom.CreateElement("div")
		host.SetAttr("id", "app")
		dom.Doc().Body().AppendChild(host)
	}
	component := NewHTMLComponent("PanicCleanup", []byte("<root></root>"), nil)
	component.SetComponent(component)
	component.Init(nil)
	cleaned := false
	component.Scope().Defer(func() { cleaned = true })
	component.SetOnUnmount(func(*HTMLComponent) { panic("unmount") })
	stopErrors := OnError(func(any, string) {})
	defer stopErrors()

	dom.UpdateDOM(component.ID, component.Render())
	component.Mount()
	component.Unmount()
	if !cleaned {
		t.Fatal("scope cleanup stopped after lifecycle panic")
	}
}

func TestAddHostComponentKeepsAllNames(t *testing.T)

{
	c := NewHTMLComponent("MultiHost", []byte(`<root></root>`), nil)
	c.AddHostComponent("Counter")
	c.AddHostComponent("Clock")
	c.AddHostComponent("Counter")

	names := c.hostComponentNames()
	if len(names) != 2 || names[0] != "Counter" || names[1] != "Clock" {
		t.Fatalf("unexpected host component names: %v", names)
	}
	if c.HostComponent != "Counter" {
		t.Fatalf("primary host component overwritten: %s", c.HostComponent)
	}
}

func TestSuspenseMountState(t *testing.T)

{
	s := NewSuspense(func() (string, error) { return "ready", nil }, "loading")
	if s.IsMounted() {
		t.Fatal("new Suspense should not be mounted")
	}
	s.Mount()
	if !s.IsMounted() {
		t.Fatal("Suspense should be mounted after Mount")
	}
	s.Unmount()
	if s.IsMounted() {
		t.Fatal("Suspense should not be mounted after Unmount")
	}
}

func TestSuspenseUpdatesWhenResourceResolves(t *testing.T)

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

	release := make(chan struct{})
	resource := state.NewResource(func(context.Context) (string, error) {
		<-release
		return "ready", nil
	})
	defer resource.Close()

	suspense := NewSuspense(func() (string, error) {
		value, err := resource.Read()
		return "<p>" + value + "</p>", err
	}, "<p>loading</p>")
	dom.UpdateDOM(suspense.GetID(), suspense.Render())
	suspense.Mount()
	defer suspense.Unmount()

	if html := dom.ComponentRoot(suspense.GetID()).HTML(); !strings.Contains(html, "loading") {
		t.Fatalf("fallback missing: %s", html)
	}
	close(release)

	deadline := time.Now().Add(time.Second)
	for {
		if html := dom.ComponentRoot(suspense.GetID()).HTML(); strings.Contains(html, "ready") {
			break
		}
		if time.Now().After(deadline) {
			t.Fatalf("resolved content missing: %s", dom.ComponentRoot(suspense.GetID()).HTML())
		}
		time.Sleep(time.Millisecond)
	}
}

func TestSuspenseCoalescesReactiveDOMUpdates(t *testing.T)

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

	value := state.NewSignal("zero")
	suspense := NewSuspense(func() (string, error) {
		return "<p>" + value.Get() + "</p>", nil
	}, "<p>loading</p>")
	dom.UpdateDOM(suspense.GetID(), suspense.Render())
	suspense.Mount()
	defer suspense.Unmount()

	previousHook := dom.TemplateHook
	commits := 0
	dom.TemplateHook = func(componentID, _ string) {
		if componentID == suspense.GetID() {
			commits++
		}
	}
	defer func() { dom.TemplateHook = previousHook }()

	for i := 0; i < 10; i++ {
		value.Set(fmt.Sprintf("value-%d", i))
	}
	waitForRenderFlush()

	if commits != 1 {
		t.Fatalf("Suspense update burst produced %d DOM commits, want 1", commits)
	}
	if html := dom.ComponentRoot(suspense.GetID()).HTML(); !strings.Contains(html, "value-9") {
		t.Fatalf("Suspense committed stale content: %s", html)
	}
}

func TestRegisterPlugin_dedup(t *testing.T)

{
	app = newApp()
	p1 := &namedTestPlugin{}
	RegisterPlugin(p1)
	if p1.installed != 1 {
		t.Fatalf("expected first plugin to install once, got %d", p1.installed)
	}
	p2 := &namedTestPlugin{}
	RegisterPlugin(p2)
	if p2.installed != 0 {
		t.Fatalf("expected second plugin not to install, got %d", p2.installed)
	}
	if !app.HasPlugin("named-test") {
		t.Fatalf("expected HasPlugin to return true")
	}
}

func TestRegisterPlugin_requires(t *testing.T)

{
	app = newApp()
	dep := &depPlugin{}
	req := &requiresPlugin{dep: dep}
	RegisterPlugin(req)
	if dep.installed != 1 {
		t.Fatalf("expected dependency to install, got %d", dep.installed)
	}
	if !app.HasPlugin("dep") || !app.HasPlugin("requires") {
		t.Fatalf("expected both plugins to be registered")
	}
}

func TestRegisterPlugin_optional(t *testing.T)

{
	app = newApp()
	dep := &depPlugin{}
	opt := &optionalPlugin{dep: dep, enable: true}
	RegisterPlugin(opt)
	if dep.installed != 1 {
		t.Fatalf("expected optional dependency to install")
	}

	app = newApp()
	dep2 := &depPlugin{}
	opt2 := &optionalPlugin{dep: dep2, enable: false}
	RegisterPlugin(opt2)
	if dep2.installed != 0 {
		t.Fatalf("expected disabled optional dependency not to install")
	}
}

func OnError(fn ErrorSink) func()

{
	if fn == nil {
		return func() {}
	}
	errorMu.Lock()
	errorSinks = append(errorSinks, fn)
	idx := len(errorSinks) - 1
	errorMu.Unlock()
	return func() {
		errorMu.Lock()
		if idx < len(errorSinks) {
			errorSinks[idx] = nil
		}
		errorMu.Unlock()
	}
}

func ReportError(err any, context string)

{
	errorMu.Lock()
	sinks := make([]ErrorSink, len(errorSinks))
	copy(sinks, errorSinks)
	errorMu.Unlock()
	for _, fn := range sinks {
		if fn != nil {
			func() {
				defer func() {
					if sinkPanic := recover(); sinkPanic != nil {
						log.Printf("[rfw] error sink failed while reporting %s: %v", context, sinkPanic)
					}
				}()
				fn(err, context)
			}()
		}
	}
	func() {
		defer func() {
			if overlayPanic := recover(); overlayPanic != nil {
				log.Printf("[rfw] error overlay failed while reporting %s: %v", context, overlayPanic)
			}
		}()
		ShowErrorOverlay(err, context)
	}()
}

func init()

{
	dom.OnHandlerPanic = func(err any, name string) {
		ReportError(err, "Handler: "+name)
	}
	js.OnRuntimePanic = func(err any, context string, stack []byte) {
		ReportError(recoveredPanic{value: err, stack: stack}, context)
	}
	state.OnCallbackPanic = func(err any, context string, stack []byte) {
		ReportError(recoveredPanic{value: err, stack: stack}, context)
	}
}

func TestReportErrorFansOutToSinks(t *testing.T)

{
	var got []string
	stop := OnError(func(_ any, ctx string) {
		got = append(got, ctx)
	})
	defer stop()

	TryRender(newErrPipeComponent())
	if len(got) != 1 || !strings.HasPrefix(got[0], "Render: Boom") {
		t.Fatalf("expected render report, got %v", got)
	}

	b := NewErrorBoundary(newErrPipeComponent(), "<p>fallback</p>")
	out := b.Render()
	if !strings.Contains(out, "fallback") {
		t.Fatalf("expected fallback html, got %q", out)
	}
	if len(got) != 2 || !strings.HasPrefix(got[1], "Boundary render: Boom") {
		t.Fatalf("expected boundary report, got %v", got)
	}

	stop()
	TryRender(newErrPipeComponent())
	if len(got) != 2 {
		t.Fatalf("sink should be removed, got %v", got)
	}
}

func resolveNestedKey(m map[string]any, key string) (any, bool)

{
	parts := strings.Split(key, ".")
	val := any(m)
	for _, part := range parts {
		sub, ok := val.(map[string]any)
		if !ok {
			return nil, false
		}
		val, ok = sub[part]
		if !ok {
			return nil, false
		}
	}
	return val, true
}

func replaceForPlaceholders(template string, c *HTMLComponent) string

{
	forRegex := regexp.MustCompile(`@for:(\w+(?:,\w+)?)\s+in\s+(\S+)([\s\S]*?)@endfor`)
	// loop ids are positional, so a re-render hands every loop the id its rows
	// already carry in the DOM
	c.forSeq = 0
	return forRegex.ReplaceAllStringFunc(template, func(match string) string {
		parts := forRegex.FindStringSubmatch(match)
		if len(parts) < 4 {
			return match
		}

		varsPart := parts[1]
		expr := parts[2]
		loopContent := parts[3]

		aliases := strings.Split(varsPart, ",")
		for i := range aliases {
			aliases[i] = strings.TrimSpace(aliases[i])
		}

		loopID := fmt.Sprintf("for-%s-%d", c.ID, c.forSeq)
		c.forSeq++

		if strings.Contains(expr, "..") {
			rangeParts := strings.Split(expr, "..")
			if len(rangeParts) != 2 {
				return match
			}
			start, err := resolveNumber(rangeParts[0], c)
			if err != nil {
				return match
			}
			end, err := resolveNumber(rangeParts[1], c)
			if err != nil {
				return match
			}
			var result strings.Builder
			for i := start; i <= end; i++ {
				iter := strings.ReplaceAll(loopContent, fmt.Sprintf("@prop:%s", aliases[0]), fmt.Sprintf("%d", i))
				iter = insertDataKey(iter, i)
				result.WriteString(iter)
			}
			return result.String()
		}

		var collection any
		if strings.HasPrefix(expr, "store:") {
			storeParts := strings.Split(strings.TrimPrefix(expr, "store:"), ".")
			if len(storeParts) == 3 {
				module, storeName, key := storeParts[0], storeParts[1], storeParts[2]
				store := state.GlobalStoreManager.GetStore(module, storeName)
				if store != nil {
					collection = store.Get(key)
					// Rendering is coalesced per component; the common DOM
					// reconciler then limits mutation to changed loop rows.
					unsubscribe := store.OnChange(key, func(any) {
						if loopInHiddenConditionalBranch(c, loopID) {
							return
						}
						c.requestRender()
					})
					c.unsubscribes.Add(unsubscribe)
				} else {
					return match
				}
			} else {
				return match
			}
		} else if val, ok := c.Props[expr]; ok {
			collection = val
		} else {
			return match
		}

		switch col := collection.(type) {
		case []Component:
			tmp := make([]any, len(col))
			for i, v := range col {
				tmp[i] = v
			}
			collection = tmp
		case []*HTMLComponent:
			tmp := make([]any, len(col))
			for i, v := range col {
				tmp[i] = v
			}
			collection = tmp
		case map[string]Component:
			tmp := make(map[string]any, len(col))
			for k, v := range col {
				tmp[k] = v
			}
			collection = tmp
		case map[string]*HTMLComponent:
			tmp := make(map[string]any, len(col))
			for k, v := range col {
				tmp[k] = v
			}
			collection = tmp
		}

		rows, ok := expandForRows(c, aliases, loopContent, collection, loopID)
		if !ok {
			return match
		}
		return forAnchor(loopID) + rows
	})
}

func loopInHiddenConditionalBranch(c *HTMLComponent, loopID string) bool

{
	if c == nil || !c.mounted {
		return true
	}
	marker := fmt.Sprintf(`data-for-anchor="%s"`, loopID)
	for conditionID, content := range c.conditionContents {
		containsLoop := false
		for _, branch := range content.Branches {
			if strings.Contains(branch.Content, marker) {
				containsLoop = true
				break
			}
		}
		if !containsLoop {
			continue
		}

		root := dom.ComponentRoot(c.ID)
		if root.IsNull() || root.IsUndefined() {
			return true
		}
		condition := root.Query(fmt.Sprintf(`[data-condition="%s"]`, conditionID))
		if condition.IsNull() || condition.IsUndefined() {
			return true
		}
		selected := condition.Attr("data-condition-branch")
		for index, branch := range content.Branches {
			if fmt.Sprintf("%d", index) == selected {
				return !strings.Contains(branch.Content, marker)
			}
		}
		return true
	}
	return false
}

func insertRowMarkers(content string, key any, loopID string) string

{
	loc := reTagName.FindStringSubmatchIndex(content)
	if loc == nil {
		return content
	}
	attrs := ""
	openEnd := strings.IndexByte(content, '>')
	if openEnd < 0 || (!strings.Contains(content[:openEnd], "[key ") && !strings.Contains(content[:openEnd], "data-key=")) {
		attrs = fmt.Sprintf(` data-key="%v"`, key)
	}
	if loopID != "" {
		attrs += fmt.Sprintf(` data-for="%s"`, loopID)
	}
	return content[:loc[1]] + attrs + content[loc[1]:]
}

func expandForRows(c *HTMLComponent, aliases []string, loopContent string, collection any, loopID string) (string, bool)

{
	switch col := collection.(type) {
	case nil:
		// unset store key: no rows, and the anchor keeps the spot so the first
		// value that lands can be patched in
		return "", true
	case []any:
		var result strings.Builder
		alias := aliases[0]
		for idx, item := range col {
			iterContent := loopContent
			if comp, ok := item.(Component); ok {
				placeholder := fmt.Sprintf("for-%s-%d", alias, idx)
				c.AddDependency(placeholder, comp)
				iterContent = strings.ReplaceAll(iterContent, fmt.Sprintf("@prop:%s", alias), fmt.Sprintf("@include:%s", placeholder))
			} else if itemMap, ok := item.(map[string]any); ok {
				iterContent = substituteItemFields(iterContent, alias, itemMap)
			} else {
				iterContent = strings.ReplaceAll(iterContent, fmt.Sprintf("@prop:%s", alias), escapeValue(item))
			}
			iterContent = insertRowMarkers(iterContent, idx, loopID)
			result.WriteString(iterContent)
		}
		return result.String(), true
	case map[string]any:
		keyAlias := aliases[0]
		valAlias := keyAlias
		if len(aliases) > 1 {
			valAlias = aliases[1]
		}
		keys := make([]string, 0, len(col))
		for k := range col {
			keys = append(keys, k)
		}
		sort.Strings(keys)
		var result strings.Builder
		for idx, k := range keys {
			v := col[k]
			iterContent := strings.ReplaceAll(loopContent, fmt.Sprintf("@prop:%s", keyAlias), escapeValue(k))
			if len(aliases) > 1 {
				if vMap, ok := v.(map[string]any); ok {
					iterContent = substituteItemFields(iterContent, valAlias, vMap)
				} else if comp, ok := v.(Component); ok {
					placeholder := fmt.Sprintf("for-%s-%d", valAlias, idx)
					c.AddDependency(placeholder, comp)
					iterContent = strings.ReplaceAll(iterContent, fmt.Sprintf("@prop:%s", valAlias), fmt.Sprintf("@include:%s", placeholder))
				} else {
					iterContent = strings.ReplaceAll(iterContent, fmt.Sprintf("@rawprop:%s", valAlias), fmt.Sprintf("%v", v))
					iterContent = strings.ReplaceAll(iterContent, fmt.Sprintf("@prop:%s", valAlias), escapeValue(v))
				}
			}
			iterContent = insertRowMarkers(iterContent, k, loopID)
			result.WriteString(iterContent)
		}
		return result.String(), true
	default:
		return "", false
	}
}

func substituteItemFields(content, alias string, item map[string]any) string

{
	rawRegex := regexp.MustCompile(fmt.Sprintf(`@rawprop:%s\.(\w+(?:\.\w+)*)`, alias))
	content = rawRegex.ReplaceAllStringFunc(content, func(fieldMatch string) string {
		fieldParts := rawRegex.FindStringSubmatch(fieldMatch)
		if len(fieldParts) == 2 {
			if fieldValue, ok := resolveNestedKey(item, fieldParts[1]); ok {
				return fmt.Sprintf("%v", fieldValue)
			}
		}
		return fieldMatch
	})
	fieldRegex := regexp.MustCompile(fmt.Sprintf(`@prop:%s\.(\w+(?:\.\w+)*)`, alias))
	return fieldRegex.ReplaceAllStringFunc(content, func(fieldMatch string) string {
		fieldParts := fieldRegex.FindStringSubmatch(fieldMatch)
		if len(fieldParts) == 2 {
			if fieldValue, ok := resolveNestedKey(item, fieldParts[1]); ok {
				return escapeValue(fieldValue)
			}
		}
		return fieldMatch
	})
}

func mountForComponent(t *testing.T, name string, tpl []byte) *HTMLComponent

{
	t.Helper()
	host := dom.Doc().CreateElement("div")
	dom.Doc().Body().AppendChild(host)
	t.Cleanup(func() { host.Call("remove") })

	c := NewHTMLComponent(name, tpl, nil)
	c.SetComponent(c)
	c.Init(nil)
	dom.UpdateDOMIn(host, c.ID, c.Render())
	c.Mount()
	return c
}

func TestForPatchLeavesSiblingsAlone(t *testing.T)

{
	st := state.NewStore("forpatch", state.WithModule("app"))
	st.Set("items", []any{
		map[string]any{"label": "one"},
		map[string]any{"label": "two"},
	})
	waitForRenderFlush()

	tpl := []byte(`<root><div id="forpatch-side">side</div><ul>@for:it in store:app.forpatch.items <li>@prop:it.label</li>@endfor</ul></root>`)
	mountForComponent(t, "ForPatch", tpl)

	side := dom.ByID("forpatch-side")
	if side.IsNull() {
		t.Fatal("sibling not rendered")
	}
	side.Set("__marker", "kept")

	st.Set("items", []any{
		map[string]any{"label": "one"},
		map[string]any{"label": "two"},
		map[string]any{"label": "three"},
	})
	waitForRenderFlush()

	sideAfter := dom.ByID("forpatch-side")
	if sideAfter.IsNull() {
		t.Fatal("sibling vanished after the list changed")
	}
	if got := sideAfter.Get("__marker"); !got.Truthy() || got.String() != "kept" {
		t.Fatal("sibling was re-created: the whole component re-rendered")
	}
}

func TestForPatchRendersEveryRow(t *testing.T)

{
	st := state.NewStore("forpatch2", state.WithModule("app"))
	st.Set("items", []any{map[string]any{"label": "a"}})

	tpl := []byte(`<root><ul data-list>@for:it in store:app.forpatch2.items <li>@prop:it.label</li>@endfor</ul></root>`)
	mountForComponent(t, "ForPatch2", tpl)

	st.Set("items", []any{
		map[string]any{"label": "x"},
		map[string]any{"label": "y"},
	})
	waitForRenderFlush()

	list := dom.Query("[data-list]")
	rows := list.QueryAll("li")
	if rows.Length() != 2 {
		t.Fatalf("expected 2 rows, got %d (%s)", rows.Length(), list.HTML())
	}
	if got := rows.Index(0).Text(); got != "x" {
		t.Fatalf("first row = %q", got)
	}
	if got := rows.Index(1).Text(); got != "y" {
		t.Fatalf("second row = %q", got)
	}

	// emptying the list clears the rows and keeps the anchor for the next value
	st.Set("items", []any{})
	waitForRenderFlush()
	if n := dom.Query("[data-list]").QueryAll("li").Length(); n != 0 {
		t.Fatalf("expected no rows after clearing, got %d", n)
	}
	st.Set("items", []any{map[string]any{"label": "back"}})
	waitForRenderFlush()
	if got := dom.Query("[data-list]").QueryAll("li").Length(); got != 1 {
		t.Fatalf("expected the list to come back, got %d rows", got)
	}
}

func TestUnifiedReconcilerPreservesExplicitlyKeyedRows(t *testing.T)

{
	store := state.NewStore("reconcile_keyed", state.WithModule("app"))
	defer state.GlobalStoreManager.UnregisterStore("app", "reconcile_keyed")
	store.Set("items", []any{
		map[string]any{"id": "a", "label": "one"},
		map[string]any{"id": "b", "label": "two"},
	})

	component := mountForComponent(t, "ReconcileKeyed", []byte(`<root><ul data-list>
@for:item in store:app.reconcile_keyed.items
<li [key @prop:item.id]>@prop:item.label</li>
@endfor
</ul></root>`))
	defer component.Unmount()
	rows := dom.Query("[data-list]").QueryAll("li")
	rowA, rowB := rows.Index(0), rows.Index(1)
	if rowA.Attr("data-key") != "a" || rowB.Attr("data-key") != "b" {
		t.Fatalf("explicit row keys were not rendered: %s", dom.Query("[data-list]").HTML())
	}

	store.Set("items", []any{
		map[string]any{"id": "b", "label": "two updated"},
		map[string]any{"id": "c", "label": "three"},
	})
	waitForRenderFlush()

	rows = dom.Query("[data-list]").QueryAll("li")
	if rows.Length() != 2 || !rows.Index(0).Equal(rowB.Value) {
		t.Fatal("keyed row identity was not retained during reorder")
	}
	if rows.Index(0).Text() != "two updated" {
		t.Fatalf("retained row was not patched: %s", rows.Index(0).Text())
	}
	if rowA.Get("isConnected").Bool() {
		t.Fatal("removed keyed row remains connected")
	}
}

func TestUnifiedReconcilerKeepsFocusedInputOutsideLoop(t *testing.T)

{
	store := state.NewStore("reconcile_focus", state.WithModule("app"))
	defer state.GlobalStoreManager.UnregisterStore("app", "reconcile_focus")
	store.Set("state", "rows")
	store.Set("query", "premier ")
	store.Set("items", []any{map[string]any{"id": "a", "label": "one"}})

	component := mountForComponent(t, "ReconcileFocus", []byte(`<root>
@if:store:app.reconcile_focus.state == "rows"
<section><input id="reconcile-search" value="@store:app.reconcile_focus.query:w"><ul>
@for:item in store:app.reconcile_focus.items
<li [key @prop:item.id]>@prop:item.label</li>
@endfor
</ul></section>
@endif
</root>`))
	defer component.Unmount()
	input := dom.ByID("reconcile-search")
	input.Call("focus")
	input.Call("setSelectionRange", 4, 8)

	store.Set("state", "rows")
	store.Set("items", []any{map[string]any{"id": "a", "label": "updated"}})
	waitForRenderFlush()

	if !dom.ByID("reconcile-search").Equal(input.Value) || !dom.Doc().Get("activeElement").Equal(input.Value) {
		t.Fatal("same-branch list refresh replaced the focused input")
	}
	if input.Val() != "premier " || input.Get("selectionStart").Int() != 4 || input.Get("selectionEnd").Int() != 8 {
		t.Fatalf("focused input state changed: value=%q selection=%d:%d", input.Val(), input.Get("selectionStart").Int(), input.Get("selectionEnd").Int())
	}
}

func TestHiddenLoopWaitsForBranchMount(t *testing.T)

{
	store := state.NewStore("reconcile_hidden", state.WithModule("app"))
	defer state.GlobalStoreManager.UnregisterStore("app", "reconcile_hidden")
	store.Set("show", "no")
	store.Set("items", []any{})

	component := mountForComponent(t, "ReconcileHidden", []byte(`<root><input id="visible-control">
@if:store:app.reconcile_hidden.show == "yes"
<ul data-hidden-list>
@for:item in store:app.reconcile_hidden.items
<li [key @prop:item.id]>@prop:item.label</li>
@endfor
</ul>
@endif
</root>`))
	defer component.Unmount()
	before := component.Stats().RenderCount
	visible := dom.ByID("visible-control")

	store.Set("items", []any{map[string]any{"id": "a", "label": "latest"}})
	waitForRenderFlush()
	if component.Stats().RenderCount != before {
		t.Fatal("hidden loop scheduled a visible component render")
	}
	if !dom.ByID("visible-control").Equal(visible.Value) {
		t.Fatal("hidden loop update touched the mounted branch")
	}

	store.Set("show", "yes")
	waitForRenderFlush()
	rows := dom.Query("[data-hidden-list]").QueryAll("li")
	if rows.Length() != 1 || rows.Index(0).Text() != "latest" {
		t.Fatalf("mounted branch did not use latest loop state: %s", dom.Query("[data-hidden-list]").HTML())
	}
}

func TestForPatchRebindsInputsOnce(t *testing.T)

{
	st := state.NewStore("forpatch3", state.WithModule("app"))
	defer state.GlobalStoreManager.UnregisterStore("app", "forpatch3")
	st.Set("name", "")
	st.Set("ast", "")
	st.Set("row", "")
	st.Set("items", []any{map[string]any{"label": "one"}})

	tpl := []byte(`<root><input data-name value="@store:app.forpatch3.name:w"><input data-ast data-bind-store="app.forpatch3.ast"><ul>@for:it in store:app.forpatch3.items <li><input data-row data-bind-store="app.forpatch3.row">@prop:it.label</li>@endfor</ul></root>`)
	c := mountForComponent(t, "ForPatch3", tpl)
	defer c.Unmount()

	st.Set("items", []any{map[string]any{"label": "two"}})
	waitForRenderFlush()
	oldRow := dom.Query("[data-row]")
	st.Set("items", []any{})
	waitForRenderFlush()

	oldHook := state.StoreHook
	defer func() { state.StoreHook = oldHook }()
	sets := make(chan string, 4)
	state.StoreHook = func(module, store, key string, value any) {
		if module == "app" && store == "forpatch3" {
			sets <- key
		}
		if oldHook != nil {
			oldHook(module, store, key, value)
		}
	}

	oldRow.Set("value", "detached")
	oldRow.Call("dispatchEvent", js.CustomEvent().New("input"))
	select {
	case key := <-sets:
		t.Fatalf("detached row updated store key %q", key)
	case <-time.After(20 * time.Millisecond):
	}

	input := dom.Query("[data-name]")
	input.Set("value", "Mirko")
	input.Call("dispatchEvent", js.CustomEvent().New("input"))
	expectOneStoreSet(t, sets, "name")

	input = dom.Query("[data-ast]")
	input.Set("value", "AST")
	input.Call("dispatchEvent", js.CustomEvent().New("input"))
	expectOneStoreSet(t, sets, "ast")
}

func TestStoreInputDefersWritesDuringIMEComposition(t *testing.T)

{
	store := state.NewStore("ime_binding", state.WithModule("app"))
	defer state.GlobalStoreManager.UnregisterStore("app", "ime_binding")
	store.Set("value", "before")

	component := mountForComponent(t, "IMEBinding", []byte(`<root><input data-ime value="@store:app.ime_binding.value:w"></root>`))
	defer component.Unmount()
	input := dom.Query("[data-ime]")

	input.Set("value", "partial")
	composingOptions := js.NewDict()
	composingOptions.Set("bubbles", true)
	composingOptions.Set("isComposing", true)
	input.Call("dispatchEvent", js.Global().Get("InputEvent").New("input", composingOptions.Value))
	time.Sleep(20 * time.Millisecond)
	if got := store.Get("value"); got != "before" {
		t.Fatalf("composing input wrote store value %q, want before", got)
	}

	input.Set("value", "final")
	inputOptions := js.NewDict()
	inputOptions.Set("bubbles", true)
	input.Call("dispatchEvent", js.Global().Get("InputEvent").New("input", inputOptions.Value))
	time.Sleep(20 * time.Millisecond)
	if got := store.Get("value"); got != "final" {
		t.Fatalf("completed input wrote store value %q, want final", got)
	}
}

func expectOneStoreSet(t *testing.T, sets <-chan string, want string)

{
	t.Helper()
	select {
	case got := <-sets:
		if got != want {
			t.Fatalf("input updated store key %q, want %q", got, want)
		}
	case <-time.After(time.Second):
		t.Fatal("input did not update the store")
	}
	select {
	case got := <-sets:
		t.Fatalf("input updated store key %q more than once", got)
	case <-time.After(20 * time.Millisecond):
	}
}

func TestForPatchRebindsSignalInputsOnce(t *testing.T)

{
	st := state.NewStore("forpatch4", state.WithModule("app"))
	defer state.GlobalStoreManager.UnregisterStore("app", "forpatch4")
	st.Set("items", []any{map[string]any{"label": "one"}})
	legacy := state.NewSignal("legacy")
	ast := state.NewSignal("ast")

	host := dom.Doc().CreateElement("div")
	dom.Doc().Body().AppendChild(host)
	t.Cleanup(func() { host.Call("remove") })
	tpl := []byte(`<root><input data-legacy value="@signal:legacy:w"><span hidden>@signal:ast</span><input data-ast-signal data-bind-signal="ast"><ul>@for:it in store:app.forpatch4.items <li>@prop:it.label</li>@endfor</ul></root>`)
	c := NewHTMLComponent("ForPatch4", tpl, map[string]any{
		"legacy": legacy,
		"ast":    ast,
	})
	c.SetComponent(c)
	c.Init(nil)
	host.SetHTML(c.Render())
	c.Mount()
	defer c.Unmount()

	st.Set("items", []any{map[string]any{"label": "two"}})
	st.Set("items", []any{map[string]any{"label": "three"}})
	waitForRenderFlush()

	legacySets := make(chan string, 2)
	legacySub := legacy.OnChange(func(value string) { legacySets <- value })
	defer legacySub.Stop()
	astSets := make(chan string, 2)
	astSub := ast.OnChange(func(value string) { astSets <- value })
	defer astSub.Stop()

	input := dom.Query("[data-legacy]")
	input.Set("value", "legacy-updated")
	input.Call("dispatchEvent", js.CustomEvent().New("input"))
	expectOneSignalSet(t, legacySets, "legacy-updated")

	input = dom.Query("[data-ast-signal]")
	input.Set("value", "ast-updated")
	input.Call("dispatchEvent", js.CustomEvent().New("input"))
	expectOneSignalSet(t, astSets, "ast-updated")
}

func TestLoopInHiddenConditionalBranchIgnoresUnmountedComponent(t *testing.T)

{
	component := &HTMLComponent{
		ID: "not-mounted",
		conditionContents: map[string]ConditionContent{
			"condition": {
				Branches: []ConditionalBranchContent{{Content: `<template data-for-anchor="loop"></template>`}},
			},
		},
	}
	if !loopInHiddenConditionalBranch(component, "loop") {
		t.Fatal("unmounted component should suppress loop render work")
	}
	if !loopInHiddenConditionalBranch(nil, "loop") {
		t.Fatal("nil component should suppress loop render work")
	}

	app := dom.ByID("app")
	if !app.IsNull() && !app.IsUndefined() {
		parent := app.Get("parentNode")
		next := app.Get("nextSibling")
		app.Call("remove")
		defer func() {
			if next.Truthy() && next.Get("parentNode").Truthy() && next.Get("parentNode").Equal(parent) {
				parent.Call("insertBefore", app.Value, next)
				return
			}
			parent.Call("appendChild", app.Value)
		}()
	}
	component.mounted = true
	if !loopInHiddenConditionalBranch(component, "loop") {
		t.Fatal("component without a DOM root should suppress loop render work")
	}
}

func expectOneSignalSet(t *testing.T, sets <-chan string, want string)

{
	t.Helper()
	select {
	case got := <-sets:
		if got != want {
			t.Fatalf("signal value = %q, want %q", got, want)
		}
	case <-time.After(time.Second):
		t.Fatal("input did not update the signal")
	}
	select {
	case <-sets:
		t.Fatal("input updated the signal more than once")
	case <-time.After(20 * time.Millisecond):
	}
}

func TestPortalMountsOutsideComponentTree(t *testing.T)

{
	ensureAppRoot()
	target := dom.CreateElement("div")
	target.SetAttr("id", "portal-test-target")
	dom.Doc().Body().AppendChild(target)
	defer target.Call("remove")

	child := testHTMLComponent("PortalChild", `<root><p id="portal-content">content</p></root>`)
	portal := NewPortal("#portal-test-target", child)
	dom.UpdateDOM(portal.GetID(), portal.Render())
	portal.Mount()

	if target.Query("#portal-content").IsNull() {
		t.Fatal("portal child did not mount in target")
	}
	if !child.IsMounted() {
		t.Fatal("portal child was not mounted")
	}
	portal.Unmount()
	if !target.Query("#portal-content").IsNull() || child.IsMounted() {
		t.Fatal("portal child was not cleaned up")
	}
}

func TestKeepAlivePreservesDOMAndState(t *testing.T)

{
	app := ensureAppRoot()
	child := testHTMLComponent("CachedChild", `<root><input id="cached-input" value="initial"></root>`)
	keep := NewKeepAlive(child)
	dom.UpdateDOM(keep.GetID(), keep.Render())
	keep.Mount()

	input := dom.ByID("cached-input")
	input.SetValue("edited")
	keep.Unmount()
	app.SetHTML("<p>other route</p>")

	dom.UpdateDOM(keep.GetID(), keep.Render())
	keep.Mount()
	if value := dom.ByID("cached-input").Val(); value != "edited" {
		t.Fatalf("cached DOM state was lost: %q", value)
	}
	if !child.IsMounted() {
		t.Fatal("cached child was unmounted")
	}

	keep.Dispose()
	if child.IsMounted() || !dom.ByID("cached-input").IsNull() {
		t.Fatal("disposed cache kept the child alive")
	}
}

func TestTransitionRunsEnterAndLeavePhases(t *testing.T)

{
	ensureAppRoot()
	child := testHTMLComponent("TransitionChild", `<root><p>transition</p></root>`)
	transition := NewTransition(child, TransitionConfig{Duration: 20 * time.Millisecond})
	dom.UpdateDOM(transition.GetID(), transition.Render())
	transition.Mount()

	root := dom.ComponentRoot(transition.GetID())
	if !root.HasClass("rfw-enter-from") || !root.HasClass("rfw-enter-active") {
		t.Fatalf("enter phase classes missing: %s", root.Attr("class"))
	}
	transition.Unmount()
	if !root.HasClass("rfw-leave-from") || !root.HasClass("rfw-leave-active") {
		t.Fatalf("leave phase classes missing: %s", root.Attr("class"))
	}

	deadline := time.Now().Add(time.Second)
	for {
		html := dom.Doc().Body().HTML()
		if !child.IsMounted() && !strings.Contains(html, `data-component-id="`+transition.GetID()+`"`) {
			break
		}
		if time.Now().After(deadline) {
			t.Fatalf("transition leave did not finish: mounted=%v html=%s", child.IsMounted(), html)
		}
		time.Sleep(time.Millisecond)
	}
}

func TestTransitionCanRemountDuringLeave(t *testing.T)

{
	app := ensureAppRoot()
	child := testHTMLComponent("TransitionReturnChild", `<root><p id="transition-return">return</p></root>`)
	transition := NewTransition(child, TransitionConfig{Duration: time.Second})
	dom.UpdateDOM(transition.GetID(), transition.Render())
	transition.Mount()
	transition.Unmount()

	app.SetHTML(transition.Render())
	transition.Mount()
	if !child.IsMounted() || dom.ByID("transition-return").IsNull() {
		t.Fatal("transition did not remount during leave")
	}
	if roots := dom.QueryAll(`[data-component-id="` + transition.GetID() + `"]`); roots.Length() != 1 {
		t.Fatalf("transition left %d roots after remount", roots.Length())
	}
	transition.Dispose()
}

func TestForRendersComponentList(t *testing.T)

{
	state.NewStore("default", state.WithModule("app"))

	childTpl1 := []byte("<root><p>first</p></root>")
	childTpl2 := []byte("<root><p>second</p></root>")
	child1 := NewComponent("Child1", childTpl1, nil)
	child2 := NewComponent("Child2", childTpl2, nil)

	parentTpl := []byte("<root>@for:item in items @prop:item @endfor</root>")
	parent := NewComponent("Parent", parentTpl, map[string]any{"items": []Component{child1, child2}})

	html := parent.Render()
	if !strings.Contains(html, "first") || !strings.Contains(html, "second") {
		t.Fatalf("expected child components rendered: %s", html)
	}
}

func TestForRendersMapFields(t *testing.T)

{
	state.NewStore("default", state.WithModule("app"))

	items := []any{
		map[string]any{"name": "Mario", "age": 30},
		map[string]any{"name": "Luigi", "age": 25},
	}

	parentTpl := []byte("<root>@for:item in items <p><b>Name:</b> @prop:item.name <b>Age:</b> @prop:item.age</p> @endfor</root>")
	parent := NewComponent("Parent", parentTpl, map[string]any{"items": items})

	html := parent.Render()
	if !strings.Contains(html, "Mario") || !strings.Contains(html, "Luigi") {
		t.Fatalf("expected names rendered: %s", html)
	}
	if strings.Contains(html, "@prop:item.name") || strings.Contains(html, "@prop:item.age") {
		t.Fatalf("placeholders not replaced: %s", html)
	}
}

func TestSafeJavaScriptCallbackReportsAndRuntimeContinues(t *testing.T)

{
	contexts := []string{}
	stop := OnError(func(_ any, context string) { contexts = append(contexts, context) })
	defer stop()

	calls := 0
	callback := js.SafeFuncOf(func(js.Value, []js.Value) any {
		calls++
		if calls == 1 {
			panic("callback failure")
		}
		return calls
	})
	defer callback.Release()

	callback.Invoke()
	result := callback.Invoke()

	if calls != 2 || result.Int() != 2 {
		t.Fatalf("callback did not survive: calls=%d result=%v", calls, result)
	}
	if len(contexts) != 1 || !strings.Contains(contexts[0], "JavaScript callback") {
		t.Fatalf("unexpected recovery contexts: %v", contexts)
	}
}

func TestErrorSinkPanicDoesNotBlockOtherSinks(t *testing.T)

{
	stopBroken := OnError(func(any, string) { panic("sink failure") })
	defer stopBroken()
	called := 0
	stopHealthy := OnError(func(any, string) { called++ })
	defer stopHealthy()

	ReportError("original", "test")

	if called != 1 {
		t.Fatalf("healthy error sink calls = %d, want 1", called)
	}
}

func TestScopeCancelsAndCleansUpOnce(t *testing.T)

{
	scope := NewScope()
	var cleanups atomic.Int32
	cancelled := make(chan struct{})
	scope.Defer(func() { cleanups.Add(1) })
	scope.Go(func(ctx context.Context) {
		<-ctx.Done()
		close(cancelled)
	})

	scope.Close()
	scope.Close()

	select {
	case <-cancelled:
	case <-time.After(time.Second):
		t.Fatal("scope context was not cancelled")
	}
	if cleanups.Load() != 1 {
		t.Fatalf("cleanup count = %d", cleanups.Load())
	}
}