From ddad5c353c6708d9fb97a9ecb56ca6ebe748c21a Mon Sep 17 00:00:00 2001
From: Claude <claude@anthropic.com>
Date: Wed, 24 Jun 2026 23:13:31 -0400
Subject: [PATCH] feat(ssr): run hooks during server rendering (v3.5.0)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ui.RenderToString was hook-less — a component calling any hook errored
("called outside component context"), so only hook-free trees could be
server-rendered. RenderToString now installs a transient hook fiber per
component (withSSRHookFiber): GoUseState returns its initial value, GoUseRef/
GoUseMemo compute, GoUseContextValue resolves to the nearest provider value, and
GoUseEffect is queued but never committed (so effects don't run on the server) —
matching React's ReactDOMServerIntegrationHooks.

Context propagation: the SSR renderer threads an inherited context map
(descriptor ID -> value) through the recursion, derived at each ContextProvider
boundary via deriveContextValues, so context flows through host elements and
nested providers override correctly.

Scope/limits: hook-component SSR uses the package-global current fiber (like the
client reconciler), so a process renders hook trees one at a time. The streaming
SSR path runs hooks but passes nil context (context threading there is a
follow-up); the buffered RenderToString path is fully supported.

Replaces the old boundary test with ui/ssr_hooks_test.go (useState/useRef/
useMemo/useContext + effect-skip + nested-provider). Full suite passes,
native + wasm build clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  28 +++++
 docs/REACT_TEST_PARITY.md                     |   2 +-
 .../assets/docs/latest-release-notes.md       |  25 ++--
 .../helper_branches_additional_test.go        |   8 +-
 internal/runtime/hydration_helper_gap_test.go |  16 +--
 internal/runtime/ssr.go                       | 111 +++++++++++-------
 internal/runtime/ssr_stream.go                |   6 +-
 ui/ssr_hooks_boundary_test.go                 |  60 ----------
 ui/ssr_hooks_test.go                          | 108 +++++++++++++++++
 9 files changed, 233 insertions(+), 131 deletions(-)
 delete mode 100644 ui/ssr_hooks_boundary_test.go
 create mode 100644 ui/ssr_hooks_test.go

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0f07038d..f77149a2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,33 @@
 # Changelog
 
+## v3.5.0 - 2026-06-24
+
+### Added
+
+- **Hooks now run during server rendering (`ui.RenderToString`).** Previously the
+  string serializer was hook-less: a component calling any hook errored with
+  "called outside component context", so only hook-free trees could be
+  server-rendered. `RenderToString` now installs a transient hook fiber per
+  component, so on the server:
+  - `GoUseState` returns its initial value (the setter is a no-op);
+  - `GoUseRef` and `GoUseMemo` compute normally;
+  - `GoUseContextValue` resolves to the nearest provider's value — context flows
+    down through host elements and nested providers override correctly;
+  - `GoUseEffect` is queued but never committed, so effects do not run on the
+    server (matching React).
+
+  This makes GWC able to server-render real (hook-using) components, matching
+  React's `ReactDOMServerIntegrationHooks`. Implemented by threading the inherited
+  context map through the SSR renderer and deriving it at each `ContextProvider`
+  boundary. Covered by `ui/ssr_hooks_test.go`.
+
+  Notes: SSR-with-hooks uses the package-global current-fiber like the client
+  reconciler, so a single process renders hook components one tree at a time
+  (concurrent goroutine SSR of hook components needs external serialization — a
+  pre-existing hook-architecture constraint). The streaming SSR path runs hooks
+  but does not yet thread context (a documented follow-up); the buffered
+  `RenderToString` path is fully supported.
+
 ## v3.4.10 - 2026-06-24
 
 ### Fixed
diff --git a/docs/REACT_TEST_PARITY.md b/docs/REACT_TEST_PARITY.md
index cdbb7bf6..8bbc4fa5 100644
--- a/docs/REACT_TEST_PARITY.md
+++ b/docs/REACT_TEST_PARITY.md
@@ -29,7 +29,7 @@ re-renders/effects are observable inline. SSR behavior is tested via
 | ReactDOMServerIntegrationBasic | basic SSR render, nested components, nil | ✅ | ui/ssr_components_test.go |
 | ReactDOMServerIntegrationFragment | fragment SSR | ✅ | ui/ssr_components_test.go (component->fragment hoist) |
 | ReactDOMServerIntegrationSpecialTypes | numbers/bools/null children | 🚫 | Go static typing (ui.Node children) |
-| ReactDOMServerIntegrationHooks | hooks under SSR | 🔶 | ui/ssr_hooks_boundary_test.go — ARCHITECTURAL GAP: ui.RenderToString is hook-less; hook/context components render only via the reconciler (RenderInto), which IS tested. String-SSR of hook components errors. Candidate for a dedicated "SSR hooks" feature (transient fiber tree + context propagation + hook server-mode). |
+| ReactDOMServerIntegrationHooks | hooks under SSR | ✅ | ui/ssr_hooks_test.go — IMPLEMENTED in v3.5.0: RenderToString runs useState/useRef/useMemo/useContext (effects skipped); context flows + nested providers override. Streaming path: hooks yes, context threading is a follow-up. |
 | ReactDOMServerIntegrationRefs | refs inert during SSR | ✅ | ui/ssr_ref_and_context_test.go |
 | ReactDOMServerIntegrationNewContext | context under SSR / multi-consumer | ✅ | ui/ssr_ref_and_context_test.go, ui/context_native_test.go |
 | ReactDOMServerIntegrationTextarea/Input/Checkbox | controlled inputs SSR | ✅ | ui/ssr_controlled_inputs_test.go (textarea value->content: found+fixed v3.4.9) |
diff --git a/examples/public-examples-site/assets/docs/latest-release-notes.md b/examples/public-examples-site/assets/docs/latest-release-notes.md
index b12ec10a..e73b62ab 100644
--- a/examples/public-examples-site/assets/docs/latest-release-notes.md
+++ b/examples/public-examples-site/assets/docs/latest-release-notes.md
@@ -3,18 +3,19 @@
 This docs-site page mirrors the first section returned by
 `tools/changelogcheck.LatestEntry(CHANGELOG.md)`.
 
-## v3.4.10 - 2026-06-24
+## v3.5.0 - 2026-06-24
 
-The current latest changelog section is `v3.4.10 - 2026-06-24`. **Fixed:** a
-controlled `<select value="…">` did not mark the selected option in SSR — the
-serializer put a browser-ignored `value` attribute on the `<select>`, so a
-server-rendered select showed no initial selection and mismatched on hydration.
-The serializer now drops `value` from the `<select>` and renders the matching
-`<option>` with `selected` (matching by option value, or by text when it has no
-value, and recursing into `<optgroup>`), in both the buffered and streaming
-renderers — matching React's `ReactDOMServerIntegrationSelect`. Completes the
-controlled-input SSR work begun in v3.4.9 (textarea). It is checked by the
-blocking `tools/changelogcheck` release gate
-before a versioned release can ship.
+The current latest changelog section is `v3.5.0 - 2026-06-24`. **Added:** hooks
+now run during server rendering (`ui.RenderToString`). Previously the string
+serializer was hook-less — a component calling any hook errored, so only
+hook-free trees could be server-rendered. `RenderToString` now installs a
+transient hook fiber per component: `GoUseState` returns its initial value,
+`GoUseRef`/`GoUseMemo` compute, `GoUseContextValue` resolves to the nearest
+provider value (context flows through host elements; nested providers override),
+and `GoUseEffect` is queued but never run on the server — matching React's
+`ReactDOMServerIntegrationHooks`. This lets GWC server-render real hook-using
+components. The buffered path is fully supported; the streaming path runs hooks
+but does not yet thread context (a documented follow-up). It is checked by the
+blocking `tools/changelogcheck` release gate before a versioned release can ship.
 
 See the repository root `CHANGELOG.md` for the full entry body.
diff --git a/internal/runtime/helper_branches_additional_test.go b/internal/runtime/helper_branches_additional_test.go
index 5db0dec4..5431f2b7 100644
--- a/internal/runtime/helper_branches_additional_test.go
+++ b/internal/runtime/helper_branches_additional_test.go
@@ -228,7 +228,7 @@ func TestRuntimeHotReloadHelperBranches(parseT *testing.T) {
 
 // TestRuntimeSSRHelperBranches covers error-boundary SSR fallbacks, prop conversion, and typed memo restoration.
 func TestRuntimeSSRHelperBranches(parseT *testing.T) {
-	if parseErr := renderErrorBoundaryToString(&strings.Builder{}, nil); parseErr != nil {
+	if parseErr := renderErrorBoundaryToString(&strings.Builder{}, nil, nil); parseErr != nil {
 		parseT.Fatalf("expected nil boundary render to succeed, got %v", parseErr)
 	}
 
@@ -250,7 +250,7 @@ func TestRuntimeSSRHelperBranches(parseT *testing.T) {
 			}, nil),
 		},
 	}
-	if parseErr := renderErrorBoundaryToString(parseBoundaryBuilder, parseBoundaryElement); parseErr != nil {
+	if parseErr := renderErrorBoundaryToString(parseBoundaryBuilder, parseBoundaryElement, nil); parseErr != nil {
 		parseT.Fatalf("expected error-boundary fallback render to recover, got %v", parseErr)
 	}
 	if parseBoundaryError != "boom" {
@@ -277,7 +277,7 @@ func TestRuntimeSSRHelperBranches(parseT *testing.T) {
 			}, nil),
 		},
 	}
-	if parseErr := renderErrorBoundaryToString(parseElementFallbackBuilder, parseElementFallbackBoundary); parseErr != nil {
+	if parseErr := renderErrorBoundaryToString(parseElementFallbackBuilder, parseElementFallbackBoundary, nil); parseErr != nil {
 		parseT.Fatalf("expected fallback element render to recover, got %v", parseErr)
 	}
 	if !parseElementFallbackCalled {
@@ -302,7 +302,7 @@ func TestRuntimeSSRHelperBranches(parseT *testing.T) {
 			}, nil),
 		},
 	}
-	if parseErr := renderErrorBoundaryToString(parseNoFallbackBuilder, parseNoFallbackBoundary); parseErr != nil {
+	if parseErr := renderErrorBoundaryToString(parseNoFallbackBuilder, parseNoFallbackBoundary, nil); parseErr != nil {
 		parseT.Fatalf("expected missing fallback branch to swallow panic, got %v", parseErr)
 	}
 	if !isParseOnErrorCalled {
diff --git a/internal/runtime/hydration_helper_gap_test.go b/internal/runtime/hydration_helper_gap_test.go
index e73a91ad..032acb36 100644
--- a/internal/runtime/hydration_helper_gap_test.go
+++ b/internal/runtime/hydration_helper_gap_test.go
@@ -299,7 +299,7 @@ func TestSSRAndHotReloadHelperGapBranches(parseT *testing.T) {
 		Type:     NewContextProviderType(NewContextDescriptor("default")),
 		Children: []any{CreateElement("span", nil, "provider")},
 	}
-	if parseErr := renderElementToString(parseBuilder, parseProviderElement); parseErr != nil {
+	if parseErr := renderElementToString(parseBuilder, parseProviderElement, nil); parseErr != nil {
 		parseT.Fatalf("renderElementToString(context provider): %v", parseErr)
 	}
 	if parseBuilder.String() != "<span>provider</span>" {
@@ -311,7 +311,7 @@ func TestSSRAndHotReloadHelperGapBranches(parseT *testing.T) {
 		Type:     PortalNodeType,
 		Children: []any{CreateElement("span", nil, "portal")},
 	}
-	if parseErr := renderElementToString(parseBuilder, parsePortalElement); parseErr != nil {
+	if parseErr := renderElementToString(parseBuilder, parsePortalElement, nil); parseErr != nil {
 		parseT.Fatalf("renderElementToString(portal): %v", parseErr)
 	}
 	if parseBuilder.String() != "<span>portal</span>" {
@@ -320,7 +320,7 @@ func TestSSRAndHotReloadHelperGapBranches(parseT *testing.T) {
 
 	parseBuilder.Reset()
 	parseReactiveTextFallback := &Element{Type: ReactiveTextNodeType, TextContent: "fallback"}
-	if parseErr := renderElementToString(parseBuilder, parseReactiveTextFallback); parseErr != nil {
+	if parseErr := renderElementToString(parseBuilder, parseReactiveTextFallback, nil); parseErr != nil {
 		parseT.Fatalf("renderElementToString(reactive text fallback): %v", parseErr)
 	}
 	if parseBuilder.String() != "fallback" {
@@ -332,7 +332,7 @@ func TestSSRAndHotReloadHelperGapBranches(parseT *testing.T) {
 		Type:  ReactiveRegionNodeType,
 		Props: map[string]any{reactiveRegionRenderProp: func() *Element { return CreateElement("em", nil, "region") }},
 	}
-	if parseErr := renderElementToString(parseBuilder, parseReactiveRegionElement); parseErr != nil {
+	if parseErr := renderElementToString(parseBuilder, parseReactiveRegionElement, nil); parseErr != nil {
 		parseT.Fatalf("renderElementToString(reactive region): %v", parseErr)
 	}
 	if parseBuilder.String() != "<em>region</em>" {
@@ -340,7 +340,7 @@ func TestSSRAndHotReloadHelperGapBranches(parseT *testing.T) {
 	}
 
 	parseBuilder.Reset()
-	if parseErr := renderChildrenToString(parseBuilder, []any{nil, "text", 7}); parseErr != nil {
+	if parseErr := renderChildrenToString(parseBuilder, []any{nil, "text", 7}, nil); parseErr != nil {
 		parseT.Fatalf("renderChildrenToString(): %v", parseErr)
 	}
 	if parseBuilder.String() != "text7" {
@@ -348,14 +348,14 @@ func TestSSRAndHotReloadHelperGapBranches(parseT *testing.T) {
 	}
 
 	parseUnsupportedReturn := func() string { return "bad" }
-	if _, parseErr := resolveComponentElement(&Element{Type: parseUnsupportedReturn}); parseErr == nil || !strings.Contains(parseErr.Error(), "must return *runtime.Element") {
+	if _, parseErr := resolveComponentElement(&Element{Type: parseUnsupportedReturn}, nil); parseErr == nil || !strings.Contains(parseErr.Error(), "must return *runtime.Element") {
 		parseT.Fatalf("expected unsupported return type error, got %v", parseErr)
 	}
 	parseUnsupportedArity := func(parseLeft string, parseRight string) *Element { return nil }
-	if _, parseErr := resolveComponentElement(&Element{Type: parseUnsupportedArity}); parseErr == nil || !strings.Contains(parseErr.Error(), "unsupported arity") {
+	if _, parseErr := resolveComponentElement(&Element{Type: parseUnsupportedArity}, nil); parseErr == nil || !strings.Contains(parseErr.Error(), "unsupported arity") {
 		parseT.Fatalf("expected unsupported arity error, got %v", parseErr)
 	}
-	if _, parseErr := resolveComponentElement(&Element{Type: 42}); parseErr == nil || !strings.Contains(parseErr.Error(), "unsupported element type") {
+	if _, parseErr := resolveComponentElement(&Element{Type: 42}, nil); parseErr == nil || !strings.Contains(parseErr.Error(), "unsupported element type") {
 		parseT.Fatalf("expected unsupported element type error, got %v", parseErr)
 	}
 
diff --git a/internal/runtime/ssr.go b/internal/runtime/ssr.go
index 0a21f3d6..439b68a3 100644
--- a/internal/runtime/ssr.go
+++ b/internal/runtime/ssr.go
@@ -52,14 +52,16 @@ func RenderToString(parseElement *Element) (parseMarkup string, parseErr error)
 	}()
 
 	var parseBuilder strings.Builder
-	if parseErr2 := renderElementToString(&parseBuilder, parseElement); parseErr2 != nil {
+	if parseErr2 := renderElementToString(&parseBuilder, parseElement, nil); parseErr2 != nil {
 		return "", parseErr2
 	}
 	return parseBuilder.String(), nil
 }
 
-// renderElementToString is a core package helper.
-func renderElementToString(parseBuilder *strings.Builder, parseElement *Element) error {
+// renderElementToString is a core package helper. parseCtx carries the inherited
+// context values (descriptor ID -> value) down the tree so a server-rendered
+// component's GoUseContextValue resolves to the nearest provider's value.
+func renderElementToString(parseBuilder *strings.Builder, parseElement *Element, parseCtx map[int64]any) error {
 	if parseElement == nil {
 		return nil
 	}
@@ -70,17 +72,21 @@ func renderElementToString(parseBuilder *strings.Builder, parseElement *Element)
 			parseBuilder.WriteString(html.EscapeString(parseElement.TextContent))
 			return nil
 		case "FRAGMENT":
-			return renderChildrenToString(parseBuilder, parseElement.Children)
+			return renderChildrenToString(parseBuilder, parseElement.Children, parseCtx)
 		default:
-			return renderHostElementToString(parseBuilder, parseTyp, parseElement)
+			return renderHostElementToString(parseBuilder, parseTyp, parseElement, parseCtx)
 		}
 	}
 
-	if _, parseOk2 := parseElement.Type.(*ContextProviderType); parseOk2 {
-		return renderChildrenToString(parseBuilder, parseElement.Children)
+	if parseProvider, parseOk2 := parseElement.Type.(*ContextProviderType); parseOk2 {
+		parseChildCtx := parseCtx
+		if parseProvider.Descriptor != nil {
+			parseChildCtx = deriveContextValues(parseCtx, parseProvider.Descriptor.ID, parseElement.Props["value"])
+		}
+		return renderChildrenToString(parseBuilder, parseElement.Children, parseChildCtx)
 	}
 	if _, parseOk3 := parseElement.Type.(*PortalElementType); parseOk3 {
-		return renderChildrenToString(parseBuilder, parseElement.Children)
+		return renderChildrenToString(parseBuilder, parseElement.Children, parseCtx)
 	}
 	if _, parseOk4 := parseElement.Type.(*ReactiveTextElementType); parseOk4 {
 		parseGetter, _ := parseElement.Props[reactiveTextGetterProp].(func() string)
@@ -96,27 +102,27 @@ func renderElementToString(parseBuilder *strings.Builder, parseElement *Element)
 		if render == nil {
 			return nil
 		}
-		return renderElementToString(parseBuilder, render())
+		return renderElementToString(parseBuilder, render(), parseCtx)
 	}
 	if _, parseOk6 := parseElement.Type.(*ErrorBoundaryType); parseOk6 {
-		return renderErrorBoundaryToString(parseBuilder, parseElement)
+		return renderErrorBoundaryToString(parseBuilder, parseElement, parseCtx)
 	}
 	if _, parseOk7 := parseElement.Type.(*AsyncBoundaryElementType); parseOk7 {
-		return renderAsyncBoundaryToString(parseBuilder, parseElement)
+		return renderAsyncBoundaryToString(parseBuilder, parseElement, parseCtx)
 	}
 
-	parseResolved, parseErr := resolveComponentElement(parseElement)
+	parseResolved, parseErr := resolveComponentElement(parseElement, parseCtx)
 	if parseErr != nil {
 		return parseErr
 	}
 	if parseResolved == nil {
 		return nil
 	}
-	return renderElementToString(parseBuilder, parseResolved)
+	return renderElementToString(parseBuilder, parseResolved, parseCtx)
 }
 
 // renderErrorBoundaryToString is a core package helper.
-func renderErrorBoundaryToString(parseBuilder *strings.Builder, parseElement *Element) (parseErr error) {
+func renderErrorBoundaryToString(parseBuilder *strings.Builder, parseElement *Element, parseCtx map[int64]any) (parseErr error) {
 	if parseElement == nil {
 		return nil
 	}
@@ -137,29 +143,29 @@ func renderErrorBoundaryToString(parseBuilder *strings.Builder, parseElement *El
 
 		if parseFallbackFn, _ := parseElement.Props["errorFallback"].(func(error, func()) *Element); parseFallbackFn != nil {
 			parseFallback := parseFallbackFn(parseBoundaryErr, func() {})
-			parseErr = renderElementToString(parseBuilder, parseFallback)
+			parseErr = renderElementToString(parseBuilder, parseFallback, parseCtx)
 			return
 		}
 		if parseFallback2, _ := parseElement.Props["fallback"].(*Element); parseFallback2 != nil {
-			parseErr = renderElementToString(parseBuilder, parseFallback2)
+			parseErr = renderElementToString(parseBuilder, parseFallback2, parseCtx)
 			return
 		}
 		parseErr = nil
 	}()
 
-	return renderChildrenToString(parseBuilder, parseElement.Children)
+	return renderChildrenToString(parseBuilder, parseElement.Children, parseCtx)
 }
 
 // renderAsyncBoundaryToString renders async fallback content when a child suspends.
-func renderAsyncBoundaryToString(parseBuilder *strings.Builder, parseElement *Element) (parseErr error) {
+func renderAsyncBoundaryToString(parseBuilder *strings.Builder, parseElement *Element, parseCtx map[int64]any) (parseErr error) {
 	if parseElement == nil {
 		return nil
 	}
 	if parseErr2, _ := parseElement.Props["error"].(error); parseErr2 != nil {
-		return renderAsyncBoundaryFallbackToString(parseBuilder, parseElement, parseErr2)
+		return renderAsyncBoundaryFallbackToString(parseBuilder, parseElement, parseErr2, parseCtx)
 	}
 	if parsePending, _ := parseElement.Props["pending"].(bool); parsePending {
-		return renderAsyncBoundaryFallbackToString(parseBuilder, parseElement, nil)
+		return renderAsyncBoundaryFallbackToString(parseBuilder, parseElement, nil, parseCtx)
 	}
 
 	defer func() {
@@ -168,7 +174,7 @@ func renderAsyncBoundaryToString(parseBuilder *strings.Builder, parseElement *El
 			return
 		}
 		if _, parseOk := AsSuspension(parseRecovered); parseOk {
-			parseErr = renderAsyncBoundaryFallbackToString(parseBuilder, parseElement, nil)
+			parseErr = renderAsyncBoundaryFallbackToString(parseBuilder, parseElement, nil, parseCtx)
 			return
 		}
 		panic(parseRecovered)
@@ -176,13 +182,13 @@ func renderAsyncBoundaryToString(parseBuilder *strings.Builder, parseElement *El
 
 	var parseContentBuilder strings.Builder
 	if parseContent, _ := parseElement.Props["content"].(*Element); parseContent != nil {
-		if parseErr2 := renderElementToString(&parseContentBuilder, parseContent); parseErr2 != nil {
+		if parseErr2 := renderElementToString(&parseContentBuilder, parseContent, parseCtx); parseErr2 != nil {
 			return parseErr2
 		}
 		parseBuilder.WriteString(parseContentBuilder.String())
 		return nil
 	}
-	if parseErr2 := renderChildrenToString(&parseContentBuilder, parseElement.Children); parseErr2 != nil {
+	if parseErr2 := renderChildrenToString(&parseContentBuilder, parseElement.Children, parseCtx); parseErr2 != nil {
 		return parseErr2
 	}
 	parseBuilder.WriteString(parseContentBuilder.String())
@@ -190,17 +196,17 @@ func renderAsyncBoundaryToString(parseBuilder *strings.Builder, parseElement *El
 }
 
 // renderAsyncBoundaryFallbackToString renders the best available async fallback.
-func renderAsyncBoundaryFallbackToString(parseBuilder *strings.Builder, parseElement *Element, parseErr error) error {
+func renderAsyncBoundaryFallbackToString(parseBuilder *strings.Builder, parseElement *Element, parseErr error, parseCtx map[int64]any) error {
 	if parseElement == nil || parseElement.Props == nil {
 		return nil
 	}
 	if parseErr != nil {
 		if parseFallbackFn, _ := parseElement.Props["errorFallback"].(func(error) *Element); parseFallbackFn != nil {
-			return renderElementToString(parseBuilder, parseFallbackFn(parseErr))
+			return renderElementToString(parseBuilder, parseFallbackFn(parseErr), parseCtx)
 		}
 	}
 	if parseFallback, _ := parseElement.Props["fallback"].(*Element); parseFallback != nil {
-		return renderElementToString(parseBuilder, parseFallback)
+		return renderElementToString(parseBuilder, parseFallback, parseCtx)
 	}
 	return nil
 }
@@ -279,11 +285,11 @@ func elementWithSelected(parseOption *Element) *Element {
 // <option> whose value matches the select's controlled value as selected (unless
 // it already declares selected). It recurses into <optgroup> so nested options
 // are matched too.
-func renderSelectChildrenToString(parseBuilder *strings.Builder, parseChildren []any, parseSelectValue string) error {
+func renderSelectChildrenToString(parseBuilder *strings.Builder, parseChildren []any, parseSelectValue string, parseCtx map[int64]any) error {
 	for _, parseChild := range parseChildren {
 		parseEl, parseOk := parseChild.(*Element)
 		if !parseOk || parseEl == nil {
-			if parseErr := renderChildrenToString(parseBuilder, []any{parseChild}); parseErr != nil {
+			if parseErr := renderChildrenToString(parseBuilder, []any{parseChild}, parseCtx); parseErr != nil {
 				return parseErr
 			}
 			continue
@@ -295,7 +301,7 @@ func renderSelectChildrenToString(parseBuilder *strings.Builder, parseChildren [
 			if _, parseAlready := parseEl.Props["selected"]; !parseAlready && optionMatchValue(parseEl) == parseSelectValue {
 				parseRender = elementWithSelected(parseEl)
 			}
-			if parseErr := renderElementToString(parseBuilder, parseRender); parseErr != nil {
+			if parseErr := renderElementToString(parseBuilder, parseRender, parseCtx); parseErr != nil {
 				return parseErr
 			}
 		case strings.EqualFold(parseType, "optgroup"):
@@ -303,14 +309,14 @@ func renderSelectChildrenToString(parseBuilder *strings.Builder, parseChildren [
 			parseBuilder.WriteString(parseType)
 			writeSSRProps(parseBuilder, parseEl.Props)
 			parseBuilder.WriteByte('>')
-			if parseErr := renderSelectChildrenToString(parseBuilder, getElementChildren(parseEl), parseSelectValue); parseErr != nil {
+			if parseErr := renderSelectChildrenToString(parseBuilder, getElementChildren(parseEl), parseSelectValue, parseCtx); parseErr != nil {
 				return parseErr
 			}
 			parseBuilder.WriteString("</")
 			parseBuilder.WriteString(parseType)
 			parseBuilder.WriteByte('>')
 		default:
-			if parseErr := renderElementToString(parseBuilder, parseEl); parseErr != nil {
+			if parseErr := renderElementToString(parseBuilder, parseEl, parseCtx); parseErr != nil {
 				return parseErr
 			}
 		}
@@ -318,7 +324,7 @@ func renderSelectChildrenToString(parseBuilder *strings.Builder, parseChildren [
 	return nil
 }
 
-func renderHostElementToString(parseBuilder *strings.Builder, parseTag string, parseElement *Element) error {
+func renderHostElementToString(parseBuilder *strings.Builder, parseTag string, parseElement *Element, parseCtx map[int64]any) error {
 	// A controlled <textarea value="x"> renders its value as text content, not as
 	// a (browser-ignored) value attribute.
 	if parseTextareaValue, parseIsTextarea := textareaControlledValue(parseTag, parseElement.Props); parseIsTextarea {
@@ -340,7 +346,7 @@ func renderHostElementToString(parseBuilder *strings.Builder, parseTag string, p
 		parseBuilder.WriteString(parseTag)
 		writeSSRProps(parseBuilder, parseElement.Props, "value")
 		parseBuilder.WriteByte('>')
-		if parseErr := renderSelectChildrenToString(parseBuilder, getElementChildren(parseElement), parseSelectValue); parseErr != nil {
+		if parseErr := renderSelectChildrenToString(parseBuilder, getElementChildren(parseElement), parseSelectValue, parseCtx); parseErr != nil {
 			return parseErr
 		}
 		parseBuilder.WriteString("</")
@@ -360,7 +366,7 @@ func renderHostElementToString(parseBuilder *strings.Builder, parseTag string, p
 
 	if parseElement.hasDirectText {
 		parseBuilder.WriteString(html.EscapeString(parseElement.TextContent))
-	} else if parseErr := renderChildrenToString(parseBuilder, getElementChildren(parseElement)); parseErr != nil {
+	} else if parseErr := renderChildrenToString(parseBuilder, getElementChildren(parseElement), parseCtx); parseErr != nil {
 		return parseErr
 	}
 
@@ -371,13 +377,13 @@ func renderHostElementToString(parseBuilder *strings.Builder, parseTag string, p
 }
 
 // renderChildrenToString is a core package helper.
-func renderChildrenToString(parseBuilder *strings.Builder, parseChildren []any) error {
+func renderChildrenToString(parseBuilder *strings.Builder, parseChildren []any, parseCtx map[int64]any) error {
 	for _, parseChild := range parseChildren {
 		switch parseValue := parseChild.(type) {
 		case nil:
 			continue
 		case *Element:
-			if parseErr := renderElementToString(parseBuilder, parseValue); parseErr != nil {
+			if parseErr := renderElementToString(parseBuilder, parseValue, parseCtx); parseErr != nil {
 				return parseErr
 			}
 		case string:
@@ -390,9 +396,25 @@ func renderChildrenToString(parseBuilder *strings.Builder, parseChildren []any)
 }
 
 // resolveComponentElement is a core package helper.
-func resolveComponentElement(parseElement *Element) (*Element, error) {
+// withSSRHookFiber runs render with a transient fiber installed as the current
+// hook fiber, so a component may call hooks during server rendering. The fiber
+// carries the inherited context values (for GoUseContextValue) and a fresh hooks
+// store (GoUseState returns its initial value; GoUseRef/GoUseMemo compute;
+// GoUseEffect queues an effect that is never committed, so it never runs on the
+// server). The previous current fiber is restored afterwards.
+func withSSRHookFiber(parseType any, parseProps map[string]any, parseCtx map[int64]any, parseRender func() *Element) *Element {
+	parseFiber := &Fiber{typeOf: parseType, props: parseProps, contextValues: parseCtx}
+	parsePrev := GetCurrentFiber()
+	SetCurrentFiber(parseFiber)
+	defer SetCurrentFiber(parsePrev)
+	return parseRender()
+}
+
+func resolveComponentElement(parseElement *Element, parseCtx map[int64]any) (*Element, error) {
 	if parseComponent, parseOk := parseElement.Type.(*ComponentType); parseOk {
-		return parseComponent.Render(parseElement.Props), nil
+		return withSSRHookFiber(parseElement.Type, parseElement.Props, parseCtx, func() *Element {
+			return parseComponent.Render(parseElement.Props)
+		}), nil
 	}
 
 	parseValue := reflect.ValueOf(parseElement.Type)
@@ -422,11 +444,14 @@ func resolveComponentElement(parseElement *Element) (*Element, error) {
 		return nil, fmt.Errorf("ssr: component %T has unsupported arity %d", parseElement.Type, parseTyp.NumIn())
 	}
 
-	parseResult := parseValue.Call(parseArgs)
-	if len(parseResult) != 1 || parseResult[0].IsNil() {
-		return nil, nil
-	}
-	parseResolved, _ := parseResult[0].Interface().(*Element)
+	parseResolved := withSSRHookFiber(parseElement.Type, parseElement.Props, parseCtx, func() *Element {
+		parseResult := parseValue.Call(parseArgs)
+		if len(parseResult) != 1 || parseResult[0].IsNil() {
+			return nil
+		}
+		parseOut, _ := parseResult[0].Interface().(*Element)
+		return parseOut
+	})
 	return parseResolved, nil
 }
 
diff --git a/internal/runtime/ssr_stream.go b/internal/runtime/ssr_stream.go
index 95c401cc..7f7349e3 100644
--- a/internal/runtime/ssr_stream.go
+++ b/internal/runtime/ssr_stream.go
@@ -149,7 +149,7 @@ func renderSSRStreamBoundaryChunk(parseCtx context.Context, parseBoundary ssrStr
 				panic(parseRecovered)
 			}
 		}()
-		return renderElementToString(&parseContent, parseBoundary.content)
+		return renderElementToString(&parseContent, parseBoundary.content, nil)
 	}()
 	if parseErr != nil {
 		return SSRStreamChunk{Kind: SSRStreamChunkBoundary, BoundaryID: parseBoundary.id, Err: parseErr}
@@ -205,7 +205,7 @@ func renderElementToStreamShell(parseBuilder *strings.Builder, parseElement *Ele
 		return renderAsyncBoundaryToStreamShell(parseBuilder, parseElement, parseState)
 	}
 
-	parseResolved, parseErr := resolveComponentElement(parseElement)
+	parseResolved, parseErr := resolveComponentElement(parseElement, nil)
 	if parseErr != nil {
 		return parseErr
 	}
@@ -358,7 +358,7 @@ func renderHostElementToStreamShell(parseBuilder *strings.Builder, parseTag stri
 		parseBuilder.WriteString(parseTag)
 		writeSSRProps(parseBuilder, parseElement.Props, "value")
 		parseBuilder.WriteByte('>')
-		if parseErr := renderSelectChildrenToString(parseBuilder, getElementChildren(parseElement), parseSelectValue); parseErr != nil {
+		if parseErr := renderSelectChildrenToString(parseBuilder, getElementChildren(parseElement), parseSelectValue, nil); parseErr != nil {
 			return parseErr
 		}
 		parseBuilder.WriteString("</")
diff --git a/ui/ssr_hooks_boundary_test.go b/ui/ssr_hooks_boundary_test.go
deleted file mode 100644
index e51ce43b..00000000
--- a/ui/ssr_hooks_boundary_test.go
+++ /dev/null
@@ -1,60 +0,0 @@
-//go:build !js || !wasm
-
-package ui_test
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/monstercameron/GoWebComponents/internal/platform/mockdom"
-	"github.com/monstercameron/GoWebComponents/internal/runtime"
-	"github.com/monstercameron/GoWebComponents/ui"
-)
-
-// This documents an architectural difference from React's
-// ReactDOMServerIntegrationHooks: GWC's string serializer (ui.RenderToString) is
-// intentionally a lightweight, hook-less render path — it resolves components but
-// does not establish the hook/fiber context. A component that calls a hook
-// therefore renders to a string only through the reconciler (the client/native
-// render path), which DOES run hooks. The two assertions below pin both halves of
-// that boundary so a future change (e.g. adding SSR hook support) is noticed.
-
-// TestHookComponentRendersViaReconciler: the supported path — a hook-using
-// component renders its initial state when driven through the reconciler.
-func TestHookComponentRendersViaReconciler(t *testing.T) {
-	adapter := mockdom.NewMockDOMAdapter()
-	rt := runtime.NewRuntime(runtime.Config{DOMAdapter: adapter, Reset: true})
-	root := adapter.CreateElement("div")
-
-	rt.RenderInto(root, runtime.CreateElement(func() *runtime.Element {
-		parseGet, _ := runtime.GoUseState(rt, 42)
-		return runtime.CreateElement("span", map[string]any{}, fmt.Sprint(parseGet()))
-	}, map[string]any{}))
-
-	parseSpan := adapter.GetChildren(root)
-	if len(parseSpan) == 0 {
-		t.Fatal("nothing rendered")
-	}
-	parseNode, _ := parseSpan[0].(*mockdom.MockDOMNode)
-	if parseNode == nil || parseNode.TextContent != "42" {
-		t.Errorf("reconciler render of hook component = %+v, want text 42", parseNode)
-	}
-}
-
-// TestRenderToStringRejectsHookComponent: the documented boundary — string SSR of
-// a hook-using component returns the "outside component context" error rather than
-// silently dropping state. (If GWC gains SSR hook support, update this test.)
-func TestRenderToStringRejectsHookComponent(t *testing.T) {
-	parseComponent := func() *runtime.Element {
-		parseGet, _ := runtime.GoUseStateGlobal(1)
-		return runtime.CreateElement("span", map[string]any{}, fmt.Sprint(parseGet()))
-	}
-	_, parseErr := ui.RenderToString(ui.Node(runtime.CreateElement(parseComponent, map[string]any{})))
-	if parseErr == nil {
-		t.Fatal("expected an error rendering a hook component via RenderToString (SSR is hook-less)")
-	}
-	if !strings.Contains(parseErr.Error(), "outside component context") {
-		t.Errorf("unexpected error: %v", parseErr)
-	}
-}
diff --git a/ui/ssr_hooks_test.go b/ui/ssr_hooks_test.go
new file mode 100644
index 00000000..986b8fd1
--- /dev/null
+++ b/ui/ssr_hooks_test.go
@@ -0,0 +1,108 @@
+//go:build !js || !wasm
+
+package ui_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/monstercameron/GoWebComponents/internal/platform/mockdom"
+	"github.com/monstercameron/GoWebComponents/internal/runtime"
+	"github.com/monstercameron/GoWebComponents/ui"
+)
+
+// Ported from React's ReactDOMServerIntegrationHooks: hooks run during server
+// rendering. ui.RenderToString installs a transient hook fiber per component, so
+// GoUseState returns its initial value, GoUseRef/GoUseMemo compute, and
+// GoUseContextValue resolves to the nearest provider value (with effects queued
+// but never run on the server).
+
+func ssrString(t *testing.T, parseEl *runtime.Element) string {
+	t.Helper()
+	parseOut, parseErr := ui.RenderToString(ui.Node(parseEl))
+	if parseErr != nil {
+		t.Fatalf("render error: %v", parseErr)
+	}
+	return parseOut
+}
+
+func TestSSRUseStateRendersInitialValue(t *testing.T) {
+	parseComponent := func() *runtime.Element {
+		parseGet, _ := runtime.GoUseStateGlobal(7)
+		return runtime.CreateElement("span", map[string]any{}, fmt.Sprint(parseGet()))
+	}
+	if parseGot := ssrString(t, runtime.CreateElement(parseComponent, map[string]any{})); parseGot != "<span>7</span>" {
+		t.Errorf("useState SSR = %q, want <span>7</span>", parseGot)
+	}
+}
+
+func TestSSRUseRefAndUseMemoCompute(t *testing.T) {
+	parseComponent := func() *runtime.Element {
+		parseRef := runtime.GoUseRef(99)
+		parseMemo := runtime.GoUseMemo(func() any { return "memo" }, 1)
+		return runtime.CreateElement("span", map[string]any{}, fmt.Sprintf("%v-%v", parseRef.Current, parseMemo))
+	}
+	if parseGot := ssrString(t, runtime.CreateElement(parseComponent, map[string]any{})); parseGot != "<span>99-memo</span>" {
+		t.Errorf("useRef+useMemo SSR = %q, want <span>99-memo</span>", parseGot)
+	}
+}
+
+func TestSSRUseEffectIsNotRunOnServer(t *testing.T) {
+	parseRan := false
+	parseComponent := func() *runtime.Element {
+		runtime.GoUseEffect(func() func() { parseRan = true; return nil })
+		return runtime.CreateElement("span", map[string]any{}, "x")
+	}
+	if parseGot := ssrString(t, runtime.CreateElement(parseComponent, map[string]any{})); parseGot != "<span>x</span>" {
+		t.Errorf("effect-component SSR = %q", parseGot)
+	}
+	if parseRan {
+		t.Error("useEffect ran during server render; effects must be skipped on the server")
+	}
+}
+
+func TestSSRUseContextResolvesProviderValue(t *testing.T) {
+	parseDesc := runtime.NewContextDescriptor("DEFAULT")
+	parseProvider := runtime.NewContextProviderType(parseDesc)
+	parseConsumer := func() *runtime.Element {
+		return runtime.CreateElement("span", map[string]any{}, fmt.Sprint(runtime.GoUseContextValue(parseDesc)))
+	}
+
+	// Provided value reaches the consumer.
+	parseProvided := runtime.CreateElementOwned(parseProvider, map[string]any{"value": "PROVIDED"},
+		runtime.CreateElement(parseConsumer, map[string]any{}))
+	if parseGot := ssrString(t, parseProvided); parseGot != "<span>PROVIDED</span>" {
+		t.Errorf("useContext(provided) SSR = %q", parseGot)
+	}
+
+	// Default when no provider.
+	if parseGot := ssrString(t, runtime.CreateElement(parseConsumer, map[string]any{})); parseGot != "<span>DEFAULT</span>" {
+		t.Errorf("useContext(default) SSR = %q", parseGot)
+	}
+
+	// Nested provider overrides for a consumer nested under host elements.
+	parseNested := runtime.CreateElementOwned(parseProvider, map[string]any{"value": "OUTER"},
+		runtime.CreateElement("div", map[string]any{},
+			runtime.CreateElementOwned(parseProvider, map[string]any{"value": "INNER"},
+				runtime.CreateElement("section", map[string]any{},
+					runtime.CreateElement(parseConsumer, map[string]any{})))))
+	if parseGot := ssrString(t, parseNested); parseGot != "<div><section><span>INNER</span></section></div>" {
+		t.Errorf("nested provider SSR = %q", parseGot)
+	}
+}
+
+// The reconciler (client/native) path also renders hook components — kept to pin
+// both render paths agree on initial output.
+func TestHookComponentRendersViaReconciler(t *testing.T) {
+	adapter := mockdom.NewMockDOMAdapter()
+	rt := runtime.NewRuntime(runtime.Config{DOMAdapter: adapter, Reset: true})
+	root := adapter.CreateElement("div")
+	rt.RenderInto(root, runtime.CreateElement(func() *runtime.Element {
+		parseGet, _ := runtime.GoUseState(rt, 42)
+		return runtime.CreateElement("span", map[string]any{}, fmt.Sprint(parseGet()))
+	}, map[string]any{}))
+	parseSpan, _ := adapter.GetChildren(root)[0].(*mockdom.MockDOMNode)
+	if parseSpan == nil || parseSpan.TextContent != "42" {
+		t.Errorf("reconciler render = %+v, want text 42", parseSpan)
+	}
+}