@otto-code/brain 0.7.5

package/dist/models/pick.js

@@ -0,0 +1,36 @@
+/**
+ * Resolve a model from an exact catalog id or a unique case-insensitive name
+ * fragment. An ambiguous fragment is an error that lists the matches — ported
+ * from the original CLI's pickModel, but throwing a CommandError instead of
+ * calling process.exit, so the output layer renders it.
+ */
+import { CommandError } from "../output/types.js";
+export function pickModel(catalog, needle) {
+    if (!needle) {
+        throw new CommandError({
+            code: "NO_MODEL",
+            message: "specify a model with --model <name fragment>",
+        });
+    }
+    const exact = catalog.find((m) => m.id === needle);
+    if (exact)
+        return exact;
+    const lower = String(needle).toLowerCase();
+    const matches = catalog.filter((m) => m.displayName.toLowerCase().includes(lower) || m.id.toLowerCase().includes(lower));
+    if (!matches.length) {
+        throw new CommandError({
+            code: "NO_MATCH",
+            message: `no model matches "${needle}"`,
+            details: "run `otto brain scan` to list them",
+        });
+    }
+    if (matches.length > 1) {
+        throw new CommandError({
+            code: "AMBIGUOUS_MODEL",
+            message: `"${needle}" matches ${matches.length} models`,
+            details: matches.map((m) => m.displayName).join(", "),
+        });
+    }
+    return matches[0];
+}
+//# sourceMappingURL=pick.js.map

package/dist/models/scan.d.ts

@@ -0,0 +1,13 @@
+import type { Model } from "../types.js";
+export declare const LMSTUDIO_MODELS_DIR: string;
+export declare function detectQuant(filename: string): string | null;
+export declare function isProjectorFile(filename: string): boolean;
+export interface ScanOptions {
+    modelsDir?: string;
+    withMetadata?: boolean;
+    origin?: "managed" | "lmstudio";
+}
+export declare function scan({ modelsDir, withMetadata, origin, }?: ScanOptions): Model[];
+/** Human-readable size. */
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=scan.d.ts.map

package/dist/models/scan.js

@@ -0,0 +1,185 @@
+/**
+ * Build a catalog of hostable models from disk. Weight files and their vision
+ * projectors live side by side in the same directory, so a projector found next
+ * to a model is paired with it. Ported from the original models.js; the models
+ * directory is now configurable (managed dir ∪ LM Studio) instead of hardcoded.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import * as gguf from "../gguf.js";
+export const LMSTUDIO_MODELS_DIR = path.join(os.homedir(), ".lmstudio", "models");
+// Quantisation labels as they appear in filenames, longest first so that
+// Q4_K_M wins over Q4_K.
+const QUANT_PATTERNS = [
+    "IQ1_S",
+    "IQ1_M",
+    "IQ2_XXS",
+    "IQ2_XS",
+    "IQ2_S",
+    "IQ2_M",
+    "IQ3_XXS",
+    "IQ3_XS",
+    "IQ3_S",
+    "IQ3_M",
+    "IQ4_XS",
+    "IQ4_NL",
+    "Q2_K_S",
+    "Q2_K",
+    "Q3_K_S",
+    "Q3_K_M",
+    "Q3_K_L",
+    "Q4_K_S",
+    "Q4_K_M",
+    "Q5_K_S",
+    "Q5_K_M",
+    "Q6_K",
+    "Q8_0",
+    "Q4_0",
+    "Q4_1",
+    "Q5_0",
+    "Q5_1",
+    "NVFP4",
+    "MXFP4",
+    "BF16",
+    "F16",
+    "F32",
+];
+const MULTIPART = /-(\d{5})-of-(\d{5})\.gguf$/i;
+function walk(dir, out = []) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            walk(full, out);
+        else if (entry.isFile() && entry.name.toLowerCase().endsWith(".gguf"))
+            out.push(full);
+    }
+    return out;
+}
+export function detectQuant(filename) {
+    const upper = filename.toUpperCase();
+    for (const pattern of QUANT_PATTERNS) {
+        if (upper.includes(pattern))
+            return pattern;
+    }
+    return null;
+}
+export function isProjectorFile(filename) {
+    return /^mmproj/i.test(path.basename(filename));
+}
+/** Feature flags inferred from the filename, since these are community builds. */
+function detectFeatures(filename) {
+    const upper = path.basename(filename).toUpperCase();
+    return {
+        mtp: /\bMTP\b/.test(upper) || upper.includes("-MTP"),
+        imatrix: upper.includes("IMATRIX"),
+        distilled: upper.includes("DISTILL"),
+    };
+}
+export function scan({ modelsDir = LMSTUDIO_MODELS_DIR, withMetadata = true, origin, } = {}) {
+    const files = walk(modelsDir);
+    const projectorsByDir = new Map();
+    const weightFiles = [];
+    for (const file of files) {
+        if (isProjectorFile(file)) {
+            const dir = path.dirname(file);
+            // Prefer the largest projector if a repo ships several precisions.
+            const existing = projectorsByDir.get(dir);
+            const size = fs.statSync(file).size;
+            if (!existing || size > existing.size)
+                projectorsByDir.set(dir, { file, size });
+            continue;
+        }
+        const parts = file.match(MULTIPART);
+        // For sharded models only the first shard is passed to llama-server.
+        if (parts && parts[1] !== "00001")
+            continue;
+        weightFiles.push(file);
+    }
+    const models = [];
+    for (const file of weightFiles) {
+        const dir = path.dirname(file);
+        const stat = fs.statSync(file);
+        let sizeBytes = stat.size;
+        // Sum shards so the VRAM estimate reflects the whole model.
+        const shard = file.match(MULTIPART);
+        if (shard) {
+            const total = Number(shard[2]);
+            const base = file.replace(MULTIPART, "");
+            for (let i = 2; i <= total; i += 1) {
+                const part = `${base}-${String(i).padStart(5, "0")}-of-${shard[2]}.gguf`;
+                try {
+                    sizeBytes += fs.statSync(part).size;
+                }
+                catch {
+                    /* missing shard: reported by validate() */
+                }
+            }
+        }
+        const projector = projectorsByDir.get(dir) || null;
+        const entry = {
+            id: path.relative(modelsDir, file).replace(/\\/g, "/"),
+            displayName: path.basename(file, ".gguf"),
+            publisher: path.relative(modelsDir, dir).split(path.sep)[0] || null,
+            dir,
+            modelPath: file,
+            sizeBytes,
+            sharded: Boolean(shard),
+            quant: detectQuant(path.basename(file)),
+            features: detectFeatures(file),
+            mmprojPath: projector ? projector.file : null,
+            mmprojBytes: projector ? projector.size : 0,
+            metadata: null,
+            metadataError: null,
+            origin,
+        };
+        if (withMetadata) {
+            try {
+                entry.metadata = gguf.summarize(file);
+            }
+            catch (error) {
+                entry.metadataError = error instanceof Error ? error.message : String(error);
+            }
+        }
+        models.push(entry);
+    }
+    models.sort((a, b) => a.displayName.localeCompare(b.displayName));
+    qualifyDuplicateNames(models);
+    return models;
+}
+/**
+ * Several publishers ship identically-named quants; qualify the duplicates so the
+ * picker never shows two indistinguishable rows.
+ */
+function qualifyDuplicateNames(models) {
+    const byName = new Map();
+    for (const model of models) {
+        const list = byName.get(model.displayName) || [];
+        list.push(model);
+        byName.set(model.displayName, list);
+    }
+    for (const [, group] of byName) {
+        if (group.length < 2)
+            continue;
+        for (const model of group) {
+            if (model.publisher)
+                model.displayName = `${model.displayName} (${model.publisher})`;
+        }
+    }
+}
+/** Human-readable size. */
+export function formatBytes(bytes) {
+    if (!bytes)
+        return "0";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+    return `${(bytes / 1024 ** i).toFixed(i >= 3 ? 2 : 0)} ${units[i]}`;
+}
+//# sourceMappingURL=scan.js.map

package/dist/ops/archive.d.ts

@@ -0,0 +1,34 @@
+import type { Model } from "../types.js";
+declare const ARCHIVE_DIR: string;
+/** One archived request/response exchange. */
+export interface TranscriptEntry {
+    taskId: string;
+    label: string | null;
+    at: string;
+    meta: Record<string, unknown>;
+    request: unknown;
+    response: unknown;
+}
+/** Arguments to `put`: one exchange to archive. */
+export interface PutOptions {
+    label?: string;
+    request: unknown;
+    response: unknown;
+    meta?: Record<string, unknown>;
+}
+declare function runId(model: Model | null, timestamp?: Date): string;
+/** Where a run's transcripts live. */
+declare function runDir(id: string): string;
+/**
+ * Record one exchange. `request` and `response` are stored verbatim so a future
+ * scorer sees exactly what the model saw and said.
+ */
+declare function put(id: string, taskId: string, { label, request, response, meta }: PutOptions): string;
+/** Every transcript for a run, grouped by task id. */
+declare function load(id: string): Record<string, TranscriptEntry[]>;
+/** All archived run ids, newest first. */
+declare function list(): string[];
+/** Total bytes held, so the archive can be pruned knowingly. */
+declare function size(): number;
+export { ARCHIVE_DIR, runId, runDir, put, load, list, size };
+//# sourceMappingURL=archive.d.ts.map

package/dist/ops/archive.js

@@ -0,0 +1,105 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+/**
+ * Raw model output archive.
+ *
+ * Scoring is a separate, replayable pass over stored transcripts rather than
+ * something that only happens live. This exists because a bug in the scorer
+ * (a filename matcher that attributed every test block to the wrong file) made
+ * seven models look identical, and fixing it cost a full re-run on the GPU. The
+ * model outputs had been correct all along - only the grading was wrong.
+ *
+ * With the transcript on disk, a scorer fix re-grades history in seconds.
+ */
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(HERE, "..", "..");
+const ARCHIVE_DIR = path.join(ROOT, "results", "transcripts");
+function runId(model, timestamp = new Date()) {
+    const stamp = timestamp.toISOString().replace(/[:.]/g, "-");
+    const slug = String(model?.displayName || "unknown")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "")
+        .slice(0, 60);
+    return `${stamp}_${slug}`;
+}
+/** Where a run's transcripts live. */
+function runDir(id) {
+    return path.join(ARCHIVE_DIR, id);
+}
+/**
+ * Record one exchange. `request` and `response` are stored verbatim so a future
+ * scorer sees exactly what the model saw and said.
+ */
+function put(id, taskId, { label, request, response, meta = {} }) {
+    const dir = runDir(id);
+    fs.mkdirSync(dir, { recursive: true });
+    const key = crypto
+        .createHash("sha1")
+        .update(`${taskId}:${label || ""}:${JSON.stringify(meta)}`)
+        .digest("hex")
+        .slice(0, 8);
+    const file = path.join(dir, `${taskId.replace(/[^\w.-]/g, "_")}.${key}.json`);
+    fs.writeFileSync(file, `${JSON.stringify({
+        taskId,
+        label: label || null,
+        at: new Date().toISOString(),
+        meta,
+        request,
+        response,
+    }, null, 2)}\n`);
+    return file;
+}
+/** Every transcript for a run, grouped by task id. */
+function load(id) {
+    const dir = runDir(id);
+    if (!fs.existsSync(dir))
+        return {};
+    const byTask = {};
+    for (const name of fs.readdirSync(dir)) {
+        if (!name.endsWith(".json"))
+            continue;
+        try {
+            const entry = JSON.parse(fs.readFileSync(path.join(dir, name), "utf8"));
+            if (!byTask[entry.taskId])
+                byTask[entry.taskId] = [];
+            byTask[entry.taskId].push(entry);
+        }
+        catch {
+            /* skip an unreadable transcript rather than failing the whole load */
+        }
+    }
+    for (const list of Object.values(byTask))
+        list.sort((a, b) => (a.at < b.at ? -1 : 1));
+    return byTask;
+}
+/** All archived run ids, newest first. */
+function list() {
+    if (!fs.existsSync(ARCHIVE_DIR))
+        return [];
+    return fs
+        .readdirSync(ARCHIVE_DIR)
+        .filter((name) => fs.statSync(path.join(ARCHIVE_DIR, name)).isDirectory())
+        .sort()
+        .reverse();
+}
+/** Total bytes held, so the archive can be pruned knowingly. */
+function size() {
+    let bytes = 0;
+    for (const id of list()) {
+        const dir = runDir(id);
+        for (const name of fs.readdirSync(dir)) {
+            try {
+                bytes += fs.statSync(path.join(dir, name)).size;
+            }
+            catch {
+                /* gone */
+            }
+        }
+    }
+    return bytes;
+}
+export { ARCHIVE_DIR, runId, runDir, put, load, list, size };
+//# sourceMappingURL=archive.js.map

package/dist/ops/calibrate.d.ts

@@ -0,0 +1,49 @@
+import type { Model, Runtime } from "../types.js";
+import type { Profile } from "../config/schema.js";
+/**
+ * Measure a model's real KV-cache cost per token.
+ *
+ * The theoretical formula (layers x kv_heads x dims x bytes) overestimates
+ * badly on architectures that only keep a full cache on some layers - by ~4x
+ * on `qwen35`. So we load the model twice at two context sizes and take the
+ * slope: bytes/token = (vram_b - vram_a) / (ctx_b - ctx_a). Everything that
+ * does not scale with context (weights, projector, CUDA context, compute
+ * buffers) cancels out of the difference.
+ */
+export declare const DEFAULT_SAMPLES: number[];
+/** A single context-size measurement collected during calibration. */
+export interface CalibrationSample {
+    contextSize: number;
+    deltaBytes: number;
+    loadSeconds: number | null;
+}
+/** Progress event emitted while calibrating. */
+export interface CalibrateProgress {
+    phase: "skip" | "loading" | "measured" | "failed";
+    contextSize: number;
+    reason?: string;
+    deltaBytes?: number;
+    error?: string;
+}
+export interface CalibrateOptions {
+    runtime: Runtime;
+    model: Model;
+    profile: Profile;
+    samples?: number[];
+    internalPort?: number;
+    onProgress?: (event: CalibrateProgress) => void;
+}
+/** The measured KV-cache profile calibration produces. */
+export interface CalibrationMeasurement {
+    kvBytesPerToken: number;
+    baseOverheadBytes: number;
+    theoreticalKvBytesPerToken: number | null;
+    theoreticalRatio: number | null;
+    samples: CalibrationSample[];
+    cacheTypeK: string;
+    cacheTypeV: string;
+    vision: boolean;
+    measuredAt: string;
+}
+export declare function calibrate({ runtime, model, profile, samples, internalPort, onProgress, }: CalibrateOptions): Promise<CalibrationMeasurement>;
+//# sourceMappingURL=calibrate.d.ts.map

package/dist/ops/calibrate.js

@@ -0,0 +1,74 @@
+import { usedBytes } from "../gpu.js";
+import * as vram from "../vram.js";
+import { DEFAULT_INTERNAL_PORT, Supervisor } from "../service/supervisor.js";
+/**
+ * Measure a model's real KV-cache cost per token.
+ *
+ * The theoretical formula (layers x kv_heads x dims x bytes) overestimates
+ * badly on architectures that only keep a full cache on some layers - by ~4x
+ * on `qwen35`. So we load the model twice at two context sizes and take the
+ * slope: bytes/token = (vram_b - vram_a) / (ctx_b - ctx_a). Everything that
+ * does not scale with context (weights, projector, CUDA context, compute
+ * buffers) cancels out of the difference.
+ */
+export const DEFAULT_SAMPLES = [8192, 65536];
+export async function calibrate({ runtime, model, profile, samples = DEFAULT_SAMPLES, internalPort = DEFAULT_INTERNAL_PORT + 1, onProgress = () => { }, }) {
+    if (samples.length < 2)
+        throw new Error("calibration needs at least two context sizes");
+    const native = model.metadata?.contextLength || Math.max(...samples);
+    const points = [];
+    for (const contextSize of samples) {
+        if (contextSize > native) {
+            onProgress({ phase: "skip", contextSize, reason: `exceeds native context ${native}` });
+            continue;
+        }
+        const supervisor = new Supervisor({ runtime, internalPort });
+        onProgress({ phase: "loading", contextSize });
+        const baseline = await usedBytes();
+        try {
+            await supervisor.start(model, { ...profile, contextSize });
+            const used = supervisor.vramAtReadyBytes ?? (await usedBytes());
+            const delta = Number(used) - Number(supervisor.vramBaselineBytes ?? baseline);
+            points.push({ contextSize, deltaBytes: delta, loadSeconds: supervisor.loadSeconds });
+            onProgress({ phase: "measured", contextSize, deltaBytes: delta });
+        }
+        catch (error) {
+            onProgress({
+                phase: "failed",
+                contextSize,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+        finally {
+            await supervisor.stop();
+            // Let the driver actually release the allocation before the next sample.
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+        }
+    }
+    if (points.length < 2) {
+        throw new Error("calibration produced fewer than two usable samples");
+    }
+    points.sort((a, b) => a.contextSize - b.contextSize);
+    const low = points[0];
+    const high = points[points.length - 1];
+    const kvBytesPerToken = (high.deltaBytes - low.deltaBytes) / (high.contextSize - low.contextSize);
+    if (!(kvBytesPerToken > 0)) {
+        throw new Error("measured a non-positive bytes-per-token; results are unusable");
+    }
+    const fixedBytes = model.sizeBytes + (profile.vision && model.mmprojPath ? model.mmprojBytes : 0);
+    const baseOverheadBytes = Math.max(0, low.deltaBytes - fixedBytes - kvBytesPerToken * low.contextSize);
+    const theoretical = vram.theoreticalKvBytesPerToken(model.metadata, profile.cacheTypeK, profile.cacheTypeV);
+    return {
+        kvBytesPerToken,
+        baseOverheadBytes,
+        theoreticalKvBytesPerToken: theoretical,
+        theoreticalRatio: theoretical ? theoretical / kvBytesPerToken : null,
+        samples: points,
+        cacheTypeK: profile.cacheTypeK,
+        cacheTypeV: profile.cacheTypeV,
+        vision: Boolean(profile.vision && model.mmprojPath),
+        measuredAt: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=calibrate.js.map

package/dist/ops/report.d.ts

@@ -0,0 +1,26 @@
+import type { RunRecord } from "./results.js";
+/**
+ * Renders stored benchmark runs as a self-contained HTML report.
+ *
+ * No external assets: a strict CSP environment must be able to open the file
+ * offline, so every chart is inline SVG generated here and all CSS is local.
+ *
+ * Colour roles come from a validated categorical palette (four slots, checked
+ * for CVD separation and lightness band in both light and dark surfaces). Three
+ * light-mode slots fall below 3:1 against the light surface, so the relief rule
+ * applies: every bar carries a visible direct label and a full table view ships
+ * alongside the charts. Identity is never colour alone.
+ */
+declare const SERIES: {
+    light: string;
+    dark: string;
+}[];
+declare function build(records: RunRecord[], allRuns?: RunRecord[]): string;
+declare const STYLE = "\n<style>\n.viz-root{\n  color-scheme:light;\n  --surface-1:#fcfcfb; --plane:#f9f9f7;\n  --text-primary:#0b0b0b; --text-secondary:#52514e; --muted:#898781;\n  --grid:#e1e0d9; --axis:#c3c2b7; --border:rgba(11,11,11,0.10);\n  --series-1:#2a78d6; --series-2:#eb6834; --series-3:#1baf7a; --series-4:#eda100;\n  background:var(--plane); color:var(--text-primary);\n  font-family:system-ui,-apple-system,\"Segoe UI\",sans-serif;\n  max-width:1000px; margin:0 auto; padding:28px 20px 56px;\n}\n@media (prefers-color-scheme:dark){\n  :root:where(:not([data-theme=\"light\"])) .viz-root{\n    color-scheme:dark;\n    --surface-1:#1a1a19; --plane:#0d0d0d;\n    --text-primary:#ffffff; --text-secondary:#c3c2b7; --muted:#898781;\n    --grid:#2c2c2a; --axis:#383835; --border:rgba(255,255,255,0.10);\n    --series-1:#3987e5; --series-2:#d95926; --series-3:#199e70; --series-4:#c98500;\n  }\n}\n:root[data-theme=\"dark\"] .viz-root{\n  color-scheme:dark;\n  --surface-1:#1a1a19; --plane:#0d0d0d;\n  --text-primary:#ffffff; --text-secondary:#c3c2b7; --muted:#898781;\n  --grid:#2c2c2a; --axis:#383835; --border:rgba(255,255,255,0.10);\n  --series-1:#3987e5; --series-2:#d95926; --series-3:#199e70; --series-4:#c98500;\n}\nh1{font-size:1.55rem;margin:0 0 4px;letter-spacing:-0.01em}\nh2{font-size:1.02rem;margin:0 0 4px}\n.sub{color:var(--text-secondary);margin:0 0 22px;font-size:.88rem}\n.cap{color:var(--text-secondary);font-size:.82rem;margin:0 0 14px;max-width:66ch;line-height:1.45}\n.tiles{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin-bottom:20px}\n.tile{background:var(--surface-1);border:1px solid var(--border);border-radius:10px;padding:14px 16px}\n.tl{font-size:.72rem;text-transform:uppercase;letter-spacing:.05em;color:var(--muted)}\n.tv{font-size:1.5rem;font-weight:600;margin:4px 0 2px;line-height:1.15}\n.tn{font-size:.76rem;color:var(--text-secondary)}\n.card{background:var(--surface-1);border:1px solid var(--border);border-radius:12px;padding:18px 20px;margin-bottom:16px}\n.legend{display:flex;flex-wrap:wrap;gap:14px;margin-bottom:12px}\n.lg{display:inline-flex;align-items:center;gap:6px;font-size:.78rem;color:var(--text-secondary)}\n.lg i{width:11px;height:11px;border-radius:3px;display:inline-block;flex:none}\nsvg{display:block;overflow:visible}\n.grp{font-size:11.5px;font-weight:600;fill:var(--text-primary)}\n.grpmeta{font-size:10px;fill:var(--muted)}\n.grpscore{font-size:13px;font-weight:700;fill:var(--text-primary);font-variant-numeric:tabular-nums}\n.track{fill:var(--grid)}\n.val{font-size:10.5px;fill:var(--text-secondary);font-variant-numeric:tabular-nums}\n.tlabel{font-size:11px;fill:var(--text-secondary)}\n.twt{font-size:9.5px;fill:var(--muted);font-variant-numeric:tabular-nums}\n.scorebar{fill:var(--series-1)}\n.overallbar{fill:var(--series-1);stroke:var(--text-primary);stroke-width:.75}\n.olabel{font-size:11px;font-weight:600;fill:var(--text-primary)}\n.oval{font-size:11px;font-weight:700;fill:var(--text-primary);font-variant-numeric:tabular-nums}\n.grid{stroke:var(--grid);stroke-width:1}\n.axis{stroke:var(--axis);stroke-width:1}\n.tick{font-size:10px;fill:var(--muted);font-variant-numeric:tabular-nums}\n.axl{text-align:center;font-size:.74rem;color:var(--muted);margin:6px 0 0}\n.scroll{overflow-x:auto}\ntable{border-collapse:collapse;width:100%;font-size:.8rem}\nth,td{text-align:left;padding:7px 10px;border-bottom:1px solid var(--border);white-space:nowrap}\nth{font-size:.71rem;text-transform:uppercase;letter-spacing:.04em;color:var(--muted);font-weight:600}\n.num{text-align:right;font-variant-numeric:tabular-nums}\n.strong{font-weight:600}\n.muted{color:var(--muted)}\n.mono{font-family:ui-monospace,\"SFMono-Regular\",Menlo,Consolas,monospace;font-size:.78rem;background:var(--plane);border:1px solid var(--border);border-radius:4px;padding:1px 5px;white-space:nowrap}\n.wt{color:var(--muted);font-weight:400;font-size:.72em;margin-left:4px}\n.notes{margin:12px 0 0;padding-left:18px;color:var(--text-secondary);font-size:.78rem}\n.empty{color:var(--muted);font-size:.82rem}\n.v-good{color:var(--text-secondary)}\n.v-warn{color:#ec835a;font-weight:600}\n.v-bad{color:#d03b3b;font-weight:600}\ncircle:hover{r:6}\nrect[fill^=\"var\"]:hover{opacity:.82}\n</style>";
+/** Write the report and return its path. */
+declare function write(outFile?: string): {
+    file: string;
+    count: number;
+};
+export { write, build, STYLE, SERIES };
+//# sourceMappingURL=report.d.ts.map