@ossy/app 1.13.2 → 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,19 +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'
-
-/** Per-page client entries: `hydrate-<pageId>.jsx` under `.ossy/` */
-const HYDRATE_STUB_PREFIX = 'hydrate-'
-const HYDRATE_STUB_SUFFIX = '.jsx'
 
-/** Rollup input chunk name for a page id (safe identifier; id may contain `-`). */
-export function hydrateEntryName (pageId) {
-  return `hydrate__${pageId}`
-}
+/** 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)
@@ -205,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,
@@ -266,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({
@@ -573,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) {
@@ -670,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)
@@ -709,92 +546,213 @@ export function writePageServerRollupEntry ({ pageAbsPath, stubPath }) {
 }
 
 /**
- * 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.
+ * Generates a single shared hydrate entry that dynamically imports the active page at runtime.
+ * Rollup processes this once, emitting React and shared deps as reusable chunks instead of
+ * bundling them into every page separately.
  */
-export function generatePageHydrateModule ({ pageAbsPath, stubAbsPath, srcDir }) {
-  const rel = relToGeneratedImport(stubAbsPath, pageAbsPath)
+export function generateHydrateEntry ({ pageFiles, srcDir, stubAbsPath }) {
+  const seenIds = new Set()
+  const pageLines = []
+  for (const f of pageFiles) {
+    const hydrateId = clientHydrateIdForPage(f, srcDir)
+    if (seenIds.has(hydrateId)) {
+      throw new Error(
+        `[@ossy/app] Duplicate client hydrate id "${hydrateId}" (${f}). Pages need unique ids.`
+      )
+    }
+    seenIds.add(hydrateId)
+    const rel = relToGeneratedImport(stubAbsPath, f)
+    pageLines.push(`  '${hydrateId}': () => import('./${rel}'),`)
+  }
+
   return [
     '// Generated by @ossy/app — do not edit',
     '',
     "import { createElement } from 'react'",
     "import { hydrateRoot } from 'react-dom/client'",
     "import { App } from '@ossy/connected-components'",
-    `import * as _page from './${rel}'`,
     '',
-    'export default _page.default',
-    'export const metadata = _page.metadata',
+    'const config = window.__INITIAL_APP_CONFIG__ || {}',
+    '',
+    'const pages = {',
+    ...pageLines,
+    '}',
     '',
-    "if (typeof window !== 'undefined') {",
-    "  const config = window.__INITIAL_APP_CONFIG__ || {}",
-    '  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)',
+    'const load = pages[config.pageId]',
+    'if (load) {',
+    '  load().then((mod) => {',
+    '    const Page = mod.default',
+    "    const metadata = mod.metadata || {}",
+    '    function PageShell (props) {',
+    "      return createElement('html', { lang: props.defaultLanguage || 'en' },",
+    "        createElement('head', null,",
+    "          createElement('meta', { charSet: 'utf-8' }),",
+    "          createElement('title', null, metadata.title || ''),",
+    '        ),',
+    '        createElement(App, props,',
+    '          createElement(Page, props)',
+    '        )',
     '      )',
-    '    )',
-    '  }',
-    '  hydrateRoot(document, createElement(PageShell, config))',
+    '    }',
+    '    hydrateRoot(document, createElement(PageShell, config))',
+    '  })',
     '}',
     '',
   ].join('\n')
 }
 
-/** Writes `hydrate-<id>.jsx` for each page; removes stale `hydrate-*` outputs in `ossyDir` first. */
-export function writePageHydrateStubs (pageFiles, srcDir, ossyDir) {
+/** Writes a single `hydrate-entry.jsx`; removes any stale per-page `hydrate-*.jsx` stubs first. */
+export function writeHydrateEntry (pageFiles, srcDir, ossyDir) {
   if (!fs.existsSync(ossyDir)) fs.mkdirSync(ossyDir, { recursive: true })
   for (const ent of fs.readdirSync(ossyDir, { withFileTypes: true })) {
-    const full = path.join(ossyDir, ent.name)
-    if (ent.isDirectory() && ent.name.startsWith(HYDRATE_STUB_PREFIX)) {
-      fs.rmSync(full, { recursive: true, force: true })
-    } else if (
+    if (
       ent.isFile() &&
-      ent.name.startsWith(HYDRATE_STUB_PREFIX) &&
-      ent.name.endsWith(HYDRATE_STUB_SUFFIX)
+      ent.name.startsWith('hydrate-') &&
+      ent.name.endsWith('.jsx') &&
+      ent.name !== HYDRATE_ENTRY_FILENAME
     ) {
-      fs.rmSync(full, { force: true })
+      fs.rmSync(path.join(ossyDir, ent.name), { force: true })
     }
   }
+  const stubPath = path.join(ossyDir, HYDRATE_ENTRY_FILENAME)
+  fs.writeFileSync(stubPath, generateHydrateEntry({ pageFiles, srcDir, stubAbsPath: stubPath }))
+}
+
+/**
+ * Generates the single shared SSR entry that exports a static `pages` array and a
+ * `renderPage(pageId, props, options)` function. Each page is dynamically imported so
+ * Rollup can split out lazy chunks per page when code-splitting is enabled.
+ */
+export function generateSsrEntry ({ pageFiles, srcDir, stubAbsPath }) {
   const seenIds = new Set()
+  const pagesLiteral = []
+  const pageModuleLines = []
+
   for (const f of pageFiles) {
-    const hydrateId = clientHydrateIdForPage(f, srcDir)
-    if (seenIds.has(hydrateId)) {
+    const { id, path: routePath } = pageRouteFromSource(f, srcDir)
+    if (seenIds.has(id)) {
       throw new Error(
-        `[@ossy/app] Duplicate client hydrate id "${hydrateId}" (${f}). Per-page hydrate bundles need unique ids.`
+        `[@ossy/app] Duplicate page id "${id}" (${f}). Pages need unique ids.`
       )
     }
-    seenIds.add(hydrateId)
-    const stubPath = path.join(ossyDir, `${HYDRATE_STUB_PREFIX}${hydrateId}${HYDRATE_STUB_SUFFIX}`)
-    fs.mkdirSync(path.dirname(stubPath), { recursive: true })
-    fs.writeFileSync(
-      stubPath,
-      generatePageHydrateModule({ pageAbsPath: f, stubAbsPath: stubPath, srcDir })
-    )
+    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')
 }
 
-export function buildClientHydrateInput (pageFiles, srcDir, ossyDir) {
-  const input = {}
-  for (const f of pageFiles) {
-    const hydrateId = clientHydrateIdForPage(f, srcDir)
-    const stubPath = path.join(ossyDir, `${HYDRATE_STUB_PREFIX}${hydrateId}${HYDRATE_STUB_SUFFIX}`)
-    input[hydrateEntryName(hydrateId)] = stubPath
+/** 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)
   }
-  return input
+
+  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, '/'),
     }
@@ -918,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)
 
@@ -936,16 +895,14 @@ export const build = async (cliArgs) => {
       srcDir,
       pagesGeneratedPath,
     })
-    writePageHydrateStubs(pageFiles, srcDir, ossyDir)
-    writePageSsrStubs(pageFiles, srcDir, ossyDir)
-    const clientHydrateInput = buildClientHydrateInput(pageFiles, srcDir, ossyDir)
 
-    const { apiOverviewFiles } = resolveApiSource({
-      srcDir,
-      buildPath,
-    })
-    let middlewareSourcePath = path.resolve('src/middleware.js');
-    const publicDir = path.resolve('public')
+    // Write generated entries (both SSR and client hydrate)
+    const ssrEntryPath = writeSsrEntry(pageFiles, srcDir, ossyDir)
+    writeHydrateEntry(pageFiles, srcDir, ossyDir)
+    const clientEntryPath = path.join(ossyDir, HYDRATE_ENTRY_FILENAME)
+
+    const { apiOverviewFiles } = resolveApiSource({ srcDir, buildPath })
+    let middlewareSourcePath = path.resolve('src/middleware.js')
 
     if (!fs.existsSync(middlewareSourcePath)) {
       middlewareSourcePath = path.resolve(scriptDir, 'middleware.js')
@@ -955,45 +912,13 @@ export const build = async (cliArgs) => {
       ? configPath
       : path.resolve(scriptDir, 'default-config.js')
 
-    const useDashboard = Object.keys(clientHydrateInput).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(
@@ -1003,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',
     })
 
@@ -1019,23 +941,13 @@ export const build = async (cliArgs) => {
     })
     copyOssyAppRuntime({ scriptDir, buildPath })
 
-    if (useDashboard && dashboard) {
-      try {
-        await prerenderReactTask.handler({
-          op: 'runProduction',
-          clientHydrateInput,
-          pageFilesLength: pageFiles.length,
-          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,144 +1,8 @@
 import path from 'path'
-import fs from 'fs'
-import { rollup } from 'rollup'
-import { pageIdFromHydrateEntryName } from './build-terminal.js'
 
-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 })
+export function staticHtmlPathForRoute (routePath, publicDir) {
+  const segments = routePath === '/' ? [] : routePath.replace(/^\//, '').split('/')
+  return path.join(publicDir, ...segments, 'index.html')
 }
 
-async function bundleOneHydratePage ({
-  entryName,
-  stubPath,
-  buildPath,
-  plugins,
-  minifyPlugin,
-}) {
-  const bundle = await rollup({
-    input: { [entryName]: stubPath },
-    plugins,
-  })
-  try {
-    await bundle.write({
-      dir: path.join(buildPath, 'public'),
-      format: 'esm',
-      inlineDynamicImports: true,
-      entryFileNames (chunkInfo) {
-        const n = chunkInfo.name
-        if (n.startsWith('hydrate__')) {
-          const pageId = n.slice('hydrate__'.length)
-          return `static/${pageId}.js`
-        }
-        return 'static/[name].js'
-      },
-      chunkFileNames: 'static/[name]-[hash].js',
-      plugins: minifyPlugin ? [minifyPlugin] : [],
-    })
-  } finally {
-    await bundle.close()
-  }
-}
-
-async function bundleWithConcurrency (entries, concurrency, processFn) {
-  const results = new Array(entries.length)
-  let nextIdx = 0
-  async function worker () {
-    while (nextIdx < entries.length) {
-      const idx = nextIdx++
-      results[idx] = await processFn(entries[idx]).then(
-        (value) => ({ status: 'fulfilled', value }),
-        (reason) => ({ status: 'rejected', reason }),
-      )
-    }
-  }
-  await Promise.all(Array.from({ length: concurrency }, worker))
-  return results
-}
-
-async function bundleHydratePagesParallel ({
-  clientHydrateInput,
-  buildPath,
-  copyPublicFrom,
-  nodeEnv,
-  buildPathForPlugins,
-  createClientRollupPlugins,
-  minifyBrowserStaticChunks,
-  reporter,
-}) {
-  copyPublicToBuild({ copyPublicFrom, buildPath })
-  fs.mkdirSync(path.join(buildPath, 'public', 'static'), { recursive: true })
-
-  const entries = Object.entries(clientHydrateInput)
-
-  const BUNDLE_CONCURRENCY = 4
-
-  const results = await bundleWithConcurrency(
-    entries,
-    BUNDLE_CONCURRENCY,
-    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 = results.filter((r) => r.status === 'rejected').length
-  return { results, failures }
-}
-
-export default {
-  type: '@ossy/app/prerender-react',
-  async handler (input) {
-    const op = input?.op
-    if (op === 'runProduction') {
-      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)`
-    )
-  },
-}
+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,
@@ -36,6 +19,7 @@ export function buildPrerenderAppConfig ({
     workspaceId: buildTimeConfig.workspaceId,
     apiUrl: buildTimeConfig.apiUrl,
     pages,
+    pageId: activeRouteId,
     sidebarPrimaryCollapsed: false,
   }
 }
@@ -61,12 +45,7 @@ export function buildHydrationAppConfig (appConfig) {
 
 export const BuildPage = {
   async handle ({ route, appConfig }) {
-    const hydrationConfig = buildHydrationAppConfig(appConfig)
-    const { renderPage } = await loadSsrBundle(route)
-
-    return renderPage(hydrationConfig, {
-      bootstrapScriptContent: `window.__INITIAL_APP_CONFIG__=${JSON.stringify(hydrationConfig)}`,
-      bootstrapModules: [`/static/${route.id}.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.2",
+  "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.2",
-    "@ossy/design-system": "^1.13.2",
-    "@ossy/pages": "^1.13.2",
-    "@ossy/router": "^1.13.2",
-    "@ossy/router-react": "^1.13.2",
-    "@ossy/sdk": "^1.13.2",
-    "@ossy/sdk-react": "^1.13.2",
-    "@ossy/themes": "^1.13.2",
+    "@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": "261f99aae788324c696edaeaa13a67380780e3fc"
+  "gitHead": "c2640eba775b192c34a888bae8add3c3461305ee"
 }