@ossy/app 1.15.0 → 1.15.2

package/cli/build.js

@@ -1,972 +0,0 @@
-import path from 'path';
-import url from 'url';
-import fs from 'fs';
-import { pathToFileURL } from 'node:url'
-import { createRequire } from 'node:module'
-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 { minify as minifyWithTerser } from 'terser'
-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'
-
-export const PAGE_FILE_PATTERN = /\.page\.(jsx?|tsx?)$/
-export const API_FILE_PATTERN = /\.api\.(mjs|cjs|js)$/
-export const TASK_FILE_PATTERN = /\.task\.(mjs|cjs|js)$/
-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'
-
-export function minifyBrowserStaticChunks () {
-  return {
-    name: 'minify-browser-static-chunks',
-    async renderChunk (code, chunk, outputOptions) {
-      const fileName = chunk.fileName
-      if (!fileName || !fileName.startsWith('public/static/')) {
-        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'
-/** 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',
-]
-
-/** Output directory (relative to buildPath) for SSR bundle. */
-export const OSSY_SSR_DIRNAME = 'ssr'
-
-/** 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)
-}
-
-export function ensureOssyGeneratedDir (buildPath) {
-  const dir = ossyGeneratedDir(buildPath)
-  fs.mkdirSync(dir, { recursive: true })
-  return dir
-}
-
-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 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)))
-}
-
-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')
-}
-
-/**
- * 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 }
-}
-
-/**
- * Rollup plugins for Node-side bundles (pages / API / tasks): externals + Babel JSX.
- */
-export function createOssyAppBundlePlugins ({ nodeEnv }) {
-  return [
-    replace({
-      preventAssignment: true,
-      'process.env.NODE_ENV': JSON.stringify(nodeEnv),
-    }),
-    json(),
-    nodeExternals({
-      deps: false,
-      devDeps: true,
-      peerDeps: false,
-      packagePath: path.join(process.cwd(), 'package.json'),
-    }),
-    resolveCommonJsDependencies(),
-    resolveDependencies({ preferBuiltins: true }),
-    babel({
-      babelHelpers: 'bundled',
-      extensions: ['.jsx', '.tsx'],
-      presets: [['@babel/preset-react', { runtime: 'automatic' }]],
-    }),
-  ]
-}
-
-/**
- * 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 createCombinedBundlePlugins ({ nodeEnv }) {
-  return [
-    replace({
-      preventAssignment: true,
-      'process.env.NODE_ENV': JSON.stringify(nodeEnv),
-    }),
-    json(),
-    nodeExternals({
-      deps: false,
-      devDeps: true,
-      peerDeps: false,
-      packagePath: path.join(process.cwd(), 'package.json'),
-    }),
-    resolveCommonJsDependencies(),
-    resolveDependencies({ preferBuiltins: true }),
-    babel({
-      babelHelpers: 'bundled',
-      extensions: ['.jsx', '.tsx'],
-      presets: [['@babel/preset-react', { runtime: 'automatic' }]],
-    }),
-  ]
-}
-
-/** 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({
-    input: inputPath,
-    ...(external && external.length ? { external } : {}),
-    plugins: createOssyAppBundlePlugins({ nodeEnv }),
-    onwarn (warning, defaultHandler) {
-      if (onWarn) {
-        onWarn(warning)
-        return
-      }
-      defaultHandler(warning)
-    },
-  })
-  await bundle.write({
-    file: outputFile,
-    format: 'esm',
-    inlineDynamicImports: true,
-  })
-  await bundle.close()
-}
-
-/**
- * Re-exports middleware and app config via `file:` URLs so `src/*.js` can keep relative imports.
- */
-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`
-  )
-}
-
-/**
- * Copies framework runtime into `build/`: server, worker entry, proxy.
- * Middleware loads via `./.ossy/middleware.runtime.js`.
- */
-export function copyOssyAppRuntime ({ scriptDir, buildPath }) {
-  const require = createRequire(import.meta.url)
-  const platformServerPath = require.resolve('@ossy/platform/server')
-  const platformWorkerPath = require.resolve('@ossy/platform/worker')
-  const platformDir = path.dirname(platformServerPath)
-  const platformWorkerDir = path.dirname(platformWorkerPath)
-  for (const name of ['server.js', 'proxy-internal.js']) {
-    fs.copyFileSync(path.join(platformDir, name), path.join(buildPath, name))
-  }
-  const taskRuntimeFiles = fs
-    .readdirSync(scriptDir, { withFileTypes: true })
-    .filter((ent) => ent.isFile() && ent.name.endsWith('.task.js'))
-    .map((ent) => ent.name)
-  for (const name of taskRuntimeFiles) {
-    fs.copyFileSync(path.join(scriptDir, name), path.join(buildPath, name))
-  }
-  fs.copyFileSync(path.join(platformWorkerDir, 'worker-entry.js'), path.join(buildPath, 'worker.js'))
-  fs.copyFileSync(path.join(platformWorkerDir, 'worker-runtime.js'), path.join(buildPath, 'worker-runtime.js'))
-  const ossyOut = ossyGeneratedDir(buildPath)
-  fs.copyFileSync(
-    path.join(scriptDir, OSSY_RENDER_PAGE_RUNTIME_BASENAME),
-    path.join(ossyOut, OSSY_RENDER_PAGE_RUNTIME_BASENAME)
-  )
-}
-
-/**
- * Recursively lists files under `srcDir` whose basename matches `filePattern` (e.g. `/\.api\.js$/`).
- */
-export function discoverFilesByPattern (srcDir, filePattern) {
-  const dir = path.resolve(srcDir)
-  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
-    return []
-  }
-  const files = []
-  const walk = (d) => {
-    const entries = fs.readdirSync(d, { withFileTypes: true })
-    for (const e of entries) {
-      const full = path.join(d, e.name)
-      if (e.isDirectory()) walk(full)
-      else if (filePattern.test(e.name)) files.push(full)
-    }
-  }
-  walk(dir)
-  return files.sort()
-}
-
-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 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 taskFiles.map((f) => path.relative(cwd, f).replace(/\\/g, '/'))
-}
-
-/**
- * Writes `build/.ossy/api.generated.json` (sources only).
- * Compiled modules + `api.bundle.json` are produced by {@link compileOssyNodeArtifacts}.
- */
-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)
-  writeOssyJson(generatedPath, buildApiManifestPayload(apiFiles, cwd))
-  return { apiGeneratedPath: generatedPath, apiOverviewFiles: apiFiles }
-}
-
-/**
- * Writes `build/.ossy/tasks.generated.json` (sources only).
- */
-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)
-  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 relPath = pageServerModuleRelPath(f, srcDir)
-    const outName = path.posix.basename(relPath)
-    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,
-    })
-    bundlePages.push({
-      id: pageId,
-      module: relPath,
-    })
-  }
-  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 routes = []
-  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,
-    })
-    let meta = {}
-    try {
-      const mod = await import(pathToFileURL(outFile).href)
-      meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
-    } catch {
-      // metadata unreadable — skip
-    }
-    routes.push({ ...meta, module: `${OSSY_API_MODULES_DIRNAME}/${outName}` })
-  }
-  return routes
-}
-
-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 tasks = []
-  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,
-    })
-    let meta = {}
-    try {
-      const mod = await import(pathToFileURL(outFile).href)
-      meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
-    } catch {
-      // metadata unreadable — skip
-    }
-    tasks.push({ ...meta, module: `${OSSY_TASK_MODULES_DIRNAME}/${outName}` })
-  }
-  return tasks
-}
-
-/**
- * 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 ({
-  apiFiles,
-  taskFiles,
-  ossyDir,
-  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)
-}
-
-export function filePathToRoute(filePath, srcDir) {
-  const rel = path.relative(srcDir, filePath).replace(/\\/g, '/')
-  let pathPart = rel.replace(PAGE_FILE_PATTERN, '').replace(/\/index$/, '').replace(/\/home$/, '') || 'home'
-  if (pathPart === 'index' || pathPart === 'home') pathPart = 'home'
-  const id = pathPart === 'home' ? 'home' : pathPart.replace(/\//g, '-')
-  const routePath = pathPart === 'home' ? '/' : '/' + pathPart
-  return { id, path: routePath }
-}
-
-/**
- * Basename for `/static/<id>.js` (per-page client bundle) 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
-}
-
-/**
- * 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]
-    if (strPath) {
-      return { id, path: strPath }
-    }
-    const pathObjBody = after.match(/\bpath\s*:\s*\{([\s\S]*?)\}/)?.[1]
-    if (pathObjBody) {
-      const languagePathEntries = [...pathObjBody.matchAll(/([A-Za-z0-9_]+)\s*:\s*['"]([^'"]+)['"]/g)]
-      if (languagePathEntries.length > 0) {
-        return {
-          id,
-          path: Object.fromEntries(languagePathEntries.map(([, language, routePath]) => [language, routePath])),
-        }
-      }
-    }
-    return { id, path: 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)
-  const safeId = String(pageId).replace(/[^a-zA-Z0-9_-]+/g, '-') || 'page'
-  return `${OSSY_PAGE_MODULES_DIRNAME}/${safeId}.mjs`
-}
-
-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'
-  )
-}
-
-/**
- * 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 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(`  ${JSON.stringify(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'",
-    '',
-    'const config = window.__INITIAL_APP_CONFIG__ || {}',
-    '',
-    'const pages = {',
-    ...pageLines,
-    '}',
-    '',
-    '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))',
-    '  })',
-    '}',
-    '',
-  ].join('\n')
-}
-
-/** 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 })) {
-    if (
-      ent.isFile() &&
-      ent.name.startsWith('hydrate-') &&
-      ent.name.endsWith('.jsx') &&
-      ent.name !== HYDRATE_ENTRY_FILENAME
-    ) {
-      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 { id, path: routePath } = pageRouteFromSource(f, srcDir)
-    if (seenIds.has(id)) {
-      throw new Error(
-        `[@ossy/app] Duplicate page id "${id}" (${f}). Pages need unique ids.`
-      )
-    }
-    seenIds.add(id)
-    const rel = relToGeneratedImport(stubAbsPath, f)
-    pagesLiteral.push(`  { id: ${JSON.stringify(id)}, path: ${JSON.stringify(routePath)} },`)
-    pageModuleLines.push(`  ${JSON.stringify(id)}: () => import('./${rel}'),`)
-  }
-
-  return [
-    '// Generated by @ossy/app — do not edit',
-    '',
-    "import { createElement } from 'react'",
-    "import { renderToPipeableStream } from 'react-dom/server'",
-    "import { Writable } from 'node:stream'",
-    "import { App } from '@ossy/connected-components'",
-    '',
-    'export const pages = [',
-    ...pagesLiteral,
-    ']',
-    '',
-    'const pageModules = {',
-    ...pageModuleLines,
-    '}',
-    '',
-    'function PageShell (props) {',
-    "  const meta = props._pageMeta || {}",
-    "  return createElement('html', { lang: props.defaultLanguage || 'en' },",
-    "    createElement('head', null,",
-    "      createElement('meta', { charSet: 'utf-8' }),",
-    "      createElement('title', null, meta.title || ''),",
-    '    ),',
-    '    createElement(App, props,',
-    '      createElement(props._pageComponent, props)',
-    '    )',
-    '  )',
-    '}',
-    '',
-    'export async function renderPage (pageId, props, options = {}) {',
-    '  const load = pageModules[pageId]',
-    "  if (!load) throw new Error(`[@ossy/app] Unknown page id: ${pageId}`)",
-    '  const mod = await load()',
-    '  const merged = { ...props, _pageComponent: mod.default, _pageMeta: mod.metadata || {} }',
-    '  return new Promise((resolve, reject) => {',
-    "    let html = ''",
-    '    const writable = new Writable({',
-    '      write (chunk, _enc, cb) { html += chunk.toString(); cb() },',
-    '    })',
-    '    const { pipe } = renderToPipeableStream(createElement(PageShell, merged), {',
-    '      ...options,',
-    '      onAllReady () { pipe(writable) },',
-    '      onError (err) { reject(err) },',
-    '    })',
-    "    writable.on('finish', () => resolve(html))",
-    '  })',
-    '}',
-    '',
-  ].join('\n')
-}
-
-/** Writes `ssr-entry.mjs` into ossyDir; removes any stale per-page SSR stubs first. */
-export function writeSsrEntry (pageFiles, srcDir, ossyDir) {
-  if (!fs.existsSync(ossyDir)) fs.mkdirSync(ossyDir, { recursive: true })
-  const stubPath = path.join(ossyDir, SSR_ENTRY_FILENAME)
-  fs.writeFileSync(stubPath, generateSsrEntry({ pageFiles, srcDir, stubAbsPath: stubPath }))
-  return stubPath
-}
-
-/**
- * Runs a single Rollup pass with both the SSR entry and the client hydrate entry as inputs.
- * Produces:
- *   build/ssr/app.mjs          — Node SSR bundle
- *   build/public/static/app.js — browser hydrate bundle
- *   build/public/static/chunks/[name]-[hash].js — shared chunks
- *
- * The SSR bundle imports shared chunks via relative paths (`../public/static/chunks/…`);
- * the browser loads the same physical files from `/static/chunks/`.
- */
-export async function compileCombinedBundle ({ ssrEntryPath, clientEntryPath, buildPath, nodeEnv, copyPublicFrom, onWarn }) {
-  if (copyPublicFrom && fs.existsSync(copyPublicFrom)) {
-    const destPublic = path.join(buildPath, 'public')
-    fs.mkdirSync(destPublic, { recursive: true })
-    const copyDir = (src, dest) => {
-      fs.mkdirSync(dest, { recursive: true })
-      for (const ent of fs.readdirSync(src, { withFileTypes: true })) {
-        const srcPath = path.join(src, ent.name)
-        const destPath = path.join(dest, ent.name)
-        if (ent.isDirectory()) copyDir(srcPath, destPath)
-        else fs.copyFileSync(srcPath, destPath)
-      }
-    }
-    copyDir(copyPublicFrom, destPublic)
-  }
-
-  const bundle = await rollup({
-    input: { server: ssrEntryPath, app: clientEntryPath },
-    plugins: createCombinedBundlePlugins({ nodeEnv }),
-    onwarn (warning, defaultHandler) {
-      if (onWarn) { onWarn(warning); return }
-      defaultHandler(warning)
-    },
-  })
-  await bundle.write({
-    dir: buildPath,
-    format: 'esm',
-    entryFileNames: (chunk) =>
-      chunk.name === 'server'
-        ? 'ssr/app.mjs'
-        : 'public/static/app.js',
-    chunkFileNames: 'public/static/chunks/[name]-[hash].js',
-    plugins: [minifyBrowserStaticChunks()],
-  })
-  await bundle.close()
-}
-
-/** JSON manifest: route ids, default paths, and page source paths (posix, relative to `cwd`). */
-export function buildPagesGeneratedPayload (pageFiles, srcDir, cwd = process.cwd()) {
-  const pages = pageFiles.map((f) => {
-    const { id, path: routePath } = pageRouteFromSource(f, srcDir)
-    return {
-      id,
-      path: routePath,
-      sourceFile: path.relative(cwd, f).replace(/\\/g, '/'),
-    }
-  })
-  return pages
-}
-
-export function writePagesManifest ({
-  pageFiles,
-  srcDir,
-  pagesGeneratedPath,
-  cwd = process.cwd(),
-}) {
-  writeOssyJson(pagesGeneratedPath, buildPagesGeneratedPayload(pageFiles, srcDir, cwd))
-}
-
-export function parsePagesFromManifestJson (manifestPath) {
-  try {
-    const data = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
-    if (!Array.isArray(data)) return []
-    return data.map((p) => ({
-      id: p.id,
-      path: p.path,
-      ...(typeof p.module === 'string' ? { module: p.module } : {}),
-    }))
-  } catch {
-    return []
-  }
-}
-
-/**
- * Best-effort scan of a source file for `{ id, path }` literals (e.g. `*.api.js` default export).
- * Used only for the build dashboard API list — **not** for page discovery (`*.page.jsx` only).
- */
-export function parseIdPathPairsFromFile (filePath) {
-  try {
-    const content = fs.readFileSync(filePath, 'utf8')
-    const items = []
-    const idPathPattern = /\{\s*id\s*:\s*['"]([^'"]*)['"]\s*,\s*path\s*:\s*['"]([^'"]*)['"]/g
-    const pathObjPattern = /\{\s*path\s*:\s*\{\s*([^}]+)\}/g
-    let m
-    while ((m = idPathPattern.exec(content)) !== null) {
-      items.push({ id: m[1], path: m[2] })
-    }
-    if (items.length === 0) {
-      while ((m = pathObjPattern.exec(content)) !== null) {
-        const pathStr = m[1].replace(/\s/g, '').replace(/:/g, ': ')
-        items.push({ id: 'page', path: pathStr })
-      }
-    }
-    return items
-  } catch {
-    return []
-  }
-}
-
-/**
- * Same facts as the old build overview printout, for dashboards / plain logging.
- */
-export function getBuildOverviewSnapshot ({
-  pagesSourcePath,
-  apiOverviewFiles = [],
-  configPath,
-  pageFiles,
-}) {
-  const rel = (p) => (p ? path.relative(process.cwd(), p) : undefined)
-  const srcDir = path.resolve(process.cwd(), 'src')
-  const configRel = fs.existsSync(configPath) ? rel(configPath) : null
-
-  const pages = pageFiles?.length
-    ? 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 apiOverviewFiles) {
-    if (fs.existsSync(f)) apiRoutes.push(...parseIdPathPairsFromFile(f))
-  }
-
-  return { configRel, pages, apiRoutes }
-}
-
-export function printBuildOverview (opts) {
-  const { configRel, pages, apiRoutes } = getBuildOverviewSnapshot(opts)
-  console.log('\n  \x1b[1mBuild overview\x1b[0m')
-  if (configRel) {
-    console.log(`  \x1b[36mConfig:\x1b[0m ${configRel}`)
-  }
-  console.log('  ' + '─'.repeat(50))
-
-  if (pages.length > 0) {
-    console.log('  \x1b[36mRoutes:\x1b[0m')
-    const maxId = Math.max(6, ...pages.map((p) => String(p.id).length))
-    const maxPath = Math.max(6, ...pages.map((p) => String(p.path).length))
-    pages.forEach((p) => {
-      const id = String(p.id).padEnd(maxId)
-      const pathStr = String(p.path).padEnd(maxPath)
-      console.log(`    ${id}  ${pathStr}`)
-    })
-  } else {
-    console.log('  \x1b[33mRoutes:\x1b[0m (could not parse or empty)')
-  }
-
-  if (apiRoutes.length > 0) {
-    console.log('  \x1b[36mAPI routes:\x1b[0m')
-    apiRoutes.forEach((r) => {
-      console.log(`    ${r.id}  ${r.path}`)
-    })
-  }
-  console.log('  ' + '─'.repeat(50) + '\n')
-}
-
-export const build = async (cliArgs) => {
-    const options = arg({
-        '--config': String,
-        '-c': '--config',
-      }, { argv: 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 pageFiles = discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN)
-    const publicDir = path.resolve('public')
-
-    resetOssyBuildDir(buildPath)
-
-    const resourceTemplatesResult = writeResourceTemplatesBarrelIfPresent({
-      cwd: process.cwd(),
-      log: false,
-    })
-
-    const ossyDir = ossyGeneratedDir(buildPath)
-    const pagesGeneratedPath = path.join(ossyDir, OSSY_GEN_PAGES_BASENAME)
-
-    writePagesManifest({
-      pageFiles,
-      srcDir,
-      pagesGeneratedPath,
-    })
-
-    // 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')
-    }
-
-    const configSourcePath = fs.existsSync(configPath)
-      ? configPath
-      : path.resolve(scriptDir, 'default-config.js')
-
-    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(
-        `[@ossy/app][resource-templates] merged ${resourceTemplatesResult.count} template(s) → ${path.relative(process.cwd(), resourceTemplatesResult.path)}`
-      )
-    }
-
-    const { taskOverviewFiles } = resolveTaskSource({ srcDir, buildPath })
-    await compileOssyNodeArtifacts({
-      apiFiles: apiOverviewFiles,
-      taskFiles: taskOverviewFiles,
-      ossyDir,
-      nodeEnv: 'production',
-    })
-
-    writeAppRuntimeShims({
-      middlewareSourcePath,
-      configSourcePath,
-      ossyDir,
-    })
-    copyOssyAppRuntime({ scriptDir, buildPath })
-
-    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')
-};