@jasonshimmy/vite-plugin-cer-app 0.1.2 → 0.1.4

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

@@ -1,4 +1,4 @@
-import { vi, describe, it, expect, beforeEach } from 'vitest'
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'pathe'
 
@@ -178,3 +178,95 @@ describe('buildSSR', () => {
     expect(firstCall.define).toEqual({ MY_FLAG: 'true' })
   })
 })
+
+// ─── resolveClientEntry fallback paths ───────────────────────────────────────
+
+describe('buildSSR — resolveClientEntry fallbacks', () => {
+  let buildMock: ReturnType<typeof vi.fn>
+  let existsSyncMock: ReturnType<typeof vi.fn>
+  let buildSSR: (config: ResolvedCerConfig) => Promise<void>
+
+  beforeEach(async () => {
+    const { build } = await import('vite')
+    buildMock = vi.mocked(build)
+    buildMock.mockClear()
+    buildMock.mockResolvedValue(undefined as never)
+
+    const { existsSync } = await import('node:fs')
+    existsSyncMock = vi.mocked(existsSync)
+    ;({ buildSSR } = await import('../../plugin/build-ssr.js'))
+  })
+
+  afterEach(() => {
+    existsSyncMock.mockReturnValue(true) // restore default
+  })
+
+  it('uses index.html when it exists', async () => {
+    existsSyncMock.mockReturnValue(true) // index.html exists
+    await buildSSR(makeConfig())
+    const clientInput = (buildMock.mock.calls[0][0] as any).build.rollupOptions.input
+    expect(clientInput).toMatch(/index\.html$/)
+  })
+
+  it('falls back to entry-client.ts when index.html is absent', async () => {
+    existsSyncMock.mockImplementation((p: unknown) => String(p).endsWith('entry-client.ts'))
+    await buildSSR(makeConfig())
+    const clientInput = (buildMock.mock.calls[0][0] as any).build.rollupOptions.input
+    expect(clientInput).toMatch(/entry-client\.ts$/)
+  })
+
+  it('falls back to app.ts when neither index.html nor entry-client.ts exist', async () => {
+    existsSyncMock.mockReturnValue(false)
+    await buildSSR(makeConfig())
+    const clientInput = (buildMock.mock.calls[0][0] as any).build.rollupOptions.input
+    expect(clientInput).toMatch(/app\.ts$/)
+  })
+})
+
+// ─── Server build virtual plugin callbacks ────────────────────────────────────
+
+describe('buildSSR — virtual server-entry plugin', () => {
+  let buildMock: ReturnType<typeof vi.fn>
+  let buildSSR: (config: ResolvedCerConfig) => Promise<void>
+
+  beforeEach(async () => {
+    const { build } = await import('vite')
+    buildMock = vi.mocked(build)
+    buildMock.mockClear()
+    buildMock.mockResolvedValue(undefined as never)
+    ;({ buildSSR } = await import('../../plugin/build-ssr.js'))
+  })
+
+  async function getServerPlugin() {
+    await buildSSR(makeConfig())
+    const serverCallPlugins: any[] = (buildMock.mock.calls[1][0] as any).plugins ?? []
+    return serverCallPlugins.find((p: any) => p?.name === 'vite-plugin-cer-server-entry')
+  }
+
+  it('server build includes vite-plugin-cer-server-entry plugin', async () => {
+    const plugin = await getServerPlugin()
+    expect(plugin).toBeDefined()
+  })
+
+  it('resolveId returns resolved id for virtual:cer-server-entry', async () => {
+    const plugin = await getServerPlugin()
+    expect(plugin.resolveId('virtual:cer-server-entry')).toBe('\0virtual:cer-server-entry')
+  })
+
+  it('resolveId returns undefined for unknown ids', async () => {
+    const plugin = await getServerPlugin()
+    expect(plugin.resolveId('some-other-id')).toBeUndefined()
+  })
+
+  it('load returns server entry source for resolved id', async () => {
+    const plugin = await getServerPlugin()
+    const source = plugin.load('\0virtual:cer-server-entry')
+    expect(typeof source).toBe('string')
+    expect(source).toContain('AUTO-GENERATED server entry')
+  })
+
+  it('load returns undefined for other ids', async () => {
+    const plugin = await getServerPlugin()
+    expect(plugin.load('something-else')).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,493 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest'
+import { EventEmitter } from 'node:events'
+import { configureCerDevServer } from '../../plugin/dev-server.js'
+import type { ResolvedCerConfig } from '../../plugin/dev-server.js'
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/**
+ * Creates a minimal mock IncomingMessage.
+ * Body events are emitted via setImmediate so they fire after readBody
+ * registers its 'data'/'end' listeners (which happens inside the async
+ * middleware after several awaited ssrLoadModule calls).
+ */
+function createReq(opts: {
+  url?: string
+  method?: string
+  headers?: Record<string, string>
+  body?: string
+} = {}) {
+  const emitter = new EventEmitter()
+  setImmediate(() => {
+    if (opts.body !== undefined) emitter.emit('data', Buffer.from(opts.body))
+    emitter.emit('end')
+  })
+  return Object.assign(emitter, {
+    url: opts.url ?? '/',
+    method: opts.method ?? 'GET',
+    headers: opts.headers ?? {},
+  })
+}
+
+function createRes() {
+  const res: any = { statusCode: 200, setHeader: vi.fn(), end: vi.fn() }
+  return res
+}
+
+function makeConfig(overrides: Partial<ResolvedCerConfig> = {}): ResolvedCerConfig {
+  return {
+    mode: 'spa',
+    root: '/project',
+    srcDir: '/project/app',
+    pagesDir: '/project/app/pages',
+    layoutsDir: '/project/app/layouts',
+    componentsDir: '/project/app/components',
+    composablesDir: '/project/app/composables',
+    pluginsDir: '/project/app/plugins',
+    middlewareDir: '/project/app/middleware',
+    serverApiDir: '/project/server/api',
+    serverMiddlewareDir: '/project/server/middleware',
+    port: 3000,
+    ssr: { dsd: true, streaming: false },
+    ssg: { routes: 'auto', concurrency: 2, fallback: false },
+    router: {},
+    jitCss: { content: [], extendedColors: false },
+    autoImports: { components: true, composables: true, directives: true, runtime: true },
+    ...overrides,
+  } as ResolvedCerConfig
+}
+
+type MockServer = {
+  middlewares: { use: ReturnType<typeof vi.fn> }
+  ssrLoadModule: ReturnType<typeof vi.fn>
+  ssrFixStacktrace: ReturnType<typeof vi.fn>
+}
+
+function makeServer(): { server: MockServer; getMiddleware: () => Function } {
+  const registered: Function[] = []
+  const server: MockServer = {
+    middlewares: { use: vi.fn((fn: Function) => registered.push(fn)) },
+    ssrLoadModule: vi.fn(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      return { apiRoutes: [] }
+    }),
+    ssrFixStacktrace: vi.fn(),
+  }
+  return { server, getMiddleware: () => registered[0] }
+}
+
+// ─── Registration ─────────────────────────────────────────────────────────────
+
+describe('configureCerDevServer — registration', () => {
+  it('registers exactly one middleware via server.middlewares.use', () => {
+    const { server } = makeServer()
+    configureCerDevServer(server as any, makeConfig())
+    expect(server.middlewares.use).toHaveBeenCalledTimes(1)
+    expect(typeof (server.middlewares.use as any).mock.calls[0][0]).toBe('function')
+  })
+})
+
+// ─── Non-API pass-through ─────────────────────────────────────────────────────
+
+describe('configureCerDevServer — non-API pass-through', () => {
+  it('calls next() for a plain page request with no matching routes', async () => {
+    const { server, getMiddleware } = makeServer()
+    configureCerDevServer(server as any, makeConfig())
+    const next = vi.fn()
+    await getMiddleware()(createReq({ url: '/about' }), createRes(), next)
+    expect(next).toHaveBeenCalled()
+  })
+
+  it('calls next() when ssrLoadModule throws (module not ready)', async () => {
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockRejectedValue(new Error('not ready'))
+    configureCerDevServer(server as any, makeConfig())
+    const next = vi.fn()
+    await getMiddleware()(createReq({ url: '/test' }), createRes(), next)
+    expect(next).toHaveBeenCalled()
+  })
+})
+
+// ─── API route matching ───────────────────────────────────────────────────────
+
+describe('configureCerDevServer — API route matching', () => {
+  function makeServerWithRoute(route: { path: string; handlers: Record<string, unknown> }) {
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      return { apiRoutes: [route] }
+    })
+    configureCerDevServer(server as any, makeConfig())
+    return getMiddleware()
+  }
+
+  it('calls GET handler for matching path', async () => {
+    const handler = vi.fn((req: any, res: any) => res.end('ok'))
+    const middleware = makeServerWithRoute({ path: '/api/health', handlers: { get: handler } })
+    const next = vi.fn()
+    await middleware(createReq({ url: '/api/health' }), createRes(), next)
+    expect(handler).toHaveBeenCalled()
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  it('calls uppercase GET handler when lowercase is absent', async () => {
+    const handler = vi.fn((req: any, res: any) => res.end('ok'))
+    const middleware = makeServerWithRoute({ path: '/api/health', handlers: { GET: handler } })
+    await middleware(createReq({ url: '/api/health' }), createRes(), vi.fn())
+    expect(handler).toHaveBeenCalled()
+  })
+
+  it('calls default handler as fallback', async () => {
+    const handler = vi.fn((req: any, res: any) => res.end('ok'))
+    const middleware = makeServerWithRoute({ path: '/api/health', handlers: { default: handler } })
+    await middleware(createReq({ url: '/api/health' }), createRes(), vi.fn())
+    expect(handler).toHaveBeenCalled()
+  })
+
+  it('calls next() when no handler matches the HTTP method', async () => {
+    const middleware = makeServerWithRoute({ path: '/api/health', handlers: {} })
+    const next = vi.fn()
+    await middleware(createReq({ url: '/api/health' }), createRes(), next)
+    expect(next).toHaveBeenCalled()
+  })
+
+  it('does not match when segment counts differ', async () => {
+    const handler = vi.fn()
+    const middleware = makeServerWithRoute({ path: '/api/users/:id', handlers: { get: handler } })
+    const next = vi.fn()
+    await middleware(createReq({ url: '/api/users' }), createRes(), next)
+    expect(handler).not.toHaveBeenCalled()
+    expect(next).toHaveBeenCalled()
+  })
+
+  it('does not match when a static segment differs', async () => {
+    const handler = vi.fn()
+    const middleware = makeServerWithRoute({ path: '/api/posts', handlers: { get: handler } })
+    const next = vi.fn()
+    await middleware(createReq({ url: '/api/users' }), createRes(), next)
+    expect(handler).not.toHaveBeenCalled()
+  })
+
+  it('extracts dynamic route params and attaches to req', async () => {
+    let capturedReq: any
+    const handler = vi.fn((req: any, res: any) => { capturedReq = req; res.end('ok') })
+    const middleware = makeServerWithRoute({ path: '/api/users/:id', handlers: { get: handler } })
+    await middleware(createReq({ url: '/api/users/42' }), createRes(), vi.fn())
+    expect(capturedReq.params).toEqual({ id: '42' })
+  })
+
+  it('attaches parsed query string to req', async () => {
+    let capturedReq: any
+    const handler = vi.fn((req: any, res: any) => { capturedReq = req; res.end('ok') })
+    const middleware = makeServerWithRoute({ path: '/api/search', handlers: { get: handler } })
+    await middleware(createReq({ url: '/api/search?q=hello&page=2' }), createRes(), vi.fn())
+    expect(capturedReq.query).toEqual({ q: 'hello', page: '2' })
+  })
+
+  it('attaches empty query object when no query string', async () => {
+    let capturedReq: any
+    const handler = vi.fn((req: any, res: any) => { capturedReq = req; res.end('ok') })
+    const middleware = makeServerWithRoute({ path: '/api/health', handlers: { get: handler } })
+    await middleware(createReq({ url: '/api/health' }), createRes(), vi.fn())
+    expect(capturedReq.query).toEqual({})
+  })
+
+  it('handles query param with no value (flag style ?active)', async () => {
+    let capturedReq: any
+    const handler = vi.fn((req: any, res: any) => { capturedReq = req; res.end('ok') })
+    const middleware = makeServerWithRoute({ path: '/api/items', handlers: { get: handler } })
+    await middleware(createReq({ url: '/api/items?active' }), createRes(), vi.fn())
+    expect(capturedReq.query).toEqual({ active: '' })
+  })
+
+  it('skips empty segments from double-ampersand query strings', async () => {
+    let capturedReq: any
+    const handler = vi.fn((req: any, res: any) => { capturedReq = req; res.end('ok') })
+    const middleware = makeServerWithRoute({ path: '/api/items', handlers: { get: handler } })
+    await middleware(createReq({ url: '/api/items?a=1&&b=2' }), createRes(), vi.fn())
+    expect(capturedReq.query).toEqual({ a: '1', b: '2' })
+  })
+
+  it('decodes URL-encoded route params', async () => {
+    let capturedReq: any
+    const handler = vi.fn((req: any, res: any) => { capturedReq = req; res.end('ok') })
+    const middleware = makeServerWithRoute({ path: '/api/posts/:slug', handlers: { get: handler } })
+    await middleware(createReq({ url: '/api/posts/hello%20world' }), createRes(), vi.fn())
+    expect(capturedReq.params.slug).toBe('hello world')
+  })
+
+  it('returns 500 when API handler throws', async () => {
+    const handler = vi.fn(() => { throw new Error('oops') })
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      return { apiRoutes: [{ path: '/api/boom', handlers: { get: handler } }] }
+    })
+    configureCerDevServer(server as any, makeConfig())
+    const res = createRes()
+    await getMiddleware()(createReq({ url: '/api/boom' }), res, vi.fn())
+    expect(res.statusCode).toBe(500)
+    expect(res.end).toHaveBeenCalled()
+  })
+})
+
+// ─── Augmented response helpers ───────────────────────────────────────────────
+
+describe('configureCerDevServer — augmented response helpers', () => {
+  function makeServerWithRoute(handler: Function) {
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      return { apiRoutes: [{ path: '/api/test', handlers: { get: handler } }] }
+    })
+    configureCerDevServer(server as any, makeConfig())
+    return getMiddleware()
+  }
+
+  it('res.json() serializes data and sets Content-Type', async () => {
+    const res = createRes()
+    const middleware = makeServerWithRoute((req: any, r: any) => r.json({ ok: true }))
+    await middleware(createReq({ url: '/api/test' }), res, vi.fn())
+    expect(res.setHeader).toHaveBeenCalledWith('Content-Type', 'application/json')
+    expect(res.end).toHaveBeenCalledWith('{"ok":true}')
+  })
+
+  it('res.status() sets statusCode and is chainable', async () => {
+    const res = createRes()
+    const middleware = makeServerWithRoute((req: any, r: any) => r.status(404).end('Not Found'))
+    await middleware(createReq({ url: '/api/test' }), res, vi.fn())
+    expect(res.statusCode).toBe(404)
+    expect(res.end).toHaveBeenCalledWith('Not Found')
+  })
+})
+
+// ─── POST body parsing ────────────────────────────────────────────────────────
+
+describe('configureCerDevServer — POST body parsing', () => {
+  it('parses JSON body for POST request', async () => {
+    let capturedBody: unknown
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      return {
+        apiRoutes: [{
+          path: '/api/items',
+          handlers: { post: (req: any, res: any) => { capturedBody = req.body; res.end('ok') } },
+        }],
+      }
+    })
+    configureCerDevServer(server as any, makeConfig())
+    const req = createReq({
+      url: '/api/items',
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ name: 'test' }),
+    })
+    await getMiddleware()(req, createRes(), vi.fn())
+    expect(capturedBody).toEqual({ name: 'test' })
+  })
+
+  it('returns raw Buffer body for POST with non-JSON content-type', async () => {
+    let capturedBody: unknown
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      return {
+        apiRoutes: [{
+          path: '/api/upload',
+          handlers: { post: (req: any, res: any) => { capturedBody = req.body; res.end('ok') } },
+        }],
+      }
+    })
+    configureCerDevServer(server as any, makeConfig())
+    const req = createReq({
+      url: '/api/upload',
+      method: 'POST',
+      headers: { 'content-type': 'text/plain' },
+      body: 'raw text',
+    })
+    await getMiddleware()(req, createRes(), vi.fn())
+    expect(Buffer.isBuffer(capturedBody)).toBe(true)
+  })
+
+  it('attaches undefined body for GET requests', async () => {
+    let capturedBody: unknown = 'sentinel'
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      return {
+        apiRoutes: [{
+          path: '/api/items',
+          handlers: { get: (req: any, res: any) => { capturedBody = req.body; res.end('ok') } },
+        }],
+      }
+    })
+    configureCerDevServer(server as any, makeConfig())
+    await getMiddleware()(createReq({ url: '/api/items' }), createRes(), vi.fn())
+    expect(capturedBody).toBeUndefined()
+  })
+})
+
+// ─── Server middleware execution ──────────────────────────────────────────────
+
+describe('configureCerDevServer — server middleware', () => {
+  it('runs server middleware before API routes', async () => {
+    const callOrder: string[] = []
+    const smHandler = vi.fn((_req: any, _res: any, next: () => void) => {
+      callOrder.push('sm')
+      next()
+    })
+    const apiHandler = vi.fn((req: any, res: any) => { callOrder.push('api'); res.end('ok') })
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [{ name: 'test', handler: smHandler }] }
+      return { apiRoutes: [{ path: '/api/health', handlers: { get: apiHandler } }] }
+    })
+    configureCerDevServer(server as any, makeConfig())
+    await getMiddleware()(createReq({ url: '/api/health' }), createRes(), vi.fn())
+    expect(callOrder).toEqual(['sm', 'api'])
+  })
+
+  it('stops processing when server middleware does not call next()', async () => {
+    const smHandler = vi.fn((_req: any, res: any) => { res.end('blocked') }) // no next() call
+    const apiHandler = vi.fn()
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [{ name: 'block', handler: smHandler }] }
+      return { apiRoutes: [{ path: '/api/health', handlers: { get: apiHandler } }] }
+    })
+    configureCerDevServer(server as any, makeConfig())
+    await getMiddleware()(createReq({ url: '/api/health' }), createRes(), vi.fn())
+    expect(apiHandler).not.toHaveBeenCalled()
+  })
+})
+
+// ─── SSR mode ─────────────────────────────────────────────────────────────────
+
+describe('configureCerDevServer — SSR mode', () => {
+  it('invokes SSR handler for HTML requests in ssr mode', 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')) return { apiRoutes: [] }
+      // SSR entry module
+      return { handler: ssrHandler }
+    })
+    configureCerDevServer(server as any, makeConfig({ mode: 'ssr' }))
+    const res = createRes()
+    await getMiddleware()(
+      createReq({ url: '/', headers: { accept: 'text/html' } }),
+      res,
+      vi.fn(),
+    )
+    expect(ssrHandler).toHaveBeenCalled()
+  })
+
+  it('does not invoke SSR handler for non-HTML requests (e.g. assets)', async () => {
+    const ssrHandler = vi.fn()
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      if (path.includes('server-api')) return { apiRoutes: [] }
+      return { handler: ssrHandler }
+    })
+    configureCerDevServer(server as any, makeConfig({ mode: 'ssr' }))
+    const next = vi.fn()
+    await getMiddleware()(
+      createReq({ url: '/assets/main.js', headers: { accept: 'application/javascript' } }),
+      createRes(),
+      next,
+    )
+    expect(ssrHandler).not.toHaveBeenCalled()
+    expect(next).toHaveBeenCalled()
+  })
+
+  it('returns 500 and error text when SSR handler throws', async () => {
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      if (path.includes('server-api')) return { apiRoutes: [] }
+      return { handler: async () => { throw new Error('render failed') } }
+    })
+    configureCerDevServer(server as any, makeConfig({ mode: 'ssr' }))
+    const res = createRes()
+    await getMiddleware()(createReq({ url: '/', headers: { accept: 'text/html' } }), res, vi.fn())
+    expect(res.statusCode).toBe(500)
+  })
+
+  it('calls next() for non-HTML in ssr mode without API match', async () => {
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      return { apiRoutes: [] }
+    })
+    configureCerDevServer(server as any, makeConfig({ mode: 'ssr' }))
+    const next = vi.fn()
+    await getMiddleware()(
+      createReq({ url: '/favicon.ico', headers: { accept: 'image/x-icon' } }),
+      createRes(),
+      next,
+    )
+    expect(next).toHaveBeenCalled()
+  })
+
+  it('uses renderFn fallback when SSR entry exports render instead of handler', async () => {
+    const renderFn = vi.fn().mockResolvedValue({ html: '<div>rendered</div>' })
+    const { server, getMiddleware } = makeServer()
+    ;(server as any).transformIndexHtml = vi.fn().mockResolvedValue(
+      '<!DOCTYPE html><html><body><div id="app"></div></body></html>',
+    )
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      if (path.includes('server-api')) return { apiRoutes: [] }
+      return { render: renderFn }
+    })
+    configureCerDevServer(server as any, makeConfig({ mode: 'ssr' }))
+    const res = createRes()
+    await getMiddleware()(createReq({ url: '/', headers: { accept: 'text/html' } }), res, vi.fn())
+    expect(renderFn).toHaveBeenCalled()
+    expect(res.end).toHaveBeenCalledWith(expect.stringContaining('<div>rendered</div>'))
+  })
+
+  it('accepts html request when url is / even without text/html accept header', async () => {
+    const ssrHandler = vi.fn(async (req: any, res: any) => res.end('<html>home</html>'))
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      if (path.includes('server-api')) return { apiRoutes: [] }
+      return { handler: ssrHandler }
+    })
+    configureCerDevServer(server as any, makeConfig({ mode: 'ssr' }))
+    // url='/' triggers acceptsHtml without needing accept header
+    await getMiddleware()(createReq({ url: '/' }), createRes(), vi.fn())
+    expect(ssrHandler).toHaveBeenCalled()
+  })
+})
+
+// ─── parseBody edge cases ─────────────────────────────────────────────────────
+
+describe('configureCerDevServer — malformed JSON body', () => {
+  it('returns undefined when POST body is malformed JSON', async () => {
+    let capturedBody: unknown = 'sentinel'
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      return {
+        apiRoutes: [{
+          path: '/api/items',
+          handlers: { post: (req: any, res: any) => { capturedBody = req.body; res.end('ok') } },
+        }],
+      }
+    })
+    configureCerDevServer(server as any, makeConfig())
+    const req = createReq({
+      url: '/api/items',
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{ invalid json }',
+    })
+    await getMiddleware()(req, createRes(), vi.fn())
+    expect(capturedBody).toBeUndefined()
+  })
+})

package/src/__tests__/plugin/scanner.test.ts

@@ -54,13 +54,27 @@ describe('createWatcher', () => {
     expect(onChange).toHaveBeenCalledWith('change', '/project/app/pages/about.ts')
   })
 
-  it('does not call onChange for files outside all watched directories', () => {
+  it('does not call onChange for files outside all watched directories (add)', () => {
     const onChange = vi.fn()
     createWatcher(watcher as unknown as FSWatcher, ['/project/app/pages'], onChange)
     watcher.emit('add', '/project/other/about.ts')
     expect(onChange).not.toHaveBeenCalled()
   })
 
+  it('does not call onChange for files outside all watched directories (unlink)', () => {
+    const onChange = vi.fn()
+    createWatcher(watcher as unknown as FSWatcher, ['/project/app/pages'], onChange)
+    watcher.emit('unlink', '/project/other/about.ts')
+    expect(onChange).not.toHaveBeenCalled()
+  })
+
+  it('does not call onChange for files outside all watched directories (change)', () => {
+    const onChange = vi.fn()
+    createWatcher(watcher as unknown as FSWatcher, ['/project/app/pages'], onChange)
+    watcher.emit('change', '/project/other/about.ts')
+    expect(onChange).not.toHaveBeenCalled()
+  })
+
   it('cleanup function removes event listeners so no further callbacks fire', () => {
     const onChange = vi.fn()
     const cleanup = createWatcher(watcher as unknown as FSWatcher, ['/project/app/pages'], onChange)