@jasonshimmy/vite-plugin-cer-app 0.5.0 → 0.7.0

package/e2e/cypress/e2e/isr-nested-runtime.cy.ts

@@ -33,11 +33,13 @@ if (mode === 'ssr') {
       })
     })
 
-    // /isr-test uses revalidate: 0 — the TTL is always expired after the first
-    // render, so the second request is always served stale-while-revalidate.
-    it('first request to a revalidate:0 route returns X-Cache: HIT', () => {
+    // /isr-test uses revalidate: 0 — ISR is always engaged. The first request
+    // returns HIT (cold cache) or STALE (warm cache from a previous test run),
+    // but x-cache is always present. Exact HIT/STALE distinction for a cold
+    // cache is covered by unit tests (createIsrHandler).
+    it('revalidate:0 route always has X-Cache header (ISR engaged)', () => {
       cy.request('/isr-test').then((response) => {
-        expect(response.headers['x-cache']).to.equal('HIT')
+        expect(['HIT', 'STALE']).to.include(response.headers['x-cache'])
       })
     })
 

package/e2e/cypress/e2e/per-route-render.cy.ts

@@ -0,0 +1,70 @@
+/**
+ * Tests for per-route render strategy (meta.render).
+ *
+ * render: 'server' — route is always SSR'd, skipped during SSG pre-rendering.
+ * render: 'spa'    — route is served as SPA shell in SSR mode, skipped in SSG.
+ * render: 'static' — serve pre-rendered HTML from disk; fall back to SSR.
+ */
+
+const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg'
+
+// ─── render: 'server' ─────────────────────────────────────────────────────────
+
+describe('render: server — always SSR', () => {
+  it('renders the page in SSR mode', () => {
+    if (mode !== 'ssr') return
+    cy.visit('/render-server-test')
+    cy.get('[data-cy=render-server-heading]').should('contain', 'Render Server Test')
+  })
+
+  it('renders the page in SPA mode (client-side navigation)', () => {
+    if (mode !== 'spa') return
+    cy.visit('/render-server-test')
+    cy.get('[data-cy=render-server-heading]').should('contain', 'Render Server Test')
+  })
+
+  if (mode === 'ssr') {
+    it('pre-renders the page in the initial HTML (SSR)', () => {
+      cy.request('/render-server-test').then((response) => {
+        expect(response.body).to.include('render-server-heading')
+        expect(response.body).to.include('Render Server Test')
+      })
+    })
+  }
+
+  if (mode === 'ssg') {
+    it('route with render:server is not pre-rendered — not found in ssg dist', () => {
+      // The route was skipped during SSG. The static preview falls back to
+      // dist/index.html (SPA shell) rather than a pre-rendered page, so the
+      // server-rendered heading is absent from the raw HTML response.
+      cy.request('/render-server-test').then((response) => {
+        expect(response.body).not.to.include('render-server-heading')
+      })
+    })
+  }
+})
+
+// ─── render: 'spa' ────────────────────────────────────────────────────────────
+
+describe('render: spa — client-only', () => {
+  it('renders the page heading after JS boots', () => {
+    cy.visit('/render-spa-test')
+    cy.get('[data-cy=render-spa-heading]').should('contain', 'Render SPA Test')
+  })
+
+  if (mode === 'ssr') {
+    it('raw HTML response is the SPA shell (no SSR content)', () => {
+      cy.request('/render-spa-test').then((response) => {
+        expect(response.body).not.to.include('render-spa-heading')
+      })
+    })
+  }
+
+  if (mode === 'ssg') {
+    it('route with render:spa is not pre-rendered — not found in ssg dist', () => {
+      cy.request('/render-spa-test').then((response) => {
+        expect(response.body).not.to.include('render-spa-heading')
+      })
+    })
+  }
+})

package/e2e/kitchen-sink/app/error.ts

@@ -1,9 +1,14 @@
 component('page-error', () => {
-  const props = useProps<{ error: string }>({ error: 'An unexpected error occurred.' })
+  const props = useProps<{ error: string; status: string }>({
+    error: 'An unexpected error occurred.',
+    status: '500',
+  })
 
   return html`
     <div data-cy="error-boundary" style="padding:2rem;font-family:sans-serif">
-      <h2 data-cy="error-heading" style="color:#c00;margin-top:0">Something went wrong</h2>
+      <h2 data-cy="error-heading" style="color:#c00;margin-top:0">
+        Error ${props.status}
+      </h2>
       <pre data-cy="error-message" style="background:#fff0f0;border:1px solid #fcc;padding:1rem;border-radius:4px">${props.error}</pre>
       <button data-cy="error-retry" @click="${() => (globalThis as any).resetError?.()}">
         Try again

package/e2e/kitchen-sink/app/pages/loader-error-test.ts

@@ -0,0 +1,13 @@
+component('page-loader-error-test', () => {
+  return html`
+    <div>
+      <h1 data-cy="loader-error-heading">Loader Error Test</h1>
+    </div>
+  `
+})
+
+export async function loader() {
+  const err = new Error('Loader intentionally failed') as Error & { status?: number }
+  err.status = 503
+  throw err
+}

package/e2e/kitchen-sink/app/pages/render-server-test.ts

@@ -0,0 +1,12 @@
+component('page-render-server-test', () => {
+  return html`
+    <div>
+      <h1 data-cy="render-server-heading">Render Server Test</h1>
+      <p>This page always renders server-side.</p>
+    </div>
+  `
+})
+
+export const meta = {
+  render: 'server',
+}

package/e2e/kitchen-sink/app/pages/render-spa-test.ts

@@ -0,0 +1,12 @@
+component('page-render-spa-test', () => {
+  return html`
+    <div>
+      <h1 data-cy="render-spa-heading">Render SPA Test</h1>
+      <p>This page is client-only.</p>
+    </div>
+  `
+})
+
+export const meta = {
+  render: 'spa',
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jasonshimmy/vite-plugin-cer-app",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Nuxt-style meta-framework for @jasonshimmy/custom-elements-runtime",
   "type": "module",
   "keywords": [
@@ -37,6 +37,10 @@
       "import": "./dist/types/index.js",
       "require": "./dist/types/index.cjs",
       "types": "./dist/types/index.d.ts"
+    },
+    "./isr": {
+      "import": "./dist/runtime/isr-handler.js",
+      "types": "./dist/runtime/isr-handler.d.ts"
     }
   },
   "bin": {
@@ -68,7 +72,7 @@
     "cypress:open": "cypress open"
   },
   "peerDependencies": {
-    "@jasonshimmy/custom-elements-runtime": ">=3.0.0",
+    "@jasonshimmy/custom-elements-runtime": ">=3.4.0",
     "vite": ">=5.0.0"
   },
   "dependencies": {
@@ -78,7 +82,7 @@
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@jasonshimmy/custom-elements-runtime": "^3.2.0",
+    "@jasonshimmy/custom-elements-runtime": "^3.4.0",
     "@types/node": "^25.5.0",
     "@vitest/coverage-v8": "^4.1.0",
     "cypress": "^15.12.0",

package/src/__tests__/cli/preview-isr.test.ts

@@ -3,6 +3,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http'
 import {
   matchRoutePattern,
   findRevalidate,
+  findRenderMode,
   renderForIsr,
   serveFromIsrCache,
   type IsrCacheEntry,
@@ -119,6 +120,49 @@ describe('findRevalidate', () => {
   })
 })
 
+// ─── findRenderMode ───────────────────────────────────────────────────────────
+
+describe('findRenderMode', () => {
+  it('returns null for an empty routes array', () => {
+    expect(findRenderMode([], '/about')).toBeNull()
+  })
+
+  it('returns null when no route matches', () => {
+    const routes = [{ path: '/contact', meta: { render: 'server' } }]
+    expect(findRenderMode(routes, '/about')).toBeNull()
+  })
+
+  it('returns null when matched route has no render meta', () => {
+    const routes = [{ path: '/about' }]
+    expect(findRenderMode(routes, '/about')).toBeNull()
+  })
+
+  it('returns "server" for a matching route with render: server', () => {
+    const routes = [{ path: '/dashboard', meta: { render: 'server' } }]
+    expect(findRenderMode(routes, '/dashboard')).toBe('server')
+  })
+
+  it('returns "spa" for a matching route with render: spa', () => {
+    const routes = [{ path: '/profile', meta: { render: 'spa' } }]
+    expect(findRenderMode(routes, '/profile')).toBe('spa')
+  })
+
+  it('returns "static" for a matching route with render: static', () => {
+    const routes = [{ path: '/about', meta: { render: 'static' } }]
+    expect(findRenderMode(routes, '/about')).toBe('static')
+  })
+
+  it('returns null for unrecognised render values', () => {
+    const routes = [{ path: '/about', meta: { render: 'unknown' } }]
+    expect(findRenderMode(routes, '/about')).toBeNull()
+  })
+
+  it('matches dynamic routes', () => {
+    const routes = [{ path: '/blog/:slug', meta: { render: 'server' } }]
+    expect(findRenderMode(routes, '/blog/my-post')).toBe('server')
+  })
+})
+
 // ─── renderForIsr ─────────────────────────────────────────────────────────────
 
 describe('renderForIsr', () => {

package/src/__tests__/plugin/build-ssg-render.test.ts

@@ -97,6 +97,52 @@ describe('buildSSG — renderPath success (real server bundle)', () => {
     expect(manifest.paths).toHaveLength(2)
   })
 
+  it('captures HTML from a streaming handler that calls write() then end()', async () => {
+    // Simulate the renderToStreamWithJITCSSDSD-based handler which calls
+    // res.write(firstChunk) for sync content and res.end(polyfill + tail).
+    // Use a completely separate tmpdir with a unique path so Node's native ESM
+    // import cache cannot return a previously-loaded module for the same URL.
+    const streamRoot = join(tmpdir(), `cer-ssg-stream-${Date.now()}`)
+    const streamServerDir = join(streamRoot, 'dist', 'server')
+    mkdirSync(streamServerDir, { recursive: true })
+    writeFileSync(
+      join(streamServerDir, 'server.js'),
+      `export const handler = async (req, res) => {
+        res.setHeader('Content-Type', 'text/html');
+        res.setHeader('Transfer-Encoding', 'chunked');
+        res.write('<html><head></head>');
+        res.write('<body>streamed</body>');
+        res.end('</html>');
+      };
+      export const apiRoutes = [];
+      export const plugins = [];
+      export const layouts = {};
+      `,
+      'utf-8',
+    )
+
+    await vi.resetModules()
+    const { buildSSG } = await import('../../plugin/build-ssg.js')
+    const config = {
+      root: streamRoot,
+      srcDir: join(streamRoot, 'app'),
+      pagesDir: join(streamRoot, 'app', 'pages'),
+      mode: 'ssg',
+      ssg: { routes: ['/'], concurrency: 1 },
+    } as unknown as ResolvedCerConfig
+    await buildSSG(config)
+
+    const { readFileSync, existsSync } = await import('node:fs')
+    const outPath = join(streamRoot, 'dist', 'index.html')
+    expect(existsSync(outPath)).toBe(true)
+    const html = readFileSync(outPath, 'utf-8')
+    expect(html).toContain('<html><head></head>')
+    expect(html).toContain('<body>streamed</body>')
+    expect(html).toContain('</html>')
+
+    rmSync(streamRoot, { recursive: true, force: true })
+  })
+
   it('uses cached _serverMod on second renderPath call (no double import)', async () => {
     // In a fresh module instance, render two paths sequentially.
     // The second renderPath call hits the !_serverMod === false branch (cache).

package/src/__tests__/plugin/build-ssg.test.ts

@@ -4,6 +4,7 @@ vi.mock('node:fs', () => ({ existsSync: vi.fn().mockReturnValue(false) }))
 vi.mock('node:fs/promises', () => ({
   writeFile: vi.fn().mockResolvedValue(undefined),
   mkdir: vi.fn().mockResolvedValue(undefined),
+  readFile: vi.fn().mockResolvedValue(''),
 }))
 vi.mock('fast-glob', () => ({ default: vi.fn().mockResolvedValue([]) }))
 vi.mock('vite', () => ({
@@ -14,7 +15,7 @@ vi.mock('../../plugin/build-ssr.js', () => ({ buildSSR: vi.fn().mockResolvedValu
 vi.mock('../../plugin/path-utils.js', () => ({ buildRouteEntry: vi.fn() }))
 
 import { existsSync } from 'node:fs'
-import { writeFile, mkdir } from 'node:fs/promises'
+import { writeFile, mkdir, readFile } from 'node:fs/promises'
 import fg from 'fast-glob'
 import { createServer } from 'vite'
 import { buildSSR } from '../../plugin/build-ssr.js'
@@ -38,8 +39,10 @@ beforeEach(() => {
   vi.mocked(writeFile).mockClear()
   vi.mocked(mkdir).mockClear()
   vi.mocked(fg).mockClear()
+  vi.mocked(readFile).mockClear()
   vi.mocked(existsSync).mockReturnValue(false)
   vi.mocked(fg).mockResolvedValue([])
+  vi.mocked(readFile).mockResolvedValue('')
   vi.mocked(buildRouteEntry).mockReset()
 })
 
@@ -263,6 +266,128 @@ describe('buildSSG — path collection', () => {
   })
 })
 
+// ─── render: 'server' / 'spa' skip ───────────────────────────────────────────
+
+describe('buildSSG — render strategy skip (static pages)', () => {
+  it('skips static page with render: server', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/dashboard.ts'])
+    vi.mocked(readFile).mockResolvedValue("export const meta = { render: 'server' }")
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/dashboard',
+      isDynamic: false,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    const config = makeConfig({ ssg: { concurrency: 1 } } as Partial<ResolvedCerConfig>)
+    await buildSSG(config)
+
+    // buildRouteEntry should never be called — page is skipped before it
+    expect(buildRouteEntry).not.toHaveBeenCalled()
+  })
+
+  it('skips static page with render: spa', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/profile.ts'])
+    vi.mocked(readFile).mockResolvedValue("export const meta = { render: 'spa' }")
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/profile',
+      isDynamic: false,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    const config = makeConfig({ ssg: { concurrency: 1 } } as Partial<ResolvedCerConfig>)
+    await buildSSG(config)
+
+    expect(buildRouteEntry).not.toHaveBeenCalled()
+  })
+
+  it('does not skip static page with render: static', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/legal.ts'])
+    vi.mocked(readFile).mockResolvedValue("export const meta = { render: 'static' }")
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/legal',
+      isDynamic: false,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    await buildSSG(makeConfig())
+
+    expect(buildRouteEntry).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not skip static page with no render meta', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/about.ts'])
+    vi.mocked(readFile).mockResolvedValue("component('page-about', () => html`<h1>About</h1>`)")
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/about',
+      isDynamic: false,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    await buildSSG(makeConfig())
+
+    expect(buildRouteEntry).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('buildSSG — render strategy skip (dynamic pages)', () => {
+  it('skips dynamic page with render: server from ssrLoadModule', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/[slug].ts'])
+    vi.mocked(readFile).mockResolvedValue('')
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/:slug',
+      isDynamic: true,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    const closeFn = vi.fn().mockResolvedValue(undefined)
+    vi.mocked(createServer).mockResolvedValue({
+      ssrLoadModule: vi.fn().mockResolvedValue({ meta: { render: 'server' } }),
+      close: closeFn,
+    } as unknown as Awaited<ReturnType<typeof createServer>>)
+
+    const config = makeConfig({ ssg: { concurrency: 1 } } as Partial<ResolvedCerConfig>)
+    await buildSSG(config)
+
+    // Only '/' (always added) — the dynamic route was skipped
+    const manifestCall = vi.mocked(writeFile).mock.calls.find(([p]) =>
+      String(p).includes('ssg-manifest.json'),
+    )
+    const manifest = JSON.parse(String(manifestCall![1]))
+    expect(manifest.paths.length + manifest.errors.length).toBe(1)
+  })
+
+  it('skips dynamic page with render: spa from ssrLoadModule', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/[id].ts'])
+    vi.mocked(readFile).mockResolvedValue('')
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/:id',
+      isDynamic: true,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    const closeFn = vi.fn().mockResolvedValue(undefined)
+    vi.mocked(createServer).mockResolvedValue({
+      ssrLoadModule: vi.fn().mockResolvedValue({ meta: { render: 'spa' } }),
+      close: closeFn,
+    } as unknown as Awaited<ReturnType<typeof createServer>>)
+
+    const config = makeConfig({ ssg: { concurrency: 1 } } as Partial<ResolvedCerConfig>)
+    await buildSSG(config)
+
+    const manifestCall = vi.mocked(writeFile).mock.calls.find(([p]) =>
+      String(p).includes('ssg-manifest.json'),
+    )
+    const manifest = JSON.parse(String(manifestCall![1]))
+    expect(manifest.paths.length + manifest.errors.length).toBe(1)
+  })
+})
+
 // ─── writeRenderedPath ────────────────────────────────────────────────────────
 
 describe('writeRenderedPath', () => {

package/src/__tests__/plugin/dev-server.test.ts

@@ -464,6 +464,97 @@ describe('configureCerDevServer — SSR mode', () => {
   })
 })
 
+// ─── Per-route render mode (SSR mode) ────────────────────────────────────────
+
+describe("configureCerDevServer — per-route render mode in SSR", () => {
+  /** Build a server where virtual:cer-routes returns the given routes array. */
+  function makeServerWithRoutes(
+    pageRoutes: Array<{ path: string; meta?: Record<string, unknown> }>,
+    ssrHandler = vi.fn(async (_req: any, res: any) => res.end('<html>SSR</html>')),
+  ) {
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      if (path.includes('server-api') || path.includes('cer-server-api')) return { apiRoutes: [] }
+      if (path.includes('cer-routes')) return { default: pageRoutes }
+      return { handler: ssrHandler }
+    })
+    configureCerDevServer(server as any, makeConfig({ mode: 'ssr' }))
+    return { middleware: getMiddleware(), ssrHandler }
+  }
+
+  it("calls next() instead of SSR for a route with render: 'spa'", async () => {
+    const { middleware, ssrHandler } = makeServerWithRoutes([
+      { path: '/spa-page', meta: { render: 'spa' } },
+    ])
+    const next = vi.fn()
+    await middleware(
+      createReq({ url: '/spa-page', headers: { accept: 'text/html' } }),
+      createRes(),
+      next,
+    )
+    expect(next).toHaveBeenCalled()
+    expect(ssrHandler).not.toHaveBeenCalled()
+  })
+
+  it("proceeds to SSR for a route with render: 'server'", async () => {
+    const { middleware, ssrHandler } = makeServerWithRoutes([
+      { path: '/server-page', meta: { render: 'server' } },
+    ])
+    await middleware(
+      createReq({ url: '/server-page', headers: { accept: 'text/html' } }),
+      createRes(),
+      vi.fn(),
+    )
+    expect(ssrHandler).toHaveBeenCalled()
+  })
+
+  it("proceeds to SSR for a route with no render meta", async () => {
+    const { middleware, ssrHandler } = makeServerWithRoutes([
+      { path: '/normal-page' },
+    ])
+    await middleware(
+      createReq({ url: '/normal-page', headers: { accept: 'text/html' } }),
+      createRes(),
+      vi.fn(),
+    )
+    expect(ssrHandler).toHaveBeenCalled()
+  })
+
+  it("falls back to SSR when routes module throws during render mode check", async () => {
+    const ssrHandler = vi.fn(async (_req: any, res: any) => res.end('<html>SSR</html>'))
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      if (path.includes('server-api') || path.includes('cer-server-api')) return { apiRoutes: [] }
+      if (path.includes('cer-routes')) throw new Error('module not ready')
+      return { handler: ssrHandler }
+    })
+    configureCerDevServer(server as any, makeConfig({ mode: 'ssr' }))
+    await getMiddleware()(
+      createReq({ url: '/some-page', headers: { accept: 'text/html' } }),
+      createRes(),
+      vi.fn(),
+    )
+    // Despite the routes module throwing, SSR should still run
+    expect(ssrHandler).toHaveBeenCalled()
+  })
+
+  it("does not load routes module in SPA mode (no render mode check needed)", async () => {
+    const { server, getMiddleware } = makeServer()
+    configureCerDevServer(server as any, makeConfig({ mode: 'spa' }))
+    await getMiddleware()(
+      createReq({ url: '/about', headers: { accept: 'text/html' } }),
+      createRes(),
+      vi.fn(),
+    )
+    const routesCalls = (server.ssrLoadModule as any).mock.calls.filter(
+      ([p]: [string]) => p.includes('cer-routes'),
+    )
+    expect(routesCalls).toHaveLength(0)
+  })
+})
+
 // ─── parseBody edge cases ─────────────────────────────────────────────────────
 
 describe('configureCerDevServer — malformed JSON body', () => {

package/src/__tests__/plugin/entry-server-template.test.ts

@@ -33,8 +33,8 @@ describe('entry-server-template (ENTRY_SERVER_TEMPLATE content)', () => {
     expect(src).toContain('@jasonshimmy/custom-elements-runtime')
   })
 
-  it('imports renderToStringWithJITCSSDSD and DSD_POLYFILL_SCRIPT from ssr subpath', () => {
-    expect(src).toContain('renderToStringWithJITCSSDSD')
+  it('imports renderToStreamWithJITCSSDSD and DSD_POLYFILL_SCRIPT from ssr subpath', () => {
+    expect(src).toContain('renderToStreamWithJITCSSDSD')
     expect(src).toContain('DSD_POLYFILL_SCRIPT')
     expect(src).toContain('custom-elements-runtime/ssr')
   })
@@ -94,9 +94,17 @@ describe('entry-server-template (ENTRY_SERVER_TEMPLATE content)', () => {
     expect(src).toContain('_prepareRequest')
   })
 
-  it('uses beginHeadCollection / endHeadCollection around the render', () => {
+  it('calls endHeadCollection() synchronously before any await to avoid race conditions', () => {
     expect(src).toContain('beginHeadCollection()')
     expect(src).toContain('endHeadCollection()')
+    // endHeadCollection must come before reader.read() so concurrent requests
+    // (SSG concurrency > 1) cannot reset the shared globalThis collector between
+    // beginHeadCollection and endHeadCollection.
+    const endIdx = src.indexOf('endHeadCollection()')
+    const readIdx = src.indexOf('reader.read()')
+    expect(endIdx).toBeGreaterThan(-1)
+    expect(readIdx).toBeGreaterThan(-1)
+    expect(endIdx).toBeLessThan(readIdx)
   })
 
   it('passes dsdPolyfill: false to suppress inline polyfill', () => {
@@ -104,8 +112,8 @@ describe('entry-server-template (ENTRY_SERVER_TEMPLATE content)', () => {
   })
 
   it('injects DSD_POLYFILL_SCRIPT before </body>', () => {
-    expect(src).toContain("finalHtml.replace('</body>'")
-    expect(src).toContain('DSD_POLYFILL_SCRIPT')
+    expect(src).toContain("lastIndexOf('</body>')")
+    expect(src).toContain('DSD_POLYFILL_SCRIPT + fromBodyClose')
   })
 
   it('merges SSR html with client template when available', () => {
@@ -124,4 +132,67 @@ describe('entry-server-template (ENTRY_SERVER_TEMPLATE content)', () => {
   it('sets Content-Type header on response', () => {
     expect(src).toContain('text/html; charset=utf-8')
   })
+
+  it('sets Transfer-Encoding: chunked header for streaming', () => {
+    expect(src).toContain('Transfer-Encoding')
+    expect(src).toContain('chunked')
+  })
+
+  it('reads the stream using a reader loop', () => {
+    expect(src).toContain('stream.getReader()')
+    expect(src).toContain('reader.read()')
+  })
+
+  // ─── Error boundary ──────────────────────────────────────────────────────────
+
+  it('imports errorTag from virtual:cer-error', () => {
+    expect(src).toContain('errorTag')
+    expect(src).toContain('virtual:cer-error')
+  })
+
+  it('catches loader errors in _prepareRequest', () => {
+    expect(src).toContain('catch (err)')
+    // The catch block is inside _prepareRequest, before the layout chain
+    const catchIdx = src.indexOf('catch (err)')
+    const prepareIdx = src.indexOf('_prepareRequest')
+    expect(catchIdx).toBeGreaterThan(prepareIdx)
+  })
+
+  it('extracts .status from the thrown error for HTTP status code', () => {
+    expect(src).toContain("'status' in err")
+    expect(src).toContain('err.status')
+  })
+
+  it('defaults to status 500 when thrown error has no .status', () => {
+    expect(src).toContain(': 500')
+  })
+
+  it('renders errorTag component when loader throws and errorTag is set', () => {
+    expect(src).toContain('tag: errorTag')
+  })
+
+  it('logs to console.error when loader throws and no errorTag is defined', () => {
+    expect(src).toContain('console.error')
+    expect(src).toContain('!errorTag')
+  })
+
+  it('propagates status to res.statusCode', () => {
+    expect(src).toContain('res.statusCode = status')
+  })
+
+  it('returns status: null on the happy path', () => {
+    expect(src).toContain('status: null')
+  })
+
+  // ─── ISR production export ───────────────────────────────────────────────────
+
+  it('imports createIsrHandler from the isr subpath', () => {
+    expect(src).toContain('createIsrHandler')
+    expect(src).toContain('vite-plugin-cer-app/isr')
+  })
+
+  it('exports isrHandler wrapping handler with ISR caching', () => {
+    expect(src).toContain('export const isrHandler')
+    expect(src).toContain('createIsrHandler(routes, handler)')
+  })
 })