@brust/core 2.0.0-alpha.3 → 2.0.0-alpha.30

package/src/build/manifest.ts

@@ -6,6 +6,7 @@
 import type { FlatRoute } from '../routes'
 import type { Compiled, ComponentIR } from './compile'
 import { BuildError } from './errors'
+import { featuresOf } from './features'
 
 export interface JobCache {
   key: string | null
@@ -29,6 +30,12 @@ export interface ChildRecord {
   id: string
   instances: string
   props: Record<string, string>
+  /** F105: constant props; part of the child's job keys. */
+  literals?: Record<string, unknown>
+  /** F105: jinja over `__props` (and `__row`/`__idx` per row) the server evaluates. */
+  exprs?: Record<string, string>
+  /** F142 R34.43: the list of a `per-row-literal` instance (a constant the compiler read). */
+  rows?: unknown[]
 }
 
 export interface ComponentRecord {
@@ -40,6 +47,8 @@ export interface ComponentRecord {
   needs_worker: boolean
   use_id_slots: number
   stores: string[]
+  /** L33: the client runtime feature modules (`assets.features` keys) this component's output needs, in load order. */
+  features: string[]
 }
 
 export interface RouteRecord {
@@ -49,6 +58,8 @@ export interface RouteRecord {
   loaders: string[]
   cache: { ttl_seconds: number; prefix: string | null; bypass: true | string | null; tags: string[] } | null
   catch_all: boolean
+  /** L19 (R19.3): `client/<file>.css` in cascade order; absent when the route has none. */
+  css?: string[]
 }
 
 /** `manifest.actions` (A3): `entry` is relative to dist; `maxBodyBytes`/`maxResponseBytes` are camelCase by contract. */
@@ -60,15 +71,71 @@ export interface ActionsRecord {
   crossSite: 'reject' | 'allow'
 }
 
+/** The manifest format the Rust loader accepts (`MANIFEST_VERSION` in brust-core `manifest.rs`): the one place TS names it. */
+export const MANIFEST_VERSION = 3 as const
+
 export interface ManifestJson {
-  version: 1
+  version: typeof MANIFEST_VERSION
   routes: RouteRecord[]
   components: Record<string, ComponentRecord>
-  assets: { runtime: string }
+  /** `runtime` is the core; `features` maps each feature module name to its file (L33). */
+  assets: {
+    runtime: string
+    features: Record<string, string>
+    /** F453: the SPA-navigation module `client/nav-<hex>.js`; the `nav` tag is emitted only when it is set. */
+    nav?: string
+    /** F453: the build id (`data-brust-build`): a digest of the rest of the manifest, set last by `brust build`. */
+    build?: string
+  }
   jobs_module: string
   actions: ActionsRecord | null
+  /** L16 R16.3: an actions-only build (no routes, no templates); everything but the prefix is a 404 problem+json. */
+  actions_only?: true
+  /** L16 R16.4b: a page-only build: no local actions app, `base_url` points at the deployment that has it. */
+  actions_remote?: { prefix: string }
   /** `[cache]` (cache adapters); absent without one (the manifest is then byte-identical). */
   cache?: CacheRecord
+  /** F165 (R40.1): `brust start` spawns its worker pool (`needsWorkers`). Read by `run.ts` only; an
+   * absent value (an older or actions-only manifest) means the pool is needed. */
+  needs_workers?: boolean
+}
+
+/** F165 (R40.1): whether any request can call a worker. Workers answer four kinds of call
+ * (worker.ts): `loader`, `jobs` (precompute and SSR), `fetch` (the local actions app) and `cache`
+ * (the adapter). Only the jobs a request can plan count (`reachedJobs`, F183); a store read counts too (`readsStores`). */
+export function needsWorkers(m: Pick<ManifestJson, 'routes' | 'components' | 'actions' | 'cache'>): boolean {
+  const planned = [...reachedJobs(m).planned].some((id) => (m.components[id]?.jobs.length ?? 0) > 0)
+  return planned || m.routes.some((r) => r.loaders.length > 0) || readsStores(m) || m.actions !== null || m.cache !== undefined
+}
+
+/** A route whose chain reads a store (its components, their children and job targets, transitively) gets a loader call
+ * from brust-core even with no loader of its own: the worker builds the `__store` snapshot (pipeline.rs `reads_store`).
+ * Without a pool that call answers 503. */
+function readsStores(m: Pick<ManifestJson, 'routes' | 'components'>): boolean {
+  const seen = new Set<string>()
+  const reads = (id: string): boolean => {
+    if (seen.has(id)) return false
+    seen.add(id)
+    const c = m.components[id]
+    return !!c && (c.stores.length > 0 || c.children.some((k) => reads(k.id)) || c.jobs.some((j) => j.target !== undefined && reads(j.target)))
+  }
+  return m.routes.some((r) => r.chain.some(reads))
+}
+
+/** F183: the jobs a request can call, as brust-core plans them (`collect_jobs`, pipeline.rs): every job of each
+ * route chain component and of each of its direct `children[]` records (`planned`; nothing deeper has a job,
+ * `linkNativeChunks`), and the `ssr` of each component one of those jobs targets (`ssr`; the worker runs the
+ * target's, handlers.ts). `jobs.js` leaves out every other entry: no request reaches it. */
+export function reachedJobs(m: Pick<ManifestJson, 'routes' | 'components'>): { planned: Set<string>; ssr: Set<string> } {
+  const planned = new Set<string>()
+  for (const r of m.routes)
+    for (const id of r.chain) {
+      planned.add(id)
+      for (const ch of m.components[id]?.children ?? []) planned.add(ch.id)
+    }
+  const ssr = new Set<string>()
+  for (const id of planned) for (const j of m.components[id]?.jobs ?? []) if (j.kind === 'ssr' && j.target !== undefined) ssr.add(j.target)
+  return { planned, ssr }
 }
 
 /** `manifest.cache` / `CONFIG.cache`: the adapter the runtime loads (`cache-adapter/load.ts`). */
@@ -226,15 +293,23 @@ export function childRecords(c: Compiled, clientOnly: string[] = []): ChildRecor
     if (inst.loops.length > 1)
       throw new BuildError('nested-instance', `${ir.id}: child ${inst.child_id} sits in nested lists (M3)`)
     const list = inst.loops[0]
-    if (list === null)
+    const literal = list === null && Array.isArray(inst.rows_literal)
+    if (list === null && !literal)
       throw new BuildError('instance-list-path', `${ir.id}: child ${inst.child_id} sits in a list that is not a props path`)
     const props: Record<string, string> = {}
     for (const [name, path] of Object.entries(inst.props)) {
       if (path === null)
-        throw new BuildError('instance-prop-path', `${ir.id}: child ${inst.child_id} prop ${name} is not a props path`)
+        throw new BuildError(
+          'instance-prop-path',
+          `${ir.id}: child ${inst.child_id} prop ${name} is not a props path, a JSON literal or a template expression over props; compute it in a loader, or wrap the child's derived value in cache()`,
+        )
       props[name] = path
     }
-    return { id: inst.child_id, instances: list === undefined ? 'static' : `per-row:${list}`, props }
+    const rec: ChildRecord = { id: inst.child_id, instances: literal ? 'per-row-literal' : list === undefined ? 'static' : `per-row:${list}`, props }
+    if (inst.literals && Object.keys(inst.literals).length > 0) rec.literals = { ...inst.literals }
+    if (inst.exprs && Object.keys(inst.exprs).length > 0) rec.exprs = { ...inst.exprs }
+    if (literal) rec.rows = inst.rows_literal
+    return rec
   })
   for (const id of clientOnly) out.push({ id, instances: 'static', props: {} })
   return out
@@ -261,7 +336,8 @@ export function writeManifest(opts: {
   leaves: FlatRoute[]
   routeComponent: Map<string, string>
   compiled: Map<string, Compiled>
-  runtime: string
+  /** The runtime files `buildRuntime` wrote: the core and the feature modules. */
+  runtime: { core: string; features: Record<string, string>; nav?: string }
   /** component id → `client/<file>` (client chunk or react island chunk). */
   chunks: Map<string, string>
   actions?: ActionsRecord | null
@@ -280,7 +356,10 @@ export function writeManifest(opts: {
       needs_worker: jobs.length > 0,
       use_id_slots: c.ir.use_id_slots ?? 0,
       stores: storesOf(compiled, c.id),
+      features: featuresOf(c.id, c.jinja, tierOf(c.ir) === 'react'),
     }
+    for (const f of components[c.id]!.features)
+      if (!(f in opts.runtime.features)) throw new BuildError('runtime-feature-missing', `${c.id}: needs the client runtime feature ${f}, which the build did not ship`)
   }
   const routes: RouteRecord[] = opts.leaves.map((l) => {
     // A node without a Component (a pure path/loader group) renders nothing: not a chain entry.
@@ -302,7 +381,7 @@ export function writeManifest(opts: {
     }
   })
   linkNativeChunks(routes, compiled, components)
-  return { version: 1, routes, components, assets: { runtime: opts.runtime }, jobs_module: 'jobs.js', actions: opts.actions ?? null }
+  return { version: MANIFEST_VERSION, routes, components, assets: { runtime: opts.runtime.core, features: opts.runtime.features, ...(opts.runtime.nav === undefined ? {} : { nav: opts.runtime.nav }) }, jobs_module: 'jobs.js', actions: opts.actions ?? null }
 }
 
 /** S6 amendment (F66): the server's asset injection walks only each chain component's direct
@@ -315,6 +394,8 @@ function linkNativeChunks(routes: RouteRecord[], compiled: Map<string, Compiled>
   const chainIds = new Set(routes.flatMap((r) => r.chain))
   for (const root of chainIds) {
     const rec = components[root]!
+    // A React root renders its whole subtree itself: whatever native chunks its IR lists are not served.
+    if (rec.tier === 'react') continue
     const linked = new Set(rec.children.map((ch) => ch.id))
     const seen = new Set([root])
     const walk = (id: string) => {