@ossy/app 1.11.1 → 1.11.3

package/README.md

@@ -23,7 +23,7 @@ export default () => <h1>About</h1>
 
 For a single-file setup, use `src/pages.jsx` (legacy).
 
-Split pages are merged into **`build/.ossy/pages.generated.jsx`** (next to other build output) during `dev` / `build`.
+During `dev` / `build`, the tooling writes **JSON manifests** under **`build/.ossy/`**: **`pages.generated.json`** (route ids, default paths, and `sourceFile` paths), **`pages.bundle.json`** (compiled `page-modules/<id>.mjs` paths), plus the same pattern for API and tasks (`*.generated.json` / `*.bundle.json`). Small **`*.runtime.mjs`** loaders (copied from `@ossy/app`) dynamically `import()` those compiled modules at runtime.
 
 **Client JS (per-page):** For each `*.page.jsx`, the build emits **`build/.ossy/hydrate-<pageId>.jsx`** → **`public/static/hydrate-<pageId>.js`**. The HTML for a request only loads the hydrate script for the **current** route (full document navigation), so other pages’ components are not part of that entry. React and shared dependencies still go into hashed shared chunks. The inline config (`window.__INITIAL_APP_CONFIG__`) no longer includes the full `pages` list—only request-time fields (theme, `apiUrl`, etc.).
 
@@ -51,7 +51,7 @@ Define HTTP handlers as an array of `{ id, path, handle(req, res) }` objects (sa
 
 Add any number of `*.api.js` (or `.api.mjs` / `.api.cjs`) files under `src/` (nested dirs allowed). Each file’s **default export** is either one route object or an array of routes. Files are merged in lexicographic path order.
 
-Build/dev always writes **`build/.ossy/api.generated.js`** (typically gitignored with `build/`). With no API files it exports an empty array.
+Build/dev writes **`build/.ossy/api.generated.json`** (discovered source paths) and **`api.bundle.json`** (Rollup outputs under **`api-modules/`**). The server imports **`api.runtime.mjs`**, which loads those modules. With no API files, both JSON files list empty arrays.
 
 Example `src/health.api.js`:
 
@@ -69,7 +69,7 @@ API routes are matched before the app is rendered. The router supports dynamic s
 
 ## Background worker tasks (`*.task.js`)
 
-For long-running job processors (separate from the SSR server), use **`npx @ossy/cli build --worker`** in a package that only needs the worker. It uses the same Rollup + Babel pipeline as `ossy build`, discovers **`*.task.js`** (and `.task.mjs` / `.task.cjs`) under `src/` (or `--pages <dir>`), and writes **`build/.ossy/tasks.generated.js`** when needed—same idea as `*.api.js` and the generated API bundle.
+For long-running job processors (separate from the SSR server), use **`npx @ossy/cli build --worker`** in a package that only needs the worker. It uses the same Rollup + Babel pipeline as `ossy build`, discovers **`*.task.js`** (and `.task.mjs` / `.task.cjs`) under `src/` (or `--pages <dir>`), and writes **`tasks.generated.json`** / **`tasks.bundle.json`** plus **`tasks.runtime.mjs`**—the same metadata + per-file compile pattern as API routes.
 
 Optional legacy aggregate: **`src/tasks.js`** default export is merged **first**, then each `*.task.js` in path order.
 

package/cli/api.runtime.mjs

@@ -0,0 +1,22 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const __ossyDir = path.dirname(fileURLToPath(import.meta.url))
+
+function normalizeApiExport (mod) {
+  const d = mod?.default
+  if (d == null) return []
+  return Array.isArray(d) ? d : [d]
+}
+
+const { modules } = JSON.parse(fs.readFileSync(path.join(__ossyDir, 'api.bundle.json'), 'utf8'))
+
+const out = []
+for (const rel of modules) {
+  const abs = path.resolve(__ossyDir, rel)
+  const mod = await import(pathToFileURL(abs).href)
+  out.push(...normalizeApiExport(mod))
+}
+
+export default out

package/cli/build.js

@@ -53,15 +53,37 @@ export function minifyBrowserStaticChunks () {
 
 /** Subfolder under `build/` for generated pages/api/task entry stubs. */
 export const OSSY_GEN_DIRNAME = '.ossy'
-export const OSSY_GEN_PAGES_BASENAME = 'pages.generated.jsx'
-export const OSSY_GEN_API_BASENAME = 'api.generated.js'
-export const OSSY_GEN_TASKS_BASENAME = 'tasks.generated.js'
-
-/** Bundled pages + React for build-time prerender only (not loaded by `server.js`). */
-export const OSSY_PAGES_PRERENDER_BUNDLE = 'pages.prerender.bundle.js'
-export const OSSY_API_SERVER_BUNDLE = 'api.bundle.js'
-export const OSSY_TASKS_SERVER_BUNDLE = 'tasks.bundle.js'
+/** JSON-only manifests (sources + route metadata). */
+export const OSSY_GEN_PAGES_BASENAME = 'pages.generated.json'
+export const OSSY_GEN_API_BASENAME = 'api.generated.json'
+export const OSSY_GEN_TASKS_BASENAME = 'tasks.generated.json'
+/** JSON-only build artifact index (compiled module paths, aligned to generated manifests). */
+export const OSSY_PAGES_BUNDLE_BASENAME = 'pages.bundle.json'
+export const OSSY_API_BUNDLE_BASENAME = 'api.bundle.json'
+export const OSSY_TASKS_BUNDLE_BASENAME = 'tasks.bundle.json'
+/** Small Node loaders (not JSON) that `import()` compiled modules from the bundle manifests. */
+export const OSSY_PAGES_RUNTIME_BASENAME = 'pages.runtime.mjs'
+export const OSSY_API_RUNTIME_BASENAME = 'api.runtime.mjs'
+export const OSSY_TASKS_RUNTIME_BASENAME = 'tasks.runtime.mjs'
+
+export const OSSY_PAGE_MODULES_DIRNAME = 'page-modules'
+/** Tiny Rollup inputs that re-export `metadata` so per-page server bundles keep i18n paths. */
+export const OSSY_PAGE_SERVER_ENTRIES_DIRNAME = 'page-server-entries'
+export const OSSY_API_MODULES_DIRNAME = 'api-modules'
+export const OSSY_TASK_MODULES_DIRNAME = 'task-modules'
+
 export const OSSY_MIDDLEWARE_RUNTIME_BASENAME = 'middleware.runtime.js'
+export const OSSY_SERVER_CONFIG_RUNTIME_BASENAME = 'server-config.runtime.mjs'
+export const OSSY_RENDER_PAGE_RUNTIME_BASENAME = 'render-page.task.js'
+
+/** Keep React external across per-page server chunks so `pages.runtime.mjs` shares one React. */
+export const OSSY_PAGE_SERVER_EXTERNAL = [
+  'react',
+  'react-dom',
+  'react-dom/static',
+  'react-dom/client',
+  'react/jsx-runtime',
+]
 
 /** Per-page client entries: `hydrate-<pageId>.jsx` under `.ossy/` */
 const HYDRATE_STUB_PREFIX = 'hydrate-'
@@ -210,9 +232,10 @@ export function createOssyClientRollupPlugins ({ nodeEnv, copyPublicFrom, buildP
 }
 
 /** Bundles a single Node ESM file (inline dynamic imports) for SSR / API / tasks. */
-export async function bundleOssyNodeEntry ({ inputPath, outputFile, nodeEnv, onWarn }) {
+export async function bundleOssyNodeEntry ({ inputPath, outputFile, nodeEnv, onWarn, external }) {
   const bundle = await rollup({
     input: inputPath,
+    ...(external && external.length ? { external } : {}),
     plugins: createOssyAppBundlePlugins({ nodeEnv }),
     onwarn (warning, defaultHandler) {
       if (onWarn) {
@@ -231,14 +254,19 @@ export async function bundleOssyNodeEntry ({ inputPath, outputFile, nodeEnv, onW
 }
 
 /**
- * Re-exports middleware via `file:` URL so `src/middleware.js` can keep relative imports.
+ * Re-exports middleware and app config via `file:` URLs so `src/*.js` can keep relative imports.
  */
-export function writeAppRuntimeShims ({ middlewareSourcePath, ossyDir }) {
+export function writeAppRuntimeShims ({ middlewareSourcePath, configSourcePath, ossyDir }) {
   const mwHref = url.pathToFileURL(path.resolve(middlewareSourcePath)).href
   fs.writeFileSync(
     path.join(ossyDir, OSSY_MIDDLEWARE_RUNTIME_BASENAME),
     `// Generated by @ossy/app — do not edit\nexport { default } from '${mwHref}'\n`
   )
+  const cfgHref = url.pathToFileURL(path.resolve(configSourcePath)).href
+  fs.writeFileSync(
+    path.join(ossyDir, OSSY_SERVER_CONFIG_RUNTIME_BASENAME),
+    `// Generated by @ossy/app — do not edit\nexport { default } from '${cfgHref}'\n`
+  )
 }
 
 /**
@@ -258,6 +286,18 @@ export function copyOssyAppRuntime ({ scriptDir, buildPath }) {
   }
   fs.copyFileSync(path.join(scriptDir, 'worker-entry.js'), path.join(buildPath, 'worker.js'))
   fs.copyFileSync(path.join(scriptDir, 'worker-runtime.js'), path.join(buildPath, 'worker-runtime.js'))
+  const ossyOut = ossyGeneratedDir(buildPath)
+  for (const name of [
+    OSSY_PAGES_RUNTIME_BASENAME,
+    OSSY_API_RUNTIME_BASENAME,
+    OSSY_TASKS_RUNTIME_BASENAME,
+  ]) {
+    fs.copyFileSync(path.join(scriptDir, name), path.join(ossyOut, name))
+  }
+  fs.copyFileSync(
+    path.join(scriptDir, OSSY_RENDER_PAGE_RUNTIME_BASENAME),
+    path.join(ossyOut, OSSY_RENDER_PAGE_RUNTIME_BASENAME)
+  )
 }
 
 /**
@@ -281,107 +321,162 @@ export function discoverFilesByPattern (srcDir, filePattern) {
   return files.sort()
 }
 
-/**
- * Merges every `*.api.js` (and `.api.mjs` / `.api.cjs`) under `src/` into one default export array
- * for the Ossy API router ({ id, path, handle }). With no API files, emits `export default []`.
- */
-export function generateApiModule ({ generatedPath, apiFiles }) {
-  if (apiFiles.length === 0) {
-    return [
-      '// Generated by @ossy/app — do not edit',
-      '',
-      'export default []',
-      '',
-    ].join('\n')
+export function writeOssyJson (filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8')
+}
+
+/** JSON manifest: discovered API source paths (posix, relative to `cwd`). */
+export function buildApiManifestPayload (apiFiles, cwd = process.cwd()) {
+  return {
+    version: 1,
+    files: apiFiles.map((f) => path.relative(cwd, f).replace(/\\/g, '/')),
+  }
+}
+
+/** JSON manifest: discovered task source paths (posix, relative to `cwd`). */
+export function buildTasksManifestPayload (taskFiles, cwd = process.cwd()) {
+  return {
+    version: 1,
+    files: taskFiles.map((f) => path.relative(cwd, f).replace(/\\/g, '/')),
   }
-  const lines = [
-    '// Generated by @ossy/app — do not edit',
-    '',
-  ]
-  apiFiles.forEach((f, i) => {
-    const rel = relToGeneratedImport(generatedPath, f)
-    lines.push(`import * as _api${i} from './${rel}'`)
-  })
-  lines.push(
-    '',
-    'function _normalizeApiExport(mod) {',
-    '  const d = mod?.default',
-    '  if (d == null) return []',
-    '  return Array.isArray(d) ? d : [d]',
-    '}',
-    '',
-    'export default [',
-  )
-  const parts = apiFiles.map((_, i) => `  ..._normalizeApiExport(_api${i}),`)
-  lines.push(parts.join('\n'))
-  lines.push(']')
-  lines.push('')
-  return lines.join('\n')
 }
 
 /**
- * Writes `build/.ossy/api.generated.js` and returns its path for `@ossy/api/source-file`.
- * Always uses the generated file so the Rollup replace target stays stable.
+ * Writes `build/.ossy/api.generated.json` (sources only).
+ * Compiled modules + `api.bundle.json` are produced by {@link compileOssyNodeArtifacts}.
  */
-export function resolveApiSource ({ srcDir, buildPath }) {
+export function resolveApiSource ({ srcDir, buildPath, cwd = process.cwd() }) {
   ensureOssyGeneratedDir(buildPath)
   const generatedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_API_BASENAME)
   const apiFiles = discoverFilesByPattern(srcDir, API_FILE_PATTERN)
-  fs.writeFileSync(
-    generatedPath,
-    generateApiModule({ generatedPath, apiFiles })
-  )
-  return { apiSourcePath: generatedPath, apiOverviewFiles: apiFiles }
+  writeOssyJson(generatedPath, buildApiManifestPayload(apiFiles, cwd))
+  return { apiGeneratedPath: generatedPath, apiOverviewFiles: apiFiles }
 }
 
 /**
- * Merges `src/tasks.js` (optional) and every `*.task.js` under `src/` into one default export array
- * of job handlers `{ type, handler }` for the Ossy worker.
+ * Writes `build/.ossy/tasks.generated.json` (sources only).
  */
-export function generateTaskModule ({ generatedPath, taskFiles }) {
-  const lines = [
-    '// Generated by @ossy/app — do not edit',
-    '',
-  ]
-  taskFiles.forEach((f, i) => {
-    const rel = relToGeneratedImport(generatedPath, f)
-    lines.push(`import * as _task${i} from './${rel}'`)
-  })
-  lines.push(
-    '',
-    'function _normalizeTaskExport(mod) {',
-    '  const d = mod?.default',
-    '  if (d == null) return []',
-    '  return Array.isArray(d) ? d : [d]',
-    '}',
-    '',
-    'export default [',
-  )
-  const parts = []
-  taskFiles.forEach((_, i) => {
-    parts.push(`  ..._normalizeTaskExport(_task${i}),`)
-  })
-  lines.push(parts.join('\n'))
-  lines.push(']')
-  lines.push('')
-  return lines.join('\n')
-}
-
-/**
- * Writes `build/.ossy/tasks.generated.js` and returns its path (stable Rollup input; empty when no task files).
- */
-export function resolveTaskSource ({ srcDir, buildPath }) {
+export function resolveTaskSource ({ srcDir, buildPath, cwd = process.cwd() }) {
   ensureOssyGeneratedDir(buildPath)
   const generatedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_TASKS_BASENAME)
   const taskFiles = discoverFilesByPattern(srcDir, TASK_FILE_PATTERN)
-  fs.writeFileSync(
-    generatedPath,
-    generateTaskModule({
-      generatedPath,
-      taskFiles,
+  writeOssyJson(generatedPath, buildTasksManifestPayload(taskFiles, cwd))
+  return { tasksGeneratedPath: generatedPath, taskOverviewFiles: taskFiles }
+}
+
+export async function compilePageServerModules ({
+  pageFiles,
+  srcDir,
+  ossyDir,
+  nodeEnv,
+  onWarn,
+}) {
+  const modsDir = path.join(ossyDir, OSSY_PAGE_MODULES_DIRNAME)
+  const entriesDir = path.join(ossyDir, OSSY_PAGE_SERVER_ENTRIES_DIRNAME)
+  fs.rmSync(modsDir, { recursive: true, force: true })
+  fs.rmSync(entriesDir, { recursive: true, force: true })
+  if (pageFiles.length === 0) {
+    return []
+  }
+  fs.mkdirSync(modsDir, { recursive: true })
+  fs.mkdirSync(entriesDir, { recursive: true })
+  const bundlePages = []
+  for (const f of pageFiles) {
+    const pageId = clientHydrateIdForPage(f, srcDir)
+    const safeId = String(pageId).replace(/[^a-zA-Z0-9_-]+/g, '-') || 'page'
+    const outName = `${safeId}.mjs`
+    const outFile = path.join(modsDir, outName)
+    const stubPath = path.join(entriesDir, `${safeId}.mjs`)
+    writePageServerRollupEntry({ pageAbsPath: f, stubPath })
+    await bundleOssyNodeEntry({
+      inputPath: stubPath,
+      outputFile: outFile,
+      nodeEnv,
+      onWarn,
+      external: OSSY_PAGE_SERVER_EXTERNAL,
     })
-  )
-  return { taskSourcePath: generatedPath, taskOverviewFiles: taskFiles }
+    bundlePages.push({
+      id: pageId,
+      module: `${OSSY_PAGE_MODULES_DIRNAME}/${outName}`,
+    })
+  }
+  return bundlePages
+}
+
+export async function compileApiServerModules ({ apiFiles, ossyDir, nodeEnv, onWarn }) {
+  const modsDir = path.join(ossyDir, OSSY_API_MODULES_DIRNAME)
+  fs.rmSync(modsDir, { recursive: true, force: true })
+  if (apiFiles.length === 0) {
+    return []
+  }
+  fs.mkdirSync(modsDir, { recursive: true })
+  const modules = []
+  for (let i = 0; i < apiFiles.length; i++) {
+    const outName = `api-${i}.mjs`
+    const outFile = path.join(modsDir, outName)
+    await bundleOssyNodeEntry({
+      inputPath: apiFiles[i],
+      outputFile: outFile,
+      nodeEnv,
+      onWarn,
+    })
+    modules.push(`${OSSY_API_MODULES_DIRNAME}/${outName}`)
+  }
+  return modules
+}
+
+export async function compileTaskServerModules ({ taskFiles, ossyDir, nodeEnv, onWarn }) {
+  const modsDir = path.join(ossyDir, OSSY_TASK_MODULES_DIRNAME)
+  fs.rmSync(modsDir, { recursive: true, force: true })
+  if (taskFiles.length === 0) {
+    return []
+  }
+  fs.mkdirSync(modsDir, { recursive: true })
+  const modules = []
+  for (let i = 0; i < taskFiles.length; i++) {
+    const outName = `task-${i}.mjs`
+    const outFile = path.join(modsDir, outName)
+    await bundleOssyNodeEntry({
+      inputPath: taskFiles[i],
+      outputFile: outFile,
+      nodeEnv,
+      onWarn,
+    })
+    modules.push(`${OSSY_TASK_MODULES_DIRNAME}/${outName}`)
+  }
+  return modules
+}
+
+/**
+ * Writes `pages.bundle.json`, `api.bundle.json`, `tasks.bundle.json` by Rollup-compiling each source module.
+ */
+export async function compileOssyNodeArtifacts ({
+  pageFiles,
+  srcDir,
+  ossyDir,
+  apiFiles,
+  taskFiles,
+  nodeEnv,
+  onWarn,
+}) {
+  const [pageBundleList, apiModuleList, taskModuleList] = await Promise.all([
+    compilePageServerModules({ pageFiles, srcDir, ossyDir, nodeEnv, onWarn }),
+    compileApiServerModules({ apiFiles, ossyDir, nodeEnv, onWarn }),
+    compileTaskServerModules({ taskFiles, ossyDir, nodeEnv, onWarn }),
+  ])
+  writeOssyJson(path.join(ossyDir, OSSY_PAGES_BUNDLE_BASENAME), {
+    version: 1,
+    pages: pageBundleList,
+  })
+  writeOssyJson(path.join(ossyDir, OSSY_API_BUNDLE_BASENAME), {
+    version: 1,
+    modules: apiModuleList,
+  })
+  writeOssyJson(path.join(ossyDir, OSSY_TASKS_BUNDLE_BASENAME), {
+    version: 1,
+    modules: taskModuleList,
+  })
 }
 
 export function filePathToRoute(filePath, srcDir) {
@@ -412,9 +507,40 @@ export function clientHydrateIdForPage (pageAbsPath, srcDir) {
   return idMatch ? idMatch[1] : derived.id
 }
 
+export function pageSourceExportsMetadata (pageAbsPath) {
+  try {
+    const src = fs.readFileSync(pageAbsPath, 'utf8')
+    return /\bexport\s+const\s+metadata\b/.test(src)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Rollup tree-shakes `export const metadata` when the page file is the entry and `default`
+ * never references it — breaks i18n `path` objects at runtime. Re-export from a shim entry
+ * so `metadata` stays in the module graph.
+ */
+export function writePageServerRollupEntry ({ pageAbsPath, stubPath }) {
+  const rel = relToGeneratedImport(stubPath, pageAbsPath)
+  const meta = pageSourceExportsMetadata(pageAbsPath)
+    ? ', metadata'
+    : ''
+  fs.mkdirSync(path.dirname(stubPath), { recursive: true })
+  fs.writeFileSync(
+    stubPath,
+    [
+      '// Generated by @ossy/app — do not edit',
+      `export { default${meta} } from '${rel}'`,
+      '',
+    ].join('\n'),
+    'utf8'
+  )
+}
+
 /**
  * One client entry per page: imports only that page module and hydrates the document.
- * Keeps the same `toPage` shape as `generatePagesModule` so SSR and client trees match.
+ * Keeps the same `toPage` shape as `pages.runtime.mjs` + manifests so SSR and client trees match.
  */
 export function generatePageHydrateModule ({ pageAbsPath, stubAbsPath, srcDir }) {
   const rel = relToGeneratedImport(stubAbsPath, pageAbsPath)
@@ -491,32 +617,39 @@ export function buildClientHydrateInput (pageFiles, srcDir, ossyDir) {
   return input
 }
 
-export function generatePagesModule (pageFiles, srcDir, generatedPath) {
-  const lines = [
-    "import React from 'react'",
-    ...pageFiles.map((f, i) => {
-      const rel = relToGeneratedImport(generatedPath, f)
-      return `import * as _page${i} from './${rel}'`
-    }),
-    '',
-    'function toPage(mod, derived) {',
-    '  const meta = mod?.metadata || {}',
-    "  const def = mod?.default",
-    "  if (typeof def === 'function') {",
-    "    return { ...derived, ...meta, element: React.createElement(def) }",
-    '  }',
-    "  return { ...derived, ...meta, ...(def || {}) }",
-    '}',
-    '',
-    'export default [',
-    ...pageFiles.map((f, i) => {
-      const { id, path: defaultPath } = filePathToRoute(f, srcDir)
-      const pathStr = JSON.stringify(defaultPath)
-      return `  toPage(_page${i}, { id: '${id}', path: ${pathStr} }),`
-    }),
-    ']',
-  ]
-  return lines.join('\n')
+/** JSON manifest: route ids, default paths, and page source paths (posix, relative to `cwd`). */
+export function buildPagesGeneratedPayload (pageFiles, srcDir, cwd = process.cwd()) {
+  const pages = pageFiles.map((f) => {
+    const { path: routePath } = filePathToRoute(f, srcDir)
+    const pageId = clientHydrateIdForPage(f, srcDir)
+    return {
+      id: pageId,
+      path: routePath,
+      sourceFile: path.relative(cwd, f).replace(/\\/g, '/'),
+    }
+  })
+  return { version: 1, pages }
+}
+
+export function writePagesManifest ({
+  pageFiles,
+  srcDir,
+  pagesGeneratedPath,
+  cwd = process.cwd(),
+}) {
+  writeOssyJson(pagesGeneratedPath, buildPagesGeneratedPayload(pageFiles, srcDir, cwd))
+}
+
+export function parsePagesFromManifestJson (manifestPath) {
+  try {
+    const raw = fs.readFileSync(manifestPath, 'utf8')
+    const data = JSON.parse(raw)
+    const pages = data?.pages
+    if (!Array.isArray(pages)) return []
+    return pages.map((p) => ({ id: p.id, path: p.path }))
+  } catch {
+    return []
+  }
 }
 
 export function parsePagesFromSource(filePath) {
@@ -557,7 +690,6 @@ export function parsePagesFromSource(filePath) {
  */
 export function getBuildOverviewSnapshot ({
   pagesSourcePath,
-  apiSourcePath,
   apiOverviewFiles = [],
   configPath,
   pageFiles,
@@ -567,17 +699,14 @@ export function getBuildOverviewSnapshot ({
   const configRel = fs.existsSync(configPath) ? rel(configPath) : null
 
   const pages = pageFiles?.length
-    ? pageFiles.map((f) => filePathToRoute(f, srcDir))
-    : parsePagesFromSource(pagesSourcePath)
-
-  const apiFilesToScan =
-    apiOverviewFiles?.length > 0
-      ? apiOverviewFiles
-      : fs.existsSync(apiSourcePath)
-        ? [apiSourcePath]
-        : []
+    ? pageFiles.map((f) => {
+        const { id, path: routePath } = filePathToRoute(f, srcDir)
+        return { id: clientHydrateIdForPage(f, srcDir), path: routePath }
+      })
+    : parsePagesFromManifestJson(pagesSourcePath)
+
   const apiRoutes = []
-  for (const f of apiFilesToScan) {
+  for (const f of apiOverviewFiles) {
     if (fs.existsSync(f)) apiRoutes.push(...parsePagesFromSource(f))
   }
 
@@ -633,24 +762,21 @@ export const build = async (cliArgs) => {
       log: false,
     })
 
-    const pagesGeneratedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_PAGES_BASENAME)
+    const ossyDir = ossyGeneratedDir(buildPath)
+    const pagesGeneratedPath = path.join(ossyDir, OSSY_GEN_PAGES_BASENAME)
 
-    fs.writeFileSync(
+    writePagesManifest({
+      pageFiles,
+      srcDir,
       pagesGeneratedPath,
-      generatePagesModule(pageFiles, srcDir, pagesGeneratedPath)
-    )
-    const ossyDir = ossyGeneratedDir(buildPath)
+    })
     writePageHydrateStubs(pageFiles, srcDir, ossyDir)
     const clientHydrateInput = buildClientHydrateInput(pageFiles, srcDir, ossyDir)
 
-    const {
-      apiSourcePath: resolvedApi,
-      apiOverviewFiles,
-    } = resolveApiSource({
+    const { apiOverviewFiles } = resolveApiSource({
       srcDir,
       buildPath,
     })
-    let apiSourcePath = resolvedApi
     let middlewareSourcePath = path.resolve('src/middleware.js');
     const publicDir = path.resolve('public')
 
@@ -662,14 +788,11 @@ export const build = async (cliArgs) => {
       ? configPath
       : path.resolve(scriptDir, 'default-config.js')
 
-    const pagesBundlePath = path.join(ossyDir, OSSY_PAGES_PRERENDER_BUNDLE)
-    const apiBundlePath = path.join(ossyDir, OSSY_API_SERVER_BUNDLE)
-    const tasksBundlePath = path.join(ossyDir, OSSY_TASKS_SERVER_BUNDLE)
+    const pagesEntryPath = path.join(ossyDir, OSSY_PAGES_RUNTIME_BASENAME)
 
     const useDashboard = Object.keys(clientHydrateInput).length > 0
     const overviewSnap = getBuildOverviewSnapshot({
       pagesSourcePath: pagesGeneratedPath,
-      apiSourcePath,
       apiOverviewFiles,
       configPath,
       pageFiles,
@@ -706,7 +829,6 @@ export const build = async (cliArgs) => {
       console.log('\n  \x1b[1m@ossy/app\x1b[0m  \x1b[2mbuild\x1b[0m')
       printBuildOverview({
         pagesSourcePath: pagesGeneratedPath,
-        apiSourcePath,
         apiOverviewFiles,
         configPath,
         pageFiles,
@@ -724,28 +846,20 @@ export const build = async (cliArgs) => {
         }
       : undefined
 
-    await bundleOssyNodeEntry({
-      inputPath: pagesGeneratedPath,
-      outputFile: pagesBundlePath,
-      nodeEnv: 'production',
-      onWarn: warnSink,
-    })
-    await bundleOssyNodeEntry({
-      inputPath: apiSourcePath,
-      outputFile: apiBundlePath,
-      nodeEnv: 'production',
-      onWarn: warnSink,
-    })
-    const { taskSourcePath } = resolveTaskSource({ srcDir, buildPath })
-    await bundleOssyNodeEntry({
-      inputPath: taskSourcePath,
-      outputFile: tasksBundlePath,
+    const { taskOverviewFiles } = resolveTaskSource({ srcDir, buildPath })
+    await compileOssyNodeArtifacts({
+      pageFiles,
+      srcDir,
+      ossyDir,
+      apiFiles: apiOverviewFiles,
+      taskFiles: taskOverviewFiles,
       nodeEnv: 'production',
       onWarn: warnSink,
     })
 
     writeAppRuntimeShims({
       middlewareSourcePath,
+      configSourcePath,
       ossyDir,
     })
     copyOssyAppRuntime({ scriptDir, buildPath })
@@ -759,7 +873,7 @@ export const build = async (cliArgs) => {
           copyPublicFrom: publicDir,
           buildPath,
           nodeEnv: 'production',
-          pagesBundlePath,
+          pagesEntryPath,
           configSourcePath,
           createClientRollupPlugins: createOssyClientRollupPlugins,
           minifyBrowserStaticChunks,

package/cli/dev.js

@@ -7,11 +7,11 @@ import {
   filePathToRoute,
   discoverFilesByPattern,
   PAGE_FILE_PATTERN,
-  generatePagesModule,
+  writePagesManifest,
   resolveApiSource,
   resolveTaskSource,
   resetOssyBuildDir,
-  bundleOssyNodeEntry,
+  compileOssyNodeArtifacts,
   copyOssyAppRuntime,
   writeAppRuntimeShims,
   createOssyAppBundlePlugins,
@@ -21,11 +21,7 @@ import {
   clientHydrateIdForPage,
   ossyGeneratedDir,
   OSSY_GEN_PAGES_BASENAME,
-  OSSY_GEN_API_BASENAME,
-  OSSY_GEN_TASKS_BASENAME,
-  OSSY_PAGES_PRERENDER_BUNDLE,
-  OSSY_API_SERVER_BUNDLE,
-  OSSY_TASKS_SERVER_BUNDLE,
+  OSSY_PAGES_RUNTIME_BASENAME,
   writeResourceTemplatesBarrelIfPresent,
   resourceTemplatesDir,
   OSSY_RESOURCE_TEMPLATES_OUT,
@@ -48,7 +44,7 @@ export const dev = async (cliArgs) => {
     const buildPath = path.resolve('build')
     const srcDir = path.resolve('src')
     const configPath = path.resolve(options['--config'] || 'src/config.js');
-    const pageFiles = discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN)
+    let currentPageFiles = discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN)
 
     resetOssyBuildDir(buildPath)
 
@@ -58,35 +54,33 @@ export const dev = async (cliArgs) => {
     })
     let resourceTemplatesDevLogged = false
 
-    const pagesGeneratedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_PAGES_BASENAME)
-    fs.writeFileSync(
-      pagesGeneratedPath,
-      generatePagesModule(pageFiles, srcDir, pagesGeneratedPath)
-    )
     const ossyDir = ossyGeneratedDir(buildPath)
-    writePageHydrateStubs(pageFiles, srcDir, ossyDir)
-    const clientHydrateInput = buildClientHydrateInput(pageFiles, srcDir, ossyDir)
-
-    const {
-      apiSourcePath: resolvedApi,
-      apiOverviewFiles,
-    } = resolveApiSource({
+    const pagesGeneratedPath = path.join(ossyDir, OSSY_GEN_PAGES_BASENAME)
+    writePagesManifest({
+      pageFiles: currentPageFiles,
       srcDir,
-      buildPath,
+      pagesGeneratedPath,
     })
-    let apiSourcePath = resolvedApi
-    resolveTaskSource({ srcDir, buildPath })
+    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 (pageFiles.length === 0) {
+    if (currentPageFiles.length === 0) {
       console.log('\n  \x1b[1m@ossy/app\x1b[0m  \x1b[2mdev\x1b[0m')
       printBuildOverview({
         pagesSourcePath: pagesGeneratedPath,
-        apiSourcePath,
         apiOverviewFiles,
         configPath,
-        pageFiles,
+        pageFiles: currentPageFiles,
       })
       if (resourceTemplatesResult.wrote && resourceTemplatesResult.path) {
         console.log(
@@ -103,29 +97,21 @@ export const dev = async (cliArgs) => {
       ? configPath
       : path.resolve(scriptDir, 'default-config.js')
 
-    const pagesBundlePath = path.join(ossyDir, OSSY_PAGES_PRERENDER_BUNDLE)
-    const apiBundlePath = path.join(ossyDir, OSSY_API_SERVER_BUNDLE)
-    const tasksBundlePath = path.join(ossyDir, OSSY_TASKS_SERVER_BUNDLE)
-    const tasksGeneratedPath = path.join(ossyDir, OSSY_GEN_TASKS_BASENAME)
+    const pagesEntryPath = path.join(ossyDir, OSSY_PAGES_RUNTIME_BASENAME)
 
     const runNodeBundles = async () => {
-      await bundleOssyNodeEntry({
-        inputPath: pagesGeneratedPath,
-        outputFile: pagesBundlePath,
-        nodeEnv: 'development',
-      })
-      await bundleOssyNodeEntry({
-        inputPath: apiSourcePath,
-        outputFile: apiBundlePath,
-        nodeEnv: 'development',
-      })
-      await bundleOssyNodeEntry({
-        inputPath: tasksGeneratedPath,
-        outputFile: tasksBundlePath,
+      refreshApiTaskManifests()
+      await compileOssyNodeArtifacts({
+        pageFiles: currentPageFiles,
+        srcDir,
+        ossyDir,
+        apiFiles: apiOverviewFiles,
+        taskFiles: taskOverviewFiles,
         nodeEnv: 'development',
       })
       writeAppRuntimeShims({
         middlewareSourcePath,
+        configSourcePath,
         ossyDir,
       })
       copyOssyAppRuntime({ scriptDir, buildPath })
@@ -194,38 +180,7 @@ export const dev = async (cliArgs) => {
     }
 
     const nodeWatchOpts = { watch: { clearScreen: false } }
-    const watchConfigs = [
-      {
-        input: pagesGeneratedPath,
-        output: {
-          file: pagesBundlePath,
-          format: 'esm',
-          inlineDynamicImports: true,
-        },
-        plugins: createOssyAppBundlePlugins({ nodeEnv: 'development' }),
-        ...nodeWatchOpts,
-      },
-      {
-        input: apiSourcePath,
-        output: {
-          file: apiBundlePath,
-          format: 'esm',
-          inlineDynamicImports: true,
-        },
-        plugins: createOssyAppBundlePlugins({ nodeEnv: 'development' }),
-        ...nodeWatchOpts,
-      },
-      {
-        input: tasksGeneratedPath,
-        output: {
-          file: tasksBundlePath,
-          format: 'esm',
-          inlineDynamicImports: true,
-        },
-        plugins: createOssyAppBundlePlugins({ nodeEnv: 'development' }),
-        ...nodeWatchOpts,
-      },
-    ]
+    const watchConfigs = []
     if (Object.keys(clientHydrateInput).length > 0) {
       watchConfigs.push({
         input: clientHydrateInput,
@@ -233,6 +188,30 @@ export const dev = async (cliArgs) => {
         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)
 
@@ -251,22 +230,22 @@ export const dev = async (cliArgs) => {
       if (event.code === 'END') {
         writeAppRuntimeShims({
           middlewareSourcePath,
+          configSourcePath,
           ossyDir,
         })
         copyOssyAppRuntime({ scriptDir, buildPath })
-        if (pageFiles.length > 0) {
+        if (currentPageFiles.length > 0) {
           const pageIds = [
-            ...new Set(pageFiles.map((f) => clientHydrateIdForPage(f, srcDir))),
+            ...new Set(currentPageFiles.map((f) => clientHydrateIdForPage(f, srcDir))),
           ].sort()
           const overviewSnap = getBuildOverviewSnapshot({
             pagesSourcePath: pagesGeneratedPath,
-            apiSourcePath,
             apiOverviewFiles,
             configPath,
-            pageFiles,
+            pageFiles: currentPageFiles,
           })
           const idToPath = Object.fromEntries(
-            pageFiles.map((f) => [
+            currentPageFiles.map((f) => [
               clientHydrateIdForPage(f, srcDir),
               filePathToRoute(f, srcDir).path,
             ])
@@ -298,7 +277,7 @@ export const dev = async (cliArgs) => {
           try {
             await prerenderReactTask.handler({
               op: 'prerenderPagesParallel',
-              pagesBundlePath,
+              pagesEntryPath,
               configSourcePath,
               publicDir: path.join(buildPath, 'public'),
               reporter,
@@ -315,37 +294,34 @@ export const dev = async (cliArgs) => {
 
     const regenApiGenerated = () => {
       if (options['--api-source']) return
-      resolveApiSource({
-        srcDir,
-        buildPath,
-      })
-      const gen = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_API_BASENAME)
-      if (fs.existsSync(gen) && typeof watcher?.invalidate === 'function') {
-        watcher.invalidate(gen)
-      }
+      void runNodeBundles().then(() => scheduleRestart())
     }
 
     const regenTasksGenerated = () => {
-      resolveTaskSource({ srcDir, buildPath })
-      if (fs.existsSync(tasksGeneratedPath) && typeof watcher?.invalidate === 'function') {
-        watcher.invalidate(tasksGeneratedPath)
-      }
+      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)
-        fs.writeFileSync(regenPath, generatePagesModule(refreshedPageFiles, srcDir, regenPath))
+        writePagesManifest({
+          pageFiles: refreshedPageFiles,
+          srcDir,
+          pagesGeneratedPath: regenPath,
+        })
         writePageHydrateStubs(refreshedPageFiles, srcDir, ossyDir)
-        if (typeof watcher?.invalidate === 'function') {
-          watcher.invalidate(regenPath)
-          for (const f of refreshedPageFiles) {
-            const hid = clientHydrateIdForPage(f, srcDir)
-            watcher.invalidate(path.join(ossyDir, `hydrate-${hid}.jsx`))
+        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()

package/cli/pages.runtime.mjs

@@ -0,0 +1,39 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import React from 'react'
+
+const __ossyDir = path.dirname(fileURLToPath(import.meta.url))
+
+function readJson (name) {
+  return JSON.parse(fs.readFileSync(path.join(__ossyDir, name), 'utf8'))
+}
+
+function toPage (mod, derived) {
+  const meta = mod?.metadata || {}
+  const def = mod?.default
+  if (typeof def === 'function') {
+    return { ...derived, ...meta, element: React.createElement(def) }
+  }
+  return { ...derived, ...meta, ...(def || {}) }
+}
+
+const { pages: metaPages } = readJson('pages.generated.json')
+const { pages: bundlePages } = readJson('pages.bundle.json')
+
+if (metaPages.length !== bundlePages.length) {
+  throw new Error(
+    '[@ossy/app][pages.runtime] pages.generated.json and pages.bundle.json must list the same number of pages'
+  )
+}
+
+const out = []
+for (let i = 0; i < metaPages.length; i++) {
+  const derived = { id: metaPages[i].id, path: metaPages[i].path }
+  const rel = bundlePages[i].module
+  const abs = path.resolve(__ossyDir, rel)
+  const mod = await import(pathToFileURL(abs).href)
+  out.push(toPage(mod, derived))
+}
+
+export default out

package/cli/prerender-react.task.js

@@ -2,7 +2,7 @@ import path from 'path'
 import url from 'url'
 import fs from 'fs'
 import { rollup } from 'rollup'
-import { BuildPage } from './render-page.task.js'
+import { BuildPage, buildPrerenderAppConfig } from './render-page.task.js'
 import { pageIdFromHydrateEntryName } from './build-terminal.js'
 
 /**
@@ -24,35 +24,6 @@ function pathIsPrerenderable (routePath) {
   return true
 }
 
-/** Mirrors server-era app shell config with static defaults (no cookies / session). */
-export function buildPrerenderAppConfig ({
-  buildTimeConfig,
-  pageList,
-  activeRouteId,
-  urlPath,
-}) {
-  const pages = pageList.map((page) => {
-    const entry = {
-      id: page?.id,
-      path: page?.path,
-    }
-    if (activeRouteId != null && page?.id === activeRouteId) {
-      entry.element = page?.element
-    }
-    return entry
-  })
-  return {
-    ...buildTimeConfig,
-    url: urlPath,
-    theme: buildTimeConfig.theme || 'light',
-    isAuthenticated: false,
-    workspaceId: buildTimeConfig.workspaceId,
-    apiUrl: buildTimeConfig.apiUrl,
-    pages,
-    sidebarPrimaryCollapsed: false,
-  }
-}
-
 function copyPublicToBuild ({ copyPublicFrom, buildPath }) {
   if (!copyPublicFrom || !fs.existsSync(copyPublicFrom)) return
   const dest = path.join(buildPath, 'public')
@@ -170,13 +141,13 @@ async function prerenderOnePage ({
 }
 
 async function prerenderPagesParallel ({
-  pagesBundlePath,
+  pagesEntryPath,
   configSourcePath,
   publicDir,
   reporter,
 }) {
   const cfgHref = url.pathToFileURL(path.resolve(configSourcePath)).href
-  const pagesHref = url.pathToFileURL(path.resolve(pagesBundlePath)).href
+  const pagesHref = url.pathToFileURL(path.resolve(pagesEntryPath)).href
 
   const configModule = await import(cfgHref)
   const pagesModule = await import(pagesHref)
@@ -237,7 +208,7 @@ async function runProduction ({
   copyPublicFrom,
   buildPath,
   nodeEnv,
-  pagesBundlePath,
+  pagesEntryPath,
   configSourcePath,
   createClientRollupPlugins,
   minifyBrowserStaticChunks,
@@ -259,7 +230,7 @@ async function runProduction ({
   })
 
   const { failures: prerenderFailures } = await prerenderPagesParallel({
-    pagesBundlePath,
+    pagesEntryPath,
     configSourcePath,
     publicDir: path.join(buildPath, 'public'),
     reporter,
@@ -284,7 +255,7 @@ export default {
     }
     if (op === 'prerenderPagesParallel') {
       return prerenderPagesParallel({
-        pagesBundlePath: input.pagesBundlePath,
+        pagesEntryPath: input.pagesEntryPath,
         configSourcePath: input.configSourcePath,
         publicDir: input.publicDir,
         reporter: input.reporter,

package/cli/render-page.task.js

@@ -1,6 +1,38 @@
 import React, { cloneElement } from 'react'
 import { prerenderToNodeStream } from 'react-dom/static'
 
+/**
+ * App shell config for SSR / prerender (mirrors client: theme, pages metadata, active route element).
+ */
+export function buildPrerenderAppConfig ({
+  buildTimeConfig,
+  pageList,
+  activeRouteId,
+  urlPath,
+  isAuthenticated = false,
+}) {
+  const pages = pageList.map((page) => {
+    const entry = {
+      id: page?.id,
+      path: page?.path,
+    }
+    if (activeRouteId != null && page?.id === activeRouteId) {
+      entry.element = page?.element
+    }
+    return entry
+  })
+  return {
+    ...buildTimeConfig,
+    url: urlPath,
+    theme: buildTimeConfig.theme || 'light',
+    isAuthenticated,
+    workspaceId: buildTimeConfig.workspaceId,
+    apiUrl: buildTimeConfig.apiUrl,
+    pages,
+    sidebarPrimaryCollapsed: false,
+  }
+}
+
 /** Strips non-JSON content (e.g. React elements on `pages`) for the bootstrap script. */
 export function appConfigForBootstrap (appConfig) {
   if (!appConfig || typeof appConfig !== 'object') return appConfig

package/cli/server.js

@@ -6,12 +6,34 @@ import { Router as OssyRouter } from '@ossy/router'
 import { ProxyInternal } from './proxy-internal.js'
 import cookieParser from 'cookie-parser'
 
-import ApiRoutes from './.ossy/api.bundle.js'
+import ApiRoutes from './.ossy/api.runtime.mjs'
+import pageRoutes from './.ossy/pages.runtime.mjs'
+import buildTimeConfig from './.ossy/server-config.runtime.mjs'
+import { BuildPage, buildPrerenderAppConfig } from './.ossy/render-page.task.js'
 import Middleware from './.ossy/middleware.runtime.js'
 
 /** API bundle default may be an empty array. */
 const apiRouteList = ApiRoutes ?? []
 
+const sitePageList = Array.isArray(pageRoutes) ? pageRoutes : []
+
+/** When `src/config.js` is minimal, infer language list from the first multi-path page. */
+function pageRouterLanguageOptions (config, pages) {
+  let supported = config?.supportedLanguages
+  let defaultLanguage = config?.defaultLanguage
+  if ((!supported || supported.length <= 1) && pages.length > 0) {
+    const p0 = pages[0]
+    if (p0 && typeof p0.path === 'object' && p0.path != null) {
+      supported = Object.keys(p0.path)
+      defaultLanguage = defaultLanguage || supported[0]
+    }
+  }
+  return {
+    supportedLanguages: Array.isArray(supported) ? supported : [],
+    defaultLanguage,
+  }
+}
+
 const app = express();
 
 const currentDir = path.dirname(url.fileURLToPath(import.meta.url))
@@ -101,22 +123,62 @@ const middleware = [
 
 app.use(middleware)
 
-const Router = OssyRouter.of({
+const apiRouter = OssyRouter.of({
   pages: apiRouteList,
 })
 
-app.all('*all', (req, res) => {
-  const pathname = req.originalUrl
+const { supportedLanguages, defaultLanguage } = pageRouterLanguageOptions(
+  buildTimeConfig,
+  sitePageList
+)
 
-  const route = Router.getPageByUrl(pathname)
+const pageRouter = OssyRouter.of({
+  pages: sitePageList,
+  defaultLanguage,
+  supportedLanguages,
+})
 
-  if (route && typeof route.handle === 'function') {
-    console.log(`[@ossy/app][server] Handling API route: ${pathname}`)
-    route.handle(req, res)
-    return
-  }
+app.all('*all', async (req, res) => {
+  const requestUrl = req.originalUrl || '/'
 
-  res.status(404).send('Not found')
+  try {
+    const apiRoute = apiRouter.getPageByUrl(requestUrl)
+    if (apiRoute && typeof apiRoute.handle === 'function') {
+      console.log(`[@ossy/app][server] Handling API route: ${requestUrl}`)
+      apiRoute.handle(req, res)
+      return
+    }
+
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      res.status(404).send('Not found')
+      return
+    }
+
+    const pageRoute = pageRouter.getPageByUrl(requestUrl)
+    if (pageRoute?.element) {
+      const appConfig = buildPrerenderAppConfig({
+        buildTimeConfig,
+        pageList: sitePageList,
+        activeRouteId: pageRoute.id,
+        urlPath: requestUrl,
+        isAuthenticated: !!req.isAuthenticated,
+      })
+      const html = await BuildPage.handle({
+        route: pageRoute,
+        appConfig,
+        isDevReloadEnabled,
+      })
+      res.status(200).type('html').send(html)
+      return
+    }
+
+    res.status(404).send('Not found')
+  } catch (err) {
+    console.error('[@ossy/app][server] Request handling failed:', err)
+    if (!res.headersSent) {
+      res.status(500).type('text').send('Internal Server Error')
+    }
+  }
 })
 
 app.listen(port, () => {

package/cli/tasks.runtime.mjs

@@ -0,0 +1,22 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const __ossyDir = path.dirname(fileURLToPath(import.meta.url))
+
+function normalizeTaskExport (mod) {
+  const d = mod?.default
+  if (d == null) return []
+  return Array.isArray(d) ? d : [d]
+}
+
+const { modules } = JSON.parse(fs.readFileSync(path.join(__ossyDir, 'tasks.bundle.json'), 'utf8'))
+
+const out = []
+for (const rel of modules) {
+  const abs = path.resolve(__ossyDir, rel)
+  const mod = await import(pathToFileURL(abs).href)
+  out.push(...normalizeTaskExport(mod))
+}
+
+export default out

package/cli/worker-entry.js

@@ -1,5 +1,5 @@
 import 'dotenv/config'
-import taskHandlers from './.ossy/tasks.bundle.js'
+import taskHandlers from './.ossy/tasks.runtime.mjs'
 import { runWorkerScheduler } from './worker-runtime.js'
 
 runWorkerScheduler(taskHandlers)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/app",
-  "version": "1.11.1",
+  "version": "1.11.3",
   "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.1",
-    "@ossy/design-system": "^1.11.1",
-    "@ossy/pages": "^1.11.1",
-    "@ossy/router": "^1.11.1",
-    "@ossy/router-react": "^1.11.1",
-    "@ossy/sdk": "^1.11.1",
-    "@ossy/sdk-react": "^1.11.1",
-    "@ossy/themes": "^1.11.1",
+    "@ossy/connected-components": "^1.11.3",
+    "@ossy/design-system": "^1.11.3",
+    "@ossy/pages": "^1.11.3",
+    "@ossy/router": "^1.11.3",
+    "@ossy/router-react": "^1.11.3",
+    "@ossy/sdk": "^1.11.3",
+    "@ossy/sdk-react": "^1.11.3",
+    "@ossy/themes": "^1.11.3",
     "@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": "dfa200a3ea12c726db2054a0ab902844507716a0"
+  "gitHead": "c8b8fe48b3462ef9f7994894a1b17d844740dc11"
 }