@ossy/app 0.15.13 → 1.0.2

package/cli/build.js

@@ -5,28 +5,95 @@ import { rollup } from 'rollup';
 import babel from '@rollup/plugin-babel';
 import { nodeResolve as resolveDependencies } from '@rollup/plugin-node-resolve'
 import resolveCommonJsDependencies from '@rollup/plugin-commonjs'
-import removeOwnPeerDependencies from 'rollup-plugin-peer-deps-external'
-import minifyJS from '@rollup/plugin-terser'
+import { minify as minifyWithTerser } from 'terser'
 // import typescript from '@rollup/plugin-typescript'
-import preserveDirectives from "rollup-plugin-preserve-directives"
 import json from "@rollup/plugin-json"
+import nodeExternals from 'rollup-plugin-node-externals'
 import copy from 'rollup-plugin-copy';
 import replace from '@rollup/plugin-replace';
 import arg from 'arg'
 import { ensureBuildStubs } from '../scripts/ensure-build-stubs.mjs'
-import { builtinModules, createRequire } from 'node:module'
+import { createRequire } from 'node:module'
 // import inject from '@rollup/plugin-inject'
 
 const PAGE_FILE_PATTERN = /\.page\.(jsx?|tsx?)$/
 const API_FILE_PATTERN = /\.api\.(mjs|cjs|js)$/
 const TASK_FILE_PATTERN = /\.task\.(mjs|cjs|js)$/
+const RESOURCE_TEMPLATE_FILE_PATTERN = /\.resource\.js$/
 
-/** Subfolder under `--destination` / `build` for generated pages/api/task entry stubs. */
+const NODE_MODULES_SEG = `${path.sep}node_modules${path.sep}`
+
+/**
+ * Keep third-party code out of the Rollup graph for the server build.
+ * `preserveModules` + `@rollup/plugin-commonjs` otherwise emits `_virtual/*` chunks that import
+ * `{ __require }` from real `node_modules` paths, which Node ESM cannot execute.
+ *
+ * Rules:
+ * - Resolved absolute path under `node_modules` → external (any npm dep, including transitive).
+ * - Unresolved bare specifier → external so Node loads it (covers `react`, `lodash`, customers’
+ *   `@acme/*`, etc.). Exception: `@ossy/*` is bundled (framework packages; monorepo paths or
+ *   published tarballs — avoids relying on Node resolving those bare ids from `build/server.js`).
+ *
+ * React’s main entry is still CJS; there is no separate official ESM prod file for `import 'react'`.
+ * Leaving it external is correct: Node applies default export interop when Rollup does not rewrite it.
+ */
+export function ossyServerExternal (id, _importer, _isResolved) {
+  if (!id || id[0] === '\0') return false
+  if (path.isAbsolute(id)) {
+    return id.includes(NODE_MODULES_SEG)
+  }
+  if (id.startsWith('.')) return false
+  if (id.startsWith('@ossy/')) return false
+  return true
+}
+
+/** 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 for JS served to the browser (see `entryFileNames` / `chunkFileNames`). */
+const BROWSER_STATIC_PREFIX = 'public/static/'
+
+function minifyBrowserStaticChunks () {
+  return {
+    name: 'minify-browser-static-chunks',
+    async renderChunk (code, chunk, outputOptions) {
+      const fileName = chunk.fileName
+      if (!fileName || !fileName.startsWith(BROWSER_STATIC_PREFIX)) {
+        return null
+      }
+      const useSourceMap =
+        outputOptions.sourcemap === true || typeof outputOptions.sourcemap === 'string'
+      const fmt = outputOptions.format
+      const result = await minifyWithTerser(code, {
+        sourceMap: useSourceMap,
+        module: fmt === 'es' || fmt === 'esm',
+      })
+      const out = result.code ?? code
+      if (useSourceMap && result.map) {
+        const map =
+          typeof result.map === 'string' ? JSON.parse(result.map) : result.map
+        return { code: out, map }
+      }
+      return out
+    },
+  }
+}
+
+/** 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'
 
+/** 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}`
+}
+
 export function ossyGeneratedDir (buildPath) {
   return path.join(buildPath, OSSY_GEN_DIRNAME)
 }
@@ -37,33 +104,142 @@ export function ensureOssyGeneratedDir (buildPath) {
   return dir
 }
 
-export function resolvePageShellSource (cwd, scriptDir) {
-  const candidates = [
-    path.resolve(cwd, 'src/page-shell.jsx'),
-    path.resolve(cwd, 'src/page-shell.js'),
-  ]
-  for (const p of candidates) {
-    if (fs.existsSync(p)) return p
+function relToGeneratedImport (generatedAbs, targetAbs) {
+  return path.relative(path.dirname(generatedAbs), targetAbs).replace(/\\/g, '/')
+}
+
+/** Deletes the entire build output dir, then recreates `build/.ossy` (generated stubs are written next). */
+export function resetOssyBuildDir (buildPath) {
+  fs.rmSync(buildPath, { recursive: true, force: true })
+  ensureOssyGeneratedDir(buildPath)
+}
+
+export function resourceTemplatesDir (cwd = process.cwd()) {
+  return path.join(cwd, 'src', 'resource-templates')
+}
+
+export function discoverResourceTemplateFiles (templatesDir) {
+  if (!fs.existsSync(templatesDir) || !fs.statSync(templatesDir).isDirectory()) {
+    return []
   }
-  return path.resolve(scriptDir, 'page-shell-default.jsx')
+  return fs
+    .readdirSync(templatesDir)
+    .filter((n) => RESOURCE_TEMPLATE_FILE_PATTERN.test(n))
+    .map((n) => path.join(templatesDir, n))
+    .sort((a, b) => path.basename(a).localeCompare(path.basename(b)))
 }
 
-function relToGeneratedImport (generatedAbs, targetAbs) {
-  return path.relative(path.dirname(generatedAbs), targetAbs).replace(/\\/g, '/')
+export function generateResourceTemplatesBarrelSource ({ outputAbs, templateFilesAbs }) {
+  const lines = [
+    '// Generated by @ossy/app — do not edit',
+    '',
+  ]
+  templateFilesAbs.forEach((f, i) => {
+    const rel = relToGeneratedImport(outputAbs, f)
+    lines.push(`import _resource${i} from './${rel}'`)
+  })
+  lines.push('')
+  lines.push(
+    '/** Built-in resource templates merged into every workspace (with imported templates) in the API. */'
+  )
+  lines.push('export const SystemTemplates = [')
+  templateFilesAbs.forEach((_, i) => {
+    lines.push(`  _resource${i},`)
+  })
+  lines.push(']')
+  lines.push('')
+  return lines.join('\n')
 }
 
-/** Clears Rollup output dir but keeps `build/.ossy` (generated sources live there). */
-export function ossyCleanBuildDirPlugin (buildPath) {
-  return {
-    name: 'ossy-clean-build-dir',
-    buildStart () {
-      if (!fs.existsSync(buildPath)) return
-      for (const name of fs.readdirSync(buildPath)) {
-        if (name === OSSY_GEN_DIRNAME) continue
-        fs.rmSync(path.join(buildPath, name), { recursive: true, force: true })
-      }
-    },
+/**
+ * If `src/resource-templates/` exists, writes `.ossy-system-templates.generated.js` there.
+ * No-op when the directory is missing (e.g. website packages). Runs during `build` / `dev`.
+ */
+export function writeResourceTemplatesBarrelIfPresent ({ cwd = process.cwd(), log = true } = {}) {
+  const dir = resourceTemplatesDir(cwd)
+  if (!fs.existsSync(dir)) {
+    return { wrote: false, count: 0, path: null }
+  }
+  const files = discoverResourceTemplateFiles(dir)
+  const outAbs = path.join(dir, OSSY_RESOURCE_TEMPLATES_OUT)
+  fs.writeFileSync(outAbs, generateResourceTemplatesBarrelSource({ outputAbs: outAbs, templateFilesAbs: files }), 'utf8')
+  if (log) {
+    console.log(
+      `[@ossy/app][resource-templates] merged ${files.length} template(s) → ${path.relative(cwd, outAbs)}`
+    )
   }
+  return { wrote: true, count: files.length, path: outAbs }
+}
+
+/**
+ * Shared Rollup plugins (virtual path replaces, resolve, JSX).
+ * Server builds pass `nodeExternals: true` so `dependencies` stay importable from Node at runtime.
+ */
+export function createOssyRollupPlugins ({
+  pagesGeneratedPath,
+  apiSourcePath,
+  middlewareSourcePath,
+  configSourcePath,
+  nodeEnv,
+  nodeExternals: useNodeExternals = false,
+  preferBuiltins = true,
+  copyPublicFrom,
+  buildPath,
+}) {
+  const plugins = [
+    replace({
+      preventAssignment: true,
+      delimiters: ['%%', '%%'],
+      '@ossy/pages/source-file': pagesGeneratedPath,
+    }),
+    replace({
+      preventAssignment: true,
+      delimiters: ['%%', '%%'],
+      '@ossy/api/source-file': apiSourcePath,
+    }),
+    replace({
+      preventAssignment: true,
+      delimiters: ['%%', '%%'],
+      '@ossy/middleware/source-file': middlewareSourcePath,
+    }),
+    replace({
+      preventAssignment: true,
+      delimiters: ['%%', '%%'],
+      '@ossy/config/source-file': configSourcePath,
+    }),
+    replace({
+      preventAssignment: true,
+      'process.env.NODE_ENV': JSON.stringify(nodeEnv),
+    }),
+    json(),
+  ]
+  if (useNodeExternals) {
+    plugins.push(
+      nodeExternals({
+        deps: true,
+        devDeps: false,
+        peerDeps: true,
+        packagePath: path.join(process.cwd(), 'package.json'),
+      })
+    )
+  }
+  plugins.push(
+    resolveCommonJsDependencies(),
+    resolveDependencies({ preferBuiltins }),
+    babel({
+      babelHelpers: 'bundled',
+      extensions: ['.jsx', '.tsx'],
+      presets: ['@babel/preset-react'],
+    })
+  )
+  if (copyPublicFrom && fs.existsSync(copyPublicFrom)) {
+    plugins.push(
+      copy({
+        targets: [{ src: `${copyPublicFrom}/**/*`, dest: path.join(buildPath, 'public') }],
+      })
+    )
+  }
+  return plugins
 }
 
 export function discoverApiFiles(srcDir) {
@@ -103,19 +279,22 @@ export function discoverTaskFiles(srcDir) {
 }
 
 /**
- * Merges `src/api.js` (optional) and every `*.api.js` under the pages tree into one default export array
- * for the Ossy API router ({ id, path, handle }).
+ * 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, legacyPath }) {
+export function generateApiModule ({ generatedPath, apiFiles }) {
+  if (apiFiles.length === 0) {
+    return [
+      '// Generated by @ossy/app — do not edit',
+      '',
+      'export default []',
+      '',
+    ].join('\n')
+  }
   const lines = [
     '// Generated by @ossy/app — do not edit',
     '',
   ]
-  const hasLegacy = legacyPath && fs.existsSync(legacyPath)
-  if (hasLegacy) {
-    const rel = relToGeneratedImport(generatedPath, legacyPath)
-    lines.push(`import _legacyApi from './${rel}'`)
-  }
   apiFiles.forEach((f, i) => {
     const rel = relToGeneratedImport(generatedPath, f)
     lines.push(`import * as _api${i} from './${rel}'`)
@@ -130,13 +309,7 @@ export function generateApiModule ({ generatedPath, apiFiles, legacyPath }) {
     '',
     'export default [',
   )
-  const parts = []
-  if (hasLegacy) {
-    parts.push('  ..._normalizeApiExport({ default: _legacyApi }),')
-  }
-  apiFiles.forEach((_, i) => {
-    parts.push(`  ..._normalizeApiExport(_api${i}),`)
-  })
+  const parts = apiFiles.map((_, i) => `  ..._normalizeApiExport(_api${i}),`)
   lines.push(parts.join('\n'))
   lines.push(']')
   lines.push('')
@@ -144,60 +317,29 @@ export function generateApiModule ({ generatedPath, apiFiles, legacyPath }) {
 }
 
 /**
- * Resolves the Rollup entry for @ossy/api/source-file and which files to scan for the build overview.
+ * 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.
  */
-export function resolveApiSource ({ cwd, pagesOpt, scriptDir, explicitApiSource, buildPath }) {
-  const srcDir = path.resolve(cwd, pagesOpt)
-  const legacyPath = path.resolve(cwd, 'src/api.js')
-  const defaultStub = path.resolve(scriptDir, 'api.js')
-  const bp = path.resolve(buildPath ?? path.join(cwd, 'build'))
-  ensureOssyGeneratedDir(bp)
-  const generatedPath = path.join(ossyGeneratedDir(bp), OSSY_GEN_API_BASENAME)
-
-  if (explicitApiSource) {
-    const p = path.isAbsolute(explicitApiSource)
-      ? explicitApiSource
-      : path.resolve(cwd, explicitApiSource)
-    if (fs.existsSync(p)) {
-      return { apiSourcePath: p, apiOverviewFiles: [p], usedGenerated: false }
-    }
-    return { apiSourcePath: defaultStub, apiOverviewFiles: [], usedGenerated: false }
-  }
-
+export function resolveApiSource ({ srcDir, buildPath }) {
+  ensureOssyGeneratedDir(buildPath)
+  const generatedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_API_BASENAME)
   const apiFiles = discoverApiFiles(srcDir)
-  const hasLegacy = fs.existsSync(legacyPath)
-  // Always feed Rollup the same generated entry when there is any API surface,
-  // so adding/removing `*.api.js` does not require changing the replace target mid-dev.
-  if (apiFiles.length > 0 || hasLegacy) {
-    fs.writeFileSync(
-      generatedPath,
-      generateApiModule({
-        generatedPath,
-        apiFiles,
-        legacyPath: hasLegacy ? legacyPath : null,
-      })
-    )
-    const overview = [...(hasLegacy ? [legacyPath] : []), ...apiFiles]
-    return { apiSourcePath: generatedPath, apiOverviewFiles: overview, usedGenerated: true }
-  }
-
-  return { apiSourcePath: defaultStub, apiOverviewFiles: [], usedGenerated: false }
+  fs.writeFileSync(
+    generatedPath,
+    generateApiModule({ generatedPath, apiFiles })
+  )
+  return { apiSourcePath: 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.
  */
-export function generateTaskModule ({ generatedPath, taskFiles, legacyPath }) {
+export function generateTaskModule ({ generatedPath, taskFiles }) {
   const lines = [
     '// Generated by @ossy/app — do not edit',
     '',
   ]
-  const hasLegacy = legacyPath && fs.existsSync(legacyPath)
-  if (hasLegacy) {
-    const rel = relToGeneratedImport(generatedPath, legacyPath)
-    lines.push(`import _legacyTasks from './${rel}'`)
-  }
   taskFiles.forEach((f, i) => {
     const rel = relToGeneratedImport(generatedPath, f)
     lines.push(`import * as _task${i} from './${rel}'`)
@@ -213,9 +355,6 @@ export function generateTaskModule ({ generatedPath, taskFiles, legacyPath }) {
     'export default [',
   )
   const parts = []
-  if (hasLegacy) {
-    parts.push('  ..._normalizeTaskExport({ default: _legacyTasks }),')
-  }
   taskFiles.forEach((_, i) => {
     parts.push(`  ..._normalizeTaskExport(_task${i}),`)
   })
@@ -228,45 +367,28 @@ export function generateTaskModule ({ generatedPath, taskFiles, legacyPath }) {
 /**
  * Resolves the Rollup entry for @ossy/tasks/source-file and which files to list in the worker build overview.
  */
-export function resolveTaskSource ({ cwd, pagesOpt, scriptDir, explicitTaskSource, buildPath }) {
-  const srcDir = path.resolve(cwd, pagesOpt)
-  const legacyPath = path.resolve(cwd, 'src/tasks.js')
+export function resolveTaskSource ({ srcDir, scriptDir, buildPath }) {
   const defaultStub = path.resolve(scriptDir, 'tasks.js')
-  const bp = path.resolve(buildPath ?? path.join(cwd, 'build'))
-  ensureOssyGeneratedDir(bp)
-  const generatedPath = path.join(ossyGeneratedDir(bp), OSSY_GEN_TASKS_BASENAME)
-
-  if (explicitTaskSource) {
-    const p = path.isAbsolute(explicitTaskSource)
-      ? explicitTaskSource
-      : path.resolve(cwd, explicitTaskSource)
-    if (fs.existsSync(p)) {
-      return { taskSourcePath: p, taskOverviewFiles: [p], usedGenerated: false }
-    }
-    return { taskSourcePath: defaultStub, taskOverviewFiles: [], usedGenerated: false }
-  }
+  ensureOssyGeneratedDir(buildPath)
+  const generatedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_TASKS_BASENAME)
 
   const taskFiles = discoverTaskFiles(srcDir)
-  const hasLegacy = fs.existsSync(legacyPath)
-  if (taskFiles.length > 0 || hasLegacy) {
+  if (taskFiles.length > 0) {
     fs.writeFileSync(
       generatedPath,
       generateTaskModule({
         generatedPath,
         taskFiles,
-        legacyPath: hasLegacy ? legacyPath : null,
       })
     )
-    const overview = [...(hasLegacy ? [legacyPath] : []), ...taskFiles]
-    return { taskSourcePath: generatedPath, taskOverviewFiles: overview, usedGenerated: true }
+    return { taskSourcePath: generatedPath, taskOverviewFiles: taskFiles, usedGenerated: true }
   }
 
   return { taskSourcePath: defaultStub, taskOverviewFiles: [], usedGenerated: false }
 }
 
 export function discoverPageFiles(srcDir) {
-  const dir = path.resolve(srcDir)
-  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+  if (!fs.existsSync(srcDir) || !fs.statSync(srcDir).isDirectory()) {
     return []
   }
   const files = []
@@ -278,7 +400,7 @@ export function discoverPageFiles(srcDir) {
       else if (PAGE_FILE_PATTERN.test(e.name)) files.push(full)
     }
   }
-  walk(dir)
+  walk(srcDir)
   return files.sort()
 }
 
@@ -291,29 +413,105 @@ export function filePathToRoute(filePath, srcDir) {
   return { id, path: routePath }
 }
 
-/** Route base for `filePathToRoute`: site `--pages` dir, or a package’s `src` dir (first `src` segment in the path). */
-export function pageFilesRouteBaseDir (filePath, sitePagesDir) {
-  const fp = path.resolve(filePath)
-  const siteRoot = path.resolve(sitePagesDir)
-  const sitePrefix = siteRoot + path.sep
-  if (fp === siteRoot || fp.startsWith(sitePrefix)) {
-    return siteRoot
+/**
+ * Basename for `/static/hydrate-<id>.js` must match `route.id` after `metadata` is merged in `toPage`
+ * (`{ ...derived, ...metadata }`). Uses a light `metadata` scan when possible.
+ */
+export function clientHydrateIdForPage (pageAbsPath, srcDir) {
+  const derived = filePathToRoute(pageAbsPath, srcDir)
+  let src = ''
+  try {
+    src = fs.readFileSync(pageAbsPath, 'utf8')
+  } catch {
+    return derived.id
+  }
+  const metaIdx = src.indexOf('export const metadata')
+  if (metaIdx === -1) return derived.id
+  const after = src.slice(metaIdx)
+  const idMatch = after.match(/\bid\s*:\s*['"]([^'"]+)['"]/)
+  return idMatch ? idMatch[1] : derived.id
+}
+
+/**
+ * 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.
+ */
+export function generatePageHydrateModule ({ pageAbsPath, stubAbsPath, srcDir }) {
+  const rel = relToGeneratedImport(stubAbsPath, pageAbsPath)
+  const { id, path: routePath } = filePathToRoute(pageAbsPath, srcDir)
+  const pathLiteral = JSON.stringify(routePath)
+  const idLiteral = JSON.stringify(id)
+  return [
+    '// Generated by @ossy/app — do not edit',
+    '',
+    "import React, { cloneElement } from 'react'",
+    "import 'react-dom'",
+    "import { hydrateRoot } from 'react-dom/client'",
+    `import * as _page 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 || {}) }',
+    '}',
+    '',
+    `const _route = toPage(_page, { id: ${idLiteral}, path: ${pathLiteral} })`,
+    'const initialConfig = window.__INITIAL_APP_CONFIG__ || {}',
+    'const rootTree = _route?.element',
+    '  ? cloneElement(_route.element, initialConfig)',
+    "  : React.createElement('p', null, 'Not found')",
+    'hydrateRoot(document, rootTree)',
+    '',
+  ].join('\n')
+}
+
+/** Writes `hydrate-<id>.jsx` for each page; removes stale `hydrate-*` outputs in `ossyDir` first. */
+export function writePageHydrateStubs (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 (
+      ent.isFile() &&
+      ent.name.startsWith(HYDRATE_STUB_PREFIX) &&
+      ent.name.endsWith(HYDRATE_STUB_SUFFIX)
+    ) {
+      fs.rmSync(full, { force: true })
+    }
   }
-  const parts = fp.split(path.sep)
-  const srcIdx = parts.indexOf('src')
-  if (srcIdx !== -1) {
-    return parts.slice(0, srcIdx + 1).join(path.sep)
+  const seenIds = new Set()
+  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}). Per-page hydrate bundles 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 })
+    )
   }
-  return siteRoot
 }
 
-/** Derive `{ id, path }` for build overview when mixing site pages and installable `modules` package paths. */
-export function routeForPageFileOverview (filePath, sitePagesDir) {
-  return filePathToRoute(filePath, pageFilesRouteBaseDir(filePath, sitePagesDir))
+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
+  }
+  return input
 }
 
-export function generatePagesModule (pageFiles, cwd, srcDir, generatedPath) {
-  const resolvedSrc = path.resolve(cwd, srcDir)
+export function generatePagesModule (pageFiles, srcDir, generatedPath) {
   const lines = [
     "import React from 'react'",
     ...pageFiles.map((f, i) => {
@@ -332,8 +530,7 @@ export function generatePagesModule (pageFiles, cwd, srcDir, generatedPath) {
     '',
     'export default [',
     ...pageFiles.map((f, i) => {
-      const base = pageFilesRouteBaseDir(f, resolvedSrc)
-      const { id, path: defaultPath } = filePathToRoute(f, base)
+      const { id, path: defaultPath } = filePathToRoute(f, srcDir)
       const pathStr = JSON.stringify(defaultPath)
       return `  toPage(_page${i}, { id: '${id}', path: ${pathStr} }),`
     }),
@@ -342,81 +539,61 @@ export function generatePagesModule (pageFiles, cwd, srcDir, generatedPath) {
   return lines.join('\n')
 }
 
-function installableModulePackagesFromCfgObject (cfg, warn) {
-  if (Array.isArray(cfg.modules) && cfg.modules.length) {
-    return cfg.modules
-  }
-  if (Array.isArray(cfg.pagesModules) && cfg.pagesModules.length) {
-    warn?.('[@ossy/app][build] `pagesModules` is deprecated; use `modules` in src/config.js')
-    return cfg.pagesModules
-  }
-  if (typeof cfg.pagesModule === 'string') {
-    warn?.('[@ossy/app][build] `pagesModule` is deprecated; use `modules: [ ... ]` in src/config.js')
-    return [cfg.pagesModule]
-  }
-  return []
-}
-
-export async function discoverModulePageFiles({ cwd, configPath }) {
+export async function discoverModulePageFiles({ configPath }) {
   if (!configPath || !fs.existsSync(configPath)) return []
   try {
     // Try a cheap static parse first so we don't depend on the config file being
     // importable (configs often import theme/template modules that may not be
     // resolvable in the build-time node context).
     const cfgSource = fs.readFileSync(configPath, 'utf8')
-    const moduleNames = []
-    let warnedLegacy = false
-    const warnOnce = (msg) => {
-      if (!warnedLegacy) {
-        console.warn(msg)
-        warnedLegacy = true
-      }
-    }
+    const modules = []
 
-    const modulesArr = cfgSource.match(/\bmodules\s*:\s*\[([^\]]*)\]/m)
-    const pagesModulesArr = cfgSource.match(/\bpagesModules\s*:\s*\[([^\]]*)\]/m)
-    const listBody = modulesArr?.[1] ?? pagesModulesArr?.[1]
-    if (listBody !== undefined && listBody !== null) {
-      if (pagesModulesArr && !modulesArr) {
-        warnOnce('[@ossy/app][build] `pagesModules` is deprecated; use `modules` in src/config.js')
-      }
+    // pagesModules: ['a', "b"]
+    const arrMatch = cfgSource.match(/pagesModules\s*:\s*\[([^\]]*)\]/m)
+    if (arrMatch?.[1]) {
+      const body = arrMatch[1]
       const re = /['"]([^'"]+)['"]/g
       let m
-      while ((m = re.exec(listBody)) !== null) moduleNames.push(m[1])
+      while ((m = re.exec(body)) !== null) modules.push(m[1])
     }
 
-    if (moduleNames.length === 0) {
-      const singlePagesModule = cfgSource.match(/\bpagesModule\s*:\s*['"]([^'"]+)['"]/m)
-      if (singlePagesModule?.[1]) {
-        warnOnce('[@ossy/app][build] `pagesModule` is deprecated; use `modules: [ ... ]` in src/config.js')
-        moduleNames.push(singlePagesModule[1])
-      }
+    // pagesModule: 'a'
+    if (modules.length === 0) {
+      const singleMatch = cfgSource.match(/pagesModule\s*:\s*['"]([^'"]+)['"]/m)
+      if (singleMatch?.[1]) modules.push(singleMatch[1])
     }
 
-    const loadFromNames = (names) => {
-      const req = createRequire(path.resolve(cwd, 'package.json'))
+    if (modules.length) {
+      const req = createRequire(path.resolve(process.cwd(), 'package.json'))
       const files = []
-      for (const name of names) {
+      for (const name of modules) {
         const pkgJsonPath = req.resolve(`${name}/package.json`)
         const pkgDir = path.dirname(pkgJsonPath)
-        const moduleSrcDir = path.join(pkgDir, 'src')
-        files.push(...discoverPageFiles(moduleSrcDir))
+        const modulePagesDir = path.join(pkgDir, 'src', 'pages')
+        files.push(...discoverPageFiles(modulePagesDir))
       }
       return files
     }
 
-    if (moduleNames.length) {
-      return loadFromNames(moduleNames)
-    }
-
     const mod = await import(url.pathToFileURL(configPath))
     const cfg = mod?.default ?? mod ?? {}
-    const modules2 = installableModulePackagesFromCfgObject(cfg, (msg) => console.warn(msg))
+    const modules2 = Array.isArray(cfg.pagesModules)
+      ? cfg.pagesModules
+      : (typeof cfg.pagesModule === 'string' ? [cfg.pagesModule] : [])
 
     if (!modules2.length) return []
-    return loadFromNames(modules2)
+
+    const req = createRequire(path.resolve(process.cwd(), 'package.json'))
+    const files = []
+    for (const name of modules2) {
+      const pkgJsonPath = req.resolve(`${name}/package.json`)
+      const pkgDir = path.dirname(pkgJsonPath)
+      const modulePagesDir = path.join(pkgDir, 'src', 'pages')
+      files.push(...discoverPageFiles(modulePagesDir))
+    }
+    return files
   } catch (e) {
-    console.warn('[@ossy/app][build] `modules` config could not be loaded; continuing without installable module pages')
+    console.warn('[@ossy/app][build] pagesModules config could not be loaded; continuing without modules')
     return []
   }
 }
@@ -459,25 +636,19 @@ export function printBuildOverview({
   apiSourcePath,
   apiOverviewFiles = [],
   configPath,
-  isPageFiles,
   pageFiles,
 }) {
-  const rel = (p) => path.relative(process.cwd(), p)
-  const cwd = process.cwd()
-  const srcDir = path.resolve(cwd, 'src')
+  const rel = (p) => p ? path.relative(process.cwd(), p) : undefined
+  const srcDir = path.resolve(process.cwd(), 'src')
   console.log('\n  \x1b[1mBuild overview\x1b[0m')
-  console.log('  ' + '─'.repeat(50))
-  console.log(`  \x1b[36mPages:\x1b[0m ${rel(pagesSourcePath)}`)
   if (fs.existsSync(configPath)) {
     console.log(`  \x1b[36mConfig:\x1b[0m ${rel(configPath)}`)
   }
-  console.log(`  \x1b[36mAPI:\x1b[0m ${rel(apiSourcePath)}`)
   console.log('  ' + '─'.repeat(50))
 
-  const pages =
-    isPageFiles && pageFiles?.length
-      ? pageFiles.map((f) => routeForPageFileOverview(f, srcDir))
-      : parsePagesFromSource(pagesSourcePath)
+  const pages = pageFiles?.length
+    ? pageFiles.map((f) => filePathToRoute(f, srcDir))
+    : parsePagesFromSource(pagesSourcePath)
   if (pages.length > 0) {
     console.log('  \x1b[36mRoutes:\x1b[0m')
     const maxId = Math.max(6, ...pages.map((p) => String(p.id).length))
@@ -510,192 +681,58 @@ export function printBuildOverview({
   console.log('  ' + '─'.repeat(50) + '\n')
 }
 
-const WORKER_EXTERNAL_IDS = new Set([
-  ...builtinModules,
-  ...builtinModules.map((m) => `node:${m}`),
-  'dotenv',
-  'dotenv/config',
-  '@ossy/sdk',
-  'openai',
-  'sharp',
-])
-
-function isWorkerExternal(id) {
-  if (id.startsWith('.') || path.isAbsolute(id)) return false
-  if (WORKER_EXTERNAL_IDS.has(id)) return true
-  if (id.startsWith('node:')) return true
-  if (id === '@ossy/sdk' || id.startsWith('@ossy/sdk/')) return true
-  if (id === 'openai' || id.startsWith('openai/')) return true
-  if (id === 'sharp' || id.startsWith('sharp/')) return true
-  if (id === 'dotenv' || id.startsWith('dotenv/')) return true
-  return false
-}
-
-/**
- * Worker-only bundle: discovers `*.task.js` (and optional `src/tasks.js`), writes `build/.ossy/tasks.generated.js`
- * when needed, and emits `build/worker.js`. Invoke via `npx @ossy/cli build --worker`.
- */
-export async function buildWorker(cliArgs) {
-  console.log('[@ossy/app][build][worker] Starting...')
-
-  const workerArgv = cliArgs.filter((a) => a !== '--worker')
-  const options = arg(
-    {
-      '--pages': String,
-      '--p': '--pages',
-      '--destination': String,
-      '--d': '--destination',
-      '--task-source': String,
-    },
-    { argv: workerArgv }
-  )
-
-  const scriptDir = path.dirname(url.fileURLToPath(import.meta.url))
-  const cwd = process.cwd()
-  const pagesOpt = options['--pages'] || 'src'
-  const buildPath = path.resolve(options['--destination'] || 'build')
-  const { taskSourcePath, taskOverviewFiles, usedGenerated } = resolveTaskSource({
-    cwd,
-    pagesOpt,
-    scriptDir,
-    explicitTaskSource: options['--task-source'],
-    buildPath,
-  })
-
-  const workerEntryPath = path.resolve(scriptDir, 'worker-entry.js')
-  if (!fs.existsSync(workerEntryPath)) {
-    throw new Error(`[@ossy/app][build][worker] Missing worker entry: ${workerEntryPath}`)
-  }
-
-  console.log('\n  \x1b[1mWorker build\x1b[0m')
-  console.log('  ' + '─'.repeat(50))
-  console.log(`  \x1b[36mTasks module:\x1b[0m ${path.relative(cwd, taskSourcePath)}`)
-  if (taskOverviewFiles.length > 0) {
-    console.log('  \x1b[36mTask files:\x1b[0m')
-    taskOverviewFiles.forEach((f) => console.log(`    ${path.relative(cwd, f)}`))
-  } else if (!usedGenerated) {
-    console.log('  \x1b[33m(no *.task.js; using empty task list stub)\x1b[0m')
-  }
-  console.log('  ' + '─'.repeat(50) + '\n')
-
-  const bundle = await rollup({
-    input: workerEntryPath,
-    external: isWorkerExternal,
-    plugins: [
-      ossyCleanBuildDirPlugin(buildPath),
-      replace({
-        preventAssignment: true,
-        delimiters: ['%%', '%%'],
-        '@ossy/tasks/source-file': taskSourcePath,
-      }),
-      replace({
-        preventAssignment: true,
-        'process.env.NODE_ENV': JSON.stringify('production'),
-      }),
-      json(),
-      resolveCommonJsDependencies(),
-      resolveDependencies({ preferBuiltins: true }),
-      babel({
-        babelHelpers: 'bundled',
-        presets: ['@babel/preset-env', '@babel/preset-react'],
-      }),
-    ],
-  })
-
-  await bundle.write({
-    dir: buildPath,
-    entryFileNames: 'worker.js',
-    chunkFileNames: '[name]-[hash].js',
-    format: 'esm',
-  })
-
-  console.log('[@ossy/app][build][worker] Finished')
-}
-
 export const build = async (cliArgs) => {
     const options = arg({
-        '--pages': String,
-        '--p': '--pages',
-
-        '--destination': String,
-        '--d': '--destination',
-    
         '--config': String,
         '-c': '--config',
-
-        '--api-source': String,
-        '--worker': Boolean,
-        '--task-source': String,
       }, { argv: cliArgs })
 
-    if (options['--worker']) {
-      return buildWorker(cliArgs)
-    }
-
     console.log('[@ossy/app][build] Starting...')
 
 
     const scriptDir = path.dirname(url.fileURLToPath(import.meta.url))
-    const cwd = process.cwd()
-    const pagesOpt = options['--pages'] || 'src'
-    const buildPath = path.resolve(options['--destination'] || 'build')
-    ensureOssyGeneratedDir(buildPath)
-    const srcDir = path.resolve(pagesOpt)
+    const buildPath = path.resolve('build')
+    const srcDir = path.resolve('src')
     const configPath = path.resolve(options['--config'] || 'src/config.js');
     const pageFiles = discoverPageFiles(srcDir)
-    const modulePageFiles = await discoverModulePageFiles({ cwd, configPath })
-    const pagesJsxPath = path.resolve('src/pages.jsx')
-    const hasPagesJsx = fs.existsSync(pagesJsxPath)
-
-    let effectivePagesSource
-    let isPageFiles = false
-    if (pageFiles.length > 0 || modulePageFiles.length > 0) {
-      const pagesGeneratedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_PAGES_BASENAME)
-      fs.writeFileSync(
-        pagesGeneratedPath,
-        generatePagesModule([...pageFiles, ...modulePageFiles], cwd, pagesOpt, pagesGeneratedPath)
-      )
-      effectivePagesSource = pagesGeneratedPath
-      isPageFiles = true
-    } else if (hasPagesJsx) {
-      effectivePagesSource = pagesJsxPath
-    } else {
-      throw new Error(`[@ossy/app][build] No pages found. Create *.page.jsx files in src/, or src/pages.jsx`);
-    }
+    const modulePageFiles = await discoverModulePageFiles({ configPath })
+
+    resetOssyBuildDir(buildPath)
+
+    writeResourceTemplatesBarrelIfPresent({ cwd: process.cwd(), log: true })
+
+    const pagesGeneratedPath = path.join(ossyGeneratedDir(buildPath), OSSY_GEN_PAGES_BASENAME)
+
+    const allPageFiles = [...pageFiles, ...modulePageFiles]
+    fs.writeFileSync(
+      pagesGeneratedPath,
+      generatePagesModule(allPageFiles, srcDir, pagesGeneratedPath)
+    )
+    const ossyDir = ossyGeneratedDir(buildPath)
+    writePageHydrateStubs(allPageFiles, srcDir, ossyDir)
+    const clientHydrateInput = buildClientHydrateInput(allPageFiles, srcDir, ossyDir)
 
     const {
       apiSourcePath: resolvedApi,
       apiOverviewFiles,
     } = resolveApiSource({
-      cwd,
-      pagesOpt,
-      scriptDir,
-      explicitApiSource: options['--api-source'],
+      srcDir,
       buildPath,
     })
     let apiSourcePath = resolvedApi
-    let middlewareSourcePath = path.resolve(options['--middleware-source'] || 'src/middleware.js');
+    let middlewareSourcePath = path.resolve('src/middleware.js');
     const publicDir = path.resolve('public')
 
-    const inputClient = path.resolve(scriptDir, 'client.js')
     const inputServer = path.resolve(scriptDir, 'server.js')
 
-    const inputFiles = [inputClient, inputServer]
-
-    const appEntryPath = path.resolve(scriptDir, 'default-app.jsx')
     printBuildOverview({
-      pagesSourcePath: effectivePagesSource,
+      pagesSourcePath: pagesGeneratedPath,
       apiSourcePath,
       apiOverviewFiles,
       configPath,
-      isPageFiles,
-      pageFiles: isPageFiles ? [...pageFiles, ...modulePageFiles] : [],
+      pageFiles,
     });
 
-    if (!fs.existsSync(apiSourcePath)) {
-      apiSourcePath = path.resolve(scriptDir, 'api.js')
-    }
-
     if (!fs.existsSync(middlewareSourcePath)) {
       middlewareSourcePath = path.resolve(scriptDir, 'middleware.js')
     }
@@ -704,95 +741,64 @@ export const build = async (cliArgs) => {
       ? configPath
       : path.resolve(scriptDir, 'default-config.js')
 
-    const pageShellSourcePath = resolvePageShellSource(cwd, scriptDir)
-
-    const inputOptions = {
-        input: inputFiles,
-        plugins: [
-          ossyCleanBuildDirPlugin(buildPath),
-          // inject({ 'React': 'react' }),
-          replace({
-            preventAssignment: true,
-            delimiters: ['%%', '%%'],
-            '@ossy/app/source-file': appEntryPath,
-          }),
-          replace({
-            preventAssignment: true,
-            delimiters: ['%%', '%%'],
-            '@ossy/pages/source-file': effectivePagesSource,
-          }),
-          replace({
-            preventAssignment: true,
-            delimiters: ['%%', '%%'],
-            '@ossy/api/source-file': apiSourcePath,
-          }),
-          replace({
-            preventAssignment: true,
-            delimiters: ['%%', '%%'],
-            '@ossy/middleware/source-file': middlewareSourcePath,
-          }),
-          replace({
-            preventAssignment: true,
-            delimiters: ['%%', '%%'],
-            '@ossy/config/source-file': configSourcePath,
-          }),
-          replace({
-            preventAssignment: true,
-            delimiters: ['%%', '%%'],
-            '@ossy/page-shell/source-file': pageShellSourcePath,
-          }),
-          replace({
-            preventAssignment: true,
-            'process.env.NODE_ENV': JSON.stringify('production')
-          }),
-          json(),
-          // removeOwnPeerDependencies(),
-          resolveCommonJsDependencies(),
-          resolveDependencies({ preferBuiltins: true }),
-          babel({
-            babelHelpers: 'bundled',
-          //   exclude: ['**/node_modules/**/*'],
-            presets: ['@babel/preset-env', '@babel/preset-react']
-          }),
-          // preserveDirectives(),
-          minifyJS(),
-          copy({
-              targets: [
-                fs.existsSync(publicDir)
-                  ? { src: `${publicDir}/**/*`, dest: 'build/public' }
-                  : undefined,
-              ].filter(x => !!x)
-            })
-        ],
-    };
-
-    const outputOptions = [
-        {
-            dir: 'build',
-            // preserveModules: true,
-            entryFileNames: ({ name }) => {
-
-              const serverFileNames = ['server', 'api', 'middleware']
-
-              if (serverFileNames.includes(name)) {
-                return '[name].js'
-              }  else if (name === 'client') {
-                return 'public/static/main.js'
-              } else if (name === 'config') {
-                return 'public/static/[name].js'
-              } else {
-                return 'public/static/[name].js'
-              }
-            },
-            chunkFileNames: 'public/static/[name]-[hash].js',
-            format: 'esm',
-        }
-    ];
-
-    const bundle = await rollup(inputOptions);
-
-    for (const options of outputOptions) {
-        await bundle.write(options);
+    const sharedPluginOpts = {
+      pagesGeneratedPath,
+      apiSourcePath,
+      middlewareSourcePath,
+      configSourcePath,
+      nodeEnv: 'production',
+      buildPath,
+    }
+
+    const serverPlugins = createOssyRollupPlugins({
+      ...sharedPluginOpts,
+      nodeExternals: true,
+      preferBuiltins: true,
+      copyPublicFrom: publicDir,
+    })
+
+    const serverBundle = await rollup({
+      input: { server: inputServer },
+      plugins: serverPlugins,
+      external: ossyServerExternal,
+    })
+    await serverBundle.write({
+      dir: buildPath,
+      format: 'esm',
+      preserveModules: true,
+      preserveModulesRoot: path.dirname(inputServer),
+      entryFileNames ({ name }) {
+        return name === 'server' ? 'server.js' : '[name].js'
+      },
+      assetFileNames: '[name][extname]',
+    })
+    await serverBundle.close()
+
+    const clientPlugins = createOssyRollupPlugins({
+      ...sharedPluginOpts,
+      nodeExternals: false,
+      preferBuiltins: false,
+    })
+
+    if (Object.keys(clientHydrateInput).length > 0) {
+      const clientBundle = await rollup({
+        input: clientHydrateInput,
+        plugins: clientPlugins,
+      })
+      await clientBundle.write({
+        dir: buildPath,
+        format: 'esm',
+        entryFileNames ({ name }) {
+          if (name.startsWith('hydrate__')) {
+            const pageId = name.slice('hydrate__'.length)
+            return `public/static/hydrate-${pageId}.js`
+          }
+          return 'public/static/[name].js'
+        },
+        chunkFileNames: 'public/static/[name]-[hash].js',
+        plugins: [minifyBrowserStaticChunks()],
+      })
+      await clientBundle.close()
     }
 
     ensureBuildStubs(buildPath)