@weft-js/start 0.1.0 → 0.1.2

package/src/vite/shape-entry-css.mjs

@@ -0,0 +1,187 @@
+import { existsSync, realpathSync } from 'node:fs'
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path'
+import { shapeBody, shapeCssSource, shapeStyleSpecifier } from './route-modules.mjs'
+
+// Follow existing ancestors so a symlink cannot turn an in-project watch into an outside watch.
+export function projectParent(root, file) {
+  try {
+    const project = realpathSync(root)
+    let dir = dirname(file)
+    while (!existsSync(dir) && dirname(dir) !== dir) dir = dirname(dir)
+    const parent = realpathSync(dir)
+    const rel = relative(project, parent)
+    if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return
+    return parent
+  } catch {
+    return undefined
+  }
+}
+
+// Resolvers may preserve symlinks, so both the apparent and actual file must be app source.
+function appSource(root, file) {
+  const blocked = (base, path) => {
+    const rel = relative(base, path).replace(/\\/g, '/')
+    return (
+      rel === '..' ||
+      rel.startsWith('../') ||
+      isAbsolute(rel) ||
+      /(^|\/)node_modules\//.test(rel) ||
+      /(^|\/)server\//.test(rel) ||
+      /\.server\.[cm]?[jt]sx?$/.test(rel)
+    )
+  }
+  try {
+    return !blocked(root, file) && !blocked(realpathSync(root), realpathSync(file))
+  } catch {
+    return false
+  }
+}
+
+// Only static runtime import/export edges can lead to a stylesheet here.
+function sources(file) {
+  return shapeBody(file).filter((node) => {
+    if (node.type === 'ImportDeclaration') {
+      return (
+        node.importKind !== 'type' &&
+        (!node.specifiers.length || node.specifiers.some((item) => item.importKind !== 'type'))
+      )
+    }
+    return (
+      (node.type === 'ExportNamedDeclaration' || node.type === 'ExportAllDeclaration') &&
+      node.exportKind !== 'type' &&
+      node.source
+    )
+  })
+}
+
+function signature(nodes) {
+  return JSON.stringify(
+    nodes.map((node) => [
+      node.type,
+      node.source.value,
+      node.type === 'ImportDeclaration' && !node.specifiers.length,
+    ]),
+  )
+}
+
+/** Signature of the static dependency edges relevant to entry styles. */
+export function entryCssSignature(file) {
+  return signature(sources(file))
+}
+
+/** Collect safely resolvable local entry dependencies and their CSS in source order. */
+export async function entryCss(ctx, entry, root) {
+  const seen = new Set()
+  const styles = new Set()
+  const signatures = new Map()
+  const candidates = new Set()
+  const missing = new Set()
+  const key = (file) => file.replace(/\\/g, '/')
+  const visit = async (file) => {
+    if (seen.has(file) || seen.size >= 256) return
+    seen.add(file)
+    const nodes = sources(file)
+    signatures.set(file, signature(nodes))
+    for (const node of nodes) {
+      const spec = node.source.value
+      if (
+        node.type === 'ImportDeclaration' &&
+        !node.specifiers.length &&
+        shapeStyleSpecifier(spec)
+      ) {
+        const css = await shapeCssSource(ctx, file, spec, () => {
+          if (/^\.{1,2}\//.test(spec)) {
+            const candidate = resolve(dirname(file), spec)
+            if (projectParent(root, candidate)) {
+              candidates.add(key(candidate))
+              missing.add(key(candidate))
+            }
+          }
+        })
+        if (css) {
+          styles.add(css)
+          candidates.add(key(css))
+        }
+        continue
+      }
+      if (/[?#]/.test(spec) || /^(?:[a-z][\w+.-]*:|\/\/)/i.test(spec)) continue
+      const found = await ctx.resolve(spec, file, { skipSelf: true })
+      const local = /^\.{1,2}\//.test(spec)
+      const target = found?.id ?? (!found && local ? resolve(dirname(file), spec) : undefined)
+      if (found?.external || !target || !isAbsolute(target)) continue
+      const rel = relative(root, target).replace(/\\/g, '/')
+      if (
+        rel === '..' ||
+        rel.startsWith('../') ||
+        isAbsolute(rel) ||
+        /(^|\/)node_modules\//.test(rel) ||
+        /(^|\/)server\//.test(rel) ||
+        /\.server(?:\.[cm]?[jt]sx?)?$/.test(rel)
+      )
+        continue
+      if (!found) {
+        if (projectParent(root, target)) {
+          candidates.add(key(target))
+          missing.add(key(target))
+        }
+        continue
+      }
+      if (!/\.[cm]?[jt]sx?$/.test(target) || !appSource(root, target)) continue
+      candidates.add(key(target))
+      await visit(target)
+    }
+  }
+  await visit(entry)
+  return { styles: [...styles], signatures, candidates, missing }
+}
+
+/** Watch a missing candidate's nearest existing parent for later creation. */
+export function watchEntryCandidates(server, candidates, root) {
+  if (!server || !root) return
+  const dirs = new Set()
+  for (const file of candidates) {
+    if (existsSync(file)) continue
+    const dir = projectParent(root, file)
+    if (dir) dirs.add(dir)
+  }
+  for (const dir of dirs) server.watcher.add(dir)
+}
+
+/** Clear this server's entry metadata without changing the shared Vite watcher. */
+export function entryWatchLifecycle(state, server, modes) {
+  state.shapeScanGeneration = (state.shapeScanGeneration ?? 0) + 1
+  state.shapeEntryOwner = server
+  delete state.shapeEntryClosed
+  const close = server.close
+  server.close = async function (...args) {
+    if (state.shapeEntryOwner === server) {
+      state.shapeEntryClosed = true
+      state.shapeScanGeneration = (state.shapeScanGeneration ?? 0) + 1
+    }
+    try {
+      return await close.apply(this, args)
+    } finally {
+      if (state.shapeEntryOwner === server) {
+        delete state.shapeEntryOwner
+        delete state.shapeEntrySignatures
+        delete state.shapeEntryCandidates
+        delete state.shapeEntryMissing
+        delete state.shapeOverrideDependencies
+        if (state.vite === server) state.vite = undefined
+        modes.clear()
+      }
+    }
+  }
+}
+
+/** Match a Vite file event against exact or extensionless local candidates. */
+export function entryCandidate(candidates, file) {
+  const path = file.replace(/\\/g, '/')
+  const stem = path.replace(/\.[cm]?[jt]sx?$/, '')
+  return (
+    candidates?.has(path) ||
+    candidates?.has(stem) ||
+    (stem.endsWith('/index') && candidates?.has(stem.slice(0, -'/index'.length))) ||
+    false
+  )
+}

package/src/vite/shape-override.mjs

@@ -0,0 +1,226 @@
+import { readFileSync, realpathSync } from 'node:fs'
+import { isAbsolute, relative } from 'node:path'
+import { parse } from './syntax.mjs'
+
+const TAGS = new Set([
+  'div',
+  'span',
+  'main',
+  'section',
+  'article',
+  'header',
+  'footer',
+  'p',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'ul',
+  'ol',
+  'li',
+])
+
+function inert(node) {
+  if (node.type === 'JSXText') return true
+  if (node.type === 'JSXFragment') return node.children.every(inert)
+  if (node.type !== 'JSXElement') return false
+  const open = node.openingElement
+  if (open.name.type !== 'JSXIdentifier' || !TAGS.has(open.name.name)) return false
+  if (
+    !open.attributes.every(
+      (attr) =>
+        attr.type === 'JSXAttribute' &&
+        attr.name.type === 'JSXIdentifier' &&
+        (attr.name.name === 'class' ||
+          attr.name.name === 'className' ||
+          /^data-[a-z0-9-]+$/.test(attr.name.name)) &&
+        attr.value?.type === 'Literal' &&
+        typeof attr.value.value === 'string',
+    )
+  )
+    return false
+  return node.children.every(inert)
+}
+
+// A function declaration has a mutable binding. Reject every other occurrence,
+// including shadowed names, rather than guessing whether a write is reachable.
+function isolated(body, declaration, reference) {
+  const name = declaration.id?.name
+  if (!name) return true
+  const allowed = new Set([declaration.id, reference])
+  const safe = (node) => {
+    if (!node || typeof node !== 'object') return true
+    if (Array.isArray(node)) return node.every(safe)
+    if (node.type === 'Identifier' && node.name === 'eval') return false
+    if (node.type === 'Identifier' && node.name === name && !allowed.has(node)) return false
+    return Object.values(node).every(safe)
+  }
+  return safe(body)
+}
+
+/** Extract only a closed, static local override. Never evaluate the source module. */
+export function shapeOverride(file) {
+  const source = readFileSync(file, 'utf8')
+  const parsed = parse(file, source)
+  if (parsed.errors.length) return
+  const body = parsed.program.body
+  const exports = body.filter(
+    (n) =>
+      n.type === 'ExportNamedDeclaration' &&
+      n.declaration?.type === 'VariableDeclaration' &&
+      n.declaration.kind === 'const',
+  )
+  const declarations = exports
+    .flatMap((n) => n.declaration.declarations)
+    .filter((d) => d.id.type === 'Identifier' && d.id.name === 'skeleton')
+  if (declarations.length !== 1 || declarations[0].init?.type !== 'Identifier') return
+  if (
+    body.some(
+      (n) =>
+        n.type === 'ExportAllDeclaration' ||
+        (n.type === 'ExportNamedDeclaration' &&
+          n.specifiers.some((s) => (s.exported.name ?? s.exported.value) === 'skeleton')),
+    )
+  )
+    return
+  const name = declarations[0].init.name
+  const candidates = body.flatMap((n) => {
+    const decl =
+      n.type === 'ExportNamedDeclaration' || n.type === 'ExportDefaultDeclaration'
+        ? n.declaration
+        : n
+    if (decl?.type === 'FunctionDeclaration' && decl.id?.name === name) return [decl]
+    if (decl?.type === 'VariableDeclaration' && decl.kind === 'const')
+      return decl.declarations.filter((d) => d.id.type === 'Identifier' && d.id.name === name)
+    return []
+  })
+  if (candidates.length !== 1) return
+  const candidate = candidates[0]
+  if (candidate.type === 'FunctionDeclaration') {
+    if (!isolated(body, candidate, declarations[0].init)) return
+    return component(source, candidate)
+  }
+  return component(source, candidate.init)
+}
+
+function component(source, fn) {
+  while (fn?.type === 'ParenthesizedExpression') fn = fn.expression
+  if (
+    !fn ||
+    !['ArrowFunctionExpression', 'FunctionExpression', 'FunctionDeclaration'].includes(fn.type) ||
+    fn.async ||
+    fn.generator ||
+    fn.params.length
+  )
+    return
+  let body =
+    fn.body.type === 'BlockStatement' &&
+    fn.body.body.length === 1 &&
+    fn.body.body[0].type === 'ReturnStatement'
+      ? fn.body.body[0].argument
+      : fn.body
+  // `return (` and a multi-line tree, as a formatter writes it.
+  while (body?.type === 'ParenthesizedExpression') body = body.expression
+  if (!body || !inert(body)) return
+  const jsx = source.slice(body.start, body.end)
+  return `export default function Skeleton() { return (${jsx}); }`
+}
+
+// Follow one direct import only; imported source must itself export the component.
+export function importedOverride(file) {
+  const parsed = parse(file, readFileSync(file, 'utf8'))
+  if (parsed.errors.length) return
+  const body = parsed.program.body
+  const declarations = body
+    .flatMap((n) =>
+      n.type === 'ExportNamedDeclaration' &&
+      n.declaration?.type === 'VariableDeclaration' &&
+      n.declaration.kind === 'const'
+        ? n.declaration.declarations
+        : [],
+    )
+    .filter((d) => d.id.name === 'skeleton')
+  if (declarations.length !== 1 || declarations[0].init?.type !== 'Identifier') return
+  if (
+    body.some(
+      (n) =>
+        n.type === 'ExportAllDeclaration' ||
+        (n.type === 'ExportNamedDeclaration' &&
+          n.specifiers.some((s) => (s.exported.name ?? s.exported.value) === 'skeleton')),
+    )
+  )
+    return
+  const name = declarations[0].init.name
+  const matches = body.flatMap((n) =>
+    n.type === 'ImportDeclaration' && n.importKind !== 'type'
+      ? n.specifiers
+          .filter((s) => s.local.name === name && s.importKind !== 'type')
+          .map((s) => ({ spec: n.source.value, binding: s }))
+      : [],
+  )
+  if (matches.length !== 1) return
+  const { spec, binding } = matches[0]
+  if (binding.type === 'ImportDefaultSpecifier') return { spec, name: 'default' }
+  if (binding.type === 'ImportSpecifier') return { spec, name: binding.imported.name }
+}
+
+function dedicated(file, name) {
+  const source = readFileSync(file, 'utf8')
+  const parsed = parse(file, source)
+  if (parsed.errors.length) return
+  const matches = []
+  for (const node of parsed.program.body) {
+    if (
+      node.type === 'ExportAllDeclaration' ||
+      (node.type === 'ExportNamedDeclaration' && node.source)
+    )
+      return
+    if (name === 'default' && node.type === 'ExportDefaultDeclaration')
+      matches.push(node.declaration)
+    if (
+      node.type === 'ExportNamedDeclaration' &&
+      node.declaration?.type === 'FunctionDeclaration' &&
+      node.declaration.id?.name === name
+    )
+      matches.push(node.declaration)
+    if (
+      node.type === 'ExportNamedDeclaration' &&
+      node.declaration?.type === 'VariableDeclaration' &&
+      node.declaration.kind === 'const'
+    ) {
+      for (const item of node.declaration.declarations)
+        if (item.id.type === 'Identifier' && item.id.name === name) matches.push(item.init)
+    }
+  }
+  if (matches.length !== 1) return
+  if (matches[0].type === 'FunctionDeclaration' && !isolated(parsed.program.body, matches[0]))
+    return
+  return component(source, matches[0])
+}
+
+/** Resolve a direct dedicated source through Vite, bounded to non-server project files. */
+export async function resolveImportedOverride(ctx, file, root, onMissing) {
+  const requested = importedOverride(file)
+  if (!requested || /[?#]/.test(requested.spec) || /^(?:[a-z][\w+.-]*:|\/\/)/i.test(requested.spec))
+    return
+  const found = await ctx.resolve(requested.spec, file, { skipSelf: true })
+  if (!found && /^\.{1,2}\//.test(requested.spec)) onMissing?.(requested.spec)
+  if (!found || found.external || !isAbsolute(found.id) || !/\.[jt]sx$/.test(found.id)) return
+  const blocked = (base, target) => {
+    const rel = relative(base, target).replace(/\\/g, '/')
+    return (
+      rel === '..' ||
+      rel.startsWith('../') ||
+      isAbsolute(rel) ||
+      /(^|\/)node_modules\//.test(rel) ||
+      /(^|\/)server\//.test(rel) ||
+      /\.server\.[jt]sx$/.test(rel)
+    )
+  }
+  try {
+    if (blocked(root, found.id) || blocked(realpathSync(root), realpathSync(found.id))) return
+    return { file: found.id, code: dedicated(found.id, requested.name) }
+  } catch {}
+}

package/src/vite/shared.mjs

@@ -0,0 +1,51 @@
+import { LATE_SHEETS, REFUSED_SHEETS } from '../inline.mjs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/** This folder, wherever the package is installed. */
+export const here = dirname(fileURLToPath(new URL('../vite.mjs', import.meta.url)))
+export const V = {
+  routes: 'virtual:weft/routes',
+  app: 'virtual:weft/app',
+  server: 'virtual:weft/entry-server',
+  client: 'virtual:weft/entry-client',
+  fns: 'virtual:weft/fns',
+  context: 'virtual:weft/context',
+  auth: 'virtual:weft/auth',
+  migrations: 'virtual:weft/migrations',
+  media: 'virtual:weft/media',
+  realtime: 'virtual:weft/realtime',
+  extensions: 'virtual:weft/extensions',
+}
+export const DEFAULT_FONTS = ['Inter:400,700']
+export const SHEET = '/@weft-sheet/'
+export const ASSETS = '?weft-assets'
+export const ISLAND = 'virtual:weft/island/'
+export const PRELOAD =
+  'Per page, from the HTML: an island that loads with the page, or a lazy one in about the first 900px, is modulepreloaded (fetched, not run). The rest load when needed. Save-Data: lazy ones are not preloaded, and wait for interaction.'
+export const NOT_ASSET = /\.[cm]?[jt]sx?$/
+export const INLINE_SHEETS = '__WEFT_INLINE_SHEETS__'
+export const ROUTE_ASSET_BYTES = '__WEFT_ROUTE_ASSET_BYTES__'
+// A page's critical CSS with `criticalCss: false` uses the build's own reachability rules.
+export const purgeFile = createRequire(join(here, 'vite.mjs'))
+  .resolve('@weft-js/core/node-purge')
+  .split('\\')
+  .join('/')
+export const SHEET_PIECES = '__WEFT_SHEET_PIECES__'
+
+/**
+ * First in any entry, an app's own too. The page's inline script is the fast path and a CSP can refuse it, so a page
+ * that runs at all never stays on its first-paint rules.
+ */
+export const ENTRY_SHEETS = `${LATE_SHEETS}\n${REFUSED_SHEETS}\n`
+
+/**
+ * weft's own packages from an install, as one chunk of icons and one of what two routes share. Left alone they're a chunk
+ * per component: 31 scripts and 18 sheets for an admin page (Solid's: 16 in all), each its own request and its own
+ * compression, and 53 KB against 46. An app's own code splits as it likes.
+ */
+export const KIT_CHUNKS = [
+  { name: 'icons', test: /[\\/]node_modules[\\/]@weft-js[\\/]warp-icons[\\/]/, priority: 2 },
+  { name: 'kit', test: /[\\/]node_modules[\\/]@weft-js[\\/]/, minShareCount: 2, priority: 1 },
+]

package/src/vite/sheets.mjs

@@ -0,0 +1,92 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import { join } from 'node:path'
+import { pieces } from '@weft-js/core/node-purge'
+import { planSheets, reach } from '../sheets.mjs'
+import { INLINE_CSS_MAX } from '../inline.mjs'
+
+/**
+ * The client build's stylesheets a page can carry, `{ href: css }`, read by the server build so every preset has them
+ * with no file system. Left out: one a relative `url()` would break, and one that could close its `<style>`.
+ */
+export function inlineSheets(outDir, base, limit = INLINE_CSS_MAX) {
+  const dir = join(outDir, 'assets')
+  if (!existsSync(dir)) return {}
+  const sheets = {}
+  for (const name of readdirSync(dir).filter((f) => f.endsWith('.css'))) {
+    const css = readFileSync(join(dir, name), 'utf8')
+    if (
+      css.length <= limit &&
+      !/<\/style|<!--/i.test(css) &&
+      !/url\(\s*(?!["']?(?:\/|data:|https?:|#|%23))/.test(css)
+    )
+      sheets[`${base}assets/${name}`] = css
+  }
+  return sheets
+}
+
+/** How long a replaced sheet stays in the build, for pages cached before the deploy that replaced it: a CDN's longest day. */
+const KEEP_SHEETS_MS = 30 * 864e5
+
+/**
+ * Writes the build's combined stylesheets beside the chunks' own. A route's list is what its chunks import, the entry's
+ * included, plus the sheets of the islands in the files it imports.
+ */
+export function combineSheets(dir, bundle, manifest, abs, islands) {
+  const chunks = Object.values(bundle).filter((f) => f.type === 'chunk')
+  const holding = (id) => chunks.filter((c) => c.moduleIds.some((m) => m.split('?')[0] === id))
+  const sheetsOf = (start, seen = new Set()) =>
+    start.flatMap((c) => {
+      if (seen.has(c)) return []
+      seen.add(c)
+      return [
+        ...(c.viteMetadata?.importedCss ?? []),
+        ...sheetsOf(c.imports.map((i) => bundle[i]).filter(Boolean), seen),
+      ]
+    })
+  const entry = sheetsOf(chunks.filter((c) => c.isEntry))
+  const routes = manifest.routes
+    .map((r) => {
+      const levels = [
+        ...manifest.layouts.filter((l) => r.layouts.includes(l.id)).map((l) => abs(l.file)),
+        abs(r.file),
+      ]
+      const files = reach(levels)
+      const held = islands.filter((i) => files.has(i.file)).map((i) => i.file)
+      return [...new Set([...entry, ...sheetsOf([...levels, ...held].flatMap(holding))])]
+    })
+    .filter((list) => list.length)
+  const plan = planSheets(routes, (name) => readFileSync(join(dir, name), 'utf8'))
+  for (const [name, css] of Object.entries(plan.files)) writeFileSync(join(dir, name), css)
+  return plan
+}
+
+/**
+ * The first-paint table of the build's sheets (node/purge.mjs), and the last builds' combined sheets kept beside them: a
+ * page cached across a deploy links the ones it was built with. `.weft/sheets` carries them, so CI has to keep that folder.
+ */
+export function sheetPieces(outDir, base, plan, keep, root) {
+  const dir = join(outDir, 'assets')
+  const href = (name) => `${base}${name}`
+  const names = [...new Set([plan.shared, ...plan.routes].filter(Boolean).flatMap((s) => s.has))]
+  const sheets = names
+    .map((n) => [href(n), readFileSync(join(outDir, n), 'utf8')])
+    .filter(([, css]) => !/<\/style|<!--/i.test(css))
+  const old = join(root, '.weft/sheets')
+  mkdirSync(old, { recursive: true })
+  for (const f of Object.keys(plan.files))
+    writeFileSync(join(old, f.replace('assets/', '')), plan.files[f])
+  for (const f of readdirSync(old)) {
+    if (Date.now() - statSync(join(old, f)).mtimeMs > KEEP_SHEETS_MS) rmSync(join(old, f))
+    else if (!existsSync(join(dir, f))) writeFileSync(join(dir, f), readFileSync(join(old, f)))
+  }
+  const shape = (s) => s && { href: href(s.file), has: s.has.map(href) }
+  return { ...pieces(sheets, keep), shared: shape(plan.shared), routes: plan.routes.map(shape) }
+}

package/src/vite/state.mjs

@@ -0,0 +1,89 @@
+import { existsSync, mkdirSync, statSync, writeFileSync } from 'node:fs'
+import { join, relative, resolve } from 'node:path'
+import { solve } from '@weft-js/core/hydration'
+import { scanRoutes } from '../routes.mjs'
+import { scanServerModules } from './server-functions.mjs'
+import { usesShapes } from './dev.mjs'
+import { PRELOAD, V } from './shared.mjs'
+
+/** Partial hydration's view of the project, redone in dev when a file it read changed. */
+async function hydration(s, ctx) {
+  const { options } = s
+  if (options.hydration === 'full' || !s.compile) return undefined
+  if (s.plan && !s.dev) return s.plan
+  if (s.plan && Date.now() - s.planned < 200) return s.plan
+  s.planned = Date.now()
+  if (s.plan) {
+    const p = await s.plan
+    if (
+      !p.stamps.some(
+        (f) => statSync(f, { throwIfNoEntry: false })?.mtimeMs !== s.facts.get(f)?.mtime,
+      )
+    )
+      return p
+  }
+  const entries = [...s.manifest.routes, ...s.manifest.layouts].map((r) => s.abs(r.file))
+  s.plan = solve({
+    entries,
+    lazy: (options.hydration ?? 'lazy') === 'lazy',
+    transform: s.compile,
+    rel: (f) => relative(s.root, f).split('\\').join('/'),
+    cache: s.facts,
+    resolve: async (spec, from) => (await ctx.resolve(spec, from, { skipSelf: true }))?.id,
+  })
+  const done = await s.plan
+  try {
+    mkdirSync(join(s.root, '.weft'), { recursive: true })
+    writeFileSync(
+      join(s.root, '.weft', 'hydration.json'),
+      `${JSON.stringify({ islands: done.islands.map((i) => i.id), loads: done.loads, preload: PRELOAD, diagnostics: done.diagnostics, files: done.report }, null, 2)}\n`,
+    )
+  } catch {}
+  return done
+}
+
+/** Read the query shape table once per edit. */
+async function shapeTable(s, ctx) {
+  if (!usesShapes(s.root)) return undefined
+  const stamp = s.serverModules.map((f) => statSync(s.abs(f)).mtimeMs).join()
+  if (s.shapes?.stamp === stamp) return s.shapes.table
+  try {
+    const { readShapes } = await import('../contract.mjs')
+    s.shapes = { stamp, table: await readShapes({ root: s.root, site: s.options.site }) }
+    return s.shapes.table
+  } catch (e) {
+    ctx.warn(
+      `the query shapes couldn't be read, so skeletons only have last-seen shapes: ${e.message}`,
+    )
+  }
+}
+
+export function createState(options) {
+  const s = {
+    options,
+    root: options.root ?? process.cwd(),
+    dev: false,
+    build: '',
+    serverModules: [],
+    loaders: new Map(),
+    stubs: new Map(),
+    planned: 0,
+    facts: new Map(),
+  }
+  s.abs = (f) => resolve(s.root, f)
+  s.id = (v) => (v.startsWith('virtual:') ? '\0' + v : v)
+  s.scan = () => {
+    s.serverModules = scanServerModules(s.root)
+    return (s.manifest = scanRoutes(
+      s.root,
+      options.routesDir ? resolve(s.root, options.routesDir) : undefined,
+    ))
+  }
+  s.hydration = (ctx) => hydration(s, ctx)
+  s.shapeTable = (ctx) => shapeTable(s, ctx)
+  s.clientEntry = () =>
+    existsSync(join(s.root, 'src', 'entry.client.ts'))
+      ? join(s.root, 'src', 'entry.client.ts')
+      : V.client
+  return s
+}