diff --git a/docs/v8.md b/docs/v8.md
index 7f4b272..d0dc40e 100644
--- a/docs/v8.md
+++ b/docs/v8.md
@@ -19,17 +19,34 @@ everything new lives under `packages/`.
 - `packages/html` — `@choojs/html`: the rendering package.
   - `server.js` — server-side tagged template (← nanohtml 1.10.0 server,
     transform branches removed; pure runtime)
+  - `browser.js` — runtime-only cached template tag: each template literal
+    is parsed once (WeakMap keyed on its strings array) into a <template>
+    plus hole instructions; renders clone and fill. Values never pass
+    through innerHTML. Document-level roots (<body> etc.) parse via
+    DOMParser since <template> drops them. Known limits: no dynamic tag
+    names, no holes in raw-text elements, SVG fragments need their <svg>
+    root, and (unlike v7) whitespace is preserved as authored — which is
+    what makes server and browser output byte-identical.
   - `morph.js` — ← nanomorph 5.4.3, consolidated to one module
-  - `browser.js` — **Phase 2**: runtime-only cached template tag (WeakMap
-    keyed on the template strings array, clone-based instantiation,
-    hydration that adopts server DOM). Throws until implemented.
-  - `raw.js` — mark pre-encoded strings
+  - `raw.js` — mark pre-encoded strings (works with both renderers)
+- `packages/component` — `@choojs/component`: ← nanocomponent 6.6.0 +
+  on-load 3.4.1 as ES classes; the future island/hydration boundary.
+- `examples/counter` — the isomorphic proof: one app module, mounted
+  zero-build in the browser via import map (`index.html`), string-rendered
+  in Node (`render.js`).
 
 ## Status vs the modernization plan
 
 - [x] Phase 1: monorepo scaffold, ESM ports, choo v7 node test suite green
       on `node --test` (Node ≥ 24), CI on GitHub Actions
-- [ ] Phase 2: browser renderer rewrite + hydration, `@choojs/component`
+- [x] URL normalization fix: WHATWG URL parsing, single decode with raw
+      fallback (no more URIError on '%'), NFC matching, per-segment
+      wildcard decode, decoded state.href
+- [x] Phase 2 (core): browser renderer rewrite, `@choojs/component`,
+      zero-build counter example, full-app integration test in happy-dom
+- [ ] Phase 2 (remaining): adoption-style hydration with mismatch
+      warnings, Playwright suite in a real browser, benchmarks vs
+      nanohtml v1 / µhtml
 - [ ] Phase 3: v8 wiring (`toStream`, devtools, codemod)
 - [ ] Phase 4: bankai v10 (Vite 8/Rolldown shell, SSR middleware,
       103 Early Hints, service worker, precompression)
diff --git a/examples/counter/app.js b/examples/counter/app.js
new file mode 100644
index 0000000..b3bd1fc
--- /dev/null
+++ b/examples/counter/app.js
@@ -0,0 +1,35 @@
+// The classic choo counter. This one module is the whole app, and both
+// sides consume it: the browser mounts it (import map resolves
+// @choojs/html to the DOM renderer), Node stringifies it (same specifier
+// resolves to the string renderer). That's the isomorphic contract.
+
+import choo from '@choojs/core'
+import html from '@choojs/html'
+
+export default function createApp () {
+  const app = choo()
+  app.use(countStore)
+  app.route('/', mainView)
+  return app
+}
+
+function mainView (state, emit) {
+  return html`
+    <body>
+      <h1>count is ${state.count}</h1>
+      <button onclick=${onclick}>Increment</button>
+    </body>
+  `
+
+  function onclick () {
+    emit('increment', 1)
+  }
+}
+
+function countStore (state, emitter) {
+  state.count = state.count || 0
+  emitter.on('increment', function (count) {
+    state.count += count
+    emitter.emit('render')
+  })
+}
diff --git a/examples/counter/index.html b/examples/counter/index.html
new file mode 100644
index 0000000..dc62a3e
--- /dev/null
+++ b/examples/counter/index.html
@@ -0,0 +1,31 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>choo v8 counter — zero build</title>
+  <!--
+    No bundler, no compiler, no node_modules in the browser: an import map
+    and native ES modules. Serve this directory from the repo root, e.g.
+      npx serve .
+    then open /examples/counter/
+  -->
+  <script type="importmap">
+  {
+    "imports": {
+      "@choojs/core": "../../packages/core/index.js",
+      "@choojs/core/timing": "../../packages/core/lib/timing.js",
+      "@choojs/html": "../../packages/html/browser.js",
+      "@choojs/html/raw": "../../packages/html/raw.js",
+      "@choojs/html/morph": "../../packages/html/morph.js"
+    }
+  }
+  </script>
+</head>
+<body>
+  <script type="module">
+    import createApp from './app.js'
+    createApp().mount('body')
+  </script>
+</body>
+</html>
diff --git a/examples/counter/render.js b/examples/counter/render.js
new file mode 100644
index 0000000..4394f25
--- /dev/null
+++ b/examples/counter/render.js
@@ -0,0 +1,5 @@
+// Server-side render of the exact same app module the browser mounts:
+//   node examples/counter/render.js
+import createApp from './app.js'
+
+process.stdout.write(createApp().toString('/') + '\n')
diff --git a/packages/core/test/browser-integration.test.js b/packages/core/test/browser-integration.test.js
new file mode 100644
index 0000000..f569776
--- /dev/null
+++ b/packages/core/test/browser-integration.test.js
@@ -0,0 +1,59 @@
+// End-to-end in happy-dom: the counter app running the real browser path —
+// start(), store, emit, nanoraf-batched re-render, nanomorph in place.
+
+import { test, before } from 'node:test'
+import assert from 'node:assert'
+import { Window } from 'happy-dom'
+
+let choo, html
+
+before(async () => {
+  const win = new Window({ url: 'http://localhost/' })
+  globalThis.window = win
+  globalThis.document = win.document
+  globalThis.requestAnimationFrame = win.requestAnimationFrame.bind(win)
+  ;({ default: choo } = await import('@choojs/core'))
+  ;({ default: html } = await import('@choojs/html/browser'))
+})
+
+const tick = (ms = 30) => new Promise((resolve) => setTimeout(resolve, ms))
+
+test('a full app renders, emits, and morphs in the browser', async () => {
+  const app = choo()
+
+  app.use((state, emitter) => {
+    state.count = 0
+    emitter.on('increment', (n) => {
+      state.count += n
+      emitter.emit('render')
+    })
+  })
+
+  app.route('/', (state, emit) => {
+    return html`
+      <body>
+        <h1>count is ${state.count}</h1>
+        <button onclick=${() => emit('increment', 1)}>Increment</button>
+      </body>
+    `
+  })
+
+  const tree = app.start()
+  assert.strictEqual(tree.querySelector('h1').textContent, 'count is 0')
+
+  // state event → render event → raf-batched morph of the same tree
+  app.emit('increment', 1)
+  await tick()
+  assert.strictEqual(tree.querySelector('h1').textContent, 'count is 1', 'emit re-rendered in place')
+
+  // and through an actual DOM click on the interpolated handler
+  tree.querySelector('button').click()
+  await tick()
+  assert.strictEqual(tree.querySelector('h1').textContent, 'count is 2', 'click handler emitted')
+
+  // raf batching: two synchronous emits, one render
+  app.emit('increment', 1)
+  app.emit('increment', 1)
+  await tick()
+  assert.strictEqual(tree.querySelector('h1').textContent, 'count is 4', 'batched emits coalesced')
+})
