@weft-js/start 0.1.0 → 0.1.2

package/src/server/page-cold.ts

@@ -0,0 +1,95 @@
+// Render first when no remembered head can be sent yet.
+import { LAYER_ORDER, pageStyles, type keptSheets } from '../inline.mjs'
+import { capture, speculate } from '../capture'
+import { whole } from './compression'
+import { withHeaders } from './request'
+import { esc } from './text'
+import { finish, pageShell, render, rest, shaped, table, top } from './page-stream'
+import { HOLD, type Head, type PageState } from './page-types'
+
+type Styles = ReturnType<typeof pageStyles>
+type Shape = ReturnType<typeof shaped>
+type Table = ReturnType<typeof table>
+
+function coldHead(
+  p: PageState,
+  shape: Shape,
+  t: Table,
+  styles: Styles | undefined,
+  capturing: boolean,
+) {
+  return (
+    top(p) +
+    shape.preloads +
+    // A streamed page's entry is at the end of what the shell sends, so its script tag is found late.
+    (p.assets.entry && shape.streaming
+      ? `<link rel="modulepreload" href="${esc(p.assets.entry)}">\n`
+      : '') +
+    (t
+      ? `<style>${LAYER_ORDER}${p.assets.pieces!.layers}${t.rules(p.stream.shell)}</style>\n`
+      : styles!.head) +
+    (capturing ? `<script>${capture(shape.now)}</script>\n` + speculate(shape) : '') +
+    p.dev +
+    (p.assets.entry && !shape.streaming
+      ? `<script type="module" src="${esc(p.assets.entry)}"></script>\n`
+      : '') +
+    '</head>\n<body>\n' +
+    pageShell(p, shape, t ? t.links : '')
+  )
+}
+
+/** Render first and send the head and shell together. */
+export async function coldPage(
+  p: PageState,
+  known: Head | null | undefined,
+  cold: string,
+  kept: ReturnType<typeof keptSheets>,
+) {
+  const t0 = performance.now()
+  p.stream = render(p)
+  await p.stream.settle() // queries read outside a Boundary have nowhere to stream to
+  await p.stream.hold(p.options.hold ?? HOLD)
+  const ms = performance.now() - t0
+  p.complete(p.r, p.stream.shell)
+  const shape = shaped(p)
+  const t = table(p, shape)
+  const styles = t
+    ? undefined
+    : pageStyles(p.assets, shape.sheets, p.stream.shell, {
+        head: p.site.head,
+        have: kept,
+        keep: p.request.headers.has('cookie'),
+      })
+  const capturing = !!p.options.lazy || shape.streaming
+  if (known !== null && !p.options.dev)
+    p.remember(styles?.links ? cold + ' w' : cold, {
+      ...shape,
+      ms,
+      split: styles?.split ?? false,
+      found: styles?.found() ?? new Set(),
+      capture: capturing,
+      fold: !!shape.parts.fold.length,
+    })
+  const head = coldHead(p, shape, t, styles, capturing)
+  const init = {
+    status: p.status,
+    headers: {
+      'content-type': 'text/html; charset=utf-8',
+      'cache-control': 'no-cache',
+      ...(shape.parts.fold.length && { vary: 'Save-Data, Sec-CH-Prefers-Reduced-Data' }),
+    },
+  }
+  // No Boundary is waiting, so there's nothing to stream: the page goes out in one piece.
+  if (!shape.streaming) {
+    const res = new Response(null, init)
+    whole.set(res, head + (await finish(p, false)))
+    return withHeaders(res, p.scope)
+  }
+  const body = new ReadableStream<Uint8Array>({
+    async start(controller) {
+      controller.enqueue(p.enc.encode(head))
+      await rest(p, { controller, styles: t || styles!, streaming: true })
+    },
+  })
+  return withHeaders(new Response(body, init), p.scope)
+}

package/src/server/page-stream.tsx

@@ -0,0 +1,181 @@
+// The render's shell, incremental data, and remaining streamed chunks.
+import { metaTags, renderToStream } from '@weft-js/core/ssr'
+import { keyOf } from '../data'
+import * as exec from '../exec'
+import { hub } from '../hub'
+import { App } from '../view'
+import type { pageStyles } from '../inline.mjs'
+import { cookieJar } from './request'
+import { dataTags, pageData, payloadOf, scrubbed, wire } from './payload'
+import {
+  islandsOf,
+  modulepreloads,
+  pageChunks,
+  pageSheets,
+  saveData,
+  tableStyles,
+  withLevels,
+} from './render'
+import { esc, json } from './text'
+import type { PageState } from './page-types'
+
+/** Cache entries the client hasn't got. */
+function news(p: PageState) {
+  const fresh = wire(p.scope).filter((w) => !p.sent.has(keyOf(w[0], w[1])))
+  for (const w of fresh) p.sent.add(keyOf(w[0], w[1]))
+  return fresh
+}
+
+/** What the client hasn't been told of the render. */
+function since(p: PageState) {
+  const d = p.stream.data()
+  const changed = <T,>(from: Record<string, T>, seen: Record<string, unknown>) => {
+    const out = Object.fromEntries(Object.entries(from).filter(([k, v]) => seen[k] !== v))
+    Object.assign(seen, out)
+    return out
+  }
+  const state = JSON.stringify(d?.s)
+  const fresh = state !== p.told.s
+  p.told.s = state
+  return {
+    r: scrubbed(changed(d?.r ?? {}, p.told.r), p.scope),
+    b: changed(d?.b ?? {}, p.told.b),
+    ...(fresh && d?.s && { s: d.s }),
+  }
+}
+
+/** Start the page render with its request-local stream state. */
+export function render(p: PageState) {
+  return renderToStream(() => <App route={p.route} />, {
+    ...p.timing,
+    passes: p.passes,
+    shown: (e) => exec.shown(e, p.scope),
+    stalled: () =>
+      p.options.onDiagnostic?.({
+        code: 'E_STREAM',
+        severity: 'warning',
+        message: `${p.path}: a render stopped reading anything new, so what's still out is left to the client. Is a query's input different on every render, a \`Date.now()\` say?`,
+      }),
+    app: { cookies: cookieJar(p.request) },
+    landing: () => `(self.$wc=self.$wc||[]).push(${json({ c: news(p), ...since(p) })});`,
+  })
+}
+
+/** The head down to the fonts, after metadata is complete. */
+/**
+ * A full load between pages that opt into cross-document view transitions (warp does) brings the browser's own
+ * transition. When the browser skips one ("invalid state"), its three promises reject, and the page reveals before the
+ * runtime's module runs: so this listens from the head, on every page that has code. Chrome can also reject one the
+ * page never sees (a skipped outgoing transition), so a rejection that says only that a transition was aborted or
+ * skipped is marked handled too; nothing else is touched.
+ */
+const REVEAL = `<script>(f=>{["pagereveal","pageswap"].forEach(n=>addEventListener(n,e=>{var t=e.viewTransition;t&&[t.ready,t.finished,t.updateCallbackDone].forEach(q=>q.catch(f))}));addEventListener("unhandledrejection",e=>{/^Transition was (aborted|skipped)/.test(e.reason&&e.reason.message)&&e.preventDefault()})})(()=>{})</script>\n`
+
+export function top(p: PageState) {
+  return (
+    `<!doctype html>\n<html${p.lang}>\n<head>\n<meta charset="utf-8">\n<meta name="viewport" content="width=device-width, initial-scale=1">\n` +
+    (p.assets.entry ? REVEAL : '') +
+    metaTags(p.r.head, p.url.pathname) +
+    '\n' +
+    (p.site.head ? p.site.head + '\n' : '') +
+    (p.assets.fonts ?? [])
+      .map(
+        (f) =>
+          `<link rel="preload" as="font" type="${esc(f.type)}" href="${esc(f.href)}" crossorigin>\n`,
+      )
+      .join('')
+  )
+}
+
+/** What this render's head needs, from its HTML. */
+export function shaped(p: PageState) {
+  const payload = withLevels(payloadOf(p.r, false, p.options), p.stream.shell, p.statics, false)
+  const parts = islandsOf(p.stream.shell)
+  // A Boundary is waiting: the client starts now, not at the last byte.
+  const streaming = Object.values(p.stream.data()?.b ?? {}).includes('p')
+  const now = !parts.lazy.length || payload.m.some((m) => !m.s) || !!payload.i?.length
+  // The entry's own script tag already fetches it; preloads go above the styles.
+  const preloads = modulepreloads(
+    [
+      ...(p.assets.js ?? []),
+      ...pageChunks(payload, p.options.chunks, saveData(p.request) ? [] : parts.fold, now),
+    ],
+    p.assets,
+  )
+  return {
+    payload,
+    parts,
+    streaming,
+    now,
+    preloads,
+    sheets: pageSheets(p.assets.css, parts, p.options.chunks),
+  }
+}
+
+/** First-paint rules for this render's sheets. */
+export function table(p: PageState, shape: ReturnType<typeof shaped>) {
+  return p.assets.pieces && tableStyles(p.assets.pieces, shape.sheets, p.site.head, p.lang)
+}
+
+/** From the app element to what remains to stream. */
+export function pageShell(p: PageState, shape: ReturnType<typeof shaped>, after = '') {
+  return (
+    `<div id="app">${p.stream.shell}</div>\n` +
+    after +
+    `<script type="application/json" id="weft-route">${json(shape.payload)}</script>\n` +
+    (p.scope.form
+      ? `<script type="application/json" id="weft-form">${json(p.scope.form)}</script>\n`
+      : '') +
+    // Async, and after all it reads, so it can run while the stream goes on.
+    (shape.streaming
+      ? (since(p), dataTags({ ...pageData(p.stream.data(), p.scope)!, w: 1 }, news(p)))
+      : '') +
+    (p.assets.entry && shape.streaming
+      ? `<script type="module" async src="${esc(p.assets.entry)}"></script>\n`
+      : '')
+  )
+}
+
+/** Finish the page with the resolved cache and live cursor. */
+export async function finish(p: PageState, streaming: boolean) {
+  const cached = wire(p.scope)
+  // Read after the queries ran: the first live connect replays what is published from here.
+  if (p.scope.live) await hub().ready()
+  const liveScript = p.scope.live
+    ? `<script type="application/json" id="weft-rt">${json({ c: hub().cursor(), b: p.options.build })}</script>\n`
+    : ''
+  // A client that starts after this finds the whole page, as if it had never streamed.
+  const stale = streaming
+    ? '<script>["weft-data","weft-cache"].forEach(function(i){(i=document.getElementById(i))&&i.remove()})</script>\n'
+    : ''
+  return (
+    stale + dataTags(pageData(p.stream.data(), p.scope), cached) + liveScript + '</body>\n</html>\n'
+  )
+}
+
+/** Flush each remaining chunk with its styles. */
+export async function rest(
+  p: PageState,
+  {
+    controller,
+    styles,
+    streaming,
+  }: {
+    controller: ReadableStreamDefaultController<Uint8Array>
+    styles: Pick<ReturnType<typeof pageStyles>, 'late'>
+    streaming: boolean
+  },
+) {
+  try {
+    for await (const chunk of p.stream.chunks)
+      controller.enqueue(
+        p.enc.encode(
+          styles.late(pageSheets([], islandsOf(chunk), p.options.chunks), chunk) + chunk + '\n',
+        ),
+      )
+  } catch (e) {
+    p.options.onDiagnostic?.({ code: 'E_STREAM', severity: 'error', message: String(e) })
+  }
+  controller.enqueue(p.enc.encode(await finish(p, streaming)))
+  controller.close()
+}

package/src/server/page-types.ts

@@ -0,0 +1,51 @@
+import type { Merged, Stream } from '@weft-js/core/ssr'
+import type { createRouteState, RoutePayload } from '../router'
+import type { Scope } from '../exec'
+import type { HandlerOptions, Resolved } from './types'
+
+/** A render this long (ms) sends its head first. */
+export const EARLY_MS = 4
+/** Boundary data that arrives within this hold goes in the page. */
+export const HOLD = 25
+
+/** A remembered head for a route shape. */
+export interface Head {
+  ms: number
+  sheets: { href: string }[]
+  preloads: string
+  now: boolean
+  capture: boolean
+  fold: boolean
+  split: boolean
+  found: Set<string>
+}
+
+export interface PageDeps {
+  options: HandlerOptions
+  site: NonNullable<HandlerOptions['site']>
+  statics: Set<string>
+  timing: { timeout?: number }
+  passes: number
+  resolve: (path: string, request: Request) => Promise<Resolved>
+  stateOf: (r: Resolved, payload: RoutePayload) => ReturnType<typeof createRouteState>
+  complete: (r: Resolved, html?: string) => Merged
+  heads: Map<string, Head | null>
+  remember: (shape: string, head: Head) => void
+}
+
+export interface PageState extends PageDeps {
+  url: URL
+  request: Request
+  scope: Scope
+  path: string
+  r: Resolved
+  route: ReturnType<typeof createRouteState>
+  sent: Set<string>
+  told: { r: Record<string, unknown>; b: Record<string, unknown>; s?: string }
+  stream: Stream
+  assets: NonNullable<HandlerOptions['assets']>
+  lang: string
+  dev: string
+  status: number
+  enc: TextEncoder
+}

package/src/server/page-warm.ts

@@ -0,0 +1,130 @@
+// A known head can go out before the new render finishes.
+import { LAYER_ORDER, pageStyles, type keptSheets } from '../inline.mjs'
+import { capture, speculate } from '../capture'
+import { withHeaders } from './request'
+import { esc } from './text'
+import { pageShell, render, rest, shaped, table, top } from './page-stream'
+import { HOLD, type Head, type PageState } from './page-types'
+
+type Styles = ReturnType<typeof pageStyles>
+
+/** Render the shell behind a head that has already gone out. */
+async function warmContent(
+  p: PageState,
+  known: Head,
+  sent: {
+    cold: string
+    set: number
+    styles: Styles | undefined
+    controller: ReadableStreamDefaultController<Uint8Array>
+  },
+) {
+  const { cold, set, styles, controller } = sent
+  const t0 = performance.now()
+  p.stream = render(p)
+  await p.stream.settle() // queries read outside a Boundary have nowhere to stream to
+  await p.stream.hold(p.options.hold ?? HOLD)
+  const ms = performance.now() - t0
+  const shape = shaped(p)
+  const t = table(p, shape)
+  const capturing = !!p.options.lazy || shape.streaming
+  // What this page has beyond the head: sheets, rules, and chunks that render didn't reach.
+  const have = new Set(known.preloads.split(/(?=<link )/))
+  const more = shape.preloads
+    .split(/(?=<link )/)
+    .filter((l) => l && !have.has(l))
+    .join('')
+  const rules = t && t.rules(p.stream.shell)
+  const lead =
+    (t ? (rules ? `<style>${rules}</style>\n` : '') : styles!.late(shape.sheets, p.stream.shell)) +
+    more +
+    (capturing && !known.capture
+      ? `<script>${capture(shape.now)}</script>\n` + speculate(shape)
+      : '')
+  controller.enqueue(
+    p.enc.encode(
+      lead +
+        pageShell(p, shape, t ? t.links : '') +
+        (p.assets.entry && !shape.streaming
+          ? `<script type="module" src="${esc(p.assets.entry)}"></script>\n`
+          : ''),
+    ),
+  )
+  // A render that set a header after they went can't use this: the route goes back to rendering first.
+  if ([...p.scope.headers].length !== set) {
+    p.heads.set(cold, null).set(cold + ' w', null)
+    p.options.onDiagnostic?.({
+      code: 'E_HEAD',
+      severity: 'warning',
+      message: `${p.path}: a render set a response header after the head was sent, so this route now renders before sending anything.`,
+    })
+  } else
+    p.remember(styles?.links ? cold + ' w' : cold, {
+      ...shape,
+      ms,
+      split: styles?.split ?? false,
+      found: styles?.found() ?? new Set(),
+      capture: capturing,
+      fold: !!shape.parts.fold.length,
+      preloads: [...have, ...more.split(/(?=<link )/)].filter(Boolean).join(''),
+    })
+  await rest(p, { controller, styles: t || styles!, streaming: shape.streaming })
+}
+
+/** Send the remembered head, then flush the render behind it. */
+export async function warmPage(
+  p: PageState,
+  known: Head,
+  cold: string,
+  kept: ReturnType<typeof keptSheets>,
+) {
+  p.complete(p.r)
+  // A session read can set cookies, which have to be in the headers: read it before they go.
+  if (p.request.headers.has('cookie')) await p.scope.ctx().catch(() => {})
+  const set = [...p.scope.headers].length
+  const styles = p.assets.pieces
+    ? undefined
+    : pageStyles(p.assets, known.sheets, '', {
+        head: p.site.head,
+        seen: known,
+        have: kept,
+        keep: p.request.headers.has('cookie'),
+      })
+  // With a table, the rules come with the shell; here there is only the layer order.
+  const head =
+    top(p) +
+    known.preloads +
+    (p.assets.entry ? `<link rel="modulepreload" href="${esc(p.assets.entry)}">\n` : '') +
+    (styles ? styles.head : `<style>${LAYER_ORDER}${p.assets.pieces!.layers}</style>\n`) +
+    (known.capture ? `<script>${capture(known.now)}</script>\n` + speculate(known) : '') +
+    p.dev +
+    '</head>\n<body>\n'
+  const init = {
+    status: p.status,
+    headers: {
+      'content-type': 'text/html; charset=utf-8',
+      'cache-control': 'no-cache',
+      ...(known.fold && { vary: 'Save-Data, Sec-CH-Prefers-Reduced-Data' }),
+    },
+  }
+  const body = new ReadableStream<Uint8Array>({
+    async start(controller) {
+      controller.enqueue(p.enc.encode(head))
+      try {
+        await warmContent(p, known, { cold, set, styles, controller })
+      } catch (e) {
+        p.heads.set(cold, null).set(cold + ' w', null)
+        p.options.onDiagnostic?.({
+          code: 'E_HEAD',
+          severity: 'error',
+          message: `${p.path}: ${String(e)}`,
+        })
+        controller.enqueue(
+          p.enc.encode('<p>Something went wrong. <a href="">Reload</a></p>\n</body>\n</html>\n'),
+        )
+        controller.close()
+      }
+    },
+  })
+  return withHeaders(new Response(body, init), p.scope)
+}

package/src/server/page.ts

@@ -0,0 +1,69 @@
+// Select a remembered head or render before sending the page.
+import { keptSheets, sheetId } from '../inline.mjs'
+import type { Scope } from '../exec'
+import { payloadOf } from './payload'
+import { saveData } from './render'
+import { redirectBody } from './request'
+import { esc, moved } from './text'
+import { coldPage } from './page-cold'
+import { leftToPage } from './head'
+import { warmPage } from './page-warm'
+import { EARLY_MS, type PageDeps, type PageState } from './page-types'
+
+/** The page renderer for one handler and its remembered heads. */
+export function makePage(deps: PageDeps) {
+  return async function page(url: URL, request: Request, scope: Scope): Promise<Response> {
+    const path = url.pathname + url.search
+    const r = await deps.resolve(path, request)
+    if (r.redirect) {
+      const headers = new Headers(r.redirectHeaders)
+      headers.set('location', r.redirect.href)
+      if (!headers.has('cache-control')) headers.set('cache-control', 'no-cache')
+      return redirectBody(
+        new Response(moved(r.redirect.href), { status: r.redirect.status, headers }),
+        scope,
+        'text/html; charset=utf-8',
+        r.redirect.href,
+      )
+    }
+    scope.started = true // from here a redirect can't change the status (Q007)
+    // The render reads raw deferred data; the page carries the settled part.
+    const route = deps.stateOf(r, payloadOf(r, false))
+    const sent = new Set<string>()
+    const told: PageState['told'] = { r: {}, b: {} }
+    const assets = deps.options.assets ?? {}
+    const p: PageState = {
+      ...deps,
+      url,
+      request,
+      scope,
+      path,
+      r,
+      route,
+      sent,
+      told,
+      stream: undefined!,
+      assets,
+      lang: deps.site.locale ? ` lang="${esc(deps.site.locale.replace('_', '-'))}"` : '',
+      dev: deps.options.dev
+        ? '<script type="module" src="/@vite/client"></script>\n<script type="module" src="/@weft-agent.js"></script>\n'
+        : '',
+      status: r.status === 200 && scope.form ? scope.form.status : r.status,
+      enc: new TextEncoder(),
+    }
+    // A browser with the page's sheets gets the remembered link-only head. A table has no separate head.
+    const cold = `${p.status} ${saveData(request) ? 1 : 0} ${r.levels.map((l) => l.id).join()}`
+    const kept = assets.pieces ? undefined : keptSheets(request.headers.get('cookie'))
+    const warm = kept && p.heads.get(cold + ' w')
+    const shape = warm && warm.sheets.every((c) => kept.has(sheetId(c.href))) ? cold + ' w' : cold
+    const known = p.heads.get(shape)
+    // A level left words to the page, which are only known after it renders.
+    const worded =
+      !!r.metas &&
+      r.status === 200 &&
+      (leftToPage(r.source!.title) || leftToPage(r.source!.description))
+    // Only a render slow enough to wait on sends its remembered head first.
+    if (known && known.ms >= EARLY_MS && !worded) return warmPage(p, known, cold, kept)
+    return coldPage(p, known, cold, kept)
+  }
+}

package/src/server/payload.ts

@@ -0,0 +1,89 @@
+import type { Stream } from '@weft-js/core/ssr'
+import type { RoutePayload } from '../router'
+import type { Wire } from '../data'
+import * as exec from '../exec'
+import type { Scope } from '../exec'
+import { selectRouteAssets } from '../asset-receipt.mjs'
+import { json, thenable } from './text'
+import type { HandlerOptions, Resolved } from './types'
+
+export function fill(pattern: string, params: Record<string, string>, splat?: string) {
+  return pattern.replace(/\$([\w$]*)/g, (_, n) =>
+    n ? encodeURIComponent(params[n]!) : (params[splat!] ?? ''),
+  )
+}
+
+/** The data without its deferred (promise) fields, and their names. */
+export function split(raw: unknown): { data: unknown; d?: string[] } {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return { data: raw }
+  const fields = raw as Record<string, unknown>
+  const d = Object.keys(raw).filter((k) => thenable(fields[k]))
+  if (!d.length) return { data: raw }
+  for (const k of d) Promise.resolve(fields[k]).catch(() => {}) // a deferred failure surfaces in its Boundary
+  return { data: Object.fromEntries(Object.entries(raw).filter(([k]) => !d.includes(k))), d }
+}
+
+/** What `meta` and cards see: the settled data. Reading a deferred field is H007 (it's still streaming). */
+export function settledView(
+  raw: unknown,
+  deferred: string[] | undefined,
+  id: string,
+  options: HandlerOptions,
+) {
+  if (!deferred?.length) return raw
+  return new Proxy(raw as object, {
+    get(t, k, r) {
+      if (typeof k === 'string' && deferred.includes(k)) {
+        const message = `H007 \`meta\` (or a card) of route ${id} reads \`data.${k}\`, a deferred field that is still streaming. Await it in \`load\`, or leave it out of \`meta\`.`
+        options.onDiagnostic?.({ code: 'H007', severity: 'error', message, route: id })
+        throw Object.assign(new Error(message), { code: 'H007' })
+      }
+      return Reflect.get(t, k, r)
+    },
+  })
+}
+
+export function payloadOf(r: Resolved, withHead: boolean, options?: HandlerOptions): RoutePayload {
+  const { jsonLd: _, ...head } = r.head // only a first response carries it (`metaTags`)
+  const assetBytes = selectRouteAssets(
+    options?.routeAssetBytes,
+    options?.build,
+    r.levels.map((level) => level.id),
+  )
+  return {
+    m: r.levels.map(({ id, params, data, d, t }) => ({
+      id,
+      params,
+      data,
+      ...(d && { d }),
+      ...(t && { t }),
+    })),
+    p: r.path,
+    s: r.status,
+    ...(assetBytes && { a: assetBytes }),
+    ...(withHead && { h: head }),
+  }
+}
+
+export const dataTags = (data: unknown, cached: Wire[]) =>
+  `<script type="application/json" id="weft-data">${json(data)}</script>\n` +
+  (cached.length
+    ? `<script type="application/json" id="weft-cache">${json(cached)}</script>\n`
+    : '')
+
+/** A render's data as a page may carry it: what failed says only what `exec.shown` let through. */
+export function pageData(data: ReturnType<Stream['data']>, scope: Scope) {
+  return data && { ...data, r: scrubbed(data.r, scope) }
+}
+
+export const scrubbed = (r: Record<string, { v?: unknown; e?: string }>, scope: Scope) =>
+  Object.fromEntries(
+    Object.entries(r).map(([k, v]) => [k, v.e === undefined ? v : { e: exec.said(v.e, scope) }]),
+  )
+
+/** The request's resolved queries, as the client cache seeds them (failures are left for the client to retry). */
+export function wire(scope: Scope): Wire[] {
+  return [...scope.entries.values()]
+    .filter((e) => e.done && e.e === undefined)
+    .map((e) => [e.id, e.input, e.v, e.tags])
+}

package/src/server/prerender.ts

@@ -0,0 +1,60 @@
+import type { Merged } from '@weft-js/core/ssr'
+import { pathPages } from '../derive.mjs'
+import { esc } from './text'
+import { fill } from './payload'
+import type { Manifest, Resolved, RouteModule } from './types'
+
+export function makePrerender(
+  manifest: Manifest,
+  mod: (file?: string) => RouteModule | undefined,
+  resolve: (path: string, request: Request) => Promise<Resolved>,
+  finished: (r: Resolved, request: Request) => Promise<Merged>,
+) {
+  /** Every path `weft build` prerenders: pages from `prerender`, and the card of each page that has a generated one. */
+  async function prerenderPaths(request: Request): Promise<string[]> {
+    const paths: string[] = []
+    for (const route of manifest.routes) {
+      if (route.kind !== 'page') continue
+      const p = mod(route.file)?.prerender
+      const given = typeof p === 'function' ? await p() : p
+      const list: Record<string, string>[] =
+        given === true ? [{}] : (given ?? (route.params.length ? [] : [{}]))
+      for (const params of list) {
+        const path = fill(route.pattern, params, route.splat)
+        const r = await resolve(path, request)
+        if (given && r.status === 200) paths.push(path)
+        const image = (await finished(r, request)).og.image
+        if (
+          r.status === 200 &&
+          typeof image === 'object' &&
+          image &&
+          image.url.startsWith('/_weft/og/')
+        )
+          paths.push(image.url.replace(/\?.*/, ''))
+      }
+    }
+    return paths
+  }
+
+  /**
+   * Build mode (research 20 §4.3): the card URLs `weft build` prerenders, queued through Nitro's `x-nitro-prerender`.
+   * It's a header, so a big site's list comes a page at a time: too long a header is an error that Nitro's client
+   * logs and carries on from, and the build ends with no cards.
+   */
+  let listing: Promise<string[][]> | undefined
+  async function prerenderList(request: Request, url: URL): Promise<Response> {
+    const pages = await (listing ??= prerenderPaths(request).then((p) => pathPages(p)))
+    const n = Number(url.searchParams.get('page') ?? 0)
+    const paths = [
+      ...(pages[n] ?? []),
+      ...(n + 1 < pages.length ? [`/_weft/og-routes?page=${n + 1}`] : []),
+    ]
+    // HTML, because Nitro's prerenderer only follows links (and this header) from HTML responses.
+    const list = paths.map((p) => `<a href="${esc(p)}">${esc(p)}</a>`).join('\n')
+    return new Response(`<!doctype html>\n<meta name="robots" content="noindex">\n${list}\n`, {
+      headers: { 'content-type': 'text/html; charset=utf-8', 'x-nitro-prerender': paths.join(',') },
+    })
+  }
+
+  return prerenderList
+}