@tabnas/lsp 0.1.0

package/src/registry.js

@@ -0,0 +1,194 @@
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+'use strict'
+
+// Grammar registry: document -> grammar resolution for the unified
+// language server. Entries come from three sources with precedence
+// workspace > user > bundled (design §3, admin
+// notes/2026-08-17-unified-lsp-design.md).
+//
+// Workspace entries are FOLDER-SCOPED: they carry the folder they came
+// from (`_dir`) and apply only to documents inside it, resolved by
+// path containment with the deepest folder winning. Two roots
+// declaring the same languageId therefore keep their own grammars —
+// a flat languageId-keyed map made the last-loaded folder capture the
+// first folder's documents (review catch on #1). User and bundled
+// entries are global and keyed by languageId as before.
+//
+// A registry entry is a tabnas.plugin.json descriptor plus the
+// LSP-specific fields the descriptors do not carry yet (languageId,
+// grammarKind, pluginKind, syncGroups, semanticTokens, lexStream) —
+// supplied by the overrides table in data/registry.json until the
+// ax-descriptor extension (plan C1) lands them per repo.
+
+const path = require('path')
+
+// Load the generated bundle (tools/gen-registry.js).
+function loadBundled(file) {
+  const bundle = require(file || path.join(__dirname, '..', 'data', 'registry.json'))
+  return bundle.entries.map(normalize)
+}
+
+function normalize(e) {
+  return {
+    name: e.name,
+    languageId: e.languageId || (e.name || '').replace(/^@tabnas\//, ''),
+    extensions: e.extensions || [],
+    mediaTypes: e.mediaTypes || [],
+    base: e.base || null,
+    pluginKind: e.pluginKind || 'grammar', // grammar | compiler | modifier
+    grammarKind: e.grammarKind || 'closure', // data | compiled | closure | imperative | external
+    lexStream: e.lexStream || 'clean', // clean | speculative
+    syncGroups: e.syncGroups || null,
+    semanticTokens: e.semanticTokens || {},
+    outlineRules: e.outlineRules || null,
+    errorCodes: e.errorCodes || [],
+    enabled: false !== e.enabled,
+    // How to load: { module } | { spec } | { grammar } — the loader
+    // (loaders.js) dispatches on this.
+    load: e.load || { module: e.name },
+    options: e.options || {},
+    stack: e.stack || null, // explicit plugin stack override
+    // Provenance, stamped by the host: which config tier supplied this
+    // entry ('bundled' | 'user' | 'workspace').
+    _source: e._source || 'bundled',
+    // _dir is the SANDBOX BASE: the folder a workspace entry's relative
+    // grammar paths resolve against (loaders.js resolveSandboxed), and
+    // part of the instance cache key.
+    _dir: e._dir || null,
+    // _scope is the ROUTING SCOPE and is deliberately separate: the
+    // folder whose documents this entry serves, or null for "anywhere".
+    // Conflating the two broke client-supplied entries — they need a
+    // sandbox base (some folder) but are session-wide, so scoping them
+    // to that base made them invisible in every other workspace folder.
+    // Defaults to _dir so a folder manifest stays folder-scoped.
+    _scope: '_scope' in e ? e._scope : (e._dir || null),
+  }
+}
+
+// The filesystem path of a document URI, null for non-file documents
+// (untitled:, vscode-notebook-cell:, …) — workspace scoping applies
+// only to documents that live in a folder.
+function fsPathOf(uri) {
+  const m = /^file:\/\/[^/]*(\/.*)$/.exec(uri || '')
+  if (!m) return null
+  let p = decodeURIComponent(m[1])
+  // Windows drive form: /c:/dir -> c:/dir
+  if (/^\/[A-Za-z]:/.test(p)) p = p.slice(1)
+  return p
+}
+
+// Containment over the two path shapes this server actually holds.
+// fsPathOf() always yields forward slashes; the folder side comes from
+// url.fileURLToPath, which yields BACKSLASHES on win32 — so on Windows
+// the two sides never matched and folder-scoped routing was dead. The
+// dir side is normalised to forward slashes before comparing.
+//
+// That rewrite applies only to paths that are actually WINDOWS-SHAPED
+// — a drive letter (`c:\ws\alpha`) or a UNC root (`\\srv\share`). The
+// discriminator is the path's shape, not process.platform, and both
+// halves of that choice are deliberate:
+//
+//   - Unconditional rewriting was wrong. On POSIX a backslash is an
+//     ordinary filename character, so a workspace rooted at `/work/a\b`
+//     stopped containing its own documents and started matching the
+//     unrelated `/work/a/b` tree instead.
+//   - Sniffing process.platform would be wrong too. Windows routing is
+//     tested on Linux (there is no win32 runner in this repo's matrix),
+//     and a platform gate makes that test vacuous on every host that
+//     runs it.
+const WINDOWSY = /^([A-Za-z]:|\\\\)/
+
+function contains(dir, fsPath) {
+  if (null == dir || null == fsPath) return false
+  let d = String(dir)
+  if (WINDOWSY.test(d)) d = d.replace(/\\/g, '/')
+  d = d.replace(/\/+$/, '')
+  return fsPath === d || fsPath.startsWith(d + '/')
+}
+
+class Registry {
+  constructor(bundled, workspace, user) {
+    // Global tiers, keyed by languageId: user beats bundled.
+    this.global = new Map()
+    for (const list of [bundled || [], user || []]) {
+      for (const raw of list) {
+        const e = normalize(raw)
+        this.global.set(e.languageId, e)
+      }
+    }
+    // Workspace tier: folder-scoped, ordered as given.
+    this.workspace = (workspace || []).map(normalize)
+  }
+
+  get(languageId) {
+    return this.global.get(languageId)
+  }
+
+  // Resolve a document to an entry.
+  //
+  // Workspace entries win for documents inside their folder — matched
+  // by languageId first, then by extension, deepest folder first.
+  // Outside any workspace folder (or when none matches), the client
+  // languageId wins only when it names an ENABLED global entry
+  // (editors send generic ids like 'plaintext' for unknown
+  // extensions); otherwise fall back to the most-specific extension
+  // match. Ties surface for diagnostics.
+  resolve(languageId, uri) {
+    const fsPath = fsPathOf(uri)
+    const ext = extOf(uri)
+
+    // Workspace candidates, most specific first: entries scoped to a
+    // folder containing this document (deepest folder wins), then
+    // unscoped session-wide entries. An unscoped entry still applies to
+    // a non-file document (untitled:, vscode-notebook-cell:), which a
+    // folder-scoped one never can.
+    const usable = this.workspace.filter(
+      (e) => e.enabled && 'modifier' !== e.pluginKind)
+    const scoped = null == fsPath ? [] : usable
+      .filter((e) => null != e._scope && contains(e._scope, fsPath))
+      .sort((a, b) => String(b._scope).length - String(a._scope).length)
+    const candidates = scoped.concat(usable.filter((e) => null == e._scope))
+
+    if (0 < candidates.length) {
+      const byId = candidates.find((e) => e.languageId === languageId)
+      if (byId) return { entry: byId, via: 'workspace:languageId' }
+      const byExt = candidates.find((e) =>
+        null != ext && e.extensions.some((x) => x.toLowerCase() === ext))
+      if (byExt) return { entry: byExt, via: 'workspace:extension' }
+    }
+
+    const direct = this.global.get(languageId)
+    if (direct && direct.enabled && 'modifier' !== direct.pluginKind) {
+      return { entry: direct, via: 'languageId' }
+    }
+
+    if (!ext) return { entry: null, via: null }
+
+    let best = null
+    let ambiguous = []
+    for (const e of this.global.values()) {
+      if (!e.enabled || 'modifier' === e.pluginKind) continue
+      for (const x of e.extensions) {
+        if (x.toLowerCase() === ext) {
+          if (best && best.entry !== e) ambiguous.push(e)
+          else best = { entry: e, via: 'extension' }
+        }
+      }
+    }
+    if (best && 0 < ambiguous.length) {
+      best.ambiguous = [best.entry.languageId, ...ambiguous.map((e) => e.languageId)]
+    }
+    return best || { entry: null, via: null }
+  }
+
+  all() {
+    return [...this.global.values(), ...this.workspace]
+  }
+}
+
+function extOf(uri) {
+  const m = /(\.[^./\\]+)$/.exec(uri || '')
+  return m ? m[1].toLowerCase() : null
+}
+
+module.exports = { Registry, loadBundled, normalize, fsPathOf }

package/src/server.js

@@ -0,0 +1,371 @@
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+'use strict'
+
+// Protocol front-end: a thin vscode-languageserver wiring over core.js
+// (design §11). Incremental sync, version-stamped push diagnostics,
+// per-language routing via the registry, workspace-registered grammars
+// (the dynamic-add lanes, design §6), and the tabnas/status custom
+// request.
+//
+// The protocol library is required lazily so core.js stays testable
+// without it (and so a browser build can substitute
+// vscode-languageserver/browser).
+
+const fs = require('fs')
+const path = require('path')
+const url = require('url')
+
+const { Registry, loadBundled } = require('./registry')
+const { DocumentStore } = require('./documents')
+const { SerialInstances } = require('./instances')
+const { makeLoader, LoadError } = require('./loaders')
+const core = require('./core')
+
+const DEBOUNCE_MS = 150
+
+// Name of the per-workspace-folder grammar manifest.
+const WORKSPACE_MANIFEST = '.tabnas/lsp.json'
+
+function folderPathOf(uriOrPath) {
+  if (null == uriOrPath) return null
+  if (/^file:/.test(uriOrPath)) {
+    try {
+      return url.fileURLToPath(uriOrPath)
+    } catch (e) {
+      return null
+    }
+  }
+  return uriOrPath
+}
+
+// Read a folder's .tabnas/lsp.json manifest: { languages: [entry...] }.
+// Entries are stamped workspace-sourced with the folder as their
+// sandbox dir; a malformed manifest is reported, never fatal.
+function readWorkspaceManifest(folder, report) {
+  const file = path.join(folder, WORKSPACE_MANIFEST)
+  let text
+  try {
+    text = fs.readFileSync(file, 'utf8')
+  } catch (e) {
+    return [] // no manifest — the common case
+  }
+  try {
+    const manifest = JSON.parse(text)
+    const languages = Array.isArray(manifest.languages) ? manifest.languages : []
+    return languages.map((e) =>
+      Object.assign({}, e, { _source: 'workspace', _dir: folder }))
+  } catch (e) {
+    if (report) report(file + ': ' + e.message)
+    return []
+  }
+}
+
+function startServer(opts) {
+  const lsp = require('vscode-languageserver/node')
+  const connection = opts?.connection || lsp.createConnection(lsp.ProposedFeatures.all)
+
+  // Late-bound loader options: initializationOptions arrive after the
+  // loader is constructed; the same object is mutated at initialize.
+  const loaderOpts = { trust: {} }
+
+  // A generated single-language server passes `entries` — the exact
+  // list it serves — replacing the bundled fleet registry entirely.
+  const baseEntries = () =>
+    opts?.entries ? opts.entries : loadBundled(opts?.registryFile)
+
+  let registry = new Registry(
+    baseEntries(),
+    opts?.workspaceEntries,
+    opts?.userEntries,
+  )
+  const docs = new DocumentStore()
+  const instances = new SerialInstances(makeLoader(opts?.require, loaderOpts))
+  const timers = new Map()
+  const lastGood = new Map() // uri -> { version, analysis }
+  let workspaceFolders = []
+  let initLangs = []
+
+  // Build (or rebuild) the registry's workspace tier from
+  // initializationOptions.languages plus each folder's .tabnas/lsp.json
+  // (dynamic add, design §6). Called at initialize and again whenever a
+  // manifest changes — invalidating instances alone would keep serving
+  // the OLD entry objects: edited grammar paths and options would be
+  // ignored, added languages never routed, removed ones never dropped.
+  function rebuildRegistry() {
+    for (const e of registry ? registry.all() : []) {
+      if ('workspace' === e._source) instances.invalidate(e)
+    }
+    const workspace = []
+    // Client-supplied entries are session-wide: _dir gives their
+    // relative grammar paths a sandbox base, but _scope is null so they
+    // route in EVERY folder. Scoping them to folder[0] (the old
+    // behaviour) made them dead in every other root of a multi-root
+    // session, and dead everywhere at all when the client sent no
+    // folders, since the base then fell back to the server's cwd.
+    const defaultDir = workspaceFolders[0] || process.cwd()
+    for (const e of initLangs) {
+      workspace.push(Object.assign(
+        { _source: 'workspace', _dir: defaultDir }, e, { _scope: null }))
+    }
+    for (const folder of workspaceFolders) {
+      workspace.push(...readWorkspaceManifest(folder, (msg) =>
+        connection.console.warn('tabnas-lsp: workspace manifest ignored: ' + msg)))
+    }
+    registry = new Registry(
+      baseEntries(),
+      (opts?.workspaceEntries || []).concat(workspace),
+      opts?.userEntries,
+    )
+    for (const e of registry.all()) {
+      if ('workspace' === e._source) instances.invalidate(e)
+    }
+  }
+
+  connection.onInitialize((params) => {
+    const init = params?.initializationOptions || {}
+    if (true === init.trustWorkspaceModules) {
+      loaderOpts.trust.workspaceModules = true
+    }
+
+    workspaceFolders = (params?.workspaceFolders || [])
+      .map((f) => folderPathOf(f.uri))
+      .filter(Boolean)
+    if (0 === workspaceFolders.length && params?.rootUri) {
+      const root = folderPathOf(params.rootUri)
+      if (root) workspaceFolders = [root]
+    }
+
+    initLangs = Array.isArray(init.languages) ? init.languages : []
+    rebuildRegistry()
+
+    return {
+      capabilities: {
+        textDocumentSync: {
+          openClose: true,
+          change: lsp.TextDocumentSyncKind.Incremental,
+        },
+        completionProvider: { triggerCharacters: [':', ',', '{', '[', '"'] },
+        documentSymbolProvider: true,
+        semanticTokensProvider: {
+          legend: { tokenTypes: core.LEGEND, tokenModifiers: [] },
+          full: true,
+        },
+        hoverProvider: true,
+      },
+    }
+  })
+
+  connection.onInitialized(() => {
+    // Watch workspace grammar sources so the L4 dev loop works: an
+    // edited spec/BNF file rebuilds its instance and re-analyzes open
+    // documents, and an edited manifest rebuilds the registry tier.
+    // Registration is best-effort — plain clients without dynamic
+    // registration simply do not get hot reload.
+    //
+    // Registering whenever there is a workspace folder, NOT only when
+    // some entry already names a grammar file: the manifest watcher
+    // lives in this same registration, so gating it on existing
+    // file-backed entries meant a workspace with no manifest (or one
+    // declaring only `load:{module}` entries) never watched the
+    // manifest — and so could never pick up a language ADDED to it.
+    // The first manifest is exactly when hot reload matters most.
+    if (0 === workspaceFolders.length) return
+    try {
+      connection.client.register(lsp.DidChangeWatchedFilesNotification.type, {
+        watchers: [
+          { globPattern: '**/' + WORKSPACE_MANIFEST },
+          { globPattern: '**/*.{abnf,ebnf,gbnf}' },
+          { globPattern: '**/*.json' },
+        ],
+      }).catch(() => {})
+    } catch (e) {
+      // client does not support dynamic registration
+    }
+  })
+
+  connection.onDidChangeWatchedFiles((p) => {
+    const changedPaths = (p?.changes || [])
+      .map((c) => folderPathOf(c.uri))
+      .filter(Boolean)
+    if (0 === changedPaths.length) return
+
+    // A changed manifest means the workspace TIER changed — added,
+    // removed, or re-configured languages — so the registry itself is
+    // rebuilt, and every open document re-resolves and re-analyzes.
+    const manifestChanged = workspaceFolders.some((folder) =>
+      changedPaths.includes(path.join(folder, WORKSPACE_MANIFEST)))
+    if (manifestChanged) {
+      rebuildRegistry()
+      for (const doc of docs.docs.values()) {
+        lastGood.delete(doc.uri)
+        schedule(doc.uri)
+      }
+      return
+    }
+
+    // Otherwise: a grammar source file changed — rebuild that entry's
+    // instance and re-analyze its documents.
+    for (const entry of registry.all()) {
+      if ('workspace' !== entry._source || null == entry._dir) continue
+      const file = entry.load?.grammar ||
+        ('string' === typeof entry.load?.spec ? entry.load.spec : null)
+      if (null == file) continue
+      const abs = path.resolve(entry._dir, file)
+      if (changedPaths.includes(abs)) {
+        instances.invalidate(entry)
+        for (const doc of docs.docs.values()) {
+          if (entryFor(doc) === entry) schedule(doc.uri)
+        }
+      }
+    }
+  })
+
+  function entryFor(doc) {
+    const { entry } = registry.resolve(doc.languageId, doc.uri)
+    return entry
+  }
+
+  function schedule(uri) {
+    clearTimeout(timers.get(uri))
+    timers.set(
+      uri,
+      setTimeout(() => {
+        timers.delete(uri)
+        run(uri)
+      }, DEBOUNCE_MS),
+    )
+  }
+
+  function run(uri) {
+    const doc = docs.get(uri)
+    if (!doc) return
+    const entry = entryFor(doc)
+    if (!entry) return
+    let inst
+    try {
+      inst = instances.get(entry)
+    } catch (e) {
+      const detail = e instanceof LoadError ? e.message : String(e && e.message)
+      connection.console.error('tabnas-lsp: grammar load failed: ' + detail)
+      return
+    }
+    if (!inst) return // quarantined
+    let analysis
+    try {
+      analysis = core.analyze(instances, inst, entry, doc)
+    } catch (e) {
+      instances.recordFailure(entry)
+      connection.console.error('tabnas-lsp: analysis failed (' + entry.languageId + '): ' + e.message)
+      return
+    }
+    // Version-stamped push: stale results never land on newer content.
+    connection.sendDiagnostics({
+      uri,
+      version: doc.version,
+      diagnostics: analysis.diagnostics,
+    })
+    if (!analysis.failed) {
+      lastGood.set(uri, { version: doc.version, analysis })
+    }
+  }
+
+  // Serve from the current version, else last-good ONLY at the same
+  // version (edit-transformation of cached spans is tracked work; the
+  // stale-range review rule says suppress rather than mis-highlight).
+  function currentAnalysis(uri) {
+    const doc = docs.get(uri)
+    const lg = lastGood.get(uri)
+    if (doc && lg && lg.version === doc.version) return lg.analysis
+    return null
+  }
+
+  connection.onDidOpenTextDocument((p) => {
+    const d = p.textDocument
+    docs.open(d.uri, d.languageId, d.version, d.text)
+    schedule(d.uri)
+  })
+
+  connection.onDidChangeTextDocument((p) => {
+    const doc = docs.get(p.textDocument.uri)
+    if (!doc) return
+    let text = doc.text
+    for (const change of p.contentChanges) {
+      if (null == change.range) {
+        text = change.text
+      } else {
+        const start = doc.offsetAt(change.range.start)
+        const end = doc.offsetAt(change.range.end)
+        text = text.substring(0, start) + change.text + text.substring(end)
+      }
+      // After EVERY change, not only ranged ones. A didChange array may
+      // legally mix a full replacement with later ranged edits, and the
+      // replacement branch used to leave doc (and its line index) on the
+      // PREVIOUS text — so the next ranged edit computed offsets against
+      // a document that no longer existed, silently corrupting the text
+      // here and panicking the Go port on the same input.
+      doc.update(text, doc.version) // keep line index fresh mid-loop
+    }
+    doc.update(text, p.textDocument.version)
+    lastGood.delete(p.textDocument.uri) // suppress stale structural results
+    schedule(p.textDocument.uri)
+  })
+
+  connection.onDidCloseTextDocument((p) => {
+    docs.close(p.textDocument.uri)
+    lastGood.delete(p.textDocument.uri)
+    connection.sendDiagnostics({ uri: p.textDocument.uri, diagnostics: [] })
+  })
+
+  connection.onCompletion((p) => {
+    const doc = docs.get(p.textDocument.uri)
+    if (!doc) return []
+    const entry = entryFor(doc)
+    if (!entry) return []
+    // instances.get RETHROWS a grammar load failure (after counting it
+    // toward quarantine). run() has always caught that and logged; here
+    // it escaped the handler and surfaced to the client as an
+    // InternalError on every keystroke of a broken grammar.
+    let inst
+    try {
+      inst = instances.get(entry)
+    } catch (e) {
+      connection.console.error(
+        'tabnas-lsp: grammar load failed (' + entry.languageId + '): ' + e.message)
+      return []
+    }
+    if (!inst) return [] // quarantined
+    return core.completion(inst, entry, doc, p.position)
+  })
+
+  connection.onDocumentSymbol((p) => {
+    const a = currentAnalysis(p.textDocument.uri)
+    return a ? a.outline : []
+  })
+
+  connection.languages.semanticTokens.on((p) => {
+    const a = currentAnalysis(p.textDocument.uri)
+    return { data: a && a.semanticTokens ? a.semanticTokens.data : [] }
+  })
+
+  connection.onHover((p) => {
+    const doc = docs.get(p.textDocument.uri)
+    const a = currentAnalysis(p.textDocument.uri)
+    if (!doc || !a) return null
+    return null // v1: hover ships with tokenDesc wiring (tracked)
+  })
+
+  connection.onRequest('tabnas/status', () => ({
+    languages: registry.all().map((e) => ({
+      languageId: e.languageId,
+      enabled: e.enabled,
+      source: e._source,
+      quarantined: instances.quarantined(e),
+      lexStream: e.lexStream,
+    })),
+  }))
+
+  connection.listen()
+  return { connection, registry: () => registry, docs, instances }
+}
+
+module.exports = { startServer, makeLoader, DEBOUNCE_MS, WORKSPACE_MANIFEST, readWorkspaceManifest }

package/tools/gen-fixtures.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+'use strict'
+
+// Generate diagnostics conformance fixtures from the fleet's existing
+// test/spec TSV corpus (plan B5): every ERROR:<code> row becomes a
+// fixture { languageId, input, expect: { codes: [code] } }. These are
+// the cross-runtime parity contract for the Go server (plan P2) —
+// generated, never hand-authored (derive-don't-duplicate).
+
+const fs = require('fs')
+const path = require('path')
+
+function unescapeTSV(s) {
+  return s.replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t')
+}
+
+function collect(root) {
+  const fixtures = []
+  let repos = []
+  try {
+    repos = fs.readdirSync(root)
+  } catch (e) {
+    return fixtures
+  }
+  for (const repo of repos) {
+    const specDir = path.join(root, repo, 'test', 'spec')
+    let files = []
+    try {
+      files = fs.readdirSync(specDir).filter((f) => f.endsWith('.tsv'))
+    } catch (e) {
+      continue
+    }
+    for (const f of files) {
+      const lines = fs.readFileSync(path.join(specDir, f), 'utf8').split('\n')
+      for (let i = 1; i < lines.length; i++) {
+        const cols = lines[i].split('\t')
+        if (cols.length < 2) continue
+        const m = /^ERROR:([a-z_0-9]+)/.exec(cols[1] || '')
+        if (m) {
+          fixtures.push({
+            languageId: repo,
+            file: f,
+            row: i + 1,
+            input: unescapeTSV(cols[0]),
+            expect: { codes: [m[1]] },
+          })
+        }
+      }
+    }
+  }
+  return fixtures
+}
+
+function main() {
+  // Fleet root default matches gen-registry.js: two levels above the
+  // ts/ package (ts/tools -> ts -> lsp -> fleet).
+  const root = process.argv[2] || path.join(__dirname, '..', '..', '..')
+  const fixtures = collect(root)
+
+  // Same refusal shape as gen-registry: a near-empty result means the
+  // fleet is not where we looked (a partial checkout sees only the
+  // engine's own spec dir), not that the corpus shrank. Overwriting
+  // the committed 262-fixture corpus with that would silently gut the
+  // cross-runtime parity contract. A real fleet checkout spans many
+  // grammar repos, so require at least three before writing.
+  const languages = new Set(fixtures.map((f) => f.languageId))
+  if (languages.size < 3) {
+    console.error(
+      'gen-fixtures: only ' + languages.size + ' repo(s) with ERROR rows ' +
+        'under ' + root + ' — this looks like a partial fleet checkout.\n' +
+        'Pass the fleet root explicitly: node tools/gen-fixtures.js <root>\n' +
+        'Refusing to overwrite data/diagnostic-fixtures.json.',
+    )
+    process.exitCode = 1
+    return
+  }
+
+  const out = {
+    generated: 'tools/gen-fixtures.js',
+    count: fixtures.length,
+    fixtures,
+  }
+  const file = path.join(__dirname, '..', 'data', 'diagnostic-fixtures.json')
+  fs.writeFileSync(file, JSON.stringify(out, null, 1) + '\n')
+  console.log('wrote ' + file + ' (' + fixtures.length + ' fixtures)')
+}
+
+if (require.main === module) main()
+module.exports = { collect }