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

package/src/__tests__/runtime/use-state.test.ts

@@ -1,340 +0,0 @@
-/**
- * useState() composable tests.
- *
- * Covers:
- * - Client path: singleton Map on globalThis.__CER_STATE__
- * - SSR path: per-request Map via AsyncLocalStorage (__CER_STATE_STORE__)
- * - SSR→client hydration: __CER_STATE_INIT__ pre-populates client Map
- * - SSR serialization: v.value is readable from ALS Map refs (mirrors entry-server-template)
- * - Full round-trip: SSR ALS → serialize → __CER_STATE_INIT__ → client hydration
- * - Shared ref semantics (same key → same ref)
- * - Factory init called only once
- * - Concurrent SSR isolation
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { AsyncLocalStorage } from 'node:async_hooks'
-import { useState } from '../../runtime/composables/use-state.js'
-
-const g = globalThis as Record<string, unknown>
-
-function cleanup() {
-  delete g['__CER_STATE_STORE__']
-  delete g['__CER_STATE__']
-  delete g['__CER_STATE_INIT__']
-}
-
-// ─── Client path ──────────────────────────────────────────────────────────────
-
-describe('useState() — client path (singleton Map)', () => {
-  beforeEach(cleanup)
-  afterEach(cleanup)
-
-  it('creates a reactive ref with the init value', () => {
-    const title = useState('title', 'Hello')
-    expect(title.value).toBe('Hello')
-  })
-
-  it('returns the same ref object for the same key', () => {
-    const a = useState('counter', 0)
-    const b = useState('counter')
-    expect(a).toBe(b)
-  })
-
-  it('ignores init on subsequent calls for the same key', () => {
-    const a = useState('theme', 'light')
-    const b = useState('theme', 'dark')
-    expect(a.value).toBe('light')
-    expect(b.value).toBe('light')
-    expect(a).toBe(b)
-  })
-
-  it('mutations are visible across all refs sharing the same key', () => {
-    const a = useState('count', 0)
-    const b = useState('count')
-    a.value = 42
-    expect(b.value).toBe(42)
-  })
-
-  it('accepts a factory function as init', () => {
-    const state = useState('complex', () => ({ nested: true }))
-    expect(state.value).toEqual({ nested: true })
-  })
-
-  it('factory is only called once even when useState is called multiple times', () => {
-    let calls = 0
-    const factory = () => { calls++; return 'initial' }
-    useState('factory-key', factory)
-    useState('factory-key', factory)
-    expect(calls).toBe(1)
-  })
-
-  it('different keys produce independent refs', () => {
-    const a = useState('key-a', 1)
-    const b = useState('key-b', 2)
-    a.value = 99
-    expect(b.value).toBe(2)
-  })
-
-  it('works without an init value (value is null)', () => {
-    const state = useState<string | null>('noInit')
-    expect(state.value).toBeNull()
-  })
-
-  it('lazily initializes globalThis.__CER_STATE__ on first call', () => {
-    expect(g['__CER_STATE__']).toBeUndefined()
-    useState('lazy', 'x')
-    expect(g['__CER_STATE__']).toBeDefined()
-  })
-})
-
-// ─── SSR → client hydration ───────────────────────────────────────────────────
-
-describe('useState() — SSR→client hydration (__CER_STATE_INIT__)', () => {
-  beforeEach(cleanup)
-  afterEach(cleanup)
-
-  it('pre-populates the client Map from __CER_STATE_INIT__ on first call', () => {
-    g['__CER_STATE_INIT__'] = { pageTitle: 'SSR Title', count: 42 }
-    const title = useState<string>('pageTitle')
-    expect(title.value).toBe('SSR Title')
-    const count = useState<number>('count')
-    expect(count.value).toBe(42)
-  })
-
-  it('SSR-hydrated value takes precedence over init', () => {
-    g['__CER_STATE_INIT__'] = { pageTitle: 'From Server' }
-    const title = useState<string>('pageTitle', 'Default Title')
-    expect(title.value).toBe('From Server')
-  })
-
-  it('keys not in __CER_STATE_INIT__ still use their init value', () => {
-    g['__CER_STATE_INIT__'] = { pageTitle: 'From Server' }
-    const other = useState<string>('otherKey', 'my-default')
-    expect(other.value).toBe('my-default')
-  })
-
-  it('returns the same ref for a key already hydrated from SSR', () => {
-    g['__CER_STATE_INIT__'] = { foo: 'bar' }
-    const a = useState<string>('foo')
-    const b = useState<string>('foo')
-    expect(a).toBe(b)
-  })
-
-  it('mutations to hydrated refs are shared across all callers', () => {
-    g['__CER_STATE_INIT__'] = { theme: 'light' }
-    const a = useState<string>('theme')
-    const b = useState<string>('theme')
-    a.value = 'dark'
-    expect(b.value).toBe('dark')
-  })
-
-  it('does nothing when __CER_STATE_INIT__ is absent', () => {
-    const state = useState('key', 'client-default')
-    expect(state.value).toBe('client-default')
-  })
-
-  it('ignores __CER_STATE_INIT__ when __CER_STATE__ Map already exists', () => {
-    // Simulate: Map already created before __CER_STATE_INIT__ is checked
-    g['__CER_STATE__'] = new Map()
-    g['__CER_STATE_INIT__'] = { pageTitle: 'Should Be Ignored' }
-    const title = useState<string>('pageTitle', 'From Init Param')
-    // __CER_STATE_INIT__ is skipped because Map already exists; init param is used
-    expect(title.value).toBe('From Init Param')
-  })
-
-  it('hydrates null values from __CER_STATE_INIT__', () => {
-    g['__CER_STATE_INIT__'] = { nullable: null }
-    const state = useState<null>('nullable')
-    expect(state.value).toBeNull()
-  })
-
-  it('hydrates object values from __CER_STATE_INIT__', () => {
-    g['__CER_STATE_INIT__'] = { user: { id: 1, name: 'Alice' } }
-    const state = useState<{ id: number; name: string }>('user')
-    expect(state.value).toEqual({ id: 1, name: 'Alice' })
-  })
-
-  it('hydrates array values from __CER_STATE_INIT__', () => {
-    g['__CER_STATE_INIT__'] = { items: [1, 2, 3] }
-    const state = useState<number[]>('items')
-    expect(state.value).toEqual([1, 2, 3])
-  })
-})
-
-// ─── SSR path ─────────────────────────────────────────────────────────────────
-
-describe('useState() — SSR path (__CER_STATE_STORE__ ALS)', () => {
-  let store: AsyncLocalStorage<Map<string, unknown>>
-
-  beforeEach(() => {
-    cleanup()
-    store = new AsyncLocalStorage()
-    g['__CER_STATE_STORE__'] = store
-  })
-
-  afterEach(cleanup)
-
-  it('creates a ref with the init value inside run()', () => {
-    store.run(new Map(), () => {
-      const title = useState('title', 'SSR Page')
-      expect(title.value).toBe('SSR Page')
-    })
-  })
-
-  it('returns the same ref for the same key within the same run()', () => {
-    store.run(new Map(), () => {
-      const a = useState('counter', 0)
-      const b = useState('counter')
-      expect(a).toBe(b)
-    })
-  })
-
-  it('state written before rendering is visible to layout in same ALS context', () => {
-    store.run(new Map(), () => {
-      // Simulate loader setting state before render
-      const fromLoader = useState('pageTitle', 'Set by loader')
-      // Simulate layout reading state during render
-      const fromLayout = useState('pageTitle', 'Layout fallback')
-      expect(fromLayout.value).toBe('Set by loader')
-      expect(fromLoader).toBe(fromLayout)
-    })
-  })
-
-  it('concurrent requests have isolated state', async () => {
-    const results: string[] = []
-    await Promise.all([
-      store.run(new Map(), async () => {
-        useState('title', 'Request A')
-        await new Promise(r => setTimeout(r, 5))
-        results.push(useState<string>('title').value as string)
-      }),
-      store.run(new Map(), async () => {
-        useState('title', 'Request B')
-        await new Promise(r => setTimeout(r, 1))
-        results.push(useState<string>('title').value as string)
-      }),
-    ])
-    expect(results).toContain('Request A')
-    expect(results).toContain('Request B')
-  })
-
-  it('falls back to client Map when called outside a run() context', () => {
-    // Store is on globalThis but no active run() — getStore() returns undefined
-    const state = useState('fallthrough', 'client-init')
-    expect(state.value).toBe('client-init')
-    expect(g['__CER_STATE__']).toBeDefined()
-  })
-
-  it('ignores client Map when inside ALS context', () => {
-    // Pre-populate the client map with a conflicting value
-    g['__CER_STATE__'] = new Map([['key', { value: 'client-value' }]])
-    store.run(new Map(), () => {
-      const state = useState('key', 'ssr-value')
-      expect(state.value).toBe('ssr-value')
-    })
-  })
-
-  it('accepts a factory init on SSR', () => {
-    store.run(new Map(), () => {
-      const state = useState('data', () => [1, 2, 3])
-      expect(state.value).toEqual([1, 2, 3])
-    })
-  })
-})
-
-// ─── SSR serialization ────────────────────────────────────────────────────────
-//
-// Validates that the Map entries written by useState() on the server expose
-// .value (ref semantics), which is exactly what entry-server-template reads:
-//   for (const [k, v] of _stateMap) { _stateObj[k] = v.value }
-
-describe('useState() — SSR serialization (v.value readable from ALS Map)', () => {
-  let store: AsyncLocalStorage<Map<string, unknown>>
-
-  beforeEach(() => {
-    cleanup()
-    store = new AsyncLocalStorage()
-    g['__CER_STATE_STORE__'] = store
-  })
-
-  afterEach(cleanup)
-
-  it('refs in the ALS Map expose .value matching what was set', () => {
-    store.run(new Map(), () => {
-      useState('pageTitle', 'My Page')
-      const map = store.getStore()!
-      expect(map.size).toBe(1)
-      expect((map.get('pageTitle') as { value: unknown }).value).toBe('My Page')
-    })
-  })
-
-  it('serialization mirrors entry-server-template: Object.fromEntries v.value', () => {
-    store.run(new Map(), () => {
-      useState('title', 'About Us')
-      useState('count', 7)
-      const map = store.getStore()!
-      // Mirror the exact serialization in entry-server-template.ts:
-      //   for (const [k, v] of _stateMap) { _stateObj[k] = v.value }
-      const stateObj: Record<string, unknown> = {}
-      for (const [k, v] of map) { stateObj[k] = (v as { value: unknown }).value }
-      expect(stateObj).toEqual({ title: 'About Us', count: 7 })
-    })
-  })
-
-  it('mutation via .value is reflected in the serialized output', () => {
-    store.run(new Map(), () => {
-      const ref = useState('title', 'Original')
-      ref.value = 'Updated'
-      const map = store.getStore()!
-      expect((map.get('title') as { value: unknown }).value).toBe('Updated')
-    })
-  })
-
-  it('full round-trip: SSR ALS → serialize → __CER_STATE_INIT__ → client hydration', () => {
-    // 1. Server: loader sets state inside ALS context
-    store.run(new Map(), () => {
-      useState<string>('pageTitle').value = 'Page Title from Loader'
-      useState<number>('visitCount', 42)
-
-      // 2. Server: serialize the ALS Map (mirrors entry-server-template logic)
-      const map = store.getStore()!
-      const stateObj: Record<string, unknown> = {}
-      for (const [k, v] of map) { stateObj[k] = (v as { value: unknown }).value }
-
-      // Verify serialized shape is correct before handing it to the client
-      expect(stateObj).toEqual({ pageTitle: 'Page Title from Loader', visitCount: 42 })
-
-      // 3. Server injects window.__CER_STATE_INIT__ = JSON.parse(JSON.stringify(stateObj))
-      //    (JSON round-trip ensures only serializable values survive, as in the real path)
-      g['__CER_STATE_INIT__'] = JSON.parse(JSON.stringify(stateObj))
-    })
-
-    // 4. Client: ALS store is gone; useState() falls through to client path
-    delete g['__CER_STATE_STORE__']
-
-    // 5. Client: first useState() call creates Map from __CER_STATE_INIT__ snapshot
-    const title = useState<string>('pageTitle')
-    const count = useState<number>('visitCount')
-
-    expect(title.value).toBe('Page Title from Loader')
-    expect(count.value).toBe(42)
-
-    // 6. Both callers share the same ref (same key → same ref identity)
-    expect(title).toBe(useState<string>('pageTitle'))
-  })
-})
-
-// ─── Generic types ────────────────────────────────────────────────────────────
-
-describe('useState() — generic type inference', () => {
-  beforeEach(cleanup)
-  afterEach(cleanup)
-
-  it('preserves generic type T', () => {
-    interface User { id: number; name: string }
-    const user = useState<User>('user', { id: 1, name: 'Alice' })
-    expect(user.value.id).toBe(1)
-    expect(user.value.name).toBe('Alice')
-  })
-})

package/src/__tests__/types/config.test.ts

@@ -1,18 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { defineConfig } from '../../types/config.js'
-
-describe('defineConfig', () => {
-  it('returns the config object unchanged', () => {
-    const config = { mode: 'spa' as const, port: 4000 }
-    expect(defineConfig(config)).toBe(config)
-  })
-
-  it('accepts an empty config object', () => {
-    expect(defineConfig({})).toEqual({})
-  })
-
-  it('preserves nested ssg config', () => {
-    const config = { ssg: { routes: ['/a', '/b'], concurrency: 2 } }
-    expect(defineConfig(config)).toEqual(config)
-  })
-})

package/src/cli/adapters/cloudflare.ts

@@ -1,335 +0,0 @@
-/**
- * Cloudflare Pages adapter.
- *
- * Transforms the cer-app `dist/` output into the files needed to deploy on
- * Cloudflare Pages with an edge-side SSR worker.
- *
- * SSR mode:
- *   - Reads dist/client/index.html and inlines it as a string constant in the
- *     generated `_worker.js` (Cloudflare Pages Advanced Mode convention).
- *     The worker sets globalThis.__CER_CLIENT_TEMPLATE__ before dynamically
- *     importing the server bundle, bypassing the node:fs call in server.js.
- *   - Copies content-hashed assets and other public files to dist/ alongside
- *     _worker.js — Cloudflare Pages serves them from the CDN before the worker.
- *   - Writes `wrangler.toml` with nodejs_compat for AsyncLocalStorage + streams.
- *
- * SPA/SSG mode:
- *   - Copies static files to dist/ (already in correct layout after build).
- *   - Writes wrangler.toml pointing at dist/ with no function.
- *
- * Cloudflare Pages Advanced Mode (_worker.js) reference:
- *   https://developers.cloudflare.com/pages/functions/advanced-mode/
- *
- * nodejs_compat compatibility flag reference:
- *   https://developers.cloudflare.com/workers/runtime-apis/nodejs/
- */
-
-import { join } from 'pathe'
-import {
-  existsSync,
-  mkdirSync,
-  writeFileSync,
-  readFileSync,
-  copyFileSync,
-  cpSync,
-  readdirSync,
-  statSync,
-} from 'node:fs'
-
-// ─── Worker bridge template ───────────────────────────────────────────────────
-
-/**
- * Generates the _worker.js content with the client HTML inlined.
- *
- * Key design points:
- * - Sets globalThis.__CER_CLIENT_TEMPLATE__ BEFORE dynamically importing the
- *   server bundle so the bundle's module-init code sees the value instead of
- *   trying readFileSync (which throws in Workers without node:fs).
- * - Uses top-level await (supported in Cloudflare Workers ES modules).
- * - Mirrors the Netlify bridge's Web Request → Node.js mock → Response pattern;
- *   Cloudflare Workers with nodejs_compat support node:stream + AsyncLocalStorage.
- * - Responses are streamed via the Web Streams TransformStream API — chunks written
- *   by the SSR handler are forwarded to the client as they arrive rather than being
- *   buffered until the full page is rendered.
- * - Exports `{ fetch }` — the Cloudflare Pages _worker.js module format.
- */
-function generateWorkerBridge(clientHtml: string): string {
-  // Escape the HTML for embedding in a JS template literal.
-  const escaped = clientHtml.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${')
-
-  return `\
-// Auto-generated by @jasonshimmy/vite-plugin-cer-app — do not edit.
-// Cloudflare Pages _worker.js — Advanced Mode SSR bridge.
-// Requires compatibility_flags = ["nodejs_compat"] in wrangler.toml.
-import { Readable } from 'node:stream'
-
-// Inline the client HTML template so the server bundle does not need node:fs.
-// Must be set before the dynamic import below resolves.
-globalThis.__CER_CLIENT_TEMPLATE__ = \`${escaped}\`
-
-const { isrHandler, apiRoutes, runServerMiddleware, runWithRequestContext } = await import('./server/server.js')
-
-function matchApiPattern(pattern, urlPath) {
-  const pp = pattern.split('/')
-  const up = urlPath.split('/')
-  if (pp.length !== up.length) return null
-  const params = {}
-  for (let i = 0; i < pp.length; i++) {
-    if (pp[i].startsWith(':')) params[pp[i].slice(1)] = decodeURIComponent(up[i])
-    else if (pp[i] !== up[i]) return null
-  }
-  return params
-}
-
-function parseQuery(search) {
-  if (!search) return {}
-  const qs = search.startsWith('?') ? search.slice(1) : search
-  const result = {}
-  for (const part of qs.split('&')) {
-    if (!part) continue
-    const eqIdx = part.indexOf('=')
-    if (eqIdx === -1) result[decodeURIComponent(part)] = ''
-    else result[decodeURIComponent(part.slice(0, eqIdx))] = decodeURIComponent(part.slice(eqIdx + 1))
-  }
-  return result
-}
-
-async function toNodeRequest(webReq) {
-  const url = new URL(webReq.url)
-  const hasBody = webReq.body !== null
-    && webReq.method !== 'GET'
-    && webReq.method !== 'HEAD'
-  const body = hasBody ? Buffer.from(await webReq.arrayBuffer()) : null
-  const req = Object.assign(
-    body ? Readable.from([body]) : Readable.from([]),
-    {
-      url: url.pathname + url.search,
-      method: webReq.method,
-      headers: Object.fromEntries(webReq.headers.entries()),
-    },
-  )
-  req.query = parseQuery(url.search)
-  if (body !== null) {
-    const ct = webReq.headers.get('content-type') ?? ''
-    if (ct.includes('application/json')) {
-      try { req.body = JSON.parse(body.toString('utf-8')) } catch { req.body = undefined }
-    } else {
-      req.body = body
-    }
-  }
-  return req
-}
-
-function createNodeResponse() {
-  const { readable, writable } = new TransformStream()
-  const writer = writable.getWriter()
-  const encoder = new TextEncoder()
-  const headers = {}
-  let _resolve
-  let _ended = false
-  const promise = new Promise((res) => { _resolve = res })
-  const res = {
-    statusCode: 200,
-    setHeader(name, value) { headers[name.toLowerCase()] = String(value) },
-    getHeader(name) { return headers[name.toLowerCase()] },
-    removeHeader(name) { delete headers[name.toLowerCase()] },
-    write(chunk) {
-      if (_ended) return
-      void writer.write(typeof chunk === 'string' ? encoder.encode(chunk) : chunk).catch(() => {})
-    },
-    end(chunk) {
-      if (_ended) return
-      _ended = true
-      if (chunk) void writer.write(typeof chunk === 'string' ? encoder.encode(chunk) : chunk).catch(() => {})
-      void writer.close().catch(() => {})
-      _resolve(new Response(readable, { status: res.statusCode, headers }))
-    },
-    json(data) {
-      this.setHeader('Content-Type', 'application/json; charset=utf-8')
-      this.end(JSON.stringify(data))
-    },
-    status(code) { this.statusCode = code; return this },
-    get writableEnded() { return _ended },
-  }
-  return { res, promise }
-}
-
-async function handleRequest(webReq) {
-  const url = new URL(webReq.url)
-  const urlPath = url.pathname
-  const method = webReq.method ?? 'GET'
-
-  const nodeReq = await toNodeRequest(webReq)
-  const { res, promise } = createNodeResponse()
-
-  // Run server middleware chain (auth, logging, CORS, etc.).
-  if (!(await runServerMiddleware(nodeReq, res))) return promise
-
-  // Route /api/* requests to the API handlers exported by the server bundle.
-  if (urlPath.startsWith('/api/')) {
-    for (const route of (apiRoutes ?? [])) {
-      const params = matchApiPattern(route.path, urlPath)
-      if (params !== null) {
-        nodeReq.params = params
-        const fn = route.handlers[method.toLowerCase()]
-          ?? route.handlers[method.toUpperCase()]
-          ?? route.handlers['default']
-        if (typeof fn === 'function') {
-          // Wrap in request context so useCookie / useSession work in API handlers.
-          runWithRequestContext(nodeReq, res, () => Promise.resolve(fn(nodeReq, res))).catch(() => {
-            if (!res.writableEnded) {
-              res.statusCode = 500
-              res.end(JSON.stringify({ error: 'Internal Server Error' }))
-            }
-          })
-          return promise
-        }
-      }
-    }
-    return new Response('Not Found', { status: 404 })
-  }
-
-  // All other requests: SSR (with ISR for routes that declare meta.ssg.revalidate).
-  isrHandler(nodeReq, res).catch(() => {
-    if (!res.writableEnded) {
-      res.statusCode = 500
-      res.end('Internal Server Error')
-    }
-  })
-  return promise
-}
-
-export default {
-  async fetch(request, _env, _ctx) {
-    return handleRequest(request)
-  },
-}
-`
-}
-
-// ─── Public API ───────────────────────────────────────────────────────────────
-
-export async function runCloudflareAdapter(root: string): Promise<void> {
-  const distDir = join(root, 'dist')
-  if (!existsSync(distDir)) {
-    throw new Error(
-      `[cer-app] No dist/ directory found at ${distDir}. Run 'cer-app build' first.`,
-    )
-  }
-
-  const serverBundle = join(distDir, 'server/server.js')
-  const ssgManifest = join(distDir, 'ssg-manifest.json')
-  const isSSR = existsSync(serverBundle) && !existsSync(ssgManifest)
-
-  if (isSSR) {
-    _buildSSR(root, distDir)
-  } else {
-    _buildStatic(root, distDir)
-  }
-
-  console.log('[cer-app] Cloudflare adapter complete.')
-  if (isSSR) {
-    console.log('  Worker:  dist/_worker.js')
-    console.log('  Static:  dist/')
-    console.log('  Deploy with: wrangler pages deploy dist')
-  } else {
-    console.log('  Deploy with: wrangler pages deploy dist')
-  }
-}
-
-// ─── SSR output ───────────────────────────────────────────────────────────────
-
-function _buildSSR(root: string, distDir: string): void {
-  const clientHtmlPath = join(distDir, 'client/index.html')
-  const clientHtml = existsSync(clientHtmlPath)
-    ? readFileSync(clientHtmlPath, 'utf-8')
-    : ''
-
-  // Write the worker bridge with inlined client HTML.
-  const workerPath = join(distDir, '_worker.js')
-  writeFileSync(workerPath, generateWorkerBridge(clientHtml))
-
-  // P1-4: Warn when the worker file approaches or exceeds Cloudflare's size limits.
-  // Free plan: 1 MB compressed; Paid plan: 10 MB compressed. Check uncompressed as
-  // a conservative proxy — the compressed size will always be smaller.
-  const workerSizeBytes = statSync(workerPath).size
-  const WARN_LIMIT = 900_000   // 900 KB — approaching Free plan limit
-  const ERROR_LIMIT = 9_000_000  // 9 MB — approaching Paid plan limit
-  if (workerSizeBytes > ERROR_LIMIT) {
-    console.error(
-      `[cer-app] Cloudflare _worker.js is ${(workerSizeBytes / 1e6).toFixed(1)} MB — ` +
-      `exceeds the ${(ERROR_LIMIT / 1e6).toFixed(0)} MB limit. Deployment will likely fail.`,
-    )
-    process.exit(1)
-  } else if (workerSizeBytes > WARN_LIMIT) {
-    console.warn(
-      `[cer-app] Cloudflare _worker.js is ${(workerSizeBytes / 1e3).toFixed(0)} KB — ` +
-      `approaching the Cloudflare Free plan 1 MB limit. Consider the Paid plan or reducing bundle size.`,
-    )
-  }
-
-  // Copy assets from dist/client/ into dist/ (at the same URL paths).
-  // Cloudflare Pages CDN serves files in the deploy directory as static first;
-  // requests that don't match a static file fall through to _worker.js.
-  // We deliberately skip index.html so HTML requests hit the SSR worker.
-  _copyClientAssets(join(distDir, 'client'), distDir)
-
-  // wrangler.toml: nodejs_compat for AsyncLocalStorage + node:stream support.
-  _writeWranglerToml(root, true)
-}
-
-// ─── Static (SPA / SSG) output ────────────────────────────────────────────────
-
-function _buildStatic(root: string, distDir: string): void {
-  const clientDir = join(distDir, 'client')
-
-  if (existsSync(clientDir)) {
-    // SSG: pre-rendered HTML lives in dist/; assets in dist/client/.
-    // Move assets alongside the HTML so Cloudflare Pages serves them correctly.
-    _copyClientAssets(clientDir, distDir)
-  }
-  // SPA: everything is already in dist/ — nothing to reorganise.
-
-  _writeWranglerToml(root, false)
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function _writeWranglerToml(root: string, ssrMode: boolean): void {
-  const lines = [
-    '# Auto-generated by @jasonshimmy/vite-plugin-cer-app — do not edit.',
-    'name = "cer-app"',
-    'compatibility_date = "2024-09-23"',
-  ]
-
-  if (ssrMode) {
-    lines.push('compatibility_flags = ["nodejs_compat"]')
-  }
-
-  lines.push('')
-  lines.push('[pages_build_output_dir]')
-  lines.push('dir = "dist"')
-  lines.push('')
-
-  writeFileSync(join(root, 'wrangler.toml'), lines.join('\n'))
-}
-
-/**
- * Copies Vite-hashed assets and other public files (favicon, robots.txt, …)
- * from the client dist directory into `destDir`.
- * Skips index.html — served by the SSR worker or SSG pre-rendering.
- */
-function _copyClientAssets(clientDir: string, destDir: string): void {
-  if (!existsSync(clientDir)) return
-  mkdirSync(destDir, { recursive: true })
-  for (const entry of readdirSync(clientDir)) {
-    if (entry === 'index.html') continue
-    const src = join(clientDir, entry)
-    const dest = join(destDir, entry)
-    if (statSync(src).isDirectory()) {
-      cpSync(src, dest, { recursive: true })
-    } else {
-      copyFileSync(src, dest)
-    }
-  }
-}