fusee-framework 2.7.0 → 2.7.1

package/framework/engine-go/cmd/server/main.go

@@ -1,233 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"net/http"
-	"os"
-	"path/filepath"
-
-	engine "fusee"
-	"fusee/evalexpr"
-	"fusee/rustast"
-)
-
-type PageHandler struct {
-	engine.Module
-	AST   *rustast.Node
-	Title string
-}
-
-func main() {
-	port := flag.Int("port", 3000, "Port to listen on")
-	distDir := flag.String("dist", "./dist", "Path to dist directory for static assets")
-	flag.Parse()
-
-	// 1. Locate project root (containing package.json)
-	rootDir := "."
-	for _, candidate := range []string{".", "..", "../..", "../../.."} {
-		if _, err := os.Stat(filepath.Join(candidate, "package.json")); err == nil {
-			rootDir = candidate
-			break
-		}
-	}
-	absRoot, _ := filepath.Abs(rootDir)
-
-	// 2. Initialize Server Actions Registry
-	actionReg := engine.NewActionRegistry()
-	actionReg.DefineAction("submitContact", func(args []any) (any, error) {
-		var name, email string
-		if len(args) > 0 {
-			if m, ok := args[0].(map[string]any); ok {
-				name, _ = m["name"].(string)
-				email, _ = m["email"].(string)
-			}
-		}
-		log.Printf("[Action] submitContact received from %s <%s>", name, email)
-		return map[string]any{
-			"success": true,
-			"message": fmt.Sprintf("Thank you, %s! We received your message.", name),
-		}, nil
-	})
-
-	actionReg.DefineAction("submitFeedback", func(args []any) (any, error) {
-		var message string
-		if len(args) > 0 {
-			if m, ok := args[0].(map[string]any); ok {
-				message, _ = m["message"].(string)
-			}
-		}
-		log.Printf("[Action] submitFeedback received: %q", message)
-		return map[string]any{
-			"ok":       true,
-			"received": message,
-		}, nil
-	})
-
-	// 3. Dynamically Load Routes from .fusee/manifest.json
-	var routes []*engine.Route
-	var elements engine.ElementRegistry
-	manifestPath := filepath.Join(absRoot, ".fusee", "manifest.json")
-
-	if manifest, err := engine.LoadManifest(manifestPath); err == nil && len(manifest.Routes) > 0 {
-		elements = manifest.ElementRegistry()
-		if len(elements) > 0 {
-			log.Printf("✨ [Fusee SSR] Loaded %d custom elements for declarative shadow DOM", len(elements))
-		}
-		log.Printf("✨ [Fusee SSR] Loaded %d dynamic routes from %s", len(manifest.Routes), manifestPath)
-		for _, mr := range manifest.Routes {
-			if mr.AST == nil {
-				continue
-			}
-			routeAST := mr.AST
-			routeTitle := mr.Title
-			handler := &PageHandler{
-				Module: engine.Module{
-					Load: func(params map[string]string, query map[string][]string, r *http.Request) (any, error) {
-						return map[string]any{
-							"title":  routeTitle,
-							"status": "Pre-rendered dynamically by Go SSR Engine",
-							"count":  42,
-							"items":  []any{"Dynamic Manifest", "Zero Go Code", "Rust AST Parser", "Selective Hydration"},
-						}, nil
-					},
-				},
-				AST:   routeAST,
-				Title: routeTitle,
-			}
-			routes = append(routes, engine.Compile(mr.Pattern, handler))
-		}
-	} else {
-		log.Printf("ℹ️ [Fusee SSR] No manifest found at %s. Using default fallback routes.", manifestPath)
-		routes = append(routes, engine.Compile("/", &engine.Module{
-			Load: func(params map[string]string, query map[string][]string, r *http.Request) (any, error) {
-				return map[string]any{
-					"title":   "Welcome to Fusee SSR",
-					"status":  "SSR Active",
-					"count":   10,
-					"items":   []any{"High Performance Signals", "Go SSR Engine", "Rust AST Parser", "Selective Hydration"},
-					"version": "2.0.0",
-				}, nil
-			},
-		}))
-	}
-
-	// 4. Configure Dynamic Render Function
-	renderFunc := func(w http.ResponseWriter, r *http.Request, route *engine.Route, params map[string]string, data any) {
-		scope := evalexpr.Scope{}
-		if m, ok := data.(map[string]any); ok {
-			for k, v := range m {
-				scope[k] = v
-			}
-		}
-		for k, v := range params {
-			scope[k] = v
-		}
-
-		var bodyHTML string
-		var err error
-
-		if pageH, ok := route.Handler.(*PageHandler); ok && pageH.AST != nil {
-			bodyHTML, err = engine.RenderWithElements(pageH.AST, scope, nil, elements)
-		} else {
-			bodyHTML = fmt.Sprintf(`<div class="page"><h1>%s</h1><p>%s</p></div>`, scope["title"], scope["status"])
-		}
-
-		if err != nil {
-			http.Error(w, fmt.Sprintf("Render Error: %v", err), http.StatusInternalServerError)
-			return
-		}
-
-		signals := map[string][]any{}
-		if c, ok := scope["count"]; ok {
-			signals["count"] = []any{c}
-		}
-		if s, ok := scope["status"]; ok {
-			signals["status"] = []any{s}
-		}
-
-		hydrationScript, _ := engine.RenderDehydrationScript(nil, signals)
-
-		pageTitle := "Fusee SSR App"
-		if t, ok := scope["title"].(string); ok {
-			pageTitle = t
-		}
-
-		fullHTML := fmt.Sprintf(`<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>%s</title>
-    <link rel="icon" href="/fusee-logo.svg" type="image/svg+xml" />
-    <style>
-      *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
-      body { font-family: system-ui, sans-serif; background: #0f0f13; color: #e8e8f0; min-height: 100vh; }
-      nav { display: flex; flex-wrap: wrap; gap: 1rem; padding: 1rem 2rem; background: #1a1a24; border-bottom: 1px solid #2a2a3a; }
-      nav a { color: #ff3333; text-decoration: none; font-weight: 500; }
-      .content-wrap { padding: 2rem; max-width: 800px; margin: 0 auto; width: 100%%; }
-      .demo-card { background: #13131d; border: 1px solid #2a2a3a; border-radius: 12px; padding: 1.5rem; margin-bottom: 1.5rem; }
-      .primary-btn { padding: 0.6rem 1.25rem; border: none; background: #3b82f6; color: #fff; font-weight: 600; border-radius: 6px; cursor: pointer; }
-      .cmp-btn { padding: 0.45rem 1.1rem; border-radius: 6px; border: 1px solid #2a2a3a; background: #0f0f1a; color: #e8e8f0; cursor: pointer; }
-      .cmp-input { width: 100%%; padding: 0.5rem 0.75rem; background: #0f0f1a; border: 1px solid #2a2a3a; border-radius: 6px; color: #e8e8f0; }
-      .badge { display: inline-block; padding: 0.2rem 0.65rem; border-radius: 999px; font-size: 0.75rem; font-weight: 600; }
-      .badge-blue { background: rgba(96, 165, 250, 0.15); color: #60a5fa; }
-      .badge-red { background: rgba(255, 51, 51, 0.12); color: #ff3333; }
-      .info-section { background: #0f0f1a; border: 1px solid #2a2a3a; border-radius: 12px; padding: 1.5rem; margin-top: 2rem; }
-      .info-section h2 { color: #34d399; margin-bottom: 1rem; font-size: 1.1rem; }
-      .info-section ul { margin-left: 1.5rem; }
-      .info-section li { color: #aaa; margin-bottom: 0.5rem; }
-    </style>
-</head>
-<body>
-    <div id="app">
-        <div class="root-layout">
-            <nav>
-                <a href="/" f-link>Home</a>
-                <a href="/about" f-link>About</a>
-                <a href="/ssr-demo" f-link style="color: #60a5fa;">🚀 SSR Demo</a>
-                <a href="/users" f-link style="color: #f59e0b;">👥 Users</a>
-            </nav>
-            <main class="content-wrap">
-                <div data-router-view>%s</div>
-            </main>
-        </div>
-    </div>
-    %s
-    <script type="module" src="/app/main.js"></script>
-</body>
-</html>`, pageTitle, bodyHTML, hydrationScript)
-
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte(fullHTML))
-	}
-
-	// 5. Configure Static Assets Directory
-	absDist := *distDir
-	if absDist == "./dist" || absDist == "dist" {
-		absDist = filepath.Join(absRoot, "dist")
-		if _, err := os.Stat(absDist); os.IsNotExist(err) {
-			absDist = absRoot
-		}
-	} else {
-		absDist, _ = filepath.Abs(absDist)
-	}
-	log.Printf("[Static Assets] Serving files from: %s", absDist)
-
-	// 6. Create Dispatcher & Listen
-	dispatcher := engine.NewDispatcher(engine.Config{
-		DistDir:         absDist,
-		Routes:          routes,
-		Actions:         actionReg,
-		Render:          renderFunc,
-		ActionsBasePath: "/__fusee/actions",
-	})
-
-	addr := fmt.Sprintf(":%d", *port)
-	log.Printf("Fusee Go Server listening on http://localhost:%d", *port)
-	if err := http.ListenAndServe(addr, dispatcher); err != nil {
-		log.Fatalf("Server error: %v", err)
-	}
-}

package/framework/engine-go/comet/comet.go

@@ -1,41 +0,0 @@
-package comet
-
-import "net/http"
-
-const (
-	headerRequest  = "Comet-Request"
-	headerTrigger  = "Comet-Trigger"
-	headerTarget   = "Comet-Target"
-	headerRetarget = "Comet-Retarget"
-	headerReswap   = "Comet-Reswap"
-	headerPushURL  = "Comet-Push-Url"
-	headerRedirect = "Comet-Redirect"
-)
-
-func IsComet(r *http.Request) bool {
-	return r.Header.Get(headerRequest) == "true"
-}
-
-func GetCometTarget(r *http.Request) string {
-	return r.Header.Get(headerTarget)
-}
-
-func GetCometTrigger(r *http.Request) string {
-	return r.Header.Get(headerTrigger)
-}
-
-func Retarget(w http.ResponseWriter, selector string) {
-	w.Header().Set(headerRetarget, selector)
-}
-
-func Reswap(w http.ResponseWriter, mode string) {
-	w.Header().Set(headerReswap, mode)
-}
-
-func PushURL(w http.ResponseWriter, url string) {
-	w.Header().Set(headerPushURL, url)
-}
-
-func Redirect(w http.ResponseWriter, url string) {
-	w.Header().Set(headerRedirect, url)
-}

package/framework/engine-go/comet/fragment.go

@@ -1,51 +0,0 @@
-package comet
-
-import (
-	"context"
-	"net/http"
-
-	engine "fusee"
-)
-
-// FragmentAware wraps a fragment renderer and a full page renderer, dispatching to
-// the fragment renderer when Comet-Request header is detected, or fullPage otherwise.
-func FragmentAware(fragment, fullPage engine.RenderFunc) engine.RenderFunc {
-	return func(w http.ResponseWriter, r *http.Request, route *engine.Route, params map[string]string, data any) {
-		if IsComet(r) {
-			fragment(w, r, route, params, data)
-			return
-		}
-		fullPage(w, r, route, params, data)
-	}
-}
-
-// RenderFragment writes a standalone HTML fragment response with text/html content type.
-func RenderFragment(w http.ResponseWriter, html string) {
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	w.WriteHeader(http.StatusOK)
-	_, _ = w.Write([]byte(html))
-}
-
-// RenderFragmentWithState writes an HTML fragment accompanied by an embedded Fusée hydration state script.
-func RenderFragmentWithState(w http.ResponseWriter, html string, resources map[string]map[string]any, signals map[string][]any) error {
-	script, err := engine.RenderDehydrationScript(resources, signals)
-	if err != nil {
-		return err
-	}
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	w.WriteHeader(http.StatusOK)
-	_, err = w.Write([]byte(html + "\n" + script))
-	return err
-}
-
-// RenderFragmentWithContext writes an HTML fragment with hydration state extracted from the request Context.
-func RenderFragmentWithContext(w http.ResponseWriter, ctx context.Context, html string) error {
-	script, err := engine.BuildFromContext(ctx)
-	if err != nil {
-		return err
-	}
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	w.WriteHeader(http.StatusOK)
-	_, err = w.Write([]byte(html + "\n" + script))
-	return err
-}

package/framework/engine-go/dispatcher.go

@@ -1,120 +0,0 @@
-package engine
-
-import (
-	"encoding/json"
-	"errors"
-	"log"
-	"net/http"
-	"strings"
-)
-
-const defaultActionsBasePath = "/__fusee/actions"
-
-type LoadFunc func(params map[string]string, query map[string][]string, r *http.Request) (any, error)
-
-type RenderFunc func(w http.ResponseWriter, r *http.Request, route *Route, params map[string]string, data any)
-
-type Module struct {
-	Load LoadFunc
-}
-
-// AsModule returns the module itself. Route handlers that embed Module (for example a
-// page handler that also carries its AST) inherit it, so the dispatcher still finds Load.
-func (m *Module) AsModule() *Module { return m }
-
-type moduleHandler interface {
-	AsModule() *Module
-}
-
-type Config struct {
-	DistDir         string
-	Routes          []*Route
-	Actions         *ActionRegistry
-	Render          RenderFunc
-	ActionsBasePath string
-}
-
-type Dispatcher struct {
-	cfg Config
-}
-
-func NewDispatcher(cfg Config) *Dispatcher {
-	if cfg.ActionsBasePath == "" {
-		cfg.ActionsBasePath = defaultActionsBasePath
-	}
-	return &Dispatcher{cfg: cfg}
-}
-
-func (d *Dispatcher) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// 1. Static asset bypass
-	if d.cfg.DistDir != "" && (r.Method == http.MethodGet || r.Method == http.MethodHead) {
-		if path, ok := Resolve(d.cfg.DistDir, r.URL.Path); ok {
-			log.Printf("[HTTP 200] %s %s -> static: %s", r.Method, r.URL.Path, path)
-			if err := Serve(w, r, path); err != nil {
-				log.Printf("[HTTP 500] %s %s error serving static: %v", r.Method, r.URL.Path, err)
-				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			}
-			return
-		}
-	}
-
-	// 2. Server Actions interceptor
-	if r.Method == http.MethodPost && strings.HasPrefix(r.URL.Path, d.cfg.ActionsBasePath) {
-		if d.cfg.Actions == nil {
-			log.Printf("[HTTP 404] %s %s (No ActionRegistry)", r.Method, r.URL.Path)
-			http.Error(w, "Not Found", http.StatusNotFound)
-			return
-		}
-		name := strings.TrimPrefix(strings.TrimPrefix(r.URL.Path, d.cfg.ActionsBasePath), "/")
-		log.Printf("[HTTP Action] %s %s -> action: %s", r.Method, r.URL.Path, name)
-		d.cfg.Actions.HandleRequest(w, r, name)
-		return
-	}
-
-	match := MatchAll(d.cfg.Routes, r.URL.Path)
-	if match == nil {
-		log.Printf("[HTTP 404] %s %s (No route or static file matched)", r.Method, r.URL.Path)
-		http.Error(w, "Not Found", http.StatusNotFound)
-		return
-	}
-
-	log.Printf("[HTTP SSR] %s %s -> route: %s params: %+v", r.Method, r.URL.Path, match.Route.Pattern, match.Params)
-
-	var data any
-	if h, ok := match.Route.Handler.(moduleHandler); ok && h.AsModule() != nil && h.AsModule().Load != nil {
-		module := h.AsModule()
-		var err error
-		data, err = module.Load(match.Params, r.URL.Query(), r)
-		if err != nil {
-			log.Printf("[HTTP LoadError] %s %s: %v", r.Method, r.URL.Path, err)
-			d.handleLoadError(w, r, match.Route, err)
-			return
-		}
-	}
-
-	if d.cfg.Render == nil {
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		json.NewEncoder(w).Encode(map[string]any{"params": match.Params, "data": data})
-		return
-	}
-
-	d.cfg.Render(w, r, match.Route, match.Params, data)
-}
-
-func (d *Dispatcher) handleLoadError(w http.ResponseWriter, r *http.Request, route *Route, err error) {
-	var redirect *RouteRedirect
-	if errors.As(err, &redirect) {
-		w.Header().Set("Location", redirect.Location)
-		w.WriteHeader(redirect.Status)
-		return
-	}
-
-	var httpErr *RouteHTTPError
-	if errors.As(err, &httpErr) {
-		http.Error(w, httpErr.Message, httpErr.Status)
-		return
-	}
-
-	http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-}

package/framework/engine-go/elements.go

@@ -1,248 +0,0 @@
-package engine
-
-import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-	"strings"
-
-	"fusee/evalexpr"
-	"fusee/rustast"
-)
-
-// maxElementDepth bounds element-in-element nesting so a self-rendering element fails
-// instead of recursing forever.
-const maxElementDepth = 50
-
-// ElementProp mirrors one prop declared with defineElement().
-type ElementProp struct {
-	Name      string `json:"name"`
-	Attribute string `json:"attribute"` // "" for property-only props (attribute: false)
-	Type      string `json:"type"`      // "String", "Number", "Boolean", "Array", "Object" or ""
-	Default   any    `json:"default"`
-	Reflect   bool   `json:"reflect"`
-}
-
-// ElementShadow mirrors the shadow root options of an element.
-type ElementShadow struct {
-	Mode           string `json:"mode"`
-	DelegatesFocus bool   `json:"delegatesFocus"`
-}
-
-// Element is a custom element registered with defineElement(), rendered server-side as
-// declarative shadow DOM. Setup is optional and plays the role of the JS setup():
-// it receives the resolved props and returns the template scope. Without it, the
-// template sees each prop by name and the whole set as `props`.
-type Element struct {
-	Tag    string                                             `json:"tag"`
-	Props  []ElementProp                                      `json:"props"`
-	Styles string                                             `json:"styles"`
-	Shadow ElementShadow                                      `json:"shadow"`
-	AST    *rustast.Node                                      `json:"ast"`
-	Setup  func(props evalexpr.Scope) (evalexpr.Scope, error) `json:"-"`
-}
-
-// ElementRegistry maps lowercase tag names to element definitions.
-type ElementRegistry map[string]*Element
-
-// NewElementRegistry indexes elements by lowercase tag name, skipping entries without an AST.
-func NewElementRegistry(elements []*Element) ElementRegistry {
-	reg := ElementRegistry{}
-	for _, el := range elements {
-		if el == nil || el.AST == nil || el.Tag == "" {
-			continue
-		}
-		reg[strings.ToLower(el.Tag)] = el
-	}
-	return reg
-}
-
-func (reg ElementRegistry) lookup(tag string) *Element {
-	if reg == nil || !strings.Contains(tag, "-") {
-		return nil
-	}
-	return reg[strings.ToLower(tag)]
-}
-
-func (p ElementProp) matches(name string) bool {
-	return strings.EqualFold(name, p.Name) || (p.Attribute != "" && strings.EqualFold(name, p.Attribute))
-}
-
-// propFromAttribute converts a static attribute value (nil when present without a value)
-// to the prop's type, mirroring the client converters. ok is false when the value cannot
-// be converted, in which case the default applies.
-func (p ElementProp) propFromAttribute(value *string) (any, bool) {
-	if p.Type == "Boolean" {
-		return true, true
-	}
-	if value == nil {
-		return nil, false
-	}
-	switch p.Type {
-	case "Number":
-		if *value == "" {
-			return nil, false
-		}
-		f, err := strconv.ParseFloat(*value, 64)
-		if err != nil {
-			return nil, false
-		}
-		return f, true
-	case "Array", "Object":
-		var v any
-		if err := json.Unmarshal([]byte(*value), &v); err != nil {
-			return nil, false
-		}
-		return v, true
-	default:
-		return *value, true
-	}
-}
-
-// propToAttribute converts a prop value to its attribute form; ok is false when the
-// attribute should be absent.
-func (p ElementProp) propToAttribute(value any) (string, bool) {
-	if p.Type == "Boolean" {
-		return "", truthyForClass(value)
-	}
-	if value == nil {
-		return "", false
-	}
-	if p.Type == "Array" || p.Type == "Object" {
-		raw, err := json.Marshal(value)
-		if err != nil {
-			return "", false
-		}
-		return string(raw), true
-	}
-	return displayString(value), true
-}
-
-// resolveElementProps builds the props scope from the element's static attributes and
-// bindings. It also returns the reflected attributes that must be added to the tag
-// because nothing in the template set them.
-func resolveElementProps(el *Element, props []*rustast.Prop, scope evalexpr.Scope) (evalexpr.Scope, [][2]string, error) {
-	resolved := evalexpr.Scope{}
-	var reflected [][2]string
-
-	for _, def := range el.Props {
-		value, found := def.Default, false
-
-		for _, p := range props {
-			switch p.Type {
-			case rustast.PropAttribute:
-				if def.Attribute == "" || !strings.EqualFold(p.Attribute.Name, def.Attribute) {
-					continue
-				}
-				found = true
-				if v, ok := def.propFromAttribute(p.Attribute.Value); ok {
-					value = v
-				}
-			case rustast.PropBinding:
-				if !def.matches(p.Binding.Name) {
-					continue
-				}
-				found = true
-				v, err := evalexpr.Eval(p.Binding.Expression.Content, scope)
-				if err != nil {
-					return nil, nil, err
-				}
-				if v != nil {
-					value = v
-				}
-			}
-		}
-
-		resolved[def.Name] = value
-		if def.Reflect && !found {
-			if attr, ok := def.propToAttribute(value); ok {
-				reflected = append(reflected, [2]string{def.Attribute, attr})
-			}
-		}
-	}
-
-	return resolved, reflected, nil
-}
-
-// elementScope runs the element's Go Setup, or exposes the props directly to the template.
-func elementScope(el *Element, props evalexpr.Scope) (evalexpr.Scope, error) {
-	if el.Setup != nil {
-		return el.Setup(props)
-	}
-	scope := cloneScope(props)
-	scope["props"] = map[string]any(props)
-	return scope, nil
-}
-
-// slotOutlets makes every slot outlet in a shadow template render as a native <slot>.
-func slotOutlets(ast *rustast.Node) map[string][]*rustast.Node {
-	outlets := map[string][]*rustast.Node{}
-	var walk func(nodes []*rustast.Node)
-	walk = func(nodes []*rustast.Node) {
-		for _, n := range nodes {
-			switch n.Type {
-			case rustast.NodeSlotOutlet:
-				name := n.SlotOutlet.SlotName
-				tag := "<slot></slot>"
-				if name != "default" {
-					tag = fmt.Sprintf(`<slot name="%s"></slot>`, escapeAttr(name))
-				}
-				outlets[name] = []*rustast.Node{{Type: rustast.NodeText, Text: &rustast.TextNode{Content: tag}}}
-				walk(n.SlotOutlet.Fallback)
-			case rustast.NodeElement:
-				walk(n.Element.Children)
-			case rustast.NodeComponent:
-				for _, s := range n.Component.Slots {
-					walk(s.Children)
-				}
-			case rustast.NodeIf:
-				for _, b := range n.If.Branches {
-					walk([]*rustast.Node{b.Node})
-				}
-			}
-		}
-	}
-	walk(ast.Root.Children)
-	return outlets
-}
-
-// renderShadowRoot writes `<template shadowrootmode>` with the element's styles and its
-// template rendered against the resolved props.
-func (r *Renderer) renderShadowRoot(el *Element, props evalexpr.Scope, sb *strings.Builder) error {
-	if r.depth >= maxElementDepth {
-		return fmt.Errorf("render: elements nested deeper than %d levels at <%s> (recursive element?)", maxElementDepth, el.Tag)
-	}
-
-	scope, err := elementScope(el, props)
-	if err != nil {
-		return fmt.Errorf("render: setup of <%s> failed: %w", el.Tag, err)
-	}
-	scope = cloneScope(scope)
-	scope["_slots"] = slotOutlets(el.AST)
-
-	child := NewRenderer(r.Components)
-	child.Elements = r.Elements
-	child.depth = r.depth + 1
-	html, err := child.renderRoot(el.AST, scope)
-	if err != nil {
-		return err
-	}
-
-	mode := "open"
-	if el.Shadow.Mode == "closed" {
-		mode = "closed"
-	}
-	fmt.Fprintf(sb, `<template shadowrootmode="%s"`, mode)
-	if el.Shadow.DelegatesFocus {
-		sb.WriteString(" shadowrootdelegatesfocus")
-	}
-	sb.WriteByte('>')
-	if el.Styles != "" {
-		sb.WriteString("<style>")
-		sb.WriteString(strings.ReplaceAll(el.Styles, "</style", `<\/style`))
-		sb.WriteString("</style>")
-	}
-	sb.WriteString(html)
-	sb.WriteString("</template>")
-	return nil
-}