@ossy/app 1.13.3 → 1.13.4

package/cli/build.js

@@ -12,8 +12,6 @@ import nodeExternals from 'rollup-plugin-node-externals'
 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)$/
@@ -23,15 +21,12 @@ const RESOURCE_TEMPLATE_FILE_PATTERN = /\.resource\.js$/
 /** Written next to `*.resource.js` under `src/resource-templates/` when that dir exists. */
 export const OSSY_RESOURCE_TEMPLATES_OUT = '.ossy-system-templates.generated.js'
 
-/** Rollup output paths when `output.dir` is `<build>/public` (see `entryFileNames` / `chunkFileNames`). */
-const BROWSER_STATIC_PREFIX = 'static/'
-
 export function minifyBrowserStaticChunks () {
   return {
     name: 'minify-browser-static-chunks',
     async renderChunk (code, chunk, outputOptions) {
       const fileName = chunk.fileName
-      if (!fileName || !fileName.startsWith(BROWSER_STATIC_PREFIX)) {
+      if (!fileName || !fileName.startsWith('public/static/')) {
         return null
       }
       const useSourceMap =
@@ -87,13 +82,13 @@ export const OSSY_PAGE_SERVER_EXTERNAL = [
   'react/jsx-runtime',
 ]
 
-/** Output directory (relative to buildPath) for per-page SSR bundles. */
+/** Output directory (relative to buildPath) for SSR bundle. */
 export const OSSY_SSR_DIRNAME = 'ssr'
-/** Temp stub entries for SSR bundles (inside .ossy/). */
-const OSSY_SSR_ENTRIES_DIRNAME = 'ssr-entries'
 
-/** Single shared client hydrate entry filename under `.ossy/` */
+/** Shared client hydrate entry filename under `.ossy/` */
 const HYDRATE_ENTRY_FILENAME = 'hydrate-entry.jsx'
+/** Shared SSR entry filename under `.ossy/` */
+const SSR_ENTRY_FILENAME = 'ssr-entry.mjs'
 
 export function ossyGeneratedDir (buildPath) {
   return path.join(buildPath, OSSY_GEN_DIRNAME)
@@ -199,45 +194,12 @@ export function createOssyAppBundlePlugins ({ nodeEnv }) {
 }
 
 /**
- * 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 = [
-    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: false }),
-    babel({
-      babelHelpers: 'bundled',
-      extensions: ['.jsx', '.tsx'],
-      presets: [['@babel/preset-react', { runtime: 'automatic' }]],
-    }),
-  ]
-  if (copyPublicFrom && fs.existsSync(copyPublicFrom)) {
-    plugins.push(
-      copy({
-        targets: [{ src: `${copyPublicFrom}/**/*`, dest: path.join(buildPath, 'public') }],
-      })
-    )
-  }
-  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).
+ * Rollup plugins for the combined SSR + client bundle.
+ * `preferBuiltins: true` is correct for the SSR entry (uses `node:stream`); page component code
+ * does not import Node built-ins so this is safe for the browser entry as well.
+ * `copyPublicFrom` is handled separately before the Rollup call.
  */
-export function createOssySsrBundlePlugins ({ nodeEnv }) {
+export function createCombinedBundlePlugins ({ nodeEnv }) {
   return [
     replace({
       preventAssignment: true,
@@ -260,93 +222,6 @@ export function createOssySsrBundlePlugins ({ nodeEnv }) {
   ]
 }
 
-/** 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 { App } from '@ossy/connected-components'",
-    `import * as _page from './${rel}'`,
-    '',
-    'export const metadata = _page.metadata',
-    '',
-    'function PageShell (props) {',
-    "  return createElement('html', { lang: props.defaultLanguage || 'en' },",
-    "    createElement('head', null,",
-    "      createElement('meta', { charSet: 'utf-8' }),",
-    "      createElement('title', null, (_page.metadata && _page.metadata.title) || ''),",
-    '    ),',
-    '    createElement(App, props,',
-    '      createElement(_page.default, props)',
-    '    )',
-    '  )',
-    '}',
-    '',
-    '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(PageShell, 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.mkdirSync(path.dirname(stubPath), { recursive: true })
-    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({
@@ -567,73 +442,22 @@ 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.
- */
-/**
- * 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 basePages = JSON.parse(fs.readFileSync(pagesGeneratedPath, 'utf8'))
-  if (!Array.isArray(basePages) || basePages.length === 0) return
-
-  const pages = []
-  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 = {
-      id: basePage.id,
-      path: basePage.path,
-      ...meta,
-      sourceFile: basePage.sourceFile,
-      module: moduleRelPath,
-    }
-    try {
-      JSON.stringify(merged)
-    } catch {
-      pages.push({ id: basePage.id, path: basePage.path, sourceFile: basePage.sourceFile, module: moduleRelPath })
-      continue
-    }
-    pages.push(merged)
-  }
-  writeOssyJson(pagesGeneratedPath, pages)
-}
-
-/**
- * Compiles server-side artifacts: per-page SSR bundles, API modules, and task modules.
+ * Compiles server-side artifacts: API modules and task modules.
+ * SSR page bundles are now produced by the combined Rollup pass in compileCombinedBundle.
  */
 export async function compileOssyNodeArtifacts ({
-  pageFiles,
-  srcDir,
-  ossyDir,
-  buildPath,
   apiFiles,
   taskFiles,
+  ossyDir,
   nodeEnv,
   onWarn,
 }) {
-  const [, apiRouteList, taskList] = await Promise.all([
-    compilePageSsrModules({ pageFiles, srcDir, ossyDir, buildPath, nodeEnv, onWarn }),
+  const [apiRouteList, taskList] = await Promise.all([
     compileApiServerModules({ apiFiles, ossyDir, nodeEnv, onWarn }),
     compileTaskServerModules({ taskFiles, ossyDir, nodeEnv, onWarn }),
   ])
   writeOssyJson(path.join(ossyDir, OSSY_GEN_API_BASENAME), apiRouteList)
   writeOssyJson(path.join(ossyDir, OSSY_GEN_TASKS_BASENAME), taskList)
-  await enrichPagesGeneratedManifest({
-    ossyDir,
-    pagesGeneratedPath: path.join(ossyDir, OSSY_GEN_PAGES_BASENAME),
-  })
 }
 
 export function filePathToRoute(filePath, srcDir) {
@@ -664,6 +488,25 @@ export function clientHydrateIdForPage (pageAbsPath, srcDir) {
   return idMatch ? idMatch[1] : derived.id
 }
 
+/**
+ * Like `clientHydrateIdForPage` but also extracts `path` from `metadata`.
+ * Used to embed the static page route map directly into the SSR entry.
+ */
+export function pageRouteFromSource (pageAbsPath, srcDir) {
+  const derived = filePathToRoute(pageAbsPath, srcDir)
+  try {
+    const src = fs.readFileSync(pageAbsPath, 'utf8')
+    const metaIdx = src.indexOf('export const metadata')
+    if (metaIdx === -1) return derived
+    const after = src.slice(metaIdx)
+    const id = after.match(/\bid\s*:\s*['"]([^'"]+)['"]/)?.[1] ?? derived.id
+    const strPath = after.match(/\bpath\s*:\s*['"]([^'"]+)['"]/)?.[1]
+    return { id, path: strPath ?? derived.path }
+  } catch {
+    return derived
+  }
+}
+
 /** Posix path relative to `build/.ossy/` for the compiled **Node** page module (SSR). */
 export function pageServerModuleRelPath (pageAbsPath, srcDir) {
   const pageId = clientHydrateIdForPage(pageAbsPath, srcDir)
@@ -775,18 +618,141 @@ export function writeHydrateEntry (pageFiles, srcDir, ossyDir) {
   fs.writeFileSync(stubPath, generateHydrateEntry({ pageFiles, srcDir, stubAbsPath: stubPath }))
 }
 
-/** Returns a single-entry input map pointing at the shared hydrate entry. */
-export function buildClientHydrateInput (_pageFiles, _srcDir, ossyDir) {
-  return { app: path.join(ossyDir, HYDRATE_ENTRY_FILENAME) }
+/**
+ * Generates the single shared SSR entry that exports a static `pages` array and a
+ * `renderPage(pageId, props, options)` function. Each page is dynamically imported so
+ * Rollup can split out lazy chunks per page when code-splitting is enabled.
+ */
+export function generateSsrEntry ({ pageFiles, srcDir, stubAbsPath }) {
+  const seenIds = new Set()
+  const pagesLiteral = []
+  const pageModuleLines = []
+
+  for (const f of pageFiles) {
+    const { id, path: routePath } = pageRouteFromSource(f, srcDir)
+    if (seenIds.has(id)) {
+      throw new Error(
+        `[@ossy/app] Duplicate page id "${id}" (${f}). Pages need unique ids.`
+      )
+    }
+    seenIds.add(id)
+    const rel = relToGeneratedImport(stubAbsPath, f)
+    pagesLiteral.push(`  { id: '${id}', path: '${routePath}' },`)
+    pageModuleLines.push(`  '${id}': () => import('./${rel}'),`)
+  }
+
+  return [
+    '// Generated by @ossy/app — do not edit',
+    '',
+    "import { createElement } from 'react'",
+    "import { renderToPipeableStream } from 'react-dom/server'",
+    "import { Writable } from 'node:stream'",
+    "import { App } from '@ossy/connected-components'",
+    '',
+    'export const pages = [',
+    ...pagesLiteral,
+    ']',
+    '',
+    'const pageModules = {',
+    ...pageModuleLines,
+    '}',
+    '',
+    'function PageShell (props) {',
+    "  const meta = props._pageMeta || {}",
+    "  return createElement('html', { lang: props.defaultLanguage || 'en' },",
+    "    createElement('head', null,",
+    "      createElement('meta', { charSet: 'utf-8' }),",
+    "      createElement('title', null, meta.title || ''),",
+    '    ),',
+    '    createElement(App, props,',
+    '      createElement(props._pageComponent, props)',
+    '    )',
+    '  )',
+    '}',
+    '',
+    'export async function renderPage (pageId, props, options = {}) {',
+    '  const load = pageModules[pageId]',
+    "  if (!load) throw new Error(`[@ossy/app] Unknown page id: ${pageId}`)",
+    '  const mod = await load()',
+    '  const merged = { ...props, _pageComponent: mod.default, _pageMeta: mod.metadata || {} }',
+    '  return new Promise((resolve, reject) => {',
+    "    let html = ''",
+    '    const writable = new Writable({',
+    '      write (chunk, _enc, cb) { html += chunk.toString(); cb() },',
+    '    })',
+    '    const { pipe } = renderToPipeableStream(createElement(PageShell, merged), {',
+    '      ...options,',
+    '      onAllReady () { pipe(writable) },',
+    '      onError (err) { reject(err) },',
+    '    })',
+    "    writable.on('finish', () => resolve(html))",
+    '  })',
+    '}',
+    '',
+  ].join('\n')
+}
+
+/** Writes `ssr-entry.mjs` into ossyDir; removes any stale per-page SSR stubs first. */
+export function writeSsrEntry (pageFiles, srcDir, ossyDir) {
+  if (!fs.existsSync(ossyDir)) fs.mkdirSync(ossyDir, { recursive: true })
+  const stubPath = path.join(ossyDir, SSR_ENTRY_FILENAME)
+  fs.writeFileSync(stubPath, generateSsrEntry({ pageFiles, srcDir, stubAbsPath: stubPath }))
+  return stubPath
+}
+
+/**
+ * Runs a single Rollup pass with both the SSR entry and the client hydrate entry as inputs.
+ * Produces:
+ *   build/ssr/app.mjs          — Node SSR bundle
+ *   build/public/static/app.js — browser hydrate bundle
+ *   build/public/static/chunks/[name]-[hash].js — shared chunks
+ *
+ * The SSR bundle imports shared chunks via relative paths (`../public/static/chunks/…`);
+ * the browser loads the same physical files from `/static/chunks/`.
+ */
+export async function compileCombinedBundle ({ ssrEntryPath, clientEntryPath, buildPath, nodeEnv, copyPublicFrom, onWarn }) {
+  if (copyPublicFrom && fs.existsSync(copyPublicFrom)) {
+    const destPublic = path.join(buildPath, 'public')
+    fs.mkdirSync(destPublic, { recursive: true })
+    const copyDir = (src, dest) => {
+      fs.mkdirSync(dest, { recursive: true })
+      for (const ent of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, ent.name)
+        const destPath = path.join(dest, ent.name)
+        if (ent.isDirectory()) copyDir(srcPath, destPath)
+        else fs.copyFileSync(srcPath, destPath)
+      }
+    }
+    copyDir(copyPublicFrom, destPublic)
+  }
+
+  const bundle = await rollup({
+    input: { server: ssrEntryPath, app: clientEntryPath },
+    plugins: createCombinedBundlePlugins({ nodeEnv }),
+    onwarn (warning, defaultHandler) {
+      if (onWarn) { onWarn(warning); return }
+      defaultHandler(warning)
+    },
+  })
+  await bundle.write({
+    dir: buildPath,
+    format: 'esm',
+    entryFileNames: (chunk) =>
+      chunk.name === 'server'
+        ? 'ssr/app.mjs'
+        : 'public/static/app.js',
+    chunkFileNames: 'public/static/chunks/[name]-[hash].js',
+    plugins: [minifyBrowserStaticChunks()],
+  })
+  await bundle.close()
 }
 
 /** JSON manifest: route ids, default paths, and page source paths (posix, relative to `cwd`). */
 export function buildPagesGeneratedPayload (pageFiles, srcDir, cwd = process.cwd()) {
   const pages = pageFiles.map((f) => {
-    const { path: routePath } = filePathToRoute(f, srcDir)
-    const pageId = clientHydrateIdForPage(f, srcDir)
+    const { id, path: routePath } = pageRouteFromSource(f, srcDir)
     return {
-      id: pageId,
+      id,
       path: routePath,
       sourceFile: path.relative(cwd, f).replace(/\\/g, '/'),
     }
@@ -910,8 +876,9 @@ export const build = async (cliArgs) => {
     const scriptDir = path.dirname(url.fileURLToPath(import.meta.url))
     const buildPath = path.resolve('build')
     const srcDir = path.resolve('src')
-    const configPath = path.resolve(options['--config'] || 'src/config.js');
+    const configPath = path.resolve(options['--config'] || 'src/config.js')
     const pageFiles = discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN)
+    const publicDir = path.resolve('public')
 
     resetOssyBuildDir(buildPath)
 
@@ -928,16 +895,14 @@ export const build = async (cliArgs) => {
       srcDir,
       pagesGeneratedPath,
     })
+
+    // Write generated entries (both SSR and client hydrate)
+    const ssrEntryPath = writeSsrEntry(pageFiles, srcDir, ossyDir)
     writeHydrateEntry(pageFiles, srcDir, ossyDir)
-    writePageSsrStubs(pageFiles, srcDir, ossyDir)
-    const clientHydrateInput = buildClientHydrateInput(pageFiles, srcDir, ossyDir)
+    const clientEntryPath = path.join(ossyDir, HYDRATE_ENTRY_FILENAME)
 
-    const { apiOverviewFiles } = resolveApiSource({
-      srcDir,
-      buildPath,
-    })
-    let middlewareSourcePath = path.resolve('src/middleware.js');
-    const publicDir = path.resolve('public')
+    const { apiOverviewFiles } = resolveApiSource({ srcDir, buildPath })
+    let middlewareSourcePath = path.resolve('src/middleware.js')
 
     if (!fs.existsSync(middlewareSourcePath)) {
       middlewareSourcePath = path.resolve(scriptDir, 'middleware.js')
@@ -947,45 +912,13 @@ export const build = async (cliArgs) => {
       ? configPath
       : path.resolve(scriptDir, 'default-config.js')
 
-    const useDashboard = pageFiles.length > 0
-    const overviewSnap = getBuildOverviewSnapshot({
+    console.log('\n  \x1b[1m@ossy/app\x1b[0m  \x1b[2mbuild\x1b[0m')
+    printBuildOverview({
       pagesSourcePath: pagesGeneratedPath,
       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()
-    } 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(
@@ -995,12 +928,9 @@ export const build = async (cliArgs) => {
 
     const { taskOverviewFiles } = resolveTaskSource({ srcDir, buildPath })
     await compileOssyNodeArtifacts({
-      pageFiles,
-      srcDir,
-      ossyDir,
-      buildPath,
       apiFiles: apiOverviewFiles,
       taskFiles: taskOverviewFiles,
+      ossyDir,
       nodeEnv: 'production',
     })
 
@@ -1011,24 +941,13 @@ export const build = async (cliArgs) => {
     })
     copyOssyAppRuntime({ scriptDir, buildPath })
 
-    if (useDashboard && dashboard) {
-      try {
-        await prerenderReactTask.handler({
-          op: 'runProduction',
-          hydrateEntryPath: clientHydrateInput.app,
-          pageFilesLength: pageFiles.length,
-          pageIds,
-          copyPublicFrom: publicDir,
-          buildPath,
-          nodeEnv: 'production',
-          createClientRollupPlugins: createOssyClientRollupPlugins,
-          minifyBrowserStaticChunks,
-          reporter: dashboard,
-        })
-      } finally {
-        dashboard.dispose()
-      }
-    }
+    await compileCombinedBundle({
+      ssrEntryPath,
+      clientEntryPath,
+      buildPath,
+      nodeEnv: 'production',
+      copyPublicFrom: publicDir,
+    })
 
     console.log('  \x1b[32m✔\x1b[0m \x1b[1m@ossy/app\x1b[0m  \x1b[2mbuild finished\x1b[0m\n')
 };

package/cli/prerender-react.task.js

@@ -1,97 +1,8 @@
 import path from 'path'
-import fs from 'fs'
-import { rollup } from 'rollup'
 
 export function staticHtmlPathForRoute (routePath, publicDir) {
   const segments = routePath === '/' ? [] : routePath.replace(/^\//, '').split('/')
   return path.join(publicDir, ...segments, 'index.html')
 }
 
-function copyPublicToBuild ({ copyPublicFrom, buildPath }) {
-  if (!copyPublicFrom || !fs.existsSync(copyPublicFrom)) return
-  const dest = path.join(buildPath, 'public')
-  fs.mkdirSync(dest, { recursive: true })
-  fs.cpSync(copyPublicFrom, dest, { recursive: true })
-}
-
-async function bundleHydrateEntry ({
-  entryPath,
-  buildPath,
-  plugins,
-  minifyPlugin,
-}) {
-  const bundle = await rollup({
-    input: { app: entryPath },
-    plugins,
-  })
-  try {
-    await bundle.write({
-      dir: path.join(buildPath, 'public'),
-      format: 'esm',
-      entryFileNames: 'static/[name].js',
-      chunkFileNames: 'static/chunks/[name]-[hash].js',
-      plugins: minifyPlugin ? [minifyPlugin] : [],
-    })
-  } finally {
-    await bundle.close()
-  }
-}
-
-export default {
-  type: '@ossy/app/prerender-react',
-  async handler (input) {
-    const op = input?.op
-    if (op === 'runProduction') {
-      const {
-        hydrateEntryPath,
-        pageFilesLength,
-        pageIds,
-        copyPublicFrom,
-        buildPath,
-        nodeEnv,
-        buildPathForPlugins,
-        createClientRollupPlugins,
-        minifyBrowserStaticChunks,
-        reporter,
-      } = input
-
-      if (pageFilesLength === 0 || !hydrateEntryPath) {
-        return { bundleFailures: 0 }
-      }
-
-      copyPublicToBuild({ copyPublicFrom, buildPath })
-      fs.mkdirSync(path.join(buildPath, 'public', 'static'), { recursive: true })
-      fs.mkdirSync(path.join(buildPath, 'public', 'static', 'chunks'), { recursive: true })
-
-      const ids = pageIds || []
-      const t0 = Date.now()
-      for (const id of ids) reporter?.startBundle?.(id)
-
-      try {
-        const plugins = createClientRollupPlugins({
-          nodeEnv,
-          copyPublicFrom: undefined,
-          buildPath: buildPathForPlugins ?? buildPath,
-        })
-        await bundleHydrateEntry({
-          entryPath: hydrateEntryPath,
-          buildPath,
-          plugins,
-          minifyPlugin: minifyBrowserStaticChunks(),
-        })
-        const ms = Date.now() - t0
-        for (const id of ids) reporter?.completeBundle?.(id, { ok: true, ms })
-      } catch (error) {
-        const ms = Date.now() - t0
-        for (const id of ids) reporter?.completeBundle?.(id, { ok: false, ms, error })
-        console.error(`[@ossy/app][client-bundle] hydrate-entry failed:`, error)
-        throw error
-      }
-
-      return { bundleFailures: 0 }
-    }
-    throw new Error(
-      `[@ossy/app][prerender-react] Unknown op: ${String(op)} (expected runProduction)`
-    )
-  },
-}
+export default { type: '@ossy/app/prerender-react' }

package/cli/render-page.task.js

@@ -1,21 +1,4 @@
-import path from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-
-const __ossyDir = path.dirname(fileURLToPath(import.meta.url))
-
-async function loadSsrBundle (route) {
-  if (typeof route?.id !== 'string' || !route.id) {
-    throw new Error(`[@ossy/app][BuildPage] Route has no id`)
-  }
-  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] SSR bundle for "${route.id}" must export renderPage (got ${typeof mod?.renderPage}).`
-    )
-  }
-  return mod
-}
+import { renderPage as ssrRender } from '../ssr/app.mjs'
 
 export function buildPrerenderAppConfig ({
   buildTimeConfig,
@@ -62,12 +45,7 @@ export function buildHydrationAppConfig (appConfig) {
 
 export const BuildPage = {
   async handle ({ route, appConfig }) {
-    const hydrationConfig = { ...buildHydrationAppConfig(appConfig), pageId: route.id }
-    const { renderPage } = await loadSsrBundle(route)
-
-    return renderPage(hydrationConfig, {
-      bootstrapScriptContent: `window.__INITIAL_APP_CONFIG__=${JSON.stringify(hydrationConfig)}`,
-      bootstrapModules: ['/static/app.js'],
-    })
+    const config = buildHydrationAppConfig(appConfig)
+    return ssrRender(route.id, config, {})
   },
 }

package/cli/server.js

@@ -130,7 +130,7 @@ app.all('*all', async (req, res) => {
     }
 
     const pageRoute = pageRouter.getPageByUrl(requestUrl)
-    if (pageRoute?.module) {
+    if (pageRoute) {
       const appConfig = buildPrerenderAppConfig({
         buildTimeConfig,
         pageList: sitePageList,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/app",
-  "version": "1.13.3",
+  "version": "1.13.4",
   "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.13.3",
-    "@ossy/design-system": "^1.13.3",
-    "@ossy/pages": "^1.13.3",
-    "@ossy/router": "^1.13.3",
-    "@ossy/router-react": "^1.13.3",
-    "@ossy/sdk": "^1.13.3",
-    "@ossy/sdk-react": "^1.13.3",
-    "@ossy/themes": "^1.13.3",
+    "@ossy/connected-components": "^1.13.4",
+    "@ossy/design-system": "^1.13.4",
+    "@ossy/pages": "^1.13.4",
+    "@ossy/router": "^1.13.4",
+    "@ossy/router-react": "^1.13.4",
+    "@ossy/sdk": "^1.13.4",
+    "@ossy/sdk-react": "^1.13.4",
+    "@ossy/themes": "^1.13.4",
     "@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": "0d5eae5748fb9a32e5dcb147444b7e9a8113dcba"
+  "gitHead": "c2640eba775b192c34a888bae8add3c3461305ee"
 }