@weft-js/cli 0.0.0-stage → 0.1.1

package/src/infer/facts.cjs

@@ -0,0 +1,252 @@
+// What one file says about its components, from syntax alone (research 44 §4). No checker here: this runs on every save
+// and is cached by content, so the common file, with nothing to infer, costs a parse. CommonJS because the tsserver
+// plugin loads it synchronously; `ts` is passed in because a plugin must use the TypeScript that hosts it.
+
+const { createHash } = require('node:crypto')
+
+const hashOf = text => createHash('sha1').update(text).digest('base64url').slice(0, 16)
+const isCap = name => /^[A-Z]/.test(name)
+/** The comment a generated annotation starts with. It keeps the type regenerable; deleting it makes the type yours. */
+const MARK = '/*inferred*/'
+
+function isExported(ts, node) {
+  return !!ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some(m => m.kind === ts.SyntaxKind.ExportKeyword)
+}
+
+const walk = (ts, node, visit) => {
+  const go = n => { if (visit(n) !== false) ts.forEachChild(n, go) }
+  ts.forEachChild(node, go)
+}
+
+/** A function a component could be: the node, its name, and the parameter it would type. */
+function componentAt(ts, node) {
+  if (ts.isFunctionDeclaration(node) && node.name && isCap(node.name.text)) return { fn: node, name: node.name.text, nameNode: node.name, holder: node }
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && isCap(node.name.text) && !node.type && node.initializer) {
+    const init = node.initializer
+    if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) return { fn: init, name: node.name.text, nameNode: node.name, holder: node.parent.parent }
+  }
+  return null
+}
+
+const hasJsx = (ts, node) => {
+  let found = false
+  walk(ts, node, n => {
+    if (found) return false
+    if (ts.isJsxElement(n) || ts.isJsxSelfClosingElement(n) || ts.isJsxFragment(n)) found = true
+    return !found
+  })
+  return found
+}
+
+/** A parameter pattern's keys: `{ a, b = 1, c: d, ...rest }`. */
+function patternKeys(ts, sf, pattern, out) {
+  for (const el of pattern.elements) {
+    if (el.dotDotDotToken) { if (ts.isIdentifier(el.name)) out.rest = el.name.text; continue }
+    const key = el.propertyName && ts.isIdentifier(el.propertyName) ? el.propertyName.text : ts.isIdentifier(el.name) ? el.name.text : null
+    if (!key) { out.opaque = true; continue }
+    if (ts.isIdentifier(el.name)) out.aliases.set(el.name.text, key)
+    const entry = out.keys.get(key) ?? { uses: [] }
+    if (el.initializer) entry.fallback = [el.initializer.getStart(sf), el.initializer.end]
+    out.keys.set(key, entry)
+  }
+}
+
+/** Reads and writes of the prop `key` at `node`, the expression that names it. */
+function classify(ts, sf, node) {
+  const up = node.parent
+  const span = n => [n.getStart(sf), n.end]
+  if ((ts.isPostfixUnaryExpression(up) || ts.isPrefixUnaryExpression(up)) && (up.operator === ts.SyntaxKind.PlusPlusToken || up.operator === ts.SyntaxKind.MinusMinusToken)) return { as: 'number', span: span(node) }
+  if (ts.isBinaryExpression(up) && up.left === node) {
+    const op = up.operatorToken.kind
+    if (op === ts.SyntaxKind.EqualsToken || op === ts.SyntaxKind.PlusEqualsToken) return { as: 'write', span: span(node), value: span(up.right) }
+    if (op >= ts.SyntaxKind.FirstCompoundAssignment && op <= ts.SyntaxKind.LastCompoundAssignment) return { as: 'number', span: span(node) }
+  }
+  if (ts.isCallExpression(up) && up.expression === node) return { as: 'call', span: span(node), args: up.arguments.map(span) }
+  if ((ts.isPropertyAccessExpression(up) && up.expression === node) || (ts.isNonNullExpression(up))) {
+    const member = ts.isPropertyAccessExpression(up) ? up.name.text : null
+    if (member) return { as: 'member', span: span(up), member }
+  }
+  if (ts.isJsxExpression(up) && ts.isJsxAttribute(up.parent)) return { as: 'context', span: span(node) }
+  return { as: 'read', span: span(node) }
+}
+
+/** Every use of the props in a component's body. */
+function bodyUses(ts, sf, comp) {
+  const { fn, param, info } = comp
+  const names = new Set(ts.isIdentifier(param.name) ? [param.name.text] : [])
+  const use = (key, node) => {
+    const entry = info.keys.get(key) ?? { uses: [] }
+    entry.uses.push(classify(ts, sf, node))
+    info.keys.set(key, entry)
+  }
+  const shadows = (node, name) => node.parameters?.some(p => ts.isIdentifier(p.name) && p.name.text === name)
+  const visit = (node, scope) => {
+    // `const { a } = props`, `let n = props.n`: another name for the prop (research 43). Only the first level.
+    if (ts.isVariableDeclaration(node) && node.initializer) {
+      const init = node.initializer
+      if (ts.isIdentifier(init) && scope.has(init.text) && ts.isObjectBindingPattern(node.name)) patternKeys(ts, sf, node.name, info)
+      else if (ts.isPropertyAccessExpression(init) && ts.isIdentifier(init.expression) && scope.has(init.expression.text) && ts.isIdentifier(node.name)) {
+        info.aliases.set(node.name.text, init.name.text)
+        if (!info.keys.has(init.name.text)) info.keys.set(init.name.text, { uses: [] })
+        return
+      }
+    }
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && scope.has(node.expression.text)) return use(node.name.text, node)
+    if (ts.isElementAccessExpression(node) && ts.isIdentifier(node.expression) && scope.has(node.expression.text)) {
+      if (ts.isStringLiteralLike(node.argumentExpression)) return use(node.argumentExpression.text, node)
+      info.opaque = true
+    }
+    if (ts.isIdentifier(node) && info.aliases.has(node.text) && ts.isExpressionNode?.(node) !== false) {
+      const up = node.parent
+      const named = (ts.isPropertyAccessExpression(up) && up.name === node) || (ts.isPropertyAssignment(up) && up.name === node) || ts.isBindingElement(up) || (ts.isVariableDeclaration(up) && up.name === node) || ts.isJsxAttribute(up)
+      if (!named) use(info.aliases.get(node.text), node)
+    }
+    if (ts.isFunctionLike(node)) {
+      let inner = scope
+      for (const n of scope) if (shadows(node, n)) { inner = new Set(scope); inner.delete(n) }
+      ts.forEachChild(node, c => visit(c, inner))
+      return
+    }
+    ts.forEachChild(node, c => visit(c, scope))
+  }
+  if (fn.body) visit(fn.body, names)
+}
+
+function jsxSite(ts, sf, node, enclosing) {
+  const tag = node.tagName
+  if (!ts.isIdentifier(tag) && !ts.isPropertyAccessExpression(tag)) return null
+  if (ts.isIdentifier(tag) && !isCap(tag.text)) return null
+  const span = n => [n.getStart(sf), n.end]
+  const site = { tag: tag.getText(sf), tagSpan: span(tag), span: span(node), attrs: [], spreads: [], children: null, in: enclosing ?? null }
+  for (const a of node.attributes.properties) {
+    if (ts.isJsxSpreadAttribute(a)) { site.spreads.push({ span: span(a.expression), text: a.expression.getText(sf) }); continue }
+    const raw = a.name.getText(sf)
+    const bind = raw.startsWith('bind:')
+    const name = bind ? raw.slice(5) : raw
+    if (name === 'key') continue
+    const value = a.initializer
+    if (!value) { site.attrs.push({ name, literal: 'true', bind }); continue }
+    if (ts.isStringLiteral(value)) { site.attrs.push({ name, literal: 'string', exact: JSON.stringify(value.text), whole: span(a), bind }); continue }
+    const expr = value.expression
+    if (!expr) continue
+    const lambda = ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)
+    site.attrs.push({
+      name, span: span(expr), whole: span(a), bind, raw: bind ? span(a.name) : undefined,
+      untypedFn: lambda && expr.parameters.some(p => !p.type) || undefined,
+      value: ts.isIdentifier(expr) && isCap(expr.text) ? expr.text : undefined,
+    })
+  }
+  if (ts.isJsxOpeningElement(node)) {
+    const kids = node.parent.children.filter(c => !(ts.isJsxText(c) && !c.text.trim()))
+    if (kids.length) {
+      const only = kids.length === 1 ? kids[0] : null
+      const expr = only && ts.isJsxExpression(only) ? only.expression : null
+      const lambda = expr && (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr))
+      site.children = lambda ? { fn: true, span: span(expr), untypedFn: expr.parameters.some(p => !p.type) || undefined } : { fn: false }
+    }
+  }
+  return site
+}
+
+/** `const views = { a: A }`, `pick(A, B)`, `<X icon={A} />`: an identifier that leaves JSX tag position. */
+function escapes(ts, node) {
+  const up = node.parent
+  if (ts.isJsxOpeningLikeElement?.(up) && up.tagName === node) return false
+  if (ts.isJsxClosingElement(up)) return false
+  if (ts.isFunctionDeclaration(up) || ts.isVariableDeclaration(up) && up.name === node) return false
+  if (ts.isPropertyAccessExpression(up) && up.name === node) return false
+  if (ts.isExportSpecifier(up) || ts.isExportAssignment(up) || ts.isImportSpecifier(up) || ts.isImportClause(up)) return false
+  if (ts.isTypeQueryNode(up)) return false
+  return true
+}
+
+/** The names an initializer can hand back: `pick(A, B)`, `{ a: A, b: B }`, `views[k]`, `views.a`, `hoc(A)`, `x ? A : B`. */
+function holds(ts, init) {
+  const name = e => (ts.isIdentifier(e) ? [e.text] : [])
+  if (ts.isCallExpression(init)) return init.arguments.flatMap(a => name(a)).filter(isCap)
+  if (ts.isConditionalExpression(init)) return [...name(init.whenTrue), ...name(init.whenFalse)].filter(isCap)
+  if (ts.isObjectLiteralExpression(init)) return init.properties.flatMap(p => (ts.isPropertyAssignment(p) ? name(p.initializer) : ts.isShorthandPropertyAssignment(p) ? [p.name.text] : [])).filter(isCap)
+  if (ts.isElementAccessExpression(init) || ts.isPropertyAccessExpression(init)) return name(init.expression)
+  return []
+}
+
+const isOpening = (ts, n) => ts.isJsxOpeningElement(n) || ts.isJsxSelfClosingElement(n)
+
+/**
+ * @returns the file's facts: `comps` (untyped or generated), `sites` (capitalised JSX tags), `imports`, `wraps`
+ * (`const W = hoc(Inner)`), `escaped` (component names used as values), `exports` (local names).
+ */
+function fileFacts(ts, file, text, options = {}) {
+  const hash = hashOf(text)
+  if (!file.endsWith('.tsx')) return { file, hash, comps: [], sites: [], imports: new Map(), wraps: new Map(), escaped: new Set(), exported: new Set(), parse: null }
+  const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX)
+  const comps = [], sites = []
+  const imports = new Map(), wraps = new Map(), escaped = new Set(), exported = new Set()
+  let exportsLoad = false
+
+  for (const st of sf.statements) {
+    if (ts.isImportDeclaration(st) && st.importClause && ts.isStringLiteral(st.moduleSpecifier)) {
+      const from = st.moduleSpecifier.text
+      const { name, namedBindings } = st.importClause
+      if (name) imports.set(name.text, { from, name: 'default' })
+      if (namedBindings && ts.isNamedImports(namedBindings)) for (const el of namedBindings.elements) imports.set(el.name.text, { from, name: (el.propertyName ?? el.name).text })
+    }
+    if (ts.isExportAssignment(st) && ts.isIdentifier(st.expression)) exported.add(st.expression.text)
+    if (ts.isExportDeclaration(st) && st.exportClause && ts.isNamedExports(st.exportClause) && !st.moduleSpecifier) for (const el of st.exportClause.elements) exported.add((el.propertyName ?? el.name).text)
+    if (isExported(ts, st) && ts.isVariableStatement(st)) for (const d of st.declarationList.declarations) if (ts.isIdentifier(d.name) && d.name.text === 'load') exportsLoad = true
+    if (isExported(ts, st) && ts.isFunctionDeclaration(st) && st.name?.text === 'load') exportsLoad = true
+  }
+
+  const enclosing = []
+  const visit = node => {
+    const found = componentAt(ts, node)
+    if (found) {
+      const { fn, name } = found
+      const param = fn.parameters?.[0]
+      const typed = param?.type
+      const generated = typed && text.slice(param.name.end, typed.pos + 64).includes(MARK)
+      if (param && fn.parameters.length === 1 && (!typed || generated) && !param.questionToken && !param.dotDotDotToken && !fn.typeParameters && hasJsx(ts, fn)) {
+        const info = { keys: new Map(), aliases: new Map(), rest: null, opaque: false }
+        if (ts.isObjectBindingPattern(param.name)) patternKeys(ts, sf, param.name, info)
+        else if (!ts.isIdentifier(param.name)) info.opaque = true
+        const comp = {
+          id: `${file}#${name}`, file, name, param, fn, info, nameSpan: [found.nameNode.getStart(sf), found.nameNode.end],
+          bodySpan: [fn.getStart(sf), fn.end], exported: isExported(ts, found.holder), isDefault: (ts.canHaveModifiers(found.holder) ? ts.getModifiers(found.holder) ?? [] : []).some(m => m.kind === ts.SyntaxKind.DefaultKeyword),
+          paramSpan: [param.getStart(sf), param.end], nameEnd: param.name.end, parens: !!fn.getChildren?.(sf).some(c => c.kind === ts.SyntaxKind.OpenParenToken),
+          written: generated ? [param.name.end, typed.end] : null, writtenType: generated ? text.slice(typed.getStart(sf), typed.end).trim() : null,
+          forwards: [], local: enclosing.length > 0, async: !!(ts.getModifiers?.(fn) ?? []).some(m => m.kind === ts.SyntaxKind.AsyncKeyword),
+        }
+        bodyUses(ts, sf, comp)
+        comps.push(comp)
+      }
+    }
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+      const held = holds(ts, node.initializer)
+      if (held.length) wraps.set(node.name.text, held)
+    }
+    if (isOpening(ts, node)) {
+      const site = jsxSite(ts, sf, node, enclosing[enclosing.length - 1])
+      if (site) sites.push(site)
+    }
+    if (ts.isIdentifier(node) && isCap(node.text) && node.parent && !ts.isTypeReferenceNode(node.parent) && escapes(ts, node)) escaped.add(node.text)
+    const push = found && found.fn
+    if (push) enclosing.push(found.name)
+    ts.forEachChild(node, visit)
+    if (push) enclosing.pop()
+  }
+  ts.forEachChild(sf, visit)
+
+  for (const c of comps) if (exported.has(c.name) || c.isDefault) { c.exported = true; c.isDefault ||= false }
+  // Spreads and attributes forward from a component to whatever it renders.
+  for (const c of comps) {
+    const own = new Set([...(ts.isIdentifier(c.param.name) ? [c.param.name.text] : []), ...(c.info.rest ? [c.info.rest] : [])])
+    for (const s of sites) {
+      if (s.span[0] < c.fn.getStart(sf) || s.span[1] > c.fn.end) continue
+      for (const sp of s.spreads) if (own.has(sp.text)) c.forwards.push({ tag: s.tag, tagSpan: s.tagSpan, given: s.attrs.map(a => a.name) })
+    }
+  }
+  for (const c of comps) { delete c.fn; delete c.param }
+  return { file, hash, comps, sites, imports, wraps, escaped, exported, exportsLoad, parse: options.keep ? sf : null }
+}
+
+module.exports = { fileFacts, hashOf, MARK }

package/src/infer/hosts.cjs

@@ -0,0 +1,114 @@
+// The two ways to ask a checker about a shadow. Both answer the same four questions about a span (`query`), so the
+// engine doesn't know which compiler it is on. `tsgoHost` drives TypeScript 7's process through its unstable API with a
+// 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 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 => {
+    if (n.pos <= start && n.end >= end) {
+      if (n.end === end) best = n
+      each(n, go)
+    }
+  }
+  each(root, go)
+  return best
+}
+
+/** 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 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) }
+}
+
+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 '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) })) }
+    }
+    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) }
+    }
+  }
+}
+
+/** 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 { 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) } })
+  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 } },
+  }
+  return {
+    kind: 'tsgo',
+    update(files, touched = []) {
+      for (const [f, text] of files) overlay.set(f, text)
+      const next = api.updateSnapshot({ fileChanges: { changed: [...files.keys(), ...touched] } })
+      snap.dispose?.()
+      snap = next
+      project = snap.getProject(config) ?? snap.getProjects()[0]
+    },
+    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))
+    },
+    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) }))
+    },
+    allDiagnostics() {
+      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() },
+  }
+}
+
+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 } },
+  }
+  const each = (n, f) => ts.forEachChild(n, f)
+  return {
+    kind: 'language-service',
+    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))
+    },
+    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') }))
+    },
+    close() {},
+  }
+}
+
+module.exports = { tsgoHost, languageHost, nodeAt }

package/src/infer/lsp.mjs

@@ -0,0 +1,131 @@
+// `weft lsp`: TypeScript 7 loads no plugins and its content mappers refuse `.tsx`, so the one place left to stand is
+// between the editor and `tsc --lsp`. Buffers go in as their shadows; positions are mapped both ways (research 44 §6).
+
+import { spawn } from 'node:child_process'
+import { realpathSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { createRequire } from 'node:module'
+import { fileURLToPath } from 'node:url'
+import ts from 'typescript'
+
+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'])
+
+function framed(stream, on) {
+  let buffer = Buffer.alloc(0)
+  stream.on('data', d => {
+    buffer = Buffer.concat([buffer, d])
+    for (;;) {
+      const head = buffer.indexOf('\r\n\r\n')
+      if (head < 0) return
+      const len = Number(/Content-Length: (\d+)/i.exec(buffer.subarray(0, head).toString())[1])
+      if (buffer.length < head + 4 + len) return
+      const msg = JSON.parse(buffer.subarray(head + 4, head + 4 + len).toString())
+      buffer = buffer.subarray(head + 4 + len)
+      on(msg)
+    }
+  })
+}
+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 }
+  return at + character
+}
+const positionAt = (text, offset) => {
+  const head = text.slice(0, offset)
+  const line = head.split('\n').length - 1
+  return { line, character: offset - (head.lastIndexOf('\n') + 1) }
+}
+
+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')
+  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 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)))
+  }
+  const back = (value, 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 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) }
+      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)]
+
+  /** 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)]]))))
+    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 }] } })
+    }
+  }
+
+  // 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 }
+      docs.set(p.textDocument.uri, doc)
+      session.engine.set(doc.file, doc.text)
+      await refresh([doc.file])
+      doc.sent = session.engine.maps.get(doc.file)?.text ?? doc.text
+      return toServer({ ...msg, params: { textDocument: { ...p.textDocument, text: doc.sent } } })
+    }
+    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
+      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) } })
+    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() } }
+}

package/src/infer/session.cjs

@@ -0,0 +1,105 @@
+// One project's inference: a tsconfig's files, an engine, and a checker started only if something needs one. `weft
+// check`, `weft tsc` and the dev worker all use this. The tsserver plugin has a language service of its own (plugin).
+
+const { existsSync, readFileSync } = require('node:fs')
+const { createRequire } = require('node:module')
+const { dirname, join } = require('node:path')
+const { Engine } = require('./engine.cjs')
+const { languageHost, tsgoHost } = require('./hosts.cjs')
+
+/** The project's TypeScript when it can be driven without a plugin (7's API), else ours. */
+function projectTypescript(root) {
+  try {
+    const pkg = createRequire(join(root, 'package.json')).resolve('typescript/package.json')
+    const dir = dirname(pkg)
+    if (existsSync(join(dir, 'dist/api/sync/api.js'))) return dir
+  } catch {}
+  return null
+}
+
+/** A language service over the project and an overlay: TypeScript before 7. */
+function memoryHost(ts, root, config, parsed, overlay) {
+  const versions = new Map()
+  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) },
+    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,
+  }
+  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 })))
+  return out
+}
+
+class Session {
+  constructor(ts, root, options = {}) {
+    this.ts = ts
+    this.root = root
+    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.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)
+  }
+
+  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)
+    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))
+    for (const f of plain) this.overlay.delete(f)
+    this.host.update(new Map(), plain)
+  }
+
+  /** Findings and the checker's errors in the files inference touches, in source positions. */
+  async analyze(changed) {
+    if (!this.engine.needed()) return { findings: new Map(), errors: new Map(), started: false }
+    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
+    for (const file of redo) {
+      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)
+    }
+    return { findings, errors: this.errors, started: true }
+  }
+
+  /** Every file's errors, the way `tsc --noEmit` would report them with inference applied. */
+  async all() {
+    const host = await this.start()
+    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))
+    for (const file of files) {
+      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' })))
+        continue
+      }
+      const list = this.engine.errors(host, real)
+      if (list.length) errors.set(real, list)
+    }
+    return { findings, errors }
+  }
+
+  close() { this.host?.close(); this.host = null }
+}
+
+module.exports = { Session, projectTypescript }

package/src/infer/shadow.cjs

@@ -0,0 +1,46 @@
+// A shadow is the source with a few spans replaced (annotations in, `bind:` out). Nothing else moves, so mapping a
+// position is a binary search over the edits, in both directions, and it never needs a source map. Research 44 §5.
+
+/** @param {string} text @param {{ start: number, end: number, text: string }[]} edits sorted, not overlapping */
+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
+  for (const e of sorted) {
+    const len = e.start - at
+    segments.push({ src: at, out, len })
+    parts.push(text.slice(at, e.start), e.text)
+    out += len + e.text.length
+    at = e.end
+  }
+  segments.push({ src: at, out, len: text.length - at })
+  parts.push(text.slice(at))
+  return { text: parts.join(''), segments, edits: sorted }
+}
+
+function find(segments, pos, key) {
+  let lo = 0, hi = segments.length - 1
+  while (lo < hi) {
+    const mid = (lo + hi + 1) >> 1
+    if (segments[mid][key] <= pos) lo = mid
+    else hi = mid - 1
+  }
+  return segments[lo]
+}
+
+/** 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) }
+
+/** 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) }
+
+/** Whether a shadow span is inside text the source doesn't have. */
+const inGenerated = (map, start, length) => {
+  const s = find(map.segments, start, 'out')
+  return start >= s.out + s.len && length >= 0
+}
+
+const identity = text => ({ text, segments: [{ src: 0, out: 0, len: text.length }], edits: [] })
+
+module.exports = { shadow, toShadow, toSource, inGenerated, identity }