diff --git a/cmd/site/main.go b/cmd/site/main.go
index 8e002da..bb7a0ca 100644
--- a/cmd/site/main.go
+++ b/cmd/site/main.go
@@ -22,10 +22,23 @@ import (
 
 	counter "github.com/livetemplate/docs/content/recipes/counter/_app"
 	patterns "github.com/livetemplate/docs/content/recipes/patterns/_app"
+	pe "github.com/livetemplate/docs/content/recipes/progressive-enhancement/_app"
 	todos "github.com/livetemplate/docs/content/recipes/todos/_app"
 )
 
 func main() {
+	// Origin allowlist shared by every recipe — the docs binary serves
+	// from one of these hosts in production (Fly prod, Fly staging) or
+	// localhost / devbox during dev. Defining it once avoids drift when
+	// new origins (e.g. preview deploys) are added.
+	allowedOrigins := []string{
+		"https://livetemplate.fly.dev",
+		"https://livetemplate-docs-staging.fly.dev",
+		"http://localhost:8080",
+		"http://localhost:8084",
+		"http://devbox:8084",
+	}
+
 	mux := http.NewServeMux()
 	// Recipes are mounted under /apps/<slug>/ to match the embed-lvt
 	// `path=` attribute on docs pages. Tinkerdown's auto-proxy
@@ -49,13 +62,7 @@ func main() {
 	// WithPermissiveOriginCheck for random-port test setups.
 	mux.Handle("/patterns/", http.StripPrefix("/patterns", patterns.Handler("/patterns",
 		livetemplate.WithAuthenticator(&livetemplate.AnonymousAuthenticator{}),
-		livetemplate.WithAllowedOrigins([]string{
-			"https://livetemplate.fly.dev",
-			"https://livetemplate-docs-staging.fly.dev",
-			"http://localhost:8080",
-			"http://localhost:8084",
-			"http://devbox:8084",
-		}),
+		livetemplate.WithAllowedOrigins(allowedOrigins),
 	)))
 
 	// todos is mounted at /apps/todos/ — recipe-only (no public catalog
@@ -63,13 +70,22 @@ func main() {
 	// alice/bob inside todos.Handler), so cmd/site only supplies the
 	// origin allowlist for the docs deploy targets.
 	mux.Handle("/apps/todos/", http.StripPrefix("/apps/todos", todos.Handler(
-		livetemplate.WithAllowedOrigins([]string{
-			"https://livetemplate.fly.dev",
-			"https://livetemplate-docs-staging.fly.dev",
-			"http://localhost:8080",
-			"http://localhost:8084",
-			"http://devbox:8084",
-		}),
+		livetemplate.WithAllowedOrigins(allowedOrigins),
+	)))
+
+	// progressive-enhancement is mounted twice from one handler package
+	// — the only difference is WithWebSocketDisabled on the /no-ws/
+	// mount. Tier A (default) demonstrates JS+WS; Tier B (no-ws) shows
+	// the client falling back to HTTP fetch when the server rejects WS
+	// upgrades; Tier C (no-JS) is the same Tier A URL viewed with
+	// JavaScript disabled in the browser — the recipe page describes
+	// how to try it.
+	mux.Handle("/apps/progressive-enhancement/", http.StripPrefix("/apps/progressive-enhancement", pe.Handler(
+		livetemplate.WithAllowedOrigins(allowedOrigins),
+	)))
+	mux.Handle("/apps/progressive-enhancement/no-ws/", http.StripPrefix("/apps/progressive-enhancement/no-ws", pe.Handler(
+		livetemplate.WithAllowedOrigins(allowedOrigins),
+		livetemplate.WithWebSocketDisabled(),
 	)))
 
 	addr := ":" + getenv("RECIPES_PORT", "9091")
diff --git a/content/recipes/progressive-enhancement/_app/controller.go b/content/recipes/progressive-enhancement/_app/controller.go
new file mode 100644
index 0000000..91e5044
--- /dev/null
+++ b/content/recipes/progressive-enhancement/_app/controller.go
@@ -0,0 +1,125 @@
+package progressiveenhancement
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/go-playground/validator/v10"
+	"github.com/livetemplate/livetemplate"
+)
+
+// TodoController is a singleton that holds dependencies (the validator).
+type TodoController struct {
+	validate *validator.Validate
+}
+
+// TodoState is pure data, cloned per session.
+type TodoState struct {
+	Title string `json:"title"`
+	Items []Todo `json:"items" lvt:"persist"`
+	// InputTitle preserves the form value when validation fails so the
+	// user doesn't have to retype on the second attempt.
+	InputTitle string `json:"input_title" lvt:"persist"`
+}
+
+// Todo represents a single todo item.
+type Todo struct {
+	ID        string `json:"id"`
+	Title     string `json:"title"`
+	Completed bool   `json:"completed"`
+	CreatedAt string `json:"created_at"`
+}
+
+// AddInput is the input struct for the Add action. The validator tags
+// drive both server-side validation and the inline error display via
+// .lvt.ErrorTag in the template.
+type AddInput struct {
+	Title string `json:"title" validate:"required,min=3,max=100"`
+}
+
+// Mount runs once per session and seeds the in-memory store with three
+// sample todos. Flash messages are carried by the framework's lvt-flash
+// cookie across PRG redirects — no URL-param bridging needed, which
+// also avoids letting strangers spoof banners with ?success=...
+func (c *TodoController) Mount(state TodoState, ctx *livetemplate.Context) (TodoState, error) {
+	state.Title = "Progressive Enhancement Todo List"
+
+	if len(state.Items) == 0 {
+		state.Items = []Todo{
+			{ID: "1", Title: "Learn about progressive enhancement", Completed: true, CreatedAt: formatTime()},
+			{ID: "2", Title: "Try the app without JavaScript", Completed: false, CreatedAt: formatTime()},
+			{ID: "3", Title: "Enable JavaScript and see the difference", Completed: false, CreatedAt: formatTime()},
+		}
+	}
+
+	return state, nil
+}
+
+// Add handles adding a new todo item. On validation failure, InputTitle
+// is preserved on state so the form re-renders with the user's typed
+// value rather than blanking it.
+func (c *TodoController) Add(state TodoState, ctx *livetemplate.Context) (TodoState, error) {
+	var input AddInput
+	if err := ctx.BindAndValidate(&input, c.validate); err != nil {
+		state.InputTitle = ctx.GetString("title")
+		return state, err
+	}
+
+	title := strings.TrimSpace(input.Title)
+	newID := fmt.Sprintf("%d", time.Now().UnixNano())
+	state.Items = append(state.Items, Todo{
+		ID:        newID,
+		Title:     title,
+		Completed: false,
+		CreatedAt: formatTime(),
+	})
+
+	state.InputTitle = ""
+	ctx.SetFlash("success", fmt.Sprintf("Added: %s", title))
+
+	return state, nil
+}
+
+// Toggle flips a todo's completed status by ID.
+func (c *TodoController) Toggle(state TodoState, ctx *livetemplate.Context) (TodoState, error) {
+	id := ctx.GetString("id")
+	found := false
+	for i := range state.Items {
+		if state.Items[i].ID == id {
+			state.Items[i].Completed = !state.Items[i].Completed
+			found = true
+			ctx.SetFlash("success", "Item updated")
+			break
+		}
+	}
+	if !found {
+		ctx.SetFlash("error", "Item not found")
+	}
+	return state, nil
+}
+
+// Delete removes a todo by ID.
+func (c *TodoController) Delete(state TodoState, ctx *livetemplate.Context) (TodoState, error) {
+	id := ctx.GetString("id")
+
+	deleteIndex := -1
+	for i, item := range state.Items {
+		if item.ID == id {
+			deleteIndex = i
+			break
+		}
+	}
+
+	if deleteIndex >= 0 {
+		state.Items = append(state.Items[:deleteIndex], state.Items[deleteIndex+1:]...)
+		ctx.SetFlash("success", "Item deleted")
+	} else {
+		ctx.SetFlash("error", "Item not found")
+	}
+	return state, nil
+}
+
+func formatTime() string {
+	return time.Now().Format("2006-01-02 15:04:05")
+}
diff --git a/content/recipes/progressive-enhancement/_app/handler.go b/content/recipes/progressive-enhancement/_app/handler.go
new file mode 100644
index 0000000..5e9f3ea
--- /dev/null
+++ b/content/recipes/progressive-enhancement/_app/handler.go
@@ -0,0 +1,93 @@
+// Package progressiveenhancement is the docs-native fold of
+// examples/progressive-enhancement (with the "no WebSocket upgrade"
+// angle from examples/ws-disabled subsumed). The recipe demonstrates
+// LiveTemplate's three graceful-degradation tiers from a single
+// controller:
+//
+//	Tier A — JS on + WS on:  default options, instant updates over WS.
+//	Tier B — JS on + WS off: append WithWebSocketDisabled(); the client
+//	         falls back to HTTP fetch transparently.
+//	Tier C — JS off:         browser submits forms via raw POST; server
+//	         responds with 303 See Other (POST-Redirect-GET).
+//
+// There is no main() here. Production runs via the docs single-binary
+// container, mounted by cmd/site twice — once at
+// /apps/progressive-enhancement/ (Tier A) and once at
+// /apps/progressive-enhancement/no-ws/ (Tier B), the only difference
+// being the option set passed in.
+//
+// Architecture notes:
+//
+//   - The .tmpl ships as embed.FS and extracts once to a tmpdir at
+//     first Handler() call, mirroring counter/todos. livetemplate parses
+//     templates by filesystem path, so the extract is required.
+//
+//   - Unlike the todos package, there is no handlerOnce singleton.
+//     Two mounts with different option sets cannot share a sync.Once,
+//     and PE has no expensive init (no DB) so caching the handler buys
+//     nothing. Each Handler() call builds a fresh livetemplate + mux;
+//     session state is cloned per session by the framework, so the two
+//     mounts stay isolated.
+package progressiveenhancement
+
+import (
+	"embed"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sync"
+
+	"github.com/go-playground/validator/v10"
+	"github.com/livetemplate/livetemplate"
+	e2etest "github.com/livetemplate/lvt/testing"
+)
+
+//go:embed progressive-enhancement.tmpl
+var templateFS embed.FS
+
+var (
+	tmplPath string
+	tmplOnce sync.Once
+)
+
+func extractTemplate() string {
+	tmplOnce.Do(func() {
+		dir, err := os.MkdirTemp("", "pe-tmpl-*")
+		if err != nil {
+			log.Fatalf("progressive-enhancement: mkdtemp: %v", err)
+		}
+		data, err := templateFS.ReadFile("progressive-enhancement.tmpl")
+		if err != nil {
+			log.Fatalf("progressive-enhancement: read embedded tmpl: %v", err)
+		}
+		tmplPath = filepath.Join(dir, "progressive-enhancement.tmpl")
+		if err := os.WriteFile(tmplPath, data, 0o644); err != nil {
+			log.Fatalf("progressive-enhancement: write tmpl: %v", err)
+		}
+	})
+	return tmplPath
+}
+
+// Handler returns the progressive-enhancement app as an http.Handler
+// ready to mount. Production callers (cmd/site) supply
+// WithAllowedOrigins (and optionally WithWebSocketDisabled for the
+// Tier B mount). Test-server callers supply WithDevMode +
+// WithPermissiveOriginCheck for random-port setups.
+func Handler(opts ...livetemplate.Option) http.Handler {
+	controller := &TodoController{validate: validator.New()}
+	initialState := &TodoState{}
+
+	baseOpts := []livetemplate.Option{
+		livetemplate.WithParseFiles(extractTemplate()),
+	}
+	baseOpts = append(baseOpts, opts...)
+
+	tmpl := livetemplate.Must(livetemplate.New("progressive-enhancement", baseOpts...))
+
+	mux := http.NewServeMux()
+	mux.Handle("/", tmpl.Handle(controller, livetemplate.AsState(initialState)))
+	mux.HandleFunc("/livetemplate-client.js", e2etest.ServeClientLibrary)
+	mux.HandleFunc("/livetemplate.css", e2etest.ServeCSS)
+	return mux
+}
diff --git a/content/recipes/progressive-enhancement/_app/progressive-enhancement.tmpl b/content/recipes/progressive-enhancement/_app/progressive-enhancement.tmpl
new file mode 100644
index 0000000..d0b751e
--- /dev/null
+++ b/content/recipes/progressive-enhancement/_app/progressive-enhancement.tmpl
@@ -0,0 +1,100 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="color-scheme" content="light dark">
+    <title>Progressive Enhancement — LiveTemplate</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css">
+    {{if .lvt.DevMode}}
+    <link rel="stylesheet" href="/livetemplate.css">
+    <script defer src="/livetemplate-client.js"></script>
+    {{else}}
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@livetemplate/client@latest/livetemplate.css">
+    <script defer src="https://cdn.jsdelivr.net/npm/@livetemplate/client@latest/dist/livetemplate-client.browser.js"></script>
+    {{end}}
+</head>
+<body>
+    <main class="container">
+        <article>
+            <header>
+                <hgroup>
+                    <h1>{{.Title}}</h1>
+                    <p>This app works with or without JavaScript enabled</p>
+                </hgroup>
+            </header>
+
+            <!-- region:noscript-banner -->
+            <noscript>
+                <mark>
+                    <strong>No JavaScript Mode:</strong> Using traditional HTTP form submissions with page reloads.
+                    Each action reloads the page to show updates.
+                </mark>
+            </noscript>
+            <!-- endregion:noscript-banner -->
+
+            {{if .lvt.HasFlash "success"}}
+            <ins style="display:block;text-decoration:none">{{.lvt.Flash "success"}}</ins>
+            {{end}}
+            {{if .lvt.HasFlash "error"}}
+            <del style="display:block;text-decoration:none">{{.lvt.Flash "error"}}</del>
+            {{end}}
+
+            <!-- region:add-form -->
+            <form method="POST" name="add">
+                <fieldset role="group">
+                    <input
+                        type="text"
+                        name="title"
+                        value="{{.InputTitle}}"
+                        placeholder="What needs to be done?"
+                        {{.lvt.AriaInvalid "title"}}
+                        autofocus
+                    >
+                    <button type="submit" name="add" {{.lvt.AriaDisabled "title"}}>Add</button>
+                </fieldset>
+                {{.lvt.ErrorTag "title"}}
+            </form>
+            <!-- endregion:add-form -->
+        </article>
+
+        <article>
+            {{if not .Items}}
+            <p><small>No todos yet. Add one above!</small></p>
+            {{else}}
+            <table>
+                <tbody>
+                {{range .Items}}
+                <tr>
+                    <td>
+                        <!-- region:toggle-form -->
+                        <form method="POST" name="toggle" class="inline">
+                            <input type="hidden" name="id" value="{{.ID}}">
+                            <button type="submit" name="toggle" class="compact secondary outline" aria-label="{{if .Completed}}Mark incomplete{{else}}Mark complete{{end}}">
+                                {{if .Completed}}&#10003;{{else}}&#9675;{{end}}
+                            </button>
+                        </form>
+                        <!-- endregion:toggle-form -->
+                    </td>
+                    <td>
+                        {{if .Completed}}<s>{{.Title}}</s>{{else}}{{.Title}}{{end}}
+                    </td>
+                    <td>
+                        <small>{{.CreatedAt}}</small>
+                    </td>
+                    <td>
+                        <form method="POST" name="delete" class="inline">
+                            <input type="hidden" name="id" value="{{.ID}}">
+                            <button type="submit" name="delete" class="compact contrast outline" aria-label="Delete todo">&#10005;</button>
+                        </form>
+                    </td>
+                </tr>
+                {{end}}
+                </tbody>
+            </table>
+            {{end}}
+        </article>
+    </main>
+
+</body>
+</html>
diff --git a/content/recipes/progressive-enhancement/index.md b/content/recipes/progressive-enhancement/index.md
new file mode 100644
index 0000000..a147556
--- /dev/null
+++ b/content/recipes/progressive-enhancement/index.md
@@ -0,0 +1,123 @@
+---
+title: "Progressive enhancement: graceful degradation"
+description: "How a LiveTemplate app stays functional across three transports — full live, HTTP fetch fallback, and raw form POST — from a single controller and a single template. The only code-level switch between modes is one option flag."
+source_repo: https://github.com/livetemplate/docs
+source_path: content/recipes/progressive-enhancement/index.md
+---
+
+# Progressive enhancement: graceful degradation
+
+Most "live" frameworks have a load-bearing assumption: JavaScript is on, the WebSocket connects, and the user agent cooperates. LiveTemplate is built so that those assumptions can fail one at a time without the app breaking. The same controller, the same template, and the same form markup degrade through three modes:
+
+- **Tier A** — JS on, WS on (default). Actions travel over the WebSocket; UI updates as diff patches.
+- **Tier B** — JS on, WS off (`WithWebSocketDisabled()`). The client falls back to plain HTTP `fetch()`; same diff patches over a different transport.
+- **Tier C** — JS off entirely. Browser submits the form natively; server responds with `303 See Other` (POST-Redirect-GET).
+
+The interesting bit is that **the template doesn't change between tiers** — every form is `<form method="POST" name="add">`, every button is `<button name="add">`. Tier C falls out of native browser behavior, the framework just has to handle the POST. The only code-level distinction across the three modes is one option flag for Tier B.
+
+## Tier A — full live (the default)
+
+The live demo below uses LiveTemplate's normal transport: a WebSocket per session, diff patches over the wire, no whole-page reload between actions. Add a todo, toggle one, delete one — all without a navigation event.
+
+```embed-lvt path="/apps/progressive-enhancement/" upstream="http://localhost:9091" height="420px"
+```
+
+The handler that produces this is the smallest possible recipe shape — no auth, no DB:
+
+```go include="./_app/handler.go" lines="77-92"
+```
+
+That's it. `WithParseFiles(extractTemplate())` ships the embedded `.tmpl` into the framework; everything else (`opts...`) is what the caller — `cmd/site` in production, the e2e harness in tests — supplies for origin policy and dev-mode static assets.
+
+## Tier B — WebSocket disabled (HTTP fetch fallback)
+
+Same app, same template, same controller. The only difference is one option appended at construction time:
+
+```go
+livetemplate.WithWebSocketDisabled()
+```
+
+When the server rejects the WebSocket upgrade, the client library detects it, falls back to plain HTTP `fetch()` for action delivery, and applies the same diff patches it would have applied over WS. The user-visible behavior is identical — instant updates, no page reload — but the network path is request/response.
+
+```embed-lvt path="/apps/progressive-enhancement/no-ws/" upstream="http://localhost:9091" height="420px"
+```
+
+A WebSocket upgrade against this mount is rejected before negotiation:
+
+```text
+GET /no-ws/ HTTP/1.1
+Upgrade: websocket
+Connection: Upgrade
+
+→ HTTP/1.1 400 Bad Request   (or similar non-101)
+```
+
+The e2e suite asserts this directly with `TestPE_TierB_WebSocketRejected`. When you see a 101 from this mount, something is wrong.
+
+## Tier C — JavaScript disabled (POST-Redirect-GET)
+
+Tier C is the one that surprises people new to LiveTemplate, because there's no toggle for it on the server side — it's just what happens when the JS client isn't there to intercept the form submit. The browser sends `POST` with `Accept: text/html` to the form's action (the page's own URL), the framework handles the action, and the response is a `303 See Other` to the same URL with the flash message stashed in a cookie:
+
+```text
+POST / HTTP/1.1
+Content-Type: application/x-www-form-urlencoded
+Accept: text/html
+
+add=&title=Pick+up+milk
+
+→ HTTP/1.1 303 See Other
+   Location: /
+   Set-Cookie: lvt-flash=success=Added%3A+Pick+up+milk; ...
+```
+
+The browser follows the redirect, the next `GET` re-renders with the new state, and the flash cookie is consumed and cleared. POST-Redirect-GET is a well-known pattern; LiveTemplate just speaks it natively when the request shape says "no JS interception."
+
+The template carries one piece of UX scaffolding for this mode — a `<noscript>` banner that's only visible when scripts are disabled:
+
+```html include="./_app/progressive-enhancement.tmpl" lines="27-33"
+```
+
+To try Tier C live: open the [Tier A demo](/apps/progressive-enhancement/) in a new tab, then in DevTools (Cmd-Option-I / F12) → Settings → Debugger, check "Disable JavaScript" and refresh. The banner appears, every action causes a full page navigation, but the app remains fully functional.
+
+## Why `InputTitle` is on the state struct
+
+Forms reset on submit. If the user types `ab` (too short), submits, and gets a validation error, the framework re-renders — and on Tier A/B the framework's diff doesn't *reset* the input field, but on Tier C the page is fully reloaded after a 303 round-trip and the input is gone. Without explicit handling, the user retypes from scratch.
+
+The fix is one persisted field on state and one template binding:
+
+```go include="./_app/controller.go" lines="69-89"
+```
+
+On validation failure, `state.InputTitle = ctx.GetString("title")` captures whatever the user typed; the template binds it back via `value="{{.InputTitle}}"`. After a successful submit, `state.InputTitle = ""` clears it. The same persistence works across all three tiers because state round-trips through the framework regardless of transport.
+
+## Action resolution: form name vs button name
+
+All three forms in the template use the same shape:
+
+```html include="./_app/progressive-enhancement.tmpl" lines="41-54"
+```
+
+The form has `name="add"` and a button with `name="add"`. Both naming the same action is intentional belt-and-suspenders:
+
+- **Browser-native POST** (Tier C): the browser only includes form fields in the body. The clicked button's `name=value` pair is included, so the body is `add=&title=...` — the framework reads `add=` from the body to route the action.
+- **JS-intercepted submit** (Tier A/B): the client library reads the form's `name` attribute as the action.
+
+Either path resolves to the controller's `Add` method. The toggle and delete forms follow the same shape with hidden `id` inputs to carry the row identity.
+
+## Where this stops being free
+
+Three tiers from one controller is a lot of mileage from one option flag, but there are real limits:
+
+- **Tier C requires `<form method="POST">` for every action.** Pure-button no-form interactions (e.g., `<button onclick="...">`) skip the browser's form-encoding step and have no Tier C path.
+- **`Change()` is JS-only.** Live debounced input updates on every keystroke can't happen without JS — Tier C readers won't see incremental feedback. The `submit`-on-blur fallback is what they get.
+- **Multi-user broadcast is WS-only by default.** `BroadcastAction` to other connections needs a transport channel; HTTP fetch is request-scoped. Tier B users see *their own* updates, not peers'.
+- **Streamed responses require WS.** Anything range-streamed (SSE-style) needs the persistent connection.
+
+These are the cliffs. For the 80% of CRUD forms that don't need any of them, the recipe shape — one controller, three transports, one option flag — covers all three tiers without conditionals.
+
+## What next?
+
+- [Counter, deeper](/recipes/counter) — the broadcast story Tier B doesn't get for free.
+- [Todos: a real LiveTemplate app](/recipes/todos) — the same form-action shape with auth, persistence, and components on top.
+- [Reference — Server Actions](/reference/server-actions) — the action resolution rules in detail (form name, button name, action priority).
+- [Reference — POST-Redirect-GET](/reference/prg) — the framework's PRG implementation, including flash cookies and redirect target rules.
diff --git a/content/tinkerdown.yaml b/content/tinkerdown.yaml
index a8aafde..3d3b643 100644
--- a/content/tinkerdown.yaml
+++ b/content/tinkerdown.yaml
@@ -100,6 +100,8 @@ navigation:
         path: "recipes/counter/index.md"
       - title: "Todos: a real LiveTemplate app"
         path: "recipes/todos/index.md"
+      - title: "Progressive enhancement: graceful degradation"
+        path: "recipes/progressive-enhancement/index.md"
       - title: "Broadcasting, deeper"
         path: "recipes/patterns/broadcasting.md"
       - title: "Live Patterns Catalog"
diff --git a/e2e/progressive-enhancement/main.go b/e2e/progressive-enhancement/main.go
new file mode 100644
index 0000000..3db9542
--- /dev/null
+++ b/e2e/progressive-enhancement/main.go
@@ -0,0 +1,54 @@
+// Test-server binary for docs/e2e/progressive-enhancement. The
+// upstream test framework (e2etest.StartTestServer) shells out to
+// `go run .` from the test cwd, so the directory must contain a main
+// package.
+//
+// We mount the recipe twice:
+//
+//	/        — Tier A (default, JS+WS)
+//	/no-ws/  — Tier B (WithWebSocketDisabled)
+//
+// Tier A is at root rather than /apps/progressive-enhancement/ (the
+// production path) so the template's absolute /livetemplate-client.js
+// reference resolves without registering the dev-mode static handlers
+// at the outer level. Tier B's template makes the same reference;
+// ServeMux longest-prefix-wins routes those requests to Tier A's mux,
+// which serves the same client lib. Tier C (no-JS) is exercised via
+// raw HTTP POST against Tier A — no separate mount needed.
+//
+// WithDevMode + WithPermissiveOriginCheck:
+//   - DevMode wires the test framework's local client library
+//   - PermissiveOriginCheck waives the production allowlist; e2e
+//     spawns the server on a random port the allowlist can't anticipate
+package main
+
+import (
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/livetemplate/livetemplate"
+
+	pe "github.com/livetemplate/docs/content/recipes/progressive-enhancement/_app"
+)
+
+func main() {
+	port := os.Getenv("PORT")
+	if port == "" {
+		port = "8080"
+	}
+
+	devOpts := []livetemplate.Option{
+		livetemplate.WithDevMode(true),
+		livetemplate.WithPermissiveOriginCheck(),
+	}
+
+	mux := http.NewServeMux()
+	mux.Handle("/no-ws/", http.StripPrefix("/no-ws", pe.Handler(
+		append(devOpts, livetemplate.WithWebSocketDisabled())...,
+	)))
+	mux.Handle("/", pe.Handler(devOpts...))
+
+	log.Printf("progressive-enhancement test-server listening on :%s", port)
+	log.Fatal(http.ListenAndServe(":"+port, mux))
+}
diff --git a/e2e/progressive-enhancement/progressive_enhancement_test.go b/e2e/progressive-enhancement/progressive_enhancement_test.go
new file mode 100644
index 0000000..4c380bf
--- /dev/null
+++ b/e2e/progressive-enhancement/progressive_enhancement_test.go
@@ -0,0 +1,720 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/chromedp/cdproto/network"
+	"github.com/chromedp/chromedp"
+	"github.com/gorilla/websocket"
+	e2etest "github.com/livetemplate/lvt/testing"
+)
+
+func TestMain(m *testing.M) {
+	e2etest.CleanupChromeContainers()
+	code := m.Run()
+	e2etest.CleanupChromeContainers()
+	os.Exit(code)
+}
+
+// startServer launches the test-server binary on a free port and waits
+// until it's ready. Returns the port and a cleanup func.
+func startServer(t *testing.T) (int, func()) {
+	t.Helper()
+
+	port, err := e2etest.GetFreePort()
+	if err != nil {
+		t.Fatalf("Failed to get free port for server: %v", err)
+	}
+	portStr := fmt.Sprintf("%d", port)
+	serverURL := fmt.Sprintf("http://localhost:%d/", port)
+
+	t.Logf("Starting test server on port %s", portStr)
+	cmd := exec.Command("go", "run", ".")
+	cmd.Env = append(os.Environ(), "PORT="+portStr, "LVT_DEV_MODE=true")
+
+	// Capture stdout/stderr — exec.Cmd defaults stdio to /dev/null
+	// otherwise, so a crashed server is silent.
+	var serverLog bytes.Buffer
+	cmd.Stdout = &serverLog
+	cmd.Stderr = &serverLog
+
+	// `go run .` forks a compiled child binary; SIGKILL on the `go run`
+	// parent doesn't reliably propagate to that child, so the inherited
+	// stdout pipe can stay open and stall a naive Wait() forever.
+	// WaitDelay (Go 1.20+) closes the I/O goroutines after the delay so
+	// Wait() returns even when the child holds the pipe open — bounded
+	// reap, no zombies leaked across the suite's many startServer calls.
+	cmd.WaitDelay = 2 * time.Second
+
+	if err := cmd.Start(); err != nil {
+		t.Fatalf("Failed to start server: %v", err)
+	}
+
+	cleanup := func() {
+		if cmd.Process == nil {
+			return
+		}
+		_ = cmd.Process.Kill()
+		_ = cmd.Wait()
+	}
+
+	// Cap individual readiness probes at 1s so a hung server can't
+	// stall the loop.
+	readyClient := &http.Client{Timeout: 1 * time.Second}
+
+	const requiredSuccesses = 2
+	consecutiveSuccesses := 0
+	var lastErr error
+	ready := false
+	for i := 0; i < 50; i++ {
+		resp, err := readyClient.Get(serverURL)
+		if err == nil {
+			resp.Body.Close()
+			if resp.StatusCode == 200 {
+				consecutiveSuccesses++
+				if consecutiveSuccesses >= requiredSuccesses {
+					time.Sleep(100 * time.Millisecond)
+					ready = true
+					break
+				}
+			} else {
+				lastErr = fmt.Errorf("status %d", resp.StatusCode)
+				consecutiveSuccesses = 0
+			}
+		} else {
+			lastErr = err
+			consecutiveSuccesses = 0
+		}
+		time.Sleep(200 * time.Millisecond)
+	}
+
+	if !ready {
+		cleanup()
+		t.Logf("--- server stdout/stderr ---\n%s\n--- end server output ---", serverLog.String())
+		t.Fatalf("Server failed to start within 10 seconds. Last error: %v", lastErr)
+	}
+
+	t.Logf("✅ Test server ready at %s", serverURL)
+	t.Cleanup(func() {
+		if t.Failed() {
+			t.Logf("--- server stdout/stderr ---\n%s\n--- end server output ---", serverLog.String())
+		}
+	})
+
+	return port, cleanup
+}
+
+func waitForWSClient(timeout time.Duration) chromedp.Action {
+	return e2etest.WaitFor(
+		`window.liveTemplateClient && window.liveTemplateClient.isReady()`,
+		timeout,
+	)
+}
+
+func uiStandardsCheck(t *testing.T, ctx context.Context) {
+	t.Helper()
+	var violations string
+	err := chromedp.Run(ctx,
+		chromedp.Evaluate(`(() => {
+			const v = [];
+			['onclick','onchange','oninput','onsubmit','onkeydown','onkeyup'].forEach(h => {
+				document.querySelectorAll('[' + h + ']').forEach(el => v.push('inline ' + h + ' on <' + el.tagName.toLowerCase() + '>'));
+			});
+			document.querySelectorAll('[style]').forEach(el => {
+				if (el.tagName !== 'INS' && el.tagName !== 'DEL' && !el.closest('[data-modal]') && !el.closest('[data-lvt-toast-stack]'))
+					v.push('inline style on <' + el.tagName.toLowerCase() + '>');
+			});
+			if (!document.querySelector('meta[name="color-scheme"]')) v.push('missing color-scheme meta');
+			if (document.documentElement.lang !== 'en') v.push('missing lang=en');
+			const c = document.querySelector('.container');
+			if (c && c.offsetWidth > 700) v.push('container too wide: ' + c.offsetWidth + 'px');
+			return v.join('; ');
+		})()`, &violations),
+	)
+	if err != nil {
+		t.Fatalf("UI standards check failed: %v", err)
+	}
+	if violations != "" {
+		t.Errorf("UI standard violations: %s", violations)
+	}
+}
+
+// ============================================================================
+// Tier A — JS on + WS on (default)
+// ============================================================================
+
+func TestPE_TierA_BrowserE2E(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping E2E test in short mode")
+	}
+
+	serverPort, cleanup := startServer(t)
+	defer cleanup()
+
+	debugPort, err := e2etest.GetFreePort()
+	if err != nil {
+		t.Fatalf("Failed to get free port for Chrome: %v", err)
+	}
+
+	chromeCmd := e2etest.StartDockerChrome(t, debugPort)
+	defer e2etest.StopDockerChrome(t, debugPort)
+	_ = chromeCmd
+
+	chromeURL := fmt.Sprintf("http://localhost:%d", debugPort)
+	allocCtx, allocCancel := chromedp.NewRemoteAllocator(context.Background(), chromeURL)
+	defer allocCancel()
+
+	ctx, cancel := chromedp.NewContext(allocCtx, chromedp.WithLogf(t.Logf))
+	defer cancel()
+
+	ctx, cancel = context.WithTimeout(ctx, 60*time.Second)
+	defer cancel()
+
+	tierAURL := fmt.Sprintf("http://host.docker.internal:%d/", serverPort)
+
+	t.Run("Initial_Load", func(t *testing.T) {
+		var html string
+		err := chromedp.Run(ctx,
+			chromedp.Navigate(tierAURL),
+			e2etest.WaitForWebSocketReady(5*time.Second),
+			chromedp.WaitVisible(`h1`, chromedp.ByQuery),
+			e2etest.ValidateNoTemplateExpressions("[data-lvt-id]"),
+			chromedp.OuterHTML(`html`, &html, chromedp.ByQuery),
+		)
+		if err != nil {
+			t.Fatalf("Failed to load page: %v", err)
+		}
+		if !strings.Contains(html, "Progressive Enhancement") {
+			t.Error("Page title not found")
+		}
+		if !strings.Contains(html, `name="add"`) {
+			t.Error("Expected button with name='add' in form")
+		}
+		if !strings.Contains(html, "livetemplate-client.js") {
+			t.Error("Script tag for livetemplate-client.js not found")
+		}
+		t.Log("✅ Initial page load verified")
+	})
+
+	t.Run("UI_Standards", func(t *testing.T) {
+		uiStandardsCheck(t, ctx)
+	})
+
+	t.Run("WebSocket_Connection", func(t *testing.T) {
+		var wsConnected bool
+		err := chromedp.Run(ctx,
+			chromedp.Evaluate(`window.liveTemplateClient && window.liveTemplateClient.isReady()`, &wsConnected),
+		)
+		if err != nil {
+			t.Fatalf("Failed to check WebSocket: %v", err)
+		}
+		if !wsConnected {
+			t.Error("WebSocket not connected")
+		}
+		t.Log("✅ WebSocket connection established")
+	})
+
+	t.Run("Add_Todo", func(t *testing.T) {
+		var initialCount int
+		err := chromedp.Run(ctx,
+			chromedp.Evaluate(`document.querySelectorAll('table tbody tr').length`, &initialCount),
+		)
+		if err != nil {
+			t.Fatalf("Failed to count todos: %v", err)
+		}
+
+		expectedCount := initialCount + 1
+		err = chromedp.Run(ctx,
+			chromedp.SendKeys(`input[name="title"]`, "Tier A Todo", chromedp.ByQuery),
+			chromedp.Click(`button[name="add"]`, chromedp.ByQuery),
+			e2etest.WaitFor(fmt.Sprintf(`document.querySelectorAll('table tbody tr').length === %d`, expectedCount), 5*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Failed to add todo: %v", err)
+		}
+
+		var inputValue string
+		err = chromedp.Run(ctx,
+			chromedp.Evaluate(`document.querySelector('input[name="title"]').value`, &inputValue),
+		)
+		if err != nil {
+			t.Fatalf("Failed to get input value: %v", err)
+		}
+		if inputValue != "" {
+			t.Errorf("Input should be cleared after add, got: %q", inputValue)
+		}
+		t.Logf("✅ Todo added, count: %d → %d, input cleared", initialCount, expectedCount)
+	})
+
+	t.Run("Toggle_Todo", func(t *testing.T) {
+		err := chromedp.Run(ctx,
+			chromedp.Click(`table tbody tr:last-child button[name="toggle"]`, chromedp.ByQuery),
+			e2etest.WaitFor(`document.querySelector('table tbody tr:last-child').querySelector('s') !== null`, 5*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Failed to toggle todo: %v", err)
+		}
+
+		err = chromedp.Run(ctx,
+			chromedp.Click(`table tbody tr:last-child button[name="toggle"]`, chromedp.ByQuery),
+			e2etest.WaitFor(`document.querySelector('table tbody tr:last-child').querySelector('s') === null`, 5*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Failed to untoggle todo: %v", err)
+		}
+		t.Log("✅ Toggle and untoggle work correctly")
+	})
+
+	t.Run("Delete_Todo", func(t *testing.T) {
+		var beforeCount int
+		err := chromedp.Run(ctx,
+			chromedp.Evaluate(`document.querySelectorAll('table tbody tr').length`, &beforeCount),
+		)
+		if err != nil {
+			t.Fatalf("Failed to count todos: %v", err)
+		}
+
+		expectedCount := beforeCount - 1
+		err = chromedp.Run(ctx,
+			chromedp.Click(`table tbody tr:last-child button[name="delete"]`, chromedp.ByQuery),
+			e2etest.WaitFor(fmt.Sprintf(`document.querySelectorAll('table tbody tr').length === %d`, expectedCount), 5*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Failed to delete todo: %v", err)
+		}
+		t.Logf("✅ Todo deleted, count: %d → %d", beforeCount, expectedCount)
+	})
+
+	t.Run("Validation_Error", func(t *testing.T) {
+		err := chromedp.Run(ctx,
+			network.ClearBrowserCookies(),
+			chromedp.Navigate(tierAURL),
+			e2etest.WaitForWebSocketReady(5*time.Second),
+			chromedp.WaitVisible(`table`, chromedp.ByQuery),
+		)
+		if err != nil {
+			t.Fatalf("Failed to reload page: %v", err)
+		}
+
+		var beforeCount int
+		err = chromedp.Run(ctx,
+			chromedp.Evaluate(`document.querySelectorAll('table tbody tr').length`, &beforeCount),
+		)
+		if err != nil {
+			t.Fatalf("Failed to count todos: %v", err)
+		}
+
+		err = chromedp.Run(ctx,
+			chromedp.SetValue(`input[name="title"]`, "ab", chromedp.ByQuery),
+			chromedp.Click(`button[name="add"]`, chromedp.ByQuery),
+			e2etest.WaitFor(`document.querySelector('[aria-invalid="true"]') !== null`, 5*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Failed to submit invalid form: %v", err)
+		}
+
+		var afterCount int
+		err = chromedp.Run(ctx,
+			chromedp.Evaluate(`document.querySelectorAll('table tbody tr').length`, &afterCount),
+		)
+		if err != nil {
+			t.Fatalf("Failed to count after invalid submit: %v", err)
+		}
+		if afterCount != beforeCount {
+			t.Errorf("Count should be unchanged after validation error: expected %d, got %d", beforeCount, afterCount)
+		}
+		t.Log("✅ Validation error handled correctly in browser")
+	})
+}
+
+// ============================================================================
+// Tier B — JS on + WS off (WithWebSocketDisabled)
+// ============================================================================
+
+func TestPE_TierB_BrowserE2E(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping E2E test in short mode")
+	}
+
+	serverPort, cleanup := startServer(t)
+	defer cleanup()
+
+	debugPort, err := e2etest.GetFreePort()
+	if err != nil {
+		t.Fatalf("Failed to get free port for Chrome: %v", err)
+	}
+
+	chromeCmd := e2etest.StartDockerChrome(t, debugPort)
+	defer e2etest.StopDockerChrome(t, debugPort)
+	_ = chromeCmd
+
+	chromeURL := fmt.Sprintf("http://localhost:%d", debugPort)
+	allocCtx, allocCancel := chromedp.NewRemoteAllocator(context.Background(), chromeURL)
+	defer allocCancel()
+
+	ctx, cancel := chromedp.NewContext(allocCtx, chromedp.WithLogf(t.Logf))
+	defer cancel()
+
+	ctx, cancel = context.WithTimeout(ctx, 60*time.Second)
+	defer cancel()
+
+	tierBURL := fmt.Sprintf("http://host.docker.internal:%d/no-ws/", serverPort)
+
+	t.Run("PageLoads", func(t *testing.T) {
+		var html string
+		err := chromedp.Run(ctx,
+			chromedp.Navigate(tierBURL),
+			chromedp.WaitReady("body", chromedp.ByQuery),
+			waitForWSClient(10*time.Second),
+			chromedp.OuterHTML("html", &html, chromedp.ByQuery),
+		)
+		if err != nil {
+			t.Fatalf("chromedp failed: %v", err)
+		}
+		if !strings.Contains(html, "Progressive Enhancement") {
+			t.Error("Expected page title in HTML")
+		}
+		if !strings.Contains(html, `name="add"`) {
+			t.Error("Expected button with name='add'")
+		}
+	})
+
+	t.Run("UI_Standards", func(t *testing.T) {
+		uiStandardsCheck(t, ctx)
+	})
+
+	t.Run("FormSubmission", func(t *testing.T) {
+		err := chromedp.Run(ctx,
+			network.ClearBrowserCookies(),
+			chromedp.Navigate(tierBURL),
+			chromedp.WaitReady("body", chromedp.ByQuery),
+			waitForWSClient(10*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Initial load failed: %v", err)
+		}
+
+		var htmlAfter string
+		err = chromedp.Run(ctx,
+			chromedp.SendKeys(`input[name="title"]`, "Tier B no-WS todo", chromedp.ByQuery),
+			chromedp.Click(`button[name="add"]`, chromedp.ByQuery),
+			e2etest.WaitFor(`document.body.innerText.includes('Tier B no-WS todo')`, 10*time.Second),
+			chromedp.OuterHTML("html", &htmlAfter, chromedp.ByQuery),
+		)
+		if err != nil {
+			t.Fatalf("Form submission failed: %v", err)
+		}
+		if !strings.Contains(htmlAfter, "Tier B no-WS todo") {
+			t.Error("Expected 'Tier B no-WS todo' in page after form submission")
+		}
+
+		// Form should have auto-reset after successful submit
+		var inputVal string
+		err = chromedp.Run(ctx,
+			chromedp.Evaluate(`document.querySelector('input[name="title"]').value`, &inputVal),
+		)
+		if err != nil {
+			t.Logf("Warning: could not read input field: %v", err)
+		} else if inputVal != "" {
+			t.Errorf("Title input should be empty after submit, got %q", inputVal)
+		}
+	})
+
+	t.Run("MultipleSubmissions", func(t *testing.T) {
+		err := chromedp.Run(ctx,
+			network.ClearBrowserCookies(),
+			chromedp.Navigate(tierBURL),
+			chromedp.WaitReady("body", chromedp.ByQuery),
+			waitForWSClient(10*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Initial load failed: %v", err)
+		}
+
+		err = chromedp.Run(ctx,
+			chromedp.SendKeys(`input[name="title"]`, "First B todo", chromedp.ByQuery),
+			chromedp.Click(`button[name="add"]`, chromedp.ByQuery),
+			e2etest.WaitFor(`document.body.innerText.includes('First B todo')`, 10*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("First submission failed: %v", err)
+		}
+
+		var htmlAfterTwo string
+		err = chromedp.Run(ctx,
+			chromedp.Clear(`input[name="title"]`, chromedp.ByQuery),
+			chromedp.SendKeys(`input[name="title"]`, "Second B todo", chromedp.ByQuery),
+			chromedp.Click(`button[name="add"]`, chromedp.ByQuery),
+			e2etest.WaitFor(`document.body.innerText.includes('Second B todo')`, 10*time.Second),
+			chromedp.OuterHTML("html", &htmlAfterTwo, chromedp.ByQuery),
+		)
+		if err != nil {
+			t.Fatalf("Second submission failed: %v", err)
+		}
+		if !strings.Contains(htmlAfterTwo, "First B todo") {
+			t.Error("Expected 'First B todo' in page")
+		}
+		if !strings.Contains(htmlAfterTwo, "Second B todo") {
+			t.Error("Expected 'Second B todo' in page")
+		}
+	})
+
+	t.Run("Delete", func(t *testing.T) {
+		err := chromedp.Run(ctx,
+			network.ClearBrowserCookies(),
+			chromedp.Navigate(tierBURL),
+			chromedp.WaitReady("body", chromedp.ByQuery),
+			waitForWSClient(10*time.Second),
+			chromedp.SendKeys(`input[name="title"]`, "To delete in B", chromedp.ByQuery),
+			chromedp.Click(`button[name="add"]`, chromedp.ByQuery),
+			e2etest.WaitFor(`document.body.innerText.includes('To delete in B')`, 10*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Add failed: %v", err)
+		}
+
+		// Find the row containing our text and click its delete button
+		err = chromedp.Run(ctx,
+			chromedp.Evaluate(`(() => {
+				const rows = document.querySelectorAll('table tbody tr');
+				for (const r of rows) {
+					if (r.textContent.includes('To delete in B')) {
+						r.querySelector('button[name="delete"]').click();
+						return true;
+					}
+				}
+				return false;
+			})()`, nil),
+			e2etest.WaitFor(`!document.body.innerText.includes('To delete in B')`, 10*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Delete failed: %v", err)
+		}
+	})
+}
+
+// ============================================================================
+// Tier B — HTTP-only sentinel: WebSocket upgrade is rejected
+// ============================================================================
+
+func TestPE_TierB_WebSocketRejected(t *testing.T) {
+	serverPort, cleanup := startServer(t)
+	defer cleanup()
+
+	// A real WebSocket dial — gorilla/websocket sets the Sec-WebSocket-Key
+	// and Sec-WebSocket-Version headers a valid handshake needs. Just
+	// asserting "non-101 from a hand-rolled GET with bare Upgrade
+	// headers" would false-pass even when WebSocket was enabled, since
+	// the handshake itself is malformed.
+	wsURL := fmt.Sprintf("ws://localhost:%d/no-ws/", serverPort)
+	dialer := websocket.Dialer{HandshakeTimeout: 5 * time.Second}
+	conn, resp, err := dialer.Dial(wsURL, nil)
+	if conn != nil {
+		conn.Close()
+	}
+	if err == nil {
+		t.Error("WebSocket dial should have failed against the no-ws mount")
+	} else if !errors.Is(err, websocket.ErrBadHandshake) {
+		t.Logf("non-bad-handshake dial error (still acceptable): %v", err)
+	}
+	if resp != nil && resp.StatusCode == http.StatusSwitchingProtocols {
+		t.Errorf("Expected non-101 response on no-ws mount, got 101")
+	}
+}
+
+// ============================================================================
+// Tier C — JS off, raw HTTP POST (POST-Redirect-GET)
+// ============================================================================
+
+func TestPE_TierC_NoJS_PostRedirectsToSee(t *testing.T) {
+	serverPort, cleanup := startServer(t)
+	defer cleanup()
+
+	tierAURL := fmt.Sprintf("http://localhost:%d/", serverPort)
+
+	client := &http.Client{
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		},
+	}
+
+	// GET initial page
+	resp, err := client.Get(tierAURL)
+	if err != nil {
+		t.Fatalf("GET failed: %v", err)
+	}
+	cookies := resp.Cookies()
+	resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", resp.StatusCode)
+	}
+
+	// POST a new todo simulating a JS-disabled browser
+	form := strings.NewReader("add=&title=Tier+C+raw+POST")
+	req, err := http.NewRequest("POST", tierAURL, form)
+	if err != nil {
+		t.Fatalf("Failed to create request: %v", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("Accept", "text/html")
+	for _, c := range cookies {
+		req.AddCookie(c)
+	}
+
+	resp, err = client.Do(req)
+	if err != nil {
+		t.Fatalf("POST failed: %v", err)
+	}
+	resp.Body.Close()
+
+	if resp.StatusCode != http.StatusSeeOther {
+		t.Errorf("Expected 303 See Other (PRG), got %d", resp.StatusCode)
+	}
+	if resp.Header.Get("Location") == "" {
+		t.Error("Expected Location header in redirect response")
+	}
+
+	// Flash should be carried via lvt-flash cookie, not in the URL
+	var flashCookie *http.Cookie
+	for _, c := range resp.Cookies() {
+		if c.Name == "lvt-flash" {
+			flashCookie = c
+			break
+		}
+	}
+	if flashCookie == nil {
+		t.Fatal("Expected lvt-flash cookie to be set on PRG response")
+	}
+	if !strings.Contains(flashCookie.Value, "success=") {
+		t.Errorf("Expected 'success=' in flash cookie, got: %s", flashCookie.Value)
+	}
+}
+
+func TestPE_TierC_NoJS_HTTPToggle(t *testing.T) {
+	serverPort, cleanup := startServer(t)
+	defer cleanup()
+
+	tierAURL := fmt.Sprintf("http://localhost:%d/", serverPort)
+
+	client := &http.Client{
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		},
+	}
+
+	resp, err := client.Get(tierAURL)
+	if err != nil {
+		t.Fatalf("GET failed: %v", err)
+	}
+	cookies := resp.Cookies()
+	resp.Body.Close()
+
+	form := strings.NewReader("toggle=&id=1")
+	req, _ := http.NewRequest("POST", tierAURL, form)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("Accept", "text/html")
+	for _, c := range cookies {
+		req.AddCookie(c)
+	}
+
+	resp, err = client.Do(req)
+	if err != nil {
+		t.Fatalf("POST toggle failed: %v", err)
+	}
+	resp.Body.Close()
+
+	if resp.StatusCode != http.StatusSeeOther {
+		t.Errorf("Expected 303 (See Other) for HTTP toggle, got %d", resp.StatusCode)
+	}
+}
+
+func TestPE_TierC_NoJS_HTTPDelete(t *testing.T) {
+	serverPort, cleanup := startServer(t)
+	defer cleanup()
+
+	tierAURL := fmt.Sprintf("http://localhost:%d/", serverPort)
+
+	client := &http.Client{
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		},
+	}
+
+	resp, err := client.Get(tierAURL)
+	if err != nil {
+		t.Fatalf("GET failed: %v", err)
+	}
+	cookies := resp.Cookies()
+	resp.Body.Close()
+
+	form := strings.NewReader("delete=&id=2")
+	req, _ := http.NewRequest("POST", tierAURL, form)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("Accept", "text/html")
+	for _, c := range cookies {
+		req.AddCookie(c)
+	}
+
+	resp, err = client.Do(req)
+	if err != nil {
+		t.Fatalf("POST delete failed: %v", err)
+	}
+	resp.Body.Close()
+
+	if resp.StatusCode != http.StatusSeeOther {
+		t.Errorf("Expected 303 (See Other) for HTTP delete, got %d", resp.StatusCode)
+	}
+}
+
+func TestPE_TierC_ValidationError_JSON(t *testing.T) {
+	serverPort, cleanup := startServer(t)
+	defer cleanup()
+
+	tierAURL := fmt.Sprintf("http://localhost:%d/", serverPort)
+	client := &http.Client{}
+
+	resp, err := client.Get(tierAURL)
+	if err != nil {
+		t.Fatalf("GET failed: %v", err)
+	}
+	cookies := resp.Cookies()
+	resp.Body.Close()
+
+	// Empty title — Accept: application/json so the JS client path returns
+	// inline field errors as JSON, not the PRG redirect.
+	form := strings.NewReader("add=&title=")
+	req, _ := http.NewRequest("POST", tierAURL, form)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("Accept", "application/json")
+	for _, c := range cookies {
+		req.AddCookie(c)
+	}
+
+	resp, err = client.Do(req)
+	if err != nil {
+		t.Fatalf("POST failed: %v", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected 200 for JSON validation error, got %d", resp.StatusCode)
+	}
+	ct := resp.Header.Get("Content-Type")
+	if !strings.Contains(ct, "application/json") {
+		t.Errorf("Expected Content-Type application/json, got %q", ct)
+	}
+	body, _ := io.ReadAll(resp.Body)
+	if !strings.Contains(string(body), "title") {
+		t.Error("Expected 'title' field error in JSON response")
+	}
+}