@brust/core 2.0.0-alpha.2 → 2.0.0-alpha.20

package/src/cli.ts

@@ -3,11 +3,16 @@
 // Exit codes: 0 ok, 1 build/boot error (`error <rule> <message>` / `[brust] …`), 2 usage.
 import { parseArgs } from 'node:util'
 import { BuildError, runBuild } from './build'
+import { runBunDev } from './dev/bun'
+import { runDev } from './dev'
 import { run } from './run'
 
 const USAGE = `usage:
-  brust build [entry=routes.tsx] [--out-dir dist] [--force]
+  brust build [entry=routes.tsx] [--out-dir dist] [--force] [--target bun|cloudflare|static] [--actions-only] [--strict] [--wasm-from-source] [--dev]
+  brust dev [entry=routes.tsx] [--port N] [--workers N]    (Bun target: proxy + hot reload + inline TUI)
+  brust dev [entry=routes.tsx] --target cloudflare [--out-dir dist] [--port N] [--wasm-from-source] [-- <wrangler args>]
   brust start [--port N] [--workers N] [--dist-dir dist] [--entry routes.tsx]
+  brust shadcn init [component ...] [--force] [--css <file>] [--base-color <name>] [--shadcn-version <x.y.z>]
 
 Config precedence for start: env (BRUST_ADDR, BRUST_PORT, BRUST_WORKERS, BRUST_RENDER_SLOTS,
 BRUST_DRAIN_TIMEOUT_MS, BRUST_BOOT_TIMEOUT_MS, BRUST_DIST_DIR, BRUST_APP_ENTRY) > flags
@@ -29,7 +34,10 @@ function intFlag(name: string, v: string | undefined, min: number): number | und
 }
 
 export async function main(argv: string[]): Promise<void> {
-  const [cmd, ...rest] = argv
+  const [cmd, ...all] = argv
+  const dd = cmd === 'dev' ? all.indexOf('--') : -1
+  const rest = dd < 0 ? all : all.slice(0, dd)
+  const passthrough = dd < 0 ? [] : all.slice(dd + 1)
   if (cmd === undefined || cmd === '--help' || cmd === '-h' || cmd === 'help') {
     process.stdout.write(USAGE)
     process.exit(cmd === undefined ? 2 : 0)
@@ -46,6 +54,14 @@ export async function main(argv: string[]): Promise<void> {
         port: { type: 'string' },
         workers: { type: 'string' },
         force: { type: 'boolean' },
+        css: { type: 'string' },
+        'base-color': { type: 'string' },
+        'shadcn-version': { type: 'string' },
+        strict: { type: 'boolean' },
+        target: { type: 'string' },
+        'wasm-from-source': { type: 'boolean' },
+        'actions-only': { type: 'boolean' },
+        dev: { type: 'boolean' },
         help: { type: 'boolean', short: 'h' },
       },
     })
@@ -58,6 +74,11 @@ export async function main(argv: string[]): Promise<void> {
     process.exit(0)
   }
   const str = (k: string) => values[k] as string | undefined
+  const target = str('target')
+  if (target !== undefined && target !== 'bun' && target !== 'cloudflare' && target !== 'static')
+    usage(`--target must be bun, cloudflare or static (got ${JSON.stringify(target)})`)
+  if (values['actions-only'] === true && cmd !== 'build') usage('--actions-only only applies to brust build')
+  if (values.strict === true && (cmd !== 'build' || target !== 'static')) usage('--strict only applies to brust build --target static')
 
   if (cmd === 'build') {
     if (positionals.length > 1) usage(`build takes one entry (got ${positionals.join(' ')})`)
@@ -68,6 +89,11 @@ export async function main(argv: string[]): Promise<void> {
         entry: positionals[0] ?? 'routes.tsx',
         outDir: str('out-dir') ?? 'dist',
         force: values.force === true,
+        target: target as 'bun' | 'cloudflare' | 'static' | undefined,
+        strict: values.strict === true,
+        wasmFromSource: values['wasm-from-source'] === true,
+        actionsOnly: values['actions-only'] === true,
+        dev: values.dev === true,
         log: (s) => console.log(s),
       })
     } catch (e) {
@@ -79,6 +105,49 @@ export async function main(argv: string[]): Promise<void> {
     console.log(`[brust] built ${str('out-dir') ?? 'dist'} in ${Math.round(performance.now() - t0)}ms`)
     process.exit(0)
   }
+  if (cmd === 'dev') {
+    if (positionals.length > 1) usage(`dev takes one entry (got ${positionals.join(' ')})`)
+    const port = intFlag('port', str('port'), 0)
+    if (target !== 'cloudflare') {
+      const workers = intFlag('workers', str('workers'), 1)
+      if (passthrough.length > 0) usage('brust dev: arguments after -- are for --target cloudflare (wrangler)')
+      process.exit(await runBunDev({ appRoot: process.cwd(), entry: positionals[0] ?? 'routes.tsx', ...(port !== undefined && { port }), ...(workers !== undefined && { workers }) }))
+    }
+    try {
+      process.exit(
+        await runDev({
+          appRoot: process.cwd(),
+          entry: positionals[0] ?? 'routes.tsx',
+          outDir: str('out-dir') ?? 'dist',
+          ...(port !== undefined && { port }),
+          wranglerArgs: passthrough,
+          fromSource: values['wasm-from-source'] === true,
+          log: (s) => console.log(s),
+        }),
+      )
+    } catch (e) {
+      if (e instanceof BuildError) console.error(`error ${e.rule} ${e.message}`)
+      else console.error(`error dev ${(e as Error).stack ?? String(e)}`)
+      process.exit(1)
+    }
+  }
+  if (cmd === 'shadcn') {
+    const [sub, ...components] = positionals
+    if (sub !== 'init') usage(`shadcn takes a subcommand: init (got ${sub === undefined ? 'none' : JSON.stringify(sub)})`)
+    // F252: loaded here, so no other command pays for it (it pulls in tsconfig-paths)
+    const { shadcnInit, spawnRunner } = await import('./shadcn/init')
+    const code = await shadcnInit({
+      root: process.cwd(),
+      components,
+      force: values.force === true,
+      ...(str('css') !== undefined && { css: str('css') }),
+      ...(str('base-color') !== undefined && { baseColor: str('base-color') }),
+      ...(str('shadcn-version') !== undefined && { shadcnVersion: str('shadcn-version') }),
+      run: spawnRunner,
+      out: (s) => console.log(s),
+    })
+    process.exit(code)
+  }
   if (cmd === 'start') {
     if (positionals.length > 0) usage(`start takes no positional arguments (got ${positionals.join(' ')})`)
     const port = intFlag('port', str('port'), 0)

package/src/config.ts

@@ -1,14 +1,18 @@
 // Runtime configuration (spec §8). Precedence, high → low:
 //   env (BRUST_ADDR / BRUST_PORT / BRUST_WORKERS / BRUST_RENDER_SLOTS / BRUST_DRAIN_TIMEOUT_MS /
-//        BRUST_BOOT_TIMEOUT_MS / BRUST_CALL_TIMEOUT_MS)
-//   > CLI flags (`brust start --port/--workers`)
-//   > brust.toml ([server] address / port, [workers] count)
-//   > defaults (localhost, 1337, availableParallelism(), 1, 10000, 30000, 30000).
+//        BRUST_BOOT_TIMEOUT_MS / BRUST_CALL_TIMEOUT_MS / BRUST_SLOT_BYTES / BRUST_MAX_LOADER_RESPONSE_BYTES)
+//   > CLI flags (`brust start --port/--workers`) and `run({ config })`
+//   > brust.toml ([server] address / port / max_loader_response_bytes, [workers] count / slot_bytes, [cors], [actions] base_url / credentials)
+//   > defaults (localhost, 1337, availableParallelism(), 1, 10000, 30000, 30000, 262144, 8388608).
+// L16 R16.1: `actionsBaseUrl` follows env (BRUST_ACTIONS_BASE_URL) > run({ config }) > toml `[actions] base_url`.
+// `cors` has no env layer; `run({ config: { cors } })` replaces a toml `[cors]` as a whole (never merged), and
+// `cors: null` turns a toml `[cors]` off.
 // `brust start`'s BRUST_DIST_DIR / BRUST_APP_ENTRY follow the same env > flag rule (run.ts).
 // A missing brust.toml is fine; a present one with the wrong shape is an error. Messages follow
 // 0.1.x `runtime/config.ts`.
 import { availableParallelism } from 'node:os'
 import { join } from 'node:path'
+import { ACTION_CREDENTIALS, type ActionCredentials, baseUrlError } from './actions/prefix'
 
 /** `[cors]` in brust.toml; same shape and validation as the Rust `CorsConfig` (crates/brust-server/src/config.rs). */
 export interface CorsConfig {
@@ -32,10 +36,22 @@ export interface BrustConfig {
   callTimeoutMs: number
   /** tokio threads of the HTTP runtime (renders every page); absent = one per core (server default). */
   ioThreads?: number
-  /** From brust.toml `[cors]` only (runtime config: no env / CLI layer); absent = CORS off. */
+  /** The SAB response slot of one render slot, bytes (`slot_bytes`, env BRUST_SLOT_BYTES); 64 KiB..16 MiB. */
+  slotBytes: number
+  /** The biggest loader/jobs reply that crosses by heap when it does not fit the slot (`max_loader_response_bytes`,
+   * env BRUST_MAX_LOADER_RESPONSE_BYTES); 256 KiB..64 MiB. */
+  maxLoaderResponseBytes: number
+  /** `run({ config: { cors } })` over brust.toml `[cors]` (a whole-object replace); absent = CORS off. No env layer. */
   cors?: CorsConfig
+  /** L16 R16.1: the origin the browser `client()` calls (page script `__BRUST_ACTION_BASE__`); absent = same origin. */
+  actionsBaseUrl?: string
+  /** L16 R16.2: the client's default `RequestInit.credentials` (`__BRUST_ACTION_CREDENTIALS__`); absent = `same-origin`. */
+  actionsCredentials?: ActionCredentials
 }
 
+/** What `run({ config })` / `loadConfig`'s `cli` accepts: any setting, and `cors: null` to turn a toml `[cors]` off. */
+export type ConfigOverrides = Omit<Partial<BrustConfig>, 'cors'> & { cors?: (Omit<CorsConfig, 'credentials'> & { credentials?: boolean }) | null }
+
 export class BrustConfigError extends Error {
   override name = 'BrustConfigError'
   constructor(
@@ -46,11 +62,11 @@ export class BrustConfigError extends Error {
   }
 }
 
-const DEFAULTS = { host: 'localhost', port: 1337, drainTimeoutMs: 10_000, bootTimeoutMs: 30_000, callTimeoutMs: 30_000 }
+const DEFAULTS = { host: 'localhost', port: 1337, drainTimeoutMs: 10_000, bootTimeoutMs: 30_000, callTimeoutMs: 30_000, slotBytes: 256 * 1024, maxLoaderResponseBytes: 8_388_608 }
 
 /** Ceilings: ms values cross napi as `u32` (a larger number would wrap), more than 1024 Bun
- * workers is a misconfiguration, not a deployment, and each render slot is a 256 KiB shared
- * response buffer per worker (more than 64 would only exhaust memory). */
+ * workers is a misconfiguration, not a deployment, and each render slot is a `slotBytes` (default 256 KiB)
+ * shared response buffer per worker (more than 64 would only exhaust memory). */
 export const MAX_MS = 0xffff_ffff
 /** `max_age_seconds` crosses napi as `u32`, like the ms values. */
 const MAX_U32 = 0xffff_ffff
@@ -58,8 +74,14 @@ const MAX_U32 = 0xffff_ffff
 export const MAX_IO_THREADS = 256
 export const MAX_WORKERS = 1024
 export const MAX_RENDER_SLOTS = 64
+/** `slotBytes` (L10): 64 KiB..16 MiB. */
+export const MIN_SLOT_BYTES = 64 * 1024
+export const MAX_SLOT_BYTES = 16 * 1024 * 1024
+/** `maxLoaderResponseBytes` (L10): 256 KiB..64 MiB, like the actions limits. */
+export const MIN_LOADER_RESPONSE_BYTES = 256 * 1024
+export const MAX_LOADER_RESPONSE_BYTES = 64 * 1024 * 1024
 
-export async function loadConfig(cwd: string = process.cwd(), cli: Partial<BrustConfig> = {}): Promise<BrustConfig> {
+export async function loadConfig(cwd: string = process.cwd(), cli: ConfigOverrides = {}): Promise<BrustConfig> {
   const tomlPath = join(cwd, 'brust.toml')
   let fromToml: Partial<BrustConfig> = {}
   const file = Bun.file(tomlPath)
@@ -75,6 +97,8 @@ export async function loadConfig(cwd: string = process.cwd(), cli: Partial<Brust
   }
   const env = fromEnv()
   checkCli(cli)
+  // cli (validated, normalised) over toml as a whole object (R10.2); `null` = off.
+  const cors = cli.cors === undefined ? fromToml.cors : cli.cors === null ? undefined : checkCors(cli.cors, 'config.cors', null, false)
   return {
     host: env.host ?? cli.host ?? fromToml.host ?? DEFAULTS.host,
     port: env.port ?? cli.port ?? fromToml.port ?? DEFAULTS.port,
@@ -84,13 +108,35 @@ export async function loadConfig(cwd: string = process.cwd(), cli: Partial<Brust
     drainTimeoutMs: env.drainTimeoutMs ?? cli.drainTimeoutMs ?? DEFAULTS.drainTimeoutMs,
     bootTimeoutMs: env.bootTimeoutMs ?? cli.bootTimeoutMs ?? DEFAULTS.bootTimeoutMs,
     callTimeoutMs: env.callTimeoutMs ?? cli.callTimeoutMs ?? DEFAULTS.callTimeoutMs,
+    slotBytes: env.slotBytes ?? cli.slotBytes ?? fromToml.slotBytes ?? DEFAULTS.slotBytes,
+    maxLoaderResponseBytes: env.maxLoaderResponseBytes ?? cli.maxLoaderResponseBytes ?? fromToml.maxLoaderResponseBytes ?? DEFAULTS.maxLoaderResponseBytes,
     ioThreads: env.ioThreads ?? cli.ioThreads,
-    ...(fromToml.cors !== undefined ? { cors: fromToml.cors } : {}),
+    ...(cors ? { cors } : {}),
+    ...pick('actionsBaseUrl', env.actionsBaseUrl ?? cli.actionsBaseUrl ?? fromToml.actionsBaseUrl),
+    ...pick('actionsCredentials', cli.actionsCredentials ?? fromToml.actionsCredentials),
+  }
+}
+
+const pick = <K extends string, V>(k: K, v: V | undefined) => (v === undefined ? {} : ({ [k]: v } as { [P in K]: V }))
+
+/** `[cors]` of brust.toml and nothing else (no env, no cli): what the Cloudflare build ships in CONFIG.
+ * Throws `BrustConfigError` on a bad table, exactly like `loadConfig`. */
+export async function loadCors(cwd: string): Promise<CorsConfig | undefined> {
+  const tomlPath = join(cwd, 'brust.toml')
+  const file = Bun.file(tomlPath)
+  if (!(await file.exists())) return undefined
+  let parsed: unknown
+  try {
+    parsed = Bun.TOML.parse(await file.text())
+  } catch (e) {
+    throw new BrustConfigError(`failed to parse ${tomlPath}: ${(e as Error).message}`, tomlPath)
   }
+  const root = (parsed ?? {}) as Record<string, unknown>
+  return 'cors' in root ? parseCors(root.cors, tomlPath) : undefined
 }
 
 /** CLI / programmatic overrides get the same bounds as env (a CLI `--port 0` = any free port). */
-function checkCli(cli: Partial<BrustConfig>): void {
+function checkCli(cli: ConfigOverrides): void {
   const check = (name: string, v: number | undefined, min: number, max: number) => {
     if (v !== undefined && (!Number.isInteger(v) || v < min || v > max))
       throw new BrustConfigError(`${name} must be an integer in ${min}..${max} (got ${JSON.stringify(v)})`, null)
@@ -102,6 +148,14 @@ function checkCli(cli: Partial<BrustConfig>): void {
   check('bootTimeoutMs', cli.bootTimeoutMs, 1, MAX_MS)
   check('callTimeoutMs', cli.callTimeoutMs, 1, MAX_MS)
   check('ioThreads', cli.ioThreads, 1, MAX_IO_THREADS)
+  check('slotBytes', cli.slotBytes, MIN_SLOT_BYTES, MAX_SLOT_BYTES)
+  check('maxLoaderResponseBytes', cli.maxLoaderResponseBytes, MIN_LOADER_RESPONSE_BYTES, MAX_LOADER_RESPONSE_BYTES)
+  if (cli.actionsBaseUrl !== undefined) {
+    const why = baseUrlError(cli.actionsBaseUrl)
+    if (why) throw new BrustConfigError(`config.actionsBaseUrl ${why}`, null)
+  }
+  if (cli.actionsCredentials !== undefined && !ACTION_CREDENTIALS.includes(cli.actionsCredentials))
+    throw new BrustConfigError(`config.actionsCredentials must be one of ${ACTION_CREDENTIALS.join(', ')} (got ${JSON.stringify(cli.actionsCredentials)})`, null)
 }
 
 function table(v: unknown, what: string, file: string): Record<string, unknown> {
@@ -109,12 +163,21 @@ function table(v: unknown, what: string, file: string): Record<string, unknown>
   return v as Record<string, unknown>
 }
 
+function tomlInt(v: unknown, name: string, min: number, max: number, file: string): number | undefined {
+  if (v === undefined) return undefined
+  if (typeof v !== 'number' || !Number.isInteger(v) || v < min || v > max)
+    throw new BrustConfigError(`${file}: ${name} must be an integer in ${min}..${max} (got ${JSON.stringify(v)})`, file)
+  return v
+}
+
 function fromTomlTable(parsed: unknown, file: string): Partial<BrustConfig> {
   const root = table(parsed, 'top level', file)
   const out: Partial<BrustConfig> = {}
   if ('server' in root) {
     const server = table(root.server, '[server]', file)
     const { port, address } = server
+    const cap = tomlInt(server.max_loader_response_bytes, 'server.max_loader_response_bytes', MIN_LOADER_RESPONSE_BYTES, MAX_LOADER_RESPONSE_BYTES, file)
+    if (cap !== undefined) out.maxLoaderResponseBytes = cap
     if (port !== undefined) {
       if (typeof port !== 'number' || !Number.isInteger(port) || port < 1 || port > 65535)
         throw new BrustConfigError(`${file}: server.port must be an integer in 1..65535 (got ${JSON.stringify(port)})`, file)
@@ -127,7 +190,10 @@ function fromTomlTable(parsed: unknown, file: string): Partial<BrustConfig> {
     }
   }
   if ('workers' in root) {
-    const { count } = table(root.workers, '[workers]', file)
+    const w = table(root.workers, '[workers]', file)
+    const { count } = w
+    const slot = tomlInt(w.slot_bytes, 'workers.slot_bytes', MIN_SLOT_BYTES, MAX_SLOT_BYTES, file)
+    if (slot !== undefined) out.slotBytes = slot
     if (count !== undefined) {
       if (typeof count !== 'number' || !Number.isInteger(count) || count < 1 || count > MAX_WORKERS)
         throw new BrustConfigError(`${file}: workers.count must be an integer in 1..${MAX_WORKERS} (got ${JSON.stringify(count)})`, file)
@@ -135,34 +201,62 @@ function fromTomlTable(parsed: unknown, file: string): Partial<BrustConfig> {
     }
   }
   if ('cors' in root) out.cors = parseCors(root.cors, file)
+  if ('actions' in root) {
+    const a = table(root.actions, '[actions]', file)
+    if (a.base_url !== undefined) {
+      const why = baseUrlError(a.base_url)
+      if (why) throw new BrustConfigError(`${file}: actions.base_url ${why}`, file)
+      out.actionsBaseUrl = a.base_url as string
+    }
+    if (a.credentials !== undefined) {
+      if (typeof a.credentials !== 'string' || !ACTION_CREDENTIALS.includes(a.credentials as ActionCredentials))
+        throw new BrustConfigError(`${file}: actions.credentials must be one of ${ACTION_CREDENTIALS.join(', ')} (got ${JSON.stringify(a.credentials)})`, file)
+      out.actionsCredentials = a.credentials as ActionCredentials
+    }
+  }
   return out
 }
 
 function parseCors(v: unknown, file: string): CorsConfig {
-  const t = table(v, 'cors', file)
+  return checkCors(corsFromToml(table(v, 'cors', file)), `${file}: cors`, file, true)
+}
+
+/** brust.toml `[cors]` (snake_case keys) → the camelCase shape [`checkCors`] validates. Unknown toml keys are ignored, as always. */
+function corsFromToml(t: Record<string, unknown>): Record<string, unknown> {
+  return { origins: t.origins, methods: t.methods, headers: t.headers, exposeHeaders: t.expose_headers, credentials: t.credentials, maxAgeSeconds: t.max_age_seconds }
+}
+
+const CORS_KEYS = ['origins', 'methods', 'headers', 'exposeHeaders', 'credentials', 'maxAgeSeconds']
+
+/** The one `[cors]` validator (Rust `CorsConfig::validate`, verbatim), for toml (`where` = `<file>: cors`, key names in
+ * snake_case) and for `run({ config: { cors } })` (`where` = `config.cors`, camelCase; an unknown key is an error). */
+function checkCors(c: unknown, where: string, file: string | null, snake: boolean): CorsConfig {
+  const fail = (m: string) => new BrustConfigError(m, file)
+  if (c === null || typeof c !== 'object' || Array.isArray(c)) throw fail(`${where} must be ${file === null ? 'an object (or null)' : 'a table'} (got ${JSON.stringify(c)})`)
+  const t = c as Record<string, unknown>
+  if (!snake) {
+    const bad = Object.keys(t).find((k) => !CORS_KEYS.includes(k))
+    if (bad !== undefined) throw fail(`${where}.${bad} is not a cors option (expected ${CORS_KEYS.join(', ')})`)
+  }
+  const name = (k: string) => (snake ? k.replace(/[A-Z]/g, (m) => `_${m.toLowerCase()}`) : k)
   const strings = (val: unknown, key: string): string[] | undefined => {
     if (val === undefined) return undefined
-    if (!Array.isArray(val) || val.some((x) => typeof x !== 'string'))
-      throw new BrustConfigError(`${file}: cors.${key} must be an array of strings (got ${JSON.stringify(val)})`, file)
+    if (!Array.isArray(val) || val.some((x) => typeof x !== 'string')) throw fail(`${where}.${name(key)} must be an array of strings (got ${JSON.stringify(val)})`)
     return val as string[]
   }
   const origins = strings(t.origins, 'origins') ?? []
   const methods = strings(t.methods, 'methods')
   const headers = strings(t.headers, 'headers')
-  const exposeHeaders = strings(t.expose_headers, 'expose_headers')
-  if (t.credentials !== undefined && typeof t.credentials !== 'boolean')
-    throw new BrustConfigError(`${file}: cors.credentials must be a boolean (got ${JSON.stringify(t.credentials)})`, file)
+  const exposeHeaders = strings(t.exposeHeaders, 'exposeHeaders')
+  if (t.credentials !== undefined && typeof t.credentials !== 'boolean') throw fail(`${where}.credentials must be a boolean (got ${JSON.stringify(t.credentials)})`)
   const credentials = t.credentials === true
-  const age = t.max_age_seconds
+  const age = t.maxAgeSeconds
   if (age !== undefined && (typeof age !== 'number' || !Number.isInteger(age) || age < 0 || age > MAX_U32))
-    throw new BrustConfigError(`${file}: cors.max_age_seconds must be an integer in 0..${MAX_U32} (got ${JSON.stringify(age)})`, file)
+    throw fail(`${where}.${name('maxAgeSeconds')} must be an integer in 0..${MAX_U32} (got ${JSON.stringify(age)})`)
   // Rust CorsConfig::validate, verbatim.
-  if (origins.length === 0) throw new BrustConfigError(`${file}: cors.origins must be non-empty`, file)
+  if (origins.length === 0) throw fail(`${where}.origins must be non-empty`)
   if (credentials && origins.includes('*'))
-    throw new BrustConfigError(
-      `${file}: cors.credentials cannot be combined with a wildcard origin '*' (browsers reject Access-Control-Allow-Origin: * with credentials); list explicit origins instead`,
-      file,
-    )
+    throw fail(`${where}.credentials cannot be combined with a wildcard origin '*' (browsers reject Access-Control-Allow-Origin: * with credentials); list explicit origins instead`)
   return {
     origins,
     ...(methods ? { methods } : {}),
@@ -195,6 +289,14 @@ function fromEnv(): Partial<BrustConfig> {
   out.drainTimeoutMs = envInt('BRUST_DRAIN_TIMEOUT_MS', 0, MAX_MS, `an integer in 0..${MAX_MS}`)
   out.bootTimeoutMs = envInt('BRUST_BOOT_TIMEOUT_MS', 1, MAX_MS, `an integer in 1..${MAX_MS}`)
   out.callTimeoutMs = envInt('BRUST_CALL_TIMEOUT_MS', 1, MAX_MS, `an integer in 1..${MAX_MS}`)
+  out.slotBytes = envInt('BRUST_SLOT_BYTES', MIN_SLOT_BYTES, MAX_SLOT_BYTES, `an integer in ${MIN_SLOT_BYTES}..${MAX_SLOT_BYTES}`)
+  out.maxLoaderResponseBytes = envInt('BRUST_MAX_LOADER_RESPONSE_BYTES', MIN_LOADER_RESPONSE_BYTES, MAX_LOADER_RESPONSE_BYTES, `an integer in ${MIN_LOADER_RESPONSE_BYTES}..${MAX_LOADER_RESPONSE_BYTES}`)
   out.ioThreads = envInt('BRUST_WORKER_THREADS', 1, MAX_IO_THREADS, `an integer in 1..${MAX_IO_THREADS}`)
+  const base = process.env.BRUST_ACTIONS_BASE_URL
+  if (base !== undefined && base !== '') {
+    const why = baseUrlError(base)
+    if (why) throw new BrustConfigError(`BRUST_ACTIONS_BASE_URL ${why}`, null)
+    out.actionsBaseUrl = base
+  }
   return out
 }

package/src/css-modules.d.ts

@@ -0,0 +1,8 @@
+// L19 (R19.4): a `.module.css` import is its class map (the build's `cssPlugin`); any other `.css`
+// import is a side-effect import the server links (R19.3). Pulled in by a `/// <reference>` from the
+// entries apps import, so both forms typecheck.
+declare module '*.module.css' {
+  const classes: { readonly [name: string]: string }
+  export default classes
+}
+declare module '*.css' {}