@tensor-cad/engine 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# @tensor-cad/engine
+
+The TensorCAD analysis engine: one WebAssembly module with a JSON interface, and
+the TypeScript that loads it.
+
+Give it a design and it tells you what the design costs — parameters, FLOPs, KV
+cache, memory at an operating point, throughput, dollars — checks it against
+eighteen design rules, writes the PyTorch, and searches for a way to train it on
+a cluster. The same module answers in a browser, in a Node process and inside
+the desktop shell, so an answer cannot depend on where it was asked.
+
+## Using it
+
+In a browser or anything with `fetch`:
+
+```ts
+import { createEngine } from "@tensor-cad/engine";
+import "@tensor-cad/engine/wasm_exec";
+
+const engine = await createEngine({ wasm: "/tensorcad.wasm" });
+const doc = engine.preset("llama-3-8b");
+console.log(engine.analyze(doc).params.total); // 8030261248
+```
+
+From a Node process, where the module is read rather than fetched and held as a
+singleton:
+
+```ts
+import { analyze, getPreset, loadEngine } from "@tensor-cad/engine/node";
+
+await loadEngine();
+const report = analyze(getPreset("mixtral-8x7b"), { T: 4096 });
+console.log(report.params.total, report.params.active);
+```
+
+`wasm_exec.js` is Go's own loader, vendored from the toolchain that built the
+module. The two travel together or neither works.
+
+## What it answers
+
+| call | what it gives |
+| --- | --- |
+| `analyze(doc, options)` | every number at once |
+| `validate(doc, options)` | the design rules, and the analysis they ran against |
+| `derive(doc, options)` | the findings and every shape from one walk of the graph |
+| `infer(doc, mode)` | the shapes alone, for the wire the pointer is over |
+| `explain(doc, path)` | one block: its parameters as written and as evaluated, its shapes, its share |
+| `generateTorch(doc, options)` | a `model.py` and the design that produced it |
+| `scale(doc, {targetParams})` | the design shrunk to a budget, proportions kept |
+| `mup(doc, options)` | the same design at several widths, and what to scale by at each |
+| `plan(doc, options, {gpus})` | every way to split the training across a cluster, and which fit |
+| `importHuggingFace(text)` | a `config.json` read into a design |
+| `preset(name)`, `presets()` | the twenty designs it ships with |
+| `catalog()`, `rules()`, `hardware()` | what it knows about blocks, rules and devices |
+
+Everything crosses as JSON text. A design *is* JSON and so is every report, so
+serializing costs a copy and buys a boundary with nothing clever in it. A call
+that cannot answer throws an `EngineError` naming what was wrong rather than
+returning a default.
+
+## What it is held to
+
+`packages/core-go/testdata` in the repository: the symbol table and inferred
+shapes for twenty published architectures, the full analysis and the design-rule
+check at three operating points each, and every byte of three generated
+`model.py` variants. Seventeen of the twenty reproduce their published parameter
+count exactly and the other three are within a stated tolerance, and every one
+of them has been instantiated in PyTorch to confirm the count is real — up to
+DeepSeek-V3 at 671,026,419,200.
+
+## Building it
+
+```bash
+bun run build:wasm
+```
+
+from the repository root. The output lands in `wasm/` and is not committed, so a
+fresh clone builds it before anything works.
+
+MIT. See LICENSE.md.

package/catalog.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Asking the catalog about a block.
+ *
+ * The engine ships the blocks it knows; a design can define more. Every client
+ * needs the same two things from that — one block by name, and all of them
+ * grouped — and needs them to agree with what the analysis counted. So the
+ * folding happens here rather than three times over.
+ */
+import type { CatalogEntry, Doc, ParamSpec } from "./types.js";
+/** The blocks an engine knows, and the ones a document adds to them. */
+export declare class Catalog {
+    private readonly builtIn;
+    constructor(entries: readonly CatalogEntry[]);
+    /** Every built-in block, in the order the engine declares them. */
+    get builtInEntries(): CatalogEntry[];
+    /** True when the engine itself knows this type. */
+    isBuiltIn(type: string): boolean;
+    /**
+     * One block's definition.
+     *
+     * A design never shadows a built-in, which is what the engine's own resolver
+     * does; agreeing here keeps a palette showing what the analysis counted.
+     */
+    get(type: string, doc?: Doc): CatalogEntry | undefined;
+    /** Every block a document can use, built-ins first. */
+    entries(doc?: Doc): CatalogEntry[];
+    byCategory(doc?: Doc): Record<string, CatalogEntry[]>;
+    /** True when this type came from the design rather than from the engine. */
+    isUserBlock(doc: Doc | undefined, type: string): boolean;
+    /** A block's parameter spec, by name. */
+    param(type: string, name: string, doc?: Doc): ParamSpec | undefined;
+}
+export declare function isPrimitive(def: CatalogEntry | undefined): boolean;
+export declare function isComposite(def: CatalogEntry | undefined): boolean;
+export declare function isContainer(def: CatalogEntry | undefined): boolean;

package/format.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Display helpers.
+ *
+ * TypeScript rather than a call into the engine: these run on every repaint,
+ * beside a number the panel already has, and a boundary crossing to turn 4096
+ * into "4.1K" would be the slowest thing in the frame. The Go engine has the
+ * same set for the command line, and a test pins the two against each other.
+ */
+/** A parameter count as a person reads it: 8.03B, 124.4M, 12.9K. */
+export declare function formatCount(n: number): string;
+/** A FLOP count: 312.00 TFLOP, 1.20 PFLOP. */
+export declare function formatFlops(n: number): string;
+/** A byte count, in the binary units the hardware is sold in. */
+export declare function formatBytes(n: number): string;
+/** A duration: 45.0 min, 12.5 h, 3.2 days. */
+export declare function formatHours(h: number): string;
+/** A price: $1.20M, $4.5k, $12.34. */
+export declare function formatDollars(d: number): string;

package/index.d.ts

@@ -0,0 +1,154 @@
+/**
+ * The engine, loaded into whatever is running the editor.
+ *
+ * TensorCAD's analysis is Go, compiled to WebAssembly. That is not an
+ * optimisation: it is what keeps there from being two of it. The desktop shell,
+ * a browser tab and the command line all ask the same code the same questions,
+ * so an answer cannot depend on where it was asked.
+ *
+ * Everything crosses the boundary as JSON text. A design *is* JSON and so is
+ * every report, so serialising costs a copy and buys a boundary with nothing
+ * clever in it — no object graph to keep in step, no handles to leak.
+ */
+import { Catalog } from "./catalog.js";
+import type { AnalysisOptions, AnalysisResult, CatalogEntry, Derived, Doc, Explanation, GeneratedCode, HardwareProfile, ImportResult, Inference, MupLadder, MupOptions, ScaleOptions, ScaleResult, ClusterRequest, ClusterResult, DesignDiff, TorchOptions, UserBlockDef, ValidationReport } from "./types.js";
+export * from "./types.js";
+export * from "./format.js";
+export * from "./ir.js";
+export * from "./catalog.js";
+/** What the engine says about itself. */
+export interface EngineVersion {
+    engine: string;
+    target: string;
+}
+/**
+ * The engine's whole surface.
+ *
+ * Synchronous, because the calls run on the thread that asked and the largest
+ * design in the library analyses in a couple of milliseconds. Loading is the
+ * asynchronous part, and it happens once.
+ */
+export interface Engine {
+    version(): EngineVersion;
+    analyze(doc: Doc, options?: AnalysisOptions): AnalysisResult;
+    /** Runs the design rules and returns the analysis they were drawn from. */
+    validate(doc: Doc, options?: AnalysisOptions): ValidationReport;
+    /**
+     * The editor's entry point: the findings and the shapes together.
+     *
+     * One call rather than two, because both come from the same walk of the same
+     * graph and asking separately would walk it twice on every keystroke.
+     */
+    derive(doc: Doc, options?: AnalysisOptions): Derived;
+    /**
+     * Shape inference alone, which is what answers "would this wire type-check"
+     * for every handle the pointer passes over.
+     */
+    infer(doc: Doc, mode?: "flat" | "expanded"): Inference;
+    explain(doc: Doc, path: string, options?: AnalysisOptions): Explanation;
+    /** Every block, largest contribution first. */
+    explainAll(doc: Doc, options?: AnalysisOptions): Explanation[];
+    generateTorch(doc: Doc, options?: TorchOptions): GeneratedCode;
+    scale(doc: Doc, options: ScaleOptions): ScaleResult;
+    /**
+     * The same design at several widths, with what to multiply the
+     * initialization and the learning rate by at each one.
+     *
+     * It is what makes a sweep affordable: tune at a width that fits on one
+     * device, and carry the answer up the ladder. What it does not do is decide
+     * the base learning rate, which is what the sweep is for.
+     */
+    mup(doc: Doc, options?: MupOptions): MupLadder;
+    /**
+     * Every way of splitting the work across a cluster, and which of them fit.
+     *
+     * Memory is the claim, and it is arithmetic. Which plan is fastest is not:
+     * that turns on the interconnect and the kernels, so each plan carries a
+     * note about what it costs to run rather than a number pretending to.
+     */
+    plan(doc: Doc, options: AnalysisOptions, cluster: ClusterRequest): ClusterResult;
+    /** What changed between two designs, structurally and numerically. */
+    diff(a: Doc, b: Doc, options?: AnalysisOptions): DesignDiff;
+    /** The design library this engine ships with. */
+    presets(): string[];
+    preset(name: string): Doc;
+    /** Reads a Hugging Face `config.json`. */
+    importHuggingFace(configText: string, name?: string): ImportResult;
+    /** Every block the engine knows, for the palette. */
+    catalog(): CatalogEntry[];
+    /**
+     * The same blocks, ready to be asked about one at a time and to have a
+     * design's own definitions folded in. Fetched once when the engine loads.
+     */
+    readonly blocks: Catalog;
+    /** The design rules, for the panel that lists what is being checked. */
+    rules(): RuleInfo[];
+    /**
+     * What is wrong with a block a design defines for itself, so the block editor
+     * can say so while it is being written rather than after it is saved.
+     */
+    checkUserBlock(def: UserBlockDef, name: string): string[];
+    hardware(): HardwareProfile[];
+}
+/** The shape the WebAssembly module publishes on `globalThis`. */
+interface Exports {
+    version(): string;
+    analyze(doc: string, options: string): string;
+    validate(doc: string, options: string): string;
+    derive(doc: string, options: string): string;
+    infer(doc: string, mode: string): string;
+    explain(doc: string, path: string, options: string): string;
+    explainAll(doc: string, options: string): string;
+    generateTorch(doc: string, options: string): string;
+    scale(doc: string, options: string): string;
+    mup(doc: string, options: string): string;
+    plan(doc: string, options: string, cluster: string): string;
+    diff(a: string, b: string, options: string): string;
+    presets(): string;
+    preset(name: string): string;
+    importHf(configText: string, name: string): string;
+    catalog(): string;
+    rules(): string;
+    checkUserBlock(def: string, name: string): string;
+    hardware(): string;
+}
+/** One design rule, as the rules panel lists it. */
+export interface RuleInfo {
+    id: string;
+    title: string;
+    /** One line on what the rule protects against. */
+    description: string;
+}
+/**
+ * Raised when the engine refuses a call.
+ *
+ * A distinct type because a refusal is not a bug: an unknown hardware profile
+ * or a design with no version is something a person can fix, and the editor
+ * shows it rather than logging it.
+ */
+export declare class EngineError extends Error {
+    constructor(message: string);
+}
+/** Where to find the compiled engine, and what to run it with. */
+export interface LoadOptions {
+    /**
+     * The `.wasm` file. A URL is fetched; bytes are used as they are. Omitted,
+     * it is resolved next to this module, which is what a bundler produces.
+     */
+    wasm?: string | URL | BufferSource;
+}
+declare global {
+    var Go: (new () => {
+        importObject: WebAssembly.Imports;
+        run(instance: WebAssembly.Instance): Promise<void>;
+    }) | undefined;
+    var __tensorcad: Exports | undefined;
+}
+/**
+ * Loads the engine.
+ *
+ * `globalThis.Go` has to exist first: it comes from the Go toolchain's
+ * `wasm_exec.js`, which is vendored beside this file. A bundler wants
+ * `import "@tensor-cad/engine/wasm_exec"` before the first call.
+ */
+export declare function createEngine(options?: LoadOptions): Promise<Engine>;

package/index.js

@@ -0,0 +1,249 @@
+// packages/engine/src/catalog.ts
+function fromUserBlock(type, def) {
+  const params = { ...def.params ?? {} };
+  const shapes = (side) => {
+    const out = {};
+    for (const [name, port] of Object.entries(side ?? {})) {
+      out[name] = typeof port === "string" ? port : port.shape;
+    }
+    return out;
+  };
+  return {
+    type,
+    kind: "composite",
+    category: def.category ?? "custom",
+    docs: {
+      summary: def.docs?.summary ?? "A block this design defines for itself.",
+      formula: def.docs?.formula,
+      refs: def.docs?.refs
+    },
+    params,
+    paramOrder: Object.keys(params),
+    ports: { in: shapes(def.ports?.in), out: shapes(def.ports?.out) }
+  };
+}
+
+class Catalog {
+  builtIn;
+  constructor(entries) {
+    this.builtIn = new Map(entries.map((entry) => [entry.type, entry]));
+  }
+  get builtInEntries() {
+    return [...this.builtIn.values()];
+  }
+  isBuiltIn(type) {
+    return this.builtIn.has(type);
+  }
+  get(type, doc) {
+    if (this.builtIn.has(type))
+      return this.builtIn.get(type);
+    const own = doc?.defs?.[type];
+    return own ? fromUserBlock(type, own) : undefined;
+  }
+  entries(doc) {
+    const out = this.builtInEntries;
+    for (const [type, def] of Object.entries(doc?.defs ?? {})) {
+      if (!this.builtIn.has(type))
+        out.push(fromUserBlock(type, def));
+    }
+    return out;
+  }
+  byCategory(doc) {
+    const out = {};
+    for (const entry of this.entries(doc)) {
+      (out[entry.category] ??= []).push(entry);
+    }
+    return out;
+  }
+  isUserBlock(doc, type) {
+    return Boolean(doc?.defs && type in doc.defs && !this.builtIn.has(type));
+  }
+  param(type, name, doc) {
+    return this.get(type, doc)?.params[name];
+  }
+}
+function isPrimitive(def) {
+  return def?.kind === "primitive";
+}
+function isComposite(def) {
+  return def?.kind === "composite";
+}
+function isContainer(def) {
+  return def?.kind === "container";
+}
+
+// packages/engine/src/types.ts
+var DOC_VERSION = 1;
+var RUNTIME_SYMBOLS = ["B", "T"];
+var BOUNDARY_IN = "_in";
+var BOUNDARY_OUT = "_out";
+var DEFAULT_PARALLEL = {
+  dp: 1,
+  tp: 1,
+  pp: 1,
+  ep: 1,
+  zero: 0,
+  sequenceParallel: false
+};
+var DEFAULT_HARDWARE = "h100-sxm";
+var DTYPE_BYTES = { fp32: 4, bf16: 2, fp16: 2, fp8: 1 };
+// packages/engine/src/format.ts
+function formatCount(n) {
+  const abs = Math.abs(n);
+  if (abs >= 1000000000000)
+    return `${(n / 1000000000000).toFixed(2)}T`;
+  if (abs >= 1e9)
+    return `${(n / 1e9).toFixed(2)}B`;
+  if (abs >= 1e6)
+    return `${(n / 1e6).toFixed(1)}M`;
+  if (abs >= 1000)
+    return `${(n / 1000).toFixed(1)}K`;
+  return String(n);
+}
+function formatFlops(n) {
+  const units = [
+    [1000000000000000000, "EFLOP"],
+    [1000000000000000, "PFLOP"],
+    [1000000000000, "TFLOP"],
+    [1e9, "GFLOP"],
+    [1e6, "MFLOP"],
+    [1000, "kFLOP"]
+  ];
+  for (const [scale, unit] of units) {
+    if (Math.abs(n) >= scale)
+      return `${(n / scale).toFixed(2)} ${unit}`;
+  }
+  return `${n.toFixed(0)} FLOP`;
+}
+function formatBytes(n) {
+  const units = [
+    [1024 ** 5, "PiB"],
+    [1024 ** 4, "TiB"],
+    [1024 ** 3, "GiB"],
+    [1024 ** 2, "MiB"],
+    [1024, "KiB"]
+  ];
+  for (const [scale, unit] of units) {
+    if (Math.abs(n) >= scale)
+      return `${(n / scale).toFixed(2)} ${unit}`;
+  }
+  return `${Math.round(n)} B`;
+}
+function formatHours(h) {
+  if (h < 1)
+    return `${(h * 60).toFixed(1)} min`;
+  if (h < 48)
+    return `${h.toFixed(1)} h`;
+  return `${(h / 24).toFixed(1)} days`;
+}
+function formatDollars(d) {
+  if (d >= 1e6)
+    return `$${(d / 1e6).toFixed(2)}M`;
+  if (d >= 1000)
+    return `$${(d / 1000).toFixed(1)}k`;
+  return `$${d.toFixed(2)}`;
+}
+// packages/engine/src/ir.ts
+function splitEndpoint(endpoint) {
+  const i = endpoint.lastIndexOf(":");
+  if (i < 0)
+    throw new Error(`Malformed endpoint "${endpoint}", expected "node:port"`);
+  return { node: endpoint.slice(0, i), port: endpoint.slice(i + 1) };
+}
+function joinPath(prefix, id) {
+  return prefix ? `${prefix}/${id}` : id;
+}
+
+// packages/engine/src/index.ts
+class EngineError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EngineError";
+  }
+}
+function unwrap(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new EngineError(`The engine returned something that is not JSON: ${text.slice(0, 200)}`);
+  }
+  if (parsed && typeof parsed === "object" && "error" in parsed && typeof parsed.error === "string") {
+    throw new EngineError(parsed.error);
+  }
+  return parsed;
+}
+function point(options) {
+  return options ? JSON.stringify(options) : "";
+}
+async function bytesOf(wasm) {
+  if (wasm && typeof wasm !== "string" && !(wasm instanceof URL))
+    return wasm;
+  const url = wasm ?? new URL("../wasm/tensorcad.wasm", import.meta.url);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new EngineError(`Could not load the engine from ${String(url)}: ${response.status}`);
+  }
+  return await response.arrayBuffer();
+}
+async function createEngine(options = {}) {
+  if (typeof globalThis.Go !== "function") {
+    throw new EngineError('The Go WebAssembly runtime is missing. Import "@tensor-cad/engine/wasm_exec" before creating the engine.');
+  }
+  const go = new globalThis.Go;
+  const compiled = await WebAssembly.instantiate(await bytesOf(options.wasm), go.importObject);
+  const instance = "instance" in compiled ? compiled.instance : compiled;
+  go.run(instance);
+  const api = globalThis.__tensorcad;
+  if (!api) {
+    throw new EngineError("The engine started but published no API.");
+  }
+  return wrap(api);
+}
+function wrap(api) {
+  const entries = JSON.parse(api.catalog());
+  return {
+    blocks: new Catalog(entries),
+    version: () => unwrap(api.version()),
+    analyze: (doc, options) => unwrap(api.analyze(JSON.stringify(doc), point(options))),
+    validate: (doc, options) => unwrap(api.validate(JSON.stringify(doc), point(options))),
+    derive: (doc, options) => unwrap(api.derive(JSON.stringify(doc), point(options))),
+    infer: (doc, mode) => unwrap(api.infer(JSON.stringify(doc), mode ?? "flat")),
+    explain: (doc, path, options) => unwrap(api.explain(JSON.stringify(doc), path, point(options))),
+    explainAll: (doc, options) => unwrap(api.explainAll(JSON.stringify(doc), point(options))),
+    generateTorch: (doc, options) => unwrap(api.generateTorch(JSON.stringify(doc), options ? JSON.stringify(options) : "")),
+    scale: (doc, options) => unwrap(api.scale(JSON.stringify(doc), JSON.stringify(options))),
+    mup: (doc, options) => unwrap(api.mup(JSON.stringify(doc), options ? JSON.stringify(options) : "")),
+    plan: (doc, options, cluster) => unwrap(api.plan(JSON.stringify(doc), JSON.stringify(options ?? {}), JSON.stringify(cluster))),
+    diff: (a, b, options) => unwrap(api.diff(JSON.stringify(a), JSON.stringify(b), JSON.stringify(options ?? {}))),
+    presets: () => unwrap(api.presets()),
+    preset: (name) => unwrap(api.preset(name)),
+    importHuggingFace: (configText, name) => unwrap(api.importHf(configText, name ?? "")),
+    catalog: () => unwrap(api.catalog()),
+    rules: () => unwrap(api.rules()),
+    checkUserBlock: (def, name) => unwrap(api.checkUserBlock(JSON.stringify(def), name)),
+    hardware: () => unwrap(api.hardware())
+  };
+}
+export {
+  BOUNDARY_IN,
+  BOUNDARY_OUT,
+  Catalog,
+  DEFAULT_HARDWARE,
+  DEFAULT_PARALLEL,
+  DOC_VERSION,
+  DTYPE_BYTES,
+  EngineError,
+  RUNTIME_SYMBOLS,
+  createEngine,
+  formatBytes,
+  formatCount,
+  formatDollars,
+  formatFlops,
+  formatHours,
+  isComposite,
+  isContainer,
+  isPrimitive,
+  joinPath,
+  splitEndpoint
+};

package/ir.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Reading the IR's own spellings.
+ *
+ * An endpoint is `"nodeId:portName"` and a path is `"a/b/c"`. These are the
+ * two conventions the whole document rests on, and they are string handling
+ * rather than analysis — the editor splits a hundred of them per repaint, and
+ * crossing into the engine for that would be absurd. The Go engine has the same
+ * two functions for the same reason.
+ */
+/** One end of an edge. */
+export interface Endpoint {
+    node: string;
+    port: string;
+}
+/**
+ * Splits `"node:port"`.
+ *
+ * At the last colon, because a node id inside a container carries slashes and
+ * may itself have come from a path.
+ */
+export declare function splitEndpoint(endpoint: string): Endpoint;
+/** Builds the dotted path identifying a node inside nested graphs. */
+export declare function joinPath(prefix: string, id: string): string;

package/node.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Loading the engine outside a browser.
+ *
+ * The command line and the MCP server are Node processes with a filesystem, so
+ * they read the module rather than fetching it, and they hold it in a module
+ * singleton the way the editor does: one engine per process, loaded before the
+ * first command runs.
+ */
+import { type Engine } from "./index.js";
+import "../vendor/wasm_exec.js";
+/**
+ * Loads the engine, once per process.
+ *
+ * A missing module is the one failure worth naming precisely: it means the
+ * repository was cloned but not built, and the fix is one command.
+ */
+export declare function loadEngine(): Promise<Engine>;
+/** The engine. Throws if something asked before the load finished. */
+export declare function engine(): Engine;
+export * from "./index.js";
+import type { AnalysisOptions, AnalysisResult, CatalogEntry, ClusterRequest, ClusterResult, Derived, DesignDiff, Doc, Dtype, Explanation, GeneratedCode, HardwareProfile, ImportResult, Inference, ParamsResult, MupLadder, MupOptions, ScaleOptions, ScaleResult, SymbolTable, TorchOptions, ValidationReport } from "./index.js";
+/** Filled in by the load, so a module can hold a reference at import time. */
+export declare const PRESET_NAMES: string[];
+export declare const HARDWARE: HardwareProfile[];
+export declare const CATALOG: Record<string, CatalogEntry>;
+export declare function analyze(doc: Doc, options?: AnalysisOptions): AnalysisResult;
+export declare function validate(doc: Doc, options?: AnalysisOptions): ValidationReport;
+/** The findings and every shape, from one walk of the graph. */
+export declare function derive(doc: Doc, options?: AnalysisOptions): Derived;
+export declare function inferShapes(doc: Doc, mode?: "flat" | "expanded"): Inference;
+export declare function explain(doc: Doc, path: string, options?: AnalysisOptions): Explanation;
+export declare function explainAll(doc: Doc, options?: AnalysisOptions): Explanation[];
+export declare function generateTorch(doc: Doc, options?: TorchOptions): GeneratedCode;
+export declare function scaleDesign(doc: Doc, options: ScaleOptions): ScaleResult;
+export declare function mupLadder(doc: Doc, options?: MupOptions): MupLadder;
+export declare function planCluster(doc: Doc, options: AnalysisOptions, cluster: ClusterRequest): ClusterResult;
+export declare function diffDesigns(a: Doc, b: Doc, options?: AnalysisOptions): DesignDiff;
+export declare function importHfConfig(configText: string, name?: string): ImportResult;
+export declare function getPreset(name: string): Doc;
+/** The parameter counts alone. */
+export declare function countParams(doc: Doc): ParamsResult;
+/** The symbol table alone. */
+export declare function resolveSymbols(doc: Doc): SymbolTable;
+/** One block's definition, built-in or the design's own. */
+export declare function getBlock(type: string, doc?: Doc): CatalogEntry | undefined;
+export declare function catalogByCategory(doc?: Doc): Record<string, CatalogEntry[]>;
+export declare function hardwareById(id: string): HardwareProfile | undefined;
+/**
+ * A device's throughput for a dtype, falling back to BF16 where FP8 is
+ * unsupported. Arithmetic on a profile the caller already has, so it stays on
+ * this side of the boundary.
+ */
+export declare function peakFlops(hw: HardwareProfile, dtype: Dtype): number;