@weft-js/cli 0.1.1 → 0.1.3

package/src/project.mjs

@@ -9,15 +9,30 @@ import { relative } from 'node:path'
 import ts from 'typescript'
 import { local } from './alias.mjs'
 
-const exts = ['', '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts', '/index.jsx', '/index.js']
-const isComponentName = name => /^[A-Z]/.test(name)
+const exts = [
+  '',
+  '.tsx',
+  '.ts',
+  '.jsx',
+  '.js',
+  '/index.tsx',
+  '/index.ts',
+  '/index.jsx',
+  '/index.js',
+]
+const isComponentName = (name) => /^[A-Z]/.test(name)
 
 /** `a.b.c(…).d` → ['a', 'b']: the root identifier and the first member after it. */
 function chainRoot(expr) {
   let node = expr
   let member
   for (;;) {
-    if (ts.isParenthesizedExpression(node) || ts.isNonNullExpression(node) || ts.isAsExpression(node)) node = node.expression
+    if (
+      ts.isParenthesizedExpression(node) ||
+      ts.isNonNullExpression(node) ||
+      ts.isAsExpression(node)
+    )
+      node = node.expression
     else if (ts.isPropertyAccessExpression(node)) {
       member = node.name.text
       node = node.expression
@@ -37,9 +52,11 @@ function isInJsx(node, stop) {
 /** Identifiers an expression reads (not property names); `props.x` is kept as 'props.x'. */
 function identifiersIn(node) {
   const names = new Set()
-  const visit = n => {
-    if (ts.isPropertyAccessExpression(n) && ts.isIdentifier(n.expression)) names.add(`${n.expression.text}.${n.name.text}`)
-    if (ts.isIdentifier(n) && !(ts.isPropertyAccessExpression(n.parent) && n.parent.name === n)) names.add(n.text)
+  const visit = (n) => {
+    if (ts.isPropertyAccessExpression(n) && ts.isIdentifier(n.expression))
+      names.add(`${n.expression.text}.${n.name.text}`)
+    if (ts.isIdentifier(n) && !(ts.isPropertyAccessExpression(n.parent) && n.parent.name === n))
+      names.add(n.text)
     ts.forEachChild(n, visit)
   }
   visit(node)
@@ -55,44 +72,87 @@ function componentsOf(sf) {
     if (param && ts.isObjectBindingPattern(param.name)) {
       for (const el of param.name.elements) {
         if (el.dotDotDotToken || !ts.isIdentifier(el.name)) continue
-        const key = el.propertyName && ts.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text
+        const key =
+          el.propertyName && ts.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text
         props.set(el.name.text, key)
       }
     } else if (param && ts.isIdentifier(param.name)) propsIdent = param.name.text
     comps.push({ name, fn, props, propsIdent, derives: new Map(), lists: [], edges: [] })
   }
   for (const st of sf.statements) {
-    if (ts.isFunctionDeclaration(st) && st.name && isComponentName(st.name.text)) add(st.name.text, st)
-    if (ts.isFunctionDeclaration(st) && !st.name && st.modifiers?.some(m => m.kind === ts.SyntaxKind.DefaultKeyword)) add('default', st)
+    if (ts.isFunctionDeclaration(st) && st.name && isComponentName(st.name.text))
+      add(st.name.text, st)
+    if (
+      ts.isFunctionDeclaration(st) &&
+      !st.name &&
+      st.modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)
+    )
+      add('default', st)
     if (ts.isVariableStatement(st)) {
       for (const d of st.declarationList.declarations) {
-        if (ts.isIdentifier(d.name) && isComponentName(d.name.text) && d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer))) add(d.name.text, d.initializer)
+        if (
+          ts.isIdentifier(d.name) &&
+          isComponentName(d.name.text) &&
+          d.initializer &&
+          (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer))
+        )
+          add(d.name.text, d.initializer)
       }
     }
   }
-  for (const c of comps) {
-    const visit = n => {
-      if (ts.isVariableDeclaration(n) && ts.isIdentifier(n.name) && n.initializer && ts.isCallExpression(n.initializer)) {
-        const callee = n.initializer.expression.getText()
-        if (callee === 'derived' || callee === 'state.linked') c.derives.set(n.name.text, identifiersIn(n.initializer))
-      }
-      if (ts.isCallExpression(n) && ts.isPropertyAccessExpression(n.expression) && n.expression.name.text === 'map' && isInJsx(n, c.fn)) {
-        const cb = n.arguments[0]
-        const root = chainRoot(n.expression.expression)
-        if (root && cb && (ts.isArrowFunction(cb) || ts.isFunctionExpression(cb))) c.lists.push({ root, at: n.getStart() })
-      }
-      if ((ts.isJsxSelfClosingElement(n) || ts.isJsxOpeningElement(n)) && ts.isIdentifier(n.tagName) && isComponentName(n.tagName.text)) {
-        for (const attr of n.attributes.properties) {
-          if (!ts.isJsxAttribute(attr) || !attr.initializer || !ts.isJsxExpression(attr.initializer) || !attr.initializer.expression) continue
-          const root = chainRoot(attr.initializer.expression)
-          if (root) c.edges.push({ tag: n.tagName.text, prop: attr.name.getText(), root, at: attr.getStart() })
-        }
+  for (const c of comps) analyzeComponent(c)
+  return comps
+}
+
+function analyzeComponent(c) {
+  const visit = (n) => {
+    if (
+      ts.isVariableDeclaration(n) &&
+      ts.isIdentifier(n.name) &&
+      n.initializer &&
+      ts.isCallExpression(n.initializer)
+    ) {
+      const callee = n.initializer.expression.getText()
+      if (callee === 'derived' || callee === 'state.linked')
+        c.derives.set(n.name.text, identifiersIn(n.initializer))
+    }
+    if (
+      ts.isCallExpression(n) &&
+      ts.isPropertyAccessExpression(n.expression) &&
+      n.expression.name.text === 'map' &&
+      isInJsx(n, c.fn)
+    ) {
+      const cb = n.arguments[0]
+      const root = chainRoot(n.expression.expression)
+      if (root && cb && (ts.isArrowFunction(cb) || ts.isFunctionExpression(cb)))
+        c.lists.push({ root, at: n.getStart() })
+    }
+    if (
+      (ts.isJsxSelfClosingElement(n) || ts.isJsxOpeningElement(n)) &&
+      ts.isIdentifier(n.tagName) &&
+      isComponentName(n.tagName.text)
+    ) {
+      for (const attr of n.attributes.properties) {
+        if (
+          !ts.isJsxAttribute(attr) ||
+          !attr.initializer ||
+          !ts.isJsxExpression(attr.initializer) ||
+          !attr.initializer.expression
+        )
+          continue
+        const root = chainRoot(attr.initializer.expression)
+        if (root)
+          c.edges.push({
+            tag: n.tagName.text,
+            prop: attr.name.getText(),
+            root,
+            at: attr.getStart(),
+          })
       }
-      ts.forEachChild(n, visit)
     }
-    visit(c.fn.body ?? c.fn)
+    ts.forEachChild(n, visit)
   }
-  return comps
+  visit(c.fn.body ?? c.fn)
 }
 
 /**
@@ -101,31 +161,17 @@ function componentsOf(sf) {
  */
 export function projectView(files, pos) {
   // Only a W014 warning needs the project view, so most runs parse nothing here.
-  if (!files.some(f => f.diagnostics.some(d => d.code === 'W014' && d.severity === 'warning'))) return
-  const byAbs = new Map(files.map(f => [f.abs, f]))
-  for (const f of files) {
-    f.sf = ts.createSourceFile(f.abs, f.text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX)
-    f.comps = componentsOf(f.sf)
-    f.imports = new Map()
-    for (const st of f.sf.statements) {
-      if (!ts.isImportDeclaration(st) || !st.importClause || !ts.isStringLiteral(st.moduleSpecifier)) continue
-      const spec = st.moduleSpecifier.text
-      const base = local(f.abs, spec)
-      if (!base) continue
-      const target = exts.map(e => base + e).find(p => byAbs.has(p))
-      if (!target) continue
-      if (st.importClause.name) f.imports.set(st.importClause.name.text, { file: target, name: 'default' })
-      const named = st.importClause.namedBindings
-      if (named && ts.isNamedImports(named)) for (const el of named.elements) f.imports.set(el.name.text, { file: target, name: (el.propertyName ?? el.name).text })
-    }
-  }
+  if (!files.some((f) => f.diagnostics.some((d) => d.code === 'W014' && d.severity === 'warning')))
+    return
+  const byAbs = new Map(files.map((f) => [f.abs, f]))
+  parseProject(files, byAbs)
 
   const lookup = (file, tag) => {
-    const own = file.comps.find(c => c.name === tag)
+    const own = file.comps.find((c) => c.name === tag)
     if (own) return { file, comp: own }
     const imp = file.imports.get(tag)
     const target = imp && byAbs.get(imp.file)
-    const comp = target?.comps.find(c => c.name === imp.name)
+    const comp = target?.comps.find((c) => c.name === imp.name)
     return comp ? { file: target, comp } : null
   }
 
@@ -136,7 +182,8 @@ export function projectView(files, pos) {
     if (comp.props.has(name)) return new Set([comp.props.get(name)])
     if (name === comp.propsIdent && member) return new Set([member])
     const out = new Set()
-    for (const dep of comp.derives.get(name) ?? []) for (const p of propsRead(comp, dep.split('.'), seen)) out.add(p)
+    for (const dep of comp.derives.get(name) ?? [])
+      for (const p of propsRead(comp, dep.split('.'), seen)) out.add(p)
     return out
   }
 
@@ -145,12 +192,14 @@ export function projectView(files, pos) {
     const id = `${file.abs}#${comp.name}#${prop}`
     if (seen.has(id)) return null
     seen.add(id)
-    for (const list of comp.lists) if (propsRead(comp, list.root).has(prop)) return { file, at: list.at, via: [] }
+    for (const list of comp.lists)
+      if (propsRead(comp, list.root).has(prop)) return { file, at: list.at, via: [] }
     for (const edge of comp.edges) {
       if (!propsRead(comp, edge.root).has(prop)) continue
       const next = lookup(file, edge.tag)
       const hit = next && reachesList(next.file, next.comp, edge.prop, seen)
-      if (hit) return { ...hit, via: [{ file, at: edge.at, tag: edge.tag, prop: edge.prop }, ...hit.via] }
+      if (hit)
+        return { ...hit, via: [{ file, at: edge.at, tag: edge.tag, prop: edge.prop }, ...hit.via] }
     }
     return null
   }
@@ -160,15 +209,75 @@ export function projectView(files, pos) {
     if (name === box) return true
     if (seen.has(name)) return false
     seen.add(name)
-    return [...(comp?.derives.get(name) ?? [])].some(dep => readsBox(comp, dep.split('.'), box, seen))
+    return [...(comp?.derives.get(name) ?? [])].some((dep) =>
+      readsBox(comp, dep.split('.'), box, seen),
+    )
   }
 
+  promoteFindings(files, pos, readsBox, lookup, reachesList)
+}
+
+/** The box a flagged `.map` call writes: `box.value = …map(…)` or `const box = …map(…)`. */
+function boxOf(sf, offset) {
+  let found
+  const visit = (n) => {
+    if (found) return
+    if (ts.isCallExpression(n) && n.getStart() === offset) found = n
+    else if (n.pos <= offset && offset < n.end) ts.forEachChild(n, visit)
+  }
+  visit(sf)
+  for (let n = found; n; n = n.parent) {
+    if (ts.isBinaryExpression(n) && n.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const left = n.left
+      if (
+        ts.isPropertyAccessExpression(left) &&
+        left.name.text === 'value' &&
+        ts.isIdentifier(left.expression)
+      )
+        return left.expression.text
+      return null
+    }
+    if (ts.isVariableDeclaration(n)) return ts.isIdentifier(n.name) ? n.name.text : null
+  }
+  return null
+}
+
+export const relPath = (root, abs) => relative(root, abs).split('\\').join('/')
+
+function parseProject(files, byAbs) {
+  for (const f of files) {
+    f.sf = ts.createSourceFile(f.abs, f.text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX)
+    f.comps = componentsOf(f.sf)
+    f.imports = new Map()
+    for (const st of f.sf.statements) {
+      if (
+        !ts.isImportDeclaration(st) ||
+        !st.importClause ||
+        !ts.isStringLiteral(st.moduleSpecifier)
+      )
+        continue
+      const spec = st.moduleSpecifier.text
+      const base = local(f.abs, spec)
+      if (!base) continue
+      const target = exts.map((e) => base + e).find((p) => byAbs.has(p))
+      if (!target) continue
+      if (st.importClause.name)
+        f.imports.set(st.importClause.name.text, { file: target, name: 'default' })
+      const named = st.importClause.namedBindings
+      if (named && ts.isNamedImports(named))
+        for (const el of named.elements)
+          f.imports.set(el.name.text, { file: target, name: (el.propertyName ?? el.name).text })
+    }
+  }
+}
+
+function promoteFindings(files, pos, readsBox, lookup, reachesList) {
   for (const f of files) {
     for (const d of f.diagnostics) {
       if (d.code !== 'W014' || d.severity !== 'warning' || !d.offset) continue
       const box = boxOf(f.sf, d.offset[0])
       if (!box) continue
-      const owners = f.comps.filter(c => c.fn.pos <= d.offset[0] && d.offset[0] < c.fn.end)
+      const owners = f.comps.filter((c) => c.fn.pos <= d.offset[0] && d.offset[0] < c.fn.end)
       for (const comp of owners.length ? owners : f.comps) {
         let hit = null
         let edge
@@ -185,9 +294,13 @@ export function projectView(files, pos) {
         d.project = true
         d.why =
           `\`.map(p => ({ ...p, … }))\` gives every item a new identity on each update, and \`${box}\` reaches a keyed list in ` +
-          `${hit.file.rel}:${listPos[0]} through ${path.map(p => `<${p.tag} ${p.prop}>`).join(' → ')}: every row re-runs on every change.`
+          `${hit.file.rel}:${listPos[0]} through ${path.map((p) => `<${p.tag} ${p.prop}>`).join(' → ')}: every row re-runs on every change.`
         d.related = [
-          ...path.map(p => ({ file: p.file.rel, span: pos(p.file).span(p.at, p.at), why: `passed as \`<${p.tag} ${p.prop}>\`` })),
+          ...path.map((p) => ({
+            file: p.file.rel,
+            span: pos(p.file).span(p.at, p.at),
+            why: `passed as \`<${p.tag} ${p.prop}>\``,
+          })),
           { file: hit.file.rel, span: listPos, why: 'rendered here as a keyed list' },
         ]
         break
@@ -195,25 +308,3 @@ export function projectView(files, pos) {
     }
   }
 }
-
-/** The box a flagged `.map` call writes: `box.value = …map(…)` or `const box = …map(…)`. */
-function boxOf(sf, offset) {
-  let found
-  const visit = n => {
-    if (found) return
-    if (ts.isCallExpression(n) && n.getStart() === offset) found = n
-    else if (n.pos <= offset && offset < n.end) ts.forEachChild(n, visit)
-  }
-  visit(sf)
-  for (let n = found; n; n = n.parent) {
-    if (ts.isBinaryExpression(n) && n.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-      const left = n.left
-      if (ts.isPropertyAccessExpression(left) && left.name.text === 'value' && ts.isIdentifier(left.expression)) return left.expression.text
-      return null
-    }
-    if (ts.isVariableDeclaration(n)) return ts.isIdentifier(n.name) ? n.name.text : null
-  }
-  return null
-}
-
-export const relPath = (root, abs) => relative(root, abs).split('\\').join('/')

package/src/props-checks.mjs

@@ -1,5 +1,6 @@
 // Prop inference in `weft check` and `weft tsc` (research 44). `W080`–`W085` come from the engine; a `TS` code is the
 // compiler's own error, reported at the source position with the inferred types applied.
+// W007/W008 map proven core box errors.
 
 import { existsSync, readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
@@ -10,19 +11,36 @@ import { diagnostic, positions } from './diag.mjs'
 const require = createRequire(import.meta.url)
 const { Session } = require('./infer/session.cjs')
 
-const posix = p => p.split('\\').join('/')
+const posix = (p) => p.split('\\').join('/')
 
 export function toDiagnostics(root, list, file) {
   const rel = posix(relative(root, file))
   const text = readFileSync(file, 'utf8')
   const pos = positions(text)
-  return list.map(f => diagnostic({
-    code: f.code, severity: f.severity, file: rel, span: pos.span(f.start, f.end), offset: [f.start, f.end], why: f.why, help: f.help,
-    fix: f.edits && { description: f.help, safe: f.safe, edits: f.edits.map(e => ({ file: rel, span: pos.span(e.start, e.end), offset: [e.start, e.end], text: e.text })) },
-  }))
+  return list.map((f) =>
+    diagnostic({
+      code: f.code,
+      severity: f.severity,
+      file: rel,
+      span: pos.span(f.start, f.end),
+      offset: [f.start, f.end],
+      why: f.why,
+      help: f.help,
+      fix: f.edits && {
+        description: f.help,
+        safe: f.safe,
+        edits: f.edits.map((e) => ({
+          file: rel,
+          span: pos.span(e.start, e.end),
+          offset: [e.start, e.end],
+          text: e.text,
+        })),
+      },
+    }),
+  )
 }
 
-/** The checks `weft check` adds. A project with nothing to infer parses its `.tsx` files once and starts nothing. */
+/** Prop inference and core box diagnostics; a project with no relevant source starts no checker. */
 export async function propChecks(root, config) {
   if (config.check?.props === false || !existsSync(join(root, 'tsconfig.json'))) return []
   const session = new Session(ts, root)

package/src/props-listener.mjs

@@ -10,29 +10,47 @@ const SKIP = /[\\/](node_modules|\.weft|\.output|dist)[\\/]/
 export function attachProps(server, root, config) {
   const setting = config?.check?.props
   if (setting === false || process.env.WEFT_PROPS === 'off') return null
-  const worker = new Worker(new URL('./infer/worker.cjs', import.meta.url), { workerData: { root, write: setting !== 'manual' }, stdout: false })
+  const worker = new Worker(new URL('./infer/worker.cjs', import.meta.url), {
+    workerData: { root, write: setting !== 'manual' },
+    stdout: false,
+  })
   worker.unref()
   const stats = { saves: 0, ms: [] }
-  const post = file => { if (SOURCE.test(file) && !SKIP.test(file)) worker.postMessage(file) }
+  const post = (file) => {
+    if (SOURCE.test(file) && !SKIP.test(file)) worker.postMessage(file)
+  }
   for (const event of ['change', 'add', 'unlink']) server.watcher.on(event, post)
 
   const logger = server.config?.logger ?? console
-  worker.on('message', msg => {
+  worker.on('message', (msg) => {
     if (msg.type === 'failed') return logger.warn?.(`weft props: ${msg.message}`)
-    if (msg.type === 'wrote') return logger.info?.(`weft props: wrote the inferred type in ${msg.file}`)
+    if (msg.type === 'wrote')
+      return logger.info?.(`weft props: wrote the inferred type in ${msg.file}`)
     if (msg.type !== 'done') return
     stats.saves++
     stats.ms.push(msg.ms)
     if (!msg.changed) return
-    const errors = msg.diagnostics.filter(d => d.severity === 'error')
-    for (const d of msg.diagnostics) logger.warn?.(`${d.file}:${d.line}  ${d.code} ${d.severity}  ${d.why}\n    fix: ${d.help}`)
+    const errors = msg.diagnostics.filter((d) => d.severity === 'error')
+    for (const d of msg.diagnostics)
+      logger.warn?.(`${d.file}:${d.line}  ${d.code} ${d.severity}  ${d.why}\n    fix: ${d.help}`)
     server.ws.send({ type: 'custom', event: 'weft:props', data: msg.diagnostics })
     // A save's HMR update has cleared any earlier overlay already, so this only ever shows the current errors.
-    if (errors.length) server.ws.send({ type: 'error', err: { message: errors.map(d => `${d.file}:${d.line} ${d.code}: ${d.why}`).join('\n'), stack: '', plugin: 'weft:props' } })
+    if (errors.length)
+      server.ws.send({
+        type: 'error',
+        err: {
+          message: errors.map((d) => `${d.file}:${d.line} ${d.code}: ${d.why}`).join('\n'),
+          stack: '',
+          plugin: 'weft:props',
+        },
+      })
   })
-  worker.on('error', e => logger.warn?.(`weft props stopped: ${e.message}`))
+  worker.on('error', (e) => logger.warn?.(`weft props stopped: ${e.message}`))
 
   const close = server.close.bind(server)
-  server.close = async () => { worker.postMessage('close'); return close() }
+  server.close = async () => {
+    worker.postMessage('close')
+    return close()
+  }
   return { worker, stats }
 }

package/src/react-checks.mjs

@@ -16,19 +16,50 @@ export function reactChecks({ files }) {
     const pos = positions(text)
     for (const el of scanJsx(text, rel).elements) {
       for (const a of el.attrs) {
-        if (a.name === 'key' && a.kind === 'expr' && RANDOM.test(a.expr)) out.push(diagnostic({ code: 'W044', file: rel, span: pos.span(a.start, a.end), offset: [a.start, a.end], why: `\`key={${a.expr}}\` differs between the server and the client, so this row can't hydrate and is built again, and it differs on every render.` }))
+        if (a.name === 'key' && a.kind === 'expr' && RANDOM.test(a.expr))
+          out.push(
+            diagnostic({
+              code: 'W044',
+              file: rel,
+              span: pos.span(a.start, a.end),
+              offset: [a.start, a.end],
+              why: `\`key={${a.expr}}\` differs between the server and the client, so this row can't hydrate and is built again, and it differs on every render.`,
+            }),
+          )
       }
       if (!NATIVE.test(el.name)) continue
       for (const a of el.attrs) {
-        if (!a.name.startsWith('data-') || a.kind !== 'expr' || (a.expr !== 'true' && a.expr !== 'false')) continue
+        if (
+          !a.name.startsWith('data-') ||
+          a.kind !== 'expr' ||
+          (a.expr !== 'true' && a.expr !== 'false')
+        )
+          continue
         const on = a.expr === 'true'
         // Removing the attribute takes the space before it too.
         const [from, to] = on ? [a.start, a.end] : [text.slice(0, a.start).trimEnd().length, a.end]
         const why = on
           ? `\`${a.name}={true}\` writes \`${a.name}=""\`, not React's \`"true"\`, so \`[${a.name}="true"]\` won't match. Write \`${a.name}\` for a presence flag, or \`${a.name}="true"\` for the word.`
           : `\`${a.name}={false}\` writes no attribute, not React's \`"false"\`. Drop it, or write \`${a.name}="false"\` for the word.`
-        const fix = { description: on ? `Write \`${a.name}\`, which renders the same` : `Remove \`${a.name}\`, which renders the same`, safe: true, edits: [{ file: rel, span: pos.span(from, to), offset: [from, to], text: on ? a.name : '' }] }
-        out.push(diagnostic({ code: 'W043', file: rel, span: pos.span(a.start, a.end), offset: [a.start, a.end], why, fix }))
+        const fix = {
+          description: on
+            ? `Write \`${a.name}\`, which renders the same`
+            : `Remove \`${a.name}\`, which renders the same`,
+          safe: true,
+          edits: [
+            { file: rel, span: pos.span(from, to), offset: [from, to], text: on ? a.name : '' },
+          ],
+        }
+        out.push(
+          diagnostic({
+            code: 'W043',
+            file: rel,
+            span: pos.span(a.start, a.end),
+            offset: [a.start, a.end],
+            why,
+            fix,
+          }),
+        )
       }
     }
   }

package/src/server-state-checks.mjs

@@ -0,0 +1,34 @@
+// W030 joins server reachability with proven core state calls at module evaluation.
+import { diagnostic, positions } from './diag.mjs'
+import { serverGraph } from './state-checks/server-graph.mjs'
+import { coreState, moduleCalls } from './state-checks/core-state.mjs'
+
+/** State created by a server-reachable module is shared across requests unless explicitly global. */
+export function serverStateChecks(root, options) {
+  const graph = serverGraph(root, options)
+  if (!graph.size) return []
+  const resolve = coreState(root, graph)
+  const out = []
+  for (const [file, { sf, entry }] of graph) {
+    const pos = positions(sf.text)
+    moduleCalls(sf, (call) => {
+      if (!['state', 'linked'].includes(resolve(call.expression))) return
+      const start = call.getStart(sf),
+        end = call.end
+      out.push(
+        diagnostic({
+          code: 'W030',
+          severity: 'error',
+          file,
+          span: pos.span(start, end),
+          offset: [start, end],
+          why: `This module creates state reachable from server entry \`${entry}\`; requests share it.`,
+          help:
+            'Create state inside a request/component factory or a context owned by the request. ' +
+            'Use `state.global` only when sharing across requests is intended.',
+        }),
+      )
+    })
+  }
+  return out.sort((a, b) => a.file.localeCompare(b.file) || a.offset[0] - b.offset[0])
+}