codesynapt 0.0.0

package/packages/core/lib/search.cjs

@@ -0,0 +1,211 @@
+// search.cjs — full-text search over the scanner's file list.
+//
+// Concurrency / safety:
+//   - concurrency-limited (default 32) instead of all-at-once Promise.all
+//     → bounds libuv thread-pool queue depth, avoids stall on big repos.
+//   - per-file timeout (default 5s) → if a single file's read or scan hangs
+//     (OS lock, pathological regex), we skip it and continue.
+//   - skipped files are reported in the response so the caller knows what
+//     wasn't searched.
+
+const DEFAULT_MAX = 100
+const DEFAULT_CONCURRENCY = 32
+const DEFAULT_FILE_TIMEOUT_MS = 5000
+const SNIPPET_CONTEXT = 50
+
+function scanContent(text, q, opts, maxPerFile) {
+  const matches = []
+  if (opts.regex) {
+    const flags = opts.caseSensitive ? 'g' : 'gi'
+    let re
+    try { re = new RegExp(q, flags) }
+    catch { return [] }
+    let m
+    while ((m = re.exec(text)) !== null) {
+      const idx = m.index
+      const before = text.lastIndexOf('\n', idx - 1)
+      const line = (text.slice(0, idx).match(/\n/g) || []).length + 1
+      const col = idx - (before + 1) + 1
+      const sStart = Math.max(0, idx - SNIPPET_CONTEXT)
+      const sEnd   = Math.min(text.length, idx + m[0].length + SNIPPET_CONTEXT)
+      matches.push({
+        line, col,
+        snippet: text.slice(sStart, sEnd).replace(/\r?\n/g, ' '),
+      })
+      if (matches.length >= maxPerFile) break
+      if (m.index === re.lastIndex) re.lastIndex++
+    }
+    return matches
+  }
+
+  const needle = opts.caseSensitive ? q : q.toLowerCase()
+  const hay    = opts.caseSensitive ? text : text.toLowerCase()
+  let lineStart = 0
+  let lineNo = 1
+  while (lineStart < hay.length) {
+    let lineEnd = hay.indexOf('\n', lineStart)
+    if (lineEnd === -1) lineEnd = hay.length
+    let from = lineStart
+    while (true) {
+      const idx = hay.indexOf(needle, from)
+      if (idx === -1 || idx >= lineEnd) break
+      const sStart = Math.max(0, idx - SNIPPET_CONTEXT)
+      const sEnd   = Math.min(text.length, idx + needle.length + SNIPPET_CONTEXT)
+      matches.push({
+        line: lineNo,
+        col:  idx - lineStart + 1,
+        snippet: text.slice(sStart, sEnd).replace(/\r?\n/g, ' '),
+      })
+      if (matches.length >= maxPerFile) return matches
+      from = idx + needle.length
+    }
+    lineStart = lineEnd + 1
+    lineNo++
+  }
+  return matches
+}
+
+function withTimeout(promise, ms, label) {
+  let to
+  const timeout = new Promise((_, reject) => {
+    to = setTimeout(() => reject(new Error(`timeout ${ms}ms: ${label}`)), ms)
+  })
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(to))
+}
+
+// Run `tasks` with at most `concurrency` in flight at once.
+// Stops accepting new tasks once `shouldStop()` returns true.
+async function runConcurrent(tasks, concurrency, shouldStop) {
+  let i = 0
+  async function worker() {
+    while (i < tasks.length) {
+      if (shouldStop && shouldStop()) return
+      const idx = i++
+      await tasks[idx]()
+    }
+  }
+  const workers = Array.from({ length: Math.min(concurrency, tasks.length) }, worker)
+  await Promise.all(workers)
+}
+
+async function search(scanner, cache, opts) {
+  const t0 = Date.now()
+  const q = opts.q
+  if (!q || typeof q !== 'string') throw new Error('q (query string) is required')
+
+  const max = opts.max ?? DEFAULT_MAX
+  const concurrency = opts.concurrency ?? DEFAULT_CONCURRENCY
+  const fileTimeoutMs = opts.fileTimeoutMs ?? DEFAULT_FILE_TIMEOUT_MS
+  const regex = !!opts.regex
+  const caseSensitive = !!opts.caseSensitive
+  const maxPerFile = opts.maxPerFile ?? 10
+  const debug = !!opts.debug
+
+  if (regex) {
+    try { new RegExp(q) }
+    catch (e) { throw new Error(`invalid regex: ${e.message}`) }
+  }
+
+  const tFilesStart = Date.now()
+  const files = [...scanner.files.values()]
+  const totalFiles = files.length
+  const filesEnumMs = Date.now() - tFilesStart
+
+  const matches = []
+  const skipped = []
+  let filesScanned = 0
+  let filesMatched = 0
+  let stopFlag = false
+
+  // Timing buckets per file (debug only)
+  const timings = debug ? { readMs: [], scanMs: [] } : null
+
+  const tasks = files.map((f) => async () => {
+    if (stopFlag) return
+    let text
+    const tRead = debug ? Date.now() : 0
+    try {
+      text = await withTimeout(
+        cache.getText(f.id, f.absPath),
+        fileTimeoutMs,
+        f.id,
+      )
+    } catch (e) {
+      skipped.push({ id: f.id, reason: e.message.startsWith('timeout') ? 'timeout' : 'read-error' })
+      return
+    }
+    if (debug) timings.readMs.push(Date.now() - tRead)
+    if (stopFlag) return
+
+    filesScanned++
+    const tScan = debug ? Date.now() : 0
+    let fileMatches
+    try {
+      fileMatches = scanContent(text, q, { regex, caseSensitive }, maxPerFile)
+    } catch (e) {
+      skipped.push({ id: f.id, reason: 'scan-error' })
+      return
+    }
+    if (debug) timings.scanMs.push(Date.now() - tScan)
+    if (fileMatches.length === 0) return
+
+    filesMatched++
+    for (const m of fileMatches) {
+      matches.push({ id: f.id, line: m.line, col: m.col, snippet: m.snippet, totalInFile: fileMatches.length })
+      if (matches.length >= max) {
+        stopFlag = true
+        break
+      }
+    }
+  })
+
+  const tConcStart = Date.now()
+  await runConcurrent(tasks, concurrency, () => stopFlag)
+  const concMs = Date.now() - tConcStart
+
+  const result = {
+    query: q,
+    regex, caseSensitive,
+    totalFiles,
+    filesScanned,
+    filesMatched,
+    matches,
+    skipped,
+    truncated: stopFlag,
+    ms: Date.now() - t0,
+    cacheStats: cache.stats(),
+  }
+
+  if (debug) {
+    const sum = (a) => a.reduce((s, x) => s + x, 0)
+    const sorted = (a) => [...a].sort((x, y) => x - y)
+    const pctile = (a, p) => { const s = sorted(a); return s[Math.min(s.length-1, Math.floor(p * s.length))] || 0 }
+    result.debug = {
+      concurrency,
+      filesEnumMs,
+      runConcurrentMs: concMs,
+      reads: {
+        count: timings.readMs.length,
+        sumMs: sum(timings.readMs),
+        avgMs: timings.readMs.length ? +(sum(timings.readMs) / timings.readMs.length).toFixed(2) : 0,
+        p50:   pctile(timings.readMs, 0.5),
+        p95:   pctile(timings.readMs, 0.95),
+        p99:   pctile(timings.readMs, 0.99),
+        max:   Math.max(0, ...timings.readMs),
+      },
+      scans: {
+        count: timings.scanMs.length,
+        sumMs: sum(timings.scanMs),
+        avgMs: timings.scanMs.length ? +(sum(timings.scanMs) / timings.scanMs.length).toFixed(2) : 0,
+        p50:   pctile(timings.scanMs, 0.5),
+        p95:   pctile(timings.scanMs, 0.95),
+        p99:   pctile(timings.scanMs, 0.99),
+        max:   Math.max(0, ...timings.scanMs),
+      },
+    }
+  }
+
+  return result
+}
+
+module.exports = { search }

package/packages/core/lib/symbol-graph.cjs

@@ -0,0 +1,402 @@
+// CodeSynapt symbol mode — in-memory symbol graph that lives alongside
+// the file-graph Scanner. Built lazily; first /symbol/* request triggers
+// the scan against the currently-loaded file set.
+//
+// Data model and design notes live in docs/SYMBOL-MODE-PLAN.md.
+
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+// Parser registry — extended per-language in Stage 1 / Stage 2.
+// Each entry: { extractSymbols(content, fileId) → SymbolNode[],
+//               extractReferences(content, fileId, index) → SymbolEdge[] }
+const PARSERS = Object.create(null)
+
+// Heuristic: a file at one of these path segments isn't usually called
+// from production code. Affects resolveCall — when a name has matches
+// in both production and auxiliary paths, production wins. Doesn't
+// hide aux symbols, just deprioritises them as call targets.
+const AUX_PATH_SEGMENTS = new Set([
+  'scripts', 'script', 'tools', 'tool',
+  'tests', 'test', '__tests__', 'spec', 'specs',
+  'examples', 'example', 'samples', 'sample', 'demo', 'demos',
+  'build', 'dist', 'out', 'bin',
+  'docs', 'doc',
+  'fixtures', 'fixture',
+  'benchmarks', 'benchmark', 'bench',
+  // Vendored / prebuilt bundles that ship inside source dirs
+  // (Next.js's packages/next/src/compiled/* is the canonical case).
+  // file-mode ignores top-level node_modules, but vendored copies
+  // inside src/ slip through; deprioritise them as call targets.
+  'compiled', 'vendored', 'vendor',
+])
+function isAuxPath(fileId) {
+  if (!fileId) return false
+  // Check the first path segment + any segment whose name matches.
+  // `tests/foo.ts`, `packages/x/scripts/y.ts`, `build/x.js` all match.
+  const parts = fileId.split('/')
+  return parts.some((p) => AUX_PATH_SEGMENTS.has(p))
+}
+
+function registerParser(extOrExts, parser) {
+  const exts = Array.isArray(extOrExts) ? extOrExts : [extOrExts]
+  for (const e of exts) PARSERS[e] = parser
+}
+
+function extFor(filePath) {
+  const e = path.extname(filePath).slice(1).toLowerCase()
+  return e
+}
+
+class SymbolGraph {
+  constructor() {
+    this.nodes = new Map()      // id → SymbolNode
+    this.edges = []             // SymbolEdge[]
+    this.byFile = new Map()     // fileId → Set<symbolId>
+    this.byName = new Map()     // lowercased name → Set<symbolId>
+    // Adjacency for fast callers/callees lookup.
+    this.outAdj = new Map()     // symbolId → Set<targetId>
+    this.inAdj  = new Map()     // symbolId → Set<sourceId>
+    // File-mode imports — fed in from the host (scanner.edges). Lets
+    // call resolution disambiguate same-name symbols across files
+    // by preferring targets in files the caller actually imports.
+    this.fileImports = new Map() // fileId → Set<importedFileId>
+    this.builtAt  = 0
+    this.fileCount = 0
+    this.scanMs = 0
+  }
+
+  clear() {
+    this.nodes.clear()
+    this.edges.length = 0
+    this.byFile.clear()
+    this.byName.clear()
+    this.outAdj.clear()
+    this.inAdj.clear()
+    this.fileImports.clear()
+    this.builtAt = 0
+    this.fileCount = 0
+    this.scanMs = 0
+  }
+
+  // Best symbol match for `name` called from `fromFileId`. Preference:
+  //   1) same file
+  //   2) a file directly imported by `fromFileId`
+  // We deliberately *do not* fall back to "any file with that name"
+  // — that would link a local `request` variable in utils.ts to an
+  // unrelated `request()` function in some other file just because
+  // they share a name. AI agents downstream would get noise edges
+  // and follow false trails. Conservative beats clever here.
+  // If the host wants the loose match, set `allowAny: true`.
+  resolveCall(fromFileId, name, { allowAny = false } = {}) {
+    if (!name) return null
+    // Type-aware lookup: `User.method` matches a symbol whose
+    // qualifiedName === 'User.method' exactly. Higher priority than
+    // name-only matches because it narrows from "any method named X"
+    // to "X defined on this class".
+    if (name.includes('.')) {
+      const tail = name.split('.').pop()
+      const set = this.byName.get(tail.toLowerCase())
+      if (set) {
+        for (const id of set) {
+          const node = this.nodes.get(id)
+          if (node?.qualifiedName === name) return node
+        }
+      }
+      // No qualifiedName match — fall back to the bare method name
+      // through the regular path below.
+      name = tail
+    }
+    const set = this.byName.get(name.toLowerCase())
+    if (!set || !set.size) return null
+    let sameFile = null, imported = null
+    // Two-bucket fallback: prefer a production-path candidate
+    // over an auxiliary-path one (scripts/, test/, build/, examples/
+    // etc.) when nothing imported matches. Stops the case where
+    // production code's call to `fetch(...)` lands on a helper named
+    // `fetch` defined in scripts/.
+    let prodAny = null, auxAny = null
+    const callerIsAux = isAuxPath(fromFileId)
+    const importsOf = this.fileImports.get(fromFileId)
+    for (const id of set) {
+      const node = this.nodes.get(id)
+      if (!node) continue
+      if (node.file === fromFileId) { sameFile = node; break }
+      if (!imported && importsOf && importsOf.has(node.file)) imported = node
+      if (isAuxPath(node.file)) {
+        if (!auxAny) auxAny = node
+      } else {
+        if (!prodAny) prodAny = node
+      }
+    }
+    if (sameFile) return sameFile
+    if (imported) return imported
+    if (!allowAny) return null
+    // Prefer production over auxiliary unless the caller itself is
+    // already aux (in which case linking back into scripts/ is fine).
+    if (callerIsAux) return prodAny || auxAny
+    return prodAny || auxAny
+  }
+
+  addNode(node) {
+    this.nodes.set(node.id, node)
+    if (!this.byFile.has(node.file)) this.byFile.set(node.file, new Set())
+    this.byFile.get(node.file).add(node.id)
+    const key = (node.name || '').toLowerCase()
+    if (key) {
+      if (!this.byName.has(key)) this.byName.set(key, new Set())
+      this.byName.get(key).add(node.id)
+    }
+  }
+
+  addEdge(edge) {
+    this.edges.push(edge)
+    if (!this.outAdj.has(edge.source)) this.outAdj.set(edge.source, new Set())
+    this.outAdj.get(edge.source).add(edge.target)
+    if (!this.inAdj.has(edge.target)) this.inAdj.set(edge.target, new Set())
+    this.inAdj.get(edge.target).add(edge.source)
+  }
+
+  // Index every symbol as a 384-d MiniLM embedding so /symbol/explore
+  // can rerank by semantic similarity (auth ↔ login synonyms etc).
+  // Runs in batches of 32 to keep peak memory bounded; the caller
+  // typically fires this off without awaiting so the build finishes
+  // quickly and the embeddings populate in the background.
+  //
+  // Each symbol gets a `_embedding` Float64-style Array assigned in
+  // place. Falls back silently if `embedBatchFn` returns null (e.g.
+  // the @xenova/transformers dep isn't installed).
+  async embedAllSymbols(embedBatchFn, { chunkSize = 32 } = {}) {
+    if (this._embedded || this._embedding) return  // idempotent
+    this._embedding = true
+    const ids = []
+    const texts = []
+    for (const n of this.nodes.values()) {
+      ids.push(n.id)
+      // Keep text short — MiniLM is a 128-token model, longer input
+      // gets truncated. name + qn + kind + first 100 chars of doc is
+      // enough signal to distinguish auth-shaped from db-shaped.
+      const doc = (n.doc || '').slice(0, 100)
+      texts.push(`${n.name || ''} ${n.qualifiedName || ''} ${n.kind || ''} ${doc}`.trim())
+    }
+    const start = Date.now()
+    let done = 0
+    for (let i = 0; i < texts.length; i += chunkSize) {
+      const batch = texts.slice(i, i + chunkSize)
+      const vecs = await embedBatchFn(batch)
+      if (!vecs) {              // embed failed — give up cleanly
+        this._embedding = false
+        return false
+      }
+      for (let j = 0; j < vecs.length; j++) {
+        const node = this.nodes.get(ids[i + j])
+        if (node) node._embedding = vecs[j]
+      }
+      done += vecs.length
+      // Yield to the event loop between batches so concurrent HTTP
+      // requests (the desktop UI, the bench harness, MCP tools)
+      // aren't starved while a multi-second indexing pass runs.
+      // ONNX inference inside embedBatchFn pegs the main thread, so
+      // a `setImmediate` after each batch is the difference between
+      // "queries time out" and "queries respond within 50 ms".
+      await new Promise((r) => setImmediate(r))
+    }
+    this._embedded = true
+    this._embedding = false
+    this.embedMs = Date.now() - start
+    return true
+  }
+
+  // BFS along outAdj from every symbol the host considers a public
+  // entry (main, route handler, exported CLI bin, etc). Symbols not
+  // reachable from any entry are likely dead code. The host passes
+  // its own isEntry predicate so this module stays parser-agnostic.
+  //
+  // Important caveat documented in the explore code: our entry
+  // heuristic (name + path patterns) misses some real entries
+  // (React components, framework callbacks, decorator-bound
+  // handlers), so a `reachable: false` flag is a *hint*, not a
+  // verdict — we expose it as data and let the ranker / UI choose
+  // how strongly to weight it.
+  computeReachability(isEntry) {
+    const reachable = new Set()
+    const queue = []
+    for (const node of this.nodes.values()) {
+      try {
+        if (isEntry(node)) { reachable.add(node.id); queue.push(node.id) }
+      } catch {}
+    }
+    while (queue.length) {
+      const id = queue.shift()
+      const callees = this.outAdj.get(id)
+      if (!callees) continue
+      for (const c of callees) {
+        if (!reachable.has(c)) { reachable.add(c); queue.push(c) }
+      }
+    }
+    this._reachable = reachable
+    return reachable
+  }
+
+  callersOf(id) {
+    const set = this.inAdj.get(id)
+    if (!set) return []
+    return [...set].map((sid) => this.nodes.get(sid)).filter(Boolean)
+  }
+  calleesOf(id) {
+    const set = this.outAdj.get(id)
+    if (!set) return []
+    return [...set].map((tid) => this.nodes.get(tid)).filter(Boolean)
+  }
+  findByName(query, limit = 50) {
+    const q = (query || '').toLowerCase()
+    if (!q) return []
+    const matches = []
+    for (const [name, ids] of this.byName) {
+      if (name.includes(q)) {
+        for (const id of ids) {
+          const n = this.nodes.get(id)
+          if (n) matches.push(n)
+          if (matches.length >= limit) return matches
+        }
+      }
+    }
+    return matches
+  }
+
+  // ─── Scanning ──────────────────────────────────────────────────
+  // `fileEntries` is an iterable of { id, absPath, ext } — typically
+  // derived from the file-mode Scanner's `files` map.
+  // `fileImports` (optional) is a Map<fileId, Set<importedFileId>>
+  // built from the file-mode edge list; lets resolveCall prefer
+  // imported targets.
+  async build(fileEntries, fileImports = null, options = {}) {
+    const start = Date.now()
+    this.clear()
+    // Set imports *after* clear so the host-provided map survives.
+    if (fileImports) this.fileImports = fileImports
+    // Big-repo safety knobs. None of them block — they cap the work
+    // so a runaway monorepo (100k+ symbols) doesn't OOM the process.
+    const MAX_SYMBOLS = options.maxSymbols
+      || parseInt(process.env.CS_MAX_SYMBOLS || '200000', 10)
+    const MAX_EDGES = options.maxEdges
+      || parseInt(process.env.CS_MAX_EDGES || '1000000', 10)
+    const MAX_FILE_BYTES = options.maxFileBytes
+      || parseInt(process.env.CS_MAX_FILE_BYTES || '524288', 10)  // 512KB
+    let abortedAt = null
+    // Pass 1 — symbols. We need every symbol indexed before we can
+    // resolve references in pass 2.
+    let fileCount = 0
+    const fileContents = new Map()    // fileId → content (kept for pass 2)
+    for (const entry of fileEntries) {
+      if (this.nodes.size >= MAX_SYMBOLS) { abortedAt = 'symbols'; break }
+      const parser = PARSERS[entry.ext]
+      if (!parser) continue
+      let content, fileMtimeMs = 0
+      try {
+        const stat = fs.statSync(entry.absPath)
+        if (stat.size > MAX_FILE_BYTES) continue   // skip giant files (minified bundles, vendored libs)
+        content = fs.readFileSync(entry.absPath, 'utf8')
+        fileMtimeMs = stat.mtimeMs
+      } catch { continue }
+      fileContents.set(entry.id, content)
+      let symbols
+      try {
+        const ret = parser.extractSymbols(content, entry.id)
+        symbols = (await ret) || []
+      } catch (e) { symbols = [] }
+      // Lazy split per file — used by the deprecated probe below.
+      // Most files have no deprecated marker, so the .test() short-
+      // circuits and we never pay the split cost.
+      let _lines = null
+      const lines = () => _lines ??= content.split('\n')
+      const DEPRECATED_RE = /@?deprecated\b|todo\s*[:_-]?\s*remove|fixme\s*[:_-]?\s*remove/i
+      // Stricter pattern — used ONLY against the file header so
+      // common code-body words like "wip"/"work in progress" don't
+      // false-positive entire files. The body-level probe sticks to
+      // the precise @deprecated / TODO remove patterns above.
+      const HEAD_DEPRECATED_RE = /@?deprecated\b|do\s+not\s+use\b|work\s+in\s+progress\b|\bwip[\s:]/i
+      const fileHasDeprecated = DEPRECATED_RE.test(content)
+      // File-level deprecated marker — if the first 5 lines flag the
+      // whole file as deprecated (common pattern: file header with
+      // `// @deprecated — moved to …`), tag every symbol the file
+      // exports. Avoids the case where the file header is far above
+      // any declaration's 5-line probe window. Header check uses
+      // HEAD_DEPRECATED_RE so a body-only deprecated marker can't
+      // promote a single-symbol file to "everything deprecated".
+      let fileLevelDeprecated = false
+      const head = lines().slice(0, 5).join('\n')
+      if (HEAD_DEPRECATED_RE.test(head)) fileLevelDeprecated = true
+      for (const s of symbols) {
+        if (this.nodes.size >= MAX_SYMBOLS) { abortedAt = 'symbols'; break }
+        // Stamp every symbol with the file's mtime — explore uses it
+        // for the `legacy` classification (old + low in-degree). Cost
+        // is one extra Map allocation per symbol; the stat call was
+        // already happening above.
+        s.mtimeMs = fileMtimeMs
+        // Deprecated marker — look at the 5 lines directly above the
+        // symbol declaration. Cheaper + more precise than fighting
+        // babel's export-wrapper leading-comment attachment quirk.
+        if (fileLevelDeprecated) {
+          s.deprecated = true
+        } else if (fileHasDeprecated && s.startLine) {
+          const start = Math.max(0, s.startLine - 1 - 5)
+          const prelude = lines().slice(start, s.startLine - 1).join('\n')
+          if (DEPRECATED_RE.test(prelude)) s.deprecated = true
+        }
+        this.addNode(s)
+      }
+      fileCount++
+    }
+    // Pass 2 — references. Per-file, ask the language parser to find
+    // call/extends/implements edges. Parsers consult `this` (the
+    // symbol index) to resolve names.
+    for (const [fileId, content] of fileContents) {
+      if (this.edges.length >= MAX_EDGES) { abortedAt = abortedAt || 'edges'; break }
+      const ext = extFor(fileId)
+      const parser = PARSERS[ext]
+      if (!parser || !parser.extractReferences) continue
+      let refs
+      try {
+        const ret = parser.extractReferences(content, fileId, this)
+        refs = (await ret) || []
+      } catch (e) { refs = [] }
+      for (const r of refs) {
+        if (this.edges.length >= MAX_EDGES) { abortedAt = abortedAt || 'edges'; break }
+        if (this.nodes.has(r.source) && this.nodes.has(r.target)) {
+          this.addEdge(r)
+        }
+      }
+    }
+    this.fileCount = fileCount
+    this.builtAt = Date.now()
+    this.scanMs = this.builtAt - start
+    this.abortedAt = abortedAt          // null or 'symbols'/'edges'
+    return this.stats()
+  }
+
+  stats() {
+    const byKind = {}
+    for (const n of this.nodes.values()) {
+      byKind[n.kind] = (byKind[n.kind] || 0) + 1
+    }
+    const byEdgeKind = {}
+    for (const e of this.edges) {
+      byEdgeKind[e.kind] = (byEdgeKind[e.kind] || 0) + 1
+    }
+    return {
+      fileCount: this.fileCount,
+      symbolCount: this.nodes.size,
+      edgeCount: this.edges.length,
+      byKind,
+      byEdgeKind,
+      scanMs: this.scanMs,
+      builtAt: this.builtAt,
+      abortedAt: this.abortedAt || null,   // null | 'symbols' | 'edges'
+    }
+  }
+}
+
+module.exports = { SymbolGraph, registerParser, extFor, PARSERS }