@ossy/app 1.10.1 → 1.11.1

package/cli/build-terminal.js

@@ -0,0 +1,343 @@
+import util from 'node:util'
+
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+
+const dim = (s) => `\x1b[2m${s}\x1b[0m`
+const bold = (s) => `\x1b[1m${s}\x1b[0m`
+const green = (s) => `\x1b[32m${s}\x1b[0m`
+const red = (s) => `\x1b[31m${s}\x1b[0m`
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`
+
+function stripAnsi (s) {
+  return String(s).replace(/\x1b\[[0-9;]*m/g, '')
+}
+
+function padVisible (s, width) {
+  const n = stripAnsi(s).length
+  return n >= width ? s : s + ' '.repeat(width - n)
+}
+
+function truncateVisible (s, maxW) {
+  const plain = stripAnsi(s)
+  if (plain.length <= maxW) return s
+  const cut = Math.max(0, maxW - 1)
+  return plain.slice(0, cut) + '…'
+}
+
+export function pageIdFromHydrateEntryName (entryName) {
+  const p = String(entryName)
+  return p.startsWith('hydrate__') ? p.slice('hydrate__'.length) : p
+}
+
+function fmtPart (part, shortLabel, frame) {
+  if (part.s === 'idle') return dim('—')
+  if (part.s === 'running') {
+    const sp = SPINNER[frame % SPINNER.length]
+    return `${yellow(sp)} ${dim(shortLabel + '…')}`
+  }
+  if (part.s === 'ok') return `${green('✔')} ${dim(`${part.ms}ms`)}`
+  if (part.s === 'fail') return `${red('✖')} ${dim(shortLabel)}`
+  if (part.s === 'skip') return dim(part.note ? `— ${part.note}` : '—')
+  return dim('—')
+}
+
+function rowLeadIcon (r, mode) {
+  if (mode === 'prerender-only') {
+    const p = r.prerender.s
+    if (p === 'fail') return red('✖')
+    if (p === 'running') return yellow('◐')
+    if (p === 'ok' || p === 'skip') return green('✔')
+    if (p === 'idle') return dim('·')
+    return green('✔')
+  }
+  const b = r.bundle.s
+  const p = r.prerender.s
+  if (b === 'fail' || p === 'fail') return red('✖')
+  if (b === 'running' || p === 'running') return yellow('◐')
+  if (b === 'ok' && p === 'idle') return yellow('◐')
+  if (b === 'ok' && (p === 'ok' || p === 'skip')) return green('✔')
+  if (b === 'idle' && p === 'idle') return dim('·')
+  return green('✔')
+}
+
+function useTty (stream) {
+  return (
+    stream.isTTY === true &&
+    process.env.TERM !== 'dumb' &&
+    process.env.CI !== 'true' &&
+    process.env.OSSY_PLAIN_OUTPUT !== '1'
+  )
+}
+
+/**
+ * Merged overview + per-page progress, split layout: left = status table, right = log tail.
+ * TTY: single redraw block + optional console capture into the right column.
+ */
+export function createBuildDashboard ({
+  scope = '@ossy/app',
+  mode = 'full',
+  pageIds,
+  /** @type {Record<string, string>} route path per page id */
+  idToPath = {},
+  overview = { title: '@ossy/app', configRel: null, apiRoutes: [] },
+  stream = process.stdout,
+} = {}) {
+  const ids = [...pageIds].sort()
+  const maxId = Math.max(6, ...ids.map((id) => String(id).length))
+  const tty = useTty(stream)
+  const termW = Math.max(60, stream.columns || 100)
+  const LEFT_W = Math.min(56, Math.max(38, Math.floor(termW * 0.42)))
+  const GAP = 2
+  const RIGHT_W = Math.max(16, termW - LEFT_W - GAP)
+
+  /** @type {Map<string, { bundle: object, prerender: object }>} */
+  const rows = new Map()
+  for (const id of ids) {
+    rows.set(id, {
+      bundle: { s: 'idle' },
+      prerender: { s: 'idle' },
+    })
+  }
+
+  const logBuffer = []
+  const MAX_LOG = 120
+  let frame = 0
+  let spinTimer = null
+  let blockLines = 0
+  let captureActive = false
+  let savedConsole = null
+
+  const anyRunning = () => {
+    for (const r of rows.values()) {
+      if (r.bundle.s === 'running' || r.prerender.s === 'running') return true
+    }
+    return false
+  }
+
+  function pushLog (line) {
+    const s = String(line).trim() ? String(line) : ''
+    if (!s) return
+    if (!tty) {
+      stream.write(`${s}\n`)
+      return
+    }
+    logBuffer.push(dim(s))
+    if (logBuffer.length > MAX_LOG) logBuffer.splice(0, logBuffer.length - MAX_LOG)
+    redraw()
+  }
+
+  function leftHeaderLines () {
+    const out = []
+    out.push(bold(overview.title || `${scope} build`))
+    if (overview.configRel) {
+      out.push(`${dim('config')}  ${truncateVisible(overview.configRel, LEFT_W - 10)}`)
+    }
+    const api = overview.apiRoutes || []
+    if (api.length === 0) {
+      /* noop */
+    } else if (api.length <= 2) {
+      for (const r of api) {
+        const line = `${dim('api')}  ${truncateVisible(`${r.id}  ${r.path}`, LEFT_W - 6)}`
+        out.push(line)
+      }
+    } else {
+      out.push(`${dim('api')}  ${api.length} routes`)
+    }
+    out.push(dim('─'.repeat(Math.min(LEFT_W - 2, 44))))
+    return out
+  }
+
+  function lineForPageRow (id) {
+    const r = rows.get(id)
+    const lead = rowLeadIcon(r, mode)
+    const pathStr = idToPath[id] != null ? dim(String(idToPath[id])) : ''
+    const idCol = padVisible(dim(String(id)), maxId)
+    const pathPad = padVisible(pathStr, 14)
+    const p = fmtPart(r.prerender, 'html', frame)
+    if (mode === 'prerender-only') {
+      return `  ${lead} ${dim(scope)}  ${idCol}  ${pathPad}  ${p}`
+    }
+    const b = fmtPart(r.bundle, 'hydrate', frame)
+    return `  ${lead} ${dim(scope)}  ${idCol}  ${pathPad}  ${padVisible(b, 20)}  ${p}`
+  }
+
+  function buildLeftColumnLines () {
+    const head = leftHeaderLines()
+    const body = ids.map((id) => lineForPageRow(id))
+    return [...head, ...body]
+  }
+
+  function buildHeaderOnlyLines () {
+    return leftHeaderLines()
+  }
+
+  /** Right column row i: logs bottom-aligned to the block height */
+  function rightColumnLine (i, totalRows) {
+    const start = logBuffer.length - totalRows + i
+    if (start < 0 || start >= logBuffer.length) return dim('·')
+    return truncateVisible(logBuffer[start], RIGHT_W)
+  }
+
+  function paintRow (leftLine, rightLine) {
+    const L = padVisible(truncateVisible(leftLine, LEFT_W), LEFT_W)
+    const R = truncateVisible(rightLine, RIGHT_W)
+    return `${L}${' '.repeat(GAP)}${R}\n`
+  }
+
+  function redraw () {
+    if (!tty) return
+    const leftCol = buildLeftColumnLines()
+    const n = leftCol.length
+    const lines = []
+    for (let i = 0; i < n; i++) {
+      lines.push(paintRow(leftCol[i], rightColumnLine(i, n)))
+    }
+    if (blockLines === 0) {
+      for (const ln of lines) stream.write(ln)
+      blockLines = lines.length
+      return
+    }
+    stream.write(`\x1b[${blockLines}A`)
+    for (const ln of lines) {
+      stream.write(`\x1b[2K\r${ln}`)
+    }
+  }
+
+  function ensureSpin () {
+    if (!tty || spinTimer) return
+    spinTimer = setInterval(() => {
+      frame += 1
+      redraw()
+    }, 80)
+  }
+
+  function stopSpin () {
+    if (spinTimer) {
+      clearInterval(spinTimer)
+      spinTimer = null
+    }
+  }
+
+  function nonTtyLine (id, phase, ok, ms, err) {
+    const label = phase === 'bundle' ? 'hydrate' : 'prerender'
+    const icon = ok ? green('✔') : red('✖')
+    const time = ms != null ? dim(` (${ms}ms)`) : ''
+    stream.write(`${icon} ${dim(`${scope}:${label}:`)}${id}${time}\n`)
+    if (err && !ok) stream.write(`    ${red(String(err.message || err))}\n`)
+  }
+
+  function beginCapture () {
+    if (!tty || captureActive) return
+    captureActive = true
+    savedConsole = {
+      log: console.log,
+      warn: console.warn,
+      info: console.info,
+      error: console.error,
+    }
+    const fmt = (...a) => util.format(...a)
+    console.log = (...a) => {
+      pushLog(`[log] ${fmt(...a)}`)
+    }
+    console.warn = (...a) => {
+      pushLog(`[warn] ${fmt(...a)}`)
+    }
+    console.info = (...a) => {
+      pushLog(`[info] ${fmt(...a)}`)
+    }
+    console.error = (...a) => {
+      const msg = fmt(...a)
+      pushLog(`[error] ${msg}`)
+      savedConsole.error(`[@ossy/app] ${msg}`)
+    }
+  }
+
+  function endCapture () {
+    if (!captureActive || !savedConsole) return
+    console.log = savedConsole.log
+    console.warn = savedConsole.warn
+    console.info = savedConsole.info
+    console.error = savedConsole.error
+    savedConsole = null
+    captureActive = false
+  }
+
+  return {
+    pushLog,
+
+    /** Start optional console hijack + first paint (TTY). Plain header only when not a TTY. */
+    start () {
+      if (!tty) {
+        for (const ln of buildHeaderOnlyLines()) {
+          stream.write(`${ln}\n`)
+        }
+        stream.write('\n')
+        return
+      }
+      beginCapture()
+      redraw()
+    },
+
+    startBundle (pageId) {
+      if (mode === 'prerender-only') return
+      const r = rows.get(pageId)
+      if (!r) return
+      r.bundle = { s: 'running' }
+      ensureSpin()
+      redraw()
+    },
+
+    completeBundle (pageId, { ok, ms, error }) {
+      if (mode === 'prerender-only') return
+      const r = rows.get(pageId)
+      if (!r) return
+      r.bundle = ok ? { s: 'ok', ms } : { s: 'fail', ms, error }
+      if (!ok) {
+        r.prerender = { s: 'skip', note: 'bundle failed' }
+        if (!tty) nonTtyLine(pageId, 'bundle', false, ms, error)
+      }
+      if (!anyRunning()) stopSpin()
+      redraw()
+    },
+
+    startPrerender (pageId) {
+      const r = rows.get(pageId)
+      if (!r || r.prerender.s === 'skip') return
+      r.prerender = { s: 'running' }
+      ensureSpin()
+      redraw()
+    },
+
+    completePrerender (pageId, { ok, ms, error }) {
+      const r = rows.get(pageId)
+      if (!r || r.prerender.s === 'skip') return
+      r.prerender = ok ? { s: 'ok', ms } : { s: 'fail', ms, error }
+      if (!tty) nonTtyLine(pageId, 'prerender', ok, ms, error)
+      if (!anyRunning()) stopSpin()
+      redraw()
+    },
+
+    skipPrerender (pageId, note) {
+      const r = rows.get(pageId)
+      if (!r) return
+      if (r.bundle.s === 'fail') return
+      r.prerender = { s: 'skip', note: note || 'skipped' }
+      if (!tty) stream.write(`${dim('—')} ${scope}:prerender:${pageId} (${note})\n`)
+      redraw()
+    },
+
+    printSectionTitle () {
+      /* merged into overview.title — no-op for API compat */
+    },
+
+    dispose () {
+      stopSpin()
+      endCapture()
+      if (tty && blockLines > 0) {
+        redraw()
+        stream.write('\n')
+        blockLines = 0
+      }
+    },
+  }
+}

package/cli/build.js

@@ -12,6 +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 { createBuildDashboard } from './build-terminal.js'
 
 export const PAGE_FILE_PATTERN = /\.page\.(jsx?|tsx?)$/
 export const API_FILE_PATTERN = /\.api\.(mjs|cjs|js)$/
@@ -209,10 +210,17 @@ 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 }) {
   const bundle = await rollup({
     input: inputPath,
     plugins: createOssyAppBundlePlugins({ nodeEnv }),
+    onwarn (warning, defaultHandler) {
+      if (onWarn) {
+        onWarn(warning)
+        return
+      }
+      defaultHandler(warning)
+    },
   })
   await bundle.write({
     file: outputFile,
@@ -544,24 +552,46 @@ 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')
-  console.log('\n  \x1b[1mBuild overview\x1b[0m')
-  if (fs.existsSync(configPath)) {
-    console.log(`  \x1b[36mConfig:\x1b[0m ${rel(configPath)}`)
-  }
-  console.log('  ' + '─'.repeat(50))
+  const configRel = fs.existsSync(configPath) ? rel(configPath) : null
 
   const pages = pageFiles?.length
     ? pageFiles.map((f) => filePathToRoute(f, srcDir))
     : parsePagesFromSource(pagesSourcePath)
+
+  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))
+  }
+
+  return { configRel, pages, apiRoutes }
+}
+
+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))
@@ -575,16 +605,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) => {
@@ -600,9 +620,6 @@ export const build = async (cliArgs) => {
         '-c': '--config',
       }, { argv: cliArgs })
 
-    console.log('[@ossy/app][build] Starting...')
-
-
     const scriptDir = path.dirname(url.fileURLToPath(import.meta.url))
     const buildPath = path.resolve('build')
     const srcDir = path.resolve('src')
@@ -611,7 +628,10 @@ 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)
 
@@ -634,14 +654,6 @@ export const build = async (cliArgs) => {
     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')
     }
@@ -654,21 +666,82 @@ export const build = async (cliArgs) => {
     const apiBundlePath = path.join(ossyDir, OSSY_API_SERVER_BUNDLE)
     const tasksBundlePath = path.join(ossyDir, OSSY_TASKS_SERVER_BUNDLE)
 
+    const useDashboard = Object.keys(clientHydrateInput).length > 0
+    const overviewSnap = getBuildOverviewSnapshot({
+      pagesSourcePath: pagesGeneratedPath,
+      apiSourcePath,
+      apiOverviewFiles,
+      configPath,
+      pageFiles,
+    })
+    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,
+        apiSourcePath,
+        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
+
     await bundleOssyNodeEntry({
       inputPath: pagesGeneratedPath,
       outputFile: pagesBundlePath,
       nodeEnv: 'production',
+      onWarn: warnSink,
     })
     await bundleOssyNodeEntry({
       inputPath: apiSourcePath,
       outputFile: apiBundlePath,
       nodeEnv: 'production',
+      onWarn: warnSink,
     })
     const { taskSourcePath } = resolveTaskSource({ srcDir, buildPath })
     await bundleOssyNodeEntry({
       inputPath: taskSourcePath,
       outputFile: tasksBundlePath,
       nodeEnv: 'production',
+      onWarn: warnSink,
     })
 
     writeAppRuntimeShims({
@@ -677,20 +750,28 @@ export const build = async (cliArgs) => {
     })
     copyOssyAppRuntime({ scriptDir, buildPath })
 
-    if (Object.keys(clientHydrateInput).length > 0) {
-      await prerenderReactTask.handler({
-        op: 'runProduction',
-        clientHydrateInput,
-        pageFilesLength: pageFiles.length,
-        copyPublicFrom: publicDir,
-        buildPath,
-        nodeEnv: 'production',
-        pagesBundlePath,
-        configSourcePath,
-        createClientRollupPlugins: createOssyClientRollupPlugins,
-        minifyBrowserStaticChunks,
-      })
+    if (useDashboard && dashboard) {
+      try {
+        await prerenderReactTask.handler({
+          op: 'runProduction',
+          clientHydrateInput,
+          pageFilesLength: pageFiles.length,
+          copyPublicFrom: publicDir,
+          buildPath,
+          nodeEnv: 'production',
+          pagesBundlePath,
+          configSourcePath,
+          createClientRollupPlugins: createOssyClientRollupPlugins,
+          minifyBrowserStaticChunks,
+          reporter: dashboard,
+        })
+      } finally {
+        dashboard.dispose()
+      }
     }
 
-    console.log('[@ossy/app][build] Finished');
+    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')
 };

package/cli/dev.js

@@ -3,6 +3,8 @@ import url from 'url';
 import fs from 'fs';
 import {
   printBuildOverview,
+  getBuildOverviewSnapshot,
+  filePathToRoute,
   discoverFilesByPattern,
   PAGE_FILE_PATTERN,
   generatePagesModule,
@@ -29,14 +31,13 @@ import {
   OSSY_RESOURCE_TEMPLATES_OUT,
 } from './build.js';
 import prerenderReactTask from './prerender-react.task.js'
+import { createBuildDashboard } from './build-terminal.js'
 import { watch } from 'rollup';
 import arg from 'arg'
 import { spawn } from 'node:child_process'
 // import inject from '@rollup/plugin-inject'
 
 export const dev = async (cliArgs) => {
-    console.log('[@ossy/app][dev] Starting...')
-
     const options = arg({    
         '--config': String,
         '-c': '--config',
@@ -51,7 +52,11 @@ export const dev = async (cliArgs) => {
 
     resetOssyBuildDir(buildPath)
 
-    writeResourceTemplatesBarrelIfPresent({ cwd: process.cwd(), log: true })
+    const resourceTemplatesResult = writeResourceTemplatesBarrelIfPresent({
+      cwd: process.cwd(),
+      log: false,
+    })
+    let resourceTemplatesDevLogged = false
 
     const pagesGeneratedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_PAGES_BASENAME)
     fs.writeFileSync(
@@ -74,13 +79,21 @@ export const dev = async (cliArgs) => {
     let middlewareSourcePath = path.resolve(options['--middleware-source'] || 'src/middleware.js');
     const publicDir = path.resolve('public')
 
-    printBuildOverview({
-      pagesSourcePath: pagesGeneratedPath,
-      apiSourcePath,
-      apiOverviewFiles,
-      configPath,
-      pageFiles,
-    });
+    if (pageFiles.length === 0) {
+      console.log('\n  \x1b[1m@ossy/app\x1b[0m  \x1b[2mdev\x1b[0m')
+      printBuildOverview({
+        pagesSourcePath: pagesGeneratedPath,
+        apiSourcePath,
+        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)}`
+        )
+      }
+    }
 
     if (!fs.existsSync(middlewareSourcePath)) {
       middlewareSourcePath = path.resolve(scriptDir, 'middleware.js')
@@ -225,13 +238,15 @@ export const dev = async (cliArgs) => {
 
     watcher.on('event', async (event) => {
       if (event.code === 'BUNDLE_START') {
-        console.log('[@ossy/app][dev] Building...')
+        console.log('  \x1b[2m◐\x1b[0m \x1b[1m@ossy/app\x1b[0m  \x1b[2mrollup watch …\x1b[0m')
       }
       if (event.code === 'ERROR') {
-        console.error('[@ossy/app][dev] Build error', event.error)
+        console.error('  \x1b[31m✖\x1b[0m \x1b[1m@ossy/app\x1b[0m  build error', event.error)
       }
       if (event.code === 'BUNDLE_END') {
-        console.log(`[@ossy/app][dev] Built in ${event.duration}ms`)
+        console.log(
+          `  \x1b[32m✔\x1b[0m \x1b[1m@ossy/app\x1b[0m  \x1b[2mbundles\x1b[0m  \x1b[2m(${event.duration}ms)\x1b[0m`
+        )
       }
       if (event.code === 'END') {
         writeAppRuntimeShims({
@@ -240,15 +255,58 @@ export const dev = async (cliArgs) => {
         })
         copyOssyAppRuntime({ scriptDir, buildPath })
         if (pageFiles.length > 0) {
+          const pageIds = [
+            ...new Set(pageFiles.map((f) => clientHydrateIdForPage(f, srcDir))),
+          ].sort()
+          const overviewSnap = getBuildOverviewSnapshot({
+            pagesSourcePath: pagesGeneratedPath,
+            apiSourcePath,
+            apiOverviewFiles,
+            configPath,
+            pageFiles,
+          })
+          const idToPath = Object.fromEntries(
+            pageFiles.map((f) => [
+              clientHydrateIdForPage(f, srcDir),
+              filePathToRoute(f, srcDir).path,
+            ])
+          )
+          const reporter = pageIds.length
+            ? createBuildDashboard({
+                mode: 'prerender-only',
+                pageIds,
+                idToPath,
+                overview: {
+                  title: '@ossy/app  dev',
+                  configRel: overviewSnap.configRel,
+                  apiRoutes: overviewSnap.apiRoutes,
+                },
+              })
+            : null
+          reporter?.start()
+          if (
+            !resourceTemplatesDevLogged &&
+            resourceTemplatesResult.wrote &&
+            resourceTemplatesResult.path &&
+            reporter
+          ) {
+            reporter.pushLog(
+              `[resource-templates] merged ${resourceTemplatesResult.count} → ${path.relative(process.cwd(), resourceTemplatesResult.path)}`
+            )
+            resourceTemplatesDevLogged = true
+          }
           try {
             await prerenderReactTask.handler({
               op: 'prerenderPagesParallel',
               pagesBundlePath,
               configSourcePath,
               publicDir: path.join(buildPath, 'public'),
+              reporter,
             })
           } catch (err) {
-            console.error('[@ossy/app][dev] Prerender failed', err)
+            console.error('  \x1b[31m✖\x1b[0m \x1b[1m@ossy/app\x1b[0m  prerender failed', err)
+          } finally {
+            reporter?.dispose()
           }
         }
         scheduleRestart()
@@ -297,7 +355,7 @@ export const dev = async (cliArgs) => {
       }
       const norm = filename.replace(/\\/g, '/')
       if (/\.resource\.js$/.test(norm) && norm.includes('resource-templates/')) {
-        writeResourceTemplatesBarrelIfPresent({ cwd: process.cwd(), log: true })
+        writeResourceTemplatesBarrelIfPresent({ cwd: process.cwd(), log: false })
         const rtOut = path.join(resourceTemplatesDir(process.cwd()), OSSY_RESOURCE_TEMPLATES_OUT)
         if (fs.existsSync(rtOut) && typeof watcher?.invalidate === 'function') {
           watcher.invalidate(rtOut)

package/cli/prerender-react.task.js

@@ -3,6 +3,7 @@ import url from 'url'
 import fs from 'fs'
 import { rollup } from 'rollup'
 import { BuildPage } from './render-page.task.js'
+import { pageIdFromHydrateEntryName } from './build-terminal.js'
 
 /**
  * Maps an app route path to the file path express.static will serve for that URL
@@ -103,6 +104,7 @@ async function bundleHydratePagesParallel ({
   buildPathForPlugins,
   createClientRollupPlugins,
   minifyBrowserStaticChunks,
+  reporter,
 }) {
   copyPublicToBuild({ copyPublicFrom, buildPath })
   fs.mkdirSync(path.join(buildPath, 'public', 'static'), { recursive: true })
@@ -110,29 +112,37 @@ async function bundleHydratePagesParallel ({
   const entries = Object.entries(clientHydrateInput)
 
   const results = await Promise.allSettled(
-    entries.map(([entryName, stubPath]) => {
-      const plugins = createClientRollupPlugins({
-        nodeEnv,
-        copyPublicFrom: undefined,
-        buildPath: buildPathForPlugins,
-      })
-      return bundleOneHydratePage({
-        entryName,
-        stubPath,
-        buildPath,
-        plugins,
-        minifyPlugin: minifyBrowserStaticChunks(),
-      })
+    entries.map(async ([entryName, stubPath]) => {
+      const pageId = pageIdFromHydrateEntryName(entryName)
+      const t0 = Date.now()
+      reporter?.startBundle?.(pageId)
+      try {
+        const plugins = createClientRollupPlugins({
+          nodeEnv,
+          copyPublicFrom: undefined,
+          buildPath: buildPathForPlugins,
+        })
+        await bundleOneHydratePage({
+          entryName,
+          stubPath,
+          buildPath,
+          plugins,
+          minifyPlugin: minifyBrowserStaticChunks(),
+        })
+        reporter?.completeBundle?.(pageId, { ok: true, ms: Date.now() - t0 })
+      } catch (error) {
+        reporter?.completeBundle?.(pageId, {
+          ok: false,
+          ms: Date.now() - t0,
+          error,
+        })
+        console.error(`[@ossy/app][client-bundle] ${entryName} failed:`, error)
+        throw error
+      }
     })
   )
 
   const failures = countSettledFailures(results)
-  results.forEach((r, i) => {
-    if (r.status === 'rejected') {
-      const [entryName] = entries[i]
-      console.error(`[@ossy/app][client-bundle] ${entryName} failed:`, r.reason)
-    }
-  })
 
   return { results, failures }
 }
@@ -157,15 +167,13 @@ async function prerenderOnePage ({
   const outPath = staticHtmlPathForRoute(route.path, publicDir)
   fs.mkdirSync(path.dirname(outPath), { recursive: true })
   fs.writeFileSync(outPath, html, 'utf8')
-  console.log(
-    `[@ossy/app][prerender] ${route.path} → ${path.relative(process.cwd(), outPath)}`
-  )
 }
 
 async function prerenderPagesParallel ({
   pagesBundlePath,
   configSourcePath,
   publicDir,
+  reporter,
 }) {
   const cfgHref = url.pathToFileURL(path.resolve(configSourcePath)).href
   const pagesHref = url.pathToFileURL(path.resolve(pagesBundlePath)).href
@@ -180,6 +188,10 @@ async function prerenderPagesParallel ({
   for (const route of pageList) {
     if (!route?.element) continue
     if (!pathIsPrerenderable(route.path)) {
+      reporter?.skipPrerender?.(
+        route.id,
+        `not static (${JSON.stringify(route.path)})`
+      )
       console.warn(
         `[@ossy/app][prerender] Skipping "${route.id}" (path not prerenderable: ${JSON.stringify(route.path)})`
       )
@@ -189,25 +201,32 @@ async function prerenderPagesParallel ({
   }
 
   const results = await Promise.allSettled(
-    routesToRender.map((route) =>
-      prerenderOnePage({
-        route,
-        buildTimeConfig,
-        pageList,
-        publicDir,
-      })
-    )
+    routesToRender.map(async (route) => {
+      const t0 = Date.now()
+      reporter?.startPrerender?.(route.id)
+      try {
+        await prerenderOnePage({
+          route,
+          buildTimeConfig,
+          pageList,
+          publicDir,
+        })
+        reporter?.completePrerender?.(route.id, { ok: true, ms: Date.now() - t0 })
+      } catch (error) {
+        reporter?.completePrerender?.(route.id, {
+          ok: false,
+          ms: Date.now() - t0,
+          error,
+        })
+        console.error(
+          `[@ossy/app][prerender] "${route?.id}" (${route?.path}) failed:`,
+          error
+        )
+        throw error
+      }
+    })
   )
   const failures = countSettledFailures(results)
-  results.forEach((r, i) => {
-    if (r.status === 'rejected') {
-      const route = routesToRender[i]
-      console.error(
-        `[@ossy/app][prerender] "${route?.id}" (${route?.path}) failed:`,
-        r.reason
-      )
-    }
-  })
 
   return { results, failures }
 }
@@ -222,6 +241,7 @@ async function runProduction ({
   configSourcePath,
   createClientRollupPlugins,
   minifyBrowserStaticChunks,
+  reporter,
 }) {
   if (pageFilesLength === 0 || Object.keys(clientHydrateInput).length === 0) {
     return { bundleFailures: 0, prerenderFailures: 0 }
@@ -235,12 +255,14 @@ async function runProduction ({
     buildPathForPlugins: buildPath,
     createClientRollupPlugins,
     minifyBrowserStaticChunks,
+    reporter,
   })
 
   const { failures: prerenderFailures } = await prerenderPagesParallel({
     pagesBundlePath,
     configSourcePath,
     publicDir: path.join(buildPath, 'public'),
+    reporter,
   })
 
   if (bundleFailures + prerenderFailures > 0) {
@@ -261,7 +283,12 @@ export default {
       return runProduction(input)
     }
     if (op === 'prerenderPagesParallel') {
-      return prerenderPagesParallel(input)
+      return prerenderPagesParallel({
+        pagesBundlePath: input.pagesBundlePath,
+        configSourcePath: input.configSourcePath,
+        publicDir: input.publicDir,
+        reporter: input.reporter,
+      })
     }
     throw new Error(
       `[@ossy/app][prerender-react] Unknown op: ${String(op)} (expected runProduction | prerenderPagesParallel)`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/app",
-  "version": "1.10.1",
+  "version": "1.11.1",
   "description": "",
   "source": "./src/index.js",
   "main": "./src/index.js",
@@ -27,14 +27,14 @@
     "@babel/eslint-parser": "^7.15.8",
     "@babel/preset-react": "^7.26.3",
     "@babel/register": "^7.25.9",
-    "@ossy/connected-components": "^1.10.1",
-    "@ossy/design-system": "^1.10.1",
-    "@ossy/pages": "^1.10.1",
-    "@ossy/router": "^1.10.1",
-    "@ossy/router-react": "^1.10.1",
-    "@ossy/sdk": "^1.10.1",
-    "@ossy/sdk-react": "^1.10.1",
-    "@ossy/themes": "^1.10.1",
+    "@ossy/connected-components": "^1.11.1",
+    "@ossy/design-system": "^1.11.1",
+    "@ossy/pages": "^1.11.1",
+    "@ossy/router": "^1.11.1",
+    "@ossy/router-react": "^1.11.1",
+    "@ossy/sdk": "^1.11.1",
+    "@ossy/sdk-react": "^1.11.1",
+    "@ossy/themes": "^1.11.1",
     "@rollup/plugin-alias": "^6.0.0",
     "@rollup/plugin-babel": "6.1.0",
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -67,5 +67,5 @@
     "README.md",
     "tsconfig.json"
   ],
-  "gitHead": "d1148a29edb70bdf5daec5571504268723c9d669"
+  "gitHead": "dfa200a3ea12c726db2054a0ab902844507716a0"
 }