@ossy/app 1.15.0 → 1.15.1

package/cli/build.js

@@ -1,298 +1,51 @@
-import path from 'path';
-import url from 'url';
-import fs from 'fs';
+import fs from 'node:fs'
+import path from 'node:path'
+import url from 'node:url'
 import { pathToFileURL } from 'node:url'
 import { createRequire } from 'node:module'
-import { rollup } from 'rollup';
-import babel from '@rollup/plugin-babel';
+import arg from 'arg'
+import { rollup } from 'rollup'
+import babel from '@rollup/plugin-babel'
 import { nodeResolve as resolveDependencies } from '@rollup/plugin-node-resolve'
 import resolveCommonJsDependencies from '@rollup/plugin-commonjs'
-import { minify as minifyWithTerser } from 'terser'
-import json from "@rollup/plugin-json"
+import json from '@rollup/plugin-json'
+import replace from '@rollup/plugin-replace'
 import nodeExternals from 'rollup-plugin-node-externals'
-import copy from 'rollup-plugin-copy';
-import replace from '@rollup/plugin-replace';
-import arg from 'arg'
+import { minify as minifyWithTerser } from 'terser'
 
 export const PAGE_FILE_PATTERN = /\.page\.(jsx?|tsx?)$/
 export const API_FILE_PATTERN = /\.api\.(mjs|cjs|js)$/
 export const TASK_FILE_PATTERN = /\.task\.(mjs|cjs|js)$/
 const RESOURCE_TEMPLATE_FILE_PATTERN = /\.resource\.js$/
 
-/** Written next to `*.resource.js` under `src/resource-templates/` when that dir exists. */
-export const OSSY_RESOURCE_TEMPLATES_OUT = '.ossy-system-templates.generated.js'
-
-export function minifyBrowserStaticChunks () {
-  return {
-    name: 'minify-browser-static-chunks',
-    async renderChunk (code, chunk, outputOptions) {
-      const fileName = chunk.fileName
-      if (!fileName || !fileName.startsWith('public/static/')) {
-        return null
-      }
-      const useSourceMap =
-        outputOptions.sourcemap === true || typeof outputOptions.sourcemap === 'string'
-      const fmt = outputOptions.format
-      const result = await minifyWithTerser(code, {
-        sourceMap: useSourceMap,
-        module: fmt === 'es' || fmt === 'esm',
-      })
-      const out = result.code ?? code
-      if (useSourceMap && result.map) {
-        const map =
-          typeof result.map === 'string' ? JSON.parse(result.map) : result.map
-        return { code: out, map }
-      }
-      return out
-    },
-  }
-}
-
-/** Subfolder under `build/` for generated pages/api/task entry stubs. */
 export const OSSY_GEN_DIRNAME = '.ossy'
-/** JSON-only manifests (sources + route metadata). */
 export const OSSY_GEN_PAGES_BASENAME = 'pages.generated.json'
 export const OSSY_GEN_API_BASENAME = 'api.generated.json'
 export const OSSY_GEN_TASKS_BASENAME = 'tasks.generated.json'
-/** JSON-only build artifact index (compiled module paths, aligned to generated manifests). */
-export const OSSY_PAGES_BUNDLE_BASENAME = 'pages.bundle.json'
-export const OSSY_API_BUNDLE_BASENAME = 'api.bundle.json'
-export const OSSY_TASKS_BUNDLE_BASENAME = 'tasks.bundle.json'
-/** Small Node loaders (not JSON) that `import()` compiled modules from the bundle manifests. */
-export const OSSY_PAGES_RUNTIME_BASENAME = 'pages.runtime.mjs'
-export const OSSY_API_RUNTIME_BASENAME = 'api.runtime.mjs'
-export const OSSY_TASKS_RUNTIME_BASENAME = 'tasks.runtime.mjs'
-
-export const OSSY_PAGE_MODULES_DIRNAME = 'page-modules'
-
-/** Tiny Rollup inputs that re-export `metadata` so per-page server bundles keep i18n paths. */
-export const OSSY_PAGE_SERVER_ENTRIES_DIRNAME = 'page-server-entries'
-export const OSSY_API_MODULES_DIRNAME = 'api-modules'
-export const OSSY_TASK_MODULES_DIRNAME = 'task-modules'
-
-export const OSSY_MIDDLEWARE_RUNTIME_BASENAME = 'middleware.runtime.js'
-export const OSSY_SERVER_CONFIG_RUNTIME_BASENAME = 'server-config.runtime.mjs'
-export const OSSY_RENDER_PAGE_RUNTIME_BASENAME = 'render-page.task.js'
-
-/** Keep React external across per-page server chunks so `pages.runtime.mjs` shares one React. */
-export const OSSY_PAGE_SERVER_EXTERNAL = [
-  'react',
-  'react-dom',
-  'react-dom/static',
-  'react-dom/client',
-  'react/jsx-runtime',
-]
-
-/** Output directory (relative to buildPath) for SSR bundle. */
-export const OSSY_SSR_DIRNAME = 'ssr'
-
-/** Shared client hydrate entry filename under `.ossy/` */
+export const OSSY_RESOURCE_TEMPLATES_OUT = 'resource-templates.generated.json'
+
 const HYDRATE_ENTRY_FILENAME = 'hydrate-entry.jsx'
-/** Shared SSR entry filename under `.ossy/` */
 const SSR_ENTRY_FILENAME = 'ssr-entry.mjs'
 
-export function ossyGeneratedDir (buildPath) {
+function ossyGeneratedDir (buildPath) {
   return path.join(buildPath, OSSY_GEN_DIRNAME)
 }
 
-export function ensureOssyGeneratedDir (buildPath) {
+function ensureOssyGeneratedDir (buildPath) {
   const dir = ossyGeneratedDir(buildPath)
   fs.mkdirSync(dir, { recursive: true })
   return dir
 }
 
-function relToGeneratedImport (generatedAbs, targetAbs) {
-  return path.relative(path.dirname(generatedAbs), targetAbs).replace(/\\/g, '/')
-}
-
-/** Deletes the entire build output dir, then recreates `build/.ossy` (generated stubs are written next). */
-export function resetOssyBuildDir (buildPath) {
+function resetBuildDir (buildPath) {
   fs.rmSync(buildPath, { recursive: true, force: true })
   ensureOssyGeneratedDir(buildPath)
 }
 
-export function resourceTemplatesDir (cwd = process.cwd()) {
-  return path.join(cwd, 'src', 'resource-templates')
-}
-
-export function discoverResourceTemplateFiles (templatesDir) {
-  if (!fs.existsSync(templatesDir) || !fs.statSync(templatesDir).isDirectory()) {
-    return []
-  }
-  return fs
-    .readdirSync(templatesDir)
-    .filter((n) => RESOURCE_TEMPLATE_FILE_PATTERN.test(n))
-    .map((n) => path.join(templatesDir, n))
-    .sort((a, b) => path.basename(a).localeCompare(path.basename(b)))
-}
-
-export function generateResourceTemplatesBarrelSource ({ outputAbs, templateFilesAbs }) {
-  const lines = [
-    '// Generated by @ossy/app — do not edit',
-    '',
-  ]
-  templateFilesAbs.forEach((f, i) => {
-    const rel = relToGeneratedImport(outputAbs, f)
-    lines.push(`import _resource${i} from './${rel}'`)
-  })
-  lines.push('')
-  lines.push(
-    '/** Built-in resource templates merged into every workspace (with imported templates) in the API. */'
-  )
-  lines.push('export const SystemTemplates = [')
-  templateFilesAbs.forEach((_, i) => {
-    lines.push(`  _resource${i},`)
-  })
-  lines.push(']')
-  lines.push('')
-  return lines.join('\n')
-}
-
-/**
- * If `src/resource-templates/` exists, writes `.ossy-system-templates.generated.js` there.
- * No-op when the directory is missing (e.g. website packages). Runs during `build` / `dev`.
- */
-export function writeResourceTemplatesBarrelIfPresent ({ cwd = process.cwd(), log = true } = {}) {
-  const dir = resourceTemplatesDir(cwd)
-  if (!fs.existsSync(dir)) {
-    return { wrote: false, count: 0, path: null }
-  }
-  const files = discoverResourceTemplateFiles(dir)
-  const outAbs = path.join(dir, OSSY_RESOURCE_TEMPLATES_OUT)
-  fs.writeFileSync(outAbs, generateResourceTemplatesBarrelSource({ outputAbs: outAbs, templateFilesAbs: files }), 'utf8')
-  if (log) {
-    console.log(
-      `[@ossy/app][resource-templates] merged ${files.length} template(s) → ${path.relative(cwd, outAbs)}`
-    )
-  }
-  return { wrote: true, count: files.length, path: outAbs }
-}
-
-/**
- * Rollup plugins for Node-side bundles (pages / API / tasks): externals + Babel JSX.
- */
-export function createOssyAppBundlePlugins ({ nodeEnv }) {
-  return [
-    replace({
-      preventAssignment: true,
-      'process.env.NODE_ENV': JSON.stringify(nodeEnv),
-    }),
-    json(),
-    nodeExternals({
-      deps: false,
-      devDeps: true,
-      peerDeps: false,
-      packagePath: path.join(process.cwd(), 'package.json'),
-    }),
-    resolveCommonJsDependencies(),
-    resolveDependencies({ preferBuiltins: true }),
-    babel({
-      babelHelpers: 'bundled',
-      extensions: ['.jsx', '.tsx'],
-      presets: [['@babel/preset-react', { runtime: 'automatic' }]],
-    }),
-  ]
-}
-
-/**
- * Rollup plugins for the combined SSR + client bundle.
- * `preferBuiltins: true` is correct for the SSR entry (uses `node:stream`); page component code
- * does not import Node built-ins so this is safe for the browser entry as well.
- * `copyPublicFrom` is handled separately before the Rollup call.
- */
-export function createCombinedBundlePlugins ({ nodeEnv }) {
-  return [
-    replace({
-      preventAssignment: true,
-      'process.env.NODE_ENV': JSON.stringify(nodeEnv),
-    }),
-    json(),
-    nodeExternals({
-      deps: false,
-      devDeps: true,
-      peerDeps: false,
-      packagePath: path.join(process.cwd(), 'package.json'),
-    }),
-    resolveCommonJsDependencies(),
-    resolveDependencies({ preferBuiltins: true }),
-    babel({
-      babelHelpers: 'bundled',
-      extensions: ['.jsx', '.tsx'],
-      presets: [['@babel/preset-react', { runtime: 'automatic' }]],
-    }),
-  ]
-}
-
-/** Bundles a single Node ESM file (inline dynamic imports) for SSR / API / tasks. */
-export async function bundleOssyNodeEntry ({ inputPath, outputFile, nodeEnv, onWarn, external }) {
-  const bundle = await rollup({
-    input: inputPath,
-    ...(external && external.length ? { external } : {}),
-    plugins: createOssyAppBundlePlugins({ nodeEnv }),
-    onwarn (warning, defaultHandler) {
-      if (onWarn) {
-        onWarn(warning)
-        return
-      }
-      defaultHandler(warning)
-    },
-  })
-  await bundle.write({
-    file: outputFile,
-    format: 'esm',
-    inlineDynamicImports: true,
-  })
-  await bundle.close()
-}
-
-/**
- * Re-exports middleware and app config via `file:` URLs so `src/*.js` can keep relative imports.
- */
-export function writeAppRuntimeShims ({ middlewareSourcePath, configSourcePath, ossyDir }) {
-  const mwHref = url.pathToFileURL(path.resolve(middlewareSourcePath)).href
-  fs.writeFileSync(
-    path.join(ossyDir, OSSY_MIDDLEWARE_RUNTIME_BASENAME),
-    `// Generated by @ossy/app — do not edit\nexport { default } from '${mwHref}'\n`
-  )
-  const cfgHref = url.pathToFileURL(path.resolve(configSourcePath)).href
-  fs.writeFileSync(
-    path.join(ossyDir, OSSY_SERVER_CONFIG_RUNTIME_BASENAME),
-    `// Generated by @ossy/app — do not edit\nexport { default } from '${cfgHref}'\n`
-  )
-}
-
-/**
- * Copies framework runtime into `build/`: server, worker entry, proxy.
- * Middleware loads via `./.ossy/middleware.runtime.js`.
- */
-export function copyOssyAppRuntime ({ scriptDir, buildPath }) {
-  const require = createRequire(import.meta.url)
-  const platformServerPath = require.resolve('@ossy/platform/server')
-  const platformWorkerPath = require.resolve('@ossy/platform/worker')
-  const platformDir = path.dirname(platformServerPath)
-  const platformWorkerDir = path.dirname(platformWorkerPath)
-  for (const name of ['server.js', 'proxy-internal.js']) {
-    fs.copyFileSync(path.join(platformDir, name), path.join(buildPath, name))
-  }
-  const taskRuntimeFiles = fs
-    .readdirSync(scriptDir, { withFileTypes: true })
-    .filter((ent) => ent.isFile() && ent.name.endsWith('.task.js'))
-    .map((ent) => ent.name)
-  for (const name of taskRuntimeFiles) {
-    fs.copyFileSync(path.join(scriptDir, name), path.join(buildPath, name))
-  }
-  fs.copyFileSync(path.join(platformWorkerDir, 'worker-entry.js'), path.join(buildPath, 'worker.js'))
-  fs.copyFileSync(path.join(platformWorkerDir, 'worker-runtime.js'), path.join(buildPath, 'worker-runtime.js'))
-  const ossyOut = ossyGeneratedDir(buildPath)
-  fs.copyFileSync(
-    path.join(scriptDir, OSSY_RENDER_PAGE_RUNTIME_BASENAME),
-    path.join(ossyOut, OSSY_RENDER_PAGE_RUNTIME_BASENAME)
-  )
+function relToGeneratedImport (generatedAbs, targetAbs) {
+  return path.relative(path.dirname(generatedAbs), targetAbs).replace(/\\/g, '/')
 }
 
-/**
- * Recursively lists files under `srcDir` whose basename matches `filePattern` (e.g. `/\.api\.js$/`).
- */
 export function discoverFilesByPattern (srcDir, filePattern) {
   const dir = path.resolve(srcDir)
   if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
@@ -311,162 +64,31 @@ export function discoverFilesByPattern (srcDir, filePattern) {
   return files.sort()
 }
 
-export function writeOssyJson (filePath, data) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true })
-  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8')
-}
-
-/** JSON manifest: discovered API source paths (posix, relative to `cwd`). */
-export function buildApiManifestPayload (apiFiles, cwd = process.cwd()) {
-  return apiFiles.map((f) => path.relative(cwd, f).replace(/\\/g, '/'))
-}
-
-/** JSON manifest: discovered task source paths (posix, relative to `cwd`). */
 export function buildTasksManifestPayload (taskFiles, cwd = process.cwd()) {
   return taskFiles.map((f) => path.relative(cwd, f).replace(/\\/g, '/'))
 }
 
-/**
- * Writes `build/.ossy/api.generated.json` (sources only).
- * Compiled modules + `api.bundle.json` are produced by {@link compileOssyNodeArtifacts}.
- */
-export function resolveApiSource ({ srcDir, buildPath, cwd = process.cwd() }) {
-  ensureOssyGeneratedDir(buildPath)
-  const generatedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_API_BASENAME)
-  const apiFiles = discoverFilesByPattern(srcDir, API_FILE_PATTERN)
-  writeOssyJson(generatedPath, buildApiManifestPayload(apiFiles, cwd))
-  return { apiGeneratedPath: generatedPath, apiOverviewFiles: apiFiles }
-}
-
-/**
- * Writes `build/.ossy/tasks.generated.json` (sources only).
- */
-export function resolveTaskSource ({ srcDir, buildPath, cwd = process.cwd() }) {
-  ensureOssyGeneratedDir(buildPath)
-  const generatedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_TASKS_BASENAME)
-  const taskFiles = discoverFilesByPattern(srcDir, TASK_FILE_PATTERN)
-  writeOssyJson(generatedPath, buildTasksManifestPayload(taskFiles, cwd))
-  return { tasksGeneratedPath: generatedPath, taskOverviewFiles: taskFiles }
-}
-
-export async function compilePageServerModules ({
-  pageFiles,
-  srcDir,
-  ossyDir,
-  nodeEnv,
-  onWarn,
-}) {
-  const modsDir = path.join(ossyDir, OSSY_PAGE_MODULES_DIRNAME)
-  const entriesDir = path.join(ossyDir, OSSY_PAGE_SERVER_ENTRIES_DIRNAME)
-  fs.rmSync(modsDir, { recursive: true, force: true })
-  fs.rmSync(entriesDir, { recursive: true, force: true })
-  if (pageFiles.length === 0) {
-    return []
-  }
-  fs.mkdirSync(modsDir, { recursive: true })
-  fs.mkdirSync(entriesDir, { recursive: true })
-  const bundlePages = []
-  for (const f of pageFiles) {
-    const pageId = clientHydrateIdForPage(f, srcDir)
-    const safeId = String(pageId).replace(/[^a-zA-Z0-9_-]+/g, '-') || 'page'
-    const relPath = pageServerModuleRelPath(f, srcDir)
-    const outName = path.posix.basename(relPath)
-    const outFile = path.join(modsDir, outName)
-    const stubPath = path.join(entriesDir, `${safeId}.mjs`)
-    writePageServerRollupEntry({ pageAbsPath: f, stubPath })
-    await bundleOssyNodeEntry({
-      inputPath: stubPath,
-      outputFile: outFile,
-      nodeEnv,
-      onWarn,
-      external: OSSY_PAGE_SERVER_EXTERNAL,
-    })
-    bundlePages.push({
-      id: pageId,
-      module: relPath,
-    })
-  }
-  return bundlePages
-}
-
-export async function compileApiServerModules ({ apiFiles, ossyDir, nodeEnv, onWarn }) {
-  const modsDir = path.join(ossyDir, OSSY_API_MODULES_DIRNAME)
-  fs.rmSync(modsDir, { recursive: true, force: true })
-  if (apiFiles.length === 0) {
-    return []
-  }
-  fs.mkdirSync(modsDir, { recursive: true })
-  const routes = []
-  for (let i = 0; i < apiFiles.length; i++) {
-    const outName = `api-${i}.mjs`
-    const outFile = path.join(modsDir, outName)
-    await bundleOssyNodeEntry({
-      inputPath: apiFiles[i],
-      outputFile: outFile,
-      nodeEnv,
-      onWarn,
-    })
-    let meta = {}
-    try {
-      const mod = await import(pathToFileURL(outFile).href)
-      meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
-    } catch {
-      // metadata unreadable — skip
+export function parseIdPathPairsFromFile (filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8')
+    const items = []
+    const idPathPattern = /\{\s*id\s*:\s*['"]([^'"]*)['"]\s*,\s*path\s*:\s*['"]([^'"]*)['"]/g
+    let m
+    while ((m = idPathPattern.exec(content)) !== null) {
+      items.push({ id: m[1], path: m[2] })
     }
-    routes.push({ ...meta, module: `${OSSY_API_MODULES_DIRNAME}/${outName}` })
-  }
-  return routes
-}
-
-export async function compileTaskServerModules ({ taskFiles, ossyDir, nodeEnv, onWarn }) {
-  const modsDir = path.join(ossyDir, OSSY_TASK_MODULES_DIRNAME)
-  fs.rmSync(modsDir, { recursive: true, force: true })
-  if (taskFiles.length === 0) {
+    return items
+  } catch {
     return []
   }
-  fs.mkdirSync(modsDir, { recursive: true })
-  const tasks = []
-  for (let i = 0; i < taskFiles.length; i++) {
-    const outName = `task-${i}.mjs`
-    const outFile = path.join(modsDir, outName)
-    await bundleOssyNodeEntry({
-      inputPath: taskFiles[i],
-      outputFile: outFile,
-      nodeEnv,
-      onWarn,
-    })
-    let meta = {}
-    try {
-      const mod = await import(pathToFileURL(outFile).href)
-      meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
-    } catch {
-      // metadata unreadable — skip
-    }
-    tasks.push({ ...meta, module: `${OSSY_TASK_MODULES_DIRNAME}/${outName}` })
-  }
-  return tasks
 }
 
-/**
- * Compiles server-side artifacts: API modules and task modules.
- * SSR page bundles are now produced by the combined Rollup pass in compileCombinedBundle.
- */
-export async function compileOssyNodeArtifacts ({
-  apiFiles,
-  taskFiles,
-  ossyDir,
-  nodeEnv,
-  onWarn,
-}) {
-  const [apiRouteList, taskList] = await Promise.all([
-    compileApiServerModules({ apiFiles, ossyDir, nodeEnv, onWarn }),
-    compileTaskServerModules({ taskFiles, ossyDir, nodeEnv, onWarn }),
-  ])
-  writeOssyJson(path.join(ossyDir, OSSY_GEN_API_BASENAME), apiRouteList)
-  writeOssyJson(path.join(ossyDir, OSSY_GEN_TASKS_BASENAME), taskList)
+function writeJson (filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8')
 }
 
-export function filePathToRoute(filePath, srcDir) {
+function filePathToRoute (filePath, srcDir) {
   const rel = path.relative(srcDir, filePath).replace(/\\/g, '/')
   let pathPart = rel.replace(PAGE_FILE_PATTERN, '').replace(/\/index$/, '').replace(/\/home$/, '') || 'home'
   if (pathPart === 'index' || pathPart === 'home') pathPart = 'home'
@@ -475,30 +97,7 @@ export function filePathToRoute(filePath, srcDir) {
   return { id, path: routePath }
 }
 
-/**
- * Basename for `/static/<id>.js` (per-page client bundle) must match `route.id` after `metadata` is merged in `toPage`
- * (`{ ...derived, ...metadata }`). Uses a light `metadata` scan when possible.
- */
-export function clientHydrateIdForPage (pageAbsPath, srcDir) {
-  const derived = filePathToRoute(pageAbsPath, srcDir)
-  let src = ''
-  try {
-    src = fs.readFileSync(pageAbsPath, 'utf8')
-  } catch {
-    return derived.id
-  }
-  const metaIdx = src.indexOf('export const metadata')
-  if (metaIdx === -1) return derived.id
-  const after = src.slice(metaIdx)
-  const idMatch = after.match(/\bid\s*:\s*['"]([^'"]+)['"]/)
-  return idMatch ? idMatch[1] : derived.id
-}
-
-/**
- * Like `clientHydrateIdForPage` but also extracts `path` from `metadata`.
- * Used to embed the static page route map directly into the SSR entry.
- */
-export function pageRouteFromSource (pageAbsPath, srcDir) {
+function pageRouteFromSource (pageAbsPath, srcDir) {
   const derived = filePathToRoute(pageAbsPath, srcDir)
   try {
     const src = fs.readFileSync(pageAbsPath, 'utf8')
@@ -507,9 +106,7 @@ export function pageRouteFromSource (pageAbsPath, srcDir) {
     const after = src.slice(metaIdx)
     const id = after.match(/\bid\s*:\s*['"]([^'"]+)['"]/)?.[1] ?? derived.id
     const strPath = after.match(/\bpath\s*:\s*['"]([^'"]+)['"]/)?.[1]
-    if (strPath) {
-      return { id, path: strPath }
-    }
+    if (strPath) return { id, path: strPath }
     const pathObjBody = after.match(/\bpath\s*:\s*\{([\s\S]*?)\}/)?.[1]
     if (pathObjBody) {
       const languagePathEntries = [...pathObjBody.matchAll(/([A-Za-z0-9_]+)\s*:\s*['"]([^'"]+)['"]/g)]
@@ -526,82 +123,67 @@ export function pageRouteFromSource (pageAbsPath, srcDir) {
   }
 }
 
-/** Posix path relative to `build/.ossy/` for the compiled **Node** page module (SSR). */
-export function pageServerModuleRelPath (pageAbsPath, srcDir) {
-  const pageId = clientHydrateIdForPage(pageAbsPath, srcDir)
-  const safeId = String(pageId).replace(/[^a-zA-Z0-9_-]+/g, '-') || 'page'
-  return `${OSSY_PAGE_MODULES_DIRNAME}/${safeId}.mjs`
-}
-
-export function pageSourceExportsMetadata (pageAbsPath) {
-  try {
-    const src = fs.readFileSync(pageAbsPath, 'utf8')
-    return /\bexport\s+const\s+metadata\b/.test(src)
-  } catch {
-    return false
-  }
+function createNodePlugins (nodeEnv) {
+  return [
+    replace({
+      preventAssignment: true,
+      'process.env.NODE_ENV': JSON.stringify(nodeEnv),
+    }),
+    json(),
+    nodeExternals({
+      deps: false,
+      devDeps: true,
+      peerDeps: false,
+      packagePath: path.join(process.cwd(), 'package.json'),
+    }),
+    resolveCommonJsDependencies(),
+    resolveDependencies({ preferBuiltins: true }),
+    babel({
+      babelHelpers: 'bundled',
+      extensions: ['.jsx', '.tsx'],
+      presets: [['@babel/preset-react', { runtime: 'automatic' }]],
+    }),
+  ]
 }
 
-/**
- * Rollup tree-shakes `export const metadata` when the page file is the entry and `default`
- * never references it — breaks i18n `path` objects at runtime. Re-export from a shim entry
- * so `metadata` stays in the module graph.
- */
-export function writePageServerRollupEntry ({ pageAbsPath, stubPath }) {
-  const rel = relToGeneratedImport(stubPath, pageAbsPath)
-  const meta = pageSourceExportsMetadata(pageAbsPath)
-    ? ', metadata'
-    : ''
-  fs.mkdirSync(path.dirname(stubPath), { recursive: true })
-  fs.writeFileSync(
-    stubPath,
-    [
-      '// Generated by @ossy/app — do not edit',
-      `export { default${meta} } from '${rel}'`,
-      '',
-    ].join('\n'),
-    'utf8'
-  )
+async function bundleNodeEntry ({ inputPath, outputFile, nodeEnv }) {
+  const bundle = await rollup({
+    input: inputPath,
+    plugins: createNodePlugins(nodeEnv),
+  })
+  await bundle.write({
+    file: outputFile,
+    format: 'esm',
+    inlineDynamicImports: true,
+  })
+  await bundle.close()
 }
 
-/**
- * Generates a single shared hydrate entry that dynamically imports the active page at runtime.
- * Rollup processes this once, emitting React and shared deps as reusable chunks instead of
- * bundling them into every page separately.
- */
-export function generateHydrateEntry ({ pageFiles, srcDir, stubAbsPath }) {
+function generateHydrateEntry ({ pageFiles, srcDir, stubAbsPath }) {
   const seenIds = new Set()
-  const pageLines = []
-  for (const f of pageFiles) {
-    const hydrateId = clientHydrateIdForPage(f, srcDir)
-    if (seenIds.has(hydrateId)) {
-      throw new Error(
-        `[@ossy/app] Duplicate client hydrate id "${hydrateId}" (${f}). Pages need unique ids.`
-      )
+  const pageLines = pageFiles.map((f) => {
+    const { id } = pageRouteFromSource(f, srcDir)
+    if (seenIds.has(id)) {
+      throw new Error(`[@ossy/app] Duplicate page id "${id}" (${f}). Pages need unique ids.`)
     }
-    seenIds.add(hydrateId)
+    seenIds.add(id)
     const rel = relToGeneratedImport(stubAbsPath, f)
-    pageLines.push(`  ${JSON.stringify(hydrateId)}: () => import('./${rel}'),`)
-  }
-
+    return `  ${JSON.stringify(id)}: () => import('./${rel}'),`
+  })
   return [
     '// Generated by @ossy/app — do not edit',
-    '',
     "import { createElement } from 'react'",
     "import { hydrateRoot } from 'react-dom/client'",
     "import { App } from '@ossy/connected-components'",
-    '',
     'const config = window.__INITIAL_APP_CONFIG__ || {}',
-    '',
     'const pages = {',
     ...pageLines,
     '}',
-    '',
     'const load = pages[config.pageId]',
     'if (load) {',
     '  load().then((mod) => {',
     '    const Page = mod.default',
-    "    const metadata = mod.metadata || {}",
+    '    const metadata = mod.metadata || {}',
     '    function PageShell (props) {',
     "      return createElement('html', { lang: props.defaultLanguage || 'en' },",
     "        createElement('head', null,",
@@ -620,64 +202,34 @@ export function generateHydrateEntry ({ pageFiles, srcDir, stubAbsPath }) {
   ].join('\n')
 }
 
-/** Writes a single `hydrate-entry.jsx`; removes any stale per-page `hydrate-*.jsx` stubs first. */
-export function writeHydrateEntry (pageFiles, srcDir, ossyDir) {
-  if (!fs.existsSync(ossyDir)) fs.mkdirSync(ossyDir, { recursive: true })
-  for (const ent of fs.readdirSync(ossyDir, { withFileTypes: true })) {
-    if (
-      ent.isFile() &&
-      ent.name.startsWith('hydrate-') &&
-      ent.name.endsWith('.jsx') &&
-      ent.name !== HYDRATE_ENTRY_FILENAME
-    ) {
-      fs.rmSync(path.join(ossyDir, ent.name), { force: true })
-    }
-  }
-  const stubPath = path.join(ossyDir, HYDRATE_ENTRY_FILENAME)
-  fs.writeFileSync(stubPath, generateHydrateEntry({ pageFiles, srcDir, stubAbsPath: stubPath }))
-}
-
-/**
- * Generates the single shared SSR entry that exports a static `pages` array and a
- * `renderPage(pageId, props, options)` function. Each page is dynamically imported so
- * Rollup can split out lazy chunks per page when code-splitting is enabled.
- */
-export function generateSsrEntry ({ pageFiles, srcDir, stubAbsPath }) {
+function generateSsrEntry ({ pageFiles, srcDir, stubAbsPath }) {
   const seenIds = new Set()
   const pagesLiteral = []
   const pageModuleLines = []
-
   for (const f of pageFiles) {
     const { id, path: routePath } = pageRouteFromSource(f, srcDir)
     if (seenIds.has(id)) {
-      throw new Error(
-        `[@ossy/app] Duplicate page id "${id}" (${f}). Pages need unique ids.`
-      )
+      throw new Error(`[@ossy/app] Duplicate page id "${id}" (${f}). Pages need unique ids.`)
     }
     seenIds.add(id)
     const rel = relToGeneratedImport(stubAbsPath, f)
     pagesLiteral.push(`  { id: ${JSON.stringify(id)}, path: ${JSON.stringify(routePath)} },`)
     pageModuleLines.push(`  ${JSON.stringify(id)}: () => import('./${rel}'),`)
   }
-
   return [
     '// Generated by @ossy/app — do not edit',
-    '',
     "import { createElement } from 'react'",
     "import { renderToPipeableStream } from 'react-dom/server'",
     "import { Writable } from 'node:stream'",
     "import { App } from '@ossy/connected-components'",
-    '',
     'export const pages = [',
     ...pagesLiteral,
     ']',
-    '',
     'const pageModules = {',
     ...pageModuleLines,
     '}',
-    '',
     'function PageShell (props) {',
-    "  const meta = props._pageMeta || {}",
+    '  const meta = props._pageMeta || {}',
     "  return createElement('html', { lang: props.defaultLanguage || 'en' },",
     "    createElement('head', null,",
     "      createElement('meta', { charSet: 'utf-8' }),",
@@ -688,10 +240,9 @@ export function generateSsrEntry ({ pageFiles, srcDir, stubAbsPath }) {
     '    )',
     '  )',
     '}',
-    '',
-    'export async function renderPage (pageId, props, options = {}) {',
+    'export async function renderPage (pageId, props) {',
     '  const load = pageModules[pageId]',
-    "  if (!load) throw new Error(`[@ossy/app] Unknown page id: ${pageId}`)",
+    '  if (!load) throw new Error(`[@ossy/app] Unknown page id: ${pageId}`)',
     '  const mod = await load()',
     '  const merged = { ...props, _pageComponent: mod.default, _pageMeta: mod.metadata || {} }',
     '  return new Promise((resolve, reject) => {',
@@ -700,7 +251,6 @@ export function generateSsrEntry ({ pageFiles, srcDir, stubAbsPath }) {
     '      write (chunk, _enc, cb) { html += chunk.toString(); cb() },',
     '    })',
     '    const { pipe } = renderToPipeableStream(createElement(PageShell, merged), {',
-    '      ...options,',
     '      onAllReady () { pipe(writable) },',
     '      onError (err) { reject(err) },',
     '    })',
@@ -711,262 +261,189 @@ export function generateSsrEntry ({ pageFiles, srcDir, stubAbsPath }) {
   ].join('\n')
 }
 
-/** Writes `ssr-entry.mjs` into ossyDir; removes any stale per-page SSR stubs first. */
-export function writeSsrEntry (pageFiles, srcDir, ossyDir) {
-  if (!fs.existsSync(ossyDir)) fs.mkdirSync(ossyDir, { recursive: true })
-  const stubPath = path.join(ossyDir, SSR_ENTRY_FILENAME)
-  fs.writeFileSync(stubPath, generateSsrEntry({ pageFiles, srcDir, stubAbsPath: stubPath }))
-  return stubPath
+function writeAppRuntimeShims ({ middlewareSourcePath, configSourcePath, ossyDir }) {
+  writeJson(path.join(ossyDir, 'middleware.runtime.json'), {
+    modulePath: path.resolve(middlewareSourcePath),
+  })
+  writeJson(path.join(ossyDir, 'server-config.runtime.json'), {
+    modulePath: path.resolve(configSourcePath),
+  })
 }
 
-/**
- * Runs a single Rollup pass with both the SSR entry and the client hydrate entry as inputs.
- * Produces:
- *   build/ssr/app.mjs          — Node SSR bundle
- *   build/public/static/app.js — browser hydrate bundle
- *   build/public/static/chunks/[name]-[hash].js — shared chunks
- *
- * The SSR bundle imports shared chunks via relative paths (`../public/static/chunks/…`);
- * the browser loads the same physical files from `/static/chunks/`.
- */
-export async function compileCombinedBundle ({ ssrEntryPath, clientEntryPath, buildPath, nodeEnv, copyPublicFrom, onWarn }) {
-  if (copyPublicFrom && fs.existsSync(copyPublicFrom)) {
-    const destPublic = path.join(buildPath, 'public')
-    fs.mkdirSync(destPublic, { recursive: true })
-    const copyDir = (src, dest) => {
-      fs.mkdirSync(dest, { recursive: true })
-      for (const ent of fs.readdirSync(src, { withFileTypes: true })) {
-        const srcPath = path.join(src, ent.name)
-        const destPath = path.join(dest, ent.name)
-        if (ent.isDirectory()) copyDir(srcPath, destPath)
-        else fs.copyFileSync(srcPath, destPath)
-      }
-    }
-    copyDir(copyPublicFrom, destPublic)
+function minifyBrowserStaticChunks () {
+  return {
+    name: 'minify-browser-static-chunks',
+    async renderChunk (code, chunk, outputOptions) {
+      const fileName = chunk.fileName
+      if (!fileName || !fileName.startsWith('public/static/')) return null
+      const result = await minifyWithTerser(code, {
+        sourceMap: outputOptions.sourcemap === true || typeof outputOptions.sourcemap === 'string',
+        module: outputOptions.format === 'es' || outputOptions.format === 'esm',
+      })
+      return result.code ?? code
+    },
   }
+}
 
+async function compileCombinedBundle ({ ssrEntryPath, clientEntryPath, buildPath, nodeEnv, copyPublicFrom }) {
+  if (copyPublicFrom && fs.existsSync(copyPublicFrom)) {
+    fs.cpSync(copyPublicFrom, path.join(buildPath, 'public'), { recursive: true, force: true })
+  }
   const bundle = await rollup({
     input: { server: ssrEntryPath, app: clientEntryPath },
-    plugins: createCombinedBundlePlugins({ nodeEnv }),
-    onwarn (warning, defaultHandler) {
-      if (onWarn) { onWarn(warning); return }
-      defaultHandler(warning)
-    },
+    plugins: createNodePlugins(nodeEnv),
   })
   await bundle.write({
     dir: buildPath,
     format: 'esm',
-    entryFileNames: (chunk) =>
-      chunk.name === 'server'
-        ? 'ssr/app.mjs'
-        : 'public/static/app.js',
+    entryFileNames: (chunk) => (chunk.name === 'server' ? 'ssr/app.mjs' : 'public/static/app.js'),
     chunkFileNames: 'public/static/chunks/[name]-[hash].js',
     plugins: [minifyBrowserStaticChunks()],
   })
   await bundle.close()
 }
 
-/** JSON manifest: route ids, default paths, and page source paths (posix, relative to `cwd`). */
-export function buildPagesGeneratedPayload (pageFiles, srcDir, cwd = process.cwd()) {
-  const pages = pageFiles.map((f) => {
-    const { id, path: routePath } = pageRouteFromSource(f, srcDir)
-    return {
-      id,
-      path: routePath,
-      sourceFile: path.relative(cwd, f).replace(/\\/g, '/'),
-    }
-  })
-  return pages
+async function compileApiServerModules ({ apiFiles, ossyDir, nodeEnv }) {
+  const modsDir = path.join(ossyDir, 'api-modules')
+  fs.rmSync(modsDir, { recursive: true, force: true })
+  fs.mkdirSync(modsDir, { recursive: true })
+  const routes = []
+  for (let i = 0; i < apiFiles.length; i++) {
+    const outName = `api-${i}.mjs`
+    const outFile = path.join(modsDir, outName)
+    await bundleNodeEntry({ inputPath: apiFiles[i], outputFile: outFile, nodeEnv })
+    let meta = {}
+    try {
+      const mod = await import(pathToFileURL(outFile).href)
+      meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
+    } catch {}
+    routes.push({ ...meta, module: `api-modules/${outName}` })
+  }
+  return routes
 }
 
-export function writePagesManifest ({
-  pageFiles,
-  srcDir,
-  pagesGeneratedPath,
-  cwd = process.cwd(),
-}) {
-  writeOssyJson(pagesGeneratedPath, buildPagesGeneratedPayload(pageFiles, srcDir, cwd))
+async function compileTaskServerModules ({ taskFiles, ossyDir, nodeEnv }) {
+  const modsDir = path.join(ossyDir, 'task-modules')
+  fs.rmSync(modsDir, { recursive: true, force: true })
+  fs.mkdirSync(modsDir, { recursive: true })
+  const tasks = []
+  for (let i = 0; i < taskFiles.length; i++) {
+    const outName = `task-${i}.mjs`
+    const outFile = path.join(modsDir, outName)
+    await bundleNodeEntry({ inputPath: taskFiles[i], outputFile: outFile, nodeEnv })
+    let meta = {}
+    try {
+      const mod = await import(pathToFileURL(outFile).href)
+      meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
+    } catch {}
+    tasks.push({ ...meta, module: `task-modules/${outName}` })
+  }
+  return tasks
 }
 
-export function parsePagesFromManifestJson (manifestPath) {
-  try {
-    const data = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
-    if (!Array.isArray(data)) return []
-    return data.map((p) => ({
-      id: p.id,
-      path: p.path,
-      ...(typeof p.module === 'string' ? { module: p.module } : {}),
-    }))
-  } catch {
-    return []
-  }
+function writeGeneratedEntries ({ pageFiles, srcDir, ossyDir }) {
+  const ssrEntryPath = path.join(ossyDir, SSR_ENTRY_FILENAME)
+  const hydrateEntryPath = path.join(ossyDir, HYDRATE_ENTRY_FILENAME)
+  fs.writeFileSync(ssrEntryPath, generateSsrEntry({ pageFiles, srcDir, stubAbsPath: ssrEntryPath }))
+  fs.writeFileSync(hydrateEntryPath, generateHydrateEntry({ pageFiles, srcDir, stubAbsPath: hydrateEntryPath }))
+  return { ssrEntryPath, hydrateEntryPath }
 }
 
-/**
- * Best-effort scan of a source file for `{ id, path }` literals (e.g. `*.api.js` default export).
- * Used only for the build dashboard API list — **not** for page discovery (`*.page.jsx` only).
- */
-export function parseIdPathPairsFromFile (filePath) {
-  try {
-    const content = fs.readFileSync(filePath, 'utf8')
-    const items = []
-    const idPathPattern = /\{\s*id\s*:\s*['"]([^'"]*)['"]\s*,\s*path\s*:\s*['"]([^'"]*)['"]/g
-    const pathObjPattern = /\{\s*path\s*:\s*\{\s*([^}]+)\}/g
-    let m
-    while ((m = idPathPattern.exec(content)) !== null) {
-      items.push({ id: m[1], path: m[2] })
-    }
-    if (items.length === 0) {
-      while ((m = pathObjPattern.exec(content)) !== null) {
-        const pathStr = m[1].replace(/\s/g, '').replace(/:/g, ': ')
-        items.push({ id: 'page', path: pathStr })
-      }
-    }
-    return items
-  } catch {
-    return []
+function copyPlatformRuntime ({ buildPath }) {
+  const require = createRequire(import.meta.url)
+  const platformServerPath = require.resolve('@ossy/platform/server')
+  const platformWorkerPath = require.resolve('@ossy/platform/worker')
+  const platformServerDir = path.dirname(platformServerPath)
+  const platformWorkerDir = path.dirname(platformWorkerPath)
+
+  for (const name of ['server.js', 'proxy-internal.js']) {
+    fs.copyFileSync(path.join(platformServerDir, name), path.join(buildPath, name))
   }
+  fs.copyFileSync(path.join(platformWorkerDir, 'worker-entry.js'), path.join(buildPath, 'worker.js'))
+  fs.copyFileSync(path.join(platformWorkerDir, 'worker-runtime.js'), path.join(buildPath, 'worker-runtime.js'))
 }
 
-/**
- * Same facts as the old build overview printout, for dashboards / plain logging.
- */
-export function getBuildOverviewSnapshot ({
-  pagesSourcePath,
-  apiOverviewFiles = [],
-  configPath,
-  pageFiles,
-}) {
-  const rel = (p) => (p ? path.relative(process.cwd(), p) : undefined)
-  const srcDir = path.resolve(process.cwd(), 'src')
-  const configRel = fs.existsSync(configPath) ? rel(configPath) : null
-
-  const pages = pageFiles?.length
-    ? pageFiles.map((f) => {
-        const { id, path: routePath } = filePathToRoute(f, srcDir)
-        return { id: clientHydrateIdForPage(f, srcDir), path: routePath }
-      })
-    : parsePagesFromManifestJson(pagesSourcePath)
+export function resourceTemplatesDir (cwd = process.cwd()) {
+  return path.join(cwd, 'src', 'resource-templates')
+}
 
-  const apiRoutes = []
-  for (const f of apiOverviewFiles) {
-    if (fs.existsSync(f)) apiRoutes.push(...parseIdPathPairsFromFile(f))
-  }
+export function discoverResourceTemplateFiles (templatesDir) {
+  if (!fs.existsSync(templatesDir) || !fs.statSync(templatesDir).isDirectory()) return []
+  return fs
+    .readdirSync(templatesDir)
+    .filter((n) => RESOURCE_TEMPLATE_FILE_PATTERN.test(n))
+    .map((n) => path.join(templatesDir, n))
+    .sort((a, b) => path.basename(a).localeCompare(path.basename(b)))
+}
 
-  return { configRel, pages, apiRoutes }
+export function generateResourceTemplatesBarrelSource ({ outputAbs, templateFilesAbs }) {
+  const payload = templateFilesAbs.map((f) => relToGeneratedImport(outputAbs, f))
+  return `${JSON.stringify(payload, null, 2)}\n`
 }
 
-export function printBuildOverview (opts) {
-  const { configRel, pages, apiRoutes } = getBuildOverviewSnapshot(opts)
-  console.log('\n  \x1b[1mBuild overview\x1b[0m')
-  if (configRel) {
-    console.log(`  \x1b[36mConfig:\x1b[0m ${configRel}`)
-  }
-  console.log('  ' + '─'.repeat(50))
-
-  if (pages.length > 0) {
-    console.log('  \x1b[36mRoutes:\x1b[0m')
-    const maxId = Math.max(6, ...pages.map((p) => String(p.id).length))
-    const maxPath = Math.max(6, ...pages.map((p) => String(p.path).length))
-    pages.forEach((p) => {
-      const id = String(p.id).padEnd(maxId)
-      const pathStr = String(p.path).padEnd(maxPath)
-      console.log(`    ${id}  ${pathStr}`)
-    })
-  } else {
-    console.log('  \x1b[33mRoutes:\x1b[0m (could not parse or empty)')
+export function writeResourceTemplatesBarrelIfPresent ({ cwd = process.cwd(), log = true } = {}) {
+  const dir = resourceTemplatesDir(cwd)
+  if (!fs.existsSync(dir)) {
+    return { wrote: false, count: 0, path: null }
   }
-
-  if (apiRoutes.length > 0) {
-    console.log('  \x1b[36mAPI routes:\x1b[0m')
-    apiRoutes.forEach((r) => {
-      console.log(`    ${r.id}  ${r.path}`)
-    })
+  const files = discoverResourceTemplateFiles(dir)
+  const outAbs = path.join(dir, OSSY_RESOURCE_TEMPLATES_OUT)
+  fs.writeFileSync(outAbs, generateResourceTemplatesBarrelSource({ outputAbs: outAbs, templateFilesAbs: files }), 'utf8')
+  if (log) {
+    console.log(`[@ossy/app][resource-templates] merged ${files.length} template(s) → ${path.relative(cwd, outAbs)}`)
   }
-  console.log('  ' + '─'.repeat(50) + '\n')
+  return { wrote: true, count: files.length, path: outAbs }
 }
 
-export const build = async (cliArgs) => {
-    const options = arg({
-        '--config': String,
-        '-c': '--config',
-      }, { argv: cliArgs })
-
-    const scriptDir = path.dirname(url.fileURLToPath(import.meta.url))
-    const buildPath = path.resolve('build')
-    const srcDir = path.resolve('src')
-    const configPath = path.resolve(options['--config'] || 'src/config.js')
-    const pageFiles = discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN)
-    const publicDir = path.resolve('public')
-
-    resetOssyBuildDir(buildPath)
-
-    const resourceTemplatesResult = writeResourceTemplatesBarrelIfPresent({
-      cwd: process.cwd(),
-      log: false,
-    })
-
-    const ossyDir = ossyGeneratedDir(buildPath)
-    const pagesGeneratedPath = path.join(ossyDir, OSSY_GEN_PAGES_BASENAME)
-
-    writePagesManifest({
-      pageFiles,
-      srcDir,
-      pagesGeneratedPath,
-    })
-
-    // Write generated entries (both SSR and client hydrate)
-    const ssrEntryPath = writeSsrEntry(pageFiles, srcDir, ossyDir)
-    writeHydrateEntry(pageFiles, srcDir, ossyDir)
-    const clientEntryPath = path.join(ossyDir, HYDRATE_ENTRY_FILENAME)
-
-    const { apiOverviewFiles } = resolveApiSource({ srcDir, buildPath })
-    let middlewareSourcePath = path.resolve('src/middleware.js')
+export async function build (cliArgs = []) {
+  const options = arg({
+    '--config': String,
+    '-c': '--config',
+  }, { argv: cliArgs })
 
-    if (!fs.existsSync(middlewareSourcePath)) {
-      middlewareSourcePath = path.resolve(scriptDir, 'middleware.js')
-    }
+  const scriptDir = path.dirname(url.fileURLToPath(import.meta.url))
+  const cwd = process.cwd()
+  const buildPath = path.resolve(cwd, 'build')
+  const srcDir = path.resolve(cwd, 'src')
+  const publicDir = path.resolve(cwd, 'public')
+  const configPath = path.resolve(cwd, options['--config'] || 'src/config.js')
 
-    const configSourcePath = fs.existsSync(configPath)
-      ? configPath
-      : path.resolve(scriptDir, 'default-config.js')
+  resetBuildDir(buildPath)
+  writeResourceTemplatesBarrelIfPresent({ cwd, log: false })
+  const ossyDir = ossyGeneratedDir(buildPath)
 
-    console.log('\n  \x1b[1m@ossy/app\x1b[0m  \x1b[2mbuild\x1b[0m')
-    printBuildOverview({
-      pagesSourcePath: pagesGeneratedPath,
-      apiOverviewFiles,
-      configPath,
-      pageFiles,
-    })
-
-    if (resourceTemplatesResult.wrote && resourceTemplatesResult.path) {
-      console.log(
-        `[@ossy/app][resource-templates] merged ${resourceTemplatesResult.count} template(s) → ${path.relative(process.cwd(), resourceTemplatesResult.path)}`
-      )
-    }
-
-    const { taskOverviewFiles } = resolveTaskSource({ srcDir, buildPath })
-    await compileOssyNodeArtifacts({
-      apiFiles: apiOverviewFiles,
-      taskFiles: taskOverviewFiles,
-      ossyDir,
-      nodeEnv: 'production',
-    })
+  const pageFiles = discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN)
+  const apiFiles = discoverFilesByPattern(srcDir, API_FILE_PATTERN)
+  const taskFiles = discoverFilesByPattern(srcDir, TASK_FILE_PATTERN)
 
-    writeAppRuntimeShims({
-      middlewareSourcePath,
-      configSourcePath,
-      ossyDir,
-    })
-    copyOssyAppRuntime({ scriptDir, buildPath })
-
-    await compileCombinedBundle({
-      ssrEntryPath,
-      clientEntryPath,
-      buildPath,
-      nodeEnv: 'production',
-      copyPublicFrom: publicDir,
+  writeJson(
+    path.join(ossyDir, OSSY_GEN_PAGES_BASENAME),
+    pageFiles.map((f) => {
+      const { id, path: routePath } = pageRouteFromSource(f, srcDir)
+      return { id, path: routePath, sourceFile: path.relative(cwd, f).replace(/\\/g, '/') }
     })
+  )
 
-    console.log('  \x1b[32m✔\x1b[0m \x1b[1m@ossy/app\x1b[0m  \x1b[2mbuild finished\x1b[0m\n')
-};
+  const apiRouteList = await compileApiServerModules({ apiFiles, ossyDir, nodeEnv: 'production' })
+  const taskRouteList = await compileTaskServerModules({ taskFiles, ossyDir, nodeEnv: 'production' })
+  writeJson(path.join(ossyDir, OSSY_GEN_API_BASENAME), apiRouteList)
+  writeJson(path.join(ossyDir, OSSY_GEN_TASKS_BASENAME), taskRouteList)
+
+  const middlewareSourcePath = fs.existsSync(path.resolve(cwd, 'src/middleware.js'))
+    ? path.resolve(cwd, 'src/middleware.js')
+    : path.resolve(scriptDir, 'Middleware.js')
+  const configSourcePath = fs.existsSync(configPath)
+    ? configPath
+    : path.resolve(scriptDir, 'default-config.js')
+  writeAppRuntimeShims({ middlewareSourcePath, configSourcePath, ossyDir })
+
+  const { ssrEntryPath, hydrateEntryPath } = writeGeneratedEntries({ pageFiles, srcDir, ossyDir })
+  copyPlatformRuntime({ buildPath })
+  await compileCombinedBundle({
+    ssrEntryPath,
+    clientEntryPath: hydrateEntryPath,
+    buildPath,
+    nodeEnv: 'production',
+    copyPublicFrom: publicDir,
+  })
+}