@mettascript/core 2.0.0

package/dist/host-kERXz0y1.d.ts

@@ -0,0 +1,1035 @@
+type IntVal = number | bigint;
+/** A bigint that fits the safe-integer range collapses to a number; everything else stays bigint. */
+declare function canonInt(n: IntVal): IntVal;
+declare function addInt(x: IntVal, y: IntVal): IntVal;
+declare function subInt(x: IntVal, y: IntVal): IntVal;
+declare function mulInt(x: IntVal, y: IntVal): IntVal;
+/** Integer division truncating toward zero (matches the existing `Math.trunc(a/b)` semantics). */
+declare function intDiv(x: IntVal, y: IntVal): IntVal;
+declare function intMod(x: IntVal, y: IntVal): IntVal;
+declare function intAbs(n: IntVal): IntVal;
+declare function isZero(n: IntVal): boolean;
+/** Coerce either representation to a double for the f64 math ops (precision loss is acceptable there). */
+declare function toF64(n: IntVal): number;
+/** Three-way compare of two integer values, exact (promotes to bigint when needed). Value-level
+ *  analogue of `compareNumbers`, used by the deterministic-core compiler on unwrapped ints. */
+declare function cmpIntVal(a: IntVal, b: IntVal): number;
+
+/**
+ * The MeTTa term model. A discriminated union on `kind` (convention C1).
+ * Every variant declares ALL seven fields in the SAME order so V8 keeps one
+ * hidden class across atoms (monomorphic property access on the hot path).
+ * Unused fields are `undefined`, never absent, never deleted (C1).
+ */
+type MetaType = "Symbol" | "Variable" | "Expression" | "Grounded";
+interface SymAtom {
+    readonly kind: "sym";
+    readonly name: string;
+    readonly items: undefined;
+    readonly value: undefined;
+    readonly typ: undefined;
+    readonly exec: undefined;
+    readonly match: undefined;
+    readonly ground: true;
+}
+interface VarAtom {
+    readonly kind: "var";
+    readonly name: string;
+    readonly items: undefined;
+    readonly value: undefined;
+    readonly typ: undefined;
+    readonly exec: undefined;
+    readonly match: undefined;
+    readonly ground: false;
+}
+interface ExprAtom {
+    readonly kind: "expr";
+    readonly name: undefined;
+    readonly items: readonly Atom[];
+    readonly value: undefined;
+    readonly typ: undefined;
+    readonly exec: undefined;
+    readonly match: undefined;
+    /** True iff no variable occurs anywhere inside (a precomputed ground flag): lets `applySubst`,
+     *  `atomVars`, and `occurs` short-circuit instantly on closed terms. Computed once at construction. */
+    readonly ground: boolean;
+}
+/** A grounded value (LeaTTa `Ground`). Numbers track int vs float so `3` and `3.0` stay distinct. */
+type Ground = {
+    readonly g: "int";
+    readonly n: number | bigint;
+} | {
+    readonly g: "float";
+    readonly n: number;
+} | {
+    readonly g: "str";
+    readonly s: string;
+} | {
+    readonly g: "bool";
+    readonly b: boolean;
+} | {
+    readonly g: "unit";
+} | {
+    readonly g: "error";
+    readonly msg: string;
+} | {
+    readonly g: "ext";
+    readonly kind: string;
+    readonly id: string;
+};
+/** A grounded atom: a structured `Ground` value with a derived type atom, plus optional executor
+ *  and custom matcher (used by DAS-style grounded atoms; core built-in ops dispatch by symbol). */
+interface GndAtom {
+    readonly kind: "gnd";
+    readonly name: undefined;
+    readonly items: undefined;
+    readonly value: Ground;
+    readonly typ: Atom;
+    readonly exec: GroundedExec | undefined;
+    readonly match: GroundedMatch | undefined;
+    readonly ground: true;
+}
+type Atom = SymAtom | VarAtom | ExprAtom | GndAtom;
+/** A grounded atom's executor: applied when the atom heads an expression `(<gnd> arg...)`. Receives
+ *  the evaluated argument atoms and returns the result atoms, either directly or as a Promise. A
+ *  Promise suspends the async runner (as a named async op does) and is refused by the sync runner;
+ *  it never widens the atom record, since `exec` stays a single slot. May throw / reject for a
+ *  runtime error. */
+type GroundedExec = (args: readonly Atom[]) => readonly Atom[] | Promise<readonly Atom[]>;
+type GroundedMatch = (other: Atom) => readonly unknown[];
+declare function groundEq(a: Ground, b: Ground): boolean;
+declare function canInternExprItems(items: readonly Atom[]): boolean;
+/** Interned symbol atom: equal names share one object (reference equality, low allocation). */
+declare function sym(name: string): SymAtom;
+/** Variable atom. Not interned: freshening needs distinct identities. */
+declare function variable(name: string): VarAtom;
+declare function expr(items: readonly Atom[]): ExprAtom;
+interface InternTable {
+    readonly buckets: Map<number, Atom | Atom[]>;
+    readonly variables: Map<string, VarAtom>;
+    readonly expressions: WeakSet<ExprAtom>;
+    readonly hasUnsafeGrounded: WeakMap<ExprAtom, boolean>;
+}
+declare function createInternTable(): InternTable;
+declare function internAtom(table: InternTable | undefined, a: Atom): Atom;
+declare function internExpr(table: InternTable | undefined, a: ExprAtom): ExprAtom;
+declare function internBuiltExpr(table: InternTable | undefined, a: ExprAtom): ExprAtom;
+/** The built-in type atom for a grounded value (LeaTTa `getTypes` on grounded). */
+declare function groundType(v: Ground): Atom;
+declare function gnd(value: Ground, typ?: Atom, exec?: GroundedExec, match?: GroundedMatch): GndAtom;
+/** Grounded literal constructors. */
+declare const gint: (n: IntVal) => GndAtom;
+declare const gfloat: (n: number) => GndAtom;
+declare const gstr: (s: string) => GndAtom;
+declare const gbool: (b: boolean) => GndAtom;
+declare const gunit: GndAtom;
+declare function metaType(a: Atom): MetaType;
+declare const mixHash: (h: number, x: number) => number;
+declare const strHash: (s: string) => number;
+/** A 32-bit structural hash: equal structures hash equal. O(1) amortised for a fresh atom whose subterms
+ *  are already hashed. Collisions are possible, so callers verify a match with `atomEq`. */
+declare function hashOf(a: Atom): number;
+/** Total term size (LeaTTa `Atom.size`): leaves are 1, an expression is 1 + sum of parts. */
+declare function atomSize(a: Atom): number;
+/** All variable names occurring in an atom (LeaTTa `Atom.vars`), in first-seen order, deduped. */
+declare function atomVars(a: Atom, out?: string[]): string[];
+/** Collect an atom's variable names into `out`, deduping via the shared `seen` set (O(1) membership instead
+ *  of a linear `out.includes`). Hot accumulation loops (scopeVars/frameVars) reuse one `seen` across many
+ *  atoms so the whole walk stays linear; `atomVars` is the one-shot wrapper that seeds `seen` from `out`. */
+declare function collectVars(a: Atom, out: string[], seen: Set<string>): void;
+/** The empty expression `()` (LeaTTa `Atom.empty`), the success marker used by `assert*`. */
+declare const emptyExpr: ExprAtom;
+/** Is this atom an `(Error ...)` expression? */
+declare function isErrorAtom(a: Atom): boolean;
+declare const isExpr: (a: Atom) => a is ExprAtom;
+declare const isVar: (a: Atom) => a is VarAtom;
+declare const isSym: (a: Atom) => a is SymAtom;
+declare const isGnd: (a: Atom) => a is GndAtom;
+/** Structural equality. Interned symbols short-circuit to reference identity. */
+declare function atomEq(a: Atom, b: Atom): boolean;
+
+interface LogNode {
+    readonly atom: Atom;
+    readonly prev: AtomLog;
+    readonly size: number;
+    /** Count of non-ground atoms in this log; the index fast path is valid only when this is 0. */
+    readonly nonGround: number;
+}
+/** An atom log: `null` is empty; otherwise the most recently appended atom and the rest. */
+type AtomLog = LogNode | null;
+
+interface ValRel {
+    readonly tag: "val";
+    readonly x: string;
+    readonly a: Atom;
+    readonly y: undefined;
+}
+interface EqRel {
+    readonly tag: "eq";
+    readonly x: string;
+    readonly a: undefined;
+    readonly y: string;
+}
+type BindingRel = ValRel | EqRel;
+type Bindings = readonly BindingRel[];
+declare const emptyBindings: Bindings;
+/** The atom bound to `$x` by a direct `val` relation, if any (eq aliases are not followed). */
+declare function lookupVal(b: Bindings, x: string): Atom | undefined;
+/** Remove direct value bindings for `x`; equality relations remain. */
+declare function removeVal(b: Bindings, x: string): Bindings;
+/** True if the binding set carries a variable loop: some variable is reachable from itself by following
+ *  value bindings (`$x ← (.. $y ..)`, `$y ← (.. $x ..)`), so the set has no finite instantiation. Deep and
+ *  transitive, mirroring Hyperon `Bindings::has_loops` (a DFS over variable→value edges) and CeTTa
+ *  `bindings_atom_has_loop`. Every matcher call site drops a looping set (`if (!hasLoop(m))`), the same
+ *  boundary at which Hyperon's `match_atoms` filters `!binding.has_loops()`, so a cyclic unification that a
+ *  direct match admits (`matchAtomsWith` has no occurs check, faithfully — LeaTTa's occurs check lives only
+ *  in reconcile) never reaches the evaluator.
+ *
+ *  Was shallow, catching only the one-hop self relations `$x ← $x` / `$x = $x`, which let an indirect cycle
+ *  like `$x ← (→ $x A)` through. That is a first-bind cycle (each variable bound once); the occurs check in
+ *  `reconcile`/`addVarBinding` only fires on a SECOND bind of a variable, so it never sees such a cycle, and
+ *  the fixpoint resolver then unrolled it to depth `size(b)` and overflowed the native stack — Nil
+ *  Geisweiller's bfc-xp `obc` proof search at size ≥ 7. Deep detection is exactly the guard that makes
+ *  resolution terminate (Alloy model MT1: a binding graph is loop-free iff every variable resolves to a
+ *  finite normal form; a first-bind-only cycle is reachable, so the check must run here at the match
+ *  boundary, not only on reconcile). A variable bound directly to itself (`$x ← $x`) is an identity, not a
+ *  loop, matching Hyperon's short-circuit; it is caught above and treated as a loop only in that trivial
+ *  self form to preserve the previous behaviour exactly.
+ *
+ *  The DFS is iterative (an explicit stack, never native recursion) so detecting a loop can never itself
+ *  overflow, and 3-colours each variable so it is visited once: O(vars + total value size), like Hyperon's
+ *  bitset walk. `atomVars` is cached by object identity, so a DAG-shared value is scanned once. */
+declare function hasLoop(b: Bindings): boolean;
+/** `hasLoop` for a `merge` result whose base was already loop-free.
+ *
+ *  `merge` builds every output by prepending relations onto its base: `addVarBinding` prepends a value
+ *  relation only for a variable the current set leaves unbound (a bound variable either no-ops or goes
+ *  through `reconcile`, whose own extensions bottom out in the same prepend-or-no-op steps), and
+ *  `addVarEquality` prepends an equality. The base is therefore a reference-identical suffix of the
+ *  result, no prepend can shadow a base variable's first value, and the base's first-value graph embeds
+ *  unchanged in the result's. A cycle in the result must then pass through a prepended value binding,
+ *  so running the colour DFS only from the prepended variables is answer-equivalent to the full scan.
+ *  The self-relation quick checks run on the prepended prefix alone for the same reason. Anything that
+ *  is not a reference-identical suffix extension falls back to the full `hasLoop`.
+ *
+ *  Callers must pass the exact base the result was merged from, and that base must itself be loop-free;
+ *  the equivalence fuzz in match.test.ts pins this predicate to `hasLoop` over merge outputs. */
+declare function hasLoopFromBase(merged: Bindings, base: Bindings): boolean;
+/** Bind `$x ← a`, dropping any previous value binding for `$x`. Raw: no consistency check. */
+declare function addValRaw(b: Bindings, x: string, a: Atom): Bindings;
+/** Prepend `$x ← a` when the caller has already proved `$x` has no direct value binding. */
+declare function prependValRaw(b: Bindings, x: string, a: Atom): Bindings;
+/** Add the alias `$x = $y` (a no-op when `x = y`). Raw: no consistency check. */
+declare function addEqRaw(b: Bindings, x: string, y: string): Bindings;
+/** Build a single value relation. The canonical `ValRel` constructor for callers outside this module. */
+declare function makeValRel(x: string, a: Atom): ValRel;
+/** Build a single variable-equality relation. */
+declare function makeEqRel(x: string, y: string): EqRel;
+/** Build a binding set from an explicit list of relations (newest-first). */
+declare function fromRelations(rels: readonly BindingRel[]): Bindings;
+/** Number of relations in the set. */
+declare function size(b: Bindings): number;
+/** Whether the set has no relations. */
+declare function isEmpty(b: Bindings): boolean;
+/** Every relation, newest-first (the order `merge` folds them in). */
+declare function relations(b: Bindings): Iterable<BindingRel>;
+/** Each current value binding as `[var, atom]`. */
+declare function valEntries(b: Bindings): Iterable<readonly [string, Atom]>;
+/** Whether any value binding satisfies `pred`. */
+declare function someVal(b: Bindings, pred: (x: string, a: Atom) => boolean): boolean;
+/** Whether the set carries any `eq` alias. */
+declare function hasEq(b: Bindings): boolean;
+/** Each `eq` alias relation, newest-first. */
+declare function eqRelations(b: Bindings): Iterable<EqRel>;
+
+type ReduceEffect = {
+    readonly kind: "addAtom";
+    readonly space: Atom;
+    readonly atom: Atom;
+} | {
+    readonly kind: "removeAtom";
+    readonly space: Atom;
+    readonly atom: Atom;
+} | {
+    readonly kind: "bindToken";
+    readonly name: string;
+    readonly atom: Atom;
+};
+type ReduceResult = {
+    readonly tag: "ok";
+    readonly results: readonly Atom[];
+    readonly effects?: readonly ReduceEffect[];
+} | {
+    readonly tag: "runtimeError";
+    readonly msg: string;
+} | {
+    readonly tag: "incorrectArgument";
+    readonly msg: string;
+} | {
+    readonly tag: "noReduce";
+};
+type GroundFn = (args: readonly Atom[]) => ReduceResult;
+type GroundingTable = Map<string, GroundFn>;
+/** Return the type carried by a grounded operation, if it has one. */
+declare function groundedOperationType(op: GroundFn): Atom | undefined;
+/** Replace the line-output sink used by `println!`/`trace!` (returns the previous sink). */
+declare function setOutputSink(fn: (line: string) => void): (line: string) => void;
+/** Replace the raw (no-newline) sink used by `print!` (returns the previous sink). */
+declare function setRawSink(fn: (text: string) => void): (text: string) => void;
+/** Enable or disable host effects such as file IO and git imports for this process. */
+declare function setHostEffectsEnabled(enabled: boolean): void;
+/** Three-way compare: exact for two Ints (promoting to bigint as needed), f64 otherwise. */
+declare function compareNumbers(a: Atom, b: Atom): number | undefined;
+/** Names of the PeTTa-compat grounded ops. They yield to user `=` rules (PeTTa is rules-first, builtins as
+ *  fallback), so a program that defines its own e.g. `sort`/`length` is not shadowed by the stdlib one. */
+declare const pettaOpNames: ReadonlySet<string>;
+/** True only for the unchanged built-in function registered under this name. */
+declare function isTableSafeGroundedOp(name: string, fn: GroundFn): boolean;
+/** The arithmetic / boolean / list-surgery / math grounding core every KB starts with. */
+declare function baseTable(): GroundingTable;
+/** The full standard-library grounding table (base + stdlib grounded ops + PeTTa-compat). Later entries do
+ *  not override earlier ones (Map keeps the first), so Hyperon ops win any name shared with PeTTa-compat. */
+declare function stdTable(): GroundingTable;
+/** Dispatch `op` through the grounding table, or `noReduce` if unknown. */
+declare function callGrounded(gt: GroundingTable, op: string, args: readonly Atom[]): ReduceResult;
+
+/** Thrown by a compiled node when it meets a case it cannot handle faithfully (division by zero);
+ *  the caller catches it (along with a native stack `RangeError`) and re-runs the call in the
+ *  interpreter, which is sound because the compiled subset is side-effect-free. */
+declare const BAIL: unique symbol;
+declare class Tup {
+    readonly v: readonly IntVal[];
+    constructor(v: readonly IntVal[]);
+}
+type FrameVal = IntVal | Tup;
+type Ty = "int" | "bool" | "sym" | `tuple${number}` | `symtuple${number}`;
+/** A compiled pure function. `run` is filled after the whole dependency group is compiled, so mutual
+ *  recursion resolves through the holder object. */
+interface FunctionalHolder {
+    kind: "functional";
+    arity: number;
+    retType: Ty;
+    paramTypes: Ty[];
+    run: (vals: FrameVal[]) => FrameVal | boolean;
+}
+interface CompiledAtomResult {
+    readonly atom: Atom;
+    readonly bnd: Bindings;
+}
+interface CompiledRunResult {
+    readonly results: readonly CompiledAtomResult[];
+    readonly counterDelta: number;
+    readonly state?: St;
+}
+interface RewriteHolder {
+    kind: "rewrite";
+    arity: number;
+    retType: Ty;
+    paramTypes: Ty[];
+    ruleCount: number;
+    run: (partAtoms: readonly Atom[]) => CompiledRunResult | undefined;
+}
+interface SymbolicHolder {
+    kind: "symbolic";
+    arity: number;
+    clauseCount: number;
+    run: (partAtoms: readonly Atom[], counter: number) => CompiledRunResult | undefined;
+}
+interface CompiledImpureOps {
+    readonly addAtom: (env: MinEnv, st: St, space: Atom, atom: Atom) => St | undefined;
+    /** Solutions of a `(match space pattern template)` under the current world: the instantiated
+     *  template plus that solution's bindings, in the interpreter's own candidate order, and the
+     *  fresh-variable counter advance the interpreted match would have cost. Undefined = not a space. */
+    readonly matchSolutions?: (env: MinEnv, st: St, space: Atom, pattern: Atom, template: Atom) => {
+        readonly pairs: ReadonlyArray<readonly [Atom, Bindings]>;
+        readonly counterDelta: number;
+    } | undefined;
+    /** The add-if-absent idiom on a ground atom: exact-membership probe, then append when absent.
+     *  Undefined when the fast probe is unsound for this space (non-ground facts, static facts of the
+     *  same head, state handles), sending the caller back to the interpreter. */
+    readonly addIfAbsent?: (env: MinEnv, st: St, space: Atom, atom: Atom) => {
+        readonly added: boolean;
+        readonly state: St;
+    } | undefined;
+}
+type ImpEval = {
+    readonly value: Atom;
+    readonly st: St;
+} | typeof BAIL;
+type ImpEmit = (value: Atom, st: St) => St | typeof BAIL;
+type ImpForEach = (slots: readonly Atom[], st: St, ops: CompiledImpureOps, discard: boolean | undefined, emit: ImpEmit) => St | typeof BAIL;
+interface ImperativeHolder {
+    kind: "imperative";
+    arity: number;
+    clauseCount: number;
+    run: (partAtoms: readonly Atom[], st: St, ops: CompiledImpureOps, discard?: boolean) => ImpEval;
+    runForEach?: ImpForEach;
+}
+interface NondetHolder {
+    kind: "nondet";
+    arity: number;
+    clauseCount: number;
+    /** Prefer direct depth-first search when a later recursive call consumes a clause-local field
+     *  produced by an earlier answer. Independent overlapping calls retain table-first evaluation. */
+    preferDirectForModed: boolean;
+    run: (env: MinEnv, partAtoms: readonly Atom[], st: St, ops: CompiledImpureOps, fuel?: number) => CompiledRunResult | undefined;
+}
+type CompiledHolder = FunctionalHolder | RewriteHolder | SymbolicHolder | ImperativeHolder | NondetHolder;
+type CompiledFns = Map<string, CompiledHolder>;
+type Skel = {
+    readonly t: 0;
+    readonly a: Atom;
+} | {
+    readonly t: 1;
+    readonly i: number;
+} | {
+    readonly t: 2;
+    readonly items: readonly Skel[];
+    readonly arith: string | undefined;
+};
+interface SkelGoal {
+    readonly pat: Skel;
+    /** Empty string when `match` is set: a space-match goal has no dispatched function. */
+    readonly fn: string;
+    readonly args: readonly Skel[];
+    /** A `(match space pattern template)` goal, served by the injected immutable matcher with the
+     *  solutions bound back onto the cells. The JIT declines any group carrying one, so only the
+     *  skeleton interpreter and the immutable engine ever see it. */
+    readonly match?: {
+        readonly space: Skel;
+        readonly pattern: Skel;
+        readonly template: Skel;
+    };
+}
+type SkelTail = {
+    readonly tag: "tpl";
+    readonly tpl: Skel;
+} | {
+    readonly tag: "empty";
+} | {
+    readonly tag: "call";
+    readonly fn: string;
+    readonly args: readonly Skel[];
+} | {
+    readonly tag: "match";
+    readonly space: Skel;
+    readonly pattern: Skel;
+    readonly template: Skel;
+};
+type SkelBody = {
+    readonly tag: "seq";
+    readonly goals: readonly SkelGoal[];
+    readonly tail: SkelTail;
+} | {
+    readonly tag: "if";
+    readonly op: string;
+    readonly x: Skel;
+    readonly y: Skel;
+    readonly then: SkelBody;
+    readonly els: SkelBody;
+};
+interface SkelClause {
+    /** Number of clause-variable slots (the dispatch frame's length). */
+    readonly n: number;
+    /** Head argument skeletons (the head symbol is implied by the dispatch table). */
+    readonly lhsArgs: readonly Skel[];
+    readonly body: SkelBody;
+}
+/** Compile one answer-dependent recursive search group for query-directed dispatch. Independent
+ *  overlapping recursion stays on moded tabling and returns undefined, so the caller can use the full
+ *  compiler when the query needs another compiled fragment. */
+declare function compileDependentNondetGroup(env: MinEnv, root: string): CompiledFns | undefined;
+/** Compile every compilable pure single-clause function in `env` to a memoised native closure.
+ *  Phase 1 infers return types (fixpoint, optimistic over recursion). Phase 2 compiles bodies with
+ *  those types and drops any that fail end-to-end (a call to an uncompilable function fails too). */
+declare function compileEnv(env: MinEnv): CompiledFns;
+/** Run a compiled function, returning an ordered result bag, or `undefined` to fall back to the interpreter
+ *  when the call falls outside the proven subset. */
+declare function runCompiled(env: MinEnv, op: string, partAtoms: readonly Atom[], st: St, ops?: CompiledImpureOps, discard?: boolean, fuel?: number): CompiledRunResult | undefined;
+declare function runCompiledEffectCount(env: MinEnv, op: string, partAtoms: readonly Atom[], st: St, ops: CompiledImpureOps): {
+    readonly count: number;
+    readonly state: St;
+} | undefined;
+
+type TermId = number;
+type FactId = number;
+declare class Int32Chunks {
+    private readonly chunks;
+    private tail;
+    length: number;
+    push(value: number): number;
+    get(index: number): number;
+}
+declare function canCompactAtom(a: Atom): boolean;
+declare class FlatAtomSpaceTable {
+    readonly termKind: Int32Chunks;
+    readonly termStart: Int32Chunks;
+    readonly termLen: Int32Chunks;
+    readonly termHash: Int32Chunks;
+    readonly termGround: Int32Chunks;
+    readonly termData: Int32Chunks;
+    readonly factRoot: Int32Chunks;
+    readonly factHeadSym: Int32Chunks;
+    private slots;
+    private slotCount;
+    private missSlot;
+    private missHash;
+    private readonly symByName;
+    private readonly intNumberGrounds;
+    private readonly floatGrounds;
+    private readonly groundByKey;
+    private readonly varByName;
+    private readonly termFacts;
+    private readonly nestedHeadFacts;
+    private readonly symbols;
+    private readonly grounds;
+    private readonly vars;
+    private readonly decoded;
+    private readonly termIdOf;
+    get factCount(): number;
+    insertFact(atom: Atom): FactId;
+    factsForTerm(term: TermId): readonly FactId[];
+    insertAtom(atom: Atom): TermId;
+    private insertAtomUncached;
+    lookupAtom(atom: Atom): TermId | undefined;
+    private lookupAtomUncached;
+    decodeTerm(term: TermId): Atom;
+    private decodeTermUncached;
+    isTermGround(term: TermId): boolean;
+    headSymOf(term: TermId): number;
+    lookupHeadSym(name: string): number | undefined;
+    factsForNestedPattern(pattern: Atom): readonly FactId[] | undefined;
+    private internSym;
+    private internGround;
+    private lookupGround;
+    private internNumericGround;
+    private internGroundByKey;
+    private internVar;
+    private internLeaf;
+    private lookupLeaf;
+    private internExpr;
+    private lookupExpr;
+    private pushTerm;
+    private recordMiss;
+    private growSlots;
+}
+declare class FlatAtomSpace {
+    private readonly table;
+    private readonly ranges;
+    private readonly dead;
+    readonly liveCount: number;
+    readonly nonGroundCount: number;
+    private arr;
+    private constructor();
+    static empty(): FlatAtomSpace;
+    static fromAtoms(atoms: readonly Atom[]): FlatAtomSpace | undefined;
+    get size(): number;
+    /** Append a batch as new visible facts. Returns undefined when some atom is not flat-storable (a
+     *  grounded executor/matcher); the caller keeps such a batch on the plain log instead. */
+    appendAll(atoms: readonly Atom[]): FlatAtomSpace | undefined;
+    removeOne(atom: Atom): FlatAtomSpace;
+    exactCount(atom: Atom): number;
+    candidatesFor(patternHead: string | undefined, pattern?: Atom): Iterable<Atom>;
+    toArray(): Atom[];
+    /** Columnar mirror of the `&self` direct tally in eval.ts: over the visible facts the head filter
+     *  admits (head symbol `patternHead` or no symbol head, same filter as `candidatesFor`), count the
+     *  ones an all-distinct-variable pattern `(k $v..)` of `arity` items unifies with, without decoding
+     *  any fact. `iterated` is the admitted total (it advances the candidate counter). */
+    countHeadArity(patternHead: string, arity: number): {
+        count: number;
+        iterated: number;
+    };
+    roundTrip(atom: Atom): Atom;
+    private decodeFact;
+    private visibleFactIds;
+    private factVisible;
+}
+
+interface RangeEntry {
+    readonly value: Atom;
+    readonly occurrence: number;
+    readonly atom: Atom;
+}
+interface ArityColumn {
+    readonly total: number;
+    readonly entries: readonly RangeEntry[];
+}
+interface SortedColumn {
+    readonly functor: string;
+    readonly argPosition: number;
+    readonly totalCandidates: number;
+    readonly arities: ReadonlyMap<number, ArityColumn>;
+}
+
+interface FactIdView {
+    readonly count: number;
+    ids(): Iterable<number>;
+}
+/** Compact storage for static symbol-headed expression facts.
+ *
+ * Fact ids are the source positions passed to `fromAtoms`. Head keys use the evaluator's `headKey`
+ * format for the supported fact shape: the symbol name at expression position 0.
+ */
+declare class StaticCompactBase {
+    private readonly table;
+    private readonly headFacts;
+    readonly size: number;
+    private readonly columnCache;
+    private readonly factMemo;
+    private memoizeFactDecode;
+    private constructor();
+    /** Encode all atoms as facts 0..n-1. The batch is rejected if any fact is not compactable or is
+     *  not a symbol-headed expression. */
+    static fromAtoms(atoms: readonly Atom[]): StaticCompactBase | undefined;
+    factAtom(id: number): Atom;
+    /** Switch `factAtom` to per-fact memoized decoding: repeated reads of a fact return the identical
+     *  object. The evaluator wiring requires this (its evaluated-atoms and freshen caches key on object
+     *  identity); the unmemoized default keeps the standalone store's steady heap flat. */
+    enableDecodeMemo(): void;
+    /** Structural membership without decoding: whether some stored fact equals `atom`. The interned term
+     *  table gives each distinct term one id, so equality is an id lookup plus a per-term fact check. */
+    hasFact(atom: Atom): boolean;
+    /** Whether the functor stores two structurally identical facts. Interning makes duplicate facts share
+     *  one root term id, so this is a Set scan over the bucket's root ids, never a decode. */
+    hasDuplicateFacts(headKey: string): boolean;
+    factsForHead(headKey: string): FactIdView;
+    equalRange(headKey: string, argPos: number, value: Atom): readonly number[];
+    bucketSize(headKey: string, argPos: number, value: Atom): number;
+    numericRange(headKey: string, argPos: number, low: Atom | undefined, high: Atom | undefined, incLow: boolean, incHigh: boolean): readonly number[] | undefined;
+    private column;
+    private buildColumn;
+    private buildNumericColumn;
+    private buildKeyColumn;
+    private argumentTerm;
+    private termValue;
+    private equalNumeric;
+    private countEqualNumeric;
+    private filteredNumericIds;
+    private equalKeyed;
+    private countEqualKeyed;
+    private keyBounds;
+    private decodeTermFresh;
+}
+
+declare class StaticAtomStore {
+    private readonly slots;
+    private ids;
+    private base;
+    private arr;
+    get length(): number;
+    /** The compact base, when a compaction sweep installed one. */
+    get compactBase(): StaticCompactBase | undefined;
+    push(atom: Atom): void;
+    get(index: number): Atom;
+    /** Install the compaction result: `factIds[slot]` is the base fact id for compacted slots and
+     *  OBJECT_SLOT elsewhere. Compacted slots release their object references. */
+    adoptCompact(base: StaticCompactBase, factIds: Int32Array): void;
+    /** De-compaction for one functor: restore the given slots to plain object storage (the atoms are
+     *  decoded through the memoized base, so identity stays stable for anything already handed out). */
+    restoreSlots(slots: Int32Array): void;
+    /** Membership by structural equality. Object slots compare directly; compacted facts resolve through
+     *  the base's interned term table without decoding. */
+    hasAtom(atom: Atom): boolean;
+    /** `some` over the OBJECT slots only. Used by the custom-matcher scan: a compacted fact passed
+     *  `canCompactAtom`, so it cannot contain a custom grounded matcher and never satisfies that scan. */
+    someObject(predicate: (atom: Atom) => boolean): boolean;
+    [Symbol.iterator](): Iterator<Atom>;
+    /** Materialize the full slot-order list (the `get-atoms` / variable-headed-pattern enumeration).
+     *  Memoized until the store changes; callers must not mutate the result. */
+    toArray(): Atom[];
+}
+
+type TraceEvent = {
+    readonly kind: "reduce";
+    readonly atom: string;
+} | {
+    readonly kind: "grounded";
+    readonly op: string;
+} | {
+    readonly kind: "specialize";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly kind: "overflow";
+    readonly atom: string;
+};
+type TraceSink = (event: TraceEvent) => void;
+
+declare const TAG_ARITY = 0;
+declare const TAG_SYMBOL = 1;
+declare const TAG_NEWVAR = 2;
+declare const TAG_VARREF = 3;
+/** Interns symbols and grounded values to dense integer ids, with a reverse map so a flat atom decodes
+ *  back exactly. Symbols and grounds share the id space (a ground's id reconstructs the ground). */
+declare class Interner {
+    private readonly byKey;
+    private readonly entries;
+    private add;
+    internSym(name: string): number;
+    internGround(value: Ground): number;
+    /** The id for a symbol/ground if already interned, else undefined (a pattern symbol absent from the
+     *  KB can never match, so its lookup short-circuits). */
+    lookupSym(name: string): number | undefined;
+    lookupGround(value: Ground): number | undefined;
+    /** Reconstruct the atom for a leaf id. */
+    decodeLeaf(id: number): Atom;
+    get size(): number;
+}
+/** Encode an atom into the token array `out`, interning leaves. `varMap` assigns de Bruijn indices to
+ *  variable names (shared across one atom so repeated variables become VARREF). */
+declare function encodeInto(a: Atom, out: number[], it: Interner, varMap: Map<string, number>): void;
+/** Encode a single atom to a token array. */
+declare function encodeAtom(a: Atom, it: Interner): number[];
+/** Decode the token at `pos`, returning the atom and the position after it. Variables are reconstructed
+ *  with de Bruijn names `$0`, `$1`, … (so a decoded atom is alpha-equivalent to the original). */
+declare function decodeAt(tokens: Int32Array | number[], pos: number, it: Interner): [Atom, number];
+/** Decode a full token array to an atom. */
+declare function decodeAtom(tokens: Int32Array | number[], it: Interner): Atom;
+/** The number of tokens in the subterm starting at `pos`. */
+declare function subtermLen(tokens: Int32Array | number[], pos: number): number;
+/** Encode a query pattern using lookup (not interning): returns the tokens and the variable names in de
+ *  Bruijn order, or `null` if a pattern symbol/ground is absent from the interner (fast fail; it can
+ *  never match any stored fact). */
+declare function encodePattern(a: Atom, it: Interner): {
+    tokens: number[];
+    varNames: string[];
+} | null;
+/** One-sided match of an encoded pattern against an encoded ground fact in a (possibly shared) token
+ *  array. Returns the variable bindings (de Bruijn index -> the matched fact subterm's [start, end)
+ *  token range), or `null` on mismatch. Pure integer work over the token array, so a worker can run it
+ *  against a `SharedArrayBuffer`-backed `Int32Array` with no copying. */
+declare function matchFlatAt(pat: ArrayLike<number>, fact: Int32Array | number[], factStart: number): Map<number, [number, number]> | null;
+/** A flat, interned knowledge base: facts are appended as token runs into one array, indexed by head
+ *  functor id, and matched against an encoded pattern by integer scan. */
+declare class FlatKB {
+    readonly interner: Interner;
+    private readonly tokens;
+    private readonly byFunctor;
+    private readonly other;
+    private readonly offsets;
+    /** The token array (for packing into a SharedArrayBuffer). */
+    get tokenArray(): readonly number[];
+    /** Every fact's start offset, in insertion order (for sharding across workers). */
+    get factOffsets(): readonly number[];
+    /** Add a (typically ground) atom to the KB. */
+    add(a: Atom): void;
+    /** Candidate fact offsets for a pattern, using the functor index when the pattern head is a known
+     *  symbol; otherwise every fact. */
+    private candidates;
+    /** Match `pattern` against the KB, returning a binding map (variable name -> matched atom) per match. */
+    match(pattern: Atom): Array<Map<string, Atom>>;
+    get size(): number;
+}
+declare const _internals: {
+    tok: (tag: number, payload?: number) => number;
+    tagOf: (tok: number) => number;
+    payloadOf: (tok: number) => number;
+    subtermLen: typeof subtermLen;
+};
+
+interface TableKey {
+    readonly tokens: readonly number[];
+    readonly generation: number;
+}
+interface VariantAtomKey {
+    readonly tokens: readonly number[];
+    readonly varNames: readonly string[];
+    readonly canonicalMap: Map<string, string>;
+}
+interface EncodedAtomKey extends TableKey, VariantAtomKey {
+}
+/** Encode an atom for variant lookup without printing it. Variables are canonicalized by first occurrence. */
+declare function encodeVariantKey(a: Atom, interner: Interner): VariantAtomKey;
+declare class TokenTrie<V> {
+    private readonly root;
+    get(tokens: readonly number[]): V | undefined;
+    set(tokens: readonly number[], value: V): void;
+    delete(tokens: readonly number[]): boolean;
+    clear(): void;
+}
+interface CompletedTableEntry {
+    readonly numCallVars: number;
+    readonly results: readonly Atom[];
+    readonly answerCount: number;
+    readonly approxCells: number;
+}
+interface ActiveTableEntry {
+    readonly tokens: readonly number[];
+    readonly numCallVars: number;
+    readonly results: readonly Atom[];
+    readonly answerCount: number;
+    readonly approxCells: number;
+    cyclic: boolean;
+    overBudget: boolean;
+}
+interface TableBudget {
+    readonly maxCompletedEntries: number;
+    readonly maxCompletedAnswers: number;
+    readonly maxApproxCells: number;
+    readonly maxEntryCells: number;
+    readonly maxInternerLeaves: number;
+}
+type TableKeyKind = "ground" | "ground-distinct" | "moded";
+declare class TableSpace {
+    private readonly budget;
+    interner: Interner;
+    private generation;
+    private readonly completed;
+    private readonly active;
+    private readonly activeStack;
+    private head;
+    private tail;
+    private entries;
+    private answers;
+    private cells;
+    private activeCount;
+    private activeAnswers;
+    private activeCells;
+    constructor(budget?: TableBudget);
+    key(kind: TableKeyKind, call: Atom, runtimeVersion: number): EncodedAtomKey;
+    isCurrentKey(key: TableKey): boolean;
+    getCompleted(key: TableKey): CompletedTableEntry | undefined;
+    rememberCompleted(key: TableKey, numCallVars: number, results: readonly Atom[]): void;
+    beginActive(key: TableKey, numCallVars: number): ActiveTableEntry | null | undefined;
+    getActive(key: TableKey): ActiveTableEntry | undefined;
+    isTopActive(entry: ActiveTableEntry): boolean;
+    markCyclic(entry: ActiveTableEntry): void;
+    addActiveAnswers(entry: ActiveTableEntry, results: readonly Atom[]): number;
+    endActive(key: TableKey): void;
+    clear(): void;
+    private resetTables;
+    stats(): {
+        entries: number;
+        answers: number;
+        approxCells: number;
+    };
+    entryCellLimit(): number;
+    resourceBudget(): TableBudget;
+    private entryCost;
+    private touch;
+    private insertHead;
+    private unlink;
+    private remove;
+    private evict;
+    private makeRoomForActive;
+    private resetInternerAndTables;
+    private maybeResetInterner;
+}
+
+/** A grounded operation that runs asynchronously, for the async runner. */
+type AsyncGroundFn = (args: readonly Atom[]) => Promise<ReduceResult>;
+type HostImportFn = (space: Atom, file: Atom) => ReduceResult | Promise<ReduceResult>;
+/** Thrown when synchronous evaluation reaches an async grounded operation. Use the async runner. */
+declare class AsyncInSyncError extends Error {
+    constructor(op: string);
+}
+type Ret = "none" | "chain" | "function";
+interface Frame {
+    readonly atom: Atom;
+    readonly ret: Ret;
+    readonly vars: readonly string[];
+    readonly fin: boolean;
+}
+interface StackCons {
+    readonly head: Frame;
+    readonly tail: Stack;
+}
+type Stack = StackCons | null;
+interface Item {
+    readonly stack: Stack;
+    readonly bnd: Bindings;
+}
+interface MinEnv {
+    ruleIndex: Map<string, Array<[Atom, Atom]>>;
+    varRules: Array<[Atom, Atom]>;
+    varRulesVar: Array<[Atom, Atom]>;
+    sigs: Map<string, Atom[]>;
+    gt: GroundingTable;
+    /** Static `&self` atoms in insertion (occurrence) order. Slot-stable: the nested match index refers
+     *  to slots by occurrence id and `get-atoms` order is observable, so the compaction sweep swaps a
+     *  slot's storage without renumbering. */
+    atoms: StaticAtomStore;
+    types: Map<string, Atom[]>;
+    imports: Map<string, Atom[]>;
+    exprTypes: Array<[Atom, Atom]>;
+    /** Async grounded operations, dispatched by the async runner; empty for pure synchronous evaluation. */
+    agt: Map<string, AsyncGroundFn>;
+    /** Optional host-language import hook used by async `import!` for files outside the MeTTa import map. */
+    hostImport?: HostImportFn;
+    /** Optional opt-in execution trace sink. `undefined` when tracing is off, so emit sites cost one branch.
+     *  Always present (as `undefined` when off) to keep the env object's shape monomorphic on the hot path. */
+    trace?: TraceSink | undefined;
+    /** Per-runner `with-mutex` locks (a Promise chain per key), so mutexes do not leak across runners. */
+    mutexes: Map<string, Promise<void>>;
+    /** Optional per-run hash-cons table for immutable terms. */
+    intern?: InternTable;
+    /** Ground expressions already observed to reduce to themselves for the current rule set. */
+    evaluatedAtoms: WeakSet<Atom>;
+    factIndex: Map<string, Atom[]>;
+    argIndex: Map<string, Atom[]>;
+    nonGroundAtPos: Map<string, Atom[]>;
+    /** Internal static nested-head index. Optional so existing structural `MinEnv` values stay compatible. */
+    nestedMatchIndex?: StaticNestedMatchIndex | undefined;
+    varHeadedFacts: Atom[];
+    /** Automatic tabling storage: structural variant keys over token tries and bounded completed entries.
+     *  `undefined` when tabling is disabled. */
+    tableSpace?: TableSpace | undefined;
+    /** Positive only while an idempotent unique(collapse ...) consumer evaluates a proven-pure ground call. */
+    distinctGroundDepth?: number | undefined;
+    /** Functor names proven tabling-safe by `analyzePurity`; recomputed when equations change. */
+    pureFunctors?: Set<string>;
+    /** Functor names proven safe for MODED tabling by `analyzePurity(env, MODED_IMPURE_OPS)` — a superset of
+     *  `pureFunctors` (only `empty`, which is genuinely pure, is treated more permissively); recomputed
+     *  alongside it. */
+    modedPureFunctors?: Set<string>;
+    /** Pure functors whose rule SCC has branching recursion, so ground tabling is likely useful. */
+    tableWorth?: Set<string>;
+    /** Pure functors whose rule SCC has branching recursion under the moded purity rules. */
+    modedTableWorth?: Set<string>;
+    /** Set when equations changed and the purity/profitability analysis must be refreshed before evaluation. */
+    tablingDirty?: boolean | undefined;
+    /** Memo for `getTypes` of ground atoms: a ground atom's type is a pure function of the env's type tables,
+     *  which only change via `addAtomToEnv` (where this is reset). Keyed by atom identity, so the recursion
+     *  reuses the type of every shared subterm (a growing Peano/list term is the worst case otherwise). */
+    typeCache?: WeakMap<Atom, Atom[]> | undefined;
+    /** Optional parallel branch evaluator for `hyperpose` (set by a host worker pool). Given the formatted
+     *  branch atoms and whether to stop at the first result, returns each branch's result atoms, or `null` for
+     *  a branch that errored or (under firstOnly) lost the race. It re-evaluates each branch from the program's
+     *  rules in a worker, so it is only used when a branch is pure and the space carries no runtime additions,
+     *  so it is identical to evaluating in line. */
+    parEval?: (branchSrcs: string[], firstOnly: boolean) => (Atom[] | null)[];
+    /** Async host-worker equivalent, used by browser Web Workers and other non-blocking hosts. */
+    parEvalAsync?: (branchSrcs: string[], firstOnly: boolean) => Promise<(Atom[] | null)[]>;
+    /** Compiled pure deterministic functions (the int/bool functional core); undefined when disabled. */
+    compiled?: CompiledFns | undefined;
+    /** Set when an equation changed, so the compiler re-runs before the next query. */
+    compileDirty?: boolean | undefined;
+    /** False when `compiled` contains only query-directed dependent search groups. Undefined retains the
+     *  historical meaning for structural environments whose map was produced by `compileEnv`. */
+    compiledComplete?: boolean | undefined;
+    /** Opt-in trail-based matching (`experimental.trail`): the conjunctive `match` enumerates on a WAM-style
+     *  trail (zero per-solution allocation) instead of the immutable `Bindings`/`merge` threading. Off by
+     *  default; byte-identical to the reference matcher (differential-gated), falling back to it per query for
+     *  cases the trail cannot reproduce (custom grounded matchers). */
+    useTrail?: boolean;
+    /** Compact runtime `&self` atomspace. When on, runtime additions are stored as flat term ids and decoded
+     *  only when a query or observable operation needs tree atoms. */
+    useFlatAtomspace?: boolean;
+    /** Anchored-acyclic conjunctive matching (`experimental.conjNested`, on by default): a `(, ...)` whose
+     *  first goal is anchored by a ground argument and whose later goals are connected over a ground,
+     *  duplicate-free candidate domain runs through the source-ordered binding-aware nested loop (matchConj),
+     *  which probes the argument index per bound join variable instead of materializing every goal's full
+     *  relation for matchConjJoin's WCO. Differential-gated to matchConjJoin: same solution multiset and
+     *  multiplicity. Enumeration order can interleave differently when the anchor bucket is not grouped by
+     *  the join variable (MeTTa leaves query order unspecified — the MOPS workspace is a multiset); on
+     *  unique-entity-per-goal shapes the orders coincide, asserted by the differential suite.
+     *  Cyclic, unanchored, non-ground-fact, or duplicate-fact conjunctions stay on matchConjJoin. */
+    useConjNested?: boolean;
+    /** Ordered numeric single-column range matching (`experimental.rangeIndex`, on by default): a single
+     *  functor-headed all-variable pattern whose template is a pure nested `if` numeric range filter enumerates
+     *  the sorted numeric column slice instead of scanning the whole functor bucket. The selected slice is
+     *  restored to source order before yielding. */
+    useRangeIndex?: boolean;
+    /** Mark normal-form ground `match` results as already evaluated (`experimental.matchEvalMark`, on by
+     *  default) so the first consumer visit takes the existing evaluatedAtoms short-circuit. */
+    useMatchEvalMark?: boolean;
+    /** Answer a public-entry bare `(match &self pat templ)` straight from its match plan
+     *  (`experimental.directMatch`, on by default), skipping the generator driver, the worklist, and the
+     *  per-result reduce probe those would run. Guarded to the exact cases where that machinery is a
+     *  provable no-op; anything else declines to the general path. */
+    useDirectMatch?: boolean;
+    /** Lazily-computed set of head functors that have a duplicate ground fact. matchConjJoin's WCO trie dedups
+     *  duplicate relation tuples, so it collapses a conjunction over duplicate facts to one solution; the nested
+     *  loop preserves multiplicity. Only functors with no duplicate facts route to the nested loop, so the two
+     *  paths stay byte-identical. Computed once (conjNested only) from factIndex and cached here. */
+    duplicateFactHeadsCache?: Set<string> | undefined;
+    /** Compact static fact storage (`experimental.staticCompact`, on by default for buildEnv loads): large
+     *  all-ground flat-fact functors are swept into one shared StaticCompactBase; their slots, factIndex
+     *  buckets, and argIndex postings release the object forest, and candidates decode on demand through the
+     *  base's memoized decoder with sorted-column equality/range probes standing in for argIndex. */
+    staticBase?: StaticCompactBase;
+    /** Per-functor compaction metadata for `staticBase` (functors currently served by the compact base). */
+    compactHeads?: Map<string, CompactHeadMeta>;
+    /** Lazy ordered numeric column indexes for `experimental.rangeIndex`. Keyed by functor and argument
+     *  position; a `null` cache entry records a column that is not safely numeric, so later declined queries do
+     *  not rescan the fact bucket. */
+    numericRangeIndexCache?: Map<string, SortedColumn | null> | undefined;
+}
+interface StaticNestedMatchIndex {
+    /** Occurrence ids by functor, argument position, and nested expression head. */
+    readonly byHead: Map<string, number[]>;
+    /** Occurrence ids whose argument or argument head has a custom grounded matcher. */
+    readonly wildcardAtPos: Map<string, number[]>;
+    /** Root functors with a non-ground static fact. */
+    readonly nonGroundFactHeads: Set<string>;
+}
+/** Compaction metadata for one functor served by the shared StaticCompactBase. */
+interface CompactHeadMeta {
+    /** Fact count (the whole bucket, every arity). */
+    readonly count: number;
+    /** The facts' env.atoms slots, ascending (bucket insertion order). */
+    readonly slots: Int32Array;
+    /** The uniform expression arity (item count), or -1 when the bucket mixes arities. */
+    readonly arity: number;
+    /** Fact count per expression arity (the all-distinct-variable tally reads these without decoding). */
+    readonly arityCounts: ReadonlyMap<number, number>;
+    /** Distinct leaf symbol names across all argument positions; with the functor itself, these decide
+     *  whether a decoded fact is in normal form without decoding (isNormalForm on a flat ground fact
+     *  reduces to isDefinedHead over the head and its symbol leaves). */
+    readonly leafSyms: readonly string[];
+    /** Whether the bucket stores two structurally identical facts (the conjNested routing guard). */
+    readonly hasDup: boolean;
+}
+declare function setStaticCompactThresholdForTests(n: number): number;
+/** An empty environment for grounding table `gt`. Grow it with `addAtomToEnv`. */
+declare function emptyEnv(gt: GroundingTable): MinEnv;
+/** Register a sync grounded operation and invalidate analyses that may have classified its name. */
+declare function registerGroundedOperation(env: MinEnv, name: string, op: GroundFn): void;
+/** Register an async grounded operation and invalidate analyses that may have classified its name. */
+declare function registerAsyncGroundedOperation(env: MinEnv, name: string, op: AsyncGroundFn): void;
+declare function addAtomToEnv(env: MinEnv, x: Atom): void;
+declare function buildEnv(atoms: Atom[], gt: GroundingTable, staticCompact?: boolean): MinEnv;
+type NamedSpace = AtomLog;
+interface World {
+    spaces: Map<string, NamedSpace>;
+    store: Map<number, Atom>;
+    tokens: Map<string, Atom>;
+    selfExtra: AtomLog;
+    flatSelfExtra: FlatAtomSpace | undefined;
+    selfRules: Map<string, Array<[Atom, Atom]>>;
+    selfVarRules: ReadonlyArray<[Atom, Atom]>;
+    selfRuleVersion: number;
+    removedStatic: AtomLog;
+    removedStaticHeads: ReadonlySet<string>;
+    removedStaticVarRules: boolean;
+    maxStackDepth: number;
+}
+interface St {
+    counter: number;
+    world: World;
+}
+declare const initSt: () => St;
+declare function freshenRule(counter: number, lhs: Atom, rhs: Atom): [Atom, Atom];
+declare function getTypes(env: MinEnv, a: Atom): Atom[];
+declare function checkApplication(env: MinEnv, w: World, op: string, args: readonly Atom[], opSig?: Atom[] | undefined): Atom | null;
+declare function mettaEval(env: MinEnv, fuel: number, st: St, bnd: Bindings, a: Atom): [Array<[Atom, Bindings]>, St];
+/** Async type-directed evaluation: awaits async grounded operations (`env.agt`). An optional `signal`
+ *  makes it cancellable (used by `race` to stop losing branches). */
+declare function mettaEvalAsync(env: MinEnv, fuel: number, st: St, bnd: Bindings, a: Atom, signal?: AbortSignal): Promise<[Array<[Atom, Bindings]>, St]>;
+/** Evaluate `atom` (i.e. interpret `(eval atom)`) under `env`, returning the result atoms. */
+declare function evalAtom(env: MinEnv, atom: Atom, st?: St, fuel?: number): [Atom[], St];
+
+interface HostInterop {
+    readonly name: string;
+    readonly prelude?: string;
+    readonly asyncOps?: ReadonlyMap<string, AsyncGroundFn>;
+    readonly hostImport?: HostImportFn;
+    dispose?(): Promise<void> | void;
+}
+type HostTextLoader = (path: string, from?: string) => Promise<string>;
+interface ComposeHostInteropsOptions {
+    readonly allowDuplicateAsyncOps?: boolean;
+}
+declare function composeHostInterops(interops: readonly HostInterop[], options?: ComposeHostInteropsOptions): HostInterop;
+
+export { type TableKey as $, type Atom as A, type Bindings as B, type CompiledFns as C, type ReduceResult as D, type EncodedAtomKey as E, FlatKB as F, type GndAtom as G, type HostImportFn as H, type InternTable as I, type Ret as J, type SkelBody as K, type SkelClause as L, type MinEnv as M, type SkelGoal as N, type SkelTail as O, type St as P, type Stack as Q, type ReduceEffect as R, type Skel as S, type TraceSink as T, type StackCons as U, type SymAtom as V, TAG_ARITY as W, TAG_NEWVAR as X, TAG_SYMBOL as Y, TAG_VARREF as Z, type TableBudget as _, type AsyncGroundFn as a, internBuiltExpr as a$, type TableKeyKind as a0, TableSpace as a1, TokenTrie as a2, type TraceEvent as a3, type ValRel as a4, type VarAtom as a5, type VariantAtomKey as a6, type World as a7, _internals as a8, addAtomToEnv as a9, encodeInto as aA, encodePattern as aB, encodeVariantKey as aC, eqRelations as aD, evalAtom as aE, expr as aF, freshenRule as aG, fromRelations as aH, gbool as aI, getTypes as aJ, gfloat as aK, gint as aL, gnd as aM, groundEq as aN, groundType as aO, groundedOperationType as aP, gstr as aQ, gunit as aR, hasEq as aS, hasLoop as aT, hasLoopFromBase as aU, hashOf as aV, initSt as aW, intAbs as aX, intDiv as aY, intMod as aZ, internAtom as a_, addEqRaw as aa, addInt as ab, addValRaw as ac, atomEq as ad, atomSize as ae, atomVars as af, baseTable as ag, buildEnv as ah, callGrounded as ai, canCompactAtom as aj, canInternExprItems as ak, canonInt as al, checkApplication as am, cmpIntVal as an, collectVars as ao, compareNumbers as ap, compileDependentNondetGroup as aq, compileEnv as ar, composeHostInterops as as, createInternTable as at, decodeAt as au, decodeAtom as av, emptyBindings as aw, emptyEnv as ax, emptyExpr as ay, encodeAtom as az, type ActiveTableEntry as b, internExpr as b0, isEmpty as b1, isErrorAtom as b2, isExpr as b3, isGnd as b4, isSym as b5, isTableSafeGroundedOp as b6, isVar as b7, isZero as b8, lookupVal as b9, toF64 as bA, valEntries as bB, variable as bC, makeEqRel as ba, makeValRel as bb, matchFlatAt as bc, metaType as bd, mettaEval as be, mettaEvalAsync as bf, mixHash as bg, mulInt as bh, pettaOpNames as bi, prependValRaw as bj, registerAsyncGroundedOperation as bk, registerGroundedOperation as bl, relations as bm, removeVal as bn, runCompiled as bo, runCompiledEffectCount as bp, setHostEffectsEnabled as bq, setOutputSink as br, setRawSink as bs, setStaticCompactThresholdForTests as bt, size as bu, someVal as bv, stdTable as bw, strHash as bx, subInt as by, sym as bz, AsyncInSyncError as c, BAIL as d, type BindingRel as e, type CompiledHolder as f, type CompiledImpureOps as g, type CompiledRunResult as h, type CompletedTableEntry as i, type ComposeHostInteropsOptions as j, type EqRel as k, type ExprAtom as l, FlatAtomSpace as m, FlatAtomSpaceTable as n, type Frame as o, type Ground as p, type GroundFn as q, type GroundedExec as r, type GroundedMatch as s, type GroundingTable as t, type HostInterop as u, type HostTextLoader as v, type IntVal as w, Interner as x, type Item as y, type MetaType as z };