@weft-js/cli 0.1.1 → 0.1.3

package/src/check.mjs

@@ -2,18 +2,25 @@
 // `check` hooks, the test T-codes, the config P-codes, the style D-codes (style.mjs) and the design D-codes (design-checks.mjs), and keep `.weft/styles.json`
 // current when the project has style groups.
 
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { isAbsolute, join, relative, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
-import { diagnostic, locate, positions, sortDiagnostics, summarize } from './diag.mjs'
+import { diagnostic, positions, sortDiagnostics, summarize } from './diag.mjs'
 import { discover } from './files.mjs'
 import { isDataConfig, loadConfig, writeConfigSchema } from './load-config.mjs'
 import { sync } from './plugins.mjs'
 import { writeMap } from './map.mjs'
 import { projectView } from './project.mjs'
 import { designChecks, hasTokens } from './design-checks.mjs'
-import { classSoup, matrixDiagnostics, styleFiles, styleModule, usesTailwind, writeMatrixFile } from './style.mjs'
+import {
+  classSoup,
+  matrixDiagnostics,
+  styleFiles,
+  styleModule,
+  usesTailwind,
+  writeMatrixFile,
+} from './style.mjs'
 import { checkTests, isTestFile, testGlobs } from './tests.mjs'
 import { pluginChecks } from './plugin-checks.mjs'
 import { propChecks } from './props-checks.mjs'
@@ -21,35 +28,60 @@ import { reactChecks } from './react-checks.mjs'
 import { trustDiagnostics } from './trust.mjs'
 import { shareChecks } from './share-checks.mjs'
 import { stateChecks } from './state-checks.mjs'
+import { serverStateChecks } from './server-state-checks.mjs'
 import { surfaceChecks } from './surface-checks.mjs'
 import { textChecks } from './text-checks.mjs'
 import { loadCompiler, resolveWeft } from './weft.mjs'
 import { dbLayer } from './db-layer.mjs'
-import { routeDiagnostics, schemaHash, siteOf, start } from './start.mjs'
+import { loadEnv, routeDiagnostics, schemaHash, siteOf, start } from './start.mjs'
 import { deployChecks } from './deploy/index.mjs'
+import { rustChecks, liveChecks, socketChecks, hygiene } from './check/runtime.mjs'
 
-const posix = p => p.split('\\').join('/')
+const posix = (p) => p.split('\\').join('/')
 
 /** Q015: the schema's hash against the one `weft db generate` recorded (research 28 §2). */
 function schemaDrift(root, layer) {
   const schema = layer?.schema && join(root, layer.schema)
   if (!schema || !existsSync(schema)) return []
   const file = join(root, layer.migrations, '.schema-hash')
-  if (existsSync(file) && readFileSync(file, 'utf8').trim() === schemaHash(readFileSync(schema))) return []
-  return [diagnostic({ code: 'Q015', file: layer.schema, why: existsSync(file) ? 'The schema changed since the last `weft db generate`: the database will not match it.' : 'No migrations yet: the first request that reads a table fails with Q014.' })]
+  if (existsSync(file) && readFileSync(file, 'utf8').trim() === schemaHash(readFileSync(schema)))
+    return []
+  return [
+    diagnostic({
+      code: 'Q015',
+      file: layer.schema,
+      why: existsSync(file)
+        ? 'The schema changed since the last `weft db generate`: the database will not match it.'
+        : 'No migrations yet: the first request that reads a table fails with Q014.',
+    }),
+  ]
 }
 
 /** I001–I003: the walk a build does (@weft-js/warp-icons/compile), when the project has the package. */
 async function iconChecks(root) {
   const require = createRequire(join(root, 'package.json'))
   let compile
-  for (const from of [() => require.resolve('@weft-js/warp-icons/compile'), () => createRequire(require.resolve('@weft-js/warp'))
-    .resolve('@weft-js/warp-icons/compile')]) {
-    try { compile = from(); break } catch { /* not this way */ }
+  for (const from of [
+    () => require.resolve('@weft-js/warp-icons/compile'),
+    () => createRequire(require.resolve('@weft-js/warp')).resolve('@weft-js/warp-icons/compile'),
+  ]) {
+    try {
+      compile = from()
+      break
+    } catch {
+      /* not this way */
+    }
   }
   if (!compile) return []
   const { findings } = await import(pathToFileURL(compile).href)
-  return findings(root).map(f => diagnostic({ code: f.code, file: f.file, span: [f.line, f.column, f.line, f.column], why: f.why }))
+  return findings(root).map((f) =>
+    diagnostic({
+      code: f.code,
+      file: f.file,
+      span: [f.line, f.column, f.line, f.column],
+      why: f.why,
+    }),
+  )
 }
 
 /** H010: what the last build or `weft dev` found keeps an island from waiting (`.weft/hydration.json`, @weft-js/core/hydration). */
@@ -57,7 +89,17 @@ function hydrationChecks(root) {
   const file = join(root, '.weft', 'hydration.json')
   if (!existsSync(file)) return []
   try {
-    return JSON.parse(readFileSync(file, 'utf8')).diagnostics.filter(d => existsSync(join(root, d.file))).map(d => diagnostic({ code: d.code, file: d.file, span: [d.line, 1, d.line, 1], why: d.why, help: d.fix }))
+    return JSON.parse(readFileSync(file, 'utf8'))
+      .diagnostics.filter((d) => existsSync(join(root, d.file)))
+      .map((d) =>
+        diagnostic({
+          code: d.code,
+          file: d.file,
+          span: [d.line, 1, d.line, 1],
+          why: d.why,
+          help: d.fix,
+        }),
+      )
   } catch {
     return []
   }
@@ -68,46 +110,40 @@ function hydrationChecks(root) {
  * when a route is among them. An app that can't run here is still read: a check never fails for what it couldn't start.
  */
 async function routeChecks(root, loaded, given, reported) {
-  if (!existsSync(join(root, 'src', 'routes')) || loaded.config?.check?.routes === false || loaded.diagnostics.some(d => d.code === 'P007')) return []
-  if (given?.length && !given.some(f => f.startsWith('src/routes/'))) return []
+  if (
+    !existsSync(join(root, 'src', 'routes')) ||
+    loaded.config?.check?.routes === false ||
+    loaded.diagnostics.some((d) => d.code === 'P007')
+  )
+    return []
+  if (given?.length && !given.some((f) => f.startsWith('src/routes/'))) return []
   let inspect
-  try { inspect = await start(root, 'inspect') } catch { return [] }
-  const keep = list => routeDiagnostics(root, list).filter(d => !(d.code === 'H001' && reported.has('H001')))
+  // The routes run as they do under `weft dev`, so they get the same `.env` (an env schema throws without it).
+  loadEnv(root)
+  try {
+    inspect = await start(root, 'inspect')
+  } catch {
+    return []
+  }
+  const keep = (list) =>
+    routeDiagnostics(root, list).filter((d) => !(d.code === 'H001' && reported.has('H001')))
   try {
     return keep((await inspect.routesMeta({ root, site: siteOf(loaded) })).diagnostics)
   } catch (error) {
-    return keep([...inspect.staticRouteChecks(root), { code: 'H016', severity: 'info', file: 'src/routes', route: '*', why: `The routes didn't load here, so only their source was checked: ${String(error?.message ?? error).split('\n')[0]}` }])
+    return keep([
+      ...inspect.staticRouteChecks(root),
+      {
+        code: 'H016',
+        severity: 'info',
+        file: 'src/routes',
+        route: '*',
+        why: `The routes didn't load here, so only their source was checked: ${String(error?.message ?? error).split('\n')[0]}`,
+      },
+    ])
   }
 }
 
-/**
- * @param {string} root
- * @param {{ files?: string[] }} [options] files relative to `root` (or absolute); default: discovered
- */
-export async function check(root, options = {}) {
-  const started = performance.now()
-  root = resolve(root)
-  const weft = resolveWeft(root)
-  const compiler = loadCompiler(weft)
-  const loaded = await loadConfig(root)
-  const { config } = loaded
-  // Slot modules and plugin token files stay current with the config (research 13 §2.6).
-  if (!loaded.diagnostics.some(d => d.code === 'P007') && (config.plugins?.length || existsSync(join(root, '.weft', 'slots')))) sync(root, loaded)
-
-  if (loaded.file && isDataConfig(loaded.file)) writeConfigSchema(root)
-  if (existsSync(join(root, '.weft'))) await writeMap(root)
-
-  const exclude = [...(config.check?.exclude ?? []), ...(config.scope?.forbid ?? [])]
-  const given = options.files?.map(f => posix(relative(root, isAbsolute(f) ? f : join(root, f))))
-  const include = config.check?.include ?? ['**/*.{tsx,jsx}']
-  const rels = given?.length ? given.filter(f => /\.[jt]sx$/.test(f) || !isTestFile(f)) : discover(root, { include, exclude })
-  const testRels = given?.length ? given.filter(isTestFile) : discover(root, { include: config.test?.include ?? testGlobs, exclude })
-
-  // Style groups (research 23): the project's definitions first, so each file compiles with the groups it imports.
-  const style = await styleModule(weft)
-  const sfiles = style ? styleFiles(root, config) : []
-  const scan = sfiles.some(f => readFileSync(join(root, f), 'utf8').includes('@weft-js/core/style')) ? style.scanProject(root, sfiles, (...a) => compiler.transform(...a)) : null
-
+function compileFiles(root, rels, compiler, scan, style) {
   const files = []
   const posByAbs = new Map()
   for (const rel of rels) {
@@ -115,40 +151,69 @@ export async function check(root, options = {}) {
     const text = readFileSync(abs, 'utf8')
     const pos = positions(text)
     posByAbs.set(abs, pos)
-    const groups = scan ? style.importedGroups(abs, text, f => scan.groups.filter(g => join(root, g.file) === f)) : {}
-    const out = compiler.transform(text, Object.keys(groups).length ? { filename: abs, checkOnly: true, groups } : { filename: rel, checkOnly: true })
-    const diagnostics = out.diagnostics.map(d => {
+    const groups = scan
+      ? style.importedGroups(abs, text, (f) => scan.groups.filter((g) => join(root, g.file) === f))
+      : {}
+    const out = compiler.transform(
+      text,
+      Object.keys(groups).length
+        ? { filename: abs, checkOnly: true, groups }
+        : { filename: rel, checkOnly: true },
+    )
+    const diagnostics = out.diagnostics.map((d) => {
       const from = pos.fromByte(d.start)
       const end = pos.fromByte(d.end)
       const fix = d.fix && {
         description: d.fix.description,
         safe: d.fix.safe,
-        edits: d.fix.edits.map(e => {
+        edits: d.fix.edits.map((e) => {
           const a = pos.fromByte(e.start)
           const b = pos.fromByte(e.end)
           return { file: rel, span: pos.span(a, b), offset: [a, b], text: e.text }
         }),
       }
-      return diagnostic({ code: d.code, severity: d.severity, file: rel, span: pos.span(from, end), offset: [from, end], why: d.message, help: d.help, fix })
+      return diagnostic({
+        code: d.code,
+        severity: d.severity,
+        file: rel,
+        span: pos.span(from, end),
+        offset: [from, end],
+        why: d.message,
+        help: d.help,
+        fix,
+      })
     })
     files.push({ abs, rel, text, diagnostics })
   }
 
-  projectView(files, file => posByAbs.get(file.abs))
-
-  const matrix = scan && style.buildMatrix(scan.groups, scan.uses)
-  if (matrix && scan.groups.length) writeMatrixFile(root, matrix)
-  const styles = [...(usesTailwind(root) ? [] : classSoup(files.filter(f => /\.[jt]sx$/.test(f.rel)))), ...(matrix ? matrixDiagnostics(root, matrix) : [])]
+  return { files, posByAbs }
+}
 
-  const fontBuild = typeof loaded.slots['font.build'] === 'string' && !loaded.slots['font.build'].startsWith('weft:default')
+async function collectDiagnostics({
+  root,
+  loaded,
+  config,
+  files,
+  exclude,
+  styles,
+  testRels,
+  options,
+  given,
+}) {
+  const fontBuild =
+    typeof loaded.slots['font.build'] === 'string' &&
+    !loaded.slots['font.build'].startsWith('weft:default')
   const diagnostics = [
     ...loaded.diagnostics,
-    ...(loaded.diagnostics.some(d => d.code === 'P007') ? [] : trustDiagnostics(root, loaded)),
-    ...files.flatMap(f => f.diagnostics),
+    ...(loaded.diagnostics.some((d) => d.code === 'P007') ? [] : trustDiagnostics(root, loaded)),
+    ...files.flatMap((f) => f.diagnostics),
     ...styles,
-    ...(config.check?.design === false ? [] : designChecks(root, { files, exclude, tokens: hasTokens(root) })),
+    ...(config.check?.design === false
+      ? []
+      : designChecks(root, { files, exclude, tokens: hasTokens(root) })),
     ...textChecks(root, { files, exclude, fontBuild }),
     ...stateChecks(root, { files, exclude }),
+    ...serverStateChecks(root, { files, exclude }),
     ...shareChecks(root, { files }),
     ...reactChecks({ files }),
     ...surfaceChecks(root, { files, exclude, slots: loaded.slots }),
@@ -162,10 +227,79 @@ export async function check(root, options = {}) {
     ...schemaDrift(root, await dbLayer(root, loaded)),
     ...(await rustChecks(root, loaded)),
     ...(await liveChecks(root, loaded, options.preset)),
-    ...(loaded.diagnostics.some(d => d.code === 'P007') ? [] : deployChecks(root, config, { preset: options.preset })),
+    ...(loaded.diagnostics.some((d) => d.code === 'P007')
+      ? []
+      : deployChecks(root, config, { preset: options.preset })),
   ]
-  diagnostics.push(...await routeChecks(root, loaded, given, new Set(loaded.diagnostics.map(d => d.code))))
+  diagnostics.push(
+    ...(await routeChecks(root, loaded, given, new Set(loaded.diagnostics.map((d) => d.code)))),
+  )
   sortDiagnostics(diagnostics)
+  return diagnostics
+}
+
+/**
+ * @param {string} root
+ * @param {{ files?: string[] }} [options] files relative to `root` (or absolute); default: discovered
+ */
+export async function check(root, options = {}) {
+  const started = performance.now()
+  root = resolve(root)
+  const weft = resolveWeft(root)
+  const compiler = loadCompiler(weft)
+  const loaded = await loadConfig(root)
+  const { config } = loaded
+  // Slot modules and plugin token files stay current with the config (research 13 §2.6).
+  if (
+    !loaded.diagnostics.some((d) => d.code === 'P007') &&
+    (config.plugins?.length || existsSync(join(root, '.weft', 'slots')))
+  )
+    sync(root, loaded)
+
+  if (loaded.file && isDataConfig(loaded.file)) writeConfigSchema(root)
+  if (existsSync(join(root, '.weft'))) await writeMap(root)
+
+  const exclude = [...(config.check?.exclude ?? []), ...(config.scope?.forbid ?? [])]
+  const given = options.files?.map((f) => posix(relative(root, isAbsolute(f) ? f : join(root, f))))
+  const include = config.check?.include ?? ['**/*.{tsx,jsx}']
+  const rels = given?.length
+    ? given.filter((f) => /\.[jt]sx$/.test(f) || !isTestFile(f))
+    : discover(root, { include, exclude })
+  const testRels = given?.length
+    ? given.filter(isTestFile)
+    : discover(root, { include: config.test?.include ?? testGlobs, exclude })
+
+  // Style groups (research 23): the project's definitions first, so each file compiles with the groups it imports.
+  const style = await styleModule(weft)
+  const sfiles = style ? styleFiles(root, config) : []
+  const scan = sfiles.some((f) =>
+    readFileSync(join(root, f), 'utf8').includes('@weft-js/core/style'),
+  )
+    ? style.scanProject(root, sfiles, (...a) => compiler.transform(...a))
+    : null
+
+  const { files, posByAbs } = compileFiles(root, rels, compiler, scan, style)
+
+  projectView(files, (file) => posByAbs.get(file.abs))
+
+  const matrix = scan && style.buildMatrix(scan.groups, scan.uses)
+  if (matrix && scan.groups.length) writeMatrixFile(root, matrix)
+  const styles = [
+    ...(usesTailwind(root) ? [] : classSoup(files.filter((f) => /\.[jt]sx$/.test(f.rel)))),
+    ...(matrix ? matrixDiagnostics(root, matrix) : []),
+  ]
+
+  const diagnostics = await collectDiagnostics({
+    root,
+    loaded,
+    config,
+    files,
+    exclude,
+    styles,
+    testRels,
+    options,
+    given,
+  })
   const summary = { files: files.length, tests: testRels.length, ...summarize(diagnostics) }
   return {
     version: 1,
@@ -176,155 +310,11 @@ export async function check(root, options = {}) {
     summary,
     diagnostics,
     slots: loaded.slots,
-    styles: matrix ? { groups: Object.keys(matrix.groups).length, matrix: '.weft/styles.json' } : null,
+    styles: matrix
+      ? { groups: Object.keys(matrix.groups).length, matrix: '.weft/styles.json' }
+      : null,
     files: rels,
     tests: testRels,
     ms: Math.round(performance.now() - started),
   }
 }
-
-/**
- * R101, R102 from the contract, and R103, R109 from `cargo check`, for an app with a sidecar: an agent gets the same
- * answer here as from `weft build`, with the function's id on it.
- */
-async function rustChecks(root, loaded) {
-  let sidecar
-  try { sidecar = await start(root, 'sidecar') } catch { return [] }
-  if (!sidecar.usesRemote(root)) return []
-  const rust = loaded.config?.rust
-  const held = process.env.WEFT_BUILD
-  process.env.WEFT_BUILD = '1'
-  try {
-    const { writeContract } = await start(root, 'contract')
-    const preset = { node: 'node', bun: 'bun', deno: 'deno_server' }[loaded.config?.runtime ?? 'node']
-    const { contract, diagnostics } = await writeContract({ root, site: loaded.config?.site, rust, preset })
-    const out = diagnostics.filter(d => d.code.startsWith('R1')).map(d => diagnostic({ ...d, file: '.weft/contract.json' }))
-    if (out.some(d => d.severity === 'error')) return out
-    for (const service of Object.keys(contract.services ?? {})) {
-      if (rust?.services?.[service]?.external) continue
-      const dir = sidecar.crateDir(root, rust, service)
-      if (!existsSync(dir)) {
-        out.push(diagnostic({ code: 'R109', file: '.weft/contract.json', why: `\`rust://${service}\` has no crate at \`${posix(relative(root, dir))}\`.` }))
-        continue
-      }
-      const checked = await sidecar.cargo('check', { root, dir, service, contract })
-      out.push(...checked.diagnostics.map(({ rendered, ...d }) => diagnostic({ ...d, help: rendered })))
-      out.push(...untouchedQueries(root, dir, contract, service))
-      if (contract.services[service].kind !== 'native' || !checked.ok) continue
-      const wasm = await sidecar.checkWasm({ root, dir, service, contract, preset, rust })
-      out.push(...wasm.diagnostics.map(d => diagnostic(d)))
-    }
-    return out
-  } catch (e) {
-    return [diagnostic({ code: 'R109', severity: 'warning', file: '.weft/contract.json', why: `the contract couldn't be written, so the sidecars weren't checked: ${e.message.split('\n')[0]}` })]
-  } finally {
-    if (held === undefined) delete process.env.WEFT_BUILD
-    else process.env.WEFT_BUILD = held
-  }
-}
-
-/** R105 before anything runs: a cached query with tags whose Rust never mentions `touch`, or hands `ctx` to anything. */
-function untouchedQueries(root, dir, contract, service) {
-  const sources = readdirSync(join(dir, 'src'), { recursive: true, withFileTypes: true }).filter(f => f.isFile() && f.name.endsWith('.rs')).map(f => join(f.parentPath, f.name))
-  const out = []
-  for (const f of contract.functions) {
-    if (f.impl?.service !== service || !f.cache || !(f.tags === 'dynamic' || f.tags?.length)) continue
-    const method = f.name.replace(/[A-Z]/g, (c, i) => `${i ? '_' : ''}${c.toLowerCase()}`)
-    for (const file of sources) {
-      const text = readFileSync(file, 'utf8')
-      const at = text.search(new RegExp(`\\bfn\\s+${method}\\s*\\(`))
-      if (at < 0) continue
-      const open = text.indexOf('{', at)
-      let depth = 0, end = open
-      for (; end < text.length; end++) {
-        if (text[end] === '{') depth++
-        if (text[end] === '}' && --depth === 0) break
-      }
-      const body = text.slice(open, end)
-      const line = text.slice(0, at).split('\n').length
-      if (!/\.touch\(|\(\s*&?ctx\b|,\s*&?ctx\b/.test(body)) out.push(diagnostic({ code: 'R105', severity: 'warning', file: posix(relative(root, file)), span: [line, 1, line, 1], why: `\`${f.id}\` is cached under tags and reports no table: nothing can tell whether they cover what it reads. Call \`ctx.touch("table")\`, or drop \`tags\` if it reads none.` }))
-      break
-    }
-  }
-  return out
-}
-
-/** R013, R014 and R018: what the deploy target does to live data. Only an app with `changes` or `required` loads anything. */
-async function liveChecks(root, loaded, preset) {
-  const file = join(root, 'src/realtime.server.ts')
-  let target
-  try { target = await start(root, 'live-target') } catch { return [] }
-  const required = target.scanRequired(root)
-  if (!required.length && !target.literalSecrets(root).length && !(existsSync(file) && /\bchanges\s*[:,}]/.test(readFileSync(file, 'utf8')))) return []
-  const held = process.env.WEFT_BUILD
-  process.env.WEFT_BUILD = '1'
-  try {
-    const { readLivePlan } = await start(root, 'contract')
-    const plan = await readLivePlan({ root, site: loaded.config?.site, live: loaded.config?.live, preset: preset ?? { node: 'node', bun: 'bun', deno: 'deno_server' }[loaded.config?.runtime ?? 'node'] })
-    return plan.diagnostics.map(d => diagnostic({ ...d, file: d.file ?? required[0]?.file ?? 'src/realtime.server.ts' }))
-  } catch (e) {
-    return [diagnostic({ code: 'R014', severity: 'warning', file: 'src/realtime.server.ts', why: `the deploy target couldn't be checked: ${e.message.split('\n')[0]}` })]
-  } finally {
-    if (held === undefined) delete process.env.WEFT_BUILD
-    else process.env.WEFT_BUILD = held
-  }
-}
-
-/** R001 for a server module's `channel`, and R004 for a socket handler of the app's own (research 32 §1). */
-async function socketChecks(root) {
-  const src = join(root, 'src')
-  if (!existsSync(src)) return []
-  const out = []
-  let withIds
-  for (const f of readdirSync(src, { recursive: true, withFileTypes: true })) {
-    if (!f.isFile() || !/\.[cm]?[jt]sx?$/.test(f.name) || f.name.endsWith('.d.ts')) continue
-    const abs = join(f.parentPath, f.name), rel = relative(root, abs).replaceAll('\\', '/'), text = readFileSync(abs, 'utf8')
-    const hand = /from\s+['"]crossws|\bdefineWebSocketHandler\b/.exec(text)
-    if (hand) out.push(diagnostic({ code: 'R004', file: rel, ...locate(text, hand[0]), why: 'A WebSocket handler of its own skips the Origin check, `authorize`, the limits and resume. Use `channel`.' }))
-    if (!/\b(channel|sharedState)\s*[(<]/.test(text) || !/^src\/server\/|\.server\.[cm]?[jt]sx?$/.test(rel)) continue
-    if (withIds === undefined) {
-      try { withIds = (await import(pathToFileURL(createRequire(join(root, 'package.json')).resolve('@weft-js/start/vite')).href)).withIds } catch { withIds = null }
-    }
-    try { withIds?.(text, abs, rel) } catch (e) {
-      if (e.code !== 'R001') continue
-      const line = +/:(\d+) /.exec(e.message)?.[1]
-      out.push(diagnostic({ code: 'R001', file: rel, span: [line, 1, line, 1], why: e.message.split('\n')[0].replace(/^R001: \S+ /, '') }))
-    }
-  }
-  return out
-}
-
-/** weft owns the connection: these bypass reconnects, resume and the fake transport (research 30 §8). */
-const SOCKET_PACKAGES = ['ws', 'socket.io-client', 'reconnecting-websocket', '@microsoft/fetch-event-source']
-
-/** P002 (`package.json` scripts that aren't `weft …`), P120 (weft plugins wired straight into Vite), R007 (socket libraries). */
-function hygiene(root) {
-  const out = []
-  const pkgFile = join(root, 'package.json')
-  if (existsSync(pkgFile)) {
-    const text = readFileSync(pkgFile, 'utf8')
-    let scripts = {}, deps = {}
-    try {
-      const pkg = JSON.parse(text)
-      scripts = pkg.scripts ?? {}
-      deps = pkg.dependencies ?? {}
-    } catch {}
-    for (const name of SOCKET_PACKAGES) {
-      if (deps[name]) out.push(diagnostic({ code: 'R007', file: 'package.json', ...locate(text, `"${name}"`), why: `\`${name}\` is a dependency: its connection has no resume, no cleanup and no fake in @weft-js/core/test. Use \`stream\`, \`.live()\` or \`channel\`.` }))
-    }
-    for (const [name, cmd] of Object.entries(scripts)) {
-      if (!/^weft(\s|$)/.test(cmd.trim())) {
-        out.push(diagnostic({ code: 'P002', file: 'package.json', ...locate(text, `"${name}"`), why: `Script \`${name}\` runs \`${cmd}\`, not \`weft …\`: agents can't see what it does or what it touches.` }))
-      }
-    }
-  }
-  for (const name of ['vite.config.ts', 'vite.config.mts', 'vite.config.js', 'vite.config.mjs']) {
-    const file = join(root, name)
-    if (!existsSync(file)) continue
-    const text = readFileSync(file, 'utf8')
-    for (const m of text.matchAll(/from\s+['"](@weft-js\/(?:plugin-[\w-]+|text))/g)) {
-      out.push(diagnostic({ code: 'P120', file: name, ...locate(text, m[1]), why: `\`${m[1]}\` is registered in ${name}, which bypasses weft.config.ts.` }))
-    }
-  }
-  return out
-}