@ossy/app 1.15.2 → 1.16.1

package/cli/build.task.js

@@ -1,8 +1,6 @@
 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'
@@ -10,65 +8,214 @@ 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 getPlatformFiles from './getPlatformFiles.task.js'
 
-function resetBuildDir (buildPath) {
-  fs.rmSync(buildPath, { recursive: true, force: true })
-  fs.mkdirSync(buildPath, { recursive: true })
+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 })
 }
 
-export async function build (cliArgs = []) {
+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')
+}
 
-  const options = arg({
-    '--config': String,
-    '-c': '--config',
-  }, { argv: cliArgs })
+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')
-  const publicDir = path.resolve(cwd, 'public')
+  // `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)
 
-  resetBuildDir(buildPath)
-  const entries = await getPlatformFiles(srcDir)
+  // 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)
 
-  if (publicDir && fs.existsSync(publicDir)) {
-    fs.cpSync(publicDir, path.join(buildPath, 'public'), { recursive: true, force: true })
+  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 } = 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 })
   }
 
+  const configPath = path.resolve(srcDir, 'config.js')
+  const configValue = await loadConfig(configPath)
+
+  ensureDir(staticOutDir)
+
   const bundle = await rollup({
-    input: entries,
+    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(),
-      nodeExternals({
-        deps: false,
-        devDeps: true,
-        peerDeps: false,
-        packagePath: path.join(process.cwd(), 'package.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(),
-      resolveDependencies({ preferBuiltins: true }),
       babel({
         babelHelpers: 'bundled',
-        extensions: ['.jsx', '.tsx'],
+        extensions: ['.js', '.jsx', '.ts', '.tsx'],
         presets: [['@babel/preset-react', { runtime: 'automatic' }]],
       }),
+      manifestPlugin({
+        entriesByStub,
+        srcDir,
+        staticOutDir,
+        configValue,
+        manifestPath: path.join(buildPath, 'manifest.json'),
+      }),
     ],
   })
 
   await bundle.write({
-    dir: buildPath,
+    dir: staticOutDir,
     format: 'esm',
-    // entryFileNames: (chunk) => (chunk.name === 'server' ? 'ssr/app.mjs' : 'public/static/app.js'),
-    chunkFileNames: 'public/static/chunks/[name]-[hash].js',
-    plugins: [],
+    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,99 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+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.
+ *
+ * @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
+}
+
+/**
+ * Default `id` derived from a source file's location relative to `src/`.
+ * Used when a source module doesn't export `metadata.id`.
+ *   `src/home.page.jsx`            -> `home`
+ *   `src/index.page.jsx`           -> `home`
+ *   `src/blog/post.page.jsx`       -> `blog-post`
+ */
+export 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, '-')
+}
+
+/**
+ * Default URL path for a page when `metadata.path` isn't set.
+ * `home` is a special case — it lives at `/`.
+ */
+export function defaultPageRoute (id) {
+  return id === 'home' ? '/' : '/' + id
+}
+
+/**
+ * Walks `srcDir` and returns the user-authored entries the platform cares
+ * about, bucketed by kind. Empty (zero-byte) source files are skipped — we
+ * treat them as placeholders the user is mid-creating.
+ *
+ * Metadata isn't read here on purpose: the build pipeline reads it from the
+ * bundled output instead, which lets users compute `metadata.path` (and
+ * anything else) from imports, config, env vars, etc.
+ *
+ * @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
+    out[kind === 'page' ? 'pages' : kind === 'api' ? 'apis' : 'tasks'].push({
+      kind,
+      sourcePath,
+    })
+  }
+  return out
+}

package/cli/manifest-plugin.js

@@ -0,0 +1,138 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import { metadataIdFromFile, defaultPageRoute } from './get-platform-files.task.js'
+
+/**
+ * @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. Used to recover the entry's
+ *   `kind` and source location after Rollup has bundled and hashed each
+ *   chunk.
+ * @property {string} srcDir
+ *   Absolute path to the project's `src/` — used to derive fallback `id`s
+ *   from source file paths when `metadata.id` is missing.
+ * @property {string} staticOutDir
+ *   Absolute path to Rollup's `output.dir` (typically
+ *   `build/public/static/`). Bundled chunks live here, and we dynamically
+ *   `import()` them to read their exported metadata.
+ * @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.
+ *
+ * Metadata is read from the **bundled** output, not from the source file.
+ * Each entry stub re-exports `metadata` from the user's module, so once
+ * Rollup writes the chunk we can `await import(chunkUrl)` and read
+ * `mod.metadata` directly. This lets users compute metadata however they
+ * like (function calls, `Object.fromEntries`, values derived from imported
+ * config, etc.) — anything that runs at module load in Node will work.
+ *
+ * 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. We need the chunks on disk to dynamically `import()` them and read
+ *     their exported `metadata`.
+ *
+ * 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, srcDir, staticOutDir, configValue, manifestPath }) {
+  return {
+    name: 'ossy-manifest',
+    async 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 localPath = path.join(staticOutDir, fileName)
+
+        // Cache-bust the import so consecutive builds in a watch loop don't
+        // pick up a stale module from Node's loader cache.
+        const importHref = pathToFileURL(localPath).href + `?ts=${Date.now()}`
+        let mod
+        try {
+          mod = await import(importHref)
+        } catch (err) {
+          this.error(
+            `[@ossy/app][build] Failed to import bundled ${entryInfo.kind} entry ` +
+            `${entryInfo.sourcePath}: ${err && err.message ? err.message : err}`,
+          )
+        }
+
+        const rawMeta = (mod && mod.metadata) || {}
+        const id = rawMeta.id || metadataIdFromFile(entryInfo.sourcePath, srcDir)
+        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') {
+          const pagePath = rawMeta.path !== undefined ? rawMeta.path : defaultPageRoute(id)
+          entries.push({ type: 'page', id, path: pagePath, title: rawMeta.title, entry: url })
+        } else if (entryInfo.kind === 'api') {
+          entries.push({ type: 'api', id, path: rawMeta.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/package.json

@@ -1,10 +1,16 @@
 {
   "name": "@ossy/app",
-  "version": "1.15.2",
+  "version": "1.16.1",
   "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.2",
-    "@ossy/design-system": "^1.15.2",
-    "@ossy/pages": "^1.15.2",
-    "@ossy/platform": "^1.14.2",
-    "@ossy/router": "^1.15.2",
-    "@ossy/router-react": "^1.15.2",
-    "@ossy/sdk": "^1.15.2",
-    "@ossy/sdk-react": "^1.15.2",
-    "@ossy/themes": "^1.15.2",
+    "@ossy/connected-components": "^1.16.1",
+    "@ossy/design-system": "^1.16.1",
+    "@ossy/pages": "^1.16.1",
+    "@ossy/platform": "^1.15.1",
+    "@ossy/router": "^1.16.1",
+    "@ossy/router-react": "^1.16.1",
+    "@ossy/sdk": "^1.16.1",
+    "@ossy/sdk-react": "^1.16.1",
+    "@ossy/themes": "^1.16.1",
     "@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": "6a15f3ac4cafdb190beed11e4a93adc0ba28c245"
+  "gitHead": "031e2329e267a3e0cebc2ec0d484fa11b53082d9"
 }

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,
+  PAGE_FILE_PATTERN,
+  API_FILE_PATTERN,
+  TASK_FILE_PATTERN,
 } from '../cli/build.task.js'

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

@@ -1,234 +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'
-
-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\.(mjs|cjs|js)$/
-
-export const OSSY_GEN_DIRNAME = '.ossy'
-export const OSSY_GEN_ENTRIES_BASENAME = 'entries.generated.json'
-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'
-
-function resetBuildDir (buildPath) {
-  fs.rmSync(buildPath, { recursive: true, force: true })
-  const dir = path.join(buildPath, OSSY_GEN_DIRNAME)
-  fs.mkdirSync(dir, { recursive: true })
-  return dir
-}
-
-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
-}
-
-
-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 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')
-}
-
-export async function build (cliArgs = []) {
-
-  const options = arg({
-    '--config': String,
-    '-c': '--config',
-  }, { argv: cliArgs })
-
-  const cwd = process.cwd()
-  const buildPath = path.resolve(cwd, 'build')
-  const ossyDir = path.join(buildPath, OSSY_GEN_DIRNAME)
-  const srcDir = path.resolve(cwd, 'src')
-  const publicDir = path.resolve(cwd, 'public')
-  const configPath = path.resolve(cwd, options['--config'] || 'src/config.js')
-  const middlewarePath = fs.existsSync(path.resolve(cwd, 'src/middleware.js')) ? path.resolve(cwd, 'src/middleware.js') : null
-
-  resetBuildDir(buildPath)
-
-  const pageFiles = discoverFilesByPattern(srcDir, PAGE_FILE_PATTERN)
-  const apiFiles = discoverFilesByPattern(srcDir, API_FILE_PATTERN)
-  const taskFiles = discoverFilesByPattern(srcDir, TASK_FILE_PATTERN)
-  const resourceTemplatesFiles = discoverFilesByPattern(srcDir, TASK_FILE_PATTERN)
-
- const entries = [
-  ...(middlewarePath ? [middlewarePath] : []),
-  ...(configPath ? [configPath] : []),
-  ...pageFiles,
-  ...apiFiles,
-  ...taskFiles,
-  ...resourceTemplatesFiles,
- ]
-
- fs.mkdirSync(path.dirname(path.join(ossyDir, OSSY_GEN_ENTRIES_BASENAME)), { recursive: true })
- fs.writeFileSync(path.join(ossyDir, OSSY_GEN_ENTRIES_BASENAME), `${JSON.stringify(entries, null, 2)}\n`, 'utf8')
-
-
-}

package/cli/getPlatformFiles.task.js

@@ -1,51 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import url from 'node:url'
-
-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)$/
-export const RESOURCE_TEMPLATE_FILE_PATTERN = /\.resource\.(mjs|cjs|js)$/
-
-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
-}
-
-
-export default async function getPlatformFiles(_folder) {
-  const cwd = process.cwd()
-  const folder = path.resolve(cwd, _folder)
-
-  const configPath = fs.existsSync(path.resolve(folder, 'config.js')) ? path.resolve(folder, 'config.js') : null
-  const middlewarePath = fs.existsSync(path.resolve(folder, 'middleware.js')) ? path.resolve(folder, 'middleware.js') : null
-
-  const pageFiles = discoverFilesByPattern(folder, PAGE_FILE_PATTERN)
-  const apiFiles = discoverFilesByPattern(folder, API_FILE_PATTERN)
-  const taskFiles = discoverFilesByPattern(folder, TASK_FILE_PATTERN)
-  const resourceTemplatesFiles = discoverFilesByPattern(folder, TASK_FILE_PATTERN)
-
- const entries = [
-  ...(middlewarePath ? [middlewarePath] : []),
-  ...(configPath ? [configPath] : []),
-  ...pageFiles,
-  ...apiFiles,
-  ...taskFiles,
-  ...resourceTemplatesFiles,
- ]
-
- return entries
-}