@jasonshimmy/vite-plugin-cer-app 0.4.6 → 0.6.0

package/docs/routing.md

@@ -172,6 +172,72 @@ export const meta = {
 }
 ```
 
+### `meta.ssg.revalidate`
+
+**Type:** `number` (seconds)
+
+Enables Incremental Static Regeneration (ISR) for the route. When set, the preview server caches the rendered HTML and serves it until the TTL expires. After expiry, stale HTML is served immediately while a fresh render runs in the background (stale-while-revalidate).
+
+```ts
+// app/pages/blog/[slug].ts
+export const meta = {
+  ssg: {
+    revalidate: 60,  // re-render at most once per minute
+    paths: async () => { /* ... */ },
+  },
+}
+```
+
+See [Rendering Modes — ISR](rendering-modes.md#isr--incremental-static-regeneration) for full details.
+
+### `meta.transition`
+
+**Type:** `string | boolean`
+
+Attaches transition metadata to the route. The value is extracted at build time and emitted as `meta.transition` on the route object — the framework does **not** apply any CSS or DOM changes automatically.
+
+```ts
+// app/pages/about.ts
+export const meta = {
+  transition: 'fade',   // stored as route.meta.transition at runtime
+}
+```
+
+Read the value in your navigation handler or layout to implement transitions yourself:
+
+```ts
+import routes from 'virtual:cer-routes'
+const about = routes.find(r => r.path === '/about')
+// about.meta.transition → 'fade'
+```
+
+Example — apply a CSS class during navigation using a plugin:
+
+```ts
+// app/plugins/transitions.ts
+export default {
+  setup({ router }) {
+    router.beforeEach((to) => {
+      const name = to.meta?.transition
+      if (name) document.documentElement.setAttribute('data-transition', String(name))
+      else document.documentElement.removeAttribute('data-transition')
+    })
+  },
+}
+```
+
+```css
+[data-transition="fade"] cer-layout-view {
+  animation: fadeIn 0.2s ease;
+}
+@keyframes fadeIn {
+  from { opacity: 0 }
+  to   { opacity: 1 }
+}
+```
+
+Set to `false` to explicitly mark a page as having no transition (useful when a catch-all or default would otherwise apply one).
+
 ---
 
 ## Route sorting

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

@@ -0,0 +1,100 @@
+/**
+ * Tests for ISR (Incremental Static Regeneration), nested layouts, and
+ * runtimeConfig — features added alongside Nuxt/Next parity improvements.
+ *
+ * ISR and runtimeConfig tests only run in SSR mode (preview server).
+ * Nested-layout tests run in all modes.
+ */
+
+const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg'
+
+// ─── ISR (preview server only) ────────────────────────────────────────────────
+
+if (mode === 'ssr') {
+  describe('ISR — stale-while-revalidate cache', () => {
+    it('request to a route with revalidate returns X-Cache: HIT', () => {
+      // On first render (cache miss) the server renders, caches, then serves
+      // from cache — so all requests within the TTL return HIT.
+      cy.request('/blog/first-post').then((response) => {
+        expect(response.headers['x-cache']).to.equal('HIT')
+      })
+    })
+
+    it('subsequent requests within TTL also return X-Cache: HIT', () => {
+      cy.request('/blog/first-post')
+      cy.request('/blog/first-post').then((response) => {
+        expect(response.headers['x-cache']).to.equal('HIT')
+      })
+    })
+
+    it('X-Cache header is absent on non-revalidate routes', () => {
+      cy.request('/about').then((response) => {
+        expect(response.headers).not.to.have.property('x-cache')
+      })
+    })
+
+    // /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', () => {
+      cy.request('/isr-test').then((response) => {
+        expect(response.headers['x-cache']).to.equal('HIT')
+      })
+    })
+
+    it('second request to a revalidate:0 route returns X-Cache: STALE', () => {
+      cy.request('/isr-test') // prime the cache
+      cy.request('/isr-test').then((response) => {
+        expect(response.headers['x-cache']).to.equal('STALE')
+      })
+    })
+  })
+}
+
+// ─── Nested layouts ────────────────────────────────────────────────────────────
+
+describe('Nested layouts — admin section', () => {
+  it('renders the admin dashboard page', () => {
+    cy.visit('/admin/dashboard')
+    cy.get('[data-cy=admin-dashboard-heading]').should('contain', 'Admin Dashboard')
+  })
+
+  it('renders the outer default layout (site-header, site-nav)', () => {
+    cy.visit('/admin/dashboard')
+    cy.get('[data-cy=site-header]').should('exist')
+    cy.get('[data-cy=site-nav]').should('exist')
+  })
+
+  it('renders the inner admin layout (admin-sidebar, admin-content)', () => {
+    cy.visit('/admin/dashboard')
+    cy.get('[data-cy=admin-layout]').should('exist')
+    cy.get('[data-cy=admin-sidebar]').should('exist')
+    cy.get('[data-cy=admin-content]').should('exist')
+  })
+
+  it('layout-admin is a DOM child of layout-default (layout chain order)', () => {
+    // Verifies the chain ['default', 'admin'] is rendered outermost-first.
+    // layout-admin must be in the light DOM of layout-default, not the other
+    // way around. A CSS descendant selector proves this without needing to
+    // pierce slot boundaries.
+    cy.visit('/admin/dashboard')
+    cy.get('layout-default layout-admin').should('exist')
+  })
+
+  if (mode !== 'spa') {
+    it('admin layout is pre-rendered in initial HTML (SSR/SSG)', () => {
+      cy.request('/admin/dashboard').then((response) => {
+        expect(response.body).to.include('admin-layout')
+        expect(response.body).to.include('Admin Dashboard')
+      })
+    })
+  }
+})
+
+// ─── runtimeConfig ─────────────────────────────────────────────────────────────
+
+describe('runtimeConfig.public', () => {
+  it('renders the appName from runtimeConfig on the admin dashboard', () => {
+    cy.visit('/admin/dashboard')
+    cy.get('[data-cy=admin-app-name]').should('contain', 'Kitchen Sink')
+  })
+})

package/e2e/kitchen-sink/app/layouts/admin.ts

@@ -0,0 +1,13 @@
+component('layout-admin', () => {
+  return html`
+    <div data-cy="admin-layout">
+      <aside data-cy="admin-sidebar">
+        <p>Admin Panel</p>
+        <a href="/admin/dashboard" data-cy="admin-nav-dashboard">Dashboard</a>
+      </aside>
+      <section data-cy="admin-content">
+        <slot></slot>
+      </section>
+    </div>
+  `
+})

package/e2e/kitchen-sink/app/pages/admin/_layout.ts

@@ -0,0 +1 @@
+export default 'admin'

package/e2e/kitchen-sink/app/pages/admin/dashboard.ts

@@ -0,0 +1,11 @@
+component('page-admin-dashboard', () => {
+  const config = useRuntimeConfig()
+  const appName = config.public?.appName ?? 'Kitchen Sink'
+
+  return html`
+    <div>
+      <h1 data-cy="admin-dashboard-heading">Admin Dashboard</h1>
+      <p data-cy="admin-app-name">App: ${appName}</p>
+    </div>
+  `
+})

package/e2e/kitchen-sink/app/pages/blog/[slug].ts

@@ -46,6 +46,7 @@ export const loader = async ({ params }: { params: { slug: string } }) => {
 
 export const meta = {
   ssg: {
+    revalidate: 60,
     paths: async () => [
       { params: { slug: 'first-post' } },
       { params: { slug: 'second-post' } },

package/e2e/kitchen-sink/app/pages/isr-test.ts

@@ -0,0 +1,17 @@
+component('page-isr-test', () => {
+  return html`
+    <div>
+      <h1 data-cy="isr-test-heading">ISR Test</h1>
+      <p data-cy="isr-test-description">
+        This page uses <code>revalidate: 0</code> so every post-first request
+        is immediately stale.
+      </p>
+    </div>
+  `
+})
+
+export const meta = {
+  ssg: {
+    revalidate: 0,
+  },
+}

package/e2e/kitchen-sink/cer.config.ts

@@ -2,4 +2,9 @@
 export default {
   ssg: { routes: 'auto', concurrency: 2 },
   autoImports: { runtime: true, components: true, composables: true },
+  runtimeConfig: {
+    public: {
+      appName: 'Kitchen Sink',
+    },
+  },
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jasonshimmy/vite-plugin-cer-app",
-  "version": "0.4.6",
+  "version": "0.6.0",
   "description": "Nuxt-style meta-framework for @jasonshimmy/custom-elements-runtime",
   "type": "module",
   "keywords": [
@@ -68,7 +68,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 +78,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

@@ -0,0 +1,246 @@
+import { describe, it, expect, vi } from 'vitest'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import {
+  matchRoutePattern,
+  findRevalidate,
+  renderForIsr,
+  serveFromIsrCache,
+  type IsrCacheEntry,
+} from '../../cli/commands/preview-isr.js'
+
+// ─── matchRoutePattern ────────────────────────────────────────────────────────
+
+describe('matchRoutePattern', () => {
+  it('matches identical paths', () => {
+    expect(matchRoutePattern('/about', '/about')).toBe(true)
+  })
+
+  it('matches root path', () => {
+    expect(matchRoutePattern('/', '/')).toBe(true)
+  })
+
+  it('does not match different static paths', () => {
+    expect(matchRoutePattern('/about', '/contact')).toBe(false)
+  })
+
+  it('matches :param segments', () => {
+    expect(matchRoutePattern('/blog/:slug', '/blog/hello-world')).toBe(true)
+  })
+
+  it('does not match when param segment is missing', () => {
+    expect(matchRoutePattern('/blog/:slug', '/blog')).toBe(false)
+  })
+
+  it('matches :param* catch-all against single segment', () => {
+    expect(matchRoutePattern('/:all*', '/about')).toBe(true)
+  })
+
+  it('matches :param* catch-all against multi-segment path', () => {
+    expect(matchRoutePattern('/:all*', '/deeply/nested/path')).toBe(true)
+  })
+
+  it('matches :param* catch-all against root', () => {
+    expect(matchRoutePattern('/:all*', '/')).toBe(true)
+  })
+
+  it('does not match longer path against shorter static pattern', () => {
+    expect(matchRoutePattern('/blog', '/blog/extra')).toBe(false)
+  })
+
+  it('handles trailing slashes gracefully', () => {
+    expect(matchRoutePattern('/about/', '/about')).toBe(true)
+    expect(matchRoutePattern('/about', '/about/')).toBe(true)
+  })
+
+  it('matches multiple :param segments', () => {
+    expect(matchRoutePattern('/users/:id/posts/:postId', '/users/42/posts/99')).toBe(true)
+  })
+
+  it('does not match paths that differ only by a regex wildcard character (dot-safety)', () => {
+    // Without escaping, '/api.v1' regex would be '^/apixv1$' which matches '/apixv1'.
+    // With escaping, the dot is literal and '/apixv1' must not match '/api.v1'.
+    expect(matchRoutePattern('/api.v1/users', '/apixv1/users')).toBe(false)
+  })
+
+  it('matches route with literal dot in static segment', () => {
+    expect(matchRoutePattern('/api.v1/users', '/api.v1/users')).toBe(true)
+  })
+})
+
+// ─── findRevalidate ───────────────────────────────────────────────────────────
+
+describe('findRevalidate', () => {
+  it('returns null for an empty routes array', () => {
+    expect(findRevalidate([], '/about')).toBeNull()
+  })
+
+  it('returns null when no route matches', () => {
+    const routes = [{ path: '/contact', meta: { ssg: { revalidate: 60 } } }]
+    expect(findRevalidate(routes, '/about')).toBeNull()
+  })
+
+  it('returns null when matched route has no meta', () => {
+    const routes = [{ path: '/about' }]
+    expect(findRevalidate(routes, '/about')).toBeNull()
+  })
+
+  it('returns null when matched route has no ssg.revalidate', () => {
+    const routes = [{ path: '/about', meta: { layout: 'default' } }]
+    expect(findRevalidate(routes, '/about')).toBeNull()
+  })
+
+  it('returns revalidate value for a matching static route', () => {
+    const routes = [{ path: '/about', meta: { ssg: { revalidate: 60 } } }]
+    expect(findRevalidate(routes, '/about')).toBe(60)
+  })
+
+  it('returns revalidate value for a matching dynamic route', () => {
+    const routes = [{ path: '/blog/:slug', meta: { ssg: { revalidate: 300 } } }]
+    expect(findRevalidate(routes, '/blog/hello')).toBe(300)
+  })
+
+  it('returns revalidate value for a catch-all route', () => {
+    const routes = [{ path: '/:all*', meta: { ssg: { revalidate: 120 } } }]
+    expect(findRevalidate(routes, '/some/unmatched/path')).toBe(120)
+  })
+
+  it('picks the first matching route when multiple match', () => {
+    const routes = [
+      { path: '/blog/:slug', meta: { ssg: { revalidate: 300 } } },
+      { path: '/:all*', meta: { ssg: { revalidate: 60 } } },
+    ]
+    // /blog/:slug matches first
+    expect(findRevalidate(routes, '/blog/post')).toBe(300)
+  })
+
+  it('ignores non-numeric revalidate values', () => {
+    const routes = [{ path: '/about', meta: { ssg: { revalidate: 'invalid' } } }]
+    expect(findRevalidate(routes, '/about')).toBeNull()
+  })
+})
+
+// ─── renderForIsr ─────────────────────────────────────────────────────────────
+
+describe('renderForIsr', () => {
+  it('captures HTML from the handler', async () => {
+    const handler = (_req: IncomingMessage, res: ServerResponse) => {
+      res.setHeader('Content-Type', 'text/html')
+      res.end('<html>hello</html>')
+    }
+    const entry = await renderForIsr('/about', handler, 60)
+    expect(entry).not.toBeNull()
+    expect(entry!.html).toBe('<html>hello</html>')
+  })
+
+  it('captures status code from the handler', async () => {
+    const handler = (_req: IncomingMessage, res: ServerResponse) => {
+      res.statusCode = 404
+      res.end('Not Found')
+    }
+    const entry = await renderForIsr('/missing', handler, 30)
+    expect(entry!.statusCode).toBe(404)
+  })
+
+  it('captures response headers from the handler', async () => {
+    const handler = (_req: IncomingMessage, res: ServerResponse) => {
+      res.setHeader('Content-Type', 'text/html; charset=utf-8')
+      res.end('<html/>')
+    }
+    const entry = await renderForIsr('/about', handler, 60)
+    expect(entry!.headers['content-type']).toBe('text/html; charset=utf-8')
+  })
+
+  it('sets revalidate to the provided TTL', async () => {
+    const handler = (_req: IncomingMessage, res: ServerResponse) => { res.end('ok') }
+    const entry = await renderForIsr('/about', handler, 300)
+    expect(entry!.revalidate).toBe(300)
+  })
+
+  it('sets revalidating to false on the returned entry', async () => {
+    const handler = (_req: IncomingMessage, res: ServerResponse) => { res.end('ok') }
+    const entry = await renderForIsr('/about', handler, 60)
+    expect(entry!.revalidating).toBe(false)
+  })
+
+  it('returns null when the handler throws', async () => {
+    const handler = () => { throw new Error('boom') }
+    const entry = await renderForIsr('/about', handler as SsrHandlerFn, 60)
+    expect(entry).toBeNull()
+  })
+
+  it('passes the correct URL to the synthetic request', async () => {
+    let capturedUrl = ''
+    const handler = (req: IncomingMessage, res: ServerResponse) => {
+      capturedUrl = req.url ?? ''
+      res.end('ok')
+    }
+    await renderForIsr('/blog/hello', handler, 60)
+    expect(capturedUrl).toBe('/blog/hello')
+  })
+})
+
+type SsrHandlerFn = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>
+
+// ─── serveFromIsrCache ────────────────────────────────────────────────────────
+
+describe('serveFromIsrCache', () => {
+  function makeFakeRes() {
+    const headers: Record<string, string> = {}
+    let statusCode = 200
+    let body = ''
+    const res = {
+      get statusCode() { return statusCode },
+      set statusCode(v: number) { statusCode = v },
+      setHeader: vi.fn((name: string, value: string) => { headers[name] = value }),
+      end: vi.fn((chunk: string) => { body = chunk }),
+      _headers: headers,
+      _body: () => body,
+      _status: () => statusCode,
+    }
+    return res
+  }
+
+  function makeEntry(overrides: Partial<IsrCacheEntry> = {}): IsrCacheEntry {
+    return {
+      html: '<html>cached</html>',
+      headers: { 'content-type': 'text/html' },
+      statusCode: 200,
+      builtAt: Date.now(),
+      revalidate: 60,
+      revalidating: false,
+      ...overrides,
+    }
+  }
+
+  it('writes the cached HTML to the response', () => {
+    const res = makeFakeRes()
+    serveFromIsrCache(makeEntry(), res as unknown as ServerResponse, 'HIT')
+    expect(res.end).toHaveBeenCalledWith('<html>cached</html>')
+  })
+
+  it('sets X-Cache: HIT header', () => {
+    const res = makeFakeRes()
+    serveFromIsrCache(makeEntry(), res as unknown as ServerResponse, 'HIT')
+    expect(res.setHeader).toHaveBeenCalledWith('X-Cache', 'HIT')
+  })
+
+  it('sets X-Cache: STALE header', () => {
+    const res = makeFakeRes()
+    serveFromIsrCache(makeEntry(), res as unknown as ServerResponse, 'STALE')
+    expect(res.setHeader).toHaveBeenCalledWith('X-Cache', 'STALE')
+  })
+
+  it('forwards cached headers to the response', () => {
+    const entry = makeEntry({ headers: { 'content-type': 'text/html; charset=utf-8' } })
+    const res = makeFakeRes()
+    serveFromIsrCache(entry, res as unknown as ServerResponse, 'HIT')
+    expect(res.setHeader).toHaveBeenCalledWith('content-type', 'text/html; charset=utf-8')
+  })
+
+  it('sets the status code from the cache entry', () => {
+    const entry = makeEntry({ statusCode: 404 })
+    const res = makeFakeRes()
+    serveFromIsrCache(entry, res as unknown as ServerResponse, 'HIT')
+    expect(res._status()).toBe(404)
+  })
+})

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/dts-generator.test.ts

@@ -168,6 +168,11 @@ describe('generateAutoImportDts', () => {
     expect(dts).toContain("const useInject: typeof import('@jasonshimmy/vite-plugin-cer-app/composables')['useInject']")
   })
 
+  it('declares useRuntimeConfig as a framework global', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("const useRuntimeConfig: typeof import('@jasonshimmy/vite-plugin-cer-app/composables')['useRuntimeConfig']")
+  })
+
   it('declares when directive as a global', async () => {
     const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
     expect(dts).toContain("const when: typeof import('@jasonshimmy/custom-elements-runtime/directives')['when']")
@@ -233,6 +238,21 @@ describe('generateVirtualModuleDts', () => {
     expect(dts).toContain('errorTag')
   })
 
+  it('declares virtual:cer-app-config module', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("declare module 'virtual:cer-app-config'")
+  })
+
+  it('declares runtimeConfig export in virtual:cer-app-config', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain('runtimeConfig')
+  })
+
+  it('declares RuntimePublicConfig in virtual:cer-app-config', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain('RuntimePublicConfig')
+  })
+
   it('includes user composable re-exports in virtual:cer-composables', async () => {
     const exports = new Map([['useMyThing', `${ROOT}/app/composables/my-thing.ts`]])
     const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR, exports)

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,14 @@ 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()')
+  })
 })