@weft-js/cli 0.1.1 → 0.1.2

package/src/docs.mjs

@@ -11,31 +11,48 @@ import { probeTests } from './tests.mjs'
 import { exportsOf, loadCompiler, resolveWeft } from './weft.mjs'
 
 const docsDir = fileURLToPath(new URL('../docs/', import.meta.url))
-const fileTopics = Object.fromEntries(readdirSync(docsDir).filter(f => f.endsWith('.md')).map(f => [f.slice(0, -3), f]))
+const fileTopics = Object.fromEntries(
+  readdirSync(docsDir)
+    .filter((f) => f.endsWith('.md'))
+    .map((f) => [f.slice(0, -3), f]),
+)
 
 /** What `weft docs` can show, with the line that says what each topic covers. */
 export const topics = {
   rules: 'The nine rules: boxes, derived, live JSX and props, run-once bodies (start here)',
-  state: 'Every reactive function (state, derived, watch, untrack, flush, batch, context) and defineState with persist, sync and history; S001, S002, S008, S009, S012, S013',
+  state:
+    'Every reactive function (state, derived, watch, untrack, flush, batch, context) and defineState with persist, sync and history; S001, S002, S008, S009, S012, S013',
   props: 'How props stay live; W001, W005, W006',
   lists: 'Keyed lists, conditionals and stable items; W010, W011, W013, W014',
   async: 'resource, <Boundary pending error>, @weft-js/core/ssr and hydrate; W012',
-  start: 'full stack: routes, load, query, mutation, the database, auth, realtime, runtimes; Q001–Q016, A001–A004, C001–C002, F001–F003, R001–R023',
+  start:
+    'full stack: routes, load, query, mutation, the database, auth, realtime, runtimes; Q001–Q016, A001–A005, C001–C002, F001–F003, R001–R024',
   rust: 'Rust bodies: native() addons with a WASM fallback, remote() sidecars, weft add rust, impl, the weft crate, build.rs, Ctx, touch, weft dev reload, deployment; R101–R109',
-  deploy: 'Deploy: which hosts can run the app, weft deploy hosts/init, the push workflow, Netlify, Vercel, Cloudflare, Fly, Render, CDN and Cloudinary; E001–E014',
-  plugins: 'Build a plugin: slots, server extensions, check hooks, docs, `weft add`, conformance. Walks through how @weft-js/pay is built',
-  testing: '@weft-js/core/test: render, screen, user, flush, clock, touches and toTouchAtMost(n, { runs }); T001–T009',
-  browser: '@weft-js/core/browser: online, visible, lifecycle, media, on, interval; the net/page fakes; W050, W051, W054, W056, T012',
-  'ui-state': 'Hover, press and focus as state: interaction(), the ui prop, sharing across tabs and clients, realtime({ share }); U001–U005',
-  surface: '@weft-js/core/surface: canvas and WebGL as layout children: defineSurface, <Surface>, s.draw, s.frame, s.text, the clock; X001–X004, X009–X012',
-  verify: 'Check your work: drive the running app (weft browser / __weft__.agent: snapshot with the live graph, act, assert, clock, network, record) and the test gate; T010, T011, T020',
+  deploy:
+    'Deploy: which hosts can run the app, weft deploy hosts/init, the push workflow, Netlify, Vercel, Cloudflare, Fly, Render, CDN and Cloudinary; E001–E014',
+  plugins:
+    'Build a plugin: slots, server extensions, check hooks, docs, `weft add`, conformance. Walks through how @weft-js/pay is built',
+  theme: 'Change the look: warp() options, three worked looks, button tone channels, D010',
+  testing:
+    '@weft-js/core/test: render, screen, user, flush, clock, touches and toTouchAtMost(n, { runs }); T001–T009',
+  browser:
+    '@weft-js/core/browser: online, visible, lifecycle, media, on, interval; the net/page fakes; W050, W051, W054, W056, T012',
+  'ui-state':
+    'Hover, press and focus as state: interaction(), the ui prop, sharing across tabs and clients, realtime({ share }); U001–U005',
+  surface:
+    '@weft-js/core/surface: canvas and WebGL as layout children: defineSurface, <Surface>, s.draw, s.frame, s.text, the clock; X001–X004, X009–X012',
+  verify:
+    'Check your work: drive the running app (weft browser / __weft__.agent: snapshot with the live graph, act, assert, clock, network, record) and the test gate; T010, T011, T020',
   icons: '@weft-js/warp-icons: per-icon exports, iconSet, the three tiers, icons({ tier }), sizes',
-  fonts: 'Fonts with @weft-js/text: text({ fonts }), what the build makes, using a face in CSS, budgets; X020, X021, X022, X023',
-  meta: 'Page metadata and share cards: route `meta`, what is automatic, `site.url`, `.og.tsx`, `weft routes --meta`; H001–H008, H011–H016',
+  fonts:
+    'Fonts with @weft-js/text: text({ fonts }), what the build makes, using a face in CSS, budgets; X020, X021, X022, X023',
+  meta: 'Page metadata and share cards: route `meta`, what is automatic, `site.url`, `.og.tsx`, `weft routes --meta`; H001–H010, H011 (no description) to H017',
   config: 'weft.config.ts: scope, tasks, environments, reserved plugins/slots; P-codes',
-  design: 'The design language: Stack, Row, Heading, Text, Link, the closed vocabulary, `weft fix`, `weft tokens`; D001–D007, D011, D030–D039',
-  style: 'Style groups (@weft-js/core/style): group(), axes, parts, accents, weft style find/explain, .weft/styles.json; D020–D025, W060',
-  diagnostics: 'Every W-, T-, P-, H- and D-code, and which ones the installed weft reports',
+  design:
+    'The design language: Stack, Row, Heading, Text, Link, the closed vocabulary, `weft fix`, `weft tokens`; D001–D007, D011, D012, D030–D041',
+  style:
+    'Style groups (@weft-js/core/style): group(), axes, parts, accents, weft style find/explain, .weft/styles.json; D020–D025, W060',
+  diagnostics: 'Every diagnostic code, from W to L, and which ones the installed weft reports',
   commands: "This project's commands and tasks (from `weft tasks`)",
   agents: 'The generated AGENTS.md',
 }
@@ -45,20 +62,32 @@ const probes = new Map()
 /** What the installed weft offers: version, exports, and which catalog codes its compiler reports. */
 export function installed(root) {
   const weft = resolveWeft(root)
-  if (!probes.has(weft.compilerPath)) probes.set(weft.compilerPath, { ...probe(loadCompiler(weft)), ...probeTests(catalog) })
+  if (!probes.has(weft.compilerPath))
+    probes.set(weft.compilerPath, { ...probe(loadCompiler(weft)), ...probeTests(catalog) })
   return { weft, exports: exportsOf(weft), status: probes.get(weft.compilerPath) }
 }
 
 function status(code, info) {
   const e = entry(code)
   const st = info.status[e.code]
-  if (e.by === 'compiler') return st?.implemented ? `reported${st.autofix ? ', safe autofix' : st.suggestion ? ', suggested edit' : ''}` : 'not reported by this weft yet'
+  if (e.by === 'compiler')
+    return st?.implemented
+      ? `reported${st.autofix ? ', safe autofix' : st.suggestion ? ', suggested edit' : ''}`
+      : 'not reported by this weft yet'
   if (e.by === 'test') return 'reported by @weft-js/core/test after each test'
   if (e.by === 'gate') return 'reported by `weft test --gate` on a diff'
-  if (e.code.startsWith('T')) return st?.implemented ? `reported by weft check on test files${st.autofix ? ', safe autofix' : st.suggestion ? ', suggested edit' : ''}` : 'not reported by this weft yet'
-  if (e.by === 'start') return 'reported by @weft-js/start when it serves or renders the route, and by weft check and `weft routes --meta`'
-  if (e.by === 'cli' && e.code.startsWith('H')) return 'reported by weft check and by `weft routes --meta`, per route, on what the routes produce'
-  if (e.by === 'cli') return e.proposed ? 'reported by weft check (proposed code, research 17)' : 'reported by weft check'
+  if (e.code.startsWith('T'))
+    return st?.implemented
+      ? `reported by weft check on test files${st.autofix ? ', safe autofix' : st.suggestion ? ', suggested edit' : ''}`
+      : 'not reported by this weft yet'
+  if (e.by === 'start')
+    return 'reported by @weft-js/start when it serves or renders the route, and by weft check and `weft routes --meta`'
+  if (e.by === 'cli' && e.code.startsWith('H'))
+    return 'reported by weft check and by `weft routes --meta`, per route, on what the routes produce'
+  if (e.by === 'cli')
+    return e.proposed
+      ? 'reported by weft check (proposed code, research 17)'
+      : 'reported by weft check'
   if (e.by === 'runtime') return 'reported in dev by the runtime (a console warning)'
   if (e.by === 'plugin') return `reported by weft check when \`${e.owner}\` is in \`plugins\``
   return 'reserved'
@@ -66,31 +95,76 @@ function status(code, info) {
 
 function codePage(code, info) {
   const e = entry(code)
-  const lines = [`# ${code} (${e.severity})`, '', e.catches + '.', '', `**Fix:** ${e.fix}.`, '', `**Status in weft@${info.weft.version}:** ${status(code, info)}.`]
+  const lines = [
+    `# ${code} (${e.severity})`,
+    '',
+    e.catches + '.',
+    '',
+    `**Fix:** ${e.fix}.`,
+    '',
+    `**Status in weft@${info.weft.version}:** ${status(code, info)}.`,
+  ]
   if (e.example) lines.push('', 'Triggers it:', '', '```tsx', e.example, '```')
-  if (code.startsWith('T')) lines.push('', 'A test that needs it on purpose keeps it with a reason: `// weft-allow ' + code + ': <why>` in the file header (whole file) or on the line above.')
-  const topic = Object.entries(topics).find(([, d]) => d.includes(code)) ?? (code.startsWith('T') ? ['testing'] : undefined)
+  if (code.startsWith('T'))
+    lines.push(
+      '',
+      'A test that needs it on purpose keeps it with a reason: `// weft-allow ' +
+        code +
+        ': <why>` in the file header (whole file) or on the line above.',
+    )
+  const topic =
+    Object.entries(topics).find(([, d]) => d.includes(code)) ??
+    (code.startsWith('T') ? ['testing'] : undefined)
   if (topic) lines.push('', `More: \`weft docs ${topic[0]}\`.`)
   return lines.join('\n')
 }
 
-const contributed = async root => (await loadConfig(root)).contributions
+const contributed = async (root) => (await loadConfig(root)).contributions
 
 /** What this app's plugins add to the docs (`docs` and `diagnostics` in their manifests). */
-const pluginDocs = async root => (await contributed(root)).flatMap(c => (c.manifest.docs ? [c.manifest.docs] : []))
-const pluginCodes = async root => (await contributed(root)).flatMap(c => (c.manifest.diagnostics ?? []).map(d => ({ ...d, plugin: c.name })))
+const pluginDocs = async (root) =>
+  (await contributed(root)).flatMap((c) => (c.manifest.docs ? [c.manifest.docs] : []))
+const pluginCodes = async (root) =>
+  (await contributed(root)).flatMap((c) =>
+    (c.manifest.diagnostics ?? []).map((d) => ({ ...d, plugin: c.name })),
+  )
 
 function diagnosticsPage(info, own = []) {
-  const rows = [...catalog.map(e => `| ${e.code} | ${e.severity} | ${e.catches} | ${e.fix} | ${status(e.code, info)} |`), ...own.map(d => `| ${d.code} | ${d.severity ?? 'error'} | ${d.catches} | ${d.fix} | from \`${d.plugin}\` |`)]
-  return [`# Diagnostics (weft@${info.weft.version})`, '', '| Code | Severity | Catches | Fix | Status |', '|---|---|---|---|---|', ...rows].join('\n')
+  const rows = [
+    ...catalog.map(
+      (e) => `| ${e.code} | ${e.severity} | ${e.catches} | ${e.fix} | ${status(e.code, info)} |`,
+    ),
+    ...own.map(
+      (d) =>
+        `| ${d.code} | ${d.severity ?? 'error'} | ${d.catches} | ${d.fix} | from \`${d.plugin}\` |`,
+    ),
+  ]
+  return [
+    `# Diagnostics (weft@${info.weft.version})`,
+    '',
+    '| Code | Severity | Catches | Fix | Status |',
+    '|---|---|---|---|---|',
+    ...rows,
+  ].join('\n')
 }
 
 export function commandsPage(list, { planned: showPlanned = true } = {}) {
   const rows = list.tasks
-    .filter(t => t.available)
-    .map(t => `| \`${t.command}\` | ${t.description ?? '(no description: P004)'} | ${t.sideEffects?.length ? t.sideEffects.join(', ') : 'none'} |`)
-  const planned = list.tasks.filter(t => !t.available).map(t => `\`${t.name}\``)
-  return ['| Command | Does | Side effects |', '|---|---|---|', ...rows, '', showPlanned && planned.length ? `Planned, not shipped yet: ${planned.join(', ')}.` : ''].join('\n').trim()
+    .filter((t) => t.available)
+    .map(
+      (t) =>
+        `| \`${t.command}\` | ${t.description ?? '(no description: P004)'} | ${t.sideEffects?.length ? t.sideEffects.join(', ') : 'none'} |`,
+    )
+  const planned = list.tasks.filter((t) => !t.available).map((t) => `\`${t.name}\``)
+  return [
+    '| Command | Does | Side effects |',
+    '|---|---|---|',
+    ...rows,
+    '',
+    showPlanned && planned.length ? `Planned, not shipped yet: ${planned.join(', ')}.` : '',
+  ]
+    .join('\n')
+    .trim()
 }
 
 /**
@@ -102,31 +176,52 @@ export async function docs(root, topic) {
   root = resolve(root)
   const key = (topic ?? 'index').trim()
   if (key === 'index') {
-    const all = { ...topics, ...Object.fromEntries((await pluginDocs(root)).map(d => [d.topic, d.summary])) }
-    const text = ['# weft docs', '', ...Object.entries(all).map(([t, d]) => `- \`${t}\`: ${d}`), '', 'Any diagnostic code works too: `W014`, `T003`, `P004`, `D025`, `Q001`.'].join('\n')
+    const all = {
+      ...topics,
+      ...Object.fromEntries((await pluginDocs(root)).map((d) => [d.topic, d.summary])),
+    }
+    const text = [
+      '# weft docs',
+      '',
+      ...Object.entries(all).map(([t, d]) => `- \`${t}\`: ${d}`),
+      '',
+      'Any diagnostic code works too: `W014`, `T003`, `P004`, `D025`, `Q001`.',
+    ].join('\n')
     return { topic: 'index', text, topics: all }
   }
   const info = installed(root)
   if (/^[A-Z]{1,5}\d{3}$/i.test(key)) {
     const code = key.toUpperCase()
-    const own = !entry(code) && (await pluginCodes(root)).find(d => d.code === code)
-    if (own) return { topic: code, text: `# ${code} (${own.severity ?? 'error'})\n\n${own.catches}.\n\n**Fix:** ${own.fix}.\n\nReported by weft check, from \`${own.plugin}\`.` }
-    if (!entry(code)) throw Object.assign(new Error(`unknown diagnostic code ${code}`), { code: 'E_UNKNOWN_TOPIC' })
+    const own = !entry(code) && (await pluginCodes(root)).find((d) => d.code === code)
+    if (own)
+      return {
+        topic: code,
+        text: `# ${code} (${own.severity ?? 'error'})\n\n${own.catches}.\n\n**Fix:** ${own.fix}.\n\nReported by weft check, from \`${own.plugin}\`.`,
+      }
+    if (!entry(code))
+      throw Object.assign(new Error(`unknown diagnostic code ${code}`), { code: 'E_UNKNOWN_TOPIC' })
     return { topic: code, text: codePage(code, info) }
   }
-  if (key === 'diagnostics') return { topic: key, text: diagnosticsPage(info, await pluginCodes(root)) }
-  if (key === 'commands') return { topic: key, text: `# Commands\n\n${commandsPage(await tasks(root))}` }
+  if (key === 'diagnostics')
+    return { topic: key, text: diagnosticsPage(info, await pluginCodes(root)) }
+  if (key === 'commands')
+    return { topic: key, text: `# Commands\n\n${commandsPage(await tasks(root))}` }
   if (key === 'agents') {
     const { agentsMd } = await import('./agents-md.mjs')
     return { topic: key, text: (await agentsMd(root)).text }
   }
-  const page = (await pluginDocs(root)).find(d => d.topic === key)
+  const page = (await pluginDocs(root)).find((d) => d.topic === key)
   if (page) return { topic: key, text: readFileSync(page.file, 'utf8').trim() }
   if (fileTopics[key]) {
     const text = readFileSync(resolve(docsDir, fileTopics[key]), 'utf8').trim()
     return { topic: key, text: key === 'rules' ? `# The rules\n\n${text}` : text }
   }
-  throw Object.assign(new Error(`unknown docs topic "${key}"; topics: ${Object.keys(topics).join(', ')}, or a code like W014`), { code: 'E_UNKNOWN_TOPIC' })
+  throw Object.assign(
+    new Error(
+      `unknown docs topic "${key}"; topics: ${Object.keys(topics).join(', ')}, or a code like W014`,
+    ),
+    { code: 'E_UNKNOWN_TOPIC' },
+  )
 }
 
-export const readDoc = name => readFileSync(resolve(docsDir, `${name}.md`), 'utf8').trim()
+export const readDoc = (name) => readFileSync(resolve(docsDir, `${name}.md`), 'utf8').trim()

package/src/doctor.mjs

@@ -7,7 +7,8 @@ import { loadCompiler, resolveWeft } from './weft.mjs'
 /** One line for `weft check --verbose` and `weft doctor`. */
 export function compilerLine(backend) {
   if (!backend) return 'compiler: this weft does not say which build it uses'
-  if (backend.kind === 'native') return `compiler: native addon${backend.package ? ` (${backend.package})` : ` (${backend.file})`}`
+  if (backend.kind === 'native')
+    return `compiler: native addon${backend.package ? ` (${backend.package})` : ` (${backend.file})`}`
   const offer = backend.wanted?.length
     ? `. Optional, and faster: ${backend.wanted.join(' or ')}, which a normal install adds by itself`
     : '. No prebuilt addon for this platform, and none is needed'
@@ -19,12 +20,23 @@ export function doctor(root) {
   const { backend } = loadCompiler(weft)
   const cargo = spawnSync('cargo', ['--version'], { encoding: 'utf8' })
   const version = cargo.status === 0 ? cargo.stdout.trim() : null
-  const runtime = globalThis.Deno ? `Deno ${Deno.version.deno}` : globalThis.Bun ? `Bun ${Bun.version}` : `Node ${process.version}`
-  return { ok: true, weft: weft.version, runtime, compiler: backend ?? null, rust: { cargo: version, required: false } }
+  const runtime = globalThis.Deno
+    ? `Deno ${Deno.version.deno}`
+    : globalThis.Bun
+      ? `Bun ${Bun.version}`
+      : `Node ${process.version}`
+  return {
+    ok: true,
+    weft: weft.version,
+    runtime,
+    compiler: backend ?? null,
+    rust: { cargo: version, required: false },
+  }
 }
 
-export const formatDoctor = r => [
-  `weft ${r.weft} on ${r.runtime}`,
-  compilerLine(r.compiler),
-  `rust: ${r.rust.cargo ?? 'no cargo on PATH'}. Not needed for weft; only \`weft add rust\` sidecars and native() use it`,
-].join('\n')
+export const formatDoctor = (r) =>
+  [
+    `weft ${r.weft} on ${r.runtime}`,
+    compilerLine(r.compiler),
+    `rust: ${r.rust.cargo ?? 'no cargo on PATH'}. Not needed for weft; only \`weft add rust\` sidecars and native() use it`,
+  ].join('\n')

package/src/files.mjs

@@ -3,7 +3,16 @@
 import { readdirSync } from 'node:fs'
 import { join } from 'node:path'
 
-const skipDirs = new Set(['public', 'node_modules', '.git', '.weft', '.output', 'dist', 'coverage', 'target'])
+const skipDirs = new Set([
+  'public',
+  'node_modules',
+  '.git',
+  '.weft',
+  '.output',
+  'dist',
+  'coverage',
+  'target',
+])
 
 export function globToRegExp(glob) {
   let re = ''
@@ -16,16 +25,20 @@ export function globToRegExp(glob) {
     else if (c === '?') re += '[^/]'
     else if (c === '{') {
       const end = glob.indexOf('}', i)
-      re += `(?:${glob.slice(i + 1, end).split(',').map(s => s.replace(/[.+^$()|[\]\\]/g, '\\$&')).join('|')})`
+      re += `(?:${glob
+        .slice(i + 1, end)
+        .split(',')
+        .map((s) => s.replace(/[.+^$()|[\]\\]/g, '\\$&'))
+        .join('|')})`
       i = end
     } else re += c.replace(/[.+^$()|[\]\\]/g, '\\$&')
   }
   return new RegExp(`^${re}$`)
 }
 
-export const matcher = globs => {
+export const matcher = (globs) => {
   const res = (globs ?? []).map(globToRegExp)
-  return path => res.some(re => re.test(path))
+  return (path) => res.some((re) => re.test(path))
 }
 
 /** Relative posix paths under `root` matching `include` and none of `exclude`. Sorted, so output is stable. */
@@ -34,7 +47,7 @@ export function discover(root, { include = ['**/*.{tsx,jsx}'], exclude = [] } =
   const exc = matcher(exclude)
   /** @type {string[]} */
   const out = []
-  const walk = rel => {
+  const walk = (rel) => {
     for (const ent of readdirSync(join(root, rel), { withFileTypes: true })) {
       const path = rel ? `${rel}/${ent.name}` : ent.name
       if (ent.isDirectory()) {

package/src/fix.mjs

@@ -24,14 +24,22 @@ export async function fix(root, options = {}) {
     for (const [file, list] of byFile) {
       const edits = []
       for (const d of list) {
-        if (d.fix.edits.some(e => e.file !== file || edits.some(x => e.offset[0] < x.offset[1] && x.offset[0] < e.offset[1]))) continue
+        if (
+          d.fix.edits.some(
+            (e) =>
+              e.file !== file ||
+              edits.some((x) => e.offset[0] < x.offset[1] && x.offset[0] < e.offset[1]),
+          )
+        )
+          continue
         edits.push(...d.fix.edits)
         applied.push({ code: d.code, file, span: d.span })
         changed++
       }
       const abs = join(root, file)
       let text = readFileSync(abs, 'utf8')
-      for (const e of edits.sort((a, b) => b.offset[0] - a.offset[0])) text = text.slice(0, e.offset[0]) + e.text + text.slice(e.offset[1])
+      for (const e of edits.sort((a, b) => b.offset[0] - a.offset[0]))
+        text = text.slice(0, e.offset[0]) + e.text + text.slice(e.offset[1])
       writeFileSync(abs, text)
     }
     if (!changed) break

package/src/gate/after.mjs

@@ -0,0 +1,40 @@
+import { copyProject, removeCopy } from '../workspace.mjs'
+import { resolver } from './resolve-cases.mjs'
+
+export async function afterRun({ cases, testFiles, log, root, options, run, result }) {
+  // After: the change as it stands. Every changed test must pass.
+  log(
+    `gate: ${cases.length} new or changed tests in ${testFiles.length} files; running them on the change`,
+  )
+  const afterDir = copyProject(root, { exclude: options.exclude, id: 'after' })
+  let after
+  try {
+    after = await run(afterDir, testFiles)
+  } finally {
+    removeCopy(afterDir)
+  }
+  const resolveCases = resolver(testFiles, cases)
+  const afterStatus = resolveCases(after)
+  const byKey = new Map()
+  for (const [key, st] of afterStatus) {
+    const [file, name] = key.split('::')
+    const c =
+      cases.find((x) => x.file === file && x.name === name) ??
+      cases.find((x) => x.file === file && x.dynamic)
+    const t = {
+      file,
+      name,
+      line: c?.line ?? 1,
+      end: c?.end ?? c?.line ?? 1,
+      after: st.status,
+      afterMessage: st.status === 'passed' ? undefined : st.message,
+      before: null,
+      kills: 0,
+    }
+    byKey.set(key, t)
+    result.tests.push(t)
+  }
+  if (after.timedOut) result.notes.push('the run on the change timed out')
+
+  return { after, resolveCases, byKey }
+}

package/src/gate/before.mjs

@@ -0,0 +1,54 @@
+import { diagnostic } from '../diag.mjs'
+import { copyProject, removeCopy, writeFiles } from '../workspace.mjs'
+
+export async function beforeRun({
+  source,
+  options,
+  log,
+  root,
+  run,
+  testFiles,
+  resolveCases,
+  byKey,
+  allowed,
+  result,
+  diagnostics,
+}) {
+  // Before: source reverted, tests and their helpers as they are now. Every changed test must fail.
+  if (source.length && !options.refactor) {
+    log(`gate: reverting ${source.length} source files; the changed tests must fail`)
+    const beforeDir = copyProject(root, { exclude: options.exclude, id: 'before' })
+    let before
+    try {
+      writeFiles(beforeDir, Object.fromEntries(source.map((c) => [c.rel, c.before])))
+      before = await run(beforeDir, testFiles)
+    } finally {
+      removeCopy(beforeDir)
+    }
+    const beforeStatus = resolveCases(before)
+    for (const [key, t] of byKey) {
+      const st =
+        beforeStatus.get(key) ??
+        (before.loadErrors.has(t.file)
+          ? { status: 'failed', message: before.loadErrors.get(t.file) }
+          : { status: 'missing' })
+      t.before = st.status
+      t.beforeMessage = st.message
+      if (t.after === 'passed' && st.status === 'passed' && allowed('T010', t.file, t.line))
+        result.notes.push(`T010 allowed on "${t.name}"`)
+      else if (t.after === 'passed' && st.status === 'passed')
+        diagnostics.push(
+          diagnostic({
+            code: 'T010',
+            file: t.file,
+            span: [t.line, 1, t.line, 1],
+            why: `"${t.name}" passes on the code before this change too, so it doesn't test the change`,
+            help: "Assert what the change makes different (what the user sees now and didn't before); or, if this is a test for existing behavior, add it in its own change with no source edits",
+          }),
+        )
+    }
+  } else if (!options.refactor)
+    result.notes.push(
+      'no source change: fail-before skipped; mutants come from the source the new tests import',
+    )
+}

package/src/gate/classify.mjs

@@ -0,0 +1,72 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { discover } from '../files.mjs'
+import { changedCases, weakened } from '../testdiff.mjs'
+import { allowances, checkTestFile, isTestFile, parse } from '../tests.mjs'
+
+export function classify(root, changes, code, configFile, importsOf) {
+  // Tests, test support (helpers only tests import) and source.
+  const tests = changes.filter((c) => isTestFile(c.rel))
+  const others = changes.filter((c) => !isTestFile(c.rel) && code(c.rel) && !configFile(c.rel))
+  const testAbs = new Set(
+    discover(root, {
+      include: ['**/*.{test,spec}.{ts,tsx,mts,cts,js,jsx,mjs,cjs}'],
+      exclude: ['.weft/**'],
+    }).map((r) => join(root, r)),
+  )
+  const importedBySource = new Set()
+  for (const rel of discover(root, {
+    include: ['**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}'],
+    exclude: ['.weft/**'],
+  })) {
+    const abs = join(root, rel)
+    if (testAbs.has(abs)) continue
+    for (const p of importsOf(abs, readFileSync(abs, 'utf8'))) importedBySource.add(p)
+  }
+  const importedByTests = new Set()
+  for (const abs of testAbs)
+    for (const p of importsOf(abs, readFileSync(abs, 'utf8'))) importedByTests.add(p)
+  const isSupport = (rel) =>
+    importedByTests.has(join(root, rel)) &&
+    !importedBySource.has(join(root, rel)) &&
+    !rel.match(/(^|\/)src\//)
+  const support = others.filter((c) => isSupport(c.rel))
+  const source = others.filter((c) => !isSupport(c.rel))
+
+  // Static: T020 on every changed test file, T001–T009 on the ones that still exist (T005 blocks here).
+  const diagnostics = []
+  for (const c of tests) diagnostics.push(...weakened(c.before, c.after, c.rel))
+  for (const c of tests) {
+    if (c.after == null) continue
+    for (const d of checkTestFile(c.after, c.rel, { abs: join(root, c.rel), root })) {
+      if (d.code === 'T005' && d.severity === 'warning') {
+        d.severity = 'error'
+        d.why += ' The gate blocks implementation queries in new and changed tests.'
+      }
+      diagnostics.push(d)
+    }
+  }
+
+  // The tests this change has to prove.
+  // `// weft-allow T010: <reason>` / T011 on a test keeps it (shown in the result, for the reviewer).
+  const allowFns = new Map(
+    tests
+      .filter((c) => c.after != null)
+      .map((c) => [c.rel, allowances(c.after, parse(c.after, c.rel))]),
+  )
+  const allowed = (rule, file, line) => allowFns.get(file)?.(rule, line) ?? false
+  const cases = tests
+    .filter((c) => c.after != null)
+    .flatMap((c) =>
+      changedCases(c.before, c.after, c.rel).map((t) => ({
+        file: c.rel,
+        name: t.name,
+        line: t.line,
+        end: t.end,
+        dynamic: t.dynamic,
+      })),
+    )
+  const testFiles = [...new Set(cases.map((c) => c.file))]
+
+  return { tests, support, source, isSupport, diagnostics, allowed, cases, testFiles }
+}