@ossy/app 1.11.7 → 1.11.8

package/cli/build-terminal.js

@@ -1,5 +1,3 @@
-import util from 'node:util'
-
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
 
 const dim = (s) => `\x1b[2m${s}\x1b[0m`
@@ -69,15 +67,10 @@ function useTty (stream) {
   )
 }
 
-/**
- * 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,
@@ -86,11 +79,7 @@ export function createBuildDashboard ({
   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, {
@@ -99,13 +88,9 @@ export function createBuildDashboard ({
     })
   }
 
-  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()) {
@@ -114,36 +99,23 @@ export function createBuildDashboard ({
     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 () {
+  function headerLines () {
     const out = []
     out.push(bold(overview.title || `${scope} build`))
     if (overview.configRel) {
-      out.push(`${dim('config')}  ${truncateVisible(overview.configRel, LEFT_W - 10)}`)
+      out.push(`${dim('config')}  ${truncateVisible(overview.configRel, termW - 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)
+    if (api.length > 0) {
+      if (api.length <= 2) {
+        for (const r of api) {
+          out.push(`${dim('api')}  ${truncateVisible(`${r.id}  ${r.path}`, termW - 6)}`)
+        }
+      } else {
+        out.push(`${dim('api')}  ${api.length} routes`)
       }
-    } else {
-      out.push(`${dim('api')}  ${api.length} routes`)
     }
-    out.push(dim('─'.repeat(Math.min(LEFT_W - 2, 44))))
+    out.push(dim('─'.repeat(Math.min(termW - 2, 44))))
     return out
   }
 
@@ -161,46 +133,20 @@ export function createBuildDashboard ({
     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 buildLines () {
+    return [...headerLines(), ...ids.map((id) => lineForPageRow(id))]
   }
 
   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)))
-    }
+    const lines = buildLines()
     if (blockLines === 0) {
-      for (const ln of lines) stream.write(ln)
+      for (const ln of lines) stream.write(ln + '\n')
       blockLines = lines.length
       return
     }
     stream.write(`\x1b[${blockLines}A`)
-    for (const ln of lines) {
-      stream.write(`\x1b[2K\r${ln}`)
-    }
+    for (const ln of lines) stream.write(`\x1b[2K\r${ln}\n`)
   }
 
   function ensureSpin () {
@@ -226,55 +172,13 @@ export function createBuildDashboard ({
     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`)
-        }
+        for (const ln of headerLines()) stream.write(`${ln}\n`)
         stream.write('\n')
         return
       }
-      beginCapture()
       redraw()
     },
 
@@ -326,13 +230,8 @@ export function createBuildDashboard ({
       redraw()
     },
 
-    printSectionTitle () {
-      /* merged into overview.title — no-op for API compat */
-    },
-
     dispose () {
       stopSpin()
-      endCapture()
       if (tty && blockLines > 0) {
         redraw()
         stream.write('\n')

package/cli/build.js

@@ -87,6 +87,11 @@ export const OSSY_PAGE_SERVER_EXTERNAL = [
   'react/jsx-runtime',
 ]
 
+/** Output directory (relative to buildPath) for per-page SSR bundles. */
+export const OSSY_SSR_DIRNAME = 'ssr'
+/** Temp stub entries for SSR bundles (inside .ossy/). */
+const OSSY_SSR_ENTRIES_DIRNAME = 'ssr-entries'
+
 /** Per-page client entries: `hydrate-<pageId>.jsx` under `.ossy/` */
 const HYDRATE_STUB_PREFIX = 'hydrate-'
 const HYDRATE_STUB_SUFFIX = '.jsx'
@@ -200,7 +205,8 @@ export function createOssyAppBundlePlugins ({ nodeEnv }) {
 }
 
 /**
- * Rollup plugins for browser hydrate bundles.
+ * Rollup plugins for browser hydrate bundles. React and all deps are bundled in so the output
+ * is self-contained and requires no import maps or CDN.
  */
 export function createOssyClientRollupPlugins ({ nodeEnv, copyPublicFrom, buildPath }) {
   const plugins = [
@@ -212,7 +218,7 @@ export function createOssyClientRollupPlugins ({ nodeEnv, copyPublicFrom, buildP
     nodeExternals({
       deps: false,
       devDeps: true,
-      peerDeps: true,
+      peerDeps: false,
       packagePath: path.join(process.cwd(), 'package.json'),
     }),
     resolveCommonJsDependencies(),
@@ -233,6 +239,106 @@ export function createOssyClientRollupPlugins ({ nodeEnv, copyPublicFrom, buildP
   return plugins
 }
 
+/**
+ * Rollup plugins for per-page SSR bundles: server-side resolution, React and all deps bundled in
+ * so the output is self-contained (no node_modules needed at runtime).
+ */
+export function createOssySsrBundlePlugins ({ 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'],
+    }),
+  ]
+}
+
+/** Generates the SSR entry stub for a page: exports renderPage(props, options) and metadata. */
+export function generatePageSsrModule ({ pageAbsPath, stubAbsPath }) {
+  const rel = relToGeneratedImport(stubAbsPath, pageAbsPath)
+  return [
+    '// Generated by @ossy/app — do not edit',
+    '',
+    "import { createElement } from 'react'",
+    "import { renderToPipeableStream } from 'react-dom/server'",
+    "import { Writable } from 'node:stream'",
+    `import * as _page from './${rel}'`,
+    '',
+    'export const metadata = _page.metadata',
+    '',
+    'export function renderPage (props, options = {}) {',
+    '  return new Promise((resolve, reject) => {',
+    "    let html = ''",
+    '    const writable = new Writable({',
+    '      write (chunk, _enc, cb) { html += chunk.toString(); cb() },',
+    '    })',
+    '    const { pipe } = renderToPipeableStream(createElement(_page.default, props), {',
+    '      ...options,',
+    '      onAllReady () { pipe(writable) },',
+    '      onError (err) { reject(err) },',
+    '    })',
+    "    writable.on('finish', () => resolve(html))",
+    '  })',
+    '}',
+    '',
+  ].join('\n')
+}
+
+/** Writes `ssr-entries/<id>.mjs` stubs for each page into ossyDir. */
+export function writePageSsrStubs (pageFiles, srcDir, ossyDir) {
+  const entriesDir = path.join(ossyDir, OSSY_SSR_ENTRIES_DIRNAME)
+  fs.rmSync(entriesDir, { recursive: true, force: true })
+  if (pageFiles.length === 0) return
+  fs.mkdirSync(entriesDir, { recursive: true })
+  for (const f of pageFiles) {
+    const pageId = clientHydrateIdForPage(f, srcDir)
+    const stubPath = path.join(entriesDir, `${pageId}.mjs`)
+    fs.writeFileSync(stubPath, generatePageSsrModule({ pageAbsPath: f, stubAbsPath: stubPath }))
+  }
+}
+
+/** Compiles per-page SSR bundles to `build/ssr/<id>.mjs`. Each is self-contained with React bundled in. */
+export async function compilePageSsrModules ({ pageFiles, srcDir, ossyDir, buildPath, nodeEnv, onWarn }) {
+  const ssrDir = path.join(buildPath, OSSY_SSR_DIRNAME)
+  const entriesDir = path.join(ossyDir, OSSY_SSR_ENTRIES_DIRNAME)
+  fs.rmSync(ssrDir, { recursive: true, force: true })
+  if (pageFiles.length === 0) return []
+  fs.mkdirSync(ssrDir, { recursive: true })
+  const plugins = createOssySsrBundlePlugins({ nodeEnv })
+  const results = await Promise.all(
+    pageFiles.map(async (f) => {
+      const pageId = clientHydrateIdForPage(f, srcDir)
+      const stubPath = path.join(entriesDir, `${pageId}.mjs`)
+      const outFile = path.join(ssrDir, `${pageId}.mjs`)
+      const bundle = await rollup({
+        input: stubPath,
+        plugins,
+        onwarn (warning, defaultHandler) {
+          if (onWarn) { onWarn(warning); return }
+          defaultHandler(warning)
+        },
+      })
+      await bundle.write({ file: outFile, format: 'esm', inlineDynamicImports: true })
+      await bundle.close()
+      return { id: pageId }
+    })
+  )
+  return results
+}
+
 /** 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({
@@ -455,39 +561,40 @@ export async function compileTaskServerModules ({ taskFiles, ossyDir, nodeEnv, o
  * Merges compiled `metadata` + `module` into `pages.generated.json` (same order as `pageBundleList`).
  * Writes `module` on each route for Node SSR (`import()` of `page-modules/*.mjs`); hydrate uses a separate Rollup client entry.
  */
-export async function enrichPagesGeneratedManifest ({
-  ossyDir,
-  pagesGeneratedPath,
-  pageBundleList,
-}) {
-  if (!pageBundleList?.length || !fs.existsSync(pagesGeneratedPath)) return
+/**
+ * Enriches `pages.generated.json` with `module` paths pointing to SSR bundles and merges
+ * any `metadata` exported by each page. Runs after SSR bundles are compiled.
+ */
+export async function enrichPagesGeneratedManifest ({ ossyDir, pagesGeneratedPath }) {
+  if (!fs.existsSync(pagesGeneratedPath)) return
   const raw = JSON.parse(fs.readFileSync(pagesGeneratedPath, 'utf8'))
   const basePages = raw?.pages
-  if (!Array.isArray(basePages) || basePages.length !== pageBundleList.length) {
-    throw new Error(
-      '[@ossy/app] pages.generated.json page count must match compiled page modules (re-run build).'
-    )
-  }
+  if (!Array.isArray(basePages) || basePages.length === 0) return
+
   const pages = []
-  for (let i = 0; i < basePages.length; i++) {
-    const abs = path.join(ossyDir, pageBundleList[i].module)
-    const mod = await import(pathToFileURL(abs).href)
-    const meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
-    const derived = { id: basePages[i].id, path: basePages[i].path }
+  for (const basePage of basePages) {
+    const moduleRelPath = `../ssr/${basePage.id}.mjs`
+    const bundleAbs = path.join(ossyDir, moduleRelPath)
+    let meta = {}
+    if (fs.existsSync(bundleAbs)) {
+      try {
+        const mod = await import(pathToFileURL(bundleAbs).href)
+        meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
+      } catch {
+        // metadata unreadable — continue with defaults
+      }
+    }
     const merged = {
-      ...derived,
+      id: basePage.id,
+      path: basePage.path,
       ...meta,
-      sourceFile: basePages[i].sourceFile,
-      module: pageBundleList[i].module,
+      sourceFile: basePage.sourceFile,
+      module: moduleRelPath,
     }
     try {
       JSON.stringify(merged)
     } catch {
-      pages.push({
-        ...derived,
-        sourceFile: basePages[i].sourceFile,
-        module: pageBundleList[i].module,
-      })
+      pages.push({ id: basePage.id, path: basePage.path, sourceFile: basePage.sourceFile, module: moduleRelPath })
       continue
     }
     pages.push(merged)
@@ -496,26 +603,23 @@ export async function enrichPagesGeneratedManifest ({
 }
 
 /**
- * Writes `pages.bundle.json`, `api.bundle.json`, `tasks.bundle.json` by Rollup-compiling each source module.
+ * Compiles server-side artifacts: per-page SSR bundles, API modules, and task modules.
  */
 export async function compileOssyNodeArtifacts ({
   pageFiles,
   srcDir,
   ossyDir,
+  buildPath,
   apiFiles,
   taskFiles,
   nodeEnv,
   onWarn,
 }) {
-  const [pageBundleList, apiModuleList, taskModuleList] = await Promise.all([
-    compilePageServerModules({ pageFiles, srcDir, ossyDir, nodeEnv, onWarn }),
+  const [, apiModuleList, taskModuleList] = await Promise.all([
+    compilePageSsrModules({ pageFiles, srcDir, ossyDir, buildPath, 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,
@@ -527,7 +631,6 @@ export async function compileOssyNodeArtifacts ({
   await enrichPagesGeneratedManifest({
     ossyDir,
     pagesGeneratedPath: path.join(ossyDir, OSSY_GEN_PAGES_BASENAME),
-    pageBundleList,
   })
 }
 
@@ -598,8 +701,9 @@ export function writePageServerRollupEntry ({ pageAbsPath, stubPath }) {
 }
 
 /**
- * One client entry per page: Rollup bundles this stub with the page source so `react` resolves in the browser.
- * (Do not `import()` the Node `page-modules/*.mjs` build from the client — those files use bare `react` specifiers.)
+ * One bundle per page: exports the component (for server SSR import) and auto-hydrates in the browser.
+ * React is kept as a bare external import — resolved from node_modules on the server and via
+ * import map on the client.
  */
 export function generatePageHydrateModule ({ pageAbsPath, stubAbsPath, srcDir }) {
   const rel = relToGeneratedImport(stubAbsPath, pageAbsPath)
@@ -607,17 +711,17 @@ export function generatePageHydrateModule ({ pageAbsPath, stubAbsPath, srcDir })
     '// Generated by @ossy/app — do not edit',
     '',
     "import React, { createElement } from 'react'",
-    "import 'react-dom'",
     "import { hydrateRoot } from 'react-dom/client'",
     `import * as _page from './${rel}'`,
     '',
-    'const initialConfig = window.__INITIAL_APP_CONFIG__ || {}',
-    'const Page = _page?.default',
-    'if (typeof Page !== \'function\') {',
-    '  throw new Error(`[@ossy/app] Page must export default as a function component`)',
+    'export default _page.default',
+    'export const metadata = _page.metadata',
+    '',
+    "if (typeof window !== 'undefined') {",
+    "  const Page = _page.default",
+    "  const config = window.__INITIAL_APP_CONFIG__ || {}",
+    "  hydrateRoot(document, createElement(Page, config))",
     '}',
-    'const rootTree = createElement(Page, initialConfig)',
-    'hydrateRoot(document, rootTree)',
     '',
   ].join('\n')
 }
@@ -816,6 +920,7 @@ export const build = async (cliArgs) => {
       pagesGeneratedPath,
     })
     writePageHydrateStubs(pageFiles, srcDir, ossyDir)
+    writePageSsrStubs(pageFiles, srcDir, ossyDir)
     const clientHydrateInput = buildClientHydrateInput(pageFiles, srcDir, ossyDir)
 
     const { apiOverviewFiles } = resolveApiSource({
@@ -833,8 +938,6 @@ export const build = async (cliArgs) => {
       ? configPath
       : path.resolve(scriptDir, 'default-config.js')
 
-    const pagesEntryPath = path.join(ossyDir, OSSY_PAGES_RUNTIME_BASENAME)
-
     const useDashboard = Object.keys(clientHydrateInput).length > 0
     const overviewSnap = getBuildOverviewSnapshot({
       pagesSourcePath: pagesGeneratedPath,
@@ -865,11 +968,6 @@ export const build = async (cliArgs) => {
         },
       })
       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({
@@ -878,28 +976,23 @@ export const build = async (cliArgs) => {
         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
+    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({
       pageFiles,
       srcDir,
       ossyDir,
+      buildPath,
       apiFiles: apiOverviewFiles,
       taskFiles: taskOverviewFiles,
       nodeEnv: 'production',
-      onWarn: warnSink,
     })
 
     writeAppRuntimeShims({
@@ -918,8 +1011,6 @@ export const build = async (cliArgs) => {
           copyPublicFrom: publicDir,
           buildPath,
           nodeEnv: 'production',
-          pagesEntryPath,
-          configSourcePath,
           createClientRollupPlugins: createOssyClientRollupPlugins,
           minifyBrowserStaticChunks,
           reporter: dashboard,
@@ -929,8 +1020,5 @@ export const build = async (cliArgs) => {
       }
     }
 
-    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/index.js

@@ -1,21 +1,16 @@
 #!/usr/bin/env node
 import { build } from './build.js'
-import { dev } from './dev.js'
 
 const [,, command, ...restArgs] = process.argv
 
 if (!command) {
   console.error(
-    '[@ossy/app] No command provided. Usage: app dev | build'
+    '[@ossy/app] No command provided. Usage: app build'
   )
   process.exit(1)
 }
 
 const run = async () => {
-  if (command === 'dev') {
-    await dev(restArgs)
-    return
-  }
   if (command === 'build') {
     await build(restArgs)
     return

package/cli/prerender-react.task.js

@@ -1,29 +1,8 @@
 import path from 'path'
-import url from 'url'
 import fs from 'fs'
 import { rollup } from 'rollup'
-import { BuildPage, buildPrerenderAppConfig } 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
- * (`/` → `public/index.html`, `/a/b` → `public/a/b/index.html`).
- */
-export function staticHtmlPathForRoute (routePath, publicDir) {
-  const p = typeof routePath === 'string' ? routePath : '/'
-  if (p === '/' || p === '') {
-    return path.join(publicDir, 'index.html')
-  }
-  const segments = p.replace(/^\//, '').split('/').filter(Boolean)
-  return path.join(publicDir, ...segments, 'index.html')
-}
-
-function pathIsPrerenderable (routePath) {
-  if (typeof routePath !== 'string') return false
-  if (!routePath.startsWith('/') || routePath.includes(':')) return false
-  return true
-}
-
 function copyPublicToBuild ({ copyPublicFrom, buildPath }) {
   if (!copyPublicFrom || !fs.existsSync(copyPublicFrom)) return
   const dest = path.join(buildPath, 'public')
@@ -31,10 +10,6 @@ function copyPublicToBuild ({ copyPublicFrom, buildPath }) {
   fs.cpSync(copyPublicFrom, dest, { recursive: true })
 }
 
-function countSettledFailures (results) {
-  return results.filter((r) => r.status === 'rejected').length
-}
-
 async function bundleOneHydratePage ({
   entryName,
   stubPath,
@@ -113,156 +88,37 @@ async function bundleHydratePagesParallel ({
     })
   )
 
-  const failures = countSettledFailures(results)
-
-  return { results, failures }
-}
-
-async function prerenderOnePage ({
-  route,
-  buildTimeConfig,
-  pageList,
-  publicDir,
-}) {
-  const appConfig = buildPrerenderAppConfig({
-    buildTimeConfig,
-    pageList,
-    activeRouteId: route.id,
-    urlPath: route.path,
-  })
-  const html = await BuildPage.handle({
-    route,
-    appConfig,
-    isDevReloadEnabled: false,
-  })
-  const outPath = staticHtmlPathForRoute(route.path, publicDir)
-  fs.mkdirSync(path.dirname(outPath), { recursive: true })
-  fs.writeFileSync(outPath, html, 'utf8')
-}
-
-async function prerenderPagesParallel ({
-  pagesEntryPath,
-  configSourcePath,
-  publicDir,
-  reporter,
-}) {
-  const cfgHref = url.pathToFileURL(path.resolve(configSourcePath)).href
-  const pagesHref = url.pathToFileURL(path.resolve(pagesEntryPath)).href
-
-  const configModule = await import(cfgHref)
-  const pagesModule = await import(pagesHref)
-
-  const buildTimeConfig = configModule?.default ?? configModule ?? {}
-  const pageList = pagesModule?.default ?? []
-
-  const routesToRender = []
-  for (const route of pageList) {
-    if (typeof route?.module !== 'string' || !route.module) 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)})`
-      )
-      continue
-    }
-    routesToRender.push(route)
-  }
-
-  const results = await Promise.allSettled(
-    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)
-
+  const failures = results.filter((r) => r.status === 'rejected').length
   return { results, failures }
 }
 
-async function runProduction ({
-  clientHydrateInput,
-  pageFilesLength,
-  copyPublicFrom,
-  buildPath,
-  nodeEnv,
-  pagesEntryPath,
-  configSourcePath,
-  createClientRollupPlugins,
-  minifyBrowserStaticChunks,
-  reporter,
-}) {
-  if (pageFilesLength === 0 || Object.keys(clientHydrateInput).length === 0) {
-    return { bundleFailures: 0, prerenderFailures: 0 }
-  }
-
-  const { failures: bundleFailures } = await bundleHydratePagesParallel({
-    clientHydrateInput,
-    buildPath,
-    copyPublicFrom,
-    nodeEnv,
-    buildPathForPlugins: buildPath,
-    createClientRollupPlugins,
-    minifyBrowserStaticChunks,
-    reporter,
-  })
-
-  const { failures: prerenderFailures } = await prerenderPagesParallel({
-    pagesEntryPath,
-    configSourcePath,
-    publicDir: path.join(buildPath, 'public'),
-    reporter,
-  })
-
-  if (bundleFailures + prerenderFailures > 0) {
-    console.warn(
-      `[@ossy/app][build] Finished with ${bundleFailures} client bundle error(s) and ${prerenderFailures} prerender error(s)`
-    )
-  }
-
-  return { bundleFailures, prerenderFailures }
-}
-
 export default {
   type: '@ossy/app/prerender-react',
-  /** `input.op`: `runProduction` | `prerenderPagesParallel` (see callers in `build.js` / `dev.js`). */
   async handler (input) {
     const op = input?.op
     if (op === 'runProduction') {
-      return runProduction(input)
-    }
-    if (op === 'prerenderPagesParallel') {
-      return prerenderPagesParallel({
-        pagesEntryPath: input.pagesEntryPath,
-        configSourcePath: input.configSourcePath,
-        publicDir: input.publicDir,
-        reporter: input.reporter,
+      const { clientHydrateInput, pageFilesLength, copyPublicFrom, buildPath, nodeEnv,
+              buildPathForPlugins, createClientRollupPlugins, minifyBrowserStaticChunks, reporter } = input
+      if (pageFilesLength === 0 || Object.keys(clientHydrateInput).length === 0) {
+        return { bundleFailures: 0 }
+      }
+      const { failures: bundleFailures } = await bundleHydratePagesParallel({
+        clientHydrateInput,
+        buildPath,
+        copyPublicFrom,
+        nodeEnv,
+        buildPathForPlugins: buildPathForPlugins ?? buildPath,
+        createClientRollupPlugins,
+        minifyBrowserStaticChunks,
+        reporter,
       })
+      if (bundleFailures > 0) {
+        console.warn(`[@ossy/app][build] Finished with ${bundleFailures} client bundle error(s)`)
+      }
+      return { bundleFailures }
     }
     throw new Error(
-      `[@ossy/app][prerender-react] Unknown op: ${String(op)} (expected runProduction | prerenderPagesParallel)`
+      `[@ossy/app][prerender-react] Unknown op: ${String(op)} (expected runProduction)`
     )
   },
 }

package/cli/render-page.task.js

@@ -1,30 +1,22 @@
 import path from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import React, { createElement } from 'react'
-import { prerenderToNodeStream } from 'react-dom/static'
 
 const __ossyDir = path.dirname(fileURLToPath(import.meta.url))
 
-async function loadPageDefaultExport (route) {
-  if (typeof route?.module !== 'string' || !route.module) {
-    throw new Error(
-      `[@ossy/app][BuildPage] Route "${route?.id ?? '?'}" has no compiled module path (re-run build so pages.generated.json includes "module").`
-    )
+async function loadSsrBundle (route) {
+  if (typeof route?.id !== 'string' || !route.id) {
+    throw new Error(`[@ossy/app][BuildPage] Route has no id`)
   }
-  const abs = path.join(__ossyDir, route.module)
-  const mod = await import(pathToFileURL(abs).href)
-  const def = mod?.default
-  if (typeof def !== 'function') {
+  const bundlePath = path.join(__ossyDir, '..', 'ssr', `${route.id}.mjs`)
+  const mod = await import(pathToFileURL(bundlePath).href)
+  if (typeof mod?.renderPage !== 'function') {
     throw new Error(
-      `[@ossy/app][BuildPage] Page "${route?.id}" must export default as a function component (got ${typeof def}).`
+      `[@ossy/app][BuildPage] SSR bundle for "${route.id}" must export renderPage (got ${typeof mod?.renderPage}).`
     )
   }
-  return def
+  return mod
 }
 
-/**
- * App shell config for SSR / prerender (mirrors client: theme, pages metadata, props for the active page).
- */
 export function buildPrerenderAppConfig ({
   buildTimeConfig,
   pageList,
@@ -32,11 +24,9 @@ export function buildPrerenderAppConfig ({
   urlPath,
   isAuthenticated = false,
 }) {
-  /** `module` is the compiled page path under `.ossy/` (Node `import()` only; not loaded as raw ESM in the browser). */
   const pages = pageList.map((page) => ({
     id: page?.id,
     path: page?.path,
-    ...(typeof page?.module === 'string' ? { module: page.module } : {}),
   }))
   return {
     ...buildTimeConfig,
@@ -50,23 +40,8 @@ export function buildPrerenderAppConfig ({
   }
 }
 
-/** Strips non-JSON content for the bootstrap script; keeps serializable route fields including `module`. */
-export function appConfigForBootstrap (appConfig) {
-  if (!appConfig || typeof appConfig !== 'object') return appConfig
-  const pages = Array.isArray(appConfig.pages)
-    ? appConfig.pages.map(({ id, path, module }) => ({
-        id,
-        path,
-        ...(typeof module === 'string' ? { module } : {}),
-      }))
-    : appConfig.pages
-  return { ...appConfig, pages }
-}
-
-/** Plain data clone so server render props match `JSON.parse(JSON.stringify(...))` on the client. */
 function jsonSafeClone (value) {
   if (value == null || typeof value !== 'object') return value
-  if (typeof value === 'function' || React.isValidElement(value)) return value
   try {
     return JSON.parse(JSON.stringify(value))
   } catch {
@@ -74,42 +49,24 @@ function jsonSafeClone (value) {
   }
 }
 
-/**
- * Props passed to `<App>` for SSR and the exact object embedded in `window.__INITIAL_APP_CONFIG__`.
- * Keeps server and hydrate trees aligned (fixes React #418 hydration mismatches).
- */
 export function buildHydrationAppConfig (appConfig) {
-  const base = appConfigForBootstrap(appConfig)
+  if (!appConfig || typeof appConfig !== 'object') return appConfig
   return {
-    ...base,
-    theme: jsonSafeClone(base.theme),
-    themes: jsonSafeClone(base.themes),
-    resourceTemplates: jsonSafeClone(base.resourceTemplates),
+    ...appConfig,
+    theme: jsonSafeClone(appConfig.theme),
+    themes: jsonSafeClone(appConfig.themes),
+    resourceTemplates: jsonSafeClone(appConfig.resourceTemplates),
   }
 }
 
 export const BuildPage = {
-  async handle ({ route, appConfig, isDevReloadEnabled }) {
+  async handle ({ route, appConfig }) {
     const hydrationConfig = buildHydrationAppConfig(appConfig)
-    const Page = await loadPageDefaultExport(route)
-    const rootElement = createElement(Page, hydrationConfig)
-    const devReloadScript = isDevReloadEnabled
-      ? `(function(){try{var es=new EventSource('/__ossy_reload');es.addEventListener('reload',function(){location.reload();});}catch(e){}})();`
-      : ``
-
-    const hydrateUrl = `/static/${route.id}.js`
-    const { prelude } = await prerenderToNodeStream(rootElement, {
-      bootstrapScriptContent: `window.__INITIAL_APP_CONFIG__ = ${JSON.stringify(hydrationConfig)};${devReloadScript}`,
-      bootstrapModules: [hydrateUrl],
-    })
+    const { renderPage } = await loadSsrBundle(route)
 
-    return new Promise((resolve, reject) => {
-      let data = ''
-      prelude.on('data', (chunk) => {
-        data += chunk
-      })
-      prelude.on('end', () => resolve(data))
-      prelude.on('error', reject)
+    return renderPage(hydrationConfig, {
+      bootstrapScriptContent: `window.__INITIAL_APP_CONFIG__=${JSON.stringify(hydrationConfig)}`,
+      bootstrapModules: [`/static/${route.id}.js`],
     })
   },
 }

package/cli/server.js

@@ -39,9 +39,6 @@ const app = express();
 const currentDir = path.dirname(url.fileURLToPath(import.meta.url))
 const ROOT_PATH = path.resolve(currentDir, 'public')
 
-const isDevReloadEnabled = process.env.OSSY_DEV_RELOAD === '1'
-const reloadClients = new Set()
-
 function parsePortFromArgv(argv) {
   // Supports: --port 4000, --port=4000, -p 4000
   const idx = argv.findIndex(a => a === '--port' || a === '-p')
@@ -67,33 +64,6 @@ if (Middleware !== undefined) {
   console.log(`[@ossy/app][server] ${Middleware?.length || 0} custom middleware loaded`)
 }
 
-if (isDevReloadEnabled) {
-  app.get('/__ossy_reload', (req, res) => {
-    res.status(200)
-    res.setHeader('Content-Type', 'text/event-stream')
-    res.setHeader('Cache-Control', 'no-cache')
-    res.setHeader('Connection', 'keep-alive')
-    res.flushHeaders?.()
-
-    res.write('event: connected\ndata: ok\n\n')
-    reloadClients.add(res)
-
-    req.on('close', () => {
-      reloadClients.delete(res)
-    })
-  })
-
-  app.post('/__ossy_reload', (req, res) => {
-    for (const client of reloadClients) {
-      try {
-        client.write('event: reload\ndata: now\n\n')
-      } catch {
-        // ignore broken connections
-      }
-    }
-    res.status(204).end()
-  })
-}
 
 const middleware = [
   morgan('tiny'),
@@ -163,11 +133,7 @@ app.all('*all', async (req, res) => {
         urlPath: requestUrl,
         isAuthenticated: !!req.isAuthenticated,
       })
-      const html = await BuildPage.handle({
-        route: pageRoute,
-        appConfig,
-        isDevReloadEnabled,
-      })
+      const html = await BuildPage.handle({ route: pageRoute, appConfig })
       res.status(200).type('html').send(html)
       return
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/app",
-  "version": "1.11.7",
+  "version": "1.11.8",
   "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.11.7",
-    "@ossy/design-system": "^1.11.7",
-    "@ossy/pages": "^1.11.7",
-    "@ossy/router": "^1.11.7",
-    "@ossy/router-react": "^1.11.7",
-    "@ossy/sdk": "^1.11.7",
-    "@ossy/sdk-react": "^1.11.7",
-    "@ossy/themes": "^1.11.7",
+    "@ossy/connected-components": "^1.11.8",
+    "@ossy/design-system": "^1.11.8",
+    "@ossy/pages": "^1.11.8",
+    "@ossy/router": "^1.11.8",
+    "@ossy/router-react": "^1.11.8",
+    "@ossy/sdk": "^1.11.8",
+    "@ossy/sdk-react": "^1.11.8",
+    "@ossy/themes": "^1.11.8",
     "@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": "43d1eca8557efc9586398a893ce9832b2ebf0444"
+  "gitHead": "16cef74bf4a2709ec3bf91cb73f2149703086b62"
 }

package/cli/dev.js

@@ -1,342 +0,0 @@
-import path from 'path';
-import url from 'url';
-import fs from 'fs';
-import {
-  printBuildOverview,
-  getBuildOverviewSnapshot,
-  filePathToRoute,
-  discoverFilesByPattern,
-  PAGE_FILE_PATTERN,
-  writePagesManifest,
-  resolveApiSource,
-  resolveTaskSource,
-  resetOssyBuildDir,
-  compileOssyNodeArtifacts,
-  copyOssyAppRuntime,
-  writeAppRuntimeShims,
-  createOssyAppBundlePlugins,
-  createOssyClientRollupPlugins,
-  writePageHydrateStubs,
-  buildClientHydrateInput,
-  clientHydrateIdForPage,
-  ossyGeneratedDir,
-  OSSY_GEN_PAGES_BASENAME,
-  OSSY_PAGES_RUNTIME_BASENAME,
-  writeResourceTemplatesBarrelIfPresent,
-  resourceTemplatesDir,
-  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) => {
-    const options = arg({    
-        '--config': String,
-        '-c': '--config',
-      }, { argv: cliArgs, permissive: true })
-
-
-    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');
-    let currentPageFiles = discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN)
-
-    resetOssyBuildDir(buildPath)
-
-    const resourceTemplatesResult = writeResourceTemplatesBarrelIfPresent({
-      cwd: process.cwd(),
-      log: false,
-    })
-    let resourceTemplatesDevLogged = false
-
-    const ossyDir = ossyGeneratedDir(buildPath)
-    const pagesGeneratedPath = path.join(ossyDir, OSSY_GEN_PAGES_BASENAME)
-    writePagesManifest({
-      pageFiles: currentPageFiles,
-      srcDir,
-      pagesGeneratedPath,
-    })
-    writePageHydrateStubs(currentPageFiles, srcDir, ossyDir)
-    const clientHydrateInput = buildClientHydrateInput(currentPageFiles, srcDir, ossyDir)
-
-    let apiOverviewFiles = []
-    let taskOverviewFiles = []
-    const refreshApiTaskManifests = () => {
-      apiOverviewFiles = resolveApiSource({ srcDir, buildPath }).apiOverviewFiles
-      taskOverviewFiles = resolveTaskSource({ srcDir, buildPath }).taskOverviewFiles
-    }
-    refreshApiTaskManifests()
-    let middlewareSourcePath = path.resolve(options['--middleware-source'] || 'src/middleware.js');
-    const publicDir = path.resolve('public')
-
-    if (currentPageFiles.length === 0) {
-      console.log('\n  \x1b[1m@ossy/app\x1b[0m  \x1b[2mdev\x1b[0m')
-      printBuildOverview({
-        pagesSourcePath: pagesGeneratedPath,
-        apiOverviewFiles,
-        configPath,
-        pageFiles: currentPageFiles,
-      })
-      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')
-    }
-
-    const configSourcePath = fs.existsSync(configPath)
-      ? configPath
-      : path.resolve(scriptDir, 'default-config.js')
-
-    const pagesEntryPath = path.join(ossyDir, OSSY_PAGES_RUNTIME_BASENAME)
-
-    const runNodeBundles = async () => {
-      refreshApiTaskManifests()
-      await compileOssyNodeArtifacts({
-        pageFiles: currentPageFiles,
-        srcDir,
-        ossyDir,
-        apiFiles: apiOverviewFiles,
-        taskFiles: taskOverviewFiles,
-        nodeEnv: 'development',
-      })
-      writeAppRuntimeShims({
-        middlewareSourcePath,
-        configSourcePath,
-        ossyDir,
-      })
-      copyOssyAppRuntime({ scriptDir, buildPath })
-    }
-
-    await runNodeBundles()
-
-    const clientPlugins = createOssyClientRollupPlugins({
-      nodeEnv: 'development',
-      copyPublicFrom: publicDir,
-      buildPath,
-    })
-
-    // `dir` must not be an ancestor of hydrate stubs (`build/.ossy/…`) or Rollup watch errors.
-    const clientOutput = {
-      dir: path.join(buildPath, 'public'),
-      format: 'esm',
-      entryFileNames ({ name }) {
-        if (name.startsWith('hydrate__')) {
-          const pageId = name.slice('hydrate__'.length)
-          return `static/${pageId}.js`
-        }
-        return 'static/[name].js'
-      },
-      chunkFileNames: 'static/[name]-[hash].js',
-    }
-
-    let restartTimer = null
-    const scheduleRestart = () => {
-      clearTimeout(restartTimer)
-      restartTimer = setTimeout(async () => {
-        await triggerReload()
-        restartServer()
-      }, 100)
-    }
-
-    let serverProcess = null
-    const startServer = () => {
-      if (serverProcess) return
-      serverProcess = spawn(process.execPath, [path.resolve(buildPath, 'server.js'), ...process.argv.slice(3)], {
-        stdio: 'inherit',
-        env: {
-          ...process.env,
-          OSSY_DEV_RELOAD: '1',
-          NODE_ENV: 'development',
-        },
-      })
-      serverProcess.on('exit', () => {
-        serverProcess = null
-      })
-    }
-
-    const restartServer = () => {
-      if (!serverProcess) return startServer()
-      serverProcess.kill('SIGTERM')
-      serverProcess = null
-      startServer()
-    }
-
-    const triggerReload = async () => {
-      const port = process.env.PORT || '3000'
-      try {
-        await fetch(`http://localhost:${port}/__ossy_reload`, { method: 'POST' })
-      } catch {
-        // server might not be up yet
-      }
-    }
-
-    const nodeWatchOpts = { watch: { clearScreen: false } }
-    const watchConfigs = []
-    if (Object.keys(clientHydrateInput).length > 0) {
-      watchConfigs.push({
-        input: clientHydrateInput,
-        output: clientOutput,
-        plugins: clientPlugins,
-        watch: { clearScreen: false },
-      })
-    } else {
-      watchConfigs.push({
-        input: '\0ossy-dev-noop',
-        output: {
-          file: path.join(ossyDir, '.dev-noop-out.mjs'),
-          format: 'esm',
-          inlineDynamicImports: true,
-        },
-        plugins: [
-          {
-            name: 'ossy-dev-noop',
-            resolveId (id) {
-              if (id === '\0ossy-dev-noop') return id
-              return null
-            },
-            load (id) {
-              if (id === '\0ossy-dev-noop') return 'export default 0\n'
-              return null
-            },
-          },
-          ...createOssyAppBundlePlugins({ nodeEnv: 'development' }),
-        ],
-        ...nodeWatchOpts,
-      })
-    }
-    const watcher = watch(watchConfigs)
-
-    watcher.on('event', async (event) => {
-      if (event.code === 'BUNDLE_START') {
-        console.log('  \x1b[2m◐\x1b[0m \x1b[1m@ossy/app\x1b[0m  \x1b[2mrollup watch …\x1b[0m')
-      }
-      if (event.code === 'ERROR') {
-        console.error('  \x1b[31m✖\x1b[0m \x1b[1m@ossy/app\x1b[0m  build error', event.error)
-      }
-      if (event.code === 'BUNDLE_END') {
-        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({
-          middlewareSourcePath,
-          configSourcePath,
-          ossyDir,
-        })
-        copyOssyAppRuntime({ scriptDir, buildPath })
-        if (currentPageFiles.length > 0) {
-          const pageIds = [
-            ...new Set(currentPageFiles.map((f) => clientHydrateIdForPage(f, srcDir))),
-          ].sort()
-          const overviewSnap = getBuildOverviewSnapshot({
-            pagesSourcePath: pagesGeneratedPath,
-            apiOverviewFiles,
-            configPath,
-            pageFiles: currentPageFiles,
-          })
-          const idToPath = Object.fromEntries(
-            currentPageFiles.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',
-              pagesEntryPath,
-              configSourcePath,
-              publicDir: path.join(buildPath, 'public'),
-              reporter,
-            })
-          } catch (err) {
-            console.error('  \x1b[31m✖\x1b[0m \x1b[1m@ossy/app\x1b[0m  prerender failed', err)
-          } finally {
-            reporter?.dispose()
-          }
-        }
-        scheduleRestart()
-      }
-    })
-
-    const regenApiGenerated = () => {
-      if (options['--api-source']) return
-      void runNodeBundles().then(() => scheduleRestart())
-    }
-
-    const regenTasksGenerated = () => {
-      void runNodeBundles().then(() => scheduleRestart())
-    }
-
-    fs.watch(srcDir, { recursive: true }, (eventType, filename) => {
-      if (!filename) return
-      if (/\.page\.(jsx?|tsx?)$/.test(filename)) {
-        const refreshedPageFiles = discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN)
-        currentPageFiles = refreshedPageFiles
-        const regenPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_PAGES_BASENAME)
-        writePagesManifest({
-          pageFiles: refreshedPageFiles,
-          srcDir,
-          pagesGeneratedPath: regenPath,
-        })
-        writePageHydrateStubs(refreshedPageFiles, srcDir, ossyDir)
-        void runNodeBundles().then(() => {
-          if (typeof watcher?.invalidate === 'function') {
-            for (const f of refreshedPageFiles) {
-              const hid = clientHydrateIdForPage(f, srcDir)
-              watcher.invalidate(path.join(ossyDir, `hydrate-${hid}.jsx`))
-            }
-          }
-          scheduleRestart()
-        })
-      }
-      if (/\.api\.(mjs|cjs|js)$/.test(filename)) {
-        regenApiGenerated()
-      }
-      if (/\.task\.(mjs|cjs|js)$/.test(filename)) {
-        regenTasksGenerated()
-      }
-      const norm = filename.replace(/\\/g, '/')
-      if (/\.resource\.js$/.test(norm) && norm.includes('resource-templates/')) {
-        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)
-        }
-      }
-    })
-};