@metta-ts/core 1.0.0

package/dist/index.js

@@ -0,0 +1,4777 @@
+// src/number.ts
+var MAX = BigInt(Number.MAX_SAFE_INTEGER);
+var MIN = BigInt(Number.MIN_SAFE_INTEGER);
+function canonInt(n) {
+  if (typeof n === "bigint") return n >= MIN && n <= MAX ? Number(n) : n;
+  return n;
+}
+function addInt(x, y) {
+  if (typeof x === "number" && typeof y === "number") {
+    const r = x + y;
+    return Number.isSafeInteger(r) ? r : canonInt(BigInt(x) + BigInt(y));
+  }
+  return canonInt(BigInt(x) + BigInt(y));
+}
+function subInt(x, y) {
+  if (typeof x === "number" && typeof y === "number") {
+    const r = x - y;
+    return Number.isSafeInteger(r) ? r : canonInt(BigInt(x) - BigInt(y));
+  }
+  return canonInt(BigInt(x) - BigInt(y));
+}
+function mulInt(x, y) {
+  if (typeof x === "number" && typeof y === "number") {
+    const r = x * y;
+    return Number.isSafeInteger(r) ? r : canonInt(BigInt(x) * BigInt(y));
+  }
+  return canonInt(BigInt(x) * BigInt(y));
+}
+function intDiv(x, y) {
+  if (typeof x === "number" && typeof y === "number") return Math.trunc(x / y);
+  return canonInt(BigInt(x) / BigInt(y));
+}
+function intMod(x, y) {
+  if (typeof x === "number" && typeof y === "number") return x % y;
+  return canonInt(BigInt(x) % BigInt(y));
+}
+function intAbs(n) {
+  if (typeof n === "bigint") return n < 0n ? -n : n;
+  return Math.abs(n);
+}
+function isZero(n) {
+  return typeof n === "bigint" ? n === 0n : n === 0;
+}
+function toF64(n) {
+  return typeof n === "bigint" ? Number(n) : n;
+}
+function cmpIntVal(a, b) {
+  if (typeof a === "bigint" || typeof b === "bigint") {
+    const x = BigInt(a);
+    const y = BigInt(b);
+    return x < y ? -1 : x > y ? 1 : 0;
+  }
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/atom.ts
+function groundEq(a, b) {
+  if (a.g !== b.g) return false;
+  switch (a.g) {
+    case "int":
+    case "float":
+      return a.n === b.n;
+    case "str":
+      return a.s === b.s;
+    case "bool":
+      return a.b === b.b;
+    case "unit":
+      return true;
+    case "error":
+      return a.msg === b.msg;
+    case "ext": {
+      const e = b;
+      return a.kind === e.kind && a.id === e.id;
+    }
+  }
+}
+var SYM_INTERN = /* @__PURE__ */ new Map();
+function sym(name) {
+  let s = SYM_INTERN.get(name);
+  if (s === void 0) {
+    s = {
+      kind: "sym",
+      name,
+      items: void 0,
+      value: void 0,
+      typ: void 0,
+      exec: void 0,
+      match: void 0,
+      ground: true
+    };
+    SYM_INTERN.set(name, s);
+  }
+  return s;
+}
+function variable(name) {
+  return {
+    kind: "var",
+    name,
+    items: void 0,
+    value: void 0,
+    typ: void 0,
+    exec: void 0,
+    match: void 0,
+    ground: false
+  };
+}
+function expr(items) {
+  let ground = true;
+  for (const it of items)
+    if (!it.ground) {
+      ground = false;
+      break;
+    }
+  return {
+    kind: "expr",
+    name: void 0,
+    items,
+    value: void 0,
+    typ: void 0,
+    exec: void 0,
+    match: void 0,
+    ground
+  };
+}
+function groundType(v) {
+  switch (v.g) {
+    case "int":
+    case "float":
+      return sym("Number");
+    case "str":
+      return sym("String");
+    case "bool":
+      return sym("Bool");
+    default:
+      return sym("Grounded");
+  }
+}
+function gnd(value, typ = groundType(value), exec, match) {
+  return { kind: "gnd", name: void 0, items: void 0, value, typ, exec, match, ground: true };
+}
+var gint = (n) => gnd({ g: "int", n: canonInt(n) });
+var gfloat = (n) => gnd({ g: "float", n });
+var gstr = (s) => gnd({ g: "str", s });
+var gbool = (b) => gnd({ g: "bool", b });
+var gunit = gnd({ g: "unit" });
+function metaType(a) {
+  switch (a.kind) {
+    case "sym":
+      return "Symbol";
+    case "var":
+      return "Variable";
+    case "expr":
+      return "Expression";
+    case "gnd":
+      return "Grounded";
+  }
+}
+var exprHashCache = /* @__PURE__ */ new WeakMap();
+var mixHash = (h, x) => {
+  h = Math.imul(h ^ x, 2654435761);
+  return (h ^ h >>> 15) >>> 0;
+};
+var strHash = (s) => {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) h = Math.imul(h ^ s.charCodeAt(i), 16777619);
+  return h >>> 0;
+};
+function groundHash(g) {
+  switch (g.g) {
+    case "int":
+      return strHash("i" + g.n.toString());
+    case "float":
+      return strHash("f" + g.n.toString());
+    case "str":
+      return strHash("s" + g.s);
+    case "bool":
+      return g.b ? 1 : 2;
+    case "unit":
+      return 3;
+    case "error":
+      return strHash("e" + g.msg);
+    case "ext":
+      return strHash("x" + g.kind + "\0" + g.id);
+  }
+}
+function hashOf(a) {
+  switch (a.kind) {
+    case "sym":
+      return mixHash(1398361410, strHash(a.name));
+    // tag "SYMB"
+    case "var":
+      return mixHash(1447121474, strHash(a.name));
+    // tag "VARB"
+    case "gnd":
+      return mixHash(1196311620, groundHash(a.value));
+    // tag "GNDD"
+    case "expr": {
+      const cached = exprHashCache.get(a);
+      if (cached !== void 0) return cached;
+      let acc = 1163415634;
+      acc = mixHash(acc, a.items.length);
+      for (const it of a.items) acc = mixHash(acc, hashOf(it));
+      exprHashCache.set(a, acc);
+      return acc;
+    }
+  }
+}
+function atomSize(a) {
+  if (a.kind === "expr") {
+    let n = 1;
+    for (const it of a.items) n += atomSize(it);
+    return n;
+  }
+  return 1;
+}
+function atomVars(a, out = []) {
+  collectVars(a, out, new Set(out));
+  return out;
+}
+function collectVars(a, out, seen) {
+  if (a.ground) return;
+  switch (a.kind) {
+    case "var":
+      if (!seen.has(a.name)) {
+        seen.add(a.name);
+        out.push(a.name);
+      }
+      break;
+    case "expr":
+      for (const it of a.items) collectVars(it, out, seen);
+      break;
+    default:
+      break;
+  }
+}
+var emptyExpr = expr([]);
+function isErrorAtom(a) {
+  return a.kind === "expr" && a.items.length >= 1 && a.items[0].kind === "sym" && a.items[0].name === "Error";
+}
+var isExpr = (a) => a.kind === "expr";
+var isVar = (a) => a.kind === "var";
+var isSym = (a) => a.kind === "sym";
+var isGnd = (a) => a.kind === "gnd";
+function atomEq(a, b) {
+  if (a === b) return true;
+  if (a.kind !== b.kind) return false;
+  switch (a.kind) {
+    case "sym":
+      return false;
+    // interned: a !== b means different symbols
+    case "var":
+      return a.name === b.name;
+    case "gnd":
+      return groundEq(a.value, b.value);
+    case "expr": {
+      const bi = b.items;
+      if (a.items.length !== bi.length) return false;
+      for (let i = 0; i < a.items.length; i++) {
+        const ai = a.items[i];
+        const bii = bi[i];
+        if (!atomEq(ai, bii)) return false;
+      }
+      return true;
+    }
+  }
+}
+
+// src/tokenizer.ts
+var Tokenizer = class {
+  entries = [];
+  /** Register a (regex, constructor). Order matters: the first matching pattern wins. */
+  register(re, make) {
+    this.entries.push({ re, make });
+  }
+  /** A grounded atom for `token`, or undefined if no pattern matches (caller falls back to Symbol). */
+  tokenize(token) {
+    for (const e of this.entries) if (e.re.test(token)) return e.make(token);
+    return void 0;
+  }
+};
+
+// src/parser.ts
+var isWs = (c) => /\s/.test(c);
+var isDelim = (c) => c === "(" || c === ")" || c === '"' || c === ";" || isWs(c);
+var Cursor = class {
+  constructor(s, tk) {
+    this.s = s;
+    this.tk = tk;
+  }
+  s;
+  tk;
+  pos = 0;
+  done() {
+    return this.pos >= this.s.length;
+  }
+  peek() {
+    return this.s[this.pos];
+  }
+  skipTrivia() {
+    while (!this.done()) {
+      const c = this.peek();
+      if (isWs(c)) {
+        this.pos++;
+        continue;
+      }
+      if (c === ";") {
+        while (!this.done() && this.peek() !== "\n") this.pos++;
+        continue;
+      }
+      break;
+    }
+  }
+};
+function readString(c) {
+  c.pos++;
+  let out = "";
+  while (!c.done() && c.peek() !== '"') {
+    if (c.peek() === "\\" && c.pos + 1 < c.s.length) {
+      const next = c.s[c.pos + 1];
+      if (next === "u" && c.pos + 6 <= c.s.length) {
+        const hex = c.s.slice(c.pos + 2, c.pos + 6);
+        if (/^[0-9a-fA-F]{4}$/.test(hex)) {
+          out += String.fromCharCode(parseInt(hex, 16));
+          c.pos += 6;
+          continue;
+        }
+      }
+      out += next === "n" ? "\n" : next === "t" ? "	" : next === "r" ? "\r" : next === "b" ? "\b" : next === "f" ? "\f" : next;
+      c.pos += 2;
+      continue;
+    }
+    out += c.peek();
+    c.pos++;
+  }
+  if (c.done()) throw new Error("unterminated string literal in MeTTa source");
+  c.pos++;
+  return gstr(out);
+}
+var MAX_DEPTH = 4096;
+function readWord(c) {
+  let out = "";
+  while (!c.done() && !isDelim(c.peek())) {
+    out += c.peek();
+    c.pos++;
+  }
+  return out;
+}
+function readAtom(c, depth = 0) {
+  c.skipTrivia();
+  const ch = c.peek();
+  if (ch === "(") {
+    if (depth >= MAX_DEPTH) throw new Error("MeTTa expression nesting too deep");
+    c.pos++;
+    const items = [];
+    for (; ; ) {
+      c.skipTrivia();
+      if (c.done()) throw new Error("unbalanced '(' in MeTTa source");
+      if (c.peek() === ")") {
+        c.pos++;
+        break;
+      }
+      items.push(readAtom(c, depth + 1));
+    }
+    return expr(items);
+  }
+  if (ch === '"') return readString(c);
+  const word = readWord(c);
+  if (word.startsWith("$")) return variable(word.slice(1));
+  return c.tk.tokenize(word) ?? sym(word);
+}
+function readTop(c) {
+  let bang = false;
+  if (c.peek() === "!") {
+    bang = true;
+    c.pos++;
+    c.skipTrivia();
+  }
+  return { atom: readAtom(c), bang };
+}
+function parseTop(src, tk) {
+  const c = new Cursor(src, tk);
+  c.skipTrivia();
+  return c.done() ? void 0 : readTop(c);
+}
+function parse(src, tk) {
+  return parseTop(src, tk)?.atom;
+}
+function parseAll(src, tk) {
+  const c = new Cursor(src, tk);
+  const out = [];
+  for (; ; ) {
+    c.skipTrivia();
+    if (c.done()) break;
+    out.push(readTop(c));
+  }
+  return out;
+}
+function format(a) {
+  if (isExpr(a)) return "(" + a.items.map(format).join(" ") + ")";
+  if (isVar(a)) return "$" + a.name;
+  if (isSym(a)) return a.name;
+  if (isGnd(a)) {
+    const v = a.value;
+    switch (v.g) {
+      case "int":
+        return String(v.n);
+      case "float":
+        return Number.isInteger(v.n) ? v.n.toFixed(1) : String(v.n);
+      case "str":
+        return JSON.stringify(v.s);
+      case "bool":
+        return v.b ? "True" : "False";
+      case "unit":
+        return "()";
+      case "error":
+        return v.msg;
+      case "ext":
+        return v.id;
+    }
+  }
+  return "?";
+}
+
+// src/bindings.ts
+var emptyBindings = [];
+var valRel = (x, a) => ({ tag: "val", x, a, y: void 0 });
+var eqRel = (x, y) => ({ tag: "eq", x, a: void 0, y });
+function lookupVal(b, x) {
+  for (const r of b) if (r.tag === "val" && r.x === x) return r.a;
+  return void 0;
+}
+function removeVal(b, x) {
+  return b.filter((r) => !(r.tag === "val" && r.x === x));
+}
+function hasLoop(b) {
+  for (const r of b) {
+    if (r.tag === "val" && r.a.kind === "var" && r.a.name === r.x) return true;
+    if (r.tag === "eq" && r.x === r.y) return true;
+  }
+  return false;
+}
+function addValRaw(b, x, a) {
+  return [valRel(x, a), ...removeVal(b, x)];
+}
+function addEqRaw(b, x, y) {
+  return x === y ? b : [eqRel(x, y), ...b];
+}
+
+// src/match.ts
+function suffixVars(a, suffix) {
+  if (a.ground) return a;
+  if (a.kind === "var") return variable(a.name + suffix);
+  if (a.kind === "expr") {
+    const its = a.items;
+    let items = null;
+    for (let i = 0; i < its.length; i++) {
+      const r = suffixVars(its[i], suffix);
+      if (items !== null) items.push(r);
+      else if (r !== its[i]) {
+        items = its.slice(0, i);
+        items.push(r);
+      }
+    }
+    return items === null ? a : { ...a, items };
+  }
+  return a;
+}
+function occursThrough(target, a, rels, b, seen) {
+  if (a.ground) return false;
+  if (a.kind === "var") {
+    if (a.name === target) return true;
+    if (seen.has(a.name)) return false;
+    seen.add(a.name);
+    const nv = lookupVal(rels, a.name) ?? lookupVal(b, a.name);
+    return nv !== void 0 && occursThrough(target, nv, rels, b, seen);
+  }
+  if (a.kind === "expr") return a.items.some((it) => occursThrough(target, it, rels, b, seen));
+  return false;
+}
+function reconcile(b, l, r) {
+  const out = [];
+  for (const mb of matchAtoms(l, r)) {
+    if (mb.some((rel) => rel.tag === "val" && occursThrough(rel.x, rel.a, mb, b, /* @__PURE__ */ new Set())))
+      continue;
+    for (const m of merge(b, mb)) out.push(m);
+  }
+  return out;
+}
+function addVarBinding(b, x, v) {
+  const prev = lookupVal(b, x);
+  if (prev === void 0) return [addValRaw(b, x, v)];
+  if (atomEq(prev, v)) return [b];
+  return reconcile(b, prev, v);
+}
+function addVarEquality(b, x, y) {
+  const vx = lookupVal(b, x);
+  const vy = lookupVal(b, y);
+  if (vx === void 0 || vy === void 0 || atomEq(vx, vy)) return [addEqRaw(b, x, y)];
+  return reconcile(b, vx, vy);
+}
+function mergeOne(bs, r) {
+  const out = [];
+  for (const b of bs) {
+    const ext = r.tag === "val" ? addVarBinding(b, r.x, r.a) : addVarEquality(b, r.x, r.y);
+    for (const e of ext) out.push(e);
+  }
+  return out;
+}
+function merge(a, b) {
+  let acc = [a];
+  for (const r of b) acc = mergeOne(acc, r);
+  return acc;
+}
+function matchAtomsWith(custom, l, r, leftSuffix = "") {
+  if (l.kind === "sym" && r.kind === "sym") return l.name === r.name ? [[]] : [];
+  if (l.kind === "var" && r.kind === "var") {
+    const lx = l.name + leftSuffix;
+    return lx === r.name ? [[]] : [[{ tag: "val", x: lx, a: r, y: void 0 }]];
+  }
+  if (l.kind === "var") return [[{ tag: "val", x: l.name + leftSuffix, a: r, y: void 0 }]];
+  if (r.kind === "var")
+    return [
+      [
+        {
+          tag: "val",
+          x: r.name,
+          a: leftSuffix === "" ? l : suffixVars(l, leftSuffix),
+          y: void 0
+        }
+      ]
+    ];
+  if (l.kind === "expr" && r.kind === "expr")
+    return matchAll(custom, [[]], l.items, r.items, leftSuffix);
+  if (l.kind === "gnd") return matchGrounded(custom, l, r);
+  if (r.kind === "gnd") return matchGrounded(custom, r, l);
+  return atomEq(l, r) ? [[]] : [];
+}
+function matchGrounded(custom, g, other) {
+  if (g.kind === "gnd" && g.match !== void 0) return g.match(other);
+  if (custom !== void 0) return custom(g, other);
+  return atomEq(g, other) ? [[]] : [];
+}
+function matchAll(custom, acc, xs, ys, leftSuffix = "") {
+  if (xs.length !== ys.length) return [];
+  let cur = acc;
+  for (let i = 0; i < xs.length; i++) {
+    const subs = matchAtomsWith(custom, xs[i], ys[i], leftSuffix);
+    const next = [];
+    for (const a of cur) for (const b of subs) for (const m of merge(a, b)) next.push(m);
+    cur = next;
+    if (cur.length === 0) break;
+  }
+  return cur;
+}
+function matchAtoms(l, r) {
+  return matchAtomsWith(void 0, l, r);
+}
+function matchAtomsScoped(l, r, suffix) {
+  return matchAtomsWith(void 0, l, r, suffix);
+}
+
+// src/substitution.ts
+var emptySubst = [];
+function lookupSubst(s, x) {
+  for (const [k, v] of s) if (k === x) return v;
+  return void 0;
+}
+function eraseSubst(s, x) {
+  return s.filter((p) => p[0] !== x);
+}
+function extendSubst(s, x, a) {
+  return [[x, a], ...eraseSubst(s, x)];
+}
+function applySubst(s, a) {
+  if (a.ground) return a;
+  if (s.length === 0) return a;
+  switch (a.kind) {
+    case "var":
+      return lookupSubst(s, a.name) ?? a;
+    case "expr": {
+      const its = a.items;
+      let items = null;
+      for (let i = 0; i < its.length; i++) {
+        const it = its[i];
+        const r = applySubst(s, it);
+        if (items !== null) items.push(r);
+        else if (r !== it) {
+          items = its.slice(0, i);
+          items.push(r);
+        }
+      }
+      return items === null ? a : { ...a, items };
+    }
+    default:
+      return a;
+  }
+}
+function occurs(x, a) {
+  if (a.ground) return false;
+  switch (a.kind) {
+    case "var":
+      return x === a.name;
+    case "expr":
+      return a.items.some((it) => occurs(x, it));
+    default:
+      return false;
+  }
+}
+
+// src/instantiate.ts
+function bindingsToSubst(b) {
+  const out = [];
+  for (const r of b) if (r.tag === "val") out.push([r.x, r.a]);
+  return out;
+}
+function instantiate(b, a, suffix = "") {
+  if (a.kind === "var") {
+    if (suffix === "") return b.length === 0 ? a : lookupVal(b, a.name) ?? a;
+    const name = a.name + suffix;
+    return lookupVal(b, name) ?? variable(name);
+  }
+  if (a.ground || a.kind !== "expr") return a;
+  if (b.length === 0 && suffix === "") return a;
+  const its = a.items;
+  let items = null;
+  for (let i = 0; i < its.length; i++) {
+    const it = its[i];
+    const r = instantiate(b, it, suffix);
+    if (items !== null) items.push(r);
+    else if (r !== it) {
+      items = its.slice(0, i);
+      items.push(r);
+    }
+  }
+  return items === null ? a : { ...a, items };
+}
+
+// src/pmap.ts
+var BITS = 5;
+var WIDTH = 1 << BITS;
+var MASK = WIDTH - 1;
+var DEPTH = 7;
+var emptyPMap = null;
+function keyHash(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) h = Math.imul(h ^ s.charCodeAt(i), 16777619);
+  return h >>> 0;
+}
+var isBranch = (n) => Array.isArray(n);
+function pmGet(map, key) {
+  let node = map;
+  let h = keyHash(key);
+  for (let level = 0; level < DEPTH && isBranch(node); level++) {
+    node = node[h & MASK] ?? null;
+    h >>>= BITS;
+  }
+  if (node === null || isBranch(node)) return void 0;
+  if (node.kind === "leaf") return node.key === key ? node.val : void 0;
+  for (const e of node.entries) if (e.key === key) return e.val;
+  return void 0;
+}
+var newBranch = () => new Array(WIDTH).fill(null);
+function setLeaf(node, key, val) {
+  if (node === null) return val === void 0 ? null : { kind: "leaf", key, val };
+  if (isBranch(node)) return node;
+  if (node.kind === "leaf") {
+    if (node.key === key) return val === void 0 ? null : { kind: "leaf", key, val };
+    if (val === void 0) return node;
+    return { kind: "collision", entries: [node, { kind: "leaf", key, val }] };
+  }
+  const kept = node.entries.filter((e) => e.key !== key);
+  if (val !== void 0) kept.push({ kind: "leaf", key, val });
+  if (kept.length === 0) return null;
+  if (kept.length === 1) return kept[0];
+  return { kind: "collision", entries: kept };
+}
+function pmSet(map, key, val) {
+  const h = keyHash(key);
+  const go = (node, level) => {
+    if (level >= DEPTH) return setLeaf(node, key, val);
+    const idx = h >>> level * BITS & MASK;
+    if (node === null) {
+      if (val === void 0) return null;
+      const b = newBranch();
+      b[idx] = go(null, level + 1);
+      return b;
+    }
+    if (!isBranch(node)) return setLeaf(node, key, val);
+    const child = go(node[idx] ?? null, level + 1);
+    if (child === (node[idx] ?? null)) return node;
+    const copy = node.slice();
+    copy[idx] = child;
+    return copy;
+  };
+  return go(map, 0);
+}
+
+// src/atomlog.ts
+var idxAdd = (idx, atom) => {
+  const key = String(hashOf(atom));
+  const bucket = pmGet(idx, key) ?? [];
+  const i = bucket.findIndex((e) => atomEq(e.atom, atom));
+  const next = i < 0 ? [...bucket, { atom, count: 1 }] : bucket.map((e, j) => j === i ? { atom: e.atom, count: e.count + 1 } : e);
+  return pmSet(idx, key, next);
+};
+var idxCount = (idx, atom) => {
+  const bucket = pmGet(idx, String(hashOf(atom)));
+  if (bucket === void 0) return 0;
+  for (const e of bucket) if (atomEq(e.atom, atom)) return e.count;
+  return 0;
+};
+var emptyLog = null;
+var logSize = (log) => log === null ? 0 : log.size;
+var logGroundIdx = (log) => log === null ? emptyPMap : log.groundIdx;
+var logNonGround = (log) => log === null ? 0 : log.nonGround;
+var logAppend = (log, atom) => ({
+  atom,
+  prev: log,
+  size: (log === null ? 0 : log.size) + 1,
+  groundIdx: atom.ground ? idxAdd(logGroundIdx(log), atom) : logGroundIdx(log),
+  nonGround: (log === null ? 0 : log.nonGround) + (atom.ground ? 0 : 1)
+});
+function logAppendAll(log, atoms) {
+  let out = log;
+  for (const a of atoms) out = logAppend(out, a);
+  return out;
+}
+function logToArray(log) {
+  const n = logSize(log);
+  const out = new Array(n);
+  let i = n - 1;
+  for (let p = log; p !== null; p = p.prev) out[i--] = p.atom;
+  return out;
+}
+var logFromArray = (atoms) => logAppendAll(emptyLog, atoms);
+
+// src/wcojoin.ts
+function allVars(rels) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of rels)
+    for (const v of r.vars)
+      if (!seen.has(v)) {
+        seen.add(v);
+        out.push(v);
+      }
+  return out;
+}
+function wcoJoin(rels, key, varOrder) {
+  const order = varOrder ?? allVars(rels);
+  const relInfos = rels.map((r) => {
+    const relVars = order.filter((v) => r.vars.includes(v));
+    const root = /* @__PURE__ */ new Map();
+    tuple: for (const t of r.tuples) {
+      let node = root;
+      for (const v of relVars) {
+        const val = t.get(v);
+        if (val === void 0) continue tuple;
+        const k = key(val);
+        let e = node.get(k);
+        if (e === void 0) {
+          e = { val, child: /* @__PURE__ */ new Map() };
+          node.set(k, e);
+        }
+        node = e.child;
+      }
+    }
+    return { relVars, root };
+  });
+  const participants = order.map(
+    (v) => relInfos.map((ri, r) => ri.relVars.includes(v) ? r : -1).filter((r) => r >= 0)
+  );
+  const out = [];
+  const partial = /* @__PURE__ */ new Map();
+  const cursors = relInfos.map((ri) => ri.root);
+  const recurse = (i) => {
+    if (i === order.length) {
+      out.push(new Map(partial));
+      return;
+    }
+    const parts = participants[i];
+    if (parts.length === 0) return;
+    let smallest = parts[0];
+    for (const r of parts) if (cursors[r].size < cursors[smallest].size) smallest = r;
+    const v = order[i];
+    for (const [k, entry] of cursors[smallest]) {
+      const advanced = [];
+      let ok2 = true;
+      for (const r of parts) {
+        const e = cursors[r].get(k);
+        if (e === void 0) {
+          ok2 = false;
+          break;
+        }
+        advanced.push([r, e.child]);
+      }
+      if (!ok2) continue;
+      const saved = advanced.map(([r]) => [r, cursors[r]]);
+      for (const [r, child] of advanced) cursors[r] = child;
+      partial.set(v, entry.val);
+      recurse(i + 1);
+      for (const [r, c] of saved) cursors[r] = c;
+    }
+    partial.delete(v);
+  };
+  recurse(0);
+  return out;
+}
+
+// src/alpha.ts
+function canonicalize(a, map) {
+  switch (a.kind) {
+    case "var": {
+      let c = map.get(a.name);
+      if (c === void 0) {
+        c = "%" + String(map.size);
+        map.set(a.name, c);
+      }
+      return variable(c);
+    }
+    case "expr":
+      return expr(a.items.map((x) => canonicalize(x, map)));
+    default:
+      return a;
+  }
+}
+function alphaEq(a, b) {
+  return atomEq(canonicalize(a, /* @__PURE__ */ new Map()), canonicalize(b, /* @__PURE__ */ new Map()));
+}
+
+// src/builtins.ts
+var parseTokenizer;
+function makeTokenizer() {
+  if (parseTokenizer === void 0) {
+    const t = new Tokenizer();
+    t.register(/^-?\d+$/, (s) => gint(BigInt(s)));
+    t.register(/^-?\d+\.\d+$/, (s) => gfloat(Number(s)));
+    t.register(/^True$/, () => gbool(true));
+    t.register(/^False$/, () => gbool(false));
+    parseTokenizer = t;
+  }
+  return parseTokenizer;
+}
+var sealCounter = 0;
+var ok = (...results) => ({ tag: "ok", results });
+var rerr = (msg) => ({ tag: "runtimeError", msg });
+var ierr = (msg) => ({ tag: "incorrectArgument", msg });
+var outputSink = (line) => {
+  console.log(line);
+};
+function setOutputSink(fn) {
+  const prev = outputSink;
+  outputSink = fn;
+  return prev;
+}
+var rawSink = typeof process !== "undefined" && process.stdout && typeof process.stdout.write === "function" ? (text) => void process.stdout.write(text) : (text) => console.log(text);
+function setRawSink(fn) {
+  const prev = rawSink;
+  rawSink = fn;
+  return prev;
+}
+function display(a) {
+  if (a.kind === "gnd" && a.value.g === "str") return a.value.s;
+  return format(a);
+}
+function asIntVal(a) {
+  return a.kind === "gnd" && a.value.g === "int" ? a.value.n : void 0;
+}
+function asBool(a) {
+  if (a.kind === "gnd" && a.value.g === "bool") return a.value.b;
+  return void 0;
+}
+function asStr(a) {
+  return a.kind === "gnd" && a.value.g === "str" ? a.value.s : void 0;
+}
+function asFloat(a) {
+  if (a.kind !== "gnd") return void 0;
+  const v = a.value;
+  if (v.g === "int") return toF64(v.n);
+  if (v.g === "float") return v.n;
+  return void 0;
+}
+function arithBin(intF, floatF) {
+  return (args) => {
+    if (args.length !== 2) return ierr("expected exactly two arguments");
+    const ax = asIntVal(args[0]);
+    const ay = asIntVal(args[1]);
+    if (ax !== void 0 && ay !== void 0) return ok(gint(intF(ax, ay)));
+    const fx = asFloat(args[0]);
+    const fy = asFloat(args[1]);
+    if (fx === void 0 || fy === void 0) return ierr("expected two Numbers");
+    return ok(gfloat(floatF(fx, fy)));
+  };
+}
+function compareNumbers(a, b) {
+  const ai = asIntVal(a);
+  const bi = asIntVal(b);
+  if (ai !== void 0 && bi !== void 0) {
+    if (typeof ai === "bigint" || typeof bi === "bigint") {
+      const x = BigInt(ai);
+      const y = BigInt(bi);
+      return x < y ? -1 : x > y ? 1 : 0;
+    }
+    return ai < bi ? -1 : ai > bi ? 1 : 0;
+  }
+  const af = asFloat(a);
+  const bf = asFloat(b);
+  if (af === void 0 || bf === void 0) return void 0;
+  return af < bf ? -1 : af > bf ? 1 : 0;
+}
+function numCmp(f) {
+  return (args) => {
+    if (args.length !== 2) return ierr("expected exactly two arguments");
+    const c = compareNumbers(args[0], args[1]);
+    if (c === void 0) return ierr("expected two Numbers");
+    return ok(gbool(f(c)));
+  };
+}
+function boolBin(f) {
+  return (args) => {
+    if (args.length !== 2) return ierr("expected exactly two arguments");
+    const x = asBool(args[0]);
+    const y = asBool(args[1]);
+    if (x === void 0 || y === void 0) return ierr("expected two Bool atoms");
+    return ok(gbool(f(x, y)));
+  };
+}
+var eqAtom = (args) => {
+  if (args.length !== 2) return ierr("expected exactly two arguments");
+  const a = args[0];
+  const b = args[1];
+  if (isErrorAtom(a)) return ok(a);
+  if (isErrorAtom(b)) return ok(b);
+  return ok(gbool(atomEq(a, b)));
+};
+var consAtom = (args) => {
+  if (args.length !== 2) return ierr("expected head and tail");
+  const [h, t] = args;
+  if (t.kind !== "expr") return ierr("cons-atom: expected an expression tail");
+  return ok(expr([h, ...t.items]));
+};
+var deconsAtom = (args) => {
+  if (args.length !== 1) return ierr("expected non-empty expression");
+  const e = args[0];
+  if (e.kind !== "expr") return ierr("expected non-empty expression");
+  if (e.items.length === 0) return ok(emptyExpr);
+  const [h, ...t] = e.items;
+  return ok(expr([h, expr(t)]));
+};
+var carAtom = (args) => {
+  const e = args[0];
+  if (args.length !== 1 || e?.kind !== "expr" || e.items.length === 0)
+    return ierr("expected non-empty expression");
+  return ok(e.items[0]);
+};
+var cdrAtom = (args) => {
+  const e = args[0];
+  if (args.length !== 1 || e?.kind !== "expr" || e.items.length === 0)
+    return ierr("expected non-empty expression");
+  return ok(expr(e.items.slice(1)));
+};
+var sizeAtom = (args) => {
+  if (args.length !== 1) return ierr("expected one atom");
+  const a = args[0];
+  return ok(gint(a.kind === "expr" ? a.items.length : atomSize(a)));
+};
+var minMaxAtom = (isMin, name) => (args) => {
+  const e = args[0];
+  if (args.length !== 1 || e?.kind !== "expr")
+    return ierr(name + " expects one argument: expression");
+  const nums = [];
+  for (const c of e.items) {
+    const f = asFloat(c);
+    if (f === void 0) return rerr("Only numbers are allowed in expression");
+    nums.push(f);
+  }
+  if (nums.length === 0) return rerr("Empty expression");
+  let acc = nums[0];
+  for (const z of nums.slice(1)) acc = isMin ? z < acc ? z : acc : z > acc ? z : acc;
+  return ok(gfloat(acc));
+};
+var indexAtom = (args) => {
+  const e = args[0];
+  if (args.length !== 2 || e?.kind !== "expr")
+    return ierr("index-atom expects two arguments: expression and atom");
+  const iv = asIntVal(args[1]);
+  if (iv === void 0) return ierr("index-atom expects two arguments: expression and atom");
+  const i = Number(iv);
+  if (i < 0 || i >= e.items.length) return rerr("Index is out of bounds");
+  return ok(e.items[i]);
+};
+var floatUn = (ff) => (args) => {
+  if (args.length !== 1) return ierr("expected exactly one argument");
+  const x = asFloat(args[0]);
+  return x === void 0 ? ierr("expected a Number") : ok(gfloat(ff(x)));
+};
+var floatBin = (ff) => (args) => {
+  if (args.length !== 2) return ierr("expected exactly two arguments");
+  const x = asFloat(args[0]);
+  const y = asFloat(args[1]);
+  return x === void 0 || y === void 0 ? ierr("expected two Numbers") : ok(gfloat(ff(x, y)));
+};
+var numRound = (fi, ff) => (args) => {
+  if (args.length !== 1) return ierr("expected exactly one argument");
+  const a = args[0];
+  if (a.kind === "gnd" && a.value.g === "int") return ok(gint(fi(a.value.n)));
+  if (a.kind === "gnd" && a.value.g === "float") return ok(gfloat(ff(a.value.n)));
+  return ierr("expected a Number");
+};
+var floatPred = (fb) => (args) => {
+  if (args.length !== 1) return ierr("expected exactly one argument");
+  const a = args[0];
+  if (a.kind === "gnd" && a.value.g === "int") return ok(gbool(false));
+  if (a.kind === "gnd" && a.value.g === "float") return ok(gbool(fb(a.value.n)));
+  return ierr("expected a Number");
+};
+var mathEntries = [
+  ["sqrt-math", floatUn(Math.sqrt)],
+  ["sin-math", floatUn(Math.sin)],
+  ["cos-math", floatUn(Math.cos)],
+  ["tan-math", floatUn(Math.tan)],
+  ["asin-math", floatUn(Math.asin)],
+  ["acos-math", floatUn(Math.acos)],
+  ["atan-math", floatUn(Math.atan)],
+  ["pow-math", floatBin(Math.pow)],
+  ["log-math", floatBin((base, input) => Math.log(input) / Math.log(base))],
+  ["abs-math", numRound(intAbs, Math.abs)],
+  ["trunc-math", numRound((n) => n, Math.trunc)],
+  ["ceil-math", numRound((n) => n, Math.ceil)],
+  ["floor-math", numRound((n) => n, Math.floor)],
+  ["round-math", numRound((n) => n, Math.round)],
+  ["isnan-math", floatPred(Number.isNaN)],
+  ["isinf-math", floatPred((x) => !Number.isFinite(x) && !Number.isNaN(x))]
+];
+var coreEntries = [
+  ["+", arithBin(addInt, (a, b) => a + b)],
+  ["-", arithBin(subInt, (a, b) => a - b)],
+  ["*", arithBin(mulInt, (a, b) => a * b)],
+  ["<", numCmp((c) => c < 0)],
+  ["<=", numCmp((c) => c <= 0)],
+  [">", numCmp((c) => c > 0)],
+  [">=", numCmp((c) => c >= 0)],
+  ["==", eqAtom],
+  ["and", boolBin((a, b) => a && b)],
+  ["or", boolBin((a, b) => a || b)],
+  ["cons-atom", consAtom],
+  ["decons-atom", deconsAtom],
+  ["car-atom", carAtom],
+  ["cdr-atom", cdrAtom],
+  ["size-atom", sizeAtom],
+  ["min-atom", minMaxAtom(true, "min-atom")],
+  ["max-atom", minMaxAtom(false, "max-atom")],
+  ["index-atom", indexAtom]
+];
+var removeFirst = (a, xs) => {
+  const i = xs.findIndex((x) => atomEq(x, a));
+  return i < 0 ? [...xs] : [...xs.slice(0, i), ...xs.slice(i + 1)];
+};
+var dedupAlpha = (xs) => {
+  const out = [];
+  for (const x of xs) if (!out.some((s) => alphaEq(s, x))) out.push(x);
+  return out;
+};
+var msIntersect = (lhs, rhs) => {
+  let pool = [...rhs];
+  const out = [];
+  for (const x of lhs)
+    if (pool.some((y) => atomEq(y, x))) {
+      out.push(x);
+      pool = removeFirst(x, pool);
+    }
+  return out;
+};
+var msSubtract = (lhs, rhs) => {
+  let pool = [...rhs];
+  const out = [];
+  for (const x of lhs) {
+    if (pool.some((y) => atomEq(y, x))) pool = removeFirst(x, pool);
+    else out.push(x);
+  }
+  return out;
+};
+var resultItems = (xs) => xs.length > 0 && xs[0].kind === "sym" && xs[0].name === "," ? xs.slice(1) : [...xs];
+var removeFirstBy = (eq, a, xs) => {
+  const i = xs.findIndex((x) => eq(a, x));
+  return i < 0 ? void 0 : [...xs.slice(0, i), ...xs.slice(i + 1)];
+};
+var bagEqBy = (eq, as, bs) => {
+  let pool = [...bs];
+  for (const a of as) {
+    const r = removeFirstBy(eq, a, pool);
+    if (r === void 0) return false;
+    pool = r;
+  }
+  return pool.length === 0;
+};
+var exprArgs = (args) => {
+  const out = [];
+  for (const a of args) {
+    if (a.kind !== "expr") return void 0;
+    out.push([...a.items]);
+  }
+  return out;
+};
+var getMetatypeOp = (args) => {
+  const a = args[0];
+  if (args.length !== 1 || a === void 0) return ierr("get-metatype expects 1 argument");
+  const k = a.kind === "sym" ? "Symbol" : a.kind === "var" ? "Variable" : a.kind === "expr" ? "Expression" : "Grounded";
+  return ok(sym(k));
+};
+var assertEqOp = (eq) => (args) => {
+  if (args.length !== 3 && args.length !== 4) return ierr("_assert-results-are-equal arity");
+  const a0 = args[0];
+  const e0 = args[1];
+  if (a0?.kind !== "expr" || e0?.kind !== "expr") return ierr("expected two expressions");
+  const okEq = bagEqBy(eq, resultItems(a0.items), resultItems(e0.items));
+  if (okEq) return ok(emptyExpr);
+  const msg = args.length === 4 ? args[3] : sym("results-are-not-equal");
+  return ok(expr([sym("Error"), args[2], msg]));
+};
+var sortByFormat = (xs) => [...xs].sort((a, b) => format(a) < format(b) ? -1 : format(a) > format(b) ? 1 : 0);
+var stdEntries = [
+  [
+    "println!",
+    (args) => {
+      if (args.length !== 1) return ierr("println! expects 1 argument");
+      outputSink(display(args[0]));
+      return ok(emptyExpr);
+    }
+  ],
+  [
+    // print! writes without a trailing newline (Hyperon semantics), via the raw sink, unlike println!.
+    "print!",
+    (args) => {
+      if (args.length !== 1) return ierr("print! expects 1 argument");
+      rawSink(display(args[0]));
+      return ok(emptyExpr);
+    }
+  ],
+  [
+    "format-args",
+    (args) => {
+      if (args.length !== 2) return ierr("format-args expects 2 arguments");
+      const tmpl = args[0];
+      const items = args[1];
+      if (tmpl.kind !== "gnd" || tmpl.value.g !== "str")
+        return ierr("format-args: first argument must be a String");
+      if (items.kind !== "expr") return ierr("format-args: second argument must be an Expression");
+      let i = 0;
+      const out = tmpl.value.s.replace(/\{\}/g, () => {
+        const it = items.items[i++];
+        return it === void 0 ? "{}" : display(it);
+      });
+      return ok(gstr(out));
+    }
+  ],
+  [
+    "repr",
+    (args) => args.length === 1 ? ok(gstr(format(args[0]))) : ierr("repr expects 1 argument")
+  ],
+  [
+    "if-equal",
+    (args) => args.length === 4 ? ok(alphaEq(args[0], args[1]) ? args[2] : args[3]) : ierr("if-equal expects 4 arguments")
+  ],
+  [
+    "=alpha",
+    (args) => args.length === 2 ? ok(gbool(alphaEq(args[0], args[1]))) : ierr("=alpha expects 2 arguments")
+  ],
+  ["get-metatype", getMetatypeOp],
+  [
+    "not",
+    (args) => {
+      const b = asBool(args[0]);
+      return args.length === 1 && b !== void 0 ? ok(gbool(!b)) : ierr("not expects one Bool");
+    }
+  ],
+  [
+    "xor",
+    (args) => {
+      const x = asBool(args[0]);
+      const y = asBool(args[1]);
+      return args.length === 2 && x !== void 0 && y !== void 0 ? ok(gbool(x !== y)) : ierr("xor expects two Bool");
+    }
+  ],
+  [
+    "/",
+    (args) => {
+      if (args.length === 2) {
+        const a = asIntVal(args[0]);
+        const b = asIntVal(args[1]);
+        if (a !== void 0 && b !== void 0)
+          return isZero(b) ? rerr("DivisionByZero") : ok(gint(intDiv(a, b)));
+      }
+      return arithBin(intDiv, (x, y) => x / y)(args);
+    }
+  ],
+  [
+    "%",
+    (args) => {
+      const a = asIntVal(args[0]);
+      const b = asIntVal(args[1]);
+      if (args.length === 2 && a !== void 0 && b !== void 0)
+        return isZero(b) ? rerr("DivisionByZero") : ok(gint(intMod(a, b)));
+      return ierr("% expects two Int atoms");
+    }
+  ],
+  [
+    "unique-atom",
+    (args) => {
+      const e = exprArgs(args);
+      return e && e.length === 1 ? ok(expr(dedupAlpha(e[0]))) : ierr("unique-atom expects one expression");
+    }
+  ],
+  [
+    "union-atom",
+    (args) => {
+      const e = exprArgs(args);
+      return e && e.length === 2 ? ok(expr([...e[0], ...e[1]])) : ierr("union-atom expects two expressions");
+    }
+  ],
+  [
+    "intersection-atom",
+    (args) => {
+      const e = exprArgs(args);
+      return e && e.length === 2 ? ok(expr(msIntersect(e[0], e[1]))) : ierr("intersection-atom expects two expressions");
+    }
+  ],
+  [
+    "subtraction-atom",
+    (args) => {
+      const e = exprArgs(args);
+      return e && e.length === 2 ? ok(expr(msSubtract(e[0], e[1]))) : ierr("subtraction-atom expects two expressions");
+    }
+  ],
+  [
+    "superpose",
+    (args) => {
+      const e = exprArgs(args);
+      return e && e.length === 1 ? ok(...resultItems(e[0])) : ierr("superpose expects one expression");
+    }
+  ],
+  [
+    "hyperpose",
+    (args) => {
+      const e = exprArgs(args);
+      return e && e.length === 1 ? ok(...resultItems(e[0])) : ierr("hyperpose expects one expression");
+    }
+  ],
+  [
+    "collapse-extract",
+    (args) => {
+      const e = exprArgs(args);
+      if (!e || e.length !== 1) return ierr("collapse-extract expects one expression");
+      return ok(
+        expr(e[0].map((p) => p.kind === "expr" && p.items.length > 0 ? p.items[0] : p))
+      );
+    }
+  ],
+  [
+    "sealed",
+    // Alpha-rename every variable in the atom (second argument) to a fresh, unique variable, except those in
+    // the ignore list (first argument). The operation is Hyperon's `sealed`; it gives a higher-order template
+    // (map-atom/filter-atom's body, an applied lambda) a private copy of its variables each time, so repeated
+    // applications do not capture one another. (Previously a no-op, which silently broke that hygiene.)
+    (args) => {
+      if (args.length !== 2) return ierr("sealed expects (sealed <vars> <atom>)");
+      const ignore = new Set(
+        (args[0].kind === "expr" ? args[0].items : []).flatMap(
+          (v) => v.kind === "var" ? [v.name] : []
+        )
+      );
+      const fresh = atomVars(args[1]).filter((v) => !ignore.has(v));
+      if (fresh.length === 0) return ok(args[1]);
+      const sub = fresh.map((v) => [v, variable(v + "#" + String(sealCounter++))]);
+      return ok(applySubst(sub, args[1]));
+    }
+  ],
+  ["nop", () => ok(emptyExpr)],
+  // `pragma!` is handled as a stateful embedded op in eval.ts (it writes interpreter settings), not here.
+  ["register-module!", () => ok(emptyExpr)],
+  ["help!", () => ok(emptyExpr)],
+  ["empty", () => ok()],
+  [
+    // `(test actual expected)` checks alpha-equivalence (exactly, no convention-forgiving), prints
+    // "is X, should Y. ✅/❌", and reduces to `()` on pass. The MeTTa-TS corpus is written in MeTTa-TS
+    // conventions, so this stays strict. MeTTa-TS is not bent to match PeTTa's rendering.
+    "test",
+    (args) => {
+      if (args.length !== 2) return ierr("test expects 2 arguments");
+      const passed = alphaEq(args[0], args[1]);
+      outputSink(`is ${format(args[0])}, should ${format(args[1])}. ${passed ? "\u2705" : "\u274C"}`);
+      return passed ? ok(emptyExpr) : ok(expr([sym("Error"), expr([sym("test"), args[0], args[1]]), sym("test-failed")]));
+    }
+  ],
+  ["_assert-results-are-equal", assertEqOp(atomEq)],
+  ["_assert-results-are-equal-msg", assertEqOp(atomEq)],
+  ["_assert-results-are-alpha-equal", assertEqOp(alphaEq)],
+  ["_assert-results-are-alpha-equal-msg", assertEqOp(alphaEq)],
+  [
+    "sort-atom",
+    (args) => {
+      const e = exprArgs(args);
+      return e && e.length === 1 ? ok(expr(sortByFormat(e[0]))) : ierr("sort-atom expects one expression");
+    }
+  ],
+  [
+    "sort-strings",
+    (args) => {
+      const e = exprArgs(args);
+      return e && e.length === 1 ? ok(expr(sortByFormat(e[0]))) : ierr("sort-strings expects one expression");
+    }
+  ]
+];
+var exprItems = (a) => a?.kind === "expr" ? a.items : void 0;
+var numVal = (a) => a.kind === "gnd" && (a.value.g === "int" || a.value.g === "float") ? Number(a.value.n) : void 0;
+var termRank = (a) => numVal(a) !== void 0 ? 0 : a.kind === "var" ? 1 : a.kind === "sym" ? 2 : a.kind === "gnd" ? 3 : 4;
+var atomCmp = (a, b) => {
+  const ra = termRank(a);
+  const rb = termRank(b);
+  if (ra !== rb) return ra - rb;
+  if (ra === 0) return numVal(a) - numVal(b);
+  if (a.kind === "expr" && b.kind === "expr") {
+    if (a.items.length !== b.items.length) return a.items.length - b.items.length;
+    for (let i = 0; i < a.items.length; i++) {
+      const c = atomCmp(a.items[i], b.items[i]);
+      if (c !== 0) return c;
+    }
+    return 0;
+  }
+  const fa = format(a);
+  const fb = format(b);
+  return fa < fb ? -1 : fa > fb ? 1 : 0;
+};
+var sortStd = (xs) => [...xs].sort(atomCmp);
+var dedup = (xs) => {
+  const out = [];
+  for (const x of xs) if (!out.some((y) => atomEq(y, x))) out.push(x);
+  return out;
+};
+var metatypeOf = (a) => a.kind === "var" ? "Variable" : a.kind === "gnd" ? "Grounded" : a.kind === "expr" ? "Expression" : "Symbol";
+var oneExpr = (name, args, f) => {
+  const it = exprItems(args[0]);
+  return args.length === 1 && it ? f(it) : ierr(`${name} expects one expression`);
+};
+var pettaEntries = [
+  ["length", (a) => oneExpr("length", a, (it) => ok(gint(it.length)))],
+  ["first", (a) => oneExpr("first", a, (it) => it.length ? ok(it[0]) : ierr("first: empty"))],
+  [
+    "last",
+    (a) => oneExpr("last", a, (it) => it.length ? ok(it[it.length - 1]) : ierr("last: empty"))
+  ],
+  ["reverse", (a) => oneExpr("reverse", a, (it) => ok(expr([...it].reverse())))],
+  ["msort", (a) => oneExpr("msort", a, (it) => ok(expr(sortStd(it))))],
+  ["sort", (a) => oneExpr("sort", a, (it) => ok(expr(dedup(sortStd(it)))))],
+  ["list_to_set", (a) => oneExpr("list_to_set", a, (it) => ok(expr(dedup(it))))],
+  // PeTTa metta.pl: dedupe a tuple modulo alpha-equivalence (two atoms equal up to a consistent
+  // renaming of variables count as one). Hyperon has no such op; this is the alpha-aware sibling of
+  // unique-atom, used by lib functions that work over patterns with variables.
+  ["alpha-unique-atom", (a) => oneExpr("alpha-unique-atom", a, (it) => ok(expr(dedupAlpha(it))))],
+  [
+    "second-from-pair",
+    (a) => oneExpr("second-from-pair", a, (it) => it.length >= 2 ? ok(it[1]) : ierr("not a pair"))
+  ],
+  [
+    "append",
+    (a) => {
+      const x = exprItems(a[0]);
+      const y = exprItems(a[1]);
+      return a.length === 2 && x && y ? ok(expr([...x, ...y])) : ierr("append expects two expressions");
+    }
+  ],
+  [
+    "is-var",
+    (a) => a.length === 1 ? ok(gbool(a[0].kind === "var")) : ierr("is-var expects one atom")
+  ],
+  [
+    "is-ground",
+    (a) => a.length === 1 ? ok(gbool(atomVars(a[0]).length === 0)) : ierr("is-ground expects one atom")
+  ],
+  [
+    "is-expr",
+    (a) => a.length === 1 ? ok(gbool(a[0].kind === "expr")) : ierr("is-expr expects one atom")
+  ],
+  [
+    "is-space",
+    (a) => a.length === 1 ? ok(gbool(a[0].kind === "sym" && a[0].name.startsWith("&"))) : ierr("is-space expects one atom")
+  ],
+  [
+    "get-mettatype",
+    (a) => a.length === 1 ? ok(sym(metatypeOf(a[0]))) : ierr("get-mettatype expects one atom")
+  ],
+  // Membership: `is-member`/`is-alpha-member` give a Bool; bare `member` succeeds (True) or yields nothing,
+  // as in metta.pl's `member(X,L,true) :- member(X,L)`.
+  [
+    "is-member",
+    (a) => {
+      const l = exprItems(a[1]);
+      return a.length === 2 && l ? ok(gbool(l.some((x) => atomEq(x, a[0])))) : ierr("is-member expects (x expr)");
+    }
+  ],
+  [
+    "is-alpha-member",
+    (a) => {
+      const l = exprItems(a[1]);
+      return a.length === 2 && l ? ok(gbool(l.some((x) => alphaEq(x, a[0])))) : ierr("is-alpha-member expects (x expr)");
+    }
+  ],
+  [
+    "member",
+    (a) => {
+      const l = exprItems(a[1]);
+      if (!(a.length === 2 && l)) return ierr("member expects (x expr)");
+      return l.some((x) => atomEq(x, a[0])) ? ok(gbool(true)) : ok();
+    }
+  ],
+  [
+    "exclude-item",
+    (a) => {
+      const l = exprItems(a[1]);
+      return a.length === 2 && l ? ok(expr(l.filter((x) => !atomEq(x, a[0])))) : ierr("exclude-item expects (item expr)");
+    }
+  ],
+  // numeric min/max of two numbers (Hyperon has only the list min-atom/max-atom). Int vs float preserved.
+  [
+    "min",
+    (a) => {
+      const x = asFloat(a[0]);
+      const y = asFloat(a[1]);
+      return a.length === 2 && x !== void 0 && y !== void 0 ? ok(x <= y ? a[0] : a[1]) : ierr("min expects two Numbers");
+    }
+  ],
+  [
+    "max",
+    (a) => {
+      const x = asFloat(a[0]);
+      const y = asFloat(a[1]);
+      return a.length === 2 && x !== void 0 && y !== void 0 ? ok(x >= y ? a[0] : a[1]) : ierr("max expects two Numbers");
+    }
+  ],
+  // bare math names PeTTa registers alongside the *-math forms. log is (base value).
+  ["sqrt", floatUn(Math.sqrt)],
+  ["sin", floatUn(Math.sin)],
+  ["cos", floatUn(Math.cos)],
+  ["exp", floatUn(Math.exp)],
+  ["log", floatBin((b, x) => Math.log(x) / Math.log(b))],
+  // implies a b == (not a) or b
+  [
+    "implies",
+    (a) => {
+      const x = asBool(a[0]);
+      const y = asBool(a[1]);
+      return a.length === 2 && x !== void 0 && y !== void 0 ? ok(gbool(!x || y)) : ierr("implies expects two Bools");
+    }
+  ],
+  // string / atom construction
+  [
+    "concat",
+    (a) => {
+      const parts = a.map((x) => asStr(x) ?? format(x));
+      return ok(gstr(parts.join("")));
+    }
+  ],
+  [
+    "atom_concat",
+    (a) => ok(sym(a.map((x) => x.kind === "sym" ? x.name : asStr(x) ?? format(x)).join("")))
+  ],
+  // parse a string of MeTTa source into its (first) atom; sread is PeTTa's alias.
+  [
+    "parse",
+    (a) => {
+      const s = asStr(a[0]);
+      if (a.length !== 1 || s === void 0) return ierr("parse expects a String");
+      const tops = parseAll(s, makeTokenizer());
+      return tops.length > 0 ? ok(tops[0].atom) : ok(emptyExpr);
+    }
+  ],
+  [
+    "sread",
+    (a) => {
+      const s = asStr(a[0]);
+      if (a.length !== 1 || s === void 0) return ierr("sread expects a String");
+      const tops = parseAll(s, makeTokenizer());
+      return tops.length > 0 ? ok(tops[0].atom) : ok(emptyExpr);
+    }
+  ],
+  // Effectful PeTTa ops: a random integer in [lo, hi), a random float in [lo, hi), and the wall-clock time.
+  [
+    "random-int",
+    (a) => {
+      const lo = asIntVal(a[0]);
+      const hi = asIntVal(a[1]);
+      if (a.length !== 2 || lo === void 0 || hi === void 0)
+        return ierr("random-int expects two Ints");
+      const l = Number(lo);
+      const h = Number(hi);
+      return ok(gint(BigInt(l + Math.floor(Math.random() * Math.max(0, h - l)))));
+    }
+  ],
+  [
+    "random-float",
+    (a) => {
+      const lo = asFloat(a[0]);
+      const hi = asFloat(a[1]);
+      return a.length === 2 && lo !== void 0 && hi !== void 0 ? ok(gfloat(lo + Math.random() * (hi - lo))) : ierr("random-float expects two Numbers");
+    }
+  ],
+  ["current-time", () => ok(gfloat(Date.now() / 1e3))]
+];
+var pettaOpNames = new Set(pettaEntries.map(([n]) => n));
+function baseTable() {
+  return new Map([...mathEntries, ...coreEntries]);
+}
+function stdTable() {
+  const t = new Map([...mathEntries, ...coreEntries, ...stdEntries]);
+  for (const [name, fn] of pettaEntries) if (!t.has(name)) t.set(name, fn);
+  return t;
+}
+function callGrounded(gt, op, args) {
+  const fn = gt.get(op);
+  return fn ? fn(args) : { tag: "noReduce" };
+}
+
+// src/compile.ts
+var BAIL = /* @__PURE__ */ Symbol("bail");
+var Tup = class {
+  constructor(v) {
+    this.v = v;
+  }
+  v;
+};
+var ARITH = {
+  "+": addInt,
+  "-": subInt,
+  "*": mulInt
+};
+var KNOWN_OPS = /* @__PURE__ */ new Set([
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "==",
+  "if",
+  "unify",
+  "let"
+]);
+var asIntNode = (c) => c.node;
+function binIntArgs(args, scope, holders) {
+  if (args.length !== 2) return void 0;
+  const x = compileBody(args[0], scope, holders);
+  const y = compileBody(args[1], scope, holders);
+  if (!x || !y || x.type !== "int" || y.type !== "int") return void 0;
+  return [asIntNode(x), asIntNode(y)];
+}
+function compileIf(cond, then_, els, scope, holders, branch) {
+  const c = compileBody(cond, scope, holders);
+  const t = branch(then_);
+  const e = branch(els);
+  if (!c || !t || !e || c.type !== "bool" || t.type !== e.type) return void 0;
+  const cn = c.node;
+  const tn = t.node;
+  const en = e.node;
+  return { node: (f) => cn(f) ? tn(f) : en(f), type: t.type };
+}
+function compileBody(a, scope, holders) {
+  if (a.kind === "var") {
+    const v = scope.vars.get(a.name);
+    if (v === void 0) return void 0;
+    return { node: v.acc, type: v.type };
+  }
+  if (a.kind === "gnd") {
+    const v = a.value;
+    if (v.g === "int") {
+      const k = v.n;
+      return { node: () => k, type: "int" };
+    }
+    if (v.g === "bool") {
+      const b = v.b;
+      return { node: () => b, type: "bool" };
+    }
+    return void 0;
+  }
+  if (a.kind !== "expr" || a.items.length === 0) return void 0;
+  const head = a.items[0];
+  const isCall = head.kind === "sym" && (KNOWN_OPS.has(head.name) || holders.has(head.name));
+  if (!isCall) {
+    const elems = a.items.map((e) => compileBody(e, scope, holders));
+    if (elems.some((c) => !c || c.type !== "int")) return void 0;
+    const ns = elems.map((c) => asIntNode(c));
+    return { node: (f) => new Tup(ns.map((n) => n(f))), type: `tuple${a.items.length}` };
+  }
+  const op = head.name;
+  const args = a.items.slice(1);
+  if (op === "+" || op === "-" || op === "*") {
+    const xy = binIntArgs(args, scope, holders);
+    if (!xy) return void 0;
+    const [xn, yn] = xy;
+    const f = ARITH[op];
+    return { node: (fr) => f(xn(fr), yn(fr)), type: "int" };
+  }
+  if (op === "/" || op === "%") {
+    const xy = binIntArgs(args, scope, holders);
+    if (!xy) return void 0;
+    const [xn, yn] = xy;
+    const div = op === "/" ? intDiv : intMod;
+    return {
+      node: (fr) => {
+        const d = yn(fr);
+        if (isZero(d)) throw BAIL;
+        return div(xn(fr), d);
+      },
+      type: "int"
+    };
+  }
+  if (op === "<" || op === "<=" || op === ">" || op === ">=" || op === "==") {
+    const xy = binIntArgs(args, scope, holders);
+    if (!xy) return void 0;
+    const [xn, yn] = xy;
+    const test = op === "<" ? (c) => c < 0 : op === "<=" ? (c) => c <= 0 : op === ">" ? (c) => c > 0 : op === ">=" ? (c) => c >= 0 : (c) => c === 0;
+    return { node: (fr) => test(cmpIntVal(xn(fr), yn(fr))), type: "bool" };
+  }
+  if (op === "if") {
+    if (args.length !== 3) return void 0;
+    return compileIf(
+      args[0],
+      args[1],
+      args[2],
+      scope,
+      holders,
+      (x) => compileBody(x, scope, holders)
+    );
+  }
+  if (op === "unify") {
+    if (args.length !== 4) return void 0;
+    const pat = args[1];
+    if (!(pat.kind === "gnd" && pat.value.g === "int")) return void 0;
+    const patVal = pat.value.n;
+    const x = compileBody(args[0], scope, holders);
+    const t = compileBody(args[2], scope, holders);
+    const e = compileBody(args[3], scope, holders);
+    if (!x || !t || !e || x.type !== "int" || t.type !== e.type) return void 0;
+    const xn = asIntNode(x);
+    const tn = t.node;
+    const en = e.node;
+    return { node: (fr) => cmpIntVal(xn(fr), patVal) === 0 ? tn(fr) : en(fr), type: t.type };
+  }
+  if (op === "let") {
+    if (args.length !== 3 || args[0].kind !== "var") return void 0;
+    const val = compileBody(args[1], scope, holders);
+    if (!val || val.type !== "int") return void 0;
+    const idx = scope.len;
+    const np = {
+      vars: new Map(scope.vars).set(args[0].name, {
+        acc: (f) => f[idx],
+        type: "int"
+      }),
+      len: scope.len + 1
+    };
+    const body = compileBody(args[2], np, holders);
+    if (!body) return void 0;
+    const vn = asIntNode(val);
+    const bn = body.node;
+    return { node: (fr) => bn([...fr, vn(fr)]), type: body.type };
+  }
+  const h = holders.get(op);
+  if (h !== void 0) {
+    if (args.length !== h.arity) return void 0;
+    const cs = args.map((ar) => compileBody(ar, scope, holders));
+    if (cs.some((c, i) => !c || c.type !== h.paramTypes[i])) return void 0;
+    const ns = cs.map((c) => c.node);
+    return { node: (fr) => h.run(ns.map((n) => n(fr))), type: h.retType };
+  }
+  return void 0;
+}
+function compileTail(a, scope, holders, self) {
+  if (a.kind === "expr" && a.items.length > 0 && a.items[0].kind === "sym") {
+    const op = a.items[0].name;
+    if (op === "if" && a.items.length === 4) {
+      return compileIf(
+        a.items[1],
+        a.items[2],
+        a.items[3],
+        scope,
+        holders,
+        (x) => compileTail(x, scope, holders, self)
+      );
+    }
+    if (op === self) {
+      const h = holders.get(self);
+      if (h !== void 0 && a.items.length - 1 === h.arity) {
+        const cs = a.items.slice(1).map((x) => compileBody(x, scope, holders));
+        if (!cs.some((c, i) => !c || c.type !== h.paramTypes[i])) {
+          const ns = cs.map((c) => c.node);
+          return { node: (f) => ns.map((n) => n(f)), type: h.retType };
+        }
+      }
+    }
+  }
+  return compileBody(a, scope, holders);
+}
+var bailRun = () => {
+  throw BAIL;
+};
+function selfCallCount(a, functor) {
+  if (a.kind !== "expr" || a.items.length === 0) return 0;
+  let n = a.items[0].kind === "sym" && a.items[0].name === functor ? 1 : 0;
+  for (const it of a.items) n += selfCallCount(it, functor);
+  return n;
+}
+function makeRun(arity, node, memoize) {
+  const loop = (vals) => {
+    let frame2 = vals;
+    for (; ; ) {
+      const r = node(frame2);
+      if (Array.isArray(r)) {
+        frame2 = r;
+        continue;
+      }
+      return r;
+    }
+  };
+  if (!memoize) return loop;
+  const memo = /* @__PURE__ */ new Map();
+  const keyOf = (v) => v instanceof Tup ? "(" + v.v.map(keyOf).join(" ") + ")" : String(v);
+  return (vals) => {
+    const key = arity === 1 ? keyOf(vals[0]) : vals.map(keyOf).join(",");
+    const hit = memo.get(key);
+    if (hit !== void 0) return hit;
+    const v = loop(vals);
+    memo.set(key, v);
+    return v;
+  };
+}
+function singleClauseHead(env, functor) {
+  const eqs = env.ruleIndex.get(functor);
+  if (eqs === void 0 || eqs.length !== 1) return void 0;
+  const [lhs, body] = eqs[0];
+  if (lhs.kind !== "expr" || lhs.items.length === 0 || lhs.items[0].kind !== "sym")
+    return void 0;
+  const params = [];
+  const seen = /* @__PURE__ */ new Set();
+  const take = (name) => seen.has(name) ? false : (seen.add(name), true);
+  for (let i = 1; i < lhs.items.length; i++) {
+    const it = lhs.items[i];
+    if (it.kind === "var") {
+      if (!take(it.name)) return void 0;
+      params.push(it.name);
+    } else if (it.kind === "expr" && it.items.length > 0 && it.items.every((e) => e.kind === "var")) {
+      const elems = it.items.map((e) => e.name);
+      if (!elems.every(take)) return void 0;
+      params.push(elems);
+    } else return void 0;
+  }
+  return { params, body };
+}
+function buildScope(params, paramTypes) {
+  const vars = /* @__PURE__ */ new Map();
+  params.forEach((p, i) => {
+    if (typeof p === "string") vars.set(p, { acc: (f) => f[i], type: paramTypes[i] });
+    else p.forEach((e, j) => vars.set(e, { acc: (f) => f[i].v[j], type: "int" }));
+  });
+  return { vars, len: params.length };
+}
+function varTypesOf(params, paramTypes) {
+  const m = /* @__PURE__ */ new Map();
+  params.forEach((p, i) => {
+    if (typeof p === "string") m.set(p, paramTypes[i]);
+    else p.forEach((e) => m.set(e, "int"));
+  });
+  return m;
+}
+var paramTypesOf = (params) => params.map((p) => typeof p === "string" ? "int" : `tuple${p.length}`);
+function inferVarType(body, name, holders) {
+  let found;
+  const walk = (a) => {
+    if (found !== void 0 || a.kind !== "expr" || a.items.length === 0) return;
+    if (a.items[0].kind === "sym") {
+      const h = holders.get(a.items[0].name);
+      if (h !== void 0)
+        for (let i = 0; i + 1 < a.items.length && found === void 0; i++) {
+          const arg = a.items[i + 1];
+          if (arg.kind === "var" && arg.name === name && h.paramTypes[i] !== "int")
+            found = h.paramTypes[i];
+        }
+    }
+    for (const it of a.items) walk(it);
+  };
+  walk(body);
+  return found;
+}
+function inferType(a, varTypes, holders) {
+  if (a.kind === "var") return varTypes.get(a.name);
+  if (a.kind === "gnd")
+    return a.value.g === "int" ? "int" : a.value.g === "bool" ? "bool" : void 0;
+  if (a.kind !== "expr" || a.items.length === 0) return void 0;
+  const hd = a.items[0];
+  if (!(hd.kind === "sym" && (KNOWN_OPS.has(hd.name) || holders.has(hd.name))))
+    return a.items.every((e) => inferType(e, varTypes, holders) === "int") ? `tuple${a.items.length}` : void 0;
+  const op = hd.name;
+  if (op === "+" || op === "-" || op === "*" || op === "/" || op === "%") return "int";
+  if (op === "<" || op === "<=" || op === ">" || op === ">=" || op === "==") return "bool";
+  if (op === "if" && a.items.length === 4) {
+    const tt = inferType(a.items[2], varTypes, holders);
+    const te = inferType(a.items[3], varTypes, holders);
+    if (tt !== void 0 && te !== void 0) return tt === te ? tt : void 0;
+    return tt ?? te;
+  }
+  if (op === "unify" && a.items.length === 5) {
+    const tt = inferType(a.items[3], varTypes, holders);
+    const te = inferType(a.items[4], varTypes, holders);
+    if (tt !== void 0 && te !== void 0) return tt === te ? tt : void 0;
+    return tt ?? te;
+  }
+  if (op === "let" && a.items.length === 4) return inferType(a.items[3], varTypes, holders);
+  return holders.get(op)?.retType;
+}
+function compileEnv(env) {
+  const pure = env.pureFunctors ?? /* @__PURE__ */ new Set();
+  const cand = /* @__PURE__ */ new Map();
+  for (const f of pure) {
+    const h = singleClauseHead(env, f);
+    if (h !== void 0) cand.set(f, h);
+  }
+  const holders = /* @__PURE__ */ new Map();
+  for (const [f, { params }] of cand)
+    holders.set(f, {
+      arity: params.length,
+      retType: void 0,
+      paramTypes: paramTypesOf(params),
+      run: bailRun
+    });
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const [f, { params, body }] of cand) {
+      const h = holders.get(f);
+      params.forEach((p, i) => {
+        if (typeof p === "string" && h.paramTypes[i] === "int") {
+          const t = inferVarType(body, p, holders);
+          if (t !== void 0 && t !== "int") {
+            h.paramTypes[i] = t;
+            changed = true;
+          }
+        }
+      });
+      if (h.retType === void 0) {
+        const rt = inferType(body, varTypesOf(params, h.paramTypes), holders);
+        if (rt !== void 0) {
+          h.retType = rt;
+          changed = true;
+        }
+      }
+    }
+  }
+  for (const [f, h] of [...holders])
+    if (h.retType === void 0) holders.delete(f);
+  for (; ; ) {
+    let removed = false;
+    const result = /* @__PURE__ */ new Map();
+    for (const [f] of [...holders]) {
+      const cd = cand.get(f);
+      const c = compileTail(cd.body, buildScope(cd.params, holders.get(f).paramTypes), holders, f);
+      if (c === void 0) {
+        holders.delete(f);
+        removed = true;
+      } else {
+        result.set(f, { node: c.node, arity: cd.params.length });
+      }
+    }
+    if (!removed) {
+      for (const [f, { node, arity }] of result)
+        holders.get(f).run = makeRun(arity, node, selfCallCount(cand.get(f).body, f) >= 2);
+      return holders;
+    }
+  }
+}
+function runCompiled(env, op, partAtoms) {
+  const h = env.compiled?.get(op);
+  if (h === void 0 || partAtoms.length !== h.arity) return void 0;
+  const vals = [];
+  for (const a of partAtoms) {
+    if (a.kind === "gnd" && a.value.g === "int") vals.push(a.value.n);
+    else if (a.kind === "expr" && a.items.length > 0 && a.items.every((x) => x.kind === "gnd" && x.value.g === "int"))
+      vals.push(new Tup(a.items.map((x) => x.value.n)));
+    else return void 0;
+  }
+  try {
+    const r = h.run(vals);
+    if (typeof r === "boolean") return gbool(r);
+    if (r instanceof Tup) return expr(r.v.map((n) => gint(n)));
+    return gint(r);
+  } catch (e) {
+    if (e === BAIL || e instanceof RangeError) return void 0;
+    throw e;
+  }
+}
+
+// src/eval.ts
+var LAZY_ARGS_OPS = /* @__PURE__ */ new Set(["par", "race", "once", "with-mutex"]);
+var AsyncInSyncError = class extends Error {
+  constructor(op) {
+    super(
+      `async grounded operation '${op}' reached in synchronous evaluation; use the async runner`
+    );
+    this.name = "AsyncInSyncError";
+  }
+};
+var pendingAsyncOp = "?";
+function runGenSync(gen) {
+  const r = gen.next();
+  if (!r.done) throw new AsyncInSyncError(pendingAsyncOp);
+  return r.value;
+}
+async function runGenAsync(gen, signal) {
+  let r = gen.next();
+  while (!r.done) {
+    signal?.throwIfAborted();
+    const v = await r.value;
+    signal?.throwIfAborted();
+    r = gen.next(v);
+  }
+  return r.value;
+}
+function* callGroundedG(env, op, args) {
+  const af = env.agt.get(op);
+  if (af !== void 0) {
+    pendingAsyncOp = op;
+    return yield af(args);
+  }
+  return callGrounded(env.gt, op, args);
+}
+var cons = (head, tail) => ({ head, tail });
+var frame = (atom, ret = "none", vars = [], fin = false) => ({
+  atom,
+  ret,
+  vars,
+  fin
+});
+var notReducibleA = sym("NotReducible");
+var emptyA = sym("Empty");
+var unitA = emptyExpr;
+var errAtom = (a, msg) => expr([sym("Error"), a, sym(msg)]);
+function opOf(a) {
+  return a.kind === "expr" && a.items.length > 0 && a.items[0].kind === "sym" ? a.items[0].name : void 0;
+}
+function tryParHyperpose(env, world, bnd, arg, firstOnly) {
+  if (env.parEval === void 0) return void 0;
+  if (world.selfRules.size > 0) return void 0;
+  const a = instantiate(bnd, arg);
+  if (a.kind !== "expr" || opOf(a) !== "hyperpose" || a.items.length !== 2) return void 0;
+  const tup = a.items[1];
+  if (tup.kind !== "expr" || tup.items.length === 0) return void 0;
+  const branches = tup.items;
+  for (const b of branches) {
+    const h = opOf(b);
+    if (!b.ground || h === void 0 || env.pureFunctors?.has(h) !== true) return void 0;
+  }
+  const perBranch = env.parEval(branches.map(format), firstOnly);
+  const out = [];
+  for (const r of perBranch) if (r !== null) for (const at of r) out.push(at);
+  return out;
+}
+var EMBEDDED = /* @__PURE__ */ new Set([
+  "eval",
+  "evalc",
+  "chain",
+  "unify",
+  "cons-atom",
+  "decons-atom",
+  "function",
+  "collapse-bind",
+  "superpose-bind",
+  "metta",
+  "metta-thread",
+  "capture",
+  "context-space",
+  "match",
+  "get-type",
+  "get-type-space",
+  "get-doc",
+  "new-state",
+  "get-state",
+  "change-state!",
+  "new-space",
+  "new-mork-space",
+  "fork-space",
+  "add-atom",
+  "remove-atom",
+  "get-atoms",
+  "bind!",
+  "import!",
+  // Sets interpreter settings in-language (Hyperon `pragma!`); stateful, so handled here not as a pure op.
+  "pragma!",
+  // TS-native extension (not upstream MeTTa): atomic space mutation with rollback.
+  "transaction",
+  // TS-native concurrency primitives (async-only); see docs/.../concurrency-primitives.md.
+  "par",
+  "race",
+  "once",
+  "with-mutex"
+]);
+function isEmbeddedOp(a) {
+  const op = opOf(a);
+  return op !== void 0 && EMBEDDED.has(op);
+}
+var varsCopy = (prev) => prev !== null ? prev.head.vars : [];
+function isVariableHeaded(a) {
+  if (a.kind === "var") return true;
+  if (a.kind === "expr" && a.items.length > 0) return isVariableHeaded(a.items[0]);
+  return false;
+}
+function headKey(a) {
+  if (a.kind === "sym") return a.name;
+  if (a.kind === "expr" && a.items.length > 0 && a.items[0].kind === "sym")
+    return a.items[0].name;
+  return void 0;
+}
+function atomToStack(a, prev) {
+  if (a.kind === "expr") {
+    const op = opOf(a);
+    const it = a.items;
+    if (op === "chain" && it.length === 4 && it[2].kind === "var") {
+      return atomToStack(it[1], cons(frame(a, "chain", varsCopy(prev)), prev));
+    }
+    if (op === "function" && it.length === 2 && it[1].kind === "expr") {
+      return atomToStack(it[1], cons(frame(a, "function", varsCopy(prev)), prev));
+    }
+    if (op === "unify" && it.length === 5) {
+      return cons(frame(a, "none"), prev);
+    }
+    if (op === "chain") return cons(frame(errAtom(a, "chain: malformed"), "none", [], true), prev);
+    if (op === "function")
+      return cons(frame(errAtom(a, "function: malformed"), "none", [], true), prev);
+    if (op === "unify") return cons(frame(errAtom(a, "unify: malformed"), "none", [], true), prev);
+  }
+  return cons(frame(a, "none", varsCopy(prev)), prev);
+}
+function finItem(st, a, b) {
+  return { stack: cons(frame(a, "none", [], true), st), bnd: b };
+}
+function evalResult(prev, r, b) {
+  if (opOf(r) === "function") return { stack: atomToStack(r, prev), bnd: b };
+  return finItem(prev, r, b);
+}
+var KEY_SEP = "
";
+var ARG_SEP = "\0";
+function argKey(a) {
+  if (a.kind === "sym") return "s" + ARG_SEP + a.name;
+  if (a.kind === "gnd") {
+    const v = a.value;
+    switch (v.g) {
+      case "int":
+        return "i" + ARG_SEP + v.n;
+      case "float":
+        return "f" + ARG_SEP + v.n;
+      case "str":
+        return "S" + ARG_SEP + v.s;
+      case "bool":
+        return "b" + ARG_SEP + (v.b ? "1" : "0");
+      default:
+        return void 0;
+    }
+  }
+  return void 0;
+}
+function pushTo(m, k, x) {
+  const cur = m.get(k);
+  if (cur === void 0) m.set(k, [x]);
+  else cur.push(x);
+}
+function emptyEnv(gt) {
+  return {
+    ruleIndex: /* @__PURE__ */ new Map(),
+    varRules: [],
+    sigs: /* @__PURE__ */ new Map(),
+    gt,
+    atoms: [],
+    types: /* @__PURE__ */ new Map(),
+    imports: /* @__PURE__ */ new Map(),
+    exprTypes: [],
+    agt: /* @__PURE__ */ new Map(),
+    mutexes: /* @__PURE__ */ new Map(),
+    factIndex: /* @__PURE__ */ new Map(),
+    argIndex: /* @__PURE__ */ new Map(),
+    nonGroundAtPos: /* @__PURE__ */ new Map(),
+    varHeadedFacts: []
+  };
+}
+function invalidateTabling(env) {
+  if (env.table !== void 0) {
+    env.table.clear();
+    env.pureFunctors = analyzePurity(env);
+    env.compileDirty = true;
+  }
+}
+function usedAsHead(a, name) {
+  if (a.kind !== "expr" || a.items.length === 0) return false;
+  if (a.items[0].kind === "var" && a.items[0].name === name) return true;
+  return a.items.some((it) => usedAsHead(it, name));
+}
+function hoFunctors(env) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [g, eqs] of env.ruleIndex) {
+    if (eqs.length !== 1) continue;
+    const [lhs, rhs] = eqs[0];
+    if (lhs.kind !== "expr") continue;
+    const idxs = [];
+    for (let k = 0; k < lhs.items.length - 1; k++) {
+      const p = lhs.items[k + 1];
+      if (p.kind === "var" && usedAsHead(rhs, p.name)) idxs.push(k);
+    }
+    if (idxs.length > 0) out.set(g, { arity: lhs.items.length - 1, idxs });
+  }
+  return out;
+}
+function specBody(a, pk, fsym, g, sName, k, gArity) {
+  const rec = (x) => specBody(x, pk, fsym, g, sName, k, gArity);
+  if (a.kind === "var") return a.name === pk ? sym(fsym) : a;
+  if (a.kind !== "expr" || a.items.length === 0) return a;
+  const h = a.items[0];
+  if (h.kind === "var" && h.name === pk) return expr([sym(fsym), ...a.items.slice(1).map(rec)]);
+  if (h.kind === "sym" && h.name === g && a.items.length - 1 === gArity) {
+    const argK = a.items[k + 1];
+    if (argK.kind === "var" && argK.name === pk)
+      return expr([
+        sym(sName),
+        ...a.items.slice(1).filter((_, i) => i !== k).map(rec)
+      ]);
+  }
+  return expr(a.items.map(rec));
+}
+function makeSpec(env, g, k, fsym) {
+  const sName = g + "$" + fsym;
+  if (env.ruleIndex.has(sName)) return sName;
+  const eqs = env.ruleIndex.get(g);
+  if (eqs === void 0 || eqs.length !== 1) return void 0;
+  const [lhs, rhs] = eqs[0];
+  if (lhs.kind !== "expr") return void 0;
+  const params = lhs.items.slice(1);
+  const pk = params[k];
+  if (pk === void 0 || pk.kind !== "var") return void 0;
+  const newLhs = expr([sym(sName), ...params.filter((_, i) => i !== k)]);
+  const newRhs = specBody(rhs, pk.name, fsym, g, sName, k, params.length);
+  addAtomToEnv(env, expr([sym("="), newLhs, newRhs]));
+  return sName;
+}
+function rewriteHO(env, a, ho) {
+  if (a.kind !== "expr" || a.items.length === 0) return a;
+  const items = a.items.map((x) => rewriteHO(env, x, ho));
+  const h = items[0];
+  if (h.kind === "sym") {
+    const info = ho.get(h.name);
+    if (info !== void 0 && items.length - 1 === info.arity) {
+      for (const k of info.idxs) {
+        const argK = items[k + 1];
+        if (argK !== void 0 && argK.kind === "sym" && env.ruleIndex.has(argK.name)) {
+          const sName = makeSpec(env, h.name, k, argK.name);
+          if (sName !== void 0)
+            return expr([sym(sName), ...items.slice(1).filter((_, i) => i !== k)]);
+        }
+      }
+    }
+  }
+  return items.every((it, i) => it === a.items[i]) ? a : expr(items);
+}
+function specializeHO(env) {
+  const ho = hoFunctors(env);
+  if (ho.size === 0) return;
+  const rules = [];
+  for (const [g, eqs] of env.ruleIndex) for (const [lhs, rhs] of eqs) rules.push([g, lhs, rhs]);
+  for (const [g, lhs, rhs] of rules) {
+    const newRhs = rewriteHO(env, rhs, ho);
+    if (newRhs !== rhs) {
+      const eqs = env.ruleIndex.get(g);
+      if (eqs !== void 0) {
+        for (let i = 0; i < eqs.length; i++)
+          if (eqs[i][0] === lhs && eqs[i][1] === rhs) eqs[i] = [lhs, newRhs];
+      }
+    }
+  }
+}
+function ensureCompiled(env) {
+  if (env.compiled !== void 0 && env.compileDirty) {
+    specializeHO(env);
+    env.compiled = compileEnv(env);
+    env.compileDirty = false;
+  }
+}
+function disableTabling(env) {
+  if (env.table !== void 0) {
+    env.table.clear();
+    env.pureFunctors = /* @__PURE__ */ new Set();
+    if (env.compiled !== void 0) {
+      env.compiled = /* @__PURE__ */ new Map();
+      env.compileDirty = false;
+    }
+  }
+}
+function addAtomToEnv(env, x) {
+  env.atoms.push(x);
+  const fk = headKey(x);
+  if (fk === void 0) env.varHeadedFacts.push(x);
+  else {
+    pushTo(env.factIndex, fk, x);
+    if (x.kind === "expr")
+      for (let i = 1; i < x.items.length; i++) {
+        const ak = argKey(x.items[i]);
+        if (ak !== void 0) pushTo(env.argIndex, fk + KEY_SEP + i + KEY_SEP + ak, x);
+        else pushTo(env.nonGroundAtPos, fk + KEY_SEP + i, x);
+      }
+  }
+  if (opOf(x) === "=" && x.kind === "expr" && x.items.length === 3) {
+    const lhs = x.items[1];
+    const rhs = x.items[2];
+    const k = headKey(lhs);
+    if (k === void 0) env.varRules.push([lhs, rhs]);
+    else {
+      const cur = env.ruleIndex.get(k);
+      if (cur === void 0) env.ruleIndex.set(k, [[lhs, rhs]]);
+      else cur.push([lhs, rhs]);
+    }
+    invalidateTabling(env);
+  }
+  if (x.kind === "expr" && opOf(x) === ":" && x.items.length === 3) {
+    const subj = x.items[1];
+    const t = x.items[2];
+    if (subj.kind === "sym") {
+      if (opOf(t) === "->" && t.kind === "expr") env.sigs.set(subj.name, t.items.slice(1));
+      env.types.set(subj.name, [...env.types.get(subj.name) ?? [], t]);
+    } else if (subj.kind === "expr") {
+      env.exprTypes.push([subj, t]);
+    }
+    env.typeCache = void 0;
+  }
+}
+function buildEnv(atoms, gt) {
+  const env = emptyEnv(gt);
+  for (const x of atoms) addAtomToEnv(env, x);
+  return env;
+}
+function registerImportedTypes(env, atoms) {
+  for (const x of atoms) {
+    if (x.kind !== "expr" || opOf(x) !== ":" || x.items.length !== 3) continue;
+    const subj = x.items[1];
+    const t = x.items[2];
+    if (subj.kind === "sym") {
+      if (opOf(t) === "->" && t.kind === "expr" && !env.sigs.has(subj.name))
+        env.sigs.set(subj.name, t.items.slice(1));
+      const cur = env.types.get(subj.name) ?? [];
+      if (!cur.some((e) => atomEq(e, t))) env.types.set(subj.name, [...cur, t]);
+    } else if (subj.kind === "expr") {
+      if (!env.exprTypes.some(([s, tt]) => atomEq(s, subj) && atomEq(tt, t)))
+        env.exprTypes.push([subj, t]);
+    }
+    env.typeCache = void 0;
+  }
+}
+function selfAtoms(env, w) {
+  return logSize(w.selfExtra) === 0 ? env.atoms : [...env.atoms, ...logToArray(w.selfExtra)];
+}
+function candidates(env, toEval) {
+  const k = headKey(toEval);
+  const keyed = k !== void 0 ? env.ruleIndex.get(k) ?? [] : [];
+  return [...keyed, ...env.varRules];
+}
+var initSt = () => ({
+  counter: 0,
+  world: {
+    spaces: /* @__PURE__ */ new Map(),
+    store: /* @__PURE__ */ new Map(),
+    tokens: /* @__PURE__ */ new Map(),
+    selfExtra: emptyLog,
+    selfRules: /* @__PURE__ */ new Map(),
+    selfVarRules: [],
+    maxStackDepth: 0
+  }
+});
+function cloneWorld(w) {
+  return {
+    spaces: new Map(w.spaces),
+    store: new Map(w.store),
+    tokens: new Map(w.tokens),
+    selfExtra: w.selfExtra,
+    selfRules: new Map(w.selfRules),
+    selfVarRules: w.selfVarRules,
+    maxStackDepth: w.maxStackDepth
+  };
+}
+function multisetDelta(base, branch) {
+  const remaining = base.slice();
+  const added = [];
+  for (const a of branch) {
+    const i = remaining.findIndex((x) => atomEq(x, a));
+    if (i >= 0) remaining.splice(i, 1);
+    else added.push(a);
+  }
+  return { added, removed: remaining };
+}
+function applyAtomDelta(into, added, removed) {
+  const out = into.slice();
+  for (const r of removed) {
+    const i = out.findIndex((x) => atomEq(x, r));
+    if (i >= 0) out.splice(i, 1);
+  }
+  out.push(...added);
+  return out;
+}
+function mergeWorlds(base, branches) {
+  const baseSelf = logToArray(base.selfExtra);
+  let selfExtra = baseSelf.slice();
+  const spaces = new Map(base.spaces);
+  const store = new Map(base.store);
+  const tokens = new Map(base.tokens);
+  for (const w of branches) {
+    const d = multisetDelta(baseSelf, logToArray(w.selfExtra));
+    selfExtra = applyAtomDelta(selfExtra, d.added, d.removed);
+    for (const [k, v] of w.spaces) {
+      const baseV = base.spaces.get(k) ?? [];
+      const sd = multisetDelta(baseV, v);
+      spaces.set(k, applyAtomDelta(spaces.get(k) ?? baseV.slice(), sd.added, sd.removed));
+    }
+    for (const [k, v] of w.store) if (!Object.is(base.store.get(k), v)) store.set(k, v);
+    for (const [k, v] of w.tokens) if (!Object.is(base.tokens.get(k), v)) tokens.set(k, v);
+  }
+  const merged = {
+    spaces,
+    store,
+    tokens,
+    selfExtra: logFromArray(selfExtra),
+    selfRules: /* @__PURE__ */ new Map(),
+    selfVarRules: [],
+    maxStackDepth: base.maxStackDepth
+  };
+  indexSelfRules(merged, selfExtra);
+  return merged;
+}
+function mutexKey(a) {
+  switch (a.kind) {
+    case "sym":
+      return "s:" + a.name;
+    case "var":
+      return "v:" + a.name;
+    case "gnd": {
+      const g = a.value;
+      return g.g === "str" ? "S:" + g.s : g.g === "int" || g.g === "float" ? "n:" + g.n : "g:" + g.g;
+    }
+    case "expr":
+      return "e:[" + a.items.map(mutexKey).join(",") + "]";
+  }
+}
+function resolveTok(w, a) {
+  if (a.kind === "sym") return w.tokens.get(a.name) ?? a;
+  return a;
+}
+var stateHandle = (id) => expr([sym("State"), gint(id)]);
+function stateId(w, a) {
+  const r = resolveTok(w, a);
+  if (opOf(r) === "State" && r.kind === "expr" && r.items.length === 2) {
+    const g = r.items[1];
+    if (g.kind === "gnd" && g.value.g === "int") return Number(g.value.n);
+  }
+  return void 0;
+}
+function spaceName(w, a) {
+  const r = resolveTok(w, a);
+  return r.kind === "sym" ? r.name : void 0;
+}
+function resolveStates(w, a) {
+  if (w.store.size === 0) return a;
+  if (a.kind === "expr") {
+    if (opOf(a) === "State" && a.items.length === 2) {
+      const g = a.items[1];
+      if (g.kind === "gnd" && g.value.g === "int") return w.store.get(Number(g.value.n)) ?? a;
+    }
+    return expr(a.items.map((x) => resolveStates(w, x)));
+  }
+  return a;
+}
+function subTokens(w, a) {
+  if (w.tokens.size === 0) return a;
+  if (a.kind === "sym") return w.tokens.get(a.name) ?? a;
+  if (a.kind === "expr") return expr(a.items.map((x) => subTokens(w, x)));
+  return a;
+}
+function wrapStates(w, a) {
+  if (w.store.size === 0) return a;
+  if (a.kind === "expr") {
+    if (opOf(a) === "State" && a.items.length === 2) {
+      const g = a.items[1];
+      if (g.kind === "gnd" && g.value.g === "int") {
+        const v = w.store.get(Number(g.value.n));
+        return v !== void 0 ? expr([sym("StateValue"), v]) : a;
+      }
+    }
+    return expr(a.items.map((x) => wrapStates(w, x)));
+  }
+  return a;
+}
+var typePrep = (w, a) => wrapStates(w, subTokens(w, a));
+function candidatesW(env, w, toEval) {
+  const k2 = headKey(toEval);
+  const headRules = k2 !== void 0 ? w.selfRules.get(k2) ?? [] : [];
+  return [...candidates(env, toEval), ...headRules, ...w.selfVarRules];
+}
+var ruleVarsCache = /* @__PURE__ */ new WeakMap();
+function ruleVars(lhs, rhs) {
+  let vs = ruleVarsCache.get(lhs);
+  if (vs === void 0) {
+    vs = atomVars(lhs);
+    const seen = new Set(vs);
+    for (const v of atomVars(rhs))
+      if (!seen.has(v)) {
+        seen.add(v);
+        vs.push(v);
+      }
+    ruleVarsCache.set(lhs, vs);
+  }
+  return vs;
+}
+function freshenSub(counter, lhs, rhs) {
+  const vs = ruleVars(lhs, rhs);
+  return vs.length === 0 ? [] : vs.map((v) => [v, variable(v + "#" + String(counter))]);
+}
+function freshenRule(counter, lhs, rhs) {
+  const sub = freshenSub(counter, lhs, rhs);
+  if (sub.length === 0) return [lhs, rhs];
+  return [applySubst(sub, lhs), applySubst(sub, rhs)];
+}
+function canMatchShallow(lhs, toEval) {
+  if (lhs.kind === "var" || toEval.kind === "var") return true;
+  if (lhs.kind === "sym") return toEval.kind === "sym" && toEval.name === lhs.name;
+  if (lhs.kind === "gnd") return atomEq(lhs, toEval);
+  return toEval.kind === "expr" && toEval.items.length === lhs.items.length && canMatchShallow(lhs.items[0], toEval.items[0]);
+}
+function queryOp(env, st, prev, toEval, b) {
+  if (isVariableHeaded(toEval)) return [[finItem(prev, notReducibleA, b)], st];
+  const cands = candidatesW(env, st.world, toEval);
+  const out = [];
+  let counter = st.counter;
+  for (const [lhs0, rhs0] of cands) {
+    if (!canMatchShallow(lhs0, toEval)) {
+      counter += 1;
+      continue;
+    }
+    const suffix = "#" + counter;
+    counter += 1;
+    for (const mb of matchAtomsScoped(lhs0, toEval, suffix)) {
+      for (const m of merge(b, mb)) {
+        if (!hasLoop(m)) out.push(evalResult(prev, instantiate(m, rhs0, suffix), m));
+      }
+    }
+  }
+  const st2 = { counter, world: st.world };
+  if (out.length === 0) return [[finItem(prev, notReducibleA, b)], st2];
+  return [out, st2];
+}
+function hasRuleFor(env, w, counter, a) {
+  for (const [lhs, rhs] of candidatesW(env, w, a)) {
+    const [fl] = freshenRule(counter, lhs, rhs);
+    if (matchAtoms(fl, a).length > 0) return true;
+  }
+  return false;
+}
+function* evalOpG(env, st, prev, x, b) {
+  const x2 = instantiate(b, x);
+  const op = opOf(x2);
+  const useGrounded = op !== void 0 && x2.kind === "expr" && !(pettaOpNames.has(op) && hasRuleFor(env, st.world, st.counter, x2));
+  if (useGrounded) {
+    const args = x2.items.slice(1).map((a) => resolveStates(st.world, subTokens(st.world, a)));
+    const r = yield* callGroundedG(env, op, args);
+    if (r.tag === "ok") return [r.results.map((res) => evalResult(prev, res, b)), st];
+    if (r.tag === "runtimeError") return [[finItem(prev, errAtom(x2, r.msg), b)], st];
+    if (r.tag === "incorrectArgument") return [[finItem(prev, notReducibleA, b)], st];
+  }
+  if (x2.kind === "expr" && x2.items.length > 0) {
+    const head = x2.items[0];
+    if (head.kind === "gnd" && head.exec !== void 0) {
+      const args = x2.items.slice(1).map((a) => resolveStates(st.world, subTokens(st.world, a)));
+      try {
+        const results = head.exec(args);
+        return [results.map((res) => evalResult(prev, res, b)), st];
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return [[finItem(prev, errAtom(x2, msg), b)], st];
+      }
+    }
+  }
+  if (isEmbeddedOp(x2)) return [[{ stack: atomToStack(x2, prev), bnd: b }], st];
+  return queryOp(env, st, prev, x2, b);
+}
+function unifyOp(prev, a, p, t, e, b) {
+  const ms = [];
+  for (const mb of matchAtoms(a, p))
+    for (const m of merge(b, mb)) if (!hasLoop(m)) ms.push(finItem(prev, instantiate(m, t), m));
+  return ms.length === 0 ? [finItem(prev, e, b)] : ms;
+}
+var isFinal = (it) => it.stack !== null && it.stack.tail === null && it.stack.head.fin;
+function finalPair(it) {
+  const f = it.stack;
+  return f === null ? [emptyA, []] : [instantiate(it.bnd, f.head.atom), it.bnd];
+}
+function exhaustedPair(it) {
+  const f = it.stack;
+  return f === null ? [emptyA, it.bnd] : [expr([sym("Error"), instantiate(it.bnd, f.head.atom), sym("StackOverflow")]), it.bnd];
+}
+function resolveAtomFix(b, n, a) {
+  let cur = a;
+  for (let i = 0; i < n; i++) {
+    const next = instantiate(b, cur);
+    if (atomEq(next, cur)) return cur;
+    cur = next;
+  }
+  return cur;
+}
+function restrictBnd(vars, b) {
+  const solved = [];
+  for (const x of vars) {
+    const v = resolveAtomFix(b, b.length + 1, variable(x));
+    if (!(v.kind === "var" && v.name === x)) solved.push({ tag: "val", x, a: v, y: void 0 });
+  }
+  if (!b.some((r) => r.tag === "eq")) return solved;
+  const vset = new Set(vars);
+  const eqs = b.filter((r) => r.tag === "eq" && vset.has(r.x) && vset.has(r.y));
+  return solved.length === 0 ? eqs : [...solved, ...eqs];
+}
+function mergeRestrict(vars, baseB, pb) {
+  const merged = merge(baseB, pb);
+  return restrictBnd(vars, merged.length > 0 ? merged[0] : pb);
+}
+function scopeVars(b, prev) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let p = prev; p !== null; p = p.tail) collectVars(instantiate(b, p.head.atom), out, seen);
+  return out;
+}
+function frameVars(prev) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let p = prev; p !== null; p = p.tail) collectVars(p.head.atom, out, seen);
+  return out;
+}
+function superposeItem(prev, b, pair) {
+  if (pair.kind === "expr" && pair.items.length > 0) return finItem(prev, pair.items[0], b);
+  return finItem(prev, pair, b);
+}
+function argMask(ts, arity) {
+  const mask = new Array(arity);
+  if (ts === void 0) {
+    mask.fill(true);
+    return mask;
+  }
+  for (let i = 0; i < arity; i++) {
+    const t = ts[i];
+    mask[i] = t === void 0 || !(t.kind === "sym" && (t.name === "Atom" || t.name === "Variable" || t.name === "Expression"));
+  }
+  return mask;
+}
+function returnsAtom(env, a) {
+  const op = headKey(a);
+  if (op === void 0) return false;
+  const ts = env.sigs.get(op);
+  const last = ts && ts.length > 0 ? ts[ts.length - 1] : void 0;
+  return last !== void 0 && atomEq(last, sym("Atom"));
+}
+function functionArity(env, w, name) {
+  const sig = env.sigs.get(name);
+  if (sig !== void 0 && sig.length >= 1) return sig.length - 1;
+  for (const [lhs] of [...env.ruleIndex.get(name) ?? [], ...w.selfRules.get(name) ?? []])
+    if (lhs.kind === "expr" && lhs.items.length >= 2) return lhs.items.length - 1;
+  return void 0;
+}
+var headOr = (xs, d) => xs.length > 0 ? xs[0] : d;
+var UNDEF = sym("%Undefined%");
+var NUMBER_T = [sym("Number")];
+var STRING_T = [sym("String")];
+var BOOL_T = [sym("Bool")];
+var GROUNDED_T = [sym("Grounded")];
+var UNDEF_T = [UNDEF];
+function getTypes(env, a) {
+  if (a.ground) {
+    const cache3 = env.typeCache ??= /* @__PURE__ */ new WeakMap();
+    const hit = cache3.get(a);
+    if (hit !== void 0) return hit;
+    const r = getTypesUncached(env, a);
+    cache3.set(a, r);
+    return r;
+  }
+  return getTypesUncached(env, a);
+}
+function getTypesUncached(env, a) {
+  if (a.kind === "gnd") {
+    const g = a.value;
+    if (g.g === "int" || g.g === "float") return NUMBER_T;
+    if (g.g === "str") return STRING_T;
+    if (g.g === "bool") return BOOL_T;
+    return GROUNDED_T;
+  }
+  if (a.kind === "var") return UNDEF_T;
+  if (a.kind === "sym") {
+    const ts = env.types.get(a.name);
+    return ts && ts.length > 0 ? ts : UNDEF_T;
+  }
+  if (a.items.length === 0) return UNDEF_T;
+  if (opOf(a) === "StateValue" && a.items.length === 2)
+    return [expr([sym("StateMonad"), headOr(getTypes(env, a.items[1]), UNDEF)])];
+  const direct = env.exprTypes.filter((p) => atomEq(p[0], a));
+  if (direct.length > 0) return direct.map((p) => p[1]);
+  const f = a.items[0];
+  const args = a.items.slice(1);
+  const argTs = args.map((x) => headOr(getTypes(env, x), UNDEF));
+  const fTypes = getTypes(env, f);
+  const out = [];
+  for (const t of fTypes) {
+    if (opOf(t) === "->" && t.kind === "expr") {
+      const ts = t.items.slice(1);
+      const ret = ts.length > 0 ? ts[ts.length - 1] : UNDEF;
+      const params = ts.slice(0, -1);
+      let tb = [];
+      for (let i = 0; i < params.length && i < argTs.length; i++) {
+        const m = matchAtoms(instantiate(tb, params[i]), argTs[i]);
+        if (m.length > 0) {
+          const merged = merge(tb, m[0]);
+          if (merged.length > 0) tb = merged[0];
+        }
+      }
+      out.push(instantiate(tb, ret));
+    }
+  }
+  return out.length > 0 ? out : UNDEF_T;
+}
+function getTypesForQuery(env, a) {
+  const base = getTypes(env, a);
+  if (a.kind !== "expr" || a.items.length === 0) return base;
+  if (base.length > 0 && !base.every((t) => atomEq(t, UNDEF))) return base;
+  const f = a.items[0];
+  if (getTypes(env, f).some((t) => opOf(t) === "->")) return base;
+  let combos = [[]];
+  for (const x of a.items) {
+    const ts = getTypesForQuery(env, x);
+    const opts = ts.length > 0 ? ts : [UNDEF];
+    const next = [];
+    for (const combo of combos) for (const t of opts) next.push([...combo, t]);
+    combos = next;
+  }
+  return combos.map((c) => expr(c));
+}
+function matchReduced(tb, expected, actual) {
+  if (atomEq(expected, UNDEF) || atomEq(actual, UNDEF)) return tb;
+  if (expected.kind === "expr" && actual.kind === "expr")
+    return matchReducedList(tb, expected.items, actual.items);
+  for (const mb of matchAtoms(expected, actual)) {
+    const merged = merge(tb, mb);
+    if (merged.length > 0) return merged[0];
+  }
+  return void 0;
+}
+function matchReducedList(tb, es, acts) {
+  if (es.length !== acts.length) return void 0;
+  let cur = tb;
+  for (let i = 0; i < es.length; i++) {
+    const r = matchReduced(cur, es[i], acts[i]);
+    if (r === void 0) return void 0;
+    cur = r;
+  }
+  return cur;
+}
+function matchType(tb, expected, actual) {
+  if (atomEq(expected, UNDEF) || atomEq(actual, UNDEF) || atomEq(expected, sym("Atom")) || atomEq(actual, sym("Atom")))
+    return tb;
+  return matchReduced(tb, expected, actual);
+}
+function typeCheckArgs(env, w, argTypes, i, tb, argsLeft) {
+  if (argsLeft.length === 0) return void 0;
+  const ti0 = argTypes[i];
+  if (ti0 === void 0) return void 0;
+  const ti = instantiate(tb, ti0);
+  if (ti.kind === "sym" && (ti.name === "Atom" || ti.name === "%Undefined%"))
+    return typeCheckArgs(env, w, argTypes, i + 1, tb, argsLeft.slice(1));
+  const ai = argsLeft[0];
+  const prepped = typePrep(w, ai);
+  if (ti.kind === "sym" && ti.name === metaType(prepped))
+    return typeCheckArgs(env, w, argTypes, i + 1, tb, argsLeft.slice(1));
+  const actuals = getTypes(env, prepped);
+  for (const act of actuals) {
+    const tb2 = matchType(tb, ti, act);
+    if (tb2 !== void 0) return typeCheckArgs(env, w, argTypes, i + 1, tb2, argsLeft.slice(1));
+  }
+  return [i + 1, ti, headOr(actuals, UNDEF)];
+}
+function typeMismatch(env, w, op, args, ts = env.sigs.get(op)) {
+  if (ts === void 0) return void 0;
+  return typeCheckArgs(env, w, ts.slice(0, -1), 0, [], args);
+}
+function matchCandidates(env, w, pInst) {
+  const k = headKey(pInst);
+  if (k === void 0) {
+    const extra2 = logToArray(w.selfExtra);
+    const all = extra2.length === 0 ? env.atoms.slice() : [...env.atoms, ...extra2];
+    return resolveAll(w, all);
+  }
+  let bestKey;
+  let bestPosKey;
+  let bestSize = Infinity;
+  if (pInst.kind === "expr")
+    for (let i = 1; i < pInst.items.length; i++) {
+      const ak = argKey(pInst.items[i]);
+      if (ak === void 0) continue;
+      const ik = k + KEY_SEP + i + KEY_SEP + ak;
+      const posKey = k + KEY_SEP + i;
+      const size = (env.argIndex.get(ik)?.length ?? 0) + (env.nonGroundAtPos.get(posKey)?.length ?? 0);
+      if (size < bestSize) {
+        bestSize = size;
+        bestKey = ik;
+        bestPosKey = posKey;
+      }
+    }
+  let cands;
+  if (bestKey !== void 0) {
+    cands = [...env.argIndex.get(bestKey) ?? [], ...env.nonGroundAtPos.get(bestPosKey) ?? []];
+  } else {
+    cands = (env.factIndex.get(k) ?? []).slice();
+  }
+  cands.push(...env.varHeadedFacts);
+  if (pInst.ground && logNonGround(w.selfExtra) === 0 && w.store.size === 0) {
+    const c = idxCount(logGroundIdx(w.selfExtra), pInst);
+    for (let i = 0; i < c; i++) cands.push(pInst);
+    return cands;
+  }
+  const extra = logToArray(w.selfExtra);
+  for (const a of extra) {
+    const akk = headKey(a);
+    if (akk === void 0 || akk === k) cands.push(a);
+  }
+  return resolveAll(w, cands);
+}
+function resolveAll(w, atoms) {
+  return w.store.size === 0 ? atoms : atoms.map((x) => resolveStates(w, x));
+}
+function matchConj(getCandidates, patterns, st, sols) {
+  let cur = sols;
+  let counter = st.counter;
+  for (const p of patterns) {
+    const next = [];
+    for (const b of cur) {
+      const pInst = instantiate(b, p);
+      for (const atom of getCandidates(pInst)) {
+        const atom2 = freshenRule(counter, atom, atom)[0];
+        counter += 1;
+        for (const mb of matchAtoms(pInst, atom2))
+          for (const m of merge(b, mb)) if (!hasLoop(m)) next.push(m);
+      }
+    }
+    cur = next;
+  }
+  return [cur, { counter, world: st.world }];
+}
+function matchConjJoin(getCandidates, patterns, st, b0) {
+  let counter = st.counter;
+  const groundRels = [];
+  const otherPatterns = [];
+  for (const p of patterns) {
+    const pInst = instantiate(b0, p);
+    const pvars = atomVars(pInst);
+    if (pvars.length === 0) {
+      otherPatterns.push(p);
+      continue;
+    }
+    const tuples = [];
+    let allGround = true;
+    for (const atom of getCandidates(pInst)) {
+      const fresh = freshenRule(counter, atom, atom)[0];
+      counter += 1;
+      for (const mb of matchAtoms(pInst, fresh)) {
+        const t = /* @__PURE__ */ new Map();
+        for (const v of pvars) {
+          const val = instantiate(mb, variable(v));
+          t.set(v, val);
+          if (!val.ground) allGround = false;
+        }
+        tuples.push(t);
+      }
+    }
+    if (allGround) groundRels.push({ vars: pvars, tuples });
+    else otherPatterns.push(p);
+  }
+  let cur;
+  if (groundRels.length > 0) {
+    cur = [];
+    for (const sol of wcoJoin(groundRels, mutexKey)) {
+      let bs = [b0];
+      for (const [v, val] of sol) {
+        const nb = [];
+        for (const b of bs) nb.push(...addVarBinding(b, v, val));
+        bs = nb;
+      }
+      for (const b of bs) if (!hasLoop(b)) cur.push(b);
+    }
+  } else {
+    cur = [b0];
+  }
+  for (const p of otherPatterns) {
+    const next = [];
+    const freshCache = /* @__PURE__ */ new Map();
+    for (const b of cur) {
+      const pInst = instantiate(b, p);
+      for (const atom of getCandidates(pInst)) {
+        let fresh = freshCache.get(atom);
+        if (fresh === void 0) {
+          fresh = freshenRule(counter, atom, atom)[0];
+          counter += 1;
+          freshCache.set(atom, fresh);
+        }
+        for (const mb of matchAtoms(pInst, fresh))
+          for (const m of merge(b, mb)) if (!hasLoop(m)) next.push(m);
+      }
+    }
+    cur = next;
+  }
+  return [cur, { counter, world: st.world }];
+}
+function getDocOf(env, w, atom) {
+  const atoms = selfAtoms(env, w);
+  const ty = atom.kind === "sym" ? headOr(env.types.get(atom.name) ?? [], UNDEF) : env.exprTypes.find((p) => atomEq(p[0], atom))?.[1] ?? UNDEF;
+  const doc = atoms.find(
+    (a) => opOf(a) === "@doc" && a.kind === "expr" && a.items.length >= 2 && atomEq(a.items[1], atom)
+  );
+  if (doc === void 0 || doc.kind !== "expr") return sym("Empty");
+  if (doc.items.length === 5) {
+    const desc = doc.items[2];
+    const paramsWrap = doc.items[3];
+    const retWrap = doc.items[4];
+    const params = paramsWrap.kind === "expr" ? paramsWrap.items[1] : void 0;
+    const paramList = params && params.kind === "expr" ? params.items : [];
+    const retDesc = retWrap.kind === "expr" ? retWrap.items[1] : UNDEF;
+    const n = paramList.length;
+    let paramTys;
+    let retTy;
+    if (opOf(ty) === "->" && ty.kind === "expr" && ty.items.length - 1 === n + 1) {
+      const rest = ty.items.slice(1);
+      paramTys = rest.slice(0, -1);
+      retTy = rest[rest.length - 1];
+    } else {
+      paramTys = Array(n).fill(UNDEF);
+      retTy = UNDEF;
+    }
+    const params2 = paramList.map((pp, i) => {
+      if (opOf(pp) === "@param" && pp.kind === "expr" && pp.items.length === 2)
+        return expr([
+          sym("@param"),
+          expr([sym("@type"), paramTys[i] ?? UNDEF]),
+          expr([sym("@desc"), pp.items[1]])
+        ]);
+      return pp;
+    });
+    return expr([
+      sym("@doc-formal"),
+      expr([sym("@item"), atom]),
+      expr([sym("@kind"), sym("function")]),
+      expr([sym("@type"), ty]),
+      desc,
+      expr([sym("@params"), expr(params2)]),
+      expr([sym("@return"), expr([sym("@type"), retTy]), expr([sym("@desc"), retDesc])])
+    ]);
+  }
+  if (doc.items.length === 3) {
+    return expr([
+      sym("@doc-formal"),
+      expr([sym("@item"), atom]),
+      expr([sym("@kind"), sym("atom")]),
+      expr([sym("@type"), ty]),
+      doc.items[2]
+    ]);
+  }
+  return sym("Empty");
+}
+function* interpretStack1G(env, fuel, st, it) {
+  if (it.stack === null) return [[], st];
+  const top = it.stack.head;
+  const prev = it.stack.tail;
+  if (top.fin) {
+    if (prev === null) return [[it], st];
+    const pf = prev.head;
+    const pprev = prev.tail;
+    const res = instantiate(it.bnd, top.atom);
+    if (pf.ret === "chain") {
+      if (opOf(pf.atom) === "chain" && pf.atom.kind === "expr" && pf.atom.items.length === 4) {
+        const v = pf.atom.items[2];
+        const templ = pf.atom.items[3];
+        const nf = frame(expr([sym("chain"), res, v, templ]), pf.ret, pf.vars, false);
+        return [[{ stack: cons(nf, pprev), bnd: it.bnd }], st];
+      }
+      return [[finItem(pprev, errAtom(pf.atom, "chain: corrupt frame"), it.bnd)], st];
+    }
+    if (pf.ret === "function") {
+      if (opOf(res) === "return" && res.kind === "expr" && res.items.length === 2)
+        return [[finItem(pprev, res.items[1], it.bnd)], st];
+      if (isEmbeddedOp(res))
+        return [[{ stack: atomToStack(res, cons(pf, pprev)), bnd: it.bnd }], st];
+      const target = pprev !== null ? pprev.head.atom : res;
+      return [[finItem(pprev, errAtom(target, "NoReturn"), it.bnd)], st];
+    }
+    return [[], st];
+  }
+  const a = top.atom;
+  const op = opOf(a);
+  const it2 = a.kind === "expr" ? a.items : [];
+  switch (op) {
+    case "eval":
+      if (it2.length === 2) return yield* evalOpG(env, st, prev, it2[1], it.bnd);
+      break;
+    case "evalc":
+      if (it2.length === 3) return yield* evalOpG(env, st, prev, it2[1], it.bnd);
+      break;
+    case "chain":
+      if (it2.length === 4 && it2[2].kind === "var") {
+        const v = it2[2].name;
+        const cont = applySubst([[v, it2[1]]], it2[3]);
+        const bnd = restrictBnd(atomVars(cont, frameVars(prev)), it.bnd);
+        return [[{ stack: atomToStack(cont, prev), bnd }], st];
+      }
+      break;
+    case "unify":
+      if (it2.length === 5) return [unifyOp(prev, it2[1], it2[2], it2[3], it2[4], it.bnd), st];
+      break;
+    case "cons-atom":
+      if (it2.length === 3 && it2[2].kind === "expr")
+        return [[finItem(prev, expr([it2[1], ...it2[2].items]), it.bnd)], st];
+      if (it2.length === 3)
+        return [[finItem(prev, errAtom(a, "cons-atom: expected expression tail"), it.bnd)], st];
+      break;
+    case "decons-atom":
+      if (it2.length === 2 && it2[1].kind === "expr" && it2[1].items.length > 0) {
+        const [h, ...t] = it2[1].items;
+        return [[finItem(prev, expr([h, expr(t)]), it.bnd)], st];
+      }
+      if (it2.length === 2)
+        return [
+          [finItem(prev, errAtom(a, "decons-atom: expected non-empty expression"), it.bnd)],
+          st
+        ];
+      break;
+    case "context-space":
+      if (it2.length === 1) return [[finItem(prev, sym("&self"), it.bnd)], st];
+      break;
+    case "metta":
+    case "capture":
+    case "metta-thread": {
+      const atom = it2[1];
+      const [pairs, st2] = yield* mettaEvalG(env, fuel, st, it.bnd, atom);
+      if (op === "metta-thread") {
+        const out = [];
+        for (const p of pairs)
+          for (const m of merge(it.bnd, restrictBnd(scopeVars(it.bnd, prev), p[1])))
+            out.push(finItem(prev, p[0], m));
+        return [out, st2];
+      }
+      return [pairs.map((p) => finItem(prev, p[0], it.bnd)), st2];
+    }
+    case "get-type":
+    case "get-type-space": {
+      let typeEnv = env;
+      if (op === "get-type-space") {
+        const sp = instantiate(it.bnd, it2[1]);
+        const sname = sp.kind === "sym" ? sp.name : void 0;
+        if (sname !== void 0 && sname !== "&self") {
+          const sa = st.world.spaces.get(sname);
+          if (sa !== void 0 && sa.length > 0) typeEnv = buildEnv([...env.atoms, ...sa], env.gt);
+        }
+      }
+      const x = op === "get-type-space" ? it2[2] : it2[1];
+      return yield* getTypeOpG(typeEnv, fuel, st, prev, instantiate(it.bnd, x), it.bnd);
+    }
+    case "get-doc":
+      if (it2.length === 2)
+        return [[finItem(prev, getDocOf(env, st.world, instantiate(it.bnd, it2[1])), it.bnd)], st];
+      break;
+    case "match":
+      if (it2.length === 4) return matchOp(env, st, prev, it2[1], it2[2], it2[3], it.bnd);
+      break;
+    case "superpose-bind":
+      if (it2.length === 2 && it2[1].kind === "expr")
+        return [it2[1].items.map((p) => superposeItem(prev, it.bnd, p)), st];
+      break;
+    case "collapse-bind": {
+      if (it2.length !== 2) break;
+      const [atoms, st2] = yield* interpretLoopG(env, fuel, st, [
+        { stack: atomToStack(it2[1], null), bnd: it.bnd }
+      ]);
+      return [[finItem(prev, expr(atoms.map((p) => expr([p[0], unitA]))), it.bnd)], st2];
+    }
+    // TS-native extension. `(transaction <body>)` evaluates the body and atomically commits its
+    // space mutations only if the body succeeds. Because the world is threaded copy-on-write
+    // (cloneWorld -> new St), commit/rollback is snapshot-and-restore: keep the body's world on
+    // success, restore the pre-body world otherwise. Rollback trigger (spec A2.1): the body throws
+    // (an Error atom result) for every result, or produces zero results. The gensym counter always
+    // advances (never reused after rollback).
+    case "transaction": {
+      if (it2.length !== 2) break;
+      const snapshotWorld = st.world;
+      const [pairs, st2] = yield* mettaEvalG(env, fuel, st, it.bnd, it2[1]);
+      const committed = pairs.length > 0 && pairs.some((p) => !isErrorAtom(p[0]));
+      const world = committed ? st2.world : snapshotWorld;
+      return [pairs.map((p) => finItem(prev, p[0], it.bnd)), { counter: st2.counter, world }];
+    }
+    // TS-native concurrency (async-only; see docs/.../concurrency-primitives.md).
+    case "par": {
+      const branches = it2.slice(1);
+      pendingAsyncOp = "par";
+      const results = yield Promise.all(
+        branches.map((br) => mettaEvalAsync(env, fuel, st, it.bnd, br))
+      );
+      const out = [];
+      let counter = st.counter;
+      const worlds = [];
+      for (const [pairs, st2] of results) {
+        for (const p of pairs) out.push(finItem(prev, p[0], it.bnd));
+        worlds.push(st2.world);
+        if (st2.counter > counter) counter = st2.counter;
+      }
+      return [out, { counter, world: mergeWorlds(st.world, worlds) }];
+    }
+    case "race": {
+      const branches = it2.slice(1);
+      pendingAsyncOp = "race";
+      const winner = yield (async () => {
+        const ac = new AbortController();
+        try {
+          return await Promise.any(
+            branches.map(async (br) => {
+              const r = await mettaEvalAsync(env, fuel, st, it.bnd, br, ac.signal);
+              if (r[0].length === 0) throw new Error("empty branch");
+              return r;
+            })
+          );
+        } catch {
+          return [[], st];
+        } finally {
+          ac.abort();
+        }
+      })();
+      return [winner[0].map((p) => finItem(prev, p[0], it.bnd)), winner[1]];
+    }
+    case "once": {
+      if (it2.length !== 2) break;
+      const par = tryParHyperpose(env, st.world, it.bnd, it2[1], true);
+      if (par !== void 0) {
+        const first2 = par.length > 0 ? [par[0]] : [];
+        return [first2.map((a2) => finItem(prev, a2, it.bnd)), st];
+      }
+      const [pairs, st2] = yield* mettaEvalG(env, fuel, st, it.bnd, it2[1]);
+      const first = pairs.length > 0 ? [pairs[0]] : [];
+      return [first.map((p) => finItem(prev, p[0], it.bnd)), st2];
+    }
+    case "with-mutex": {
+      if (it2.length !== 3) break;
+      const name = mutexKey(instantiate(it.bnd, it2[1]));
+      const body = it2[2];
+      pendingAsyncOp = "with-mutex";
+      const result = yield (async () => {
+        const prior = env.mutexes.get(name) ?? Promise.resolve();
+        let release;
+        const held = new Promise((r) => release = r);
+        const chained = prior.then(() => held);
+        env.mutexes.set(name, chained);
+        await prior;
+        try {
+          return await mettaEvalAsync(env, fuel, st, it.bnd, body);
+        } finally {
+          release();
+          if (env.mutexes.get(name) === chained) env.mutexes.delete(name);
+        }
+      })();
+      return [result[0].map((p) => finItem(prev, p[0], it.bnd)), result[1]];
+    }
+    case "new-state": {
+      if (it2.length !== 2) break;
+      const id = st.counter;
+      const w = cloneWorld(st.world);
+      w.store.set(id, instantiate(it.bnd, it2[1]));
+      return [[finItem(prev, stateHandle(id), it.bnd)], { counter: id + 1, world: w }];
+    }
+    case "get-state": {
+      if (it2.length !== 2) break;
+      const id = stateId(st.world, instantiate(it.bnd, it2[1]));
+      if (id !== void 0) return [[finItem(prev, st.world.store.get(id) ?? emptyA, it.bnd)], st];
+      return [
+        [finItem(prev, errAtom(instantiate(it.bnd, it2[1]), "get-state: not a state"), it.bnd)],
+        st
+      ];
+    }
+    case "change-state!": {
+      if (it2.length !== 3) break;
+      const id = stateId(st.world, instantiate(it.bnd, it2[1]));
+      if (id !== void 0) {
+        const w = cloneWorld(st.world);
+        w.store.set(id, instantiate(it.bnd, it2[2]));
+        return [[finItem(prev, stateHandle(id), it.bnd)], { counter: st.counter, world: w }];
+      }
+      return [
+        [
+          finItem(
+            prev,
+            errAtom(instantiate(it.bnd, it2[1]), "change-state!: not a state"),
+            it.bnd
+          )
+        ],
+        st
+      ];
+    }
+    case "new-space":
+    case "new-mork-space": {
+      const id = st.counter;
+      const name = "&space-" + String(id);
+      const w = cloneWorld(st.world);
+      w.spaces.set(name, []);
+      return [[finItem(prev, sym(name), it.bnd)], { counter: id + 1, world: w }];
+    }
+    case "fork-space": {
+      if (it2.length !== 2) break;
+      const src = spaceName(st.world, instantiate(it.bnd, it2[1]));
+      if (src === void 0)
+        return [
+          [finItem(prev, errAtom(instantiate(it.bnd, it2[1]), "fork-space: not a space"), it.bnd)],
+          st
+        ];
+      const srcAtoms = src === "&self" ? selfAtoms(env, st.world) : st.world.spaces.get(src) ?? [];
+      const id = st.counter;
+      const name = "&space-" + String(id);
+      const w = cloneWorld(st.world);
+      w.spaces.set(name, [...srcAtoms]);
+      return [[finItem(prev, sym(name), it.bnd)], { counter: id + 1, world: w }];
+    }
+    case "add-atom":
+      if (it2.length === 3) {
+        const added = instantiate(it.bnd, it2[2]);
+        if (opOf(added) === "=") disableTabling(env);
+        return spaceMutate(st, prev, it2[1], it.bnd, (w, name) => appendSpace(w, name, [added]));
+      }
+      break;
+    case "remove-atom":
+      if (it2.length === 3)
+        return spaceMutate(
+          st,
+          prev,
+          it2[1],
+          it.bnd,
+          (w, name) => eraseSpace(w, name, instantiate(it.bnd, it2[2]))
+        );
+      break;
+    case "get-atoms": {
+      if (it2.length !== 2) break;
+      const name = spaceName(st.world, instantiate(it.bnd, it2[1]));
+      if (name === void 0)
+        return [
+          [finItem(prev, errAtom(instantiate(it.bnd, it2[1]), "get-atoms: not a space"), it.bnd)],
+          st
+        ];
+      const list = name === "&self" ? selfAtoms(env, st.world) : st.world.spaces.get(name) ?? [];
+      return [list.map((x) => finItem(prev, x, it.bnd)), st];
+    }
+    case "pragma!": {
+      if (it2.length !== 3) break;
+      const key = instantiate(it.bnd, it2[1]);
+      if (key.kind === "sym" && key.name === "max-stack-depth") {
+        const val = instantiate(it.bnd, it2[2]);
+        const n = val.kind === "gnd" && val.value.g === "int" ? val.value.n : void 0;
+        if (n === void 0 || n < 0 || typeof n === "number" && !Number.isInteger(n))
+          return [[finItem(prev, errAtom(a, "UnsignedIntegerIsExpected"), it.bnd)], st];
+        const w = cloneWorld(st.world);
+        w.maxStackDepth = Number(n);
+        return [[finItem(prev, emptyExpr, it.bnd)], { counter: st.counter, world: w }];
+      }
+      return [[finItem(prev, emptyExpr, it.bnd)], st];
+    }
+    case "bind!": {
+      if (it2.length !== 3) break;
+      const tok2 = instantiate(it.bnd, it2[1]);
+      if (tok2.kind === "sym") {
+        const w = cloneWorld(st.world);
+        w.tokens.set(tok2.name, instantiate(it.bnd, it2[2]));
+        return [[finItem(prev, emptyExpr, it.bnd)], { counter: st.counter, world: w }];
+      }
+      return [[finItem(prev, errAtom(tok2, "bind!: token must be a symbol"), it.bnd)], st];
+    }
+    case "import!": {
+      if (it2.length !== 3) break;
+      const fileAtom = instantiate(it.bnd, it2[2]);
+      if (fileAtom.kind === "sym" && fileAtom.name === "curry") env.curry = true;
+      const fileAtoms = fileAtom.kind === "sym" ? env.imports.get(fileAtom.name) ?? [] : [];
+      registerImportedTypes(env, fileAtoms);
+      if (fileAtoms.some((a2) => opOf(a2) === "=")) disableTabling(env);
+      return spaceMutate(st, prev, it2[1], it.bnd, (w, name) => appendSpace(w, name, fileAtoms));
+    }
+    default:
+      break;
+  }
+  if (isEmbeddedOp(a)) return [[finItem(prev, errAtom(a, "unsupported minimal op"), it.bnd)], st];
+  return [[{ stack: cons(frame(top.atom, top.ret, top.vars, true), prev), bnd: it.bnd }], st];
+}
+function indexSelfRules(w, atoms) {
+  for (const x of atoms) {
+    if (opOf(x) === "=" && x.kind === "expr" && x.items.length === 3) {
+      const lhs = x.items[1];
+      const rhs = x.items[2];
+      const k = headKey(lhs);
+      if (k === void 0) w.selfVarRules = [...w.selfVarRules, [lhs, rhs]];
+      else w.selfRules.set(k, [...w.selfRules.get(k) ?? [], [lhs, rhs]]);
+    }
+  }
+}
+function appendSpace(w0, name, atoms) {
+  if (name === "&self") {
+    let selfRules = w0.selfRules;
+    let selfVarRules = w0.selfVarRules;
+    let copiedRules = false;
+    for (const x of atoms) {
+      if (opOf(x) === "=" && x.kind === "expr" && x.items.length === 3) {
+        if (!copiedRules) {
+          selfRules = new Map(w0.selfRules);
+          copiedRules = true;
+        }
+        const lhs = x.items[1];
+        const rhs = x.items[2];
+        const k = headKey(lhs);
+        if (k === void 0) selfVarRules = [...selfVarRules, [lhs, rhs]];
+        else selfRules.set(k, [...selfRules.get(k) ?? [], [lhs, rhs]]);
+      }
+    }
+    return {
+      spaces: w0.spaces,
+      store: w0.store,
+      tokens: w0.tokens,
+      selfExtra: logAppendAll(w0.selfExtra, atoms),
+      selfRules,
+      selfVarRules,
+      maxStackDepth: w0.maxStackDepth
+    };
+  }
+  const w = cloneWorld(w0);
+  w.spaces.set(name, [...w.spaces.get(name) ?? [], ...atoms]);
+  return w;
+}
+function eraseSpace(w0, name, a) {
+  const w = cloneWorld(w0);
+  const erase1 = (xs) => {
+    const i = xs.findIndex((y) => atomEq(y, a));
+    return i < 0 ? [...xs] : [...xs.slice(0, i), ...xs.slice(i + 1)];
+  };
+  if (name === "&self") {
+    const xs = logToArray(w.selfExtra);
+    const i = xs.findIndex((y) => atomEq(y, a));
+    if (i >= 0) w.selfExtra = logFromArray([...xs.slice(0, i), ...xs.slice(i + 1)]);
+  } else w.spaces.set(name, erase1(w.spaces.get(name) ?? []));
+  return w;
+}
+function spaceMutate(st, prev, s, b, f) {
+  const name = spaceName(st.world, instantiate(b, s));
+  if (name === void 0)
+    return [[finItem(prev, errAtom(instantiate(b, s), "not a space"), b)], st];
+  return [[finItem(prev, emptyExpr, b)], { counter: st.counter, world: f(st.world, name) }];
+}
+function* getTypeOpG(env, fuel, st, prev, xi, b) {
+  const emit = function* (st0) {
+    let acc = [];
+    let cur = st0;
+    for (const t of getTypesForQuery(env, typePrep(st.world, xi))) {
+      const [rs, st2] = yield* mettaEvalG(env, fuel, cur, b, t);
+      acc = [...acc, ...rs.map((p) => finItem(prev, p[0], b))];
+      cur = st2;
+    }
+    return [acc, cur];
+  };
+  if (xi.kind === "expr" && xi.items.length > 0) {
+    const head = xi.items[0];
+    const args = xi.items.slice(1);
+    if (head.kind === "sym") {
+      if (typeMismatch(env, st.world, head.name, args) !== void 0) return [[], st];
+      return yield* emit(st);
+    }
+    const illTyped = getTypes(env, typePrep(st.world, head)).some((ft) => {
+      if (opOf(ft) === "->" && ft.kind === "expr")
+        return typeCheckArgs(env, st.world, ft.items.slice(1, -1), 0, [], args) !== void 0;
+      return false;
+    });
+    return illTyped ? [[], st] : yield* emit(st);
+  }
+  return yield* emit(st);
+}
+function matchOp(env, st, prev, space, pattern, template, b) {
+  const sn = spaceName(st.world, instantiate(b, space));
+  const subbed = subTokens(st.world, pattern);
+  const patterns = opOf(subbed) === "," && subbed.kind === "expr" ? subbed.items.slice(1).map((p) => resolveStates(st.world, p)) : [resolveStates(st.world, subbed)];
+  let getCandidates;
+  if (sn === void 0 || sn === "&self") {
+    getCandidates = (pInst) => matchCandidates(env, st.world, pInst);
+  } else {
+    const named = (st.world.spaces.get(sn) ?? []).map((x) => resolveStates(st.world, x));
+    getCandidates = () => named;
+  }
+  const [sols, st2] = patterns.length >= 2 ? matchConjJoin(getCandidates, patterns, st, b) : matchConj(getCandidates, patterns, st, [b]);
+  const out = [];
+  for (const m of sols) if (!hasLoop(m)) out.push(finItem(prev, instantiate(m, template), m));
+  return [out, st2];
+}
+function* interpretLoopG(env, fuel, st, work, sink) {
+  const done = [];
+  const emit = (pair) => {
+    if (sink !== void 0) sink(pair);
+    else done.push(pair);
+  };
+  const stack = [];
+  for (let i = work.length - 1; i >= 0; i--) stack.push(work[i]);
+  let cur = st;
+  let f = fuel;
+  while (stack.length > 0) {
+    if (f <= 0) {
+      for (let i = stack.length - 1; i >= 0; i--) {
+        const it2 = stack[i];
+        emit(isFinal(it2) ? finalPair(it2) : exhaustedPair(it2));
+      }
+      return [done, cur];
+    }
+    const it = stack.pop();
+    if (cur.world.maxStackDepth > 0) {
+      let depth = 0;
+      for (let p = it.stack; p !== null; p = p.tail) depth++;
+      if (depth >= cur.world.maxStackDepth) {
+        emit(isFinal(it) ? finalPair(it) : exhaustedPair(it));
+        continue;
+      }
+    }
+    const [results, st2] = yield* interpretStack1G(env, f - 1, cur, it);
+    cur = st2;
+    f -= 1;
+    const more = [];
+    for (const r of results) {
+      if (isFinal(r)) {
+        if (sink !== void 0) sink(finalPair(r));
+        else done.push(finalPair(r));
+      } else more.push(r);
+    }
+    for (let i = more.length - 1; i >= 0; i--) stack.push(more[i]);
+  }
+  return [done, cur];
+}
+var evaluatedAtoms = /* @__PURE__ */ new WeakSet();
+function* reduceChildrenG(env, fuel, st, pairs, onTerminal) {
+  const out = [];
+  let cur = st;
+  for (const p of pairs) {
+    const term = onTerminal(p);
+    if (term !== void 0) {
+      out.push(...term);
+    } else {
+      const [more, st3] = yield* mettaEvalG(env, fuel - 1, cur, p[1], p[0]);
+      cur = st3;
+      out.push(...more);
+    }
+  }
+  return [out, cur];
+}
+var runtimeRuleVersionCounter = 0;
+var runtimeRuleVersions = /* @__PURE__ */ new WeakMap();
+function rulesVersion(rules) {
+  if (rules === void 0) return 0;
+  let v = runtimeRuleVersions.get(rules);
+  if (v === void 0) {
+    v = ++runtimeRuleVersionCounter;
+    runtimeRuleVersions.set(rules, v);
+  }
+  return v;
+}
+function collectHeadSyms(a, out) {
+  if (a.kind === "expr" && a.items.length > 0) {
+    if (a.items[0].kind === "sym") out.add(a.items[0].name);
+    for (const it of a.items) collectHeadSyms(it, out);
+  }
+}
+var runtimePureCache = /* @__PURE__ */ new Map();
+function runtimeFunctorPure(env, w, op) {
+  if (env.varRules.some(([lhs]) => isVariableHeaded(lhs)) || w.selfVarRules.length > 0)
+    return false;
+  const ck = op + "@" + rulesVersion(w.selfRules.get(op));
+  const cached = runtimePureCache.get(ck);
+  if (cached !== void 0) return cached;
+  const visit = (f, seen) => {
+    if (seen.has(f)) return true;
+    seen.add(f);
+    const rules = [...env.ruleIndex.get(f) ?? [], ...w.selfRules.get(f) ?? []];
+    for (const [, rhs] of rules) {
+      const heads = /* @__PURE__ */ new Set();
+      collectHeadSyms(rhs, heads);
+      for (const h of heads) {
+        if (IMPURE_OPS.has(h)) return false;
+        if ((env.ruleIndex.has(h) || w.selfRules.has(h)) && !visit(h, seen)) return false;
+      }
+    }
+    return true;
+  };
+  const pure = visit(op, /* @__PURE__ */ new Set());
+  runtimePureCache.set(ck, pure);
+  return pure;
+}
+var COUNT_UNIT = sym("u");
+function countOnlyMatch(z) {
+  return z.kind === "expr" && z.items.length === 4 && opOf(z) === "match" ? expr([z.items[0], z.items[1], z.items[2], COUNT_UNIT]) : z;
+}
+function* mettaEvalG(env, fuel, st, bnd, a) {
+  if (fuel <= 0)
+    return [[[expr([sym("Error"), instantiate(bnd, a), sym("StackOverflow")]), bnd]], st];
+  const w = instantiate(bnd, a);
+  if (w.kind === "expr" && w.ground && evaluatedAtoms.has(w)) return [[[w, bnd]], st];
+  const isErr = (x) => x.kind === "expr" && x.items.length >= 1 && x.items[0].kind === "sym" && x.items[0].name === "Error";
+  if (w.kind === "expr" && w.items.length > 0 && w.items[0].kind === "sym") {
+    let la = a;
+    let lbnd = bnd;
+    let lst = st;
+    let lw = w;
+    const pendingKeys = [];
+    const flushReturn = (res, stR) => {
+      if (pendingKeys.length > 0 && env.table !== void 0 && res.every((p) => p[0].ground)) {
+        const prod = res.map((p) => p[0]);
+        for (const k of pendingKeys) env.table.set(k, prod);
+      }
+      return [res, stR];
+    };
+    reduceTrampoline: for (; ; ) {
+      const op = lw.items[0].name;
+      const args = lw.items.slice(1);
+      if ((op === "length" || op === "size-atom") && args.length === 1 && args[0].kind === "expr" && opOf(args[0]) === "collapse" && args[0].items.length === 2 && !env.ruleIndex.has(op) && !lst.world.selfRules.has(op)) {
+        let count = 0;
+        const [, stC] = yield* interpretLoopG(
+          env,
+          fuel,
+          lst,
+          [
+            {
+              stack: atomToStack(
+                expr([sym("metta"), countOnlyMatch(args[0].items[1]), UNDEF, sym("&self")]),
+                null
+              ),
+              bnd: lbnd
+            }
+          ],
+          () => {
+            count++;
+          }
+        );
+        return flushReturn([[gint(BigInt(count)), lbnd]], stC);
+      }
+      const opSig = env.sigs.get(op);
+      if (opSig !== void 0 && opSig.length >= 1 && args.length !== opSig.length - 1) {
+        const hasTupleType = (env.types.get(op) ?? []).some((t) => opOf(t) !== "->");
+        const underAppliedCurry = env.curry && args.length >= 1 && args.length < opSig.length - 1;
+        if (!hasTupleType && !underAppliedCurry)
+          return flushReturn(
+            [
+              [
+                expr([sym("Error"), expr([sym(op), ...args]), sym("IncorrectNumberOfArguments")]),
+                lbnd
+              ]
+            ],
+            lst
+          );
+      }
+      const mm = typeMismatch(env, lst.world, op, args, opSig);
+      if (mm !== void 0) {
+        const [pos, expected, actual] = mm;
+        return flushReturn(
+          [
+            [
+              expr([
+                sym("Error"),
+                expr([sym(op), ...args]),
+                expr([sym("BadArgType"), gint(pos), expected, actual])
+              ]),
+              lbnd
+            ]
+          ],
+          lst
+        );
+      }
+      const queryVars = args.flatMap((x) => atomVars(x));
+      const sig = opSig;
+      const opReturnsAtom = sig !== void 0 && sig.length > 0 && atomEq(sig[sig.length - 1], sym("Atom"));
+      const mask = LAZY_ARGS_OPS.has(op) ? args.map(() => false) : argMask(sig, args.length);
+      let partials = [[[], []]];
+      let cur = lst;
+      for (let i = 0; i < args.length; i++) {
+        const ae = args[i];
+        const evalThis = mask[i];
+        const nextParts = [];
+        for (const [accAtoms, accB] of partials) {
+          if (evalThis) {
+            const [ps, st2] = yield* mettaEvalG(env, fuel - 1, cur, accB, ae);
+            cur = st2;
+            for (const p of ps) {
+              nextParts.push([[...accAtoms, p[0]], mergeRestrict(queryVars, accB, p[1])]);
+            }
+          } else {
+            nextParts.push([[...accAtoms, instantiate(accB, ae)], accB]);
+          }
+        }
+        partials = nextParts;
+      }
+      const out = [];
+      let cur2 = cur;
+      const tabling = env.table !== void 0 && queryVars.length === 0;
+      const staticPure = env.pureFunctors?.has(op) ?? false;
+      for (const [partAtoms, partB] of partials) {
+        let errFound;
+        for (let i = 0; i < partAtoms.length; i++) {
+          if (isErr(partAtoms[i]) && !atomEq(partAtoms[i], args[i])) {
+            errFound = partAtoms[i];
+            break;
+          }
+        }
+        if (errFound !== void 0) {
+          out.push([errFound, partB]);
+          continue;
+        }
+        const wApp = expr([sym(op), ...partAtoms]);
+        if (env.curry && partAtoms.length >= 1) {
+          const ar = functionArity(env, cur2.world, op);
+          if (ar !== void 0 && partAtoms.length < ar) {
+            out.push([expr([sym("partial"), sym(op), expr(partAtoms)]), partB]);
+            continue;
+          }
+        }
+        if (env.compiled !== void 0) {
+          const cr = runCompiled(env, op, partAtoms);
+          if (cr !== void 0) {
+            out.push([cr, partB]);
+            continue;
+          }
+        }
+        let eligible = false;
+        let key = "";
+        if (tabling && wApp.ground && keyWellFormed(wApp)) {
+          if (cur2.world.selfRules.has(op)) {
+            if (runtimeFunctorPure(env, cur2.world, op)) {
+              eligible = true;
+              key = tableKey(wApp) + "@v" + rulesVersion(cur2.world.selfRules.get(op));
+            }
+          } else if (staticPure) {
+            eligible = true;
+            key = tableKey(wApp);
+          }
+          if (eligible) {
+            const hit = env.table.get(key);
+            if (hit !== void 0) {
+              for (const r of hit) out.push([r, partB]);
+              continue;
+            }
+          }
+        }
+        const before = out.length;
+        const [pairs2, st3] = yield* interpretLoopG(env, fuel, cur2, [
+          { stack: atomToStack(expr([sym("eval"), wApp]), null), bnd: lbnd }
+        ]);
+        cur2 = st3;
+        if (partials.length === 1 && queryVars.length === 0 && pairs2.length === 1) {
+          const p = pairs2[0];
+          const isData = atomEq(p[0], notReducibleA) || atomEq(p[0], wApp);
+          if (!isData && !(opReturnsAtom && !isEmbeddedOp(p[0])) && opOf(p[0]) !== void 0) {
+            const pb = mergeRestrict(queryVars, partB, p[1]);
+            if (eligible) pendingKeys.push(key);
+            la = p[0];
+            lbnd = pb;
+            lst = cur2;
+            lw = instantiate(lbnd, la);
+            continue reduceTrampoline;
+          }
+        }
+        for (const p of pairs2) {
+          const pb = mergeRestrict(queryVars, partB, p[1]);
+          if (atomEq(p[0], notReducibleA) || atomEq(p[0], wApp)) {
+            if (wApp.ground) evaluatedAtoms.add(wApp);
+            out.push([wApp, partB]);
+          } else if (opReturnsAtom && !isEmbeddedOp(p[0])) {
+            out.push([p[0], pb]);
+          } else {
+            const [more, st4] = yield* mettaEvalG(env, fuel - 1, cur2, pb, p[0]);
+            cur2 = st4;
+            for (const m of more) {
+              out.push([m[0], mergeRestrict(queryVars, pb, m[1])]);
+            }
+          }
+        }
+        if (eligible) {
+          const produced = out.slice(before).map((p) => p[0]);
+          if (produced.every((a2) => a2.ground)) env.table.set(key, produced);
+        }
+      }
+      return flushReturn(out, cur2);
+    }
+  }
+  if (w.kind === "expr" && w.items.length > 0) {
+    const [ruleRes, st12] = yield* interpretLoopG(env, fuel, st, [
+      { stack: atomToStack(expr([sym("eval"), w]), null), bnd }
+    ]);
+    const reduced = ruleRes.filter((p) => !atomEq(p[0], w) && !atomEq(p[0], notReducibleA));
+    if (reduced.length === 0) {
+      const [tupleRes, st2] = yield* interpretLoopG(env, fuel, st12, [
+        {
+          stack: atomToStack(
+            expr([sym("eval"), expr([sym("interpret-tuple"), w, sym("&self")])]),
+            null
+          ),
+          bnd
+        }
+      ]);
+      return yield* reduceChildrenG(
+        env,
+        fuel,
+        st2,
+        tupleRes,
+        (p) => atomEq(p[0], w) ? [p] : void 0
+      );
+    }
+    return yield* reduceChildrenG(env, fuel, st12, reduced, () => void 0);
+  }
+  const [pairs, st1] = yield* interpretLoopG(env, fuel, st, [
+    { stack: atomToStack(expr([sym("eval"), w]), null), bnd }
+  ]);
+  return yield* reduceChildrenG(
+    env,
+    fuel,
+    st1,
+    pairs,
+    (p) => atomEq(p[0], notReducibleA) || atomEq(p[0], w) ? [[w, bnd]] : returnsAtom(env, w) && !isEmbeddedOp(p[0]) ? [p] : void 0
+  );
+}
+var DEFAULT_FUEL = 2e6;
+function isNativeStackOverflow(e) {
+  return e instanceof RangeError && /call stack/i.test(e.message);
+}
+function stackOverflowResult(st, bnd, a) {
+  return [[[expr([sym("Error"), instantiate(bnd, a), sym("StackOverflow")]), bnd]], st];
+}
+function mettaEval(env, fuel, st, bnd, a) {
+  ensureCompiled(env);
+  try {
+    return runGenSync(mettaEvalG(env, fuel, st, bnd, a));
+  } catch (e) {
+    if (isNativeStackOverflow(e)) return stackOverflowResult(st, bnd, a);
+    throw e;
+  }
+}
+function mettaEvalAsync(env, fuel, st, bnd, a, signal) {
+  ensureCompiled(env);
+  return runGenAsync(mettaEvalG(env, fuel, st, bnd, a), signal).catch((e) => {
+    if (isNativeStackOverflow(e)) return stackOverflowResult(st, bnd, a);
+    throw e;
+  });
+}
+function evalAtom(env, atom, st = initSt(), fuel = DEFAULT_FUEL) {
+  const [pairs, st2] = mettaEval(env, fuel, st, [], atom);
+  return [pairs.map((p) => p[0]), st2];
+}
+
+// src/tabling.ts
+var IMPURE_OPS = /* @__PURE__ */ new Set([
+  "add-atom",
+  "remove-atom",
+  "add-reduct",
+  "add-reducts",
+  "add-atoms",
+  "new-state",
+  "get-state",
+  "change-state!",
+  "new-space",
+  "new-mork-space",
+  "fork-space",
+  "get-atoms",
+  "bind!",
+  "import!",
+  "transaction",
+  "context-space",
+  "par",
+  "race",
+  "once",
+  "with-mutex",
+  "superpose",
+  "hyperpose",
+  "collapse",
+  "collapse-bind",
+  "superpose-bind",
+  "collapse-extract",
+  "match",
+  "metta",
+  "metta-thread",
+  "capture",
+  "println!",
+  "print!",
+  "trace!",
+  "pragma!",
+  "register-module!",
+  "get-type",
+  "get-type-space",
+  "get-doc",
+  "empty"
+]);
+function headSymbols(a, out) {
+  if (a.kind === "expr" && a.items.length > 0) {
+    if (a.items[0].kind === "sym") out.add(a.items[0].name);
+    for (const it of a.items) headSymbols(it, out);
+  }
+  return out;
+}
+function variableHeaded(a) {
+  return a.kind === "var" || a.kind === "expr" && a.items.length > 0 && variableHeaded(a.items[0]);
+}
+function analyzePurity(env) {
+  if (env.varRules.some(([lhs]) => variableHeaded(lhs))) return /* @__PURE__ */ new Set();
+  const deps = /* @__PURE__ */ new Map();
+  for (const [k, eqs] of env.ruleIndex) {
+    const s = /* @__PURE__ */ new Set();
+    for (const [, rhs] of eqs) headSymbols(rhs, s);
+    deps.set(k, s);
+  }
+  const impure = /* @__PURE__ */ new Set();
+  for (const [k, s] of deps) {
+    for (const h of s)
+      if (IMPURE_OPS.has(h)) {
+        impure.add(k);
+        break;
+      }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [k, s] of deps) {
+      if (impure.has(k)) continue;
+      for (const h of s)
+        if (impure.has(h)) {
+          impure.add(k);
+          changed = true;
+          break;
+        }
+    }
+  }
+  const pure = /* @__PURE__ */ new Set();
+  for (const k of deps.keys()) if (!impure.has(k)) pure.add(k);
+  return pure;
+}
+function tableKey(call) {
+  return format(call);
+}
+function keyWellFormed(a) {
+  if (a.kind === "gnd") return a.value.g !== "float";
+  if (a.kind === "expr") return a.items.every(keyWellFormed);
+  return true;
+}
+
+// src/unify.ts
+function decomposeEq(a, b) {
+  if (a.kind === "var" && b.kind === "var") return a.name === b.name ? [] : [[a.name, b]];
+  if (a.kind === "var") return [[a.name, b]];
+  if (b.kind === "var") return [[b.name, a]];
+  if (a.kind === "sym" && b.kind === "sym") return a.name === b.name ? [] : null;
+  if (a.kind === "gnd" && b.kind === "gnd") return atomEq(a, b) ? [] : null;
+  if (a.kind === "expr" && b.kind === "expr") return decomposeList(a.items, b.items);
+  return null;
+}
+function decomposeList(xs, ys) {
+  if (xs.length !== ys.length) return null;
+  const out = [];
+  for (let i = 0; i < xs.length; i++) {
+    const c = decomposeEq(xs[i], ys[i]);
+    if (c === null) return null;
+    out.push(...c);
+  }
+  return out;
+}
+function decomposeAll(eqs) {
+  const out = [];
+  for (const [a, b] of eqs) {
+    const c = decomposeEq(a, b);
+    if (c === null) return null;
+    out.push(...c);
+  }
+  return out;
+}
+function unifyRounds(fuel, eqs, s) {
+  const decomposed = decomposeAll(eqs);
+  if (decomposed === null) return null;
+  if (decomposed.length === 0) return s;
+  if (fuel <= 0) return null;
+  const [x, t] = decomposed[0];
+  const rest = decomposed.slice(1);
+  if (occurs(x, t)) return null;
+  const sub = [[x, t]];
+  const rest2 = rest.map((p) => [
+    applySubst(sub, variable(p[0])),
+    applySubst(sub, p[1])
+  ]);
+  return unifyRounds(fuel - 1, rest2, extendSubst(s, x, t));
+}
+function unifyTop(a, b) {
+  return unifyRounds(atomSize(a) + atomSize(b), [[a, b]], []);
+}
+function unifiable(a, b) {
+  return unifyTop(a, b) !== null;
+}
+
+// src/space.ts
+var InMemorySpace = class {
+  store = [];
+  add(atom) {
+    this.store.push(atom);
+  }
+  remove(atom) {
+    const i = this.store.findIndex((a) => atomEq(a, atom));
+    if (i < 0) return false;
+    this.store.splice(i, 1);
+    return true;
+  }
+  query(pattern, freshen) {
+    const out = [];
+    for (const a of this.store) {
+      const target = freshen ? freshen(a) : a;
+      for (const b of matchAtoms(pattern, target)) out.push(b);
+    }
+    return out;
+  }
+  atoms() {
+    return this.store;
+  }
+};
+
+// src/prelude.ts
+var PRELUDE_SRC = '(: + (-> Number Number Number))\n   (: - (-> Number Number Number))\n   (: * (-> Number Number Number))\n   (: / (-> Number Number Number))\n   (: % (-> Number Number Number))\n   (: = (-> $t $t %Undefined%))\n   (: == (-> $t $t Bool))\n   (: < (-> Number Number Bool))\n   (: > (-> Number Number Bool))\n   (: <= (-> Number Number Bool))\n   (: >= (-> Number Number Bool))\n   (: get-type (-> Atom Atom))\n   (: get-doc (-> Atom %Undefined%))\n   (: help! (-> Atom %Undefined%))\n   (: eval (-> Atom Atom))\n   (: evalc (-> Atom SpaceType Atom))\n   (: chain (-> Atom Variable Atom %Undefined%))\n   (: unify (-> Atom Atom Atom Atom %Undefined%))\n   (: function (-> Atom Atom))\n   (: return (-> Atom Atom))\n   (: cons-atom (-> Atom Expression Atom))\n   (: decons-atom (-> Expression Atom))\n   (: collapse-bind (-> Atom Expression))\n   (: superpose-bind (-> Expression Atom))\n   (: metta (-> Atom Atom Atom Atom))\n   (: quote (-> Atom Atom))\n   (: new-state (-> $t (StateMonad $t)))\n   (: change-state! (-> (StateMonad $t) $t (StateMonad $t)))\n   (: if (-> Bool Atom Atom $t))\n   (: let (-> Atom %Undefined% Atom %Undefined%))\n   (: let* (-> Expression Atom %Undefined%))\n   (: car-atom (-> Expression %Undefined%))\n   (: cdr-atom (-> Expression Expression))\n   (: switch (-> %Undefined% Expression %Undefined%))\n   (: interpret-tuple (-> Atom Atom Atom))\n   (= (interpret-tuple $expr $space)\n      (function (eval (if-equal $expr ()\n        (return ())\n        (chain (decons-atom $expr) $ht\n          (unify ($head $tail) $ht\n            (chain (metta-thread $head %Undefined% $space) $rhead\n              (chain (eval (interpret-tuple $tail $space)) $rtail\n                (chain (cons-atom $rhead $rtail) $res (return $res))))\n            (return $expr)))))))\n   (: switch-minimal (-> Atom Expression Atom))\n   (: switch-internal (-> Atom Expression Atom))\n   (: collapse (-> Atom Atom))\n   (: unique (-> Atom %Undefined%))\n   (: union (-> Atom Atom %Undefined%))\n   (: intersection (-> Atom Atom %Undefined%))\n   (: subtraction (-> Atom Atom %Undefined%))\n   (: Error (-> Atom Atom Atom))\n   (: noeval (-> Atom Atom))\n   (: id (-> $t $t))\n   (: match (-> Atom Atom Atom %Undefined%))\n   (: if-decons-expr (-> Expression Variable Variable Atom Atom %Undefined%))\n   (: foldl-atom (-> Expression Atom Variable Variable Atom %Undefined%))\n   (: assert (-> Atom (->)))\n   (: assertIncludes (-> Atom Expression (->)))\n   (: assertEqual (-> Atom Atom (->)))\n   (: assertEqualMsg (-> Atom Atom Atom (->)))\n   (: assertEqualToResult (-> Atom Atom (->)))\n   (: assertEqualToResultMsg (-> Atom Atom Atom (->)))\n   (: assertAlphaEqual (-> Atom Atom (->)))\n   (: assertAlphaEqualMsg (-> Atom Atom Atom (->)))\n   (: assertAlphaEqualToResult (-> Atom Atom (->)))\n   (: assertAlphaEqualToResultMsg (-> Atom Atom Atom (->)))\n   (= (if True $t $e) $t)\n   (= (if False $t $e) $e)\n   (= (id $x) $x)\n   (= (noeval $x) $x)\n   (= (quote $atom) NotReducible)\n   (= (unquote (quote $atom)) $atom)\n   (= (nop) ())\n   (= (let $pattern $atom $template) (unify $atom $pattern $template Empty))\n   (= (let* $pairs $template)\n      (chain (decons-atom $pairs) $ht\n        (unify ($head $tail) $ht\n          (unify ($pat $at) $head\n            (let $pat $at (let* $tail $template))\n            (Error (let* $pairs $template) bad-let-star))\n          $template)))\n   (= (car-atom $a)\n      (chain (decons-atom $a) $ht (unify ($head $tail) $ht $head (Error (car-atom $a) car-atom-empty))))\n   (= (cdr-atom $a)\n      (chain (decons-atom $a) $ht (unify ($head $tail) $ht $tail (Error (cdr-atom $a) cdr-atom-empty))))\n   (= (switch $atom $cases) (id (switch-minimal $atom $cases)))\n   (= (switch-minimal $atom $cases)\n      (function (chain (decons-atom $cases) $list\n        (chain (eval (switch-internal $atom $list)) $res\n          (chain (eval (if-equal $res NotReducible Empty $res)) $x (return $x))))))\n   (= (switch-internal $atom (($pattern $template) $tail))\n      (function (unify $atom $pattern\n        (return $template)\n        (chain (eval (switch-minimal $atom $tail)) $ret (return $ret)))))\n   (: case (-> Atom Expression %Undefined%))\n   (= (case $atom $cases)\n      (function\n        (chain (context-space) $space\n        (chain (collapse-bind (metta $atom %Undefined% $space)) $c\n        (chain (eval (== $c ())) $is_empty\n        (unify $is_empty True\n          (chain (eval (switch-minimal Empty $cases)) $r (return $r))\n          (chain (superpose-bind $c) $e\n            (chain (eval (switch-minimal $e $cases)) $r (return $r)))))))))\n   (= (collapse $atom)\n      (function (chain (context-space) $space\n        (chain (collapse-bind (metta $atom %Undefined% $space)) $pairs\n          (chain (eval (collapse-extract $pairs)) $r (return $r))))))\n   (= (unique $arg) (let $c (collapse $arg) (let $u (unique-atom $c) (superpose $u))))\n   (= (union $a $b) (let $c1 (collapse $a) (let $c2 (collapse $b) (let $u (union-atom $c1 $c2) (superpose $u)))))\n   (= (intersection $a $b) (let $c1 (collapse $a) (let $c2 (collapse $b) (let $u (intersection-atom $c1 $c2) (superpose $u)))))\n   (= (subtraction $a $b) (let $c1 (collapse $a) (let $c2 (collapse $b) (let $u (subtraction-atom $c1 $c2) (superpose $u)))))\n   (: atom-subst (-> Atom Variable Atom Atom))\n   (= (atom-subst $atom $var $templ)\n      (function (chain (eval (noeval $atom)) $var (return $templ))))\n   (: map-atom (-> Expression Variable Atom Expression))\n   (= (map-atom $list $var $map)\n      (function (chain (decons-atom $list) $ht\n        (unify ($head $tail) $ht\n          (chain (eval (sealed ($var) $map)) $sealedmap\n            (chain (eval (map-atom $tail $var $sealedmap)) $tail-mapped\n              (chain (eval (atom-subst $head $var $sealedmap)) $map-expr\n                (chain (metta $map-expr %Undefined% &self) $head-mapped\n                  (chain (cons-atom $head-mapped $tail-mapped) $res (return $res))))))\n          (return ())))))\n   (: filter-atom (-> Expression Variable Atom Expression))\n   (= (filter-atom $list $var $filter)\n      (function (chain (decons-atom $list) $ht\n        (unify ($head $tail) $ht\n          (chain (eval (sealed ($var) $filter)) $sealedfilter\n            (chain (eval (filter-atom $tail $var $sealedfilter)) $tail-filtered\n              (chain (eval (atom-subst $head $var $sealedfilter)) $filter-expr\n                (chain (metta $filter-expr %Undefined% &self) $is-filtered\n                  (eval (if $is-filtered\n                    (chain (cons-atom $head $tail-filtered) $res (return $res))\n                    (return $tail-filtered)))))))\n          (return ())))))\n   (= (if-decons-expr $atom $head $tail $then $else)\n      (function (eval (if-equal $atom ()\n        (return $else)\n        (chain (decons-atom $atom) $list\n          (unify $list ($head $tail) (return $then) (return $else)))))))\n   (= (foldl-atom $list $init $a $b $op)\n      (function (eval (if-equal $list ()\n        (return $init)\n        (chain (decons-atom $list) $ht\n          (unify ($head $tail) $ht\n            (chain (eval (atom-subst $init $a $op)) $op1\n              (chain (eval (atom-subst $head $b $op1)) $op2\n                (chain (metta $op2 %Undefined% &self) $newacc\n                  (chain (eval (foldl-atom $tail $newacc $a $b $op)) $r (return $r)))))\n            (return $init)))))))\n   (= (assert $atom)\n      (chain (context-space) $space\n        (chain (metta $atom %Undefined% $space) $eval-atom\n          (unify $eval-atom True () (Error (assert $atom) ($atom not True))))))\n   (= (assertIncludes $atom $content)\n      (let $eval_atom (collapse $atom)\n        (let $diff (subtraction-atom $content $eval_atom)\n          (if (== $diff ())\n            ()\n            (Error (assertIncludes $atom $content)\n              (assertIncludes error: $diff not included in result: $eval_atom))))))\n   (= (assertEqual $actual $expected)\n      (chain (context-space) $space\n        (chain (metta (collapse $actual) %Undefined% $space) $actual-results\n          (chain (metta (collapse $expected) %Undefined% $space) $expected-results\n            (eval (_assert-results-are-equal $actual-results $expected-results (assertEqual $actual $expected)))))))\n   (= (assertEqualMsg $actual $expected $msg)\n      (chain (context-space) $space\n        (chain (metta (collapse $actual) %Undefined% $space) $actual-results\n          (chain (metta (collapse $expected) %Undefined% $space) $expected-results\n            (eval (_assert-results-are-equal-msg $actual-results $expected-results (assertEqualMsg $actual $expected) $msg))))))\n   (= (assertEqualToResult $actual $expected-results)\n      (chain (context-space) $space\n        (chain (metta (collapse $actual) %Undefined% $space) $actual-results\n          (eval (_assert-results-are-equal $actual-results $expected-results (assertEqualToResult $actual $expected-results))))))\n   (= (assertEqualToResultMsg $actual $expected-results $msg)\n      (chain (context-space) $space\n        (chain (metta (collapse $actual) %Undefined% $space) $actual-results\n          (eval (_assert-results-are-equal-msg $actual-results $expected-results (assertEqualToResultMsg $actual $expected-results) $msg)))))\n   (= (assertAlphaEqual $actual $expected)\n      (chain (context-space) $space\n        (chain (metta (collapse $actual) %Undefined% $space) $actual-results\n          (chain (metta (collapse $expected) %Undefined% $space) $expected-results\n            (eval (_assert-results-are-alpha-equal $actual-results $expected-results (assertAlphaEqual $actual $expected)))))))\n   (= (assertAlphaEqualMsg $actual $expected $msg)\n      (chain (context-space) $space\n        (chain (metta (collapse $actual) %Undefined% $space) $actual-results\n          (chain (metta (collapse $expected) %Undefined% $space) $expected-results\n            (eval (_assert-results-are-alpha-equal-msg $actual-results $expected-results (assertAlphaEqualMsg $actual $expected) $msg))))))\n   (= (assertAlphaEqualToResult $actual $expected-results)\n      (chain (context-space) $space\n        (chain (metta (collapse $actual) %Undefined% $space) $actual-results\n          (eval (_assert-results-are-alpha-equal $actual-results $expected-results (assertAlphaEqualToResult $actual $expected-results))))))\n   (= (assertAlphaEqualToResultMsg $actual $expected-results $msg)\n      (chain (context-space) $space\n        (chain (metta (collapse $actual) %Undefined% $space) $actual-results\n          (eval (_assert-results-are-alpha-equal-msg $actual-results $expected-results (assertAlphaEqualToResultMsg $actual $expected-results) $msg)))))\n   (: noreduce-eq (-> Atom Atom Bool))\n   (= (noreduce-eq $a $b) (== (quote $a) (quote $b)))\n   (: if-error (-> Atom Atom Atom %Undefined%))\n   (= (if-error $atom $then $else)\n      (function (chain (eval (get-metatype $atom)) $meta\n        (eval (if-equal $meta Expression\n          (eval (if-equal $atom ()\n            (return $else)\n            (chain (decons-atom $atom) $list\n              (unify $list ($head $tail)\n                (eval (if-equal $head Error (return $then) (return $else)))\n                (return $else) ))))\n          (return $else) )))))\n   (: return-on-error (-> Atom Atom %Undefined%))\n   (= (return-on-error $atom $then)\n      (function (eval (if-equal $atom Empty (return (return Empty))\n        (eval (if-error $atom (return (return $atom))\n          (return $then) ))))))\n   (: for-each-in-atom (-> Expression Atom (->)))\n   (= (for-each-in-atom $expr $func)\n      (if (noreduce-eq $expr ())\n        ()\n        (let $head (car-atom $expr)\n          (let $tail (cdr-atom $expr)\n          (let $_ ($func $head)\n          (for-each-in-atom $tail $func) )))))\n   (: is-function (-> Type Bool))\n   (= (is-function $type)\n      (let $mtype (get-metatype $type)\n        (unify $mtype Expression\n          (let $size (size-atom $type)\n            (unify $size 0\n              False\n              (let ($h $t) (decons-atom $type)\n                (unify $h -> True False))))\n          False)))\n   (: match-types (-> Type Type Atom Atom %Undefined%))\n   (= (match-types $type1 $type2 $then $else)\n      (function (eval (if-equal $type1 %Undefined%\n        (return $then)\n        (eval (if-equal $type2 %Undefined%\n          (return $then)\n          (eval (if-equal $type1 Atom\n            (return $then)\n            (eval (if-equal $type2 Atom\n              (return $then)\n              (unify $type1 $type2 (return $then) (return $else)) ))))))))))\n   (: match-type-or (-> Bool Atom Type Bool))\n   (= (match-type-or $folded $next $type)\n      (function\n        (chain (eval (match-types $next $type True False)) $matched\n          (chain (eval (or $folded $matched)) $or (return $or)) )))\n   (: first-from-pair (-> Expression Atom))\n   (= (first-from-pair $pair)\n      (function\n        (unify $pair ($first $second)\n          (return $first)\n          (return (Error (first-from-pair $pair) "incorrect pair format")))))\n   (: type-cast-error-or-bad-type (-> Atom Expression Atom))\n   (= (type-cast-error-or-bad-type $atom $actual-types)\n      (function\n        (chain (eval (filter-atom $actual-types $actual (eval (if-error $actual True False)))) $actual-errors\n          (chain (decons-atom $actual-errors) $error-and-tail\n            (unify $error-and-tail ($error $tail)\n              (return $error)\n              (return (Error $atom BadType)))))))\n   (: type-cast (-> Atom Type Space %Undefined%))\n   (= (type-cast $atom $type $space)\n      (function (chain (eval (get-metatype $atom)) $meta\n        (eval (if-equal $type $meta\n          (return $atom)\n          (chain (eval (collapse-bind (eval (get-type $atom $space)))) $collapsed\n            (chain (eval (map-atom $collapsed $pair (eval (first-from-pair $pair)))) $actual-types\n              (chain (eval (foldl-atom $actual-types False $a $b (eval (match-type-or $a $b $type)))) $is-some-comp\n                (eval (if $is-some-comp\n                  (return $atom)\n                  (chain (eval (type-cast-error-or-bad-type $atom $actual-types)) $error (return $error)) ))))))))))\n   (: ErrorType Type)\n   (: SpaceType Type)\n   (: BadType (-> Type Type ErrorDescription))\n   (: BadArgType (-> Number Type Type ErrorDescription))\n   (: IncorrectNumberOfArguments ErrorDescription)\n   (: add-atom (-> SpaceType Atom (->)))\n   (: remove-atom (-> SpaceType Atom (->)))\n   (: add-reduct (-> SpaceType %Undefined% (->)))\n   (= (add-reduct $dst $atom) (add-atom $dst $atom))\n   (: add-reducts (-> SpaceType %Undefined% (->)))\n   (= (add-reducts $space $tuple) (foldl-atom $tuple () $a $b (add-reduct $space $b)))\n   (: add-atoms (-> SpaceType Expression (->)))\n   (= (add-atoms $space $tuple) (foldl-atom $tuple () $a $b (add-atom $space $b)))\n';
+
+// src/extensions.ts
+var CONCURRENCY_MODULE_SRC = `
+  (: transaction (-> Atom %Undefined%))
+`;
+var CURRY_MODULE_SRC = `
+  (: partial (-> Atom Expression Atom))
+
+  ; Apply a closure to further arguments: append them to the bound list, rebuild the call, evaluate it.
+  ; append is forced through its own let (cons-atom would otherwise take it as a literal subexpression),
+  ; and the rebuilt call is fully reduced with metta (eval is a single step), which re-curries if still
+  ; under-applied.
+  (= ((partial $f $bound) $a)
+     (let $args (append $bound ($a))
+       (let $call (cons-atom $f $args) (metta $call %Undefined% &self))))
+  (= ((partial $f $bound) $a $b)
+     (let $args (append $bound ($a $b))
+       (let $call (cons-atom $f $args) (metta $call %Undefined% &self))))
+
+  ; An under-applied |-> lambda (head is an expression, so the core hook does not see it) becomes a
+  ; partial closure over the lambda value; applying it later rebuilds the full application.
+  (= ((|-> ($p1 $p2) $body) $a1)
+     (partial (|-> ($p1 $p2) $body) ($a1)))
+  (= ((|-> ($p1 $p2 $p3) $body) $a1)
+     (partial (|-> ($p1 $p2 $p3) $body) ($a1)))
+  (= ((|-> ($p1 $p2 $p3) $body) $a1 $a2)
+     (partial (|-> ($p1 $p2 $p3) $body) ($a1 $a2)))
+`;
+var moduleCache = /* @__PURE__ */ new Map();
+function parseModule(src) {
+  return parseAll(src, standardTokenizer()).filter((t) => !t.bang).map((t) => t.atom);
+}
+function builtinModules() {
+  if (moduleCache.size === 0) {
+    moduleCache.set("concurrency", parseModule(CONCURRENCY_MODULE_SRC));
+    moduleCache.set("curry", parseModule(CURRY_MODULE_SRC));
+  }
+  return moduleCache;
+}
+function withBuiltinModules(extra) {
+  const out = new Map(builtinModules());
+  if (extra) {
+    for (const [k, v] of extra) if (!out.has(k)) out.set(k, v);
+  }
+  return out;
+}
+
+// src/stdlib.ts
+var STDLIB_SRC = `
+  ; ---- Types of the grounded ops (math, bool, atom). Hyperon's grounded atoms carry their type
+  ; intrinsically and \`get-type\` reads it; @metta-ts grounds these as host functions in builtins.ts,
+  ; so the type signature is declared here to match. Values from hyperon-experimental math.rs/atom.rs
+  ; (math ops are f64-valued, so e.g. pow-math/sqrt-math return Number; min-atom/max-atom take any
+  ; expression, typed %Undefined% -> Number). The core arithmetic and comparison ops (+ - < == \u2026) are
+  ; already declared in the prelude.
+  (: pow-math (-> Number Number Number))
+  (: sqrt-math (-> Number Number))
+  (: abs-math (-> Number Number))
+  (: log-math (-> Number Number Number))
+  (: trunc-math (-> Number Number))
+  (: ceil-math (-> Number Number))
+  (: floor-math (-> Number Number))
+  (: round-math (-> Number Number))
+  (: sin-math (-> Number Number))
+  (: asin-math (-> Number Number))
+  (: cos-math (-> Number Number))
+  (: acos-math (-> Number Number))
+  (: tan-math (-> Number Number))
+  (: atan-math (-> Number Number))
+  (: isnan-math (-> Number Bool))
+  (: isinf-math (-> Number Bool))
+  (: min-atom (-> %Undefined% Number))
+  (: max-atom (-> %Undefined% Number))
+  (: and (-> Bool Bool Bool))
+  (: or (-> Bool Bool Bool))
+  (: not (-> Bool Bool))
+  (: xor (-> Bool Bool Bool))
+
+  ; sealed alpha-renames the variables of its second argument. That argument is Atom-typed so the
+  ; body reaches sealed unevaluated (hyperon-experimental core.rs: (-> Expression Atom Atom)); without
+  ; this the reduce loop would evaluate the body first, e.g. collapsing (== 1 $e) before renaming.
+  (: sealed (-> Expression Atom Atom))
+
+  ; ---- IO (host primitives grounded in builtins.ts) ----
+  (: println! (-> %Undefined% (->)))
+  (: print! (-> %Undefined% (->)))
+  (: format-args (-> String Expression String))
+  ; repr renders an atom's textual form. The argument is Atom-typed (not evaluated) so repr shows the
+  ; atom as written; to repr a reduced form, evaluate it first (e.g. bind it with let).
+  (: repr (-> Atom String))
+
+  ; trace! prints its first argument and returns the (evaluated) second.
+  (: trace! (-> %Undefined% %Undefined% %Undefined%))
+  (= (trace! $msg $ret) (let $unit (println! $msg) $ret))
+
+  ; include = import a module's contents into the current space.
+  (: include (-> Atom %Undefined%))
+  (= (include $module) (import! &self $module))
+
+  ; ---- Error system ----
+  (: ErrorType Type)
+  (: ErrorDescription Type)
+  (: IncorrectNumberOfArguments ErrorDescription)
+  (: BadType (-> Type Type ErrorDescription))
+  (: BadArgType (-> Number Type Type ErrorDescription))
+
+  ; ---- Module system (minimal: @metta-ts resolves modules via import! into a space) ----
+  (: module-space-no-deps (-> SpaceType SpaceType))
+  (= (module-space-no-deps $s) $s)
+  (: print-mods! (-> (->)))
+  (= (print-mods!) ())
+  (: git-module! (-> Atom (->)))
+  (= (git-module! $url) (Error (git-module! $url) "git-module! is not supported in @metta-ts"))
+
+  ; ---- Documentation system (ported from hyperon stdlib.metta) ----
+  (: DocDescription Type)
+  (: DocInformal Type)
+  (: DocFormal Type)
+  (: DocItem Type)
+  (: DocKindFunction Type)
+  (: DocKindAtom Type)
+  (: DocType Type)
+  (: DocParameters Type)
+  (: DocParameter Type)
+  (: DocParameterInformal Type)
+  (: DocReturn Type)
+  (: DocReturnInformal Type)
+  (: @doc (-> Atom DocDescription DocParameters DocReturnInformal DocInformal))
+  (: @desc (-> String DocDescription))
+  (: @param (-> DocType DocDescription DocParameter))
+  (: @return (-> DocType DocDescription DocReturn))
+  (: @doc-formal (-> DocItem DocKindFunction DocType DocDescription DocParameters DocReturn DocFormal))
+  (: @item (-> Atom DocItem))
+  (: @kind (-> Atom DocKindFunction))
+  (: @type (-> Type DocType))
+  (: @params (-> Expression DocParameters))
+
+  (= (get-doc-single-atom $space $atom)
+    (let $type (get-type-space $space $atom)
+      (if (is-function $type)
+        (get-doc-function $space $atom $type)
+        (get-doc-atom $space $atom) )))
+  (= (get-doc-function $space $name $type)
+    (unify $space (@doc $name $desc (@params $params) $ret)
+      (let $type' (if (== $type %Undefined%) (undefined-doc-function-type $params) (cdr-atom $type))
+      (let ($params' $ret') (get-doc-params $params $ret $type')
+        (@doc-formal (@item $name) (@kind function) (@type $type) $desc (@params $params') $ret')))
+      Empty ))
+  (= (get-doc-atom $space $atom)
+    (let $type (get-type-space $space $atom)
+      (unify $space (@doc $atom $desc)
+        (@doc-formal (@item $atom) (@kind atom) (@type $type) $desc)
+        (unify $space (@doc $atom $desc' (@params $params) $ret)
+          (get-doc-function $space $atom %Undefined%)
+          Empty ))))
+  (= (get-doc-params $params $ret $types)
+    (let $head-type (car-atom $types)
+    (let $tail-types (cdr-atom $types)
+      (if (== () $params)
+        (let (@return $ret-desc) $ret
+          (() (@return (@type $head-type) (@desc $ret-desc))) )
+        (let (@param $param-desc) (car-atom $params)
+          (let $tail-params (cdr-atom $params)
+          (let ($params' $result-ret) (get-doc-params $tail-params $ret $tail-types)
+          (let $result-params (cons-atom (@param (@type $head-type) (@desc $param-desc)) $params')
+            ($result-params $result-ret) ))))))))
+  (= (undefined-doc-function-type $params)
+    (if (== () $params) (%Undefined%)
+      (let $params-tail (cdr-atom $params)
+      (let $tail (undefined-doc-function-type $params-tail)
+        (cons-atom %Undefined% $tail) ))))
+  (= (help-param! $param)
+    (let (@param (@type $type) (@desc $desc)) $param
+      (println! (format-args "  {} {}" ((type $type) $desc))) ))
+  (: help-space! (-> SpaceType (->)))
+  (= (help-space! $space)
+    (let $_ (collapse
+      (unify $space (@doc $name (@desc $desc) $params $ret)
+        (let () (println! (format-args "{} {}" ($name $desc))) Empty)
+        Empty )) ()))
+
+  ; mod-space! loads a module into a fresh space and returns it.
+  (: mod-space! (-> Atom SpaceType))
+  (= (mod-space! $module) (let $s (new-space) (let $u (import! $s $module) $s)))
+`;
+var cache;
+function stdlibAtoms() {
+  if (cache === void 0)
+    cache = parseAll(STDLIB_SRC, standardTokenizer()).filter((t) => !t.bang).map((t) => t.atom);
+  return cache;
+}
+
+// src/petta-stdlib.ts
+var PETTA_STDLIB_SRC = `
+  ; ---- Types of the PeTTa-compat grounded ops (grounded in builtins.ts pettaEntries). These are not
+  ; Hyperon ops; PeTTa's lib_builtin_types declares them, so the types are declared here to match. ----
+  (: exp (-> Number Number))
+  (: min (-> Number Number Number))
+  (: max (-> Number Number Number))
+
+  ; A |-> lambda is a value: (|-> (params) body) has no rewrite of its own, only its application does.
+  ; The body is Atom-typed so it is carried unevaluated. Without this, evaluating the lambda value (e.g.
+  ; when it is bound by let, whose value slot is %Undefined%-typed and so evaluated) would reduce the body
+  ; early, collapsing a nondeterministic body before the lambda is ever applied.
+  (: |-> (-> Expression Atom Atom))
+
+  ; ---- anonymous function application: ((|-> (params...) body) args...) ----
+  ; Each clause seals the (params body) to fresh variables, binds the fresh params to the arguments, then
+  ; evaluates the fresh body. sealing is what makes a lambda reusable inside a higher-order function.
+  ; Limitation: one clause per arity (1-5 here). A single variadic clause is not expressible because a
+  ; MeTTa rule head has a fixed shape \u2014 it cannot match "the lambda applied to any number of arguments";
+  ; extend by adding the next arity. (PeTTa handles this in its translator, not in MeTTa.)
+  (= ((|-> ($p1) $body) $a1)
+     (let* (((($q1) $sb) (sealed () (($p1) $body))) ($q1 $a1)) $sb))
+  (= ((|-> ($p1 $p2) $body) $a1 $a2)
+     (let* (((($q1 $q2) $sb) (sealed () (($p1 $p2) $body))) ($q1 $a1) ($q2 $a2)) $sb))
+  (= ((|-> ($p1 $p2 $p3) $body) $a1 $a2 $a3)
+     (let* (((($q1 $q2 $q3) $sb) (sealed () (($p1 $p2 $p3) $body))) ($q1 $a1) ($q2 $a2) ($q3 $a3)) $sb))
+  (= ((|-> ($p1 $p2 $p3 $p4) $body) $a1 $a2 $a3 $a4)
+     (let* (((($q1 $q2 $q3 $q4) $sb) (sealed () (($p1 $p2 $p3 $p4) $body)))
+            ($q1 $a1) ($q2 $a2) ($q3 $a3) ($q4 $a4)) $sb))
+  (= ((|-> ($p1 $p2 $p3 $p4 $p5) $body) $a1 $a2 $a3 $a4 $a5)
+     (let* (((($q1 $q2 $q3 $q4 $q5) $sb) (sealed () (($p1 $p2 $p3 $p4 $p5) $body)))
+            ($q1 $a1) ($q2 $a2) ($q3 $a3) ($q4 $a4) ($q5 $a5)) $sb))
+
+  ; ---- foldall: fold an aggregator over ALL nondeterministic results of a generator ----
+  ; The generator is Atom-typed so it reaches foldall unevaluated; collapse then runs it and collects the
+  ; results into a tuple, which fold-over walks left to right. The aggregator stays Atom-typed (a symbol or a
+  ; lambda); the accumulator is evaluated so each application reduces.
+  (: foldall (-> Atom Atom Atom %Undefined%))
+  (: fold-over (-> Atom %Undefined% Atom %Undefined%))
+  (= (fold-over $agg $acc $t)
+     (if (== $t ())
+         $acc
+         (let* (($h (car-atom $t)) ($r (cdr-atom $t)))
+           (fold-over $agg ($agg $acc $h) $r))))
+  (= (foldall $agg $gen $init)
+     (let $rs (collapse $gen) (fold-over $agg $init $rs)))
+
+  ; ---- cons (PeTTa alias of cons-atom) ----
+  (= (cons $h $t) (cons-atom $h $t))
+
+  ; ---- progn: evaluate each argument in order, return the last (arguments evaluate applicatively, so the
+  ;      earlier ones run for their side effects) ----
+  (= (progn $a) $a)
+  (= (progn $a $b) $b)
+  (= (progn $a $b $c) $c)
+  (= (progn $a $b $c $d) $d)
+
+  ; ---- prog1: evaluate each argument in order, return the FIRST (the others run for their side effects) ----
+  (= (prog1 $a) $a)
+  (= (prog1 $a $b) $a)
+  (= (prog1 $a $b $c) $a)
+  (= (prog1 $a $b $c $d) $a)
+
+  ; ---- forall: True iff every nondeterministic result of the generator passes the check ----
+  (: forall (-> Atom Atom Bool))
+  (: all-true (-> Atom %Undefined% Bool))
+  (= (all-true $check $rs)
+     (if (== $rs ())
+         True
+         (let* (($h (car-atom $rs)) ($r (cdr-atom $rs)) ($ok ($check $h)))
+           (if $ok (all-true $check $r) False))))
+  (= (forall $gen $check)
+     (let $rs (collapse $gen) (all-true $check $rs)))
+
+  ; ---- foldl: fold a function over a list, init as the seed; applies ($f elem acc), left to right ----
+  (: foldl (-> Atom %Undefined% %Undefined% %Undefined%))
+  (= (foldl $f $list $acc)
+     (if (== $list ())
+         $acc
+         (let* (($h (car-atom $list)) ($t (cdr-atom $list)) ($a1 ($f $h $acc)))
+           (foldl $f $t $a1))))
+
+  ; ---- reduce: PeTTa's full-evaluation operator. Its argument is %Undefined%-typed, so @metta-ts has
+  ;      already evaluated it to a normal form by the time the rule fires; returning it (identity) is
+  ;      therefore exactly "fully evaluate the argument". Hyperon's single-step eval is the distinct op.
+  (= (reduce $x) $x)
+
+  ; ---- find: True iff a pattern matches anything in a space, else False (PeTTa lib_spaces; the
+  ;      minimal-MeTTa unify-space case as a boolean). Uses match + case, both Hyperon ops. ----
+  (= (find $space $pattern)
+     (case (match $space $pattern True)
+           ((True True)
+            (Empty False))))
+
+  ; ---- match-count: count matches of a pattern without listifying them (PeTTa lib_spaces). ----
+  (= (match-count $space $pattern)
+     (foldall + (match $space $pattern 1) 0))
+
+  ; ---- iterate: apply $step ($i $state) -> $state' n times, counting $i up (PeTTa lib_patrick). $step is
+  ;      a symbol or a |-> lambda; ($step $i $state) is an ordinary application. ----
+  (= (iterate $i $n $state $step)
+     (if (== $n 0)
+         $state
+         (iterate (+ $i 1) (- $n 1) ($step $i $state) $step)))
+
+  ; ---- maplist: apply a function (symbol or lambda) to each element of a tuple ----
+  ; cons-atom's head is Atom-typed (unevaluated), so the application ($f $h) and the recursive call are
+  ; forced through let* before being consed.
+  (: maplist (-> Atom Atom %Undefined%))
+  (= (maplist $f $list)
+     (if (== $list ())
+         ()
+         (let* (($h (car-atom $list))
+                ($t (cdr-atom $list))
+                ($fh ($f $h))
+                ($rest (maplist $f $t)))
+           (cons-atom $fh $rest))))
+`;
+var cache2;
+function pettaStdlibAtoms() {
+  if (cache2 === void 0)
+    cache2 = parseAll(PETTA_STDLIB_SRC, standardTokenizer()).filter((t) => !t.bang).map((t) => t.atom);
+  return cache2;
+}
+
+// src/runner.ts
+function standardTokenizer() {
+  const t = new Tokenizer();
+  t.register(/^-?\d+$/, (s) => gint(BigInt(s)));
+  t.register(/^-?\d+\.\d+$/, (s) => gfloat(Number(s)));
+  t.register(/^-?\d+(\.\d+)?[eE][-+]?\d+$/, (s) => gfloat(Number(s)));
+  t.register(/^True$/, () => gbool(true));
+  t.register(/^False$/, () => gbool(false));
+  return t;
+}
+var preludeCache;
+function preludeAtoms() {
+  if (preludeCache === void 0)
+    preludeCache = parseAll(PRELUDE_SRC, standardTokenizer()).filter((t) => !t.bang).map((t) => t.atom);
+  return preludeCache;
+}
+var DEFAULT_FUEL2 = 1e5;
+var DEFAULT_TABLING = true;
+function buildDefaultEnv(imports, tabling) {
+  const env = buildEnv(
+    [...preludeAtoms(), ...stdlibAtoms(), ...pettaStdlibAtoms()],
+    stdTable()
+  );
+  env.imports = withBuiltinModules(imports);
+  if (tabling) {
+    env.table = /* @__PURE__ */ new Map();
+    env.pureFunctors = analyzePurity(env);
+    env.compiled = /* @__PURE__ */ new Map();
+    env.compileDirty = true;
+  }
+  return env;
+}
+function evalSequential(atoms, fuel = DEFAULT_FUEL2, imports = /* @__PURE__ */ new Map(), opts = {}) {
+  const out = [];
+  let st = initSt();
+  if (opts.maxStackDepth !== void 0) st.world.maxStackDepth = opts.maxStackDepth;
+  const env = buildDefaultEnv(imports, opts.tabling ?? DEFAULT_TABLING);
+  if (opts.parEvalImpl !== void 0) {
+    const rulesSrc = atoms.filter((a) => !a.bang).map((a) => format(a.atom)).join("\n");
+    const impl = opts.parEvalImpl;
+    env.parEval = (branchSrcs, firstOnly) => impl(rulesSrc, branchSrcs, firstOnly).map(
+      (r) => r === null ? null : r.flatMap((s) => parseAll(s, standardTokenizer()).map((p) => p.atom))
+    );
+  }
+  for (const { atom, bang } of atoms) {
+    if (!bang) {
+      addAtomToEnv(env, atom);
+      continue;
+    }
+    const [pairs, st2] = mettaEval(env, fuel, st, [], atom);
+    st = st2;
+    out.push({ query: atom, results: pairs.map((p) => p[0]) });
+  }
+  return out;
+}
+function runProgram(src, fuel = DEFAULT_FUEL2, imports = /* @__PURE__ */ new Map(), opts = {}) {
+  return evalSequential(parseAll(src, standardTokenizer()), fuel, imports, opts);
+}
+async function runProgramAsync(src, asyncOps = /* @__PURE__ */ new Map(), fuel = DEFAULT_FUEL2, imports = /* @__PURE__ */ new Map()) {
+  const parsed = parseAll(src, standardTokenizer());
+  const env = buildDefaultEnv(imports, false);
+  for (const [k, v] of asyncOps) env.agt.set(k, v);
+  const out = [];
+  let st = initSt();
+  for (const { atom, bang } of parsed) {
+    if (!bang) {
+      addAtomToEnv(env, atom);
+      continue;
+    }
+    const [pairs, st2] = await mettaEvalAsync(env, fuel, st, [], atom);
+    st = st2;
+    out.push({ query: atom, results: pairs.map((p) => p[0]) });
+  }
+  return out;
+}
+function collectImports(src) {
+  const out = [];
+  for (const { atom } of parseAll(src, standardTokenizer())) {
+    if (atom.kind === "expr" && atom.items.length === 3 && atom.items[0].kind === "sym" && atom.items[0].name === "import!" && atom.items[2].kind === "sym")
+      out.push(atom.items[2].name);
+  }
+  return out;
+}
+function isOraclePass(r) {
+  return r.results.length === 1 && r.results[0].kind === "expr" && r.results[0].items.length === 0;
+}
+function oracleReport(src, fuel = DEFAULT_FUEL2, imports = /* @__PURE__ */ new Map()) {
+  const results = runProgram(src, fuel, imports);
+  let passed = 0;
+  const failures = [];
+  for (const r of results) {
+    if (isOraclePass(r)) passed++;
+    else
+      failures.push(
+        `FAIL: ${format(r.query)}
+   got: ${r.results.map(format).join(" ") || "(no results)"}`
+      );
+  }
+  return { total: results.length, passed, failures };
+}
+
+// src/flat-kb.ts
+var TAG_ARITY = 0;
+var TAG_SYMBOL = 1;
+var TAG_NEWVAR = 2;
+var TAG_VARREF = 3;
+var tagOf = (tok2) => tok2 >>> 28 & 15;
+var payloadOf = (tok2) => tok2 & 268435455;
+var tok = (tag, payload = 0) => tag << 28 | payload | 0;
+var Interner = class {
+  byKey = /* @__PURE__ */ new Map();
+  entries = [];
+  add(key, entry) {
+    const existing = this.byKey.get(key);
+    if (existing !== void 0) return existing;
+    const id = this.entries.length;
+    if (id > 268435455) throw new Error("flat-kb: interner exceeded 2^28 unique leaves");
+    this.entries.push(entry);
+    this.byKey.set(key, id);
+    return id;
+  }
+  internSym(name) {
+    return this.add("s\0" + name, { kind: "sym", name });
+  }
+  internGround(value) {
+    return this.add(groundKey(value), { kind: "gnd", value });
+  }
+  /** 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) {
+    return this.byKey.get("s\0" + name);
+  }
+  lookupGround(value) {
+    return this.byKey.get(groundKey(value));
+  }
+  /** Reconstruct the atom for a leaf id. */
+  decodeLeaf(id) {
+    const e = this.entries[id];
+    return e.kind === "sym" ? sym(e.name) : gnd(e.value);
+  }
+  get size() {
+    return this.entries.length;
+  }
+};
+function groundKey(v) {
+  switch (v.g) {
+    case "int":
+      return "i\0" + v.n;
+    case "float":
+      return "f\0" + v.n;
+    case "str":
+      return "S\0" + v.s;
+    case "bool":
+      return "b\0" + (v.b ? "1" : "0");
+    case "unit":
+      return "u";
+    case "error":
+      return "e\0" + v.msg;
+    case "ext":
+      return "x\0" + v.kind + "\0" + v.id;
+  }
+}
+function encodeInto(a, out, it, varMap) {
+  switch (a.kind) {
+    case "sym":
+      out.push(tok(TAG_SYMBOL, it.internSym(a.name)));
+      return;
+    case "gnd":
+      out.push(tok(TAG_SYMBOL, it.internGround(a.value)));
+      return;
+    case "var": {
+      const existing = varMap.get(a.name);
+      if (existing === void 0) {
+        varMap.set(a.name, varMap.size);
+        out.push(tok(TAG_NEWVAR));
+      } else {
+        out.push(tok(TAG_VARREF, existing));
+      }
+      return;
+    }
+    case "expr":
+      out.push(tok(TAG_ARITY, a.items.length));
+      for (const child of a.items) encodeInto(child, out, it, varMap);
+      return;
+  }
+}
+function encodeAtom(a, it) {
+  const out = [];
+  encodeInto(a, out, it, /* @__PURE__ */ new Map());
+  return out;
+}
+function decodeAt(tokens, pos, it) {
+  let nextVar = 0;
+  const go = (p) => {
+    const t = tokens[p];
+    const tag = tagOf(t);
+    const payload = payloadOf(t);
+    switch (tag) {
+      case TAG_SYMBOL:
+        return [it.decodeLeaf(payload), p + 1];
+      case TAG_NEWVAR:
+        return [variable(String(nextVar++)), p + 1];
+      case TAG_VARREF:
+        return [variable(String(payload)), p + 1];
+      case TAG_ARITY: {
+        const items = [];
+        let q = p + 1;
+        for (let i = 0; i < payload; i++) {
+          const [child, nq] = go(q);
+          items.push(child);
+          q = nq;
+        }
+        return [expr(items), q];
+      }
+      default:
+        throw new Error(`flat-kb: bad token tag ${tag}`);
+    }
+  };
+  return go(pos);
+}
+function decodeAtom(tokens, it) {
+  return decodeAt(tokens, 0, it)[0];
+}
+function subtermLen(tokens, pos) {
+  const t = tokens[pos];
+  if (tagOf(t) === TAG_ARITY) {
+    let len = 1;
+    let p = pos + 1;
+    for (let i = 0; i < payloadOf(t); i++) {
+      const l = subtermLen(tokens, p);
+      len += l;
+      p += l;
+    }
+    return len;
+  }
+  return 1;
+}
+function rangeEq(a, as, b, bs) {
+  const len = subtermLen(a, as);
+  if (len !== subtermLen(b, bs)) return false;
+  for (let i = 0; i < len; i++) if (a[as + i] !== b[bs + i]) return false;
+  return true;
+}
+function encodePattern(a, it) {
+  const tokens = [];
+  const varNames = [];
+  const varMap = /* @__PURE__ */ new Map();
+  const go = (x) => {
+    switch (x.kind) {
+      case "sym": {
+        const id = it.lookupSym(x.name);
+        if (id === void 0) return false;
+        tokens.push(tok(TAG_SYMBOL, id));
+        return true;
+      }
+      case "gnd": {
+        const id = it.lookupGround(x.value);
+        if (id === void 0) return false;
+        tokens.push(tok(TAG_SYMBOL, id));
+        return true;
+      }
+      case "var": {
+        const existing = varMap.get(x.name);
+        if (existing === void 0) {
+          varMap.set(x.name, varNames.length);
+          varNames.push(x.name);
+          tokens.push(tok(TAG_NEWVAR));
+        } else {
+          tokens.push(tok(TAG_VARREF, existing));
+        }
+        return true;
+      }
+      case "expr":
+        tokens.push(tok(TAG_ARITY, x.items.length));
+        for (const c of x.items) if (!go(c)) return false;
+        return true;
+    }
+  };
+  return go(a) ? { tokens, varNames } : null;
+}
+function matchFlatAt(pat, fact, factStart) {
+  const binds = /* @__PURE__ */ new Map();
+  let varCounter = 0;
+  let pp = 0;
+  let fp = factStart;
+  const go = () => {
+    const pt = pat[pp];
+    const ptag = tagOf(pt);
+    if (ptag === TAG_NEWVAR) {
+      const len = subtermLen(fact, fp);
+      binds.set(varCounter++, [fp, fp + len]);
+      pp += 1;
+      fp += len;
+      return true;
+    }
+    if (ptag === TAG_VARREF) {
+      const ref = binds.get(payloadOf(pt));
+      if (ref === void 0) return false;
+      if (!rangeEq(fact, ref[0], fact, fp)) return false;
+      pp += 1;
+      fp += subtermLen(fact, fp);
+      return true;
+    }
+    if (ptag === TAG_SYMBOL) {
+      if (fact[fp] !== pt) return false;
+      pp += 1;
+      fp += 1;
+      return true;
+    }
+    if (fact[fp] !== pt) return false;
+    const n = payloadOf(pt);
+    pp += 1;
+    fp += 1;
+    for (let i = 0; i < n; i++) if (!go()) return false;
+    return true;
+  };
+  return go() ? binds : null;
+}
+var FlatKB = class {
+  interner = new Interner();
+  tokens = [];
+  // functor id -> list of fact start offsets. Facts whose head is not a symbol (var-headed or non-expr)
+  // are not keyed here; they go in `other`.
+  byFunctor = /* @__PURE__ */ new Map();
+  other = [];
+  offsets = [];
+  /** The token array (for packing into a SharedArrayBuffer). */
+  get tokenArray() {
+    return this.tokens;
+  }
+  /** Every fact's start offset, in insertion order (for sharding across workers). */
+  get factOffsets() {
+    return this.offsets;
+  }
+  /** Add a (typically ground) atom to the KB. */
+  add(a) {
+    const start = this.tokens.length;
+    this.offsets.push(start);
+    encodeInto(a, this.tokens, this.interner, /* @__PURE__ */ new Map());
+    const head = this.tokens[start];
+    if (tagOf(head) === TAG_ARITY) {
+      const fid = this.tokens[start + 1];
+      if (tagOf(fid) === TAG_SYMBOL) {
+        const k = payloadOf(fid);
+        const cur = this.byFunctor.get(k);
+        if (cur === void 0) this.byFunctor.set(k, [start]);
+        else cur.push(start);
+        return;
+      }
+    } else if (tagOf(head) === TAG_SYMBOL) {
+      const k = payloadOf(head);
+      const cur = this.byFunctor.get(k);
+      if (cur === void 0) this.byFunctor.set(k, [start]);
+      else cur.push(start);
+      return;
+    }
+    this.other.push(start);
+  }
+  /** Candidate fact offsets for a pattern, using the functor index when the pattern head is a known
+   *  symbol; otherwise every fact. */
+  candidates(pattern) {
+    const head = pattern.kind === "expr" && pattern.items.length > 0 ? pattern.items[0] : pattern;
+    if (head !== void 0 && head.kind === "sym") {
+      const fid = this.interner.lookupSym(head.name);
+      if (fid === void 0) return [];
+      return [...this.byFunctor.get(fid) ?? [], ...this.other];
+    }
+    return "all";
+  }
+  /** Match `pattern` against the KB, returning a binding map (variable name -> matched atom) per match. */
+  match(pattern) {
+    const enc = encodePattern(pattern, this.interner);
+    if (enc === null) return [];
+    const cand = this.candidates(pattern);
+    const offsets = cand === "all" ? this.offsets : cand;
+    const out = [];
+    for (const off of offsets) {
+      const binds = matchFlatAt(enc.tokens, this.tokens, off);
+      if (binds === null) continue;
+      const m = /* @__PURE__ */ new Map();
+      for (const [idx, [s]] of binds)
+        m.set(enc.varNames[idx], decodeAt(this.tokens, s, this.interner)[0]);
+      out.push(m);
+    }
+    return out;
+  }
+  get size() {
+    return this.offsets.length;
+  }
+};
+var _internals = { tok, tagOf, payloadOf, subtermLen };
+
+// src/flat-william.ts
+var { tagOf: tagOf2, payloadOf: payloadOf2 } = _internals;
+function eachSubterm(tokens, factStart, cb) {
+  const go = (pos) => {
+    const t = tokens[pos];
+    const start = pos;
+    if (tagOf2(t) === TAG_ARITY) {
+      let p = pos + 1;
+      for (let i = 0; i < payloadOf2(t); i++) p = go(p);
+      cb(start, p);
+      return p;
+    }
+    cb(start, pos + 1);
+    return pos + 1;
+  };
+  go(factStart);
+}
+function williamTopK(kb, k, refCost = 4) {
+  const tokens = kb.tokenArray;
+  const counts = /* @__PURE__ */ new Map();
+  for (const factStart of kb.factOffsets) {
+    eachSubterm(tokens, factStart, (s, e) => {
+      let key = "";
+      for (let i = s; i < e; i++) key += tokens[i] + ",";
+      const info = counts.get(key);
+      if (info !== void 0) info.count++;
+      else counts.set(key, { count: 1, len: e - s, start: s });
+    });
+  }
+  const scored = [];
+  for (const info of counts.values()) {
+    if (info.count < 2 || info.len < 2) continue;
+    const gain = (info.count - 1) * info.len - info.count * refCost;
+    if (gain > 0) scored.push({ ...info, gain });
+  }
+  scored.sort((a, b) => b.gain - a.gain || b.count - a.count);
+  return scored.slice(0, k).map((s) => ({
+    pattern: decodeAt(tokens, s.start, kb.interner)[0],
+    count: s.count,
+    len: s.len,
+    gain: s.gain
+  }));
+}
+
+// src/trail.ts
+var Trail = class {
+  binds = /* @__PURE__ */ new Map();
+  trail = [];
+  /** A restore point: the current trail length. */
+  mark() {
+    return this.trail.length;
+  }
+  /** Undo every binding made since `m`. */
+  undo(m) {
+    const t = this.trail;
+    while (t.length > m) this.binds.delete(t.pop());
+  }
+  /** Bind `$name` to `a` and record it on the trail. The caller guarantees `$name` is currently unbound. */
+  bind(name, a) {
+    this.binds.set(name, a);
+    this.trail.push(name);
+  }
+  /** Follow variable bindings to the representative: a non-variable, or an unbound variable. */
+  deref(a) {
+    let cur = a;
+    while (cur.kind === "var") {
+      const v = this.binds.get(cur.name);
+      if (v === void 0) return cur;
+      cur = v;
+    }
+    return cur;
+  }
+  /** Resolve `a` against the current bindings, one pass (the same discipline as the immutable
+   *  `instantiate`/`applySubst`): a variable becomes its bound value as-is; the value's own variables are
+   *  not re-resolved, and an expression's children are resolved. This matches the evaluator exactly,
+   *  including that a cyclic binding (`$y = (.. $y ..)`, which `matchAtoms` produces and `hasLoop` does not
+   *  reject) terminates instead of looping. A new term is built only where a child changed. */
+  resolve(a) {
+    if (a.kind === "var") return this.deref(a);
+    if (a.kind !== "expr" || a.ground) return a;
+    const its = a.items;
+    let items = null;
+    for (let i = 0; i < its.length; i++) {
+      const it = its[i];
+      const r = this.resolve(it);
+      if (items !== null) items.push(r);
+      else if (r !== it) {
+        items = its.slice(0, i);
+        items.push(r);
+      }
+    }
+    return items === null ? a : { ...a, items };
+  }
+};
+function unifyTrail(tr, l0, r0) {
+  const l = tr.deref(l0);
+  const r = tr.deref(r0);
+  if (l === r) return true;
+  if (l.kind === "var") {
+    if (r.kind === "var" && l.name === r.name) return true;
+    tr.bind(l.name, r);
+    return true;
+  }
+  if (r.kind === "var") {
+    tr.bind(r.name, l);
+    return true;
+  }
+  if (l.kind === "sym") return r.kind === "sym" && l.name === r.name;
+  if (l.kind === "gnd") return r.kind === "gnd" && atomEq(l, r);
+  if (r.kind !== "expr" || l.items.length !== r.items.length) return false;
+  for (let i = 0; i < l.items.length; i++)
+    if (!unifyTrail(tr, l.items[i], r.items[i])) return false;
+  return true;
+}
+export {
+  AsyncInSyncError,
+  BAIL,
+  CONCURRENCY_MODULE_SRC,
+  CURRY_MODULE_SRC,
+  DEFAULT_FUEL2 as DEFAULT_FUEL,
+  FlatKB,
+  IMPURE_OPS,
+  InMemorySpace,
+  Interner,
+  STDLIB_SRC,
+  TAG_ARITY,
+  TAG_NEWVAR,
+  TAG_SYMBOL,
+  TAG_VARREF,
+  Tokenizer,
+  Trail,
+  _internals,
+  addAtomToEnv,
+  addEqRaw,
+  addInt,
+  addValRaw,
+  addVarBinding,
+  addVarEquality,
+  alphaEq,
+  analyzePurity,
+  applySubst,
+  atomEq,
+  atomSize,
+  atomVars,
+  baseTable,
+  bindingsToSubst,
+  buildEnv,
+  builtinModules,
+  callGrounded,
+  canonInt,
+  cmpIntVal,
+  collectImports,
+  collectVars,
+  compileEnv,
+  decodeAt,
+  decodeAtom,
+  emptyBindings,
+  emptyEnv,
+  emptyExpr,
+  emptySubst,
+  encodeAtom,
+  encodeInto,
+  encodePattern,
+  eraseSubst,
+  evalAtom,
+  evalSequential,
+  expr,
+  extendSubst,
+  format,
+  freshenRule,
+  gbool,
+  getTypes,
+  gfloat,
+  gint,
+  gnd,
+  groundEq,
+  groundType,
+  gstr,
+  gunit,
+  hasLoop,
+  hashOf,
+  initSt,
+  instantiate,
+  intAbs,
+  intDiv,
+  intMod,
+  isErrorAtom,
+  isExpr,
+  isGnd,
+  isOraclePass,
+  isSym,
+  isVar,
+  isZero,
+  keyWellFormed,
+  lookupSubst,
+  lookupVal,
+  matchAtoms,
+  matchAtomsScoped,
+  matchAtomsWith,
+  matchFlatAt,
+  merge,
+  metaType,
+  mettaEval,
+  mettaEvalAsync,
+  mulInt,
+  occurs,
+  oracleReport,
+  parse,
+  parseAll,
+  pettaOpNames,
+  preludeAtoms,
+  removeVal,
+  runCompiled,
+  runProgram,
+  runProgramAsync,
+  setOutputSink,
+  setRawSink,
+  standardTokenizer,
+  stdTable,
+  stdlibAtoms,
+  subInt,
+  sym,
+  tableKey,
+  toF64,
+  unifiable,
+  unifyTop,
+  unifyTrail,
+  variable,
+  wcoJoin,
+  williamTopK,
+  withBuiltinModules
+};