@ossy/app 1.15.1 → 1.16.0

package/cli/build.task.js

@@ -0,0 +1,219 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import arg from 'arg'
+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 json from '@rollup/plugin-json'
+import replace from '@rollup/plugin-replace'
+
+import getPlatformFiles, {
+  PAGE_FILE_PATTERN,
+  API_FILE_PATTERN,
+  TASK_FILE_PATTERN,
+} from './get-platform-files.task.js'
+import { manifestPlugin } from './manifest-plugin.js'
+
+export { PAGE_FILE_PATTERN, API_FILE_PATTERN, TASK_FILE_PATTERN }
+
+// Generated entry stubs live under `build/.ossy/entries/`. Putting them
+// inside `build/` means they're cleaned automatically with every build,
+// gitignored alongside other build output, and never pollute the project
+// root. The source-relative `import` paths in each stub are computed off
+// of this absolute location, so they keep working wherever it lives.
+const STUB_DIR_REL = path.join('build', '.ossy', 'entries')
+
+// Node built-ins that may appear without the `node:` prefix when CommonJS deps
+// are wrapped by `@rollup/plugin-commonjs`. We keep them external so the
+// runtime resolves the actual built-in instead of bundling a polyfill.
+const NODE_BUILTINS = new Set([
+  'assert', 'async_hooks', 'buffer', 'child_process', 'cluster', 'console',
+  'constants', 'crypto', 'dgram', 'diagnostics_channel', 'dns', 'domain',
+  'events', 'fs', 'http', 'http2', 'https', 'inspector', 'module', 'net',
+  'os', 'path', 'perf_hooks', 'process', 'punycode', 'querystring', 'readline',
+  'repl', 'stream', 'string_decoder', 'sys', 'timers', 'tls', 'trace_events',
+  'tty', 'url', 'util', 'v8', 'vm', 'wasi', 'worker_threads', 'zlib',
+])
+
+function resetDir (dir) {
+  fs.rmSync(dir, { recursive: true, force: true })
+  fs.mkdirSync(dir, { recursive: true })
+}
+
+function ensureDir (dir) {
+  fs.mkdirSync(dir, { recursive: true })
+}
+
+function stubFileNameFor (kind, sourcePath, srcDir) {
+  const rel = path.relative(srcDir, sourcePath).replace(/\\/g, '/')
+  const flat = rel.replace(/\//g, '__')
+  const ext = kind === 'page' ? '.entry.jsx' : '.entry.js'
+  return flat.replace(/\.(jsx?|tsx?|mjs|cjs)$/, '') + ext
+}
+
+function relImport (fromAbs, toAbs) {
+  let rel = path.relative(path.dirname(fromAbs), toAbs).replace(/\\/g, '/')
+  if (!rel.startsWith('.')) rel = './' + rel
+  return rel
+}
+
+function generatePageStub ({ stubAbs, sourceAbs }) {
+  const importPath = relImport(stubAbs, sourceAbs)
+  return [
+    "// Generated by @ossy/app — do not edit",
+    "import { createPageEntry } from '@ossy/app/runtime/page-runtime'",
+    `import * as page from '${importPath}'`,
+    '',
+    'const entry = createPageEntry(page, { entryUrl: import.meta.url })',
+    'export const metadata = entry.metadata',
+    'export const render = entry.render',
+    '',
+    "if (typeof window !== 'undefined') entry.hydrate()",
+    '',
+  ].join('\n')
+}
+
+function generateApiStub ({ stubAbs, sourceAbs }) {
+  const importPath = relImport(stubAbs, sourceAbs)
+  return [
+    "// Generated by @ossy/app — do not edit",
+    "import { createApiEntry } from '@ossy/app/runtime/api-runtime'",
+    `import * as api from '${importPath}'`,
+    '',
+    'const entry = createApiEntry(api)',
+    'export const metadata = entry.metadata',
+    'export const handle = entry.handle',
+    '',
+  ].join('\n')
+}
+
+function generateTaskStub ({ stubAbs, sourceAbs }) {
+  const importPath = relImport(stubAbs, sourceAbs)
+  return [
+    "// Generated by @ossy/app — do not edit",
+    "import { createTaskEntry } from '@ossy/app/runtime/task-runtime'",
+    `import * as task from '${importPath}'`,
+    '',
+    'const entry = createTaskEntry(task)',
+    'export const metadata = entry.metadata',
+    'export const run = entry.run',
+    '',
+  ].join('\n')
+}
+
+function stubFor (kind, args) {
+  if (kind === 'page') return generatePageStub(args)
+  if (kind === 'api') return generateApiStub(args)
+  return generateTaskStub(args)
+}
+
+async function loadConfig (configPath) {
+  if (!fs.existsSync(configPath)) return {}
+  const mod = await import(pathToFileURL(configPath).href + `?t=${Date.now()}`)
+  return mod.default || {}
+}
+
+export async function build (cliArgs = []) {
+  arg(
+    {
+      '--config': String,
+      '-c': '--config',
+    },
+    { argv: cliArgs },
+  )
+
+  const cwd = process.cwd()
+  const buildPath = path.resolve(cwd, 'build')
+  const publicOutDir = path.join(buildPath, 'public')
+  const staticOutDir = path.join(publicOutDir, 'static')
+  const srcDir = path.resolve(cwd, 'src')
+  // `public/` is a sibling of `src/`, not nested inside it. Keeping them
+  // separate means the build copies the public tree verbatim without
+  // accidentally treating `*.page.*` / `*.api.*` files inside it as entries.
+  const publicSrc = path.resolve(cwd, 'public')
+  const stubDir = path.resolve(cwd, STUB_DIR_REL)
+
+  // Wipe the whole build dir up front; this also takes the previous
+  // `build/.ossy/entries/` stubs with it, so stub generation is idempotent.
+  resetDir(buildPath)
+  ensureDir(stubDir)
+
+  const platformFiles = await getPlatformFiles(srcDir)
+  const allEntries = [...platformFiles.pages, ...platformFiles.apis, ...platformFiles.tasks]
+
+  const entriesByStub = new Map()
+  const stubInputMap = {}
+
+  for (const entry of allEntries) {
+    const { kind, sourcePath, metadata } = entry
+    const stubFileName = stubFileNameFor(kind, sourcePath, srcDir)
+    const stubAbs = path.join(stubDir, stubFileName)
+    fs.writeFileSync(stubAbs, stubFor(kind, { stubAbs, sourceAbs: sourcePath }), 'utf8')
+
+    const inputName = path.basename(sourcePath).replace(/\.(jsx?|tsx?|mjs|cjs)$/, '')
+    if (stubInputMap[inputName]) {
+      throw new Error(`[@ossy/app][build] Duplicate entry name "${inputName}" between ${stubInputMap[inputName]} and ${stubAbs}.`)
+    }
+    stubInputMap[inputName] = stubAbs
+    entriesByStub.set(stubAbs, { kind, sourcePath, metadata })
+  }
+
+  const configPath = path.resolve(srcDir, 'config.js')
+  const configValue = await loadConfig(configPath)
+
+  ensureDir(staticOutDir)
+
+  const bundle = await rollup({
+    input: stubInputMap,
+    // Pages execute in BOTH runtimes (Node SSR + browser hydration). We only
+    // externalize Node built-ins; everything else (React, ReactDOM, App
+    // wrapper, page deps) is bundled into per-entry chunks with shared chunks
+    // hoisted by Rollup. The platform server never imports React directly, so
+    // the dual-package hazard cannot happen — there is exactly one React in
+    // the page bundle, regardless of runtime.
+    external: (id) => id.startsWith('node:') || NODE_BUILTINS.has(id),
+    plugins: [
+      replace({
+        preventAssignment: true,
+        'process.env.NODE_ENV': '"production"',
+      }),
+      json(),
+      // Pages execute in BOTH Node (SSR) and browser (hydration). The bundle
+      // dynamically imports `react-dom/server` only on the server; we must
+      // therefore resolve packages with the Node export conditions so React
+      // gives us `renderToPipeableStream` rather than its browser-only stub.
+      resolveDependencies({
+        preferBuiltins: false,
+        exportConditions: ['node', 'module', 'import', 'default'],
+        extensions: ['.mjs', '.js', '.jsx', '.ts', '.tsx'],
+      }),
+      resolveCommonJsDependencies(),
+      babel({
+        babelHelpers: 'bundled',
+        extensions: ['.js', '.jsx', '.ts', '.tsx'],
+        presets: [['@babel/preset-react', { runtime: 'automatic' }]],
+      }),
+      manifestPlugin({
+        entriesByStub,
+        configValue,
+        manifestPath: path.join(buildPath, 'manifest.json'),
+      }),
+    ],
+  })
+
+  await bundle.write({
+    dir: staticOutDir,
+    format: 'esm',
+    entryFileNames: '[name]-[hash].js',
+    chunkFileNames: 'chunks/[name]-[hash].js',
+    sourcemap: false,
+  })
+
+  await bundle.close()
+
+  if (fs.existsSync(publicSrc)) {
+    fs.cpSync(publicSrc, publicOutDir, { recursive: true, force: true })
+  }
+}

package/cli/get-platform-files.task.js

@@ -0,0 +1,185 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { parse as babelParse } from '@babel/parser'
+
+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)$/
+
+/**
+ * @typedef {'page' | 'api' | 'task'} EntryKind
+ *
+ * @typedef {object} PlatformEntry
+ * @property {EntryKind} kind         Which bucket this entry lives in.
+ * @property {string} sourcePath      Absolute path to the user-authored source file.
+ * @property {object} metadata        Normalized metadata (always has `id`; pages always have `path`).
+ *
+ * @typedef {object} PlatformFiles
+ * @property {PlatformEntry[]} pages  Discovered `*.page.{jsx,tsx,...}` entries.
+ * @property {PlatformEntry[]} apis   Discovered `*.api.{js,mjs,cjs}` entries.
+ * @property {PlatformEntry[]} tasks  Discovered `*.task.{js,mjs,cjs}` entries.
+ */
+
+function discoverFilesByPattern (srcDir, filePattern) {
+  const dir = path.resolve(srcDir)
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return []
+  const files = []
+  const walk = (d) => {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      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
+}
+
+function classifyFile (absPath) {
+  const base = path.basename(absPath)
+  if (PAGE_FILE_PATTERN.test(base)) return 'page'
+  if (API_FILE_PATTERN.test(base)) return 'api'
+  if (TASK_FILE_PATTERN.test(base)) return 'task'
+  return null
+}
+
+function metadataIdFromFile (absPath, srcDir) {
+  const rel = path.relative(srcDir, absPath).replace(/\\/g, '/')
+  const noExt = rel
+    .replace(PAGE_FILE_PATTERN, '')
+    .replace(API_FILE_PATTERN, '')
+    .replace(TASK_FILE_PATTERN, '')
+  if (noExt === 'home' || noExt === 'index') return 'home'
+  return noExt.replace(/\//g, '-')
+}
+
+function defaultPageRoute (id) {
+  return id === 'home' ? '/' : '/' + id
+}
+
+// Parses the static `metadata` export from a source file without executing it.
+// Returns a plain JS-able shape: strings, numbers, booleans, arrays, and
+// nested objects with string keys. Arbitrary expressions (function calls,
+// references) are not supported here — pages must declare their metadata as
+// a literal object expression so the build can read it without bundling.
+function parseMetadataFromSource (absPath) {
+  const source = fs.readFileSync(absPath, 'utf8')
+  const ext = path.extname(absPath)
+  const plugins = ['importMeta']
+  if (ext === '.tsx' || ext === '.ts') plugins.push('typescript')
+  if (ext === '.jsx' || ext === '.tsx') plugins.push('jsx')
+
+  let ast
+  try {
+    ast = babelParse(source, {
+      sourceType: 'module',
+      allowImportExportEverywhere: true,
+      plugins,
+    })
+  } catch (err) {
+    throw new Error(`[@ossy/app][build] Failed to parse ${absPath}: ${err.message}`)
+  }
+
+  for (const node of ast.program.body) {
+    if (node.type !== 'ExportNamedDeclaration') continue
+    const decl = node.declaration
+    if (!decl || decl.type !== 'VariableDeclaration') continue
+    for (const declarator of decl.declarations) {
+      if (declarator.id?.type !== 'Identifier') continue
+      if (declarator.id.name !== 'metadata') continue
+      const literal = literalFromNode(declarator.init)
+      if (literal === undefined) {
+        throw new Error(`[@ossy/app][build] metadata in ${absPath} must be a literal object expression.`)
+      }
+      return literal
+    }
+  }
+  return null
+}
+
+function literalFromNode (node) {
+  if (!node) return undefined
+  switch (node.type) {
+    case 'StringLiteral':
+    case 'NumericLiteral':
+    case 'BooleanLiteral':
+      return node.value
+    case 'NullLiteral':
+      return null
+    case 'TemplateLiteral':
+      if (node.expressions.length === 0) return node.quasis.map((q) => q.value.cooked).join('')
+      return undefined
+    case 'ArrayExpression': {
+      const out = []
+      for (const el of node.elements) {
+        if (el === null) { out.push(null); continue }
+        const value = literalFromNode(el)
+        if (value === undefined) return undefined
+        out.push(value)
+      }
+      return out
+    }
+    case 'ObjectExpression': {
+      const out = {}
+      for (const prop of node.properties) {
+        if (prop.type !== 'ObjectProperty') return undefined
+        let key
+        if (prop.key.type === 'Identifier') key = prop.key.name
+        else if (prop.key.type === 'StringLiteral') key = prop.key.value
+        else return undefined
+        const value = literalFromNode(prop.value)
+        if (value === undefined) return undefined
+        out[key] = value
+      }
+      return out
+    }
+    default:
+      return undefined
+  }
+}
+
+function ensureMetadataForKind ({ kind, sourcePath, parsed, srcDir }) {
+  const fallbackId = metadataIdFromFile(sourcePath, srcDir)
+  const meta = { ...(parsed || {}) }
+  if (!meta.id) meta.id = fallbackId
+  if (kind === 'page' && meta.path === undefined) meta.path = defaultPageRoute(meta.id)
+  if (kind === 'task' && !meta.id && meta.type) meta.id = meta.type
+  return meta
+}
+
+/**
+ * Walks `srcDir` and returns the user-authored entries that the platform
+ * cares about, bucketed by kind and with their static metadata already
+ * parsed. Empty (zero-byte) source files are skipped — they're treated as
+ * placeholders the user is mid-creating.
+ *
+ * Build is the only thing that calls this today, but it's deliberately a
+ * separate task so the gather phase stays inspectable on its own (handy
+ * for tooling, dev servers, and tests that want to know "what's in src/?"
+ * without triggering Rollup).
+ *
+ * @param {string} srcDir Absolute path to the project's `src/` directory.
+ * @returns {Promise<PlatformFiles>}
+ */
+export default async function getPlatformFiles (srcDir) {
+  const out = { pages: [], apis: [], tasks: [] }
+  const all = [
+    ...discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN),
+    ...discoverFilesByPattern(srcDir, API_FILE_PATTERN),
+    ...discoverFilesByPattern(srcDir, TASK_FILE_PATTERN),
+  ]
+  for (const sourcePath of all) {
+    const stat = fs.statSync(sourcePath)
+    if (!stat.isFile() || stat.size === 0) continue
+    const kind = classifyFile(sourcePath)
+    if (!kind) continue
+    const parsed = parseMetadataFromSource(sourcePath)
+    const metadata = ensureMetadataForKind({ kind, sourcePath, parsed, srcDir })
+    out[kind === 'page' ? 'pages' : kind === 'api' ? 'apis' : 'tasks'].push({
+      kind,
+      sourcePath,
+      metadata,
+    })
+  }
+  return out
+}

package/cli/index.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { build } from './build.js'
+import { build } from './build.task.js'
+import { start } from './start.task.js'
 
 const [,, command, ...restArgs] = process.argv
 
 if (!command) {
   console.error(
-    '[@ossy/app] No command provided. Usage: app build'
+    '[@ossy/app] No command provided. Usage: app <build|start>'
   )
   process.exit(1)
 }
@@ -15,6 +16,10 @@ const run = async () => {
     await build(restArgs)
     return
   }
+  if (command === 'start') {
+    await start(restArgs)
+    return
+  }
   console.error(`[@ossy/app] Unknown command: ${command}`)
   process.exit(1)
 }

package/cli/manifest-plugin.js

@@ -0,0 +1,108 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * @typedef {import('./get-platform-files.task.js').PlatformEntry} PlatformEntry
+ *
+ * @typedef {object} ManifestPluginOptions
+ * @property {Map<string, PlatformEntry>} entriesByStub
+ *   Maps each generated stub's absolute path (Rollup's `facadeModuleId`) to
+ *   the `PlatformEntry` it was created for. The plugin uses this to recover
+ *   the entry's `kind` and parsed metadata after Rollup has bundled and
+ *   hashed each chunk.
+ * @property {object} configValue
+ *   The serializable config object (typically `src/config.js`'s default
+ *   export). Inlined under `manifest.config` so the platform server doesn't
+ *   need a runtime `import('./config.js')`.
+ * @property {string} manifestPath
+ *   Absolute path to write the manifest to (typically `build/manifest.json`).
+ *
+ * @typedef {'page' | 'api' | 'task'} ManifestEntryType
+ *
+ * @typedef {object} ManifestEntry
+ * @property {ManifestEntryType} type     Discriminator — one of `page | api | task`.
+ * @property {string} id                  Unique within `type`.
+ * @property {string | Record<string, string>} [path]
+ *                                        Required for pages and APIs; absent on tasks.
+ * @property {string} [title]             Optional; only meaningful for pages today.
+ * @property {string} entry               URL the platform serves the bundle from
+ *                                        (e.g. `/static/home.page-7f2a.js`).
+ *
+ * @typedef {object} Manifest
+ * @property {ManifestEntry[]} entries    Flat, ordered list of every routable thing.
+ * @property {object} config              Inlined `src/config.js` default export.
+ */
+
+/**
+ * Rollup plugin that emits `build/manifest.json` — the single contract the
+ * platform server, worker, and any future CMS use to discover pages, APIs,
+ * and tasks.
+ *
+ * Output shape is intentionally flat: every routable thing lives in one
+ * `entries` array, discriminated by `type`. Consumers filter as needed
+ * (`entries.filter(e => e.type === 'page')` etc.). `config` keeps its own
+ * top-level key because it isn't an entry — it's the runtime context the
+ * platform threads into every page render.
+ *
+ * The plugin runs in the `writeBundle` hook (rather than `generateBundle` +
+ * `emitFile`) for two reasons:
+ *
+ *  1. The manifest lives at `build/manifest.json`, one level above
+ *     `output.dir` (`build/public/static/`). Rollup forbids relative paths
+ *     in `emitFile({ type: 'asset', fileName })`, so we write the file
+ *     directly with `fs` once Rollup has finished writing the chunks.
+ *  2. Hashed chunk filenames are only stable in the post-write bundle
+ *     object, which is exactly what `writeBundle` is given.
+ *
+ * For each entry chunk in the bundle whose `facadeModuleId` matches a
+ * known stub (see `entriesByStub`), the plugin appends a record to
+ * `manifest.entries` and stamps `entry: '/static/<chunk-name>'`.
+ * Duplicate ids within a `type` abort the build — routers key on `id`
+ * and would otherwise silently dispatch to the wrong entry.
+ *
+ * @param {ManifestPluginOptions} options
+ * @returns {import('rollup').Plugin}
+ */
+export function manifestPlugin ({ entriesByStub, configValue, manifestPath }) {
+  return {
+    name: 'ossy-manifest',
+    writeBundle (_, bundle) {
+      /** @type {ManifestEntry[]} */
+      const entries = []
+      const seenIds = { page: new Set(), api: new Set(), task: new Set() }
+
+      for (const fileName of Object.keys(bundle)) {
+        const chunk = bundle[fileName]
+        if (chunk.type !== 'chunk' || !chunk.isEntry) continue
+        const facade = chunk.facadeModuleId
+        if (!facade) continue
+        const entryInfo = entriesByStub.get(facade)
+        if (!entryInfo) continue
+
+        const url = '/static/' + fileName
+        const meta = entryInfo.metadata
+        const id = meta.id
+        if (!id) {
+          this.error(`[@ossy/app][build] ${entryInfo.kind} entry missing metadata.id: ${entryInfo.sourcePath}`)
+        }
+        if (seenIds[entryInfo.kind].has(id)) {
+          this.error(`[@ossy/app][build] Duplicate ${entryInfo.kind} id "${id}"`)
+        }
+        seenIds[entryInfo.kind].add(id)
+
+        if (entryInfo.kind === 'page') {
+          entries.push({ type: 'page', id, path: meta.path, title: meta.title, entry: url })
+        } else if (entryInfo.kind === 'api') {
+          entries.push({ type: 'api', id, path: meta.path, entry: url })
+        } else {
+          entries.push({ type: 'task', id, entry: url })
+        }
+      }
+
+      /** @type {Manifest} */
+      const manifest = { entries, config: configValue || {} }
+      fs.mkdirSync(path.dirname(manifestPath), { recursive: true })
+      fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8')
+    },
+  }
+}

package/cli/start.task.js

@@ -0,0 +1,19 @@
+import path from 'node:path'
+import arg from 'arg'
+import { startServer } from '@ossy/platform/server'
+
+export async function start (cliArgs = []) {
+  const options = arg({
+    '--port': Number,
+    '-p': '--port',
+    '--build-dir': String,
+    '--cwd': String,
+  }, { argv: cliArgs })
+
+  const cwd = options['--cwd'] ? path.resolve(options['--cwd']) : process.cwd()
+  const buildDir = options['--build-dir'] || 'build'
+  const port = options['--port']
+
+  const { lifetime } = await startServer({ cwd, buildDir, port })
+  await lifetime
+}

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "@ossy/app",
-  "version": "1.15.1",
+  "version": "1.16.0",
   "description": "",
   "source": "./src/index.js",
   "main": "./src/index.js",
   "type": "module",
+  "exports": {
+    ".": "./src/index.js",
+    "./runtime/page-runtime": "./runtime/page-runtime.js",
+    "./runtime/api-runtime": "./runtime/api-runtime.js",
+    "./runtime/task-runtime": "./runtime/task-runtime.js"
+  },
   "bin": {
     "app": "./cli/index.js"
   },
@@ -27,15 +33,15 @@
     "@babel/eslint-parser": "^7.15.8",
     "@babel/preset-react": "^7.26.3",
     "@babel/register": "^7.25.9",
-    "@ossy/connected-components": "^1.15.1",
-    "@ossy/design-system": "^1.15.1",
-    "@ossy/pages": "^1.15.1",
-    "@ossy/platform": "^1.14.1",
-    "@ossy/router": "^1.15.1",
-    "@ossy/router-react": "^1.15.1",
-    "@ossy/sdk": "^1.15.1",
-    "@ossy/sdk-react": "^1.15.1",
-    "@ossy/themes": "^1.15.1",
+    "@ossy/connected-components": "^1.16.0",
+    "@ossy/design-system": "^1.16.0",
+    "@ossy/pages": "^1.16.0",
+    "@ossy/platform": "^1.15.0",
+    "@ossy/router": "^1.16.0",
+    "@ossy/router-react": "^1.16.0",
+    "@ossy/sdk": "^1.16.0",
+    "@ossy/sdk-react": "^1.16.0",
+    "@ossy/themes": "^1.16.0",
     "@rollup/plugin-alias": "^6.0.0",
     "@rollup/plugin-babel": "6.1.0",
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -63,10 +69,11 @@
   },
   "files": [
     "/cli",
+    "/runtime",
     "/scripts",
     "/src",
     "README.md",
     "tsconfig.json"
   ],
-  "gitHead": "6476ba57e0bdf65f55dfd6671a59c7a7ad773327"
+  "gitHead": "db2ab43d6b3266c59eb53c8046811e0acb3f87f1"
 }

package/runtime/api-runtime.js

@@ -0,0 +1,14 @@
+export function createApiEntry (apiModule) {
+  const metadata = apiModule.metadata || {}
+  const handler = apiModule.default
+  return {
+    metadata,
+    async handle (req, res) {
+      if (typeof handler !== 'function') {
+        res.status(503).type('text').send('API handler unavailable')
+        return
+      }
+      return handler(req, res)
+    },
+  }
+}

package/runtime/page-runtime.js

@@ -0,0 +1,91 @@
+import { createElement } from 'react'
+import { App } from '@ossy/connected-components'
+
+function buildTree ({ Component, metadata, props }) {
+  const lang = props.htmlLang || props.defaultLanguage || 'en'
+  return createElement(
+    'html',
+    { lang },
+    createElement(
+      'head',
+      null,
+      createElement('meta', { charSet: 'utf-8' }),
+      createElement('title', null, metadata.title || props.documentTitle || ''),
+    ),
+    createElement(App, props, createElement(Component, props)),
+  )
+}
+
+function escapeBootstrapJson (json) {
+  return json
+    .replace(/</g, '\\u003c')
+    .replace(/>/g, '\\u003e')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+}
+
+// `entryUrl` is `import.meta.url` of the bundled stub. On the server this is a
+// `file://...` URL pointing inside `build/public/static/`; we slice off the
+// public-relative segment so the browser <script type="module" src="..."> tag
+// resolves through the static asset middleware.
+function toBootstrapUrl (entryUrl) {
+  if (!entryUrl) return null
+  if (entryUrl.startsWith('file://')) {
+    const u = new URL(entryUrl)
+    const idx = u.pathname.lastIndexOf('/static/')
+    if (idx !== -1) return u.pathname.slice(idx)
+    return null
+  }
+  return entryUrl
+}
+
+export function createPageEntry (pageModule, options = {}) {
+  const Component = pageModule.default
+  const metadata = pageModule.metadata || {}
+  const entryUrl = options.entryUrl || null
+
+  async function render (props = {}) {
+    const [{ renderToPipeableStream }, { Writable }] = await Promise.all([
+      import('react-dom/server'),
+      import('node:stream'),
+    ])
+
+    const tree = buildTree({ Component, metadata, props })
+    const bootstrapUrl = toBootstrapUrl(entryUrl)
+    const bootstrapModules = bootstrapUrl ? [bootstrapUrl] : []
+    const bootstrapScriptContent =
+      'window.__OSSY__=' + escapeBootstrapJson(JSON.stringify(props ?? {}))
+
+    return new Promise((resolve, reject) => {
+      let html = ''
+      const writable = new Writable({
+        write (chunk, _enc, cb) { html += chunk.toString(); cb() },
+      })
+      // React 19's `renderToPipeableStream` emits a leading `<!DOCTYPE html>`
+      // whenever the root element is `<html>`. We keep that single source of
+      // truth instead of concatenating our own — duplicating it would emit
+      // `<!doctype html><!DOCTYPE html>...` which still parses but is ugly.
+      writable.on('finish', () => resolve(html))
+      writable.on('error', reject)
+      const stream = renderToPipeableStream(tree, {
+        bootstrapScriptContent,
+        bootstrapModules,
+        onAllReady () { stream.pipe(writable) },
+        onError (err) { reject(err) },
+      })
+    })
+  }
+
+  let hydrated = false
+  function hydrate () {
+    if (hydrated) return
+    if (typeof document === 'undefined' || typeof window === 'undefined') return
+    hydrated = true
+    const props = window.__OSSY__ || {}
+    import('react-dom/client').then(({ hydrateRoot }) => {
+      hydrateRoot(document, buildTree({ Component, metadata, props }))
+    })
+  }
+
+  return { metadata, render, hydrate }
+}

package/runtime/task-runtime.js

@@ -0,0 +1,13 @@
+export function createTaskEntry (taskModule) {
+  const metadata = taskModule.metadata || {}
+  const handler = taskModule.default
+  return {
+    metadata,
+    async run (context) {
+      if (typeof handler !== 'function') {
+        throw new Error('[@ossy/app][task] No default export to run')
+      }
+      return handler(context)
+    },
+  }
+}

package/src/index.js

@@ -1,6 +1,6 @@
 export {
   build,
-  writeResourceTemplatesBarrelIfPresent,
-  resourceTemplatesDir,
-  OSSY_RESOURCE_TEMPLATES_OUT,
-} from '../cli/build.js'
+  PAGE_FILE_PATTERN,
+  API_FILE_PATTERN,
+  TASK_FILE_PATTERN,
+} from '../cli/build.task.js'

package/cli/build.js

@@ -1,449 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import url from 'node:url'
-import { pathToFileURL } from 'node:url'
-import { createRequire } from 'node:module'
-import arg from 'arg'
-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 json from '@rollup/plugin-json'
-import replace from '@rollup/plugin-replace'
-import nodeExternals from 'rollup-plugin-node-externals'
-import { minify as minifyWithTerser } from 'terser'
-
-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$/
-
-export const OSSY_GEN_DIRNAME = '.ossy'
-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'
-export const OSSY_RESOURCE_TEMPLATES_OUT = 'resource-templates.generated.json'
-
-const HYDRATE_ENTRY_FILENAME = 'hydrate-entry.jsx'
-const SSR_ENTRY_FILENAME = 'ssr-entry.mjs'
-
-function ossyGeneratedDir (buildPath) {
-  return path.join(buildPath, OSSY_GEN_DIRNAME)
-}
-
-function ensureOssyGeneratedDir (buildPath) {
-  const dir = ossyGeneratedDir(buildPath)
-  fs.mkdirSync(dir, { recursive: true })
-  return dir
-}
-
-function resetBuildDir (buildPath) {
-  fs.rmSync(buildPath, { recursive: true, force: true })
-  ensureOssyGeneratedDir(buildPath)
-}
-
-function relToGeneratedImport (generatedAbs, targetAbs) {
-  return path.relative(path.dirname(generatedAbs), targetAbs).replace(/\\/g, '/')
-}
-
-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 buildTasksManifestPayload (taskFiles, cwd = process.cwd()) {
-  return taskFiles.map((f) => path.relative(cwd, f).replace(/\\/g, '/'))
-}
-
-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
-    let m
-    while ((m = idPathPattern.exec(content)) !== null) {
-      items.push({ id: m[1], path: m[2] })
-    }
-    return items
-  } catch {
-    return []
-  }
-}
-
-function writeJson (filePath, data) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true })
-  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8')
-}
-
-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 }
-}
-
-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
-  }
-}
-
-function createNodePlugins (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' }]],
-    }),
-  ]
-}
-
-async function bundleNodeEntry ({ inputPath, outputFile, nodeEnv }) {
-  const bundle = await rollup({
-    input: inputPath,
-    plugins: createNodePlugins(nodeEnv),
-  })
-  await bundle.write({
-    file: outputFile,
-    format: 'esm',
-    inlineDynamicImports: true,
-  })
-  await bundle.close()
-}
-
-function generateHydrateEntry ({ pageFiles, srcDir, stubAbsPath }) {
-  const seenIds = new Set()
-  const pageLines = pageFiles.map((f) => {
-    const { id } = 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)
-    return `  ${JSON.stringify(id)}: () => 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')
-}
-
-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) {',
-    '  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), {',
-    '      onAllReady () { pipe(writable) },',
-    '      onError (err) { reject(err) },',
-    '    })',
-    "    writable.on('finish', () => resolve(html))",
-    '  })',
-    '}',
-    '',
-  ].join('\n')
-}
-
-function writeAppRuntimeShims ({ middlewareSourcePath, configSourcePath, ossyDir }) {
-  writeJson(path.join(ossyDir, 'middleware.runtime.json'), {
-    modulePath: path.resolve(middlewareSourcePath),
-  })
-  writeJson(path.join(ossyDir, 'server-config.runtime.json'), {
-    modulePath: path.resolve(configSourcePath),
-  })
-}
-
-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 result = await minifyWithTerser(code, {
-        sourceMap: outputOptions.sourcemap === true || typeof outputOptions.sourcemap === 'string',
-        module: outputOptions.format === 'es' || outputOptions.format === 'esm',
-      })
-      return result.code ?? code
-    },
-  }
-}
-
-async function compileCombinedBundle ({ ssrEntryPath, clientEntryPath, buildPath, nodeEnv, copyPublicFrom }) {
-  if (copyPublicFrom && fs.existsSync(copyPublicFrom)) {
-    fs.cpSync(copyPublicFrom, path.join(buildPath, 'public'), { recursive: true, force: true })
-  }
-  const bundle = await rollup({
-    input: { server: ssrEntryPath, app: clientEntryPath },
-    plugins: createNodePlugins(nodeEnv),
-  })
-  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()
-}
-
-async function compileApiServerModules ({ apiFiles, ossyDir, nodeEnv }) {
-  const modsDir = path.join(ossyDir, 'api-modules')
-  fs.rmSync(modsDir, { recursive: true, force: true })
-  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 bundleNodeEntry({ inputPath: apiFiles[i], outputFile: outFile, nodeEnv })
-    let meta = {}
-    try {
-      const mod = await import(pathToFileURL(outFile).href)
-      meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
-    } catch {}
-    routes.push({ ...meta, module: `api-modules/${outName}` })
-  }
-  return routes
-}
-
-async function compileTaskServerModules ({ taskFiles, ossyDir, nodeEnv }) {
-  const modsDir = path.join(ossyDir, 'task-modules')
-  fs.rmSync(modsDir, { recursive: true, force: true })
-  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 bundleNodeEntry({ inputPath: taskFiles[i], outputFile: outFile, nodeEnv })
-    let meta = {}
-    try {
-      const mod = await import(pathToFileURL(outFile).href)
-      meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
-    } catch {}
-    tasks.push({ ...meta, module: `task-modules/${outName}` })
-  }
-  return tasks
-}
-
-function writeGeneratedEntries ({ pageFiles, srcDir, ossyDir }) {
-  const ssrEntryPath = path.join(ossyDir, SSR_ENTRY_FILENAME)
-  const hydrateEntryPath = path.join(ossyDir, HYDRATE_ENTRY_FILENAME)
-  fs.writeFileSync(ssrEntryPath, generateSsrEntry({ pageFiles, srcDir, stubAbsPath: ssrEntryPath }))
-  fs.writeFileSync(hydrateEntryPath, generateHydrateEntry({ pageFiles, srcDir, stubAbsPath: hydrateEntryPath }))
-  return { ssrEntryPath, hydrateEntryPath }
-}
-
-function copyPlatformRuntime ({ buildPath }) {
-  const require = createRequire(import.meta.url)
-  const platformServerPath = require.resolve('@ossy/platform/server')
-  const platformWorkerPath = require.resolve('@ossy/platform/worker')
-  const platformServerDir = path.dirname(platformServerPath)
-  const platformWorkerDir = path.dirname(platformWorkerPath)
-
-  for (const name of ['server.js', 'proxy-internal.js']) {
-    fs.copyFileSync(path.join(platformServerDir, 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'))
-}
-
-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 payload = templateFilesAbs.map((f) => relToGeneratedImport(outputAbs, f))
-  return `${JSON.stringify(payload, null, 2)}\n`
-}
-
-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 }
-}
-
-export async function build (cliArgs = []) {
-  const options = arg({
-    '--config': String,
-    '-c': '--config',
-  }, { argv: cliArgs })
-
-  const scriptDir = path.dirname(url.fileURLToPath(import.meta.url))
-  const cwd = process.cwd()
-  const buildPath = path.resolve(cwd, 'build')
-  const srcDir = path.resolve(cwd, 'src')
-  const publicDir = path.resolve(cwd, 'public')
-  const configPath = path.resolve(cwd, options['--config'] || 'src/config.js')
-
-  resetBuildDir(buildPath)
-  writeResourceTemplatesBarrelIfPresent({ cwd, log: false })
-  const ossyDir = ossyGeneratedDir(buildPath)
-
-  const pageFiles = discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN)
-  const apiFiles = discoverFilesByPattern(srcDir, API_FILE_PATTERN)
-  const taskFiles = discoverFilesByPattern(srcDir, TASK_FILE_PATTERN)
-
-  writeJson(
-    path.join(ossyDir, OSSY_GEN_PAGES_BASENAME),
-    pageFiles.map((f) => {
-      const { id, path: routePath } = pageRouteFromSource(f, srcDir)
-      return { id, path: routePath, sourceFile: path.relative(cwd, f).replace(/\\/g, '/') }
-    })
-  )
-
-  const apiRouteList = await compileApiServerModules({ apiFiles, ossyDir, nodeEnv: 'production' })
-  const taskRouteList = await compileTaskServerModules({ taskFiles, ossyDir, nodeEnv: 'production' })
-  writeJson(path.join(ossyDir, OSSY_GEN_API_BASENAME), apiRouteList)
-  writeJson(path.join(ossyDir, OSSY_GEN_TASKS_BASENAME), taskRouteList)
-
-  const middlewareSourcePath = fs.existsSync(path.resolve(cwd, 'src/middleware.js'))
-    ? path.resolve(cwd, 'src/middleware.js')
-    : path.resolve(scriptDir, 'Middleware.js')
-  const configSourcePath = fs.existsSync(configPath)
-    ? configPath
-    : path.resolve(scriptDir, 'default-config.js')
-  writeAppRuntimeShims({ middlewareSourcePath, configSourcePath, ossyDir })
-
-  const { ssrEntryPath, hydrateEntryPath } = writeGeneratedEntries({ pageFiles, srcDir, ossyDir })
-  copyPlatformRuntime({ buildPath })
-  await compileCombinedBundle({
-    ssrEntryPath,
-    clientEntryPath: hydrateEntryPath,
-    buildPath,
-    nodeEnv: 'production',
-    copyPublicFrom: publicDir,
-  })
-}