@ossy/app 1.11.0 → 1.11.2

package/cli/build.js

@@ -12,7 +12,7 @@ import copy from 'rollup-plugin-copy';
 import replace from '@rollup/plugin-replace';
 import arg from 'arg'
 import prerenderReactTask from './prerender-react.task.js'
-import { createParallelPagesReporter } from './build-terminal.js'
+import { createBuildDashboard } from './build-terminal.js'
 
 export const PAGE_FILE_PATTERN = /\.page\.(jsx?|tsx?)$/
 export const API_FILE_PATTERN = /\.api\.(mjs|cjs|js)$/
@@ -53,15 +53,35 @@ export function minifyBrowserStaticChunks () {
 
 /** Subfolder under `build/` for generated pages/api/task entry stubs. */
 export const OSSY_GEN_DIRNAME = '.ossy'
-export const OSSY_GEN_PAGES_BASENAME = 'pages.generated.jsx'
-export const OSSY_GEN_API_BASENAME = 'api.generated.js'
-export const OSSY_GEN_TASKS_BASENAME = 'tasks.generated.js'
-
-/** Bundled pages + React for build-time prerender only (not loaded by `server.js`). */
-export const OSSY_PAGES_PRERENDER_BUNDLE = 'pages.prerender.bundle.js'
-export const OSSY_API_SERVER_BUNDLE = 'api.bundle.js'
-export const OSSY_TASKS_SERVER_BUNDLE = 'tasks.bundle.js'
+/** 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'
+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',
+]
 
 /** Per-page client entries: `hydrate-<pageId>.jsx` under `.ossy/` */
 const HYDRATE_STUB_PREFIX = 'hydrate-'
@@ -210,10 +230,18 @@ export function createOssyClientRollupPlugins ({ nodeEnv, copyPublicFrom, buildP
 }
 
 /** Bundles a single Node ESM file (inline dynamic imports) for SSR / API / tasks. */
-export async function bundleOssyNodeEntry ({ inputPath, outputFile, nodeEnv }) {
+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,
@@ -224,14 +252,19 @@ export async function bundleOssyNodeEntry ({ inputPath, outputFile, nodeEnv }) {
 }
 
 /**
- * Re-exports middleware via `file:` URL so `src/middleware.js` can keep relative imports.
+ * Re-exports middleware and app config via `file:` URLs so `src/*.js` can keep relative imports.
  */
-export function writeAppRuntimeShims ({ middlewareSourcePath, ossyDir }) {
+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`
+  )
 }
 
 /**
@@ -251,6 +284,18 @@ export function copyOssyAppRuntime ({ scriptDir, buildPath }) {
   }
   fs.copyFileSync(path.join(scriptDir, 'worker-entry.js'), path.join(buildPath, 'worker.js'))
   fs.copyFileSync(path.join(scriptDir, 'worker-runtime.js'), path.join(buildPath, 'worker-runtime.js'))
+  const ossyOut = ossyGeneratedDir(buildPath)
+  for (const name of [
+    OSSY_PAGES_RUNTIME_BASENAME,
+    OSSY_API_RUNTIME_BASENAME,
+    OSSY_TASKS_RUNTIME_BASENAME,
+  ]) {
+    fs.copyFileSync(path.join(scriptDir, name), path.join(ossyOut, name))
+  }
+  fs.copyFileSync(
+    path.join(scriptDir, OSSY_RENDER_PAGE_RUNTIME_BASENAME),
+    path.join(ossyOut, OSSY_RENDER_PAGE_RUNTIME_BASENAME)
+  )
 }
 
 /**
@@ -274,107 +319,157 @@ export function discoverFilesByPattern (srcDir, filePattern) {
   return files.sort()
 }
 
-/**
- * Merges every `*.api.js` (and `.api.mjs` / `.api.cjs`) under `src/` into one default export array
- * for the Ossy API router ({ id, path, handle }). With no API files, emits `export default []`.
- */
-export function generateApiModule ({ generatedPath, apiFiles }) {
-  if (apiFiles.length === 0) {
-    return [
-      '// Generated by @ossy/app — do not edit',
-      '',
-      'export default []',
-      '',
-    ].join('\n')
+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 {
+    version: 1,
+    files: 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 {
+    version: 1,
+    files: taskFiles.map((f) => path.relative(cwd, f).replace(/\\/g, '/')),
   }
-  const lines = [
-    '// Generated by @ossy/app — do not edit',
-    '',
-  ]
-  apiFiles.forEach((f, i) => {
-    const rel = relToGeneratedImport(generatedPath, f)
-    lines.push(`import * as _api${i} from './${rel}'`)
-  })
-  lines.push(
-    '',
-    'function _normalizeApiExport(mod) {',
-    '  const d = mod?.default',
-    '  if (d == null) return []',
-    '  return Array.isArray(d) ? d : [d]',
-    '}',
-    '',
-    'export default [',
-  )
-  const parts = apiFiles.map((_, i) => `  ..._normalizeApiExport(_api${i}),`)
-  lines.push(parts.join('\n'))
-  lines.push(']')
-  lines.push('')
-  return lines.join('\n')
 }
 
 /**
- * Writes `build/.ossy/api.generated.js` and returns its path for `@ossy/api/source-file`.
- * Always uses the generated file so the Rollup replace target stays stable.
+ * Writes `build/.ossy/api.generated.json` (sources only).
+ * Compiled modules + `api.bundle.json` are produced by {@link compileOssyNodeArtifacts}.
  */
-export function resolveApiSource ({ srcDir, buildPath }) {
+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)
-  fs.writeFileSync(
-    generatedPath,
-    generateApiModule({ generatedPath, apiFiles })
-  )
-  return { apiSourcePath: generatedPath, apiOverviewFiles: apiFiles }
-}
-
-/**
- * Merges `src/tasks.js` (optional) and every `*.task.js` under `src/` into one default export array
- * of job handlers `{ type, handler }` for the Ossy worker.
- */
-export function generateTaskModule ({ generatedPath, taskFiles }) {
-  const lines = [
-    '// Generated by @ossy/app — do not edit',
-    '',
-  ]
-  taskFiles.forEach((f, i) => {
-    const rel = relToGeneratedImport(generatedPath, f)
-    lines.push(`import * as _task${i} from './${rel}'`)
-  })
-  lines.push(
-    '',
-    'function _normalizeTaskExport(mod) {',
-    '  const d = mod?.default',
-    '  if (d == null) return []',
-    '  return Array.isArray(d) ? d : [d]',
-    '}',
-    '',
-    'export default [',
-  )
-  const parts = []
-  taskFiles.forEach((_, i) => {
-    parts.push(`  ..._normalizeTaskExport(_task${i}),`)
-  })
-  lines.push(parts.join('\n'))
-  lines.push(']')
-  lines.push('')
-  return lines.join('\n')
+  writeOssyJson(generatedPath, buildApiManifestPayload(apiFiles, cwd))
+  return { apiGeneratedPath: generatedPath, apiOverviewFiles: apiFiles }
 }
 
 /**
- * Writes `build/.ossy/tasks.generated.js` and returns its path (stable Rollup input; empty when no task files).
+ * Writes `build/.ossy/tasks.generated.json` (sources only).
  */
-export function resolveTaskSource ({ srcDir, buildPath }) {
+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)
-  fs.writeFileSync(
-    generatedPath,
-    generateTaskModule({
-      generatedPath,
-      taskFiles,
+  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)
+  fs.rmSync(modsDir, { recursive: true, force: true })
+  if (pageFiles.length === 0) {
+    return []
+  }
+  fs.mkdirSync(modsDir, { 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 outName = `${safeId}.mjs`
+    const outFile = path.join(modsDir, outName)
+    await bundleOssyNodeEntry({
+      inputPath: f,
+      outputFile: outFile,
+      nodeEnv,
+      onWarn,
+      external: OSSY_PAGE_SERVER_EXTERNAL,
     })
-  )
-  return { taskSourcePath: generatedPath, taskOverviewFiles: taskFiles }
+    bundlePages.push({
+      id: pageId,
+      module: `${OSSY_PAGE_MODULES_DIRNAME}/${outName}`,
+    })
+  }
+  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 modules = []
+  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,
+    })
+    modules.push(`${OSSY_API_MODULES_DIRNAME}/${outName}`)
+  }
+  return modules
+}
+
+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 []
+  }
+  fs.mkdirSync(modsDir, { recursive: true })
+  const modules = []
+  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,
+    })
+    modules.push(`${OSSY_TASK_MODULES_DIRNAME}/${outName}`)
+  }
+  return modules
+}
+
+/**
+ * Writes `pages.bundle.json`, `api.bundle.json`, `tasks.bundle.json` by Rollup-compiling each source module.
+ */
+export async function compileOssyNodeArtifacts ({
+  pageFiles,
+  srcDir,
+  ossyDir,
+  apiFiles,
+  taskFiles,
+  nodeEnv,
+  onWarn,
+}) {
+  const [pageBundleList, apiModuleList, taskModuleList] = await Promise.all([
+    compilePageServerModules({ pageFiles, srcDir, ossyDir, nodeEnv, onWarn }),
+    compileApiServerModules({ apiFiles, ossyDir, nodeEnv, onWarn }),
+    compileTaskServerModules({ taskFiles, ossyDir, nodeEnv, onWarn }),
+  ])
+  writeOssyJson(path.join(ossyDir, OSSY_PAGES_BUNDLE_BASENAME), {
+    version: 1,
+    pages: pageBundleList,
+  })
+  writeOssyJson(path.join(ossyDir, OSSY_API_BUNDLE_BASENAME), {
+    version: 1,
+    modules: apiModuleList,
+  })
+  writeOssyJson(path.join(ossyDir, OSSY_TASKS_BUNDLE_BASENAME), {
+    version: 1,
+    modules: taskModuleList,
+  })
 }
 
 export function filePathToRoute(filePath, srcDir) {
@@ -407,7 +502,7 @@ export function clientHydrateIdForPage (pageAbsPath, srcDir) {
 
 /**
  * One client entry per page: imports only that page module and hydrates the document.
- * Keeps the same `toPage` shape as `generatePagesModule` so SSR and client trees match.
+ * Keeps the same `toPage` shape as `pages.runtime.mjs` + manifests so SSR and client trees match.
  */
 export function generatePageHydrateModule ({ pageAbsPath, stubAbsPath, srcDir }) {
   const rel = relToGeneratedImport(stubAbsPath, pageAbsPath)
@@ -484,32 +579,39 @@ export function buildClientHydrateInput (pageFiles, srcDir, ossyDir) {
   return input
 }
 
-export function generatePagesModule (pageFiles, srcDir, generatedPath) {
-  const lines = [
-    "import React from 'react'",
-    ...pageFiles.map((f, i) => {
-      const rel = relToGeneratedImport(generatedPath, f)
-      return `import * as _page${i} from './${rel}'`
-    }),
-    '',
-    'function toPage(mod, derived) {',
-    '  const meta = mod?.metadata || {}',
-    "  const def = mod?.default",
-    "  if (typeof def === 'function') {",
-    "    return { ...derived, ...meta, element: React.createElement(def) }",
-    '  }',
-    "  return { ...derived, ...meta, ...(def || {}) }",
-    '}',
-    '',
-    'export default [',
-    ...pageFiles.map((f, i) => {
-      const { id, path: defaultPath } = filePathToRoute(f, srcDir)
-      const pathStr = JSON.stringify(defaultPath)
-      return `  toPage(_page${i}, { id: '${id}', path: ${pathStr} }),`
-    }),
-    ']',
-  ]
-  return lines.join('\n')
+/** 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 { path: routePath } = filePathToRoute(f, srcDir)
+    const pageId = clientHydrateIdForPage(f, srcDir)
+    return {
+      id: pageId,
+      path: routePath,
+      sourceFile: path.relative(cwd, f).replace(/\\/g, '/'),
+    }
+  })
+  return { version: 1, pages }
+}
+
+export function writePagesManifest ({
+  pageFiles,
+  srcDir,
+  pagesGeneratedPath,
+  cwd = process.cwd(),
+}) {
+  writeOssyJson(pagesGeneratedPath, buildPagesGeneratedPayload(pageFiles, srcDir, cwd))
+}
+
+export function parsePagesFromManifestJson (manifestPath) {
+  try {
+    const raw = fs.readFileSync(manifestPath, 'utf8')
+    const data = JSON.parse(raw)
+    const pages = data?.pages
+    if (!Array.isArray(pages)) return []
+    return pages.map((p) => ({ id: p.id, path: p.path }))
+  } catch {
+    return []
+  }
 }
 
 export function parsePagesFromSource(filePath) {
@@ -545,24 +647,42 @@ export function parsePagesFromSource(filePath) {
   }
 }
 
-export function printBuildOverview({
+/**
+ * Same facts as the old build overview printout, for dashboards / plain logging.
+ */
+export function getBuildOverviewSnapshot ({
   pagesSourcePath,
-  apiSourcePath,
   apiOverviewFiles = [],
   configPath,
   pageFiles,
 }) {
-  const rel = (p) => p ? path.relative(process.cwd(), p) : undefined
+  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)
+
+  const apiRoutes = []
+  for (const f of apiOverviewFiles) {
+    if (fs.existsSync(f)) apiRoutes.push(...parsePagesFromSource(f))
+  }
+
+  return { configRel, pages, apiRoutes }
+}
+
+export function printBuildOverview (opts) {
+  const { configRel, pages, apiRoutes } = getBuildOverviewSnapshot(opts)
   console.log('\n  \x1b[1mBuild overview\x1b[0m')
-  if (fs.existsSync(configPath)) {
-    console.log(`  \x1b[36mConfig:\x1b[0m ${rel(configPath)}`)
+  if (configRel) {
+    console.log(`  \x1b[36mConfig:\x1b[0m ${configRel}`)
   }
   console.log('  ' + '─'.repeat(50))
 
-  const pages = pageFiles?.length
-    ? pageFiles.map((f) => filePathToRoute(f, srcDir))
-    : parsePagesFromSource(pagesSourcePath)
   if (pages.length > 0) {
     console.log('  \x1b[36mRoutes:\x1b[0m')
     const maxId = Math.max(6, ...pages.map((p) => String(p.id).length))
@@ -576,16 +696,6 @@ export function printBuildOverview({
     console.log('  \x1b[33mRoutes:\x1b[0m (could not parse or empty)')
   }
 
-  const apiFilesToScan =
-    apiOverviewFiles?.length > 0
-      ? apiOverviewFiles
-      : fs.existsSync(apiSourcePath)
-        ? [apiSourcePath]
-        : []
-  const apiRoutes = []
-  for (const f of apiFilesToScan) {
-    if (fs.existsSync(f)) apiRoutes.push(...parsePagesFromSource(f))
-  }
   if (apiRoutes.length > 0) {
     console.log('  \x1b[36mAPI routes:\x1b[0m')
     apiRoutes.forEach((r) => {
@@ -601,10 +711,6 @@ export const build = async (cliArgs) => {
         '-c': '--config',
       }, { argv: cliArgs })
 
-    console.log('\n  \x1b[1m@ossy/app\x1b[0m  \x1b[2mbuild\x1b[0m')
-    console.log('  \x1b[2m────────────────────────────────────────\x1b[0m')
-
-
     const scriptDir = path.dirname(url.fileURLToPath(import.meta.url))
     const buildPath = path.resolve('build')
     const srcDir = path.resolve('src')
@@ -613,37 +719,29 @@ export const build = async (cliArgs) => {
 
     resetOssyBuildDir(buildPath)
 
-    writeResourceTemplatesBarrelIfPresent({ cwd: process.cwd(), log: true })
+    const resourceTemplatesResult = writeResourceTemplatesBarrelIfPresent({
+      cwd: process.cwd(),
+      log: false,
+    })
 
-    const pagesGeneratedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_PAGES_BASENAME)
+    const ossyDir = ossyGeneratedDir(buildPath)
+    const pagesGeneratedPath = path.join(ossyDir, OSSY_GEN_PAGES_BASENAME)
 
-    fs.writeFileSync(
+    writePagesManifest({
+      pageFiles,
+      srcDir,
       pagesGeneratedPath,
-      generatePagesModule(pageFiles, srcDir, pagesGeneratedPath)
-    )
-    const ossyDir = ossyGeneratedDir(buildPath)
+    })
     writePageHydrateStubs(pageFiles, srcDir, ossyDir)
     const clientHydrateInput = buildClientHydrateInput(pageFiles, srcDir, ossyDir)
 
-    const {
-      apiSourcePath: resolvedApi,
-      apiOverviewFiles,
-    } = resolveApiSource({
+    const { apiOverviewFiles } = resolveApiSource({
       srcDir,
       buildPath,
     })
-    let apiSourcePath = resolvedApi
     let middlewareSourcePath = path.resolve('src/middleware.js');
     const publicDir = path.resolve('public')
 
-    printBuildOverview({
-      pagesSourcePath: pagesGeneratedPath,
-      apiSourcePath,
-      apiOverviewFiles,
-      configPath,
-      pageFiles,
-    });
-
     if (!fs.existsSync(middlewareSourcePath)) {
       middlewareSourcePath = path.resolve(scriptDir, 'middleware.js')
     }
@@ -652,41 +750,83 @@ export const build = async (cliArgs) => {
       ? configPath
       : path.resolve(scriptDir, 'default-config.js')
 
-    const pagesBundlePath = path.join(ossyDir, OSSY_PAGES_PRERENDER_BUNDLE)
-    const apiBundlePath = path.join(ossyDir, OSSY_API_SERVER_BUNDLE)
-    const tasksBundlePath = path.join(ossyDir, OSSY_TASKS_SERVER_BUNDLE)
+    const pagesEntryPath = path.join(ossyDir, OSSY_PAGES_RUNTIME_BASENAME)
 
-    await bundleOssyNodeEntry({
-      inputPath: pagesGeneratedPath,
-      outputFile: pagesBundlePath,
-      nodeEnv: 'production',
-    })
-    await bundleOssyNodeEntry({
-      inputPath: apiSourcePath,
-      outputFile: apiBundlePath,
-      nodeEnv: 'production',
+    const useDashboard = Object.keys(clientHydrateInput).length > 0
+    const overviewSnap = getBuildOverviewSnapshot({
+      pagesSourcePath: pagesGeneratedPath,
+      apiOverviewFiles,
+      configPath,
+      pageFiles,
     })
-    const { taskSourcePath } = resolveTaskSource({ srcDir, buildPath })
-    await bundleOssyNodeEntry({
-      inputPath: taskSourcePath,
-      outputFile: tasksBundlePath,
+    const idToPath = Object.fromEntries(
+      pageFiles.map((f) => [
+        clientHydrateIdForPage(f, srcDir),
+        filePathToRoute(f, srcDir).path,
+      ])
+    )
+    const pageIds = useDashboard
+      ? [...new Set(pageFiles.map((f) => clientHydrateIdForPage(f, srcDir)))].sort()
+      : []
+
+    let dashboard = null
+    if (useDashboard && pageIds.length > 0) {
+      dashboard = createBuildDashboard({
+        mode: 'full',
+        pageIds,
+        idToPath,
+        overview: {
+          title: '@ossy/app  build',
+          configRel: overviewSnap.configRel,
+          apiRoutes: overviewSnap.apiRoutes,
+        },
+      })
+      dashboard.start()
+      if (resourceTemplatesResult.wrote && resourceTemplatesResult.path) {
+        dashboard.pushLog(
+          `[resource-templates] merged ${resourceTemplatesResult.count} → ${path.relative(process.cwd(), resourceTemplatesResult.path)}`
+        )
+      }
+    } else {
+      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 warnSink = dashboard
+      ? (w) => {
+          dashboard.pushLog(`rollup: ${w.message}`)
+        }
+      : undefined
+
+    const { taskOverviewFiles } = resolveTaskSource({ srcDir, buildPath })
+    await compileOssyNodeArtifacts({
+      pageFiles,
+      srcDir,
+      ossyDir,
+      apiFiles: apiOverviewFiles,
+      taskFiles: taskOverviewFiles,
       nodeEnv: 'production',
+      onWarn: warnSink,
     })
 
     writeAppRuntimeShims({
       middlewareSourcePath,
+      configSourcePath,
       ossyDir,
     })
     copyOssyAppRuntime({ scriptDir, buildPath })
 
-    if (Object.keys(clientHydrateInput).length > 0) {
-      const pageIds = [
-        ...new Set(pageFiles.map((f) => clientHydrateIdForPage(f, srcDir))),
-      ].sort()
-      const reporter = pageIds.length
-        ? createParallelPagesReporter({ pageIds })
-        : null
-      reporter?.printSectionTitle('client hydrate + prerender (parallel)')
+    if (useDashboard && dashboard) {
       try {
         await prerenderReactTask.handler({
           op: 'runProduction',
@@ -695,17 +835,19 @@ export const build = async (cliArgs) => {
           copyPublicFrom: publicDir,
           buildPath,
           nodeEnv: 'production',
-          pagesBundlePath,
+          pagesEntryPath,
           configSourcePath,
           createClientRollupPlugins: createOssyClientRollupPlugins,
           minifyBrowserStaticChunks,
-          reporter,
+          reporter: dashboard,
         })
       } finally {
-        reporter?.dispose()
+        dashboard.dispose()
       }
     }
 
-    console.log('  \x1b[2m────────────────────────────────────────\x1b[0m')
+    if (useDashboard && dashboard) {
+      console.log('  \x1b[2m────────────────────────────────────────\x1b[0m')
+    }
     console.log('  \x1b[32m✔\x1b[0m \x1b[1m@ossy/app\x1b[0m  \x1b[2mbuild finished\x1b[0m\n')
 };