@ossy/app 1.11.6 → 1.11.8

package/README.md

@@ -21,9 +21,9 @@ export const metadata = { path: { en: '/about', sv: '/om' } }
 export default () => <h1>About</h1>
 ```
 
-During `dev` / `build`, the tooling writes **JSON manifests** under **`build/.ossy/`**: **`pages.generated.json`** (after compile: route ids, paths, `sourceFile`, merged `metadata`, and **`module`** — a `page-modules/<id>.mjs` path used for lazy `import()` in the browser and on SSR), **`pages.bundle.json`** (compiled module index), plus the same pattern for API and tasks. Small **`*.runtime.mjs`** loaders (copied from `@ossy/app`) load the app shell; **`pages.runtime.mjs`** exports the route table from **`pages.generated.json`** only. The server exposes compiled page modules at **`/__ossy/page-modules/`** for same-origin dynamic imports.
+During `dev` / `build`, the tooling writes **JSON manifests** under **`build/.ossy/`**: **`pages.generated.json`** (after compile: route ids, paths, `sourceFile`, merged `metadata`, and **`module`** — a `page-modules/<id>.mjs` path the **Node** server `import()`s per request for SSR), **`pages.bundle.json`** (compiled module index), plus the same pattern for API and tasks. **`pages.runtime.mjs`** exports the route table from **`pages.generated.json`** only.
 
-**Client JS (per-page):** For each `*.page.jsx`, the build emits **`build/.ossy/hydrate-<pageId>.jsx`** → **`public/static/<pageId>.js`**. The HTML for a request only loads the hydrate script for the **current** route (full document navigation), so other pages’ components are not part of that entry. React and shared dependencies still go into hashed shared chunks. The inline config (`window.__INITIAL_APP_CONFIG__`) no longer includes the full `pages` list—only request-time fields (theme, `apiUrl`, etc.).
+**Client JS (per-page):** For each `*.page.jsx`, the build emits **`build/.ossy/hydrate-<pageId>.jsx`** → **`public/static/<pageId>.js`**. Rollup bundles that entry with the page source so **`react` resolves in the browser** (unlike the Node `page-modules/*.mjs` chunks, which keep `react` external). The HTML only loads the hydrate script for the **current** route. The inline config (`window.__INITIAL_APP_CONFIG__`) keeps request-time fields (theme, `apiUrl`, etc.); `pages` in config include `id`, `path`, and `module` for consistency with the manifest.
 
 Add `src/config.js` for workspace and theme:
 

package/cli/build-terminal.js

@@ -1,5 +1,3 @@
-import util from 'node:util'
-
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
 
 const dim = (s) => `\x1b[2m${s}\x1b[0m`
@@ -69,15 +67,10 @@ function useTty (stream) {
   )
 }
 
-/**
- * Merged overview + per-page progress, split layout: left = status table, right = log tail.
- * TTY: single redraw block + optional console capture into the right column.
- */
 export function createBuildDashboard ({
   scope = '@ossy/app',
   mode = 'full',
   pageIds,
-  /** @type {Record<string, string>} route path per page id */
   idToPath = {},
   overview = { title: '@ossy/app', configRel: null, apiRoutes: [] },
   stream = process.stdout,
@@ -86,11 +79,7 @@ export function createBuildDashboard ({
   const maxId = Math.max(6, ...ids.map((id) => String(id).length))
   const tty = useTty(stream)
   const termW = Math.max(60, stream.columns || 100)
-  const LEFT_W = Math.min(56, Math.max(38, Math.floor(termW * 0.42)))
-  const GAP = 2
-  const RIGHT_W = Math.max(16, termW - LEFT_W - GAP)
 
-  /** @type {Map<string, { bundle: object, prerender: object }>} */
   const rows = new Map()
   for (const id of ids) {
     rows.set(id, {
@@ -99,13 +88,9 @@ export function createBuildDashboard ({
     })
   }
 
-  const logBuffer = []
-  const MAX_LOG = 120
   let frame = 0
   let spinTimer = null
   let blockLines = 0
-  let captureActive = false
-  let savedConsole = null
 
   const anyRunning = () => {
     for (const r of rows.values()) {
@@ -114,36 +99,23 @@ export function createBuildDashboard ({
     return false
   }
 
-  function pushLog (line) {
-    const s = String(line).trim() ? String(line) : ''
-    if (!s) return
-    if (!tty) {
-      stream.write(`${s}\n`)
-      return
-    }
-    logBuffer.push(dim(s))
-    if (logBuffer.length > MAX_LOG) logBuffer.splice(0, logBuffer.length - MAX_LOG)
-    redraw()
-  }
-
-  function leftHeaderLines () {
+  function headerLines () {
     const out = []
     out.push(bold(overview.title || `${scope} build`))
     if (overview.configRel) {
-      out.push(`${dim('config')}  ${truncateVisible(overview.configRel, LEFT_W - 10)}`)
+      out.push(`${dim('config')}  ${truncateVisible(overview.configRel, termW - 10)}`)
     }
     const api = overview.apiRoutes || []
-    if (api.length === 0) {
-      /* noop */
-    } else if (api.length <= 2) {
-      for (const r of api) {
-        const line = `${dim('api')}  ${truncateVisible(`${r.id}  ${r.path}`, LEFT_W - 6)}`
-        out.push(line)
+    if (api.length > 0) {
+      if (api.length <= 2) {
+        for (const r of api) {
+          out.push(`${dim('api')}  ${truncateVisible(`${r.id}  ${r.path}`, termW - 6)}`)
+        }
+      } else {
+        out.push(`${dim('api')}  ${api.length} routes`)
       }
-    } else {
-      out.push(`${dim('api')}  ${api.length} routes`)
     }
-    out.push(dim('─'.repeat(Math.min(LEFT_W - 2, 44))))
+    out.push(dim('─'.repeat(Math.min(termW - 2, 44))))
     return out
   }
 
@@ -161,46 +133,20 @@ export function createBuildDashboard ({
     return `  ${lead} ${dim(scope)}  ${idCol}  ${pathPad}  ${padVisible(b, 20)}  ${p}`
   }
 
-  function buildLeftColumnLines () {
-    const head = leftHeaderLines()
-    const body = ids.map((id) => lineForPageRow(id))
-    return [...head, ...body]
-  }
-
-  function buildHeaderOnlyLines () {
-    return leftHeaderLines()
-  }
-
-  /** Right column row i: logs bottom-aligned to the block height */
-  function rightColumnLine (i, totalRows) {
-    const start = logBuffer.length - totalRows + i
-    if (start < 0 || start >= logBuffer.length) return dim('·')
-    return truncateVisible(logBuffer[start], RIGHT_W)
-  }
-
-  function paintRow (leftLine, rightLine) {
-    const L = padVisible(truncateVisible(leftLine, LEFT_W), LEFT_W)
-    const R = truncateVisible(rightLine, RIGHT_W)
-    return `${L}${' '.repeat(GAP)}${R}\n`
+  function buildLines () {
+    return [...headerLines(), ...ids.map((id) => lineForPageRow(id))]
   }
 
   function redraw () {
     if (!tty) return
-    const leftCol = buildLeftColumnLines()
-    const n = leftCol.length
-    const lines = []
-    for (let i = 0; i < n; i++) {
-      lines.push(paintRow(leftCol[i], rightColumnLine(i, n)))
-    }
+    const lines = buildLines()
     if (blockLines === 0) {
-      for (const ln of lines) stream.write(ln)
+      for (const ln of lines) stream.write(ln + '\n')
       blockLines = lines.length
       return
     }
     stream.write(`\x1b[${blockLines}A`)
-    for (const ln of lines) {
-      stream.write(`\x1b[2K\r${ln}`)
-    }
+    for (const ln of lines) stream.write(`\x1b[2K\r${ln}\n`)
   }
 
   function ensureSpin () {
@@ -226,55 +172,13 @@ export function createBuildDashboard ({
     if (err && !ok) stream.write(`    ${red(String(err.message || err))}\n`)
   }
 
-  function beginCapture () {
-    if (!tty || captureActive) return
-    captureActive = true
-    savedConsole = {
-      log: console.log,
-      warn: console.warn,
-      info: console.info,
-      error: console.error,
-    }
-    const fmt = (...a) => util.format(...a)
-    console.log = (...a) => {
-      pushLog(`[log] ${fmt(...a)}`)
-    }
-    console.warn = (...a) => {
-      pushLog(`[warn] ${fmt(...a)}`)
-    }
-    console.info = (...a) => {
-      pushLog(`[info] ${fmt(...a)}`)
-    }
-    console.error = (...a) => {
-      const msg = fmt(...a)
-      pushLog(`[error] ${msg}`)
-      savedConsole.error(`[@ossy/app] ${msg}`)
-    }
-  }
-
-  function endCapture () {
-    if (!captureActive || !savedConsole) return
-    console.log = savedConsole.log
-    console.warn = savedConsole.warn
-    console.info = savedConsole.info
-    console.error = savedConsole.error
-    savedConsole = null
-    captureActive = false
-  }
-
   return {
-    pushLog,
-
-    /** Start optional console hijack + first paint (TTY). Plain header only when not a TTY. */
     start () {
       if (!tty) {
-        for (const ln of buildHeaderOnlyLines()) {
-          stream.write(`${ln}\n`)
-        }
+        for (const ln of headerLines()) stream.write(`${ln}\n`)
         stream.write('\n')
         return
       }
-      beginCapture()
       redraw()
     },
 
@@ -326,13 +230,8 @@ export function createBuildDashboard ({
       redraw()
     },
 
-    printSectionTitle () {
-      /* merged into overview.title — no-op for API compat */
-    },
-
     dispose () {
       stopSpin()
-      endCapture()
       if (tty && blockLines > 0) {
         redraw()
         stream.write('\n')

package/cli/build.js

@@ -69,8 +69,6 @@ export const OSSY_TASKS_RUNTIME_BASENAME = 'tasks.runtime.mjs'
 
 export const OSSY_PAGE_MODULES_DIRNAME = 'page-modules'
 
-/** Express serves compiled page modules here for browser `import()`. Must match `server.js`. */
-export const OSSY_PAGE_MODULE_WEB_PREFIX = '/__ossy/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'
@@ -89,6 +87,11 @@ export const OSSY_PAGE_SERVER_EXTERNAL = [
   'react/jsx-runtime',
 ]
 
+/** Output directory (relative to buildPath) for per-page SSR bundles. */
+export const OSSY_SSR_DIRNAME = 'ssr'
+/** Temp stub entries for SSR bundles (inside .ossy/). */
+const OSSY_SSR_ENTRIES_DIRNAME = 'ssr-entries'
+
 /** Per-page client entries: `hydrate-<pageId>.jsx` under `.ossy/` */
 const HYDRATE_STUB_PREFIX = 'hydrate-'
 const HYDRATE_STUB_SUFFIX = '.jsx'
@@ -202,7 +205,8 @@ export function createOssyAppBundlePlugins ({ nodeEnv }) {
 }
 
 /**
- * Rollup plugins for browser hydrate bundles.
+ * Rollup plugins for browser hydrate bundles. React and all deps are bundled in so the output
+ * is self-contained and requires no import maps or CDN.
  */
 export function createOssyClientRollupPlugins ({ nodeEnv, copyPublicFrom, buildPath }) {
   const plugins = [
@@ -214,7 +218,7 @@ export function createOssyClientRollupPlugins ({ nodeEnv, copyPublicFrom, buildP
     nodeExternals({
       deps: false,
       devDeps: true,
-      peerDeps: true,
+      peerDeps: false,
       packagePath: path.join(process.cwd(), 'package.json'),
     }),
     resolveCommonJsDependencies(),
@@ -235,6 +239,106 @@ export function createOssyClientRollupPlugins ({ nodeEnv, copyPublicFrom, buildP
   return plugins
 }
 
+/**
+ * Rollup plugins for per-page SSR bundles: server-side resolution, React and all deps bundled in
+ * so the output is self-contained (no node_modules needed at runtime).
+ */
+export function createOssySsrBundlePlugins ({ 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'],
+    }),
+  ]
+}
+
+/** Generates the SSR entry stub for a page: exports renderPage(props, options) and metadata. */
+export function generatePageSsrModule ({ pageAbsPath, stubAbsPath }) {
+  const rel = relToGeneratedImport(stubAbsPath, pageAbsPath)
+  return [
+    '// Generated by @ossy/app — do not edit',
+    '',
+    "import { createElement } from 'react'",
+    "import { renderToPipeableStream } from 'react-dom/server'",
+    "import { Writable } from 'node:stream'",
+    `import * as _page from './${rel}'`,
+    '',
+    'export const metadata = _page.metadata',
+    '',
+    'export function renderPage (props, options = {}) {',
+    '  return new Promise((resolve, reject) => {',
+    "    let html = ''",
+    '    const writable = new Writable({',
+    '      write (chunk, _enc, cb) { html += chunk.toString(); cb() },',
+    '    })',
+    '    const { pipe } = renderToPipeableStream(createElement(_page.default, props), {',
+    '      ...options,',
+    '      onAllReady () { pipe(writable) },',
+    '      onError (err) { reject(err) },',
+    '    })',
+    "    writable.on('finish', () => resolve(html))",
+    '  })',
+    '}',
+    '',
+  ].join('\n')
+}
+
+/** Writes `ssr-entries/<id>.mjs` stubs for each page into ossyDir. */
+export function writePageSsrStubs (pageFiles, srcDir, ossyDir) {
+  const entriesDir = path.join(ossyDir, OSSY_SSR_ENTRIES_DIRNAME)
+  fs.rmSync(entriesDir, { recursive: true, force: true })
+  if (pageFiles.length === 0) return
+  fs.mkdirSync(entriesDir, { recursive: true })
+  for (const f of pageFiles) {
+    const pageId = clientHydrateIdForPage(f, srcDir)
+    const stubPath = path.join(entriesDir, `${pageId}.mjs`)
+    fs.writeFileSync(stubPath, generatePageSsrModule({ pageAbsPath: f, stubAbsPath: stubPath }))
+  }
+}
+
+/** Compiles per-page SSR bundles to `build/ssr/<id>.mjs`. Each is self-contained with React bundled in. */
+export async function compilePageSsrModules ({ pageFiles, srcDir, ossyDir, buildPath, nodeEnv, onWarn }) {
+  const ssrDir = path.join(buildPath, OSSY_SSR_DIRNAME)
+  const entriesDir = path.join(ossyDir, OSSY_SSR_ENTRIES_DIRNAME)
+  fs.rmSync(ssrDir, { recursive: true, force: true })
+  if (pageFiles.length === 0) return []
+  fs.mkdirSync(ssrDir, { recursive: true })
+  const plugins = createOssySsrBundlePlugins({ nodeEnv })
+  const results = await Promise.all(
+    pageFiles.map(async (f) => {
+      const pageId = clientHydrateIdForPage(f, srcDir)
+      const stubPath = path.join(entriesDir, `${pageId}.mjs`)
+      const outFile = path.join(ssrDir, `${pageId}.mjs`)
+      const bundle = await rollup({
+        input: stubPath,
+        plugins,
+        onwarn (warning, defaultHandler) {
+          if (onWarn) { onWarn(warning); return }
+          defaultHandler(warning)
+        },
+      })
+      await bundle.write({ file: outFile, format: 'esm', inlineDynamicImports: true })
+      await bundle.close()
+      return { id: pageId }
+    })
+  )
+  return results
+}
+
 /** 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({
@@ -455,41 +559,42 @@ export async function compileTaskServerModules ({ taskFiles, ossyDir, nodeEnv, o
 
 /**
  * Merges compiled `metadata` + `module` into `pages.generated.json` (same order as `pageBundleList`).
- * Enables lazy `import()` in the browser and Node without putting `Component` on the route object.
+ * Writes `module` on each route for Node SSR (`import()` of `page-modules/*.mjs`); hydrate uses a separate Rollup client entry.
  */
-export async function enrichPagesGeneratedManifest ({
-  ossyDir,
-  pagesGeneratedPath,
-  pageBundleList,
-}) {
-  if (!pageBundleList?.length || !fs.existsSync(pagesGeneratedPath)) return
+/**
+ * Enriches `pages.generated.json` with `module` paths pointing to SSR bundles and merges
+ * any `metadata` exported by each page. Runs after SSR bundles are compiled.
+ */
+export async function enrichPagesGeneratedManifest ({ ossyDir, pagesGeneratedPath }) {
+  if (!fs.existsSync(pagesGeneratedPath)) return
   const raw = JSON.parse(fs.readFileSync(pagesGeneratedPath, 'utf8'))
   const basePages = raw?.pages
-  if (!Array.isArray(basePages) || basePages.length !== pageBundleList.length) {
-    throw new Error(
-      '[@ossy/app] pages.generated.json page count must match compiled page modules (re-run build).'
-    )
-  }
+  if (!Array.isArray(basePages) || basePages.length === 0) return
+
   const pages = []
-  for (let i = 0; i < basePages.length; i++) {
-    const abs = path.join(ossyDir, pageBundleList[i].module)
-    const mod = await import(pathToFileURL(abs).href)
-    const meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
-    const derived = { id: basePages[i].id, path: basePages[i].path }
+  for (const basePage of basePages) {
+    const moduleRelPath = `../ssr/${basePage.id}.mjs`
+    const bundleAbs = path.join(ossyDir, moduleRelPath)
+    let meta = {}
+    if (fs.existsSync(bundleAbs)) {
+      try {
+        const mod = await import(pathToFileURL(bundleAbs).href)
+        meta = mod?.metadata && typeof mod.metadata === 'object' ? mod.metadata : {}
+      } catch {
+        // metadata unreadable — continue with defaults
+      }
+    }
     const merged = {
-      ...derived,
+      id: basePage.id,
+      path: basePage.path,
       ...meta,
-      sourceFile: basePages[i].sourceFile,
-      module: pageBundleList[i].module,
+      sourceFile: basePage.sourceFile,
+      module: moduleRelPath,
     }
     try {
       JSON.stringify(merged)
     } catch {
-      pages.push({
-        ...derived,
-        sourceFile: basePages[i].sourceFile,
-        module: pageBundleList[i].module,
-      })
+      pages.push({ id: basePage.id, path: basePage.path, sourceFile: basePage.sourceFile, module: moduleRelPath })
       continue
     }
     pages.push(merged)
@@ -498,26 +603,23 @@ export async function enrichPagesGeneratedManifest ({
 }
 
 /**
- * Writes `pages.bundle.json`, `api.bundle.json`, `tasks.bundle.json` by Rollup-compiling each source module.
+ * Compiles server-side artifacts: per-page SSR bundles, API modules, and task modules.
  */
 export async function compileOssyNodeArtifacts ({
   pageFiles,
   srcDir,
   ossyDir,
+  buildPath,
   apiFiles,
   taskFiles,
   nodeEnv,
   onWarn,
 }) {
-  const [pageBundleList, apiModuleList, taskModuleList] = await Promise.all([
-    compilePageServerModules({ pageFiles, srcDir, ossyDir, nodeEnv, onWarn }),
+  const [, apiModuleList, taskModuleList] = await Promise.all([
+    compilePageSsrModules({ pageFiles, srcDir, ossyDir, buildPath, nodeEnv, onWarn }),
     compileApiServerModules({ apiFiles, ossyDir, nodeEnv, onWarn }),
     compileTaskServerModules({ taskFiles, ossyDir, nodeEnv, onWarn }),
   ])
-  writeOssyJson(path.join(ossyDir, OSSY_PAGES_BUNDLE_BASENAME), {
-    version: 1,
-    pages: pageBundleList,
-  })
   writeOssyJson(path.join(ossyDir, OSSY_API_BUNDLE_BASENAME), {
     version: 1,
     modules: apiModuleList,
@@ -529,7 +631,6 @@ export async function compileOssyNodeArtifacts ({
   await enrichPagesGeneratedManifest({
     ossyDir,
     pagesGeneratedPath: path.join(ossyDir, OSSY_GEN_PAGES_BASENAME),
-    pageBundleList,
   })
 }
 
@@ -561,7 +662,7 @@ export function clientHydrateIdForPage (pageAbsPath, srcDir) {
   return idMatch ? idMatch[1] : derived.id
 }
 
-/** Posix path relative to `build/.ossy/` for the compiled server/browser page module. */
+/** 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'
@@ -600,35 +701,27 @@ export function writePageServerRollupEntry ({ pageAbsPath, stubPath }) {
 }
 
 /**
- * One client entry per page: `import()` the compiled page module URL, then hydrates the document.
+ * One bundle per page: exports the component (for server SSR import) and auto-hydrates in the browser.
+ * React is kept as a bare external import — resolved from node_modules on the server and via
+ * import map on the client.
  */
 export function generatePageHydrateModule ({ pageAbsPath, stubAbsPath, srcDir }) {
-  void stubAbsPath
-  const outName = path.posix.basename(pageServerModuleRelPath(pageAbsPath, srcDir))
-  const pageImportUrl = `${OSSY_PAGE_MODULE_WEB_PREFIX}/${outName}`
-  const pageImportLiteral = JSON.stringify(pageImportUrl)
+  const rel = relToGeneratedImport(stubAbsPath, pageAbsPath)
   return [
     '// Generated by @ossy/app — do not edit',
     '',
     "import React, { createElement } from 'react'",
-    "import 'react-dom'",
     "import { hydrateRoot } from 'react-dom/client'",
+    `import * as _page from './${rel}'`,
     '',
-    'async function main () {',
-    '  const initialConfig = window.__INITIAL_APP_CONFIG__ || {}',
-    `  const _page = await import(${pageImportLiteral})`,
-    '  const Page = _page?.default',
-    '  if (typeof Page !== \'function\') {',
-    '    throw new Error(`[@ossy/app] Page must export default as a function component`)',
-    '  }',
-    '  const rootTree = createElement(Page, initialConfig)',
-    '  hydrateRoot(document, rootTree)',
-    '}',
+    'export default _page.default',
+    'export const metadata = _page.metadata',
     '',
-    'main().catch((err) => {',
-    '  console.error(err)',
-    "  document.body.innerHTML = '<p style=\\'font-family:sans-serif;padding:1rem\\'>Hydration failed.</p>'",
-    '})',
+    "if (typeof window !== 'undefined') {",
+    "  const Page = _page.default",
+    "  const config = window.__INITIAL_APP_CONFIG__ || {}",
+    "  hydrateRoot(document, createElement(Page, config))",
+    '}',
     '',
   ].join('\n')
 }
@@ -827,6 +920,7 @@ export const build = async (cliArgs) => {
       pagesGeneratedPath,
     })
     writePageHydrateStubs(pageFiles, srcDir, ossyDir)
+    writePageSsrStubs(pageFiles, srcDir, ossyDir)
     const clientHydrateInput = buildClientHydrateInput(pageFiles, srcDir, ossyDir)
 
     const { apiOverviewFiles } = resolveApiSource({
@@ -844,8 +938,6 @@ export const build = async (cliArgs) => {
       ? configPath
       : path.resolve(scriptDir, 'default-config.js')
 
-    const pagesEntryPath = path.join(ossyDir, OSSY_PAGES_RUNTIME_BASENAME)
-
     const useDashboard = Object.keys(clientHydrateInput).length > 0
     const overviewSnap = getBuildOverviewSnapshot({
       pagesSourcePath: pagesGeneratedPath,
@@ -876,11 +968,6 @@ export const build = async (cliArgs) => {
         },
       })
       dashboard.start()
-      if (resourceTemplatesResult.wrote && resourceTemplatesResult.path) {
-        dashboard.pushLog(
-          `[resource-templates] merged ${resourceTemplatesResult.count} → ${path.relative(process.cwd(), resourceTemplatesResult.path)}`
-        )
-      }
     } else {
       console.log('\n  \x1b[1m@ossy/app\x1b[0m  \x1b[2mbuild\x1b[0m')
       printBuildOverview({
@@ -889,28 +976,23 @@ export const build = async (cliArgs) => {
         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 warnSink = dashboard
-      ? (w) => {
-          dashboard.pushLog(`rollup: ${w.message}`)
-        }
-      : undefined
+    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({
       pageFiles,
       srcDir,
       ossyDir,
+      buildPath,
       apiFiles: apiOverviewFiles,
       taskFiles: taskOverviewFiles,
       nodeEnv: 'production',
-      onWarn: warnSink,
     })
 
     writeAppRuntimeShims({
@@ -929,8 +1011,6 @@ export const build = async (cliArgs) => {
           copyPublicFrom: publicDir,
           buildPath,
           nodeEnv: 'production',
-          pagesEntryPath,
-          configSourcePath,
           createClientRollupPlugins: createOssyClientRollupPlugins,
           minifyBrowserStaticChunks,
           reporter: dashboard,
@@ -940,8 +1020,5 @@ export const build = async (cliArgs) => {
       }
     }
 
-    if (useDashboard && dashboard) {
-      console.log('  \x1b[2m────────────────────────────────────────\x1b[0m')
-    }
     console.log('  \x1b[32m✔\x1b[0m \x1b[1m@ossy/app\x1b[0m  \x1b[2mbuild finished\x1b[0m\n')
 };

package/cli/index.js

@@ -1,21 +1,16 @@
 #!/usr/bin/env node
 import { build } from './build.js'
-import { dev } from './dev.js'
 
 const [,, command, ...restArgs] = process.argv
 
 if (!command) {
   console.error(
-    '[@ossy/app] No command provided. Usage: app dev | build'
+    '[@ossy/app] No command provided. Usage: app build'
   )
   process.exit(1)
 }
 
 const run = async () => {
-  if (command === 'dev') {
-    await dev(restArgs)
-    return
-  }
   if (command === 'build') {
     await build(restArgs)
     return