@weft-js/start 0.1.1 → 0.1.2

package/src/view.tsx

@@ -5,6 +5,20 @@
 
 import { untrack } from '@weft-js/core'
 import { active, level, type RouteState } from './router'
+import type { PreparedRouteShape } from './run/shape-preparation'
+import { retainRouteView } from './run/retain-view'
+
+function ShapeTree(props: { shapes: PreparedRouteShape[]; depth: number }): unknown {
+  // A skeleton is a snapshot: the outlet swaps the whole tree when its shapes change.
+  const item = untrack(() => props.shapes[props.depth])
+  if (!item) return null
+  const Shape = item.component as (props: { children: unknown }) => unknown
+  return (
+    <Shape>
+      <ShapeTree shapes={props.shapes} depth={props.depth + 1} />
+    </Shape>
+  )
+}
 
 // The route state travels as a prop, not a context: a level's view runs later, in the hole that shows it, under that
 // hole's owner. `active.route` is the state of the render in progress (a server pass is synchronous; the client has one).
@@ -15,33 +29,104 @@ export function App(props: { route: RouteState }) {
 
 export function Level(props: { route: RouteState; depth: number }) {
   const route = untrack(() => props.route)
-  const lv = level(route, untrack(() => props.depth))
+  const lv = level(
+    route,
+    untrack(() => props.depth),
+  )
   const next = untrack(() => props.depth) + 1
   const view = () => {
     const id = lv.id.value
     if (id === undefined) return null
     const html = route.mount ? lv.html.value : undefined
-    if (html !== undefined) return route.mount!(html, untrack(() => props.depth), () => <Level route={route} depth={next} />)
-    const Route = route.comps[id] as ((props: { params: Record<string, string>; data: unknown; children: unknown }) => unknown) | undefined
+    if (html !== undefined)
+      return route.mount!(
+        html,
+        untrack(() => props.depth),
+        () => <Level route={route} depth={next} />,
+      )
+    const Route = route.comps[id] as
+      | ((props: { params: Record<string, string>; data: unknown; children: unknown }) => unknown)
+      | undefined
     if (!Route) return null
-    const body = () => <Route params={lv.params.value} data={lv.data.value}><Level route={route} depth={next} /></Route>
-    return route.around ? route.around(untrack(() => props.depth), id, body) : body()
+    const body = () => (
+      <Route params={lv.params.value} data={lv.data.value}>
+        <Level route={route} depth={next} />
+      </Route>
+    )
+    return route.around
+      ? route.around(
+          untrack(() => props.depth),
+          id,
+          body,
+        )
+      : body()
   }
-  return <>{view()}</>
+  const display = retainRouteView(view, () => {
+    const shape = lv.shape.value
+    return shape ? (
+      <div inert aria-hidden="true" style="display:contents">
+        <ShapeTree shapes={shape} depth={0} />
+      </div>
+    ) : undefined
+  })
+  return <>{display()}</>
+}
+
+/** True when `path` is `href`, or with `section`, any page under it (a top link for `/components` on `/components/modal`). */
+export function isCurrent(path: string, href: string, section = false) {
+  if (path === href) return true
+  return section && href !== '/' && path.startsWith(`${href.replace(/\/$/, '')}/`)
 }
 
 /**
- * `<a>` with `aria-current="page"` while its path is the current one. Any same-origin `<a href>` navigates on the
- * client (start() listens for clicks); Link only adds the current-page state. In a static level the server writes it
- * and start() updates it after a navigation, so a Link needs no code there.
+ * `<a>` with `aria-current="page"` while its path is the current one, or with `match="section"` any page under it, as a
+ * site's top links want. Any same-origin `<a href>` navigates on the client (start() listens for clicks); Link only
+ * adds the current-page state. In a static level the server writes it and start() updates it after a navigation, so a
+ * Link needs no code there.
  *
  * @weft static
  */
-export function Link({ href, children, ...rest }: Record<string, unknown> & { href: string; class?: string; rel?: string; children?: unknown }) {
+export function Link({
+  href,
+  match,
+  children,
+  ...rest
+}: Record<string, unknown> & {
+  href: string
+  match?: 'page' | 'section'
+  class?: string
+  rel?: string
+  children?: unknown
+}) {
   const route = active.route
   return (
-    <a {...rest} href={href} aria-current={route && route.path.value.replace(/[?#].*/, '') === href ? 'page' : undefined}>
+    <a
+      {...rest}
+      href={href}
+      data-match={match === 'section' ? 'section' : undefined}
+      aria-current={
+        route && isCurrent(route.path.value.replace(/[?#].*/, ''), href, match === 'section')
+          ? 'page'
+          : undefined
+      }
+    >
       {children}
     </a>
   )
 }
+
+/**
+ * The current page's path, without its search or hash: the request's on the server, and on the client the accepted
+ * destination from the moment a navigation starts. Reading it is reactive.
+ *
+ * Use it to keep shared chrome mounted across sections: one layout above them renders the sidebar and picks its items
+ * from the path, so moving between sections swaps the items and the page, and the sidebar stays. A layout per section
+ * would be replaced, sidebar and all, on every move between them.
+ *
+ * What reads it runs in the browser, since it changes there: a static level's HTML would be swapped whole on each move.
+ *
+ * @weft client
+ */
+export function currentPath(): string {
+  return active.route?.path.value.replace(/[?#].*/, '') ?? '/'
+}

package/src/vite/asset-bytes.mjs

@@ -0,0 +1,95 @@
+const byText = (a, b) => (a < b ? -1 : a > b ? 1 : 0)
+
+// A closure names emitted files, so callers can union routes without counting a shared file twice.
+function closure(bundle, roots) {
+  const seen = new Set()
+  let complete = true
+  const visit = (file) => {
+    if (seen.has(file)) return
+    seen.add(file)
+    const item = bundle[file]
+    if (item?.type !== 'chunk') return
+    if (
+      !Array.isArray(item.imports) ||
+      !item.viteMetadata?.importedCss ||
+      !item.viteMetadata?.importedAssets
+    )
+      complete = false
+    for (const dep of item.imports ?? []) visit(dep)
+    for (const dep of item.viteMetadata?.importedCss ?? []) visit(dep)
+    for (const dep of item.viteMetadata?.importedAssets ?? []) visit(dep)
+  }
+  for (const file of roots) visit(file)
+  return { files: [...seen].sort(byText), complete }
+}
+
+function chunkFor(bundle, ids) {
+  const matches = Object.entries(bundle).filter(
+    ([, item]) =>
+      item.type === 'chunk' &&
+      ids.some((id) => item.facadeModuleId === id || Object.hasOwn(item.modules ?? {}, id)),
+  )
+  return matches.length === 1 ? matches[0][0] : undefined
+}
+
+/** Byte lengths of emitted static closures. Dynamic and external dependencies are not inferred. */
+export function assetBytes(bundle, read, manifest, abs) {
+  const routes = Object.fromEntries(
+    [...manifest.layouts, ...manifest.routes].map((route) => {
+      const file = abs(route.file)
+      const root = chunkFor(bundle, [file, `${file}?weft-assets`])
+      return [route.id, root ? closure(bundle, [root]) : null]
+    }),
+  )
+  const eagerRoot = chunkFor(bundle, ['\0virtual:weft/routes'])
+  const eager = eagerRoot ? closure(bundle, [eagerRoot]) : null
+  const owners = new Map()
+  for (const entry of [...Object.values(routes), eager]) {
+    for (const file of entry?.files ?? []) owners.set(file, (owners.get(file) ?? 0) + 1)
+  }
+  const shared = [...owners]
+    .filter(([, count]) => count > 1)
+    .map(([file]) => file)
+    .sort(byText)
+  const sharedSet = new Set(shared)
+  const files = Object.fromEntries(
+    [...owners.keys()].sort(byText).map((file) => {
+      const item = bundle[file]
+      let bytes = null
+      if (item) {
+        try {
+          bytes = read(file).length
+        } catch {
+          /* not emitted or not readable */
+        }
+      }
+      const kind = !item
+        ? 'unknown'
+        : item.type === 'chunk'
+          ? 'js'
+          : file.endsWith('.css')
+            ? 'css'
+            : 'asset'
+      return [file, { bytes, kind }]
+    }),
+  )
+  const size = (items) =>
+    items.some((file) => files[file].bytes === null)
+      ? null
+      : items.reduce((sum, file) => sum + files[file].bytes, 0)
+  const describe = (entry) =>
+    entry && {
+      files: entry.files,
+      bytes: entry.complete ? size(entry.files) : null,
+      uniqueBytes: entry.complete ? size(entry.files.filter((file) => !sharedSet.has(file))) : null,
+      sharedBytes: entry.complete ? size(entry.files.filter((file) => sharedSet.has(file))) : null,
+    }
+  return {
+    version: 1,
+    scope: 'vite-static-closure',
+    files,
+    shared,
+    routes: Object.fromEntries(Object.entries(routes).map(([id, items]) => [id, describe(items)])),
+    eager: describe(eager),
+  }
+}

package/src/vite/assets.mjs

@@ -0,0 +1,117 @@
+import { readFileSync } from 'node:fs'
+import { relative } from 'node:path'
+import { parse } from './syntax.mjs'
+import { isServerModule } from './server-functions.mjs'
+import { NOT_ASSET, ASSETS } from './shared.mjs'
+
+/** weft's own packages from an install: a static component's stylesheets are in them, and they ship source. */
+const KIT = /\/node_modules\/@weft-js\/.*\.[jt]sx?$/
+
+/**
+ * The stylesheets a kit import reaches, in import order, written straight into the static module: chained `?weft-assets`
+ * modules from a package with `sideEffects` would be shaken away. `names` follows a barrel only to the components named,
+ * so a page with one doesn't pull every component's sheet.
+ */
+async function kitAssets(ctx, file, names, seen, words) {
+  const id = names ? `${file}|${names.join()}` : file
+  if (seen.has(id)) return []
+  seen.add(id)
+  const code = readFileSync(file, 'utf8')
+  const body = parse(file, code).program.body
+  const wanted = (name) => !names || names.includes(name)
+  const makes = ({ declaration: d, specifiers }) =>
+    d?.declarations
+      ? d.declarations.some((v) => v.id.type !== 'Identifier' || names.includes(v.id.name))
+      : names.includes(d?.id?.name) ||
+        specifiers.some((s) => names.includes(s.exported.name ?? s.exported.value))
+  // Only a file that makes a name itself brings its own imports: one that passes it on is a barrel.
+  const own =
+    !names ||
+    body.some(
+      (n) =>
+        n.type === 'ExportDefaultDeclaration' ||
+        (n.type === 'ExportNamedDeclaration' && !n.source && makes(n)),
+    )
+  if (own) words?.add(code)
+  const out = []
+  for (const n of body) {
+    if (!n.source || n.importKind === 'type' || n.exportKind === 'type') continue
+    const all = n.type === 'ExportAllDeclaration'
+    const space = all && n.exported && (n.exported.name ?? n.exported.value) // `export * as K`: K is the whole module
+    const passed =
+      n.type === 'ExportNamedDeclaration' &&
+      n.specifiers
+        .filter((s) => s.exportKind !== 'type' && wanted(s.exported.name ?? s.exported.value))
+        .map((s) => s.local.name ?? s.local.value)
+    // A bare import runs whatever the importer wants from the file.
+    if (
+      n.type === 'ImportDeclaration'
+        ? !own && n.specifiers.length
+        : passed
+          ? !passed.length
+          : !all || (space && !wanted(space))
+    )
+      continue
+    if (/^@weft-js\/(?:core|start)($|\/)/.test(n.source.value)) continue
+    const target = (await ctx.resolve(n.source.value, file, { skipSelf: true }))?.id
+    if (!target) continue
+    const bare = target.replace(/\?.*$/, '')
+    if (!NOT_ASSET.test(bare))
+      out.push(`import ${JSON.stringify(target.startsWith('\0') ? n.source.value : bare)}`)
+    else if (KIT.test(bare))
+      out.push(
+        ...(await kitAssets(
+          ctx,
+          bare,
+          passed || (space ? undefined : all ? names : importedNames(n)),
+          seen,
+          words,
+        )),
+      )
+  }
+  return [...new Set(out)]
+}
+
+/** The value names an import takes, or undefined for the whole module (`import 'x'`, `import * as x`). */
+const importedNames = (n) => {
+  const names = (n.specifiers ?? [])
+    .filter((s) => s.type === 'ImportSpecifier' && s.importKind !== 'type')
+    .map((s) => (s.imported ?? s.local).name ?? (s.imported ?? s.local).value)
+  return names.length && n.specifiers.every((s) => s.type === 'ImportSpecifier') ? names : undefined
+}
+
+/**
+ * A static module in the client build: what it imports that isn't code (stylesheets, images), and the same of the
+ * modules it imports. Its class names go to the purge, which only sees client files.
+ */
+export async function assetsOnly(ctx, code, path, root, words) {
+  words?.add(code)
+  const ast = parse(path, code)
+  const out = []
+  const seen = new Set()
+  for (const n of ast.program.body) {
+    if (
+      !/^(ImportDeclaration|ExportNamedDeclaration|ExportAllDeclaration)$/.test(n.type) ||
+      !n.source ||
+      n.importKind === 'type' ||
+      n.exportKind === 'type'
+    )
+      continue
+    const spec = n.source.value
+    if (/^@weft-js\/(?:core|start)($|\/)/.test(spec)) continue
+    const file = (await ctx.resolve(spec, path, { skipSelf: true }))?.id
+    if (!file) continue
+    const bare = file.replace(/\?.*$/, '')
+    if (!NOT_ASSET.test(bare)) out.push(`import ${JSON.stringify(spec)}`)
+    else if (KIT.test(bare))
+      out.push(...(await kitAssets(ctx, bare, importedNames(n), seen, words)))
+    else if (
+      !bare.includes('/node_modules/') &&
+      !isServerModule(relative(root, bare).split('\\').join('/'))
+    )
+      out.push(`import ${JSON.stringify(bare + ASSETS)}`)
+  }
+  if (code.includes('@weft-js/core/style')) out.push(`import 'virtual:weft/groups.css'`)
+  out.push('export default null') // a chunk of only CSS is dropped, and the server looks this one up
+  return out.join('\n') + '\n'
+}

package/src/vite/config-hooks.mjs

@@ -0,0 +1,166 @@
+import { createHash } from 'node:crypto'
+import { readFileSync, realpathSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { isAbsolute, join, relative, resolve, sep, win32 } from 'node:path'
+import { searchForWorkspaceRoot } from 'vite'
+import { INLINE_CSS_MAX } from '../inline.mjs'
+import { packageDirs } from './dev.mjs'
+import { assetBytes } from './asset-bytes.mjs'
+import { combineSheets, sheetPieces, inlineSheets } from './sheets.mjs'
+import { here, V, KIT_CHUNKS, INLINE_SHEETS, SHEET_PIECES, ROUTE_ASSET_BYTES } from './shared.mjs'
+
+export const configHook = (s) =>
+  function (config, env) {
+    s.root = config.root ? resolve(config.root) : s.root
+    s.dev = env.command === 'serve'
+    s.scan()
+    return {
+      environments: {
+        client: {
+          build: {
+            rollupOptions: {
+              input: s.clientEntry(),
+              output: { advancedChunks: { groups: KIT_CHUNKS } },
+            },
+          },
+        },
+        ssr: { build: { rollupOptions: { input: V.server } } },
+      },
+      // The router-core server bundle and Takumi's addon stay external to the SSR graph; Nitro traces them.
+      ssr: {
+        noExternal: ['@weft-js/start', '@weft-js/warp', '@weft-js/warp-icons', '@weft-js/core'],
+        external: ['@takumi-rs/core'],
+      },
+      optimizeDeps: {
+        exclude: ['@weft-js/start', '@weft-js/warp', '@weft-js/warp-icons', '@weft-js/core'],
+      }, // they ship TSX for the weft plugin
+      // The runtime files of @weft-js/start, weft and Nitro are served from wherever they're installed (a linked package
+      // sits outside the app's root).
+      server: {
+        fs: { allow: [searchForWorkspaceRoot(s.root), join(here, '..'), ...packageDirs(s.root)] },
+      },
+      // One copy of the router: the app's route files and the generated entries import the same module.
+      resolve: {
+        alias: [
+          { find: /^@weft-js\/start$/, replacement: join(here, 'index.ts') },
+          { find: /^@weft-js\/start\/(client|server)$/, replacement: join(here, '$1.tsx') },
+          { find: /^@weft-js\/start\/media$/, replacement: join(here, 'media.ts') },
+        ],
+      },
+    }
+  }
+
+function emittedReader(dir) {
+  const root = realpathSync(dir)
+  const inside = (path) => {
+    const rel = relative(root, path)
+    return rel !== '' && rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)
+  }
+  return (file) => {
+    if (
+      typeof file !== 'string' ||
+      !file ||
+      isAbsolute(file) ||
+      win32.parse(file).root ||
+      file.includes('\\') ||
+      file.split('/').includes('..')
+    )
+      throw new Error('Invalid asset path')
+    const path = resolve(root, file)
+    if (!inside(path)) throw new Error('Asset outside output')
+    const real = realpathSync(path)
+    if (!inside(real)) throw new Error('Asset outside output')
+    return readFileSync(real)
+  }
+}
+
+export const writeBundle = (s) => ({
+  order: 'post',
+  async handler(out, bundle) {
+    if (!s.dev && this.environment?.config.consumer === 'client' && out.dir) {
+      const name = 'weft-route-assets.json'
+      if (bundle[name]) throw new Error(`Cannot overwrite emitted ${name}`)
+      const bytes = assetBytes(bundle, emittedReader(out.dir), s.manifest ?? s.scan(), s.abs)
+      bytes.build = s.build || null
+      writeFileSync(join(out.dir, name), JSON.stringify(bytes))
+      s.routeAssetBytes = bytes
+    }
+    if (
+      s.dev ||
+      this.environment?.config.consumer !== 'client' ||
+      s.options.site?.criticalCss === false ||
+      s.options.site?.inlineCss === false
+    )
+      return
+    s.sheetPlan = combineSheets(
+      out.dir,
+      bundle,
+      s.manifest ?? s.scan(),
+      s.abs,
+      (await s.hydration(this))?.islands ?? [],
+      s.options.site?.base ?? '/',
+    )
+  },
+})
+
+export const renderChunk = (s) => ({
+  order: 'post',
+  handler(code) {
+    const receiptToken = new RegExp(`["'\`]${ROUTE_ASSET_BYTES}["'\`]`)
+    const hasReceipt = receiptToken.test(code)
+    if (hasReceipt) {
+      let receipt = null
+      try {
+        const top = this.environment.getTopLevelConfig()
+        const client = resolve(s.root, top.environments.client.build.outDir)
+        const saved = JSON.parse(readFileSync(join(client, 'weft-route-assets.json'), 'utf8'))
+        if (s.build && saved.build === s.build) receipt = saved
+      } catch {
+        /* no matching client receipt */
+      }
+      code = code.replace(receiptToken, () => JSON.stringify(receipt))
+    }
+    const token = new RegExp(`["'\`]${INLINE_SHEETS}["'\`]`)
+    if (!token.test(code)) return hasReceipt ? { code, map: null } : null
+    const top = this.environment.getTopLevelConfig()
+    const client = resolve(s.root, top.environments.client.build.outDir)
+    code = code.replace(new RegExp(`["'\`]${SHEET_PIECES}["'\`]`), () =>
+      JSON.stringify(
+        s.sheetPlan &&
+          sheetPieces(client, top.base ?? '/', s.sheetPlan, s.options.site?.criticalKeep, s.root),
+      ),
+    )
+    // With a first-paint table the server reads none of these; without, a page too big to carry whole is split (`pageStyles`).
+    const sheets =
+      s.options.site?.inlineCss === false
+        ? {}
+        : inlineSheets(
+            client,
+            top.base ?? '/',
+            s.options.site?.criticalCss === false ? Infinity : INLINE_CSS_MAX,
+          )
+    return { code: code.replace(token, () => JSON.stringify(sheets)), map: null }
+  },
+})
+
+export const configResolved = (s) =>
+  function (config) {
+    // Each build is its own version, unless it's pinned: instances built apart that serve one deploy, or a
+    // reproducible build (SOURCE_DATE_EPOCH), have to agree on it.
+    s.build =
+      process.env.WEFT_BUILD_ID ||
+      createHash('sha256')
+        .update(process.env.SOURCE_DATE_EPOCH || String(Date.now()))
+        .digest('hex')
+        .slice(0, 8)
+    if (s.dev) s.build = 'dev'
+    s.root = config.root
+    const main = config.plugins.find((p) => p.name === 'weft')
+    s.words = config.plugins.find((p) => p.name === 'weft:purge')?.api
+    s.words?.add('data-weft styled') // gate.css reveals a mark a static page's HTML may hold alone
+    if (main?.api) {
+      s.compile = createRequire(join(here, 'vite.mjs'))('@weft-js/core/compiler').transform
+      main.api.islands = async (ctx, file) =>
+        (await s.hydration(ctx))?.files.get(file.replace(/\?.*$/, ''))
+    }
+  }

package/src/vite/dev-hooks.mjs

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync, watch } from 'node:fs'
+import { join, relative } from 'node:path'
+import { waitingForAFix, reaches, refresh } from './dev.mjs'
+import { serverExports } from './syntax.mjs'
+import { isServerModule } from './server-functions.mjs'
+import { SHEET, ASSETS, V } from './shared.mjs'
+
+export const configureServer = (s) =>
+  function (server) {
+    s.vite = server
+    // A `<link>` to a virtual sheet (`weft:fonts`): Vite only serves those as modules.
+    const sheet = async (req, res, next) => {
+      const css = await server.environments.client.pluginContainer
+        .load(decodeURIComponent(req.url.slice(1)))
+        .catch(() => undefined)
+      if (css == null) return next()
+      res.setHeader('content-type', 'text/css')
+      res.end(typeof css === 'string' ? css : css.code)
+    }
+    server.middlewares.use(SHEET, (req, res, next) => void sheet(req, res, next))
+    server.middlewares.use(waitingForAFix)
+    // A route file added or removed changes the virtual modules; edits to existing ones are ordinary HMR/reloads.
+    const dir = join(s.root, 'src')
+    if (!existsSync(dir)) return
+    const routesDir = relative(dir, join(s.root, s.manifest.dir)).split('\\').join('/')
+    const shape = () =>
+      JSON.stringify([
+        s.manifest.routes.map((r) => r.file),
+        s.manifest.layouts.map((l) => l.file),
+        s.serverModules,
+      ])
+    const changed = (file) => {
+      const rel = file.split('\\').join('/')
+      if (!rel.startsWith(routesDir + '/') && !isServerModule('src/' + rel)) return
+      // Saving a file can count as a rename, depending on the platform and the editor.
+      const before = shape()
+      s.scan()
+      if (shape() === before) return
+      for (const env of Object.values(server.environments)) {
+        for (const v of [V.routes, V.fns, V.context]) {
+          const m = env.moduleGraph.getModuleById('\0' + v)
+          if (m) env.moduleGraph.invalidateModule(m)
+        }
+      }
+      server.config.logger.info(
+        `weft: full reload: ${rel} was added or removed, so the routes changed`,
+        { timestamp: true },
+      )
+      server.ws.send({ type: 'full-reload' })
+    }
+    const w = watch(dir, { recursive: true }, (event, file) => {
+      if (event === 'rename' && file) changed(file)
+    })
+    // Not every runtime's recursive watch reports a new file, and Vite's watcher does.
+    for (const event of ['add', 'unlink'])
+      server.watcher.on(event, (file) => {
+        if (file.startsWith(dir)) changed(relative(dir, file))
+      })
+    // Close with the server (middleware mode, as `weft routes --meta` runs it, has no httpServer to listen on).
+    const close = server.close.bind(server)
+    server.close = () => (w.close(), close())
+  }
+
+export const hotUpdate = (s) =>
+  async function ({ file, modules }) {
+    const rel = relative(s.root, file).split('\\').join('/')
+    if (this.environment.config.consumer === 'server') {
+      // An edit can add or drop a stylesheet import: the next server load of the routes walks the graph again.
+      const m = this.environment.moduleGraph.getModuleById('\0' + V.routes)
+      if (m) this.environment.moduleGraph.invalidateModule(m)
+      // A static component or a server helper is in no browser's module graph, so nothing else would tell the tab.
+      if (
+        !s.vite?.environments.client.moduleGraph.getModulesByFile(file)?.size &&
+        this.environment.moduleGraph.getModulesByFile(file)?.size
+      )
+        refresh(s.vite, rel)
+      return
+    }
+    const route =
+      s.manifest.routes.some((r) => r.file === rel) ||
+      s.manifest.layouts.some((l) => l.file === rel)
+    if (route) {
+      const part = serverExports(readFileSync(file, 'utf8'), file)
+      // A level the server renders has no module in the page, and its `load` and `meta` are on the server too.
+      refresh(s.vite, rel, s.loaders.get(file) !== part, false)
+      s.loaders.set(file, part)
+    }
+    if (isServerModule(rel) && s.stubs.has(file) && modules.length) {
+      const before = s.stubs.get(file)
+      await Promise.all(
+        modules.map((m) => this.environment.transformRequest(m.url).catch(() => undefined)),
+      )
+      if (s.stubs.get(file) === before) return (refresh(s.vite, rel), [])
+    }
+    // A static route's stylesheet list: nothing runs it, so nothing has to take the update.
+    const live = modules.filter((m) => !m.url.endsWith(ASSETS))
+    if (live.some((m) => !reaches(m)))
+      this.environment.logger.info(
+        `weft: full reload: ${rel} exports more than components and nothing that imports it can take the update`,
+        { timestamp: true },
+      )
+    if (live.length < modules.length) return live
+  }