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

package/src/plugin/dev-server.ts

@@ -1,377 +0,0 @@
-import type { ViteDevServer } from 'vite'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import { existsSync, readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { join } from 'pathe'
-import { getGeneratedDir } from './generated-dir.js'
-
-export interface ResolvedCerConfig {
-  mode: 'spa' | 'ssr' | 'ssg'
-  srcDir: string
-  root: string
-  contentDir: string
-  pagesDir: string
-  layoutsDir: string
-  componentsDir: string
-  composablesDir: string
-  pluginsDir: string
-  middlewareDir: string
-  serverApiDir: string
-  serverMiddlewareDir: string
-  port: number
-  ssg: { routes: 'auto' | string[]; concurrency: number; fallback: boolean }
-  router: { base?: string; scrollToFragment?: boolean | object }
-  jitCss: { content: string[]; extendedColors: boolean; customColors?: Record<string, Record<string, string>> }
-  autoImports: { components: boolean; composables: boolean; directives: boolean; runtime: boolean }
-  runtimeConfig: { public: Record<string, unknown>; private: import('../types/config.js').RuntimePrivateConfig }
-  auth: import('../types/config.js').AuthConfig | null
-  i18n: { locales: string[]; defaultLocale: string; strategy: 'prefix' | 'prefix_except_default' | 'no_prefix' } | null
-}
-
-/**
- * Reads the raw body from an IncomingMessage as a Buffer.
- */
-function readBody(req: IncomingMessage): Promise<Buffer> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = []
-    req.on('data', (chunk: Buffer) => chunks.push(chunk))
-    req.on('end', () => resolve(Buffer.concat(chunks)))
-    req.on('error', reject)
-  })
-}
-
-/**
- * Parses the request body for JSON content types.
- * Attaches the parsed body (or raw buffer) to `(req as any).body`.
- */
-async function parseBody(req: IncomingMessage): Promise<unknown> {
-  const contentType = req.headers['content-type'] ?? ''
-  const method = req.method?.toUpperCase() ?? 'GET'
-
-  if (!['POST', 'PUT', 'PATCH'].includes(method)) {
-    return undefined
-  }
-
-  const buf = await readBody(req)
-
-  if (contentType.includes('application/json')) {
-    try {
-      return JSON.parse(buf.toString('utf-8'))
-    } catch {
-      return undefined
-    }
-  }
-
-  return buf
-}
-
-/**
- * Extracts route params from a path pattern.
- * e.g. pattern="/api/users/:id", path="/api/users/42" -> { id: "42" }
- */
-function matchApiPath(
-  pattern: string,
-  urlPath: string,
-): Record<string, string> | null {
-  const patternParts = pattern.split('/')
-  const urlParts = urlPath.split('?')[0].split('/')
-
-  if (patternParts.length !== urlParts.length) return null
-
-  const params: Record<string, string> = {}
-  for (let i = 0; i < patternParts.length; i++) {
-    const p = patternParts[i]
-    const u = urlParts[i]
-    if (p.startsWith(':')) {
-      params[p.slice(1)] = decodeURIComponent(u)
-    } else if (p !== u) {
-      return null
-    }
-  }
-
-  return params
-}
-
-/**
- * Parses URL query string into a plain object.
- */
-function parseQuery(url: string): Record<string, string> {
-  const qIndex = url.indexOf('?')
-  if (qIndex === -1) return {}
-  const qs = url.slice(qIndex + 1)
-  const result: Record<string, string> = {}
-  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
-}
-
-/**
- * Tests whether a route path pattern matches a URL path.
- * Mirrors the logic in preview-isr.ts#matchRoutePattern — kept local to
- * avoid a plugin→CLI dependency.
- */
-function _matchDevRoute(pattern: string, urlPath: string): boolean {
-  const norm = (s: string) => s.replace(/\/+$/, '') || '/'
-  if (norm(pattern) === norm(urlPath)) return true
-  const regexStr =
-    '^' +
-    norm(pattern)
-      .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
-      .replace(/:[^/]+\*/g, '.*')
-      .replace(/:[^/]+/g, '[^/]+') +
-    '$'
-  return new RegExp(regexStr).test(norm(urlPath))
-}
-
-function _isHtmlRequest(url: string, acceptHeader: string | string[] | undefined): boolean {
-  const accept = Array.isArray(acceptHeader) ? acceptHeader.join(',') : (acceptHeader ?? '')
-  if (url.startsWith('/api/') || url.startsWith('/@')) return false
-  return (
-    accept.includes('text/html') ||
-    url === '/' ||
-    url === '/index.html' ||
-    !url.includes('.')
-  )
-}
-
-async function _serveSpaShell(
-  server: ViteDevServer,
-  config: ResolvedCerConfig,
-  url: string,
-  res: ServerResponse,
-): Promise<boolean> {
-  const userHtml = resolve(config.root, 'index.html')
-  const cerHtml = join(getGeneratedDir(config.root), 'index.html')
-  const shellPath = existsSync(userHtml) ? userHtml : cerHtml
-  if (!existsSync(shellPath)) return false
-
-  const rawHtml = readFileSync(shellPath, 'utf-8')
-  const transformed = await server.transformIndexHtml(url, rawHtml)
-  res.setHeader('Content-Type', 'text/html; charset=utf-8')
-  res.statusCode = 200
-  res.end(transformed)
-  return true
-}
-
-/**
- * Configures the Vite dev server with:
- * 1. API route handlers from server/api/
- * 2. Server middleware from server/middleware/
- * 3. SSR HTML rendering (when mode is 'ssr')
- */
-export function configureCerDevServer(
-  server: ViteDevServer,
-  config: ResolvedCerConfig,
-): void {
-  server.middlewares.use(async (req: IncomingMessage, res: ServerResponse, next: () => void) => {
-    const url = req.url ?? '/'
-    const method = req.method?.toUpperCase() ?? 'GET'
-    const acceptsHtml = _isHtmlRequest(url, req.headers['accept'])
-
-    // 1. Server middleware from server/middleware/ runs first (CORS, auth, logging, etc.)
-    try {
-      const smMod = await server.ssrLoadModule('virtual:cer-server-middleware')
-      const serverMiddleware = (smMod.serverMiddleware ?? smMod.default ?? []) as Array<{
-        name: string
-        handler: (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => void | Promise<void>
-      }>
-
-      for (const { handler } of serverMiddleware) {
-        if (typeof handler !== 'function') continue
-        let calledNext = false
-        try {
-          await new Promise<void>((resolve, reject) => {
-            Promise.resolve(handler(req, res, (err?: unknown) => {
-              if (err) reject(err)
-              else { calledNext = true; resolve() }
-            })).then(() => { if (!calledNext) resolve() }).catch(reject)
-          })
-        } catch {
-          if (!res.writableEnded) { res.statusCode = 500; res.end('Internal Server Error') }
-          return
-        }
-        if (res.writableEnded || !calledNext) return
-      }
-    } catch {
-      // middleware module not ready — continue
-    }
-
-    // 2. API route handlers from server/api/
-    try {
-      const mod = await server.ssrLoadModule('virtual:cer-server-api')
-      const apiRoutes: Array<{ path: string; handlers: Record<string, unknown> }> =
-        mod.apiRoutes ?? mod.default?.apiRoutes ?? []
-
-      for (const route of apiRoutes) {
-        const params = matchApiPath(route.path, url.split('?')[0])
-        if (params === null) continue
-
-        const query = parseQuery(url)
-        const body = await parseBody(req)
-
-        // Augment request
-        const augmentedReq = req as IncomingMessage & {
-          params: Record<string, string>
-          query: Record<string, string>
-          body: unknown
-        }
-        augmentedReq.params = params
-        augmentedReq.query = query
-        augmentedReq.body = body
-
-        // Augment response with json() and status() helpers
-        const augmentedRes = res as ServerResponse & {
-          json(data: unknown): void
-          status(code: number): typeof augmentedRes
-          _statusCode?: number
-        }
-
-        augmentedRes.json = function (data: unknown) {
-          const json = JSON.stringify(data)
-          this.setHeader('Content-Type', 'application/json')
-          this.end(json)
-        }
-
-        augmentedRes.status = function (code: number) {
-          this.statusCode = code
-          return this
-        }
-
-        // Try to find a handler for the HTTP method. Exports may be GET/POST (uppercase)
-        // or get/post (lowercase); try both plus a 'default' fallback.
-        type RouteHandlerFn = (req: typeof augmentedReq, res: typeof augmentedRes) => void | Promise<void>
-        const handlerKey = method.toLowerCase()
-        const handler =
-          (route.handlers[handlerKey] as RouteHandlerFn | undefined) ??
-          (route.handlers[method.toUpperCase()] as RouteHandlerFn | undefined) ??
-          (route.handlers['default'] as RouteHandlerFn | undefined)
-
-        if (typeof handler === 'function') {
-          try {
-            await handler(augmentedReq, augmentedRes)
-          } catch (err) {
-            server.ssrFixStacktrace(err as Error)
-            console.error(`[cer-app] API handler error at ${route.path}:`, err)
-            res.statusCode = 500
-            res.setHeader('Content-Type', 'application/json')
-            res.end(JSON.stringify({ error: 'Internal Server Error' }))
-          }
-          return
-        }
-      }
-    } catch {
-      // virtual:cer-server-api not yet ready or empty — continue
-    }
-
-    // 3. SPA mode: answer client-routed HTML navigations with the shell directly
-    // so Vite's history fallback never emits an intermediate 404 for valid app routes.
-    if (config.mode === 'spa' && (method === 'GET' || method === 'HEAD') && acceptsHtml) {
-      if (await _serveSpaShell(server, config, url, res)) {
-        return
-      }
-    }
-
-    // 4. SSR/SSG mode: intercept HTML requests and server-render them.
-    // Both 'ssr' and 'ssg' modes run loaders on the server so usePageData()
-    // returns real data during dev — matching production behaviour.
-    // 'spa' mode never runs server loaders, so it falls through to the client bundle.
-    if (config.mode === 'ssr' || config.mode === 'ssg') {
-      if (acceptsHtml) {
-        // Check per-route render mode — skip SSR for 'spa' routes.
-        const urlPathOnly = url.split('?')[0]
-        try {
-          const routesMod = await server.ssrLoadModule('virtual:cer-routes')
-          const pageRoutes = Array.isArray(routesMod.default) ? routesMod.default as Array<{ path: string; meta?: Record<string, unknown> }> : []
-          for (const route of pageRoutes) {
-            if (_matchDevRoute(route.path, urlPathOnly)) {
-              if (route.meta?.render === 'spa') {
-                // In SSR/SSG dev mode, a route with render:'spa' should be served as
-                // the SPA shell (no server rendering). Serve .cer/index.html so the
-                // client bundle boots and handles the route client-side.
-                if (await _serveSpaShell(server, config, url, res)) {
-                  return
-                }
-                next()
-                return
-              }
-              break
-            }
-          }
-        } catch { /* module not ready — continue to SSR */ }
-        try {
-          // Load the SSR entry module from .cer/entry-server.ts (written by
-          // writeGeneratedDir). The production build uses a virtual plugin for
-          // the same template; the dev server needs a real file on disk.
-          const ssrEntry = await server.ssrLoadModule(
-            join(getGeneratedDir(config.root), 'entry-server.ts'),
-          )
-
-          const handler =
-            ssrEntry.handler ?? ssrEntry.default?.handler
-
-          if (typeof handler === 'function') {
-            // In dev mode _clientTemplate inside entry-server.ts is null because
-            // the dist/client/index.html path doesn't exist. Set the global that
-            // the handler reads per-request so the SSR response includes the
-            // Vite client scripts (/@vite/client, HMR, module imports for app.ts).
-            const _userIndexPath = resolve(config.root, 'index.html')
-            const _genIndexPath = join(getGeneratedDir(config.root), 'index.html')
-            const _rawHtml = existsSync(_userIndexPath)
-              ? readFileSync(_userIndexPath, 'utf-8')
-              : existsSync(_genIndexPath)
-                ? readFileSync(_genIndexPath, 'utf-8')
-                : null
-            if (_rawHtml) {
-              ;(globalThis as Record<string, unknown>).__CER_CLIENT_TEMPLATE__ =
-                await server.transformIndexHtml(url, _rawHtml)
-            }
-            try {
-              await handler(req, res)
-            } finally {
-              ;(globalThis as Record<string, unknown>).__CER_CLIENT_TEMPLATE__ = undefined
-            }
-            return
-          }
-
-          // Fallback: render using template + ssrEntry render function
-          const renderFn = ssrEntry.render ?? ssrEntry.default?.render
-
-          if (typeof renderFn === 'function') {
-            const template = await server.transformIndexHtml(
-              url,
-              `<!DOCTYPE html><html><head></head><body><div id="app"></div></body></html>`,
-            )
-
-            const result = await renderFn({ url, req })
-            const rendered = template.replace(
-              '<div id="app"></div>',
-              `<div id="app">${result.html ?? ''}</div>`,
-            )
-
-            res.setHeader('Content-Type', 'text/html; charset=utf-8')
-            res.end(rendered)
-            return
-          }
-        } catch (err) {
-          server.ssrFixStacktrace(err as Error)
-          console.error('[cer-app] SSR render error:', err)
-          res.statusCode = 500
-          res.setHeader('Content-Type', 'text/plain')
-          res.end('SSR Error: ' + String(err))
-          return
-        }
-      }
-    }
-
-    next()
-  })
-}

package/src/plugin/dts-generator.ts

@@ -1,273 +0,0 @@
-import { writeFileSync, mkdirSync, existsSync } from 'node:fs'
-import { readFileSync } from 'node:fs'
-import { join, relative } from 'pathe'
-import { scanDirectory } from './scanner.js'
-import { GENERATED_DIR_NAME } from './generated-dir.js'
-
-/**
- * Writes `.cer/tsconfig.json` containing path aliases for the `~/` prefix
- * plus include/exclude entries so the consumer's `tsconfig.json` only needs:
- *   { "extends": "./.cer/tsconfig.json" }
- */
-export function writeTsconfigPaths(root: string, srcDir: string): void {
-  const cerDir = join(root, GENERATED_DIR_NAME)
-  if (!existsSync(cerDir)) {
-    mkdirSync(cerDir, { recursive: true })
-  }
-
-  // Paths are relative to .cer/ inside the project root, so prefix with ../
-  const srcRel = '../' + relative(root, srcDir).replace(/\\/g, '/')
-  const paths: Record<string, string[]> = {
-    '~/*': [`${srcRel}/*`],
-    '~/pages/*': [`${srcRel}/pages/*`],
-    '~/layouts/*': [`${srcRel}/layouts/*`],
-    '~/components/*': [`${srcRel}/components/*`],
-    '~/composables/*': [`${srcRel}/composables/*`],
-    '~/plugins/*': [`${srcRel}/plugins/*`],
-    '~/middleware/*': [`${srcRel}/middleware/*`],
-    '~/assets/*': [`${srcRel}/assets/*`],
-  }
-
-  const tsconfig = {
-    compilerOptions: { paths },
-    include: [
-      '../app/**/*.ts',
-      '../server/**/*.ts',
-      './**/*.ts',
-      './**/*.d.ts',
-    ],
-    exclude: ['../node_modules', '../dist'],
-  }
-
-  const content = JSON.stringify(tsconfig, null, 2) + '\n'
-  const tsconfigPath = join(cerDir, 'tsconfig.json')
-  // Skip write when content is unchanged to avoid triggering Vite's tsconfig
-  // watcher, which would cause an unnecessary server restart on every dev start.
-  try {
-    if (existsSync(tsconfigPath) && readFileSync(tsconfigPath, 'utf-8') === content) return
-  } catch { /* proceed to write */ }
-  writeFileSync(tsconfigPath, content, 'utf-8')
-}
-
-const RUNTIME_GLOBALS = [
-  'component',
-  'html',
-  'css',
-  'ref',
-  'computed',
-  'watch',
-  'watchEffect',
-  'useProps',
-  'useEmit',
-  'useOnConnected',
-  'useOnDisconnected',
-  'useOnAttributeChanged',
-  'useOnError',
-  'useStyle',
-  'useDesignTokens',
-  'useGlobalStyle',
-  'useExpose',
-  'useSlots',
-  'provide',
-  'inject',
-  'createComposable',
-  'nextTick',
-  'defineModel',
-  'getCurrentComponentContext',
-  'isReactiveState',
-  'unsafeHTML',
-  'decodeEntities',
-  'useTeleport',
-]
-
-const DIRECTIVE_GLOBALS = ['when', 'each', 'match', 'anchorBlock']
-
-const FRAMEWORK_GLOBALS = ['useHead', 'usePageData', 'useInject', 'useRuntimeConfig', 'defineMiddleware', 'defineServerMiddleware', 'useSeoMeta', 'useCookie', 'useSession', 'useAuth', 'useFetch', 'useRoute', 'navigateTo', 'useState', 'useLocale', 'queryContent', 'useContentSearch']
-
-/**
- * Scans a composables directory and returns a map of export name → file path.
- * Uses a simple regex to find exported identifiers.
- */
-export async function scanComposableExports(composablesDir: string): Promise<Map<string, string>> {
-  const result = new Map<string, string>()
-  if (!existsSync(composablesDir)) return result
-
-  const files = await scanDirectory('**/*.ts', composablesDir)
-  const exportPattern = /export\s+(?:async\s+)?(?:function|const|let|var|class)\s+(\w+)/g
-
-  for (const file of files) {
-    const code = readFileSync(file, 'utf-8')
-    exportPattern.lastIndex = 0
-    let match
-    while ((match = exportPattern.exec(code)) !== null) {
-      result.set(match[1], file)
-    }
-  }
-
-  return result
-}
-
-/**
- * Generates the content of `cer-auto-imports.d.ts`.
- * @param root - project root (where the .d.ts file will be written)
- */
-export async function generateAutoImportDts(
-  root: string,
-  composablesDir: string,
-  composableExports?: Map<string, string>,
-): Promise<string> {
-  const exports = composableExports ?? await scanComposableExports(composablesDir)
-
-  const lines: string[] = [
-    '// AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app',
-    '// Do not edit — regenerated automatically on dev server start and build.',
-    '',
-    'export {}',
-    '',
-    'declare global {',
-  ]
-
-  for (const name of RUNTIME_GLOBALS) {
-    lines.push(`  const ${name}: typeof import('@jasonshimmy/custom-elements-runtime')['${name}']`)
-  }
-
-  lines.push('')
-
-  for (const name of DIRECTIVE_GLOBALS) {
-    lines.push(`  const ${name}: typeof import('@jasonshimmy/custom-elements-runtime/directives')['${name}']`)
-  }
-
-  lines.push('')
-
-  for (const name of FRAMEWORK_GLOBALS) {
-    lines.push(`  const ${name}: typeof import('@jasonshimmy/vite-plugin-cer-app/composables')['${name}']`)
-  }
-
-  if (exports.size > 0) {
-    lines.push('')
-    for (const [name, filePath] of exports) {
-      // Use a path relative to .cer/ (one level up from root) so the .d.ts resolves correctly
-      const rel = '../' + relative(root, filePath).replace(/\.ts$/, '')
-      lines.push(`  const ${name}: typeof import('${rel}')['${name}']`)
-    }
-  }
-
-  lines.push('')
-  lines.push('  // Content layer types')
-  lines.push(`  type ContentMeta = import('@jasonshimmy/vite-plugin-cer-app').ContentMeta`)
-  lines.push(`  type ContentItem = import('@jasonshimmy/vite-plugin-cer-app').ContentItem`)
-  lines.push(`  type ContentHeading = import('@jasonshimmy/vite-plugin-cer-app').ContentHeading`)
-  lines.push(`  type ContentSearchResult = import('@jasonshimmy/vite-plugin-cer-app').ContentSearchResult`)
-  lines.push('')
-  lines.push('  // SSR loader data injected as window.__CER_DATA__ by the server.')
-  lines.push('  // Consumed once by usePageData() during client hydration.')
-  lines.push('  // eslint-disable-next-line @typescript-eslint/no-explicit-any')
-  lines.push('  var __CER_DATA__: any')
-  lines.push('  // SSR useState() values injected as window.__CER_STATE_INIT__ by the server.')
-  lines.push('  // Pre-populates the client useState() Map on first use.')
-  lines.push('  // eslint-disable-next-line @typescript-eslint/no-explicit-any')
-  lines.push('  var __CER_STATE_INIT__: any')
-  lines.push('  // App config injected by virtual:cer-app-config at app bootstrap.')
-  lines.push('  // eslint-disable-next-line @typescript-eslint/no-explicit-any')
-  lines.push('  var __CER_APP_CONFIG__: any')
-  lines.push('}')
-  lines.push('')
-
-  return lines.join('\n')
-}
-
-/**
- * Generates the content of `cer-env.d.ts` — a script (non-module) file
- * containing ambient `declare module` declarations for all virtual modules.
- * Must NOT contain `export {}` or any top-level imports/exports.
- */
-export async function generateVirtualModuleDts(
-  root: string,
-  composablesDir: string,
-  composableExports?: Map<string, string>,
-): Promise<string> {
-  const exports = composableExports ?? await scanComposableExports(composablesDir)
-
-  const lines: string[] = [
-    '// AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app',
-    '// Do not edit — regenerated automatically on dev server start and build.',
-    '',
-    `declare module 'virtual:cer-routes' {`,
-    `  import type { Route } from '@jasonshimmy/custom-elements-runtime/router'`,
-    `  const routes: Route[]`,
-    `  export default routes`,
-    `}`,
-    '',
-    `declare module 'virtual:cer-layouts' {}`,
-    '',
-    `declare module 'virtual:cer-plugins' {`,
-    `  import type { AppPlugin } from '@jasonshimmy/vite-plugin-cer-app/types'`,
-    `  const plugins: AppPlugin[]`,
-    `  export default plugins`,
-    `}`,
-    '',
-    `declare module 'virtual:cer-composables' {`,
-  ]
-
-  for (const [name, filePath] of exports) {
-    const rel = '../' + relative(root, filePath).replace(/\.ts$/, '')
-    lines.push(`  export { ${name} } from '${rel}'`)
-  }
-
-  lines.push(`}`)
-  lines.push('')
-  lines.push(`declare module 'virtual:cer-middleware' {`)
-  lines.push(`  const middleware: Record<string, Function>`)
-  lines.push(`  export { middleware }`)
-  lines.push(`}`)
-  lines.push('')
-  lines.push(`declare module 'virtual:cer-server-middleware' {`)
-  lines.push(`  import type { ServerMiddleware } from '@jasonshimmy/vite-plugin-cer-app/types'`)
-  lines.push(`  export const serverMiddleware: Array<{ name: string; handler: ServerMiddleware }>`)
-  lines.push(`  export default serverMiddleware`)
-  lines.push(`}`)
-  lines.push('')
-  lines.push(`declare module 'virtual:cer-loading' {`)
-  lines.push(`  export const hasLoading: boolean`)
-  lines.push(`  export const loadingTag: string | null`)
-  lines.push(`}`)
-  lines.push('')
-  lines.push(`declare module 'virtual:cer-error' {`)
-  lines.push(`  export const hasError: boolean`)
-  lines.push(`  export const errorTag: string | null`)
-  lines.push(`}`)
-  lines.push('')
-  lines.push(`declare module 'virtual:cer-app-config' {`)
-  lines.push(`  import type { RuntimePublicConfig, RuntimePrivateConfig } from '@jasonshimmy/vite-plugin-cer-app/types'`)
-  lines.push(`  export const appConfig: { mode: string; router: Record<string, unknown>; ssg: Record<string, unknown> }`)
-  lines.push(`  export const runtimeConfig: { public: RuntimePublicConfig }`)
-  lines.push(`  /** Server-only — present only in the SSR bundle. Always \`undefined\` in the client bundle. */`)
-  lines.push(`  export const _runtimePrivateDefaults: RuntimePrivateConfig | undefined`)
-  lines.push(`  /** Cookie/session key for the auth session. Derived from the app name. */`)
-  lines.push(`  export const _authSessionKey: string`)
-  lines.push(`  export default appConfig`)
-  lines.push(`}`)
-  lines.push('')
-
-  return lines.join('\n')
-}
-
-/**
- * Writes `auto-imports.d.ts` and `env.d.ts` to `.cer/` inside the project root.
- */
-export async function writeAutoImportDts(
-  root: string,
-  composablesDir: string,
-  composableExports?: Map<string, string>,
-): Promise<void> {
-  const cerDir = join(root, GENERATED_DIR_NAME)
-  if (!existsSync(cerDir)) {
-    mkdirSync(cerDir, { recursive: true })
-  }
-
-  const scanned = composableExports ?? await scanComposableExports(composablesDir)
-  const autoImportsContent = await generateAutoImportDts(root, composablesDir, scanned)
-  const envContent = await generateVirtualModuleDts(root, composablesDir, scanned)
-  writeFileSync(join(cerDir, 'auto-imports.d.ts'), autoImportsContent, 'utf-8')
-  writeFileSync(join(cerDir, 'env.d.ts'), envContent, 'utf-8')
-}