fix(wasm): reduce binary from 1.56MB to 830KB gzip

Move heavyweight imports out of WASM build via //go:build !js tags:
- register.go: encoding/json + text/template (codegen)
- pipeline.go: go-i18n/reversal (grammar imprint)
- layout.go: replace fmt.Sprintf with string concat

Add cmd/codegen/ CLI as build-time replacement for in-browser
registerComponents(). Reads slot JSON from stdin, writes WC bundle
JS to stdout.

Result: 2.90MB raw / 830KB gzip (was 6.04MB / 1.56MB).
Makefile gate passes (limit 1MB gzip).

Co-Authored-By: Virgil <virgil@lethean.io>

CLAUDE.md

@@ -21,7 +21,16 @@ GOOS=js GOARCH=wasm go build -o gohtml.wasm ./cmd/wasm/  # WASM build
 - **Responsive**: Multi-variant breakpoint wrapper (`data-variant` attributes)
 - **Pipeline**: Render → StripTags → go-i18n/reversal Tokenise → GrammarImprint
 - **Codegen**: Web Component classes with closed Shadow DOM
-- **WASM**: `cmd/wasm/` exports `renderToString()` and `registerComponents()` to JS
+- **WASM**: `cmd/wasm/` exports `renderToString()` only (lean client-side renderer, ~830KB gzip)
+- **Codegen CLI**: `cmd/codegen/` reads slot JSON from stdin, writes WC bundle JS to stdout (build-time tool, not in WASM)
+
+## Server/Client Split
+
+Files guarded with `//go:build !js` are excluded from WASM builds:
+- `pipeline.go` — Imprint/CompareVariants use `go-i18n/reversal` (heavyweight, server-side only)
+- `cmd/wasm/register.go` — encoding/json + codegen (replaced by `cmd/codegen/` CLI)
+
+WASM binary contains only: node types, layout, responsive, context, render, path, and go-i18n core (translation).
 
 ## Dependencies
 
@@ -51,4 +60,5 @@ No specific suffix pattern — use table-driven subtests with `t.Run()`.
 | `responsive.go` | Multi-variant breakpoint wrapper |
 | `context.go` | Rendering context (Identity, Locale, Entitlements, i18n Service) |
 | `codegen/codegen.go` | Web Component class generation |
-| `cmd/wasm/main.go` | WASM entry point |
+| `cmd/wasm/main.go` | WASM entry point (`renderToString` only) |
+| `cmd/codegen/main.go` | Build-time CLI for WC bundle generation |

TODO.md

@@ -2,36 +2,36 @@
 
 ## High Priority — WASM Binary Size Fix
 
-Current: 6.04 MB raw / 1.58 MB gzip. Target: < 1 MB gzip (Makefile gate: WASM_GZ_LIMIT 1048576).
+~~Current: 6.04 MB raw / 1.58 MB gzip.~~ Fixed: 2.90 MB raw / 830 KB gzip. Target: < 1 MB gzip (Makefile gate: WASM_GZ_LIMIT 1048576).
 
-Root cause: `registerComponents()` pulls in `encoding/json` (~200KB gz), `text/template` (~125KB gz), and `fmt` (~50KB gz). Plus `pipeline.go` links `go-i18n/reversal` (~250KB gz). These are heavyweight imports for code that doesn't need to run client-side.
+Root cause: `registerComponents()` pulled in `encoding/json` (~200KB gz), `text/template` (~125KB gz), and `fmt` (~50KB gz). Plus `pipeline.go` linked `go-i18n/reversal` (~250KB gz). These were heavyweight imports for code that doesn't need to run client-side.
 
 ### Step 1: Remove `registerComponents()` from WASM
 
-- [ ] **Move `cmd/wasm/register.go` out of WASM** — Add `//go:build !js` build tag OR delete it from `cmd/wasm/`. The `registerComponents()` JS bridge in `main.go` must also be removed. This removes `encoding/json` and `text/template` from the binary.
-- [ ] **Move codegen to build-time CLI** — Create `cmd/codegen/main.go` that reads slot config from stdin (JSON) and writes generated JS to stdout. This replaces the WASM-based registration. Usage: `echo '{"H":"nav-bar","C":"main-content"}' | go run ./cmd/codegen/ > components.js`. Consumers pre-generate during build.
-- [ ] **Update `cmd/wasm/main.go`** — Remove `registerComponents` from the `gohtml` JS object. Only expose `renderToString`. Remove the `encoding/json` and `codegen` imports.
+- [x] **Move `cmd/wasm/register.go` out of WASM** — Added `//go:build !js` build tag. The `registerComponents()` JS bridge in `main.go` removed. This removes `encoding/json` and `text/template` from the binary.
+- [x] **Move codegen to build-time CLI** — Created `cmd/codegen/main.go` that reads slot config from stdin (JSON) and writes generated JS to stdout. Usage: `echo '{"H":"nav-bar","C":"main-content"}' | go run ./cmd/codegen/ > components.js`. Consumers pre-generate during build.
+- [x] **Update `cmd/wasm/main.go`** — Removed `registerComponents` from the `gohtml` JS object. Only exposes `renderToString`.
 
 ### Step 2: Remove Pipeline from WASM
 
-- [ ] **Guard `pipeline.go` with build tag** — Add `//go:build !js` to `pipeline.go`. The `Imprint()` and `CompareVariants()` functions use `go-i18n/reversal` which is heavyweight. These are server-side analysis functions, not needed in browser rendering.
-- [ ] **Update `cmd/wasm/main.go`** — Ensure no references to `pipeline.go` functions. Currently `renderToString` doesn't use them, so this should be clean.
+- [x] **Guard `pipeline.go` with build tag** — Added `//go:build !js` to `pipeline.go`. The `Imprint()` and `CompareVariants()` functions use `go-i18n/reversal` which is heavyweight. Server-side analysis only.
+- [x] **Update `cmd/wasm/main.go`** — No references to `pipeline.go` functions. `renderToString` never used them.
 
 ### Step 3: Minimise `fmt` Usage
 
-- [ ] **Replace `fmt.Errorf` in WASM-linked code** — In any source files compiled into WASM (node.go, layout.go, responsive.go, context.go, render.go), replace `fmt.Errorf("...: %w", err)` with `errors.New("...")` or manual string concatenation where wrapping isn't needed. Goal: eliminate `fmt` from the WASM import graph entirely if possible.
+- [x] **Replace `fmt.Sprintf` in WASM-linked code** — Replaced `fmt.Sprintf` in `layout.go` `blockID()` with string concatenation. `fmt` eliminated from the WASM import graph.
 
 ### Step 4: Verify Size
 
-- [ ] **Build and measure** — Run `GOOS=js GOARCH=wasm go build -o gohtml.wasm ./cmd/wasm/` then `gzip -9 -c gohtml.wasm | wc -c`. Must be < 1,048,576 bytes. Update Makefile if the gate passes.
-- [ ] **Document the server/client split** — Update CLAUDE.md with the new architecture: WASM = `renderToString()` only, codegen = build-time CLI.
+- [x] **Build and measure** — 2,900,777 bytes raw, 830,314 bytes gzip (842,146 via `make wasm`). Well under 1 MB limit.
+- [x] **Document the server/client split** — Updated CLAUDE.md with new architecture: WASM = `renderToString()` only, codegen = build-time CLI.
 
 ### Step 5: Tests
 
 - [ ] **WASM build gate test** — `TestWASMBinarySize` in `cmd/wasm/main_test.go`: build WASM, gzip, assert < 1MB
-- [ ] **Codegen CLI test** — `cmd/codegen/main_test.go`: pipe JSON stdin → verify JS output matches `GenerateBundle()`
-- [ ] **renderToString still works** — Existing WASM tests for `renderToString` pass (may need JS runtime like `wasmedge` or build-tag guarded)
-- [ ] **Existing tests still pass** — `go test ./...` (non-WASM) still passes, pipeline/codegen tests unaffected
+- [x] **Codegen CLI test** — `cmd/codegen/main_test.go`: pipe JSON stdin, verify JS output matches `GenerateBundle()`
+- [x] **renderToString still works** — Existing WASM tests for `renderToString` pass (build-tag guarded)
+- [x] **Existing tests still pass** — `go test ./...` (non-WASM) all 70+ tests pass, pipeline/codegen tests unaffected
 
 ## Medium Priority
 

cmd/codegen/main.go

@@ -0,0 +1,43 @@
+// Package main provides a build-time CLI for generating Web Component JS bundles.
+// Reads a JSON slot map from stdin, writes the generated JS to stdout.
+//
+// Usage:
+//
+//	echo '{"H":"nav-bar","C":"main-content"}' | go run ./cmd/codegen/ > components.js
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+
+	"forge.lthn.ai/core/go-html/codegen"
+)
+
+func run(r io.Reader, w io.Writer) error {
+	data, err := io.ReadAll(r)
+	if err != nil {
+		return fmt.Errorf("codegen: reading stdin: %w", err)
+	}
+
+	var slots map[string]string
+	if err := json.Unmarshal(data, &slots); err != nil {
+		return fmt.Errorf("codegen: invalid JSON: %w", err)
+	}
+
+	js, err := codegen.GenerateBundle(slots)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.WriteString(w, js)
+	return err
+}
+
+func main() {
+	if err := run(os.Stdin, os.Stdout); err != nil {
+		fmt.Fprintf(os.Stderr, "%s\n", err)
+		os.Exit(1)
+	}
+}

cmd/codegen/main_test.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRun_Good(t *testing.T) {
+	input := strings.NewReader(`{"H":"nav-bar","C":"main-content"}`)
+	var output bytes.Buffer
+
+	err := run(input, &output)
+	require.NoError(t, err)
+
+	js := output.String()
+	assert.Contains(t, js, "NavBar")
+	assert.Contains(t, js, "MainContent")
+	assert.Contains(t, js, "customElements.define")
+	assert.Equal(t, 2, strings.Count(js, "extends HTMLElement"))
+}
+
+func TestRun_Bad_InvalidJSON(t *testing.T) {
+	input := strings.NewReader(`not json`)
+	var output bytes.Buffer
+
+	err := run(input, &output)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "invalid JSON")
+}
+
+func TestRun_Bad_InvalidTag(t *testing.T) {
+	input := strings.NewReader(`{"H":"notag"}`)
+	var output bytes.Buffer
+
+	err := run(input, &output)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "hyphen")
+}
+
+func TestRun_Good_Empty(t *testing.T) {
+	input := strings.NewReader(`{}`)
+	var output bytes.Buffer
+
+	err := run(input, &output)
+	require.NoError(t, err)
+	assert.Empty(t, output.String())
+}

cmd/wasm/main.go

@@ -50,28 +50,9 @@ func renderToString(_ js.Value, args []js.Value) any {
 	return layout.Render(ctx)
 }
 
-// registerComponentsJS wraps buildComponentJS for the WASM→JS bridge.
-// Takes a JSON string of slot assignments, generates the WC bundle,
-// and executes it in the browser via the Function constructor.
-func registerComponentsJS(_ js.Value, args []js.Value) any {
-	if len(args) < 1 {
-		return js.ValueOf("error: slotsJSON argument required")
-	}
-	jsCode, err := buildComponentJS(args[0].String())
-	if err != nil {
-		return js.ValueOf("error: " + err.Error())
-	}
-	// Execute the generated WC definitions in the browser context.
-	// Uses the standard Function constructor — the normal Go WASM→JS pattern.
-	fn := js.Global().Call("Function", jsCode)
-	fn.Invoke()
-	return js.ValueOf(jsCode)
-}
-
 func main() {
 	js.Global().Set("gohtml", js.ValueOf(map[string]any{
-		"renderToString":     js.FuncOf(renderToString),
-		"registerComponents": js.FuncOf(registerComponentsJS),
+		"renderToString": js.FuncOf(renderToString),
 	}))
 
 	select {}

cmd/wasm/register.go

@@ -1,3 +1,5 @@
+//go:build !js
+
 package main
 
 import (
@@ -9,6 +11,8 @@ import (
 
 // buildComponentJS takes a JSON slot map and returns the WC bundle JS string.
 // This is the pure-Go part testable without WASM.
+// Excluded from WASM builds — encoding/json and text/template are too heavy.
+// Use cmd/codegen/ CLI instead for build-time generation.
 func buildComponentJS(slotsJSON string) (string, error) {
 	var slots map[string]string
 	if err := json.Unmarshal([]byte(slotsJSON), &slots); err != nil {

layout.go

@@ -1,9 +1,6 @@
 package html
 
-import (
-	"fmt"
-	"strings"
-)
+import "strings"
 
 // slotMeta holds the semantic HTML mapping for each HLCRF slot.
 type slotMeta struct {
@@ -69,7 +66,7 @@ func (l *Layout) F(nodes ...Node) *Layout {
 
 // blockID returns the deterministic data-block attribute value for a slot.
 func (l *Layout) blockID(slot byte) string {
-	return fmt.Sprintf("%s%c-0", l.path, slot)
+	return l.path + string(slot) + "-0"
 }
 
 // Render produces the semantic HTML for this layout.

pipeline.go

@@ -1,3 +1,5 @@
+//go:build !js
+
 package html
 
 import (

pipeline_test.go

@@ -1,3 +1,5 @@
+//go:build !js
+
 package html
 
 import (