carrick 0.3.105 → 0.3.107

package/sidecar/dist/src/function-line-index.js

@@ -0,0 +1,162 @@
+/**
+ * The function a line names, from an index built once per source file
+ * (carrick#1915).
+ *
+ * A signature request carries only the line its function starts on, and a
+ * signature pass sends one request per unannotated slot: thousands of
+ * lookups, several per function and many per file. Answering each by walking
+ * the file's every node cost the file's size per slot, and was 81% of the
+ * pass on a 2,345-file program. Here the file is walked once, over the
+ * compiler's own nodes, and each lookup reads the few entries near its line.
+ *
+ * The index belongs to the compiler's source file node, not to the file's
+ * name: replacing a file's text gives it a new node, so a file rewritten for
+ * one reading (the unwidened reading, the retype check) and then restored is
+ * indexed again each time, and never answered from positions it no longer has.
+ */
+import { SyntaxKind, ts, } from 'ts-morph';
+import { lineIndex } from './line-index.js';
+/** How far, in lines, a function may start from the line that names it. */
+const LINE_TOLERANCE = 2;
+const FUNCTION_KINDS = new Set([
+    SyntaxKind.FunctionDeclaration,
+    SyntaxKind.ArrowFunction,
+    SyntaxKind.FunctionExpression,
+    SyntaxKind.MethodDeclaration,
+]);
+/** The kinds ts-morph's `Node.isStatement` accepts. */
+const STATEMENT_KINDS = new Set([
+    SyntaxKind.Block,
+    SyntaxKind.BreakStatement,
+    SyntaxKind.ClassDeclaration,
+    SyntaxKind.ContinueStatement,
+    SyntaxKind.DebuggerStatement,
+    SyntaxKind.DoStatement,
+    SyntaxKind.EmptyStatement,
+    SyntaxKind.EnumDeclaration,
+    SyntaxKind.ExportAssignment,
+    SyntaxKind.ExportDeclaration,
+    SyntaxKind.ExpressionStatement,
+    SyntaxKind.ForInStatement,
+    SyntaxKind.ForOfStatement,
+    SyntaxKind.ForStatement,
+    SyntaxKind.FunctionDeclaration,
+    SyntaxKind.IfStatement,
+    SyntaxKind.ImportDeclaration,
+    SyntaxKind.ImportEqualsDeclaration,
+    SyntaxKind.InterfaceDeclaration,
+    SyntaxKind.LabeledStatement,
+    SyntaxKind.ModuleBlock,
+    SyntaxKind.ModuleDeclaration,
+    SyntaxKind.NotEmittedStatement,
+    SyntaxKind.ReturnStatement,
+    SyntaxKind.SwitchStatement,
+    SyntaxKind.ThrowStatement,
+    SyntaxKind.TryStatement,
+    SyntaxKind.TypeAliasDeclaration,
+    SyntaxKind.VariableStatement,
+    SyntaxKind.WhileStatement,
+    SyntaxKind.WithStatement,
+]);
+const indexes = new WeakMap();
+/**
+ * The function whose declaration starts at, or within `LINE_TOLERANCE` lines
+ * of, the given line: the closest, then the smallest, then the first in the
+ * file. A function starting after the line is passed over when a statement
+ * that opens on the line or after it, on a line before the function's, does
+ * not contain the function. Undefined when no function is left.
+ *
+ * These are `TypeInferrer.findFunctionByLine`'s rules, which says why each is
+ * there; this is where they are computed.
+ */
+export function functionAtLine(sourceFile, line) {
+    if (!Number.isFinite(line))
+        return undefined;
+    const index = indexOf(sourceFile.compilerNode);
+    /** Statements opening inside the forward window. */
+    const windowStatements = [];
+    for (let at = Math.ceil(line); at <= line + LINE_TOLERANCE; at++) {
+        const opening = index.statementsByLine.get(at);
+        if (opening)
+            windowStatements.push(...opening);
+    }
+    const separatedFromAnchor = (fn) => windowStatements.some((statement) => statement.line < fn.line && !(statement.start <= fn.start && statement.end >= fn.end));
+    let best;
+    for (let at = Math.ceil(line - LINE_TOLERANCE); at <= line + LINE_TOLERANCE; at++) {
+        for (const fn of index.functionsByLine.get(at) ?? []) {
+            if (fn.line > line && separatedFromAnchor(fn))
+                continue;
+            if (best === undefined || isBetter(fn, best, line))
+                best = fn;
+        }
+    }
+    return best ? wrapped(sourceFile, best) : undefined;
+}
+/** Closer to the line, then smaller, then earlier in the file. */
+function isBetter(fn, best, line) {
+    const delta = Math.abs(fn.line - line);
+    const bestDelta = Math.abs(best.line - line);
+    if (delta !== bestDelta)
+        return delta < bestDelta;
+    const size = fn.end - fn.start;
+    const bestSize = best.end - best.start;
+    if (size !== bestSize)
+        return size < bestSize;
+    return fn.order < best.order;
+}
+function indexOf(file) {
+    let index = indexes.get(file);
+    if (!index) {
+        index = buildIndex(file);
+        indexes.set(file, index);
+    }
+    return index;
+}
+function buildIndex(file) {
+    // Lines as ts-morph's `getStartLineNumber` counts them, which is what the
+    // scanner's line numbers were matched against.
+    const lineAt = lineIndex(file.text);
+    const functionsByLine = new Map();
+    const statementsByLine = new Map();
+    let order = 0;
+    const visit = (node) => {
+        const isFunction = FUNCTION_KINDS.has(node.kind);
+        const isStatement = STATEMENT_KINDS.has(node.kind);
+        if (isFunction || isStatement) {
+            const start = node.getStart(file);
+            const extent = { start, end: node.end, line: lineAt(start) };
+            if (isFunction) {
+                pushAt(functionsByLine, extent.line, { ...extent, node, order: order++ });
+            }
+            if (isStatement) {
+                pushAt(statementsByLine, extent.line, extent);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(file, visit);
+    return { functionsByLine, statementsByLine };
+}
+function pushAt(byLine, line, entry) {
+    const entries = byLine.get(line);
+    if (entries)
+        entries.push(entry);
+    else
+        byLine.set(line, [entry]);
+}
+/**
+ * The ts-morph node for an indexed function. Only this one is wrapped: the
+ * deepest node at the function's first character is the function or sits
+ * inside it, so its ancestors lead there, and the rest of the file's nodes are
+ * never given wrappers they would keep for the life of the project.
+ */
+function wrapped(sourceFile, fn) {
+    let node = sourceFile.getDescendantAtPos(fn.start);
+    while (node && node.compilerNode !== fn.node) {
+        node = node.getParent();
+    }
+    // An invariant, not a case: no shape is known where the climb misses. If
+    // one exists, the answer is still the function the index chose.
+    node ??= sourceFile.getFirstDescendant((descendant) => descendant.compilerNode === fn.node);
+    return node;
+}

package/sidecar/dist/src/index.d.ts

@@ -10,5 +10,10 @@
  * - stdout is ONLY for JSON responses
  * - stderr is for logging
  * - Process stays alive between requests (warm standby)
+ * - One request at a time. A handler that runs the compiler blocks the event
+ *   loop until it returns, so a request sent meanwhile waits in the pipe, and
+ *   nothing can cancel the one that is running. The scanner kills a process
+ *   that goes silent past its deadline; a long handler stays alive by writing
+ *   `progress` frames as it finishes units of work (writeProgress).
  */
 export {};

package/sidecar/dist/src/index.js

@@ -10,6 +10,11 @@
  * - stdout is ONLY for JSON responses
  * - stderr is for logging
  * - Process stays alive between requests (warm standby)
+ * - One request at a time. A handler that runs the compiler blocks the event
+ *   loop until it returns, so a request sent meanwhile waits in the pipe, and
+ *   nothing can cancel the one that is running. The scanner kills a process
+ *   that goes silent past its deadline; a long handler stays alive by writing
+ *   `progress` frames as it finishes units of work (writeProgress).
  */
 import * as path from 'node:path';
 import * as readline from 'node:readline';
@@ -21,6 +26,7 @@ import { DefinitionResolver } from './definition-resolver.js';
 import { captureStub, findDisqualifyingTopTypes, jsonWireDeclarations, runCheck, } from './capture/index.js';
 import { Retyper } from './retype.js';
 import { LibraryClaimsVerifier, httpCheck } from './library-claims.js';
+import { PROGRESS_INTERVAL_MS, atMostEvery } from './progress.js';
 // ===========================================================================
 // Module-level state
 // ===========================================================================
@@ -168,7 +174,11 @@ function handleBundle(request) {
         log(`Bundling ${request.symbols.length} symbol(s)`);
         // A symbol named by a path is bundled from the program of the project
         // that owns that file (carrick#1604).
-        const results = [...byProject(request.symbols, (symbol) => symbol.source_file)].map(([key, symbols]) => projectComponents(key).typeBundler.bundle(symbols));
+        const results = [...byProject(request.symbols, (symbol) => symbol.source_file)].map(([key, symbols]) => {
+            const { typeBundler } = projectComponents(key);
+            writeProgress(request.request_id, 'bundle', 'program ready');
+            return typeBundler.bundle(symbols);
+        });
         const result = results.length === 1 ? results[0] : mergeBundles(results);
         if (!result.success) {
             return {
@@ -284,7 +294,13 @@ async function handleCheckV2Async(request) {
 function handleInfer(request) {
     try {
         log(`Inferring ${request.requests.length} type(s)`);
-        const results = [...byProject(request.requests, (item) => item.file_path)].map(([key, items]) => projectComponents(key).typeInferrer.infer(items, request.extraction_config));
+        // One count for the request, whichever programs its items span.
+        let done = 0;
+        const report = atMostEvery(PROGRESS_INTERVAL_MS, () => writeProgress(request.request_id, 'infer', `${done} of ${request.requests.length}`));
+        const results = [...byProject(request.requests, (item) => item.file_path)].map(([key, items]) => projectComponents(key).typeInferrer.infer(items, request.extraction_config, () => {
+            done += 1;
+            report();
+        }));
         const result = results.length === 1
             ? results[0]
             : (() => {
@@ -388,6 +404,8 @@ function handleVerifyLibraryClaims(request) {
     const started = performance.now();
     try {
         const { claimsVerifier } = projectComponents();
+        // The verifier's budget starts now, and so does the scanner's wait.
+        writeProgress(request.request_id, 'verify_library_claims', 'program ready');
         const fromDir = path.resolve(projectLoader.getRepoRoot(), request.from_dir);
         log(`Verifying ${request.checks.length} library claim(s) from ${fromDir}`);
         const { semantics, modules } = claimsVerifier.run(fromDir, request.checks, request.budget_ms ?? SEMANTICS_BUDGET_MS);
@@ -530,9 +548,15 @@ function writeResponse(response) {
     process.stdout.write(json + '\n');
 }
 /**
- * Write a non-terminal progress/keepalive frame (async install protocol).
- * Distinct `status: 'progress'` so clients skip it and wait for the terminal
- * success/error frame.
+ * Write a non-terminal progress frame. Distinct `status: 'progress'` so
+ * clients skip it and wait for the terminal success/error frame; the scanner
+ * restarts its deadline for the request on each one (carrick#1914).
+ *
+ * A synchronous handler calls this between units of its work, with the event
+ * loop blocked. The frame still leaves at once: a write this small to a pipe
+ * with room in it completes inside the call, and the reader on the other end
+ * drains the pipe on its own thread, so there is room. It is written through
+ * the same stream as every answer, so a frame can never land inside one.
  */
 function writeProgress(requestId, phase, message) {
     process.stdout.write(JSON.stringify({ request_id: requestId, status: 'progress', phase, message }) + '\n');

package/sidecar/dist/src/line-index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The 1-based line of a position in a text, counted by line feeds alone: one
+ * more than the `\n`s before the position. That is the count ts-morph's
+ * `getStartLineNumber` makes. A lone carriage return or a Unicode line
+ * separator ends a line for the compiler and not here.
+ *
+ * The text is read once; each lookup after that is a binary search.
+ */
+export declare function lineIndex(text: string): (pos: number) => number;

package/sidecar/dist/src/line-index.js

@@ -0,0 +1,26 @@
+/**
+ * The 1-based line of a position in a text, counted by line feeds alone: one
+ * more than the `\n`s before the position. That is the count ts-morph's
+ * `getStartLineNumber` makes. A lone carriage return or a Unicode line
+ * separator ends a line for the compiler and not here.
+ *
+ * The text is read once; each lookup after that is a binary search.
+ */
+export function lineIndex(text) {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++)
+        if (text[i] === '\n')
+            starts.push(i + 1);
+    return (pos) => {
+        let lo = 0;
+        let hi = starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (starts[mid] <= pos)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo + 1;
+    };
+}

package/sidecar/dist/src/printed-names.d.ts

@@ -0,0 +1,43 @@
+/**
+ * carrick#1836: what each bare name in an inference's printed text meant.
+ *
+ * The structural printer (`type-structural-expander.ts`) hands some subtrees
+ * back to the compiler's own print with no enclosing declaration, and that
+ * print writes every named type by its bare name: a database client's row,
+ * which is a library's mapped type, prints `{ status: EntityStatus; ... }`.
+ * The file a request names often never imports `EntityStatus`, so the text
+ * names nothing where it is read (TS2304), and the member reads `any` in the
+ * capture's surface.
+ *
+ * The compiler knew the symbol when it printed the name, and only then. So
+ * every type print made while an inference runs is noted (`notePrintedType`),
+ * and when it ends (`PrintedTypes.namesIn`) the names its text prints that the
+ * request's file cannot resolve are looked up in those prints: the node
+ * builder gives each name it writes the symbol it wrote it for. Each such
+ * symbol is recorded as the module that declares it and its export path
+ * there. A name printed for two declarations is recorded twice, and the
+ * reader of the record decides what an ambiguous name means.
+ *
+ * Only the prints whose text writes such a name are read back, and only when
+ * the inference's text has one, so an inference whose names all resolve costs
+ * no more than keeping the list.
+ */
+import { ts, type Node, type Type } from 'ts-morph';
+import type { PrintedName } from './types.js';
+/**
+ * Note a type the compiler printed as `text`, so the inference running now can
+ * tell what the names in that print meant. Does nothing outside a recording.
+ */
+export declare function notePrintedType(type: Type, enclosing: Node | undefined, text: string): void;
+/** The type prints one inference made. */
+export declare class PrintedTypes {
+    private readonly prints;
+    /** Run `read`, noting every type it prints. */
+    during<T>(read: () => T): T;
+    /**
+     * The declarations behind each name `texts` print that `source` does not
+     * resolve, sorted, one entry per distinct declaration. `checker` must be
+     * the one the prints were made with: call this before the program changes.
+     */
+    namesIn(texts: readonly string[], source: ts.SourceFile, checker: ts.TypeChecker): PrintedName[];
+}

package/sidecar/dist/src/printed-names.js

@@ -0,0 +1,186 @@
+/**
+ * carrick#1836: what each bare name in an inference's printed text meant.
+ *
+ * The structural printer (`type-structural-expander.ts`) hands some subtrees
+ * back to the compiler's own print with no enclosing declaration, and that
+ * print writes every named type by its bare name: a database client's row,
+ * which is a library's mapped type, prints `{ status: EntityStatus; ... }`.
+ * The file a request names often never imports `EntityStatus`, so the text
+ * names nothing where it is read (TS2304), and the member reads `any` in the
+ * capture's surface.
+ *
+ * The compiler knew the symbol when it printed the name, and only then. So
+ * every type print made while an inference runs is noted (`notePrintedType`),
+ * and when it ends (`PrintedTypes.namesIn`) the names its text prints that the
+ * request's file cannot resolve are looked up in those prints: the node
+ * builder gives each name it writes the symbol it wrote it for. Each such
+ * symbol is recorded as the module that declares it and its export path
+ * there. A name printed for two declarations is recorded twice, and the
+ * reader of the record decides what an ambiguous name means.
+ *
+ * Only the prints whose text writes such a name are read back, and only when
+ * the inference's text has one, so an inference whose names all resolve costs
+ * no more than keeping the list.
+ */
+import { ts } from 'ts-morph';
+/** The prints of the inference running now, when one is recording. */
+let recording;
+/**
+ * Note a type the compiler printed as `text`, so the inference running now can
+ * tell what the names in that print meant. Does nothing outside a recording.
+ */
+export function notePrintedType(type, enclosing, text) {
+    recording?.push({ type: type.compilerType, enclosing: enclosing?.compilerNode, text });
+}
+/**
+ * Same flags the printers pass `typeToString` (`NoTruncation`, `InTypeAlias`),
+ * so the node read back is the one that was printed.
+ */
+const NODE_FLAGS = ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.InTypeAlias | ts.NodeBuilderFlags.IgnoreErrors;
+const REFERENCE_MEANING = ts.SymbolFlags.Type | ts.SymbolFlags.Namespace | ts.SymbolFlags.Alias;
+/** The type prints one inference made. */
+export class PrintedTypes {
+    prints = [];
+    /** Run `read`, noting every type it prints. */
+    during(read) {
+        const outer = recording;
+        recording = this.prints;
+        try {
+            return read();
+        }
+        finally {
+            recording = outer;
+        }
+    }
+    /**
+     * The declarations behind each name `texts` print that `source` does not
+     * resolve, sorted, one entry per distinct declaration. `checker` must be
+     * the one the prints were made with: call this before the program changes.
+     */
+    namesIn(texts, source, checker) {
+        const wanted = new Set();
+        for (const text of texts) {
+            for (const name of referencedNames(text)) {
+                if (!checker.resolveName(name, source, REFERENCE_MEANING, false))
+                    wanted.add(name);
+            }
+        }
+        if (wanted.size === 0)
+            return [];
+        // Only a print whose text writes one of the names can say what it meant.
+        const alternatives = [...wanted].map((name) => name.replace(/\$/g, '\\$')).join('|');
+        const writes = new RegExp(`(?<![\\w$.])(?:${alternatives})(?![\\w$])`);
+        const found = new Map();
+        const identities = new Map();
+        const visited = new Map();
+        for (const { type, enclosing, text } of this.prints) {
+            if (!writes.test(text))
+                continue;
+            const at = visited.get(type) ?? new Set();
+            if (at.has(enclosing))
+                continue;
+            visited.set(type, at.add(enclosing));
+            let node;
+            try {
+                node = checker.typeToTypeNode(type, enclosing, NODE_FLAGS);
+            }
+            catch {
+                continue;
+            }
+            const visit = (current) => {
+                if (ts.isTypeReferenceNode(current)) {
+                    const id = leftmost(current.typeName);
+                    const name = ts.idText(id);
+                    const symbol = wanted.has(name) ? symbolOf(id, checker) : undefined;
+                    if (symbol) {
+                        if (!identities.has(symbol))
+                            identities.set(symbol, identityOf(symbol, checker));
+                        const identity = identities.get(symbol);
+                        if (identity) {
+                            found.set(`${name}\0${identity.file}\0${identity.export_path.join('.')}`, { name, ...identity });
+                        }
+                    }
+                }
+                ts.forEachChild(current, visit);
+            };
+            if (node)
+                visit(node);
+        }
+        return [...found.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([, entry]) => entry);
+    }
+}
+function leftmost(name) {
+    return ts.isIdentifier(name) ? name : leftmost(name.left);
+}
+/**
+ * The leftmost names of the type references `text` makes, less the type
+ * parameters the text declares itself (`[K in ...]`, `infer U`).
+ */
+function referencedNames(text) {
+    const parsed = ts.createSourceFile('printed.ts', `type __Printed = ${text};`, ts.ScriptTarget.Latest, true);
+    const names = new Set();
+    const declared = new Set();
+    const visit = (node) => {
+        if (ts.isTypeParameterDeclaration(node))
+            declared.add(node.name.text);
+        if (ts.isTypeReferenceNode(node))
+            names.add(ts.idText(leftmost(node.typeName)));
+        ts.forEachChild(node, visit);
+    };
+    visit(parsed);
+    for (const name of declared)
+        names.delete(name);
+    names.delete('__Printed');
+    return names;
+}
+/**
+ * The symbol a printed name was written for. The node builder sets it on
+ * every identifier it creates (`symbol` is not in the public typings); a name
+ * it copied from source carries none, and is read at its original node.
+ */
+function symbolOf(id, checker) {
+    const written = id.symbol;
+    if (written)
+        return written;
+    const original = ts.getOriginalNode(id);
+    return original !== id && original.parent ? checker.getSymbolAtLocation(original) : undefined;
+}
+/**
+ * The module that declares `symbol`'s type and the export path to it there,
+ * or undefined for a type no module export reaches: a global, a type
+ * parameter, a declaration a function body holds, a module itself.
+ */
+function identityOf(symbol, checker) {
+    const resolve = (s) => s.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(s) : s;
+    const target = resolve(symbol);
+    if (!(target.flags & (ts.SymbolFlags.Type | ts.SymbolFlags.Namespace)) ||
+        target.flags & ts.SymbolFlags.TypeParameter) {
+        return undefined;
+    }
+    const declaration = target.declarations?.[0];
+    if (!declaration || ts.isSourceFile(declaration))
+        return undefined;
+    const file = declaration.getSourceFile();
+    const moduleSymbol = checker.getSymbolAtLocation(file);
+    if (!moduleSymbol)
+        return undefined;
+    const direct = checker.getExportsOfModule(moduleSymbol).filter((e) => resolve(e) === target);
+    if (direct.length > 0) {
+        const chosen = direct.find((e) => e.getName() === target.getName()) ?? direct[0];
+        return { file: file.fileName, export_path: [chosen.getName()] };
+    }
+    // A namespace member: `"<module>".Billing.Kind`, checked step by step.
+    const qualified = checker.getFullyQualifiedName(target);
+    const close = qualified.startsWith('"') ? qualified.indexOf('"', 1) : -1;
+    if (close < 0)
+        return undefined;
+    const exportPath = qualified.slice(close + 2).split('.');
+    let current = moduleSymbol;
+    for (const part of exportPath) {
+        const next = current
+            ? checker.getExportsOfModule(current).find((e) => e.getName() === part)
+            : undefined;
+        current = next && resolve(next);
+    }
+    return current === target ? { file: file.fileName, export_path: exportPath } : undefined;
+}

package/sidecar/dist/src/progress.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pacing for the `progress` frames a long request writes (carrick#1914).
+ */
+/**
+ * The least time between two progress frames of one request.
+ *
+ * The scanner's deadline for a request is how long the sidecar may stay
+ * silent about it, so a frame has to say that a unit of work finished, and
+ * has to be far more frequent than that deadline. It does not have to follow
+ * every unit: a batch can finish thousands in a second.
+ */
+export declare const PROGRESS_INTERVAL_MS = 1500;
+/**
+ * `report`, held to one call per `intervalMs`: the first call goes through at
+ * once, and a call made sooner than `intervalMs` after the last one that went
+ * through is dropped.
+ *
+ * It is called by the work, between units, and never by a timer. A handler
+ * that stops finishing units stops reporting, which is what the reader on the
+ * other end is waiting to notice.
+ */
+export declare function atMostEvery<Args extends unknown[]>(intervalMs: number, report: (...args: Args) => void, now?: () => number): (...args: Args) => void;

package/sidecar/dist/src/progress.js

@@ -0,0 +1,31 @@
+/**
+ * Pacing for the `progress` frames a long request writes (carrick#1914).
+ */
+/**
+ * The least time between two progress frames of one request.
+ *
+ * The scanner's deadline for a request is how long the sidecar may stay
+ * silent about it, so a frame has to say that a unit of work finished, and
+ * has to be far more frequent than that deadline. It does not have to follow
+ * every unit: a batch can finish thousands in a second.
+ */
+export const PROGRESS_INTERVAL_MS = 1500;
+/**
+ * `report`, held to one call per `intervalMs`: the first call goes through at
+ * once, and a call made sooner than `intervalMs` after the last one that went
+ * through is dropped.
+ *
+ * It is called by the work, between units, and never by a timer. A handler
+ * that stops finishing units stops reporting, which is what the reader on the
+ * other end is waiting to notice.
+ */
+export function atMostEvery(intervalMs, report, now = () => performance.now()) {
+    let last = Number.NEGATIVE_INFINITY;
+    return (...args) => {
+        const at = now();
+        if (at - last < intervalMs)
+            return;
+        last = at;
+        report(...args);
+    };
+}