bantamkit-mcp 0.29.1 → 0.30.0

package/dist/pysem.d.ts

@@ -0,0 +1,81 @@
+/**
+ * CPython string semantics this runtime needs in more than one place, written ONCE.
+ *
+ * `docs/roadmap-toolbox.md` row 8, entry (n): `pyStrip`, `cmpCodepoint` and `pyRepr` had each
+ * been ported twice — once in `docread.ts` and once under `memory/` — as independent
+ * re-derivations of the same three CPython behaviours. Two implementations of one semantic are
+ * two chances to be right and one certainty of drifting, and neither copy had a test that
+ * compared it to the other.
+ *
+ * **The pairs were diffed before they were merged**, because unifying two functions that are
+ * not the same function is a behaviour change wearing a refactor's clothes:
+ *
+ * * `pyStrip` — the two agreed on the set of characters `str.isspace()` is true for (29 each,
+ *   with an empty symmetric difference over all 1,114,112 codepoints) and on 200,000 random
+ *   strings built from that alphabet. Kept: the REGEX spelling, because the set-based one
+ *   spreads the whole string into an array of characters first, and this is called once per
+ *   rendered row.
+ * * `pyRepr` — byte-identical output on every one of the 1,114,112 codepoints and on a pool of
+ *   quoting edge cases. `docread`'s explicit `Cc|Cf|Cs|Co|Cn|Zl|Zp|Zs` class and `memory`'s
+ *   `\p{C}|\p{Z}` are the same set spelled two ways. Kept: the precompiled class.
+ * * `cmpCodepoint` — the same ORDER on every pair (0 sign disagreements), and different
+ *   NUMBERS: `docread`'s returned the codepoint difference and the `memory` copy returns
+ *   -1/0/1, so `cmp('', 'ab')` was -1 there and -2 here. Kept: the `memory` spelling to the
+ *   digit, because every importer outside `docread.ts` already sees those numbers, while
+ *   `docread`'s copy had no importer at all and one use — `Array.prototype.sort`, which reads
+ *   the sign and nothing else.
+ *
+ * **A THIRD COPY SURVIVED THAT CLOSURE AND WAS FOLDED IN ON 2026-09-06 (job44, unit F4).**
+ * "written ONCE" was not true when it was written: entry (n) named `docread.ts` and `memory/`
+ * and nothing else, so `skillaudit.ts` — product surface, the eleventh MCP tool — kept its own
+ * `pyStrip` on a 29-codepoint Set and its own `cmpCodepoint` in the `cx - cy` spelling, the two
+ * this module had just rejected. Both now import from here, gated first by the same method:
+ * an empty symmetric difference between the two whitespace sets over every codepoint, 0
+ * disagreements on `pyStrip` over 200,000 random strings, 0 disagreements on a
+ * `` `^${PY_WS_CLASS}` `` regex against that module's Set-membership `startsWithSpace` over
+ * every codepoint, and — the reason the gate is not optional — `cmpCodepoint` agreeing on SIGN
+ * in all of 324 exhaustive plus 200,000 random pairs while disagreeing on the NUMBER in
+ * 167,851 of them. `skillaudit.ts`'s six uses read the sign alone, which is what made the
+ * substitution safe; its header carries the reading and the caveat.
+ *
+ * Nothing here is re-exported from `index.ts`: the names stay exported from the modules that
+ * always exported them, so this is a delegation and not a surface change.
+ */
+/**
+ * The characters `str.isspace()` is true for — what `strip()` and `split()` consume.
+ *
+ * NOT `String.prototype.trim()`'s set. Measured over all 0x110000 codepoints: Python strips 29,
+ * JS strips 25, and the two disagree on six — Python also strips U+001C..U+001F and U+0085, JS
+ * also strips U+FEFF. `_write_fact` ends with `fact.body.strip() + "\n"`, so each of those six
+ * is a byte of difference in a file the memory store then compares, hashes and diffs; in
+ * `docread` the same six decide whether a row is blank.
+ */
+export declare const PY_WS = "\t\n\v\f\r\u001C\u001D\u001E\u001F \u0085\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000";
+/** `PY_WS` as a character class, with the four characters a class gives meaning escaped. */
+export declare const PY_WS_CLASS: string;
+/** `str.strip()` with no argument. */
+export declare function pyStrip(s: string): string;
+/**
+ * Python's `<` on `str`, which is CODEPOINT order. JS compares UTF-16 code units.
+ *
+ * They disagree for every astral character: `['\u{1F414}.md', '！.md'].sort()` puts the chicken
+ * first because its lead surrogate is 0xD83D, and Python puts it last because 0x1F414 > 0xFF01.
+ * `_fact_paths` sorts, `recall` breaks score ties on the name, and the index is written in that
+ * order — so a single astral fact name is enough to make two `index.md` files that differ. In
+ * `docread` the same order decides which omission reason is rendered first.
+ */
+export declare function cmpCodepoint(a: string, b: string): number;
+/**
+ * `repr(str)` — the refusal sentences' quoting, and `_pinned_store`'s `{raw!r}`.
+ *
+ * Python quotes with `'` unless the value contains a `'` and no `"`; it escapes `\\`, the
+ * quote, `\t`, `\n`, `\r`, and every codepoint that is not `str.isprintable()` — that is,
+ * everything in a `C*` category and every separator except the space itself. The escapes are
+ * `\xNN` below U+0100, `\uNNNN` below U+10000, `\UNNNNNNNN` above.
+ *
+ * The one place it can drift is a codepoint whose category changed between CPython 3.12's
+ * Unicode 15.0 and the ICU this Node was built against: a newly assigned character is `Cn`
+ * (not printable, escaped) for Python and assigned (printable, raw) here. A path made of
+ * brand-new codepoints is the only input that reaches it.
+ */
+export declare function pyRepr(s: string): string;

package/dist/pysem.js

@@ -0,0 +1,126 @@
+/**
+ * CPython string semantics this runtime needs in more than one place, written ONCE.
+ *
+ * `docs/roadmap-toolbox.md` row 8, entry (n): `pyStrip`, `cmpCodepoint` and `pyRepr` had each
+ * been ported twice — once in `docread.ts` and once under `memory/` — as independent
+ * re-derivations of the same three CPython behaviours. Two implementations of one semantic are
+ * two chances to be right and one certainty of drifting, and neither copy had a test that
+ * compared it to the other.
+ *
+ * **The pairs were diffed before they were merged**, because unifying two functions that are
+ * not the same function is a behaviour change wearing a refactor's clothes:
+ *
+ * * `pyStrip` — the two agreed on the set of characters `str.isspace()` is true for (29 each,
+ *   with an empty symmetric difference over all 1,114,112 codepoints) and on 200,000 random
+ *   strings built from that alphabet. Kept: the REGEX spelling, because the set-based one
+ *   spreads the whole string into an array of characters first, and this is called once per
+ *   rendered row.
+ * * `pyRepr` — byte-identical output on every one of the 1,114,112 codepoints and on a pool of
+ *   quoting edge cases. `docread`'s explicit `Cc|Cf|Cs|Co|Cn|Zl|Zp|Zs` class and `memory`'s
+ *   `\p{C}|\p{Z}` are the same set spelled two ways. Kept: the precompiled class.
+ * * `cmpCodepoint` — the same ORDER on every pair (0 sign disagreements), and different
+ *   NUMBERS: `docread`'s returned the codepoint difference and the `memory` copy returns
+ *   -1/0/1, so `cmp('', 'ab')` was -1 there and -2 here. Kept: the `memory` spelling to the
+ *   digit, because every importer outside `docread.ts` already sees those numbers, while
+ *   `docread`'s copy had no importer at all and one use — `Array.prototype.sort`, which reads
+ *   the sign and nothing else.
+ *
+ * **A THIRD COPY SURVIVED THAT CLOSURE AND WAS FOLDED IN ON 2026-09-06 (job44, unit F4).**
+ * "written ONCE" was not true when it was written: entry (n) named `docread.ts` and `memory/`
+ * and nothing else, so `skillaudit.ts` — product surface, the eleventh MCP tool — kept its own
+ * `pyStrip` on a 29-codepoint Set and its own `cmpCodepoint` in the `cx - cy` spelling, the two
+ * this module had just rejected. Both now import from here, gated first by the same method:
+ * an empty symmetric difference between the two whitespace sets over every codepoint, 0
+ * disagreements on `pyStrip` over 200,000 random strings, 0 disagreements on a
+ * `` `^${PY_WS_CLASS}` `` regex against that module's Set-membership `startsWithSpace` over
+ * every codepoint, and — the reason the gate is not optional — `cmpCodepoint` agreeing on SIGN
+ * in all of 324 exhaustive plus 200,000 random pairs while disagreeing on the NUMBER in
+ * 167,851 of them. `skillaudit.ts`'s six uses read the sign alone, which is what made the
+ * substitution safe; its header carries the reading and the caveat.
+ *
+ * Nothing here is re-exported from `index.ts`: the names stay exported from the modules that
+ * always exported them, so this is a delegation and not a surface change.
+ */
+// ------------------------------------------------------------------------- str.strip()
+/**
+ * The characters `str.isspace()` is true for — what `strip()` and `split()` consume.
+ *
+ * NOT `String.prototype.trim()`'s set. Measured over all 0x110000 codepoints: Python strips 29,
+ * JS strips 25, and the two disagree on six — Python also strips U+001C..U+001F and U+0085, JS
+ * also strips U+FEFF. `_write_fact` ends with `fact.body.strip() + "\n"`, so each of those six
+ * is a byte of difference in a file the memory store then compares, hashes and diffs; in
+ * `docread` the same six decide whether a row is blank.
+ */
+export const PY_WS = '\t\n\x0b\x0c\r\x1c\x1d\x1e\x1f \x85\xa0            

  　';
+/** `PY_WS` as a character class, with the four characters a class gives meaning escaped. */
+export const PY_WS_CLASS = `[${PY_WS.replace(/[\]\\^-]/g, '\\$&')}]`;
+const PY_STRIP = new RegExp(`^${PY_WS_CLASS}+|${PY_WS_CLASS}+$`, 'g');
+/** `str.strip()` with no argument. */
+export function pyStrip(s) {
+    return s.replace(PY_STRIP, '');
+}
+// ------------------------------------------------------------------------ sorted() on str
+/**
+ * Python's `<` on `str`, which is CODEPOINT order. JS compares UTF-16 code units.
+ *
+ * They disagree for every astral character: `['\u{1F414}.md', '！.md'].sort()` puts the chicken
+ * first because its lead surrogate is 0xD83D, and Python puts it last because 0x1F414 > 0xFF01.
+ * `_fact_paths` sorts, `recall` breaks score ties on the name, and the index is written in that
+ * order — so a single astral fact name is enough to make two `index.md` files that differ. In
+ * `docread` the same order decides which omission reason is rendered first.
+ */
+export function cmpCodepoint(a, b) {
+    const x = [...a];
+    const y = [...b];
+    const n = Math.min(x.length, y.length);
+    for (let i = 0; i < n; i += 1) {
+        const p = x[i].codePointAt(0);
+        const q = y[i].codePointAt(0);
+        if (p !== q)
+            return p < q ? -1 : 1;
+    }
+    return x.length - y.length;
+}
+// ---------------------------------------------------------------------------- repr(str)
+// `str.isprintable()` is false for these categories (space itself excepted). Precompiled: the
+// refusal sentences build one of these per character of a path.
+const NONPRINTABLE = /[\p{Cc}\p{Cf}\p{Cs}\p{Co}\p{Cn}\p{Zl}\p{Zp}\p{Zs}]/u;
+/**
+ * `repr(str)` — the refusal sentences' quoting, and `_pinned_store`'s `{raw!r}`.
+ *
+ * Python quotes with `'` unless the value contains a `'` and no `"`; it escapes `\\`, the
+ * quote, `\t`, `\n`, `\r`, and every codepoint that is not `str.isprintable()` — that is,
+ * everything in a `C*` category and every separator except the space itself. The escapes are
+ * `\xNN` below U+0100, `\uNNNN` below U+10000, `\UNNNNNNNN` above.
+ *
+ * The one place it can drift is a codepoint whose category changed between CPython 3.12's
+ * Unicode 15.0 and the ICU this Node was built against: a newly assigned character is `Cn`
+ * (not printable, escaped) for Python and assigned (printable, raw) here. A path made of
+ * brand-new codepoints is the only input that reaches it.
+ */
+export function pyRepr(s) {
+    const quote = s.includes("'") && !s.includes('"') ? '"' : "'";
+    let out = quote;
+    for (const ch of s) {
+        const code = ch.codePointAt(0);
+        if (ch === quote || ch === '\\')
+            out += '\\' + ch;
+        else if (ch === '\t')
+            out += '\\t';
+        else if (ch === '\n')
+            out += '\\n';
+        else if (ch === '\r')
+            out += '\\r';
+        else if (ch !== ' ' && NONPRINTABLE.test(ch)) {
+            if (code < 0x100)
+                out += '\\x' + code.toString(16).padStart(2, '0');
+            else if (code < 0x10000)
+                out += '\\u' + code.toString(16).padStart(4, '0');
+            else
+                out += '\\U' + code.toString(16).padStart(8, '0');
+        }
+        else
+            out += ch;
+    }
+    return out + quote;
+}

package/dist/repomap.d.ts

@@ -0,0 +1,247 @@
+export declare const DAMPING = 0.2;
+export declare const ITERATIONS = 30;
+export declare const MIN_REFERENCE_LENGTH = 3;
+export declare const REFERENCE_DF_MAX_NUM = 1;
+export declare const REFERENCE_DF_MAX_DEN = 8;
+export declare const MAX_DEFINITIONS_PER_FILE = 4;
+export declare const DEFAULT_BUDGET = 4000;
+export declare const SCORE_SCALE = 1000000000;
+export declare const MAX_FILE_BYTES = 1048576;
+export declare const SKIP_DIRS: readonly string[];
+/**
+ * Suffix -> dialect. Two dialects only: `python` and `ecma`. TypeScript and JavaScript
+ * share a scanner because their DECLARATION forms are the same set; the extra TypeScript
+ * keywords (`interface`, `type`, `enum`) are simply absent from a `.js` file.
+ */
+export declare const LANGUAGES: Readonly<Record<string, string>>;
+export declare const OMIT_UNKNOWN_LANGUAGE = "unknown-language";
+export declare const OMIT_UNREADABLE = "unreadable-bytes";
+export declare const OMIT_SIZE_CAP = "size-cap";
+export declare const OMIT_NO_DEFINITIONS = "no-definitions";
+export declare const OMIT_UNREACHABLE = "unreachable";
+export declare const OMIT_PER_FILE_CAP = "per-file-cap";
+export declare const OMIT_BUDGET = "budget";
+/**
+ * Fixed render order for the footer, so two runs of the same map cannot disagree about the
+ * order of their disclosures.
+ */
+export declare const OMISSION_ORDER: readonly string[];
+/**
+ * One definition, at the line it was declared on. `line` is 1-based and counts lines of the
+ * ORIGINAL file, not of the comment-stripped view: a caller that jumps to it must land
+ * where the reader would.
+ */
+export interface Definition {
+    readonly path: string;
+    readonly line: number;
+    readonly kind: string;
+    readonly name: string;
+}
+/**
+ * Something the tree holds that the map does not carry, as a COUNT and the fact behind it —
+ * `docread`'s `Omission` discipline, deliberately re-stated here rather than imported,
+ * because these subjects are this module's and a shared vocabulary would make a change to
+ * one reader a change to the other.
+ *
+ * Never an adjective. `subject` is one of the `OMIT_*` tokens; a renderer that meets a token
+ * it does not know must still print the count. A silent skip is how a reader lies about its
+ * coverage.
+ */
+export interface Omission {
+    readonly subject: string;
+    readonly count: number;
+    readonly size: number;
+    readonly facts: readonly (readonly [string, number])[];
+}
+export interface RankedFile {
+    readonly path: string;
+    readonly rankUnits: number;
+    readonly definitions: readonly Definition[];
+    /**
+     * The raw double. Reported for a caller that wants it; NEVER rendered, and never the sort
+     * key — see trap (8).
+     */
+    readonly score: number;
+}
+export interface RepoMap {
+    readonly text: string;
+    readonly ranked: readonly RankedFile[];
+    readonly omissions: readonly Omission[];
+    readonly focus: readonly string[];
+    readonly nodes: number;
+    readonly edges: number;
+    readonly definitions: number;
+    readonly damping: number;
+    readonly iterations: number;
+    readonly budget: number;
+    readonly perFile: number;
+    readonly listingBytes: number;
+    readonly filesRendered: number;
+    readonly definitionsRendered: number;
+}
+export interface RepoMapOptions {
+    readonly focus?: readonly string[];
+    readonly budget?: number;
+    readonly files?: readonly string[] | null;
+    readonly damping?: number;
+    readonly iterations?: number;
+    readonly perFile?: number;
+}
+/**
+ * The dialect for a path, or `null` when this scanner has no reader for it.
+ *
+ * Dispatch is on SUFFIX, and that is a deliberate departure from `docread`, which sniffs
+ * because a suffix is measurably a lie about a document's container. A source file is
+ * different: `.py` and `.ts` name a GRAMMAR, and there is no magic number for a grammar. A
+ * file whose suffix is unknown is reported, never guessed at.
+ */
+export declare function languageOf(path: string): string | null;
+/**
+ * The file's lines with comments and docstrings blanked, one output line per input line so
+ * line numbers survive.
+ *
+ * Line-oriented and stateful across lines, because both traps that matter span lines: a
+ * Python triple-quoted docstring and an ECMAScript block comment. What is removed:
+ *
+ * - `python` — `'''`/`"""` blocks (the delimiter that opens is the only one that can close),
+ *   and everything from an unquoted `#` to end of line.
+ * - `ecma` — block comments, and everything from `//` to end of line.
+ *
+ * What is NOT removed, and is declared rather than hidden: the contents of a SINGLE-line
+ * string literal. Stripping those would lose the real references inside an f-string, and
+ * keeping them costs a definition-shaped line inside a one-line string being read as a
+ * definition. Backslash escapes are NOT honoured: a `"""` inside a string toggles the state
+ * machine. Both runtimes get that wrong identically, which is the requirement.
+ */
+export declare function stripNoncode(text: string, language: string): string[];
+/**
+ * Every definition in `text`, in source order.
+ *
+ * `python` — `def` and `class` at ANY indentation, so a method counts. Methods are the
+ * signal that made the difference in measurement: a focus on `memory/dream.py` reaches
+ * `memory/store.py` through `_write_fact`, `_fact_path` and `_check_index_budget`, none of
+ * which is top-level. Plus a bare `NAME =` or `NAME: T =` at column 0, which is how this
+ * repository declares its constants.
+ *
+ * `ecma` — `function class interface type const let var enum` at COLUMN 0 only, optionally
+ * behind `export` and `default` and `async`. Restricting to column 0 was the second-largest
+ * measured improvement in this module (recall@10 0.361 -> 0.410 on its own): an indented
+ * `const` is a local, and `runtime-ts/src/docread.ts` was contributing 452 of them.
+ *
+ * The asymmetry is real and is not an oversight: an ECMAScript class member cannot be told
+ * from a call at the same indentation without tracking braces, and a scanner that guessed
+ * would invent definitions. Python's `def` keyword makes the same question free.
+ */
+export declare function scanDefinitions(text: string, language: string, path?: string): Definition[];
+/**
+ * Every identifier of at least `MIN_REFERENCE_LENGTH` characters outside a comment.
+ *
+ * A SET, not a count. The edge weight below is "how many DISTINCT names of B does A
+ * mention", so a file that repeats one name a hundred times does not out-weigh a file that
+ * mentions ten. That is the choice the ambiguity filter and `MIN_REFERENCE_LENGTH` were
+ * tuned against and it keeps every weight an exact integer.
+ */
+export declare function referenceNames(text: string, language: string): Set<string>;
+/**
+ * Every path under `root`, relative, POSIX, code-point sorted.
+ *
+ * DIRECTORY SYMLINKS ARE NOT FOLLOWED, AND ON THIS SIDE THAT IS REAL LOGIC RATHER THAN A
+ * FLAG. `os.walk(followlinks=False)` gives CPython the whole rule for free, and J45-9's
+ * mutation 24 — delete the explicit `islink` filter — SURVIVED there for exactly that
+ * reason. Node has no equivalent, and the Dirent that looks like the answer is the wrong
+ * one: `readdirSync(..., {withFileTypes: true})` reports from **lstat**, so a symlink to a
+ * directory answers `isDirectory() === false` and a naive port hands it to the scanner as a
+ * source FILE. CPython does the opposite — `os.scandir`'s `entry.is_dir()` FOLLOWS, so the
+ * link lands in `dirs`, and `followlinks=False` then declines to descend, so it appears in
+ * the output neither as a file nor as a directory.
+ *
+ * Measured on node v25.2.1 and CPython 3.12.13 over one tree holding `real/`,
+ * `linkdir -> real`, `linkfile.py -> plain.py` and a dangling `dangling.py`: CPython's walk
+ * yields `dirs=['linkdir', 'real'] files=['dangling.py', 'linkfile.py', 'plain.py']` and
+ * `walk_sources` returns `['dangling.py', 'linkfile.py', 'plain.py', 'real/a.py']`. So the
+ * three cases are separated by a FOLLOW-`stat`, not by the Dirent:
+ *
+ * - symlink whose target is a directory  -> a directory, and not descended into: gone.
+ * - symlink whose target is a file       -> a file: kept.
+ * - dangling symlink                     -> `stat` throws, CPython's `is_dir()` raises and
+ *                                           is caught as False: a file, kept, and it will
+ *                                           be counted as `unreadable-bytes` downstream.
+ *
+ * Two reasons the rule exists and both are measured elsewhere in this repository: a symlink
+ * cycle makes the walk non-terminating, and a dangling directory symlink is one error shape
+ * on POSIX and two on Windows (`reference-windows-dangling-symlink-two-shapes`).
+ *
+ * A directory whose listing throws is skipped whole, silently, because that is what
+ * `os.walk`'s default `onerror=None` does.
+ */
+export declare function walkSources(root: string): string[];
+/**
+ * `source -> {target: weight}`, weight being the number of surviving names the source
+ * mentions that ONLY the target defines.
+ *
+ * Weights are exact integers, so `out[i]` in `pagerank` is an exact integer too and the only
+ * inexact step in the whole pass is the one division.
+ */
+export declare function buildGraph(definitions: Map<string, readonly Definition[]>, references: Map<string, ReadonlySet<string>>): Map<string, Map<string, number>>;
+/**
+ * At most `limit` of a file's definitions, chosen by kind then reach, returned in SOURCE
+ * order.
+ *
+ * The key is `(kind rank, -reference count, line, name)`, and every part of it is an integer
+ * or a code-point comparison, so the choice is TOTAL — which is why this port does not lean
+ * on `Array.prototype.sort` being stable. `references` is the RAW count from `nameIndex`;
+ * see there for why it is not the filtered one.
+ *
+ * **This ordering is argued, not measured, and the difference matters.** Every other
+ * constant in this module beat a named alternative on a yardstick. This one cannot: the
+ * yardstick is "does the focus file's own import appear in the rendered map", which is a
+ * question about which FILES are listed, and selection only decides which lines appear UNDER
+ * a file already listed. Measured, it moves that number by zero. So it rests on a stated
+ * principle instead — name the file's subject before its details — and a later unit with a
+ * definition-level yardstick is entitled to overturn it. What it is NOT is source order,
+ * which put `VALID_TYPES`, `DURABLE_TYPES`, `NAME_RE` and `DUPLICATE_JACCARD` at the head of
+ * `memory/store.py`'s block.
+ *
+ * The selected definitions are re-sorted into SOURCE order for rendering: a block whose line
+ * numbers ran backwards would be harder to read for no gain, and the order a block is chosen
+ * in is not the order it is read in.
+ */
+export declare function selectDefinitions(definitions: readonly Definition[], references: Map<string, number>, limit: number): readonly Definition[];
+/**
+ * Personalised PageRank, bit-identical to `repomap.py` by construction.
+ *
+ * The port contract, in the order the loop performs it:
+ *
+ * 1. `nodes` is already sorted; index by position in it.
+ * 2. `out[i]` is the exact integer sum of node i's out-weights.
+ * 3. Each node's out-edges are visited in sorted TARGET order.
+ * 4. The personalisation vector is `1/len(personal)` on each focus node and 0 elsewhere;
+ *    with no focus it is `1/n` on every node. The INITIAL vector is that same vector.
+ * 5. Per round: zero `next`; walk sources in node order; a node with no out-edges adds its
+ *    whole score to `dangling`; otherwise each out-edge adds `score[i] * weight / out[i]`,
+ *    evaluated strictly left to right.
+ * 6. `tele = damping * dangling + (1.0 - damping)`, then
+ *    `next[i] = next[i] * damping + tele * personal[i]`.
+ * 7. Exactly `iterations` rounds. No early stop, no convergence test — a branch on a float
+ *    is one more thing for a port to get wrong, and the contraction bound (the linear part
+ *    is `damping * column-stochastic`, so the residual after 30 rounds is under
+ *    `2 * 0.2 ** 30` = 2.1e-21) makes the test unnecessary.
+ *
+ * THERE IS NO `reduce` HERE AND THERE MUST NOT BE ONE: every accumulation is a written-out
+ * loop in the same order as CPython's, because CPython's `sum()` is Neumaier-compensated and
+ * nothing in JavaScript is (trap 7). The Python side is held to the same rule by
+ * `test_no_float_summation_or_rounding_in_the_source`, which reads that function's body.
+ */
+export declare function pagerank(nodes: readonly string[], edges: Map<string, Map<string, number>>, personal: readonly string[], damping?: number, iterations?: number): number[];
+/**
+ * Scan `root`, rank its files against `focus`, and render a listing within `budget`.
+ *
+ * `focus` is the current unit's files, relative to `root` and POSIX-separated; a focus entry
+ * that is not a scanned source is ignored for the personalisation vector but is still
+ * excluded from the listing, because a caller naming a file has it open already. An empty
+ * focus gives the uniform vector — plain centrality over the whole tree.
+ *
+ * `budget` is UTF-8 BYTES of the listing. See the header: this runtime has no model
+ * tokenizer and will not pretend to one.
+ */
+export declare function repoMap(root: string, options?: RepoMapOptions): RepoMap;