@weft-js/start 0.1.1 → 0.1.2

package/src/vite/dev.mjs

@@ -0,0 +1,102 @@
+import { existsSync, readFileSync, readdirSync, realpathSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import { here } from './shared.mjs'
+
+/** Dev, in place of the bare JSON a page gets when its code won't load: this tab can't take an update, so it reloads. */
+const NOT_LOADING = `<!doctype html><meta charset="utf-8"><title>This page failed to load</title>
+<body style="font:16px system-ui;padding:2rem"><h1>This page failed to load</h1><p>The error is in the terminal. This tab reloads when you save a fix.</p>
+<script type="module">
+import { createHotContext } from '/@vite/client'
+const hot = createHotContext('/@weft/not-loading')
+for (const event of ['vite:afterUpdate', 'weft:refresh']) hot.on(event, () => location.reload())
+</script>`
+
+export function waitingForAFix(req, res, next) {
+  if (!req.headers.accept?.includes('text/html')) return next()
+  const { writeHead, end } = res
+  const json = (headers) =>
+    /json/.test(
+      String(
+        Array.isArray(headers)
+          ? headers.flat().join(' ')
+          : headers && Object.entries(headers).flat().join(' '),
+      ) + res.getHeader('content-type'),
+    )
+  let failed = false
+  res.writeHead = function (status, ...rest) {
+    failed = status >= 500 && json(rest.at(-1))
+    if (!failed) return writeHead.call(this, status, ...rest)
+    res.statusCode = status
+    return this
+  }
+  const write = res.write
+  res.write = function (...args) {
+    return failed ? true : write.apply(this, args)
+  }
+  res.end = function (...args) {
+    if (!failed && !(res.statusCode >= 500 && !res.headersSent && json()))
+      return end.apply(this, args)
+    res.setHeader('content-type', 'text/html')
+    res.removeHeader('content-length')
+    return end.call(this, NOT_LOADING)
+  }
+  next()
+}
+
+/** Whether an update to `mod` stops at a module that accepts it. */
+export function reaches(mod, seen = new Set()) {
+  if (mod.isSelfAccepting || mod.acceptedHmrDeps?.size) return true
+  if (seen.has(mod)) return true
+  seen.add(mod)
+  return (
+    mod.importers.size > 0 &&
+    [...mod.importers].every((m) => m.acceptedHmrDeps?.has(mod) || reaches(m, seen))
+  )
+}
+
+/** Ask open pages for the server's new answer, once the server's own reload has been told. A burst of saves is one ask. */
+const asking = new WeakMap()
+export function refresh(vite, rel, say = true, queries = true) {
+  if (!vite) return
+  clearTimeout(asking.get(vite))
+  asking.set(
+    vite,
+    setTimeout(() => {
+      if (say)
+        vite.config.logger.info(
+          `weft: ${rel} runs on the server: refreshing the page's data, state kept`,
+          { timestamp: true },
+        )
+      vite.ws.send({ type: 'custom', event: 'weft:refresh', data: { queries } })
+    }, 50),
+  )
+}
+
+export function packageDirs(root) {
+  const req = createRequire(join(root, 'package.json'))
+  const own = createRequire(join(here, 'vite.mjs'))
+  const out = []
+  for (const name of ['@weft-js/core/vite', 'nitro/package.json']) {
+    // each at its package root
+    for (const r of [req, own]) {
+      try {
+        out.push(dirname(realpathSync(r.resolve(name))))
+        break
+      } catch {}
+    }
+  }
+  return out
+}
+
+/** The project asks for shapes: a `pending="shape"`, or a read of `.shape`. */
+export function usesShapes(root) {
+  const src = join(root, 'src')
+  if (!existsSync(src)) return false
+  return readdirSync(src, { recursive: true, withFileTypes: true }).some(
+    (f) =>
+      f.isFile() &&
+      /\.[jt]sx?$/.test(f.name) &&
+      /pending="shape"|\.shape\b/.test(readFileSync(join(f.parentPath, f.name), 'utf8')),
+  )
+}

package/src/vite/entries.mjs

@@ -0,0 +1,145 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+import { scanRequired } from '../live-target.mjs'
+import { here, V, purgeFile, INLINE_SHEETS, SHEET_PIECES, ROUTE_ASSET_BYTES } from './shared.mjs'
+
+export function serverEntry(clientEntry, dev, root) {
+  return `import { createHandler } from ${JSON.stringify(join(here, 'server.tsx'))}
+import { chunks, lazy, manifest, modules, routeCss, statics } from '${V.routes}'
+import '${V.fns}'
+import context from '${V.context}'
+import auth from '${V.auth}'
+import migrations from '${V.migrations}'
+import media from '${V.media}'
+import realtime from '${V.realtime}'
+import extensions from '${V.extensions}'
+import * as app from '${V.app}'
+import assets from '${clientEntry}?assets=client'
+import { preloads } from 'weft:fonts/preloads'
+${dev ? '' : `import { parse, purge } from ${JSON.stringify(purgeFile)}\n`}const fetch = createHandler({ manifest, modules, statics, chunks, lazy, context, auth, migrations, media, realtime, liveRequired: ${JSON.stringify(scanRequired(root).map((r) => r.name))}, extensions, site: app.site, build: app.build, dev: app.dev, fonts: app.fonts(), timeout: app.timeout, hold: app.hold, routeAssetBytes: ${dev ? 'null' : `'${ROUTE_ASSET_BYTES}'`}, assets: { entry: assets.entry, js: assets.js, get css() { return routeCss(assets.css) }, fonts: preloads, inline: ${dev ? 'undefined' : `'${INLINE_SHEETS}'`}, pieces: ${dev ? 'undefined' : `'${SHEET_PIECES}'`}, critical: ${dev ? 'undefined' : '{ parse, purge }'} },
+  // H005–H008, Q002–Q014, A002–A004, F002–F003, M017 and R-codes found while serving: the server log, in dev and production.
+  onDiagnostic: d => console.warn(\`[weft] \${d.code} \${d.severity}\${d.route ? \` (\${d.route})\` : ''}: \${d.message.replace(/^[A-Z]{1,3}\\d{3}:? /, '')}\`) })
+export default { fetch }
+${dev ? "import { acceptScopeReruns } from '@weft-js/core/hmr'\nacceptScopeReruns()\n" : ''}`
+}
+
+/**
+ * A `server.extension` provider runs only for an app with `src/<key>.server.ts`, the file that says it wants it (P118):
+ * the provider is loaded on the first request and handed that file's default export. No provider gives an empty list.
+ */
+export function extensionsModule(root, abs) {
+  const slot = join(root, '.weft', 'slots', 'server.extension.ts')
+  const keys = existsSync(slot)
+    ? Object.entries(
+        JSON.parse(/providers = (\{.*\}) as const/.exec(readFileSync(slot, 'utf8'))?.[1] ?? '{}'),
+      )
+        .filter(([, name]) => name)
+        .map(([key]) => key)
+    : []
+  const files = keys.flatMap((key) => {
+    const f = ['ts', 'mts', 'js', 'mjs']
+      .map((x) => `src/${key}.server.${x}`)
+      .find((x) => existsSync(abs(x)))
+    return f ? [[key, abs(f)]] : []
+  })
+  if (!files.length) return 'export default []\n'
+  return `import { load } from 'weft:slot/server.extension'\n${files.map(([, f], i) => `import app${i} from ${JSON.stringify(f)}\n`).join('')}export default [${files.map(([key], i) => `{ key: ${JSON.stringify(key)}, load: () => load(${JSON.stringify(key)}).then(extend => extend(app${i})) }`).join(', ')}]\n`
+}
+
+/** Dev serves from the project; a built server from the directory it runs in (or `WEFT_MEDIA_DIR`). */
+export function mediaModule(root, dev) {
+  const slot = join(root, '.weft', 'slots', 'media.server.ts')
+  if (!existsSync(slot) || readFileSync(slot, 'utf8').includes('provider = null'))
+    return 'export default undefined\n'
+  const at = dev ? JSON.stringify(root) : 'undefined'
+  if (!existsSync(join(root, '.weft', 'slots', 'media.encode.ts')))
+    return `import { load } from 'weft:slot/media.server'\nexport default () => load().then(m => m.at(${at}))\n`
+  return `import { load } from 'weft:slot/media.server'
+import { load as encoder, providers } from 'weft:slot/media.encode'
+const encode = async () => Object.fromEntries(await Promise.all(Object.keys(providers).filter(k => providers[k]).map(async k => [k, await encoder(k)])))
+export default () => Promise.all([load(), encode()]).then(([m, e]) => m.at(${at}, e))
+`
+}
+
+export const busBound = (root) => {
+  const slot = join(root, '.weft', 'slots', 'realtime.bus.ts')
+  return existsSync(slot) && readFileSync(slot, 'utf8').includes('provider = {')
+}
+
+/** A bus in `src/realtime.server.ts` wins over the plugin's, like any explicit choice. */
+export const busModule = (file, from) => `import { load, provider } from 'weft:slot/realtime.bus'
+import { slotBus } from ${JSON.stringify(join(from, 'bus.ts'))}
+${file ? `import own from ${JSON.stringify(file)}` : 'const own = undefined'}
+export default { ...own, bus: own?.bus ?? slotBus(provider.plugin, load) }
+`
+
+export function appModule({ site, build, dev, fonts, timeout, hold }) {
+  return `export const site = ${JSON.stringify(site)}
+export const build = ${JSON.stringify(build)}
+export const dev = ${dev}
+export const timeout = ${timeout ?? 'undefined'}
+export const hold = ${hold ?? 'undefined'}
+const raw = ${JSON.stringify(fonts)}
+let decoded
+export function fonts() {
+  return (decoded ??= raw.map(f => ({ ...f, data: Uint8Array.from(atob(f.data), c => c.charCodeAt(0)) })))
+}
+`
+}
+
+/**
+ * The fonts every card can use, resolved at build and shipped inside the server bundle (research 20 §4.2: a render
+ * never fetches fonts). `Inter:400,700` → `@fontsource/inter`'s latin WOFF2 files, from the app or from @weft-js/start.
+ */
+export function cardFonts(manifest, abs, defaults, root, own = {}) {
+  const specs = new Set(defaults)
+  for (const f of [...manifest.routes.map((r) => r.card), manifest.defaultCard].filter(Boolean)) {
+    const m = /export\s+const\s+fonts\s*=\s*\[([^\]]*)\]/.exec(readFileSync(abs(f), 'utf8'))
+    if (m) for (const s of m[1].matchAll(/['"]([^'"]+)['"]/g)) specs.add(s[1])
+  }
+  const requires = [
+    createRequire(join(root, 'package.json')),
+    createRequire(join(here, 'vite.mjs')),
+  ]
+  const out = []
+  // The app's own faces (`site.card.fonts`, filled in by the text plugin): the card's title and text look like the app.
+  for (const f of [own.display, own.body].filter(Boolean)) {
+    const path = join(root, f.src)
+    if (existsSync(path) && !out.some((x) => x.name === f.family))
+      out.push({
+        name: f.family,
+        weight: f.weight ?? 400,
+        style: 'normal',
+        data: readFileSync(path).toString('base64'),
+      })
+  }
+  for (const spec of specs) {
+    const [family, weights = '400'] = spec.split(':')
+    const pkg = family.toLowerCase().replace(/\s+/g, '-')
+    for (const w of weights.split(',')) {
+      const [weight, italic] = [Number.parseInt(w), /i(talic)?$/.test(w)]
+      const file = `@fontsource/${pkg}/files/${pkg}-latin-${weight}-${italic ? 'italic' : 'normal'}.woff2`
+      const path = requires
+        .map((r) => {
+          try {
+            return r.resolve(file)
+          } catch {
+            return undefined
+          }
+        })
+        .find(Boolean)
+      if (!path)
+        throw new Error(
+          `weft: card font \`${spec}\` needs \`@fontsource/${pkg}\` installed (looked for ${file})`,
+        )
+      out.push({
+        name: family,
+        weight,
+        style: italic ? 'italic' : 'normal',
+        data: readFileSync(path).toString('base64'),
+      })
+    }
+  }
+  return out
+}

package/src/vite/module-hooks.mjs

@@ -0,0 +1,288 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join, relative, resolve } from 'node:path'
+import { readMigrations } from '../migrations.mjs'
+import { routeTypes } from '../routes.mjs'
+import { assetsOnly } from './assets.mjs'
+import { entryCss, projectParent, watchEntryCandidates } from './shape-entry-css.mjs'
+import { resolveImportedOverride, shapeOverride } from './shape-override.mjs'
+import {
+  clientRoutes,
+  serverRoutes,
+  devStyles,
+  markLinks,
+  skeletonExport,
+} from './route-modules.mjs'
+import {
+  serverEntry,
+  extensionsModule,
+  mediaModule,
+  busBound,
+  busModule,
+  appModule,
+  cardFonts,
+} from './entries.mjs'
+import { stripServerExports, serverExports } from './syntax.mjs'
+import { isServerModule, definesFns, withIds, clientStubs } from './server-functions.mjs'
+import { here, V, DEFAULT_FONTS, ASSETS, ISLAND, ENTRY_SHEETS } from './shared.mjs'
+
+export const resolveId = (s) => ({
+  filter: {
+    id: /^(virtual:weft\/|@weft-js\/start\/(db|auth|bus|list|rust|sidecar)(\/|$)|@weft-js\/(realtime-(redis|nats|durable-object)|db-[\w-]+)$|sharp$)/,
+  },
+  handler(source, importer) {
+    // Sharp's addon can't be bundled, so it stays external and Nitro traces it, which it can only do from the app.
+    if (source === 'sharp') {
+      if (s.dev || !importer?.includes('plugin-media')) return
+      try {
+        createRequire(join(s.root, 'package.json')).resolve('sharp')
+      } catch {
+        this.warn(
+          "M017: `sharp` isn't a dependency of this app, so the built server can't load it for the media route.\n  fix: add `sharp` to dependencies",
+        )
+        return
+      }
+      return { id: 'sharp', external: true }
+    }
+    if (source.startsWith('@weft-js/')) {
+      if (this.environment?.config.consumer === 'client')
+        this.error(
+          `Q012: \`${source}\` reached the client graph${importer ? ` from ${relative(s.root, importer)}` : ''}: the database, auth and buses run on the server only.\n  fix: import it from a server module (src/server/**, *.server.ts) or a route's \`load\``,
+        )
+      return
+    }
+    const base = source.replace(/\?.*$/, '')
+    if (
+      Object.values(V).includes(base) ||
+      base.startsWith(ISLAND) ||
+      base.startsWith('virtual:weft/shape-override/')
+    )
+      return s.id(source)
+  },
+})
+
+export const load = (s) => ({
+  filter: { id: /^\0virtual:weft\// },
+  async handler(raw) {
+    // `virtual:weft/entry-client?assets=client` (no src/entry.client.ts) is Nitro's assets plugin's to load.
+    if (/[?&]assets\b/.test(raw)) return
+    const which = raw.slice(1).replace(/\?.*$/, '')
+    const client = this.environment?.config.consumer === 'client'
+    if (which.startsWith('virtual:weft/shape-override/'))
+      return overrideModule(this, s, which, client)
+    if (which.startsWith(ISLAND)) {
+      const { islands } = await s.hydration(this)
+      const i = islands[Number(which.slice(ISLAND.length))]
+      return `export { $i${i.index} as default } from ${JSON.stringify(i.file)}\n`
+    }
+    if (which === V.routes) return routesModule(this, s, client)
+    if (which === V.app)
+      return appModule({
+        site: s.options.site ?? {},
+        build: s.build,
+        dev: s.dev,
+        fonts: cardFonts(
+          s.manifest,
+          s.abs,
+          s.options.fonts ?? DEFAULT_FONTS,
+          s.root,
+          s.options.site?.card?.fonts,
+        ),
+        timeout: s.options.timeout,
+        hold: s.options.hold,
+      })
+    if (which === V.server) return serverEntry(s.clientEntry(), s.dev, s.root)
+    if (which === V.fns)
+      return s.serverModules.map((f) => `import ${JSON.stringify(s.abs(f))}`).join('\n') + '\n'
+    if (which === V.context || which === V.auth || which === V.realtime)
+      return configModule(s, which)
+    if (which === V.extensions) return extensionsModule(s.root, s.abs)
+    if (which === V.migrations)
+      return s.dev
+        ? `import { readMigrations } from ${JSON.stringify(join(here, 'migrations.mjs'))}\nexport default () => readMigrations(${JSON.stringify(s.root)})\n`
+        : `const list = ${JSON.stringify(readMigrations(s.root))}\nexport default () => list\n`
+    if (which === V.media) return mediaModule(s.root, s.dev)
+    if (which === V.client)
+      return `import { start } from ${JSON.stringify(join(here, 'client.tsx'))}\nimport * as routes from '${V.routes}'\n${ENTRY_SHEETS}start(routes)\n`
+  },
+})
+
+export const transform = (s) => ({
+  filter: { id: /\.[jt]sx?(\?weft-assets)?$|\/vite\/dist\/client\/client\.mjs$/ },
+  async handler(code, file) {
+    const path = file.replace(/\?.*$/, '')
+    if (file.endsWith(ASSETS))
+      return { code: await assetsOnly(this, code, path, s.root, s.words), map: null }
+    if (path.endsWith('/client.mjs')) return s.dev ? markLinks(s.root) + code : undefined
+    if (path.includes('/node_modules/')) return
+    const client = this.environment?.config.consumer === 'client'
+    if (client && path === s.clientEntry()) return { code: ENTRY_SHEETS + code, map: null }
+    const rel = relative(s.root, path).split('\\').join('/')
+    if (isServerModule(rel)) {
+      const out = client
+        ? clientStubs(code, path, rel, await s.shapeTable(this))
+        : withIds(code, path, rel)
+      if (client && s.dev) s.stubs.set(path, out)
+      return out === code ? undefined : { code: out, map: null }
+    }
+    if (client && !rel.startsWith('..')) {
+      const q003 = definesFns(code, path)
+      if (q003)
+        this.error(
+          `Q003: ${rel} defines \`${q003.name}\` with \`${q003.kind}()\`, but it isn't a server module: its \`run\` and imports would ship to the client.\n  fix: move it to src/server/ or a *.server.ts file`,
+        )
+    }
+    if (!client) return
+    if (
+      !s.manifest.routes.some((r) => r.file === rel) &&
+      !s.manifest.layouts.some((l) => l.file === rel)
+    )
+      return
+    if (s.dev) s.loaders.set(file, serverExports(code, file))
+    const out = stripServerExports(code, file)
+    // @weft-js/core/hmr saw the server exports and left this to Vite, but they're gone and the rest is components.
+    if (
+      s.dev &&
+      out !== code &&
+      !/^export (?!default\b|\{ \S+\$shape as default\$shape \})/m.test(out) &&
+      !out.includes('import.meta.hot.accept(')
+    )
+      return { code: `${out}\nif (import.meta.hot) import.meta.hot.accept();\n`, map: null }
+    return out === code ? undefined : { code: out, map: null }
+  },
+})
+
+export const api = (s) => ({
+  manifest: () => s.manifest ?? s.scan(),
+  types: () => routeTypes(s.manifest ?? s.scan()),
+  serverModules: () => (s.manifest ?? s.scan(), s.serverModules),
+})
+
+/** What a route's imported skeleton gave: a file to watch, an override to use, or nothing (said so). */
+function took(ctx, { s, root, file, found, depend, overrides }) {
+  if (found?.file) depend(found.file, file)
+  if (found?.code) overrides.set(file, found.code)
+  // An imported function that isn't plain markup is as unusable as a local one.
+  else unusableSkeleton(ctx, s, root, file)
+}
+
+/** A route that exports `skeleton` in a form navigation can't use gets none at all: say so once, with what works. */
+function unusableSkeleton(ctx, s, root, file) {
+  if (!/export\s+const\s+skeleton\b/.test(readFileSync(file, 'utf8'))) return
+  const warned = (s.skeletonWarned ??= new Set())
+  if (warned.has(file)) return
+  warned.add(file)
+  ctx.warn(
+    `${relative(root, file)}: \`export const skeleton\` can't be used, so this route shows no skeleton. ` +
+      'Name a function in this file (or one imported from its own file) whose JSX is plain markup: div, span, section, ' +
+      'article, main, header, footer, p, h1-h6, ul, ol, li, with only string class and data-* attributes. ' +
+      '`export const skeleton = false` turns it off. `weft docs start` has an example.',
+  )
+}
+
+async function overrideModule(ctx, s, which, client) {
+  if (!client || !which.endsWith('.tsx')) ctx.error('Invalid skeleton override request')
+  const file = decodeURIComponent(which.slice('virtual:weft/shape-override/'.length, -4))
+  const levels = [...s.manifest.layouts, ...s.manifest.routes]
+  if (!levels.some((level) => s.abs(level.file) === file)) ctx.error('Unknown skeleton override')
+  const imported = await resolveImportedOverride(ctx, file, s.root ?? dirname(file))
+  const code = shapeOverride(file) ?? imported?.code
+  if (!code) ctx.error(`Unsafe or missing skeleton override: ${file}`)
+  ctx.addWatchFile(file)
+  if (imported?.file) ctx.addWatchFile(imported.file)
+  return code
+}
+
+function configModule(s, which) {
+  const name = which.slice('virtual:weft/'.length)
+  const f = ['ts', 'mts', 'js', 'mjs']
+    .map((x) => `src/${name}.server.${x}`)
+    .find((x) => existsSync(s.abs(x)))
+  if (which === V.realtime && busBound(s.root)) return busModule(f && s.abs(f), here)
+  return f ? `export { default } from ${JSON.stringify(s.abs(f))}\n` : 'export default undefined\n'
+}
+
+async function routesModule(ctx, s, client) {
+  const run = { owner: s.shapeEntryOwner, scan: undefined }
+  if (client && s.shapeEntryClosed) throw new Error('entry style scan outlived its server')
+  if (client)
+    run.scan = s.shapeScanActive = s.shapeScanGeneration = (s.shapeScanGeneration ?? 0) + 1
+  try {
+    const p = await s.hydration(ctx)
+    if (client) return await clientRoutesModule(ctx, s, p, run)
+    return serverRoutes(
+      s.manifest,
+      s.abs,
+      s.dev
+        ? await devStyles(s.vite.environments.client, s.manifest, s.abs, s.clientEntry())
+        : undefined,
+      p,
+    )
+  } finally {
+    if (client && s.shapeScanActive === run.scan) delete s.shapeScanActive
+  }
+}
+
+async function scanOverrides(ctx, s, all, root) {
+  const overrides = new Map()
+  const dependencies = new Map()
+  const missing = new Set()
+  const depend = (target, file) => {
+    if (!dependencies.has(target)) dependencies.set(target, new Set())
+    dependencies.get(target).add(file)
+  }
+  for (const file of all) {
+    if (!/\.[jt]sx$/.test(file) || skeletonExport(file) !== 'unavailable') continue
+    const found = await resolveImportedOverride(ctx, file, root, (spec) => {
+      const candidate = resolve(dirname(file), spec)
+      if (projectParent(root, candidate)) {
+        const path = candidate.replace(/\\/g, '/')
+        missing.add(path)
+        depend(path, file)
+      }
+    })
+    took(ctx, { s, root, file, found, depend, overrides })
+  }
+  return { overrides, dependencies, missing }
+}
+
+async function clientRoutesModule(ctx, s, p, run) {
+  const entry = s.clientEntry()
+  const entryFile = entry.startsWith('virtual:') ? join(here, 'client.tsx') : entry
+  const levels = [...s.manifest.layouts, ...s.manifest.routes]
+  const all = [...new Set(levels.map((r) => s.abs(r.file)))]
+  const root = s.root ?? dirname(entryFile)
+  const { overrides, dependencies, missing } = await scanOverrides(ctx, s, all, root)
+  const files = all.filter(
+    (file) =>
+      /\.[jt]sx$/.test(file) &&
+      (overrides.has(file) || ['generated', 'custom'].includes(skeletonExport(file))),
+  )
+  const sources = await Promise.all(files.map((file) => entryCss(ctx, file, root)))
+  const shared = await entryCss(ctx, entryFile, root)
+  if (run.owner && run.owner !== s.shapeEntryOwner)
+    throw new Error('entry style scan outlived its server')
+  if (run.scan !== s.shapeScanGeneration) throw new Error('entry style scan superseded')
+  for (const source of sources) {
+    for (const [file, signature] of source.signatures) shared.signatures.set(file, signature)
+    for (const file of source.candidates) shared.candidates.add(file)
+    for (const file of source.missing) shared.missing.add(file)
+  }
+  for (const file of missing) {
+    shared.candidates.add(file)
+    shared.missing.add(file)
+  }
+  const css = {
+    entry: shared.styles,
+    levels: new Map(files.map((file, i) => [file, sources[i].styles])),
+    overrides,
+    build: s.build || null,
+  }
+  const output = clientRoutes(s.manifest, s.abs, p, css)
+  s.shapeEntrySignatures = shared.signatures
+  s.shapeEntryCandidates = shared.candidates
+  s.shapeEntryMissing = shared.missing
+  s.shapeOverrideDependencies = dependencies
+  if (s.dev) watchEntryCandidates(s.vite, shared.missing, root)
+  return output
+}