@weft-js/cli 0.1.1 → 0.1.2

package/src/gate.mjs

@@ -13,30 +13,43 @@
 import { execFileSync } from 'node:child_process'
 import { existsSync, readFileSync } from 'node:fs'
 import { availableParallelism } from 'node:os'
-import { join, relative, resolve } from 'node:path'
-import { diagnostic, sortDiagnostics, summarize } from './diag.mjs'
-import { discover } from './files.mjs'
+import { join, resolve } from 'node:path'
+import { diagnostic } from './diag.mjs'
+import { runGate } from './gate/run.mjs'
+import { classify } from './gate/classify.mjs'
+import { makeResult } from './gate/result.mjs'
 import { loadConfig } from './load-config.mjs'
-import { apply, changedLines, mutants as makeMutants, sample, suggest } from './mutate.mjs'
-import { changedCases, testCases, weakened } from './testdiff.mjs'
-import { allowances, checkTestFile, isTestFile, parse, resolveImport } from './tests.mjs'
-import { copyProject, removeCopy, runVitest, vitestBin, writeFiles } from './workspace.mjs'
+import { testCases } from './testdiff.mjs'
+import { resolveImport } from './tests.mjs'
 
-const code = rel => /\.[cm]?[jt]sx?$/.test(rel) && !/\.d\.[cm]?ts$/.test(rel)
-const configFile = rel => /(^|\/)(vite|vitest|weft|tsup|eslint|playwright)\.config\.[cm]?[jt]s$/.test(rel)
-const posix = p => p.split('\\').join('/')
+const code = (rel) => /\.[cm]?[jt]sx?$/.test(rel) && !/\.d\.[cm]?ts$/.test(rel)
+const configFile = (rel) =>
+  /(^|\/)(vite|vitest|weft|tsup|eslint|playwright)\.config\.[cm]?[jt]s$/.test(rel)
+const posix = (p) => p.split('\\').join('/')
 
 /** Changed files between `base` and the working tree, from git (paths relative to `root`). */
 export function gitChanges(root, base = 'HEAD') {
-  const git = (...args) => execFileSync('git', ['-C', root, ...args], { encoding: 'utf8', maxBuffer: 1 << 28, stdio: ['ignore', 'pipe', 'ignore'] })
-  const list = [...git('diff', '--name-only', '--relative', '--no-renames', base).split('\n'), ...git('ls-files', '--others', '--exclude-standard').split('\n')]
-  const rels = [...new Set(list.filter(r => r && !r.startsWith('.weft/')))]
-  return rels.map(rel => {
-    let before = null
-    try { before = git('show', `${base}:./${rel}`) } catch {}
-    const abs = join(root, rel)
-    return { rel, before, after: existsSync(abs) ? readFileSync(abs, 'utf8') : null }
-  }).filter(c => c.before !== c.after)
+  const git = (...args) =>
+    execFileSync('git', ['-C', root, ...args], {
+      encoding: 'utf8',
+      maxBuffer: 1 << 28,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+  const list = [
+    ...git('diff', '--name-only', '--relative', '--no-renames', base).split('\n'),
+    ...git('ls-files', '--others', '--exclude-standard').split('\n'),
+  ]
+  const rels = [...new Set(list.filter((r) => r && !r.startsWith('.weft/')))]
+  return rels
+    .map((rel) => {
+      let before = null
+      try {
+        before = git('show', `${base}:./${rel}`)
+      } catch {}
+      const abs = join(root, rel)
+      return { rel, before, after: existsSync(abs) ? readFileSync(abs, 'utf8') : null }
+    })
+    .filter((c) => c.before !== c.after)
 }
 
 const importRe = /(?:from\s*|import\s*\(\s*|import\s+)['"]([^'"]+)['"]/g
@@ -67,207 +80,96 @@ export async function gate(root, options = {}) {
   const gateCfg = config.test?.gate ?? {}
   const budgetSec = options.budgetSec ?? gateCfg.mutationBudgetSec ?? 60
   const maxMutants = options.maxMutants ?? gateCfg.maxMutants ?? 40
-  const concurrency = Math.max(1, options.concurrency ?? Math.min(4, Math.floor(availableParallelism() / 3) || 1))
-  const changes = (options.changes ?? gitChanges(root, options.base ?? 'HEAD')).map(c => ({ ...c, rel: posix(c.rel) }))
-
-  // 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))]
-  const result = {
-    version: 1, ok: true, root, base: options.changes ? null : (options.base ?? 'HEAD'),
-    files: { tests: tests.map(c => c.rel), support: support.map(c => c.rel), source: source.map(c => c.rel) },
-    tests: [], mutants: { generated: 0, run: 0, killed: 0, survived: 0, timedOut: 0, invalid: 0, sampled: false, budgetSec }, survivors: [],
-    diagnostics, summary: null, notes: [], ms: 0,
-  }
-  const finish = () => {
-    sortDiagnostics(diagnostics)
-    // Each test's verdict: it ran green on the change, failed before it (when there was a before), and no error
-    // diagnostic falls inside it.
-    for (const t of result.tests) {
-      t.codes = diagnostics.filter(d => d.severity === 'error' && d.file === t.file && d.span[0] >= t.line && d.span[0] <= t.end).map(d => d.code)
-      t.accepted = t.after === 'passed' && t.before !== 'passed' && !t.codes.length
-    }
-    result.summary = { changedTests: result.tests.length, ...summarize(diagnostics) }
-    result.ok = result.summary.errors === 0 && result.tests.every(t => t.accepted)
-    result.ms = Math.round(performance.now() - started)
-    return result
-  }
+  const concurrency = Math.max(
+    1,
+    options.concurrency ?? Math.min(4, Math.floor(availableParallelism() / 3) || 1),
+  )
+  const changes = (options.changes ?? gitChanges(root, options.base ?? 'HEAD')).map((c) => ({
+    ...c,
+    rel: posix(c.rel),
+  }))
+
+  const { tests, support, source, isSupport, diagnostics, allowed, cases, testFiles } = classify(
+    root,
+    changes,
+    code,
+    configFile,
+    importsOf,
+  )
+  const { result, finish } = makeResult({
+    root,
+    options,
+    tests,
+    support,
+    source,
+    diagnostics,
+    budgetSec,
+    started,
+  })
 
   if (options.refactor) {
-    if (cases.length) for (const c of cases) diagnostics.push(diagnostic({ code: 'T020', file: c.file, span: [c.line, 1, c.line, 1], why: `--refactor promises behavior didn't change, but test "${c.name}" is new or edited`, help: 'Drop --refactor, or leave the tests alone' }))
-    if (!cases.length) { result.notes.push('refactor: no test changed; run the whole suite to confirm behavior'); return finish() }
-  }
-  if (!cases.length) { result.notes.push('no new or changed tests'); return finish() }
-
-  const bin = vitestBin(root)
-  const run = (dir, files) => runVitest(dir, files, { bin, config: options.config, timeoutMs: 180_000 })
-
-  // 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 = res => {
-    // Static names map 1:1; results nobody claimed belong to the file's dynamic (`.each`) cases.
-    const out = new Map()
-    for (const f of testFiles) {
-      const mine = cases.filter(c => c.file === f)
-      const keys = [...res.tests.keys()].filter(k => k.startsWith(`${f}::`))
-      for (const c of mine.filter(x => !x.dynamic)) out.set(`${f}::${c.name}`, res.loadErrors.has(f) ? { status: 'failed', message: res.loadErrors.get(f), load: true } : res.tests.get(`${f}::${c.name}`) ?? { status: 'missing' })
-      if (mine.some(c => c.dynamic)) for (const k of keys) if (!out.has(k)) out.set(k, res.tests.get(k))
+    if (cases.length)
+      for (const c of cases)
+        diagnostics.push(
+          diagnostic({
+            code: 'T020',
+            file: c.file,
+            span: [c.line, 1, c.line, 1],
+            why: `--refactor promises behavior didn't change, but test "${c.name}" is new or edited`,
+            help: 'Drop --refactor, or leave the tests alone',
+          }),
+        )
+    if (!cases.length) {
+      result.notes.push('refactor: no test changed; run the whole suite to confirm behavior')
+      return finish()
     }
-    return out
   }
-  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 (!cases.length) {
+    result.notes.push('no new or changed tests')
+    return finish()
   }
-  if (after.timedOut) result.notes.push('the run on the change timed out')
-
-  // 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')
 
-  // Mutation: the changed source lines (or, with no source change, the source files the tests import).
-  if (options.mutation !== false) {
-    // Only code the changed tests can reach (runtime imports): a mutant nothing runs survives by definition.
-    const reach = (limit) => {
-      const seen = new Set()
-      const walk = (abs, depth) => {
-        if (seen.has(abs) || depth > limit || !existsSync(abs)) return
-        seen.add(abs)
-        for (const p of importsOf(abs, readFileSync(abs, 'utf8'))) walk(p, depth + 1)
-      }
-      for (const f of testFiles) walk(join(root, f), 0)
-      return seen
-    }
-    const reachable = reach(12)
-    const unreached = source.filter(c => c.after != null && code(c.rel) && !reachable.has(join(root, c.rel))).map(c => c.rel)
-    if (unreached.length) result.notes.push(`not mutated (no changed test imports them): ${unreached.join(', ')}`)
-    let targets = source.filter(c => c.after != null && reachable.has(join(root, c.rel))).map(c => ({ rel: c.rel, text: c.after, lines: changedLines(c.before, c.after) }))
-    if (!source.length) {
-      targets = [...reach(3)].map(abs => posix(relative(root, abs))).filter(rel => !isTestFile(rel) && code(rel) && !isSupport(rel) && !rel.startsWith('..') && !rel.includes('node_modules'))
-        .map(rel => { const text = readFileSync(join(root, rel), 'utf8'); return { rel, text, lines: changedLines(null, text) } })
-    }
-    const all = targets.flatMap(t => makeMutants(t.text, t.rel, t.lines))
-    const list = sample(all, maxMutants)
-    result.mutants.generated = all.length
-    result.mutants.sampled = list.length < all.length
-    const passing = [...byKey.values()].filter(t => t.after === 'passed')
-    const files = [...new Set(passing.map(t => t.file))]
-    if (list.length && files.length) {
-      log(`gate: ${list.length}${result.mutants.sampled ? ` of ${all.length}` : ''} mutants on ${targets.length} files, ${concurrency} at a time, ${budgetSec}s budget`)
-      const texts = Object.fromEntries(targets.map(t => [t.rel, t.text]))
-      const deadline = started + budgetSec * 1000 + after.ms
-      const timeoutMs = Math.max(15_000, after.ms * 3)
-      const queue = [...list]
-      const outcomes = []
-      const worker = async i => {
-        const dir = copyProject(root, { exclude: options.exclude, id: `mutant-${i}` })
-        try {
-          for (let m; (m = queue.shift()); ) {
-            if (performance.now() > deadline) { result.mutants.sampled = true; queue.length = 0; break }
-            writeFiles(dir, { [m.file]: apply(texts[m.file], m) })
-            const res = await runVitest(dir, files, { bin, config: options.config, timeoutMs })
-            writeFiles(dir, { [m.file]: texts[m.file] })
-            outcomes.push({ m, res })
-          }
-        } finally { removeCopy(dir) }
-      }
-      await Promise.all(Array.from({ length: Math.min(concurrency, list.length) }, (_, i) => worker(i)))
-      for (const { m, res } of outcomes) {
-        result.mutants.run++
-        if (res.timedOut) { result.mutants.timedOut++; result.mutants.killed++; continue }
-        const loadOnly = res.tests.size === 0 && res.loadErrors.size > 0
-        if (loadOnly && [...res.loadErrors.values()].some(compileError)) { result.mutants.invalid++; continue }
-        let killed = false
-        for (const t of passing) {
-          const st = res.loadErrors.has(t.file) ? 'failed' : res.tests.get(`${t.file}::${t.name}`)?.status
-          if (st && st !== 'passed') { t.kills++; killed = true }
-        }
-        if (killed) result.mutants.killed++
-        else { result.mutants.survived++; result.survivors.push({ file: m.file, line: m.line, column: m.column, op: m.op, original: m.original.slice(0, 80), replacement: m.replacement, suggestion: suggest(m) }) }
-      }
-      const valid = result.mutants.run - result.mutants.invalid
-      if (valid > 0)
-        for (const t of passing) {
-          if (t.kills > 0 || t.before === 'passed') continue
-          if (allowed('T011', t.file, t.line)) { result.notes.push(`T011 allowed on "${t.name}"`); continue }
-          const partial = result.mutants.sampled
-          diagnostics.push(diagnostic({
-            code: 'T011', severity: partial ? 'warning' : 'error', file: t.file, span: [t.line, 1, t.line, 1],
-            why: `"${t.name}" killed none of the ${valid} mutants of the changed lines${partial ? ` (a sample of ${result.mutants.generated})` : ''}: it would still pass if that code were wrong`,
-            help: result.survivors[0] ? `Assert what the changed code computes. For example: ${result.survivors[0].suggestion}` : 'Assert what the changed code computes',
-          }))
-        }
-    } else if (!list.length) result.notes.push('no mutants on the changed lines')
-  }
+  await runGate({
+    root,
+    options,
+    cases,
+    testFiles,
+    log,
+    result,
+    source,
+    allowed,
+    diagnostics,
+    importsOf,
+    code,
+    posix,
+    isSupport,
+    maxMutants,
+    concurrency,
+    budgetSec,
+    started,
+    compileError,
+  })
   return finish()
 }
 
 /** A mutant the compiler or parser rejects never ran, so it counts as neither killed nor survived. */
-const compileError = msg => /\bW\d{3}\b|SyntaxError|Transform failed|Parse error|Unexpected token|Expected/.test(msg)
+const compileError = (msg) =>
+  /\bW\d{3}\b|SyntaxError|Transform failed|Parse error|Unexpected token|Expected/.test(msg)
 
 /** Human summary for stderr. */
 export function formatGate(r) {
   const lines = []
   for (const t of r.tests) {
     const mark = t.accepted ? '✓' : '✗'
-    lines.push(`${mark} ${t.file} › ${t.name}  before: ${t.before ?? '—'}, after: ${t.after}, kills: ${t.kills}${t.codes?.length ? `, ${t.codes.join(' ')}` : ''}${t.after !== 'passed' && t.afterMessage ? `\n    ${t.afterMessage}` : ''}`)
+    lines.push(
+      `${mark} ${t.file} › ${t.name}  before: ${t.before ?? '—'}, after: ${t.after}, kills: ${t.kills}${t.codes?.length ? `, ${t.codes.join(' ')}` : ''}${t.after !== 'passed' && t.afterMessage ? `\n    ${t.afterMessage}` : ''}`,
+    )
   }
   const m = r.mutants
-  if (m.run) lines.push(`mutants: ${m.killed}/${m.run - m.invalid} killed${m.timedOut ? ` (${m.timedOut} by timeout)` : ''}${m.invalid ? `, ${m.invalid} didn't compile` : ''}${m.sampled ? `, sampled from ${m.generated}` : ''}`)
+  if (m.run)
+    lines.push(
+      `mutants: ${m.killed}/${m.run - m.invalid} killed${m.timedOut ? ` (${m.timedOut} by timeout)` : ''}${m.invalid ? `, ${m.invalid} didn't compile` : ''}${m.sampled ? `, sampled from ${m.generated}` : ''}`,
+    )
   for (const s of r.survivors.slice(0, 8)) lines.push(`  survived: ${s.suggestion}`)
   for (const n of r.notes) lines.push(`note: ${n}`)
   return lines.join('\n')

package/src/infer/box-props.cjs

@@ -0,0 +1,140 @@
+// Map proven JSX box/value assignability errors. Type names alone are not evidence:
+// value members must come from the resolved core State/Derived exports.
+const { coreMembers, known } = require('./core-boxes.cjs')
+const assignmentCodes = new Set([2322, 2739, 2740, 2741])
+
+function boxKind(ts, checker, type, members) {
+  if (!known(ts, type)) return null
+  if (type.isUnion()) {
+    const nullable = ts.TypeFlags.Null | ts.TypeFlags.Undefined
+    const parts = type.types.filter((part) => !(part.flags & nullable))
+    const kinds = new Set(parts.map((part) => boxKind(ts, checker, part, members)))
+    return kinds.size === 1 ? [...kinds][0] : null
+  }
+  if (members.roots.has(type.getSymbol()) || members.roots.has(type.aliasSymbol)) return 'box'
+  const value = checker.getPropertyOfType(type, 'value')
+  const declarations = value?.getDeclarations() ?? []
+  const names = new Set(checker.getPropertiesOfType(type).map((property) => property.name))
+  // A projection of just .value is not evidence of the complete box contract.
+  return members.shapes.some(
+    (shape) =>
+      shape.names.length > 1 &&
+      shape.names.every((name) => names.has(name)) &&
+      declarations.some((declaration) => shape.declarations.has(declaration)),
+  )
+    ? 'box'
+    : 'value'
+}
+
+function attribute(ts, file, start) {
+  let node = ts.getTokenAtPosition(file, start)
+  while (node && !ts.isJsxAttribute(node)) node = node.parent
+  if (!node || !node.initializer || !ts.isJsxExpression(node.initializer)) return null
+  const expression = node.initializer.expression
+  const opening = node.parent.parent
+  if (!expression || !opening.tagName || start > expression.getStart(file)) return null
+  return { expression, tag: opening.tagName }
+}
+
+// Scalar aliases and synthesized boxes stay opaque; no complete contract is proven there.
+function originatingBox(ts, expression) {
+  while (
+    ts.isParenthesizedExpression(expression) ||
+    ts.isAsExpression(expression) ||
+    ts.isTypeAssertionExpression(expression) ||
+    ts.isNonNullExpression(expression) ||
+    ts.isSatisfiesExpression(expression)
+  )
+    expression = expression.expression
+  if (ts.isPropertyAccessExpression(expression) && expression.name.text === 'value')
+    return expression.expression
+  if (
+    ts.isElementAccessExpression(expression) &&
+    expression.argumentExpression &&
+    ts.isStringLiteralLike(expression.argumentExpression) &&
+    expression.argumentExpression.text === 'value'
+  )
+    return expression.expression
+  return null
+}
+
+/** A core diagnostic only when changing box/value direction explains the type error. */
+function boxMismatch(ts, program, diagnostic) {
+  if (!assignmentCodes.has(diagnostic.code) || !diagnostic.file || diagnostic.start === undefined)
+    return null
+  const site = attribute(ts, diagnostic.file, diagnostic.start)
+  if (!site) return null
+  const checker = program.getTypeChecker()
+  const tag = checker.getTypeAtLocation(site.tag)
+  if (!tag.getCallSignatures().length && !tag.getConstructSignatures().length) return null
+  const actual = checker.getTypeAtLocation(site.expression)
+  const expected = checker.getContextualType(site.expression)
+  const members = coreMembers(ts, program, checker)
+  const given = boxKind(ts, checker, actual, members)
+  const wanted = boxKind(ts, checker, expected, members)
+  if (!given || !wanted || given === wanted || checker.isTypeAssignableTo(actual, expected))
+    return null
+  const box = checker.getNonNullableType(given === 'box' ? actual : expected)
+  const value = checker.getTypeOfPropertyOfType(box, 'value')
+  if (!known(ts, value)) return null
+  const from = given === 'box' ? value : actual
+  const to = given === 'box' ? expected : value
+  if (!checker.isTypeAssignableTo(from, to)) return null
+  if (given === 'value') {
+    const origin = originatingBox(ts, site.expression)
+    const original = origin && checker.getTypeAtLocation(origin)
+    if (
+      boxKind(ts, checker, original, members) !== 'box' ||
+      !checker.isTypeAssignableTo(original, expected)
+    )
+      return null
+  }
+  const text = site.expression.getText(diagnostic.file)
+  return {
+    code: 'W008',
+    severity: 'error',
+    why:
+      given === 'box'
+        ? `This component prop expects a value, but \`${text}\` is a core box.`
+        : `This component prop expects a core box, but \`${text}\` is a value.`,
+    help:
+      given === 'box'
+        ? `Read the box's \`.value\` before passing it to this prop; handle null or undefined first if needed.`
+        : 'Pass the State/Derived box itself, for example `count` instead of `count.value`.',
+  }
+}
+
+function canMap(file, diagnostic) {
+  return diagnostic.code === 2540 || (file.endsWith('.tsx') && assignmentCodes.has(diagnostic.code))
+}
+
+/** Keep native inference; lazily map core box prop and readonly errors with the existing JS host. */
+function withBoxProps(host, createFallback) {
+  let fallback
+  return {
+    ...host,
+    update(files, touched = []) {
+      host.update(files, touched)
+      fallback?.update(files, touched)
+    },
+    diagnostics(file) {
+      const list = host.diagnostics(file)
+      if (!list.some((diagnostic) => canMap(file, diagnostic))) return list
+      fallback ??= createFallback()
+      const mapped = fallback.diagnostics(file).filter((diagnostic) => diagnostic.weft)
+      return list.map((diagnostic) => {
+        if (!canMap(file, diagnostic)) return diagnostic
+        const match = mapped.find(
+          (candidate) => candidate.start === diagnostic.start && candidate.code === diagnostic.code,
+        )
+        return match ? { ...diagnostic, weft: match.weft } : diagnostic
+      })
+    },
+    close() {
+      host.close()
+      fallback?.close()
+    },
+  }
+}
+
+module.exports = { boxMismatch, withBoxProps }

package/src/infer/core-boxes.cjs

@@ -0,0 +1,46 @@
+// Core box provenance shared by TypeScript diagnostic mappings.
+const programs = new WeakMap()
+
+/** Resolved core exports and member declarations for one checker program. */
+function coreMembers(ts, program, checker) {
+  if (programs.has(program)) return programs.get(program)
+  const roots = new Set(),
+    shapes = [],
+    derivedRoots = new Set()
+  for (const file of program.getSourceFiles()) {
+    for (const node of file.statements) {
+      if (
+        (!ts.isImportDeclaration(node) && !ts.isExportDeclaration(node)) ||
+        node.moduleSpecifier?.text !== '@weft-js/core'
+      )
+        continue
+      const module = checker.getSymbolAtLocation(node.moduleSpecifier)
+      if (!module) continue
+      for (let symbol of checker.getExportsOfModule(module)) {
+        if (!['State', 'Derived'].includes(symbol.name)) continue
+        const derived = symbol.name === 'Derived'
+        if (symbol.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol)
+        const type = checker.getDeclaredTypeOfSymbol(symbol)
+        const value = checker.getPropertyOfType(type, 'value')
+        roots.add(symbol)
+        if (derived) derivedRoots.add(symbol)
+        shapes.push({
+          names: checker.getPropertiesOfType(type).map((property) => property.name),
+          declarations: new Set(value?.getDeclarations() ?? []),
+        })
+      }
+    }
+  }
+  const core = { roots, shapes, derivedRoots }
+  programs.set(program, core)
+  return core
+}
+
+/** Whether a type avoids any, unknown and unresolved type parameters. */
+function known(ts, type) {
+  if (!type || type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter))
+    return false
+  return !type.isUnion() || type.types.every((part) => known(ts, part))
+}
+
+module.exports = { coreMembers, known }

package/src/infer/derived-writes.cjs

@@ -0,0 +1,95 @@
+// W007 maps only TypeScript's readonly write error on a proven core Derived.value.
+const { coreMembers, known } = require('./core-boxes.cjs')
+
+function derivedSymbol(ts, checker, symbol, roots, seen = new Set()) {
+  if (!symbol || seen.has(symbol)) return false
+  seen.add(symbol)
+  if (symbol.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol)
+  if (roots.has(symbol)) return true
+  return (symbol.getDeclarations() ?? []).some((declaration) => {
+    if (!ts.isTypeAliasDeclaration(declaration)) return false
+    let type = declaration.type
+    while (ts.isParenthesizedTypeNode(type)) type = type.type
+    return (
+      ts.isTypeReferenceNode(type) &&
+      derivedSymbol(ts, checker, checker.getSymbolAtLocation(type.typeName), roots, seen)
+    )
+  })
+}
+
+function derivedType(ts, checker, type, roots) {
+  if (!known(ts, type)) return false
+  if (type.isUnion()) return type.types.every((part) => derivedType(ts, checker, part, roots))
+  if (type.isIntersection()) return type.types.some((part) => derivedType(ts, checker, part, roots))
+  if (
+    derivedSymbol(ts, checker, type.aliasSymbol, roots) ||
+    derivedSymbol(ts, checker, type.getSymbol(), roots)
+  )
+    return true
+  return (
+    !!type.isClassOrInterface?.() &&
+    checker.getBaseTypes(type).some((base) => derivedType(ts, checker, base, roots))
+  )
+}
+
+function writeTarget(ts, node) {
+  for (let parent = node.parent; parent; node = parent, parent = parent.parent) {
+    if (ts.isBinaryExpression(parent) && parent.left === node) {
+      const operator = parent.operatorToken.kind
+      return (
+        operator === ts.SyntaxKind.EqualsToken ||
+        (operator >= ts.SyntaxKind.FirstCompoundAssignment &&
+          operator <= ts.SyntaxKind.LastCompoundAssignment)
+      )
+    }
+    if (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent))
+      return (
+        parent.operand === node &&
+        [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(parent.operator)
+      )
+    if (ts.isForOfStatement(parent) || ts.isForInStatement(parent))
+      return parent.initializer === node
+    const wrapped =
+      ts.isParenthesizedExpression(parent) ||
+      ts.isNonNullExpression(parent) ||
+      ts.isAsExpression(parent) ||
+      ts.isTypeAssertionExpression(parent)
+    const wrapper = wrapped && parent.expression === node
+    const pattern =
+      ts.isArrayLiteralExpression(parent) ||
+      ts.isObjectLiteralExpression(parent) ||
+      (ts.isPropertyAssignment(parent) && parent.initializer === node) ||
+      (ts.isSpreadElement(parent) && parent.expression === node) ||
+      (ts.isSpreadAssignment(parent) && parent.expression === node)
+    if (!wrapper && !pattern) return false
+  }
+  return false
+}
+
+/** Remap actual readonly assignments; ambiguous receivers and projections keep TS2540. */
+function derivedWrite(ts, program, diagnostic) {
+  if (diagnostic.code !== 2540 || !diagnostic.file || diagnostic.start === undefined) return null
+  let node = ts.getTokenAtPosition(diagnostic.file, diagnostic.start)
+  while (node && !ts.isPropertyAccessExpression(node) && !ts.isElementAccessExpression(node))
+    node = node.parent
+  if (!node || !writeTarget(ts, node)) return null
+  const name = ts.isPropertyAccessExpression(node)
+    ? node.name
+    : node.argumentExpression && ts.isStringLiteralLike(node.argumentExpression)
+      ? node.argumentExpression
+      : null
+  if (name?.text !== 'value') return null
+  const checker = program.getTypeChecker()
+  const roots = coreMembers(ts, program, checker).derivedRoots
+  if (!derivedType(ts, checker, checker.getTypeAtLocation(node.expression), roots)) return null
+  return {
+    code: 'W007',
+    severity: 'error',
+    why: 'This writes a core Derived.value; derived values are readonly computations.',
+    help:
+      'Use `state(initial)` or `state.linked(() => source)` when independent writes are intended. ' +
+      'Otherwise keep `derived(() => expression)` pure and update its source state instead.',
+  }
+}
+
+module.exports = { derivedWrite }