@jasonshimmy/vite-plugin-cer-app 0.23.2 → 0.24.0

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

@@ -1,320 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import {
-  isPathBounded,
-  matchRoutePattern,
-  findRevalidate,
-  findRenderMode,
-  renderForIsr,
-  serveFromIsrCache,
-  type IsrCacheEntry,
-} from '../../cli/commands/preview-isr.js'
-
-// ─── isPathBounded ────────────────────────────────────────────────────────────
-
-describe('isPathBounded', () => {
-  it('allows normal file paths inside the root', () => {
-    expect(isPathBounded('/dist', '/index.html')).toBe(true)
-  })
-
-  it('allows nested paths inside the root', () => {
-    expect(isPathBounded('/dist', '/assets/app.js')).toBe(true)
-  })
-
-  it('allows the root path itself', () => {
-    expect(isPathBounded('/dist', '/')).toBe(true)
-  })
-
-  it('blocks simple path traversal (../ escape)', () => {
-    expect(isPathBounded('/dist', '/../../../../etc/passwd')).toBe(false)
-  })
-
-  it('blocks a path that escapes by one level', () => {
-    expect(isPathBounded('/dist', '/../secret')).toBe(false)
-  })
-
-  it('does not confuse a sibling directory for the root', () => {
-    // /dist-other starts with /dist but is NOT inside /dist
-    expect(isPathBounded('/dist', '/../dist-other/file')).toBe(false)
-  })
-})
-
-// ─── 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()
-  })
-})
-
-// ─── 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', () => {
-  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__/index.test.ts

@@ -1,21 +0,0 @@
-import { describe, it, expect } from 'vitest'
-
-// Import from the main package entry to trigger coverage of src/index.ts
-// re-exports. These are all re-exports of other modules so we just verify
-// the named exports resolve without errors.
-import { defineConfig, cerApp } from '../index.js'
-
-describe('package main entry', () => {
-  it('exports defineConfig', () => {
-    expect(typeof defineConfig).toBe('function')
-  })
-
-  it('defineConfig is a pass-through', () => {
-    const cfg = { mode: 'spa' as const }
-    expect(defineConfig(cfg)).toBe(cfg)
-  })
-
-  it('exports cerApp', () => {
-    expect(typeof cerApp).toBe('function')
-  })
-})

package/src/__tests__/plugin/app-template.test.ts

@@ -1,166 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'pathe'
-import { generateAppEntryTemplate } from '../../runtime/app-template.js'
-import { generateJitInitModule } from '../../plugin/index.js'
-
-const src = readFileSync(
-  resolve(import.meta.dirname, '../../runtime/app-template.ts'),
-  'utf-8',
-)
-
-describe('app-template (source content)', () => {
-  it('does not import virtual:cer-components (components injected per-file by cerComponentImports)', () => {
-    expect(src).not.toContain('virtual:cer-components')
-  })
-
-  it('imports virtual:cer-routes', () => {
-    expect(src).toContain('virtual:cer-routes')
-  })
-
-  it('imports virtual:cer-layouts', () => {
-    expect(src).toContain('virtual:cer-layouts')
-  })
-
-  it('imports virtual:cer-plugins', () => {
-    expect(src).toContain('virtual:cer-plugins')
-  })
-
-  it('imports registerBuiltinComponents from custom-elements-runtime', () => {
-    expect(src).toContain('registerBuiltinComponents')
-    expect(src).toContain('setDevMode')
-    expect(src).toContain('@jasonshimmy/custom-elements-runtime')
-  })
-
-  it('enables runtime dev logging from the downstream Vite env', () => {
-    expect(src).toContain('const _cerRuntimeDev')
-    expect(src).toContain('import.meta.env?.DEV')
-    expect(src).toContain('_cerProcess?.env')
-    expect(src).toContain('(globalThis).__CE_RUNTIME_DEV__ = _cerRuntimeDev')
-    expect(src).toContain('setDevMode(_cerRuntimeDev)')
-  })
-
-  it('imports initRouter from the router subpath', () => {
-    expect(src).toContain('initRouter')
-    expect(src).toContain('custom-elements-runtime/router')
-  })
-
-  it('imports virtual:cer-jit-css', () => {
-    expect(src).toContain('virtual:cer-jit-css')
-  })
-
-  it('imports virtual:cer-jit-init before virtual:cer-layouts so JIT CSS is enabled before elements upgrade', () => {
-    expect(src).toContain('virtual:cer-jit-init')
-    const initIdx = src.indexOf('virtual:cer-jit-init')
-    const layoutsIdx = src.indexOf('virtual:cer-layouts')
-    const pluginsIdx = src.indexOf('virtual:cer-plugins')
-    expect(initIdx).toBeLessThan(layoutsIdx)
-    expect(initIdx).toBeLessThan(pluginsIdx)
-  })
-
-  it('does not import enableJITCSS in the module body (delegated to virtual:cer-jit-init)', () => {
-    // The enableJITCSS import must not appear in the template literal — it belongs
-    // in virtual:cer-jit-init which runs during the static import phase, before
-    // virtual:cer-layouts and virtual:cer-plugins upgrade custom elements.
-    const templateStart = src.indexOf('return `')
-    expect(src.slice(templateStart)).not.toContain("import { enableJITCSS }")
-  })
-
-  it('imports virtual:cer-content-components for markdown-backed custom elements', () => {
-    expect(src).toContain('virtual:cer-content-components')
-  })
-
-  it('exports router', () => {
-    expect(src).toContain('export { router }')
-  })
-})
-
-describe('generateAppEntryTemplate', () => {
-  it('includes virtual:cer-jit-init import', () => {
-    const out = generateAppEntryTemplate()
-    expect(out).toContain("import 'virtual:cer-jit-init'")
-  })
-
-  it('places virtual:cer-jit-init before virtual:cer-layouts and virtual:cer-plugins', () => {
-    const out = generateAppEntryTemplate()
-    const initIdx = out.indexOf('virtual:cer-jit-init')
-    const layoutsIdx = out.indexOf('virtual:cer-layouts')
-    const pluginsIdx = out.indexOf('virtual:cer-plugins')
-    expect(initIdx).toBeGreaterThanOrEqual(0)
-    expect(initIdx).toBeLessThan(layoutsIdx)
-    expect(initIdx).toBeLessThan(pluginsIdx)
-  })
-
-  it('does not import enableJITCSS in the generated output (delegated to virtual:cer-jit-init)', () => {
-    const out = generateAppEntryTemplate()
-    expect(out).not.toContain("import { enableJITCSS }")
-  })
-
-  it('still includes all standard template content', () => {
-    const out = generateAppEntryTemplate()
-    expect(out).toContain('virtual:cer-jit-css')
-    expect(out).toContain('virtual:cer-routes')
-    expect(out).toContain('export { router }')
-  })
-})
-
-describe('generateJitInitModule', () => {
-  it('calls enableJITCSS() with no arguments when no options are set', () => {
-    const out = generateJitInitModule({ content: [], extendedColors: false, customColors: undefined })
-    expect(out).toContain('enableJITCSS()')
-    expect(out).not.toContain('customColors')
-    expect(out).not.toContain('extendedColors')
-  })
-
-  it('calls enableJITCSS() with no arguments when customColors is an empty object', () => {
-    const out = generateJitInitModule({ content: [], extendedColors: false, customColors: {} })
-    expect(out).toContain('enableJITCSS()')
-    expect(out).not.toContain('customColors')
-  })
-
-  it('serializes a single color family into the enableJITCSS call', () => {
-    const out = generateJitInitModule({ content: [], extendedColors: false, customColors: { brand: { '500': '#7c3aed' } } })
-    expect(out).toContain('enableJITCSS({ customColors:')
-    expect(out).toContain('"brand"')
-    expect(out).toContain('"500"')
-    expect(out).toContain('"#7c3aed"')
-  })
-
-  it('serializes multiple color families correctly', () => {
-    const out = generateJitInitModule({
-      content: [],
-      extendedColors: false,
-      customColors: { brand: { '100': '#ede9fe', '900': '#4c1d95' }, accent: { DEFAULT: '#f59e0b' } },
-    })
-    expect(out).toContain('"brand"')
-    expect(out).toContain('"accent"')
-    expect(out).toContain('"DEFAULT"')
-    expect(out).toContain('"#f59e0b"')
-  })
-
-  it('serializes CSS variable references as color values', () => {
-    const out = generateJitInitModule({
-      content: [],
-      extendedColors: false,
-      customColors: { surface: { DEFAULT: 'var(--md-sys-color-surface)' } },
-    })
-    expect(out).toContain('"surface"')
-    expect(out).toContain('var(--md-sys-color-surface)')
-  })
-
-  it('includes extendedColors: true when set', () => {
-    const out = generateJitInitModule({ content: [], extendedColors: true, customColors: undefined })
-    expect(out).toContain('extendedColors: true')
-  })
-
-  it('includes extendedColors array when set', () => {
-    const out = generateJitInitModule({ content: [], extendedColors: ['slate', 'blue'], customColors: undefined })
-    expect(out).toContain('extendedColors: ["slate","blue"]')
-  })
-
-  it('imports enableJITCSS from the jit-css subpath', () => {
-    const out = generateJitInitModule({ content: [], extendedColors: false, customColors: undefined })
-    expect(out).toContain('enableJITCSS')
-    expect(out).toContain('custom-elements-runtime/jit-css')
-  })
-})

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

@@ -1,155 +0,0 @@
-/**
- * Integration tests for the build-ssg renderPath success path.
- *
- * These tests use a real temporary ESM module as the "server bundle" so that
- * the dynamic import() inside renderPath actually resolves, exercising the
- * success branches (writeRenderedPath call, generatedPaths.push, etc.) that
- * are unreachable when the bundle is absent.
- *
- * A separate test file is required so the node:fs/promises mock does NOT
- * shadow the real writeFile/mkdir used to set up the temp bundle.
- */
-import { vi, describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { mkdirSync, writeFileSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'pathe'
-
-// Mock buildSSR so the SSG pipeline skips the Vite build step.
-vi.mock('../../plugin/build-ssr.js', () => ({ buildSSR: vi.fn().mockResolvedValue(undefined) }))
-vi.mock('fast-glob', () => ({ default: vi.fn().mockResolvedValue([]) }))
-// Intentionally NOT mocking node:fs or node:fs/promises so real writes work.
-
-import type { ResolvedCerConfig } from '../../plugin/dev-server.js'
-
-let tmpRoot: string
-
-beforeAll(() => {
-  // Create a minimal "server bundle" that exports a handler.
-  // The handler writes a minimal HTML string to res.end so renderPath captures it.
-  tmpRoot = join(tmpdir(), `cer-ssg-render-${Date.now()}`)
-  const serverDir = join(tmpRoot, 'dist', 'server')
-  mkdirSync(serverDir, { recursive: true })
-  writeFileSync(
-    join(serverDir, 'server.js'),
-    // ESM module — works because Vitest runs with Node's native ESM loader.
-    `export const handler = async (req, res) => {
-      res.setHeader('Content-Type', 'text/html');
-      res.end('<!DOCTYPE html><html><head></head><body>Hello from ' + req.url + '</body></html>');
-    };
-    export const apiRoutes = [];
-    export const plugins = [];
-    export const layouts = {};
-    `,
-    'utf-8',
-  )
-})
-
-afterAll(() => {
-  rmSync(tmpRoot, { recursive: true, force: true })
-})
-
-function makeConfig(overrides: Partial<ResolvedCerConfig> = {}): ResolvedCerConfig {
-  return {
-    root: tmpRoot,
-    srcDir: join(tmpRoot, 'app'),
-    pagesDir: join(tmpRoot, 'app', 'pages'),
-    mode: 'ssg',
-    ssg: { routes: ['/'], concurrency: 1 },
-    ...overrides,
-  } as unknown as ResolvedCerConfig
-}
-
-describe('buildSSG — renderPath success (real server bundle)', () => {
-  it('writes rendered HTML for the root path to dist/index.html', async () => {
-    // Reset module registry so _serverMod cache is cleared between test runs.
-    await vi.resetModules()
-    const { buildSSG } = await import('../../plugin/build-ssg.js')
-    await buildSSG(makeConfig())
-
-    const { readFileSync, existsSync } = await import('node:fs')
-    const outPath = join(tmpRoot, 'dist', 'index.html')
-    expect(existsSync(outPath)).toBe(true)
-    const html = readFileSync(outPath, 'utf-8')
-    expect(html).toContain('Hello from /')
-  })
-
-  it('records the path in the ssg-manifest paths array', async () => {
-    await vi.resetModules()
-    const { buildSSG } = await import('../../plugin/build-ssg.js')
-    await buildSSG(makeConfig())
-
-    const { readFileSync } = await import('node:fs')
-    const manifest = JSON.parse(readFileSync(join(tmpRoot, 'dist', 'ssg-manifest.json'), 'utf-8'))
-    expect(manifest.paths).toContain('/')
-    expect(manifest.errors).toHaveLength(0)
-  })
-
-  it('renders multiple paths with concurrency > 1', async () => {
-    await vi.resetModules()
-    const { buildSSG } = await import('../../plugin/build-ssg.js')
-    const config = makeConfig({ ssg: { routes: ['/', '/about'], concurrency: 2 } } as Partial<ResolvedCerConfig>)
-    await buildSSG(config)
-
-    const { readFileSync, existsSync } = await import('node:fs')
-    expect(existsSync(join(tmpRoot, 'dist', 'index.html'))).toBe(true)
-    expect(existsSync(join(tmpRoot, 'dist', 'about', 'index.html'))).toBe(true)
-    const manifest = JSON.parse(readFileSync(join(tmpRoot, 'dist', 'ssg-manifest.json'), 'utf-8'))
-    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).
-    await vi.resetModules()
-    const { buildSSG } = await import('../../plugin/build-ssg.js')
-    const config = makeConfig({ ssg: { routes: ['/', '/page2'], concurrency: 1 } } as Partial<ResolvedCerConfig>)
-    // Should complete without error — second call uses cached module
-    await expect(buildSSG(config)).resolves.not.toThrow()
-  })
-})