open-context-engine 0.1.0

package/src/retrieval/languages/python.py

@@ -0,0 +1,113 @@
+"""Python AST adapter; preserves v1 spans and edges for the frozen baseline.
+
+Name-resolved calls/inheritance remain heuristic (shadowing/dynamic dispatch are
+not fully resolved); confidence is a provenance category, not a probability.
+"""
+import ast
+from collections import defaultdict
+
+def extract(sources, max_lines=65, options=None):
+    if options:
+        raise ValueError("Python adapter does not accept language options")
+    units, trees, aliases, class_bases = [], {}, {}, {}
+    for source in sources:
+        path, text = source.path, source.text
+        lines = text.splitlines()
+        module = path.removesuffix('.py').replace('/', '.')
+        if module.endswith('.__init__'):
+            module = module[:-9]
+        tree = ast.parse(text, filename=path)
+        trees[module] = tree
+        imports = {}
+        for n in tree.body:
+            if isinstance(n, ast.Import):
+                for item in n.names:
+                    imports[item.asname or item.name.split('.')[0]] = item.name if item.asname else item.name.split('.')[0]
+            elif isinstance(n, ast.ImportFrom):
+                prefix = n.module or ''
+                if n.level:
+                    package = module if path.endswith('/__init__.py') else module.rsplit('.', 1)[0]
+                    parts = package.split('.')
+                    prefix = '.'.join(parts[:len(parts) - n.level + 1] + ([prefix] if prefix else []))
+                for item in n.names:
+                    imports[item.asname or item.name] = prefix + '.' + item.name
+        aliases[module] = imports
+
+        def add(start, end, name, kind, node=None, owner=None):
+            if start > end:
+                return
+            # Prefer statement boundaries; oversized statements are split by line.
+            boundaries = sorted({n.lineno for n in ast.walk(node) if isinstance(n, ast.stmt)
+                                 and start < n.lineno <= end}) if node else []
+            while start <= end:
+                stop = min(end, start + max_lines - 1)
+                choices = [b - 1 for b in boundaries if start + max_lines // 2 <= b <= stop + 1]
+                if stop < end and choices:
+                    stop = max(choices)
+                snippet = '\n'.join(lines[start - 1:stop])
+                if snippet.strip():
+                    units.append({'id': len(units), 'path': path, 'module': module, 'name': name,
+                        'symbol': module + ('.' + name if name else ''), 'kind': kind, 'owner': owner,
+                        'start': start, 'end': stop, 'text': snippet,
+                        'calls': [ast.unparse(n.func) for n in ast.walk(node)
+                                  if isinstance(n, ast.Call) and start <= n.lineno <= stop] if node else [],
+                        'edges': []})
+                start = stop + 1
+
+        def definitions(body, prefix='', low=1, high=None, owner=None):
+            cursor = low
+            for n in body:
+                if not isinstance(n, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
+                    continue
+                start = min([n.lineno] + [d.lineno for d in n.decorator_list])
+                add(cursor, start - 1, prefix, 'class-body' if prefix else 'module', owner=owner)
+                name = '.'.join(x for x in [prefix, n.name] if x)
+                if isinstance(n, ast.ClassDef):
+                    class_bases[module + '.' + name] = [ast.unparse(b) for b in n.bases]
+                    # Keep class header, attributes and docstring as their own spans.
+                    definitions(n.body, name, start, n.end_lineno, module + '.' + name)
+                else:
+                    add(start, n.end_lineno, name, 'function', n, owner)
+                cursor = n.end_lineno + 1
+            add(cursor, high if high is not None else len(lines), prefix,
+                'class-body' if prefix else 'module', owner=owner)
+
+        definitions(tree.body)
+
+    symbols = defaultdict(list)
+    for u in units:
+        symbols[u['symbol']].append(u['id'])
+    for u in units:
+        targets, relations = [], []
+
+        def relate(ids, kind, confidence, resolution):
+            targets.extend(ids)
+            relations.extend({'target': target, 'kind': kind, 'confidence': confidence,
+                              'resolution': resolution} for target in ids if target != u['id'])
+        if u['owner']:
+            relate(symbols.get(u['owner'], []), 'member_of', 1.0, 'syntax')
+        for call in u['calls']:
+            pieces = call.split('.')
+            first = pieces[0]
+            target = None
+            if first in ('self', 'cls') and u['owner']:
+                target = u['owner'] + '.' + '.'.join(pieces[1:])
+            elif first in aliases[u['module']]:
+                target = aliases[u['module']][first] + ('.' + '.'.join(pieces[1:]) if len(pieces) > 1 else '')
+            elif len(pieces) == 1:
+                target = u['module'] + '.' + call
+            if target:
+                relate(symbols.get(target, []), 'calls', .7, 'static-name')
+        for base in class_bases.get(u['owner'] or u['symbol'], []):
+            pieces = base.split('.')
+            target = aliases[u['module']].get(pieces[0], u['module'] + '.' + pieces[0])
+            if len(pieces) > 1:
+                target += '.' + '.'.join(pieces[1:])
+            relate(symbols.get(target, []), 'inherits', .7, 'static-name')
+        # A split function's parts form one symbol, preserving continuation links.
+        relate(symbols[u['symbol']], 'same_symbol', 1.0, 'syntax')
+        u['edges'] = sorted(set(targets) - {u['id']})
+        u.update(language='python', scope=u['owner'] or u['module'],
+                 relations=sorted({(r['target'], r['kind'], r['confidence'], r['resolution']): r
+                                   for r in relations}.values(), key=lambda r: (r['target'], r['kind'])))
+    return units

package/src/retrieval/languages/schema.py

@@ -0,0 +1,81 @@
+"""Language-neutral source units. Relations describe static evidence, not runtime proof."""
+from dataclasses import dataclass
+import math
+from typing import TypedDict
+
+SCHEMA_VERSION = 'source-units-v2'
+RELATION_KINDS = frozenset({'calls', 'member_of', 'inherits', 'implements',
+                            'same_symbol', 'imports', 'references_type'})
+
+
+@dataclass(frozen=True)
+class SourceFile:
+    path: str
+    text: str
+    sha256: str
+
+
+def physical_lines(text):
+    """Match editor line numbers: CRLF/CR/LF, not Unicode paragraph separators."""
+    lines = text.replace('\r\n', '\n').replace('\r', '\n').split('\n')
+    return lines[:-1] if lines and not lines[-1] else lines
+
+
+class Relation(TypedDict):
+    target: int
+    kind: str
+    confidence: float
+    resolution: str
+
+
+class CodeUnit(TypedDict):
+    id: int
+    language: str
+    path: str
+    module: str
+    name: str
+    symbol: str
+    kind: str
+    scope: str
+    owner: str | None
+    start: int
+    end: int
+    text: str
+    relations: list[Relation]
+    # Compatibility projection used by the unchanged retrieval algorithms.
+    edges: list[int]
+
+
+def validate_units(units, sources):
+    """Require lossless source coordinates, non-overlapping spans and valid graph IDs."""
+    text_paths = {unit['path'] for unit in units if unit['language'] in {'text', 'javascript', 'typescript', 'go'}}
+    lines = {source.path: (physical_lines(source.text) if source.path in text_paths
+                          else source.text.splitlines()) for source in sources}
+    covered = {path: set() for path in lines}
+    for expected, unit in enumerate(units):
+        if unit['id'] != expected or unit['path'] not in lines:
+            raise ValueError('Invalid unit ID or source path')
+        source = lines[unit['path']]
+        start, end = unit['start'], unit['end']
+        if not 1 <= start <= end <= len(source):
+            raise ValueError('Invalid source span')
+        if unit['text'] != '\n'.join(source[start-1:end]):
+            raise ValueError('Source text does not match its span')
+        span = set(range(start, end+1))
+        if covered[unit['path']] & span:
+            raise ValueError('Overlapping source spans')
+        covered[unit['path']].update(span)
+        if not all(isinstance(unit[key], str) and unit[key] for key in ['language', 'module', 'symbol', 'kind', 'scope']):
+            raise ValueError('Missing unit identity')
+        for relation in unit['relations']:
+            target, confidence = relation['target'], relation['confidence']
+            if (type(target) is not int or not 0 <= target < len(units) or target == expected
+                    or relation['kind'] not in RELATION_KINDS or not math.isfinite(confidence)
+                    or not 0 <= confidence <= 1 or not relation['resolution']):
+                raise ValueError('Invalid static relation')
+        if unit['edges'] != sorted({relation['target'] for relation in unit['relations']}):
+            raise ValueError('Edges must be the exact projection of typed relations')
+    for path, source in lines.items():
+        missing = [i for i, line in enumerate(source, 1) if line.strip() and i not in covered[path]]
+        if missing:
+            raise ValueError(f'Uncovered source lines: {path}: {missing[:5]}')

package/src/retrieval/languages/text.py

@@ -0,0 +1,39 @@
+"""Lossless line chunks for text without a structural adapter; no inferred edges."""
+from pathlib import PurePosixPath
+from .schema import physical_lines
+
+VERSION = 'line-chunks-v1'
+MAX_CHARS = 1800
+
+
+def extract(sources, max_lines=65, options=None):
+    if options:
+        raise ValueError('Text adapter does not accept language options')
+    units = []
+    for source in sources:
+        lines = physical_lines(source.text)
+        start = 0
+        while start < len(lines):
+            end, size = start, 0
+            while end < len(lines) and end-start < max_lines:
+                cost = len(lines[end])+1
+                # Keep an oversized line intact so its source coordinates remain true.
+                if end > start and size+cost > MAX_CHARS:
+                    break
+                size += cost
+                end += 1
+            if end < len(lines):
+                boundaries = [i+1 for i in range(start+(end-start)//2, end)
+                              if not lines[i].strip()]
+                if boundaries:
+                    end = boundaries[-1]
+            snippet = '\n'.join(lines[start:end])
+            if snippet.strip():
+                units.append({'id': len(units), 'language': 'text', 'path': source.path,
+                              'module': source.path, 'name': PurePosixPath(source.path).name,
+                              'symbol': f'text:{source.path}:L{start+1}', 'kind': 'text',
+                              'scope': source.path, 'owner': None,
+                              'start': start+1, 'end': end, 'text': snippet,
+                              'relations': [], 'edges': []})
+            start = end
+    return units

package/src/retrieval/languages/typescript.mjs

@@ -0,0 +1,233 @@
+/** Parse and bind only the frozen source set. Never emit, execute, or load repo plugins. */
+import ts from 'typescript';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+const COMPILER_VERSION = '5.9.3';
+if (ts.version !== COMPILER_VERSION) throw new Error(`Expected TypeScript ${COMPILER_VERSION}; run npm ci`);
+const ROOT = '/reponerve-snapshot';
+const absolute = name => path.posix.resolve(ROOT, name);
+const slashLines = text => text.replace(/\r\n?/g, '\n').split('\n');
+
+export function extract(files, maxLines = 65, settings = {}) {
+  if (!settings || typeof settings !== 'object' || Array.isArray(settings)
+      || Object.keys(settings).some(key => !['baseUrl', 'paths'].includes(key))) {
+    throw new Error('TypeScript options support only explicit baseUrl and paths');
+  }
+  if (settings.baseUrl !== undefined && typeof settings.baseUrl !== 'string') throw new Error('baseUrl must be text');
+  if (settings.paths !== undefined && (!settings.paths || typeof settings.paths !== 'object' || Array.isArray(settings.paths)
+      || Object.values(settings.paths).some(v => !Array.isArray(v) || !v.length || v.some(s => typeof s !== 'string')))) {
+    throw new Error('paths must map aliases to nonempty arrays of paths');
+  }
+  const baseUrl = absolute(settings.baseUrl ?? '.');
+  if (baseUrl !== ROOT && !baseUrl.startsWith(ROOT + '/')) throw new Error('baseUrl escapes snapshot');
+  const texts = new Map(files.map(file => [absolute(file.path), file.text]));
+  const directories = new Set([ROOT]);
+  for (const name of texts.keys()) {
+    for (let directory = path.posix.dirname(name); directory.startsWith(ROOT); directory = path.posix.dirname(directory)) {
+      directories.add(directory);
+    }
+  }
+  const options = { target: ts.ScriptTarget.ESNext, module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler, jsx: ts.JsxEmit.Preserve,
+    noEmit: true, noLib: true, skipLibCheck: true, allowImportingTsExtensions: true,
+    ...(files.some(f => /\.(?:jsx?|mjs|cjs)$/.test(f.path)) ? { allowJs: true, checkJs: true } : {}),
+    experimentalDecorators: true, baseUrl, paths: settings.paths };
+  const host = {
+    getSourceFile: (name, version) => texts.has(name) ? ts.createSourceFile(name, texts.get(name), version, true) : undefined,
+    getDefaultLibFileName: () => '', writeFile: () => { throw new Error('Emit is disabled'); },
+    getCurrentDirectory: () => ROOT, getDirectories: () => [],
+    fileExists: name => texts.has(name), readFile: name => texts.get(name),
+    directoryExists: name => directories.has(name), realpath: name => name,
+    getCanonicalFileName: name => name, useCaseSensitiveFileNames: () => true, getNewLine: () => '\n',
+  };
+  const program = ts.createProgram([...texts.keys()], options, host);
+  const errors = program.getSyntacticDiagnostics();
+  if (errors.length) {
+    throw new Error(errors.slice(0, 5).map(d => {
+      const line = d.file.getLineAndCharacterOfPosition(d.start ?? 0).line + 1;
+      return `${path.posix.relative(ROOT, d.file.fileName)}:${line}: ${ts.flattenDiagnosticMessageText(d.messageText, ' ')}`;
+    }).join('\n'));
+  }
+  const checker = program.getTypeChecker();
+  const units = [], records = new Map(), nodeEntries = new Map();
+  const executable = node => Boolean(node && ((ts.isFunctionLike(node) && node.body) || ts.isClassLike(node)));
+  const named = node => node.name?.getText() ?? (ts.isConstructorDeclaration(node) ? 'constructor' : 'default');
+  const describe = node => {
+    if (ts.isClassDeclaration(node)) return ['class-body', named(node)];
+    if (ts.isInterfaceDeclaration(node)) return ['interface', named(node)];
+    if (ts.isTypeAliasDeclaration(node)) return ['type', named(node)];
+    if (ts.isEnumDeclaration(node)) return ['enum', named(node)];
+    if (ts.isModuleDeclaration(node)) return ['namespace', named(node)];
+    if (ts.isFunctionDeclaration(node)) return ['function', named(node)];
+    if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || ts.isConstructorDeclaration(node)
+        || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node)) return ['method', named(node)];
+    if (ts.isPropertyDeclaration(node) || ts.isPropertySignature(node)) return ['property', named(node)];
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer
+        && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer)
+            || ts.isClassExpression(node.initializer))) {
+      return [ts.isClassExpression(node.initializer) ? 'class-body' : 'function', named(node)];
+    }
+    return null;
+  };
+
+  for (const file of files) {
+    const sf = program.getSourceFile(absolute(file.path));
+    const lines = slashLines(file.text);
+    // Python splitlines() omits the final empty line; use the same span convention.
+    if (lines.at(-1) === '') lines.pop();
+    const module = file.path.replace(/\.(?:tsx?|mts|cts|jsx?|mjs|cjs)$/, '');
+    // Source citations use physical CR/LF lines, including when JavaScript
+    // treats a Unicode separator as a lexical line terminator. Offsets are UTF-16.
+    const starts = [0, ...[...file.text.matchAll(/\r\n|\r|\n/g)].map(m => m.index + m[0].length)];
+    const lineOf = position => {
+      let low = 0, high = starts.length;
+      while (low + 1 < high) {
+        const middle = (low + high) >>> 1;
+        if (starts[middle] <= position) low = middle; else high = middle;
+      }
+      return low + 1;
+    };
+    const root = { node: sf, name: '', symbol: module + '::', kind: 'module', start: 1,
+      end: lines.length, parent: null, depth: 0, ids: [] };
+    const entries = [root], boundaries = new Set();
+    nodeEntries.set(sf, root);
+    function visit(node, parent) {
+      let current = parent;
+      const description = describe(node);
+      if (description) {
+        const [kind, shortName] = description;
+        const name = parent.name ? `${parent.name}.${shortName}` : shortName;
+        current = { node, name, symbol: module + '::' + name, kind, parent, depth: parent.depth + 1,
+          start: lineOf(node.getStart(sf, true)), end: lineOf(Math.max(node.getStart(sf), node.end - 1)), ids: [] };
+        entries.push(current); nodeEntries.set(node, current);
+        if (ts.isVariableDeclaration(node) && node.initializer) nodeEntries.set(node.initializer, current);
+      }
+      if (ts.isStatement(node)) boundaries.add(lineOf(node.getStart(sf)));
+      ts.forEachChild(node, child => visit(child, current));
+    }
+    ts.forEachChild(sf, child => visit(child, root));
+    const owners = Array(lines.length).fill(root);
+    for (const entry of entries.slice(1).sort((a, b) => a.depth - b.depth || a.start - b.start)) {
+      // A line-addressed evidence unit cannot separate members from a one-line
+      // container. Keep the enclosing declaration's identity for that line.
+      if (entry.parent !== root && entry.start === entry.parent.start && entry.end === entry.parent.end) continue;
+      for (let i = entry.start - 1; i < entry.end; i++) owners[i] = entry;
+    }
+    const lineUnits = Array(lines.length).fill(null);
+    let start = 1;
+    while (start <= lines.length) {
+      const owner = owners[start - 1];
+      let end = start;
+      while (end < lines.length && owners[end] === owner) end++;
+      while (start <= end) {
+        let stop = Math.min(end, start + maxLines - 1);
+        if (stop < end) {
+          const candidates = [...boundaries].filter(b => start + Math.floor(maxLines / 2) <= b && b <= stop + 1 && b > start);
+          if (candidates.length) stop = Math.max(...candidates) - 1;
+        }
+        const text = lines.slice(start - 1, stop).join('\n');
+        if (text.trim()) {
+          const id = units.length;
+          const unit = { id, language: /\.(?:jsx?|mjs|cjs)$/.test(file.path) ? 'javascript' : 'typescript', path: file.path, module, name: owner.name,
+            symbol: owner.symbol, kind: owner.kind, scope: owner.parent?.symbol ?? root.symbol,
+            owner: owner.parent && owner.parent !== root ? owner.parent.symbol : null,
+            start, end: stop, text, calls: [], relations: [], edges: [], unresolved: [] };
+          units.push(unit); owner.ids.push(id);
+          for (let i = start - 1; i < stop; i++) lineUnits[i] = id;
+        }
+        start = stop + 1;
+      }
+    }
+    records.set(sf.fileName, { sf, entries, root, lineUnits, lineOf });
+  }
+  const unitAt = node => {
+    const record = records.get(node.getSourceFile().fileName);
+    return record?.lineUnits[record.lineOf(node.getStart()) - 1];
+  };
+  const entryFor = node => {
+    for (let cursor = node; cursor; cursor = cursor.parent) if (nodeEntries.has(cursor)) return nodeEntries.get(cursor);
+    return undefined;
+  };
+  const idsFor = node => {
+    if (!records.has(node.getSourceFile().fileName)) return [];
+    const entry = entryFor(node);
+    // Multiple declarations can share a line. Link to that actual source unit
+    // instead of inventing overlapping spans or dropping the declaration.
+    return entry?.ids.length ? entry.ids : [unitAt(node)].filter(id => id !== null && id !== undefined);
+  };
+  const symbolAt = node => {
+    let symbol = checker.getSymbolAtLocation(node);
+    if (symbol?.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+    return symbol;
+  };
+  const declarations = node => symbolAt(node)?.declarations ?? [];
+  const add = (from, targets, kind, confidence, resolution) => {
+    if (from === null || from === undefined) return;
+    for (const target of targets) if (target !== from) units[from].relations.push({ target, kind, confidence, resolution });
+  };
+  const unresolved = (node, kind, reason) => {
+    const id = unitAt(node);
+    if (id !== null && id !== undefined) units[id].unresolved.push({ kind, text: node.getText().slice(0, 200),
+      line: records.get(node.getSourceFile().fileName).lineOf(node.getStart()), reason });
+  };
+  for (const record of records.values()) {
+    for (const entry of record.entries) {
+      for (const id of entry.ids) {
+        add(id, entry.ids, 'same_symbol', 1, 'syntax');
+        if (entry.parent && entry.parent !== record.root) add(id, idsFor(entry.parent.node), 'member_of', 1, 'syntax');
+      }
+    }
+    function link(node) {
+      if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+        const expression = node.expression;
+        const id = unitAt(expression);
+        if (id !== null && id !== undefined) units[id].calls.push(expression.getText());
+        const type = checker.getTypeAtLocation(expression);
+        let targets = [];
+        if (!(type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown))) {
+          const symbolNode = ts.isPropertyAccessExpression(expression) ? expression.name : expression;
+          targets = declarations(symbolNode).filter(executable);
+          const signature = checker.getResolvedSignature(node)?.declaration;
+          if (!targets.length && executable(signature)) targets = [signature];
+        }
+        const ids = targets.flatMap(idsFor);
+        if (ids.length) add(id, ids, 'calls', .9, 'compiler-symbol');
+        else unresolved(expression, 'calls', 'dynamic, external, or no implementation in snapshot');
+      }
+      if ((ts.isClassLike(node) || ts.isInterfaceDeclaration(node)) && node.heritageClauses) {
+        for (const clause of node.heritageClauses) for (const type of clause.types) {
+          const targets = declarations(type.expression).flatMap(idsFor);
+          const kind = clause.token === ts.SyntaxKind.ExtendsKeyword ? 'inherits' : 'implements';
+          for (const id of idsFor(node)) add(id, targets, kind, .9, 'compiler-symbol');
+          if (!targets.length) unresolved(type, kind, 'no declaration in snapshot');
+        }
+      }
+      if (ts.isImportClause(node) || ts.isImportSpecifier(node) || ts.isNamespaceImport(node)) {
+        if (node.name) {
+          const targets = declarations(node.name).flatMap(idsFor);
+          add(unitAt(node), targets, 'imports', 1, 'compiler-symbol');
+          if (!targets.length) unresolved(node, 'imports', 'external or unresolved module');
+        }
+      }
+      if (ts.isTypeReferenceNode(node)) add(unitAt(node), declarations(node.typeName).flatMap(idsFor), 'references_type', .9, 'compiler-symbol');
+      ts.forEachChild(node, link);
+    }
+    link(record.sf);
+  }
+  for (const unit of units) {
+    unit.relations = [...new Map(unit.relations.map(r => [r.target + ':' + r.kind, r])).values()]
+      .sort((a, b) => a.target - b.target || a.kind.localeCompare(b.kind, 'en'));
+    unit.edges = [...new Set(unit.relations.map(r => r.target))].sort((a, b) => a - b);
+  }
+  return { compilerVersion: ts.version, units };
+}
+
+if (process.argv[1] && new URL(import.meta.url).pathname === path.resolve(process.argv[1])) {
+  try {
+    const input = JSON.parse(readFileSync(0, 'utf8'));
+    process.stdout.write(JSON.stringify(extract(input.files, input.maxLines, input.options)));
+  } catch (error) {
+    console.error(error.message); process.exitCode = 1;
+  }
+}

package/src/retrieval/languages/typescript.py

@@ -0,0 +1,23 @@
+"""Bridge to the pinned TypeScript compiler; reads source, never executes it."""
+import json
+from pathlib import Path
+import subprocess
+
+COMPILER_VERSION = '5.9.3'
+
+
+def extract(sources, max_lines=65, options=None):
+    payload = {'files': [{'path': source.path, 'text': source.text} for source in sources],
+               'maxLines': max_lines, 'options': options or {}}
+    try:
+        result = subprocess.run(['node', str(Path(__file__).with_suffix('.mjs'))],
+                                input=json.dumps(payload), text=True, capture_output=True,
+                                timeout=120, check=False)
+    except FileNotFoundError as error:
+        raise RuntimeError('TypeScript indexing requires Node.js and npm ci') from error
+    if result.returncode:
+        raise ValueError('TypeScript adapter failed: ' + result.stderr.strip()[:2000])
+    output = json.loads(result.stdout)
+    if output['compilerVersion'] != COMPILER_VERSION:
+        raise ValueError('Unexpected TypeScript compiler version; run npm ci')
+    return output['units']