@holmes-lab/holmes-kit 0.3.10 → 0.4.0

package/dist/holmes/cpg/foundation/ddg.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defUseOf = defUseOf;
+exports.ddgOf = ddgOf;
+exports.ddgViolations = ddgViolations;
+const cfg_1 = require("./cfg");
+/** Identifier positions that are DEF sites, keyed by the parent node type. */
+const PATTERN_TYPES = new Set(['object_pattern', 'array_pattern', 'shorthand_property_identifier_pattern',
+    'pair_pattern', 'rest_pattern', 'assignment_pattern']);
+function defUseOf(ast, cfg, fn, source) {
+    const kids = (0, cfg_1.childrenIndex)(ast);
+    const text = (i) => source.slice(ast.nodes[i].start, ast.nodes[i].end);
+    // ── parameters: ENTRY defs (and part of the local namespace).
+    const isPython = ast.lang === 'python';
+    const params = new Map();
+    const bareArrow = ast.nodes[fn.nodeIndex].type === 'arrow_function'
+        && !kids.of(fn.nodeIndex).some((k) => ast.nodes[k].type === 'formal_parameters');
+    for (const k of kids.of(fn.nodeIndex)) {
+        // Only formal_parameters — a declaration's NAME identifier is not a parameter (measured: the
+        // early break on the name swallowed every real parameter of named functions).
+        // @implements A-SPEC-510.7 — Python's parameter list node is `parameters`.
+        const isParamList = ast.nodes[k].type === 'formal_parameters' || ast.nodes[k].type === 'parameters';
+        if (!isParamList && !(bareArrow && ast.nodes[k].type === 'identifier'))
+            continue;
+        const collect = (n) => {
+            const ty = ast.nodes[n].type;
+            if (ty === 'identifier' || ty === 'shorthand_property_identifier_pattern')
+                params.set(text(n), n);
+            if (ty === 'type_annotation')
+                return; // types are not values
+            for (const c of kids.of(n))
+                collect(c);
+        };
+        collect(k);
+        if (isParamList)
+            break;
+    }
+    const defs = new Map();
+    const uses = new Map();
+    const add = (m, s, name) => {
+        if (!m.has(s))
+            m.set(s, new Set());
+        m.get(s).add(name);
+    };
+    // Walk one statement's subtree, skipping nested functions (their CFG owns them).
+    const stmtSet = new Set();
+    for (const b of cfg.blocks)
+        for (const s of b.stmts)
+            stmtSet.add(s);
+    const classify = (stmt) => {
+        const walk = (n, defCtx) => {
+            const ty = ast.nodes[n].type;
+            if (n !== stmt && cfg_1.FUNCTION_TYPES.has(ty))
+                return; // nested function boundary
+            if (n !== stmt && stmtSet.has(n))
+                return; // nested statements are their own rows
+            if (ty === 'type_annotation' || ty === 'type_arguments' || ty === 'comment')
+                return;
+            if (ty === 'identifier' || ty === 'shorthand_property_identifier_pattern') {
+                if (defCtx)
+                    add(defs, stmt, text(n));
+                else
+                    add(uses, stmt, text(n));
+                return;
+            }
+            if (ty === 'property_identifier' || ty === 'statement_identifier' || ty === 'type_identifier')
+                return;
+            switch (ty) {
+                // @implements A-SPEC-510.7 — Python's assignment shapes.
+                case 'assignment': {
+                    const named = kids.of(n).filter((c) => ast.nodes[c].named);
+                    const lhs = named[0];
+                    if (lhs !== undefined) {
+                        walk(lhs, ast.nodes[lhs].type === 'identifier' || PATTERN_TYPES.has(ast.nodes[lhs].type)
+                            || ast.nodes[lhs].type === 'pattern_list' || ast.nodes[lhs].type === 'tuple_pattern');
+                    }
+                    for (const r of named.slice(1))
+                        walk(r, false);
+                    return;
+                }
+                case 'augmented_assignment': {
+                    const named = kids.of(n).filter((c) => ast.nodes[c].named);
+                    const lhs = named[0];
+                    if (lhs !== undefined && ast.nodes[lhs].type === 'identifier') {
+                        add(defs, stmt, text(lhs));
+                        add(uses, stmt, text(lhs));
+                    }
+                    else if (lhs !== undefined)
+                        walk(lhs, false);
+                    for (const r of named.slice(1))
+                        walk(r, false);
+                    return;
+                }
+                case 'as_pattern': {
+                    // `with x as y` / `except E as y`: the alias is a def, the source an ordinary use.
+                    const named = kids.of(n).filter((c) => ast.nodes[c].named);
+                    for (let k = 0; k < named.length; k++)
+                        walk(named[k], k === named.length - 1);
+                    return;
+                }
+                case 'as_pattern_target': {
+                    for (const c of kids.of(n))
+                        walk(c, true);
+                    return;
+                }
+                case 'variable_declarator': {
+                    const [name, ...rest] = kids.of(n);
+                    walk(name, true);
+                    for (const r of rest)
+                        walk(r, false);
+                    return;
+                }
+                case 'assignment_expression': {
+                    const [lhs, ...rest] = kids.of(n).filter((c) => ast.nodes[c].named);
+                    // Only a bare identifier LHS is a def; a.b / a[i] mutation is NOT (sealed envelope) —
+                    // its identifiers (a, i) are USES.
+                    walk(lhs, ast.nodes[lhs].type === 'identifier' || PATTERN_TYPES.has(ast.nodes[lhs].type));
+                    for (const r of rest)
+                        walk(r, false);
+                    return;
+                }
+                case 'augmented_assignment_expression': {
+                    const [lhs, ...rest] = kids.of(n).filter((c) => ast.nodes[c].named);
+                    if (ast.nodes[lhs].type === 'identifier') {
+                        add(defs, stmt, text(lhs));
+                        add(uses, stmt, text(lhs));
+                    }
+                    else
+                        walk(lhs, false);
+                    for (const r of rest)
+                        walk(r, false);
+                    return;
+                }
+                case 'update_expression': {
+                    const arg = kids.of(n).find((c) => ast.nodes[c].named);
+                    if (arg !== undefined && ast.nodes[arg].type === 'identifier') {
+                        add(defs, stmt, text(arg));
+                        add(uses, stmt, text(arg));
+                    }
+                    else if (arg !== undefined)
+                        walk(arg, false);
+                    return;
+                }
+                case 'for_statement': {
+                    if (!isPython) {
+                        for (const c of kids.of(n))
+                            walk(c, false);
+                        return;
+                    }
+                    // Python `for TARGET in ITER:` — the target binds fresh each iteration.
+                    const named = kids.of(n).filter((c) => ast.nodes[c].named);
+                    if (named[0] !== undefined)
+                        walk(named[0], true);
+                    for (const r of named.slice(1))
+                        walk(r, false);
+                    return;
+                }
+                case 'for_in_statement': {
+                    // left is a def (fresh binding per iteration); right and body handled elsewhere/below.
+                    const named = kids.of(n).filter((c) => ast.nodes[c].named);
+                    walk(named[0], true);
+                    for (const r of named.slice(1))
+                        walk(r, false);
+                    return;
+                }
+                case 'attribute':
+                case 'subscript':
+                case 'member_expression':
+                case 'subscript_expression': {
+                    const named = kids.of(n).filter((c) => ast.nodes[c].named);
+                    walk(named[0], false); // the object is a use…
+                    for (const r of named.slice(1))
+                        if (ast.nodes[r].type !== 'property_identifier')
+                            walk(r, false);
+                    return;
+                }
+                default: {
+                    const patternDef = defCtx && PATTERN_TYPES.has(ty);
+                    for (const c of kids.of(n))
+                        walk(c, patternDef || defCtx && PATTERN_TYPES.has(ty));
+                    if (!patternDef && defCtx) { /* keep defCtx only through pattern nodes */ }
+                    return;
+                }
+            }
+        };
+        walk(stmt, false);
+    };
+    for (const s of stmtSet)
+        classify(s);
+    // catch parameters: a def at the head of the handler body's first statement.
+    ast.nodes.forEach((n, i) => {
+        if (n.type !== 'catch_clause')
+            return;
+        const named = kids.of(i).filter((k) => ast.nodes[k].named);
+        const param = named.find((k) => ast.nodes[k].type === 'identifier');
+        const block = named.find((k) => ast.nodes[k].type === 'statement_block');
+        if (param === undefined || block === undefined)
+            return;
+        const first = kids.of(block).find((k) => stmtSet.has(k));
+        if (first !== undefined)
+            add(defs, first, text(param));
+    });
+    // Locals-only filter for uses: names defined somewhere in this function, or parameters.
+    const local = new Set(params.keys());
+    for (const s of defs.values())
+        for (const name of s)
+            local.add(name);
+    for (const [s, names] of uses) {
+        const kept = new Set([...names].filter((n) => local.has(n)));
+        if (kept.size === 0)
+            uses.delete(s);
+        else
+            uses.set(s, kept);
+    }
+    return { defs, uses, params };
+}
+// @implements A-SPEC-510.4
+function ddgOf(ast, cfg, fn, source) {
+    if ('unsupported' in cfg)
+        return cfg; // no partial DDG over a refused CFG
+    const { defs, uses, params } = defUseOf(ast, cfg, fn, source);
+    const byName = new Map();
+    const notePoint = (name, p) => {
+        if (!byName.has(name))
+            byName.set(name, new Set());
+        byName.get(name).add(p);
+    };
+    for (const [s, names] of defs)
+        for (const name of names)
+            notePoint(name, s);
+    for (const [name, p] of params)
+        notePoint(name, p);
+    const nBlocks = cfg.blocks.length;
+    const IN = Array.from({ length: nBlocks }, () => new Map());
+    const OUT = Array.from({ length: nBlocks }, () => new Map());
+    const succ = Array.from({ length: nBlocks }, () => []);
+    const pred = Array.from({ length: nBlocks }, () => []);
+    const excPred = Array.from({ length: nBlocks }, () => []);
+    for (const e of cfg.edges) {
+        succ[e.from].push(e.to);
+        if (e.kind === 'exception')
+            excPred[e.to].push(e.from);
+        else
+            pred[e.to].push(e.from);
+    }
+    // ENTRY OUT: parameters.
+    for (const [name, p] of params)
+        OUT[cfg.entry].set(name, new Set([p]));
+    const transfer = (b) => {
+        const out = new Map();
+        for (const [k, v] of IN[b])
+            out.set(k, new Set(v));
+        if (b === cfg.entry)
+            for (const [name, p] of params)
+                out.set(name, new Set([p]));
+        for (const s of cfg.blocks[b].stmts) {
+            const names = defs.get(s);
+            if (names)
+                for (const name of names)
+                    out.set(name, new Set([s])); // kill + gen
+        }
+        return out;
+    };
+    const eq = (a, b) => {
+        if (a.size !== b.size)
+            return false;
+        for (const [k, v] of a) {
+            const w = b.get(k);
+            if (!w || w.size !== v.size)
+                return false;
+            for (const x of v)
+                if (!w.has(x))
+                    return false;
+        }
+        return true;
+    };
+    const work = [...Array(nBlocks).keys()];
+    while (work.length) {
+        const b = work.shift();
+        const nin = new Map();
+        const fold = (m) => {
+            for (const [k, v] of m) {
+                if (!nin.has(k))
+                    nin.set(k, new Set());
+                for (const x of v)
+                    nin.get(k).add(x);
+            }
+        };
+        for (const p of pred[b])
+            fold(OUT[p]);
+        // Exception predecessors may throw mid-statement: their PRE-state (IN) reaches the handler
+        // as well as their post-state (OUT) — union is the conservative may-analysis direction.
+        for (const p of excPred[b]) {
+            fold(IN[p]);
+            fold(OUT[p]);
+        }
+        IN[b] = nin;
+        const nout = transfer(b);
+        if (!eq(nout, OUT[b])) {
+            OUT[b] = nout;
+            for (const s of succ[b])
+                if (!work.includes(s))
+                    work.push(s);
+        }
+    }
+    // Edges: for each use, the defs live just before it (block-local order first, then IN).
+    const edges = [];
+    const seen = new Set();
+    for (const b of cfg.blocks) {
+        const live = new Map();
+        for (const [k, v] of IN[b.id])
+            live.set(k, new Set(v));
+        if (b.id === cfg.entry)
+            for (const [name, p] of params)
+                live.set(name, new Set([p]));
+        for (const s of b.stmts) {
+            const names = uses.get(s);
+            if (names) {
+                for (const name of names) {
+                    for (const d of live.get(name) ?? []) {
+                        const key = `${d}>${s}>${name}`;
+                        if (!seen.has(key)) {
+                            seen.add(key);
+                            edges.push({ defStmt: d, useStmt: s, name });
+                        }
+                    }
+                }
+            }
+            const dnames = defs.get(s);
+            if (dnames)
+                for (const name of dnames)
+                    live.set(name, new Set([s]));
+        }
+    }
+    return { edges, defs, uses, params };
+}
+// @implements A-SPEC-510.4
+/** The DDG verifier — [] means the reaching-definition THEORY holds on this instance. */
+function ddgViolations(ast, cfg, ddg) {
+    const out = [];
+    const stmtBlock = new Map();
+    for (const b of cfg.blocks)
+        for (const s of b.stmts)
+            stmtBlock.set(s, b.id);
+    const paramPoints = new Set(ddg.params.values());
+    const succ = cfg.blocks.map(() => []);
+    for (const e of cfg.edges)
+        succ[e.from].push(e.to);
+    const reachesFrom = (a, b) => {
+        const seen = new Set([a]);
+        const st = [a];
+        while (st.length) {
+            const x = st.pop();
+            if (x === b)
+                return true;
+            for (const s of succ[x])
+                if (!seen.has(s)) {
+                    seen.add(s);
+                    st.push(s);
+                }
+        }
+        return false;
+    };
+    const dup = new Set();
+    for (const e of ddg.edges) {
+        const key = `${e.defStmt}>${e.useStmt}>${e.name}`;
+        if (dup.has(key))
+            out.push(`duplicate edge ${key}`);
+        dup.add(key);
+        if (!stmtBlock.has(e.useStmt)) {
+            out.push(`use ${e.useStmt} outside the CFG`);
+            continue;
+        }
+        const db = paramPoints.has(e.defStmt) ? cfg.entry : stmtBlock.get(e.defStmt);
+        if (db === undefined) {
+            out.push(`def ${e.defStmt} outside the CFG`);
+            continue;
+        }
+        const ub = stmtBlock.get(e.useStmt);
+        // A reaching definition MUST have a CFG path def→use (same block counts as ordered).
+        if (db === ub) {
+            const stmts = cfg.blocks[db].stmts;
+            if (!paramPoints.has(e.defStmt) && stmts.indexOf(e.defStmt) >= stmts.indexOf(e.useStmt)) {
+                // def after use in the same block: only legitimate via a loop back to the block head.
+                if (!reachesFrom(ub, db))
+                    out.push(`same-block def ${e.defStmt} after use ${e.useStmt} with no loop`);
+            }
+        }
+        else if (!reachesFrom(db, ub)) {
+            out.push(`no CFG path from def ${e.defStmt} (block ${db}) to use ${e.useStmt} (block ${ub})`);
+        }
+    }
+    return out;
+}

package/dist/holmes/cpg/foundation/language-envelope.d.ts

@@ -0,0 +1,29 @@
+export declare const LANG_FIXTURES: ReadonlyArray<{
+    file: string;
+    lang: string;
+    construct: string;
+}>;
+export declare const LANG_FIXTURES_DIR: string;
+export interface LangEnvelopeRow {
+    file: string;
+    lang: string;
+    construct: string;
+    symbols: number;
+    edges: number;
+    /** Distinct relation kinds the scanner recovered — 'calls' | 'imports' | 'inherits'. */
+    relationKinds: string[];
+}
+/**
+ * Scan EXACTLY the language corpus with the CURRENT extractor. Pure with respect to anything
+ * outside the declared fixture list, exactly like the TS/Python census.
+ */
+export declare function languageEnvelope(dir?: string): LangEnvelopeRow[];
+/** Constructs the current extractor cannot see at all — the honest half of the envelope. */
+export declare function invisibleLangConstructs(rows?: LangEnvelopeRow[]): string[];
+/** Per-language totals, for the activation-log table. */
+export declare function envelopeByLanguage(rows?: LangEnvelopeRow[]): Record<string, {
+    files: number;
+    symbols: number;
+    edges: number;
+    invisible: number;
+}>;

package/dist/holmes/cpg/foundation/language-envelope.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LANG_FIXTURES_DIR = exports.LANG_FIXTURES = void 0;
+exports.languageEnvelope = languageEnvelope;
+exports.invisibleLangConstructs = invisibleLangConstructs;
+exports.envelopeByLanguage = envelopeByLanguage;
+// @implements A-SPEC-510.6
+/**
+ * The per-language honesty envelope for L0 extraction — the .1 method (a construct corpus whose
+ * failures are frozen AS failures) extended to every language holmes-kit advertises beyond
+ * TS/Python. What the extractor cannot see in Go, Rust, Java, C# or C++ becomes a NUMBER here
+ * instead of an unexamined assumption.
+ *
+ * Concepts are matched across languages so the table compares like with like: types+methods,
+ * interfaces/traits, generics/templates, concurrency/async, error handling, branching.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const cpg_scanner_1 = require("../cpg-scanner");
+exports.LANG_FIXTURES = [
+    // Go
+    { file: 'types_methods.go', lang: 'go', construct: 'struct + pointer/value receivers' },
+    { file: 'interfaces.go', lang: 'go', construct: 'interface + implementations + range' },
+    { file: 'generics.go', lang: 'go', construct: 'type-parameter constraints, generic struct' },
+    { file: 'concurrency.go', lang: 'go', construct: 'goroutine + channel + WaitGroup' },
+    { file: 'errors.go', lang: 'go', construct: 'error wrapping + defer/recover' },
+    { file: 'branching.go', lang: 'go', construct: 'type switch with multi-value case' },
+    // Rust
+    { file: 'types_methods.rs', lang: 'rust', construct: 'struct + impl block' },
+    { file: 'traits.rs', lang: 'rust', construct: 'trait with default method + impl for' },
+    { file: 'generics.rs', lang: 'rust', construct: 'bounded generics + generic impl' },
+    { file: 'async_fixture.rs', lang: 'rust', construct: 'async fn + await' },
+    { file: 'errors.rs', lang: 'rust', construct: 'Result + ? operator + enum error' },
+    { file: 'branching.rs', lang: 'rust', construct: 'match with guards and or-patterns' },
+    // Java
+    { file: 'WidgetFixture.java', lang: 'java', construct: 'class + constructor + fields' },
+    { file: 'RendererFixture.java', lang: 'java', construct: 'interface with default method' },
+    { file: 'GenericsFixture.java', lang: 'java', construct: 'bounded type params + generic method' },
+    { file: 'LambdaFixture.java', lang: 'java', construct: 'lambda + method reference + stream' },
+    { file: 'ErrorsFixture.java', lang: 'java', construct: 'try-with-resources + catch + finally' },
+    { file: 'BranchingFixture.java', lang: 'java', construct: 'switch with fallthrough + default' },
+    // C#
+    { file: 'WidgetFixture.cs', lang: 'csharp', construct: 'class + expression-bodied members' },
+    { file: 'RendererFixture.cs', lang: 'csharp', construct: 'interface default impl + implementer' },
+    { file: 'GenericsFixture.cs', lang: 'csharp', construct: 'generic class with where + generic method' },
+    { file: 'AsyncFixture.cs', lang: 'csharp', construct: 'async/await Task methods' },
+    { file: 'ErrorsFixture.cs', lang: 'csharp', construct: 'try/catch/finally' },
+    { file: 'BranchingFixture.cs', lang: 'csharp', construct: 'switch expression with patterns' },
+    // C++
+    { file: 'widget.cpp', lang: 'cpp', construct: 'class + member init + const method' },
+    { file: 'renderer.cpp', lang: 'cpp', construct: 'abstract base + virtual override' },
+    { file: 'templates.cpp', lang: 'cpp', construct: 'function + class templates' },
+    { file: 'lambdas.cpp', lang: 'cpp', construct: 'lambda capture + algorithm' },
+    { file: 'errors.cpp', lang: 'cpp', construct: 'throw + multiple catch + catch-all' },
+    { file: 'branching.cpp', lang: 'cpp', construct: 'switch with fallthrough + block case' },
+];
+exports.LANG_FIXTURES_DIR = (() => {
+    const here = path.join(__dirname, 'fixtures-lang');
+    // Fixtures are DATA (excluded from tsc), so a dist-resolved consumer falls back to src.
+    return fs.existsSync(here) ? here : here.replace(`${path.sep}dist${path.sep}`, `${path.sep}src${path.sep}`);
+})();
+/**
+ * Scan EXACTLY the language corpus with the CURRENT extractor. Pure with respect to anything
+ * outside the declared fixture list, exactly like the TS/Python census.
+ */
+function languageEnvelope(dir = exports.LANG_FIXTURES_DIR) {
+    const scanned = new cpg_scanner_1.CpgScanner().scan(dir, dir);
+    const byBase = new Map(scanned.map((f) => [path.basename(f.path), f]));
+    return exports.LANG_FIXTURES.map(({ file, lang, construct }) => {
+        const f = byBase.get(file);
+        const edges = f?.edges ?? [];
+        return {
+            file,
+            lang,
+            construct,
+            symbols: f?.symbols.length ?? 0,
+            edges: edges.length,
+            relationKinds: [...new Set(edges.map((e) => e.rel))].sort(),
+        };
+    });
+}
+/** Constructs the current extractor cannot see at all — the honest half of the envelope. */
+function invisibleLangConstructs(rows = languageEnvelope()) {
+    return rows.filter((r) => r.symbols === 0).map((r) => r.file);
+}
+/** Per-language totals, for the activation-log table. */
+function envelopeByLanguage(rows = languageEnvelope()) {
+    const out = {};
+    for (const r of rows) {
+        const acc = out[r.lang] ?? (out[r.lang] = { files: 0, symbols: 0, edges: 0, invisible: 0 });
+        acc.files++;
+        acc.symbols += r.symbols;
+        acc.edges += r.edges;
+        if (r.symbols === 0)
+            acc.invisible++;
+    }
+    return out;
+}

package/dist/holmes/cpg/foundation/language-matrix.d.ts

@@ -0,0 +1,57 @@
+export declare const LAYERS: readonly ["relations", "ast", "cfg", "ddg", "cdg", "runner", "taint"];
+export type Layer = typeof LAYERS[number];
+/** The language families holmes-kit advertises, each with the probe inputs the derivation needs. */
+export declare const MATRIX_LANGUAGES: readonly [{
+    readonly lang: "typescript";
+    readonly label: "TypeScript / JavaScript";
+    readonly ext: ".ts";
+    readonly astLang: "typescript";
+    readonly sampleFile: "x.test.ts";
+}, {
+    readonly lang: "python";
+    readonly label: "Python";
+    readonly ext: ".py";
+    readonly astLang: "python";
+    readonly sampleFile: "test_x.py";
+}, {
+    readonly lang: "csharp";
+    readonly label: "C#";
+    readonly ext: ".cs";
+    readonly astLang: "csharp";
+    readonly sampleFile: "XTest.cs";
+}, {
+    readonly lang: "java";
+    readonly label: "Java";
+    readonly ext: ".java";
+    readonly astLang: "java";
+    readonly sampleFile: "XTest.java";
+}, {
+    readonly lang: "go";
+    readonly label: "Go";
+    readonly ext: ".go";
+    readonly astLang: "go";
+    readonly sampleFile: "x_test.go";
+}, {
+    readonly lang: "rust";
+    readonly label: "Rust";
+    readonly ext: ".rs";
+    readonly astLang: "rust";
+    readonly sampleFile: "tests/x.rs";
+}, {
+    readonly lang: "cpp";
+    readonly label: "C++";
+    readonly ext: ".cpp";
+    readonly astLang: "cpp";
+    readonly sampleFile: "x_test.cpp";
+}];
+export type MatrixLanguage = typeof MATRIX_LANGUAGES[number]['lang'];
+export type Support = 'full' | 'partial' | 'none';
+export interface Cell {
+    support: Support;
+    basis: string;
+}
+export type LanguageMatrix = Record<Layer, Record<string, Cell>>;
+/** Derive the whole matrix. Pure, cheap, and impossible to drift from its sources. */
+export declare function languageMatrix(): LanguageMatrix;
+/** Render docs/language-support.md — the table is a PRODUCT of the code, not a claim beside it. */
+export declare function renderLanguageSupport(): string;