@weft-js/cli 0.1.1 → 0.1.2

package/src/infer/hosts.cjs

@@ -3,12 +3,15 @@
 // file overlay: `tsc --noEmit` of the source tree, with no files on disk and no plugin. `languageHost` reuses a language
 // service, which is what a tsserver plugin has, and what a project on TypeScript 6 gets.
 
+const { boxMismatch } = require('./box-props.cjs')
+const { derivedWrite } = require('./derived-writes.cjs')
+
 const NO_TRUNCATE = 1
 
 /** The node exactly on [start, end]: the deepest one, because `x` and `x;` can share an end but not a start. */
 function nodeAt(each, root, start, end) {
   let best = null
-  const go = n => {
+  const go = (n) => {
     if (n.pos <= start && n.end >= end) {
       if (n.end === end) best = n
       each(n, go)
@@ -21,7 +24,9 @@ function nodeAt(each, root, start, end) {
 /** The flags the engine reads. `lit`: the widened text differs from the exact one. */
 function describe(checker, type, flagsAny, node) {
   if (!type) return { text: 'any', any: true }
-  const widened = checker.getWidenedType?.(checker.getBaseTypeOfLiteralType(type)) ?? checker.getBaseTypeOfLiteralType(type)
+  const widened =
+    checker.getWidenedType?.(checker.getBaseTypeOfLiteralType(type)) ??
+    checker.getBaseTypeOfLiteralType(type)
   const text = checker.typeToString(widened, node, NO_TRUNCATE)
   const exact = checker.typeToString(type, node, NO_TRUNCATE)
   return { text, exact: exact === text ? undefined : exact, any: !!(type.flags & flagsAny) }
@@ -30,34 +35,52 @@ function describe(checker, type, flagsAny, node) {
 function answer(checker, node, req, env) {
   if (!node) return { text: 'any', any: true, missing: true }
   switch (req.kind) {
-    case 'type': return describe(checker, checker.getTypeAtLocation(node), env.Any, node)
-    case 'context': return describe(checker, checker.getContextualType(node), env.Any, node)
+    case 'type':
+      return describe(checker, checker.getTypeAtLocation(node), env.Any, node)
+    case 'context':
+      return describe(checker, checker.getContextualType(node), env.Any, node)
     case 'spread': {
       const type = checker.getTypeAtLocation(node)
       if (!type || type.flags & env.Any) return { any: true, props: [] }
-      return { props: checker.getPropertiesOfType(type).map(s => ({ name: s.name, optional: !!(s.flags & env.Optional), ...describe(checker, checker.getTypeOfSymbol(s), env.Any, node) })) }
+      return {
+        props: checker.getPropertiesOfType(type).map((s) => ({
+          name: s.name,
+          optional: !!(s.flags & env.Optional),
+          ...describe(checker, checker.getTypeOfSymbol(s), env.Any, node),
+        })),
+      }
     }
     case 'decls': {
       const type = checker.getTypeAtLocation(node)
       if (!type) return { decls: [] }
       const members = env.union(type) ?? [type]
-      return { decls: members.flatMap(t => checker.getSignaturesOfType(t, env.Call).map(s => env.place(s))).filter(Boolean) }
+      return {
+        decls: members
+          .flatMap((t) => checker.getSignaturesOfType(t, env.Call).map((s) => env.place(s)))
+          .filter(Boolean),
+      }
     }
   }
 }
 
 /** Over TypeScript 7's API. `typescript/unstable/*` is a moving name, so this is the one file that touches it. */
 async function tsgoHost({ root, config, typescriptDir, overlay }) {
-  const load = name => import(require('node:url').pathToFileURL(require('node:path').join(typescriptDir, name)).href)
+  const load = (name) =>
+    import(require('node:url').pathToFileURL(require('node:path').join(typescriptDir, name)).href)
   const { API, SignatureKind, SymbolFlags, TypeFlags } = await load('dist/api/sync/api.js')
   const each = (n, f) => n.forEachChild(f)
-  const api = new API({ cwd: root, fs: { readFile: f => overlay.get(f) } })
+  const api = new API({ cwd: root, fs: { readFile: (f) => overlay.get(f) } })
   let snap = api.updateSnapshot({ openProject: config })
   let project = snap.getProject(config) ?? snap.getProjects()[0]
   const env = {
-    Any: TypeFlags.Any, Optional: SymbolFlags.Optional, Call: SignatureKind.Call,
-    union: t => (t.isUnionType() ? t.getTypes() : null),
-    place(s) { const n = s.declaration?.resolve(project); return n && { file: s.declaration.path, pos: n.pos, end: n.end } },
+    Any: TypeFlags.Any,
+    Optional: SymbolFlags.Optional,
+    Call: SignatureKind.Call,
+    union: (t) => (t.isUnionType() ? t.getTypes() : null),
+    place(s) {
+      const n = s.declaration?.resolve(project)
+      return n && { file: s.declaration.path, pos: n.pos, end: n.end }
+    },
   }
   return {
     kind: 'tsgo',
@@ -71,41 +94,65 @@ async function tsgoHost({ root, config, typescriptDir, overlay }) {
     query(file, reqs) {
       const sf = project.program.getSourceFile(file)
       if (!sf) return reqs.map(() => ({ text: 'any', any: true, missing: true }))
-      return reqs.map(r => answer(project.checker, nodeAt(each, sf, r.start, r.end), r, env))
+      return reqs.map((r) => answer(project.checker, nodeAt(each, sf, r.start, r.end), r, env))
     },
     diagnostics(file) {
-      return [...project.program.getSyntacticDiagnostics(file), ...project.program.getSemanticDiagnostics(file)].map(d => ({ start: d.pos, length: d.end - d.pos, code: d.code, text: flatten(d) }))
+      return [
+        ...project.program.getSyntacticDiagnostics(file),
+        ...project.program.getSemanticDiagnostics(file),
+      ].map((d) => ({ start: d.pos, length: d.end - d.pos, code: d.code, text: flatten(d) }))
     },
     allDiagnostics() {
-      return project.program.getSourceFileNames().filter(f => !f.includes('/node_modules/')).flatMap(f => this.diagnostics(f).map(d => ({ ...d, file: f })))
+      return project.program
+        .getSourceFileNames()
+        .filter((f) => !f.includes('/node_modules/'))
+        .flatMap((f) => this.diagnostics(f).map((d) => ({ ...d, file: f })))
+    },
+    close() {
+      snap.dispose?.()
+      api.close()
     },
-    close() { snap.dispose?.(); api.close() },
   }
 }
 
-const flatten = d => (typeof d.text === 'string' ? d.text : d.message ?? d.messageText ?? String(d.text)) + (d.messageChain?.length ? `\n  ${d.messageChain.map(flatten).join('\n  ')}` : '')
+const flatten = (d) =>
+  (typeof d.text === 'string' ? d.text : (d.message ?? d.messageText ?? String(d.text))) +
+  (d.messageChain?.length ? `\n  ${d.messageChain.map(flatten).join('\n  ')}` : '')
 
 /** Over a TypeScript language service: `service()` returns it, `sync()` makes it see what `update` was told. */
 function languageHost(ts, service, sync = () => {}) {
   const env = {
-    Any: ts.TypeFlags.Any, Optional: ts.SymbolFlags.Optional, Call: ts.SignatureKind.Call,
-    union: t => (t.isUnion() ? t.types : null),
-    place(s) { const n = s.declaration; return n && { file: n.getSourceFile().fileName, pos: n.pos, end: n.end } },
+    Any: ts.TypeFlags.Any,
+    Optional: ts.SymbolFlags.Optional,
+    Call: ts.SignatureKind.Call,
+    union: (t) => (t.isUnion() ? t.types : null),
+    place(s) {
+      const n = s.declaration
+      return n && { file: n.getSourceFile().fileName, pos: n.pos, end: n.end }
+    },
   }
   const each = (n, f) => ts.forEachChild(n, f)
   return {
     kind: 'language-service',
-    update(files, touched = []) { sync(files, touched) },
+    update(files, touched = []) {
+      sync(files, touched)
+    },
     query(file, reqs) {
       const program = service().getProgram()
       const sf = program.getSourceFile(file)
       if (!sf) return reqs.map(() => ({ text: 'any', any: true, missing: true }))
       const checker = program.getTypeChecker()
-      return reqs.map(r => answer(checker, nodeAt(each, sf, r.start, r.end), r, env))
+      return reqs.map((r) => answer(checker, nodeAt(each, sf, r.start, r.end), r, env))
     },
     diagnostics(file) {
       const s = service()
-      return [...s.getSyntacticDiagnostics(file), ...s.getSemanticDiagnostics(file)].map(d => ({ start: d.start ?? 0, length: d.length ?? 0, code: d.code, text: ts.flattenDiagnosticMessageText(d.messageText, '\n') }))
+      return [...s.getSyntacticDiagnostics(file), ...s.getSemanticDiagnostics(file)].map((d) => ({
+        start: d.start ?? 0,
+        length: d.length ?? 0,
+        code: d.code,
+        text: ts.flattenDiagnosticMessageText(d.messageText, '\n'),
+        weft: derivedWrite(ts, s.getProgram(), d) ?? boxMismatch(ts, s.getProgram(), d),
+      }))
     },
     close() {},
   }

package/src/infer/lsp.mjs

@@ -12,11 +12,19 @@ const require = createRequire(import.meta.url)
 const { Session, projectTypescript } = require('./session.cjs')
 const { inGenerated, toShadow, toSource } = require('./shadow.cjs')
 
-const RANGES = new Set(['range', 'selectionRange', 'targetRange', 'targetSelectionRange', 'originSelectionRange', 'insert', 'replace'])
+const RANGES = new Set([
+  'range',
+  'selectionRange',
+  'targetRange',
+  'targetSelectionRange',
+  'originSelectionRange',
+  'insert',
+  'replace',
+])
 
 function framed(stream, on) {
   let buffer = Buffer.alloc(0)
-  stream.on('data', d => {
+  stream.on('data', (d) => {
     buffer = Buffer.concat([buffer, d])
     for (;;) {
       const head = buffer.indexOf('\r\n\r\n')
@@ -29,11 +37,18 @@ function framed(stream, on) {
     }
   })
 }
-const frame = msg => { const body = Buffer.from(JSON.stringify(msg)); return Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r\n\r\n`), body]) }
+const frame = (msg) => {
+  const body = Buffer.from(JSON.stringify(msg))
+  return Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r\n\r\n`), body])
+}
 
 const offsetAt = (text, { line, character }) => {
   let at = 0
-  for (let i = 0; i < line; i++) { const n = text.indexOf('\n', at); if (n < 0) return text.length; at = n + 1 }
+  for (let i = 0; i < line; i++) {
+    const n = text.indexOf('\n', at)
+    if (n < 0) return text.length
+    at = n + 1
+  }
   return at + character
 }
 const positionAt = (text, offset) => {
@@ -44,59 +59,159 @@ const positionAt = (text, offset) => {
 
 export function lsp(root, { input = process.stdin, output = process.stdout } = {}) {
   const dir = projectTypescript(root)
-  if (!dir) throw Object.assign(new Error('`weft lsp` needs TypeScript 7 in the project; older versions use the tsserver plugin'), { code: 'E_USAGE' })
-  const exe = join(dirname(createRequire(join(realpathSync(dir), 'package.json')).resolve(`@typescript/typescript-${process.platform}-${process.arch}/package.json`)), 'lib', process.platform === 'win32' ? 'tsc.exe' : 'tsc')
+  if (!dir)
+    throw Object.assign(
+      new Error(
+        '`weft lsp` needs TypeScript 7 in the project; older versions use the tsserver plugin',
+      ),
+      { code: 'E_USAGE' },
+    )
+  const exe = join(
+    dirname(
+      createRequire(join(realpathSync(dir), 'package.json')).resolve(
+        `@typescript/typescript-${process.platform}-${process.arch}/package.json`,
+      ),
+    ),
+    'lib',
+    process.platform === 'win32' ? 'tsc.exe' : 'tsc',
+  )
   const server = spawn(exe, ['--lsp', '--stdio'], { cwd: root, stdio: ['pipe', 'pipe', 'inherit'] })
   const session = new Session(ts, root)
   const docs = new Map() // uri → { file, text, sent, version }
   const pending = new Map() // request id → uri
-  const toServer = m => server.stdin.write(frame(m))
-  const toClient = m => output.write(frame(m))
-  const fileOf = uri => fileURLToPath(uri)
-  const mapOf = doc => doc && session.engine.maps.get(doc.file)
+  const toServer = (m) => server.stdin.write(frame(m))
+  const toClient = (m) => output.write(frame(m))
+  const fileOf = (uri) => fileURLToPath(uri)
+  const { pos, back, items } = makeMapping(session, docs)
+
+  const client = makeClient({ docs, session, toServer, pos, fileOf, pending })
+
+  // One at a time: a request has to see the shadow its position is mapped for.
+  let line = Promise.resolve()
+  framed(input, (msg) => {
+    line = line.then(() => client(msg)).catch((e) => process.stderr.write(`weft lsp: ${e.stack}\n`))
+  })
+
+  framed(server.stdout, (msg) => {
+    if (msg.method === 'textDocument/publishDiagnostics') {
+      const doc = docs.get(msg.params.uri)
+      return toClient(
+        doc
+          ? { ...msg, params: { ...msg.params, diagnostics: items(doc, msg.params.diagnostics) } }
+          : msg,
+      )
+    }
+    const hold = msg.id !== undefined && !msg.method ? pending.get(msg.id) : null
+    if (!hold) return toClient(msg)
+    pending.delete(msg.id)
+    if (hold.method === 'textDocument/diagnostic' && msg.result?.items)
+      return toClient({
+        ...msg,
+        result: { ...msg.result, items: items(hold.doc, msg.result.items) },
+      })
+    toClient({ ...msg, result: back(msg.result, hold.doc) })
+  })
+  server.on('exit', (code) => {
+    session.close()
+    process.exitCode = code ?? 0
+  })
+  return {
+    server,
+    close: () => {
+      server.kill()
+      session.close()
+    },
+  }
+}
+
+function makeMapping(session, docs) {
+  const mapOf = (doc) => doc && session.engine.maps.get(doc.file)
 
   const pos = (doc, p, to) => {
     const map = mapOf(doc)
     if (!map) return p
-    return to ? positionAt(map.text, toShadow(map, offsetAt(doc.text, p))) : positionAt(doc.text, toSource(map, offsetAt(map.text, p)))
+    return to
+      ? positionAt(map.text, toShadow(map, offsetAt(doc.text, p)))
+      : positionAt(doc.text, toSource(map, offsetAt(map.text, p)))
   }
   const back = (value, doc) => {
-    if (Array.isArray(value)) return value.map(v => back(v, doc))
+    if (Array.isArray(value)) return value.map((v) => back(v, doc))
     if (!value || typeof value !== 'object') return value
     const uri = value.uri ?? value.targetUri
-    const here = uri ? docs.get(uri) ?? doc : doc
+    const here = uri ? (docs.get(uri) ?? doc) : doc
     const out = {}
     for (const [k, v] of Object.entries(value)) {
-      if (RANGES.has(k) && v?.start && mapOf(here)) out[k] = { start: pos(here, v.start), end: pos(here, v.end) }
+      if (RANGES.has(k) && v?.start && mapOf(here))
+        out[k] = { start: pos(here, v.start), end: pos(here, v.end) }
       else out[k] = back(v, here)
     }
     return out
   }
-  const generated = (doc, d) => { const map = mapOf(doc); if (!map) return false; const a = offsetAt(map.text, d.range.start); return inGenerated(map, a, offsetAt(map.text, d.range.end) - a) }
-  const ours = doc => (session.engine.findings.get(doc.file) ?? []).map(f => ({
-    range: { start: positionAt(doc.text, f.start), end: positionAt(doc.text, f.end) }, severity: f.severity === 'warning' ? 2 : 1, code: f.code, source: 'weft', message: `${f.why} Fix: ${f.help}`,
-  }))
-  const items = (doc, list) => [...back(list.filter(d => !generated(doc, d)), doc).filter(d => !(session.engine.findings.get(doc.file) ?? []).some(f => f.code === 'W084' && offsetAt(doc.text, d.range.start) < f.end && f.start <= offsetAt(doc.text, d.range.start))), ...ours(doc)]
+  const generated = (doc, d) => {
+    const map = mapOf(doc)
+    if (!map) return false
+    const a = offsetAt(map.text, d.range.start)
+    return inGenerated(map, a, offsetAt(map.text, d.range.end) - a)
+  }
+  const ours = (doc) =>
+    (session.engine.findings.get(doc.file) ?? []).map((f) => ({
+      range: { start: positionAt(doc.text, f.start), end: positionAt(doc.text, f.end) },
+      severity: f.severity === 'warning' ? 2 : 1,
+      code: f.code,
+      source: 'weft',
+      message: `${f.why} Fix: ${f.help}`,
+    }))
+  const items = (doc, list) => [
+    ...back(
+      list.filter((d) => !generated(doc, d)),
+      doc,
+    ).filter(
+      (d) =>
+        !(session.engine.findings.get(doc.file) ?? []).some(
+          (f) =>
+            f.code === 'W084' &&
+            offsetAt(doc.text, d.range.start) < f.end &&
+            f.start <= offsetAt(doc.text, d.range.start),
+        ),
+    ),
+    ...ours(doc),
+  ]
 
+  return { pos, back, items }
+}
+
+function makeClient({ docs, session, toServer, pos, fileOf, pending }) {
   /** Inference over the buffers, then every open file whose shadow moved. */
   async function refresh(changed) {
-    if (session.host) session.host.update(new Map(changed.flatMap(f => (session.engine.maps.has(f) ? [] : [[f, session.engine.texts.get(f)]]))))
+    if (session.host)
+      session.host.update(
+        new Map(
+          changed.flatMap((f) =>
+            session.engine.maps.has(f) ? [] : [[f, session.engine.texts.get(f)]],
+          ),
+        ),
+      )
     await session.analyze(session.host ? changed : undefined)
     for (const [uri, doc] of docs) {
       const text = session.engine.maps.get(doc.file)?.text ?? doc.text
       if (text === doc.sent) continue
       doc.sent = text
-      toServer({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri, version: ++doc.version }, contentChanges: [{ text }] } })
+      toServer({
+        jsonrpc: '2.0',
+        method: 'textDocument/didChange',
+        params: { textDocument: { uri, version: ++doc.version }, contentChanges: [{ text }] },
+      })
     }
   }
 
-  // One at a time: a request has to see the shadow its position is mapped for.
-  let line = Promise.resolve()
-  framed(input, msg => { line = line.then(() => client(msg)).catch(e => process.stderr.write(`weft lsp: ${e.stack}\n`)) })
   async function client(msg) {
     const p = msg.params
     if (msg.method === 'textDocument/didOpen') {
-      const doc = { file: fileOf(p.textDocument.uri), text: p.textDocument.text, version: p.textDocument.version }
+      const doc = {
+        file: fileOf(p.textDocument.uri),
+        text: p.textDocument.text,
+        version: p.textDocument.version,
+      }
       docs.set(p.textDocument.uri, doc)
       session.engine.set(doc.file, doc.text)
       await refresh([doc.file])
@@ -105,27 +220,21 @@ export function lsp(root, { input = process.stdin, output = process.stdout } = {
     }
     if (msg.method === 'textDocument/didChange') {
       const doc = docs.get(p.textDocument.uri)
-      for (const c of p.contentChanges) doc.text = c.range ? doc.text.slice(0, offsetAt(doc.text, c.range.start)) + c.text + doc.text.slice(offsetAt(doc.text, c.range.end)) : c.text
+      for (const c of p.contentChanges)
+        doc.text = c.range
+          ? doc.text.slice(0, offsetAt(doc.text, c.range.start)) +
+            c.text +
+            doc.text.slice(offsetAt(doc.text, c.range.end))
+          : c.text
       session.engine.set(doc.file, doc.text)
       return refresh([doc.file])
     }
     const doc = p?.textDocument && docs.get(p.textDocument.uri)
     if (msg.id !== undefined && doc) pending.set(msg.id, { doc, method: msg.method })
-    if (doc && p.position) return toServer({ ...msg, params: { ...p, position: pos(doc, p.position, true) } })
+    if (doc && p.position)
+      return toServer({ ...msg, params: { ...p, position: pos(doc, p.position, true) } })
     toServer(msg)
   }
 
-  framed(server.stdout, msg => {
-    if (msg.method === 'textDocument/publishDiagnostics') {
-      const doc = docs.get(msg.params.uri)
-      return toClient(doc ? { ...msg, params: { ...msg.params, diagnostics: items(doc, msg.params.diagnostics) } } : msg)
-    }
-    const hold = msg.id !== undefined && !msg.method ? pending.get(msg.id) : null
-    if (!hold) return toClient(msg)
-    pending.delete(msg.id)
-    if (hold.method === 'textDocument/diagnostic' && msg.result?.items) return toClient({ ...msg, result: { ...msg.result, items: items(hold.doc, msg.result.items) } })
-    toClient({ ...msg, result: back(msg.result, hold.doc) })
-  })
-  server.on('exit', code => { session.close(); process.exitCode = code ?? 0 })
-  return { server, close: () => { server.kill(); session.close() } }
+  return client
 }

package/src/infer/session.cjs

@@ -6,6 +6,7 @@ const { createRequire } = require('node:module')
 const { dirname, join } = require('node:path')
 const { Engine } = require('./engine.cjs')
 const { languageHost, tsgoHost } = require('./hosts.cjs')
+const { withBoxProps } = require('./box-props.cjs')
 
 /** The project's TypeScript when it can be driven without a plugin (7's API), else ours. */
 function projectTypescript(root) {
@@ -23,16 +24,34 @@ function memoryHost(ts, root, config, parsed, overlay) {
   const host = {
     getCompilationSettings: () => parsed.options,
     getScriptFileNames: () => parsed.fileNames,
-    getScriptVersion: f => String(versions.get(f) ?? 0),
-    getScriptSnapshot(f) { const t = overlay.get(f) ?? (existsSync(f) ? readFileSync(f, 'utf8') : undefined); return t === undefined ? undefined : ts.ScriptSnapshot.fromString(t) },
+    getScriptVersion: (f) => String(versions.get(f) ?? 0),
+    getScriptSnapshot(f) {
+      const t = overlay.get(f) ?? (existsSync(f) ? readFileSync(f, 'utf8') : undefined)
+      return t === undefined ? undefined : ts.ScriptSnapshot.fromString(t)
+    },
     getCurrentDirectory: () => root,
-    getDefaultLibFileName: o => ts.getDefaultLibFilePath(o),
-    fileExists: ts.sys.fileExists, readFile: ts.sys.readFile, readDirectory: ts.sys.readDirectory, directoryExists: ts.sys.directoryExists, getDirectories: ts.sys.getDirectories,
+    getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+    readDirectory: ts.sys.readDirectory,
+    directoryExists: ts.sys.directoryExists,
+    getDirectories: ts.sys.getDirectories,
   }
   const service = ts.createLanguageService(host)
-  const bump = f => versions.set(f, (versions.get(f) ?? 0) + 1)
-  const out = languageHost(ts, () => service, (files, touched) => { for (const [f, t] of files) { overlay.set(f, t); bump(f) } touched.forEach(bump) })
-  out.allDiagnostics = () => parsed.fileNames.flatMap(f => out.diagnostics(f).map(d => ({ ...d, file: f })))
+  const bump = (f) => versions.set(f, (versions.get(f) ?? 0) + 1)
+  const out = languageHost(
+    ts,
+    () => service,
+    (files, touched) => {
+      for (const [f, t] of files) {
+        overlay.set(f, t)
+        bump(f)
+      }
+      touched.forEach(bump)
+    },
+  )
+  out.allDiagnostics = () =>
+    parsed.fileNames.flatMap((f) => out.diagnostics(f).map((d) => ({ ...d, file: f })))
   return out
 }
 
@@ -43,23 +62,38 @@ class Session {
     this.config = options.config ?? join(root, 'tsconfig.json')
     const raw = ts.readConfigFile(this.config, ts.sys.readFile)
     this.parsed = ts.parseJsonConfigFileContent(raw.config ?? {}, ts.sys, root)
-    this.engine = new Engine({ ts, read: f => (existsSync(f) ? readFileSync(f, 'utf8') : undefined), routes: options.routes })
+    this.engine = new Engine({
+      ts,
+      read: (f) => (existsSync(f) ? readFileSync(f, 'utf8') : undefined),
+      routes: options.routes,
+    })
     this.host = null
     this.overlay = new Map()
     this.errors = new Map()
-    for (const f of this.parsed.fileNames) if (f.endsWith('.tsx')) this.engine.set(f)
+    for (const f of this.parsed.fileNames) if (/\.(?:[cm]?ts|tsx)$/.test(f)) this.engine.set(f)
   }
 
   async start() {
     if (this.host) return this.host
     const dir = projectTypescript(this.root)
-    this.host = dir ? await tsgoHost({ root: this.root, config: this.config, typescriptDir: dir, overlay: this.overlay }) : memoryHost(this.ts, this.root, this.config, this.parsed, this.overlay)
+    this.host = dir
+      ? await tsgoHost({
+          root: this.root,
+          config: this.config,
+          typescriptDir: dir,
+          overlay: this.overlay,
+        })
+      : memoryHost(this.ts, this.root, this.config, this.parsed, this.overlay)
+    if (dir)
+      this.host = withBoxProps(this.host, () =>
+        memoryHost(this.ts, this.root, this.config, this.parsed, this.overlay),
+      )
     return this.host
   }
 
   /** Saved files: the checker reads them again, except where a shadow still stands in for them. */
   touch(files) {
-    const plain = files.filter(f => !this.engine.maps.has(f))
+    const plain = files.filter((f) => !this.engine.maps.has(f))
     for (const f of plain) this.overlay.delete(f)
     this.host.update(new Map(), plain)
   }
@@ -70,9 +104,15 @@ class Session {
     const fresh = !this.host
     const host = await this.start()
     const findings = this.engine.run(host, fresh ? undefined : changed)
-    const redo = fresh || !changed ? this.engine.affected() : this.engine.touched
+    const redo =
+      fresh || !changed || this.engine.typedChecksNeeded()
+        ? this.engine.affected()
+        : this.engine.touched
     for (const file of redo) {
-      if (!this.engine.facts.has(file)) { this.errors.delete(file); continue }
+      if (!this.engine.facts.has(file)) {
+        this.errors.delete(file)
+        continue
+      }
       const list = this.engine.errors(host, file)
       if (list.length) this.errors.set(file, list)
       else this.errors.delete(file)
@@ -86,11 +126,24 @@ class Session {
     const findings = this.engine.needed() ? this.engine.run(host) : new Map()
     const diags = host.allDiagnostics()
     const errors = new Map()
-    const files = new Set(diags.map(d => d.file))
+    const files = new Set(diags.map((d) => d.file))
     for (const file of files) {
-      const real = [...this.engine.facts.keys()].find(f => f.toLowerCase() === file.toLowerCase()) ?? file
+      const real =
+        [...this.engine.facts.keys()].find((f) => f.toLowerCase() === file.toLowerCase()) ?? file
       if (!this.engine.facts.has(real)) {
-        errors.set(real, diags.filter(d => d.file === file).map(d => ({ code: `TS${d.code}`, start: d.start, end: d.start + d.length, why: d.text, help: 'Fix the type error' })))
+        errors.set(
+          real,
+          diags
+            .filter((d) => d.file === file)
+            .map((d) => ({
+              code: `TS${d.code}`,
+              start: d.start,
+              end: d.start + d.length,
+              why: d.text,
+              help: 'Fix the type error',
+              ...d.weft,
+            })),
+        )
         continue
       }
       const list = this.engine.errors(host, real)
@@ -99,7 +152,10 @@ class Session {
     return { findings, errors }
   }
 
-  close() { this.host?.close(); this.host = null }
+  close() {
+    this.host?.close()
+    this.host = null
+  }
 }
 
 module.exports = { Session, projectTypescript }

package/src/infer/shadow.cjs

@@ -6,7 +6,8 @@ function shadow(text, edits) {
   const sorted = [...edits].sort((a, b) => a.start - b.start)
   const parts = []
   const segments = [] // { src, out, len }: runs that are unchanged
-  let at = 0, out = 0
+  let at = 0,
+    out = 0
   for (const e of sorted) {
     const len = e.start - at
     segments.push({ src: at, out, len })
@@ -20,7 +21,8 @@ function shadow(text, edits) {
 }
 
 function find(segments, pos, key) {
-  let lo = 0, hi = segments.length - 1
+  let lo = 0,
+    hi = segments.length - 1
   while (lo < hi) {
     const mid = (lo + hi + 1) >> 1
     if (segments[mid][key] <= pos) lo = mid
@@ -30,10 +32,16 @@ function find(segments, pos, key) {
 }
 
 /** Source position to shadow position. */
-const toShadow = (map, pos) => { const s = find(map.segments, pos, 'src'); return s.out + Math.min(pos - s.src, s.len) }
+const toShadow = (map, pos) => {
+  const s = find(map.segments, pos, 'src')
+  return s.out + Math.min(pos - s.src, s.len)
+}
 
 /** Shadow position to source position. A position inside generated text lands where that text was inserted. */
-const toSource = (map, pos) => { const s = find(map.segments, pos, 'out'); return s.src + Math.min(pos - s.out, s.len) }
+const toSource = (map, pos) => {
+  const s = find(map.segments, pos, 'out')
+  return s.src + Math.min(pos - s.out, s.len)
+}
 
 /** Whether a shadow span is inside text the source doesn't have. */
 const inGenerated = (map, start, length) => {
@@ -41,6 +49,6 @@ const inGenerated = (map, start, length) => {
   return start >= s.out + s.len && length >= 0
 }
 
-const identity = text => ({ text, segments: [{ src: 0, out: 0, len: text.length }], edits: [] })
+const identity = (text) => ({ text, segments: [{ src: 0, out: 0, len: text.length }], edits: [] })
 
 module.exports = { shadow, toShadow, toSource, inGenerated, identity }