From a4def074174a77a10a5a35618a00b0ca7cf6d0f5 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sat, 30 Aug 2025 21:03:34 -0700
Subject: [PATCH 001/134] copy vdom to tsunami/vdom

---
 tsunami/go.mod                           |  12 +
 tsunami/go.sum                           |   6 +
 tsunami/util/compare.go                  | 166 +++++++
 tsunami/util/marshal.go                  | 121 +++++
 tsunami/vdom/cssparser/cssparser.go      | 159 ++++++
 tsunami/vdom/cssparser/cssparser_test.go |  81 ++++
 tsunami/vdom/vdom.go                     | 521 ++++++++++++++++++++
 tsunami/vdom/vdom_comp.go                |  40 ++
 tsunami/vdom/vdom_html.go                | 403 +++++++++++++++
 tsunami/vdom/vdom_root.go                | 594 +++++++++++++++++++++++
 tsunami/vdom/vdom_test.go                | 185 +++++++
 tsunami/vdom/vdom_types.go               | 316 ++++++++++++
 12 files changed, 2604 insertions(+)
 create mode 100644 tsunami/go.mod
 create mode 100644 tsunami/go.sum
 create mode 100644 tsunami/util/compare.go
 create mode 100644 tsunami/util/marshal.go
 create mode 100644 tsunami/vdom/cssparser/cssparser.go
 create mode 100644 tsunami/vdom/cssparser/cssparser_test.go
 create mode 100644 tsunami/vdom/vdom.go
 create mode 100644 tsunami/vdom/vdom_comp.go
 create mode 100644 tsunami/vdom/vdom_html.go
 create mode 100644 tsunami/vdom/vdom_root.go
 create mode 100644 tsunami/vdom/vdom_test.go
 create mode 100644 tsunami/vdom/vdom_types.go

diff --git a/tsunami/go.mod b/tsunami/go.mod
new file mode 100644
index 0000000000..1a7e3b9b91
--- /dev/null
+++ b/tsunami/go.mod
@@ -0,0 +1,12 @@
+module tsunami
+
+go 1.22.4
+
+toolchain go1.24.6
+
+require (
+	github.com/google/uuid v1.6.0
+	github.com/wavetermdev/htmltoken v0.2.0
+)
+
+require golang.org/x/net v0.27.0 // indirect
diff --git a/tsunami/go.sum b/tsunami/go.sum
new file mode 100644
index 0000000000..338224a4d8
--- /dev/null
+++ b/tsunami/go.sum
@@ -0,0 +1,6 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/wavetermdev/htmltoken v0.2.0 h1:sFVPPemlDv7/jg7n4Hx1AEF2m9MVAFjFpELWfhi/DlM=
+github.com/wavetermdev/htmltoken v0.2.0/go.mod h1:5FM0XV6zNYiNza2iaTcFGj+hnMtgqumFHO31Z8euquk=
+golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
+golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
diff --git a/tsunami/util/compare.go b/tsunami/util/compare.go
new file mode 100644
index 0000000000..41299af5e2
--- /dev/null
+++ b/tsunami/util/compare.go
@@ -0,0 +1,166 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package util
+
+import (
+	"reflect"
+	"strconv"
+)
+
+// this is a shallow equal, but with special handling for numeric types
+// it will up convert to float64 and compare
+func JsonValEqual(a, b any) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+	typeA := reflect.TypeOf(a)
+	typeB := reflect.TypeOf(b)
+	if typeA == typeB && typeA.Comparable() {
+		return a == b
+	}
+	if IsNumericType(a) && IsNumericType(b) {
+		return CompareAsFloat64(a, b)
+	}
+	if typeA != typeB {
+		return false
+	}
+	// for slices and maps, compare their pointers
+	valA := reflect.ValueOf(a)
+	valB := reflect.ValueOf(b)
+	switch valA.Kind() {
+	case reflect.Slice, reflect.Map:
+		return valA.Pointer() == valB.Pointer()
+	}
+	return false
+}
+
+// Helper to check if a value is a numeric type
+func IsNumericType(val any) bool {
+	switch val.(type) {
+	case int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64,
+		float32, float64:
+		return true
+	default:
+		return false
+	}
+}
+
+// Helper to handle numeric comparisons as float64
+func CompareAsFloat64(a, b any) bool {
+	valA, okA := ToFloat64(a)
+	valB, okB := ToFloat64(b)
+	return okA && okB && valA == valB
+}
+
+// Convert various numeric types to float64 for comparison
+func ToFloat64(val any) (float64, bool) {
+	if val == nil {
+		return 0, false
+	}
+	switch v := val.(type) {
+	case int:
+		return float64(v), true
+	case int8:
+		return float64(v), true
+	case int16:
+		return float64(v), true
+	case int32:
+		return float64(v), true
+	case int64:
+		return float64(v), true
+	case uint:
+		return float64(v), true
+	case uint8:
+		return float64(v), true
+	case uint16:
+		return float64(v), true
+	case uint32:
+		return float64(v), true
+	case uint64:
+		return float64(v), true
+	case float32:
+		return float64(v), true
+	case float64:
+		return v, true
+	default:
+		return 0, false
+	}
+}
+
+func ToInt64(val any) (int64, bool) {
+	if val == nil {
+		return 0, false
+	}
+	switch v := val.(type) {
+	case int:
+		return int64(v), true
+	case int8:
+		return int64(v), true
+	case int16:
+		return int64(v), true
+	case int32:
+		return int64(v), true
+	case int64:
+		return v, true
+	case uint:
+		return int64(v), true
+	case uint8:
+		return int64(v), true
+	case uint16:
+		return int64(v), true
+	case uint32:
+		return int64(v), true
+	case uint64:
+		return int64(v), true
+	case float32:
+		return int64(v), true
+	case float64:
+		return int64(v), true
+	default:
+		return 0, false
+	}
+}
+
+func ToInt(val any) (int, bool) {
+	i, ok := ToInt64(val)
+	if !ok {
+		return 0, false
+	}
+	return int(i), true
+}
+
+func NumToString[T any](value T) (string, bool) {
+	switch v := any(value).(type) {
+	case int:
+		return strconv.FormatInt(int64(v), 10), true
+	case int8:
+		return strconv.FormatInt(int64(v), 10), true
+	case int16:
+		return strconv.FormatInt(int64(v), 10), true
+	case int32:
+		return strconv.FormatInt(int64(v), 10), true
+	case int64:
+		return strconv.FormatInt(v, 10), true
+	case uint:
+		return strconv.FormatUint(uint64(v), 10), true
+	case uint8:
+		return strconv.FormatUint(uint64(v), 10), true
+	case uint16:
+		return strconv.FormatUint(uint64(v), 10), true
+	case uint32:
+		return strconv.FormatUint(uint64(v), 10), true
+	case uint64:
+		return strconv.FormatUint(v, 10), true
+	case float32:
+		return strconv.FormatFloat(float64(v), 'f', -1, 32), true
+	case float64:
+		return strconv.FormatFloat(v, 'f', -1, 64), true
+	default:
+		return "", false
+	}
+}
\ No newline at end of file
diff --git a/tsunami/util/marshal.go b/tsunami/util/marshal.go
new file mode 100644
index 0000000000..7ae33f42d7
--- /dev/null
+++ b/tsunami/util/marshal.go
@@ -0,0 +1,121 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package util
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+func MapToStruct(in map[string]any, out any) error {
+	// Check that out is a pointer
+	outValue := reflect.ValueOf(out)
+	if outValue.Kind() != reflect.Ptr {
+		return fmt.Errorf("out parameter must be a pointer, got %v", outValue.Kind())
+	}
+
+	// Get the struct it points to
+	elem := outValue.Elem()
+	if elem.Kind() != reflect.Struct {
+		return fmt.Errorf("out parameter must be a pointer to struct, got pointer to %v", elem.Kind())
+	}
+
+	// Get type information
+	typ := elem.Type()
+
+	// For each field in the struct
+	for i := 0; i < typ.NumField(); i++ {
+		field := typ.Field(i)
+
+		// Skip unexported fields
+		if !field.IsExported() {
+			continue
+		}
+
+		name := getJSONName(field)
+		if value, ok := in[name]; ok {
+			if err := setValue(elem.Field(i), value); err != nil {
+				return fmt.Errorf("error setting field %s: %w", name, err)
+			}
+		}
+	}
+
+	return nil
+}
+
+func StructToMap(in any) (map[string]any, error) {
+	// Get value and handle pointer
+	val := reflect.ValueOf(in)
+	if val.Kind() == reflect.Ptr {
+		val = val.Elem()
+	}
+
+	// Check that we have a struct
+	if val.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("input must be a struct or pointer to struct, got %v", val.Kind())
+	}
+
+	// Get type information
+	typ := val.Type()
+	out := make(map[string]any)
+
+	// For each field in the struct
+	for i := 0; i < typ.NumField(); i++ {
+		field := typ.Field(i)
+
+		// Skip unexported fields
+		if !field.IsExported() {
+			continue
+		}
+
+		name := getJSONName(field)
+		out[name] = val.Field(i).Interface()
+	}
+
+	return out, nil
+}
+
+// getJSONName returns the field name to use for JSON mapping
+func getJSONName(field reflect.StructField) string {
+	tag := field.Tag.Get("json")
+	if tag == "" || tag == "-" {
+		return field.Name
+	}
+	return strings.Split(tag, ",")[0]
+}
+
+// setValue attempts to set a reflect.Value with a given interface{} value
+func setValue(field reflect.Value, value any) error {
+	if value == nil {
+		return nil
+	}
+
+	valueRef := reflect.ValueOf(value)
+
+	// Direct assignment if types are exactly equal
+	if valueRef.Type() == field.Type() {
+		field.Set(valueRef)
+		return nil
+	}
+
+	// Check if types are assignable
+	if valueRef.Type().AssignableTo(field.Type()) {
+		field.Set(valueRef)
+		return nil
+	}
+
+	// If field is pointer and value isn't already a pointer, try address
+	if field.Kind() == reflect.Ptr && valueRef.Kind() != reflect.Ptr {
+		return setValue(field, valueRef.Addr().Interface())
+	}
+
+	// Try conversion if types are convertible
+	if valueRef.Type().ConvertibleTo(field.Type()) {
+		field.Set(valueRef.Convert(field.Type()))
+		return nil
+	}
+
+	return fmt.Errorf("cannot set value of type %v to field of type %v", valueRef.Type(), field.Type())
+}
\ No newline at end of file
diff --git a/tsunami/vdom/cssparser/cssparser.go b/tsunami/vdom/cssparser/cssparser.go
new file mode 100644
index 0000000000..a430624d5f
--- /dev/null
+++ b/tsunami/vdom/cssparser/cssparser.go
@@ -0,0 +1,159 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package cssparser
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+)
+
+type Parser struct {
+	Input      string
+	Pos        int
+	Length     int
+	InQuote    bool
+	QuoteChar  rune
+	OpenParens int
+	Debug      bool
+}
+
+func MakeParser(input string) *Parser {
+	return &Parser{
+		Input:  input,
+		Length: len(input),
+	}
+}
+
+func (p *Parser) Parse() (map[string]string, error) {
+	result := make(map[string]string)
+	lastProp := ""
+	for {
+		p.skipWhitespace()
+		if p.eof() {
+			break
+		}
+		propName, err := p.parseIdentifierColon(lastProp)
+		if err != nil {
+			return nil, err
+		}
+		lastProp = propName
+		p.skipWhitespace()
+		value, err := p.parseValue(propName)
+		if err != nil {
+			return nil, err
+		}
+		result[propName] = value
+		p.skipWhitespace()
+		if p.eof() {
+			break
+		}
+		if !p.expectChar(';') {
+			break
+		}
+	}
+	p.skipWhitespace()
+	if !p.eof() {
+		return nil, fmt.Errorf("bad style attribute, unexpected character %q at pos %d", string(p.Input[p.Pos]), p.Pos+1)
+	}
+	return result, nil
+}
+
+func (p *Parser) parseIdentifierColon(lastProp string) (string, error) {
+	start := p.Pos
+	for !p.eof() {
+		c := p.peekChar()
+		if isIdentChar(c) || c == '-' {
+			p.advance()
+		} else {
+			break
+		}
+	}
+	attrName := p.Input[start:p.Pos]
+	p.skipWhitespace()
+	if p.eof() {
+		return "", fmt.Errorf("bad style attribute, expected colon after property %q, got EOF, at pos %d", attrName, p.Pos+1)
+	}
+	if attrName == "" {
+		return "", fmt.Errorf("bad style attribute, invalid property name after property %q, at pos %d", lastProp, p.Pos+1)
+	}
+	if !p.expectChar(':') {
+		return "", fmt.Errorf("bad style attribute, bad property name starting with %q, expected colon, got %q, at pos %d", attrName, string(p.Input[p.Pos]), p.Pos+1)
+	}
+	return attrName, nil
+}
+
+func (p *Parser) parseValue(propName string) (string, error) {
+	start := p.Pos
+	quotePos := 0
+	parenPosStack := make([]int, 0)
+	for !p.eof() {
+		c := p.peekChar()
+		if p.InQuote {
+			if c == p.QuoteChar {
+				p.InQuote = false
+			} else if c == '\\' {
+				p.advance()
+			}
+		} else {
+			if c == '"' || c == '\'' {
+				p.InQuote = true
+				p.QuoteChar = c
+				quotePos = p.Pos
+			} else if c == '(' {
+				p.OpenParens++
+				parenPosStack = append(parenPosStack, p.Pos)
+			} else if c == ')' {
+				if p.OpenParens == 0 {
+					return "", fmt.Errorf("unmatched ')' at pos %d", p.Pos+1)
+				}
+				p.OpenParens--
+				parenPosStack = parenPosStack[:len(parenPosStack)-1]
+			} else if c == ';' && p.OpenParens == 0 {
+				break
+			}
+		}
+		p.advance()
+	}
+	if p.eof() && p.InQuote {
+		return "", fmt.Errorf("bad style attribute, while parsing attribute %q, unmatched quote at pos %d", propName, quotePos+1)
+	}
+	if p.eof() && p.OpenParens > 0 {
+		return "", fmt.Errorf("bad style attribute, while parsing property %q, unmatched '(' at pos %d", propName, parenPosStack[len(parenPosStack)-1]+1)
+	}
+	return strings.TrimSpace(p.Input[start:p.Pos]), nil
+}
+
+func isIdentChar(r rune) bool {
+	return unicode.IsLetter(r) || unicode.IsDigit(r)
+}
+
+func (p *Parser) skipWhitespace() {
+	for !p.eof() && unicode.IsSpace(p.peekChar()) {
+		p.advance()
+	}
+}
+
+func (p *Parser) expectChar(expected rune) bool {
+	if !p.eof() && p.peekChar() == expected {
+		p.advance()
+		return true
+	}
+	return false
+}
+
+func (p *Parser) peekChar() rune {
+	if p.Pos >= p.Length {
+		return 0
+	}
+	return rune(p.Input[p.Pos])
+}
+
+func (p *Parser) advance() {
+	p.Pos++
+}
+
+func (p *Parser) eof() bool {
+	return p.Pos >= p.Length
+}
\ No newline at end of file
diff --git a/tsunami/vdom/cssparser/cssparser_test.go b/tsunami/vdom/cssparser/cssparser_test.go
new file mode 100644
index 0000000000..a2ea46bd66
--- /dev/null
+++ b/tsunami/vdom/cssparser/cssparser_test.go
@@ -0,0 +1,81 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package cssparser
+
+import (
+	"fmt"
+	"log"
+	"testing"
+)
+
+func compareMaps(a, b map[string]string) error {
+	if len(a) != len(b) {
+		return fmt.Errorf("map length mismatch: %d != %d", len(a), len(b))
+	}
+	for k, v := range a {
+		if b[k] != v {
+			return fmt.Errorf("value mismatch for key %s: %q != %q", k, v, b[k])
+		}
+	}
+	return nil
+}
+
+func TestParse1(t *testing.T) {
+	style := `background: url("example;with;semicolons.jpg"); color: red; margin-right: 5px; content: "hello;world";`
+	p := MakeParser(style)
+	parsed, err := p.Parse()
+	if err != nil {
+		t.Fatalf("Parse failed: %v", err)
+		return
+	}
+	expected := map[string]string{
+		"background":   `url("example;with;semicolons.jpg")`,
+		"color":        "red",
+		"margin-right": "5px",
+		"content":      `"hello;world"`,
+	}
+	if err := compareMaps(parsed, expected); err != nil {
+		t.Fatalf("Parsed map does not match expected: %v", err)
+	}
+
+	style = `margin-right: calc(10px + 5px); color: red; font-family: "Arial";`
+	p = MakeParser(style)
+	parsed, err = p.Parse()
+	if err != nil {
+		t.Fatalf("Parse failed: %v", err)
+		return
+	}
+	expected = map[string]string{
+		"margin-right": `calc(10px + 5px)`,
+		"color":        "red",
+		"font-family":  `"Arial"`,
+	}
+	if err := compareMaps(parsed, expected); err != nil {
+		t.Fatalf("Parsed map does not match expected: %v", err)
+	}
+}
+
+func TestParserErrors(t *testing.T) {
+	style := `hello more: bad;`
+	p := MakeParser(style)
+	_, err := p.Parse()
+	if err == nil {
+		t.Fatalf("expected error, got nil")
+	}
+	log.Printf("got expected error: %v\n", err)
+	style = `background: url("example.jpg`
+	p = MakeParser(style)
+	_, err = p.Parse()
+	if err == nil {
+		t.Fatalf("expected error, got nil")
+	}
+	log.Printf("got expected error: %v\n", err)
+	style = `foo: url(...`
+	p = MakeParser(style)
+	_, err = p.Parse()
+	if err == nil {
+		t.Fatalf("expected error, got nil")
+	}
+	log.Printf("got expected error: %v\n", err)
+}
\ No newline at end of file
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
new file mode 100644
index 0000000000..f49743730b
--- /dev/null
+++ b/tsunami/vdom/vdom.go
@@ -0,0 +1,521 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package vdom
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"reflect"
+	"strconv"
+	"strings"
+	"unicode"
+
+	"tsunami/util"
+)
+
+// ReactNode types = nil | string | Elem
+
+type Component[P any] func(props P) *VDomElem
+
+type styleAttrWrapper struct {
+	StyleAttr string
+	Val       any
+}
+
+type classAttrWrapper struct {
+	ClassName string
+	Cond      bool
+}
+
+type styleAttrMapWrapper struct {
+	StyleAttrMap map[string]any
+}
+
+func (e *VDomElem) Key() string {
+	keyVal, ok := e.Props[KeyPropKey]
+	if !ok {
+		return ""
+	}
+	keyStr, ok := keyVal.(string)
+	if ok {
+		return keyStr
+	}
+	return ""
+}
+
+func (e *VDomElem) WithKey(key string) *VDomElem {
+	if e == nil {
+		return nil
+	}
+	if e.Props == nil {
+		e.Props = make(map[string]any)
+	}
+	e.Props[KeyPropKey] = key
+	return e
+}
+
+func TextElem(text string) VDomElem {
+	return VDomElem{Tag: TextTag, Text: text}
+}
+
+func mergeProps(props *map[string]any, newProps map[string]any) {
+	if *props == nil {
+		*props = make(map[string]any)
+	}
+	for k, v := range newProps {
+		if v == nil {
+			delete(*props, k)
+			continue
+		}
+		(*props)[k] = v
+	}
+}
+
+func mergeStyleAttr(props *map[string]any, styleAttr styleAttrWrapper) {
+	if *props == nil {
+		*props = make(map[string]any)
+	}
+	if (*props)["style"] == nil {
+		(*props)["style"] = make(map[string]any)
+	}
+	styleMap, ok := (*props)["style"].(map[string]any)
+	if !ok {
+		return
+	}
+	styleMap[styleAttr.StyleAttr] = styleAttr.Val
+}
+
+func mergeClassAttr(props *map[string]any, classAttr classAttrWrapper) {
+	if *props == nil {
+		*props = make(map[string]any)
+	}
+	if classAttr.Cond {
+		if (*props)["className"] == nil {
+			(*props)["className"] = classAttr.ClassName
+			return
+		}
+		classVal, ok := (*props)["className"].(string)
+		if !ok {
+			return
+		}
+		// check if class already exists (must split, contains won't work)
+		splitArr := strings.Split(classVal, " ")
+		for _, class := range splitArr {
+			if class == classAttr.ClassName {
+				return
+			}
+		}
+		(*props)["className"] = classVal + " " + classAttr.ClassName
+	} else {
+		classVal, ok := (*props)["className"].(string)
+		if !ok {
+			return
+		}
+		splitArr := strings.Split(classVal, " ")
+		for i, class := range splitArr {
+			if class == classAttr.ClassName {
+				splitArr = append(splitArr[:i], splitArr[i+1:]...)
+				break
+			}
+		}
+		if len(splitArr) == 0 {
+			delete(*props, "className")
+		} else {
+			(*props)["className"] = strings.Join(splitArr, " ")
+		}
+	}
+}
+
+func Classes(classes ...any) string {
+	var parts []string
+	for _, class := range classes {
+		switch c := class.(type) {
+		case nil:
+			continue
+		case string:
+			if c != "" {
+				parts = append(parts, c)
+			}
+		}
+		// Ignore any other types
+	}
+	return strings.Join(parts, " ")
+}
+
+func H(tag string, props map[string]any, children ...any) *VDomElem {
+	rtn := &VDomElem{Tag: tag, Props: props}
+	if len(children) > 0 {
+		for _, part := range children {
+			elems := partToElems(part)
+			rtn.Children = append(rtn.Children, elems...)
+		}
+	}
+	return rtn
+}
+
+func E(tag string, parts ...any) *VDomElem {
+	rtn := &VDomElem{Tag: tag}
+	for _, part := range parts {
+		if part == nil {
+			continue
+		}
+		props, ok := part.(map[string]any)
+		if ok {
+			mergeProps(&rtn.Props, props)
+			continue
+		}
+		if styleAttr, ok := part.(styleAttrWrapper); ok {
+			mergeStyleAttr(&rtn.Props, styleAttr)
+			continue
+		}
+		if styleAttrMap, ok := part.(styleAttrMapWrapper); ok {
+			for k, v := range styleAttrMap.StyleAttrMap {
+				mergeStyleAttr(&rtn.Props, styleAttrWrapper{StyleAttr: k, Val: v})
+			}
+			continue
+		}
+		if classAttr, ok := part.(classAttrWrapper); ok {
+			mergeClassAttr(&rtn.Props, classAttr)
+			continue
+		}
+		elems := partToElems(part)
+		rtn.Children = append(rtn.Children, elems...)
+	}
+	return rtn
+}
+
+func Class(name string) classAttrWrapper {
+	return classAttrWrapper{ClassName: name, Cond: true}
+}
+
+func ClassIf(cond bool, name string) classAttrWrapper {
+	return classAttrWrapper{ClassName: name, Cond: cond}
+}
+
+func ClassIfElse(cond bool, name string, elseName string) classAttrWrapper {
+	if cond {
+		return classAttrWrapper{ClassName: name, Cond: true}
+	}
+	return classAttrWrapper{ClassName: elseName, Cond: true}
+}
+
+func If(cond bool, part any) any {
+	if cond {
+		return part
+	}
+	return nil
+}
+
+func IfElse(cond bool, part any, elsePart any) any {
+	if cond {
+		return part
+	}
+	return elsePart
+}
+
+func ForEach[T any](items []T, fn func(T) any) []any {
+	var elems []any
+	for _, item := range items {
+		fnResult := fn(item)
+		elems = append(elems, fnResult)
+	}
+	return elems
+}
+
+func ForEachIdx[T any](items []T, fn func(T, int) any) []any {
+	var elems []any
+	for idx, item := range items {
+		fnResult := fn(item, idx)
+		elems = append(elems, fnResult)
+	}
+	return elems
+}
+
+func Filter[T any](items []T, fn func(T) bool) []T {
+	var elems []T
+	for _, item := range items {
+		if fn(item) {
+			elems = append(elems, item)
+		}
+	}
+	return elems
+}
+
+func FilterIdx[T any](items []T, fn func(T, int) bool) []T {
+	var elems []T
+	for idx, item := range items {
+		if fn(item, idx) {
+			elems = append(elems, item)
+		}
+	}
+	return elems
+}
+
+func Props(props any) map[string]any {
+	m, err := util.StructToMap(props)
+	if err != nil {
+		return nil
+	}
+	return m
+}
+
+func PStyle(styleAttr string, propVal any) any {
+	return styleAttrWrapper{StyleAttr: styleAttr, Val: propVal}
+}
+
+func Fragment(parts ...any) any {
+	return parts
+}
+
+func P(propName string, propVal any) any {
+	if propVal == nil {
+		return map[string]any{propName: nil}
+	}
+	if propName == "style" {
+		strVal, ok := propVal.(string)
+		if ok {
+			styleMap, err := styleAttrStrToStyleMap(strVal, nil)
+			if err == nil {
+				return styleAttrMapWrapper{StyleAttrMap: styleMap}
+			}
+			log.Printf("Error parsing style attribute: %v\n", err)
+			return nil
+		}
+	}
+	return map[string]any{propName: propVal}
+}
+
+func getHookFromCtx(ctx context.Context) (*VDomContextVal, *Hook) {
+	vc := getRenderContext(ctx)
+	if vc == nil {
+		panic("UseState must be called within a component (no context)")
+	}
+	if vc.Comp == nil {
+		panic("UseState must be called within a component (vc.Comp is nil)")
+	}
+	for len(vc.Comp.Hooks) <= vc.HookIdx {
+		vc.Comp.Hooks = append(vc.Comp.Hooks, &Hook{Idx: len(vc.Comp.Hooks)})
+	}
+	hookVal := vc.Comp.Hooks[vc.HookIdx]
+	vc.HookIdx++
+	return vc, hookVal
+}
+
+func UseState[T any](ctx context.Context, initialVal T) (T, func(T)) {
+	vc, hookVal := getHookFromCtx(ctx)
+	if !hookVal.Init {
+		hookVal.Init = true
+		hookVal.Val = initialVal
+	}
+	var rtnVal T
+	rtnVal, ok := hookVal.Val.(T)
+	if !ok {
+		panic("UseState hook value is not a state (possible out of order or conditional hooks)")
+	}
+	setVal := func(newVal T) {
+		hookVal.Val = newVal
+		vc.Root.AddRenderWork(vc.Comp.WaveId)
+	}
+	return rtnVal, setVal
+}
+
+func UseStateWithFn[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T)) {
+	vc, hookVal := getHookFromCtx(ctx)
+	if !hookVal.Init {
+		hookVal.Init = true
+		hookVal.Val = initialVal
+	}
+	var rtnVal T
+	rtnVal, ok := hookVal.Val.(T)
+	if !ok {
+		panic("UseState hook value is not a state (possible out of order or conditional hooks)")
+	}
+
+	setVal := func(newVal T) {
+		hookVal.Val = newVal
+		vc.Root.AddRenderWork(vc.Comp.WaveId)
+	}
+
+	setFuncVal := func(updateFunc func(T) T) {
+		hookVal.Val = updateFunc(hookVal.Val.(T))
+		vc.Root.AddRenderWork(vc.Comp.WaveId)
+	}
+
+	return rtnVal, setVal, setFuncVal
+}
+
+func UseAtom[T any](ctx context.Context, atomName string) (T, func(T)) {
+	vc, hookVal := getHookFromCtx(ctx)
+	if !hookVal.Init {
+		hookVal.Init = true
+		closedWaveId := vc.Comp.WaveId
+		hookVal.UnmountFn = func() {
+			atom := vc.Root.GetAtom(atomName)
+			delete(atom.UsedBy, closedWaveId)
+		}
+	}
+	atom := vc.Root.GetAtom(atomName)
+	atom.UsedBy[vc.Comp.WaveId] = true
+	atomVal, ok := atom.Val.(T)
+	if !ok {
+		panic(fmt.Sprintf("UseAtom %q value type mismatch (expected %T, got %T)", atomName, atomVal, atom.Val))
+	}
+	setVal := func(newVal T) {
+		atom.Val = newVal
+		for waveId := range atom.UsedBy {
+			vc.Root.AddRenderWork(waveId)
+		}
+	}
+	return atomVal, setVal
+}
+
+func UseVDomRef(ctx context.Context) *VDomRef {
+	vc, hookVal := getHookFromCtx(ctx)
+	if !hookVal.Init {
+		hookVal.Init = true
+		refId := vc.Comp.WaveId + ":" + strconv.Itoa(hookVal.Idx)
+		hookVal.Val = &VDomRef{Type: ObjectType_Ref, RefId: refId}
+	}
+	refVal, ok := hookVal.Val.(*VDomRef)
+	if !ok {
+		panic("UseRef hook value is not a ref (possible out of order or conditional hooks)")
+	}
+	return refVal
+}
+
+func UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T] {
+	_, hookVal := getHookFromCtx(ctx)
+	if !hookVal.Init {
+		hookVal.Init = true
+		hookVal.Val = &VDomSimpleRef[T]{Current: val}
+	}
+	refVal, ok := hookVal.Val.(*VDomSimpleRef[T])
+	if !ok {
+		panic("UseRef hook value is not a ref (possible out of order or conditional hooks)")
+	}
+	return refVal
+}
+
+func UseId(ctx context.Context) string {
+	vc := getRenderContext(ctx)
+	if vc == nil {
+		panic("UseId must be called within a component (no context)")
+	}
+	return vc.Comp.WaveId
+}
+
+func UseRenderTs(ctx context.Context) int64 {
+	vc := getRenderContext(ctx)
+	if vc == nil {
+		panic("UseRenderTs must be called within a component (no context)")
+	}
+	return vc.Root.RenderTs
+}
+
+func QueueRefOp(ctx context.Context, ref *VDomRef, op VDomRefOperation) {
+	if ref == nil || !ref.HasCurrent {
+		return
+	}
+	vc := getRenderContext(ctx)
+	if vc == nil {
+		panic("QueueRefOp must be called within a component (no context)")
+	}
+	if op.RefId == "" {
+		op.RefId = ref.RefId
+	}
+	vc.Root.QueueRefOp(op)
+}
+
+func depsEqual(deps1 []any, deps2 []any) bool {
+	if len(deps1) != len(deps2) {
+		return false
+	}
+	for i := range deps1 {
+		if deps1[i] != deps2[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func UseEffect(ctx context.Context, fn func() func(), deps []any) {
+	// note UseEffect never actually runs anything, it just queues the effect to run later
+	vc, hookVal := getHookFromCtx(ctx)
+	if !hookVal.Init {
+		hookVal.Init = true
+		hookVal.Fn = fn
+		hookVal.Deps = deps
+		vc.Root.AddEffectWork(vc.Comp.WaveId, hookVal.Idx)
+		return
+	}
+	if depsEqual(hookVal.Deps, deps) {
+		return
+	}
+	hookVal.Fn = fn
+	hookVal.Deps = deps
+	vc.Root.AddEffectWork(vc.Comp.WaveId, hookVal.Idx)
+}
+
+
+func partToElems(part any) []VDomElem {
+	if part == nil {
+		return nil
+	}
+	switch partTyped := part.(type) {
+	case string:
+		return []VDomElem{TextElem(partTyped)}
+	case VDomElem:
+		return []VDomElem{partTyped}
+	case *VDomElem:
+		if partTyped == nil {
+			return nil
+		}
+		return []VDomElem{*partTyped}
+	case []VDomElem:
+		return partTyped
+	case []*VDomElem:
+		var rtn []VDomElem
+		for _, elem := range partTyped {
+			if elem != nil {
+				rtn = append(rtn, *elem)
+			}
+		}
+		return rtn
+	case []any:
+		var rtn []VDomElem
+		for _, subPart := range partTyped {
+			rtn = append(rtn, partToElems(subPart)...)
+		}
+		return rtn
+	default:
+		partVal := reflect.ValueOf(part)
+		if partVal.Kind() == reflect.Slice {
+			var rtn []VDomElem
+			for i := 0; i < partVal.Len(); i++ {
+				rtn = append(rtn, partToElems(partVal.Index(i).Interface())...)
+			}
+			return rtn
+		}
+		strVal, ok := util.NumToString(part)
+		if ok {
+			return []VDomElem{TextElem(strVal)}
+		}
+		return nil
+	}
+}
+
+func isBaseTag(tag string) bool {
+	if tag == "" {
+		return false
+	}
+	if tag == TextTag || tag == WaveTextTag || tag == WaveNullTag || tag == FragmentTag {
+		return true
+	}
+	if tag[0] == '#' {
+		return true
+	}
+	firstChar := rune(tag[0])
+	return unicode.IsLower(firstChar)
+}
diff --git a/tsunami/vdom/vdom_comp.go b/tsunami/vdom/vdom_comp.go
new file mode 100644
index 0000000000..37b973951f
--- /dev/null
+++ b/tsunami/vdom/vdom_comp.go
@@ -0,0 +1,40 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package vdom
+
+// so components either render to another component (or fragment)
+// or to a base element (text or vdom).  base elements can then render children
+
+type ChildKey struct {
+	Tag string
+	Idx int
+	Key string
+}
+
+type ComponentImpl struct {
+	WaveId  string
+	Tag     string
+	Key     string
+	Elem    *VDomElem
+	Mounted bool
+
+	// hooks
+	Hooks []*Hook
+
+	// #text component
+	Text string
+
+	// base component -- vdom, wave elem, or #fragment
+	Children []*ComponentImpl
+
+	// component -> component
+	Comp *ComponentImpl
+}
+
+func (c *ComponentImpl) compMatch(tag string, key string) bool {
+	if c == nil {
+		return false
+	}
+	return c.Tag == tag && c.Key == key
+}
\ No newline at end of file
diff --git a/tsunami/vdom/vdom_html.go b/tsunami/vdom/vdom_html.go
new file mode 100644
index 0000000000..fa7ec8a27c
--- /dev/null
+++ b/tsunami/vdom/vdom_html.go
@@ -0,0 +1,403 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package vdom
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+
+	"tsunami/vdom/cssparser"
+
+	"github.com/wavetermdev/htmltoken"
+)
+
+// can tokenize and bind HTML to Elems
+
+const Html_BindPrefix = "#bind:"
+const Html_ParamPrefix = "#param:"
+const Html_GlobalEventPrefix = "#globalevent"
+const Html_BindParamTagName = "bindparam"
+const Html_BindTagName = "bind"
+
+func appendChildToStack(stack []*VDomElem, child *VDomElem) {
+	if child == nil {
+		return
+	}
+	if len(stack) == 0 {
+		return
+	}
+	parent := stack[len(stack)-1]
+	parent.Children = append(parent.Children, *child)
+}
+
+func pushElemStack(stack []*VDomElem, elem *VDomElem) []*VDomElem {
+	if elem == nil {
+		return stack
+	}
+	return append(stack, elem)
+}
+
+func popElemStack(stack []*VDomElem) []*VDomElem {
+	if len(stack) <= 1 {
+		return stack
+	}
+	curElem := stack[len(stack)-1]
+	appendChildToStack(stack[:len(stack)-1], curElem)
+	return stack[:len(stack)-1]
+}
+
+func curElemTag(stack []*VDomElem) string {
+	if len(stack) == 0 {
+		return ""
+	}
+	return stack[len(stack)-1].Tag
+}
+
+func finalizeStack(stack []*VDomElem) *VDomElem {
+	if len(stack) == 0 {
+		return nil
+	}
+	for len(stack) > 1 {
+		stack = popElemStack(stack)
+	}
+	rtnElem := stack[0]
+	if len(rtnElem.Children) == 0 {
+		return nil
+	}
+	if len(rtnElem.Children) == 1 {
+		return &rtnElem.Children[0]
+	}
+	return rtnElem
+}
+
+// returns value, isjson
+func getAttrString(token htmltoken.Token, key string) string {
+	for _, attr := range token.Attr {
+		if attr.Key == key {
+			return attr.Val
+		}
+	}
+	return ""
+}
+
+func attrToProp(attrVal string, isJson bool, params map[string]any) any {
+	if isJson {
+		var val any
+		err := json.Unmarshal([]byte(attrVal), &val)
+		if err != nil {
+			return nil
+		}
+		unmStrVal, ok := val.(string)
+		if !ok {
+			return val
+		}
+		attrVal = unmStrVal
+		// fallthrough using the json str val
+	}
+	if strings.HasPrefix(attrVal, Html_ParamPrefix) {
+		bindKey := attrVal[len(Html_ParamPrefix):]
+		bindVal, ok := params[bindKey]
+		if !ok {
+			return nil
+		}
+		return bindVal
+	}
+	if strings.HasPrefix(attrVal, Html_BindPrefix) {
+		bindKey := attrVal[len(Html_BindPrefix):]
+		if bindKey == "" {
+			return nil
+		}
+		return &VDomBinding{Type: ObjectType_Binding, Bind: bindKey}
+	}
+	if strings.HasPrefix(attrVal, Html_GlobalEventPrefix) {
+		splitArr := strings.Split(attrVal, ":")
+		if len(splitArr) < 2 {
+			return nil
+		}
+		eventName := splitArr[1]
+		if eventName == "" {
+			return nil
+		}
+		return &VDomFunc{Type: ObjectType_Func, GlobalEvent: eventName}
+	}
+	return attrVal
+}
+
+func tokenToElem(token htmltoken.Token, params map[string]any) *VDomElem {
+	elem := &VDomElem{Tag: token.Data}
+	if len(token.Attr) > 0 {
+		elem.Props = make(map[string]any)
+	}
+	for _, attr := range token.Attr {
+		if attr.Key == "" || attr.Val == "" {
+			continue
+		}
+		propVal := attrToProp(attr.Val, attr.IsJson, params)
+		elem.Props[attr.Key] = propVal
+	}
+	return elem
+}
+
+func isWsChar(char rune) bool {
+	return char == ' ' || char == '\t' || char == '\n' || char == '\r'
+}
+
+func isWsByte(char byte) bool {
+	return char == ' ' || char == '\t' || char == '\n' || char == '\r'
+}
+
+func isFirstCharLt(s string) bool {
+	for _, char := range s {
+		if isWsChar(char) {
+			continue
+		}
+		return char == '<'
+	}
+	return false
+}
+
+func isLastCharGt(s string) bool {
+	for i := len(s) - 1; i >= 0; i-- {
+		char := s[i]
+		if isWsByte(char) {
+			continue
+		}
+		return char == '>'
+	}
+	return false
+}
+
+func isAllWhitespace(s string) bool {
+	for _, char := range s {
+		if !isWsChar(char) {
+			return false
+		}
+	}
+	return true
+}
+
+func trimWhitespaceConditionally(s string) string {
+	// Trim leading whitespace if the first non-whitespace character is '<'
+	if isAllWhitespace(s) {
+		return ""
+	}
+	if isFirstCharLt(s) {
+		s = strings.TrimLeftFunc(s, func(r rune) bool {
+			return isWsChar(r)
+		})
+	}
+	// Trim trailing whitespace if the last non-whitespace character is '>'
+	if isLastCharGt(s) {
+		s = strings.TrimRightFunc(s, func(r rune) bool {
+			return isWsChar(r)
+		})
+	}
+	return s
+}
+
+func processWhitespace(htmlStr string) string {
+	lines := strings.Split(htmlStr, "\n")
+	var newLines []string
+	for _, line := range lines {
+		trimmedLine := trimWhitespaceConditionally(line + "\n")
+		if trimmedLine == "" {
+			continue
+		}
+		newLines = append(newLines, trimmedLine)
+	}
+	return strings.Join(newLines, "")
+}
+
+func processTextStr(s string) string {
+	if s == "" {
+		return ""
+	}
+	if isAllWhitespace(s) {
+		return " "
+	}
+	return strings.TrimSpace(s)
+}
+
+func makePathStr(elemPath []string) string {
+	return strings.Join(elemPath, " ")
+}
+
+func capitalizeAscii(s string) string {
+	if s == "" || s[0] < 'a' || s[0] > 'z' {
+		return s
+	}
+	return strings.ToUpper(s[:1]) + s[1:]
+}
+
+func toReactName(input string) string {
+	// Check for CSS custom properties (variables) which start with '--'
+	if strings.HasPrefix(input, "--") {
+		return input
+	}
+	parts := strings.Split(input, "-")
+	result := ""
+	index := 0
+	if parts[0] == "" && len(parts) > 1 {
+		// handle vendor prefixes
+		prefix := parts[1]
+		if prefix == "ms" {
+			result += "ms"
+		} else {
+			result += capitalizeAscii(prefix)
+		}
+		index = 2 // Skip the empty string and prefix
+	} else {
+		result += parts[0]
+		index = 1
+	}
+	// Convert remaining parts to CamelCase
+	for ; index < len(parts); index++ {
+		if parts[index] != "" {
+			result += capitalizeAscii(parts[index])
+		}
+	}
+	return result
+}
+
+func convertStyleToReactStyles(styleMap map[string]string, params map[string]any) map[string]any {
+	if len(styleMap) == 0 {
+		return nil
+	}
+	rtn := make(map[string]any)
+	for key, val := range styleMap {
+		rtn[toReactName(key)] = attrToProp(val, false, params)
+	}
+	return rtn
+}
+
+func styleAttrStrToStyleMap(styleText string, params map[string]any) (map[string]any, error) {
+	parser := cssparser.MakeParser(styleText)
+	m, err := parser.Parse()
+	if err != nil {
+		return nil, err
+	}
+	return convertStyleToReactStyles(m, params), nil
+}
+
+func fixStyleAttribute(elem *VDomElem, params map[string]any, elemPath []string) error {
+	styleText, ok := elem.Props["style"].(string)
+	if !ok {
+		return nil
+	}
+	styleMap, err := styleAttrStrToStyleMap(styleText, params)
+	if err != nil {
+		return fmt.Errorf("%v (at %s)", err, makePathStr(elemPath))
+	}
+	elem.Props["style"] = styleMap
+	return nil
+}
+
+func fixupStyleAttributes(elem *VDomElem, params map[string]any, elemPath []string) {
+	if elem == nil {
+		return
+	}
+	// call fixStyleAttribute, and walk children
+	elemCountMap := make(map[string]int)
+	if len(elemPath) == 0 {
+		elemPath = append(elemPath, elem.Tag)
+	}
+	fixStyleAttribute(elem, params, elemPath)
+	for i := range elem.Children {
+		child := &elem.Children[i]
+		elemCountMap[child.Tag]++
+		subPath := child.Tag
+		if elemCountMap[child.Tag] > 1 {
+			subPath = fmt.Sprintf("%s[%d]", child.Tag, elemCountMap[child.Tag])
+		}
+		elemPath = append(elemPath, subPath)
+		fixupStyleAttributes(&elem.Children[i], params, elemPath)
+		elemPath = elemPath[:len(elemPath)-1]
+	}
+}
+
+func Bind(htmlStr string, params map[string]any) *VDomElem {
+	htmlStr = processWhitespace(htmlStr)
+	r := strings.NewReader(htmlStr)
+	iter := htmltoken.NewTokenizer(r)
+	var elemStack []*VDomElem
+	elemStack = append(elemStack, &VDomElem{Tag: FragmentTag})
+	var tokenErr error
+outer:
+	for {
+		tokenType := iter.Next()
+		token := iter.Token()
+		switch tokenType {
+		case htmltoken.StartTagToken:
+			if token.Data == Html_BindTagName || token.Data == Html_BindParamTagName {
+				tokenErr = errors.New("bind tags must be self closing")
+				break outer
+			}
+			elem := tokenToElem(token, params)
+			elemStack = pushElemStack(elemStack, elem)
+		case htmltoken.EndTagToken:
+			if token.Data == Html_BindTagName || token.Data == Html_BindParamTagName {
+				tokenErr = errors.New("bind tags must be self closing")
+				break outer
+			}
+			if len(elemStack) <= 1 {
+				tokenErr = fmt.Errorf("end tag %q without start tag", token.Data)
+				break outer
+			}
+			if curElemTag(elemStack) != token.Data {
+				tokenErr = fmt.Errorf("end tag %q does not match start tag %q", token.Data, curElemTag(elemStack))
+				break outer
+			}
+			elemStack = popElemStack(elemStack)
+		case htmltoken.SelfClosingTagToken:
+			if token.Data == Html_BindParamTagName {
+				keyAttr := getAttrString(token, "key")
+				dataVal := params[keyAttr]
+				elemList := partToElems(dataVal)
+				for _, elem := range elemList {
+					appendChildToStack(elemStack, &elem)
+				}
+				continue
+			}
+			if token.Data == Html_BindTagName {
+				keyAttr := getAttrString(token, "key")
+				binding := &VDomBinding{Type: ObjectType_Binding, Bind: keyAttr}
+				appendChildToStack(elemStack, &VDomElem{Tag: WaveTextTag, Props: map[string]any{"text": binding}})
+				continue
+			}
+			elem := tokenToElem(token, params)
+			appendChildToStack(elemStack, elem)
+		case htmltoken.TextToken:
+			if token.Data == "" {
+				continue
+			}
+			textStr := processTextStr(token.Data)
+			if textStr == "" {
+				continue
+			}
+			elem := TextElem(textStr)
+			appendChildToStack(elemStack, &elem)
+		case htmltoken.CommentToken:
+			continue
+		case htmltoken.DoctypeToken:
+			tokenErr = errors.New("doctype not supported")
+			break outer
+		case htmltoken.ErrorToken:
+			if iter.Err() == io.EOF {
+				break outer
+			}
+			tokenErr = iter.Err()
+			break outer
+		}
+	}
+	if tokenErr != nil {
+		errTextElem := TextElem(tokenErr.Error())
+		appendChildToStack(elemStack, &errTextElem)
+	}
+	rtn := finalizeStack(elemStack)
+	fixupStyleAttributes(rtn, params, nil)
+	return rtn
+}
diff --git a/tsunami/vdom/vdom_root.go b/tsunami/vdom/vdom_root.go
new file mode 100644
index 0000000000..e7b5b3b984
--- /dev/null
+++ b/tsunami/vdom/vdom_root.go
@@ -0,0 +1,594 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package vdom
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/google/uuid"
+	"tsunami/util"
+)
+
+const (
+	BackendUpdate_InitialChunkSize = 50  // Size for initial chunks that contain both TransferElems and StateSync
+	BackendUpdate_ChunkSize        = 100 // Size for subsequent chunks
+)
+
+func (r *RootElem) AddRenderWork(id string) {
+	if r.NeedsRenderMap == nil {
+		r.NeedsRenderMap = make(map[string]bool)
+	}
+	r.NeedsRenderMap[id] = true
+}
+
+func (r *RootElem) AddEffectWork(id string, effectIndex int) {
+	r.EffectWorkQueue = append(r.EffectWorkQueue, &EffectWorkElem{Id: id, EffectIndex: effectIndex})
+}
+
+func MakeRoot() *RootElem {
+	return &RootElem{
+		Root:    nil,
+		CFuncs:  make(map[string]any),
+		CompMap: make(map[string]*ComponentImpl),
+		Atoms:   make(map[string]*Atom),
+	}
+}
+
+func (r *RootElem) GetAtom(name string) *Atom {
+	atom, ok := r.Atoms[name]
+	if !ok {
+		atom = &Atom{UsedBy: make(map[string]bool)}
+		r.Atoms[name] = atom
+	}
+	return atom
+}
+
+func (r *RootElem) GetAtomVal(name string) any {
+	atom := r.GetAtom(name)
+	return atom.Val
+}
+
+func (r *RootElem) GetStateSync(full bool) []VDomStateSync {
+	stateSync := make([]VDomStateSync, 0)
+	for atomName, atom := range r.Atoms {
+		if atom.Dirty || full {
+			stateSync = append(stateSync, VDomStateSync{Atom: atomName, Value: atom.Val})
+			atom.Dirty = false
+		}
+	}
+	return stateSync
+}
+
+func (r *RootElem) SetAtomVal(name string, val any, markDirty bool) {
+	atom := r.GetAtom(name)
+	if !markDirty {
+		atom.Val = val
+		return
+	}
+	// try to avoid setting the value and marking as dirty if it's the "same"
+	if util.JsonValEqual(val, atom.Val) {
+		return
+	}
+	atom.Val = val
+	atom.Dirty = true
+}
+
+func (r *RootElem) SetOuterCtx(ctx context.Context) {
+	r.OuterCtx = ctx
+}
+
+func validateCFunc(cfunc any) error {
+	if cfunc == nil {
+		return fmt.Errorf("Component function cannot b nil")
+	}
+	rval := reflect.ValueOf(cfunc)
+	if rval.Kind() != reflect.Func {
+		return fmt.Errorf("Component function must be a function")
+	}
+	rtype := rval.Type()
+	if rtype.NumIn() != 2 {
+		return fmt.Errorf("Component function must take exactly 2 arguments")
+	}
+	if rtype.NumOut() != 1 {
+		return fmt.Errorf("Component function must return exactly 1 value")
+	}
+	// first arg must be context.Context
+	if rtype.In(0) != reflect.TypeOf((*context.Context)(nil)).Elem() {
+		return fmt.Errorf("Component function first argument must be context.Context")
+	}
+	// second can a map[string]any, or a struct, or ptr to struct (we'll reflect the value into it)
+	arg2Type := rtype.In(1)
+	if arg2Type.Kind() == reflect.Ptr {
+		arg2Type = arg2Type.Elem()
+	}
+	if arg2Type.Kind() == reflect.Map {
+		if arg2Type.Key().Kind() != reflect.String ||
+			!(arg2Type.Elem().Kind() == reflect.Interface && arg2Type.Elem().NumMethod() == 0) {
+			return fmt.Errorf("Map argument must be map[string]any")
+		}
+	} else if arg2Type.Kind() != reflect.Struct &&
+		!(arg2Type.Kind() == reflect.Interface && arg2Type.NumMethod() == 0) {
+		return fmt.Errorf("Component function second argument must be map[string]any, struct, or any")
+	}
+	return nil
+}
+
+func (r *RootElem) RegisterComponent(name string, cfunc any) error {
+	if err := validateCFunc(cfunc); err != nil {
+		return err
+	}
+	r.CFuncs[name] = cfunc
+	return nil
+}
+
+func (r *RootElem) Render(elem *VDomElem) {
+	r.render(elem, &r.Root)
+}
+
+func (vdf *VDomFunc) CallFn(event VDomEvent) {
+	if vdf.Fn == nil {
+		return
+	}
+	rval := reflect.ValueOf(vdf.Fn)
+	if rval.Kind() != reflect.Func {
+		return
+	}
+	rtype := rval.Type()
+	if rtype.NumIn() == 0 {
+		rval.Call(nil)
+	}
+	if rtype.NumIn() == 1 {
+		if rtype.In(0) == reflect.TypeOf((*VDomEvent)(nil)).Elem() {
+			rval.Call([]reflect.Value{reflect.ValueOf(event)})
+		}
+	}
+}
+
+func callVDomFn(fnVal any, data VDomEvent) {
+	if fnVal == nil {
+		return
+	}
+	fn := fnVal
+	if vdf, ok := fnVal.(*VDomFunc); ok {
+		fn = vdf.Fn
+	}
+	if fn == nil {
+		return
+	}
+	rval := reflect.ValueOf(fn)
+	if rval.Kind() != reflect.Func {
+		return
+	}
+	rtype := rval.Type()
+	if rtype.NumIn() == 0 {
+		rval.Call(nil)
+		return
+	}
+	if rtype.NumIn() == 1 {
+		rval.Call([]reflect.Value{reflect.ValueOf(data)})
+		return
+	}
+}
+
+func (r *RootElem) Event(id string, propName string, event VDomEvent) {
+	comp := r.CompMap[id]
+	if comp == nil || comp.Elem == nil {
+		return
+	}
+	fnVal := comp.Elem.Props[propName]
+	callVDomFn(fnVal, event)
+}
+
+// this will be called by the frontend to say the DOM has been mounted
+// it will eventually send any updated "refs" to the backend as well
+func (r *RootElem) RunWork() {
+	workQueue := r.EffectWorkQueue
+	r.EffectWorkQueue = nil
+	// first, run effect cleanups
+	for _, work := range workQueue {
+		comp := r.CompMap[work.Id]
+		if comp == nil {
+			continue
+		}
+		hook := comp.Hooks[work.EffectIndex]
+		if hook.UnmountFn != nil {
+			hook.UnmountFn()
+		}
+	}
+	// now run, new effects
+	for _, work := range workQueue {
+		comp := r.CompMap[work.Id]
+		if comp == nil {
+			continue
+		}
+		hook := comp.Hooks[work.EffectIndex]
+		if hook.Fn != nil {
+			hook.UnmountFn = hook.Fn()
+		}
+	}
+	// now check if we need a render
+	if len(r.NeedsRenderMap) > 0 {
+		r.NeedsRenderMap = nil
+		r.render(r.Root.Elem, &r.Root)
+	}
+}
+
+func (r *RootElem) render(elem *VDomElem, comp **ComponentImpl) {
+	if elem == nil || elem.Tag == "" {
+		r.unmount(comp)
+		return
+	}
+	elemKey := elem.Key()
+	if *comp == nil || !(*comp).compMatch(elem.Tag, elemKey) {
+		r.unmount(comp)
+		r.createComp(elem.Tag, elemKey, comp)
+	}
+	(*comp).Elem = elem
+	if elem.Tag == TextTag {
+		r.renderText(elem.Text, comp)
+		return
+	}
+	if isBaseTag(elem.Tag) {
+		// simple vdom, fragment, wave element
+		r.renderSimple(elem, comp)
+		return
+	}
+	cfunc := r.CFuncs[elem.Tag]
+	if cfunc == nil {
+		text := fmt.Sprintf("<%s>", elem.Tag)
+		r.renderText(text, comp)
+		return
+	}
+	r.renderComponent(cfunc, elem, comp)
+}
+
+func (r *RootElem) unmount(comp **ComponentImpl) {
+	if *comp == nil {
+		return
+	}
+	// parent clean up happens first
+	for _, hook := range (*comp).Hooks {
+		if hook.UnmountFn != nil {
+			hook.UnmountFn()
+		}
+	}
+	// clean up any children
+	if (*comp).Comp != nil {
+		r.unmount(&(*comp).Comp)
+	}
+	if (*comp).Children != nil {
+		for _, child := range (*comp).Children {
+			r.unmount(&child)
+		}
+	}
+	delete(r.CompMap, (*comp).WaveId)
+	*comp = nil
+}
+
+func (r *RootElem) createComp(tag string, key string, comp **ComponentImpl) {
+	*comp = &ComponentImpl{WaveId: uuid.New().String(), Tag: tag, Key: key}
+	r.CompMap[(*comp).WaveId] = *comp
+}
+
+func (r *RootElem) renderText(text string, comp **ComponentImpl) {
+	if (*comp).Text != text {
+		(*comp).Text = text
+	}
+}
+
+func (r *RootElem) renderChildren(elems []VDomElem, curChildren []*ComponentImpl) []*ComponentImpl {
+	newChildren := make([]*ComponentImpl, len(elems))
+	curCM := make(map[ChildKey]*ComponentImpl)
+	usedMap := make(map[*ComponentImpl]bool)
+	for idx, child := range curChildren {
+		if child.Key != "" {
+			curCM[ChildKey{Tag: child.Tag, Idx: 0, Key: child.Key}] = child
+		} else {
+			curCM[ChildKey{Tag: child.Tag, Idx: idx, Key: ""}] = child
+		}
+	}
+	for idx, elem := range elems {
+		elemKey := elem.Key()
+		var curChild *ComponentImpl
+		if elemKey != "" {
+			curChild = curCM[ChildKey{Tag: elem.Tag, Idx: 0, Key: elemKey}]
+		} else {
+			curChild = curCM[ChildKey{Tag: elem.Tag, Idx: idx, Key: ""}]
+		}
+		usedMap[curChild] = true
+		newChildren[idx] = curChild
+		r.render(&elem, &newChildren[idx])
+	}
+	for _, child := range curChildren {
+		if !usedMap[child] {
+			r.unmount(&child)
+		}
+	}
+	return newChildren
+}
+
+func (r *RootElem) renderSimple(elem *VDomElem, comp **ComponentImpl) {
+	if (*comp).Comp != nil {
+		r.unmount(&(*comp).Comp)
+	}
+	(*comp).Children = r.renderChildren(elem.Children, (*comp).Children)
+}
+
+func (r *RootElem) makeRenderContext(comp *ComponentImpl) context.Context {
+	var ctx context.Context
+	if r.OuterCtx != nil {
+		ctx = r.OuterCtx
+	} else {
+		ctx = context.Background()
+	}
+	ctx = context.WithValue(ctx, vdomContextKey, &VDomContextVal{Root: r, Comp: comp, HookIdx: 0})
+	return ctx
+}
+
+func getRenderContext(ctx context.Context) *VDomContextVal {
+	v := ctx.Value(vdomContextKey)
+	if v == nil {
+		return nil
+	}
+	return v.(*VDomContextVal)
+}
+
+func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
+	rval := reflect.ValueOf(cfunc)
+	arg2Type := rval.Type().In(1)
+
+	var arg2Val reflect.Value
+	if arg2Type.Kind() == reflect.Interface && arg2Type.NumMethod() == 0 {
+		// For any/interface{}, pass nil properly
+		arg2Val = reflect.New(arg2Type)
+	} else {
+		arg2Val = reflect.New(arg2Type)
+		// if arg2 is a map, just pass props
+		if arg2Type.Kind() == reflect.Map {
+			arg2Val.Elem().Set(reflect.ValueOf(props))
+		} else {
+			err := util.MapToStruct(props, arg2Val.Interface())
+			if err != nil {
+				fmt.Printf("error unmarshalling props: %v\n", err)
+			}
+		}
+	}
+	rtnVal := rval.Call([]reflect.Value{reflect.ValueOf(ctx), arg2Val.Elem()})
+	if len(rtnVal) == 0 {
+		return nil
+	}
+	return rtnVal[0].Interface()
+}
+
+func (r *RootElem) renderComponent(cfunc any, elem *VDomElem, comp **ComponentImpl) {
+	if (*comp).Children != nil {
+		for _, child := range (*comp).Children {
+			r.unmount(&child)
+		}
+		(*comp).Children = nil
+	}
+	props := make(map[string]any)
+	for k, v := range elem.Props {
+		props[k] = v
+	}
+	props[ChildrenPropKey] = elem.Children
+	ctx := r.makeRenderContext(*comp)
+	renderedElem := callCFunc(cfunc, ctx, props)
+	rtnElemArr := partToElems(renderedElem)
+	if len(rtnElemArr) == 0 {
+		r.unmount(&(*comp).Comp)
+		return
+	}
+	var rtnElem *VDomElem
+	if len(rtnElemArr) == 1 {
+		rtnElem = &rtnElemArr[0]
+	} else {
+		rtnElem = &VDomElem{Tag: FragmentTag, Children: rtnElemArr}
+	}
+	r.render(rtnElem, &(*comp).Comp)
+}
+
+func (r *RootElem) UpdateRef(updateRef VDomRefUpdate) {
+	refId := updateRef.RefId
+	split := strings.SplitN(refId, ":", 2)
+	if len(split) != 2 {
+		log.Printf("invalid ref id: %s\n", refId)
+		return
+	}
+	waveId := split[0]
+	hookIdx, err := strconv.Atoi(split[1])
+	if err != nil {
+		log.Printf("invalid ref id (bad hook idx): %s\n", refId)
+		return
+	}
+	comp := r.CompMap[waveId]
+	if comp == nil {
+		return
+	}
+	if hookIdx < 0 || hookIdx >= len(comp.Hooks) {
+		return
+	}
+	hook := comp.Hooks[hookIdx]
+	if hook == nil {
+		return
+	}
+	ref, ok := hook.Val.(*VDomRef)
+	if !ok {
+		return
+	}
+	ref.HasCurrent = updateRef.HasCurrent
+	ref.Position = updateRef.Position
+	r.AddRenderWork(waveId)
+}
+
+func (r *RootElem) QueueRefOp(op VDomRefOperation) {
+	r.RefOperations = append(r.RefOperations, op)
+}
+
+func (r *RootElem) GetRefOperations() []VDomRefOperation {
+	ops := r.RefOperations
+	r.RefOperations = nil
+	return ops
+}
+
+func convertPropsToVDom(props map[string]any) map[string]any {
+	if len(props) == 0 {
+		return nil
+	}
+	vdomProps := make(map[string]any)
+	for k, v := range props {
+		if v == nil {
+			continue
+		}
+		val := reflect.ValueOf(v)
+		if val.Kind() == reflect.Func {
+			vdomProps[k] = VDomFunc{Type: ObjectType_Func}
+			continue
+		}
+		vdomProps[k] = v
+	}
+	return vdomProps
+}
+
+func convertBaseToVDom(c *ComponentImpl) *VDomElem {
+	elem := &VDomElem{WaveId: c.WaveId, Tag: c.Tag}
+	if c.Elem != nil {
+		elem.Props = convertPropsToVDom(c.Elem.Props)
+	}
+	for _, child := range c.Children {
+		childElem := convertCompToVDom(child)
+		if childElem != nil {
+			elem.Children = append(elem.Children, *childElem)
+		}
+	}
+	if c.Tag == TextTag {
+		elem.Text = c.Text
+	}
+	return elem
+}
+
+func convertCompToVDom(c *ComponentImpl) *VDomElem {
+	if c == nil {
+		return nil
+	}
+	if c.Comp != nil {
+		return convertCompToVDom(c.Comp)
+	}
+	return convertBaseToVDom(c)
+}
+
+func (r *RootElem) MakeVDom() *VDomElem {
+	if r.Root == nil {
+		return nil
+	}
+	return convertCompToVDom(r.Root)
+}
+
+func ConvertElemsToTransferElems(elems []VDomElem) []VDomTransferElem {
+	transferElems := make([]VDomTransferElem, 0)
+	for _, elem := range elems {
+		transferElem := VDomTransferElem{
+			WaveId: elem.WaveId,
+			Tag:    elem.Tag,
+			Props:  elem.Props,
+			Text:   elem.Text,
+		}
+		for _, child := range elem.Children {
+			transferElem.Children = append(transferElem.Children, child.WaveId)
+		}
+		transferElems = append(transferElems, transferElem)
+		childTransferElems := ConvertElemsToTransferElems(elem.Children)
+		transferElems = append(transferElems, childTransferElems...)
+	}
+	return transferElems
+}
+
+func DedupTransferElems(elems []VDomTransferElem) []VDomTransferElem {
+	seen := make(map[string]bool)
+	result := make([]VDomTransferElem, 0)
+	for _, elem := range elems {
+		if !seen[elem.WaveId] {
+			seen[elem.WaveId] = true
+			result = append(result, elem)
+		}
+	}
+	return result
+}
+
+func (beUpdate *VDomBackendUpdate) CreateTransferElems() {
+	var allElems []VDomElem
+	for _, renderUpdate := range beUpdate.RenderUpdates {
+		if renderUpdate.VDom != nil {
+			allElems = append(allElems, *renderUpdate.VDom)
+		}
+	}
+	transferElems := ConvertElemsToTransferElems(allElems)
+	beUpdate.TransferElems = DedupTransferElems(transferElems)
+	for i := range beUpdate.RenderUpdates {
+		beUpdate.RenderUpdates[i].VDom = nil
+	}
+}
+
+func SplitBackendUpdate(update *VDomBackendUpdate) []*VDomBackendUpdate {
+	if len(update.TransferElems) <= BackendUpdate_InitialChunkSize && len(update.StateSync) <= BackendUpdate_InitialChunkSize {
+		return []*VDomBackendUpdate{update}
+	}
+
+	updates := make([]*VDomBackendUpdate, 0)
+	transferElemChunks := chunkSlice(update.TransferElems, BackendUpdate_ChunkSize)
+	stateSyncChunks := chunkSlice(update.StateSync, BackendUpdate_ChunkSize)
+
+	maxChunks := len(transferElemChunks)
+	if len(stateSyncChunks) > maxChunks {
+		maxChunks = len(stateSyncChunks)
+	}
+
+	for i := 0; i < maxChunks; i++ {
+		newUpdate := &VDomBackendUpdate{
+			Type:    update.Type,
+			Ts:      update.Ts,
+			BlockId: update.BlockId,
+		}
+
+		if i == 0 {
+			newUpdate.Opts = update.Opts
+			newUpdate.HasWork = update.HasWork
+			newUpdate.RenderUpdates = update.RenderUpdates
+			newUpdate.RefOperations = update.RefOperations
+			newUpdate.Messages = update.Messages
+		}
+
+		if i < len(transferElemChunks) {
+			newUpdate.TransferElems = transferElemChunks[i]
+		}
+
+		if i < len(stateSyncChunks) {
+			newUpdate.StateSync = stateSyncChunks[i]
+		}
+
+		updates = append(updates, newUpdate)
+	}
+
+	return updates
+}
+
+func chunkSlice[T any](slice []T, chunkSize int) [][]T {
+	if len(slice) == 0 {
+		return nil
+	}
+	chunks := make([][]T, 0)
+	for i := 0; i < len(slice); i += chunkSize {
+		end := i + chunkSize
+		if end > len(slice) {
+			end = len(slice)
+		}
+		chunks = append(chunks, slice[i:end])
+	}
+	return chunks
+}
\ No newline at end of file
diff --git a/tsunami/vdom/vdom_test.go b/tsunami/vdom/vdom_test.go
new file mode 100644
index 0000000000..8707f6ca4e
--- /dev/null
+++ b/tsunami/vdom/vdom_test.go
@@ -0,0 +1,185 @@
+package vdom
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"reflect"
+	"testing"
+
+	"tsunami/util"
+)
+
+type renderContextKeyType struct{}
+
+var renderContextKey = renderContextKeyType{}
+
+type TestContext struct {
+	ButtonId string
+}
+
+func Page(ctx context.Context, props map[string]any) any {
+	clicked, setClicked := UseState(ctx, false)
+	var clickedDiv *VDomElem
+	if clicked {
+		clickedDiv = Bind(`<div>clicked</div>`, nil)
+	}
+	clickFn := func() {
+		log.Printf("run clickFn\n")
+		setClicked(true)
+	}
+	return Bind(
+		`
+<div>
+    <h1>hello world</h1>
+	<Button onClick="#param:clickFn">hello</Button>
+	<bindparam key="clickedDiv"/>
+</div>
+`,
+		map[string]any{"clickFn": clickFn, "clickedDiv": clickedDiv},
+	)
+}
+
+func Button(ctx context.Context, props map[string]any) any {
+	ref := UseVDomRef(ctx)
+	clName, setClName := UseState(ctx, "button")
+	UseEffect(ctx, func() func() {
+		fmt.Printf("Button useEffect\n")
+		setClName("button mounted")
+		return nil
+	}, nil)
+	compId := UseId(ctx)
+	testContext := getTestContext(ctx)
+	if testContext != nil {
+		testContext.ButtonId = compId
+	}
+	return Bind(`
+		<div className="#param:clName" ref="#param:ref" onClick="#param:onClick">
+			<bindparam key="children"/>
+		</div>
+	`, map[string]any{"clName": clName, "ref": ref, "onClick": props["onClick"], "children": props["children"]})
+}
+
+func printVDom(root *RootElem) {
+	vd := root.MakeVDom()
+	jsonBytes, _ := json.MarshalIndent(vd, "", "  ")
+	fmt.Printf("%s\n", string(jsonBytes))
+}
+
+func getTestContext(ctx context.Context) *TestContext {
+	val := ctx.Value(renderContextKey)
+	if val == nil {
+		return nil
+	}
+	return val.(*TestContext)
+}
+
+func Test1(t *testing.T) {
+	log.Printf("hello!\n")
+	testContext := &TestContext{ButtonId: ""}
+	ctx := context.WithValue(context.Background(), renderContextKey, testContext)
+	root := MakeRoot()
+	root.SetOuterCtx(ctx)
+	root.RegisterComponent("Page", Page)
+	root.RegisterComponent("Button", Button)
+	root.Render(E("Page"))
+	if root.Root == nil {
+		t.Fatalf("root.Root is nil")
+	}
+	printVDom(root)
+	root.RunWork()
+	printVDom(root)
+	root.Event(testContext.ButtonId, "onClick", VDomEvent{EventType: "onClick"})
+	root.RunWork()
+	printVDom(root)
+}
+
+func TestBind(t *testing.T) {
+	elem := Bind(`<div>clicked</div>`, nil)
+	jsonBytes, _ := json.MarshalIndent(elem, "", "  ")
+	log.Printf("%s\n", string(jsonBytes))
+
+	elem = Bind(`
+	<div>
+	    clicked
+    </div>`, nil)
+	jsonBytes, _ = json.MarshalIndent(elem, "", "  ")
+	log.Printf("%s\n", string(jsonBytes))
+
+	elem = Bind(`<Button>foo</Button>`, nil)
+	jsonBytes, _ = json.MarshalIndent(elem, "", "  ")
+	log.Printf("%s\n", string(jsonBytes))
+
+	elem = Bind(`
+<div>
+    <h1>hello world</h1>
+	<Button onClick="#param:clickFn">hello</Button>
+	<bindparam key="clickedDiv"/>
+</div>
+`, nil)
+	jsonBytes, _ = json.MarshalIndent(elem, "", "  ")
+	log.Printf("%s\n", string(jsonBytes))
+}
+
+func TestJsonBind(t *testing.T) {
+	elem := Bind(`<div data1={5} data2={[1,2,3]} data3={{"a": 1}}/>`, nil)
+	if elem == nil {
+		t.Fatalf("elem is nil")
+	}
+	if elem.Tag != "div" {
+		t.Fatalf("elem.Tag: %s (expected 'div')\n", elem.Tag)
+	}
+	if elem.Props == nil || len(elem.Props) != 3 {
+		t.Fatalf("elem.Props: %v\n", elem.Props)
+	}
+	data1Val, ok := elem.Props["data1"]
+	if !ok {
+		t.Fatalf("data1 not found\n")
+	}
+	_, ok = data1Val.(float64)
+	if !ok {
+		t.Fatalf("data1: %T\n", data1Val)
+	}
+	data1Int, ok := util.ToInt(data1Val)
+	if !ok || data1Int != 5 {
+		t.Fatalf("data1: %v\n", data1Val)
+	}
+	data2Val, ok := elem.Props["data2"]
+	if !ok {
+		t.Fatalf("data2 not found\n")
+	}
+	d2type := reflect.TypeOf(data2Val)
+	if d2type.Kind() != reflect.Slice {
+		t.Fatalf("data2: %T\n", data2Val)
+	}
+	data2Arr := data2Val.([]any)
+	if len(data2Arr) != 3 {
+		t.Fatalf("data2: %v\n", data2Val)
+	}
+	d2v2, ok := data2Arr[1].(float64)
+	if !ok || d2v2 != 2 {
+		t.Fatalf("data2: %v\n", data2Val)
+	}
+	data3Val, ok := elem.Props["data3"]
+	if !ok || data3Val == nil {
+		t.Fatalf("data3 not found\n")
+	}
+	d3type := reflect.TypeOf(data3Val)
+	if d3type.Kind() != reflect.Map {
+		t.Fatalf("data3: %T\n", data3Val)
+	}
+	data3Map := data3Val.(map[string]any)
+	if len(data3Map) != 1 {
+		t.Fatalf("data3: %v\n", data3Val)
+	}
+	d3v1, ok := data3Map["a"]
+	if !ok {
+		t.Fatalf("data3: %v\n", data3Val)
+	}
+	mval, ok := util.ToInt(d3v1)
+	if !ok || mval != 1 {
+		t.Fatalf("data3: %v\n", data3Val)
+	}
+	log.Printf("elem: %v\n", elem)
+}
\ No newline at end of file
diff --git a/tsunami/vdom/vdom_types.go b/tsunami/vdom/vdom_types.go
new file mode 100644
index 0000000000..a920185e0f
--- /dev/null
+++ b/tsunami/vdom/vdom_types.go
@@ -0,0 +1,316 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package vdom
+
+import (
+	"context"
+	"time"
+)
+
+const TextTag = "#text"
+const WaveTextTag = "wave:text"
+const WaveNullTag = "wave:null"
+const FragmentTag = "#fragment"
+const BindTag = "#bind"
+
+const ChildrenPropKey = "children"
+const KeyPropKey = "key"
+
+const ObjectType_Ref = "ref"
+const ObjectType_Binding = "binding"
+const ObjectType_Func = "func"
+
+// generic hook structure
+type Hook struct {
+	Init      bool          // is initialized
+	Idx       int           // index in the hook array
+	Fn        func() func() // for useEffect
+	UnmountFn func()        // for useEffect
+	Val       any           // for useState, useMemo, useRef
+	Deps      []any
+}
+
+type vdomContextKeyType struct{}
+
+var vdomContextKey = vdomContextKeyType{}
+
+type VDomContextVal struct {
+	Root    *RootElem
+	Comp    *ComponentImpl
+	HookIdx int
+}
+
+type Atom struct {
+	Val    any
+	Dirty  bool
+	UsedBy map[string]bool // component waveid -> true
+}
+
+type RootElem struct {
+	OuterCtx        context.Context
+	Root            *ComponentImpl
+	RenderTs        int64
+	CFuncs          map[string]any
+	CompMap         map[string]*ComponentImpl // component waveid -> component
+	EffectWorkQueue []*EffectWorkElem
+	NeedsRenderMap  map[string]bool
+	Atoms           map[string]*Atom
+	RefOperations   []VDomRefOperation
+}
+
+const (
+	WorkType_Render = "render"
+	WorkType_Effect = "effect"
+)
+
+type EffectWorkElem struct {
+	Id          string
+	EffectIndex int
+}
+
+// vdom element
+type VDomElem struct {
+	WaveId   string         `json:"waveid,omitempty"` // required, except for #text nodes
+	Tag      string         `json:"tag"`
+	Props    map[string]any `json:"props,omitempty"`
+	Children []VDomElem     `json:"children,omitempty"`
+	Text     string         `json:"text,omitempty"`
+}
+
+// the over the wire format for a vdom element
+type VDomTransferElem struct {
+	WaveId   string         `json:"waveid,omitempty"` // required, except for #text nodes
+	Tag      string         `json:"tag"`
+	Props    map[string]any `json:"props,omitempty"`
+	Children []string       `json:"children,omitempty"`
+	Text     string         `json:"text,omitempty"`
+}
+
+//// protocol messages
+
+type VDomCreateContext struct {
+	Type    string         `json:"type" tstype:"\"createcontext\""`
+	Ts      int64          `json:"ts"`
+	Meta    map[string]any `json:"meta,omitempty"`
+	Target  *VDomTarget    `json:"target,omitempty"`
+	Persist bool           `json:"persist,omitempty"`
+}
+
+type VDomAsyncInitiationRequest struct {
+	Type    string `json:"type" tstype:"\"asyncinitiationrequest\""`
+	Ts      int64  `json:"ts"`
+	BlockId string `json:"blockid,omitempty"`
+}
+
+func MakeAsyncInitiationRequest(blockId string) VDomAsyncInitiationRequest {
+	return VDomAsyncInitiationRequest{
+		Type:    "asyncinitiationrequest",
+		Ts:      time.Now().UnixMilli(),
+		BlockId: blockId,
+	}
+}
+
+type VDomFrontendUpdate struct {
+	Type          string            `json:"type" tstype:"\"frontendupdate\""`
+	Ts            int64             `json:"ts"`
+	BlockId       string            `json:"blockid"`
+	CorrelationId string            `json:"correlationid,omitempty"`
+	Dispose       bool              `json:"dispose,omitempty"` // the vdom context was closed
+	Resync        bool              `json:"resync,omitempty"`  // resync (send all backend data).  useful when the FE reloads
+	RenderContext VDomRenderContext `json:"rendercontext,omitempty"`
+	Events        []VDomEvent       `json:"events,omitempty"`
+	StateSync     []VDomStateSync   `json:"statesync,omitempty"`
+	RefUpdates    []VDomRefUpdate   `json:"refupdates,omitempty"`
+	Messages      []VDomMessage     `json:"messages,omitempty"`
+}
+
+type VDomBackendUpdate struct {
+	Type          string             `json:"type" tstype:"\"backendupdate\""`
+	Ts            int64              `json:"ts"`
+	BlockId       string             `json:"blockid"`
+	Opts          *VDomBackendOpts   `json:"opts,omitempty"`
+	HasWork       bool               `json:"haswork,omitempty"`
+	RenderUpdates []VDomRenderUpdate `json:"renderupdates,omitempty"`
+	TransferElems []VDomTransferElem `json:"transferelems,omitempty"`
+	StateSync     []VDomStateSync    `json:"statesync,omitempty"`
+	RefOperations []VDomRefOperation `json:"refoperations,omitempty"`
+	Messages      []VDomMessage      `json:"messages,omitempty"`
+}
+
+///// prop types
+
+// used in props
+type VDomBinding struct {
+	Type string `json:"type" tstype:"\"binding\""`
+	Bind string `json:"bind"`
+}
+
+// used in props
+type VDomFunc struct {
+	Fn              any      `json:"-"` // server side function (called with reflection)
+	Type            string   `json:"type" tstype:"\"func\""`
+	StopPropagation bool     `json:"stoppropagation,omitempty"`
+	PreventDefault  bool     `json:"preventdefault,omitempty"`
+	GlobalEvent     string   `json:"globalevent,omitempty"`
+	Keys            []string `json:"#keys,omitempty"` // special for keyDown events a list of keys to "capture"
+}
+
+// used in props
+type VDomRef struct {
+	Type          string           `json:"type" tstype:"\"ref\""`
+	RefId         string           `json:"refid"`
+	TrackPosition bool             `json:"trackposition,omitempty"`
+	Position      *VDomRefPosition `json:"position,omitempty"`
+	HasCurrent    bool             `json:"hascurrent,omitempty"`
+}
+
+type VDomSimpleRef[T any] struct {
+	Current T `json:"current"`
+}
+
+type DomRect struct {
+	Top    float64 `json:"top"`
+	Left   float64 `json:"left"`
+	Right  float64 `json:"right"`
+	Bottom float64 `json:"bottom"`
+	Width  float64 `json:"width"`
+	Height float64 `json:"height"`
+}
+
+type VDomRefPosition struct {
+	OffsetHeight       int     `json:"offsetheight"`
+	OffsetWidth        int     `json:"offsetwidth"`
+	ScrollHeight       int     `json:"scrollheight"`
+	ScrollWidth        int     `json:"scrollwidth"`
+	ScrollTop          int     `json:"scrolltop"`
+	BoundingClientRect DomRect `json:"boundingclientrect"`
+}
+
+///// subbordinate protocol types
+
+type VDomEvent struct {
+	WaveId          string             `json:"waveid"`
+	EventType       string             `json:"eventtype"` // usually the prop name (e.g. onClick, onKeyDown)
+	GlobalEventType string             `json:"globaleventtype,omitempty"`
+	TargetValue     string             `json:"targetvalue,omitempty"`
+	TargetChecked   bool               `json:"targetchecked,omitempty"`
+	TargetName      string             `json:"targetname,omitempty"`
+	TargetId        string             `json:"targetid,omitempty"`
+	KeyData         *WaveKeyboardEvent `json:"keydata,omitempty"`
+	MouseData       *WavePointerData   `json:"mousedata,omitempty"`
+}
+
+type VDomRenderContext struct {
+	BlockId    string `json:"blockid"`
+	Focused    bool   `json:"focused"`
+	Width      int    `json:"width"`
+	Height     int    `json:"height"`
+	RootRefId  string `json:"rootrefid"`
+	Background bool   `json:"background,omitempty"`
+}
+
+type VDomStateSync struct {
+	Atom  string `json:"atom"`
+	Value any    `json:"value"`
+}
+
+type VDomRefUpdate struct {
+	RefId      string           `json:"refid"`
+	HasCurrent bool             `json:"hascurrent"`
+	Position   *VDomRefPosition `json:"position,omitempty"`
+}
+
+type VDomBackendOpts struct {
+	CloseOnCtrlC         bool `json:"closeonctrlc,omitempty"`
+	GlobalKeyboardEvents bool `json:"globalkeyboardevents,omitempty"`
+	GlobalStyles         bool `json:"globalstyles,omitempty"`
+}
+
+type VDomRenderUpdate struct {
+	UpdateType string    `json:"updatetype" tstype:"\"root\"|\"append\"|\"replace\"|\"remove\"|\"insert\""`
+	WaveId     string    `json:"waveid,omitempty"`
+	VDomWaveId string    `json:"vdomwaveid,omitempty"`
+	VDom       *VDomElem `json:"vdom,omitempty"` // these get removed for transfer (encoded to transferelems)
+	Index      *int      `json:"index,omitempty"`
+}
+
+type VDomRefOperation struct {
+	RefId     string `json:"refid"`
+	Op        string `json:"op"`
+	Params    []any  `json:"params,omitempty"`
+	OutputRef string `json:"outputref,omitempty"`
+}
+
+type VDomMessage struct {
+	MessageType string `json:"messagetype"`
+	Message     string `json:"message"`
+	StackTrace  string `json:"stacktrace,omitempty"`
+	Params      []any  `json:"params,omitempty"`
+}
+
+// target -- to support new targets in the future, like toolbars, partial blocks, splits, etc.
+// default is vdom context inside of a terminal block
+type VDomTarget struct {
+	NewBlock  bool               `json:"newblock,omitempty"`
+	Magnified bool               `json:"magnified,omitempty"`
+	Toolbar   *VDomTargetToolbar `json:"toolbar,omitempty"`
+}
+
+type VDomTargetToolbar struct {
+	Toolbar bool   `json:"toolbar"`
+	Height  string `json:"height,omitempty"`
+}
+
+// matches WaveKeyboardEvent
+type VDomKeyboardEvent struct {
+	Type     string `json:"type"`
+	Key      string `json:"key"`
+	Code     string `json:"code"`
+	Shift    bool   `json:"shift,omitempty"`
+	Control  bool   `json:"ctrl,omitempty"`
+	Alt      bool   `json:"alt,omitempty"`
+	Meta     bool   `json:"meta,omitempty"`
+	Cmd      bool   `json:"cmd,omitempty"`
+	Option   bool   `json:"option,omitempty"`
+	Repeat   bool   `json:"repeat,omitempty"`
+	Location int    `json:"location,omitempty"`
+}
+
+type WaveKeyboardEvent struct {
+	Type     string `json:"type" tstype:"\"keydown\"|\"keyup\"|\"keypress\"|\"unknown\""`
+	Key      string `json:"key"`  // KeyboardEvent.key
+	Code     string `json:"code"` // KeyboardEvent.code
+	Repeat   bool   `json:"repeat,omitempty"`
+	Location int    `json:"location,omitempty"` // KeyboardEvent.location
+
+	// modifiers
+	Shift   bool `json:"shift,omitempty"`
+	Control bool `json:"control,omitempty"`
+	Alt     bool `json:"alt,omitempty"`
+	Meta    bool `json:"meta,omitempty"`
+	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
+	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
+}
+
+type WavePointerData struct {
+	Button  int `json:"button"`
+	Buttons int `json:"buttons"`
+
+	ClientX   int `json:"clientx,omitempty"`
+	ClientY   int `json:"clienty,omitempty"`
+	PageX     int `json:"pagex,omitempty"`
+	PageY     int `json:"pagey,omitempty"`
+	ScreenX   int `json:"screenx,omitempty"`
+	ScreenY   int `json:"screeny,omitempty"`
+	MovementX int `json:"movementx,omitempty"`
+	MovementY int `json:"movementy,omitempty"`
+
+	// Modifiers
+	Shift   bool `json:"shift,omitempty"`
+	Control bool `json:"control,omitempty"`
+	Alt     bool `json:"alt,omitempty"`
+	Meta    bool `json:"meta,omitempty"`
+	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
+	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
+}
\ No newline at end of file

From 0bfffccdc7ec5c3d3c4e21ed1eef05e85c1fe796 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sat, 30 Aug 2025 21:51:23 -0700
Subject: [PATCH 002/134] fix all errors in tsunami packages

---
 tsunami/app/streamingresp.go     | 129 +++++++++
 tsunami/app/waveapp.go           | 444 +++++++++++++++++++++++++++++++
 tsunami/app/waveappserverimpl.go | 151 +++++++++++
 tsunami/go.mod                   |   3 +-
 tsunami/go.sum                   |   2 +
 tsunami/rpc/rpc.go               |   8 +
 tsunami/rpc/types.go             |  51 ++++
 tsunami/rpc/wps.go               |  31 +++
 tsunami/rpcclient/client.go      |  43 +++
 tsunami/rpcclient/rpcclient.go   |  27 ++
 tsunami/util/util.go             |  52 ++++
 tsunami/vdom/vdom.go             |   3 +-
 tsunami/vdom/vdom_html.go        |   2 +-
 tsunami/vdom/vdom_root.go        |   4 +-
 tsunami/vdom/vdom_test.go        |   4 +-
 15 files changed, 946 insertions(+), 8 deletions(-)
 create mode 100644 tsunami/app/streamingresp.go
 create mode 100644 tsunami/app/waveapp.go
 create mode 100644 tsunami/app/waveappserverimpl.go
 create mode 100644 tsunami/rpc/rpc.go
 create mode 100644 tsunami/rpc/types.go
 create mode 100644 tsunami/rpc/wps.go
 create mode 100644 tsunami/rpcclient/client.go
 create mode 100644 tsunami/rpcclient/rpcclient.go
 create mode 100644 tsunami/util/util.go

diff --git a/tsunami/app/streamingresp.go b/tsunami/app/streamingresp.go
new file mode 100644
index 0000000000..57188baab4
--- /dev/null
+++ b/tsunami/app/streamingresp.go
@@ -0,0 +1,129 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package waveapp
+
+import (
+	"bytes"
+	"net/http"
+
+	"github.com/wavetermdev/waveterm/tsunami/rpc"
+)
+
+const maxChunkSize = 64 * 1024 // 64KB maximum chunk size
+
+// StreamingResponseWriter implements http.ResponseWriter interface to stream response
+// data through a channel rather than buffering it in memory. This is particularly
+// useful for handling large responses like video streams or file downloads.
+type StreamingResponseWriter struct {
+	header     http.Header
+	statusCode int
+	respChan   chan<- rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse]
+	headerSent bool
+	buffer     *bytes.Buffer
+}
+
+func NewStreamingResponseWriter(respChan chan<- rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse]) *StreamingResponseWriter {
+	return &StreamingResponseWriter{
+		header:     make(http.Header),
+		statusCode: http.StatusOK,
+		respChan:   respChan,
+		headerSent: false,
+		buffer:     bytes.NewBuffer(make([]byte, 0, maxChunkSize)),
+	}
+}
+
+func (w *StreamingResponseWriter) Header() http.Header {
+	return w.header
+}
+
+func (w *StreamingResponseWriter) WriteHeader(statusCode int) {
+	if w.headerSent {
+		return
+	}
+
+	w.statusCode = statusCode
+	w.headerSent = true
+
+	headers := make(map[string]string)
+	for key, values := range w.header {
+		if len(values) > 0 {
+			headers[key] = values[0]
+		}
+	}
+
+	w.respChan <- rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse]{
+		Response: rpc.VDomUrlRequestResponse{
+			StatusCode: w.statusCode,
+			Headers:    headers,
+		},
+	}
+}
+
+// sendChunk sends a single chunk of exactly maxChunkSize (or less)
+func (w *StreamingResponseWriter) sendChunk(data []byte) {
+	if len(data) == 0 {
+		return
+	}
+	chunk := make([]byte, len(data))
+	copy(chunk, data)
+	w.respChan <- rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse]{
+		Response: rpc.VDomUrlRequestResponse{
+			Body: chunk,
+		},
+	}
+}
+
+func (w *StreamingResponseWriter) Write(data []byte) (int, error) {
+	if !w.headerSent {
+		w.WriteHeader(http.StatusOK)
+	}
+
+	originalLen := len(data)
+
+	// If we already have data in the buffer
+	if w.buffer.Len() > 0 {
+		// Fill the buffer up to maxChunkSize
+		spaceInBuffer := maxChunkSize - w.buffer.Len()
+		if spaceInBuffer > 0 {
+			// How much of the new data can fit in the buffer
+			toBuffer := spaceInBuffer
+			if toBuffer > len(data) {
+				toBuffer = len(data)
+			}
+			w.buffer.Write(data[:toBuffer])
+			data = data[toBuffer:] // Advance data slice
+		}
+
+		// If buffer is full, send it
+		if w.buffer.Len() == maxChunkSize {
+			w.sendChunk(w.buffer.Bytes())
+			w.buffer.Reset()
+		}
+	}
+
+	// Send any full chunks from data
+	for len(data) >= maxChunkSize {
+		w.sendChunk(data[:maxChunkSize])
+		data = data[maxChunkSize:]
+	}
+
+	// Buffer any remaining data
+	if len(data) > 0 {
+		w.buffer.Write(data)
+	}
+
+	return originalLen, nil
+}
+
+func (w *StreamingResponseWriter) Close() error {
+	if !w.headerSent {
+		w.WriteHeader(http.StatusOK)
+	}
+
+	if w.buffer.Len() > 0 {
+		w.sendChunk(w.buffer.Bytes())
+		w.buffer.Reset()
+	}
+	return nil
+}
diff --git a/tsunami/app/waveapp.go b/tsunami/app/waveapp.go
new file mode 100644
index 0000000000..bd43a2f826
--- /dev/null
+++ b/tsunami/app/waveapp.go
@@ -0,0 +1,444 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package waveapp
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/fs"
+	"log"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"time"
+	"unicode"
+
+	"github.com/google/uuid"
+	"github.com/gorilla/mux"
+	"github.com/wavetermdev/waveterm/tsunami/rpc"
+	"github.com/wavetermdev/waveterm/tsunami/rpcclient"
+	"github.com/wavetermdev/waveterm/tsunami/util"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+type AppOpts struct {
+	CloseOnCtrlC         bool
+	GlobalKeyboardEvents bool
+	GlobalStyles         []byte
+	RootComponentName    string // defaults to "App"
+	NewBlockFlag         string // defaults to "n" (set to "-" to disable)
+	TargetNewBlock       bool
+	TargetToolbar        *vdom.VDomTargetToolbar
+}
+
+type Client struct {
+	Lock               *sync.Mutex
+	AppOpts            AppOpts
+	Root               *vdom.RootElem
+	RootElem           *vdom.VDomElem
+	RpcClient          *rpcclient.RpcClient
+	RpcContext         *rpc.RpcContext
+	ServerImpl         *WaveAppServerImpl
+	IsDone             bool
+	RouteId            string
+	VDomContextBlockId string
+	DoneReason         string
+	DoneCh             chan struct{}
+	Opts               vdom.VDomBackendOpts
+	GlobalEventHandler func(client *Client, event vdom.VDomEvent)
+	GlobalStylesOption *FileHandlerOption
+	UrlHandlerMux      *mux.Router
+	OverrideUrlHandler http.Handler
+	NewBlockFlag       bool
+	SetupFn            func()
+}
+
+func (c *Client) GetIsDone() bool {
+	c.Lock.Lock()
+	defer c.Lock.Unlock()
+	return c.IsDone
+}
+
+func (c *Client) doShutdown(reason string) {
+	c.Lock.Lock()
+	defer c.Lock.Unlock()
+	if c.IsDone {
+		return
+	}
+	c.DoneReason = reason
+	c.IsDone = true
+	close(c.DoneCh)
+}
+
+func (c *Client) SetGlobalEventHandler(handler func(client *Client, event vdom.VDomEvent)) {
+	c.GlobalEventHandler = handler
+}
+
+func (c *Client) SetOverrideUrlHandler(handler http.Handler) {
+	c.OverrideUrlHandler = handler
+}
+
+func MakeClient(appOpts AppOpts) *Client {
+	if appOpts.RootComponentName == "" {
+		appOpts.RootComponentName = "App"
+	}
+	if appOpts.NewBlockFlag == "" {
+		appOpts.NewBlockFlag = "n"
+	}
+	client := &Client{
+		Lock:          &sync.Mutex{},
+		AppOpts:       appOpts,
+		Root:          vdom.MakeRoot(),
+		RpcClient:     rpcclient.MakeRpcClient(),
+		DoneCh:        make(chan struct{}),
+		UrlHandlerMux: mux.NewRouter(),
+		Opts: vdom.VDomBackendOpts{
+			CloseOnCtrlC:         appOpts.CloseOnCtrlC,
+			GlobalKeyboardEvents: appOpts.GlobalKeyboardEvents,
+		},
+	}
+	if len(appOpts.GlobalStyles) > 0 {
+		client.Opts.GlobalStyles = true
+		client.GlobalStylesOption = &FileHandlerOption{Data: appOpts.GlobalStyles, MimeType: "text/css"}
+	}
+	client.SetRootElem(vdom.E(appOpts.RootComponentName))
+	return client
+}
+
+func (client *Client) runMainE() error {
+	if client.SetupFn != nil {
+		client.SetupFn()
+	}
+	err := client.Connect()
+	if err != nil {
+		return err
+	}
+	target := &vdom.VDomTarget{}
+	if client.AppOpts.TargetNewBlock || client.NewBlockFlag {
+		target.NewBlock = client.NewBlockFlag
+	}
+	if client.AppOpts.TargetToolbar != nil {
+		target.Toolbar = client.AppOpts.TargetToolbar
+	}
+	if target.NewBlock && target.Toolbar != nil {
+		return fmt.Errorf("cannot specify both new block and toolbar target")
+	}
+	err = client.CreateVDomContext(target)
+	if err != nil {
+		return err
+	}
+	<-client.DoneCh
+	return nil
+}
+
+func (client *Client) AddSetupFn(fn func()) {
+	client.SetupFn = fn
+}
+
+func (client *Client) RegisterDefaultFlags() {
+	if client.AppOpts.NewBlockFlag != "-" {
+		flag.BoolVar(&client.NewBlockFlag, client.AppOpts.NewBlockFlag, false, "new block")
+	}
+}
+
+func (client *Client) RunMain() {
+	if !flag.Parsed() {
+		client.RegisterDefaultFlags()
+		flag.Parse()
+	}
+	err := client.runMainE()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+func (client *Client) Connect() error {
+	return errors.New("unimplemented")
+}
+
+func (c *Client) SetRootElem(elem *vdom.VDomElem) {
+	c.RootElem = elem
+}
+
+func (c *Client) CreateVDomContext(target *vdom.VDomTarget) error {
+	blockORef, err := rpcclient.VDomCreateContextCommand(
+		c.RpcClient,
+		vdom.VDomCreateContext{Target: target},
+		&rpc.RpcOpts{Route: rpc.MakeFeBlockRouteId(c.RpcContext.BlockId)},
+	)
+	if err != nil {
+		return err
+	}
+	c.VDomContextBlockId = blockORef.OID
+	log.Printf("created vdom context: %v\n", blockORef)
+	gotRoute, err := rpcclient.WaitForRouteCommand(c.RpcClient, rpc.CommandWaitForRouteData{
+		RouteId: rpc.MakeFeBlockRouteId(blockORef.OID),
+		WaitMs:  4000,
+	}, &rpc.RpcOpts{Timeout: 5000})
+	if err != nil {
+		return fmt.Errorf("error waiting for vdom context route: %v", err)
+	}
+	if !gotRoute {
+		return fmt.Errorf("vdom context route could not be established")
+	}
+	rpcclient.EventSubCommand(c.RpcClient, rpc.SubscriptionRequest{Event: rpc.Event_BlockClose, Scopes: []string{
+		blockORef.String(),
+	}}, nil)
+	c.RpcClient.EventListener.On("blockclose", func(event *rpc.WaveEvent) {
+		c.doShutdown("got blockclose event")
+	})
+	return nil
+}
+
+func (c *Client) SendAsyncInitiation() error {
+	if c.VDomContextBlockId == "" {
+		return fmt.Errorf("no vdom context block id")
+	}
+	if c.GetIsDone() {
+		return fmt.Errorf("client is done")
+	}
+	return rpcclient.VDomAsyncInitiationCommand(
+		c.RpcClient,
+		vdom.MakeAsyncInitiationRequest(c.RpcContext.BlockId),
+		&rpc.RpcOpts{Route: rpc.MakeFeBlockRouteId(c.VDomContextBlockId)},
+	)
+}
+
+func (c *Client) SetAtomVals(m map[string]any) {
+	for k, v := range m {
+		c.Root.SetAtomVal(k, v, true)
+	}
+}
+
+func (c *Client) SetAtomVal(name string, val any) {
+	c.Root.SetAtomVal(name, val, true)
+}
+
+func (c *Client) GetAtomVal(name string) any {
+	return c.Root.GetAtomVal(name)
+}
+
+func makeNullVDom() *vdom.VDomElem {
+	return &vdom.VDomElem{WaveId: uuid.New().String(), Tag: vdom.WaveNullTag}
+}
+
+func DefineComponent[P any](client *Client, name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
+	if name == "" {
+		panic("Component name cannot be empty")
+	}
+	if !unicode.IsUpper(rune(name[0])) {
+		panic("Component name must start with an uppercase letter")
+	}
+	err := client.RegisterComponent(name, renderFn)
+	if err != nil {
+		panic(err)
+	}
+	return func(props P) *vdom.VDomElem {
+		return vdom.E(name, vdom.Props(props))
+	}
+}
+
+func (c *Client) RegisterComponent(name string, cfunc any) error {
+	return c.Root.RegisterComponent(name, cfunc)
+}
+
+func (c *Client) fullRender() (*vdom.VDomBackendUpdate, error) {
+	c.Root.RunWork()
+	c.Root.Render(c.RootElem)
+	renderedVDom := c.Root.MakeVDom()
+	if renderedVDom == nil {
+		renderedVDom = makeNullVDom()
+	}
+	return &vdom.VDomBackendUpdate{
+		Type:    "backendupdate",
+		Ts:      time.Now().UnixMilli(),
+		BlockId: c.RpcContext.BlockId,
+		HasWork: len(c.Root.EffectWorkQueue) > 0,
+		Opts:    &c.Opts,
+		RenderUpdates: []vdom.VDomRenderUpdate{
+			{UpdateType: "root", VDom: renderedVDom},
+		},
+		RefOperations: c.Root.GetRefOperations(),
+		StateSync:     c.Root.GetStateSync(true),
+	}, nil
+}
+
+func (c *Client) incrementalRender() (*vdom.VDomBackendUpdate, error) {
+	c.Root.RunWork()
+	renderedVDom := c.Root.MakeVDom()
+	if renderedVDom == nil {
+		renderedVDom = makeNullVDom()
+	}
+	return &vdom.VDomBackendUpdate{
+		Type:    "backendupdate",
+		Ts:      time.Now().UnixMilli(),
+		BlockId: c.RpcContext.BlockId,
+		RenderUpdates: []vdom.VDomRenderUpdate{
+			{UpdateType: "root", VDom: renderedVDom},
+		},
+		RefOperations: c.Root.GetRefOperations(),
+		StateSync:     c.Root.GetStateSync(false),
+	}, nil
+}
+
+func (c *Client) RegisterUrlPathHandler(path string, handler http.Handler) {
+	c.UrlHandlerMux.Handle(path, handler)
+}
+
+type FileHandlerOption struct {
+	FilePath string    // optional file path on disk
+	Data     []byte    // optional byte slice content
+	Reader   io.Reader // optional reader for content
+	File     fs.File   // optional embedded or opened file
+	MimeType string    // optional mime type
+	ETag     string    // optional ETag (if set, resource may be cached)
+}
+
+func determineMimeType(option FileHandlerOption) (string, []byte) {
+	// If MimeType is set, use it directly
+	if option.MimeType != "" {
+		return option.MimeType, nil
+	}
+
+	// Detect from Data if available, no need to buffer
+	if option.Data != nil {
+		return http.DetectContentType(option.Data), nil
+	}
+
+	// Detect from FilePath, no buffering necessary
+	if option.FilePath != "" {
+		filePath := util.ExpandHomeDirSafe(option.FilePath)
+		file, err := os.Open(filePath)
+		if err != nil {
+			return "application/octet-stream", nil // Fallback on error
+		}
+		defer file.Close()
+
+		// Read first 512 bytes for MIME detection
+		buf := make([]byte, 512)
+		_, err = file.Read(buf)
+		if err != nil && err != io.EOF {
+			return "application/octet-stream", nil
+		}
+		return http.DetectContentType(buf), nil
+	}
+
+	// Buffer for File (fs.File), since it lacks Seek
+	if option.File != nil {
+		buf := make([]byte, 512)
+		n, err := option.File.Read(buf)
+		if err != nil && err != io.EOF {
+			return "application/octet-stream", nil
+		}
+		return http.DetectContentType(buf[:n]), buf[:n]
+	}
+
+	// Buffer for Reader (io.Reader), same as File
+	if option.Reader != nil {
+		buf := make([]byte, 512)
+		n, err := option.Reader.Read(buf)
+		if err != nil && err != io.EOF {
+			return "application/octet-stream", nil
+		}
+		return http.DetectContentType(buf[:n]), buf[:n]
+	}
+
+	// Default MIME type if none specified
+	return "application/octet-stream", nil
+}
+
+// ServeFileOption handles serving content based on the provided FileHandlerOption
+func ServeFileOption(w http.ResponseWriter, r *http.Request, option FileHandlerOption) error {
+	// Determine MIME type and get buffered data if needed
+	contentType, bufferedData := determineMimeType(option)
+	w.Header().Set("Content-Type", contentType)
+	// Handle ETag
+	if option.ETag != "" {
+		w.Header().Set("ETag", option.ETag)
+
+		// Check If-None-Match header
+		if inm := r.Header.Get("If-None-Match"); inm != "" {
+			// Strip W/ prefix and quotes if present
+			inm = strings.Trim(inm, `"`)
+			inm = strings.TrimPrefix(inm, "W/")
+			etag := strings.Trim(option.ETag, `"`)
+			etag = strings.TrimPrefix(etag, "W/")
+
+			if inm == etag {
+				// Resource not modified
+				w.WriteHeader(http.StatusNotModified)
+				return nil
+			}
+		}
+	}
+
+	// Handle the content based on the option type
+	switch {
+	case option.FilePath != "":
+		filePath := util.ExpandHomeDirSafe(option.FilePath)
+		http.ServeFile(w, r, filePath)
+
+	case option.Data != nil:
+		w.Header().Set("Content-Length", fmt.Sprintf("%d", len(option.Data)))
+		w.WriteHeader(http.StatusOK)
+		if _, err := w.Write(option.Data); err != nil {
+			return fmt.Errorf("failed to write data: %v", err)
+		}
+
+	case option.File != nil:
+		if bufferedData != nil {
+			if _, err := w.Write(bufferedData); err != nil {
+				return fmt.Errorf("failed to write buffered data: %v", err)
+			}
+		}
+		if _, err := io.Copy(w, option.File); err != nil {
+			return fmt.Errorf("failed to copy from file: %v", err)
+		}
+
+	case option.Reader != nil:
+		if bufferedData != nil {
+			if _, err := w.Write(bufferedData); err != nil {
+				return fmt.Errorf("failed to write buffered data: %v", err)
+			}
+		}
+		if _, err := io.Copy(w, option.Reader); err != nil {
+			return fmt.Errorf("failed to copy from reader: %v", err)
+		}
+
+	default:
+		return fmt.Errorf("no content available")
+	}
+
+	return nil
+}
+
+func (c *Client) RegisterFilePrefixHandler(prefix string, optionProvider func(path string) (*FileHandlerOption, error)) {
+	c.UrlHandlerMux.PathPrefix(prefix).HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		option, err := optionProvider(r.URL.Path)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if option == nil {
+			http.Error(w, "no content available", http.StatusNotFound)
+			return
+		}
+		if err := ServeFileOption(w, r, *option); err != nil {
+			http.Error(w, fmt.Sprintf("Failed to serve content: %v", err), http.StatusInternalServerError)
+		}
+	})
+}
+
+func (c *Client) RegisterFileHandler(path string, option FileHandlerOption) {
+	c.UrlHandlerMux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		if err := ServeFileOption(w, r, option); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+	})
+}
diff --git a/tsunami/app/waveappserverimpl.go b/tsunami/app/waveappserverimpl.go
new file mode 100644
index 0000000000..de057d0fba
--- /dev/null
+++ b/tsunami/app/waveappserverimpl.go
@@ -0,0 +1,151 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package waveapp
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/wavetermdev/waveterm/tsunami/rpc"
+	"github.com/wavetermdev/waveterm/tsunami/util"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+type WaveAppServerImpl struct {
+	Client  *Client
+	BlockId string
+}
+
+func (*WaveAppServerImpl) WshServerImpl() {}
+
+func (impl *WaveAppServerImpl) VDomRenderCommand(ctx context.Context, feUpdate vdom.VDomFrontendUpdate) chan rpc.RespOrErrorUnion[*vdom.VDomBackendUpdate] {
+	respChan := make(chan rpc.RespOrErrorUnion[*vdom.VDomBackendUpdate], 5)
+	defer func() {
+		panicErr := util.PanicHandler("VDomRenderCommand", recover())
+		if panicErr != nil {
+			respChan <- rpc.RespOrErrorUnion[*vdom.VDomBackendUpdate]{
+				Error: panicErr,
+			}
+			close(respChan)
+		}
+	}()
+
+	if feUpdate.Dispose {
+		defer close(respChan)
+		log.Printf("got dispose from frontend\n")
+		impl.Client.doShutdown("got dispose from frontend")
+		return respChan
+	}
+
+	if impl.Client.GetIsDone() {
+		close(respChan)
+		return respChan
+	}
+
+	impl.Client.Root.RenderTs = feUpdate.Ts
+
+	// set atoms
+	for _, ss := range feUpdate.StateSync {
+		impl.Client.Root.SetAtomVal(ss.Atom, ss.Value, false)
+	}
+	// run events
+	for _, event := range feUpdate.Events {
+		if event.GlobalEventType != "" {
+			if impl.Client.GlobalEventHandler != nil {
+				impl.Client.GlobalEventHandler(impl.Client, event)
+			}
+		} else {
+			impl.Client.Root.Event(event.WaveId, event.EventType, event)
+		}
+	}
+	// update refs
+	for _, ref := range feUpdate.RefUpdates {
+		impl.Client.Root.UpdateRef(ref)
+	}
+
+	var update *vdom.VDomBackendUpdate
+	var err error
+
+	if feUpdate.Resync || true {
+		update, err = impl.Client.fullRender()
+	} else {
+		update, err = impl.Client.incrementalRender()
+	}
+	update.CreateTransferElems()
+
+	if err != nil {
+		respChan <- rpc.RespOrErrorUnion[*vdom.VDomBackendUpdate]{
+			Error: err,
+		}
+		close(respChan)
+		return respChan
+	}
+
+	// Split the update into chunks and send them sequentially
+	updates := vdom.SplitBackendUpdate(update)
+	go func() {
+		defer func() {
+			util.PanicHandler("VDomRenderCommand:splitUpdates", recover())
+		}()
+		defer close(respChan)
+		for _, splitUpdate := range updates {
+			respChan <- rpc.RespOrErrorUnion[*vdom.VDomBackendUpdate]{
+				Response: splitUpdate,
+			}
+		}
+	}()
+
+	return respChan
+}
+
+func (impl *WaveAppServerImpl) VDomUrlRequestCommand(ctx context.Context, data rpc.VDomUrlRequestData) chan rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse] {
+	respChan := make(chan rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse])
+	writer := NewStreamingResponseWriter(respChan)
+
+	go func() {
+		defer close(respChan) // Declared first, so it executes last
+		defer writer.Close()  // Ensures writer is closed before the channel is closed
+
+		defer func() {
+			panicErr := util.PanicHandler("VDomUrlRequestCommand", recover())
+			if panicErr != nil {
+				writer.WriteHeader(http.StatusInternalServerError)
+				writer.Write([]byte(fmt.Sprintf("internal server error: %v", panicErr)))
+			}
+		}()
+
+		// Create an HTTP request from the RPC request data
+		var bodyReader *bytes.Reader
+		if data.Body != nil {
+			bodyReader = bytes.NewReader(data.Body)
+		} else {
+			bodyReader = bytes.NewReader([]byte{})
+		}
+
+		httpReq, err := http.NewRequest(data.Method, data.URL, bodyReader)
+		if err != nil {
+			writer.WriteHeader(http.StatusInternalServerError)
+			writer.Write([]byte(err.Error()))
+			return
+		}
+
+		for key, value := range data.Headers {
+			httpReq.Header.Set(key, value)
+		}
+		if httpReq.URL.Path == "/wave/global.css" && impl.Client.GlobalStylesOption != nil {
+			ServeFileOption(writer, httpReq, *impl.Client.GlobalStylesOption)
+			return
+		}
+		if impl.Client.OverrideUrlHandler != nil {
+			impl.Client.OverrideUrlHandler.ServeHTTP(writer, httpReq)
+			return
+		}
+		impl.Client.UrlHandlerMux.ServeHTTP(writer, httpReq)
+	}()
+
+	return respChan
+}
diff --git a/tsunami/go.mod b/tsunami/go.mod
index 1a7e3b9b91..9f44097522 100644
--- a/tsunami/go.mod
+++ b/tsunami/go.mod
@@ -1,4 +1,4 @@
-module tsunami
+module github.com/wavetermdev/waveterm/tsunami
 
 go 1.22.4
 
@@ -6,6 +6,7 @@ toolchain go1.24.6
 
 require (
 	github.com/google/uuid v1.6.0
+	github.com/gorilla/mux v1.8.1
 	github.com/wavetermdev/htmltoken v0.2.0
 )
 
diff --git a/tsunami/go.sum b/tsunami/go.sum
index 338224a4d8..87a6d9bc63 100644
--- a/tsunami/go.sum
+++ b/tsunami/go.sum
@@ -1,5 +1,7 @@
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
+github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
 github.com/wavetermdev/htmltoken v0.2.0 h1:sFVPPemlDv7/jg7n4Hx1AEF2m9MVAFjFpELWfhi/DlM=
 github.com/wavetermdev/htmltoken v0.2.0/go.mod h1:5FM0XV6zNYiNza2iaTcFGj+hnMtgqumFHO31Z8euquk=
 golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
diff --git a/tsunami/rpc/rpc.go b/tsunami/rpc/rpc.go
new file mode 100644
index 0000000000..913cd57b4c
--- /dev/null
+++ b/tsunami/rpc/rpc.go
@@ -0,0 +1,8 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package rpc
+
+func MakeFeBlockRouteId(blockId string) string {
+	return "feblock:" + blockId
+}
\ No newline at end of file
diff --git a/tsunami/rpc/types.go b/tsunami/rpc/types.go
new file mode 100644
index 0000000000..834f0dbabf
--- /dev/null
+++ b/tsunami/rpc/types.go
@@ -0,0 +1,51 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package rpc
+
+type RespOrErrorUnion[T any] struct {
+	Response T
+	Error    error
+}
+
+type VDomUrlRequestData struct {
+	Method  string            `json:"method"`
+	URL     string            `json:"url"`
+	Headers map[string]string `json:"headers"`
+	Body    []byte            `json:"body,omitempty"`
+}
+
+type VDomUrlRequestResponse struct {
+	StatusCode int               `json:"statuscode,omitempty"`
+	Headers    map[string]string `json:"headers,omitempty"`
+	Body       []byte            `json:"body,omitempty"`
+}
+
+type RpcOpts struct {
+	Timeout    int64  `json:"timeout,omitempty"`
+	NoResponse bool   `json:"noresponse,omitempty"`
+	Route      string `json:"route,omitempty"`
+
+	StreamCancelFn func() `json:"-"` // this is an *output* parameter, set by the handler
+}
+
+type RpcContext struct {
+	ClientType string `json:"ctype,omitempty"`
+	BlockId    string `json:"blockid,omitempty"`
+	TabId      string `json:"tabid,omitempty"`
+	Conn       string `json:"conn,omitempty"`
+}
+
+type CommandWaitForRouteData struct {
+	RouteId string `json:"routeid"`
+	WaitMs  int    `json:"waitms"`
+}
+
+type ORef struct {
+	OType string `json:"otype"`
+	OID   string `json:"oid"`
+}
+
+func (oref ORef) String() string {
+	return oref.OType + ":" + oref.OID
+}
diff --git a/tsunami/rpc/wps.go b/tsunami/rpc/wps.go
new file mode 100644
index 0000000000..4f324cbe08
--- /dev/null
+++ b/tsunami/rpc/wps.go
@@ -0,0 +1,31 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package rpc
+
+const (
+	Event_BlockClose = "blockclose"
+)
+
+type WaveEvent struct {
+	Event   string   `json:"event"`
+	Scopes  []string `json:"scopes,omitempty"`
+	Sender  string   `json:"sender,omitempty"`
+	Persist int      `json:"persist,omitempty"`
+	Data    any      `json:"data,omitempty"`
+}
+
+func (e WaveEvent) HasScope(scope string) bool {
+	for _, s := range e.Scopes {
+		if s == scope {
+			return true
+		}
+	}
+	return false
+}
+
+type SubscriptionRequest struct {
+	Event     string   `json:"event"`
+	Scopes    []string `json:"scopes,omitempty"`
+	AllScopes bool     `json:"allscopes,omitempty"`
+}
\ No newline at end of file
diff --git a/tsunami/rpcclient/client.go b/tsunami/rpcclient/client.go
new file mode 100644
index 0000000000..9e8256c351
--- /dev/null
+++ b/tsunami/rpcclient/client.go
@@ -0,0 +1,43 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package rpcclient
+
+import (
+	"github.com/wavetermdev/waveterm/tsunami/rpc"
+)
+
+type EventListener struct {
+	eventHandlers map[string][]func(event *rpc.WaveEvent)
+}
+
+func MakeEventListener() *EventListener {
+	return &EventListener{
+		eventHandlers: make(map[string][]func(event *rpc.WaveEvent)),
+	}
+}
+
+func (el *EventListener) On(eventName string, handler func(event *rpc.WaveEvent)) {
+	if el.eventHandlers == nil {
+		el.eventHandlers = make(map[string][]func(event *rpc.WaveEvent))
+	}
+	el.eventHandlers[eventName] = append(el.eventHandlers[eventName], handler)
+}
+
+func (el *EventListener) Emit(eventName string, event *rpc.WaveEvent) {
+	if handlers, exists := el.eventHandlers[eventName]; exists {
+		for _, handler := range handlers {
+			handler(event)
+		}
+	}
+}
+
+type RpcClient struct {
+	EventListener *EventListener
+}
+
+func MakeRpcClient() *RpcClient {
+	return &RpcClient{
+		EventListener: MakeEventListener(),
+	}
+}
\ No newline at end of file
diff --git a/tsunami/rpcclient/rpcclient.go b/tsunami/rpcclient/rpcclient.go
new file mode 100644
index 0000000000..28096619de
--- /dev/null
+++ b/tsunami/rpcclient/rpcclient.go
@@ -0,0 +1,27 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package rpcclient
+
+import (
+	"errors"
+
+	"github.com/wavetermdev/waveterm/tsunami/rpc"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+func VDomCreateContextCommand(rpcClient *RpcClient, data vdom.VDomCreateContext, opts *rpc.RpcOpts) (rpc.ORef, error) {
+	return rpc.ORef{}, errors.New("VDomCreateContextCommand: unimplemented")
+}
+
+func WaitForRouteCommand(rpcClient *RpcClient, data rpc.CommandWaitForRouteData, opts *rpc.RpcOpts) (bool, error) {
+	return false, errors.New("WaitForRouteCommand: unimplemented")
+}
+
+func EventSubCommand(rpcClient *RpcClient, data rpc.SubscriptionRequest, opts *rpc.RpcOpts) error {
+	return errors.New("EventSubCommand: unimplemented")
+}
+
+func VDomAsyncInitiationCommand(rpcClient *RpcClient, data vdom.VDomAsyncInitiationRequest, opts *rpc.RpcOpts) error {
+	return errors.New("VDomAsyncInitiationCommand: unimplemented")
+}
\ No newline at end of file
diff --git a/tsunami/util/util.go b/tsunami/util/util.go
new file mode 100644
index 0000000000..d45e8a3881
--- /dev/null
+++ b/tsunami/util/util.go
@@ -0,0 +1,52 @@
+package util
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"runtime"
+	"runtime/debug"
+	"strings"
+)
+
+func PanicHandler(debugStr string, recoverVal any) error {
+	if recoverVal == nil {
+		return nil
+	}
+	log.Printf("[panic] in %s: %v\n", debugStr, recoverVal)
+	debug.PrintStack()
+	if err, ok := recoverVal.(error); ok {
+		return fmt.Errorf("panic in %s: %w", debugStr, err)
+	}
+	return fmt.Errorf("panic in %s: %v", debugStr, recoverVal)
+}
+
+func GetHomeDir() string {
+	homeVar, err := os.UserHomeDir()
+	if err != nil {
+		return "/"
+	}
+	return homeVar
+}
+
+func ExpandHomeDir(pathStr string) (string, error) {
+	if pathStr != "~" && !strings.HasPrefix(pathStr, "~/") && (!strings.HasPrefix(pathStr, `~\`) || runtime.GOOS != "windows") {
+		return filepath.Clean(pathStr), nil
+	}
+	homeDir := GetHomeDir()
+	if pathStr == "~" {
+		return homeDir, nil
+	}
+	expandedPath := filepath.Clean(filepath.Join(homeDir, pathStr[2:]))
+	absPath, err := filepath.Abs(filepath.Join(homeDir, expandedPath))
+	if err != nil || !strings.HasPrefix(absPath, homeDir) {
+		return "", fmt.Errorf("potential path traversal detected for path %s", pathStr)
+	}
+	return expandedPath, nil
+}
+
+func ExpandHomeDirSafe(pathStr string) string {
+	path, _ := ExpandHomeDir(pathStr)
+	return path
+}
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index f49743730b..c4f6c037f0 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -12,7 +12,7 @@ import (
 	"strings"
 	"unicode"
 
-	"tsunami/util"
+	"github.com/wavetermdev/waveterm/tsunami/util"
 )
 
 // ReactNode types = nil | string | Elem
@@ -458,7 +458,6 @@ func UseEffect(ctx context.Context, fn func() func(), deps []any) {
 	vc.Root.AddEffectWork(vc.Comp.WaveId, hookVal.Idx)
 }
 
-
 func partToElems(part any) []VDomElem {
 	if part == nil {
 		return nil
diff --git a/tsunami/vdom/vdom_html.go b/tsunami/vdom/vdom_html.go
index fa7ec8a27c..9501ca2c53 100644
--- a/tsunami/vdom/vdom_html.go
+++ b/tsunami/vdom/vdom_html.go
@@ -10,7 +10,7 @@ import (
 	"io"
 	"strings"
 
-	"tsunami/vdom/cssparser"
+	"github.com/wavetermdev/waveterm/tsunami/vdom/cssparser"
 
 	"github.com/wavetermdev/htmltoken"
 )
diff --git a/tsunami/vdom/vdom_root.go b/tsunami/vdom/vdom_root.go
index e7b5b3b984..dd2ca0ae69 100644
--- a/tsunami/vdom/vdom_root.go
+++ b/tsunami/vdom/vdom_root.go
@@ -12,7 +12,7 @@ import (
 	"strings"
 
 	"github.com/google/uuid"
-	"tsunami/util"
+	"github.com/wavetermdev/waveterm/tsunami/util"
 )
 
 const (
@@ -591,4 +591,4 @@ func chunkSlice[T any](slice []T, chunkSize int) [][]T {
 		chunks = append(chunks, slice[i:end])
 	}
 	return chunks
-}
\ No newline at end of file
+}
diff --git a/tsunami/vdom/vdom_test.go b/tsunami/vdom/vdom_test.go
index 8707f6ca4e..7ecf35facb 100644
--- a/tsunami/vdom/vdom_test.go
+++ b/tsunami/vdom/vdom_test.go
@@ -8,7 +8,7 @@ import (
 	"reflect"
 	"testing"
 
-	"tsunami/util"
+	"github.com/wavetermdev/waveterm/tsunami/util"
 )
 
 type renderContextKeyType struct{}
@@ -182,4 +182,4 @@ func TestJsonBind(t *testing.T) {
 		t.Fatalf("data3: %v\n", data3Val)
 	}
 	log.Printf("elem: %v\n", elem)
-}
\ No newline at end of file
+}

From 6398a5f698e1dd324ac8f70dc59d7c188c3ccb4f Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 10:06:48 -0700
Subject: [PATCH 003/134] refactor rpctypes (protocol messages)

---
 tsunami/app/waveapp.go           |  51 +++++------
 tsunami/app/waveappserverimpl.go |  16 ++--
 tsunami/go.mod                   |   4 +-
 tsunami/go.sum                   |   4 +-
 tsunami/rpc/types.go             |  27 ++----
 tsunami/rpcclient/rpcclient.go   |   8 +-
 tsunami/rpctypes/types.go        | 140 +++++++++++++++++++++++++++++++
 tsunami/util/util.go             |  15 ++++
 tsunami/vdom/vdom_root.go        |  75 -----------------
 tsunami/vdom/vdom_types.go       |  49 -----------
 10 files changed, 206 insertions(+), 183 deletions(-)
 create mode 100644 tsunami/rpctypes/types.go

diff --git a/tsunami/app/waveapp.go b/tsunami/app/waveapp.go
index bd43a2f826..c95d228523 100644
--- a/tsunami/app/waveapp.go
+++ b/tsunami/app/waveapp.go
@@ -22,6 +22,7 @@ import (
 	"github.com/gorilla/mux"
 	"github.com/wavetermdev/waveterm/tsunami/rpc"
 	"github.com/wavetermdev/waveterm/tsunami/rpcclient"
+	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
@@ -110,55 +111,55 @@ func MakeClient(appOpts AppOpts) *Client {
 	return client
 }
 
-func (client *Client) runMainE() error {
-	if client.SetupFn != nil {
-		client.SetupFn()
+func (c *Client) runMainE() error {
+	if c.SetupFn != nil {
+		c.SetupFn()
 	}
-	err := client.Connect()
+	err := c.Connect()
 	if err != nil {
 		return err
 	}
 	target := &vdom.VDomTarget{}
-	if client.AppOpts.TargetNewBlock || client.NewBlockFlag {
-		target.NewBlock = client.NewBlockFlag
+	if c.AppOpts.TargetNewBlock || c.NewBlockFlag {
+		target.NewBlock = c.NewBlockFlag
 	}
-	if client.AppOpts.TargetToolbar != nil {
-		target.Toolbar = client.AppOpts.TargetToolbar
+	if c.AppOpts.TargetToolbar != nil {
+		target.Toolbar = c.AppOpts.TargetToolbar
 	}
 	if target.NewBlock && target.Toolbar != nil {
 		return fmt.Errorf("cannot specify both new block and toolbar target")
 	}
-	err = client.CreateVDomContext(target)
+	err = c.CreateVDomContext(target)
 	if err != nil {
 		return err
 	}
-	<-client.DoneCh
+	<-c.DoneCh
 	return nil
 }
 
-func (client *Client) AddSetupFn(fn func()) {
-	client.SetupFn = fn
+func (c *Client) AddSetupFn(fn func()) {
+	c.SetupFn = fn
 }
 
-func (client *Client) RegisterDefaultFlags() {
-	if client.AppOpts.NewBlockFlag != "-" {
-		flag.BoolVar(&client.NewBlockFlag, client.AppOpts.NewBlockFlag, false, "new block")
+func (c *Client) RegisterDefaultFlags() {
+	if c.AppOpts.NewBlockFlag != "-" {
+		flag.BoolVar(&c.NewBlockFlag, c.AppOpts.NewBlockFlag, false, "new block")
 	}
 }
 
-func (client *Client) RunMain() {
+func (c *Client) RunMain() {
 	if !flag.Parsed() {
-		client.RegisterDefaultFlags()
+		c.RegisterDefaultFlags()
 		flag.Parse()
 	}
-	err := client.runMainE()
+	err := c.runMainE()
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 }
 
-func (client *Client) Connect() error {
+func (c *Client) Connect() error {
 	return errors.New("unimplemented")
 }
 
@@ -169,7 +170,7 @@ func (c *Client) SetRootElem(elem *vdom.VDomElem) {
 func (c *Client) CreateVDomContext(target *vdom.VDomTarget) error {
 	blockORef, err := rpcclient.VDomCreateContextCommand(
 		c.RpcClient,
-		vdom.VDomCreateContext{Target: target},
+		rpctypes.VDomCreateContext{Target: target},
 		&rpc.RpcOpts{Route: rpc.MakeFeBlockRouteId(c.RpcContext.BlockId)},
 	)
 	if err != nil {
@@ -205,7 +206,7 @@ func (c *Client) SendAsyncInitiation() error {
 	}
 	return rpcclient.VDomAsyncInitiationCommand(
 		c.RpcClient,
-		vdom.MakeAsyncInitiationRequest(c.RpcContext.BlockId),
+		rpctypes.MakeAsyncInitiationRequest(c.RpcContext.BlockId),
 		&rpc.RpcOpts{Route: rpc.MakeFeBlockRouteId(c.VDomContextBlockId)},
 	)
 }
@@ -248,14 +249,14 @@ func (c *Client) RegisterComponent(name string, cfunc any) error {
 	return c.Root.RegisterComponent(name, cfunc)
 }
 
-func (c *Client) fullRender() (*vdom.VDomBackendUpdate, error) {
+func (c *Client) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 	c.Root.RunWork()
 	c.Root.Render(c.RootElem)
 	renderedVDom := c.Root.MakeVDom()
 	if renderedVDom == nil {
 		renderedVDom = makeNullVDom()
 	}
-	return &vdom.VDomBackendUpdate{
+	return &rpctypes.VDomBackendUpdate{
 		Type:    "backendupdate",
 		Ts:      time.Now().UnixMilli(),
 		BlockId: c.RpcContext.BlockId,
@@ -269,13 +270,13 @@ func (c *Client) fullRender() (*vdom.VDomBackendUpdate, error) {
 	}, nil
 }
 
-func (c *Client) incrementalRender() (*vdom.VDomBackendUpdate, error) {
+func (c *Client) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 	c.Root.RunWork()
 	renderedVDom := c.Root.MakeVDom()
 	if renderedVDom == nil {
 		renderedVDom = makeNullVDom()
 	}
-	return &vdom.VDomBackendUpdate{
+	return &rpctypes.VDomBackendUpdate{
 		Type:    "backendupdate",
 		Ts:      time.Now().UnixMilli(),
 		BlockId: c.RpcContext.BlockId,
diff --git a/tsunami/app/waveappserverimpl.go b/tsunami/app/waveappserverimpl.go
index de057d0fba..376f7aae1d 100644
--- a/tsunami/app/waveappserverimpl.go
+++ b/tsunami/app/waveappserverimpl.go
@@ -11,8 +11,8 @@ import (
 	"net/http"
 
 	"github.com/wavetermdev/waveterm/tsunami/rpc"
+	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
-	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
 type WaveAppServerImpl struct {
@@ -22,12 +22,12 @@ type WaveAppServerImpl struct {
 
 func (*WaveAppServerImpl) WshServerImpl() {}
 
-func (impl *WaveAppServerImpl) VDomRenderCommand(ctx context.Context, feUpdate vdom.VDomFrontendUpdate) chan rpc.RespOrErrorUnion[*vdom.VDomBackendUpdate] {
-	respChan := make(chan rpc.RespOrErrorUnion[*vdom.VDomBackendUpdate], 5)
+func (impl *WaveAppServerImpl) VDomRenderCommand(ctx context.Context, feUpdate rpctypes.VDomFrontendUpdate) chan rpc.RespOrErrorUnion[*rpctypes.VDomBackendUpdate] {
+	respChan := make(chan rpc.RespOrErrorUnion[*rpctypes.VDomBackendUpdate], 5)
 	defer func() {
 		panicErr := util.PanicHandler("VDomRenderCommand", recover())
 		if panicErr != nil {
-			respChan <- rpc.RespOrErrorUnion[*vdom.VDomBackendUpdate]{
+			respChan <- rpc.RespOrErrorUnion[*rpctypes.VDomBackendUpdate]{
 				Error: panicErr,
 			}
 			close(respChan)
@@ -67,7 +67,7 @@ func (impl *WaveAppServerImpl) VDomRenderCommand(ctx context.Context, feUpdate v
 		impl.Client.Root.UpdateRef(ref)
 	}
 
-	var update *vdom.VDomBackendUpdate
+	var update *rpctypes.VDomBackendUpdate
 	var err error
 
 	if feUpdate.Resync || true {
@@ -78,7 +78,7 @@ func (impl *WaveAppServerImpl) VDomRenderCommand(ctx context.Context, feUpdate v
 	update.CreateTransferElems()
 
 	if err != nil {
-		respChan <- rpc.RespOrErrorUnion[*vdom.VDomBackendUpdate]{
+		respChan <- rpc.RespOrErrorUnion[*rpctypes.VDomBackendUpdate]{
 			Error: err,
 		}
 		close(respChan)
@@ -86,14 +86,14 @@ func (impl *WaveAppServerImpl) VDomRenderCommand(ctx context.Context, feUpdate v
 	}
 
 	// Split the update into chunks and send them sequentially
-	updates := vdom.SplitBackendUpdate(update)
+	updates := rpctypes.SplitBackendUpdate(update)
 	go func() {
 		defer func() {
 			util.PanicHandler("VDomRenderCommand:splitUpdates", recover())
 		}()
 		defer close(respChan)
 		for _, splitUpdate := range updates {
-			respChan <- rpc.RespOrErrorUnion[*vdom.VDomBackendUpdate]{
+			respChan <- rpc.RespOrErrorUnion[*rpctypes.VDomBackendUpdate]{
 				Response: splitUpdate,
 			}
 		}
diff --git a/tsunami/go.mod b/tsunami/go.mod
index 9f44097522..68aaca9c38 100644
--- a/tsunami/go.mod
+++ b/tsunami/go.mod
@@ -1,6 +1,6 @@
 module github.com/wavetermdev/waveterm/tsunami
 
-go 1.22.4
+go 1.23.0
 
 toolchain go1.24.6
 
@@ -10,4 +10,4 @@ require (
 	github.com/wavetermdev/htmltoken v0.2.0
 )
 
-require golang.org/x/net v0.27.0 // indirect
+require golang.org/x/net v0.43.0 // indirect
diff --git a/tsunami/go.sum b/tsunami/go.sum
index 87a6d9bc63..4fe0663af0 100644
--- a/tsunami/go.sum
+++ b/tsunami/go.sum
@@ -4,5 +4,5 @@ github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
 github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
 github.com/wavetermdev/htmltoken v0.2.0 h1:sFVPPemlDv7/jg7n4Hx1AEF2m9MVAFjFpELWfhi/DlM=
 github.com/wavetermdev/htmltoken v0.2.0/go.mod h1:5FM0XV6zNYiNza2iaTcFGj+hnMtgqumFHO31Z8euquk=
-golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
-golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
diff --git a/tsunami/rpc/types.go b/tsunami/rpc/types.go
index 834f0dbabf..70c46bcefd 100644
--- a/tsunami/rpc/types.go
+++ b/tsunami/rpc/types.go
@@ -3,24 +3,15 @@
 
 package rpc
 
+import (
+	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
+)
+
 type RespOrErrorUnion[T any] struct {
 	Response T
 	Error    error
 }
 
-type VDomUrlRequestData struct {
-	Method  string            `json:"method"`
-	URL     string            `json:"url"`
-	Headers map[string]string `json:"headers"`
-	Body    []byte            `json:"body,omitempty"`
-}
-
-type VDomUrlRequestResponse struct {
-	StatusCode int               `json:"statuscode,omitempty"`
-	Headers    map[string]string `json:"headers,omitempty"`
-	Body       []byte            `json:"body,omitempty"`
-}
-
 type RpcOpts struct {
 	Timeout    int64  `json:"timeout,omitempty"`
 	NoResponse bool   `json:"noresponse,omitempty"`
@@ -36,11 +27,6 @@ type RpcContext struct {
 	Conn       string `json:"conn,omitempty"`
 }
 
-type CommandWaitForRouteData struct {
-	RouteId string `json:"routeid"`
-	WaitMs  int    `json:"waitms"`
-}
-
 type ORef struct {
 	OType string `json:"otype"`
 	OID   string `json:"oid"`
@@ -49,3 +35,8 @@ type ORef struct {
 func (oref ORef) String() string {
 	return oref.OType + ":" + oref.OID
 }
+
+// Types moved to rpctypes package
+type VDomUrlRequestData = rpctypes.VDomUrlRequestData
+type VDomUrlRequestResponse = rpctypes.VDomUrlRequestResponse
+type CommandWaitForRouteData = rpctypes.CommandWaitForRouteData
diff --git a/tsunami/rpcclient/rpcclient.go b/tsunami/rpcclient/rpcclient.go
index 28096619de..da87aea1a6 100644
--- a/tsunami/rpcclient/rpcclient.go
+++ b/tsunami/rpcclient/rpcclient.go
@@ -7,10 +7,10 @@ import (
 	"errors"
 
 	"github.com/wavetermdev/waveterm/tsunami/rpc"
-	"github.com/wavetermdev/waveterm/tsunami/vdom"
+	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 )
 
-func VDomCreateContextCommand(rpcClient *RpcClient, data vdom.VDomCreateContext, opts *rpc.RpcOpts) (rpc.ORef, error) {
+func VDomCreateContextCommand(rpcClient *RpcClient, data rpctypes.VDomCreateContext, opts *rpc.RpcOpts) (rpc.ORef, error) {
 	return rpc.ORef{}, errors.New("VDomCreateContextCommand: unimplemented")
 }
 
@@ -22,6 +22,6 @@ func EventSubCommand(rpcClient *RpcClient, data rpc.SubscriptionRequest, opts *r
 	return errors.New("EventSubCommand: unimplemented")
 }
 
-func VDomAsyncInitiationCommand(rpcClient *RpcClient, data vdom.VDomAsyncInitiationRequest, opts *rpc.RpcOpts) error {
+func VDomAsyncInitiationCommand(rpcClient *RpcClient, data rpctypes.VDomAsyncInitiationRequest, opts *rpc.RpcOpts) error {
 	return errors.New("VDomAsyncInitiationCommand: unimplemented")
-}
\ No newline at end of file
+}
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
new file mode 100644
index 0000000000..b76d7e8459
--- /dev/null
+++ b/tsunami/rpctypes/types.go
@@ -0,0 +1,140 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package rpctypes
+
+import (
+	"time"
+
+	"github.com/wavetermdev/waveterm/tsunami/util"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+const (
+	BackendUpdate_InitialChunkSize = 50  // Size for initial chunks that contain both TransferElems and StateSync
+	BackendUpdate_ChunkSize        = 100 // Size for subsequent chunks
+)
+
+type VDomUrlRequestData struct {
+	Method  string            `json:"method"`
+	URL     string            `json:"url"`
+	Headers map[string]string `json:"headers"`
+	Body    []byte            `json:"body,omitempty"`
+}
+
+type VDomUrlRequestResponse struct {
+	StatusCode int               `json:"statuscode,omitempty"`
+	Headers    map[string]string `json:"headers,omitempty"`
+	Body       []byte            `json:"body,omitempty"`
+}
+
+type CommandWaitForRouteData struct {
+	RouteId string `json:"routeid"`
+	WaitMs  int    `json:"waitms"`
+}
+
+type VDomCreateContext struct {
+	Type    string           `json:"type" tstype:"\"createcontext\""`
+	Ts      int64            `json:"ts"`
+	Meta    map[string]any   `json:"meta,omitempty"`
+	Target  *vdom.VDomTarget `json:"target,omitempty"`
+	Persist bool             `json:"persist,omitempty"`
+}
+
+type VDomAsyncInitiationRequest struct {
+	Type    string `json:"type" tstype:"\"asyncinitiationrequest\""`
+	Ts      int64  `json:"ts"`
+	BlockId string `json:"blockid,omitempty"`
+}
+
+func MakeAsyncInitiationRequest(blockId string) VDomAsyncInitiationRequest {
+	return VDomAsyncInitiationRequest{
+		Type:    "asyncinitiationrequest",
+		Ts:      time.Now().UnixMilli(),
+		BlockId: blockId,
+	}
+}
+
+type VDomFrontendUpdate struct {
+	Type          string                 `json:"type" tstype:"\"frontendupdate\""`
+	Ts            int64                  `json:"ts"`
+	BlockId       string                 `json:"blockid"`
+	CorrelationId string                 `json:"correlationid,omitempty"`
+	Dispose       bool                   `json:"dispose,omitempty"` // the vdom context was closed
+	Resync        bool                   `json:"resync,omitempty"`  // resync (send all backend data).  useful when the FE reloads
+	RenderContext vdom.VDomRenderContext `json:"rendercontext,omitempty"`
+	Events        []vdom.VDomEvent       `json:"events,omitempty"`
+	StateSync     []vdom.VDomStateSync   `json:"statesync,omitempty"`
+	RefUpdates    []vdom.VDomRefUpdate   `json:"refupdates,omitempty"`
+	Messages      []vdom.VDomMessage     `json:"messages,omitempty"`
+}
+
+type VDomBackendUpdate struct {
+	Type          string                  `json:"type" tstype:"\"backendupdate\""`
+	Ts            int64                   `json:"ts"`
+	BlockId       string                  `json:"blockid"`
+	Opts          *vdom.VDomBackendOpts   `json:"opts,omitempty"`
+	HasWork       bool                    `json:"haswork,omitempty"`
+	RenderUpdates []vdom.VDomRenderUpdate `json:"renderupdates,omitempty"`
+	TransferElems []vdom.VDomTransferElem `json:"transferelems,omitempty"`
+	StateSync     []vdom.VDomStateSync    `json:"statesync,omitempty"`
+	RefOperations []vdom.VDomRefOperation   `json:"refoperations,omitempty"`
+	Messages      []vdom.VDomMessage        `json:"messages,omitempty"`
+}
+
+func (beUpdate *VDomBackendUpdate) CreateTransferElems() {
+	var allElems []vdom.VDomElem
+	for _, renderUpdate := range beUpdate.RenderUpdates {
+		if renderUpdate.VDom != nil {
+			allElems = append(allElems, *renderUpdate.VDom)
+		}
+	}
+	transferElems := vdom.ConvertElemsToTransferElems(allElems)
+	beUpdate.TransferElems = vdom.DedupTransferElems(transferElems)
+	for i := range beUpdate.RenderUpdates {
+		beUpdate.RenderUpdates[i].VDom = nil
+	}
+}
+
+func SplitBackendUpdate(update *VDomBackendUpdate) []*VDomBackendUpdate {
+	if len(update.TransferElems) <= BackendUpdate_InitialChunkSize && len(update.StateSync) <= BackendUpdate_InitialChunkSize {
+		return []*VDomBackendUpdate{update}
+	}
+
+	updates := make([]*VDomBackendUpdate, 0)
+	transferElemChunks := util.ChunkSlice(update.TransferElems, BackendUpdate_ChunkSize)
+	stateSyncChunks := util.ChunkSlice(update.StateSync, BackendUpdate_ChunkSize)
+
+	maxChunks := len(transferElemChunks)
+	if len(stateSyncChunks) > maxChunks {
+		maxChunks = len(stateSyncChunks)
+	}
+
+	for i := 0; i < maxChunks; i++ {
+		newUpdate := &VDomBackendUpdate{
+			Type:    update.Type,
+			Ts:      update.Ts,
+			BlockId: update.BlockId,
+		}
+
+		if i == 0 {
+			newUpdate.Opts = update.Opts
+			newUpdate.HasWork = update.HasWork
+			newUpdate.RenderUpdates = update.RenderUpdates
+			newUpdate.RefOperations = update.RefOperations
+			newUpdate.Messages = update.Messages
+		}
+
+		if i < len(transferElemChunks) {
+			newUpdate.TransferElems = transferElemChunks[i]
+		}
+
+		if i < len(stateSyncChunks) {
+			newUpdate.StateSync = stateSyncChunks[i]
+		}
+
+		updates = append(updates, newUpdate)
+	}
+
+	return updates
+}
diff --git a/tsunami/util/util.go b/tsunami/util/util.go
index d45e8a3881..ee2ce5ce89 100644
--- a/tsunami/util/util.go
+++ b/tsunami/util/util.go
@@ -50,3 +50,18 @@ func ExpandHomeDirSafe(pathStr string) string {
 	path, _ := ExpandHomeDir(pathStr)
 	return path
 }
+
+func ChunkSlice[T any](slice []T, chunkSize int) [][]T {
+	if len(slice) == 0 {
+		return nil
+	}
+	chunks := make([][]T, 0)
+	for i := 0; i < len(slice); i += chunkSize {
+		end := i + chunkSize
+		if end > len(slice) {
+			end = len(slice)
+		}
+		chunks = append(chunks, slice[i:end])
+	}
+	return chunks
+}
diff --git a/tsunami/vdom/vdom_root.go b/tsunami/vdom/vdom_root.go
index dd2ca0ae69..3e4a4ff45a 100644
--- a/tsunami/vdom/vdom_root.go
+++ b/tsunami/vdom/vdom_root.go
@@ -15,10 +15,6 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/util"
 )
 
-const (
-	BackendUpdate_InitialChunkSize = 50  // Size for initial chunks that contain both TransferElems and StateSync
-	BackendUpdate_ChunkSize        = 100 // Size for subsequent chunks
-)
 
 func (r *RootElem) AddRenderWork(id string) {
 	if r.NeedsRenderMap == nil {
@@ -521,74 +517,3 @@ func DedupTransferElems(elems []VDomTransferElem) []VDomTransferElem {
 	return result
 }
 
-func (beUpdate *VDomBackendUpdate) CreateTransferElems() {
-	var allElems []VDomElem
-	for _, renderUpdate := range beUpdate.RenderUpdates {
-		if renderUpdate.VDom != nil {
-			allElems = append(allElems, *renderUpdate.VDom)
-		}
-	}
-	transferElems := ConvertElemsToTransferElems(allElems)
-	beUpdate.TransferElems = DedupTransferElems(transferElems)
-	for i := range beUpdate.RenderUpdates {
-		beUpdate.RenderUpdates[i].VDom = nil
-	}
-}
-
-func SplitBackendUpdate(update *VDomBackendUpdate) []*VDomBackendUpdate {
-	if len(update.TransferElems) <= BackendUpdate_InitialChunkSize && len(update.StateSync) <= BackendUpdate_InitialChunkSize {
-		return []*VDomBackendUpdate{update}
-	}
-
-	updates := make([]*VDomBackendUpdate, 0)
-	transferElemChunks := chunkSlice(update.TransferElems, BackendUpdate_ChunkSize)
-	stateSyncChunks := chunkSlice(update.StateSync, BackendUpdate_ChunkSize)
-
-	maxChunks := len(transferElemChunks)
-	if len(stateSyncChunks) > maxChunks {
-		maxChunks = len(stateSyncChunks)
-	}
-
-	for i := 0; i < maxChunks; i++ {
-		newUpdate := &VDomBackendUpdate{
-			Type:    update.Type,
-			Ts:      update.Ts,
-			BlockId: update.BlockId,
-		}
-
-		if i == 0 {
-			newUpdate.Opts = update.Opts
-			newUpdate.HasWork = update.HasWork
-			newUpdate.RenderUpdates = update.RenderUpdates
-			newUpdate.RefOperations = update.RefOperations
-			newUpdate.Messages = update.Messages
-		}
-
-		if i < len(transferElemChunks) {
-			newUpdate.TransferElems = transferElemChunks[i]
-		}
-
-		if i < len(stateSyncChunks) {
-			newUpdate.StateSync = stateSyncChunks[i]
-		}
-
-		updates = append(updates, newUpdate)
-	}
-
-	return updates
-}
-
-func chunkSlice[T any](slice []T, chunkSize int) [][]T {
-	if len(slice) == 0 {
-		return nil
-	}
-	chunks := make([][]T, 0)
-	for i := 0; i < len(slice); i += chunkSize {
-		end := i + chunkSize
-		if end > len(slice) {
-			end = len(slice)
-		}
-		chunks = append(chunks, slice[i:end])
-	}
-	return chunks
-}
diff --git a/tsunami/vdom/vdom_types.go b/tsunami/vdom/vdom_types.go
index a920185e0f..54d849d621 100644
--- a/tsunami/vdom/vdom_types.go
+++ b/tsunami/vdom/vdom_types.go
@@ -5,7 +5,6 @@ package vdom
 
 import (
 	"context"
-	"time"
 )
 
 const TextTag = "#text"
@@ -89,54 +88,6 @@ type VDomTransferElem struct {
 
 //// protocol messages
 
-type VDomCreateContext struct {
-	Type    string         `json:"type" tstype:"\"createcontext\""`
-	Ts      int64          `json:"ts"`
-	Meta    map[string]any `json:"meta,omitempty"`
-	Target  *VDomTarget    `json:"target,omitempty"`
-	Persist bool           `json:"persist,omitempty"`
-}
-
-type VDomAsyncInitiationRequest struct {
-	Type    string `json:"type" tstype:"\"asyncinitiationrequest\""`
-	Ts      int64  `json:"ts"`
-	BlockId string `json:"blockid,omitempty"`
-}
-
-func MakeAsyncInitiationRequest(blockId string) VDomAsyncInitiationRequest {
-	return VDomAsyncInitiationRequest{
-		Type:    "asyncinitiationrequest",
-		Ts:      time.Now().UnixMilli(),
-		BlockId: blockId,
-	}
-}
-
-type VDomFrontendUpdate struct {
-	Type          string            `json:"type" tstype:"\"frontendupdate\""`
-	Ts            int64             `json:"ts"`
-	BlockId       string            `json:"blockid"`
-	CorrelationId string            `json:"correlationid,omitempty"`
-	Dispose       bool              `json:"dispose,omitempty"` // the vdom context was closed
-	Resync        bool              `json:"resync,omitempty"`  // resync (send all backend data).  useful when the FE reloads
-	RenderContext VDomRenderContext `json:"rendercontext,omitempty"`
-	Events        []VDomEvent       `json:"events,omitempty"`
-	StateSync     []VDomStateSync   `json:"statesync,omitempty"`
-	RefUpdates    []VDomRefUpdate   `json:"refupdates,omitempty"`
-	Messages      []VDomMessage     `json:"messages,omitempty"`
-}
-
-type VDomBackendUpdate struct {
-	Type          string             `json:"type" tstype:"\"backendupdate\""`
-	Ts            int64              `json:"ts"`
-	BlockId       string             `json:"blockid"`
-	Opts          *VDomBackendOpts   `json:"opts,omitempty"`
-	HasWork       bool               `json:"haswork,omitempty"`
-	RenderUpdates []VDomRenderUpdate `json:"renderupdates,omitempty"`
-	TransferElems []VDomTransferElem `json:"transferelems,omitempty"`
-	StateSync     []VDomStateSync    `json:"statesync,omitempty"`
-	RefOperations []VDomRefOperation `json:"refoperations,omitempty"`
-	Messages      []VDomMessage      `json:"messages,omitempty"`
-}
 
 ///// prop types
 

From 819f3ab584d62fe14b1e9ee072748a2eb2a2b802 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 12:03:29 -0700
Subject: [PATCH 004/134] moved componentimpl and rootelem to the comp pkg

---
 tsunami/app/waveapp.go                        |  23 +-
 tsunami/{vdom/vdom_comp.go => comp/comp.go}   |  10 +-
 tsunami/comp/root_test.go                     |  99 +++++++
 .../{vdom/vdom_root.go => comp/rootelem.go}   | 161 ++++++-----
 tsunami/comp/vdomcontext.go                   |  54 ++++
 tsunami/rpctypes/types.go                     | 261 ++++++++++++++++--
 tsunami/vdom/vdom.go                          |  90 +++---
 tsunami/vdom/vdom_context.go                  |  36 +++
 tsunami/vdom/vdom_html.go                     |   2 +-
 tsunami/vdom/vdom_test.go                     |  86 ------
 tsunami/vdom/vdom_types.go                    | 168 -----------
 11 files changed, 553 insertions(+), 437 deletions(-)
 rename tsunami/{vdom/vdom_comp.go => comp/comp.go} (85%)
 create mode 100644 tsunami/comp/root_test.go
 rename tsunami/{vdom/vdom_root.go => comp/rootelem.go} (75%)
 create mode 100644 tsunami/comp/vdomcontext.go
 create mode 100644 tsunami/vdom/vdom_context.go

diff --git a/tsunami/app/waveapp.go b/tsunami/app/waveapp.go
index c95d228523..fd0d995ca3 100644
--- a/tsunami/app/waveapp.go
+++ b/tsunami/app/waveapp.go
@@ -20,6 +20,7 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
+	"github.com/wavetermdev/waveterm/tsunami/comp"
 	"github.com/wavetermdev/waveterm/tsunami/rpc"
 	"github.com/wavetermdev/waveterm/tsunami/rpcclient"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
@@ -34,13 +35,13 @@ type AppOpts struct {
 	RootComponentName    string // defaults to "App"
 	NewBlockFlag         string // defaults to "n" (set to "-" to disable)
 	TargetNewBlock       bool
-	TargetToolbar        *vdom.VDomTargetToolbar
+	TargetToolbar        *rpctypes.VDomTargetToolbar
 }
 
 type Client struct {
 	Lock               *sync.Mutex
 	AppOpts            AppOpts
-	Root               *vdom.RootElem
+	Root               *comp.RootElem
 	RootElem           *vdom.VDomElem
 	RpcClient          *rpcclient.RpcClient
 	RpcContext         *rpc.RpcContext
@@ -50,8 +51,8 @@ type Client struct {
 	VDomContextBlockId string
 	DoneReason         string
 	DoneCh             chan struct{}
-	Opts               vdom.VDomBackendOpts
-	GlobalEventHandler func(client *Client, event vdom.VDomEvent)
+	Opts               rpctypes.VDomBackendOpts
+	GlobalEventHandler func(client *Client, event rpctypes.VDomEvent)
 	GlobalStylesOption *FileHandlerOption
 	UrlHandlerMux      *mux.Router
 	OverrideUrlHandler http.Handler
@@ -76,7 +77,7 @@ func (c *Client) doShutdown(reason string) {
 	close(c.DoneCh)
 }
 
-func (c *Client) SetGlobalEventHandler(handler func(client *Client, event vdom.VDomEvent)) {
+func (c *Client) SetGlobalEventHandler(handler func(client *Client, event rpctypes.VDomEvent)) {
 	c.GlobalEventHandler = handler
 }
 
@@ -94,11 +95,11 @@ func MakeClient(appOpts AppOpts) *Client {
 	client := &Client{
 		Lock:          &sync.Mutex{},
 		AppOpts:       appOpts,
-		Root:          vdom.MakeRoot(),
+		Root:          comp.MakeRoot(),
 		RpcClient:     rpcclient.MakeRpcClient(),
 		DoneCh:        make(chan struct{}),
 		UrlHandlerMux: mux.NewRouter(),
-		Opts: vdom.VDomBackendOpts{
+		Opts: rpctypes.VDomBackendOpts{
 			CloseOnCtrlC:         appOpts.CloseOnCtrlC,
 			GlobalKeyboardEvents: appOpts.GlobalKeyboardEvents,
 		},
@@ -119,7 +120,7 @@ func (c *Client) runMainE() error {
 	if err != nil {
 		return err
 	}
-	target := &vdom.VDomTarget{}
+	target := &rpctypes.VDomTarget{}
 	if c.AppOpts.TargetNewBlock || c.NewBlockFlag {
 		target.NewBlock = c.NewBlockFlag
 	}
@@ -167,7 +168,7 @@ func (c *Client) SetRootElem(elem *vdom.VDomElem) {
 	c.RootElem = elem
 }
 
-func (c *Client) CreateVDomContext(target *vdom.VDomTarget) error {
+func (c *Client) CreateVDomContext(target *rpctypes.VDomTarget) error {
 	blockORef, err := rpcclient.VDomCreateContextCommand(
 		c.RpcClient,
 		rpctypes.VDomCreateContext{Target: target},
@@ -262,7 +263,7 @@ func (c *Client) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 		BlockId: c.RpcContext.BlockId,
 		HasWork: len(c.Root.EffectWorkQueue) > 0,
 		Opts:    &c.Opts,
-		RenderUpdates: []vdom.VDomRenderUpdate{
+		RenderUpdates: []rpctypes.VDomRenderUpdate{
 			{UpdateType: "root", VDom: renderedVDom},
 		},
 		RefOperations: c.Root.GetRefOperations(),
@@ -280,7 +281,7 @@ func (c *Client) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 		Type:    "backendupdate",
 		Ts:      time.Now().UnixMilli(),
 		BlockId: c.RpcContext.BlockId,
-		RenderUpdates: []vdom.VDomRenderUpdate{
+		RenderUpdates: []rpctypes.VDomRenderUpdate{
 			{UpdateType: "root", VDom: renderedVDom},
 		},
 		RefOperations: c.Root.GetRefOperations(),
diff --git a/tsunami/vdom/vdom_comp.go b/tsunami/comp/comp.go
similarity index 85%
rename from tsunami/vdom/vdom_comp.go
rename to tsunami/comp/comp.go
index 37b973951f..07d16c8985 100644
--- a/tsunami/vdom/vdom_comp.go
+++ b/tsunami/comp/comp.go
@@ -1,7 +1,9 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package vdom
+package comp
+
+import "github.com/wavetermdev/waveterm/tsunami/vdom"
 
 // so components either render to another component (or fragment)
 // or to a base element (text or vdom).  base elements can then render children
@@ -16,11 +18,11 @@ type ComponentImpl struct {
 	WaveId  string
 	Tag     string
 	Key     string
-	Elem    *VDomElem
+	Elem    *vdom.VDomElem
 	Mounted bool
 
 	// hooks
-	Hooks []*Hook
+	Hooks []*vdom.Hook
 
 	// #text component
 	Text string
@@ -37,4 +39,4 @@ func (c *ComponentImpl) compMatch(tag string, key string) bool {
 		return false
 	}
 	return c.Tag == tag && c.Key == key
-}
\ No newline at end of file
+}
diff --git a/tsunami/comp/root_test.go b/tsunami/comp/root_test.go
new file mode 100644
index 0000000000..30f57ccacf
--- /dev/null
+++ b/tsunami/comp/root_test.go
@@ -0,0 +1,99 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package comp
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"testing"
+
+	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+type renderContextKeyType struct{}
+
+var renderContextKey = renderContextKeyType{}
+
+type TestContext struct {
+	ButtonId string
+}
+
+func Page(ctx context.Context, props map[string]any) any {
+	clicked, setClicked := vdom.UseState(ctx, false)
+	var clickedDiv *vdom.VDomElem
+	if clicked {
+		clickedDiv = vdom.Bind(`<div>clicked</div>`, nil)
+	}
+	clickFn := func() {
+		log.Printf("run clickFn\n")
+		setClicked(true)
+	}
+	return vdom.Bind(
+		`
+<div>
+    <h1>hello world</h1>
+	<Button onClick="#param:clickFn">hello</Button>
+	<bindparam key="clickedDiv"/>
+</div>
+`,
+		map[string]any{"clickFn": clickFn, "clickedDiv": clickedDiv},
+	)
+}
+
+func Button(ctx context.Context, props map[string]any) any {
+	ref := vdom.UseVDomRef(ctx)
+	clName, setClName := vdom.UseState(ctx, "button")
+	vdom.UseEffect(ctx, func() func() {
+		fmt.Printf("Button useEffect\n")
+		setClName("button mounted")
+		return nil
+	}, nil)
+	compId := vdom.UseId(ctx)
+	testContext := getTestContext(ctx)
+	if testContext != nil {
+		testContext.ButtonId = compId
+	}
+	return vdom.Bind(`
+		<div className="#param:clName" ref="#param:ref" onClick="#param:onClick">
+			<bindparam key="children"/>
+		</div>
+	`, map[string]any{"clName": clName, "ref": ref, "onClick": props["onClick"], "children": props["children"]})
+}
+
+func printVDom(root *RootElem) {
+	vd := root.MakeVDom()
+	jsonBytes, _ := json.MarshalIndent(vd, "", "  ")
+	fmt.Printf("%s\n", string(jsonBytes))
+}
+
+func getTestContext(ctx context.Context) *TestContext {
+	val := ctx.Value(renderContextKey)
+	if val == nil {
+		return nil
+	}
+	return val.(*TestContext)
+}
+
+func Test1(t *testing.T) {
+	log.Printf("hello!\n")
+	testContext := &TestContext{ButtonId: ""}
+	ctx := context.WithValue(context.Background(), renderContextKey, testContext)
+	root := MakeRoot()
+	root.SetOuterCtx(ctx)
+	root.RegisterComponent("Page", Page)
+	root.RegisterComponent("Button", Button)
+	root.Render(vdom.E("Page"))
+	if root.Root == nil {
+		t.Fatalf("root.Root is nil")
+	}
+	printVDom(root)
+	root.RunWork()
+	printVDom(root)
+	root.Event(testContext.ButtonId, "onClick", rpctypes.VDomEvent{EventType: "onClick"})
+	root.RunWork()
+	printVDom(root)
+}
diff --git a/tsunami/vdom/vdom_root.go b/tsunami/comp/rootelem.go
similarity index 75%
rename from tsunami/vdom/vdom_root.go
rename to tsunami/comp/rootelem.go
index 3e4a4ff45a..04b7ab6dcb 100644
--- a/tsunami/vdom/vdom_root.go
+++ b/tsunami/comp/rootelem.go
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package vdom
+package comp
 
 import (
 	"context"
@@ -12,9 +12,22 @@ import (
 	"strings"
 
 	"github.com/google/uuid"
+	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
+type RootElem struct {
+	OuterCtx        context.Context
+	Root            *ComponentImpl
+	RenderTs        int64
+	CFuncs          map[string]any
+	CompMap         map[string]*ComponentImpl // component waveid -> component
+	EffectWorkQueue []*vdom.EffectWorkElem
+	NeedsRenderMap  map[string]bool
+	Atoms           map[string]*vdom.Atom
+	RefOperations   []rpctypes.VDomRefOperation
+}
 
 func (r *RootElem) AddRenderWork(id string) {
 	if r.NeedsRenderMap == nil {
@@ -24,7 +37,7 @@ func (r *RootElem) AddRenderWork(id string) {
 }
 
 func (r *RootElem) AddEffectWork(id string, effectIndex int) {
-	r.EffectWorkQueue = append(r.EffectWorkQueue, &EffectWorkElem{Id: id, EffectIndex: effectIndex})
+	r.EffectWorkQueue = append(r.EffectWorkQueue, &vdom.EffectWorkElem{Id: id, EffectIndex: effectIndex})
 }
 
 func MakeRoot() *RootElem {
@@ -32,14 +45,14 @@ func MakeRoot() *RootElem {
 		Root:    nil,
 		CFuncs:  make(map[string]any),
 		CompMap: make(map[string]*ComponentImpl),
-		Atoms:   make(map[string]*Atom),
+		Atoms:   make(map[string]*vdom.Atom),
 	}
 }
 
-func (r *RootElem) GetAtom(name string) *Atom {
+func (r *RootElem) GetAtom(name string) *vdom.Atom {
 	atom, ok := r.Atoms[name]
 	if !ok {
-		atom = &Atom{UsedBy: make(map[string]bool)}
+		atom = &vdom.Atom{UsedBy: make(map[string]bool)}
 		r.Atoms[name] = atom
 	}
 	return atom
@@ -50,11 +63,11 @@ func (r *RootElem) GetAtomVal(name string) any {
 	return atom.Val
 }
 
-func (r *RootElem) GetStateSync(full bool) []VDomStateSync {
-	stateSync := make([]VDomStateSync, 0)
+func (r *RootElem) GetStateSync(full bool) []rpctypes.VDomStateSync {
+	stateSync := make([]rpctypes.VDomStateSync, 0)
 	for atomName, atom := range r.Atoms {
 		if atom.Dirty || full {
-			stateSync = append(stateSync, VDomStateSync{Atom: atomName, Value: atom.Val})
+			stateSync = append(stateSync, rpctypes.VDomStateSync{Atom: atomName, Value: atom.Val})
 			atom.Dirty = false
 		}
 	}
@@ -123,35 +136,16 @@ func (r *RootElem) RegisterComponent(name string, cfunc any) error {
 	return nil
 }
 
-func (r *RootElem) Render(elem *VDomElem) {
+func (r *RootElem) Render(elem *vdom.VDomElem) {
 	r.render(elem, &r.Root)
 }
 
-func (vdf *VDomFunc) CallFn(event VDomEvent) {
-	if vdf.Fn == nil {
-		return
-	}
-	rval := reflect.ValueOf(vdf.Fn)
-	if rval.Kind() != reflect.Func {
-		return
-	}
-	rtype := rval.Type()
-	if rtype.NumIn() == 0 {
-		rval.Call(nil)
-	}
-	if rtype.NumIn() == 1 {
-		if rtype.In(0) == reflect.TypeOf((*VDomEvent)(nil)).Elem() {
-			rval.Call([]reflect.Value{reflect.ValueOf(event)})
-		}
-	}
-}
-
-func callVDomFn(fnVal any, data VDomEvent) {
+func callVDomFn(fnVal any, data rpctypes.VDomEvent) {
 	if fnVal == nil {
 		return
 	}
 	fn := fnVal
-	if vdf, ok := fnVal.(*VDomFunc); ok {
+	if vdf, ok := fnVal.(*vdom.VDomFunc); ok {
 		fn = vdf.Fn
 	}
 	if fn == nil {
@@ -172,7 +166,7 @@ func callVDomFn(fnVal any, data VDomEvent) {
 	}
 }
 
-func (r *RootElem) Event(id string, propName string, event VDomEvent) {
+func (r *RootElem) Event(id string, propName string, event rpctypes.VDomEvent) {
 	comp := r.CompMap[id]
 	if comp == nil || comp.Elem == nil {
 		return
@@ -215,7 +209,7 @@ func (r *RootElem) RunWork() {
 	}
 }
 
-func (r *RootElem) render(elem *VDomElem, comp **ComponentImpl) {
+func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl) {
 	if elem == nil || elem.Tag == "" {
 		r.unmount(comp)
 		return
@@ -226,11 +220,11 @@ func (r *RootElem) render(elem *VDomElem, comp **ComponentImpl) {
 		r.createComp(elem.Tag, elemKey, comp)
 	}
 	(*comp).Elem = elem
-	if elem.Tag == TextTag {
+	if elem.Tag == vdom.TextTag {
 		r.renderText(elem.Text, comp)
 		return
 	}
-	if isBaseTag(elem.Tag) {
+	if vdom.IsBaseTag(elem.Tag) {
 		// simple vdom, fragment, wave element
 		r.renderSimple(elem, comp)
 		return
@@ -278,7 +272,7 @@ func (r *RootElem) renderText(text string, comp **ComponentImpl) {
 	}
 }
 
-func (r *RootElem) renderChildren(elems []VDomElem, curChildren []*ComponentImpl) []*ComponentImpl {
+func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*ComponentImpl) []*ComponentImpl {
 	newChildren := make([]*ComponentImpl, len(elems))
 	curCM := make(map[ChildKey]*ComponentImpl)
 	usedMap := make(map[*ComponentImpl]bool)
@@ -309,32 +303,13 @@ func (r *RootElem) renderChildren(elems []VDomElem, curChildren []*ComponentImpl
 	return newChildren
 }
 
-func (r *RootElem) renderSimple(elem *VDomElem, comp **ComponentImpl) {
+func (r *RootElem) renderSimple(elem *vdom.VDomElem, comp **ComponentImpl) {
 	if (*comp).Comp != nil {
 		r.unmount(&(*comp).Comp)
 	}
 	(*comp).Children = r.renderChildren(elem.Children, (*comp).Children)
 }
 
-func (r *RootElem) makeRenderContext(comp *ComponentImpl) context.Context {
-	var ctx context.Context
-	if r.OuterCtx != nil {
-		ctx = r.OuterCtx
-	} else {
-		ctx = context.Background()
-	}
-	ctx = context.WithValue(ctx, vdomContextKey, &VDomContextVal{Root: r, Comp: comp, HookIdx: 0})
-	return ctx
-}
-
-func getRenderContext(ctx context.Context) *VDomContextVal {
-	v := ctx.Value(vdomContextKey)
-	if v == nil {
-		return nil
-	}
-	return v.(*VDomContextVal)
-}
-
 func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
 	rval := reflect.ValueOf(cfunc)
 	arg2Type := rval.Type().In(1)
@@ -362,7 +337,7 @@ func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
 	return rtnVal[0].Interface()
 }
 
-func (r *RootElem) renderComponent(cfunc any, elem *VDomElem, comp **ComponentImpl) {
+func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **ComponentImpl) {
 	if (*comp).Children != nil {
 		for _, child := range (*comp).Children {
 			r.unmount(&child)
@@ -373,24 +348,25 @@ func (r *RootElem) renderComponent(cfunc any, elem *VDomElem, comp **ComponentIm
 	for k, v := range elem.Props {
 		props[k] = v
 	}
-	props[ChildrenPropKey] = elem.Children
-	ctx := r.makeRenderContext(*comp)
+	props[vdom.ChildrenPropKey] = elem.Children
+	vc := MakeContextVal(r, *comp)
+	ctx := vdom.WithRenderContext(r.OuterCtx, vc)
 	renderedElem := callCFunc(cfunc, ctx, props)
-	rtnElemArr := partToElems(renderedElem)
+	rtnElemArr := vdom.PartToElems(renderedElem)
 	if len(rtnElemArr) == 0 {
 		r.unmount(&(*comp).Comp)
 		return
 	}
-	var rtnElem *VDomElem
+	var rtnElem *vdom.VDomElem
 	if len(rtnElemArr) == 1 {
 		rtnElem = &rtnElemArr[0]
 	} else {
-		rtnElem = &VDomElem{Tag: FragmentTag, Children: rtnElemArr}
+		rtnElem = &vdom.VDomElem{Tag: vdom.FragmentTag, Children: rtnElemArr}
 	}
 	r.render(rtnElem, &(*comp).Comp)
 }
 
-func (r *RootElem) UpdateRef(updateRef VDomRefUpdate) {
+func (r *RootElem) UpdateRef(updateRef rpctypes.VDomRefUpdate) {
 	refId := updateRef.RefId
 	split := strings.SplitN(refId, ":", 2)
 	if len(split) != 2 {
@@ -414,7 +390,7 @@ func (r *RootElem) UpdateRef(updateRef VDomRefUpdate) {
 	if hook == nil {
 		return
 	}
-	ref, ok := hook.Val.(*VDomRef)
+	ref, ok := hook.Val.(*vdom.VDomRef)
 	if !ok {
 		return
 	}
@@ -423,11 +399,11 @@ func (r *RootElem) UpdateRef(updateRef VDomRefUpdate) {
 	r.AddRenderWork(waveId)
 }
 
-func (r *RootElem) QueueRefOp(op VDomRefOperation) {
+func (r *RootElem) QueueRefOp(op rpctypes.VDomRefOperation) {
 	r.RefOperations = append(r.RefOperations, op)
 }
 
-func (r *RootElem) GetRefOperations() []VDomRefOperation {
+func (r *RootElem) GetRefOperations() []rpctypes.VDomRefOperation {
 	ops := r.RefOperations
 	r.RefOperations = nil
 	return ops
@@ -444,7 +420,7 @@ func convertPropsToVDom(props map[string]any) map[string]any {
 		}
 		val := reflect.ValueOf(v)
 		if val.Kind() == reflect.Func {
-			vdomProps[k] = VDomFunc{Type: ObjectType_Func}
+			vdomProps[k] = vdom.VDomFunc{Type: vdom.ObjectType_Func}
 			continue
 		}
 		vdomProps[k] = v
@@ -452,8 +428,8 @@ func convertPropsToVDom(props map[string]any) map[string]any {
 	return vdomProps
 }
 
-func convertBaseToVDom(c *ComponentImpl) *VDomElem {
-	elem := &VDomElem{WaveId: c.WaveId, Tag: c.Tag}
+func convertBaseToVDom(c *ComponentImpl) *vdom.VDomElem {
+	elem := &vdom.VDomElem{WaveId: c.WaveId, Tag: c.Tag}
 	if c.Elem != nil {
 		elem.Props = convertPropsToVDom(c.Elem.Props)
 	}
@@ -463,13 +439,13 @@ func convertBaseToVDom(c *ComponentImpl) *VDomElem {
 			elem.Children = append(elem.Children, *childElem)
 		}
 	}
-	if c.Tag == TextTag {
+	if c.Tag == vdom.TextTag {
 		elem.Text = c.Text
 	}
 	return elem
 }
 
-func convertCompToVDom(c *ComponentImpl) *VDomElem {
+func convertCompToVDom(c *ComponentImpl) *vdom.VDomElem {
 	if c == nil {
 		return nil
 	}
@@ -479,17 +455,17 @@ func convertCompToVDom(c *ComponentImpl) *VDomElem {
 	return convertBaseToVDom(c)
 }
 
-func (r *RootElem) MakeVDom() *VDomElem {
+func (r *RootElem) MakeVDom() *vdom.VDomElem {
 	if r.Root == nil {
 		return nil
 	}
 	return convertCompToVDom(r.Root)
 }
 
-func ConvertElemsToTransferElems(elems []VDomElem) []VDomTransferElem {
-	transferElems := make([]VDomTransferElem, 0)
+func ConvertElemsToTransferElems(elems []vdom.VDomElem) []rpctypes.VDomTransferElem {
+	transferElems := make([]rpctypes.VDomTransferElem, 0)
 	for _, elem := range elems {
-		transferElem := VDomTransferElem{
+		transferElem := rpctypes.VDomTransferElem{
 			WaveId: elem.WaveId,
 			Tag:    elem.Tag,
 			Props:  elem.Props,
@@ -505,15 +481,36 @@ func ConvertElemsToTransferElems(elems []VDomElem) []VDomTransferElem {
 	return transferElems
 }
 
-func DedupTransferElems(elems []VDomTransferElem) []VDomTransferElem {
-	seen := make(map[string]bool)
-	result := make([]VDomTransferElem, 0)
-	for _, elem := range elems {
-		if !seen[elem.WaveId] {
-			seen[elem.WaveId] = true
-			result = append(result, elem)
+func VDomFuncCallFn(vdf *vdom.VDomFunc, event rpctypes.VDomEvent) {
+	if vdf.Fn == nil {
+		return
+	}
+	rval := reflect.ValueOf(vdf.Fn)
+	if rval.Kind() != reflect.Func {
+		return
+	}
+	rtype := rval.Type()
+	if rtype.NumIn() == 0 {
+		rval.Call(nil)
+	}
+	if rtype.NumIn() == 1 {
+		if rtype.In(0) == reflect.TypeOf((*rpctypes.VDomEvent)(nil)).Elem() {
+			rval.Call([]reflect.Value{reflect.ValueOf(event)})
 		}
 	}
-	return result
 }
 
+func QueueRefOp(ctx context.Context, ref *vdom.VDomRef, op rpctypes.VDomRefOperation) {
+	if ref == nil || !ref.HasCurrent {
+		return
+	}
+	vcIf := vdom.GetRenderContext(ctx)
+	if vcIf == nil {
+		panic("QueueRefOp must be called within a component (no context)")
+	}
+	vc := vcIf.(*VDomContextVal)
+	if op.RefId == "" {
+		op.RefId = ref.RefId
+	}
+	vc.Root.QueueRefOp(op)
+}
diff --git a/tsunami/comp/vdomcontext.go b/tsunami/comp/vdomcontext.go
new file mode 100644
index 0000000000..63063951db
--- /dev/null
+++ b/tsunami/comp/vdomcontext.go
@@ -0,0 +1,54 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package comp
+
+import "github.com/wavetermdev/waveterm/tsunami/vdom"
+
+type VDomContextVal struct {
+	Root    *RootElem
+	Comp    *ComponentImpl
+	HookIdx int
+}
+
+func MakeContextVal(root *RootElem, comp *ComponentImpl) *VDomContextVal {
+	return &VDomContextVal{Root: root, Comp: comp, HookIdx: 0}
+}
+
+// Compile-time check to ensure VDomContextVal implements vdom.VDomContext
+var _ vdom.VDomContext = (*VDomContextVal)(nil)
+
+func (vc *VDomContextVal) AddRenderWork(id string) {
+	vc.Root.AddRenderWork(id)
+}
+
+func (vc *VDomContextVal) AddEffectWork(id string, effectIndex int) {
+	vc.Root.AddEffectWork(id, effectIndex)
+}
+
+func (vc *VDomContextVal) GetAtom(atomName string) *vdom.Atom {
+	return vc.Root.GetAtom(atomName)
+}
+
+func (vc *VDomContextVal) GetRenderTs() int64 {
+	return vc.Root.RenderTs
+}
+
+func (vc *VDomContextVal) GetCompWaveId() string {
+	if vc.Comp == nil {
+		return ""
+	}
+	return vc.Comp.WaveId
+}
+
+func (vc *VDomContextVal) GetOrderedHook() *vdom.Hook {
+	if vc.Comp == nil {
+		panic("tsunami hooks must be called within a component (vc.Comp is nil)")
+	}
+	for len(vc.Comp.Hooks) <= vc.HookIdx {
+		vc.Comp.Hooks = append(vc.Comp.Hooks, &vdom.Hook{Idx: len(vc.Comp.Hooks)})
+	}
+	hookVal := vc.Comp.Hooks[vc.HookIdx]
+	vc.HookIdx++
+	return hookVal
+}
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
index b76d7e8459..f578cba04e 100644
--- a/tsunami/rpctypes/types.go
+++ b/tsunami/rpctypes/types.go
@@ -4,6 +4,7 @@
 package rpctypes
 
 import (
+	"fmt"
 	"time"
 
 	"github.com/wavetermdev/waveterm/tsunami/util"
@@ -34,11 +35,11 @@ type CommandWaitForRouteData struct {
 }
 
 type VDomCreateContext struct {
-	Type    string           `json:"type" tstype:"\"createcontext\""`
-	Ts      int64            `json:"ts"`
-	Meta    map[string]any   `json:"meta,omitempty"`
-	Target  *vdom.VDomTarget `json:"target,omitempty"`
-	Persist bool             `json:"persist,omitempty"`
+	Type    string         `json:"type" tstype:"\"createcontext\""`
+	Ts      int64          `json:"ts"`
+	Meta    map[string]any `json:"meta,omitempty"`
+	Target  *VDomTarget    `json:"target,omitempty"`
+	Persist bool           `json:"persist,omitempty"`
 }
 
 type VDomAsyncInitiationRequest struct {
@@ -56,30 +57,39 @@ func MakeAsyncInitiationRequest(blockId string) VDomAsyncInitiationRequest {
 }
 
 type VDomFrontendUpdate struct {
-	Type          string                 `json:"type" tstype:"\"frontendupdate\""`
-	Ts            int64                  `json:"ts"`
-	BlockId       string                 `json:"blockid"`
-	CorrelationId string                 `json:"correlationid,omitempty"`
-	Dispose       bool                   `json:"dispose,omitempty"` // the vdom context was closed
-	Resync        bool                   `json:"resync,omitempty"`  // resync (send all backend data).  useful when the FE reloads
-	RenderContext vdom.VDomRenderContext `json:"rendercontext,omitempty"`
-	Events        []vdom.VDomEvent       `json:"events,omitempty"`
-	StateSync     []vdom.VDomStateSync   `json:"statesync,omitempty"`
-	RefUpdates    []vdom.VDomRefUpdate   `json:"refupdates,omitempty"`
-	Messages      []vdom.VDomMessage     `json:"messages,omitempty"`
+	Type          string            `json:"type" tstype:"\"frontendupdate\""`
+	Ts            int64             `json:"ts"`
+	BlockId       string            `json:"blockid"`
+	CorrelationId string            `json:"correlationid,omitempty"`
+	Dispose       bool              `json:"dispose,omitempty"` // the vdom context was closed
+	Resync        bool              `json:"resync,omitempty"`  // resync (send all backend data).  useful when the FE reloads
+	RenderContext VDomRenderContext `json:"rendercontext,omitempty"`
+	Events        []VDomEvent       `json:"events,omitempty"`
+	StateSync     []VDomStateSync   `json:"statesync,omitempty"`
+	RefUpdates    []VDomRefUpdate   `json:"refupdates,omitempty"`
+	Messages      []VDomMessage     `json:"messages,omitempty"`
 }
 
 type VDomBackendUpdate struct {
-	Type          string                  `json:"type" tstype:"\"backendupdate\""`
-	Ts            int64                   `json:"ts"`
-	BlockId       string                  `json:"blockid"`
-	Opts          *vdom.VDomBackendOpts   `json:"opts,omitempty"`
-	HasWork       bool                    `json:"haswork,omitempty"`
-	RenderUpdates []vdom.VDomRenderUpdate `json:"renderupdates,omitempty"`
-	TransferElems []vdom.VDomTransferElem `json:"transferelems,omitempty"`
-	StateSync     []vdom.VDomStateSync    `json:"statesync,omitempty"`
-	RefOperations []vdom.VDomRefOperation   `json:"refoperations,omitempty"`
-	Messages      []vdom.VDomMessage        `json:"messages,omitempty"`
+	Type          string             `json:"type" tstype:"\"backendupdate\""`
+	Ts            int64              `json:"ts"`
+	BlockId       string             `json:"blockid"`
+	Opts          *VDomBackendOpts   `json:"opts,omitempty"`
+	HasWork       bool               `json:"haswork,omitempty"`
+	RenderUpdates []VDomRenderUpdate `json:"renderupdates,omitempty"`
+	TransferElems []VDomTransferElem `json:"transferelems,omitempty"`
+	StateSync     []VDomStateSync    `json:"statesync,omitempty"`
+	RefOperations []VDomRefOperation `json:"refoperations,omitempty"`
+	Messages      []VDomMessage      `json:"messages,omitempty"`
+}
+
+// the over the wire format for a vdom element
+type VDomTransferElem struct {
+	WaveId   string         `json:"waveid,omitempty"` // required, except for #text nodes
+	Tag      string         `json:"tag"`
+	Props    map[string]any `json:"props,omitempty"`
+	Children []string       `json:"children,omitempty"`
+	Text     string         `json:"text,omitempty"`
 }
 
 func (beUpdate *VDomBackendUpdate) CreateTransferElems() {
@@ -89,13 +99,82 @@ func (beUpdate *VDomBackendUpdate) CreateTransferElems() {
 			allElems = append(allElems, *renderUpdate.VDom)
 		}
 	}
-	transferElems := vdom.ConvertElemsToTransferElems(allElems)
-	beUpdate.TransferElems = vdom.DedupTransferElems(transferElems)
+	transferElems := ConvertElemsToTransferElems(allElems)
+	beUpdate.TransferElems = DedupTransferElems(transferElems)
 	for i := range beUpdate.RenderUpdates {
 		beUpdate.RenderUpdates[i].VDom = nil
 	}
 }
 
+func ConvertElemsToTransferElems(elems []vdom.VDomElem) []VDomTransferElem {
+	var transferElems []VDomTransferElem
+	textCounter := 0 // Counter for generating unique IDs for #text nodes
+
+	// Helper function to recursively process each VDomElem in preorder
+	var processElem func(elem vdom.VDomElem) string
+	processElem = func(elem vdom.VDomElem) string {
+		// Handle #text nodes by generating a unique placeholder ID
+		if elem.Tag == "#text" {
+			textId := fmt.Sprintf("text-%d", textCounter)
+			textCounter++
+			transferElems = append(transferElems, VDomTransferElem{
+				WaveId:   textId,
+				Tag:      elem.Tag,
+				Text:     elem.Text,
+				Props:    nil,
+				Children: nil,
+			})
+			return textId
+		}
+
+		// Convert children to WaveId references, handling potential #text nodes
+		childrenIds := make([]string, len(elem.Children))
+		for i, child := range elem.Children {
+			childrenIds[i] = processElem(child) // Children are not roots
+		}
+
+		// Create the VDomTransferElem for the current element
+		transferElem := VDomTransferElem{
+			WaveId:   elem.WaveId,
+			Tag:      elem.Tag,
+			Props:    elem.Props,
+			Children: childrenIds,
+			Text:     elem.Text,
+		}
+		transferElems = append(transferElems, transferElem)
+
+		return elem.WaveId
+	}
+
+	// Start processing each top-level element, marking them as roots
+	for _, elem := range elems {
+		processElem(elem)
+	}
+
+	return transferElems
+}
+
+func DedupTransferElems(elems []VDomTransferElem) []VDomTransferElem {
+	seen := make(map[string]int) // maps WaveId to its index in the result slice
+	var result []VDomTransferElem
+
+	for _, elem := range elems {
+		if idx, exists := seen[elem.WaveId]; exists {
+			// Overwrite the previous element with the latest one
+			result[idx] = elem
+		} else {
+			// Add new element and store its index
+			seen[elem.WaveId] = len(result)
+			result = append(result, elem)
+		}
+	}
+
+	return result
+}
+
+// SplitBackendUpdate splits a large VDomBackendUpdate into multiple smaller updates
+// The first update contains all the core fields, while subsequent updates only contain
+// array elements that need to be appended
 func SplitBackendUpdate(update *VDomBackendUpdate) []*VDomBackendUpdate {
 	if len(update.TransferElems) <= BackendUpdate_InitialChunkSize && len(update.StateSync) <= BackendUpdate_InitialChunkSize {
 		return []*VDomBackendUpdate{update}
@@ -138,3 +217,129 @@ func SplitBackendUpdate(update *VDomBackendUpdate) []*VDomBackendUpdate {
 
 	return updates
 }
+
+type VDomEvent struct {
+	WaveId          string             `json:"waveid"`
+	EventType       string             `json:"eventtype"` // usually the prop name (e.g. onClick, onKeyDown)
+	GlobalEventType string             `json:"globaleventtype,omitempty"`
+	TargetValue     string             `json:"targetvalue,omitempty"`
+	TargetChecked   bool               `json:"targetchecked,omitempty"`
+	TargetName      string             `json:"targetname,omitempty"`
+	TargetId        string             `json:"targetid,omitempty"`
+	KeyData         *WaveKeyboardEvent `json:"keydata,omitempty"`
+	MouseData       *WavePointerData   `json:"mousedata,omitempty"`
+}
+
+type VDomRenderContext struct {
+	BlockId    string `json:"blockid"`
+	Focused    bool   `json:"focused"`
+	Width      int    `json:"width"`
+	Height     int    `json:"height"`
+	RootRefId  string `json:"rootrefid"`
+	Background bool   `json:"background,omitempty"`
+}
+
+type VDomStateSync struct {
+	Atom  string `json:"atom"`
+	Value any    `json:"value"`
+}
+
+type VDomRefUpdate struct {
+	RefId      string                `json:"refid"`
+	HasCurrent bool                  `json:"hascurrent"`
+	Position   *vdom.VDomRefPosition `json:"position,omitempty"`
+}
+
+type VDomBackendOpts struct {
+	CloseOnCtrlC         bool `json:"closeonctrlc,omitempty"`
+	GlobalKeyboardEvents bool `json:"globalkeyboardevents,omitempty"`
+	GlobalStyles         bool `json:"globalstyles,omitempty"`
+}
+
+type VDomRenderUpdate struct {
+	UpdateType string         `json:"updatetype" tstype:"\"root\"|\"append\"|\"replace\"|\"remove\"|\"insert\""`
+	WaveId     string         `json:"waveid,omitempty"`
+	VDomWaveId string         `json:"vdomwaveid,omitempty"`
+	VDom       *vdom.VDomElem `json:"vdom,omitempty"` // these get removed for transfer (encoded to transferelems)
+	Index      *int           `json:"index,omitempty"`
+}
+
+type VDomRefOperation struct {
+	RefId     string `json:"refid"`
+	Op        string `json:"op"`
+	Params    []any  `json:"params,omitempty"`
+	OutputRef string `json:"outputref,omitempty"`
+}
+
+type VDomMessage struct {
+	MessageType string `json:"messagetype"`
+	Message     string `json:"message"`
+	StackTrace  string `json:"stacktrace,omitempty"`
+	Params      []any  `json:"params,omitempty"`
+}
+
+// target -- to support new targets in the future, like toolbars, partial blocks, splits, etc.
+// default is vdom context inside of a terminal block
+type VDomTarget struct {
+	NewBlock  bool               `json:"newblock,omitempty"`
+	Magnified bool               `json:"magnified,omitempty"`
+	Toolbar   *VDomTargetToolbar `json:"toolbar,omitempty"`
+}
+
+type VDomTargetToolbar struct {
+	Toolbar bool   `json:"toolbar"`
+	Height  string `json:"height,omitempty"`
+}
+
+// matches WaveKeyboardEvent
+type VDomKeyboardEvent struct {
+	Type     string `json:"type"`
+	Key      string `json:"key"`
+	Code     string `json:"code"`
+	Shift    bool   `json:"shift,omitempty"`
+	Control  bool   `json:"ctrl,omitempty"`
+	Alt      bool   `json:"alt,omitempty"`
+	Meta     bool   `json:"meta,omitempty"`
+	Cmd      bool   `json:"cmd,omitempty"`
+	Option   bool   `json:"option,omitempty"`
+	Repeat   bool   `json:"repeat,omitempty"`
+	Location int    `json:"location,omitempty"`
+}
+
+type WaveKeyboardEvent struct {
+	Type     string `json:"type" tstype:"\"keydown\"|\"keyup\"|\"keypress\"|\"unknown\""`
+	Key      string `json:"key"`  // KeyboardEvent.key
+	Code     string `json:"code"` // KeyboardEvent.code
+	Repeat   bool   `json:"repeat,omitempty"`
+	Location int    `json:"location,omitempty"` // KeyboardEvent.location
+
+	// modifiers
+	Shift   bool `json:"shift,omitempty"`
+	Control bool `json:"control,omitempty"`
+	Alt     bool `json:"alt,omitempty"`
+	Meta    bool `json:"meta,omitempty"`
+	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
+	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
+}
+
+type WavePointerData struct {
+	Button  int `json:"button"`
+	Buttons int `json:"buttons"`
+
+	ClientX   int `json:"clientx,omitempty"`
+	ClientY   int `json:"clienty,omitempty"`
+	PageX     int `json:"pagex,omitempty"`
+	PageY     int `json:"pagey,omitempty"`
+	ScreenX   int `json:"screenx,omitempty"`
+	ScreenY   int `json:"screeny,omitempty"`
+	MovementX int `json:"movementx,omitempty"`
+	MovementY int `json:"movementy,omitempty"`
+
+	// Modifiers
+	Shift   bool `json:"shift,omitempty"`
+	Control bool `json:"control,omitempty"`
+	Alt     bool `json:"alt,omitempty"`
+	Meta    bool `json:"meta,omitempty"`
+	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
+	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
+}
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index c4f6c037f0..dab9465182 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -148,7 +148,7 @@ func H(tag string, props map[string]any, children ...any) *VDomElem {
 	rtn := &VDomElem{Tag: tag, Props: props}
 	if len(children) > 0 {
 		for _, part := range children {
-			elems := partToElems(part)
+			elems := PartToElems(part)
 			rtn.Children = append(rtn.Children, elems...)
 		}
 	}
@@ -180,7 +180,7 @@ func E(tag string, parts ...any) *VDomElem {
 			mergeClassAttr(&rtn.Props, classAttr)
 			continue
 		}
-		elems := partToElems(part)
+		elems := PartToElems(part)
 		rtn.Children = append(rtn.Children, elems...)
 	}
 	return rtn
@@ -287,24 +287,9 @@ func P(propName string, propVal any) any {
 	return map[string]any{propName: propVal}
 }
 
-func getHookFromCtx(ctx context.Context) (*VDomContextVal, *Hook) {
-	vc := getRenderContext(ctx)
-	if vc == nil {
-		panic("UseState must be called within a component (no context)")
-	}
-	if vc.Comp == nil {
-		panic("UseState must be called within a component (vc.Comp is nil)")
-	}
-	for len(vc.Comp.Hooks) <= vc.HookIdx {
-		vc.Comp.Hooks = append(vc.Comp.Hooks, &Hook{Idx: len(vc.Comp.Hooks)})
-	}
-	hookVal := vc.Comp.Hooks[vc.HookIdx]
-	vc.HookIdx++
-	return vc, hookVal
-}
-
 func UseState[T any](ctx context.Context, initialVal T) (T, func(T)) {
-	vc, hookVal := getHookFromCtx(ctx)
+	vc := GetRenderContext(ctx)
+	hookVal := vc.GetOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
 		hookVal.Val = initialVal
@@ -316,13 +301,14 @@ func UseState[T any](ctx context.Context, initialVal T) (T, func(T)) {
 	}
 	setVal := func(newVal T) {
 		hookVal.Val = newVal
-		vc.Root.AddRenderWork(vc.Comp.WaveId)
+		vc.AddRenderWork(vc.GetCompWaveId())
 	}
 	return rtnVal, setVal
 }
 
 func UseStateWithFn[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T)) {
-	vc, hookVal := getHookFromCtx(ctx)
+	vc := GetRenderContext(ctx)
+	hookVal := vc.GetOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
 		hookVal.Val = initialVal
@@ -335,29 +321,30 @@ func UseStateWithFn[T any](ctx context.Context, initialVal T) (T, func(T), func(
 
 	setVal := func(newVal T) {
 		hookVal.Val = newVal
-		vc.Root.AddRenderWork(vc.Comp.WaveId)
+		vc.AddRenderWork(vc.GetCompWaveId())
 	}
 
 	setFuncVal := func(updateFunc func(T) T) {
 		hookVal.Val = updateFunc(hookVal.Val.(T))
-		vc.Root.AddRenderWork(vc.Comp.WaveId)
+		vc.AddRenderWork(vc.GetCompWaveId())
 	}
 
 	return rtnVal, setVal, setFuncVal
 }
 
 func UseAtom[T any](ctx context.Context, atomName string) (T, func(T)) {
-	vc, hookVal := getHookFromCtx(ctx)
+	vc := GetRenderContext(ctx)
+	hookVal := vc.GetOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
-		closedWaveId := vc.Comp.WaveId
+		closedWaveId := vc.GetCompWaveId()
 		hookVal.UnmountFn = func() {
-			atom := vc.Root.GetAtom(atomName)
+			atom := vc.GetAtom(atomName)
 			delete(atom.UsedBy, closedWaveId)
 		}
 	}
-	atom := vc.Root.GetAtom(atomName)
-	atom.UsedBy[vc.Comp.WaveId] = true
+	atom := vc.GetAtom(atomName)
+	atom.UsedBy[vc.GetCompWaveId()] = true
 	atomVal, ok := atom.Val.(T)
 	if !ok {
 		panic(fmt.Sprintf("UseAtom %q value type mismatch (expected %T, got %T)", atomName, atomVal, atom.Val))
@@ -365,17 +352,18 @@ func UseAtom[T any](ctx context.Context, atomName string) (T, func(T)) {
 	setVal := func(newVal T) {
 		atom.Val = newVal
 		for waveId := range atom.UsedBy {
-			vc.Root.AddRenderWork(waveId)
+			vc.AddRenderWork(waveId)
 		}
 	}
 	return atomVal, setVal
 }
 
 func UseVDomRef(ctx context.Context) *VDomRef {
-	vc, hookVal := getHookFromCtx(ctx)
+	vc := GetRenderContext(ctx)
+	hookVal := vc.GetOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
-		refId := vc.Comp.WaveId + ":" + strconv.Itoa(hookVal.Idx)
+		refId := vc.GetCompWaveId() + ":" + strconv.Itoa(hookVal.Idx)
 		hookVal.Val = &VDomRef{Type: ObjectType_Ref, RefId: refId}
 	}
 	refVal, ok := hookVal.Val.(*VDomRef)
@@ -386,7 +374,8 @@ func UseVDomRef(ctx context.Context) *VDomRef {
 }
 
 func UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T] {
-	_, hookVal := getHookFromCtx(ctx)
+	vc := GetRenderContext(ctx)
+	hookVal := vc.GetOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
 		hookVal.Val = &VDomSimpleRef[T]{Current: val}
@@ -399,33 +388,19 @@ func UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T] {
 }
 
 func UseId(ctx context.Context) string {
-	vc := getRenderContext(ctx)
+	vc := GetRenderContext(ctx)
 	if vc == nil {
 		panic("UseId must be called within a component (no context)")
 	}
-	return vc.Comp.WaveId
+	return vc.GetCompWaveId()
 }
 
 func UseRenderTs(ctx context.Context) int64 {
-	vc := getRenderContext(ctx)
+	vc := GetRenderContext(ctx)
 	if vc == nil {
 		panic("UseRenderTs must be called within a component (no context)")
 	}
-	return vc.Root.RenderTs
-}
-
-func QueueRefOp(ctx context.Context, ref *VDomRef, op VDomRefOperation) {
-	if ref == nil || !ref.HasCurrent {
-		return
-	}
-	vc := getRenderContext(ctx)
-	if vc == nil {
-		panic("QueueRefOp must be called within a component (no context)")
-	}
-	if op.RefId == "" {
-		op.RefId = ref.RefId
-	}
-	vc.Root.QueueRefOp(op)
+	return vc.GetRenderTs()
 }
 
 func depsEqual(deps1 []any, deps2 []any) bool {
@@ -442,12 +417,13 @@ func depsEqual(deps1 []any, deps2 []any) bool {
 
 func UseEffect(ctx context.Context, fn func() func(), deps []any) {
 	// note UseEffect never actually runs anything, it just queues the effect to run later
-	vc, hookVal := getHookFromCtx(ctx)
+	vc := GetRenderContext(ctx)
+	hookVal := vc.GetOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
 		hookVal.Fn = fn
 		hookVal.Deps = deps
-		vc.Root.AddEffectWork(vc.Comp.WaveId, hookVal.Idx)
+		vc.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
 		return
 	}
 	if depsEqual(hookVal.Deps, deps) {
@@ -455,10 +431,10 @@ func UseEffect(ctx context.Context, fn func() func(), deps []any) {
 	}
 	hookVal.Fn = fn
 	hookVal.Deps = deps
-	vc.Root.AddEffectWork(vc.Comp.WaveId, hookVal.Idx)
+	vc.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
 }
 
-func partToElems(part any) []VDomElem {
+func PartToElems(part any) []VDomElem {
 	if part == nil {
 		return nil
 	}
@@ -485,7 +461,7 @@ func partToElems(part any) []VDomElem {
 	case []any:
 		var rtn []VDomElem
 		for _, subPart := range partTyped {
-			rtn = append(rtn, partToElems(subPart)...)
+			rtn = append(rtn, PartToElems(subPart)...)
 		}
 		return rtn
 	default:
@@ -493,7 +469,7 @@ func partToElems(part any) []VDomElem {
 		if partVal.Kind() == reflect.Slice {
 			var rtn []VDomElem
 			for i := 0; i < partVal.Len(); i++ {
-				rtn = append(rtn, partToElems(partVal.Index(i).Interface())...)
+				rtn = append(rtn, PartToElems(partVal.Index(i).Interface())...)
 			}
 			return rtn
 		}
@@ -505,7 +481,7 @@ func partToElems(part any) []VDomElem {
 	}
 }
 
-func isBaseTag(tag string) bool {
+func IsBaseTag(tag string) bool {
 	if tag == "" {
 		return false
 	}
diff --git a/tsunami/vdom/vdom_context.go b/tsunami/vdom/vdom_context.go
new file mode 100644
index 0000000000..b693116ff0
--- /dev/null
+++ b/tsunami/vdom/vdom_context.go
@@ -0,0 +1,36 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package vdom
+
+import (
+	"context"
+)
+
+type vdomContextKeyType struct{}
+
+var vdomContextKey = vdomContextKeyType{}
+
+type VDomContext interface {
+	AddRenderWork(id string)
+	AddEffectWork(id string, effectIndex int)
+	GetAtom(atomName string) *Atom
+	GetRenderTs() int64
+	GetCompWaveId() string
+	GetOrderedHook() *Hook
+}
+
+func WithRenderContext(ctx context.Context, vc VDomContext) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, vdomContextKey, vc)
+}
+
+func GetRenderContext(ctx context.Context) VDomContext {
+	v := ctx.Value(vdomContextKey)
+	if v == nil {
+		return nil
+	}
+	return v.(VDomContext)
+}
diff --git a/tsunami/vdom/vdom_html.go b/tsunami/vdom/vdom_html.go
index 9501ca2c53..b167d4d0f4 100644
--- a/tsunami/vdom/vdom_html.go
+++ b/tsunami/vdom/vdom_html.go
@@ -356,7 +356,7 @@ outer:
 			if token.Data == Html_BindParamTagName {
 				keyAttr := getAttrString(token, "key")
 				dataVal := params[keyAttr]
-				elemList := partToElems(dataVal)
+				elemList := PartToElems(dataVal)
 				for _, elem := range elemList {
 					appendChildToStack(elemStack, &elem)
 				}
diff --git a/tsunami/vdom/vdom_test.go b/tsunami/vdom/vdom_test.go
index 7ecf35facb..9c5c2ef79a 100644
--- a/tsunami/vdom/vdom_test.go
+++ b/tsunami/vdom/vdom_test.go
@@ -1,9 +1,7 @@
 package vdom
 
 import (
-	"context"
 	"encoding/json"
-	"fmt"
 	"log"
 	"reflect"
 	"testing"
@@ -11,90 +9,6 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/util"
 )
 
-type renderContextKeyType struct{}
-
-var renderContextKey = renderContextKeyType{}
-
-type TestContext struct {
-	ButtonId string
-}
-
-func Page(ctx context.Context, props map[string]any) any {
-	clicked, setClicked := UseState(ctx, false)
-	var clickedDiv *VDomElem
-	if clicked {
-		clickedDiv = Bind(`<div>clicked</div>`, nil)
-	}
-	clickFn := func() {
-		log.Printf("run clickFn\n")
-		setClicked(true)
-	}
-	return Bind(
-		`
-<div>
-    <h1>hello world</h1>
-	<Button onClick="#param:clickFn">hello</Button>
-	<bindparam key="clickedDiv"/>
-</div>
-`,
-		map[string]any{"clickFn": clickFn, "clickedDiv": clickedDiv},
-	)
-}
-
-func Button(ctx context.Context, props map[string]any) any {
-	ref := UseVDomRef(ctx)
-	clName, setClName := UseState(ctx, "button")
-	UseEffect(ctx, func() func() {
-		fmt.Printf("Button useEffect\n")
-		setClName("button mounted")
-		return nil
-	}, nil)
-	compId := UseId(ctx)
-	testContext := getTestContext(ctx)
-	if testContext != nil {
-		testContext.ButtonId = compId
-	}
-	return Bind(`
-		<div className="#param:clName" ref="#param:ref" onClick="#param:onClick">
-			<bindparam key="children"/>
-		</div>
-	`, map[string]any{"clName": clName, "ref": ref, "onClick": props["onClick"], "children": props["children"]})
-}
-
-func printVDom(root *RootElem) {
-	vd := root.MakeVDom()
-	jsonBytes, _ := json.MarshalIndent(vd, "", "  ")
-	fmt.Printf("%s\n", string(jsonBytes))
-}
-
-func getTestContext(ctx context.Context) *TestContext {
-	val := ctx.Value(renderContextKey)
-	if val == nil {
-		return nil
-	}
-	return val.(*TestContext)
-}
-
-func Test1(t *testing.T) {
-	log.Printf("hello!\n")
-	testContext := &TestContext{ButtonId: ""}
-	ctx := context.WithValue(context.Background(), renderContextKey, testContext)
-	root := MakeRoot()
-	root.SetOuterCtx(ctx)
-	root.RegisterComponent("Page", Page)
-	root.RegisterComponent("Button", Button)
-	root.Render(E("Page"))
-	if root.Root == nil {
-		t.Fatalf("root.Root is nil")
-	}
-	printVDom(root)
-	root.RunWork()
-	printVDom(root)
-	root.Event(testContext.ButtonId, "onClick", VDomEvent{EventType: "onClick"})
-	root.RunWork()
-	printVDom(root)
-}
-
 func TestBind(t *testing.T) {
 	elem := Bind(`<div>clicked</div>`, nil)
 	jsonBytes, _ := json.MarshalIndent(elem, "", "  ")
diff --git a/tsunami/vdom/vdom_types.go b/tsunami/vdom/vdom_types.go
index 54d849d621..cfce234243 100644
--- a/tsunami/vdom/vdom_types.go
+++ b/tsunami/vdom/vdom_types.go
@@ -3,10 +3,6 @@
 
 package vdom
 
-import (
-	"context"
-)
-
 const TextTag = "#text"
 const WaveTextTag = "wave:text"
 const WaveNullTag = "wave:null"
@@ -30,34 +26,12 @@ type Hook struct {
 	Deps      []any
 }
 
-type vdomContextKeyType struct{}
-
-var vdomContextKey = vdomContextKeyType{}
-
-type VDomContextVal struct {
-	Root    *RootElem
-	Comp    *ComponentImpl
-	HookIdx int
-}
-
 type Atom struct {
 	Val    any
 	Dirty  bool
 	UsedBy map[string]bool // component waveid -> true
 }
 
-type RootElem struct {
-	OuterCtx        context.Context
-	Root            *ComponentImpl
-	RenderTs        int64
-	CFuncs          map[string]any
-	CompMap         map[string]*ComponentImpl // component waveid -> component
-	EffectWorkQueue []*EffectWorkElem
-	NeedsRenderMap  map[string]bool
-	Atoms           map[string]*Atom
-	RefOperations   []VDomRefOperation
-}
-
 const (
 	WorkType_Render = "render"
 	WorkType_Effect = "effect"
@@ -77,20 +51,6 @@ type VDomElem struct {
 	Text     string         `json:"text,omitempty"`
 }
 
-// the over the wire format for a vdom element
-type VDomTransferElem struct {
-	WaveId   string         `json:"waveid,omitempty"` // required, except for #text nodes
-	Tag      string         `json:"tag"`
-	Props    map[string]any `json:"props,omitempty"`
-	Children []string       `json:"children,omitempty"`
-	Text     string         `json:"text,omitempty"`
-}
-
-//// protocol messages
-
-
-///// prop types
-
 // used in props
 type VDomBinding struct {
 	Type string `json:"type" tstype:"\"binding\""`
@@ -137,131 +97,3 @@ type VDomRefPosition struct {
 	ScrollTop          int     `json:"scrolltop"`
 	BoundingClientRect DomRect `json:"boundingclientrect"`
 }
-
-///// subbordinate protocol types
-
-type VDomEvent struct {
-	WaveId          string             `json:"waveid"`
-	EventType       string             `json:"eventtype"` // usually the prop name (e.g. onClick, onKeyDown)
-	GlobalEventType string             `json:"globaleventtype,omitempty"`
-	TargetValue     string             `json:"targetvalue,omitempty"`
-	TargetChecked   bool               `json:"targetchecked,omitempty"`
-	TargetName      string             `json:"targetname,omitempty"`
-	TargetId        string             `json:"targetid,omitempty"`
-	KeyData         *WaveKeyboardEvent `json:"keydata,omitempty"`
-	MouseData       *WavePointerData   `json:"mousedata,omitempty"`
-}
-
-type VDomRenderContext struct {
-	BlockId    string `json:"blockid"`
-	Focused    bool   `json:"focused"`
-	Width      int    `json:"width"`
-	Height     int    `json:"height"`
-	RootRefId  string `json:"rootrefid"`
-	Background bool   `json:"background,omitempty"`
-}
-
-type VDomStateSync struct {
-	Atom  string `json:"atom"`
-	Value any    `json:"value"`
-}
-
-type VDomRefUpdate struct {
-	RefId      string           `json:"refid"`
-	HasCurrent bool             `json:"hascurrent"`
-	Position   *VDomRefPosition `json:"position,omitempty"`
-}
-
-type VDomBackendOpts struct {
-	CloseOnCtrlC         bool `json:"closeonctrlc,omitempty"`
-	GlobalKeyboardEvents bool `json:"globalkeyboardevents,omitempty"`
-	GlobalStyles         bool `json:"globalstyles,omitempty"`
-}
-
-type VDomRenderUpdate struct {
-	UpdateType string    `json:"updatetype" tstype:"\"root\"|\"append\"|\"replace\"|\"remove\"|\"insert\""`
-	WaveId     string    `json:"waveid,omitempty"`
-	VDomWaveId string    `json:"vdomwaveid,omitempty"`
-	VDom       *VDomElem `json:"vdom,omitempty"` // these get removed for transfer (encoded to transferelems)
-	Index      *int      `json:"index,omitempty"`
-}
-
-type VDomRefOperation struct {
-	RefId     string `json:"refid"`
-	Op        string `json:"op"`
-	Params    []any  `json:"params,omitempty"`
-	OutputRef string `json:"outputref,omitempty"`
-}
-
-type VDomMessage struct {
-	MessageType string `json:"messagetype"`
-	Message     string `json:"message"`
-	StackTrace  string `json:"stacktrace,omitempty"`
-	Params      []any  `json:"params,omitempty"`
-}
-
-// target -- to support new targets in the future, like toolbars, partial blocks, splits, etc.
-// default is vdom context inside of a terminal block
-type VDomTarget struct {
-	NewBlock  bool               `json:"newblock,omitempty"`
-	Magnified bool               `json:"magnified,omitempty"`
-	Toolbar   *VDomTargetToolbar `json:"toolbar,omitempty"`
-}
-
-type VDomTargetToolbar struct {
-	Toolbar bool   `json:"toolbar"`
-	Height  string `json:"height,omitempty"`
-}
-
-// matches WaveKeyboardEvent
-type VDomKeyboardEvent struct {
-	Type     string `json:"type"`
-	Key      string `json:"key"`
-	Code     string `json:"code"`
-	Shift    bool   `json:"shift,omitempty"`
-	Control  bool   `json:"ctrl,omitempty"`
-	Alt      bool   `json:"alt,omitempty"`
-	Meta     bool   `json:"meta,omitempty"`
-	Cmd      bool   `json:"cmd,omitempty"`
-	Option   bool   `json:"option,omitempty"`
-	Repeat   bool   `json:"repeat,omitempty"`
-	Location int    `json:"location,omitempty"`
-}
-
-type WaveKeyboardEvent struct {
-	Type     string `json:"type" tstype:"\"keydown\"|\"keyup\"|\"keypress\"|\"unknown\""`
-	Key      string `json:"key"`  // KeyboardEvent.key
-	Code     string `json:"code"` // KeyboardEvent.code
-	Repeat   bool   `json:"repeat,omitempty"`
-	Location int    `json:"location,omitempty"` // KeyboardEvent.location
-
-	// modifiers
-	Shift   bool `json:"shift,omitempty"`
-	Control bool `json:"control,omitempty"`
-	Alt     bool `json:"alt,omitempty"`
-	Meta    bool `json:"meta,omitempty"`
-	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
-	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
-}
-
-type WavePointerData struct {
-	Button  int `json:"button"`
-	Buttons int `json:"buttons"`
-
-	ClientX   int `json:"clientx,omitempty"`
-	ClientY   int `json:"clienty,omitempty"`
-	PageX     int `json:"pagex,omitempty"`
-	PageY     int `json:"pagey,omitempty"`
-	ScreenX   int `json:"screenx,omitempty"`
-	ScreenY   int `json:"screeny,omitempty"`
-	MovementX int `json:"movementx,omitempty"`
-	MovementY int `json:"movementy,omitempty"`
-
-	// Modifiers
-	Shift   bool `json:"shift,omitempty"`
-	Control bool `json:"control,omitempty"`
-	Alt     bool `json:"alt,omitempty"`
-	Meta    bool `json:"meta,omitempty"`
-	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
-	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
-}
\ No newline at end of file

From cd8ae61944b31519b278d2d276a459b1ccdda9d1 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 12:06:55 -0700
Subject: [PATCH 005/134] remove vdom.scss

---
 frontend/app/view/vdom/vdom.scss | 8 --------
 frontend/app/view/vdom/vdom.tsx  | 3 +--
 2 files changed, 1 insertion(+), 10 deletions(-)
 delete mode 100644 frontend/app/view/vdom/vdom.scss

diff --git a/frontend/app/view/vdom/vdom.scss b/frontend/app/view/vdom/vdom.scss
deleted file mode 100644
index b8cd5f3003..0000000000
--- a/frontend/app/view/vdom/vdom.scss
+++ /dev/null
@@ -1,8 +0,0 @@
-// Copyright 2024, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-.view-vdom {
-    overflow: auto;
-    width: 100%;
-    min-height: 100%;
-}
diff --git a/frontend/app/view/vdom/vdom.tsx b/frontend/app/view/vdom/vdom.tsx
index 4634defd87..eacdb79424 100644
--- a/frontend/app/view/vdom/vdom.tsx
+++ b/frontend/app/view/vdom/vdom.tsx
@@ -16,7 +16,6 @@ import {
     validateAndWrapCss,
     validateAndWrapReactStyle,
 } from "@/app/view/vdom/vdom-utils";
-import "./vdom.scss";
 
 const TextTag = "#text";
 const FragmentTag = "#fragment";
@@ -506,7 +505,7 @@ function VDomView({ blockId, model }: VDomViewProps) {
     model.viewRef = viewRef;
     const vdomClass = "vdom-" + blockId;
     return (
-        <div className={clsx("view-vdom", vdomClass)} ref={viewRef}>
+        <div className={clsx("overflow-auto w-full min-h-full", vdomClass)} ref={viewRef}>
             {contextActive ? <VDomInnerView blockId={blockId} model={model} /> : null}
         </div>
     );

From 73b3527e5c8290f952b3e96be576f030c861e4f8 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 13:26:35 -0700
Subject: [PATCH 006/134] server handlers + listenandserve

---
 tsunami/app/serverhandlers.go | 138 ++++++++++++++++++++++++++++++++++
 tsunami/app/waveapp.go        |  47 +++++++++++-
 2 files changed, 181 insertions(+), 4 deletions(-)
 create mode 100644 tsunami/app/serverhandlers.go

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
new file mode 100644
index 0000000000..b20b9ce13f
--- /dev/null
+++ b/tsunami/app/serverhandlers.go
@@ -0,0 +1,138 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package waveapp
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"strings"
+
+	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
+	"github.com/wavetermdev/waveterm/tsunami/util"
+)
+
+type HTTPHandlers struct {
+	Client  *Client
+	BlockId string
+}
+
+func NewHTTPHandlers(client *Client, blockId string) *HTTPHandlers {
+	return &HTTPHandlers{
+		Client:  client,
+		BlockId: blockId,
+	}
+}
+
+func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux) {
+	mux.HandleFunc("/api/render", h.handleRender)
+	mux.HandleFunc("/vdom/", h.handleVDomUrl)
+}
+
+func (h *HTTPHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
+	defer func() {
+		panicErr := util.PanicHandler("handleRender", recover())
+		if panicErr != nil {
+			http.Error(w, fmt.Sprintf("internal server error: %v", panicErr), http.StatusInternalServerError)
+		}
+	}()
+
+	if r.Method != http.MethodPost {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("failed to read request body: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	var feUpdate rpctypes.VDomFrontendUpdate
+	if err := json.Unmarshal(body, &feUpdate); err != nil {
+		http.Error(w, fmt.Sprintf("failed to parse JSON: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	if feUpdate.Dispose {
+		log.Printf("got dispose from frontend\n")
+		h.Client.doShutdown("got dispose from frontend")
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+
+	if h.Client.GetIsDone() {
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+
+	h.Client.Root.RenderTs = feUpdate.Ts
+
+	// set atoms
+	for _, ss := range feUpdate.StateSync {
+		h.Client.Root.SetAtomVal(ss.Atom, ss.Value, false)
+	}
+	// run events
+	for _, event := range feUpdate.Events {
+		if event.GlobalEventType != "" {
+			if h.Client.GlobalEventHandler != nil {
+				h.Client.GlobalEventHandler(h.Client, event)
+			}
+		} else {
+			h.Client.Root.Event(event.WaveId, event.EventType, event)
+		}
+	}
+	// update refs
+	for _, ref := range feUpdate.RefUpdates {
+		h.Client.Root.UpdateRef(ref)
+	}
+
+	var update *rpctypes.VDomBackendUpdate
+	var renderErr error
+
+	if feUpdate.Resync || true {
+		update, renderErr = h.Client.fullRender()
+	} else {
+		update, renderErr = h.Client.incrementalRender()
+	}
+
+	if renderErr != nil {
+		http.Error(w, fmt.Sprintf("render error: %v", renderErr), http.StatusInternalServerError)
+		return
+	}
+
+	update.CreateTransferElems()
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(update); err != nil {
+		log.Printf("failed to encode response: %v", err)
+	}
+}
+
+func (h *HTTPHandlers) handleVDomUrl(w http.ResponseWriter, r *http.Request) {
+	defer func() {
+		panicErr := util.PanicHandler("handleVDomUrl", recover())
+		if panicErr != nil {
+			http.Error(w, fmt.Sprintf("internal server error: %v", panicErr), http.StatusInternalServerError)
+		}
+	}()
+
+	// Strip /vdom prefix and update the request URL
+	r.URL.Path = strings.TrimPrefix(r.URL.Path, "/vdom")
+	if r.URL.Path == "" {
+		r.URL.Path = "/"
+	}
+
+	if r.URL.Path == "/wave/global.css" && h.Client.GlobalStylesOption != nil {
+		ServeFileOption(w, r, *h.Client.GlobalStylesOption)
+		return
+	}
+	if h.Client.OverrideUrlHandler != nil {
+		h.Client.OverrideUrlHandler.ServeHTTP(w, r)
+		return
+	}
+	h.Client.UrlHandlerMux.ServeHTTP(w, r)
+}
diff --git a/tsunami/app/waveapp.go b/tsunami/app/waveapp.go
index fd0d995ca3..14fc0f9612 100644
--- a/tsunami/app/waveapp.go
+++ b/tsunami/app/waveapp.go
@@ -5,12 +5,12 @@ package waveapp
 
 import (
 	"context"
-	"errors"
 	"flag"
 	"fmt"
 	"io"
 	"io/fs"
 	"log"
+	"net"
 	"net/http"
 	"os"
 	"strings"
@@ -116,7 +116,7 @@ func (c *Client) runMainE() error {
 	if c.SetupFn != nil {
 		c.SetupFn()
 	}
-	err := c.Connect()
+	err := c.ListenAndServe(context.Background())
 	if err != nil {
 		return err
 	}
@@ -160,8 +160,47 @@ func (c *Client) RunMain() {
 	}
 }
 
-func (c *Client) Connect() error {
-	return errors.New("unimplemented")
+func (c *Client) ListenAndServe(ctx context.Context) error {
+	// Create HTTP handlers
+	handlers := NewHTTPHandlers(c, c.RpcContext.BlockId)
+	
+	// Create a new ServeMux and register handlers
+	mux := http.NewServeMux()
+	handlers.RegisterHandlers(mux)
+	
+	// Create server and listen on any available port on localhost
+	server := &http.Server{
+		Addr:    "localhost:0",
+		Handler: mux,
+	}
+	
+	// Start listening
+	listener, err := net.Listen("tcp", "localhost:0")
+	if err != nil {
+		return fmt.Errorf("failed to listen: %v", err)
+	}
+	
+	// Log the port we're listening on
+	port := listener.Addr().(*net.TCPAddr).Port
+	log.Printf("Wave app server listening on port %d", port)
+	
+	// Serve in a goroutine so we don't block
+	go func() {
+		if err := server.Serve(listener); err != nil && err != http.ErrServerClosed {
+			log.Printf("HTTP server error: %v", err)
+		}
+	}()
+	
+	// Wait for context cancellation and shutdown server gracefully
+	go func() {
+		<-ctx.Done()
+		log.Printf("Context canceled, shutting down server...")
+		if err := server.Shutdown(context.Background()); err != nil {
+			log.Printf("Server shutdown error: %v", err)
+		}
+	}()
+	
+	return nil
 }
 
 func (c *Client) SetRootElem(elem *vdom.VDomElem) {

From ec54dc96a32c3a98515213d6c7e29b8010034a87 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 13:28:14 -0700
Subject: [PATCH 007/134] use handlers intead of rpc

---
 tsunami/app/waveapp.go           |  15 ++-
 tsunami/app/waveappserverimpl.go | 151 -------------------------------
 2 files changed, 7 insertions(+), 159 deletions(-)
 delete mode 100644 tsunami/app/waveappserverimpl.go

diff --git a/tsunami/app/waveapp.go b/tsunami/app/waveapp.go
index 14fc0f9612..5f0e660e1a 100644
--- a/tsunami/app/waveapp.go
+++ b/tsunami/app/waveapp.go
@@ -45,7 +45,6 @@ type Client struct {
 	RootElem           *vdom.VDomElem
 	RpcClient          *rpcclient.RpcClient
 	RpcContext         *rpc.RpcContext
-	ServerImpl         *WaveAppServerImpl
 	IsDone             bool
 	RouteId            string
 	VDomContextBlockId string
@@ -163,34 +162,34 @@ func (c *Client) RunMain() {
 func (c *Client) ListenAndServe(ctx context.Context) error {
 	// Create HTTP handlers
 	handlers := NewHTTPHandlers(c, c.RpcContext.BlockId)
-	
+
 	// Create a new ServeMux and register handlers
 	mux := http.NewServeMux()
 	handlers.RegisterHandlers(mux)
-	
+
 	// Create server and listen on any available port on localhost
 	server := &http.Server{
 		Addr:    "localhost:0",
 		Handler: mux,
 	}
-	
+
 	// Start listening
 	listener, err := net.Listen("tcp", "localhost:0")
 	if err != nil {
 		return fmt.Errorf("failed to listen: %v", err)
 	}
-	
+
 	// Log the port we're listening on
 	port := listener.Addr().(*net.TCPAddr).Port
 	log.Printf("Wave app server listening on port %d", port)
-	
+
 	// Serve in a goroutine so we don't block
 	go func() {
 		if err := server.Serve(listener); err != nil && err != http.ErrServerClosed {
 			log.Printf("HTTP server error: %v", err)
 		}
 	}()
-	
+
 	// Wait for context cancellation and shutdown server gracefully
 	go func() {
 		<-ctx.Done()
@@ -199,7 +198,7 @@ func (c *Client) ListenAndServe(ctx context.Context) error {
 			log.Printf("Server shutdown error: %v", err)
 		}
 	}()
-	
+
 	return nil
 }
 
diff --git a/tsunami/app/waveappserverimpl.go b/tsunami/app/waveappserverimpl.go
deleted file mode 100644
index 376f7aae1d..0000000000
--- a/tsunami/app/waveappserverimpl.go
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package waveapp
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"log"
-	"net/http"
-
-	"github.com/wavetermdev/waveterm/tsunami/rpc"
-	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
-	"github.com/wavetermdev/waveterm/tsunami/util"
-)
-
-type WaveAppServerImpl struct {
-	Client  *Client
-	BlockId string
-}
-
-func (*WaveAppServerImpl) WshServerImpl() {}
-
-func (impl *WaveAppServerImpl) VDomRenderCommand(ctx context.Context, feUpdate rpctypes.VDomFrontendUpdate) chan rpc.RespOrErrorUnion[*rpctypes.VDomBackendUpdate] {
-	respChan := make(chan rpc.RespOrErrorUnion[*rpctypes.VDomBackendUpdate], 5)
-	defer func() {
-		panicErr := util.PanicHandler("VDomRenderCommand", recover())
-		if panicErr != nil {
-			respChan <- rpc.RespOrErrorUnion[*rpctypes.VDomBackendUpdate]{
-				Error: panicErr,
-			}
-			close(respChan)
-		}
-	}()
-
-	if feUpdate.Dispose {
-		defer close(respChan)
-		log.Printf("got dispose from frontend\n")
-		impl.Client.doShutdown("got dispose from frontend")
-		return respChan
-	}
-
-	if impl.Client.GetIsDone() {
-		close(respChan)
-		return respChan
-	}
-
-	impl.Client.Root.RenderTs = feUpdate.Ts
-
-	// set atoms
-	for _, ss := range feUpdate.StateSync {
-		impl.Client.Root.SetAtomVal(ss.Atom, ss.Value, false)
-	}
-	// run events
-	for _, event := range feUpdate.Events {
-		if event.GlobalEventType != "" {
-			if impl.Client.GlobalEventHandler != nil {
-				impl.Client.GlobalEventHandler(impl.Client, event)
-			}
-		} else {
-			impl.Client.Root.Event(event.WaveId, event.EventType, event)
-		}
-	}
-	// update refs
-	for _, ref := range feUpdate.RefUpdates {
-		impl.Client.Root.UpdateRef(ref)
-	}
-
-	var update *rpctypes.VDomBackendUpdate
-	var err error
-
-	if feUpdate.Resync || true {
-		update, err = impl.Client.fullRender()
-	} else {
-		update, err = impl.Client.incrementalRender()
-	}
-	update.CreateTransferElems()
-
-	if err != nil {
-		respChan <- rpc.RespOrErrorUnion[*rpctypes.VDomBackendUpdate]{
-			Error: err,
-		}
-		close(respChan)
-		return respChan
-	}
-
-	// Split the update into chunks and send them sequentially
-	updates := rpctypes.SplitBackendUpdate(update)
-	go func() {
-		defer func() {
-			util.PanicHandler("VDomRenderCommand:splitUpdates", recover())
-		}()
-		defer close(respChan)
-		for _, splitUpdate := range updates {
-			respChan <- rpc.RespOrErrorUnion[*rpctypes.VDomBackendUpdate]{
-				Response: splitUpdate,
-			}
-		}
-	}()
-
-	return respChan
-}
-
-func (impl *WaveAppServerImpl) VDomUrlRequestCommand(ctx context.Context, data rpc.VDomUrlRequestData) chan rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse] {
-	respChan := make(chan rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse])
-	writer := NewStreamingResponseWriter(respChan)
-
-	go func() {
-		defer close(respChan) // Declared first, so it executes last
-		defer writer.Close()  // Ensures writer is closed before the channel is closed
-
-		defer func() {
-			panicErr := util.PanicHandler("VDomUrlRequestCommand", recover())
-			if panicErr != nil {
-				writer.WriteHeader(http.StatusInternalServerError)
-				writer.Write([]byte(fmt.Sprintf("internal server error: %v", panicErr)))
-			}
-		}()
-
-		// Create an HTTP request from the RPC request data
-		var bodyReader *bytes.Reader
-		if data.Body != nil {
-			bodyReader = bytes.NewReader(data.Body)
-		} else {
-			bodyReader = bytes.NewReader([]byte{})
-		}
-
-		httpReq, err := http.NewRequest(data.Method, data.URL, bodyReader)
-		if err != nil {
-			writer.WriteHeader(http.StatusInternalServerError)
-			writer.Write([]byte(err.Error()))
-			return
-		}
-
-		for key, value := range data.Headers {
-			httpReq.Header.Set(key, value)
-		}
-		if httpReq.URL.Path == "/wave/global.css" && impl.Client.GlobalStylesOption != nil {
-			ServeFileOption(writer, httpReq, *impl.Client.GlobalStylesOption)
-			return
-		}
-		if impl.Client.OverrideUrlHandler != nil {
-			impl.Client.OverrideUrlHandler.ServeHTTP(writer, httpReq)
-			return
-		}
-		impl.Client.UrlHandlerMux.ServeHTTP(writer, httpReq)
-	}()
-
-	return respChan
-}

From e58d7265188de048d7efbca784cdfba7168c1893 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 13:46:13 -0700
Subject: [PATCH 008/134] add an sse handler

---
 tsunami/app/serverhandlers.go | 66 ++++++++++++++++++++++++++++++++---
 tsunami/app/waveapp.go        |  9 ++++-
 2 files changed, 69 insertions(+), 6 deletions(-)

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index b20b9ce13f..904c52c1da 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -10,25 +10,27 @@ import (
 	"log"
 	"net/http"
 	"strings"
+	"time"
 
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 )
 
+const SSEKeepAliveDuration = 5 * time.Second
+
 type HTTPHandlers struct {
-	Client  *Client
-	BlockId string
+	Client *Client
 }
 
-func NewHTTPHandlers(client *Client, blockId string) *HTTPHandlers {
+func NewHTTPHandlers(client *Client) *HTTPHandlers {
 	return &HTTPHandlers{
-		Client:  client,
-		BlockId: blockId,
+		Client: client,
 	}
 }
 
 func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux) {
 	mux.HandleFunc("/api/render", h.handleRender)
+	mux.HandleFunc("/api/updates", h.handleSSE)
 	mux.HandleFunc("/vdom/", h.handleVDomUrl)
 }
 
@@ -136,3 +138,57 @@ func (h *HTTPHandlers) handleVDomUrl(w http.ResponseWriter, r *http.Request) {
 	}
 	h.Client.UrlHandlerMux.ServeHTTP(w, r)
 }
+
+func (h *HTTPHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
+	defer func() {
+		panicErr := util.PanicHandler("handleSSE", recover())
+		if panicErr != nil {
+			http.Error(w, fmt.Sprintf("internal server error: %v", panicErr), http.StatusInternalServerError)
+		}
+	}()
+
+	if r.Method != http.MethodGet {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	// Set SSE headers
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+	w.Header().Set("X-Accel-Buffering", "no")
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+
+	// Flush headers immediately
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		http.Error(w, "streaming not supported", http.StatusInternalServerError)
+		return
+	}
+	flusher.Flush()
+
+	// Create a ticker for keepalive packets
+	keepaliveTicker := time.NewTicker(SSEKeepAliveDuration)
+	defer keepaliveTicker.Stop()
+
+	for {
+		select {
+		case <-r.Context().Done():
+			return
+		case <-keepaliveTicker.C:
+			// Send keepalive comment
+			fmt.Fprintf(w, ": keepalive\n\n")
+			flusher.Flush()
+		case event := <-h.Client.SSEventCh:
+			// Send actual event
+			if event.Event != "" {
+				fmt.Fprintf(w, "event: %s\n", event.Event)
+			}
+			if len(event.Data) > 0 {
+				fmt.Fprintf(w, "data: %s\n", string(event.Data))
+			}
+			fmt.Fprintf(w, "\n")
+			flusher.Flush()
+		}
+	}
+}
diff --git a/tsunami/app/waveapp.go b/tsunami/app/waveapp.go
index 5f0e660e1a..bfb8446761 100644
--- a/tsunami/app/waveapp.go
+++ b/tsunami/app/waveapp.go
@@ -28,6 +28,11 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
+type SSEvent struct {
+	Event string
+	Data  []byte
+}
+
 type AppOpts struct {
 	CloseOnCtrlC         bool
 	GlobalKeyboardEvents bool
@@ -50,6 +55,7 @@ type Client struct {
 	VDomContextBlockId string
 	DoneReason         string
 	DoneCh             chan struct{}
+	SSEventCh          chan SSEvent
 	Opts               rpctypes.VDomBackendOpts
 	GlobalEventHandler func(client *Client, event rpctypes.VDomEvent)
 	GlobalStylesOption *FileHandlerOption
@@ -97,6 +103,7 @@ func MakeClient(appOpts AppOpts) *Client {
 		Root:          comp.MakeRoot(),
 		RpcClient:     rpcclient.MakeRpcClient(),
 		DoneCh:        make(chan struct{}),
+		SSEventCh:     make(chan SSEvent, 100),
 		UrlHandlerMux: mux.NewRouter(),
 		Opts: rpctypes.VDomBackendOpts{
 			CloseOnCtrlC:         appOpts.CloseOnCtrlC,
@@ -161,7 +168,7 @@ func (c *Client) RunMain() {
 
 func (c *Client) ListenAndServe(ctx context.Context) error {
 	// Create HTTP handlers
-	handlers := NewHTTPHandlers(c, c.RpcContext.BlockId)
+	handlers := NewHTTPHandlers(c)
 
 	// Create a new ServeMux and register handlers
 	mux := http.NewServeMux()

From fc9f1e14f72abb754df9f791cb808e0cd1f06bc9 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 13:51:51 -0700
Subject: [PATCH 009/134] remove client, implement sse for async initiation

---
 tsunami/app/serverhandlers.go  |  6 ++--
 tsunami/app/waveapp.go         | 59 ++++------------------------------
 tsunami/rpcclient/client.go    | 43 -------------------------
 tsunami/rpcclient/rpcclient.go | 27 ----------------
 4 files changed, 10 insertions(+), 125 deletions(-)
 delete mode 100644 tsunami/rpcclient/client.go
 delete mode 100644 tsunami/rpcclient/rpcclient.go

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index 904c52c1da..464c530c9e 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -180,10 +180,10 @@ func (h *HTTPHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 			fmt.Fprintf(w, ": keepalive\n\n")
 			flusher.Flush()
 		case event := <-h.Client.SSEventCh:
-			// Send actual event
-			if event.Event != "" {
-				fmt.Fprintf(w, "event: %s\n", event.Event)
+			if event.Event == "" {
+				break
 			}
+			fmt.Fprintf(w, "event: %s\n", event.Event)
 			if len(event.Data) > 0 {
 				fmt.Fprintf(w, "data: %s\n", string(event.Data))
 			}
diff --git a/tsunami/app/waveapp.go b/tsunami/app/waveapp.go
index bfb8446761..fddc02d76f 100644
--- a/tsunami/app/waveapp.go
+++ b/tsunami/app/waveapp.go
@@ -22,7 +22,6 @@ import (
 	"github.com/gorilla/mux"
 	"github.com/wavetermdev/waveterm/tsunami/comp"
 	"github.com/wavetermdev/waveterm/tsunami/rpc"
-	"github.com/wavetermdev/waveterm/tsunami/rpcclient"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -48,7 +47,6 @@ type Client struct {
 	AppOpts            AppOpts
 	Root               *comp.RootElem
 	RootElem           *vdom.VDomElem
-	RpcClient          *rpcclient.RpcClient
 	RpcContext         *rpc.RpcContext
 	IsDone             bool
 	RouteId            string
@@ -101,7 +99,6 @@ func MakeClient(appOpts AppOpts) *Client {
 		Lock:          &sync.Mutex{},
 		AppOpts:       appOpts,
 		Root:          comp.MakeRoot(),
-		RpcClient:     rpcclient.MakeRpcClient(),
 		DoneCh:        make(chan struct{}),
 		SSEventCh:     make(chan SSEvent, 100),
 		UrlHandlerMux: mux.NewRouter(),
@@ -126,20 +123,6 @@ func (c *Client) runMainE() error {
 	if err != nil {
 		return err
 	}
-	target := &rpctypes.VDomTarget{}
-	if c.AppOpts.TargetNewBlock || c.NewBlockFlag {
-		target.NewBlock = c.NewBlockFlag
-	}
-	if c.AppOpts.TargetToolbar != nil {
-		target.Toolbar = c.AppOpts.TargetToolbar
-	}
-	if target.NewBlock && target.Toolbar != nil {
-		return fmt.Errorf("cannot specify both new block and toolbar target")
-	}
-	err = c.CreateVDomContext(target)
-	if err != nil {
-		return err
-	}
 	<-c.DoneCh
 	return nil
 }
@@ -213,36 +196,6 @@ func (c *Client) SetRootElem(elem *vdom.VDomElem) {
 	c.RootElem = elem
 }
 
-func (c *Client) CreateVDomContext(target *rpctypes.VDomTarget) error {
-	blockORef, err := rpcclient.VDomCreateContextCommand(
-		c.RpcClient,
-		rpctypes.VDomCreateContext{Target: target},
-		&rpc.RpcOpts{Route: rpc.MakeFeBlockRouteId(c.RpcContext.BlockId)},
-	)
-	if err != nil {
-		return err
-	}
-	c.VDomContextBlockId = blockORef.OID
-	log.Printf("created vdom context: %v\n", blockORef)
-	gotRoute, err := rpcclient.WaitForRouteCommand(c.RpcClient, rpc.CommandWaitForRouteData{
-		RouteId: rpc.MakeFeBlockRouteId(blockORef.OID),
-		WaitMs:  4000,
-	}, &rpc.RpcOpts{Timeout: 5000})
-	if err != nil {
-		return fmt.Errorf("error waiting for vdom context route: %v", err)
-	}
-	if !gotRoute {
-		return fmt.Errorf("vdom context route could not be established")
-	}
-	rpcclient.EventSubCommand(c.RpcClient, rpc.SubscriptionRequest{Event: rpc.Event_BlockClose, Scopes: []string{
-		blockORef.String(),
-	}}, nil)
-	c.RpcClient.EventListener.On("blockclose", func(event *rpc.WaveEvent) {
-		c.doShutdown("got blockclose event")
-	})
-	return nil
-}
-
 func (c *Client) SendAsyncInitiation() error {
 	if c.VDomContextBlockId == "" {
 		return fmt.Errorf("no vdom context block id")
@@ -250,11 +203,13 @@ func (c *Client) SendAsyncInitiation() error {
 	if c.GetIsDone() {
 		return fmt.Errorf("client is done")
 	}
-	return rpcclient.VDomAsyncInitiationCommand(
-		c.RpcClient,
-		rpctypes.MakeAsyncInitiationRequest(c.RpcContext.BlockId),
-		&rpc.RpcOpts{Route: rpc.MakeFeBlockRouteId(c.VDomContextBlockId)},
-	)
+
+	select {
+	case c.SSEventCh <- SSEvent{Event: "asyncinitiation", Data: nil}:
+		return nil
+	default:
+		return fmt.Errorf("SSEvent channel is full")
+	}
 }
 
 func (c *Client) SetAtomVals(m map[string]any) {
diff --git a/tsunami/rpcclient/client.go b/tsunami/rpcclient/client.go
deleted file mode 100644
index 9e8256c351..0000000000
--- a/tsunami/rpcclient/client.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package rpcclient
-
-import (
-	"github.com/wavetermdev/waveterm/tsunami/rpc"
-)
-
-type EventListener struct {
-	eventHandlers map[string][]func(event *rpc.WaveEvent)
-}
-
-func MakeEventListener() *EventListener {
-	return &EventListener{
-		eventHandlers: make(map[string][]func(event *rpc.WaveEvent)),
-	}
-}
-
-func (el *EventListener) On(eventName string, handler func(event *rpc.WaveEvent)) {
-	if el.eventHandlers == nil {
-		el.eventHandlers = make(map[string][]func(event *rpc.WaveEvent))
-	}
-	el.eventHandlers[eventName] = append(el.eventHandlers[eventName], handler)
-}
-
-func (el *EventListener) Emit(eventName string, event *rpc.WaveEvent) {
-	if handlers, exists := el.eventHandlers[eventName]; exists {
-		for _, handler := range handlers {
-			handler(event)
-		}
-	}
-}
-
-type RpcClient struct {
-	EventListener *EventListener
-}
-
-func MakeRpcClient() *RpcClient {
-	return &RpcClient{
-		EventListener: MakeEventListener(),
-	}
-}
\ No newline at end of file
diff --git a/tsunami/rpcclient/rpcclient.go b/tsunami/rpcclient/rpcclient.go
deleted file mode 100644
index da87aea1a6..0000000000
--- a/tsunami/rpcclient/rpcclient.go
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package rpcclient
-
-import (
-	"errors"
-
-	"github.com/wavetermdev/waveterm/tsunami/rpc"
-	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
-)
-
-func VDomCreateContextCommand(rpcClient *RpcClient, data rpctypes.VDomCreateContext, opts *rpc.RpcOpts) (rpc.ORef, error) {
-	return rpc.ORef{}, errors.New("VDomCreateContextCommand: unimplemented")
-}
-
-func WaitForRouteCommand(rpcClient *RpcClient, data rpc.CommandWaitForRouteData, opts *rpc.RpcOpts) (bool, error) {
-	return false, errors.New("WaitForRouteCommand: unimplemented")
-}
-
-func EventSubCommand(rpcClient *RpcClient, data rpc.SubscriptionRequest, opts *rpc.RpcOpts) error {
-	return errors.New("EventSubCommand: unimplemented")
-}
-
-func VDomAsyncInitiationCommand(rpcClient *RpcClient, data rpctypes.VDomAsyncInitiationRequest, opts *rpc.RpcOpts) error {
-	return errors.New("VDomAsyncInitiationCommand: unimplemented")
-}

From d7934eb39c436c1745df772436677646fbf6f651 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 13:57:29 -0700
Subject: [PATCH 010/134] remove more rpc cruft

---
 tsunami/app/streamingresp.go | 129 -----------------------------------
 tsunami/app/waveapp.go       |   7 +-
 tsunami/rpc/types.go         |   9 ---
 tsunami/rpctypes/types.go    |  86 -----------------------
 4 files changed, 2 insertions(+), 229 deletions(-)
 delete mode 100644 tsunami/app/streamingresp.go

diff --git a/tsunami/app/streamingresp.go b/tsunami/app/streamingresp.go
deleted file mode 100644
index 57188baab4..0000000000
--- a/tsunami/app/streamingresp.go
+++ /dev/null
@@ -1,129 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package waveapp
-
-import (
-	"bytes"
-	"net/http"
-
-	"github.com/wavetermdev/waveterm/tsunami/rpc"
-)
-
-const maxChunkSize = 64 * 1024 // 64KB maximum chunk size
-
-// StreamingResponseWriter implements http.ResponseWriter interface to stream response
-// data through a channel rather than buffering it in memory. This is particularly
-// useful for handling large responses like video streams or file downloads.
-type StreamingResponseWriter struct {
-	header     http.Header
-	statusCode int
-	respChan   chan<- rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse]
-	headerSent bool
-	buffer     *bytes.Buffer
-}
-
-func NewStreamingResponseWriter(respChan chan<- rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse]) *StreamingResponseWriter {
-	return &StreamingResponseWriter{
-		header:     make(http.Header),
-		statusCode: http.StatusOK,
-		respChan:   respChan,
-		headerSent: false,
-		buffer:     bytes.NewBuffer(make([]byte, 0, maxChunkSize)),
-	}
-}
-
-func (w *StreamingResponseWriter) Header() http.Header {
-	return w.header
-}
-
-func (w *StreamingResponseWriter) WriteHeader(statusCode int) {
-	if w.headerSent {
-		return
-	}
-
-	w.statusCode = statusCode
-	w.headerSent = true
-
-	headers := make(map[string]string)
-	for key, values := range w.header {
-		if len(values) > 0 {
-			headers[key] = values[0]
-		}
-	}
-
-	w.respChan <- rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse]{
-		Response: rpc.VDomUrlRequestResponse{
-			StatusCode: w.statusCode,
-			Headers:    headers,
-		},
-	}
-}
-
-// sendChunk sends a single chunk of exactly maxChunkSize (or less)
-func (w *StreamingResponseWriter) sendChunk(data []byte) {
-	if len(data) == 0 {
-		return
-	}
-	chunk := make([]byte, len(data))
-	copy(chunk, data)
-	w.respChan <- rpc.RespOrErrorUnion[rpc.VDomUrlRequestResponse]{
-		Response: rpc.VDomUrlRequestResponse{
-			Body: chunk,
-		},
-	}
-}
-
-func (w *StreamingResponseWriter) Write(data []byte) (int, error) {
-	if !w.headerSent {
-		w.WriteHeader(http.StatusOK)
-	}
-
-	originalLen := len(data)
-
-	// If we already have data in the buffer
-	if w.buffer.Len() > 0 {
-		// Fill the buffer up to maxChunkSize
-		spaceInBuffer := maxChunkSize - w.buffer.Len()
-		if spaceInBuffer > 0 {
-			// How much of the new data can fit in the buffer
-			toBuffer := spaceInBuffer
-			if toBuffer > len(data) {
-				toBuffer = len(data)
-			}
-			w.buffer.Write(data[:toBuffer])
-			data = data[toBuffer:] // Advance data slice
-		}
-
-		// If buffer is full, send it
-		if w.buffer.Len() == maxChunkSize {
-			w.sendChunk(w.buffer.Bytes())
-			w.buffer.Reset()
-		}
-	}
-
-	// Send any full chunks from data
-	for len(data) >= maxChunkSize {
-		w.sendChunk(data[:maxChunkSize])
-		data = data[maxChunkSize:]
-	}
-
-	// Buffer any remaining data
-	if len(data) > 0 {
-		w.buffer.Write(data)
-	}
-
-	return originalLen, nil
-}
-
-func (w *StreamingResponseWriter) Close() error {
-	if !w.headerSent {
-		w.WriteHeader(http.StatusOK)
-	}
-
-	if w.buffer.Len() > 0 {
-		w.sendChunk(w.buffer.Bytes())
-		w.buffer.Reset()
-	}
-	return nil
-}
diff --git a/tsunami/app/waveapp.go b/tsunami/app/waveapp.go
index fddc02d76f..ae406e0e71 100644
--- a/tsunami/app/waveapp.go
+++ b/tsunami/app/waveapp.go
@@ -39,7 +39,6 @@ type AppOpts struct {
 	RootComponentName    string // defaults to "App"
 	NewBlockFlag         string // defaults to "n" (set to "-" to disable)
 	TargetNewBlock       bool
-	TargetToolbar        *rpctypes.VDomTargetToolbar
 }
 
 type Client struct {
@@ -260,7 +259,6 @@ func (c *Client) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 	return &rpctypes.VDomBackendUpdate{
 		Type:    "backendupdate",
 		Ts:      time.Now().UnixMilli(),
-		BlockId: c.RpcContext.BlockId,
 		HasWork: len(c.Root.EffectWorkQueue) > 0,
 		Opts:    &c.Opts,
 		RenderUpdates: []rpctypes.VDomRenderUpdate{
@@ -278,9 +276,8 @@ func (c *Client) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 		renderedVDom = makeNullVDom()
 	}
 	return &rpctypes.VDomBackendUpdate{
-		Type:    "backendupdate",
-		Ts:      time.Now().UnixMilli(),
-		BlockId: c.RpcContext.BlockId,
+		Type: "backendupdate",
+		Ts:   time.Now().UnixMilli(),
 		RenderUpdates: []rpctypes.VDomRenderUpdate{
 			{UpdateType: "root", VDom: renderedVDom},
 		},
diff --git a/tsunami/rpc/types.go b/tsunami/rpc/types.go
index 70c46bcefd..f4d8f7fb00 100644
--- a/tsunami/rpc/types.go
+++ b/tsunami/rpc/types.go
@@ -3,10 +3,6 @@
 
 package rpc
 
-import (
-	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
-)
-
 type RespOrErrorUnion[T any] struct {
 	Response T
 	Error    error
@@ -35,8 +31,3 @@ type ORef struct {
 func (oref ORef) String() string {
 	return oref.OType + ":" + oref.OID
 }
-
-// Types moved to rpctypes package
-type VDomUrlRequestData = rpctypes.VDomUrlRequestData
-type VDomUrlRequestResponse = rpctypes.VDomUrlRequestResponse
-type CommandWaitForRouteData = rpctypes.CommandWaitForRouteData
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
index f578cba04e..1d54841813 100644
--- a/tsunami/rpctypes/types.go
+++ b/tsunami/rpctypes/types.go
@@ -7,41 +7,15 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-const (
-	BackendUpdate_InitialChunkSize = 50  // Size for initial chunks that contain both TransferElems and StateSync
-	BackendUpdate_ChunkSize        = 100 // Size for subsequent chunks
-)
-
-type VDomUrlRequestData struct {
-	Method  string            `json:"method"`
-	URL     string            `json:"url"`
-	Headers map[string]string `json:"headers"`
-	Body    []byte            `json:"body,omitempty"`
-}
-
 type VDomUrlRequestResponse struct {
 	StatusCode int               `json:"statuscode,omitempty"`
 	Headers    map[string]string `json:"headers,omitempty"`
 	Body       []byte            `json:"body,omitempty"`
 }
 
-type CommandWaitForRouteData struct {
-	RouteId string `json:"routeid"`
-	WaitMs  int    `json:"waitms"`
-}
-
-type VDomCreateContext struct {
-	Type    string         `json:"type" tstype:"\"createcontext\""`
-	Ts      int64          `json:"ts"`
-	Meta    map[string]any `json:"meta,omitempty"`
-	Target  *VDomTarget    `json:"target,omitempty"`
-	Persist bool           `json:"persist,omitempty"`
-}
-
 type VDomAsyncInitiationRequest struct {
 	Type    string `json:"type" tstype:"\"asyncinitiationrequest\""`
 	Ts      int64  `json:"ts"`
@@ -73,7 +47,6 @@ type VDomFrontendUpdate struct {
 type VDomBackendUpdate struct {
 	Type          string             `json:"type" tstype:"\"backendupdate\""`
 	Ts            int64              `json:"ts"`
-	BlockId       string             `json:"blockid"`
 	Opts          *VDomBackendOpts   `json:"opts,omitempty"`
 	HasWork       bool               `json:"haswork,omitempty"`
 	RenderUpdates []VDomRenderUpdate `json:"renderupdates,omitempty"`
@@ -172,52 +145,6 @@ func DedupTransferElems(elems []VDomTransferElem) []VDomTransferElem {
 	return result
 }
 
-// SplitBackendUpdate splits a large VDomBackendUpdate into multiple smaller updates
-// The first update contains all the core fields, while subsequent updates only contain
-// array elements that need to be appended
-func SplitBackendUpdate(update *VDomBackendUpdate) []*VDomBackendUpdate {
-	if len(update.TransferElems) <= BackendUpdate_InitialChunkSize && len(update.StateSync) <= BackendUpdate_InitialChunkSize {
-		return []*VDomBackendUpdate{update}
-	}
-
-	updates := make([]*VDomBackendUpdate, 0)
-	transferElemChunks := util.ChunkSlice(update.TransferElems, BackendUpdate_ChunkSize)
-	stateSyncChunks := util.ChunkSlice(update.StateSync, BackendUpdate_ChunkSize)
-
-	maxChunks := len(transferElemChunks)
-	if len(stateSyncChunks) > maxChunks {
-		maxChunks = len(stateSyncChunks)
-	}
-
-	for i := 0; i < maxChunks; i++ {
-		newUpdate := &VDomBackendUpdate{
-			Type:    update.Type,
-			Ts:      update.Ts,
-			BlockId: update.BlockId,
-		}
-
-		if i == 0 {
-			newUpdate.Opts = update.Opts
-			newUpdate.HasWork = update.HasWork
-			newUpdate.RenderUpdates = update.RenderUpdates
-			newUpdate.RefOperations = update.RefOperations
-			newUpdate.Messages = update.Messages
-		}
-
-		if i < len(transferElemChunks) {
-			newUpdate.TransferElems = transferElemChunks[i]
-		}
-
-		if i < len(stateSyncChunks) {
-			newUpdate.StateSync = stateSyncChunks[i]
-		}
-
-		updates = append(updates, newUpdate)
-	}
-
-	return updates
-}
-
 type VDomEvent struct {
 	WaveId          string             `json:"waveid"`
 	EventType       string             `json:"eventtype"` // usually the prop name (e.g. onClick, onKeyDown)
@@ -278,19 +205,6 @@ type VDomMessage struct {
 	Params      []any  `json:"params,omitempty"`
 }
 
-// target -- to support new targets in the future, like toolbars, partial blocks, splits, etc.
-// default is vdom context inside of a terminal block
-type VDomTarget struct {
-	NewBlock  bool               `json:"newblock,omitempty"`
-	Magnified bool               `json:"magnified,omitempty"`
-	Toolbar   *VDomTargetToolbar `json:"toolbar,omitempty"`
-}
-
-type VDomTargetToolbar struct {
-	Toolbar bool   `json:"toolbar"`
-	Height  string `json:"height,omitempty"`
-}
-
 // matches WaveKeyboardEvent
 type VDomKeyboardEvent struct {
 	Type     string `json:"type"`

From 73badade47791edd07f9a8faa55b66e77a8a7e55 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 14:02:41 -0700
Subject: [PATCH 011/134] more cleanup

---
 tsunami/app/waveapp.go    | 25 +------------------------
 tsunami/rpctypes/types.go |  2 +-
 2 files changed, 2 insertions(+), 25 deletions(-)

diff --git a/tsunami/app/waveapp.go b/tsunami/app/waveapp.go
index ae406e0e71..395e2f55b1 100644
--- a/tsunami/app/waveapp.go
+++ b/tsunami/app/waveapp.go
@@ -5,7 +5,6 @@ package waveapp
 
 import (
 	"context"
-	"flag"
 	"fmt"
 	"io"
 	"io/fs"
@@ -21,7 +20,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
 	"github.com/wavetermdev/waveterm/tsunami/comp"
-	"github.com/wavetermdev/waveterm/tsunami/rpc"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -37,8 +35,6 @@ type AppOpts struct {
 	GlobalKeyboardEvents bool
 	GlobalStyles         []byte
 	RootComponentName    string // defaults to "App"
-	NewBlockFlag         string // defaults to "n" (set to "-" to disable)
-	TargetNewBlock       bool
 }
 
 type Client struct {
@@ -46,10 +42,8 @@ type Client struct {
 	AppOpts            AppOpts
 	Root               *comp.RootElem
 	RootElem           *vdom.VDomElem
-	RpcContext         *rpc.RpcContext
+	CurrentClientId    string
 	IsDone             bool
-	RouteId            string
-	VDomContextBlockId string
 	DoneReason         string
 	DoneCh             chan struct{}
 	SSEventCh          chan SSEvent
@@ -58,7 +52,6 @@ type Client struct {
 	GlobalStylesOption *FileHandlerOption
 	UrlHandlerMux      *mux.Router
 	OverrideUrlHandler http.Handler
-	NewBlockFlag       bool
 	SetupFn            func()
 }
 
@@ -91,9 +84,6 @@ func MakeClient(appOpts AppOpts) *Client {
 	if appOpts.RootComponentName == "" {
 		appOpts.RootComponentName = "App"
 	}
-	if appOpts.NewBlockFlag == "" {
-		appOpts.NewBlockFlag = "n"
-	}
 	client := &Client{
 		Lock:          &sync.Mutex{},
 		AppOpts:       appOpts,
@@ -130,17 +120,7 @@ func (c *Client) AddSetupFn(fn func()) {
 	c.SetupFn = fn
 }
 
-func (c *Client) RegisterDefaultFlags() {
-	if c.AppOpts.NewBlockFlag != "-" {
-		flag.BoolVar(&c.NewBlockFlag, c.AppOpts.NewBlockFlag, false, "new block")
-	}
-}
-
 func (c *Client) RunMain() {
-	if !flag.Parsed() {
-		c.RegisterDefaultFlags()
-		flag.Parse()
-	}
 	err := c.runMainE()
 	if err != nil {
 		fmt.Println(err)
@@ -196,9 +176,6 @@ func (c *Client) SetRootElem(elem *vdom.VDomElem) {
 }
 
 func (c *Client) SendAsyncInitiation() error {
-	if c.VDomContextBlockId == "" {
-		return fmt.Errorf("no vdom context block id")
-	}
 	if c.GetIsDone() {
 		return fmt.Errorf("client is done")
 	}
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
index 1d54841813..86a0fe36c0 100644
--- a/tsunami/rpctypes/types.go
+++ b/tsunami/rpctypes/types.go
@@ -33,7 +33,7 @@ func MakeAsyncInitiationRequest(blockId string) VDomAsyncInitiationRequest {
 type VDomFrontendUpdate struct {
 	Type          string            `json:"type" tstype:"\"frontendupdate\""`
 	Ts            int64             `json:"ts"`
-	BlockId       string            `json:"blockid"`
+	ClientId      string            `json:"clientid"`
 	CorrelationId string            `json:"correlationid,omitempty"`
 	Dispose       bool              `json:"dispose,omitempty"` // the vdom context was closed
 	Resync        bool              `json:"resync,omitempty"`  // resync (send all backend data).  useful when the FE reloads

From 1379d9a68ac8ef3064529f30f255787fe21d60c6 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 14:11:54 -0700
Subject: [PATCH 012/134] add a clientid

---
 tsunami/app/serverhandlers.go | 15 +++++++++++++++
 tsunami/app/waveapp.go        | 19 +++++++++++++++++++
 tsunami/rpctypes/types.go     |  1 +
 3 files changed, 35 insertions(+)

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index 464c530c9e..49ec0f0263 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -59,6 +59,15 @@ func (h *HTTPHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	if feUpdate.ForceTakeover {
+		h.Client.ClientTakeover(feUpdate.ClientId)
+	}
+
+	if err := h.Client.CheckClientId(feUpdate.ClientId); err != nil {
+		http.Error(w, fmt.Sprintf("client id error: %v", err), http.StatusBadRequest)
+		return
+	}
+
 	if feUpdate.Dispose {
 		log.Printf("got dispose from frontend\n")
 		h.Client.doShutdown("got dispose from frontend")
@@ -152,6 +161,12 @@ func (h *HTTPHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	clientId := r.URL.Query().Get("clientId")
+	if err := h.Client.CheckClientId(clientId); err != nil {
+		http.Error(w, fmt.Sprintf("client id error: %v", err), http.StatusBadRequest)
+		return
+	}
+
 	// Set SSE headers
 	w.Header().Set("Content-Type", "text/event-stream")
 	w.Header().Set("Cache-Control", "no-cache")
diff --git a/tsunami/app/waveapp.go b/tsunami/app/waveapp.go
index 395e2f55b1..1c80893a92 100644
--- a/tsunami/app/waveapp.go
+++ b/tsunami/app/waveapp.go
@@ -61,6 +61,25 @@ func (c *Client) GetIsDone() bool {
 	return c.IsDone
 }
 
+func (c *Client) CheckClientId(clientId string) error {
+	if clientId == "" {
+		return fmt.Errorf("client id cannot be empty")
+	}
+	c.Lock.Lock()
+	defer c.Lock.Unlock()
+	if c.CurrentClientId == "" || c.CurrentClientId == clientId {
+		c.CurrentClientId = clientId
+		return nil
+	}
+	return fmt.Errorf("client id mismatch: expected %s, got %s", c.CurrentClientId, clientId)
+}
+
+func (c *Client) ClientTakeover(clientId string) {
+	c.Lock.Lock()
+	defer c.Lock.Unlock()
+	c.CurrentClientId = clientId
+}
+
 func (c *Client) doShutdown(reason string) {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
index 86a0fe36c0..b33b1de0d7 100644
--- a/tsunami/rpctypes/types.go
+++ b/tsunami/rpctypes/types.go
@@ -34,6 +34,7 @@ type VDomFrontendUpdate struct {
 	Type          string            `json:"type" tstype:"\"frontendupdate\""`
 	Ts            int64             `json:"ts"`
 	ClientId      string            `json:"clientid"`
+	ForceTakeover bool              `json:"forcetakeover,omitempty"`
 	CorrelationId string            `json:"correlationid,omitempty"`
 	Dispose       bool              `json:"dispose,omitempty"` // the vdom context was closed
 	Resync        bool              `json:"resync,omitempty"`  // resync (send all backend data).  useful when the FE reloads

From 432d333aca4744113c0c740b569d5abdbbc43564 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 31 Aug 2025 14:18:59 -0700
Subject: [PATCH 013/134] handle fe update should be in a critical section

---
 tsunami/app/serverhandlers.go | 39 ++++++++++++++++++++++++-----------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index 49ec0f0263..0fbed3862a 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -10,6 +10,7 @@ import (
 	"log"
 	"net/http"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
@@ -19,7 +20,8 @@ import (
 const SSEKeepAliveDuration = 5 * time.Second
 
 type HTTPHandlers struct {
-	Client *Client
+	Client     *Client
+	renderLock sync.Mutex
 }
 
 func NewHTTPHandlers(client *Client) *HTTPHandlers {
@@ -68,16 +70,34 @@ func (h *HTTPHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	update, err := h.processFrontendUpdate(&feUpdate)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("render error: %v", err), http.StatusInternalServerError)
+		return
+	}
+	if update == nil {
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(update); err != nil {
+		log.Printf("failed to encode response: %v", err)
+	}
+}
+
+func (h *HTTPHandlers) processFrontendUpdate(feUpdate *rpctypes.VDomFrontendUpdate) (*rpctypes.VDomBackendUpdate, error) {
+	h.renderLock.Lock()
+	defer h.renderLock.Unlock()
+
 	if feUpdate.Dispose {
 		log.Printf("got dispose from frontend\n")
 		h.Client.doShutdown("got dispose from frontend")
-		w.WriteHeader(http.StatusOK)
-		return
+		return nil, nil
 	}
 
 	if h.Client.GetIsDone() {
-		w.WriteHeader(http.StatusOK)
-		return
+		return nil, nil
 	}
 
 	h.Client.Root.RenderTs = feUpdate.Ts
@@ -111,16 +131,11 @@ func (h *HTTPHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if renderErr != nil {
-		http.Error(w, fmt.Sprintf("render error: %v", renderErr), http.StatusInternalServerError)
-		return
+		return nil, renderErr
 	}
 
 	update.CreateTransferElems()
-
-	w.Header().Set("Content-Type", "application/json")
-	if err := json.NewEncoder(w).Encode(update); err != nil {
-		log.Printf("failed to encode response: %v", err)
-	}
+	return update, nil
 }
 
 func (h *HTTPHandlers) handleVDomUrl(w http.ResponseWriter, r *http.Request) {

From 41d04b746de36b7fa36097733240895314ba466d Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 10:08:20 -0700
Subject: [PATCH 014/134] set go 1.24.6

---
 go.mod         | 2 +-
 tsunami/go.mod | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/go.mod b/go.mod
index 673758bf09..8d9e28f361 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
 module github.com/wavetermdev/waveterm
 
-go 1.24.2
+go 1.24.6
 
 require (
 	github.com/alexflint/go-filemutex v1.3.0
diff --git a/tsunami/go.mod b/tsunami/go.mod
index 68aaca9c38..eb3016560f 100644
--- a/tsunami/go.mod
+++ b/tsunami/go.mod
@@ -1,8 +1,6 @@
 module github.com/wavetermdev/waveterm/tsunami
 
-go 1.23.0
-
-toolchain go1.24.6
+go 1.24.6
 
 require (
 	github.com/google/uuid v1.6.0

From e256dfdfd532e38da5dd305b748d21bcc966355d Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 12:04:35 -0700
Subject: [PATCH 015/134] working on getting frontend setup (checkpoint)

---
 package.json                                 |   3 +-
 tsunami/frontend/index.html                  |  13 +
 tsunami/frontend/package.json                |  36 +
 tsunami/frontend/src/app.tsx                 |  17 +
 tsunami/frontend/src/element/markdown.tsx    |  87 +++
 tsunami/frontend/src/main.tsx                |  13 +
 tsunami/frontend/src/model/model-utils.ts    | 244 +++++++
 tsunami/frontend/src/model/tsunami-model.tsx | 690 +++++++++++++++++++
 tsunami/frontend/src/tailwind.css            |  62 ++
 tsunami/frontend/src/types/custom.d.ts       |  30 +
 tsunami/frontend/src/types/vdom.d.ts         | 243 +++++++
 tsunami/frontend/src/util/keyutil.ts         | 343 +++++++++
 tsunami/frontend/src/util/platformutil.ts    |  30 +
 tsunami/frontend/src/vdom.tsx                | 509 ++++++++++++++
 tsunami/frontend/tsconfig.json               |  26 +
 tsunami/frontend/vite.config.ts              |  22 +
 yarn.lock                                    |  88 ++-
 17 files changed, 2452 insertions(+), 4 deletions(-)
 create mode 100644 tsunami/frontend/index.html
 create mode 100644 tsunami/frontend/package.json
 create mode 100644 tsunami/frontend/src/app.tsx
 create mode 100644 tsunami/frontend/src/element/markdown.tsx
 create mode 100644 tsunami/frontend/src/main.tsx
 create mode 100644 tsunami/frontend/src/model/model-utils.ts
 create mode 100644 tsunami/frontend/src/model/tsunami-model.tsx
 create mode 100644 tsunami/frontend/src/tailwind.css
 create mode 100644 tsunami/frontend/src/types/custom.d.ts
 create mode 100644 tsunami/frontend/src/types/vdom.d.ts
 create mode 100644 tsunami/frontend/src/util/keyutil.ts
 create mode 100644 tsunami/frontend/src/util/platformutil.ts
 create mode 100644 tsunami/frontend/src/vdom.tsx
 create mode 100644 tsunami/frontend/tsconfig.json
 create mode 100644 tsunami/frontend/vite.config.ts

diff --git a/package.json b/package.json
index 915c737405..a1b2f62779 100644
--- a/package.json
+++ b/package.json
@@ -172,6 +172,7 @@
     },
     "packageManager": "yarn@4.6.0",
     "workspaces": [
-        "docs"
+        "docs",
+        "tsunami/frontend"
     ]
 }
diff --git a/tsunami/frontend/index.html b/tsunami/frontend/index.html
new file mode 100644
index 0000000000..cd14fa1d91
--- /dev/null
+++ b/tsunami/frontend/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Tsunami Frontend</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/tsunami/frontend/package.json b/tsunami/frontend/package.json
new file mode 100644
index 0000000000..7ac38ddd69
--- /dev/null
+++ b/tsunami/frontend/package.json
@@ -0,0 +1,36 @@
+{
+    "name": "tsunami-frontend",
+    "author": {
+        "name": "Command Line Inc",
+        "email": "info@commandline.dev"
+    },
+    "description": "Tsunami Frontend - React application",
+    "license": "Apache-2.0",
+    "version": "0.1.0",
+    "private": true,
+    "type": "module",
+    "scripts": {
+        "dev": "vite",
+        "build": "vite build",
+        "preview": "vite preview",
+        "type-check": "tsc --noEmit"
+    },
+    "dependencies": {
+        "clsx": "^2.1.1",
+        "debug": "^4.4.1",
+        "jotai": "^2.13.1",
+        "react": "^19.1.1",
+        "react-dom": "^19.1.1",
+        "react-markdown": "^10.1.0",
+        "tailwind-merge": "^3.3.1"
+    },
+    "devDependencies": {
+        "@tailwindcss/vite": "^4.0.17",
+        "@types/react": "^19",
+        "@types/react-dom": "^19",
+        "@vitejs/plugin-react-swc": "^4.0.1",
+        "tailwindcss": "^4.1.12",
+        "typescript": "^5.9.2",
+        "vite": "^6.0.0"
+    }
+}
diff --git a/tsunami/frontend/src/app.tsx b/tsunami/frontend/src/app.tsx
new file mode 100644
index 0000000000..823cf54d13
--- /dev/null
+++ b/tsunami/frontend/src/app.tsx
@@ -0,0 +1,17 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+function App() {
+    return (
+        <div className="min-h-screen bg-background text-foreground">
+            <div className="container mx-auto px-4 py-8">
+                <h1 className="text-title font-bold text-accent mb-4">Tsunami Frontend</h1>
+                <p className="text-default text-muted-foreground">
+                    Welcome to the Tsunami Frontend application built with React 19, TypeScript, and Tailwind v4.
+                </p>
+            </div>
+        </div>
+    );
+}
+
+export default App;
diff --git a/tsunami/frontend/src/element/markdown.tsx b/tsunami/frontend/src/element/markdown.tsx
new file mode 100644
index 0000000000..632964f86f
--- /dev/null
+++ b/tsunami/frontend/src/element/markdown.tsx
@@ -0,0 +1,87 @@
+import React from 'react';
+import ReactMarkdown, { Components } from 'react-markdown';
+import { twMerge } from 'tailwind-merge';
+
+interface MarkdownProps {
+    text?: string;
+    style?: React.CSSProperties;
+    className?: string;
+    scrollable?: boolean;
+}
+
+const markdownComponents: Partial<Components> = {
+    h1: ({ children }) => <h1 className="text-3xl font-bold mb-4 mt-6 text-foreground">{children}</h1>,
+    h2: ({ children }) => <h2 className="text-2xl font-bold mb-3 mt-5 text-foreground">{children}</h2>,
+    h3: ({ children }) => <h3 className="text-xl font-bold mb-3 mt-4 text-foreground">{children}</h3>,
+    h4: ({ children }) => <h4 className="text-lg font-bold mb-2 mt-3 text-foreground">{children}</h4>,
+    h5: ({ children }) => <h5 className="text-base font-bold mb-2 mt-3 text-foreground">{children}</h5>,
+    h6: ({ children }) => <h6 className="text-sm font-bold mb-2 mt-3 text-foreground">{children}</h6>,
+    p: ({ children }) => <p className="mb-4 leading-relaxed text-secondary">{children}</p>,
+    a: ({ href, children }) => (
+        <a href={href} className="text-accent hover:text-accent-300 underline">
+            {children}
+        </a>
+    ),
+    ul: ({ children }) => <ul className="list-disc list-inside mb-4 space-y-1 text-secondary">{children}</ul>,
+    ol: ({ children }) => <ol className="list-decimal list-inside mb-4 space-y-1 text-secondary">{children}</ol>,
+    li: ({ children }) => <li className="ml-4">{children}</li>,
+    code: ({ className, children }) => {
+        const isInline = !className;
+        if (isInline) {
+            return (
+                <code className="bg-panel text-foreground px-1 py-0.5 rounded text-sm font-mono">
+                    {children}
+                </code>
+            );
+        }
+        return (
+            <code className={className}>
+                {children}
+            </code>
+        );
+    },
+    pre: ({ children }) => (
+        <pre className="bg-panel text-foreground p-4 rounded-lg overflow-x-auto mb-4 text-sm font-mono">
+            {children}
+        </pre>
+    ),
+    blockquote: ({ children }) => (
+        <blockquote className="border-l-4 border-border pl-4 italic mb-4 text-muted">
+            {children}
+        </blockquote>
+    ),
+    hr: () => <hr className="border-border my-6" />,
+    table: ({ children }) => (
+        <div className="overflow-x-auto mb-4">
+            <table className="min-w-full border-collapse border border-border">
+                {children}
+            </table>
+        </div>
+    ),
+    th: ({ children }) => (
+        <th className="border border-border px-4 py-2 bg-panel font-bold text-left text-foreground">
+            {children}
+        </th>
+    ),
+    td: ({ children }) => (
+        <td className="border border-border px-4 py-2 text-secondary">
+            {children}
+        </td>
+    ),
+};
+
+export function Markdown({ text, style, className, scrollable = true }: MarkdownProps) {
+    const scrollClasses = scrollable ? "overflow-auto" : "";
+    const baseClasses = "prose prose-sm max-w-none";
+    
+    return (
+        <div
+            className={twMerge(baseClasses, scrollClasses, className)}
+            style={style}
+        >
+            <ReactMarkdown components={markdownComponents}>
+                {text || ''}
+            </ReactMarkdown>
+        </div>
+    );
+}
\ No newline at end of file
diff --git a/tsunami/frontend/src/main.tsx b/tsunami/frontend/src/main.tsx
new file mode 100644
index 0000000000..1764ca476e
--- /dev/null
+++ b/tsunami/frontend/src/main.tsx
@@ -0,0 +1,13 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import React from "react";
+import ReactDOM from "react-dom/client";
+import App from "./app";
+import "./tailwind.css";
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+    <React.StrictMode>
+        <App />
+    </React.StrictMode>
+);
diff --git a/tsunami/frontend/src/model/model-utils.ts b/tsunami/frontend/src/model/model-utils.ts
new file mode 100644
index 0000000000..c521ebb816
--- /dev/null
+++ b/tsunami/frontend/src/model/model-utils.ts
@@ -0,0 +1,244 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { CssNode, List, ListItem } from "css-tree";
+import * as csstree from "css-tree";
+import type { TsunamiModel } from "./tsunami-model";
+
+const TextTag = "#text";
+
+// TODO support binding
+export function getTextChildren(elem: VDomElem): string {
+    if (elem.tag == TextTag) {
+        return elem.text;
+    }
+    if (!elem.children) {
+        return null;
+    }
+    const textArr = elem.children.map((child) => {
+        return getTextChildren(child);
+    });
+    return textArr.join("");
+}
+
+export function convertVDomId(model: TsunamiModel, id: string): string {
+    return model.blockId + "::" + id;
+}
+
+export function validateAndWrapCss(model: TsunamiModel, cssText: string, wrapperClassName: string) {
+    try {
+        const ast = csstree.parse(cssText);
+        csstree.walk(ast, {
+            enter(node: CssNode, item: ListItem<CssNode>, list: List<CssNode>) {
+                // Remove disallowed @rules
+                const blockedRules = ["import", "font-face", "keyframes", "namespace", "supports"];
+                if (node.type === "Atrule" && blockedRules.includes(node.name)) {
+                    list.remove(item);
+                }
+                // Remove :root selectors
+                if (
+                    node.type === "Selector" &&
+                    node.children.some((child) => child.type === "PseudoClassSelector" && child.name === "root")
+                ) {
+                    list.remove(item);
+                }
+
+                if (node.type === "IdSelector") {
+                    node.name = convertVDomId(model, node.name);
+                }
+
+                // Transform url(#id) references in filter and mask properties (svg)
+                if (node.type === "Declaration" && ["filter", "mask"].includes(node.property)) {
+                    if (node.value && node.value.type === "Value" && "children" in node.value) {
+                        const urlNode = node.value.children
+                            .toArray()
+                            .find(
+                                (child: CssNode): child is CssNode & { value: string } =>
+                                    child && child.type === "Url" && typeof (child as any).value === "string"
+                            );
+                        if (urlNode && urlNode.value && urlNode.value.startsWith("#")) {
+                            urlNode.value = "#" + convertVDomId(model, urlNode.value.substring(1));
+                        }
+                    }
+                }
+                // transform url(vdom:///foo.jpg)
+                if (node.type === "Url" && node.value != null && node.value.startsWith("vdom://")) {
+                    const newUrl = model.transformVDomUrl(node.value);
+                    if (newUrl == null) {
+                        list.remove(item);
+                    } else {
+                        node.value = newUrl;
+                    }
+                }
+            },
+        });
+        const sanitizedCss = csstree.generate(ast);
+        return `.${wrapperClassName} { ${sanitizedCss} }`;
+    } catch (error) {
+        // TODO better error handling
+        console.error("CSS processing error:", error);
+        return null;
+    }
+}
+
+function cssTransformStyleValue(model: TsunamiModel, property: string, value: string): string {
+    try {
+        const ast = csstree.parse(value, { context: "value" });
+        csstree.walk(ast, {
+            enter(node: CssNode, item: ListItem<CssNode>, list: List<CssNode>) {
+                // Transform url(#id) in filter/mask properties
+                if (node.type === "Url" && (property === "filter" || property === "mask")) {
+                    if (node.value.startsWith("#")) {
+                        node.value = `#${convertVDomId(model, node.value.substring(1))}`;
+                    }
+                }
+                // transform vdom:// urls
+                if (node.type === "Url" && node.value != null && node.value.startsWith("vdom://")) {
+                    const newUrl = model.transformVDomUrl(node.value);
+                    if (newUrl == null) {
+                        list.remove(item);
+                    } else {
+                        node.value = newUrl;
+                    }
+                }
+            },
+        });
+
+        return csstree.generate(ast);
+    } catch (error) {
+        console.error("Error processing style value:", error);
+        return value;
+    }
+}
+
+export function validateAndWrapReactStyle(model: TsunamiModel, style: Record<string, any>): Record<string, any> {
+    const sanitizedStyle: Record<string, any> = {};
+    let updated = false;
+    for (const [property, value] of Object.entries(style)) {
+        if (value == null || value === "") {
+            continue;
+        }
+        if (typeof value !== "string") {
+            sanitizedStyle[property] = value; // For non-string values, just copy as-is
+            continue;
+        }
+        if (value.includes("vdom://") || value.includes("url(#")) {
+            updated = true;
+            sanitizedStyle[property] = cssTransformStyleValue(model, property, value);
+        } else {
+            sanitizedStyle[property] = value;
+        }
+    }
+    if (!updated) {
+        return style;
+    }
+    return sanitizedStyle;
+}
+
+export function restoreVDomElems(backendUpdate: VDomBackendUpdate) {
+    if (!backendUpdate.transferelems || !backendUpdate.renderupdates) {
+        return;
+    }
+
+    // Step 1: Map of waveid to VDomElem, skipping any without a waveid
+    const elemMap = new Map<string, VDomElem>();
+    backendUpdate.transferelems.forEach((transferElem) => {
+        if (!transferElem.waveid) {
+            return;
+        }
+        elemMap.set(transferElem.waveid, {
+            waveid: transferElem.waveid,
+            tag: transferElem.tag,
+            props: transferElem.props,
+            children: [], // Will populate children later
+            text: transferElem.text,
+        });
+    });
+
+    // Step 2: Build VDomElem trees by linking children
+    backendUpdate.transferelems.forEach((transferElem) => {
+        const parent = elemMap.get(transferElem.waveid);
+        if (!parent || !transferElem.children || transferElem.children.length === 0) {
+            return;
+        }
+        parent.children = transferElem.children.map((childId) => elemMap.get(childId)).filter((child) => child != null); // Explicit null check
+    });
+
+    // Step 3: Update renderupdates with rebuilt VDomElem trees
+    backendUpdate.renderupdates.forEach((update) => {
+        if (update.vdomwaveid) {
+            update.vdom = elemMap.get(update.vdomwaveid);
+        }
+    });
+}
+
+export function mergeBackendUpdates(baseUpdate: VDomBackendUpdate, nextUpdate: VDomBackendUpdate) {
+    // Verify the updates are from the same block/sequence
+    if (baseUpdate.blockid !== nextUpdate.blockid || baseUpdate.ts !== nextUpdate.ts) {
+        console.error("Attempted to merge updates from different blocks or timestamps");
+        return;
+    }
+
+    // Merge TransferElems
+    if (nextUpdate.transferelems?.length > 0) {
+        if (!baseUpdate.transferelems) {
+            baseUpdate.transferelems = [];
+        }
+        baseUpdate.transferelems.push(...nextUpdate.transferelems);
+    }
+
+    // Merge StateSync
+    if (nextUpdate.statesync?.length > 0) {
+        if (!baseUpdate.statesync) {
+            baseUpdate.statesync = [];
+        }
+        baseUpdate.statesync.push(...nextUpdate.statesync);
+    }
+}
+
+export function applyCanvasOp(canvas: HTMLCanvasElement, canvasOp: VDomRefOperation, refStore: Map<string, any>) {
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+        console.error("Canvas 2D context not available.");
+        return;
+    }
+
+    let { op, params, outputref } = canvasOp;
+    if (params == null) {
+        params = [];
+    }
+    if (op == null || op == "") {
+        return;
+    }
+    // Resolve any reference parameters in params
+    const resolvedParams: any[] = [];
+    params.forEach((param) => {
+        if (typeof param === "string" && param.startsWith("#ref:")) {
+            const refId = param.slice(5); // Remove "#ref:" prefix
+            resolvedParams.push(refStore.get(refId));
+        } else if (typeof param === "string" && param.startsWith("#spreadRef:")) {
+            const refId = param.slice(11); // Remove "#spreadRef:" prefix
+            const arrayRef = refStore.get(refId);
+            if (Array.isArray(arrayRef)) {
+                resolvedParams.push(...arrayRef); // Spread array elements
+            } else {
+                console.error(`Reference ${refId} is not an array and cannot be spread.`);
+            }
+        } else {
+            resolvedParams.push(param);
+        }
+    });
+
+    // Apply the operation on the canvas context
+    if (op === "dropRef" && params.length > 0 && typeof params[0] === "string") {
+        refStore.delete(params[0]);
+    } else if (op === "addRef" && outputref) {
+        refStore.set(outputref, resolvedParams[0]);
+    } else if (typeof ctx[op as keyof CanvasRenderingContext2D] === "function") {
+        (ctx[op as keyof CanvasRenderingContext2D] as Function).apply(ctx, resolvedParams);
+    } else if (op in ctx) {
+        (ctx as any)[op] = resolvedParams[0];
+    } else {
+        console.error(`Unsupported canvas operation: ${op}`);
+    }
+}
diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
new file mode 100644
index 0000000000..7d719cfc59
--- /dev/null
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -0,0 +1,690 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import debug from "debug";
+import * as jotai from "jotai";
+
+import { BlockNodeModel } from "@/app/block/blocktypes";
+import { getBlockMetaKeyAtom, globalStore, WOS } from "@/app/store/global";
+import { makeORef } from "@/app/store/wos";
+import { waveEventSubscribe } from "@/app/store/wps";
+import { RpcResponseHelper, WshClient } from "@/app/store/wshclient";
+import { RpcApi } from "@/app/store/wshclientapi";
+import { makeFeBlockRouteId } from "@/app/store/wshrouter";
+import { DefaultRouter, TabRpcClient } from "@/app/store/wshrpcutil";
+import { VDomView } from "@/app/view/vdom/vdom";
+import { adaptFromReactOrNativeKeyEvent, checkKeyPressed } from "@/util/keyutil";
+import { PLATFORM, PlatformMacOS } from "@/util/platformutil";
+import { applyCanvasOp, mergeBackendUpdates, restoreVDomElems } from "./model-utils";
+
+const dlog = debug("wave:vdom");
+
+type AtomContainer = {
+    val: any;
+    beVal: any;
+    usedBy: Set<string>;
+};
+
+type RefContainer = {
+    refFn: (elem: HTMLElement) => void;
+    vdomRef: VDomRef;
+    elem: HTMLElement;
+    updated: boolean;
+};
+
+function makeVDomIdMap(vdom: VDomElem, idMap: Map<string, VDomElem>) {
+    if (vdom == null) {
+        return;
+    }
+    if (vdom.waveid != null) {
+        idMap.set(vdom.waveid, vdom);
+    }
+    if (vdom.children == null) {
+        return;
+    }
+    for (let child of vdom.children) {
+        makeVDomIdMap(child, idMap);
+    }
+}
+
+function annotateEvent(event: VDomEvent, propName: string, reactEvent: React.SyntheticEvent) {
+    if (reactEvent == null) {
+        return;
+    }
+    if (propName == "onChange") {
+        const changeEvent = reactEvent as React.ChangeEvent<any>;
+        event.targetvalue = changeEvent.target?.value;
+        event.targetchecked = changeEvent.target?.checked;
+    }
+    if (propName == "onClick" || propName == "onMouseDown") {
+        const mouseEvent = reactEvent as React.MouseEvent<any>;
+        event.mousedata = {
+            button: mouseEvent.button,
+            buttons: mouseEvent.buttons,
+            alt: mouseEvent.altKey,
+            control: mouseEvent.ctrlKey,
+            shift: mouseEvent.shiftKey,
+            meta: mouseEvent.metaKey,
+            clientx: mouseEvent.clientX,
+            clienty: mouseEvent.clientY,
+            pagex: mouseEvent.pageX,
+            pagey: mouseEvent.pageY,
+            screenx: mouseEvent.screenX,
+            screeny: mouseEvent.screenY,
+            movementx: mouseEvent.movementX,
+            movementy: mouseEvent.movementY,
+        };
+        if (PLATFORM == PlatformMacOS) {
+            event.mousedata.cmd = event.mousedata.meta;
+            event.mousedata.option = event.mousedata.alt;
+        } else {
+            event.mousedata.cmd = event.mousedata.alt;
+            event.mousedata.option = event.mousedata.meta;
+        }
+    }
+    if (propName == "onKeyDown") {
+        const waveKeyEvent = adaptFromReactOrNativeKeyEvent(reactEvent as React.KeyboardEvent);
+        event.keydata = waveKeyEvent;
+    }
+}
+
+class VDomWshClient extends WshClient {
+    model: TsunamiModel;
+
+    constructor(model: TsunamiModel) {
+        super(makeFeBlockRouteId(model.blockId));
+        this.model = model;
+    }
+
+    handle_vdomasyncinitiation(rh: RpcResponseHelper, data: VDomAsyncInitiationRequest) {
+        dlog("async-initiation", rh.getSource(), data);
+        this.model.queueUpdate(true);
+    }
+}
+
+export class TsunamiModel {
+    blockId: string;
+    nodeModel: BlockNodeModel;
+    viewType: string;
+    viewIcon: jotai.Atom<string>;
+    viewName: jotai.Atom<string>;
+    viewRef: React.RefObject<HTMLDivElement> = { current: null };
+    vdomRoot: jotai.PrimitiveAtom<VDomElem> = jotai.atom();
+    atoms: Map<string, AtomContainer> = new Map(); // key is atomname
+    refs: Map<string, RefContainer> = new Map(); // key is refid
+    batchedEvents: VDomEvent[] = [];
+    messages: VDomMessage[] = [];
+    needsResync: boolean = true;
+    vdomNodeVersion: WeakMap<VDomElem, jotai.PrimitiveAtom<number>> = new WeakMap();
+    compoundAtoms: Map<string, jotai.PrimitiveAtom<{ [key: string]: any }>> = new Map();
+    rootRefId: string = crypto.randomUUID();
+    backendRoute: jotai.Atom<string>;
+    backendOpts: VDomBackendOpts;
+    shouldDispose: boolean;
+    disposed: boolean;
+    hasPendingRequest: boolean;
+    needsUpdate: boolean;
+    maxNormalUpdateIntervalMs: number = 100;
+    needsImmediateUpdate: boolean;
+    lastUpdateTs: number = 0;
+    queuedUpdate: { timeoutId: any; ts: number; quick: boolean };
+    contextActive: jotai.PrimitiveAtom<boolean>;
+    wshClient: VDomWshClient;
+    persist: jotai.Atom<boolean>;
+    routeGoneUnsub: () => void;
+    routeConfirmed: boolean = false;
+    refOutputStore: Map<string, any> = new Map();
+    globalVersion: jotai.PrimitiveAtom<number> = jotai.atom(0);
+    hasBackendWork: boolean = false;
+    noPadding: jotai.PrimitiveAtom<boolean>;
+
+    constructor(blockId: string, nodeModel: BlockNodeModel) {
+        this.viewType = "vdom";
+        this.blockId = blockId;
+        this.nodeModel = nodeModel;
+        this.contextActive = jotai.atom(false);
+        this.reset();
+        this.viewIcon = jotai.atom("bolt");
+        this.viewName = jotai.atom("Wave App");
+        this.backendRoute = jotai.atom((get) => {
+            const blockData = get(WOS.getWaveObjectAtom<Block>(makeORef("block", this.blockId)));
+            return blockData?.meta?.["vdom:route"];
+        });
+        this.noPadding = jotai.atom(true);
+        this.persist = getBlockMetaKeyAtom(this.blockId, "vdom:persist");
+        this.wshClient = new VDomWshClient(this);
+        DefaultRouter.registerRoute(this.wshClient.routeId, this.wshClient);
+        const curBackendRoute = globalStore.get(this.backendRoute);
+        if (curBackendRoute) {
+            this.queueUpdate(true);
+        }
+        this.routeGoneUnsub = waveEventSubscribe({
+            eventType: "route:gone",
+            scope: curBackendRoute,
+            handler: (event: WaveEvent) => {
+                this.disposed = true;
+                const shouldPersist = globalStore.get(this.persist);
+                if (!shouldPersist) {
+                    this.nodeModel?.onClose?.();
+                }
+            },
+        });
+        RpcApi.WaitForRouteCommand(TabRpcClient, { routeid: curBackendRoute, waitms: 4000 }, { timeout: 5000 }).then(
+            (routeOk: boolean) => {
+                if (routeOk) {
+                    this.routeConfirmed = true;
+                    this.queueUpdate(true);
+                } else {
+                    this.disposed = true;
+                    const shouldPersist = globalStore.get(this.persist);
+                    if (!shouldPersist) {
+                        this.nodeModel?.onClose?.();
+                    }
+                }
+            }
+        );
+    }
+
+    get viewComponent(): ViewComponent {
+        return VDomView;
+    }
+
+    dispose() {
+        DefaultRouter.unregisterRoute(this.wshClient.routeId);
+        this.routeGoneUnsub?.();
+    }
+
+    reset() {
+        globalStore.set(this.vdomRoot, null);
+        this.atoms.clear();
+        this.refs.clear();
+        this.batchedEvents = [];
+        this.messages = [];
+        this.needsResync = true;
+        this.vdomNodeVersion = new WeakMap();
+        this.compoundAtoms.clear();
+        this.rootRefId = crypto.randomUUID();
+        this.backendOpts = {};
+        this.shouldDispose = false;
+        this.disposed = false;
+        this.hasPendingRequest = false;
+        this.needsUpdate = false;
+        this.maxNormalUpdateIntervalMs = 100;
+        this.needsImmediateUpdate = false;
+        this.lastUpdateTs = 0;
+        this.queuedUpdate = null;
+        this.refOutputStore.clear();
+        this.globalVersion = jotai.atom(0);
+        this.hasBackendWork = false;
+        globalStore.set(this.contextActive, false);
+    }
+
+    getBackendRoute(): string {
+        const blockData = globalStore.get(WOS.getWaveObjectAtom<Block>(makeORef("block", this.blockId)));
+        return blockData?.meta?.["vdom:route"];
+    }
+
+    transformVDomUrl(url: string): string {
+        if (url == null || url == "") {
+            return null;
+        }
+        if (!url.startsWith("vdom://")) {
+            return url;
+        }
+        const absUrl = url.substring(7);
+        return this.makeVDomUrl(absUrl);
+    }
+
+    makeVDomUrl(path: string): string {
+        if (path == null || path == "") {
+            return null;
+        }
+        if (!path.startsWith("/")) {
+            return null;
+        }
+        const backendRouteId = this.getBackendRouteId();
+        if (backendRouteId == null) {
+            return null;
+        }
+        const fullUrl = "/vdom/" + backendRouteId + path;
+        return fullUrl;
+    }
+
+    keyDownHandler(e: WaveKeyboardEvent): boolean {
+        if (this.backendOpts?.closeonctrlc && checkKeyPressed(e, "Ctrl:c")) {
+            this.shouldDispose = true;
+            this.queueUpdate(true);
+            return true;
+        }
+        if (this.backendOpts?.globalkeyboardevents) {
+            if (e.cmd || e.meta) {
+                return false;
+            }
+            this.batchedEvents.push({
+                globaleventtype: "onKeyDown",
+                waveid: null,
+                eventtype: "onKeyDown",
+                keydata: e,
+            });
+            this.queueUpdate();
+            return true;
+        }
+        return false;
+    }
+
+    hasRefUpdates() {
+        for (let ref of this.refs.values()) {
+            if (ref.updated) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    getRefUpdates(): VDomRefUpdate[] {
+        let updates: VDomRefUpdate[] = [];
+        for (let ref of this.refs.values()) {
+            if (ref.updated || (ref.vdomRef.trackposition && ref.elem != null)) {
+                const ru: VDomRefUpdate = {
+                    refid: ref.vdomRef.refid,
+                    hascurrent: ref.vdomRef.hascurrent,
+                };
+                if (ref.vdomRef.trackposition && ref.elem != null) {
+                    ru.position = {
+                        offsetheight: ref.elem.offsetHeight,
+                        offsetwidth: ref.elem.offsetWidth,
+                        scrollheight: ref.elem.scrollHeight,
+                        scrollwidth: ref.elem.scrollWidth,
+                        scrolltop: ref.elem.scrollTop,
+                        boundingclientrect: ref.elem.getBoundingClientRect(),
+                    };
+                }
+                updates.push(ru);
+                ref.updated = false;
+            }
+        }
+        return updates;
+    }
+
+    queueUpdate(quick: boolean = false, delay: number = 10) {
+        if (this.disposed) {
+            return;
+        }
+        this.needsUpdate = true;
+        let nowTs = Date.now();
+        if (delay > this.maxNormalUpdateIntervalMs) {
+            delay = this.maxNormalUpdateIntervalMs;
+        }
+        if (quick) {
+            if (this.queuedUpdate) {
+                if (this.queuedUpdate.quick || this.queuedUpdate.ts <= nowTs) {
+                    return;
+                }
+                clearTimeout(this.queuedUpdate.timeoutId);
+                this.queuedUpdate = null;
+            }
+            let timeoutId = setTimeout(() => {
+                this._sendRenderRequest(true);
+            }, 0);
+            this.queuedUpdate = { timeoutId: timeoutId, ts: nowTs, quick: true };
+            return;
+        }
+        if (this.queuedUpdate) {
+            return;
+        }
+        let lastUpdateDiff = nowTs - this.lastUpdateTs;
+        let timeoutMs: number = null;
+        if (lastUpdateDiff >= this.maxNormalUpdateIntervalMs) {
+            // it has been a while since the last update, so use delay
+            timeoutMs = delay;
+        } else {
+            timeoutMs = this.maxNormalUpdateIntervalMs - lastUpdateDiff;
+        }
+        if (timeoutMs < delay) {
+            timeoutMs = delay;
+        }
+        let timeoutId = setTimeout(() => {
+            this._sendRenderRequest(false);
+        }, timeoutMs);
+        this.queuedUpdate = { timeoutId: timeoutId, ts: nowTs + timeoutMs, quick: false };
+    }
+
+    async _sendRenderRequest(force: boolean) {
+        this.queuedUpdate = null;
+        if (this.disposed || !this.routeConfirmed) {
+            return;
+        }
+        if (this.hasPendingRequest) {
+            if (force) {
+                this.needsImmediateUpdate = true;
+            }
+            return;
+        }
+        if (!force && !this.needsUpdate) {
+            return;
+        }
+        const backendRoute = globalStore.get(this.backendRoute);
+        if (backendRoute == null) {
+            console.log("vdom-model", "no backend route");
+            return;
+        }
+        this.hasPendingRequest = true;
+        this.needsImmediateUpdate = false;
+        try {
+            const feUpdate = this.createFeUpdate();
+            dlog("fe-update", feUpdate);
+            const beUpdateGen = await RpcApi.VDomRenderCommand(TabRpcClient, feUpdate, { route: backendRoute });
+            let baseUpdate: VDomBackendUpdate = null;
+            for await (const beUpdate of beUpdateGen) {
+                if (baseUpdate === null) {
+                    baseUpdate = beUpdate;
+                } else {
+                    mergeBackendUpdates(baseUpdate, beUpdate);
+                }
+            }
+            if (baseUpdate !== null) {
+                restoreVDomElems(baseUpdate);
+                dlog("be-update", baseUpdate);
+                this.handleBackendUpdate(baseUpdate);
+            }
+            dlog("update cycle done");
+        } finally {
+            this.lastUpdateTs = Date.now();
+            this.hasPendingRequest = false;
+        }
+        if (this.needsImmediateUpdate) {
+            this.queueUpdate(true);
+        }
+    }
+
+    getAtomContainer(atomName: string): AtomContainer {
+        let container = this.atoms.get(atomName);
+        if (container == null) {
+            container = {
+                val: null,
+                beVal: null,
+                usedBy: new Set(),
+            };
+            this.atoms.set(atomName, container);
+        }
+        return container;
+    }
+
+    getOrCreateRefContainer(vdomRef: VDomRef): RefContainer {
+        let container = this.refs.get(vdomRef.refid);
+        if (container == null) {
+            container = {
+                refFn: (elem: HTMLElement) => {
+                    container.elem = elem;
+                    const hasElem = elem != null;
+                    if (vdomRef.hascurrent != hasElem) {
+                        container.updated = true;
+                        vdomRef.hascurrent = hasElem;
+                    }
+                },
+                vdomRef: vdomRef,
+                elem: null,
+                updated: false,
+            };
+            this.refs.set(vdomRef.refid, container);
+        }
+        return container;
+    }
+
+    tagUseAtoms(waveId: string, atomNames: Set<string>) {
+        for (let atomName of atomNames) {
+            let container = this.getAtomContainer(atomName);
+            container.usedBy.add(waveId);
+        }
+    }
+
+    tagUnuseAtoms(waveId: string, atomNames: Set<string>) {
+        for (let atomName of atomNames) {
+            let container = this.getAtomContainer(atomName);
+            container.usedBy.delete(waveId);
+        }
+    }
+
+    getVDomNodeVersionAtom(vdom: VDomElem) {
+        let atom = this.vdomNodeVersion.get(vdom);
+        if (atom == null) {
+            atom = jotai.atom(0);
+            this.vdomNodeVersion.set(vdom, atom);
+        }
+        return atom;
+    }
+
+    incVDomNodeVersion(vdom: VDomElem) {
+        if (vdom == null) {
+            return;
+        }
+        const atom = this.getVDomNodeVersionAtom(vdom);
+        globalStore.set(atom, globalStore.get(atom) + 1);
+    }
+
+    addErrorMessage(message: string) {
+        this.messages.push({
+            messagetype: "error",
+            message: message,
+        });
+    }
+
+    handleRenderUpdates(update: VDomBackendUpdate, idMap: Map<string, VDomElem>) {
+        if (!update.renderupdates) {
+            return;
+        }
+        for (let renderUpdate of update.renderupdates) {
+            if (renderUpdate.updatetype == "root") {
+                globalStore.set(this.vdomRoot, renderUpdate.vdom);
+                continue;
+            }
+            if (renderUpdate.updatetype == "append") {
+                let parent = idMap.get(renderUpdate.waveid);
+                if (parent == null) {
+                    this.addErrorMessage(`Could not find vdom with id ${renderUpdate.waveid} (for renderupdates)`);
+                    continue;
+                }
+                if (parent.children == null) {
+                    parent.children = [];
+                }
+                parent.children.push(renderUpdate.vdom);
+                this.incVDomNodeVersion(parent);
+                continue;
+            }
+            if (renderUpdate.updatetype == "replace") {
+                let parent = idMap.get(renderUpdate.waveid);
+                if (parent == null) {
+                    this.addErrorMessage(`Could not find vdom with id ${renderUpdate.waveid} (for renderupdates)`);
+                    continue;
+                }
+                if (renderUpdate.index < 0 || parent.children == null || parent.children.length <= renderUpdate.index) {
+                    this.addErrorMessage(`Could not find child at index ${renderUpdate.index} (for renderupdates)`);
+                    continue;
+                }
+                parent.children[renderUpdate.index] = renderUpdate.vdom;
+                this.incVDomNodeVersion(parent);
+                continue;
+            }
+            if (renderUpdate.updatetype == "remove") {
+                let parent = idMap.get(renderUpdate.waveid);
+                if (parent == null) {
+                    this.addErrorMessage(`Could not find vdom with id ${renderUpdate.waveid} (for renderupdates)`);
+                    continue;
+                }
+                if (renderUpdate.index < 0 || parent.children == null || parent.children.length <= renderUpdate.index) {
+                    this.addErrorMessage(`Could not find child at index ${renderUpdate.index} (for renderupdates)`);
+                    continue;
+                }
+                parent.children.splice(renderUpdate.index, 1);
+                this.incVDomNodeVersion(parent);
+                continue;
+            }
+            if (renderUpdate.updatetype == "insert") {
+                let parent = idMap.get(renderUpdate.waveid);
+                if (parent == null) {
+                    this.addErrorMessage(`Could not find vdom with id ${renderUpdate.waveid} (for renderupdates)`);
+                    continue;
+                }
+                if (parent.children == null) {
+                    parent.children = [];
+                }
+                if (renderUpdate.index < 0 || parent.children.length < renderUpdate.index) {
+                    this.addErrorMessage(`Could not find child at index ${renderUpdate.index} (for renderupdates)`);
+                    continue;
+                }
+                parent.children.splice(renderUpdate.index, 0, renderUpdate.vdom);
+                this.incVDomNodeVersion(parent);
+                continue;
+            }
+            this.addErrorMessage(`Unknown updatetype ${renderUpdate.updatetype}`);
+        }
+    }
+
+    setAtomValue(atomName: string, value: any, fromBe: boolean, idMap: Map<string, VDomElem>) {
+        dlog("setAtomValue", atomName, value, fromBe);
+        let container = this.getAtomContainer(atomName);
+        container.val = value;
+        if (fromBe) {
+            container.beVal = value;
+        }
+        for (let id of container.usedBy) {
+            this.incVDomNodeVersion(idMap.get(id));
+        }
+    }
+
+    handleStateSync(update: VDomBackendUpdate, idMap: Map<string, VDomElem>) {
+        if (update.statesync == null) {
+            return;
+        }
+        for (let sync of update.statesync) {
+            this.setAtomValue(sync.atom, sync.value, true, idMap);
+        }
+    }
+
+    getRefElem(refId: string): HTMLElement {
+        if (refId == this.rootRefId) {
+            return this.viewRef.current;
+        }
+        const ref = this.refs.get(refId);
+        return ref?.elem;
+    }
+
+    handleRefOperations(update: VDomBackendUpdate, idMap: Map<string, VDomElem>) {
+        if (update.refoperations == null) {
+            return;
+        }
+        for (let refOp of update.refoperations) {
+            const elem = this.getRefElem(refOp.refid);
+            if (elem == null) {
+                this.addErrorMessage(`Could not find ref with id ${refOp.refid}`);
+                continue;
+            }
+            if (elem instanceof HTMLCanvasElement) {
+                applyCanvasOp(elem, refOp, this.refOutputStore);
+                continue;
+            }
+            if (refOp.op == "focus") {
+                if (elem == null) {
+                    this.addErrorMessage(`Could not focus ref with id ${refOp.refid}: elem is null`);
+                    continue;
+                }
+                try {
+                    elem.focus();
+                } catch (e) {
+                    this.addErrorMessage(`Could not focus ref with id ${refOp.refid}: ${e.message}`);
+                }
+            } else {
+                this.addErrorMessage(`Unknown ref operation ${refOp.refid} ${refOp.op}`);
+            }
+        }
+    }
+
+    handleBackendUpdate(update: VDomBackendUpdate) {
+        if (update == null) {
+            return;
+        }
+        globalStore.set(this.contextActive, true);
+        const idMap = new Map<string, VDomElem>();
+        const vdomRoot = globalStore.get(this.vdomRoot);
+        if (update.opts != null) {
+            this.backendOpts = update.opts;
+        }
+        makeVDomIdMap(vdomRoot, idMap);
+        this.handleRenderUpdates(update, idMap);
+        this.handleStateSync(update, idMap);
+        this.handleRefOperations(update, idMap);
+        if (update.messages) {
+            for (let message of update.messages) {
+                console.log("vdom-message", this.blockId, message.messagetype, message.message);
+                if (message.stacktrace) {
+                    console.log("vdom-message-stacktrace", message.stacktrace);
+                }
+            }
+        }
+        globalStore.set(this.globalVersion, globalStore.get(this.globalVersion) + 1);
+        if (update.haswork) {
+            this.hasBackendWork = true;
+        }
+    }
+
+    renderDone(version: number) {
+        // called when the render is done
+        dlog("renderDone", version);
+        if (this.hasRefUpdates() || this.hasBackendWork) {
+            this.hasBackendWork = false;
+            this.queueUpdate(true);
+        }
+    }
+
+    callVDomFunc(fnDecl: VDomFunc, e: React.SyntheticEvent, compId: string, propName: string) {
+        const vdomEvent: VDomEvent = {
+            waveid: compId,
+            eventtype: propName,
+        };
+        if (fnDecl.globalevent) {
+            vdomEvent.globaleventtype = fnDecl.globalevent;
+        }
+        annotateEvent(vdomEvent, propName, e);
+        this.batchedEvents.push(vdomEvent);
+        this.queueUpdate(true);
+    }
+
+    createFeUpdate(): VDomFrontendUpdate {
+        const blockORef = makeORef("block", this.blockId);
+        const blockAtom = WOS.getWaveObjectAtom<Block>(blockORef);
+        const blockData = globalStore.get(blockAtom);
+        const isBlockFocused = globalStore.get(this.nodeModel.isFocused);
+        const renderContext: VDomRenderContext = {
+            blockid: this.blockId,
+            focused: isBlockFocused,
+            width: this.viewRef?.current?.offsetWidth ?? 0,
+            height: this.viewRef?.current?.offsetHeight ?? 0,
+            rootrefid: this.rootRefId,
+            background: false,
+        };
+        const feUpdate: VDomFrontendUpdate = {
+            type: "frontendupdate",
+            ts: Date.now(),
+            blockid: this.blockId,
+            rendercontext: renderContext,
+            dispose: this.shouldDispose,
+            resync: this.needsResync,
+            events: this.batchedEvents,
+            refupdates: this.getRefUpdates(),
+        };
+        this.needsResync = false;
+        this.batchedEvents = [];
+        if (this.shouldDispose) {
+            this.disposed = true;
+        }
+        return feUpdate;
+    }
+
+    getBackendRouteId(): string {
+        const fullRoute = globalStore.get(this.backendRoute);
+        if (fullRoute == null || !fullRoute.startsWith("proc:")) {
+            return null;
+        }
+        return fullRoute?.split(":")[1];
+    }
+}
diff --git a/tsunami/frontend/src/tailwind.css b/tsunami/frontend/src/tailwind.css
new file mode 100644
index 0000000000..224623f0bd
--- /dev/null
+++ b/tsunami/frontend/src/tailwind.css
@@ -0,0 +1,62 @@
+/* Copyright 2025, Command Line Inc. */
+/* SPDX-License-Identifier: Apache-2.0 */
+
+@import "tailwindcss";
+
+@theme {
+    --color-background: rgb(34, 34, 34);
+    --color-foreground: #f7f7f7;
+    --color-white: #f7f7f7;
+    --color-secondary: rgba(215, 218, 224, 0.7);
+    --color-muted: rgba(215, 218, 224, 0.5);
+    --color-accent-50: rgb(236, 253, 232);
+    --color-accent-100: rgb(209, 250, 202);
+    --color-accent-200: rgb(167, 243, 168);
+    --color-accent-300: rgb(110, 231, 133);
+    --color-accent-400: rgb(88, 193, 66); /* main accent color */
+    --color-accent-500: rgb(63, 162, 51);
+    --color-accent-600: rgb(47, 133, 47);
+    --color-accent-700: rgb(34, 104, 43);
+    --color-accent-800: rgb(22, 81, 35);
+    --color-accent-900: rgb(15, 61, 29);
+    --color-error: rgb(229, 77, 46);
+    --color-warning: rgb(224, 185, 86);
+    --color-success: rgb(78, 154, 6);
+    --color-panel: rgba(31, 33, 31, 0.5);
+    --color-hover: rgba(255, 255, 255, 0.1);
+    --color-border: rgba(255, 255, 255, 0.16);
+    --color-modalbg: #232323;
+    --color-accentbg: rgba(88, 193, 66, 0.5);
+    --color-hoverbg: rgba(255, 255, 255, 0.2);
+    --color-accent: rgb(88, 193, 66);
+    --color-accenthover: rgb(118, 223, 96);
+
+    --font-sans: "Inter", sans-serif;
+    --font-mono: "Hack", monospace;
+    --font-markdown: -apple-system, BlinkMacSystemFont, "Segoe UI", "Noto Sans", Helvetica, Arial, sans-serif,
+        "Apple Color Emoji", "Segoe UI Emoji";
+
+    --text-xxs: 10px;
+    --text-title: 18px;
+    --text-default: 14px;
+
+    --radius: 8px;
+
+    /* ANSI Colors (Default Dark Palette) */
+    --ansi-black: #757575;
+    --ansi-red: #cc685c;
+    --ansi-green: #76c266;
+    --ansi-yellow: #cbca9b;
+    --ansi-blue: #85aacb;
+    --ansi-magenta: #cc72ca;
+    --ansi-cyan: #74a7cb;
+    --ansi-white: #c1c1c1;
+    --ansi-brightblack: #727272;
+    --ansi-brightred: #cc9d97;
+    --ansi-brightgreen: #a3dd97;
+    --ansi-brightyellow: #cbcaaa;
+    --ansi-brightblue: #9ab6cb;
+    --ansi-brightmagenta: #cc8ecb;
+    --ansi-brightcyan: #b7b8cb;
+    --ansi-brightwhite: #f0f0f0;
+}
diff --git a/tsunami/frontend/src/types/custom.d.ts b/tsunami/frontend/src/types/custom.d.ts
new file mode 100644
index 0000000000..1c5b788ade
--- /dev/null
+++ b/tsunami/frontend/src/types/custom.d.ts
@@ -0,0 +1,30 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// vdom.WaveKeyboardEvent
+type WaveKeyboardEvent = {
+    type: "keydown" | "keyup" | "keypress" | "unknown";
+    key: string;
+    code: string;
+    repeat?: boolean;
+    location?: number;
+    shift?: boolean;
+    control?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    cmd?: boolean;
+    option?: boolean;
+};
+
+type KeyPressDecl = {
+    mods: {
+        Cmd?: boolean;
+        Option?: boolean;
+        Shift?: boolean;
+        Ctrl?: boolean;
+        Alt?: boolean;
+        Meta?: boolean;
+    };
+    key: string;
+    keyType: string;
+};
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
new file mode 100644
index 0000000000..9ec52fcc01
--- /dev/null
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -0,0 +1,243 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// vdom.VDomAsyncInitiationRequest
+type VDomAsyncInitiationRequest = {
+    type: "asyncinitiationrequest";
+    ts: number;
+    blockid?: string;
+};
+
+// vdom.VDomBackendOpts
+type VDomBackendOpts = {
+    closeonctrlc?: boolean;
+    globalkeyboardevents?: boolean;
+    globalstyles?: boolean;
+};
+
+// vdom.VDomBackendUpdate
+type VDomBackendUpdate = {
+    type: "backendupdate";
+    ts: number;
+    opts?: VDomBackendOpts;
+    haswork?: boolean;
+    renderupdates?: VDomRenderUpdate[];
+    transferelems?: VDomTransferElem[];
+    statesync?: VDomStateSync[];
+    refoperations?: VDomRefOperation[];
+    messages?: VDomMessage[];
+};
+
+// vdom.VDomBinding
+type VDomBinding = {
+    type: "binding";
+    bind: string;
+};
+
+// vdom.VDomCreateContext
+type VDomCreateContext = {
+    type: "createcontext";
+    ts: number;
+    meta?: MetaType;
+    target?: VDomTarget;
+    persist?: boolean;
+};
+
+// vdom.VDomElem
+type VDomElem = {
+    waveid?: string;
+    tag: string;
+    props?: { [key: string]: any };
+    children?: VDomElem[];
+    text?: string;
+};
+
+// vdom.VDomEvent
+type VDomEvent = {
+    waveid: string;
+    eventtype: string;
+    globaleventtype?: string;
+    targetvalue?: string;
+    targetchecked?: boolean;
+    targetname?: string;
+    targetid?: string;
+    keydata?: WaveKeyboardEvent;
+    mousedata?: WavePointerData;
+};
+
+// vdom.VDomFrontendUpdate
+type VDomFrontendUpdate = {
+    type: "frontendupdate";
+    ts: number;
+    clientid: string;
+    forcetakeover?: boolean;
+    correlationid?: string;
+    dispose?: boolean;
+    resync?: boolean;
+    rendercontext: VDomRenderContext;
+    events?: VDomEvent[];
+    statesync?: VDomStateSync[];
+    refupdates?: VDomRefUpdate[];
+    messages?: VDomMessage[];
+};
+
+// vdom.VDomFunc
+type VDomFunc = {
+    type: "func";
+    stoppropagation?: boolean;
+    preventdefault?: boolean;
+    globalevent?: string;
+    "#keys"?: string[];
+};
+
+// vdom.VDomMessage
+type VDomMessage = {
+    messagetype: string;
+    message: string;
+    stacktrace?: string;
+    params?: any[];
+};
+
+// vdom.VDomRef
+type VDomRef = {
+    type: "ref";
+    refid: string;
+    trackposition?: boolean;
+    position?: VDomRefPosition;
+    hascurrent?: boolean;
+};
+
+// vdom.VDomRefOperation
+type VDomRefOperation = {
+    refid: string;
+    op: string;
+    params?: any[];
+    outputref?: string;
+};
+
+// vdom.VDomRefPosition
+type VDomRefPosition = {
+    offsetheight: number;
+    offsetwidth: number;
+    scrollheight: number;
+    scrollwidth: number;
+    scrolltop: number;
+    boundingclientrect: DomRect;
+};
+
+// vdom.VDomRefUpdate
+type VDomRefUpdate = {
+    refid: string;
+    hascurrent: boolean;
+    position?: VDomRefPosition;
+};
+
+// vdom.VDomRenderContext
+type VDomRenderContext = {
+    blockid: string;
+    focused: boolean;
+    width: number;
+    height: number;
+    rootrefid: string;
+    background?: boolean;
+};
+
+// vdom.VDomRenderUpdate
+type VDomRenderUpdate = {
+    updatetype: "root" | "append" | "replace" | "remove" | "insert";
+    waveid?: string;
+    vdomwaveid?: string;
+    vdom?: VDomElem;
+    index?: number;
+};
+
+// vdom.VDomStateSync
+type VDomStateSync = {
+    atom: string;
+    value: any;
+};
+
+// vdom.VDomTarget
+type VDomTarget = {
+    newblock?: boolean;
+    magnified?: boolean;
+    toolbar?: VDomTargetToolbar;
+};
+
+// vdom.VDomTargetToolbar
+type VDomTargetToolbar = {
+    toolbar: boolean;
+    height?: string;
+};
+
+// vdom.VDomTransferElem
+type VDomTransferElem = {
+    waveid?: string;
+    tag: string;
+    props?: { [key: string]: any };
+    children?: string[];
+    text?: string;
+};
+
+// wshrpc.VDomUrlRequestData
+type VDomUrlRequestData = {
+    method: string;
+    url: string;
+    headers: { [key: string]: string };
+    body?: string;
+};
+
+// wshrpc.VDomUrlRequestResponse
+type VDomUrlRequestResponse = {
+    statuscode?: number;
+    headers?: { [key: string]: string };
+    body?: Uint8Array;
+};
+
+// Additional types from rpctypes that were missing
+type VDomKeyboardEvent = {
+    type: string;
+    key: string;
+    code: string;
+    shift?: boolean;
+    control?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    cmd?: boolean;
+    option?: boolean;
+    repeat?: boolean;
+    location?: number;
+};
+
+type WaveKeyboardEvent = {
+    type: "keydown" | "keyup" | "keypress" | "unknown";
+    key: string;
+    code: string;
+    repeat?: boolean;
+    location?: number;
+    shift?: boolean;
+    control?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    cmd?: boolean;
+    option?: boolean;
+};
+
+type WavePointerData = {
+    button: number;
+    buttons: number;
+    clientx?: number;
+    clienty?: number;
+    pagex?: number;
+    pagey?: number;
+    screenx?: number;
+    screeny?: number;
+    movementx?: number;
+    movementy?: number;
+    shift?: boolean;
+    control?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    cmd?: boolean;
+    option?: boolean;
+};
diff --git a/tsunami/frontend/src/util/keyutil.ts b/tsunami/frontend/src/util/keyutil.ts
new file mode 100644
index 0000000000..25b6c8dbf1
--- /dev/null
+++ b/tsunami/frontend/src/util/keyutil.ts
@@ -0,0 +1,343 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+const KeyTypeCodeRegex = /c{(.*)}/;
+const KeyTypeKey = "key";
+const KeyTypeCode = "code";
+
+let PLATFORM: NodeJS.Platform = "darwin";
+const PlatformMacOS = "darwin";
+
+function setKeyUtilPlatform(platform: NodeJS.Platform) {
+    PLATFORM = platform;
+}
+
+function getKeyUtilPlatform(): NodeJS.Platform {
+    return PLATFORM;
+}
+
+function keydownWrapper(
+    fn: (waveEvent: WaveKeyboardEvent) => boolean
+): (event: KeyboardEvent | React.KeyboardEvent) => void {
+    return (event: KeyboardEvent | React.KeyboardEvent) => {
+        const waveEvent = adaptFromReactOrNativeKeyEvent(event);
+        const rtnVal = fn(waveEvent);
+        if (rtnVal) {
+            event.preventDefault();
+            event.stopPropagation();
+        }
+    };
+}
+
+function waveEventToKeyDesc(waveEvent: WaveKeyboardEvent): string {
+    let keyDesc: string[] = [];
+    if (waveEvent.cmd) {
+        keyDesc.push("Cmd");
+    }
+    if (waveEvent.option) {
+        keyDesc.push("Option");
+    }
+    if (waveEvent.meta) {
+        keyDesc.push("Meta");
+    }
+    if (waveEvent.control) {
+        keyDesc.push("Ctrl");
+    }
+    if (waveEvent.shift) {
+        keyDesc.push("Shift");
+    }
+    if (waveEvent.key != null && waveEvent.key != "") {
+        if (waveEvent.key == " ") {
+            keyDesc.push("Space");
+        } else {
+            keyDesc.push(waveEvent.key);
+        }
+    } else {
+        keyDesc.push("c{" + waveEvent.code + "}");
+    }
+    return keyDesc.join(":");
+}
+
+function parseKey(key: string): { key: string; type: string } {
+    let regexMatch = key.match(KeyTypeCodeRegex);
+    if (regexMatch != null && regexMatch.length > 1) {
+        let code = regexMatch[1];
+        return { key: code, type: KeyTypeCode };
+    } else if (regexMatch != null) {
+        console.log("error: regexMatch is not null yet there is no captured group: ", regexMatch, key);
+    }
+    return { key: key, type: KeyTypeKey };
+}
+
+function parseKeyDescription(keyDescription: string): KeyPressDecl {
+    let rtn = { key: "", mods: {} } as KeyPressDecl;
+    let keys = keyDescription.replace(/[()]/g, "").split(":");
+    for (let key of keys) {
+        if (key == "Cmd") {
+            if (PLATFORM == PlatformMacOS) {
+                rtn.mods.Meta = true;
+            } else {
+                rtn.mods.Alt = true;
+            }
+            rtn.mods.Cmd = true;
+        } else if (key == "Shift") {
+            rtn.mods.Shift = true;
+        } else if (key == "Ctrl") {
+            rtn.mods.Ctrl = true;
+        } else if (key == "Option") {
+            if (PLATFORM == PlatformMacOS) {
+                rtn.mods.Alt = true;
+            } else {
+                rtn.mods.Meta = true;
+            }
+            rtn.mods.Option = true;
+        } else if (key == "Alt") {
+            if (PLATFORM == PlatformMacOS) {
+                rtn.mods.Option = true;
+            } else {
+                rtn.mods.Cmd = true;
+            }
+            rtn.mods.Alt = true;
+        } else if (key == "Meta") {
+            if (PLATFORM == PlatformMacOS) {
+                rtn.mods.Cmd = true;
+            } else {
+                rtn.mods.Option = true;
+            }
+            rtn.mods.Meta = true;
+        } else {
+            let { key: parsedKey, type: keyType } = parseKey(key);
+            rtn.key = parsedKey;
+            rtn.keyType = keyType;
+            if (rtn.keyType == KeyTypeKey && key.length == 1) {
+                // check for if key is upper case
+                // TODO what about unicode upper case?
+                if (/[A-Z]/.test(key.charAt(0))) {
+                    // this key is an upper case A - Z - we should apply the shift key, even if it wasn't specified
+                    rtn.mods.Shift = true;
+                } else if (key == " ") {
+                    rtn.key = "Space";
+                    // we allow " " and "Space" to be mapped to Space key
+                }
+            }
+        }
+    }
+    return rtn;
+}
+
+function notMod(keyPressMod: boolean, eventMod: boolean) {
+    return (keyPressMod && !eventMod) || (eventMod && !keyPressMod);
+}
+
+function countGraphemes(str: string): number {
+    if (str == null) {
+        return 0;
+    }
+    // this exists (need to hack TS to get it to not show an error)
+    const seg = new (Intl as any).Segmenter(undefined, { granularity: "grapheme" });
+    return Array.from(seg.segment(str)).length;
+}
+
+function isCharacterKeyEvent(event: WaveKeyboardEvent): boolean {
+    if (event.alt || event.meta || event.control) {
+        return false;
+    }
+    return countGraphemes(event.key) == 1;
+}
+
+const inputKeyMap = new Map<string, boolean>([
+    ["Backspace", true],
+    ["Delete", true],
+    ["Enter", true],
+    ["Space", true],
+    ["Tab", true],
+    ["ArrowLeft", true],
+    ["ArrowRight", true],
+    ["ArrowUp", true],
+    ["ArrowDown", true],
+    ["Home", true],
+    ["End", true],
+    ["PageUp", true],
+    ["PageDown", true],
+    ["Cmd:a", true],
+    ["Cmd:c", true],
+    ["Cmd:v", true],
+    ["Cmd:x", true],
+    ["Cmd:z", true],
+    ["Cmd:Shift:z", true],
+    ["Cmd:ArrowLeft", true],
+    ["Cmd:ArrowRight", true],
+    ["Cmd:Backspace", true],
+    ["Cmd:Delete", true],
+    ["Shift:ArrowLeft", true],
+    ["Shift:ArrowRight", true],
+    ["Shift:ArrowUp", true],
+    ["Shift:ArrowDown", true],
+    ["Shift:Home", true],
+    ["Shift:End", true],
+    ["Cmd:Shift:ArrowLeft", true],
+    ["Cmd:Shift:ArrowRight", true],
+    ["Cmd:Shift:ArrowUp", true],
+    ["Cmd:Shift:ArrowDown", true],
+]);
+
+function isInputEvent(event: WaveKeyboardEvent): boolean {
+    if (isCharacterKeyEvent(event)) {
+        return true;
+    }
+    for (let key of inputKeyMap.keys()) {
+        if (checkKeyPressed(event, key)) {
+            return true;
+        }
+    }
+}
+
+function checkKeyPressed(event: WaveKeyboardEvent, keyDescription: string): boolean {
+    let keyPress = parseKeyDescription(keyDescription);
+    if (notMod(keyPress.mods.Option, event.option)) {
+        return false;
+    }
+    if (notMod(keyPress.mods.Cmd, event.cmd)) {
+        return false;
+    }
+    if (notMod(keyPress.mods.Shift, event.shift)) {
+        return false;
+    }
+    if (notMod(keyPress.mods.Ctrl, event.control)) {
+        return false;
+    }
+    if (notMod(keyPress.mods.Alt, event.alt)) {
+        return false;
+    }
+    if (notMod(keyPress.mods.Meta, event.meta)) {
+        return false;
+    }
+    let eventKey = "";
+    let descKey = keyPress.key;
+    if (keyPress.keyType == KeyTypeCode) {
+        eventKey = event.code;
+    }
+    if (keyPress.keyType == KeyTypeKey) {
+        eventKey = event.key;
+        if (eventKey != null && eventKey.length == 1 && /[A-Z]/.test(eventKey.charAt(0))) {
+            // key is upper case A-Z, this means shift is applied, we want to allow
+            // "Shift:e" as well as "Shift:E" or "E"
+            eventKey = eventKey.toLocaleLowerCase();
+            descKey = descKey.toLocaleLowerCase();
+        } else if (eventKey == " ") {
+            eventKey = "Space";
+            // a space key is shown as " ", we want users to be able to set space key as "Space" or " ", whichever they prefer
+        }
+    }
+    if (descKey != eventKey) {
+        return false;
+    }
+    return true;
+}
+
+function adaptFromReactOrNativeKeyEvent(event: React.KeyboardEvent | KeyboardEvent): WaveKeyboardEvent {
+    let rtn: WaveKeyboardEvent = {} as WaveKeyboardEvent;
+    rtn.control = event.ctrlKey;
+    rtn.shift = event.shiftKey;
+    rtn.cmd = PLATFORM == PlatformMacOS ? event.metaKey : event.altKey;
+    rtn.option = PLATFORM == PlatformMacOS ? event.altKey : event.metaKey;
+    rtn.meta = event.metaKey;
+    rtn.alt = event.altKey;
+    rtn.code = event.code;
+    rtn.key = event.key;
+    rtn.location = event.location;
+    (rtn as any).nativeEvent = event;
+    if (event.type == "keydown" || event.type == "keyup" || event.type == "keypress") {
+        rtn.type = event.type;
+    } else {
+        rtn.type = "unknown";
+    }
+    rtn.repeat = event.repeat;
+    return rtn;
+}
+
+function adaptFromElectronKeyEvent(event: any): WaveKeyboardEvent {
+    let rtn: WaveKeyboardEvent = {} as WaveKeyboardEvent;
+    if (event.type == "keyUp") {
+        rtn.type = "keyup";
+    } else if (event.type == "keyDown") {
+        rtn.type = "keydown";
+    } else {
+        rtn.type = "unknown";
+    }
+    rtn.control = event.control;
+    rtn.cmd = PLATFORM == PlatformMacOS ? event.meta : event.alt;
+    rtn.option = PLATFORM == PlatformMacOS ? event.alt : event.meta;
+    rtn.meta = event.meta;
+    rtn.alt = event.alt;
+    rtn.shift = event.shift;
+    rtn.repeat = event.isAutoRepeat;
+    rtn.location = event.location;
+    rtn.code = event.code;
+    rtn.key = event.key;
+    return rtn;
+}
+
+const keyMap = {
+    Enter: "\r",
+    Backspace: "\x7f",
+    Tab: "\t",
+    Escape: "\x1b",
+    ArrowUp: "\x1b[A",
+    ArrowDown: "\x1b[B",
+    ArrowRight: "\x1b[C",
+    ArrowLeft: "\x1b[D",
+    Insert: "\x1b[2~",
+    Delete: "\x1b[3~",
+    Home: "\x1b[1~",
+    End: "\x1b[4~",
+    PageUp: "\x1b[5~",
+    PageDown: "\x1b[6~",
+};
+
+function keyboardEventToASCII(event: WaveKeyboardEvent): string {
+    // check modifiers
+    // if no modifiers are set, just send the key
+    if (!event.alt && !event.control && !event.meta) {
+        if (event.key == null || event.key == "") {
+            return "";
+        }
+        if (keyMap[event.key] != null) {
+            return keyMap[event.key];
+        }
+        if (event.key.length == 1) {
+            return event.key;
+        } else {
+            console.log("not sending keyboard event", event.key, event);
+        }
+    }
+    // if meta or alt is set, there is no ASCII representation
+    if (event.meta || event.alt) {
+        return "";
+    }
+    // if ctrl is set, if it is a letter, subtract 64 from the uppercase value to get the ASCII value
+    if (event.control) {
+        if (
+            (event.key.length === 1 && event.key >= "A" && event.key <= "Z") ||
+            (event.key >= "a" && event.key <= "z")
+        ) {
+            const key = event.key.toUpperCase();
+            return String.fromCharCode(key.charCodeAt(0) - 64);
+        }
+    }
+    return "";
+}
+
+export {
+    adaptFromElectronKeyEvent,
+    adaptFromReactOrNativeKeyEvent,
+    checkKeyPressed,
+    getKeyUtilPlatform,
+    isCharacterKeyEvent,
+    isInputEvent,
+    keyboardEventToASCII,
+    keydownWrapper,
+    parseKeyDescription,
+    setKeyUtilPlatform,
+    waveEventToKeyDesc,
+};
diff --git a/tsunami/frontend/src/util/platformutil.ts b/tsunami/frontend/src/util/platformutil.ts
new file mode 100644
index 0000000000..410f248fb3
--- /dev/null
+++ b/tsunami/frontend/src/util/platformutil.ts
@@ -0,0 +1,30 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export const PlatformMacOS = "darwin";
+export let PLATFORM: NodeJS.Platform = PlatformMacOS;
+
+export function setPlatform(platform: NodeJS.Platform) {
+    PLATFORM = platform;
+}
+
+export function makeNativeLabel(isDirectory: boolean) {
+    let managerName: string;
+    if (!isDirectory) {
+        managerName = "Default Application";
+    } else if (PLATFORM === PlatformMacOS) {
+        managerName = "Finder";
+    } else if (PLATFORM == "win32") {
+        managerName = "Explorer";
+    } else {
+        managerName = "File Manager";
+    }
+
+    let fileAction: string;
+    if (isDirectory) {
+        fileAction = "Reveal";
+    } else {
+        fileAction = "Open File";
+    }
+    return `${fileAction} in ${managerName}`;
+}
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
new file mode 100644
index 0000000000..7e67c54ffb
--- /dev/null
+++ b/tsunami/frontend/src/vdom.tsx
@@ -0,0 +1,509 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import clsx from "clsx";
+import debug from "debug";
+import * as jotai from "jotai";
+import * as React from "react";
+
+import { BlockNodeModel } from "@/app/block/blocktypes";
+import { Markdown } from "@/element/markdown";
+import { convertVDomId, getTextChildren, validateAndWrapCss, validateAndWrapReactStyle } from "@/model/model-utils";
+import { TsunamiModel } from "@/model/tsunami-model";
+import { adaptFromReactOrNativeKeyEvent, checkKeyPressed } from "@/util/keyutil";
+
+const TextTag = "#text";
+const FragmentTag = "#fragment";
+const WaveTextTag = "wave:text";
+const WaveNullTag = "wave:null";
+const StyleTagName = "style";
+const WaveStyleTagName = "wave:style";
+
+const VDomObjType_Ref = "ref";
+const VDomObjType_Binding = "binding";
+const VDomObjType_Func = "func";
+
+const dlog = debug("wave:vdom");
+
+type VDomReactTagType = (props: { elem: VDomElem; model: TsunamiModel }) => React.ReactElement;
+
+const WaveTagMap: Record<string, VDomReactTagType> = {
+    "wave:markdown": WaveMarkdown,
+};
+
+const AllowedSimpleTags: { [tagName: string]: boolean } = {
+    div: true,
+    b: true,
+    i: true,
+    p: true,
+    s: true,
+    span: true,
+    a: true,
+    img: true,
+    h1: true,
+    h2: true,
+    h3: true,
+    h4: true,
+    h5: true,
+    h6: true,
+    ul: true,
+    ol: true,
+    li: true,
+    input: true,
+    button: true,
+    textarea: true,
+    select: true,
+    option: true,
+    form: true,
+    label: true,
+    table: true,
+    thead: true,
+    tbody: true,
+    tr: true,
+    th: true,
+    td: true,
+    hr: true,
+    br: true,
+    pre: true,
+    code: true,
+    canvas: true,
+};
+
+const AllowedSvgTags = {
+    // SVG tags
+    svg: true,
+    circle: true,
+    ellipse: true,
+    line: true,
+    path: true,
+    polygon: true,
+    polyline: true,
+    rect: true,
+    g: true,
+    text: true,
+    tspan: true,
+    textPath: true,
+    use: true,
+    defs: true,
+    linearGradient: true,
+    radialGradient: true,
+    stop: true,
+    clipPath: true,
+    mask: true,
+    pattern: true,
+    image: true,
+    marker: true,
+    symbol: true,
+    filter: true,
+    feBlend: true,
+    feColorMatrix: true,
+    feComponentTransfer: true,
+    feComposite: true,
+    feConvolveMatrix: true,
+    feDiffuseLighting: true,
+    feDisplacementMap: true,
+    feFlood: true,
+    feGaussianBlur: true,
+    feImage: true,
+    feMerge: true,
+    feMorphology: true,
+    feOffset: true,
+    feSpecularLighting: true,
+    feTile: true,
+    feTurbulence: true,
+};
+
+const IdAttributes = {
+    id: true,
+    for: true,
+    "aria-labelledby": true,
+    "aria-describedby": true,
+    "aria-controls": true,
+    "aria-owns": true,
+    form: true,
+    headers: true,
+    usemap: true,
+    list: true,
+};
+
+const SvgUrlIdAttributes = {
+    "clip-path": true,
+    mask: true,
+    filter: true,
+    fill: true,
+    stroke: true,
+    "marker-start": true,
+    "marker-mid": true,
+    "marker-end": true,
+    "text-decoration": true,
+};
+
+function convertVDomFunc(model: TsunamiModel, fnDecl: VDomFunc, compId: string, propName: string): (e: any) => void {
+    return (e: any) => {
+        if ((propName == "onKeyDown" || propName == "onKeyDownCapture") && fnDecl["#keys"]) {
+            dlog("key event", fnDecl, e);
+            let waveEvent = adaptFromReactOrNativeKeyEvent(e);
+            for (let keyDesc of fnDecl["#keys"] || []) {
+                if (checkKeyPressed(waveEvent, keyDesc)) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    model.callVDomFunc(fnDecl, e, compId, propName);
+                    return;
+                }
+            }
+            return;
+        }
+        if (fnDecl.preventdefault) {
+            e.preventDefault();
+        }
+        if (fnDecl.stoppropagation) {
+            e.stopPropagation();
+        }
+        model.callVDomFunc(fnDecl, e, compId, propName);
+    };
+}
+
+function convertElemToTag(elem: VDomElem, model: TsunamiModel): React.ReactNode {
+    if (elem == null) {
+        return null;
+    }
+    if (elem.tag == TextTag) {
+        return elem.text;
+    }
+    return React.createElement(VDomTag, { key: elem.waveid, elem, model });
+}
+
+function isObject(v: any): boolean {
+    return v != null && !Array.isArray(v) && typeof v === "object";
+}
+
+function isArray(v: any): boolean {
+    return Array.isArray(v);
+}
+
+function resolveBinding(binding: VDomBinding, model: TsunamiModel): [any, string[]] {
+    const bindName = binding.bind;
+    if (bindName == null || bindName == "") {
+        return [null, []];
+    }
+    // for now we only recognize $.[atomname] bindings
+    if (!bindName.startsWith("$.")) {
+        return [null, []];
+    }
+    const atomName = bindName.substring(2);
+    if (atomName == "") {
+        return [null, []];
+    }
+    const atom = model.getAtomContainer(atomName);
+    if (atom == null) {
+        return [null, []];
+    }
+    return [atom.val, [atomName]];
+}
+
+type GenericPropsType = { [key: string]: any };
+
+// returns props, and a set of atom keys used in the props
+function convertProps(elem: VDomElem, model: TsunamiModel): [GenericPropsType, Set<string>] {
+    let props: GenericPropsType = {};
+    let atomKeys = new Set<string>();
+    if (elem.props == null) {
+        return [props, atomKeys];
+    }
+    for (let key in elem.props) {
+        let val = elem.props[key];
+        if (val == null) {
+            continue;
+        }
+        if (key == "ref") {
+            if (val == null) {
+                continue;
+            }
+            if (isObject(val) && val.type == VDomObjType_Ref) {
+                const valRef = val as VDomRef;
+                const refContainer = model.getOrCreateRefContainer(valRef);
+                props[key] = refContainer.refFn;
+            }
+            continue;
+        }
+        if (isObject(val) && val.type == VDomObjType_Func) {
+            const valFunc = val as VDomFunc;
+            props[key] = convertVDomFunc(model, valFunc, elem.waveid, key);
+            continue;
+        }
+        if (isObject(val) && val.type == VDomObjType_Binding) {
+            const [propVal, atomDeps] = resolveBinding(val as VDomBinding, model);
+            props[key] = propVal;
+            for (let atomDep of atomDeps) {
+                atomKeys.add(atomDep);
+            }
+            continue;
+        }
+        if (key == "style" && isObject(val)) {
+            // assuming the entire style prop wasn't bound, look through the individual keys and bind them
+            for (let styleKey in val) {
+                let styleVal = val[styleKey];
+                if (isObject(styleVal) && styleVal.type == VDomObjType_Binding) {
+                    const [stylePropVal, styleAtomDeps] = resolveBinding(styleVal as VDomBinding, model);
+                    val[styleKey] = stylePropVal;
+                    for (let styleAtomDep of styleAtomDeps) {
+                        atomKeys.add(styleAtomDep);
+                    }
+                }
+            }
+            val = validateAndWrapReactStyle(model, val);
+            props[key] = val;
+            continue;
+        }
+        if (IdAttributes[key]) {
+            props[key] = convertVDomId(model, val);
+            continue;
+        }
+        if (AllowedSvgTags[elem.tag]) {
+            if ((elem.tag == "use" && key == "href") || (elem.tag == "textPath" && key == "href")) {
+                if (val == null || !val.startsWith("#")) {
+                    continue;
+                }
+                props[key] = convertVDomId(model, "#" + val.substring(1));
+                continue;
+            }
+            if (SvgUrlIdAttributes[key]) {
+                if (val == null || !val.startsWith("url(#") || !val.endsWith(")")) {
+                    continue;
+                }
+                props[key] = "url(#" + convertVDomId(model, val.substring(4, val.length - 1)) + ")";
+                continue;
+            }
+        }
+        if (key == "src" && val != null && val.startsWith("vdom://")) {
+            // transform vdom:// urls
+            const newUrl = model.transformVDomUrl(val);
+            if (newUrl == null) {
+                continue;
+            }
+            props[key] = newUrl;
+            continue;
+        }
+        props[key] = val;
+    }
+    return [props, atomKeys];
+}
+
+function convertChildren(elem: VDomElem, model: TsunamiModel): React.ReactNode[] {
+    if (elem.children == null || elem.children.length == 0) {
+        return null;
+    }
+    let childrenComps: React.ReactNode[] = [];
+    for (let child of elem.children) {
+        if (child == null) {
+            continue;
+        }
+        childrenComps.push(convertElemToTag(child, model));
+    }
+    if (childrenComps.length == 0) {
+        return null;
+    }
+    return childrenComps;
+}
+
+function stringSetsEqual(set1: Set<string>, set2: Set<string>): boolean {
+    if (set1.size != set2.size) {
+        return false;
+    }
+    for (let elem of set1) {
+        if (!set2.has(elem)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function useVDom(model: TsunamiModel, elem: VDomElem): GenericPropsType {
+    const version = jotai.useAtomValue(model.getVDomNodeVersionAtom(elem));
+    const [oldAtomKeys, setOldAtomKeys] = React.useState<Set<string>>(new Set());
+    let [props, atomKeys] = convertProps(elem, model);
+    React.useEffect(() => {
+        if (stringSetsEqual(atomKeys, oldAtomKeys)) {
+            return;
+        }
+        model.tagUnuseAtoms(elem.waveid, oldAtomKeys);
+        model.tagUseAtoms(elem.waveid, atomKeys);
+        setOldAtomKeys(atomKeys);
+    }, [atomKeys]);
+    React.useEffect(() => {
+        return () => {
+            model.tagUnuseAtoms(elem.waveid, oldAtomKeys);
+        };
+    }, []);
+    return props;
+}
+
+function WaveMarkdown({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
+    const props = useVDom(model, elem);
+    return (
+        <Markdown
+            text={props?.text}
+            style={props?.style}
+            className={props?.className}
+            scrollable={props?.scrollable}
+            rehype={props?.rehype}
+        />
+    );
+}
+
+function StyleTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
+    const styleText = getTextChildren(elem);
+    if (styleText == null) {
+        return null;
+    }
+    const wrapperClassName = "vdom-" + model.blockId;
+    // TODO handle errors
+    const sanitizedCss = validateAndWrapCss(model, styleText, wrapperClassName);
+    if (sanitizedCss == null) {
+        return null;
+    }
+    return <style>{sanitizedCss}</style>;
+}
+
+function WaveStyle({ src, model, onMount }: { src: string; model: TsunamiModel; onMount?: () => void }) {
+    const [styleContent, setStyleContent] = React.useState<string | null>(null);
+    React.useEffect(() => {
+        async function fetchAndSanitizeCss() {
+            try {
+                const response = await fetch(src);
+                if (!response.ok) {
+                    console.error(`Failed to load CSS from ${src}`);
+                    return;
+                }
+                const cssText = await response.text();
+                const wrapperClassName = "vdom-" + model.blockId;
+                const sanitizedCss = validateAndWrapCss(model, cssText, wrapperClassName);
+                if (sanitizedCss) {
+                    setStyleContent(sanitizedCss);
+                } else {
+                    onMount?.();
+                    console.error("Failed to sanitize CSS");
+                }
+            } catch (error) {
+                console.error("Error fetching CSS:", error);
+                onMount?.();
+            }
+        }
+        fetchAndSanitizeCss();
+    }, [src, model]);
+    // Trigger onMount after styleContent has been set and mounted
+    React.useEffect(() => {
+        if (styleContent) {
+            onMount?.();
+        }
+    }, [styleContent, onMount]);
+    if (!styleContent) {
+        return null;
+    }
+    return <style>{styleContent}</style>;
+}
+
+function VDomTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
+    const props = useVDom(model, elem);
+    if (elem.tag == WaveNullTag) {
+        return null;
+    }
+    if (elem.tag == WaveTextTag) {
+        return props.text;
+    }
+    const waveTag = WaveTagMap[elem.tag];
+    if (waveTag) {
+        return waveTag({ elem, model });
+    }
+    if (elem.tag == StyleTagName) {
+        return <StyleTag elem={elem} model={model} />;
+    }
+    if (elem.tag == WaveStyleTagName) {
+        return <WaveStyle src={props.src} model={model} />;
+    }
+    if (!AllowedSimpleTags[elem.tag] && !AllowedSvgTags[elem.tag]) {
+        return <div>{"Invalid Tag <" + elem.tag + ">"}</div>;
+    }
+    let childrenComps = convertChildren(elem, model);
+    if (elem.tag == FragmentTag) {
+        return childrenComps;
+    }
+    props.key = "e-" + elem.waveid;
+    return React.createElement(elem.tag, props, childrenComps);
+}
+
+function vdomText(text: string): VDomElem {
+    return {
+        tag: "#text",
+        text: text,
+    };
+}
+
+const testVDom: VDomElem = {
+    waveid: "testid1",
+    tag: "div",
+    children: [
+        {
+            waveid: "testh1",
+            tag: "h1",
+            children: [vdomText("Hello World")],
+        },
+        {
+            waveid: "testp",
+            tag: "p",
+            children: [vdomText("This is a paragraph (from VDOM)")],
+        },
+    ],
+};
+
+function VDomRoot({ model }: { model: TsunamiModel }) {
+    let version = jotai.useAtomValue(model.globalVersion);
+    let rootNode = jotai.useAtomValue(model.vdomRoot);
+    React.useEffect(() => {
+        model.renderDone(version);
+    }, [version]);
+    if (model.viewRef.current == null || rootNode == null) {
+        return null;
+    }
+    dlog("render", version, rootNode);
+    let rtn = convertElemToTag(rootNode, model);
+    return <div className="vdom">{rtn}</div>;
+}
+
+function makeVDomModel(blockId: string, nodeModel: BlockNodeModel): TsunamiModel {
+    return new TsunamiModel(blockId, nodeModel);
+}
+
+type VDomViewProps = {
+    model: TsunamiModel;
+    blockId: string;
+};
+
+function VDomInnerView({ blockId, model }: VDomViewProps) {
+    let [styleMounted, setStyleMounted] = React.useState(!model.backendOpts?.globalstyles);
+    const handleStylesMounted = () => {
+        setStyleMounted(true);
+    };
+    return (
+        <>
+            {model.backendOpts?.globalstyles ? (
+                <WaveStyle src={model.makeVDomUrl("/wave/global.css")} model={model} onMount={handleStylesMounted} />
+            ) : null}
+            {styleMounted ? <VDomRoot model={model} /> : null}
+        </>
+    );
+}
+
+function VDomView({ blockId, model }: VDomViewProps) {
+    let viewRef = React.useRef(null);
+    let contextActive = jotai.useAtomValue(model.contextActive);
+    model.viewRef = viewRef;
+    const vdomClass = "vdom-" + blockId;
+    return (
+        <div className={clsx("overflow-auto w-full min-h-full", vdomClass)} ref={viewRef}>
+            {contextActive ? <VDomInnerView blockId={blockId} model={model} /> : null}
+        </div>
+    );
+}
+
+export { makeVDomModel, VDomView };
diff --git a/tsunami/frontend/tsconfig.json b/tsunami/frontend/tsconfig.json
new file mode 100644
index 0000000000..27d4e97b90
--- /dev/null
+++ b/tsunami/frontend/tsconfig.json
@@ -0,0 +1,26 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "lib": ["ES2023", "DOM", "DOM.Iterable"],
+        "module": "ESNext",
+        "skipLibCheck": true,
+        "allowJs": false,
+        "esModuleInterop": false,
+        "allowSyntheticDefaultImports": true,
+        "strict": false,
+        "strictNullChecks": false,
+        "forceConsistentCasingInFileNames": true,
+        "moduleResolution": "bundler",
+        "allowImportingTsExtensions": true,
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "noEmit": true,
+        "jsx": "react-jsx",
+        "baseUrl": ".",
+        "paths": {
+            "@/*": ["./src/*"]
+        }
+    },
+    "include": ["src/**/*", "vite.config.ts"],
+    "exclude": ["node_modules", "dist"]
+}
diff --git a/tsunami/frontend/vite.config.ts b/tsunami/frontend/vite.config.ts
new file mode 100644
index 0000000000..d2f1d946f2
--- /dev/null
+++ b/tsunami/frontend/vite.config.ts
@@ -0,0 +1,22 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react-swc";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+    plugins: [react(), tailwindcss()],
+    resolve: {
+        alias: {
+            "@": "/src",
+        },
+    },
+    server: {
+        port: 12025,
+        open: true,
+    },
+    build: {
+        outDir: "dist",
+    },
+});
diff --git a/yarn.lock b/yarn.lock
index c30975291f..af94e825f9 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -6475,6 +6475,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/react-dom@npm:^19":
+  version: 19.1.9
+  resolution: "@types/react-dom@npm:19.1.9"
+  peerDependencies:
+    "@types/react": ^19.0.0
+  checksum: 10c0/34c8dda86c1590b3ef0e7ecd38f9663a66ba2dd69113ba74fb0adc36b83bbfb8c94c1487a2505282a5f7e5e000d2ebf36f4c0fd41b3b672f5178fd1d4f1f8f58
+  languageName: node
+  linkType: hard
+
 "@types/react-router-config@npm:*, @types/react-router-config@npm:^5.0.7":
   version: 5.0.11
   resolution: "@types/react-router-config@npm:5.0.11"
@@ -6536,6 +6545,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/react@npm:^19":
+  version: 19.1.12
+  resolution: "@types/react@npm:19.1.12"
+  dependencies:
+    csstype: "npm:^3.0.2"
+  checksum: 10c0/e35912b43da0caaab5252444bab87a31ca22950cde2822b3b3dc32e39c2d42dad1a4cf7b5dde9783aa2d007f0b2cba6ab9563fc6d2dbcaaa833b35178118767c
+  languageName: node
+  linkType: hard
+
 "@types/resolve@npm:1.20.2":
   version: 1.20.2
   resolution: "@types/resolve@npm:1.20.2"
@@ -6890,7 +6908,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@vitejs/plugin-react-swc@npm:4.0.1":
+"@vitejs/plugin-react-swc@npm:4.0.1, @vitejs/plugin-react-swc@npm:^4.0.1":
   version: 4.0.1
   resolution: "@vitejs/plugin-react-swc@npm:4.0.1"
   dependencies:
@@ -13825,6 +13843,27 @@ __metadata:
   languageName: node
   linkType: hard
 
+"jotai@npm:^2.13.1":
+  version: 2.13.1
+  resolution: "jotai@npm:2.13.1"
+  peerDependencies:
+    "@babel/core": ">=7.0.0"
+    "@babel/template": ">=7.0.0"
+    "@types/react": ">=17.0.0"
+    react: ">=17.0.0"
+  peerDependenciesMeta:
+    "@babel/core":
+      optional: true
+    "@babel/template":
+      optional: true
+    "@types/react":
+      optional: true
+    react:
+      optional: true
+  checksum: 10c0/777915c4f83c372bac066ce3acb037c8c5c01e2789b8b435bf3f302ef32a5564d471217c89b9cdee219d735d445b166bf3ff15a9f43f4cb92a8a9115c72446ad
+  languageName: node
+  linkType: hard
+
 "js-tokens@npm:^3.0.0 || ^4.0.0, js-tokens@npm:^4.0.0":
   version: 4.0.0
   resolution: "js-tokens@npm:4.0.0"
@@ -18077,7 +18116,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-dom@npm:19.1.1":
+"react-dom@npm:19.1.1, react-dom@npm:^19.1.1":
   version: 19.1.1
   resolution: "react-dom@npm:19.1.1"
   dependencies:
@@ -18226,6 +18265,28 @@ __metadata:
   languageName: node
   linkType: hard
 
+"react-markdown@npm:^10.1.0":
+  version: 10.1.0
+  resolution: "react-markdown@npm:10.1.0"
+  dependencies:
+    "@types/hast": "npm:^3.0.0"
+    "@types/mdast": "npm:^4.0.0"
+    devlop: "npm:^1.0.0"
+    hast-util-to-jsx-runtime: "npm:^2.0.0"
+    html-url-attributes: "npm:^3.0.0"
+    mdast-util-to-hast: "npm:^13.0.0"
+    remark-parse: "npm:^11.0.0"
+    remark-rehype: "npm:^11.0.0"
+    unified: "npm:^11.0.0"
+    unist-util-visit: "npm:^5.0.0"
+    vfile: "npm:^6.0.0"
+  peerDependencies:
+    "@types/react": ">=18"
+    react: ">=18"
+  checksum: 10c0/4a5dc7d15ca6d05e9ee95318c1904f83b111a76f7588c44f50f1d54d4c97193b84e4f64c4b592057c989228238a2590306cedd0c4d398e75da49262b2b5ae1bf
+  languageName: node
+  linkType: hard
+
 "react-markdown@npm:^9.0.3":
   version: 9.0.3
   resolution: "react-markdown@npm:9.0.3"
@@ -18348,7 +18409,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react@npm:19.1.1":
+"react@npm:19.1.1, react@npm:^19.1.1":
   version: 19.1.1
   resolution: "react@npm:19.1.1"
   checksum: 10c0/8c9769a2dfd02e603af6445058325e6c8a24b47b185d0e461f66a6454765ddcaecb3f0a90184836c68bb509f3c38248359edbc42f0d07c23eb500a5c30c87b4e
@@ -21235,6 +21296,27 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tsunami-frontend@workspace:tsunami/frontend":
+  version: 0.0.0-use.local
+  resolution: "tsunami-frontend@workspace:tsunami/frontend"
+  dependencies:
+    "@tailwindcss/vite": "npm:^4.0.17"
+    "@types/react": "npm:^19"
+    "@types/react-dom": "npm:^19"
+    "@vitejs/plugin-react-swc": "npm:^4.0.1"
+    clsx: "npm:^2.1.1"
+    debug: "npm:^4.4.1"
+    jotai: "npm:^2.13.1"
+    react: "npm:^19.1.1"
+    react-dom: "npm:^19.1.1"
+    react-markdown: "npm:^10.1.0"
+    tailwind-merge: "npm:^3.3.1"
+    tailwindcss: "npm:^4.1.12"
+    typescript: "npm:^5.9.2"
+    vite: "npm:^6.0.0"
+  languageName: unknown
+  linkType: soft
+
 "tsx@npm:^4.20.4":
   version: 4.20.4
   resolution: "tsx@npm:4.20.4"

From 336dc293a4e8b5a3d5012cf8f7f962e370b4a342 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 12:31:52 -0700
Subject: [PATCH 016/134] checkpoint

---
 tsunami/frontend/src/model/model-utils.ts    | 142 ---------------
 tsunami/frontend/src/model/tsunami-model.tsx | 176 ++++---------------
 tsunami/frontend/src/types/vdom.d.ts         |   1 -
 tsunami/frontend/src/util/clientid.ts        |  26 +++
 tsunami/frontend/src/vdom.tsx                |  75 ++------
 tsunami/rpctypes/types.go                    |   1 -
 6 files changed, 73 insertions(+), 348 deletions(-)
 create mode 100644 tsunami/frontend/src/util/clientid.ts

diff --git a/tsunami/frontend/src/model/model-utils.ts b/tsunami/frontend/src/model/model-utils.ts
index c521ebb816..a4f05f9947 100644
--- a/tsunami/frontend/src/model/model-utils.ts
+++ b/tsunami/frontend/src/model/model-utils.ts
@@ -1,10 +1,6 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { CssNode, List, ListItem } from "css-tree";
-import * as csstree from "css-tree";
-import type { TsunamiModel } from "./tsunami-model";
-
 const TextTag = "#text";
 
 // TODO support binding
@@ -21,120 +17,6 @@ export function getTextChildren(elem: VDomElem): string {
     return textArr.join("");
 }
 
-export function convertVDomId(model: TsunamiModel, id: string): string {
-    return model.blockId + "::" + id;
-}
-
-export function validateAndWrapCss(model: TsunamiModel, cssText: string, wrapperClassName: string) {
-    try {
-        const ast = csstree.parse(cssText);
-        csstree.walk(ast, {
-            enter(node: CssNode, item: ListItem<CssNode>, list: List<CssNode>) {
-                // Remove disallowed @rules
-                const blockedRules = ["import", "font-face", "keyframes", "namespace", "supports"];
-                if (node.type === "Atrule" && blockedRules.includes(node.name)) {
-                    list.remove(item);
-                }
-                // Remove :root selectors
-                if (
-                    node.type === "Selector" &&
-                    node.children.some((child) => child.type === "PseudoClassSelector" && child.name === "root")
-                ) {
-                    list.remove(item);
-                }
-
-                if (node.type === "IdSelector") {
-                    node.name = convertVDomId(model, node.name);
-                }
-
-                // Transform url(#id) references in filter and mask properties (svg)
-                if (node.type === "Declaration" && ["filter", "mask"].includes(node.property)) {
-                    if (node.value && node.value.type === "Value" && "children" in node.value) {
-                        const urlNode = node.value.children
-                            .toArray()
-                            .find(
-                                (child: CssNode): child is CssNode & { value: string } =>
-                                    child && child.type === "Url" && typeof (child as any).value === "string"
-                            );
-                        if (urlNode && urlNode.value && urlNode.value.startsWith("#")) {
-                            urlNode.value = "#" + convertVDomId(model, urlNode.value.substring(1));
-                        }
-                    }
-                }
-                // transform url(vdom:///foo.jpg)
-                if (node.type === "Url" && node.value != null && node.value.startsWith("vdom://")) {
-                    const newUrl = model.transformVDomUrl(node.value);
-                    if (newUrl == null) {
-                        list.remove(item);
-                    } else {
-                        node.value = newUrl;
-                    }
-                }
-            },
-        });
-        const sanitizedCss = csstree.generate(ast);
-        return `.${wrapperClassName} { ${sanitizedCss} }`;
-    } catch (error) {
-        // TODO better error handling
-        console.error("CSS processing error:", error);
-        return null;
-    }
-}
-
-function cssTransformStyleValue(model: TsunamiModel, property: string, value: string): string {
-    try {
-        const ast = csstree.parse(value, { context: "value" });
-        csstree.walk(ast, {
-            enter(node: CssNode, item: ListItem<CssNode>, list: List<CssNode>) {
-                // Transform url(#id) in filter/mask properties
-                if (node.type === "Url" && (property === "filter" || property === "mask")) {
-                    if (node.value.startsWith("#")) {
-                        node.value = `#${convertVDomId(model, node.value.substring(1))}`;
-                    }
-                }
-                // transform vdom:// urls
-                if (node.type === "Url" && node.value != null && node.value.startsWith("vdom://")) {
-                    const newUrl = model.transformVDomUrl(node.value);
-                    if (newUrl == null) {
-                        list.remove(item);
-                    } else {
-                        node.value = newUrl;
-                    }
-                }
-            },
-        });
-
-        return csstree.generate(ast);
-    } catch (error) {
-        console.error("Error processing style value:", error);
-        return value;
-    }
-}
-
-export function validateAndWrapReactStyle(model: TsunamiModel, style: Record<string, any>): Record<string, any> {
-    const sanitizedStyle: Record<string, any> = {};
-    let updated = false;
-    for (const [property, value] of Object.entries(style)) {
-        if (value == null || value === "") {
-            continue;
-        }
-        if (typeof value !== "string") {
-            sanitizedStyle[property] = value; // For non-string values, just copy as-is
-            continue;
-        }
-        if (value.includes("vdom://") || value.includes("url(#")) {
-            updated = true;
-            sanitizedStyle[property] = cssTransformStyleValue(model, property, value);
-        } else {
-            sanitizedStyle[property] = value;
-        }
-    }
-    if (!updated) {
-        return style;
-    }
-    return sanitizedStyle;
-}
-
 export function restoreVDomElems(backendUpdate: VDomBackendUpdate) {
     if (!backendUpdate.transferelems || !backendUpdate.renderupdates) {
         return;
@@ -172,30 +54,6 @@ export function restoreVDomElems(backendUpdate: VDomBackendUpdate) {
     });
 }
 
-export function mergeBackendUpdates(baseUpdate: VDomBackendUpdate, nextUpdate: VDomBackendUpdate) {
-    // Verify the updates are from the same block/sequence
-    if (baseUpdate.blockid !== nextUpdate.blockid || baseUpdate.ts !== nextUpdate.ts) {
-        console.error("Attempted to merge updates from different blocks or timestamps");
-        return;
-    }
-
-    // Merge TransferElems
-    if (nextUpdate.transferelems?.length > 0) {
-        if (!baseUpdate.transferelems) {
-            baseUpdate.transferelems = [];
-        }
-        baseUpdate.transferelems.push(...nextUpdate.transferelems);
-    }
-
-    // Merge StateSync
-    if (nextUpdate.statesync?.length > 0) {
-        if (!baseUpdate.statesync) {
-            baseUpdate.statesync = [];
-        }
-        baseUpdate.statesync.push(...nextUpdate.statesync);
-    }
-}
-
 export function applyCanvasOp(canvas: HTMLCanvasElement, canvasOp: VDomRefOperation, refStore: Map<string, any>) {
     const ctx = canvas.getContext("2d");
     if (!ctx) {
diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
index 7d719cfc59..3adde5b54e 100644
--- a/tsunami/frontend/src/model/tsunami-model.tsx
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -4,18 +4,13 @@
 import debug from "debug";
 import * as jotai from "jotai";
 
-import { BlockNodeModel } from "@/app/block/blocktypes";
-import { getBlockMetaKeyAtom, globalStore, WOS } from "@/app/store/global";
-import { makeORef } from "@/app/store/wos";
-import { waveEventSubscribe } from "@/app/store/wps";
 import { RpcResponseHelper, WshClient } from "@/app/store/wshclient";
-import { RpcApi } from "@/app/store/wshclientapi";
 import { makeFeBlockRouteId } from "@/app/store/wshrouter";
-import { DefaultRouter, TabRpcClient } from "@/app/store/wshrpcutil";
-import { VDomView } from "@/app/view/vdom/vdom";
+import { getOrCreateClientId } from "@/util/clientid";
 import { adaptFromReactOrNativeKeyEvent, checkKeyPressed } from "@/util/keyutil";
 import { PLATFORM, PlatformMacOS } from "@/util/platformutil";
-import { applyCanvasOp, mergeBackendUpdates, restoreVDomElems } from "./model-utils";
+import { getDefaultStore } from "jotai";
+import { applyCanvasOp, restoreVDomElems } from "./model-utils";
 
 const dlog = debug("wave:vdom");
 
@@ -103,11 +98,7 @@ class VDomWshClient extends WshClient {
 }
 
 export class TsunamiModel {
-    blockId: string;
-    nodeModel: BlockNodeModel;
-    viewType: string;
-    viewIcon: jotai.Atom<string>;
-    viewName: jotai.Atom<string>;
+    clientId: string;
     viewRef: React.RefObject<HTMLDivElement> = { current: null };
     vdomRoot: jotai.PrimitiveAtom<VDomElem> = jotai.atom();
     atoms: Map<string, AtomContainer> = new Map(); // key is atomname
@@ -118,7 +109,6 @@ export class TsunamiModel {
     vdomNodeVersion: WeakMap<VDomElem, jotai.PrimitiveAtom<number>> = new WeakMap();
     compoundAtoms: Map<string, jotai.PrimitiveAtom<{ [key: string]: any }>> = new Map();
     rootRefId: string = crypto.randomUUID();
-    backendRoute: jotai.Atom<string>;
     backendOpts: VDomBackendOpts;
     shouldDispose: boolean;
     disposed: boolean;
@@ -130,72 +120,23 @@ export class TsunamiModel {
     queuedUpdate: { timeoutId: any; ts: number; quick: boolean };
     contextActive: jotai.PrimitiveAtom<boolean>;
     wshClient: VDomWshClient;
-    persist: jotai.Atom<boolean>;
-    routeGoneUnsub: () => void;
-    routeConfirmed: boolean = false;
     refOutputStore: Map<string, any> = new Map();
     globalVersion: jotai.PrimitiveAtom<number> = jotai.atom(0);
     hasBackendWork: boolean = false;
     noPadding: jotai.PrimitiveAtom<boolean>;
 
-    constructor(blockId: string, nodeModel: BlockNodeModel) {
-        this.viewType = "vdom";
-        this.blockId = blockId;
-        this.nodeModel = nodeModel;
+    constructor() {
+        this.clientId = getOrCreateClientId();
         this.contextActive = jotai.atom(false);
         this.reset();
-        this.viewIcon = jotai.atom("bolt");
-        this.viewName = jotai.atom("Wave App");
-        this.backendRoute = jotai.atom((get) => {
-            const blockData = get(WOS.getWaveObjectAtom<Block>(makeORef("block", this.blockId)));
-            return blockData?.meta?.["vdom:route"];
-        });
         this.noPadding = jotai.atom(true);
-        this.persist = getBlockMetaKeyAtom(this.blockId, "vdom:persist");
-        this.wshClient = new VDomWshClient(this);
-        DefaultRouter.registerRoute(this.wshClient.routeId, this.wshClient);
-        const curBackendRoute = globalStore.get(this.backendRoute);
-        if (curBackendRoute) {
-            this.queueUpdate(true);
-        }
-        this.routeGoneUnsub = waveEventSubscribe({
-            eventType: "route:gone",
-            scope: curBackendRoute,
-            handler: (event: WaveEvent) => {
-                this.disposed = true;
-                const shouldPersist = globalStore.get(this.persist);
-                if (!shouldPersist) {
-                    this.nodeModel?.onClose?.();
-                }
-            },
-        });
-        RpcApi.WaitForRouteCommand(TabRpcClient, { routeid: curBackendRoute, waitms: 4000 }, { timeout: 5000 }).then(
-            (routeOk: boolean) => {
-                if (routeOk) {
-                    this.routeConfirmed = true;
-                    this.queueUpdate(true);
-                } else {
-                    this.disposed = true;
-                    const shouldPersist = globalStore.get(this.persist);
-                    if (!shouldPersist) {
-                        this.nodeModel?.onClose?.();
-                    }
-                }
-            }
-        );
-    }
-
-    get viewComponent(): ViewComponent {
-        return VDomView;
+        this.queueUpdate(true);
     }
 
-    dispose() {
-        DefaultRouter.unregisterRoute(this.wshClient.routeId);
-        this.routeGoneUnsub?.();
-    }
+    dispose() {}
 
     reset() {
-        globalStore.set(this.vdomRoot, null);
+        getDefaultStore().set(this.vdomRoot, null);
         this.atoms.clear();
         this.refs.clear();
         this.batchedEvents = [];
@@ -216,38 +157,7 @@ export class TsunamiModel {
         this.refOutputStore.clear();
         this.globalVersion = jotai.atom(0);
         this.hasBackendWork = false;
-        globalStore.set(this.contextActive, false);
-    }
-
-    getBackendRoute(): string {
-        const blockData = globalStore.get(WOS.getWaveObjectAtom<Block>(makeORef("block", this.blockId)));
-        return blockData?.meta?.["vdom:route"];
-    }
-
-    transformVDomUrl(url: string): string {
-        if (url == null || url == "") {
-            return null;
-        }
-        if (!url.startsWith("vdom://")) {
-            return url;
-        }
-        const absUrl = url.substring(7);
-        return this.makeVDomUrl(absUrl);
-    }
-
-    makeVDomUrl(path: string): string {
-        if (path == null || path == "") {
-            return null;
-        }
-        if (!path.startsWith("/")) {
-            return null;
-        }
-        const backendRouteId = this.getBackendRouteId();
-        if (backendRouteId == null) {
-            return null;
-        }
-        const fullUrl = "/vdom/" + backendRouteId + path;
-        return fullUrl;
+        getDefaultStore().set(this.contextActive, false);
     }
 
     keyDownHandler(e: WaveKeyboardEvent): boolean {
@@ -351,7 +261,7 @@ export class TsunamiModel {
 
     async _sendRenderRequest(force: boolean) {
         this.queuedUpdate = null;
-        if (this.disposed || !this.routeConfirmed) {
+        if (this.disposed) {
             return;
         }
         if (this.hasPendingRequest) {
@@ -363,29 +273,29 @@ export class TsunamiModel {
         if (!force && !this.needsUpdate) {
             return;
         }
-        const backendRoute = globalStore.get(this.backendRoute);
-        if (backendRoute == null) {
-            console.log("vdom-model", "no backend route");
-            return;
-        }
         this.hasPendingRequest = true;
         this.needsImmediateUpdate = false;
         try {
             const feUpdate = this.createFeUpdate();
             dlog("fe-update", feUpdate);
-            const beUpdateGen = await RpcApi.VDomRenderCommand(TabRpcClient, feUpdate, { route: backendRoute });
-            let baseUpdate: VDomBackendUpdate = null;
-            for await (const beUpdate of beUpdateGen) {
-                if (baseUpdate === null) {
-                    baseUpdate = beUpdate;
-                } else {
-                    mergeBackendUpdates(baseUpdate, beUpdate);
-                }
+
+            const response = await fetch("/api/render", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(feUpdate),
+            });
+
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
-            if (baseUpdate !== null) {
-                restoreVDomElems(baseUpdate);
-                dlog("be-update", baseUpdate);
-                this.handleBackendUpdate(baseUpdate);
+
+            const backendUpdate: VDomBackendUpdate = await response.json();
+            if (backendUpdate !== null) {
+                restoreVDomElems(backendUpdate);
+                dlog("be-update", backendUpdate);
+                this.handleBackendUpdate(backendUpdate);
             }
             dlog("update cycle done");
         } finally {
@@ -459,7 +369,7 @@ export class TsunamiModel {
             return;
         }
         const atom = this.getVDomNodeVersionAtom(vdom);
-        globalStore.set(atom, globalStore.get(atom) + 1);
+        getDefaultStore().set(atom, getDefaultStore().get(atom) + 1);
     }
 
     addErrorMessage(message: string) {
@@ -475,7 +385,7 @@ export class TsunamiModel {
         }
         for (let renderUpdate of update.renderupdates) {
             if (renderUpdate.updatetype == "root") {
-                globalStore.set(this.vdomRoot, renderUpdate.vdom);
+                getDefaultStore().set(this.vdomRoot, renderUpdate.vdom);
                 continue;
             }
             if (renderUpdate.updatetype == "append") {
@@ -603,9 +513,9 @@ export class TsunamiModel {
         if (update == null) {
             return;
         }
-        globalStore.set(this.contextActive, true);
+        getDefaultStore().set(this.contextActive, true);
         const idMap = new Map<string, VDomElem>();
-        const vdomRoot = globalStore.get(this.vdomRoot);
+        const vdomRoot = getDefaultStore().get(this.vdomRoot);
         if (update.opts != null) {
             this.backendOpts = update.opts;
         }
@@ -615,13 +525,13 @@ export class TsunamiModel {
         this.handleRefOperations(update, idMap);
         if (update.messages) {
             for (let message of update.messages) {
-                console.log("vdom-message", this.blockId, message.messagetype, message.message);
+                console.log("vdom-message", message.messagetype, message.message);
                 if (message.stacktrace) {
                     console.log("vdom-message-stacktrace", message.stacktrace);
                 }
             }
         }
-        globalStore.set(this.globalVersion, globalStore.get(this.globalVersion) + 1);
+        getDefaultStore().set(this.globalVersion, getDefaultStore().get(this.globalVersion) + 1);
         if (update.haswork) {
             this.hasBackendWork = true;
         }
@@ -650,13 +560,9 @@ export class TsunamiModel {
     }
 
     createFeUpdate(): VDomFrontendUpdate {
-        const blockORef = makeORef("block", this.blockId);
-        const blockAtom = WOS.getWaveObjectAtom<Block>(blockORef);
-        const blockData = globalStore.get(blockAtom);
-        const isBlockFocused = globalStore.get(this.nodeModel.isFocused);
+        const isFocused = document.hasFocus();
         const renderContext: VDomRenderContext = {
-            blockid: this.blockId,
-            focused: isBlockFocused,
+            focused: isFocused,
             width: this.viewRef?.current?.offsetWidth ?? 0,
             height: this.viewRef?.current?.offsetHeight ?? 0,
             rootrefid: this.rootRefId,
@@ -665,7 +571,7 @@ export class TsunamiModel {
         const feUpdate: VDomFrontendUpdate = {
             type: "frontendupdate",
             ts: Date.now(),
-            blockid: this.blockId,
+            clientid: this.clientId,
             rendercontext: renderContext,
             dispose: this.shouldDispose,
             resync: this.needsResync,
@@ -679,12 +585,4 @@ export class TsunamiModel {
         }
         return feUpdate;
     }
-
-    getBackendRouteId(): string {
-        const fullRoute = globalStore.get(this.backendRoute);
-        if (fullRoute == null || !fullRoute.startsWith("proc:")) {
-            return null;
-        }
-        return fullRoute?.split(":")[1];
-    }
 }
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
index 9ec52fcc01..f55b93b341 100644
--- a/tsunami/frontend/src/types/vdom.d.ts
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -134,7 +134,6 @@ type VDomRefUpdate = {
 
 // vdom.VDomRenderContext
 type VDomRenderContext = {
-    blockid: string;
     focused: boolean;
     width: number;
     height: number;
diff --git a/tsunami/frontend/src/util/clientid.ts b/tsunami/frontend/src/util/clientid.ts
new file mode 100644
index 0000000000..4217e291ae
--- /dev/null
+++ b/tsunami/frontend/src/util/clientid.ts
@@ -0,0 +1,26 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+const CLIENT_ID_KEY = "tsunami:clientid";
+
+/**
+ * Gets or creates a unique client ID for this browser tab/window.
+ * The client ID is stored in sessionStorage and persists for the lifetime of the tab.
+ * If no client ID exists, a new UUID is generated and stored.
+ */
+export function getOrCreateClientId(): string {
+    let clientId = sessionStorage.getItem(CLIENT_ID_KEY);
+    if (!clientId) {
+        clientId = crypto.randomUUID();
+        sessionStorage.setItem(CLIENT_ID_KEY, clientId);
+    }
+    return clientId;
+}
+
+/**
+ * Clears the stored client ID from sessionStorage.
+ * A new client ID will be generated on the next call to getOrCreateClientId().
+ */
+export function clearClientId(): void {
+    sessionStorage.removeItem(CLIENT_ID_KEY);
+}
\ No newline at end of file
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index 7e67c54ffb..278bb4a1ab 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -6,10 +6,9 @@ import debug from "debug";
 import * as jotai from "jotai";
 import * as React from "react";
 
-import { BlockNodeModel } from "@/app/block/blocktypes";
 import { Markdown } from "@/element/markdown";
-import { convertVDomId, getTextChildren, validateAndWrapCss, validateAndWrapReactStyle } from "@/model/model-utils";
-import { TsunamiModel } from "@/model/tsunami-model";
+import { getTextChildren } from "@/model/model-utils";
+import type { TsunamiModel } from "@/model/tsunami-model";
 import { adaptFromReactOrNativeKeyEvent, checkKeyPressed } from "@/util/keyutil";
 
 const TextTag = "#text";
@@ -251,39 +250,9 @@ function convertProps(elem: VDomElem, model: TsunamiModel): [GenericPropsType, S
                     }
                 }
             }
-            val = validateAndWrapReactStyle(model, val);
             props[key] = val;
             continue;
         }
-        if (IdAttributes[key]) {
-            props[key] = convertVDomId(model, val);
-            continue;
-        }
-        if (AllowedSvgTags[elem.tag]) {
-            if ((elem.tag == "use" && key == "href") || (elem.tag == "textPath" && key == "href")) {
-                if (val == null || !val.startsWith("#")) {
-                    continue;
-                }
-                props[key] = convertVDomId(model, "#" + val.substring(1));
-                continue;
-            }
-            if (SvgUrlIdAttributes[key]) {
-                if (val == null || !val.startsWith("url(#") || !val.endsWith(")")) {
-                    continue;
-                }
-                props[key] = "url(#" + convertVDomId(model, val.substring(4, val.length - 1)) + ")";
-                continue;
-            }
-        }
-        if (key == "src" && val != null && val.startsWith("vdom://")) {
-            // transform vdom:// urls
-            const newUrl = model.transformVDomUrl(val);
-            if (newUrl == null) {
-                continue;
-            }
-            props[key] = newUrl;
-            continue;
-        }
         props[key] = val;
     }
     return [props, atomKeys];
@@ -341,13 +310,7 @@ function useVDom(model: TsunamiModel, elem: VDomElem): GenericPropsType {
 function WaveMarkdown({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
     const props = useVDom(model, elem);
     return (
-        <Markdown
-            text={props?.text}
-            style={props?.style}
-            className={props?.className}
-            scrollable={props?.scrollable}
-            rehype={props?.rehype}
-        />
+        <Markdown text={props?.text} style={props?.style} className={props?.className} scrollable={props?.scrollable} />
     );
 }
 
@@ -356,19 +319,13 @@ function StyleTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
     if (styleText == null) {
         return null;
     }
-    const wrapperClassName = "vdom-" + model.blockId;
-    // TODO handle errors
-    const sanitizedCss = validateAndWrapCss(model, styleText, wrapperClassName);
-    if (sanitizedCss == null) {
-        return null;
-    }
-    return <style>{sanitizedCss}</style>;
+    return <style>{styleText}</style>;
 }
 
 function WaveStyle({ src, model, onMount }: { src: string; model: TsunamiModel; onMount?: () => void }) {
     const [styleContent, setStyleContent] = React.useState<string | null>(null);
     React.useEffect(() => {
-        async function fetchAndSanitizeCss() {
+        async function fetchCss() {
             try {
                 const response = await fetch(src);
                 if (!response.ok) {
@@ -376,20 +333,13 @@ function WaveStyle({ src, model, onMount }: { src: string; model: TsunamiModel;
                     return;
                 }
                 const cssText = await response.text();
-                const wrapperClassName = "vdom-" + model.blockId;
-                const sanitizedCss = validateAndWrapCss(model, cssText, wrapperClassName);
-                if (sanitizedCss) {
-                    setStyleContent(sanitizedCss);
-                } else {
-                    onMount?.();
-                    console.error("Failed to sanitize CSS");
-                }
+                setStyleContent(cssText);
             } catch (error) {
                 console.error("Error fetching CSS:", error);
                 onMount?.();
             }
         }
-        fetchAndSanitizeCss();
+        fetchCss();
     }, [src, model]);
     // Trigger onMount after styleContent has been set and mounted
     React.useEffect(() => {
@@ -470,10 +420,6 @@ function VDomRoot({ model }: { model: TsunamiModel }) {
     return <div className="vdom">{rtn}</div>;
 }
 
-function makeVDomModel(blockId: string, nodeModel: BlockNodeModel): TsunamiModel {
-    return new TsunamiModel(blockId, nodeModel);
-}
-
 type VDomViewProps = {
     model: TsunamiModel;
     blockId: string;
@@ -487,7 +433,7 @@ function VDomInnerView({ blockId, model }: VDomViewProps) {
     return (
         <>
             {model.backendOpts?.globalstyles ? (
-                <WaveStyle src={model.makeVDomUrl("/wave/global.css")} model={model} onMount={handleStylesMounted} />
+                <WaveStyle src="/vdom/global.css" model={model} onMount={handleStylesMounted} />
             ) : null}
             {styleMounted ? <VDomRoot model={model} /> : null}
         </>
@@ -498,12 +444,11 @@ function VDomView({ blockId, model }: VDomViewProps) {
     let viewRef = React.useRef(null);
     let contextActive = jotai.useAtomValue(model.contextActive);
     model.viewRef = viewRef;
-    const vdomClass = "vdom-" + blockId;
     return (
-        <div className={clsx("overflow-auto w-full min-h-full", vdomClass)} ref={viewRef}>
+        <div className={clsx("overflow-auto w-full min-h-full")} ref={viewRef}>
             {contextActive ? <VDomInnerView blockId={blockId} model={model} /> : null}
         </div>
     );
 }
 
-export { makeVDomModel, VDomView };
+export { VDomView };
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
index b33b1de0d7..459e6fbb1b 100644
--- a/tsunami/rpctypes/types.go
+++ b/tsunami/rpctypes/types.go
@@ -159,7 +159,6 @@ type VDomEvent struct {
 }
 
 type VDomRenderContext struct {
-	BlockId    string `json:"blockid"`
 	Focused    bool   `json:"focused"`
 	Width      int    `json:"width"`
 	Height     int    `json:"height"`

From 44f943cbddf24090259fb9eedbc1781c93f53594 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 12:53:14 -0700
Subject: [PATCH 017/134] checkpoint, no errors, try to load the view

---
 tsunami/frontend/src/app.tsx                 | 12 ++--
 tsunami/frontend/src/model/tsunami-model.tsx | 58 ++++++++++++++------
 tsunami/frontend/src/vdom.tsx                |  7 +--
 3 files changed, 49 insertions(+), 28 deletions(-)

diff --git a/tsunami/frontend/src/app.tsx b/tsunami/frontend/src/app.tsx
index 823cf54d13..d6ffd04b2e 100644
--- a/tsunami/frontend/src/app.tsx
+++ b/tsunami/frontend/src/app.tsx
@@ -1,15 +1,15 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+import { TsunamiModel } from "@/model/tsunami-model";
+import { VDomView } from "./vdom";
+
+const globalModel = new TsunamiModel();
+
 function App() {
     return (
         <div className="min-h-screen bg-background text-foreground">
-            <div className="container mx-auto px-4 py-8">
-                <h1 className="text-title font-bold text-accent mb-4">Tsunami Frontend</h1>
-                <p className="text-default text-muted-foreground">
-                    Welcome to the Tsunami Frontend application built with React 19, TypeScript, and Tailwind v4.
-                </p>
-            </div>
+            <VDomView model={globalModel} />
         </div>
     );
 }
diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
index 3adde5b54e..4cb03e49e8 100644
--- a/tsunami/frontend/src/model/tsunami-model.tsx
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -4,8 +4,6 @@
 import debug from "debug";
 import * as jotai from "jotai";
 
-import { RpcResponseHelper, WshClient } from "@/app/store/wshclient";
-import { makeFeBlockRouteId } from "@/app/store/wshrouter";
 import { getOrCreateClientId } from "@/util/clientid";
 import { adaptFromReactOrNativeKeyEvent, checkKeyPressed } from "@/util/keyutil";
 import { PLATFORM, PlatformMacOS } from "@/util/platformutil";
@@ -83,20 +81,6 @@ function annotateEvent(event: VDomEvent, propName: string, reactEvent: React.Syn
     }
 }
 
-class VDomWshClient extends WshClient {
-    model: TsunamiModel;
-
-    constructor(model: TsunamiModel) {
-        super(makeFeBlockRouteId(model.blockId));
-        this.model = model;
-    }
-
-    handle_vdomasyncinitiation(rh: RpcResponseHelper, data: VDomAsyncInitiationRequest) {
-        dlog("async-initiation", rh.getSource(), data);
-        this.model.queueUpdate(true);
-    }
-}
-
 export class TsunamiModel {
     clientId: string;
     viewRef: React.RefObject<HTMLDivElement> = { current: null };
@@ -119,7 +103,7 @@ export class TsunamiModel {
     lastUpdateTs: number = 0;
     queuedUpdate: { timeoutId: any; ts: number; quick: boolean };
     contextActive: jotai.PrimitiveAtom<boolean>;
-    wshClient: VDomWshClient;
+    serverEventSource: EventSource;
     refOutputStore: Map<string, any> = new Map();
     globalVersion: jotai.PrimitiveAtom<number> = jotai.atom(0);
     hasBackendWork: boolean = false;
@@ -130,12 +114,44 @@ export class TsunamiModel {
         this.contextActive = jotai.atom(false);
         this.reset();
         this.noPadding = jotai.atom(true);
+        this.setupServerEventSource();
         this.queueUpdate(true);
     }
 
-    dispose() {}
+    dispose() {
+        if (this.serverEventSource) {
+            this.serverEventSource.close();
+            this.serverEventSource = null;
+        }
+    }
+
+    setupServerEventSource() {
+        if (this.serverEventSource) {
+            this.serverEventSource.close();
+        }
+
+        const url = `/api/updates?clientId=${encodeURIComponent(this.clientId)}`;
+        this.serverEventSource = new EventSource(url);
+
+        this.serverEventSource.addEventListener("asyncinitiation", (event) => {
+            dlog("async-initiation SSE event received", event);
+            this.queueUpdate(true);
+        });
+
+        this.serverEventSource.addEventListener("error", (event) => {
+            console.error("SSE connection error:", event);
+        });
+
+        this.serverEventSource.addEventListener("open", (event) => {
+            dlog("SSE connection opened", event);
+        });
+    }
 
     reset() {
+        if (this.serverEventSource) {
+            this.serverEventSource.close();
+            this.serverEventSource = null;
+        }
         getDefaultStore().set(this.vdomRoot, null);
         this.atoms.clear();
         this.refs.clear();
@@ -291,6 +307,12 @@ export class TsunamiModel {
                 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
 
+            // Check if EventSource connection is closed and reconnect if needed
+            if (this.serverEventSource && this.serverEventSource.readyState === EventSource.CLOSED) {
+                dlog("EventSource connection closed, reconnecting");
+                this.setupServerEventSource();
+            }
+
             const backendUpdate: VDomBackendUpdate = await response.json();
             if (backendUpdate !== null) {
                 restoreVDomElems(backendUpdate);
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index 278bb4a1ab..486a12064b 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -422,10 +422,9 @@ function VDomRoot({ model }: { model: TsunamiModel }) {
 
 type VDomViewProps = {
     model: TsunamiModel;
-    blockId: string;
 };
 
-function VDomInnerView({ blockId, model }: VDomViewProps) {
+function VDomInnerView({ model }: VDomViewProps) {
     let [styleMounted, setStyleMounted] = React.useState(!model.backendOpts?.globalstyles);
     const handleStylesMounted = () => {
         setStyleMounted(true);
@@ -440,13 +439,13 @@ function VDomInnerView({ blockId, model }: VDomViewProps) {
     );
 }
 
-function VDomView({ blockId, model }: VDomViewProps) {
+function VDomView({ model }: VDomViewProps) {
     let viewRef = React.useRef(null);
     let contextActive = jotai.useAtomValue(model.contextActive);
     model.viewRef = viewRef;
     return (
         <div className={clsx("overflow-auto w-full min-h-full")} ref={viewRef}>
-            {contextActive ? <VDomInnerView blockId={blockId} model={model} /> : null}
+            {contextActive ? <VDomInnerView model={model} /> : null}
         </div>
     );
 }

From 53ff0c3d631319246d1b28de7a6ed48bd6fe2f93 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 12:57:22 -0700
Subject: [PATCH 018/134] tsunami_listenaddr

---
 tsunami/app/{waveapp.go => tsunamiapp.go} | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)
 rename tsunami/app/{waveapp.go => tsunamiapp.go} (96%)

diff --git a/tsunami/app/waveapp.go b/tsunami/app/tsunamiapp.go
similarity index 96%
rename from tsunami/app/waveapp.go
rename to tsunami/app/tsunamiapp.go
index 1c80893a92..d3c64becc0 100644
--- a/tsunami/app/waveapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -25,6 +25,9 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
+const TsunamiListenAddrEnvVar = "TSUNAMI_LISTENADDR"
+const DefaultListenAddr = "localhost:0"
+
 type SSEvent struct {
 	Event string
 	Data  []byte
@@ -155,14 +158,20 @@ func (c *Client) ListenAndServe(ctx context.Context) error {
 	mux := http.NewServeMux()
 	handlers.RegisterHandlers(mux)
 
-	// Create server and listen on any available port on localhost
+	// Determine listen address from environment variable or use default
+	listenAddr := os.Getenv(TsunamiListenAddrEnvVar)
+	if listenAddr == "" {
+		listenAddr = DefaultListenAddr
+	}
+
+	// Create server and listen on specified address
 	server := &http.Server{
-		Addr:    "localhost:0",
+		Addr:    listenAddr,
 		Handler: mux,
 	}
 
 	// Start listening
-	listener, err := net.Listen("tcp", "localhost:0")
+	listener, err := net.Listen("tcp", listenAddr)
 	if err != nil {
 		return fmt.Errorf("failed to listen: %v", err)
 	}

From 58eaf16c43116c2142d81810826254bef2d3e638 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 13:59:46 -0700
Subject: [PATCH 019/134] checkpoint -- fixing types, names, packages

---
 tsunami/app/serverhandlers.go                |  2 +-
 tsunami/app/tsunamiapp.go                    |  6 +-
 tsunami/comp/root_test.go                    |  3 +-
 tsunami/comp/rootelem.go                     |  8 +--
 tsunami/frontend/src/model/tsunami-model.tsx |  2 +-
 tsunami/frontend/src/types/custom.d.ts       | 15 -----
 tsunami/frontend/src/types/vdom.d.ts         | 20 +-----
 tsunami/frontend/src/util/keyutil.ts         | 20 +++---
 tsunami/rpctypes/types.go                    | 67 +-------------------
 tsunami/vdom/vdom_types.go                   | 50 +++++++++++++++
 10 files changed, 74 insertions(+), 119 deletions(-)

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index 0fbed3862a..bef047adcf 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package waveapp
+package app
 
 import (
 	"encoding/json"
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index d3c64becc0..5ced66abde 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package waveapp
+package app
 
 import (
 	"context"
@@ -51,7 +51,7 @@ type Client struct {
 	DoneCh             chan struct{}
 	SSEventCh          chan SSEvent
 	Opts               rpctypes.VDomBackendOpts
-	GlobalEventHandler func(client *Client, event rpctypes.VDomEvent)
+	GlobalEventHandler func(client *Client, event vdom.VDomEvent)
 	GlobalStylesOption *FileHandlerOption
 	UrlHandlerMux      *mux.Router
 	OverrideUrlHandler http.Handler
@@ -94,7 +94,7 @@ func (c *Client) doShutdown(reason string) {
 	close(c.DoneCh)
 }
 
-func (c *Client) SetGlobalEventHandler(handler func(client *Client, event rpctypes.VDomEvent)) {
+func (c *Client) SetGlobalEventHandler(handler func(client *Client, event vdom.VDomEvent)) {
 	c.GlobalEventHandler = handler
 }
 
diff --git a/tsunami/comp/root_test.go b/tsunami/comp/root_test.go
index 30f57ccacf..e7880829c3 100644
--- a/tsunami/comp/root_test.go
+++ b/tsunami/comp/root_test.go
@@ -10,7 +10,6 @@ import (
 	"log"
 	"testing"
 
-	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
@@ -93,7 +92,7 @@ func Test1(t *testing.T) {
 	printVDom(root)
 	root.RunWork()
 	printVDom(root)
-	root.Event(testContext.ButtonId, "onClick", rpctypes.VDomEvent{EventType: "onClick"})
+	root.Event(testContext.ButtonId, "onClick", vdom.VDomEvent{EventType: "onClick"})
 	root.RunWork()
 	printVDom(root)
 }
diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index 04b7ab6dcb..26559ba387 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -140,7 +140,7 @@ func (r *RootElem) Render(elem *vdom.VDomElem) {
 	r.render(elem, &r.Root)
 }
 
-func callVDomFn(fnVal any, data rpctypes.VDomEvent) {
+func callVDomFn(fnVal any, data vdom.VDomEvent) {
 	if fnVal == nil {
 		return
 	}
@@ -166,7 +166,7 @@ func callVDomFn(fnVal any, data rpctypes.VDomEvent) {
 	}
 }
 
-func (r *RootElem) Event(id string, propName string, event rpctypes.VDomEvent) {
+func (r *RootElem) Event(id string, propName string, event vdom.VDomEvent) {
 	comp := r.CompMap[id]
 	if comp == nil || comp.Elem == nil {
 		return
@@ -481,7 +481,7 @@ func ConvertElemsToTransferElems(elems []vdom.VDomElem) []rpctypes.VDomTransferE
 	return transferElems
 }
 
-func VDomFuncCallFn(vdf *vdom.VDomFunc, event rpctypes.VDomEvent) {
+func VDomFuncCallFn(vdf *vdom.VDomFunc, event vdom.VDomEvent) {
 	if vdf.Fn == nil {
 		return
 	}
@@ -494,7 +494,7 @@ func VDomFuncCallFn(vdf *vdom.VDomFunc, event rpctypes.VDomEvent) {
 		rval.Call(nil)
 	}
 	if rtype.NumIn() == 1 {
-		if rtype.In(0) == reflect.TypeOf((*rpctypes.VDomEvent)(nil)).Elem() {
+		if rtype.In(0) == reflect.TypeOf((*vdom.VDomEvent)(nil)).Elem() {
 			rval.Call([]reflect.Value{reflect.ValueOf(event)})
 		}
 	}
diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
index 4cb03e49e8..76cd5cb95c 100644
--- a/tsunami/frontend/src/model/tsunami-model.tsx
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -176,7 +176,7 @@ export class TsunamiModel {
         getDefaultStore().set(this.contextActive, false);
     }
 
-    keyDownHandler(e: WaveKeyboardEvent): boolean {
+    keyDownHandler(e: VDomKeyboardEvent): boolean {
         if (this.backendOpts?.closeonctrlc && checkKeyPressed(e, "Ctrl:c")) {
             this.shouldDispose = true;
             this.queueUpdate(true);
diff --git a/tsunami/frontend/src/types/custom.d.ts b/tsunami/frontend/src/types/custom.d.ts
index 1c5b788ade..b7c843aeb2 100644
--- a/tsunami/frontend/src/types/custom.d.ts
+++ b/tsunami/frontend/src/types/custom.d.ts
@@ -1,21 +1,6 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-// vdom.WaveKeyboardEvent
-type WaveKeyboardEvent = {
-    type: "keydown" | "keyup" | "keypress" | "unknown";
-    key: string;
-    code: string;
-    repeat?: boolean;
-    location?: number;
-    shift?: boolean;
-    control?: boolean;
-    alt?: boolean;
-    meta?: boolean;
-    cmd?: boolean;
-    option?: boolean;
-};
-
 type KeyPressDecl = {
     mods: {
         Cmd?: boolean;
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
index f55b93b341..bfd45a3da5 100644
--- a/tsunami/frontend/src/types/vdom.d.ts
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -61,8 +61,8 @@ type VDomEvent = {
     targetchecked?: boolean;
     targetname?: string;
     targetid?: string;
-    keydata?: WaveKeyboardEvent;
-    mousedata?: WavePointerData;
+    keydata?: VDomKeyboardEvent;
+    mousedata?: VDomPointerData;
 };
 
 // vdom.VDomFrontendUpdate
@@ -208,21 +208,7 @@ type VDomKeyboardEvent = {
     location?: number;
 };
 
-type WaveKeyboardEvent = {
-    type: "keydown" | "keyup" | "keypress" | "unknown";
-    key: string;
-    code: string;
-    repeat?: boolean;
-    location?: number;
-    shift?: boolean;
-    control?: boolean;
-    alt?: boolean;
-    meta?: boolean;
-    cmd?: boolean;
-    option?: boolean;
-};
-
-type WavePointerData = {
+type VDomPointerData = {
     button: number;
     buttons: number;
     clientx?: number;
diff --git a/tsunami/frontend/src/util/keyutil.ts b/tsunami/frontend/src/util/keyutil.ts
index 25b6c8dbf1..04c0d2048e 100644
--- a/tsunami/frontend/src/util/keyutil.ts
+++ b/tsunami/frontend/src/util/keyutil.ts
@@ -17,7 +17,7 @@ function getKeyUtilPlatform(): NodeJS.Platform {
 }
 
 function keydownWrapper(
-    fn: (waveEvent: WaveKeyboardEvent) => boolean
+    fn: (waveEvent: VDomKeyboardEvent) => boolean
 ): (event: KeyboardEvent | React.KeyboardEvent) => void {
     return (event: KeyboardEvent | React.KeyboardEvent) => {
         const waveEvent = adaptFromReactOrNativeKeyEvent(event);
@@ -29,7 +29,7 @@ function keydownWrapper(
     };
 }
 
-function waveEventToKeyDesc(waveEvent: WaveKeyboardEvent): string {
+function waveEventToKeyDesc(waveEvent: VDomKeyboardEvent): string {
     let keyDesc: string[] = [];
     if (waveEvent.cmd) {
         keyDesc.push("Cmd");
@@ -138,7 +138,7 @@ function countGraphemes(str: string): number {
     return Array.from(seg.segment(str)).length;
 }
 
-function isCharacterKeyEvent(event: WaveKeyboardEvent): boolean {
+function isCharacterKeyEvent(event: VDomKeyboardEvent): boolean {
     if (event.alt || event.meta || event.control) {
         return false;
     }
@@ -181,7 +181,7 @@ const inputKeyMap = new Map<string, boolean>([
     ["Cmd:Shift:ArrowDown", true],
 ]);
 
-function isInputEvent(event: WaveKeyboardEvent): boolean {
+function isInputEvent(event: VDomKeyboardEvent): boolean {
     if (isCharacterKeyEvent(event)) {
         return true;
     }
@@ -192,7 +192,7 @@ function isInputEvent(event: WaveKeyboardEvent): boolean {
     }
 }
 
-function checkKeyPressed(event: WaveKeyboardEvent, keyDescription: string): boolean {
+function checkKeyPressed(event: VDomKeyboardEvent, keyDescription: string): boolean {
     let keyPress = parseKeyDescription(keyDescription);
     if (notMod(keyPress.mods.Option, event.option)) {
         return false;
@@ -235,8 +235,8 @@ function checkKeyPressed(event: WaveKeyboardEvent, keyDescription: string): bool
     return true;
 }
 
-function adaptFromReactOrNativeKeyEvent(event: React.KeyboardEvent | KeyboardEvent): WaveKeyboardEvent {
-    let rtn: WaveKeyboardEvent = {} as WaveKeyboardEvent;
+function adaptFromReactOrNativeKeyEvent(event: React.KeyboardEvent | KeyboardEvent): VDomKeyboardEvent {
+    let rtn: VDomKeyboardEvent = {} as VDomKeyboardEvent;
     rtn.control = event.ctrlKey;
     rtn.shift = event.shiftKey;
     rtn.cmd = PLATFORM == PlatformMacOS ? event.metaKey : event.altKey;
@@ -256,8 +256,8 @@ function adaptFromReactOrNativeKeyEvent(event: React.KeyboardEvent | KeyboardEve
     return rtn;
 }
 
-function adaptFromElectronKeyEvent(event: any): WaveKeyboardEvent {
-    let rtn: WaveKeyboardEvent = {} as WaveKeyboardEvent;
+function adaptFromElectronKeyEvent(event: any): VDomKeyboardEvent {
+    let rtn: VDomKeyboardEvent = {} as VDomKeyboardEvent;
     if (event.type == "keyUp") {
         rtn.type = "keyup";
     } else if (event.type == "keyDown") {
@@ -295,7 +295,7 @@ const keyMap = {
     PageDown: "\x1b[6~",
 };
 
-function keyboardEventToASCII(event: WaveKeyboardEvent): string {
+function keyboardEventToASCII(event: VDomKeyboardEvent): string {
     // check modifiers
     // if no modifiers are set, just send the key
     if (!event.alt && !event.control && !event.meta) {
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
index 459e6fbb1b..b5b0849a5f 100644
--- a/tsunami/rpctypes/types.go
+++ b/tsunami/rpctypes/types.go
@@ -39,7 +39,7 @@ type VDomFrontendUpdate struct {
 	Dispose       bool              `json:"dispose,omitempty"` // the vdom context was closed
 	Resync        bool              `json:"resync,omitempty"`  // resync (send all backend data).  useful when the FE reloads
 	RenderContext VDomRenderContext `json:"rendercontext,omitempty"`
-	Events        []VDomEvent       `json:"events,omitempty"`
+	Events        []vdom.VDomEvent  `json:"events,omitempty"`
 	StateSync     []VDomStateSync   `json:"statesync,omitempty"`
 	RefUpdates    []VDomRefUpdate   `json:"refupdates,omitempty"`
 	Messages      []VDomMessage     `json:"messages,omitempty"`
@@ -146,18 +146,6 @@ func DedupTransferElems(elems []VDomTransferElem) []VDomTransferElem {
 	return result
 }
 
-type VDomEvent struct {
-	WaveId          string             `json:"waveid"`
-	EventType       string             `json:"eventtype"` // usually the prop name (e.g. onClick, onKeyDown)
-	GlobalEventType string             `json:"globaleventtype,omitempty"`
-	TargetValue     string             `json:"targetvalue,omitempty"`
-	TargetChecked   bool               `json:"targetchecked,omitempty"`
-	TargetName      string             `json:"targetname,omitempty"`
-	TargetId        string             `json:"targetid,omitempty"`
-	KeyData         *WaveKeyboardEvent `json:"keydata,omitempty"`
-	MouseData       *WavePointerData   `json:"mousedata,omitempty"`
-}
-
 type VDomRenderContext struct {
 	Focused    bool   `json:"focused"`
 	Width      int    `json:"width"`
@@ -204,56 +192,3 @@ type VDomMessage struct {
 	StackTrace  string `json:"stacktrace,omitempty"`
 	Params      []any  `json:"params,omitempty"`
 }
-
-// matches WaveKeyboardEvent
-type VDomKeyboardEvent struct {
-	Type     string `json:"type"`
-	Key      string `json:"key"`
-	Code     string `json:"code"`
-	Shift    bool   `json:"shift,omitempty"`
-	Control  bool   `json:"ctrl,omitempty"`
-	Alt      bool   `json:"alt,omitempty"`
-	Meta     bool   `json:"meta,omitempty"`
-	Cmd      bool   `json:"cmd,omitempty"`
-	Option   bool   `json:"option,omitempty"`
-	Repeat   bool   `json:"repeat,omitempty"`
-	Location int    `json:"location,omitempty"`
-}
-
-type WaveKeyboardEvent struct {
-	Type     string `json:"type" tstype:"\"keydown\"|\"keyup\"|\"keypress\"|\"unknown\""`
-	Key      string `json:"key"`  // KeyboardEvent.key
-	Code     string `json:"code"` // KeyboardEvent.code
-	Repeat   bool   `json:"repeat,omitempty"`
-	Location int    `json:"location,omitempty"` // KeyboardEvent.location
-
-	// modifiers
-	Shift   bool `json:"shift,omitempty"`
-	Control bool `json:"control,omitempty"`
-	Alt     bool `json:"alt,omitempty"`
-	Meta    bool `json:"meta,omitempty"`
-	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
-	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
-}
-
-type WavePointerData struct {
-	Button  int `json:"button"`
-	Buttons int `json:"buttons"`
-
-	ClientX   int `json:"clientx,omitempty"`
-	ClientY   int `json:"clienty,omitempty"`
-	PageX     int `json:"pagex,omitempty"`
-	PageY     int `json:"pagey,omitempty"`
-	ScreenX   int `json:"screenx,omitempty"`
-	ScreenY   int `json:"screeny,omitempty"`
-	MovementX int `json:"movementx,omitempty"`
-	MovementY int `json:"movementy,omitempty"`
-
-	// Modifiers
-	Shift   bool `json:"shift,omitempty"`
-	Control bool `json:"control,omitempty"`
-	Alt     bool `json:"alt,omitempty"`
-	Meta    bool `json:"meta,omitempty"`
-	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
-	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
-}
diff --git a/tsunami/vdom/vdom_types.go b/tsunami/vdom/vdom_types.go
index cfce234243..56664a13de 100644
--- a/tsunami/vdom/vdom_types.go
+++ b/tsunami/vdom/vdom_types.go
@@ -97,3 +97,53 @@ type VDomRefPosition struct {
 	ScrollTop          int     `json:"scrolltop"`
 	BoundingClientRect DomRect `json:"boundingclientrect"`
 }
+
+type VDomEvent struct {
+	WaveId          string             `json:"waveid"`
+	EventType       string             `json:"eventtype"` // usually the prop name (e.g. onClick, onKeyDown)
+	GlobalEventType string             `json:"globaleventtype,omitempty"`
+	TargetValue     string             `json:"targetvalue,omitempty"`
+	TargetChecked   bool               `json:"targetchecked,omitempty"`
+	TargetName      string             `json:"targetname,omitempty"`
+	TargetId        string             `json:"targetid,omitempty"`
+	KeyData         *VDomKeyboardEvent `json:"keydata,omitempty"`
+	MouseData       *VDomPointerData   `json:"mousedata,omitempty"`
+}
+
+type VDomKeyboardEvent struct {
+	Type     string `json:"type" tstype:"\"keydown\"|\"keyup\"|\"keypress\"|\"unknown\""`
+	Key      string `json:"key"`  // KeyboardEvent.key
+	Code     string `json:"code"` // KeyboardEvent.code
+	Repeat   bool   `json:"repeat,omitempty"`
+	Location int    `json:"location,omitempty"` // KeyboardEvent.location
+
+	// modifiers
+	Shift   bool `json:"shift,omitempty"`
+	Control bool `json:"control,omitempty"`
+	Alt     bool `json:"alt,omitempty"`
+	Meta    bool `json:"meta,omitempty"`
+	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
+	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
+}
+
+type VDomPointerData struct {
+	Button  int `json:"button"`
+	Buttons int `json:"buttons"`
+
+	ClientX   int `json:"clientx,omitempty"`
+	ClientY   int `json:"clienty,omitempty"`
+	PageX     int `json:"pagex,omitempty"`
+	PageY     int `json:"pagey,omitempty"`
+	ScreenX   int `json:"screenx,omitempty"`
+	ScreenY   int `json:"screeny,omitempty"`
+	MovementX int `json:"movementx,omitempty"`
+	MovementY int `json:"movementy,omitempty"`
+
+	// Modifiers
+	Shift   bool `json:"shift,omitempty"`
+	Control bool `json:"control,omitempty"`
+	Alt     bool `json:"alt,omitempty"`
+	Meta    bool `json:"meta,omitempty"`
+	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
+	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
+}

From d3d66846d3f85bf471651af1a16a4aa1bad7875f Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 14:49:23 -0700
Subject: [PATCH 020/134] got hello world working with new model

---
 Taskfile.yml                         |  12 ++
 frontend/types/gotypes.d.ts          |   1 +
 tsunami/app/serverhandlers.go        |  12 +-
 tsunami/demo/todo/main-todo.go       | 188 +++++++++++++++++++++++++++
 tsunami/demo/todo/style.css          |  68 ++++++++++
 tsunami/frontend/src/util/keyutil.ts |   1 -
 tsunami/frontend/src/vdom.tsx        |   2 +-
 tsunami/frontend/vite.config.ts      |  10 ++
 tsunami/rpctypes/types.go            |  19 +--
 9 files changed, 296 insertions(+), 17 deletions(-)
 create mode 100644 tsunami/demo/todo/main-todo.go
 create mode 100644 tsunami/demo/todo/style.css

diff --git a/Taskfile.yml b/Taskfile.yml
index 5e25f0967b..17cad4e27e 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -438,3 +438,15 @@ tasks:
               ignore_error: true
             - cmd: '{{.RMRF}} "dist"'
               ignore_error: true
+
+    tsunami:demo:todo:
+        desc: Run the tsunami todo demo application
+        cmd: go run demo/todo/main-todo.go
+        dir: tsunami
+        env:
+            TSUNAMI_LISTENADDR: "localhost:12026"
+
+    tsunami:frontend:dev:
+        desc: Run the tsunami frontend vite dev server
+        cmd: npm run dev
+        dir: tsunami/frontend
diff --git a/frontend/types/gotypes.d.ts b/frontend/types/gotypes.d.ts
index 3c09656649..0d70582e48 100644
--- a/frontend/types/gotypes.d.ts
+++ b/frontend/types/gotypes.d.ts
@@ -837,6 +837,7 @@ declare global {
         "debug:panictype"?: string;
         "block:view"?: string;
         "ai:backendtype"?: string;
+        "ai:local"?: boolean;
         "wsh:cmd"?: string;
         "wsh:haderror"?: boolean;
         "conn:conntype"?: string;
diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index bef047adcf..bbc5f8a893 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -33,7 +33,7 @@ func NewHTTPHandlers(client *Client) *HTTPHandlers {
 func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux) {
 	mux.HandleFunc("/api/render", h.handleRender)
 	mux.HandleFunc("/api/updates", h.handleSSE)
-	mux.HandleFunc("/vdom/", h.handleVDomUrl)
+	mux.HandleFunc("/assets/", h.handleAssetsUrl)
 }
 
 func (h *HTTPHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
@@ -138,21 +138,21 @@ func (h *HTTPHandlers) processFrontendUpdate(feUpdate *rpctypes.VDomFrontendUpda
 	return update, nil
 }
 
-func (h *HTTPHandlers) handleVDomUrl(w http.ResponseWriter, r *http.Request) {
+func (h *HTTPHandlers) handleAssetsUrl(w http.ResponseWriter, r *http.Request) {
 	defer func() {
-		panicErr := util.PanicHandler("handleVDomUrl", recover())
+		panicErr := util.PanicHandler("handleAssetsUrl", recover())
 		if panicErr != nil {
 			http.Error(w, fmt.Sprintf("internal server error: %v", panicErr), http.StatusInternalServerError)
 		}
 	}()
 
-	// Strip /vdom prefix and update the request URL
-	r.URL.Path = strings.TrimPrefix(r.URL.Path, "/vdom")
+	// Strip /assets prefix and update the request URL
+	r.URL.Path = strings.TrimPrefix(r.URL.Path, "/assets")
 	if r.URL.Path == "" {
 		r.URL.Path = "/"
 	}
 
-	if r.URL.Path == "/wave/global.css" && h.Client.GlobalStylesOption != nil {
+	if r.URL.Path == "/global.css" && h.Client.GlobalStylesOption != nil {
 		ServeFileOption(w, r, *h.Client.GlobalStylesOption)
 		return
 	}
diff --git a/tsunami/demo/todo/main-todo.go b/tsunami/demo/todo/main-todo.go
new file mode 100644
index 0000000000..17d37345a4
--- /dev/null
+++ b/tsunami/demo/todo/main-todo.go
@@ -0,0 +1,188 @@
+package main
+
+import (
+	"context"
+	_ "embed"
+	"strconv"
+
+	"github.com/wavetermdev/waveterm/tsunami/app"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+//go:embed style.css
+var styleCSS []byte
+
+// Initialize client with embedded styles and ctrl-c handling
+var AppClient = app.MakeClient(app.AppOpts{
+	CloseOnCtrlC: true,
+	GlobalStyles: styleCSS,
+})
+
+// Basic domain types with json tags for props
+type Todo struct {
+	Id        int    `json:"id"`
+	Text      string `json:"text"`
+	Completed bool   `json:"completed"`
+}
+
+// Prop types demonstrate parent->child data flow
+type TodoListProps struct {
+	Todos    []Todo    `json:"todos"`
+	OnToggle func(int) `json:"onToggle"`
+	OnDelete func(int) `json:"onDelete"`
+}
+
+type TodoItemProps struct {
+	Todo     Todo   `json:"todo"`
+	OnToggle func() `json:"onToggle"`
+	OnDelete func() `json:"onDelete"`
+}
+
+type InputFieldProps struct {
+	Value    string       `json:"value"`
+	OnChange func(string) `json:"onChange"`
+	OnEnter  func()       `json:"onEnter"`
+}
+
+// Reusable input component showing keyboard event handling
+var InputField = app.DefineComponent[InputFieldProps](AppClient, "InputField",
+	func(ctx context.Context, props InputFieldProps) any {
+		// Example of special key handling with VDomFunc
+		keyDown := &vdom.VDomFunc{
+			Type:            vdom.ObjectType_Func,
+			Fn:              func(event vdom.VDomEvent) { props.OnEnter() },
+			StopPropagation: true,
+			PreventDefault:  true,
+			Keys:            []string{"Enter", "Cmd:Enter"},
+		}
+
+		return vdom.H("input", map[string]any{
+			"className":   "todo-input",
+			"type":        "text",
+			"placeholder": "What needs to be done?",
+			"value":       props.Value,
+			"onChange": func(e vdom.VDomEvent) {
+				props.OnChange(e.TargetValue)
+			},
+			"onKeyDown": keyDown,
+		})
+	},
+)
+
+// Item component showing conditional classes and event handling
+var TodoItem = app.DefineComponent(AppClient, "TodoItem",
+	func(ctx context.Context, props TodoItemProps) any {
+		return vdom.H("div", map[string]any{
+			"className": vdom.Classes("todo-item", vdom.If(props.Todo.Completed, "completed")),
+		},
+			vdom.H("input", map[string]any{
+				"className": "todo-checkbox",
+				"type":      "checkbox",
+				"checked":   props.Todo.Completed,
+				"onChange":  props.OnToggle,
+			}),
+			vdom.H("span", map[string]any{
+				"className": "todo-text",
+			}, props.Todo.Text),
+			vdom.H("button", map[string]any{
+				"className": "todo-delete",
+				"onClick":   props.OnDelete,
+			}, "×"),
+		)
+	},
+)
+
+// List component demonstrating mapping over data, using WithKey to set key on a component
+var TodoList = app.DefineComponent(AppClient, "TodoList",
+	func(ctx context.Context, props TodoListProps) any {
+		return vdom.H("div", map[string]any{
+			"className": "todo-list",
+		}, vdom.ForEach(props.Todos, func(todo Todo) any {
+			return TodoItem(TodoItemProps{
+				Todo:     todo,
+				OnToggle: func() { props.OnToggle(todo.Id) },
+				OnDelete: func() { props.OnDelete(todo.Id) },
+			}).WithKey(strconv.Itoa(todo.Id))
+		}))
+	},
+)
+
+// Root component showing state management and composition
+var App = app.DefineComponent(AppClient, "App",
+	func(ctx context.Context, _ any) any {
+		// Multiple state hooks example
+		todos, setTodos := vdom.UseState(ctx, []Todo{
+			{Id: 1, Text: "Learn VDOM", Completed: false},
+			{Id: 2, Text: "Build a todo app", Completed: false},
+		})
+		nextId, setNextId := vdom.UseState(ctx, 3)
+		inputText, setInputText := vdom.UseState(ctx, "")
+
+		// Event handlers modifying multiple pieces of state
+		addTodo := func() {
+			if inputText == "" {
+				return
+			}
+			setTodos(append(todos, Todo{
+				Id:        nextId,
+				Text:      inputText,
+				Completed: false,
+			}))
+			setNextId(nextId + 1)
+			setInputText("")
+		}
+
+		// Immutable state update pattern
+		toggleTodo := func(id int) {
+			newTodos := make([]Todo, len(todos))
+			copy(newTodos, todos)
+			for i := range newTodos {
+				if newTodos[i].Id == id {
+					newTodos[i].Completed = !newTodos[i].Completed
+					break
+				}
+			}
+			setTodos(newTodos)
+		}
+
+		// Filter pattern for deletion
+		deleteTodo := func(id int) {
+			newTodos := vdom.Filter(todos, func(todo Todo) bool {
+				return todo.Id != id
+			})
+			setTodos(newTodos)
+		}
+
+		return vdom.H("div", map[string]any{
+			"className": "todo-app",
+		},
+			vdom.H("div", map[string]any{
+				"className": "todo-header",
+			}, vdom.H("h1", nil, "Todo List")),
+
+			vdom.H("div", map[string]any{
+				"className": "todo-form",
+			},
+				InputField(InputFieldProps{
+					Value:    inputText,
+					OnChange: setInputText,
+					OnEnter:  addTodo,
+				}),
+				vdom.H("button", map[string]any{
+					"className": "todo-button",
+					"onClick":   addTodo,
+				}, "Add Todo"),
+			),
+
+			TodoList(TodoListProps{
+				Todos:    todos,
+				OnToggle: toggleTodo,
+				OnDelete: deleteTodo,
+			}),
+		)
+	},
+)
+
+func main() {
+	AppClient.RunMain()
+}
diff --git a/tsunami/demo/todo/style.css b/tsunami/demo/todo/style.css
new file mode 100644
index 0000000000..89d4ce82c6
--- /dev/null
+++ b/tsunami/demo/todo/style.css
@@ -0,0 +1,68 @@
+.todo-app {
+    max-width: 500px;
+    margin: 20px;
+    font-family: sans-serif;
+}
+.todo-header {
+    margin-bottom: 20px;
+}
+.todo-form {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 20px;
+}
+.todo-input {
+    flex: 1;
+    padding: 8px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    background: var(--input-bg);
+    color: var(--text-color);
+}
+.todo-button {
+    padding: 8px 16px;
+    background: var(--button-bg);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    color: var(--text-color);
+    cursor: pointer;
+}
+.todo-button:hover {
+    background: var(--button-hover-bg);
+}
+.todo-list {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+.todo-item {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 8px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    background: var(--block-bg);
+}
+.todo-item.completed {
+    opacity: 0.7;
+}
+.todo-item.completed .todo-text {
+    text-decoration: line-through;
+}
+.todo-text {
+    flex: 1;
+}
+.todo-checkbox {
+    width: 16px;
+    height: 16px;
+}
+.todo-delete {
+    color: var(--error-color);
+    cursor: pointer;
+    padding: 4px 8px;
+    border-radius: 4px;
+}
+.todo-delete:hover {
+    background: var(--error-bg);
+}
diff --git a/tsunami/frontend/src/util/keyutil.ts b/tsunami/frontend/src/util/keyutil.ts
index 04c0d2048e..625cc1fc7c 100644
--- a/tsunami/frontend/src/util/keyutil.ts
+++ b/tsunami/frontend/src/util/keyutil.ts
@@ -246,7 +246,6 @@ function adaptFromReactOrNativeKeyEvent(event: React.KeyboardEvent | KeyboardEve
     rtn.code = event.code;
     rtn.key = event.key;
     rtn.location = event.location;
-    (rtn as any).nativeEvent = event;
     if (event.type == "keydown" || event.type == "keyup" || event.type == "keypress") {
         rtn.type = event.type;
     } else {
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index 486a12064b..09544faf2f 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -432,7 +432,7 @@ function VDomInnerView({ model }: VDomViewProps) {
     return (
         <>
             {model.backendOpts?.globalstyles ? (
-                <WaveStyle src="/vdom/global.css" model={model} onMount={handleStylesMounted} />
+                <WaveStyle src="/assets/global.css" model={model} onMount={handleStylesMounted} />
             ) : null}
             {styleMounted ? <VDomRoot model={model} /> : null}
         </>
diff --git a/tsunami/frontend/vite.config.ts b/tsunami/frontend/vite.config.ts
index d2f1d946f2..4faaf3cb18 100644
--- a/tsunami/frontend/vite.config.ts
+++ b/tsunami/frontend/vite.config.ts
@@ -15,6 +15,16 @@ export default defineConfig({
     server: {
         port: 12025,
         open: true,
+        proxy: {
+            "/api": {
+                target: "http://localhost:12026",
+                changeOrigin: true,
+            },
+            "/assets": {
+                target: "http://localhost:12026",
+                changeOrigin: true,
+            },
+        },
     },
     build: {
         outDir: "dist",
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
index b5b0849a5f..0b3ee35395 100644
--- a/tsunami/rpctypes/types.go
+++ b/tsunami/rpctypes/types.go
@@ -67,17 +67,18 @@ type VDomTransferElem struct {
 }
 
 func (beUpdate *VDomBackendUpdate) CreateTransferElems() {
-	var allElems []vdom.VDomElem
-	for _, renderUpdate := range beUpdate.RenderUpdates {
-		if renderUpdate.VDom != nil {
-			allElems = append(allElems, *renderUpdate.VDom)
+	var vdomElems []vdom.VDomElem
+	for idx, reUpdate := range beUpdate.RenderUpdates {
+		if reUpdate.VDom == nil {
+			continue
 		}
+		vdomElems = append(vdomElems, *reUpdate.VDom)
+		beUpdate.RenderUpdates[idx].VDomWaveId = reUpdate.VDom.WaveId
+		beUpdate.RenderUpdates[idx].VDom = nil
 	}
-	transferElems := ConvertElemsToTransferElems(allElems)
-	beUpdate.TransferElems = DedupTransferElems(transferElems)
-	for i := range beUpdate.RenderUpdates {
-		beUpdate.RenderUpdates[i].VDom = nil
-	}
+	transferElems := ConvertElemsToTransferElems(vdomElems)
+	transferElems = DedupTransferElems(transferElems)
+	beUpdate.TransferElems = transferElems
 }
 
 func ConvertElemsToTransferElems(elems []vdom.VDomElem) []VDomTransferElem {

From db9cfb1ed509275a026a2186b557b0ab92da6a8a Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 14:58:12 -0700
Subject: [PATCH 021/134] add Title AppOpt

---
 tsunami/app/tsunamiapp.go                    | 2 ++
 tsunami/demo/todo/main-todo.go               | 3 ++-
 tsunami/frontend/index.html                  | 2 +-
 tsunami/frontend/src/model/tsunami-model.tsx | 3 +++
 tsunami/frontend/src/types/vdom.d.ts         | 1 +
 tsunami/rpctypes/types.go                    | 7 ++++---
 6 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 5ced66abde..44de35a11f 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -38,6 +38,7 @@ type AppOpts struct {
 	GlobalKeyboardEvents bool
 	GlobalStyles         []byte
 	RootComponentName    string // defaults to "App"
+	Title                string
 }
 
 type Client struct {
@@ -116,6 +117,7 @@ func MakeClient(appOpts AppOpts) *Client {
 		Opts: rpctypes.VDomBackendOpts{
 			CloseOnCtrlC:         appOpts.CloseOnCtrlC,
 			GlobalKeyboardEvents: appOpts.GlobalKeyboardEvents,
+			Title:                appOpts.Title,
 		},
 	}
 	if len(appOpts.GlobalStyles) > 0 {
diff --git a/tsunami/demo/todo/main-todo.go b/tsunami/demo/todo/main-todo.go
index 17d37345a4..b15ed38c05 100644
--- a/tsunami/demo/todo/main-todo.go
+++ b/tsunami/demo/todo/main-todo.go
@@ -16,6 +16,7 @@ var styleCSS []byte
 var AppClient = app.MakeClient(app.AppOpts{
 	CloseOnCtrlC: true,
 	GlobalStyles: styleCSS,
+	Title:        "Todo App (Tsunami Demo)",
 })
 
 // Basic domain types with json tags for props
@@ -45,7 +46,7 @@ type InputFieldProps struct {
 }
 
 // Reusable input component showing keyboard event handling
-var InputField = app.DefineComponent[InputFieldProps](AppClient, "InputField",
+var InputField = app.DefineComponent(AppClient, "InputField",
 	func(ctx context.Context, props InputFieldProps) any {
 		// Example of special key handling with VDomFunc
 		keyDown := &vdom.VDomFunc{
diff --git a/tsunami/frontend/index.html b/tsunami/frontend/index.html
index cd14fa1d91..95f7db0085 100644
--- a/tsunami/frontend/index.html
+++ b/tsunami/frontend/index.html
@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Tsunami Frontend</title>
+    <title>Tsunami App</title>
   </head>
   <body>
     <div id="root"></div>
diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
index 76cd5cb95c..10782eb447 100644
--- a/tsunami/frontend/src/model/tsunami-model.tsx
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -540,6 +540,9 @@ export class TsunamiModel {
         const vdomRoot = getDefaultStore().get(this.vdomRoot);
         if (update.opts != null) {
             this.backendOpts = update.opts;
+            if (update.opts.title && update.opts.title.trim() !== "") {
+                document.title = update.opts.title;
+            }
         }
         makeVDomIdMap(vdomRoot, idMap);
         this.handleRenderUpdates(update, idMap);
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
index bfd45a3da5..b2fe97918b 100644
--- a/tsunami/frontend/src/types/vdom.d.ts
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -13,6 +13,7 @@ type VDomBackendOpts = {
     closeonctrlc?: boolean;
     globalkeyboardevents?: boolean;
     globalstyles?: boolean;
+    title?: string;
 };
 
 // vdom.VDomBackendUpdate
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
index 0b3ee35395..0da48e4409 100644
--- a/tsunami/rpctypes/types.go
+++ b/tsunami/rpctypes/types.go
@@ -167,9 +167,10 @@ type VDomRefUpdate struct {
 }
 
 type VDomBackendOpts struct {
-	CloseOnCtrlC         bool `json:"closeonctrlc,omitempty"`
-	GlobalKeyboardEvents bool `json:"globalkeyboardevents,omitempty"`
-	GlobalStyles         bool `json:"globalstyles,omitempty"`
+	CloseOnCtrlC         bool   `json:"closeonctrlc,omitempty"`
+	GlobalKeyboardEvents bool   `json:"globalkeyboardevents,omitempty"`
+	GlobalStyles         bool   `json:"globalstyles,omitempty"`
+	Title                string `json:"title,omitempty"`
 }
 
 type VDomRenderUpdate struct {

From 89635edc300b6dce9758ebbbeb29556cdfeb9e80 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 16:50:44 -0700
Subject: [PATCH 022/134] work on tailwind, pass renderopts through render
 funcs... add UseResync hook

---
 tsunami/app/tsunamiapp.go      |  10 +-
 tsunami/comp/root_test.go      |   6 +-
 tsunami/comp/rootelem.go       |  32 ++--
 tsunami/comp/vdomcontext.go    |  13 +-
 tsunami/demo/todo/main-todo.go |  28 ++--
 tsunami/demo/todo/tw.css       | 267 +++++++++++++++++++++++++++++++++
 tsunami/frontend/package.json  |   1 +
 tsunami/vdom/vdom.go           |   8 +
 tsunami/vdom/vdom_context.go   |   1 +
 yarn.lock                      | 164 +++++++++++++++++++-
 10 files changed, 493 insertions(+), 37 deletions(-)
 create mode 100644 tsunami/demo/todo/tw.css

diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 44de35a11f..1b0a65f131 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -34,11 +34,11 @@ type SSEvent struct {
 }
 
 type AppOpts struct {
+	Title                string // window title
 	CloseOnCtrlC         bool
 	GlobalKeyboardEvents bool
 	GlobalStyles         []byte
 	RootComponentName    string // defaults to "App"
-	Title                string
 }
 
 type Client struct {
@@ -257,8 +257,9 @@ func (c *Client) RegisterComponent(name string, cfunc any) error {
 }
 
 func (c *Client) fullRender() (*rpctypes.VDomBackendUpdate, error) {
-	c.Root.RunWork()
-	c.Root.Render(c.RootElem)
+	opts := &comp.RenderOpts{Resync: true}
+	c.Root.RunWork(opts)
+	c.Root.Render(c.RootElem, opts)
 	renderedVDom := c.Root.MakeVDom()
 	if renderedVDom == nil {
 		renderedVDom = makeNullVDom()
@@ -277,7 +278,8 @@ func (c *Client) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 }
 
 func (c *Client) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
-	c.Root.RunWork()
+	opts := &comp.RenderOpts{Resync: false}
+	c.Root.RunWork(opts)
 	renderedVDom := c.Root.MakeVDom()
 	if renderedVDom == nil {
 		renderedVDom = makeNullVDom()
diff --git a/tsunami/comp/root_test.go b/tsunami/comp/root_test.go
index e7880829c3..397b1dc24b 100644
--- a/tsunami/comp/root_test.go
+++ b/tsunami/comp/root_test.go
@@ -85,14 +85,14 @@ func Test1(t *testing.T) {
 	root.SetOuterCtx(ctx)
 	root.RegisterComponent("Page", Page)
 	root.RegisterComponent("Button", Button)
-	root.Render(vdom.E("Page"))
+	root.Render(vdom.E("Page"), &RenderOpts{Resync: false})
 	if root.Root == nil {
 		t.Fatalf("root.Root is nil")
 	}
 	printVDom(root)
-	root.RunWork()
+	root.RunWork(&RenderOpts{Resync: false})
 	printVDom(root)
 	root.Event(testContext.ButtonId, "onClick", vdom.VDomEvent{EventType: "onClick"})
-	root.RunWork()
+	root.RunWork(&RenderOpts{Resync: false})
 	printVDom(root)
 }
diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index 26559ba387..6e5811f4b5 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -17,6 +17,10 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
+type RenderOpts struct {
+	Resync bool
+}
+
 type RootElem struct {
 	OuterCtx        context.Context
 	Root            *ComponentImpl
@@ -136,8 +140,8 @@ func (r *RootElem) RegisterComponent(name string, cfunc any) error {
 	return nil
 }
 
-func (r *RootElem) Render(elem *vdom.VDomElem) {
-	r.render(elem, &r.Root)
+func (r *RootElem) Render(elem *vdom.VDomElem, opts *RenderOpts) {
+	r.render(elem, &r.Root, opts)
 }
 
 func callVDomFn(fnVal any, data vdom.VDomEvent) {
@@ -177,7 +181,7 @@ func (r *RootElem) Event(id string, propName string, event vdom.VDomEvent) {
 
 // this will be called by the frontend to say the DOM has been mounted
 // it will eventually send any updated "refs" to the backend as well
-func (r *RootElem) RunWork() {
+func (r *RootElem) RunWork(opts *RenderOpts) {
 	workQueue := r.EffectWorkQueue
 	r.EffectWorkQueue = nil
 	// first, run effect cleanups
@@ -205,11 +209,11 @@ func (r *RootElem) RunWork() {
 	// now check if we need a render
 	if len(r.NeedsRenderMap) > 0 {
 		r.NeedsRenderMap = nil
-		r.render(r.Root.Elem, &r.Root)
+		r.render(r.Root.Elem, &r.Root, opts)
 	}
 }
 
-func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl) {
+func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
 	if elem == nil || elem.Tag == "" {
 		r.unmount(comp)
 		return
@@ -226,7 +230,7 @@ func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl) {
 	}
 	if vdom.IsBaseTag(elem.Tag) {
 		// simple vdom, fragment, wave element
-		r.renderSimple(elem, comp)
+		r.renderSimple(elem, comp, opts)
 		return
 	}
 	cfunc := r.CFuncs[elem.Tag]
@@ -235,7 +239,7 @@ func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl) {
 		r.renderText(text, comp)
 		return
 	}
-	r.renderComponent(cfunc, elem, comp)
+	r.renderComponent(cfunc, elem, comp, opts)
 }
 
 func (r *RootElem) unmount(comp **ComponentImpl) {
@@ -272,7 +276,7 @@ func (r *RootElem) renderText(text string, comp **ComponentImpl) {
 	}
 }
 
-func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*ComponentImpl) []*ComponentImpl {
+func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*ComponentImpl, opts *RenderOpts) []*ComponentImpl {
 	newChildren := make([]*ComponentImpl, len(elems))
 	curCM := make(map[ChildKey]*ComponentImpl)
 	usedMap := make(map[*ComponentImpl]bool)
@@ -293,7 +297,7 @@ func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*Componen
 		}
 		usedMap[curChild] = true
 		newChildren[idx] = curChild
-		r.render(&elem, &newChildren[idx])
+		r.render(&elem, &newChildren[idx], opts)
 	}
 	for _, child := range curChildren {
 		if !usedMap[child] {
@@ -303,11 +307,11 @@ func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*Componen
 	return newChildren
 }
 
-func (r *RootElem) renderSimple(elem *vdom.VDomElem, comp **ComponentImpl) {
+func (r *RootElem) renderSimple(elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
 	if (*comp).Comp != nil {
 		r.unmount(&(*comp).Comp)
 	}
-	(*comp).Children = r.renderChildren(elem.Children, (*comp).Children)
+	(*comp).Children = r.renderChildren(elem.Children, (*comp).Children, opts)
 }
 
 func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
@@ -337,7 +341,7 @@ func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
 	return rtnVal[0].Interface()
 }
 
-func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **ComponentImpl) {
+func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
 	if (*comp).Children != nil {
 		for _, child := range (*comp).Children {
 			r.unmount(&child)
@@ -349,7 +353,7 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 		props[k] = v
 	}
 	props[vdom.ChildrenPropKey] = elem.Children
-	vc := MakeContextVal(r, *comp)
+	vc := MakeContextVal(r, *comp, opts)
 	ctx := vdom.WithRenderContext(r.OuterCtx, vc)
 	renderedElem := callCFunc(cfunc, ctx, props)
 	rtnElemArr := vdom.PartToElems(renderedElem)
@@ -363,7 +367,7 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 	} else {
 		rtnElem = &vdom.VDomElem{Tag: vdom.FragmentTag, Children: rtnElemArr}
 	}
-	r.render(rtnElem, &(*comp).Comp)
+	r.render(rtnElem, &(*comp).Comp, opts)
 }
 
 func (r *RootElem) UpdateRef(updateRef rpctypes.VDomRefUpdate) {
diff --git a/tsunami/comp/vdomcontext.go b/tsunami/comp/vdomcontext.go
index 63063951db..2710ec0d37 100644
--- a/tsunami/comp/vdomcontext.go
+++ b/tsunami/comp/vdomcontext.go
@@ -9,10 +9,15 @@ type VDomContextVal struct {
 	Root    *RootElem
 	Comp    *ComponentImpl
 	HookIdx int
+	Resync  bool
 }
 
-func MakeContextVal(root *RootElem, comp *ComponentImpl) *VDomContextVal {
-	return &VDomContextVal{Root: root, Comp: comp, HookIdx: 0}
+func MakeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *VDomContextVal {
+	resync := false
+	if opts != nil {
+		resync = opts.Resync
+	}
+	return &VDomContextVal{Root: root, Comp: comp, HookIdx: 0, Resync: resync}
 }
 
 // Compile-time check to ensure VDomContextVal implements vdom.VDomContext
@@ -52,3 +57,7 @@ func (vc *VDomContextVal) GetOrderedHook() *vdom.Hook {
 	vc.HookIdx++
 	return hookVal
 }
+
+func (vc *VDomContextVal) IsResync() bool {
+	return vc.Resync
+}
diff --git a/tsunami/demo/todo/main-todo.go b/tsunami/demo/todo/main-todo.go
index b15ed38c05..4e456d0771 100644
--- a/tsunami/demo/todo/main-todo.go
+++ b/tsunami/demo/todo/main-todo.go
@@ -9,10 +9,10 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-//go:embed style.css
+//go:embed tw.css
 var styleCSS []byte
 
-// Initialize client with embedded styles and ctrl-c handling
+// Initialize client with embedded Tailwind styles and ctrl-c handling
 var AppClient = app.MakeClient(app.AppOpts{
 	CloseOnCtrlC: true,
 	GlobalStyles: styleCSS,
@@ -58,7 +58,7 @@ var InputField = app.DefineComponent(AppClient, "InputField",
 		}
 
 		return vdom.H("input", map[string]any{
-			"className":   "todo-input",
+			"className":   "flex-1 p-2 border border-border rounded",
 			"type":        "text",
 			"placeholder": "What needs to be done?",
 			"value":       props.Value,
@@ -74,19 +74,19 @@ var InputField = app.DefineComponent(AppClient, "InputField",
 var TodoItem = app.DefineComponent(AppClient, "TodoItem",
 	func(ctx context.Context, props TodoItemProps) any {
 		return vdom.H("div", map[string]any{
-			"className": vdom.Classes("todo-item", vdom.If(props.Todo.Completed, "completed")),
+			"className": vdom.Classes("flex items-center gap-2.5 p-2 border border-border rounded", vdom.If(props.Todo.Completed, "opacity-70")),
 		},
 			vdom.H("input", map[string]any{
-				"className": "todo-checkbox",
+				"className": "w-4 h-4",
 				"type":      "checkbox",
 				"checked":   props.Todo.Completed,
 				"onChange":  props.OnToggle,
 			}),
 			vdom.H("span", map[string]any{
-				"className": "todo-text",
+				"className": vdom.Classes("flex-1", vdom.If(props.Todo.Completed, "line-through")),
 			}, props.Todo.Text),
 			vdom.H("button", map[string]any{
-				"className": "todo-delete",
+				"className": "text-red-500 cursor-pointer px-2 py-1 rounded",
 				"onClick":   props.OnDelete,
 			}, "×"),
 		)
@@ -97,7 +97,7 @@ var TodoItem = app.DefineComponent(AppClient, "TodoItem",
 var TodoList = app.DefineComponent(AppClient, "TodoList",
 	func(ctx context.Context, props TodoListProps) any {
 		return vdom.H("div", map[string]any{
-			"className": "todo-list",
+			"className": "flex flex-col gap-2",
 		}, vdom.ForEach(props.Todos, func(todo Todo) any {
 			return TodoItem(TodoItemProps{
 				Todo:     todo,
@@ -155,14 +155,16 @@ var App = app.DefineComponent(AppClient, "App",
 		}
 
 		return vdom.H("div", map[string]any{
-			"className": "todo-app",
+			"className": "max-w-[500px] m-5 font-sans",
 		},
 			vdom.H("div", map[string]any{
-				"className": "todo-header",
-			}, vdom.H("h1", nil, "Todo List")),
+				"className": "mb-5",
+			}, vdom.H("h1", map[string]any{
+				"className": "text-2xl font-bold",
+			}, "Todo List")),
 
 			vdom.H("div", map[string]any{
-				"className": "todo-form",
+				"className": "flex gap-2.5 mb-5",
 			},
 				InputField(InputFieldProps{
 					Value:    inputText,
@@ -170,7 +172,7 @@ var App = app.DefineComponent(AppClient, "App",
 					OnEnter:  addTodo,
 				}),
 				vdom.H("button", map[string]any{
-					"className": "todo-button",
+					"className": "px-4 py-2 border border-border rounded cursor-pointer",
 					"onClick":   addTodo,
 				}, "Add Todo"),
 			),
diff --git a/tsunami/demo/todo/tw.css b/tsunami/demo/todo/tw.css
new file mode 100644
index 0000000000..584081e972
--- /dev/null
+++ b/tsunami/demo/todo/tw.css
@@ -0,0 +1,267 @@
+/*! tailwindcss v4.1.12 | MIT License | https://tailwindcss.com */
+@layer properties;
+@layer theme, base, components, utilities;
+@layer theme {
+  :root, :host {
+    --font-sans: "Inter", sans-serif;
+    --font-mono: "Hack", monospace;
+    --color-red-100: oklch(93.6% 0.032 17.717);
+    --color-red-500: oklch(63.7% 0.237 25.331);
+    --spacing: 0.25rem;
+    --text-2xl: 1.5rem;
+    --text-2xl--line-height: calc(2 / 1.5);
+    --font-weight-bold: 700;
+    --default-font-family: var(--font-sans);
+    --default-mono-font-family: var(--font-mono);
+    --radius: 8px;
+    --color-border: rgba(255, 255, 255, 0.16);
+  }
+}
+@layer base {
+  *, ::after, ::before, ::backdrop, ::file-selector-button {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+    border: 0 solid;
+  }
+  html, :host {
+    line-height: 1.5;
+    -webkit-text-size-adjust: 100%;
+    tab-size: 4;
+    font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");
+    font-feature-settings: var(--default-font-feature-settings, normal);
+    font-variation-settings: var(--default-font-variation-settings, normal);
+    -webkit-tap-highlight-color: transparent;
+  }
+  hr {
+    height: 0;
+    color: inherit;
+    border-top-width: 1px;
+  }
+  abbr:where([title]) {
+    -webkit-text-decoration: underline dotted;
+    text-decoration: underline dotted;
+  }
+  h1, h2, h3, h4, h5, h6 {
+    font-size: inherit;
+    font-weight: inherit;
+  }
+  a {
+    color: inherit;
+    -webkit-text-decoration: inherit;
+    text-decoration: inherit;
+  }
+  b, strong {
+    font-weight: bolder;
+  }
+  code, kbd, samp, pre {
+    font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
+    font-feature-settings: var(--default-mono-font-feature-settings, normal);
+    font-variation-settings: var(--default-mono-font-variation-settings, normal);
+    font-size: 1em;
+  }
+  small {
+    font-size: 80%;
+  }
+  sub, sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+  }
+  sub {
+    bottom: -0.25em;
+  }
+  sup {
+    top: -0.5em;
+  }
+  table {
+    text-indent: 0;
+    border-color: inherit;
+    border-collapse: collapse;
+  }
+  :-moz-focusring {
+    outline: auto;
+  }
+  progress {
+    vertical-align: baseline;
+  }
+  summary {
+    display: list-item;
+  }
+  ol, ul, menu {
+    list-style: none;
+  }
+  img, svg, video, canvas, audio, iframe, embed, object {
+    display: block;
+    vertical-align: middle;
+  }
+  img, video {
+    max-width: 100%;
+    height: auto;
+  }
+  button, input, select, optgroup, textarea, ::file-selector-button {
+    font: inherit;
+    font-feature-settings: inherit;
+    font-variation-settings: inherit;
+    letter-spacing: inherit;
+    color: inherit;
+    border-radius: 0;
+    background-color: transparent;
+    opacity: 1;
+  }
+  :where(select:is([multiple], [size])) optgroup {
+    font-weight: bolder;
+  }
+  :where(select:is([multiple], [size])) optgroup option {
+    padding-inline-start: 20px;
+  }
+  ::file-selector-button {
+    margin-inline-end: 4px;
+  }
+  ::placeholder {
+    opacity: 1;
+  }
+  @supports (not (-webkit-appearance: -apple-pay-button))  or (contain-intrinsic-size: 1px) {
+    ::placeholder {
+      color: currentcolor;
+      @supports (color: color-mix(in lab, red, red)) {
+        color: color-mix(in oklab, currentcolor 50%, transparent);
+      }
+    }
+  }
+  textarea {
+    resize: vertical;
+  }
+  ::-webkit-search-decoration {
+    -webkit-appearance: none;
+  }
+  ::-webkit-date-and-time-value {
+    min-height: 1lh;
+    text-align: inherit;
+  }
+  ::-webkit-datetime-edit {
+    display: inline-flex;
+  }
+  ::-webkit-datetime-edit-fields-wrapper {
+    padding: 0;
+  }
+  ::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field {
+    padding-block: 0;
+  }
+  ::-webkit-calendar-picker-indicator {
+    line-height: 1;
+  }
+  :-moz-ui-invalid {
+    box-shadow: none;
+  }
+  button, input:where([type="button"], [type="reset"], [type="submit"]), ::file-selector-button {
+    appearance: button;
+  }
+  ::-webkit-inner-spin-button, ::-webkit-outer-spin-button {
+    height: auto;
+  }
+  [hidden]:where(:not([hidden="until-found"])) {
+    display: none !important;
+  }
+}
+@layer utilities {
+  .m-5 {
+    margin: calc(var(--spacing) * 5);
+  }
+  .mb-5 {
+    margin-bottom: calc(var(--spacing) * 5);
+  }
+  .flex {
+    display: flex;
+  }
+  .h-4 {
+    height: calc(var(--spacing) * 4);
+  }
+  .w-4 {
+    width: calc(var(--spacing) * 4);
+  }
+  .max-w-\[500px\] {
+    max-width: 500px;
+  }
+  .flex-1 {
+    flex: 1;
+  }
+  .cursor-pointer {
+    cursor: pointer;
+  }
+  .flex-col {
+    flex-direction: column;
+  }
+  .items-center {
+    align-items: center;
+  }
+  .gap-2 {
+    gap: calc(var(--spacing) * 2);
+  }
+  .gap-2\.5 {
+    gap: calc(var(--spacing) * 2.5);
+  }
+  .rounded {
+    border-radius: var(--radius);
+  }
+  .border {
+    border-style: var(--tw-border-style);
+    border-width: 1px;
+  }
+  .border-border {
+    border-color: var(--color-border);
+  }
+  .p-2 {
+    padding: calc(var(--spacing) * 2);
+  }
+  .px-2 {
+    padding-inline: calc(var(--spacing) * 2);
+  }
+  .px-4 {
+    padding-inline: calc(var(--spacing) * 4);
+  }
+  .py-1 {
+    padding-block: calc(var(--spacing) * 1);
+  }
+  .py-2 {
+    padding-block: calc(var(--spacing) * 2);
+  }
+  .font-sans {
+    font-family: var(--font-sans);
+  }
+  .text-2xl {
+    font-size: var(--text-2xl);
+    line-height: var(--tw-leading, var(--text-2xl--line-height));
+  }
+  .font-bold {
+    --tw-font-weight: var(--font-weight-bold);
+    font-weight: var(--font-weight-bold);
+  }
+  .text-red-500 {
+    color: var(--color-red-500);
+  }
+  .line-through {
+    text-decoration-line: line-through;
+  }
+  .opacity-70 {
+    opacity: 70%;
+  }
+}
+@property --tw-border-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-font-weight {
+  syntax: "*";
+  inherits: false;
+}
+@layer properties {
+  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
+    *, ::before, ::after, ::backdrop {
+      --tw-border-style: solid;
+      --tw-font-weight: initial;
+    }
+  }
+}
diff --git a/tsunami/frontend/package.json b/tsunami/frontend/package.json
index 7ac38ddd69..98c7914245 100644
--- a/tsunami/frontend/package.json
+++ b/tsunami/frontend/package.json
@@ -25,6 +25,7 @@
         "tailwind-merge": "^3.3.1"
     },
     "devDependencies": {
+        "@tailwindcss/cli": "^4.1.12",
         "@tailwindcss/vite": "^4.0.17",
         "@types/react": "^19",
         "@types/react-dom": "^19",
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index dab9465182..8954ce307f 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -403,6 +403,14 @@ func UseRenderTs(ctx context.Context) int64 {
 	return vc.GetRenderTs()
 }
 
+func UseResync(ctx context.Context) bool {
+	vc := GetRenderContext(ctx)
+	if vc == nil {
+		panic("UseResync must be called within a component (no context)")
+	}
+	return vc.IsResync()
+}
+
 func depsEqual(deps1 []any, deps2 []any) bool {
 	if len(deps1) != len(deps2) {
 		return false
diff --git a/tsunami/vdom/vdom_context.go b/tsunami/vdom/vdom_context.go
index b693116ff0..0dbdd4a9b5 100644
--- a/tsunami/vdom/vdom_context.go
+++ b/tsunami/vdom/vdom_context.go
@@ -18,6 +18,7 @@ type VDomContext interface {
 	GetRenderTs() int64
 	GetCompWaveId() string
 	GetOrderedHook() *Hook
+	IsResync() bool
 }
 
 func WithRenderContext(ctx context.Context, vc VDomContext) context.Context {
diff --git a/yarn.lock b/yarn.lock
index af94e825f9..b98d85fb21 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4163,6 +4163,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-android-arm64@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-android-arm64@npm:2.5.1"
+  conditions: os=android & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-darwin-arm64@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-darwin-arm64@npm:2.5.0"
@@ -4170,6 +4177,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-darwin-arm64@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-darwin-arm64@npm:2.5.1"
+  conditions: os=darwin & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-darwin-x64@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-darwin-x64@npm:2.5.0"
@@ -4177,6 +4191,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-darwin-x64@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-darwin-x64@npm:2.5.1"
+  conditions: os=darwin & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-freebsd-x64@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-freebsd-x64@npm:2.5.0"
@@ -4184,6 +4205,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-freebsd-x64@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-freebsd-x64@npm:2.5.1"
+  conditions: os=freebsd & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-linux-arm-glibc@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-linux-arm-glibc@npm:2.5.0"
@@ -4191,6 +4219,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-linux-arm-glibc@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-linux-arm-glibc@npm:2.5.1"
+  conditions: os=linux & cpu=arm & libc=glibc
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-linux-arm-musl@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-linux-arm-musl@npm:2.5.0"
@@ -4198,6 +4233,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-linux-arm-musl@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-linux-arm-musl@npm:2.5.1"
+  conditions: os=linux & cpu=arm & libc=musl
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-linux-arm64-glibc@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-linux-arm64-glibc@npm:2.5.0"
@@ -4205,6 +4247,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-linux-arm64-glibc@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-linux-arm64-glibc@npm:2.5.1"
+  conditions: os=linux & cpu=arm64 & libc=glibc
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-linux-arm64-musl@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-linux-arm64-musl@npm:2.5.0"
@@ -4212,6 +4261,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-linux-arm64-musl@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-linux-arm64-musl@npm:2.5.1"
+  conditions: os=linux & cpu=arm64 & libc=musl
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-linux-x64-glibc@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-linux-x64-glibc@npm:2.5.0"
@@ -4219,6 +4275,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-linux-x64-glibc@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-linux-x64-glibc@npm:2.5.1"
+  conditions: os=linux & cpu=x64 & libc=glibc
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-linux-x64-musl@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-linux-x64-musl@npm:2.5.0"
@@ -4226,6 +4289,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-linux-x64-musl@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-linux-x64-musl@npm:2.5.1"
+  conditions: os=linux & cpu=x64 & libc=musl
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-win32-arm64@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-win32-arm64@npm:2.5.0"
@@ -4233,6 +4303,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-win32-arm64@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-win32-arm64@npm:2.5.1"
+  conditions: os=win32 & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-win32-ia32@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-win32-ia32@npm:2.5.0"
@@ -4240,6 +4317,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-win32-ia32@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-win32-ia32@npm:2.5.1"
+  conditions: os=win32 & cpu=ia32
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-win32-x64@npm:2.5.0":
   version: 2.5.0
   resolution: "@parcel/watcher-win32-x64@npm:2.5.0"
@@ -4247,6 +4331,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher-win32-x64@npm:2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher-win32-x64@npm:2.5.1"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher@npm:^2.4.1":
   version: 2.5.0
   resolution: "@parcel/watcher@npm:2.5.0"
@@ -4300,6 +4391,59 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@parcel/watcher@npm:^2.5.1":
+  version: 2.5.1
+  resolution: "@parcel/watcher@npm:2.5.1"
+  dependencies:
+    "@parcel/watcher-android-arm64": "npm:2.5.1"
+    "@parcel/watcher-darwin-arm64": "npm:2.5.1"
+    "@parcel/watcher-darwin-x64": "npm:2.5.1"
+    "@parcel/watcher-freebsd-x64": "npm:2.5.1"
+    "@parcel/watcher-linux-arm-glibc": "npm:2.5.1"
+    "@parcel/watcher-linux-arm-musl": "npm:2.5.1"
+    "@parcel/watcher-linux-arm64-glibc": "npm:2.5.1"
+    "@parcel/watcher-linux-arm64-musl": "npm:2.5.1"
+    "@parcel/watcher-linux-x64-glibc": "npm:2.5.1"
+    "@parcel/watcher-linux-x64-musl": "npm:2.5.1"
+    "@parcel/watcher-win32-arm64": "npm:2.5.1"
+    "@parcel/watcher-win32-ia32": "npm:2.5.1"
+    "@parcel/watcher-win32-x64": "npm:2.5.1"
+    detect-libc: "npm:^1.0.3"
+    is-glob: "npm:^4.0.3"
+    micromatch: "npm:^4.0.5"
+    node-addon-api: "npm:^7.0.0"
+    node-gyp: "npm:latest"
+  dependenciesMeta:
+    "@parcel/watcher-android-arm64":
+      optional: true
+    "@parcel/watcher-darwin-arm64":
+      optional: true
+    "@parcel/watcher-darwin-x64":
+      optional: true
+    "@parcel/watcher-freebsd-x64":
+      optional: true
+    "@parcel/watcher-linux-arm-glibc":
+      optional: true
+    "@parcel/watcher-linux-arm-musl":
+      optional: true
+    "@parcel/watcher-linux-arm64-glibc":
+      optional: true
+    "@parcel/watcher-linux-arm64-musl":
+      optional: true
+    "@parcel/watcher-linux-x64-glibc":
+      optional: true
+    "@parcel/watcher-linux-x64-musl":
+      optional: true
+    "@parcel/watcher-win32-arm64":
+      optional: true
+    "@parcel/watcher-win32-ia32":
+      optional: true
+    "@parcel/watcher-win32-x64":
+      optional: true
+  checksum: 10c0/8f35073d0c0b34a63d4c8d2213482f0ebc6a25de7b2cdd415d19cb929964a793cb285b68d1d50bfb732b070b3c82a2fdb4eb9c250eab709a1cd9d63345455a82
+  languageName: node
+  linkType: hard
+
 "@pkgjs/parseargs@npm:^0.11.0":
   version: 0.11.0
   resolution: "@pkgjs/parseargs@npm:0.11.0"
@@ -5586,6 +5730,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@tailwindcss/cli@npm:^4.1.12":
+  version: 4.1.12
+  resolution: "@tailwindcss/cli@npm:4.1.12"
+  dependencies:
+    "@parcel/watcher": "npm:^2.5.1"
+    "@tailwindcss/node": "npm:4.1.12"
+    "@tailwindcss/oxide": "npm:4.1.12"
+    enhanced-resolve: "npm:^5.18.3"
+    mri: "npm:^1.2.0"
+    picocolors: "npm:^1.1.1"
+    tailwindcss: "npm:4.1.12"
+  bin:
+    tailwindcss: dist/index.mjs
+  checksum: 10c0/629abde6773c630fa72e653e17e675f5ffe080d720d99124b5361e684785e43d7f72e36ee53437a0e53f91c8ea61267a793cce8fe09b3a03288083d4efc19e5d
+  languageName: node
+  linkType: hard
+
 "@tailwindcss/node@npm:4.1.12":
   version: 4.1.12
   resolution: "@tailwindcss/node@npm:4.1.12"
@@ -15865,7 +16026,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mri@npm:^1.1.0":
+"mri@npm:^1.1.0, mri@npm:^1.2.0":
   version: 1.2.0
   resolution: "mri@npm:1.2.0"
   checksum: 10c0/a3d32379c2554cf7351db6237ddc18dc9e54e4214953f3da105b97dc3babe0deb3ffe99cf409b38ea47cc29f9430561ba6b53b24ab8f9ce97a4b50409e4a50e7
@@ -21300,6 +21461,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "tsunami-frontend@workspace:tsunami/frontend"
   dependencies:
+    "@tailwindcss/cli": "npm:^4.1.12"
     "@tailwindcss/vite": "npm:^4.0.17"
     "@types/react": "npm:^19"
     "@types/react-dom": "npm:^19"

From e29e47f91e6e152846c03211b62200b55c7d036d Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 16:54:21 -0700
Subject: [PATCH 023/134] hold renderops in vdomcontextval

---
 tsunami/comp/vdomcontext.go | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/tsunami/comp/vdomcontext.go b/tsunami/comp/vdomcontext.go
index 2710ec0d37..a9594757f9 100644
--- a/tsunami/comp/vdomcontext.go
+++ b/tsunami/comp/vdomcontext.go
@@ -6,18 +6,14 @@ package comp
 import "github.com/wavetermdev/waveterm/tsunami/vdom"
 
 type VDomContextVal struct {
-	Root    *RootElem
-	Comp    *ComponentImpl
-	HookIdx int
-	Resync  bool
+	Root       *RootElem
+	Comp       *ComponentImpl
+	HookIdx    int
+	RenderOpts *RenderOpts
 }
 
 func MakeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *VDomContextVal {
-	resync := false
-	if opts != nil {
-		resync = opts.Resync
-	}
-	return &VDomContextVal{Root: root, Comp: comp, HookIdx: 0, Resync: resync}
+	return &VDomContextVal{Root: root, Comp: comp, HookIdx: 0, RenderOpts: opts}
 }
 
 // Compile-time check to ensure VDomContextVal implements vdom.VDomContext
@@ -59,5 +55,8 @@ func (vc *VDomContextVal) GetOrderedHook() *vdom.Hook {
 }
 
 func (vc *VDomContextVal) IsResync() bool {
-	return vc.Resync
+	if vc.RenderOpts == nil {
+		return false
+	}
+	return vc.RenderOpts.Resync
 }

From 0f776edd801de03c520f3790d08aa7c48dffd69e Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 20:56:44 -0700
Subject: [PATCH 024/134] deal with static files (for prod builds)

---
 Taskfile.yml                                  |   2 +-
 public/logos/wave-logo-256.png                | Bin 0 -> 9793 bytes
 tsunami/app/serverhandlers.go                 |  44 +++++++++++++++++-
 tsunami/app/tsunamiapp.go                     |  13 ++++--
 tsunami/frontend/public/fonts/hack-bold.woff2 | Bin 0 -> 108008 bytes
 .../frontend/public/fonts/hack-regular.woff2  | Bin 0 -> 106236 bytes
 .../public/fonts/inter-variable.woff2         | Bin 0 -> 345588 bytes
 tsunami/frontend/public/wave-logo-256.png     | Bin 0 -> 9793 bytes
 tsunami/frontend/src/vdom.tsx                 |   2 +-
 9 files changed, 54 insertions(+), 7 deletions(-)
 create mode 100644 public/logos/wave-logo-256.png
 create mode 100644 tsunami/frontend/public/fonts/hack-bold.woff2
 create mode 100644 tsunami/frontend/public/fonts/hack-regular.woff2
 create mode 100644 tsunami/frontend/public/fonts/inter-variable.woff2
 create mode 100644 tsunami/frontend/public/wave-logo-256.png

diff --git a/Taskfile.yml b/Taskfile.yml
index 17cad4e27e..124220e38c 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -441,7 +441,7 @@ tasks:
 
     tsunami:demo:todo:
         desc: Run the tsunami todo demo application
-        cmd: go run demo/todo/main-todo.go
+        cmd: go run demo/todo/*.go
         dir: tsunami
         env:
             TSUNAMI_LISTENADDR: "localhost:12026"
diff --git a/public/logos/wave-logo-256.png b/public/logos/wave-logo-256.png
new file mode 100644
index 0000000000000000000000000000000000000000..d360280f1df6044b709b13257bff6e7806b31882
GIT binary patch
literal 9793
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
WfZg^0S>uBPprxj#TBmFq^}hgAr7bZ4

literal 0
HcmV?d00001

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index bbc5f8a893..c77f82d1cb 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -4,10 +4,12 @@
 package app
 
 import (
+	"embed"
 	"encoding/json"
 	"fmt"
 	"io"
 	"log"
+	"mime"
 	"net/http"
 	"strings"
 	"sync"
@@ -19,6 +21,11 @@ import (
 
 const SSEKeepAliveDuration = 5 * time.Second
 
+func init() {
+	// Add explicit mapping for .json files
+	mime.AddExtensionType(".json", "application/json")
+}
+
 type HTTPHandlers struct {
 	Client     *Client
 	renderLock sync.Mutex
@@ -30,10 +37,15 @@ func NewHTTPHandlers(client *Client) *HTTPHandlers {
 	}
 }
 
-func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux) {
+func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux, embeddedFS *embed.FS) {
 	mux.HandleFunc("/api/render", h.handleRender)
 	mux.HandleFunc("/api/updates", h.handleSSE)
-	mux.HandleFunc("/assets/", h.handleAssetsUrl)
+	mux.HandleFunc("/files/", h.handleAssetsUrl)
+	
+	// Add fallback handler for embedded static files in production mode
+	if embeddedFS != nil {
+		mux.HandleFunc("/", h.handleStaticFiles(embeddedFS))
+	}
 }
 
 func (h *HTTPHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
@@ -222,3 +234,31 @@ func (h *HTTPHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 }
+
+func (h *HTTPHandlers) handleStaticFiles(embeddedFS *embed.FS) http.HandlerFunc {
+	// Create a file server from the embedded FS
+	fileServer := http.FileServer(http.FS(embeddedFS))
+	
+	return func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			panicErr := util.PanicHandler("handleStaticFiles", recover())
+			if panicErr != nil {
+				http.Error(w, fmt.Sprintf("internal server error: %v", panicErr), http.StatusInternalServerError)
+			}
+		}()
+
+		// Skip if this is an API or files request (already handled by other handlers)
+		if strings.HasPrefix(r.URL.Path, "/api/") || strings.HasPrefix(r.URL.Path, "/files/") {
+			http.NotFound(w, r)
+			return
+		}
+
+		// Handle root "/" => "/index.html"
+		if r.URL.Path == "/" {
+			r.URL.Path = "/index.html"
+		}
+
+		// Serve the file using Go's file server
+		fileServer.ServeHTTP(w, r)
+	}
+}
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 1b0a65f131..58e2e67975 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -5,6 +5,7 @@ package app
 
 import (
 	"context"
+	"embed"
 	"fmt"
 	"io"
 	"io/fs"
@@ -28,6 +29,8 @@ import (
 const TsunamiListenAddrEnvVar = "TSUNAMI_LISTENADDR"
 const DefaultListenAddr = "localhost:0"
 
+var assetsFS *embed.FS
+
 type SSEvent struct {
 	Event string
 	Data  []byte
@@ -132,7 +135,7 @@ func (c *Client) runMainE() error {
 	if c.SetupFn != nil {
 		c.SetupFn()
 	}
-	err := c.ListenAndServe(context.Background())
+	err := c.ListenAndServe(context.Background(), assetsFS)
 	if err != nil {
 		return err
 	}
@@ -152,13 +155,13 @@ func (c *Client) RunMain() {
 	}
 }
 
-func (c *Client) ListenAndServe(ctx context.Context) error {
+func (c *Client) ListenAndServe(ctx context.Context, embeddedFS *embed.FS) error {
 	// Create HTTP handlers
 	handlers := NewHTTPHandlers(c)
 
 	// Create a new ServeMux and register handlers
 	mux := http.NewServeMux()
-	handlers.RegisterHandlers(mux)
+	handlers.RegisterHandlers(mux, embeddedFS)
 
 	// Determine listen address from environment variable or use default
 	listenAddr := os.Getenv(TsunamiListenAddrEnvVar)
@@ -450,3 +453,7 @@ func (c *Client) RegisterFileHandler(path string, option FileHandlerOption) {
 		}
 	})
 }
+
+func RegisterAssetsFS(fs embed.FS) {
+	assetsFS = &fs
+}
diff --git a/tsunami/frontend/public/fonts/hack-bold.woff2 b/tsunami/frontend/public/fonts/hack-bold.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..1155477e966f2967366ee1ae3f658eef0448a51e
GIT binary patch
literal 108008
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
EKi!h~=l}o!

literal 0
HcmV?d00001

diff --git a/tsunami/frontend/public/fonts/hack-regular.woff2 b/tsunami/frontend/public/fonts/hack-regular.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..524465cf5113597c83bb73e60fff0bd64fef0644
GIT binary patch
literal 106236
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
NE|#bL1PcHF{s%4XDq#Qs

literal 0
HcmV?d00001

diff --git a/tsunami/frontend/public/fonts/inter-variable.woff2 b/tsunami/frontend/public/fonts/inter-variable.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..22a12b04e1abd959c00f9d8429ca78ddae3f7dde
GIT binary patch
literal 345588
zcmV)IK)k<qPew8T0RR911x54#6951J4KyGC1x0!Q1ONa400000000000000000000
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
z%0A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%0D?psw!DE?8^2j5joVXFOa)ua%K)@2QRe
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
UMQ*lvlk>j@mv~dN-<otg0~V>b!vFvP

literal 0
HcmV?d00001

diff --git a/tsunami/frontend/public/wave-logo-256.png b/tsunami/frontend/public/wave-logo-256.png
new file mode 100644
index 0000000000000000000000000000000000000000..d360280f1df6044b709b13257bff6e7806b31882
GIT binary patch
literal 9793
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
WfZg^0S>uBPprxj#TBmFq^}hgAr7bZ4

literal 0
HcmV?d00001

diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index 09544faf2f..c87008ab0a 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -432,7 +432,7 @@ function VDomInnerView({ model }: VDomViewProps) {
     return (
         <>
             {model.backendOpts?.globalstyles ? (
-                <WaveStyle src="/assets/global.css" model={model} onMount={handleStylesMounted} />
+                <WaveStyle src="/files/global.css" model={model} onMount={handleStylesMounted} />
             ) : null}
             {styleMounted ? <VDomRoot model={model} /> : null}
         </>

From 7bdad4b3e51838f7a262f484c17d774be989ee6b Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 21:05:14 -0700
Subject: [PATCH 025/134] add static handlers as well...

---
 tsunami/app/serverhandlers.go | 38 ++++++++++++++++++++++++++++++-----
 tsunami/app/tsunamiapp.go     | 11 +++++++---
 2 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index c77f82d1cb..922649fa8e 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -37,14 +37,19 @@ func NewHTTPHandlers(client *Client) *HTTPHandlers {
 	}
 }
 
-func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux, embeddedFS *embed.FS) {
+func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux, assetsFS *embed.FS, staticFS *embed.FS) {
 	mux.HandleFunc("/api/render", h.handleRender)
 	mux.HandleFunc("/api/updates", h.handleSSE)
 	mux.HandleFunc("/files/", h.handleAssetsUrl)
-	
+
+	// Add handler for static files at /static/ path
+	if staticFS != nil {
+		mux.HandleFunc("/static/", h.handleStaticPathFiles(staticFS))
+	}
+
 	// Add fallback handler for embedded static files in production mode
-	if embeddedFS != nil {
-		mux.HandleFunc("/", h.handleStaticFiles(embeddedFS))
+	if assetsFS != nil {
+		mux.HandleFunc("/", h.handleStaticFiles(assetsFS))
 	}
 }
 
@@ -238,7 +243,7 @@ func (h *HTTPHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 func (h *HTTPHandlers) handleStaticFiles(embeddedFS *embed.FS) http.HandlerFunc {
 	// Create a file server from the embedded FS
 	fileServer := http.FileServer(http.FS(embeddedFS))
-	
+
 	return func(w http.ResponseWriter, r *http.Request) {
 		defer func() {
 			panicErr := util.PanicHandler("handleStaticFiles", recover())
@@ -262,3 +267,26 @@ func (h *HTTPHandlers) handleStaticFiles(embeddedFS *embed.FS) http.HandlerFunc
 		fileServer.ServeHTTP(w, r)
 	}
 }
+
+func (h *HTTPHandlers) handleStaticPathFiles(staticFS *embed.FS) http.HandlerFunc {
+	// Create a file server from the embedded FS
+	fileServer := http.FileServer(http.FS(staticFS))
+
+	return func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			panicErr := util.PanicHandler("handleStaticPathFiles", recover())
+			if panicErr != nil {
+				http.Error(w, fmt.Sprintf("internal server error: %v", panicErr), http.StatusInternalServerError)
+			}
+		}()
+
+		// Strip /static/ prefix from the path
+		r.URL.Path = strings.TrimPrefix(r.URL.Path, "/static")
+		if r.URL.Path == "" {
+			r.URL.Path = "/"
+		}
+
+		// Serve the file using Go's file server
+		fileServer.ServeHTTP(w, r)
+	}
+}
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 58e2e67975..e3b9c0e8ed 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -30,6 +30,7 @@ const TsunamiListenAddrEnvVar = "TSUNAMI_LISTENADDR"
 const DefaultListenAddr = "localhost:0"
 
 var assetsFS *embed.FS
+var staticFS *embed.FS
 
 type SSEvent struct {
 	Event string
@@ -135,7 +136,7 @@ func (c *Client) runMainE() error {
 	if c.SetupFn != nil {
 		c.SetupFn()
 	}
-	err := c.ListenAndServe(context.Background(), assetsFS)
+	err := c.ListenAndServe(context.Background())
 	if err != nil {
 		return err
 	}
@@ -155,13 +156,13 @@ func (c *Client) RunMain() {
 	}
 }
 
-func (c *Client) ListenAndServe(ctx context.Context, embeddedFS *embed.FS) error {
+func (c *Client) ListenAndServe(ctx context.Context) error {
 	// Create HTTP handlers
 	handlers := NewHTTPHandlers(c)
 
 	// Create a new ServeMux and register handlers
 	mux := http.NewServeMux()
-	handlers.RegisterHandlers(mux, embeddedFS)
+	handlers.RegisterHandlers(mux, assetsFS, staticFS)
 
 	// Determine listen address from environment variable or use default
 	listenAddr := os.Getenv(TsunamiListenAddrEnvVar)
@@ -457,3 +458,7 @@ func (c *Client) RegisterFileHandler(path string, option FileHandlerOption) {
 func RegisterAssetsFS(fs embed.FS) {
 	assetsFS = &fs
 }
+
+func RegisterStaticFS(fs embed.FS) {
+	staticFS = &fs
+}

From 45f94c361210b401656d5ac3c401f4e9be20dff8 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 21:49:03 -0700
Subject: [PATCH 026/134] useState and useAtom both now return 3 values....

---
 tsunami/demo/todo/main-todo.go |  6 +++---
 tsunami/vdom/vdom.go           | 31 +++++++++----------------------
 2 files changed, 12 insertions(+), 25 deletions(-)

diff --git a/tsunami/demo/todo/main-todo.go b/tsunami/demo/todo/main-todo.go
index 4e456d0771..04a87464b3 100644
--- a/tsunami/demo/todo/main-todo.go
+++ b/tsunami/demo/todo/main-todo.go
@@ -112,12 +112,12 @@ var TodoList = app.DefineComponent(AppClient, "TodoList",
 var App = app.DefineComponent(AppClient, "App",
 	func(ctx context.Context, _ any) any {
 		// Multiple state hooks example
-		todos, setTodos := vdom.UseState(ctx, []Todo{
+		todos, setTodos, _ := vdom.UseState(ctx, []Todo{
 			{Id: 1, Text: "Learn VDOM", Completed: false},
 			{Id: 2, Text: "Build a todo app", Completed: false},
 		})
-		nextId, setNextId := vdom.UseState(ctx, 3)
-		inputText, setInputText := vdom.UseState(ctx, "")
+		nextId, setNextId, _ := vdom.UseState(ctx, 3)
+		inputText, setInputText, _ := vdom.UseState(ctx, "")
 
 		// Event handlers modifying multiple pieces of state
 		addTodo := func() {
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index 8954ce307f..c218a1f90a 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -287,26 +287,7 @@ func P(propName string, propVal any) any {
 	return map[string]any{propName: propVal}
 }
 
-func UseState[T any](ctx context.Context, initialVal T) (T, func(T)) {
-	vc := GetRenderContext(ctx)
-	hookVal := vc.GetOrderedHook()
-	if !hookVal.Init {
-		hookVal.Init = true
-		hookVal.Val = initialVal
-	}
-	var rtnVal T
-	rtnVal, ok := hookVal.Val.(T)
-	if !ok {
-		panic("UseState hook value is not a state (possible out of order or conditional hooks)")
-	}
-	setVal := func(newVal T) {
-		hookVal.Val = newVal
-		vc.AddRenderWork(vc.GetCompWaveId())
-	}
-	return rtnVal, setVal
-}
-
-func UseStateWithFn[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T)) {
+func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T)) {
 	vc := GetRenderContext(ctx)
 	hookVal := vc.GetOrderedHook()
 	if !hookVal.Init {
@@ -332,7 +313,7 @@ func UseStateWithFn[T any](ctx context.Context, initialVal T) (T, func(T), func(
 	return rtnVal, setVal, setFuncVal
 }
 
-func UseAtom[T any](ctx context.Context, atomName string) (T, func(T)) {
+func UseSharedAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
 	vc := GetRenderContext(ctx)
 	hookVal := vc.GetOrderedHook()
 	if !hookVal.Init {
@@ -355,7 +336,13 @@ func UseAtom[T any](ctx context.Context, atomName string) (T, func(T)) {
 			vc.AddRenderWork(waveId)
 		}
 	}
-	return atomVal, setVal
+	setFuncVal := func(updateFunc func(T) T) {
+		atom.Val = updateFunc(atom.Val.(T))
+		for waveId := range atom.UsedBy {
+			vc.AddRenderWork(waveId)
+		}
+	}
+	return atomVal, setVal, setFuncVal
 }
 
 func UseVDomRef(ctx context.Context) *VDomRef {

From 4b9154e473b13b5e8842aa700bebd8e231449d3c Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 22:22:22 -0700
Subject: [PATCH 027/134] 3 types of atoms... $shared, $config, and $data...

---
 tsunami/frontend/src/vdom.tsx | 17 +++++++++--------
 tsunami/vdom/vdom.go          | 14 +++++++++++++-
 tsunami/vdom/vdom_html.go     | 25 ++++++++++++++++++++++++-
 3 files changed, 46 insertions(+), 10 deletions(-)

diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index c87008ab0a..455f485070 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -185,19 +185,20 @@ function resolveBinding(binding: VDomBinding, model: TsunamiModel): [any, string
     if (bindName == null || bindName == "") {
         return [null, []];
     }
-    // for now we only recognize $.[atomname] bindings
-    if (!bindName.startsWith("$.")) {
+    // validate that bindName starts with valid atom prefix and has at least one char after the dot
+    const isValidBinding = (bindName.startsWith("$shared.") && bindName.length > 8) ||
+                          (bindName.startsWith("$config.") && bindName.length > 8) ||
+                          (bindName.startsWith("$data.") && bindName.length > 6);
+    
+    if (!isValidBinding) {
         return [null, []];
     }
-    const atomName = bindName.substring(2);
-    if (atomName == "") {
-        return [null, []];
-    }
-    const atom = model.getAtomContainer(atomName);
+    
+    const atom = model.getAtomContainer(bindName);
     if (atom == null) {
         return [null, []];
     }
-    return [atom.val, [atomName]];
+    return [atom.val, [bindName]];
 }
 
 type GenericPropsType = { [key: string]: any };
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index c218a1f90a..a95315ebd0 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -313,7 +313,7 @@ func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T
 	return rtnVal, setVal, setFuncVal
 }
 
-func UseSharedAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
+func useAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
 	vc := GetRenderContext(ctx)
 	hookVal := vc.GetOrderedHook()
 	if !hookVal.Init {
@@ -345,6 +345,18 @@ func UseSharedAtom[T any](ctx context.Context, atomName string) (T, func(T), fun
 	return atomVal, setVal, setFuncVal
 }
 
+func UseSharedAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
+	return useAtom[T](ctx, "$shared."+atomName)
+}
+
+func UseConfig[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
+	return useAtom[T](ctx, "$config."+atomName)
+}
+
+func UseData[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
+	return useAtom[T](ctx, "$data."+atomName)
+}
+
 func UseVDomRef(ctx context.Context) *VDomRef {
 	vc := GetRenderContext(ctx)
 	hookVal := vc.GetOrderedHook()
diff --git a/tsunami/vdom/vdom_html.go b/tsunami/vdom/vdom_html.go
index b167d4d0f4..08a38649a2 100644
--- a/tsunami/vdom/vdom_html.go
+++ b/tsunami/vdom/vdom_html.go
@@ -84,6 +84,23 @@ func getAttrString(token htmltoken.Token, key string) string {
 	return ""
 }
 
+func isValidBindingKey(bindKey string) bool {
+	if bindKey == "" {
+		return false
+	}
+	// validate that bindKey starts with valid atom prefix and has at least one char after the dot
+	if strings.HasPrefix(bindKey, "$shared.") && len(bindKey) > 8 {
+		return true
+	}
+	if strings.HasPrefix(bindKey, "$config.") && len(bindKey) > 8 {
+		return true
+	}
+	if strings.HasPrefix(bindKey, "$data.") && len(bindKey) > 6 {
+		return true
+	}
+	return false
+}
+
 func attrToProp(attrVal string, isJson bool, params map[string]any) any {
 	if isJson {
 		var val any
@@ -108,7 +125,7 @@ func attrToProp(attrVal string, isJson bool, params map[string]any) any {
 	}
 	if strings.HasPrefix(attrVal, Html_BindPrefix) {
 		bindKey := attrVal[len(Html_BindPrefix):]
-		if bindKey == "" {
+		if bindKey == "" || !isValidBindingKey(bindKey) {
 			return nil
 		}
 		return &VDomBinding{Type: ObjectType_Binding, Bind: bindKey}
@@ -364,6 +381,12 @@ outer:
 			}
 			if token.Data == Html_BindTagName {
 				keyAttr := getAttrString(token, "key")
+				if !isValidBindingKey(keyAttr) {
+					errText := fmt.Sprintf("invalid binding key: %q (must start with $shared., $config., or $data.)", keyAttr)
+					errTextElem := TextElem(errText)
+					appendChildToStack(elemStack, &errTextElem)
+					continue
+				}
 				binding := &VDomBinding{Type: ObjectType_Binding, Bind: keyAttr}
 				appendChildToStack(elemStack, &VDomElem{Tag: WaveTextTag, Props: map[string]any{"text": binding}})
 				continue

From e2909248bb3b72b76c4de939e0085b5a2d1c1028 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 22:49:49 -0700
Subject: [PATCH 028/134] synchronize atoms, implement GET /api/data

---
 tsunami/app/serverhandlers.go | 23 ++++++++++++++
 tsunami/comp/root_test.go     |  4 +--
 tsunami/comp/rootelem.go      | 60 +++++++++++++++++++++++++++++++++--
 tsunami/comp/vdomcontext.go   | 16 ++++++++--
 tsunami/vdom/vdom.go          | 24 +++++++-------
 tsunami/vdom/vdom_context.go  |  5 ++-
 6 files changed, 111 insertions(+), 21 deletions(-)

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index 922649fa8e..330b98e4aa 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -40,6 +40,7 @@ func NewHTTPHandlers(client *Client) *HTTPHandlers {
 func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux, assetsFS *embed.FS, staticFS *embed.FS) {
 	mux.HandleFunc("/api/render", h.handleRender)
 	mux.HandleFunc("/api/updates", h.handleSSE)
+	mux.HandleFunc("/api/data", h.handleData)
 	mux.HandleFunc("/files/", h.handleAssetsUrl)
 
 	// Add handler for static files at /static/ path
@@ -155,6 +156,28 @@ func (h *HTTPHandlers) processFrontendUpdate(feUpdate *rpctypes.VDomFrontendUpda
 	return update, nil
 }
 
+func (h *HTTPHandlers) handleData(w http.ResponseWriter, r *http.Request) {
+	defer func() {
+		panicErr := util.PanicHandler("handleData", recover())
+		if panicErr != nil {
+			http.Error(w, fmt.Sprintf("internal server error: %v", panicErr), http.StatusInternalServerError)
+		}
+	}()
+
+	if r.Method != http.MethodGet {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	result := h.Client.Root.GetDataMap()
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		log.Printf("failed to encode data response: %v", err)
+		http.Error(w, "failed to encode response", http.StatusInternalServerError)
+	}
+}
+
 func (h *HTTPHandlers) handleAssetsUrl(w http.ResponseWriter, r *http.Request) {
 	defer func() {
 		panicErr := util.PanicHandler("handleAssetsUrl", recover())
diff --git a/tsunami/comp/root_test.go b/tsunami/comp/root_test.go
index 397b1dc24b..346b30b58f 100644
--- a/tsunami/comp/root_test.go
+++ b/tsunami/comp/root_test.go
@@ -22,7 +22,7 @@ type TestContext struct {
 }
 
 func Page(ctx context.Context, props map[string]any) any {
-	clicked, setClicked := vdom.UseState(ctx, false)
+	clicked, setClicked, _ := vdom.UseState(ctx, false)
 	var clickedDiv *vdom.VDomElem
 	if clicked {
 		clickedDiv = vdom.Bind(`<div>clicked</div>`, nil)
@@ -45,7 +45,7 @@ func Page(ctx context.Context, props map[string]any) any {
 
 func Button(ctx context.Context, props map[string]any) any {
 	ref := vdom.UseVDomRef(ctx)
-	clName, setClName := vdom.UseState(ctx, "button")
+	clName, setClName, _ := vdom.UseState(ctx, "button")
 	vdom.UseEffect(ctx, func() func() {
 		fmt.Printf("Button useEffect\n")
 		setClName("button mounted")
diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index 6e5811f4b5..2fe8037c76 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -10,6 +10,7 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
+	"sync"
 
 	"github.com/google/uuid"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
@@ -30,6 +31,7 @@ type RootElem struct {
 	EffectWorkQueue []*vdom.EffectWorkElem
 	NeedsRenderMap  map[string]bool
 	Atoms           map[string]*vdom.Atom
+	atomLock        sync.Mutex
 	RefOperations   []rpctypes.VDomRefOperation
 }
 
@@ -44,6 +46,20 @@ func (r *RootElem) AddEffectWork(id string, effectIndex int) {
 	r.EffectWorkQueue = append(r.EffectWorkQueue, &vdom.EffectWorkElem{Id: id, EffectIndex: effectIndex})
 }
 
+func (r *RootElem) GetDataMap() map[string]any {
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+
+	result := make(map[string]any)
+	for atomName, atom := range r.Atoms {
+		if strings.HasPrefix(atomName, "$data.") {
+			strippedName := strings.TrimPrefix(atomName, "$data.")
+			result[strippedName] = atom.Val
+		}
+	}
+	return result
+}
+
 func MakeRoot() *RootElem {
 	return &RootElem{
 		Root:    nil,
@@ -53,7 +69,7 @@ func MakeRoot() *RootElem {
 	}
 }
 
-func (r *RootElem) GetAtom(name string) *vdom.Atom {
+func (r *RootElem) ensureAtomNoLock(name string) *vdom.Atom {
 	atom, ok := r.Atoms[name]
 	if !ok {
 		atom = &vdom.Atom{UsedBy: make(map[string]bool)}
@@ -62,12 +78,47 @@ func (r *RootElem) GetAtom(name string) *vdom.Atom {
 	return atom
 }
 
+
+func (r *RootElem) AtomSetUsedBy(atomName string, waveId string, used bool) {
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+	
+	atom := r.ensureAtomNoLock(atomName)
+	if used {
+		atom.UsedBy[waveId] = true
+	} else {
+		delete(atom.UsedBy, waveId)
+	}
+}
+
+func (r *RootElem) AtomAddRenderWork(atomName string) {
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+	
+	atom, ok := r.Atoms[atomName]
+	if !ok {
+		return
+	}
+	for compId := range atom.UsedBy {
+		r.AddRenderWork(compId)
+	}
+}
+
 func (r *RootElem) GetAtomVal(name string) any {
-	atom := r.GetAtom(name)
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+
+	atom, ok := r.Atoms[name]
+	if !ok {
+		return nil
+	}
 	return atom.Val
 }
 
 func (r *RootElem) GetStateSync(full bool) []rpctypes.VDomStateSync {
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+
 	stateSync := make([]rpctypes.VDomStateSync, 0)
 	for atomName, atom := range r.Atoms {
 		if atom.Dirty || full {
@@ -79,7 +130,10 @@ func (r *RootElem) GetStateSync(full bool) []rpctypes.VDomStateSync {
 }
 
 func (r *RootElem) SetAtomVal(name string, val any, markDirty bool) {
-	atom := r.GetAtom(name)
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+
+	atom := r.ensureAtomNoLock(name)
 	if !markDirty {
 		atom.Val = val
 		return
diff --git a/tsunami/comp/vdomcontext.go b/tsunami/comp/vdomcontext.go
index a9594757f9..59d09bb857 100644
--- a/tsunami/comp/vdomcontext.go
+++ b/tsunami/comp/vdomcontext.go
@@ -27,8 +27,20 @@ func (vc *VDomContextVal) AddEffectWork(id string, effectIndex int) {
 	vc.Root.AddEffectWork(id, effectIndex)
 }
 
-func (vc *VDomContextVal) GetAtom(atomName string) *vdom.Atom {
-	return vc.Root.GetAtom(atomName)
+func (vc *VDomContextVal) AtomSetUsedBy(atomName string, waveId string, used bool) {
+	vc.Root.AtomSetUsedBy(atomName, waveId, used)
+}
+
+func (vc *VDomContextVal) AtomAddRenderWork(atomName string) {
+	vc.Root.AtomAddRenderWork(atomName)
+}
+
+func (vc *VDomContextVal) GetAtomVal(atomName string) any {
+	return vc.Root.GetAtomVal(atomName)
+}
+
+func (vc *VDomContextVal) SetAtomVal(atomName string, val any, markDirty bool) {
+	vc.Root.SetAtomVal(atomName, val, markDirty)
 }
 
 func (vc *VDomContextVal) GetRenderTs() int64 {
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index a95315ebd0..ed7977ff1d 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -320,27 +320,25 @@ func useAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func
 		hookVal.Init = true
 		closedWaveId := vc.GetCompWaveId()
 		hookVal.UnmountFn = func() {
-			atom := vc.GetAtom(atomName)
-			delete(atom.UsedBy, closedWaveId)
+			vc.AtomSetUsedBy(atomName, closedWaveId, false)
 		}
 	}
-	atom := vc.GetAtom(atomName)
-	atom.UsedBy[vc.GetCompWaveId()] = true
-	atomVal, ok := atom.Val.(T)
+	vc.AtomSetUsedBy(atomName, vc.GetCompWaveId(), true)
+	atomVal, ok := vc.GetAtomVal(atomName).(T)
 	if !ok {
-		panic(fmt.Sprintf("UseAtom %q value type mismatch (expected %T, got %T)", atomName, atomVal, atom.Val))
+		panic(fmt.Sprintf("UseAtom %q value type mismatch (expected %T, got %T)", atomName, atomVal, vc.GetAtomVal(atomName)))
 	}
 	setVal := func(newVal T) {
-		atom.Val = newVal
-		for waveId := range atom.UsedBy {
-			vc.AddRenderWork(waveId)
-		}
+		vc.SetAtomVal(atomName, newVal, true)
+		vc.AtomAddRenderWork(atomName)
 	}
 	setFuncVal := func(updateFunc func(T) T) {
-		atom.Val = updateFunc(atom.Val.(T))
-		for waveId := range atom.UsedBy {
-			vc.AddRenderWork(waveId)
+		currentVal, ok := vc.GetAtomVal(atomName).(T)
+		if !ok {
+			panic(fmt.Sprintf("UseAtom %q value type mismatch in setFuncVal", atomName))
 		}
+		vc.SetAtomVal(atomName, updateFunc(currentVal), true)
+		vc.AtomAddRenderWork(atomName)
 	}
 	return atomVal, setVal, setFuncVal
 }
diff --git a/tsunami/vdom/vdom_context.go b/tsunami/vdom/vdom_context.go
index 0dbdd4a9b5..bebecfdb0b 100644
--- a/tsunami/vdom/vdom_context.go
+++ b/tsunami/vdom/vdom_context.go
@@ -14,7 +14,10 @@ var vdomContextKey = vdomContextKeyType{}
 type VDomContext interface {
 	AddRenderWork(id string)
 	AddEffectWork(id string, effectIndex int)
-	GetAtom(atomName string) *Atom
+	AtomSetUsedBy(atomName string, waveId string, used bool)
+	AtomAddRenderWork(atomName string)
+	GetAtomVal(atomName string) any
+	SetAtomVal(atomName string, val any, markDirty bool)
 	GetRenderTs() int64
 	GetCompWaveId() string
 	GetOrderedHook() *Hook

From be395861021c11474ada257d3039371ce4f89f70 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 23:16:59 -0700
Subject: [PATCH 029/134] implement /api/config and /api/data

---
 tsunami/app/serverhandlers.go | 50 +++++++++++++++++++++++++++++++++++
 tsunami/comp/rootelem.go      | 14 ++++++++++
 2 files changed, 64 insertions(+)

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index 330b98e4aa..2b233eba47 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -41,6 +41,7 @@ func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux, assetsFS *embed.FS,
 	mux.HandleFunc("/api/render", h.handleRender)
 	mux.HandleFunc("/api/updates", h.handleSSE)
 	mux.HandleFunc("/api/data", h.handleData)
+	mux.HandleFunc("/api/config", h.handleConfig)
 	mux.HandleFunc("/files/", h.handleAssetsUrl)
 
 	// Add handler for static files at /static/ path
@@ -178,6 +179,55 @@ func (h *HTTPHandlers) handleData(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func (h *HTTPHandlers) handleConfig(w http.ResponseWriter, r *http.Request) {
+	defer func() {
+		panicErr := util.PanicHandler("handleConfig", recover())
+		if panicErr != nil {
+			http.Error(w, fmt.Sprintf("internal server error: %v", panicErr), http.StatusInternalServerError)
+		}
+	}()
+
+	switch r.Method {
+	case http.MethodGet:
+		h.handleConfigGet(w, r)
+	case http.MethodPost:
+		h.handleConfigPost(w, r)
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func (h *HTTPHandlers) handleConfigGet(w http.ResponseWriter, r *http.Request) {
+	result := h.Client.Root.GetConfigMap()
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		log.Printf("failed to encode config response: %v", err)
+		http.Error(w, "failed to encode response", http.StatusInternalServerError)
+	}
+}
+
+func (h *HTTPHandlers) handleConfigPost(w http.ResponseWriter, r *http.Request) {
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("failed to read request body: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	var configData map[string]any
+	if err := json.Unmarshal(body, &configData); err != nil {
+		http.Error(w, fmt.Sprintf("failed to parse JSON: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	for key, value := range configData {
+		atomName := "$config." + key
+		h.Client.Root.SetAtomVal(atomName, value, true)
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
 func (h *HTTPHandlers) handleAssetsUrl(w http.ResponseWriter, r *http.Request) {
 	defer func() {
 		panicErr := util.PanicHandler("handleAssetsUrl", recover())
diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index 2fe8037c76..0ab5197833 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -60,6 +60,20 @@ func (r *RootElem) GetDataMap() map[string]any {
 	return result
 }
 
+func (r *RootElem) GetConfigMap() map[string]any {
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+	
+	result := make(map[string]any)
+	for atomName, atom := range r.Atoms {
+		if strings.HasPrefix(atomName, "$config.") {
+			strippedName := strings.TrimPrefix(atomName, "$config.")
+			result[strippedName] = atom.Val
+		}
+	}
+	return result
+}
+
 func MakeRoot() *RootElem {
 	return &RootElem{
 		Root:    nil,

From 12318a4bc89b8df46798f0d6cc9dbc7d403264e4 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 1 Sep 2025 23:41:05 -0700
Subject: [PATCH 030/134]  make some methods private, and implement a
 SetAppOpts method

---
 tsunami/app/serverhandlers.go | 12 +++----
 tsunami/app/tsunamiapp.go     | 66 +++++++++++++++++++----------------
 2 files changed, 40 insertions(+), 38 deletions(-)

diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index 2b233eba47..e8ddbe0897 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -81,10 +81,10 @@ func (h *HTTPHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if feUpdate.ForceTakeover {
-		h.Client.ClientTakeover(feUpdate.ClientId)
+		h.Client.clientTakeover(feUpdate.ClientId)
 	}
 
-	if err := h.Client.CheckClientId(feUpdate.ClientId); err != nil {
+	if err := h.Client.checkClientId(feUpdate.ClientId); err != nil {
 		http.Error(w, fmt.Sprintf("client id error: %v", err), http.StatusBadRequest)
 		return
 	}
@@ -197,7 +197,7 @@ func (h *HTTPHandlers) handleConfig(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (h *HTTPHandlers) handleConfigGet(w http.ResponseWriter, r *http.Request) {
+func (h *HTTPHandlers) handleConfigGet(w http.ResponseWriter, _ *http.Request) {
 	result := h.Client.Root.GetConfigMap()
 
 	w.Header().Set("Content-Type", "application/json")
@@ -246,10 +246,6 @@ func (h *HTTPHandlers) handleAssetsUrl(w http.ResponseWriter, r *http.Request) {
 		ServeFileOption(w, r, *h.Client.GlobalStylesOption)
 		return
 	}
-	if h.Client.OverrideUrlHandler != nil {
-		h.Client.OverrideUrlHandler.ServeHTTP(w, r)
-		return
-	}
 	h.Client.UrlHandlerMux.ServeHTTP(w, r)
 }
 
@@ -267,7 +263,7 @@ func (h *HTTPHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 	}
 
 	clientId := r.URL.Query().Get("clientId")
-	if err := h.Client.CheckClientId(clientId); err != nil {
+	if err := h.Client.checkClientId(clientId); err != nil {
 		http.Error(w, fmt.Sprintf("client id error: %v", err), http.StatusBadRequest)
 		return
 	}
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index e3b9c0e8ed..1113e09b68 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -59,17 +59,28 @@ type Client struct {
 	GlobalEventHandler func(client *Client, event vdom.VDomEvent)
 	GlobalStylesOption *FileHandlerOption
 	UrlHandlerMux      *mux.Router
-	OverrideUrlHandler http.Handler
 	SetupFn            func()
 }
 
+func MakeClient(appOpts AppOpts) *Client {
+	client := &Client{
+		Lock:          &sync.Mutex{},
+		Root:          comp.MakeRoot(),
+		DoneCh:        make(chan struct{}),
+		SSEventCh:     make(chan SSEvent, 100),
+		UrlHandlerMux: mux.NewRouter(),
+	}
+	client.SetAppOpts(appOpts)
+	return client
+}
+
 func (c *Client) GetIsDone() bool {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
 	return c.IsDone
 }
 
-func (c *Client) CheckClientId(clientId string) error {
+func (c *Client) checkClientId(clientId string) error {
 	if clientId == "" {
 		return fmt.Errorf("client id cannot be empty")
 	}
@@ -82,7 +93,7 @@ func (c *Client) CheckClientId(clientId string) error {
 	return fmt.Errorf("client id mismatch: expected %s, got %s", c.CurrentClientId, clientId)
 }
 
-func (c *Client) ClientTakeover(clientId string) {
+func (c *Client) clientTakeover(clientId string) {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
 	c.CurrentClientId = clientId
@@ -103,40 +114,39 @@ func (c *Client) SetGlobalEventHandler(handler func(client *Client, event vdom.V
 	c.GlobalEventHandler = handler
 }
 
-func (c *Client) SetOverrideUrlHandler(handler http.Handler) {
-	c.OverrideUrlHandler = handler
-}
+func (c *Client) SetAppOpts(appOpts AppOpts) {
+	c.Lock.Lock()
+	defer c.Lock.Unlock()
 
-func MakeClient(appOpts AppOpts) *Client {
 	if appOpts.RootComponentName == "" {
 		appOpts.RootComponentName = "App"
 	}
-	client := &Client{
-		Lock:          &sync.Mutex{},
-		AppOpts:       appOpts,
-		Root:          comp.MakeRoot(),
-		DoneCh:        make(chan struct{}),
-		SSEventCh:     make(chan SSEvent, 100),
-		UrlHandlerMux: mux.NewRouter(),
-		Opts: rpctypes.VDomBackendOpts{
-			CloseOnCtrlC:         appOpts.CloseOnCtrlC,
-			GlobalKeyboardEvents: appOpts.GlobalKeyboardEvents,
-			Title:                appOpts.Title,
-		},
-	}
+
+	c.AppOpts = appOpts
+
+	// Update the VDomBackendOpts
+	c.Opts.CloseOnCtrlC = appOpts.CloseOnCtrlC
+	c.Opts.GlobalKeyboardEvents = appOpts.GlobalKeyboardEvents
+	c.Opts.Title = appOpts.Title
+
+	// Update RootElem if component name changed
+	c.RootElem = vdom.E(appOpts.RootComponentName)
+
+	// Update global styles
 	if len(appOpts.GlobalStyles) > 0 {
-		client.Opts.GlobalStyles = true
-		client.GlobalStylesOption = &FileHandlerOption{Data: appOpts.GlobalStyles, MimeType: "text/css"}
+		c.Opts.GlobalStyles = true
+		c.GlobalStylesOption = &FileHandlerOption{Data: appOpts.GlobalStyles, MimeType: "text/css"}
+	} else {
+		c.Opts.GlobalStyles = false
+		c.GlobalStylesOption = nil
 	}
-	client.SetRootElem(vdom.E(appOpts.RootComponentName))
-	return client
 }
 
 func (c *Client) runMainE() error {
 	if c.SetupFn != nil {
 		c.SetupFn()
 	}
-	err := c.ListenAndServe(context.Background())
+	err := c.listenAndServe(context.Background())
 	if err != nil {
 		return err
 	}
@@ -156,7 +166,7 @@ func (c *Client) RunMain() {
 	}
 }
 
-func (c *Client) ListenAndServe(ctx context.Context) error {
+func (c *Client) listenAndServe(ctx context.Context) error {
 	// Create HTTP handlers
 	handlers := NewHTTPHandlers(c)
 
@@ -205,10 +215,6 @@ func (c *Client) ListenAndServe(ctx context.Context) error {
 	return nil
 }
 
-func (c *Client) SetRootElem(elem *vdom.VDomElem) {
-	c.RootElem = elem
-}
-
 func (c *Client) SendAsyncInitiation() error {
 	if c.GetIsDone() {
 		return fmt.Errorf("client is done")

From 0cfa0f83815d6dd83bd0f639d5eccdac72735fe3 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 2 Sep 2025 00:25:58 -0700
Subject: [PATCH 031/134] default client + working on better type conversions
 for useatom...

---
 tsunami/app/defaultclient.go   | 63 +++++++++++++++++++++++++++++
 tsunami/app/tsunamiapp.go      |  6 +--
 tsunami/demo/todo/main-todo.go | 24 ++++++-----
 tsunami/util/compare.go        | 74 ++++++++++++++++++++++++++++++++++
 tsunami/vdom/vdom.go           | 30 ++++++++++----
 5 files changed, 175 insertions(+), 22 deletions(-)
 create mode 100644 tsunami/app/defaultclient.go

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
new file mode 100644
index 0000000000..2bb516635e
--- /dev/null
+++ b/tsunami/app/defaultclient.go
@@ -0,0 +1,63 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package app
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+var defaultClient = MakeClient(AppOpts{})
+
+// Default client methods that operate on the global defaultClient
+
+func DefineComponent[P any](name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
+	return DefineComponentEx(defaultClient, name, renderFn)
+}
+
+func SetGlobalEventHandler(handler func(client *Client, event vdom.VDomEvent)) {
+	defaultClient.SetGlobalEventHandler(handler)
+}
+
+func SetAppOpts(appOpts AppOpts) {
+	defaultClient.SetAppOpts(appOpts)
+}
+
+func AddSetupFn(fn func()) {
+	defaultClient.AddSetupFn(fn)
+}
+
+func RunMain() {
+	defaultClient.RunMain()
+}
+
+func SendAsyncInitiation() error {
+	return defaultClient.SendAsyncInitiation()
+}
+
+func SetAtomVals(m map[string]any) {
+	defaultClient.SetAtomVals(m)
+}
+
+func SetAtomVal(name string, val any) {
+	defaultClient.SetAtomVal(name, val)
+}
+
+func GetAtomVal(name string) any {
+	return defaultClient.GetAtomVal(name)
+}
+
+func RegisterUrlPathHandler(path string, handler http.Handler) {
+	defaultClient.RegisterUrlPathHandler(path, handler)
+}
+
+func RegisterFilePrefixHandler(prefix string, optionProvider func(path string) (*FileHandlerOption, error)) {
+	defaultClient.RegisterFilePrefixHandler(prefix, optionProvider)
+}
+
+func RegisterFileHandler(path string, option FileHandlerOption) {
+	defaultClient.RegisterFileHandler(path, option)
+}
\ No newline at end of file
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 1113e09b68..6cd4ea921b 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -246,14 +246,14 @@ func makeNullVDom() *vdom.VDomElem {
 	return &vdom.VDomElem{WaveId: uuid.New().String(), Tag: vdom.WaveNullTag}
 }
 
-func DefineComponent[P any](client *Client, name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
+func DefineComponentEx[P any](client *Client, name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
 	if name == "" {
 		panic("Component name cannot be empty")
 	}
 	if !unicode.IsUpper(rune(name[0])) {
 		panic("Component name must start with an uppercase letter")
 	}
-	err := client.RegisterComponent(name, renderFn)
+	err := client.registerComponent(name, renderFn)
 	if err != nil {
 		panic(err)
 	}
@@ -262,7 +262,7 @@ func DefineComponent[P any](client *Client, name string, renderFn func(ctx conte
 	}
 }
 
-func (c *Client) RegisterComponent(name string, cfunc any) error {
+func (c *Client) registerComponent(name string, cfunc any) error {
 	return c.Root.RegisterComponent(name, cfunc)
 }
 
diff --git a/tsunami/demo/todo/main-todo.go b/tsunami/demo/todo/main-todo.go
index 04a87464b3..5fb0d56af4 100644
--- a/tsunami/demo/todo/main-todo.go
+++ b/tsunami/demo/todo/main-todo.go
@@ -12,12 +12,14 @@ import (
 //go:embed tw.css
 var styleCSS []byte
 
-// Initialize client with embedded Tailwind styles and ctrl-c handling
-var AppClient = app.MakeClient(app.AppOpts{
-	CloseOnCtrlC: true,
-	GlobalStyles: styleCSS,
-	Title:        "Todo App (Tsunami Demo)",
-})
+func init() {
+	// Set up the default client with embedded Tailwind styles and ctrl-c handling
+	app.SetAppOpts(app.AppOpts{
+		CloseOnCtrlC: true,
+		GlobalStyles: styleCSS,
+		Title:        "Todo App (Tsunami Demo)",
+	})
+}
 
 // Basic domain types with json tags for props
 type Todo struct {
@@ -46,7 +48,7 @@ type InputFieldProps struct {
 }
 
 // Reusable input component showing keyboard event handling
-var InputField = app.DefineComponent(AppClient, "InputField",
+var InputField = app.DefineComponent("InputField",
 	func(ctx context.Context, props InputFieldProps) any {
 		// Example of special key handling with VDomFunc
 		keyDown := &vdom.VDomFunc{
@@ -71,7 +73,7 @@ var InputField = app.DefineComponent(AppClient, "InputField",
 )
 
 // Item component showing conditional classes and event handling
-var TodoItem = app.DefineComponent(AppClient, "TodoItem",
+var TodoItem = app.DefineComponent("TodoItem",
 	func(ctx context.Context, props TodoItemProps) any {
 		return vdom.H("div", map[string]any{
 			"className": vdom.Classes("flex items-center gap-2.5 p-2 border border-border rounded", vdom.If(props.Todo.Completed, "opacity-70")),
@@ -94,7 +96,7 @@ var TodoItem = app.DefineComponent(AppClient, "TodoItem",
 )
 
 // List component demonstrating mapping over data, using WithKey to set key on a component
-var TodoList = app.DefineComponent(AppClient, "TodoList",
+var TodoList = app.DefineComponent("TodoList",
 	func(ctx context.Context, props TodoListProps) any {
 		return vdom.H("div", map[string]any{
 			"className": "flex flex-col gap-2",
@@ -109,7 +111,7 @@ var TodoList = app.DefineComponent(AppClient, "TodoList",
 )
 
 // Root component showing state management and composition
-var App = app.DefineComponent(AppClient, "App",
+var App = app.DefineComponent("App",
 	func(ctx context.Context, _ any) any {
 		// Multiple state hooks example
 		todos, setTodos, _ := vdom.UseState(ctx, []Todo{
@@ -187,5 +189,5 @@ var App = app.DefineComponent(AppClient, "App",
 )
 
 func main() {
-	AppClient.RunMain()
+	app.RunMain()
 }
diff --git a/tsunami/util/compare.go b/tsunami/util/compare.go
index 41299af5e2..3792f2624c 100644
--- a/tsunami/util/compare.go
+++ b/tsunami/util/compare.go
@@ -4,6 +4,7 @@
 package util
 
 import (
+	"math"
 	"reflect"
 	"strconv"
 )
@@ -163,4 +164,77 @@ func NumToString[T any](value T) (string, bool) {
 	default:
 		return "", false
 	}
+}
+
+// FromFloat64 converts a float64 to the specified numeric type T
+// Returns the converted value and a bool indicating if the conversion was successful
+func FromFloat64[T any](val float64) (T, bool) {
+	var zero T
+	
+	// Check for NaN or infinity
+	if math.IsNaN(val) || math.IsInf(val, 0) {
+		return zero, false
+	}
+	
+	switch any(zero).(type) {
+	case int:
+		if val != float64(int64(val)) || val < math.MinInt || val > math.MaxInt {
+			return zero, false
+		}
+		return any(int(val)).(T), true
+	case int8:
+		if val != float64(int64(val)) || val < math.MinInt8 || val > math.MaxInt8 {
+			return zero, false
+		}
+		return any(int8(val)).(T), true
+	case int16:
+		if val != float64(int64(val)) || val < math.MinInt16 || val > math.MaxInt16 {
+			return zero, false
+		}
+		return any(int16(val)).(T), true
+	case int32:
+		if val != float64(int64(val)) || val < math.MinInt32 || val > math.MaxInt32 {
+			return zero, false
+		}
+		return any(int32(val)).(T), true
+	case int64:
+		if val != float64(int64(val)) || val < math.MinInt64 || val > math.MaxInt64 {
+			return zero, false
+		}
+		return any(int64(val)).(T), true
+	case uint:
+		if val < 0 || val != float64(uint64(val)) || val > math.MaxUint {
+			return zero, false
+		}
+		return any(uint(val)).(T), true
+	case uint8:
+		if val < 0 || val != float64(uint64(val)) || val > math.MaxUint8 {
+			return zero, false
+		}
+		return any(uint8(val)).(T), true
+	case uint16:
+		if val < 0 || val != float64(uint64(val)) || val > math.MaxUint16 {
+			return zero, false
+		}
+		return any(uint16(val)).(T), true
+	case uint32:
+		if val < 0 || val != float64(uint64(val)) || val > math.MaxUint32 {
+			return zero, false
+		}
+		return any(uint32(val)).(T), true
+	case uint64:
+		if val < 0 || val != float64(uint64(val)) || val > math.MaxUint64 {
+			return zero, false
+		}
+		return any(uint64(val)).(T), true
+	case float32:
+		if math.Abs(val) > math.MaxFloat32 {
+			return zero, false
+		}
+		return any(float32(val)).(T), true
+	case float64:
+		return any(val).(T), true
+	default:
+		return zero, false
+	}
 }
\ No newline at end of file
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index ed7977ff1d..bb9abfb922 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -313,6 +313,26 @@ func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T
 	return rtnVal, setVal, setFuncVal
 }
 
+func getTypedAtomValue[T any](rawVal any, atomName string) T {
+	var result T
+	if rawVal == nil {
+		return *new(T)
+	}
+
+	var ok bool
+	result, ok = rawVal.(T)
+	if !ok {
+		// Try converting from float64 if rawVal is float64
+		if f64Val, isFloat64 := rawVal.(float64); isFloat64 {
+			if converted, convOk := util.FromFloat64[T](f64Val); convOk {
+				return converted
+			}
+		}
+		panic(fmt.Sprintf("UseAtom %q value type mismatch (expected %T, got %T)", atomName, *new(T), rawVal))
+	}
+	return result
+}
+
 func useAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
 	vc := GetRenderContext(ctx)
 	hookVal := vc.GetOrderedHook()
@@ -324,19 +344,13 @@ func useAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func
 		}
 	}
 	vc.AtomSetUsedBy(atomName, vc.GetCompWaveId(), true)
-	atomVal, ok := vc.GetAtomVal(atomName).(T)
-	if !ok {
-		panic(fmt.Sprintf("UseAtom %q value type mismatch (expected %T, got %T)", atomName, atomVal, vc.GetAtomVal(atomName)))
-	}
+	atomVal := getTypedAtomValue[T](vc.GetAtomVal(atomName), atomName)
 	setVal := func(newVal T) {
 		vc.SetAtomVal(atomName, newVal, true)
 		vc.AtomAddRenderWork(atomName)
 	}
 	setFuncVal := func(updateFunc func(T) T) {
-		currentVal, ok := vc.GetAtomVal(atomName).(T)
-		if !ok {
-			panic(fmt.Sprintf("UseAtom %q value type mismatch in setFuncVal", atomName))
-		}
+		currentVal := getTypedAtomValue[T](vc.GetAtomVal(atomName), atomName)
 		vc.SetAtomVal(atomName, updateFunc(currentVal), true)
 		vc.AtomAddRenderWork(atomName)
 	}

From 927be3f094ec27048ac06e969987f3424aebd9c7 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 2 Sep 2025 09:53:34 -0700
Subject: [PATCH 032/134] implement /api/manifest (register manifest file)

---
 tsunami/app/defaultclient.go  | 18 +++++++++++++++-
 tsunami/app/serverhandlers.go | 40 ++++++++++++++++++++++++++++++-----
 tsunami/app/tsunamiapp.go     | 18 +++++-----------
 3 files changed, 57 insertions(+), 19 deletions(-)

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 2bb516635e..c9b63b38c8 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -5,12 +5,16 @@ package app
 
 import (
 	"context"
+	"embed"
 	"net/http"
 
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
 var defaultClient = MakeClient(AppOpts{})
+var assetsFS *embed.FS
+var staticFS *embed.FS
+var manifestFile *FileHandlerOption
 
 // Default client methods that operate on the global defaultClient
 
@@ -60,4 +64,16 @@ func RegisterFilePrefixHandler(prefix string, optionProvider func(path string) (
 
 func RegisterFileHandler(path string, option FileHandlerOption) {
 	defaultClient.RegisterFileHandler(path, option)
-}
\ No newline at end of file
+}
+
+func RegisterAssetsFS(fs embed.FS) {
+	assetsFS = &fs
+}
+
+func RegisterStaticFS(fs embed.FS) {
+	staticFS = &fs
+}
+
+func RegisterManifestFile(option FileHandlerOption) {
+	manifestFile = &option
+}
diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index e8ddbe0897..efc52c6688 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -26,6 +26,12 @@ func init() {
 	mime.AddExtensionType(".json", "application/json")
 }
 
+type HandlerOpts struct {
+	AssetsFS     *embed.FS
+	StaticFS     *embed.FS
+	ManifestFile *FileHandlerOption
+}
+
 type HTTPHandlers struct {
 	Client     *Client
 	renderLock sync.Mutex
@@ -37,21 +43,22 @@ func NewHTTPHandlers(client *Client) *HTTPHandlers {
 	}
 }
 
-func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux, assetsFS *embed.FS, staticFS *embed.FS) {
+func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux, opts HandlerOpts) {
 	mux.HandleFunc("/api/render", h.handleRender)
 	mux.HandleFunc("/api/updates", h.handleSSE)
 	mux.HandleFunc("/api/data", h.handleData)
 	mux.HandleFunc("/api/config", h.handleConfig)
+	mux.HandleFunc("/api/manifest", h.handleManifest(opts.ManifestFile))
 	mux.HandleFunc("/files/", h.handleAssetsUrl)
 
 	// Add handler for static files at /static/ path
-	if staticFS != nil {
-		mux.HandleFunc("/static/", h.handleStaticPathFiles(staticFS))
+	if opts.StaticFS != nil {
+		mux.HandleFunc("/static/", h.handleStaticPathFiles(opts.StaticFS))
 	}
 
 	// Add fallback handler for embedded static files in production mode
-	if assetsFS != nil {
-		mux.HandleFunc("/", h.handleStaticFiles(assetsFS))
+	if opts.AssetsFS != nil {
+		mux.HandleFunc("/", h.handleStaticFiles(opts.AssetsFS))
 	}
 }
 
@@ -337,6 +344,29 @@ func (h *HTTPHandlers) handleStaticFiles(embeddedFS *embed.FS) http.HandlerFunc
 	}
 }
 
+func (h *HTTPHandlers) handleManifest(manifestFile *FileHandlerOption) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			panicErr := util.PanicHandler("handleManifest", recover())
+			if panicErr != nil {
+				http.Error(w, fmt.Sprintf("internal server error: %v", panicErr), http.StatusInternalServerError)
+			}
+		}()
+
+		if r.Method != http.MethodGet {
+			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		if manifestFile == nil {
+			http.NotFound(w, r)
+			return
+		}
+
+		ServeFileOption(w, r, *manifestFile)
+	}
+}
+
 func (h *HTTPHandlers) handleStaticPathFiles(staticFS *embed.FS) http.HandlerFunc {
 	// Create a file server from the embedded FS
 	fileServer := http.FileServer(http.FS(staticFS))
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 6cd4ea921b..8d6409c5a9 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -5,7 +5,6 @@ package app
 
 import (
 	"context"
-	"embed"
 	"fmt"
 	"io"
 	"io/fs"
@@ -29,9 +28,6 @@ import (
 const TsunamiListenAddrEnvVar = "TSUNAMI_LISTENADDR"
 const DefaultListenAddr = "localhost:0"
 
-var assetsFS *embed.FS
-var staticFS *embed.FS
-
 type SSEvent struct {
 	Event string
 	Data  []byte
@@ -172,7 +168,11 @@ func (c *Client) listenAndServe(ctx context.Context) error {
 
 	// Create a new ServeMux and register handlers
 	mux := http.NewServeMux()
-	handlers.RegisterHandlers(mux, assetsFS, staticFS)
+	handlers.RegisterHandlers(mux, HandlerOpts{
+		AssetsFS:     assetsFS,
+		StaticFS:     staticFS,
+		ManifestFile: manifestFile,
+	})
 
 	// Determine listen address from environment variable or use default
 	listenAddr := os.Getenv(TsunamiListenAddrEnvVar)
@@ -460,11 +460,3 @@ func (c *Client) RegisterFileHandler(path string, option FileHandlerOption) {
 		}
 	})
 }
-
-func RegisterAssetsFS(fs embed.FS) {
-	assetsFS = &fs
-}
-
-func RegisterStaticFS(fs embed.FS) {
-	staticFS = &fs
-}

From a46558c1ed706e1099430bc29f1dc8c80b6574ee Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 2 Sep 2025 10:04:51 -0700
Subject: [PATCH 033/134] tsunami bin ... build, cobra, etc

---
 Taskfile.yml                       | 14 +++++++++++
 tsunami/cmd/main-tsunami.go        | 40 ++++++++++++++++++++++++++++++
 tsunami/go.mod                     |  7 +++++-
 tsunami/go.sum                     | 10 ++++++++
 tsunami/tsunamibase/tsunamibase.go |  3 +++
 5 files changed, 73 insertions(+), 1 deletion(-)
 create mode 100644 tsunami/cmd/main-tsunami.go
 create mode 100644 tsunami/tsunamibase/tsunamibase.go

diff --git a/Taskfile.yml b/Taskfile.yml
index 124220e38c..f3d3a1815b 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -450,3 +450,17 @@ tasks:
         desc: Run the tsunami frontend vite dev server
         cmd: npm run dev
         dir: tsunami/frontend
+
+    tsunami:build:
+        desc: Build the tsunami binary.
+        cmds:
+            - cmd: "{{.RM}} bin/tsunami*"
+              ignore_error: true
+            - mkdir -p bin
+            - cd tsunami && go build -ldflags "-X main.BuildTime=$({{.DATE}} +'%Y%m%d%H%M') -X main.TsunamiVersion={{.VERSION}}" -o ../bin/tsunami{{exeExt}} cmd/main-tsunami.go
+        sources:
+            - "tsunami/**/*.go"
+            - "tsunami/go.mod"
+            - "tsunami/go.sum"
+        generates:
+            - "bin/tsunami{{exeExt}}"
diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
new file mode 100644
index 0000000000..b5c526c8f9
--- /dev/null
+++ b/tsunami/cmd/main-tsunami.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+	"github.com/wavetermdev/waveterm/tsunami/tsunamibase"
+)
+
+// these are set at build time
+var TsunamiVersion = "0.0.0"
+var BuildTime = "0"
+
+var rootCmd = &cobra.Command{
+	Use:   "tsunami",
+	Short: "Tsunami - A VDOM-based UI framework",
+	Long:  `Tsunami is a VDOM-based UI framework for building modern applications.`,
+}
+
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Print Tsunami version",
+	Long:  `Print Tsunami version`,
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Println("v" + tsunamibase.TsunamiVersion)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(versionCmd)
+}
+
+func main() {
+	tsunamibase.TsunamiVersion = TsunamiVersion
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
\ No newline at end of file
diff --git a/tsunami/go.mod b/tsunami/go.mod
index eb3016560f..c197f7b4f1 100644
--- a/tsunami/go.mod
+++ b/tsunami/go.mod
@@ -5,7 +5,12 @@ go 1.24.6
 require (
 	github.com/google/uuid v1.6.0
 	github.com/gorilla/mux v1.8.1
+	github.com/spf13/cobra v1.10.1
 	github.com/wavetermdev/htmltoken v0.2.0
 )
 
-require golang.org/x/net v0.43.0 // indirect
+require (
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/spf13/pflag v1.0.9 // indirect
+	golang.org/x/net v0.43.0 // indirect
+)
diff --git a/tsunami/go.sum b/tsunami/go.sum
index 4fe0663af0..63173da653 100644
--- a/tsunami/go.sum
+++ b/tsunami/go.sum
@@ -1,8 +1,18 @@
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
 github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
+github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
+github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/wavetermdev/htmltoken v0.2.0 h1:sFVPPemlDv7/jg7n4Hx1AEF2m9MVAFjFpELWfhi/DlM=
 github.com/wavetermdev/htmltoken v0.2.0/go.mod h1:5FM0XV6zNYiNza2iaTcFGj+hnMtgqumFHO31Z8euquk=
 golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
 golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/tsunami/tsunamibase/tsunamibase.go b/tsunami/tsunamibase/tsunamibase.go
new file mode 100644
index 0000000000..0242bad120
--- /dev/null
+++ b/tsunami/tsunamibase/tsunamibase.go
@@ -0,0 +1,3 @@
+package tsunamibase
+
+var TsunamiVersion = "0.0.0"
\ No newline at end of file

From e9d02586e488558dc35d514fe07589c25bb391e7 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 2 Sep 2025 16:49:34 -0700
Subject: [PATCH 034/134] starting the build/run commands

---
 tsunami/build/build.go      | 144 ++++++++++++++++++++++++++++++++++++
 tsunami/build/buildutil.go  | 116 +++++++++++++++++++++++++++++
 tsunami/cmd/main-tsunami.go |  45 ++++++++++-
 3 files changed, 304 insertions(+), 1 deletion(-)
 create mode 100644 tsunami/build/build.go
 create mode 100644 tsunami/build/buildutil.go

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
new file mode 100644
index 0000000000..df8c899206
--- /dev/null
+++ b/tsunami/build/build.go
@@ -0,0 +1,144 @@
+package build
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type BuildOpts struct {
+	Dir     string
+	Verbose bool
+}
+
+func verifyTsunamiDir(dir string) error {
+	if dir == "" {
+		return fmt.Errorf("directory path cannot be empty")
+	}
+
+	// Check if directory exists
+	info, err := os.Stat(dir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("directory %q does not exist", dir)
+		}
+		return fmt.Errorf("error accessing directory %q: %w", dir, err)
+	}
+
+	if !info.IsDir() {
+		return fmt.Errorf("%q is not a directory", dir)
+	}
+
+	// Check for app.go file
+	appGoPath := filepath.Join(dir, "app.go")
+	if err := CheckFileExists(appGoPath); err != nil {
+		return fmt.Errorf("app.go check failed in directory %q: %w", dir, err)
+	}
+
+	// Check static directory if it exists
+	staticPath := filepath.Join(dir, "static")
+	if err := IsDirOrNotFound(staticPath); err != nil {
+		return fmt.Errorf("static directory check failed in %q: %w", dir, err)
+	}
+
+	// Check that dist doesn't exist
+	distPath := filepath.Join(dir, "dist")
+	if err := FileMustNotExist(distPath); err != nil {
+		return fmt.Errorf("dist check failed in %q: %w", dir, err)
+	}
+
+	return nil
+}
+
+func TsunamiBuild(opts BuildOpts) error {
+	if err := verifyTsunamiDir(opts.Dir); err != nil {
+		return err
+	}
+
+	// Create temporary directory
+	tempDir, err := os.MkdirTemp("", "tsunami-build-*")
+	if err != nil {
+		return fmt.Errorf("failed to create temp directory: %w", err)
+	}
+
+	log.Printf("Building tsunami app from %s\n", opts.Dir)
+
+	if opts.Verbose {
+		log.Printf("Temp dir: %s\n", tempDir)
+	}
+
+	// Copy all *.go files from the root directory
+	goCount, err := copyGoFiles(opts.Dir, tempDir)
+	if err != nil {
+		return fmt.Errorf("failed to copy go files: %w", err)
+	}
+
+	// Copy static directory
+	staticCount, err := copyStaticDir(opts.Dir, tempDir)
+	if err != nil {
+		return fmt.Errorf("failed to copy static directory: %w", err)
+	}
+
+	// Create dist directory
+	distDir := filepath.Join(tempDir, "dist")
+	if err := os.MkdirAll(distDir, 0755); err != nil {
+		return fmt.Errorf("failed to create dist directory: %w", err)
+	}
+
+	if opts.Verbose {
+		log.Printf("Copied %d go files, %d static files\n", goCount, staticCount)
+	}
+	return nil
+}
+
+func copyStaticDir(srcDir, destDir string) (int, error) {
+	// Always create static directory in temp dir
+	staticDestDir := filepath.Join(destDir, "static")
+	if err := os.MkdirAll(staticDestDir, 0755); err != nil {
+		return 0, fmt.Errorf("failed to create static directory: %w", err)
+	}
+
+	// Copy static/ directory contents if it exists
+	staticSrcDir := filepath.Join(srcDir, "static")
+	if _, err := os.Stat(staticSrcDir); err == nil {
+		return copyDirRecursive(staticSrcDir, staticDestDir)
+	}
+
+	return 0, nil
+}
+
+func copyGoFiles(srcDir, destDir string) (int, error) {
+	entries, err := os.ReadDir(srcDir)
+	if err != nil {
+		return 0, err
+	}
+
+	fileCount := 0
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+
+		if strings.HasSuffix(entry.Name(), ".go") {
+			srcPath := filepath.Join(srcDir, entry.Name())
+			destPath := filepath.Join(destDir, entry.Name())
+
+			if err := copyFile(srcPath, destPath); err != nil {
+				return 0, fmt.Errorf("failed to copy %s: %w", entry.Name(), err)
+			}
+			fileCount++
+		}
+	}
+
+	return fileCount, nil
+}
+
+func TsunamiRun(opts BuildOpts) error {
+	if err := TsunamiBuild(opts); err != nil {
+		return err
+	}
+
+	return fmt.Errorf("TsunamiRun not implemented yet")
+}
diff --git a/tsunami/build/buildutil.go b/tsunami/build/buildutil.go
new file mode 100644
index 0000000000..8e316b9ce5
--- /dev/null
+++ b/tsunami/build/buildutil.go
@@ -0,0 +1,116 @@
+package build
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+func IsDirOrNotFound(path string) error {
+	info, err := os.Stat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // Not found is OK
+		}
+		return err // Other errors are not OK
+	}
+
+	if !info.IsDir() {
+		return fmt.Errorf("%q exists but is not a directory", path)
+	}
+
+	return nil // It's a directory, which is OK
+}
+
+func CheckFileExists(path string) error {
+	info, err := os.Stat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("file %q not found", path)
+		}
+		return fmt.Errorf("error accessing file %q: %w", path, err)
+	}
+
+	if info.IsDir() {
+		return fmt.Errorf("%q is a directory, not a file", path)
+	}
+
+	return nil
+}
+
+func FileMustNotExist(path string) error {
+	if _, err := os.Stat(path); err == nil {
+		return fmt.Errorf("%q must not exist", path)
+	} else if !os.IsNotExist(err) {
+		return err // Other errors are not OK
+	}
+	return nil // Not found is OK
+}
+
+func copyDirRecursive(srcDir, destDir string) (int, error) {
+	fileCount := 0
+	err := filepath.Walk(srcDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Calculate destination path
+		relPath, err := filepath.Rel(srcDir, path)
+		if err != nil {
+			return err
+		}
+		destPath := filepath.Join(destDir, relPath)
+
+		if info.IsDir() {
+			// Create directory
+			if err := os.MkdirAll(destPath, info.Mode()); err != nil {
+				return err
+			}
+		} else {
+			// Copy file
+			if err := copyFile(path, destPath); err != nil {
+				return err
+			}
+			fileCount++
+		}
+
+		return nil
+	})
+
+	return fileCount, err
+}
+
+func copyFile(srcPath, destPath string) error {
+	// Get source file info for mode
+	srcInfo, err := os.Stat(srcPath)
+	if err != nil {
+		return err
+	}
+
+	// Create destination directory if it doesn't exist
+	destDir := filepath.Dir(destPath)
+	if err := os.MkdirAll(destDir, 0755); err != nil {
+		return err
+	}
+
+	srcFile, err := os.Open(srcPath)
+	if err != nil {
+		return err
+	}
+	defer srcFile.Close()
+
+	destFile, err := os.Create(destPath)
+	if err != nil {
+		return err
+	}
+	defer destFile.Close()
+
+	_, err = io.Copy(destFile, srcFile)
+	if err != nil {
+		return err
+	}
+
+	// Set the same mode as source file
+	return os.Chmod(destPath, srcInfo.Mode())
+}
diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
index b5c526c8f9..cea851335b 100644
--- a/tsunami/cmd/main-tsunami.go
+++ b/tsunami/cmd/main-tsunami.go
@@ -5,6 +5,7 @@ import (
 	"os"
 
 	"github.com/spf13/cobra"
+	"github.com/wavetermdev/waveterm/tsunami/build"
 	"github.com/wavetermdev/waveterm/tsunami/tsunamibase"
 )
 
@@ -27,8 +28,50 @@ var versionCmd = &cobra.Command{
 	},
 }
 
+var buildCmd = &cobra.Command{
+	Use:   "build [directory]",
+	Short: "Build a Tsunami application",
+	Long:  `Build a Tsunami application from the specified directory.`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		verbose, _ := cmd.Flags().GetBool("verbose")
+		opts := build.BuildOpts{
+			Dir:     args[0],
+			Verbose: verbose,
+		}
+		if err := build.TsunamiBuild(opts); err != nil {
+			fmt.Printf("Build failed: %v\n", err)
+			os.Exit(1)
+		}
+	},
+}
+
+var runCmd = &cobra.Command{
+	Use:   "run [directory]",
+	Short: "Build and run a Tsunami application",
+	Long:  `Build and run a Tsunami application from the specified directory.`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		verbose, _ := cmd.Flags().GetBool("verbose")
+		opts := build.BuildOpts{
+			Dir:     args[0],
+			Verbose: verbose,
+		}
+		if err := build.TsunamiRun(opts); err != nil {
+			fmt.Printf("Run failed: %v\n", err)
+			os.Exit(1)
+		}
+	},
+}
+
 func init() {
 	rootCmd.AddCommand(versionCmd)
+
+	buildCmd.Flags().BoolP("verbose", "v", false, "Enable verbose output")
+	rootCmd.AddCommand(buildCmd)
+
+	runCmd.Flags().BoolP("verbose", "v", false, "Enable verbose output")
+	rootCmd.AddCommand(runCmd)
 }
 
 func main() {
@@ -37,4 +80,4 @@ func main() {
 		fmt.Println(err)
 		os.Exit(1)
 	}
-}
\ No newline at end of file
+}

From eabda0dd07685b4f40455a6c59dc02df867bdf8a Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 2 Sep 2025 21:54:20 -0700
Subject: [PATCH 035/134] update AppOpts, simplify, working on build and
 tw.css...

---
 tsunami/app/tsunamiapp.go                    | 59 +++++++-------
 tsunami/build/build.go                       | 82 ++++++++++++++++++++
 tsunami/demo/todo/{main-todo.go => app.go}   |  4 -
 tsunami/frontend/index.html                  |  3 +-
 tsunami/frontend/src/app.tsx                 | 25 +++++-
 tsunami/frontend/src/model/tsunami-model.tsx | 42 ++++++++++
 tsunami/frontend/src/types/vdom.d.ts         |  3 +-
 tsunami/frontend/src/vdom.tsx                | 54 +++----------
 tsunami/rpctypes/types.go                    |  5 +-
 9 files changed, 192 insertions(+), 85 deletions(-)
 rename tsunami/demo/todo/{main-todo.go => app.go} (98%)

diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 8d6409c5a9..efba12cc5d 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -27,6 +27,7 @@ import (
 
 const TsunamiListenAddrEnvVar = "TSUNAMI_LISTENADDR"
 const DefaultListenAddr = "localhost:0"
+const DefaultComponentName = "App"
 
 type SSEvent struct {
 	Event string
@@ -37,8 +38,6 @@ type AppOpts struct {
 	Title                string // window title
 	CloseOnCtrlC         bool
 	GlobalKeyboardEvents bool
-	GlobalStyles         []byte
-	RootComponentName    string // defaults to "App"
 }
 
 type Client struct {
@@ -47,11 +46,11 @@ type Client struct {
 	Root               *comp.RootElem
 	RootElem           *vdom.VDomElem
 	CurrentClientId    string
+	ServerId           string
 	IsDone             bool
 	DoneReason         string
 	DoneCh             chan struct{}
 	SSEventCh          chan SSEvent
-	Opts               rpctypes.VDomBackendOpts
 	GlobalEventHandler func(client *Client, event vdom.VDomEvent)
 	GlobalStylesOption *FileHandlerOption
 	UrlHandlerMux      *mux.Router
@@ -65,6 +64,8 @@ func MakeClient(appOpts AppOpts) *Client {
 		DoneCh:        make(chan struct{}),
 		SSEventCh:     make(chan SSEvent, 100),
 		UrlHandlerMux: mux.NewRouter(),
+		ServerId:      uuid.New().String(),
+		RootElem:      vdom.E(DefaultComponentName),
 	}
 	client.SetAppOpts(appOpts)
 	return client
@@ -114,27 +115,27 @@ func (c *Client) SetAppOpts(appOpts AppOpts) {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
 
-	if appOpts.RootComponentName == "" {
-		appOpts.RootComponentName = "App"
-	}
-
 	c.AppOpts = appOpts
+}
+
+func getFaviconPath() string {
+	if staticFS != nil {
+		faviconNames := []string{"favicon.ico", "favicon.png", "favicon.svg", "favicon.gif", "favicon.jpg"}
+		for _, name := range faviconNames {
+			if _, err := staticFS.Open(name); err == nil {
+				return "/static/" + name
+			}
+		}
+	}
+	return "/wave-logo-256.png"
+}
 
-	// Update the VDomBackendOpts
-	c.Opts.CloseOnCtrlC = appOpts.CloseOnCtrlC
-	c.Opts.GlobalKeyboardEvents = appOpts.GlobalKeyboardEvents
-	c.Opts.Title = appOpts.Title
-
-	// Update RootElem if component name changed
-	c.RootElem = vdom.E(appOpts.RootComponentName)
-
-	// Update global styles
-	if len(appOpts.GlobalStyles) > 0 {
-		c.Opts.GlobalStyles = true
-		c.GlobalStylesOption = &FileHandlerOption{Data: appOpts.GlobalStyles, MimeType: "text/css"}
-	} else {
-		c.Opts.GlobalStyles = false
-		c.GlobalStylesOption = nil
+func (c *Client) makeBackendOpts() *rpctypes.VDomBackendOpts {
+	return &rpctypes.VDomBackendOpts{
+		Title:                c.AppOpts.Title,
+		CloseOnCtrlC:         c.AppOpts.CloseOnCtrlC,
+		GlobalKeyboardEvents: c.AppOpts.GlobalKeyboardEvents,
+		FaviconPath:          getFaviconPath(),
 	}
 }
 
@@ -275,10 +276,11 @@ func (c *Client) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 		renderedVDom = makeNullVDom()
 	}
 	return &rpctypes.VDomBackendUpdate{
-		Type:    "backendupdate",
-		Ts:      time.Now().UnixMilli(),
-		HasWork: len(c.Root.EffectWorkQueue) > 0,
-		Opts:    &c.Opts,
+		Type:     "backendupdate",
+		Ts:       time.Now().UnixMilli(),
+		ServerId: c.ServerId,
+		HasWork:  len(c.Root.EffectWorkQueue) > 0,
+		Opts:     c.makeBackendOpts(),
 		RenderUpdates: []rpctypes.VDomRenderUpdate{
 			{UpdateType: "root", VDom: renderedVDom},
 		},
@@ -295,8 +297,9 @@ func (c *Client) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 		renderedVDom = makeNullVDom()
 	}
 	return &rpctypes.VDomBackendUpdate{
-		Type: "backendupdate",
-		Ts:   time.Now().UnixMilli(),
+		Type:     "backendupdate",
+		Ts:       time.Now().UnixMilli(),
+		ServerId: c.ServerId,
 		RenderUpdates: []rpctypes.VDomRenderUpdate{
 			{UpdateType: "root", VDom: renderedVDom},
 		},
diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index df8c899206..8363e2de58 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -4,7 +4,10 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"regexp"
+	"strconv"
 	"strings"
 )
 
@@ -13,6 +16,81 @@ type BuildOpts struct {
 	Verbose bool
 }
 
+func verifyEnvironment(verbose bool) error {
+	// Check if go is in PATH
+	goPath, err := exec.LookPath("go")
+	if err != nil {
+		return fmt.Errorf("go command not found in PATH: %w", err)
+	}
+
+	// Run go version command
+	cmd := exec.Command(goPath, "version")
+	output, err := cmd.Output()
+	if err != nil {
+		return fmt.Errorf("failed to run 'go version': %w", err)
+	}
+
+	// Parse go version output and check for 1.21+
+	versionStr := strings.TrimSpace(string(output))
+	if verbose {
+		log.Printf("Found %s", versionStr)
+	}
+
+	// Extract version like "go1.21.0" from output
+	versionRegex := regexp.MustCompile(`go1\.(\d+)`)
+	matches := versionRegex.FindStringSubmatch(versionStr)
+	if len(matches) < 2 {
+		return fmt.Errorf("unable to parse go version from: %s", versionStr)
+	}
+
+	minor, err := strconv.Atoi(matches[1])
+	if err != nil || minor < 21 {
+		return fmt.Errorf("go version 1.21 or higher required, found: %s", versionStr)
+	}
+
+	// Check if npx is in PATH
+	_, err = exec.LookPath("npx")
+	if err != nil {
+		return fmt.Errorf("npx command not found in PATH: %w", err)
+	}
+
+	if verbose {
+		log.Printf("Found npx in PATH")
+	}
+
+	// Check Tailwind CSS version
+	tailwindCmd := exec.Command("npx", "@tailwindcss/cli")
+	tailwindOutput, err := tailwindCmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("failed to run 'npx @tailwindcss/cli': %w", err)
+	}
+
+	tailwindStr := strings.TrimSpace(string(tailwindOutput))
+	lines := strings.Split(tailwindStr, "\n")
+	if len(lines) == 0 {
+		return fmt.Errorf("no output from tailwindcss command")
+	}
+
+	firstLine := lines[0]
+	if verbose {
+		log.Printf("Found %s", firstLine)
+	}
+
+	// Check for v4 (format: "≈ tailwindcss v4.1.12")
+	tailwindRegex := regexp.MustCompile(`tailwindcss v(\d+)`)
+	matches = tailwindRegex.FindStringSubmatch(firstLine)
+	if len(matches) < 2 {
+		return fmt.Errorf("unable to parse tailwindcss version from: %s", firstLine)
+	}
+
+	majorVersion, err := strconv.Atoi(matches[1])
+	if err != nil || majorVersion != 4 {
+		return fmt.Errorf("tailwindcss v4 required, found: %s", firstLine)
+	}
+
+	return nil
+}
+
 func verifyTsunamiDir(dir string) error {
 	if dir == "" {
 		return fmt.Errorf("directory path cannot be empty")
@@ -53,6 +131,10 @@ func verifyTsunamiDir(dir string) error {
 }
 
 func TsunamiBuild(opts BuildOpts) error {
+	if err := verifyEnvironment(opts.Verbose); err != nil {
+		return err
+	}
+
 	if err := verifyTsunamiDir(opts.Dir); err != nil {
 		return err
 	}
diff --git a/tsunami/demo/todo/main-todo.go b/tsunami/demo/todo/app.go
similarity index 98%
rename from tsunami/demo/todo/main-todo.go
rename to tsunami/demo/todo/app.go
index 5fb0d56af4..e1f62c16b8 100644
--- a/tsunami/demo/todo/main-todo.go
+++ b/tsunami/demo/todo/app.go
@@ -9,14 +9,10 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-//go:embed tw.css
-var styleCSS []byte
-
 func init() {
 	// Set up the default client with embedded Tailwind styles and ctrl-c handling
 	app.SetAppOpts(app.AppOpts{
 		CloseOnCtrlC: true,
-		GlobalStyles: styleCSS,
 		Title:        "Todo App (Tsunami Demo)",
 	})
 }
diff --git a/tsunami/frontend/index.html b/tsunami/frontend/index.html
index 95f7db0085..80e4e5b3ed 100644
--- a/tsunami/frontend/index.html
+++ b/tsunami/frontend/index.html
@@ -2,11 +2,10 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Tsunami App</title>
   </head>
-  <body>
+  <body className="bg-background text-primary">
     <div id="root"></div>
     <script type="module" src="/src/main.tsx"></script>
   </body>
diff --git a/tsunami/frontend/src/app.tsx b/tsunami/frontend/src/app.tsx
index d6ffd04b2e..247b940ccf 100644
--- a/tsunami/frontend/src/app.tsx
+++ b/tsunami/frontend/src/app.tsx
@@ -1,15 +1,34 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+import { useState, useEffect } from "react";
 import { TsunamiModel } from "@/model/tsunami-model";
 import { VDomView } from "./vdom";
 
-const globalModel = new TsunamiModel();
-
 function App() {
+    const [remountKey, setRemountKey] = useState(0);
+    const [model, setModel] = useState(() => {
+        const newModel = new TsunamiModel();
+        newModel.remountCallback = () => {
+            setRemountKey(prev => prev + 1);
+        };
+        return newModel;
+    });
+
+    useEffect(() => {
+        // Create a new model when remount key changes
+        if (remountKey > 0) {
+            const newModel = new TsunamiModel();
+            newModel.remountCallback = () => {
+                setRemountKey(prev => prev + 1);
+            };
+            setModel(newModel);
+        }
+    }, [remountKey]);
+
     return (
         <div className="min-h-screen bg-background text-foreground">
-            <VDomView model={globalModel} />
+            <VDomView key={remountKey} model={model} />
         </div>
     );
 }
diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
index 10782eb447..5b86941370 100644
--- a/tsunami/frontend/src/model/tsunami-model.tsx
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -83,7 +83,9 @@ function annotateEvent(event: VDomEvent, propName: string, reactEvent: React.Syn
 
 export class TsunamiModel {
     clientId: string;
+    serverId: string;
     viewRef: React.RefObject<HTMLDivElement> = { current: null };
+    remountCallback: (() => void) | null = null;
     vdomRoot: jotai.PrimitiveAtom<VDomElem> = jotai.atom();
     atoms: Map<string, AtomContainer> = new Map(); // key is atomname
     refs: Map<string, RefContainer> = new Map(); // key is refid
@@ -108,6 +110,7 @@ export class TsunamiModel {
     globalVersion: jotai.PrimitiveAtom<number> = jotai.atom(0);
     hasBackendWork: boolean = false;
     noPadding: jotai.PrimitiveAtom<boolean>;
+    cachedFaviconPath: string | null = null;
 
     constructor() {
         this.clientId = getOrCreateClientId();
@@ -531,10 +534,46 @@ export class TsunamiModel {
         }
     }
 
+    updateFavicon(faviconPath: string | null) {
+        if (faviconPath === this.cachedFaviconPath) {
+            return;
+        }
+        
+        this.cachedFaviconPath = faviconPath;
+        
+        let existingFavicon = document.querySelector('link[rel="icon"]') as HTMLLinkElement;
+        
+        if (faviconPath) {
+            if (existingFavicon) {
+                existingFavicon.href = faviconPath;
+            } else {
+                const link = document.createElement('link');
+                link.rel = 'icon';
+                link.href = faviconPath;
+                document.head.appendChild(link);
+            }
+        } else {
+            if (existingFavicon) {
+                existingFavicon.remove();
+            }
+        }
+    }
+
     handleBackendUpdate(update: VDomBackendUpdate) {
         if (update == null) {
             return;
         }
+        
+        // Check if serverId is changing and trigger remount if needed
+        if (this.serverId != null && this.serverId !== update.serverid) {
+            // Server ID changed - need to remount the entire app
+            if (this.remountCallback) {
+                this.remountCallback();
+            }
+            return;
+        }
+        
+        this.serverId = update.serverid;
         getDefaultStore().set(this.contextActive, true);
         const idMap = new Map<string, VDomElem>();
         const vdomRoot = getDefaultStore().get(this.vdomRoot);
@@ -543,6 +582,9 @@ export class TsunamiModel {
             if (update.opts.title && update.opts.title.trim() !== "") {
                 document.title = update.opts.title;
             }
+            if (update.opts.faviconpath !== undefined) {
+                this.updateFavicon(update.opts.faviconpath);
+            }
         }
         makeVDomIdMap(vdomRoot, idMap);
         this.handleRenderUpdates(update, idMap);
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
index b2fe97918b..bdef3b9498 100644
--- a/tsunami/frontend/src/types/vdom.d.ts
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -12,14 +12,15 @@ type VDomAsyncInitiationRequest = {
 type VDomBackendOpts = {
     closeonctrlc?: boolean;
     globalkeyboardevents?: boolean;
-    globalstyles?: boolean;
     title?: string;
+    faviconpath?: string;
 };
 
 // vdom.VDomBackendUpdate
 type VDomBackendUpdate = {
     type: "backendupdate";
     ts: number;
+    serverid: string;
     opts?: VDomBackendOpts;
     haswork?: boolean;
     renderupdates?: VDomRenderUpdate[];
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index 455f485070..ad1bf078f0 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -16,7 +16,6 @@ const FragmentTag = "#fragment";
 const WaveTextTag = "wave:text";
 const WaveNullTag = "wave:null";
 const StyleTagName = "style";
-const WaveStyleTagName = "wave:style";
 
 const VDomObjType_Ref = "ref";
 const VDomObjType_Binding = "binding";
@@ -186,14 +185,15 @@ function resolveBinding(binding: VDomBinding, model: TsunamiModel): [any, string
         return [null, []];
     }
     // validate that bindName starts with valid atom prefix and has at least one char after the dot
-    const isValidBinding = (bindName.startsWith("$shared.") && bindName.length > 8) ||
-                          (bindName.startsWith("$config.") && bindName.length > 8) ||
-                          (bindName.startsWith("$data.") && bindName.length > 6);
-    
+    const isValidBinding =
+        (bindName.startsWith("$shared.") && bindName.length > 8) ||
+        (bindName.startsWith("$config.") && bindName.length > 8) ||
+        (bindName.startsWith("$data.") && bindName.length > 6);
+
     if (!isValidBinding) {
         return [null, []];
     }
-    
+
     const atom = model.getAtomContainer(bindName);
     if (atom == null) {
         return [null, []];
@@ -323,37 +323,6 @@ function StyleTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
     return <style>{styleText}</style>;
 }
 
-function WaveStyle({ src, model, onMount }: { src: string; model: TsunamiModel; onMount?: () => void }) {
-    const [styleContent, setStyleContent] = React.useState<string | null>(null);
-    React.useEffect(() => {
-        async function fetchCss() {
-            try {
-                const response = await fetch(src);
-                if (!response.ok) {
-                    console.error(`Failed to load CSS from ${src}`);
-                    return;
-                }
-                const cssText = await response.text();
-                setStyleContent(cssText);
-            } catch (error) {
-                console.error("Error fetching CSS:", error);
-                onMount?.();
-            }
-        }
-        fetchCss();
-    }, [src, model]);
-    // Trigger onMount after styleContent has been set and mounted
-    React.useEffect(() => {
-        if (styleContent) {
-            onMount?.();
-        }
-    }, [styleContent, onMount]);
-    if (!styleContent) {
-        return null;
-    }
-    return <style>{styleContent}</style>;
-}
-
 function VDomTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
     const props = useVDom(model, elem);
     if (elem.tag == WaveNullTag) {
@@ -369,9 +338,6 @@ function VDomTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
     if (elem.tag == StyleTagName) {
         return <StyleTag elem={elem} model={model} />;
     }
-    if (elem.tag == WaveStyleTagName) {
-        return <WaveStyle src={props.src} model={model} />;
-    }
     if (!AllowedSimpleTags[elem.tag] && !AllowedSvgTags[elem.tag]) {
         return <div>{"Invalid Tag <" + elem.tag + ">"}</div>;
     }
@@ -426,15 +392,13 @@ type VDomViewProps = {
 };
 
 function VDomInnerView({ model }: VDomViewProps) {
-    let [styleMounted, setStyleMounted] = React.useState(!model.backendOpts?.globalstyles);
-    const handleStylesMounted = () => {
+    let [styleMounted, setStyleMounted] = React.useState(false);
+    const handleStyleLoad = () => {
         setStyleMounted(true);
     };
     return (
         <>
-            {model.backendOpts?.globalstyles ? (
-                <WaveStyle src="/files/global.css" model={model} onMount={handleStylesMounted} />
-            ) : null}
+            <link rel="stylesheet" href={`/static/tw.css?x=${model.serverId}`} onLoad={handleStyleLoad} />
             {styleMounted ? <VDomRoot model={model} /> : null}
         </>
     );
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
index 0da48e4409..9ff99bf708 100644
--- a/tsunami/rpctypes/types.go
+++ b/tsunami/rpctypes/types.go
@@ -48,6 +48,7 @@ type VDomFrontendUpdate struct {
 type VDomBackendUpdate struct {
 	Type          string             `json:"type" tstype:"\"backendupdate\""`
 	Ts            int64              `json:"ts"`
+	ServerId      string             `json:"serverid"`
 	Opts          *VDomBackendOpts   `json:"opts,omitempty"`
 	HasWork       bool               `json:"haswork,omitempty"`
 	RenderUpdates []VDomRenderUpdate `json:"renderupdates,omitempty"`
@@ -167,10 +168,10 @@ type VDomRefUpdate struct {
 }
 
 type VDomBackendOpts struct {
+	Title                string `json:"title,omitempty"`
 	CloseOnCtrlC         bool   `json:"closeonctrlc,omitempty"`
 	GlobalKeyboardEvents bool   `json:"globalkeyboardevents,omitempty"`
-	GlobalStyles         bool   `json:"globalstyles,omitempty"`
-	Title                string `json:"title,omitempty"`
+	FaviconPath          string `json:"faviconpath,omitempty"`
 }
 
 type VDomRenderUpdate struct {

From 4c5c1afc6cd43bfdbe537eeac3e0dbf86813a878 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 2 Sep 2025 22:14:19 -0700
Subject: [PATCH 036/134] tsunami_distpath

---
 tsunami/build/build.go      | 36 ++++++++++++++++++++++++++++++++++--
 tsunami/cmd/main-tsunami.go | 20 ++++++++++++++++----
 tsunami/demo/todo/app.go    |  4 ----
 3 files changed, 50 insertions(+), 10 deletions(-)

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 8363e2de58..3043871f0d 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -12,8 +12,9 @@ import (
 )
 
 type BuildOpts struct {
-	Dir     string
-	Verbose bool
+	Dir      string
+	Verbose  bool
+	DistPath string
 }
 
 func verifyEnvironment(verbose bool) error {
@@ -130,6 +131,33 @@ func verifyTsunamiDir(dir string) error {
 	return nil
 }
 
+func verifyDistPath(distPath string) error {
+	if distPath == "" {
+		return fmt.Errorf("distPath cannot be empty")
+	}
+
+	// Check if directory exists
+	info, err := os.Stat(distPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("distPath directory %q does not exist", distPath)
+		}
+		return fmt.Errorf("error accessing distPath directory %q: %w", distPath, err)
+	}
+
+	if !info.IsDir() {
+		return fmt.Errorf("distPath %q is not a directory", distPath)
+	}
+
+	// Check for index.html file
+	indexPath := filepath.Join(distPath, "index.html")
+	if err := CheckFileExists(indexPath); err != nil {
+		return fmt.Errorf("index.html check failed in distPath %q: %w", distPath, err)
+	}
+
+	return nil
+}
+
 func TsunamiBuild(opts BuildOpts) error {
 	if err := verifyEnvironment(opts.Verbose); err != nil {
 		return err
@@ -139,6 +167,10 @@ func TsunamiBuild(opts BuildOpts) error {
 		return err
 	}
 
+	if err := verifyDistPath(opts.DistPath); err != nil {
+		return err
+	}
+
 	// Create temporary directory
 	tempDir, err := os.MkdirTemp("", "tsunami-build-*")
 	if err != nil {
diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
index cea851335b..e13e524a6e 100644
--- a/tsunami/cmd/main-tsunami.go
+++ b/tsunami/cmd/main-tsunami.go
@@ -35,9 +35,15 @@ var buildCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		verbose, _ := cmd.Flags().GetBool("verbose")
+		distPath := os.Getenv("TSUNAMI_DISTPATH")
+		if distPath == "" {
+			fmt.Printf("Error: TSUNAMI_DISTPATH environment variable must be set\n")
+			os.Exit(1)
+		}
 		opts := build.BuildOpts{
-			Dir:     args[0],
-			Verbose: verbose,
+			Dir:      args[0],
+			Verbose:  verbose,
+			DistPath: distPath,
 		}
 		if err := build.TsunamiBuild(opts); err != nil {
 			fmt.Printf("Build failed: %v\n", err)
@@ -53,9 +59,15 @@ var runCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		verbose, _ := cmd.Flags().GetBool("verbose")
+		distPath := os.Getenv("TSUNAMI_DISTPATH")
+		if distPath == "" {
+			fmt.Printf("Error: TSUNAMI_DISTPATH environment variable must be set\n")
+			os.Exit(1)
+		}
 		opts := build.BuildOpts{
-			Dir:     args[0],
-			Verbose: verbose,
+			Dir:      args[0],
+			Verbose:  verbose,
+			DistPath: distPath,
 		}
 		if err := build.TsunamiRun(opts); err != nil {
 			fmt.Printf("Run failed: %v\n", err)
diff --git a/tsunami/demo/todo/app.go b/tsunami/demo/todo/app.go
index e1f62c16b8..2962a018e7 100644
--- a/tsunami/demo/todo/app.go
+++ b/tsunami/demo/todo/app.go
@@ -183,7 +183,3 @@ var App = app.DefineComponent("App",
 		)
 	},
 )
-
-func main() {
-	app.RunMain()
-}

From 7ae7cf8f2b79442279f042a67c6c242b2d8da03d Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 2 Sep 2025 22:27:37 -0700
Subject: [PATCH 037/134] working on the build

---
 tsunami/build/build.go   |  52 ++++++++
 tsunami/demo/todo/tw.css | 267 ---------------------------------------
 2 files changed, 52 insertions(+), 267 deletions(-)
 delete mode 100644 tsunami/demo/todo/tw.css

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 3043871f0d..b5dab84b75 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -155,6 +155,18 @@ func verifyDistPath(distPath string) error {
 		return fmt.Errorf("index.html check failed in distPath %q: %w", distPath, err)
 	}
 
+	// Check for templates/tailwind.css file
+	tailwindPath := filepath.Join(distPath, "templates", "tailwind.css")
+	if err := CheckFileExists(tailwindPath); err != nil {
+		return fmt.Errorf("templates/tailwind.css check failed in distPath %q: %w", distPath, err)
+	}
+
+	// Check for templates/main.go.tmpl file
+	mainTmplPath := filepath.Join(distPath, "templates", "main.go.tmpl")
+	if err := CheckFileExists(mainTmplPath); err != nil {
+		return fmt.Errorf("templates/main.go.tmpl check failed in distPath %q: %w", distPath, err)
+	}
+
 	return nil
 }
 
@@ -204,6 +216,46 @@ func TsunamiBuild(opts BuildOpts) error {
 	if opts.Verbose {
 		log.Printf("Copied %d go files, %d static files\n", goCount, staticCount)
 	}
+
+	// Copy main.go.tmpl from dist/templates to temp dir as main-app.go
+	mainTmplSrc := filepath.Join(opts.DistPath, "templates", "main.go.tmpl")
+	mainTmplDest := filepath.Join(tempDir, "main-app.go")
+	if err := copyFile(mainTmplSrc, mainTmplDest); err != nil {
+		return fmt.Errorf("failed to copy main.go.tmpl: %w", err)
+	}
+
+	// Generate Tailwind CSS
+	if err := generateAppTailwindCss(opts.DistPath, tempDir, opts.Verbose); err != nil {
+		return fmt.Errorf("failed to generate tailwind css: %w", err)
+	}
+
+	return nil
+}
+
+func generateAppTailwindCss(distPath, tempDir string, verbose bool) error {
+	tailwindInput := filepath.Join(distPath, "templates", "tailwind.css")
+	tailwindOutput := filepath.Join(tempDir, "static", "tw.css")
+	contentGlob := filepath.Join(tempDir, "*.go")
+	
+	tailwindCmd := exec.Command("npx", "@tailwindcss/cli",
+		"-i", tailwindInput,
+		"-o", tailwindOutput,
+		"--content", contentGlob)
+	
+	if verbose {
+		log.Printf("Running: %s", strings.Join(tailwindCmd.Args, " "))
+		tailwindCmd.Stdout = os.Stdout
+		tailwindCmd.Stderr = os.Stderr
+	}
+	
+	if err := tailwindCmd.Run(); err != nil {
+		return fmt.Errorf("failed to run tailwind command: %w", err)
+	}
+
+	if verbose {
+		log.Printf("Tailwind CSS generated successfully")
+	}
+
 	return nil
 }
 
diff --git a/tsunami/demo/todo/tw.css b/tsunami/demo/todo/tw.css
deleted file mode 100644
index 584081e972..0000000000
--- a/tsunami/demo/todo/tw.css
+++ /dev/null
@@ -1,267 +0,0 @@
-/*! tailwindcss v4.1.12 | MIT License | https://tailwindcss.com */
-@layer properties;
-@layer theme, base, components, utilities;
-@layer theme {
-  :root, :host {
-    --font-sans: "Inter", sans-serif;
-    --font-mono: "Hack", monospace;
-    --color-red-100: oklch(93.6% 0.032 17.717);
-    --color-red-500: oklch(63.7% 0.237 25.331);
-    --spacing: 0.25rem;
-    --text-2xl: 1.5rem;
-    --text-2xl--line-height: calc(2 / 1.5);
-    --font-weight-bold: 700;
-    --default-font-family: var(--font-sans);
-    --default-mono-font-family: var(--font-mono);
-    --radius: 8px;
-    --color-border: rgba(255, 255, 255, 0.16);
-  }
-}
-@layer base {
-  *, ::after, ::before, ::backdrop, ::file-selector-button {
-    box-sizing: border-box;
-    margin: 0;
-    padding: 0;
-    border: 0 solid;
-  }
-  html, :host {
-    line-height: 1.5;
-    -webkit-text-size-adjust: 100%;
-    tab-size: 4;
-    font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");
-    font-feature-settings: var(--default-font-feature-settings, normal);
-    font-variation-settings: var(--default-font-variation-settings, normal);
-    -webkit-tap-highlight-color: transparent;
-  }
-  hr {
-    height: 0;
-    color: inherit;
-    border-top-width: 1px;
-  }
-  abbr:where([title]) {
-    -webkit-text-decoration: underline dotted;
-    text-decoration: underline dotted;
-  }
-  h1, h2, h3, h4, h5, h6 {
-    font-size: inherit;
-    font-weight: inherit;
-  }
-  a {
-    color: inherit;
-    -webkit-text-decoration: inherit;
-    text-decoration: inherit;
-  }
-  b, strong {
-    font-weight: bolder;
-  }
-  code, kbd, samp, pre {
-    font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
-    font-feature-settings: var(--default-mono-font-feature-settings, normal);
-    font-variation-settings: var(--default-mono-font-variation-settings, normal);
-    font-size: 1em;
-  }
-  small {
-    font-size: 80%;
-  }
-  sub, sup {
-    font-size: 75%;
-    line-height: 0;
-    position: relative;
-    vertical-align: baseline;
-  }
-  sub {
-    bottom: -0.25em;
-  }
-  sup {
-    top: -0.5em;
-  }
-  table {
-    text-indent: 0;
-    border-color: inherit;
-    border-collapse: collapse;
-  }
-  :-moz-focusring {
-    outline: auto;
-  }
-  progress {
-    vertical-align: baseline;
-  }
-  summary {
-    display: list-item;
-  }
-  ol, ul, menu {
-    list-style: none;
-  }
-  img, svg, video, canvas, audio, iframe, embed, object {
-    display: block;
-    vertical-align: middle;
-  }
-  img, video {
-    max-width: 100%;
-    height: auto;
-  }
-  button, input, select, optgroup, textarea, ::file-selector-button {
-    font: inherit;
-    font-feature-settings: inherit;
-    font-variation-settings: inherit;
-    letter-spacing: inherit;
-    color: inherit;
-    border-radius: 0;
-    background-color: transparent;
-    opacity: 1;
-  }
-  :where(select:is([multiple], [size])) optgroup {
-    font-weight: bolder;
-  }
-  :where(select:is([multiple], [size])) optgroup option {
-    padding-inline-start: 20px;
-  }
-  ::file-selector-button {
-    margin-inline-end: 4px;
-  }
-  ::placeholder {
-    opacity: 1;
-  }
-  @supports (not (-webkit-appearance: -apple-pay-button))  or (contain-intrinsic-size: 1px) {
-    ::placeholder {
-      color: currentcolor;
-      @supports (color: color-mix(in lab, red, red)) {
-        color: color-mix(in oklab, currentcolor 50%, transparent);
-      }
-    }
-  }
-  textarea {
-    resize: vertical;
-  }
-  ::-webkit-search-decoration {
-    -webkit-appearance: none;
-  }
-  ::-webkit-date-and-time-value {
-    min-height: 1lh;
-    text-align: inherit;
-  }
-  ::-webkit-datetime-edit {
-    display: inline-flex;
-  }
-  ::-webkit-datetime-edit-fields-wrapper {
-    padding: 0;
-  }
-  ::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field {
-    padding-block: 0;
-  }
-  ::-webkit-calendar-picker-indicator {
-    line-height: 1;
-  }
-  :-moz-ui-invalid {
-    box-shadow: none;
-  }
-  button, input:where([type="button"], [type="reset"], [type="submit"]), ::file-selector-button {
-    appearance: button;
-  }
-  ::-webkit-inner-spin-button, ::-webkit-outer-spin-button {
-    height: auto;
-  }
-  [hidden]:where(:not([hidden="until-found"])) {
-    display: none !important;
-  }
-}
-@layer utilities {
-  .m-5 {
-    margin: calc(var(--spacing) * 5);
-  }
-  .mb-5 {
-    margin-bottom: calc(var(--spacing) * 5);
-  }
-  .flex {
-    display: flex;
-  }
-  .h-4 {
-    height: calc(var(--spacing) * 4);
-  }
-  .w-4 {
-    width: calc(var(--spacing) * 4);
-  }
-  .max-w-\[500px\] {
-    max-width: 500px;
-  }
-  .flex-1 {
-    flex: 1;
-  }
-  .cursor-pointer {
-    cursor: pointer;
-  }
-  .flex-col {
-    flex-direction: column;
-  }
-  .items-center {
-    align-items: center;
-  }
-  .gap-2 {
-    gap: calc(var(--spacing) * 2);
-  }
-  .gap-2\.5 {
-    gap: calc(var(--spacing) * 2.5);
-  }
-  .rounded {
-    border-radius: var(--radius);
-  }
-  .border {
-    border-style: var(--tw-border-style);
-    border-width: 1px;
-  }
-  .border-border {
-    border-color: var(--color-border);
-  }
-  .p-2 {
-    padding: calc(var(--spacing) * 2);
-  }
-  .px-2 {
-    padding-inline: calc(var(--spacing) * 2);
-  }
-  .px-4 {
-    padding-inline: calc(var(--spacing) * 4);
-  }
-  .py-1 {
-    padding-block: calc(var(--spacing) * 1);
-  }
-  .py-2 {
-    padding-block: calc(var(--spacing) * 2);
-  }
-  .font-sans {
-    font-family: var(--font-sans);
-  }
-  .text-2xl {
-    font-size: var(--text-2xl);
-    line-height: var(--tw-leading, var(--text-2xl--line-height));
-  }
-  .font-bold {
-    --tw-font-weight: var(--font-weight-bold);
-    font-weight: var(--font-weight-bold);
-  }
-  .text-red-500 {
-    color: var(--color-red-500);
-  }
-  .line-through {
-    text-decoration-line: line-through;
-  }
-  .opacity-70 {
-    opacity: 70%;
-  }
-}
-@property --tw-border-style {
-  syntax: "*";
-  inherits: false;
-  initial-value: solid;
-}
-@property --tw-font-weight {
-  syntax: "*";
-  inherits: false;
-}
-@layer properties {
-  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
-    *, ::before, ::after, ::backdrop {
-      --tw-border-style: solid;
-      --tw-font-weight: initial;
-    }
-  }
-}

From 35a98fe8e06d52ae3a7248bf241a7e77b9981472 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 2 Sep 2025 23:14:43 -0700
Subject: [PATCH 038/134] getting closer with the build...

---
 tsunami/build/build.go      | 171 +++++++++++++++++++++++++++++++-----
 tsunami/build/buildutil.go  |  16 ++++
 tsunami/cmd/main-tsunami.go |  72 ++++++++-------
 tsunami/go.mod              |   1 +
 tsunami/go.sum              |   2 +
 5 files changed, 210 insertions(+), 52 deletions(-)

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index b5dab84b75..3a1ce1622f 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -9,26 +9,33 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+
+	"golang.org/x/mod/modfile"
 )
 
 type BuildOpts struct {
-	Dir      string
-	Verbose  bool
-	DistPath string
+	Dir            string
+	Verbose        bool
+	DistPath       string
+	SdkReplacePath string
+}
+
+type BuildEnv struct {
+	GoVersion string
 }
 
-func verifyEnvironment(verbose bool) error {
+func verifyEnvironment(verbose bool) (*BuildEnv, error) {
 	// Check if go is in PATH
 	goPath, err := exec.LookPath("go")
 	if err != nil {
-		return fmt.Errorf("go command not found in PATH: %w", err)
+		return nil, fmt.Errorf("go command not found in PATH: %w", err)
 	}
 
 	// Run go version command
 	cmd := exec.Command(goPath, "version")
 	output, err := cmd.Output()
 	if err != nil {
-		return fmt.Errorf("failed to run 'go version': %w", err)
+		return nil, fmt.Errorf("failed to run 'go version': %w", err)
 	}
 
 	// Parse go version output and check for 1.21+
@@ -38,21 +45,30 @@ func verifyEnvironment(verbose bool) error {
 	}
 
 	// Extract version like "go1.21.0" from output
-	versionRegex := regexp.MustCompile(`go1\.(\d+)`)
+	versionRegex := regexp.MustCompile(`go(1\.\d+)`)
 	matches := versionRegex.FindStringSubmatch(versionStr)
 	if len(matches) < 2 {
-		return fmt.Errorf("unable to parse go version from: %s", versionStr)
+		return nil, fmt.Errorf("unable to parse go version from: %s", versionStr)
+	}
+
+	goVersion := matches[1]
+
+	// Check if version is 1.21+
+	minorRegex := regexp.MustCompile(`1\.(\d+)`)
+	minorMatches := minorRegex.FindStringSubmatch(goVersion)
+	if len(minorMatches) < 2 {
+		return nil, fmt.Errorf("unable to parse minor version from: %s", goVersion)
 	}
 
-	minor, err := strconv.Atoi(matches[1])
+	minor, err := strconv.Atoi(minorMatches[1])
 	if err != nil || minor < 21 {
-		return fmt.Errorf("go version 1.21 or higher required, found: %s", versionStr)
+		return nil, fmt.Errorf("go version 1.21 or higher required, found: %s", versionStr)
 	}
 
 	// Check if npx is in PATH
 	_, err = exec.LookPath("npx")
 	if err != nil {
-		return fmt.Errorf("npx command not found in PATH: %w", err)
+		return nil, fmt.Errorf("npx command not found in PATH: %w", err)
 	}
 
 	if verbose {
@@ -63,13 +79,13 @@ func verifyEnvironment(verbose bool) error {
 	tailwindCmd := exec.Command("npx", "@tailwindcss/cli")
 	tailwindOutput, err := tailwindCmd.CombinedOutput()
 	if err != nil {
-		return fmt.Errorf("failed to run 'npx @tailwindcss/cli': %w", err)
+		return nil, fmt.Errorf("failed to run 'npx @tailwindcss/cli': %w", err)
 	}
 
 	tailwindStr := strings.TrimSpace(string(tailwindOutput))
 	lines := strings.Split(tailwindStr, "\n")
 	if len(lines) == 0 {
-		return fmt.Errorf("no output from tailwindcss command")
+		return nil, fmt.Errorf("no output from tailwindcss command")
 	}
 
 	firstLine := lines[0]
@@ -79,14 +95,76 @@ func verifyEnvironment(verbose bool) error {
 
 	// Check for v4 (format: "≈ tailwindcss v4.1.12")
 	tailwindRegex := regexp.MustCompile(`tailwindcss v(\d+)`)
-	matches = tailwindRegex.FindStringSubmatch(firstLine)
-	if len(matches) < 2 {
-		return fmt.Errorf("unable to parse tailwindcss version from: %s", firstLine)
+	tailwindMatches := tailwindRegex.FindStringSubmatch(firstLine)
+	if len(tailwindMatches) < 2 {
+		return nil, fmt.Errorf("unable to parse tailwindcss version from: %s", firstLine)
 	}
 
-	majorVersion, err := strconv.Atoi(matches[1])
+	majorVersion, err := strconv.Atoi(tailwindMatches[1])
 	if err != nil || majorVersion != 4 {
-		return fmt.Errorf("tailwindcss v4 required, found: %s", firstLine)
+		return nil, fmt.Errorf("tailwindcss v4 required, found: %s", firstLine)
+	}
+
+	return &BuildEnv{GoVersion: goVersion}, nil
+}
+
+func createGoMod(tempDir, appDirName, goVersion string, opts BuildOpts, verbose bool) error {
+	modulePath := fmt.Sprintf("tsunami/app/%s", appDirName)
+
+	// Create new modfile
+	modFile := &modfile.File{}
+	if err := modFile.AddModuleStmt(modulePath); err != nil {
+		return fmt.Errorf("failed to add module statement: %w", err)
+	}
+
+	if err := modFile.AddGoStmt(goVersion); err != nil {
+		return fmt.Errorf("failed to add go version: %w", err)
+	}
+
+	// Add requirement for tsunami SDK
+	if err := modFile.AddRequire("github.com/wavetermdev/waveterm/tsunami", "v0.0.0"); err != nil {
+		return fmt.Errorf("failed to add require directive: %w", err)
+	}
+
+	// Add replace directive for tsunami SDK
+	if err := modFile.AddReplace("github.com/wavetermdev/waveterm/tsunami", "", opts.SdkReplacePath, ""); err != nil {
+		return fmt.Errorf("failed to add replace directive: %w", err)
+	}
+
+	// Format and write the file
+	modFile.Cleanup()
+	goModContent, err := modFile.Format()
+	if err != nil {
+		return fmt.Errorf("failed to format go.mod: %w", err)
+	}
+
+	goModPath := filepath.Join(tempDir, "go.mod")
+	if err := os.WriteFile(goModPath, goModContent, 0644); err != nil {
+		return fmt.Errorf("failed to write go.mod file: %w", err)
+	}
+
+	if verbose {
+		log.Printf("Created go.mod with module path: %s", modulePath)
+		log.Printf("Added require: github.com/wavetermdev/waveterm/tsunami v0.0.0")
+		log.Printf("Added replace directive: github.com/wavetermdev/waveterm/tsunami => %s", opts.SdkReplacePath)
+	}
+
+	// Run go mod tidy to clean up dependencies
+	tidyCmd := exec.Command("go", "mod", "tidy")
+	tidyCmd.Dir = tempDir
+
+	if verbose {
+		log.Printf("Running go mod tidy in %s", tempDir)
+	}
+
+	output, err := tidyCmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("failed to run go mod tidy: %w\nOutput: %s", err, string(output))
+	}
+
+	if verbose {
+		log.Printf("go mod tidy output:\n%s", string(output))
+		log.Printf("Successfully ran go mod tidy")
 	}
 
 	return nil
@@ -171,7 +249,8 @@ func verifyDistPath(distPath string) error {
 }
 
 func TsunamiBuild(opts BuildOpts) error {
-	if err := verifyEnvironment(opts.Verbose); err != nil {
+	buildEnv, err := verifyEnvironment(opts.Verbose)
+	if err != nil {
 		return err
 	}
 
@@ -224,11 +303,59 @@ func TsunamiBuild(opts BuildOpts) error {
 		return fmt.Errorf("failed to copy main.go.tmpl: %w", err)
 	}
 
+	// Create go.mod file
+	appDirName := filepath.Base(opts.Dir)
+	if err := createGoMod(tempDir, appDirName, buildEnv.GoVersion, opts, opts.Verbose); err != nil {
+		return fmt.Errorf("failed to create go.mod: %w", err)
+	}
+
 	// Generate Tailwind CSS
 	if err := generateAppTailwindCss(opts.DistPath, tempDir, opts.Verbose); err != nil {
 		return fmt.Errorf("failed to generate tailwind css: %w", err)
 	}
 
+	// Build the Go application
+	if err := runGoBuild(tempDir, opts.Verbose); err != nil {
+		return fmt.Errorf("failed to build application: %w", err)
+	}
+
+	return nil
+}
+
+func runGoBuild(tempDir string, verbose bool) error {
+	binDir := filepath.Join(tempDir, "bin")
+	if err := os.MkdirAll(binDir, 0755); err != nil {
+		return fmt.Errorf("failed to create bin directory: %w", err)
+	}
+
+	goFiles, err := listGoFilesInDir(tempDir)
+	if err != nil {
+		return fmt.Errorf("failed to list go files: %w", err)
+	}
+
+	if len(goFiles) == 0 {
+		return fmt.Errorf("no .go files found in %s", tempDir)
+	}
+
+	// Build command with explicit go files
+	args := append([]string{"build", "-o", "bin/app"}, goFiles...)
+	buildCmd := exec.Command("go", args...)
+	buildCmd.Dir = tempDir
+
+	if verbose {
+		log.Printf("Running: %s in %s", strings.Join(buildCmd.Args, " "), tempDir)
+		buildCmd.Stdout = os.Stdout
+		buildCmd.Stderr = os.Stderr
+	}
+
+	if err := buildCmd.Run(); err != nil {
+		return fmt.Errorf("failed to build application: %w", err)
+	}
+
+	if verbose {
+		log.Printf("Application built successfully at %s", filepath.Join(binDir, "app"))
+	}
+
 	return nil
 }
 
@@ -236,18 +363,18 @@ func generateAppTailwindCss(distPath, tempDir string, verbose bool) error {
 	tailwindInput := filepath.Join(distPath, "templates", "tailwind.css")
 	tailwindOutput := filepath.Join(tempDir, "static", "tw.css")
 	contentGlob := filepath.Join(tempDir, "*.go")
-	
+
 	tailwindCmd := exec.Command("npx", "@tailwindcss/cli",
 		"-i", tailwindInput,
 		"-o", tailwindOutput,
 		"--content", contentGlob)
-	
+
 	if verbose {
 		log.Printf("Running: %s", strings.Join(tailwindCmd.Args, " "))
 		tailwindCmd.Stdout = os.Stdout
 		tailwindCmd.Stderr = os.Stderr
 	}
-	
+
 	if err := tailwindCmd.Run(); err != nil {
 		return fmt.Errorf("failed to run tailwind command: %w", err)
 	}
diff --git a/tsunami/build/buildutil.go b/tsunami/build/buildutil.go
index 8e316b9ce5..9ef8dce67b 100644
--- a/tsunami/build/buildutil.go
+++ b/tsunami/build/buildutil.go
@@ -114,3 +114,19 @@ func copyFile(srcPath, destPath string) error {
 	// Set the same mode as source file
 	return os.Chmod(destPath, srcInfo.Mode())
 }
+
+func listGoFilesInDir(dirPath string) ([]string, error) {
+	entries, err := os.ReadDir(dirPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read directory %s: %w", dirPath, err)
+	}
+
+	var goFiles []string
+	for _, entry := range entries {
+		if !entry.IsDir() && filepath.Ext(entry.Name()) == ".go" {
+			goFiles = append(goFiles, entry.Name())
+		}
+	}
+
+	return goFiles, nil
+}
diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
index e13e524a6e..a8ca35f64b 100644
--- a/tsunami/cmd/main-tsunami.go
+++ b/tsunami/cmd/main-tsunami.go
@@ -28,51 +28,63 @@ var versionCmd = &cobra.Command{
 	},
 }
 
+func validateEnvironmentVars(opts *build.BuildOpts) error {
+	distPath := os.Getenv("TSUNAMI_DISTPATH")
+	if distPath == "" {
+		return fmt.Errorf("TSUNAMI_DISTPATH environment variable must be set")
+	}
+	
+	sdkReplacePath := os.Getenv("TSUNAMI_SDKREPLACEPATH")
+	if sdkReplacePath == "" {
+		return fmt.Errorf("TSUNAMI_SDKREPLACEPATH environment variable must be set")
+	}
+	
+	opts.DistPath = distPath
+	opts.SdkReplacePath = sdkReplacePath
+	return nil
+}
+
 var buildCmd = &cobra.Command{
-	Use:   "build [directory]",
-	Short: "Build a Tsunami application",
-	Long:  `Build a Tsunami application from the specified directory.`,
-	Args:  cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
+	Use:          "build [directory]",
+	Short:        "Build a Tsunami application",
+	Long:         `Build a Tsunami application from the specified directory.`,
+	Args:         cobra.ExactArgs(1),
+	SilenceUsage: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
 		verbose, _ := cmd.Flags().GetBool("verbose")
-		distPath := os.Getenv("TSUNAMI_DISTPATH")
-		if distPath == "" {
-			fmt.Printf("Error: TSUNAMI_DISTPATH environment variable must be set\n")
-			os.Exit(1)
-		}
 		opts := build.BuildOpts{
-			Dir:      args[0],
-			Verbose:  verbose,
-			DistPath: distPath,
+			Dir:     args[0],
+			Verbose: verbose,
+		}
+		if err := validateEnvironmentVars(&opts); err != nil {
+			return err
 		}
 		if err := build.TsunamiBuild(opts); err != nil {
-			fmt.Printf("Build failed: %v\n", err)
-			os.Exit(1)
+			return fmt.Errorf("build failed: %w", err)
 		}
+		return nil
 	},
 }
 
 var runCmd = &cobra.Command{
-	Use:   "run [directory]",
-	Short: "Build and run a Tsunami application",
-	Long:  `Build and run a Tsunami application from the specified directory.`,
-	Args:  cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
+	Use:          "run [directory]",
+	Short:        "Build and run a Tsunami application",
+	Long:         `Build and run a Tsunami application from the specified directory.`,
+	Args:         cobra.ExactArgs(1),
+	SilenceUsage: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
 		verbose, _ := cmd.Flags().GetBool("verbose")
-		distPath := os.Getenv("TSUNAMI_DISTPATH")
-		if distPath == "" {
-			fmt.Printf("Error: TSUNAMI_DISTPATH environment variable must be set\n")
-			os.Exit(1)
-		}
 		opts := build.BuildOpts{
-			Dir:      args[0],
-			Verbose:  verbose,
-			DistPath: distPath,
+			Dir:     args[0],
+			Verbose: verbose,
+		}
+		if err := validateEnvironmentVars(&opts); err != nil {
+			return err
 		}
 		if err := build.TsunamiRun(opts); err != nil {
-			fmt.Printf("Run failed: %v\n", err)
-			os.Exit(1)
+			return fmt.Errorf("run failed: %w", err)
 		}
+		return nil
 	},
 }
 
diff --git a/tsunami/go.mod b/tsunami/go.mod
index c197f7b4f1..a4de9dea20 100644
--- a/tsunami/go.mod
+++ b/tsunami/go.mod
@@ -7,6 +7,7 @@ require (
 	github.com/gorilla/mux v1.8.1
 	github.com/spf13/cobra v1.10.1
 	github.com/wavetermdev/htmltoken v0.2.0
+	golang.org/x/mod v0.27.0
 )
 
 require (
diff --git a/tsunami/go.sum b/tsunami/go.sum
index 63173da653..4f3b18dd07 100644
--- a/tsunami/go.sum
+++ b/tsunami/go.sum
@@ -12,6 +12,8 @@ github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/wavetermdev/htmltoken v0.2.0 h1:sFVPPemlDv7/jg7n4Hx1AEF2m9MVAFjFpELWfhi/DlM=
 github.com/wavetermdev/htmltoken v0.2.0/go.mod h1:5FM0XV6zNYiNza2iaTcFGj+hnMtgqumFHO31Z8euquk=
+golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
+golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
 golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
 golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

From bea4592dc8151ba1ac7aed583fda9e714ca8895b Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 09:15:28 -0700
Subject: [PATCH 039/134] progress on build, still fighting tailwind

---
 tsunami/app/defaultclient.go  | 14 ++---
 tsunami/app/serverhandlers.go | 98 ++++++++++++++++++++++++++++-------
 tsunami/app/tsunamiapp.go     |  2 +-
 tsunami/build/build.go        | 87 +++++++++++++++++++++----------
 tsunami/cmd/main-tsunami.go   |  2 +-
 tsunami/frontend/.gitignore   |  1 +
 6 files changed, 149 insertions(+), 55 deletions(-)
 create mode 100644 tsunami/frontend/.gitignore

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index c9b63b38c8..6cafc4b16c 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -5,15 +5,15 @@ package app
 
 import (
 	"context"
-	"embed"
+	"io/fs"
 	"net/http"
 
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
 var defaultClient = MakeClient(AppOpts{})
-var assetsFS *embed.FS
-var staticFS *embed.FS
+var assetsFS fs.FS
+var staticFS fs.FS
 var manifestFile *FileHandlerOption
 
 // Default client methods that operate on the global defaultClient
@@ -66,12 +66,12 @@ func RegisterFileHandler(path string, option FileHandlerOption) {
 	defaultClient.RegisterFileHandler(path, option)
 }
 
-func RegisterAssetsFS(fs embed.FS) {
-	assetsFS = &fs
+func RegisterAssetsFS(filesystem fs.FS) {
+	assetsFS = filesystem
 }
 
-func RegisterStaticFS(fs embed.FS) {
-	staticFS = &fs
+func RegisterStaticFS(filesystem fs.FS) {
+	staticFS = filesystem
 }
 
 func RegisterManifestFile(option FileHandlerOption) {
diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index efc52c6688..3ec489a9ba 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -4,10 +4,10 @@
 package app
 
 import (
-	"embed"
 	"encoding/json"
 	"fmt"
 	"io"
+	"io/fs"
 	"log"
 	"mime"
 	"net/http"
@@ -27,8 +27,8 @@ func init() {
 }
 
 type HandlerOpts struct {
-	AssetsFS     *embed.FS
-	StaticFS     *embed.FS
+	AssetsFS     fs.FS
+	StaticFS     fs.FS
 	ManifestFile *FileHandlerOption
 }
 
@@ -316,8 +316,39 @@ func (h *HTTPHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (h *HTTPHandlers) handleStaticFiles(embeddedFS *embed.FS) http.HandlerFunc {
-	// Create a file server from the embedded FS
+// serveFileDirectly serves a file directly from an embed.FS to avoid redirect loops
+// when serving directory paths that end with "/"
+func serveFileDirectly(w http.ResponseWriter, r *http.Request, embeddedFS fs.FS, requestPath, fileName string) bool {
+	if !strings.HasSuffix(requestPath, "/") {
+		return false
+	}
+	
+	// Try to serve the specified file from that directory
+	var filePath string
+	if requestPath == "/" {
+		filePath = fileName
+	} else {
+		filePath = strings.TrimPrefix(requestPath, "/") + fileName
+	}
+	
+	file, err := embeddedFS.Open(filePath)
+	if err != nil {
+		return false
+	}
+	defer file.Close()
+	
+	// Get file info for modification time
+	fileInfo, err := file.Stat()
+	if err != nil {
+		return false
+	}
+	
+	// Serve the file directly with proper mod time
+	http.ServeContent(w, r, fileName, fileInfo.ModTime(), file.(io.ReadSeeker))
+	return true
+}
+
+func (h *HTTPHandlers) handleStaticFiles(embeddedFS fs.FS) http.HandlerFunc {
 	fileServer := http.FileServer(http.FS(embeddedFS))
 
 	return func(w http.ResponseWriter, r *http.Request) {
@@ -328,18 +359,26 @@ func (h *HTTPHandlers) handleStaticFiles(embeddedFS *embed.FS) http.HandlerFunc
 			}
 		}()
 
-		// Skip if this is an API or files request (already handled by other handlers)
-		if strings.HasPrefix(r.URL.Path, "/api/") || strings.HasPrefix(r.URL.Path, "/files/") {
+		// Skip if this is an API, files, or static request (already handled by other handlers)
+		if strings.HasPrefix(r.URL.Path, "/api/") || strings.HasPrefix(r.URL.Path, "/files/") || strings.HasPrefix(r.URL.Path, "/static/") {
 			http.NotFound(w, r)
 			return
 		}
 
-		// Handle root "/" => "/index.html"
-		if r.URL.Path == "/" {
-			r.URL.Path = "/index.html"
+		// Handle any path ending with "/" to avoid redirect loops
+		if serveFileDirectly(w, r, embeddedFS, r.URL.Path, "index.html") {
+			return
+		}
+
+		// For other files, check if they exist before serving
+		filePath := strings.TrimPrefix(r.URL.Path, "/")
+		_, err := embeddedFS.Open(filePath)
+		if err != nil {
+			http.NotFound(w, r)
+			return
 		}
 
-		// Serve the file using Go's file server
+		// Serve the file using the file server
 		fileServer.ServeHTTP(w, r)
 	}
 }
@@ -367,10 +406,7 @@ func (h *HTTPHandlers) handleManifest(manifestFile *FileHandlerOption) http.Hand
 	}
 }
 
-func (h *HTTPHandlers) handleStaticPathFiles(staticFS *embed.FS) http.HandlerFunc {
-	// Create a file server from the embedded FS
-	fileServer := http.FileServer(http.FS(staticFS))
-
+func (h *HTTPHandlers) handleStaticPathFiles(staticFS fs.FS) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		defer func() {
 			panicErr := util.PanicHandler("handleStaticPathFiles", recover())
@@ -380,12 +416,36 @@ func (h *HTTPHandlers) handleStaticPathFiles(staticFS *embed.FS) http.HandlerFun
 		}()
 
 		// Strip /static/ prefix from the path
-		r.URL.Path = strings.TrimPrefix(r.URL.Path, "/static")
-		if r.URL.Path == "" {
-			r.URL.Path = "/"
+		filePath := strings.TrimPrefix(r.URL.Path, "/static/")
+		if filePath == "" {
+			// Handle requests to "/static/" directly
+			if serveFileDirectly(w, r, staticFS, "/", "index.html") {
+				return
+			}
+			http.NotFound(w, r)
+			return
+		}
+
+		// Handle directory paths ending with "/" to avoid redirect loops
+		strippedPath := "/" + filePath
+		if serveFileDirectly(w, r, staticFS, strippedPath, "index.html") {
+			return
+		}
+
+		// Check if file exists in staticFS
+		_, err := staticFS.Open(filePath)
+		if err != nil {
+			http.NotFound(w, r)
+			return
 		}
 
-		// Serve the file using Go's file server
+		// Create a file server and serve the file
+		fileServer := http.FileServer(http.FS(staticFS))
+
+		// Temporarily modify the URL path for the file server
+		originalPath := r.URL.Path
+		r.URL.Path = "/" + filePath
 		fileServer.ServeHTTP(w, r)
+		r.URL.Path = originalPath
 	}
 }
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index efba12cc5d..bdeb2ad182 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -195,7 +195,7 @@ func (c *Client) listenAndServe(ctx context.Context) error {
 
 	// Log the port we're listening on
 	port := listener.Addr().(*net.TCPAddr).Port
-	log.Printf("Wave app server listening on port %d", port)
+	log.Printf("[tsunami] listening on port %d", port)
 
 	// Serve in a goroutine so we don't block
 	go func() {
diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 3a1ce1622f..8e7027fdab 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -22,6 +22,7 @@ type BuildOpts struct {
 
 type BuildEnv struct {
 	GoVersion string
+	TempDir   string
 }
 
 func verifyEnvironment(verbose bool) (*BuildEnv, error) {
@@ -154,16 +155,16 @@ func createGoMod(tempDir, appDirName, goVersion string, opts BuildOpts, verbose
 	tidyCmd.Dir = tempDir
 
 	if verbose {
-		log.Printf("Running go mod tidy in %s", tempDir)
+		log.Printf("Running go mod tidy")
+		tidyCmd.Stdout = os.Stdout
+		tidyCmd.Stderr = os.Stderr
 	}
 
-	output, err := tidyCmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("failed to run go mod tidy: %w\nOutput: %s", err, string(output))
+	if err := tidyCmd.Run(); err != nil {
+		return fmt.Errorf("failed to run go mod tidy: %w", err)
 	}
 
 	if verbose {
-		log.Printf("go mod tidy output:\n%s", string(output))
 		log.Printf("Successfully ran go mod tidy")
 	}
 
@@ -248,26 +249,28 @@ func verifyDistPath(distPath string) error {
 	return nil
 }
 
-func TsunamiBuild(opts BuildOpts) error {
+func TsunamiBuild(opts BuildOpts) (*BuildEnv, error) {
 	buildEnv, err := verifyEnvironment(opts.Verbose)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	if err := verifyTsunamiDir(opts.Dir); err != nil {
-		return err
+		return nil, err
 	}
 
 	if err := verifyDistPath(opts.DistPath); err != nil {
-		return err
+		return nil, err
 	}
 
 	// Create temporary directory
 	tempDir, err := os.MkdirTemp("", "tsunami-build-*")
 	if err != nil {
-		return fmt.Errorf("failed to create temp directory: %w", err)
+		return nil, fmt.Errorf("failed to create temp directory: %w", err)
 	}
 
+	buildEnv.TempDir = tempDir
+
 	log.Printf("Building tsunami app from %s\n", opts.Dir)
 
 	if opts.Verbose {
@@ -277,49 +280,55 @@ func TsunamiBuild(opts BuildOpts) error {
 	// Copy all *.go files from the root directory
 	goCount, err := copyGoFiles(opts.Dir, tempDir)
 	if err != nil {
-		return fmt.Errorf("failed to copy go files: %w", err)
+		return nil, fmt.Errorf("failed to copy go files: %w", err)
 	}
 
 	// Copy static directory
 	staticCount, err := copyStaticDir(opts.Dir, tempDir)
 	if err != nil {
-		return fmt.Errorf("failed to copy static directory: %w", err)
+		return nil, fmt.Errorf("failed to copy static directory: %w", err)
 	}
 
 	// Create dist directory
 	distDir := filepath.Join(tempDir, "dist")
 	if err := os.MkdirAll(distDir, 0755); err != nil {
-		return fmt.Errorf("failed to create dist directory: %w", err)
+		return nil, fmt.Errorf("failed to create dist directory: %w", err)
+	}
+
+	// Copy dist directory contents
+	distCount, err := copyDirRecursive(opts.DistPath, distDir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to copy dist directory: %w", err)
 	}
 
 	if opts.Verbose {
-		log.Printf("Copied %d go files, %d static files\n", goCount, staticCount)
+		log.Printf("Copied %d go files, %d static files, %d dist files\n", goCount, staticCount, distCount)
 	}
 
 	// Copy main.go.tmpl from dist/templates to temp dir as main-app.go
 	mainTmplSrc := filepath.Join(opts.DistPath, "templates", "main.go.tmpl")
 	mainTmplDest := filepath.Join(tempDir, "main-app.go")
 	if err := copyFile(mainTmplSrc, mainTmplDest); err != nil {
-		return fmt.Errorf("failed to copy main.go.tmpl: %w", err)
+		return nil, fmt.Errorf("failed to copy main.go.tmpl: %w", err)
 	}
 
 	// Create go.mod file
 	appDirName := filepath.Base(opts.Dir)
 	if err := createGoMod(tempDir, appDirName, buildEnv.GoVersion, opts, opts.Verbose); err != nil {
-		return fmt.Errorf("failed to create go.mod: %w", err)
+		return nil, fmt.Errorf("failed to create go.mod: %w", err)
 	}
 
 	// Generate Tailwind CSS
 	if err := generateAppTailwindCss(opts.DistPath, tempDir, opts.Verbose); err != nil {
-		return fmt.Errorf("failed to generate tailwind css: %w", err)
+		return nil, fmt.Errorf("failed to generate tailwind css: %w", err)
 	}
 
 	// Build the Go application
 	if err := runGoBuild(tempDir, opts.Verbose); err != nil {
-		return fmt.Errorf("failed to build application: %w", err)
+		return nil, fmt.Errorf("failed to build application: %w", err)
 	}
 
-	return nil
+	return buildEnv, nil
 }
 
 func runGoBuild(tempDir string, verbose bool) error {
@@ -343,7 +352,7 @@ func runGoBuild(tempDir string, verbose bool) error {
 	buildCmd.Dir = tempDir
 
 	if verbose {
-		log.Printf("Running: %s in %s", strings.Join(buildCmd.Args, " "), tempDir)
+		log.Printf("Running: %s", strings.Join(buildCmd.Args, " "))
 		buildCmd.Stdout = os.Stdout
 		buildCmd.Stderr = os.Stderr
 	}
@@ -360,14 +369,19 @@ func runGoBuild(tempDir string, verbose bool) error {
 }
 
 func generateAppTailwindCss(distPath, tempDir string, verbose bool) error {
-	tailwindInput := filepath.Join(distPath, "templates", "tailwind.css")
+	// Copy tailwind.css from dist/templates to temp dir
+	tailwindSrc := filepath.Join(distPath, "templates", "tailwind.css")
+	tailwindDest := filepath.Join(tempDir, "tailwind.css")
+	if err := copyFile(tailwindSrc, tailwindDest); err != nil {
+		return fmt.Errorf("failed to copy tailwind.css: %w", err)
+	}
+
 	tailwindOutput := filepath.Join(tempDir, "static", "tw.css")
-	contentGlob := filepath.Join(tempDir, "*.go")
 
 	tailwindCmd := exec.Command("npx", "@tailwindcss/cli",
-		"-i", tailwindInput,
-		"-o", tailwindOutput,
-		"--content", contentGlob)
+		"-i", "./tailwind.css",
+		"-o", tailwindOutput)
+	tailwindCmd.Dir = tempDir
 
 	if verbose {
 		log.Printf("Running: %s", strings.Join(tailwindCmd.Args, " "))
@@ -429,9 +443,28 @@ func copyGoFiles(srcDir, destDir string) (int, error) {
 }
 
 func TsunamiRun(opts BuildOpts) error {
-	if err := TsunamiBuild(opts); err != nil {
+	buildEnv, err := TsunamiBuild(opts)
+	if err != nil {
 		return err
 	}
 
-	return fmt.Errorf("TsunamiRun not implemented yet")
+	// Run the built application
+	appPath := filepath.Join(buildEnv.TempDir, "bin", "app")
+	runCmd := exec.Command(appPath)
+	runCmd.Dir = buildEnv.TempDir
+
+	log.Printf("Running tsunami app from %s", opts.Dir)
+
+	runCmd.Stdin = os.Stdin
+	if opts.Verbose {
+		log.Printf("Executing: %s", appPath)
+		runCmd.Stdout = os.Stdout
+		runCmd.Stderr = os.Stderr
+	}
+
+	if err := runCmd.Run(); err != nil {
+		return fmt.Errorf("failed to run application: %w", err)
+	}
+
+	return nil
 }
diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
index a8ca35f64b..ea5029cc04 100644
--- a/tsunami/cmd/main-tsunami.go
+++ b/tsunami/cmd/main-tsunami.go
@@ -59,7 +59,7 @@ var buildCmd = &cobra.Command{
 		if err := validateEnvironmentVars(&opts); err != nil {
 			return err
 		}
-		if err := build.TsunamiBuild(opts); err != nil {
+		if _, err := build.TsunamiBuild(opts); err != nil {
 			return fmt.Errorf("build failed: %w", err)
 		}
 		return nil
diff --git a/tsunami/frontend/.gitignore b/tsunami/frontend/.gitignore
new file mode 100644
index 0000000000..f1f6cef32c
--- /dev/null
+++ b/tsunami/frontend/.gitignore
@@ -0,0 +1 @@
+scaffold/
\ No newline at end of file

From b5ac1541ab1146e38ee87e75d274220f084e12fe Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 10:53:36 -0700
Subject: [PATCH 040/134] build/run working!

---
 Taskfile.yml                       |  25 ++++
 tsunami/.gitignore                 |   1 +
 tsunami/app/tsunamiapp.go          |   4 +-
 tsunami/build/build.go             | 190 +++++++++++++++++++----------
 tsunami/build/buildutil.go         | 100 ++++++++++++++-
 tsunami/cmd/main-tsunami.go        |  11 +-
 tsunami/frontend/index.html        |   1 +
 tsunami/templates/app-main.go.tmpl |  22 ++++
 tsunami/templates/gitignore.tmpl   |   3 +
 tsunami/templates/tailwind.css     |  60 +++++++++
 tsunami/util/util.go               |  25 ++++
 11 files changed, 367 insertions(+), 75 deletions(-)
 create mode 100644 tsunami/.gitignore
 create mode 100644 tsunami/templates/app-main.go.tmpl
 create mode 100644 tsunami/templates/gitignore.tmpl
 create mode 100644 tsunami/templates/tailwind.css

diff --git a/Taskfile.yml b/Taskfile.yml
index f3d3a1815b..4b3c8d7833 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -451,6 +451,31 @@ tasks:
         cmd: npm run dev
         dir: tsunami/frontend
 
+    tsunami:frontend:build:
+        desc: Build the tsunami frontend
+        cmd: yarn build
+        dir: tsunami/frontend
+
+    tsunami:scaffold:
+        desc: Build scaffold for tsunami frontend development
+        dir: tsunami/frontend
+        deps:
+            - tsunami:frontend:build
+        cmds:
+            - cmd: "{{.RMRF}} scaffold"
+              ignore_error: true
+            - mkdir scaffold
+            - cd scaffold && npm --no-workspaces init -y --init-license Apache-2.0
+            - cd scaffold && npm pkg set name=tsunami-scaffold
+            - cd scaffold && npm pkg delete author
+            - cd scaffold && npm pkg set author.name="Command Line Inc"
+            - cd scaffold && npm pkg set author.email="info@commandline.dev"
+            - cd scaffold && npm --no-workspaces install tailwindcss @tailwindcss/cli
+            - cp -r dist scaffold/
+            - cp ../templates/app-main.go.tmpl scaffold/app-main.go
+            - cp ../templates/tailwind.css scaffold/
+            - cp ../templates/gitignore.tmpl scaffold/.gitignore
+
     tsunami:build:
         desc: Build the tsunami binary.
         cmds:
diff --git a/tsunami/.gitignore b/tsunami/.gitignore
new file mode 100644
index 0000000000..6dd29b7f8d
--- /dev/null
+++ b/tsunami/.gitignore
@@ -0,0 +1 @@
+bin/
\ No newline at end of file
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index bdeb2ad182..486dce6381 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -193,9 +193,9 @@ func (c *Client) listenAndServe(ctx context.Context) error {
 		return fmt.Errorf("failed to listen: %v", err)
 	}
 
-	// Log the port we're listening on
+	// Log the address we're listening on
 	port := listener.Addr().(*net.TCPAddr).Port
-	log.Printf("[tsunami] listening on port %d", port)
+	log.Printf("[tsunami] listening at http://localhost:%d", port)
 
 	// Serve in a goroutine so we don't block
 	go func() {
diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 8e7027fdab..85e4cea068 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -1,7 +1,9 @@
 package build
 
 import (
+	"bufio"
 	"fmt"
+	"io"
 	"log"
 	"os"
 	"os/exec"
@@ -9,14 +11,17 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"time"
 
+	"github.com/wavetermdev/waveterm/tsunami/util"
 	"golang.org/x/mod/modfile"
 )
 
 type BuildOpts struct {
 	Dir            string
 	Verbose        bool
-	DistPath       string
+	Open           bool
+	ScaffoldPath   string
 	SdkReplacePath string
 }
 
@@ -210,40 +215,60 @@ func verifyTsunamiDir(dir string) error {
 	return nil
 }
 
-func verifyDistPath(distPath string) error {
-	if distPath == "" {
-		return fmt.Errorf("distPath cannot be empty")
+func verifyScaffoldPath(scaffoldPath string) error {
+	if scaffoldPath == "" {
+		return fmt.Errorf("scaffoldPath cannot be empty")
 	}
 
 	// Check if directory exists
-	info, err := os.Stat(distPath)
+	info, err := os.Stat(scaffoldPath)
 	if err != nil {
 		if os.IsNotExist(err) {
-			return fmt.Errorf("distPath directory %q does not exist", distPath)
+			return fmt.Errorf("scaffoldPath directory %q does not exist", scaffoldPath)
 		}
-		return fmt.Errorf("error accessing distPath directory %q: %w", distPath, err)
+		return fmt.Errorf("error accessing scaffoldPath directory %q: %w", scaffoldPath, err)
 	}
 
 	if !info.IsDir() {
-		return fmt.Errorf("distPath %q is not a directory", distPath)
+		return fmt.Errorf("scaffoldPath %q is not a directory", scaffoldPath)
 	}
 
-	// Check for index.html file
-	indexPath := filepath.Join(distPath, "index.html")
-	if err := CheckFileExists(indexPath); err != nil {
-		return fmt.Errorf("index.html check failed in distPath %q: %w", distPath, err)
+	// Check for dist directory
+	distPath := filepath.Join(scaffoldPath, "dist")
+	if err := IsDirOrNotFound(distPath); err != nil {
+		return fmt.Errorf("dist directory check failed in scaffoldPath %q: %w", scaffoldPath, err)
+	}
+	info, err = os.Stat(distPath)
+	if err != nil || !info.IsDir() {
+		return fmt.Errorf("dist directory must exist in scaffoldPath %q", scaffoldPath)
+	}
+
+	// Check for app-main.go file
+	appMainPath := filepath.Join(scaffoldPath, "app-main.go")
+	if err := CheckFileExists(appMainPath); err != nil {
+		return fmt.Errorf("app-main.go check failed in scaffoldPath %q: %w", scaffoldPath, err)
 	}
 
-	// Check for templates/tailwind.css file
-	tailwindPath := filepath.Join(distPath, "templates", "tailwind.css")
+	// Check for tailwind.css file
+	tailwindPath := filepath.Join(scaffoldPath, "tailwind.css")
 	if err := CheckFileExists(tailwindPath); err != nil {
-		return fmt.Errorf("templates/tailwind.css check failed in distPath %q: %w", distPath, err)
+		return fmt.Errorf("tailwind.css check failed in scaffoldPath %q: %w", scaffoldPath, err)
 	}
 
-	// Check for templates/main.go.tmpl file
-	mainTmplPath := filepath.Join(distPath, "templates", "main.go.tmpl")
-	if err := CheckFileExists(mainTmplPath); err != nil {
-		return fmt.Errorf("templates/main.go.tmpl check failed in distPath %q: %w", distPath, err)
+	// Check for package.json file
+	packageJsonPath := filepath.Join(scaffoldPath, "package.json")
+	if err := CheckFileExists(packageJsonPath); err != nil {
+		return fmt.Errorf("package.json check failed in scaffoldPath %q: %w", scaffoldPath, err)
+	}
+
+	// Check for node_modules directory
+	nodeModulesPath := filepath.Join(scaffoldPath, "node_modules")
+	if err := IsDirOrNotFound(nodeModulesPath); err != nil {
+		return fmt.Errorf("node_modules directory check failed in scaffoldPath %q: %w", scaffoldPath, err)
+	}
+	info, err = os.Stat(nodeModulesPath)
+	if err != nil || !info.IsDir() {
+		return fmt.Errorf("node_modules directory must exist in scaffoldPath %q", scaffoldPath)
 	}
 
 	return nil
@@ -259,7 +284,7 @@ func TsunamiBuild(opts BuildOpts) (*BuildEnv, error) {
 		return nil, err
 	}
 
-	if err := verifyDistPath(opts.DistPath); err != nil {
+	if err := verifyScaffoldPath(opts.ScaffoldPath); err != nil {
 		return nil, err
 	}
 
@@ -284,32 +309,28 @@ func TsunamiBuild(opts BuildOpts) (*BuildEnv, error) {
 	}
 
 	// Copy static directory
-	staticCount, err := copyStaticDir(opts.Dir, tempDir)
+	staticSrcDir := filepath.Join(opts.Dir, "static")
+	staticDestDir := filepath.Join(tempDir, "static")
+	staticCount, err := copyDirRecursive(staticSrcDir, staticDestDir, true)
 	if err != nil {
 		return nil, fmt.Errorf("failed to copy static directory: %w", err)
 	}
 
-	// Create dist directory
-	distDir := filepath.Join(tempDir, "dist")
-	if err := os.MkdirAll(distDir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create dist directory: %w", err)
-	}
-
-	// Copy dist directory contents
-	distCount, err := copyDirRecursive(opts.DistPath, distDir)
+	// Copy scaffold directory contents selectively
+	scaffoldCount, err := copyScaffoldSelective(opts.ScaffoldPath, tempDir)
 	if err != nil {
-		return nil, fmt.Errorf("failed to copy dist directory: %w", err)
+		return nil, fmt.Errorf("failed to copy scaffold directory: %w", err)
 	}
 
 	if opts.Verbose {
-		log.Printf("Copied %d go files, %d static files, %d dist files\n", goCount, staticCount, distCount)
+		log.Printf("Copied %d go files, %d static files, %d scaffold files\n", goCount, staticCount, scaffoldCount)
 	}
 
-	// Copy main.go.tmpl from dist/templates to temp dir as main-app.go
-	mainTmplSrc := filepath.Join(opts.DistPath, "templates", "main.go.tmpl")
-	mainTmplDest := filepath.Join(tempDir, "main-app.go")
-	if err := copyFile(mainTmplSrc, mainTmplDest); err != nil {
-		return nil, fmt.Errorf("failed to copy main.go.tmpl: %w", err)
+	// Copy app-main.go from scaffold to main-app.go in temp dir
+	appMainSrc := filepath.Join(tempDir, "app-main.go")
+	appMainDest := filepath.Join(tempDir, "main-app.go")
+	if err := os.Rename(appMainSrc, appMainDest); err != nil {
+		return nil, fmt.Errorf("failed to rename app-main.go to main-app.go: %w", err)
 	}
 
 	// Create go.mod file
@@ -319,7 +340,7 @@ func TsunamiBuild(opts BuildOpts) (*BuildEnv, error) {
 	}
 
 	// Generate Tailwind CSS
-	if err := generateAppTailwindCss(opts.DistPath, tempDir, opts.Verbose); err != nil {
+	if err := generateAppTailwindCss(tempDir, opts.Verbose); err != nil {
 		return nil, fmt.Errorf("failed to generate tailwind css: %w", err)
 	}
 
@@ -368,14 +389,8 @@ func runGoBuild(tempDir string, verbose bool) error {
 	return nil
 }
 
-func generateAppTailwindCss(distPath, tempDir string, verbose bool) error {
-	// Copy tailwind.css from dist/templates to temp dir
-	tailwindSrc := filepath.Join(distPath, "templates", "tailwind.css")
-	tailwindDest := filepath.Join(tempDir, "tailwind.css")
-	if err := copyFile(tailwindSrc, tailwindDest); err != nil {
-		return fmt.Errorf("failed to copy tailwind.css: %w", err)
-	}
-
+func generateAppTailwindCss(tempDir string, verbose bool) error {
+	// tailwind.css is already in tempDir from scaffold copy
 	tailwindOutput := filepath.Join(tempDir, "static", "tw.css")
 
 	tailwindCmd := exec.Command("npx", "@tailwindcss/cli",
@@ -400,22 +415,6 @@ func generateAppTailwindCss(distPath, tempDir string, verbose bool) error {
 	return nil
 }
 
-func copyStaticDir(srcDir, destDir string) (int, error) {
-	// Always create static directory in temp dir
-	staticDestDir := filepath.Join(destDir, "static")
-	if err := os.MkdirAll(staticDestDir, 0755); err != nil {
-		return 0, fmt.Errorf("failed to create static directory: %w", err)
-	}
-
-	// Copy static/ directory contents if it exists
-	staticSrcDir := filepath.Join(srcDir, "static")
-	if _, err := os.Stat(staticSrcDir); err == nil {
-		return copyDirRecursive(staticSrcDir, staticDestDir)
-	}
-
-	return 0, nil
-}
-
 func copyGoFiles(srcDir, destDir string) (int, error) {
 	entries, err := os.ReadDir(srcDir)
 	if err != nil {
@@ -456,15 +455,72 @@ func TsunamiRun(opts BuildOpts) error {
 	log.Printf("Running tsunami app from %s", opts.Dir)
 
 	runCmd.Stdin = os.Stdin
-	if opts.Verbose {
-		log.Printf("Executing: %s", appPath)
+
+	if opts.Open {
+		// If --open flag is set, we need to capture stderr to parse the listening message
+		stderr, err := runCmd.StderrPipe()
+		if err != nil {
+			return fmt.Errorf("failed to create stderr pipe: %w", err)
+		}
 		runCmd.Stdout = os.Stdout
-		runCmd.Stderr = os.Stderr
-	}
 
-	if err := runCmd.Run(); err != nil {
-		return fmt.Errorf("failed to run application: %w", err)
+		if err := runCmd.Start(); err != nil {
+			return fmt.Errorf("failed to start application: %w", err)
+		}
+
+		// Monitor stderr for the listening message
+		go monitorAndOpenBrowser(stderr, opts.Verbose)
+
+		if err := runCmd.Wait(); err != nil {
+			return fmt.Errorf("application exited with error: %w", err)
+		}
+	} else {
+		// Normal execution without browser opening
+		if opts.Verbose {
+			log.Printf("Executing: %s", appPath)
+			runCmd.Stdout = os.Stdout
+			runCmd.Stderr = os.Stderr
+		}
+
+		if err := runCmd.Run(); err != nil {
+			return fmt.Errorf("failed to run application: %w", err)
+		}
 	}
 
 	return nil
 }
+
+func monitorAndOpenBrowser(stdout io.ReadCloser, verbose bool) {
+	defer stdout.Close()
+
+	scanner := bufio.NewScanner(stdout)
+	urlRegex := regexp.MustCompile(`\[tsunami\] listening at (http://[^\s]+)`)
+	browserOpened := false
+	if verbose {
+		log.Printf("monitoring for browser open\n")
+	}
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		if verbose {
+			log.Println(line)
+		}
+
+		if !browserOpened && len(urlRegex.FindStringSubmatch(line)) > 1 {
+			matches := urlRegex.FindStringSubmatch(line)
+			url := matches[1]
+			if verbose {
+				log.Printf("Opening browser to %s", url)
+			}
+			go util.OpenBrowser(url, 100*time.Millisecond)
+			browserOpened = true
+		}
+	}
+
+	// Continue reading and printing output if verbose
+	if verbose {
+		for scanner.Scan() {
+			log.Println(scanner.Text())
+		}
+	}
+}
diff --git a/tsunami/build/buildutil.go b/tsunami/build/buildutil.go
index 9ef8dce67b..3ad35233e0 100644
--- a/tsunami/build/buildutil.go
+++ b/tsunami/build/buildutil.go
@@ -48,9 +48,29 @@ func FileMustNotExist(path string) error {
 	return nil // Not found is OK
 }
 
-func copyDirRecursive(srcDir, destDir string) (int, error) {
+func copyDirRecursive(srcDir, destDir string, forceCreateDestDir bool) (int, error) {
+	// Check if source directory exists
+	srcInfo, err := os.Stat(srcDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			if forceCreateDestDir {
+				// Create destination directory even if source doesn't exist
+				if err := os.MkdirAll(destDir, 0755); err != nil {
+					return 0, fmt.Errorf("failed to create destination directory %s: %w", destDir, err)
+				}
+			}
+			return 0, nil // Source doesn't exist, return 0 files copied
+		}
+		return 0, fmt.Errorf("error accessing source directory %s: %w", srcDir, err)
+	}
+
+	// Check if source is actually a directory
+	if !srcInfo.IsDir() {
+		return 0, fmt.Errorf("source %s is not a directory", srcDir)
+	}
+
 	fileCount := 0
-	err := filepath.Walk(srcDir, func(path string, info os.FileInfo, err error) error {
+	err = filepath.Walk(srcDir, func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
 		}
@@ -130,3 +150,79 @@ func listGoFilesInDir(dirPath string) ([]string, error) {
 
 	return goFiles, nil
 }
+
+func copyScaffoldSelective(scaffoldPath, destDir string) (int, error) {
+	fileCount := 0
+
+	// Create symlinks for node_modules directory
+	symlinkItems := []string{"node_modules"}
+	for _, item := range symlinkItems {
+		srcPath := filepath.Join(scaffoldPath, item)
+		destPath := filepath.Join(destDir, item)
+
+		// Check if source exists
+		if _, err := os.Stat(srcPath); err != nil {
+			if os.IsNotExist(err) {
+				continue // Skip if doesn't exist
+			}
+			return 0, fmt.Errorf("error checking %s: %w", item, err)
+		}
+
+		// Create symlink
+		if err := os.Symlink(srcPath, destPath); err != nil {
+			return 0, fmt.Errorf("failed to create symlink for %s: %w", item, err)
+		}
+		fileCount++
+	}
+
+	// Copy package files instead of symlinking
+	packageFiles := []string{"package.json", "package-lock.json"}
+	for _, fileName := range packageFiles {
+		srcPath := filepath.Join(scaffoldPath, fileName)
+		destPath := filepath.Join(destDir, fileName)
+
+		// Check if source exists
+		if _, err := os.Stat(srcPath); err != nil {
+			if os.IsNotExist(err) {
+				continue // Skip if doesn't exist
+			}
+			return 0, fmt.Errorf("error checking %s: %w", fileName, err)
+		}
+
+		// Copy file
+		if err := copyFile(srcPath, destPath); err != nil {
+			return 0, fmt.Errorf("failed to copy %s: %w", fileName, err)
+		}
+		fileCount++
+	}
+
+	// Copy dist directory that needs to be fully copied for go embed
+	distSrcPath := filepath.Join(scaffoldPath, "dist")
+	distDestPath := filepath.Join(destDir, "dist")
+	dirCount, err := copyDirRecursive(distSrcPath, distDestPath, false)
+	if err != nil {
+		return 0, fmt.Errorf("failed to copy dist directory: %w", err)
+	}
+	fileCount += dirCount
+
+	// Copy files by pattern (*.go, *.md, *.json, tailwind.css)
+	patterns := []string{"*.go", "*.md", "*.json", "tailwind.css"}
+	for _, pattern := range patterns {
+		matches, err := filepath.Glob(filepath.Join(scaffoldPath, pattern))
+		if err != nil {
+			return 0, fmt.Errorf("failed to glob pattern %s: %w", pattern, err)
+		}
+
+		for _, srcPath := range matches {
+			fileName := filepath.Base(srcPath)
+			destPath := filepath.Join(destDir, fileName)
+
+			if err := copyFile(srcPath, destPath); err != nil {
+				return 0, fmt.Errorf("failed to copy %s: %w", fileName, err)
+			}
+			fileCount++
+		}
+	}
+
+	return fileCount, nil
+}
diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
index ea5029cc04..c960f406fe 100644
--- a/tsunami/cmd/main-tsunami.go
+++ b/tsunami/cmd/main-tsunami.go
@@ -29,9 +29,9 @@ var versionCmd = &cobra.Command{
 }
 
 func validateEnvironmentVars(opts *build.BuildOpts) error {
-	distPath := os.Getenv("TSUNAMI_DISTPATH")
-	if distPath == "" {
-		return fmt.Errorf("TSUNAMI_DISTPATH environment variable must be set")
+	scaffoldPath := os.Getenv("TSUNAMI_SCAFFOLDPATH")
+	if scaffoldPath == "" {
+		return fmt.Errorf("TSUNAMI_SCAFFOLDPATH environment variable must be set")
 	}
 	
 	sdkReplacePath := os.Getenv("TSUNAMI_SDKREPLACEPATH")
@@ -39,7 +39,7 @@ func validateEnvironmentVars(opts *build.BuildOpts) error {
 		return fmt.Errorf("TSUNAMI_SDKREPLACEPATH environment variable must be set")
 	}
 	
-	opts.DistPath = distPath
+	opts.ScaffoldPath = scaffoldPath
 	opts.SdkReplacePath = sdkReplacePath
 	return nil
 }
@@ -74,9 +74,11 @@ var runCmd = &cobra.Command{
 	SilenceUsage: true,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		verbose, _ := cmd.Flags().GetBool("verbose")
+		open, _ := cmd.Flags().GetBool("open")
 		opts := build.BuildOpts{
 			Dir:     args[0],
 			Verbose: verbose,
+			Open:    open,
 		}
 		if err := validateEnvironmentVars(&opts); err != nil {
 			return err
@@ -95,6 +97,7 @@ func init() {
 	rootCmd.AddCommand(buildCmd)
 
 	runCmd.Flags().BoolP("verbose", "v", false, "Enable verbose output")
+	runCmd.Flags().Bool("open", false, "Open the application in the browser after starting")
 	rootCmd.AddCommand(runCmd)
 }
 
diff --git a/tsunami/frontend/index.html b/tsunami/frontend/index.html
index 80e4e5b3ed..99ed1d7f3d 100644
--- a/tsunami/frontend/index.html
+++ b/tsunami/frontend/index.html
@@ -4,6 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Tsunami App</title>
+    <link rel="icon" href="public/wave-logo-256.png" />
   </head>
   <body className="bg-background text-primary">
     <div id="root"></div>
diff --git a/tsunami/templates/app-main.go.tmpl b/tsunami/templates/app-main.go.tmpl
new file mode 100644
index 0000000000..5111095cbd
--- /dev/null
+++ b/tsunami/templates/app-main.go.tmpl
@@ -0,0 +1,22 @@
+package main
+
+import (
+	"embed"
+	"io/fs"
+
+	"github.com/wavetermdev/waveterm/tsunami/app"
+)
+
+//go:embed dist/**
+var distFS embed.FS
+
+//go:embed static/**
+var staticFS embed.FS
+
+func main() {
+	subDistFS, _ := fs.Sub(distFS, "dist")
+	app.RegisterAssetsFS(subDistFS)
+	subStaticFS, _ := fs.Sub(staticFS, "static")
+	app.RegisterStaticFS(subStaticFS)
+	app.RunMain()
+}
diff --git a/tsunami/templates/gitignore.tmpl b/tsunami/templates/gitignore.tmpl
new file mode 100644
index 0000000000..e45080f05f
--- /dev/null
+++ b/tsunami/templates/gitignore.tmpl
@@ -0,0 +1,3 @@
+dist/
+node_modules/
+bin/
\ No newline at end of file
diff --git a/tsunami/templates/tailwind.css b/tsunami/templates/tailwind.css
new file mode 100644
index 0000000000..1bc07b3ca6
--- /dev/null
+++ b/tsunami/templates/tailwind.css
@@ -0,0 +1,60 @@
+/* Copyright 2025, Command Line Inc. */
+/* SPDX-License-Identifier: Apache-2.0 */
+
+@import "tailwindcss";
+@source inline("bg-background text-primary");
+
+@theme {
+    --color-background: rgb(34, 34, 34); /* default background color */
+    --color-primary: rgb(247, 247, 247); /* primary text color (headers, bold text) */
+    --color-secondary: rgba(215, 218, 224, 0.7); /* secondary text */
+    --color-muted: rgba(215, 218, 224, 0.5); /* muted, faint, small text */
+    --color-accent-50: rgb(236, 253, 232);
+    --color-accent-100: rgb(209, 250, 202);
+    --color-accent-200: rgb(167, 243, 168);
+    --color-accent-300: rgb(110, 231, 133);
+    --color-accent-400: rgb(88, 193, 66); /* main accent color */
+    --color-accent-500: rgb(63, 162, 51);
+    --color-accent-600: rgb(47, 133, 47);
+    --color-accent-700: rgb(34, 104, 43);
+    --color-accent-800: rgb(22, 81, 35);
+    --color-accent-900: rgb(15, 61, 29);
+    --color-error: rgb(229, 77, 46); /* use as bg w/ primary text */
+    --color-warning: rgb(181, 137, 0); /* use as bg w/ primary text */
+    --color-success: rgb(78, 154, 6); /* use as bg w/ primary text */
+    --color-panel: rgba(255, 255, 255, 0.12); /* use a bg for panels */
+    --color-hoverbg: rgba(255, 255, 255, 0.16); /* on hover, can use as a bg to highlight */
+    --color-border: rgba(255, 255, 255, 0.16); /* fine border color */
+    --color-strongborder: rgba(255, 255, 255, 0.24); /* stronger border / divider color */
+    --color-accentbg: rgba(88, 193, 66, 0.4); /* accented bg color */
+    --color-accent: rgb(88, 193, 66); /* accent text color */
+    --color-accenthover: rgb(118, 223, 96); /* brighter accent text color (hover effect) */
+
+    --font-sans: "Inter", sans-serif; /* regular text font */
+    --font-mono: "Hack", monospace; /* monospace, code, terminal, command font */
+    --font-markdown: -apple-system, BlinkMacSystemFont, "Segoe UI", "Noto Sans", Helvetica, Arial, sans-serif,
+        "Apple Color Emoji", "Segoe UI Emoji";
+
+    --text-xxs: 10px; /* small, very fine text */
+    --text-title: 18px; /* font size for titles */
+    --text-default: 14px; /* default font size */
+    --radius: 8px; /* default border radius */
+
+    /* ANSI Terminal Colors (Default Dark Palette) */
+    --ansi-black: #757575;
+    --ansi-red: #cc685c;
+    --ansi-green: #76c266;
+    --ansi-yellow: #cbca9b;
+    --ansi-blue: #85aacb;
+    --ansi-magenta: #cc72ca;
+    --ansi-cyan: #74a7cb;
+    --ansi-white: #c1c1c1;
+    --ansi-brightblack: #727272;
+    --ansi-brightred: #cc9d97;
+    --ansi-brightgreen: #a3dd97;
+    --ansi-brightyellow: #cbcaaa;
+    --ansi-brightblue: #9ab6cb;
+    --ansi-brightmagenta: #cc8ecb;
+    --ansi-brightcyan: #b7b8cb;
+    --ansi-brightwhite: #f0f0f0;
+}
diff --git a/tsunami/util/util.go b/tsunami/util/util.go
index ee2ce5ce89..117ba7adab 100644
--- a/tsunami/util/util.go
+++ b/tsunami/util/util.go
@@ -4,10 +4,12 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"runtime"
 	"runtime/debug"
 	"strings"
+	"time"
 )
 
 func PanicHandler(debugStr string, recoverVal any) error {
@@ -65,3 +67,26 @@ func ChunkSlice[T any](slice []T, chunkSize int) [][]T {
 	}
 	return chunks
 }
+
+func OpenBrowser(url string, delay time.Duration) {
+	if delay > 0 {
+		time.Sleep(delay)
+	}
+	
+	var cmd string
+	var args []string
+
+	switch runtime.GOOS {
+	case "windows":
+		cmd = "cmd"
+		args = []string{"/c", "start", url}
+	case "darwin":
+		cmd = "open"
+		args = []string{url}
+	default: // "linux", "freebsd", "openbsd", "netbsd"
+		cmd = "xdg-open"
+		args = []string{url}
+	}
+
+	exec.Command(cmd, args...).Start()
+}

From f57ace9d627591d7d6bb6bc4aef63207f24622c1 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 11:02:13 -0700
Subject: [PATCH 041/134] implement -o for tsunami build

---
 tsunami/build/build.go      | 41 ++++++++++++++++++++++++++++---------
 tsunami/cmd/main-tsunami.go | 19 ++++++++++++-----
 2 files changed, 45 insertions(+), 15 deletions(-)

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 85e4cea068..db6b79a201 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -21,6 +21,8 @@ type BuildOpts struct {
 	Dir            string
 	Verbose        bool
 	Open           bool
+	KeepTemp       bool
+	OutputFile     string
 	ScaffoldPath   string
 	SdkReplacePath string
 }
@@ -275,6 +277,10 @@ func verifyScaffoldPath(scaffoldPath string) error {
 }
 
 func TsunamiBuild(opts BuildOpts) (*BuildEnv, error) {
+	return tsunamiBuildInternal(opts)
+}
+
+func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 	buildEnv, err := verifyEnvironment(opts.Verbose)
 	if err != nil {
 		return nil, err
@@ -345,17 +351,28 @@ func TsunamiBuild(opts BuildOpts) (*BuildEnv, error) {
 	}
 
 	// Build the Go application
-	if err := runGoBuild(tempDir, opts.Verbose); err != nil {
+	if err := runGoBuild(tempDir, opts); err != nil {
 		return nil, fmt.Errorf("failed to build application: %w", err)
 	}
 
 	return buildEnv, nil
 }
 
-func runGoBuild(tempDir string, verbose bool) error {
-	binDir := filepath.Join(tempDir, "bin")
-	if err := os.MkdirAll(binDir, 0755); err != nil {
-		return fmt.Errorf("failed to create bin directory: %w", err)
+func runGoBuild(tempDir string, opts BuildOpts) error {
+	var outputPath string
+	if opts.OutputFile != "" {
+		// Convert to absolute path resolved against current working directory
+		var err error
+		outputPath, err = filepath.Abs(opts.OutputFile)
+		if err != nil {
+			return fmt.Errorf("failed to resolve output path: %w", err)
+		}
+	} else {
+		binDir := filepath.Join(tempDir, "bin")
+		if err := os.MkdirAll(binDir, 0755); err != nil {
+			return fmt.Errorf("failed to create bin directory: %w", err)
+		}
+		outputPath = "bin/app"
 	}
 
 	goFiles, err := listGoFilesInDir(tempDir)
@@ -368,11 +385,11 @@ func runGoBuild(tempDir string, verbose bool) error {
 	}
 
 	// Build command with explicit go files
-	args := append([]string{"build", "-o", "bin/app"}, goFiles...)
+	args := append([]string{"build", "-o", outputPath}, goFiles...)
 	buildCmd := exec.Command("go", args...)
 	buildCmd.Dir = tempDir
 
-	if verbose {
+	if opts.Verbose {
 		log.Printf("Running: %s", strings.Join(buildCmd.Args, " "))
 		buildCmd.Stdout = os.Stdout
 		buildCmd.Stderr = os.Stderr
@@ -382,8 +399,12 @@ func runGoBuild(tempDir string, verbose bool) error {
 		return fmt.Errorf("failed to build application: %w", err)
 	}
 
-	if verbose {
-		log.Printf("Application built successfully at %s", filepath.Join(binDir, "app"))
+	if opts.Verbose {
+		if opts.OutputFile != "" {
+			log.Printf("Application built successfully at %s", outputPath)
+		} else {
+			log.Printf("Application built successfully at %s", filepath.Join(tempDir, "bin", "app"))
+		}
 	}
 
 	return nil
@@ -442,7 +463,7 @@ func copyGoFiles(srcDir, destDir string) (int, error) {
 }
 
 func TsunamiRun(opts BuildOpts) error {
-	buildEnv, err := TsunamiBuild(opts)
+	buildEnv, err := tsunamiBuildInternal(opts)
 	if err != nil {
 		return err
 	}
diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
index c960f406fe..1ea515d6d1 100644
--- a/tsunami/cmd/main-tsunami.go
+++ b/tsunami/cmd/main-tsunami.go
@@ -52,9 +52,13 @@ var buildCmd = &cobra.Command{
 	SilenceUsage: true,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		verbose, _ := cmd.Flags().GetBool("verbose")
+		keepTemp, _ := cmd.Flags().GetBool("keeptemp")
+		output, _ := cmd.Flags().GetString("output")
 		opts := build.BuildOpts{
-			Dir:     args[0],
-			Verbose: verbose,
+			Dir:        args[0],
+			Verbose:    verbose,
+			KeepTemp:   keepTemp,
+			OutputFile: output,
 		}
 		if err := validateEnvironmentVars(&opts); err != nil {
 			return err
@@ -75,10 +79,12 @@ var runCmd = &cobra.Command{
 	RunE: func(cmd *cobra.Command, args []string) error {
 		verbose, _ := cmd.Flags().GetBool("verbose")
 		open, _ := cmd.Flags().GetBool("open")
+		keepTemp, _ := cmd.Flags().GetBool("keeptemp")
 		opts := build.BuildOpts{
-			Dir:     args[0],
-			Verbose: verbose,
-			Open:    open,
+			Dir:      args[0],
+			Verbose:  verbose,
+			Open:     open,
+			KeepTemp: keepTemp,
 		}
 		if err := validateEnvironmentVars(&opts); err != nil {
 			return err
@@ -94,10 +100,13 @@ func init() {
 	rootCmd.AddCommand(versionCmd)
 
 	buildCmd.Flags().BoolP("verbose", "v", false, "Enable verbose output")
+	buildCmd.Flags().Bool("keeptemp", false, "Keep temporary build directory")
+	buildCmd.Flags().StringP("output", "o", "", "Output file path for the built application")
 	rootCmd.AddCommand(buildCmd)
 
 	runCmd.Flags().BoolP("verbose", "v", false, "Enable verbose output")
 	runCmd.Flags().Bool("open", false, "Open the application in the browser after starting")
+	runCmd.Flags().Bool("keeptemp", false, "Keep temporary build directory")
 	rootCmd.AddCommand(runCmd)
 }
 

From 296ac34931ea00b1e3b25031cafe94c401f6381c Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 12:00:01 -0700
Subject: [PATCH 042/134] tempdir cleanup

---
 tsunami/build/build.go      | 84 ++++++++++++++++++++++++++++++-------
 tsunami/cmd/main-tsunami.go | 24 ++++++-----
 2 files changed, 81 insertions(+), 27 deletions(-)

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index db6b79a201..5bdbd74056 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -7,10 +7,13 @@ import (
 	"log"
 	"os"
 	"os/exec"
+	"os/signal"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"
+	"syscall"
 	"time"
 
 	"github.com/wavetermdev/waveterm/tsunami/util"
@@ -28,8 +31,9 @@ type BuildOpts struct {
 }
 
 type BuildEnv struct {
-	GoVersion string
-	TempDir   string
+	GoVersion   string
+	TempDir     string
+	cleanupOnce *sync.Once
 }
 
 func verifyEnvironment(verbose bool) (*BuildEnv, error) {
@@ -113,7 +117,10 @@ func verifyEnvironment(verbose bool) (*BuildEnv, error) {
 		return nil, fmt.Errorf("tailwindcss v4 required, found: %s", firstLine)
 	}
 
-	return &BuildEnv{GoVersion: goVersion}, nil
+	return &BuildEnv{
+		GoVersion:   goVersion,
+		cleanupOnce: &sync.Once{},
+	}, nil
 }
 
 func createGoMod(tempDir, appDirName, goVersion string, opts BuildOpts, verbose bool) error {
@@ -276,8 +283,49 @@ func verifyScaffoldPath(scaffoldPath string) error {
 	return nil
 }
 
-func TsunamiBuild(opts BuildOpts) (*BuildEnv, error) {
-	return tsunamiBuildInternal(opts)
+func (be *BuildEnv) cleanupTempDir(keepTemp bool, verbose bool) {
+	if be == nil || be.cleanupOnce == nil {
+		return
+	}
+
+	be.cleanupOnce.Do(func() {
+		if keepTemp || be.TempDir == "" {
+			log.Printf("NOT cleaning tempdir\n")
+			return
+		}
+		if err := os.RemoveAll(be.TempDir); err != nil {
+			log.Printf("Failed to remove temp directory %s: %v", be.TempDir, err)
+		} else if verbose {
+			log.Printf("Removed temp directory: %s", be.TempDir)
+		}
+	})
+}
+
+func setupSignalCleanup(buildEnv *BuildEnv, keepTemp, verbose bool) {
+	if keepTemp {
+		return
+	}
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
+	go func() {
+		defer signal.Stop(sigChan)
+		sig := <-sigChan
+		if verbose {
+			log.Printf("Received signal %v, cleaning up temp directory", sig)
+		}
+		buildEnv.cleanupTempDir(keepTemp, verbose)
+		os.Exit(1)
+	}()
+}
+
+func TsunamiBuild(opts BuildOpts) error {
+	buildEnv, err := tsunamiBuildInternal(opts)
+	defer buildEnv.cleanupTempDir(opts.KeepTemp, opts.Verbose)
+	if err != nil {
+		return err
+	}
+	setupSignalCleanup(buildEnv, opts.KeepTemp, opts.Verbose)
+	return nil
 }
 
 func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
@@ -311,7 +359,7 @@ func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 	// Copy all *.go files from the root directory
 	goCount, err := copyGoFiles(opts.Dir, tempDir)
 	if err != nil {
-		return nil, fmt.Errorf("failed to copy go files: %w", err)
+		return buildEnv, fmt.Errorf("failed to copy go files: %w", err)
 	}
 
 	// Copy static directory
@@ -319,13 +367,13 @@ func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 	staticDestDir := filepath.Join(tempDir, "static")
 	staticCount, err := copyDirRecursive(staticSrcDir, staticDestDir, true)
 	if err != nil {
-		return nil, fmt.Errorf("failed to copy static directory: %w", err)
+		return buildEnv, fmt.Errorf("failed to copy static directory: %w", err)
 	}
 
 	// Copy scaffold directory contents selectively
 	scaffoldCount, err := copyScaffoldSelective(opts.ScaffoldPath, tempDir)
 	if err != nil {
-		return nil, fmt.Errorf("failed to copy scaffold directory: %w", err)
+		return buildEnv, fmt.Errorf("failed to copy scaffold directory: %w", err)
 	}
 
 	if opts.Verbose {
@@ -336,23 +384,23 @@ func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 	appMainSrc := filepath.Join(tempDir, "app-main.go")
 	appMainDest := filepath.Join(tempDir, "main-app.go")
 	if err := os.Rename(appMainSrc, appMainDest); err != nil {
-		return nil, fmt.Errorf("failed to rename app-main.go to main-app.go: %w", err)
+		return buildEnv, fmt.Errorf("failed to rename app-main.go to main-app.go: %w", err)
 	}
 
 	// Create go.mod file
 	appDirName := filepath.Base(opts.Dir)
 	if err := createGoMod(tempDir, appDirName, buildEnv.GoVersion, opts, opts.Verbose); err != nil {
-		return nil, fmt.Errorf("failed to create go.mod: %w", err)
+		return buildEnv, fmt.Errorf("failed to create go.mod: %w", err)
 	}
 
 	// Generate Tailwind CSS
 	if err := generateAppTailwindCss(tempDir, opts.Verbose); err != nil {
-		return nil, fmt.Errorf("failed to generate tailwind css: %w", err)
+		return buildEnv, fmt.Errorf("failed to generate tailwind css: %w", err)
 	}
 
 	// Build the Go application
 	if err := runGoBuild(tempDir, opts); err != nil {
-		return nil, fmt.Errorf("failed to build application: %w", err)
+		return buildEnv, fmt.Errorf("failed to build application: %w", err)
 	}
 
 	return buildEnv, nil
@@ -421,8 +469,6 @@ func generateAppTailwindCss(tempDir string, verbose bool) error {
 
 	if verbose {
 		log.Printf("Running: %s", strings.Join(tailwindCmd.Args, " "))
-		tailwindCmd.Stdout = os.Stdout
-		tailwindCmd.Stderr = os.Stderr
 	}
 
 	if err := tailwindCmd.Run(); err != nil {
@@ -464,9 +510,11 @@ func copyGoFiles(srcDir, destDir string) (int, error) {
 
 func TsunamiRun(opts BuildOpts) error {
 	buildEnv, err := tsunamiBuildInternal(opts)
+	defer buildEnv.cleanupTempDir(opts.KeepTemp, opts.Verbose)
 	if err != nil {
 		return err
 	}
+	setupSignalCleanup(buildEnv, opts.KeepTemp, opts.Verbose)
 
 	// Run the built application
 	appPath := filepath.Join(buildEnv.TempDir, "bin", "app")
@@ -503,8 +551,12 @@ func TsunamiRun(opts BuildOpts) error {
 			runCmd.Stderr = os.Stderr
 		}
 
-		if err := runCmd.Run(); err != nil {
-			return fmt.Errorf("failed to run application: %w", err)
+		if err := runCmd.Start(); err != nil {
+			return fmt.Errorf("failed to start application: %w", err)
+		}
+
+		if err := runCmd.Wait(); err != nil {
+			return fmt.Errorf("application exited with error: %w", err)
 		}
 	}
 
diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
index 1ea515d6d1..6eae0f1951 100644
--- a/tsunami/cmd/main-tsunami.go
+++ b/tsunami/cmd/main-tsunami.go
@@ -33,12 +33,12 @@ func validateEnvironmentVars(opts *build.BuildOpts) error {
 	if scaffoldPath == "" {
 		return fmt.Errorf("TSUNAMI_SCAFFOLDPATH environment variable must be set")
 	}
-	
+
 	sdkReplacePath := os.Getenv("TSUNAMI_SDKREPLACEPATH")
 	if sdkReplacePath == "" {
 		return fmt.Errorf("TSUNAMI_SDKREPLACEPATH environment variable must be set")
 	}
-	
+
 	opts.ScaffoldPath = scaffoldPath
 	opts.SdkReplacePath = sdkReplacePath
 	return nil
@@ -50,7 +50,7 @@ var buildCmd = &cobra.Command{
 	Long:         `Build a Tsunami application from the specified directory.`,
 	Args:         cobra.ExactArgs(1),
 	SilenceUsage: true,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	Run: func(cmd *cobra.Command, args []string) {
 		verbose, _ := cmd.Flags().GetBool("verbose")
 		keepTemp, _ := cmd.Flags().GetBool("keeptemp")
 		output, _ := cmd.Flags().GetString("output")
@@ -61,12 +61,13 @@ var buildCmd = &cobra.Command{
 			OutputFile: output,
 		}
 		if err := validateEnvironmentVars(&opts); err != nil {
-			return err
+			fmt.Println(err)
+			os.Exit(1)
 		}
-		if _, err := build.TsunamiBuild(opts); err != nil {
-			return fmt.Errorf("build failed: %w", err)
+		if err := build.TsunamiBuild(opts); err != nil {
+			fmt.Println(err)
+			os.Exit(1)
 		}
-		return nil
 	},
 }
 
@@ -76,7 +77,7 @@ var runCmd = &cobra.Command{
 	Long:         `Build and run a Tsunami application from the specified directory.`,
 	Args:         cobra.ExactArgs(1),
 	SilenceUsage: true,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	Run: func(cmd *cobra.Command, args []string) {
 		verbose, _ := cmd.Flags().GetBool("verbose")
 		open, _ := cmd.Flags().GetBool("open")
 		keepTemp, _ := cmd.Flags().GetBool("keeptemp")
@@ -87,12 +88,13 @@ var runCmd = &cobra.Command{
 			KeepTemp: keepTemp,
 		}
 		if err := validateEnvironmentVars(&opts); err != nil {
-			return err
+			fmt.Println(err)
+			os.Exit(1)
 		}
 		if err := build.TsunamiRun(opts); err != nil {
-			return fmt.Errorf("run failed: %w", err)
+			fmt.Println(err)
+			os.Exit(1)
 		}
-		return nil
 	},
 }
 

From 013e4f4ec9a300caba4bccf567ce5341888822cd Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 12:30:27 -0700
Subject: [PATCH 043/134] fixed SSE asyncinitation, ported pomodoro

---
 .vscode/settings.json         |   3 +-
 tsunami/app/serverhandlers.go |  26 ++--
 tsunami/demo/pomodoro/app.go  | 237 ++++++++++++++++++++++++++++++++++
 3 files changed, 251 insertions(+), 15 deletions(-)
 create mode 100644 tsunami/demo/pomodoro/app.go

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 15c0d1c61c..07a68e5252 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -59,6 +59,7 @@
     "gopls": {
         "analyses": {
             "QF1003": false
-        }
+        },
+        "directoryFilters": ["-tsunami/frontend/scaffold"]
     }
 }
diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index 3ec489a9ba..5feb9e5f93 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -277,18 +277,18 @@ func (h *HTTPHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 
 	// Set SSE headers
 	w.Header().Set("Content-Type", "text/event-stream")
-	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Cache-Control", "no-cache, no-transform")
 	w.Header().Set("Connection", "keep-alive")
 	w.Header().Set("X-Accel-Buffering", "no")
 	w.Header().Set("X-Content-Type-Options", "nosniff")
+	w.Header().Set("X-Accel-Buffering", "no") // nginx hint
 
-	// Flush headers immediately
-	flusher, ok := w.(http.Flusher)
-	if !ok {
+	// Use ResponseController for better flushing control
+	rc := http.NewResponseController(w)
+	if err := rc.Flush(); err != nil {
 		http.Error(w, "streaming not supported", http.StatusInternalServerError)
 		return
 	}
-	flusher.Flush()
 
 	// Create a ticker for keepalive packets
 	keepaliveTicker := time.NewTicker(SSEKeepAliveDuration)
@@ -301,17 +301,15 @@ func (h *HTTPHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 		case <-keepaliveTicker.C:
 			// Send keepalive comment
 			fmt.Fprintf(w, ": keepalive\n\n")
-			flusher.Flush()
+			rc.Flush()
 		case event := <-h.Client.SSEventCh:
 			if event.Event == "" {
 				break
 			}
 			fmt.Fprintf(w, "event: %s\n", event.Event)
-			if len(event.Data) > 0 {
-				fmt.Fprintf(w, "data: %s\n", string(event.Data))
-			}
+			fmt.Fprintf(w, "data: %s\n", string(event.Data))
 			fmt.Fprintf(w, "\n")
-			flusher.Flush()
+			rc.Flush()
 		}
 	}
 }
@@ -322,7 +320,7 @@ func serveFileDirectly(w http.ResponseWriter, r *http.Request, embeddedFS fs.FS,
 	if !strings.HasSuffix(requestPath, "/") {
 		return false
 	}
-	
+
 	// Try to serve the specified file from that directory
 	var filePath string
 	if requestPath == "/" {
@@ -330,19 +328,19 @@ func serveFileDirectly(w http.ResponseWriter, r *http.Request, embeddedFS fs.FS,
 	} else {
 		filePath = strings.TrimPrefix(requestPath, "/") + fileName
 	}
-	
+
 	file, err := embeddedFS.Open(filePath)
 	if err != nil {
 		return false
 	}
 	defer file.Close()
-	
+
 	// Get file info for modification time
 	fileInfo, err := file.Stat()
 	if err != nil {
 		return false
 	}
-	
+
 	// Serve the file directly with proper mod time
 	http.ServeContent(w, r, fileName, fileInfo.ModTime(), file.(io.ReadSeeker))
 	return true
diff --git a/tsunami/demo/pomodoro/app.go b/tsunami/demo/pomodoro/app.go
new file mode 100644
index 0000000000..15ec2dbf42
--- /dev/null
+++ b/tsunami/demo/pomodoro/app.go
@@ -0,0 +1,237 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/wavetermdev/waveterm/tsunami/app"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+func init() {
+	app.SetAppOpts(app.AppOpts{
+		CloseOnCtrlC: true,
+		Title:        "Pomodoro Timer (Tsunami Demo)",
+	})
+}
+
+type Mode struct {
+	Name     string `json:"name"`
+	Duration int    `json:"duration"` // in minutes
+}
+
+var (
+	WorkMode  = Mode{Name: "Work", Duration: 25}
+	BreakMode = Mode{Name: "Break", Duration: 5}
+)
+
+type TimerDisplayProps struct {
+	Minutes int    `json:"minutes"`
+	Seconds int    `json:"seconds"`
+	Mode    string `json:"mode"`
+}
+
+type ControlButtonsProps struct {
+	IsRunning bool      `json:"isRunning"`
+	OnStart   func()    `json:"onStart"`
+	OnPause   func()    `json:"onPause"`
+	OnReset   func()    `json:"onReset"`
+	OnMode    func(int) `json:"onMode"`
+}
+
+type TimerState struct {
+	ticker    *time.Ticker
+	done      chan bool
+	startTime time.Time
+	duration  time.Duration
+	isActive  bool // Track if the timer goroutine is running
+}
+
+var TimerDisplay = app.DefineComponent("TimerDisplay",
+	func(ctx context.Context, props TimerDisplayProps) any {
+		return vdom.E("div",
+			vdom.Class("bg-slate-700 p-8 rounded-lg mb-8 text-center"),
+			vdom.E("div",
+				vdom.Class("text-xl text-blue-400 mb-2"),
+				props.Mode,
+			),
+			vdom.E("div",
+				vdom.Class("text-6xl font-bold font-mono text-slate-100"),
+				fmt.Sprintf("%02d:%02d", props.Minutes, props.Seconds),
+			),
+		)
+	},
+)
+
+var ControlButtons = app.DefineComponent("ControlButtons",
+	func(ctx context.Context, props ControlButtonsProps) any {
+		return vdom.E("div",
+			vdom.Class("flex flex-col gap-4"),
+			vdom.IfElse(props.IsRunning,
+				vdom.E("button",
+					vdom.Class("px-6 py-3 text-lg border-none rounded bg-blue-500 text-white cursor-pointer hover:bg-blue-600 transition-colors duration-200"),
+					vdom.P("onClick", props.OnPause),
+					"Pause",
+				),
+				vdom.E("button",
+					vdom.Class("px-6 py-3 text-lg border-none rounded bg-blue-500 text-white cursor-pointer hover:bg-blue-600 transition-colors duration-200"),
+					vdom.P("onClick", props.OnStart),
+					"Start",
+				),
+			),
+			vdom.E("button",
+				vdom.Class("px-6 py-3 text-lg border-none rounded bg-blue-500 text-white cursor-pointer hover:bg-blue-600 transition-colors duration-200"),
+				vdom.P("onClick", props.OnReset),
+				"Reset",
+			),
+			vdom.E("div",
+				vdom.Class("flex gap-4 mt-4"),
+				vdom.E("button",
+					vdom.Class("flex-1 px-3 py-3 text-base border-none rounded bg-green-500 text-white cursor-pointer hover:bg-green-600 transition-colors duration-200"),
+					vdom.P("onClick", func() { props.OnMode(WorkMode.Duration) }),
+					"Work Mode",
+				),
+				vdom.E("button",
+					vdom.Class("flex-1 px-3 py-3 text-base border-none rounded bg-green-500 text-white cursor-pointer hover:bg-green-600 transition-colors duration-200"),
+					vdom.P("onClick", func() { props.OnMode(BreakMode.Duration) }),
+					"Break Mode",
+				),
+			),
+		)
+	},
+)
+
+var App = app.DefineComponent("App",
+	func(ctx context.Context, _ any) any {
+		isRunning, setIsRunning, _ := vdom.UseState(ctx, false)
+		minutes, setMinutes, _ := vdom.UseState(ctx, WorkMode.Duration)
+		seconds, setSeconds, _ := vdom.UseState(ctx, 0)
+		mode, setMode, _ := vdom.UseState(ctx, WorkMode.Name)
+		_, setIsComplete, _ := vdom.UseState(ctx, false)
+		timerRef := vdom.UseRef(ctx, &TimerState{
+			done: make(chan bool),
+		})
+
+		stopTimer := func() {
+			if timerRef.Current.ticker != nil {
+				timerRef.Current.ticker.Stop()
+				timerRef.Current.ticker = nil
+			}
+			if timerRef.Current.isActive {
+				close(timerRef.Current.done)
+				timerRef.Current.isActive = false
+			}
+			timerRef.Current.done = make(chan bool)
+		}
+
+		startTimer := func() {
+			if timerRef.Current.isActive {
+				return // Timer already running
+			}
+
+			// Stop any existing timer first
+			stopTimer()
+
+			setIsComplete(false)
+			timerRef.Current.startTime = time.Now()
+			timerRef.Current.duration = time.Duration(minutes) * time.Minute
+			timerRef.Current.isActive = true
+			setIsRunning(true)
+			timerRef.Current.ticker = time.NewTicker(1 * time.Second)
+
+			go func() {
+				for {
+					select {
+					case <-timerRef.Current.done:
+						return
+					case <-timerRef.Current.ticker.C:
+						elapsed := time.Since(timerRef.Current.startTime)
+						remaining := timerRef.Current.duration - elapsed
+
+						if remaining <= 0 {
+							// Timer completed
+							setIsRunning(false)
+							setMinutes(0)
+							setSeconds(0)
+							setIsComplete(true)
+							stopTimer()
+							app.SendAsyncInitiation()
+							return
+						}
+
+						m := int(remaining.Minutes())
+						s := int(remaining.Seconds()) % 60
+
+						// Only send update if values actually changed
+						if m != minutes || s != seconds {
+							setMinutes(m)
+							setSeconds(s)
+							app.SendAsyncInitiation()
+						}
+					}
+				}
+			}()
+		}
+
+		pauseTimer := func() {
+			stopTimer()
+			setIsRunning(false)
+			app.SendAsyncInitiation()
+		}
+
+		resetTimer := func() {
+			stopTimer()
+			setIsRunning(false)
+			setIsComplete(false)
+			if mode == WorkMode.Name {
+				setMinutes(WorkMode.Duration)
+			} else {
+				setMinutes(BreakMode.Duration)
+			}
+			setSeconds(0)
+			app.SendAsyncInitiation()
+		}
+
+		changeMode := func(duration int) {
+			stopTimer()
+			setIsRunning(false)
+			setIsComplete(false)
+			setMinutes(duration)
+			setSeconds(0)
+			if duration == WorkMode.Duration {
+				setMode(WorkMode.Name)
+			} else {
+				setMode(BreakMode.Name)
+			}
+			app.SendAsyncInitiation()
+		}
+
+		// Cleanup on unmount
+		vdom.UseEffect(ctx, func() func() {
+			return func() {
+				stopTimer()
+			}
+		}, []any{})
+
+		return vdom.E("div",
+			vdom.Class("max-w-sm mx-auto my-8 p-8 bg-slate-800 rounded-xl text-slate-100 font-sans"),
+			vdom.E("h1",
+				vdom.Class("text-center text-slate-100 mb-8 text-3xl"),
+				"Pomodoro Timer",
+			),
+			TimerDisplay(TimerDisplayProps{
+				Minutes: minutes,
+				Seconds: seconds,
+				Mode:    mode,
+			}),
+			ControlButtons(ControlButtonsProps{
+				IsRunning: isRunning,
+				OnStart:   startTimer,
+				OnPause:   pauseTimer,
+				OnReset:   resetTimer,
+				OnMode:    changeMode,
+			}),
+		)
+	},
+)

From 5eb75b240625e4fbae912214604a8a00ce13d0bf Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 12:51:17 -0700
Subject: [PATCH 044/134] first cut at new prompt.md for tsunami (ported from
 waveapps)

---
 tsunami/prompt.md | 877 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 877 insertions(+)
 create mode 100644 tsunami/prompt.md

diff --git a/tsunami/prompt.md b/tsunami/prompt.md
new file mode 100644
index 0000000000..3636c20998
--- /dev/null
+++ b/tsunami/prompt.md
@@ -0,0 +1,877 @@
+# Tsunami Framework Guide
+
+Wave Terminal includes a powerful Tsunami framework that lets developers create rich HTML/React-based UI applications directly from Go code. The system translates Go components and elements into React components that are rendered within Wave Terminal's UI. It's particularly well-suited for administrative interfaces, monitoring dashboards, data visualization, configuration managers, and form-based applications where you want a graphical interface but don't need complex browser-side interactions.
+
+This guide explains how to use the Tsunami framework (and corresponding VDOM, virtual DOM, component) to create interactive applications that run in Wave Terminal. While the patterns will feel familiar to React developers (components, props, hooks), the implementation is pure Go and takes advantage of Go's strengths like goroutines for async operations. Note that complex browser-side interactions like drag-and-drop, rich text editing, or heavy JavaScript functionality are not supported - the framework is designed for straightforward, practical applications.
+
+You'll learn how to:
+
+- Create and compose components
+- Manage state and handle events
+- Work with styles and CSS
+- Handle async operations with goroutines
+- Create rich UIs that render in Wave Terminal
+
+The included todo-main.go provides a complete example application showing these patterns in action.
+
+## App Setup and Registration
+
+Tsunami applications use a default client configured through `app.SetAppOpts()` in an `init()` function:
+
+```go
+func init() {
+    // Set up the default client with options
+    app.SetAppOpts(app.AppOpts{
+        CloseOnCtrlC: true,
+        Title:        "My Tsunami App",
+    })
+}
+
+// Components are defined using the default client
+var MyComponent = app.DefineComponent("MyComponent",
+    func(ctx context.Context, props MyProps) any {
+        // component logic
+    },
+)
+```
+
+## Building Elements with vdom.H()
+
+The H function creates virtual DOM elements following a React-like pattern. It takes a tag name, a props map, and any number of children:
+
+```go
+// Basic element with no props
+vdom.H("div", nil, "Hello world")
+
+// Element with props
+vdom.H("div", map[string]any{
+    "className": "container",
+    "id": "main",
+    "onClick": func() {
+        fmt.Println("clicked!")
+    },
+},
+    "child content",
+)
+
+// Element with style
+vdom.H("div", map[string]any{
+    "style": map[string]any{
+        "marginTop": 10,      // Numbers automatically convert to px
+        "color": "red",
+        "display": "flex",
+    },
+})
+
+// Working with classes
+vdom.H("div", map[string]any{
+    "className": vdom.Classes(
+        "base",                     // Static classes
+        vdom.If(isActive, "active"),    // Conditional class: condition first, then class
+        vdom.If(isDisabled, "disabled"), // Another conditional
+    ),
+})
+
+// Nesting elements
+vdom.H("div", map[string]any{
+    "className": "container",
+},
+    vdom.H("h1", map[string]any{
+        "className": "title",
+    }, "Hello"),
+    vdom.H("p", map[string]any{
+        "className": "content",
+    }, "Some content"),
+)
+
+// Handling events
+vdom.H("button", map[string]any{
+    "onClick": func() {
+        handleClick()
+    },
+    "onKeyDown": &vdom.VDomFunc{
+        Fn: handleKey,
+        Keys: []string{"Enter", "Space"},
+        PreventDefault: true,
+    },
+})
+
+// List rendering
+vdom.H("ul", nil,
+    vdom.ForEachIdx(items, func(item string, idx int) any {
+        return vdom.H("li", map[string]any{
+            "key": idx,
+            "className": "list-item",
+        }, item)
+    }),
+)
+
+// Conditional rendering
+vdom.H("div", nil,
+    vdom.If(isVisible, vdom.H("span", nil, "Visible content")),
+)
+```
+
+Arguments to H:
+
+1. `tag` (string): The HTML tag name
+2. `props` (map[string]any or nil): Props map including:
+   - className: String of space-separated classes
+   - style: map[string]any of CSS properties
+   - Event handlers (onClick, onChange, etc)
+   - Any other valid HTML attributes
+3. `children` (...any): Any number of child elements:
+   - Other H() elements
+   - Strings (become text nodes)
+   - Numbers (converted to string)
+   - Arrays of the above
+   - nil values are ignored
+   - Anything with String() method becomes text
+
+Best practices:
+
+- Use Classes() with If() for conditional classes
+- Use camelCase for style properties (matching React)
+- Numbers in style are automatically converted to pixel values
+- Always create new slices when updating arrays in state
+- Use ForEach or ForEachIdx for list rendering
+- Include key prop when rendering lists
+
+## Conditional Rendering and Lists
+
+The system provides helper functions for conditional and list rendering:
+
+```go
+// Conditional rendering with vdom.If()
+vdom.H("div", nil,
+    vdom.If(isVisible,
+        vdom.H("span", nil, "Visible content"),
+    ),
+)
+
+// Branching with vdom.IfElse()
+vdom.H("div", nil,
+    vdom.IfElse(isActive,
+        vdom.H("span", nil, "Active"),
+        vdom.H("span", nil, "Inactive"),
+    ),
+)
+
+// List rendering (adding "key" prop to li element)
+items := []string{"A", "B", "C"}
+vdom.H("ul", nil,
+    vdom.ForEachIdx(items, func(item string, idx int) any {
+        return vdom.H("li", map[string]any{
+            "key": idx,
+            "className": "list-item",
+        }, item)
+    }),
+)
+```
+
+Helper functions:
+
+- `vdom.Fragment(...any)` - Combines elements into a group without adding a DOM node. Useful with conditional functions.
+- `vdom.If(cond bool, part any) any` - Returns part if condition is true, nil otherwise
+- `vdom.IfElse(cond bool, truePart any, falsePart any) any` - Returns truePart if condition is true, falsePart otherwise
+- `vdom.ForEach[T any](items []T, fn func(T) any) []any` - Maps over items without index
+- `vdom.ForEachIdx[T any](items []T, fn func(T, int) any) []any` - Maps over items with index
+- `vdom.Filter[T any](items []T, fn func(T) bool) []T` - Filters items based on condition
+- `vdom.FilterIdx[T any](items []T, fn func(T, int) bool) []T` - Filters items with index access
+
+- The same If/IfElse functions are used for both conditional rendering and conditional classes, always following the pattern of condition first, then value(s).
+- Remember to use vdom.IfElse if you need a true ternary condition. vdom.If will return nil on false and does not allow a 3rd argument.
+
+## Style Handling
+
+Tsunami applications use Tailwind v4 CSS by default for styling. You can also define inline styles using a map[string]any in the props:
+
+```go
+vdom.H("div", map[string]any{
+    "style": map[string]any{
+        "marginRight": 10,         // Numbers for px values
+        "backgroundColor": "#fff", // Colors as strings
+        "display": "flex",         // CSS values as strings
+        "fontSize": 16,            // More numbers
+        "borderRadius": 4,         // Numbers to px
+    },
+})
+
+// Multiple style properties can be combined with dynamic values
+vdom.H("div", map[string]any{
+    "style": map[string]any{
+        "marginTop": spacing,      // Variables work too
+        "color": vdom.IfElse(isActive, "blue", "gray"),
+        "display": "flex",
+        "opacity": vdom.If(isVisible, 1.0),  // Conditional styles
+    },
+})
+```
+
+Properties use camelCase (must match React) and values can be:
+
+- Numbers (automatically converted to pixel values)
+- Colors as strings
+- Other CSS values as strings
+- Conditional values using If/IfElse
+
+The style map in props mirrors React's style object pattern, making it familiar to React developers while maintaining type safety in Go.
+
+## Component Definition Pattern
+
+Create typed, reusable components using the client:
+
+```go
+// Define prop types with json tags
+type TodoItemProps struct {
+    Todo     Todo    `json:"todo"`
+    OnToggle func()  `json:"onToggle"`
+    IsActive bool    `json:"isActive"`
+}
+
+// Create component with typed props
+var TodoItem = app.DefineComponent("TodoItem",
+    func(ctx context.Context, props TodoItemProps) any {
+        return vdom.H("div", map[string]any{
+            "className": vdom.Classes(
+                "todo-item",
+                vdom.If(props.IsActive, "active"),
+            ),
+            "onClick": props.OnToggle,
+            "style": map[string]any{
+                "cursor": "pointer",
+                "opacity": vdom.If(props.IsActive, 1.0, 0.7),
+            },
+        }, props.Todo.Text)
+    },
+)
+
+// Usage in parent component:
+vdom.H("div", map[string]any{
+    "className": "todo-list",
+},
+    TodoItem(TodoItemProps{
+        Todo: todo,
+        OnToggle: handleToggle,
+        IsActive: isCurrentItem,
+    }),
+)
+
+// Usage with key (when in lists)
+TodoItem(TodoItemProps{
+    Todo: todo,
+    OnToggle: handleToggle,
+}).WithKey(fmt.Sprint(idx))
+```
+
+Components in Tsunami:
+
+- Use Go structs with json tags for props
+- Take a context and props as arguments
+- Return elements created with vdom.H()
+- Can use all hooks (useState, useRef, etc)
+- Are registered with the default client and given a name
+- Are called as functions with their props struct
+
+Special Handling for Component "key" prop:
+
+- Use the WithKey(key string) chaining func to set a key on a component
+- Keys must be added for components rendered in lists (just like in React)
+- Keys should be unique among siblings and stable across renders
+- Keys are handled at the framework level and should not be declared in component props
+
+This pattern matches React's functional components while maintaining Go's type safety and explicit props definition.
+
+## Handler Functions
+
+For most event handling, passing a function directly in the props map works:
+
+```go
+vdom.H("button", map[string]any{
+    "onClick": func() {
+        fmt.Println("clicked!")
+    },
+})
+
+// With event data
+vdom.H("input", map[string]any{
+    "onChange": func(e vdom.VDomEvent) {
+        fmt.Println("new value:", e.TargetValue)
+    },
+})
+```
+
+For keyboard events that need special handling, preventDefault, or stopPropagation, use VDomFunc:
+
+```go
+// Handle specific keys with onKeyDown
+keyHandler := &vdom.VDomFunc{
+    Type:            vdom.ObjectType_Func,
+    Fn:              func(event vdom.VDomEvent) {
+        // handle key press
+    },
+    StopPropagation: true,    // Stop event bubbling
+    PreventDefault: true,     // Prevent default browser behavior
+    Keys: []string{
+        "Enter",              // Just Enter key
+        "Shift:Tab",          // Shift+Tab
+        "Control:c",          // Ctrl+C
+        "Meta:v",             // Meta+V (Windows)/Command+V (Mac)
+        "Alt:x",              // Alt+X
+        "Cmd:s",             // Command+S (Mac)/Alt+S (Windows)
+        "Option:f",          // Option+F (Mac)/Meta+F (Windows)
+    },
+}
+
+vdom.H("input", map[string]any{
+    "className": "special-input",
+    "onKeyDown": keyHandler,
+})
+
+// Common pattern for form handling
+vdom.H("form", map[string]any{
+    "onSubmit": &vdom.VDomFunc{
+        Fn:             handleSubmit,
+        PreventDefault: true,  // Prevent form submission
+    },
+})
+```
+
+The Keys field on VDomFunc:
+
+- Only works with onKeyDown events
+- Format is "[modifier]:key" or just "key"
+- Modifiers:
+  - Shift, Control, Meta, Alt: work as expected
+  - Cmd: maps to Meta on Mac, Alt on Windows/Linux
+  - Option: maps to Alt on Mac, Meta on Windows/Linux
+
+Event handlers follow React patterns while providing additional type safety and explicit control over event behavior through VDomFunc.
+
+## State Management with Hooks
+
+```go
+func MyComponent(ctx context.Context, props MyProps) any {
+    // UseState: returns current value, setter function, and functional setter
+    count, setCount, _ := vdom.UseState(ctx, 0)     // Initial value of 0
+    items, setItems, _ := vdom.UseState(ctx, []string{}) // Initial value of empty slice
+
+    // When you need the functional setter, use all 3 return values
+    counter, setCounter, setCounterFn := vdom.UseState(ctx, 0)
+
+    // Event handlers that update state (called from onClick, onChange, etc.)
+    incrementCount := func() {
+        setCount(count + 1)  // Direct update when you have the value
+    }
+
+    incrementCounterFn := func() {
+        setCounterFn(func(current int) int {
+            return current + 1  // Functional update based on current value
+        })
+    }
+
+    addItem := func(item string) {
+        // When updating slices/maps, create new value
+        setItems(append([]string{}, items..., item))
+    }
+
+    // Refs for values that persist between renders but don't trigger updates
+    renderCounter := vdom.UseRef(ctx, 0)
+    renderCounter.Current++  // Doesn't cause re-render
+
+    // DOM refs for accessing elements directly
+    inputRef := vdom.UseVDomRef(ctx)
+
+    // Side effects (can call setters here)
+    vdom.UseEffect(ctx, func() func() {
+        // Example: set counter to 10 on mount
+        setCounter(10)
+        
+        return func() {
+            // cleanup
+        }
+    }, []any{}) // Empty dependency array means run once on mount
+
+    return vdom.H("div", nil,
+        vdom.H("button", map[string]any{
+            "onClick": incrementCount,  // State setter called in event handler
+        }, "Increment: ", count),
+        vdom.H("button", map[string]any{
+            "onClick": incrementCounterFn,  // Functional setter in event handler
+        }, "Functional Increment: ", counter),
+        vdom.H("input", map[string]any{
+            "ref": inputRef,
+            "type": "text",
+            "placeholder": "Add item",
+            "onKeyDown": &vdom.VDomFunc{
+                Fn: func(e vdom.VDomEvent) {
+                    if e.TargetValue != "" {
+                        addItem(e.TargetValue)  // State setter in event handler
+                    }
+                },
+                Keys: []string{"Enter"},
+            },
+        }),
+        vdom.H("ul", nil,
+            vdom.ForEach(items, func(item string) any {
+                return vdom.H("li", nil, item)
+            }),
+        ),
+    )
+}
+```
+
+## Available Hooks
+
+The system provides three main types of hooks:
+
+1. `UseState` - For values that trigger re-renders when changed:
+
+   - Returns current value, direct setter, and functional setter
+   - Direct setter triggers component re-render
+   - Functional setter ensures you're working with latest state value
+   - Create new values for slices/maps when updating
+
+   ```go
+   count, setCount, setCountFn := vdom.UseState(ctx, 0)
+   // Direct update when you have the value:
+   setCount(42)
+   // Functional update when you need current value:
+   setCountFn(func(current int) int {
+       return current + 1
+   })
+   ```
+
+2. `UseRef` - For values that persist between renders without triggering updates:
+
+   - Holds mutable values that survive re-renders
+   - Changes don't cause re-renders
+   - Perfect for:
+     - Managing goroutine state
+     - Storing timers/channels
+     - Tracking subscriptions
+     - Holding complex state structures
+
+   ```go
+   timerRef := vdom.UseRef(ctx, &TimerState{
+       done: make(chan bool),
+   })
+   ```
+
+3. `UseVDomRef` - For accessing DOM elements directly:
+   - Creates refs for DOM interaction
+   - Useful for:
+     - Accessing DOM element properties
+     - Managing focus
+     - Measuring elements
+     - Direct DOM manipulation when needed
+   ```go
+   inputRef := vdom.UseVDomRef(ctx)
+   vdom.H("input", map[string]any{
+       "ref": inputRef,
+       "type": "text",
+   })
+   ```
+
+Best Practices:
+
+- Use `UseState` for all UI state - it provides both direct and functional setters
+- Use functional setter when updating state from goroutines or based on current value
+- Use `UseRef` for complex state that goroutines need to access
+- Always clean up timers, channels, and goroutines in UseEffect cleanup functions
+
+## State Management and Async Updates
+
+While React patterns typically avoid globals, in Go Tsunami applications it's perfectly fine and often clearer to use global variables. However, when dealing with async operations and goroutines, special care must be taken:
+
+```go
+// Global state is fine!
+var globalTodos []Todo
+var globalFilter string
+
+// For async operations, consider using a state struct
+type TimerState struct {
+    ticker   *time.Ticker
+    done     chan bool
+    isActive bool
+}
+
+var TodoApp = app.DefineComponent("TodoApp",
+    func(ctx context.Context, _ struct{}) any {
+        // Local state for UI updates
+        count, setCount := vdom.UseState(ctx, 0)
+
+        // UseState returns value, setter, and functional setter
+        seconds, setSeconds, setSecondsFn := vdom.UseState(ctx, 0)
+
+        // Use refs to store complex state that goroutines need to access
+        stateRef := vdom.UseRef(ctx, &TimerState{
+            done: make(chan bool),
+        })
+
+        // Example of safe goroutine management
+        startAsync := func() {
+            if stateRef.Current.isActive {
+                return // Prevent multiple goroutines
+            }
+
+            stateRef.Current.isActive = true
+            go func() {
+                defer func() {
+                    stateRef.Current.isActive = false
+                }()
+
+                // Use channels for cleanup
+                for {
+                    select {
+                    case <-stateRef.Current.done:
+                        return
+                    case <-time.After(time.Second):
+                        // Use functional updates for state that depends on current value
+                        setSecondsFn(func(s int) int {
+                            return s + 1
+                        })
+                        // Notify UI of update
+                        app.SendAsyncInitiation()
+                    }
+                }
+            }()
+        }
+
+        // Always clean up goroutines
+        stopAsync := func() {
+            if stateRef.Current.isActive {
+                close(stateRef.Current.done)
+                stateRef.Current.done = make(chan bool)
+            }
+        }
+
+        // Use UseEffect for cleanup on unmount
+        vdom.UseEffect(ctx, func() func() {
+            return func() {
+                stopAsync()
+            }
+        }, []any{})
+
+        return vdom.H("div", nil,
+            vdom.ForEach(globalTodos, func(todo Todo) any {
+                return TodoItem(TodoItemProps{Todo: todo})
+            }),
+        )
+    },
+)
+```
+
+Key points for state management:
+
+- Global state is fine for simple data structures
+- Use functional setter when updating state based on its current value, especially in goroutines
+- Store complex state in refs when it needs to be accessed by goroutines
+- Use `UseEffect` cleanup function to handle component unmount
+- Call `SendAsyncInitiation()` after state changes in goroutines (consider round trip performance, so don't call at very high speeds)
+- Use atomic operations if globals are modified from multiple goroutines (or locks)
+
+## Global Keyboard Handling
+
+The Tsunami framework provides two approaches for handling keyboard events:
+
+1. Standard DOM event handling on elements:
+
+```go
+vdom.H("div", map[string]any{
+    "onKeyDown": func(e vdom.VDomEvent) {
+        // Handle key event
+    },
+})
+```
+
+2. Global keyboard event handling:
+
+```go
+func init() {
+    app.SetAppOpts(app.AppOpts{
+        CloseOnCtrlC:         true,
+        GlobalKeyboardEvents: true,  // Enable global keyboard events
+        Title:                "My Tsunami App",
+    })
+}
+
+// In main() or an effect:
+app.SetGlobalEventHandler(func(event vdom.VDomEvent) {
+    if event.EventType != "onKeyDown" || event.KeyData == nil {
+        return
+    }
+
+    switch event.KeyData.Key {
+    case "ArrowUp":
+        // Handle up arrow
+    case "ArrowDown":
+        // Handle down arrow
+    }
+})
+```
+
+The global handler approach is particularly useful when:
+
+- You need to handle keyboard events regardless of focus state
+- Building terminal-like applications that need consistent keyboard control
+- Implementing application-wide keyboard shortcuts
+- Managing navigation in full-screen applications
+
+Key differences:
+
+- Standard DOM events require the element to have focus
+- Global events work regardless of focus state
+- Global events can be used alongside regular DOM event handlers
+- Global handler receives all keyboard events for the application
+
+The event handler receives a VDomEvent with KeyData for keyboard events:
+
+```go
+type VDomEvent struct {
+    EventType       string             // e.g., "onKeyDown"
+    KeyData         *WaveKeyboardEvent `json:"keydata,omitempty"`
+    // ... other fields
+}
+
+type WaveKeyboardEvent struct {
+    Type     string // "keydown", "keyup", "keypress"
+    Key      string // The key value (e.g., "ArrowUp")
+    Code     string // Physical key code
+    Shift    bool   // Modifier states
+    Control  bool
+    Alt      bool
+    Meta     bool
+    Cmd      bool   // Meta on Mac, Alt on Windows/Linux
+    Option   bool   // Alt on Mac, Meta on Windows/Linux
+}
+```
+
+When using global keyboard events, remember to:
+
+1. Enable GlobalKeyboardEvents in AppOpts
+2. Set up the handler in a place where you have access to necessary state updates
+
+## File Handling
+
+The Tsunami framework can serve files to components. Any URL starting with `vdom://` will be handled by the registered handlers:
+
+```go
+// Register handlers for files (in the main func)
+app.RegisterFileHandler("/logo.png", app.FileHandlerOption{
+    FilePath: "./assets/logo.png",
+})
+
+// returning nil will produce a 404, path will be the full path, including the prefix
+app.RegisterFilePrefixHandler("/img/", func(path string) (*app.FileHandlerOption, error) {
+    return &app.FileHandlerOption{Data: data, MimeType: "image/png"}
+})
+
+// Use in components with vdom:// prefix
+vdom.H("img", map[string]any{
+    "src": "vdom:///logo.png",  // Note the vdom:// prefix
+    "alt": "Logo",
+    "style": map[string]any{
+        "background": "url(vdom:///logo.png)", // vdom urls can be used in CSS as well
+    },
+})
+```
+
+Files can come from:
+
+- Disk (FilePath)
+- Memory (Data + MimeType)
+- Stream (Reader)
+
+```
+type FileHandlerOption struct {
+	FilePath string    // optional file path on disk
+	Data     []byte    // optional byte slice content (easy to use with go:embed)
+	Reader   io.Reader // optional reader for content
+	File     fs.File   // optional embedded or opened file
+	MimeType string    // optional mime type
+	ETag     string    // optional ETag (if set, resource may be cached)
+}
+```
+
+Any URL passed to src attributes that starts with vdom:// will be handled by the registered handlers. All registered paths should be absolute (start with "/").
+
+Note that the system will attempt to detect the file type using the first 512 bytes of content. This works great for images, videos, and binary files. For text files which might be ambiguous (CSS, JSON, YAML, TOML, JavaScript, Go Code, Java, other programming languages) it can make sense to specify the mimetype (but usually only required if the frontend needs it for some reason).
+
+By default, files will not be cached. If you'd like to enable caching, pass an ETag. If a subsequent request comes and the ETag matches the system will used the cached content.
+
+## Tsunami App Template
+
+```go
+package main
+
+import (
+    "context"
+    _ "embed"
+    "strconv"
+
+    "github.com/wavetermdev/waveterm/tsunami/app"
+    "github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+func init() {
+    // Set up the default client with Tailwind styles and ctrl-c handling
+    app.SetAppOpts(app.AppOpts{
+        CloseOnCtrlC: true,
+        Title:        "My Tsunami App",
+    })
+}
+
+// Basic domain types with json tags for props
+type Todo struct {
+    Id        int    `json:"id"`
+    Text      string `json:"text"`
+    Completed bool   `json:"completed"`
+}
+
+type TodoItemProps struct {
+    Todo     Todo   `json:"todo"`
+    OnToggle func() `json:"onToggle"`
+    OnDelete func() `json:"onDelete"`
+}
+
+// Reusable components
+var TodoItem = app.DefineComponent("TodoItem",
+    func(ctx context.Context, props TodoItemProps) any {
+        return vdom.H("div", map[string]any{
+            "className": vdom.Classes("flex items-center gap-2.5 p-2 border border-border rounded", vdom.If(props.Todo.Completed, "opacity-70")),
+        },
+            vdom.H("input", map[string]any{
+                "className": "w-4 h-4",
+                "type":      "checkbox",
+                "checked":   props.Todo.Completed,
+                "onChange":  props.OnToggle,
+            }),
+            vdom.H("span", map[string]any{
+                "className": vdom.Classes("flex-1", vdom.If(props.Todo.Completed, "line-through")),
+            }, props.Todo.Text),
+            vdom.H("button", map[string]any{
+                "className": "text-red-500 cursor-pointer px-2 py-1 rounded",
+                "onClick":   props.OnDelete,
+            }, "×"),
+        )
+    },
+)
+
+// Root component must be named "App"
+var App = app.DefineComponent("App",
+    func(ctx context.Context, _ any) any {
+        // UseState returns 3 values: value, setter, functional setter
+        // Use ", _" to ignore the functional setter when not needed
+        todos, setTodos, _ := vdom.UseState(ctx, []Todo{
+            {Id: 1, Text: "Learn Tsunami", Completed: false},
+            {Id: 2, Text: "Build an app", Completed: false},
+        })
+        nextId, setNextId, _ := vdom.UseState(ctx, 3)
+        inputText, setInputText, _ := vdom.UseState(ctx, "")
+
+        // Event handlers
+        addTodo := func() {
+            if inputText == "" {
+                return
+            }
+            setTodos(append(todos, Todo{
+                Id:        nextId,
+                Text:      inputText,
+                Completed: false,
+            }))
+            setNextId(nextId + 1)
+            setInputText("")
+        }
+
+        toggleTodo := func(id int) {
+            newTodos := make([]Todo, len(todos))
+            copy(newTodos, todos)
+            for i := range newTodos {
+                if newTodos[i].Id == id {
+                    newTodos[i].Completed = !newTodos[i].Completed
+                    break
+                }
+            }
+            setTodos(newTodos)
+        }
+
+        deleteTodo := func(id int) {
+            newTodos := vdom.Filter(todos, func(todo Todo) bool {
+                return todo.Id != id
+            })
+            setTodos(newTodos)
+        }
+
+        return vdom.H("div", map[string]any{
+            "className": "max-w-[500px] m-5 font-sans",
+        },
+            vdom.H("h1", map[string]any{
+                "className": "text-2xl font-bold mb-5",
+            }, "My Tsunami App"),
+
+            vdom.H("div", map[string]any{
+                "className": "flex gap-2.5 mb-5",
+            },
+                vdom.H("input", map[string]any{
+                    "className":   "flex-1 p-2 border border-border rounded",
+                    "type":        "text",
+                    "placeholder": "Add new item...",
+                    "value":       inputText,
+                    "onChange": func(e vdom.VDomEvent) {
+                        setInputText(e.TargetValue)
+                    },
+                }),
+                vdom.H("button", map[string]any{
+                    "className": "px-4 py-2 border border-border rounded cursor-pointer",
+                    "onClick":   addTodo,
+                }, "Add"),
+            ),
+
+            vdom.H("div", map[string]any{
+                "className": "flex flex-col gap-2",
+            }, vdom.ForEach(todos, func(todo Todo) any {
+                return TodoItem(TodoItemProps{
+                    Todo:     todo,
+                    OnToggle: func() { toggleTodo(todo.Id) },
+                    OnDelete: func() { deleteTodo(todo.Id) },
+                }).WithKey(strconv.Itoa(todo.Id))
+            })),
+        )
+    },
+)
+
+```
+
+Key points:
+
+1. Root component must be named "App"
+2. Use `init()` function to configure app options
+3. No main() function is needed - the framework handles app lifecycle
+4. File handlers can be registered in init() if needed
+
+```
+type AppOpts struct {
+    Title                string // window title
+    CloseOnCtrlC         bool
+    GlobalKeyboardEvents bool
+}
+```
+
+## Important Technical Details
+
+- Props must be defined as Go structs with json tags
+- Components take their props type directly: `func MyComponent(ctx context.Context, props MyProps) any`
+- Always use app.DefineComponent for component registration
+- Call app.SendAsyncInitiation() after async state updates
+- Provide keys when using ForEach() with lists (using WithKey() method)
+- Use Classes() with If() for combining static and conditional class names
+- Consider cleanup functions in UseEffect() for async operations
+- <script> tags are not supported
+- Applications consist of a single file: app.go containing all Go code and component definitions
+- Styling is handled through Tailwind v4 CSS classes
+- No main() function is needed - use init() for configuration
+- This is a pure Go system - do not attempt to write React components or JavaScript code
+- All UI rendering, including complex visualizations, should be done through Go using vdom.H()
+
+The todo demo demonstrates all these patterns in a complete application.

From 384699a0ac62c52891a7937bc5d24e4372e2509f Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 13:54:17 -0700
Subject: [PATCH 045/134] remove closeonctrlc functionality

---
 tsunami/app/tsunamiapp.go                    |  2 --
 tsunami/demo/pomodoro/app.go                 |  3 +--
 tsunami/demo/todo/app.go                     |  5 ++---
 tsunami/frontend/src/model/tsunami-model.tsx |  5 -----
 tsunami/frontend/src/types/vdom.d.ts         |  1 -
 tsunami/prompt.md                            | 10 +++-------
 tsunami/rpctypes/types.go                    |  1 -
 7 files changed, 6 insertions(+), 21 deletions(-)

diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 486dce6381..2719a536b4 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -36,7 +36,6 @@ type SSEvent struct {
 
 type AppOpts struct {
 	Title                string // window title
-	CloseOnCtrlC         bool
 	GlobalKeyboardEvents bool
 }
 
@@ -133,7 +132,6 @@ func getFaviconPath() string {
 func (c *Client) makeBackendOpts() *rpctypes.VDomBackendOpts {
 	return &rpctypes.VDomBackendOpts{
 		Title:                c.AppOpts.Title,
-		CloseOnCtrlC:         c.AppOpts.CloseOnCtrlC,
 		GlobalKeyboardEvents: c.AppOpts.GlobalKeyboardEvents,
 		FaviconPath:          getFaviconPath(),
 	}
diff --git a/tsunami/demo/pomodoro/app.go b/tsunami/demo/pomodoro/app.go
index 15ec2dbf42..035bef9240 100644
--- a/tsunami/demo/pomodoro/app.go
+++ b/tsunami/demo/pomodoro/app.go
@@ -11,8 +11,7 @@ import (
 
 func init() {
 	app.SetAppOpts(app.AppOpts{
-		CloseOnCtrlC: true,
-		Title:        "Pomodoro Timer (Tsunami Demo)",
+		Title: "Pomodoro Timer (Tsunami Demo)",
 	})
 }
 
diff --git a/tsunami/demo/todo/app.go b/tsunami/demo/todo/app.go
index 2962a018e7..e33f5b6192 100644
--- a/tsunami/demo/todo/app.go
+++ b/tsunami/demo/todo/app.go
@@ -10,10 +10,9 @@ import (
 )
 
 func init() {
-	// Set up the default client with embedded Tailwind styles and ctrl-c handling
+	// Set up the default client with embedded Tailwind styles
 	app.SetAppOpts(app.AppOpts{
-		CloseOnCtrlC: true,
-		Title:        "Todo App (Tsunami Demo)",
+		Title: "Todo App (Tsunami Demo)",
 	})
 }
 
diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
index 5b86941370..d9b2c933fb 100644
--- a/tsunami/frontend/src/model/tsunami-model.tsx
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -180,11 +180,6 @@ export class TsunamiModel {
     }
 
     keyDownHandler(e: VDomKeyboardEvent): boolean {
-        if (this.backendOpts?.closeonctrlc && checkKeyPressed(e, "Ctrl:c")) {
-            this.shouldDispose = true;
-            this.queueUpdate(true);
-            return true;
-        }
         if (this.backendOpts?.globalkeyboardevents) {
             if (e.cmd || e.meta) {
                 return false;
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
index bdef3b9498..ec32c9b81c 100644
--- a/tsunami/frontend/src/types/vdom.d.ts
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -10,7 +10,6 @@ type VDomAsyncInitiationRequest = {
 
 // vdom.VDomBackendOpts
 type VDomBackendOpts = {
-    closeonctrlc?: boolean;
     globalkeyboardevents?: boolean;
     title?: string;
     faviconpath?: string;
diff --git a/tsunami/prompt.md b/tsunami/prompt.md
index 3636c20998..74cf450fe4 100644
--- a/tsunami/prompt.md
+++ b/tsunami/prompt.md
@@ -22,8 +22,7 @@ Tsunami applications use a default client configured through `app.SetAppOpts()`
 func init() {
     // Set up the default client with options
     app.SetAppOpts(app.AppOpts{
-        CloseOnCtrlC: true,
-        Title:        "My Tsunami App",
+        Title: "My Tsunami App",
     })
 }
 
@@ -590,7 +589,6 @@ vdom.H("div", map[string]any{
 ```go
 func init() {
     app.SetAppOpts(app.AppOpts{
-        CloseOnCtrlC:         true,
         GlobalKeyboardEvents: true,  // Enable global keyboard events
         Title:                "My Tsunami App",
     })
@@ -715,10 +713,9 @@ import (
 )
 
 func init() {
-    // Set up the default client with Tailwind styles and ctrl-c handling
+    // Set up the default client with Tailwind styles
     app.SetAppOpts(app.AppOpts{
-        CloseOnCtrlC: true,
-        Title:        "My Tsunami App",
+        Title: "My Tsunami App",
     })
 }
 
@@ -853,7 +850,6 @@ Key points:
 ```
 type AppOpts struct {
     Title                string // window title
-    CloseOnCtrlC         bool
     GlobalKeyboardEvents bool
 }
 ```
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/types.go
index 9ff99bf708..9137410060 100644
--- a/tsunami/rpctypes/types.go
+++ b/tsunami/rpctypes/types.go
@@ -169,7 +169,6 @@ type VDomRefUpdate struct {
 
 type VDomBackendOpts struct {
 	Title                string `json:"title,omitempty"`
-	CloseOnCtrlC         bool   `json:"closeonctrlc,omitempty"`
 	GlobalKeyboardEvents bool   `json:"globalkeyboardevents,omitempty"`
 	FaviconPath          string `json:"faviconpath,omitempty"`
 }

From 131a3eef737e3015779912919dff3ed805d42d7f Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 16:18:53 -0700
Subject: [PATCH 046/134] remove AppOpts, move title to hook, derrive
 GlobalKeyboardHandler... update prompt, etc...

---
 tsunami/app/defaultclient.go                  |  5 +-
 tsunami/app/serverhandlers.go                 | 12 ++--
 tsunami/app/tsunamiapp.go                     | 20 ++-----
 tsunami/build/build.go                        | 12 ++--
 tsunami/comp/rootelem.go                      |  1 +
 tsunami/comp/vdomcontext.go                   | 11 ++++
 tsunami/demo/pomodoro/app.go                  |  7 +--
 tsunami/demo/todo/app.go                      |  8 +--
 tsunami/prompt.md                             | 60 +++++++------------
 .../rpctypes/{types.go => protocoltypes.go}   |  0
 tsunami/vdom/vdom.go                          | 17 ++++++
 tsunami/vdom/vdom_context.go                  |  2 +
 tsunami/vdom/vdom_types.go                    |  4 +-
 13 files changed, 76 insertions(+), 83 deletions(-)
 rename tsunami/rpctypes/{types.go => protocoltypes.go} (100%)

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 6cafc4b16c..553ce526e4 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -11,7 +11,7 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-var defaultClient = MakeClient(AppOpts{})
+var defaultClient = MakeClient()
 var assetsFS fs.FS
 var staticFS fs.FS
 var manifestFile *FileHandlerOption
@@ -26,9 +26,6 @@ func SetGlobalEventHandler(handler func(client *Client, event vdom.VDomEvent)) {
 	defaultClient.SetGlobalEventHandler(handler)
 }
 
-func SetAppOpts(appOpts AppOpts) {
-	defaultClient.SetAppOpts(appOpts)
-}
 
 func AddSetupFn(fn func()) {
 	defaultClient.AddSetupFn(fn)
diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index 5feb9e5f93..022a93549c 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -49,7 +49,7 @@ func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux, opts HandlerOpts) {
 	mux.HandleFunc("/api/data", h.handleData)
 	mux.HandleFunc("/api/config", h.handleConfig)
 	mux.HandleFunc("/api/manifest", h.handleManifest(opts.ManifestFile))
-	mux.HandleFunc("/files/", h.handleAssetsUrl)
+	mux.HandleFunc("/dyn/", h.handleDynContent)
 
 	// Add handler for static files at /static/ path
 	if opts.StaticFS != nil {
@@ -235,24 +235,20 @@ func (h *HTTPHandlers) handleConfigPost(w http.ResponseWriter, r *http.Request)
 	w.WriteHeader(http.StatusOK)
 }
 
-func (h *HTTPHandlers) handleAssetsUrl(w http.ResponseWriter, r *http.Request) {
+func (h *HTTPHandlers) handleDynContent(w http.ResponseWriter, r *http.Request) {
 	defer func() {
-		panicErr := util.PanicHandler("handleAssetsUrl", recover())
+		panicErr := util.PanicHandler("handleDynContent", recover())
 		if panicErr != nil {
 			http.Error(w, fmt.Sprintf("internal server error: %v", panicErr), http.StatusInternalServerError)
 		}
 	}()
 
 	// Strip /assets prefix and update the request URL
-	r.URL.Path = strings.TrimPrefix(r.URL.Path, "/assets")
+	r.URL.Path = strings.TrimPrefix(r.URL.Path, "/dyn")
 	if r.URL.Path == "" {
 		r.URL.Path = "/"
 	}
 
-	if r.URL.Path == "/global.css" && h.Client.GlobalStylesOption != nil {
-		ServeFileOption(w, r, *h.Client.GlobalStylesOption)
-		return
-	}
 	h.Client.UrlHandlerMux.ServeHTTP(w, r)
 }
 
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 2719a536b4..0829f4face 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -34,14 +34,8 @@ type SSEvent struct {
 	Data  []byte
 }
 
-type AppOpts struct {
-	Title                string // window title
-	GlobalKeyboardEvents bool
-}
-
 type Client struct {
 	Lock               *sync.Mutex
-	AppOpts            AppOpts
 	Root               *comp.RootElem
 	RootElem           *vdom.VDomElem
 	CurrentClientId    string
@@ -56,7 +50,7 @@ type Client struct {
 	SetupFn            func()
 }
 
-func MakeClient(appOpts AppOpts) *Client {
+func MakeClient() *Client {
 	client := &Client{
 		Lock:          &sync.Mutex{},
 		Root:          comp.MakeRoot(),
@@ -66,7 +60,6 @@ func MakeClient(appOpts AppOpts) *Client {
 		ServerId:      uuid.New().String(),
 		RootElem:      vdom.E(DefaultComponentName),
 	}
-	client.SetAppOpts(appOpts)
 	return client
 }
 
@@ -110,12 +103,6 @@ func (c *Client) SetGlobalEventHandler(handler func(client *Client, event vdom.V
 	c.GlobalEventHandler = handler
 }
 
-func (c *Client) SetAppOpts(appOpts AppOpts) {
-	c.Lock.Lock()
-	defer c.Lock.Unlock()
-
-	c.AppOpts = appOpts
-}
 
 func getFaviconPath() string {
 	if staticFS != nil {
@@ -131,8 +118,8 @@ func getFaviconPath() string {
 
 func (c *Client) makeBackendOpts() *rpctypes.VDomBackendOpts {
 	return &rpctypes.VDomBackendOpts{
-		Title:                c.AppOpts.Title,
-		GlobalKeyboardEvents: c.AppOpts.GlobalKeyboardEvents,
+		Title:                c.Root.AppTitle,
+		GlobalKeyboardEvents: c.GlobalEventHandler != nil,
 		FaviconPath:          getFaviconPath(),
 	}
 }
@@ -298,6 +285,7 @@ func (c *Client) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 		Type:     "backendupdate",
 		Ts:       time.Now().UnixMilli(),
 		ServerId: c.ServerId,
+		Opts:     c.makeBackendOpts(),
 		RenderUpdates: []rpctypes.VDomRenderUpdate{
 			{UpdateType: "root", VDom: renderedVDom},
 		},
diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 5bdbd74056..68e7f86be2 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -20,6 +20,8 @@ import (
 	"golang.org/x/mod/modfile"
 )
 
+const MinSupportedGoMinorVersion = 22
+
 type BuildOpts struct {
 	Dir            string
 	Verbose        bool
@@ -50,13 +52,13 @@ func verifyEnvironment(verbose bool) (*BuildEnv, error) {
 		return nil, fmt.Errorf("failed to run 'go version': %w", err)
 	}
 
-	// Parse go version output and check for 1.21+
+	// Parse go version output and check for 1.22+
 	versionStr := strings.TrimSpace(string(output))
 	if verbose {
 		log.Printf("Found %s", versionStr)
 	}
 
-	// Extract version like "go1.21.0" from output
+	// Extract version like "go1.22.0" from output
 	versionRegex := regexp.MustCompile(`go(1\.\d+)`)
 	matches := versionRegex.FindStringSubmatch(versionStr)
 	if len(matches) < 2 {
@@ -65,7 +67,7 @@ func verifyEnvironment(verbose bool) (*BuildEnv, error) {
 
 	goVersion := matches[1]
 
-	// Check if version is 1.21+
+	// Check if version is 1.22+
 	minorRegex := regexp.MustCompile(`1\.(\d+)`)
 	minorMatches := minorRegex.FindStringSubmatch(goVersion)
 	if len(minorMatches) < 2 {
@@ -73,8 +75,8 @@ func verifyEnvironment(verbose bool) (*BuildEnv, error) {
 	}
 
 	minor, err := strconv.Atoi(minorMatches[1])
-	if err != nil || minor < 21 {
-		return nil, fmt.Errorf("go version 1.21 or higher required, found: %s", versionStr)
+	if err != nil || minor < MinSupportedGoMinorVersion {
+		return nil, fmt.Errorf("go version 1.%d or higher required, found: %s", MinSupportedGoMinorVersion, versionStr)
 	}
 
 	// Check if npx is in PATH
diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index 0ab5197833..dfa57b1677 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -26,6 +26,7 @@ type RootElem struct {
 	OuterCtx        context.Context
 	Root            *ComponentImpl
 	RenderTs        int64
+	AppTitle        string
 	CFuncs          map[string]any
 	CompMap         map[string]*ComponentImpl // component waveid -> component
 	EffectWorkQueue []*vdom.EffectWorkElem
diff --git a/tsunami/comp/vdomcontext.go b/tsunami/comp/vdomcontext.go
index 59d09bb857..4299089a89 100644
--- a/tsunami/comp/vdomcontext.go
+++ b/tsunami/comp/vdomcontext.go
@@ -72,3 +72,14 @@ func (vc *VDomContextVal) IsResync() bool {
 	}
 	return vc.RenderOpts.Resync
 }
+
+func (vc *VDomContextVal) GetCompName() string {
+	if vc.Comp == nil || vc.Comp.Elem == nil {
+		return ""
+	}
+	return vc.Comp.Elem.Tag
+}
+
+func (vc *VDomContextVal) SetAppTitle(title string) {
+	vc.Root.AppTitle = title
+}
diff --git a/tsunami/demo/pomodoro/app.go b/tsunami/demo/pomodoro/app.go
index 035bef9240..a2de040627 100644
--- a/tsunami/demo/pomodoro/app.go
+++ b/tsunami/demo/pomodoro/app.go
@@ -9,11 +9,6 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-func init() {
-	app.SetAppOpts(app.AppOpts{
-		Title: "Pomodoro Timer (Tsunami Demo)",
-	})
-}
 
 type Mode struct {
 	Name     string `json:"name"`
@@ -103,6 +98,8 @@ var ControlButtons = app.DefineComponent("ControlButtons",
 
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ any) any {
+		vdom.UseSetAppTitle(ctx, "Pomodoro Timer (Tsunami Demo)")
+		
 		isRunning, setIsRunning, _ := vdom.UseState(ctx, false)
 		minutes, setMinutes, _ := vdom.UseState(ctx, WorkMode.Duration)
 		seconds, setSeconds, _ := vdom.UseState(ctx, 0)
diff --git a/tsunami/demo/todo/app.go b/tsunami/demo/todo/app.go
index e33f5b6192..840bcb25ea 100644
--- a/tsunami/demo/todo/app.go
+++ b/tsunami/demo/todo/app.go
@@ -9,12 +9,6 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-func init() {
-	// Set up the default client with embedded Tailwind styles
-	app.SetAppOpts(app.AppOpts{
-		Title: "Todo App (Tsunami Demo)",
-	})
-}
 
 // Basic domain types with json tags for props
 type Todo struct {
@@ -108,6 +102,8 @@ var TodoList = app.DefineComponent("TodoList",
 // Root component showing state management and composition
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ any) any {
+		vdom.UseSetAppTitle(ctx, "Todo App (Tsunami Demo)")
+		
 		// Multiple state hooks example
 		todos, setTodos, _ := vdom.UseState(ctx, []Todo{
 			{Id: 1, Text: "Learn VDOM", Completed: false},
diff --git a/tsunami/prompt.md b/tsunami/prompt.md
index 74cf450fe4..59d98f2883 100644
--- a/tsunami/prompt.md
+++ b/tsunami/prompt.md
@@ -16,22 +16,26 @@ The included todo-main.go provides a complete example application showing these
 
 ## App Setup and Registration
 
-Tsunami applications use a default client configured through `app.SetAppOpts()` in an `init()` function:
+Tsunami applications define components using the default client:
 
 ```go
-func init() {
-    // Set up the default client with options
-    app.SetAppOpts(app.AppOpts{
-        Title: "My Tsunami App",
-    })
-}
-
 // Components are defined using the default client
 var MyComponent = app.DefineComponent("MyComponent",
     func(ctx context.Context, props MyProps) any {
         // component logic
     },
 )
+
+// The main "App" component can set the app title
+var App = app.DefineComponent("App",
+    func(ctx context.Context, _ struct{}) any {
+        vdom.UseSetAppTitle(ctx, "My Tsunami App")  // Only works in top-level App component
+
+        return vdom.H("div", nil,
+            // app content
+        )
+    },
+)
 ```
 
 ## Building Elements with vdom.H()
@@ -183,7 +187,7 @@ Helper functions:
 
 ## Style Handling
 
-Tsunami applications use Tailwind v4 CSS by default for styling. You can also define inline styles using a map[string]any in the props:
+Tsunami applications use Tailwind v4 CSS by default for styling (className prop). You can also define inline styles using a map[string]any in the props:
 
 ```go
 vdom.H("div", map[string]any{
@@ -385,7 +389,7 @@ func MyComponent(ctx context.Context, props MyProps) any {
     vdom.UseEffect(ctx, func() func() {
         // Example: set counter to 10 on mount
         setCounter(10)
-        
+
         return func() {
             // cleanup
         }
@@ -587,15 +591,9 @@ vdom.H("div", map[string]any{
 2. Global keyboard event handling:
 
 ```go
+// Global keyboard events are automatically enabled when you set a global event handler
 func init() {
-    app.SetAppOpts(app.AppOpts{
-        GlobalKeyboardEvents: true,  // Enable global keyboard events
-        Title:                "My Tsunami App",
-    })
-}
-
-// In main() or an effect:
-app.SetGlobalEventHandler(func(event vdom.VDomEvent) {
+    app.SetGlobalEventHandler(func(event vdom.VDomEvent) {
     if event.EventType != "onKeyDown" || event.KeyData == nil {
         return
     }
@@ -645,10 +643,9 @@ type WaveKeyboardEvent struct {
 }
 ```
 
-When using global keyboard events, remember to:
+When using global keyboard events:
 
-1. Enable GlobalKeyboardEvents in AppOpts
-2. Set up the handler in a place where you have access to necessary state updates
+Global keyboard events are automatically enabled when you set a global event handler. Set up the handler in a place where you have access to necessary state updates.
 
 ## File Handling
 
@@ -712,12 +709,8 @@ import (
     "github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-func init() {
-    // Set up the default client with Tailwind styles
-    app.SetAppOpts(app.AppOpts{
-        Title: "My Tsunami App",
-    })
-}
+// Tsunami applications automatically include Tailwind v4 CSS
+// No setup required - just use Tailwind classes in your components
 
 // Basic domain types with json tags for props
 type Todo struct {
@@ -843,17 +836,10 @@ var App = app.DefineComponent("App",
 Key points:
 
 1. Root component must be named "App"
-2. Use `init()` function to configure app options
-3. No main() function is needed - the framework handles app lifecycle
+2. Use `vdom.UseSetAppTitle()` in the main App component to set the window title
+3. Do NOT write a main() function - the framework handles app lifecycle
 4. File handlers can be registered in init() if needed
 
-```
-type AppOpts struct {
-    Title                string // window title
-    GlobalKeyboardEvents bool
-}
-```
-
 ## Important Technical Details
 
 - Props must be defined as Go structs with json tags
@@ -863,7 +849,7 @@ type AppOpts struct {
 - Provide keys when using ForEach() with lists (using WithKey() method)
 - Use Classes() with If() for combining static and conditional class names
 - Consider cleanup functions in UseEffect() for async operations
-- <script> tags are not supported
+- <script> tags are NOT supported
 - Applications consist of a single file: app.go containing all Go code and component definitions
 - Styling is handled through Tailwind v4 CSS classes
 - No main() function is needed - use init() for configuration
diff --git a/tsunami/rpctypes/types.go b/tsunami/rpctypes/protocoltypes.go
similarity index 100%
rename from tsunami/rpctypes/types.go
rename to tsunami/rpctypes/protocoltypes.go
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index bb9abfb922..5229e49261 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -453,6 +453,23 @@ func UseEffect(ctx context.Context, fn func() func(), deps []any) {
 	vc.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
 }
 
+func UseSetAppTitle(ctx context.Context, title string) {
+	vc := GetRenderContext(ctx)
+	if vc == nil {
+		log.Printf("UseSetAppTitle must be called within a component (no context)")
+		return
+	}
+	
+	// Check if this is being called from the App component
+	if vc.GetCompName() != "App" {
+		log.Printf("UseSetAppTitle can only be called from the App component")
+		return
+	}
+	
+	// Set the title on the RootElem
+	vc.SetAppTitle(title)
+}
+
 func PartToElems(part any) []VDomElem {
 	if part == nil {
 		return nil
diff --git a/tsunami/vdom/vdom_context.go b/tsunami/vdom/vdom_context.go
index bebecfdb0b..6ac838a703 100644
--- a/tsunami/vdom/vdom_context.go
+++ b/tsunami/vdom/vdom_context.go
@@ -22,6 +22,8 @@ type VDomContext interface {
 	GetCompWaveId() string
 	GetOrderedHook() *Hook
 	IsResync() bool
+	GetCompName() string
+	SetAppTitle(title string)
 }
 
 func WithRenderContext(ctx context.Context, vc VDomContext) context.Context {
diff --git a/tsunami/vdom/vdom_types.go b/tsunami/vdom/vdom_types.go
index 56664a13de..9efbdaf75e 100644
--- a/tsunami/vdom/vdom_types.go
+++ b/tsunami/vdom/vdom_types.go
@@ -61,8 +61,8 @@ type VDomBinding struct {
 type VDomFunc struct {
 	Fn              any      `json:"-"` // server side function (called with reflection)
 	Type            string   `json:"type" tstype:"\"func\""`
-	StopPropagation bool     `json:"stoppropagation,omitempty"`
-	PreventDefault  bool     `json:"preventdefault,omitempty"`
+	StopPropagation bool     `json:"stoppropagation,omitempty"` // set to call e.stopPropagation() on the client side
+	PreventDefault  bool     `json:"preventdefault,omitempty"`  // set to call e.preventDefault() on the client side
 	GlobalEvent     string   `json:"globalevent,omitempty"`
 	Keys            []string `json:"#keys,omitempty"` // special for keyDown events a list of keys to "capture"
 }

From f8cbbe0f4fc19657935755e0d1660073c2b61b58 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 16:54:57 -0700
Subject: [PATCH 047/134] simplify.  remove vdom.E(), remove gorilla/mux,
 remove vdom.Bind(), remove cssparser...

---
 tsunami/app/tsunamiapp.go                |  16 +-
 tsunami/comp/root_test.go                |  27 +-
 tsunami/demo/pomodoro/app.go             |  71 ++--
 tsunami/go.mod                           |   3 -
 tsunami/go.sum                           |   6 -
 tsunami/vdom/cssparser/cssparser.go      | 159 ---------
 tsunami/vdom/cssparser/cssparser_test.go |  81 -----
 tsunami/vdom/vdom.go                     | 158 +--------
 tsunami/vdom/vdom_html.go                | 426 -----------------------
 tsunami/vdom/vdom_test.go                |  33 +-
 10 files changed, 79 insertions(+), 901 deletions(-)
 delete mode 100644 tsunami/vdom/cssparser/cssparser.go
 delete mode 100644 tsunami/vdom/cssparser/cssparser_test.go
 delete mode 100644 tsunami/vdom/vdom_html.go

diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 0829f4face..ff11bd79fe 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -18,7 +18,6 @@ import (
 	"unicode"
 
 	"github.com/google/uuid"
-	"github.com/gorilla/mux"
 	"github.com/wavetermdev/waveterm/tsunami/comp"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
@@ -46,7 +45,7 @@ type Client struct {
 	SSEventCh          chan SSEvent
 	GlobalEventHandler func(client *Client, event vdom.VDomEvent)
 	GlobalStylesOption *FileHandlerOption
-	UrlHandlerMux      *mux.Router
+	UrlHandlerMux      *http.ServeMux
 	SetupFn            func()
 }
 
@@ -56,9 +55,9 @@ func MakeClient() *Client {
 		Root:          comp.MakeRoot(),
 		DoneCh:        make(chan struct{}),
 		SSEventCh:     make(chan SSEvent, 100),
-		UrlHandlerMux: mux.NewRouter(),
+		UrlHandlerMux: http.NewServeMux(),
 		ServerId:      uuid.New().String(),
-		RootElem:      vdom.E(DefaultComponentName),
+		RootElem:      vdom.H(DefaultComponentName, nil),
 	}
 	return client
 }
@@ -103,7 +102,6 @@ func (c *Client) SetGlobalEventHandler(handler func(client *Client, event vdom.V
 	c.GlobalEventHandler = handler
 }
 
-
 func getFaviconPath() string {
 	if staticFS != nil {
 		faviconNames := []string{"favicon.ico", "favicon.png", "favicon.svg", "favicon.gif", "favicon.jpg"}
@@ -244,7 +242,7 @@ func DefineComponentEx[P any](client *Client, name string, renderFn func(ctx con
 		panic(err)
 	}
 	return func(props P) *vdom.VDomElem {
-		return vdom.E(name, vdom.Props(props))
+		return vdom.H(name, vdom.Props(props))
 	}
 }
 
@@ -426,7 +424,11 @@ func ServeFileOption(w http.ResponseWriter, r *http.Request, option FileHandlerO
 }
 
 func (c *Client) RegisterFilePrefixHandler(prefix string, optionProvider func(path string) (*FileHandlerOption, error)) {
-	c.UrlHandlerMux.PathPrefix(prefix).HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	c.UrlHandlerMux.HandleFunc(prefix, func(w http.ResponseWriter, r *http.Request) {
+		if !strings.HasPrefix(r.URL.Path, prefix) {
+			http.NotFound(w, r)
+			return
+		}
 		option, err := optionProvider(r.URL.Path)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
diff --git a/tsunami/comp/root_test.go b/tsunami/comp/root_test.go
index 346b30b58f..518cc2cca3 100644
--- a/tsunami/comp/root_test.go
+++ b/tsunami/comp/root_test.go
@@ -25,21 +25,16 @@ func Page(ctx context.Context, props map[string]any) any {
 	clicked, setClicked, _ := vdom.UseState(ctx, false)
 	var clickedDiv *vdom.VDomElem
 	if clicked {
-		clickedDiv = vdom.Bind(`<div>clicked</div>`, nil)
+		clickedDiv = vdom.H("div", nil, "clicked")
 	}
 	clickFn := func() {
 		log.Printf("run clickFn\n")
 		setClicked(true)
 	}
-	return vdom.Bind(
-		`
-<div>
-    <h1>hello world</h1>
-	<Button onClick="#param:clickFn">hello</Button>
-	<bindparam key="clickedDiv"/>
-</div>
-`,
-		map[string]any{"clickFn": clickFn, "clickedDiv": clickedDiv},
+	return vdom.H("div", nil,
+		vdom.H("h1", nil, "hello world"),
+		vdom.H("Button", map[string]any{"onClick": clickFn}, "hello"),
+		clickedDiv,
 	)
 }
 
@@ -56,11 +51,11 @@ func Button(ctx context.Context, props map[string]any) any {
 	if testContext != nil {
 		testContext.ButtonId = compId
 	}
-	return vdom.Bind(`
-		<div className="#param:clName" ref="#param:ref" onClick="#param:onClick">
-			<bindparam key="children"/>
-		</div>
-	`, map[string]any{"clName": clName, "ref": ref, "onClick": props["onClick"], "children": props["children"]})
+	return vdom.H("div", map[string]any{
+		"className": clName,
+		"ref":       ref,
+		"onClick":   props["onClick"],
+	}, props["children"])
 }
 
 func printVDom(root *RootElem) {
@@ -85,7 +80,7 @@ func Test1(t *testing.T) {
 	root.SetOuterCtx(ctx)
 	root.RegisterComponent("Page", Page)
 	root.RegisterComponent("Button", Button)
-	root.Render(vdom.E("Page"), &RenderOpts{Resync: false})
+	root.Render(vdom.H("Page", nil), &RenderOpts{Resync: false})
 	if root.Root == nil {
 		t.Fatalf("root.Root is nil")
 	}
diff --git a/tsunami/demo/pomodoro/app.go b/tsunami/demo/pomodoro/app.go
index a2de040627..ad981f4f51 100644
--- a/tsunami/demo/pomodoro/app.go
+++ b/tsunami/demo/pomodoro/app.go
@@ -9,7 +9,6 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-
 type Mode struct {
 	Name     string `json:"name"`
 	Duration int    `json:"duration"` // in minutes
@@ -44,14 +43,14 @@ type TimerState struct {
 
 var TimerDisplay = app.DefineComponent("TimerDisplay",
 	func(ctx context.Context, props TimerDisplayProps) any {
-		return vdom.E("div",
-			vdom.Class("bg-slate-700 p-8 rounded-lg mb-8 text-center"),
-			vdom.E("div",
-				vdom.Class("text-xl text-blue-400 mb-2"),
+		return vdom.H("div",
+			map[string]any{"className": "bg-slate-700 p-8 rounded-lg mb-8 text-center"},
+			vdom.H("div",
+				map[string]any{"className": "text-xl text-blue-400 mb-2"},
 				props.Mode,
 			),
-			vdom.E("div",
-				vdom.Class("text-6xl font-bold font-mono text-slate-100"),
+			vdom.H("div",
+				map[string]any{"className": "text-6xl font-bold font-mono text-slate-100"},
 				fmt.Sprintf("%02d:%02d", props.Minutes, props.Seconds),
 			),
 		)
@@ -60,35 +59,45 @@ var TimerDisplay = app.DefineComponent("TimerDisplay",
 
 var ControlButtons = app.DefineComponent("ControlButtons",
 	func(ctx context.Context, props ControlButtonsProps) any {
-		return vdom.E("div",
-			vdom.Class("flex flex-col gap-4"),
+		return vdom.H("div",
+			map[string]any{"className": "flex flex-col gap-4"},
 			vdom.IfElse(props.IsRunning,
-				vdom.E("button",
-					vdom.Class("px-6 py-3 text-lg border-none rounded bg-blue-500 text-white cursor-pointer hover:bg-blue-600 transition-colors duration-200"),
-					vdom.P("onClick", props.OnPause),
+				vdom.H("button",
+					map[string]any{
+						"className": "px-6 py-3 text-lg border-none rounded bg-blue-500 text-white cursor-pointer hover:bg-blue-600 transition-colors duration-200",
+						"onClick":   props.OnPause,
+					},
 					"Pause",
 				),
-				vdom.E("button",
-					vdom.Class("px-6 py-3 text-lg border-none rounded bg-blue-500 text-white cursor-pointer hover:bg-blue-600 transition-colors duration-200"),
-					vdom.P("onClick", props.OnStart),
+				vdom.H("button",
+					map[string]any{
+						"className": "px-6 py-3 text-lg border-none rounded bg-blue-500 text-white cursor-pointer hover:bg-blue-600 transition-colors duration-200",
+						"onClick":   props.OnStart,
+					},
 					"Start",
 				),
 			),
-			vdom.E("button",
-				vdom.Class("px-6 py-3 text-lg border-none rounded bg-blue-500 text-white cursor-pointer hover:bg-blue-600 transition-colors duration-200"),
-				vdom.P("onClick", props.OnReset),
+			vdom.H("button",
+				map[string]any{
+					"className": "px-6 py-3 text-lg border-none rounded bg-blue-500 text-white cursor-pointer hover:bg-blue-600 transition-colors duration-200",
+					"onClick":   props.OnReset,
+				},
 				"Reset",
 			),
-			vdom.E("div",
-				vdom.Class("flex gap-4 mt-4"),
-				vdom.E("button",
-					vdom.Class("flex-1 px-3 py-3 text-base border-none rounded bg-green-500 text-white cursor-pointer hover:bg-green-600 transition-colors duration-200"),
-					vdom.P("onClick", func() { props.OnMode(WorkMode.Duration) }),
+			vdom.H("div",
+				map[string]any{"className": "flex gap-4 mt-4"},
+				vdom.H("button",
+					map[string]any{
+						"className": "flex-1 px-3 py-3 text-base border-none rounded bg-green-500 text-white cursor-pointer hover:bg-green-600 transition-colors duration-200",
+						"onClick":   func() { props.OnMode(WorkMode.Duration) },
+					},
 					"Work Mode",
 				),
-				vdom.E("button",
-					vdom.Class("flex-1 px-3 py-3 text-base border-none rounded bg-green-500 text-white cursor-pointer hover:bg-green-600 transition-colors duration-200"),
-					vdom.P("onClick", func() { props.OnMode(BreakMode.Duration) }),
+				vdom.H("button",
+					map[string]any{
+						"className": "flex-1 px-3 py-3 text-base border-none rounded bg-green-500 text-white cursor-pointer hover:bg-green-600 transition-colors duration-200",
+						"onClick":   func() { props.OnMode(BreakMode.Duration) },
+					},
 					"Break Mode",
 				),
 			),
@@ -99,7 +108,7 @@ var ControlButtons = app.DefineComponent("ControlButtons",
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ any) any {
 		vdom.UseSetAppTitle(ctx, "Pomodoro Timer (Tsunami Demo)")
-		
+
 		isRunning, setIsRunning, _ := vdom.UseState(ctx, false)
 		minutes, setMinutes, _ := vdom.UseState(ctx, WorkMode.Duration)
 		seconds, setSeconds, _ := vdom.UseState(ctx, 0)
@@ -210,10 +219,10 @@ var App = app.DefineComponent("App",
 			}
 		}, []any{})
 
-		return vdom.E("div",
-			vdom.Class("max-w-sm mx-auto my-8 p-8 bg-slate-800 rounded-xl text-slate-100 font-sans"),
-			vdom.E("h1",
-				vdom.Class("text-center text-slate-100 mb-8 text-3xl"),
+		return vdom.H("div",
+			map[string]any{"className": "max-w-sm mx-auto my-8 p-8 bg-slate-800 rounded-xl text-slate-100 font-sans"},
+			vdom.H("h1",
+				map[string]any{"className": "text-center text-slate-100 mb-8 text-3xl"},
 				"Pomodoro Timer",
 			),
 			TimerDisplay(TimerDisplayProps{
diff --git a/tsunami/go.mod b/tsunami/go.mod
index a4de9dea20..2f9a557fb6 100644
--- a/tsunami/go.mod
+++ b/tsunami/go.mod
@@ -4,14 +4,11 @@ go 1.24.6
 
 require (
 	github.com/google/uuid v1.6.0
-	github.com/gorilla/mux v1.8.1
 	github.com/spf13/cobra v1.10.1
-	github.com/wavetermdev/htmltoken v0.2.0
 	golang.org/x/mod v0.27.0
 )
 
 require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.9 // indirect
-	golang.org/x/net v0.43.0 // indirect
 )
diff --git a/tsunami/go.sum b/tsunami/go.sum
index 4f3b18dd07..9aaf33b329 100644
--- a/tsunami/go.sum
+++ b/tsunami/go.sum
@@ -1,8 +1,6 @@
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
-github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
@@ -10,11 +8,7 @@ github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
 github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
 github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/wavetermdev/htmltoken v0.2.0 h1:sFVPPemlDv7/jg7n4Hx1AEF2m9MVAFjFpELWfhi/DlM=
-github.com/wavetermdev/htmltoken v0.2.0/go.mod h1:5FM0XV6zNYiNza2iaTcFGj+hnMtgqumFHO31Z8euquk=
 golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
 golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/tsunami/vdom/cssparser/cssparser.go b/tsunami/vdom/cssparser/cssparser.go
deleted file mode 100644
index a430624d5f..0000000000
--- a/tsunami/vdom/cssparser/cssparser.go
+++ /dev/null
@@ -1,159 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package cssparser
-
-import (
-	"fmt"
-	"strings"
-	"unicode"
-)
-
-type Parser struct {
-	Input      string
-	Pos        int
-	Length     int
-	InQuote    bool
-	QuoteChar  rune
-	OpenParens int
-	Debug      bool
-}
-
-func MakeParser(input string) *Parser {
-	return &Parser{
-		Input:  input,
-		Length: len(input),
-	}
-}
-
-func (p *Parser) Parse() (map[string]string, error) {
-	result := make(map[string]string)
-	lastProp := ""
-	for {
-		p.skipWhitespace()
-		if p.eof() {
-			break
-		}
-		propName, err := p.parseIdentifierColon(lastProp)
-		if err != nil {
-			return nil, err
-		}
-		lastProp = propName
-		p.skipWhitespace()
-		value, err := p.parseValue(propName)
-		if err != nil {
-			return nil, err
-		}
-		result[propName] = value
-		p.skipWhitespace()
-		if p.eof() {
-			break
-		}
-		if !p.expectChar(';') {
-			break
-		}
-	}
-	p.skipWhitespace()
-	if !p.eof() {
-		return nil, fmt.Errorf("bad style attribute, unexpected character %q at pos %d", string(p.Input[p.Pos]), p.Pos+1)
-	}
-	return result, nil
-}
-
-func (p *Parser) parseIdentifierColon(lastProp string) (string, error) {
-	start := p.Pos
-	for !p.eof() {
-		c := p.peekChar()
-		if isIdentChar(c) || c == '-' {
-			p.advance()
-		} else {
-			break
-		}
-	}
-	attrName := p.Input[start:p.Pos]
-	p.skipWhitespace()
-	if p.eof() {
-		return "", fmt.Errorf("bad style attribute, expected colon after property %q, got EOF, at pos %d", attrName, p.Pos+1)
-	}
-	if attrName == "" {
-		return "", fmt.Errorf("bad style attribute, invalid property name after property %q, at pos %d", lastProp, p.Pos+1)
-	}
-	if !p.expectChar(':') {
-		return "", fmt.Errorf("bad style attribute, bad property name starting with %q, expected colon, got %q, at pos %d", attrName, string(p.Input[p.Pos]), p.Pos+1)
-	}
-	return attrName, nil
-}
-
-func (p *Parser) parseValue(propName string) (string, error) {
-	start := p.Pos
-	quotePos := 0
-	parenPosStack := make([]int, 0)
-	for !p.eof() {
-		c := p.peekChar()
-		if p.InQuote {
-			if c == p.QuoteChar {
-				p.InQuote = false
-			} else if c == '\\' {
-				p.advance()
-			}
-		} else {
-			if c == '"' || c == '\'' {
-				p.InQuote = true
-				p.QuoteChar = c
-				quotePos = p.Pos
-			} else if c == '(' {
-				p.OpenParens++
-				parenPosStack = append(parenPosStack, p.Pos)
-			} else if c == ')' {
-				if p.OpenParens == 0 {
-					return "", fmt.Errorf("unmatched ')' at pos %d", p.Pos+1)
-				}
-				p.OpenParens--
-				parenPosStack = parenPosStack[:len(parenPosStack)-1]
-			} else if c == ';' && p.OpenParens == 0 {
-				break
-			}
-		}
-		p.advance()
-	}
-	if p.eof() && p.InQuote {
-		return "", fmt.Errorf("bad style attribute, while parsing attribute %q, unmatched quote at pos %d", propName, quotePos+1)
-	}
-	if p.eof() && p.OpenParens > 0 {
-		return "", fmt.Errorf("bad style attribute, while parsing property %q, unmatched '(' at pos %d", propName, parenPosStack[len(parenPosStack)-1]+1)
-	}
-	return strings.TrimSpace(p.Input[start:p.Pos]), nil
-}
-
-func isIdentChar(r rune) bool {
-	return unicode.IsLetter(r) || unicode.IsDigit(r)
-}
-
-func (p *Parser) skipWhitespace() {
-	for !p.eof() && unicode.IsSpace(p.peekChar()) {
-		p.advance()
-	}
-}
-
-func (p *Parser) expectChar(expected rune) bool {
-	if !p.eof() && p.peekChar() == expected {
-		p.advance()
-		return true
-	}
-	return false
-}
-
-func (p *Parser) peekChar() rune {
-	if p.Pos >= p.Length {
-		return 0
-	}
-	return rune(p.Input[p.Pos])
-}
-
-func (p *Parser) advance() {
-	p.Pos++
-}
-
-func (p *Parser) eof() bool {
-	return p.Pos >= p.Length
-}
\ No newline at end of file
diff --git a/tsunami/vdom/cssparser/cssparser_test.go b/tsunami/vdom/cssparser/cssparser_test.go
deleted file mode 100644
index a2ea46bd66..0000000000
--- a/tsunami/vdom/cssparser/cssparser_test.go
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package cssparser
-
-import (
-	"fmt"
-	"log"
-	"testing"
-)
-
-func compareMaps(a, b map[string]string) error {
-	if len(a) != len(b) {
-		return fmt.Errorf("map length mismatch: %d != %d", len(a), len(b))
-	}
-	for k, v := range a {
-		if b[k] != v {
-			return fmt.Errorf("value mismatch for key %s: %q != %q", k, v, b[k])
-		}
-	}
-	return nil
-}
-
-func TestParse1(t *testing.T) {
-	style := `background: url("example;with;semicolons.jpg"); color: red; margin-right: 5px; content: "hello;world";`
-	p := MakeParser(style)
-	parsed, err := p.Parse()
-	if err != nil {
-		t.Fatalf("Parse failed: %v", err)
-		return
-	}
-	expected := map[string]string{
-		"background":   `url("example;with;semicolons.jpg")`,
-		"color":        "red",
-		"margin-right": "5px",
-		"content":      `"hello;world"`,
-	}
-	if err := compareMaps(parsed, expected); err != nil {
-		t.Fatalf("Parsed map does not match expected: %v", err)
-	}
-
-	style = `margin-right: calc(10px + 5px); color: red; font-family: "Arial";`
-	p = MakeParser(style)
-	parsed, err = p.Parse()
-	if err != nil {
-		t.Fatalf("Parse failed: %v", err)
-		return
-	}
-	expected = map[string]string{
-		"margin-right": `calc(10px + 5px)`,
-		"color":        "red",
-		"font-family":  `"Arial"`,
-	}
-	if err := compareMaps(parsed, expected); err != nil {
-		t.Fatalf("Parsed map does not match expected: %v", err)
-	}
-}
-
-func TestParserErrors(t *testing.T) {
-	style := `hello more: bad;`
-	p := MakeParser(style)
-	_, err := p.Parse()
-	if err == nil {
-		t.Fatalf("expected error, got nil")
-	}
-	log.Printf("got expected error: %v\n", err)
-	style = `background: url("example.jpg`
-	p = MakeParser(style)
-	_, err = p.Parse()
-	if err == nil {
-		t.Fatalf("expected error, got nil")
-	}
-	log.Printf("got expected error: %v\n", err)
-	style = `foo: url(...`
-	p = MakeParser(style)
-	_, err = p.Parse()
-	if err == nil {
-		t.Fatalf("expected error, got nil")
-	}
-	log.Printf("got expected error: %v\n", err)
-}
\ No newline at end of file
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index 5229e49261..797c9005ec 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -19,20 +19,6 @@ import (
 
 type Component[P any] func(props P) *VDomElem
 
-type styleAttrWrapper struct {
-	StyleAttr string
-	Val       any
-}
-
-type classAttrWrapper struct {
-	ClassName string
-	Cond      bool
-}
-
-type styleAttrMapWrapper struct {
-	StyleAttrMap map[string]any
-}
-
 func (e *VDomElem) Key() string {
 	keyVal, ok := e.Props[KeyPropKey]
 	if !ok {
@@ -60,74 +46,6 @@ func TextElem(text string) VDomElem {
 	return VDomElem{Tag: TextTag, Text: text}
 }
 
-func mergeProps(props *map[string]any, newProps map[string]any) {
-	if *props == nil {
-		*props = make(map[string]any)
-	}
-	for k, v := range newProps {
-		if v == nil {
-			delete(*props, k)
-			continue
-		}
-		(*props)[k] = v
-	}
-}
-
-func mergeStyleAttr(props *map[string]any, styleAttr styleAttrWrapper) {
-	if *props == nil {
-		*props = make(map[string]any)
-	}
-	if (*props)["style"] == nil {
-		(*props)["style"] = make(map[string]any)
-	}
-	styleMap, ok := (*props)["style"].(map[string]any)
-	if !ok {
-		return
-	}
-	styleMap[styleAttr.StyleAttr] = styleAttr.Val
-}
-
-func mergeClassAttr(props *map[string]any, classAttr classAttrWrapper) {
-	if *props == nil {
-		*props = make(map[string]any)
-	}
-	if classAttr.Cond {
-		if (*props)["className"] == nil {
-			(*props)["className"] = classAttr.ClassName
-			return
-		}
-		classVal, ok := (*props)["className"].(string)
-		if !ok {
-			return
-		}
-		// check if class already exists (must split, contains won't work)
-		splitArr := strings.Split(classVal, " ")
-		for _, class := range splitArr {
-			if class == classAttr.ClassName {
-				return
-			}
-		}
-		(*props)["className"] = classVal + " " + classAttr.ClassName
-	} else {
-		classVal, ok := (*props)["className"].(string)
-		if !ok {
-			return
-		}
-		splitArr := strings.Split(classVal, " ")
-		for i, class := range splitArr {
-			if class == classAttr.ClassName {
-				splitArr = append(splitArr[:i], splitArr[i+1:]...)
-				break
-			}
-		}
-		if len(splitArr) == 0 {
-			delete(*props, "className")
-		} else {
-			(*props)["className"] = strings.Join(splitArr, " ")
-		}
-	}
-}
-
 func Classes(classes ...any) string {
 	var parts []string
 	for _, class := range classes {
@@ -155,52 +73,6 @@ func H(tag string, props map[string]any, children ...any) *VDomElem {
 	return rtn
 }
 
-func E(tag string, parts ...any) *VDomElem {
-	rtn := &VDomElem{Tag: tag}
-	for _, part := range parts {
-		if part == nil {
-			continue
-		}
-		props, ok := part.(map[string]any)
-		if ok {
-			mergeProps(&rtn.Props, props)
-			continue
-		}
-		if styleAttr, ok := part.(styleAttrWrapper); ok {
-			mergeStyleAttr(&rtn.Props, styleAttr)
-			continue
-		}
-		if styleAttrMap, ok := part.(styleAttrMapWrapper); ok {
-			for k, v := range styleAttrMap.StyleAttrMap {
-				mergeStyleAttr(&rtn.Props, styleAttrWrapper{StyleAttr: k, Val: v})
-			}
-			continue
-		}
-		if classAttr, ok := part.(classAttrWrapper); ok {
-			mergeClassAttr(&rtn.Props, classAttr)
-			continue
-		}
-		elems := PartToElems(part)
-		rtn.Children = append(rtn.Children, elems...)
-	}
-	return rtn
-}
-
-func Class(name string) classAttrWrapper {
-	return classAttrWrapper{ClassName: name, Cond: true}
-}
-
-func ClassIf(cond bool, name string) classAttrWrapper {
-	return classAttrWrapper{ClassName: name, Cond: cond}
-}
-
-func ClassIfElse(cond bool, name string, elseName string) classAttrWrapper {
-	if cond {
-		return classAttrWrapper{ClassName: name, Cond: true}
-	}
-	return classAttrWrapper{ClassName: elseName, Cond: true}
-}
-
 func If(cond bool, part any) any {
 	if cond {
 		return part
@@ -261,32 +133,6 @@ func Props(props any) map[string]any {
 	return m
 }
 
-func PStyle(styleAttr string, propVal any) any {
-	return styleAttrWrapper{StyleAttr: styleAttr, Val: propVal}
-}
-
-func Fragment(parts ...any) any {
-	return parts
-}
-
-func P(propName string, propVal any) any {
-	if propVal == nil {
-		return map[string]any{propName: nil}
-	}
-	if propName == "style" {
-		strVal, ok := propVal.(string)
-		if ok {
-			styleMap, err := styleAttrStrToStyleMap(strVal, nil)
-			if err == nil {
-				return styleAttrMapWrapper{StyleAttrMap: styleMap}
-			}
-			log.Printf("Error parsing style attribute: %v\n", err)
-			return nil
-		}
-	}
-	return map[string]any{propName: propVal}
-}
-
 func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T)) {
 	vc := GetRenderContext(ctx)
 	hookVal := vc.GetOrderedHook()
@@ -459,13 +305,13 @@ func UseSetAppTitle(ctx context.Context, title string) {
 		log.Printf("UseSetAppTitle must be called within a component (no context)")
 		return
 	}
-	
+
 	// Check if this is being called from the App component
 	if vc.GetCompName() != "App" {
 		log.Printf("UseSetAppTitle can only be called from the App component")
 		return
 	}
-	
+
 	// Set the title on the RootElem
 	vc.SetAppTitle(title)
 }
diff --git a/tsunami/vdom/vdom_html.go b/tsunami/vdom/vdom_html.go
deleted file mode 100644
index 08a38649a2..0000000000
--- a/tsunami/vdom/vdom_html.go
+++ /dev/null
@@ -1,426 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package vdom
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/wavetermdev/waveterm/tsunami/vdom/cssparser"
-
-	"github.com/wavetermdev/htmltoken"
-)
-
-// can tokenize and bind HTML to Elems
-
-const Html_BindPrefix = "#bind:"
-const Html_ParamPrefix = "#param:"
-const Html_GlobalEventPrefix = "#globalevent"
-const Html_BindParamTagName = "bindparam"
-const Html_BindTagName = "bind"
-
-func appendChildToStack(stack []*VDomElem, child *VDomElem) {
-	if child == nil {
-		return
-	}
-	if len(stack) == 0 {
-		return
-	}
-	parent := stack[len(stack)-1]
-	parent.Children = append(parent.Children, *child)
-}
-
-func pushElemStack(stack []*VDomElem, elem *VDomElem) []*VDomElem {
-	if elem == nil {
-		return stack
-	}
-	return append(stack, elem)
-}
-
-func popElemStack(stack []*VDomElem) []*VDomElem {
-	if len(stack) <= 1 {
-		return stack
-	}
-	curElem := stack[len(stack)-1]
-	appendChildToStack(stack[:len(stack)-1], curElem)
-	return stack[:len(stack)-1]
-}
-
-func curElemTag(stack []*VDomElem) string {
-	if len(stack) == 0 {
-		return ""
-	}
-	return stack[len(stack)-1].Tag
-}
-
-func finalizeStack(stack []*VDomElem) *VDomElem {
-	if len(stack) == 0 {
-		return nil
-	}
-	for len(stack) > 1 {
-		stack = popElemStack(stack)
-	}
-	rtnElem := stack[0]
-	if len(rtnElem.Children) == 0 {
-		return nil
-	}
-	if len(rtnElem.Children) == 1 {
-		return &rtnElem.Children[0]
-	}
-	return rtnElem
-}
-
-// returns value, isjson
-func getAttrString(token htmltoken.Token, key string) string {
-	for _, attr := range token.Attr {
-		if attr.Key == key {
-			return attr.Val
-		}
-	}
-	return ""
-}
-
-func isValidBindingKey(bindKey string) bool {
-	if bindKey == "" {
-		return false
-	}
-	// validate that bindKey starts with valid atom prefix and has at least one char after the dot
-	if strings.HasPrefix(bindKey, "$shared.") && len(bindKey) > 8 {
-		return true
-	}
-	if strings.HasPrefix(bindKey, "$config.") && len(bindKey) > 8 {
-		return true
-	}
-	if strings.HasPrefix(bindKey, "$data.") && len(bindKey) > 6 {
-		return true
-	}
-	return false
-}
-
-func attrToProp(attrVal string, isJson bool, params map[string]any) any {
-	if isJson {
-		var val any
-		err := json.Unmarshal([]byte(attrVal), &val)
-		if err != nil {
-			return nil
-		}
-		unmStrVal, ok := val.(string)
-		if !ok {
-			return val
-		}
-		attrVal = unmStrVal
-		// fallthrough using the json str val
-	}
-	if strings.HasPrefix(attrVal, Html_ParamPrefix) {
-		bindKey := attrVal[len(Html_ParamPrefix):]
-		bindVal, ok := params[bindKey]
-		if !ok {
-			return nil
-		}
-		return bindVal
-	}
-	if strings.HasPrefix(attrVal, Html_BindPrefix) {
-		bindKey := attrVal[len(Html_BindPrefix):]
-		if bindKey == "" || !isValidBindingKey(bindKey) {
-			return nil
-		}
-		return &VDomBinding{Type: ObjectType_Binding, Bind: bindKey}
-	}
-	if strings.HasPrefix(attrVal, Html_GlobalEventPrefix) {
-		splitArr := strings.Split(attrVal, ":")
-		if len(splitArr) < 2 {
-			return nil
-		}
-		eventName := splitArr[1]
-		if eventName == "" {
-			return nil
-		}
-		return &VDomFunc{Type: ObjectType_Func, GlobalEvent: eventName}
-	}
-	return attrVal
-}
-
-func tokenToElem(token htmltoken.Token, params map[string]any) *VDomElem {
-	elem := &VDomElem{Tag: token.Data}
-	if len(token.Attr) > 0 {
-		elem.Props = make(map[string]any)
-	}
-	for _, attr := range token.Attr {
-		if attr.Key == "" || attr.Val == "" {
-			continue
-		}
-		propVal := attrToProp(attr.Val, attr.IsJson, params)
-		elem.Props[attr.Key] = propVal
-	}
-	return elem
-}
-
-func isWsChar(char rune) bool {
-	return char == ' ' || char == '\t' || char == '\n' || char == '\r'
-}
-
-func isWsByte(char byte) bool {
-	return char == ' ' || char == '\t' || char == '\n' || char == '\r'
-}
-
-func isFirstCharLt(s string) bool {
-	for _, char := range s {
-		if isWsChar(char) {
-			continue
-		}
-		return char == '<'
-	}
-	return false
-}
-
-func isLastCharGt(s string) bool {
-	for i := len(s) - 1; i >= 0; i-- {
-		char := s[i]
-		if isWsByte(char) {
-			continue
-		}
-		return char == '>'
-	}
-	return false
-}
-
-func isAllWhitespace(s string) bool {
-	for _, char := range s {
-		if !isWsChar(char) {
-			return false
-		}
-	}
-	return true
-}
-
-func trimWhitespaceConditionally(s string) string {
-	// Trim leading whitespace if the first non-whitespace character is '<'
-	if isAllWhitespace(s) {
-		return ""
-	}
-	if isFirstCharLt(s) {
-		s = strings.TrimLeftFunc(s, func(r rune) bool {
-			return isWsChar(r)
-		})
-	}
-	// Trim trailing whitespace if the last non-whitespace character is '>'
-	if isLastCharGt(s) {
-		s = strings.TrimRightFunc(s, func(r rune) bool {
-			return isWsChar(r)
-		})
-	}
-	return s
-}
-
-func processWhitespace(htmlStr string) string {
-	lines := strings.Split(htmlStr, "\n")
-	var newLines []string
-	for _, line := range lines {
-		trimmedLine := trimWhitespaceConditionally(line + "\n")
-		if trimmedLine == "" {
-			continue
-		}
-		newLines = append(newLines, trimmedLine)
-	}
-	return strings.Join(newLines, "")
-}
-
-func processTextStr(s string) string {
-	if s == "" {
-		return ""
-	}
-	if isAllWhitespace(s) {
-		return " "
-	}
-	return strings.TrimSpace(s)
-}
-
-func makePathStr(elemPath []string) string {
-	return strings.Join(elemPath, " ")
-}
-
-func capitalizeAscii(s string) string {
-	if s == "" || s[0] < 'a' || s[0] > 'z' {
-		return s
-	}
-	return strings.ToUpper(s[:1]) + s[1:]
-}
-
-func toReactName(input string) string {
-	// Check for CSS custom properties (variables) which start with '--'
-	if strings.HasPrefix(input, "--") {
-		return input
-	}
-	parts := strings.Split(input, "-")
-	result := ""
-	index := 0
-	if parts[0] == "" && len(parts) > 1 {
-		// handle vendor prefixes
-		prefix := parts[1]
-		if prefix == "ms" {
-			result += "ms"
-		} else {
-			result += capitalizeAscii(prefix)
-		}
-		index = 2 // Skip the empty string and prefix
-	} else {
-		result += parts[0]
-		index = 1
-	}
-	// Convert remaining parts to CamelCase
-	for ; index < len(parts); index++ {
-		if parts[index] != "" {
-			result += capitalizeAscii(parts[index])
-		}
-	}
-	return result
-}
-
-func convertStyleToReactStyles(styleMap map[string]string, params map[string]any) map[string]any {
-	if len(styleMap) == 0 {
-		return nil
-	}
-	rtn := make(map[string]any)
-	for key, val := range styleMap {
-		rtn[toReactName(key)] = attrToProp(val, false, params)
-	}
-	return rtn
-}
-
-func styleAttrStrToStyleMap(styleText string, params map[string]any) (map[string]any, error) {
-	parser := cssparser.MakeParser(styleText)
-	m, err := parser.Parse()
-	if err != nil {
-		return nil, err
-	}
-	return convertStyleToReactStyles(m, params), nil
-}
-
-func fixStyleAttribute(elem *VDomElem, params map[string]any, elemPath []string) error {
-	styleText, ok := elem.Props["style"].(string)
-	if !ok {
-		return nil
-	}
-	styleMap, err := styleAttrStrToStyleMap(styleText, params)
-	if err != nil {
-		return fmt.Errorf("%v (at %s)", err, makePathStr(elemPath))
-	}
-	elem.Props["style"] = styleMap
-	return nil
-}
-
-func fixupStyleAttributes(elem *VDomElem, params map[string]any, elemPath []string) {
-	if elem == nil {
-		return
-	}
-	// call fixStyleAttribute, and walk children
-	elemCountMap := make(map[string]int)
-	if len(elemPath) == 0 {
-		elemPath = append(elemPath, elem.Tag)
-	}
-	fixStyleAttribute(elem, params, elemPath)
-	for i := range elem.Children {
-		child := &elem.Children[i]
-		elemCountMap[child.Tag]++
-		subPath := child.Tag
-		if elemCountMap[child.Tag] > 1 {
-			subPath = fmt.Sprintf("%s[%d]", child.Tag, elemCountMap[child.Tag])
-		}
-		elemPath = append(elemPath, subPath)
-		fixupStyleAttributes(&elem.Children[i], params, elemPath)
-		elemPath = elemPath[:len(elemPath)-1]
-	}
-}
-
-func Bind(htmlStr string, params map[string]any) *VDomElem {
-	htmlStr = processWhitespace(htmlStr)
-	r := strings.NewReader(htmlStr)
-	iter := htmltoken.NewTokenizer(r)
-	var elemStack []*VDomElem
-	elemStack = append(elemStack, &VDomElem{Tag: FragmentTag})
-	var tokenErr error
-outer:
-	for {
-		tokenType := iter.Next()
-		token := iter.Token()
-		switch tokenType {
-		case htmltoken.StartTagToken:
-			if token.Data == Html_BindTagName || token.Data == Html_BindParamTagName {
-				tokenErr = errors.New("bind tags must be self closing")
-				break outer
-			}
-			elem := tokenToElem(token, params)
-			elemStack = pushElemStack(elemStack, elem)
-		case htmltoken.EndTagToken:
-			if token.Data == Html_BindTagName || token.Data == Html_BindParamTagName {
-				tokenErr = errors.New("bind tags must be self closing")
-				break outer
-			}
-			if len(elemStack) <= 1 {
-				tokenErr = fmt.Errorf("end tag %q without start tag", token.Data)
-				break outer
-			}
-			if curElemTag(elemStack) != token.Data {
-				tokenErr = fmt.Errorf("end tag %q does not match start tag %q", token.Data, curElemTag(elemStack))
-				break outer
-			}
-			elemStack = popElemStack(elemStack)
-		case htmltoken.SelfClosingTagToken:
-			if token.Data == Html_BindParamTagName {
-				keyAttr := getAttrString(token, "key")
-				dataVal := params[keyAttr]
-				elemList := PartToElems(dataVal)
-				for _, elem := range elemList {
-					appendChildToStack(elemStack, &elem)
-				}
-				continue
-			}
-			if token.Data == Html_BindTagName {
-				keyAttr := getAttrString(token, "key")
-				if !isValidBindingKey(keyAttr) {
-					errText := fmt.Sprintf("invalid binding key: %q (must start with $shared., $config., or $data.)", keyAttr)
-					errTextElem := TextElem(errText)
-					appendChildToStack(elemStack, &errTextElem)
-					continue
-				}
-				binding := &VDomBinding{Type: ObjectType_Binding, Bind: keyAttr}
-				appendChildToStack(elemStack, &VDomElem{Tag: WaveTextTag, Props: map[string]any{"text": binding}})
-				continue
-			}
-			elem := tokenToElem(token, params)
-			appendChildToStack(elemStack, elem)
-		case htmltoken.TextToken:
-			if token.Data == "" {
-				continue
-			}
-			textStr := processTextStr(token.Data)
-			if textStr == "" {
-				continue
-			}
-			elem := TextElem(textStr)
-			appendChildToStack(elemStack, &elem)
-		case htmltoken.CommentToken:
-			continue
-		case htmltoken.DoctypeToken:
-			tokenErr = errors.New("doctype not supported")
-			break outer
-		case htmltoken.ErrorToken:
-			if iter.Err() == io.EOF {
-				break outer
-			}
-			tokenErr = iter.Err()
-			break outer
-		}
-	}
-	if tokenErr != nil {
-		errTextElem := TextElem(tokenErr.Error())
-		appendChildToStack(elemStack, &errTextElem)
-	}
-	rtn := finalizeStack(elemStack)
-	fixupStyleAttributes(rtn, params, nil)
-	return rtn
-}
diff --git a/tsunami/vdom/vdom_test.go b/tsunami/vdom/vdom_test.go
index 9c5c2ef79a..528717f677 100644
--- a/tsunami/vdom/vdom_test.go
+++ b/tsunami/vdom/vdom_test.go
@@ -9,35 +9,36 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/util"
 )
 
-func TestBind(t *testing.T) {
-	elem := Bind(`<div>clicked</div>`, nil)
+func TestH(t *testing.T) {
+	elem := H("div", nil, "clicked")
 	jsonBytes, _ := json.MarshalIndent(elem, "", "  ")
 	log.Printf("%s\n", string(jsonBytes))
 
-	elem = Bind(`
-	<div>
-	    clicked
-    </div>`, nil)
+	elem = H("div", nil, "clicked")
 	jsonBytes, _ = json.MarshalIndent(elem, "", "  ")
 	log.Printf("%s\n", string(jsonBytes))
 
-	elem = Bind(`<Button>foo</Button>`, nil)
+	elem = H("Button", nil, "foo")
 	jsonBytes, _ = json.MarshalIndent(elem, "", "  ")
 	log.Printf("%s\n", string(jsonBytes))
 
-	elem = Bind(`
-<div>
-    <h1>hello world</h1>
-	<Button onClick="#param:clickFn">hello</Button>
-	<bindparam key="clickedDiv"/>
-</div>
-`, nil)
+	clickFn := "test-click-function"
+	clickedDiv := H("div", nil, "test-content")
+	elem = H("div", nil,
+		H("h1", nil, "hello world"),
+		H("Button", map[string]any{"onClick": clickFn}, "hello"),
+		clickedDiv,
+	)
 	jsonBytes, _ = json.MarshalIndent(elem, "", "  ")
 	log.Printf("%s\n", string(jsonBytes))
 }
 
-func TestJsonBind(t *testing.T) {
-	elem := Bind(`<div data1={5} data2={[1,2,3]} data3={{"a": 1}}/>`, nil)
+func TestJsonH(t *testing.T) {
+	elem := H("div", map[string]any{
+		"data1": 5,
+		"data2": []any{1, 2, 3},
+		"data3": map[string]any{"a": 1},
+	})
 	if elem == nil {
 		t.Fatalf("elem is nil")
 	}

From 48b85807ef9e0cb3855efb72a006bf3e3a5c2447 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 19:10:18 -0700
Subject: [PATCH 048/134] remove FilterFns, add Ternary, one ForEach which
 includes index...

---
 tsunami/demo/todo/app.go | 15 ++++++++-------
 tsunami/vdom/vdom.go     | 35 +++++++----------------------------
 2 files changed, 15 insertions(+), 35 deletions(-)

diff --git a/tsunami/demo/todo/app.go b/tsunami/demo/todo/app.go
index 840bcb25ea..6e955236a0 100644
--- a/tsunami/demo/todo/app.go
+++ b/tsunami/demo/todo/app.go
@@ -9,7 +9,6 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-
 // Basic domain types with json tags for props
 type Todo struct {
 	Id        int    `json:"id"`
@@ -89,7 +88,7 @@ var TodoList = app.DefineComponent("TodoList",
 	func(ctx context.Context, props TodoListProps) any {
 		return vdom.H("div", map[string]any{
 			"className": "flex flex-col gap-2",
-		}, vdom.ForEach(props.Todos, func(todo Todo) any {
+		}, vdom.ForEach(props.Todos, func(todo Todo, _ int) any {
 			return TodoItem(TodoItemProps{
 				Todo:     todo,
 				OnToggle: func() { props.OnToggle(todo.Id) },
@@ -103,7 +102,7 @@ var TodoList = app.DefineComponent("TodoList",
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ any) any {
 		vdom.UseSetAppTitle(ctx, "Todo App (Tsunami Demo)")
-		
+
 		// Multiple state hooks example
 		todos, setTodos, _ := vdom.UseState(ctx, []Todo{
 			{Id: 1, Text: "Learn VDOM", Completed: false},
@@ -139,11 +138,13 @@ var App = app.DefineComponent("App",
 			setTodos(newTodos)
 		}
 
-		// Filter pattern for deletion
 		deleteTodo := func(id int) {
-			newTodos := vdom.Filter(todos, func(todo Todo) bool {
-				return todo.Id != id
-			})
+			newTodos := make([]Todo, 0, len(todos)-1)
+			for _, todo := range todos {
+				if todo.Id != id {
+					newTodos = append(newTodos, todo)
+				}
+			}
 			setTodos(newTodos)
 		}
 
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index 797c9005ec..e850fdba6c 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -87,17 +87,16 @@ func IfElse(cond bool, part any, elsePart any) any {
 	return elsePart
 }
 
-func ForEach[T any](items []T, fn func(T) any) []any {
-	var elems []any
-	for _, item := range items {
-		fnResult := fn(item)
-		elems = append(elems, fnResult)
+func Ternary[T any](cond bool, trueRtn T, falseRtn T) T {
+	if cond {
+		return trueRtn
+	} else {
+		return falseRtn
 	}
-	return elems
 }
 
-func ForEachIdx[T any](items []T, fn func(T, int) any) []any {
-	var elems []any
+func ForEach[T any](items []T, fn func(T, int) any) []any {
+	elems := make([]any, len(items))
 	for idx, item := range items {
 		fnResult := fn(item, idx)
 		elems = append(elems, fnResult)
@@ -105,26 +104,6 @@ func ForEachIdx[T any](items []T, fn func(T, int) any) []any {
 	return elems
 }
 
-func Filter[T any](items []T, fn func(T) bool) []T {
-	var elems []T
-	for _, item := range items {
-		if fn(item) {
-			elems = append(elems, item)
-		}
-	}
-	return elems
-}
-
-func FilterIdx[T any](items []T, fn func(T, int) bool) []T {
-	var elems []T
-	for idx, item := range items {
-		if fn(item, idx) {
-			elems = append(elems, item)
-		}
-	}
-	return elems
-}
-
 func Props(props any) map[string]any {
 	m, err := util.StructToMap(props)
 	if err != nil {

From aceff3adea02e4fccf010e97ce308657a1337c07 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 19:22:51 -0700
Subject: [PATCH 049/134] godoc tasks

---
 Taskfile.yml | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/Taskfile.yml b/Taskfile.yml
index 4b3c8d7833..3c39b08b28 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -489,3 +489,12 @@ tasks:
             - "tsunami/go.sum"
         generates:
             - "bin/tsunami{{exeExt}}"
+
+    godoc:
+        desc: Start the Go documentation server for the root module
+        cmd: $(go env GOPATH)/bin/pkgsite -http=:6060
+
+    tsunami:godoc:
+        desc: Start the Go documentation server for the tsunami module
+        cmd: $(go env GOPATH)/bin/pkgsite -http=:6060
+        dir: tsunami

From f4e100b7f7f12e7b9de95d54808f555b79732f41 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 22:44:41 -0700
Subject: [PATCH 050/134] simplify vdom pkg, remove more public methods and
 types (hooks implemented in comp)

---
 tsunami/comp/comp.go              |   2 +-
 tsunami/comp/hooks.go             | 191 ++++++++++++++++++++++++++
 tsunami/comp/rootelem.go          |  65 +++++----
 tsunami/comp/vdomcontext.go       |  85 ------------
 tsunami/rpctypes/protocoltypes.go |  27 ++--
 tsunami/vdom/vdom.go              | 218 +++++++++++-------------------
 tsunami/vdom/vdom_context.go      |  42 ------
 tsunami/vdom/vdom_types.go        |  35 +----
 tsunami/vdomctx/vdomctx.go        |  40 ++++++
 9 files changed, 368 insertions(+), 337 deletions(-)
 create mode 100644 tsunami/comp/hooks.go
 delete mode 100644 tsunami/comp/vdomcontext.go
 delete mode 100644 tsunami/vdom/vdom_context.go
 create mode 100644 tsunami/vdomctx/vdomctx.go

diff --git a/tsunami/comp/comp.go b/tsunami/comp/comp.go
index 07d16c8985..101394dae0 100644
--- a/tsunami/comp/comp.go
+++ b/tsunami/comp/comp.go
@@ -22,7 +22,7 @@ type ComponentImpl struct {
 	Mounted bool
 
 	// hooks
-	Hooks []*vdom.Hook
+	Hooks []*Hook
 
 	// #text component
 	Text string
diff --git a/tsunami/comp/hooks.go b/tsunami/comp/hooks.go
new file mode 100644
index 0000000000..fe78818462
--- /dev/null
+++ b/tsunami/comp/hooks.go
@@ -0,0 +1,191 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package comp
+
+import (
+	"context"
+	"log"
+	"strconv"
+
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
+)
+
+// generic hook structure
+type Hook struct {
+	Init      bool          // is initialized
+	Idx       int           // index in the hook array
+	Fn        func() func() // for useEffect
+	UnmountFn func()        // for useEffect
+	Val       any           // for useState, useMemo, useRef
+	Deps      []any
+}
+
+type VDomContextImpl struct {
+	Root       *RootElem
+	Comp       *ComponentImpl
+	HookIdx    int
+	RenderOpts *RenderOpts
+}
+
+// Compile-time check to ensure VDomContextImpl implements vdomctx.VDomContext
+var _ vdomctx.VDomContext = (*VDomContextImpl)(nil)
+
+// Implement vdomctx.VDomContext interface methods on VDomContextImpl
+
+func MakeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *VDomContextImpl {
+	return &VDomContextImpl{Root: root, Comp: comp, HookIdx: 0, RenderOpts: opts}
+}
+
+func (vc *VDomContextImpl) getCompWaveId() string {
+	if vc.Comp == nil {
+		return ""
+	}
+	return vc.Comp.WaveId
+}
+
+func (vc *VDomContextImpl) getOrderedHook() *Hook {
+	if vc.Comp == nil {
+		panic("tsunami hooks must be called within a component (vc.Comp is nil)")
+	}
+	for len(vc.Comp.Hooks) <= vc.HookIdx {
+		vc.Comp.Hooks = append(vc.Comp.Hooks, &Hook{Idx: len(vc.Comp.Hooks)})
+	}
+	hookVal := vc.Comp.Hooks[vc.HookIdx]
+	vc.HookIdx++
+	return hookVal
+}
+
+func (vc *VDomContextImpl) getCompName() string {
+	if vc.Comp == nil || vc.Comp.Elem == nil {
+		return ""
+	}
+	return vc.Comp.Elem.Tag
+}
+
+func (vc *VDomContextImpl) UseRenderTs(ctx context.Context) int64 {
+	return vc.Root.RenderTs
+}
+
+func (vc *VDomContextImpl) UseId(ctx context.Context) string {
+	return vc.getCompWaveId()
+}
+
+func (vc *VDomContextImpl) UseState(ctx context.Context, initialVal any) (any, func(any), func(func(any) any)) {
+	hookVal := vc.getOrderedHook()
+	if !hookVal.Init {
+		hookVal.Init = true
+		hookVal.Val = initialVal
+	}
+
+	setVal := func(newVal any) {
+		hookVal.Val = newVal
+		vc.Root.AddRenderWork(vc.getCompWaveId())
+	}
+
+	setFuncVal := func(updateFunc func(any) any) {
+		hookVal.Val = updateFunc(hookVal.Val)
+		vc.Root.AddRenderWork(vc.getCompWaveId())
+	}
+
+	return hookVal.Val, setVal, setFuncVal
+}
+
+func (vc *VDomContextImpl) UseAtom(ctx context.Context, atomName string) (any, func(any), func(func(any) any)) {
+	hookVal := vc.getOrderedHook()
+	if !hookVal.Init {
+		hookVal.Init = true
+		closedWaveId := vc.getCompWaveId()
+		hookVal.UnmountFn = func() {
+			vc.Root.AtomSetUsedBy(atomName, closedWaveId, false)
+		}
+	}
+	vc.Root.AtomSetUsedBy(atomName, vc.getCompWaveId(), true)
+	atomVal := vc.Root.GetAtomVal(atomName)
+
+	setVal := func(newVal any) {
+		vc.Root.SetAtomVal(atomName, newVal, true)
+		vc.Root.AtomAddRenderWork(atomName)
+	}
+
+	setFuncVal := func(updateFunc func(any) any) {
+		currentVal := vc.Root.GetAtomVal(atomName)
+		vc.Root.SetAtomVal(atomName, updateFunc(currentVal), true)
+		vc.Root.AtomAddRenderWork(atomName)
+	}
+
+	return atomVal, setVal, setFuncVal
+}
+
+func (vc *VDomContextImpl) UseVDomRef(ctx context.Context) any {
+	hookVal := vc.getOrderedHook()
+	if !hookVal.Init {
+		hookVal.Init = true
+		refId := vc.getCompWaveId() + ":" + strconv.Itoa(hookVal.Idx)
+		hookVal.Val = &vdom.VDomRef{Type: vdom.ObjectType_Ref, RefId: refId}
+	}
+	refVal, ok := hookVal.Val.(*vdom.VDomRef)
+	if !ok {
+		panic("UseVDomRef hook value is not a ref (possible out of order or conditional hooks)")
+	}
+	return refVal
+}
+
+func (vc *VDomContextImpl) UseRef(ctx context.Context, hookInitialVal any) any {
+	hookVal := vc.getOrderedHook()
+	if !hookVal.Init {
+		hookVal.Init = true
+		hookVal.Val = hookInitialVal
+	}
+	return hookVal.Val
+}
+
+func depsEqual(deps1 []any, deps2 []any) bool {
+	if len(deps1) != len(deps2) {
+		return false
+	}
+	for i := range deps1 {
+		if deps1[i] != deps2[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func (vc *VDomContextImpl) UseEffect(ctx context.Context, fn func() func(), deps []any) {
+	hookVal := vc.getOrderedHook()
+	if !hookVal.Init {
+		hookVal.Init = true
+		hookVal.Fn = fn
+		hookVal.Deps = deps
+		vc.Root.AddEffectWork(vc.getCompWaveId(), hookVal.Idx)
+		return
+	}
+	if depsEqual(hookVal.Deps, deps) {
+		return
+	}
+	hookVal.Fn = fn
+	hookVal.Deps = deps
+	vc.Root.AddEffectWork(vc.getCompWaveId(), hookVal.Idx)
+}
+
+func (vc *VDomContextImpl) UseResync(ctx context.Context) bool {
+	if vc.RenderOpts == nil {
+		return false
+	}
+	return vc.RenderOpts.Resync
+}
+
+func (vc *VDomContextImpl) UseSetAppTitle(ctx context.Context, title string) {
+	if vc.getCompName() != "App" {
+		log.Printf("UseSetAppTitle can only be called from the App component")
+		return
+	}
+	vc.Root.AppTitle = title
+}
+
+func (vc *VDomContextImpl) QueueRefOp(ctx context.Context, op any) {
+	typedOp := op.(vdom.VDomRefOperation)
+	vc.Root.QueueRefOp(typedOp)
+}
diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index dfa57b1677..280075359e 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -11,17 +11,32 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"unicode"
 
 	"github.com/google/uuid"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
+	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
 )
 
+const ChildrenPropKey = "children"
+
 type RenderOpts struct {
 	Resync bool
 }
 
+type Atom struct {
+	Val    any
+	Dirty  bool
+	UsedBy map[string]bool // component waveid -> true
+}
+
+type EffectWorkElem struct {
+	Id          string
+	EffectIndex int
+}
+
 type RootElem struct {
 	OuterCtx        context.Context
 	Root            *ComponentImpl
@@ -29,11 +44,11 @@ type RootElem struct {
 	AppTitle        string
 	CFuncs          map[string]any
 	CompMap         map[string]*ComponentImpl // component waveid -> component
-	EffectWorkQueue []*vdom.EffectWorkElem
+	EffectWorkQueue []*EffectWorkElem
 	NeedsRenderMap  map[string]bool
-	Atoms           map[string]*vdom.Atom
+	Atoms           map[string]*Atom
 	atomLock        sync.Mutex
-	RefOperations   []rpctypes.VDomRefOperation
+	RefOperations   []vdom.VDomRefOperation
 }
 
 func (r *RootElem) AddRenderWork(id string) {
@@ -44,7 +59,7 @@ func (r *RootElem) AddRenderWork(id string) {
 }
 
 func (r *RootElem) AddEffectWork(id string, effectIndex int) {
-	r.EffectWorkQueue = append(r.EffectWorkQueue, &vdom.EffectWorkElem{Id: id, EffectIndex: effectIndex})
+	r.EffectWorkQueue = append(r.EffectWorkQueue, &EffectWorkElem{Id: id, EffectIndex: effectIndex})
 }
 
 func (r *RootElem) GetDataMap() map[string]any {
@@ -64,7 +79,7 @@ func (r *RootElem) GetDataMap() map[string]any {
 func (r *RootElem) GetConfigMap() map[string]any {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
-	
+
 	result := make(map[string]any)
 	for atomName, atom := range r.Atoms {
 		if strings.HasPrefix(atomName, "$config.") {
@@ -80,24 +95,23 @@ func MakeRoot() *RootElem {
 		Root:    nil,
 		CFuncs:  make(map[string]any),
 		CompMap: make(map[string]*ComponentImpl),
-		Atoms:   make(map[string]*vdom.Atom),
+		Atoms:   make(map[string]*Atom),
 	}
 }
 
-func (r *RootElem) ensureAtomNoLock(name string) *vdom.Atom {
+func (r *RootElem) ensureAtomNoLock(name string) *Atom {
 	atom, ok := r.Atoms[name]
 	if !ok {
-		atom = &vdom.Atom{UsedBy: make(map[string]bool)}
+		atom = &Atom{UsedBy: make(map[string]bool)}
 		r.Atoms[name] = atom
 	}
 	return atom
 }
 
-
 func (r *RootElem) AtomSetUsedBy(atomName string, waveId string, used bool) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
-	
+
 	atom := r.ensureAtomNoLock(atomName)
 	if used {
 		atom.UsedBy[waveId] = true
@@ -109,7 +123,7 @@ func (r *RootElem) AtomSetUsedBy(atomName string, waveId string, used bool) {
 func (r *RootElem) AtomAddRenderWork(atomName string) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
-	
+
 	atom, ok := r.Atoms[atomName]
 	if !ok {
 		return
@@ -297,7 +311,7 @@ func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl, opts *Rende
 		r.renderText(elem.Text, comp)
 		return
 	}
-	if vdom.IsBaseTag(elem.Tag) {
+	if isBaseTag(elem.Tag) {
 		// simple vdom, fragment, wave element
 		r.renderSimple(elem, comp, opts)
 		return
@@ -421,9 +435,9 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 	for k, v := range elem.Props {
 		props[k] = v
 	}
-	props[vdom.ChildrenPropKey] = elem.Children
+	props[ChildrenPropKey] = elem.Children
 	vc := MakeContextVal(r, *comp, opts)
-	ctx := vdom.WithRenderContext(r.OuterCtx, vc)
+	ctx := vdomctx.WithRenderContext(r.OuterCtx, vc)
 	renderedElem := callCFunc(cfunc, ctx, props)
 	rtnElemArr := vdom.PartToElems(renderedElem)
 	if len(rtnElemArr) == 0 {
@@ -472,11 +486,11 @@ func (r *RootElem) UpdateRef(updateRef rpctypes.VDomRefUpdate) {
 	r.AddRenderWork(waveId)
 }
 
-func (r *RootElem) QueueRefOp(op rpctypes.VDomRefOperation) {
+func (r *RootElem) QueueRefOp(op vdom.VDomRefOperation) {
 	r.RefOperations = append(r.RefOperations, op)
 }
 
-func (r *RootElem) GetRefOperations() []rpctypes.VDomRefOperation {
+func (r *RootElem) GetRefOperations() []vdom.VDomRefOperation {
 	ops := r.RefOperations
 	r.RefOperations = nil
 	return ops
@@ -573,17 +587,16 @@ func VDomFuncCallFn(vdf *vdom.VDomFunc, event vdom.VDomEvent) {
 	}
 }
 
-func QueueRefOp(ctx context.Context, ref *vdom.VDomRef, op rpctypes.VDomRefOperation) {
-	if ref == nil || !ref.HasCurrent {
-		return
+func isBaseTag(tag string) bool {
+	if tag == "" {
+		return false
 	}
-	vcIf := vdom.GetRenderContext(ctx)
-	if vcIf == nil {
-		panic("QueueRefOp must be called within a component (no context)")
+	if tag == vdom.TextTag || tag == vdom.WaveTextTag || tag == vdom.WaveNullTag || tag == vdom.FragmentTag {
+		return true
 	}
-	vc := vcIf.(*VDomContextVal)
-	if op.RefId == "" {
-		op.RefId = ref.RefId
+	if tag[0] == '#' {
+		return true
 	}
-	vc.Root.QueueRefOp(op)
+	firstChar := rune(tag[0])
+	return unicode.IsLower(firstChar)
 }
diff --git a/tsunami/comp/vdomcontext.go b/tsunami/comp/vdomcontext.go
deleted file mode 100644
index 4299089a89..0000000000
--- a/tsunami/comp/vdomcontext.go
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package comp
-
-import "github.com/wavetermdev/waveterm/tsunami/vdom"
-
-type VDomContextVal struct {
-	Root       *RootElem
-	Comp       *ComponentImpl
-	HookIdx    int
-	RenderOpts *RenderOpts
-}
-
-func MakeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *VDomContextVal {
-	return &VDomContextVal{Root: root, Comp: comp, HookIdx: 0, RenderOpts: opts}
-}
-
-// Compile-time check to ensure VDomContextVal implements vdom.VDomContext
-var _ vdom.VDomContext = (*VDomContextVal)(nil)
-
-func (vc *VDomContextVal) AddRenderWork(id string) {
-	vc.Root.AddRenderWork(id)
-}
-
-func (vc *VDomContextVal) AddEffectWork(id string, effectIndex int) {
-	vc.Root.AddEffectWork(id, effectIndex)
-}
-
-func (vc *VDomContextVal) AtomSetUsedBy(atomName string, waveId string, used bool) {
-	vc.Root.AtomSetUsedBy(atomName, waveId, used)
-}
-
-func (vc *VDomContextVal) AtomAddRenderWork(atomName string) {
-	vc.Root.AtomAddRenderWork(atomName)
-}
-
-func (vc *VDomContextVal) GetAtomVal(atomName string) any {
-	return vc.Root.GetAtomVal(atomName)
-}
-
-func (vc *VDomContextVal) SetAtomVal(atomName string, val any, markDirty bool) {
-	vc.Root.SetAtomVal(atomName, val, markDirty)
-}
-
-func (vc *VDomContextVal) GetRenderTs() int64 {
-	return vc.Root.RenderTs
-}
-
-func (vc *VDomContextVal) GetCompWaveId() string {
-	if vc.Comp == nil {
-		return ""
-	}
-	return vc.Comp.WaveId
-}
-
-func (vc *VDomContextVal) GetOrderedHook() *vdom.Hook {
-	if vc.Comp == nil {
-		panic("tsunami hooks must be called within a component (vc.Comp is nil)")
-	}
-	for len(vc.Comp.Hooks) <= vc.HookIdx {
-		vc.Comp.Hooks = append(vc.Comp.Hooks, &vdom.Hook{Idx: len(vc.Comp.Hooks)})
-	}
-	hookVal := vc.Comp.Hooks[vc.HookIdx]
-	vc.HookIdx++
-	return hookVal
-}
-
-func (vc *VDomContextVal) IsResync() bool {
-	if vc.RenderOpts == nil {
-		return false
-	}
-	return vc.RenderOpts.Resync
-}
-
-func (vc *VDomContextVal) GetCompName() string {
-	if vc.Comp == nil || vc.Comp.Elem == nil {
-		return ""
-	}
-	return vc.Comp.Elem.Tag
-}
-
-func (vc *VDomContextVal) SetAppTitle(title string) {
-	vc.Root.AppTitle = title
-}
diff --git a/tsunami/rpctypes/protocoltypes.go b/tsunami/rpctypes/protocoltypes.go
index 9137410060..72b360f60a 100644
--- a/tsunami/rpctypes/protocoltypes.go
+++ b/tsunami/rpctypes/protocoltypes.go
@@ -46,16 +46,16 @@ type VDomFrontendUpdate struct {
 }
 
 type VDomBackendUpdate struct {
-	Type          string             `json:"type" tstype:"\"backendupdate\""`
-	Ts            int64              `json:"ts"`
-	ServerId      string             `json:"serverid"`
-	Opts          *VDomBackendOpts   `json:"opts,omitempty"`
-	HasWork       bool               `json:"haswork,omitempty"`
-	RenderUpdates []VDomRenderUpdate `json:"renderupdates,omitempty"`
-	TransferElems []VDomTransferElem `json:"transferelems,omitempty"`
-	StateSync     []VDomStateSync    `json:"statesync,omitempty"`
-	RefOperations []VDomRefOperation `json:"refoperations,omitempty"`
-	Messages      []VDomMessage      `json:"messages,omitempty"`
+	Type          string                  `json:"type" tstype:"\"backendupdate\""`
+	Ts            int64                   `json:"ts"`
+	ServerId      string                  `json:"serverid"`
+	Opts          *VDomBackendOpts        `json:"opts,omitempty"`
+	HasWork       bool                    `json:"haswork,omitempty"`
+	RenderUpdates []VDomRenderUpdate      `json:"renderupdates,omitempty"`
+	TransferElems []VDomTransferElem      `json:"transferelems,omitempty"`
+	StateSync     []VDomStateSync         `json:"statesync,omitempty"`
+	RefOperations []vdom.VDomRefOperation `json:"refoperations,omitempty"`
+	Messages      []VDomMessage           `json:"messages,omitempty"`
 }
 
 // the over the wire format for a vdom element
@@ -181,13 +181,6 @@ type VDomRenderUpdate struct {
 	Index      *int           `json:"index,omitempty"`
 }
 
-type VDomRefOperation struct {
-	RefId     string `json:"refid"`
-	Op        string `json:"op"`
-	Params    []any  `json:"params,omitempty"`
-	OutputRef string `json:"outputref,omitempty"`
-}
-
 type VDomMessage struct {
 	MessageType string `json:"messagetype"`
 	Message     string `json:"message"`
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index e850fdba6c..0b12284546 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -6,13 +6,11 @@ package vdom
 import (
 	"context"
 	"fmt"
-	"log"
 	"reflect"
-	"strconv"
 	"strings"
-	"unicode"
 
 	"github.com/wavetermdev/waveterm/tsunami/util"
+	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
 )
 
 // ReactNode types = nil | string | Elem
@@ -113,29 +111,27 @@ func Props(props any) map[string]any {
 }
 
 func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T)) {
-	vc := GetRenderContext(ctx)
-	hookVal := vc.GetOrderedHook()
-	if !hookVal.Init {
-		hookVal.Init = true
-		hookVal.Val = initialVal
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
+		panic("UseState must be called within a component (no context)")
 	}
+	val, setVal, setFn := rc.UseState(ctx, initialVal)
+
+	// Adapt the "any" values to type "T"
 	var rtnVal T
-	rtnVal, ok := hookVal.Val.(T)
+	rtnVal, ok := val.(T)
 	if !ok {
 		panic("UseState hook value is not a state (possible out of order or conditional hooks)")
 	}
-
-	setVal := func(newVal T) {
-		hookVal.Val = newVal
-		vc.AddRenderWork(vc.GetCompWaveId())
+	typedSetVal := func(newVal T) {
+		setVal(newVal)
 	}
-
-	setFuncVal := func(updateFunc func(T) T) {
-		hookVal.Val = updateFunc(hookVal.Val.(T))
-		vc.AddRenderWork(vc.GetCompWaveId())
+	typedSetFuncVal := func(updateFunc func(T) T) {
+		setFn(func(oldVal any) any {
+			return updateFunc(oldVal.(T))
+		})
 	}
-
-	return rtnVal, setVal, setFuncVal
+	return rtnVal, typedSetVal, typedSetFuncVal
 }
 
 func getTypedAtomValue[T any](rawVal any, atomName string) T {
@@ -158,141 +154,115 @@ func getTypedAtomValue[T any](rawVal any, atomName string) T {
 	return result
 }
 
-func useAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
-	vc := GetRenderContext(ctx)
-	hookVal := vc.GetOrderedHook()
-	if !hookVal.Init {
-		hookVal.Init = true
-		closedWaveId := vc.GetCompWaveId()
-		hookVal.UnmountFn = func() {
-			vc.AtomSetUsedBy(atomName, closedWaveId, false)
-		}
+func useAtom[T any](ctx context.Context, hookName string, atomName string) (T, func(T), func(func(T) T)) {
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
+		panic(hookName + " must be called within a component (no context)")
 	}
-	vc.AtomSetUsedBy(atomName, vc.GetCompWaveId(), true)
-	atomVal := getTypedAtomValue[T](vc.GetAtomVal(atomName), atomName)
-	setVal := func(newVal T) {
-		vc.SetAtomVal(atomName, newVal, true)
-		vc.AtomAddRenderWork(atomName)
+	val, setVal, setFn := rc.UseAtom(ctx, atomName)
+
+	// Adapt the "any" values to type "T"
+	atomVal := getTypedAtomValue[T](val, atomName)
+
+	typedSetVal := func(newVal T) {
+		setVal(newVal)
 	}
-	setFuncVal := func(updateFunc func(T) T) {
-		currentVal := getTypedAtomValue[T](vc.GetAtomVal(atomName), atomName)
-		vc.SetAtomVal(atomName, updateFunc(currentVal), true)
-		vc.AtomAddRenderWork(atomName)
+
+	typedSetFuncVal := func(updateFunc func(T) T) {
+		setFn(func(oldVal any) any {
+			typedOldVal := getTypedAtomValue[T](oldVal, atomName)
+			return updateFunc(typedOldVal)
+		})
 	}
-	return atomVal, setVal, setFuncVal
+
+	return atomVal, typedSetVal, typedSetFuncVal
 }
 
 func UseSharedAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
-	return useAtom[T](ctx, "$shared."+atomName)
+	return useAtom[T](ctx, "UseSharedAtom", "$shared."+atomName)
 }
 
 func UseConfig[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
-	return useAtom[T](ctx, "$config."+atomName)
+	return useAtom[T](ctx, "UseConfig", "$config."+atomName)
 }
 
 func UseData[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
-	return useAtom[T](ctx, "$data."+atomName)
+	return useAtom[T](ctx, "UseData", "$data."+atomName)
 }
 
 func UseVDomRef(ctx context.Context) *VDomRef {
-	vc := GetRenderContext(ctx)
-	hookVal := vc.GetOrderedHook()
-	if !hookVal.Init {
-		hookVal.Init = true
-		refId := vc.GetCompWaveId() + ":" + strconv.Itoa(hookVal.Idx)
-		hookVal.Val = &VDomRef{Type: ObjectType_Ref, RefId: refId}
-	}
-	refVal, ok := hookVal.Val.(*VDomRef)
+	rc := vdomctx.GetRenderContext(ctx)
+	val := rc.UseVDomRef(ctx)
+	refVal, ok := val.(*VDomRef)
 	if !ok {
-		panic("UseRef hook value is not a ref (possible out of order or conditional hooks)")
+		panic("UseVDomRef hook value is not a ref (possible out of order or conditional hooks)")
 	}
 	return refVal
 }
 
 func UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T] {
-	vc := GetRenderContext(ctx)
-	hookVal := vc.GetOrderedHook()
-	if !hookVal.Init {
-		hookVal.Init = true
-		hookVal.Val = &VDomSimpleRef[T]{Current: val}
-	}
-	refVal, ok := hookVal.Val.(*VDomSimpleRef[T])
+	rc := vdomctx.GetRenderContext(ctx)
+	refVal := rc.UseRef(ctx, &VDomSimpleRef[T]{Current: val})
+	typedRef, ok := refVal.(*VDomSimpleRef[T])
 	if !ok {
 		panic("UseRef hook value is not a ref (possible out of order or conditional hooks)")
 	}
-	return refVal
+	return typedRef
 }
 
 func UseId(ctx context.Context) string {
-	vc := GetRenderContext(ctx)
-	if vc == nil {
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
 		panic("UseId must be called within a component (no context)")
 	}
-	return vc.GetCompWaveId()
+	return rc.UseId(ctx)
 }
 
 func UseRenderTs(ctx context.Context) int64 {
-	vc := GetRenderContext(ctx)
-	if vc == nil {
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
 		panic("UseRenderTs must be called within a component (no context)")
 	}
-	return vc.GetRenderTs()
+	return rc.UseRenderTs(ctx)
 }
 
 func UseResync(ctx context.Context) bool {
-	vc := GetRenderContext(ctx)
-	if vc == nil {
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
 		panic("UseResync must be called within a component (no context)")
 	}
-	return vc.IsResync()
-}
-
-func depsEqual(deps1 []any, deps2 []any) bool {
-	if len(deps1) != len(deps2) {
-		return false
-	}
-	for i := range deps1 {
-		if deps1[i] != deps2[i] {
-			return false
-		}
-	}
-	return true
+	return rc.UseResync(ctx)
 }
 
 func UseEffect(ctx context.Context, fn func() func(), deps []any) {
 	// note UseEffect never actually runs anything, it just queues the effect to run later
-	vc := GetRenderContext(ctx)
-	hookVal := vc.GetOrderedHook()
-	if !hookVal.Init {
-		hookVal.Init = true
-		hookVal.Fn = fn
-		hookVal.Deps = deps
-		vc.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
-		return
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
+		panic("UseEffect must be called within a component (no context)")
 	}
-	if depsEqual(hookVal.Deps, deps) {
-		return
-	}
-	hookVal.Fn = fn
-	hookVal.Deps = deps
-	vc.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
+	rc.UseEffect(ctx, fn, deps)
 }
 
 func UseSetAppTitle(ctx context.Context, title string) {
-	vc := GetRenderContext(ctx)
-	if vc == nil {
-		log.Printf("UseSetAppTitle must be called within a component (no context)")
-		return
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
+		panic("UseSetAppTitle must be called within a component (no context)")
 	}
+	rc.UseSetAppTitle(ctx, title)
+}
 
-	// Check if this is being called from the App component
-	if vc.GetCompName() != "App" {
-		log.Printf("UseSetAppTitle can only be called from the App component")
+func QueueRefOp(ctx context.Context, ref *VDomRef, op VDomRefOperation) {
+	if ref == nil || !ref.HasCurrent {
 		return
 	}
-
-	// Set the title on the RootElem
-	vc.SetAppTitle(title)
+	vc := vdomctx.GetRenderContext(ctx)
+	if vc == nil {
+		panic("QueueRefOp must be called within a component (no context)")
+	}
+	if op.RefId == "" {
+		op.RefId = ref.RefId
+	}
+	vc.QueueRefOp(ctx, op)
 }
 
 func PartToElems(part any) []VDomElem {
@@ -302,6 +272,12 @@ func PartToElems(part any) []VDomElem {
 	switch partTyped := part.(type) {
 	case string:
 		return []VDomElem{TextElem(partTyped)}
+	case bool:
+		// matches react
+		if partTyped {
+			return []VDomElem{TextElem("true")}
+		}
+		return nil
 	case VDomElem:
 		return []VDomElem{partTyped}
 	case *VDomElem:
@@ -309,22 +285,6 @@ func PartToElems(part any) []VDomElem {
 			return nil
 		}
 		return []VDomElem{*partTyped}
-	case []VDomElem:
-		return partTyped
-	case []*VDomElem:
-		var rtn []VDomElem
-		for _, elem := range partTyped {
-			if elem != nil {
-				rtn = append(rtn, *elem)
-			}
-		}
-		return rtn
-	case []any:
-		var rtn []VDomElem
-		for _, subPart := range partTyped {
-			rtn = append(rtn, PartToElems(subPart)...)
-		}
-		return rtn
 	default:
 		partVal := reflect.ValueOf(part)
 		if partVal.Kind() == reflect.Slice {
@@ -334,24 +294,6 @@ func PartToElems(part any) []VDomElem {
 			}
 			return rtn
 		}
-		strVal, ok := util.NumToString(part)
-		if ok {
-			return []VDomElem{TextElem(strVal)}
-		}
-		return nil
-	}
-}
-
-func IsBaseTag(tag string) bool {
-	if tag == "" {
-		return false
-	}
-	if tag == TextTag || tag == WaveTextTag || tag == WaveNullTag || tag == FragmentTag {
-		return true
-	}
-	if tag[0] == '#' {
-		return true
+		return []VDomElem{TextElem(fmt.Sprint(part))}
 	}
-	firstChar := rune(tag[0])
-	return unicode.IsLower(firstChar)
 }
diff --git a/tsunami/vdom/vdom_context.go b/tsunami/vdom/vdom_context.go
deleted file mode 100644
index 6ac838a703..0000000000
--- a/tsunami/vdom/vdom_context.go
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package vdom
-
-import (
-	"context"
-)
-
-type vdomContextKeyType struct{}
-
-var vdomContextKey = vdomContextKeyType{}
-
-type VDomContext interface {
-	AddRenderWork(id string)
-	AddEffectWork(id string, effectIndex int)
-	AtomSetUsedBy(atomName string, waveId string, used bool)
-	AtomAddRenderWork(atomName string)
-	GetAtomVal(atomName string) any
-	SetAtomVal(atomName string, val any, markDirty bool)
-	GetRenderTs() int64
-	GetCompWaveId() string
-	GetOrderedHook() *Hook
-	IsResync() bool
-	GetCompName() string
-	SetAppTitle(title string)
-}
-
-func WithRenderContext(ctx context.Context, vc VDomContext) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	return context.WithValue(ctx, vdomContextKey, vc)
-}
-
-func GetRenderContext(ctx context.Context) VDomContext {
-	v := ctx.Value(vdomContextKey)
-	if v == nil {
-		return nil
-	}
-	return v.(VDomContext)
-}
diff --git a/tsunami/vdom/vdom_types.go b/tsunami/vdom/vdom_types.go
index 9efbdaf75e..86c890f67b 100644
--- a/tsunami/vdom/vdom_types.go
+++ b/tsunami/vdom/vdom_types.go
@@ -7,41 +7,13 @@ const TextTag = "#text"
 const WaveTextTag = "wave:text"
 const WaveNullTag = "wave:null"
 const FragmentTag = "#fragment"
-const BindTag = "#bind"
 
-const ChildrenPropKey = "children"
 const KeyPropKey = "key"
 
 const ObjectType_Ref = "ref"
 const ObjectType_Binding = "binding"
 const ObjectType_Func = "func"
 
-// generic hook structure
-type Hook struct {
-	Init      bool          // is initialized
-	Idx       int           // index in the hook array
-	Fn        func() func() // for useEffect
-	UnmountFn func()        // for useEffect
-	Val       any           // for useState, useMemo, useRef
-	Deps      []any
-}
-
-type Atom struct {
-	Val    any
-	Dirty  bool
-	UsedBy map[string]bool // component waveid -> true
-}
-
-const (
-	WorkType_Render = "render"
-	WorkType_Effect = "effect"
-)
-
-type EffectWorkElem struct {
-	Id          string
-	EffectIndex int
-}
-
 // vdom element
 type VDomElem struct {
 	WaveId   string         `json:"waveid,omitempty"` // required, except for #text nodes
@@ -147,3 +119,10 @@ type VDomPointerData struct {
 	Cmd     bool `json:"cmd,omitempty"`    // special (on mac it is meta, on windows/linux it is alt)
 	Option  bool `json:"option,omitempty"` // special (on mac it is alt, on windows/linux it is meta)
 }
+
+type VDomRefOperation struct {
+	RefId     string `json:"refid"`
+	Op        string `json:"op"`
+	Params    []any  `json:"params,omitempty"`
+	OutputRef string `json:"outputref,omitempty"`
+}
diff --git a/tsunami/vdomctx/vdomctx.go b/tsunami/vdomctx/vdomctx.go
new file mode 100644
index 0000000000..4e5c2c7d50
--- /dev/null
+++ b/tsunami/vdomctx/vdomctx.go
@@ -0,0 +1,40 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package vdomctx
+
+import (
+	"context"
+)
+
+type vdomContextKeyType struct{}
+
+var vdomContextKey = vdomContextKeyType{}
+
+type VDomContext interface {
+	UseRenderTs(ctx context.Context) int64
+	UseId(ctx context.Context) string
+	UseState(ctx context.Context, initialVal any) (any, func(any), func(func(any) any))
+	UseAtom(ctx context.Context, atomName string) (any, func(any), func(func(any) any))
+	UseVDomRef(ctx context.Context) any
+	UseRef(ctx context.Context, initialVal any) any
+	UseEffect(ctx context.Context, fn func() func(), deps []any)
+	UseResync(ctx context.Context) bool
+	UseSetAppTitle(ctx context.Context, title string)
+	QueueRefOp(ctx context.Context, op any)
+}
+
+func WithRenderContext(ctx context.Context, vc VDomContext) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, vdomContextKey, vc)
+}
+
+func GetRenderContext(ctx context.Context) VDomContext {
+	v := ctx.Value(vdomContextKey)
+	if v == nil {
+		return nil
+	}
+	return v.(VDomContext)
+}

From 2893a07a35aaa19803ebbfcec3c268c78f7e32ea Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 23:27:37 -0700
Subject: [PATCH 051/134] small cleanups and add godocs for public vdom
 funcs...

---
 tsunami/app/tsunamiapp.go |  10 ++-
 tsunami/vdom/vdom.go      | 147 +++++++++++++++++++++++++++++++-------
 2 files changed, 130 insertions(+), 27 deletions(-)

diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index ff11bd79fe..01d58bb487 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -230,6 +230,14 @@ func makeNullVDom() *vdom.VDomElem {
 	return &vdom.VDomElem{WaveId: uuid.New().String(), Tag: vdom.WaveNullTag}
 }
 
+func structToProps(props any) map[string]any {
+	m, err := util.StructToMap(props)
+	if err != nil {
+		return nil
+	}
+	return m
+}
+
 func DefineComponentEx[P any](client *Client, name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
 	if name == "" {
 		panic("Component name cannot be empty")
@@ -242,7 +250,7 @@ func DefineComponentEx[P any](client *Client, name string, renderFn func(ctx con
 		panic(err)
 	}
 	return func(props P) *vdom.VDomElem {
-		return vdom.H(name, vdom.Props(props))
+		return vdom.H(name, structToProps(props))
 	}
 }
 
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index 0b12284546..9845a0b769 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -17,18 +17,19 @@ import (
 
 type Component[P any] func(props P) *VDomElem
 
+// Key returns the key property of the VDomElem as a string.
+// Returns an empty string if the key is not set, otherwise converts the key value to string using fmt.Sprint.
 func (e *VDomElem) Key() string {
 	keyVal, ok := e.Props[KeyPropKey]
 	if !ok {
 		return ""
 	}
-	keyStr, ok := keyVal.(string)
-	if ok {
-		return keyStr
-	}
-	return ""
+	return fmt.Sprint(keyVal)
 }
 
+// WithKey sets the key property of the VDomElem and returns the element.
+// This is particularly useful for defined components since their prop types won't include keys.
+// Returns nil if the element is nil, otherwise returns the same element for chaining.
 func (e *VDomElem) WithKey(key string) *VDomElem {
 	if e == nil {
 		return nil
@@ -40,26 +41,67 @@ func (e *VDomElem) WithKey(key string) *VDomElem {
 	return e
 }
 
-func TextElem(text string) VDomElem {
+func textElem(text string) VDomElem {
 	return VDomElem{Tag: TextTag, Text: text}
 }
 
+func partToClasses(class any) []string {
+	if class == nil {
+		return nil
+	}
+	switch c := class.(type) {
+	case string:
+		if c != "" {
+			return []string{c}
+		}
+	case []string:
+		var parts []string
+		for _, s := range c {
+			if s != "" {
+				parts = append(parts, s)
+			}
+		}
+		return parts
+	case map[string]bool:
+		var parts []string
+		for k, v := range c {
+			if v && k != "" {
+				parts = append(parts, k)
+			}
+		}
+		return parts
+	case []any:
+		var parts []string
+		for _, item := range c {
+			parts = append(parts, partToClasses(item)...)
+		}
+		return parts
+	}
+	return nil
+}
+
+// Classes combines multiple class values into a single space-separated string.
+// Similar to the JavaScript clsx library, it accepts:
+//   - strings: added directly if non-empty
+//   - nil: ignored (useful for vdom.If() statements)
+//   - []string: all non-empty strings are added
+//   - map[string]bool: keys with true values are added
+//   - []any: recursively processed
+//
+// Returns a space-separated string of all valid class names.
 func Classes(classes ...any) string {
 	var parts []string
 	for _, class := range classes {
-		switch c := class.(type) {
-		case nil:
-			continue
-		case string:
-			if c != "" {
-				parts = append(parts, c)
-			}
-		}
-		// Ignore any other types
+		parts = append(parts, partToClasses(class)...)
 	}
 	return strings.Join(parts, " ")
 }
 
+// H creates a VDomElem with the specified tag, properties, and children.
+// This is the primary function for creating virtual DOM elements.
+// Children can be strings, VDomElems, *VDomElem, slices, booleans, numeric types,
+// or other types which are converted to strings using fmt.Sprint.
+// nil children are allowed and removed from the final list.
 func H(tag string, props map[string]any, children ...any) *VDomElem {
 	rtn := &VDomElem{Tag: tag, Props: props}
 	if len(children) > 0 {
@@ -71,6 +113,8 @@ func H(tag string, props map[string]any, children ...any) *VDomElem {
 	return rtn
 }
 
+// If returns the provided part if the condition is true, otherwise returns nil.
+// This is useful for conditional rendering in VDOM children lists, props, and style attributes.
 func If(cond bool, part any) any {
 	if cond {
 		return part
@@ -78,6 +122,9 @@ func If(cond bool, part any) any {
 	return nil
 }
 
+// IfElse returns part if the condition is true, otherwise returns elsePart.
+// This provides ternary-like conditional logic for VDOM children, props, and attributes.
+// Accepts mixed types - part and elsePart don't need to be the same type, which is especially useful for children.
 func IfElse(cond bool, part any, elsePart any) any {
 	if cond {
 		return part
@@ -85,6 +132,8 @@ func IfElse(cond bool, part any, elsePart any) any {
 	return elsePart
 }
 
+// Ternary returns trueRtn if the condition is true, otherwise returns falseRtn.
+// Unlike IfElse, this enforces type safety by requiring both return values to be the same type T.
 func Ternary[T any](cond bool, trueRtn T, falseRtn T) T {
 	if cond {
 		return trueRtn
@@ -93,6 +142,8 @@ func Ternary[T any](cond bool, trueRtn T, falseRtn T) T {
 	}
 }
 
+// ForEach applies a function to each item in a slice and returns a slice of results.
+// The function receives the item and its index, and can return any type for flexible VDOM generation.
 func ForEach[T any](items []T, fn func(T, int) any) []any {
 	elems := make([]any, len(items))
 	for idx, item := range items {
@@ -102,14 +153,11 @@ func ForEach[T any](items []T, fn func(T, int) any) []any {
 	return elems
 }
 
-func Props(props any) map[string]any {
-	m, err := util.StructToMap(props)
-	if err != nil {
-		return nil
-	}
-	return m
-}
-
+// UseState is the tsunami analog to React's useState hook.
+// It provides persistent state management within a VDOM component, returning the current
+// state value, a setter function, and an updater function.
+// Setting a new value causes a re-render of the component.
+// This hook must be called within a component context.
 func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T)) {
 	rc := vdomctx.GetRenderContext(ctx)
 	if rc == nil {
@@ -178,18 +226,35 @@ func useAtom[T any](ctx context.Context, hookName string, atomName string) (T, f
 	return atomVal, typedSetVal, typedSetFuncVal
 }
 
+// UseSharedAtom provides access to a shared atom state across components.
+// It returns the current atom value, a setter function, and an updater function.
+// Setting a new value causes a re-render of any component using this atom.
+// This hook must be called within a component context.
 func UseSharedAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
 	return useAtom[T](ctx, "UseSharedAtom", "$shared."+atomName)
 }
 
+// UseConfig provides access to config values (atom names are global across the app).
+// It returns the current config value, a setter function, and an updater function.
+// Setting a new value causes a re-render of all components using this config atom.
+// This hook must be called within a component context.
 func UseConfig[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
 	return useAtom[T](ctx, "UseConfig", "$config."+atomName)
 }
 
+// UseData provides access to data values (atom names are global across the app).
+// It returns the current data value, a setter function, and an updater function.
+// Setting a new value causes a re-render of all components using this data atom.
+// This hook must be called within a component context.
 func UseData[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
 	return useAtom[T](ctx, "UseData", "$data."+atomName)
 }
 
+// UseVDomRef provides a reference to a DOM element in the VDOM tree.
+// It returns a VDomRef that can be attached to elements for direct DOM access.
+// The ref will not be current on the first render - refs are set and become
+// current after client-side mounting.
+// This hook must be called within a component context.
 func UseVDomRef(ctx context.Context) *VDomRef {
 	rc := vdomctx.GetRenderContext(ctx)
 	val := rc.UseVDomRef(ctx)
@@ -200,6 +265,10 @@ func UseVDomRef(ctx context.Context) *VDomRef {
 	return refVal
 }
 
+// UseRef is the tsunami analog to React's useRef hook.
+// It provides a mutable ref object that persists across re-renders.
+// Unlike UseVDomRef, this is not tied to DOM elements but holds arbitrary values.
+// This hook must be called within a component context.
 func UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T] {
 	rc := vdomctx.GetRenderContext(ctx)
 	refVal := rc.UseRef(ctx, &VDomSimpleRef[T]{Current: val})
@@ -210,6 +279,10 @@ func UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T] {
 	return typedRef
 }
 
+// UseId returns the underlying component's unique identifier (UUID).
+// The ID persists across re-renders but is recreated when the component
+// is recreated, following React component lifecycle.
+// This hook must be called within a component context.
 func UseId(ctx context.Context) string {
 	rc := vdomctx.GetRenderContext(ctx)
 	if rc == nil {
@@ -218,6 +291,8 @@ func UseId(ctx context.Context) string {
 	return rc.UseId(ctx)
 }
 
+// UseRenderTs returns the timestamp of the current render.
+// This hook must be called within a component context.
 func UseRenderTs(ctx context.Context) int64 {
 	rc := vdomctx.GetRenderContext(ctx)
 	if rc == nil {
@@ -226,6 +301,10 @@ func UseRenderTs(ctx context.Context) int64 {
 	return rc.UseRenderTs(ctx)
 }
 
+// UseResync returns whether the current render is a resync operation.
+// Resyncs happen on initial app loads or full refreshes, as opposed to
+// incremental renders which happen otherwise.
+// This hook must be called within a component context.
 func UseResync(ctx context.Context) bool {
 	rc := vdomctx.GetRenderContext(ctx)
 	if rc == nil {
@@ -234,6 +313,11 @@ func UseResync(ctx context.Context) bool {
 	return rc.UseResync(ctx)
 }
 
+// UseEffect is the tsunami analog to React's useEffect hook.
+// It queues effects to run after the render cycle completes.
+// The function can return a cleanup function that runs before the next effect
+// or when the component unmounts. Dependencies use shallow comparison, just like React.
+// This hook must be called within a component context.
 func UseEffect(ctx context.Context, fn func() func(), deps []any) {
 	// note UseEffect never actually runs anything, it just queues the effect to run later
 	rc := vdomctx.GetRenderContext(ctx)
@@ -243,6 +327,8 @@ func UseEffect(ctx context.Context, fn func() func(), deps []any) {
 	rc.UseEffect(ctx, fn, deps)
 }
 
+// UseSetAppTitle sets the application title for the current component.
+// This hook must be called within a component context.
 func UseSetAppTitle(ctx context.Context, title string) {
 	rc := vdomctx.GetRenderContext(ctx)
 	if rc == nil {
@@ -251,6 +337,10 @@ func UseSetAppTitle(ctx context.Context, title string) {
 	rc.UseSetAppTitle(ctx, title)
 }
 
+// QueueRefOp queues a reference operation to be executed on the DOM element.
+// Operations include actions like "focus", "scrollIntoView", etc.
+// If the ref is nil or not current, the operation is ignored.
+// This function must be called within a component context.
 func QueueRefOp(ctx context.Context, ref *VDomRef, op VDomRefOperation) {
 	if ref == nil || !ref.HasCurrent {
 		return
@@ -265,17 +355,22 @@ func QueueRefOp(ctx context.Context, ref *VDomRef, op VDomRefOperation) {
 	vc.QueueRefOp(ctx, op)
 }
 
+// PartToElems converts various types into VDomElem slices for use in VDOM children.
+// It handles strings, booleans, VDomElems, *VDomElem, slices, and other types
+// by converting them to appropriate VDomElem representations.
+// nil values are ignored and removed from the final slice.
+// This is primarily an internal function and not typically called directly by application code.
 func PartToElems(part any) []VDomElem {
 	if part == nil {
 		return nil
 	}
 	switch partTyped := part.(type) {
 	case string:
-		return []VDomElem{TextElem(partTyped)}
+		return []VDomElem{textElem(partTyped)}
 	case bool:
 		// matches react
 		if partTyped {
-			return []VDomElem{TextElem("true")}
+			return []VDomElem{textElem("true")}
 		}
 		return nil
 	case VDomElem:
@@ -294,6 +389,6 @@ func PartToElems(part any) []VDomElem {
 			}
 			return rtn
 		}
-		return []VDomElem{TextElem(fmt.Sprint(part))}
+		return []VDomElem{textElem(fmt.Sprint(part))}
 	}
 }

From 1068fc57a1d38816f360efcdc5be94a129bb0ece Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 3 Sep 2025 23:37:58 -0700
Subject: [PATCH 052/134] rename parttoelems to toelems...

---
 tsunami/comp/rootelem.go | 2 +-
 tsunami/vdom/vdom.go     | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index 280075359e..bf89c7c971 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -439,7 +439,7 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 	vc := MakeContextVal(r, *comp, opts)
 	ctx := vdomctx.WithRenderContext(r.OuterCtx, vc)
 	renderedElem := callCFunc(cfunc, ctx, props)
-	rtnElemArr := vdom.PartToElems(renderedElem)
+	rtnElemArr := vdom.ToElems(renderedElem)
 	if len(rtnElemArr) == 0 {
 		r.unmount(&(*comp).Comp)
 		return
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index 9845a0b769..c473d3c5cb 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -106,7 +106,7 @@ func H(tag string, props map[string]any, children ...any) *VDomElem {
 	rtn := &VDomElem{Tag: tag, Props: props}
 	if len(children) > 0 {
 		for _, part := range children {
-			elems := PartToElems(part)
+			elems := ToElems(part)
 			rtn.Children = append(rtn.Children, elems...)
 		}
 	}
@@ -355,12 +355,12 @@ func QueueRefOp(ctx context.Context, ref *VDomRef, op VDomRefOperation) {
 	vc.QueueRefOp(ctx, op)
 }
 
-// PartToElems converts various types into VDomElem slices for use in VDOM children.
+// ToElems converts various types into VDomElem slices for use in VDOM children.
 // It handles strings, booleans, VDomElems, *VDomElem, slices, and other types
 // by converting them to appropriate VDomElem representations.
 // nil values are ignored and removed from the final slice.
 // This is primarily an internal function and not typically called directly by application code.
-func PartToElems(part any) []VDomElem {
+func ToElems(part any) []VDomElem {
 	if part == nil {
 		return nil
 	}
@@ -385,7 +385,7 @@ func PartToElems(part any) []VDomElem {
 		if partVal.Kind() == reflect.Slice {
 			var rtn []VDomElem
 			for i := 0; i < partVal.Len(); i++ {
-				rtn = append(rtn, PartToElems(partVal.Index(i).Interface())...)
+				rtn = append(rtn, ToElems(partVal.Index(i).Interface())...)
 			}
 			return rtn
 		}

From 41ff2e11294bae03d1c76e3f5e155f5f33b92a7a Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 4 Sep 2025 10:30:04 -0700
Subject: [PATCH 053/134] prompt updates, create promps dir, rename to
 system.md

---
 tsunami/{prompt.md => prompts/system.md} | 150 ++++++++++++++++++-----
 1 file changed, 120 insertions(+), 30 deletions(-)
 rename tsunami/{prompt.md => prompts/system.md} (80%)

diff --git a/tsunami/prompt.md b/tsunami/prompts/system.md
similarity index 80%
rename from tsunami/prompt.md
rename to tsunami/prompts/system.md
index 59d98f2883..ef86cb9a31 100644
--- a/tsunami/prompt.md
+++ b/tsunami/prompts/system.md
@@ -1,43 +1,80 @@
 # Tsunami Framework Guide
 
-Wave Terminal includes a powerful Tsunami framework that lets developers create rich HTML/React-based UI applications directly from Go code. The system translates Go components and elements into React components that are rendered within Wave Terminal's UI. It's particularly well-suited for administrative interfaces, monitoring dashboards, data visualization, configuration managers, and form-based applications where you want a graphical interface but don't need complex browser-side interactions.
+The Tsunami framework brings React-style UI development to Go, letting you build rich graphical applications that run inside Wave Terminal. If you know React, you already understand Tsunami's core concepts - it uses the same patterns for components, props, hooks, state management, and styling, but implemented entirely in Go.
 
-This guide explains how to use the Tsunami framework (and corresponding VDOM, virtual DOM, component) to create interactive applications that run in Wave Terminal. While the patterns will feel familiar to React developers (components, props, hooks), the implementation is pure Go and takes advantage of Go's strengths like goroutines for async operations. Note that complex browser-side interactions like drag-and-drop, rich text editing, or heavy JavaScript functionality are not supported - the framework is designed for straightforward, practical applications.
+## React Patterns in Go
 
-You'll learn how to:
+Tsunami mirrors React's developer experience:
 
-- Create and compose components
-- Manage state and handle events
-- Work with styles and CSS
-- Handle async operations with goroutines
-- Create rich UIs that render in Wave Terminal
+- **Components**: Define reusable UI pieces with typed props structs
+- **JSX-like syntax**: Use `vdom.H()` to build element trees (like `React.createElement`)
+- **Hooks**: `UseState`, `UseEffect`, `UseRef` work exactly like React hooks
+- **Props and state**: Familiar patterns for data flow and updates
+- **Conditional rendering**: `vdom.If()` and `vdom.IfElse()` for dynamic UIs
+- **Event handling**: onClick, onChange, onKeyDown with React-like event objects
+- **Styling**: Built-in Tailwind v4 CSS classes, plus inline styles via `style` prop
 
-The included todo-main.go provides a complete example application showing these patterns in action.
+The key difference: everything is pure Go code. No JavaScript, no build tools, no transpilation. You get React's mental model with Go's type safety, performance, and ecosystem.
 
-## App Setup and Registration
+## Built for AI Development
 
-Tsunami applications define components using the default client:
+Tsunami is designed with AI code generation in mind. The framework maps directly to React concepts that AI models understand well:
 
 ```go
-// Components are defined using the default client
-var MyComponent = app.DefineComponent("MyComponent",
-    func(ctx context.Context, props MyProps) any {
-        // component logic
-    },
+// This feels like React JSX, but it's pure Go
+return vdom.H("div", map[string]any{
+    "className": "flex items-center gap-4 p-4",
+},
+    vdom.H("input", map[string]any{
+        "type": "checkbox",
+        "checked": todo.Completed,
+        "onChange": handleToggle,
+    }),
+    vdom.H("span", map[string]any{
+        "className": vdom.Classes("flex-1", vdom.If(todo.Completed, "line-through")),
+    }, todo.Text),
 )
+```
+
+AI models can leverage their React knowledge to generate Tsunami applications, while developers get the benefits of Go's concurrency, error handling, and type system.
 
-// The main "App" component can set the app title
+## How It Works
+
+Tsunami applications run as Go programs that generate virtual DOM structures. Wave Terminal renders these as HTML/CSS in its interface, handling the React-like reconciliation and updates. You write Go code using familiar React patterns, and Wave Terminal handles the browser complexity.
+
+## Creating a Tsunami Application
+
+A Tsunami application is simply a Go package with an `App` component. Here's a minimal "Hello World" example:
+
+```go
+package main
+
+import (
+    "context"
+    "github.com/wavetermdev/waveterm/tsunami/app"
+    "github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+// The App component is the required entry point for every Tsunami application
 var App = app.DefineComponent("App",
     func(ctx context.Context, _ struct{}) any {
-        vdom.UseSetAppTitle(ctx, "My Tsunami App")  // Only works in top-level App component
+        vdom.UseSetAppTitle(ctx, "Hello World")
 
-        return vdom.H("div", nil,
-            // app content
-        )
+        return vdom.H("div", map[string]any{
+            "className": "flex items-center justify-center h-screen text-xl font-bold",
+        }, "Hello, Tsunami!")
     },
 )
 ```
 
+Key Points:
+
+- Must use package main.
+- The `App` component is required. It serves as the entry point to your application.
+- Do NOT add a `main()` function, that is provided by the framework when building.
+- Uses Tailwind v4 for styling - you can use any Tailwind classes in your components.
+- Use React-style camel case props (`className`, `onClick`)
+
 ## Building Elements with vdom.H()
 
 The H function creates virtual DOM elements following a React-like pattern. It takes a tag name, a props map, and any number of children:
@@ -174,16 +211,69 @@ vdom.H("ul", nil,
 
 Helper functions:
 
-- `vdom.Fragment(...any)` - Combines elements into a group without adding a DOM node. Useful with conditional functions.
 - `vdom.If(cond bool, part any) any` - Returns part if condition is true, nil otherwise
-- `vdom.IfElse(cond bool, truePart any, falsePart any) any` - Returns truePart if condition is true, falsePart otherwise
-- `vdom.ForEach[T any](items []T, fn func(T) any) []any` - Maps over items without index
-- `vdom.ForEachIdx[T any](items []T, fn func(T, int) any) []any` - Maps over items with index
-- `vdom.Filter[T any](items []T, fn func(T) bool) []T` - Filters items based on condition
-- `vdom.FilterIdx[T any](items []T, fn func(T, int) bool) []T` - Filters items with index access
-
-- The same If/IfElse functions are used for both conditional rendering and conditional classes, always following the pattern of condition first, then value(s).
-- Remember to use vdom.IfElse if you need a true ternary condition. vdom.If will return nil on false and does not allow a 3rd argument.
+- `vdom.IfElse(cond bool, part any, elsePart any) any` - Returns part if condition is true, elsePart otherwise
+- `vdom.Ternary[T any](cond bool, trueRtn T, falseRtn T) T` - Type-safe ternary operation, returns trueRtn if condition is true, falseRtn otherwise
+- `vdom.ForEach[T any](items []T, fn func(T, int) any) []any` - Maps over items with index, function receives item and index
+- `vdom.Classes(classes ...any) string` - Combines multiple class values into a single space-separated string, similar to JavaScript clsx library (accepts string, []string, and map[string]bool params)
+
+- The vdom.If and vdom.IfElse functions can be used for both conditional rendering of elements, conditional classes, and conditional props.
+- For vdom.If and vdom.IfElse, always follow the pattern of condition first (bool), then value(s).
+- Use vdom.IfElse for conditions that return different types, use Ternary when the return values are the same type.
+
+## Using Hooks in Tsunami
+
+Functions starting with `vdom.Use*` are hooks in Tsunami, following the exact same rules as React hooks.
+
+**Key Rules:**
+
+- ✅ Only call hooks inside `app.DefineComponent` functions
+- ✅ Always call hooks at the **top level** of your component function
+- ✅ Call hooks before any early returns or conditional logic
+- 🔴 Never call hooks inside loops, conditions, or after conditional returns
+
+```go
+var MyComponent = app.DefineComponent("MyComponent",
+    func(ctx context.Context, props MyProps) any {
+        // ✅ Good: hooks at top level
+        count := vdom.UseState(ctx, 0)
+        vdom.UseEffect(ctx, func() { /* effect */ }, nil)
+
+        // Now safe to have conditional logic
+        if someCondition {
+            return vdom.H("div", nil, "Early return")
+        }
+
+        return vdom.H("div", nil, "Content")
+    },
+)
+```
+
+**Common Hooks (React-like):**
+
+- `UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T))` - Component state management (React `useState`)
+- `UseEffect(ctx context.Context, fn func() func(), deps []any)` - Side effects after render (React `useEffect`)
+- `UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T]` - Mutable refs for arbitrary values (React `useRef`)
+- `UseVDomRef(ctx context.Context) *VDomRef` - DOM element references (React `useRef` for DOM elements)
+- `UseSetAppTitle(ctx context.Context, title string)` - Sets the application title (used in every app, only works in top-level "App" component)
+
+**Global Data Hooks (Jotai-like atoms):**
+
+- `UseSharedAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T))` - Shared state across components
+- `UseConfig[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T))` - Access to global config values
+- `UseData[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T))` - Access to global data values
+
+These allow applications to easily share data between components. When an atom is updated, all components using it will re-render.
+
+**Specialty Hooks (less common):**
+
+- `UseId(ctx context.Context) string` - Component's unique identifier
+- `UseRenderTs(ctx context.Context) int64` - Current render timestamp
+- `UseResync(ctx context.Context) bool` - Whether current render is a resync operation
+
+Most applications won't need these specialty hooks, but they're available for advanced use cases.
+
+This ensures hooks are called in the same order every render, which is essential for Tsunami's state management.
 
 ## Style Handling
 

From bedfe330a1b360b536a0df6090df7312228ff5f2 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 4 Sep 2025 10:43:22 -0700
Subject: [PATCH 054/134] prompt updates, vdom bug fix

---
 tsunami/prompts/system.md | 63 +++++++++++++++++++++------------------
 tsunami/vdom/vdom.go      |  2 +-
 2 files changed, 35 insertions(+), 30 deletions(-)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index ef86cb9a31..58574258ef 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -77,7 +77,7 @@ Key Points:
 
 ## Building Elements with vdom.H()
 
-The H function creates virtual DOM elements following a React-like pattern. It takes a tag name, a props map, and any number of children:
+The H function creates virtual DOM elements following a React-like pattern (`React.createElement`). It takes a tag name, a props map, and any number of children:
 
 ```go
 // Basic element with no props
@@ -85,7 +85,7 @@ vdom.H("div", nil, "Hello world")
 
 // Element with props
 vdom.H("div", map[string]any{
-    "className": "container",
+    "className": "max-w-4xl mx-auto p-4",
     "id": "main",
     "onClick": func() {
         fmt.Println("clicked!")
@@ -94,38 +94,39 @@ vdom.H("div", map[string]any{
     "child content",
 )
 
-// Element with style
+// Element with style (for custom CSS properties not available in Tailwind)
 vdom.H("div", map[string]any{
     "style": map[string]any{
-        "marginTop": 10,      // Numbers automatically convert to px
-        "color": "red",
-        "display": "flex",
+        "marginTop": 10,      // Numbers automatically convert to px (like React)
+        "zIndex": 1000,
+        "transform": "rotate(45deg)",
     },
 })
 
-// Working with classes
+// Working with Tailwind classes
 vdom.H("div", map[string]any{
     "className": vdom.Classes(
-        "base",                     // Static classes
-        vdom.If(isActive, "active"),    // Conditional class: condition first, then class
-        vdom.If(isDisabled, "disabled"), // Another conditional
+        "p-4 bg-white rounded-lg",                    // Static Tailwind classes
+        vdom.If(isActive, "bg-blue-500 text-white"),     // Conditional class: condition first, then class
+        vdom.If(isDisabled, "opacity-50 cursor-not-allowed"), // Another conditional
     ),
 })
 
 // Nesting elements
 vdom.H("div", map[string]any{
-    "className": "container",
+    "className": "max-w-4xl mx-auto",
 },
     vdom.H("h1", map[string]any{
-        "className": "title",
+        "className": "text-2xl font-bold mb-4",
     }, "Hello"),
     vdom.H("p", map[string]any{
-        "className": "content",
+        "className": "text-gray-600 leading-relaxed",
     }, "Some content"),
 )
 
 // Handling events
 vdom.H("button", map[string]any{
+    "className": "px-4 py-2 bg-blue-500 text-white rounded hover:bg-blue-600",
     "onClick": func() {
         handleClick()
     },
@@ -137,18 +138,22 @@ vdom.H("button", map[string]any{
 })
 
 // List rendering
-vdom.H("ul", nil,
-    vdom.ForEachIdx(items, func(item string, idx int) any {
+vdom.H("ul", map[string]any{
+    "className": "space-y-2",
+},
+    vdom.ForEach(items, func(item string, idx int) any {
         return vdom.H("li", map[string]any{
             "key": idx,
-            "className": "list-item",
+            "className": "py-2 px-4 bg-gray-100 rounded",
         }, item)
     }),
 )
 
 // Conditional rendering
 vdom.H("div", nil,
-    vdom.If(isVisible, vdom.H("span", nil, "Visible content")),
+    vdom.If(isVisible, vdom.H("span", map[string]any{
+        "className": "text-green-500 font-semibold",
+    }, "Visible content")),
 )
 ```
 
@@ -156,8 +161,8 @@ Arguments to H:
 
 1. `tag` (string): The HTML tag name
 2. `props` (map[string]any or nil): Props map including:
-   - className: String of space-separated classes
-   - style: map[string]any of CSS properties
+   - className: String of space-separated classes (like React)
+   - style: map[string]any of CSS properties (like React)
    - Event handlers (onClick, onChange, etc)
    - Any other valid HTML attributes
 3. `children` (...any): Any number of child elements:
@@ -170,12 +175,12 @@ Arguments to H:
 
 Best practices:
 
-- Use Classes() with If() for conditional classes
-- Use camelCase for style properties (matching React)
-- Numbers in style are automatically converted to pixel values
-- Always create new slices when updating arrays in state
-- Use ForEach or ForEachIdx for list rendering
-- Include key prop when rendering lists
+- Use Classes() with If() for conditional classes (similar to React's conditional className patterns)
+- Use camelCase for style properties (exactly like React)
+- Numbers in style are automatically converted to pixel values (like React)
+- Always create new slices when updating arrays in state (like React's immutability principle)
+- Use ForEach for list rendering (always passes index, like React's map with index)
+- Include key prop when rendering lists (essential for React-like reconciliation)
 
 ## Conditional Rendering and Lists
 
@@ -200,7 +205,7 @@ vdom.H("div", nil,
 // List rendering (adding "key" prop to li element)
 items := []string{"A", "B", "C"}
 vdom.H("ul", nil,
-    vdom.ForEachIdx(items, func(item string, idx int) any {
+    vdom.ForEach(items, func(item string, idx int) any {
         return vdom.H("li", map[string]any{
             "key": idx,
             "className": "list-item",
@@ -506,7 +511,7 @@ func MyComponent(ctx context.Context, props MyProps) any {
             },
         }),
         vdom.H("ul", nil,
-            vdom.ForEach(items, func(item string) any {
+            vdom.ForEach(items, func(item string, _ int) any {
                 return vdom.H("li", nil, item)
             }),
         ),
@@ -647,7 +652,7 @@ var TodoApp = app.DefineComponent("TodoApp",
         }, []any{})
 
         return vdom.H("div", nil,
-            vdom.ForEach(globalTodos, func(todo Todo) any {
+            vdom.ForEach(globalTodos, func(todo Todo, _ int) any {
                 return TodoItem(TodoItemProps{Todo: todo})
             }),
         )
@@ -910,7 +915,7 @@ var App = app.DefineComponent("App",
 
             vdom.H("div", map[string]any{
                 "className": "flex flex-col gap-2",
-            }, vdom.ForEach(todos, func(todo Todo) any {
+            }, vdom.ForEach(todos, func(todo Todo, _ int) any {
                 return TodoItem(TodoItemProps{
                     Todo:     todo,
                     OnToggle: func() { toggleTodo(todo.Id) },
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index c473d3c5cb..33e7947c08 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -145,7 +145,7 @@ func Ternary[T any](cond bool, trueRtn T, falseRtn T) T {
 // ForEach applies a function to each item in a slice and returns a slice of results.
 // The function receives the item and its index, and can return any type for flexible VDOM generation.
 func ForEach[T any](items []T, fn func(T, int) any) []any {
-	elems := make([]any, len(items))
+	elems := make([]any, 0, len(items))
 	for idx, item := range items {
 		fnResult := fn(item, idx)
 		elems = append(elems, fnResult)

From 6bff9aac7dd3af39da8c00a4a54aae63df5f1fad Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 4 Sep 2025 12:59:36 -0700
Subject: [PATCH 055/134] consistent naming

---
 tsunami/prompts/system.md | 50 +++++++++++++++++++--------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 58574258ef..bee9b25bdd 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -7,10 +7,10 @@ The Tsunami framework brings React-style UI development to Go, letting you build
 Tsunami mirrors React's developer experience:
 
 - **Components**: Define reusable UI pieces with typed props structs
-- **JSX-like syntax**: Use `vdom.H()` to build element trees (like `React.createElement`)
-- **Hooks**: `UseState`, `UseEffect`, `UseRef` work exactly like React hooks
+- **JSX-like syntax**: Use vdom.H to build element trees (like React.createElement)
+- **Hooks**: vdom.UseState, vdom.UseEffect, vdom.UseRef work exactly like React hooks
 - **Props and state**: Familiar patterns for data flow and updates
-- **Conditional rendering**: `vdom.If()` and `vdom.IfElse()` for dynamic UIs
+- **Conditional rendering**: vdom.If and vdom.IfElse for dynamic UIs
 - **Event handling**: onClick, onChange, onKeyDown with React-like event objects
 - **Styling**: Built-in Tailwind v4 CSS classes, plus inline styles via `style` prop
 
@@ -77,7 +77,7 @@ Key Points:
 
 ## Building Elements with vdom.H()
 
-The H function creates virtual DOM elements following a React-like pattern (`React.createElement`). It takes a tag name, a props map, and any number of children:
+The vdom.H function creates virtual DOM elements following a React-like pattern (React.createElement). It takes a tag name, a props map, and any number of children:
 
 ```go
 // Basic element with no props
@@ -175,11 +175,11 @@ Arguments to H:
 
 Best practices:
 
-- Use Classes() with If() for conditional classes (similar to React's conditional className patterns)
+- Use vdom.Classes with vdom.If for conditional classes (similar to React's conditional className patterns)
 - Use camelCase for style properties (exactly like React)
 - Numbers in style are automatically converted to pixel values (like React)
 - Always create new slices when updating arrays in state (like React's immutability principle)
-- Use ForEach for list rendering (always passes index, like React's map with index)
+- Use vdom.ForEach for list rendering (always passes index, like React's map with index)
 - Include key prop when rendering lists (essential for React-like reconciliation)
 
 ## Conditional Rendering and Lists
@@ -232,7 +232,7 @@ Functions starting with `vdom.Use*` are hooks in Tsunami, following the exact sa
 
 **Key Rules:**
 
-- ✅ Only call hooks inside `app.DefineComponent` functions
+- ✅ Only call hooks inside app.DefineComponent functions
 - ✅ Always call hooks at the **top level** of your component function
 - ✅ Call hooks before any early returns or conditional logic
 - 🔴 Never call hooks inside loops, conditions, or after conditional returns
@@ -366,8 +366,8 @@ Components in Tsunami:
 
 - Use Go structs with json tags for props
 - Take a context and props as arguments
-- Return elements created with vdom.H()
-- Can use all hooks (useState, useRef, etc)
+- Return elements created with vdom.H
+- Can use all hooks (vdom.UseState, vdom.UseRef, etc)
 - Are registered with the default client and given a name
 - Are called as functions with their props struct
 
@@ -523,7 +523,7 @@ func MyComponent(ctx context.Context, props MyProps) any {
 
 The system provides three main types of hooks:
 
-1. `UseState` - For values that trigger re-renders when changed:
+1. vdom.UseState - For values that trigger re-renders when changed:
 
    - Returns current value, direct setter, and functional setter
    - Direct setter triggers component re-render
@@ -540,7 +540,7 @@ The system provides three main types of hooks:
    })
    ```
 
-2. `UseRef` - For values that persist between renders without triggering updates:
+2. vdom.UseRef - For values that persist between renders without triggering updates:
 
    - Holds mutable values that survive re-renders
    - Changes don't cause re-renders
@@ -556,7 +556,7 @@ The system provides three main types of hooks:
    })
    ```
 
-3. `UseVDomRef` - For accessing DOM elements directly:
+3. vdom.UseVDomRef - For accessing DOM elements directly:
    - Creates refs for DOM interaction
    - Useful for:
      - Accessing DOM element properties
@@ -573,10 +573,10 @@ The system provides three main types of hooks:
 
 Best Practices:
 
-- Use `UseState` for all UI state - it provides both direct and functional setters
+- Use vdom.UseState for all UI state - it provides both direct and functional setters
 - Use functional setter when updating state from goroutines or based on current value
-- Use `UseRef` for complex state that goroutines need to access
-- Always clean up timers, channels, and goroutines in UseEffect cleanup functions
+- Use vdom.UseRef for complex state that goroutines need to access
+- Always clean up timers, channels, and goroutines in vdom.UseEffect cleanup functions
 
 ## State Management and Async Updates
 
@@ -599,7 +599,7 @@ var TodoApp = app.DefineComponent("TodoApp",
         // Local state for UI updates
         count, setCount := vdom.UseState(ctx, 0)
 
-        // UseState returns value, setter, and functional setter
+        // vdom.UseState returns value, setter, and functional setter
         seconds, setSeconds, setSecondsFn := vdom.UseState(ctx, 0)
 
         // Use refs to store complex state that goroutines need to access
@@ -644,7 +644,7 @@ var TodoApp = app.DefineComponent("TodoApp",
             }
         }
 
-        // Use UseEffect for cleanup on unmount
+        // Use vdom.UseEffect for cleanup on unmount
         vdom.UseEffect(ctx, func() func() {
             return func() {
                 stopAsync()
@@ -665,8 +665,8 @@ Key points for state management:
 - Global state is fine for simple data structures
 - Use functional setter when updating state based on its current value, especially in goroutines
 - Store complex state in refs when it needs to be accessed by goroutines
-- Use `UseEffect` cleanup function to handle component unmount
-- Call `SendAsyncInitiation()` after state changes in goroutines (consider round trip performance, so don't call at very high speeds)
+- Use vdom.UseEffect cleanup function to handle component unmount
+- Call app.SendAsyncInitiation after state changes in goroutines (consider round trip performance, so don't call at very high speeds)
 - Use atomic operations if globals are modified from multiple goroutines (or locks)
 
 ## Global Keyboard Handling
@@ -931,7 +931,7 @@ var App = app.DefineComponent("App",
 Key points:
 
 1. Root component must be named "App"
-2. Use `vdom.UseSetAppTitle()` in the main App component to set the window title
+2. Use vdom.UseSetAppTitle in the main App component to set the window title
 3. Do NOT write a main() function - the framework handles app lifecycle
 4. File handlers can be registered in init() if needed
 
@@ -940,15 +940,15 @@ Key points:
 - Props must be defined as Go structs with json tags
 - Components take their props type directly: `func MyComponent(ctx context.Context, props MyProps) any`
 - Always use app.DefineComponent for component registration
-- Call app.SendAsyncInitiation() after async state updates
-- Provide keys when using ForEach() with lists (using WithKey() method)
-- Use Classes() with If() for combining static and conditional class names
-- Consider cleanup functions in UseEffect() for async operations
+- Call app.SendAsyncInitiation after async state updates
+- Provide keys when using vdom.ForEach with lists (using WithKey method)
+- Use vdom.Classes with vdom.If for combining static and conditional class names
+- Consider cleanup functions in vdom.UseEffect for async operations
 - <script> tags are NOT supported
 - Applications consist of a single file: app.go containing all Go code and component definitions
 - Styling is handled through Tailwind v4 CSS classes
 - No main() function is needed - use init() for configuration
 - This is a pure Go system - do not attempt to write React components or JavaScript code
-- All UI rendering, including complex visualizations, should be done through Go using vdom.H()
+- All UI rendering, including complex visualizations, should be done through Go using vdom.H
 
 The todo demo demonstrates all these patterns in a complete application.

From ce86dedffd2dd735956e60bf35ab60014332d3c3 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 4 Sep 2025 13:21:32 -0700
Subject: [PATCH 056/134] clean up tsunami/app api surface

---
 tsunami/app/defaultclient.go       | 29 +++++-------
 tsunami/app/serverhandlers.go      | 38 +++++++--------
 tsunami/app/tsunamiapp.go          | 76 ++++++++++++++++--------------
 tsunami/templates/app-main.go.tmpl |  3 +-
 4 files changed, 72 insertions(+), 74 deletions(-)

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 553ce526e4..16d41ed170 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -11,30 +11,25 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-var defaultClient = MakeClient()
+var defaultClient = makeClient()
 var assetsFS fs.FS
 var staticFS fs.FS
-var manifestFile *FileHandlerOption
+var manifestFileBytes []byte
 
 // Default client methods that operate on the global defaultClient
 
 func DefineComponent[P any](name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
-	return DefineComponentEx(defaultClient, name, renderFn)
+	return defineComponentEx(defaultClient, name, renderFn)
 }
 
-func SetGlobalEventHandler(handler func(client *Client, event vdom.VDomEvent)) {
+func SetGlobalEventHandler(handler func(event vdom.VDomEvent)) {
 	defaultClient.SetGlobalEventHandler(handler)
 }
 
-
 func AddSetupFn(fn func()) {
 	defaultClient.AddSetupFn(fn)
 }
 
-func RunMain() {
-	defaultClient.RunMain()
-}
-
 func SendAsyncInitiation() error {
 	return defaultClient.SendAsyncInitiation()
 }
@@ -63,14 +58,14 @@ func RegisterFileHandler(path string, option FileHandlerOption) {
 	defaultClient.RegisterFileHandler(path, option)
 }
 
-func RegisterAssetsFS(filesystem fs.FS) {
-	assetsFS = filesystem
-}
-
-func RegisterStaticFS(filesystem fs.FS) {
-	staticFS = filesystem
+// RunMain is used internally by generated code and should not be called directly.
+func RunMain() {
+	defaultClient.RunMain()
 }
 
-func RegisterManifestFile(option FileHandlerOption) {
-	manifestFile = &option
+// RegisterEmbeds is used internally by generated code and should not be called directly.
+func RegisterEmbeds(assetsFilesystem fs.FS, staticFilesystem fs.FS, manifest []byte) {
+	assetsFS = assetsFilesystem
+	staticFS = staticFilesystem
+	manifestFileBytes = manifest
 }
diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index 022a93549c..c6288ab6ae 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -26,24 +26,24 @@ func init() {
 	mime.AddExtensionType(".json", "application/json")
 }
 
-type HandlerOpts struct {
+type handlerOpts struct {
 	AssetsFS     fs.FS
 	StaticFS     fs.FS
 	ManifestFile *FileHandlerOption
 }
 
-type HTTPHandlers struct {
-	Client     *Client
+type httpHandlers struct {
+	Client     *clientImpl
 	renderLock sync.Mutex
 }
 
-func NewHTTPHandlers(client *Client) *HTTPHandlers {
-	return &HTTPHandlers{
+func newHTTPHandlers(client *clientImpl) *httpHandlers {
+	return &httpHandlers{
 		Client: client,
 	}
 }
 
-func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux, opts HandlerOpts) {
+func (h *httpHandlers) registerHandlers(mux *http.ServeMux, opts handlerOpts) {
 	mux.HandleFunc("/api/render", h.handleRender)
 	mux.HandleFunc("/api/updates", h.handleSSE)
 	mux.HandleFunc("/api/data", h.handleData)
@@ -62,7 +62,7 @@ func (h *HTTPHandlers) RegisterHandlers(mux *http.ServeMux, opts HandlerOpts) {
 	}
 }
 
-func (h *HTTPHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
+func (h *httpHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
 	defer func() {
 		panicErr := util.PanicHandler("handleRender", recover())
 		if panicErr != nil {
@@ -112,7 +112,7 @@ func (h *HTTPHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (h *HTTPHandlers) processFrontendUpdate(feUpdate *rpctypes.VDomFrontendUpdate) (*rpctypes.VDomBackendUpdate, error) {
+func (h *httpHandlers) processFrontendUpdate(feUpdate *rpctypes.VDomFrontendUpdate) (*rpctypes.VDomBackendUpdate, error) {
 	h.renderLock.Lock()
 	defer h.renderLock.Unlock()
 
@@ -136,7 +136,7 @@ func (h *HTTPHandlers) processFrontendUpdate(feUpdate *rpctypes.VDomFrontendUpda
 	for _, event := range feUpdate.Events {
 		if event.GlobalEventType != "" {
 			if h.Client.GlobalEventHandler != nil {
-				h.Client.GlobalEventHandler(h.Client, event)
+				h.Client.GlobalEventHandler(event)
 			}
 		} else {
 			h.Client.Root.Event(event.WaveId, event.EventType, event)
@@ -164,7 +164,7 @@ func (h *HTTPHandlers) processFrontendUpdate(feUpdate *rpctypes.VDomFrontendUpda
 	return update, nil
 }
 
-func (h *HTTPHandlers) handleData(w http.ResponseWriter, r *http.Request) {
+func (h *httpHandlers) handleData(w http.ResponseWriter, r *http.Request) {
 	defer func() {
 		panicErr := util.PanicHandler("handleData", recover())
 		if panicErr != nil {
@@ -186,7 +186,7 @@ func (h *HTTPHandlers) handleData(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (h *HTTPHandlers) handleConfig(w http.ResponseWriter, r *http.Request) {
+func (h *httpHandlers) handleConfig(w http.ResponseWriter, r *http.Request) {
 	defer func() {
 		panicErr := util.PanicHandler("handleConfig", recover())
 		if panicErr != nil {
@@ -204,7 +204,7 @@ func (h *HTTPHandlers) handleConfig(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (h *HTTPHandlers) handleConfigGet(w http.ResponseWriter, _ *http.Request) {
+func (h *httpHandlers) handleConfigGet(w http.ResponseWriter, _ *http.Request) {
 	result := h.Client.Root.GetConfigMap()
 
 	w.Header().Set("Content-Type", "application/json")
@@ -214,7 +214,7 @@ func (h *HTTPHandlers) handleConfigGet(w http.ResponseWriter, _ *http.Request) {
 	}
 }
 
-func (h *HTTPHandlers) handleConfigPost(w http.ResponseWriter, r *http.Request) {
+func (h *httpHandlers) handleConfigPost(w http.ResponseWriter, r *http.Request) {
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		http.Error(w, fmt.Sprintf("failed to read request body: %v", err), http.StatusBadRequest)
@@ -235,7 +235,7 @@ func (h *HTTPHandlers) handleConfigPost(w http.ResponseWriter, r *http.Request)
 	w.WriteHeader(http.StatusOK)
 }
 
-func (h *HTTPHandlers) handleDynContent(w http.ResponseWriter, r *http.Request) {
+func (h *httpHandlers) handleDynContent(w http.ResponseWriter, r *http.Request) {
 	defer func() {
 		panicErr := util.PanicHandler("handleDynContent", recover())
 		if panicErr != nil {
@@ -252,7 +252,7 @@ func (h *HTTPHandlers) handleDynContent(w http.ResponseWriter, r *http.Request)
 	h.Client.UrlHandlerMux.ServeHTTP(w, r)
 }
 
-func (h *HTTPHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
+func (h *httpHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 	defer func() {
 		panicErr := util.PanicHandler("handleSSE", recover())
 		if panicErr != nil {
@@ -342,7 +342,7 @@ func serveFileDirectly(w http.ResponseWriter, r *http.Request, embeddedFS fs.FS,
 	return true
 }
 
-func (h *HTTPHandlers) handleStaticFiles(embeddedFS fs.FS) http.HandlerFunc {
+func (h *httpHandlers) handleStaticFiles(embeddedFS fs.FS) http.HandlerFunc {
 	fileServer := http.FileServer(http.FS(embeddedFS))
 
 	return func(w http.ResponseWriter, r *http.Request) {
@@ -377,7 +377,7 @@ func (h *HTTPHandlers) handleStaticFiles(embeddedFS fs.FS) http.HandlerFunc {
 	}
 }
 
-func (h *HTTPHandlers) handleManifest(manifestFile *FileHandlerOption) http.HandlerFunc {
+func (h *httpHandlers) handleManifest(manifestFile *FileHandlerOption) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		defer func() {
 			panicErr := util.PanicHandler("handleManifest", recover())
@@ -396,11 +396,11 @@ func (h *HTTPHandlers) handleManifest(manifestFile *FileHandlerOption) http.Hand
 			return
 		}
 
-		ServeFileOption(w, r, *manifestFile)
+		serveFileOption(w, r, *manifestFile)
 	}
 }
 
-func (h *HTTPHandlers) handleStaticPathFiles(staticFS fs.FS) http.HandlerFunc {
+func (h *httpHandlers) handleStaticPathFiles(staticFS fs.FS) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		defer func() {
 			panicErr := util.PanicHandler("handleStaticPathFiles", recover())
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 01d58bb487..53c7c3af62 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -28,12 +28,12 @@ const TsunamiListenAddrEnvVar = "TSUNAMI_LISTENADDR"
 const DefaultListenAddr = "localhost:0"
 const DefaultComponentName = "App"
 
-type SSEvent struct {
+type ssEvent struct {
 	Event string
 	Data  []byte
 }
 
-type Client struct {
+type clientImpl struct {
 	Lock               *sync.Mutex
 	Root               *comp.RootElem
 	RootElem           *vdom.VDomElem
@@ -42,19 +42,19 @@ type Client struct {
 	IsDone             bool
 	DoneReason         string
 	DoneCh             chan struct{}
-	SSEventCh          chan SSEvent
-	GlobalEventHandler func(client *Client, event vdom.VDomEvent)
+	SSEventCh          chan ssEvent
+	GlobalEventHandler func(event vdom.VDomEvent)
 	GlobalStylesOption *FileHandlerOption
 	UrlHandlerMux      *http.ServeMux
 	SetupFn            func()
 }
 
-func MakeClient() *Client {
-	client := &Client{
+func makeClient() *clientImpl {
+	client := &clientImpl{
 		Lock:          &sync.Mutex{},
 		Root:          comp.MakeRoot(),
 		DoneCh:        make(chan struct{}),
-		SSEventCh:     make(chan SSEvent, 100),
+		SSEventCh:     make(chan ssEvent, 100),
 		UrlHandlerMux: http.NewServeMux(),
 		ServerId:      uuid.New().String(),
 		RootElem:      vdom.H(DefaultComponentName, nil),
@@ -62,13 +62,13 @@ func MakeClient() *Client {
 	return client
 }
 
-func (c *Client) GetIsDone() bool {
+func (c *clientImpl) GetIsDone() bool {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
 	return c.IsDone
 }
 
-func (c *Client) checkClientId(clientId string) error {
+func (c *clientImpl) checkClientId(clientId string) error {
 	if clientId == "" {
 		return fmt.Errorf("client id cannot be empty")
 	}
@@ -81,13 +81,13 @@ func (c *Client) checkClientId(clientId string) error {
 	return fmt.Errorf("client id mismatch: expected %s, got %s", c.CurrentClientId, clientId)
 }
 
-func (c *Client) clientTakeover(clientId string) {
+func (c *clientImpl) clientTakeover(clientId string) {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
 	c.CurrentClientId = clientId
 }
 
-func (c *Client) doShutdown(reason string) {
+func (c *clientImpl) doShutdown(reason string) {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
 	if c.IsDone {
@@ -98,7 +98,7 @@ func (c *Client) doShutdown(reason string) {
 	close(c.DoneCh)
 }
 
-func (c *Client) SetGlobalEventHandler(handler func(client *Client, event vdom.VDomEvent)) {
+func (c *clientImpl) SetGlobalEventHandler(handler func(event vdom.VDomEvent)) {
 	c.GlobalEventHandler = handler
 }
 
@@ -114,7 +114,7 @@ func getFaviconPath() string {
 	return "/wave-logo-256.png"
 }
 
-func (c *Client) makeBackendOpts() *rpctypes.VDomBackendOpts {
+func (c *clientImpl) makeBackendOpts() *rpctypes.VDomBackendOpts {
 	return &rpctypes.VDomBackendOpts{
 		Title:                c.Root.AppTitle,
 		GlobalKeyboardEvents: c.GlobalEventHandler != nil,
@@ -122,7 +122,7 @@ func (c *Client) makeBackendOpts() *rpctypes.VDomBackendOpts {
 	}
 }
 
-func (c *Client) runMainE() error {
+func (c *clientImpl) runMainE() error {
 	if c.SetupFn != nil {
 		c.SetupFn()
 	}
@@ -134,11 +134,11 @@ func (c *Client) runMainE() error {
 	return nil
 }
 
-func (c *Client) AddSetupFn(fn func()) {
+func (c *clientImpl) AddSetupFn(fn func()) {
 	c.SetupFn = fn
 }
 
-func (c *Client) RunMain() {
+func (c *clientImpl) RunMain() {
 	err := c.runMainE()
 	if err != nil {
 		fmt.Println(err)
@@ -146,16 +146,20 @@ func (c *Client) RunMain() {
 	}
 }
 
-func (c *Client) listenAndServe(ctx context.Context) error {
+func (c *clientImpl) listenAndServe(ctx context.Context) error {
 	// Create HTTP handlers
-	handlers := NewHTTPHandlers(c)
+	handlers := newHTTPHandlers(c)
 
 	// Create a new ServeMux and register handlers
 	mux := http.NewServeMux()
-	handlers.RegisterHandlers(mux, HandlerOpts{
+	var manifestOption *FileHandlerOption
+	if len(manifestFileBytes) > 0 {
+		manifestOption = &FileHandlerOption{Data: manifestFileBytes}
+	}
+	handlers.registerHandlers(mux, handlerOpts{
 		AssetsFS:     assetsFS,
 		StaticFS:     staticFS,
-		ManifestFile: manifestFile,
+		ManifestFile: manifestOption,
 	})
 
 	// Determine listen address from environment variable or use default
@@ -199,30 +203,30 @@ func (c *Client) listenAndServe(ctx context.Context) error {
 	return nil
 }
 
-func (c *Client) SendAsyncInitiation() error {
+func (c *clientImpl) SendAsyncInitiation() error {
 	if c.GetIsDone() {
 		return fmt.Errorf("client is done")
 	}
 
 	select {
-	case c.SSEventCh <- SSEvent{Event: "asyncinitiation", Data: nil}:
+	case c.SSEventCh <- ssEvent{Event: "asyncinitiation", Data: nil}:
 		return nil
 	default:
 		return fmt.Errorf("SSEvent channel is full")
 	}
 }
 
-func (c *Client) SetAtomVals(m map[string]any) {
+func (c *clientImpl) SetAtomVals(m map[string]any) {
 	for k, v := range m {
 		c.Root.SetAtomVal(k, v, true)
 	}
 }
 
-func (c *Client) SetAtomVal(name string, val any) {
+func (c *clientImpl) SetAtomVal(name string, val any) {
 	c.Root.SetAtomVal(name, val, true)
 }
 
-func (c *Client) GetAtomVal(name string) any {
+func (c *clientImpl) GetAtomVal(name string) any {
 	return c.Root.GetAtomVal(name)
 }
 
@@ -238,7 +242,7 @@ func structToProps(props any) map[string]any {
 	return m
 }
 
-func DefineComponentEx[P any](client *Client, name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
+func defineComponentEx[P any](client *clientImpl, name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
 	if name == "" {
 		panic("Component name cannot be empty")
 	}
@@ -254,11 +258,11 @@ func DefineComponentEx[P any](client *Client, name string, renderFn func(ctx con
 	}
 }
 
-func (c *Client) registerComponent(name string, cfunc any) error {
+func (c *clientImpl) registerComponent(name string, cfunc any) error {
 	return c.Root.RegisterComponent(name, cfunc)
 }
 
-func (c *Client) fullRender() (*rpctypes.VDomBackendUpdate, error) {
+func (c *clientImpl) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 	opts := &comp.RenderOpts{Resync: true}
 	c.Root.RunWork(opts)
 	c.Root.Render(c.RootElem, opts)
@@ -280,7 +284,7 @@ func (c *Client) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 	}, nil
 }
 
-func (c *Client) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
+func (c *clientImpl) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 	opts := &comp.RenderOpts{Resync: false}
 	c.Root.RunWork(opts)
 	renderedVDom := c.Root.MakeVDom()
@@ -300,7 +304,7 @@ func (c *Client) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 	}, nil
 }
 
-func (c *Client) RegisterUrlPathHandler(path string, handler http.Handler) {
+func (c *clientImpl) RegisterUrlPathHandler(path string, handler http.Handler) {
 	c.UrlHandlerMux.Handle(path, handler)
 }
 
@@ -366,8 +370,8 @@ func determineMimeType(option FileHandlerOption) (string, []byte) {
 	return "application/octet-stream", nil
 }
 
-// ServeFileOption handles serving content based on the provided FileHandlerOption
-func ServeFileOption(w http.ResponseWriter, r *http.Request, option FileHandlerOption) error {
+// serveFileOption handles serving content based on the provided FileHandlerOption
+func serveFileOption(w http.ResponseWriter, r *http.Request, option FileHandlerOption) error {
 	// Determine MIME type and get buffered data if needed
 	contentType, bufferedData := determineMimeType(option)
 	w.Header().Set("Content-Type", contentType)
@@ -431,7 +435,7 @@ func ServeFileOption(w http.ResponseWriter, r *http.Request, option FileHandlerO
 	return nil
 }
 
-func (c *Client) RegisterFilePrefixHandler(prefix string, optionProvider func(path string) (*FileHandlerOption, error)) {
+func (c *clientImpl) RegisterFilePrefixHandler(prefix string, optionProvider func(path string) (*FileHandlerOption, error)) {
 	c.UrlHandlerMux.HandleFunc(prefix, func(w http.ResponseWriter, r *http.Request) {
 		if !strings.HasPrefix(r.URL.Path, prefix) {
 			http.NotFound(w, r)
@@ -446,15 +450,15 @@ func (c *Client) RegisterFilePrefixHandler(prefix string, optionProvider func(pa
 			http.Error(w, "no content available", http.StatusNotFound)
 			return
 		}
-		if err := ServeFileOption(w, r, *option); err != nil {
+		if err := serveFileOption(w, r, *option); err != nil {
 			http.Error(w, fmt.Sprintf("Failed to serve content: %v", err), http.StatusInternalServerError)
 		}
 	})
 }
 
-func (c *Client) RegisterFileHandler(path string, option FileHandlerOption) {
+func (c *clientImpl) RegisterFileHandler(path string, option FileHandlerOption) {
 	c.UrlHandlerMux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
-		if err := ServeFileOption(w, r, option); err != nil {
+		if err := serveFileOption(w, r, option); err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 		}
 	})
diff --git a/tsunami/templates/app-main.go.tmpl b/tsunami/templates/app-main.go.tmpl
index 5111095cbd..f4a85c0f6c 100644
--- a/tsunami/templates/app-main.go.tmpl
+++ b/tsunami/templates/app-main.go.tmpl
@@ -15,8 +15,7 @@ var staticFS embed.FS
 
 func main() {
 	subDistFS, _ := fs.Sub(distFS, "dist")
-	app.RegisterAssetsFS(subDistFS)
 	subStaticFS, _ := fs.Sub(staticFS, "static")
-	app.RegisterStaticFS(subStaticFS)
+	app.RegisterEmbeds(subDistFS, subStaticFS, nil)
 	app.RunMain()
 }

From 964ccece240ab2b3af469e4b4b6ae144c0238e06 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 4 Sep 2025 15:18:21 -0700
Subject: [PATCH 057/134] greatly simplify + document dynamic content handling

---
 tsunami/app/defaultclient.go  |  26 ++---
 tsunami/app/serverhandlers.go |   9 +-
 tsunami/app/tsunamiapp.go     | 173 ++--------------------------------
 tsunami/prompts/system.md     |  92 +++++++++++-------
 4 files changed, 86 insertions(+), 214 deletions(-)

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 16d41ed170..f18a030be5 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -26,10 +26,17 @@ func SetGlobalEventHandler(handler func(event vdom.VDomEvent)) {
 	defaultClient.SetGlobalEventHandler(handler)
 }
 
-func AddSetupFn(fn func()) {
-	defaultClient.AddSetupFn(fn)
+// RegisterSetupFn registers a single setup function that is called before the app starts running.
+// Only one setup function is allowed, so calling this will replace any previously registered
+// setup function.
+func RegisterSetupFn(fn func()) {
+	defaultClient.RegisterSetupFn(fn)
 }
 
+// SendAsyncInitiation notifies the frontend that the backend has updated state
+// and requires a re-render. Normally the frontend calls the backend in response
+// to events, but when the backend changes state independently (e.g., from a
+// background process), this function gives the frontend a "nudge" to update.
 func SendAsyncInitiation() error {
 	return defaultClient.SendAsyncInitiation()
 }
@@ -46,16 +53,11 @@ func GetAtomVal(name string) any {
 	return defaultClient.GetAtomVal(name)
 }
 
-func RegisterUrlPathHandler(path string, handler http.Handler) {
-	defaultClient.RegisterUrlPathHandler(path, handler)
-}
-
-func RegisterFilePrefixHandler(prefix string, optionProvider func(path string) (*FileHandlerOption, error)) {
-	defaultClient.RegisterFilePrefixHandler(prefix, optionProvider)
-}
-
-func RegisterFileHandler(path string, option FileHandlerOption) {
-	defaultClient.RegisterFileHandler(path, option)
+// HandleDynFunc registers a dynamic HTTP handler function with the internal http.ServeMux.
+// The pattern MUST start with "/dyn/" to be valid. This allows registration of dynamic
+// routes that can be handled at runtime.
+func HandleDynFunc(pattern string, fn func(http.ResponseWriter, *http.Request)) {
+	defaultClient.HandleDynFunc(pattern, fn)
 }
 
 // RunMain is used internally by generated code and should not be called directly.
diff --git a/tsunami/app/serverhandlers.go b/tsunami/app/serverhandlers.go
index c6288ab6ae..00c3379b63 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/app/serverhandlers.go
@@ -29,7 +29,7 @@ func init() {
 type handlerOpts struct {
 	AssetsFS     fs.FS
 	StaticFS     fs.FS
-	ManifestFile *FileHandlerOption
+	ManifestFile []byte
 }
 
 type httpHandlers struct {
@@ -377,7 +377,7 @@ func (h *httpHandlers) handleStaticFiles(embeddedFS fs.FS) http.HandlerFunc {
 	}
 }
 
-func (h *httpHandlers) handleManifest(manifestFile *FileHandlerOption) http.HandlerFunc {
+func (h *httpHandlers) handleManifest(manifestFileBytes []byte) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		defer func() {
 			panicErr := util.PanicHandler("handleManifest", recover())
@@ -391,12 +391,13 @@ func (h *httpHandlers) handleManifest(manifestFile *FileHandlerOption) http.Hand
 			return
 		}
 
-		if manifestFile == nil {
+		if manifestFileBytes == nil {
 			http.NotFound(w, r)
 			return
 		}
 
-		serveFileOption(w, r, *manifestFile)
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(manifestFileBytes)
 	}
 }
 
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 53c7c3af62..b32a7cb4a6 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -6,8 +6,6 @@ package app
 import (
 	"context"
 	"fmt"
-	"io"
-	"io/fs"
 	"log"
 	"net"
 	"net/http"
@@ -44,7 +42,6 @@ type clientImpl struct {
 	DoneCh             chan struct{}
 	SSEventCh          chan ssEvent
 	GlobalEventHandler func(event vdom.VDomEvent)
-	GlobalStylesOption *FileHandlerOption
 	UrlHandlerMux      *http.ServeMux
 	SetupFn            func()
 }
@@ -134,7 +131,7 @@ func (c *clientImpl) runMainE() error {
 	return nil
 }
 
-func (c *clientImpl) AddSetupFn(fn func()) {
+func (c *clientImpl) RegisterSetupFn(fn func()) {
 	c.SetupFn = fn
 }
 
@@ -152,14 +149,10 @@ func (c *clientImpl) listenAndServe(ctx context.Context) error {
 
 	// Create a new ServeMux and register handlers
 	mux := http.NewServeMux()
-	var manifestOption *FileHandlerOption
-	if len(manifestFileBytes) > 0 {
-		manifestOption = &FileHandlerOption{Data: manifestFileBytes}
-	}
 	handlers.registerHandlers(mux, handlerOpts{
 		AssetsFS:     assetsFS,
 		StaticFS:     staticFS,
-		ManifestFile: manifestOption,
+		ManifestFile: manifestFileBytes,
 	})
 
 	// Determine listen address from environment variable or use default
@@ -304,162 +297,10 @@ func (c *clientImpl) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 	}, nil
 }
 
-func (c *clientImpl) RegisterUrlPathHandler(path string, handler http.Handler) {
-	c.UrlHandlerMux.Handle(path, handler)
-}
-
-type FileHandlerOption struct {
-	FilePath string    // optional file path on disk
-	Data     []byte    // optional byte slice content
-	Reader   io.Reader // optional reader for content
-	File     fs.File   // optional embedded or opened file
-	MimeType string    // optional mime type
-	ETag     string    // optional ETag (if set, resource may be cached)
-}
-
-func determineMimeType(option FileHandlerOption) (string, []byte) {
-	// If MimeType is set, use it directly
-	if option.MimeType != "" {
-		return option.MimeType, nil
-	}
-
-	// Detect from Data if available, no need to buffer
-	if option.Data != nil {
-		return http.DetectContentType(option.Data), nil
-	}
-
-	// Detect from FilePath, no buffering necessary
-	if option.FilePath != "" {
-		filePath := util.ExpandHomeDirSafe(option.FilePath)
-		file, err := os.Open(filePath)
-		if err != nil {
-			return "application/octet-stream", nil // Fallback on error
-		}
-		defer file.Close()
-
-		// Read first 512 bytes for MIME detection
-		buf := make([]byte, 512)
-		_, err = file.Read(buf)
-		if err != nil && err != io.EOF {
-			return "application/octet-stream", nil
-		}
-		return http.DetectContentType(buf), nil
-	}
-
-	// Buffer for File (fs.File), since it lacks Seek
-	if option.File != nil {
-		buf := make([]byte, 512)
-		n, err := option.File.Read(buf)
-		if err != nil && err != io.EOF {
-			return "application/octet-stream", nil
-		}
-		return http.DetectContentType(buf[:n]), buf[:n]
-	}
-
-	// Buffer for Reader (io.Reader), same as File
-	if option.Reader != nil {
-		buf := make([]byte, 512)
-		n, err := option.Reader.Read(buf)
-		if err != nil && err != io.EOF {
-			return "application/octet-stream", nil
-		}
-		return http.DetectContentType(buf[:n]), buf[:n]
-	}
-
-	// Default MIME type if none specified
-	return "application/octet-stream", nil
-}
-
-// serveFileOption handles serving content based on the provided FileHandlerOption
-func serveFileOption(w http.ResponseWriter, r *http.Request, option FileHandlerOption) error {
-	// Determine MIME type and get buffered data if needed
-	contentType, bufferedData := determineMimeType(option)
-	w.Header().Set("Content-Type", contentType)
-	// Handle ETag
-	if option.ETag != "" {
-		w.Header().Set("ETag", option.ETag)
-
-		// Check If-None-Match header
-		if inm := r.Header.Get("If-None-Match"); inm != "" {
-			// Strip W/ prefix and quotes if present
-			inm = strings.Trim(inm, `"`)
-			inm = strings.TrimPrefix(inm, "W/")
-			etag := strings.Trim(option.ETag, `"`)
-			etag = strings.TrimPrefix(etag, "W/")
-
-			if inm == etag {
-				// Resource not modified
-				w.WriteHeader(http.StatusNotModified)
-				return nil
-			}
-		}
-	}
-
-	// Handle the content based on the option type
-	switch {
-	case option.FilePath != "":
-		filePath := util.ExpandHomeDirSafe(option.FilePath)
-		http.ServeFile(w, r, filePath)
-
-	case option.Data != nil:
-		w.Header().Set("Content-Length", fmt.Sprintf("%d", len(option.Data)))
-		w.WriteHeader(http.StatusOK)
-		if _, err := w.Write(option.Data); err != nil {
-			return fmt.Errorf("failed to write data: %v", err)
-		}
-
-	case option.File != nil:
-		if bufferedData != nil {
-			if _, err := w.Write(bufferedData); err != nil {
-				return fmt.Errorf("failed to write buffered data: %v", err)
-			}
-		}
-		if _, err := io.Copy(w, option.File); err != nil {
-			return fmt.Errorf("failed to copy from file: %v", err)
-		}
-
-	case option.Reader != nil:
-		if bufferedData != nil {
-			if _, err := w.Write(bufferedData); err != nil {
-				return fmt.Errorf("failed to write buffered data: %v", err)
-			}
-		}
-		if _, err := io.Copy(w, option.Reader); err != nil {
-			return fmt.Errorf("failed to copy from reader: %v", err)
-		}
-
-	default:
-		return fmt.Errorf("no content available")
+func (c *clientImpl) HandleDynFunc(pattern string, fn func(http.ResponseWriter, *http.Request)) {
+	if !strings.HasPrefix(pattern, "/dyn/") {
+		log.Printf("invalid dyn pattern: %s (must start with /dyn/)", pattern)
+		return
 	}
-
-	return nil
-}
-
-func (c *clientImpl) RegisterFilePrefixHandler(prefix string, optionProvider func(path string) (*FileHandlerOption, error)) {
-	c.UrlHandlerMux.HandleFunc(prefix, func(w http.ResponseWriter, r *http.Request) {
-		if !strings.HasPrefix(r.URL.Path, prefix) {
-			http.NotFound(w, r)
-			return
-		}
-		option, err := optionProvider(r.URL.Path)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		if option == nil {
-			http.Error(w, "no content available", http.StatusNotFound)
-			return
-		}
-		if err := serveFileOption(w, r, *option); err != nil {
-			http.Error(w, fmt.Sprintf("Failed to serve content: %v", err), http.StatusInternalServerError)
-		}
-	})
-}
-
-func (c *clientImpl) RegisterFileHandler(path string, option FileHandlerOption) {
-	c.UrlHandlerMux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
-		if err := serveFileOption(w, r, option); err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-		}
-	})
+	c.UrlHandlerMux.HandleFunc(pattern, fn)
 }
diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index bee9b25bdd..84792c7204 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -744,51 +744,79 @@ Global keyboard events are automatically enabled when you set a global event han
 
 ## File Handling
 
-The Tsunami framework can serve files to components. Any URL starting with `vdom://` will be handled by the registered handlers:
+The Tsunami framework provides two simple approaches for serving content:
 
-```go
-// Register handlers for files (in the main func)
-app.RegisterFileHandler("/logo.png", app.FileHandlerOption{
-    FilePath: "./assets/logo.png",
-})
+### Static Files
 
-// returning nil will produce a 404, path will be the full path, including the prefix
-app.RegisterFilePrefixHandler("/img/", func(path string) (*app.FileHandlerOption, error) {
-    return &app.FileHandlerOption{Data: data, MimeType: "image/png"}
-})
+For static assets (images, CSS, fonts, etc.), simply create a `static/` directory in your application directory. All files in this directory are automatically served under the `/static/` URL path:
+
+```
+your-app/
+├── app.go
+└── static/
+    ├── logo.png
+    ├── styles.css
+    └── images/
+        └── icon.svg
+```
+
+Use these files in your components with `/static/` URLs:
 
-// Use in components with vdom:// prefix
+```go
 vdom.H("img", map[string]any{
-    "src": "vdom:///logo.png",  // Note the vdom:// prefix
+    "src": "/static/logo.png",
     "alt": "Logo",
+})
+
+vdom.H("div", map[string]any{
     "style": map[string]any{
-        "background": "url(vdom:///logo.png)", // vdom urls can be used in CSS as well
+        "background": "url(/static/images/icon.svg)",
     },
 })
 ```
 
-Files can come from:
+### Dynamic URL Handlers
 
-- Disk (FilePath)
-- Memory (Data + MimeType)
-- Stream (Reader)
+For dynamic content or API endpoints, use app.HandleDynFunc to register standard http.ServeMux handlers. All dynamic routes MUST be registered under the `/dyn/` path:
 
-```
-type FileHandlerOption struct {
-	FilePath string    // optional file path on disk
-	Data     []byte    // optional byte slice content (easy to use with go:embed)
-	Reader   io.Reader // optional reader for content
-	File     fs.File   // optional embedded or opened file
-	MimeType string    // optional mime type
-	ETag     string    // optional ETag (if set, resource may be cached)
-}
+```go
+// Register dynamic handlers (typically in init() or setup function)
+app.HandleDynFunc("/dyn/api/data", func(w http.ResponseWriter, r *http.Request) {
+    w.Header().Set("Content-Type", "application/json")
+    json.NewEncoder(w).Encode(map[string]any{"status": "ok"})
+})
+
+app.HandleDynFunc("/dyn/generate-image", func(w http.ResponseWriter, r *http.Request) {
+    // Generate dynamic content
+    img := generateImage()
+    w.Header().Set("Content-Type", "image/png")
+    png.Encode(w, img)
+})
+
+// Use standard http.ServeMux patterns
+app.HandleDynFunc("/dyn/files/{id}", func(w http.ResponseWriter, r *http.Request) {
+    id := r.PathValue("id")
+    // Handle file by ID
+})
 ```
 
-Any URL passed to src attributes that starts with vdom:// will be handled by the registered handlers. All registered paths should be absolute (start with "/").
+Use dynamic endpoints in your components:
 
-Note that the system will attempt to detect the file type using the first 512 bytes of content. This works great for images, videos, and binary files. For text files which might be ambiguous (CSS, JSON, YAML, TOML, JavaScript, Go Code, Java, other programming languages) it can make sense to specify the mimetype (but usually only required if the frontend needs it for some reason).
+```go
+vdom.H("img", map[string]any{
+    "src": "/dyn/generate-image?type=chart&data=123",
+    "alt": "Dynamic Chart",
+})
+```
+
+Key points:
 
-By default, files will not be cached. If you'd like to enable caching, pass an ETag. If a subsequent request comes and the ETag matches the system will used the cached content.
+- **Static files**: Create `static/` directory, use `/static/` URLs
+- **Dynamic content**: Use app.HandleDynFunc with `/dyn/` prefix
+- Dynamic handlers use standard Go http.Handler interface
+- You can use any http.ServeMux pattern in the route
+- Content-Type is automatically detected for static files
+- For dynamic handlers, set Content-Type explicitly when needed
 
 ## Tsunami App Template
 
@@ -933,7 +961,7 @@ Key points:
 1. Root component must be named "App"
 2. Use vdom.UseSetAppTitle in the main App component to set the window title
 3. Do NOT write a main() function - the framework handles app lifecycle
-4. File handlers can be registered in init() if needed
+4. Use init() for setup like registering dynamic handlers with app.HandleDynFunc
 
 ## Important Technical Details
 
@@ -944,10 +972,10 @@ Key points:
 - Provide keys when using vdom.ForEach with lists (using WithKey method)
 - Use vdom.Classes with vdom.If for combining static and conditional class names
 - Consider cleanup functions in vdom.UseEffect for async operations
-- <script> tags are NOT supported
+- `<script>` tags are NOT supported
 - Applications consist of a single file: app.go containing all Go code and component definitions
 - Styling is handled through Tailwind v4 CSS classes
-- No main() function is needed - use init() for configuration
+- Do NOT write a main() function - use init() for setup like dynamic handlers
 - This is a pure Go system - do not attempt to write React components or JavaScript code
 - All UI rendering, including complex visualizations, should be done through Go using vdom.H
 

From 3f01b49c67ace976ee5c0c6b94a5afbfef90c4bb Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 4 Sep 2025 16:05:54 -0700
Subject: [PATCH 058/134] update app API for 3 different atom types

---
 tsunami/app/defaultclient.go                | 28 ++++++--
 tsunami/prompts/global-keyboard-handling.md | 72 ++++++++++++++++++++
 tsunami/prompts/system.md                   | 75 +--------------------
 tsunami/util/util.go                        | 20 ++++++
 tsunami/vdom/vdom.go                        | 23 +------
 5 files changed, 119 insertions(+), 99 deletions(-)
 create mode 100644 tsunami/prompts/global-keyboard-handling.md

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index f18a030be5..c71be7ccec 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -8,6 +8,7 @@ import (
 	"io/fs"
 	"net/http"
 
+	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
@@ -41,16 +42,31 @@ func SendAsyncInitiation() error {
 	return defaultClient.SendAsyncInitiation()
 }
 
-func SetAtomVals(m map[string]any) {
-	defaultClient.SetAtomVals(m)
+func GetSharedAtom[T any](name string) T {
+	rawVal := defaultClient.GetAtomVal("$shared." + name)
+	return util.GetTypedAtomValue[T](rawVal, "$shared."+name)
 }
 
-func SetAtomVal(name string, val any) {
-	defaultClient.SetAtomVal(name, val)
+func SetSharedAtom[T any](name string, val T) {
+	defaultClient.SetAtomVal("$shared."+name, val)
 }
 
-func GetAtomVal(name string) any {
-	return defaultClient.GetAtomVal(name)
+func GetConfig[T any](name string) T {
+	rawVal := defaultClient.GetAtomVal("$config." + name)
+	return util.GetTypedAtomValue[T](rawVal, "$config."+name)
+}
+
+func SetConfig[T any](name string, val T) {
+	defaultClient.SetAtomVal("$config."+name, val)
+}
+
+func GetData[T any](name string) T {
+	rawVal := defaultClient.GetAtomVal("$data." + name)
+	return util.GetTypedAtomValue[T](rawVal, "$data."+name)
+}
+
+func SetData[T any](name string, val T) {
+	defaultClient.SetAtomVal("$data."+name, val)
 }
 
 // HandleDynFunc registers a dynamic HTTP handler function with the internal http.ServeMux.
diff --git a/tsunami/prompts/global-keyboard-handling.md b/tsunami/prompts/global-keyboard-handling.md
new file mode 100644
index 0000000000..76d501e160
--- /dev/null
+++ b/tsunami/prompts/global-keyboard-handling.md
@@ -0,0 +1,72 @@
+# Global Keyboard Handling
+
+The Tsunami framework provides two approaches for handling keyboard events:
+
+1. Standard DOM event handling on elements:
+
+```go
+vdom.H("div", map[string]any{
+    "onKeyDown": func(e vdom.VDomEvent) {
+        // Handle key event
+    },
+})
+```
+
+2. Global keyboard event handling:
+
+```go
+// Global keyboard events are automatically enabled when you set a global event handler
+func init() {
+    app.SetGlobalEventHandler(func(event vdom.VDomEvent) {
+    if event.EventType != "onKeyDown" || event.KeyData == nil {
+        return
+    }
+
+    switch event.KeyData.Key {
+    case "ArrowUp":
+        // Handle up arrow
+    case "ArrowDown":
+        // Handle down arrow
+    }
+})
+```
+
+The global handler approach is particularly useful when:
+
+- You need to handle keyboard events regardless of focus state
+- Building terminal-like applications that need consistent keyboard control
+- Implementing application-wide keyboard shortcuts
+- Managing navigation in full-screen applications
+
+Key differences:
+
+- Standard DOM events require the element to have focus
+- Global events work regardless of focus state
+- Global events can be used alongside regular DOM event handlers
+- Global handler receives all keyboard events for the application
+
+The event handler receives a VDomEvent with KeyData for keyboard events:
+
+```go
+type VDomEvent struct {
+    EventType       string             // e.g., "onKeyDown"
+    KeyData         *WaveKeyboardEvent `json:"keydata,omitempty"`
+    // ... other fields
+}
+
+type WaveKeyboardEvent struct {
+    Type     string // "keydown", "keyup", "keypress"
+    Key      string // The key value (e.g., "ArrowUp")
+    Code     string // Physical key code
+    Shift    bool   // Modifier states
+    Control  bool
+    Alt      bool
+    Meta     bool
+    Cmd      bool   // Meta on Mac, Alt on Windows/Linux
+    Option   bool   // Alt on Mac, Meta on Windows/Linux
+}
+```
+
+When using global keyboard events:
+
+Global keyboard events are automatically enabled when you set a global event handler. Set up the handler in a place where you have access to necessary state updates.
\ No newline at end of file
diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 84792c7204..d3822ece6f 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -69,7 +69,7 @@ var App = app.DefineComponent("App",
 
 Key Points:
 
-- Must use package main.
+- Must use `package main`.
 - The `App` component is required. It serves as the entry point to your application.
 - Do NOT add a `main()` function, that is provided by the framework when building.
 - Uses Tailwind v4 for styling - you can use any Tailwind classes in your components.
@@ -98,7 +98,7 @@ vdom.H("div", map[string]any{
 vdom.H("div", map[string]any{
     "style": map[string]any{
         "marginTop": 10,      // Numbers automatically convert to px (like React)
-        "zIndex": 1000,
+        "zIndex": 1000,       // use React style names
         "transform": "rotate(45deg)",
     },
 })
@@ -671,76 +671,7 @@ Key points for state management:
 
 ## Global Keyboard Handling
 
-The Tsunami framework provides two approaches for handling keyboard events:
-
-1. Standard DOM event handling on elements:
-
-```go
-vdom.H("div", map[string]any{
-    "onKeyDown": func(e vdom.VDomEvent) {
-        // Handle key event
-    },
-})
-```
-
-2. Global keyboard event handling:
-
-```go
-// Global keyboard events are automatically enabled when you set a global event handler
-func init() {
-    app.SetGlobalEventHandler(func(event vdom.VDomEvent) {
-    if event.EventType != "onKeyDown" || event.KeyData == nil {
-        return
-    }
-
-    switch event.KeyData.Key {
-    case "ArrowUp":
-        // Handle up arrow
-    case "ArrowDown":
-        // Handle down arrow
-    }
-})
-```
-
-The global handler approach is particularly useful when:
-
-- You need to handle keyboard events regardless of focus state
-- Building terminal-like applications that need consistent keyboard control
-- Implementing application-wide keyboard shortcuts
-- Managing navigation in full-screen applications
-
-Key differences:
-
-- Standard DOM events require the element to have focus
-- Global events work regardless of focus state
-- Global events can be used alongside regular DOM event handlers
-- Global handler receives all keyboard events for the application
-
-The event handler receives a VDomEvent with KeyData for keyboard events:
-
-```go
-type VDomEvent struct {
-    EventType       string             // e.g., "onKeyDown"
-    KeyData         *WaveKeyboardEvent `json:"keydata,omitempty"`
-    // ... other fields
-}
-
-type WaveKeyboardEvent struct {
-    Type     string // "keydown", "keyup", "keypress"
-    Key      string // The key value (e.g., "ArrowUp")
-    Code     string // Physical key code
-    Shift    bool   // Modifier states
-    Control  bool
-    Alt      bool
-    Meta     bool
-    Cmd      bool   // Meta on Mac, Alt on Windows/Linux
-    Option   bool   // Alt on Mac, Meta on Windows/Linux
-}
-```
-
-When using global keyboard events:
-
-Global keyboard events are automatically enabled when you set a global event handler. Set up the handler in a place where you have access to necessary state updates.
+For some applications, getting access to each key press regardless of focus state is essential. To enable global keyboard handling that captures all keyboard events across your application, see the global-keyboard-handling.md document.
 
 ## File Handling
 
diff --git a/tsunami/util/util.go b/tsunami/util/util.go
index 117ba7adab..69d4b5c1bd 100644
--- a/tsunami/util/util.go
+++ b/tsunami/util/util.go
@@ -90,3 +90,23 @@ func OpenBrowser(url string, delay time.Duration) {
 
 	exec.Command(cmd, args...).Start()
 }
+
+func GetTypedAtomValue[T any](rawVal any, atomName string) T {
+	var result T
+	if rawVal == nil {
+		return *new(T)
+	}
+
+	var ok bool
+	result, ok = rawVal.(T)
+	if !ok {
+		// Try converting from float64 if rawVal is float64
+		if f64Val, isFloat64 := rawVal.(float64); isFloat64 {
+			if converted, convOk := FromFloat64[T](f64Val); convOk {
+				return converted
+			}
+		}
+		panic(fmt.Sprintf("GetTypedAtomValue %q value type mismatch (expected %T, got %T)", atomName, *new(T), rawVal))
+	}
+	return result
+}
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index 33e7947c08..aee265e966 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -182,25 +182,6 @@ func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T
 	return rtnVal, typedSetVal, typedSetFuncVal
 }
 
-func getTypedAtomValue[T any](rawVal any, atomName string) T {
-	var result T
-	if rawVal == nil {
-		return *new(T)
-	}
-
-	var ok bool
-	result, ok = rawVal.(T)
-	if !ok {
-		// Try converting from float64 if rawVal is float64
-		if f64Val, isFloat64 := rawVal.(float64); isFloat64 {
-			if converted, convOk := util.FromFloat64[T](f64Val); convOk {
-				return converted
-			}
-		}
-		panic(fmt.Sprintf("UseAtom %q value type mismatch (expected %T, got %T)", atomName, *new(T), rawVal))
-	}
-	return result
-}
 
 func useAtom[T any](ctx context.Context, hookName string, atomName string) (T, func(T), func(func(T) T)) {
 	rc := vdomctx.GetRenderContext(ctx)
@@ -210,7 +191,7 @@ func useAtom[T any](ctx context.Context, hookName string, atomName string) (T, f
 	val, setVal, setFn := rc.UseAtom(ctx, atomName)
 
 	// Adapt the "any" values to type "T"
-	atomVal := getTypedAtomValue[T](val, atomName)
+	atomVal := util.GetTypedAtomValue[T](val, atomName)
 
 	typedSetVal := func(newVal T) {
 		setVal(newVal)
@@ -218,7 +199,7 @@ func useAtom[T any](ctx context.Context, hookName string, atomName string) (T, f
 
 	typedSetFuncVal := func(updateFunc func(T) T) {
 		setFn(func(oldVal any) any {
-			typedOldVal := getTypedAtomValue[T](oldVal, atomName)
+			typedOldVal := util.GetTypedAtomValue[T](oldVal, atomName)
 			return updateFunc(typedOldVal)
 		})
 	}

From 04839235b554daa36bf0b1fd3822c5b53d427b23 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 4 Sep 2025 16:16:55 -0700
Subject: [PATCH 059/134] added global state management docs

---
 tsunami/prompts/system.md | 44 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index d3822ece6f..fab44c335b 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -280,6 +280,50 @@ Most applications won't need these specialty hooks, but they're available for ad
 
 This ensures hooks are called in the same order every render, which is essential for Tsunami's state management.
 
+## Global State Management
+
+Tsunami provides three types of global atoms for sharing state across components and with external systems:
+
+### Atom Types
+
+**UseSharedAtom** - Basic shared state between components:
+
+```go
+// Shared between components, not shared externally
+// Triggers re-renders when updated
+isLoading, setIsLoading, _ := vdom.UseSharedAtom[bool](ctx, "isLoading")
+```
+
+**UseConfig** - Configuration that external systems can read/write:
+
+```go
+// External tools can GET/POST to /api/config to read/modify these
+// Triggers re-renders when updated (internally or externally)
+theme, setTheme, _ := vdom.UseConfig[string](ctx, "theme")
+apiKey, _, _ := vdom.UseConfig[string](ctx, "apiKey")
+```
+
+**UseData** - Application data that external systems can read:
+
+```go
+// External tools can GET /api/data to inspect app state
+// Triggers re-renders when updated
+userStats, setUserStats, _ := vdom.UseData[UserStats](ctx, "currentUser")
+apiResult, setLastPoll, setLastPollFn := vdom.UseData[APIResult](ctx, "lastPoll")
+```
+
+All atom types work exactly like UseState - they return the current value, a setter function, and a functional setter. The key difference is their scope and external API accessibility.
+
+### External API Integration
+
+The UseConfig and UseData atoms automatically create REST endpoints:
+
+- `GET /api/config` - Returns all config atom values
+- `POST /api/config` - Updates (merges) config atom values
+- `GET /api/data` - Returns all data atom values
+
+This makes Tsunami applications naturally suitable for integration with external tools, monitoring systems, and AI agents that need to inspect or configure the application.
+
 ## Style Handling
 
 Tsunami applications use Tailwind v4 CSS by default for styling (className prop). You can also define inline styles using a map[string]any in the props:

From ee30814ed03cf78538258dbfc6c53e6707488569 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 4 Sep 2025 17:07:26 -0700
Subject: [PATCH 060/134] WithKey takes any.  fix tailwind stuff in system.md. 
 fix deps in UseEffect to match react

---
 tsunami/comp/hooks.go     |  8 +++++++
 tsunami/prompts/system.md | 46 ++++++++++++++++++++++++---------------
 tsunami/vdom/vdom.go      |  4 ++--
 3 files changed, 38 insertions(+), 20 deletions(-)

diff --git a/tsunami/comp/hooks.go b/tsunami/comp/hooks.go
index fe78818462..2b14362365 100644
--- a/tsunami/comp/hooks.go
+++ b/tsunami/comp/hooks.go
@@ -162,6 +162,14 @@ func (vc *VDomContextImpl) UseEffect(ctx context.Context, fn func() func(), deps
 		vc.Root.AddEffectWork(vc.getCompWaveId(), hookVal.Idx)
 		return
 	}
+	// If deps is nil, always run (like React with no dependency array)
+	if deps == nil {
+		hookVal.Fn = fn
+		hookVal.Deps = deps
+		vc.Root.AddEffectWork(vc.getCompWaveId(), hookVal.Idx)
+		return
+	}
+
 	if depsEqual(hookVal.Deps, deps) {
 		return
 	}
diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index fab44c335b..0d111fea90 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -208,7 +208,7 @@ vdom.H("ul", nil,
     vdom.ForEach(items, func(item string, idx int) any {
         return vdom.H("li", map[string]any{
             "key": idx,
-            "className": "list-item",
+            "className": "py-2 px-3 border-b border-gray-100",
         }, item)
     }),
 )
@@ -326,7 +326,7 @@ This makes Tsunami applications naturally suitable for integration with external
 
 ## Style Handling
 
-Tsunami applications use Tailwind v4 CSS by default for styling (className prop). You can also define inline styles using a map[string]any in the props:
+Tsunami applications use Tailwind v4 CSS by default for styling (className prop) and you should favor styling with Tailwind whenever possible. However, you may also define inline styles using a map[string]any in the props:
 
 ```go
 vdom.H("div", map[string]any{
@@ -359,6 +359,14 @@ Properties use camelCase (must match React) and values can be:
 
 The style map in props mirrors React's style object pattern, making it familiar to React developers while maintaining type safety in Go.
 
+### External Styles and Stylesheets
+
+Quick styles can be added using a vdom.H("style", nil, "...") tag. You may also place CSS files in the `static` directory, and serve them directly with:
+
+```go
+vdom.H("link", map[string]any{"rel": "stylesheet", "src": "/static/mystyles.css"})
+```
+
 ## Component Definition Pattern
 
 Create typed, reusable components using the client:
@@ -376,21 +384,17 @@ var TodoItem = app.DefineComponent("TodoItem",
     func(ctx context.Context, props TodoItemProps) any {
         return vdom.H("div", map[string]any{
             "className": vdom.Classes(
-                "todo-item",
-                vdom.If(props.IsActive, "active"),
+                "p-3 border-b border-gray-200 cursor-pointer transition-opacity",
+                vdom.If(props.IsActive, "opacity-100 bg-blue-50", "opacity-70 hover:bg-gray-50"),
             ),
             "onClick": props.OnToggle,
-            "style": map[string]any{
-                "cursor": "pointer",
-                "opacity": vdom.If(props.IsActive, 1.0, 0.7),
-            },
         }, props.Todo.Text)
     },
 )
 
 // Usage in parent component:
 vdom.H("div", map[string]any{
-    "className": "todo-list",
+    "className": "bg-white rounded-lg shadow-sm border",
 },
     TodoItem(TodoItemProps{
         Todo: todo,
@@ -403,7 +407,7 @@ vdom.H("div", map[string]any{
 TodoItem(TodoItemProps{
     Todo: todo,
     OnToggle: handleToggle,
-}).WithKey(fmt.Sprint(idx))
+}).WithKey(idx)
 ```
 
 Components in Tsunami:
@@ -417,10 +421,11 @@ Components in Tsunami:
 
 Special Handling for Component "key" prop:
 
-- Use the WithKey(key string) chaining func to set a key on a component
+- Use the `WithKey(key any)` chaining func to set a key on a component
 - Keys must be added for components rendered in lists (just like in React)
 - Keys should be unique among siblings and stable across renders
 - Keys are handled at the framework level and should not be declared in component props
+- `WithKey` accepts any type and automatically converts it to a string using fmt.Sprint
 
 This pattern matches React's functional components while maintaining Go's type safety and explicit props definition.
 
@@ -466,7 +471,7 @@ keyHandler := &vdom.VDomFunc{
 }
 
 vdom.H("input", map[string]any{
-    "className": "special-input",
+    "className": "px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500",
     "onKeyDown": keyHandler,
 })
 
@@ -555,8 +560,10 @@ func MyComponent(ctx context.Context, props MyProps) any {
             },
         }),
         vdom.H("ul", nil,
-            vdom.ForEach(items, func(item string, _ int) any {
-                return vdom.H("li", nil, item)
+            vdom.ForEach(items, func(item string, idx int) any {
+                return vdom.H("li", map[string]any{
+                    "key": idx,
+                }, item)
             }),
         ),
     )
@@ -584,7 +591,7 @@ The system provides three main types of hooks:
    })
    ```
 
-2. vdom.UseRef - For values that persist between renders without triggering updates:
+2. vdom.UseRef - For values that persist between renders without triggering updates (like React.useRef):
 
    - Holds mutable values that survive re-renders
    - Changes don't cause re-renders
@@ -593,6 +600,7 @@ The system provides three main types of hooks:
      - Storing timers/channels
      - Tracking subscriptions
      - Holding complex state structures
+   - Unlike React, this ref CANNOT be set as the ref prop on an element
 
    ```go
    timerRef := vdom.UseRef(ctx, &TimerState{
@@ -607,6 +615,7 @@ The system provides three main types of hooks:
      - Managing focus
      - Measuring elements
      - Direct DOM manipulation when needed
+   - These ref objects SHOULD be set as ref prop on elements.
    ```go
    inputRef := vdom.UseVDomRef(ctx)
    vdom.H("input", map[string]any{
@@ -696,8 +705,9 @@ var TodoApp = app.DefineComponent("TodoApp",
         }, []any{})
 
         return vdom.H("div", nil,
-            vdom.ForEach(globalTodos, func(todo Todo, _ int) any {
-                return TodoItem(TodoItemProps{Todo: todo})
+            vdom.ForEach(globalTodos, func(todo Todo, idx int) any {
+                // Use WithKey() for adding keys to components
+                return TodoItem(TodoItemProps{Todo: todo}).WithKey(idx)
             }),
         )
     },
@@ -923,7 +933,7 @@ var App = app.DefineComponent("App",
                     Todo:     todo,
                     OnToggle: func() { toggleTodo(todo.Id) },
                     OnDelete: func() { deleteTodo(todo.Id) },
-                }).WithKey(strconv.Itoa(todo.Id))
+                }).WithKey(todo.Id)
             })),
         )
     },
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index aee265e966..15b154cef9 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -30,14 +30,14 @@ func (e *VDomElem) Key() string {
 // WithKey sets the key property of the VDomElem and returns the element.
 // This is particularly useful for defined components since their prop types won't include keys.
 // Returns nil if the element is nil, otherwise returns the same element for chaining.
-func (e *VDomElem) WithKey(key string) *VDomElem {
+func (e *VDomElem) WithKey(key any) *VDomElem {
 	if e == nil {
 		return nil
 	}
 	if e.Props == nil {
 		e.Props = make(map[string]any)
 	}
-	e.Props[KeyPropKey] = key
+	e.Props[KeyPropKey] = fmt.Sprint(key)
 	return e
 }
 

From 6c6e504c8b263aeb80f40da6815b9e307c0d288c Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 4 Sep 2025 17:28:06 -0700
Subject: [PATCH 061/134] fix errors in example

---
 tsunami/prompts/system.md | 70 ++++++++++++++++++++++++++++++---------
 1 file changed, 55 insertions(+), 15 deletions(-)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 0d111fea90..3e09dfb0bc 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -633,12 +633,20 @@ Best Practices:
 
 ## State Management and Async Updates
 
-While React patterns typically avoid globals, in Go Tsunami applications it's perfectly fine and often clearer to use global variables. However, when dealing with async operations and goroutines, special care must be taken:
+For global state management, use the atoms system (SharedAtom, Config, or Data as appropriate). This provides global reactive state that components can subscribe to:
 
 ```go
-// Global state is fine!
-var globalTodos []Todo
-var globalFilter string
+// Use func init() to set atom defaults
+func init() {
+    app.SetData("todos", []Todo{})
+    app.SetConfig("filter", "")
+}
+
+type Todo struct {
+    Id   int    `json:"id"`
+    Text string `json:"text"`
+    Done bool   `json:"done"`
+}
 
 // For async operations, consider using a state struct
 type TimerState struct {
@@ -649,11 +657,12 @@ type TimerState struct {
 
 var TodoApp = app.DefineComponent("TodoApp",
     func(ctx context.Context, _ struct{}) any {
-        // Local state for UI updates
-        count, setCount := vdom.UseState(ctx, 0)
+        // Use atoms for global state (prefixes must match init functions)
+        todos, setTodos, _ := vdom.UseData[[]Todo](ctx, "todos")
+        filter, setFilter, _ := vdom.UseConfig[string](ctx, "filter")
 
-        // vdom.UseState returns value, setter, and functional setter
-        seconds, setSeconds, setSecondsFn := vdom.UseState(ctx, 0)
+        // Local state for async timer demo
+        seconds, _, setSecondsFn := vdom.UseState[int](ctx, 0)
 
         // Use refs to store complex state that goroutines need to access
         stateRef := vdom.UseRef(ctx, &TimerState{
@@ -699,15 +708,43 @@ var TodoApp = app.DefineComponent("TodoApp",
 
         // Use vdom.UseEffect for cleanup on unmount
         vdom.UseEffect(ctx, func() func() {
+            startAsync() // Start the timer when component mounts
             return func() {
                 stopAsync()
             }
         }, []any{})
 
-        return vdom.H("div", nil,
-            vdom.ForEach(globalTodos, func(todo Todo, idx int) any {
-                // Use WithKey() for adding keys to components
-                return TodoItem(TodoItemProps{Todo: todo}).WithKey(idx)
+        addTodo := func(text string) {
+            newTodo := Todo{
+                Id:   len(todos) + 1,
+                Text: text,
+                Done: false,
+            }
+            setTodos(append(todos, newTodo))
+        }
+
+        return vdom.H("div", map[string]any{"className": "todo-app"},
+            vdom.H("h1", nil, "Todo App"),
+            vdom.H("p", nil, "Timer: ", seconds, " seconds"),
+            vdom.H("input", map[string]any{
+                "placeholder": "Filter todos...",
+                "value":       filter,
+                "onChange":    func(e vdom.VDomEvent) { setFilter(e.TargetValue) },
+            }),
+            vdom.H("button", map[string]any{
+                "onClick": func() { addTodo("New todo") },
+            }, "Add Todo"),
+            vdom.ForEach(todos, func(todo Todo, idx int) any {
+                // Only show todos that contain the filter text
+                if filter != "" && !strings.Contains(strings.ToLower(todo.Text), strings.ToLower(filter)) {
+                    return nil
+                }
+                return vdom.H("div", map[string]any{
+                    "key":       todo.Id,
+                    "className": "todo-item",
+                },
+                    vdom.H("span", nil, todo.Text),
+                )
             }),
         )
     },
@@ -895,9 +932,12 @@ var App = app.DefineComponent("App",
         }
 
         deleteTodo := func(id int) {
-            newTodos := vdom.Filter(todos, func(todo Todo) bool {
-                return todo.Id != id
-            })
+            newTodos := make([]Todo, 0)
+            for _, todo := range todos {
+                if todo.Id != id {
+                    newTodos = append(newTodos, todo)
+                }
+            }
             setTodos(newTodos)
         }
 

From c4160266ef56d283532bcb98a95a569f03a68d4c Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 4 Sep 2025 21:59:52 -0700
Subject: [PATCH 062/134] wow recharts demo working

---
 Taskfile.yml                               |  29 +-
 tsunami/demo/recharts/app.go               | 469 +++++++++++++++++++++
 tsunami/frontend/package.json              |   2 +
 tsunami/frontend/src/recharts/recharts.tsx | 168 ++++++++
 tsunami/frontend/src/vdom.tsx              |   9 +-
 tsunami/frontend/vite.config.ts            |   2 +
 6 files changed, 677 insertions(+), 2 deletions(-)
 create mode 100644 tsunami/demo/recharts/app.go
 create mode 100644 tsunami/frontend/src/recharts/recharts.tsx

diff --git a/Taskfile.yml b/Taskfile.yml
index 3c39b08b28..cdf3860b25 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -456,11 +456,29 @@ tasks:
         cmd: yarn build
         dir: tsunami/frontend
 
+    tsunami:frontend:devbuild:
+        desc: Build the tsunami frontend in development mode (with source maps and symbols)
+        cmd: yarn build:dev
+        dir: tsunami/frontend
+
     tsunami:scaffold:
         desc: Build scaffold for tsunami frontend development
-        dir: tsunami/frontend
         deps:
             - tsunami:frontend:build
+        cmds:
+            - task: tsunami:scaffold:internal
+
+    tsunami:devscaffold:
+        desc: Build scaffold for tsunami frontend development (with source maps and symbols)
+        deps:
+            - tsunami:frontend:devbuild
+        cmds:
+            - task: tsunami:scaffold:internal
+
+    tsunami:scaffold:internal:
+        desc: Internal task to create scaffold directory structure
+        dir: tsunami/frontend
+        internal: true
         cmds:
             - cmd: "{{.RMRF}} scaffold"
               ignore_error: true
@@ -490,6 +508,15 @@ tasks:
         generates:
             - "bin/tsunami{{exeExt}}"
 
+    tsunami:clean:
+        desc: Clean tsunami frontend build artifacts
+        dir: tsunami/frontend
+        cmds:
+            - cmd: "{{.RMRF}} dist"
+              ignore_error: true
+            - cmd: "{{.RMRF}} scaffold"
+              ignore_error: true
+
     godoc:
         desc: Start the Go documentation server for the root module
         cmd: $(go env GOPATH)/bin/pkgsite -http=:6060
diff --git a/tsunami/demo/recharts/app.go b/tsunami/demo/recharts/app.go
new file mode 100644
index 0000000000..3257f6f664
--- /dev/null
+++ b/tsunami/demo/recharts/app.go
@@ -0,0 +1,469 @@
+package main
+
+import (
+	"context"
+	"math"
+	"time"
+
+	"github.com/wavetermdev/waveterm/tsunami/app"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+// Use func init() to set atom defaults
+func init() {
+	app.SetData("chartData", generateInitialData())
+	app.SetConfig("chartType", "line")
+	app.SetSharedAtom("isAnimating", false)
+}
+
+type DataPoint struct {
+	Time int     `json:"time"`
+	CPU  float64 `json:"cpu"`
+	Mem  float64 `json:"mem"`
+	Disk float64 `json:"disk"`
+}
+
+func generateInitialData() []DataPoint {
+	data := make([]DataPoint, 20)
+	for i := 0; i < 20; i++ {
+		data[i] = DataPoint{
+			Time: i,
+			CPU:  50 + 30*math.Sin(float64(i)*0.3) + 10*math.Sin(float64(i)*0.7),
+			Mem:  40 + 25*math.Cos(float64(i)*0.4) + 15*math.Sin(float64(i)*0.9),
+			Disk: 30 + 20*math.Sin(float64(i)*0.2) + 10*math.Cos(float64(i)*1.1),
+		}
+	}
+	return data
+}
+
+func generateNewDataPoint(currentData []DataPoint) DataPoint {
+	lastTime := 0
+	if len(currentData) > 0 {
+		lastTime = currentData[len(currentData)-1].Time
+	}
+	newTime := lastTime + 1
+	
+	return DataPoint{
+		Time: newTime,
+		CPU:  50 + 30*math.Sin(float64(newTime)*0.3) + 10*math.Sin(float64(newTime)*0.7),
+		Mem:  40 + 25*math.Cos(float64(newTime)*0.4) + 15*math.Sin(float64(newTime)*0.9),
+		Disk: 30 + 20*math.Sin(float64(newTime)*0.2) + 10*math.Cos(float64(newTime)*1.1),
+	}
+}
+
+var App = app.DefineComponent("App",
+	func(ctx context.Context, _ struct{}) any {
+		vdom.UseSetAppTitle(ctx, "Recharts Demo")
+
+		// Global state
+		chartData, setChartData, setChartDataFn := vdom.UseData[[]DataPoint](ctx, "chartData")
+		chartType, setChartType, _ := vdom.UseConfig[string](ctx, "chartType")
+		isAnimating, setIsAnimating, _ := vdom.UseSharedAtom[bool](ctx, "isAnimating")
+
+		// Local state for timer
+		_, _, setTickerFn := vdom.UseState[int](ctx, 0)
+
+		// Timer effect for live data updates
+		vdom.UseEffect(ctx, func() func() {
+			if !isAnimating {
+				return nil
+			}
+
+			ticker := time.NewTicker(1 * time.Second)
+			done := make(chan bool)
+
+			go func() {
+				for {
+					select {
+					case <-done:
+						return
+					case <-ticker.C:
+						// Add new data point and keep only last 20 points
+						setChartDataFn(func(currentData []DataPoint) []DataPoint {
+							newData := append(currentData, generateNewDataPoint(currentData))
+							if len(newData) > 20 {
+								newData = newData[1:]
+							}
+							return newData
+						})
+						// Trigger a re-render
+						setTickerFn(func(t int) int { return t + 1 })
+						app.SendAsyncInitiation()
+					}
+				}
+			}()
+
+			return func() {
+				ticker.Stop()
+				close(done)
+			}
+		}, []any{isAnimating})
+
+		handleStartStop := func() {
+			setIsAnimating(!isAnimating)
+		}
+
+		handleReset := func() {
+			setChartData(generateInitialData())
+			setIsAnimating(false)
+		}
+
+		handleChartTypeChange := func(newType string) {
+			setChartType(newType)
+		}
+
+		return vdom.H("div", map[string]any{
+			"className": "min-h-screen bg-gray-50 p-6",
+		},
+			vdom.H("div", map[string]any{
+				"className": "max-w-6xl mx-auto",
+			},
+				// Header
+				vdom.H("div", map[string]any{
+					"className": "mb-8",
+				},
+					vdom.H("h1", map[string]any{
+						"className": "text-3xl font-bold text-gray-900 mb-2",
+					}, "Recharts Integration Demo"),
+					vdom.H("p", map[string]any{
+						"className": "text-gray-600",
+					}, "Demonstrating recharts components in Tsunami VDOM system"),
+				),
+
+				// Controls
+				vdom.H("div", map[string]any{
+					"className": "bg-white rounded-lg shadow-sm border p-4 mb-6",
+				},
+					vdom.H("div", map[string]any{
+						"className": "flex items-center gap-4 flex-wrap",
+					},
+						// Chart type selector
+						vdom.H("div", map[string]any{
+							"className": "flex items-center gap-2",
+						},
+							vdom.H("label", map[string]any{
+								"className": "text-sm font-medium text-gray-700",
+							}, "Chart Type:"),
+							vdom.H("select", map[string]any{
+								"className": "px-3 py-1 border border-gray-300 rounded-md text-sm bg-white text-gray-900 focus:ring-2 focus:ring-blue-500 focus:border-blue-500",
+								"value":     chartType,
+								"onChange": func(e vdom.VDomEvent) {
+									handleChartTypeChange(e.TargetValue)
+								},
+							},
+								vdom.H("option", map[string]any{"value": "line"}, "Line Chart"),
+								vdom.H("option", map[string]any{"value": "area"}, "Area Chart"),
+								vdom.H("option", map[string]any{"value": "bar"}, "Bar Chart"),
+							),
+						),
+
+						// Animation controls
+						vdom.H("button", map[string]any{
+							"className": vdom.Classes(
+								"px-4 py-2 rounded-md text-sm font-medium transition-colors",
+								vdom.IfElse(isAnimating,
+									"bg-red-500 hover:bg-red-600 text-white",
+									"bg-green-500 hover:bg-green-600 text-white",
+								),
+							),
+							"onClick": handleStartStop,
+						}, vdom.IfElse(isAnimating, "Stop Animation", "Start Animation")),
+
+						vdom.H("button", map[string]any{
+							"className": "px-4 py-2 bg-gray-500 hover:bg-gray-600 text-white rounded-md text-sm font-medium transition-colors",
+							"onClick":   handleReset,
+						}, "Reset Data"),
+
+						// Status indicator
+						vdom.H("div", map[string]any{
+							"className": "flex items-center gap-2",
+						},
+							vdom.H("div", map[string]any{
+								"className": vdom.Classes(
+									"w-2 h-2 rounded-full",
+									vdom.IfElse(isAnimating, "bg-green-500", "bg-gray-400"),
+								),
+							}),
+							vdom.H("span", map[string]any{
+								"className": "text-sm text-gray-600",
+							}, vdom.IfElse(isAnimating, "Live Updates", "Static")),
+						),
+					),
+				),
+
+				// Main chart
+				vdom.H("div", map[string]any{
+					"className": "bg-white rounded-lg shadow-sm border p-6 mb-6",
+				},
+					vdom.H("h2", map[string]any{
+						"className": "text-xl font-semibold text-gray-900 mb-4",
+					}, "System Metrics Over Time"),
+					vdom.H("div", map[string]any{
+						"className": "w-full h-96",
+					},
+						// Main chart - switches based on chartType
+						vdom.IfElse(chartType == "line",
+							// Line Chart
+							vdom.H("recharts:ResponsiveContainer", map[string]any{
+								"width":  "100%",
+								"height": "100%",
+							},
+								vdom.H("recharts:LineChart", map[string]any{
+									"data": chartData,
+								},
+									vdom.H("recharts:CartesianGrid", map[string]any{
+										"strokeDasharray": "3 3",
+									}),
+									vdom.H("recharts:XAxis", map[string]any{
+										"dataKey": "time",
+									}),
+									vdom.H("recharts:YAxis", nil),
+									vdom.H("recharts:Tooltip", nil),
+									vdom.H("recharts:Legend", nil),
+									vdom.H("recharts:Line", map[string]any{
+										"type":     "monotone",
+										"dataKey":  "cpu",
+										"stroke":   "#8884d8",
+										"name":     "CPU %",
+									}),
+									vdom.H("recharts:Line", map[string]any{
+										"type":     "monotone",
+										"dataKey":  "mem",
+										"stroke":   "#82ca9d",
+										"name":     "Memory %",
+									}),
+									vdom.H("recharts:Line", map[string]any{
+										"type":     "monotone",
+										"dataKey":  "disk",
+										"stroke":   "#ffc658",
+										"name":     "Disk %",
+									}),
+								),
+							),
+							vdom.IfElse(chartType == "area",
+								// Area Chart
+								vdom.H("recharts:ResponsiveContainer", map[string]any{
+									"width":  "100%",
+									"height": "100%",
+								},
+									vdom.H("recharts:AreaChart", map[string]any{
+										"data": chartData,
+									},
+										vdom.H("recharts:CartesianGrid", map[string]any{
+											"strokeDasharray": "3 3",
+										}),
+										vdom.H("recharts:XAxis", map[string]any{
+											"dataKey": "time",
+										}),
+										vdom.H("recharts:YAxis", nil),
+										vdom.H("recharts:Tooltip", nil),
+										vdom.H("recharts:Legend", nil),
+										vdom.H("recharts:Area", map[string]any{
+											"type":     "monotone",
+											"dataKey":  "cpu",
+											"stackId":  "1",
+											"stroke":   "#8884d8",
+											"fill":     "#8884d8",
+											"name":     "CPU %",
+										}),
+										vdom.H("recharts:Area", map[string]any{
+											"type":     "monotone",
+											"dataKey":  "mem",
+											"stackId":  "1",
+											"stroke":   "#82ca9d",
+											"fill":     "#82ca9d",
+											"name":     "Memory %",
+										}),
+										vdom.H("recharts:Area", map[string]any{
+											"type":     "monotone",
+											"dataKey":  "disk",
+											"stackId":  "1",
+											"stroke":   "#ffc658",
+											"fill":     "#ffc658",
+											"name":     "Disk %",
+										}),
+									),
+								),
+								// Bar Chart
+								vdom.H("recharts:ResponsiveContainer", map[string]any{
+									"width":  "100%",
+									"height": "100%",
+								},
+									vdom.H("recharts:BarChart", map[string]any{
+										"data": chartData,
+									},
+										vdom.H("recharts:CartesianGrid", map[string]any{
+											"strokeDasharray": "3 3",
+										}),
+										vdom.H("recharts:XAxis", map[string]any{
+											"dataKey": "time",
+										}),
+										vdom.H("recharts:YAxis", nil),
+										vdom.H("recharts:Tooltip", nil),
+										vdom.H("recharts:Legend", nil),
+										vdom.H("recharts:Bar", map[string]any{
+											"dataKey": "cpu",
+											"fill":    "#8884d8",
+											"name":    "CPU %",
+										}),
+										vdom.H("recharts:Bar", map[string]any{
+											"dataKey": "mem",
+											"fill":    "#82ca9d",
+											"name":    "Memory %",
+										}),
+										vdom.H("recharts:Bar", map[string]any{
+											"dataKey": "disk",
+											"fill":    "#ffc658",
+											"name":    "Disk %",
+										}),
+									),
+								),
+							),
+						),
+					),
+				),
+
+				// Mini charts row
+				vdom.H("div", map[string]any{
+					"className": "grid grid-cols-1 md:grid-cols-3 gap-6 mb-6",
+				},
+					// CPU Mini Chart
+					vdom.H("div", map[string]any{
+						"className": "bg-white rounded-lg shadow-sm border p-4",
+					},
+						vdom.H("h3", map[string]any{
+							"className": "text-lg font-medium text-gray-900 mb-3",
+						}, "CPU Usage"),
+						vdom.H("div", map[string]any{
+							"className": "h-32",
+						},
+							vdom.H("recharts:ResponsiveContainer", map[string]any{
+								"width":  "100%",
+								"height": "100%",
+							},
+								vdom.H("recharts:LineChart", map[string]any{
+									"data": chartData,
+								},
+									vdom.H("recharts:Line", map[string]any{
+										"type":            "monotone",
+										"dataKey":         "cpu",
+										"stroke":          "#8884d8",
+										"strokeWidth":     2,
+										"dot":             false,
+									}),
+								),
+							),
+						),
+					),
+
+					// Memory Mini Chart
+					vdom.H("div", map[string]any{
+						"className": "bg-white rounded-lg shadow-sm border p-4",
+					},
+						vdom.H("h3", map[string]any{
+							"className": "text-lg font-medium text-gray-900 mb-3",
+						}, "Memory Usage"),
+						vdom.H("div", map[string]any{
+							"className": "h-32",
+						},
+							vdom.H("recharts:ResponsiveContainer", map[string]any{
+								"width":  "100%",
+								"height": "100%",
+							},
+								vdom.H("recharts:AreaChart", map[string]any{
+									"data": chartData,
+								},
+									vdom.H("recharts:Area", map[string]any{
+										"type":    "monotone",
+										"dataKey": "mem",
+										"stroke":  "#82ca9d",
+										"fill":    "#82ca9d",
+									}),
+								),
+							),
+						),
+					),
+
+					// Disk Mini Chart  
+					vdom.H("div", map[string]any{
+						"className": "bg-white rounded-lg shadow-sm border p-4",
+					},
+						vdom.H("h3", map[string]any{
+							"className": "text-lg font-medium text-gray-900 mb-3",
+						}, "Disk Usage"),
+						vdom.H("div", map[string]any{
+							"className": "h-32",
+						},
+							vdom.H("recharts:ResponsiveContainer", map[string]any{
+								"width":  "100%",
+								"height": "100%",
+							},
+								vdom.H("recharts:BarChart", map[string]any{
+									"data": chartData,
+								},
+									vdom.H("recharts:Bar", map[string]any{
+										"dataKey": "disk",
+										"fill":    "#ffc658",
+									}),
+								),
+							),
+						),
+					),
+				),
+
+				// Info section
+				vdom.H("div", map[string]any{
+					"className": "bg-blue-50 border border-blue-200 rounded-lg p-4",
+				},
+					vdom.H("h3", map[string]any{
+						"className": "text-lg font-semibold text-blue-900 mb-2",
+					}, "Recharts Integration Features"),
+					vdom.H("ul", map[string]any{
+						"className": "space-y-2 text-blue-800",
+					},
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-500 mt-1",
+							}, "•"),
+							"Support for all major Recharts components (LineChart, AreaChart, BarChart, etc.)",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-500 mt-1",
+							}, "•"),
+							"Live data updates with animation support",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-500 mt-1",
+							}, "•"),
+							"Responsive containers that resize with the window",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-500 mt-1",
+							}, "•"),
+							"Full prop support for customization and styling",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-500 mt-1",
+							}, "•"),
+							"Uses recharts: namespace to dispatch to the recharts handler",
+						),
+					),
+				),
+			),
+		)
+	},
+)
diff --git a/tsunami/frontend/package.json b/tsunami/frontend/package.json
index 98c7914245..8f392d58bf 100644
--- a/tsunami/frontend/package.json
+++ b/tsunami/frontend/package.json
@@ -12,6 +12,7 @@
     "scripts": {
         "dev": "vite",
         "build": "vite build",
+        "build:dev": "NODE_ENV=development vite build --mode development",
         "preview": "vite preview",
         "type-check": "tsc --noEmit"
     },
@@ -22,6 +23,7 @@
         "react": "^19.1.1",
         "react-dom": "^19.1.1",
         "react-markdown": "^10.1.0",
+        "recharts": "^3.1.2",
         "tailwind-merge": "^3.3.1"
     },
     "devDependencies": {
diff --git a/tsunami/frontend/src/recharts/recharts.tsx b/tsunami/frontend/src/recharts/recharts.tsx
new file mode 100644
index 0000000000..64aef65abb
--- /dev/null
+++ b/tsunami/frontend/src/recharts/recharts.tsx
@@ -0,0 +1,168 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import * as React from "react";
+import {
+    LineChart,
+    AreaChart,
+    BarChart,
+    PieChart,
+    ScatterChart,
+    RadarChart,
+    ComposedChart,
+    CartesianGrid,
+    XAxis,
+    YAxis,
+    ZAxis,
+    Tooltip,
+    Legend,
+    Line,
+    Area,
+    Bar,
+    Pie,
+    Cell,
+    Scatter,
+    Radar,
+    PolarGrid,
+    PolarAngleAxis,
+    PolarRadiusAxis,
+    ResponsiveContainer,
+    ReferenceLine,
+    ReferenceArea,
+    ReferenceDot,
+    Brush,
+    ErrorBar,
+    LabelList,
+    FunnelChart,
+    Funnel,
+    Treemap,
+} from "recharts";
+
+import type { TsunamiModel } from "@/model/tsunami-model";
+import { convertElemToTag } from "@/vdom";
+
+type VDomRechartsTagType = (props: { elem: VDomElem; model: TsunamiModel }) => React.ReactElement;
+
+// Map recharts component names to their actual components
+const RechartsComponentMap: Record<string, React.ComponentType<any>> = {
+    LineChart,
+    AreaChart,
+    BarChart,
+    PieChart,
+    ScatterChart,
+    RadarChart,
+    ComposedChart,
+    CartesianGrid,
+    XAxis,
+    YAxis,
+    ZAxis,
+    Tooltip,
+    Legend,
+    Line,
+    Area,
+    Bar,
+    Pie,
+    Cell,
+    Scatter,
+    Radar,
+    PolarGrid,
+    PolarAngleAxis,
+    PolarRadiusAxis,
+    ResponsiveContainer,
+    ReferenceLine,
+    ReferenceArea,
+    ReferenceDot,
+    Brush,
+    ErrorBar,
+    LabelList,
+    FunnelChart,
+    Funnel,
+    Treemap,
+};
+
+// Handler for recharts components - uses the same pattern as VDomTag from vdom.tsx
+function RechartsTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
+    // Convert props
+    const props = convertRechartsProps(model, elem);
+    
+    // Extract the component name from the tag (remove "recharts:" prefix)
+    const componentName = elem.tag.replace("recharts:", "");
+    
+    // Get the React component from the map
+    const RechartsComponent = RechartsComponentMap[componentName];
+    
+    if (!RechartsComponent) {
+        return <div>{"Invalid Recharts Component <" + elem.tag + ">"}</div>;
+    }
+    
+    const children = convertRechartsChildren(elem, model);
+    
+    // Add the waveid as key
+    props.key = "recharts-" + elem.waveid;
+    
+    return React.createElement(RechartsComponent, props, children);
+}
+
+// Simplified version of useVDom for recharts - handles basic prop conversion
+function convertRechartsProps(model: TsunamiModel, elem: VDomElem): any {
+    // For now, do a basic prop conversion without full binding support
+    // This can be enhanced later to use the full useVDom functionality
+    if (!elem.props) {
+        return {};
+    }
+    
+    const props: any = {};
+    for (const [key, value] of Object.entries(elem.props)) {
+        if (value != null) {
+            props[key] = value;
+        }
+    }
+    
+    return props;
+}
+
+// Convert children for recharts components - return literal Recharts components
+function convertRechartsChildren(elem: VDomElem, model: TsunamiModel): React.ReactNode[] | null {
+    if (!elem.children || elem.children.length === 0) {
+        return null;
+    }
+    
+    const children: React.ReactNode[] = [];
+    
+    for (const child of elem.children) {
+        if (!child) continue;
+        
+        if (child.tag === "#text") {
+            // Allow text nodes (rare but valid)
+            children.push(child.text ?? "");
+            continue;
+        }
+        
+        if (child.tag?.startsWith("recharts:")) {
+            // Extract component name and get the actual Recharts component
+            const componentName = child.tag.replace("recharts:", "");
+            const RechartsComponent = RechartsComponentMap[componentName];
+            
+            if (RechartsComponent) {
+                // Convert props using the same logic as convertRechartsProps
+                const childProps = convertRechartsProps(model, child);
+                childProps.key = "recharts-" + child.waveid;
+                
+                // Recursively convert children
+                const grandChildren = convertRechartsChildren(child, model);
+                
+                // Create the raw Recharts component directly
+                children.push(React.createElement(RechartsComponent, childProps, grandChildren));
+            }
+            continue;
+        }
+        
+        // Non-Recharts nodes under charts aren't supported; drop silently
+        // Could add warning: console.warn("Unsupported child type in Recharts:", child.tag);
+    }
+    
+    return children.length > 0 ? children : null;
+}
+
+
+export { RechartsTag };
\ No newline at end of file
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index ad1bf078f0..86cbdd3aa3 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -10,6 +10,7 @@ import { Markdown } from "@/element/markdown";
 import { getTextChildren } from "@/model/model-utils";
 import type { TsunamiModel } from "@/model/tsunami-model";
 import { adaptFromReactOrNativeKeyEvent, checkKeyPressed } from "@/util/keyutil";
+import { RechartsTag } from "@/recharts/recharts";
 
 const TextTag = "#text";
 const FragmentTag = "#fragment";
@@ -161,7 +162,7 @@ function convertVDomFunc(model: TsunamiModel, fnDecl: VDomFunc, compId: string,
     };
 }
 
-function convertElemToTag(elem: VDomElem, model: TsunamiModel): React.ReactNode {
+export function convertElemToTag(elem: VDomElem, model: TsunamiModel): React.ReactNode {
     if (elem == null) {
         return null;
     }
@@ -331,6 +332,12 @@ function VDomTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
     if (elem.tag == WaveTextTag) {
         return props.text;
     }
+    
+    // Dispatch recharts: prefixed tags to RechartsTag
+    if (elem.tag.startsWith("recharts:")) {
+        return <RechartsTag elem={elem} model={model} />;
+    }
+    
     const waveTag = WaveTagMap[elem.tag];
     if (waveTag) {
         return waveTag({ elem, model });
diff --git a/tsunami/frontend/vite.config.ts b/tsunami/frontend/vite.config.ts
index 4faaf3cb18..522985810d 100644
--- a/tsunami/frontend/vite.config.ts
+++ b/tsunami/frontend/vite.config.ts
@@ -28,5 +28,7 @@ export default defineConfig({
     },
     build: {
         outDir: "dist",
+        minify: process.env.NODE_ENV === "development" ? false : "esbuild",
+        sourcemap: process.env.NODE_ENV === "development" ? true : false,
     },
 });

From d7a4b5f2358a8cb36821ef7dd88bb90b296c36ac Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Fri, 5 Sep 2025 11:28:14 -0700
Subject: [PATCH 063/134] add recharts documentation for prompt

---
 tsunami/demo/recharts/app.go | 292 ++++++++++++++++---------------
 tsunami/prompts/graphing.md  | 325 +++++++++++++++++++++++++++++++++++
 2 files changed, 480 insertions(+), 137 deletions(-)
 create mode 100644 tsunami/prompts/graphing.md

diff --git a/tsunami/demo/recharts/app.go b/tsunami/demo/recharts/app.go
index 3257f6f664..3a0b29bd64 100644
--- a/tsunami/demo/recharts/app.go
+++ b/tsunami/demo/recharts/app.go
@@ -51,6 +51,157 @@ func generateNewDataPoint(currentData []DataPoint) DataPoint {
 	}
 }
 
+var InfoSection = app.DefineComponent("InfoSection",
+	func(ctx context.Context, _ struct{}) any {
+		return vdom.H("div", map[string]any{
+			"className": "bg-blue-50 border border-blue-200 rounded-lg p-4",
+		},
+			vdom.H("h3", map[string]any{
+				"className": "text-lg font-semibold text-blue-900 mb-2",
+			}, "Recharts Integration Features"),
+			vdom.H("ul", map[string]any{
+				"className": "space-y-2 text-blue-800",
+			},
+				vdom.H("li", map[string]any{
+					"className": "flex items-start gap-2",
+				},
+					vdom.H("span", map[string]any{
+						"className": "text-blue-500 mt-1",
+					}, "•"),
+					"Support for all major Recharts components (LineChart, AreaChart, BarChart, etc.)",
+				),
+				vdom.H("li", map[string]any{
+					"className": "flex items-start gap-2",
+				},
+					vdom.H("span", map[string]any{
+						"className": "text-blue-500 mt-1",
+					}, "•"),
+					"Live data updates with animation support",
+				),
+				vdom.H("li", map[string]any{
+					"className": "flex items-start gap-2",
+				},
+					vdom.H("span", map[string]any{
+						"className": "text-blue-500 mt-1",
+					}, "•"),
+					"Responsive containers that resize with the window",
+				),
+				vdom.H("li", map[string]any{
+					"className": "flex items-start gap-2",
+				},
+					vdom.H("span", map[string]any{
+						"className": "text-blue-500 mt-1",
+					}, "•"),
+					"Full prop support for customization and styling",
+				),
+				vdom.H("li", map[string]any{
+					"className": "flex items-start gap-2",
+				},
+					vdom.H("span", map[string]any{
+						"className": "text-blue-500 mt-1",
+					}, "•"),
+					"Uses recharts: namespace to dispatch to the recharts handler",
+				),
+			),
+		)
+	},
+)
+
+type MiniChartsProps struct {
+	ChartData []DataPoint `json:"chartData"`
+}
+
+var MiniCharts = app.DefineComponent("MiniCharts",
+	func(ctx context.Context, props MiniChartsProps) any {
+		return vdom.H("div", map[string]any{
+			"className": "grid grid-cols-1 md:grid-cols-3 gap-6 mb-6",
+		},
+			// CPU Mini Chart
+			vdom.H("div", map[string]any{
+				"className": "bg-white rounded-lg shadow-sm border p-4",
+			},
+				vdom.H("h3", map[string]any{
+					"className": "text-lg font-medium text-gray-900 mb-3",
+				}, "CPU Usage"),
+				vdom.H("div", map[string]any{
+					"className": "h-32",
+				},
+					vdom.H("recharts:ResponsiveContainer", map[string]any{
+						"width":  "100%",
+						"height": "100%",
+					},
+						vdom.H("recharts:LineChart", map[string]any{
+							"data": props.ChartData,
+						},
+							vdom.H("recharts:Line", map[string]any{
+								"type":            "monotone",
+								"dataKey":         "cpu",
+								"stroke":          "#8884d8",
+								"strokeWidth":     2,
+								"dot":             false,
+							}),
+						),
+					),
+				),
+			),
+
+			// Memory Mini Chart
+			vdom.H("div", map[string]any{
+				"className": "bg-white rounded-lg shadow-sm border p-4",
+			},
+				vdom.H("h3", map[string]any{
+					"className": "text-lg font-medium text-gray-900 mb-3",
+				}, "Memory Usage"),
+				vdom.H("div", map[string]any{
+					"className": "h-32",
+				},
+					vdom.H("recharts:ResponsiveContainer", map[string]any{
+						"width":  "100%",
+						"height": "100%",
+					},
+						vdom.H("recharts:AreaChart", map[string]any{
+							"data": props.ChartData,
+						},
+							vdom.H("recharts:Area", map[string]any{
+								"type":    "monotone",
+								"dataKey": "mem",
+								"stroke":  "#82ca9d",
+								"fill":    "#82ca9d",
+							}),
+						),
+					),
+				),
+			),
+
+			// Disk Mini Chart
+			vdom.H("div", map[string]any{
+				"className": "bg-white rounded-lg shadow-sm border p-4",
+			},
+				vdom.H("h3", map[string]any{
+					"className": "text-lg font-medium text-gray-900 mb-3",
+				}, "Disk Usage"),
+				vdom.H("div", map[string]any{
+					"className": "h-32",
+				},
+					vdom.H("recharts:ResponsiveContainer", map[string]any{
+						"width":  "100%",
+						"height": "100%",
+					},
+						vdom.H("recharts:BarChart", map[string]any{
+							"data": props.ChartData,
+						},
+							vdom.H("recharts:Bar", map[string]any{
+								"dataKey": "disk",
+								"fill":    "#ffc658",
+							}),
+						),
+					),
+				),
+			),
+		)
+	},
+)
+
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ struct{}) any {
 		vdom.UseSetAppTitle(ctx, "Recharts Demo")
@@ -324,145 +475,12 @@ var App = app.DefineComponent("App",
 				),
 
 				// Mini charts row
-				vdom.H("div", map[string]any{
-					"className": "grid grid-cols-1 md:grid-cols-3 gap-6 mb-6",
-				},
-					// CPU Mini Chart
-					vdom.H("div", map[string]any{
-						"className": "bg-white rounded-lg shadow-sm border p-4",
-					},
-						vdom.H("h3", map[string]any{
-							"className": "text-lg font-medium text-gray-900 mb-3",
-						}, "CPU Usage"),
-						vdom.H("div", map[string]any{
-							"className": "h-32",
-						},
-							vdom.H("recharts:ResponsiveContainer", map[string]any{
-								"width":  "100%",
-								"height": "100%",
-							},
-								vdom.H("recharts:LineChart", map[string]any{
-									"data": chartData,
-								},
-									vdom.H("recharts:Line", map[string]any{
-										"type":            "monotone",
-										"dataKey":         "cpu",
-										"stroke":          "#8884d8",
-										"strokeWidth":     2,
-										"dot":             false,
-									}),
-								),
-							),
-						),
-					),
-
-					// Memory Mini Chart
-					vdom.H("div", map[string]any{
-						"className": "bg-white rounded-lg shadow-sm border p-4",
-					},
-						vdom.H("h3", map[string]any{
-							"className": "text-lg font-medium text-gray-900 mb-3",
-						}, "Memory Usage"),
-						vdom.H("div", map[string]any{
-							"className": "h-32",
-						},
-							vdom.H("recharts:ResponsiveContainer", map[string]any{
-								"width":  "100%",
-								"height": "100%",
-							},
-								vdom.H("recharts:AreaChart", map[string]any{
-									"data": chartData,
-								},
-									vdom.H("recharts:Area", map[string]any{
-										"type":    "monotone",
-										"dataKey": "mem",
-										"stroke":  "#82ca9d",
-										"fill":    "#82ca9d",
-									}),
-								),
-							),
-						),
-					),
-
-					// Disk Mini Chart  
-					vdom.H("div", map[string]any{
-						"className": "bg-white rounded-lg shadow-sm border p-4",
-					},
-						vdom.H("h3", map[string]any{
-							"className": "text-lg font-medium text-gray-900 mb-3",
-						}, "Disk Usage"),
-						vdom.H("div", map[string]any{
-							"className": "h-32",
-						},
-							vdom.H("recharts:ResponsiveContainer", map[string]any{
-								"width":  "100%",
-								"height": "100%",
-							},
-								vdom.H("recharts:BarChart", map[string]any{
-									"data": chartData,
-								},
-									vdom.H("recharts:Bar", map[string]any{
-										"dataKey": "disk",
-										"fill":    "#ffc658",
-									}),
-								),
-							),
-						),
-					),
-				),
+				MiniCharts(MiniChartsProps{
+					ChartData: chartData,
+				}),
 
 				// Info section
-				vdom.H("div", map[string]any{
-					"className": "bg-blue-50 border border-blue-200 rounded-lg p-4",
-				},
-					vdom.H("h3", map[string]any{
-						"className": "text-lg font-semibold text-blue-900 mb-2",
-					}, "Recharts Integration Features"),
-					vdom.H("ul", map[string]any{
-						"className": "space-y-2 text-blue-800",
-					},
-						vdom.H("li", map[string]any{
-							"className": "flex items-start gap-2",
-						},
-							vdom.H("span", map[string]any{
-								"className": "text-blue-500 mt-1",
-							}, "•"),
-							"Support for all major Recharts components (LineChart, AreaChart, BarChart, etc.)",
-						),
-						vdom.H("li", map[string]any{
-							"className": "flex items-start gap-2",
-						},
-							vdom.H("span", map[string]any{
-								"className": "text-blue-500 mt-1",
-							}, "•"),
-							"Live data updates with animation support",
-						),
-						vdom.H("li", map[string]any{
-							"className": "flex items-start gap-2",
-						},
-							vdom.H("span", map[string]any{
-								"className": "text-blue-500 mt-1",
-							}, "•"),
-							"Responsive containers that resize with the window",
-						),
-						vdom.H("li", map[string]any{
-							"className": "flex items-start gap-2",
-						},
-							vdom.H("span", map[string]any{
-								"className": "text-blue-500 mt-1",
-							}, "•"),
-							"Full prop support for customization and styling",
-						),
-						vdom.H("li", map[string]any{
-							"className": "flex items-start gap-2",
-						},
-							vdom.H("span", map[string]any{
-								"className": "text-blue-500 mt-1",
-							}, "•"),
-							"Uses recharts: namespace to dispatch to the recharts handler",
-						),
-					),
-				),
+				InfoSection(struct{}{}),
 			),
 		)
 	},
diff --git a/tsunami/prompts/graphing.md b/tsunami/prompts/graphing.md
new file mode 100644
index 0000000000..c917d2bd24
--- /dev/null
+++ b/tsunami/prompts/graphing.md
@@ -0,0 +1,325 @@
+# Graphing with Recharts in Tsunami
+
+The Tsunami framework provides seamless integration with the Recharts library (v3), allowing you to create rich, interactive charts and graphs using familiar React patterns but with Go's type safety and performance.
+
+## How Recharts Works in Tsunami
+
+Recharts components are accessed through the `recharts:` namespace in your VDOM elements. This tells Tsunami's renderer to dispatch these elements to the specialized recharts handler instead of creating regular HTML elements.
+
+```go
+// Basic chart structure
+vdom.H("recharts:ResponsiveContainer", map[string]any{
+    "width":  "100%",
+    "height": 300,
+},
+    vdom.H("recharts:LineChart", map[string]any{
+        "data": chartData,
+    },
+        vdom.H("recharts:Line", map[string]any{
+            "dataKey": "value",
+            "stroke":  "#8884d8",
+        }),
+    ),
+)
+```
+
+## Key Concepts
+
+### Namespace Usage
+All recharts components use the `recharts:` prefix and have the same names as their React counterparts:
+- `recharts:ResponsiveContainer` - Container that responds to parent size changes
+- `recharts:LineChart`, `recharts:AreaChart`, `recharts:BarChart` - Chart types
+- `recharts:XAxis`, `recharts:YAxis` - Axis components
+- `recharts:CartesianGrid`, `recharts:Tooltip`, `recharts:Legend` - Supporting components
+- `recharts:Line`, `recharts:Area`, `recharts:Bar` - Data series components
+
+Every Recharts component from the React library is available with the `recharts:` prefix.
+
+### Data Structure
+Charts expect Go structs or slices that can be serialized to JSON. Use json tags to control field names:
+
+```go
+type DataPoint struct {
+    Time  int     `json:"time"`
+    Value float64 `json:"value"`
+    Label string  `json:"label"`
+}
+
+data := []DataPoint{
+    {Time: 1, Value: 100, Label: "Jan"},
+    {Time: 2, Value: 150, Label: "Feb"},
+    {Time: 3, Value: 120, Label: "Mar"},
+}
+```
+
+### Props and Configuration
+Recharts components accept the same props as the React version, passed as Go map[string]any:
+
+```go
+vdom.H("recharts:Line", map[string]any{
+    "type":        "monotone",    // Line interpolation
+    "dataKey":     "value",       // Field name from data struct
+    "stroke":      "#8884d8",     // Line color
+    "strokeWidth": 2,             // Line thickness
+    "dot":         false,         // Hide data points
+})
+```
+
+## Chart Examples
+
+### Simple Line Chart
+
+```go
+type MetricsData struct {
+    Time int     `json:"time"`
+    CPU  float64 `json:"cpu"`
+    Mem  float64 `json:"mem"`
+}
+
+func renderLineChart(data []MetricsData) any {
+    return vdom.H("recharts:ResponsiveContainer", map[string]any{
+        "width":  "100%",
+        "height": 400,
+    },
+        vdom.H("recharts:LineChart", map[string]any{
+            "data": data,
+        },
+            vdom.H("recharts:CartesianGrid", map[string]any{
+                "strokeDasharray": "3 3",
+            }),
+            vdom.H("recharts:XAxis", map[string]any{
+                "dataKey": "time",
+            }),
+            vdom.H("recharts:YAxis", nil),
+            vdom.H("recharts:Tooltip", nil),
+            vdom.H("recharts:Legend", nil),
+            vdom.H("recharts:Line", map[string]any{
+                "type":    "monotone",
+                "dataKey": "cpu",
+                "stroke":  "#8884d8",
+                "name":    "CPU %",
+            }),
+            vdom.H("recharts:Line", map[string]any{
+                "type":    "monotone",
+                "dataKey": "mem",
+                "stroke":  "#82ca9d",
+                "name":    "Memory %",
+            }),
+        ),
+    )
+}
+```
+
+### Area Chart with Stacking
+
+```go
+func renderAreaChart(data []MetricsData) any {
+    return vdom.H("recharts:ResponsiveContainer", map[string]any{
+        "width":  "100%",
+        "height": 300,
+    },
+        vdom.H("recharts:AreaChart", map[string]any{
+            "data": data,
+        },
+            vdom.H("recharts:XAxis", map[string]any{
+                "dataKey": "time",
+            }),
+            vdom.H("recharts:YAxis", nil),
+            vdom.H("recharts:Tooltip", nil),
+            vdom.H("recharts:Area", map[string]any{
+                "type":    "monotone",
+                "dataKey": "cpu",
+                "stackId": "1",
+                "stroke":  "#8884d8",
+                "fill":    "#8884d8",
+            }),
+            vdom.H("recharts:Area", map[string]any{
+                "type":    "monotone",
+                "dataKey": "mem",
+                "stackId": "1",
+                "stroke":  "#82ca9d",
+                "fill":    "#82ca9d",
+            }),
+        ),
+    )
+}
+```
+
+### Bar Chart
+
+```go
+func renderBarChart(data []MetricsData) any {
+    return vdom.H("recharts:ResponsiveContainer", map[string]any{
+        "width":  "100%",
+        "height": 350,
+    },
+        vdom.H("recharts:BarChart", map[string]any{
+            "data": data,
+        },
+            vdom.H("recharts:CartesianGrid", map[string]any{
+                "strokeDasharray": "3 3",
+            }),
+            vdom.H("recharts:XAxis", map[string]any{
+                "dataKey": "time",
+            }),
+            vdom.H("recharts:YAxis", nil),
+            vdom.H("recharts:Tooltip", nil),
+            vdom.H("recharts:Legend", nil),
+            vdom.H("recharts:Bar", map[string]any{
+                "dataKey": "cpu",
+                "fill":    "#8884d8",
+                "name":    "CPU %",
+            }),
+            vdom.H("recharts:Bar", map[string]any{
+                "dataKey": "mem",
+                "fill":    "#82ca9d",
+                "name":    "Memory %",
+            }),
+        ),
+    )
+}
+```
+
+## Live Data Updates
+
+Charts automatically re-render when their data changes through Tsunami's reactive state system:
+
+```go
+var App = app.DefineComponent("App",
+    func(ctx context.Context, _ struct{}) any {
+        // State management
+        chartData, setChartData, setChartDataFn := vdom.UseData[[]MetricsData](ctx, "metrics")
+        
+        // Timer for live updates
+        vdom.UseEffect(ctx, func() func() {
+            ticker := time.NewTicker(1 * time.Second)
+            done := make(chan bool)
+            
+            go func() {
+                for {
+                    select {
+                    case <-done:
+                        return
+                    case <-ticker.C:
+                        // Update data and trigger re-render
+                        setChartDataFn(func(current []MetricsData) []MetricsData {
+                            newPoint := generateNewDataPoint()
+                            updated := append(current, newPoint)
+                            // Keep only last 20 points
+                            if len(updated) > 20 {
+                                updated = updated[1:]
+                            }
+                            return updated
+                        })
+                        app.SendAsyncInitiation() // This is necessary to force the FE to update
+                    }
+                }
+            }()
+            
+            return func() {
+                ticker.Stop()
+                close(done)
+            }
+        }, []any{})
+        
+        return renderLineChart(chartData)
+    },
+)
+```
+
+## Responsive Design
+
+### Container Sizing
+Always use `ResponsiveContainer` for charts that should adapt to their container:
+
+```go
+// Responsive - adapts to parent container
+vdom.H("recharts:ResponsiveContainer", map[string]any{
+    "width":  "100%",
+    "height": "100%",
+})
+
+// Fixed size
+vdom.H("recharts:ResponsiveContainer", map[string]any{
+    "width":  400,
+    "height": 300,
+})
+```
+
+### Mobile-Friendly Charts
+Use Tailwind classes to create responsive chart layouts:
+
+```go
+vdom.H("div", map[string]any{
+    "className": "w-full h-64 md:h-96 lg:h-[32rem]",
+},
+    vdom.H("recharts:ResponsiveContainer", map[string]any{
+        "width":  "100%",
+        "height": "100%",
+    },
+        // chart content
+    ),
+)
+```
+
+## Advanced Features
+
+### Custom Styling
+You can customize chart appearance through props:
+
+```go
+vdom.H("recharts:Tooltip", map[string]any{
+    "labelStyle": map[string]any{
+        "color": "#333",
+    },
+    "contentStyle": map[string]any{
+        "backgroundColor": "#f8f9fa",
+        "border": "1px solid #dee2e6",
+    },
+})
+```
+
+### Event Handling
+Charts support interaction events:
+
+```go
+vdom.H("recharts:LineChart", map[string]any{
+    "data": chartData,
+    "onClick": func(event map[string]any) {
+        // Handle chart click
+        fmt.Printf("Chart clicked: %+v\n", event)
+    },
+})
+```
+
+## Best Practices
+
+### Data Management
+- Use global atoms (`UseData`) for chart data that updates frequently
+- Implement data windowing for large datasets to maintain performance
+- Structure data with appropriate json tags for clean field names
+
+### Performance
+- Limit data points for real-time charts (typically 20-100 points)
+- Use `UseEffect` cleanup functions to prevent memory leaks with timers
+- Consider data aggregation for historical views
+
+### Styling
+- Use consistent color schemes across charts
+- Leverage Tailwind classes for chart containers and surrounding UI
+- Consider dark/light theme support in color choices
+
+### State Updates
+- Use functional setters (`setDataFn`) for complex data transformations
+- Call `app.SendAsyncInitiation()` after async state updates
+- Implement proper cleanup in `UseEffect` for timers and goroutines
+
+## Differences from React Recharts
+
+1. **Namespace**: All components use `recharts:` prefix
+2. **Props**: Pass as Go `map[string]any` instead of JSX props
+3. **Data**: Use Go structs with json tags instead of JavaScript objects
+4. **Events**: Event handlers receive Go types, not JavaScript events
+5. **Styling**: Combine Recharts styling with Tailwind classes for layout
+
+The core Recharts API remains the same - consult the official Recharts documentation for detailed prop references and advanced features. The Tsunami integration simply adapts the React patterns to Go's type system while maintaining the familiar development experience.
\ No newline at end of file

From 489285dfd0f4051e98e6fa3ad6151736642915b0 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Fri, 5 Sep 2025 13:36:33 -0700
Subject: [PATCH 064/134] updated demos with go.mod and tw.css...

---
 tsunami/build/build.go              |   48 +
 tsunami/demo/cpuchart/app.go        |  390 ++++++++
 tsunami/demo/cpuchart/go.mod        |   22 +
 tsunami/demo/cpuchart/go.sum        |   34 +
 tsunami/demo/cpuchart/static/tw.css | 1312 +++++++++++++++++++++++++++
 tsunami/demo/pomodoro/go.mod        |    9 +
 tsunami/demo/pomodoro/go.sum        |    2 +
 tsunami/demo/pomodoro/static/tw.css | 1276 ++++++++++++++++++++++++++
 tsunami/demo/todo/go.mod            |    9 +
 tsunami/demo/todo/go.sum            |    2 +
 tsunami/demo/todo/static/tw.css     | 1213 +++++++++++++++++++++++++
 tsunami/prompts/system.md           |    3 +-
 12 files changed, 4319 insertions(+), 1 deletion(-)
 create mode 100644 tsunami/demo/cpuchart/app.go
 create mode 100644 tsunami/demo/cpuchart/go.mod
 create mode 100644 tsunami/demo/cpuchart/go.sum
 create mode 100644 tsunami/demo/cpuchart/static/tw.css
 create mode 100644 tsunami/demo/pomodoro/go.mod
 create mode 100644 tsunami/demo/pomodoro/go.sum
 create mode 100644 tsunami/demo/pomodoro/static/tw.css
 create mode 100644 tsunami/demo/todo/go.mod
 create mode 100644 tsunami/demo/todo/go.sum
 create mode 100644 tsunami/demo/todo/static/tw.css

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 68e7f86be2..b0e4eeae83 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -405,9 +405,57 @@ func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 		return buildEnv, fmt.Errorf("failed to build application: %w", err)
 	}
 
+	// Move generated files back to original directory
+	if err := moveFilesBack(tempDir, opts.Dir, opts.Verbose); err != nil {
+		return buildEnv, fmt.Errorf("failed to move files back: %w", err)
+	}
+
 	return buildEnv, nil
 }
 
+func moveFilesBack(tempDir, originalDir string, verbose bool) error {
+	// Move go.mod back to original directory
+	goModSrc := filepath.Join(tempDir, "go.mod")
+	goModDest := filepath.Join(originalDir, "go.mod")
+	if err := copyFile(goModSrc, goModDest); err != nil {
+		return fmt.Errorf("failed to copy go.mod back: %w", err)
+	}
+	if verbose {
+		log.Printf("Moved go.mod back to %s", goModDest)
+	}
+
+	// Move go.sum back to original directory
+	goSumSrc := filepath.Join(tempDir, "go.sum")
+	goSumDest := filepath.Join(originalDir, "go.sum")
+	if err := copyFile(goSumSrc, goSumDest); err != nil {
+		return fmt.Errorf("failed to copy go.sum back: %w", err)
+	}
+	if verbose {
+		log.Printf("Moved go.sum back to %s", goSumDest)
+	}
+
+	// Ensure static directory exists in original directory
+	staticDir := filepath.Join(originalDir, "static")
+	if err := os.MkdirAll(staticDir, 0755); err != nil {
+		return fmt.Errorf("failed to create static directory: %w", err)
+	}
+	if verbose {
+		log.Printf("Ensured static directory exists at %s", staticDir)
+	}
+
+	// Move tw.css back to original directory
+	twCssSrc := filepath.Join(tempDir, "static", "tw.css")
+	twCssDest := filepath.Join(originalDir, "static", "tw.css")
+	if err := copyFile(twCssSrc, twCssDest); err != nil {
+		return fmt.Errorf("failed to copy tw.css back: %w", err)
+	}
+	if verbose {
+		log.Printf("Moved tw.css back to %s", twCssDest)
+	}
+
+	return nil
+}
+
 func runGoBuild(tempDir string, opts BuildOpts) error {
 	var outputPath string
 	if opts.OutputFile != "" {
diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
new file mode 100644
index 0000000000..aa9d17c191
--- /dev/null
+++ b/tsunami/demo/cpuchart/app.go
@@ -0,0 +1,390 @@
+package main
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/shirou/gopsutil/v4/cpu"
+	"github.com/wavetermdev/waveterm/tsunami/app"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+// Use func init() to set atom defaults
+func init() {
+	// Set default configuration
+	app.SetConfig("dataPointCount", 60)
+	
+	// Initialize with empty data points to maintain consistent chart size
+	dataPointCount := 60 // Default value for initialization
+	initialData := make([]CPUDataPoint, dataPointCount)
+	for i := range initialData {
+		initialData[i] = CPUDataPoint{
+			Time:      0,
+			CPUUsage:  nil, // Use nil to represent empty slots
+			Timestamp: "",
+		}
+	}
+	app.SetData("cpuData", initialData)
+}
+
+type CPUDataPoint struct {
+	Time      int64    `json:"time"`      // Unix timestamp in seconds
+	CPUUsage  *float64 `json:"cpuUsage"`  // CPU usage percentage (nil for empty slots)
+	Timestamp string   `json:"timestamp"` // Human readable timestamp
+}
+
+func collectCPUUsage() (float64, error) {
+	percentages, err := cpu.Percent(time.Second, false)
+	if err != nil {
+		return 0, err
+	}
+	if len(percentages) == 0 {
+		return 0, nil
+	}
+	return percentages[0], nil
+}
+
+func generateCPUDataPoint() CPUDataPoint {
+	now := time.Now()
+	cpuUsage, err := collectCPUUsage()
+	if err != nil {
+		log.Printf("Error collecting CPU usage: %v", err)
+		cpuUsage = 0
+	}
+
+	dataPoint := CPUDataPoint{
+		Time:      now.Unix(),
+		CPUUsage:  &cpuUsage, // Convert to pointer
+		Timestamp: now.Format("15:04:05"),
+	}
+
+	log.Printf("CPU Usage: %.2f%% at %s", cpuUsage, dataPoint.Timestamp)
+	return dataPoint
+}
+
+var StatsPanel = app.DefineComponent("StatsPanel",
+	func(ctx context.Context, props struct {
+		Data []CPUDataPoint `json:"data"`
+	}) any {
+		var currentUsage float64
+		var avgUsage float64
+		var maxUsage float64
+		var validCount int
+
+		if len(props.Data) > 0 {
+			lastPoint := props.Data[len(props.Data)-1]
+			if lastPoint.CPUUsage != nil {
+				currentUsage = *lastPoint.CPUUsage
+			}
+			
+			// Calculate average and max from non-nil values
+			total := 0.0
+			for _, point := range props.Data {
+				if point.CPUUsage != nil {
+					total += *point.CPUUsage
+					validCount++
+					if *point.CPUUsage > maxUsage {
+						maxUsage = *point.CPUUsage
+					}
+				}
+			}
+			if validCount > 0 {
+				avgUsage = total / float64(validCount)
+			}
+		}
+
+		return vdom.H("div", map[string]any{
+			"className": "bg-gray-800 rounded-lg p-4 mb-6",
+		},
+			vdom.H("h3", map[string]any{
+				"className": "text-lg font-semibold text-white mb-3",
+			}, "CPU Statistics"),
+			vdom.H("div", map[string]any{
+				"className": "grid grid-cols-3 gap-4",
+			},
+				// Current Usage
+				vdom.H("div", map[string]any{
+					"className": "bg-gray-700 rounded p-3",
+				},
+					vdom.H("div", map[string]any{
+						"className": "text-sm text-gray-400 mb-1",
+					}, "Current"),
+					vdom.H("div", map[string]any{
+						"className": "text-2xl font-bold text-blue-400",
+					}, vdom.H("span", nil, int(currentUsage+0.5), "%")),
+				),
+				// Average Usage
+				vdom.H("div", map[string]any{
+					"className": "bg-gray-700 rounded p-3",
+				},
+					vdom.H("div", map[string]any{
+						"className": "text-sm text-gray-400 mb-1",
+					}, "Average"),
+					vdom.H("div", map[string]any{
+						"className": "text-2xl font-bold text-green-400",
+					}, vdom.H("span", nil, int(avgUsage+0.5), "%")),
+				),
+				// Max Usage
+				vdom.H("div", map[string]any{
+					"className": "bg-gray-700 rounded p-3",
+				},
+					vdom.H("div", map[string]any{
+						"className": "text-sm text-gray-400 mb-1",
+					}, "Peak"),
+					vdom.H("div", map[string]any{
+						"className": "text-2xl font-bold text-red-400",
+					}, vdom.H("span", nil, int(maxUsage+0.5), "%")),
+				),
+			),
+		)
+	},
+)
+
+var App = app.DefineComponent("App",
+	func(ctx context.Context, _ struct{}) any {
+		vdom.UseSetAppTitle(ctx, "CPU Usage Monitor")
+
+		// Global state
+		cpuData, setCpuData, setCpuDataFn := vdom.UseData[[]CPUDataPoint](ctx, "cpuData")
+		dataPointCount, _, _ := vdom.UseConfig[int](ctx, "dataPointCount")
+
+		// Local state for forcing re-renders
+		_, _, setTickerFn := vdom.UseState[int](ctx, 0)
+
+		// Timer effect for continuous CPU data collection
+		vdom.UseEffect(ctx, func() func() {
+			ticker := time.NewTicker(1 * time.Second)
+			done := make(chan bool)
+
+			go func() {
+				for {
+					select {
+					case <-done:
+						return
+					case <-ticker.C:
+						// Collect new CPU data point and shift the data window
+						setCpuDataFn(func(currentData []CPUDataPoint) []CPUDataPoint {
+							newPoint := generateCPUDataPoint()
+							// Read current config inside the loop to get live updates
+							currentDataPointCount := app.GetConfig[int]("dataPointCount")
+							
+							// Ensure we have the right size array
+							if len(currentData) != currentDataPointCount {
+								// Resize array if config changed
+								newData := make([]CPUDataPoint, currentDataPointCount)
+								copyCount := currentDataPointCount
+								if len(currentData) < copyCount {
+									copyCount = len(currentData)
+								}
+								if copyCount > 0 {
+									copy(newData[currentDataPointCount-copyCount:], currentData[len(currentData)-copyCount:])
+								}
+								currentData = newData
+							}
+							// Create a new slice with exact point count
+							newData := make([]CPUDataPoint, currentDataPointCount)
+							// Shift existing data left by 1 and add new point at the end
+							if currentDataPointCount > 1 {
+								copy(newData, currentData[1:])
+							}
+							if currentDataPointCount > 0 {
+								newData[currentDataPointCount-1] = newPoint
+							}
+							return newData
+						})
+						// Trigger a re-render
+						setTickerFn(func(t int) int { return t + 1 })
+						app.SendAsyncInitiation()
+					}
+				}
+			}()
+
+			return func() {
+				ticker.Stop()
+				close(done)
+			}
+		}, []any{})
+
+		handleClear := func() {
+			// Reset with empty data points based on current config
+			currentDataPointCount := app.GetConfig[int]("dataPointCount")
+			initialData := make([]CPUDataPoint, currentDataPointCount)
+			for i := range initialData {
+				initialData[i] = CPUDataPoint{
+					Time:      0,
+					CPUUsage:  nil,
+					Timestamp: "",
+				}
+			}
+			setCpuData(initialData)
+		}
+
+		return vdom.H("div", map[string]any{
+			"className": "min-h-screen bg-gray-900 text-white p-6",
+		},
+			vdom.H("div", map[string]any{
+				"className": "max-w-6xl mx-auto",
+			},
+				// Header
+				vdom.H("div", map[string]any{
+					"className": "mb-8",
+				},
+					vdom.H("h1", map[string]any{
+						"className": "text-3xl font-bold text-white mb-2",
+					}, "Real-Time CPU Usage Monitor"),
+					vdom.H("p", map[string]any{
+						"className": "text-gray-400",
+					}, "Live CPU usage data collected using gopsutil, displaying 60 seconds of history"),
+				),
+
+				// Controls
+				vdom.H("div", map[string]any{
+					"className": "bg-gray-800 rounded-lg p-4 mb-6",
+				},
+					vdom.H("div", map[string]any{
+						"className": "flex items-center gap-4 flex-wrap",
+					},
+						// Clear button
+						vdom.H("button", map[string]any{
+							"className": "px-4 py-2 bg-gray-600 hover:bg-gray-700 text-white rounded-md text-sm font-medium transition-colors cursor-pointer",
+							"onClick":   handleClear,
+						}, "Clear Data"),
+
+						// Status indicator
+						vdom.H("div", map[string]any{
+							"className": "flex items-center gap-2",
+						},
+							vdom.H("div", map[string]any{
+								"className": "w-2 h-2 rounded-full bg-green-500",
+							}),
+							vdom.H("span", map[string]any{
+								"className": "text-sm text-gray-400",
+							}, "Live Monitoring"),
+							vdom.H("span", map[string]any{
+								"className": "text-sm text-gray-500 ml-2",
+							}, "(", len(cpuData), "/", dataPointCount, " data points)"),
+						),
+					),
+				),
+
+				// Statistics Panel
+				StatsPanel(struct {
+					Data []CPUDataPoint `json:"data"`
+				}{
+					Data: cpuData,
+				}),
+
+				// Main chart
+				vdom.H("div", map[string]any{
+					"className": "bg-gray-800 rounded-lg p-6 mb-6",
+				},
+					vdom.H("h2", map[string]any{
+						"className": "text-xl font-semibold text-white mb-4",
+					}, "CPU Usage Over Time"),
+					vdom.H("div", map[string]any{
+						"className": "w-full h-96",
+					},
+						vdom.H("recharts:ResponsiveContainer", map[string]any{
+							"width":  "100%",
+							"height": "100%",
+						},
+							vdom.H("recharts:LineChart", map[string]any{
+								"data":               cpuData,
+								"isAnimationActive":  false,
+							},
+								vdom.H("recharts:CartesianGrid", map[string]any{
+									"strokeDasharray": "3 3",
+									"stroke":          "#374151",
+								}),
+								vdom.H("recharts:XAxis", map[string]any{
+									"dataKey":  "timestamp",
+									"stroke":   "#9CA3AF",
+									"fontSize": 12,
+								}),
+								vdom.H("recharts:YAxis", map[string]any{
+									"domain":   []int{0, 100},
+									"stroke":   "#9CA3AF",
+									"fontSize": 12,
+								}),
+								vdom.H("recharts:Tooltip", map[string]any{
+									"labelStyle": map[string]any{
+										"color": "#374151",
+									},
+									"contentStyle": map[string]any{
+										"backgroundColor": "#1F2937",
+										"border":          "1px solid #374151",
+										"borderRadius":    "6px",
+										"color":           "#F3F4F6",
+									},
+								}),
+								vdom.H("recharts:Line", map[string]any{
+									"type":               "monotone",
+									"dataKey":            "cpuUsage",
+									"stroke":             "#3B82F6",
+									"strokeWidth":        2,
+									"dot":                false,
+									"name":               "CPU Usage (%)",
+									"isAnimationActive":  false,
+								}),
+							),
+						),
+					),
+				),
+
+				// Info section
+				vdom.H("div", map[string]any{
+					"className": "bg-blue-900 bg-opacity-50 border border-blue-700 rounded-lg p-4",
+				},
+					vdom.H("h3", map[string]any{
+						"className": "text-lg font-semibold text-blue-200 mb-2",
+					}, "Real-Time CPU Monitoring Features"),
+					vdom.H("ul", map[string]any{
+						"className": "space-y-2 text-blue-100",
+					},
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-400 mt-1",
+							}, "•"),
+							"Live CPU usage data collected using github.com/shirou/gopsutil/v4",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-400 mt-1",
+							}, "•"),
+							"Continuous monitoring with 1-second update intervals",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-400 mt-1",
+							}, "•"),
+							"Rolling window of 60 seconds of historical data",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-400 mt-1",
+							}, "•"),
+							"Real-time statistics: current, average, and peak usage",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-400 mt-1",
+							}, "•"),
+							"Dark theme optimized for Wave Terminal",
+						),
+					),
+				),
+			),
+		)
+	},
+)
diff --git a/tsunami/demo/cpuchart/go.mod b/tsunami/demo/cpuchart/go.mod
new file mode 100644
index 0000000000..a54289a76b
--- /dev/null
+++ b/tsunami/demo/cpuchart/go.mod
@@ -0,0 +1,22 @@
+module tsunami/app/cpuchart
+
+go 1.24.6
+
+require (
+	github.com/shirou/gopsutil/v4 v4.25.8
+	github.com/wavetermdev/waveterm/tsunami v0.0.0
+)
+
+require (
+	github.com/ebitengine/purego v0.8.4 // indirect
+	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect
+	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
+	github.com/tklauser/go-sysconf v0.3.15 // indirect
+	github.com/tklauser/numcpus v0.10.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
+	golang.org/x/sys v0.35.0 // indirect
+)
+
+replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/cpuchart/go.sum b/tsunami/demo/cpuchart/go.sum
new file mode 100644
index 0000000000..e3d3d7efce
--- /dev/null
+++ b/tsunami/demo/cpuchart/go.sum
@@ -0,0 +1,34 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/ebitengine/purego v0.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw=
+github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
+github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
+github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4=
+github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU=
+github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
+github.com/shirou/gopsutil/v4 v4.25.8 h1:NnAsw9lN7587WHxjJA9ryDnqhJpFH6A+wagYWTOH970=
+github.com/shirou/gopsutil/v4 v4.25.8/go.mod h1:q9QdMmfAOVIw7a+eF86P7ISEU6ka+NLgkUxlopV4RwI=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4=
+github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4=
+github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso=
+github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ=
+github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
+github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
+golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/tsunami/demo/cpuchart/static/tw.css b/tsunami/demo/cpuchart/static/tw.css
new file mode 100644
index 0000000000..9838118d47
--- /dev/null
+++ b/tsunami/demo/cpuchart/static/tw.css
@@ -0,0 +1,1312 @@
+/*! tailwindcss v4.1.13 | MIT License | https://tailwindcss.com */
+@layer properties;
+@layer theme, base, components, utilities;
+@layer theme {
+  :root, :host {
+    --font-sans: "Inter", sans-serif;
+    --font-mono: "Hack", monospace;
+    --color-red-400: oklch(70.4% 0.191 22.216);
+    --color-green-400: oklch(79.2% 0.209 151.711);
+    --color-green-500: oklch(72.3% 0.219 149.579);
+    --color-blue-100: oklch(93.2% 0.032 255.585);
+    --color-blue-200: oklch(88.2% 0.059 254.128);
+    --color-blue-400: oklch(70.7% 0.165 254.624);
+    --color-blue-700: oklch(48.8% 0.243 264.376);
+    --color-blue-900: oklch(37.9% 0.146 265.522);
+    --color-gray-400: oklch(70.7% 0.022 261.325);
+    --color-gray-500: oklch(55.1% 0.027 264.364);
+    --color-gray-600: oklch(44.6% 0.03 256.802);
+    --color-gray-700: oklch(37.3% 0.034 259.733);
+    --color-gray-800: oklch(27.8% 0.033 256.848);
+    --color-gray-900: oklch(21% 0.034 264.665);
+    --color-white: #fff;
+    --spacing: 0.25rem;
+    --container-6xl: 72rem;
+    --text-sm: 0.875rem;
+    --text-sm--line-height: calc(1.25 / 0.875);
+    --text-base: 1rem;
+    --text-base--line-height: calc(1.5 / 1);
+    --text-lg: 1.125rem;
+    --text-lg--line-height: calc(1.75 / 1.125);
+    --text-xl: 1.25rem;
+    --text-xl--line-height: calc(1.75 / 1.25);
+    --text-2xl: 1.5rem;
+    --text-2xl--line-height: calc(2 / 1.5);
+    --text-3xl: 1.875rem;
+    --text-3xl--line-height: calc(2.25 / 1.875);
+    --font-weight-medium: 500;
+    --font-weight-semibold: 600;
+    --font-weight-bold: 700;
+    --leading-relaxed: 1.625;
+    --radius-md: 0.375rem;
+    --radius-lg: 0.5rem;
+    --ease-in: cubic-bezier(0.4, 0, 1, 1);
+    --ease-out: cubic-bezier(0, 0, 0.2, 1);
+    --ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-transition-duration: 150ms;
+    --default-transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-font-family: var(--font-sans);
+    --default-mono-font-family: var(--font-mono);
+    --radius: 8px;
+    --color-background: rgb(34, 34, 34);
+    --color-primary: rgb(247, 247, 247);
+    --color-secondary: rgba(215, 218, 224, 0.7);
+    --color-muted: rgba(215, 218, 224, 0.5);
+    --color-accent-300: rgb(110, 231, 133);
+    --color-panel: rgba(255, 255, 255, 0.12);
+    --color-border: rgba(255, 255, 255, 0.16);
+    --color-accent: rgb(88, 193, 66);
+  }
+}
+@layer base {
+  *, ::after, ::before, ::backdrop, ::file-selector-button {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+    border: 0 solid;
+  }
+  html, :host {
+    line-height: 1.5;
+    -webkit-text-size-adjust: 100%;
+    tab-size: 4;
+    font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");
+    font-feature-settings: var(--default-font-feature-settings, normal);
+    font-variation-settings: var(--default-font-variation-settings, normal);
+    -webkit-tap-highlight-color: transparent;
+  }
+  hr {
+    height: 0;
+    color: inherit;
+    border-top-width: 1px;
+  }
+  abbr:where([title]) {
+    -webkit-text-decoration: underline dotted;
+    text-decoration: underline dotted;
+  }
+  h1, h2, h3, h4, h5, h6 {
+    font-size: inherit;
+    font-weight: inherit;
+  }
+  a {
+    color: inherit;
+    -webkit-text-decoration: inherit;
+    text-decoration: inherit;
+  }
+  b, strong {
+    font-weight: bolder;
+  }
+  code, kbd, samp, pre {
+    font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
+    font-feature-settings: var(--default-mono-font-feature-settings, normal);
+    font-variation-settings: var(--default-mono-font-variation-settings, normal);
+    font-size: 1em;
+  }
+  small {
+    font-size: 80%;
+  }
+  sub, sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+  }
+  sub {
+    bottom: -0.25em;
+  }
+  sup {
+    top: -0.5em;
+  }
+  table {
+    text-indent: 0;
+    border-color: inherit;
+    border-collapse: collapse;
+  }
+  :-moz-focusring {
+    outline: auto;
+  }
+  progress {
+    vertical-align: baseline;
+  }
+  summary {
+    display: list-item;
+  }
+  ol, ul, menu {
+    list-style: none;
+  }
+  img, svg, video, canvas, audio, iframe, embed, object {
+    display: block;
+    vertical-align: middle;
+  }
+  img, video {
+    max-width: 100%;
+    height: auto;
+  }
+  button, input, select, optgroup, textarea, ::file-selector-button {
+    font: inherit;
+    font-feature-settings: inherit;
+    font-variation-settings: inherit;
+    letter-spacing: inherit;
+    color: inherit;
+    border-radius: 0;
+    background-color: transparent;
+    opacity: 1;
+  }
+  :where(select:is([multiple], [size])) optgroup {
+    font-weight: bolder;
+  }
+  :where(select:is([multiple], [size])) optgroup option {
+    padding-inline-start: 20px;
+  }
+  ::file-selector-button {
+    margin-inline-end: 4px;
+  }
+  ::placeholder {
+    opacity: 1;
+  }
+  @supports (not (-webkit-appearance: -apple-pay-button))  or (contain-intrinsic-size: 1px) {
+    ::placeholder {
+      color: currentcolor;
+      @supports (color: color-mix(in lab, red, red)) {
+        color: color-mix(in oklab, currentcolor 50%, transparent);
+      }
+    }
+  }
+  textarea {
+    resize: vertical;
+  }
+  ::-webkit-search-decoration {
+    -webkit-appearance: none;
+  }
+  ::-webkit-date-and-time-value {
+    min-height: 1lh;
+    text-align: inherit;
+  }
+  ::-webkit-datetime-edit {
+    display: inline-flex;
+  }
+  ::-webkit-datetime-edit-fields-wrapper {
+    padding: 0;
+  }
+  ::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field {
+    padding-block: 0;
+  }
+  ::-webkit-calendar-picker-indicator {
+    line-height: 1;
+  }
+  :-moz-ui-invalid {
+    box-shadow: none;
+  }
+  button, input:where([type="button"], [type="reset"], [type="submit"]), ::file-selector-button {
+    appearance: button;
+  }
+  ::-webkit-inner-spin-button, ::-webkit-outer-spin-button {
+    height: auto;
+  }
+  [hidden]:where(:not([hidden="until-found"])) {
+    display: none !important;
+  }
+}
+@layer utilities {
+  .collapse {
+    visibility: collapse;
+  }
+  .invisible {
+    visibility: hidden;
+  }
+  .visible {
+    visibility: visible;
+  }
+  .sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border-width: 0;
+  }
+  .not-sr-only {
+    position: static;
+    width: auto;
+    height: auto;
+    padding: 0;
+    margin: 0;
+    overflow: visible;
+    clip-path: none;
+    white-space: normal;
+  }
+  .absolute {
+    position: absolute;
+  }
+  .fixed {
+    position: fixed;
+  }
+  .relative {
+    position: relative;
+  }
+  .static {
+    position: static;
+  }
+  .sticky {
+    position: sticky;
+  }
+  .-inset-1 {
+    inset: calc(var(--spacing) * -1);
+  }
+  .isolate {
+    isolation: isolate;
+  }
+  .isolation-auto {
+    isolation: auto;
+  }
+  .\!container {
+    width: 100% !important;
+    @media (width >= 40rem) {
+      max-width: 40rem !important;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem !important;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem !important;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem !important;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem !important;
+    }
+  }
+  .container {
+    width: 100%;
+    @media (width >= 40rem) {
+      max-width: 40rem;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem;
+    }
+  }
+  .mx-auto {
+    margin-inline: auto;
+  }
+  .my-6 {
+    margin-block: calc(var(--spacing) * 6);
+  }
+  .mt-1 {
+    margin-top: calc(var(--spacing) * 1);
+  }
+  .mt-3 {
+    margin-top: calc(var(--spacing) * 3);
+  }
+  .mt-4 {
+    margin-top: calc(var(--spacing) * 4);
+  }
+  .mt-5 {
+    margin-top: calc(var(--spacing) * 5);
+  }
+  .mt-6 {
+    margin-top: calc(var(--spacing) * 6);
+  }
+  .mb-1 {
+    margin-bottom: calc(var(--spacing) * 1);
+  }
+  .mb-2 {
+    margin-bottom: calc(var(--spacing) * 2);
+  }
+  .mb-3 {
+    margin-bottom: calc(var(--spacing) * 3);
+  }
+  .mb-4 {
+    margin-bottom: calc(var(--spacing) * 4);
+  }
+  .mb-6 {
+    margin-bottom: calc(var(--spacing) * 6);
+  }
+  .mb-8 {
+    margin-bottom: calc(var(--spacing) * 8);
+  }
+  .ml-2 {
+    margin-left: calc(var(--spacing) * 2);
+  }
+  .ml-4 {
+    margin-left: calc(var(--spacing) * 4);
+  }
+  .block {
+    display: block;
+  }
+  .contents {
+    display: contents;
+  }
+  .flex {
+    display: flex;
+  }
+  .flow-root {
+    display: flow-root;
+  }
+  .grid {
+    display: grid;
+  }
+  .hidden {
+    display: none;
+  }
+  .inline {
+    display: inline;
+  }
+  .inline-block {
+    display: inline-block;
+  }
+  .inline-flex {
+    display: inline-flex;
+  }
+  .inline-grid {
+    display: inline-grid;
+  }
+  .inline-table {
+    display: inline-table;
+  }
+  .list-item {
+    display: list-item;
+  }
+  .table {
+    display: table;
+  }
+  .table-caption {
+    display: table-caption;
+  }
+  .table-cell {
+    display: table-cell;
+  }
+  .table-column {
+    display: table-column;
+  }
+  .table-column-group {
+    display: table-column-group;
+  }
+  .table-footer-group {
+    display: table-footer-group;
+  }
+  .table-header-group {
+    display: table-header-group;
+  }
+  .table-row {
+    display: table-row;
+  }
+  .table-row-group {
+    display: table-row-group;
+  }
+  .h-2 {
+    height: calc(var(--spacing) * 2);
+  }
+  .h-96 {
+    height: calc(var(--spacing) * 96);
+  }
+  .min-h-full {
+    min-height: 100%;
+  }
+  .min-h-screen {
+    min-height: 100vh;
+  }
+  .w-2 {
+    width: calc(var(--spacing) * 2);
+  }
+  .w-full {
+    width: 100%;
+  }
+  .max-w-6xl {
+    max-width: var(--container-6xl);
+  }
+  .max-w-none {
+    max-width: none;
+  }
+  .min-w-full {
+    min-width: 100%;
+  }
+  .shrink {
+    flex-shrink: 1;
+  }
+  .grow {
+    flex-grow: 1;
+  }
+  .border-collapse {
+    border-collapse: collapse;
+  }
+  .translate-none {
+    translate: none;
+  }
+  .scale-3d {
+    scale: var(--tw-scale-x) var(--tw-scale-y) var(--tw-scale-z);
+  }
+  .transform {
+    transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,);
+  }
+  .cursor-pointer {
+    cursor: pointer;
+  }
+  .touch-pinch-zoom {
+    --tw-pinch-zoom: pinch-zoom;
+    touch-action: var(--tw-pan-x,) var(--tw-pan-y,) var(--tw-pinch-zoom,);
+  }
+  .resize {
+    resize: both;
+  }
+  .list-inside {
+    list-style-position: inside;
+  }
+  .list-decimal {
+    list-style-type: decimal;
+  }
+  .list-disc {
+    list-style-type: disc;
+  }
+  .grid-cols-3 {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+  .flex-wrap {
+    flex-wrap: wrap;
+  }
+  .items-center {
+    align-items: center;
+  }
+  .items-start {
+    align-items: flex-start;
+  }
+  .gap-2 {
+    gap: calc(var(--spacing) * 2);
+  }
+  .gap-4 {
+    gap: calc(var(--spacing) * 4);
+  }
+  .space-y-1 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-2 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 2) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 2) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 1;
+    }
+  }
+  .space-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-x-reverse: 1;
+    }
+  }
+  .divide-x {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 0;
+      border-inline-style: var(--tw-border-style);
+      border-inline-start-width: calc(1px * var(--tw-divide-x-reverse));
+      border-inline-end-width: calc(1px * calc(1 - var(--tw-divide-x-reverse)));
+    }
+  }
+  .divide-y {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 0;
+      border-bottom-style: var(--tw-border-style);
+      border-top-style: var(--tw-border-style);
+      border-top-width: calc(1px * var(--tw-divide-y-reverse));
+      border-bottom-width: calc(1px * calc(1 - var(--tw-divide-y-reverse)));
+    }
+  }
+  .divide-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 1;
+    }
+  }
+  .truncate {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+  .overflow-auto {
+    overflow: auto;
+  }
+  .overflow-x-auto {
+    overflow-x: auto;
+  }
+  .rounded {
+    border-radius: var(--radius);
+  }
+  .rounded-full {
+    border-radius: calc(infinity * 1px);
+  }
+  .rounded-lg {
+    border-radius: var(--radius-lg);
+  }
+  .rounded-md {
+    border-radius: var(--radius-md);
+  }
+  .rounded-s {
+    border-start-start-radius: var(--radius);
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-ss {
+    border-start-start-radius: var(--radius);
+  }
+  .rounded-e {
+    border-start-end-radius: var(--radius);
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-se {
+    border-start-end-radius: var(--radius);
+  }
+  .rounded-ee {
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-es {
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-t {
+    border-top-left-radius: var(--radius);
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-l {
+    border-top-left-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-tl {
+    border-top-left-radius: var(--radius);
+  }
+  .rounded-r {
+    border-top-right-radius: var(--radius);
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-tr {
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-b {
+    border-bottom-right-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-br {
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-bl {
+    border-bottom-left-radius: var(--radius);
+  }
+  .border {
+    border-style: var(--tw-border-style);
+    border-width: 1px;
+  }
+  .border-x {
+    border-inline-style: var(--tw-border-style);
+    border-inline-width: 1px;
+  }
+  .border-y {
+    border-block-style: var(--tw-border-style);
+    border-block-width: 1px;
+  }
+  .border-s {
+    border-inline-start-style: var(--tw-border-style);
+    border-inline-start-width: 1px;
+  }
+  .border-e {
+    border-inline-end-style: var(--tw-border-style);
+    border-inline-end-width: 1px;
+  }
+  .border-t {
+    border-top-style: var(--tw-border-style);
+    border-top-width: 1px;
+  }
+  .border-r {
+    border-right-style: var(--tw-border-style);
+    border-right-width: 1px;
+  }
+  .border-b {
+    border-bottom-style: var(--tw-border-style);
+    border-bottom-width: 1px;
+  }
+  .border-l {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 1px;
+  }
+  .border-l-4 {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 4px;
+  }
+  .border-blue-700 {
+    border-color: var(--color-blue-700);
+  }
+  .border-border {
+    border-color: var(--color-border);
+  }
+  .bg-background {
+    background-color: var(--color-background);
+  }
+  .bg-blue-900 {
+    background-color: var(--color-blue-900);
+  }
+  .bg-gray-600 {
+    background-color: var(--color-gray-600);
+  }
+  .bg-gray-700 {
+    background-color: var(--color-gray-700);
+  }
+  .bg-gray-800 {
+    background-color: var(--color-gray-800);
+  }
+  .bg-gray-900 {
+    background-color: var(--color-gray-900);
+  }
+  .bg-green-500 {
+    background-color: var(--color-green-500);
+  }
+  .bg-panel {
+    background-color: var(--color-panel);
+  }
+  .bg-repeat {
+    background-repeat: repeat;
+  }
+  .mask-no-clip {
+    mask-clip: no-clip;
+  }
+  .mask-repeat {
+    mask-repeat: repeat;
+  }
+  .p-3 {
+    padding: calc(var(--spacing) * 3);
+  }
+  .p-4 {
+    padding: calc(var(--spacing) * 4);
+  }
+  .p-6 {
+    padding: calc(var(--spacing) * 6);
+  }
+  .px-1 {
+    padding-inline: calc(var(--spacing) * 1);
+  }
+  .px-4 {
+    padding-inline: calc(var(--spacing) * 4);
+  }
+  .py-0\.5 {
+    padding-block: calc(var(--spacing) * 0.5);
+  }
+  .py-2 {
+    padding-block: calc(var(--spacing) * 2);
+  }
+  .pl-4 {
+    padding-left: calc(var(--spacing) * 4);
+  }
+  .text-left {
+    text-align: left;
+  }
+  .font-mono {
+    font-family: var(--font-mono);
+  }
+  .text-2xl {
+    font-size: var(--text-2xl);
+    line-height: var(--tw-leading, var(--text-2xl--line-height));
+  }
+  .text-3xl {
+    font-size: var(--text-3xl);
+    line-height: var(--tw-leading, var(--text-3xl--line-height));
+  }
+  .text-base {
+    font-size: var(--text-base);
+    line-height: var(--tw-leading, var(--text-base--line-height));
+  }
+  .text-lg {
+    font-size: var(--text-lg);
+    line-height: var(--tw-leading, var(--text-lg--line-height));
+  }
+  .text-sm {
+    font-size: var(--text-sm);
+    line-height: var(--tw-leading, var(--text-sm--line-height));
+  }
+  .text-xl {
+    font-size: var(--text-xl);
+    line-height: var(--tw-leading, var(--text-xl--line-height));
+  }
+  .leading-relaxed {
+    --tw-leading: var(--leading-relaxed);
+    line-height: var(--leading-relaxed);
+  }
+  .font-bold {
+    --tw-font-weight: var(--font-weight-bold);
+    font-weight: var(--font-weight-bold);
+  }
+  .font-medium {
+    --tw-font-weight: var(--font-weight-medium);
+    font-weight: var(--font-weight-medium);
+  }
+  .font-semibold {
+    --tw-font-weight: var(--font-weight-semibold);
+    font-weight: var(--font-weight-semibold);
+  }
+  .text-wrap {
+    text-wrap: wrap;
+  }
+  .text-clip {
+    text-overflow: clip;
+  }
+  .text-ellipsis {
+    text-overflow: ellipsis;
+  }
+  .text-accent {
+    color: var(--color-accent);
+  }
+  .text-blue-100 {
+    color: var(--color-blue-100);
+  }
+  .text-blue-200 {
+    color: var(--color-blue-200);
+  }
+  .text-blue-400 {
+    color: var(--color-blue-400);
+  }
+  .text-gray-400 {
+    color: var(--color-gray-400);
+  }
+  .text-gray-500 {
+    color: var(--color-gray-500);
+  }
+  .text-green-400 {
+    color: var(--color-green-400);
+  }
+  .text-muted {
+    color: var(--color-muted);
+  }
+  .text-primary {
+    color: var(--color-primary);
+  }
+  .text-red-400 {
+    color: var(--color-red-400);
+  }
+  .text-secondary {
+    color: var(--color-secondary);
+  }
+  .text-white {
+    color: var(--color-white);
+  }
+  .capitalize {
+    text-transform: capitalize;
+  }
+  .lowercase {
+    text-transform: lowercase;
+  }
+  .normal-case {
+    text-transform: none;
+  }
+  .uppercase {
+    text-transform: uppercase;
+  }
+  .italic {
+    font-style: italic;
+  }
+  .not-italic {
+    font-style: normal;
+  }
+  .diagonal-fractions {
+    --tw-numeric-fraction: diagonal-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .lining-nums {
+    --tw-numeric-figure: lining-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .oldstyle-nums {
+    --tw-numeric-figure: oldstyle-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .ordinal {
+    --tw-ordinal: ordinal;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .proportional-nums {
+    --tw-numeric-spacing: proportional-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .slashed-zero {
+    --tw-slashed-zero: slashed-zero;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .stacked-fractions {
+    --tw-numeric-fraction: stacked-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .tabular-nums {
+    --tw-numeric-spacing: tabular-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .normal-nums {
+    font-variant-numeric: normal;
+  }
+  .line-through {
+    text-decoration-line: line-through;
+  }
+  .no-underline {
+    text-decoration-line: none;
+  }
+  .overline {
+    text-decoration-line: overline;
+  }
+  .underline {
+    text-decoration-line: underline;
+  }
+  .antialiased {
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+  .subpixel-antialiased {
+    -webkit-font-smoothing: auto;
+    -moz-osx-font-smoothing: auto;
+  }
+  .shadow {
+    --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .ring {
+    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .inset-ring {
+    --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .outline {
+    outline-style: var(--tw-outline-style);
+    outline-width: 1px;
+  }
+  .blur {
+    --tw-blur: blur(8px);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .drop-shadow {
+    --tw-drop-shadow-size: drop-shadow(0 1px 2px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.1))) drop-shadow(0 1px 1px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.06)));
+    --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .grayscale {
+    --tw-grayscale: grayscale(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .invert {
+    --tw-invert: invert(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .sepia {
+    --tw-sepia: sepia(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .filter {
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .backdrop-blur {
+    --tw-backdrop-blur: blur(8px);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-grayscale {
+    --tw-backdrop-grayscale: grayscale(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-invert {
+    --tw-backdrop-invert: invert(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-sepia {
+    --tw-backdrop-sepia: sepia(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-filter {
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .transition {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .transition-colors {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .ease-in {
+    --tw-ease: var(--ease-in);
+    transition-timing-function: var(--ease-in);
+  }
+  .ease-in-out {
+    --tw-ease: var(--ease-in-out);
+    transition-timing-function: var(--ease-in-out);
+  }
+  .ease-out {
+    --tw-ease: var(--ease-out);
+    transition-timing-function: var(--ease-out);
+  }
+  .divide-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 1;
+    }
+  }
+  .ring-inset {
+    --tw-ring-inset: inset;
+  }
+  .hover\:bg-gray-700 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-gray-700);
+      }
+    }
+  }
+  .hover\:text-accent-300 {
+    &:hover {
+      @media (hover: hover) {
+        color: var(--color-accent-300);
+      }
+    }
+  }
+}
+@property --tw-scale-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-z {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-rotate-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-z {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pinch-zoom {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-space-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-space-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-divide-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-border-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-divide-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-leading {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-font-weight {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ordinal {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-slashed-zero {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-figure {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-spacing {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-fraction {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-inset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-ring-inset {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-offset-width {
+  syntax: "<length>";
+  inherits: false;
+  initial-value: 0px;
+}
+@property --tw-ring-offset-color {
+  syntax: "*";
+  inherits: false;
+  initial-value: #fff;
+}
+@property --tw-ring-offset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-outline-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-drop-shadow-size {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ease {
+  syntax: "*";
+  inherits: false;
+}
+@layer properties {
+  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
+    *, ::before, ::after, ::backdrop {
+      --tw-scale-x: 1;
+      --tw-scale-y: 1;
+      --tw-scale-z: 1;
+      --tw-rotate-x: initial;
+      --tw-rotate-y: initial;
+      --tw-rotate-z: initial;
+      --tw-skew-x: initial;
+      --tw-skew-y: initial;
+      --tw-pan-x: initial;
+      --tw-pan-y: initial;
+      --tw-pinch-zoom: initial;
+      --tw-space-y-reverse: 0;
+      --tw-space-x-reverse: 0;
+      --tw-divide-x-reverse: 0;
+      --tw-border-style: solid;
+      --tw-divide-y-reverse: 0;
+      --tw-leading: initial;
+      --tw-font-weight: initial;
+      --tw-ordinal: initial;
+      --tw-slashed-zero: initial;
+      --tw-numeric-figure: initial;
+      --tw-numeric-spacing: initial;
+      --tw-numeric-fraction: initial;
+      --tw-shadow: 0 0 #0000;
+      --tw-shadow-color: initial;
+      --tw-shadow-alpha: 100%;
+      --tw-inset-shadow: 0 0 #0000;
+      --tw-inset-shadow-color: initial;
+      --tw-inset-shadow-alpha: 100%;
+      --tw-ring-color: initial;
+      --tw-ring-shadow: 0 0 #0000;
+      --tw-inset-ring-color: initial;
+      --tw-inset-ring-shadow: 0 0 #0000;
+      --tw-ring-inset: initial;
+      --tw-ring-offset-width: 0px;
+      --tw-ring-offset-color: #fff;
+      --tw-ring-offset-shadow: 0 0 #0000;
+      --tw-outline-style: solid;
+      --tw-blur: initial;
+      --tw-brightness: initial;
+      --tw-contrast: initial;
+      --tw-grayscale: initial;
+      --tw-hue-rotate: initial;
+      --tw-invert: initial;
+      --tw-opacity: initial;
+      --tw-saturate: initial;
+      --tw-sepia: initial;
+      --tw-drop-shadow: initial;
+      --tw-drop-shadow-color: initial;
+      --tw-drop-shadow-alpha: 100%;
+      --tw-drop-shadow-size: initial;
+      --tw-backdrop-blur: initial;
+      --tw-backdrop-brightness: initial;
+      --tw-backdrop-contrast: initial;
+      --tw-backdrop-grayscale: initial;
+      --tw-backdrop-hue-rotate: initial;
+      --tw-backdrop-invert: initial;
+      --tw-backdrop-opacity: initial;
+      --tw-backdrop-saturate: initial;
+      --tw-backdrop-sepia: initial;
+      --tw-ease: initial;
+    }
+  }
+}
diff --git a/tsunami/demo/pomodoro/go.mod b/tsunami/demo/pomodoro/go.mod
new file mode 100644
index 0000000000..a4c46d73ca
--- /dev/null
+++ b/tsunami/demo/pomodoro/go.mod
@@ -0,0 +1,9 @@
+module tsunami/app/pomodoro
+
+go 1.24.6
+
+require github.com/wavetermdev/waveterm/tsunami v0.0.0
+
+require github.com/google/uuid v1.6.0 // indirect
+
+replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/pomodoro/go.sum b/tsunami/demo/pomodoro/go.sum
new file mode 100644
index 0000000000..7790d7c3e0
--- /dev/null
+++ b/tsunami/demo/pomodoro/go.sum
@@ -0,0 +1,2 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
diff --git a/tsunami/demo/pomodoro/static/tw.css b/tsunami/demo/pomodoro/static/tw.css
new file mode 100644
index 0000000000..f4663b3c96
--- /dev/null
+++ b/tsunami/demo/pomodoro/static/tw.css
@@ -0,0 +1,1276 @@
+/*! tailwindcss v4.1.13 | MIT License | https://tailwindcss.com */
+@layer properties;
+@layer theme, base, components, utilities;
+@layer theme {
+  :root, :host {
+    --font-sans: "Inter", sans-serif;
+    --font-mono: "Hack", monospace;
+    --color-green-500: oklch(72.3% 0.219 149.579);
+    --color-green-600: oklch(62.7% 0.194 149.214);
+    --color-blue-400: oklch(70.7% 0.165 254.624);
+    --color-blue-500: oklch(62.3% 0.214 259.815);
+    --color-blue-600: oklch(54.6% 0.245 262.881);
+    --color-slate-100: oklch(96.8% 0.007 247.896);
+    --color-slate-700: oklch(37.2% 0.044 257.287);
+    --color-slate-800: oklch(27.9% 0.041 260.031);
+    --color-white: #fff;
+    --spacing: 0.25rem;
+    --container-sm: 24rem;
+    --text-sm: 0.875rem;
+    --text-sm--line-height: calc(1.25 / 0.875);
+    --text-base: 1rem;
+    --text-base--line-height: calc(1.5 / 1);
+    --text-lg: 1.125rem;
+    --text-lg--line-height: calc(1.75 / 1.125);
+    --text-xl: 1.25rem;
+    --text-xl--line-height: calc(1.75 / 1.25);
+    --text-2xl: 1.5rem;
+    --text-2xl--line-height: calc(2 / 1.5);
+    --text-3xl: 1.875rem;
+    --text-3xl--line-height: calc(2.25 / 1.875);
+    --text-6xl: 3.75rem;
+    --text-6xl--line-height: 1;
+    --font-weight-bold: 700;
+    --leading-relaxed: 1.625;
+    --radius-lg: 0.5rem;
+    --radius-xl: 0.75rem;
+    --ease-in: cubic-bezier(0.4, 0, 1, 1);
+    --ease-out: cubic-bezier(0, 0, 0.2, 1);
+    --ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-transition-duration: 150ms;
+    --default-transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-font-family: var(--font-sans);
+    --default-mono-font-family: var(--font-mono);
+    --radius: 8px;
+    --color-background: rgb(34, 34, 34);
+    --color-primary: rgb(247, 247, 247);
+    --color-secondary: rgba(215, 218, 224, 0.7);
+    --color-muted: rgba(215, 218, 224, 0.5);
+    --color-accent-300: rgb(110, 231, 133);
+    --color-panel: rgba(255, 255, 255, 0.12);
+    --color-border: rgba(255, 255, 255, 0.16);
+    --color-accent: rgb(88, 193, 66);
+  }
+}
+@layer base {
+  *, ::after, ::before, ::backdrop, ::file-selector-button {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+    border: 0 solid;
+  }
+  html, :host {
+    line-height: 1.5;
+    -webkit-text-size-adjust: 100%;
+    tab-size: 4;
+    font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");
+    font-feature-settings: var(--default-font-feature-settings, normal);
+    font-variation-settings: var(--default-font-variation-settings, normal);
+    -webkit-tap-highlight-color: transparent;
+  }
+  hr {
+    height: 0;
+    color: inherit;
+    border-top-width: 1px;
+  }
+  abbr:where([title]) {
+    -webkit-text-decoration: underline dotted;
+    text-decoration: underline dotted;
+  }
+  h1, h2, h3, h4, h5, h6 {
+    font-size: inherit;
+    font-weight: inherit;
+  }
+  a {
+    color: inherit;
+    -webkit-text-decoration: inherit;
+    text-decoration: inherit;
+  }
+  b, strong {
+    font-weight: bolder;
+  }
+  code, kbd, samp, pre {
+    font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
+    font-feature-settings: var(--default-mono-font-feature-settings, normal);
+    font-variation-settings: var(--default-mono-font-variation-settings, normal);
+    font-size: 1em;
+  }
+  small {
+    font-size: 80%;
+  }
+  sub, sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+  }
+  sub {
+    bottom: -0.25em;
+  }
+  sup {
+    top: -0.5em;
+  }
+  table {
+    text-indent: 0;
+    border-color: inherit;
+    border-collapse: collapse;
+  }
+  :-moz-focusring {
+    outline: auto;
+  }
+  progress {
+    vertical-align: baseline;
+  }
+  summary {
+    display: list-item;
+  }
+  ol, ul, menu {
+    list-style: none;
+  }
+  img, svg, video, canvas, audio, iframe, embed, object {
+    display: block;
+    vertical-align: middle;
+  }
+  img, video {
+    max-width: 100%;
+    height: auto;
+  }
+  button, input, select, optgroup, textarea, ::file-selector-button {
+    font: inherit;
+    font-feature-settings: inherit;
+    font-variation-settings: inherit;
+    letter-spacing: inherit;
+    color: inherit;
+    border-radius: 0;
+    background-color: transparent;
+    opacity: 1;
+  }
+  :where(select:is([multiple], [size])) optgroup {
+    font-weight: bolder;
+  }
+  :where(select:is([multiple], [size])) optgroup option {
+    padding-inline-start: 20px;
+  }
+  ::file-selector-button {
+    margin-inline-end: 4px;
+  }
+  ::placeholder {
+    opacity: 1;
+  }
+  @supports (not (-webkit-appearance: -apple-pay-button))  or (contain-intrinsic-size: 1px) {
+    ::placeholder {
+      color: currentcolor;
+      @supports (color: color-mix(in lab, red, red)) {
+        color: color-mix(in oklab, currentcolor 50%, transparent);
+      }
+    }
+  }
+  textarea {
+    resize: vertical;
+  }
+  ::-webkit-search-decoration {
+    -webkit-appearance: none;
+  }
+  ::-webkit-date-and-time-value {
+    min-height: 1lh;
+    text-align: inherit;
+  }
+  ::-webkit-datetime-edit {
+    display: inline-flex;
+  }
+  ::-webkit-datetime-edit-fields-wrapper {
+    padding: 0;
+  }
+  ::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field {
+    padding-block: 0;
+  }
+  ::-webkit-calendar-picker-indicator {
+    line-height: 1;
+  }
+  :-moz-ui-invalid {
+    box-shadow: none;
+  }
+  button, input:where([type="button"], [type="reset"], [type="submit"]), ::file-selector-button {
+    appearance: button;
+  }
+  ::-webkit-inner-spin-button, ::-webkit-outer-spin-button {
+    height: auto;
+  }
+  [hidden]:where(:not([hidden="until-found"])) {
+    display: none !important;
+  }
+}
+@layer utilities {
+  .collapse {
+    visibility: collapse;
+  }
+  .invisible {
+    visibility: hidden;
+  }
+  .visible {
+    visibility: visible;
+  }
+  .sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border-width: 0;
+  }
+  .not-sr-only {
+    position: static;
+    width: auto;
+    height: auto;
+    padding: 0;
+    margin: 0;
+    overflow: visible;
+    clip-path: none;
+    white-space: normal;
+  }
+  .absolute {
+    position: absolute;
+  }
+  .fixed {
+    position: fixed;
+  }
+  .relative {
+    position: relative;
+  }
+  .static {
+    position: static;
+  }
+  .sticky {
+    position: sticky;
+  }
+  .-inset-1 {
+    inset: calc(var(--spacing) * -1);
+  }
+  .isolate {
+    isolation: isolate;
+  }
+  .isolation-auto {
+    isolation: auto;
+  }
+  .\!container {
+    width: 100% !important;
+    @media (width >= 40rem) {
+      max-width: 40rem !important;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem !important;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem !important;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem !important;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem !important;
+    }
+  }
+  .container {
+    width: 100%;
+    @media (width >= 40rem) {
+      max-width: 40rem;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem;
+    }
+  }
+  .mx-auto {
+    margin-inline: auto;
+  }
+  .my-6 {
+    margin-block: calc(var(--spacing) * 6);
+  }
+  .my-8 {
+    margin-block: calc(var(--spacing) * 8);
+  }
+  .mt-3 {
+    margin-top: calc(var(--spacing) * 3);
+  }
+  .mt-4 {
+    margin-top: calc(var(--spacing) * 4);
+  }
+  .mt-5 {
+    margin-top: calc(var(--spacing) * 5);
+  }
+  .mt-6 {
+    margin-top: calc(var(--spacing) * 6);
+  }
+  .mb-2 {
+    margin-bottom: calc(var(--spacing) * 2);
+  }
+  .mb-3 {
+    margin-bottom: calc(var(--spacing) * 3);
+  }
+  .mb-4 {
+    margin-bottom: calc(var(--spacing) * 4);
+  }
+  .mb-8 {
+    margin-bottom: calc(var(--spacing) * 8);
+  }
+  .ml-4 {
+    margin-left: calc(var(--spacing) * 4);
+  }
+  .block {
+    display: block;
+  }
+  .contents {
+    display: contents;
+  }
+  .flex {
+    display: flex;
+  }
+  .flow-root {
+    display: flow-root;
+  }
+  .grid {
+    display: grid;
+  }
+  .hidden {
+    display: none;
+  }
+  .inline {
+    display: inline;
+  }
+  .inline-block {
+    display: inline-block;
+  }
+  .inline-flex {
+    display: inline-flex;
+  }
+  .inline-grid {
+    display: inline-grid;
+  }
+  .inline-table {
+    display: inline-table;
+  }
+  .list-item {
+    display: list-item;
+  }
+  .table {
+    display: table;
+  }
+  .table-caption {
+    display: table-caption;
+  }
+  .table-cell {
+    display: table-cell;
+  }
+  .table-column {
+    display: table-column;
+  }
+  .table-column-group {
+    display: table-column-group;
+  }
+  .table-footer-group {
+    display: table-footer-group;
+  }
+  .table-header-group {
+    display: table-header-group;
+  }
+  .table-row {
+    display: table-row;
+  }
+  .table-row-group {
+    display: table-row-group;
+  }
+  .min-h-full {
+    min-height: 100%;
+  }
+  .min-h-screen {
+    min-height: 100vh;
+  }
+  .w-full {
+    width: 100%;
+  }
+  .max-w-none {
+    max-width: none;
+  }
+  .max-w-sm {
+    max-width: var(--container-sm);
+  }
+  .min-w-full {
+    min-width: 100%;
+  }
+  .flex-1 {
+    flex: 1;
+  }
+  .shrink {
+    flex-shrink: 1;
+  }
+  .grow {
+    flex-grow: 1;
+  }
+  .border-collapse {
+    border-collapse: collapse;
+  }
+  .translate-none {
+    translate: none;
+  }
+  .scale-3d {
+    scale: var(--tw-scale-x) var(--tw-scale-y) var(--tw-scale-z);
+  }
+  .transform {
+    transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,);
+  }
+  .cursor-pointer {
+    cursor: pointer;
+  }
+  .touch-pinch-zoom {
+    --tw-pinch-zoom: pinch-zoom;
+    touch-action: var(--tw-pan-x,) var(--tw-pan-y,) var(--tw-pinch-zoom,);
+  }
+  .resize {
+    resize: both;
+  }
+  .list-inside {
+    list-style-position: inside;
+  }
+  .list-decimal {
+    list-style-type: decimal;
+  }
+  .list-disc {
+    list-style-type: disc;
+  }
+  .flex-col {
+    flex-direction: column;
+  }
+  .flex-wrap {
+    flex-wrap: wrap;
+  }
+  .gap-4 {
+    gap: calc(var(--spacing) * 4);
+  }
+  .space-y-1 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 1;
+    }
+  }
+  .space-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-x-reverse: 1;
+    }
+  }
+  .divide-x {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 0;
+      border-inline-style: var(--tw-border-style);
+      border-inline-start-width: calc(1px * var(--tw-divide-x-reverse));
+      border-inline-end-width: calc(1px * calc(1 - var(--tw-divide-x-reverse)));
+    }
+  }
+  .divide-y {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 0;
+      border-bottom-style: var(--tw-border-style);
+      border-top-style: var(--tw-border-style);
+      border-top-width: calc(1px * var(--tw-divide-y-reverse));
+      border-bottom-width: calc(1px * calc(1 - var(--tw-divide-y-reverse)));
+    }
+  }
+  .divide-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 1;
+    }
+  }
+  .truncate {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+  .overflow-auto {
+    overflow: auto;
+  }
+  .overflow-x-auto {
+    overflow-x: auto;
+  }
+  .rounded {
+    border-radius: var(--radius);
+  }
+  .rounded-lg {
+    border-radius: var(--radius-lg);
+  }
+  .rounded-xl {
+    border-radius: var(--radius-xl);
+  }
+  .rounded-s {
+    border-start-start-radius: var(--radius);
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-ss {
+    border-start-start-radius: var(--radius);
+  }
+  .rounded-e {
+    border-start-end-radius: var(--radius);
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-se {
+    border-start-end-radius: var(--radius);
+  }
+  .rounded-ee {
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-es {
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-t {
+    border-top-left-radius: var(--radius);
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-l {
+    border-top-left-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-tl {
+    border-top-left-radius: var(--radius);
+  }
+  .rounded-r {
+    border-top-right-radius: var(--radius);
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-tr {
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-b {
+    border-bottom-right-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-br {
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-bl {
+    border-bottom-left-radius: var(--radius);
+  }
+  .border {
+    border-style: var(--tw-border-style);
+    border-width: 1px;
+  }
+  .border-x {
+    border-inline-style: var(--tw-border-style);
+    border-inline-width: 1px;
+  }
+  .border-y {
+    border-block-style: var(--tw-border-style);
+    border-block-width: 1px;
+  }
+  .border-s {
+    border-inline-start-style: var(--tw-border-style);
+    border-inline-start-width: 1px;
+  }
+  .border-e {
+    border-inline-end-style: var(--tw-border-style);
+    border-inline-end-width: 1px;
+  }
+  .border-t {
+    border-top-style: var(--tw-border-style);
+    border-top-width: 1px;
+  }
+  .border-r {
+    border-right-style: var(--tw-border-style);
+    border-right-width: 1px;
+  }
+  .border-b {
+    border-bottom-style: var(--tw-border-style);
+    border-bottom-width: 1px;
+  }
+  .border-l {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 1px;
+  }
+  .border-l-4 {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 4px;
+  }
+  .border-none {
+    --tw-border-style: none;
+    border-style: none;
+  }
+  .border-border {
+    border-color: var(--color-border);
+  }
+  .bg-background {
+    background-color: var(--color-background);
+  }
+  .bg-blue-500 {
+    background-color: var(--color-blue-500);
+  }
+  .bg-green-500 {
+    background-color: var(--color-green-500);
+  }
+  .bg-panel {
+    background-color: var(--color-panel);
+  }
+  .bg-slate-700 {
+    background-color: var(--color-slate-700);
+  }
+  .bg-slate-800 {
+    background-color: var(--color-slate-800);
+  }
+  .bg-repeat {
+    background-repeat: repeat;
+  }
+  .mask-no-clip {
+    mask-clip: no-clip;
+  }
+  .mask-repeat {
+    mask-repeat: repeat;
+  }
+  .p-4 {
+    padding: calc(var(--spacing) * 4);
+  }
+  .p-8 {
+    padding: calc(var(--spacing) * 8);
+  }
+  .px-1 {
+    padding-inline: calc(var(--spacing) * 1);
+  }
+  .px-3 {
+    padding-inline: calc(var(--spacing) * 3);
+  }
+  .px-4 {
+    padding-inline: calc(var(--spacing) * 4);
+  }
+  .px-6 {
+    padding-inline: calc(var(--spacing) * 6);
+  }
+  .py-0\.5 {
+    padding-block: calc(var(--spacing) * 0.5);
+  }
+  .py-2 {
+    padding-block: calc(var(--spacing) * 2);
+  }
+  .py-3 {
+    padding-block: calc(var(--spacing) * 3);
+  }
+  .pl-4 {
+    padding-left: calc(var(--spacing) * 4);
+  }
+  .text-center {
+    text-align: center;
+  }
+  .text-left {
+    text-align: left;
+  }
+  .font-mono {
+    font-family: var(--font-mono);
+  }
+  .font-sans {
+    font-family: var(--font-sans);
+  }
+  .text-2xl {
+    font-size: var(--text-2xl);
+    line-height: var(--tw-leading, var(--text-2xl--line-height));
+  }
+  .text-3xl {
+    font-size: var(--text-3xl);
+    line-height: var(--tw-leading, var(--text-3xl--line-height));
+  }
+  .text-6xl {
+    font-size: var(--text-6xl);
+    line-height: var(--tw-leading, var(--text-6xl--line-height));
+  }
+  .text-base {
+    font-size: var(--text-base);
+    line-height: var(--tw-leading, var(--text-base--line-height));
+  }
+  .text-lg {
+    font-size: var(--text-lg);
+    line-height: var(--tw-leading, var(--text-lg--line-height));
+  }
+  .text-sm {
+    font-size: var(--text-sm);
+    line-height: var(--tw-leading, var(--text-sm--line-height));
+  }
+  .text-xl {
+    font-size: var(--text-xl);
+    line-height: var(--tw-leading, var(--text-xl--line-height));
+  }
+  .leading-relaxed {
+    --tw-leading: var(--leading-relaxed);
+    line-height: var(--leading-relaxed);
+  }
+  .font-bold {
+    --tw-font-weight: var(--font-weight-bold);
+    font-weight: var(--font-weight-bold);
+  }
+  .text-wrap {
+    text-wrap: wrap;
+  }
+  .text-clip {
+    text-overflow: clip;
+  }
+  .text-ellipsis {
+    text-overflow: ellipsis;
+  }
+  .text-accent {
+    color: var(--color-accent);
+  }
+  .text-blue-400 {
+    color: var(--color-blue-400);
+  }
+  .text-muted {
+    color: var(--color-muted);
+  }
+  .text-primary {
+    color: var(--color-primary);
+  }
+  .text-secondary {
+    color: var(--color-secondary);
+  }
+  .text-slate-100 {
+    color: var(--color-slate-100);
+  }
+  .text-white {
+    color: var(--color-white);
+  }
+  .capitalize {
+    text-transform: capitalize;
+  }
+  .lowercase {
+    text-transform: lowercase;
+  }
+  .normal-case {
+    text-transform: none;
+  }
+  .uppercase {
+    text-transform: uppercase;
+  }
+  .italic {
+    font-style: italic;
+  }
+  .not-italic {
+    font-style: normal;
+  }
+  .diagonal-fractions {
+    --tw-numeric-fraction: diagonal-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .lining-nums {
+    --tw-numeric-figure: lining-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .oldstyle-nums {
+    --tw-numeric-figure: oldstyle-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .ordinal {
+    --tw-ordinal: ordinal;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .proportional-nums {
+    --tw-numeric-spacing: proportional-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .slashed-zero {
+    --tw-slashed-zero: slashed-zero;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .stacked-fractions {
+    --tw-numeric-fraction: stacked-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .tabular-nums {
+    --tw-numeric-spacing: tabular-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .normal-nums {
+    font-variant-numeric: normal;
+  }
+  .line-through {
+    text-decoration-line: line-through;
+  }
+  .no-underline {
+    text-decoration-line: none;
+  }
+  .overline {
+    text-decoration-line: overline;
+  }
+  .underline {
+    text-decoration-line: underline;
+  }
+  .antialiased {
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+  .subpixel-antialiased {
+    -webkit-font-smoothing: auto;
+    -moz-osx-font-smoothing: auto;
+  }
+  .shadow {
+    --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .ring {
+    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .inset-ring {
+    --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .outline {
+    outline-style: var(--tw-outline-style);
+    outline-width: 1px;
+  }
+  .blur {
+    --tw-blur: blur(8px);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .drop-shadow {
+    --tw-drop-shadow-size: drop-shadow(0 1px 2px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.1))) drop-shadow(0 1px 1px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.06)));
+    --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .grayscale {
+    --tw-grayscale: grayscale(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .invert {
+    --tw-invert: invert(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .sepia {
+    --tw-sepia: sepia(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .filter {
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .backdrop-blur {
+    --tw-backdrop-blur: blur(8px);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-grayscale {
+    --tw-backdrop-grayscale: grayscale(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-invert {
+    --tw-backdrop-invert: invert(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-sepia {
+    --tw-backdrop-sepia: sepia(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-filter {
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .transition {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .transition-colors {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .duration-200 {
+    --tw-duration: 200ms;
+    transition-duration: 200ms;
+  }
+  .ease-in {
+    --tw-ease: var(--ease-in);
+    transition-timing-function: var(--ease-in);
+  }
+  .ease-in-out {
+    --tw-ease: var(--ease-in-out);
+    transition-timing-function: var(--ease-in-out);
+  }
+  .ease-out {
+    --tw-ease: var(--ease-out);
+    transition-timing-function: var(--ease-out);
+  }
+  .divide-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 1;
+    }
+  }
+  .ring-inset {
+    --tw-ring-inset: inset;
+  }
+  .hover\:bg-blue-600 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-blue-600);
+      }
+    }
+  }
+  .hover\:bg-green-600 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-green-600);
+      }
+    }
+  }
+  .hover\:text-accent-300 {
+    &:hover {
+      @media (hover: hover) {
+        color: var(--color-accent-300);
+      }
+    }
+  }
+}
+@property --tw-scale-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-z {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-rotate-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-z {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pinch-zoom {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-space-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-space-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-divide-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-border-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-divide-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-leading {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-font-weight {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ordinal {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-slashed-zero {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-figure {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-spacing {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-fraction {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-inset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-ring-inset {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-offset-width {
+  syntax: "<length>";
+  inherits: false;
+  initial-value: 0px;
+}
+@property --tw-ring-offset-color {
+  syntax: "*";
+  inherits: false;
+  initial-value: #fff;
+}
+@property --tw-ring-offset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-outline-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-drop-shadow-size {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-duration {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ease {
+  syntax: "*";
+  inherits: false;
+}
+@layer properties {
+  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
+    *, ::before, ::after, ::backdrop {
+      --tw-scale-x: 1;
+      --tw-scale-y: 1;
+      --tw-scale-z: 1;
+      --tw-rotate-x: initial;
+      --tw-rotate-y: initial;
+      --tw-rotate-z: initial;
+      --tw-skew-x: initial;
+      --tw-skew-y: initial;
+      --tw-pan-x: initial;
+      --tw-pan-y: initial;
+      --tw-pinch-zoom: initial;
+      --tw-space-y-reverse: 0;
+      --tw-space-x-reverse: 0;
+      --tw-divide-x-reverse: 0;
+      --tw-border-style: solid;
+      --tw-divide-y-reverse: 0;
+      --tw-leading: initial;
+      --tw-font-weight: initial;
+      --tw-ordinal: initial;
+      --tw-slashed-zero: initial;
+      --tw-numeric-figure: initial;
+      --tw-numeric-spacing: initial;
+      --tw-numeric-fraction: initial;
+      --tw-shadow: 0 0 #0000;
+      --tw-shadow-color: initial;
+      --tw-shadow-alpha: 100%;
+      --tw-inset-shadow: 0 0 #0000;
+      --tw-inset-shadow-color: initial;
+      --tw-inset-shadow-alpha: 100%;
+      --tw-ring-color: initial;
+      --tw-ring-shadow: 0 0 #0000;
+      --tw-inset-ring-color: initial;
+      --tw-inset-ring-shadow: 0 0 #0000;
+      --tw-ring-inset: initial;
+      --tw-ring-offset-width: 0px;
+      --tw-ring-offset-color: #fff;
+      --tw-ring-offset-shadow: 0 0 #0000;
+      --tw-outline-style: solid;
+      --tw-blur: initial;
+      --tw-brightness: initial;
+      --tw-contrast: initial;
+      --tw-grayscale: initial;
+      --tw-hue-rotate: initial;
+      --tw-invert: initial;
+      --tw-opacity: initial;
+      --tw-saturate: initial;
+      --tw-sepia: initial;
+      --tw-drop-shadow: initial;
+      --tw-drop-shadow-color: initial;
+      --tw-drop-shadow-alpha: 100%;
+      --tw-drop-shadow-size: initial;
+      --tw-backdrop-blur: initial;
+      --tw-backdrop-brightness: initial;
+      --tw-backdrop-contrast: initial;
+      --tw-backdrop-grayscale: initial;
+      --tw-backdrop-hue-rotate: initial;
+      --tw-backdrop-invert: initial;
+      --tw-backdrop-opacity: initial;
+      --tw-backdrop-saturate: initial;
+      --tw-backdrop-sepia: initial;
+      --tw-duration: initial;
+      --tw-ease: initial;
+    }
+  }
+}
diff --git a/tsunami/demo/todo/go.mod b/tsunami/demo/todo/go.mod
new file mode 100644
index 0000000000..fd0c143085
--- /dev/null
+++ b/tsunami/demo/todo/go.mod
@@ -0,0 +1,9 @@
+module tsunami/app/todo
+
+go 1.24.6
+
+require github.com/wavetermdev/waveterm/tsunami v0.0.0
+
+require github.com/google/uuid v1.6.0 // indirect
+
+replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/todo/go.sum b/tsunami/demo/todo/go.sum
new file mode 100644
index 0000000000..7790d7c3e0
--- /dev/null
+++ b/tsunami/demo/todo/go.sum
@@ -0,0 +1,2 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
diff --git a/tsunami/demo/todo/static/tw.css b/tsunami/demo/todo/static/tw.css
new file mode 100644
index 0000000000..434fee658b
--- /dev/null
+++ b/tsunami/demo/todo/static/tw.css
@@ -0,0 +1,1213 @@
+/*! tailwindcss v4.1.13 | MIT License | https://tailwindcss.com */
+@layer properties;
+@layer theme, base, components, utilities;
+@layer theme {
+  :root, :host {
+    --font-sans: "Inter", sans-serif;
+    --font-mono: "Hack", monospace;
+    --color-red-500: oklch(63.7% 0.237 25.331);
+    --spacing: 0.25rem;
+    --text-sm: 0.875rem;
+    --text-sm--line-height: calc(1.25 / 0.875);
+    --text-base: 1rem;
+    --text-base--line-height: calc(1.5 / 1);
+    --text-lg: 1.125rem;
+    --text-lg--line-height: calc(1.75 / 1.125);
+    --text-xl: 1.25rem;
+    --text-xl--line-height: calc(1.75 / 1.25);
+    --text-2xl: 1.5rem;
+    --text-2xl--line-height: calc(2 / 1.5);
+    --text-3xl: 1.875rem;
+    --text-3xl--line-height: calc(2.25 / 1.875);
+    --font-weight-bold: 700;
+    --leading-relaxed: 1.625;
+    --radius-lg: 0.5rem;
+    --ease-in: cubic-bezier(0.4, 0, 1, 1);
+    --ease-out: cubic-bezier(0, 0, 0.2, 1);
+    --ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-transition-duration: 150ms;
+    --default-transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-font-family: var(--font-sans);
+    --default-mono-font-family: var(--font-mono);
+    --radius: 8px;
+    --color-background: rgb(34, 34, 34);
+    --color-primary: rgb(247, 247, 247);
+    --color-secondary: rgba(215, 218, 224, 0.7);
+    --color-muted: rgba(215, 218, 224, 0.5);
+    --color-accent-300: rgb(110, 231, 133);
+    --color-panel: rgba(255, 255, 255, 0.12);
+    --color-border: rgba(255, 255, 255, 0.16);
+    --color-accent: rgb(88, 193, 66);
+  }
+}
+@layer base {
+  *, ::after, ::before, ::backdrop, ::file-selector-button {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+    border: 0 solid;
+  }
+  html, :host {
+    line-height: 1.5;
+    -webkit-text-size-adjust: 100%;
+    tab-size: 4;
+    font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");
+    font-feature-settings: var(--default-font-feature-settings, normal);
+    font-variation-settings: var(--default-font-variation-settings, normal);
+    -webkit-tap-highlight-color: transparent;
+  }
+  hr {
+    height: 0;
+    color: inherit;
+    border-top-width: 1px;
+  }
+  abbr:where([title]) {
+    -webkit-text-decoration: underline dotted;
+    text-decoration: underline dotted;
+  }
+  h1, h2, h3, h4, h5, h6 {
+    font-size: inherit;
+    font-weight: inherit;
+  }
+  a {
+    color: inherit;
+    -webkit-text-decoration: inherit;
+    text-decoration: inherit;
+  }
+  b, strong {
+    font-weight: bolder;
+  }
+  code, kbd, samp, pre {
+    font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
+    font-feature-settings: var(--default-mono-font-feature-settings, normal);
+    font-variation-settings: var(--default-mono-font-variation-settings, normal);
+    font-size: 1em;
+  }
+  small {
+    font-size: 80%;
+  }
+  sub, sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+  }
+  sub {
+    bottom: -0.25em;
+  }
+  sup {
+    top: -0.5em;
+  }
+  table {
+    text-indent: 0;
+    border-color: inherit;
+    border-collapse: collapse;
+  }
+  :-moz-focusring {
+    outline: auto;
+  }
+  progress {
+    vertical-align: baseline;
+  }
+  summary {
+    display: list-item;
+  }
+  ol, ul, menu {
+    list-style: none;
+  }
+  img, svg, video, canvas, audio, iframe, embed, object {
+    display: block;
+    vertical-align: middle;
+  }
+  img, video {
+    max-width: 100%;
+    height: auto;
+  }
+  button, input, select, optgroup, textarea, ::file-selector-button {
+    font: inherit;
+    font-feature-settings: inherit;
+    font-variation-settings: inherit;
+    letter-spacing: inherit;
+    color: inherit;
+    border-radius: 0;
+    background-color: transparent;
+    opacity: 1;
+  }
+  :where(select:is([multiple], [size])) optgroup {
+    font-weight: bolder;
+  }
+  :where(select:is([multiple], [size])) optgroup option {
+    padding-inline-start: 20px;
+  }
+  ::file-selector-button {
+    margin-inline-end: 4px;
+  }
+  ::placeholder {
+    opacity: 1;
+  }
+  @supports (not (-webkit-appearance: -apple-pay-button))  or (contain-intrinsic-size: 1px) {
+    ::placeholder {
+      color: currentcolor;
+      @supports (color: color-mix(in lab, red, red)) {
+        color: color-mix(in oklab, currentcolor 50%, transparent);
+      }
+    }
+  }
+  textarea {
+    resize: vertical;
+  }
+  ::-webkit-search-decoration {
+    -webkit-appearance: none;
+  }
+  ::-webkit-date-and-time-value {
+    min-height: 1lh;
+    text-align: inherit;
+  }
+  ::-webkit-datetime-edit {
+    display: inline-flex;
+  }
+  ::-webkit-datetime-edit-fields-wrapper {
+    padding: 0;
+  }
+  ::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field {
+    padding-block: 0;
+  }
+  ::-webkit-calendar-picker-indicator {
+    line-height: 1;
+  }
+  :-moz-ui-invalid {
+    box-shadow: none;
+  }
+  button, input:where([type="button"], [type="reset"], [type="submit"]), ::file-selector-button {
+    appearance: button;
+  }
+  ::-webkit-inner-spin-button, ::-webkit-outer-spin-button {
+    height: auto;
+  }
+  [hidden]:where(:not([hidden="until-found"])) {
+    display: none !important;
+  }
+}
+@layer utilities {
+  .collapse {
+    visibility: collapse;
+  }
+  .invisible {
+    visibility: hidden;
+  }
+  .visible {
+    visibility: visible;
+  }
+  .sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border-width: 0;
+  }
+  .not-sr-only {
+    position: static;
+    width: auto;
+    height: auto;
+    padding: 0;
+    margin: 0;
+    overflow: visible;
+    clip-path: none;
+    white-space: normal;
+  }
+  .absolute {
+    position: absolute;
+  }
+  .fixed {
+    position: fixed;
+  }
+  .relative {
+    position: relative;
+  }
+  .static {
+    position: static;
+  }
+  .sticky {
+    position: sticky;
+  }
+  .-inset-1 {
+    inset: calc(var(--spacing) * -1);
+  }
+  .isolate {
+    isolation: isolate;
+  }
+  .isolation-auto {
+    isolation: auto;
+  }
+  .\!container {
+    width: 100% !important;
+    @media (width >= 40rem) {
+      max-width: 40rem !important;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem !important;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem !important;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem !important;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem !important;
+    }
+  }
+  .container {
+    width: 100%;
+    @media (width >= 40rem) {
+      max-width: 40rem;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem;
+    }
+  }
+  .m-5 {
+    margin: calc(var(--spacing) * 5);
+  }
+  .my-6 {
+    margin-block: calc(var(--spacing) * 6);
+  }
+  .mt-3 {
+    margin-top: calc(var(--spacing) * 3);
+  }
+  .mt-4 {
+    margin-top: calc(var(--spacing) * 4);
+  }
+  .mt-5 {
+    margin-top: calc(var(--spacing) * 5);
+  }
+  .mt-6 {
+    margin-top: calc(var(--spacing) * 6);
+  }
+  .mb-2 {
+    margin-bottom: calc(var(--spacing) * 2);
+  }
+  .mb-3 {
+    margin-bottom: calc(var(--spacing) * 3);
+  }
+  .mb-4 {
+    margin-bottom: calc(var(--spacing) * 4);
+  }
+  .mb-5 {
+    margin-bottom: calc(var(--spacing) * 5);
+  }
+  .ml-4 {
+    margin-left: calc(var(--spacing) * 4);
+  }
+  .block {
+    display: block;
+  }
+  .contents {
+    display: contents;
+  }
+  .flex {
+    display: flex;
+  }
+  .flow-root {
+    display: flow-root;
+  }
+  .grid {
+    display: grid;
+  }
+  .hidden {
+    display: none;
+  }
+  .inline {
+    display: inline;
+  }
+  .inline-block {
+    display: inline-block;
+  }
+  .inline-flex {
+    display: inline-flex;
+  }
+  .inline-grid {
+    display: inline-grid;
+  }
+  .inline-table {
+    display: inline-table;
+  }
+  .list-item {
+    display: list-item;
+  }
+  .table {
+    display: table;
+  }
+  .table-caption {
+    display: table-caption;
+  }
+  .table-cell {
+    display: table-cell;
+  }
+  .table-column {
+    display: table-column;
+  }
+  .table-column-group {
+    display: table-column-group;
+  }
+  .table-footer-group {
+    display: table-footer-group;
+  }
+  .table-header-group {
+    display: table-header-group;
+  }
+  .table-row {
+    display: table-row;
+  }
+  .table-row-group {
+    display: table-row-group;
+  }
+  .h-4 {
+    height: calc(var(--spacing) * 4);
+  }
+  .min-h-full {
+    min-height: 100%;
+  }
+  .min-h-screen {
+    min-height: 100vh;
+  }
+  .w-4 {
+    width: calc(var(--spacing) * 4);
+  }
+  .w-full {
+    width: 100%;
+  }
+  .max-w-\[500px\] {
+    max-width: 500px;
+  }
+  .max-w-none {
+    max-width: none;
+  }
+  .min-w-full {
+    min-width: 100%;
+  }
+  .flex-1 {
+    flex: 1;
+  }
+  .shrink {
+    flex-shrink: 1;
+  }
+  .grow {
+    flex-grow: 1;
+  }
+  .border-collapse {
+    border-collapse: collapse;
+  }
+  .translate-none {
+    translate: none;
+  }
+  .scale-3d {
+    scale: var(--tw-scale-x) var(--tw-scale-y) var(--tw-scale-z);
+  }
+  .transform {
+    transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,);
+  }
+  .cursor-pointer {
+    cursor: pointer;
+  }
+  .touch-pinch-zoom {
+    --tw-pinch-zoom: pinch-zoom;
+    touch-action: var(--tw-pan-x,) var(--tw-pan-y,) var(--tw-pinch-zoom,);
+  }
+  .resize {
+    resize: both;
+  }
+  .list-inside {
+    list-style-position: inside;
+  }
+  .list-decimal {
+    list-style-type: decimal;
+  }
+  .list-disc {
+    list-style-type: disc;
+  }
+  .flex-col {
+    flex-direction: column;
+  }
+  .flex-wrap {
+    flex-wrap: wrap;
+  }
+  .items-center {
+    align-items: center;
+  }
+  .gap-2 {
+    gap: calc(var(--spacing) * 2);
+  }
+  .gap-2\.5 {
+    gap: calc(var(--spacing) * 2.5);
+  }
+  .space-y-1 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 1;
+    }
+  }
+  .space-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-x-reverse: 1;
+    }
+  }
+  .divide-x {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 0;
+      border-inline-style: var(--tw-border-style);
+      border-inline-start-width: calc(1px * var(--tw-divide-x-reverse));
+      border-inline-end-width: calc(1px * calc(1 - var(--tw-divide-x-reverse)));
+    }
+  }
+  .divide-y {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 0;
+      border-bottom-style: var(--tw-border-style);
+      border-top-style: var(--tw-border-style);
+      border-top-width: calc(1px * var(--tw-divide-y-reverse));
+      border-bottom-width: calc(1px * calc(1 - var(--tw-divide-y-reverse)));
+    }
+  }
+  .divide-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 1;
+    }
+  }
+  .truncate {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+  .overflow-auto {
+    overflow: auto;
+  }
+  .overflow-x-auto {
+    overflow-x: auto;
+  }
+  .rounded {
+    border-radius: var(--radius);
+  }
+  .rounded-lg {
+    border-radius: var(--radius-lg);
+  }
+  .rounded-s {
+    border-start-start-radius: var(--radius);
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-ss {
+    border-start-start-radius: var(--radius);
+  }
+  .rounded-e {
+    border-start-end-radius: var(--radius);
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-se {
+    border-start-end-radius: var(--radius);
+  }
+  .rounded-ee {
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-es {
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-t {
+    border-top-left-radius: var(--radius);
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-l {
+    border-top-left-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-tl {
+    border-top-left-radius: var(--radius);
+  }
+  .rounded-r {
+    border-top-right-radius: var(--radius);
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-tr {
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-b {
+    border-bottom-right-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-br {
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-bl {
+    border-bottom-left-radius: var(--radius);
+  }
+  .border {
+    border-style: var(--tw-border-style);
+    border-width: 1px;
+  }
+  .border-x {
+    border-inline-style: var(--tw-border-style);
+    border-inline-width: 1px;
+  }
+  .border-y {
+    border-block-style: var(--tw-border-style);
+    border-block-width: 1px;
+  }
+  .border-s {
+    border-inline-start-style: var(--tw-border-style);
+    border-inline-start-width: 1px;
+  }
+  .border-e {
+    border-inline-end-style: var(--tw-border-style);
+    border-inline-end-width: 1px;
+  }
+  .border-t {
+    border-top-style: var(--tw-border-style);
+    border-top-width: 1px;
+  }
+  .border-r {
+    border-right-style: var(--tw-border-style);
+    border-right-width: 1px;
+  }
+  .border-b {
+    border-bottom-style: var(--tw-border-style);
+    border-bottom-width: 1px;
+  }
+  .border-l {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 1px;
+  }
+  .border-l-4 {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 4px;
+  }
+  .border-border {
+    border-color: var(--color-border);
+  }
+  .bg-background {
+    background-color: var(--color-background);
+  }
+  .bg-panel {
+    background-color: var(--color-panel);
+  }
+  .bg-repeat {
+    background-repeat: repeat;
+  }
+  .mask-no-clip {
+    mask-clip: no-clip;
+  }
+  .mask-repeat {
+    mask-repeat: repeat;
+  }
+  .p-2 {
+    padding: calc(var(--spacing) * 2);
+  }
+  .p-4 {
+    padding: calc(var(--spacing) * 4);
+  }
+  .px-1 {
+    padding-inline: calc(var(--spacing) * 1);
+  }
+  .px-2 {
+    padding-inline: calc(var(--spacing) * 2);
+  }
+  .px-4 {
+    padding-inline: calc(var(--spacing) * 4);
+  }
+  .py-0\.5 {
+    padding-block: calc(var(--spacing) * 0.5);
+  }
+  .py-1 {
+    padding-block: calc(var(--spacing) * 1);
+  }
+  .py-2 {
+    padding-block: calc(var(--spacing) * 2);
+  }
+  .pl-4 {
+    padding-left: calc(var(--spacing) * 4);
+  }
+  .text-left {
+    text-align: left;
+  }
+  .font-mono {
+    font-family: var(--font-mono);
+  }
+  .font-sans {
+    font-family: var(--font-sans);
+  }
+  .text-2xl {
+    font-size: var(--text-2xl);
+    line-height: var(--tw-leading, var(--text-2xl--line-height));
+  }
+  .text-3xl {
+    font-size: var(--text-3xl);
+    line-height: var(--tw-leading, var(--text-3xl--line-height));
+  }
+  .text-base {
+    font-size: var(--text-base);
+    line-height: var(--tw-leading, var(--text-base--line-height));
+  }
+  .text-lg {
+    font-size: var(--text-lg);
+    line-height: var(--tw-leading, var(--text-lg--line-height));
+  }
+  .text-sm {
+    font-size: var(--text-sm);
+    line-height: var(--tw-leading, var(--text-sm--line-height));
+  }
+  .text-xl {
+    font-size: var(--text-xl);
+    line-height: var(--tw-leading, var(--text-xl--line-height));
+  }
+  .leading-relaxed {
+    --tw-leading: var(--leading-relaxed);
+    line-height: var(--leading-relaxed);
+  }
+  .font-bold {
+    --tw-font-weight: var(--font-weight-bold);
+    font-weight: var(--font-weight-bold);
+  }
+  .text-wrap {
+    text-wrap: wrap;
+  }
+  .text-clip {
+    text-overflow: clip;
+  }
+  .text-ellipsis {
+    text-overflow: ellipsis;
+  }
+  .text-accent {
+    color: var(--color-accent);
+  }
+  .text-muted {
+    color: var(--color-muted);
+  }
+  .text-primary {
+    color: var(--color-primary);
+  }
+  .text-red-500 {
+    color: var(--color-red-500);
+  }
+  .text-secondary {
+    color: var(--color-secondary);
+  }
+  .capitalize {
+    text-transform: capitalize;
+  }
+  .lowercase {
+    text-transform: lowercase;
+  }
+  .normal-case {
+    text-transform: none;
+  }
+  .uppercase {
+    text-transform: uppercase;
+  }
+  .italic {
+    font-style: italic;
+  }
+  .not-italic {
+    font-style: normal;
+  }
+  .diagonal-fractions {
+    --tw-numeric-fraction: diagonal-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .lining-nums {
+    --tw-numeric-figure: lining-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .oldstyle-nums {
+    --tw-numeric-figure: oldstyle-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .ordinal {
+    --tw-ordinal: ordinal;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .proportional-nums {
+    --tw-numeric-spacing: proportional-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .slashed-zero {
+    --tw-slashed-zero: slashed-zero;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .stacked-fractions {
+    --tw-numeric-fraction: stacked-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .tabular-nums {
+    --tw-numeric-spacing: tabular-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .normal-nums {
+    font-variant-numeric: normal;
+  }
+  .line-through {
+    text-decoration-line: line-through;
+  }
+  .no-underline {
+    text-decoration-line: none;
+  }
+  .overline {
+    text-decoration-line: overline;
+  }
+  .underline {
+    text-decoration-line: underline;
+  }
+  .antialiased {
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+  .subpixel-antialiased {
+    -webkit-font-smoothing: auto;
+    -moz-osx-font-smoothing: auto;
+  }
+  .opacity-70 {
+    opacity: 70%;
+  }
+  .shadow {
+    --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .ring {
+    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .inset-ring {
+    --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .outline {
+    outline-style: var(--tw-outline-style);
+    outline-width: 1px;
+  }
+  .blur {
+    --tw-blur: blur(8px);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .drop-shadow {
+    --tw-drop-shadow-size: drop-shadow(0 1px 2px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.1))) drop-shadow(0 1px 1px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.06)));
+    --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .grayscale {
+    --tw-grayscale: grayscale(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .invert {
+    --tw-invert: invert(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .sepia {
+    --tw-sepia: sepia(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .filter {
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .backdrop-blur {
+    --tw-backdrop-blur: blur(8px);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-grayscale {
+    --tw-backdrop-grayscale: grayscale(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-invert {
+    --tw-backdrop-invert: invert(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-sepia {
+    --tw-backdrop-sepia: sepia(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-filter {
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .transition {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .ease-in {
+    --tw-ease: var(--ease-in);
+    transition-timing-function: var(--ease-in);
+  }
+  .ease-in-out {
+    --tw-ease: var(--ease-in-out);
+    transition-timing-function: var(--ease-in-out);
+  }
+  .ease-out {
+    --tw-ease: var(--ease-out);
+    transition-timing-function: var(--ease-out);
+  }
+  .divide-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 1;
+    }
+  }
+  .ring-inset {
+    --tw-ring-inset: inset;
+  }
+  .hover\:text-accent-300 {
+    &:hover {
+      @media (hover: hover) {
+        color: var(--color-accent-300);
+      }
+    }
+  }
+}
+@property --tw-scale-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-z {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-rotate-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-z {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pinch-zoom {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-space-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-space-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-divide-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-border-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-divide-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-leading {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-font-weight {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ordinal {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-slashed-zero {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-figure {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-spacing {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-fraction {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-inset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-ring-inset {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-offset-width {
+  syntax: "<length>";
+  inherits: false;
+  initial-value: 0px;
+}
+@property --tw-ring-offset-color {
+  syntax: "*";
+  inherits: false;
+  initial-value: #fff;
+}
+@property --tw-ring-offset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-outline-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-drop-shadow-size {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ease {
+  syntax: "*";
+  inherits: false;
+}
+@layer properties {
+  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
+    *, ::before, ::after, ::backdrop {
+      --tw-scale-x: 1;
+      --tw-scale-y: 1;
+      --tw-scale-z: 1;
+      --tw-rotate-x: initial;
+      --tw-rotate-y: initial;
+      --tw-rotate-z: initial;
+      --tw-skew-x: initial;
+      --tw-skew-y: initial;
+      --tw-pan-x: initial;
+      --tw-pan-y: initial;
+      --tw-pinch-zoom: initial;
+      --tw-space-y-reverse: 0;
+      --tw-space-x-reverse: 0;
+      --tw-divide-x-reverse: 0;
+      --tw-border-style: solid;
+      --tw-divide-y-reverse: 0;
+      --tw-leading: initial;
+      --tw-font-weight: initial;
+      --tw-ordinal: initial;
+      --tw-slashed-zero: initial;
+      --tw-numeric-figure: initial;
+      --tw-numeric-spacing: initial;
+      --tw-numeric-fraction: initial;
+      --tw-shadow: 0 0 #0000;
+      --tw-shadow-color: initial;
+      --tw-shadow-alpha: 100%;
+      --tw-inset-shadow: 0 0 #0000;
+      --tw-inset-shadow-color: initial;
+      --tw-inset-shadow-alpha: 100%;
+      --tw-ring-color: initial;
+      --tw-ring-shadow: 0 0 #0000;
+      --tw-inset-ring-color: initial;
+      --tw-inset-ring-shadow: 0 0 #0000;
+      --tw-ring-inset: initial;
+      --tw-ring-offset-width: 0px;
+      --tw-ring-offset-color: #fff;
+      --tw-ring-offset-shadow: 0 0 #0000;
+      --tw-outline-style: solid;
+      --tw-blur: initial;
+      --tw-brightness: initial;
+      --tw-contrast: initial;
+      --tw-grayscale: initial;
+      --tw-hue-rotate: initial;
+      --tw-invert: initial;
+      --tw-opacity: initial;
+      --tw-saturate: initial;
+      --tw-sepia: initial;
+      --tw-drop-shadow: initial;
+      --tw-drop-shadow-color: initial;
+      --tw-drop-shadow-alpha: 100%;
+      --tw-drop-shadow-size: initial;
+      --tw-backdrop-blur: initial;
+      --tw-backdrop-brightness: initial;
+      --tw-backdrop-contrast: initial;
+      --tw-backdrop-grayscale: initial;
+      --tw-backdrop-hue-rotate: initial;
+      --tw-backdrop-invert: initial;
+      --tw-backdrop-opacity: initial;
+      --tw-backdrop-saturate: initial;
+      --tw-backdrop-sepia: initial;
+      --tw-ease: initial;
+    }
+  }
+}
diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 3e09dfb0bc..4e3cab0646 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -326,7 +326,7 @@ This makes Tsunami applications naturally suitable for integration with external
 
 ## Style Handling
 
-Tsunami applications use Tailwind v4 CSS by default for styling (className prop) and you should favor styling with Tailwind whenever possible. However, you may also define inline styles using a map[string]any in the props:
+Tsunami applications use Tailwind v4 CSS by default for styling (className prop) and you should favor styling with Tailwind whenever possible. Also Tsunami Apps are built to run inside of Wave Terminal which is a dark mode application. Please create your styles in tailwind specifically to support DARK mode (so dark backgrounds and light text colors). You may also define inline styles using a map[string]any in the props:
 
 ```go
 vdom.H("div", map[string]any{
@@ -1000,6 +1000,7 @@ Key points:
 - `<script>` tags are NOT supported
 - Applications consist of a single file: app.go containing all Go code and component definitions
 - Styling is handled through Tailwind v4 CSS classes
+- Create Apps that work well in DARK mode (dark backgrounds, and light text)
 - Do NOT write a main() function - use init() for setup like dynamic handlers
 - This is a pure Go system - do not attempt to write React components or JavaScript code
 - All UI rendering, including complex visualizations, should be done through Go using vdom.H

From c2596cca178ad9c42653310e1197999e5be30f8d Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Fri, 5 Sep 2025 13:39:51 -0700
Subject: [PATCH 065/134] copy go.mod file

---
 tsunami/build/build.go | 57 ++++++++++++++++++++++++++++++++++--------
 1 file changed, 46 insertions(+), 11 deletions(-)

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index b0e4eeae83..1fdd14ce71 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -128,19 +128,54 @@ func verifyEnvironment(verbose bool) (*BuildEnv, error) {
 func createGoMod(tempDir, appDirName, goVersion string, opts BuildOpts, verbose bool) error {
 	modulePath := fmt.Sprintf("tsunami/app/%s", appDirName)
 
-	// Create new modfile
-	modFile := &modfile.File{}
-	if err := modFile.AddModuleStmt(modulePath); err != nil {
-		return fmt.Errorf("failed to add module statement: %w", err)
-	}
+	// Check if go.mod already exists in original directory
+	originalGoModPath := filepath.Join(opts.Dir, "go.mod")
+	var modFile *modfile.File
+	var err error
 
-	if err := modFile.AddGoStmt(goVersion); err != nil {
-		return fmt.Errorf("failed to add go version: %w", err)
-	}
+	if _, err := os.Stat(originalGoModPath); err == nil {
+		// go.mod exists, copy and parse it
+		if verbose {
+			log.Printf("Found existing go.mod, copying from %s", originalGoModPath)
+		}
+		
+		// Copy existing go.mod to temp directory
+		tempGoModPath := filepath.Join(tempDir, "go.mod")
+		if err := copyFile(originalGoModPath, tempGoModPath); err != nil {
+			return fmt.Errorf("failed to copy existing go.mod: %w", err)
+		}
+
+		// Parse the existing go.mod
+		goModContent, err := os.ReadFile(tempGoModPath)
+		if err != nil {
+			return fmt.Errorf("failed to read copied go.mod: %w", err)
+		}
+
+		modFile, err = modfile.Parse("go.mod", goModContent, nil)
+		if err != nil {
+			return fmt.Errorf("failed to parse existing go.mod: %w", err)
+		}
+	} else if os.IsNotExist(err) {
+		// go.mod doesn't exist, create new one
+		if verbose {
+			log.Printf("No existing go.mod found, creating new one")
+		}
+		
+		modFile = &modfile.File{}
+		if err := modFile.AddModuleStmt(modulePath); err != nil {
+			return fmt.Errorf("failed to add module statement: %w", err)
+		}
 
-	// Add requirement for tsunami SDK
-	if err := modFile.AddRequire("github.com/wavetermdev/waveterm/tsunami", "v0.0.0"); err != nil {
-		return fmt.Errorf("failed to add require directive: %w", err)
+		if err := modFile.AddGoStmt(goVersion); err != nil {
+			return fmt.Errorf("failed to add go version: %w", err)
+		}
+
+		// Add requirement for tsunami SDK
+		if err := modFile.AddRequire("github.com/wavetermdev/waveterm/tsunami", "v0.0.0"); err != nil {
+			return fmt.Errorf("failed to add require directive: %w", err)
+		}
+	} else {
+		return fmt.Errorf("error checking for existing go.mod: %w", err)
 	}
 
 	// Add replace directive for tsunami SDK

From a75e4748acdebd0bbfc666d8629f85ad6c076c10 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Fri, 5 Sep 2025 16:28:54 -0700
Subject: [PATCH 066/134] fix rendering bug

---
 tsunami/comp/rootelem.go | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index bf89c7c971..1795dae9c0 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -515,13 +515,13 @@ func convertPropsToVDom(props map[string]any) map[string]any {
 	return vdomProps
 }
 
-func convertBaseToVDom(c *ComponentImpl) *vdom.VDomElem {
+func (r *RootElem) convertBaseToVDom(c *ComponentImpl) *vdom.VDomElem {
 	elem := &vdom.VDomElem{WaveId: c.WaveId, Tag: c.Tag}
 	if c.Elem != nil {
 		elem.Props = convertPropsToVDom(c.Elem.Props)
 	}
 	for _, child := range c.Children {
-		childElem := convertCompToVDom(child)
+		childElem := r.convertCompToVDom(child)
 		if childElem != nil {
 			elem.Children = append(elem.Children, *childElem)
 		}
@@ -532,21 +532,26 @@ func convertBaseToVDom(c *ComponentImpl) *vdom.VDomElem {
 	return elem
 }
 
-func convertCompToVDom(c *ComponentImpl) *vdom.VDomElem {
+func (r *RootElem) convertCompToVDom(c *ComponentImpl) *vdom.VDomElem {
 	if c == nil {
 		return nil
 	}
 	if c.Comp != nil {
-		return convertCompToVDom(c.Comp)
+		return r.convertCompToVDom(c.Comp)
 	}
-	return convertBaseToVDom(c)
+	// If this is a registered component that was unmounted (c.Comp == nil) and has no children, return nil
+	// This prevents unmounted components from being serialized as their original tag names
+	if len(c.Children) == 0 && r.CFuncs[c.Tag] != nil {
+		return nil
+	}
+	return r.convertBaseToVDom(c)
 }
 
 func (r *RootElem) MakeVDom() *vdom.VDomElem {
 	if r.Root == nil {
 		return nil
 	}
-	return convertCompToVDom(r.Root)
+	return r.convertCompToVDom(r.Root)
 }
 
 func ConvertElemsToTransferElems(elems []vdom.VDomElem) []rpctypes.VDomTransferElem {

From bac641a9cf5d7b74b688a42a8ac36ca39721eba4 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Fri, 5 Sep 2025 16:46:47 -0700
Subject: [PATCH 067/134] tsunami config and githubactions monitor

---
 tsunami/demo/githubaction/app.go         |  452 +++++++
 tsunami/demo/githubaction/go.mod         |    9 +
 tsunami/demo/githubaction/go.sum         |    2 +
 tsunami/demo/githubaction/static/tw.css  | 1371 ++++++++++++++++++++++
 tsunami/demo/tsunamiconfig/app.go        |  368 ++++++
 tsunami/demo/tsunamiconfig/go.mod        |    9 +
 tsunami/demo/tsunamiconfig/go.sum        |    2 +
 tsunami/demo/tsunamiconfig/static/tw.css | 1320 +++++++++++++++++++++
 8 files changed, 3533 insertions(+)
 create mode 100644 tsunami/demo/githubaction/app.go
 create mode 100644 tsunami/demo/githubaction/go.mod
 create mode 100644 tsunami/demo/githubaction/go.sum
 create mode 100644 tsunami/demo/githubaction/static/tw.css
 create mode 100644 tsunami/demo/tsunamiconfig/app.go
 create mode 100644 tsunami/demo/tsunamiconfig/go.mod
 create mode 100644 tsunami/demo/tsunamiconfig/go.sum
 create mode 100644 tsunami/demo/tsunamiconfig/static/tw.css

diff --git a/tsunami/demo/githubaction/app.go b/tsunami/demo/githubaction/app.go
new file mode 100644
index 0000000000..0637ad6e14
--- /dev/null
+++ b/tsunami/demo/githubaction/app.go
@@ -0,0 +1,452 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"sort"
+	"strconv"
+	"time"
+
+	"github.com/wavetermdev/waveterm/tsunami/app"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+func init() {
+	app.SetConfig("pollInterval", 5)
+	app.SetConfig("repository", "wavetermdev/waveterm")
+	app.SetConfig("workflow", "build-helper.yml")
+	app.SetConfig("maxWorkflowRuns", 10)
+	app.SetData("workflowRuns", []WorkflowRun{})
+	app.SetData("lastError", "")
+	app.SetData("isLoading", true)
+	app.SetData("lastRefreshTime", time.Time{})
+}
+
+type WorkflowRun struct {
+	ID         int64     `json:"id"`
+	Name       string    `json:"name"`
+	Status     string    `json:"status"`
+	Conclusion string    `json:"conclusion"`
+	CreatedAt  time.Time `json:"created_at"`
+	UpdatedAt  time.Time `json:"updated_at"`
+	HTMLURL    string    `json:"html_url"`
+	RunNumber  int       `json:"run_number"`
+}
+
+type GitHubResponse struct {
+	TotalCount   int           `json:"total_count"`
+	WorkflowRuns []WorkflowRun `json:"workflow_runs"`
+}
+
+func fetchWorkflowRuns(repository, workflow string, maxRuns int) ([]WorkflowRun, error) {
+	apiKey := os.Getenv("GITHUB_APIKEY")
+	if apiKey == "" {
+		return nil, fmt.Errorf("GITHUB_APIKEY environment variable not set")
+	}
+
+	url := fmt.Sprintf("https://api.github.com/repos/%s/actions/workflows/%s/runs?per_page=%d", repository, workflow, maxRuns)
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Authorization", "Bearer "+apiKey)
+	req.Header.Set("Accept", "application/vnd.github.v3+json")
+	req.Header.Set("User-Agent", "WaveTerminal-GitHubMonitor")
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to make request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("GitHub API returned status %d: %s", resp.StatusCode, string(body))
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var response GitHubResponse
+	if err := json.Unmarshal(body, &response); err != nil {
+		return nil, fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	return response.WorkflowRuns, nil
+}
+
+func getStatusIcon(status, conclusion string) string {
+	switch status {
+	case "in_progress", "queued", "pending":
+		return "🔄"
+	case "completed":
+		switch conclusion {
+		case "success":
+			return "✅"
+		case "failure":
+			return "❌"
+		case "cancelled":
+			return "🚫"
+		case "skipped":
+			return "⏭️"
+		default:
+			return "❓"
+		}
+	default:
+		return "❓"
+	}
+}
+
+func getStatusColor(status, conclusion string) string {
+	switch status {
+	case "in_progress", "queued", "pending":
+		return "text-yellow-400"
+	case "completed":
+		switch conclusion {
+		case "success":
+			return "text-green-400"
+		case "failure":
+			return "text-red-400"
+		case "cancelled":
+			return "text-gray-400"
+		case "skipped":
+			return "text-blue-400"
+		default:
+			return "text-gray-400"
+		}
+	default:
+		return "text-gray-400"
+	}
+}
+
+func formatDuration(start, end time.Time, isRunning bool) string {
+	if isRunning {
+		duration := time.Since(start)
+		return fmt.Sprintf("%v (running)", duration.Round(time.Second))
+	}
+	if end.IsZero() {
+		return "Unknown"
+	}
+	duration := end.Sub(start)
+	return duration.Round(time.Second).String()
+}
+
+func getDisplayStatus(status, conclusion string) string {
+	switch status {
+	case "in_progress":
+		return "Running"
+	case "queued":
+		return "Queued"
+	case "pending":
+		return "Pending"
+	case "completed":
+		switch conclusion {
+		case "success":
+			return "Success"
+		case "failure":
+			return "Failed"
+		case "cancelled":
+			return "Cancelled"
+		case "skipped":
+			return "Skipped"
+		default:
+			return "Completed"
+		}
+	default:
+		return status
+	}
+}
+
+type WorkflowRunItemProps struct {
+	Run WorkflowRun `json:"run"`
+}
+
+var WorkflowRunItem = app.DefineComponent("WorkflowRunItem",
+	func(ctx context.Context, props WorkflowRunItemProps) any {
+		run := props.Run
+		isRunning := run.Status == "in_progress" || run.Status == "queued" || run.Status == "pending"
+
+		return vdom.H("div", map[string]any{
+			"className": "bg-gray-800 rounded-lg p-4 border border-gray-700 hover:border-gray-600 transition-colors",
+		},
+			vdom.H("div", map[string]any{
+				"className": "flex items-start justify-between",
+			},
+				vdom.H("div", map[string]any{
+					"className": "flex-1 min-w-0",
+				},
+					vdom.H("div", map[string]any{
+						"className": "flex items-center gap-3 mb-2",
+					},
+						vdom.H("span", map[string]any{
+							"className": "text-2xl",
+						}, getStatusIcon(run.Status, run.Conclusion)),
+						vdom.H("a", map[string]any{
+							"href":      run.HTMLURL,
+							"target":    "_blank",
+							"className": "font-semibold text-blue-400 hover:text-blue-300 cursor-pointer",
+						}, run.Name),
+						vdom.H("span", map[string]any{
+							"className": "text-sm text-gray-300",
+						}, "#", run.RunNumber),
+					),
+					vdom.H("div", map[string]any{
+						"className": "flex items-center gap-4 text-sm",
+					},
+						vdom.H("span", map[string]any{
+							"className": vdom.Classes("font-medium", getStatusColor(run.Status, run.Conclusion)),
+						}, getDisplayStatus(run.Status, run.Conclusion)),
+						vdom.H("span", map[string]any{
+							"className": "text-gray-400",
+						}, "Duration: ", formatDuration(run.CreatedAt, run.UpdatedAt, isRunning)),
+						vdom.H("span", map[string]any{
+							"className": "text-gray-300",
+						}, "Started: ", run.CreatedAt.Format("15:04:05")),
+					),
+				),
+			),
+		)
+	},
+)
+
+var App = app.DefineComponent("App",
+	func(ctx context.Context, _ struct{}) any {
+		vdom.UseSetAppTitle(ctx, "GitHub Actions Monitor")
+
+		workflowRuns, setWorkflowRuns, _ := vdom.UseData[[]WorkflowRun](ctx, "workflowRuns")
+		lastError, setLastError, _ := vdom.UseData[string](ctx, "lastError")
+		isLoading, setIsLoading, _ := vdom.UseData[bool](ctx, "isLoading")
+		lastRefreshTime, setLastRefreshTime, _ := vdom.UseData[time.Time](ctx, "lastRefreshTime")
+		pollInterval, _, _ := vdom.UseConfig[int](ctx, "pollInterval")
+		repository, _, _ := vdom.UseConfig[string](ctx, "repository")
+		workflow, _, _ := vdom.UseConfig[string](ctx, "workflow")
+		maxWorkflowRuns, _, _ := vdom.UseConfig[int](ctx, "maxWorkflowRuns")
+
+		_, _, setTickerFn := vdom.UseState[int](ctx, 0)
+
+		vdom.UseEffect(ctx, func() func() {
+			ticker := time.NewTicker(time.Duration(pollInterval) * time.Second)
+			done := make(chan bool)
+
+			fetchData := func() {
+				currentMaxRuns := app.GetConfig[int]("maxWorkflowRuns")
+				runs, err := fetchWorkflowRuns(repository, workflow, currentMaxRuns)
+				if err != nil {
+					log.Printf("Error fetching workflow runs: %v", err)
+					setLastError(err.Error())
+				} else {
+					sort.Slice(runs, func(i, j int) bool {
+						return runs[i].CreatedAt.After(runs[j].CreatedAt)
+					})
+					setWorkflowRuns(runs)
+					setLastError("")
+				}
+				setLastRefreshTime(time.Now())
+				setIsLoading(false)
+			}
+
+			fetchData()
+
+			go func() {
+				for {
+					select {
+					case <-done:
+						return
+					case <-ticker.C:
+						fetchData()
+						setTickerFn(func(t int) int { return t + 1 })
+						app.SendAsyncInitiation()
+					}
+				}
+			}()
+
+			return func() {
+				ticker.Stop()
+				close(done)
+			}
+		}, []any{pollInterval})
+
+		handleRefresh := func() {
+			setIsLoading(true)
+			go func() {
+				currentMaxRuns := app.GetConfig[int]("maxWorkflowRuns")
+				runs, err := fetchWorkflowRuns(repository, workflow, currentMaxRuns)
+				if err != nil {
+					log.Printf("Error fetching workflow runs: %v", err)
+					setLastError(err.Error())
+				} else {
+					sort.Slice(runs, func(i, j int) bool {
+						return runs[i].CreatedAt.After(runs[j].CreatedAt)
+					})
+					setWorkflowRuns(runs)
+					setLastError("")
+				}
+				setLastRefreshTime(time.Now())
+				setIsLoading(false)
+				app.SendAsyncInitiation()
+			}()
+		}
+
+		return vdom.H("div", map[string]any{
+			"className": "min-h-screen bg-gray-900 text-white p-6",
+		},
+			vdom.H("div", map[string]any{
+				"className": "max-w-6xl mx-auto",
+			},
+				vdom.H("div", map[string]any{
+					"className": "mb-8",
+				},
+					vdom.H("h1", map[string]any{
+						"className": "text-3xl font-bold text-white mb-2",
+					}, "GitHub Actions Monitor"),
+					vdom.H("p", map[string]any{
+						"className": "text-gray-400",
+					}, "Monitoring ", repository, " ", workflow, " workflow"),
+				),
+
+				vdom.H("div", map[string]any{
+					"className": "bg-gray-800 rounded-lg p-4 mb-6",
+				},
+					vdom.H("div", map[string]any{
+						"className": "flex items-center justify-between",
+					},
+						vdom.H("div", map[string]any{
+							"className": "flex items-center gap-4",
+						},
+							vdom.H("button", map[string]any{
+								"className": vdom.Classes(
+									"px-4 py-2 rounded-md text-sm font-medium transition-colors cursor-pointer",
+									vdom.IfElse(isLoading, "bg-gray-600 text-gray-400", "bg-blue-600 hover:bg-blue-700 text-white"),
+								),
+								"onClick":  vdom.If(!isLoading, handleRefresh),
+								"disabled": isLoading,
+							}, vdom.IfElse(isLoading, "Refreshing...", "Refresh")),
+
+							vdom.H("div", map[string]any{
+								"className": "flex items-center gap-2",
+							},
+								vdom.H("div", map[string]any{
+									"className": vdom.Classes("w-2 h-2 rounded-full", vdom.IfElse(lastError == "", "bg-green-500", "bg-red-500")),
+								}),
+								vdom.H("span", map[string]any{
+									"className": "text-sm text-gray-400",
+								}, vdom.IfElse(lastError == "", "Connected", "Error")),
+								vdom.H("span", map[string]any{
+									"className": "text-sm text-gray-300 ml-2",
+								}, "Poll interval: ", pollInterval, "s"),
+								vdom.If(!lastRefreshTime.IsZero(),
+									vdom.H("span", map[string]any{
+										"className": "text-sm text-gray-300 ml-4",
+									}, "Last refresh: ", lastRefreshTime.Format("15:04:05")),
+								),
+							),
+						),
+						vdom.H("div", map[string]any{
+							"className": "text-sm text-gray-300",
+						}, "Last ", maxWorkflowRuns, " workflow runs"),
+					),
+				),
+
+				vdom.If(lastError != "",
+					vdom.H("div", map[string]any{
+						"className": "bg-red-900 bg-opacity-50 border border-red-700 rounded-lg p-4 mb-6",
+					},
+						vdom.H("div", map[string]any{
+							"className": "flex items-center gap-2 text-red-200",
+						},
+							vdom.H("span", nil, "❌"),
+							vdom.H("strong", nil, "Error:"),
+						),
+						vdom.H("p", map[string]any{
+							"className": "text-red-100 mt-1",
+						}, lastError),
+					),
+				),
+
+				vdom.H("div", map[string]any{
+					"className": "space-y-4",
+				},
+					vdom.If(isLoading && len(workflowRuns) == 0,
+						vdom.H("div", map[string]any{
+							"className": "text-center py-8 text-gray-400",
+						}, "Loading workflow runs..."),
+					),
+					vdom.If(len(workflowRuns) > 0,
+						vdom.ForEach(workflowRuns, func(run WorkflowRun, idx int) any {
+							return WorkflowRunItem(WorkflowRunItemProps{
+								Run: run,
+							}).WithKey(strconv.FormatInt(run.ID, 10))
+						}),
+					),
+					vdom.If(!isLoading && len(workflowRuns) == 0 && lastError == "",
+						vdom.H("div", map[string]any{
+							"className": "text-center py-8 text-gray-400",
+						}, "No workflow runs found"),
+					),
+				),
+
+				vdom.H("div", map[string]any{
+					"className": "mt-8 bg-blue-900 bg-opacity-50 border border-blue-700 rounded-lg p-4",
+				},
+					vdom.H("h3", map[string]any{
+						"className": "text-lg font-semibold text-blue-200 mb-2",
+					}, "GitHub Actions Monitor Features"),
+					vdom.H("ul", map[string]any{
+						"className": "space-y-2 text-blue-100",
+					},
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-400 mt-1",
+							}, "•"),
+							"Monitors ", repository, " ", workflow, " workflow",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-400 mt-1",
+							}, "•"),
+							"Polls GitHub API every 5 seconds for real-time updates",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-400 mt-1",
+							}, "•"),
+							"Shows status icons: ✅ Success, ❌ Failure, 🔄 Running",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-400 mt-1",
+							}, "•"),
+							"Clickable workflow names open in GitHub (new tab)",
+						),
+						vdom.H("li", map[string]any{
+							"className": "flex items-start gap-2",
+						},
+							vdom.H("span", map[string]any{
+								"className": "text-blue-400 mt-1",
+							}, "•"),
+							"Live duration tracking for running jobs",
+						),
+					),
+				),
+			),
+		)
+	},
+)
diff --git a/tsunami/demo/githubaction/go.mod b/tsunami/demo/githubaction/go.mod
new file mode 100644
index 0000000000..30e86ad8cd
--- /dev/null
+++ b/tsunami/demo/githubaction/go.mod
@@ -0,0 +1,9 @@
+module tsunami/app/githubaction
+
+go 1.24.6
+
+require github.com/wavetermdev/waveterm/tsunami v0.0.0
+
+require github.com/google/uuid v1.6.0 // indirect
+
+replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/githubaction/go.sum b/tsunami/demo/githubaction/go.sum
new file mode 100644
index 0000000000..7790d7c3e0
--- /dev/null
+++ b/tsunami/demo/githubaction/go.sum
@@ -0,0 +1,2 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
diff --git a/tsunami/demo/githubaction/static/tw.css b/tsunami/demo/githubaction/static/tw.css
new file mode 100644
index 0000000000..21f779143b
--- /dev/null
+++ b/tsunami/demo/githubaction/static/tw.css
@@ -0,0 +1,1371 @@
+/*! tailwindcss v4.1.13 | MIT License | https://tailwindcss.com */
+@layer properties;
+@layer theme, base, components, utilities;
+@layer theme {
+  :root, :host {
+    --font-sans: "Inter", sans-serif;
+    --font-mono: "Hack", monospace;
+    --color-red-100: oklch(93.6% 0.032 17.717);
+    --color-red-200: oklch(88.5% 0.062 18.334);
+    --color-red-400: oklch(70.4% 0.191 22.216);
+    --color-red-500: oklch(63.7% 0.237 25.331);
+    --color-red-700: oklch(50.5% 0.213 27.518);
+    --color-red-900: oklch(39.6% 0.141 25.723);
+    --color-yellow-400: oklch(85.2% 0.199 91.936);
+    --color-green-400: oklch(79.2% 0.209 151.711);
+    --color-green-500: oklch(72.3% 0.219 149.579);
+    --color-blue-100: oklch(93.2% 0.032 255.585);
+    --color-blue-200: oklch(88.2% 0.059 254.128);
+    --color-blue-300: oklch(80.9% 0.105 251.813);
+    --color-blue-400: oklch(70.7% 0.165 254.624);
+    --color-blue-600: oklch(54.6% 0.245 262.881);
+    --color-blue-700: oklch(48.8% 0.243 264.376);
+    --color-blue-900: oklch(37.9% 0.146 265.522);
+    --color-gray-300: oklch(87.2% 0.01 258.338);
+    --color-gray-400: oklch(70.7% 0.022 261.325);
+    --color-gray-600: oklch(44.6% 0.03 256.802);
+    --color-gray-700: oklch(37.3% 0.034 259.733);
+    --color-gray-800: oklch(27.8% 0.033 256.848);
+    --color-gray-900: oklch(21% 0.034 264.665);
+    --color-white: #fff;
+    --spacing: 0.25rem;
+    --container-6xl: 72rem;
+    --text-sm: 0.875rem;
+    --text-sm--line-height: calc(1.25 / 0.875);
+    --text-base: 1rem;
+    --text-base--line-height: calc(1.5 / 1);
+    --text-lg: 1.125rem;
+    --text-lg--line-height: calc(1.75 / 1.125);
+    --text-xl: 1.25rem;
+    --text-xl--line-height: calc(1.75 / 1.25);
+    --text-2xl: 1.5rem;
+    --text-2xl--line-height: calc(2 / 1.5);
+    --text-3xl: 1.875rem;
+    --text-3xl--line-height: calc(2.25 / 1.875);
+    --font-weight-medium: 500;
+    --font-weight-semibold: 600;
+    --font-weight-bold: 700;
+    --leading-relaxed: 1.625;
+    --radius-md: 0.375rem;
+    --radius-lg: 0.5rem;
+    --ease-in: cubic-bezier(0.4, 0, 1, 1);
+    --ease-out: cubic-bezier(0, 0, 0.2, 1);
+    --ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-transition-duration: 150ms;
+    --default-transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-font-family: var(--font-sans);
+    --default-mono-font-family: var(--font-mono);
+    --radius: 8px;
+    --color-background: rgb(34, 34, 34);
+    --color-primary: rgb(247, 247, 247);
+    --color-secondary: rgba(215, 218, 224, 0.7);
+    --color-muted: rgba(215, 218, 224, 0.5);
+    --color-accent-300: rgb(110, 231, 133);
+    --color-panel: rgba(255, 255, 255, 0.12);
+    --color-border: rgba(255, 255, 255, 0.16);
+    --color-accent: rgb(88, 193, 66);
+  }
+}
+@layer base {
+  *, ::after, ::before, ::backdrop, ::file-selector-button {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+    border: 0 solid;
+  }
+  html, :host {
+    line-height: 1.5;
+    -webkit-text-size-adjust: 100%;
+    tab-size: 4;
+    font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");
+    font-feature-settings: var(--default-font-feature-settings, normal);
+    font-variation-settings: var(--default-font-variation-settings, normal);
+    -webkit-tap-highlight-color: transparent;
+  }
+  hr {
+    height: 0;
+    color: inherit;
+    border-top-width: 1px;
+  }
+  abbr:where([title]) {
+    -webkit-text-decoration: underline dotted;
+    text-decoration: underline dotted;
+  }
+  h1, h2, h3, h4, h5, h6 {
+    font-size: inherit;
+    font-weight: inherit;
+  }
+  a {
+    color: inherit;
+    -webkit-text-decoration: inherit;
+    text-decoration: inherit;
+  }
+  b, strong {
+    font-weight: bolder;
+  }
+  code, kbd, samp, pre {
+    font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
+    font-feature-settings: var(--default-mono-font-feature-settings, normal);
+    font-variation-settings: var(--default-mono-font-variation-settings, normal);
+    font-size: 1em;
+  }
+  small {
+    font-size: 80%;
+  }
+  sub, sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+  }
+  sub {
+    bottom: -0.25em;
+  }
+  sup {
+    top: -0.5em;
+  }
+  table {
+    text-indent: 0;
+    border-color: inherit;
+    border-collapse: collapse;
+  }
+  :-moz-focusring {
+    outline: auto;
+  }
+  progress {
+    vertical-align: baseline;
+  }
+  summary {
+    display: list-item;
+  }
+  ol, ul, menu {
+    list-style: none;
+  }
+  img, svg, video, canvas, audio, iframe, embed, object {
+    display: block;
+    vertical-align: middle;
+  }
+  img, video {
+    max-width: 100%;
+    height: auto;
+  }
+  button, input, select, optgroup, textarea, ::file-selector-button {
+    font: inherit;
+    font-feature-settings: inherit;
+    font-variation-settings: inherit;
+    letter-spacing: inherit;
+    color: inherit;
+    border-radius: 0;
+    background-color: transparent;
+    opacity: 1;
+  }
+  :where(select:is([multiple], [size])) optgroup {
+    font-weight: bolder;
+  }
+  :where(select:is([multiple], [size])) optgroup option {
+    padding-inline-start: 20px;
+  }
+  ::file-selector-button {
+    margin-inline-end: 4px;
+  }
+  ::placeholder {
+    opacity: 1;
+  }
+  @supports (not (-webkit-appearance: -apple-pay-button))  or (contain-intrinsic-size: 1px) {
+    ::placeholder {
+      color: currentcolor;
+      @supports (color: color-mix(in lab, red, red)) {
+        color: color-mix(in oklab, currentcolor 50%, transparent);
+      }
+    }
+  }
+  textarea {
+    resize: vertical;
+  }
+  ::-webkit-search-decoration {
+    -webkit-appearance: none;
+  }
+  ::-webkit-date-and-time-value {
+    min-height: 1lh;
+    text-align: inherit;
+  }
+  ::-webkit-datetime-edit {
+    display: inline-flex;
+  }
+  ::-webkit-datetime-edit-fields-wrapper {
+    padding: 0;
+  }
+  ::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field {
+    padding-block: 0;
+  }
+  ::-webkit-calendar-picker-indicator {
+    line-height: 1;
+  }
+  :-moz-ui-invalid {
+    box-shadow: none;
+  }
+  button, input:where([type="button"], [type="reset"], [type="submit"]), ::file-selector-button {
+    appearance: button;
+  }
+  ::-webkit-inner-spin-button, ::-webkit-outer-spin-button {
+    height: auto;
+  }
+  [hidden]:where(:not([hidden="until-found"])) {
+    display: none !important;
+  }
+}
+@layer utilities {
+  .collapse {
+    visibility: collapse;
+  }
+  .invisible {
+    visibility: hidden;
+  }
+  .visible {
+    visibility: visible;
+  }
+  .sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border-width: 0;
+  }
+  .not-sr-only {
+    position: static;
+    width: auto;
+    height: auto;
+    padding: 0;
+    margin: 0;
+    overflow: visible;
+    clip-path: none;
+    white-space: normal;
+  }
+  .absolute {
+    position: absolute;
+  }
+  .fixed {
+    position: fixed;
+  }
+  .relative {
+    position: relative;
+  }
+  .static {
+    position: static;
+  }
+  .sticky {
+    position: sticky;
+  }
+  .-inset-1 {
+    inset: calc(var(--spacing) * -1);
+  }
+  .isolate {
+    isolation: isolate;
+  }
+  .isolation-auto {
+    isolation: auto;
+  }
+  .\!container {
+    width: 100% !important;
+    @media (width >= 40rem) {
+      max-width: 40rem !important;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem !important;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem !important;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem !important;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem !important;
+    }
+  }
+  .container {
+    width: 100%;
+    @media (width >= 40rem) {
+      max-width: 40rem;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem;
+    }
+  }
+  .mx-auto {
+    margin-inline: auto;
+  }
+  .my-6 {
+    margin-block: calc(var(--spacing) * 6);
+  }
+  .mt-1 {
+    margin-top: calc(var(--spacing) * 1);
+  }
+  .mt-3 {
+    margin-top: calc(var(--spacing) * 3);
+  }
+  .mt-4 {
+    margin-top: calc(var(--spacing) * 4);
+  }
+  .mt-5 {
+    margin-top: calc(var(--spacing) * 5);
+  }
+  .mt-6 {
+    margin-top: calc(var(--spacing) * 6);
+  }
+  .mt-8 {
+    margin-top: calc(var(--spacing) * 8);
+  }
+  .mb-2 {
+    margin-bottom: calc(var(--spacing) * 2);
+  }
+  .mb-3 {
+    margin-bottom: calc(var(--spacing) * 3);
+  }
+  .mb-4 {
+    margin-bottom: calc(var(--spacing) * 4);
+  }
+  .mb-6 {
+    margin-bottom: calc(var(--spacing) * 6);
+  }
+  .mb-8 {
+    margin-bottom: calc(var(--spacing) * 8);
+  }
+  .ml-2 {
+    margin-left: calc(var(--spacing) * 2);
+  }
+  .ml-4 {
+    margin-left: calc(var(--spacing) * 4);
+  }
+  .block {
+    display: block;
+  }
+  .contents {
+    display: contents;
+  }
+  .flex {
+    display: flex;
+  }
+  .flow-root {
+    display: flow-root;
+  }
+  .grid {
+    display: grid;
+  }
+  .hidden {
+    display: none;
+  }
+  .inline {
+    display: inline;
+  }
+  .inline-block {
+    display: inline-block;
+  }
+  .inline-flex {
+    display: inline-flex;
+  }
+  .inline-grid {
+    display: inline-grid;
+  }
+  .inline-table {
+    display: inline-table;
+  }
+  .list-item {
+    display: list-item;
+  }
+  .table {
+    display: table;
+  }
+  .table-caption {
+    display: table-caption;
+  }
+  .table-cell {
+    display: table-cell;
+  }
+  .table-column {
+    display: table-column;
+  }
+  .table-column-group {
+    display: table-column-group;
+  }
+  .table-footer-group {
+    display: table-footer-group;
+  }
+  .table-header-group {
+    display: table-header-group;
+  }
+  .table-row {
+    display: table-row;
+  }
+  .table-row-group {
+    display: table-row-group;
+  }
+  .h-2 {
+    height: calc(var(--spacing) * 2);
+  }
+  .min-h-full {
+    min-height: 100%;
+  }
+  .min-h-screen {
+    min-height: 100vh;
+  }
+  .w-2 {
+    width: calc(var(--spacing) * 2);
+  }
+  .w-full {
+    width: 100%;
+  }
+  .max-w-6xl {
+    max-width: var(--container-6xl);
+  }
+  .max-w-none {
+    max-width: none;
+  }
+  .min-w-0 {
+    min-width: calc(var(--spacing) * 0);
+  }
+  .min-w-full {
+    min-width: 100%;
+  }
+  .flex-1 {
+    flex: 1;
+  }
+  .shrink {
+    flex-shrink: 1;
+  }
+  .grow {
+    flex-grow: 1;
+  }
+  .border-collapse {
+    border-collapse: collapse;
+  }
+  .translate-none {
+    translate: none;
+  }
+  .scale-3d {
+    scale: var(--tw-scale-x) var(--tw-scale-y) var(--tw-scale-z);
+  }
+  .transform {
+    transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,);
+  }
+  .cursor-pointer {
+    cursor: pointer;
+  }
+  .touch-pinch-zoom {
+    --tw-pinch-zoom: pinch-zoom;
+    touch-action: var(--tw-pan-x,) var(--tw-pan-y,) var(--tw-pinch-zoom,);
+  }
+  .resize {
+    resize: both;
+  }
+  .list-inside {
+    list-style-position: inside;
+  }
+  .list-decimal {
+    list-style-type: decimal;
+  }
+  .list-disc {
+    list-style-type: disc;
+  }
+  .flex-wrap {
+    flex-wrap: wrap;
+  }
+  .items-center {
+    align-items: center;
+  }
+  .items-start {
+    align-items: flex-start;
+  }
+  .justify-between {
+    justify-content: space-between;
+  }
+  .gap-2 {
+    gap: calc(var(--spacing) * 2);
+  }
+  .gap-3 {
+    gap: calc(var(--spacing) * 3);
+  }
+  .gap-4 {
+    gap: calc(var(--spacing) * 4);
+  }
+  .space-y-1 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-2 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 2) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 2) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-4 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 4) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 4) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 1;
+    }
+  }
+  .space-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-x-reverse: 1;
+    }
+  }
+  .divide-x {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 0;
+      border-inline-style: var(--tw-border-style);
+      border-inline-start-width: calc(1px * var(--tw-divide-x-reverse));
+      border-inline-end-width: calc(1px * calc(1 - var(--tw-divide-x-reverse)));
+    }
+  }
+  .divide-y {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 0;
+      border-bottom-style: var(--tw-border-style);
+      border-top-style: var(--tw-border-style);
+      border-top-width: calc(1px * var(--tw-divide-y-reverse));
+      border-bottom-width: calc(1px * calc(1 - var(--tw-divide-y-reverse)));
+    }
+  }
+  .divide-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 1;
+    }
+  }
+  .truncate {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+  .overflow-auto {
+    overflow: auto;
+  }
+  .overflow-x-auto {
+    overflow-x: auto;
+  }
+  .rounded {
+    border-radius: var(--radius);
+  }
+  .rounded-full {
+    border-radius: calc(infinity * 1px);
+  }
+  .rounded-lg {
+    border-radius: var(--radius-lg);
+  }
+  .rounded-md {
+    border-radius: var(--radius-md);
+  }
+  .rounded-s {
+    border-start-start-radius: var(--radius);
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-ss {
+    border-start-start-radius: var(--radius);
+  }
+  .rounded-e {
+    border-start-end-radius: var(--radius);
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-se {
+    border-start-end-radius: var(--radius);
+  }
+  .rounded-ee {
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-es {
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-t {
+    border-top-left-radius: var(--radius);
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-l {
+    border-top-left-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-tl {
+    border-top-left-radius: var(--radius);
+  }
+  .rounded-r {
+    border-top-right-radius: var(--radius);
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-tr {
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-b {
+    border-bottom-right-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-br {
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-bl {
+    border-bottom-left-radius: var(--radius);
+  }
+  .border {
+    border-style: var(--tw-border-style);
+    border-width: 1px;
+  }
+  .border-x {
+    border-inline-style: var(--tw-border-style);
+    border-inline-width: 1px;
+  }
+  .border-y {
+    border-block-style: var(--tw-border-style);
+    border-block-width: 1px;
+  }
+  .border-s {
+    border-inline-start-style: var(--tw-border-style);
+    border-inline-start-width: 1px;
+  }
+  .border-e {
+    border-inline-end-style: var(--tw-border-style);
+    border-inline-end-width: 1px;
+  }
+  .border-t {
+    border-top-style: var(--tw-border-style);
+    border-top-width: 1px;
+  }
+  .border-r {
+    border-right-style: var(--tw-border-style);
+    border-right-width: 1px;
+  }
+  .border-b {
+    border-bottom-style: var(--tw-border-style);
+    border-bottom-width: 1px;
+  }
+  .border-l {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 1px;
+  }
+  .border-l-4 {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 4px;
+  }
+  .border-blue-700 {
+    border-color: var(--color-blue-700);
+  }
+  .border-border {
+    border-color: var(--color-border);
+  }
+  .border-gray-700 {
+    border-color: var(--color-gray-700);
+  }
+  .border-red-700 {
+    border-color: var(--color-red-700);
+  }
+  .bg-background {
+    background-color: var(--color-background);
+  }
+  .bg-blue-600 {
+    background-color: var(--color-blue-600);
+  }
+  .bg-blue-900 {
+    background-color: var(--color-blue-900);
+  }
+  .bg-gray-600 {
+    background-color: var(--color-gray-600);
+  }
+  .bg-gray-800 {
+    background-color: var(--color-gray-800);
+  }
+  .bg-gray-900 {
+    background-color: var(--color-gray-900);
+  }
+  .bg-green-500 {
+    background-color: var(--color-green-500);
+  }
+  .bg-panel {
+    background-color: var(--color-panel);
+  }
+  .bg-red-500 {
+    background-color: var(--color-red-500);
+  }
+  .bg-red-900 {
+    background-color: var(--color-red-900);
+  }
+  .bg-repeat {
+    background-repeat: repeat;
+  }
+  .mask-no-clip {
+    mask-clip: no-clip;
+  }
+  .mask-repeat {
+    mask-repeat: repeat;
+  }
+  .p-4 {
+    padding: calc(var(--spacing) * 4);
+  }
+  .p-6 {
+    padding: calc(var(--spacing) * 6);
+  }
+  .px-1 {
+    padding-inline: calc(var(--spacing) * 1);
+  }
+  .px-4 {
+    padding-inline: calc(var(--spacing) * 4);
+  }
+  .py-0\.5 {
+    padding-block: calc(var(--spacing) * 0.5);
+  }
+  .py-2 {
+    padding-block: calc(var(--spacing) * 2);
+  }
+  .py-8 {
+    padding-block: calc(var(--spacing) * 8);
+  }
+  .pl-4 {
+    padding-left: calc(var(--spacing) * 4);
+  }
+  .text-center {
+    text-align: center;
+  }
+  .text-left {
+    text-align: left;
+  }
+  .font-mono {
+    font-family: var(--font-mono);
+  }
+  .text-2xl {
+    font-size: var(--text-2xl);
+    line-height: var(--tw-leading, var(--text-2xl--line-height));
+  }
+  .text-3xl {
+    font-size: var(--text-3xl);
+    line-height: var(--tw-leading, var(--text-3xl--line-height));
+  }
+  .text-base {
+    font-size: var(--text-base);
+    line-height: var(--tw-leading, var(--text-base--line-height));
+  }
+  .text-lg {
+    font-size: var(--text-lg);
+    line-height: var(--tw-leading, var(--text-lg--line-height));
+  }
+  .text-sm {
+    font-size: var(--text-sm);
+    line-height: var(--tw-leading, var(--text-sm--line-height));
+  }
+  .text-xl {
+    font-size: var(--text-xl);
+    line-height: var(--tw-leading, var(--text-xl--line-height));
+  }
+  .leading-relaxed {
+    --tw-leading: var(--leading-relaxed);
+    line-height: var(--leading-relaxed);
+  }
+  .font-bold {
+    --tw-font-weight: var(--font-weight-bold);
+    font-weight: var(--font-weight-bold);
+  }
+  .font-medium {
+    --tw-font-weight: var(--font-weight-medium);
+    font-weight: var(--font-weight-medium);
+  }
+  .font-semibold {
+    --tw-font-weight: var(--font-weight-semibold);
+    font-weight: var(--font-weight-semibold);
+  }
+  .text-wrap {
+    text-wrap: wrap;
+  }
+  .text-clip {
+    text-overflow: clip;
+  }
+  .text-ellipsis {
+    text-overflow: ellipsis;
+  }
+  .text-accent {
+    color: var(--color-accent);
+  }
+  .text-blue-100 {
+    color: var(--color-blue-100);
+  }
+  .text-blue-200 {
+    color: var(--color-blue-200);
+  }
+  .text-blue-400 {
+    color: var(--color-blue-400);
+  }
+  .text-gray-300 {
+    color: var(--color-gray-300);
+  }
+  .text-gray-400 {
+    color: var(--color-gray-400);
+  }
+  .text-green-400 {
+    color: var(--color-green-400);
+  }
+  .text-muted {
+    color: var(--color-muted);
+  }
+  .text-primary {
+    color: var(--color-primary);
+  }
+  .text-red-100 {
+    color: var(--color-red-100);
+  }
+  .text-red-200 {
+    color: var(--color-red-200);
+  }
+  .text-red-400 {
+    color: var(--color-red-400);
+  }
+  .text-secondary {
+    color: var(--color-secondary);
+  }
+  .text-white {
+    color: var(--color-white);
+  }
+  .text-yellow-400 {
+    color: var(--color-yellow-400);
+  }
+  .capitalize {
+    text-transform: capitalize;
+  }
+  .lowercase {
+    text-transform: lowercase;
+  }
+  .normal-case {
+    text-transform: none;
+  }
+  .uppercase {
+    text-transform: uppercase;
+  }
+  .italic {
+    font-style: italic;
+  }
+  .not-italic {
+    font-style: normal;
+  }
+  .diagonal-fractions {
+    --tw-numeric-fraction: diagonal-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .lining-nums {
+    --tw-numeric-figure: lining-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .oldstyle-nums {
+    --tw-numeric-figure: oldstyle-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .ordinal {
+    --tw-ordinal: ordinal;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .proportional-nums {
+    --tw-numeric-spacing: proportional-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .slashed-zero {
+    --tw-slashed-zero: slashed-zero;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .stacked-fractions {
+    --tw-numeric-fraction: stacked-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .tabular-nums {
+    --tw-numeric-spacing: tabular-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .normal-nums {
+    font-variant-numeric: normal;
+  }
+  .line-through {
+    text-decoration-line: line-through;
+  }
+  .no-underline {
+    text-decoration-line: none;
+  }
+  .overline {
+    text-decoration-line: overline;
+  }
+  .underline {
+    text-decoration-line: underline;
+  }
+  .antialiased {
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+  .subpixel-antialiased {
+    -webkit-font-smoothing: auto;
+    -moz-osx-font-smoothing: auto;
+  }
+  .shadow {
+    --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .ring {
+    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .inset-ring {
+    --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .outline {
+    outline-style: var(--tw-outline-style);
+    outline-width: 1px;
+  }
+  .blur {
+    --tw-blur: blur(8px);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .drop-shadow {
+    --tw-drop-shadow-size: drop-shadow(0 1px 2px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.1))) drop-shadow(0 1px 1px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.06)));
+    --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .grayscale {
+    --tw-grayscale: grayscale(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .invert {
+    --tw-invert: invert(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .sepia {
+    --tw-sepia: sepia(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .filter {
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .backdrop-blur {
+    --tw-backdrop-blur: blur(8px);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-grayscale {
+    --tw-backdrop-grayscale: grayscale(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-invert {
+    --tw-backdrop-invert: invert(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-sepia {
+    --tw-backdrop-sepia: sepia(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-filter {
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .transition {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .transition-colors {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .ease-in {
+    --tw-ease: var(--ease-in);
+    transition-timing-function: var(--ease-in);
+  }
+  .ease-in-out {
+    --tw-ease: var(--ease-in-out);
+    transition-timing-function: var(--ease-in-out);
+  }
+  .ease-out {
+    --tw-ease: var(--ease-out);
+    transition-timing-function: var(--ease-out);
+  }
+  .divide-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 1;
+    }
+  }
+  .ring-inset {
+    --tw-ring-inset: inset;
+  }
+  .hover\:border-gray-600 {
+    &:hover {
+      @media (hover: hover) {
+        border-color: var(--color-gray-600);
+      }
+    }
+  }
+  .hover\:bg-blue-700 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-blue-700);
+      }
+    }
+  }
+  .hover\:text-accent-300 {
+    &:hover {
+      @media (hover: hover) {
+        color: var(--color-accent-300);
+      }
+    }
+  }
+  .hover\:text-blue-300 {
+    &:hover {
+      @media (hover: hover) {
+        color: var(--color-blue-300);
+      }
+    }
+  }
+}
+@property --tw-scale-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-z {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-rotate-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-z {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pinch-zoom {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-space-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-space-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-divide-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-border-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-divide-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-leading {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-font-weight {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ordinal {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-slashed-zero {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-figure {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-spacing {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-fraction {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-inset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-ring-inset {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-offset-width {
+  syntax: "<length>";
+  inherits: false;
+  initial-value: 0px;
+}
+@property --tw-ring-offset-color {
+  syntax: "*";
+  inherits: false;
+  initial-value: #fff;
+}
+@property --tw-ring-offset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-outline-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-drop-shadow-size {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ease {
+  syntax: "*";
+  inherits: false;
+}
+@layer properties {
+  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
+    *, ::before, ::after, ::backdrop {
+      --tw-scale-x: 1;
+      --tw-scale-y: 1;
+      --tw-scale-z: 1;
+      --tw-rotate-x: initial;
+      --tw-rotate-y: initial;
+      --tw-rotate-z: initial;
+      --tw-skew-x: initial;
+      --tw-skew-y: initial;
+      --tw-pan-x: initial;
+      --tw-pan-y: initial;
+      --tw-pinch-zoom: initial;
+      --tw-space-y-reverse: 0;
+      --tw-space-x-reverse: 0;
+      --tw-divide-x-reverse: 0;
+      --tw-border-style: solid;
+      --tw-divide-y-reverse: 0;
+      --tw-leading: initial;
+      --tw-font-weight: initial;
+      --tw-ordinal: initial;
+      --tw-slashed-zero: initial;
+      --tw-numeric-figure: initial;
+      --tw-numeric-spacing: initial;
+      --tw-numeric-fraction: initial;
+      --tw-shadow: 0 0 #0000;
+      --tw-shadow-color: initial;
+      --tw-shadow-alpha: 100%;
+      --tw-inset-shadow: 0 0 #0000;
+      --tw-inset-shadow-color: initial;
+      --tw-inset-shadow-alpha: 100%;
+      --tw-ring-color: initial;
+      --tw-ring-shadow: 0 0 #0000;
+      --tw-inset-ring-color: initial;
+      --tw-inset-ring-shadow: 0 0 #0000;
+      --tw-ring-inset: initial;
+      --tw-ring-offset-width: 0px;
+      --tw-ring-offset-color: #fff;
+      --tw-ring-offset-shadow: 0 0 #0000;
+      --tw-outline-style: solid;
+      --tw-blur: initial;
+      --tw-brightness: initial;
+      --tw-contrast: initial;
+      --tw-grayscale: initial;
+      --tw-hue-rotate: initial;
+      --tw-invert: initial;
+      --tw-opacity: initial;
+      --tw-saturate: initial;
+      --tw-sepia: initial;
+      --tw-drop-shadow: initial;
+      --tw-drop-shadow-color: initial;
+      --tw-drop-shadow-alpha: 100%;
+      --tw-drop-shadow-size: initial;
+      --tw-backdrop-blur: initial;
+      --tw-backdrop-brightness: initial;
+      --tw-backdrop-contrast: initial;
+      --tw-backdrop-grayscale: initial;
+      --tw-backdrop-hue-rotate: initial;
+      --tw-backdrop-invert: initial;
+      --tw-backdrop-opacity: initial;
+      --tw-backdrop-saturate: initial;
+      --tw-backdrop-sepia: initial;
+      --tw-ease: initial;
+    }
+  }
+}
diff --git a/tsunami/demo/tsunamiconfig/app.go b/tsunami/demo/tsunamiconfig/app.go
new file mode 100644
index 0000000000..21c7ea1dea
--- /dev/null
+++ b/tsunami/demo/tsunamiconfig/app.go
@@ -0,0 +1,368 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/wavetermdev/waveterm/tsunami/app"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+type URLInputProps struct {
+	Value     string       `json:"value"`
+	OnChange  func(string) `json:"onChange"`
+	OnSubmit  func()       `json:"onSubmit"`
+	IsLoading bool         `json:"isLoading"`
+}
+
+type JSONEditorProps struct {
+	Value       string       `json:"value"`
+	OnChange    func(string) `json:"onChange"`
+	OnSubmit    func()       `json:"onSubmit"`
+	IsLoading   bool         `json:"isLoading"`
+	Placeholder string       `json:"placeholder"`
+}
+
+type ErrorDisplayProps struct {
+	Message string `json:"message"`
+}
+
+type SuccessDisplayProps struct {
+	Message string `json:"message"`
+}
+
+// parseURL takes flexible URL input and returns a normalized base URL
+func parseURL(input string) (string, error) {
+	if input == "" {
+		return "", fmt.Errorf("URL cannot be empty")
+	}
+
+	input = strings.TrimSpace(input)
+
+	// Handle just port number (e.g., "52848")
+	if portRegex := regexp.MustCompile(`^\d+$`); portRegex.MatchString(input) {
+		return fmt.Sprintf("http://localhost:%s", input), nil
+	}
+
+	// Add http:// if no protocol specified
+	if !strings.HasPrefix(input, "http://") && !strings.HasPrefix(input, "https://") {
+		input = "http://" + input
+	}
+
+	// Parse the URL to validate and extract components
+	parsedURL, err := url.Parse(input)
+	if err != nil {
+		return "", fmt.Errorf("invalid URL format: %v", err)
+	}
+
+	if parsedURL.Host == "" {
+		return "", fmt.Errorf("no host specified in URL")
+	}
+
+	// Return base URL (scheme + host)
+	baseURL := fmt.Sprintf("%s://%s", parsedURL.Scheme, parsedURL.Host)
+	return baseURL, nil
+}
+
+// fetchConfig fetches JSON from the /api/config endpoint
+func fetchConfig(baseURL string) (string, error) {
+	configURL := baseURL + "/api/config"
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Get(configURL)
+	if err != nil {
+		return "", fmt.Errorf("failed to connect to %s: %v", configURL, err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("server returned status %d from %s", resp.StatusCode, configURL)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read response: %v", err)
+	}
+
+	// Validate that it's valid JSON
+	var jsonObj interface{}
+	if err := json.Unmarshal(body, &jsonObj); err != nil {
+		return "", fmt.Errorf("response is not valid JSON: %v", err)
+	}
+
+	// Pretty print the JSON
+	prettyJSON, err := json.MarshalIndent(jsonObj, "", "  ")
+	if err != nil {
+		return "", fmt.Errorf("failed to format JSON: %v", err)
+	}
+
+	return string(prettyJSON), nil
+}
+
+// postConfig sends JSON to the /api/config endpoint
+func postConfig(baseURL, jsonContent string) error {
+	configURL := baseURL + "/api/config"
+
+	// Validate JSON before sending
+	var jsonObj interface{}
+	if err := json.Unmarshal([]byte(jsonContent), &jsonObj); err != nil {
+		return fmt.Errorf("invalid JSON: %v", err)
+	}
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Post(configURL, "application/json", strings.NewReader(jsonContent))
+	if err != nil {
+		return fmt.Errorf("failed to send request to %s: %v", configURL, err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("server returned status %d: %s", resp.StatusCode, string(body))
+	}
+
+	return nil
+}
+
+var URLInput = app.DefineComponent("URLInput",
+	func(ctx context.Context, props URLInputProps) any {
+		keyHandler := &vdom.VDomFunc{
+			Type: "func",
+			Fn: func(event vdom.VDomEvent) {
+				if !props.IsLoading {
+					props.OnSubmit()
+				}
+			},
+			Keys:           []string{"Enter"},
+			PreventDefault: true,
+		}
+
+		return vdom.H("div", map[string]any{
+			"className": "flex gap-2 mb-4",
+		},
+			vdom.H("input", map[string]any{
+				"className":   "flex-1 px-3 py-2 bg-slate-700 border border-slate-600 rounded text-slate-100 placeholder-slate-400 focus:outline-none focus:ring-2 focus:ring-blue-500",
+				"type":        "text",
+				"placeholder": "Enter URL (e.g., localhost:52848, http://localhost:52848/api/config, or just 52848)",
+				"value":       props.Value,
+				"disabled":    props.IsLoading,
+				"onChange": func(e vdom.VDomEvent) {
+					props.OnChange(e.TargetValue)
+				},
+				"onKeyDown": keyHandler,
+			}),
+			vdom.H("button", map[string]any{
+				"className": vdom.Classes(
+					"px-4 py-2 rounded font-medium cursor-pointer transition-colors",
+					vdom.IfElse(props.IsLoading,
+						"bg-slate-600 text-slate-400 cursor-not-allowed",
+						"bg-blue-600 text-white hover:bg-blue-700",
+					),
+				),
+				"onClick":  vdom.If(!props.IsLoading, props.OnSubmit),
+				"disabled": props.IsLoading,
+			}, vdom.IfElse(props.IsLoading, "Loading...", "Fetch")),
+		)
+	},
+)
+
+var JSONEditor = app.DefineComponent("JSONEditor",
+	func(ctx context.Context, props JSONEditorProps) any {
+		if props.Value == "" && props.Placeholder == "" {
+			return vdom.H("div", map[string]any{
+				"className": "text-slate-400 text-center py-8",
+			}, "Enter a URL above and click Fetch to load configuration")
+		}
+
+		return vdom.H("div", map[string]any{
+			"className": "flex flex-col",
+		},
+			vdom.H("textarea", map[string]any{
+				"className":   "w-full h-96 px-3 py-2 bg-slate-700 border border-slate-600 rounded text-slate-100 font-mono text-sm resize-y focus:outline-none focus:ring-2 focus:ring-blue-500",
+				"value":       props.Value,
+				"placeholder": props.Placeholder,
+				"disabled":    props.IsLoading,
+				"onChange": func(e vdom.VDomEvent) {
+					props.OnChange(e.TargetValue)
+				},
+			}),
+			vdom.If(props.Value != "",
+				vdom.H("button", map[string]any{
+					"className": vdom.Classes(
+						"mt-2 w-full py-2 rounded font-medium cursor-pointer transition-colors",
+						vdom.IfElse(props.IsLoading,
+							"bg-slate-600 text-slate-400 cursor-not-allowed",
+							"bg-green-600 text-white hover:bg-green-700",
+						),
+					),
+					"onClick":  vdom.If(!props.IsLoading, props.OnSubmit),
+					"disabled": props.IsLoading,
+				}, vdom.IfElse(props.IsLoading, "Submitting...", "Submit Changes")),
+			),
+		)
+	},
+)
+
+var ErrorDisplay = app.DefineComponent("ErrorDisplay",
+	func(ctx context.Context, props ErrorDisplayProps) any {
+		if props.Message == "" {
+			return nil
+		}
+
+		return vdom.H("div", map[string]any{
+			"className": "bg-red-900 border border-red-700 text-red-100 px-4 py-3 rounded mb-4",
+		},
+			vdom.H("div", map[string]any{
+				"className": "font-medium",
+			}, "Error"),
+			vdom.H("div", map[string]any{
+				"className": "text-sm mt-1",
+			}, props.Message),
+		)
+	},
+)
+
+var SuccessDisplay = app.DefineComponent("SuccessDisplay",
+	func(ctx context.Context, props SuccessDisplayProps) any {
+		if props.Message == "" {
+			return nil
+		}
+
+		return vdom.H("div", map[string]any{
+			"className": "bg-green-900 border border-green-700 text-green-100 px-4 py-3 rounded mb-4",
+		},
+			vdom.H("div", map[string]any{
+				"className": "font-medium",
+			}, "Success"),
+			vdom.H("div", map[string]any{
+				"className": "text-sm mt-1",
+			}, props.Message),
+		)
+	},
+)
+
+var App = app.DefineComponent("App",
+	func(ctx context.Context, _ any) any {
+		vdom.UseSetAppTitle(ctx, "Tsunami Config Manager")
+
+		// Use UseConfig for the URL input so it persists
+		urlInput, setURLInput, _ := vdom.UseConfig[string](ctx, "serverURL")
+		jsonContent, setJSONContent, _ := vdom.UseState(ctx, "")
+		errorMessage, setErrorMessage, _ := vdom.UseState(ctx, "")
+		successMessage, setSuccessMessage, _ := vdom.UseState(ctx, "")
+		isLoading, setIsLoading, _ := vdom.UseState(ctx, false)
+		lastFetch, setLastFetch, _ := vdom.UseState(ctx, "")
+		currentBaseURL, setCurrentBaseURL, _ := vdom.UseState(ctx, "")
+
+		clearMessages := func() {
+			setErrorMessage("")
+			setSuccessMessage("")
+		}
+
+		fetchConfigData := func() {
+			clearMessages()
+
+			baseURL, err := parseURL(urlInput)
+			if err != nil {
+				setErrorMessage(err.Error())
+				return
+			}
+
+			setIsLoading(true)
+			setCurrentBaseURL(baseURL)
+
+			go func() {
+				defer func() {
+					setIsLoading(false)
+					app.SendAsyncInitiation()
+				}()
+
+				content, err := fetchConfig(baseURL)
+				if err != nil {
+					setErrorMessage(err.Error())
+					return
+				}
+
+				setJSONContent(content)
+				setLastFetch(time.Now().Format("2006-01-02 15:04:05"))
+				setSuccessMessage(fmt.Sprintf("Successfully fetched config from %s", baseURL))
+			}()
+		}
+
+		submitConfigData := func() {
+			if currentBaseURL == "" {
+				setErrorMessage("No base URL available. Please fetch config first.")
+				return
+			}
+
+			clearMessages()
+			setIsLoading(true)
+
+			go func() {
+				defer func() {
+					setIsLoading(false)
+					app.SendAsyncInitiation()
+				}()
+
+				err := postConfig(currentBaseURL, jsonContent)
+				if err != nil {
+					setErrorMessage(fmt.Sprintf("Failed to submit config: %v", err))
+					return
+				}
+
+				setSuccessMessage(fmt.Sprintf("Successfully submitted config to %s", currentBaseURL))
+			}()
+		}
+
+		return vdom.H("div", map[string]any{
+			"className": "max-w-4xl mx-auto p-6 bg-slate-800 text-slate-100 min-h-screen",
+		},
+			vdom.H("div", map[string]any{
+				"className": "mb-6",
+			},
+				vdom.H("h1", map[string]any{
+					"className": "text-3xl font-bold mb-2",
+				}, "Tsunami Config Manager"),
+				vdom.H("p", map[string]any{
+					"className": "text-slate-400",
+				}, "Fetch and edit configuration from remote servers"),
+			),
+
+			URLInput(URLInputProps{
+				Value:     urlInput,
+				OnChange:  setURLInput,
+				OnSubmit:  fetchConfigData,
+				IsLoading: isLoading,
+			}),
+
+			ErrorDisplay(ErrorDisplayProps{
+				Message: errorMessage,
+			}),
+
+			SuccessDisplay(SuccessDisplayProps{
+				Message: successMessage,
+			}),
+
+			vdom.If(lastFetch != "",
+				vdom.H("div", map[string]any{
+					"className": "text-sm text-slate-400 mb-4",
+				}, fmt.Sprintf("Last fetched: %s from %s", lastFetch, currentBaseURL)),
+			),
+
+			JSONEditor(JSONEditorProps{
+				Value:       jsonContent,
+				OnChange:    setJSONContent,
+				OnSubmit:    submitConfigData,
+				IsLoading:   isLoading,
+				Placeholder: "JSON configuration will appear here after fetching...",
+			}),
+		)
+	},
+)
diff --git a/tsunami/demo/tsunamiconfig/go.mod b/tsunami/demo/tsunamiconfig/go.mod
new file mode 100644
index 0000000000..940686f31d
--- /dev/null
+++ b/tsunami/demo/tsunamiconfig/go.mod
@@ -0,0 +1,9 @@
+module tsunami/app/tsunamiconfig
+
+go 1.24.6
+
+require github.com/wavetermdev/waveterm/tsunami v0.0.0
+
+require github.com/google/uuid v1.6.0 // indirect
+
+replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/tsunamiconfig/go.sum b/tsunami/demo/tsunamiconfig/go.sum
new file mode 100644
index 0000000000..7790d7c3e0
--- /dev/null
+++ b/tsunami/demo/tsunamiconfig/go.sum
@@ -0,0 +1,2 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
diff --git a/tsunami/demo/tsunamiconfig/static/tw.css b/tsunami/demo/tsunamiconfig/static/tw.css
new file mode 100644
index 0000000000..a989fdd0df
--- /dev/null
+++ b/tsunami/demo/tsunamiconfig/static/tw.css
@@ -0,0 +1,1320 @@
+/*! tailwindcss v4.1.13 | MIT License | https://tailwindcss.com */
+@layer properties;
+@layer theme, base, components, utilities;
+@layer theme {
+  :root, :host {
+    --font-sans: "Inter", sans-serif;
+    --font-mono: "Hack", monospace;
+    --color-red-100: oklch(93.6% 0.032 17.717);
+    --color-red-700: oklch(50.5% 0.213 27.518);
+    --color-red-900: oklch(39.6% 0.141 25.723);
+    --color-green-100: oklch(96.2% 0.044 156.743);
+    --color-green-600: oklch(62.7% 0.194 149.214);
+    --color-green-700: oklch(52.7% 0.154 150.069);
+    --color-green-900: oklch(39.3% 0.095 152.535);
+    --color-blue-500: oklch(62.3% 0.214 259.815);
+    --color-blue-600: oklch(54.6% 0.245 262.881);
+    --color-blue-700: oklch(48.8% 0.243 264.376);
+    --color-slate-100: oklch(96.8% 0.007 247.896);
+    --color-slate-400: oklch(70.4% 0.04 256.788);
+    --color-slate-600: oklch(44.6% 0.043 257.281);
+    --color-slate-700: oklch(37.2% 0.044 257.287);
+    --color-slate-800: oklch(27.9% 0.041 260.031);
+    --color-white: #fff;
+    --spacing: 0.25rem;
+    --container-4xl: 56rem;
+    --text-sm: 0.875rem;
+    --text-sm--line-height: calc(1.25 / 0.875);
+    --text-base: 1rem;
+    --text-base--line-height: calc(1.5 / 1);
+    --text-lg: 1.125rem;
+    --text-lg--line-height: calc(1.75 / 1.125);
+    --text-xl: 1.25rem;
+    --text-xl--line-height: calc(1.75 / 1.25);
+    --text-2xl: 1.5rem;
+    --text-2xl--line-height: calc(2 / 1.5);
+    --text-3xl: 1.875rem;
+    --text-3xl--line-height: calc(2.25 / 1.875);
+    --font-weight-medium: 500;
+    --font-weight-bold: 700;
+    --leading-relaxed: 1.625;
+    --radius-lg: 0.5rem;
+    --ease-in: cubic-bezier(0.4, 0, 1, 1);
+    --ease-out: cubic-bezier(0, 0, 0.2, 1);
+    --ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-transition-duration: 150ms;
+    --default-transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-font-family: var(--font-sans);
+    --default-mono-font-family: var(--font-mono);
+    --radius: 8px;
+    --color-background: rgb(34, 34, 34);
+    --color-primary: rgb(247, 247, 247);
+    --color-secondary: rgba(215, 218, 224, 0.7);
+    --color-muted: rgba(215, 218, 224, 0.5);
+    --color-accent-300: rgb(110, 231, 133);
+    --color-panel: rgba(255, 255, 255, 0.12);
+    --color-border: rgba(255, 255, 255, 0.16);
+    --color-accent: rgb(88, 193, 66);
+  }
+}
+@layer base {
+  *, ::after, ::before, ::backdrop, ::file-selector-button {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+    border: 0 solid;
+  }
+  html, :host {
+    line-height: 1.5;
+    -webkit-text-size-adjust: 100%;
+    tab-size: 4;
+    font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");
+    font-feature-settings: var(--default-font-feature-settings, normal);
+    font-variation-settings: var(--default-font-variation-settings, normal);
+    -webkit-tap-highlight-color: transparent;
+  }
+  hr {
+    height: 0;
+    color: inherit;
+    border-top-width: 1px;
+  }
+  abbr:where([title]) {
+    -webkit-text-decoration: underline dotted;
+    text-decoration: underline dotted;
+  }
+  h1, h2, h3, h4, h5, h6 {
+    font-size: inherit;
+    font-weight: inherit;
+  }
+  a {
+    color: inherit;
+    -webkit-text-decoration: inherit;
+    text-decoration: inherit;
+  }
+  b, strong {
+    font-weight: bolder;
+  }
+  code, kbd, samp, pre {
+    font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
+    font-feature-settings: var(--default-mono-font-feature-settings, normal);
+    font-variation-settings: var(--default-mono-font-variation-settings, normal);
+    font-size: 1em;
+  }
+  small {
+    font-size: 80%;
+  }
+  sub, sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+  }
+  sub {
+    bottom: -0.25em;
+  }
+  sup {
+    top: -0.5em;
+  }
+  table {
+    text-indent: 0;
+    border-color: inherit;
+    border-collapse: collapse;
+  }
+  :-moz-focusring {
+    outline: auto;
+  }
+  progress {
+    vertical-align: baseline;
+  }
+  summary {
+    display: list-item;
+  }
+  ol, ul, menu {
+    list-style: none;
+  }
+  img, svg, video, canvas, audio, iframe, embed, object {
+    display: block;
+    vertical-align: middle;
+  }
+  img, video {
+    max-width: 100%;
+    height: auto;
+  }
+  button, input, select, optgroup, textarea, ::file-selector-button {
+    font: inherit;
+    font-feature-settings: inherit;
+    font-variation-settings: inherit;
+    letter-spacing: inherit;
+    color: inherit;
+    border-radius: 0;
+    background-color: transparent;
+    opacity: 1;
+  }
+  :where(select:is([multiple], [size])) optgroup {
+    font-weight: bolder;
+  }
+  :where(select:is([multiple], [size])) optgroup option {
+    padding-inline-start: 20px;
+  }
+  ::file-selector-button {
+    margin-inline-end: 4px;
+  }
+  ::placeholder {
+    opacity: 1;
+  }
+  @supports (not (-webkit-appearance: -apple-pay-button))  or (contain-intrinsic-size: 1px) {
+    ::placeholder {
+      color: currentcolor;
+      @supports (color: color-mix(in lab, red, red)) {
+        color: color-mix(in oklab, currentcolor 50%, transparent);
+      }
+    }
+  }
+  textarea {
+    resize: vertical;
+  }
+  ::-webkit-search-decoration {
+    -webkit-appearance: none;
+  }
+  ::-webkit-date-and-time-value {
+    min-height: 1lh;
+    text-align: inherit;
+  }
+  ::-webkit-datetime-edit {
+    display: inline-flex;
+  }
+  ::-webkit-datetime-edit-fields-wrapper {
+    padding: 0;
+  }
+  ::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field {
+    padding-block: 0;
+  }
+  ::-webkit-calendar-picker-indicator {
+    line-height: 1;
+  }
+  :-moz-ui-invalid {
+    box-shadow: none;
+  }
+  button, input:where([type="button"], [type="reset"], [type="submit"]), ::file-selector-button {
+    appearance: button;
+  }
+  ::-webkit-inner-spin-button, ::-webkit-outer-spin-button {
+    height: auto;
+  }
+  [hidden]:where(:not([hidden="until-found"])) {
+    display: none !important;
+  }
+}
+@layer utilities {
+  .collapse {
+    visibility: collapse;
+  }
+  .invisible {
+    visibility: hidden;
+  }
+  .visible {
+    visibility: visible;
+  }
+  .sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border-width: 0;
+  }
+  .not-sr-only {
+    position: static;
+    width: auto;
+    height: auto;
+    padding: 0;
+    margin: 0;
+    overflow: visible;
+    clip-path: none;
+    white-space: normal;
+  }
+  .absolute {
+    position: absolute;
+  }
+  .fixed {
+    position: fixed;
+  }
+  .relative {
+    position: relative;
+  }
+  .static {
+    position: static;
+  }
+  .sticky {
+    position: sticky;
+  }
+  .-inset-1 {
+    inset: calc(var(--spacing) * -1);
+  }
+  .isolate {
+    isolation: isolate;
+  }
+  .isolation-auto {
+    isolation: auto;
+  }
+  .\!container {
+    width: 100% !important;
+    @media (width >= 40rem) {
+      max-width: 40rem !important;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem !important;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem !important;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem !important;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem !important;
+    }
+  }
+  .container {
+    width: 100%;
+    @media (width >= 40rem) {
+      max-width: 40rem;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem;
+    }
+  }
+  .mx-auto {
+    margin-inline: auto;
+  }
+  .my-6 {
+    margin-block: calc(var(--spacing) * 6);
+  }
+  .mt-1 {
+    margin-top: calc(var(--spacing) * 1);
+  }
+  .mt-2 {
+    margin-top: calc(var(--spacing) * 2);
+  }
+  .mt-3 {
+    margin-top: calc(var(--spacing) * 3);
+  }
+  .mt-4 {
+    margin-top: calc(var(--spacing) * 4);
+  }
+  .mt-5 {
+    margin-top: calc(var(--spacing) * 5);
+  }
+  .mt-6 {
+    margin-top: calc(var(--spacing) * 6);
+  }
+  .mb-2 {
+    margin-bottom: calc(var(--spacing) * 2);
+  }
+  .mb-3 {
+    margin-bottom: calc(var(--spacing) * 3);
+  }
+  .mb-4 {
+    margin-bottom: calc(var(--spacing) * 4);
+  }
+  .mb-6 {
+    margin-bottom: calc(var(--spacing) * 6);
+  }
+  .ml-4 {
+    margin-left: calc(var(--spacing) * 4);
+  }
+  .block {
+    display: block;
+  }
+  .contents {
+    display: contents;
+  }
+  .flex {
+    display: flex;
+  }
+  .flow-root {
+    display: flow-root;
+  }
+  .grid {
+    display: grid;
+  }
+  .hidden {
+    display: none;
+  }
+  .inline {
+    display: inline;
+  }
+  .inline-block {
+    display: inline-block;
+  }
+  .inline-flex {
+    display: inline-flex;
+  }
+  .inline-grid {
+    display: inline-grid;
+  }
+  .inline-table {
+    display: inline-table;
+  }
+  .list-item {
+    display: list-item;
+  }
+  .table {
+    display: table;
+  }
+  .table-caption {
+    display: table-caption;
+  }
+  .table-cell {
+    display: table-cell;
+  }
+  .table-column {
+    display: table-column;
+  }
+  .table-column-group {
+    display: table-column-group;
+  }
+  .table-footer-group {
+    display: table-footer-group;
+  }
+  .table-header-group {
+    display: table-header-group;
+  }
+  .table-row {
+    display: table-row;
+  }
+  .table-row-group {
+    display: table-row-group;
+  }
+  .h-96 {
+    height: calc(var(--spacing) * 96);
+  }
+  .min-h-full {
+    min-height: 100%;
+  }
+  .min-h-screen {
+    min-height: 100vh;
+  }
+  .w-full {
+    width: 100%;
+  }
+  .max-w-4xl {
+    max-width: var(--container-4xl);
+  }
+  .max-w-none {
+    max-width: none;
+  }
+  .min-w-full {
+    min-width: 100%;
+  }
+  .flex-1 {
+    flex: 1;
+  }
+  .shrink {
+    flex-shrink: 1;
+  }
+  .grow {
+    flex-grow: 1;
+  }
+  .border-collapse {
+    border-collapse: collapse;
+  }
+  .translate-none {
+    translate: none;
+  }
+  .scale-3d {
+    scale: var(--tw-scale-x) var(--tw-scale-y) var(--tw-scale-z);
+  }
+  .transform {
+    transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,);
+  }
+  .cursor-not-allowed {
+    cursor: not-allowed;
+  }
+  .cursor-pointer {
+    cursor: pointer;
+  }
+  .touch-pinch-zoom {
+    --tw-pinch-zoom: pinch-zoom;
+    touch-action: var(--tw-pan-x,) var(--tw-pan-y,) var(--tw-pinch-zoom,);
+  }
+  .resize {
+    resize: both;
+  }
+  .resize-y {
+    resize: vertical;
+  }
+  .list-inside {
+    list-style-position: inside;
+  }
+  .list-decimal {
+    list-style-type: decimal;
+  }
+  .list-disc {
+    list-style-type: disc;
+  }
+  .flex-col {
+    flex-direction: column;
+  }
+  .flex-wrap {
+    flex-wrap: wrap;
+  }
+  .gap-2 {
+    gap: calc(var(--spacing) * 2);
+  }
+  .space-y-1 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 1;
+    }
+  }
+  .space-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-x-reverse: 1;
+    }
+  }
+  .divide-x {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 0;
+      border-inline-style: var(--tw-border-style);
+      border-inline-start-width: calc(1px * var(--tw-divide-x-reverse));
+      border-inline-end-width: calc(1px * calc(1 - var(--tw-divide-x-reverse)));
+    }
+  }
+  .divide-y {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 0;
+      border-bottom-style: var(--tw-border-style);
+      border-top-style: var(--tw-border-style);
+      border-top-width: calc(1px * var(--tw-divide-y-reverse));
+      border-bottom-width: calc(1px * calc(1 - var(--tw-divide-y-reverse)));
+    }
+  }
+  .divide-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 1;
+    }
+  }
+  .truncate {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+  .overflow-auto {
+    overflow: auto;
+  }
+  .overflow-x-auto {
+    overflow-x: auto;
+  }
+  .rounded {
+    border-radius: var(--radius);
+  }
+  .rounded-lg {
+    border-radius: var(--radius-lg);
+  }
+  .rounded-s {
+    border-start-start-radius: var(--radius);
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-ss {
+    border-start-start-radius: var(--radius);
+  }
+  .rounded-e {
+    border-start-end-radius: var(--radius);
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-se {
+    border-start-end-radius: var(--radius);
+  }
+  .rounded-ee {
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-es {
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-t {
+    border-top-left-radius: var(--radius);
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-l {
+    border-top-left-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-tl {
+    border-top-left-radius: var(--radius);
+  }
+  .rounded-r {
+    border-top-right-radius: var(--radius);
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-tr {
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-b {
+    border-bottom-right-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-br {
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-bl {
+    border-bottom-left-radius: var(--radius);
+  }
+  .border {
+    border-style: var(--tw-border-style);
+    border-width: 1px;
+  }
+  .border-x {
+    border-inline-style: var(--tw-border-style);
+    border-inline-width: 1px;
+  }
+  .border-y {
+    border-block-style: var(--tw-border-style);
+    border-block-width: 1px;
+  }
+  .border-s {
+    border-inline-start-style: var(--tw-border-style);
+    border-inline-start-width: 1px;
+  }
+  .border-e {
+    border-inline-end-style: var(--tw-border-style);
+    border-inline-end-width: 1px;
+  }
+  .border-t {
+    border-top-style: var(--tw-border-style);
+    border-top-width: 1px;
+  }
+  .border-r {
+    border-right-style: var(--tw-border-style);
+    border-right-width: 1px;
+  }
+  .border-b {
+    border-bottom-style: var(--tw-border-style);
+    border-bottom-width: 1px;
+  }
+  .border-l {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 1px;
+  }
+  .border-l-4 {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 4px;
+  }
+  .border-border {
+    border-color: var(--color-border);
+  }
+  .border-green-700 {
+    border-color: var(--color-green-700);
+  }
+  .border-red-700 {
+    border-color: var(--color-red-700);
+  }
+  .border-slate-600 {
+    border-color: var(--color-slate-600);
+  }
+  .bg-background {
+    background-color: var(--color-background);
+  }
+  .bg-blue-600 {
+    background-color: var(--color-blue-600);
+  }
+  .bg-green-600 {
+    background-color: var(--color-green-600);
+  }
+  .bg-green-900 {
+    background-color: var(--color-green-900);
+  }
+  .bg-panel {
+    background-color: var(--color-panel);
+  }
+  .bg-red-900 {
+    background-color: var(--color-red-900);
+  }
+  .bg-slate-600 {
+    background-color: var(--color-slate-600);
+  }
+  .bg-slate-700 {
+    background-color: var(--color-slate-700);
+  }
+  .bg-slate-800 {
+    background-color: var(--color-slate-800);
+  }
+  .bg-repeat {
+    background-repeat: repeat;
+  }
+  .mask-no-clip {
+    mask-clip: no-clip;
+  }
+  .mask-repeat {
+    mask-repeat: repeat;
+  }
+  .p-4 {
+    padding: calc(var(--spacing) * 4);
+  }
+  .p-6 {
+    padding: calc(var(--spacing) * 6);
+  }
+  .px-1 {
+    padding-inline: calc(var(--spacing) * 1);
+  }
+  .px-3 {
+    padding-inline: calc(var(--spacing) * 3);
+  }
+  .px-4 {
+    padding-inline: calc(var(--spacing) * 4);
+  }
+  .py-0\.5 {
+    padding-block: calc(var(--spacing) * 0.5);
+  }
+  .py-2 {
+    padding-block: calc(var(--spacing) * 2);
+  }
+  .py-3 {
+    padding-block: calc(var(--spacing) * 3);
+  }
+  .py-8 {
+    padding-block: calc(var(--spacing) * 8);
+  }
+  .pl-4 {
+    padding-left: calc(var(--spacing) * 4);
+  }
+  .text-center {
+    text-align: center;
+  }
+  .text-left {
+    text-align: left;
+  }
+  .font-mono {
+    font-family: var(--font-mono);
+  }
+  .text-2xl {
+    font-size: var(--text-2xl);
+    line-height: var(--tw-leading, var(--text-2xl--line-height));
+  }
+  .text-3xl {
+    font-size: var(--text-3xl);
+    line-height: var(--tw-leading, var(--text-3xl--line-height));
+  }
+  .text-base {
+    font-size: var(--text-base);
+    line-height: var(--tw-leading, var(--text-base--line-height));
+  }
+  .text-lg {
+    font-size: var(--text-lg);
+    line-height: var(--tw-leading, var(--text-lg--line-height));
+  }
+  .text-sm {
+    font-size: var(--text-sm);
+    line-height: var(--tw-leading, var(--text-sm--line-height));
+  }
+  .text-xl {
+    font-size: var(--text-xl);
+    line-height: var(--tw-leading, var(--text-xl--line-height));
+  }
+  .leading-relaxed {
+    --tw-leading: var(--leading-relaxed);
+    line-height: var(--leading-relaxed);
+  }
+  .font-bold {
+    --tw-font-weight: var(--font-weight-bold);
+    font-weight: var(--font-weight-bold);
+  }
+  .font-medium {
+    --tw-font-weight: var(--font-weight-medium);
+    font-weight: var(--font-weight-medium);
+  }
+  .text-wrap {
+    text-wrap: wrap;
+  }
+  .text-clip {
+    text-overflow: clip;
+  }
+  .text-ellipsis {
+    text-overflow: ellipsis;
+  }
+  .text-accent {
+    color: var(--color-accent);
+  }
+  .text-green-100 {
+    color: var(--color-green-100);
+  }
+  .text-muted {
+    color: var(--color-muted);
+  }
+  .text-primary {
+    color: var(--color-primary);
+  }
+  .text-red-100 {
+    color: var(--color-red-100);
+  }
+  .text-secondary {
+    color: var(--color-secondary);
+  }
+  .text-slate-100 {
+    color: var(--color-slate-100);
+  }
+  .text-slate-400 {
+    color: var(--color-slate-400);
+  }
+  .text-white {
+    color: var(--color-white);
+  }
+  .capitalize {
+    text-transform: capitalize;
+  }
+  .lowercase {
+    text-transform: lowercase;
+  }
+  .normal-case {
+    text-transform: none;
+  }
+  .uppercase {
+    text-transform: uppercase;
+  }
+  .italic {
+    font-style: italic;
+  }
+  .not-italic {
+    font-style: normal;
+  }
+  .diagonal-fractions {
+    --tw-numeric-fraction: diagonal-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .lining-nums {
+    --tw-numeric-figure: lining-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .oldstyle-nums {
+    --tw-numeric-figure: oldstyle-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .ordinal {
+    --tw-ordinal: ordinal;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .proportional-nums {
+    --tw-numeric-spacing: proportional-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .slashed-zero {
+    --tw-slashed-zero: slashed-zero;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .stacked-fractions {
+    --tw-numeric-fraction: stacked-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .tabular-nums {
+    --tw-numeric-spacing: tabular-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .normal-nums {
+    font-variant-numeric: normal;
+  }
+  .line-through {
+    text-decoration-line: line-through;
+  }
+  .no-underline {
+    text-decoration-line: none;
+  }
+  .overline {
+    text-decoration-line: overline;
+  }
+  .underline {
+    text-decoration-line: underline;
+  }
+  .antialiased {
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+  .subpixel-antialiased {
+    -webkit-font-smoothing: auto;
+    -moz-osx-font-smoothing: auto;
+  }
+  .placeholder-slate-400 {
+    &::placeholder {
+      color: var(--color-slate-400);
+    }
+  }
+  .shadow {
+    --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .ring {
+    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .inset-ring {
+    --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .outline {
+    outline-style: var(--tw-outline-style);
+    outline-width: 1px;
+  }
+  .blur {
+    --tw-blur: blur(8px);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .drop-shadow {
+    --tw-drop-shadow-size: drop-shadow(0 1px 2px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.1))) drop-shadow(0 1px 1px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.06)));
+    --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .grayscale {
+    --tw-grayscale: grayscale(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .invert {
+    --tw-invert: invert(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .sepia {
+    --tw-sepia: sepia(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .filter {
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .backdrop-blur {
+    --tw-backdrop-blur: blur(8px);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-grayscale {
+    --tw-backdrop-grayscale: grayscale(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-invert {
+    --tw-backdrop-invert: invert(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-sepia {
+    --tw-backdrop-sepia: sepia(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-filter {
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .transition {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .transition-colors {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .ease-in {
+    --tw-ease: var(--ease-in);
+    transition-timing-function: var(--ease-in);
+  }
+  .ease-in-out {
+    --tw-ease: var(--ease-in-out);
+    transition-timing-function: var(--ease-in-out);
+  }
+  .ease-out {
+    --tw-ease: var(--ease-out);
+    transition-timing-function: var(--ease-out);
+  }
+  .divide-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 1;
+    }
+  }
+  .ring-inset {
+    --tw-ring-inset: inset;
+  }
+  .hover\:bg-blue-700 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-blue-700);
+      }
+    }
+  }
+  .hover\:bg-green-700 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-green-700);
+      }
+    }
+  }
+  .hover\:text-accent-300 {
+    &:hover {
+      @media (hover: hover) {
+        color: var(--color-accent-300);
+      }
+    }
+  }
+  .focus\:ring-2 {
+    &:focus {
+      --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
+      box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+    }
+  }
+  .focus\:ring-blue-500 {
+    &:focus {
+      --tw-ring-color: var(--color-blue-500);
+    }
+  }
+  .focus\:outline-none {
+    &:focus {
+      --tw-outline-style: none;
+      outline-style: none;
+    }
+  }
+}
+@property --tw-scale-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-z {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-rotate-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-z {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pinch-zoom {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-space-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-space-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-divide-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-border-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-divide-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-leading {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-font-weight {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ordinal {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-slashed-zero {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-figure {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-spacing {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-fraction {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-inset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-ring-inset {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-offset-width {
+  syntax: "<length>";
+  inherits: false;
+  initial-value: 0px;
+}
+@property --tw-ring-offset-color {
+  syntax: "*";
+  inherits: false;
+  initial-value: #fff;
+}
+@property --tw-ring-offset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-outline-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-drop-shadow-size {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ease {
+  syntax: "*";
+  inherits: false;
+}
+@layer properties {
+  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
+    *, ::before, ::after, ::backdrop {
+      --tw-scale-x: 1;
+      --tw-scale-y: 1;
+      --tw-scale-z: 1;
+      --tw-rotate-x: initial;
+      --tw-rotate-y: initial;
+      --tw-rotate-z: initial;
+      --tw-skew-x: initial;
+      --tw-skew-y: initial;
+      --tw-pan-x: initial;
+      --tw-pan-y: initial;
+      --tw-pinch-zoom: initial;
+      --tw-space-y-reverse: 0;
+      --tw-space-x-reverse: 0;
+      --tw-divide-x-reverse: 0;
+      --tw-border-style: solid;
+      --tw-divide-y-reverse: 0;
+      --tw-leading: initial;
+      --tw-font-weight: initial;
+      --tw-ordinal: initial;
+      --tw-slashed-zero: initial;
+      --tw-numeric-figure: initial;
+      --tw-numeric-spacing: initial;
+      --tw-numeric-fraction: initial;
+      --tw-shadow: 0 0 #0000;
+      --tw-shadow-color: initial;
+      --tw-shadow-alpha: 100%;
+      --tw-inset-shadow: 0 0 #0000;
+      --tw-inset-shadow-color: initial;
+      --tw-inset-shadow-alpha: 100%;
+      --tw-ring-color: initial;
+      --tw-ring-shadow: 0 0 #0000;
+      --tw-inset-ring-color: initial;
+      --tw-inset-ring-shadow: 0 0 #0000;
+      --tw-ring-inset: initial;
+      --tw-ring-offset-width: 0px;
+      --tw-ring-offset-color: #fff;
+      --tw-ring-offset-shadow: 0 0 #0000;
+      --tw-outline-style: solid;
+      --tw-blur: initial;
+      --tw-brightness: initial;
+      --tw-contrast: initial;
+      --tw-grayscale: initial;
+      --tw-hue-rotate: initial;
+      --tw-invert: initial;
+      --tw-opacity: initial;
+      --tw-saturate: initial;
+      --tw-sepia: initial;
+      --tw-drop-shadow: initial;
+      --tw-drop-shadow-color: initial;
+      --tw-drop-shadow-alpha: 100%;
+      --tw-drop-shadow-size: initial;
+      --tw-backdrop-blur: initial;
+      --tw-backdrop-brightness: initial;
+      --tw-backdrop-contrast: initial;
+      --tw-backdrop-grayscale: initial;
+      --tw-backdrop-hue-rotate: initial;
+      --tw-backdrop-invert: initial;
+      --tw-backdrop-opacity: initial;
+      --tw-backdrop-saturate: initial;
+      --tw-backdrop-sepia: initial;
+      --tw-ease: initial;
+    }
+  }
+}

From cfdff413eb8ff820fb591761af99fbfda58a7cde Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Fri, 5 Sep 2025 19:14:38 -0700
Subject: [PATCH 068/134] small change to not dirty atoms that are the same

---
 tsunami/frontend/src/model/tsunami-model.tsx | 19 +++++++++++--------
 tsunami/frontend/src/vdom.tsx                |  6 +++---
 2 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
index d9b2c933fb..48f89fb1be 100644
--- a/tsunami/frontend/src/model/tsunami-model.tsx
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -5,7 +5,7 @@ import debug from "debug";
 import * as jotai from "jotai";
 
 import { getOrCreateClientId } from "@/util/clientid";
-import { adaptFromReactOrNativeKeyEvent, checkKeyPressed } from "@/util/keyutil";
+import { adaptFromReactOrNativeKeyEvent } from "@/util/keyutil";
 import { PLATFORM, PlatformMacOS } from "@/util/platformutil";
 import { getDefaultStore } from "jotai";
 import { applyCanvasOp, restoreVDomElems } from "./model-utils";
@@ -473,6 +473,9 @@ export class TsunamiModel {
     setAtomValue(atomName: string, value: any, fromBe: boolean, idMap: Map<string, VDomElem>) {
         dlog("setAtomValue", atomName, value, fromBe);
         let container = this.getAtomContainer(atomName);
+        if (container.val === value) {
+            return;
+        }
         container.val = value;
         if (fromBe) {
             container.beVal = value;
@@ -533,17 +536,17 @@ export class TsunamiModel {
         if (faviconPath === this.cachedFaviconPath) {
             return;
         }
-        
+
         this.cachedFaviconPath = faviconPath;
-        
+
         let existingFavicon = document.querySelector('link[rel="icon"]') as HTMLLinkElement;
-        
+
         if (faviconPath) {
             if (existingFavicon) {
                 existingFavicon.href = faviconPath;
             } else {
-                const link = document.createElement('link');
-                link.rel = 'icon';
+                const link = document.createElement("link");
+                link.rel = "icon";
                 link.href = faviconPath;
                 document.head.appendChild(link);
             }
@@ -558,7 +561,7 @@ export class TsunamiModel {
         if (update == null) {
             return;
         }
-        
+
         // Check if serverId is changing and trigger remount if needed
         if (this.serverId != null && this.serverId !== update.serverid) {
             // Server ID changed - need to remount the entire app
@@ -567,7 +570,7 @@ export class TsunamiModel {
             }
             return;
         }
-        
+
         this.serverId = update.serverid;
         getDefaultStore().set(this.contextActive, true);
         const idMap = new Map<string, VDomElem>();
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index 86cbdd3aa3..60914429a5 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -9,8 +9,8 @@ import * as React from "react";
 import { Markdown } from "@/element/markdown";
 import { getTextChildren } from "@/model/model-utils";
 import type { TsunamiModel } from "@/model/tsunami-model";
-import { adaptFromReactOrNativeKeyEvent, checkKeyPressed } from "@/util/keyutil";
 import { RechartsTag } from "@/recharts/recharts";
+import { adaptFromReactOrNativeKeyEvent, checkKeyPressed } from "@/util/keyutil";
 
 const TextTag = "#text";
 const FragmentTag = "#fragment";
@@ -332,12 +332,12 @@ function VDomTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
     if (elem.tag == WaveTextTag) {
         return props.text;
     }
-    
+
     // Dispatch recharts: prefixed tags to RechartsTag
     if (elem.tag.startsWith("recharts:")) {
         return <RechartsTag elem={elem} model={model} />;
     }
-    
+
     const waveTag = WaveTagMap[elem.tag];
     if (waveTag) {
         return waveTag({ elem, model });

From 64bd41fe233821d6d08d333e5512f422cd1ad51d Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Fri, 5 Sep 2025 19:51:57 -0700
Subject: [PATCH 069/134] fix remount issue

---
 tsunami/app/tsunamiapp.go                    | 20 +++++----
 tsunami/frontend/src/app.tsx                 | 26 ++---------
 tsunami/frontend/src/model/tsunami-model.tsx | 45 ++++++++++++++------
 tsunami/frontend/src/types/vdom.d.ts         |  1 +
 tsunami/rpctypes/protocoltypes.go            |  1 +
 5 files changed, 50 insertions(+), 43 deletions(-)

diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index b32a7cb4a6..25f90b2087 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -264,11 +264,12 @@ func (c *clientImpl) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 		renderedVDom = makeNullVDom()
 	}
 	return &rpctypes.VDomBackendUpdate{
-		Type:     "backendupdate",
-		Ts:       time.Now().UnixMilli(),
-		ServerId: c.ServerId,
-		HasWork:  len(c.Root.EffectWorkQueue) > 0,
-		Opts:     c.makeBackendOpts(),
+		Type:       "backendupdate",
+		Ts:         time.Now().UnixMilli(),
+		ServerId:   c.ServerId,
+		HasWork:    len(c.Root.EffectWorkQueue) > 0,
+		FullUpdate: true,
+		Opts:       c.makeBackendOpts(),
 		RenderUpdates: []rpctypes.VDomRenderUpdate{
 			{UpdateType: "root", VDom: renderedVDom},
 		},
@@ -285,10 +286,11 @@ func (c *clientImpl) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 		renderedVDom = makeNullVDom()
 	}
 	return &rpctypes.VDomBackendUpdate{
-		Type:     "backendupdate",
-		Ts:       time.Now().UnixMilli(),
-		ServerId: c.ServerId,
-		Opts:     c.makeBackendOpts(),
+		Type:       "backendupdate",
+		Ts:         time.Now().UnixMilli(),
+		ServerId:   c.ServerId,
+		FullUpdate: false,
+		Opts:       c.makeBackendOpts(),
 		RenderUpdates: []rpctypes.VDomRenderUpdate{
 			{UpdateType: "root", VDom: renderedVDom},
 		},
diff --git a/tsunami/frontend/src/app.tsx b/tsunami/frontend/src/app.tsx
index 247b940ccf..38c94e0a51 100644
--- a/tsunami/frontend/src/app.tsx
+++ b/tsunami/frontend/src/app.tsx
@@ -1,34 +1,16 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { useState, useEffect } from "react";
 import { TsunamiModel } from "@/model/tsunami-model";
 import { VDomView } from "./vdom";
 
-function App() {
-    const [remountKey, setRemountKey] = useState(0);
-    const [model, setModel] = useState(() => {
-        const newModel = new TsunamiModel();
-        newModel.remountCallback = () => {
-            setRemountKey(prev => prev + 1);
-        };
-        return newModel;
-    });
-
-    useEffect(() => {
-        // Create a new model when remount key changes
-        if (remountKey > 0) {
-            const newModel = new TsunamiModel();
-            newModel.remountCallback = () => {
-                setRemountKey(prev => prev + 1);
-            };
-            setModel(newModel);
-        }
-    }, [remountKey]);
+// Global model instance
+const globalModel = new TsunamiModel();
 
+function App() {
     return (
         <div className="min-h-screen bg-background text-foreground">
-            <VDomView key={remountKey} model={model} />
+            <VDomView model={globalModel} />
         </div>
     );
 }
diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
index 48f89fb1be..9f12116a59 100644
--- a/tsunami/frontend/src/model/tsunami-model.tsx
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -85,7 +85,6 @@ export class TsunamiModel {
     clientId: string;
     serverId: string;
     viewRef: React.RefObject<HTMLDivElement> = { current: null };
-    remountCallback: (() => void) | null = null;
     vdomRoot: jotai.PrimitiveAtom<VDomElem> = jotai.atom();
     atoms: Map<string, AtomContainer> = new Map(); // key is atomname
     refs: Map<string, RefContainer> = new Map(); // key is refid
@@ -486,11 +485,35 @@ export class TsunamiModel {
     }
 
     handleStateSync(update: VDomBackendUpdate, idMap: Map<string, VDomElem>) {
-        if (update.statesync == null) {
-            return;
-        }
-        for (let sync of update.statesync) {
-            this.setAtomValue(sync.atom, sync.value, true, idMap);
+        if (update.fullupdate) {
+            if (update.statesync == null) {
+                this.atoms.clear();
+                return;
+            }
+
+            const sentAtoms = new Set<string>();
+            for (let sync of update.statesync) {
+                sentAtoms.add(sync.atom);
+                this.setAtomValue(sync.atom, sync.value, true, idMap);
+            }
+
+            const atomsToRemove: string[] = [];
+            for (let atomName of this.atoms.keys()) {
+                if (!sentAtoms.has(atomName)) {
+                    atomsToRemove.push(atomName);
+                }
+            }
+
+            for (let atomName of atomsToRemove) {
+                this.atoms.delete(atomName);
+            }
+        } else {
+            if (update.statesync == null) {
+                return;
+            }
+            for (let sync of update.statesync) {
+                this.setAtomValue(sync.atom, sync.value, true, idMap);
+            }
         }
     }
 
@@ -562,13 +585,11 @@ export class TsunamiModel {
             return;
         }
 
-        // Check if serverId is changing and trigger remount if needed
+        // Check if serverId is changing and reset if needed
         if (this.serverId != null && this.serverId !== update.serverid) {
-            // Server ID changed - need to remount the entire app
-            if (this.remountCallback) {
-                this.remountCallback();
-            }
-            return;
+            // Server ID changed - reset the model state
+            this.reset();
+            this.setupServerEventSource();
         }
 
         this.serverId = update.serverid;
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
index ec32c9b81c..2159f33ae3 100644
--- a/tsunami/frontend/src/types/vdom.d.ts
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -22,6 +22,7 @@ type VDomBackendUpdate = {
     serverid: string;
     opts?: VDomBackendOpts;
     haswork?: boolean;
+    fullupdate?: boolean;
     renderupdates?: VDomRenderUpdate[];
     transferelems?: VDomTransferElem[];
     statesync?: VDomStateSync[];
diff --git a/tsunami/rpctypes/protocoltypes.go b/tsunami/rpctypes/protocoltypes.go
index 72b360f60a..45775025a7 100644
--- a/tsunami/rpctypes/protocoltypes.go
+++ b/tsunami/rpctypes/protocoltypes.go
@@ -51,6 +51,7 @@ type VDomBackendUpdate struct {
 	ServerId      string                  `json:"serverid"`
 	Opts          *VDomBackendOpts        `json:"opts,omitempty"`
 	HasWork       bool                    `json:"haswork,omitempty"`
+	FullUpdate    bool                    `json:"fullupdate,omitempty"`
 	RenderUpdates []VDomRenderUpdate      `json:"renderupdates,omitempty"`
 	TransferElems []VDomTransferElem      `json:"transferelems,omitempty"`
 	StateSync     []VDomStateSync         `json:"statesync,omitempty"`

From 867409586afc6975f9cf4ab6ee36d161dbc43523 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 7 Sep 2025 11:59:19 -0700
Subject: [PATCH 070/134] working towards new atom interface

---
 tsunami/app/defaultclient.go      | 43 +++++++++++++++----------------
 tsunami/app/tsunamiapp.go         | 24 +++++++++++++++++
 tsunami/demo/cpuchart/app.go      | 42 +++++++++++++++---------------
 tsunami/demo/githubaction/app.go  | 41 +++++++++++++++--------------
 tsunami/demo/recharts/app.go      | 20 +++++++-------
 tsunami/demo/tsunamiconfig/app.go |  7 ++++-
 tsunami/vdom/vdom.go              | 25 +++---------------
 tsunami/vdom/vdom_types.go        |  5 ++++
 8 files changed, 112 insertions(+), 95 deletions(-)

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index c71be7ccec..5c79bf55a7 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -8,7 +8,6 @@ import (
 	"io/fs"
 	"net/http"
 
-	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
@@ -42,31 +41,31 @@ func SendAsyncInitiation() error {
 	return defaultClient.SendAsyncInitiation()
 }
 
-func GetSharedAtom[T any](name string) T {
-	rawVal := defaultClient.GetAtomVal("$shared." + name)
-	return util.GetTypedAtomValue[T](rawVal, "$shared."+name)
+func ConfigAtom[T any](name string, defaultValue T) Atom[T] {
+	fullName := "$config." + name
+	// Set the default value if not already set
+	if defaultClient.GetAtomVal(fullName) == nil {
+		defaultClient.SetAtomVal(fullName, defaultValue)
+	}
+	return Atom[T]{name: fullName, client: defaultClient}
 }
 
-func SetSharedAtom[T any](name string, val T) {
-	defaultClient.SetAtomVal("$shared."+name, val)
+func DataAtom[T any](name string, defaultValue T) Atom[T] {
+	fullName := "$data." + name
+	// Set the default value if not already set
+	if defaultClient.GetAtomVal(fullName) == nil {
+		defaultClient.SetAtomVal(fullName, defaultValue)
+	}
+	return Atom[T]{name: fullName, client: defaultClient}
 }
 
-func GetConfig[T any](name string) T {
-	rawVal := defaultClient.GetAtomVal("$config." + name)
-	return util.GetTypedAtomValue[T](rawVal, "$config."+name)
-}
-
-func SetConfig[T any](name string, val T) {
-	defaultClient.SetAtomVal("$config."+name, val)
-}
-
-func GetData[T any](name string) T {
-	rawVal := defaultClient.GetAtomVal("$data." + name)
-	return util.GetTypedAtomValue[T](rawVal, "$data."+name)
-}
-
-func SetData[T any](name string, val T) {
-	defaultClient.SetAtomVal("$data."+name, val)
+func SharedAtom[T any](name string, defaultValue T) Atom[T] {
+	fullName := "$shared." + name
+	// Set the default value if not already set
+	if defaultClient.GetAtomVal(fullName) == nil {
+		defaultClient.SetAtomVal(fullName, defaultValue)
+	}
+	return Atom[T]{name: fullName, client: defaultClient}
 }
 
 // HandleDynFunc registers a dynamic HTTP handler function with the internal http.ServeMux.
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 25f90b2087..d20501b119 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -306,3 +306,27 @@ func (c *clientImpl) HandleDynFunc(pattern string, fn func(http.ResponseWriter,
 	}
 	c.UrlHandlerMux.HandleFunc(pattern, fn)
 }
+
+// Atom[T] represents a typed atom implementation
+type Atom[T any] struct {
+	name   string
+	client *clientImpl
+}
+
+// AtomName implements the vdom.Atom interface
+func (a Atom[T]) AtomName() string {
+	return a.name
+}
+
+// Get returns the current value of the atom
+func (a Atom[T]) Get() T {
+	val := a.client.GetAtomVal(a.name)
+	return util.GetTypedAtomValue[T](val, a.name)
+}
+
+// Set updates the atom's value
+func (a Atom[T]) Set(newVal T) {
+	a.client.SetAtomVal(a.name, newVal)
+}
+
+
diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
index aa9d17c191..d625b82c1a 100644
--- a/tsunami/demo/cpuchart/app.go
+++ b/tsunami/demo/cpuchart/app.go
@@ -10,23 +10,23 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-// Use func init() to set atom defaults
-func init() {
-	// Set default configuration
-	app.SetConfig("dataPointCount", 60)
-	
-	// Initialize with empty data points to maintain consistent chart size
-	dataPointCount := 60 // Default value for initialization
-	initialData := make([]CPUDataPoint, dataPointCount)
-	for i := range initialData {
-		initialData[i] = CPUDataPoint{
-			Time:      0,
-			CPUUsage:  nil, // Use nil to represent empty slots
-			Timestamp: "",
+// Global atoms for config and data
+var (
+	dataPointCountAtom = app.ConfigAtom("dataPointCount", 60)
+	cpuDataAtom        = app.DataAtom("cpuData", func() []CPUDataPoint {
+		// Initialize with empty data points to maintain consistent chart size
+		dataPointCount := 60 // Default value for initialization
+		initialData := make([]CPUDataPoint, dataPointCount)
+		for i := range initialData {
+			initialData[i] = CPUDataPoint{
+				Time:      0,
+				CPUUsage:  nil, // Use nil to represent empty slots
+				Timestamp: "",
+			}
 		}
-	}
-	app.SetData("cpuData", initialData)
-}
+		return initialData
+	}())
+)
 
 type CPUDataPoint struct {
 	Time      int64    `json:"time"`      // Unix timestamp in seconds
@@ -145,9 +145,9 @@ var App = app.DefineComponent("App",
 	func(ctx context.Context, _ struct{}) any {
 		vdom.UseSetAppTitle(ctx, "CPU Usage Monitor")
 
-		// Global state
-		cpuData, setCpuData, setCpuDataFn := vdom.UseData[[]CPUDataPoint](ctx, "cpuData")
-		dataPointCount, _, _ := vdom.UseConfig[int](ctx, "dataPointCount")
+		// Global state using atoms
+		cpuData, setCpuData, setCpuDataFn := vdom.UseAtom[[]CPUDataPoint](ctx, cpuDataAtom)
+		dataPointCount, _, _ := vdom.UseAtom[int](ctx, dataPointCountAtom)
 
 		// Local state for forcing re-renders
 		_, _, setTickerFn := vdom.UseState[int](ctx, 0)
@@ -167,7 +167,7 @@ var App = app.DefineComponent("App",
 						setCpuDataFn(func(currentData []CPUDataPoint) []CPUDataPoint {
 							newPoint := generateCPUDataPoint()
 							// Read current config inside the loop to get live updates
-							currentDataPointCount := app.GetConfig[int]("dataPointCount")
+							currentDataPointCount := dataPointCountAtom.Get()
 							
 							// Ensure we have the right size array
 							if len(currentData) != currentDataPointCount {
@@ -208,7 +208,7 @@ var App = app.DefineComponent("App",
 
 		handleClear := func() {
 			// Reset with empty data points based on current config
-			currentDataPointCount := app.GetConfig[int]("dataPointCount")
+			currentDataPointCount := dataPointCountAtom.Get()
 			initialData := make([]CPUDataPoint, currentDataPointCount)
 			for i := range initialData {
 				initialData[i] = CPUDataPoint{
diff --git a/tsunami/demo/githubaction/app.go b/tsunami/demo/githubaction/app.go
index 0637ad6e14..e34af22ba2 100644
--- a/tsunami/demo/githubaction/app.go
+++ b/tsunami/demo/githubaction/app.go
@@ -16,16 +16,17 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-func init() {
-	app.SetConfig("pollInterval", 5)
-	app.SetConfig("repository", "wavetermdev/waveterm")
-	app.SetConfig("workflow", "build-helper.yml")
-	app.SetConfig("maxWorkflowRuns", 10)
-	app.SetData("workflowRuns", []WorkflowRun{})
-	app.SetData("lastError", "")
-	app.SetData("isLoading", true)
-	app.SetData("lastRefreshTime", time.Time{})
-}
+// Global atoms for config and data
+var (
+	pollIntervalAtom    = app.ConfigAtom("pollInterval", 5)
+	repositoryAtom      = app.ConfigAtom("repository", "wavetermdev/waveterm")
+	workflowAtom        = app.ConfigAtom("workflow", "build-helper.yml")
+	maxWorkflowRunsAtom = app.ConfigAtom("maxWorkflowRuns", 10)
+	workflowRunsAtom    = app.DataAtom("workflowRuns", []WorkflowRun{})
+	lastErrorAtom       = app.DataAtom("lastError", "")
+	isLoadingAtom       = app.DataAtom("isLoading", true)
+	lastRefreshTimeAtom = app.DataAtom("lastRefreshTime", time.Time{})
+)
 
 type WorkflowRun struct {
 	ID         int64     `json:"id"`
@@ -223,14 +224,14 @@ var App = app.DefineComponent("App",
 	func(ctx context.Context, _ struct{}) any {
 		vdom.UseSetAppTitle(ctx, "GitHub Actions Monitor")
 
-		workflowRuns, setWorkflowRuns, _ := vdom.UseData[[]WorkflowRun](ctx, "workflowRuns")
-		lastError, setLastError, _ := vdom.UseData[string](ctx, "lastError")
-		isLoading, setIsLoading, _ := vdom.UseData[bool](ctx, "isLoading")
-		lastRefreshTime, setLastRefreshTime, _ := vdom.UseData[time.Time](ctx, "lastRefreshTime")
-		pollInterval, _, _ := vdom.UseConfig[int](ctx, "pollInterval")
-		repository, _, _ := vdom.UseConfig[string](ctx, "repository")
-		workflow, _, _ := vdom.UseConfig[string](ctx, "workflow")
-		maxWorkflowRuns, _, _ := vdom.UseConfig[int](ctx, "maxWorkflowRuns")
+		workflowRuns, setWorkflowRuns, _ := vdom.UseAtom[[]WorkflowRun](ctx, workflowRunsAtom)
+		lastError, setLastError, _ := vdom.UseAtom[string](ctx, lastErrorAtom)
+		isLoading, setIsLoading, _ := vdom.UseAtom[bool](ctx, isLoadingAtom)
+		lastRefreshTime, setLastRefreshTime, _ := vdom.UseAtom[time.Time](ctx, lastRefreshTimeAtom)
+		pollInterval, _, _ := vdom.UseAtom[int](ctx, pollIntervalAtom)
+		repository, _, _ := vdom.UseAtom[string](ctx, repositoryAtom)
+		workflow, _, _ := vdom.UseAtom[string](ctx, workflowAtom)
+		maxWorkflowRuns, _, _ := vdom.UseAtom[int](ctx, maxWorkflowRunsAtom)
 
 		_, _, setTickerFn := vdom.UseState[int](ctx, 0)
 
@@ -239,7 +240,7 @@ var App = app.DefineComponent("App",
 			done := make(chan bool)
 
 			fetchData := func() {
-				currentMaxRuns := app.GetConfig[int]("maxWorkflowRuns")
+				currentMaxRuns := maxWorkflowRunsAtom.Get()
 				runs, err := fetchWorkflowRuns(repository, workflow, currentMaxRuns)
 				if err != nil {
 					log.Printf("Error fetching workflow runs: %v", err)
@@ -279,7 +280,7 @@ var App = app.DefineComponent("App",
 		handleRefresh := func() {
 			setIsLoading(true)
 			go func() {
-				currentMaxRuns := app.GetConfig[int]("maxWorkflowRuns")
+				currentMaxRuns := maxWorkflowRunsAtom.Get()
 				runs, err := fetchWorkflowRuns(repository, workflow, currentMaxRuns)
 				if err != nil {
 					log.Printf("Error fetching workflow runs: %v", err)
diff --git a/tsunami/demo/recharts/app.go b/tsunami/demo/recharts/app.go
index 3a0b29bd64..9dfaf67b3d 100644
--- a/tsunami/demo/recharts/app.go
+++ b/tsunami/demo/recharts/app.go
@@ -9,12 +9,12 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-// Use func init() to set atom defaults
-func init() {
-	app.SetData("chartData", generateInitialData())
-	app.SetConfig("chartType", "line")
-	app.SetSharedAtom("isAnimating", false)
-}
+// Global atoms for config and data
+var (
+	chartDataAtom   = app.DataAtom("chartData", generateInitialData())
+	chartTypeAtom   = app.ConfigAtom("chartType", "line")
+	isAnimatingAtom = app.SharedAtom("isAnimating", false)
+)
 
 type DataPoint struct {
 	Time int     `json:"time"`
@@ -206,10 +206,10 @@ var App = app.DefineComponent("App",
 	func(ctx context.Context, _ struct{}) any {
 		vdom.UseSetAppTitle(ctx, "Recharts Demo")
 
-		// Global state
-		chartData, setChartData, setChartDataFn := vdom.UseData[[]DataPoint](ctx, "chartData")
-		chartType, setChartType, _ := vdom.UseConfig[string](ctx, "chartType")
-		isAnimating, setIsAnimating, _ := vdom.UseSharedAtom[bool](ctx, "isAnimating")
+		// Global state using atoms
+		chartData, setChartData, setChartDataFn := vdom.UseAtom[[]DataPoint](ctx, chartDataAtom)
+		chartType, setChartType, _ := vdom.UseAtom[string](ctx, chartTypeAtom)
+		isAnimating, setIsAnimating, _ := vdom.UseAtom[bool](ctx, isAnimatingAtom)
 
 		// Local state for timer
 		_, _, setTickerFn := vdom.UseState[int](ctx, 0)
diff --git a/tsunami/demo/tsunamiconfig/app.go b/tsunami/demo/tsunamiconfig/app.go
index 21c7ea1dea..469444d6ad 100644
--- a/tsunami/demo/tsunamiconfig/app.go
+++ b/tsunami/demo/tsunamiconfig/app.go
@@ -15,6 +15,11 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
+// Global atoms for config
+var (
+	serverURLAtom = app.ConfigAtom("serverURL", "")
+)
+
 type URLInputProps struct {
 	Value     string       `json:"value"`
 	OnChange  func(string) `json:"onChange"`
@@ -253,7 +258,7 @@ var App = app.DefineComponent("App",
 		vdom.UseSetAppTitle(ctx, "Tsunami Config Manager")
 
 		// Use UseConfig for the URL input so it persists
-		urlInput, setURLInput, _ := vdom.UseConfig[string](ctx, "serverURL")
+		urlInput, setURLInput, _ := vdom.UseAtom[string](ctx, serverURLAtom)
 		jsonContent, setJSONContent, _ := vdom.UseState(ctx, "")
 		errorMessage, setErrorMessage, _ := vdom.UseState(ctx, "")
 		successMessage, setSuccessMessage, _ := vdom.UseState(ctx, "")
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index 15b154cef9..b8fa23048b 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -182,7 +182,6 @@ func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T
 	return rtnVal, typedSetVal, typedSetFuncVal
 }
 
-
 func useAtom[T any](ctx context.Context, hookName string, atomName string) (T, func(T), func(func(T) T)) {
 	rc := vdomctx.GetRenderContext(ctx)
 	if rc == nil {
@@ -207,28 +206,12 @@ func useAtom[T any](ctx context.Context, hookName string, atomName string) (T, f
 	return atomVal, typedSetVal, typedSetFuncVal
 }
 
-// UseSharedAtom provides access to a shared atom state across components.
+// UseAtom provides access to atom values using an Atom interface.
 // It returns the current atom value, a setter function, and an updater function.
-// Setting a new value causes a re-render of any component using this atom.
-// This hook must be called within a component context.
-func UseSharedAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
-	return useAtom[T](ctx, "UseSharedAtom", "$shared."+atomName)
-}
-
-// UseConfig provides access to config values (atom names are global across the app).
-// It returns the current config value, a setter function, and an updater function.
-// Setting a new value causes a re-render of all components using this config atom.
-// This hook must be called within a component context.
-func UseConfig[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
-	return useAtom[T](ctx, "UseConfig", "$config."+atomName)
-}
-
-// UseData provides access to data values (atom names are global across the app).
-// It returns the current data value, a setter function, and an updater function.
-// Setting a new value causes a re-render of all components using this data atom.
+// Setting a new value causes a re-render of all components using this atom.
 // This hook must be called within a component context.
-func UseData[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T)) {
-	return useAtom[T](ctx, "UseData", "$data."+atomName)
+func UseAtom[T any](ctx context.Context, atom Atom) (T, func(T), func(func(T) T)) {
+	return useAtom[T](ctx, "UseAtom", atom.AtomName())
 }
 
 // UseVDomRef provides a reference to a DOM element in the VDOM tree.
diff --git a/tsunami/vdom/vdom_types.go b/tsunami/vdom/vdom_types.go
index 86c890f67b..677ba5de1a 100644
--- a/tsunami/vdom/vdom_types.go
+++ b/tsunami/vdom/vdom_types.go
@@ -126,3 +126,8 @@ type VDomRefOperation struct {
 	Params    []any  `json:"params,omitempty"`
 	OutputRef string `json:"outputref,omitempty"`
 }
+
+// Atom interface for atom implementations
+type Atom interface {
+	AtomName() string
+}

From e49dfa1526759657d0b2461b88da476e785a2f8e Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 7 Sep 2025 13:03:11 -0700
Subject: [PATCH 071/134] more updates to atom API

---
 tsunami/app/atom.go                 |   68 ++
 tsunami/app/tsunamiapp.go           |   24 -
 tsunami/comp/hooks.go               |   20 +-
 tsunami/comp/rootelem.go            |   49 +-
 tsunami/demo/recharts/go.mod        |    9 +
 tsunami/demo/recharts/go.sum        |    2 +
 tsunami/demo/recharts/static/tw.css | 1356 +++++++++++++++++++++++++++
 7 files changed, 1485 insertions(+), 43 deletions(-)
 create mode 100644 tsunami/app/atom.go
 create mode 100644 tsunami/demo/recharts/go.mod
 create mode 100644 tsunami/demo/recharts/go.sum
 create mode 100644 tsunami/demo/recharts/static/tw.css

diff --git a/tsunami/app/atom.go b/tsunami/app/atom.go
new file mode 100644
index 0000000000..0fa239707c
--- /dev/null
+++ b/tsunami/app/atom.go
@@ -0,0 +1,68 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package app
+
+import (
+	"log"
+	"runtime"
+
+	"github.com/wavetermdev/waveterm/tsunami/comp"
+	"github.com/wavetermdev/waveterm/tsunami/util"
+)
+
+// logInvalidAtomSet logs an error when an atom is being set during component render
+func logInvalidAtomSet(atomName string) {
+	_, file, line, ok := runtime.Caller(2)
+	if ok {
+		log.Printf("invalid Set of atom '%s' in component render function at %s:%d", atomName, file, line)
+	} else {
+		log.Printf("invalid Set of atom '%s' in component render function", atomName)
+	}
+}
+
+// Atom[T] represents a typed atom implementation
+type Atom[T any] struct {
+	name   string
+	client *clientImpl
+}
+
+// AtomName implements the vdom.Atom interface
+func (a Atom[T]) AtomName() string {
+	return a.name
+}
+
+// Get returns the current value of the atom
+func (a Atom[T]) Get() T {
+	vc := comp.GetGlobalContext()
+	if vc != nil {
+		compWaveId := vc.GetCompWaveId()
+		vc.Root.AtomSetUsedBy(a.name, compWaveId, true)
+	}
+	val := a.client.GetAtomVal(a.name)
+	return util.GetTypedAtomValue[T](val, a.name)
+}
+
+// Set updates the atom's value
+func (a Atom[T]) Set(newVal T) {
+	vc := comp.GetGlobalContext()
+	if vc != nil {
+		logInvalidAtomSet(a.name)
+		return
+	}
+	a.client.Root.AtomAddRenderWork(a.name)
+	a.client.SetAtomVal(a.name, newVal)
+}
+
+func (a Atom[T]) SetFn(fn func(T) T) {
+	vc := comp.GetGlobalContext()
+	if vc != nil {
+		logInvalidAtomSet(a.name)
+		return
+	}
+	val := a.client.GetAtomVal(a.name)
+	typedVal := util.GetTypedAtomValue[T](val, a.name)
+	newVal := fn(typedVal)
+	a.client.Root.AtomAddRenderWork(a.name)
+	a.client.SetAtomVal(a.name, newVal)
+}
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index d20501b119..25f90b2087 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -306,27 +306,3 @@ func (c *clientImpl) HandleDynFunc(pattern string, fn func(http.ResponseWriter,
 	}
 	c.UrlHandlerMux.HandleFunc(pattern, fn)
 }
-
-// Atom[T] represents a typed atom implementation
-type Atom[T any] struct {
-	name   string
-	client *clientImpl
-}
-
-// AtomName implements the vdom.Atom interface
-func (a Atom[T]) AtomName() string {
-	return a.name
-}
-
-// Get returns the current value of the atom
-func (a Atom[T]) Get() T {
-	val := a.client.GetAtomVal(a.name)
-	return util.GetTypedAtomValue[T](val, a.name)
-}
-
-// Set updates the atom's value
-func (a Atom[T]) Set(newVal T) {
-	a.client.SetAtomVal(a.name, newVal)
-}
-
-
diff --git a/tsunami/comp/hooks.go b/tsunami/comp/hooks.go
index 2b14362365..175df60812 100644
--- a/tsunami/comp/hooks.go
+++ b/tsunami/comp/hooks.go
@@ -38,7 +38,7 @@ func MakeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *VDom
 	return &VDomContextImpl{Root: root, Comp: comp, HookIdx: 0, RenderOpts: opts}
 }
 
-func (vc *VDomContextImpl) getCompWaveId() string {
+func (vc *VDomContextImpl) GetCompWaveId() string {
 	if vc.Comp == nil {
 		return ""
 	}
@@ -69,7 +69,7 @@ func (vc *VDomContextImpl) UseRenderTs(ctx context.Context) int64 {
 }
 
 func (vc *VDomContextImpl) UseId(ctx context.Context) string {
-	return vc.getCompWaveId()
+	return vc.GetCompWaveId()
 }
 
 func (vc *VDomContextImpl) UseState(ctx context.Context, initialVal any) (any, func(any), func(func(any) any)) {
@@ -81,12 +81,12 @@ func (vc *VDomContextImpl) UseState(ctx context.Context, initialVal any) (any, f
 
 	setVal := func(newVal any) {
 		hookVal.Val = newVal
-		vc.Root.AddRenderWork(vc.getCompWaveId())
+		vc.Root.AddRenderWork(vc.GetCompWaveId())
 	}
 
 	setFuncVal := func(updateFunc func(any) any) {
 		hookVal.Val = updateFunc(hookVal.Val)
-		vc.Root.AddRenderWork(vc.getCompWaveId())
+		vc.Root.AddRenderWork(vc.GetCompWaveId())
 	}
 
 	return hookVal.Val, setVal, setFuncVal
@@ -96,12 +96,12 @@ func (vc *VDomContextImpl) UseAtom(ctx context.Context, atomName string) (any, f
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
-		closedWaveId := vc.getCompWaveId()
+		closedWaveId := vc.GetCompWaveId()
 		hookVal.UnmountFn = func() {
 			vc.Root.AtomSetUsedBy(atomName, closedWaveId, false)
 		}
 	}
-	vc.Root.AtomSetUsedBy(atomName, vc.getCompWaveId(), true)
+	vc.Root.AtomSetUsedBy(atomName, vc.GetCompWaveId(), true)
 	atomVal := vc.Root.GetAtomVal(atomName)
 
 	setVal := func(newVal any) {
@@ -122,7 +122,7 @@ func (vc *VDomContextImpl) UseVDomRef(ctx context.Context) any {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
-		refId := vc.getCompWaveId() + ":" + strconv.Itoa(hookVal.Idx)
+		refId := vc.GetCompWaveId() + ":" + strconv.Itoa(hookVal.Idx)
 		hookVal.Val = &vdom.VDomRef{Type: vdom.ObjectType_Ref, RefId: refId}
 	}
 	refVal, ok := hookVal.Val.(*vdom.VDomRef)
@@ -159,14 +159,14 @@ func (vc *VDomContextImpl) UseEffect(ctx context.Context, fn func() func(), deps
 		hookVal.Init = true
 		hookVal.Fn = fn
 		hookVal.Deps = deps
-		vc.Root.AddEffectWork(vc.getCompWaveId(), hookVal.Idx)
+		vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
 		return
 	}
 	// If deps is nil, always run (like React with no dependency array)
 	if deps == nil {
 		hookVal.Fn = fn
 		hookVal.Deps = deps
-		vc.Root.AddEffectWork(vc.getCompWaveId(), hookVal.Idx)
+		vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
 		return
 	}
 
@@ -175,7 +175,7 @@ func (vc *VDomContextImpl) UseEffect(ctx context.Context, fn func() func(), deps
 	}
 	hookVal.Fn = fn
 	hookVal.Deps = deps
-	vc.Root.AddEffectWork(vc.getCompWaveId(), hookVal.Idx)
+	vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
 }
 
 func (vc *VDomContextImpl) UseResync(ctx context.Context) bool {
diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index 1795dae9c0..c18b9cc4a9 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -22,11 +22,15 @@ import (
 
 const ChildrenPropKey = "children"
 
+// is set ONLY when we're in the render function of a component
+// used for hooks, and automatic dependency tracking
+var globalVC *VDomContextImpl
+
 type RenderOpts struct {
 	Resync bool
 }
 
-type Atom struct {
+type atomImpl struct {
 	Val    any
 	Dirty  bool
 	UsedBy map[string]bool // component waveid -> true
@@ -46,7 +50,7 @@ type RootElem struct {
 	CompMap         map[string]*ComponentImpl // component waveid -> component
 	EffectWorkQueue []*EffectWorkElem
 	NeedsRenderMap  map[string]bool
-	Atoms           map[string]*Atom
+	Atoms           map[string]*atomImpl
 	atomLock        sync.Mutex
 	RefOperations   []vdom.VDomRefOperation
 }
@@ -95,19 +99,30 @@ func MakeRoot() *RootElem {
 		Root:    nil,
 		CFuncs:  make(map[string]any),
 		CompMap: make(map[string]*ComponentImpl),
-		Atoms:   make(map[string]*Atom),
+		Atoms:   make(map[string]*atomImpl),
 	}
 }
 
-func (r *RootElem) ensureAtomNoLock(name string) *Atom {
+func (r *RootElem) ensureAtomNoLock(name string) *atomImpl {
 	atom, ok := r.Atoms[name]
 	if !ok {
-		atom = &Atom{UsedBy: make(map[string]bool)}
+		atom = &atomImpl{UsedBy: make(map[string]bool)}
 		r.Atoms[name] = atom
 	}
 	return atom
 }
 
+// we can do better here with an inverted map, but
+// this will work fine for now to clean up dependencies from atom.Get()
+func (r *RootElem) cleanupUsedByForUnmount(waveId string) {
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+
+	for _, atom := range r.Atoms {
+		delete(atom.UsedBy, waveId)
+	}
+}
+
 func (r *RootElem) AtomSetUsedBy(atomName string, waveId string, used bool) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
@@ -329,6 +344,7 @@ func (r *RootElem) unmount(comp **ComponentImpl) {
 	if *comp == nil {
 		return
 	}
+	waveId := (*comp).WaveId
 	// parent clean up happens first
 	for _, hook := range (*comp).Hooks {
 		if hook.UnmountFn != nil {
@@ -344,7 +360,8 @@ func (r *RootElem) unmount(comp **ComponentImpl) {
 			r.unmount(&child)
 		}
 	}
-	delete(r.CompMap, (*comp).WaveId)
+	delete(r.CompMap, waveId)
+	r.cleanupUsedByForUnmount(waveId)
 	*comp = nil
 }
 
@@ -424,6 +441,18 @@ func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
 	return rtnVal[0].Interface()
 }
 
+func withGlobalCtx[T any](vc *VDomContextImpl, fn func() T) T {
+	globalVC = vc
+	defer func() {
+		globalVC = nil
+	}()
+	return fn()
+}
+
+func GetGlobalContext() *VDomContextImpl {
+	return globalVC
+}
+
 func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
 	if (*comp).Children != nil {
 		for _, child := range (*comp).Children {
@@ -437,9 +466,11 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 	}
 	props[ChildrenPropKey] = elem.Children
 	vc := MakeContextVal(r, *comp, opts)
-	ctx := vdomctx.WithRenderContext(r.OuterCtx, vc)
-	renderedElem := callCFunc(cfunc, ctx, props)
-	rtnElemArr := vdom.ToElems(renderedElem)
+	rtnElemArr := withGlobalCtx(vc, func() []vdom.VDomElem {
+		ctx := vdomctx.WithRenderContext(r.OuterCtx, vc)
+		renderedElem := callCFunc(cfunc, ctx, props)
+		return vdom.ToElems(renderedElem)
+	})
 	if len(rtnElemArr) == 0 {
 		r.unmount(&(*comp).Comp)
 		return
diff --git a/tsunami/demo/recharts/go.mod b/tsunami/demo/recharts/go.mod
new file mode 100644
index 0000000000..ccb343e166
--- /dev/null
+++ b/tsunami/demo/recharts/go.mod
@@ -0,0 +1,9 @@
+module tsunami/app/recharts
+
+go 1.24.6
+
+require github.com/wavetermdev/waveterm/tsunami v0.0.0
+
+require github.com/google/uuid v1.6.0 // indirect
+
+replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/recharts/go.sum b/tsunami/demo/recharts/go.sum
new file mode 100644
index 0000000000..7790d7c3e0
--- /dev/null
+++ b/tsunami/demo/recharts/go.sum
@@ -0,0 +1,2 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
diff --git a/tsunami/demo/recharts/static/tw.css b/tsunami/demo/recharts/static/tw.css
new file mode 100644
index 0000000000..3e36ada910
--- /dev/null
+++ b/tsunami/demo/recharts/static/tw.css
@@ -0,0 +1,1356 @@
+/*! tailwindcss v4.1.13 | MIT License | https://tailwindcss.com */
+@layer properties;
+@layer theme, base, components, utilities;
+@layer theme {
+  :root, :host {
+    --font-sans: "Inter", sans-serif;
+    --font-mono: "Hack", monospace;
+    --color-red-500: oklch(63.7% 0.237 25.331);
+    --color-red-600: oklch(57.7% 0.245 27.325);
+    --color-green-500: oklch(72.3% 0.219 149.579);
+    --color-green-600: oklch(62.7% 0.194 149.214);
+    --color-blue-50: oklch(97% 0.014 254.604);
+    --color-blue-200: oklch(88.2% 0.059 254.128);
+    --color-blue-500: oklch(62.3% 0.214 259.815);
+    --color-blue-800: oklch(42.4% 0.199 265.638);
+    --color-blue-900: oklch(37.9% 0.146 265.522);
+    --color-gray-50: oklch(98.5% 0.002 247.839);
+    --color-gray-300: oklch(87.2% 0.01 258.338);
+    --color-gray-400: oklch(70.7% 0.022 261.325);
+    --color-gray-500: oklch(55.1% 0.027 264.364);
+    --color-gray-600: oklch(44.6% 0.03 256.802);
+    --color-gray-700: oklch(37.3% 0.034 259.733);
+    --color-gray-900: oklch(21% 0.034 264.665);
+    --color-white: #fff;
+    --spacing: 0.25rem;
+    --container-6xl: 72rem;
+    --text-sm: 0.875rem;
+    --text-sm--line-height: calc(1.25 / 0.875);
+    --text-base: 1rem;
+    --text-base--line-height: calc(1.5 / 1);
+    --text-lg: 1.125rem;
+    --text-lg--line-height: calc(1.75 / 1.125);
+    --text-xl: 1.25rem;
+    --text-xl--line-height: calc(1.75 / 1.25);
+    --text-2xl: 1.5rem;
+    --text-2xl--line-height: calc(2 / 1.5);
+    --text-3xl: 1.875rem;
+    --text-3xl--line-height: calc(2.25 / 1.875);
+    --font-weight-medium: 500;
+    --font-weight-semibold: 600;
+    --font-weight-bold: 700;
+    --leading-relaxed: 1.625;
+    --radius-md: 0.375rem;
+    --radius-lg: 0.5rem;
+    --ease-in: cubic-bezier(0.4, 0, 1, 1);
+    --ease-out: cubic-bezier(0, 0, 0.2, 1);
+    --ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-transition-duration: 150ms;
+    --default-transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-font-family: var(--font-sans);
+    --default-mono-font-family: var(--font-mono);
+    --radius: 8px;
+    --color-background: rgb(34, 34, 34);
+    --color-primary: rgb(247, 247, 247);
+    --color-secondary: rgba(215, 218, 224, 0.7);
+    --color-muted: rgba(215, 218, 224, 0.5);
+    --color-accent-300: rgb(110, 231, 133);
+    --color-panel: rgba(255, 255, 255, 0.12);
+    --color-border: rgba(255, 255, 255, 0.16);
+    --color-accent: rgb(88, 193, 66);
+  }
+}
+@layer base {
+  *, ::after, ::before, ::backdrop, ::file-selector-button {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+    border: 0 solid;
+  }
+  html, :host {
+    line-height: 1.5;
+    -webkit-text-size-adjust: 100%;
+    tab-size: 4;
+    font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");
+    font-feature-settings: var(--default-font-feature-settings, normal);
+    font-variation-settings: var(--default-font-variation-settings, normal);
+    -webkit-tap-highlight-color: transparent;
+  }
+  hr {
+    height: 0;
+    color: inherit;
+    border-top-width: 1px;
+  }
+  abbr:where([title]) {
+    -webkit-text-decoration: underline dotted;
+    text-decoration: underline dotted;
+  }
+  h1, h2, h3, h4, h5, h6 {
+    font-size: inherit;
+    font-weight: inherit;
+  }
+  a {
+    color: inherit;
+    -webkit-text-decoration: inherit;
+    text-decoration: inherit;
+  }
+  b, strong {
+    font-weight: bolder;
+  }
+  code, kbd, samp, pre {
+    font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
+    font-feature-settings: var(--default-mono-font-feature-settings, normal);
+    font-variation-settings: var(--default-mono-font-variation-settings, normal);
+    font-size: 1em;
+  }
+  small {
+    font-size: 80%;
+  }
+  sub, sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+  }
+  sub {
+    bottom: -0.25em;
+  }
+  sup {
+    top: -0.5em;
+  }
+  table {
+    text-indent: 0;
+    border-color: inherit;
+    border-collapse: collapse;
+  }
+  :-moz-focusring {
+    outline: auto;
+  }
+  progress {
+    vertical-align: baseline;
+  }
+  summary {
+    display: list-item;
+  }
+  ol, ul, menu {
+    list-style: none;
+  }
+  img, svg, video, canvas, audio, iframe, embed, object {
+    display: block;
+    vertical-align: middle;
+  }
+  img, video {
+    max-width: 100%;
+    height: auto;
+  }
+  button, input, select, optgroup, textarea, ::file-selector-button {
+    font: inherit;
+    font-feature-settings: inherit;
+    font-variation-settings: inherit;
+    letter-spacing: inherit;
+    color: inherit;
+    border-radius: 0;
+    background-color: transparent;
+    opacity: 1;
+  }
+  :where(select:is([multiple], [size])) optgroup {
+    font-weight: bolder;
+  }
+  :where(select:is([multiple], [size])) optgroup option {
+    padding-inline-start: 20px;
+  }
+  ::file-selector-button {
+    margin-inline-end: 4px;
+  }
+  ::placeholder {
+    opacity: 1;
+  }
+  @supports (not (-webkit-appearance: -apple-pay-button))  or (contain-intrinsic-size: 1px) {
+    ::placeholder {
+      color: currentcolor;
+      @supports (color: color-mix(in lab, red, red)) {
+        color: color-mix(in oklab, currentcolor 50%, transparent);
+      }
+    }
+  }
+  textarea {
+    resize: vertical;
+  }
+  ::-webkit-search-decoration {
+    -webkit-appearance: none;
+  }
+  ::-webkit-date-and-time-value {
+    min-height: 1lh;
+    text-align: inherit;
+  }
+  ::-webkit-datetime-edit {
+    display: inline-flex;
+  }
+  ::-webkit-datetime-edit-fields-wrapper {
+    padding: 0;
+  }
+  ::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field {
+    padding-block: 0;
+  }
+  ::-webkit-calendar-picker-indicator {
+    line-height: 1;
+  }
+  :-moz-ui-invalid {
+    box-shadow: none;
+  }
+  button, input:where([type="button"], [type="reset"], [type="submit"]), ::file-selector-button {
+    appearance: button;
+  }
+  ::-webkit-inner-spin-button, ::-webkit-outer-spin-button {
+    height: auto;
+  }
+  [hidden]:where(:not([hidden="until-found"])) {
+    display: none !important;
+  }
+}
+@layer utilities {
+  .collapse {
+    visibility: collapse;
+  }
+  .invisible {
+    visibility: hidden;
+  }
+  .visible {
+    visibility: visible;
+  }
+  .sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border-width: 0;
+  }
+  .not-sr-only {
+    position: static;
+    width: auto;
+    height: auto;
+    padding: 0;
+    margin: 0;
+    overflow: visible;
+    clip-path: none;
+    white-space: normal;
+  }
+  .absolute {
+    position: absolute;
+  }
+  .fixed {
+    position: fixed;
+  }
+  .relative {
+    position: relative;
+  }
+  .static {
+    position: static;
+  }
+  .sticky {
+    position: sticky;
+  }
+  .-inset-1 {
+    inset: calc(var(--spacing) * -1);
+  }
+  .isolate {
+    isolation: isolate;
+  }
+  .isolation-auto {
+    isolation: auto;
+  }
+  .\!container {
+    width: 100% !important;
+    @media (width >= 40rem) {
+      max-width: 40rem !important;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem !important;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem !important;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem !important;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem !important;
+    }
+  }
+  .container {
+    width: 100%;
+    @media (width >= 40rem) {
+      max-width: 40rem;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem;
+    }
+  }
+  .mx-auto {
+    margin-inline: auto;
+  }
+  .my-6 {
+    margin-block: calc(var(--spacing) * 6);
+  }
+  .mt-1 {
+    margin-top: calc(var(--spacing) * 1);
+  }
+  .mt-3 {
+    margin-top: calc(var(--spacing) * 3);
+  }
+  .mt-4 {
+    margin-top: calc(var(--spacing) * 4);
+  }
+  .mt-5 {
+    margin-top: calc(var(--spacing) * 5);
+  }
+  .mt-6 {
+    margin-top: calc(var(--spacing) * 6);
+  }
+  .mb-2 {
+    margin-bottom: calc(var(--spacing) * 2);
+  }
+  .mb-3 {
+    margin-bottom: calc(var(--spacing) * 3);
+  }
+  .mb-4 {
+    margin-bottom: calc(var(--spacing) * 4);
+  }
+  .mb-6 {
+    margin-bottom: calc(var(--spacing) * 6);
+  }
+  .mb-8 {
+    margin-bottom: calc(var(--spacing) * 8);
+  }
+  .ml-4 {
+    margin-left: calc(var(--spacing) * 4);
+  }
+  .block {
+    display: block;
+  }
+  .contents {
+    display: contents;
+  }
+  .flex {
+    display: flex;
+  }
+  .flow-root {
+    display: flow-root;
+  }
+  .grid {
+    display: grid;
+  }
+  .hidden {
+    display: none;
+  }
+  .inline {
+    display: inline;
+  }
+  .inline-block {
+    display: inline-block;
+  }
+  .inline-flex {
+    display: inline-flex;
+  }
+  .inline-grid {
+    display: inline-grid;
+  }
+  .inline-table {
+    display: inline-table;
+  }
+  .list-item {
+    display: list-item;
+  }
+  .table {
+    display: table;
+  }
+  .table-caption {
+    display: table-caption;
+  }
+  .table-cell {
+    display: table-cell;
+  }
+  .table-column {
+    display: table-column;
+  }
+  .table-column-group {
+    display: table-column-group;
+  }
+  .table-footer-group {
+    display: table-footer-group;
+  }
+  .table-header-group {
+    display: table-header-group;
+  }
+  .table-row {
+    display: table-row;
+  }
+  .table-row-group {
+    display: table-row-group;
+  }
+  .h-2 {
+    height: calc(var(--spacing) * 2);
+  }
+  .h-32 {
+    height: calc(var(--spacing) * 32);
+  }
+  .h-96 {
+    height: calc(var(--spacing) * 96);
+  }
+  .min-h-full {
+    min-height: 100%;
+  }
+  .min-h-screen {
+    min-height: 100vh;
+  }
+  .w-2 {
+    width: calc(var(--spacing) * 2);
+  }
+  .w-full {
+    width: 100%;
+  }
+  .max-w-6xl {
+    max-width: var(--container-6xl);
+  }
+  .max-w-none {
+    max-width: none;
+  }
+  .min-w-full {
+    min-width: 100%;
+  }
+  .shrink {
+    flex-shrink: 1;
+  }
+  .grow {
+    flex-grow: 1;
+  }
+  .border-collapse {
+    border-collapse: collapse;
+  }
+  .translate-none {
+    translate: none;
+  }
+  .scale-3d {
+    scale: var(--tw-scale-x) var(--tw-scale-y) var(--tw-scale-z);
+  }
+  .transform {
+    transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,);
+  }
+  .touch-pinch-zoom {
+    --tw-pinch-zoom: pinch-zoom;
+    touch-action: var(--tw-pan-x,) var(--tw-pan-y,) var(--tw-pinch-zoom,);
+  }
+  .resize {
+    resize: both;
+  }
+  .list-inside {
+    list-style-position: inside;
+  }
+  .list-decimal {
+    list-style-type: decimal;
+  }
+  .list-disc {
+    list-style-type: disc;
+  }
+  .grid-cols-1 {
+    grid-template-columns: repeat(1, minmax(0, 1fr));
+  }
+  .flex-wrap {
+    flex-wrap: wrap;
+  }
+  .items-center {
+    align-items: center;
+  }
+  .items-start {
+    align-items: flex-start;
+  }
+  .gap-2 {
+    gap: calc(var(--spacing) * 2);
+  }
+  .gap-4 {
+    gap: calc(var(--spacing) * 4);
+  }
+  .gap-6 {
+    gap: calc(var(--spacing) * 6);
+  }
+  .space-y-1 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-2 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 2) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 2) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 1;
+    }
+  }
+  .space-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-x-reverse: 1;
+    }
+  }
+  .divide-x {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 0;
+      border-inline-style: var(--tw-border-style);
+      border-inline-start-width: calc(1px * var(--tw-divide-x-reverse));
+      border-inline-end-width: calc(1px * calc(1 - var(--tw-divide-x-reverse)));
+    }
+  }
+  .divide-y {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 0;
+      border-bottom-style: var(--tw-border-style);
+      border-top-style: var(--tw-border-style);
+      border-top-width: calc(1px * var(--tw-divide-y-reverse));
+      border-bottom-width: calc(1px * calc(1 - var(--tw-divide-y-reverse)));
+    }
+  }
+  .divide-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 1;
+    }
+  }
+  .truncate {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+  .overflow-auto {
+    overflow: auto;
+  }
+  .overflow-x-auto {
+    overflow-x: auto;
+  }
+  .rounded {
+    border-radius: var(--radius);
+  }
+  .rounded-full {
+    border-radius: calc(infinity * 1px);
+  }
+  .rounded-lg {
+    border-radius: var(--radius-lg);
+  }
+  .rounded-md {
+    border-radius: var(--radius-md);
+  }
+  .rounded-s {
+    border-start-start-radius: var(--radius);
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-ss {
+    border-start-start-radius: var(--radius);
+  }
+  .rounded-e {
+    border-start-end-radius: var(--radius);
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-se {
+    border-start-end-radius: var(--radius);
+  }
+  .rounded-ee {
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-es {
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-t {
+    border-top-left-radius: var(--radius);
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-l {
+    border-top-left-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-tl {
+    border-top-left-radius: var(--radius);
+  }
+  .rounded-r {
+    border-top-right-radius: var(--radius);
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-tr {
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-b {
+    border-bottom-right-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-br {
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-bl {
+    border-bottom-left-radius: var(--radius);
+  }
+  .border {
+    border-style: var(--tw-border-style);
+    border-width: 1px;
+  }
+  .border-x {
+    border-inline-style: var(--tw-border-style);
+    border-inline-width: 1px;
+  }
+  .border-y {
+    border-block-style: var(--tw-border-style);
+    border-block-width: 1px;
+  }
+  .border-s {
+    border-inline-start-style: var(--tw-border-style);
+    border-inline-start-width: 1px;
+  }
+  .border-e {
+    border-inline-end-style: var(--tw-border-style);
+    border-inline-end-width: 1px;
+  }
+  .border-t {
+    border-top-style: var(--tw-border-style);
+    border-top-width: 1px;
+  }
+  .border-r {
+    border-right-style: var(--tw-border-style);
+    border-right-width: 1px;
+  }
+  .border-b {
+    border-bottom-style: var(--tw-border-style);
+    border-bottom-width: 1px;
+  }
+  .border-l {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 1px;
+  }
+  .border-l-4 {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 4px;
+  }
+  .border-blue-200 {
+    border-color: var(--color-blue-200);
+  }
+  .border-border {
+    border-color: var(--color-border);
+  }
+  .border-gray-300 {
+    border-color: var(--color-gray-300);
+  }
+  .bg-background {
+    background-color: var(--color-background);
+  }
+  .bg-blue-50 {
+    background-color: var(--color-blue-50);
+  }
+  .bg-gray-50 {
+    background-color: var(--color-gray-50);
+  }
+  .bg-gray-400 {
+    background-color: var(--color-gray-400);
+  }
+  .bg-gray-500 {
+    background-color: var(--color-gray-500);
+  }
+  .bg-green-500 {
+    background-color: var(--color-green-500);
+  }
+  .bg-panel {
+    background-color: var(--color-panel);
+  }
+  .bg-red-500 {
+    background-color: var(--color-red-500);
+  }
+  .bg-white {
+    background-color: var(--color-white);
+  }
+  .bg-repeat {
+    background-repeat: repeat;
+  }
+  .mask-no-clip {
+    mask-clip: no-clip;
+  }
+  .mask-repeat {
+    mask-repeat: repeat;
+  }
+  .p-4 {
+    padding: calc(var(--spacing) * 4);
+  }
+  .p-6 {
+    padding: calc(var(--spacing) * 6);
+  }
+  .px-1 {
+    padding-inline: calc(var(--spacing) * 1);
+  }
+  .px-3 {
+    padding-inline: calc(var(--spacing) * 3);
+  }
+  .px-4 {
+    padding-inline: calc(var(--spacing) * 4);
+  }
+  .py-0\.5 {
+    padding-block: calc(var(--spacing) * 0.5);
+  }
+  .py-1 {
+    padding-block: calc(var(--spacing) * 1);
+  }
+  .py-2 {
+    padding-block: calc(var(--spacing) * 2);
+  }
+  .pl-4 {
+    padding-left: calc(var(--spacing) * 4);
+  }
+  .text-left {
+    text-align: left;
+  }
+  .font-mono {
+    font-family: var(--font-mono);
+  }
+  .text-2xl {
+    font-size: var(--text-2xl);
+    line-height: var(--tw-leading, var(--text-2xl--line-height));
+  }
+  .text-3xl {
+    font-size: var(--text-3xl);
+    line-height: var(--tw-leading, var(--text-3xl--line-height));
+  }
+  .text-base {
+    font-size: var(--text-base);
+    line-height: var(--tw-leading, var(--text-base--line-height));
+  }
+  .text-lg {
+    font-size: var(--text-lg);
+    line-height: var(--tw-leading, var(--text-lg--line-height));
+  }
+  .text-sm {
+    font-size: var(--text-sm);
+    line-height: var(--tw-leading, var(--text-sm--line-height));
+  }
+  .text-xl {
+    font-size: var(--text-xl);
+    line-height: var(--tw-leading, var(--text-xl--line-height));
+  }
+  .leading-relaxed {
+    --tw-leading: var(--leading-relaxed);
+    line-height: var(--leading-relaxed);
+  }
+  .font-bold {
+    --tw-font-weight: var(--font-weight-bold);
+    font-weight: var(--font-weight-bold);
+  }
+  .font-medium {
+    --tw-font-weight: var(--font-weight-medium);
+    font-weight: var(--font-weight-medium);
+  }
+  .font-semibold {
+    --tw-font-weight: var(--font-weight-semibold);
+    font-weight: var(--font-weight-semibold);
+  }
+  .text-wrap {
+    text-wrap: wrap;
+  }
+  .text-clip {
+    text-overflow: clip;
+  }
+  .text-ellipsis {
+    text-overflow: ellipsis;
+  }
+  .text-accent {
+    color: var(--color-accent);
+  }
+  .text-blue-500 {
+    color: var(--color-blue-500);
+  }
+  .text-blue-800 {
+    color: var(--color-blue-800);
+  }
+  .text-blue-900 {
+    color: var(--color-blue-900);
+  }
+  .text-gray-600 {
+    color: var(--color-gray-600);
+  }
+  .text-gray-700 {
+    color: var(--color-gray-700);
+  }
+  .text-gray-900 {
+    color: var(--color-gray-900);
+  }
+  .text-muted {
+    color: var(--color-muted);
+  }
+  .text-primary {
+    color: var(--color-primary);
+  }
+  .text-secondary {
+    color: var(--color-secondary);
+  }
+  .text-white {
+    color: var(--color-white);
+  }
+  .capitalize {
+    text-transform: capitalize;
+  }
+  .lowercase {
+    text-transform: lowercase;
+  }
+  .normal-case {
+    text-transform: none;
+  }
+  .uppercase {
+    text-transform: uppercase;
+  }
+  .italic {
+    font-style: italic;
+  }
+  .not-italic {
+    font-style: normal;
+  }
+  .diagonal-fractions {
+    --tw-numeric-fraction: diagonal-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .lining-nums {
+    --tw-numeric-figure: lining-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .oldstyle-nums {
+    --tw-numeric-figure: oldstyle-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .ordinal {
+    --tw-ordinal: ordinal;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .proportional-nums {
+    --tw-numeric-spacing: proportional-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .slashed-zero {
+    --tw-slashed-zero: slashed-zero;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .stacked-fractions {
+    --tw-numeric-fraction: stacked-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .tabular-nums {
+    --tw-numeric-spacing: tabular-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .normal-nums {
+    font-variant-numeric: normal;
+  }
+  .line-through {
+    text-decoration-line: line-through;
+  }
+  .no-underline {
+    text-decoration-line: none;
+  }
+  .overline {
+    text-decoration-line: overline;
+  }
+  .underline {
+    text-decoration-line: underline;
+  }
+  .antialiased {
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+  .subpixel-antialiased {
+    -webkit-font-smoothing: auto;
+    -moz-osx-font-smoothing: auto;
+  }
+  .shadow {
+    --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .shadow-sm {
+    --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .ring {
+    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .inset-ring {
+    --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .outline {
+    outline-style: var(--tw-outline-style);
+    outline-width: 1px;
+  }
+  .blur {
+    --tw-blur: blur(8px);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .drop-shadow {
+    --tw-drop-shadow-size: drop-shadow(0 1px 2px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.1))) drop-shadow(0 1px 1px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.06)));
+    --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .grayscale {
+    --tw-grayscale: grayscale(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .invert {
+    --tw-invert: invert(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .sepia {
+    --tw-sepia: sepia(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .filter {
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .backdrop-blur {
+    --tw-backdrop-blur: blur(8px);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-grayscale {
+    --tw-backdrop-grayscale: grayscale(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-invert {
+    --tw-backdrop-invert: invert(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-sepia {
+    --tw-backdrop-sepia: sepia(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-filter {
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .transition {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .transition-colors {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .ease-in {
+    --tw-ease: var(--ease-in);
+    transition-timing-function: var(--ease-in);
+  }
+  .ease-in-out {
+    --tw-ease: var(--ease-in-out);
+    transition-timing-function: var(--ease-in-out);
+  }
+  .ease-out {
+    --tw-ease: var(--ease-out);
+    transition-timing-function: var(--ease-out);
+  }
+  .divide-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 1;
+    }
+  }
+  .ring-inset {
+    --tw-ring-inset: inset;
+  }
+  .hover\:bg-gray-600 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-gray-600);
+      }
+    }
+  }
+  .hover\:bg-green-600 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-green-600);
+      }
+    }
+  }
+  .hover\:bg-red-600 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-red-600);
+      }
+    }
+  }
+  .hover\:text-accent-300 {
+    &:hover {
+      @media (hover: hover) {
+        color: var(--color-accent-300);
+      }
+    }
+  }
+  .focus\:border-blue-500 {
+    &:focus {
+      border-color: var(--color-blue-500);
+    }
+  }
+  .focus\:ring-2 {
+    &:focus {
+      --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
+      box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+    }
+  }
+  .focus\:ring-blue-500 {
+    &:focus {
+      --tw-ring-color: var(--color-blue-500);
+    }
+  }
+  .md\:grid-cols-3 {
+    @media (width >= 48rem) {
+      grid-template-columns: repeat(3, minmax(0, 1fr));
+    }
+  }
+}
+@property --tw-scale-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-z {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-rotate-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-z {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pinch-zoom {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-space-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-space-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-divide-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-border-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-divide-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-leading {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-font-weight {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ordinal {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-slashed-zero {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-figure {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-spacing {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-fraction {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-inset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-ring-inset {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-offset-width {
+  syntax: "<length>";
+  inherits: false;
+  initial-value: 0px;
+}
+@property --tw-ring-offset-color {
+  syntax: "*";
+  inherits: false;
+  initial-value: #fff;
+}
+@property --tw-ring-offset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-outline-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-drop-shadow-size {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ease {
+  syntax: "*";
+  inherits: false;
+}
+@layer properties {
+  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
+    *, ::before, ::after, ::backdrop {
+      --tw-scale-x: 1;
+      --tw-scale-y: 1;
+      --tw-scale-z: 1;
+      --tw-rotate-x: initial;
+      --tw-rotate-y: initial;
+      --tw-rotate-z: initial;
+      --tw-skew-x: initial;
+      --tw-skew-y: initial;
+      --tw-pan-x: initial;
+      --tw-pan-y: initial;
+      --tw-pinch-zoom: initial;
+      --tw-space-y-reverse: 0;
+      --tw-space-x-reverse: 0;
+      --tw-divide-x-reverse: 0;
+      --tw-border-style: solid;
+      --tw-divide-y-reverse: 0;
+      --tw-leading: initial;
+      --tw-font-weight: initial;
+      --tw-ordinal: initial;
+      --tw-slashed-zero: initial;
+      --tw-numeric-figure: initial;
+      --tw-numeric-spacing: initial;
+      --tw-numeric-fraction: initial;
+      --tw-shadow: 0 0 #0000;
+      --tw-shadow-color: initial;
+      --tw-shadow-alpha: 100%;
+      --tw-inset-shadow: 0 0 #0000;
+      --tw-inset-shadow-color: initial;
+      --tw-inset-shadow-alpha: 100%;
+      --tw-ring-color: initial;
+      --tw-ring-shadow: 0 0 #0000;
+      --tw-inset-ring-color: initial;
+      --tw-inset-ring-shadow: 0 0 #0000;
+      --tw-ring-inset: initial;
+      --tw-ring-offset-width: 0px;
+      --tw-ring-offset-color: #fff;
+      --tw-ring-offset-shadow: 0 0 #0000;
+      --tw-outline-style: solid;
+      --tw-blur: initial;
+      --tw-brightness: initial;
+      --tw-contrast: initial;
+      --tw-grayscale: initial;
+      --tw-hue-rotate: initial;
+      --tw-invert: initial;
+      --tw-opacity: initial;
+      --tw-saturate: initial;
+      --tw-sepia: initial;
+      --tw-drop-shadow: initial;
+      --tw-drop-shadow-color: initial;
+      --tw-drop-shadow-alpha: 100%;
+      --tw-drop-shadow-size: initial;
+      --tw-backdrop-blur: initial;
+      --tw-backdrop-brightness: initial;
+      --tw-backdrop-contrast: initial;
+      --tw-backdrop-grayscale: initial;
+      --tw-backdrop-hue-rotate: initial;
+      --tw-backdrop-invert: initial;
+      --tw-backdrop-opacity: initial;
+      --tw-backdrop-saturate: initial;
+      --tw-backdrop-sepia: initial;
+      --tw-ease: initial;
+    }
+  }
+}

From a48c80bbfdef34b9783e11f5c7dac4c603373a74 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Sun, 7 Sep 2025 13:17:58 -0700
Subject: [PATCH 072/134] remove vdom.UseAtom

---
 tsunami/comp/rootelem.go          |  8 ++++
 tsunami/demo/cpuchart/app.go      | 36 ++++++++----------
 tsunami/demo/githubaction/app.go  | 61 +++++++++++++++----------------
 tsunami/demo/recharts/app.go      | 18 ++++-----
 tsunami/demo/tsunamiconfig/app.go |  6 +--
 tsunami/go.mod                    |  1 +
 tsunami/go.sum                    |  2 +
 tsunami/vdom/vdom.go              | 33 -----------------
 8 files changed, 69 insertions(+), 96 deletions(-)

diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index c18b9cc4a9..c925ae656f 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -14,6 +14,7 @@ import (
 	"unicode"
 
 	"github.com/google/uuid"
+	"github.com/outrigdev/goid"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -25,6 +26,7 @@ const ChildrenPropKey = "children"
 // is set ONLY when we're in the render function of a component
 // used for hooks, and automatic dependency tracking
 var globalVC *VDomContextImpl
+var globalRenderGoId uint64
 
 type RenderOpts struct {
 	Resync bool
@@ -443,13 +445,19 @@ func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
 
 func withGlobalCtx[T any](vc *VDomContextImpl, fn func() T) T {
 	globalVC = vc
+	globalRenderGoId = goid.Get()
 	defer func() {
 		globalVC = nil
+		globalRenderGoId = 0
 	}()
 	return fn()
 }
 
 func GetGlobalContext() *VDomContextImpl {
+	gid := goid.Get()
+	if gid != globalRenderGoId {
+		return nil
+	}
 	return globalVC
 }
 
diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
index d625b82c1a..52797afd52 100644
--- a/tsunami/demo/cpuchart/app.go
+++ b/tsunami/demo/cpuchart/app.go
@@ -77,7 +77,7 @@ var StatsPanel = app.DefineComponent("StatsPanel",
 			if lastPoint.CPUUsage != nil {
 				currentUsage = *lastPoint.CPUUsage
 			}
-			
+
 			// Calculate average and max from non-nil values
 			total := 0.0
 			for _, point := range props.Data {
@@ -145,12 +145,8 @@ var App = app.DefineComponent("App",
 	func(ctx context.Context, _ struct{}) any {
 		vdom.UseSetAppTitle(ctx, "CPU Usage Monitor")
 
-		// Global state using atoms
-		cpuData, setCpuData, setCpuDataFn := vdom.UseAtom[[]CPUDataPoint](ctx, cpuDataAtom)
-		dataPointCount, _, _ := vdom.UseAtom[int](ctx, dataPointCountAtom)
-
 		// Local state for forcing re-renders
-		_, _, setTickerFn := vdom.UseState[int](ctx, 0)
+		_, _, setTickerFn := vdom.UseState(ctx, 0)
 
 		// Timer effect for continuous CPU data collection
 		vdom.UseEffect(ctx, func() func() {
@@ -164,11 +160,11 @@ var App = app.DefineComponent("App",
 						return
 					case <-ticker.C:
 						// Collect new CPU data point and shift the data window
-						setCpuDataFn(func(currentData []CPUDataPoint) []CPUDataPoint {
+						cpuDataAtom.SetFn(func(currentData []CPUDataPoint) []CPUDataPoint {
 							newPoint := generateCPUDataPoint()
 							// Read current config inside the loop to get live updates
 							currentDataPointCount := dataPointCountAtom.Get()
-							
+
 							// Ensure we have the right size array
 							if len(currentData) != currentDataPointCount {
 								// Resize array if config changed
@@ -217,7 +213,7 @@ var App = app.DefineComponent("App",
 					Timestamp: "",
 				}
 			}
-			setCpuData(initialData)
+			cpuDataAtom.Set(initialData)
 		}
 
 		return vdom.H("div", map[string]any{
@@ -263,7 +259,7 @@ var App = app.DefineComponent("App",
 							}, "Live Monitoring"),
 							vdom.H("span", map[string]any{
 								"className": "text-sm text-gray-500 ml-2",
-							}, "(", len(cpuData), "/", dataPointCount, " data points)"),
+							}, "(", len(cpuDataAtom.Get()), "/", dataPointCountAtom.Get(), " data points)"),
 						),
 					),
 				),
@@ -272,7 +268,7 @@ var App = app.DefineComponent("App",
 				StatsPanel(struct {
 					Data []CPUDataPoint `json:"data"`
 				}{
-					Data: cpuData,
+					Data: cpuDataAtom.Get(),
 				}),
 
 				// Main chart
@@ -290,8 +286,8 @@ var App = app.DefineComponent("App",
 							"height": "100%",
 						},
 							vdom.H("recharts:LineChart", map[string]any{
-								"data":               cpuData,
-								"isAnimationActive":  false,
+								"data":              cpuDataAtom.Get(),
+								"isAnimationActive": false,
 							},
 								vdom.H("recharts:CartesianGrid", map[string]any{
 									"strokeDasharray": "3 3",
@@ -319,13 +315,13 @@ var App = app.DefineComponent("App",
 									},
 								}),
 								vdom.H("recharts:Line", map[string]any{
-									"type":               "monotone",
-									"dataKey":            "cpuUsage",
-									"stroke":             "#3B82F6",
-									"strokeWidth":        2,
-									"dot":                false,
-									"name":               "CPU Usage (%)",
-									"isAnimationActive":  false,
+									"type":              "monotone",
+									"dataKey":           "cpuUsage",
+									"stroke":            "#3B82F6",
+									"strokeWidth":       2,
+									"dot":               false,
+									"name":              "CPU Usage (%)",
+									"isAnimationActive": false,
 								}),
 							),
 						),
diff --git a/tsunami/demo/githubaction/app.go b/tsunami/demo/githubaction/app.go
index e34af22ba2..9cc424cf10 100644
--- a/tsunami/demo/githubaction/app.go
+++ b/tsunami/demo/githubaction/app.go
@@ -223,37 +223,27 @@ var WorkflowRunItem = app.DefineComponent("WorkflowRunItem",
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ struct{}) any {
 		vdom.UseSetAppTitle(ctx, "GitHub Actions Monitor")
-
-		workflowRuns, setWorkflowRuns, _ := vdom.UseAtom[[]WorkflowRun](ctx, workflowRunsAtom)
-		lastError, setLastError, _ := vdom.UseAtom[string](ctx, lastErrorAtom)
-		isLoading, setIsLoading, _ := vdom.UseAtom[bool](ctx, isLoadingAtom)
-		lastRefreshTime, setLastRefreshTime, _ := vdom.UseAtom[time.Time](ctx, lastRefreshTimeAtom)
-		pollInterval, _, _ := vdom.UseAtom[int](ctx, pollIntervalAtom)
-		repository, _, _ := vdom.UseAtom[string](ctx, repositoryAtom)
-		workflow, _, _ := vdom.UseAtom[string](ctx, workflowAtom)
-		maxWorkflowRuns, _, _ := vdom.UseAtom[int](ctx, maxWorkflowRunsAtom)
-
-		_, _, setTickerFn := vdom.UseState[int](ctx, 0)
+		_, _, setTickerFn := vdom.UseState(ctx, 0)
 
 		vdom.UseEffect(ctx, func() func() {
-			ticker := time.NewTicker(time.Duration(pollInterval) * time.Second)
+			ticker := time.NewTicker(time.Duration(pollIntervalAtom.Get()) * time.Second)
 			done := make(chan bool)
 
 			fetchData := func() {
 				currentMaxRuns := maxWorkflowRunsAtom.Get()
-				runs, err := fetchWorkflowRuns(repository, workflow, currentMaxRuns)
+				runs, err := fetchWorkflowRuns(repositoryAtom.Get(), workflowAtom.Get(), currentMaxRuns)
 				if err != nil {
 					log.Printf("Error fetching workflow runs: %v", err)
-					setLastError(err.Error())
+					lastErrorAtom.Set(err.Error())
 				} else {
 					sort.Slice(runs, func(i, j int) bool {
 						return runs[i].CreatedAt.After(runs[j].CreatedAt)
 					})
-					setWorkflowRuns(runs)
-					setLastError("")
+					workflowRunsAtom.Set(runs)
+					lastErrorAtom.Set("")
 				}
-				setLastRefreshTime(time.Now())
-				setIsLoading(false)
+				lastRefreshTimeAtom.Set(time.Now())
+				isLoadingAtom.Set(false)
 			}
 
 			fetchData()
@@ -275,29 +265,38 @@ var App = app.DefineComponent("App",
 				ticker.Stop()
 				close(done)
 			}
-		}, []any{pollInterval})
+		}, []any{pollIntervalAtom.Get()})
 
 		handleRefresh := func() {
-			setIsLoading(true)
+			isLoadingAtom.Set(true)
 			go func() {
 				currentMaxRuns := maxWorkflowRunsAtom.Get()
-				runs, err := fetchWorkflowRuns(repository, workflow, currentMaxRuns)
+				runs, err := fetchWorkflowRuns(repositoryAtom.Get(), workflowAtom.Get(), currentMaxRuns)
 				if err != nil {
 					log.Printf("Error fetching workflow runs: %v", err)
-					setLastError(err.Error())
+					lastErrorAtom.Set(err.Error())
 				} else {
 					sort.Slice(runs, func(i, j int) bool {
 						return runs[i].CreatedAt.After(runs[j].CreatedAt)
 					})
-					setWorkflowRuns(runs)
-					setLastError("")
+					workflowRunsAtom.Set(runs)
+					lastErrorAtom.Set("")
 				}
-				setLastRefreshTime(time.Now())
-				setIsLoading(false)
+				lastRefreshTimeAtom.Set(time.Now())
+				isLoadingAtom.Set(false)
 				app.SendAsyncInitiation()
 			}()
 		}
 
+		workflowRuns := workflowRunsAtom.Get()
+		lastError := lastErrorAtom.Get()
+		isLoading := isLoadingAtom.Get()
+		lastRefreshTime := lastRefreshTimeAtom.Get()
+		pollInterval := pollIntervalAtom.Get()
+		repository := repositoryAtom.Get()
+		workflow := workflowAtom.Get()
+		maxWorkflowRuns := maxWorkflowRunsAtom.Get()
+
 		return vdom.H("div", map[string]any{
 			"className": "min-h-screen bg-gray-900 text-white p-6",
 		},
@@ -312,7 +311,7 @@ var App = app.DefineComponent("App",
 					}, "GitHub Actions Monitor"),
 					vdom.H("p", map[string]any{
 						"className": "text-gray-400",
-					}, "Monitoring ", repository, " ", workflow, " workflow"),
+					}, "Monitoring ", repositoryAtom.Get(), " ", workflowAtom.Get(), " workflow"),
 				),
 
 				vdom.H("div", map[string]any{
@@ -327,11 +326,11 @@ var App = app.DefineComponent("App",
 							vdom.H("button", map[string]any{
 								"className": vdom.Classes(
 									"px-4 py-2 rounded-md text-sm font-medium transition-colors cursor-pointer",
-									vdom.IfElse(isLoading, "bg-gray-600 text-gray-400", "bg-blue-600 hover:bg-blue-700 text-white"),
+									vdom.IfElse(isLoadingAtom.Get(), "bg-gray-600 text-gray-400", "bg-blue-600 hover:bg-blue-700 text-white"),
 								),
-								"onClick":  vdom.If(!isLoading, handleRefresh),
-								"disabled": isLoading,
-							}, vdom.IfElse(isLoading, "Refreshing...", "Refresh")),
+								"onClick":  vdom.If(!isLoadingAtom.Get(), handleRefresh),
+								"disabled": isLoadingAtom.Get(),
+							}, vdom.IfElse(isLoadingAtom.Get(), "Refreshing...", "Refresh")),
 
 							vdom.H("div", map[string]any{
 								"className": "flex items-center gap-2",
diff --git a/tsunami/demo/recharts/app.go b/tsunami/demo/recharts/app.go
index 9dfaf67b3d..a838de1886 100644
--- a/tsunami/demo/recharts/app.go
+++ b/tsunami/demo/recharts/app.go
@@ -206,10 +206,10 @@ var App = app.DefineComponent("App",
 	func(ctx context.Context, _ struct{}) any {
 		vdom.UseSetAppTitle(ctx, "Recharts Demo")
 
-		// Global state using atoms
-		chartData, setChartData, setChartDataFn := vdom.UseAtom[[]DataPoint](ctx, chartDataAtom)
-		chartType, setChartType, _ := vdom.UseAtom[string](ctx, chartTypeAtom)
-		isAnimating, setIsAnimating, _ := vdom.UseAtom[bool](ctx, isAnimatingAtom)
+		// Get atom values once at the top
+		chartData := chartDataAtom.Get()
+		chartType := chartTypeAtom.Get()
+		isAnimating := isAnimatingAtom.Get()
 
 		// Local state for timer
 		_, _, setTickerFn := vdom.UseState[int](ctx, 0)
@@ -230,7 +230,7 @@ var App = app.DefineComponent("App",
 						return
 					case <-ticker.C:
 						// Add new data point and keep only last 20 points
-						setChartDataFn(func(currentData []DataPoint) []DataPoint {
+						chartDataAtom.SetFn(func(currentData []DataPoint) []DataPoint {
 							newData := append(currentData, generateNewDataPoint(currentData))
 							if len(newData) > 20 {
 								newData = newData[1:]
@@ -251,16 +251,16 @@ var App = app.DefineComponent("App",
 		}, []any{isAnimating})
 
 		handleStartStop := func() {
-			setIsAnimating(!isAnimating)
+			isAnimatingAtom.Set(!isAnimating)
 		}
 
 		handleReset := func() {
-			setChartData(generateInitialData())
-			setIsAnimating(false)
+			chartDataAtom.Set(generateInitialData())
+			isAnimatingAtom.Set(false)
 		}
 
 		handleChartTypeChange := func(newType string) {
-			setChartType(newType)
+			chartTypeAtom.Set(newType)
 		}
 
 		return vdom.H("div", map[string]any{
diff --git a/tsunami/demo/tsunamiconfig/app.go b/tsunami/demo/tsunamiconfig/app.go
index 469444d6ad..f529ee496c 100644
--- a/tsunami/demo/tsunamiconfig/app.go
+++ b/tsunami/demo/tsunamiconfig/app.go
@@ -257,8 +257,8 @@ var App = app.DefineComponent("App",
 	func(ctx context.Context, _ any) any {
 		vdom.UseSetAppTitle(ctx, "Tsunami Config Manager")
 
-		// Use UseConfig for the URL input so it persists
-		urlInput, setURLInput, _ := vdom.UseAtom[string](ctx, serverURLAtom)
+		// Get atom value once at the top
+		urlInput := serverURLAtom.Get()
 		jsonContent, setJSONContent, _ := vdom.UseState(ctx, "")
 		errorMessage, setErrorMessage, _ := vdom.UseState(ctx, "")
 		successMessage, setSuccessMessage, _ := vdom.UseState(ctx, "")
@@ -342,7 +342,7 @@ var App = app.DefineComponent("App",
 
 			URLInput(URLInputProps{
 				Value:     urlInput,
-				OnChange:  setURLInput,
+				OnChange:  serverURLAtom.Set,
 				OnSubmit:  fetchConfigData,
 				IsLoading: isLoading,
 			}),
diff --git a/tsunami/go.mod b/tsunami/go.mod
index 2f9a557fb6..b9ccfffda4 100644
--- a/tsunami/go.mod
+++ b/tsunami/go.mod
@@ -4,6 +4,7 @@ go 1.24.6
 
 require (
 	github.com/google/uuid v1.6.0
+	github.com/outrigdev/goid v0.3.0
 	github.com/spf13/cobra v1.10.1
 	golang.org/x/mod v0.27.0
 )
diff --git a/tsunami/go.sum b/tsunami/go.sum
index 9aaf33b329..47484dfb22 100644
--- a/tsunami/go.sum
+++ b/tsunami/go.sum
@@ -3,6 +3,8 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/outrigdev/goid v0.3.0 h1:t/otQD3EXc45cLtQVPUnNgEyRaTQA4cPeu3qVcrsIws=
+github.com/outrigdev/goid v0.3.0/go.mod h1:hEH7f27ypN/GHWt/7gvkRoFYR0LZizfUBIAbak4neVE=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
 github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index b8fa23048b..73c2112e34 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -9,7 +9,6 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
 )
 
@@ -182,38 +181,6 @@ func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T
 	return rtnVal, typedSetVal, typedSetFuncVal
 }
 
-func useAtom[T any](ctx context.Context, hookName string, atomName string) (T, func(T), func(func(T) T)) {
-	rc := vdomctx.GetRenderContext(ctx)
-	if rc == nil {
-		panic(hookName + " must be called within a component (no context)")
-	}
-	val, setVal, setFn := rc.UseAtom(ctx, atomName)
-
-	// Adapt the "any" values to type "T"
-	atomVal := util.GetTypedAtomValue[T](val, atomName)
-
-	typedSetVal := func(newVal T) {
-		setVal(newVal)
-	}
-
-	typedSetFuncVal := func(updateFunc func(T) T) {
-		setFn(func(oldVal any) any {
-			typedOldVal := util.GetTypedAtomValue[T](oldVal, atomName)
-			return updateFunc(typedOldVal)
-		})
-	}
-
-	return atomVal, typedSetVal, typedSetFuncVal
-}
-
-// UseAtom provides access to atom values using an Atom interface.
-// It returns the current atom value, a setter function, and an updater function.
-// Setting a new value causes a re-render of all components using this atom.
-// This hook must be called within a component context.
-func UseAtom[T any](ctx context.Context, atom Atom) (T, func(T), func(func(T) T)) {
-	return useAtom[T](ctx, "UseAtom", atom.AtomName())
-}
-
 // UseVDomRef provides a reference to a DOM element in the VDOM tree.
 // It returns a VDomRef that can be attached to elements for direct DOM access.
 // The ref will not be current on the first render - refs are set and become

From 731aaf8efff5711d25cb98f54abb85d72fa3aa99 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 10:34:42 -0700
Subject: [PATCH 073/134] mutex for globalctx

---
 tsunami/comp/globalctx.go | 38 ++++++++++++++++++++++++++++++++++++++
 tsunami/comp/rootelem.go  | 24 ------------------------
 2 files changed, 38 insertions(+), 24 deletions(-)
 create mode 100644 tsunami/comp/globalctx.go

diff --git a/tsunami/comp/globalctx.go b/tsunami/comp/globalctx.go
new file mode 100644
index 0000000000..bb8aea27ca
--- /dev/null
+++ b/tsunami/comp/globalctx.go
@@ -0,0 +1,38 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package comp
+
+import (
+	"sync"
+
+	"github.com/outrigdev/goid"
+)
+
+// is set ONLY when we're in the render function of a component
+// used for hooks, and automatic dependency tracking
+var globalVC *VDomContextImpl
+var globalRenderGoId uint64
+var globalCtxMutex sync.Mutex
+
+func withGlobalCtx[T any](vc *VDomContextImpl, fn func() T) T {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	globalVC = vc
+	globalRenderGoId = goid.Get()
+	defer func() {
+		globalVC = nil
+		globalRenderGoId = 0
+	}()
+	return fn()
+}
+
+func GetGlobalContext() *VDomContextImpl {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	gid := goid.Get()
+	if gid != globalRenderGoId {
+		return nil
+	}
+	return globalVC
+}
diff --git a/tsunami/comp/rootelem.go b/tsunami/comp/rootelem.go
index c925ae656f..5a96fa09a4 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/comp/rootelem.go
@@ -14,7 +14,6 @@ import (
 	"unicode"
 
 	"github.com/google/uuid"
-	"github.com/outrigdev/goid"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -23,11 +22,6 @@ import (
 
 const ChildrenPropKey = "children"
 
-// is set ONLY when we're in the render function of a component
-// used for hooks, and automatic dependency tracking
-var globalVC *VDomContextImpl
-var globalRenderGoId uint64
-
 type RenderOpts struct {
 	Resync bool
 }
@@ -443,24 +437,6 @@ func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
 	return rtnVal[0].Interface()
 }
 
-func withGlobalCtx[T any](vc *VDomContextImpl, fn func() T) T {
-	globalVC = vc
-	globalRenderGoId = goid.Get()
-	defer func() {
-		globalVC = nil
-		globalRenderGoId = 0
-	}()
-	return fn()
-}
-
-func GetGlobalContext() *VDomContextImpl {
-	gid := goid.Get()
-	if gid != globalRenderGoId {
-		return nil
-	}
-	return globalVC
-}
-
 func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
 	if (*comp).Children != nil {
 		for _, child := range (*comp).Children {

From 638c0bd8b0a487e536cf7aedc37300ef60a5608b Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 11:03:34 -0700
Subject: [PATCH 074/134] rename "comp" to "engine" for internal stuff

---
 tsunami/app/atom.go                   |   8 +-
 tsunami/app/tsunamiapp.go             |  10 +-
 tsunami/{comp => engine}/comp.go      |   2 +-
 tsunami/{comp => engine}/globalctx.go |   2 +-
 tsunami/{comp => engine}/hooks.go     |   2 +-
 tsunami/{comp => engine}/root_test.go |   2 +-
 tsunami/{comp => engine}/rootelem.go  |   2 +-
 tsunami/vdom/vdom.go                  | 152 +++-----------------------
 tsunami/vdom/vdomhooks.go             | 126 +++++++++++++++++++++
 9 files changed, 158 insertions(+), 148 deletions(-)
 rename tsunami/{comp => engine}/comp.go (98%)
 rename tsunami/{comp => engine}/globalctx.go (98%)
 rename tsunami/{comp => engine}/hooks.go (99%)
 rename tsunami/{comp => engine}/root_test.go (99%)
 rename tsunami/{comp => engine}/rootelem.go (99%)
 create mode 100644 tsunami/vdom/vdomhooks.go

diff --git a/tsunami/app/atom.go b/tsunami/app/atom.go
index 0fa239707c..b479ae5875 100644
--- a/tsunami/app/atom.go
+++ b/tsunami/app/atom.go
@@ -7,7 +7,7 @@ import (
 	"log"
 	"runtime"
 
-	"github.com/wavetermdev/waveterm/tsunami/comp"
+	"github.com/wavetermdev/waveterm/tsunami/engine"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 )
 
@@ -34,7 +34,7 @@ func (a Atom[T]) AtomName() string {
 
 // Get returns the current value of the atom
 func (a Atom[T]) Get() T {
-	vc := comp.GetGlobalContext()
+	vc := engine.GetGlobalContext()
 	if vc != nil {
 		compWaveId := vc.GetCompWaveId()
 		vc.Root.AtomSetUsedBy(a.name, compWaveId, true)
@@ -45,7 +45,7 @@ func (a Atom[T]) Get() T {
 
 // Set updates the atom's value
 func (a Atom[T]) Set(newVal T) {
-	vc := comp.GetGlobalContext()
+	vc := engine.GetGlobalContext()
 	if vc != nil {
 		logInvalidAtomSet(a.name)
 		return
@@ -55,7 +55,7 @@ func (a Atom[T]) Set(newVal T) {
 }
 
 func (a Atom[T]) SetFn(fn func(T) T) {
-	vc := comp.GetGlobalContext()
+	vc := engine.GetGlobalContext()
 	if vc != nil {
 		logInvalidAtomSet(a.name)
 		return
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/app/tsunamiapp.go
index 25f90b2087..c6ac24ef2f 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/app/tsunamiapp.go
@@ -16,7 +16,7 @@ import (
 	"unicode"
 
 	"github.com/google/uuid"
-	"github.com/wavetermdev/waveterm/tsunami/comp"
+	"github.com/wavetermdev/waveterm/tsunami/engine"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -33,7 +33,7 @@ type ssEvent struct {
 
 type clientImpl struct {
 	Lock               *sync.Mutex
-	Root               *comp.RootElem
+	Root               *engine.RootElem
 	RootElem           *vdom.VDomElem
 	CurrentClientId    string
 	ServerId           string
@@ -49,7 +49,7 @@ type clientImpl struct {
 func makeClient() *clientImpl {
 	client := &clientImpl{
 		Lock:          &sync.Mutex{},
-		Root:          comp.MakeRoot(),
+		Root:          engine.MakeRoot(),
 		DoneCh:        make(chan struct{}),
 		SSEventCh:     make(chan ssEvent, 100),
 		UrlHandlerMux: http.NewServeMux(),
@@ -256,7 +256,7 @@ func (c *clientImpl) registerComponent(name string, cfunc any) error {
 }
 
 func (c *clientImpl) fullRender() (*rpctypes.VDomBackendUpdate, error) {
-	opts := &comp.RenderOpts{Resync: true}
+	opts := &engine.RenderOpts{Resync: true}
 	c.Root.RunWork(opts)
 	c.Root.Render(c.RootElem, opts)
 	renderedVDom := c.Root.MakeVDom()
@@ -279,7 +279,7 @@ func (c *clientImpl) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 }
 
 func (c *clientImpl) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
-	opts := &comp.RenderOpts{Resync: false}
+	opts := &engine.RenderOpts{Resync: false}
 	c.Root.RunWork(opts)
 	renderedVDom := c.Root.MakeVDom()
 	if renderedVDom == nil {
diff --git a/tsunami/comp/comp.go b/tsunami/engine/comp.go
similarity index 98%
rename from tsunami/comp/comp.go
rename to tsunami/engine/comp.go
index 101394dae0..a2f230225c 100644
--- a/tsunami/comp/comp.go
+++ b/tsunami/engine/comp.go
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package comp
+package engine
 
 import "github.com/wavetermdev/waveterm/tsunami/vdom"
 
diff --git a/tsunami/comp/globalctx.go b/tsunami/engine/globalctx.go
similarity index 98%
rename from tsunami/comp/globalctx.go
rename to tsunami/engine/globalctx.go
index bb8aea27ca..327ee094ad 100644
--- a/tsunami/comp/globalctx.go
+++ b/tsunami/engine/globalctx.go
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package comp
+package engine
 
 import (
 	"sync"
diff --git a/tsunami/comp/hooks.go b/tsunami/engine/hooks.go
similarity index 99%
rename from tsunami/comp/hooks.go
rename to tsunami/engine/hooks.go
index 175df60812..e5fb17053a 100644
--- a/tsunami/comp/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package comp
+package engine
 
 import (
 	"context"
diff --git a/tsunami/comp/root_test.go b/tsunami/engine/root_test.go
similarity index 99%
rename from tsunami/comp/root_test.go
rename to tsunami/engine/root_test.go
index 518cc2cca3..586cb71f53 100644
--- a/tsunami/comp/root_test.go
+++ b/tsunami/engine/root_test.go
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package comp
+package engine
 
 import (
 	"context"
diff --git a/tsunami/comp/rootelem.go b/tsunami/engine/rootelem.go
similarity index 99%
rename from tsunami/comp/rootelem.go
rename to tsunami/engine/rootelem.go
index 5a96fa09a4..1fd059562d 100644
--- a/tsunami/comp/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package comp
+package engine
 
 import (
 	"context"
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index 73c2112e34..89c6afcc37 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -152,140 +152,6 @@ func ForEach[T any](items []T, fn func(T, int) any) []any {
 	return elems
 }
 
-// UseState is the tsunami analog to React's useState hook.
-// It provides persistent state management within a VDOM component, returning the current
-// state value, a setter function, and an updater function.
-// Setting a new value causes a re-render of the component.
-// This hook must be called within a component context.
-func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T)) {
-	rc := vdomctx.GetRenderContext(ctx)
-	if rc == nil {
-		panic("UseState must be called within a component (no context)")
-	}
-	val, setVal, setFn := rc.UseState(ctx, initialVal)
-
-	// Adapt the "any" values to type "T"
-	var rtnVal T
-	rtnVal, ok := val.(T)
-	if !ok {
-		panic("UseState hook value is not a state (possible out of order or conditional hooks)")
-	}
-	typedSetVal := func(newVal T) {
-		setVal(newVal)
-	}
-	typedSetFuncVal := func(updateFunc func(T) T) {
-		setFn(func(oldVal any) any {
-			return updateFunc(oldVal.(T))
-		})
-	}
-	return rtnVal, typedSetVal, typedSetFuncVal
-}
-
-// UseVDomRef provides a reference to a DOM element in the VDOM tree.
-// It returns a VDomRef that can be attached to elements for direct DOM access.
-// The ref will not be current on the first render - refs are set and become
-// current after client-side mounting.
-// This hook must be called within a component context.
-func UseVDomRef(ctx context.Context) *VDomRef {
-	rc := vdomctx.GetRenderContext(ctx)
-	val := rc.UseVDomRef(ctx)
-	refVal, ok := val.(*VDomRef)
-	if !ok {
-		panic("UseVDomRef hook value is not a ref (possible out of order or conditional hooks)")
-	}
-	return refVal
-}
-
-// UseRef is the tsunami analog to React's useRef hook.
-// It provides a mutable ref object that persists across re-renders.
-// Unlike UseVDomRef, this is not tied to DOM elements but holds arbitrary values.
-// This hook must be called within a component context.
-func UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T] {
-	rc := vdomctx.GetRenderContext(ctx)
-	refVal := rc.UseRef(ctx, &VDomSimpleRef[T]{Current: val})
-	typedRef, ok := refVal.(*VDomSimpleRef[T])
-	if !ok {
-		panic("UseRef hook value is not a ref (possible out of order or conditional hooks)")
-	}
-	return typedRef
-}
-
-// UseId returns the underlying component's unique identifier (UUID).
-// The ID persists across re-renders but is recreated when the component
-// is recreated, following React component lifecycle.
-// This hook must be called within a component context.
-func UseId(ctx context.Context) string {
-	rc := vdomctx.GetRenderContext(ctx)
-	if rc == nil {
-		panic("UseId must be called within a component (no context)")
-	}
-	return rc.UseId(ctx)
-}
-
-// UseRenderTs returns the timestamp of the current render.
-// This hook must be called within a component context.
-func UseRenderTs(ctx context.Context) int64 {
-	rc := vdomctx.GetRenderContext(ctx)
-	if rc == nil {
-		panic("UseRenderTs must be called within a component (no context)")
-	}
-	return rc.UseRenderTs(ctx)
-}
-
-// UseResync returns whether the current render is a resync operation.
-// Resyncs happen on initial app loads or full refreshes, as opposed to
-// incremental renders which happen otherwise.
-// This hook must be called within a component context.
-func UseResync(ctx context.Context) bool {
-	rc := vdomctx.GetRenderContext(ctx)
-	if rc == nil {
-		panic("UseResync must be called within a component (no context)")
-	}
-	return rc.UseResync(ctx)
-}
-
-// UseEffect is the tsunami analog to React's useEffect hook.
-// It queues effects to run after the render cycle completes.
-// The function can return a cleanup function that runs before the next effect
-// or when the component unmounts. Dependencies use shallow comparison, just like React.
-// This hook must be called within a component context.
-func UseEffect(ctx context.Context, fn func() func(), deps []any) {
-	// note UseEffect never actually runs anything, it just queues the effect to run later
-	rc := vdomctx.GetRenderContext(ctx)
-	if rc == nil {
-		panic("UseEffect must be called within a component (no context)")
-	}
-	rc.UseEffect(ctx, fn, deps)
-}
-
-// UseSetAppTitle sets the application title for the current component.
-// This hook must be called within a component context.
-func UseSetAppTitle(ctx context.Context, title string) {
-	rc := vdomctx.GetRenderContext(ctx)
-	if rc == nil {
-		panic("UseSetAppTitle must be called within a component (no context)")
-	}
-	rc.UseSetAppTitle(ctx, title)
-}
-
-// QueueRefOp queues a reference operation to be executed on the DOM element.
-// Operations include actions like "focus", "scrollIntoView", etc.
-// If the ref is nil or not current, the operation is ignored.
-// This function must be called within a component context.
-func QueueRefOp(ctx context.Context, ref *VDomRef, op VDomRefOperation) {
-	if ref == nil || !ref.HasCurrent {
-		return
-	}
-	vc := vdomctx.GetRenderContext(ctx)
-	if vc == nil {
-		panic("QueueRefOp must be called within a component (no context)")
-	}
-	if op.RefId == "" {
-		op.RefId = ref.RefId
-	}
-	vc.QueueRefOp(ctx, op)
-}
-
 // ToElems converts various types into VDomElem slices for use in VDOM children.
 // It handles strings, booleans, VDomElems, *VDomElem, slices, and other types
 // by converting them to appropriate VDomElem representations.
@@ -323,3 +189,21 @@ func ToElems(part any) []VDomElem {
 		return []VDomElem{textElem(fmt.Sprint(part))}
 	}
 }
+
+// QueueRefOp queues a reference operation to be executed on the DOM element.
+// Operations include actions like "focus", "scrollIntoView", etc.
+// If the ref is nil or not current, the operation is ignored.
+// This function must be called within a component context.
+func QueueRefOp(ctx context.Context, ref *VDomRef, op VDomRefOperation) {
+	if ref == nil || !ref.HasCurrent {
+		return
+	}
+	vc := vdomctx.GetRenderContext(ctx)
+	if vc == nil {
+		panic("QueueRefOp must be called within a component (no context)")
+	}
+	if op.RefId == "" {
+		op.RefId = ref.RefId
+	}
+	vc.QueueRefOp(ctx, op)
+}
diff --git a/tsunami/vdom/vdomhooks.go b/tsunami/vdom/vdomhooks.go
new file mode 100644
index 0000000000..737bdc14c4
--- /dev/null
+++ b/tsunami/vdom/vdomhooks.go
@@ -0,0 +1,126 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package vdom
+
+import (
+	"context"
+
+	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
+)
+
+// UseState is the tsunami analog to React's useState hook.
+// It provides persistent state management within a VDOM component, returning the current
+// state value, a setter function, and an updater function.
+// Setting a new value causes a re-render of the component.
+// This hook must be called within a component context.
+func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T)) {
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
+		panic("UseState must be called within a component (no context)")
+	}
+	val, setVal, setFn := rc.UseState(ctx, initialVal)
+
+	// Adapt the "any" values to type "T"
+	var rtnVal T
+	rtnVal, ok := val.(T)
+	if !ok {
+		panic("UseState hook value is not a state (possible out of order or conditional hooks)")
+	}
+	typedSetVal := func(newVal T) {
+		setVal(newVal)
+	}
+	typedSetFuncVal := func(updateFunc func(T) T) {
+		setFn(func(oldVal any) any {
+			return updateFunc(oldVal.(T))
+		})
+	}
+	return rtnVal, typedSetVal, typedSetFuncVal
+}
+
+// UseVDomRef provides a reference to a DOM element in the VDOM tree.
+// It returns a VDomRef that can be attached to elements for direct DOM access.
+// The ref will not be current on the first render - refs are set and become
+// current after client-side mounting.
+// This hook must be called within a component context.
+func UseVDomRef(ctx context.Context) *VDomRef {
+	rc := vdomctx.GetRenderContext(ctx)
+	val := rc.UseVDomRef(ctx)
+	refVal, ok := val.(*VDomRef)
+	if !ok {
+		panic("UseVDomRef hook value is not a ref (possible out of order or conditional hooks)")
+	}
+	return refVal
+}
+
+// UseRef is the tsunami analog to React's useRef hook.
+// It provides a mutable ref object that persists across re-renders.
+// Unlike UseVDomRef, this is not tied to DOM elements but holds arbitrary values.
+// This hook must be called within a component context.
+func UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T] {
+	rc := vdomctx.GetRenderContext(ctx)
+	refVal := rc.UseRef(ctx, &VDomSimpleRef[T]{Current: val})
+	typedRef, ok := refVal.(*VDomSimpleRef[T])
+	if !ok {
+		panic("UseRef hook value is not a ref (possible out of order or conditional hooks)")
+	}
+	return typedRef
+}
+
+// UseId returns the underlying component's unique identifier (UUID).
+// The ID persists across re-renders but is recreated when the component
+// is recreated, following React component lifecycle.
+// This hook must be called within a component context.
+func UseId(ctx context.Context) string {
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
+		panic("UseId must be called within a component (no context)")
+	}
+	return rc.UseId(ctx)
+}
+
+// UseRenderTs returns the timestamp of the current render.
+// This hook must be called within a component context.
+func UseRenderTs(ctx context.Context) int64 {
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
+		panic("UseRenderTs must be called within a component (no context)")
+	}
+	return rc.UseRenderTs(ctx)
+}
+
+// UseResync returns whether the current render is a resync operation.
+// Resyncs happen on initial app loads or full refreshes, as opposed to
+// incremental renders which happen otherwise.
+// This hook must be called within a component context.
+func UseResync(ctx context.Context) bool {
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
+		panic("UseResync must be called within a component (no context)")
+	}
+	return rc.UseResync(ctx)
+}
+
+// UseEffect is the tsunami analog to React's useEffect hook.
+// It queues effects to run after the render cycle completes.
+// The function can return a cleanup function that runs before the next effect
+// or when the component unmounts. Dependencies use shallow comparison, just like React.
+// This hook must be called within a component context.
+func UseEffect(ctx context.Context, fn func() func(), deps []any) {
+	// note UseEffect never actually runs anything, it just queues the effect to run later
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
+		panic("UseEffect must be called within a component (no context)")
+	}
+	rc.UseEffect(ctx, fn, deps)
+}
+
+// UseSetAppTitle sets the application title for the current component.
+// This hook must be called within a component context.
+func UseSetAppTitle(ctx context.Context, title string) {
+	rc := vdomctx.GetRenderContext(ctx)
+	if rc == nil {
+		panic("UseSetAppTitle must be called within a component (no context)")
+	}
+	rc.UseSetAppTitle(ctx, title)
+}

From 67914612319671e031aeee00f1a5041e5fe99acc Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 15:04:18 -0700
Subject: [PATCH 075/134] recursive type validation for atoms

---
 tsunami/util/util.go | 117 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 116 insertions(+), 1 deletion(-)

diff --git a/tsunami/util/util.go b/tsunami/util/util.go
index 69d4b5c1bd..74032036b5 100644
--- a/tsunami/util/util.go
+++ b/tsunami/util/util.go
@@ -1,11 +1,14 @@
 package util
 
 import (
+	"encoding"
+	"encoding/json"
 	"fmt"
 	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"reflect"
 	"runtime"
 	"runtime/debug"
 	"strings"
@@ -72,7 +75,7 @@ func OpenBrowser(url string, delay time.Duration) {
 	if delay > 0 {
 		time.Sleep(delay)
 	}
-	
+
 	var cmd string
 	var args []string
 
@@ -110,3 +113,115 @@ func GetTypedAtomValue[T any](rawVal any, atomName string) T {
 	}
 	return result
 }
+
+var (
+	jsonMarshalerT = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
+	textMarshalerT = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
+)
+
+func implementsJSON(t reflect.Type) bool {
+	if t.Implements(jsonMarshalerT) || t.Implements(textMarshalerT) {
+		return true
+	}
+	if t.Kind() != reflect.Pointer {
+		pt := reflect.PointerTo(t)
+		return pt.Implements(jsonMarshalerT) || pt.Implements(textMarshalerT)
+	}
+	return false
+}
+
+func ValidateAtomType(t reflect.Type, atomName string) error {
+	seen := make(map[reflect.Type]bool)
+	return validateAtomTypeRecursive(t, seen, atomName, "")
+}
+
+func makeAtomError(atomName string, parentName string, message string) error {
+	if parentName != "" {
+		return fmt.Errorf("atom %s: in %s: %s", atomName, parentName, message)
+	}
+	return fmt.Errorf("atom %s: %s", atomName, message)
+}
+
+func validateAtomTypeRecursive(t reflect.Type, seen map[reflect.Type]bool, atomName string, parentName string) error {
+	if t == nil {
+		return makeAtomError(atomName, parentName, "nil type")
+	}
+
+	if seen[t] {
+		return nil
+	}
+	seen[t] = true
+
+	// Check if type implements json.Marshaler or encoding.TextMarshaler
+	if implementsJSON(t) {
+		return nil
+	}
+
+	switch t.Kind() {
+	case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+		reflect.Float32, reflect.Float64, reflect.String:
+		return nil
+
+	case reflect.Ptr:
+		return validateAtomTypeRecursive(t.Elem(), seen, atomName, parentName)
+
+	case reflect.Array, reflect.Slice:
+		elemType := t.Elem()
+		// Allow []any as a JSON value slot
+		if elemType.Kind() == reflect.Interface && elemType.NumMethod() == 0 {
+			return nil
+		}
+		return validateAtomTypeRecursive(elemType, seen, atomName, parentName)
+
+	case reflect.Map:
+		if t.Key().Kind() != reflect.String {
+			return makeAtomError(atomName, parentName, fmt.Sprintf("map key must be string, got %s", t.Key().Kind()))
+		}
+		elemType := t.Elem()
+		// Allow map[string]any as a JSON value slot
+		if elemType.Kind() == reflect.Interface && elemType.NumMethod() == 0 {
+			return nil
+		}
+		return validateAtomTypeRecursive(elemType, seen, atomName, parentName)
+
+	case reflect.Struct:
+		structName := t.Name()
+		if structName == "" {
+			structName = "anonymous struct"
+		}
+		for i := 0; i < t.NumField(); i++ {
+			field := t.Field(i)
+			fieldPath := fmt.Sprintf("%s.%s", structName, field.Name)
+
+			if !field.IsExported() {
+				return makeAtomError(atomName, fieldPath, "field is not exported (cannot round trip)")
+			}
+
+			// Check for json:"-" tag
+			if tag := field.Tag.Get("json"); tag != "" {
+				if name, _, _ := strings.Cut(tag, ","); name == "-" {
+					return makeAtomError(atomName, fieldPath, `field has json:"-" (breaks round trip)`)
+				}
+			}
+
+			if err := validateAtomTypeRecursive(field.Type, seen, atomName, fieldPath); err != nil {
+				return err
+			}
+		}
+		return nil
+
+	case reflect.Interface:
+		// Allow empty interface (any) as JSON value slot
+		if t.NumMethod() == 0 {
+			return nil
+		}
+		return makeAtomError(atomName, parentName, "non-empty interface types are not JSON serializable (cannot round trip)")
+
+	case reflect.Func, reflect.Chan, reflect.UnsafePointer, reflect.Uintptr, reflect.Complex64, reflect.Complex128:
+		return makeAtomError(atomName, parentName, fmt.Sprintf("type %s is not JSON serializable", t.Kind()))
+
+	default:
+		return makeAtomError(atomName, parentName, fmt.Sprintf("unsupported type %s", t.Kind()))
+	}
+}

From bf4a41763c6261091567ba4f2700593c1b92745f Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 15:04:53 -0700
Subject: [PATCH 076/134] move client / serverhandlers to engine

---
 tsunami/app/atom.go                           |  2 +-
 tsunami/app/defaultclient.go                  | 64 +++++++++------
 .../tsunamiapp.go => engine/clientimpl.go}    | 79 +++++++++++--------
 tsunami/{app => engine}/serverhandlers.go     |  8 +-
 4 files changed, 88 insertions(+), 65 deletions(-)
 rename tsunami/{app/tsunamiapp.go => engine/clientimpl.go} (77%)
 rename tsunami/{app => engine}/serverhandlers.go (99%)

diff --git a/tsunami/app/atom.go b/tsunami/app/atom.go
index b479ae5875..769df71340 100644
--- a/tsunami/app/atom.go
+++ b/tsunami/app/atom.go
@@ -24,7 +24,7 @@ func logInvalidAtomSet(atomName string) {
 // Atom[T] represents a typed atom implementation
 type Atom[T any] struct {
 	name   string
-	client *clientImpl
+	client *engine.ClientImpl
 }
 
 // AtomName implements the vdom.Atom interface
diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 5c79bf55a7..97a9ec430b 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -5,32 +5,27 @@ package app
 
 import (
 	"context"
+	"encoding/json"
 	"io/fs"
 	"net/http"
 
+	"github.com/wavetermdev/waveterm/tsunami/engine"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-var defaultClient = makeClient()
-var assetsFS fs.FS
-var staticFS fs.FS
-var manifestFileBytes []byte
-
-// Default client methods that operate on the global defaultClient
-
 func DefineComponent[P any](name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
-	return defineComponentEx(defaultClient, name, renderFn)
+	return engine.DefineComponentEx(engine.GetDefaultClient(), name, renderFn)
 }
 
 func SetGlobalEventHandler(handler func(event vdom.VDomEvent)) {
-	defaultClient.SetGlobalEventHandler(handler)
+	engine.GetDefaultClient().SetGlobalEventHandler(handler)
 }
 
 // RegisterSetupFn registers a single setup function that is called before the app starts running.
 // Only one setup function is allowed, so calling this will replace any previously registered
 // setup function.
 func RegisterSetupFn(fn func()) {
-	defaultClient.RegisterSetupFn(fn)
+	engine.GetDefaultClient().RegisterSetupFn(fn)
 }
 
 // SendAsyncInitiation notifies the frontend that the backend has updated state
@@ -38,51 +33,70 @@ func RegisterSetupFn(fn func()) {
 // to events, but when the backend changes state independently (e.g., from a
 // background process), this function gives the frontend a "nudge" to update.
 func SendAsyncInitiation() error {
-	return defaultClient.SendAsyncInitiation()
+	return engine.GetDefaultClient().SendAsyncInitiation()
 }
 
 func ConfigAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$config." + name
+	client := engine.GetDefaultClient()
 	// Set the default value if not already set
-	if defaultClient.GetAtomVal(fullName) == nil {
-		defaultClient.SetAtomVal(fullName, defaultValue)
+	if client.GetAtomVal(fullName) == nil {
+		client.SetAtomVal(fullName, defaultValue)
 	}
-	return Atom[T]{name: fullName, client: defaultClient}
+	return Atom[T]{name: fullName, client: client}
 }
 
 func DataAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$data." + name
+	client := engine.GetDefaultClient()
 	// Set the default value if not already set
-	if defaultClient.GetAtomVal(fullName) == nil {
-		defaultClient.SetAtomVal(fullName, defaultValue)
+	if client.GetAtomVal(fullName) == nil {
+		client.SetAtomVal(fullName, defaultValue)
 	}
-	return Atom[T]{name: fullName, client: defaultClient}
+	return Atom[T]{name: fullName, client: client}
 }
 
 func SharedAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$shared." + name
+	client := engine.GetDefaultClient()
 	// Set the default value if not already set
-	if defaultClient.GetAtomVal(fullName) == nil {
-		defaultClient.SetAtomVal(fullName, defaultValue)
+	if client.GetAtomVal(fullName) == nil {
+		client.SetAtomVal(fullName, defaultValue)
 	}
-	return Atom[T]{name: fullName, client: defaultClient}
+	return Atom[T]{name: fullName, client: client}
 }
 
 // HandleDynFunc registers a dynamic HTTP handler function with the internal http.ServeMux.
 // The pattern MUST start with "/dyn/" to be valid. This allows registration of dynamic
 // routes that can be handled at runtime.
 func HandleDynFunc(pattern string, fn func(http.ResponseWriter, *http.Request)) {
-	defaultClient.HandleDynFunc(pattern, fn)
+	engine.GetDefaultClient().HandleDynFunc(pattern, fn)
 }
 
 // RunMain is used internally by generated code and should not be called directly.
 func RunMain() {
-	defaultClient.RunMain()
+	engine.GetDefaultClient().RunMain()
 }
 
 // RegisterEmbeds is used internally by generated code and should not be called directly.
 func RegisterEmbeds(assetsFilesystem fs.FS, staticFilesystem fs.FS, manifest []byte) {
-	assetsFS = assetsFilesystem
-	staticFS = staticFilesystem
-	manifestFileBytes = manifest
+	client := engine.GetDefaultClient()
+	client.AssetsFS = assetsFilesystem
+	client.StaticFS = staticFilesystem
+	client.ManifestFileBytes = manifest
+}
+
+// DeepCopy creates a deep copy of the input value using JSON marshal/unmarshal.
+// Panics on JSON errors.
+func DeepCopy[T any](v T) T {
+	data, err := json.Marshal(v)
+	if err != nil {
+		panic(err)
+	}
+	var result T
+	err = json.Unmarshal(data, &result)
+	if err != nil {
+		panic(err)
+	}
+	return result
 }
diff --git a/tsunami/app/tsunamiapp.go b/tsunami/engine/clientimpl.go
similarity index 77%
rename from tsunami/app/tsunamiapp.go
rename to tsunami/engine/clientimpl.go
index c6ac24ef2f..be1063a352 100644
--- a/tsunami/app/tsunamiapp.go
+++ b/tsunami/engine/clientimpl.go
@@ -1,11 +1,12 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package app
+package engine
 
 import (
 	"context"
 	"fmt"
+	"io/fs"
 	"log"
 	"net"
 	"net/http"
@@ -16,7 +17,6 @@ import (
 	"unicode"
 
 	"github.com/google/uuid"
-	"github.com/wavetermdev/waveterm/tsunami/engine"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -31,9 +31,11 @@ type ssEvent struct {
 	Data  []byte
 }
 
-type clientImpl struct {
+var defaultClient = makeClient()
+
+type ClientImpl struct {
 	Lock               *sync.Mutex
-	Root               *engine.RootElem
+	Root               *RootElem
 	RootElem           *vdom.VDomElem
 	CurrentClientId    string
 	ServerId           string
@@ -44,12 +46,15 @@ type clientImpl struct {
 	GlobalEventHandler func(event vdom.VDomEvent)
 	UrlHandlerMux      *http.ServeMux
 	SetupFn            func()
+	AssetsFS           fs.FS
+	StaticFS           fs.FS
+	ManifestFileBytes  []byte
 }
 
-func makeClient() *clientImpl {
-	client := &clientImpl{
+func makeClient() *ClientImpl {
+	client := &ClientImpl{
 		Lock:          &sync.Mutex{},
-		Root:          engine.MakeRoot(),
+		Root:          MakeRoot(),
 		DoneCh:        make(chan struct{}),
 		SSEventCh:     make(chan ssEvent, 100),
 		UrlHandlerMux: http.NewServeMux(),
@@ -59,13 +64,17 @@ func makeClient() *clientImpl {
 	return client
 }
 
-func (c *clientImpl) GetIsDone() bool {
+func GetDefaultClient() *ClientImpl {
+	return defaultClient
+}
+
+func (c *ClientImpl) GetIsDone() bool {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
 	return c.IsDone
 }
 
-func (c *clientImpl) checkClientId(clientId string) error {
+func (c *ClientImpl) checkClientId(clientId string) error {
 	if clientId == "" {
 		return fmt.Errorf("client id cannot be empty")
 	}
@@ -78,13 +87,13 @@ func (c *clientImpl) checkClientId(clientId string) error {
 	return fmt.Errorf("client id mismatch: expected %s, got %s", c.CurrentClientId, clientId)
 }
 
-func (c *clientImpl) clientTakeover(clientId string) {
+func (c *ClientImpl) clientTakeover(clientId string) {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
 	c.CurrentClientId = clientId
 }
 
-func (c *clientImpl) doShutdown(reason string) {
+func (c *ClientImpl) doShutdown(reason string) {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
 	if c.IsDone {
@@ -95,15 +104,15 @@ func (c *clientImpl) doShutdown(reason string) {
 	close(c.DoneCh)
 }
 
-func (c *clientImpl) SetGlobalEventHandler(handler func(event vdom.VDomEvent)) {
+func (c *ClientImpl) SetGlobalEventHandler(handler func(event vdom.VDomEvent)) {
 	c.GlobalEventHandler = handler
 }
 
-func getFaviconPath() string {
-	if staticFS != nil {
+func (c *ClientImpl) getFaviconPath() string {
+	if c.StaticFS != nil {
 		faviconNames := []string{"favicon.ico", "favicon.png", "favicon.svg", "favicon.gif", "favicon.jpg"}
 		for _, name := range faviconNames {
-			if _, err := staticFS.Open(name); err == nil {
+			if _, err := c.StaticFS.Open(name); err == nil {
 				return "/static/" + name
 			}
 		}
@@ -111,15 +120,15 @@ func getFaviconPath() string {
 	return "/wave-logo-256.png"
 }
 
-func (c *clientImpl) makeBackendOpts() *rpctypes.VDomBackendOpts {
+func (c *ClientImpl) makeBackendOpts() *rpctypes.VDomBackendOpts {
 	return &rpctypes.VDomBackendOpts{
 		Title:                c.Root.AppTitle,
 		GlobalKeyboardEvents: c.GlobalEventHandler != nil,
-		FaviconPath:          getFaviconPath(),
+		FaviconPath:          c.getFaviconPath(),
 	}
 }
 
-func (c *clientImpl) runMainE() error {
+func (c *ClientImpl) runMainE() error {
 	if c.SetupFn != nil {
 		c.SetupFn()
 	}
@@ -131,11 +140,11 @@ func (c *clientImpl) runMainE() error {
 	return nil
 }
 
-func (c *clientImpl) RegisterSetupFn(fn func()) {
+func (c *ClientImpl) RegisterSetupFn(fn func()) {
 	c.SetupFn = fn
 }
 
-func (c *clientImpl) RunMain() {
+func (c *ClientImpl) RunMain() {
 	err := c.runMainE()
 	if err != nil {
 		fmt.Println(err)
@@ -143,16 +152,16 @@ func (c *clientImpl) RunMain() {
 	}
 }
 
-func (c *clientImpl) listenAndServe(ctx context.Context) error {
+func (c *ClientImpl) listenAndServe(ctx context.Context) error {
 	// Create HTTP handlers
 	handlers := newHTTPHandlers(c)
 
 	// Create a new ServeMux and register handlers
 	mux := http.NewServeMux()
 	handlers.registerHandlers(mux, handlerOpts{
-		AssetsFS:     assetsFS,
-		StaticFS:     staticFS,
-		ManifestFile: manifestFileBytes,
+		AssetsFS:     c.AssetsFS,
+		StaticFS:     c.StaticFS,
+		ManifestFile: c.ManifestFileBytes,
 	})
 
 	// Determine listen address from environment variable or use default
@@ -196,7 +205,7 @@ func (c *clientImpl) listenAndServe(ctx context.Context) error {
 	return nil
 }
 
-func (c *clientImpl) SendAsyncInitiation() error {
+func (c *ClientImpl) SendAsyncInitiation() error {
 	if c.GetIsDone() {
 		return fmt.Errorf("client is done")
 	}
@@ -209,17 +218,17 @@ func (c *clientImpl) SendAsyncInitiation() error {
 	}
 }
 
-func (c *clientImpl) SetAtomVals(m map[string]any) {
+func (c *ClientImpl) SetAtomVals(m map[string]any) {
 	for k, v := range m {
 		c.Root.SetAtomVal(k, v, true)
 	}
 }
 
-func (c *clientImpl) SetAtomVal(name string, val any) {
+func (c *ClientImpl) SetAtomVal(name string, val any) {
 	c.Root.SetAtomVal(name, val, true)
 }
 
-func (c *clientImpl) GetAtomVal(name string) any {
+func (c *ClientImpl) GetAtomVal(name string) any {
 	return c.Root.GetAtomVal(name)
 }
 
@@ -235,7 +244,7 @@ func structToProps(props any) map[string]any {
 	return m
 }
 
-func defineComponentEx[P any](client *clientImpl, name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
+func DefineComponentEx[P any](client *ClientImpl, name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
 	if name == "" {
 		panic("Component name cannot be empty")
 	}
@@ -251,12 +260,12 @@ func defineComponentEx[P any](client *clientImpl, name string, renderFn func(ctx
 	}
 }
 
-func (c *clientImpl) registerComponent(name string, cfunc any) error {
+func (c *ClientImpl) registerComponent(name string, cfunc any) error {
 	return c.Root.RegisterComponent(name, cfunc)
 }
 
-func (c *clientImpl) fullRender() (*rpctypes.VDomBackendUpdate, error) {
-	opts := &engine.RenderOpts{Resync: true}
+func (c *ClientImpl) fullRender() (*rpctypes.VDomBackendUpdate, error) {
+	opts := &RenderOpts{Resync: true}
 	c.Root.RunWork(opts)
 	c.Root.Render(c.RootElem, opts)
 	renderedVDom := c.Root.MakeVDom()
@@ -278,8 +287,8 @@ func (c *clientImpl) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 	}, nil
 }
 
-func (c *clientImpl) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
-	opts := &engine.RenderOpts{Resync: false}
+func (c *ClientImpl) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
+	opts := &RenderOpts{Resync: false}
 	c.Root.RunWork(opts)
 	renderedVDom := c.Root.MakeVDom()
 	if renderedVDom == nil {
@@ -299,7 +308,7 @@ func (c *clientImpl) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 	}, nil
 }
 
-func (c *clientImpl) HandleDynFunc(pattern string, fn func(http.ResponseWriter, *http.Request)) {
+func (c *ClientImpl) HandleDynFunc(pattern string, fn func(http.ResponseWriter, *http.Request)) {
 	if !strings.HasPrefix(pattern, "/dyn/") {
 		log.Printf("invalid dyn pattern: %s (must start with /dyn/)", pattern)
 		return
diff --git a/tsunami/app/serverhandlers.go b/tsunami/engine/serverhandlers.go
similarity index 99%
rename from tsunami/app/serverhandlers.go
rename to tsunami/engine/serverhandlers.go
index 00c3379b63..b30069cb13 100644
--- a/tsunami/app/serverhandlers.go
+++ b/tsunami/engine/serverhandlers.go
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package app
+package engine
 
 import (
 	"encoding/json"
@@ -33,11 +33,11 @@ type handlerOpts struct {
 }
 
 type httpHandlers struct {
-	Client     *clientImpl
+	Client     *ClientImpl
 	renderLock sync.Mutex
 }
 
-func newHTTPHandlers(client *clientImpl) *httpHandlers {
+func newHTTPHandlers(client *ClientImpl) *httpHandlers {
 	return &httpHandlers{
 		Client: client,
 	}
@@ -443,4 +443,4 @@ func (h *httpHandlers) handleStaticPathFiles(staticFS fs.FS) http.HandlerFunc {
 		fileServer.ServeHTTP(w, r)
 		r.URL.Path = originalPath
 	}
-}
+}
\ No newline at end of file

From 273163320019e7698b8c90834d0fa96d3ebcac73 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 16:02:03 -0700
Subject: [PATCH 077/134] big update, move hooks to app.  move client to
 engine, remove vdomctx.

---
 tsunami/app/defaultclient.go                | 15 ++++++
 tsunami/{vdom/vdomhooks.go => app/hooks.go} | 59 ++++++++++-----------
 tsunami/{engine => app}/root_test.go        | 23 ++++----
 tsunami/demo/cpuchart/app.go                |  6 +--
 tsunami/demo/cpuchart/go.mod                |  1 +
 tsunami/demo/cpuchart/go.sum                |  2 +
 tsunami/demo/githubaction/app.go            |  6 +--
 tsunami/demo/githubaction/go.mod            |  5 +-
 tsunami/demo/githubaction/go.sum            |  2 +
 tsunami/demo/pomodoro/app.go                | 18 +++----
 tsunami/demo/pomodoro/go.mod                |  5 +-
 tsunami/demo/pomodoro/go.sum                |  2 +
 tsunami/demo/recharts/app.go                |  6 +--
 tsunami/demo/recharts/go.mod                |  5 +-
 tsunami/demo/recharts/go.sum                |  2 +
 tsunami/demo/todo/app.go                    |  8 +--
 tsunami/demo/todo/go.mod                    |  5 +-
 tsunami/demo/todo/go.sum                    |  2 +
 tsunami/demo/tsunamiconfig/app.go           | 14 ++---
 tsunami/demo/tsunamiconfig/go.mod           |  5 +-
 tsunami/demo/tsunamiconfig/go.sum           |  2 +
 tsunami/engine/globalctx.go                 | 18 +++++--
 tsunami/engine/hooks.go                     | 32 ++++-------
 tsunami/engine/rootelem.go                  | 23 ++++++--
 tsunami/engine/serverhandlers.go            |  2 +-
 tsunami/vdom/vdom.go                        | 31 -----------
 tsunami/vdom/vdom_types.go                  |  5 --
 tsunami/vdomctx/vdomctx.go                  | 40 --------------
 28 files changed, 160 insertions(+), 184 deletions(-)
 rename tsunami/{vdom/vdomhooks.go => app/hooks.go} (74%)
 rename tsunami/{engine => app}/root_test.go (80%)
 delete mode 100644 tsunami/vdomctx/vdomctx.go

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 97a9ec430b..5e3eca207e 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -100,3 +100,18 @@ func DeepCopy[T any](v T) T {
 	}
 	return result
 }
+
+// QueueRefOp queues a reference operation to be executed on the DOM element.
+// Operations include actions like "focus", "scrollIntoView", etc.
+// If the ref is nil or not current, the operation is ignored.
+// This function must be called within a component context.
+func QueueRefOp(ref *vdom.VDomRef, op vdom.VDomRefOperation) {
+	if ref == nil || !ref.HasCurrent {
+		return
+	}
+	if op.RefId == "" {
+		op.RefId = ref.RefId
+	}
+	client := engine.GetDefaultClient()
+	client.Root.QueueRefOp(op)
+}
diff --git a/tsunami/vdom/vdomhooks.go b/tsunami/app/hooks.go
similarity index 74%
rename from tsunami/vdom/vdomhooks.go
rename to tsunami/app/hooks.go
index 737bdc14c4..349c3551b6 100644
--- a/tsunami/vdom/vdomhooks.go
+++ b/tsunami/app/hooks.go
@@ -1,12 +1,11 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package vdom
+package app
 
 import (
-	"context"
-
-	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
+	"github.com/wavetermdev/waveterm/tsunami/engine"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
 // UseState is the tsunami analog to React's useState hook.
@@ -14,12 +13,12 @@ import (
 // state value, a setter function, and an updater function.
 // Setting a new value causes a re-render of the component.
 // This hook must be called within a component context.
-func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T)) {
-	rc := vdomctx.GetRenderContext(ctx)
+func UseState[T any](initialVal T) (T, func(T), func(func(T) T)) {
+	rc := engine.GetGlobalContext()
 	if rc == nil {
 		panic("UseState must be called within a component (no context)")
 	}
-	val, setVal, setFn := rc.UseState(ctx, initialVal)
+	val, setVal, setFn := engine.UseState(rc, initialVal)
 
 	// Adapt the "any" values to type "T"
 	var rtnVal T
@@ -43,10 +42,10 @@ func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T
 // The ref will not be current on the first render - refs are set and become
 // current after client-side mounting.
 // This hook must be called within a component context.
-func UseVDomRef(ctx context.Context) *VDomRef {
-	rc := vdomctx.GetRenderContext(ctx)
-	val := rc.UseVDomRef(ctx)
-	refVal, ok := val.(*VDomRef)
+func UseVDomRef() *vdom.VDomRef {
+	rc := engine.GetGlobalContext()
+	val := engine.UseVDomRef(rc)
+	refVal, ok := val.(*vdom.VDomRef)
 	if !ok {
 		panic("UseVDomRef hook value is not a ref (possible out of order or conditional hooks)")
 	}
@@ -57,10 +56,10 @@ func UseVDomRef(ctx context.Context) *VDomRef {
 // It provides a mutable ref object that persists across re-renders.
 // Unlike UseVDomRef, this is not tied to DOM elements but holds arbitrary values.
 // This hook must be called within a component context.
-func UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T] {
-	rc := vdomctx.GetRenderContext(ctx)
-	refVal := rc.UseRef(ctx, &VDomSimpleRef[T]{Current: val})
-	typedRef, ok := refVal.(*VDomSimpleRef[T])
+func UseRef[T any](val T) *vdom.VDomSimpleRef[T] {
+	rc := engine.GetGlobalContext()
+	refVal := engine.UseRef(rc, &vdom.VDomSimpleRef[T]{Current: val})
+	typedRef, ok := refVal.(*vdom.VDomSimpleRef[T])
 	if !ok {
 		panic("UseRef hook value is not a ref (possible out of order or conditional hooks)")
 	}
@@ -71,34 +70,34 @@ func UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T] {
 // The ID persists across re-renders but is recreated when the component
 // is recreated, following React component lifecycle.
 // This hook must be called within a component context.
-func UseId(ctx context.Context) string {
-	rc := vdomctx.GetRenderContext(ctx)
+func UseId() string {
+	rc := engine.GetGlobalContext()
 	if rc == nil {
 		panic("UseId must be called within a component (no context)")
 	}
-	return rc.UseId(ctx)
+	return engine.UseId(rc)
 }
 
 // UseRenderTs returns the timestamp of the current render.
 // This hook must be called within a component context.
-func UseRenderTs(ctx context.Context) int64 {
-	rc := vdomctx.GetRenderContext(ctx)
+func UseRenderTs() int64 {
+	rc := engine.GetGlobalContext()
 	if rc == nil {
 		panic("UseRenderTs must be called within a component (no context)")
 	}
-	return rc.UseRenderTs(ctx)
+	return engine.UseRenderTs(rc)
 }
 
 // UseResync returns whether the current render is a resync operation.
 // Resyncs happen on initial app loads or full refreshes, as opposed to
 // incremental renders which happen otherwise.
 // This hook must be called within a component context.
-func UseResync(ctx context.Context) bool {
-	rc := vdomctx.GetRenderContext(ctx)
+func UseResync() bool {
+	rc := engine.GetGlobalContext()
 	if rc == nil {
 		panic("UseResync must be called within a component (no context)")
 	}
-	return rc.UseResync(ctx)
+	return engine.UseResync(rc)
 }
 
 // UseEffect is the tsunami analog to React's useEffect hook.
@@ -106,21 +105,21 @@ func UseResync(ctx context.Context) bool {
 // The function can return a cleanup function that runs before the next effect
 // or when the component unmounts. Dependencies use shallow comparison, just like React.
 // This hook must be called within a component context.
-func UseEffect(ctx context.Context, fn func() func(), deps []any) {
+func UseEffect(fn func() func(), deps []any) {
 	// note UseEffect never actually runs anything, it just queues the effect to run later
-	rc := vdomctx.GetRenderContext(ctx)
+	rc := engine.GetGlobalContext()
 	if rc == nil {
 		panic("UseEffect must be called within a component (no context)")
 	}
-	rc.UseEffect(ctx, fn, deps)
+	engine.UseEffect(rc, fn, deps)
 }
 
 // UseSetAppTitle sets the application title for the current component.
 // This hook must be called within a component context.
-func UseSetAppTitle(ctx context.Context, title string) {
-	rc := vdomctx.GetRenderContext(ctx)
+func UseSetAppTitle(title string) {
+	rc := engine.GetGlobalContext()
 	if rc == nil {
 		panic("UseSetAppTitle must be called within a component (no context)")
 	}
-	rc.UseSetAppTitle(ctx, title)
+	engine.UseSetAppTitle(rc, title)
 }
diff --git a/tsunami/engine/root_test.go b/tsunami/app/root_test.go
similarity index 80%
rename from tsunami/engine/root_test.go
rename to tsunami/app/root_test.go
index 586cb71f53..fc988c798a 100644
--- a/tsunami/engine/root_test.go
+++ b/tsunami/app/root_test.go
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-package engine
+package app
 
 import (
 	"context"
@@ -10,6 +10,7 @@ import (
 	"log"
 	"testing"
 
+	"github.com/wavetermdev/waveterm/tsunami/engine"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
@@ -22,7 +23,7 @@ type TestContext struct {
 }
 
 func Page(ctx context.Context, props map[string]any) any {
-	clicked, setClicked, _ := vdom.UseState(ctx, false)
+	clicked, setClicked, _ := UseState(false)
 	var clickedDiv *vdom.VDomElem
 	if clicked {
 		clickedDiv = vdom.H("div", nil, "clicked")
@@ -39,14 +40,14 @@ func Page(ctx context.Context, props map[string]any) any {
 }
 
 func Button(ctx context.Context, props map[string]any) any {
-	ref := vdom.UseVDomRef(ctx)
-	clName, setClName, _ := vdom.UseState(ctx, "button")
-	vdom.UseEffect(ctx, func() func() {
+	ref := UseVDomRef()
+	clName, setClName, _ := UseState("button")
+	UseEffect(func() func() {
 		fmt.Printf("Button useEffect\n")
 		setClName("button mounted")
 		return nil
 	}, nil)
-	compId := vdom.UseId(ctx)
+	compId := UseId()
 	testContext := getTestContext(ctx)
 	if testContext != nil {
 		testContext.ButtonId = compId
@@ -58,7 +59,7 @@ func Button(ctx context.Context, props map[string]any) any {
 	}, props["children"])
 }
 
-func printVDom(root *RootElem) {
+func printVDom(root *engine.RootElem) {
 	vd := root.MakeVDom()
 	jsonBytes, _ := json.MarshalIndent(vd, "", "  ")
 	fmt.Printf("%s\n", string(jsonBytes))
@@ -76,18 +77,18 @@ func Test1(t *testing.T) {
 	log.Printf("hello!\n")
 	testContext := &TestContext{ButtonId: ""}
 	ctx := context.WithValue(context.Background(), renderContextKey, testContext)
-	root := MakeRoot()
+	root := engine.MakeRoot()
 	root.SetOuterCtx(ctx)
 	root.RegisterComponent("Page", Page)
 	root.RegisterComponent("Button", Button)
-	root.Render(vdom.H("Page", nil), &RenderOpts{Resync: false})
+	root.Render(vdom.H("Page", nil), &engine.RenderOpts{Resync: false})
 	if root.Root == nil {
 		t.Fatalf("root.Root is nil")
 	}
 	printVDom(root)
-	root.RunWork(&RenderOpts{Resync: false})
+	root.RunWork(&engine.RenderOpts{Resync: false})
 	printVDom(root)
 	root.Event(testContext.ButtonId, "onClick", vdom.VDomEvent{EventType: "onClick"})
-	root.RunWork(&RenderOpts{Resync: false})
+	root.RunWork(&engine.RenderOpts{Resync: false})
 	printVDom(root)
 }
diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
index 52797afd52..2d855ed18d 100644
--- a/tsunami/demo/cpuchart/app.go
+++ b/tsunami/demo/cpuchart/app.go
@@ -143,13 +143,13 @@ var StatsPanel = app.DefineComponent("StatsPanel",
 
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ struct{}) any {
-		vdom.UseSetAppTitle(ctx, "CPU Usage Monitor")
+		app.UseSetAppTitle("CPU Usage Monitor")
 
 		// Local state for forcing re-renders
-		_, _, setTickerFn := vdom.UseState(ctx, 0)
+		_, _, setTickerFn := app.UseState(0)
 
 		// Timer effect for continuous CPU data collection
-		vdom.UseEffect(ctx, func() func() {
+		app.UseEffect(func() func() {
 			ticker := time.NewTicker(1 * time.Second)
 			done := make(chan bool)
 
diff --git a/tsunami/demo/cpuchart/go.mod b/tsunami/demo/cpuchart/go.mod
index a54289a76b..0140d12180 100644
--- a/tsunami/demo/cpuchart/go.mod
+++ b/tsunami/demo/cpuchart/go.mod
@@ -12,6 +12,7 @@ require (
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect
+	github.com/outrigdev/goid v0.3.0 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
 	github.com/tklauser/go-sysconf v0.3.15 // indirect
 	github.com/tklauser/numcpus v0.10.0 // indirect
diff --git a/tsunami/demo/cpuchart/go.sum b/tsunami/demo/cpuchart/go.sum
index e3d3d7efce..4d3c872cfc 100644
--- a/tsunami/demo/cpuchart/go.sum
+++ b/tsunami/demo/cpuchart/go.sum
@@ -11,6 +11,8 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4=
 github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I=
+github.com/outrigdev/goid v0.3.0 h1:t/otQD3EXc45cLtQVPUnNgEyRaTQA4cPeu3qVcrsIws=
+github.com/outrigdev/goid v0.3.0/go.mod h1:hEH7f27ypN/GHWt/7gvkRoFYR0LZizfUBIAbak4neVE=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU=
diff --git a/tsunami/demo/githubaction/app.go b/tsunami/demo/githubaction/app.go
index 9cc424cf10..bc08d8b75f 100644
--- a/tsunami/demo/githubaction/app.go
+++ b/tsunami/demo/githubaction/app.go
@@ -222,10 +222,10 @@ var WorkflowRunItem = app.DefineComponent("WorkflowRunItem",
 
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ struct{}) any {
-		vdom.UseSetAppTitle(ctx, "GitHub Actions Monitor")
-		_, _, setTickerFn := vdom.UseState(ctx, 0)
+		app.UseSetAppTitle("GitHub Actions Monitor")
+		_, _, setTickerFn := app.UseState(0)
 
-		vdom.UseEffect(ctx, func() func() {
+		app.UseEffect(func() func() {
 			ticker := time.NewTicker(time.Duration(pollIntervalAtom.Get()) * time.Second)
 			done := make(chan bool)
 
diff --git a/tsunami/demo/githubaction/go.mod b/tsunami/demo/githubaction/go.mod
index 30e86ad8cd..cf51505f61 100644
--- a/tsunami/demo/githubaction/go.mod
+++ b/tsunami/demo/githubaction/go.mod
@@ -4,6 +4,9 @@ go 1.24.6
 
 require github.com/wavetermdev/waveterm/tsunami v0.0.0
 
-require github.com/google/uuid v1.6.0 // indirect
+require (
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/outrigdev/goid v0.3.0 // indirect
+)
 
 replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/githubaction/go.sum b/tsunami/demo/githubaction/go.sum
index 7790d7c3e0..4c44991dfc 100644
--- a/tsunami/demo/githubaction/go.sum
+++ b/tsunami/demo/githubaction/go.sum
@@ -1,2 +1,4 @@
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/outrigdev/goid v0.3.0 h1:t/otQD3EXc45cLtQVPUnNgEyRaTQA4cPeu3qVcrsIws=
+github.com/outrigdev/goid v0.3.0/go.mod h1:hEH7f27ypN/GHWt/7gvkRoFYR0LZizfUBIAbak4neVE=
diff --git a/tsunami/demo/pomodoro/app.go b/tsunami/demo/pomodoro/app.go
index ad981f4f51..d755d2978a 100644
--- a/tsunami/demo/pomodoro/app.go
+++ b/tsunami/demo/pomodoro/app.go
@@ -107,14 +107,14 @@ var ControlButtons = app.DefineComponent("ControlButtons",
 
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ any) any {
-		vdom.UseSetAppTitle(ctx, "Pomodoro Timer (Tsunami Demo)")
-
-		isRunning, setIsRunning, _ := vdom.UseState(ctx, false)
-		minutes, setMinutes, _ := vdom.UseState(ctx, WorkMode.Duration)
-		seconds, setSeconds, _ := vdom.UseState(ctx, 0)
-		mode, setMode, _ := vdom.UseState(ctx, WorkMode.Name)
-		_, setIsComplete, _ := vdom.UseState(ctx, false)
-		timerRef := vdom.UseRef(ctx, &TimerState{
+		app.UseSetAppTitle("Pomodoro Timer (Tsunami Demo)")
+
+		isRunning, setIsRunning, _ := app.UseState(false)
+		minutes, setMinutes, _ := app.UseState(WorkMode.Duration)
+		seconds, setSeconds, _ := app.UseState(0)
+		mode, setMode, _ := app.UseState(WorkMode.Name)
+		_, setIsComplete, _ := app.UseState(false)
+		timerRef := app.UseRef(&TimerState{
 			done: make(chan bool),
 		})
 
@@ -213,7 +213,7 @@ var App = app.DefineComponent("App",
 		}
 
 		// Cleanup on unmount
-		vdom.UseEffect(ctx, func() func() {
+		app.UseEffect(func() func() {
 			return func() {
 				stopTimer()
 			}
diff --git a/tsunami/demo/pomodoro/go.mod b/tsunami/demo/pomodoro/go.mod
index a4c46d73ca..9e5e8362d4 100644
--- a/tsunami/demo/pomodoro/go.mod
+++ b/tsunami/demo/pomodoro/go.mod
@@ -4,6 +4,9 @@ go 1.24.6
 
 require github.com/wavetermdev/waveterm/tsunami v0.0.0
 
-require github.com/google/uuid v1.6.0 // indirect
+require (
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/outrigdev/goid v0.3.0 // indirect
+)
 
 replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/pomodoro/go.sum b/tsunami/demo/pomodoro/go.sum
index 7790d7c3e0..4c44991dfc 100644
--- a/tsunami/demo/pomodoro/go.sum
+++ b/tsunami/demo/pomodoro/go.sum
@@ -1,2 +1,4 @@
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/outrigdev/goid v0.3.0 h1:t/otQD3EXc45cLtQVPUnNgEyRaTQA4cPeu3qVcrsIws=
+github.com/outrigdev/goid v0.3.0/go.mod h1:hEH7f27ypN/GHWt/7gvkRoFYR0LZizfUBIAbak4neVE=
diff --git a/tsunami/demo/recharts/app.go b/tsunami/demo/recharts/app.go
index a838de1886..3e3b6e75f4 100644
--- a/tsunami/demo/recharts/app.go
+++ b/tsunami/demo/recharts/app.go
@@ -204,7 +204,7 @@ var MiniCharts = app.DefineComponent("MiniCharts",
 
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ struct{}) any {
-		vdom.UseSetAppTitle(ctx, "Recharts Demo")
+		app.UseSetAppTitle("Recharts Demo")
 
 		// Get atom values once at the top
 		chartData := chartDataAtom.Get()
@@ -212,10 +212,10 @@ var App = app.DefineComponent("App",
 		isAnimating := isAnimatingAtom.Get()
 
 		// Local state for timer
-		_, _, setTickerFn := vdom.UseState[int](ctx, 0)
+		_, _, setTickerFn := app.UseState(0)
 
 		// Timer effect for live data updates
-		vdom.UseEffect(ctx, func() func() {
+		app.UseEffect(func() func() {
 			if !isAnimating {
 				return nil
 			}
diff --git a/tsunami/demo/recharts/go.mod b/tsunami/demo/recharts/go.mod
index ccb343e166..dfe7fef813 100644
--- a/tsunami/demo/recharts/go.mod
+++ b/tsunami/demo/recharts/go.mod
@@ -4,6 +4,9 @@ go 1.24.6
 
 require github.com/wavetermdev/waveterm/tsunami v0.0.0
 
-require github.com/google/uuid v1.6.0 // indirect
+require (
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/outrigdev/goid v0.3.0 // indirect
+)
 
 replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/recharts/go.sum b/tsunami/demo/recharts/go.sum
index 7790d7c3e0..4c44991dfc 100644
--- a/tsunami/demo/recharts/go.sum
+++ b/tsunami/demo/recharts/go.sum
@@ -1,2 +1,4 @@
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/outrigdev/goid v0.3.0 h1:t/otQD3EXc45cLtQVPUnNgEyRaTQA4cPeu3qVcrsIws=
+github.com/outrigdev/goid v0.3.0/go.mod h1:hEH7f27ypN/GHWt/7gvkRoFYR0LZizfUBIAbak4neVE=
diff --git a/tsunami/demo/todo/app.go b/tsunami/demo/todo/app.go
index 6e955236a0..9bcfe94fd4 100644
--- a/tsunami/demo/todo/app.go
+++ b/tsunami/demo/todo/app.go
@@ -101,15 +101,15 @@ var TodoList = app.DefineComponent("TodoList",
 // Root component showing state management and composition
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ any) any {
-		vdom.UseSetAppTitle(ctx, "Todo App (Tsunami Demo)")
+		app.UseSetAppTitle("Todo App (Tsunami Demo)")
 
 		// Multiple state hooks example
-		todos, setTodos, _ := vdom.UseState(ctx, []Todo{
+		todos, setTodos, _ := app.UseState([]Todo{
 			{Id: 1, Text: "Learn VDOM", Completed: false},
 			{Id: 2, Text: "Build a todo app", Completed: false},
 		})
-		nextId, setNextId, _ := vdom.UseState(ctx, 3)
-		inputText, setInputText, _ := vdom.UseState(ctx, "")
+		nextId, setNextId, _ := app.UseState(3)
+		inputText, setInputText, _ := app.UseState("")
 
 		// Event handlers modifying multiple pieces of state
 		addTodo := func() {
diff --git a/tsunami/demo/todo/go.mod b/tsunami/demo/todo/go.mod
index fd0c143085..f82b52b1cc 100644
--- a/tsunami/demo/todo/go.mod
+++ b/tsunami/demo/todo/go.mod
@@ -4,6 +4,9 @@ go 1.24.6
 
 require github.com/wavetermdev/waveterm/tsunami v0.0.0
 
-require github.com/google/uuid v1.6.0 // indirect
+require (
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/outrigdev/goid v0.3.0 // indirect
+)
 
 replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/todo/go.sum b/tsunami/demo/todo/go.sum
index 7790d7c3e0..4c44991dfc 100644
--- a/tsunami/demo/todo/go.sum
+++ b/tsunami/demo/todo/go.sum
@@ -1,2 +1,4 @@
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/outrigdev/goid v0.3.0 h1:t/otQD3EXc45cLtQVPUnNgEyRaTQA4cPeu3qVcrsIws=
+github.com/outrigdev/goid v0.3.0/go.mod h1:hEH7f27ypN/GHWt/7gvkRoFYR0LZizfUBIAbak4neVE=
diff --git a/tsunami/demo/tsunamiconfig/app.go b/tsunami/demo/tsunamiconfig/app.go
index f529ee496c..b345783057 100644
--- a/tsunami/demo/tsunamiconfig/app.go
+++ b/tsunami/demo/tsunamiconfig/app.go
@@ -255,16 +255,16 @@ var SuccessDisplay = app.DefineComponent("SuccessDisplay",
 
 var App = app.DefineComponent("App",
 	func(ctx context.Context, _ any) any {
-		vdom.UseSetAppTitle(ctx, "Tsunami Config Manager")
+		app.UseSetAppTitle("Tsunami Config Manager")
 
 		// Get atom value once at the top
 		urlInput := serverURLAtom.Get()
-		jsonContent, setJSONContent, _ := vdom.UseState(ctx, "")
-		errorMessage, setErrorMessage, _ := vdom.UseState(ctx, "")
-		successMessage, setSuccessMessage, _ := vdom.UseState(ctx, "")
-		isLoading, setIsLoading, _ := vdom.UseState(ctx, false)
-		lastFetch, setLastFetch, _ := vdom.UseState(ctx, "")
-		currentBaseURL, setCurrentBaseURL, _ := vdom.UseState(ctx, "")
+		jsonContent, setJSONContent, _ := app.UseState("")
+		errorMessage, setErrorMessage, _ := app.UseState("")
+		successMessage, setSuccessMessage, _ := app.UseState("")
+		isLoading, setIsLoading, _ := app.UseState(false)
+		lastFetch, setLastFetch, _ := app.UseState("")
+		currentBaseURL, setCurrentBaseURL, _ := app.UseState("")
 
 		clearMessages := func() {
 			setErrorMessage("")
diff --git a/tsunami/demo/tsunamiconfig/go.mod b/tsunami/demo/tsunamiconfig/go.mod
index 940686f31d..165622f27a 100644
--- a/tsunami/demo/tsunamiconfig/go.mod
+++ b/tsunami/demo/tsunamiconfig/go.mod
@@ -4,6 +4,9 @@ go 1.24.6
 
 require github.com/wavetermdev/waveterm/tsunami v0.0.0
 
-require github.com/google/uuid v1.6.0 // indirect
+require (
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/outrigdev/goid v0.3.0 // indirect
+)
 
 replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/tsunamiconfig/go.sum b/tsunami/demo/tsunamiconfig/go.sum
index 7790d7c3e0..4c44991dfc 100644
--- a/tsunami/demo/tsunamiconfig/go.sum
+++ b/tsunami/demo/tsunamiconfig/go.sum
@@ -1,2 +1,4 @@
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/outrigdev/goid v0.3.0 h1:t/otQD3EXc45cLtQVPUnNgEyRaTQA4cPeu3qVcrsIws=
+github.com/outrigdev/goid v0.3.0/go.mod h1:hEH7f27ypN/GHWt/7gvkRoFYR0LZizfUBIAbak4neVE=
diff --git a/tsunami/engine/globalctx.go b/tsunami/engine/globalctx.go
index 327ee094ad..2591e177fe 100644
--- a/tsunami/engine/globalctx.go
+++ b/tsunami/engine/globalctx.go
@@ -15,15 +15,23 @@ var globalVC *VDomContextImpl
 var globalRenderGoId uint64
 var globalCtxMutex sync.Mutex
 
-func withGlobalCtx[T any](vc *VDomContextImpl, fn func() T) T {
+func setGlobalContext(vc *VDomContextImpl) {
 	globalCtxMutex.Lock()
 	defer globalCtxMutex.Unlock()
 	globalVC = vc
 	globalRenderGoId = goid.Get()
-	defer func() {
-		globalVC = nil
-		globalRenderGoId = 0
-	}()
+}
+
+func clearGlobalContext() {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	globalVC = nil
+	globalRenderGoId = 0
+}
+
+func withGlobalCtx[T any](vc *VDomContextImpl, fn func() T) T {
+	setGlobalContext(vc)
+	defer clearGlobalContext()
 	return fn()
 }
 
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index e5fb17053a..aa7caa71b6 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -4,12 +4,10 @@
 package engine
 
 import (
-	"context"
 	"log"
 	"strconv"
 
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
-	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
 )
 
 // generic hook structure
@@ -29,12 +27,7 @@ type VDomContextImpl struct {
 	RenderOpts *RenderOpts
 }
 
-// Compile-time check to ensure VDomContextImpl implements vdomctx.VDomContext
-var _ vdomctx.VDomContext = (*VDomContextImpl)(nil)
-
-// Implement vdomctx.VDomContext interface methods on VDomContextImpl
-
-func MakeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *VDomContextImpl {
+func makeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *VDomContextImpl {
 	return &VDomContextImpl{Root: root, Comp: comp, HookIdx: 0, RenderOpts: opts}
 }
 
@@ -64,15 +57,15 @@ func (vc *VDomContextImpl) getCompName() string {
 	return vc.Comp.Elem.Tag
 }
 
-func (vc *VDomContextImpl) UseRenderTs(ctx context.Context) int64 {
+func UseRenderTs(vc *VDomContextImpl) int64 {
 	return vc.Root.RenderTs
 }
 
-func (vc *VDomContextImpl) UseId(ctx context.Context) string {
+func UseId(vc *VDomContextImpl) string {
 	return vc.GetCompWaveId()
 }
 
-func (vc *VDomContextImpl) UseState(ctx context.Context, initialVal any) (any, func(any), func(func(any) any)) {
+func UseState(vc *VDomContextImpl, initialVal any) (any, func(any), func(func(any) any)) {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
@@ -92,7 +85,7 @@ func (vc *VDomContextImpl) UseState(ctx context.Context, initialVal any) (any, f
 	return hookVal.Val, setVal, setFuncVal
 }
 
-func (vc *VDomContextImpl) UseAtom(ctx context.Context, atomName string) (any, func(any), func(func(any) any)) {
+func UseAtom(vc *VDomContextImpl, atomName string) (any, func(any), func(func(any) any)) {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
@@ -118,7 +111,7 @@ func (vc *VDomContextImpl) UseAtom(ctx context.Context, atomName string) (any, f
 	return atomVal, setVal, setFuncVal
 }
 
-func (vc *VDomContextImpl) UseVDomRef(ctx context.Context) any {
+func UseVDomRef(vc *VDomContextImpl) any {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
@@ -132,7 +125,7 @@ func (vc *VDomContextImpl) UseVDomRef(ctx context.Context) any {
 	return refVal
 }
 
-func (vc *VDomContextImpl) UseRef(ctx context.Context, hookInitialVal any) any {
+func UseRef(vc *VDomContextImpl, hookInitialVal any) any {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
@@ -153,7 +146,7 @@ func depsEqual(deps1 []any, deps2 []any) bool {
 	return true
 }
 
-func (vc *VDomContextImpl) UseEffect(ctx context.Context, fn func() func(), deps []any) {
+func UseEffect(vc *VDomContextImpl, fn func() func(), deps []any) {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
@@ -178,22 +171,17 @@ func (vc *VDomContextImpl) UseEffect(ctx context.Context, fn func() func(), deps
 	vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
 }
 
-func (vc *VDomContextImpl) UseResync(ctx context.Context) bool {
+func UseResync(vc *VDomContextImpl) bool {
 	if vc.RenderOpts == nil {
 		return false
 	}
 	return vc.RenderOpts.Resync
 }
 
-func (vc *VDomContextImpl) UseSetAppTitle(ctx context.Context, title string) {
+func UseSetAppTitle(vc *VDomContextImpl, title string) {
 	if vc.getCompName() != "App" {
 		log.Printf("UseSetAppTitle can only be called from the App component")
 		return
 	}
 	vc.Root.AppTitle = title
 }
-
-func (vc *VDomContextImpl) QueueRefOp(ctx context.Context, op any) {
-	typedOp := op.(vdom.VDomRefOperation)
-	vc.Root.QueueRefOp(typedOp)
-}
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 1fd059562d..a10be3b543 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -17,11 +17,21 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
-	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
 )
 
 const ChildrenPropKey = "children"
 
+func getElemKey(elem *vdom.VDomElem) string {
+	if elem == nil {
+		return ""
+	}
+	keyVal, ok := elem.Props[vdom.KeyPropKey]
+	if !ok {
+		return ""
+	}
+	return fmt.Sprint(keyVal)
+}
+
 type RenderOpts struct {
 	Resync bool
 }
@@ -312,7 +322,7 @@ func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl, opts *Rende
 		r.unmount(comp)
 		return
 	}
-	elemKey := elem.Key()
+	elemKey := getElemKey(elem)
 	if *comp == nil || !(*comp).compMatch(elem.Tag, elemKey) {
 		r.unmount(comp)
 		r.createComp(elem.Tag, elemKey, comp)
@@ -384,7 +394,7 @@ func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*Componen
 		}
 	}
 	for idx, elem := range elems {
-		elemKey := elem.Key()
+		elemKey := getElemKey(&elem)
 		var curChild *ComponentImpl
 		if elemKey != "" {
 			curChild = curCM[ChildKey{Tag: elem.Tag, Idx: 0, Key: elemKey}]
@@ -449,9 +459,12 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 		props[k] = v
 	}
 	props[ChildrenPropKey] = elem.Children
-	vc := MakeContextVal(r, *comp, opts)
+	vc := makeContextVal(r, *comp, opts)
 	rtnElemArr := withGlobalCtx(vc, func() []vdom.VDomElem {
-		ctx := vdomctx.WithRenderContext(r.OuterCtx, vc)
+		ctx := r.OuterCtx
+		if ctx == nil {
+			ctx = context.Background()
+		}
 		renderedElem := callCFunc(cfunc, ctx, props)
 		return vdom.ToElems(renderedElem)
 	})
diff --git a/tsunami/engine/serverhandlers.go b/tsunami/engine/serverhandlers.go
index b30069cb13..880f6ddb84 100644
--- a/tsunami/engine/serverhandlers.go
+++ b/tsunami/engine/serverhandlers.go
@@ -443,4 +443,4 @@ func (h *httpHandlers) handleStaticPathFiles(staticFS fs.FS) http.HandlerFunc {
 		fileServer.ServeHTTP(w, r)
 		r.URL.Path = originalPath
 	}
-}
\ No newline at end of file
+}
diff --git a/tsunami/vdom/vdom.go b/tsunami/vdom/vdom.go
index 89c6afcc37..513325dc0d 100644
--- a/tsunami/vdom/vdom.go
+++ b/tsunami/vdom/vdom.go
@@ -4,28 +4,15 @@
 package vdom
 
 import (
-	"context"
 	"fmt"
 	"reflect"
 	"strings"
-
-	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
 )
 
 // ReactNode types = nil | string | Elem
 
 type Component[P any] func(props P) *VDomElem
 
-// Key returns the key property of the VDomElem as a string.
-// Returns an empty string if the key is not set, otherwise converts the key value to string using fmt.Sprint.
-func (e *VDomElem) Key() string {
-	keyVal, ok := e.Props[KeyPropKey]
-	if !ok {
-		return ""
-	}
-	return fmt.Sprint(keyVal)
-}
-
 // WithKey sets the key property of the VDomElem and returns the element.
 // This is particularly useful for defined components since their prop types won't include keys.
 // Returns nil if the element is nil, otherwise returns the same element for chaining.
@@ -189,21 +176,3 @@ func ToElems(part any) []VDomElem {
 		return []VDomElem{textElem(fmt.Sprint(part))}
 	}
 }
-
-// QueueRefOp queues a reference operation to be executed on the DOM element.
-// Operations include actions like "focus", "scrollIntoView", etc.
-// If the ref is nil or not current, the operation is ignored.
-// This function must be called within a component context.
-func QueueRefOp(ctx context.Context, ref *VDomRef, op VDomRefOperation) {
-	if ref == nil || !ref.HasCurrent {
-		return
-	}
-	vc := vdomctx.GetRenderContext(ctx)
-	if vc == nil {
-		panic("QueueRefOp must be called within a component (no context)")
-	}
-	if op.RefId == "" {
-		op.RefId = ref.RefId
-	}
-	vc.QueueRefOp(ctx, op)
-}
diff --git a/tsunami/vdom/vdom_types.go b/tsunami/vdom/vdom_types.go
index 677ba5de1a..86c890f67b 100644
--- a/tsunami/vdom/vdom_types.go
+++ b/tsunami/vdom/vdom_types.go
@@ -126,8 +126,3 @@ type VDomRefOperation struct {
 	Params    []any  `json:"params,omitempty"`
 	OutputRef string `json:"outputref,omitempty"`
 }
-
-// Atom interface for atom implementations
-type Atom interface {
-	AtomName() string
-}
diff --git a/tsunami/vdomctx/vdomctx.go b/tsunami/vdomctx/vdomctx.go
deleted file mode 100644
index 4e5c2c7d50..0000000000
--- a/tsunami/vdomctx/vdomctx.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package vdomctx
-
-import (
-	"context"
-)
-
-type vdomContextKeyType struct{}
-
-var vdomContextKey = vdomContextKeyType{}
-
-type VDomContext interface {
-	UseRenderTs(ctx context.Context) int64
-	UseId(ctx context.Context) string
-	UseState(ctx context.Context, initialVal any) (any, func(any), func(func(any) any))
-	UseAtom(ctx context.Context, atomName string) (any, func(any), func(func(any) any))
-	UseVDomRef(ctx context.Context) any
-	UseRef(ctx context.Context, initialVal any) any
-	UseEffect(ctx context.Context, fn func() func(), deps []any)
-	UseResync(ctx context.Context) bool
-	UseSetAppTitle(ctx context.Context, title string)
-	QueueRefOp(ctx context.Context, op any)
-}
-
-func WithRenderContext(ctx context.Context, vc VDomContext) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	return context.WithValue(ctx, vdomContextKey, vc)
-}
-
-func GetRenderContext(ctx context.Context) VDomContext {
-	v := ctx.Value(vdomContextKey)
-	if v == nil {
-		return nil
-	}
-	return v.(VDomContext)
-}

From 7fa0786baa148608791b546ec9a7db134952b64e Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 16:12:46 -0700
Subject: [PATCH 078/134] add uselocal hook (to replace usestate)

---
 tsunami/app/hooks.go       | 15 +++++++++++++++
 tsunami/engine/hooks.go    | 14 ++++++++++++++
 tsunami/engine/rootelem.go |  7 +++++++
 3 files changed, 36 insertions(+)

diff --git a/tsunami/app/hooks.go b/tsunami/app/hooks.go
index 349c3551b6..3a49fb9c8d 100644
--- a/tsunami/app/hooks.go
+++ b/tsunami/app/hooks.go
@@ -123,3 +123,18 @@ func UseSetAppTitle(title string) {
 	}
 	engine.UseSetAppTitle(rc, title)
 }
+
+// UseLocal creates a component-local atom that is automatically cleaned up when the component unmounts.
+// The atom is created with a unique name based on the component's wave ID and hook index.
+// This hook must be called within a component context.
+func UseLocal[T any](initialVal T) Atom[T] {
+	rc := engine.GetGlobalContext()
+	if rc == nil {
+		panic("UseLocal must be called within a component (no context)")
+	}
+	atomName := engine.UseLocal(rc, initialVal)
+	return Atom[T]{
+		name:   atomName,
+		client: engine.GetDefaultClient(),
+	}
+}
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index aa7caa71b6..07006d25ef 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -111,6 +111,20 @@ func UseAtom(vc *VDomContextImpl, atomName string) (any, func(any), func(func(an
 	return atomVal, setVal, setFuncVal
 }
 
+func UseLocal(vc *VDomContextImpl, initialVal any) string {
+	hookVal := vc.getOrderedHook()
+	atomName := "$local." + vc.GetCompWaveId() + "#" + strconv.Itoa(hookVal.Idx)
+	if !hookVal.Init {
+		hookVal.Init = true
+		vc.Root.SetAtomVal(atomName, initialVal, false)
+		closedAtomName := atomName
+		hookVal.UnmountFn = func() {
+			vc.Root.RemoveAtom(closedAtomName)
+		}
+	}
+	return atomName
+}
+
 func UseVDomRef(vc *VDomContextImpl) any {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index a10be3b543..852957eed9 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -196,6 +196,13 @@ func (r *RootElem) SetAtomVal(name string, val any, markDirty bool) {
 	atom.Dirty = true
 }
 
+func (r *RootElem) RemoveAtom(name string) {
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+
+	delete(r.Atoms, name)
+}
+
 func (r *RootElem) SetOuterCtx(ctx context.Context) {
 	r.OuterCtx = ctx
 }

From 352182eee20e921f39b8fa7a5379bebbcb587336 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 16:31:20 -0700
Subject: [PATCH 079/134] removing vdombindings and atom state sync (simplify)

---
 tsunami/engine/clientimpl.go                 |  8 --
 tsunami/engine/rootelem.go                   | 16 ----
 tsunami/engine/serverhandlers.go             |  4 -
 tsunami/frontend/src/model/tsunami-model.tsx | 83 --------------------
 tsunami/frontend/src/types/vdom.d.ts         | 14 ----
 tsunami/rpctypes/protocoltypes.go            |  6 --
 tsunami/vdom/vdom_types.go                   |  7 --
 7 files changed, 138 deletions(-)

diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index be1063a352..69304ef3bf 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -218,12 +218,6 @@ func (c *ClientImpl) SendAsyncInitiation() error {
 	}
 }
 
-func (c *ClientImpl) SetAtomVals(m map[string]any) {
-	for k, v := range m {
-		c.Root.SetAtomVal(k, v, true)
-	}
-}
-
 func (c *ClientImpl) SetAtomVal(name string, val any) {
 	c.Root.SetAtomVal(name, val, true)
 }
@@ -283,7 +277,6 @@ func (c *ClientImpl) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 			{UpdateType: "root", VDom: renderedVDom},
 		},
 		RefOperations: c.Root.GetRefOperations(),
-		StateSync:     c.Root.GetStateSync(true),
 	}, nil
 }
 
@@ -304,7 +297,6 @@ func (c *ClientImpl) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 			{UpdateType: "root", VDom: renderedVDom},
 		},
 		RefOperations: c.Root.GetRefOperations(),
-		StateSync:     c.Root.GetStateSync(false),
 	}, nil
 }
 
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 852957eed9..039f8fe1fe 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -38,7 +38,6 @@ type RenderOpts struct {
 
 type atomImpl struct {
 	Val    any
-	Dirty  bool
 	UsedBy map[string]bool // component waveid -> true
 }
 
@@ -165,20 +164,6 @@ func (r *RootElem) GetAtomVal(name string) any {
 	return atom.Val
 }
 
-func (r *RootElem) GetStateSync(full bool) []rpctypes.VDomStateSync {
-	r.atomLock.Lock()
-	defer r.atomLock.Unlock()
-
-	stateSync := make([]rpctypes.VDomStateSync, 0)
-	for atomName, atom := range r.Atoms {
-		if atom.Dirty || full {
-			stateSync = append(stateSync, rpctypes.VDomStateSync{Atom: atomName, Value: atom.Val})
-			atom.Dirty = false
-		}
-	}
-	return stateSync
-}
-
 func (r *RootElem) SetAtomVal(name string, val any, markDirty bool) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
@@ -193,7 +178,6 @@ func (r *RootElem) SetAtomVal(name string, val any, markDirty bool) {
 		return
 	}
 	atom.Val = val
-	atom.Dirty = true
 }
 
 func (r *RootElem) RemoveAtom(name string) {
diff --git a/tsunami/engine/serverhandlers.go b/tsunami/engine/serverhandlers.go
index 880f6ddb84..55d71b61b8 100644
--- a/tsunami/engine/serverhandlers.go
+++ b/tsunami/engine/serverhandlers.go
@@ -128,10 +128,6 @@ func (h *httpHandlers) processFrontendUpdate(feUpdate *rpctypes.VDomFrontendUpda
 
 	h.Client.Root.RenderTs = feUpdate.Ts
 
-	// set atoms
-	for _, ss := range feUpdate.StateSync {
-		h.Client.Root.SetAtomVal(ss.Atom, ss.Value, false)
-	}
 	// run events
 	for _, event := range feUpdate.Events {
 		if event.GlobalEventType != "" {
diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
index 9f12116a59..17d0bcdbee 100644
--- a/tsunami/frontend/src/model/tsunami-model.tsx
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -12,12 +12,6 @@ import { applyCanvasOp, restoreVDomElems } from "./model-utils";
 
 const dlog = debug("wave:vdom");
 
-type AtomContainer = {
-    val: any;
-    beVal: any;
-    usedBy: Set<string>;
-};
-
 type RefContainer = {
     refFn: (elem: HTMLElement) => void;
     vdomRef: VDomRef;
@@ -86,13 +80,11 @@ export class TsunamiModel {
     serverId: string;
     viewRef: React.RefObject<HTMLDivElement> = { current: null };
     vdomRoot: jotai.PrimitiveAtom<VDomElem> = jotai.atom();
-    atoms: Map<string, AtomContainer> = new Map(); // key is atomname
     refs: Map<string, RefContainer> = new Map(); // key is refid
     batchedEvents: VDomEvent[] = [];
     messages: VDomMessage[] = [];
     needsResync: boolean = true;
     vdomNodeVersion: WeakMap<VDomElem, jotai.PrimitiveAtom<number>> = new WeakMap();
-    compoundAtoms: Map<string, jotai.PrimitiveAtom<{ [key: string]: any }>> = new Map();
     rootRefId: string = crypto.randomUUID();
     backendOpts: VDomBackendOpts;
     shouldDispose: boolean;
@@ -155,13 +147,11 @@ export class TsunamiModel {
             this.serverEventSource = null;
         }
         getDefaultStore().set(this.vdomRoot, null);
-        this.atoms.clear();
         this.refs.clear();
         this.batchedEvents = [];
         this.messages = [];
         this.needsResync = true;
         this.vdomNodeVersion = new WeakMap();
-        this.compoundAtoms.clear();
         this.rootRefId = crypto.randomUUID();
         this.backendOpts = {};
         this.shouldDispose = false;
@@ -326,18 +316,6 @@ export class TsunamiModel {
         }
     }
 
-    getAtomContainer(atomName: string): AtomContainer {
-        let container = this.atoms.get(atomName);
-        if (container == null) {
-            container = {
-                val: null,
-                beVal: null,
-                usedBy: new Set(),
-            };
-            this.atoms.set(atomName, container);
-        }
-        return container;
-    }
 
     getOrCreateRefContainer(vdomRef: VDomRef): RefContainer {
         let container = this.refs.get(vdomRef.refid);
@@ -360,19 +338,6 @@ export class TsunamiModel {
         return container;
     }
 
-    tagUseAtoms(waveId: string, atomNames: Set<string>) {
-        for (let atomName of atomNames) {
-            let container = this.getAtomContainer(atomName);
-            container.usedBy.add(waveId);
-        }
-    }
-
-    tagUnuseAtoms(waveId: string, atomNames: Set<string>) {
-        for (let atomName of atomNames) {
-            let container = this.getAtomContainer(atomName);
-            container.usedBy.delete(waveId);
-        }
-    }
 
     getVDomNodeVersionAtom(vdom: VDomElem) {
         let atom = this.vdomNodeVersion.get(vdom);
@@ -469,53 +434,6 @@ export class TsunamiModel {
         }
     }
 
-    setAtomValue(atomName: string, value: any, fromBe: boolean, idMap: Map<string, VDomElem>) {
-        dlog("setAtomValue", atomName, value, fromBe);
-        let container = this.getAtomContainer(atomName);
-        if (container.val === value) {
-            return;
-        }
-        container.val = value;
-        if (fromBe) {
-            container.beVal = value;
-        }
-        for (let id of container.usedBy) {
-            this.incVDomNodeVersion(idMap.get(id));
-        }
-    }
-
-    handleStateSync(update: VDomBackendUpdate, idMap: Map<string, VDomElem>) {
-        if (update.fullupdate) {
-            if (update.statesync == null) {
-                this.atoms.clear();
-                return;
-            }
-
-            const sentAtoms = new Set<string>();
-            for (let sync of update.statesync) {
-                sentAtoms.add(sync.atom);
-                this.setAtomValue(sync.atom, sync.value, true, idMap);
-            }
-
-            const atomsToRemove: string[] = [];
-            for (let atomName of this.atoms.keys()) {
-                if (!sentAtoms.has(atomName)) {
-                    atomsToRemove.push(atomName);
-                }
-            }
-
-            for (let atomName of atomsToRemove) {
-                this.atoms.delete(atomName);
-            }
-        } else {
-            if (update.statesync == null) {
-                return;
-            }
-            for (let sync of update.statesync) {
-                this.setAtomValue(sync.atom, sync.value, true, idMap);
-            }
-        }
-    }
 
     getRefElem(refId: string): HTMLElement {
         if (refId == this.rootRefId) {
@@ -607,7 +525,6 @@ export class TsunamiModel {
         }
         makeVDomIdMap(vdomRoot, idMap);
         this.handleRenderUpdates(update, idMap);
-        this.handleStateSync(update, idMap);
         this.handleRefOperations(update, idMap);
         if (update.messages) {
             for (let message of update.messages) {
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
index 2159f33ae3..a0d8b4def9 100644
--- a/tsunami/frontend/src/types/vdom.d.ts
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -25,17 +25,10 @@ type VDomBackendUpdate = {
     fullupdate?: boolean;
     renderupdates?: VDomRenderUpdate[];
     transferelems?: VDomTransferElem[];
-    statesync?: VDomStateSync[];
     refoperations?: VDomRefOperation[];
     messages?: VDomMessage[];
 };
 
-// vdom.VDomBinding
-type VDomBinding = {
-    type: "binding";
-    bind: string;
-};
-
 // vdom.VDomCreateContext
 type VDomCreateContext = {
     type: "createcontext";
@@ -78,7 +71,6 @@ type VDomFrontendUpdate = {
     resync?: boolean;
     rendercontext: VDomRenderContext;
     events?: VDomEvent[];
-    statesync?: VDomStateSync[];
     refupdates?: VDomRefUpdate[];
     messages?: VDomMessage[];
 };
@@ -152,12 +144,6 @@ type VDomRenderUpdate = {
     index?: number;
 };
 
-// vdom.VDomStateSync
-type VDomStateSync = {
-    atom: string;
-    value: any;
-};
-
 // vdom.VDomTarget
 type VDomTarget = {
     newblock?: boolean;
diff --git a/tsunami/rpctypes/protocoltypes.go b/tsunami/rpctypes/protocoltypes.go
index 45775025a7..743b00baaa 100644
--- a/tsunami/rpctypes/protocoltypes.go
+++ b/tsunami/rpctypes/protocoltypes.go
@@ -40,7 +40,6 @@ type VDomFrontendUpdate struct {
 	Resync        bool              `json:"resync,omitempty"`  // resync (send all backend data).  useful when the FE reloads
 	RenderContext VDomRenderContext `json:"rendercontext,omitempty"`
 	Events        []vdom.VDomEvent  `json:"events,omitempty"`
-	StateSync     []VDomStateSync   `json:"statesync,omitempty"`
 	RefUpdates    []VDomRefUpdate   `json:"refupdates,omitempty"`
 	Messages      []VDomMessage     `json:"messages,omitempty"`
 }
@@ -54,7 +53,6 @@ type VDomBackendUpdate struct {
 	FullUpdate    bool                    `json:"fullupdate,omitempty"`
 	RenderUpdates []VDomRenderUpdate      `json:"renderupdates,omitempty"`
 	TransferElems []VDomTransferElem      `json:"transferelems,omitempty"`
-	StateSync     []VDomStateSync         `json:"statesync,omitempty"`
 	RefOperations []vdom.VDomRefOperation `json:"refoperations,omitempty"`
 	Messages      []VDomMessage           `json:"messages,omitempty"`
 }
@@ -157,10 +155,6 @@ type VDomRenderContext struct {
 	Background bool   `json:"background,omitempty"`
 }
 
-type VDomStateSync struct {
-	Atom  string `json:"atom"`
-	Value any    `json:"value"`
-}
 
 type VDomRefUpdate struct {
 	RefId      string                `json:"refid"`
diff --git a/tsunami/vdom/vdom_types.go b/tsunami/vdom/vdom_types.go
index 86c890f67b..21f8479f3b 100644
--- a/tsunami/vdom/vdom_types.go
+++ b/tsunami/vdom/vdom_types.go
@@ -11,7 +11,6 @@ const FragmentTag = "#fragment"
 const KeyPropKey = "key"
 
 const ObjectType_Ref = "ref"
-const ObjectType_Binding = "binding"
 const ObjectType_Func = "func"
 
 // vdom element
@@ -23,12 +22,6 @@ type VDomElem struct {
 	Text     string         `json:"text,omitempty"`
 }
 
-// used in props
-type VDomBinding struct {
-	Type string `json:"type" tstype:"\"binding\""`
-	Bind string `json:"bind"`
-}
-
 // used in props
 type VDomFunc struct {
 	Fn              any      `json:"-"` // server side function (called with reflection)

From 40969b2a5a4d8ac89ab4c136515af37395e510b6 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 16:31:41 -0700
Subject: [PATCH 080/134] vdom.tsx updates for removing FE atoms and bindings

---
 tsunami/frontend/src/vdom.tsx | 84 +++--------------------------------
 1 file changed, 5 insertions(+), 79 deletions(-)

diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index 60914429a5..a926af3b4b 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -19,7 +19,6 @@ const WaveNullTag = "wave:null";
 const StyleTagName = "style";
 
 const VDomObjType_Ref = "ref";
-const VDomObjType_Binding = "binding";
 const VDomObjType_Func = "func";
 
 const dlog = debug("wave:vdom");
@@ -180,36 +179,12 @@ function isArray(v: any): boolean {
     return Array.isArray(v);
 }
 
-function resolveBinding(binding: VDomBinding, model: TsunamiModel): [any, string[]] {
-    const bindName = binding.bind;
-    if (bindName == null || bindName == "") {
-        return [null, []];
-    }
-    // validate that bindName starts with valid atom prefix and has at least one char after the dot
-    const isValidBinding =
-        (bindName.startsWith("$shared.") && bindName.length > 8) ||
-        (bindName.startsWith("$config.") && bindName.length > 8) ||
-        (bindName.startsWith("$data.") && bindName.length > 6);
-
-    if (!isValidBinding) {
-        return [null, []];
-    }
-
-    const atom = model.getAtomContainer(bindName);
-    if (atom == null) {
-        return [null, []];
-    }
-    return [atom.val, [bindName]];
-}
-
 type GenericPropsType = { [key: string]: any };
 
-// returns props, and a set of atom keys used in the props
-function convertProps(elem: VDomElem, model: TsunamiModel): [GenericPropsType, Set<string>] {
+function convertProps(elem: VDomElem, model: TsunamiModel): GenericPropsType {
     let props: GenericPropsType = {};
-    let atomKeys = new Set<string>();
     if (elem.props == null) {
-        return [props, atomKeys];
+        return props;
     }
     for (let key in elem.props) {
         let val = elem.props[key];
@@ -232,32 +207,9 @@ function convertProps(elem: VDomElem, model: TsunamiModel): [GenericPropsType, S
             props[key] = convertVDomFunc(model, valFunc, elem.waveid, key);
             continue;
         }
-        if (isObject(val) && val.type == VDomObjType_Binding) {
-            const [propVal, atomDeps] = resolveBinding(val as VDomBinding, model);
-            props[key] = propVal;
-            for (let atomDep of atomDeps) {
-                atomKeys.add(atomDep);
-            }
-            continue;
-        }
-        if (key == "style" && isObject(val)) {
-            // assuming the entire style prop wasn't bound, look through the individual keys and bind them
-            for (let styleKey in val) {
-                let styleVal = val[styleKey];
-                if (isObject(styleVal) && styleVal.type == VDomObjType_Binding) {
-                    const [stylePropVal, styleAtomDeps] = resolveBinding(styleVal as VDomBinding, model);
-                    val[styleKey] = stylePropVal;
-                    for (let styleAtomDep of styleAtomDeps) {
-                        atomKeys.add(styleAtomDep);
-                    }
-                }
-            }
-            props[key] = val;
-            continue;
-        }
         props[key] = val;
     }
-    return [props, atomKeys];
+    return props;
 }
 
 function convertChildren(elem: VDomElem, model: TsunamiModel): React.ReactNode[] {
@@ -277,35 +229,9 @@ function convertChildren(elem: VDomElem, model: TsunamiModel): React.ReactNode[]
     return childrenComps;
 }
 
-function stringSetsEqual(set1: Set<string>, set2: Set<string>): boolean {
-    if (set1.size != set2.size) {
-        return false;
-    }
-    for (let elem of set1) {
-        if (!set2.has(elem)) {
-            return false;
-        }
-    }
-    return true;
-}
-
 function useVDom(model: TsunamiModel, elem: VDomElem): GenericPropsType {
-    const version = jotai.useAtomValue(model.getVDomNodeVersionAtom(elem));
-    const [oldAtomKeys, setOldAtomKeys] = React.useState<Set<string>>(new Set());
-    let [props, atomKeys] = convertProps(elem, model);
-    React.useEffect(() => {
-        if (stringSetsEqual(atomKeys, oldAtomKeys)) {
-            return;
-        }
-        model.tagUnuseAtoms(elem.waveid, oldAtomKeys);
-        model.tagUseAtoms(elem.waveid, atomKeys);
-        setOldAtomKeys(atomKeys);
-    }, [atomKeys]);
-    React.useEffect(() => {
-        return () => {
-            model.tagUnuseAtoms(elem.waveid, oldAtomKeys);
-        };
-    }, []);
+    const version = jotai.useAtomValue(model.getVDomNodeVersionAtom(elem)); // this triggers updates when vdom nodes change
+    let props = convertProps(elem, model);
     return props;
 }
 

From 20a68e968ef3ea4b64a9b6194750bae650fca693 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 18:08:26 -0700
Subject: [PATCH 081/134] createatom flow

---
 tsunami/app/defaultclient.go | 15 +++-----------
 tsunami/engine/atomimpl.go   | 32 +++++++++++++++++++++++++++++
 tsunami/engine/clientimpl.go |  4 ++++
 tsunami/engine/hooks.go      |  2 +-
 tsunami/engine/rootelem.go   | 40 +++++++++++++++++++-----------------
 5 files changed, 61 insertions(+), 32 deletions(-)
 create mode 100644 tsunami/engine/atomimpl.go

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 5e3eca207e..64e6df788a 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -39,30 +39,21 @@ func SendAsyncInitiation() error {
 func ConfigAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$config." + name
 	client := engine.GetDefaultClient()
-	// Set the default value if not already set
-	if client.GetAtomVal(fullName) == nil {
-		client.SetAtomVal(fullName, defaultValue)
-	}
+	client.CreateAtom(fullName, defaultValue)
 	return Atom[T]{name: fullName, client: client}
 }
 
 func DataAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$data." + name
 	client := engine.GetDefaultClient()
-	// Set the default value if not already set
-	if client.GetAtomVal(fullName) == nil {
-		client.SetAtomVal(fullName, defaultValue)
-	}
+	client.CreateAtom(fullName, defaultValue)
 	return Atom[T]{name: fullName, client: client}
 }
 
 func SharedAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$shared." + name
 	client := engine.GetDefaultClient()
-	// Set the default value if not already set
-	if client.GetAtomVal(fullName) == nil {
-		client.SetAtomVal(fullName, defaultValue)
-	}
+	client.CreateAtom(fullName, defaultValue)
 	return Atom[T]{name: fullName, client: client}
 }
 
diff --git a/tsunami/engine/atomimpl.go b/tsunami/engine/atomimpl.go
new file mode 100644
index 0000000000..9a2d189280
--- /dev/null
+++ b/tsunami/engine/atomimpl.go
@@ -0,0 +1,32 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package engine
+
+import "sync"
+
+type atomImpl struct {
+	lock   *sync.Mutex
+	val    any
+	UsedBy map[string]bool // component waveid -> true
+}
+
+func makeAtom(initialVal any) *atomImpl {
+	return &atomImpl{
+		lock:   &sync.Mutex{},
+		val:    initialVal,
+		UsedBy: make(map[string]bool),
+	}
+}
+
+func (a *atomImpl) GetVal() any {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+	return a.val
+}
+
+func (a *atomImpl) SetVal(val any) {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+	a.val = val
+}
diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index 69304ef3bf..072ab79b57 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -218,6 +218,10 @@ func (c *ClientImpl) SendAsyncInitiation() error {
 	}
 }
 
+func (c *ClientImpl) CreateAtom(name string, initialVal any) {
+	c.Root.CreateAtom(name, initialVal)
+}
+
 func (c *ClientImpl) SetAtomVal(name string, val any) {
 	c.Root.SetAtomVal(name, val, true)
 }
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index 07006d25ef..291cd7c174 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -116,7 +116,7 @@ func UseLocal(vc *VDomContextImpl, initialVal any) string {
 	atomName := "$local." + vc.GetCompWaveId() + "#" + strconv.Itoa(hookVal.Idx)
 	if !hookVal.Init {
 		hookVal.Init = true
-		vc.Root.SetAtomVal(atomName, initialVal, false)
+		vc.Root.CreateAtom(atomName, initialVal)
 		closedAtomName := atomName
 		hookVal.UnmountFn = func() {
 			vc.Root.RemoveAtom(closedAtomName)
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 039f8fe1fe..6818159f3e 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -36,11 +36,6 @@ type RenderOpts struct {
 	Resync bool
 }
 
-type atomImpl struct {
-	Val    any
-	UsedBy map[string]bool // component waveid -> true
-}
-
 type EffectWorkElem struct {
 	Id          string
 	EffectIndex int
@@ -79,7 +74,7 @@ func (r *RootElem) GetDataMap() map[string]any {
 	for atomName, atom := range r.Atoms {
 		if strings.HasPrefix(atomName, "$data.") {
 			strippedName := strings.TrimPrefix(atomName, "$data.")
-			result[strippedName] = atom.Val
+			result[strippedName] = atom.GetVal()
 		}
 	}
 	return result
@@ -93,7 +88,7 @@ func (r *RootElem) GetConfigMap() map[string]any {
 	for atomName, atom := range r.Atoms {
 		if strings.HasPrefix(atomName, "$config.") {
 			strippedName := strings.TrimPrefix(atomName, "$config.")
-			result[strippedName] = atom.Val
+			result[strippedName] = atom.GetVal()
 		}
 	}
 	return result
@@ -108,13 +103,14 @@ func MakeRoot() *RootElem {
 	}
 }
 
-func (r *RootElem) ensureAtomNoLock(name string) *atomImpl {
-	atom, ok := r.Atoms[name]
-	if !ok {
-		atom = &atomImpl{UsedBy: make(map[string]bool)}
-		r.Atoms[name] = atom
+func (r *RootElem) CreateAtom(name string, initialVal any) {
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+
+	if _, ok := r.Atoms[name]; ok {
+		panic(fmt.Sprintf("atom %s already exists", name))
 	}
-	return atom
+	r.Atoms[name] = makeAtom(initialVal)
 }
 
 // we can do better here with an inverted map, but
@@ -132,7 +128,10 @@ func (r *RootElem) AtomSetUsedBy(atomName string, waveId string, used bool) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
 
-	atom := r.ensureAtomNoLock(atomName)
+	atom, ok := r.Atoms[atomName]
+	if !ok {
+		return
+	}
 	if used {
 		atom.UsedBy[waveId] = true
 	} else {
@@ -161,23 +160,26 @@ func (r *RootElem) GetAtomVal(name string) any {
 	if !ok {
 		return nil
 	}
-	return atom.Val
+	return atom.GetVal()
 }
 
 func (r *RootElem) SetAtomVal(name string, val any, markDirty bool) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
 
-	atom := r.ensureAtomNoLock(name)
+	atom, ok := r.Atoms[name]
+	if !ok {
+		return
+	}
 	if !markDirty {
-		atom.Val = val
+		atom.SetVal(val)
 		return
 	}
 	// try to avoid setting the value and marking as dirty if it's the "same"
-	if util.JsonValEqual(val, atom.Val) {
+	if util.JsonValEqual(val, atom.GetVal()) {
 		return
 	}
-	atom.Val = val
+	atom.SetVal(val)
 }
 
 func (r *RootElem) RemoveAtom(name string) {

From 9dd37ed00b9506fbc636692f372926459b57a0cc Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 18:19:18 -0700
Subject: [PATCH 082/134] working on atom impl...

---
 tsunami/app/defaultclient.go |  7 ++++---
 tsunami/engine/atomimpl.go   |  9 +++++++--
 tsunami/engine/clientimpl.go |  4 ----
 tsunami/engine/hooks.go      |  3 ++-
 tsunami/engine/rootelem.go   | 12 ++----------
 5 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 64e6df788a..6579660d84 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -8,6 +8,7 @@ import (
 	"encoding/json"
 	"io/fs"
 	"net/http"
+	"reflect"
 
 	"github.com/wavetermdev/waveterm/tsunami/engine"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -39,21 +40,21 @@ func SendAsyncInitiation() error {
 func ConfigAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$config." + name
 	client := engine.GetDefaultClient()
-	client.CreateAtom(fullName, defaultValue)
+	client.Root.CreateAtom(fullName, defaultValue, reflect.TypeOf(defaultValue))
 	return Atom[T]{name: fullName, client: client}
 }
 
 func DataAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$data." + name
 	client := engine.GetDefaultClient()
-	client.CreateAtom(fullName, defaultValue)
+	client.Root.CreateAtom(fullName, defaultValue, reflect.TypeOf(defaultValue))
 	return Atom[T]{name: fullName, client: client}
 }
 
 func SharedAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$shared." + name
 	client := engine.GetDefaultClient()
-	client.CreateAtom(fullName, defaultValue)
+	client.Root.CreateAtom(fullName, defaultValue, reflect.TypeOf(defaultValue))
 	return Atom[T]{name: fullName, client: client}
 }
 
diff --git a/tsunami/engine/atomimpl.go b/tsunami/engine/atomimpl.go
index 9a2d189280..d56c6bbb8d 100644
--- a/tsunami/engine/atomimpl.go
+++ b/tsunami/engine/atomimpl.go
@@ -3,18 +3,23 @@
 
 package engine
 
-import "sync"
+import (
+	"reflect"
+	"sync"
+)
 
 type atomImpl struct {
 	lock   *sync.Mutex
 	val    any
+	typ    reflect.Type
 	UsedBy map[string]bool // component waveid -> true
 }
 
-func makeAtom(initialVal any) *atomImpl {
+func makeAtom(initialVal any, typ reflect.Type) *atomImpl {
 	return &atomImpl{
 		lock:   &sync.Mutex{},
 		val:    initialVal,
+		typ:    typ,
 		UsedBy: make(map[string]bool),
 	}
 }
diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index 072ab79b57..69304ef3bf 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -218,10 +218,6 @@ func (c *ClientImpl) SendAsyncInitiation() error {
 	}
 }
 
-func (c *ClientImpl) CreateAtom(name string, initialVal any) {
-	c.Root.CreateAtom(name, initialVal)
-}
-
 func (c *ClientImpl) SetAtomVal(name string, val any) {
 	c.Root.SetAtomVal(name, val, true)
 }
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index 291cd7c174..813c501ec1 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -5,6 +5,7 @@ package engine
 
 import (
 	"log"
+	"reflect"
 	"strconv"
 
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -116,7 +117,7 @@ func UseLocal(vc *VDomContextImpl, initialVal any) string {
 	atomName := "$local." + vc.GetCompWaveId() + "#" + strconv.Itoa(hookVal.Idx)
 	if !hookVal.Init {
 		hookVal.Init = true
-		vc.Root.CreateAtom(atomName, initialVal)
+		vc.Root.CreateAtom(atomName, initialVal, reflect.TypeOf(initialVal))
 		closedAtomName := atomName
 		hookVal.UnmountFn = func() {
 			vc.Root.RemoveAtom(closedAtomName)
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 6818159f3e..26c9f0bd50 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -103,14 +103,14 @@ func MakeRoot() *RootElem {
 	}
 }
 
-func (r *RootElem) CreateAtom(name string, initialVal any) {
+func (r *RootElem) CreateAtom(name string, initialVal any, typ reflect.Type) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
 
 	if _, ok := r.Atoms[name]; ok {
 		panic(fmt.Sprintf("atom %s already exists", name))
 	}
-	r.Atoms[name] = makeAtom(initialVal)
+	r.Atoms[name] = makeAtom(initialVal, typ)
 }
 
 // we can do better here with an inverted map, but
@@ -171,14 +171,6 @@ func (r *RootElem) SetAtomVal(name string, val any, markDirty bool) {
 	if !ok {
 		return
 	}
-	if !markDirty {
-		atom.SetVal(val)
-		return
-	}
-	// try to avoid setting the value and marking as dirty if it's the "same"
-	if util.JsonValEqual(val, atom.GetVal()) {
-		return
-	}
 	atom.SetVal(val)
 }
 

From d4f86872f0c914e87d203e1aa3dcb89c4a22c728 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 18:31:08 -0700
Subject: [PATCH 083/134] genatom interface in rootelem

---
 tsunami/app/atom.go              |  4 ++--
 tsunami/engine/atomimpl.go       | 21 +++++++++++++++++++++
 tsunami/engine/clientimpl.go     |  4 ----
 tsunami/engine/hooks.go          |  4 ++--
 tsunami/engine/rootelem.go       | 23 +++++++++++++----------
 tsunami/engine/serverhandlers.go |  2 +-
 6 files changed, 39 insertions(+), 19 deletions(-)

diff --git a/tsunami/app/atom.go b/tsunami/app/atom.go
index 769df71340..954cd3d700 100644
--- a/tsunami/app/atom.go
+++ b/tsunami/app/atom.go
@@ -51,7 +51,7 @@ func (a Atom[T]) Set(newVal T) {
 		return
 	}
 	a.client.Root.AtomAddRenderWork(a.name)
-	a.client.SetAtomVal(a.name, newVal)
+	a.client.Root.SetAtomVal(a.name, newVal)
 }
 
 func (a Atom[T]) SetFn(fn func(T) T) {
@@ -64,5 +64,5 @@ func (a Atom[T]) SetFn(fn func(T) T) {
 	typedVal := util.GetTypedAtomValue[T](val, a.name)
 	newVal := fn(typedVal)
 	a.client.Root.AtomAddRenderWork(a.name)
-	a.client.SetAtomVal(a.name, newVal)
+	a.client.Root.SetAtomVal(a.name, newVal)
 }
diff --git a/tsunami/engine/atomimpl.go b/tsunami/engine/atomimpl.go
index d56c6bbb8d..20a8b35df8 100644
--- a/tsunami/engine/atomimpl.go
+++ b/tsunami/engine/atomimpl.go
@@ -35,3 +35,24 @@ func (a *atomImpl) SetVal(val any) {
 	defer a.lock.Unlock()
 	a.val = val
 }
+
+func (a *atomImpl) SetUsedBy(waveId string, used bool) {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+	if used {
+		a.UsedBy[waveId] = true
+	} else {
+		delete(a.UsedBy, waveId)
+	}
+}
+
+func (a *atomImpl) GetUsedBy() []string {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+
+	keys := make([]string, 0, len(a.UsedBy))
+	for compId := range a.UsedBy {
+		keys = append(keys, compId)
+	}
+	return keys
+}
diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index 69304ef3bf..4155e43470 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -218,10 +218,6 @@ func (c *ClientImpl) SendAsyncInitiation() error {
 	}
 }
 
-func (c *ClientImpl) SetAtomVal(name string, val any) {
-	c.Root.SetAtomVal(name, val, true)
-}
-
 func (c *ClientImpl) GetAtomVal(name string) any {
 	return c.Root.GetAtomVal(name)
 }
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index 813c501ec1..1eddafb8e7 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -99,13 +99,13 @@ func UseAtom(vc *VDomContextImpl, atomName string) (any, func(any), func(func(an
 	atomVal := vc.Root.GetAtomVal(atomName)
 
 	setVal := func(newVal any) {
-		vc.Root.SetAtomVal(atomName, newVal, true)
+		vc.Root.SetAtomVal(atomName, newVal)
 		vc.Root.AtomAddRenderWork(atomName)
 	}
 
 	setFuncVal := func(updateFunc func(any) any) {
 		currentVal := vc.Root.GetAtomVal(atomName)
-		vc.Root.SetAtomVal(atomName, updateFunc(currentVal), true)
+		vc.Root.SetAtomVal(atomName, updateFunc(currentVal))
 		vc.Root.AtomAddRenderWork(atomName)
 	}
 
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 26c9f0bd50..e84b334107 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -41,6 +41,13 @@ type EffectWorkElem struct {
 	EffectIndex int
 }
 
+type genAtom interface {
+	GetVal() any
+	SetVal(any)
+	SetUsedBy(string, bool)
+	GetUsedBy() []string
+}
+
 type RootElem struct {
 	OuterCtx        context.Context
 	Root            *ComponentImpl
@@ -50,7 +57,7 @@ type RootElem struct {
 	CompMap         map[string]*ComponentImpl // component waveid -> component
 	EffectWorkQueue []*EffectWorkElem
 	NeedsRenderMap  map[string]bool
-	Atoms           map[string]*atomImpl
+	Atoms           map[string]genAtom
 	atomLock        sync.Mutex
 	RefOperations   []vdom.VDomRefOperation
 }
@@ -99,7 +106,7 @@ func MakeRoot() *RootElem {
 		Root:    nil,
 		CFuncs:  make(map[string]any),
 		CompMap: make(map[string]*ComponentImpl),
-		Atoms:   make(map[string]*atomImpl),
+		Atoms:   make(map[string]genAtom),
 	}
 }
 
@@ -120,7 +127,7 @@ func (r *RootElem) cleanupUsedByForUnmount(waveId string) {
 	defer r.atomLock.Unlock()
 
 	for _, atom := range r.Atoms {
-		delete(atom.UsedBy, waveId)
+		atom.SetUsedBy(waveId, false)
 	}
 }
 
@@ -132,11 +139,7 @@ func (r *RootElem) AtomSetUsedBy(atomName string, waveId string, used bool) {
 	if !ok {
 		return
 	}
-	if used {
-		atom.UsedBy[waveId] = true
-	} else {
-		delete(atom.UsedBy, waveId)
-	}
+	atom.SetUsedBy(waveId, used)
 }
 
 func (r *RootElem) AtomAddRenderWork(atomName string) {
@@ -147,7 +150,7 @@ func (r *RootElem) AtomAddRenderWork(atomName string) {
 	if !ok {
 		return
 	}
-	for compId := range atom.UsedBy {
+	for _, compId := range atom.GetUsedBy() {
 		r.AddRenderWork(compId)
 	}
 }
@@ -163,7 +166,7 @@ func (r *RootElem) GetAtomVal(name string) any {
 	return atom.GetVal()
 }
 
-func (r *RootElem) SetAtomVal(name string, val any, markDirty bool) {
+func (r *RootElem) SetAtomVal(name string, val any) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
 
diff --git a/tsunami/engine/serverhandlers.go b/tsunami/engine/serverhandlers.go
index 55d71b61b8..245178893e 100644
--- a/tsunami/engine/serverhandlers.go
+++ b/tsunami/engine/serverhandlers.go
@@ -225,7 +225,7 @@ func (h *httpHandlers) handleConfigPost(w http.ResponseWriter, r *http.Request)
 
 	for key, value := range configData {
 		atomName := "$config." + key
-		h.Client.Root.SetAtomVal(atomName, value, true)
+		h.Client.Root.SetAtomVal(atomName, value)
 	}
 
 	w.WriteHeader(http.StatusOK)

From 58a7a77109120869afddec0b5e85a179df1c6d43 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 19:00:37 -0700
Subject: [PATCH 084/134] new generic atoms in engine.  update SetVal to deal
 with conversion (via json)

---
 tsunami/app/atom.go              | 10 ++++--
 tsunami/app/defaultclient.go     | 10 +++---
 tsunami/engine/atomimpl.go       | 61 ++++++++++++++++++++++----------
 tsunami/engine/hooks.go          | 14 +++++---
 tsunami/engine/rootelem.go       | 12 +++----
 tsunami/engine/serverhandlers.go | 20 ++++++++++-
 6 files changed, 92 insertions(+), 35 deletions(-)

diff --git a/tsunami/app/atom.go b/tsunami/app/atom.go
index 954cd3d700..b5acdf769b 100644
--- a/tsunami/app/atom.go
+++ b/tsunami/app/atom.go
@@ -50,8 +50,11 @@ func (a Atom[T]) Set(newVal T) {
 		logInvalidAtomSet(a.name)
 		return
 	}
+	if err := a.client.Root.SetAtomVal(a.name, newVal); err != nil {
+		log.Printf("Failed to set atom value for %s: %v", a.name, err)
+		return
+	}
 	a.client.Root.AtomAddRenderWork(a.name)
-	a.client.Root.SetAtomVal(a.name, newVal)
 }
 
 func (a Atom[T]) SetFn(fn func(T) T) {
@@ -63,6 +66,9 @@ func (a Atom[T]) SetFn(fn func(T) T) {
 	val := a.client.GetAtomVal(a.name)
 	typedVal := util.GetTypedAtomValue[T](val, a.name)
 	newVal := fn(typedVal)
+	if err := a.client.Root.SetAtomVal(a.name, newVal); err != nil {
+		log.Printf("Failed to set atom value for %s: %v", a.name, err)
+		return
+	}
 	a.client.Root.AtomAddRenderWork(a.name)
-	a.client.Root.SetAtomVal(a.name, newVal)
 }
diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 6579660d84..2fcb26fb89 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -8,7 +8,6 @@ import (
 	"encoding/json"
 	"io/fs"
 	"net/http"
-	"reflect"
 
 	"github.com/wavetermdev/waveterm/tsunami/engine"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -40,21 +39,24 @@ func SendAsyncInitiation() error {
 func ConfigAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$config." + name
 	client := engine.GetDefaultClient()
-	client.Root.CreateAtom(fullName, defaultValue, reflect.TypeOf(defaultValue))
+	atom := engine.MakeAtomImpl(defaultValue)
+	client.Root.RegisterAtom(fullName, atom)
 	return Atom[T]{name: fullName, client: client}
 }
 
 func DataAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$data." + name
 	client := engine.GetDefaultClient()
-	client.Root.CreateAtom(fullName, defaultValue, reflect.TypeOf(defaultValue))
+	atom := engine.MakeAtomImpl(defaultValue)
+	client.Root.RegisterAtom(fullName, atom)
 	return Atom[T]{name: fullName, client: client}
 }
 
 func SharedAtom[T any](name string, defaultValue T) Atom[T] {
 	fullName := "$shared." + name
 	client := engine.GetDefaultClient()
-	client.Root.CreateAtom(fullName, defaultValue, reflect.TypeOf(defaultValue))
+	atom := engine.MakeAtomImpl(defaultValue)
+	client.Root.RegisterAtom(fullName, atom)
 	return Atom[T]{name: fullName, client: client}
 }
 
diff --git a/tsunami/engine/atomimpl.go b/tsunami/engine/atomimpl.go
index 20a8b35df8..3d8f6761c6 100644
--- a/tsunami/engine/atomimpl.go
+++ b/tsunami/engine/atomimpl.go
@@ -4,54 +4,79 @@
 package engine
 
 import (
-	"reflect"
+	"encoding/json"
+	"fmt"
 	"sync"
 )
 
-type atomImpl struct {
+type AtomImpl[T any] struct {
 	lock   *sync.Mutex
-	val    any
-	typ    reflect.Type
-	UsedBy map[string]bool // component waveid -> true
+	val    T
+	usedBy map[string]bool // component waveid -> true
 }
 
-func makeAtom(initialVal any, typ reflect.Type) *atomImpl {
-	return &atomImpl{
+func MakeAtomImpl[T any](initialVal T) *AtomImpl[T] {
+	return &AtomImpl[T]{
 		lock:   &sync.Mutex{},
 		val:    initialVal,
-		typ:    typ,
-		UsedBy: make(map[string]bool),
+		usedBy: make(map[string]bool),
 	}
 }
 
-func (a *atomImpl) GetVal() any {
+func (a *AtomImpl[T]) GetVal() any {
 	a.lock.Lock()
 	defer a.lock.Unlock()
 	return a.val
 }
 
-func (a *atomImpl) SetVal(val any) {
+func (a *AtomImpl[T]) SetVal(val any) error {
 	a.lock.Lock()
 	defer a.lock.Unlock()
-	a.val = val
+
+	if val == nil {
+		var zero T
+		a.val = zero
+		return nil
+	}
+
+	// Try direct assignment if it's already type T
+	if typed, ok := val.(T); ok {
+		a.val = typed
+		return nil
+	}
+
+	// Try JSON marshaling/unmarshaling
+	jsonBytes, err := json.Marshal(val)
+	if err != nil {
+		var result T
+		return fmt.Errorf("failed to adapt type from %T => %T, input type failed to marshal: %w", val, result, err)
+	}
+
+	var result T
+	if err := json.Unmarshal(jsonBytes, &result); err != nil {
+		return fmt.Errorf("failed to adapt type from %T => %T: %w", val, result, err)
+	}
+
+	a.val = result
+	return nil
 }
 
-func (a *atomImpl) SetUsedBy(waveId string, used bool) {
+func (a *AtomImpl[T]) SetUsedBy(waveId string, used bool) {
 	a.lock.Lock()
 	defer a.lock.Unlock()
 	if used {
-		a.UsedBy[waveId] = true
+		a.usedBy[waveId] = true
 	} else {
-		delete(a.UsedBy, waveId)
+		delete(a.usedBy, waveId)
 	}
 }
 
-func (a *atomImpl) GetUsedBy() []string {
+func (a *AtomImpl[T]) GetUsedBy() []string {
 	a.lock.Lock()
 	defer a.lock.Unlock()
 
-	keys := make([]string, 0, len(a.UsedBy))
-	for compId := range a.UsedBy {
+	keys := make([]string, 0, len(a.usedBy))
+	for compId := range a.usedBy {
 		keys = append(keys, compId)
 	}
 	return keys
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index 1eddafb8e7..41f9755faa 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -5,7 +5,6 @@ package engine
 
 import (
 	"log"
-	"reflect"
 	"strconv"
 
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -99,13 +98,19 @@ func UseAtom(vc *VDomContextImpl, atomName string) (any, func(any), func(func(an
 	atomVal := vc.Root.GetAtomVal(atomName)
 
 	setVal := func(newVal any) {
-		vc.Root.SetAtomVal(atomName, newVal)
+		if err := vc.Root.SetAtomVal(atomName, newVal); err != nil {
+			log.Printf("Failed to set atom value for %s: %v", atomName, err)
+			return
+		}
 		vc.Root.AtomAddRenderWork(atomName)
 	}
 
 	setFuncVal := func(updateFunc func(any) any) {
 		currentVal := vc.Root.GetAtomVal(atomName)
-		vc.Root.SetAtomVal(atomName, updateFunc(currentVal))
+		if err := vc.Root.SetAtomVal(atomName, updateFunc(currentVal)); err != nil {
+			log.Printf("Failed to set atom value for %s: %v", atomName, err)
+			return
+		}
 		vc.Root.AtomAddRenderWork(atomName)
 	}
 
@@ -117,7 +122,8 @@ func UseLocal(vc *VDomContextImpl, initialVal any) string {
 	atomName := "$local." + vc.GetCompWaveId() + "#" + strconv.Itoa(hookVal.Idx)
 	if !hookVal.Init {
 		hookVal.Init = true
-		vc.Root.CreateAtom(atomName, initialVal, reflect.TypeOf(initialVal))
+		atom := MakeAtomImpl(initialVal)
+		vc.Root.RegisterAtom(atomName, atom)
 		closedAtomName := atomName
 		hookVal.UnmountFn = func() {
 			vc.Root.RemoveAtom(closedAtomName)
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index e84b334107..ea94c06ba3 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -43,7 +43,7 @@ type EffectWorkElem struct {
 
 type genAtom interface {
 	GetVal() any
-	SetVal(any)
+	SetVal(any) error
 	SetUsedBy(string, bool)
 	GetUsedBy() []string
 }
@@ -110,14 +110,14 @@ func MakeRoot() *RootElem {
 	}
 }
 
-func (r *RootElem) CreateAtom(name string, initialVal any, typ reflect.Type) {
+func (r *RootElem) RegisterAtom(name string, atom genAtom) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
 
 	if _, ok := r.Atoms[name]; ok {
 		panic(fmt.Sprintf("atom %s already exists", name))
 	}
-	r.Atoms[name] = makeAtom(initialVal, typ)
+	r.Atoms[name] = atom
 }
 
 // we can do better here with an inverted map, but
@@ -166,15 +166,15 @@ func (r *RootElem) GetAtomVal(name string) any {
 	return atom.GetVal()
 }
 
-func (r *RootElem) SetAtomVal(name string, val any) {
+func (r *RootElem) SetAtomVal(name string, val any) error {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
 
 	atom, ok := r.Atoms[name]
 	if !ok {
-		return
+		return fmt.Errorf("atom %q not found", name)
 	}
-	atom.SetVal(val)
+	return atom.SetVal(val)
 }
 
 func (r *RootElem) RemoveAtom(name string) {
diff --git a/tsunami/engine/serverhandlers.go b/tsunami/engine/serverhandlers.go
index 245178893e..58ea95f9be 100644
--- a/tsunami/engine/serverhandlers.go
+++ b/tsunami/engine/serverhandlers.go
@@ -223,12 +223,30 @@ func (h *httpHandlers) handleConfigPost(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
+	var failedKeys []string
 	for key, value := range configData {
 		atomName := "$config." + key
-		h.Client.Root.SetAtomVal(atomName, value)
+		if err := h.Client.Root.SetAtomVal(atomName, value); err != nil {
+			failedKeys = append(failedKeys, key)
+		}
 	}
 
+	w.Header().Set("Content-Type", "application/json")
+	
+	var response map[string]any
+	if len(failedKeys) > 0 {
+		response = map[string]any{
+			"error": fmt.Sprintf("Failed to update keys: %s", strings.Join(failedKeys, ", ")),
+		}
+	} else {
+		response = map[string]any{
+			"success": true,
+		}
+	}
+	
 	w.WriteHeader(http.StatusOK)
+	
+	json.NewEncoder(w).Encode(response)
 }
 
 func (h *httpHandlers) handleDynContent(w http.ResponseWriter, r *http.Request) {

From dda17b48f754dc4a408221d5cc067aa882352fdb Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 19:05:46 -0700
Subject: [PATCH 085/134] use new deepcopy func and avoid concurrent mutation

---
 tsunami/demo/cpuchart/app.go | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
index 2d855ed18d..23ba0f3abc 100644
--- a/tsunami/demo/cpuchart/app.go
+++ b/tsunami/demo/cpuchart/app.go
@@ -162,32 +162,31 @@ var App = app.DefineComponent("App",
 						// Collect new CPU data point and shift the data window
 						cpuDataAtom.SetFn(func(currentData []CPUDataPoint) []CPUDataPoint {
 							newPoint := generateCPUDataPoint()
-							// Read current config inside the loop to get live updates
 							currentDataPointCount := dataPointCountAtom.Get()
 
+							// Make a safe copy to avoid mutation issues
+							data := app.DeepCopy(currentData)
+
 							// Ensure we have the right size array
-							if len(currentData) != currentDataPointCount {
+							if len(data) != currentDataPointCount {
 								// Resize array if config changed
-								newData := make([]CPUDataPoint, currentDataPointCount)
+								resized := make([]CPUDataPoint, currentDataPointCount)
 								copyCount := currentDataPointCount
-								if len(currentData) < copyCount {
-									copyCount = len(currentData)
+								if len(data) < copyCount {
+									copyCount = len(data)
 								}
 								if copyCount > 0 {
-									copy(newData[currentDataPointCount-copyCount:], currentData[len(currentData)-copyCount:])
+									copy(resized[currentDataPointCount-copyCount:], data[len(data)-copyCount:])
 								}
-								currentData = newData
-							}
-							// Create a new slice with exact point count
-							newData := make([]CPUDataPoint, currentDataPointCount)
-							// Shift existing data left by 1 and add new point at the end
-							if currentDataPointCount > 1 {
-								copy(newData, currentData[1:])
+								data = resized
 							}
-							if currentDataPointCount > 0 {
-								newData[currentDataPointCount-1] = newPoint
+
+							// Append new point and keep only the last currentDataPointCount elements
+							data = append(data, newPoint)
+							if len(data) > currentDataPointCount {
+								data = data[len(data)-currentDataPointCount:]
 							}
-							return newData
+							return data
 						})
 						// Trigger a re-render
 						setTickerFn(func(t int) int { return t + 1 })

From ac8503557e1d9efd72bd70d1f6c986daa1ef3bb2 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Mon, 8 Sep 2025 23:05:07 -0700
Subject: [PATCH 086/134] cleanup and document rendering pipeline (render.go /
 render.md).  remove some unused types, fix some weirdness

---
 tsunami/app/root_test.go             |   2 +-
 tsunami/engine/clientimpl.go         |  12 +-
 tsunami/engine/comp.go               |  32 +--
 tsunami/engine/render.go             | 289 ++++++++++++++++++++++++++
 tsunami/engine/render.md             | 262 ++++++++++++++++++++++++
 tsunami/engine/rootelem.go           | 295 ---------------------------
 tsunami/frontend/src/types/vdom.d.ts |  58 +-----
 tsunami/frontend/src/vdom.tsx        |   4 +-
 tsunami/rpctypes/protocoltypes.go    |  49 ++---
 tsunami/vdom/vdom_types.go           |   3 +-
 10 files changed, 612 insertions(+), 394 deletions(-)
 create mode 100644 tsunami/engine/render.go
 create mode 100644 tsunami/engine/render.md

diff --git a/tsunami/app/root_test.go b/tsunami/app/root_test.go
index fc988c798a..494a7f6eac 100644
--- a/tsunami/app/root_test.go
+++ b/tsunami/app/root_test.go
@@ -60,7 +60,7 @@ func Button(ctx context.Context, props map[string]any) any {
 }
 
 func printVDom(root *engine.RootElem) {
-	vd := root.MakeVDom()
+	vd := root.MakeRendered()
 	jsonBytes, _ := json.MarshalIndent(vd, "", "  ")
 	fmt.Printf("%s\n", string(jsonBytes))
 }
diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index 4155e43470..bbd55cf809 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -222,8 +222,8 @@ func (c *ClientImpl) GetAtomVal(name string) any {
 	return c.Root.GetAtomVal(name)
 }
 
-func makeNullVDom() *vdom.VDomElem {
-	return &vdom.VDomElem{WaveId: uuid.New().String(), Tag: vdom.WaveNullTag}
+func makeNullRendered() *rpctypes.RenderedElem {
+	return &rpctypes.RenderedElem{WaveId: uuid.New().String(), Tag: vdom.WaveNullTag}
 }
 
 func structToProps(props any) map[string]any {
@@ -258,9 +258,9 @@ func (c *ClientImpl) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 	opts := &RenderOpts{Resync: true}
 	c.Root.RunWork(opts)
 	c.Root.Render(c.RootElem, opts)
-	renderedVDom := c.Root.MakeVDom()
+	renderedVDom := c.Root.MakeRendered()
 	if renderedVDom == nil {
-		renderedVDom = makeNullVDom()
+		renderedVDom = makeNullRendered()
 	}
 	return &rpctypes.VDomBackendUpdate{
 		Type:       "backendupdate",
@@ -279,9 +279,9 @@ func (c *ClientImpl) fullRender() (*rpctypes.VDomBackendUpdate, error) {
 func (c *ClientImpl) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 	opts := &RenderOpts{Resync: false}
 	c.Root.RunWork(opts)
-	renderedVDom := c.Root.MakeVDom()
+	renderedVDom := c.Root.MakeRendered()
 	if renderedVDom == nil {
-		renderedVDom = makeNullVDom()
+		renderedVDom = makeNullRendered()
 	}
 	return &rpctypes.VDomBackendUpdate{
 		Type:       "backendupdate",
diff --git a/tsunami/engine/comp.go b/tsunami/engine/comp.go
index a2f230225c..c712359416 100644
--- a/tsunami/engine/comp.go
+++ b/tsunami/engine/comp.go
@@ -14,24 +14,30 @@ type ChildKey struct {
 	Key string
 }
 
+// ComponentImpl represents a node in the persistent shadow component tree.
+// This is Tsunami's equivalent to React's Fiber nodes - it maintains component
+// identity, state, and lifecycle across renders while the VDomElem input/output
+// structures are ephemeral.
 type ComponentImpl struct {
-	WaveId  string
-	Tag     string
-	Key     string
-	Elem    *vdom.VDomElem
-	Mounted bool
+	WaveId  string         // Unique identifier for this component instance
+	Tag     string         // Component type (HTML tag, custom component name, "#text", etc.)
+	Key     string         // User-provided key for reconciliation (like React keys)
+	Elem    *vdom.VDomElem // Reference to the current input VDomElem being rendered
+	Mounted bool           // Whether this component is currently mounted
 
-	// hooks
-	Hooks []*Hook
+	// Hooks system (React-like)
+	Hooks []*Hook // Array of hooks (state, effects, etc.) attached to this component
 
-	// #text component
-	Text string
+	// Component content - exactly ONE of these patterns is used:
 
-	// base component -- vdom, wave elem, or #fragment
-	Children []*ComponentImpl
+	// Pattern 1: Text nodes
+	Text string // For "#text" components - stores the actual text content
 
-	// component -> component
-	Comp *ComponentImpl
+	// Pattern 2: Base/DOM elements with children
+	Children []*ComponentImpl // For HTML tags, fragments - array of child components
+
+	// Pattern 3: Custom components that render to other components
+	RenderedComp *ComponentImpl // For custom components - points to what this component rendered to
 }
 
 func (c *ComponentImpl) compMatch(tag string, key string) bool {
diff --git a/tsunami/engine/render.go b/tsunami/engine/render.go
new file mode 100644
index 0000000000..4ccc253646
--- /dev/null
+++ b/tsunami/engine/render.go
@@ -0,0 +1,289 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package engine
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"unicode"
+
+	"github.com/google/uuid"
+	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
+	"github.com/wavetermdev/waveterm/tsunami/util"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+// see render.md for a complete guide to how tsunami rendering, lifecycle, and reconciliation works
+
+type RenderOpts struct {
+	Resync bool
+}
+
+func (r *RootElem) Render(elem *vdom.VDomElem, opts *RenderOpts) {
+	r.render(elem, &r.Root, opts)
+}
+
+func getElemKey(elem *vdom.VDomElem) string {
+	if elem == nil {
+		return ""
+	}
+	keyVal, ok := elem.Props[vdom.KeyPropKey]
+	if !ok {
+		return ""
+	}
+	return fmt.Sprint(keyVal)
+}
+
+func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
+	if elem == nil || elem.Tag == "" {
+		r.unmount(comp)
+		return
+	}
+	elemKey := getElemKey(elem)
+	if *comp == nil || !(*comp).compMatch(elem.Tag, elemKey) {
+		r.unmount(comp)
+		r.createComp(elem.Tag, elemKey, comp)
+	}
+	(*comp).Elem = elem
+	if elem.Tag == vdom.TextTag {
+		// Pattern 1: Text Nodes
+		r.renderText(elem.Text, comp)
+		return
+	}
+	if isBaseTag(elem.Tag) {
+		// Pattern 2: Base elements
+		r.renderSimple(elem, comp, opts)
+		return
+	}
+	cfunc := r.CFuncs[elem.Tag]
+	if cfunc == nil {
+		text := fmt.Sprintf("<%s>", elem.Tag)
+		r.renderText(text, comp)
+		return
+	}
+	// Pattern 3: components
+	r.renderComponent(cfunc, elem, comp, opts)
+}
+
+// Pattern 1
+func (r *RootElem) renderText(text string, comp **ComponentImpl) {
+	// No need to clear Children/Comp - text components cannot have them
+	if (*comp).Text != text {
+		(*comp).Text = text
+	}
+}
+
+// Pattern 2
+func (r *RootElem) renderSimple(elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
+	if (*comp).RenderedComp != nil {
+		// Clear Comp since base elements don't use it
+		r.unmount(&(*comp).RenderedComp)
+	}
+	(*comp).Children = r.renderChildren(elem.Children, (*comp).Children, opts)
+}
+
+// Pattern 3
+func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
+	if (*comp).Children != nil {
+		// Clear Children since custom components don't use them
+		for _, child := range (*comp).Children {
+			r.unmount(&child)
+		}
+		(*comp).Children = nil
+	}
+	props := make(map[string]any)
+	for k, v := range elem.Props {
+		props[k] = v
+	}
+	props[ChildrenPropKey] = elem.Children
+	vc := makeContextVal(r, *comp, opts)
+	rtnElemArr := withGlobalCtx(vc, func() []vdom.VDomElem {
+		ctx := r.OuterCtx
+		if ctx == nil {
+			ctx = context.Background()
+		}
+		renderedElem := callCFunc(cfunc, ctx, props)
+		return vdom.ToElems(renderedElem)
+	})
+	var rtnElem *vdom.VDomElem
+	if len(rtnElemArr) == 0 {
+		rtnElem = nil
+	} else if len(rtnElemArr) == 1 {
+		rtnElem = &rtnElemArr[0]
+	} else {
+		rtnElem = &vdom.VDomElem{Tag: vdom.FragmentTag, Children: rtnElemArr}
+	}
+	r.render(rtnElem, &(*comp).RenderedComp, opts)
+}
+
+func (r *RootElem) unmount(comp **ComponentImpl) {
+	if *comp == nil {
+		return
+	}
+	waveId := (*comp).WaveId
+	for _, hook := range (*comp).Hooks {
+		if hook.UnmountFn != nil {
+			hook.UnmountFn()
+		}
+	}
+	if (*comp).RenderedComp != nil {
+		r.unmount(&(*comp).RenderedComp)
+	}
+	if (*comp).Children != nil {
+		for _, child := range (*comp).Children {
+			r.unmount(&child)
+		}
+	}
+	delete(r.CompMap, waveId)
+	r.cleanupUsedByForUnmount(waveId)
+	*comp = nil
+}
+
+func (r *RootElem) createComp(tag string, key string, comp **ComponentImpl) {
+	*comp = &ComponentImpl{WaveId: uuid.New().String(), Tag: tag, Key: key}
+	r.CompMap[(*comp).WaveId] = *comp
+}
+
+// handles reconcilation
+// maps children via key or index (exclusively)
+func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*ComponentImpl, opts *RenderOpts) []*ComponentImpl {
+	newChildren := make([]*ComponentImpl, len(elems))
+	curCM := make(map[ChildKey]*ComponentImpl)
+	usedMap := make(map[*ComponentImpl]bool)
+	for idx, child := range curChildren {
+		if child.Key != "" {
+			curCM[ChildKey{Tag: child.Tag, Idx: 0, Key: child.Key}] = child
+		} else {
+			curCM[ChildKey{Tag: child.Tag, Idx: idx, Key: ""}] = child
+		}
+	}
+	for idx, elem := range elems {
+		elemKey := getElemKey(&elem)
+		var curChild *ComponentImpl
+		if elemKey != "" {
+			curChild = curCM[ChildKey{Tag: elem.Tag, Idx: 0, Key: elemKey}]
+		} else {
+			curChild = curCM[ChildKey{Tag: elem.Tag, Idx: idx, Key: ""}]
+		}
+		usedMap[curChild] = true
+		newChildren[idx] = curChild
+		r.render(&elem, &newChildren[idx], opts)
+	}
+	for _, child := range curChildren {
+		if !usedMap[child] {
+			r.unmount(&child)
+		}
+	}
+	return newChildren
+}
+
+// uses reflection to call the component function
+func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
+	rval := reflect.ValueOf(cfunc)
+	arg2Type := rval.Type().In(1)
+
+	var arg2Val reflect.Value
+	if arg2Type.Kind() == reflect.Interface && arg2Type.NumMethod() == 0 {
+		arg2Val = reflect.New(arg2Type)
+	} else {
+		arg2Val = reflect.New(arg2Type)
+		if arg2Type.Kind() == reflect.Map {
+			arg2Val.Elem().Set(reflect.ValueOf(props))
+		} else {
+			err := util.MapToStruct(props, arg2Val.Interface())
+			if err != nil {
+				fmt.Printf("error unmarshalling props: %v\n", err)
+			}
+		}
+	}
+	rtnVal := rval.Call([]reflect.Value{reflect.ValueOf(ctx), arg2Val.Elem()})
+	if len(rtnVal) == 0 {
+		return nil
+	}
+	return rtnVal[0].Interface()
+}
+
+func convertPropsToVDom(props map[string]any) map[string]any {
+	if len(props) == 0 {
+		return nil
+	}
+	vdomProps := make(map[string]any)
+	for k, v := range props {
+		if v == nil {
+			continue
+		}
+		if vdomFunc, ok := v.(vdom.VDomFunc); ok {
+			// ensure Type is set on all VDomFuncs
+			vdomFunc.Type = vdom.ObjectType_Func
+			vdomProps[k] = vdomFunc
+			continue
+		}
+		if vdomRef, ok := v.(vdom.VDomRef); ok {
+			// ensure Type is set on all VDomRefs
+			vdomRef.Type = vdom.ObjectType_Ref
+			vdomProps[k] = vdomRef
+			continue
+		}
+		val := reflect.ValueOf(v)
+		if val.Kind() == reflect.Func {
+			// convert go functions passed to event handlers to VDomFuncs
+			vdomProps[k] = vdom.VDomFunc{Type: vdom.ObjectType_Func}
+			continue
+		}
+		vdomProps[k] = v
+	}
+	return vdomProps
+}
+
+func (r *RootElem) MakeRendered() *rpctypes.RenderedElem {
+	if r.Root == nil {
+		return nil
+	}
+	return r.convertCompToRendered(r.Root)
+}
+
+func (r *RootElem) convertCompToRendered(c *ComponentImpl) *rpctypes.RenderedElem {
+	if c == nil {
+		return nil
+	}
+	if c.RenderedComp != nil {
+		return r.convertCompToRendered(c.RenderedComp)
+	}
+	if len(c.Children) == 0 && r.CFuncs[c.Tag] != nil {
+		return nil
+	}
+	return r.convertBaseToRendered(c)
+}
+
+func (r *RootElem) convertBaseToRendered(c *ComponentImpl) *rpctypes.RenderedElem {
+	elem := &rpctypes.RenderedElem{WaveId: c.WaveId, Tag: c.Tag}
+	if c.Elem != nil {
+		elem.Props = convertPropsToVDom(c.Elem.Props)
+	}
+	for _, child := range c.Children {
+		childElem := r.convertCompToRendered(child)
+		if childElem != nil {
+			elem.Children = append(elem.Children, *childElem)
+		}
+	}
+	if c.Tag == vdom.TextTag {
+		elem.Text = c.Text
+	}
+	return elem
+}
+
+func isBaseTag(tag string) bool {
+	if tag == "" {
+		return false
+	}
+	if tag == vdom.TextTag || tag == vdom.WaveTextTag || tag == vdom.WaveNullTag || tag == vdom.FragmentTag {
+		return true
+	}
+	if tag[0] == '#' {
+		return true
+	}
+	firstChar := rune(tag[0])
+	return unicode.IsLower(firstChar)
+}
diff --git a/tsunami/engine/render.md b/tsunami/engine/render.md
new file mode 100644
index 0000000000..b3fc0b64af
--- /dev/null
+++ b/tsunami/engine/render.md
@@ -0,0 +1,262 @@
+# Tsunami Rendering Engine
+
+The Tsunami rendering engine implements a React-like component system with virtual DOM reconciliation. It maintains a persistent shadow component tree that efficiently updates in response to new VDom input, similar to React's Fiber architecture.
+
+## Core Architecture
+
+### Two-Phase VDom System
+
+Tsunami uses separate types for different phases of the rendering pipeline:
+
+- **VDomElem**: Input format used by developers (JSX-like elements created with `vdom.H()`)
+- **ComponentImpl**: Internal shadow tree that maintains component identity and state across renders
+- **RenderedElem**: Output format sent to the frontend with populated WaveIds
+
+This separation mirrors React's approach where JSX elements, Fiber nodes, and DOM operations use different data structures optimized for their specific purposes.
+
+### ComponentImpl: The Shadow Tree
+
+The `ComponentImpl` structure is Tsunami's equivalent to React's Fiber nodes. It maintains a persistent tree that survives between renders, preserving component identity, state, and lifecycle information.
+
+Each ComponentImpl contains:
+
+- **Identity fields**: WaveId (unique identifier), Tag (component type), Key (for reconciliation)
+- **State management**: Hooks array for React-like state and effects
+- **Content organization**: Exactly one of three mutually exclusive patterns
+
+## Three Component Patterns
+
+The engine organizes components into three distinct patterns, each using different fields in ComponentImpl:
+
+### Pattern 1: Text Components
+
+```go
+Text string                    // Text content (Pattern 1: text nodes only)
+Children = nil                 // Not used
+RenderedComp = nil            // Not used
+```
+
+Used for `#text` components that render string content directly. These are the leaf nodes of the component tree.
+
+**Example**: `vdom.H("#text", nil, "Hello World")` creates a ComponentImpl with `Text = "Hello World"`
+
+### Pattern 2: Base/DOM Elements
+
+```go
+Text = ""                      // Not used
+Children []*ComponentImpl      // Child components (Pattern 2: containers only)
+RenderedComp = nil            // Not used
+```
+
+Used for HTML elements, fragments, and Wave-specific elements that act as containers. These components render multiple children but don't transform into other component types.
+
+**Example**: `vdom.H("div", nil, child1, child2)` creates a ComponentImpl with `Children = [child1Comp, child2Comp]`
+
+**Base elements include**:
+
+- HTML tags with lowercase first letter (`"div"`, `"span"`, `"button"`)
+- Hash-prefixed special elements (`"#fragment"`, `"#text"`)
+- Wave-specific elements (`"wave:text"`, `"wave:null"`)
+
+### Pattern 3: Custom Components
+
+```go
+Text = ""                      // Not used
+Children = nil                 // Not used
+RenderedComp *ComponentImpl   // Rendered output (Pattern 3: custom components only)
+```
+
+Used for user-defined components that transform into other components through their render functions. These create component chains where custom components render to base elements.
+
+**Example**: A `TodoItem` component renders to a `div`, creating the chain:
+
+```
+TodoItem ComponentImpl (Pattern 3)
+└── RenderedComp → div ComponentImpl (Pattern 2)
+                   └── Children → [text, button, etc.]
+```
+
+## Rendering Flow
+
+### 1. Reconciliation and Pattern Routing
+
+The main `render()` function performs React-like reconciliation:
+
+1. **Null handling**: `elem == nil` unmounts the component
+2. **Component matching**: Existing components are reused if tag and key match
+3. **Pattern routing**: Elements are routed to the appropriate pattern based on tag type
+
+```go
+if elem.Tag == vdom.TextTag {
+    // Pattern 1: Text Nodes
+    r.renderText(elem.Text, comp)
+} else if isBaseTag(elem.Tag) {
+    // Pattern 2: Base elements
+    r.renderSimple(elem, comp, opts)
+} else {
+    // Pattern 3: Custom components
+    r.renderComponent(cfunc, elem, comp, opts)
+}
+```
+
+### 2. Pattern-Specific Rendering
+
+Each pattern has its own rendering function that manages field usage:
+
+**renderText()**: Simply stores text content, no cleanup needed since text components can't have other patterns.
+
+**renderSimple()**: Clears any existing `RenderedComp` (Pattern 3) and renders children into the `Children` field (Pattern 2).
+
+**renderComponent()**: Clears any existing `Children` (Pattern 2), calls the component function, and renders the result into `RenderedComp` (Pattern 3).
+
+### 3. Component Function Execution
+
+Custom components are Go functions called via reflection:
+
+1. **Props conversion**: The VDomElem props map is converted to the expected Go struct type
+2. **Function execution**: The component function is called with context and typed props
+3. **Result processing**: Returned elements are converted to VDomElem arrays
+4. **Fragment wrapping**: Multiple returned elements are automatically wrapped in fragments
+
+```go
+// Single element: renders directly to RenderedComp
+// Multiple elements: wrapped in fragment, then rendered to RenderedComp
+if len(rtnElemArr) == 1 {
+    rtnElem = &rtnElemArr[0]
+} else {
+    rtnElem = &vdom.VDomElem{Tag: vdom.FragmentTag, Children: rtnElemArr}
+}
+```
+
+## Key-Based Reconciliation
+
+The children reconciliation system implements React's key-matching logic:
+
+### ChildKey Structure
+
+```go
+type ChildKey struct {
+    Tag string  // Component type must match
+    Idx int     // Position index for non-keyed elements
+    Key string  // Explicit key for keyed elements
+}
+```
+
+### Matching Rules
+
+1. **Keyed elements**: Match by tag + key, position ignored
+
+   - `<div key="a">` only matches `<div key="a">`
+   - Position changes don't break identity
+
+2. **Non-keyed elements**: Match by tag + position
+
+   - `<div>` at position 0 only matches `<div>` at position 0
+   - Moving elements breaks identity and causes remount
+
+3. **Key transitions**: Keyed and non-keyed elements never match
+   - `<div>` → `<div key="hello">` causes remount
+   - Adding/removing keys breaks component identity
+
+### Reconciliation Algorithm
+
+```go
+// Build map of existing children by ChildKey
+for idx, child := range curChildren {
+    if child.Key != "" {
+        curCM[ChildKey{Tag: child.Tag, Idx: 0, Key: child.Key}] = child
+    } else {
+        curCM[ChildKey{Tag: child.Tag, Idx: idx, Key: ""}] = child
+    }
+}
+
+// Match new elements against existing map
+for idx, elem := range elems {
+    elemKey := getElemKey(&elem)
+    if elemKey != "" {
+        curChild = curCM[ChildKey{Tag: elem.Tag, Idx: 0, Key: elemKey}]
+    } else {
+        curChild = curCM[ChildKey{Tag: elem.Tag, Idx: idx, Key: ""}]
+    }
+    // Reuse existing component or create new one
+}
+```
+
+## Component Lifecycle
+
+### Mounting
+
+New components are created with:
+
+- Unique WaveId for tracking
+- Tag and Key for reconciliation
+- Registration in global ComponentMap
+- Empty pattern fields (populated during rendering)
+
+### Unmounting
+
+The unmounting process ensures complete cleanup:
+
+1. **Hook cleanup**: All hook `UnmountFn` callbacks are executed
+2. **Pattern-specific cleanup**:
+   - Pattern 3: Recursively unmount `RenderedComp`
+   - Pattern 2: Recursively unmount all `Children`
+   - Pattern 1: No child cleanup needed
+3. **Global cleanup**: Remove from ComponentMap and dependency tracking
+
+This prevents memory leaks and ensures proper lifecycle management.
+
+### Component vs Rendered Content Lifecycle
+
+A key distinction in Tsunami (matching React) is that component mounting/unmounting is separate from what they render:
+
+- **Component returns `nil`**: Component stays mounted (keeps state/hooks), but `RenderedComp` becomes `nil`
+- **Component returns content again**: Component reuses existing identity, new content gets mounted
+
+This preserves component state across rendering/not-rendering cycles.
+
+## Output Generation
+
+The shadow tree gets converted to frontend-ready format through `MakeRendered()`:
+
+1. **Component chain following**: For Pattern 3 components, follow `RenderedComp` until reaching a base element
+2. **Base element conversion**: Convert Pattern 1/2 components to RenderedElem with WaveIds
+3. **Null component filtering**: Components with `RenderedComp == nil` don't appear in output
+
+Only base elements (Pattern 1/2) appear in the final output - custom components (Pattern 3) are invisible, having transformed into base elements.
+
+## React Similarities and Differences
+
+### Similarities
+
+- **Reconciliation**: Same key-based matching and component reuse logic
+- **Hooks**: Same lifecycle patterns with cleanup functions
+- **Component identity**: Persistent component instances across renders
+- **Null rendering**: Components can render nothing while staying mounted
+
+### Key Differences
+
+- **Server-side**: Runs entirely in Go backend, sends VDom to frontend
+- **Component chaining**: Pattern 3 allows direct component-to-component rendering via `RenderedComp`
+- **Explicit patterns**: Three mutually exclusive patterns vs React's more flexible structure
+- **Type separation**: Clear separation between input VDom, shadow tree, and output types
+
+### Performance Optimizations
+
+The three-pattern system provides significant optimizations:
+
+- **Base element efficiency**: HTML elements use `Children` directly without intermediate transformation nodes
+- **Component chain efficiency**: Custom components chain via `RenderedComp` without wrapper overhead
+- **Memory efficiency**: Each pattern only allocates fields it actually uses
+
+This avoids React's issue where every element creates wrapper nodes, leading to shorter traversal paths and fewer allocations.
+
+## Pattern Transition Rules
+
+Components never transition between patterns - they maintain their pattern for their entire lifecycle:
+
+- **Tag determines pattern**: `#text` → Pattern 1, base tags → Pattern 2, custom tags → Pattern 3
+- **Tag changes cause remount**: Different tag = different component = complete unmount/remount
+- **Pattern fields are exclusive**: Only one pattern's fields are populated per component
+
+This ensures clean memory management and predictable behavior - no cross-pattern cleanup is needed within individual render functions.
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index ea94c06ba3..271f9c95ee 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -11,30 +11,13 @@ import (
 	"strconv"
 	"strings"
 	"sync"
-	"unicode"
 
-	"github.com/google/uuid"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
-	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
 const ChildrenPropKey = "children"
 
-func getElemKey(elem *vdom.VDomElem) string {
-	if elem == nil {
-		return ""
-	}
-	keyVal, ok := elem.Props[vdom.KeyPropKey]
-	if !ok {
-		return ""
-	}
-	return fmt.Sprint(keyVal)
-}
-
-type RenderOpts struct {
-	Resync bool
-}
 
 type EffectWorkElem struct {
 	Id          string
@@ -232,10 +215,6 @@ func (r *RootElem) RegisterComponent(name string, cfunc any) error {
 	return nil
 }
 
-func (r *RootElem) Render(elem *vdom.VDomElem, opts *RenderOpts) {
-	r.render(elem, &r.Root, opts)
-}
-
 func callVDomFn(fnVal any, data vdom.VDomEvent) {
 	if fnVal == nil {
 		return
@@ -305,170 +284,6 @@ func (r *RootElem) RunWork(opts *RenderOpts) {
 	}
 }
 
-func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
-	if elem == nil || elem.Tag == "" {
-		r.unmount(comp)
-		return
-	}
-	elemKey := getElemKey(elem)
-	if *comp == nil || !(*comp).compMatch(elem.Tag, elemKey) {
-		r.unmount(comp)
-		r.createComp(elem.Tag, elemKey, comp)
-	}
-	(*comp).Elem = elem
-	if elem.Tag == vdom.TextTag {
-		r.renderText(elem.Text, comp)
-		return
-	}
-	if isBaseTag(elem.Tag) {
-		// simple vdom, fragment, wave element
-		r.renderSimple(elem, comp, opts)
-		return
-	}
-	cfunc := r.CFuncs[elem.Tag]
-	if cfunc == nil {
-		text := fmt.Sprintf("<%s>", elem.Tag)
-		r.renderText(text, comp)
-		return
-	}
-	r.renderComponent(cfunc, elem, comp, opts)
-}
-
-func (r *RootElem) unmount(comp **ComponentImpl) {
-	if *comp == nil {
-		return
-	}
-	waveId := (*comp).WaveId
-	// parent clean up happens first
-	for _, hook := range (*comp).Hooks {
-		if hook.UnmountFn != nil {
-			hook.UnmountFn()
-		}
-	}
-	// clean up any children
-	if (*comp).Comp != nil {
-		r.unmount(&(*comp).Comp)
-	}
-	if (*comp).Children != nil {
-		for _, child := range (*comp).Children {
-			r.unmount(&child)
-		}
-	}
-	delete(r.CompMap, waveId)
-	r.cleanupUsedByForUnmount(waveId)
-	*comp = nil
-}
-
-func (r *RootElem) createComp(tag string, key string, comp **ComponentImpl) {
-	*comp = &ComponentImpl{WaveId: uuid.New().String(), Tag: tag, Key: key}
-	r.CompMap[(*comp).WaveId] = *comp
-}
-
-func (r *RootElem) renderText(text string, comp **ComponentImpl) {
-	if (*comp).Text != text {
-		(*comp).Text = text
-	}
-}
-
-func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*ComponentImpl, opts *RenderOpts) []*ComponentImpl {
-	newChildren := make([]*ComponentImpl, len(elems))
-	curCM := make(map[ChildKey]*ComponentImpl)
-	usedMap := make(map[*ComponentImpl]bool)
-	for idx, child := range curChildren {
-		if child.Key != "" {
-			curCM[ChildKey{Tag: child.Tag, Idx: 0, Key: child.Key}] = child
-		} else {
-			curCM[ChildKey{Tag: child.Tag, Idx: idx, Key: ""}] = child
-		}
-	}
-	for idx, elem := range elems {
-		elemKey := getElemKey(&elem)
-		var curChild *ComponentImpl
-		if elemKey != "" {
-			curChild = curCM[ChildKey{Tag: elem.Tag, Idx: 0, Key: elemKey}]
-		} else {
-			curChild = curCM[ChildKey{Tag: elem.Tag, Idx: idx, Key: ""}]
-		}
-		usedMap[curChild] = true
-		newChildren[idx] = curChild
-		r.render(&elem, &newChildren[idx], opts)
-	}
-	for _, child := range curChildren {
-		if !usedMap[child] {
-			r.unmount(&child)
-		}
-	}
-	return newChildren
-}
-
-func (r *RootElem) renderSimple(elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
-	if (*comp).Comp != nil {
-		r.unmount(&(*comp).Comp)
-	}
-	(*comp).Children = r.renderChildren(elem.Children, (*comp).Children, opts)
-}
-
-func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
-	rval := reflect.ValueOf(cfunc)
-	arg2Type := rval.Type().In(1)
-
-	var arg2Val reflect.Value
-	if arg2Type.Kind() == reflect.Interface && arg2Type.NumMethod() == 0 {
-		// For any/interface{}, pass nil properly
-		arg2Val = reflect.New(arg2Type)
-	} else {
-		arg2Val = reflect.New(arg2Type)
-		// if arg2 is a map, just pass props
-		if arg2Type.Kind() == reflect.Map {
-			arg2Val.Elem().Set(reflect.ValueOf(props))
-		} else {
-			err := util.MapToStruct(props, arg2Val.Interface())
-			if err != nil {
-				fmt.Printf("error unmarshalling props: %v\n", err)
-			}
-		}
-	}
-	rtnVal := rval.Call([]reflect.Value{reflect.ValueOf(ctx), arg2Val.Elem()})
-	if len(rtnVal) == 0 {
-		return nil
-	}
-	return rtnVal[0].Interface()
-}
-
-func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
-	if (*comp).Children != nil {
-		for _, child := range (*comp).Children {
-			r.unmount(&child)
-		}
-		(*comp).Children = nil
-	}
-	props := make(map[string]any)
-	for k, v := range elem.Props {
-		props[k] = v
-	}
-	props[ChildrenPropKey] = elem.Children
-	vc := makeContextVal(r, *comp, opts)
-	rtnElemArr := withGlobalCtx(vc, func() []vdom.VDomElem {
-		ctx := r.OuterCtx
-		if ctx == nil {
-			ctx = context.Background()
-		}
-		renderedElem := callCFunc(cfunc, ctx, props)
-		return vdom.ToElems(renderedElem)
-	})
-	if len(rtnElemArr) == 0 {
-		r.unmount(&(*comp).Comp)
-		return
-	}
-	var rtnElem *vdom.VDomElem
-	if len(rtnElemArr) == 1 {
-		rtnElem = &rtnElemArr[0]
-	} else {
-		rtnElem = &vdom.VDomElem{Tag: vdom.FragmentTag, Children: rtnElemArr}
-	}
-	r.render(rtnElem, &(*comp).Comp, opts)
-}
-
 func (r *RootElem) UpdateRef(updateRef rpctypes.VDomRefUpdate) {
 	refId := updateRef.RefId
 	split := strings.SplitN(refId, ":", 2)
@@ -511,113 +326,3 @@ func (r *RootElem) GetRefOperations() []vdom.VDomRefOperation {
 	r.RefOperations = nil
 	return ops
 }
-
-func convertPropsToVDom(props map[string]any) map[string]any {
-	if len(props) == 0 {
-		return nil
-	}
-	vdomProps := make(map[string]any)
-	for k, v := range props {
-		if v == nil {
-			continue
-		}
-		val := reflect.ValueOf(v)
-		if val.Kind() == reflect.Func {
-			vdomProps[k] = vdom.VDomFunc{Type: vdom.ObjectType_Func}
-			continue
-		}
-		vdomProps[k] = v
-	}
-	return vdomProps
-}
-
-func (r *RootElem) convertBaseToVDom(c *ComponentImpl) *vdom.VDomElem {
-	elem := &vdom.VDomElem{WaveId: c.WaveId, Tag: c.Tag}
-	if c.Elem != nil {
-		elem.Props = convertPropsToVDom(c.Elem.Props)
-	}
-	for _, child := range c.Children {
-		childElem := r.convertCompToVDom(child)
-		if childElem != nil {
-			elem.Children = append(elem.Children, *childElem)
-		}
-	}
-	if c.Tag == vdom.TextTag {
-		elem.Text = c.Text
-	}
-	return elem
-}
-
-func (r *RootElem) convertCompToVDom(c *ComponentImpl) *vdom.VDomElem {
-	if c == nil {
-		return nil
-	}
-	if c.Comp != nil {
-		return r.convertCompToVDom(c.Comp)
-	}
-	// If this is a registered component that was unmounted (c.Comp == nil) and has no children, return nil
-	// This prevents unmounted components from being serialized as their original tag names
-	if len(c.Children) == 0 && r.CFuncs[c.Tag] != nil {
-		return nil
-	}
-	return r.convertBaseToVDom(c)
-}
-
-func (r *RootElem) MakeVDom() *vdom.VDomElem {
-	if r.Root == nil {
-		return nil
-	}
-	return r.convertCompToVDom(r.Root)
-}
-
-func ConvertElemsToTransferElems(elems []vdom.VDomElem) []rpctypes.VDomTransferElem {
-	transferElems := make([]rpctypes.VDomTransferElem, 0)
-	for _, elem := range elems {
-		transferElem := rpctypes.VDomTransferElem{
-			WaveId: elem.WaveId,
-			Tag:    elem.Tag,
-			Props:  elem.Props,
-			Text:   elem.Text,
-		}
-		for _, child := range elem.Children {
-			transferElem.Children = append(transferElem.Children, child.WaveId)
-		}
-		transferElems = append(transferElems, transferElem)
-		childTransferElems := ConvertElemsToTransferElems(elem.Children)
-		transferElems = append(transferElems, childTransferElems...)
-	}
-	return transferElems
-}
-
-func VDomFuncCallFn(vdf *vdom.VDomFunc, event vdom.VDomEvent) {
-	if vdf.Fn == nil {
-		return
-	}
-	rval := reflect.ValueOf(vdf.Fn)
-	if rval.Kind() != reflect.Func {
-		return
-	}
-	rtype := rval.Type()
-	if rtype.NumIn() == 0 {
-		rval.Call(nil)
-	}
-	if rtype.NumIn() == 1 {
-		if rtype.In(0) == reflect.TypeOf((*vdom.VDomEvent)(nil)).Elem() {
-			rval.Call([]reflect.Value{reflect.ValueOf(event)})
-		}
-	}
-}
-
-func isBaseTag(tag string) bool {
-	if tag == "" {
-		return false
-	}
-	if tag == vdom.TextTag || tag == vdom.WaveTextTag || tag == vdom.WaveNullTag || tag == vdom.FragmentTag {
-		return true
-	}
-	if tag[0] == '#' {
-		return true
-	}
-	firstChar := rune(tag[0])
-	return unicode.IsLower(firstChar)
-}
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
index a0d8b4def9..861447a2e1 100644
--- a/tsunami/frontend/src/types/vdom.d.ts
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -1,21 +1,14 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-// vdom.VDomAsyncInitiationRequest
-type VDomAsyncInitiationRequest = {
-    type: "asyncinitiationrequest";
-    ts: number;
-    blockid?: string;
-};
-
-// vdom.VDomBackendOpts
+// rpctypes.VDomBackendOpts
 type VDomBackendOpts = {
     globalkeyboardevents?: boolean;
     title?: string;
     faviconpath?: string;
 };
 
-// vdom.VDomBackendUpdate
+// rpctypes.VDomBackendUpdate
 type VDomBackendUpdate = {
     type: "backendupdate";
     ts: number;
@@ -29,16 +22,7 @@ type VDomBackendUpdate = {
     messages?: VDomMessage[];
 };
 
-// vdom.VDomCreateContext
-type VDomCreateContext = {
-    type: "createcontext";
-    ts: number;
-    meta?: MetaType;
-    target?: VDomTarget;
-    persist?: boolean;
-};
-
-// vdom.VDomElem
+// rpctypes.RenderedElem
 type VDomElem = {
     waveid?: string;
     tag: string;
@@ -81,7 +65,7 @@ type VDomFunc = {
     stoppropagation?: boolean;
     preventdefault?: boolean;
     globalevent?: string;
-    "#keys"?: string[];
+    keys?: string[];
 };
 
 // vdom.VDomMessage
@@ -119,14 +103,14 @@ type VDomRefPosition = {
     boundingclientrect: DomRect;
 };
 
-// vdom.VDomRefUpdate
+// rpctypes.VDomRefUpdate
 type VDomRefUpdate = {
     refid: string;
     hascurrent: boolean;
     position?: VDomRefPosition;
 };
 
-// vdom.VDomRenderContext
+// rpctypes.VDomRenderContext
 type VDomRenderContext = {
     focused: boolean;
     width: number;
@@ -135,7 +119,7 @@ type VDomRenderContext = {
     background?: boolean;
 };
 
-// vdom.VDomRenderUpdate
+// rpctypes.VDomRenderUpdate
 type VDomRenderUpdate = {
     updatetype: "root" | "append" | "replace" | "remove" | "insert";
     waveid?: string;
@@ -144,20 +128,7 @@ type VDomRenderUpdate = {
     index?: number;
 };
 
-// vdom.VDomTarget
-type VDomTarget = {
-    newblock?: boolean;
-    magnified?: boolean;
-    toolbar?: VDomTargetToolbar;
-};
-
-// vdom.VDomTargetToolbar
-type VDomTargetToolbar = {
-    toolbar: boolean;
-    height?: string;
-};
-
-// vdom.VDomTransferElem
+// rpctypes.VDomTransferElem
 type VDomTransferElem = {
     waveid?: string;
     tag: string;
@@ -166,22 +137,14 @@ type VDomTransferElem = {
     text?: string;
 };
 
-// wshrpc.VDomUrlRequestData
-type VDomUrlRequestData = {
-    method: string;
-    url: string;
-    headers: { [key: string]: string };
-    body?: string;
-};
-
-// wshrpc.VDomUrlRequestResponse
+// rpctypes.VDomUrlRequestResponse
 type VDomUrlRequestResponse = {
     statuscode?: number;
     headers?: { [key: string]: string };
     body?: Uint8Array;
 };
 
-// Additional types from rpctypes that were missing
+// vdom.VDomKeyboardEvent
 type VDomKeyboardEvent = {
     type: string;
     key: string;
@@ -196,6 +159,7 @@ type VDomKeyboardEvent = {
     location?: number;
 };
 
+// vdom.VDomPointerData
 type VDomPointerData = {
     button: number;
     buttons: number;
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index a926af3b4b..3e2a447385 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -138,10 +138,10 @@ const SvgUrlIdAttributes = {
 
 function convertVDomFunc(model: TsunamiModel, fnDecl: VDomFunc, compId: string, propName: string): (e: any) => void {
     return (e: any) => {
-        if ((propName == "onKeyDown" || propName == "onKeyDownCapture") && fnDecl["#keys"]) {
+        if ((propName == "onKeyDown" || propName == "onKeyDownCapture") && fnDecl["keys"]) {
             dlog("key event", fnDecl, e);
             let waveEvent = adaptFromReactOrNativeKeyEvent(e);
-            for (let keyDesc of fnDecl["#keys"] || []) {
+            for (let keyDesc of fnDecl["keys"] || []) {
                 if (checkKeyPressed(waveEvent, keyDesc)) {
                     e.preventDefault();
                     e.stopPropagation();
diff --git a/tsunami/rpctypes/protocoltypes.go b/tsunami/rpctypes/protocoltypes.go
index 743b00baaa..056c7e32ab 100644
--- a/tsunami/rpctypes/protocoltypes.go
+++ b/tsunami/rpctypes/protocoltypes.go
@@ -5,31 +5,25 @@ package rpctypes
 
 import (
 	"fmt"
-	"time"
 
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
+// rendered element (output from rendering pipeline)
+type RenderedElem struct {
+	WaveId   string         `json:"waveid,omitempty"` // required, except for #text nodes
+	Tag      string         `json:"tag"`
+	Props    map[string]any `json:"props,omitempty"`
+	Children []RenderedElem `json:"children,omitempty"`
+	Text     string         `json:"text,omitempty"`
+}
+
 type VDomUrlRequestResponse struct {
 	StatusCode int               `json:"statuscode,omitempty"`
 	Headers    map[string]string `json:"headers,omitempty"`
 	Body       []byte            `json:"body,omitempty"`
 }
 
-type VDomAsyncInitiationRequest struct {
-	Type    string `json:"type" tstype:"\"asyncinitiationrequest\""`
-	Ts      int64  `json:"ts"`
-	BlockId string `json:"blockid,omitempty"`
-}
-
-func MakeAsyncInitiationRequest(blockId string) VDomAsyncInitiationRequest {
-	return VDomAsyncInitiationRequest{
-		Type:    "asyncinitiationrequest",
-		Ts:      time.Now().UnixMilli(),
-		BlockId: blockId,
-	}
-}
-
 type VDomFrontendUpdate struct {
 	Type          string            `json:"type" tstype:"\"frontendupdate\""`
 	Ts            int64             `json:"ts"`
@@ -67,27 +61,27 @@ type VDomTransferElem struct {
 }
 
 func (beUpdate *VDomBackendUpdate) CreateTransferElems() {
-	var vdomElems []vdom.VDomElem
+	var renderedElems []RenderedElem
 	for idx, reUpdate := range beUpdate.RenderUpdates {
 		if reUpdate.VDom == nil {
 			continue
 		}
-		vdomElems = append(vdomElems, *reUpdate.VDom)
+		renderedElems = append(renderedElems, *reUpdate.VDom)
 		beUpdate.RenderUpdates[idx].VDomWaveId = reUpdate.VDom.WaveId
 		beUpdate.RenderUpdates[idx].VDom = nil
 	}
-	transferElems := ConvertElemsToTransferElems(vdomElems)
+	transferElems := ConvertElemsToTransferElems(renderedElems)
 	transferElems = DedupTransferElems(transferElems)
 	beUpdate.TransferElems = transferElems
 }
 
-func ConvertElemsToTransferElems(elems []vdom.VDomElem) []VDomTransferElem {
+func ConvertElemsToTransferElems(elems []RenderedElem) []VDomTransferElem {
 	var transferElems []VDomTransferElem
 	textCounter := 0 // Counter for generating unique IDs for #text nodes
 
-	// Helper function to recursively process each VDomElem in preorder
-	var processElem func(elem vdom.VDomElem) string
-	processElem = func(elem vdom.VDomElem) string {
+	// Helper function to recursively process each RenderedElem in preorder
+	var processElem func(elem RenderedElem) string
+	processElem = func(elem RenderedElem) string {
 		// Handle #text nodes by generating a unique placeholder ID
 		if elem.Tag == "#text" {
 			textId := fmt.Sprintf("text-%d", textCounter)
@@ -155,7 +149,6 @@ type VDomRenderContext struct {
 	Background bool   `json:"background,omitempty"`
 }
 
-
 type VDomRefUpdate struct {
 	RefId      string                `json:"refid"`
 	HasCurrent bool                  `json:"hascurrent"`
@@ -169,11 +162,11 @@ type VDomBackendOpts struct {
 }
 
 type VDomRenderUpdate struct {
-	UpdateType string         `json:"updatetype" tstype:"\"root\"|\"append\"|\"replace\"|\"remove\"|\"insert\""`
-	WaveId     string         `json:"waveid,omitempty"`
-	VDomWaveId string         `json:"vdomwaveid,omitempty"`
-	VDom       *vdom.VDomElem `json:"vdom,omitempty"` // these get removed for transfer (encoded to transferelems)
-	Index      *int           `json:"index,omitempty"`
+	UpdateType string        `json:"updatetype" tstype:"\"root\"|\"append\"|\"replace\"|\"remove\"|\"insert\""`
+	WaveId     string        `json:"waveid,omitempty"`
+	VDomWaveId string        `json:"vdomwaveid,omitempty"`
+	VDom       *RenderedElem `json:"vdom,omitempty"` // these get removed for transfer (encoded to transferelems)
+	Index      *int          `json:"index,omitempty"`
 }
 
 type VDomMessage struct {
diff --git a/tsunami/vdom/vdom_types.go b/tsunami/vdom/vdom_types.go
index 21f8479f3b..29bbc86835 100644
--- a/tsunami/vdom/vdom_types.go
+++ b/tsunami/vdom/vdom_types.go
@@ -15,7 +15,6 @@ const ObjectType_Func = "func"
 
 // vdom element
 type VDomElem struct {
-	WaveId   string         `json:"waveid,omitempty"` // required, except for #text nodes
 	Tag      string         `json:"tag"`
 	Props    map[string]any `json:"props,omitempty"`
 	Children []VDomElem     `json:"children,omitempty"`
@@ -29,7 +28,7 @@ type VDomFunc struct {
 	StopPropagation bool     `json:"stoppropagation,omitempty"` // set to call e.stopPropagation() on the client side
 	PreventDefault  bool     `json:"preventdefault,omitempty"`  // set to call e.preventDefault() on the client side
 	GlobalEvent     string   `json:"globalevent,omitempty"`
-	Keys            []string `json:"#keys,omitempty"` // special for keyDown events a list of keys to "capture"
+	Keys            []string `json:"keys,omitempty"` // special for keyDown events a list of keys to "capture"
 }
 
 // used in props

From c8f8e1bf17b2a81d2a404408ebb6560040af8870 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 00:19:34 -0700
Subject: [PATCH 087/134] wire up an optimistic input to fix react cursor
 issues

---
 tsunami/demo/githubaction/static/tw.css  |  48 ----------
 tsunami/demo/tsunamiconfig/static/tw.css |  48 ----------
 tsunami/frontend/src/input.tsx           | 107 +++++++++++++++++++++++
 tsunami/frontend/src/vdom.tsx            |  12 +++
 4 files changed, 119 insertions(+), 96 deletions(-)
 create mode 100644 tsunami/frontend/src/input.tsx

diff --git a/tsunami/demo/githubaction/static/tw.css b/tsunami/demo/githubaction/static/tw.css
index 21f779143b..9cee1e8fbe 100644
--- a/tsunami/demo/githubaction/static/tw.css
+++ b/tsunami/demo/githubaction/static/tw.css
@@ -260,33 +260,12 @@
   .sticky {
     position: sticky;
   }
-  .-inset-1 {
-    inset: calc(var(--spacing) * -1);
-  }
   .isolate {
     isolation: isolate;
   }
   .isolation-auto {
     isolation: auto;
   }
-  .\!container {
-    width: 100% !important;
-    @media (width >= 40rem) {
-      max-width: 40rem !important;
-    }
-    @media (width >= 48rem) {
-      max-width: 48rem !important;
-    }
-    @media (width >= 64rem) {
-      max-width: 64rem !important;
-    }
-    @media (width >= 80rem) {
-      max-width: 80rem !important;
-    }
-    @media (width >= 96rem) {
-      max-width: 96rem !important;
-    }
-  }
   .container {
     width: 100%;
     @media (width >= 40rem) {
@@ -920,18 +899,10 @@
     --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .ring {
-    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
-    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
-  }
   .inset-ring {
     --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .outline {
-    outline-style: var(--tw-outline-style);
-    outline-width: 1px;
-  }
   .blur {
     --tw-blur: blur(8px);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
@@ -941,18 +912,10 @@
     --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .grayscale {
-    --tw-grayscale: grayscale(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .invert {
     --tw-invert: invert(100%);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .sepia {
-    --tw-sepia: sepia(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .filter {
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
@@ -980,11 +943,6 @@
     -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
     backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
   }
-  .transition {
-    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
-    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
-    transition-duration: var(--tw-duration, var(--default-transition-duration));
-  }
   .transition-colors {
     transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
     transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
@@ -1204,11 +1162,6 @@
   inherits: false;
   initial-value: 0 0 #0000;
 }
-@property --tw-outline-style {
-  syntax: "*";
-  inherits: false;
-  initial-value: solid;
-}
 @property --tw-blur {
   syntax: "*";
   inherits: false;
@@ -1342,7 +1295,6 @@
       --tw-ring-offset-width: 0px;
       --tw-ring-offset-color: #fff;
       --tw-ring-offset-shadow: 0 0 #0000;
-      --tw-outline-style: solid;
       --tw-blur: initial;
       --tw-brightness: initial;
       --tw-contrast: initial;
diff --git a/tsunami/demo/tsunamiconfig/static/tw.css b/tsunami/demo/tsunamiconfig/static/tw.css
index a989fdd0df..bb214da782 100644
--- a/tsunami/demo/tsunamiconfig/static/tw.css
+++ b/tsunami/demo/tsunamiconfig/static/tw.css
@@ -251,33 +251,12 @@
   .sticky {
     position: sticky;
   }
-  .-inset-1 {
-    inset: calc(var(--spacing) * -1);
-  }
   .isolate {
     isolation: isolate;
   }
   .isolation-auto {
     isolation: auto;
   }
-  .\!container {
-    width: 100% !important;
-    @media (width >= 40rem) {
-      max-width: 40rem !important;
-    }
-    @media (width >= 48rem) {
-      max-width: 48rem !important;
-    }
-    @media (width >= 64rem) {
-      max-width: 64rem !important;
-    }
-    @media (width >= 80rem) {
-      max-width: 80rem !important;
-    }
-    @media (width >= 96rem) {
-      max-width: 96rem !important;
-    }
-  }
   .container {
     width: 100%;
     @media (width >= 40rem) {
@@ -859,18 +838,10 @@
     --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .ring {
-    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
-    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
-  }
   .inset-ring {
     --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .outline {
-    outline-style: var(--tw-outline-style);
-    outline-width: 1px;
-  }
   .blur {
     --tw-blur: blur(8px);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
@@ -880,18 +851,10 @@
     --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .grayscale {
-    --tw-grayscale: grayscale(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .invert {
     --tw-invert: invert(100%);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .sepia {
-    --tw-sepia: sepia(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .filter {
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
@@ -919,11 +882,6 @@
     -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
     backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
   }
-  .transition {
-    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
-    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
-    transition-duration: var(--tw-duration, var(--default-transition-duration));
-  }
   .transition-colors {
     transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
     transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
@@ -1153,11 +1111,6 @@
   inherits: false;
   initial-value: 0 0 #0000;
 }
-@property --tw-outline-style {
-  syntax: "*";
-  inherits: false;
-  initial-value: solid;
-}
 @property --tw-blur {
   syntax: "*";
   inherits: false;
@@ -1291,7 +1244,6 @@
       --tw-ring-offset-width: 0px;
       --tw-ring-offset-color: #fff;
       --tw-ring-offset-shadow: 0 0 #0000;
-      --tw-outline-style: solid;
       --tw-blur: initial;
       --tw-brightness: initial;
       --tw-contrast: initial;
diff --git a/tsunami/frontend/src/input.tsx b/tsunami/frontend/src/input.tsx
new file mode 100644
index 0000000000..08fbbeae6d
--- /dev/null
+++ b/tsunami/frontend/src/input.tsx
@@ -0,0 +1,107 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import * as React from "react";
+
+type Props = {
+    value?: string;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    onInput?: (e: React.FormEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    ttlMs?: number; // default 100
+    ref?: React.Ref<HTMLInputElement | HTMLTextAreaElement>;
+    _tagName: "input" | "textarea";
+} & Omit<React.InputHTMLAttributes<HTMLInputElement> & React.TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "onChange" | "onInput">;
+
+/**
+ * OptimisticInput - A React input component that provides optimistic UI updates for Tsunami's framework.
+ *
+ * Problem: In Tsunami's reactive framework, every onChange event is sent to the server, which can cause
+ * the cursor to jump or typing to feel laggy as the server responds with updates.
+ *
+ * Solution: This component applies updates optimistically by maintaining a "shadow" value that shows
+ * immediately in the UI while waiting for server acknowledgment. If the server responds with the same
+ * value within the TTL period (default 100ms), the optimistic update is confirmed. If the server
+ * doesn't respond or responds with a different value, the input reverts to the server value.
+ *
+ * Key behaviors:
+ * - For controlled inputs (value provided): Uses optimistic updates with shadow state
+ * - For uncontrolled inputs (value undefined): Behaves like a normal React input
+ * - Skips optimistic logic when disabled or readonly
+ * - Handles IME composition properly to avoid interfering with multi-byte character input
+ * - Supports both onChange and onInput event handlers
+ * - Preserves cursor position through React's natural behavior (no manual cursor management)
+ *
+ * Example usage:
+ * ```tsx
+ * <OptimisticInput
+ *   value={serverValue}
+ *   onChange={(e) => sendToServer(e.target.value)}
+ *   ttlMs={200}
+ * />
+ * ```
+ */
+function OptimisticInput({ value, onChange, onInput, ttlMs = 100, ref: forwardedRef, _tagName, ...rest }: Props) {
+    const [shadow, setShadow] = React.useState<string | null>(null);
+    const timer = React.useRef<number | undefined>(undefined);
+
+    const startTTL = React.useCallback(() => {
+        if (timer.current) clearTimeout(timer.current);
+        timer.current = window.setTimeout(() => {
+            // no ack within TTL → revert to server
+            setShadow(null);
+            // caret will follow serverValue; optionally restore selRef here if you track a server caret
+        }, ttlMs);
+    }, [ttlMs]);
+
+    const handleChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
+        // Skip validation during IME composition
+        // (works in modern browsers/React via nativeEvent)
+        // @ts-expect-error React typing doesn't surface this directly
+        if (e.nativeEvent?.isComposing) return;
+
+        // If uncontrolled (value is undefined), skip optimistic logic
+        if (value === undefined) {
+            onChange?.(e);
+            onInput?.(e);
+            return;
+        }
+
+        // Skip optimistic logic if readonly or disabled
+        if (rest.disabled || rest.readOnly) {
+            onChange?.(e);
+            onInput?.(e);
+            return;
+        }
+
+        const v = e.currentTarget.value;
+        setShadow(v); // optimistic echo
+        startTTL(); // wait for ack
+        onChange?.(e);
+        onInput?.(e);
+    };
+
+    // Ack: backend caught up → drop shadow (and stop the TTL)
+    React.useLayoutEffect(() => {
+        if (shadow !== null && shadow === value) {
+            setShadow(null);
+            if (timer.current) clearTimeout(timer.current);
+        }
+    }, [value, shadow]);
+
+    React.useEffect(
+        () => () => {
+            if (timer.current) clearTimeout(timer.current);
+        },
+        []
+    );
+
+    const realValue = value === undefined ? undefined : (shadow ?? value ?? "");
+    
+    if (_tagName === "textarea") {
+        return <textarea ref={forwardedRef as React.Ref<HTMLTextAreaElement>} value={realValue} onChange={handleChange} {...rest} />;
+    }
+    
+    return <input ref={forwardedRef as React.Ref<HTMLInputElement>} value={realValue} onChange={handleChange} {...rest} />;
+}
+
+export default OptimisticInput;
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index 3e2a447385..52272046a6 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -11,6 +11,7 @@ import { getTextChildren } from "@/model/model-utils";
 import type { TsunamiModel } from "@/model/tsunami-model";
 import { RechartsTag } from "@/recharts/recharts";
 import { adaptFromReactOrNativeKeyEvent, checkKeyPressed } from "@/util/keyutil";
+import OptimisticInput from "./input";
 
 const TextTag = "#text";
 const FragmentTag = "#fragment";
@@ -278,6 +279,17 @@ function VDomTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
     if (elem.tag == FragmentTag) {
         return childrenComps;
     }
+    
+    // Use OptimisticInput for input and textarea elements
+    if (elem.tag === "input" || elem.tag === "textarea") {
+        props.key = "e-" + elem.waveid;
+        const optimisticProps = {
+            ...props,
+            _tagName: elem.tag as "input" | "textarea"
+        };
+        return React.createElement(OptimisticInput, optimisticProps, childrenComps);
+    }
+    
     props.key = "e-" + elem.waveid;
     return React.createElement(elem.tag, props, childrenComps);
 }

From 492c238ca38918c3753c0e3f48205a088b1e601c Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 00:50:54 -0700
Subject: [PATCH 088/134] optimize transfering text with new TransferText
 field...

---
 tsunami/engine/clientimpl.go              |  1 +
 tsunami/frontend/src/model/model-utils.ts | 33 +++++++++++++++---
 tsunami/frontend/src/types/vdom.d.ts      |  7 ++++
 tsunami/frontend/src/vdom.tsx             | 30 ++--------------
 tsunami/rpctypes/protocoltypes.go         | 42 +++++++++++++++--------
 5 files changed, 67 insertions(+), 46 deletions(-)

diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index bbd55cf809..f7a9add5e4 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -287,6 +287,7 @@ func (c *ClientImpl) incrementalRender() (*rpctypes.VDomBackendUpdate, error) {
 		Type:       "backendupdate",
 		Ts:         time.Now().UnixMilli(),
 		ServerId:   c.ServerId,
+		HasWork:    len(c.Root.EffectWorkQueue) > 0,
 		FullUpdate: false,
 		Opts:       c.makeBackendOpts(),
 		RenderUpdates: []rpctypes.VDomRenderUpdate{
diff --git a/tsunami/frontend/src/model/model-utils.ts b/tsunami/frontend/src/model/model-utils.ts
index a4f05f9947..a24ba8a329 100644
--- a/tsunami/frontend/src/model/model-utils.ts
+++ b/tsunami/frontend/src/model/model-utils.ts
@@ -22,7 +22,15 @@ export function restoreVDomElems(backendUpdate: VDomBackendUpdate) {
         return;
     }
 
-    // Step 1: Map of waveid to VDomElem, skipping any without a waveid
+    // Step 1: Create text map from transfertext
+    const textMap = new Map<number, string>();
+    if (backendUpdate.transfertext) {
+        backendUpdate.transfertext.forEach((textEntry) => {
+            textMap.set(textEntry.id, textEntry.text);
+        });
+    }
+
+    // Step 2: Map of waveid to VDomElem, skipping any without a waveid
     const elemMap = new Map<string, VDomElem>();
     backendUpdate.transferelems.forEach((transferElem) => {
         if (!transferElem.waveid) {
@@ -37,16 +45,33 @@ export function restoreVDomElems(backendUpdate: VDomBackendUpdate) {
         });
     });
 
-    // Step 2: Build VDomElem trees by linking children
+    // Step 3: Build VDomElem trees by linking children
     backendUpdate.transferelems.forEach((transferElem) => {
         const parent = elemMap.get(transferElem.waveid);
         if (!parent || !transferElem.children || transferElem.children.length === 0) {
             return;
         }
-        parent.children = transferElem.children.map((childId) => elemMap.get(childId)).filter((child) => child != null); // Explicit null check
+        parent.children = transferElem.children
+            .map((childId) => {
+                // Check if this is a text reference
+                if (childId.startsWith("t:")) {
+                    const textId = parseInt(childId.slice(2));
+                    const textContent = textMap.get(textId);
+                    if (textContent != null) {
+                        return {
+                            tag: TextTag,
+                            text: textContent,
+                        };
+                    }
+                    return null;
+                }
+                // Regular element reference
+                return elemMap.get(childId);
+            })
+            .filter((child) => child != null); // Explicit null check
     });
 
-    // Step 3: Update renderupdates with rebuilt VDomElem trees
+    // Step 4: Update renderupdates with rebuilt VDomElem trees
     backendUpdate.renderupdates.forEach((update) => {
         if (update.vdomwaveid) {
             update.vdom = elemMap.get(update.vdomwaveid);
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
index 861447a2e1..9b15b1c6e9 100644
--- a/tsunami/frontend/src/types/vdom.d.ts
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -18,6 +18,7 @@ type VDomBackendUpdate = {
     fullupdate?: boolean;
     renderupdates?: VDomRenderUpdate[];
     transferelems?: VDomTransferElem[];
+    transfertext?: VDomText[];
     refoperations?: VDomRefOperation[];
     messages?: VDomMessage[];
 };
@@ -137,6 +138,12 @@ type VDomTransferElem = {
     text?: string;
 };
 
+// rpctypes.VDomText
+type VDomText = {
+    id: number;
+    text: string;
+};
+
 // rpctypes.VDomUrlRequestResponse
 type VDomUrlRequestResponse = {
     statuscode?: number;
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index 52272046a6..ef5009ca3d 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -279,45 +279,21 @@ function VDomTag({ elem, model }: { elem: VDomElem; model: TsunamiModel }) {
     if (elem.tag == FragmentTag) {
         return childrenComps;
     }
-    
+
     // Use OptimisticInput for input and textarea elements
     if (elem.tag === "input" || elem.tag === "textarea") {
         props.key = "e-" + elem.waveid;
         const optimisticProps = {
             ...props,
-            _tagName: elem.tag as "input" | "textarea"
+            _tagName: elem.tag as "input" | "textarea",
         };
         return React.createElement(OptimisticInput, optimisticProps, childrenComps);
     }
-    
+
     props.key = "e-" + elem.waveid;
     return React.createElement(elem.tag, props, childrenComps);
 }
 
-function vdomText(text: string): VDomElem {
-    return {
-        tag: "#text",
-        text: text,
-    };
-}
-
-const testVDom: VDomElem = {
-    waveid: "testid1",
-    tag: "div",
-    children: [
-        {
-            waveid: "testh1",
-            tag: "h1",
-            children: [vdomText("Hello World")],
-        },
-        {
-            waveid: "testp",
-            tag: "p",
-            children: [vdomText("This is a paragraph (from VDOM)")],
-        },
-    ],
-};
-
 function VDomRoot({ model }: { model: TsunamiModel }) {
     let version = jotai.useAtomValue(model.globalVersion);
     let rootNode = jotai.useAtomValue(model.vdomRoot);
diff --git a/tsunami/rpctypes/protocoltypes.go b/tsunami/rpctypes/protocoltypes.go
index 056c7e32ab..bec19c7122 100644
--- a/tsunami/rpctypes/protocoltypes.go
+++ b/tsunami/rpctypes/protocoltypes.go
@@ -47,6 +47,7 @@ type VDomBackendUpdate struct {
 	FullUpdate    bool                    `json:"fullupdate,omitempty"`
 	RenderUpdates []VDomRenderUpdate      `json:"renderupdates,omitempty"`
 	TransferElems []VDomTransferElem      `json:"transferelems,omitempty"`
+	TransferText  []VDomText              `json:"transfertext,omitempty"`
 	RefOperations []vdom.VDomRefOperation `json:"refoperations,omitempty"`
 	Messages      []VDomMessage           `json:"messages,omitempty"`
 }
@@ -60,6 +61,11 @@ type VDomTransferElem struct {
 	Text     string         `json:"text,omitempty"`
 }
 
+type VDomText struct {
+	Id   int    `json:"id"`
+	Text string `json:"text"`
+}
+
 func (beUpdate *VDomBackendUpdate) CreateTransferElems() {
 	var renderedElems []RenderedElem
 	for idx, reUpdate := range beUpdate.RenderUpdates {
@@ -70,30 +76,36 @@ func (beUpdate *VDomBackendUpdate) CreateTransferElems() {
 		beUpdate.RenderUpdates[idx].VDomWaveId = reUpdate.VDom.WaveId
 		beUpdate.RenderUpdates[idx].VDom = nil
 	}
-	transferElems := ConvertElemsToTransferElems(renderedElems)
+	transferElems, transferText := ConvertElemsToTransferElems(renderedElems)
 	transferElems = DedupTransferElems(transferElems)
 	beUpdate.TransferElems = transferElems
+	beUpdate.TransferText = transferText
 }
 
-func ConvertElemsToTransferElems(elems []RenderedElem) []VDomTransferElem {
+func ConvertElemsToTransferElems(elems []RenderedElem) ([]VDomTransferElem, []VDomText) {
 	var transferElems []VDomTransferElem
-	textCounter := 0 // Counter for generating unique IDs for #text nodes
+	var transferText []VDomText
+	textMap := make(map[string]int) // map text content to ID for deduplication
 
 	// Helper function to recursively process each RenderedElem in preorder
 	var processElem func(elem RenderedElem) string
 	processElem = func(elem RenderedElem) string {
-		// Handle #text nodes by generating a unique placeholder ID
+		// Handle #text nodes with deduplication
 		if elem.Tag == "#text" {
-			textId := fmt.Sprintf("text-%d", textCounter)
-			textCounter++
-			transferElems = append(transferElems, VDomTransferElem{
-				WaveId:   textId,
-				Tag:      elem.Tag,
-				Text:     elem.Text,
-				Props:    nil,
-				Children: nil,
-			})
-			return textId
+			textId, exists := textMap[elem.Text]
+			if !exists {
+				// New text content, create new entry
+				textId = len(textMap) + 1
+				textMap[elem.Text] = textId
+				transferText = append(transferText, VDomText{
+					Id:   textId,
+					Text: elem.Text,
+				})
+			}
+
+			// Return sentinel string with ID (no VDomTransferElem created)
+			textIdStr := fmt.Sprintf("t:%d", textId)
+			return textIdStr
 		}
 
 		// Convert children to WaveId references, handling potential #text nodes
@@ -120,7 +132,7 @@ func ConvertElemsToTransferElems(elems []RenderedElem) []VDomTransferElem {
 		processElem(elem)
 	}
 
-	return transferElems
+	return transferElems, transferText
 }
 
 func DedupTransferElems(elems []VDomTransferElem) []VDomTransferElem {

From 4fc183aff1445edb668fb6539bdc97cadc34dbe0 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 09:52:14 -0700
Subject: [PATCH 089/134] updated system prompt for new app hooks (in app pkg
 and no ctx passing)

---
 tsunami/prompts/graphing.md | 34 +++++++++++++++++++++++-----------
 1 file changed, 23 insertions(+), 11 deletions(-)

diff --git a/tsunami/prompts/graphing.md b/tsunami/prompts/graphing.md
index c917d2bd24..50e947c3e2 100644
--- a/tsunami/prompts/graphing.md
+++ b/tsunami/prompts/graphing.md
@@ -26,7 +26,9 @@ vdom.H("recharts:ResponsiveContainer", map[string]any{
 ## Key Concepts
 
 ### Namespace Usage
+
 All recharts components use the `recharts:` prefix and have the same names as their React counterparts:
+
 - `recharts:ResponsiveContainer` - Container that responds to parent size changes
 - `recharts:LineChart`, `recharts:AreaChart`, `recharts:BarChart` - Chart types
 - `recharts:XAxis`, `recharts:YAxis` - Axis components
@@ -36,6 +38,7 @@ All recharts components use the `recharts:` prefix and have the same names as th
 Every Recharts component from the React library is available with the `recharts:` prefix.
 
 ### Data Structure
+
 Charts expect Go structs or slices that can be serialized to JSON. Use json tags to control field names:
 
 ```go
@@ -53,6 +56,7 @@ data := []DataPoint{
 ```
 
 ### Props and Configuration
+
 Recharts components accept the same props as the React version, passed as Go map[string]any:
 
 ```go
@@ -188,13 +192,13 @@ Charts automatically re-render when their data changes through Tsunami's reactiv
 var App = app.DefineComponent("App",
     func(ctx context.Context, _ struct{}) any {
         // State management
-        chartData, setChartData, setChartDataFn := vdom.UseData[[]MetricsData](ctx, "metrics")
-        
+        chartData, setChartData, setChartDataFn := app.UseData[[]MetricsData]("metrics")
+
         // Timer for live updates
-        vdom.UseEffect(ctx, func() func() {
+        app.UseEffect(func() func() {
             ticker := time.NewTicker(1 * time.Second)
             done := make(chan bool)
-            
+
             go func() {
                 for {
                     select {
@@ -215,13 +219,13 @@ var App = app.DefineComponent("App",
                     }
                 }
             }()
-            
+
             return func() {
                 ticker.Stop()
                 close(done)
             }
         }, []any{})
-        
+
         return renderLineChart(chartData)
     },
 )
@@ -230,6 +234,7 @@ var App = app.DefineComponent("App",
 ## Responsive Design
 
 ### Container Sizing
+
 Always use `ResponsiveContainer` for charts that should adapt to their container:
 
 ```go
@@ -247,6 +252,7 @@ vdom.H("recharts:ResponsiveContainer", map[string]any{
 ```
 
 ### Mobile-Friendly Charts
+
 Use Tailwind classes to create responsive chart layouts:
 
 ```go
@@ -265,6 +271,7 @@ vdom.H("div", map[string]any{
 ## Advanced Features
 
 ### Custom Styling
+
 You can customize chart appearance through props:
 
 ```go
@@ -280,6 +287,7 @@ vdom.H("recharts:Tooltip", map[string]any{
 ```
 
 ### Event Handling
+
 Charts support interaction events:
 
 ```go
@@ -295,24 +303,28 @@ vdom.H("recharts:LineChart", map[string]any{
 ## Best Practices
 
 ### Data Management
-- Use global atoms (`UseData`) for chart data that updates frequently
+
+- Use global atoms (app.UseData) for chart data that updates frequently
 - Implement data windowing for large datasets to maintain performance
 - Structure data with appropriate json tags for clean field names
 
 ### Performance
+
 - Limit data points for real-time charts (typically 20-100 points)
-- Use `UseEffect` cleanup functions to prevent memory leaks with timers
+- Use app.UseEffect cleanup functions to prevent memory leaks with timers
 - Consider data aggregation for historical views
 
 ### Styling
+
 - Use consistent color schemes across charts
 - Leverage Tailwind classes for chart containers and surrounding UI
 - Consider dark/light theme support in color choices
 
 ### State Updates
+
 - Use functional setters (`setDataFn`) for complex data transformations
-- Call `app.SendAsyncInitiation()` after async state updates
-- Implement proper cleanup in `UseEffect` for timers and goroutines
+- Call app.SendAsyncInitiation() after async state updates
+- Implement proper cleanup in app.UseEffect for timers and goroutines
 
 ## Differences from React Recharts
 
@@ -322,4 +334,4 @@ vdom.H("recharts:LineChart", map[string]any{
 4. **Events**: Event handlers receive Go types, not JavaScript events
 5. **Styling**: Combine Recharts styling with Tailwind classes for layout
 
-The core Recharts API remains the same - consult the official Recharts documentation for detailed prop references and advanced features. The Tsunami integration simply adapts the React patterns to Go's type system while maintaining the familiar development experience.
\ No newline at end of file
+The core Recharts API remains the same - consult the official Recharts documentation for detailed prop references and advanced features. The Tsunami integration simply adapts the React patterns to Go's type system while maintaining the familiar development experience.

From 7b94e94e8169ad37f5c0a8bd39bb099c1cb91d66 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 09:52:32 -0700
Subject: [PATCH 090/134] updated system prompt for new app hooks (app pkg, no
 ctx)

---
 tsunami/prompts/system.md | 102 +++++++++++++++++++-------------------
 1 file changed, 51 insertions(+), 51 deletions(-)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 4e3cab0646..745a0d0017 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -8,7 +8,7 @@ Tsunami mirrors React's developer experience:
 
 - **Components**: Define reusable UI pieces with typed props structs
 - **JSX-like syntax**: Use vdom.H to build element trees (like React.createElement)
-- **Hooks**: vdom.UseState, vdom.UseEffect, vdom.UseRef work exactly like React hooks
+- **Hooks**: app.UseState, app.UseEffect, app.UseRef work exactly like React hooks
 - **Props and state**: Familiar patterns for data flow and updates
 - **Conditional rendering**: vdom.If and vdom.IfElse for dynamic UIs
 - **Event handling**: onClick, onChange, onKeyDown with React-like event objects
@@ -58,7 +58,7 @@ import (
 // The App component is the required entry point for every Tsunami application
 var App = app.DefineComponent("App",
     func(ctx context.Context, _ struct{}) any {
-        vdom.UseSetAppTitle(ctx, "Hello World")
+        app.UseSetAppTitle("Hello World")
 
         return vdom.H("div", map[string]any{
             "className": "flex items-center justify-center h-screen text-xl font-bold",
@@ -228,7 +228,7 @@ Helper functions:
 
 ## Using Hooks in Tsunami
 
-Functions starting with `vdom.Use*` are hooks in Tsunami, following the exact same rules as React hooks.
+Functions starting with `app.Use*` are hooks in Tsunami, following the exact same rules as React hooks.
 
 **Key Rules:**
 
@@ -241,8 +241,8 @@ Functions starting with `vdom.Use*` are hooks in Tsunami, following the exact sa
 var MyComponent = app.DefineComponent("MyComponent",
     func(ctx context.Context, props MyProps) any {
         // ✅ Good: hooks at top level
-        count := vdom.UseState(ctx, 0)
-        vdom.UseEffect(ctx, func() { /* effect */ }, nil)
+        count := app.UseState(0)
+        app.UseEffect(func() { /* effect */ }, nil)
 
         // Now safe to have conditional logic
         if someCondition {
@@ -256,25 +256,25 @@ var MyComponent = app.DefineComponent("MyComponent",
 
 **Common Hooks (React-like):**
 
-- `UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T) T))` - Component state management (React `useState`)
-- `UseEffect(ctx context.Context, fn func() func(), deps []any)` - Side effects after render (React `useEffect`)
-- `UseRef[T any](ctx context.Context, val T) *VDomSimpleRef[T]` - Mutable refs for arbitrary values (React `useRef`)
-- `UseVDomRef(ctx context.Context) *VDomRef` - DOM element references (React `useRef` for DOM elements)
-- `UseSetAppTitle(ctx context.Context, title string)` - Sets the application title (used in every app, only works in top-level "App" component)
+- `app.UseState[T any](initialVal T) (T, func(T), func(func(T) T))` - Component state management (React `useState`)
+- `app.UseEffect(fn func() func(), deps []any)` - Side effects after render (React `useEffect`)
+- `app.UseRef[T any](val T) *VDomSimpleRef[T]` - Mutable refs for arbitrary values (React `useRef`)
+- `app.UseVDomRef() *VDomRef` - DOM element references (React `useRef` for DOM elements)
+- `app.UseSetAppTitle(title string)` - Sets the application title (used in every app, only works in top-level "App" component)
 
 **Global Data Hooks (Jotai-like atoms):**
 
-- `UseSharedAtom[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T))` - Shared state across components
-- `UseConfig[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T))` - Access to global config values
-- `UseData[T any](ctx context.Context, atomName string) (T, func(T), func(func(T) T))` - Access to global data values
+- `UseSharedAtom[T any](atomName string) (T, func(T), func(func(T) T))` - Shared state across components
+- `UseConfig[T any](atomName string) (T, func(T), func(func(T) T))` - Access to global config values
+- `UseData[T any](atomName string) (T, func(T), func(func(T) T))` - Access to global data values
 
 These allow applications to easily share data between components. When an atom is updated, all components using it will re-render.
 
 **Specialty Hooks (less common):**
 
-- `UseId(ctx context.Context) string` - Component's unique identifier
-- `UseRenderTs(ctx context.Context) int64` - Current render timestamp
-- `UseResync(ctx context.Context) bool` - Whether current render is a resync operation
+- `app.UseId() string` - Component's unique identifier
+- `app.UseRenderTs() int64` - Current render timestamp
+- `app.UseResync() bool` - Whether current render is a resync operation
 
 Most applications won't need these specialty hooks, but they're available for advanced use cases.
 
@@ -291,7 +291,7 @@ Tsunami provides three types of global atoms for sharing state across components
 ```go
 // Shared between components, not shared externally
 // Triggers re-renders when updated
-isLoading, setIsLoading, _ := vdom.UseSharedAtom[bool](ctx, "isLoading")
+isLoading, setIsLoading, _ := app.UseSharedAtom[bool]("isLoading")
 ```
 
 **UseConfig** - Configuration that external systems can read/write:
@@ -299,8 +299,8 @@ isLoading, setIsLoading, _ := vdom.UseSharedAtom[bool](ctx, "isLoading")
 ```go
 // External tools can GET/POST to /api/config to read/modify these
 // Triggers re-renders when updated (internally or externally)
-theme, setTheme, _ := vdom.UseConfig[string](ctx, "theme")
-apiKey, _, _ := vdom.UseConfig[string](ctx, "apiKey")
+theme, setTheme, _ := app.UseConfig[string]("theme")
+apiKey, _, _ := app.UseConfig[string]("apiKey")
 ```
 
 **UseData** - Application data that external systems can read:
@@ -308,15 +308,15 @@ apiKey, _, _ := vdom.UseConfig[string](ctx, "apiKey")
 ```go
 // External tools can GET /api/data to inspect app state
 // Triggers re-renders when updated
-userStats, setUserStats, _ := vdom.UseData[UserStats](ctx, "currentUser")
-apiResult, setLastPoll, setLastPollFn := vdom.UseData[APIResult](ctx, "lastPoll")
+userStats, setUserStats, _ := app.UseData[UserStats]("currentUser")
+apiResult, setLastPoll, setLastPollFn := app.UseData[APIResult]("lastPoll")
 ```
 
-All atom types work exactly like UseState - they return the current value, a setter function, and a functional setter. The key difference is their scope and external API accessibility.
+All atom types work exactly like app.UseState - they return the current value, a setter function, and a functional setter. The key difference is their scope and external API accessibility.
 
 ### External API Integration
 
-The UseConfig and UseData atoms automatically create REST endpoints:
+The app.UseConfig and app.UseData atoms automatically create REST endpoints:
 
 - `GET /api/config` - Returns all config atom values
 - `POST /api/config` - Updates (merges) config atom values
@@ -415,7 +415,7 @@ Components in Tsunami:
 - Use Go structs with json tags for props
 - Take a context and props as arguments
 - Return elements created with vdom.H
-- Can use all hooks (vdom.UseState, vdom.UseRef, etc)
+- Can use all hooks (app.UseState, app.UseRef, etc)
 - Are registered with the default client and given a name
 - Are called as functions with their props struct
 
@@ -500,11 +500,11 @@ Event handlers follow React patterns while providing additional type safety and
 ```go
 func MyComponent(ctx context.Context, props MyProps) any {
     // UseState: returns current value, setter function, and functional setter
-    count, setCount, _ := vdom.UseState(ctx, 0)     // Initial value of 0
-    items, setItems, _ := vdom.UseState(ctx, []string{}) // Initial value of empty slice
+    count, setCount, _ := app.UseState(0)     // Initial value of 0
+    items, setItems, _ := app.UseState([]string{}) // Initial value of empty slice
 
     // When you need the functional setter, use all 3 return values
-    counter, setCounter, setCounterFn := vdom.UseState(ctx, 0)
+    counter, setCounter, setCounterFn := app.UseState(0)
 
     // Event handlers that update state (called from onClick, onChange, etc.)
     incrementCount := func() {
@@ -523,14 +523,14 @@ func MyComponent(ctx context.Context, props MyProps) any {
     }
 
     // Refs for values that persist between renders but don't trigger updates
-    renderCounter := vdom.UseRef(ctx, 0)
+    renderCounter := app.UseRef(0)
     renderCounter.Current++  // Doesn't cause re-render
 
     // DOM refs for accessing elements directly
-    inputRef := vdom.UseVDomRef(ctx)
+    inputRef := app.UseVDomRef()
 
     // Side effects (can call setters here)
-    vdom.UseEffect(ctx, func() func() {
+    app.UseEffect(func() func() {
         // Example: set counter to 10 on mount
         setCounter(10)
 
@@ -574,7 +574,7 @@ func MyComponent(ctx context.Context, props MyProps) any {
 
 The system provides three main types of hooks:
 
-1. vdom.UseState - For values that trigger re-renders when changed:
+1. app.UseState - For values that trigger re-renders when changed:
 
    - Returns current value, direct setter, and functional setter
    - Direct setter triggers component re-render
@@ -582,7 +582,7 @@ The system provides three main types of hooks:
    - Create new values for slices/maps when updating
 
    ```go
-   count, setCount, setCountFn := vdom.UseState(ctx, 0)
+   count, setCount, setCountFn := app.UseState(0)
    // Direct update when you have the value:
    setCount(42)
    // Functional update when you need current value:
@@ -591,7 +591,7 @@ The system provides three main types of hooks:
    })
    ```
 
-2. vdom.UseRef - For values that persist between renders without triggering updates (like React.useRef):
+2. app.UseRef - For values that persist between renders without triggering updates (like React.useRef):
 
    - Holds mutable values that survive re-renders
    - Changes don't cause re-renders
@@ -603,12 +603,12 @@ The system provides three main types of hooks:
    - Unlike React, this ref CANNOT be set as the ref prop on an element
 
    ```go
-   timerRef := vdom.UseRef(ctx, &TimerState{
+   timerRef := app.UseRef(&TimerState{
        done: make(chan bool),
    })
    ```
 
-3. vdom.UseVDomRef - For accessing DOM elements directly:
+3. app.UseVDomRef - For accessing DOM elements directly:
    - Creates refs for DOM interaction
    - Useful for:
      - Accessing DOM element properties
@@ -617,7 +617,7 @@ The system provides three main types of hooks:
      - Direct DOM manipulation when needed
    - These ref objects SHOULD be set as ref prop on elements.
    ```go
-   inputRef := vdom.UseVDomRef(ctx)
+   inputRef := app.UseVDomRef()
    vdom.H("input", map[string]any{
        "ref": inputRef,
        "type": "text",
@@ -626,10 +626,10 @@ The system provides three main types of hooks:
 
 Best Practices:
 
-- Use vdom.UseState for all UI state - it provides both direct and functional setters
+- Use app.UseState for all UI state - it provides both direct and functional setters
 - Use functional setter when updating state from goroutines or based on current value
-- Use vdom.UseRef for complex state that goroutines need to access
-- Always clean up timers, channels, and goroutines in vdom.UseEffect cleanup functions
+- Use app.UseRef for complex state that goroutines need to access
+- Always clean up timers, channels, and goroutines in app.UseEffect cleanup functions
 
 ## State Management and Async Updates
 
@@ -658,14 +658,14 @@ type TimerState struct {
 var TodoApp = app.DefineComponent("TodoApp",
     func(ctx context.Context, _ struct{}) any {
         // Use atoms for global state (prefixes must match init functions)
-        todos, setTodos, _ := vdom.UseData[[]Todo](ctx, "todos")
-        filter, setFilter, _ := vdom.UseConfig[string](ctx, "filter")
+        todos, setTodos, _ := app.UseData[[]Todo]("todos")
+        filter, setFilter, _ := app.UseConfig[string]("filter")
 
         // Local state for async timer demo
-        seconds, _, setSecondsFn := vdom.UseState[int](ctx, 0)
+        seconds, _, setSecondsFn := app.UseState[int](0)
 
         // Use refs to store complex state that goroutines need to access
-        stateRef := vdom.UseRef(ctx, &TimerState{
+        stateRef := app.UseRef(&TimerState{
             done: make(chan bool),
         })
 
@@ -706,8 +706,8 @@ var TodoApp = app.DefineComponent("TodoApp",
             }
         }
 
-        // Use vdom.UseEffect for cleanup on unmount
-        vdom.UseEffect(ctx, func() func() {
+        // Use app.UseEffect for cleanup on unmount
+        app.UseEffect(func() func() {
             startAsync() // Start the timer when component mounts
             return func() {
                 stopAsync()
@@ -756,7 +756,7 @@ Key points for state management:
 - Global state is fine for simple data structures
 - Use functional setter when updating state based on its current value, especially in goroutines
 - Store complex state in refs when it needs to be accessed by goroutines
-- Use vdom.UseEffect cleanup function to handle component unmount
+- Use app.UseEffect cleanup function to handle component unmount
 - Call app.SendAsyncInitiation after state changes in goroutines (consider round trip performance, so don't call at very high speeds)
 - Use atomic operations if globals are modified from multiple goroutines (or locks)
 
@@ -898,12 +898,12 @@ var App = app.DefineComponent("App",
     func(ctx context.Context, _ any) any {
         // UseState returns 3 values: value, setter, functional setter
         // Use ", _" to ignore the functional setter when not needed
-        todos, setTodos, _ := vdom.UseState(ctx, []Todo{
+        todos, setTodos, _ := app.UseState([]Todo{
             {Id: 1, Text: "Learn Tsunami", Completed: false},
             {Id: 2, Text: "Build an app", Completed: false},
         })
-        nextId, setNextId, _ := vdom.UseState(ctx, 3)
-        inputText, setInputText, _ := vdom.UseState(ctx, "")
+        nextId, setNextId, _ := app.UseState(3)
+        inputText, setInputText, _ := app.UseState("")
 
         // Event handlers
         addTodo := func() {
@@ -984,7 +984,7 @@ var App = app.DefineComponent("App",
 Key points:
 
 1. Root component must be named "App"
-2. Use vdom.UseSetAppTitle in the main App component to set the window title
+2. Use app.UseSetAppTitle in the main App component to set the window title
 3. Do NOT write a main() function - the framework handles app lifecycle
 4. Use init() for setup like registering dynamic handlers with app.HandleDynFunc
 
@@ -996,7 +996,7 @@ Key points:
 - Call app.SendAsyncInitiation after async state updates
 - Provide keys when using vdom.ForEach with lists (using WithKey method)
 - Use vdom.Classes with vdom.If for combining static and conditional class names
-- Consider cleanup functions in vdom.UseEffect for async operations
+- Consider cleanup functions in app.UseEffect for async operations
 - `<script>` tags are NOT supported
 - Applications consist of a single file: app.go containing all Go code and component definitions
 - Styling is handled through Tailwind v4 CSS classes

From 78c33919c17fbae64796480124ddb92e5b976d4a Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 10:14:45 -0700
Subject: [PATCH 091/134] remove ctx from component renderfns...

---
 tsunami/app/defaultclient.go     |  3 +--
 tsunami/app/root_test.go         | 32 ++++++----------------------
 tsunami/demo/cpuchart/app.go     |  5 ++---
 tsunami/demo/githubaction/app.go |  5 ++---
 tsunami/demo/pomodoro/app.go     |  7 +++----
 tsunami/demo/todo/app.go         |  9 ++++----
 tsunami/engine/clientimpl.go     |  2 +-
 tsunami/engine/render.go         | 36 +++++++++++++++++---------------
 tsunami/engine/rootelem.go       | 35 +++++++++++--------------------
 tsunami/prompts/graphing.md      |  2 +-
 tsunami/prompts/system.md        |  9 ++++----
 11 files changed, 55 insertions(+), 90 deletions(-)

diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 2fcb26fb89..dde0d6f264 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -4,7 +4,6 @@
 package app
 
 import (
-	"context"
 	"encoding/json"
 	"io/fs"
 	"net/http"
@@ -13,7 +12,7 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-func DefineComponent[P any](name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
+func DefineComponent[P any](name string, renderFn func(props P) any) vdom.Component[P] {
 	return engine.DefineComponentEx(engine.GetDefaultClient(), name, renderFn)
 }
 
diff --git a/tsunami/app/root_test.go b/tsunami/app/root_test.go
index 494a7f6eac..eba0a51689 100644
--- a/tsunami/app/root_test.go
+++ b/tsunami/app/root_test.go
@@ -4,7 +4,6 @@
 package app
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"log"
@@ -14,15 +13,7 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-type renderContextKeyType struct{}
-
-var renderContextKey = renderContextKeyType{}
-
-type TestContext struct {
-	ButtonId string
-}
-
-func Page(ctx context.Context, props map[string]any) any {
+func Page(props map[string]any) any {
 	clicked, setClicked, _ := UseState(false)
 	var clickedDiv *vdom.VDomElem
 	if clicked {
@@ -39,7 +30,7 @@ func Page(ctx context.Context, props map[string]any) any {
 	)
 }
 
-func Button(ctx context.Context, props map[string]any) any {
+func Button(props map[string]any) any {
 	ref := UseVDomRef()
 	clName, setClName, _ := UseState("button")
 	UseEffect(func() func() {
@@ -48,10 +39,8 @@ func Button(ctx context.Context, props map[string]any) any {
 		return nil
 	}, nil)
 	compId := UseId()
-	testContext := getTestContext(ctx)
-	if testContext != nil {
-		testContext.ButtonId = compId
-	}
+	// Store the button ID in a global variable for testing
+	buttonId = compId
 	return vdom.H("div", map[string]any{
 		"className": clName,
 		"ref":       ref,
@@ -65,20 +54,11 @@ func printVDom(root *engine.RootElem) {
 	fmt.Printf("%s\n", string(jsonBytes))
 }
 
-func getTestContext(ctx context.Context) *TestContext {
-	val := ctx.Value(renderContextKey)
-	if val == nil {
-		return nil
-	}
-	return val.(*TestContext)
-}
+var buttonId string
 
 func Test1(t *testing.T) {
 	log.Printf("hello!\n")
-	testContext := &TestContext{ButtonId: ""}
-	ctx := context.WithValue(context.Background(), renderContextKey, testContext)
 	root := engine.MakeRoot()
-	root.SetOuterCtx(ctx)
 	root.RegisterComponent("Page", Page)
 	root.RegisterComponent("Button", Button)
 	root.Render(vdom.H("Page", nil), &engine.RenderOpts{Resync: false})
@@ -88,7 +68,7 @@ func Test1(t *testing.T) {
 	printVDom(root)
 	root.RunWork(&engine.RenderOpts{Resync: false})
 	printVDom(root)
-	root.Event(testContext.ButtonId, "onClick", vdom.VDomEvent{EventType: "onClick"})
+	root.Event(buttonId, "onClick", vdom.VDomEvent{EventType: "onClick"})
 	root.RunWork(&engine.RenderOpts{Resync: false})
 	printVDom(root)
 }
diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
index 23ba0f3abc..b0fb552ccf 100644
--- a/tsunami/demo/cpuchart/app.go
+++ b/tsunami/demo/cpuchart/app.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"log"
 	"time"
 
@@ -64,7 +63,7 @@ func generateCPUDataPoint() CPUDataPoint {
 }
 
 var StatsPanel = app.DefineComponent("StatsPanel",
-	func(ctx context.Context, props struct {
+	func(props struct {
 		Data []CPUDataPoint `json:"data"`
 	}) any {
 		var currentUsage float64
@@ -142,7 +141,7 @@ var StatsPanel = app.DefineComponent("StatsPanel",
 )
 
 var App = app.DefineComponent("App",
-	func(ctx context.Context, _ struct{}) any {
+	func(_ struct{}) any {
 		app.UseSetAppTitle("CPU Usage Monitor")
 
 		// Local state for forcing re-renders
diff --git a/tsunami/demo/githubaction/app.go b/tsunami/demo/githubaction/app.go
index bc08d8b75f..4d8e65d105 100644
--- a/tsunami/demo/githubaction/app.go
+++ b/tsunami/demo/githubaction/app.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -173,7 +172,7 @@ type WorkflowRunItemProps struct {
 }
 
 var WorkflowRunItem = app.DefineComponent("WorkflowRunItem",
-	func(ctx context.Context, props WorkflowRunItemProps) any {
+	func(props WorkflowRunItemProps) any {
 		run := props.Run
 		isRunning := run.Status == "in_progress" || run.Status == "queued" || run.Status == "pending"
 
@@ -221,7 +220,7 @@ var WorkflowRunItem = app.DefineComponent("WorkflowRunItem",
 )
 
 var App = app.DefineComponent("App",
-	func(ctx context.Context, _ struct{}) any {
+	func(_ struct{}) any {
 		app.UseSetAppTitle("GitHub Actions Monitor")
 		_, _, setTickerFn := app.UseState(0)
 
diff --git a/tsunami/demo/pomodoro/app.go b/tsunami/demo/pomodoro/app.go
index d755d2978a..2f0bfbf2ba 100644
--- a/tsunami/demo/pomodoro/app.go
+++ b/tsunami/demo/pomodoro/app.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"fmt"
 	"time"
 
@@ -42,7 +41,7 @@ type TimerState struct {
 }
 
 var TimerDisplay = app.DefineComponent("TimerDisplay",
-	func(ctx context.Context, props TimerDisplayProps) any {
+	func(props TimerDisplayProps) any {
 		return vdom.H("div",
 			map[string]any{"className": "bg-slate-700 p-8 rounded-lg mb-8 text-center"},
 			vdom.H("div",
@@ -58,7 +57,7 @@ var TimerDisplay = app.DefineComponent("TimerDisplay",
 )
 
 var ControlButtons = app.DefineComponent("ControlButtons",
-	func(ctx context.Context, props ControlButtonsProps) any {
+	func(props ControlButtonsProps) any {
 		return vdom.H("div",
 			map[string]any{"className": "flex flex-col gap-4"},
 			vdom.IfElse(props.IsRunning,
@@ -106,7 +105,7 @@ var ControlButtons = app.DefineComponent("ControlButtons",
 )
 
 var App = app.DefineComponent("App",
-	func(ctx context.Context, _ any) any {
+	func(_ any) any {
 		app.UseSetAppTitle("Pomodoro Timer (Tsunami Demo)")
 
 		isRunning, setIsRunning, _ := app.UseState(false)
diff --git a/tsunami/demo/todo/app.go b/tsunami/demo/todo/app.go
index 9bcfe94fd4..20a740e382 100644
--- a/tsunami/demo/todo/app.go
+++ b/tsunami/demo/todo/app.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	_ "embed"
 	"strconv"
 
@@ -37,7 +36,7 @@ type InputFieldProps struct {
 
 // Reusable input component showing keyboard event handling
 var InputField = app.DefineComponent("InputField",
-	func(ctx context.Context, props InputFieldProps) any {
+	func(props InputFieldProps) any {
 		// Example of special key handling with VDomFunc
 		keyDown := &vdom.VDomFunc{
 			Type:            vdom.ObjectType_Func,
@@ -62,7 +61,7 @@ var InputField = app.DefineComponent("InputField",
 
 // Item component showing conditional classes and event handling
 var TodoItem = app.DefineComponent("TodoItem",
-	func(ctx context.Context, props TodoItemProps) any {
+	func(props TodoItemProps) any {
 		return vdom.H("div", map[string]any{
 			"className": vdom.Classes("flex items-center gap-2.5 p-2 border border-border rounded", vdom.If(props.Todo.Completed, "opacity-70")),
 		},
@@ -85,7 +84,7 @@ var TodoItem = app.DefineComponent("TodoItem",
 
 // List component demonstrating mapping over data, using WithKey to set key on a component
 var TodoList = app.DefineComponent("TodoList",
-	func(ctx context.Context, props TodoListProps) any {
+	func(props TodoListProps) any {
 		return vdom.H("div", map[string]any{
 			"className": "flex flex-col gap-2",
 		}, vdom.ForEach(props.Todos, func(todo Todo, _ int) any {
@@ -100,7 +99,7 @@ var TodoList = app.DefineComponent("TodoList",
 
 // Root component showing state management and composition
 var App = app.DefineComponent("App",
-	func(ctx context.Context, _ any) any {
+	func(_ any) any {
 		app.UseSetAppTitle("Todo App (Tsunami Demo)")
 
 		// Multiple state hooks example
diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index f7a9add5e4..04c9454df1 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -234,7 +234,7 @@ func structToProps(props any) map[string]any {
 	return m
 }
 
-func DefineComponentEx[P any](client *ClientImpl, name string, renderFn func(ctx context.Context, props P) any) vdom.Component[P] {
+func DefineComponentEx[P any](client *ClientImpl, name string, renderFn func(props P) any) vdom.Component[P] {
 	if name == "" {
 		panic("Component name cannot be empty")
 	}
diff --git a/tsunami/engine/render.go b/tsunami/engine/render.go
index 4ccc253646..50d558a258 100644
--- a/tsunami/engine/render.go
+++ b/tsunami/engine/render.go
@@ -4,7 +4,6 @@
 package engine
 
 import (
-	"context"
 	"fmt"
 	"reflect"
 	"unicode"
@@ -100,11 +99,7 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 	props[ChildrenPropKey] = elem.Children
 	vc := makeContextVal(r, *comp, opts)
 	rtnElemArr := withGlobalCtx(vc, func() []vdom.VDomElem {
-		ctx := r.OuterCtx
-		if ctx == nil {
-			ctx = context.Background()
-		}
-		renderedElem := callCFunc(cfunc, ctx, props)
+		renderedElem := callCFunc(cfunc, props)
 		return vdom.ToElems(renderedElem)
 	})
 	var rtnElem *vdom.VDomElem
@@ -180,25 +175,32 @@ func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*Componen
 }
 
 // uses reflection to call the component function
-func callCFunc(cfunc any, ctx context.Context, props map[string]any) any {
+func callCFunc(cfunc any, props map[string]any) any {
 	rval := reflect.ValueOf(cfunc)
-	arg2Type := rval.Type().In(1)
+	rtype := rval.Type()
+
+	if rtype.NumIn() != 1 {
+		fmt.Printf("component function must have exactly 1 parameter, got %d\n", rtype.NumIn())
+		return nil
+	}
+
+	argType := rtype.In(0)
 
-	var arg2Val reflect.Value
-	if arg2Type.Kind() == reflect.Interface && arg2Type.NumMethod() == 0 {
-		arg2Val = reflect.New(arg2Type)
+	var arg1Val reflect.Value
+	if argType.Kind() == reflect.Interface && argType.NumMethod() == 0 {
+		arg1Val = reflect.New(argType)
 	} else {
-		arg2Val = reflect.New(arg2Type)
-		if arg2Type.Kind() == reflect.Map {
-			arg2Val.Elem().Set(reflect.ValueOf(props))
+		arg1Val = reflect.New(argType)
+		if argType.Kind() == reflect.Map {
+			arg1Val.Elem().Set(reflect.ValueOf(props))
 		} else {
-			err := util.MapToStruct(props, arg2Val.Interface())
+			err := util.MapToStruct(props, arg1Val.Interface())
 			if err != nil {
-				fmt.Printf("error unmarshalling props: %v\n", err)
+				fmt.Printf("error converting props: %v\n", err)
 			}
 		}
 	}
-	rtnVal := rval.Call([]reflect.Value{reflect.ValueOf(ctx), arg2Val.Elem()})
+	rtnVal := rval.Call([]reflect.Value{arg1Val.Elem()})
 	if len(rtnVal) == 0 {
 		return nil
 	}
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 271f9c95ee..2c5e1fb9de 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -4,7 +4,6 @@
 package engine
 
 import (
-	"context"
 	"fmt"
 	"log"
 	"reflect"
@@ -18,7 +17,6 @@ import (
 
 const ChildrenPropKey = "children"
 
-
 type EffectWorkElem struct {
 	Id          string
 	EffectIndex int
@@ -32,7 +30,6 @@ type genAtom interface {
 }
 
 type RootElem struct {
-	OuterCtx        context.Context
 	Root            *ComponentImpl
 	RenderTs        int64
 	AppTitle        string
@@ -167,10 +164,6 @@ func (r *RootElem) RemoveAtom(name string) {
 	delete(r.Atoms, name)
 }
 
-func (r *RootElem) SetOuterCtx(ctx context.Context) {
-	r.OuterCtx = ctx
-}
-
 func validateCFunc(cfunc any) error {
 	if cfunc == nil {
 		return fmt.Errorf("Component function cannot b nil")
@@ -180,29 +173,25 @@ func validateCFunc(cfunc any) error {
 		return fmt.Errorf("Component function must be a function")
 	}
 	rtype := rval.Type()
-	if rtype.NumIn() != 2 {
-		return fmt.Errorf("Component function must take exactly 2 arguments")
+	if rtype.NumIn() != 1 {
+		return fmt.Errorf("Component function must take exactly 1 argument")
 	}
 	if rtype.NumOut() != 1 {
 		return fmt.Errorf("Component function must return exactly 1 value")
 	}
-	// first arg must be context.Context
-	if rtype.In(0) != reflect.TypeOf((*context.Context)(nil)).Elem() {
-		return fmt.Errorf("Component function first argument must be context.Context")
-	}
-	// second can a map[string]any, or a struct, or ptr to struct (we'll reflect the value into it)
-	arg2Type := rtype.In(1)
-	if arg2Type.Kind() == reflect.Ptr {
-		arg2Type = arg2Type.Elem()
+	// first argument can be a map[string]any, or a struct, or ptr to struct (we'll reflect the value into it)
+	arg1Type := rtype.In(0)
+	if arg1Type.Kind() == reflect.Ptr {
+		arg1Type = arg1Type.Elem()
 	}
-	if arg2Type.Kind() == reflect.Map {
-		if arg2Type.Key().Kind() != reflect.String ||
-			!(arg2Type.Elem().Kind() == reflect.Interface && arg2Type.Elem().NumMethod() == 0) {
+	if arg1Type.Kind() == reflect.Map {
+		if arg1Type.Key().Kind() != reflect.String ||
+			!(arg1Type.Elem().Kind() == reflect.Interface && arg1Type.Elem().NumMethod() == 0) {
 			return fmt.Errorf("Map argument must be map[string]any")
 		}
-	} else if arg2Type.Kind() != reflect.Struct &&
-		!(arg2Type.Kind() == reflect.Interface && arg2Type.NumMethod() == 0) {
-		return fmt.Errorf("Component function second argument must be map[string]any, struct, or any")
+	} else if arg1Type.Kind() != reflect.Struct &&
+		!(arg1Type.Kind() == reflect.Interface && arg1Type.NumMethod() == 0) {
+		return fmt.Errorf("Component function argument must be map[string]any, struct, or any")
 	}
 	return nil
 }
diff --git a/tsunami/prompts/graphing.md b/tsunami/prompts/graphing.md
index 50e947c3e2..cf3894d28c 100644
--- a/tsunami/prompts/graphing.md
+++ b/tsunami/prompts/graphing.md
@@ -190,7 +190,7 @@ Charts automatically re-render when their data changes through Tsunami's reactiv
 
 ```go
 var App = app.DefineComponent("App",
-    func(ctx context.Context, _ struct{}) any {
+    func(_ struct{}) any {
         // State management
         chartData, setChartData, setChartDataFn := app.UseData[[]MetricsData]("metrics")
 
diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 745a0d0017..9979f83eac 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -50,14 +50,13 @@ A Tsunami application is simply a Go package with an `App` component. Here's a m
 package main
 
 import (
-    "context"
     "github.com/wavetermdev/waveterm/tsunami/app"
     "github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
 // The App component is the required entry point for every Tsunami application
 var App = app.DefineComponent("App",
-    func(ctx context.Context, _ struct{}) any {
+    func(_ struct{}) any {
         app.UseSetAppTitle("Hello World")
 
         return vdom.H("div", map[string]any{
@@ -239,7 +238,7 @@ Functions starting with `app.Use*` are hooks in Tsunami, following the exact sam
 
 ```go
 var MyComponent = app.DefineComponent("MyComponent",
-    func(ctx context.Context, props MyProps) any {
+    func(props MyProps) any {
         // ✅ Good: hooks at top level
         count := app.UseState(0)
         app.UseEffect(func() { /* effect */ }, nil)
@@ -381,7 +380,7 @@ type TodoItemProps struct {
 
 // Create component with typed props
 var TodoItem = app.DefineComponent("TodoItem",
-    func(ctx context.Context, props TodoItemProps) any {
+    func(props TodoItemProps) any {
         return vdom.H("div", map[string]any{
             "className": vdom.Classes(
                 "p-3 border-b border-gray-200 cursor-pointer transition-opacity",
@@ -413,7 +412,7 @@ TodoItem(TodoItemProps{
 Components in Tsunami:
 
 - Use Go structs with json tags for props
-- Take a context and props as arguments
+- Take props as their single argument
 - Return elements created with vdom.H
 - Can use all hooks (app.UseState, app.UseRef, etc)
 - Are registered with the default client and given a name

From cdf66ccb5fd78e885ccee32626db02a4c0c687a3 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 10:20:03 -0700
Subject: [PATCH 092/134] update todo app to use new UseLocal

---
 tsunami/demo/todo/app.go        | 64 ++++++++++++++++++---------------
 tsunami/demo/todo/static/tw.css | 48 -------------------------
 2 files changed, 35 insertions(+), 77 deletions(-)

diff --git a/tsunami/demo/todo/app.go b/tsunami/demo/todo/app.go
index 20a740e382..791a931517 100644
--- a/tsunami/demo/todo/app.go
+++ b/tsunami/demo/todo/app.go
@@ -102,49 +102,55 @@ var App = app.DefineComponent("App",
 	func(_ any) any {
 		app.UseSetAppTitle("Todo App (Tsunami Demo)")
 
-		// Multiple state hooks example
-		todos, setTodos, _ := app.UseState([]Todo{
+		// Multiple local atoms example
+		todosAtom := app.UseLocal([]Todo{
 			{Id: 1, Text: "Learn VDOM", Completed: false},
 			{Id: 2, Text: "Build a todo app", Completed: false},
 		})
-		nextId, setNextId, _ := app.UseState(3)
-		inputText, setInputText, _ := app.UseState("")
+		nextIdAtom := app.UseLocal(3)
+		inputTextAtom := app.UseLocal("")
 
 		// Event handlers modifying multiple pieces of state
 		addTodo := func() {
-			if inputText == "" {
+			if inputTextAtom.Get() == "" {
 				return
 			}
-			setTodos(append(todos, Todo{
-				Id:        nextId,
-				Text:      inputText,
-				Completed: false,
-			}))
-			setNextId(nextId + 1)
-			setInputText("")
+			todosAtom.SetFn(func(todos []Todo) []Todo {
+				newTodos := app.DeepCopy(todos)
+				return append(newTodos, Todo{
+					Id:        nextIdAtom.Get(),
+					Text:      inputTextAtom.Get(),
+					Completed: false,
+				})
+			})
+			nextIdAtom.Set(nextIdAtom.Get() + 1)
+			inputTextAtom.Set("")
 		}
 
 		// Immutable state update pattern
 		toggleTodo := func(id int) {
-			newTodos := make([]Todo, len(todos))
-			copy(newTodos, todos)
-			for i := range newTodos {
-				if newTodos[i].Id == id {
-					newTodos[i].Completed = !newTodos[i].Completed
-					break
+			todosAtom.SetFn(func(todos []Todo) []Todo {
+				newTodos := app.DeepCopy(todos)
+				for i := range newTodos {
+					if newTodos[i].Id == id {
+						newTodos[i].Completed = !newTodos[i].Completed
+						break
+					}
 				}
-			}
-			setTodos(newTodos)
+				return newTodos
+			})
 		}
 
 		deleteTodo := func(id int) {
-			newTodos := make([]Todo, 0, len(todos)-1)
-			for _, todo := range todos {
-				if todo.Id != id {
-					newTodos = append(newTodos, todo)
+			todosAtom.SetFn(func(todos []Todo) []Todo {
+				newTodos := make([]Todo, 0, len(todos)-1)
+				for _, todo := range todos {
+					if todo.Id != id {
+						newTodos = append(newTodos, todo)
+					}
 				}
-			}
-			setTodos(newTodos)
+				return newTodos
+			})
 		}
 
 		return vdom.H("div", map[string]any{
@@ -160,8 +166,8 @@ var App = app.DefineComponent("App",
 				"className": "flex gap-2.5 mb-5",
 			},
 				InputField(InputFieldProps{
-					Value:    inputText,
-					OnChange: setInputText,
+					Value:    inputTextAtom.Get(),
+					OnChange: inputTextAtom.Set,
 					OnEnter:  addTodo,
 				}),
 				vdom.H("button", map[string]any{
@@ -171,7 +177,7 @@ var App = app.DefineComponent("App",
 			),
 
 			TodoList(TodoListProps{
-				Todos:    todos,
+				Todos:    todosAtom.Get(),
 				OnToggle: toggleTodo,
 				OnDelete: deleteTodo,
 			}),
diff --git a/tsunami/demo/todo/static/tw.css b/tsunami/demo/todo/static/tw.css
index 434fee658b..58f65736ad 100644
--- a/tsunami/demo/todo/static/tw.css
+++ b/tsunami/demo/todo/static/tw.css
@@ -234,33 +234,12 @@
   .sticky {
     position: sticky;
   }
-  .-inset-1 {
-    inset: calc(var(--spacing) * -1);
-  }
   .isolate {
     isolation: isolate;
   }
   .isolation-auto {
     isolation: auto;
   }
-  .\!container {
-    width: 100% !important;
-    @media (width >= 40rem) {
-      max-width: 40rem !important;
-    }
-    @media (width >= 48rem) {
-      max-width: 48rem !important;
-    }
-    @media (width >= 64rem) {
-      max-width: 64rem !important;
-    }
-    @media (width >= 80rem) {
-      max-width: 80rem !important;
-    }
-    @media (width >= 96rem) {
-      max-width: 96rem !important;
-    }
-  }
   .container {
     width: 100%;
     @media (width >= 40rem) {
@@ -788,18 +767,10 @@
     --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .ring {
-    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
-    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
-  }
   .inset-ring {
     --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .outline {
-    outline-style: var(--tw-outline-style);
-    outline-width: 1px;
-  }
   .blur {
     --tw-blur: blur(8px);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
@@ -809,18 +780,10 @@
     --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .grayscale {
-    --tw-grayscale: grayscale(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .invert {
     --tw-invert: invert(100%);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .sepia {
-    --tw-sepia: sepia(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .filter {
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
@@ -848,11 +811,6 @@
     -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
     backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
   }
-  .transition {
-    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
-    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
-    transition-duration: var(--tw-duration, var(--default-transition-duration));
-  }
   .ease-in {
     --tw-ease: var(--ease-in);
     transition-timing-function: var(--ease-in);
@@ -1046,11 +1004,6 @@
   inherits: false;
   initial-value: 0 0 #0000;
 }
-@property --tw-outline-style {
-  syntax: "*";
-  inherits: false;
-  initial-value: solid;
-}
 @property --tw-blur {
   syntax: "*";
   inherits: false;
@@ -1184,7 +1137,6 @@
       --tw-ring-offset-width: 0px;
       --tw-ring-offset-color: #fff;
       --tw-ring-offset-shadow: 0 0 #0000;
-      --tw-outline-style: solid;
       --tw-blur: initial;
       --tw-brightness: initial;
       --tw-contrast: initial;

From 9ef011067c39f9777b50cf57f053091ce2463dba Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 10:52:33 -0700
Subject: [PATCH 093/134] big updates to system prompt to deal with UseLocal
 instead of UseState.  also new global atom definition pattern.

---
 tsunami/prompts/system.md | 362 ++++++++++++++++++++++----------------
 1 file changed, 212 insertions(+), 150 deletions(-)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 9979f83eac..4c166f52ce 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -8,7 +8,9 @@ Tsunami mirrors React's developer experience:
 
 - **Components**: Define reusable UI pieces with typed props structs
 - **JSX-like syntax**: Use vdom.H to build element trees (like React.createElement)
-- **Hooks**: app.UseState, app.UseEffect, app.UseRef work exactly like React hooks
+- **Hooks**: app.UseEffect, app.UseRef work exactly like React hooks
+- **Local state**: Use app.UseLocal as a replacement for React.useState
+- **Global state**: Use app.ConfigAtom, app.DataAtom, app.SharedAtom for cross-component state
 - **Props and state**: Familiar patterns for data flow and updates
 - **Conditional rendering**: vdom.If and vdom.IfElse for dynamic UIs
 - **Event handling**: onClick, onChange, onKeyDown with React-like event objects
@@ -240,7 +242,7 @@ Functions starting with `app.Use*` are hooks in Tsunami, following the exact sam
 var MyComponent = app.DefineComponent("MyComponent",
     func(props MyProps) any {
         // ✅ Good: hooks at top level
-        count := app.UseState(0)
+        count := app.UseLocal(0)
         app.UseEffect(func() { /* effect */ }, nil)
 
         // Now safe to have conditional logic
@@ -255,20 +257,12 @@ var MyComponent = app.DefineComponent("MyComponent",
 
 **Common Hooks (React-like):**
 
-- `app.UseState[T any](initialVal T) (T, func(T), func(func(T) T))` - Component state management (React `useState`)
-- `app.UseEffect(fn func() func(), deps []any)` - Side effects after render (React `useEffect`)
-- `app.UseRef[T any](val T) *VDomSimpleRef[T]` - Mutable refs for arbitrary values (React `useRef`)
-- `app.UseVDomRef() *VDomRef` - DOM element references (React `useRef` for DOM elements)
+- `app.UseLocal[T any](initialVal T) Atom[T]` - Component state management (replacement for React.useState)
+- `app.UseEffect(fn func() func(), deps []any)` - Side effects after render (React.useEffect)
+- `app.UseRef[T any](val T) *VDomSimpleRef[T]` - Mutable refs for arbitrary values (React.useRef)
+- `app.UseVDomRef() *VDomRef` - DOM element references (React.useRef for DOM elements)
 - `app.UseSetAppTitle(title string)` - Sets the application title (used in every app, only works in top-level "App" component)
 
-**Global Data Hooks (Jotai-like atoms):**
-
-- `UseSharedAtom[T any](atomName string) (T, func(T), func(func(T) T))` - Shared state across components
-- `UseConfig[T any](atomName string) (T, func(T), func(func(T) T))` - Access to global config values
-- `UseData[T any](atomName string) (T, func(T), func(func(T) T))` - Access to global data values
-
-These allow applications to easily share data between components. When an atom is updated, all components using it will re-render.
-
 **Specialty Hooks (less common):**
 
 - `app.UseId() string` - Component's unique identifier
@@ -281,41 +275,83 @@ This ensures hooks are called in the same order every render, which is essential
 
 ## Global State Management
 
-Tsunami provides three types of global atoms for sharing state across components and with external systems:
+Tsunami provides three types of global atoms for sharing state across components and with external systems. These atoms are declared as global variables using type-safe constructor functions.
 
-### Atom Types
+### Declaring Global Atoms
 
-**UseSharedAtom** - Basic shared state between components:
+Global atoms are declared using constructor functions that take a name and default value:
 
 ```go
-// Shared between components, not shared externally
-// Triggers re-renders when updated
-isLoading, setIsLoading, _ := app.UseSharedAtom[bool]("isLoading")
+// Declare global atoms as package-level variables
+var (
+    // SharedAtom - Basic shared state between components
+    isLoading = app.SharedAtom("isLoading", false)
+    userPrefs = app.SharedAtom("userPrefs", UserPreferences{})
+
+    // ConfigAtom - Configuration that external systems can read/write
+    theme = app.ConfigAtom("theme", "dark")
+    apiKey = app.ConfigAtom("apiKey", "")
+    maxRetries = app.ConfigAtom("maxRetries", 3)
+
+    // DataAtom - Application data that external systems can read
+    currentUser = app.DataAtom("currentUser", UserStats{})
+    lastPollResult = app.DataAtom("lastPoll", APIResult{})
+)
 ```
 
-**UseConfig** - Configuration that external systems can read/write:
+### Using Atoms in Components
+
+Atoms provide simple Get/Set methods that automatically handle render dependencies:
 
 ```go
-// External tools can GET/POST to /api/config to read/modify these
-// Triggers re-renders when updated (internally or externally)
-theme, setTheme, _ := app.UseConfig[string]("theme")
-apiKey, _, _ := app.UseConfig[string]("apiKey")
+// Reading atom values (registers render dependency)
+loading := isLoading.Get()
+currentTheme := theme.Get()
+user := currentUser.Get()
+
+// Setting atom values (only in event handlers, effects, or async code)
+handleToggle := func() {
+    isLoading.Set(true) // Direct value setting
+}
+
+handleRetry := func() {
+    maxRetries.SetFn(func(current int) int {
+        return current + 1  // Functional update
+    })
+}
 ```
 
-**UseData** - Application data that external systems can read:
+### Important Rules
 
-```go
-// External tools can GET /api/data to inspect app state
-// Triggers re-renders when updated
-userStats, setUserStats, _ := app.UseData[UserStats]("currentUser")
-apiResult, setLastPoll, setLastPollFn := app.UseData[APIResult]("lastPoll")
-```
+- **Declaration**: Atoms must be declared as global variables using the constructor functions
+- **Reading**: Call `.Get()` to read values - this automatically registers render dependencies
+- **Writing**: Call `.Set(value)` or `.SetFn(func(T) T)` to update values
+- **Render Safety**: NEVER call Set or SetFn in render code - only in event handlers, effects, or async code
+- **Type Safety**: Atoms are type-safe with `Atom[T]` - the type is established at declaration time
+
+### Atom Types
+
+**SharedAtom** - Basic shared state between components:
+
+- Shared between components within the application
+- Not accessible to external systems
+- Triggers re-renders when updated
+
+**ConfigAtom** - Configuration that external systems can read/write:
 
-All atom types work exactly like app.UseState - they return the current value, a setter function, and a functional setter. The key difference is their scope and external API accessibility.
+- External tools can GET/POST to `/api/config` to read/modify these
+- Triggers re-renders when updated (internally or externally)
+- Perfect for user settings, API keys, feature flags
+
+**DataAtom** - Application data that external systems can read:
+
+- External tools can GET `/api/data` to inspect app state
+- Triggers re-renders when updated
+- Ideal for application state, user data, API results
 
 ### External API Integration
 
-The app.UseConfig and app.UseData atoms automatically create REST endpoints:
+ConfigAtom and DataAtom automatically create REST endpoints:
 
 - `GET /api/config` - Returns all config atom values
 - `POST /api/config` - Updates (merges) config atom values
@@ -414,7 +450,7 @@ Components in Tsunami:
 - Use Go structs with json tags for props
 - Take props as their single argument
 - Return elements created with vdom.H
-- Can use all hooks (app.UseState, app.UseRef, etc)
+- Can use all hooks (app.UseLocal, app.UseRef, etc)
 - Are registered with the default client and given a name
 - Are called as functions with their props struct
 
@@ -497,97 +533,113 @@ Event handlers follow React patterns while providing additional type safety and
 ## State Management with Hooks
 
 ```go
-func MyComponent(ctx context.Context, props MyProps) any {
-    // UseState: returns current value, setter function, and functional setter
-    count, setCount, _ := app.UseState(0)     // Initial value of 0
-    items, setItems, _ := app.UseState([]string{}) // Initial value of empty slice
-
-    // When you need the functional setter, use all 3 return values
-    counter, setCounter, setCounterFn := app.UseState(0)
-
-    // Event handlers that update state (called from onClick, onChange, etc.)
-    incrementCount := func() {
-        setCount(count + 1)  // Direct update when you have the value
-    }
-
-    incrementCounterFn := func() {
-        setCounterFn(func(current int) int {
-            return current + 1  // Functional update based on current value
-        })
-    }
-
-    addItem := func(item string) {
-        // When updating slices/maps, create new value
-        setItems(append([]string{}, items..., item))
-    }
+var MyComponent = app.DefineComponent("MyComponent",
+    func(props MyProps) any {
+        // UseLocal: returns Atom[T] with Get(), Set(), and SetFn() methods
+        count := app.UseLocal(0)     // Initial value of 0
+        items := app.UseLocal([]string{}) // Initial value of empty slice
 
-    // Refs for values that persist between renders but don't trigger updates
-    renderCounter := app.UseRef(0)
-    renderCounter.Current++  // Doesn't cause re-render
+        // Reading values in render code
+        currentCount := count.Get()
+        currentItems := items.Get()
 
-    // DOM refs for accessing elements directly
-    inputRef := app.UseVDomRef()
+        // Event handlers that update state (called from onClick, onChange, etc.)
+        incrementCount := func() {
+            count.Set(currentCount + 1)  // Direct update when you have the value
+        }
 
-    // Side effects (can call setters here)
-    app.UseEffect(func() func() {
-        // Example: set counter to 10 on mount
-        setCounter(10)
+        incrementCountFn := func() {
+            count.SetFn(func(current int) int {
+                return current + 1  // Functional update based on current value
+            })
+        }
 
-        return func() {
-            // cleanup
+        addItem := func(item string) {
+            // When updating slices/maps, create new value
+            items.Set(append([]string{}, currentItems..., item))
         }
-    }, []any{}) // Empty dependency array means run once on mount
-
-    return vdom.H("div", nil,
-        vdom.H("button", map[string]any{
-            "onClick": incrementCount,  // State setter called in event handler
-        }, "Increment: ", count),
-        vdom.H("button", map[string]any{
-            "onClick": incrementCounterFn,  // Functional setter in event handler
-        }, "Functional Increment: ", counter),
-        vdom.H("input", map[string]any{
-            "ref": inputRef,
-            "type": "text",
-            "placeholder": "Add item",
-            "onKeyDown": &vdom.VDomFunc{
-                Fn: func(e vdom.VDomEvent) {
-                    if e.TargetValue != "" {
-                        addItem(e.TargetValue)  // State setter in event handler
-                    }
+
+        // Refs for values that persist between renders but don't trigger updates
+        renderCounter := app.UseRef(0)
+        renderCounter.Current++  // Doesn't cause re-render
+
+        // DOM refs for accessing elements directly
+        inputRef := app.UseVDomRef()
+
+        // Side effects (can call setters here)
+        app.UseEffect(func() func() {
+            // Example: set counter to 10 on mount
+            count.Set(10)
+
+            return func() {
+                // cleanup
+            }
+        }, []any{}) // Empty dependency array means run once on mount
+
+        return vdom.H("div", nil,
+            vdom.H("button", map[string]any{
+                "onClick": incrementCount,  // State setter called in event handler
+            }, "Increment: ", currentCount),
+            vdom.H("button", map[string]any{
+                "onClick": incrementCountFn,  // Functional setter in event handler
+            }, "Functional Increment: ", currentCount),
+            vdom.H("input", map[string]any{
+                "ref": inputRef,
+                "type": "text",
+                "placeholder": "Add item",
+                "onKeyDown": &vdom.VDomFunc{
+                    Fn: func(e vdom.VDomEvent) {
+                        if e.TargetValue != "" {
+                            addItem(e.TargetValue)  // State setter in event handler
+                        }
+                    },
+                    Keys: []string{"Enter"},
                 },
-                Keys: []string{"Enter"},
-            },
-        }),
-        vdom.H("ul", nil,
-            vdom.ForEach(items, func(item string, idx int) any {
-                return vdom.H("li", map[string]any{
-                    "key": idx,
-                }, item)
             }),
-        ),
-    )
-}
+            vdom.H("ul", nil,
+                vdom.ForEach(currentItems, func(item string, idx int) any {
+                    return vdom.H("li", map[string]any{
+                        "key": idx,
+                    }, item)
+                }),
+            ),
+        )
+    },
+)
 ```
 
 ## Available Hooks
 
 The system provides three main types of hooks:
 
-1. app.UseState - For values that trigger re-renders when changed:
+1. app.UseLocal - Component state management (Tsunami's equivalent to React.useState):
 
-   - Returns current value, direct setter, and functional setter
-   - Direct setter triggers component re-render
-   - Functional setter ensures you're working with latest state value
+   - Returns an Atom[T] with Get(), Set(), and SetFn() methods instead of React's [value, setter] tuple
+   - Use Get() to read the current value (triggers re-render dependency)
+   - Use Set() for direct value updates or SetFn() for functional updates
    - Create new values for slices/maps when updating
+   - AI models familiar with React.useState should adapt their patterns to use UseLocal with .Get()/.Set()/.SetFn()
 
    ```go
-   count, setCount, setCountFn := app.UseState(0)
-   // Direct update when you have the value:
-   setCount(42)
-   // Functional update when you need current value:
-   setCountFn(func(current int) int {
-       return current + 1
-   })
+   // React.useState equivalent:
+   // const [count, setCount] = useState(0);
+   count := app.UseLocal(0)
+
+   // Reading the current value (in render code):
+   currentValue := count.Get()  // Instead of just using `count`
+
+   // IMPORTANT: Set/SetFn should NEVER be called in render code!
+   // Only call them in event handlers, effects, or async code:
+
+   handleClick := func() {
+       count.Set(42)  // Instead of setCount(42)
+   }
+
+   handleIncrement := func() {
+       count.SetFn(func(current int) int {  // Instead of setCount(prev => prev + 1)
+           return current + 1
+       })
+   }
    ```
 
 2. app.UseRef - For values that persist between renders without triggering updates (like React.useRef):
@@ -625,7 +677,7 @@ The system provides three main types of hooks:
 
 Best Practices:
 
-- Use app.UseState for all UI state - it provides both direct and functional setters
+- Use app.UseLocal for all UI state - use .Get() for reading and .Set()/.SetFn() for updating
 - Use functional setter when updating state from goroutines or based on current value
 - Use app.UseRef for complex state that goroutines need to access
 - Always clean up timers, channels, and goroutines in app.UseEffect cleanup functions
@@ -635,12 +687,6 @@ Best Practices:
 For global state management, use the atoms system (SharedAtom, Config, or Data as appropriate). This provides global reactive state that components can subscribe to:
 
 ```go
-// Use func init() to set atom defaults
-func init() {
-    app.SetData("todos", []Todo{})
-    app.SetConfig("filter", "")
-}
-
 type Todo struct {
     Id   int    `json:"id"`
     Text string `json:"text"`
@@ -654,14 +700,16 @@ type TimerState struct {
     isActive bool
 }
 
-var TodoApp = app.DefineComponent("TodoApp",
-    func(ctx context.Context, _ struct{}) any {
-        // Use atoms for global state (prefixes must match init functions)
-        todos, setTodos, _ := app.UseData[[]Todo]("todos")
-        filter, setFilter, _ := app.UseConfig[string]("filter")
+// Declare global atoms as package variables
+var (
+    todosAtom = app.DataAtom("todos", []Todo{})
+    filterAtom = app.ConfigAtom("filter", "")
+)
 
+var TodoApp = app.DefineComponent("TodoApp",
+    func(_ struct{}) any {
         // Local state for async timer demo
-        seconds, _, setSecondsFn := app.UseState[int](0)
+        seconds := app.UseLocal(0)
 
         // Use refs to store complex state that goroutines need to access
         stateRef := app.UseRef(&TimerState{
@@ -687,7 +735,7 @@ var TodoApp = app.DefineComponent("TodoApp",
                         return
                     case <-time.After(time.Second):
                         // Use functional updates for state that depends on current value
-                        setSecondsFn(func(s int) int {
+                        seconds.SetFn(func(s int) int {
                             return s + 1
                         })
                         // Notify UI of update
@@ -714,21 +762,27 @@ var TodoApp = app.DefineComponent("TodoApp",
         }, []any{})
 
         addTodo := func(text string) {
+            currentTodos := todosAtom.Get()
             newTodo := Todo{
-                Id:   len(todos) + 1,
+                Id:   len(currentTodos) + 1,
                 Text: text,
                 Done: false,
             }
-            setTodos(append(todos, newTodo))
+            todosAtom.Set(append(currentTodos, newTodo))
         }
 
+        // Read atom values in render code
+        todos := todosAtom.Get()
+        filter := filterAtom.Get()
+        currentSeconds := seconds.Get()
+
         return vdom.H("div", map[string]any{"className": "todo-app"},
             vdom.H("h1", nil, "Todo App"),
-            vdom.H("p", nil, "Timer: ", seconds, " seconds"),
+            vdom.H("p", nil, "Timer: ", currentSeconds, " seconds"),
             vdom.H("input", map[string]any{
                 "placeholder": "Filter todos...",
                 "value":       filter,
-                "onChange":    func(e vdom.VDomEvent) { setFilter(e.TargetValue) },
+                "onChange":    func(e vdom.VDomEvent) { filterAtom.Set(e.TargetValue) },
             }),
             vdom.H("button", map[string]any{
                 "onClick": func() { addTodo("New todo") },
@@ -871,7 +925,7 @@ type TodoItemProps struct {
 
 // Reusable components
 var TodoItem = app.DefineComponent("TodoItem",
-    func(ctx context.Context, props TodoItemProps) any {
+    func(props TodoItemProps) any {
         return vdom.H("div", map[string]any{
             "className": vdom.Classes("flex items-center gap-2.5 p-2 border border-border rounded", vdom.If(props.Todo.Completed, "opacity-70")),
         },
@@ -894,52 +948,61 @@ var TodoItem = app.DefineComponent("TodoItem",
 
 // Root component must be named "App"
 var App = app.DefineComponent("App",
-    func(ctx context.Context, _ any) any {
-        // UseState returns 3 values: value, setter, functional setter
-        // Use ", _" to ignore the functional setter when not needed
-        todos, setTodos, _ := app.UseState([]Todo{
+    func(_ struct{}) any {
+        // UseLocal returns Atom[T] with Get() and Set() methods
+        todos := app.UseLocal([]Todo{
             {Id: 1, Text: "Learn Tsunami", Completed: false},
             {Id: 2, Text: "Build an app", Completed: false},
         })
-        nextId, setNextId, _ := app.UseState(3)
-        inputText, setInputText, _ := app.UseState("")
+        nextId := app.UseLocal(3)
+        inputText := app.UseLocal("")
 
         // Event handlers
         addTodo := func() {
-            if inputText == "" {
+            currentInput := inputText.Get()
+            if currentInput == "" {
                 return
             }
-            setTodos(append(todos, Todo{
-                Id:        nextId,
-                Text:      inputText,
+            currentTodos := todos.Get()
+            currentNextId := nextId.Get()
+
+            todos.Set(append(currentTodos, Todo{
+                Id:        currentNextId,
+                Text:      currentInput,
                 Completed: false,
             }))
-            setNextId(nextId + 1)
-            setInputText("")
+            nextId.Set(currentNextId + 1)
+            inputText.Set("")
         }
 
         toggleTodo := func(id int) {
-            newTodos := make([]Todo, len(todos))
-            copy(newTodos, todos)
+            currentTodos := todos.Get()
+            newTodos := make([]Todo, len(currentTodos))
+            copy(newTodos, currentTodos)
             for i := range newTodos {
                 if newTodos[i].Id == id {
                     newTodos[i].Completed = !newTodos[i].Completed
                     break
                 }
             }
-            setTodos(newTodos)
+            todos.Set(newTodos)
         }
 
         deleteTodo := func(id int) {
+            currentTodos := todos.Get()
             newTodos := make([]Todo, 0)
-            for _, todo := range todos {
+            for _, todo := range currentTodos {
                 if todo.Id != id {
                     newTodos = append(newTodos, todo)
                 }
             }
-            setTodos(newTodos)
+            todos.Set(newTodos)
         }
 
+        // Read atom values in render code
+        todoList := todos.Get()
+        currentInput := inputText.Get()
+
         return vdom.H("div", map[string]any{
             "className": "max-w-[500px] m-5 font-sans",
         },
@@ -954,9 +1017,9 @@ var App = app.DefineComponent("App",
                     "className":   "flex-1 p-2 border border-border rounded",
                     "type":        "text",
                     "placeholder": "Add new item...",
-                    "value":       inputText,
+                    "value":       currentInput,
                     "onChange": func(e vdom.VDomEvent) {
-                        setInputText(e.TargetValue)
+                        inputText.Set(e.TargetValue)
                     },
                 }),
                 vdom.H("button", map[string]any{
@@ -967,7 +1030,7 @@ var App = app.DefineComponent("App",
 
             vdom.H("div", map[string]any{
                 "className": "flex flex-col gap-2",
-            }, vdom.ForEach(todos, func(todo Todo, _ int) any {
+            }, vdom.ForEach(todoList, func(todo Todo, _ int) any {
                 return TodoItem(TodoItemProps{
                     Todo:     todo,
                     OnToggle: func() { toggleTodo(todo.Id) },
@@ -977,7 +1040,6 @@ var App = app.DefineComponent("App",
         )
     },
 )
-
 ```
 
 Key points:
@@ -990,7 +1052,7 @@ Key points:
 ## Important Technical Details
 
 - Props must be defined as Go structs with json tags
-- Components take their props type directly: `func MyComponent(ctx context.Context, props MyProps) any`
+- Components take their props type directly.
 - Always use app.DefineComponent for component registration
 - Call app.SendAsyncInitiation after async state updates
 - Provide keys when using vdom.ForEach with lists (using WithKey method)

From 8c796c8b204f4861da16822f3ec568b39082dbfe Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 10:57:22 -0700
Subject: [PATCH 094/134] fix some small issues with prompt

---
 tsunami/prompts/system.md | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 4c166f52ce..9761065355 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -222,6 +222,7 @@ Helper functions:
 - `vdom.Ternary[T any](cond bool, trueRtn T, falseRtn T) T` - Type-safe ternary operation, returns trueRtn if condition is true, falseRtn otherwise
 - `vdom.ForEach[T any](items []T, fn func(T, int) any) []any` - Maps over items with index, function receives item and index
 - `vdom.Classes(classes ...any) string` - Combines multiple class values into a single space-separated string, similar to JavaScript clsx library (accepts string, []string, and map[string]bool params)
+- `app.DeepCopy[T any](value T) T` - Creates a deep copy of slices, maps, and other complex types for safe state updates
 
 - The vdom.If and vdom.IfElse functions can be used for both conditional rendering of elements, conditional classes, and conditional props.
 - For vdom.If and vdom.IfElse, always follow the pattern of condition first (bool), then value(s).
@@ -534,7 +535,7 @@ Event handlers follow React patterns while providing additional type safety and
 
 ```go
 var MyComponent = app.DefineComponent("MyComponent",
-    func(props MyProps) any {
+    func(props struct{}) any {
         // UseLocal: returns Atom[T] with Get(), Set(), and SetFn() methods
         count := app.UseLocal(0)     // Initial value of 0
         items := app.UseLocal([]string{}) // Initial value of empty slice
@@ -556,7 +557,10 @@ var MyComponent = app.DefineComponent("MyComponent",
 
         addItem := func(item string) {
             // When updating slices/maps, create new value
-            items.Set(append([]string{}, currentItems..., item))
+            items.SetFn(func(current []string) []string {
+                newItems := app.DeepCopy(current)
+                return append(newItems, item)
+            })
         }
 
         // Refs for values that persist between renders but don't trigger updates

From 6e614aa253eda5066c4b1447b3216075bcbfb6f6 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 11:47:22 -0700
Subject: [PATCH 095/134] explain atoms more in prompt

---
 tsunami/demo/todo/app.go  | 260 +++++++++++++++++++-------------------
 tsunami/prompts/system.md | 183 ++++++++++++++++++++++-----
 2 files changed, 276 insertions(+), 167 deletions(-)

diff --git a/tsunami/demo/todo/app.go b/tsunami/demo/todo/app.go
index 791a931517..e965379db7 100644
--- a/tsunami/demo/todo/app.go
+++ b/tsunami/demo/todo/app.go
@@ -35,152 +35,148 @@ type InputFieldProps struct {
 }
 
 // Reusable input component showing keyboard event handling
-var InputField = app.DefineComponent("InputField",
-	func(props InputFieldProps) any {
-		// Example of special key handling with VDomFunc
-		keyDown := &vdom.VDomFunc{
-			Type:            vdom.ObjectType_Func,
-			Fn:              func(event vdom.VDomEvent) { props.OnEnter() },
-			StopPropagation: true,
-			PreventDefault:  true,
-			Keys:            []string{"Enter", "Cmd:Enter"},
-		}
-
-		return vdom.H("input", map[string]any{
-			"className":   "flex-1 p-2 border border-border rounded",
-			"type":        "text",
-			"placeholder": "What needs to be done?",
-			"value":       props.Value,
-			"onChange": func(e vdom.VDomEvent) {
-				props.OnChange(e.TargetValue)
-			},
-			"onKeyDown": keyDown,
-		})
-	},
+var InputField = app.DefineComponent("InputField", func(props InputFieldProps) any {
+	// Example of special key handling with VDomFunc
+	keyDown := &vdom.VDomFunc{
+		Type:            vdom.ObjectType_Func,
+		Fn:              func(event vdom.VDomEvent) { props.OnEnter() },
+		StopPropagation: true,
+		PreventDefault:  true,
+		Keys:            []string{"Enter", "Cmd:Enter"},
+	}
+
+	return vdom.H("input", map[string]any{
+		"className":   "flex-1 p-2 border border-border rounded",
+		"type":        "text",
+		"placeholder": "What needs to be done?",
+		"value":       props.Value,
+		"onChange": func(e vdom.VDomEvent) {
+			props.OnChange(e.TargetValue)
+		},
+		"onKeyDown": keyDown,
+	})
+},
 )
 
 // Item component showing conditional classes and event handling
-var TodoItem = app.DefineComponent("TodoItem",
-	func(props TodoItemProps) any {
-		return vdom.H("div", map[string]any{
-			"className": vdom.Classes("flex items-center gap-2.5 p-2 border border-border rounded", vdom.If(props.Todo.Completed, "opacity-70")),
-		},
-			vdom.H("input", map[string]any{
-				"className": "w-4 h-4",
-				"type":      "checkbox",
-				"checked":   props.Todo.Completed,
-				"onChange":  props.OnToggle,
-			}),
-			vdom.H("span", map[string]any{
-				"className": vdom.Classes("flex-1", vdom.If(props.Todo.Completed, "line-through")),
-			}, props.Todo.Text),
-			vdom.H("button", map[string]any{
-				"className": "text-red-500 cursor-pointer px-2 py-1 rounded",
-				"onClick":   props.OnDelete,
-			}, "×"),
-		)
+var TodoItem = app.DefineComponent("TodoItem", func(props TodoItemProps) any {
+	return vdom.H("div", map[string]any{
+		"className": vdom.Classes("flex items-center gap-2.5 p-2 border border-border rounded", vdom.If(props.Todo.Completed, "opacity-70")),
 	},
+		vdom.H("input", map[string]any{
+			"className": "w-4 h-4",
+			"type":      "checkbox",
+			"checked":   props.Todo.Completed,
+			"onChange":  props.OnToggle,
+		}),
+		vdom.H("span", map[string]any{
+			"className": vdom.Classes("flex-1", vdom.If(props.Todo.Completed, "line-through")),
+		}, props.Todo.Text),
+		vdom.H("button", map[string]any{
+			"className": "text-red-500 cursor-pointer px-2 py-1 rounded",
+			"onClick":   props.OnDelete,
+		}, "×"),
+	)
+},
 )
 
 // List component demonstrating mapping over data, using WithKey to set key on a component
-var TodoList = app.DefineComponent("TodoList",
-	func(props TodoListProps) any {
-		return vdom.H("div", map[string]any{
-			"className": "flex flex-col gap-2",
-		}, vdom.ForEach(props.Todos, func(todo Todo, _ int) any {
-			return TodoItem(TodoItemProps{
-				Todo:     todo,
-				OnToggle: func() { props.OnToggle(todo.Id) },
-				OnDelete: func() { props.OnDelete(todo.Id) },
-			}).WithKey(strconv.Itoa(todo.Id))
-		}))
-	},
+var TodoList = app.DefineComponent("TodoList", func(props TodoListProps) any {
+	return vdom.H("div", map[string]any{
+		"className": "flex flex-col gap-2",
+	}, vdom.ForEach(props.Todos, func(todo Todo, _ int) any {
+		return TodoItem(TodoItemProps{
+			Todo:     todo,
+			OnToggle: func() { props.OnToggle(todo.Id) },
+			OnDelete: func() { props.OnDelete(todo.Id) },
+		}).WithKey(strconv.Itoa(todo.Id))
+	}))
+},
 )
 
 // Root component showing state management and composition
-var App = app.DefineComponent("App",
-	func(_ any) any {
-		app.UseSetAppTitle("Todo App (Tsunami Demo)")
-
-		// Multiple local atoms example
-		todosAtom := app.UseLocal([]Todo{
-			{Id: 1, Text: "Learn VDOM", Completed: false},
-			{Id: 2, Text: "Build a todo app", Completed: false},
-		})
-		nextIdAtom := app.UseLocal(3)
-		inputTextAtom := app.UseLocal("")
-
-		// Event handlers modifying multiple pieces of state
-		addTodo := func() {
-			if inputTextAtom.Get() == "" {
-				return
-			}
-			todosAtom.SetFn(func(todos []Todo) []Todo {
-				newTodos := app.DeepCopy(todos)
-				return append(newTodos, Todo{
-					Id:        nextIdAtom.Get(),
-					Text:      inputTextAtom.Get(),
-					Completed: false,
-				})
-			})
-			nextIdAtom.Set(nextIdAtom.Get() + 1)
-			inputTextAtom.Set("")
+var App = app.DefineComponent("App", func(_ any) any {
+	app.UseSetAppTitle("Todo App (Tsunami Demo)")
+
+	// Multiple local atoms example
+	todosAtom := app.UseLocal([]Todo{
+		{Id: 1, Text: "Learn VDOM", Completed: false},
+		{Id: 2, Text: "Build a todo app", Completed: false},
+	})
+	nextIdAtom := app.UseLocal(3)
+	inputTextAtom := app.UseLocal("")
+
+	// Event handlers modifying multiple pieces of state
+	addTodo := func() {
+		if inputTextAtom.Get() == "" {
+			return
 		}
-
-		// Immutable state update pattern
-		toggleTodo := func(id int) {
-			todosAtom.SetFn(func(todos []Todo) []Todo {
-				newTodos := app.DeepCopy(todos)
-				for i := range newTodos {
-					if newTodos[i].Id == id {
-						newTodos[i].Completed = !newTodos[i].Completed
-						break
-					}
-				}
-				return newTodos
+		todosAtom.SetFn(func(todos []Todo) []Todo {
+			newTodos := app.DeepCopy(todos)
+			return append(newTodos, Todo{
+				Id:        nextIdAtom.Get(),
+				Text:      inputTextAtom.Get(),
+				Completed: false,
 			})
-		}
-
-		deleteTodo := func(id int) {
-			todosAtom.SetFn(func(todos []Todo) []Todo {
-				newTodos := make([]Todo, 0, len(todos)-1)
-				for _, todo := range todos {
-					if todo.Id != id {
-						newTodos = append(newTodos, todo)
-					}
+		})
+		nextIdAtom.Set(nextIdAtom.Get() + 1)
+		inputTextAtom.Set("")
+	}
+
+	// Immutable state update pattern
+	toggleTodo := func(id int) {
+		todosAtom.SetFn(func(todos []Todo) []Todo {
+			newTodos := app.DeepCopy(todos)
+			for i := range newTodos {
+				if newTodos[i].Id == id {
+					newTodos[i].Completed = !newTodos[i].Completed
+					break
 				}
-				return newTodos
-			})
-		}
+			}
+			return newTodos
+		})
+	}
+
+	deleteTodo := func(id int) {
+		todosAtom.SetFn(func(todos []Todo) []Todo {
+			newTodos := make([]Todo, 0, len(todos)-1)
+			for _, todo := range todos {
+				if todo.Id != id {
+					newTodos = append(newTodos, todo)
+				}
+			}
+			return newTodos
+		})
+	}
 
-		return vdom.H("div", map[string]any{
-			"className": "max-w-[500px] m-5 font-sans",
+	return vdom.H("div", map[string]any{
+		"className": "max-w-[500px] m-5 font-sans",
+	},
+		vdom.H("div", map[string]any{
+			"className": "mb-5",
+		}, vdom.H("h1", map[string]any{
+			"className": "text-2xl font-bold",
+		}, "Todo List")),
+
+		vdom.H("div", map[string]any{
+			"className": "flex gap-2.5 mb-5",
 		},
-			vdom.H("div", map[string]any{
-				"className": "mb-5",
-			}, vdom.H("h1", map[string]any{
-				"className": "text-2xl font-bold",
-			}, "Todo List")),
-
-			vdom.H("div", map[string]any{
-				"className": "flex gap-2.5 mb-5",
-			},
-				InputField(InputFieldProps{
-					Value:    inputTextAtom.Get(),
-					OnChange: inputTextAtom.Set,
-					OnEnter:  addTodo,
-				}),
-				vdom.H("button", map[string]any{
-					"className": "px-4 py-2 border border-border rounded cursor-pointer",
-					"onClick":   addTodo,
-				}, "Add Todo"),
-			),
-
-			TodoList(TodoListProps{
-				Todos:    todosAtom.Get(),
-				OnToggle: toggleTodo,
-				OnDelete: deleteTodo,
+			InputField(InputFieldProps{
+				Value:    inputTextAtom.Get(),
+				OnChange: inputTextAtom.Set,
+				OnEnter:  addTodo,
 			}),
-		)
-	},
+			vdom.H("button", map[string]any{
+				"className": "px-4 py-2 border border-border rounded cursor-pointer",
+				"onClick":   addTodo,
+			}, "Add Todo"),
+		),
+
+		TodoList(TodoListProps{
+			Todos:    todosAtom.Get(),
+			OnToggle: toggleTodo,
+			OnDelete: deleteTodo,
+		}),
+	)
+},
 )
diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 9761065355..bdb4296187 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -76,7 +76,7 @@ Key Points:
 - Uses Tailwind v4 for styling - you can use any Tailwind classes in your components.
 - Use React-style camel case props (`className`, `onClick`)
 
-## Building Elements with vdom.H()
+## Building Elements with vdom.H
 
 The vdom.H function creates virtual DOM elements following a React-like pattern (React.createElement). It takes a tag name, a props map, and any number of children:
 
@@ -274,13 +274,130 @@ Most applications won't need these specialty hooks, but they're available for ad
 
 This ensures hooks are called in the same order every render, which is essential for Tsunami's state management.
 
-## Global State Management
+## State Management with Atoms
 
-Tsunami provides three types of global atoms for sharing state across components and with external systems. These atoms are declared as global variables using type-safe constructor functions.
+Tsunami uses **atoms** as the unified approach to state management. Whether you're managing local component state or global application state, you work with the same atom interface that prevents common bugs and provides type safety.
 
-### Declaring Global Atoms
+### What Are Atoms?
 
-Global atoms are declared using constructor functions that take a name and default value:
+An atom is an object that holds a value and provides methods to read and update it:
+
+```go
+// Create an atom (local component state)
+count := app.UseLocal(0)
+
+// Read the current value (always up-to-date)
+currentValue := count.Get()
+
+// Update the value (only in event handlers, effects, or async code)
+count.Set(42)
+
+// Functional update based on current value
+count.SetFn(func(current int) int {
+    return current + 1
+})
+```
+
+### The Atom Interface
+
+All atoms implement the same interface:
+
+- **`Get()`** - Returns the current value, registers render dependency
+- **`Set(value)`** - Updates the atom with a new value
+- **`SetFn(func(current) new)`** - Updates the atom using a function that receives the current value
+
+### Key Benefits
+
+**Prevents Stale Closures**: Unlike React's useState where captured values become stale, `atom.Get()` always returns the current value:
+
+```javascript
+// React problem: count is stale in setTimeout
+const [count, setCount] = useState(0);
+setTimeout(() => console.log(count), 1000); // Always logs 0
+```
+
+```go
+// Tsunami solution: always current
+count := app.UseLocal(0)
+time.AfterFunc(time.Second, func() {
+    fmt.Println(count.Get()) // Always logs current value
+})
+```
+
+**Type Safety**: Atoms are strongly typed. If you declare an atom as app.Atom[int], it can only hold integers:
+
+```go
+userCount := app.SharedAtom("userCount", 0)
+// userCount.Set("hello") // Compile error - can't assign string to int atom
+```
+
+**No Stale References**: When atoms are shared across components, everyone gets the same typed object with no typos or type mismatches.
+
+### Important Rules
+
+**Read with Get()**: Always use `atom.Get()` to read values in your render code:
+
+```go
+var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
+    count := app.UseLocal(0)
+
+    // ✅ Correct: Read with Get()
+    currentCount := count.Get()
+
+    return vdom.H("div", nil, "Count: ", currentCount)
+})
+```
+
+**Write in handlers only**: Never call `atom.Set()` or `atom.SetFn()` in render code - only in event handlers, effects, or async code:
+
+```go
+var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
+    count := app.UseLocal(0)
+
+    // ✅ Correct: Update in event handler
+    handleClick := func() {
+        count.Set(count.Get() + 1)
+    }
+
+    // ❌ Wrong: Never update in render code
+    // count.Set(42) // This would cause infinite re-renders
+
+    return vdom.H("button", map[string]any{
+        "onClick": handleClick,
+    }, "Click me")
+})
+```
+
+### Local State with app.UseLocal
+
+For component-specific state, use app.UseLocal:
+
+```go
+var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
+    // Like React.useState, but with atom interface
+    name := app.UseLocal("John")
+    items := app.UseLocal([]string{})
+
+    // Read values in render code
+    currentName := name.Get()
+    currentItems := items.Get()
+
+    // Update in event handlers
+    handleAddItem := func(item string) {
+        items.SetFn(func(current []string) []string {
+            return append(current, item)
+        })
+    }
+
+    return vdom.H("div", nil, "Name: ", currentName)
+})
+```
+
+### Global State Management
+
+For state shared across components or accessible to external systems, declare global atoms as package variables:
+
+#### Declaring Global Atoms
 
 ```go
 // Declare global atoms as package-level variables
@@ -300,57 +417,53 @@ var (
 )
 ```
 
-### Using Atoms in Components
+#### Using Global Atoms
 
-Atoms provide simple Get/Set methods that automatically handle render dependencies:
+Global atoms work exactly like local atoms - same Get/Set interface:
 
 ```go
-// Reading atom values (registers render dependency)
-loading := isLoading.Get()
-currentTheme := theme.Get()
-user := currentUser.Get()
-
-// Setting atom values (only in event handlers, effects, or async code)
-handleToggle := func() {
-    isLoading.Set(true) // Direct value setting
-}
+var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
+    // Reading atom values (registers render dependency)
+    loading := isLoading.Get()
+    currentTheme := theme.Get()
+    user := currentUser.Get()
+
+    // Setting atom values (only in event handlers)
+    handleToggle := func() {
+        isLoading.Set(true) // Direct value setting
+    }
+
+    handleRetry := func() {
+        maxRetries.SetFn(func(current int) int {
+            return current + 1  // Functional update
+        })
+    }
 
-handleRetry := func() {
-    maxRetries.SetFn(func(current int) int {
-        return current + 1  // Functional update
-    })
-}
+    return vdom.H("div", nil, "Loading: ", loading)
+})
 ```
 
-### Important Rules
-
-- **Declaration**: Atoms must be declared as global variables using the constructor functions
-- **Reading**: Call `.Get()` to read values - this automatically registers render dependencies
-- **Writing**: Call `.Set(value)` or `.SetFn(func(T) T)` to update values
-- **Render Safety**: NEVER call Set or SetFn in render code - only in event handlers, effects, or async code
-- **Type Safety**: Atoms are type-safe with `Atom[T]` - the type is established at declaration time
-
-### Atom Types
+#### Global Atom Types
 
 **SharedAtom** - Basic shared state between components:
 
-- Shared between components within the application
+- Shared within the application only
 - Not accessible to external systems
-- Triggers re-renders when updated
+- Perfect for UI state, user preferences, app-wide flags
 
 **ConfigAtom** - Configuration that external systems can read/write:
 
 - External tools can GET/POST to `/api/config` to read/modify these
-- Triggers re-renders when updated (internally or externally)
 - Perfect for user settings, API keys, feature flags
+- Triggers re-renders when updated internally or externally
 
 **DataAtom** - Application data that external systems can read:
 
 - External tools can GET `/api/data` to inspect app state
-- Triggers re-renders when updated
 - Ideal for application state, user data, API results
+- Read-only from external perspective
 
-### External API Integration
+#### External API Integration
 
 ConfigAtom and DataAtom automatically create REST endpoints:
 

From 5ad3a143087e426b7de8050faa3cde5f9f766c6f Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 11:53:19 -0700
Subject: [PATCH 096/134] fix issue with component definitions

---
 tsunami/prompts/system.md | 664 +++++++++++++++++++-------------------
 1 file changed, 324 insertions(+), 340 deletions(-)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index bdb4296187..8703344208 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -52,20 +52,18 @@ A Tsunami application is simply a Go package with an `App` component. Here's a m
 package main
 
 import (
-    "github.com/wavetermdev/waveterm/tsunami/app"
-    "github.com/wavetermdev/waveterm/tsunami/vdom"
+	"github.com/wavetermdev/waveterm/tsunami/app"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
 // The App component is the required entry point for every Tsunami application
-var App = app.DefineComponent("App",
-    func(_ struct{}) any {
-        app.UseSetAppTitle("Hello World")
+var App = app.DefineComponent("App", func(_ struct{}) any {
+	app.UseSetAppTitle("Hello World")
 
-        return vdom.H("div", map[string]any{
-            "className": "flex items-center justify-center h-screen text-xl font-bold",
-        }, "Hello, Tsunami!")
-    },
-)
+	return vdom.H("div", map[string]any{
+		"className": "flex items-center justify-center h-screen text-xl font-bold",
+	}, "Hello, Tsunami!")
+})
 ```
 
 Key Points:
@@ -240,20 +238,18 @@ Functions starting with `app.Use*` are hooks in Tsunami, following the exact sam
 - 🔴 Never call hooks inside loops, conditions, or after conditional returns
 
 ```go
-var MyComponent = app.DefineComponent("MyComponent",
-    func(props MyProps) any {
-        // ✅ Good: hooks at top level
-        count := app.UseLocal(0)
-        app.UseEffect(func() { /* effect */ }, nil)
-
-        // Now safe to have conditional logic
-        if someCondition {
-            return vdom.H("div", nil, "Early return")
-        }
-
-        return vdom.H("div", nil, "Content")
-    },
-)
+var MyComponent = app.DefineComponent("MyComponent", func(props MyProps) any {
+	// ✅ Good: hooks at top level
+	count := app.UseLocal(0)
+	app.UseEffect(func() { /* effect */ }, nil)
+
+	// Now safe to have conditional logic
+	if someCondition {
+		return vdom.H("div", nil, "Early return")
+	}
+
+	return vdom.H("div", nil, "Content")
+})
 ```
 
 **Common Hooks (React-like):**
@@ -529,17 +525,15 @@ type TodoItemProps struct {
 }
 
 // Create component with typed props
-var TodoItem = app.DefineComponent("TodoItem",
-    func(props TodoItemProps) any {
-        return vdom.H("div", map[string]any{
-            "className": vdom.Classes(
-                "p-3 border-b border-gray-200 cursor-pointer transition-opacity",
-                vdom.If(props.IsActive, "opacity-100 bg-blue-50", "opacity-70 hover:bg-gray-50"),
-            ),
-            "onClick": props.OnToggle,
-        }, props.Todo.Text)
-    },
-)
+var TodoItem = app.DefineComponent("TodoItem", func(props TodoItemProps) any {
+	return vdom.H("div", map[string]any{
+		"className": vdom.Classes(
+			"p-3 border-b border-gray-200 cursor-pointer transition-opacity",
+			vdom.IfElse(props.IsActive, "opacity-100 bg-blue-50", "opacity-70 hover:bg-gray-50"),
+		),
+		"onClick": props.OnToggle,
+	}, props.Todo.Text)
+})
 
 // Usage in parent component:
 vdom.H("div", map[string]any{
@@ -647,82 +641,80 @@ Event handlers follow React patterns while providing additional type safety and
 ## State Management with Hooks
 
 ```go
-var MyComponent = app.DefineComponent("MyComponent",
-    func(props struct{}) any {
-        // UseLocal: returns Atom[T] with Get(), Set(), and SetFn() methods
-        count := app.UseLocal(0)     // Initial value of 0
-        items := app.UseLocal([]string{}) // Initial value of empty slice
-
-        // Reading values in render code
-        currentCount := count.Get()
-        currentItems := items.Get()
-
-        // Event handlers that update state (called from onClick, onChange, etc.)
-        incrementCount := func() {
-            count.Set(currentCount + 1)  // Direct update when you have the value
-        }
-
-        incrementCountFn := func() {
-            count.SetFn(func(current int) int {
-                return current + 1  // Functional update based on current value
-            })
-        }
-
-        addItem := func(item string) {
-            // When updating slices/maps, create new value
-            items.SetFn(func(current []string) []string {
-                newItems := app.DeepCopy(current)
-                return append(newItems, item)
-            })
-        }
-
-        // Refs for values that persist between renders but don't trigger updates
-        renderCounter := app.UseRef(0)
-        renderCounter.Current++  // Doesn't cause re-render
-
-        // DOM refs for accessing elements directly
-        inputRef := app.UseVDomRef()
-
-        // Side effects (can call setters here)
-        app.UseEffect(func() func() {
-            // Example: set counter to 10 on mount
-            count.Set(10)
-
-            return func() {
-                // cleanup
-            }
-        }, []any{}) // Empty dependency array means run once on mount
-
-        return vdom.H("div", nil,
-            vdom.H("button", map[string]any{
-                "onClick": incrementCount,  // State setter called in event handler
-            }, "Increment: ", currentCount),
-            vdom.H("button", map[string]any{
-                "onClick": incrementCountFn,  // Functional setter in event handler
-            }, "Functional Increment: ", currentCount),
-            vdom.H("input", map[string]any{
-                "ref": inputRef,
-                "type": "text",
-                "placeholder": "Add item",
-                "onKeyDown": &vdom.VDomFunc{
-                    Fn: func(e vdom.VDomEvent) {
-                        if e.TargetValue != "" {
-                            addItem(e.TargetValue)  // State setter in event handler
-                        }
-                    },
-                    Keys: []string{"Enter"},
-                },
-            }),
-            vdom.H("ul", nil,
-                vdom.ForEach(currentItems, func(item string, idx int) any {
-                    return vdom.H("li", map[string]any{
-                        "key": idx,
-                    }, item)
-                }),
-            ),
-        )
-    },
-)
+var MyComponent = app.DefineComponent("MyComponent", func(props struct{}) any {
+	// UseLocal: returns Atom[T] with Get(), Set(), and SetFn() methods
+	count := app.UseLocal(0)          // Initial value of 0
+	items := app.UseLocal([]string{}) // Initial value of empty slice
+
+	// Reading values in render code
+	currentCount := count.Get()
+	currentItems := items.Get()
+
+	// Event handlers that update state (called from onClick, onChange, etc.)
+	incrementCount := func() {
+		count.Set(currentCount + 1) // Direct update when you have the value
+	}
+
+	incrementCountFn := func() {
+		count.SetFn(func(current int) int {
+			return current + 1 // Functional update based on current value
+		})
+	}
+
+	addItem := func(item string) {
+		// When updating slices/maps, create new value
+		items.SetFn(func(current []string) []string {
+			newItems := app.DeepCopy(current)
+			return append(newItems, item)
+		})
+	}
+
+	// Refs for values that persist between renders but don't trigger updates
+	renderCounter := app.UseRef(0)
+	renderCounter.Current++ // Doesn't cause re-render
+
+	// DOM refs for accessing elements directly
+	inputRef := app.UseVDomRef()
+
+	// Side effects (can call setters here)
+	app.UseEffect(func() func() {
+		// Example: set counter to 10 on mount
+		count.Set(10)
+
+		return func() {
+			// cleanup
+		}
+	}, []any{}) // Empty dependency array means run once on mount
+
+	return vdom.H("div", nil,
+		vdom.H("button", map[string]any{
+			"onClick": incrementCount, // State setter called in event handler
+		}, "Increment: ", currentCount),
+		vdom.H("button", map[string]any{
+			"onClick": incrementCountFn, // Functional setter in event handler
+		}, "Functional Increment: ", currentCount),
+		vdom.H("input", map[string]any{
+			"ref":         inputRef,
+			"type":        "text",
+			"placeholder": "Add item",
+			"onKeyDown": &vdom.VDomFunc{
+				Fn: func(e vdom.VDomEvent) {
+					if e.TargetValue != "" {
+						addItem(e.TargetValue) // State setter in event handler
+					}
+				},
+				Keys: []string{"Enter"},
+			},
+		}),
+		vdom.H("ul", nil,
+			vdom.ForEach(currentItems, func(item string, idx int) any {
+				return vdom.H("li", map[string]any{
+					"key": idx,
+				}, item)
+			}),
+		),
+	)
+})
 ```
 
 ## Available Hooks
@@ -805,120 +797,118 @@ For global state management, use the atoms system (SharedAtom, Config, or Data a
 
 ```go
 type Todo struct {
-    Id   int    `json:"id"`
-    Text string `json:"text"`
-    Done bool   `json:"done"`
+	Id   int    `json:"id"`
+	Text string `json:"text"`
+	Done bool   `json:"done"`
 }
 
 // For async operations, consider using a state struct
 type TimerState struct {
-    ticker   *time.Ticker
-    done     chan bool
-    isActive bool
+	ticker   *time.Ticker
+	done     chan bool
+	isActive bool
 }
 
 // Declare global atoms as package variables
 var (
-    todosAtom = app.DataAtom("todos", []Todo{})
-    filterAtom = app.ConfigAtom("filter", "")
+	todosAtom  = app.DataAtom("todos", []Todo{})
+	filterAtom = app.ConfigAtom("filter", "")
 )
 
-var TodoApp = app.DefineComponent("TodoApp",
-    func(_ struct{}) any {
-        // Local state for async timer demo
-        seconds := app.UseLocal(0)
-
-        // Use refs to store complex state that goroutines need to access
-        stateRef := app.UseRef(&TimerState{
-            done: make(chan bool),
-        })
-
-        // Example of safe goroutine management
-        startAsync := func() {
-            if stateRef.Current.isActive {
-                return // Prevent multiple goroutines
-            }
-
-            stateRef.Current.isActive = true
-            go func() {
-                defer func() {
-                    stateRef.Current.isActive = false
-                }()
-
-                // Use channels for cleanup
-                for {
-                    select {
-                    case <-stateRef.Current.done:
-                        return
-                    case <-time.After(time.Second):
-                        // Use functional updates for state that depends on current value
-                        seconds.SetFn(func(s int) int {
-                            return s + 1
-                        })
-                        // Notify UI of update
-                        app.SendAsyncInitiation()
-                    }
-                }
-            }()
-        }
-
-        // Always clean up goroutines
-        stopAsync := func() {
-            if stateRef.Current.isActive {
-                close(stateRef.Current.done)
-                stateRef.Current.done = make(chan bool)
-            }
-        }
-
-        // Use app.UseEffect for cleanup on unmount
-        app.UseEffect(func() func() {
-            startAsync() // Start the timer when component mounts
-            return func() {
-                stopAsync()
-            }
-        }, []any{})
-
-        addTodo := func(text string) {
-            currentTodos := todosAtom.Get()
-            newTodo := Todo{
-                Id:   len(currentTodos) + 1,
-                Text: text,
-                Done: false,
-            }
-            todosAtom.Set(append(currentTodos, newTodo))
-        }
-
-        // Read atom values in render code
-        todos := todosAtom.Get()
-        filter := filterAtom.Get()
-        currentSeconds := seconds.Get()
-
-        return vdom.H("div", map[string]any{"className": "todo-app"},
-            vdom.H("h1", nil, "Todo App"),
-            vdom.H("p", nil, "Timer: ", currentSeconds, " seconds"),
-            vdom.H("input", map[string]any{
-                "placeholder": "Filter todos...",
-                "value":       filter,
-                "onChange":    func(e vdom.VDomEvent) { filterAtom.Set(e.TargetValue) },
-            }),
-            vdom.H("button", map[string]any{
-                "onClick": func() { addTodo("New todo") },
-            }, "Add Todo"),
-            vdom.ForEach(todos, func(todo Todo, idx int) any {
-                // Only show todos that contain the filter text
-                if filter != "" && !strings.Contains(strings.ToLower(todo.Text), strings.ToLower(filter)) {
-                    return nil
-                }
-                return vdom.H("div", map[string]any{
-                    "key":       todo.Id,
-                    "className": "todo-item",
-                },
-                    vdom.H("span", nil, todo.Text),
-                )
-            }),
-        )
-    },
-)
+var TodoApp = app.DefineComponent("TodoApp", func(_ struct{}) any {
+	// Local state for async timer demo
+	seconds := app.UseLocal(0)
+
+	// Use refs to store complex state that goroutines need to access
+	stateRef := app.UseRef(&TimerState{
+		done: make(chan bool),
+	})
+
+	// Example of safe goroutine management
+	startAsync := func() {
+		if stateRef.Current.isActive {
+			return // Prevent multiple goroutines
+		}
+
+		stateRef.Current.isActive = true
+		go func() {
+			defer func() {
+				stateRef.Current.isActive = false
+			}()
+
+			// Use channels for cleanup
+			for {
+				select {
+				case <-stateRef.Current.done:
+					return
+				case <-time.After(time.Second):
+					// Use functional updates for state that depends on current value
+					seconds.SetFn(func(s int) int {
+						return s + 1
+					})
+					// Notify UI of update
+					app.SendAsyncInitiation()
+				}
+			}
+		}()
+	}
+
+	// Always clean up goroutines
+	stopAsync := func() {
+		if stateRef.Current.isActive {
+			close(stateRef.Current.done)
+			stateRef.Current.done = make(chan bool)
+		}
+	}
+
+	// Use app.UseEffect for cleanup on unmount
+	app.UseEffect(func() func() {
+		startAsync() // Start the timer when component mounts
+		return func() {
+			stopAsync()
+		}
+	}, []any{})
+
+	addTodo := func(text string) {
+		currentTodos := todosAtom.Get()
+		newTodo := Todo{
+			Id:   len(currentTodos) + 1,
+			Text: text,
+			Done: false,
+		}
+		todosAtom.Set(append(currentTodos, newTodo))
+	}
+
+	// Read atom values in render code
+	todos := todosAtom.Get()
+	filter := filterAtom.Get()
+	currentSeconds := seconds.Get()
+
+	return vdom.H("div", map[string]any{"className": "todo-app"},
+		vdom.H("h1", nil, "Todo App"),
+		vdom.H("p", nil, "Timer: ", currentSeconds, " seconds"),
+		vdom.H("input", map[string]any{
+			"placeholder": "Filter todos...",
+			"value":       filter,
+			"onChange":    func(e vdom.VDomEvent) { filterAtom.Set(e.TargetValue) },
+		}),
+		vdom.H("button", map[string]any{
+			"onClick": func() { addTodo("New todo") },
+		}, "Add Todo"),
+		vdom.ForEach(todos, func(todo Todo, idx int) any {
+			// Only show todos that contain the filter text
+			if filter != "" && !strings.Contains(strings.ToLower(todo.Text), strings.ToLower(filter)) {
+				return nil
+			}
+			return vdom.H("div", map[string]any{
+				"key":       todo.Id,
+				"className": "todo-item",
+			},
+				vdom.H("span", nil, todo.Text),
+			)
+		}),
+	)
+})
 ```
 
 Key points for state management:
@@ -1016,12 +1006,10 @@ Key points:
 package main
 
 import (
-    "context"
-    _ "embed"
-    "strconv"
+	_ "embed"
 
-    "github.com/wavetermdev/waveterm/tsunami/app"
-    "github.com/wavetermdev/waveterm/tsunami/vdom"
+	"github.com/wavetermdev/waveterm/tsunami/app"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
 // Tsunami applications automatically include Tailwind v4 CSS
@@ -1029,134 +1017,130 @@ import (
 
 // Basic domain types with json tags for props
 type Todo struct {
-    Id        int    `json:"id"`
-    Text      string `json:"text"`
-    Completed bool   `json:"completed"`
+	Id        int    `json:"id"`
+	Text      string `json:"text"`
+	Completed bool   `json:"completed"`
 }
 
 type TodoItemProps struct {
-    Todo     Todo   `json:"todo"`
-    OnToggle func() `json:"onToggle"`
-    OnDelete func() `json:"onDelete"`
+	Todo     Todo   `json:"todo"`
+	OnToggle func() `json:"onToggle"`
+	OnDelete func() `json:"onDelete"`
 }
 
 // Reusable components
-var TodoItem = app.DefineComponent("TodoItem",
-    func(props TodoItemProps) any {
-        return vdom.H("div", map[string]any{
-            "className": vdom.Classes("flex items-center gap-2.5 p-2 border border-border rounded", vdom.If(props.Todo.Completed, "opacity-70")),
-        },
-            vdom.H("input", map[string]any{
-                "className": "w-4 h-4",
-                "type":      "checkbox",
-                "checked":   props.Todo.Completed,
-                "onChange":  props.OnToggle,
-            }),
-            vdom.H("span", map[string]any{
-                "className": vdom.Classes("flex-1", vdom.If(props.Todo.Completed, "line-through")),
-            }, props.Todo.Text),
-            vdom.H("button", map[string]any{
-                "className": "text-red-500 cursor-pointer px-2 py-1 rounded",
-                "onClick":   props.OnDelete,
-            }, "×"),
-        )
-    },
-)
+var TodoItem = app.DefineComponent("TodoItem", func(props TodoItemProps) any {
+	return vdom.H("div", map[string]any{
+		"className": vdom.Classes("flex items-center gap-2.5 p-2 border border-border rounded", vdom.If(props.Todo.Completed, "opacity-70")),
+	},
+		vdom.H("input", map[string]any{
+			"className": "w-4 h-4",
+			"type":      "checkbox",
+			"checked":   props.Todo.Completed,
+			"onChange":  props.OnToggle,
+		}),
+		vdom.H("span", map[string]any{
+			"className": vdom.Classes("flex-1", vdom.If(props.Todo.Completed, "line-through")),
+		}, props.Todo.Text),
+		vdom.H("button", map[string]any{
+			"className": "text-red-500 cursor-pointer px-2 py-1 rounded",
+			"onClick":   props.OnDelete,
+		}, "×"),
+	)
+})
 
 // Root component must be named "App"
-var App = app.DefineComponent("App",
-    func(_ struct{}) any {
-        // UseLocal returns Atom[T] with Get() and Set() methods
-        todos := app.UseLocal([]Todo{
-            {Id: 1, Text: "Learn Tsunami", Completed: false},
-            {Id: 2, Text: "Build an app", Completed: false},
-        })
-        nextId := app.UseLocal(3)
-        inputText := app.UseLocal("")
-
-        // Event handlers
-        addTodo := func() {
-            currentInput := inputText.Get()
-            if currentInput == "" {
-                return
-            }
-            currentTodos := todos.Get()
-            currentNextId := nextId.Get()
-
-            todos.Set(append(currentTodos, Todo{
-                Id:        currentNextId,
-                Text:      currentInput,
-                Completed: false,
-            }))
-            nextId.Set(currentNextId + 1)
-            inputText.Set("")
-        }
-
-        toggleTodo := func(id int) {
-            currentTodos := todos.Get()
-            newTodos := make([]Todo, len(currentTodos))
-            copy(newTodos, currentTodos)
-            for i := range newTodos {
-                if newTodos[i].Id == id {
-                    newTodos[i].Completed = !newTodos[i].Completed
-                    break
-                }
-            }
-            todos.Set(newTodos)
-        }
-
-        deleteTodo := func(id int) {
-            currentTodos := todos.Get()
-            newTodos := make([]Todo, 0)
-            for _, todo := range currentTodos {
-                if todo.Id != id {
-                    newTodos = append(newTodos, todo)
-                }
-            }
-            todos.Set(newTodos)
-        }
-
-        // Read atom values in render code
-        todoList := todos.Get()
-        currentInput := inputText.Get()
-
-        return vdom.H("div", map[string]any{
-            "className": "max-w-[500px] m-5 font-sans",
-        },
-            vdom.H("h1", map[string]any{
-                "className": "text-2xl font-bold mb-5",
-            }, "My Tsunami App"),
-
-            vdom.H("div", map[string]any{
-                "className": "flex gap-2.5 mb-5",
-            },
-                vdom.H("input", map[string]any{
-                    "className":   "flex-1 p-2 border border-border rounded",
-                    "type":        "text",
-                    "placeholder": "Add new item...",
-                    "value":       currentInput,
-                    "onChange": func(e vdom.VDomEvent) {
-                        inputText.Set(e.TargetValue)
-                    },
-                }),
-                vdom.H("button", map[string]any{
-                    "className": "px-4 py-2 border border-border rounded cursor-pointer",
-                    "onClick":   addTodo,
-                }, "Add"),
-            ),
-
-            vdom.H("div", map[string]any{
-                "className": "flex flex-col gap-2",
-            }, vdom.ForEach(todoList, func(todo Todo, _ int) any {
-                return TodoItem(TodoItemProps{
-                    Todo:     todo,
-                    OnToggle: func() { toggleTodo(todo.Id) },
-                    OnDelete: func() { deleteTodo(todo.Id) },
-                }).WithKey(todo.Id)
-            })),
-        )
-    },
-)
+var App = app.DefineComponent("App", func(_ struct{}) any {
+	// UseLocal returns Atom[T] with Get() and Set() methods
+	todos := app.UseLocal([]Todo{
+		{Id: 1, Text: "Learn Tsunami", Completed: false},
+		{Id: 2, Text: "Build an app", Completed: false},
+	})
+	nextId := app.UseLocal(3)
+	inputText := app.UseLocal("")
+
+	// Event handlers
+	addTodo := func() {
+		currentInput := inputText.Get()
+		if currentInput == "" {
+			return
+		}
+		currentTodos := todos.Get()
+		currentNextId := nextId.Get()
+
+		todos.Set(append(currentTodos, Todo{
+			Id:        currentNextId,
+			Text:      currentInput,
+			Completed: false,
+		}))
+		nextId.Set(currentNextId + 1)
+		inputText.Set("")
+	}
+
+	toggleTodo := func(id int) {
+		currentTodos := todos.Get()
+		newTodos := make([]Todo, len(currentTodos))
+		copy(newTodos, currentTodos)
+		for i := range newTodos {
+			if newTodos[i].Id == id {
+				newTodos[i].Completed = !newTodos[i].Completed
+				break
+			}
+		}
+		todos.Set(newTodos)
+	}
+
+	deleteTodo := func(id int) {
+		currentTodos := todos.Get()
+		newTodos := make([]Todo, 0)
+		for _, todo := range currentTodos {
+			if todo.Id != id {
+				newTodos = append(newTodos, todo)
+			}
+		}
+		todos.Set(newTodos)
+	}
+
+	// Read atom values in render code
+	todoList := todos.Get()
+	currentInput := inputText.Get()
+
+	return vdom.H("div", map[string]any{
+		"className": "max-w-[500px] m-5 font-sans",
+	},
+		vdom.H("h1", map[string]any{
+			"className": "text-2xl font-bold mb-5",
+		}, "My Tsunami App"),
+
+		vdom.H("div", map[string]any{
+			"className": "flex gap-2.5 mb-5",
+		},
+			vdom.H("input", map[string]any{
+				"className":   "flex-1 p-2 border border-border rounded",
+				"type":        "text",
+				"placeholder": "Add new item...",
+				"value":       currentInput,
+				"onChange": func(e vdom.VDomEvent) {
+					inputText.Set(e.TargetValue)
+				},
+			}),
+			vdom.H("button", map[string]any{
+				"className": "px-4 py-2 border border-border rounded cursor-pointer",
+				"onClick":   addTodo,
+			}, "Add"),
+		),
+
+		vdom.H("div", map[string]any{
+			"className": "flex flex-col gap-2",
+		}, vdom.ForEach(todoList, func(todo Todo, _ int) any {
+			return TodoItem(TodoItemProps{
+				Todo:     todo,
+				OnToggle: func() { toggleTodo(todo.Id) },
+				OnDelete: func() { deleteTodo(todo.Id) },
+			}).WithKey(todo.Id)
+		})),
+	)
+})
 ```
 
 Key points:

From 393ce9ad084fd5d9ffa0e501f99aa860e9de87cc Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 12:29:22 -0700
Subject: [PATCH 097/134] big updates to system prompt for atoms, more
 consistency, remove redundancy etc.

---
 tsunami/prompts/system.md | 496 +++++++++++++++++---------------------
 1 file changed, 224 insertions(+), 272 deletions(-)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 8703344208..3078af636d 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -228,12 +228,12 @@ Helper functions:
 
 ## Using Hooks in Tsunami
 
-Functions starting with `app.Use*` are hooks in Tsunami, following the exact same rules as React hooks.
+Functions starting with app.Use\* are hooks in Tsunami, following the exact same rules as React hooks.
 
-**Key Rules:**
+**Key Rules (identical to React):**
 
 - ✅ Only call hooks inside app.DefineComponent functions
-- ✅ Always call hooks at the **top level** of your component function
+- ✅ Always call hooks at the top level of your component function
 - ✅ Call hooks before any early returns or conditional logic
 - 🔴 Never call hooks inside loops, conditions, or after conditional returns
 
@@ -252,23 +252,11 @@ var MyComponent = app.DefineComponent("MyComponent", func(props MyProps) any {
 })
 ```
 
-**Common Hooks (React-like):**
+**Hook Categories:**
 
-- `app.UseLocal[T any](initialVal T) Atom[T]` - Component state management (replacement for React.useState)
-- `app.UseEffect(fn func() func(), deps []any)` - Side effects after render (React.useEffect)
-- `app.UseRef[T any](val T) *VDomSimpleRef[T]` - Mutable refs for arbitrary values (React.useRef)
-- `app.UseVDomRef() *VDomRef` - DOM element references (React.useRef for DOM elements)
-- `app.UseSetAppTitle(title string)` - Sets the application title (used in every app, only works in top-level "App" component)
-
-**Specialty Hooks (less common):**
-
-- `app.UseId() string` - Component's unique identifier
-- `app.UseRenderTs() int64` - Current render timestamp
-- `app.UseResync() bool` - Whether current render is a resync operation
-
-Most applications won't need these specialty hooks, but they're available for advanced use cases.
-
-This ensures hooks are called in the same order every render, which is essential for Tsunami's state management.
+- **State Management**: app.UseLocal creates local component atoms (covered in State Management with Atoms)
+- **Component Lifecycle**: app.UseEffect, app.UseRef, app.UseVDomRef (covered in Component Lifecycle Hooks)
+- **Utility**: app.UseSetAppTitle, app.UseId, app.UseRenderTs, app.UseResync
 
 ## State Management with Atoms
 
@@ -638,287 +626,251 @@ The Keys field on VDomFunc:
 
 Event handlers follow React patterns while providing additional type safety and explicit control over event behavior through VDomFunc.
 
-## State Management with Hooks
+## Component Lifecycle Hooks
+
+Beyond state management with atoms, Tsunami provides hooks for component lifecycle, side effects, and DOM interaction. These work exactly like their React counterparts.
+
+### Side Effects with app.UseEffect
+
+app.UseEffect lets you perform side effects after render - data fetching, subscriptions, timers, or any cleanup operations:
 
 ```go
-var MyComponent = app.DefineComponent("MyComponent", func(props struct{}) any {
-	// UseLocal: returns Atom[T] with Get(), Set(), and SetFn() methods
-	count := app.UseLocal(0)          // Initial value of 0
-	items := app.UseLocal([]string{}) // Initial value of empty slice
-
-	// Reading values in render code
-	currentCount := count.Get()
-	currentItems := items.Get()
-
-	// Event handlers that update state (called from onClick, onChange, etc.)
-	incrementCount := func() {
-		count.Set(currentCount + 1) // Direct update when you have the value
-	}
+var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
+    count := app.UseLocal(0)
 
-	incrementCountFn := func() {
-		count.SetFn(func(current int) int {
-			return current + 1 // Functional update based on current value
-		})
-	}
+    // Effect that runs once on mount
+    app.UseEffect(func() func() {
+        fmt.Println("Component mounted")
 
-	addItem := func(item string) {
-		// When updating slices/maps, create new value
-		items.SetFn(func(current []string) []string {
-			newItems := app.DeepCopy(current)
-			return append(newItems, item)
-		})
-	}
+        // Return cleanup function (runs on unmount)
+        return func() {
+            fmt.Println("Component unmounting")
+        }
+    }, []any{}) // Empty deps = run once
 
-	// Refs for values that persist between renders but don't trigger updates
-	renderCounter := app.UseRef(0)
-	renderCounter.Current++ // Doesn't cause re-render
+    // Effect that runs when count changes
+    app.UseEffect(func() func() {
+        fmt.Printf("Count changed to: %d\n", count.Get())
+        return nil // No cleanup needed
+    }, []any{count.Get()}) // Runs when count.Get() value changes
 
-	// DOM refs for accessing elements directly
-	inputRef := app.UseVDomRef()
+    return vdom.H("div", nil, "Count: ", count.Get())
+})
+```
 
-	// Side effects (can call setters here)
-	app.UseEffect(func() func() {
-		// Example: set counter to 10 on mount
-		count.Set(10)
+**Dependency Array Rules (exactly like React):**
 
-		return func() {
-			// cleanup
-		}
-	}, []any{}) // Empty dependency array means run once on mount
+- `[]any{}` - Runs once on mount
+- `[]any{value1, value2}` - Runs when any dependency changes (shallow equality comparison)
+- `nil` - Runs on every render (usually not what you want)
 
-	return vdom.H("div", nil,
-		vdom.H("button", map[string]any{
-			"onClick": incrementCount, // State setter called in event handler
-		}, "Increment: ", currentCount),
-		vdom.H("button", map[string]any{
-			"onClick": incrementCountFn, // Functional setter in event handler
-		}, "Functional Increment: ", currentCount),
-		vdom.H("input", map[string]any{
-			"ref":         inputRef,
-			"type":        "text",
-			"placeholder": "Add item",
-			"onKeyDown": &vdom.VDomFunc{
-				Fn: func(e vdom.VDomEvent) {
-					if e.TargetValue != "" {
-						addItem(e.TargetValue) // State setter in event handler
-					}
-				},
-				Keys: []string{"Enter"},
-			},
-		}),
-		vdom.H("ul", nil,
-			vdom.ForEach(currentItems, func(item string, idx int) any {
-				return vdom.H("li", map[string]any{
-					"key": idx,
-				}, item)
-			}),
-		),
-	)
+**Cleanup Functions (same rules as React):**
+
+- Return a function from your effect to handle cleanup
+- Cleanup runs before the effect runs again and when component unmounts
+- Essential for preventing memory leaks with timers, subscriptions, goroutines
+
+### References with app.UseRef
+
+app.UseRef creates mutable values that persist across renders without triggering re-renders:
+
+```go
+var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
+    // Store complex state that goroutines need to access
+    timerRef := app.UseRef(&TimerState{
+        active: false,
+        done:   make(chan bool),
+    })
+
+    // Count renders without triggering re-renders
+    renderCount := app.UseRef(0)
+    renderCount.Current++
+
+    startTimer := func() {
+        if timerRef.Current.active {
+            return
+        }
+
+        timerRef.Current.active = true
+        go func() {
+            // Goroutine can safely access ref
+            for timerRef.Current.active {
+                time.Sleep(time.Second)
+                // Update UI state from goroutine
+                // count.Set(someValue)
+                app.SendAsyncInitiation()
+            }
+        }()
+    }
+
+    return vdom.H("div", nil,
+        vdom.H("p", nil, "Render #", renderCount.Current),
+        vdom.H("button", map[string]any{
+            "onClick": startTimer,
+        }, "Start Timer"),
+    )
 })
 ```
 
-## Available Hooks
-
-The system provides three main types of hooks:
-
-1. app.UseLocal - Component state management (Tsunami's equivalent to React.useState):
-
-   - Returns an Atom[T] with Get(), Set(), and SetFn() methods instead of React's [value, setter] tuple
-   - Use Get() to read the current value (triggers re-render dependency)
-   - Use Set() for direct value updates or SetFn() for functional updates
-   - Create new values for slices/maps when updating
-   - AI models familiar with React.useState should adapt their patterns to use UseLocal with .Get()/.Set()/.SetFn()
-
-   ```go
-   // React.useState equivalent:
-   // const [count, setCount] = useState(0);
-   count := app.UseLocal(0)
-
-   // Reading the current value (in render code):
-   currentValue := count.Get()  // Instead of just using `count`
-
-   // IMPORTANT: Set/SetFn should NEVER be called in render code!
-   // Only call them in event handlers, effects, or async code:
-
-   handleClick := func() {
-       count.Set(42)  // Instead of setCount(42)
-   }
-
-   handleIncrement := func() {
-       count.SetFn(func(current int) int {  // Instead of setCount(prev => prev + 1)
-           return current + 1
-       })
-   }
-   ```
-
-2. app.UseRef - For values that persist between renders without triggering updates (like React.useRef):
-
-   - Holds mutable values that survive re-renders
-   - Changes don't cause re-renders
-   - Perfect for:
-     - Managing goroutine state
-     - Storing timers/channels
-     - Tracking subscriptions
-     - Holding complex state structures
-   - Unlike React, this ref CANNOT be set as the ref prop on an element
-
-   ```go
-   timerRef := app.UseRef(&TimerState{
-       done: make(chan bool),
-   })
-   ```
-
-3. app.UseVDomRef - For accessing DOM elements directly:
-   - Creates refs for DOM interaction
-   - Useful for:
-     - Accessing DOM element properties
-     - Managing focus
-     - Measuring elements
-     - Direct DOM manipulation when needed
-   - These ref objects SHOULD be set as ref prop on elements.
-   ```go
-   inputRef := app.UseVDomRef()
-   vdom.H("input", map[string]any{
-       "ref": inputRef,
-       "type": "text",
-   })
-   ```
-
-Best Practices:
-
-- Use app.UseLocal for all UI state - use .Get() for reading and .Set()/.SetFn() for updating
-- Use functional setter when updating state from goroutines or based on current value
-- Use app.UseRef for complex state that goroutines need to access
-- Always clean up timers, channels, and goroutines in app.UseEffect cleanup functions
-
-## State Management and Async Updates
-
-For global state management, use the atoms system (SharedAtom, Config, or Data as appropriate). This provides global reactive state that components can subscribe to:
+**Key Points:**
+
+- Changes to ref.Current don't trigger re-renders
+- Perfect for storing goroutine state, timers, subscriptions
+- Cannot be used as the ref prop on DOM elements
+
+### DOM References with app.UseVDomRef
+
+app.UseVDomRef provides access to DOM elements, similar to React's useRef for DOM references. Use it when you need direct DOM manipulation:
 
 ```go
-type Todo struct {
-	Id   int    `json:"id"`
-	Text string `json:"text"`
-	Done bool   `json:"done"`
-}
+var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
+    inputRef := app.UseVDomRef()
 
-// For async operations, consider using a state struct
-type TimerState struct {
-	ticker   *time.Ticker
-	done     chan bool
-	isActive bool
-}
+    focusInput := func() {
+        // Access DOM element properties/methods
+        if inputRef.Current != nil {
+            inputRef.Current.Focus()
+        }
+    }
 
-// Declare global atoms as package variables
-var (
-	todosAtom  = app.DataAtom("todos", []Todo{})
-	filterAtom = app.ConfigAtom("filter", "")
-)
+    return vdom.H("div", nil,
+        vdom.H("input", map[string]any{
+            "ref":  inputRef, // Attach ref to DOM element
+            "type": "text",
+        }),
+        vdom.H("button", map[string]any{
+            "onClick": focusInput,
+        }, "Focus Input"),
+    )
+})
+```
 
-var TodoApp = app.DefineComponent("TodoApp", func(_ struct{}) any {
-	// Local state for async timer demo
-	seconds := app.UseLocal(0)
+**Use Cases:**
 
-	// Use refs to store complex state that goroutines need to access
-	stateRef := app.UseRef(&TimerState{
-		done: make(chan bool),
-	})
+- Managing focus programmatically
+- Measuring element dimensions
+- Direct DOM manipulation when needed
+- Integration with third-party DOM libraries
 
-	// Example of safe goroutine management
-	startAsync := func() {
-		if stateRef.Current.isActive {
-			return // Prevent multiple goroutines
-		}
+### Utility Hooks
 
-		stateRef.Current.isActive = true
-		go func() {
-			defer func() {
-				stateRef.Current.isActive = false
-			}()
-
-			// Use channels for cleanup
-			for {
-				select {
-				case <-stateRef.Current.done:
-					return
-				case <-time.After(time.Second):
-					// Use functional updates for state that depends on current value
-					seconds.SetFn(func(s int) int {
-						return s + 1
-					})
-					// Notify UI of update
-					app.SendAsyncInitiation()
-				}
-			}
-		}()
-	}
+**app.UseSetAppTitle** - Sets the application window title:
 
-	// Always clean up goroutines
-	stopAsync := func() {
-		if stateRef.Current.isActive {
-			close(stateRef.Current.done)
-			stateRef.Current.done = make(chan bool)
-		}
-	}
+```go
+var App = app.DefineComponent("App", func(_ struct{}) any {
+    app.UseSetAppTitle("My Tsunami App")
+    // Only works in the top-level App component
+    return vdom.H("div", nil, "Hello World")
+})
+```
 
-	// Use app.UseEffect for cleanup on unmount
-	app.UseEffect(func() func() {
-		startAsync() // Start the timer when component mounts
-		return func() {
-			stopAsync()
-		}
-	}, []any{})
-
-	addTodo := func(text string) {
-		currentTodos := todosAtom.Get()
-		newTodo := Todo{
-			Id:   len(currentTodos) + 1,
-			Text: text,
-			Done: false,
-		}
-		todosAtom.Set(append(currentTodos, newTodo))
-	}
+**Specialty Hooks** (rarely needed):
 
-	// Read atom values in render code
-	todos := todosAtom.Get()
-	filter := filterAtom.Get()
-	currentSeconds := seconds.Get()
+- `app.UseId()` - Unique component identifier
+- `app.UseRenderTs()` - Current render timestamp
+- `app.UseResync()` - Whether this is a resync render
 
-	return vdom.H("div", map[string]any{"className": "todo-app"},
-		vdom.H("h1", nil, "Todo App"),
-		vdom.H("p", nil, "Timer: ", currentSeconds, " seconds"),
-		vdom.H("input", map[string]any{
-			"placeholder": "Filter todos...",
-			"value":       filter,
-			"onChange":    func(e vdom.VDomEvent) { filterAtom.Set(e.TargetValue) },
-		}),
-		vdom.H("button", map[string]any{
-			"onClick": func() { addTodo("New todo") },
-		}, "Add Todo"),
-		vdom.ForEach(todos, func(todo Todo, idx int) any {
-			// Only show todos that contain the filter text
-			if filter != "" && !strings.Contains(strings.ToLower(todo.Text), strings.ToLower(filter)) {
-				return nil
-			}
-			return vdom.H("div", map[string]any{
-				"key":       todo.Id,
-				"className": "todo-item",
-			},
-				vdom.H("span", nil, todo.Text),
-			)
-		}),
-	)
+## Best Practices
+
+- **Effects**: Always include proper dependency arrays to avoid infinite loops
+- **Cleanup**: Return cleanup functions from effects for timers, subscriptions, goroutines
+- **Refs**: Use app.UseRef for goroutine communication, app.UseVDomRef for DOM access
+- **Async Updates**: Call app.SendAsyncInitiation after updating atoms from goroutines
+- **Performance**: Don't overuse effects - most logic should be in event handlers
+
+## Async Operations and Goroutines
+
+When working with goroutines, timers, or other async operations in Tsunami, follow these patterns to safely update state and manage cleanup:
+
+### Goroutine State Management
+
+Use app.UseRef for data that goroutines need to access but shouldn't trigger re-renders (like channels, flags, or complex state). Use atoms when you want goroutine updates to trigger UI re-renders:
+
+```go
+type TimerState struct {
+    done     chan bool
+    isActive bool
+}
+
+var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
+    seconds := app.UseLocal(0)
+
+    // Store goroutine state in a ref
+    timerRef := app.UseRef(&TimerState{
+        done: make(chan bool),
+    })
+
+    startTimer := func() {
+        if timerRef.Current.isActive {
+            return // Prevent multiple goroutines
+        }
+
+        timerRef.Current.isActive = true
+        go func() {
+            defer func() {
+                timerRef.Current.isActive = false
+            }()
+
+            for {
+                select {
+                case <-timerRef.Current.done:
+                    return
+                case <-time.After(time.Second):
+                    // Update state from goroutine
+                    seconds.SetFn(func(s int) int { return s + 1 })
+                    app.SendAsyncInitiation() // Trigger UI update
+                }
+            }
+        }()
+    }
+
+    // Start timer on mount and cleanup on unmount
+    app.UseEffect(func() func() {
+        startTimer() // Start the timer when component mounts
+        return func() {
+            if timerRef.Current.isActive {
+                close(timerRef.Current.done)
+            }
+        }
+    }, []any{})
+
+    return vdom.H("div", nil, "Seconds: ", seconds.Get())
 })
 ```
 
-Key points for state management:
+### Key Patterns
+
+**app.SendAsyncInitiation()**: Call this after updating atoms from goroutines to trigger UI re-renders. Don't call it at high frequency - consider batching updates.
+
+**Functional setters in goroutines**: Always use atom.SetFn() when updating state from goroutines to avoid race conditions:
+
+```go
+// Safe: uses current value
+count.SetFn(func(current int) int { return current + 1 })
+
+// Risky: might use stale value
+count.Set(count.Get() + 1)
+```
+
+**Cleanup channels**: Use channels and select statements for clean goroutine shutdown. Always clean up in app.UseEffect return functions.
+
+**Prevent duplicate goroutines**: Use ref state to track if async operations are already running.
+
+### Thread Safety
+
+Atoms are internally synchronized, so multiple goroutines can safely call Get() and Set() on the same atom. However, never mutate data returned from atom.Get() - always use app.DeepCopy() for modifications:
+
+```go
+// Safe pattern for concurrent updates using SetFn
+updateTodos := func() {
+    todosAtom.SetFn(func(current []Todo) []Todo {
+        todosCopy := app.DeepCopy(current)
+        return append(todosCopy, newTodo)
+    })
+}
+```
 
-- Global state is fine for simple data structures
-- Use functional setter when updating state based on its current value, especially in goroutines
-- Store complex state in refs when it needs to be accessed by goroutines
-- Use app.UseEffect cleanup function to handle component unmount
-- Call app.SendAsyncInitiation after state changes in goroutines (consider round trip performance, so don't call at very high speeds)
-- Use atomic operations if globals are modified from multiple goroutines (or locks)
+Atoms handle the synchronization internally, so you don't need additional locking for basic read/write operations.
 
 ## Global Keyboard Handling
 

From db74ad9e13a1d480ca9313773becb7f1744796f8 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 12:46:32 -0700
Subject: [PATCH 098/134] add UseGoRoutine

---
 tsunami/app/hooks.go      | 36 ++++++++++++++++
 tsunami/prompts/system.md | 87 ++++++++++++++++++---------------------
 2 files changed, 75 insertions(+), 48 deletions(-)

diff --git a/tsunami/app/hooks.go b/tsunami/app/hooks.go
index 3a49fb9c8d..325fad4df0 100644
--- a/tsunami/app/hooks.go
+++ b/tsunami/app/hooks.go
@@ -4,6 +4,8 @@
 package app
 
 import (
+	"context"
+
 	"github.com/wavetermdev/waveterm/tsunami/engine"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
@@ -138,3 +140,37 @@ func UseLocal[T any](initialVal T) Atom[T] {
 		client: engine.GetDefaultClient(),
 	}
 }
+
+// UseGoRoutine manages a goroutine lifecycle within a component.
+// It spawns a new goroutine with the provided function when dependencies change,
+// and automatically cancels the context on dependency changes or component unmount.
+// This hook must be called within a component context.
+func UseGoRoutine(fn func(ctx context.Context), deps []any) {
+	rc := engine.GetGlobalContext()
+	if rc == nil {
+		panic("UseGoRoutine must be called within a component (no context)")
+	}
+
+	// Use UseRef to store the cancel function
+	cancelRef := UseRef[context.CancelFunc](nil)
+
+	UseEffect(func() func() {
+		// Cancel any existing goroutine
+		if cancelRef.Current != nil {
+			cancelRef.Current()
+		}
+
+		// Create new context and start goroutine
+		ctx, cancel := context.WithCancel(context.Background())
+		cancelRef.Current = cancel
+
+		go fn(ctx)
+
+		// Return cleanup function that cancels the context
+		return func() {
+			if cancel != nil {
+				cancel()
+			}
+		}
+	}, deps)
+}
diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 3078af636d..da031fdb1a 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -256,6 +256,7 @@ var MyComponent = app.DefineComponent("MyComponent", func(props MyProps) any {
 
 - **State Management**: app.UseLocal creates local component atoms (covered in State Management with Atoms)
 - **Component Lifecycle**: app.UseEffect, app.UseRef, app.UseVDomRef (covered in Component Lifecycle Hooks)
+- **Async Operations**: app.UseGoRoutine manages goroutine lifecycle (covered in Async Operations and Goroutines)
 - **Utility**: app.UseSetAppTitle, app.UseId, app.UseRenderTs, app.UseResync
 
 ## State Management with Atoms
@@ -782,67 +783,61 @@ var App = app.DefineComponent("App", func(_ struct{}) any {
 
 When working with goroutines, timers, or other async operations in Tsunami, follow these patterns to safely update state and manage cleanup:
 
-### Goroutine State Management
+### Goroutine Management
 
-Use app.UseRef for data that goroutines need to access but shouldn't trigger re-renders (like channels, flags, or complex state). Use atoms when you want goroutine updates to trigger UI re-renders:
+For async operations like timers, background tasks, or data polling, use app.UseGoRoutine to safely manage goroutine lifecycle:
 
 ```go
-type TimerState struct {
-    done     chan bool
-    isActive bool
-}
-
 var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
     seconds := app.UseLocal(0)
 
-    // Store goroutine state in a ref
-    timerRef := app.UseRef(&TimerState{
-        done: make(chan bool),
-    })
-
-    startTimer := func() {
-        if timerRef.Current.isActive {
-            return // Prevent multiple goroutines
-        }
-
-        timerRef.Current.isActive = true
-        go func() {
-            defer func() {
-                timerRef.Current.isActive = false
-            }()
-
-            for {
-                select {
-                case <-timerRef.Current.done:
-                    return
-                case <-time.After(time.Second):
-                    // Update state from goroutine
-                    seconds.SetFn(func(s int) int { return s + 1 })
-                    app.SendAsyncInitiation() // Trigger UI update
-                }
+    timerFn := func(ctx context.Context) {
+        for {
+            select {
+            case <-ctx.Done():
+                return
+            case <-time.After(time.Second):
+                // Update state from goroutine
+                seconds.SetFn(func(s int) int { return s + 1 })
+                app.SendAsyncInitiation() // Trigger UI update
             }
-        }()
+        }
     }
 
-    // Start timer on mount and cleanup on unmount
-    app.UseEffect(func() func() {
-        startTimer() // Start the timer when component mounts
-        return func() {
-            if timerRef.Current.isActive {
-                close(timerRef.Current.done)
-            }
-        }
-    }, []any{})
+    // Start timer on mount, cleanup on unmount
+    app.UseGoRoutine(timerFn, []any{})
 
     return vdom.H("div", nil, "Seconds: ", seconds.Get())
 })
 ```
 
+app.UseGoRoutine handles the complex lifecycle automatically:
+
+- Spawns a new goroutine with your function
+- Provides a context that cancels on dependency changes or component unmount
+- Prevents goroutine leaks through automatic cleanup
+- Cancels existing goroutines before starting new ones when dependencies change
+
 ### Key Patterns
 
-**app.SendAsyncInitiation()**: Call this after updating atoms from goroutines to trigger UI re-renders. Don't call it at high frequency - consider batching updates.
+**Context cancellation**: Always check ctx.Done() in your goroutine loops for clean shutdown:
 
-**Functional setters in goroutines**: Always use atom.SetFn() when updating state from goroutines to avoid race conditions:
+```go
+pollData := func(ctx context.Context) {
+    for {
+        select {
+        case <-ctx.Done():
+            return // Clean exit when component unmounts or deps change
+        case <-time.After(5 * time.Second):
+            // Do work
+        }
+    }
+}
+```
+
+**app.SendAsyncInitiation()**: Call this after updating atoms from goroutines to trigger UI re-renders. Don't call at high frequency - consider batching updates.
+
+**Functional setters**: Always use atom.SetFn() when updating state from goroutines to avoid race conditions:
 
 ```go
 // Safe: uses current value
@@ -852,10 +847,6 @@ count.SetFn(func(current int) int { return current + 1 })
 count.Set(count.Get() + 1)
 ```
 
-**Cleanup channels**: Use channels and select statements for clean goroutine shutdown. Always clean up in app.UseEffect return functions.
-
-**Prevent duplicate goroutines**: Use ref state to track if async operations are already running.
-
 ### Thread Safety
 
 Atoms are internally synchronized, so multiple goroutines can safely call Get() and Set() on the same atom. However, never mutate data returned from atom.Get() - always use app.DeepCopy() for modifications:

From 8234325ea74229d763ef905b460c1e737cefb6b6 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 13:13:16 -0700
Subject: [PATCH 099/134] more system prompt updates

---
 tsunami/prompts/system.md | 166 +++++++++++++++++++++++++++++---------
 1 file changed, 127 insertions(+), 39 deletions(-)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index da031fdb1a..3fda5c57d1 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -74,6 +74,16 @@ Key Points:
 - Uses Tailwind v4 for styling - you can use any Tailwind classes in your components.
 - Use React-style camel case props (`className`, `onClick`)
 
+## Quick Reference
+
+- Component: app.DefineComponent("Name", func(props PropsType) any { ... })
+- Element: vdom.H("div", map[string]any{"className": "..."}, children...)
+- Local state: atom := app.UseLocal(initialValue); atom.Get(); atom.Set(value)
+- Event handler: "onClick": func() { ... }
+- Conditional: vdom.If(condition, element)
+- Lists: vdom.ForEach(items, func(item, idx) any { return ... })
+- Styling: "className": vdom.Classes("bg-gray-900 text-white p-4", vdom.If(cond, "bg-blue-800")) // Tailwind + dark mode
+
 ## Building Elements with vdom.H
 
 The vdom.H function creates virtual DOM elements following a React-like pattern (React.createElement). It takes a tag name, a props map, and any number of children:
@@ -220,7 +230,6 @@ Helper functions:
 - `vdom.Ternary[T any](cond bool, trueRtn T, falseRtn T) T` - Type-safe ternary operation, returns trueRtn if condition is true, falseRtn otherwise
 - `vdom.ForEach[T any](items []T, fn func(T, int) any) []any` - Maps over items with index, function receives item and index
 - `vdom.Classes(classes ...any) string` - Combines multiple class values into a single space-separated string, similar to JavaScript clsx library (accepts string, []string, and map[string]bool params)
-- `app.DeepCopy[T any](value T) T` - Creates a deep copy of slices, maps, and other complex types for safe state updates
 
 - The vdom.If and vdom.IfElse functions can be used for both conditional rendering of elements, conditional classes, and conditional props.
 - For vdom.If and vdom.IfElse, always follow the pattern of condition first (bool), then value(s).
@@ -353,6 +362,65 @@ var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
 })
 ```
 
+**Never mutate values from Get()**: For complex data types, never modify the value returned from `atom.Get()`. Always use `app.DeepCopy()` before mutations:
+
+```go
+var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
+    todos := app.UseLocal([]Todo{{Text: "Learn Tsunami"}})
+
+    addTodo := func() {
+        // ✅ Correct: Copy before modifying
+        todos.SetFn(func(current []Todo) []Todo {
+            todosCopy := app.DeepCopy(current)
+            return append(todosCopy, Todo{Text: "New task"})
+        })
+    }
+
+    // ❌ Wrong: Never mutate the original
+    // badUpdate := func() {
+    //     current := todos.Get()
+    //     current[0].Text = "Modified" // Dangerous mutation!
+    //     todos.Set(current)
+    // }
+
+    return vdom.H("div", nil, "Todo count: ", len(todos.Get()))
+})
+```
+
+**Capture atoms, not values**: In closures and async code, always capture the atom itself, never captured values from render:
+
+```go
+var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
+    count := app.UseLocal(0)
+    currentCount := count.Get() // Read in render
+
+    // ✅ Correct: Capture the atom
+    handleDelayedIncrement := func() {
+        time.AfterFunc(time.Second, func() {
+            count.SetFn(func(current int) int { return current + 1 })
+        })
+    }
+
+    // ❌ Wrong: Capturing stale value from render
+    // handleStaleIncrement := func() {
+    //     time.AfterFunc(time.Second, func() {
+    //         count.Set(currentCount + 1) // Uses stale currentCount!
+    //     })
+    // }
+
+    return vdom.H("button", map[string]any{
+        "onClick": handleDelayedIncrement,
+    }, "Count: ", currentCount)
+})
+```
+
+**Key Points:**
+
+- Use `app.DeepCopy(value)` before modifying complex data from `atom.Get()`
+- Always capture atoms in closures, never captured render values
+- This prevents stale closures and shared reference bugs
+- `app.DeepCopy[T any](value T) T` works with slices, maps, structs, and nested combinations
+
 ### Local State with app.UseLocal
 
 For component-specific state, use app.UseLocal:
@@ -677,38 +745,26 @@ app.UseRef creates mutable values that persist across renders without triggering
 
 ```go
 var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
-    // Store complex state that goroutines need to access
-    timerRef := app.UseRef(&TimerState{
-        active: false,
-        done:   make(chan bool),
-    })
-
     // Count renders without triggering re-renders
     renderCount := app.UseRef(0)
     renderCount.Current++
 
-    startTimer := func() {
-        if timerRef.Current.active {
-            return
-        }
+    // Store previous values for comparison
+    prevCount := app.UseRef(0)
+    count := app.UseLocal(0)
 
-        timerRef.Current.active = true
-        go func() {
-            // Goroutine can safely access ref
-            for timerRef.Current.active {
-                time.Sleep(time.Second)
-                // Update UI state from goroutine
-                // count.Set(someValue)
-                app.SendAsyncInitiation()
-            }
-        }()
+    currentCount := count.Get()
+    if prevCount.Current != currentCount {
+        fmt.Printf("Count changed from %d to %d\n", prevCount.Current, currentCount)
+        prevCount.Current = currentCount
     }
 
     return vdom.H("div", nil,
         vdom.H("p", nil, "Render #", renderCount.Current),
+        vdom.H("p", nil, "Count: ", currentCount),
         vdom.H("button", map[string]any{
-            "onClick": startTimer,
-        }, "Start Timer"),
+            "onClick": func() { count.Set(currentCount + 1) },
+        }, "Increment"),
     )
 })
 ```
@@ -943,6 +999,19 @@ Key points:
 - Content-Type is automatically detected for static files
 - For dynamic handlers, set Content-Type explicitly when needed
 
+## CRITICAL RULES (Must Follow)
+
+### Hooks (Same as React)
+
+- ✅ Only call hooks at component top level, before any returns
+- ❌ Never call hooks in loops, conditions, or after early returns
+
+### Atoms (Tsunami-specific)
+
+- ✅ Read with atom.Get() in render code
+- ❌ Never call atom.Set() in render code - only in handlers/effects
+- ✅ Always use SetFn() for concurrent updates from goroutines
+
 ## Tsunami App Template
 
 ```go
@@ -1020,18 +1089,18 @@ var App = app.DefineComponent("App", func(_ struct{}) any {
 		inputText.Set("")
 	}
 
-	toggleTodo := func(id int) {
-		currentTodos := todos.Get()
-		newTodos := make([]Todo, len(currentTodos))
-		copy(newTodos, currentTodos)
-		for i := range newTodos {
-			if newTodos[i].Id == id {
-				newTodos[i].Completed = !newTodos[i].Completed
-				break
-			}
-		}
-		todos.Set(newTodos)
-	}
+    toggleTodo := func(id int) {
+        todos.SetFn(func(current []Todo) []Todo {
+            todosCopy := app.DeepCopy(current)
+            for i := range todosCopy {
+                if todosCopy[i].Id == id {
+                    todosCopy[i].Completed = !todosCopy[i].Completed
+                    break
+                }
+            }
+            return todosCopy
+        })
+    }
 
 	deleteTodo := func(id int) {
 		currentTodos := todos.Get()
@@ -1093,15 +1162,29 @@ Key points:
 3. Do NOT write a main() function - the framework handles app lifecycle
 4. Use init() for setup like registering dynamic handlers with app.HandleDynFunc
 
+## Common Mistakes to Avoid
+
+1. **Calling Set in render**: `countAtom.Set(42)` in component body causes infinite loops
+2. **Missing keys in lists**: Always use `.WithKey(id)` for list items
+3. **Stale closures in goroutines**: Use `atom.Get()` inside event handlers, effects, and goroutines, not captured values
+4. **Wrong prop format**: Use `"className"` not `"class"`, `"onClick"` not `"onclick"` (matching React prop and style names)
+5. **Mutating state**: Always create new slices/objects when updating atoms (can use app.DeepCopy helper)
+
+## Styling Requirements
+
+**IMPORTANT**: Tsunami apps run in Wave Terminal (dark mode). Always use dark-friendly styles:
+
+- ✅ `"bg-gray-900 text-white"`
+- ✅ `"bg-slate-800 border-gray-600"`
+- ❌ `"bg-white text-black"` (avoid light backgrounds)
+
 ## Important Technical Details
 
 - Props must be defined as Go structs with json tags
-- Components take their props type directly.
+- Components take their props type directly as a parameter
 - Always use app.DefineComponent for component registration
-- Call app.SendAsyncInitiation after async state updates
 - Provide keys when using vdom.ForEach with lists (using WithKey method)
 - Use vdom.Classes with vdom.If for combining static and conditional class names
-- Consider cleanup functions in app.UseEffect for async operations
 - `<script>` tags are NOT supported
 - Applications consist of a single file: app.go containing all Go code and component definitions
 - Styling is handled through Tailwind v4 CSS classes
@@ -1110,4 +1193,9 @@ Key points:
 - This is a pure Go system - do not attempt to write React components or JavaScript code
 - All UI rendering, including complex visualizations, should be done through Go using vdom.H
 
-The todo demo demonstrates all these patterns in a complete application.
+**Async Operation Guidelines**
+
+- Use app.UseGoRoutine instead of raw go statements for component-related async work
+- Always respect ctx.Done() in app.UseGoRoutine functions to prevent goroutine leaks
+- Use app.UseEffect with cleanup functions for subscriptions, timers, and other lifecycle management
+- Call app.SendAsyncInitiation after state updates to trigger re-rendering

From 77f8a00e1cdf89a0147b52f4c1f1ae83c368c3c8 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 14:22:44 -0700
Subject: [PATCH 100/134] more prompt updates.  migrate cpuchart

---
 tsunami/demo/cpuchart/app.go | 525 +++++++++++++++++------------------
 tsunami/prompts/system.md    |  96 ++++++-
 2 files changed, 349 insertions(+), 272 deletions(-)

diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
index b0fb552ccf..ee6f2e2f8a 100644
--- a/tsunami/demo/cpuchart/app.go
+++ b/tsunami/demo/cpuchart/app.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"log"
 	"time"
 
@@ -33,6 +34,10 @@ type CPUDataPoint struct {
 	Timestamp string   `json:"timestamp"` // Human readable timestamp
 }
 
+type StatsPanelProps struct {
+	Data []CPUDataPoint `json:"data"`
+}
+
 func collectCPUUsage() (float64, error) {
 	percentages, err := cpu.Percent(time.Second, false)
 	if err != nil {
@@ -62,323 +67,309 @@ func generateCPUDataPoint() CPUDataPoint {
 	return dataPoint
 }
 
-var StatsPanel = app.DefineComponent("StatsPanel",
-	func(props struct {
-		Data []CPUDataPoint `json:"data"`
-	}) any {
-		var currentUsage float64
-		var avgUsage float64
-		var maxUsage float64
-		var validCount int
+var StatsPanel = app.DefineComponent("StatsPanel", func(props StatsPanelProps) any {
+	var currentUsage float64
+	var avgUsage float64
+	var maxUsage float64
+	var validCount int
 
-		if len(props.Data) > 0 {
-			lastPoint := props.Data[len(props.Data)-1]
-			if lastPoint.CPUUsage != nil {
-				currentUsage = *lastPoint.CPUUsage
-			}
+	if len(props.Data) > 0 {
+		lastPoint := props.Data[len(props.Data)-1]
+		if lastPoint.CPUUsage != nil {
+			currentUsage = *lastPoint.CPUUsage
+		}
 
-			// Calculate average and max from non-nil values
-			total := 0.0
-			for _, point := range props.Data {
-				if point.CPUUsage != nil {
-					total += *point.CPUUsage
-					validCount++
-					if *point.CPUUsage > maxUsage {
-						maxUsage = *point.CPUUsage
-					}
+		// Calculate average and max from non-nil values
+		total := 0.0
+		for _, point := range props.Data {
+			if point.CPUUsage != nil {
+				total += *point.CPUUsage
+				validCount++
+				if *point.CPUUsage > maxUsage {
+					maxUsage = *point.CPUUsage
 				}
 			}
-			if validCount > 0 {
-				avgUsage = total / float64(validCount)
-			}
 		}
+		if validCount > 0 {
+			avgUsage = total / float64(validCount)
+		}
+	}
 
-		return vdom.H("div", map[string]any{
-			"className": "bg-gray-800 rounded-lg p-4 mb-6",
+	return vdom.H("div", map[string]any{
+		"className": "bg-gray-800 rounded-lg p-4 mb-6",
+	},
+		vdom.H("h3", map[string]any{
+			"className": "text-lg font-semibold text-white mb-3",
+		}, "CPU Statistics"),
+		vdom.H("div", map[string]any{
+			"className": "grid grid-cols-3 gap-4",
 		},
-			vdom.H("h3", map[string]any{
-				"className": "text-lg font-semibold text-white mb-3",
-			}, "CPU Statistics"),
+			// Current Usage
 			vdom.H("div", map[string]any{
-				"className": "grid grid-cols-3 gap-4",
+				"className": "bg-gray-700 rounded p-3",
 			},
-				// Current Usage
 				vdom.H("div", map[string]any{
-					"className": "bg-gray-700 rounded p-3",
-				},
-					vdom.H("div", map[string]any{
-						"className": "text-sm text-gray-400 mb-1",
-					}, "Current"),
-					vdom.H("div", map[string]any{
-						"className": "text-2xl font-bold text-blue-400",
-					}, vdom.H("span", nil, int(currentUsage+0.5), "%")),
-				),
-				// Average Usage
+					"className": "text-sm text-gray-400 mb-1",
+				}, "Current"),
 				vdom.H("div", map[string]any{
-					"className": "bg-gray-700 rounded p-3",
-				},
-					vdom.H("div", map[string]any{
-						"className": "text-sm text-gray-400 mb-1",
-					}, "Average"),
-					vdom.H("div", map[string]any{
-						"className": "text-2xl font-bold text-green-400",
-					}, vdom.H("span", nil, int(avgUsage+0.5), "%")),
-				),
-				// Max Usage
+					"className": "text-2xl font-bold text-blue-400",
+				}, vdom.H("span", nil, int(currentUsage+0.5), "%")),
+			),
+			// Average Usage
+			vdom.H("div", map[string]any{
+				"className": "bg-gray-700 rounded p-3",
+			},
 				vdom.H("div", map[string]any{
-					"className": "bg-gray-700 rounded p-3",
-				},
-					vdom.H("div", map[string]any{
-						"className": "text-sm text-gray-400 mb-1",
-					}, "Peak"),
-					vdom.H("div", map[string]any{
-						"className": "text-2xl font-bold text-red-400",
-					}, vdom.H("span", nil, int(maxUsage+0.5), "%")),
-				),
+					"className": "text-sm text-gray-400 mb-1",
+				}, "Average"),
+				vdom.H("div", map[string]any{
+					"className": "text-2xl font-bold text-green-400",
+				}, vdom.H("span", nil, int(avgUsage+0.5), "%")),
 			),
-		)
-	},
+			// Max Usage
+			vdom.H("div", map[string]any{
+				"className": "bg-gray-700 rounded p-3",
+			},
+				vdom.H("div", map[string]any{
+					"className": "text-sm text-gray-400 mb-1",
+				}, "Peak"),
+				vdom.H("div", map[string]any{
+					"className": "text-2xl font-bold text-red-400",
+				}, vdom.H("span", nil, int(maxUsage+0.5), "%")),
+			),
+		),
+	)
+},
 )
 
-var App = app.DefineComponent("App",
-	func(_ struct{}) any {
-		app.UseSetAppTitle("CPU Usage Monitor")
-
-		// Local state for forcing re-renders
-		_, _, setTickerFn := app.UseState(0)
-
-		// Timer effect for continuous CPU data collection
-		app.UseEffect(func() func() {
-			ticker := time.NewTicker(1 * time.Second)
-			done := make(chan bool)
-
-			go func() {
-				for {
-					select {
-					case <-done:
-						return
-					case <-ticker.C:
-						// Collect new CPU data point and shift the data window
-						cpuDataAtom.SetFn(func(currentData []CPUDataPoint) []CPUDataPoint {
-							newPoint := generateCPUDataPoint()
-							currentDataPointCount := dataPointCountAtom.Get()
+var App = app.DefineComponent("App", func(_ struct{}) any {
+	app.UseSetAppTitle("CPU Usage Monitor")
 
-							// Make a safe copy to avoid mutation issues
-							data := app.DeepCopy(currentData)
+	// Timer function for continuous CPU data collection
+	timerFn := func(ctx context.Context) {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-time.After(time.Second):
+				// Collect new CPU data point and shift the data window
+				cpuDataAtom.SetFn(func(currentData []CPUDataPoint) []CPUDataPoint {
+					newPoint := generateCPUDataPoint()
+					currentDataPointCount := dataPointCountAtom.Get()
 
-							// Ensure we have the right size array
-							if len(data) != currentDataPointCount {
-								// Resize array if config changed
-								resized := make([]CPUDataPoint, currentDataPointCount)
-								copyCount := currentDataPointCount
-								if len(data) < copyCount {
-									copyCount = len(data)
-								}
-								if copyCount > 0 {
-									copy(resized[currentDataPointCount-copyCount:], data[len(data)-copyCount:])
-								}
-								data = resized
-							}
+					// Make a safe copy to avoid mutation issues
+					data := app.DeepCopy(currentData)
 
-							// Append new point and keep only the last currentDataPointCount elements
-							data = append(data, newPoint)
-							if len(data) > currentDataPointCount {
-								data = data[len(data)-currentDataPointCount:]
-							}
-							return data
-						})
-						// Trigger a re-render
-						setTickerFn(func(t int) int { return t + 1 })
-						app.SendAsyncInitiation()
+					// Ensure we have the right size array
+					if len(data) != currentDataPointCount {
+						// Resize array if config changed
+						resized := make([]CPUDataPoint, currentDataPointCount)
+						copyCount := currentDataPointCount
+						if len(data) < copyCount {
+							copyCount = len(data)
+						}
+						if copyCount > 0 {
+							copy(resized[currentDataPointCount-copyCount:], data[len(data)-copyCount:])
+						}
+						data = resized
 					}
-				}
-			}()
 
-			return func() {
-				ticker.Stop()
-				close(done)
+					// Append new point and keep only the last currentDataPointCount elements
+					data = append(data, newPoint)
+					if len(data) > currentDataPointCount {
+						data = data[len(data)-currentDataPointCount:]
+					}
+					return data
+				})
+				app.SendAsyncInitiation()
 			}
-		}, []any{})
+		}
+	}
 
-		handleClear := func() {
-			// Reset with empty data points based on current config
-			currentDataPointCount := dataPointCountAtom.Get()
-			initialData := make([]CPUDataPoint, currentDataPointCount)
-			for i := range initialData {
-				initialData[i] = CPUDataPoint{
-					Time:      0,
-					CPUUsage:  nil,
-					Timestamp: "",
-				}
+	// Use UseGoRoutine for managed goroutine lifecycle
+	app.UseGoRoutine(timerFn, []any{})
+
+	handleClear := func() {
+		// Reset with empty data points based on current config
+		currentDataPointCount := dataPointCountAtom.Get()
+		initialData := make([]CPUDataPoint, currentDataPointCount)
+		for i := range initialData {
+			initialData[i] = CPUDataPoint{
+				Time:      0,
+				CPUUsage:  nil,
+				Timestamp: "",
 			}
-			cpuDataAtom.Set(initialData)
 		}
+		cpuDataAtom.Set(initialData)
+	}
 
-		return vdom.H("div", map[string]any{
-			"className": "min-h-screen bg-gray-900 text-white p-6",
+	// Read atom values once for rendering
+	cpuData := cpuDataAtom.Get()
+	dataPointCount := dataPointCountAtom.Get()
+
+	return vdom.H("div", map[string]any{
+		"className": "min-h-screen bg-gray-900 text-white p-6",
+	},
+		vdom.H("div", map[string]any{
+			"className": "max-w-6xl mx-auto",
 		},
+			// Header
 			vdom.H("div", map[string]any{
-				"className": "max-w-6xl mx-auto",
+				"className": "mb-8",
 			},
-				// Header
-				vdom.H("div", map[string]any{
-					"className": "mb-8",
-				},
-					vdom.H("h1", map[string]any{
-						"className": "text-3xl font-bold text-white mb-2",
-					}, "Real-Time CPU Usage Monitor"),
-					vdom.H("p", map[string]any{
-						"className": "text-gray-400",
-					}, "Live CPU usage data collected using gopsutil, displaying 60 seconds of history"),
-				),
+				vdom.H("h1", map[string]any{
+					"className": "text-3xl font-bold text-white mb-2",
+				}, "Real-Time CPU Usage Monitor"),
+				vdom.H("p", map[string]any{
+					"className": "text-gray-400",
+				}, "Live CPU usage data collected using gopsutil, displaying 60 seconds of history"),
+			),
 
-				// Controls
+			// Controls
+			vdom.H("div", map[string]any{
+				"className": "bg-gray-800 rounded-lg p-4 mb-6",
+			},
 				vdom.H("div", map[string]any{
-					"className": "bg-gray-800 rounded-lg p-4 mb-6",
+					"className": "flex items-center gap-4 flex-wrap",
 				},
+					// Clear button
+					vdom.H("button", map[string]any{
+						"className": "px-4 py-2 bg-gray-600 hover:bg-gray-700 text-white rounded-md text-sm font-medium transition-colors cursor-pointer",
+						"onClick":   handleClear,
+					}, "Clear Data"),
+
+					// Status indicator
 					vdom.H("div", map[string]any{
-						"className": "flex items-center gap-4 flex-wrap",
+						"className": "flex items-center gap-2",
 					},
-						// Clear button
-						vdom.H("button", map[string]any{
-							"className": "px-4 py-2 bg-gray-600 hover:bg-gray-700 text-white rounded-md text-sm font-medium transition-colors cursor-pointer",
-							"onClick":   handleClear,
-						}, "Clear Data"),
-
-						// Status indicator
 						vdom.H("div", map[string]any{
-							"className": "flex items-center gap-2",
-						},
-							vdom.H("div", map[string]any{
-								"className": "w-2 h-2 rounded-full bg-green-500",
-							}),
-							vdom.H("span", map[string]any{
-								"className": "text-sm text-gray-400",
-							}, "Live Monitoring"),
-							vdom.H("span", map[string]any{
-								"className": "text-sm text-gray-500 ml-2",
-							}, "(", len(cpuDataAtom.Get()), "/", dataPointCountAtom.Get(), " data points)"),
-						),
+							"className": "w-2 h-2 rounded-full bg-green-500",
+						}),
+						vdom.H("span", map[string]any{
+							"className": "text-sm text-gray-400",
+						}, "Live Monitoring"),
+						vdom.H("span", map[string]any{
+							"className": "text-sm text-gray-500 ml-2",
+						}, "(", len(cpuData), "/", dataPointCount, " data points)"),
 					),
 				),
+			),
 
-				// Statistics Panel
-				StatsPanel(struct {
-					Data []CPUDataPoint `json:"data"`
-				}{
-					Data: cpuDataAtom.Get(),
-				}),
+			// Statistics Panel
+			StatsPanel(StatsPanelProps{
+				Data: cpuData,
+			}),
 
-				// Main chart
+			// Main chart
+			vdom.H("div", map[string]any{
+				"className": "bg-gray-800 rounded-lg p-6 mb-6",
+			},
+				vdom.H("h2", map[string]any{
+					"className": "text-xl font-semibold text-white mb-4",
+				}, "CPU Usage Over Time"),
 				vdom.H("div", map[string]any{
-					"className": "bg-gray-800 rounded-lg p-6 mb-6",
+					"className": "w-full h-96",
 				},
-					vdom.H("h2", map[string]any{
-						"className": "text-xl font-semibold text-white mb-4",
-					}, "CPU Usage Over Time"),
-					vdom.H("div", map[string]any{
-						"className": "w-full h-96",
+					vdom.H("recharts:ResponsiveContainer", map[string]any{
+						"width":  "100%",
+						"height": "100%",
 					},
-						vdom.H("recharts:ResponsiveContainer", map[string]any{
-							"width":  "100%",
-							"height": "100%",
+						vdom.H("recharts:LineChart", map[string]any{
+							"data":              cpuData,
+							"isAnimationActive": false,
 						},
-							vdom.H("recharts:LineChart", map[string]any{
-								"data":              cpuDataAtom.Get(),
+							vdom.H("recharts:CartesianGrid", map[string]any{
+								"strokeDasharray": "3 3",
+								"stroke":          "#374151",
+							}),
+							vdom.H("recharts:XAxis", map[string]any{
+								"dataKey":  "timestamp",
+								"stroke":   "#9CA3AF",
+								"fontSize": 12,
+							}),
+							vdom.H("recharts:YAxis", map[string]any{
+								"domain":   []int{0, 100},
+								"stroke":   "#9CA3AF",
+								"fontSize": 12,
+							}),
+							vdom.H("recharts:Tooltip", map[string]any{
+								"labelStyle": map[string]any{
+									"color": "#374151",
+								},
+								"contentStyle": map[string]any{
+									"backgroundColor": "#1F2937",
+									"border":          "1px solid #374151",
+									"borderRadius":    "6px",
+									"color":           "#F3F4F6",
+								},
+							}),
+							vdom.H("recharts:Line", map[string]any{
+								"type":              "monotone",
+								"dataKey":           "cpuUsage",
+								"stroke":            "#3B82F6",
+								"strokeWidth":       2,
+								"dot":               false,
+								"name":              "CPU Usage (%)",
 								"isAnimationActive": false,
-							},
-								vdom.H("recharts:CartesianGrid", map[string]any{
-									"strokeDasharray": "3 3",
-									"stroke":          "#374151",
-								}),
-								vdom.H("recharts:XAxis", map[string]any{
-									"dataKey":  "timestamp",
-									"stroke":   "#9CA3AF",
-									"fontSize": 12,
-								}),
-								vdom.H("recharts:YAxis", map[string]any{
-									"domain":   []int{0, 100},
-									"stroke":   "#9CA3AF",
-									"fontSize": 12,
-								}),
-								vdom.H("recharts:Tooltip", map[string]any{
-									"labelStyle": map[string]any{
-										"color": "#374151",
-									},
-									"contentStyle": map[string]any{
-										"backgroundColor": "#1F2937",
-										"border":          "1px solid #374151",
-										"borderRadius":    "6px",
-										"color":           "#F3F4F6",
-									},
-								}),
-								vdom.H("recharts:Line", map[string]any{
-									"type":              "monotone",
-									"dataKey":           "cpuUsage",
-									"stroke":            "#3B82F6",
-									"strokeWidth":       2,
-									"dot":               false,
-									"name":              "CPU Usage (%)",
-									"isAnimationActive": false,
-								}),
-							),
+							}),
 						),
 					),
 				),
+			),
 
-				// Info section
-				vdom.H("div", map[string]any{
-					"className": "bg-blue-900 bg-opacity-50 border border-blue-700 rounded-lg p-4",
+			// Info section
+			vdom.H("div", map[string]any{
+				"className": "bg-blue-900 bg-opacity-50 border border-blue-700 rounded-lg p-4",
+			},
+				vdom.H("h3", map[string]any{
+					"className": "text-lg font-semibold text-blue-200 mb-2",
+				}, "Real-Time CPU Monitoring Features"),
+				vdom.H("ul", map[string]any{
+					"className": "space-y-2 text-blue-100",
 				},
-					vdom.H("h3", map[string]any{
-						"className": "text-lg font-semibold text-blue-200 mb-2",
-					}, "Real-Time CPU Monitoring Features"),
-					vdom.H("ul", map[string]any{
-						"className": "space-y-2 text-blue-100",
+					vdom.H("li", map[string]any{
+						"className": "flex items-start gap-2",
 					},
-						vdom.H("li", map[string]any{
-							"className": "flex items-start gap-2",
-						},
-							vdom.H("span", map[string]any{
-								"className": "text-blue-400 mt-1",
-							}, "•"),
-							"Live CPU usage data collected using github.com/shirou/gopsutil/v4",
-						),
-						vdom.H("li", map[string]any{
-							"className": "flex items-start gap-2",
-						},
-							vdom.H("span", map[string]any{
-								"className": "text-blue-400 mt-1",
-							}, "•"),
-							"Continuous monitoring with 1-second update intervals",
-						),
-						vdom.H("li", map[string]any{
-							"className": "flex items-start gap-2",
-						},
-							vdom.H("span", map[string]any{
-								"className": "text-blue-400 mt-1",
-							}, "•"),
-							"Rolling window of 60 seconds of historical data",
-						),
-						vdom.H("li", map[string]any{
-							"className": "flex items-start gap-2",
-						},
-							vdom.H("span", map[string]any{
-								"className": "text-blue-400 mt-1",
-							}, "•"),
-							"Real-time statistics: current, average, and peak usage",
-						),
-						vdom.H("li", map[string]any{
-							"className": "flex items-start gap-2",
-						},
-							vdom.H("span", map[string]any{
-								"className": "text-blue-400 mt-1",
-							}, "•"),
-							"Dark theme optimized for Wave Terminal",
-						),
+						vdom.H("span", map[string]any{
+							"className": "text-blue-400 mt-1",
+						}, "•"),
+						"Live CPU usage data collected using github.com/shirou/gopsutil/v4",
+					),
+					vdom.H("li", map[string]any{
+						"className": "flex items-start gap-2",
+					},
+						vdom.H("span", map[string]any{
+							"className": "text-blue-400 mt-1",
+						}, "•"),
+						"Continuous monitoring with 1-second update intervals",
+					),
+					vdom.H("li", map[string]any{
+						"className": "flex items-start gap-2",
+					},
+						vdom.H("span", map[string]any{
+							"className": "text-blue-400 mt-1",
+						}, "•"),
+						"Rolling window of 60 seconds of historical data",
+					),
+					vdom.H("li", map[string]any{
+						"className": "flex items-start gap-2",
+					},
+						vdom.H("span", map[string]any{
+							"className": "text-blue-400 mt-1",
+						}, "•"),
+						"Real-time statistics: current, average, and peak usage",
+					),
+					vdom.H("li", map[string]any{
+						"className": "flex items-start gap-2",
+					},
+						vdom.H("span", map[string]any{
+							"className": "text-blue-400 mt-1",
+						}, "•"),
+						"Dark theme optimized for Wave Terminal",
 					),
 				),
 			),
-		)
-	},
+		),
+	)
+},
 )
diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 3fda5c57d1..d9c5e1b42d 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -1,6 +1,8 @@
 # Tsunami Framework Guide
 
-The Tsunami framework brings React-style UI development to Go, letting you build rich graphical applications that run inside Wave Terminal. If you know React, you already understand Tsunami's core concepts - it uses the same patterns for components, props, hooks, state management, and styling, but implemented entirely in Go.
+The Tsunami framework brings React-style UI development to Go, letting you build rich graphical applications that run inside Wave Terminal. Tsunami is designed for quick, widget-like applications - think dashboards, utilities, and small tools rather than large monolithic apps. Everything lives in a single Go file to keep things simple and focused.
+
+If you know React, you already understand Tsunami's core concepts - it uses the same patterns for components, props, hooks, state management, and styling, but implemented entirely in Go.
 
 ## React Patterns in Go
 
@@ -526,6 +528,89 @@ ConfigAtom and DataAtom automatically create REST endpoints:
 
 This makes Tsunami applications naturally suitable for integration with external tools, monitoring systems, and AI agents that need to inspect or configure the application.
 
+## Component Code Conventions
+
+Tsunami follows specific patterns that make code predictable for both developers and AI code generation. Following these conventions ensures consistent, maintainable code and prevents common bugs.
+
+Always organize components in this exact order to prevent stale closure bugs and maintain clarity:
+
+```go
+type ToggleCounterProps struct {
+	Title string `json:"title"`
+}
+
+var ToggleCounter = app.DefineComponent("ToggleCounter", func(props ToggleCounterProps) any {
+	// 1. Atoms and Refs defined at the top
+	visibleAtom := app.UseLocal(true)
+	renderCountRef := app.UseRef(0)
+
+	// 2. Effects and GoRoutines next. Two steps, first define the function, then call the hook
+	//    Only closure atoms and refs, do not closure values (as they can be stale)
+	incrementCounterFn := func() func() {
+		renderCountRef.Current = renderCountRef.Current + 1
+		return nil
+	}
+	app.UseEffect(incrementCounterFn, []any{})
+
+	// 3. Event handlers (closure atoms, not values)
+	handleToggle := func() {
+		visibleAtom.SetFn(func(isVisible bool) bool { return !isVisible })
+	}
+
+	handleReset := func() {
+		renderCountRef.Current = 0
+		visibleAtom.Set(true)
+	}
+
+	// 4. Atom reads (fresh values right before render)
+	//    Read here to prevent accidentally using these values in the closures above
+	isVisible := visibleAtom.Get()
+	renderCount := renderCountRef.Current
+
+	// 5. Render (return statement)
+	return vdom.H("div", map[string]any{
+		"className": "p-4 border border-gray-300 rounded-lg",
+	},
+		vdom.H("h3", map[string]any{
+			"className": "text-lg font-bold mb-2",
+		}, props.Title),
+
+		vdom.H("div", map[string]any{
+			"className": "mb-4 space-x-2",
+		},
+			vdom.H("button", map[string]any{
+				"className": "px-3 py-1 bg-blue-500 text-white rounded cursor-pointer",
+				"onClick":   handleToggle,
+			}, vdom.IfElse(isVisible, "Hide", "Show")),
+
+			vdom.H("button", map[string]any{
+				"className": "px-3 py-1 bg-gray-500 text-white rounded cursor-pointer",
+				"onClick":   handleReset,
+			}, "Reset"),
+		),
+
+		vdom.H("div", map[string]any{
+			"className": vdom.Classes("p-3 bg-gray-100 rounded", vdom.If(!isVisible, "hidden")),
+		},
+			vdom.H("p", nil, "This content can be toggled!"),
+			vdom.H("p", map[string]any{
+				"className": "text-sm text-gray-600 mt-2",
+			}, "Render count: ", renderCount),
+		),
+	)
+})
+```
+
+**Why this order matters:**
+
+- **Props**: Always declare a Props type for your component (matching the component name + Props)
+- **Define Component**: Always use DefineComponent to register your components. Variable name, and component name should match.
+- **UseLocal / UseRef Hooks first**: React rule - always call hooks at the top level, can use these values in closures later
+- **UseEffect / UseGoRoutine Hooks next**: React rule - always call hooks at the top level, can use atoms and refs from above
+- **Handlers next**: Can safely reference atoms without stale closures
+- **Atom reads last**: Fresh values right before render
+- **Render final**: Clean separation of logic and presentation. Can also conditionally return at this point based on the data, as all the hooks have been declared.
+
 ## Style Handling
 
 Tsunami applications use Tailwind v4 CSS by default for styling (className prop) and you should favor styling with Tailwind whenever possible. Also Tsunami Apps are built to run inside of Wave Terminal which is a dark mode application. Please create your styles in tailwind specifically to support DARK mode (so dark backgrounds and light text colors). You may also define inline styles using a map[string]any in the props:
@@ -741,7 +826,7 @@ var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
 
 ### References with app.UseRef
 
-app.UseRef creates mutable values that persist across renders without triggering re-renders:
+app.UseRef creates mutable values that persist across renders without triggering re-renders. Access and modify the value using the `Current` field. The ref is type-safe - the type of `Current` is automatically inferred from the initial value you provide.
 
 ```go
 var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
@@ -771,8 +856,9 @@ var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
 
 **Key Points:**
 
+- Access and modify values using the `Current` field
+- Type safety: `Current` has the same type as your initial value
 - Changes to ref.Current don't trigger re-renders
-- Perfect for storing goroutine state, timers, subscriptions
 - Cannot be used as the ref prop on DOM elements
 
 ### DOM References with app.UseVDomRef
@@ -958,7 +1044,7 @@ vdom.H("div", map[string]any{
 
 ### Dynamic URL Handlers
 
-For dynamic content or API endpoints, use app.HandleDynFunc to register standard http.ServeMux handlers. All dynamic routes MUST be registered under the `/dyn/` path:
+For dynamic content and file operations, use app.HandleDynFunc to register standard http.ServeMux handlers. Common use cases include serving generated images/charts, downloading CSV exports, serving external data fetched from 3rd party APIs (GitHub artifacts, APIs), file transfers, and format conversions (Markdown, Graphviz diagrams). All dynamic routes MUST be registered under the `/dyn/` path to avoid conflicts with framework routes (`/api/`, `/static/`, etc.):
 
 ```go
 // Register dynamic handlers (typically in init() or setup function)
@@ -992,7 +1078,7 @@ vdom.H("img", map[string]any{
 
 Key points:
 
-- **Static files**: Create `static/` directory, use `/static/` URLs
+- **Static files**: Create `static` directory, use `/static/` URLs
 - **Dynamic content**: Use app.HandleDynFunc with `/dyn/` prefix
 - Dynamic handlers use standard Go http.Handler interface
 - You can use any http.ServeMux pattern in the route

From 3d18fa7b6010631826ffd4e0227e930f24811666 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 14:47:29 -0700
Subject: [PATCH 101/134] add timer hooks

---
 tsunami/app/hooks.go      |  39 ++++++++++++++
 tsunami/prompts/system.md | 106 +++++++++++++++++++++++++++++++++-----
 2 files changed, 131 insertions(+), 14 deletions(-)

diff --git a/tsunami/app/hooks.go b/tsunami/app/hooks.go
index 325fad4df0..c1febe7c7b 100644
--- a/tsunami/app/hooks.go
+++ b/tsunami/app/hooks.go
@@ -5,6 +5,7 @@ package app
 
 import (
 	"context"
+	"time"
 
 	"github.com/wavetermdev/waveterm/tsunami/engine"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
@@ -174,3 +175,41 @@ func UseGoRoutine(fn func(ctx context.Context), deps []any) {
 		}
 	}, deps)
 }
+
+// UseTicker manages a ticker lifecycle within a component.
+// It creates a ticker that calls the provided function at regular intervals.
+// The ticker is automatically stopped on dependency changes or component unmount.
+// This hook must be called within a component context.
+func UseTicker(interval time.Duration, tickFn func(), deps []any) {
+	UseGoRoutine(func(ctx context.Context) {
+		ticker := time.NewTicker(interval)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				tickFn()
+			}
+		}
+	}, deps)
+}
+
+// UseAfter manages a timeout lifecycle within a component.
+// It creates a timer that calls the provided function after the specified duration.
+// The timer is automatically canceled on dependency changes or component unmount.
+// This hook must be called within a component context.
+func UseAfter(duration time.Duration, timeoutFn func(), deps []any) {
+	UseGoRoutine(func(ctx context.Context) {
+		timer := time.NewTimer(duration)
+		defer timer.Stop()
+
+		select {
+		case <-ctx.Done():
+			return
+		case <-timer.C:
+			timeoutFn()
+		}
+	}, deps)
+}
diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index d9c5e1b42d..b11855e680 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -267,7 +267,7 @@ var MyComponent = app.DefineComponent("MyComponent", func(props MyProps) any {
 
 - **State Management**: app.UseLocal creates local component atoms (covered in State Management with Atoms)
 - **Component Lifecycle**: app.UseEffect, app.UseRef, app.UseVDomRef (covered in Component Lifecycle Hooks)
-- **Async Operations**: app.UseGoRoutine manages goroutine lifecycle (covered in Async Operations and Goroutines)
+- **Async Operations**: app.UseGoRoutine, app.UseTicker, app.UseAfter manage goroutine and timer lifecycle (covered in Async Operations and Goroutines)
 - **Utility**: app.UseSetAppTitle, app.UseId, app.UseRenderTs, app.UseResync
 
 ## State Management with Atoms
@@ -925,31 +925,107 @@ var App = app.DefineComponent("App", func(_ struct{}) any {
 
 When working with goroutines, timers, or other async operations in Tsunami, follow these patterns to safely update state and manage cleanup:
 
-### Goroutine Management
+### Timer Hooks
 
-For async operations like timers, background tasks, or data polling, use app.UseGoRoutine to safely manage goroutine lifecycle:
+For common timing operations, Tsunami provides simplified hooks that handle cleanup automatically:
+
+#### UseTicker for Recurring Operations
+
+Use `app.UseTicker` for operations that need to run at regular intervals:
 
 ```go
-var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
-    seconds := app.UseLocal(0)
+var ClockComponent = app.DefineComponent("ClockComponent", func(_ struct{}) any {
+    currentTime := app.UseLocal(time.Now().Format("15:04:05"))
+
+    // Update every second - automatically cleaned up on unmount
+    app.UseTicker(time.Second, func() {
+        currentTime.Set(time.Now().Format("15:04:05"))
+        app.SendAsyncInitiation()
+    }, []any{})
+
+    return vdom.H("div", map[string]any{
+        "className": "text-2xl font-mono",
+    }, "Current time: ", currentTime.Get())
+})
+```
+
+#### UseAfter for Delayed Operations
+
+Use `app.UseAfter` for one-time delayed operations:
+
+```go
+type ToastComponentProps struct {
+    Message string
+    Duration time.Duration
+}
+
+var ToastComponent = app.DefineComponent("ToastComponent", func(props ToastComponentProps) any {
+    visible := app.UseLocal(true)
+
+    // Auto-hide after specified duration - cancelled if component unmounts
+    app.UseAfter(props.Duration, func() {
+        visible.Set(false)
+        app.SendAsyncInitiation()
+    }, []any{props.Duration})
+
+    if !visible.Get() {
+        return nil
+    }
+
+    return vdom.H("div", map[string]any{
+        "className": "bg-blue-500 text-white p-4 rounded",
+    }, props.Message)
+})
+```
+
+**Benefits of Timer Hooks:**
+
+- **Automatic cleanup**: Timers are stopped when component unmounts or dependencies change
+- **No goroutine leaks**: Built on top of `UseGoRoutine` with proper context cancellation
+- **Simpler API**: No need to manually manage ticker channels or timer cleanup
+- **Dependency tracking**: Change dependencies to restart timers with new intervals
+
+### Complex Async Operations with UseGoRoutine
 
-    timerFn := func(ctx context.Context) {
+For more complex async operations like data polling, background processing, or custom timing logic, use `app.UseGoRoutine` directly:
+
+```go
+var DataPollerComponent = app.DefineComponent("DataPollerComponent", func(_ struct{}) any {
+    data := app.UseLocal([]APIResult{})
+    status := app.UseLocal("idle")
+
+    pollDataFn := func(ctx context.Context) {
         for {
             select {
             case <-ctx.Done():
                 return
-            case <-time.After(time.Second):
-                // Update state from goroutine
-                seconds.SetFn(func(s int) int { return s + 1 })
-                app.SendAsyncInitiation() // Trigger UI update
+            case <-time.After(30 * time.Second):
+                status.Set("fetching")
+                app.SendAsyncInitiation()
+
+                // Complex async operation: fetch, process, validate
+                newData, err := fetchAndProcessData()
+                if err != nil {
+                    status.Set("error")
+                } else {
+                    data.SetFn(func(current []APIResult) []APIResult {
+                        // Merge new data with existing, handle deduplication
+                        return mergeResults(current, newData)
+                    })
+                    status.Set("success")
+                }
+                app.SendAsyncInitiation()
             }
         }
     }
 
-    // Start timer on mount, cleanup on unmount
-    app.UseGoRoutine(timerFn, []any{})
+    // Start polling on mount, cleanup on unmount
+    app.UseGoRoutine(pollDataFn, []any{})
 
-    return vdom.H("div", nil, "Seconds: ", seconds.Get())
+    return vdom.H("div", nil,
+        vdom.H("div", nil, "Status: ", status.Get()),
+        vdom.H("div", nil, "Data count: ", len(data.Get())),
+    )
 })
 ```
 
@@ -1282,6 +1358,8 @@ Key points:
 **Async Operation Guidelines**
 
 - Use app.UseGoRoutine instead of raw go statements for component-related async work
+- Use app.UseTicker instead of manual time.Ticker management for recurring operations
+- Use app.UseAfter instead of time.AfterFunc for delayed operations
 - Always respect ctx.Done() in app.UseGoRoutine functions to prevent goroutine leaks
-- Use app.UseEffect with cleanup functions for subscriptions, timers, and other lifecycle management
+- All timer and goroutine cleanup is handled automatically on component unmount or dependency changes
 - Call app.SendAsyncInitiation after state updates to trigger re-rendering

From bb523bad567cc0e972a42b208bcf9f289166ef53 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 14:53:04 -0700
Subject: [PATCH 102/134] new ticker pattern for cpu

---
 tsunami/demo/cpuchart/app.go | 69 +++++++++++++++---------------------
 1 file changed, 29 insertions(+), 40 deletions(-)

diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
index ee6f2e2f8a..19e0da5969 100644
--- a/tsunami/demo/cpuchart/app.go
+++ b/tsunami/demo/cpuchart/app.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"log"
 	"time"
 
@@ -145,49 +144,39 @@ var StatsPanel = app.DefineComponent("StatsPanel", func(props StatsPanelProps) a
 var App = app.DefineComponent("App", func(_ struct{}) any {
 	app.UseSetAppTitle("CPU Usage Monitor")
 
-	// Timer function for continuous CPU data collection
-	timerFn := func(ctx context.Context) {
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case <-time.After(time.Second):
-				// Collect new CPU data point and shift the data window
-				cpuDataAtom.SetFn(func(currentData []CPUDataPoint) []CPUDataPoint {
-					newPoint := generateCPUDataPoint()
-					currentDataPointCount := dataPointCountAtom.Get()
+	// Use UseTicker for continuous CPU data collection - automatically cleaned up on unmount
+	app.UseTicker(time.Second, func() {
+		// Collect new CPU data point and shift the data window
+		cpuDataAtom.SetFn(func(currentData []CPUDataPoint) []CPUDataPoint {
+			newPoint := generateCPUDataPoint()
+			currentDataPointCount := dataPointCountAtom.Get()
 
-					// Make a safe copy to avoid mutation issues
-					data := app.DeepCopy(currentData)
+			// Make a safe copy to avoid mutation issues
+			data := app.DeepCopy(currentData)
 
-					// Ensure we have the right size array
-					if len(data) != currentDataPointCount {
-						// Resize array if config changed
-						resized := make([]CPUDataPoint, currentDataPointCount)
-						copyCount := currentDataPointCount
-						if len(data) < copyCount {
-							copyCount = len(data)
-						}
-						if copyCount > 0 {
-							copy(resized[currentDataPointCount-copyCount:], data[len(data)-copyCount:])
-						}
-						data = resized
-					}
-
-					// Append new point and keep only the last currentDataPointCount elements
-					data = append(data, newPoint)
-					if len(data) > currentDataPointCount {
-						data = data[len(data)-currentDataPointCount:]
-					}
-					return data
-				})
-				app.SendAsyncInitiation()
+			// Ensure we have the right size array
+			if len(data) != currentDataPointCount {
+				// Resize array if config changed
+				resized := make([]CPUDataPoint, currentDataPointCount)
+				copyCount := currentDataPointCount
+				if len(data) < copyCount {
+					copyCount = len(data)
+				}
+				if copyCount > 0 {
+					copy(resized[currentDataPointCount-copyCount:], data[len(data)-copyCount:])
+				}
+				data = resized
 			}
-		}
-	}
 
-	// Use UseGoRoutine for managed goroutine lifecycle
-	app.UseGoRoutine(timerFn, []any{})
+			// Append new point and keep only the last currentDataPointCount elements
+			data = append(data, newPoint)
+			if len(data) > currentDataPointCount {
+				data = data[len(data)-currentDataPointCount:]
+			}
+			return data
+		})
+		app.SendAsyncInitiation()
+	}, []any{})
 
 	handleClear := func() {
 		// Reset with empty data points based on current config

From 6bdbc63c792634b34862894f164b01b79bfb3a56 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 15:12:34 -0700
Subject: [PATCH 103/134] use new hooks for githubaction (significant benefit)

---
 tsunami/demo/githubaction/app.go | 75 ++++++++++----------------------
 1 file changed, 24 insertions(+), 51 deletions(-)

diff --git a/tsunami/demo/githubaction/app.go b/tsunami/demo/githubaction/app.go
index 4d8e65d105..a78cc3cf78 100644
--- a/tsunami/demo/githubaction/app.go
+++ b/tsunami/demo/githubaction/app.go
@@ -222,67 +222,40 @@ var WorkflowRunItem = app.DefineComponent("WorkflowRunItem",
 var App = app.DefineComponent("App",
 	func(_ struct{}) any {
 		app.UseSetAppTitle("GitHub Actions Monitor")
-		_, _, setTickerFn := app.UseState(0)
 
-		app.UseEffect(func() func() {
-			ticker := time.NewTicker(time.Duration(pollIntervalAtom.Get()) * time.Second)
-			done := make(chan bool)
-
-			fetchData := func() {
-				currentMaxRuns := maxWorkflowRunsAtom.Get()
-				runs, err := fetchWorkflowRuns(repositoryAtom.Get(), workflowAtom.Get(), currentMaxRuns)
-				if err != nil {
-					log.Printf("Error fetching workflow runs: %v", err)
-					lastErrorAtom.Set(err.Error())
-				} else {
-					sort.Slice(runs, func(i, j int) bool {
-						return runs[i].CreatedAt.After(runs[j].CreatedAt)
-					})
-					workflowRunsAtom.Set(runs)
-					lastErrorAtom.Set("")
-				}
-				lastRefreshTimeAtom.Set(time.Now())
-				isLoadingAtom.Set(false)
+		fetchData := func() {
+			currentMaxRuns := maxWorkflowRunsAtom.Get()
+			runs, err := fetchWorkflowRuns(repositoryAtom.Get(), workflowAtom.Get(), currentMaxRuns)
+			if err != nil {
+				log.Printf("Error fetching workflow runs: %v", err)
+				lastErrorAtom.Set(err.Error())
+			} else {
+				sort.Slice(runs, func(i, j int) bool {
+					return runs[i].CreatedAt.After(runs[j].CreatedAt)
+				})
+				workflowRunsAtom.Set(runs)
+				lastErrorAtom.Set("")
 			}
+			lastRefreshTimeAtom.Set(time.Now())
+			isLoadingAtom.Set(false)
+		}
 
+		// Initial fetch on mount
+		app.UseEffect(func() func() {
 			fetchData()
+			return nil
+		}, []any{})
 
-			go func() {
-				for {
-					select {
-					case <-done:
-						return
-					case <-ticker.C:
-						fetchData()
-						setTickerFn(func(t int) int { return t + 1 })
-						app.SendAsyncInitiation()
-					}
-				}
-			}()
-
-			return func() {
-				ticker.Stop()
-				close(done)
-			}
+		// Automatic polling with UseTicker - automatically cleaned up on unmount
+		app.UseTicker(time.Duration(pollIntervalAtom.Get())*time.Second, func() {
+			fetchData()
+			app.SendAsyncInitiation()
 		}, []any{pollIntervalAtom.Get()})
 
 		handleRefresh := func() {
 			isLoadingAtom.Set(true)
 			go func() {
-				currentMaxRuns := maxWorkflowRunsAtom.Get()
-				runs, err := fetchWorkflowRuns(repositoryAtom.Get(), workflowAtom.Get(), currentMaxRuns)
-				if err != nil {
-					log.Printf("Error fetching workflow runs: %v", err)
-					lastErrorAtom.Set(err.Error())
-				} else {
-					sort.Slice(runs, func(i, j int) bool {
-						return runs[i].CreatedAt.After(runs[j].CreatedAt)
-					})
-					workflowRunsAtom.Set(runs)
-					lastErrorAtom.Set("")
-				}
-				lastRefreshTimeAtom.Set(time.Now())
-				isLoadingAtom.Set(false)
+				fetchData()
 				app.SendAsyncInitiation()
 			}()
 		}

From 28e79db365d97ddad8dfe191bfa5bbb7df77f412 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 15:38:36 -0700
Subject: [PATCH 104/134] implement a true atomic SetFn for atoms

---
 tsunami/app/atom.go          | 14 ++++++++------
 tsunami/demo/.gitignore      |  1 +
 tsunami/engine/atomimpl.go   | 19 +++++++++++++++----
 tsunami/engine/clientimpl.go |  4 ----
 tsunami/engine/rootelem.go   | 12 ++++++++++++
 5 files changed, 36 insertions(+), 14 deletions(-)
 create mode 100644 tsunami/demo/.gitignore

diff --git a/tsunami/app/atom.go b/tsunami/app/atom.go
index b5acdf769b..ba0c7c26f7 100644
--- a/tsunami/app/atom.go
+++ b/tsunami/app/atom.go
@@ -39,8 +39,9 @@ func (a Atom[T]) Get() T {
 		compWaveId := vc.GetCompWaveId()
 		vc.Root.AtomSetUsedBy(a.name, compWaveId, true)
 	}
-	val := a.client.GetAtomVal(a.name)
-	return util.GetTypedAtomValue[T](val, a.name)
+	val := a.client.Root.GetAtomVal(a.name)
+	typedVal := util.GetTypedAtomValue[T](val, a.name)
+	return typedVal
 }
 
 // Set updates the atom's value
@@ -63,10 +64,11 @@ func (a Atom[T]) SetFn(fn func(T) T) {
 		logInvalidAtomSet(a.name)
 		return
 	}
-	val := a.client.GetAtomVal(a.name)
-	typedVal := util.GetTypedAtomValue[T](val, a.name)
-	newVal := fn(typedVal)
-	if err := a.client.Root.SetAtomVal(a.name, newVal); err != nil {
+	err := a.client.Root.SetFnAtomVal(a.name, func(val any) any {
+		typedVal := util.GetTypedAtomValue[T](val, a.name)
+		return fn(typedVal)
+	})
+	if err != nil {
 		log.Printf("Failed to set atom value for %s: %v", a.name, err)
 		return
 	}
diff --git a/tsunami/demo/.gitignore b/tsunami/demo/.gitignore
new file mode 100644
index 0000000000..b59f7e3a95
--- /dev/null
+++ b/tsunami/demo/.gitignore
@@ -0,0 +1 @@
+test/
\ No newline at end of file
diff --git a/tsunami/engine/atomimpl.go b/tsunami/engine/atomimpl.go
index 3d8f6761c6..9851fe0ff6 100644
--- a/tsunami/engine/atomimpl.go
+++ b/tsunami/engine/atomimpl.go
@@ -29,10 +29,7 @@ func (a *AtomImpl[T]) GetVal() any {
 	return a.val
 }
 
-func (a *AtomImpl[T]) SetVal(val any) error {
-	a.lock.Lock()
-	defer a.lock.Unlock()
-
+func (a *AtomImpl[T]) setVal_nolock(val any) error {
 	if val == nil {
 		var zero T
 		a.val = zero
@@ -61,6 +58,20 @@ func (a *AtomImpl[T]) SetVal(val any) error {
 	return nil
 }
 
+func (a *AtomImpl[T]) SetVal(val any) error {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+	return a.setVal_nolock(val)
+}
+
+func (a *AtomImpl[T]) SetFnVal(setFn func(any) any) error {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+	
+	newVal := setFn(a.val)
+	return a.setVal_nolock(newVal)
+}
+
 func (a *AtomImpl[T]) SetUsedBy(waveId string, used bool) {
 	a.lock.Lock()
 	defer a.lock.Unlock()
diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index 04c9454df1..b12e63bea3 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -218,10 +218,6 @@ func (c *ClientImpl) SendAsyncInitiation() error {
 	}
 }
 
-func (c *ClientImpl) GetAtomVal(name string) any {
-	return c.Root.GetAtomVal(name)
-}
-
 func makeNullRendered() *rpctypes.RenderedElem {
 	return &rpctypes.RenderedElem{WaveId: uuid.New().String(), Tag: vdom.WaveNullTag}
 }
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 2c5e1fb9de..c950b4131d 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -25,6 +25,7 @@ type EffectWorkElem struct {
 type genAtom interface {
 	GetVal() any
 	SetVal(any) error
+	SetFnVal(func(any) any) error
 	SetUsedBy(string, bool)
 	GetUsedBy() []string
 }
@@ -157,6 +158,17 @@ func (r *RootElem) SetAtomVal(name string, val any) error {
 	return atom.SetVal(val)
 }
 
+func (r *RootElem) SetFnAtomVal(name string, setFn func(any) any) error {
+	r.atomLock.Lock()
+	defer r.atomLock.Unlock()
+
+	atom, ok := r.Atoms[name]
+	if !ok {
+		return fmt.Errorf("atom %q not found", name)
+	}
+	return atom.SetFnVal(setFn)
+}
+
 func (r *RootElem) RemoveAtom(name string) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()

From b6f12b32232093e784308f7580d4134ee00876c3 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 16:15:50 -0700
Subject: [PATCH 105/134] new pattern for recharts demo

---
 tsunami/demo/recharts/app.go        | 238 +++++++++++++---------------
 tsunami/demo/recharts/static/tw.css |  48 ------
 2 files changed, 106 insertions(+), 180 deletions(-)

diff --git a/tsunami/demo/recharts/app.go b/tsunami/demo/recharts/app.go
index 3e3b6e75f4..6c628fd94f 100644
--- a/tsunami/demo/recharts/app.go
+++ b/tsunami/demo/recharts/app.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"math"
 	"time"
 
@@ -42,7 +41,7 @@ func generateNewDataPoint(currentData []DataPoint) DataPoint {
 		lastTime = currentData[len(currentData)-1].Time
 	}
 	newTime := lastTime + 1
-	
+
 	return DataPoint{
 		Time: newTime,
 		CPU:  50 + 30*math.Sin(float64(newTime)*0.3) + 10*math.Sin(float64(newTime)*0.7),
@@ -51,60 +50,59 @@ func generateNewDataPoint(currentData []DataPoint) DataPoint {
 	}
 }
 
-var InfoSection = app.DefineComponent("InfoSection",
-	func(ctx context.Context, _ struct{}) any {
-		return vdom.H("div", map[string]any{
-			"className": "bg-blue-50 border border-blue-200 rounded-lg p-4",
+var InfoSection = app.DefineComponent("InfoSection", func(_ struct{}) any {
+	return vdom.H("div", map[string]any{
+		"className": "bg-blue-50 border border-blue-200 rounded-lg p-4",
+	},
+		vdom.H("h3", map[string]any{
+			"className": "text-lg font-semibold text-blue-900 mb-2",
+		}, "Recharts Integration Features"),
+		vdom.H("ul", map[string]any{
+			"className": "space-y-2 text-blue-800",
 		},
-			vdom.H("h3", map[string]any{
-				"className": "text-lg font-semibold text-blue-900 mb-2",
-			}, "Recharts Integration Features"),
-			vdom.H("ul", map[string]any{
-				"className": "space-y-2 text-blue-800",
+			vdom.H("li", map[string]any{
+				"className": "flex items-start gap-2",
 			},
-				vdom.H("li", map[string]any{
-					"className": "flex items-start gap-2",
-				},
-					vdom.H("span", map[string]any{
-						"className": "text-blue-500 mt-1",
-					}, "•"),
-					"Support for all major Recharts components (LineChart, AreaChart, BarChart, etc.)",
-				),
-				vdom.H("li", map[string]any{
-					"className": "flex items-start gap-2",
-				},
-					vdom.H("span", map[string]any{
-						"className": "text-blue-500 mt-1",
-					}, "•"),
-					"Live data updates with animation support",
-				),
-				vdom.H("li", map[string]any{
-					"className": "flex items-start gap-2",
-				},
-					vdom.H("span", map[string]any{
-						"className": "text-blue-500 mt-1",
-					}, "•"),
-					"Responsive containers that resize with the window",
-				),
-				vdom.H("li", map[string]any{
-					"className": "flex items-start gap-2",
-				},
-					vdom.H("span", map[string]any{
-						"className": "text-blue-500 mt-1",
-					}, "•"),
-					"Full prop support for customization and styling",
-				),
-				vdom.H("li", map[string]any{
-					"className": "flex items-start gap-2",
-				},
-					vdom.H("span", map[string]any{
-						"className": "text-blue-500 mt-1",
-					}, "•"),
-					"Uses recharts: namespace to dispatch to the recharts handler",
-				),
+				vdom.H("span", map[string]any{
+					"className": "text-blue-500 mt-1",
+				}, "•"),
+				"Support for all major Recharts components (LineChart, AreaChart, BarChart, etc.)",
 			),
-		)
-	},
+			vdom.H("li", map[string]any{
+				"className": "flex items-start gap-2",
+			},
+				vdom.H("span", map[string]any{
+					"className": "text-blue-500 mt-1",
+				}, "•"),
+				"Live data updates with animation support",
+			),
+			vdom.H("li", map[string]any{
+				"className": "flex items-start gap-2",
+			},
+				vdom.H("span", map[string]any{
+					"className": "text-blue-500 mt-1",
+				}, "•"),
+				"Responsive containers that resize with the window",
+			),
+			vdom.H("li", map[string]any{
+				"className": "flex items-start gap-2",
+			},
+				vdom.H("span", map[string]any{
+					"className": "text-blue-500 mt-1",
+				}, "•"),
+				"Full prop support for customization and styling",
+			),
+			vdom.H("li", map[string]any{
+				"className": "flex items-start gap-2",
+			},
+				vdom.H("span", map[string]any{
+					"className": "text-blue-500 mt-1",
+				}, "•"),
+				"Uses recharts: namespace to dispatch to the recharts handler",
+			),
+		),
+	)
+},
 )
 
 type MiniChartsProps struct {
@@ -112,7 +110,7 @@ type MiniChartsProps struct {
 }
 
 var MiniCharts = app.DefineComponent("MiniCharts",
-	func(ctx context.Context, props MiniChartsProps) any {
+	func(props MiniChartsProps) any {
 		return vdom.H("div", map[string]any{
 			"className": "grid grid-cols-1 md:grid-cols-3 gap-6 mb-6",
 		},
@@ -134,11 +132,11 @@ var MiniCharts = app.DefineComponent("MiniCharts",
 							"data": props.ChartData,
 						},
 							vdom.H("recharts:Line", map[string]any{
-								"type":            "monotone",
-								"dataKey":         "cpu",
-								"stroke":          "#8884d8",
-								"strokeWidth":     2,
-								"dot":             false,
+								"type":        "monotone",
+								"dataKey":     "cpu",
+								"stroke":      "#8884d8",
+								"strokeWidth": 2,
+								"dot":         false,
 							}),
 						),
 					),
@@ -203,55 +201,27 @@ var MiniCharts = app.DefineComponent("MiniCharts",
 )
 
 var App = app.DefineComponent("App",
-	func(ctx context.Context, _ struct{}) any {
+	func(_ struct{}) any {
 		app.UseSetAppTitle("Recharts Demo")
 
-		// Get atom values once at the top
-		chartData := chartDataAtom.Get()
-		chartType := chartTypeAtom.Get()
-		isAnimating := isAnimatingAtom.Get()
-
-		// Local state for timer
-		_, _, setTickerFn := app.UseState(0)
-
-		// Timer effect for live data updates
-		app.UseEffect(func() func() {
-			if !isAnimating {
-				return nil
+		tickerFn := func() {
+			if !isAnimatingAtom.Get() {
+				return
 			}
-
-			ticker := time.NewTicker(1 * time.Second)
-			done := make(chan bool)
-
-			go func() {
-				for {
-					select {
-					case <-done:
-						return
-					case <-ticker.C:
-						// Add new data point and keep only last 20 points
-						chartDataAtom.SetFn(func(currentData []DataPoint) []DataPoint {
-							newData := append(currentData, generateNewDataPoint(currentData))
-							if len(newData) > 20 {
-								newData = newData[1:]
-							}
-							return newData
-						})
-						// Trigger a re-render
-						setTickerFn(func(t int) int { return t + 1 })
-						app.SendAsyncInitiation()
-					}
+			chartDataAtom.SetFn(func(currentData []DataPoint) []DataPoint {
+				currentData = app.DeepCopy(currentData)
+				newData := append(currentData, generateNewDataPoint(currentData))
+				if len(newData) > 20 {
+					newData = newData[1:]
 				}
-			}()
-
-			return func() {
-				ticker.Stop()
-				close(done)
-			}
-		}, []any{isAnimating})
+				return newData
+			})
+			app.SendAsyncInitiation()
+		}
+		app.UseTicker(time.Second, tickerFn, []any{})
 
 		handleStartStop := func() {
-			isAnimatingAtom.Set(!isAnimating)
+			isAnimatingAtom.Set(!isAnimatingAtom.Get())
 		}
 
 		handleReset := func() {
@@ -263,6 +233,10 @@ var App = app.DefineComponent("App",
 			chartTypeAtom.Set(newType)
 		}
 
+		chartData := chartDataAtom.Get()
+		chartType := chartTypeAtom.Get()
+		isAnimating := isAnimatingAtom.Get()
+
 		return vdom.H("div", map[string]any{
 			"className": "min-h-screen bg-gray-50 p-6",
 		},
@@ -372,22 +346,22 @@ var App = app.DefineComponent("App",
 									vdom.H("recharts:Tooltip", nil),
 									vdom.H("recharts:Legend", nil),
 									vdom.H("recharts:Line", map[string]any{
-										"type":     "monotone",
-										"dataKey":  "cpu",
-										"stroke":   "#8884d8",
-										"name":     "CPU %",
+										"type":    "monotone",
+										"dataKey": "cpu",
+										"stroke":  "#8884d8",
+										"name":    "CPU %",
 									}),
 									vdom.H("recharts:Line", map[string]any{
-										"type":     "monotone",
-										"dataKey":  "mem",
-										"stroke":   "#82ca9d",
-										"name":     "Memory %",
+										"type":    "monotone",
+										"dataKey": "mem",
+										"stroke":  "#82ca9d",
+										"name":    "Memory %",
 									}),
 									vdom.H("recharts:Line", map[string]any{
-										"type":     "monotone",
-										"dataKey":  "disk",
-										"stroke":   "#ffc658",
-										"name":     "Disk %",
+										"type":    "monotone",
+										"dataKey": "disk",
+										"stroke":  "#ffc658",
+										"name":    "Disk %",
 									}),
 								),
 							),
@@ -410,28 +384,28 @@ var App = app.DefineComponent("App",
 										vdom.H("recharts:Tooltip", nil),
 										vdom.H("recharts:Legend", nil),
 										vdom.H("recharts:Area", map[string]any{
-											"type":     "monotone",
-											"dataKey":  "cpu",
-											"stackId":  "1",
-											"stroke":   "#8884d8",
-											"fill":     "#8884d8",
-											"name":     "CPU %",
+											"type":    "monotone",
+											"dataKey": "cpu",
+											"stackId": "1",
+											"stroke":  "#8884d8",
+											"fill":    "#8884d8",
+											"name":    "CPU %",
 										}),
 										vdom.H("recharts:Area", map[string]any{
-											"type":     "monotone",
-											"dataKey":  "mem",
-											"stackId":  "1",
-											"stroke":   "#82ca9d",
-											"fill":     "#82ca9d",
-											"name":     "Memory %",
+											"type":    "monotone",
+											"dataKey": "mem",
+											"stackId": "1",
+											"stroke":  "#82ca9d",
+											"fill":    "#82ca9d",
+											"name":    "Memory %",
 										}),
 										vdom.H("recharts:Area", map[string]any{
-											"type":     "monotone",
-											"dataKey":  "disk",
-											"stackId":  "1",
-											"stroke":   "#ffc658",
-											"fill":     "#ffc658",
-											"name":     "Disk %",
+											"type":    "monotone",
+											"dataKey": "disk",
+											"stackId": "1",
+											"stroke":  "#ffc658",
+											"fill":    "#ffc658",
+											"name":    "Disk %",
 										}),
 									),
 								),
diff --git a/tsunami/demo/recharts/static/tw.css b/tsunami/demo/recharts/static/tw.css
index 3e36ada910..cc96f5a20c 100644
--- a/tsunami/demo/recharts/static/tw.css
+++ b/tsunami/demo/recharts/static/tw.css
@@ -254,33 +254,12 @@
   .sticky {
     position: sticky;
   }
-  .-inset-1 {
-    inset: calc(var(--spacing) * -1);
-  }
   .isolate {
     isolation: isolate;
   }
   .isolation-auto {
     isolation: auto;
   }
-  .\!container {
-    width: 100% !important;
-    @media (width >= 40rem) {
-      max-width: 40rem !important;
-    }
-    @media (width >= 48rem) {
-      max-width: 48rem !important;
-    }
-    @media (width >= 64rem) {
-      max-width: 64rem !important;
-    }
-    @media (width >= 80rem) {
-      max-width: 80rem !important;
-    }
-    @media (width >= 96rem) {
-      max-width: 96rem !important;
-    }
-  }
   .container {
     width: 100%;
     @media (width >= 40rem) {
@@ -884,18 +863,10 @@
     --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .ring {
-    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
-    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
-  }
   .inset-ring {
     --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .outline {
-    outline-style: var(--tw-outline-style);
-    outline-width: 1px;
-  }
   .blur {
     --tw-blur: blur(8px);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
@@ -905,18 +876,10 @@
     --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .grayscale {
-    --tw-grayscale: grayscale(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .invert {
     --tw-invert: invert(100%);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .sepia {
-    --tw-sepia: sepia(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .filter {
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
@@ -944,11 +907,6 @@
     -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
     backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
   }
-  .transition {
-    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
-    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
-    transition-duration: var(--tw-duration, var(--default-transition-duration));
-  }
   .transition-colors {
     transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
     transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
@@ -1189,11 +1147,6 @@
   inherits: false;
   initial-value: 0 0 #0000;
 }
-@property --tw-outline-style {
-  syntax: "*";
-  inherits: false;
-  initial-value: solid;
-}
 @property --tw-blur {
   syntax: "*";
   inherits: false;
@@ -1327,7 +1280,6 @@
       --tw-ring-offset-width: 0px;
       --tw-ring-offset-color: #fff;
       --tw-ring-offset-shadow: 0 0 #0000;
-      --tw-outline-style: solid;
       --tw-blur: initial;
       --tw-brightness: initial;
       --tw-contrast: initial;

From af19bbff38f0b93dbe79bc402a921d9d755e3e84 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 16:39:30 -0700
Subject: [PATCH 106/134] update atom.  deep copy on SetFn.  warning for data
 mutation

---
 tsunami/app/atom.go          | 57 ++++++++++++++++++++++++++++++++++--
 tsunami/demo/recharts/app.go |  1 -
 2 files changed, 55 insertions(+), 3 deletions(-)

diff --git a/tsunami/app/atom.go b/tsunami/app/atom.go
index ba0c7c26f7..4dc0e671e6 100644
--- a/tsunami/app/atom.go
+++ b/tsunami/app/atom.go
@@ -5,6 +5,7 @@ package app
 
 import (
 	"log"
+	"reflect"
 	"runtime"
 
 	"github.com/wavetermdev/waveterm/tsunami/engine"
@@ -21,6 +22,42 @@ func logInvalidAtomSet(atomName string) {
 	}
 }
 
+// sameRef returns true if oldVal and newVal share the same underlying reference
+// (pointer, map, or slice). Nil values return false.
+func sameRef[T any](oldVal, newVal T) bool {
+	vOld := reflect.ValueOf(oldVal)
+	vNew := reflect.ValueOf(newVal)
+
+	if !vOld.IsValid() || !vNew.IsValid() {
+		return false
+	}
+
+	switch vNew.Kind() {
+	case reflect.Ptr:
+		// direct comparison works for *T
+		return any(oldVal) == any(newVal)
+
+	case reflect.Map, reflect.Slice:
+		if vOld.Kind() != vNew.Kind() || vOld.IsZero() || vNew.IsZero() {
+			return false
+		}
+		return vOld.Pointer() == vNew.Pointer()
+	}
+
+	// primitives, structs, etc. → not a reference type
+	return false
+}
+
+// logMutationWarning logs a warning when mutation is detected
+func logMutationWarning(atomName string) {
+	_, file, line, ok := runtime.Caller(2)
+	if ok {
+		log.Printf("WARNING: atom '%s' appears to be mutated instead of copied at %s:%d - use app.DeepCopy to create a copy before mutating", atomName, file, line)
+	} else {
+		log.Printf("WARNING: atom '%s' appears to be mutated instead of copied - use app.DeepCopy to create a copy before mutating", atomName)
+	}
+}
+
 // Atom[T] represents a typed atom implementation
 type Atom[T any] struct {
 	name   string
@@ -32,7 +69,9 @@ func (a Atom[T]) AtomName() string {
 	return a.name
 }
 
-// Get returns the current value of the atom
+// Get returns the current value of the atom. When called during component render,
+// it automatically registers the component as a dependency for this atom, ensuring
+// the component re-renders when the atom value changes.
 func (a Atom[T]) Get() T {
 	vc := engine.GetGlobalContext()
 	if vc != nil {
@@ -44,13 +83,23 @@ func (a Atom[T]) Get() T {
 	return typedVal
 }
 
-// Set updates the atom's value
+// Set updates the atom's value to the provided new value and triggers re-rendering
+// of any components that depend on this atom. This method cannot be called during
+// render cycles - use effects or event handlers instead.
 func (a Atom[T]) Set(newVal T) {
 	vc := engine.GetGlobalContext()
 	if vc != nil {
 		logInvalidAtomSet(a.name)
 		return
 	}
+
+	// Check for potential mutation bugs with reference types
+	currentVal := a.client.Root.GetAtomVal(a.name)
+	currentTyped := util.GetTypedAtomValue[T](currentVal, a.name)
+	if sameRef(currentTyped, newVal) {
+		logMutationWarning(a.name)
+	}
+
 	if err := a.client.Root.SetAtomVal(a.name, newVal); err != nil {
 		log.Printf("Failed to set atom value for %s: %v", a.name, err)
 		return
@@ -58,6 +107,10 @@ func (a Atom[T]) Set(newVal T) {
 	a.client.Root.AtomAddRenderWork(a.name)
 }
 
+// SetFn updates the atom's value by applying the provided function to the current value.
+// The function receives a copy of the current atom value, which can be safely mutated
+// without affecting the original data. The return value from the function becomes the
+// new atom value. This method cannot be called during render cycles.
 func (a Atom[T]) SetFn(fn func(T) T) {
 	vc := engine.GetGlobalContext()
 	if vc != nil {
diff --git a/tsunami/demo/recharts/app.go b/tsunami/demo/recharts/app.go
index 6c628fd94f..77b6c36c22 100644
--- a/tsunami/demo/recharts/app.go
+++ b/tsunami/demo/recharts/app.go
@@ -209,7 +209,6 @@ var App = app.DefineComponent("App",
 				return
 			}
 			chartDataAtom.SetFn(func(currentData []DataPoint) []DataPoint {
-				currentData = app.DeepCopy(currentData)
 				newData := append(currentData, generateNewDataPoint(currentData))
 				if len(newData) > 20 {
 					newData = newData[1:]

From 99ea01d843202c14534d9e5c59b5b47a51ec8726 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 16:47:05 -0700
Subject: [PATCH 107/134] modify demos and system prompt to say SetFn is safe
 for modifications (no DeepCopy required)

---
 tsunami/demo/cpuchart/app.go |  5 +----
 tsunami/demo/todo/app.go     | 12 +++++-------
 tsunami/prompts/system.md    | 32 +++++++++++++++++---------------
 3 files changed, 23 insertions(+), 26 deletions(-)

diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
index 19e0da5969..e4d1c09bfd 100644
--- a/tsunami/demo/cpuchart/app.go
+++ b/tsunami/demo/cpuchart/app.go
@@ -147,13 +147,10 @@ var App = app.DefineComponent("App", func(_ struct{}) any {
 	// Use UseTicker for continuous CPU data collection - automatically cleaned up on unmount
 	app.UseTicker(time.Second, func() {
 		// Collect new CPU data point and shift the data window
-		cpuDataAtom.SetFn(func(currentData []CPUDataPoint) []CPUDataPoint {
+		cpuDataAtom.SetFn(func(data []CPUDataPoint) []CPUDataPoint {
 			newPoint := generateCPUDataPoint()
 			currentDataPointCount := dataPointCountAtom.Get()
 
-			// Make a safe copy to avoid mutation issues
-			data := app.DeepCopy(currentData)
-
 			// Ensure we have the right size array
 			if len(data) != currentDataPointCount {
 				// Resize array if config changed
diff --git a/tsunami/demo/todo/app.go b/tsunami/demo/todo/app.go
index e965379db7..82c5ac6dc8 100644
--- a/tsunami/demo/todo/app.go
+++ b/tsunami/demo/todo/app.go
@@ -112,8 +112,7 @@ var App = app.DefineComponent("App", func(_ any) any {
 			return
 		}
 		todosAtom.SetFn(func(todos []Todo) []Todo {
-			newTodos := app.DeepCopy(todos)
-			return append(newTodos, Todo{
+			return append(todos, Todo{
 				Id:        nextIdAtom.Get(),
 				Text:      inputTextAtom.Get(),
 				Completed: false,
@@ -126,14 +125,13 @@ var App = app.DefineComponent("App", func(_ any) any {
 	// Immutable state update pattern
 	toggleTodo := func(id int) {
 		todosAtom.SetFn(func(todos []Todo) []Todo {
-			newTodos := app.DeepCopy(todos)
-			for i := range newTodos {
-				if newTodos[i].Id == id {
-					newTodos[i].Completed = !newTodos[i].Completed
+			for i := range todos {
+				if todos[i].Id == id {
+					todos[i].Completed = !todos[i].Completed
 					break
 				}
 			}
-			return newTodos
+			return todos
 		})
 	}
 
diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index b11855e680..37e00fdb78 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -364,17 +364,18 @@ var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
 })
 ```
 
-**Never mutate values from Get()**: For complex data types, never modify the value returned from `atom.Get()`. Always use `app.DeepCopy()` before mutations:
+**Never mutate values from Get()**: For complex data types, never modify the value returned from `atom.Get()`.
+
+**Use SetFn() for safe mutations**: `SetFn()` automatically handles deep copying, making it safe to modify complex data:
 
 ```go
 var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
     todos := app.UseLocal([]Todo{{Text: "Learn Tsunami"}})
 
     addTodo := func() {
-        // ✅ Correct: Copy before modifying
+        // ✅ Correct: SetFn automatically deep copies the current value
         todos.SetFn(func(current []Todo) []Todo {
-            todosCopy := app.DeepCopy(current)
-            return append(todosCopy, Todo{Text: "New task"})
+            return append(current, Todo{Text: "New task"})
         })
     }
 
@@ -418,7 +419,8 @@ var MyComponent = app.DefineComponent("MyComponent", func(_ struct{}) any {
 
 **Key Points:**
 
-- Use `app.DeepCopy(value)` before modifying complex data from `atom.Get()`
+- `SetFn()` automatically deep copies the current value before passing it to your function
+- For direct mutations using `Set()`, manually use `app.DeepCopy(value)` before modifying complex data from `atom.Get()`
 - Always capture atoms in closures, never captured render values
 - This prevents stale closures and shared reference bugs
 - `app.DeepCopy[T any](value T) T` works with slices, maps, structs, and nested combinations
@@ -1009,7 +1011,7 @@ var DataPollerComponent = app.DefineComponent("DataPollerComponent", func(_ stru
                     status.Set("error")
                 } else {
                     data.SetFn(func(current []APIResult) []APIResult {
-                        // Merge new data with existing, handle deduplication
+                        // SetFn automatically deep copies current, safe to modify
                         return mergeResults(current, newData)
                     })
                     status.Set("success")
@@ -1073,8 +1075,8 @@ Atoms are internally synchronized, so multiple goroutines can safely call Get()
 // Safe pattern for concurrent updates using SetFn
 updateTodos := func() {
     todosAtom.SetFn(func(current []Todo) []Todo {
-        todosCopy := app.DeepCopy(current)
-        return append(todosCopy, newTodo)
+        // SetFn automatically deep copies current value
+        return append(current, newTodo)
     })
 }
 ```
@@ -1172,7 +1174,7 @@ Key points:
 
 - ✅ Read with atom.Get() in render code
 - ❌ Never call atom.Set() in render code - only in handlers/effects
-- ✅ Always use SetFn() for concurrent updates from goroutines
+- ✅ Always use SetFn() for concurrent updates from goroutines (automatically deep copies the value)
 
 ## Tsunami App Template
 
@@ -1253,14 +1255,14 @@ var App = app.DefineComponent("App", func(_ struct{}) any {
 
     toggleTodo := func(id int) {
         todos.SetFn(func(current []Todo) []Todo {
-            todosCopy := app.DeepCopy(current)
-            for i := range todosCopy {
-                if todosCopy[i].Id == id {
-                    todosCopy[i].Completed = !todosCopy[i].Completed
+            // SetFn automatically deep copies current value
+            for i := range current {
+                if current[i].Id == id {
+                    current[i].Completed = !current[i].Completed
                     break
                 }
             }
-            return todosCopy
+            return current
         })
     }
 
@@ -1330,7 +1332,7 @@ Key points:
 2. **Missing keys in lists**: Always use `.WithKey(id)` for list items
 3. **Stale closures in goroutines**: Use `atom.Get()` inside event handlers, effects, and goroutines, not captured values
 4. **Wrong prop format**: Use `"className"` not `"class"`, `"onClick"` not `"onclick"` (matching React prop and style names)
-5. **Mutating state**: Always create new slices/objects when updating atoms (can use app.DeepCopy helper)
+5. **Mutating state**: With `SetFn()`, you can safely modify the current value as it's automatically deep copied. With `Set()`, create new slices/objects or use app.DeepCopy helper
 
 ## Styling Requirements
 

From 60bd7c0d006c65627204b1696062c6cddcd30824 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Tue, 9 Sep 2025 20:56:14 -0700
Subject: [PATCH 108/134] remove legacy rpc code

---
 tsunami/rpc/rpc.go   |  8 --------
 tsunami/rpc/types.go | 33 ---------------------------------
 tsunami/rpc/wps.go   | 31 -------------------------------
 3 files changed, 72 deletions(-)
 delete mode 100644 tsunami/rpc/rpc.go
 delete mode 100644 tsunami/rpc/types.go
 delete mode 100644 tsunami/rpc/wps.go

diff --git a/tsunami/rpc/rpc.go b/tsunami/rpc/rpc.go
deleted file mode 100644
index 913cd57b4c..0000000000
--- a/tsunami/rpc/rpc.go
+++ /dev/null
@@ -1,8 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package rpc
-
-func MakeFeBlockRouteId(blockId string) string {
-	return "feblock:" + blockId
-}
\ No newline at end of file
diff --git a/tsunami/rpc/types.go b/tsunami/rpc/types.go
deleted file mode 100644
index f4d8f7fb00..0000000000
--- a/tsunami/rpc/types.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package rpc
-
-type RespOrErrorUnion[T any] struct {
-	Response T
-	Error    error
-}
-
-type RpcOpts struct {
-	Timeout    int64  `json:"timeout,omitempty"`
-	NoResponse bool   `json:"noresponse,omitempty"`
-	Route      string `json:"route,omitempty"`
-
-	StreamCancelFn func() `json:"-"` // this is an *output* parameter, set by the handler
-}
-
-type RpcContext struct {
-	ClientType string `json:"ctype,omitempty"`
-	BlockId    string `json:"blockid,omitempty"`
-	TabId      string `json:"tabid,omitempty"`
-	Conn       string `json:"conn,omitempty"`
-}
-
-type ORef struct {
-	OType string `json:"otype"`
-	OID   string `json:"oid"`
-}
-
-func (oref ORef) String() string {
-	return oref.OType + ":" + oref.OID
-}
diff --git a/tsunami/rpc/wps.go b/tsunami/rpc/wps.go
deleted file mode 100644
index 4f324cbe08..0000000000
--- a/tsunami/rpc/wps.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package rpc
-
-const (
-	Event_BlockClose = "blockclose"
-)
-
-type WaveEvent struct {
-	Event   string   `json:"event"`
-	Scopes  []string `json:"scopes,omitempty"`
-	Sender  string   `json:"sender,omitempty"`
-	Persist int      `json:"persist,omitempty"`
-	Data    any      `json:"data,omitempty"`
-}
-
-func (e WaveEvent) HasScope(scope string) bool {
-	for _, s := range e.Scopes {
-		if s == scope {
-			return true
-		}
-	}
-	return false
-}
-
-type SubscriptionRequest struct {
-	Event     string   `json:"event"`
-	Scopes    []string `json:"scopes,omitempty"`
-	AllScopes bool     `json:"allscopes,omitempty"`
-}
\ No newline at end of file

From 0a3fc8f02c2fb30277f03094ef45fc789f3dc221 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 09:24:24 -0700
Subject: [PATCH 109/134] call twmerge on className prop

---
 tsunami/frontend/src/vdom.tsx | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index ef5009ca3d..5ee1b29760 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -5,6 +5,7 @@ import clsx from "clsx";
 import debug from "debug";
 import * as jotai from "jotai";
 import * as React from "react";
+import { twMerge } from "tailwind-merge";
 
 import { Markdown } from "@/element/markdown";
 import { getTextChildren } from "@/model/model-utils";
@@ -203,6 +204,10 @@ function convertProps(elem: VDomElem, model: TsunamiModel): GenericPropsType {
             }
             continue;
         }
+        if (key == "className" && typeof val === "string") {
+            props[key] = twMerge(val);
+            continue;
+        }
         if (isObject(val) && val.type == VDomObjType_Func) {
             const valFunc = val as VDomFunc;
             props[key] = convertVDomFunc(model, valFunc, elem.waveid, key);

From 0e5f6b13bdaa278e2d2af79d9d520d758376f8f9 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 11:39:41 -0700
Subject: [PATCH 110/134] working on a backend table component

---
 tsunami/build/build.go               |   10 +
 tsunami/demo/tabletest/app.go        |  114 +++
 tsunami/demo/tabletest/go.mod        |   12 +
 tsunami/demo/tabletest/go.sum        |    4 +
 tsunami/demo/tabletest/static/tw.css | 1279 ++++++++++++++++++++++++++
 tsunami/ui/table.go                  |  545 +++++++++++
 6 files changed, 1964 insertions(+)
 create mode 100644 tsunami/demo/tabletest/app.go
 create mode 100644 tsunami/demo/tabletest/go.mod
 create mode 100644 tsunami/demo/tabletest/go.sum
 create mode 100644 tsunami/demo/tabletest/static/tw.css
 create mode 100644 tsunami/ui/table.go

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 1fdd14ce71..8ac4ce260f 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -430,6 +430,16 @@ func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 		return buildEnv, fmt.Errorf("failed to create go.mod: %w", err)
 	}
 
+	// Create symlink to SDK ui directory so Tailwind can see those classes
+	uiLinkPath := filepath.Join(tempDir, "ui")
+	uiTargetPath := filepath.Join(opts.SdkReplacePath, "ui")
+	if err := os.Symlink(uiTargetPath, uiLinkPath); err != nil {
+		return buildEnv, fmt.Errorf("failed to create ui symlink: %w", err)
+	}
+	if opts.Verbose {
+		log.Printf("Created symlink: %s -> %s", uiLinkPath, uiTargetPath)
+	}
+
 	// Generate Tailwind CSS
 	if err := generateAppTailwindCss(tempDir, opts.Verbose); err != nil {
 		return buildEnv, fmt.Errorf("failed to generate tailwind css: %w", err)
diff --git a/tsunami/demo/tabletest/app.go b/tsunami/demo/tabletest/app.go
new file mode 100644
index 0000000000..3e8c2a48f3
--- /dev/null
+++ b/tsunami/demo/tabletest/app.go
@@ -0,0 +1,114 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/wavetermdev/waveterm/tsunami/app"
+	"github.com/wavetermdev/waveterm/tsunami/ui"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+// Sample data structure for the table
+type Person struct {
+	Name  string `json:"name"`
+	Age   int    `json:"age"`
+	Email string `json:"email"`
+	City  string `json:"city"`
+}
+
+// Create the table component for Person data
+var PersonTable = ui.MakeTableComponent[Person]("PersonTable")
+
+// Sample data
+var sampleData = []Person{
+	{Name: "Alice Johnson", Age: 28, Email: "alice@example.com", City: "New York"},
+	{Name: "Bob Smith", Age: 34, Email: "bob@example.com", City: "Los Angeles"},
+	{Name: "Carol Davis", Age: 22, Email: "carol@example.com", City: "Chicago"},
+	{Name: "David Wilson", Age: 41, Email: "david@example.com", City: "Houston"},
+	{Name: "Eve Brown", Age: 29, Email: "eve@example.com", City: "Phoenix"},
+	{Name: "Frank Miller", Age: 37, Email: "frank@example.com", City: "Philadelphia"},
+	{Name: "Grace Lee", Age: 25, Email: "grace@example.com", City: "San Antonio"},
+	{Name: "Henry Taylor", Age: 33, Email: "henry@example.com", City: "San Diego"},
+	{Name: "Ivy Chen", Age: 26, Email: "ivy@example.com", City: "Dallas"},
+	{Name: "Jack Anderson", Age: 31, Email: "jack@example.com", City: "San Jose"},
+}
+
+// The App component is the required entry point for every Tsunami application
+var App = app.DefineComponent("App", func(_ struct{}) any {
+	app.UseSetAppTitle("Table Test Demo")
+
+	// Define table columns
+	columns := []ui.TableColumn[Person]{
+		{
+			AccessorKey: "Name",
+			Header:      "Full Name",
+			Sortable:    true,
+			Width:       "200px",
+		},
+		{
+			AccessorKey: "Age", 
+			Header:      "Age",
+			Sortable:    true,
+			Width:       "80px",
+		},
+		{
+			AccessorKey: "Email",
+			Header:      "Email Address", 
+			Sortable:    true,
+			Width:       "250px",
+		},
+		{
+			AccessorKey: "City",
+			Header:      "City",
+			Sortable:    true,
+			Width:       "150px",
+		},
+	}
+
+	// Handle row clicks
+	handleRowClick := func(person Person, idx int) {
+		fmt.Printf("Clicked on row %d: %s from %s\n", idx, person.Name, person.City)
+	}
+
+	// Handle sorting
+	handleSort := func(column string, direction string) {
+		fmt.Printf("Sorting by %s in %s order\n", column, direction)
+	}
+
+	return vdom.H("div", map[string]any{
+		"className": "max-w-6xl mx-auto p-6 space-y-6",
+	},
+		vdom.H("div", map[string]any{
+			"className": "text-center",
+		},
+			vdom.H("h1", map[string]any{
+				"className": "text-3xl font-bold text-white mb-2",
+			}, "Table Component Demo"),
+			vdom.H("p", map[string]any{
+				"className": "text-gray-300",
+			}, "Testing the Tsunami table component with sample data"),
+		),
+
+		vdom.H("div", map[string]any{
+			"className": "bg-gray-800 p-4 rounded-lg",
+		},
+			PersonTable(ui.TableProps[Person]{
+				Data:        sampleData,
+				Columns:     columns,
+				OnRowClick:  handleRowClick,
+				OnSort:      handleSort,
+				DefaultSort: "Name",
+				Selectable:  true,
+				Pagination: &ui.PaginationConfig{
+					PageSize:    5,
+					CurrentPage: 0,
+					ShowSizes:   []int{5, 10, 25},
+				},
+			}),
+		),
+
+		vdom.H("div", map[string]any{
+			"className": "text-center text-gray-400 text-sm",
+		}, "Click on rows to see interactions. Try sorting by clicking column headers."),
+	)
+})
\ No newline at end of file
diff --git a/tsunami/demo/tabletest/go.mod b/tsunami/demo/tabletest/go.mod
new file mode 100644
index 0000000000..86b7209a5a
--- /dev/null
+++ b/tsunami/demo/tabletest/go.mod
@@ -0,0 +1,12 @@
+module tsunami/app/tabletest
+
+go 1.24.6
+
+require github.com/wavetermdev/waveterm/tsunami v0.0.0
+
+require (
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/outrigdev/goid v0.3.0 // indirect
+)
+
+replace github.com/wavetermdev/waveterm/tsunami => /Users/mike/work/waveterm/tsunami
diff --git a/tsunami/demo/tabletest/go.sum b/tsunami/demo/tabletest/go.sum
new file mode 100644
index 0000000000..4c44991dfc
--- /dev/null
+++ b/tsunami/demo/tabletest/go.sum
@@ -0,0 +1,4 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/outrigdev/goid v0.3.0 h1:t/otQD3EXc45cLtQVPUnNgEyRaTQA4cPeu3qVcrsIws=
+github.com/outrigdev/goid v0.3.0/go.mod h1:hEH7f27ypN/GHWt/7gvkRoFYR0LZizfUBIAbak4neVE=
diff --git a/tsunami/demo/tabletest/static/tw.css b/tsunami/demo/tabletest/static/tw.css
new file mode 100644
index 0000000000..e4a6426655
--- /dev/null
+++ b/tsunami/demo/tabletest/static/tw.css
@@ -0,0 +1,1279 @@
+/*! tailwindcss v4.1.13 | MIT License | https://tailwindcss.com */
+@layer properties;
+@layer theme, base, components, utilities;
+@layer theme {
+  :root, :host {
+    --font-sans: "Inter", sans-serif;
+    --font-mono: "Hack", monospace;
+    --color-blue-400: oklch(70.7% 0.165 254.624);
+    --color-blue-500: oklch(62.3% 0.214 259.815);
+    --color-blue-600: oklch(54.6% 0.245 262.881);
+    --color-blue-700: oklch(48.8% 0.243 264.376);
+    --color-blue-900: oklch(37.9% 0.146 265.522);
+    --color-gray-300: oklch(87.2% 0.01 258.338);
+    --color-gray-400: oklch(70.7% 0.022 261.325);
+    --color-gray-500: oklch(55.1% 0.027 264.364);
+    --color-gray-600: oklch(44.6% 0.03 256.802);
+    --color-gray-700: oklch(37.3% 0.034 259.733);
+    --color-gray-800: oklch(27.8% 0.033 256.848);
+    --color-gray-900: oklch(21% 0.034 264.665);
+    --color-white: #fff;
+    --spacing: 0.25rem;
+    --container-6xl: 72rem;
+    --text-sm: 0.875rem;
+    --text-sm--line-height: calc(1.25 / 0.875);
+    --text-base: 1rem;
+    --text-base--line-height: calc(1.5 / 1);
+    --text-lg: 1.125rem;
+    --text-lg--line-height: calc(1.75 / 1.125);
+    --text-xl: 1.25rem;
+    --text-xl--line-height: calc(1.75 / 1.25);
+    --text-2xl: 1.5rem;
+    --text-2xl--line-height: calc(2 / 1.5);
+    --text-3xl: 1.875rem;
+    --text-3xl--line-height: calc(2.25 / 1.875);
+    --font-weight-semibold: 600;
+    --font-weight-bold: 700;
+    --leading-relaxed: 1.625;
+    --radius-lg: 0.5rem;
+    --ease-in: cubic-bezier(0.4, 0, 1, 1);
+    --ease-out: cubic-bezier(0, 0, 0.2, 1);
+    --ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-transition-duration: 150ms;
+    --default-transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+    --default-font-family: var(--font-sans);
+    --default-mono-font-family: var(--font-mono);
+    --radius: 8px;
+    --color-background: rgb(34, 34, 34);
+    --color-primary: rgb(247, 247, 247);
+    --color-secondary: rgba(215, 218, 224, 0.7);
+    --color-muted: rgba(215, 218, 224, 0.5);
+    --color-accent-300: rgb(110, 231, 133);
+    --color-panel: rgba(255, 255, 255, 0.12);
+    --color-border: rgba(255, 255, 255, 0.16);
+    --color-accent: rgb(88, 193, 66);
+  }
+}
+@layer base {
+  *, ::after, ::before, ::backdrop, ::file-selector-button {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+    border: 0 solid;
+  }
+  html, :host {
+    line-height: 1.5;
+    -webkit-text-size-adjust: 100%;
+    tab-size: 4;
+    font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");
+    font-feature-settings: var(--default-font-feature-settings, normal);
+    font-variation-settings: var(--default-font-variation-settings, normal);
+    -webkit-tap-highlight-color: transparent;
+  }
+  hr {
+    height: 0;
+    color: inherit;
+    border-top-width: 1px;
+  }
+  abbr:where([title]) {
+    -webkit-text-decoration: underline dotted;
+    text-decoration: underline dotted;
+  }
+  h1, h2, h3, h4, h5, h6 {
+    font-size: inherit;
+    font-weight: inherit;
+  }
+  a {
+    color: inherit;
+    -webkit-text-decoration: inherit;
+    text-decoration: inherit;
+  }
+  b, strong {
+    font-weight: bolder;
+  }
+  code, kbd, samp, pre {
+    font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
+    font-feature-settings: var(--default-mono-font-feature-settings, normal);
+    font-variation-settings: var(--default-mono-font-variation-settings, normal);
+    font-size: 1em;
+  }
+  small {
+    font-size: 80%;
+  }
+  sub, sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+  }
+  sub {
+    bottom: -0.25em;
+  }
+  sup {
+    top: -0.5em;
+  }
+  table {
+    text-indent: 0;
+    border-color: inherit;
+    border-collapse: collapse;
+  }
+  :-moz-focusring {
+    outline: auto;
+  }
+  progress {
+    vertical-align: baseline;
+  }
+  summary {
+    display: list-item;
+  }
+  ol, ul, menu {
+    list-style: none;
+  }
+  img, svg, video, canvas, audio, iframe, embed, object {
+    display: block;
+    vertical-align: middle;
+  }
+  img, video {
+    max-width: 100%;
+    height: auto;
+  }
+  button, input, select, optgroup, textarea, ::file-selector-button {
+    font: inherit;
+    font-feature-settings: inherit;
+    font-variation-settings: inherit;
+    letter-spacing: inherit;
+    color: inherit;
+    border-radius: 0;
+    background-color: transparent;
+    opacity: 1;
+  }
+  :where(select:is([multiple], [size])) optgroup {
+    font-weight: bolder;
+  }
+  :where(select:is([multiple], [size])) optgroup option {
+    padding-inline-start: 20px;
+  }
+  ::file-selector-button {
+    margin-inline-end: 4px;
+  }
+  ::placeholder {
+    opacity: 1;
+  }
+  @supports (not (-webkit-appearance: -apple-pay-button))  or (contain-intrinsic-size: 1px) {
+    ::placeholder {
+      color: currentcolor;
+      @supports (color: color-mix(in lab, red, red)) {
+        color: color-mix(in oklab, currentcolor 50%, transparent);
+      }
+    }
+  }
+  textarea {
+    resize: vertical;
+  }
+  ::-webkit-search-decoration {
+    -webkit-appearance: none;
+  }
+  ::-webkit-date-and-time-value {
+    min-height: 1lh;
+    text-align: inherit;
+  }
+  ::-webkit-datetime-edit {
+    display: inline-flex;
+  }
+  ::-webkit-datetime-edit-fields-wrapper {
+    padding: 0;
+  }
+  ::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field {
+    padding-block: 0;
+  }
+  ::-webkit-calendar-picker-indicator {
+    line-height: 1;
+  }
+  :-moz-ui-invalid {
+    box-shadow: none;
+  }
+  button, input:where([type="button"], [type="reset"], [type="submit"]), ::file-selector-button {
+    appearance: button;
+  }
+  ::-webkit-inner-spin-button, ::-webkit-outer-spin-button {
+    height: auto;
+  }
+  [hidden]:where(:not([hidden="until-found"])) {
+    display: none !important;
+  }
+}
+@layer utilities {
+  .collapse {
+    visibility: collapse;
+  }
+  .invisible {
+    visibility: hidden;
+  }
+  .visible {
+    visibility: visible;
+  }
+  .sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border-width: 0;
+  }
+  .not-sr-only {
+    position: static;
+    width: auto;
+    height: auto;
+    padding: 0;
+    margin: 0;
+    overflow: visible;
+    clip-path: none;
+    white-space: normal;
+  }
+  .absolute {
+    position: absolute;
+  }
+  .fixed {
+    position: fixed;
+  }
+  .relative {
+    position: relative;
+  }
+  .static {
+    position: static;
+  }
+  .sticky {
+    position: sticky;
+  }
+  .isolate {
+    isolation: isolate;
+  }
+  .isolation-auto {
+    isolation: auto;
+  }
+  .container {
+    width: 100%;
+    @media (width >= 40rem) {
+      max-width: 40rem;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem;
+    }
+  }
+  .mx-1 {
+    margin-inline: calc(var(--spacing) * 1);
+  }
+  .mx-auto {
+    margin-inline: auto;
+  }
+  .my-6 {
+    margin-block: calc(var(--spacing) * 6);
+  }
+  .mt-3 {
+    margin-top: calc(var(--spacing) * 3);
+  }
+  .mt-4 {
+    margin-top: calc(var(--spacing) * 4);
+  }
+  .mt-5 {
+    margin-top: calc(var(--spacing) * 5);
+  }
+  .mt-6 {
+    margin-top: calc(var(--spacing) * 6);
+  }
+  .mb-2 {
+    margin-bottom: calc(var(--spacing) * 2);
+  }
+  .mb-3 {
+    margin-bottom: calc(var(--spacing) * 3);
+  }
+  .mb-4 {
+    margin-bottom: calc(var(--spacing) * 4);
+  }
+  .ml-4 {
+    margin-left: calc(var(--spacing) * 4);
+  }
+  .block {
+    display: block;
+  }
+  .contents {
+    display: contents;
+  }
+  .flex {
+    display: flex;
+  }
+  .flow-root {
+    display: flow-root;
+  }
+  .grid {
+    display: grid;
+  }
+  .hidden {
+    display: none;
+  }
+  .inline {
+    display: inline;
+  }
+  .inline-block {
+    display: inline-block;
+  }
+  .inline-flex {
+    display: inline-flex;
+  }
+  .inline-grid {
+    display: inline-grid;
+  }
+  .inline-table {
+    display: inline-table;
+  }
+  .list-item {
+    display: list-item;
+  }
+  .table {
+    display: table;
+  }
+  .table-caption {
+    display: table-caption;
+  }
+  .table-cell {
+    display: table-cell;
+  }
+  .table-column {
+    display: table-column;
+  }
+  .table-column-group {
+    display: table-column-group;
+  }
+  .table-footer-group {
+    display: table-footer-group;
+  }
+  .table-header-group {
+    display: table-header-group;
+  }
+  .table-row {
+    display: table-row;
+  }
+  .table-row-group {
+    display: table-row-group;
+  }
+  .min-h-full {
+    min-height: 100%;
+  }
+  .min-h-screen {
+    min-height: 100vh;
+  }
+  .w-full {
+    width: 100%;
+  }
+  .max-w-6xl {
+    max-width: var(--container-6xl);
+  }
+  .max-w-none {
+    max-width: none;
+  }
+  .min-w-full {
+    min-width: 100%;
+  }
+  .shrink {
+    flex-shrink: 1;
+  }
+  .grow {
+    flex-grow: 1;
+  }
+  .border-collapse {
+    border-collapse: collapse;
+  }
+  .translate-none {
+    translate: none;
+  }
+  .scale-3d {
+    scale: var(--tw-scale-x) var(--tw-scale-y) var(--tw-scale-z);
+  }
+  .transform {
+    transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,);
+  }
+  .cursor-not-allowed {
+    cursor: not-allowed;
+  }
+  .cursor-pointer {
+    cursor: pointer;
+  }
+  .touch-pinch-zoom {
+    --tw-pinch-zoom: pinch-zoom;
+    touch-action: var(--tw-pan-x,) var(--tw-pan-y,) var(--tw-pinch-zoom,);
+  }
+  .resize {
+    resize: both;
+  }
+  .list-inside {
+    list-style-position: inside;
+  }
+  .list-decimal {
+    list-style-type: decimal;
+  }
+  .list-disc {
+    list-style-type: disc;
+  }
+  .flex-wrap {
+    flex-wrap: wrap;
+  }
+  .items-center {
+    align-items: center;
+  }
+  .justify-between {
+    justify-content: space-between;
+  }
+  .gap-2 {
+    gap: calc(var(--spacing) * 2);
+  }
+  .gap-3 {
+    gap: calc(var(--spacing) * 3);
+  }
+  .space-y-1 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-6 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 6) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 6) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
+  .space-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 1;
+    }
+  }
+  .space-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-space-x-reverse: 1;
+    }
+  }
+  .divide-x {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 0;
+      border-inline-style: var(--tw-border-style);
+      border-inline-start-width: calc(1px * var(--tw-divide-x-reverse));
+      border-inline-end-width: calc(1px * calc(1 - var(--tw-divide-x-reverse)));
+    }
+  }
+  .divide-y {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 0;
+      border-bottom-style: var(--tw-border-style);
+      border-top-style: var(--tw-border-style);
+      border-top-width: calc(1px * var(--tw-divide-y-reverse));
+      border-bottom-width: calc(1px * calc(1 - var(--tw-divide-y-reverse)));
+    }
+  }
+  .divide-y-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-y-reverse: 1;
+    }
+  }
+  .divide-gray-700 {
+    :where(& > :not(:last-child)) {
+      border-color: var(--color-gray-700);
+    }
+  }
+  .truncate {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+  .overflow-auto {
+    overflow: auto;
+  }
+  .overflow-x-auto {
+    overflow-x: auto;
+  }
+  .rounded {
+    border-radius: var(--radius);
+  }
+  .rounded-lg {
+    border-radius: var(--radius-lg);
+  }
+  .rounded-s {
+    border-start-start-radius: var(--radius);
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-ss {
+    border-start-start-radius: var(--radius);
+  }
+  .rounded-e {
+    border-start-end-radius: var(--radius);
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-se {
+    border-start-end-radius: var(--radius);
+  }
+  .rounded-ee {
+    border-end-end-radius: var(--radius);
+  }
+  .rounded-es {
+    border-end-start-radius: var(--radius);
+  }
+  .rounded-t {
+    border-top-left-radius: var(--radius);
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-l {
+    border-top-left-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-tl {
+    border-top-left-radius: var(--radius);
+  }
+  .rounded-r {
+    border-top-right-radius: var(--radius);
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-tr {
+    border-top-right-radius: var(--radius);
+  }
+  .rounded-b {
+    border-bottom-right-radius: var(--radius);
+    border-bottom-left-radius: var(--radius);
+  }
+  .rounded-br {
+    border-bottom-right-radius: var(--radius);
+  }
+  .rounded-bl {
+    border-bottom-left-radius: var(--radius);
+  }
+  .border {
+    border-style: var(--tw-border-style);
+    border-width: 1px;
+  }
+  .border-x {
+    border-inline-style: var(--tw-border-style);
+    border-inline-width: 1px;
+  }
+  .border-y {
+    border-block-style: var(--tw-border-style);
+    border-block-width: 1px;
+  }
+  .border-s {
+    border-inline-start-style: var(--tw-border-style);
+    border-inline-start-width: 1px;
+  }
+  .border-e {
+    border-inline-end-style: var(--tw-border-style);
+    border-inline-end-width: 1px;
+  }
+  .border-t {
+    border-top-style: var(--tw-border-style);
+    border-top-width: 1px;
+  }
+  .border-r {
+    border-right-style: var(--tw-border-style);
+    border-right-width: 1px;
+  }
+  .border-b {
+    border-bottom-style: var(--tw-border-style);
+    border-bottom-width: 1px;
+  }
+  .border-l {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 1px;
+  }
+  .border-l-4 {
+    border-left-style: var(--tw-border-style);
+    border-left-width: 4px;
+  }
+  .border-border {
+    border-color: var(--color-border);
+  }
+  .border-gray-600 {
+    border-color: var(--color-gray-600);
+  }
+  .bg-background {
+    background-color: var(--color-background);
+  }
+  .bg-blue-600 {
+    background-color: var(--color-blue-600);
+  }
+  .bg-blue-900 {
+    background-color: var(--color-blue-900);
+  }
+  .bg-gray-600 {
+    background-color: var(--color-gray-600);
+  }
+  .bg-gray-700 {
+    background-color: var(--color-gray-700);
+  }
+  .bg-gray-800 {
+    background-color: var(--color-gray-800);
+  }
+  .bg-gray-900 {
+    background-color: var(--color-gray-900);
+  }
+  .bg-panel {
+    background-color: var(--color-panel);
+  }
+  .bg-repeat {
+    background-repeat: repeat;
+  }
+  .mask-no-clip {
+    mask-clip: no-clip;
+  }
+  .mask-repeat {
+    mask-repeat: repeat;
+  }
+  .p-3 {
+    padding: calc(var(--spacing) * 3);
+  }
+  .p-4 {
+    padding: calc(var(--spacing) * 4);
+  }
+  .p-6 {
+    padding: calc(var(--spacing) * 6);
+  }
+  .px-1 {
+    padding-inline: calc(var(--spacing) * 1);
+  }
+  .px-2 {
+    padding-inline: calc(var(--spacing) * 2);
+  }
+  .px-3 {
+    padding-inline: calc(var(--spacing) * 3);
+  }
+  .px-4 {
+    padding-inline: calc(var(--spacing) * 4);
+  }
+  .py-0\.5 {
+    padding-block: calc(var(--spacing) * 0.5);
+  }
+  .py-1 {
+    padding-block: calc(var(--spacing) * 1);
+  }
+  .py-1\.5 {
+    padding-block: calc(var(--spacing) * 1.5);
+  }
+  .py-2 {
+    padding-block: calc(var(--spacing) * 2);
+  }
+  .py-3 {
+    padding-block: calc(var(--spacing) * 3);
+  }
+  .pl-4 {
+    padding-left: calc(var(--spacing) * 4);
+  }
+  .text-center {
+    text-align: center;
+  }
+  .text-left {
+    text-align: left;
+  }
+  .font-mono {
+    font-family: var(--font-mono);
+  }
+  .text-2xl {
+    font-size: var(--text-2xl);
+    line-height: var(--tw-leading, var(--text-2xl--line-height));
+  }
+  .text-3xl {
+    font-size: var(--text-3xl);
+    line-height: var(--tw-leading, var(--text-3xl--line-height));
+  }
+  .text-base {
+    font-size: var(--text-base);
+    line-height: var(--tw-leading, var(--text-base--line-height));
+  }
+  .text-lg {
+    font-size: var(--text-lg);
+    line-height: var(--tw-leading, var(--text-lg--line-height));
+  }
+  .text-sm {
+    font-size: var(--text-sm);
+    line-height: var(--tw-leading, var(--text-sm--line-height));
+  }
+  .text-xl {
+    font-size: var(--text-xl);
+    line-height: var(--tw-leading, var(--text-xl--line-height));
+  }
+  .leading-relaxed {
+    --tw-leading: var(--leading-relaxed);
+    line-height: var(--leading-relaxed);
+  }
+  .font-bold {
+    --tw-font-weight: var(--font-weight-bold);
+    font-weight: var(--font-weight-bold);
+  }
+  .font-semibold {
+    --tw-font-weight: var(--font-weight-semibold);
+    font-weight: var(--font-weight-semibold);
+  }
+  .text-wrap {
+    text-wrap: wrap;
+  }
+  .text-clip {
+    text-overflow: clip;
+  }
+  .text-ellipsis {
+    text-overflow: ellipsis;
+  }
+  .text-accent {
+    color: var(--color-accent);
+  }
+  .text-blue-400 {
+    color: var(--color-blue-400);
+  }
+  .text-gray-300 {
+    color: var(--color-gray-300);
+  }
+  .text-gray-400 {
+    color: var(--color-gray-400);
+  }
+  .text-gray-500 {
+    color: var(--color-gray-500);
+  }
+  .text-muted {
+    color: var(--color-muted);
+  }
+  .text-primary {
+    color: var(--color-primary);
+  }
+  .text-secondary {
+    color: var(--color-secondary);
+  }
+  .text-white {
+    color: var(--color-white);
+  }
+  .capitalize {
+    text-transform: capitalize;
+  }
+  .lowercase {
+    text-transform: lowercase;
+  }
+  .normal-case {
+    text-transform: none;
+  }
+  .uppercase {
+    text-transform: uppercase;
+  }
+  .italic {
+    font-style: italic;
+  }
+  .not-italic {
+    font-style: normal;
+  }
+  .diagonal-fractions {
+    --tw-numeric-fraction: diagonal-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .lining-nums {
+    --tw-numeric-figure: lining-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .oldstyle-nums {
+    --tw-numeric-figure: oldstyle-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .ordinal {
+    --tw-ordinal: ordinal;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .proportional-nums {
+    --tw-numeric-spacing: proportional-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .slashed-zero {
+    --tw-slashed-zero: slashed-zero;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .stacked-fractions {
+    --tw-numeric-fraction: stacked-fractions;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .tabular-nums {
+    --tw-numeric-spacing: tabular-nums;
+    font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,);
+  }
+  .normal-nums {
+    font-variant-numeric: normal;
+  }
+  .line-through {
+    text-decoration-line: line-through;
+  }
+  .no-underline {
+    text-decoration-line: none;
+  }
+  .overline {
+    text-decoration-line: overline;
+  }
+  .underline {
+    text-decoration-line: underline;
+  }
+  .antialiased {
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+  .subpixel-antialiased {
+    -webkit-font-smoothing: auto;
+    -moz-osx-font-smoothing: auto;
+  }
+  .shadow {
+    --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .inset-ring {
+    --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
+    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+  }
+  .blur {
+    --tw-blur: blur(8px);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .drop-shadow {
+    --tw-drop-shadow-size: drop-shadow(0 1px 2px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.1))) drop-shadow(0 1px 1px var(--tw-drop-shadow-color, rgb(0 0 0 / 0.06)));
+    --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .invert {
+    --tw-invert: invert(100%);
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .filter {
+    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
+  }
+  .backdrop-blur {
+    --tw-backdrop-blur: blur(8px);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-grayscale {
+    --tw-backdrop-grayscale: grayscale(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-invert {
+    --tw-backdrop-invert: invert(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-sepia {
+    --tw-backdrop-sepia: sepia(100%);
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .backdrop-filter {
+    -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+    backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
+  }
+  .transition-colors {
+    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .ease-in {
+    --tw-ease: var(--ease-in);
+    transition-timing-function: var(--ease-in);
+  }
+  .ease-in-out {
+    --tw-ease: var(--ease-in-out);
+    transition-timing-function: var(--ease-in-out);
+  }
+  .ease-out {
+    --tw-ease: var(--ease-out);
+    transition-timing-function: var(--ease-out);
+  }
+  .divide-x-reverse {
+    :where(& > :not(:last-child)) {
+      --tw-divide-x-reverse: 1;
+    }
+  }
+  .ring-inset {
+    --tw-ring-inset: inset;
+  }
+  .hover\:bg-blue-700 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-blue-700);
+      }
+    }
+  }
+  .hover\:bg-gray-700 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-gray-700);
+      }
+    }
+  }
+  .hover\:bg-gray-800 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-gray-800);
+      }
+    }
+  }
+  .hover\:text-accent-300 {
+    &:hover {
+      @media (hover: hover) {
+        color: var(--color-accent-300);
+      }
+    }
+  }
+  .focus\:bg-gray-600 {
+    &:focus {
+      background-color: var(--color-gray-600);
+    }
+  }
+  .focus\:ring-1 {
+    &:focus {
+      --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
+      box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+    }
+  }
+  .focus\:ring-blue-500 {
+    &:focus {
+      --tw-ring-color: var(--color-blue-500);
+    }
+  }
+  .focus\:outline-none {
+    &:focus {
+      --tw-outline-style: none;
+      outline-style: none;
+    }
+  }
+}
+@property --tw-scale-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-z {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-rotate-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-rotate-z {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-skew-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-x {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pan-y {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-pinch-zoom {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-space-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-space-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-divide-x-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-border-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-divide-y-reverse {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-leading {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-font-weight {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ordinal {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-slashed-zero {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-figure {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-spacing {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-numeric-fraction {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-inset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-ring-inset {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-offset-width {
+  syntax: "<length>";
+  inherits: false;
+  initial-value: 0px;
+}
+@property --tw-ring-offset-color {
+  syntax: "*";
+  inherits: false;
+  initial-value: #fff;
+}
+@property --tw-ring-offset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-drop-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-drop-shadow-size {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-blur {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-brightness {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-contrast {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-grayscale {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-hue-rotate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-invert {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-opacity {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-saturate {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-backdrop-sepia {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ease {
+  syntax: "*";
+  inherits: false;
+}
+@layer properties {
+  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
+    *, ::before, ::after, ::backdrop {
+      --tw-scale-x: 1;
+      --tw-scale-y: 1;
+      --tw-scale-z: 1;
+      --tw-rotate-x: initial;
+      --tw-rotate-y: initial;
+      --tw-rotate-z: initial;
+      --tw-skew-x: initial;
+      --tw-skew-y: initial;
+      --tw-pan-x: initial;
+      --tw-pan-y: initial;
+      --tw-pinch-zoom: initial;
+      --tw-space-y-reverse: 0;
+      --tw-space-x-reverse: 0;
+      --tw-divide-x-reverse: 0;
+      --tw-border-style: solid;
+      --tw-divide-y-reverse: 0;
+      --tw-leading: initial;
+      --tw-font-weight: initial;
+      --tw-ordinal: initial;
+      --tw-slashed-zero: initial;
+      --tw-numeric-figure: initial;
+      --tw-numeric-spacing: initial;
+      --tw-numeric-fraction: initial;
+      --tw-shadow: 0 0 #0000;
+      --tw-shadow-color: initial;
+      --tw-shadow-alpha: 100%;
+      --tw-inset-shadow: 0 0 #0000;
+      --tw-inset-shadow-color: initial;
+      --tw-inset-shadow-alpha: 100%;
+      --tw-ring-color: initial;
+      --tw-ring-shadow: 0 0 #0000;
+      --tw-inset-ring-color: initial;
+      --tw-inset-ring-shadow: 0 0 #0000;
+      --tw-ring-inset: initial;
+      --tw-ring-offset-width: 0px;
+      --tw-ring-offset-color: #fff;
+      --tw-ring-offset-shadow: 0 0 #0000;
+      --tw-blur: initial;
+      --tw-brightness: initial;
+      --tw-contrast: initial;
+      --tw-grayscale: initial;
+      --tw-hue-rotate: initial;
+      --tw-invert: initial;
+      --tw-opacity: initial;
+      --tw-saturate: initial;
+      --tw-sepia: initial;
+      --tw-drop-shadow: initial;
+      --tw-drop-shadow-color: initial;
+      --tw-drop-shadow-alpha: 100%;
+      --tw-drop-shadow-size: initial;
+      --tw-backdrop-blur: initial;
+      --tw-backdrop-brightness: initial;
+      --tw-backdrop-contrast: initial;
+      --tw-backdrop-grayscale: initial;
+      --tw-backdrop-hue-rotate: initial;
+      --tw-backdrop-invert: initial;
+      --tw-backdrop-opacity: initial;
+      --tw-backdrop-saturate: initial;
+      --tw-backdrop-sepia: initial;
+      --tw-ease: initial;
+    }
+  }
+}
diff --git a/tsunami/ui/table.go b/tsunami/ui/table.go
new file mode 100644
index 0000000000..827163147b
--- /dev/null
+++ b/tsunami/ui/table.go
@@ -0,0 +1,545 @@
+package ui
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strconv"
+
+	"github.com/wavetermdev/waveterm/tsunami/app"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+// Core table types
+type CellContext[T any] struct {
+	Data   T      `json:"row"`
+	Value  any    `json:"value"`
+	RowIdx int    `json:"rowIdx"`
+	ColIdx int    `json:"colIdx"`
+	Column string `json:"column"`
+}
+
+type RowContext[T any] struct {
+	Data   T   `json:"row"`
+	RowIdx int `json:"rowIdx"`
+}
+
+type HeaderContext struct {
+	Column        string `json:"column"`
+	IsSorted      bool   `json:"isSorted"`
+	SortDirection string `json:"sortDirection"`
+}
+
+// Column definition - similar to TanStack Table
+type TableColumn[T any] struct {
+	AccessorKey     string                         `json:"accessorKey"` // Field name in the data
+	AccessorFn      func(rowCtx RowContext[T]) any `json:"-"`           // Function to extract value from row
+	Header          string                         `json:"header"`      // Display name
+	Width           string                         `json:"width,omitempty"`
+	Sortable        bool                           `json:"sortable"`
+	CellClassName   string
+	HeaderClassName string
+	CellRender      func(ctx CellContext[T]) any `json:"-"` // Custom cell renderer
+	HeaderRender    func(ctx HeaderContext) any  `json:"-"` // Custom header renderer
+}
+
+// Table props
+type TableProps[T any] struct {
+	Data              []T                                   `json:"data"`
+	Columns           []TableColumn[T]                      `json:"columns"`
+	RowRender         func(ctx RowContext[T]) any           `json:"-"` // Custom row renderer (overrides columns)
+	RowClassName      func(ctx RowContext[T]) string        `json:"-"` // Custom row class names
+	OnRowClick        func(row T, idx int)                  `json:"-"`
+	OnSort            func(column string, direction string) `json:"-"`
+	DefaultSort       string                                `json:"defaultSort,omitempty"`
+	Pagination        *PaginationConfig                     `json:"pagination,omitempty"`
+	Selectable        bool                                  `json:"selectable"`
+	SelectedRows      []int                                 `json:"selectedRows,omitempty"`
+	OnSelectionChange func(selectedRows []int)              `json:"-"`
+}
+
+type PaginationConfig struct {
+	PageSize    int   `json:"pageSize"`
+	CurrentPage int   `json:"currentPage"`
+	ShowSizes   []int `json:"showSizes,omitempty"` // [10, 25, 50, 100]
+}
+
+// Helper to extract field value from struct/map using reflection
+func getFieldValueWithReflection(item any, key string) any {
+	if item == nil {
+		return nil
+	}
+
+	// Handle map[string]any
+	if m, ok := item.(map[string]any); ok {
+		return m[key]
+	}
+
+	// Handle struct via reflection
+	v := reflect.ValueOf(item)
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+	if v.Kind() != reflect.Struct {
+		return nil
+	}
+
+	field := v.FieldByName(key)
+	if !field.IsValid() {
+		return nil
+	}
+	return field.Interface()
+}
+
+// Generic helper to extract field value using either AccessorFn or reflection
+func getFieldValue[T any](row T, rowIdx int, col TableColumn[T]) any {
+	if col.AccessorFn != nil {
+		return col.AccessorFn(RowContext[T]{
+			Data:   row,
+			RowIdx: rowIdx,
+		})
+	}
+	return getFieldValueWithReflection(row, col.AccessorKey)
+}
+
+// Helper to find column by accessor key
+func findColumnByKey[T any](columns []TableColumn[T], key string) *TableColumn[T] {
+	for _, col := range columns {
+		if col.AccessorKey == key {
+			return &col
+		}
+	}
+	return nil
+}
+
+// Sort data by column
+func sortData[T any](data []T, col TableColumn[T], direction string) []T {
+	if len(data) == 0 || (col.AccessorKey == "" && col.AccessorFn == nil) {
+		return data
+	}
+
+	sorted := make([]T, len(data))
+	copy(sorted, data)
+
+	sort.Slice(sorted, func(i, j int) bool {
+		valI := getFieldValue(sorted[i], i, col)
+		valJ := getFieldValue(sorted[j], j, col)
+
+		// Handle nil values
+		if valI == nil && valJ == nil {
+			return false
+		}
+		if valI == nil {
+			return direction == "asc"
+		}
+		if valJ == nil {
+			return direction == "desc"
+		}
+
+		// Convert to strings for comparison (could be enhanced for numbers/dates)
+		strI := fmt.Sprintf("%v", valI)
+		strJ := fmt.Sprintf("%v", valJ)
+
+		if direction == "asc" {
+			return strI < strJ
+		}
+		return strI > strJ
+	})
+
+	return sorted
+}
+
+// Paginate data
+func paginateData[T any](data []T, config *PaginationConfig) []T {
+	if config == nil || len(data) == 0 {
+		return data
+	}
+
+	start := config.CurrentPage * config.PageSize
+	end := start + config.PageSize
+
+	if start >= len(data) {
+		return []T{}
+	}
+	if end > len(data) {
+		end = len(data)
+	}
+
+	return data[start:end]
+}
+
+// Default cell renderer
+func defaultCellRenderer[T any](ctx CellContext[T]) any {
+	if ctx.Value == nil {
+		return vdom.H("span", map[string]any{
+			"className": "text-gray-500",
+		}, "-")
+	}
+
+	return vdom.H("span", nil, fmt.Sprintf("%v", ctx.Value))
+}
+
+// Default header renderer
+func defaultHeaderRenderer(ctx HeaderContext) any {
+	return vdom.H("div", map[string]any{
+		"className": "flex items-center gap-2",
+	},
+		vdom.H("span", nil, ctx.Column),
+		vdom.If(ctx.IsSorted,
+			vdom.H("span", map[string]any{
+				"className": "text-blue-400",
+			}, vdom.IfElse(ctx.SortDirection == "asc", "↑", "↓")),
+		),
+	)
+}
+
+// Helper function to safely call RowClassName function
+func makeRowClassName[T any](rowClassNameFunc func(ctx RowContext[T]) string, rowCtx RowContext[T]) string {
+	if rowClassNameFunc == nil {
+		return ""
+	}
+	return rowClassNameFunc(rowCtx)
+}
+
+func MakeTableComponent[T any](componentName string) vdom.Component[TableProps[T]] {
+	return app.DefineComponent(componentName, genTableRenderFunc[T])
+}
+
+func genTableRenderFunc[T any](props TableProps[T]) any {
+	// State for sorting
+	sortColumnAtom := app.UseLocal(props.DefaultSort)
+	sortDirectionAtom := app.UseLocal("asc")
+
+	// State for pagination - initialize with prop values
+	initialPage := 0
+	initialPageSize := 25
+	if props.Pagination != nil {
+		initialPage = props.Pagination.CurrentPage
+		initialPageSize = props.Pagination.PageSize
+	}
+	currentPageAtom := app.UseLocal(initialPage)
+	pageSizeAtom := app.UseLocal(initialPageSize)
+
+	// State for selection - initialize with empty slice if nil
+	initialSelection := props.SelectedRows
+	if initialSelection == nil {
+		initialSelection = []int{}
+	}
+	selectedRowsAtom := app.UseLocal(initialSelection)
+
+
+	// Handle sorting
+	handleSort := func(column string) {
+		currentSort := sortColumnAtom.Get()
+		currentDir := sortDirectionAtom.Get()
+
+		if currentSort == column {
+			// Toggle direction
+			newDir := vdom.IfElse(currentDir == "asc", "desc", "asc").(string)
+			sortDirectionAtom.Set(newDir)
+			if props.OnSort != nil {
+				props.OnSort(column, newDir)
+			}
+		} else {
+			// New column
+			sortColumnAtom.Set(column)
+			sortDirectionAtom.Set("asc")
+			if props.OnSort != nil {
+				props.OnSort(column, "asc")
+			}
+		}
+	}
+
+	// Handle row selection
+	handleRowSelect := func(rowIdx int) {
+		if !props.Selectable {
+			return
+		}
+
+		selectedRowsAtom.SetFn(func(current []int) []int {
+			// Toggle selection
+			for i, idx := range current {
+				if idx == rowIdx {
+					// Remove
+					return append(current[:i], current[i+1:]...)
+				}
+			}
+			// Add
+			return append(current, rowIdx)
+		})
+
+		if props.OnSelectionChange != nil {
+			props.OnSelectionChange(selectedRowsAtom.Get())
+		}
+	}
+
+	// Handle pagination
+	handlePageChange := func(page int) {
+		currentPageAtom.Set(page)
+	}
+
+	handlePageSizeChange := func(size int) {
+		pageSizeAtom.Set(size)
+		currentPageAtom.Set(0) // Reset to first page
+	}
+
+	// Process data
+	processedData := props.Data
+	if sortColumnAtom.Get() != "" {
+		if sortCol := findColumnByKey(props.Columns, sortColumnAtom.Get()); sortCol != nil {
+			processedData = sortData(processedData, *sortCol, sortDirectionAtom.Get())
+		}
+	}
+
+	totalRows := len(processedData)
+
+	// Apply pagination
+	paginationConfig := &PaginationConfig{
+		PageSize:    pageSizeAtom.Get(),
+		CurrentPage: currentPageAtom.Get(),
+	}
+
+	paginatedData := paginateData(processedData, paginationConfig)
+
+	// Get current state values
+	currentSort := sortColumnAtom.Get()
+	currentDir := sortDirectionAtom.Get()
+	currentSelected := selectedRowsAtom.Get()
+
+	return vdom.H("div", map[string]any{
+		"className": "w-full",
+	},
+		// Table
+		vdom.H("div", map[string]any{
+			"className": "overflow-auto border border-gray-600 rounded-lg",
+		},
+			vdom.H("table", map[string]any{
+				"className": "w-full bg-gray-900 text-white",
+			},
+				// Header
+				vdom.H("thead", map[string]any{
+					"className": "bg-gray-800 border-b border-gray-600",
+				},
+					vdom.H("tr", nil,
+						vdom.If(props.Selectable,
+							vdom.H("th", map[string]any{
+								"className": "p-3 text-left",
+								"style":     map[string]any{"width": "40px"},
+							},
+								vdom.H("input", map[string]any{
+									"type":    "checkbox",
+									"checked": len(currentSelected) == len(paginatedData) && len(paginatedData) > 0,
+									"onChange": func() {
+										if len(currentSelected) == len(paginatedData) {
+											selectedRowsAtom.Set([]int{})
+										} else {
+											allSelected := make([]int, len(paginatedData))
+											for i := range paginatedData {
+												allSelected[i] = i
+											}
+											selectedRowsAtom.Set(allSelected)
+										}
+									},
+								}),
+							),
+						),
+						vdom.ForEach(props.Columns, func(col TableColumn[T], colIdx int) any {
+							isSorted := currentSort == col.AccessorKey
+
+							headerCtx := HeaderContext{
+								Column:        col.Header,
+								IsSorted:      isSorted,
+								SortDirection: currentDir,
+							}
+
+							headerContent := defaultHeaderRenderer(headerCtx)
+							if col.HeaderRender != nil {
+								headerContent = col.HeaderRender(headerCtx)
+							}
+
+							return vdom.H("th", map[string]any{
+								"key": col.AccessorKey,
+								"className": vdom.Classes(
+									"p-3 text-left font-semibold",
+									vdom.If(col.Sortable, "cursor-pointer hover:bg-gray-700"),
+									col.HeaderClassName,
+								),
+								"style":   vdom.If(col.Width != "", map[string]any{"width": col.Width}),
+								"onClick": vdom.If(col.Sortable, func() { handleSort(col.AccessorKey) }),
+							}, headerContent)
+						}),
+					),
+				),
+
+				// Body
+				vdom.H("tbody", map[string]any{
+					"className": "divide-y divide-gray-700",
+				},
+					vdom.ForEach(paginatedData, func(row T, rowIdx int) any {
+						isSelected := func() bool {
+							for _, idx := range currentSelected {
+								if idx == rowIdx {
+									return true
+								}
+							}
+							return false
+						}()
+
+						// Custom row renderer
+						if props.RowRender != nil {
+							return props.RowRender(RowContext[T]{
+								Data:   row,
+								RowIdx: rowIdx,
+							})
+						}
+
+						// Default row rendering with columns
+						rowCtx := RowContext[T]{
+							Data:   row,
+							RowIdx: rowIdx,
+						}
+
+						return vdom.H("tr", map[string]any{
+							"key": rowIdx,
+							"className": vdom.Classes(
+								"hover:bg-gray-800 transition-colors",
+								vdom.If(isSelected, "bg-blue-900"),
+								vdom.If(props.OnRowClick != nil, "cursor-pointer"),
+								makeRowClassName(props.RowClassName, rowCtx),
+							),
+							"onClick": func() {
+								if props.OnRowClick != nil {
+									props.OnRowClick(row, rowIdx)
+								}
+							},
+						},
+							vdom.If(props.Selectable,
+								vdom.H("td", map[string]any{
+									"className": "p-3",
+								},
+									vdom.H("input", map[string]any{
+										"type":     "checkbox",
+										"checked":  isSelected,
+										"onChange": func() { handleRowSelect(rowIdx) },
+									}),
+								),
+							),
+							vdom.ForEach(props.Columns, func(col TableColumn[T], colIdx int) any {
+								var value any
+								value = getFieldValue(row, rowIdx, col)
+								cellCtx := CellContext[T]{
+									Data:   row,
+									Value:  value,
+									RowIdx: rowIdx,
+									ColIdx: colIdx,
+									Column: col.AccessorKey,
+								}
+
+								cellContent := defaultCellRenderer(cellCtx)
+								if col.CellRender != nil {
+									cellContent = col.CellRender(cellCtx)
+								}
+
+								return vdom.H("td", map[string]any{
+									"key":       col.AccessorKey,
+									"className": vdom.Classes("p-3", col.CellClassName),
+								}, cellContent)
+							}),
+						)
+					}),
+				),
+			),
+		),
+
+		// Pagination
+		vdom.If(props.Pagination != nil,
+			renderPagination(totalRows, paginationConfig, handlePageChange, handlePageSizeChange),
+		),
+	)
+}
+
+// Pagination component
+func renderPagination(totalRows int, config *PaginationConfig, onPageChange func(int), onPageSizeChange func(int)) any {
+	totalPages := (totalRows + config.PageSize - 1) / config.PageSize
+	currentPage := config.CurrentPage
+
+	return vdom.H("div", map[string]any{
+		"className": "flex items-center justify-between mt-4 px-4 py-3 bg-gray-800 rounded-lg",
+	},
+		// Page size selector
+		vdom.H("div", map[string]any{
+			"className": "flex items-center gap-2",
+		},
+			vdom.H("span", map[string]any{
+				"className": "text-sm text-gray-400",
+			}, "Show"),
+			vdom.H("select", map[string]any{
+				"className": "bg-gray-700 text-white rounded px-2 py-1 text-sm focus:outline-none focus:ring-1 focus:ring-blue-500 focus:bg-gray-600 mx-1",
+				"value":     strconv.Itoa(config.PageSize),
+				"onChange": func(e vdom.VDomEvent) {
+					if size, err := strconv.Atoi(e.TargetValue); err == nil {
+						onPageSizeChange(size)
+					}
+				},
+			},
+				vdom.H("option", map[string]any{"value": "10"}, "10"),
+				vdom.H("option", map[string]any{"value": "25"}, "25"),
+				vdom.H("option", map[string]any{"value": "50"}, "50"),
+				vdom.H("option", map[string]any{"value": "100"}, "100"),
+			),
+			vdom.H("span", map[string]any{
+				"className": "text-sm text-gray-400",
+			}, "entries"),
+		),
+
+		// Page info
+		vdom.H("span", map[string]any{
+			"className": "text-sm text-gray-400",
+		}, fmt.Sprintf("Showing %d-%d of %d",
+			currentPage*config.PageSize+1,
+			vdom.Ternary(currentPage*config.PageSize+config.PageSize > totalRows,
+				totalRows,
+				currentPage*config.PageSize+config.PageSize),
+			totalRows,
+		)),
+
+		// Page controls
+		vdom.H("div", map[string]any{
+			"className": "flex items-center gap-3",
+		},
+			vdom.H("button", map[string]any{
+				"className": vdom.Classes(
+					"px-3 py-1.5 rounded text-sm transition-colors",
+					vdom.IfElse(currentPage > 0,
+						"bg-blue-600 hover:bg-blue-700 text-white cursor-pointer",
+						"bg-gray-600 text-gray-500 cursor-not-allowed"),
+				),
+				"disabled": currentPage <= 0,
+				"onClick": func() {
+					if currentPage > 0 {
+						onPageChange(currentPage - 1)
+					}
+				},
+			}, "Previous"),
+
+			vdom.H("span", map[string]any{
+				"className": "text-sm text-gray-400 px-2",
+			}, fmt.Sprintf("Page %d of %d", currentPage+1, totalPages)),
+
+			vdom.H("button", map[string]any{
+				"className": vdom.Classes(
+					"px-3 py-1.5 rounded text-sm transition-colors",
+					vdom.IfElse(currentPage < totalPages-1,
+						"bg-blue-600 hover:bg-blue-700 text-white cursor-pointer",
+						"bg-gray-600 text-gray-500 cursor-not-allowed"),
+				),
+				"disabled": currentPage >= totalPages-1,
+				"onClick": func() {
+					if currentPage < totalPages-1 {
+						onPageChange(currentPage + 1)
+					}
+				},
+			}, "Next"),
+		),
+	)
+}

From da8c718c745eb36a860c6dcfffe979a9a986a237 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 11:48:25 -0700
Subject: [PATCH 111/134] fix tsunamiconfig, expose data in tabletest

---
 tsunami/demo/tabletest/app.go            |  8 +-
 tsunami/demo/tabletest/static/tw.css     |  7 +-
 tsunami/demo/tsunamiconfig/app.go        | 75 +++++++++---------
 tsunami/demo/tsunamiconfig/static/tw.css | 98 ++++++++++++++++++++++++
 tsunami/ui/table.go                      | 12 +--
 5 files changed, 149 insertions(+), 51 deletions(-)

diff --git a/tsunami/demo/tabletest/app.go b/tsunami/demo/tabletest/app.go
index 3e8c2a48f3..cb086f5709 100644
--- a/tsunami/demo/tabletest/app.go
+++ b/tsunami/demo/tabletest/app.go
@@ -19,8 +19,8 @@ type Person struct {
 // Create the table component for Person data
 var PersonTable = ui.MakeTableComponent[Person]("PersonTable")
 
-// Sample data
-var sampleData = []Person{
+// Sample data exposed as DataAtom for external system access
+var sampleData = app.DataAtom("sampleData", []Person{
 	{Name: "Alice Johnson", Age: 28, Email: "alice@example.com", City: "New York"},
 	{Name: "Bob Smith", Age: 34, Email: "bob@example.com", City: "Los Angeles"},
 	{Name: "Carol Davis", Age: 22, Email: "carol@example.com", City: "Chicago"},
@@ -31,7 +31,7 @@ var sampleData = []Person{
 	{Name: "Henry Taylor", Age: 33, Email: "henry@example.com", City: "San Diego"},
 	{Name: "Ivy Chen", Age: 26, Email: "ivy@example.com", City: "Dallas"},
 	{Name: "Jack Anderson", Age: 31, Email: "jack@example.com", City: "San Jose"},
-}
+})
 
 // The App component is the required entry point for every Tsunami application
 var App = app.DefineComponent("App", func(_ struct{}) any {
@@ -93,7 +93,7 @@ var App = app.DefineComponent("App", func(_ struct{}) any {
 			"className": "bg-gray-800 p-4 rounded-lg",
 		},
 			PersonTable(ui.TableProps[Person]{
-				Data:        sampleData,
+				Data:        sampleData.Get(),
 				Columns:     columns,
 				OnRowClick:  handleRowClick,
 				OnSort:      handleSort,
diff --git a/tsunami/demo/tabletest/static/tw.css b/tsunami/demo/tabletest/static/tw.css
index e4a6426655..37ff5e8bb1 100644
--- a/tsunami/demo/tabletest/static/tw.css
+++ b/tsunami/demo/tabletest/static/tw.css
@@ -10,6 +10,7 @@
     --color-blue-600: oklch(54.6% 0.245 262.881);
     --color-blue-700: oklch(48.8% 0.243 264.376);
     --color-blue-900: oklch(37.9% 0.146 265.522);
+    --color-gray-200: oklch(92.8% 0.006 264.531);
     --color-gray-300: oklch(87.2% 0.01 258.338);
     --color-gray-400: oklch(70.7% 0.022 261.325);
     --color-gray-500: oklch(55.1% 0.027 264.364);
@@ -404,9 +405,6 @@
   .transform {
     transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,);
   }
-  .cursor-not-allowed {
-    cursor: not-allowed;
-  }
   .cursor-pointer {
     cursor: pointer;
   }
@@ -735,6 +733,9 @@
   .text-blue-400 {
     color: var(--color-blue-400);
   }
+  .text-gray-200 {
+    color: var(--color-gray-200);
+  }
   .text-gray-300 {
     color: var(--color-gray-300);
   }
diff --git a/tsunami/demo/tsunamiconfig/app.go b/tsunami/demo/tsunamiconfig/app.go
index b345783057..87687af1ce 100644
--- a/tsunami/demo/tsunamiconfig/app.go
+++ b/tsunami/demo/tsunamiconfig/app.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -137,7 +136,7 @@ func postConfig(baseURL, jsonContent string) error {
 }
 
 var URLInput = app.DefineComponent("URLInput",
-	func(ctx context.Context, props URLInputProps) any {
+	func(props URLInputProps) any {
 		keyHandler := &vdom.VDomFunc{
 			Type: "func",
 			Fn: func(event vdom.VDomEvent) {
@@ -179,7 +178,7 @@ var URLInput = app.DefineComponent("URLInput",
 )
 
 var JSONEditor = app.DefineComponent("JSONEditor",
-	func(ctx context.Context, props JSONEditorProps) any {
+	func(props JSONEditorProps) any {
 		if props.Value == "" && props.Placeholder == "" {
 			return vdom.H("div", map[string]any{
 				"className": "text-slate-400 text-center py-8",
@@ -216,7 +215,7 @@ var JSONEditor = app.DefineComponent("JSONEditor",
 )
 
 var ErrorDisplay = app.DefineComponent("ErrorDisplay",
-	func(ctx context.Context, props ErrorDisplayProps) any {
+	func(props ErrorDisplayProps) any {
 		if props.Message == "" {
 			return nil
 		}
@@ -235,7 +234,7 @@ var ErrorDisplay = app.DefineComponent("ErrorDisplay",
 )
 
 var SuccessDisplay = app.DefineComponent("SuccessDisplay",
-	func(ctx context.Context, props SuccessDisplayProps) any {
+	func(props SuccessDisplayProps) any {
 		if props.Message == "" {
 			return nil
 		}
@@ -254,75 +253,75 @@ var SuccessDisplay = app.DefineComponent("SuccessDisplay",
 )
 
 var App = app.DefineComponent("App",
-	func(ctx context.Context, _ any) any {
+	func(_ struct{}) any {
 		app.UseSetAppTitle("Tsunami Config Manager")
 
 		// Get atom value once at the top
 		urlInput := serverURLAtom.Get()
-		jsonContent, setJSONContent, _ := app.UseState("")
-		errorMessage, setErrorMessage, _ := app.UseState("")
-		successMessage, setSuccessMessage, _ := app.UseState("")
-		isLoading, setIsLoading, _ := app.UseState(false)
-		lastFetch, setLastFetch, _ := app.UseState("")
-		currentBaseURL, setCurrentBaseURL, _ := app.UseState("")
+		jsonContent := app.UseLocal("")
+		errorMessage := app.UseLocal("")
+		successMessage := app.UseLocal("")
+		isLoading := app.UseLocal(false)
+		lastFetch := app.UseLocal("")
+		currentBaseURL := app.UseLocal("")
 
 		clearMessages := func() {
-			setErrorMessage("")
-			setSuccessMessage("")
+			errorMessage.Set("")
+			successMessage.Set("")
 		}
 
 		fetchConfigData := func() {
 			clearMessages()
 
-			baseURL, err := parseURL(urlInput)
+			baseURL, err := parseURL(serverURLAtom.Get())
 			if err != nil {
-				setErrorMessage(err.Error())
+				errorMessage.Set(err.Error())
 				return
 			}
 
-			setIsLoading(true)
-			setCurrentBaseURL(baseURL)
+			isLoading.Set(true)
+			currentBaseURL.Set(baseURL)
 
 			go func() {
 				defer func() {
-					setIsLoading(false)
+					isLoading.Set(false)
 					app.SendAsyncInitiation()
 				}()
 
 				content, err := fetchConfig(baseURL)
 				if err != nil {
-					setErrorMessage(err.Error())
+					errorMessage.Set(err.Error())
 					return
 				}
 
-				setJSONContent(content)
-				setLastFetch(time.Now().Format("2006-01-02 15:04:05"))
-				setSuccessMessage(fmt.Sprintf("Successfully fetched config from %s", baseURL))
+				jsonContent.Set(content)
+				lastFetch.Set(time.Now().Format("2006-01-02 15:04:05"))
+				successMessage.Set(fmt.Sprintf("Successfully fetched config from %s", baseURL))
 			}()
 		}
 
 		submitConfigData := func() {
-			if currentBaseURL == "" {
-				setErrorMessage("No base URL available. Please fetch config first.")
+			if currentBaseURL.Get() == "" {
+				errorMessage.Set("No base URL available. Please fetch config first.")
 				return
 			}
 
 			clearMessages()
-			setIsLoading(true)
+			isLoading.Set(true)
 
 			go func() {
 				defer func() {
-					setIsLoading(false)
+					isLoading.Set(false)
 					app.SendAsyncInitiation()
 				}()
 
-				err := postConfig(currentBaseURL, jsonContent)
+				err := postConfig(currentBaseURL.Get(), jsonContent.Get())
 				if err != nil {
-					setErrorMessage(fmt.Sprintf("Failed to submit config: %v", err))
+					errorMessage.Set(fmt.Sprintf("Failed to submit config: %v", err))
 					return
 				}
 
-				setSuccessMessage(fmt.Sprintf("Successfully submitted config to %s", currentBaseURL))
+				successMessage.Set(fmt.Sprintf("Successfully submitted config to %s", currentBaseURL.Get()))
 			}()
 		}
 
@@ -344,28 +343,28 @@ var App = app.DefineComponent("App",
 				Value:     urlInput,
 				OnChange:  serverURLAtom.Set,
 				OnSubmit:  fetchConfigData,
-				IsLoading: isLoading,
+				IsLoading: isLoading.Get(),
 			}),
 
 			ErrorDisplay(ErrorDisplayProps{
-				Message: errorMessage,
+				Message: errorMessage.Get(),
 			}),
 
 			SuccessDisplay(SuccessDisplayProps{
-				Message: successMessage,
+				Message: successMessage.Get(),
 			}),
 
-			vdom.If(lastFetch != "",
+			vdom.If(lastFetch.Get() != "",
 				vdom.H("div", map[string]any{
 					"className": "text-sm text-slate-400 mb-4",
-				}, fmt.Sprintf("Last fetched: %s from %s", lastFetch, currentBaseURL)),
+				}, fmt.Sprintf("Last fetched: %s from %s", lastFetch.Get(), currentBaseURL.Get())),
 			),
 
 			JSONEditor(JSONEditorProps{
-				Value:       jsonContent,
-				OnChange:    setJSONContent,
+				Value:       jsonContent.Get(),
+				OnChange:    jsonContent.Set,
 				OnSubmit:    submitConfigData,
-				IsLoading:   isLoading,
+				IsLoading:   isLoading.Get(),
 				Placeholder: "JSON configuration will appear here after fetching...",
 			}),
 		)
diff --git a/tsunami/demo/tsunamiconfig/static/tw.css b/tsunami/demo/tsunamiconfig/static/tw.css
index bb214da782..72e621c014 100644
--- a/tsunami/demo/tsunamiconfig/static/tw.css
+++ b/tsunami/demo/tsunamiconfig/static/tw.css
@@ -12,14 +12,23 @@
     --color-green-600: oklch(62.7% 0.194 149.214);
     --color-green-700: oklch(52.7% 0.154 150.069);
     --color-green-900: oklch(39.3% 0.095 152.535);
+    --color-blue-400: oklch(70.7% 0.165 254.624);
     --color-blue-500: oklch(62.3% 0.214 259.815);
     --color-blue-600: oklch(54.6% 0.245 262.881);
     --color-blue-700: oklch(48.8% 0.243 264.376);
+    --color-blue-900: oklch(37.9% 0.146 265.522);
     --color-slate-100: oklch(96.8% 0.007 247.896);
     --color-slate-400: oklch(70.4% 0.04 256.788);
     --color-slate-600: oklch(44.6% 0.043 257.281);
     --color-slate-700: oklch(37.2% 0.044 257.287);
     --color-slate-800: oklch(27.9% 0.041 260.031);
+    --color-gray-200: oklch(92.8% 0.006 264.531);
+    --color-gray-400: oklch(70.7% 0.022 261.325);
+    --color-gray-500: oklch(55.1% 0.027 264.364);
+    --color-gray-600: oklch(44.6% 0.03 256.802);
+    --color-gray-700: oklch(37.3% 0.034 259.733);
+    --color-gray-800: oklch(27.8% 0.033 256.848);
+    --color-gray-900: oklch(21% 0.034 264.665);
     --color-white: #fff;
     --spacing: 0.25rem;
     --container-4xl: 56rem;
@@ -36,6 +45,7 @@
     --text-3xl: 1.875rem;
     --text-3xl--line-height: calc(2.25 / 1.875);
     --font-weight-medium: 500;
+    --font-weight-semibold: 600;
     --font-weight-bold: 700;
     --leading-relaxed: 1.625;
     --radius-lg: 0.5rem;
@@ -275,6 +285,9 @@
       max-width: 96rem;
     }
   }
+  .mx-1 {
+    margin-inline: calc(var(--spacing) * 1);
+  }
   .mx-auto {
     margin-inline: auto;
   }
@@ -450,9 +463,18 @@
   .flex-wrap {
     flex-wrap: wrap;
   }
+  .items-center {
+    align-items: center;
+  }
+  .justify-between {
+    justify-content: space-between;
+  }
   .gap-2 {
     gap: calc(var(--spacing) * 2);
   }
+  .gap-3 {
+    gap: calc(var(--spacing) * 3);
+  }
   .space-y-1 {
     :where(& > :not(:last-child)) {
       --tw-space-y-reverse: 0;
@@ -492,6 +514,11 @@
       --tw-divide-y-reverse: 1;
     }
   }
+  .divide-gray-700 {
+    :where(& > :not(:last-child)) {
+      border-color: var(--color-gray-700);
+    }
+  }
   .truncate {
     overflow: hidden;
     text-overflow: ellipsis;
@@ -600,6 +627,9 @@
   .border-border {
     border-color: var(--color-border);
   }
+  .border-gray-600 {
+    border-color: var(--color-gray-600);
+  }
   .border-green-700 {
     border-color: var(--color-green-700);
   }
@@ -615,6 +645,21 @@
   .bg-blue-600 {
     background-color: var(--color-blue-600);
   }
+  .bg-blue-900 {
+    background-color: var(--color-blue-900);
+  }
+  .bg-gray-600 {
+    background-color: var(--color-gray-600);
+  }
+  .bg-gray-700 {
+    background-color: var(--color-gray-700);
+  }
+  .bg-gray-800 {
+    background-color: var(--color-gray-800);
+  }
+  .bg-gray-900 {
+    background-color: var(--color-gray-900);
+  }
   .bg-green-600 {
     background-color: var(--color-green-600);
   }
@@ -645,6 +690,9 @@
   .mask-repeat {
     mask-repeat: repeat;
   }
+  .p-3 {
+    padding: calc(var(--spacing) * 3);
+  }
   .p-4 {
     padding: calc(var(--spacing) * 4);
   }
@@ -654,6 +702,9 @@
   .px-1 {
     padding-inline: calc(var(--spacing) * 1);
   }
+  .px-2 {
+    padding-inline: calc(var(--spacing) * 2);
+  }
   .px-3 {
     padding-inline: calc(var(--spacing) * 3);
   }
@@ -663,6 +714,12 @@
   .py-0\.5 {
     padding-block: calc(var(--spacing) * 0.5);
   }
+  .py-1 {
+    padding-block: calc(var(--spacing) * 1);
+  }
+  .py-1\.5 {
+    padding-block: calc(var(--spacing) * 1.5);
+  }
   .py-2 {
     padding-block: calc(var(--spacing) * 2);
   }
@@ -720,6 +777,10 @@
     --tw-font-weight: var(--font-weight-medium);
     font-weight: var(--font-weight-medium);
   }
+  .font-semibold {
+    --tw-font-weight: var(--font-weight-semibold);
+    font-weight: var(--font-weight-semibold);
+  }
   .text-wrap {
     text-wrap: wrap;
   }
@@ -732,6 +793,18 @@
   .text-accent {
     color: var(--color-accent);
   }
+  .text-blue-400 {
+    color: var(--color-blue-400);
+  }
+  .text-gray-200 {
+    color: var(--color-gray-200);
+  }
+  .text-gray-400 {
+    color: var(--color-gray-400);
+  }
+  .text-gray-500 {
+    color: var(--color-gray-500);
+  }
   .text-green-100 {
     color: var(--color-green-100);
   }
@@ -914,6 +987,20 @@
       }
     }
   }
+  .hover\:bg-gray-700 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-gray-700);
+      }
+    }
+  }
+  .hover\:bg-gray-800 {
+    &:hover {
+      @media (hover: hover) {
+        background-color: var(--color-gray-800);
+      }
+    }
+  }
   .hover\:bg-green-700 {
     &:hover {
       @media (hover: hover) {
@@ -928,6 +1015,17 @@
       }
     }
   }
+  .focus\:bg-gray-600 {
+    &:focus {
+      background-color: var(--color-gray-600);
+    }
+  }
+  .focus\:ring-1 {
+    &:focus {
+      --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
+      box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+    }
+  }
   .focus\:ring-2 {
     &:focus {
       --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
diff --git a/tsunami/ui/table.go b/tsunami/ui/table.go
index 827163147b..d040f994e4 100644
--- a/tsunami/ui/table.go
+++ b/tsunami/ui/table.go
@@ -314,11 +314,11 @@ func genTableRenderFunc[T any](props TableProps[T]) any {
 			"className": "overflow-auto border border-gray-600 rounded-lg",
 		},
 			vdom.H("table", map[string]any{
-				"className": "w-full bg-gray-900 text-white",
+				"className": "w-full bg-gray-900 text-gray-200",
 			},
 				// Header
 				vdom.H("thead", map[string]any{
-					"className": "bg-gray-800 border-b border-gray-600",
+					"className": "bg-gray-800 border-b border-gray-600 text-white",
 				},
 					vdom.H("tr", nil,
 						vdom.If(props.Selectable,
@@ -512,7 +512,7 @@ func renderPagination(totalRows int, config *PaginationConfig, onPageChange func
 					"px-3 py-1.5 rounded text-sm transition-colors",
 					vdom.IfElse(currentPage > 0,
 						"bg-blue-600 hover:bg-blue-700 text-white cursor-pointer",
-						"bg-gray-600 text-gray-500 cursor-not-allowed"),
+						"bg-gray-600 text-gray-500"),
 				),
 				"disabled": currentPage <= 0,
 				"onClick": func() {
@@ -521,17 +521,17 @@ func renderPagination(totalRows int, config *PaginationConfig, onPageChange func
 					}
 				},
 			}, "Previous"),
-
+	
 			vdom.H("span", map[string]any{
 				"className": "text-sm text-gray-400 px-2",
 			}, fmt.Sprintf("Page %d of %d", currentPage+1, totalPages)),
-
+	
 			vdom.H("button", map[string]any{
 				"className": vdom.Classes(
 					"px-3 py-1.5 rounded text-sm transition-colors",
 					vdom.IfElse(currentPage < totalPages-1,
 						"bg-blue-600 hover:bg-blue-700 text-white cursor-pointer",
-						"bg-gray-600 text-gray-500 cursor-not-allowed"),
+						"bg-gray-600 text-gray-500"),
 				),
 				"disabled": currentPage >= totalPages-1,
 				"onClick": func() {

From ee131149280ab3d459d54e786b8a275b4f6e0dd8 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 11:55:17 -0700
Subject: [PATCH 112/134] conditionally symlink "ui" pkg

---
 tsunami/build/build.go                   | 56 ++++++++++++---
 tsunami/cmd/main-tsunami.go              | 13 ++--
 tsunami/demo/tsunamiconfig/static/tw.css | 88 ------------------------
 3 files changed, 56 insertions(+), 101 deletions(-)

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 8ac4ce260f..79dae82201 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -3,6 +3,8 @@ package build
 import (
 	"bufio"
 	"fmt"
+	"go/parser"
+	"go/token"
 	"io"
 	"log"
 	"os"
@@ -21,6 +23,7 @@ import (
 )
 
 const MinSupportedGoMinorVersion = 22
+const TsunamiUIImportPath = "github.com/wavetermdev/waveterm/tsunami/ui"
 
 type BuildOpts struct {
 	Dir            string
@@ -138,7 +141,7 @@ func createGoMod(tempDir, appDirName, goVersion string, opts BuildOpts, verbose
 		if verbose {
 			log.Printf("Found existing go.mod, copying from %s", originalGoModPath)
 		}
-		
+
 		// Copy existing go.mod to temp directory
 		tempGoModPath := filepath.Join(tempDir, "go.mod")
 		if err := copyFile(originalGoModPath, tempGoModPath); err != nil {
@@ -160,7 +163,7 @@ func createGoMod(tempDir, appDirName, goVersion string, opts BuildOpts, verbose
 		if verbose {
 			log.Printf("No existing go.mod found, creating new one")
 		}
-		
+
 		modFile = &modfile.File{}
 		if err := modFile.AddModuleStmt(modulePath); err != nil {
 			return fmt.Errorf("failed to add module statement: %w", err)
@@ -320,6 +323,31 @@ func verifyScaffoldPath(scaffoldPath string) error {
 	return nil
 }
 
+func buildImportsMap(dir string) (map[string]bool, error) {
+	imports := make(map[string]bool)
+
+	files, err := filepath.Glob(filepath.Join(dir, "*.go"))
+	if err != nil {
+		return nil, fmt.Errorf("failed to list go files: %w", err)
+	}
+
+	fset := token.NewFileSet()
+	for _, file := range files {
+		node, err := parser.ParseFile(fset, file, nil, parser.ImportsOnly)
+		if err != nil {
+			continue // Skip files that can't be parsed
+		}
+
+		for _, imp := range node.Imports {
+			// Remove quotes from import path
+			importPath := strings.Trim(imp.Path.Value, `"`)
+			imports[importPath] = true
+		}
+	}
+
+	return imports, nil
+}
+
 func (be *BuildEnv) cleanupTempDir(keepTemp bool, verbose bool) {
 	if be == nil || be.cleanupOnce == nil {
 		return
@@ -430,14 +458,24 @@ func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 		return buildEnv, fmt.Errorf("failed to create go.mod: %w", err)
 	}
 
-	// Create symlink to SDK ui directory so Tailwind can see those classes
-	uiLinkPath := filepath.Join(tempDir, "ui")
-	uiTargetPath := filepath.Join(opts.SdkReplacePath, "ui")
-	if err := os.Symlink(uiTargetPath, uiLinkPath); err != nil {
-		return buildEnv, fmt.Errorf("failed to create ui symlink: %w", err)
+	// Build imports map from Go files
+	imports, err := buildImportsMap(tempDir)
+	if err != nil {
+		return buildEnv, fmt.Errorf("failed to build imports map: %w", err)
 	}
-	if opts.Verbose {
-		log.Printf("Created symlink: %s -> %s", uiLinkPath, uiTargetPath)
+
+	// Create symlink to SDK ui directory only if UI package is imported
+	if imports[TsunamiUIImportPath] {
+		uiLinkPath := filepath.Join(tempDir, "ui")
+		uiTargetPath := filepath.Join(opts.SdkReplacePath, "ui")
+		if err := os.Symlink(uiTargetPath, uiLinkPath); err != nil {
+			return buildEnv, fmt.Errorf("failed to create ui symlink: %w", err)
+		}
+		if opts.Verbose {
+			log.Printf("Created UI symlink: %s -> %s", uiLinkPath, uiTargetPath)
+		}
+	} else if opts.Verbose {
+		log.Printf("Skipping UI symlink creation - no UI package imports found")
 	}
 
 	// Generate Tailwind CSS
diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
index 6eae0f1951..1ca4ffefd8 100644
--- a/tsunami/cmd/main-tsunami.go
+++ b/tsunami/cmd/main-tsunami.go
@@ -9,6 +9,11 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/tsunamibase"
 )
 
+const (
+	EnvTsunamiScaffoldPath   = "TSUNAMI_SCAFFOLDPATH"
+	EnvTsunamiSdkReplacePath = "TSUNAMI_SDKREPLACEPATH"
+)
+
 // these are set at build time
 var TsunamiVersion = "0.0.0"
 var BuildTime = "0"
@@ -29,14 +34,14 @@ var versionCmd = &cobra.Command{
 }
 
 func validateEnvironmentVars(opts *build.BuildOpts) error {
-	scaffoldPath := os.Getenv("TSUNAMI_SCAFFOLDPATH")
+	scaffoldPath := os.Getenv(EnvTsunamiScaffoldPath)
 	if scaffoldPath == "" {
-		return fmt.Errorf("TSUNAMI_SCAFFOLDPATH environment variable must be set")
+		return fmt.Errorf("%s environment variable must be set", EnvTsunamiScaffoldPath)
 	}
 
-	sdkReplacePath := os.Getenv("TSUNAMI_SDKREPLACEPATH")
+	sdkReplacePath := os.Getenv(EnvTsunamiSdkReplacePath)
 	if sdkReplacePath == "" {
-		return fmt.Errorf("TSUNAMI_SDKREPLACEPATH environment variable must be set")
+		return fmt.Errorf("%s environment variable must be set", EnvTsunamiSdkReplacePath)
 	}
 
 	opts.ScaffoldPath = scaffoldPath
diff --git a/tsunami/demo/tsunamiconfig/static/tw.css b/tsunami/demo/tsunamiconfig/static/tw.css
index 72e621c014..bb9786b7b5 100644
--- a/tsunami/demo/tsunamiconfig/static/tw.css
+++ b/tsunami/demo/tsunamiconfig/static/tw.css
@@ -285,9 +285,6 @@
       max-width: 96rem;
     }
   }
-  .mx-1 {
-    margin-inline: calc(var(--spacing) * 1);
-  }
   .mx-auto {
     margin-inline: auto;
   }
@@ -463,18 +460,9 @@
   .flex-wrap {
     flex-wrap: wrap;
   }
-  .items-center {
-    align-items: center;
-  }
-  .justify-between {
-    justify-content: space-between;
-  }
   .gap-2 {
     gap: calc(var(--spacing) * 2);
   }
-  .gap-3 {
-    gap: calc(var(--spacing) * 3);
-  }
   .space-y-1 {
     :where(& > :not(:last-child)) {
       --tw-space-y-reverse: 0;
@@ -514,11 +502,6 @@
       --tw-divide-y-reverse: 1;
     }
   }
-  .divide-gray-700 {
-    :where(& > :not(:last-child)) {
-      border-color: var(--color-gray-700);
-    }
-  }
   .truncate {
     overflow: hidden;
     text-overflow: ellipsis;
@@ -627,9 +610,6 @@
   .border-border {
     border-color: var(--color-border);
   }
-  .border-gray-600 {
-    border-color: var(--color-gray-600);
-  }
   .border-green-700 {
     border-color: var(--color-green-700);
   }
@@ -645,21 +625,6 @@
   .bg-blue-600 {
     background-color: var(--color-blue-600);
   }
-  .bg-blue-900 {
-    background-color: var(--color-blue-900);
-  }
-  .bg-gray-600 {
-    background-color: var(--color-gray-600);
-  }
-  .bg-gray-700 {
-    background-color: var(--color-gray-700);
-  }
-  .bg-gray-800 {
-    background-color: var(--color-gray-800);
-  }
-  .bg-gray-900 {
-    background-color: var(--color-gray-900);
-  }
   .bg-green-600 {
     background-color: var(--color-green-600);
   }
@@ -690,9 +655,6 @@
   .mask-repeat {
     mask-repeat: repeat;
   }
-  .p-3 {
-    padding: calc(var(--spacing) * 3);
-  }
   .p-4 {
     padding: calc(var(--spacing) * 4);
   }
@@ -702,9 +664,6 @@
   .px-1 {
     padding-inline: calc(var(--spacing) * 1);
   }
-  .px-2 {
-    padding-inline: calc(var(--spacing) * 2);
-  }
   .px-3 {
     padding-inline: calc(var(--spacing) * 3);
   }
@@ -714,12 +673,6 @@
   .py-0\.5 {
     padding-block: calc(var(--spacing) * 0.5);
   }
-  .py-1 {
-    padding-block: calc(var(--spacing) * 1);
-  }
-  .py-1\.5 {
-    padding-block: calc(var(--spacing) * 1.5);
-  }
   .py-2 {
     padding-block: calc(var(--spacing) * 2);
   }
@@ -777,10 +730,6 @@
     --tw-font-weight: var(--font-weight-medium);
     font-weight: var(--font-weight-medium);
   }
-  .font-semibold {
-    --tw-font-weight: var(--font-weight-semibold);
-    font-weight: var(--font-weight-semibold);
-  }
   .text-wrap {
     text-wrap: wrap;
   }
@@ -793,18 +742,6 @@
   .text-accent {
     color: var(--color-accent);
   }
-  .text-blue-400 {
-    color: var(--color-blue-400);
-  }
-  .text-gray-200 {
-    color: var(--color-gray-200);
-  }
-  .text-gray-400 {
-    color: var(--color-gray-400);
-  }
-  .text-gray-500 {
-    color: var(--color-gray-500);
-  }
   .text-green-100 {
     color: var(--color-green-100);
   }
@@ -987,20 +924,6 @@
       }
     }
   }
-  .hover\:bg-gray-700 {
-    &:hover {
-      @media (hover: hover) {
-        background-color: var(--color-gray-700);
-      }
-    }
-  }
-  .hover\:bg-gray-800 {
-    &:hover {
-      @media (hover: hover) {
-        background-color: var(--color-gray-800);
-      }
-    }
-  }
   .hover\:bg-green-700 {
     &:hover {
       @media (hover: hover) {
@@ -1015,17 +938,6 @@
       }
     }
   }
-  .focus\:bg-gray-600 {
-    &:focus {
-      background-color: var(--color-gray-600);
-    }
-  }
-  .focus\:ring-1 {
-    &:focus {
-      --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
-      box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
-    }
-  }
   .focus\:ring-2 {
     &:focus {
       --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);

From a7bab9894912843cba5cc86560b4f22067167653 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 12:46:11 -0700
Subject: [PATCH 113/134] add a fe-update reason

---
 tsunami/frontend/src/model/tsunami-model.tsx | 75 ++++++++++++++------
 tsunami/frontend/src/types/vdom.d.ts         |  1 +
 tsunami/rpctypes/protocoltypes.go            |  1 +
 3 files changed, 54 insertions(+), 23 deletions(-)

diff --git a/tsunami/frontend/src/model/tsunami-model.tsx b/tsunami/frontend/src/model/tsunami-model.tsx
index 17d0bcdbee..737ce6c6da 100644
--- a/tsunami/frontend/src/model/tsunami-model.tsx
+++ b/tsunami/frontend/src/model/tsunami-model.tsx
@@ -102,6 +102,7 @@ export class TsunamiModel {
     hasBackendWork: boolean = false;
     noPadding: jotai.PrimitiveAtom<boolean>;
     cachedFaviconPath: string | null = null;
+    reason: string | null = null;
 
     constructor() {
         this.clientId = getOrCreateClientId();
@@ -109,7 +110,7 @@ export class TsunamiModel {
         this.reset();
         this.noPadding = jotai.atom(true);
         this.setupServerEventSource();
-        this.queueUpdate(true);
+        this.queueUpdate(true, "initial");
     }
 
     dispose() {
@@ -129,7 +130,7 @@ export class TsunamiModel {
 
         this.serverEventSource.addEventListener("asyncinitiation", (event) => {
             dlog("async-initiation SSE event received", event);
-            this.queueUpdate(true);
+            this.queueUpdate(true, "asyncinitiation");
         });
 
         this.serverEventSource.addEventListener("error", (event) => {
@@ -165,24 +166,25 @@ export class TsunamiModel {
         this.refOutputStore.clear();
         this.globalVersion = jotai.atom(0);
         this.hasBackendWork = false;
+        this.reason = null;
         getDefaultStore().set(this.contextActive, false);
     }
 
     keyDownHandler(e: VDomKeyboardEvent): boolean {
-        if (this.backendOpts?.globalkeyboardevents) {
-            if (e.cmd || e.meta) {
-                return false;
-            }
-            this.batchedEvents.push({
-                globaleventtype: "onKeyDown",
-                waveid: null,
-                eventtype: "onKeyDown",
-                keydata: e,
-            });
-            this.queueUpdate();
-            return true;
+        if (!this.backendOpts?.globalkeyboardevents) {
+            return false;
         }
-        return false;
+        if (e.cmd || e.meta) {
+            return false;
+        }
+        this.batchedEvents.push({
+            globaleventtype: "onKeyDown",
+            waveid: null,
+            eventtype: "onKeyDown",
+            keydata: e,
+        });
+        this.queueUpdate(false, "globalkeyboard");
+        return true;
     }
 
     hasRefUpdates() {
@@ -219,11 +221,29 @@ export class TsunamiModel {
         return updates;
     }
 
-    queueUpdate(quick: boolean = false, delay: number = 10) {
+    mergeReasons(newReason: string): string {
+        if (!this.reason) {
+            return newReason;
+        }
+        const existingReasons = this.reason.split(",");
+        const newReasons = newReason.split(",");
+        for (const reason of newReasons) {
+            if (!existingReasons.includes(reason)) {
+                existingReasons.push(reason);
+            }
+        }
+        return existingReasons.join(",");
+    }
+
+    queueUpdate(quick: boolean = false, reason: string | null) {
         if (this.disposed) {
             return;
         }
+        if (reason) {
+            this.reason = this.mergeReasons(reason);
+        }
         this.needsUpdate = true;
+        let delay = 10;
         let nowTs = Date.now();
         if (delay > this.maxNormalUpdateIntervalMs) {
             delay = this.maxNormalUpdateIntervalMs;
@@ -312,11 +332,10 @@ export class TsunamiModel {
             this.hasPendingRequest = false;
         }
         if (this.needsImmediateUpdate) {
-            this.queueUpdate(true);
+            this.queueUpdate(true, null); // reason should already be set, dont try to add a new one
         }
     }
 
-
     getOrCreateRefContainer(vdomRef: VDomRef): RefContainer {
         let container = this.refs.get(vdomRef.refid);
         if (container == null) {
@@ -338,7 +357,6 @@ export class TsunamiModel {
         return container;
     }
 
-
     getVDomNodeVersionAtom(vdom: VDomElem) {
         let atom = this.vdomNodeVersion.get(vdom);
         if (atom == null) {
@@ -434,7 +452,6 @@ export class TsunamiModel {
         }
     }
 
-
     getRefElem(refId: string): HTMLElement {
         if (refId == this.rootRefId) {
             return this.viewRef.current;
@@ -543,9 +560,19 @@ export class TsunamiModel {
     renderDone(version: number) {
         // called when the render is done
         dlog("renderDone", version);
-        if (this.hasRefUpdates() || this.hasBackendWork) {
+        let reasons: string[] = [];
+        let needsQueue = false;
+        if (this.hasRefUpdates()) {
+            reasons.push("refupdates");
+            needsQueue = true;
+        }
+        if (this.hasBackendWork) {
+            reasons.push("backendwork");
+            needsQueue = true;
             this.hasBackendWork = false;
-            this.queueUpdate(true);
+        }
+        if (needsQueue) {
+            this.queueUpdate(true, reasons.join(","));
         }
     }
 
@@ -559,7 +586,7 @@ export class TsunamiModel {
         }
         annotateEvent(vdomEvent, propName, e);
         this.batchedEvents.push(vdomEvent);
-        this.queueUpdate(true);
+        this.queueUpdate(true, "event");
     }
 
     createFeUpdate(): VDomFrontendUpdate {
@@ -580,9 +607,11 @@ export class TsunamiModel {
             resync: this.needsResync,
             events: this.batchedEvents,
             refupdates: this.getRefUpdates(),
+            reason: this.reason,
         };
         this.needsResync = false;
         this.batchedEvents = [];
+        this.reason = null;
         if (this.shouldDispose) {
             this.disposed = true;
         }
diff --git a/tsunami/frontend/src/types/vdom.d.ts b/tsunami/frontend/src/types/vdom.d.ts
index 9b15b1c6e9..ed94ae9d72 100644
--- a/tsunami/frontend/src/types/vdom.d.ts
+++ b/tsunami/frontend/src/types/vdom.d.ts
@@ -52,6 +52,7 @@ type VDomFrontendUpdate = {
     clientid: string;
     forcetakeover?: boolean;
     correlationid?: string;
+    reason?: string;
     dispose?: boolean;
     resync?: boolean;
     rendercontext: VDomRenderContext;
diff --git a/tsunami/rpctypes/protocoltypes.go b/tsunami/rpctypes/protocoltypes.go
index bec19c7122..24136a6039 100644
--- a/tsunami/rpctypes/protocoltypes.go
+++ b/tsunami/rpctypes/protocoltypes.go
@@ -30,6 +30,7 @@ type VDomFrontendUpdate struct {
 	ClientId      string            `json:"clientid"`
 	ForceTakeover bool              `json:"forcetakeover,omitempty"`
 	CorrelationId string            `json:"correlationid,omitempty"`
+	Reason        string            `json:"reason,omitempty"`
 	Dispose       bool              `json:"dispose,omitempty"` // the vdom context was closed
 	Resync        bool              `json:"resync,omitempty"`  // resync (send all backend data).  useful when the FE reloads
 	RenderContext VDomRenderContext `json:"rendercontext,omitempty"`

From 40b4ae498a8c87a80927724114768f1544cff284 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 13:42:18 -0700
Subject: [PATCH 114/134] write a log line on render

---
 tsunami/demo/tsunamiconfig/static/tw.css | 10 ----------
 tsunami/engine/serverhandlers.go         | 18 +++++++++++++++++-
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/tsunami/demo/tsunamiconfig/static/tw.css b/tsunami/demo/tsunamiconfig/static/tw.css
index bb9786b7b5..bb214da782 100644
--- a/tsunami/demo/tsunamiconfig/static/tw.css
+++ b/tsunami/demo/tsunamiconfig/static/tw.css
@@ -12,23 +12,14 @@
     --color-green-600: oklch(62.7% 0.194 149.214);
     --color-green-700: oklch(52.7% 0.154 150.069);
     --color-green-900: oklch(39.3% 0.095 152.535);
-    --color-blue-400: oklch(70.7% 0.165 254.624);
     --color-blue-500: oklch(62.3% 0.214 259.815);
     --color-blue-600: oklch(54.6% 0.245 262.881);
     --color-blue-700: oklch(48.8% 0.243 264.376);
-    --color-blue-900: oklch(37.9% 0.146 265.522);
     --color-slate-100: oklch(96.8% 0.007 247.896);
     --color-slate-400: oklch(70.4% 0.04 256.788);
     --color-slate-600: oklch(44.6% 0.043 257.281);
     --color-slate-700: oklch(37.2% 0.044 257.287);
     --color-slate-800: oklch(27.9% 0.041 260.031);
-    --color-gray-200: oklch(92.8% 0.006 264.531);
-    --color-gray-400: oklch(70.7% 0.022 261.325);
-    --color-gray-500: oklch(55.1% 0.027 264.364);
-    --color-gray-600: oklch(44.6% 0.03 256.802);
-    --color-gray-700: oklch(37.3% 0.034 259.733);
-    --color-gray-800: oklch(27.8% 0.033 256.848);
-    --color-gray-900: oklch(21% 0.034 264.665);
     --color-white: #fff;
     --spacing: 0.25rem;
     --container-4xl: 56rem;
@@ -45,7 +36,6 @@
     --text-3xl: 1.875rem;
     --text-3xl--line-height: calc(2.25 / 1.875);
     --font-weight-medium: 500;
-    --font-weight-semibold: 600;
     --font-weight-bold: 700;
     --leading-relaxed: 1.625;
     --radius-lg: 0.5rem;
diff --git a/tsunami/engine/serverhandlers.go b/tsunami/engine/serverhandlers.go
index 58ea95f9be..3d74ef0461 100644
--- a/tsunami/engine/serverhandlers.go
+++ b/tsunami/engine/serverhandlers.go
@@ -96,19 +96,35 @@ func (h *httpHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	startTime := time.Now()
 	update, err := h.processFrontendUpdate(&feUpdate)
+	duration := time.Since(startTime)
+	
 	if err != nil {
 		http.Error(w, fmt.Sprintf("render error: %v", err), http.StatusInternalServerError)
 		return
 	}
 	if update == nil {
 		w.WriteHeader(http.StatusOK)
+		log.Printf("render %4dms %4dk %s", duration.Milliseconds(), 0, feUpdate.Reason)
 		return
 	}
 
 	w.Header().Set("Content-Type", "application/json")
-	if err := json.NewEncoder(w).Encode(update); err != nil {
+	
+	// Encode to bytes first to calculate size
+	responseBytes, err := json.Marshal(update)
+	if err != nil {
 		log.Printf("failed to encode response: %v", err)
+		http.Error(w, "failed to encode response", http.StatusInternalServerError)
+		return
+	}
+	
+	updateSizeKB := len(responseBytes) / 1024
+	log.Printf("render %4dms %4dk %s", duration.Milliseconds(), updateSizeKB, feUpdate.Reason)
+	
+	if _, err := w.Write(responseBytes); err != nil {
+		log.Printf("failed to write response: %v", err)
 	}
 }
 

From 5d3d6c6689c9a7169d3733e69fe6f624e516b3e8 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 13:50:44 -0700
Subject: [PATCH 115/134] add rendertype

---
 tsunami/engine/serverhandlers.go | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/tsunami/engine/serverhandlers.go b/tsunami/engine/serverhandlers.go
index 3d74ef0461..0fd1afc43a 100644
--- a/tsunami/engine/serverhandlers.go
+++ b/tsunami/engine/serverhandlers.go
@@ -99,19 +99,19 @@ func (h *httpHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
 	startTime := time.Now()
 	update, err := h.processFrontendUpdate(&feUpdate)
 	duration := time.Since(startTime)
-	
+
 	if err != nil {
 		http.Error(w, fmt.Sprintf("render error: %v", err), http.StatusInternalServerError)
 		return
 	}
 	if update == nil {
 		w.WriteHeader(http.StatusOK)
-		log.Printf("render %4dms %4dk %s", duration.Milliseconds(), 0, feUpdate.Reason)
+		log.Printf("render %4s %4dms %4dk %s", "none", duration.Milliseconds(), 0, feUpdate.Reason)
 		return
 	}
 
 	w.Header().Set("Content-Type", "application/json")
-	
+
 	// Encode to bytes first to calculate size
 	responseBytes, err := json.Marshal(update)
 	if err != nil {
@@ -119,10 +119,14 @@ func (h *httpHandlers) handleRender(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "failed to encode response", http.StatusInternalServerError)
 		return
 	}
-	
+
 	updateSizeKB := len(responseBytes) / 1024
-	log.Printf("render %4dms %4dk %s", duration.Milliseconds(), updateSizeKB, feUpdate.Reason)
-	
+	renderType := "inc"
+	if update.FullUpdate {
+		renderType = "full"
+	}
+	log.Printf("render %4s %4dms %4dk %s", renderType, duration.Milliseconds(), updateSizeKB, feUpdate.Reason)
+
 	if _, err := w.Write(responseBytes); err != nil {
 		log.Printf("failed to write response: %v", err)
 	}
@@ -248,7 +252,7 @@ func (h *httpHandlers) handleConfigPost(w http.ResponseWriter, r *http.Request)
 	}
 
 	w.Header().Set("Content-Type", "application/json")
-	
+
 	var response map[string]any
 	if len(failedKeys) > 0 {
 		response = map[string]any{
@@ -259,9 +263,9 @@ func (h *httpHandlers) handleConfigPost(w http.ResponseWriter, r *http.Request)
 			"success": true,
 		}
 	}
-	
+
 	w.WriteHeader(http.StatusOK)
-	
+
 	json.NewEncoder(w).Encode(response)
 }
 

From beda3c4817bcc94ef849130bf2644d238ff4ae0d Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 14:32:38 -0700
Subject: [PATCH 116/134] track containing component in componentimpl, error
 messages for vdom events

---
 tsunami/engine/comp.go         | 11 +++----
 tsunami/engine/render.go       | 52 ++++++++++++++++++++++++++--------
 tsunami/engine/rootelem.go     | 15 +++++++++-
 tsunami/templates/tailwind.css |  3 +-
 4 files changed, 62 insertions(+), 19 deletions(-)

diff --git a/tsunami/engine/comp.go b/tsunami/engine/comp.go
index c712359416..c16135ff7d 100644
--- a/tsunami/engine/comp.go
+++ b/tsunami/engine/comp.go
@@ -19,11 +19,12 @@ type ChildKey struct {
 // identity, state, and lifecycle across renders while the VDomElem input/output
 // structures are ephemeral.
 type ComponentImpl struct {
-	WaveId  string         // Unique identifier for this component instance
-	Tag     string         // Component type (HTML tag, custom component name, "#text", etc.)
-	Key     string         // User-provided key for reconciliation (like React keys)
-	Elem    *vdom.VDomElem // Reference to the current input VDomElem being rendered
-	Mounted bool           // Whether this component is currently mounted
+	WaveId         string         // Unique identifier for this component instance
+	Tag            string         // Component type (HTML tag, custom component name, "#text", etc.)
+	Key            string         // User-provided key for reconciliation (like React keys)
+	ContainingComp string         // Which vdom component's render function created this ComponentImpl
+	Elem           *vdom.VDomElem // Reference to the current input VDomElem being rendered
+	Mounted        bool           // Whether this component is currently mounted
 
 	// Hooks system (React-like)
 	Hooks []*Hook // Array of hooks (state, effects, etc.) attached to this component
diff --git a/tsunami/engine/render.go b/tsunami/engine/render.go
index 50d558a258..f345461d53 100644
--- a/tsunami/engine/render.go
+++ b/tsunami/engine/render.go
@@ -6,6 +6,7 @@ package engine
 import (
 	"fmt"
 	"reflect"
+	"runtime/debug"
 	"unicode"
 
 	"github.com/google/uuid"
@@ -21,7 +22,7 @@ type RenderOpts struct {
 }
 
 func (r *RootElem) Render(elem *vdom.VDomElem, opts *RenderOpts) {
-	r.render(elem, &r.Root, opts)
+	r.render(elem, &r.Root, "root", opts)
 }
 
 func getElemKey(elem *vdom.VDomElem) string {
@@ -35,7 +36,7 @@ func getElemKey(elem *vdom.VDomElem) string {
 	return fmt.Sprint(keyVal)
 }
 
-func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
+func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl, containingComp string, opts *RenderOpts) {
 	if elem == nil || elem.Tag == "" {
 		r.unmount(comp)
 		return
@@ -43,7 +44,7 @@ func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl, opts *Rende
 	elemKey := getElemKey(elem)
 	if *comp == nil || !(*comp).compMatch(elem.Tag, elemKey) {
 		r.unmount(comp)
-		r.createComp(elem.Tag, elemKey, comp)
+		r.createComp(elem.Tag, elemKey, containingComp, comp)
 	}
 	(*comp).Elem = elem
 	if elem.Tag == vdom.TextTag {
@@ -53,7 +54,7 @@ func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl, opts *Rende
 	}
 	if isBaseTag(elem.Tag) {
 		// Pattern 2: Base elements
-		r.renderSimple(elem, comp, opts)
+		r.renderSimple(elem, comp, containingComp, opts)
 		return
 	}
 	cfunc := r.CFuncs[elem.Tag]
@@ -75,12 +76,12 @@ func (r *RootElem) renderText(text string, comp **ComponentImpl) {
 }
 
 // Pattern 2
-func (r *RootElem) renderSimple(elem *vdom.VDomElem, comp **ComponentImpl, opts *RenderOpts) {
+func (r *RootElem) renderSimple(elem *vdom.VDomElem, comp **ComponentImpl, containingComp string, opts *RenderOpts) {
 	if (*comp).RenderedComp != nil {
 		// Clear Comp since base elements don't use it
 		r.unmount(&(*comp).RenderedComp)
 	}
-	(*comp).Children = r.renderChildren(elem.Children, (*comp).Children, opts)
+	(*comp).Children = r.renderChildren(elem.Children, (*comp).Children, containingComp, opts)
 }
 
 // Pattern 3
@@ -99,7 +100,7 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 	props[ChildrenPropKey] = elem.Children
 	vc := makeContextVal(r, *comp, opts)
 	rtnElemArr := withGlobalCtx(vc, func() []vdom.VDomElem {
-		renderedElem := callCFunc(cfunc, props)
+		renderedElem := callCFuncWithErrorGuard(cfunc, props, elem.Tag)
 		return vdom.ToElems(renderedElem)
 	})
 	var rtnElem *vdom.VDomElem
@@ -110,7 +111,7 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 	} else {
 		rtnElem = &vdom.VDomElem{Tag: vdom.FragmentTag, Children: rtnElemArr}
 	}
-	r.render(rtnElem, &(*comp).RenderedComp, opts)
+	r.render(rtnElem, &(*comp).RenderedComp, elem.Tag, opts)
 }
 
 func (r *RootElem) unmount(comp **ComponentImpl) {
@@ -136,14 +137,14 @@ func (r *RootElem) unmount(comp **ComponentImpl) {
 	*comp = nil
 }
 
-func (r *RootElem) createComp(tag string, key string, comp **ComponentImpl) {
-	*comp = &ComponentImpl{WaveId: uuid.New().String(), Tag: tag, Key: key}
+func (r *RootElem) createComp(tag string, key string, containingComp string, comp **ComponentImpl) {
+	*comp = &ComponentImpl{WaveId: uuid.New().String(), Tag: tag, Key: key, ContainingComp: containingComp}
 	r.CompMap[(*comp).WaveId] = *comp
 }
 
 // handles reconcilation
 // maps children via key or index (exclusively)
-func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*ComponentImpl, opts *RenderOpts) []*ComponentImpl {
+func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*ComponentImpl, containingComp string, opts *RenderOpts) []*ComponentImpl {
 	newChildren := make([]*ComponentImpl, len(elems))
 	curCM := make(map[ChildKey]*ComponentImpl)
 	usedMap := make(map[*ComponentImpl]bool)
@@ -164,7 +165,7 @@ func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*Componen
 		}
 		usedMap[curChild] = true
 		newChildren[idx] = curChild
-		r.render(&elem, &newChildren[idx], opts)
+		r.render(&elem, &newChildren[idx], containingComp, opts)
 	}
 	for _, child := range curChildren {
 		if !usedMap[child] {
@@ -174,6 +175,33 @@ func (r *RootElem) renderChildren(elems []vdom.VDomElem, curChildren []*Componen
 	return newChildren
 }
 
+// creates an error component for display when a component panics
+func renderErrorComponent(componentName string, errorMsg string) any {
+	return vdom.H("div", map[string]any{
+		"className": "p-4 border border-red-500 bg-red-100 text-red-800 rounded font-mono",
+	},
+		vdom.H("div", map[string]any{
+			"className": "font-bold mb-2",
+		}, fmt.Sprintf("Component Error: %s", componentName)),
+		vdom.H("div", nil, errorMsg),
+	)
+}
+
+// safely calls the component function with panic recovery
+func callCFuncWithErrorGuard(cfunc any, props map[string]any, componentName string) (result any) {
+	defer func() {
+		if r := recover(); r != nil {
+			errorMsg := fmt.Sprintf("Error: %v", r)
+			result = renderErrorComponent(componentName, errorMsg)
+			stackTrace := string(debug.Stack())
+			fmt.Printf("Render panic in component '%s': %v\n%s\n", componentName, r, stackTrace)
+		}
+	}()
+
+	result = callCFunc(cfunc, props)
+	return result
+}
+
 // uses reflection to call the component function
 func callCFunc(cfunc any, props map[string]any) any {
 	rval := reflect.ValueOf(cfunc)
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index c950b4131d..b53ba17b8e 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"log"
 	"reflect"
+	"runtime/debug"
 	"strconv"
 	"strings"
 	"sync"
@@ -247,6 +248,18 @@ func (r *RootElem) Event(id string, propName string, event vdom.VDomEvent) {
 	if comp == nil || comp.Elem == nil {
 		return
 	}
+	
+	defer func() {
+		if r := recover(); r != nil {
+			tag := ""
+			if comp.Elem != nil {
+				tag = comp.Elem.Tag
+			}
+			log.Printf("PANIC in Event handler - comp: %s, tag: %s, prop: %s, error: %v\n", comp.ContainingComp, tag, propName, r)
+			log.Printf("Stack trace:\n%s", debug.Stack())
+		}
+	}()
+	
 	fnVal := comp.Elem.Props[propName]
 	callVDomFn(fnVal, event)
 }
@@ -281,7 +294,7 @@ func (r *RootElem) RunWork(opts *RenderOpts) {
 	// now check if we need a render
 	if len(r.NeedsRenderMap) > 0 {
 		r.NeedsRenderMap = nil
-		r.render(r.Root.Elem, &r.Root, opts)
+		r.render(r.Root.Elem, &r.Root, "root", opts)
 	}
 }
 
diff --git a/tsunami/templates/tailwind.css b/tsunami/templates/tailwind.css
index 1bc07b3ca6..72db71b2b7 100644
--- a/tsunami/templates/tailwind.css
+++ b/tsunami/templates/tailwind.css
@@ -2,7 +2,8 @@
 /* SPDX-License-Identifier: Apache-2.0 */
 
 @import "tailwindcss";
-@source inline("bg-background text-primary");
+@source inline("bg-background text-primary"); /* index.html */
+@source inline("p-4 border border-red-500 bg-red-100 text-red-800 rounded font-mono font-bold mb-2"); /* error component */
 
 @theme {
     --color-background: rgb(34, 34, 34); /* default background color */

From ba5655f10a31a31f9cd4db41dc72a61749738487 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 14:45:53 -0700
Subject: [PATCH 117/134] panic handlers

---
 tsunami/app/hooks.go       | 14 +++++++++++++-
 tsunami/engine/render.go   |  8 ++------
 tsunami/engine/rootelem.go | 13 +++++--------
 tsunami/util/util.go       |  6 ++++++
 4 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/tsunami/app/hooks.go b/tsunami/app/hooks.go
index c1febe7c7b..bf629d2c75 100644
--- a/tsunami/app/hooks.go
+++ b/tsunami/app/hooks.go
@@ -5,9 +5,11 @@ package app
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	"github.com/wavetermdev/waveterm/tsunami/engine"
+	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
@@ -165,7 +167,17 @@ func UseGoRoutine(fn func(ctx context.Context), deps []any) {
 		ctx, cancel := context.WithCancel(context.Background())
 		cancelRef.Current = cancel
 
-		go fn(ctx)
+		componentName := "unknown"
+		if rc.Comp != nil && rc.Comp.Elem != nil {
+			componentName = rc.Comp.Elem.Tag
+		}
+
+		go func() {
+			defer func() {
+				util.PanicHandler(fmt.Sprintf("UseGoRoutine in component '%s'", componentName), recover())
+			}()
+			fn(ctx)
+		}()
 
 		// Return cleanup function that cancels the context
 		return func() {
diff --git a/tsunami/engine/render.go b/tsunami/engine/render.go
index f345461d53..76da43782c 100644
--- a/tsunami/engine/render.go
+++ b/tsunami/engine/render.go
@@ -6,7 +6,6 @@ package engine
 import (
 	"fmt"
 	"reflect"
-	"runtime/debug"
 	"unicode"
 
 	"github.com/google/uuid"
@@ -190,11 +189,8 @@ func renderErrorComponent(componentName string, errorMsg string) any {
 // safely calls the component function with panic recovery
 func callCFuncWithErrorGuard(cfunc any, props map[string]any, componentName string) (result any) {
 	defer func() {
-		if r := recover(); r != nil {
-			errorMsg := fmt.Sprintf("Error: %v", r)
-			result = renderErrorComponent(componentName, errorMsg)
-			stackTrace := string(debug.Stack())
-			fmt.Printf("Render panic in component '%s': %v\n%s\n", componentName, r, stackTrace)
+		if panicErr := util.PanicHandler(fmt.Sprintf("render component '%s'", componentName), recover()); panicErr != nil {
+			result = renderErrorComponent(componentName, panicErr.Error())
 		}
 	}()
 
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index b53ba17b8e..8895562329 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -7,12 +7,12 @@ import (
 	"fmt"
 	"log"
 	"reflect"
-	"runtime/debug"
 	"strconv"
 	"strings"
 	"sync"
 
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
+	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
@@ -250,14 +250,11 @@ func (r *RootElem) Event(id string, propName string, event vdom.VDomEvent) {
 	}
 	
 	defer func() {
-		if r := recover(); r != nil {
-			tag := ""
-			if comp.Elem != nil {
-				tag = comp.Elem.Tag
-			}
-			log.Printf("PANIC in Event handler - comp: %s, tag: %s, prop: %s, error: %v\n", comp.ContainingComp, tag, propName, r)
-			log.Printf("Stack trace:\n%s", debug.Stack())
+		tag := ""
+		if comp.Elem != nil {
+			tag = comp.Elem.Tag
 		}
+		util.PanicHandler(fmt.Sprintf("Event handler - comp: %s, tag: %s, prop: %s", comp.ContainingComp, tag, propName), recover())
 	}()
 	
 	fnVal := comp.Elem.Props[propName]
diff --git a/tsunami/util/util.go b/tsunami/util/util.go
index 74032036b5..e8d879c783 100644
--- a/tsunami/util/util.go
+++ b/tsunami/util/util.go
@@ -15,6 +15,12 @@ import (
 	"time"
 )
 
+// PanicHandler handles panic recovery and logging.
+// It can be called directly with recover() without checking for nil first.
+// Example usage:
+//   defer func() {
+//       util.PanicHandler("operation name", recover())
+//   }()
 func PanicHandler(debugStr string, recoverVal any) error {
 	if recoverVal == nil {
 		return nil

From f24b7367b0701ff8b79a4e8eb91525dea5a7ed1a Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 15:16:32 -0700
Subject: [PATCH 118/134] create a global event context

---
 tsunami/app/atom.go              |  6 ++--
 tsunami/app/hooks.go             | 20 +++++------
 tsunami/app/root_test.go         |  2 +-
 tsunami/engine/clientimpl.go     |  6 ++++
 tsunami/engine/globalctx.go      | 59 ++++++++++++++++++++++++++------
 tsunami/engine/hooks.go          | 32 ++++++++---------
 tsunami/engine/render.go         |  2 +-
 tsunami/engine/rootelem.go       | 46 ++++++++++++++++++-------
 tsunami/engine/serverhandlers.go | 10 +-----
 9 files changed, 121 insertions(+), 62 deletions(-)

diff --git a/tsunami/app/atom.go b/tsunami/app/atom.go
index 4dc0e671e6..4817adc297 100644
--- a/tsunami/app/atom.go
+++ b/tsunami/app/atom.go
@@ -73,7 +73,7 @@ func (a Atom[T]) AtomName() string {
 // it automatically registers the component as a dependency for this atom, ensuring
 // the component re-renders when the atom value changes.
 func (a Atom[T]) Get() T {
-	vc := engine.GetGlobalContext()
+	vc := engine.GetGlobalRenderContext()
 	if vc != nil {
 		compWaveId := vc.GetCompWaveId()
 		vc.Root.AtomSetUsedBy(a.name, compWaveId, true)
@@ -87,7 +87,7 @@ func (a Atom[T]) Get() T {
 // of any components that depend on this atom. This method cannot be called during
 // render cycles - use effects or event handlers instead.
 func (a Atom[T]) Set(newVal T) {
-	vc := engine.GetGlobalContext()
+	vc := engine.GetGlobalRenderContext()
 	if vc != nil {
 		logInvalidAtomSet(a.name)
 		return
@@ -112,7 +112,7 @@ func (a Atom[T]) Set(newVal T) {
 // without affecting the original data. The return value from the function becomes the
 // new atom value. This method cannot be called during render cycles.
 func (a Atom[T]) SetFn(fn func(T) T) {
-	vc := engine.GetGlobalContext()
+	vc := engine.GetGlobalRenderContext()
 	if vc != nil {
 		logInvalidAtomSet(a.name)
 		return
diff --git a/tsunami/app/hooks.go b/tsunami/app/hooks.go
index bf629d2c75..35df25b886 100644
--- a/tsunami/app/hooks.go
+++ b/tsunami/app/hooks.go
@@ -19,7 +19,7 @@ import (
 // Setting a new value causes a re-render of the component.
 // This hook must be called within a component context.
 func UseState[T any](initialVal T) (T, func(T), func(func(T) T)) {
-	rc := engine.GetGlobalContext()
+	rc := engine.GetGlobalRenderContext()
 	if rc == nil {
 		panic("UseState must be called within a component (no context)")
 	}
@@ -48,7 +48,7 @@ func UseState[T any](initialVal T) (T, func(T), func(func(T) T)) {
 // current after client-side mounting.
 // This hook must be called within a component context.
 func UseVDomRef() *vdom.VDomRef {
-	rc := engine.GetGlobalContext()
+	rc := engine.GetGlobalRenderContext()
 	val := engine.UseVDomRef(rc)
 	refVal, ok := val.(*vdom.VDomRef)
 	if !ok {
@@ -62,7 +62,7 @@ func UseVDomRef() *vdom.VDomRef {
 // Unlike UseVDomRef, this is not tied to DOM elements but holds arbitrary values.
 // This hook must be called within a component context.
 func UseRef[T any](val T) *vdom.VDomSimpleRef[T] {
-	rc := engine.GetGlobalContext()
+	rc := engine.GetGlobalRenderContext()
 	refVal := engine.UseRef(rc, &vdom.VDomSimpleRef[T]{Current: val})
 	typedRef, ok := refVal.(*vdom.VDomSimpleRef[T])
 	if !ok {
@@ -76,7 +76,7 @@ func UseRef[T any](val T) *vdom.VDomSimpleRef[T] {
 // is recreated, following React component lifecycle.
 // This hook must be called within a component context.
 func UseId() string {
-	rc := engine.GetGlobalContext()
+	rc := engine.GetGlobalRenderContext()
 	if rc == nil {
 		panic("UseId must be called within a component (no context)")
 	}
@@ -86,7 +86,7 @@ func UseId() string {
 // UseRenderTs returns the timestamp of the current render.
 // This hook must be called within a component context.
 func UseRenderTs() int64 {
-	rc := engine.GetGlobalContext()
+	rc := engine.GetGlobalRenderContext()
 	if rc == nil {
 		panic("UseRenderTs must be called within a component (no context)")
 	}
@@ -98,7 +98,7 @@ func UseRenderTs() int64 {
 // incremental renders which happen otherwise.
 // This hook must be called within a component context.
 func UseResync() bool {
-	rc := engine.GetGlobalContext()
+	rc := engine.GetGlobalRenderContext()
 	if rc == nil {
 		panic("UseResync must be called within a component (no context)")
 	}
@@ -112,7 +112,7 @@ func UseResync() bool {
 // This hook must be called within a component context.
 func UseEffect(fn func() func(), deps []any) {
 	// note UseEffect never actually runs anything, it just queues the effect to run later
-	rc := engine.GetGlobalContext()
+	rc := engine.GetGlobalRenderContext()
 	if rc == nil {
 		panic("UseEffect must be called within a component (no context)")
 	}
@@ -122,7 +122,7 @@ func UseEffect(fn func() func(), deps []any) {
 // UseSetAppTitle sets the application title for the current component.
 // This hook must be called within a component context.
 func UseSetAppTitle(title string) {
-	rc := engine.GetGlobalContext()
+	rc := engine.GetGlobalRenderContext()
 	if rc == nil {
 		panic("UseSetAppTitle must be called within a component (no context)")
 	}
@@ -133,7 +133,7 @@ func UseSetAppTitle(title string) {
 // The atom is created with a unique name based on the component's wave ID and hook index.
 // This hook must be called within a component context.
 func UseLocal[T any](initialVal T) Atom[T] {
-	rc := engine.GetGlobalContext()
+	rc := engine.GetGlobalRenderContext()
 	if rc == nil {
 		panic("UseLocal must be called within a component (no context)")
 	}
@@ -149,7 +149,7 @@ func UseLocal[T any](initialVal T) Atom[T] {
 // and automatically cancels the context on dependency changes or component unmount.
 // This hook must be called within a component context.
 func UseGoRoutine(fn func(ctx context.Context), deps []any) {
-	rc := engine.GetGlobalContext()
+	rc := engine.GetGlobalRenderContext()
 	if rc == nil {
 		panic("UseGoRoutine must be called within a component (no context)")
 	}
diff --git a/tsunami/app/root_test.go b/tsunami/app/root_test.go
index eba0a51689..dc1e78d6e3 100644
--- a/tsunami/app/root_test.go
+++ b/tsunami/app/root_test.go
@@ -68,7 +68,7 @@ func Test1(t *testing.T) {
 	printVDom(root)
 	root.RunWork(&engine.RenderOpts{Resync: false})
 	printVDom(root)
-	root.Event(buttonId, "onClick", vdom.VDomEvent{EventType: "onClick"})
+	root.Event(vdom.VDomEvent{WaveId: buttonId, EventType: "onClick"}, nil)
 	root.RunWork(&engine.RenderOpts{Resync: false})
 	printVDom(root)
 }
diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index b12e63bea3..96b2bc95f9 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -300,3 +300,9 @@ func (c *ClientImpl) HandleDynFunc(pattern string, fn func(http.ResponseWriter,
 	}
 	c.UrlHandlerMux.HandleFunc(pattern, fn)
 }
+
+func (c *ClientImpl) RunEvents(events []vdom.VDomEvent) {
+	for _, event := range events {
+		c.Root.Event(event, c.GlobalEventHandler)
+	}
+}
diff --git a/tsunami/engine/globalctx.go b/tsunami/engine/globalctx.go
index 2591e177fe..ee7f292625 100644
--- a/tsunami/engine/globalctx.go
+++ b/tsunami/engine/globalctx.go
@@ -7,40 +7,79 @@ import (
 	"sync"
 
 	"github.com/outrigdev/goid"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
 // is set ONLY when we're in the render function of a component
 // used for hooks, and automatic dependency tracking
-var globalVC *VDomContextImpl
+var globalRenderContext *RenderContextImpl
 var globalRenderGoId uint64
+
+var globalEventContext *EventContextImpl
+var globalEventGoId uint64
+
 var globalCtxMutex sync.Mutex
 
-func setGlobalContext(vc *VDomContextImpl) {
+type EventContextImpl struct {
+	Event vdom.VDomEvent
+}
+
+func setGlobalRenderContext(vc *RenderContextImpl) {
 	globalCtxMutex.Lock()
 	defer globalCtxMutex.Unlock()
-	globalVC = vc
+	globalRenderContext = vc
 	globalRenderGoId = goid.Get()
 }
 
-func clearGlobalContext() {
+func clearGlobalRenderContext() {
 	globalCtxMutex.Lock()
 	defer globalCtxMutex.Unlock()
-	globalVC = nil
+	globalRenderContext = nil
 	globalRenderGoId = 0
 }
 
-func withGlobalCtx[T any](vc *VDomContextImpl, fn func() T) T {
-	setGlobalContext(vc)
-	defer clearGlobalContext()
+func withGlobalRenderCtx[T any](vc *RenderContextImpl, fn func() T) T {
+	setGlobalRenderContext(vc)
+	defer clearGlobalRenderContext()
 	return fn()
 }
 
-func GetGlobalContext() *VDomContextImpl {
+func GetGlobalRenderContext() *RenderContextImpl {
 	globalCtxMutex.Lock()
 	defer globalCtxMutex.Unlock()
 	gid := goid.Get()
 	if gid != globalRenderGoId {
 		return nil
 	}
-	return globalVC
+	return globalRenderContext
+}
+
+func setGlobalEventContext(ec *EventContextImpl) {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	globalEventContext = ec
+	globalEventGoId = goid.Get()
+}
+
+func clearGlobalEventContext() {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	globalEventContext = nil
+	globalEventGoId = 0
+}
+
+func withGlobalEventCtx[T any](ec *EventContextImpl, fn func() T) T {
+	setGlobalEventContext(ec)
+	defer clearGlobalEventContext()
+	return fn()
+}
+
+func GetGlobalEventContext() *EventContextImpl {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	gid := goid.Get()
+	if gid != globalEventGoId {
+		return nil
+	}
+	return globalEventContext
 }
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index 41f9755faa..9657fab456 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -20,25 +20,25 @@ type Hook struct {
 	Deps      []any
 }
 
-type VDomContextImpl struct {
+type RenderContextImpl struct {
 	Root       *RootElem
 	Comp       *ComponentImpl
 	HookIdx    int
 	RenderOpts *RenderOpts
 }
 
-func makeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *VDomContextImpl {
-	return &VDomContextImpl{Root: root, Comp: comp, HookIdx: 0, RenderOpts: opts}
+func makeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *RenderContextImpl {
+	return &RenderContextImpl{Root: root, Comp: comp, HookIdx: 0, RenderOpts: opts}
 }
 
-func (vc *VDomContextImpl) GetCompWaveId() string {
+func (vc *RenderContextImpl) GetCompWaveId() string {
 	if vc.Comp == nil {
 		return ""
 	}
 	return vc.Comp.WaveId
 }
 
-func (vc *VDomContextImpl) getOrderedHook() *Hook {
+func (vc *RenderContextImpl) getOrderedHook() *Hook {
 	if vc.Comp == nil {
 		panic("tsunami hooks must be called within a component (vc.Comp is nil)")
 	}
@@ -50,22 +50,22 @@ func (vc *VDomContextImpl) getOrderedHook() *Hook {
 	return hookVal
 }
 
-func (vc *VDomContextImpl) getCompName() string {
+func (vc *RenderContextImpl) getCompName() string {
 	if vc.Comp == nil || vc.Comp.Elem == nil {
 		return ""
 	}
 	return vc.Comp.Elem.Tag
 }
 
-func UseRenderTs(vc *VDomContextImpl) int64 {
+func UseRenderTs(vc *RenderContextImpl) int64 {
 	return vc.Root.RenderTs
 }
 
-func UseId(vc *VDomContextImpl) string {
+func UseId(vc *RenderContextImpl) string {
 	return vc.GetCompWaveId()
 }
 
-func UseState(vc *VDomContextImpl, initialVal any) (any, func(any), func(func(any) any)) {
+func UseState(vc *RenderContextImpl, initialVal any) (any, func(any), func(func(any) any)) {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
@@ -85,7 +85,7 @@ func UseState(vc *VDomContextImpl, initialVal any) (any, func(any), func(func(an
 	return hookVal.Val, setVal, setFuncVal
 }
 
-func UseAtom(vc *VDomContextImpl, atomName string) (any, func(any), func(func(any) any)) {
+func UseAtom(vc *RenderContextImpl, atomName string) (any, func(any), func(func(any) any)) {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
@@ -117,7 +117,7 @@ func UseAtom(vc *VDomContextImpl, atomName string) (any, func(any), func(func(an
 	return atomVal, setVal, setFuncVal
 }
 
-func UseLocal(vc *VDomContextImpl, initialVal any) string {
+func UseLocal(vc *RenderContextImpl, initialVal any) string {
 	hookVal := vc.getOrderedHook()
 	atomName := "$local." + vc.GetCompWaveId() + "#" + strconv.Itoa(hookVal.Idx)
 	if !hookVal.Init {
@@ -132,7 +132,7 @@ func UseLocal(vc *VDomContextImpl, initialVal any) string {
 	return atomName
 }
 
-func UseVDomRef(vc *VDomContextImpl) any {
+func UseVDomRef(vc *RenderContextImpl) any {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
@@ -146,7 +146,7 @@ func UseVDomRef(vc *VDomContextImpl) any {
 	return refVal
 }
 
-func UseRef(vc *VDomContextImpl, hookInitialVal any) any {
+func UseRef(vc *RenderContextImpl, hookInitialVal any) any {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
@@ -167,7 +167,7 @@ func depsEqual(deps1 []any, deps2 []any) bool {
 	return true
 }
 
-func UseEffect(vc *VDomContextImpl, fn func() func(), deps []any) {
+func UseEffect(vc *RenderContextImpl, fn func() func(), deps []any) {
 	hookVal := vc.getOrderedHook()
 	if !hookVal.Init {
 		hookVal.Init = true
@@ -192,14 +192,14 @@ func UseEffect(vc *VDomContextImpl, fn func() func(), deps []any) {
 	vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
 }
 
-func UseResync(vc *VDomContextImpl) bool {
+func UseResync(vc *RenderContextImpl) bool {
 	if vc.RenderOpts == nil {
 		return false
 	}
 	return vc.RenderOpts.Resync
 }
 
-func UseSetAppTitle(vc *VDomContextImpl, title string) {
+func UseSetAppTitle(vc *RenderContextImpl, title string) {
 	if vc.getCompName() != "App" {
 		log.Printf("UseSetAppTitle can only be called from the App component")
 		return
diff --git a/tsunami/engine/render.go b/tsunami/engine/render.go
index 76da43782c..c24021e665 100644
--- a/tsunami/engine/render.go
+++ b/tsunami/engine/render.go
@@ -98,7 +98,7 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 	}
 	props[ChildrenPropKey] = elem.Children
 	vc := makeContextVal(r, *comp, opts)
-	rtnElemArr := withGlobalCtx(vc, func() []vdom.VDomElem {
+	rtnElemArr := withGlobalRenderCtx(vc, func() []vdom.VDomElem {
 		renderedElem := callCFuncWithErrorGuard(cfunc, props, elem.Tag)
 		return vdom.ToElems(renderedElem)
 	})
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 8895562329..9b0d6f8279 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -243,22 +243,44 @@ func callVDomFn(fnVal any, data vdom.VDomEvent) {
 	}
 }
 
-func (r *RootElem) Event(id string, propName string, event vdom.VDomEvent) {
-	comp := r.CompMap[id]
-	if comp == nil || comp.Elem == nil {
-		return
-	}
-	
+func (r *RootElem) Event(event vdom.VDomEvent, globalEventHandler func(vdom.VDomEvent)) {
 	defer func() {
-		tag := ""
-		if comp.Elem != nil {
-			tag = comp.Elem.Tag
+		if event.GlobalEventType != "" {
+			util.PanicHandler(fmt.Sprintf("Global event handler - event:%s", event.GlobalEventType), recover())
+		} else {
+			comp := r.CompMap[event.WaveId]
+			tag := ""
+			if comp != nil && comp.Elem != nil {
+				tag = comp.Elem.Tag
+			}
+			compName := ""
+			if comp != nil {
+				compName = comp.ContainingComp
+			}
+			util.PanicHandler(fmt.Sprintf("Event handler - comp: %s, tag: %s, prop: %s", compName, tag, event.EventType), recover())
 		}
-		util.PanicHandler(fmt.Sprintf("Event handler - comp: %s, tag: %s, prop: %s", comp.ContainingComp, tag, propName), recover())
 	}()
 	
-	fnVal := comp.Elem.Props[propName]
-	callVDomFn(fnVal, event)
+	eventCtx := &EventContextImpl{Event: event}
+	withGlobalEventCtx(eventCtx, func() any {
+		if event.GlobalEventType != "" {
+			if globalEventHandler == nil {
+				log.Printf("global event %s but no handler", event.GlobalEventType)
+				return nil
+			}
+			globalEventHandler(event)
+			return nil
+		}
+		
+		comp := r.CompMap[event.WaveId]
+		if comp == nil || comp.Elem == nil {
+			return nil
+		}
+		
+		fnVal := comp.Elem.Props[event.EventType]
+		callVDomFn(fnVal, event)
+		return nil
+	})
 }
 
 // this will be called by the frontend to say the DOM has been mounted
diff --git a/tsunami/engine/serverhandlers.go b/tsunami/engine/serverhandlers.go
index 0fd1afc43a..05b8a38364 100644
--- a/tsunami/engine/serverhandlers.go
+++ b/tsunami/engine/serverhandlers.go
@@ -149,15 +149,7 @@ func (h *httpHandlers) processFrontendUpdate(feUpdate *rpctypes.VDomFrontendUpda
 	h.Client.Root.RenderTs = feUpdate.Ts
 
 	// run events
-	for _, event := range feUpdate.Events {
-		if event.GlobalEventType != "" {
-			if h.Client.GlobalEventHandler != nil {
-				h.Client.GlobalEventHandler(event)
-			}
-		} else {
-			h.Client.Root.Event(event.WaveId, event.EventType, event)
-		}
-	}
+	h.Client.RunEvents(feUpdate.Events)
 	// update refs
 	for _, ref := range feUpdate.RefUpdates {
 		h.Client.Root.UpdateRef(ref)

From 1c91358aa51db3b0a9f2d4b215da316a3eff4fc9 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 15:37:40 -0700
Subject: [PATCH 119/134] add panic handlers for effect work

---
 tsunami/engine/globalctx.go | 38 ++++++++++++++++++++
 tsunami/engine/hooks.go     | 10 ++++--
 tsunami/engine/rootelem.go  | 69 +++++++++++++++++++++++++++++--------
 3 files changed, 100 insertions(+), 17 deletions(-)

diff --git a/tsunami/engine/globalctx.go b/tsunami/engine/globalctx.go
index ee7f292625..782e1889fa 100644
--- a/tsunami/engine/globalctx.go
+++ b/tsunami/engine/globalctx.go
@@ -18,12 +18,20 @@ var globalRenderGoId uint64
 var globalEventContext *EventContextImpl
 var globalEventGoId uint64
 
+var globalEffectContext *EffectContextImpl
+var globalEffectGoId uint64
+
 var globalCtxMutex sync.Mutex
 
 type EventContextImpl struct {
 	Event vdom.VDomEvent
 }
 
+type EffectContextImpl struct {
+	WorkElem EffectWorkElem
+	WorkType string // "run" or "unmount"
+}
+
 func setGlobalRenderContext(vc *RenderContextImpl) {
 	globalCtxMutex.Lock()
 	defer globalCtxMutex.Unlock()
@@ -83,3 +91,33 @@ func GetGlobalEventContext() *EventContextImpl {
 	}
 	return globalEventContext
 }
+
+func setGlobalEffectContext(ec *EffectContextImpl) {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	globalEffectContext = ec
+	globalEffectGoId = goid.Get()
+}
+
+func clearGlobalEffectContext() {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	globalEffectContext = nil
+	globalEffectGoId = 0
+}
+
+func withGlobalEffectCtx[T any](ec *EffectContextImpl, fn func() T) T {
+	setGlobalEffectContext(ec)
+	defer clearGlobalEffectContext()
+	return fn()
+}
+
+func GetGlobalEffectContext() *EffectContextImpl {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	gid := goid.Get()
+	if gid != globalEffectGoId {
+		return nil
+	}
+	return globalEffectContext
+}
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index 9657fab456..d8269705ee 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -169,18 +169,22 @@ func depsEqual(deps1 []any, deps2 []any) bool {
 
 func UseEffect(vc *RenderContextImpl, fn func() func(), deps []any) {
 	hookVal := vc.getOrderedHook()
+	compTag := ""
+	if vc.Comp != nil {
+		compTag = vc.Comp.Tag
+	}
 	if !hookVal.Init {
 		hookVal.Init = true
 		hookVal.Fn = fn
 		hookVal.Deps = deps
-		vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
+		vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
 		return
 	}
 	// If deps is nil, always run (like React with no dependency array)
 	if deps == nil {
 		hookVal.Fn = fn
 		hookVal.Deps = deps
-		vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
+		vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
 		return
 	}
 
@@ -189,7 +193,7 @@ func UseEffect(vc *RenderContextImpl, fn func() func(), deps []any) {
 	}
 	hookVal.Fn = fn
 	hookVal.Deps = deps
-	vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx)
+	vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
 }
 
 func UseResync(vc *RenderContextImpl) bool {
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 9b0d6f8279..ff7bbae038 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -19,8 +19,9 @@ import (
 const ChildrenPropKey = "children"
 
 type EffectWorkElem struct {
-	Id          string
+	WaveId      string
 	EffectIndex int
+	CompTag     string
 }
 
 type genAtom interface {
@@ -51,8 +52,8 @@ func (r *RootElem) AddRenderWork(id string) {
 	r.NeedsRenderMap[id] = true
 }
 
-func (r *RootElem) AddEffectWork(id string, effectIndex int) {
-	r.EffectWorkQueue = append(r.EffectWorkQueue, &EffectWorkElem{Id: id, EffectIndex: effectIndex})
+func (r *RootElem) AddEffectWork(id string, effectIndex int, compTag string) {
+	r.EffectWorkQueue = append(r.EffectWorkQueue, &EffectWorkElem{WaveId: id, EffectIndex: effectIndex, CompTag: compTag})
 }
 
 func (r *RootElem) GetDataMap() map[string]any {
@@ -260,7 +261,7 @@ func (r *RootElem) Event(event vdom.VDomEvent, globalEventHandler func(vdom.VDom
 			util.PanicHandler(fmt.Sprintf("Event handler - comp: %s, tag: %s, prop: %s", compName, tag, event.EventType), recover())
 		}
 	}()
-	
+
 	eventCtx := &EventContextImpl{Event: event}
 	withGlobalEventCtx(eventCtx, func() any {
 		if event.GlobalEventType != "" {
@@ -271,18 +272,62 @@ func (r *RootElem) Event(event vdom.VDomEvent, globalEventHandler func(vdom.VDom
 			globalEventHandler(event)
 			return nil
 		}
-		
+
 		comp := r.CompMap[event.WaveId]
 		if comp == nil || comp.Elem == nil {
 			return nil
 		}
-		
+
 		fnVal := comp.Elem.Props[event.EventType]
 		callVDomFn(fnVal, event)
 		return nil
 	})
 }
 
+func (r *RootElem) runEffectUnmount(work *EffectWorkElem, hook *Hook) {
+	defer func() {
+		comp := r.CompMap[work.WaveId]
+		compName := ""
+		if comp != nil {
+			compName = comp.ContainingComp
+		}
+		util.PanicHandler(fmt.Sprintf("UseEffect unmount - comp: %s", compName), recover())
+	}()
+	if hook.UnmountFn == nil {
+		return
+	}
+	effectCtx := &EffectContextImpl{
+		WorkElem: *work,
+		WorkType: "unmount",
+	}
+	withGlobalEffectCtx(effectCtx, func() any {
+		hook.UnmountFn()
+		return nil
+	})
+}
+
+func (r *RootElem) runEffect(work *EffectWorkElem, hook *Hook) {
+	defer func() {
+		comp := r.CompMap[work.WaveId]
+		compName := ""
+		if comp != nil {
+			compName = comp.ContainingComp
+		}
+		util.PanicHandler(fmt.Sprintf("UseEffect run - comp: %s", compName), recover())
+	}()
+	if hook.Fn == nil {
+		return
+	}
+	effectCtx := &EffectContextImpl{
+		WorkElem: *work,
+		WorkType: "run",
+	}
+	unmountFn := withGlobalEffectCtx(effectCtx, func() func() {
+		return hook.Fn()
+	})
+	hook.UnmountFn = unmountFn
+}
+
 // this will be called by the frontend to say the DOM has been mounted
 // it will eventually send any updated "refs" to the backend as well
 func (r *RootElem) RunWork(opts *RenderOpts) {
@@ -290,25 +335,21 @@ func (r *RootElem) RunWork(opts *RenderOpts) {
 	r.EffectWorkQueue = nil
 	// first, run effect cleanups
 	for _, work := range workQueue {
-		comp := r.CompMap[work.Id]
+		comp := r.CompMap[work.WaveId]
 		if comp == nil {
 			continue
 		}
 		hook := comp.Hooks[work.EffectIndex]
-		if hook.UnmountFn != nil {
-			hook.UnmountFn()
-		}
+		r.runEffectUnmount(work, hook)
 	}
 	// now run, new effects
 	for _, work := range workQueue {
-		comp := r.CompMap[work.Id]
+		comp := r.CompMap[work.WaveId]
 		if comp == nil {
 			continue
 		}
 		hook := comp.Hooks[work.EffectIndex]
-		if hook.Fn != nil {
-			hook.UnmountFn = hook.Fn()
-		}
+		r.runEffect(work, hook)
 	}
 	// now check if we need a render
 	if len(r.NeedsRenderMap) > 0 {

From c33fc7e3346f7ed5933a4a92bcfb048785b5ea30 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 15:40:34 -0700
Subject: [PATCH 120/134] added RootElem to event/effect global contexts

---
 tsunami/engine/globalctx.go | 2 ++
 tsunami/engine/rootelem.go  | 4 +++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/tsunami/engine/globalctx.go b/tsunami/engine/globalctx.go
index 782e1889fa..07508dbf88 100644
--- a/tsunami/engine/globalctx.go
+++ b/tsunami/engine/globalctx.go
@@ -25,11 +25,13 @@ var globalCtxMutex sync.Mutex
 
 type EventContextImpl struct {
 	Event vdom.VDomEvent
+	Root  *RootElem
 }
 
 type EffectContextImpl struct {
 	WorkElem EffectWorkElem
 	WorkType string // "run" or "unmount"
+	Root     *RootElem
 }
 
 func setGlobalRenderContext(vc *RenderContextImpl) {
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index ff7bbae038..7bc9906e19 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -262,7 +262,7 @@ func (r *RootElem) Event(event vdom.VDomEvent, globalEventHandler func(vdom.VDom
 		}
 	}()
 
-	eventCtx := &EventContextImpl{Event: event}
+	eventCtx := &EventContextImpl{Event: event, Root: r}
 	withGlobalEventCtx(eventCtx, func() any {
 		if event.GlobalEventType != "" {
 			if globalEventHandler == nil {
@@ -299,6 +299,7 @@ func (r *RootElem) runEffectUnmount(work *EffectWorkElem, hook *Hook) {
 	effectCtx := &EffectContextImpl{
 		WorkElem: *work,
 		WorkType: "unmount",
+		Root:     r,
 	}
 	withGlobalEffectCtx(effectCtx, func() any {
 		hook.UnmountFn()
@@ -321,6 +322,7 @@ func (r *RootElem) runEffect(work *EffectWorkElem, hook *Hook) {
 	effectCtx := &EffectContextImpl{
 		WorkElem: *work,
 		WorkType: "run",
+		Root:     r,
 	}
 	unmountFn := withGlobalEffectCtx(effectCtx, func() func() {
 		return hook.Fn()

From 6cc1969ffa0e419c47ccefea60259002314bf0d5 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 16:00:12 -0700
Subject: [PATCH 121/134] add clientimpl pointer to rootelem for easy access

---
 tsunami/app/root_test.go     | 2 +-
 tsunami/engine/clientimpl.go | 2 +-
 tsunami/engine/rootelem.go   | 4 +++-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/tsunami/app/root_test.go b/tsunami/app/root_test.go
index dc1e78d6e3..ef6717a854 100644
--- a/tsunami/app/root_test.go
+++ b/tsunami/app/root_test.go
@@ -58,7 +58,7 @@ var buttonId string
 
 func Test1(t *testing.T) {
 	log.Printf("hello!\n")
-	root := engine.MakeRoot()
+	root := engine.MakeRoot(nil)
 	root.RegisterComponent("Page", Page)
 	root.RegisterComponent("Button", Button)
 	root.Render(vdom.H("Page", nil), &engine.RenderOpts{Resync: false})
diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index 96b2bc95f9..852dd31fec 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -54,13 +54,13 @@ type ClientImpl struct {
 func makeClient() *ClientImpl {
 	client := &ClientImpl{
 		Lock:          &sync.Mutex{},
-		Root:          MakeRoot(),
 		DoneCh:        make(chan struct{}),
 		SSEventCh:     make(chan ssEvent, 100),
 		UrlHandlerMux: http.NewServeMux(),
 		ServerId:      uuid.New().String(),
 		RootElem:      vdom.H(DefaultComponentName, nil),
 	}
+	client.Root = MakeRoot(client)
 	return client
 }
 
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 7bc9906e19..fd36afecdf 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -43,6 +43,7 @@ type RootElem struct {
 	Atoms           map[string]genAtom
 	atomLock        sync.Mutex
 	RefOperations   []vdom.VDomRefOperation
+	Client          *ClientImpl
 }
 
 func (r *RootElem) AddRenderWork(id string) {
@@ -84,12 +85,13 @@ func (r *RootElem) GetConfigMap() map[string]any {
 	return result
 }
 
-func MakeRoot() *RootElem {
+func MakeRoot(client *ClientImpl) *RootElem {
 	return &RootElem{
 		Root:    nil,
 		CFuncs:  make(map[string]any),
 		CompMap: make(map[string]*ComponentImpl),
 		Atoms:   make(map[string]genAtom),
+		Client:  client,
 	}
 }
 

From c3fa716e61780e67c1832228deb7cc48d933c6bf Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 16:07:02 -0700
Subject: [PATCH 122/134] remove UseState and UseAtom

---
 tsunami/app/hooks.go     | 29 ----------------
 tsunami/app/root_test.go | 74 ----------------------------------------
 tsunami/engine/hooks.go  | 52 ----------------------------
 3 files changed, 155 deletions(-)
 delete mode 100644 tsunami/app/root_test.go

diff --git a/tsunami/app/hooks.go b/tsunami/app/hooks.go
index 35df25b886..4be83edd24 100644
--- a/tsunami/app/hooks.go
+++ b/tsunami/app/hooks.go
@@ -13,35 +13,6 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
-// UseState is the tsunami analog to React's useState hook.
-// It provides persistent state management within a VDOM component, returning the current
-// state value, a setter function, and an updater function.
-// Setting a new value causes a re-render of the component.
-// This hook must be called within a component context.
-func UseState[T any](initialVal T) (T, func(T), func(func(T) T)) {
-	rc := engine.GetGlobalRenderContext()
-	if rc == nil {
-		panic("UseState must be called within a component (no context)")
-	}
-	val, setVal, setFn := engine.UseState(rc, initialVal)
-
-	// Adapt the "any" values to type "T"
-	var rtnVal T
-	rtnVal, ok := val.(T)
-	if !ok {
-		panic("UseState hook value is not a state (possible out of order or conditional hooks)")
-	}
-	typedSetVal := func(newVal T) {
-		setVal(newVal)
-	}
-	typedSetFuncVal := func(updateFunc func(T) T) {
-		setFn(func(oldVal any) any {
-			return updateFunc(oldVal.(T))
-		})
-	}
-	return rtnVal, typedSetVal, typedSetFuncVal
-}
-
 // UseVDomRef provides a reference to a DOM element in the VDOM tree.
 // It returns a VDomRef that can be attached to elements for direct DOM access.
 // The ref will not be current on the first render - refs are set and become
diff --git a/tsunami/app/root_test.go b/tsunami/app/root_test.go
deleted file mode 100644
index ef6717a854..0000000000
--- a/tsunami/app/root_test.go
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package app
-
-import (
-	"encoding/json"
-	"fmt"
-	"log"
-	"testing"
-
-	"github.com/wavetermdev/waveterm/tsunami/engine"
-	"github.com/wavetermdev/waveterm/tsunami/vdom"
-)
-
-func Page(props map[string]any) any {
-	clicked, setClicked, _ := UseState(false)
-	var clickedDiv *vdom.VDomElem
-	if clicked {
-		clickedDiv = vdom.H("div", nil, "clicked")
-	}
-	clickFn := func() {
-		log.Printf("run clickFn\n")
-		setClicked(true)
-	}
-	return vdom.H("div", nil,
-		vdom.H("h1", nil, "hello world"),
-		vdom.H("Button", map[string]any{"onClick": clickFn}, "hello"),
-		clickedDiv,
-	)
-}
-
-func Button(props map[string]any) any {
-	ref := UseVDomRef()
-	clName, setClName, _ := UseState("button")
-	UseEffect(func() func() {
-		fmt.Printf("Button useEffect\n")
-		setClName("button mounted")
-		return nil
-	}, nil)
-	compId := UseId()
-	// Store the button ID in a global variable for testing
-	buttonId = compId
-	return vdom.H("div", map[string]any{
-		"className": clName,
-		"ref":       ref,
-		"onClick":   props["onClick"],
-	}, props["children"])
-}
-
-func printVDom(root *engine.RootElem) {
-	vd := root.MakeRendered()
-	jsonBytes, _ := json.MarshalIndent(vd, "", "  ")
-	fmt.Printf("%s\n", string(jsonBytes))
-}
-
-var buttonId string
-
-func Test1(t *testing.T) {
-	log.Printf("hello!\n")
-	root := engine.MakeRoot(nil)
-	root.RegisterComponent("Page", Page)
-	root.RegisterComponent("Button", Button)
-	root.Render(vdom.H("Page", nil), &engine.RenderOpts{Resync: false})
-	if root.Root == nil {
-		t.Fatalf("root.Root is nil")
-	}
-	printVDom(root)
-	root.RunWork(&engine.RenderOpts{Resync: false})
-	printVDom(root)
-	root.Event(vdom.VDomEvent{WaveId: buttonId, EventType: "onClick"}, nil)
-	root.RunWork(&engine.RenderOpts{Resync: false})
-	printVDom(root)
-}
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index d8269705ee..10c769e057 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -65,58 +65,6 @@ func UseId(vc *RenderContextImpl) string {
 	return vc.GetCompWaveId()
 }
 
-func UseState(vc *RenderContextImpl, initialVal any) (any, func(any), func(func(any) any)) {
-	hookVal := vc.getOrderedHook()
-	if !hookVal.Init {
-		hookVal.Init = true
-		hookVal.Val = initialVal
-	}
-
-	setVal := func(newVal any) {
-		hookVal.Val = newVal
-		vc.Root.AddRenderWork(vc.GetCompWaveId())
-	}
-
-	setFuncVal := func(updateFunc func(any) any) {
-		hookVal.Val = updateFunc(hookVal.Val)
-		vc.Root.AddRenderWork(vc.GetCompWaveId())
-	}
-
-	return hookVal.Val, setVal, setFuncVal
-}
-
-func UseAtom(vc *RenderContextImpl, atomName string) (any, func(any), func(func(any) any)) {
-	hookVal := vc.getOrderedHook()
-	if !hookVal.Init {
-		hookVal.Init = true
-		closedWaveId := vc.GetCompWaveId()
-		hookVal.UnmountFn = func() {
-			vc.Root.AtomSetUsedBy(atomName, closedWaveId, false)
-		}
-	}
-	vc.Root.AtomSetUsedBy(atomName, vc.GetCompWaveId(), true)
-	atomVal := vc.Root.GetAtomVal(atomName)
-
-	setVal := func(newVal any) {
-		if err := vc.Root.SetAtomVal(atomName, newVal); err != nil {
-			log.Printf("Failed to set atom value for %s: %v", atomName, err)
-			return
-		}
-		vc.Root.AtomAddRenderWork(atomName)
-	}
-
-	setFuncVal := func(updateFunc func(any) any) {
-		currentVal := vc.Root.GetAtomVal(atomName)
-		if err := vc.Root.SetAtomVal(atomName, updateFunc(currentVal)); err != nil {
-			log.Printf("Failed to set atom value for %s: %v", atomName, err)
-			return
-		}
-		vc.Root.AtomAddRenderWork(atomName)
-	}
-
-	return atomVal, setVal, setFuncVal
-}
-
 func UseLocal(vc *RenderContextImpl, initialVal any) string {
 	hookVal := vc.getOrderedHook()
 	atomName := "$local." + vc.GetCompWaveId() + "#" + strconv.Itoa(hookVal.Idx)

From 9f200f3e0cb3ff264b301afa4fe8097bafefd1d8 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 16:36:14 -0700
Subject: [PATCH 123/134] synchronize renderwork.  call notifyfn when we get
 new render work from an async context...

---
 tsunami/engine/clientimpl.go |  8 ++++++
 tsunami/engine/globalctx.go  | 34 ++++++++++++++++++++++
 tsunami/engine/hooks.go      |  6 ++--
 tsunami/engine/rootelem.go   | 56 +++++++++++++++++++++++++++---------
 4 files changed, 88 insertions(+), 16 deletions(-)

diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index 852dd31fec..20e44b5a53 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -26,6 +26,10 @@ const TsunamiListenAddrEnvVar = "TSUNAMI_LISTENADDR"
 const DefaultListenAddr = "localhost:0"
 const DefaultComponentName = "App"
 
+const NotifyMaxCadence = 10 * time.Millisecond
+const NotifyDebounceTime = 500 * time.Microsecond
+const NotifyMaxDebounceTime = 2 * time.Millisecond
+
 type ssEvent struct {
 	Event string
 	Data  []byte
@@ -218,6 +222,10 @@ func (c *ClientImpl) SendAsyncInitiation() error {
 	}
 }
 
+func (c *ClientImpl) notifyAsyncRenderWork() {
+	// TODO
+}
+
 func makeNullRendered() *rpctypes.RenderedElem {
 	return &rpctypes.RenderedElem{WaveId: uuid.New().String(), Tag: vdom.WaveNullTag}
 }
diff --git a/tsunami/engine/globalctx.go b/tsunami/engine/globalctx.go
index 07508dbf88..0d03a93710 100644
--- a/tsunami/engine/globalctx.go
+++ b/tsunami/engine/globalctx.go
@@ -10,6 +10,13 @@ import (
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
+const (
+	GlobalContextType_async  = "async"
+	GlobalContextType_render = "render"
+	GlobalContextType_effect = "effect"
+	GlobalContextType_event  = "event"
+)
+
 // is set ONLY when we're in the render function of a component
 // used for hooks, and automatic dependency tracking
 var globalRenderContext *RenderContextImpl
@@ -123,3 +130,30 @@ func GetGlobalEffectContext() *EffectContextImpl {
 	}
 	return globalEffectContext
 }
+
+// inContextType returns the current global context type.
+// Returns one of:
+//   - GlobalContextType_render: when in a component render function
+//   - GlobalContextType_event: when in an event handler
+//   - GlobalContextType_effect: when in an effect function
+//   - GlobalContextType_async: when not in any specific context (default/async)
+func inContextType() string {
+	globalCtxMutex.Lock()
+	defer globalCtxMutex.Unlock()
+	
+	gid := goid.Get()
+	
+	if globalRenderContext != nil && gid == globalRenderGoId {
+		return GlobalContextType_render
+	}
+	
+	if globalEventContext != nil && gid == globalEventGoId {
+		return GlobalContextType_event
+	}
+	
+	if globalEffectContext != nil && gid == globalEffectGoId {
+		return GlobalContextType_effect
+	}
+	
+	return GlobalContextType_async
+}
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index 10c769e057..738dd3a8df 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -125,14 +125,14 @@ func UseEffect(vc *RenderContextImpl, fn func() func(), deps []any) {
 		hookVal.Init = true
 		hookVal.Fn = fn
 		hookVal.Deps = deps
-		vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
+		vc.Root.addEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
 		return
 	}
 	// If deps is nil, always run (like React with no dependency array)
 	if deps == nil {
 		hookVal.Fn = fn
 		hookVal.Deps = deps
-		vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
+		vc.Root.addEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
 		return
 	}
 
@@ -141,7 +141,7 @@ func UseEffect(vc *RenderContextImpl, fn func() func(), deps []any) {
 	}
 	hookVal.Fn = fn
 	hookVal.Deps = deps
-	vc.Root.AddEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
+	vc.Root.addEffectWork(vc.GetCompWaveId(), hookVal.Idx, compTag)
 }
 
 func UseResync(vc *RenderContextImpl) bool {
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index fd36afecdf..3811cb0e2d 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -36,24 +36,50 @@ type RootElem struct {
 	Root            *ComponentImpl
 	RenderTs        int64
 	AppTitle        string
-	CFuncs          map[string]any
+	CFuncs          map[string]any            // component name => render function
 	CompMap         map[string]*ComponentImpl // component waveid -> component
 	EffectWorkQueue []*EffectWorkElem
-	NeedsRenderMap  map[string]bool
-	Atoms           map[string]genAtom
+	needsRenderMap  map[string]bool // key: waveid
+	needsRenderLock sync.Mutex
+	Atoms           map[string]genAtom // key: atomName
 	atomLock        sync.Mutex
 	RefOperations   []vdom.VDomRefOperation
 	Client          *ClientImpl
 }
 
-func (r *RootElem) AddRenderWork(id string) {
-	if r.NeedsRenderMap == nil {
-		r.NeedsRenderMap = make(map[string]bool)
+func (r *RootElem) addRenderWork(id string) {
+	defer func() {
+		if inContextType() == GlobalContextType_async {
+			r.Client.notifyAsyncRenderWork()
+		}
+	}()
+	
+	r.needsRenderLock.Lock()
+	defer r.needsRenderLock.Unlock()
+
+	if r.needsRenderMap == nil {
+		r.needsRenderMap = make(map[string]bool)
 	}
-	r.NeedsRenderMap[id] = true
+	r.needsRenderMap[id] = true
 }
 
-func (r *RootElem) AddEffectWork(id string, effectIndex int, compTag string) {
+func (r *RootElem) getAndClearRenderWork() []string {
+	r.needsRenderLock.Lock()
+	defer r.needsRenderLock.Unlock()
+
+	if len(r.needsRenderMap) == 0 {
+		return nil
+	}
+
+	ids := make([]string, 0, len(r.needsRenderMap))
+	for id := range r.needsRenderMap {
+		ids = append(ids, id)
+	}
+	r.needsRenderMap = nil
+	return ids
+}
+
+func (r *RootElem) addEffectWork(id string, effectIndex int, compTag string) {
 	r.EffectWorkQueue = append(r.EffectWorkQueue, &EffectWorkElem{WaveId: id, EffectIndex: effectIndex, CompTag: compTag})
 }
 
@@ -135,8 +161,12 @@ func (r *RootElem) AtomAddRenderWork(atomName string) {
 	if !ok {
 		return
 	}
-	for _, compId := range atom.GetUsedBy() {
-		r.AddRenderWork(compId)
+	usedBy := atom.GetUsedBy()
+	if len(usedBy) == 0 {
+		return
+	}
+	for _, compId := range usedBy {
+		r.addRenderWork(compId)
 	}
 }
 
@@ -356,8 +386,8 @@ func (r *RootElem) RunWork(opts *RenderOpts) {
 		r.runEffect(work, hook)
 	}
 	// now check if we need a render
-	if len(r.NeedsRenderMap) > 0 {
-		r.NeedsRenderMap = nil
+	renderIds := r.getAndClearRenderWork()
+	if len(renderIds) > 0 {
 		r.render(r.Root.Elem, &r.Root, "root", opts)
 	}
 }
@@ -392,7 +422,7 @@ func (r *RootElem) UpdateRef(updateRef rpctypes.VDomRefUpdate) {
 	}
 	ref.HasCurrent = updateRef.HasCurrent
 	ref.Position = updateRef.Position
-	r.AddRenderWork(waveId)
+	r.addRenderWork(waveId)
 }
 
 func (r *RootElem) QueueRefOp(op vdom.VDomRefOperation) {

From 1bd88e8b99d561fac4c48b92b51fec2ec7fa8022 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 17:03:58 -0700
Subject: [PATCH 124/134] implement RenderWork based send async initiation

---
 tsunami/app/atom.go                 |  13 +--
 tsunami/demo/cpuchart/app.go        |   1 -
 tsunami/demo/cpuchart/static/tw.css |  48 --------
 tsunami/engine/asyncnotify.go       | 164 ++++++++++++++++++++++++++++
 tsunami/engine/atomimpl.go          |   8 --
 tsunami/engine/clientimpl.go        |  18 +--
 tsunami/engine/rootelem.go          |  14 +--
 7 files changed, 179 insertions(+), 87 deletions(-)
 create mode 100644 tsunami/engine/asyncnotify.go

diff --git a/tsunami/app/atom.go b/tsunami/app/atom.go
index 4817adc297..ca50cd2327 100644
--- a/tsunami/app/atom.go
+++ b/tsunami/app/atom.go
@@ -117,13 +117,8 @@ func (a Atom[T]) SetFn(fn func(T) T) {
 		logInvalidAtomSet(a.name)
 		return
 	}
-	err := a.client.Root.SetFnAtomVal(a.name, func(val any) any {
-		typedVal := util.GetTypedAtomValue[T](val, a.name)
-		return fn(typedVal)
-	})
-	if err != nil {
-		log.Printf("Failed to set atom value for %s: %v", a.name, err)
-		return
-	}
-	a.client.Root.AtomAddRenderWork(a.name)
+	currentVal := a.Get()
+	copiedVal := DeepCopy(currentVal)
+	newVal := fn(copiedVal)
+	a.Set(newVal)
 }
diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
index e4d1c09bfd..a3e24cbb42 100644
--- a/tsunami/demo/cpuchart/app.go
+++ b/tsunami/demo/cpuchart/app.go
@@ -172,7 +172,6 @@ var App = app.DefineComponent("App", func(_ struct{}) any {
 			}
 			return data
 		})
-		app.SendAsyncInitiation()
 	}, []any{})
 
 	handleClear := func() {
diff --git a/tsunami/demo/cpuchart/static/tw.css b/tsunami/demo/cpuchart/static/tw.css
index 9838118d47..ddea1ba46e 100644
--- a/tsunami/demo/cpuchart/static/tw.css
+++ b/tsunami/demo/cpuchart/static/tw.css
@@ -252,33 +252,12 @@
   .sticky {
     position: sticky;
   }
-  .-inset-1 {
-    inset: calc(var(--spacing) * -1);
-  }
   .isolate {
     isolation: isolate;
   }
   .isolation-auto {
     isolation: auto;
   }
-  .\!container {
-    width: 100% !important;
-    @media (width >= 40rem) {
-      max-width: 40rem !important;
-    }
-    @media (width >= 48rem) {
-      max-width: 48rem !important;
-    }
-    @media (width >= 64rem) {
-      max-width: 64rem !important;
-    }
-    @media (width >= 80rem) {
-      max-width: 80rem !important;
-    }
-    @media (width >= 96rem) {
-      max-width: 96rem !important;
-    }
-  }
   .container {
     width: 100%;
     @media (width >= 40rem) {
@@ -875,18 +854,10 @@
     --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .ring {
-    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
-    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
-  }
   .inset-ring {
     --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .outline {
-    outline-style: var(--tw-outline-style);
-    outline-width: 1px;
-  }
   .blur {
     --tw-blur: blur(8px);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
@@ -896,18 +867,10 @@
     --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .grayscale {
-    --tw-grayscale: grayscale(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .invert {
     --tw-invert: invert(100%);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .sepia {
-    --tw-sepia: sepia(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .filter {
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
@@ -935,11 +898,6 @@
     -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
     backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
   }
-  .transition {
-    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
-    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
-    transition-duration: var(--tw-duration, var(--default-transition-duration));
-  }
   .transition-colors {
     transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
     transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
@@ -1145,11 +1103,6 @@
   inherits: false;
   initial-value: 0 0 #0000;
 }
-@property --tw-outline-style {
-  syntax: "*";
-  inherits: false;
-  initial-value: solid;
-}
 @property --tw-blur {
   syntax: "*";
   inherits: false;
@@ -1283,7 +1236,6 @@
       --tw-ring-offset-width: 0px;
       --tw-ring-offset-color: #fff;
       --tw-ring-offset-shadow: 0 0 #0000;
-      --tw-outline-style: solid;
       --tw-blur: initial;
       --tw-brightness: initial;
       --tw-contrast: initial;
diff --git a/tsunami/engine/asyncnotify.go b/tsunami/engine/asyncnotify.go
new file mode 100644
index 0000000000..ffd56c186f
--- /dev/null
+++ b/tsunami/engine/asyncnotify.go
@@ -0,0 +1,164 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package engine
+
+import (
+	"log"
+	"time"
+)
+
+const NotifyMaxCadence = 10 * time.Millisecond
+const NotifyDebounceTime = 500 * time.Microsecond
+const NotifyMaxDebounceTime = 2 * time.Millisecond
+
+func (c *ClientImpl) notifyAsyncRenderWork() {
+	log.Printf("notify async work\n")
+	c.notifyOnce.Do(func() {
+		c.notifyWakeCh = make(chan struct{}, 1)
+		go c.asyncInitiationLoop()
+	})
+
+	nowNs := time.Now().UnixNano()
+	c.notifyLastEventNs.Store(nowNs)
+	// Establish batch start if there's no active batch.
+	if c.notifyBatchStartNs.Load() == 0 {
+		c.notifyBatchStartNs.CompareAndSwap(0, nowNs)
+	}
+	// Coalesced wake-up.
+	select {
+	case c.notifyWakeCh <- struct{}{}:
+	default:
+	}
+}
+
+func (c *ClientImpl) asyncInitiationLoop() {
+	var (
+		lastSent time.Time
+		timer    *time.Timer
+		timerC   <-chan time.Time
+	)
+
+	schedule := func() {
+		firstNs := c.notifyBatchStartNs.Load()
+		if firstNs == 0 {
+			// No pending batch; stop timer if running.
+			if timer != nil {
+				if !timer.Stop() {
+					select {
+					case <-timer.C:
+					default:
+					}
+				}
+			}
+			timerC = nil
+			return
+		}
+		lastNs := c.notifyLastEventNs.Load()
+
+		first := time.Unix(0, firstNs)
+		last := time.Unix(0, lastNs)
+		cadenceReady := lastSent.Add(NotifyMaxCadence)
+
+		// Reset the 2ms "max debounce" window at the cadence boundary:
+		// deadline = max(first, cadenceReady) + 2ms
+		anchor := first
+		if cadenceReady.After(anchor) {
+			anchor = cadenceReady
+		}
+		deadline := anchor.Add(NotifyMaxDebounceTime)
+
+		// candidate = min(last+500us, deadline)
+		candidate := last.Add(NotifyDebounceTime)
+		if deadline.Before(candidate) {
+			candidate = deadline
+		}
+
+		// final target = max(cadenceReady, candidate)
+		target := candidate
+		if cadenceReady.After(target) {
+			target = cadenceReady
+		}
+
+		d := time.Until(target)
+		if d < 0 {
+			d = 0
+		}
+		if timer == nil {
+			timer = time.NewTimer(d)
+		} else {
+			if !timer.Stop() {
+				select {
+				case <-timer.C:
+				default:
+				}
+			}
+			timer.Reset(d)
+		}
+		timerC = timer.C
+	}
+
+	for {
+		select {
+		case <-c.notifyWakeCh:
+			schedule()
+
+		case <-timerC:
+			now := time.Now()
+
+			// Recompute right before sending; if a late event arrived,
+			// push the fire time out to respect the debounce.
+			firstNs := c.notifyBatchStartNs.Load()
+			if firstNs == 0 {
+				// Nothing to do.
+				continue
+			}
+			lastNs := c.notifyLastEventNs.Load()
+
+			first := time.Unix(0, firstNs)
+			last := time.Unix(0, lastNs)
+			cadenceReady := lastSent.Add(NotifyMaxCadence)
+
+			anchor := first
+			if cadenceReady.After(anchor) {
+				anchor = cadenceReady
+			}
+			deadline := anchor.Add(NotifyMaxDebounceTime)
+
+			candidate := last.Add(NotifyDebounceTime)
+			if deadline.Before(candidate) {
+				candidate = deadline
+			}
+			target := candidate
+			if cadenceReady.After(target) {
+				target = cadenceReady
+			}
+
+			// If we're early (because a new event just came in), reschedule.
+			if now.Before(target) {
+				d := time.Until(target)
+				if d < 0 {
+					d = 0
+				}
+				if !timer.Stop() {
+					select {
+					case <-timer.C:
+					default:
+					}
+				}
+				timer.Reset(d)
+				continue
+			}
+
+			// Fire.
+			_ = c.SendAsyncInitiation()
+			lastSent = now
+
+			// Close current batch; a concurrent notify will CAS a new start.
+			c.notifyBatchStartNs.Store(0)
+
+			// If anything is already pending, this will arm the next timer.
+			schedule()
+		}
+	}
+}
diff --git a/tsunami/engine/atomimpl.go b/tsunami/engine/atomimpl.go
index 9851fe0ff6..3d9c5a4896 100644
--- a/tsunami/engine/atomimpl.go
+++ b/tsunami/engine/atomimpl.go
@@ -64,14 +64,6 @@ func (a *AtomImpl[T]) SetVal(val any) error {
 	return a.setVal_nolock(val)
 }
 
-func (a *AtomImpl[T]) SetFnVal(setFn func(any) any) error {
-	a.lock.Lock()
-	defer a.lock.Unlock()
-	
-	newVal := setFn(a.val)
-	return a.setVal_nolock(newVal)
-}
-
 func (a *AtomImpl[T]) SetUsedBy(waveId string, used bool) {
 	a.lock.Lock()
 	defer a.lock.Unlock()
diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index 20e44b5a53..73697c1754 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.go
@@ -13,6 +13,7 @@ import (
 	"os"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 	"unicode"
 
@@ -26,10 +27,6 @@ const TsunamiListenAddrEnvVar = "TSUNAMI_LISTENADDR"
 const DefaultListenAddr = "localhost:0"
 const DefaultComponentName = "App"
 
-const NotifyMaxCadence = 10 * time.Millisecond
-const NotifyDebounceTime = 500 * time.Microsecond
-const NotifyMaxDebounceTime = 2 * time.Millisecond
-
 type ssEvent struct {
 	Event string
 	Data  []byte
@@ -53,6 +50,14 @@ type ClientImpl struct {
 	AssetsFS           fs.FS
 	StaticFS           fs.FS
 	ManifestFileBytes  []byte
+
+	// for notification
+	// Atomics so we never drop "last event" timing info even if wakeCh is full.
+	// 0 means "no pending batch".
+	notifyOnce         sync.Once
+	notifyWakeCh       chan struct{}
+	notifyBatchStartNs atomic.Int64 // ns of first event in current batch
+	notifyLastEventNs  atomic.Int64 // ns of most recent event
 }
 
 func makeClient() *ClientImpl {
@@ -210,6 +215,7 @@ func (c *ClientImpl) listenAndServe(ctx context.Context) error {
 }
 
 func (c *ClientImpl) SendAsyncInitiation() error {
+	log.Printf("send async initiation\n")
 	if c.GetIsDone() {
 		return fmt.Errorf("client is done")
 	}
@@ -222,10 +228,6 @@ func (c *ClientImpl) SendAsyncInitiation() error {
 	}
 }
 
-func (c *ClientImpl) notifyAsyncRenderWork() {
-	// TODO
-}
-
 func makeNullRendered() *rpctypes.RenderedElem {
 	return &rpctypes.RenderedElem{WaveId: uuid.New().String(), Tag: vdom.WaveNullTag}
 }
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index 3811cb0e2d..bd38cf3657 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -27,7 +27,6 @@ type EffectWorkElem struct {
 type genAtom interface {
 	GetVal() any
 	SetVal(any) error
-	SetFnVal(func(any) any) error
 	SetUsedBy(string, bool)
 	GetUsedBy() []string
 }
@@ -53,7 +52,7 @@ func (r *RootElem) addRenderWork(id string) {
 			r.Client.notifyAsyncRenderWork()
 		}
 	}()
-	
+
 	r.needsRenderLock.Lock()
 	defer r.needsRenderLock.Unlock()
 
@@ -192,17 +191,6 @@ func (r *RootElem) SetAtomVal(name string, val any) error {
 	return atom.SetVal(val)
 }
 
-func (r *RootElem) SetFnAtomVal(name string, setFn func(any) any) error {
-	r.atomLock.Lock()
-	defer r.atomLock.Unlock()
-
-	atom, ok := r.Atoms[name]
-	if !ok {
-		return fmt.Errorf("atom %q not found", name)
-	}
-	return atom.SetFnVal(setFn)
-}
-
 func (r *RootElem) RemoveAtom(name string) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()

From 9db6f91c946f1253433513d9ed6b0d8cecc678c2 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 17:14:06 -0700
Subject: [PATCH 125/134] remove async notify (port pomodoro example to new
 code)

---
 tsunami/demo/githubaction/app.go    |   2 -
 tsunami/demo/pomodoro/app.go        | 155 ++++++++++------------------
 tsunami/demo/pomodoro/static/tw.css |  48 ---------
 tsunami/demo/recharts/app.go        |   1 -
 tsunami/demo/tsunamiconfig/app.go   |   2 -
 tsunami/engine/asyncnotify.go       |   2 -
 6 files changed, 56 insertions(+), 154 deletions(-)

diff --git a/tsunami/demo/githubaction/app.go b/tsunami/demo/githubaction/app.go
index a78cc3cf78..2a8ef1a7e2 100644
--- a/tsunami/demo/githubaction/app.go
+++ b/tsunami/demo/githubaction/app.go
@@ -249,14 +249,12 @@ var App = app.DefineComponent("App",
 		// Automatic polling with UseTicker - automatically cleaned up on unmount
 		app.UseTicker(time.Duration(pollIntervalAtom.Get())*time.Second, func() {
 			fetchData()
-			app.SendAsyncInitiation()
 		}, []any{pollIntervalAtom.Get()})
 
 		handleRefresh := func() {
 			isLoadingAtom.Set(true)
 			go func() {
 				fetchData()
-				app.SendAsyncInitiation()
 			}()
 		}
 
diff --git a/tsunami/demo/pomodoro/app.go b/tsunami/demo/pomodoro/app.go
index 2f0bfbf2ba..7cbc186c5c 100644
--- a/tsunami/demo/pomodoro/app.go
+++ b/tsunami/demo/pomodoro/app.go
@@ -32,13 +32,6 @@ type ControlButtonsProps struct {
 	OnMode    func(int) `json:"onMode"`
 }
 
-type TimerState struct {
-	ticker    *time.Ticker
-	done      chan bool
-	startTime time.Time
-	duration  time.Duration
-	isActive  bool // Track if the timer goroutine is running
-}
 
 var TimerDisplay = app.DefineComponent("TimerDisplay",
 	func(props TimerDisplayProps) any {
@@ -105,119 +98,83 @@ var ControlButtons = app.DefineComponent("ControlButtons",
 )
 
 var App = app.DefineComponent("App",
-	func(_ any) any {
+	func(_ struct{}) any {
 		app.UseSetAppTitle("Pomodoro Timer (Tsunami Demo)")
 
-		isRunning, setIsRunning, _ := app.UseState(false)
-		minutes, setMinutes, _ := app.UseState(WorkMode.Duration)
-		seconds, setSeconds, _ := app.UseState(0)
-		mode, setMode, _ := app.UseState(WorkMode.Name)
-		_, setIsComplete, _ := app.UseState(false)
-		timerRef := app.UseRef(&TimerState{
-			done: make(chan bool),
-		})
-
-		stopTimer := func() {
-			if timerRef.Current.ticker != nil {
-				timerRef.Current.ticker.Stop()
-				timerRef.Current.ticker = nil
+		isRunning := app.UseLocal(false)
+		minutes := app.UseLocal(WorkMode.Duration)
+		seconds := app.UseLocal(0)
+		mode := app.UseLocal(WorkMode.Name)
+		isComplete := app.UseLocal(false)
+		startTime := app.UseRef(time.Time{})
+		totalDuration := app.UseRef(time.Duration(0))
+
+		// Timer that updates every second using the new pattern
+		app.UseTicker(time.Second, func() {
+			if !isRunning.Get() {
+				return
 			}
-			if timerRef.Current.isActive {
-				close(timerRef.Current.done)
-				timerRef.Current.isActive = false
+
+			elapsed := time.Since(startTime.Current)
+			remaining := totalDuration.Current - elapsed
+
+			if remaining <= 0 {
+				// Timer completed
+				isRunning.Set(false)
+				minutes.Set(0)
+				seconds.Set(0)
+				isComplete.Set(true)
+				return
 			}
-			timerRef.Current.done = make(chan bool)
-		}
+
+			m := int(remaining.Minutes())
+			s := int(remaining.Seconds()) % 60
+
+			// Only send update if values actually changed
+			if m != minutes.Get() || s != seconds.Get() {
+				minutes.Set(m)
+				seconds.Set(s)
+			}
+		}, []any{isRunning.Get()})
 
 		startTimer := func() {
-			if timerRef.Current.isActive {
+			if isRunning.Get() {
 				return // Timer already running
 			}
 
-			// Stop any existing timer first
-			stopTimer()
-
-			setIsComplete(false)
-			timerRef.Current.startTime = time.Now()
-			timerRef.Current.duration = time.Duration(minutes) * time.Minute
-			timerRef.Current.isActive = true
-			setIsRunning(true)
-			timerRef.Current.ticker = time.NewTicker(1 * time.Second)
-
-			go func() {
-				for {
-					select {
-					case <-timerRef.Current.done:
-						return
-					case <-timerRef.Current.ticker.C:
-						elapsed := time.Since(timerRef.Current.startTime)
-						remaining := timerRef.Current.duration - elapsed
-
-						if remaining <= 0 {
-							// Timer completed
-							setIsRunning(false)
-							setMinutes(0)
-							setSeconds(0)
-							setIsComplete(true)
-							stopTimer()
-							app.SendAsyncInitiation()
-							return
-						}
-
-						m := int(remaining.Minutes())
-						s := int(remaining.Seconds()) % 60
-
-						// Only send update if values actually changed
-						if m != minutes || s != seconds {
-							setMinutes(m)
-							setSeconds(s)
-							app.SendAsyncInitiation()
-						}
-					}
-				}
-			}()
+			isComplete.Set(false)
+			startTime.Current = time.Now()
+			totalDuration.Current = time.Duration(minutes.Get()) * time.Minute
+			isRunning.Set(true)
 		}
 
 		pauseTimer := func() {
-			stopTimer()
-			setIsRunning(false)
-			app.SendAsyncInitiation()
+			isRunning.Set(false)
 		}
 
 		resetTimer := func() {
-			stopTimer()
-			setIsRunning(false)
-			setIsComplete(false)
-			if mode == WorkMode.Name {
-				setMinutes(WorkMode.Duration)
+			isRunning.Set(false)
+			isComplete.Set(false)
+			if mode.Get() == WorkMode.Name {
+				minutes.Set(WorkMode.Duration)
 			} else {
-				setMinutes(BreakMode.Duration)
+				minutes.Set(BreakMode.Duration)
 			}
-			setSeconds(0)
-			app.SendAsyncInitiation()
+			seconds.Set(0)
 		}
 
 		changeMode := func(duration int) {
-			stopTimer()
-			setIsRunning(false)
-			setIsComplete(false)
-			setMinutes(duration)
-			setSeconds(0)
+			isRunning.Set(false)
+			isComplete.Set(false)
+			minutes.Set(duration)
+			seconds.Set(0)
 			if duration == WorkMode.Duration {
-				setMode(WorkMode.Name)
+				mode.Set(WorkMode.Name)
 			} else {
-				setMode(BreakMode.Name)
+				mode.Set(BreakMode.Name)
 			}
-			app.SendAsyncInitiation()
 		}
 
-		// Cleanup on unmount
-		app.UseEffect(func() func() {
-			return func() {
-				stopTimer()
-			}
-		}, []any{})
-
 		return vdom.H("div",
 			map[string]any{"className": "max-w-sm mx-auto my-8 p-8 bg-slate-800 rounded-xl text-slate-100 font-sans"},
 			vdom.H("h1",
@@ -225,12 +182,12 @@ var App = app.DefineComponent("App",
 				"Pomodoro Timer",
 			),
 			TimerDisplay(TimerDisplayProps{
-				Minutes: minutes,
-				Seconds: seconds,
-				Mode:    mode,
+				Minutes: minutes.Get(),
+				Seconds: seconds.Get(),
+				Mode:    mode.Get(),
 			}),
 			ControlButtons(ControlButtonsProps{
-				IsRunning: isRunning,
+				IsRunning: isRunning.Get(),
 				OnStart:   startTimer,
 				OnPause:   pauseTimer,
 				OnReset:   resetTimer,
diff --git a/tsunami/demo/pomodoro/static/tw.css b/tsunami/demo/pomodoro/static/tw.css
index f4663b3c96..4108051a51 100644
--- a/tsunami/demo/pomodoro/static/tw.css
+++ b/tsunami/demo/pomodoro/static/tw.css
@@ -246,33 +246,12 @@
   .sticky {
     position: sticky;
   }
-  .-inset-1 {
-    inset: calc(var(--spacing) * -1);
-  }
   .isolate {
     isolation: isolate;
   }
   .isolation-auto {
     isolation: auto;
   }
-  .\!container {
-    width: 100% !important;
-    @media (width >= 40rem) {
-      max-width: 40rem !important;
-    }
-    @media (width >= 48rem) {
-      max-width: 48rem !important;
-    }
-    @media (width >= 64rem) {
-      max-width: 64rem !important;
-    }
-    @media (width >= 80rem) {
-      max-width: 80rem !important;
-    }
-    @media (width >= 96rem) {
-      max-width: 96rem !important;
-    }
-  }
   .container {
     width: 100%;
     @media (width >= 40rem) {
@@ -823,18 +802,10 @@
     --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .ring {
-    --tw-ring-shadow: var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color, currentcolor);
-    box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
-  }
   .inset-ring {
     --tw-inset-ring-shadow: inset 0 0 0 1px var(--tw-inset-ring-color, currentcolor);
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
   }
-  .outline {
-    outline-style: var(--tw-outline-style);
-    outline-width: 1px;
-  }
   .blur {
     --tw-blur: blur(8px);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
@@ -844,18 +815,10 @@
     --tw-drop-shadow: drop-shadow(0 1px 2px rgb(0 0 0 / 0.1)) drop-shadow( 0 1px 1px rgb(0 0 0 / 0.06));
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .grayscale {
-    --tw-grayscale: grayscale(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .invert {
     --tw-invert: invert(100%);
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
-  .sepia {
-    --tw-sepia: sepia(100%);
-    filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
-  }
   .filter {
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
@@ -883,11 +846,6 @@
     -webkit-backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
     backdrop-filter: var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);
   }
-  .transition {
-    transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter, display, content-visibility, overlay, pointer-events;
-    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
-    transition-duration: var(--tw-duration, var(--default-transition-duration));
-  }
   .transition-colors {
     transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to;
     transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
@@ -1104,11 +1062,6 @@
   inherits: false;
   initial-value: 0 0 #0000;
 }
-@property --tw-outline-style {
-  syntax: "*";
-  inherits: false;
-  initial-value: solid;
-}
 @property --tw-blur {
   syntax: "*";
   inherits: false;
@@ -1246,7 +1199,6 @@
       --tw-ring-offset-width: 0px;
       --tw-ring-offset-color: #fff;
       --tw-ring-offset-shadow: 0 0 #0000;
-      --tw-outline-style: solid;
       --tw-blur: initial;
       --tw-brightness: initial;
       --tw-contrast: initial;
diff --git a/tsunami/demo/recharts/app.go b/tsunami/demo/recharts/app.go
index 77b6c36c22..b558292d1a 100644
--- a/tsunami/demo/recharts/app.go
+++ b/tsunami/demo/recharts/app.go
@@ -215,7 +215,6 @@ var App = app.DefineComponent("App",
 				}
 				return newData
 			})
-			app.SendAsyncInitiation()
 		}
 		app.UseTicker(time.Second, tickerFn, []any{})
 
diff --git a/tsunami/demo/tsunamiconfig/app.go b/tsunami/demo/tsunamiconfig/app.go
index 87687af1ce..77730763ac 100644
--- a/tsunami/demo/tsunamiconfig/app.go
+++ b/tsunami/demo/tsunamiconfig/app.go
@@ -285,7 +285,6 @@ var App = app.DefineComponent("App",
 			go func() {
 				defer func() {
 					isLoading.Set(false)
-					app.SendAsyncInitiation()
 				}()
 
 				content, err := fetchConfig(baseURL)
@@ -312,7 +311,6 @@ var App = app.DefineComponent("App",
 			go func() {
 				defer func() {
 					isLoading.Set(false)
-					app.SendAsyncInitiation()
 				}()
 
 				err := postConfig(currentBaseURL.Get(), jsonContent.Get())
diff --git a/tsunami/engine/asyncnotify.go b/tsunami/engine/asyncnotify.go
index ffd56c186f..c9ebbb2b18 100644
--- a/tsunami/engine/asyncnotify.go
+++ b/tsunami/engine/asyncnotify.go
@@ -4,7 +4,6 @@
 package engine
 
 import (
-	"log"
 	"time"
 )
 
@@ -13,7 +12,6 @@ const NotifyDebounceTime = 500 * time.Microsecond
 const NotifyMaxDebounceTime = 2 * time.Millisecond
 
 func (c *ClientImpl) notifyAsyncRenderWork() {
-	log.Printf("notify async work\n")
 	c.notifyOnce.Do(func() {
 		c.notifyWakeCh = make(chan struct{}, 1)
 		go c.asyncInitiationLoop()

From 094dbbed1c0d41b914f4e48fb41c4c2fabd61ec9 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 17:15:12 -0700
Subject: [PATCH 126/134] remove sendasyncinitiation from docs

---
 tsunami/prompts/system.md | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/tsunami/prompts/system.md b/tsunami/prompts/system.md
index 37e00fdb78..e07212ea77 100644
--- a/tsunami/prompts/system.md
+++ b/tsunami/prompts/system.md
@@ -920,7 +920,6 @@ var App = app.DefineComponent("App", func(_ struct{}) any {
 - **Effects**: Always include proper dependency arrays to avoid infinite loops
 - **Cleanup**: Return cleanup functions from effects for timers, subscriptions, goroutines
 - **Refs**: Use app.UseRef for goroutine communication, app.UseVDomRef for DOM access
-- **Async Updates**: Call app.SendAsyncInitiation after updating atoms from goroutines
 - **Performance**: Don't overuse effects - most logic should be in event handlers
 
 ## Async Operations and Goroutines
@@ -942,7 +941,6 @@ var ClockComponent = app.DefineComponent("ClockComponent", func(_ struct{}) any
     // Update every second - automatically cleaned up on unmount
     app.UseTicker(time.Second, func() {
         currentTime.Set(time.Now().Format("15:04:05"))
-        app.SendAsyncInitiation()
     }, []any{})
 
     return vdom.H("div", map[string]any{
@@ -967,7 +965,6 @@ var ToastComponent = app.DefineComponent("ToastComponent", func(props ToastCompo
     // Auto-hide after specified duration - cancelled if component unmounts
     app.UseAfter(props.Duration, func() {
         visible.Set(false)
-        app.SendAsyncInitiation()
     }, []any{props.Duration})
 
     if !visible.Get() {
@@ -1003,7 +1000,6 @@ var DataPollerComponent = app.DefineComponent("DataPollerComponent", func(_ stru
                 return
             case <-time.After(30 * time.Second):
                 status.Set("fetching")
-                app.SendAsyncInitiation()
 
                 // Complex async operation: fetch, process, validate
                 newData, err := fetchAndProcessData()
@@ -1016,7 +1012,6 @@ var DataPollerComponent = app.DefineComponent("DataPollerComponent", func(_ stru
                     })
                     status.Set("success")
                 }
-                app.SendAsyncInitiation()
             }
         }
     }
@@ -1055,8 +1050,6 @@ pollData := func(ctx context.Context) {
 }
 ```
 
-**app.SendAsyncInitiation()**: Call this after updating atoms from goroutines to trigger UI re-renders. Don't call at high frequency - consider batching updates.
-
 **Functional setters**: Always use atom.SetFn() when updating state from goroutines to avoid race conditions:
 
 ```go
@@ -1364,4 +1357,3 @@ Key points:
 - Use app.UseAfter instead of time.AfterFunc for delayed operations
 - Always respect ctx.Done() in app.UseGoRoutine functions to prevent goroutine leaks
 - All timer and goroutine cleanup is handled automatically on component unmount or dependency changes
-- Call app.SendAsyncInitiation after state updates to trigger re-rendering

From f0305f6b2ca8aa28fc4209ad7b803a16b32d2e80 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 18:16:08 -0700
Subject: [PATCH 127/134] update usedby, double map, track atoms across render

---
 tsunami/app/atom.go          |  3 +--
 tsunami/demo/cpuchart/app.go |  2 +-
 tsunami/engine/comp.go       |  3 +++
 tsunami/engine/hooks.go      |  9 ++++++-
 tsunami/engine/render.go     |  6 ++++-
 tsunami/engine/rootelem.go   | 49 ++++++++++++++++++++++++++++--------
 6 files changed, 57 insertions(+), 15 deletions(-)

diff --git a/tsunami/app/atom.go b/tsunami/app/atom.go
index ca50cd2327..2800f7f65f 100644
--- a/tsunami/app/atom.go
+++ b/tsunami/app/atom.go
@@ -75,8 +75,7 @@ func (a Atom[T]) AtomName() string {
 func (a Atom[T]) Get() T {
 	vc := engine.GetGlobalRenderContext()
 	if vc != nil {
-		compWaveId := vc.GetCompWaveId()
-		vc.Root.AtomSetUsedBy(a.name, compWaveId, true)
+		vc.UsedAtoms[a.name] = true
 	}
 	val := a.client.Root.GetAtomVal(a.name)
 	typedVal := util.GetTypedAtomValue[T](val, a.name)
diff --git a/tsunami/demo/cpuchart/app.go b/tsunami/demo/cpuchart/app.go
index a3e24cbb42..3d6802e3ef 100644
--- a/tsunami/demo/cpuchart/app.go
+++ b/tsunami/demo/cpuchart/app.go
@@ -147,8 +147,8 @@ var App = app.DefineComponent("App", func(_ struct{}) any {
 	// Use UseTicker for continuous CPU data collection - automatically cleaned up on unmount
 	app.UseTicker(time.Second, func() {
 		// Collect new CPU data point and shift the data window
+		newPoint := generateCPUDataPoint()
 		cpuDataAtom.SetFn(func(data []CPUDataPoint) []CPUDataPoint {
-			newPoint := generateCPUDataPoint()
 			currentDataPointCount := dataPointCountAtom.Get()
 
 			// Ensure we have the right size array
diff --git a/tsunami/engine/comp.go b/tsunami/engine/comp.go
index c16135ff7d..2bbea1a74a 100644
--- a/tsunami/engine/comp.go
+++ b/tsunami/engine/comp.go
@@ -29,6 +29,9 @@ type ComponentImpl struct {
 	// Hooks system (React-like)
 	Hooks []*Hook // Array of hooks (state, effects, etc.) attached to this component
 
+	// Atom dependency tracking
+	UsedAtoms map[string]bool // atomName -> true, tracks which atoms this component uses
+
 	// Component content - exactly ONE of these patterns is used:
 
 	// Pattern 1: Text nodes
diff --git a/tsunami/engine/hooks.go b/tsunami/engine/hooks.go
index 738dd3a8df..d4db65d8cc 100644
--- a/tsunami/engine/hooks.go
+++ b/tsunami/engine/hooks.go
@@ -25,10 +25,17 @@ type RenderContextImpl struct {
 	Comp       *ComponentImpl
 	HookIdx    int
 	RenderOpts *RenderOpts
+	UsedAtoms  map[string]bool // Track atoms used during this render
 }
 
 func makeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *RenderContextImpl {
-	return &RenderContextImpl{Root: root, Comp: comp, HookIdx: 0, RenderOpts: opts}
+	return &RenderContextImpl{
+		Root:       root,
+		Comp:       comp,
+		HookIdx:    0,
+		RenderOpts: opts,
+		UsedAtoms:  make(map[string]bool),
+	}
 }
 
 func (vc *RenderContextImpl) GetCompWaveId() string {
diff --git a/tsunami/engine/render.go b/tsunami/engine/render.go
index c24021e665..5da8dc6262 100644
--- a/tsunami/engine/render.go
+++ b/tsunami/engine/render.go
@@ -102,6 +102,10 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 		renderedElem := callCFuncWithErrorGuard(cfunc, props, elem.Tag)
 		return vdom.ToElems(renderedElem)
 	})
+	
+	// Process atom usage after render
+	r.updateComponentAtomUsage(*comp, vc.UsedAtoms)
+	
 	var rtnElem *vdom.VDomElem
 	if len(rtnElemArr) == 0 {
 		rtnElem = nil
@@ -132,7 +136,7 @@ func (r *RootElem) unmount(comp **ComponentImpl) {
 		}
 	}
 	delete(r.CompMap, waveId)
-	r.cleanupUsedByForUnmount(waveId)
+	r.cleanupUsedByForUnmount(*comp)
 	*comp = nil
 }
 
diff --git a/tsunami/engine/rootelem.go b/tsunami/engine/rootelem.go
index bd38cf3657..15ed18442f 100644
--- a/tsunami/engine/rootelem.go
+++ b/tsunami/engine/rootelem.go
@@ -130,26 +130,55 @@ func (r *RootElem) RegisterAtom(name string, atom genAtom) {
 	r.Atoms[name] = atom
 }
 
-// we can do better here with an inverted map, but
-// this will work fine for now to clean up dependencies from atom.Get()
-func (r *RootElem) cleanupUsedByForUnmount(waveId string) {
+// cleanupUsedByForUnmount uses the reverse mapping for efficient cleanup
+func (r *RootElem) cleanupUsedByForUnmount(comp *ComponentImpl) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
 
-	for _, atom := range r.Atoms {
-		atom.SetUsedBy(waveId, false)
+	// Use reverse mapping for efficient cleanup
+	for atomName := range comp.UsedAtoms {
+		if atom, ok := r.Atoms[atomName]; ok {
+			atom.SetUsedBy(comp.WaveId, false)
+		}
 	}
+	
+	// Clear the component's atom tracking
+	comp.UsedAtoms = nil
 }
 
-func (r *RootElem) AtomSetUsedBy(atomName string, waveId string, used bool) {
+func (r *RootElem) updateComponentAtomUsage(comp *ComponentImpl, newUsedAtoms map[string]bool) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
 
-	atom, ok := r.Atoms[atomName]
-	if !ok {
-		return
+	oldUsedAtoms := comp.UsedAtoms
+
+	// Remove component from atoms it no longer uses
+	for atomName := range oldUsedAtoms {
+		if !newUsedAtoms[atomName] {
+			if atom, ok := r.Atoms[atomName]; ok {
+				atom.SetUsedBy(comp.WaveId, false)
+			}
+		}
+	}
+
+	// Add component to atoms it now uses
+	for atomName := range newUsedAtoms {
+		if !oldUsedAtoms[atomName] {
+			if atom, ok := r.Atoms[atomName]; ok {
+				atom.SetUsedBy(comp.WaveId, true)
+			}
+		}
+	}
+
+	// Update component's atom usage map
+	if len(newUsedAtoms) == 0 {
+		comp.UsedAtoms = nil
+	} else {
+		comp.UsedAtoms = make(map[string]bool)
+		for atomName := range newUsedAtoms {
+			comp.UsedAtoms[atomName] = true
+		}
 	}
-	atom.SetUsedBy(waveId, used)
 }
 
 func (r *RootElem) AtomAddRenderWork(atomName string) {

From 14f2c9999f36b5c866c246aee28c08152d6768e8 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Wed, 10 Sep 2025 21:58:21 -0700
Subject: [PATCH 128/134] fix double timestamps

---
 tsunami/build/build.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 79dae82201..44572cae8c 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -709,7 +709,7 @@ func monitorAndOpenBrowser(stdout io.ReadCloser, verbose bool) {
 	for scanner.Scan() {
 		line := scanner.Text()
 		if verbose {
-			log.Println(line)
+			fmt.Println(line)
 		}
 
 		if !browserOpened && len(urlRegex.FindStringSubmatch(line)) > 1 {
@@ -726,7 +726,7 @@ func monitorAndOpenBrowser(stdout io.ReadCloser, verbose bool) {
 	// Continue reading and printing output if verbose
 	if verbose {
 		for scanner.Scan() {
-			log.Println(scanner.Text())
+			fmt.Println(scanner.Text())
 		}
 	}
 }

From 388f338b29ac3539c3fd90c0e3a8e263e1c06b39 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 11 Sep 2025 10:55:41 -0700
Subject: [PATCH 129/134] better go detection

---
 tsunami/build/build.go              | 44 +++++++++++++++++++++++++++--
 tsunami/demo/cpuchart/static/tw.css | 12 ++++++++
 2 files changed, 53 insertions(+), 3 deletions(-)

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 44572cae8c..37db21fb02 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -12,6 +12,7 @@ import (
 	"os/signal"
 	"path/filepath"
 	"regexp"
+	"runtime"
 	"strconv"
 	"strings"
 	"sync"
@@ -41,11 +42,48 @@ type BuildEnv struct {
 	cleanupOnce *sync.Once
 }
 
+func findGoExecutable() (string, error) {
+	// First try the standard PATH lookup
+	if goPath, err := exec.LookPath("go"); err == nil {
+		return goPath, nil
+	}
+
+	// Define platform-specific paths to check
+	var pathsToCheck []string
+	
+	if runtime.GOOS == "windows" {
+		pathsToCheck = []string{
+			`c:\go\bin\go.exe`,
+			`c:\program files\go\bin\go.exe`,
+		}
+	} else {
+		// Unix-like systems (macOS, Linux, etc.)
+		pathsToCheck = []string{
+			"/opt/homebrew/bin/go",     // Homebrew on Apple Silicon
+			"/usr/local/bin/go",        // Traditional Homebrew or manual install
+			"/usr/local/go/bin/go",     // Official Go installation
+			"/usr/bin/go",              // System package manager
+		}
+	}
+
+	// Check each path
+	for _, path := range pathsToCheck {
+		if _, err := os.Stat(path); err == nil {
+			// File exists, check if it's executable
+			if info, err := os.Stat(path); err == nil && !info.IsDir() {
+				return path, nil
+			}
+		}
+	}
+
+	return "", fmt.Errorf("go command not found in PATH or common installation locations")
+}
+
 func verifyEnvironment(verbose bool) (*BuildEnv, error) {
-	// Check if go is in PATH
-	goPath, err := exec.LookPath("go")
+	// Find Go executable using enhanced search
+	goPath, err := findGoExecutable()
 	if err != nil {
-		return nil, fmt.Errorf("go command not found in PATH: %w", err)
+		return nil, fmt.Errorf("go command not found: %w", err)
 	}
 
 	// Run go version command
diff --git a/tsunami/demo/cpuchart/static/tw.css b/tsunami/demo/cpuchart/static/tw.css
index ddea1ba46e..e7b155870f 100644
--- a/tsunami/demo/cpuchart/static/tw.css
+++ b/tsunami/demo/cpuchart/static/tw.css
@@ -5,7 +5,10 @@
   :root, :host {
     --font-sans: "Inter", sans-serif;
     --font-mono: "Hack", monospace;
+    --color-red-100: oklch(93.6% 0.032 17.717);
     --color-red-400: oklch(70.4% 0.191 22.216);
+    --color-red-500: oklch(63.7% 0.237 25.331);
+    --color-red-800: oklch(44.4% 0.177 26.899);
     --color-green-400: oklch(79.2% 0.209 151.711);
     --color-green-500: oklch(72.3% 0.219 149.579);
     --color-blue-100: oklch(93.2% 0.032 255.585);
@@ -629,6 +632,9 @@
   .border-border {
     border-color: var(--color-border);
   }
+  .border-red-500 {
+    border-color: var(--color-red-500);
+  }
   .bg-background {
     background-color: var(--color-background);
   }
@@ -653,6 +659,9 @@
   .bg-panel {
     background-color: var(--color-panel);
   }
+  .bg-red-100 {
+    background-color: var(--color-red-100);
+  }
   .bg-repeat {
     background-repeat: repeat;
   }
@@ -771,6 +780,9 @@
   .text-red-400 {
     color: var(--color-red-400);
   }
+  .text-red-800 {
+    color: var(--color-red-800);
+  }
   .text-secondary {
     color: var(--color-secondary);
   }

From fc03346bc2bc1632c100e509c600c40a027ee0dd Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 11 Sep 2025 13:05:58 -0700
Subject: [PATCH 130/134] updated css

---
 tsunami/demo/githubaction/static/tw.css  | 10 ++++++++++
 tsunami/demo/tabletest/static/tw.css     | 12 ++++++++++++
 tsunami/demo/tsunamiconfig/static/tw.css | 11 +++++++++++
 3 files changed, 33 insertions(+)

diff --git a/tsunami/demo/githubaction/static/tw.css b/tsunami/demo/githubaction/static/tw.css
index 9cee1e8fbe..2e3d9c16ac 100644
--- a/tsunami/demo/githubaction/static/tw.css
+++ b/tsunami/demo/githubaction/static/tw.css
@@ -10,6 +10,7 @@
     --color-red-400: oklch(70.4% 0.191 22.216);
     --color-red-500: oklch(63.7% 0.237 25.331);
     --color-red-700: oklch(50.5% 0.213 27.518);
+    --color-red-800: oklch(44.4% 0.177 26.899);
     --color-red-900: oklch(39.6% 0.141 25.723);
     --color-yellow-400: oklch(85.2% 0.199 91.936);
     --color-green-400: oklch(79.2% 0.209 151.711);
@@ -653,6 +654,9 @@
   .border-gray-700 {
     border-color: var(--color-gray-700);
   }
+  .border-red-500 {
+    border-color: var(--color-red-500);
+  }
   .border-red-700 {
     border-color: var(--color-red-700);
   }
@@ -680,6 +684,9 @@
   .bg-panel {
     background-color: var(--color-panel);
   }
+  .bg-red-100 {
+    background-color: var(--color-red-100);
+  }
   .bg-red-500 {
     background-color: var(--color-red-500);
   }
@@ -813,6 +820,9 @@
   .text-red-400 {
     color: var(--color-red-400);
   }
+  .text-red-800 {
+    color: var(--color-red-800);
+  }
   .text-secondary {
     color: var(--color-secondary);
   }
diff --git a/tsunami/demo/tabletest/static/tw.css b/tsunami/demo/tabletest/static/tw.css
index 37ff5e8bb1..96e58c618c 100644
--- a/tsunami/demo/tabletest/static/tw.css
+++ b/tsunami/demo/tabletest/static/tw.css
@@ -5,6 +5,9 @@
   :root, :host {
     --font-sans: "Inter", sans-serif;
     --font-mono: "Hack", monospace;
+    --color-red-100: oklch(93.6% 0.032 17.717);
+    --color-red-500: oklch(63.7% 0.237 25.331);
+    --color-red-800: oklch(44.4% 0.177 26.899);
     --color-blue-400: oklch(70.7% 0.165 254.624);
     --color-blue-500: oklch(62.3% 0.214 259.815);
     --color-blue-600: oklch(54.6% 0.245 262.881);
@@ -601,6 +604,9 @@
   .border-gray-600 {
     border-color: var(--color-gray-600);
   }
+  .border-red-500 {
+    border-color: var(--color-red-500);
+  }
   .bg-background {
     background-color: var(--color-background);
   }
@@ -625,6 +631,9 @@
   .bg-panel {
     background-color: var(--color-panel);
   }
+  .bg-red-100 {
+    background-color: var(--color-red-100);
+  }
   .bg-repeat {
     background-repeat: repeat;
   }
@@ -751,6 +760,9 @@
   .text-primary {
     color: var(--color-primary);
   }
+  .text-red-800 {
+    color: var(--color-red-800);
+  }
   .text-secondary {
     color: var(--color-secondary);
   }
diff --git a/tsunami/demo/tsunamiconfig/static/tw.css b/tsunami/demo/tsunamiconfig/static/tw.css
index bb214da782..e06a738e3a 100644
--- a/tsunami/demo/tsunamiconfig/static/tw.css
+++ b/tsunami/demo/tsunamiconfig/static/tw.css
@@ -6,7 +6,9 @@
     --font-sans: "Inter", sans-serif;
     --font-mono: "Hack", monospace;
     --color-red-100: oklch(93.6% 0.032 17.717);
+    --color-red-500: oklch(63.7% 0.237 25.331);
     --color-red-700: oklch(50.5% 0.213 27.518);
+    --color-red-800: oklch(44.4% 0.177 26.899);
     --color-red-900: oklch(39.6% 0.141 25.723);
     --color-green-100: oklch(96.2% 0.044 156.743);
     --color-green-600: oklch(62.7% 0.194 149.214);
@@ -603,6 +605,9 @@
   .border-green-700 {
     border-color: var(--color-green-700);
   }
+  .border-red-500 {
+    border-color: var(--color-red-500);
+  }
   .border-red-700 {
     border-color: var(--color-red-700);
   }
@@ -624,6 +629,9 @@
   .bg-panel {
     background-color: var(--color-panel);
   }
+  .bg-red-100 {
+    background-color: var(--color-red-100);
+  }
   .bg-red-900 {
     background-color: var(--color-red-900);
   }
@@ -744,6 +752,9 @@
   .text-red-100 {
     color: var(--color-red-100);
   }
+  .text-red-800 {
+    color: var(--color-red-800);
+  }
   .text-secondary {
     color: var(--color-secondary);
   }

From d54fd164c5d9e187ebfd740e163cb806a90352d8 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 11 Sep 2025 13:12:19 -0700
Subject: [PATCH 131/134] move go.sum back to orig dir.  also make sure to copy
 go.sum to temp if it exists

---
 tsunami/build/build.go | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 37db21fb02..c786a49c36 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -186,6 +186,18 @@ func createGoMod(tempDir, appDirName, goVersion string, opts BuildOpts, verbose
 			return fmt.Errorf("failed to copy existing go.mod: %w", err)
 		}
 
+		// Also copy go.sum if it exists
+		originalGoSumPath := filepath.Join(opts.Dir, "go.sum")
+		if _, err := os.Stat(originalGoSumPath); err == nil {
+			tempGoSumPath := filepath.Join(tempDir, "go.sum")
+			if err := copyFile(originalGoSumPath, tempGoSumPath); err != nil {
+				return fmt.Errorf("failed to copy existing go.sum: %w", err)
+			}
+			if verbose {
+				log.Printf("Found and copied existing go.sum from %s", originalGoSumPath)
+			}
+		}
+
 		// Parse the existing go.mod
 		goModContent, err := os.ReadFile(tempGoModPath)
 		if err != nil {
@@ -545,14 +557,16 @@ func moveFilesBack(tempDir, originalDir string, verbose bool) error {
 		log.Printf("Moved go.mod back to %s", goModDest)
 	}
 
-	// Move go.sum back to original directory
+	// Move go.sum back to original directory (only if it exists)
 	goSumSrc := filepath.Join(tempDir, "go.sum")
-	goSumDest := filepath.Join(originalDir, "go.sum")
-	if err := copyFile(goSumSrc, goSumDest); err != nil {
-		return fmt.Errorf("failed to copy go.sum back: %w", err)
-	}
-	if verbose {
-		log.Printf("Moved go.sum back to %s", goSumDest)
+	if _, err := os.Stat(goSumSrc); err == nil {
+		goSumDest := filepath.Join(originalDir, "go.sum")
+		if err := copyFile(goSumSrc, goSumDest); err != nil {
+			return fmt.Errorf("failed to copy go.sum back: %w", err)
+		}
+		if verbose {
+			log.Printf("Moved go.sum back to %s", goSumDest)
+		}
 	}
 
 	// Ensure static directory exists in original directory

From fb071a20c0f26847e692389c429f09c5b80403f6 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 11 Sep 2025 13:16:30 -0700
Subject: [PATCH 132/134] always show stderr/stdout output from program

---
 tsunami/build/build.go | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index c786a49c36..7ac516760e 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -748,10 +748,10 @@ func TsunamiRun(opts BuildOpts) error {
 	return nil
 }
 
-func monitorAndOpenBrowser(stdout io.ReadCloser, verbose bool) {
-	defer stdout.Close()
+func monitorAndOpenBrowser(r io.ReadCloser, verbose bool) {
+	defer r.Close()
 
-	scanner := bufio.NewScanner(stdout)
+	scanner := bufio.NewScanner(r)
 	urlRegex := regexp.MustCompile(`\[tsunami\] listening at (http://[^\s]+)`)
 	browserOpened := false
 	if verbose {
@@ -760,9 +760,7 @@ func monitorAndOpenBrowser(stdout io.ReadCloser, verbose bool) {
 
 	for scanner.Scan() {
 		line := scanner.Text()
-		if verbose {
-			fmt.Println(line)
-		}
+		fmt.Println(line)
 
 		if !browserOpened && len(urlRegex.FindStringSubmatch(line)) > 1 {
 			matches := urlRegex.FindStringSubmatch(line)
@@ -774,11 +772,4 @@ func monitorAndOpenBrowser(stdout io.ReadCloser, verbose bool) {
 			browserOpened = true
 		}
 	}
-
-	// Continue reading and printing output if verbose
-	if verbose {
-		for scanner.Scan() {
-			fmt.Println(scanner.Text())
-		}
-	}
 }

From 656eea279b54efd2a60ec74e8b0b1883d8088293 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 11 Sep 2025 14:03:42 -0700
Subject: [PATCH 133/134] expose remainingseconds as a data atom

---
 tsunami/demo/pomodoro/app.go | 52 ++++++++++++++++++++----------------
 1 file changed, 29 insertions(+), 23 deletions(-)

diff --git a/tsunami/demo/pomodoro/app.go b/tsunami/demo/pomodoro/app.go
index 7cbc186c5c..eda19c0835 100644
--- a/tsunami/demo/pomodoro/app.go
+++ b/tsunami/demo/pomodoro/app.go
@@ -16,12 +16,14 @@ type Mode struct {
 var (
 	WorkMode  = Mode{Name: "Work", Duration: 25}
 	BreakMode = Mode{Name: "Break", Duration: 5}
+
+	// Data atom to expose remaining seconds to external systems
+	remainingSecondsAtom = app.DataAtom("remainingSeconds", WorkMode.Duration*60)
 )
 
 type TimerDisplayProps struct {
-	Minutes int    `json:"minutes"`
-	Seconds int    `json:"seconds"`
-	Mode    string `json:"mode"`
+	RemainingSeconds int    `json:"remainingSeconds"`
+	Mode             string `json:"mode"`
 }
 
 type ControlButtonsProps struct {
@@ -35,6 +37,8 @@ type ControlButtonsProps struct {
 
 var TimerDisplay = app.DefineComponent("TimerDisplay",
 	func(props TimerDisplayProps) any {
+		minutes := props.RemainingSeconds / 60
+		seconds := props.RemainingSeconds % 60
 		return vdom.H("div",
 			map[string]any{"className": "bg-slate-700 p-8 rounded-lg mb-8 text-center"},
 			vdom.H("div",
@@ -43,7 +47,7 @@ var TimerDisplay = app.DefineComponent("TimerDisplay",
 			),
 			vdom.H("div",
 				map[string]any{"className": "text-6xl font-bold font-mono text-slate-100"},
-				fmt.Sprintf("%02d:%02d", props.Minutes, props.Seconds),
+				fmt.Sprintf("%02d:%02d", minutes, seconds),
 			),
 		)
 	},
@@ -102,8 +106,6 @@ var App = app.DefineComponent("App",
 		app.UseSetAppTitle("Pomodoro Timer (Tsunami Demo)")
 
 		isRunning := app.UseLocal(false)
-		minutes := app.UseLocal(WorkMode.Duration)
-		seconds := app.UseLocal(0)
 		mode := app.UseLocal(WorkMode.Name)
 		isComplete := app.UseLocal(false)
 		startTime := app.UseRef(time.Time{})
@@ -121,19 +123,16 @@ var App = app.DefineComponent("App",
 			if remaining <= 0 {
 				// Timer completed
 				isRunning.Set(false)
-				minutes.Set(0)
-				seconds.Set(0)
+				remainingSecondsAtom.Set(0)
 				isComplete.Set(true)
 				return
 			}
 
-			m := int(remaining.Minutes())
-			s := int(remaining.Seconds()) % 60
+			newSeconds := int(remaining.Seconds())
 
-			// Only send update if values actually changed
-			if m != minutes.Get() || s != seconds.Get() {
-				minutes.Set(m)
-				seconds.Set(s)
+			// Only send update if value actually changed
+			if newSeconds != remainingSecondsAtom.Get() {
+				remainingSecondsAtom.Set(newSeconds)
 			}
 		}, []any{isRunning.Get()})
 
@@ -144,11 +143,21 @@ var App = app.DefineComponent("App",
 
 			isComplete.Set(false)
 			startTime.Current = time.Now()
-			totalDuration.Current = time.Duration(minutes.Get()) * time.Minute
+			totalDuration.Current = time.Duration(remainingSecondsAtom.Get()) * time.Second
 			isRunning.Set(true)
 		}
 
 		pauseTimer := func() {
+			if !isRunning.Get() {
+				return
+			}
+			
+			// Calculate remaining time and update remainingSeconds
+			elapsed := time.Since(startTime.Current)
+			remaining := totalDuration.Current - elapsed
+			if remaining > 0 {
+				remainingSecondsAtom.Set(int(remaining.Seconds()))
+			}
 			isRunning.Set(false)
 		}
 
@@ -156,18 +165,16 @@ var App = app.DefineComponent("App",
 			isRunning.Set(false)
 			isComplete.Set(false)
 			if mode.Get() == WorkMode.Name {
-				minutes.Set(WorkMode.Duration)
+				remainingSecondsAtom.Set(WorkMode.Duration * 60)
 			} else {
-				minutes.Set(BreakMode.Duration)
+				remainingSecondsAtom.Set(BreakMode.Duration * 60)
 			}
-			seconds.Set(0)
 		}
 
 		changeMode := func(duration int) {
 			isRunning.Set(false)
 			isComplete.Set(false)
-			minutes.Set(duration)
-			seconds.Set(0)
+			remainingSecondsAtom.Set(duration * 60)
 			if duration == WorkMode.Duration {
 				mode.Set(WorkMode.Name)
 			} else {
@@ -182,9 +189,8 @@ var App = app.DefineComponent("App",
 				"Pomodoro Timer",
 			),
 			TimerDisplay(TimerDisplayProps{
-				Minutes: minutes.Get(),
-				Seconds: seconds.Get(),
-				Mode:    mode.Get(),
+				RemainingSeconds: remainingSecondsAtom.Get(),
+				Mode:            mode.Get(),
 			}),
 			ControlButtons(ControlButtonsProps{
 				IsRunning: isRunning.Get(),

From 82aec17d08553ce1fba712da0663777ddb14ddb2 Mon Sep 17 00:00:00 2001
From: sawka <mike@commandline.dev>
Date: Thu, 11 Sep 2025 14:06:24 -0700
Subject: [PATCH 134/134] updates to pomodoro tw

---
 tsunami/demo/pomodoro/static/tw.css | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tsunami/demo/pomodoro/static/tw.css b/tsunami/demo/pomodoro/static/tw.css
index 4108051a51..9ed99608a3 100644
--- a/tsunami/demo/pomodoro/static/tw.css
+++ b/tsunami/demo/pomodoro/static/tw.css
@@ -5,6 +5,9 @@
   :root, :host {
     --font-sans: "Inter", sans-serif;
     --font-mono: "Hack", monospace;
+    --color-red-100: oklch(93.6% 0.032 17.717);
+    --color-red-500: oklch(63.7% 0.237 25.331);
+    --color-red-800: oklch(44.4% 0.177 26.899);
     --color-green-500: oklch(72.3% 0.219 149.579);
     --color-green-600: oklch(62.7% 0.194 149.214);
     --color-blue-400: oklch(70.7% 0.165 254.624);
@@ -590,6 +593,9 @@
   .border-border {
     border-color: var(--color-border);
   }
+  .border-red-500 {
+    border-color: var(--color-red-500);
+  }
   .bg-background {
     background-color: var(--color-background);
   }
@@ -602,6 +608,9 @@
   .bg-panel {
     background-color: var(--color-panel);
   }
+  .bg-red-100 {
+    background-color: var(--color-red-100);
+  }
   .bg-slate-700 {
     background-color: var(--color-slate-700);
   }
@@ -716,6 +725,9 @@
   .text-primary {
     color: var(--color-primary);
   }
+  .text-red-800 {
+    color: var(--color-red-800);
+  }
   .text-secondary {
     color: var(--color-secondary);
   }