@metta-ts/core 1.0.1 → 1.0.3

package/dist/index.js

@@ -75,6 +75,10 @@ function groundEq(a, b) {
   }
 }
 var SYM_INTERN = /* @__PURE__ */ new Map();
+var MIN_EXPR_INTERN_ARITY = 64;
+function canInternExprItems(items) {
+  return items.length >= MIN_EXPR_INTERN_ARITY;
+}
 function sym(name) {
   let s = SYM_INTERN.get(name);
   if (s === void 0) {
@@ -122,6 +126,112 @@ function expr(items) {
     ground
   };
 }
+function createInternTable() {
+  return {
+    buckets: /* @__PURE__ */ new Map(),
+    variables: /* @__PURE__ */ new Map(),
+    expressions: /* @__PURE__ */ new WeakSet(),
+    hasUnsafeGrounded: /* @__PURE__ */ new WeakMap()
+  };
+}
+function bucketIntern(table, a) {
+  const h = hashOf(a);
+  const entry = table.buckets.get(h);
+  if (entry === void 0) {
+    table.buckets.set(h, a);
+    if (a.kind === "expr") table.expressions.add(a);
+    return a;
+  }
+  if (!Array.isArray(entry)) {
+    if (atomEq(entry, a)) return entry;
+    table.buckets.set(h, [entry, a]);
+    if (a.kind === "expr") table.expressions.add(a);
+    return a;
+  }
+  for (const existing of entry) {
+    if (atomEq(existing, a)) return existing;
+  }
+  entry.push(a);
+  if (a.kind === "expr") table.expressions.add(a);
+  return a;
+}
+function isStateExpression(a) {
+  const head = a.items[0];
+  return head?.kind === "sym" && (head.name === "State" || head.name === "StateValue");
+}
+function hasUnsafeGrounded(table, a) {
+  if (a.kind === "gnd") return true;
+  if (a.kind !== "expr") return false;
+  if (isStateExpression(a)) return true;
+  const cached = table.hasUnsafeGrounded.get(a);
+  if (cached !== void 0) return cached;
+  for (const it of a.items) {
+    if (hasUnsafeGrounded(table, it)) {
+      table.hasUnsafeGrounded.set(a, true);
+      return true;
+    }
+  }
+  table.hasUnsafeGrounded.set(a, false);
+  return false;
+}
+function internVariable(table, a) {
+  let v = table.variables.get(a.name);
+  if (v === void 0) {
+    v = a;
+    table.variables.set(a.name, v);
+  }
+  return v;
+}
+function internAtom(table, a) {
+  if (table === void 0) return a;
+  switch (a.kind) {
+    case "sym":
+      return sym(a.name);
+    case "var":
+      return internVariable(table, a);
+    case "expr":
+      return internExpr(table, a);
+    case "gnd":
+      return a;
+  }
+}
+function internExpr(table, a) {
+  if (table === void 0 || table.expressions.has(a) || !a.ground || !canInternExprItems(a.items) || hasUnsafeGrounded(table, a)) {
+    return a;
+  }
+  const its = a.items;
+  let items = null;
+  let ground = true;
+  for (let i = 0; i < its.length; i++) {
+    const it = its[i];
+    const r = internAtom(table, it);
+    if (!r.ground) ground = false;
+    if (items !== null) items.push(r);
+    else if (r !== it) {
+      items = its.slice(0, i);
+      items.push(r);
+    }
+  }
+  const candidate = items === null && ground === a.ground ? a : expr(items ?? its);
+  return bucketIntern(table, candidate);
+}
+function internBuiltExpr(table, a) {
+  if (table === void 0 || table.expressions.has(a) || !a.ground || !canInternExprItems(a.items) || hasUnsafeGrounded(table, a)) {
+    return a;
+  }
+  const its = a.items;
+  let items = null;
+  for (let i = 0; i < its.length; i++) {
+    const it = its[i];
+    const r = it.kind === "var" ? internVariable(table, it) : it.kind === "sym" ? sym(it.name) : it;
+    if (items !== null) items.push(r);
+    else if (r !== it) {
+      items = its.slice(0, i);
+      items.push(r);
+    }
+  }
+  return bucketIntern(table, items === null ? a : expr(items));
+}
 function groundType(v) {
   switch (v.g) {
     case "int":
@@ -425,12 +535,32 @@ function format(a) {
 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 isValFor(r, x) {
+  return r.tag === "val" && r.x === x;
+}
+function firstValIndex(b, x) {
+  for (let i = 0; i < b.length; i++) if (isValFor(b[i], x)) return i;
+  return -1;
+}
+function copyWithoutVal(b, x, first, out = []) {
+  for (let i = 0; i < first; i++) out.push(b[i]);
+  for (let i = first + 1; i < b.length; i++) {
+    const r = b[i];
+    if (!isValFor(r, x)) out.push(r);
+  }
+  return out;
+}
 function lookupVal(b, x) {
-  for (const r of b) if (r.tag === "val" && r.x === x) return r.a;
+  for (let i = 0; i < b.length; i++) {
+    const r = b[i];
+    if (isValFor(r, x)) return r.a;
+  }
   return void 0;
 }
 function removeVal(b, x) {
-  return b.filter((r) => !(r.tag === "val" && r.x === x));
+  const first = firstValIndex(b, x);
+  if (first < 0) return b;
+  return copyWithoutVal(b, x, first);
 }
 function hasLoop(b) {
   for (const r of b) {
@@ -440,10 +570,48 @@ function hasLoop(b) {
   return false;
 }
 function addValRaw(b, x, a) {
-  return [valRel(x, a), ...removeVal(b, x)];
+  const first = firstValIndex(b, x);
+  if (first < 0) {
+    return prependValRaw(b, x, a);
+  }
+  return copyWithoutVal(b, x, first, [valRel(x, a)]);
+}
+function prependValRaw(b, x, a) {
+  const rel = valRel(x, a);
+  return b.length === 0 ? [rel] : [rel, ...b];
 }
 function addEqRaw(b, x, y) {
-  return x === y ? b : [eqRel(x, y), ...b];
+  if (x === y) return b;
+  return [eqRel(x, y), ...b];
+}
+function makeValRel(x, a) {
+  return valRel(x, a);
+}
+function fromRelations(rels) {
+  return rels;
+}
+function size(b) {
+  return b.length;
+}
+function isEmpty(b) {
+  return b.length === 0;
+}
+function relations(b) {
+  return b;
+}
+function* valEntries(b) {
+  for (const r of b) if (r.tag === "val") yield [r.x, r.a];
+}
+function someVal(b, pred) {
+  for (const r of b) if (r.tag === "val" && pred(r.x, r.a)) return true;
+  return false;
+}
+function hasEq(b) {
+  for (const r of b) if (r.tag === "eq") return true;
+  return false;
+}
+function* eqRelations(b) {
+  for (const r of b) if (r.tag === "eq") yield r;
 }
 
 // src/match.ts
@@ -480,25 +648,26 @@ function occursThrough(target, a, rels, b, seen) {
 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;
+    if (someVal(mb, (x, a) => occursThrough(x, 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 (prev === void 0) return [prependValRaw(b, x, v)];
   if (atomEq(prev, v)) return [b];
   return reconcile(b, prev, v);
 }
 function addVarEquality(b, x, y) {
+  if (x === y) return [b];
   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) {
+  if (r.tag === "eq" && r.x === r.y) return bs;
   const out = [];
   for (const b of bs) {
     const ext = r.tag === "val" ? addVarBinding(b, r.x, r.a) : addVarEquality(b, r.x, r.y);
@@ -508,37 +677,30 @@ function mergeOne(bs, r) {
 }
 function merge(a, b) {
   let acc = [a];
-  for (const r of b) acc = mergeOne(acc, r);
+  for (const r of relations(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 === "sym" && r.kind === "sym") return l.name === r.name ? [emptyBindings] : [];
   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 }]];
+    return lx === r.name ? [emptyBindings] : [prependValRaw(emptyBindings, lx, r)];
   }
-  if (l.kind === "var") return [[{ tag: "val", x: l.name + leftSuffix, a: r, y: void 0 }]];
+  if (l.kind === "var") return [prependValRaw(emptyBindings, l.name + leftSuffix, r)];
   if (r.kind === "var")
     return [
-      [
-        {
-          tag: "val",
-          x: r.name,
-          a: leftSuffix === "" ? l : suffixVars(l, leftSuffix),
-          y: void 0
-        }
-      ]
+      prependValRaw(emptyBindings, r.name, leftSuffix === "" ? l : suffixVars(l, leftSuffix))
     ];
   if (l.kind === "expr" && r.kind === "expr")
-    return matchAll(custom, [[]], l.items, r.items, leftSuffix);
+    return matchAll(custom, [emptyBindings], 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) ? [[]] : [];
+  return atomEq(l, r) ? [emptyBindings] : [];
 }
 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) ? [[]] : [];
+  return atomEq(g, other) ? [emptyBindings] : [];
 }
 function matchAll(custom, acc, xs, ys, leftSuffix = "") {
   if (xs.length !== ys.length) return [];
@@ -559,6 +721,81 @@ function matchAtomsScoped(l, r, suffix) {
   return matchAtomsWith(void 0, l, r, suffix);
 }
 
+// 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;
+  }
+  /** The atom currently bound to `$name`, if any (the direct binding, not dereferenced). */
+  get(name) {
+    return this.binds.get(name);
+  }
+  /** 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;
+}
+
 // src/substitution.ts
 var emptySubst = [];
 function lookupSubst(s, x) {
@@ -610,29 +847,31 @@ function occurs(x, a) {
 // src/instantiate.ts
 function bindingsToSubst(b) {
   const out = [];
-  for (const r of b) if (r.tag === "val") out.push([r.x, r.a]);
+  for (const e of valEntries(b)) out.push(e);
   return out;
 }
-function instantiate(b, a, suffix = "") {
+function instantiate(b, a, suffix = "", intern) {
   if (a.kind === "var") {
-    if (suffix === "") return b.length === 0 ? a : lookupVal(b, a.name) ?? a;
+    if (suffix === "") return isEmpty(b) ? 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;
+  if (isEmpty(b) && 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);
+    const r = instantiate(b, it, suffix, intern);
     if (items !== null) items.push(r);
     else if (r !== it) {
       items = its.slice(0, i);
       items.push(r);
     }
   }
-  return items === null ? a : { ...a, items };
+  if (items === null) return a;
+  if (intern === void 0 || !canInternExprItems(items)) return expr(items);
+  return internBuiltExpr(intern, expr(items));
 }
 
 // src/pmap.ts
@@ -711,13 +950,30 @@ var idxCount = (idx, atom) => {
 };
 var emptyLog = null;
 var logSize = (log) => log === null ? 0 : log.size;
-var logGroundIdx = (log) => log === null ? emptyPMap : log.groundIdx;
+var idxCache = /* @__PURE__ */ new WeakMap();
+var logGroundIdx = (log) => {
+  if (log === null) return emptyPMap;
+  const hit = idxCache.get(log);
+  if (hit !== void 0) return hit;
+  const chain = [];
+  let node = log;
+  while (node !== null && !idxCache.has(node)) {
+    chain.push(node);
+    node = node.prev;
+  }
+  let idx = node === null ? emptyPMap : idxCache.get(node);
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const n = chain[i];
+    if (n.atom.ground) idx = idxAdd(idx, n.atom);
+    idxCache.set(n, idx);
+  }
+  return idx;
+};
 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) {
@@ -734,6 +990,374 @@ function logToArray(log) {
 }
 var logFromArray = (atoms) => logAppendAll(emptyLog, atoms);
 
+// src/flat-atomspace.ts
+var TERM_SYM = 1;
+var TERM_GND = 2;
+var TERM_VAR = 3;
+var TERM_EXPR = 4;
+var CHUNK_SIZE = 16384;
+var ABSENT = -1;
+var Int32Chunks = class {
+  chunks = [];
+  tail = new Int32Array(CHUNK_SIZE);
+  length = 0;
+  push(value) {
+    const index = this.length;
+    const offset = index % CHUNK_SIZE;
+    if (offset === 0) {
+      if (index > 0) this.chunks.push(this.tail);
+      this.tail = new Int32Array(CHUNK_SIZE);
+    }
+    this.tail[offset] = value | 0;
+    this.length = index + 1;
+    return index;
+  }
+  get(index) {
+    return index < this.chunks.length * CHUNK_SIZE ? this.chunks[Math.floor(index / CHUNK_SIZE)][index % CHUNK_SIZE] : this.tail[index % CHUNK_SIZE];
+  }
+};
+function groundKey(v) {
+  switch (v.g) {
+    case "int":
+      return "i\0" + typeof v.n + "\0" + String(v.n);
+    case "float":
+      return "f\0" + String(v.n);
+    case "str":
+      return "s\0" + v.s;
+    case "bool":
+      return v.b ? "b\x001" : "b\x000";
+    case "unit":
+      return "u";
+    case "error":
+      return "e\0" + v.msg;
+    case "ext":
+      return "x\0" + v.kind + "\0" + v.id;
+  }
+}
+function groundHash2(v) {
+  return strHash(groundKey(v));
+}
+function canCompactAtom(a) {
+  switch (a.kind) {
+    case "sym":
+    case "var":
+      return true;
+    case "gnd":
+      return a.exec === void 0 && a.match === void 0;
+    case "expr":
+      return a.items.every(canCompactAtom);
+  }
+}
+var FlatAtomSpaceTable = class {
+  termKind = new Int32Chunks();
+  termStart = new Int32Chunks();
+  termLen = new Int32Chunks();
+  termHash = new Int32Chunks();
+  termGround = new Int32Chunks();
+  termData = new Int32Chunks();
+  factRoot = new Int32Chunks();
+  factHeadSym = new Int32Chunks();
+  hashBuckets = /* @__PURE__ */ new Map();
+  symByName = /* @__PURE__ */ new Map();
+  groundByKey = /* @__PURE__ */ new Map();
+  varByName = /* @__PURE__ */ new Map();
+  termFacts = /* @__PURE__ */ new Map();
+  symbols = [];
+  grounds = [];
+  vars = [];
+  get factCount() {
+    return this.factRoot.length;
+  }
+  insertFact(atom) {
+    const root = this.insertAtom(atom);
+    const id = this.factRoot.push(root);
+    this.factHeadSym.push(this.headSymOf(root));
+    const facts = this.termFacts.get(root);
+    if (facts === void 0) this.termFacts.set(root, [id]);
+    else facts.push(id);
+    return id;
+  }
+  factsForTerm(term) {
+    return this.termFacts.get(term) ?? [];
+  }
+  insertAtom(atom) {
+    switch (atom.kind) {
+      case "sym":
+        return this.internLeaf(
+          TERM_SYM,
+          this.internSym(atom.name),
+          strHash("s\0" + atom.name),
+          true
+        );
+      case "gnd": {
+        const key = groundKey(atom.value);
+        return this.internLeaf(
+          TERM_GND,
+          this.internGround(key, atom.value),
+          groundHash2(atom.value),
+          true
+        );
+      }
+      case "var":
+        return this.internLeaf(
+          TERM_VAR,
+          this.internVar(atom.name),
+          strHash("v\0" + atom.name),
+          false
+        );
+      case "expr": {
+        const children = atom.items.map((child) => this.insertAtom(child));
+        return this.internExpr(children);
+      }
+    }
+  }
+  lookupAtom(atom) {
+    switch (atom.kind) {
+      case "sym": {
+        const leaf = this.symByName.get(atom.name);
+        return leaf === void 0 ? void 0 : this.lookupLeaf(TERM_SYM, leaf, strHash("s\0" + atom.name));
+      }
+      case "gnd": {
+        if (!canCompactAtom(atom)) return void 0;
+        const key = groundKey(atom.value);
+        const leaf = this.groundByKey.get(key);
+        return leaf === void 0 ? void 0 : this.lookupLeaf(TERM_GND, leaf, groundHash2(atom.value));
+      }
+      case "var": {
+        const leaf = this.varByName.get(atom.name);
+        return leaf === void 0 ? void 0 : this.lookupLeaf(TERM_VAR, leaf, strHash("v\0" + atom.name));
+      }
+      case "expr": {
+        const children = [];
+        for (const child of atom.items) {
+          const term = this.lookupAtom(child);
+          if (term === void 0) return void 0;
+          children.push(term);
+        }
+        return this.lookupExpr(children);
+      }
+    }
+  }
+  decodeTerm(term) {
+    const kind = this.termKind.get(term);
+    const start = this.termStart.get(term);
+    switch (kind) {
+      case TERM_SYM:
+        return sym(this.symbols[start]);
+      case TERM_GND: {
+        const ground = this.grounds[start];
+        return gnd(ground, groundType(ground));
+      }
+      case TERM_VAR:
+        return variable(this.vars[start]);
+      case TERM_EXPR: {
+        const len = this.termLen.get(term);
+        const items = [];
+        for (let i = 0; i < len; i++) items.push(this.decodeTerm(this.termData.get(start + i)));
+        return expr(items);
+      }
+      default:
+        throw new Error(`flat-atomspace: bad term kind ${kind}`);
+    }
+  }
+  isTermGround(term) {
+    return this.termGround.get(term) === 1;
+  }
+  headSymOf(term) {
+    const kind = this.termKind.get(term);
+    if (kind === TERM_SYM) return this.termStart.get(term);
+    if (kind !== TERM_EXPR || this.termLen.get(term) === 0) return ABSENT;
+    const head = this.termData.get(this.termStart.get(term));
+    return this.termKind.get(head) === TERM_SYM ? this.termStart.get(head) : ABSENT;
+  }
+  lookupHeadSym(name) {
+    return this.symByName.get(name);
+  }
+  internSym(name) {
+    const existing = this.symByName.get(name);
+    if (existing !== void 0) return existing;
+    const id = this.symbols.length;
+    this.symbols.push(name);
+    this.symByName.set(name, id);
+    return id;
+  }
+  internGround(key, value) {
+    const existing = this.groundByKey.get(key);
+    if (existing !== void 0) return existing;
+    const id = this.grounds.length;
+    this.grounds.push(value);
+    this.groundByKey.set(key, id);
+    return id;
+  }
+  internVar(name) {
+    const existing = this.varByName.get(name);
+    if (existing !== void 0) return existing;
+    const id = this.vars.length;
+    this.vars.push(name);
+    this.varByName.set(name, id);
+    return id;
+  }
+  internLeaf(kind, leaf, hash, ground) {
+    const existing = this.lookupLeaf(kind, leaf, hash);
+    if (existing !== void 0) return existing;
+    return this.pushTerm(kind, leaf, 1, hash, ground);
+  }
+  lookupLeaf(kind, leaf, hash) {
+    const bucket = this.hashBuckets.get(hash);
+    if (bucket === void 0) return void 0;
+    for (const term of bucket)
+      if (this.termKind.get(term) === kind && this.termStart.get(term) === leaf) return term;
+    return void 0;
+  }
+  internExpr(children) {
+    const existing = this.lookupExpr(children);
+    if (existing !== void 0) return existing;
+    let hash = mixHash(1163415634, children.length);
+    let ground = true;
+    const start = this.termData.length;
+    for (const child of children) {
+      hash = mixHash(hash, child);
+      if (!this.isTermGround(child)) ground = false;
+      this.termData.push(child);
+    }
+    return this.pushTerm(TERM_EXPR, start, children.length, hash, ground);
+  }
+  lookupExpr(children) {
+    let hash = mixHash(1163415634, children.length);
+    for (const child of children) hash = mixHash(hash, child);
+    const bucket = this.hashBuckets.get(hash);
+    if (bucket === void 0) return void 0;
+    termLoop: for (const term of bucket) {
+      if (this.termKind.get(term) !== TERM_EXPR || this.termLen.get(term) !== children.length)
+        continue;
+      const start = this.termStart.get(term);
+      for (let i = 0; i < children.length; i++)
+        if (this.termData.get(start + i) !== children[i]) continue termLoop;
+      return term;
+    }
+    return void 0;
+  }
+  pushTerm(kind, start, len, hash, ground) {
+    const term = this.termKind.length;
+    this.termKind.push(kind);
+    this.termStart.push(start);
+    this.termLen.push(len);
+    this.termHash.push(hash);
+    this.termGround.push(ground ? 1 : 0);
+    const bucket = this.hashBuckets.get(hash);
+    if (bucket === void 0) this.hashBuckets.set(hash, [term]);
+    else bucket.push(term);
+    return term;
+  }
+};
+var FlatAtomSpace = class _FlatAtomSpace {
+  constructor(table, ranges, dead, liveCount, nonGroundCount) {
+    this.table = table;
+    this.ranges = ranges;
+    this.dead = dead;
+    this.liveCount = liveCount;
+    this.nonGroundCount = nonGroundCount;
+  }
+  table;
+  ranges;
+  dead;
+  liveCount;
+  nonGroundCount;
+  static empty() {
+    return new _FlatAtomSpace(new FlatAtomSpaceTable(), [], /* @__PURE__ */ new Set(), 0, 0);
+  }
+  static fromAtoms(atoms) {
+    if (!atoms.every(canCompactAtom)) return void 0;
+    return _FlatAtomSpace.empty().appendAll(atoms);
+  }
+  get size() {
+    return this.liveCount;
+  }
+  appendAll(atoms) {
+    if (atoms.length === 0) return this;
+    const start = this.table.factCount;
+    let nonGround = this.nonGroundCount;
+    for (const atom of atoms) {
+      const fact = this.table.insertFact(atom);
+      if (!this.table.isTermGround(this.table.factRoot.get(fact))) nonGround += 1;
+    }
+    const end = this.table.factCount;
+    return new _FlatAtomSpace(
+      this.table,
+      appendRange(this.ranges, start, end),
+      this.dead,
+      this.liveCount + atoms.length,
+      nonGround
+    );
+  }
+  removeOne(atom) {
+    const term = this.table.lookupAtom(atom);
+    if (term === void 0) return this;
+    for (const fact of this.visibleFactIds()) {
+      if (this.table.factRoot.get(fact) !== term) continue;
+      const dead = new Set(this.dead);
+      dead.add(fact);
+      const nonGround = this.table.isTermGround(term) ? this.nonGroundCount : this.nonGroundCount - 1;
+      return new _FlatAtomSpace(this.table, this.ranges, dead, this.liveCount - 1, nonGround);
+    }
+    return this;
+  }
+  exactCount(atom) {
+    if (!atom.ground) return 0;
+    const term = this.table.lookupAtom(atom);
+    if (term === void 0) return 0;
+    let count = 0;
+    for (const fact of this.table.factsForTerm(term))
+      if (this.factVisible(fact) && !this.dead.has(fact)) count += 1;
+    return count;
+  }
+  *candidatesFor(patternHead) {
+    if (patternHead === void 0) {
+      for (const fact of this.visibleFactIds()) yield this.decodeFact(fact);
+      return;
+    }
+    const head = this.table.lookupHeadSym(patternHead);
+    if (head === void 0) {
+      for (const fact of this.visibleFactIds())
+        if (this.table.factHeadSym.get(fact) === ABSENT) yield this.decodeFact(fact);
+      return;
+    }
+    for (const fact of this.visibleFactIds()) {
+      const factHead = this.table.factHeadSym.get(fact);
+      if (factHead === ABSENT || factHead === head) yield this.decodeFact(fact);
+    }
+  }
+  toArray() {
+    const out = [];
+    for (const fact of this.visibleFactIds()) out.push(this.decodeFact(fact));
+    return out;
+  }
+  roundTrip(atom) {
+    return this.table.decodeTerm(this.table.insertAtom(atom));
+  }
+  decodeFact(fact) {
+    return this.table.decodeTerm(this.table.factRoot.get(fact));
+  }
+  *visibleFactIds() {
+    for (const range of this.ranges)
+      for (let fact = range.start; fact < range.end; fact++) if (!this.dead.has(fact)) yield fact;
+  }
+  factVisible(fact) {
+    for (const range of this.ranges) {
+      if (fact < range.start) return false;
+      if (fact < range.end) return true;
+    }
+    return false;
+  }
+};
+function appendRange(ranges, start, end) {
+  if (start === end) return ranges;
+  const last = ranges[ranges.length - 1];
+  if (last !== void 0 && last.end === start)
+    return [...ranges.slice(0, -1), { start: last.start, end }];
+  return [...ranges, { start, end }];
+}
+
 // src/wcojoin.ts
 function allVars(rels) {
   const seen = /* @__PURE__ */ new Set();
@@ -746,7 +1370,7 @@ function allVars(rels) {
       }
   return out;
 }
-function wcoJoin(rels, key, varOrder) {
+function wcoJoinFold(rels, key, hooks, varOrder) {
   const order = varOrder ?? allVars(rels);
   const relInfos = rels.map((r) => {
     const relVars = order.filter((v) => r.vars.includes(v));
@@ -770,12 +1394,10 @@ function wcoJoin(rels, key, varOrder) {
   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));
+      hooks.onLeaf();
       return;
     }
     const parts = participants[i];
@@ -797,13 +1419,27 @@ function wcoJoin(rels, key, varOrder) {
       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);
+      hooks.onDescend(v, entry.val);
       recurse(i + 1);
+      hooks.onAscend(v);
       for (const [r, c] of saved) cursors[r] = c;
     }
-    partial.delete(v);
   };
   recurse(0);
+}
+function wcoJoin(rels, key, varOrder) {
+  const out = [];
+  const partial = /* @__PURE__ */ new Map();
+  wcoJoinFold(
+    rels,
+    key,
+    {
+      onDescend: (v, val) => partial.set(v, val),
+      onAscend: (v) => partial.delete(v),
+      onLeaf: () => out.push(new Map(partial))
+    },
+    varOrder
+  );
   return out;
 }
 
@@ -1818,16 +2454,607 @@ function inferType(a, varTypes, holders) {
   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);
-  }
+function compileRewriteCellPat(a, seen) {
+  if (a.kind === "sym") return { tag: "sym", atom: a };
+  if (a.kind !== "var" || seen.has(a.name)) return void 0;
+  seen.add(a.name);
+  return { tag: "var", name: a.name };
+}
+function compileRewriteArgPat(a, seen) {
+  if (a.kind === "sym") return { tag: "sym", atom: a };
+  if (a.kind !== "expr" || a.items.length === 0) return void 0;
+  const items = a.items.map((it) => compileRewriteCellPat(it, seen));
+  if (items.some((it) => it === void 0)) return void 0;
+  return { tag: "tuple", items };
+}
+function compileRewriteOut(a, vars) {
+  if (a.kind !== "expr" || a.items.length === 0) return void 0;
+  const out = [];
+  for (const it of a.items) {
+    if (it.kind === "sym") out.push({ tag: "sym", atom: it });
+    else if (it.kind === "var" && vars.has(it.name)) out.push({ tag: "var", name: it.name });
+    else return void 0;
+  }
+  return out;
+}
+function capturePositions(args) {
+  const vars = /* @__PURE__ */ new Map();
+  args.forEach((arg, i) => {
+    if (arg.tag === "tuple")
+      arg.items.forEach((cell, j) => {
+        if (cell.tag === "var") vars.set(cell.name, { arg: i, cell: j });
+      });
+  });
+  return vars;
+}
+function rewriteParamTypes(args) {
+  return args.map((arg) => arg.tag === "sym" ? "sym" : `symtuple${arg.items.length}`);
+}
+function sameRewriteParamType(arg, type) {
+  if (type === "sym") return arg.tag === "sym";
+  if (!type.startsWith("symtuple") || arg.tag !== "tuple") return false;
+  return arg.items.length === Number(type.slice("symtuple".length));
+}
+function atomToRewriteArg(a, type) {
+  if (type === "sym") {
+    if (a.kind === "sym") return { tag: "sym", atom: a };
+    if (a.kind === "var") return { tag: "qvar", name: a.name };
+    return void 0;
+  }
+  if (!type.startsWith("symtuple") || a.kind !== "expr") return void 0;
+  const width = Number(type.slice("symtuple".length));
+  if (a.items.length !== width) return void 0;
+  const items = [];
+  for (const it of a.items) {
+    if (it.kind !== "sym") return void 0;
+    items.push(it);
+  }
+  return { tag: "tuple", items };
+}
+function bindQueryVar(b, name, atom) {
+  for (const rel of b) {
+    if (rel.tag === "val" && rel.x === name) return rel.a === atom ? b : void 0;
+  }
+  return prependValRaw(b, name, atom);
+}
+function runRewriteRule(rule, vals) {
+  let b = emptyBindings;
+  for (let i = 0; i < rule.args.length; i++) {
+    const pat = rule.args[i];
+    const actual = vals[i];
+    if (pat.tag === "sym") {
+      if (actual.tag === "sym") {
+        if (actual.atom !== pat.atom) return void 0;
+      } else if (actual.tag === "qvar") {
+        const nb = bindQueryVar(b, actual.name, pat.atom);
+        if (nb === void 0) return void 0;
+        b = nb;
+      } else return void 0;
+      continue;
+    }
+    if (actual.tag !== "tuple" || actual.items.length !== pat.items.length) return void 0;
+    for (let j = 0; j < pat.items.length; j++) {
+      const cell = pat.items[j];
+      if (cell.tag === "sym" && actual.items[j] !== cell.atom) return void 0;
+    }
+  }
+  const out = rule.out.map((part) => {
+    if (part.tag === "sym") return part.atom;
+    const pos = rule.vars.get(part.name);
+    return vals[pos.arg].items[pos.cell];
+  });
+  return { atom: expr(out), bnd: b };
+}
+function compileRewrite(env, functor) {
+  const eqs = env.ruleIndex.get(functor);
+  if (eqs === void 0 || eqs.length === 0) return void 0;
+  const rules = [];
+  let arity;
+  let retType;
+  let paramTypes;
+  for (const [lhs, rhs] of eqs) {
+    if (lhs.kind !== "expr" || lhs.items.length === 0 || lhs.items[0].kind !== "sym")
+      return void 0;
+    if (lhs.items[0].name !== functor) return void 0;
+    arity ??= lhs.items.length - 1;
+    if (lhs.items.length - 1 !== arity) return void 0;
+    const seen = /* @__PURE__ */ new Set();
+    const args = lhs.items.slice(1).map((arg) => compileRewriteArgPat(arg, seen));
+    if (args.some((arg) => arg === void 0)) return void 0;
+    const typedArgs = args;
+    if (paramTypes === void 0) paramTypes = rewriteParamTypes(typedArgs);
+    else if (typedArgs.length !== paramTypes.length || typedArgs.some((arg, i) => !sameRewriteParamType(arg, paramTypes[i])))
+      return void 0;
+    const vars = capturePositions(typedArgs);
+    const out = compileRewriteOut(rhs, new Set(vars.keys()));
+    if (out === void 0) return void 0;
+    const rt = `symtuple${out.length}`;
+    if (retType === void 0) retType = rt;
+    else if (retType !== rt) return void 0;
+    rules.push({ args: typedArgs, out, vars });
+  }
+  if (arity === void 0 || retType === void 0 || paramTypes === void 0) return void 0;
+  const run = (partAtoms) => {
+    const vals = [];
+    const qvars = /* @__PURE__ */ new Set();
+    for (let i = 0; i < partAtoms.length; i++) {
+      const v = atomToRewriteArg(partAtoms[i], paramTypes[i]);
+      if (v === void 0) return void 0;
+      if (v.tag === "qvar") {
+        if (qvars.has(v.name)) return void 0;
+        qvars.add(v.name);
+      }
+      vals.push(v);
+    }
+    const results = [];
+    for (const rule of rules) {
+      const r = runRewriteRule(rule, vals);
+      if (r !== void 0) results.push(r);
+    }
+    return results.length === 0 ? void 0 : { results, counterDelta: rules.length };
+  };
+  return { kind: "rewrite", arity, retType, paramTypes, ruleCount: rules.length, run };
+}
+function compileSymPat(a, slots) {
+  if (a.kind === "sym") return { tag: "sym", name: a.name };
+  if (a.kind === "var") {
+    if (slots.has(a.name)) return void 0;
+    const slot = slots.size;
+    slots.set(a.name, slot);
+    return { tag: "slot", slot };
+  }
+  if (a.kind === "gnd") return { tag: "lit", atom: a };
+  const items = [];
+  for (const it of a.items) {
+    const p = compileSymPat(it, slots);
+    if (p === void 0) return void 0;
+    items.push(p);
+  }
+  return { tag: "expr", items };
+}
+function compileSymTpl(a, slots) {
+  if (a.kind === "var") {
+    const slot = slots.get(a.name);
+    return slot === void 0 ? { tag: "fresh", name: a.name } : { tag: "slot", slot };
+  }
+  if (a.kind !== "expr") return { tag: "atom", atom: a };
+  return { tag: "expr", items: a.items.map((it) => compileSymTpl(it, slots)) };
+}
+function matchSymPat(pat, arg, slots) {
+  switch (pat.tag) {
+    case "sym":
+      return arg.kind === "sym" && arg.name === pat.name;
+    case "slot":
+      slots[pat.slot] = arg;
+      return true;
+    case "lit":
+      return atomEq(arg, pat.atom);
+    case "expr": {
+      if (arg.kind !== "expr" || arg.items.length !== pat.items.length) return false;
+      for (let i = 0; i < pat.items.length; i++)
+        if (!matchSymPat(pat.items[i], arg.items[i], slots)) return false;
+      return true;
+    }
+  }
+}
+function bindSymQueryVar(bs, name, value) {
+  const out = [];
+  for (const b of bs) for (const ext of addVarBinding(b, name, value)) out.push(ext);
+  return out;
+}
+function matchSymPatQuery(pat, arg, slots, bs) {
+  switch (pat.tag) {
+    case "sym":
+      if (arg.kind === "var") return bindSymQueryVar(bs, arg.name, sym(pat.name));
+      return arg.kind === "sym" && arg.name === pat.name ? [...bs] : [];
+    case "slot":
+      slots[pat.slot] = arg;
+      return [...bs];
+    case "lit":
+      if (arg.kind === "var") return bindSymQueryVar(bs, arg.name, pat.atom);
+      return atomEq(arg, pat.atom) ? [...bs] : [];
+    case "expr": {
+      if (arg.kind === "var") return void 0;
+      if (arg.kind !== "expr" || arg.items.length !== pat.items.length) return [];
+      let cur = [...bs];
+      for (let i = 0; i < pat.items.length; i++) {
+        const next = matchSymPatQuery(pat.items[i], arg.items[i], slots, cur);
+        if (next === void 0) return void 0;
+        if (next.length === 0) return [];
+        cur = next;
+      }
+      return cur;
+    }
+  }
+}
+function buildSymTpl(tpl, slots, suffix) {
+  switch (tpl.tag) {
+    case "atom":
+      return tpl.atom;
+    case "slot":
+      return slots[tpl.slot];
+    case "fresh":
+      return variable(tpl.name + suffix);
+    case "expr":
+      return expr(tpl.items.map((t) => buildSymTpl(t, slots, suffix)));
+  }
+}
+function compileSymbolic(env, functor) {
+  if (env.varRulesVar.length !== 0) return void 0;
+  const eqs = env.ruleIndex.get(functor);
+  if (eqs === void 0 || eqs.length === 0) return void 0;
+  const clauses = [];
+  let arity;
+  for (const [lhs, rhs] of eqs) {
+    if (lhs.kind !== "expr" || lhs.items.length === 0) return void 0;
+    if (lhs.items[0].kind !== "sym" || lhs.items[0].name !== functor) return void 0;
+    const a = lhs.items.length - 1;
+    if (arity === void 0) arity = a;
+    else if (a !== arity) return void 0;
+    const slots = /* @__PURE__ */ new Map();
+    const pats = [];
+    for (let i = 1; i < lhs.items.length; i++) {
+      const p = compileSymPat(lhs.items[i], slots);
+      if (p === void 0) return void 0;
+      pats.push(p);
+    }
+    clauses.push({ pats, tpl: compileSymTpl(rhs, slots), nslots: slots.size });
+  }
+  if (arity === void 0) return void 0;
+  const clauseCount = clauses.length;
+  const run = (partAtoms, counter) => {
+    const results = [];
+    for (let i = 0; i < clauseCount; i++) {
+      const clause = clauses[i];
+      const slots = new Array(clause.nslots);
+      let bnds = [emptyBindings];
+      for (let j = 0; j < clause.pats.length; j++) {
+        if (partAtoms[j].ground) {
+          if (!matchSymPat(clause.pats[j], partAtoms[j], slots)) {
+            bnds = [];
+            break;
+          }
+          continue;
+        }
+        const next = matchSymPatQuery(clause.pats[j], partAtoms[j], slots, bnds);
+        if (next === void 0) return void 0;
+        bnds = next;
+        if (bnds.length === 0) break;
+      }
+      if (bnds.length > 0) {
+        const atom = buildSymTpl(clause.tpl, slots, "#" + (counter + i));
+        for (const bnd of bnds)
+          results.push({
+            atom,
+            bnd
+          });
+      }
+    }
+    return results.length === 0 ? void 0 : { results, counterDelta: clauseCount };
+  };
+  return { kind: "symbolic", arity, clauseCount, run };
+}
+var IMP_GROUNDED = /* @__PURE__ */ new Set(["==", "<", ">", "<=", ">=", "+", "-", "*", "%"]);
+var DATA_DENY = /* @__PURE__ */ new Set([...KNOWN_OPS, "let*", "add-atom"]);
+var addCounter = (st, n) => n === 0 ? st : { counter: st.counter + n, world: st.world };
+var impBail = () => BAIL;
+function impMeta(parts) {
+  const callees = /* @__PURE__ */ new Set();
+  let directEffect = false;
+  for (const part of parts) {
+    if (part.directEffect) directEffect = true;
+    for (const c of part.callees) callees.add(c);
+  }
+  return { directEffect, callees };
+}
+function impConst(atom) {
+  return { node: (_slots, st) => ({ value: atom, st }), directEffect: false, callees: /* @__PURE__ */ new Set() };
+}
+function isDataSymbol(env, name) {
+  return !DATA_DENY.has(name) && !env.ruleIndex.has(name) && !env.gt.has(name);
+}
+function compileImpStaticAtom(env, a, scope) {
+  if (a.kind === "var") {
+    const slot = scope.vars.get(a.name);
+    if (slot === void 0) return void 0;
+    return {
+      node: (slots, st) => ({ value: slots[slot], st }),
+      directEffect: false,
+      callees: /* @__PURE__ */ new Set()
+    };
+  }
+  if (a.kind === "sym") return isDataSymbol(env, a.name) ? impConst(a) : void 0;
+  if (a.kind === "gnd") return impConst(a);
+  if (a.items.length === 0) return impConst(a);
+  const head = a.items[0];
+  if (head.kind === "var") return void 0;
+  if (head.kind === "sym" && !isDataSymbol(env, head.name)) return void 0;
+  const items = a.items.map((it) => compileImpStaticAtom(env, it, scope));
+  if (items.some((it) => it === void 0)) return void 0;
+  const parts = items;
+  return {
+    node: (slots, st, ops) => {
+      const out = [];
+      let cur = st;
+      for (const part of parts) {
+        const r = part.node(slots, cur, ops);
+        if (r === BAIL) return BAIL;
+        out.push(r.value);
+        cur = r.st;
+      }
+      return { value: expr(out), st: cur };
+    },
+    ...impMeta(parts)
+  };
+}
+function compileImpGrounded(env, op, args, scope, holders) {
+  if (env.ruleIndex.has(op)) return void 0;
+  const parts = args.map((arg) => compileImpAtom(env, arg, scope, holders));
+  if (parts.some((part) => part === void 0)) return void 0;
+  const compiled = parts;
+  return {
+    node: (slots, st, ops) => {
+      const vals = [];
+      let cur = st;
+      for (const part of compiled) {
+        const r = part.node(slots, cur, ops);
+        if (r === BAIL) return BAIL;
+        vals.push(r.value);
+        cur = r.st;
+      }
+      const gr = callGrounded(env.gt, op, vals);
+      return gr.tag === "ok" && gr.results.length === 1 ? { value: gr.results[0], st: cur } : BAIL;
+    },
+    ...impMeta(compiled)
+  };
+}
+function compileImpIf(env, args, scope, holders) {
+  if (args.length !== 3 || (env.ruleIndex.get("if")?.length ?? 0) !== 2) return void 0;
+  const cond = compileImpAtom(env, args[0], scope, holders);
+  const then_ = compileImpAtom(env, args[1], scope, holders);
+  const els = compileImpAtom(env, args[2], scope, holders);
+  if (cond === void 0 || then_ === void 0 || els === void 0) return void 0;
+  return {
+    node: (slots, st, ops, discard) => {
+      const c = cond.node(slots, st, ops);
+      if (c === BAIL) return BAIL;
+      const stIf = addCounter(c.st, 2);
+      if (c.value.kind !== "gnd" || c.value.value.g !== "bool") return BAIL;
+      return (c.value.value.b ? then_ : els).node(slots, stIf, ops, discard);
+    },
+    ...impMeta([cond, then_, els])
+  };
+}
+function compileImpLet(env, args, scope, holders) {
+  if (args.length !== 3 || args[0].kind !== "var" || (env.ruleIndex.get("let")?.length ?? 0) !== 1)
+    return void 0;
+  const value = compileImpAtom(env, args[1], scope, holders);
+  if (value === void 0) return void 0;
+  const slot = scope.len;
+  const nextScope = {
+    vars: new Map(scope.vars).set(args[0].name, slot),
+    len: slot + 1
+  };
+  const body = compileImpAtom(env, args[2], nextScope, holders);
+  if (body === void 0) return void 0;
+  return {
+    node: (slots, st, ops, discard) => {
+      const v = value.node(slots, st, ops);
+      if (v === BAIL) return BAIL;
+      const local = slots.slice();
+      local[slot] = v.value;
+      return body.node(local, addCounter(v.st, 1), ops, discard);
+    },
+    ...impMeta([value, body])
+  };
+}
+function compileImpLetStar(env, args, scope, holders) {
+  if (args.length !== 2 || args[0].kind !== "expr" || (env.ruleIndex.get("let*")?.length ?? 0) !== 1 || (env.ruleIndex.get("let")?.length ?? 0) !== 1)
+    return void 0;
+  let curScope = scope;
+  const bindings = [];
+  for (const pair of args[0].items) {
+    if (pair.kind !== "expr" || pair.items.length !== 2 || pair.items[0].kind !== "var")
+      return void 0;
+    const value = compileImpAtom(env, pair.items[1], curScope, holders);
+    if (value === void 0) return void 0;
+    const slot = curScope.len;
+    bindings.push({ slot, value });
+    curScope = {
+      vars: new Map(curScope.vars).set(pair.items[0].name, slot),
+      len: slot + 1
+    };
+  }
+  const body = compileImpAtom(env, args[1], curScope, holders);
+  if (body === void 0) return void 0;
+  const parts = [...bindings.map((b) => b.value), body];
+  return {
+    node: (slots, st, ops, discard) => {
+      const local = slots.slice();
+      let cur = addCounter(st, 1);
+      for (const binding of bindings) {
+        const v = binding.value.node(local, cur, ops);
+        if (v === BAIL) return BAIL;
+        local[binding.slot] = v.value;
+        cur = addCounter(addCounter(v.st, 1), 1);
+      }
+      return body.node(local, cur, ops, discard);
+    },
+    ...impMeta(parts)
+  };
+}
+function compileImpAddAtom(env, args, scope) {
+  if (args.length !== 2 || args[0].kind !== "sym") return void 0;
+  const added = args[1];
+  if (added.kind !== "expr" || added.items.length === 0 || added.items[0].kind !== "sym" || added.items[0].name === "=")
+    return void 0;
+  const space = compileImpStaticAtom(env, args[0], scope);
+  const atom = compileImpStaticAtom(env, added, scope);
+  if (space === void 0 || atom === void 0) return void 0;
+  return {
+    node: (slots, st, ops) => {
+      const s = space.node(slots, st, ops);
+      if (s === BAIL) return BAIL;
+      const a = atom.node(slots, s.st, ops);
+      if (a === BAIL) return BAIL;
+      const st2 = ops.addAtom(env, a.st, s.value, a.value);
+      return st2 === void 0 ? BAIL : { value: emptyExpr, st: st2 };
+    },
+    directEffect: true,
+    callees: /* @__PURE__ */ new Set()
+  };
+}
+function compileImpCall(env, op, args, scope, holders) {
+  const h = holders.get(op);
+  if (h === void 0 || args.length !== h.arity) return void 0;
+  const compiledArgs = args.map((arg) => compileImpAtom(env, arg, scope, holders));
+  if (compiledArgs.some((arg) => arg === void 0)) return void 0;
+  const parts = compiledArgs;
+  const meta = impMeta(parts);
+  return {
+    node: (slots, st, ops, discard) => {
+      const vals = [];
+      let cur = st;
+      for (const part of parts) {
+        const r = part.node(slots, cur, ops);
+        if (r === BAIL) return BAIL;
+        vals.push(r.value);
+        cur = r.st;
+      }
+      return h.run(vals, cur, ops, discard);
+    },
+    directEffect: meta.directEffect,
+    callees: /* @__PURE__ */ new Set([...meta.callees, op])
+  };
+}
+function compileImpTuple(env, items, scope, holders) {
+  const parts = items.map((it) => compileImpAtom(env, it, scope, holders));
+  if (parts.some((part) => part === void 0)) return void 0;
+  const compiled = parts;
+  return {
+    node: (slots, st, ops, discard) => {
+      let cur = st;
+      if (discard === true) {
+        for (const part of compiled) {
+          const r = part.node(slots, cur, ops, true);
+          if (r === BAIL) return BAIL;
+          cur = r.st;
+        }
+        return { value: emptyExpr, st: cur };
+      }
+      const out = [];
+      for (const part of compiled) {
+        const r = part.node(slots, cur, ops);
+        if (r === BAIL) return BAIL;
+        out.push(r.value);
+        cur = r.st;
+      }
+      return { value: expr(out), st: cur };
+    },
+    ...impMeta(compiled)
+  };
+}
+function compileImpAtom(env, a, scope, holders) {
+  if (a.kind !== "expr" || a.items.length === 0) return compileImpStaticAtom(env, a, scope);
+  const head = a.items[0];
+  if (head.kind !== "sym") {
+    if (head.kind === "var") return void 0;
+    return compileImpTuple(env, a.items, scope, holders);
+  }
+  const op = head.name;
+  const args = a.items.slice(1);
+  if (op === "if") return compileImpIf(env, args, scope, holders);
+  if (op === "let") return compileImpLet(env, args, scope, holders);
+  if (op === "let*") return compileImpLetStar(env, args, scope, holders);
+  if (op === "add-atom") return compileImpAddAtom(env, args, scope);
+  if (IMP_GROUNDED.has(op)) return compileImpGrounded(env, op, args, scope, holders);
+  const call = compileImpCall(env, op, args, scope, holders);
+  if (call !== void 0) return call;
+  return compileImpStaticAtom(env, a, scope);
+}
+function buildImpScope(params) {
+  const vars = /* @__PURE__ */ new Map();
+  for (let i = 0; i < params.length; i++) {
+    const p = params[i];
+    if (typeof p !== "string") return void 0;
+    vars.set(p, i);
+  }
+  return { vars, len: params.length };
+}
+function compileImperative(env, compiled) {
+  if (env.varRulesVar.length !== 0) return;
+  const cand = /* @__PURE__ */ new Map();
+  for (const f of env.ruleIndex.keys()) {
+    if (compiled.has(f)) continue;
+    const h = singleClauseHead(env, f);
+    if (h !== void 0 && h.params.every((p) => typeof p === "string")) cand.set(f, h);
+  }
+  const holders = /* @__PURE__ */ new Map();
+  for (const [f, { params }] of cand)
+    holders.set(f, { kind: "imperative", arity: params.length, clauseCount: 1, run: impBail });
+  for (; ; ) {
+    let removed = false;
+    const bodies = /* @__PURE__ */ new Map();
+    for (const [f, h] of [...holders]) {
+      const cd = cand.get(f);
+      const scope = buildImpScope(cd.params);
+      const body = scope === void 0 ? void 0 : compileImpAtom(env, cd.body, scope, holders);
+      if (body === void 0) {
+        holders.delete(f);
+        removed = true;
+      } else {
+        bodies.set(f, body);
+        h.arity = cd.params.length;
+      }
+    }
+    if (removed) continue;
+    const effectful = /* @__PURE__ */ new Set();
+    for (const [f, body] of bodies) if (body.directEffect) effectful.add(f);
+    for (let changed = true; changed; ) {
+      changed = false;
+      for (const [f, body] of bodies) {
+        if (effectful.has(f)) continue;
+        for (const callee of body.callees)
+          if (effectful.has(callee)) {
+            effectful.add(f);
+            changed = true;
+            break;
+          }
+      }
+    }
+    for (const f of [...holders.keys()])
+      if (!effectful.has(f)) {
+        holders.delete(f);
+        removed = true;
+      }
+    if (removed) continue;
+    for (const [f, body] of bodies) {
+      const arity = cand.get(f).params.length;
+      holders.get(f).run = (partAtoms, st, ops, discard) => {
+        if (partAtoms.length !== arity || partAtoms.some((a) => !a.ground)) return BAIL;
+        try {
+          return body.node(partAtoms, addCounter(st, 1), ops, discard);
+        } catch (e) {
+          if (e === BAIL) return BAIL;
+          throw e;
+        }
+      };
+    }
+    for (const [f, h] of holders) compiled.set(f, h);
+    return;
+  }
+}
+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, {
+      kind: "functional",
       arity: params.length,
       retType: void 0,
       paramTypes: paramTypesOf(params),
@@ -1873,13 +3100,32 @@ function compileEnv(env) {
     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;
+      const compiled = new Map(holders);
+      for (const f of pure) {
+        if (compiled.has(f)) continue;
+        const rewrite = compileRewrite(env, f);
+        if (rewrite !== void 0) {
+          compiled.set(f, rewrite);
+          continue;
+        }
+        const symbolic = compileSymbolic(env, f);
+        if (symbolic !== void 0) compiled.set(f, symbolic);
+      }
+      compileImperative(env, compiled);
+      return compiled;
     }
   }
 }
-function runCompiled(env, op, partAtoms) {
+function runCompiled(env, op, partAtoms, st, ops, discard) {
   const h = env.compiled?.get(op);
   if (h === void 0 || partAtoms.length !== h.arity) return void 0;
+  if (h.kind === "rewrite") return h.run(partAtoms);
+  if (h.kind === "symbolic") return h.run(partAtoms, st.counter);
+  if (h.kind === "imperative") {
+    if (ops === void 0) return void 0;
+    const r = h.run(partAtoms, st, ops, discard);
+    return r === BAIL ? void 0 : { results: [{ atom: r.value, bnd: emptyBindings }], counterDelta: 0, state: r.st };
+  }
   const vals = [];
   for (const a of partAtoms) {
     if (a.kind === "gnd" && a.value.g === "int") vals.push(a.value.n);
@@ -1889,9 +3135,8 @@ function runCompiled(env, op, partAtoms) {
   }
   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);
+    const atom = typeof r === "boolean" ? gbool(r) : r instanceof Tup ? expr(r.v.map((n) => gint(n))) : gint(r);
+    return { results: [{ atom, bnd: emptyBindings }], counterDelta: 0 };
   } catch (e) {
     if (e === BAIL || e instanceof RangeError) return void 0;
     throw e;
@@ -1899,6 +3144,18 @@ function runCompiled(env, op, partAtoms) {
 }
 
 // src/eval.ts
+var CTOR_SC = process.env.METTA_CTOR_SC !== "0";
+var STREAM_CASE = process.env.METTA_STREAM_CASE !== "0";
+function exactCandidateSource(atom, count, total) {
+  return {
+    counterPadding: total - count,
+    *[Symbol.iterator]() {
+      for (let i = 0; i < count; i++) yield atom;
+    }
+  };
+}
+var candidateCounterPadding = (source) => source.counterPadding ?? 0;
+var syntheticCandidateSource = (source) => Object.prototype.hasOwnProperty.call(source, "counterPadding");
 var LAZY_ARGS_OPS = /* @__PURE__ */ new Set(["par", "race", "once", "with-mutex"]);
 var AsyncInSyncError = class extends Error {
   constructor(op) {
@@ -1933,6 +3190,9 @@ function* callGroundedG(env, op, args) {
   return callGrounded(env.gt, op, args);
 }
 var cons = (head, tail) => ({ head, tail });
+function isItemSource(work) {
+  return !Array.isArray(work);
+}
 var frame = (atom, ret = "none", vars = [], fin = false) => ({
   atom,
   ret,
@@ -1943,13 +3203,15 @@ var notReducibleA = sym("NotReducible");
 var emptyA = sym("Empty");
 var unitA = emptyExpr;
 var errAtom = (a, msg) => expr([sym("Error"), a, sym(msg)]);
+var makeExpr = (_env, items) => expr(items);
+var inst = (env, b, a, suffix = "") => instantiate(b, a, suffix, env.intern);
 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);
+  const a = inst(env, 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;
@@ -2018,6 +3280,40 @@ function headKey(a) {
     return a.items[0].name;
   return void 0;
 }
+function isDefinedHead(env, w, name) {
+  return env.ruleIndex.has(name) || env.sigs.has(name) || w.selfRules.has(name) || env.gt.has(name) || IMPURE_OPS.has(name);
+}
+function isNormalForm(env, w, t) {
+  switch (t.kind) {
+    case "var":
+    case "gnd":
+      return true;
+    case "sym":
+      return !isDefinedHead(env, w, t.name);
+    case "expr": {
+      const its = t.items;
+      if (its.length === 0) return true;
+      const h = its[0];
+      if (h.kind !== "sym" || isDefinedHead(env, w, h.name)) return false;
+      for (let i = 1; i < its.length; i++) if (!isNormalForm(env, w, its[i])) return false;
+      return true;
+    }
+  }
+}
+function isNormalFormAssumingVars(env, w, t) {
+  switch (t.kind) {
+    case "var":
+      return true;
+    case "sym":
+    case "gnd":
+      return isNormalForm(env, w, t);
+    case "expr": {
+      if (t.items.length === 0) return true;
+      const h = t.items[0];
+      return h.kind === "sym" && !isDefinedHead(env, w, h.name) && t.items.every((x) => isNormalFormAssumingVars(env, w, x));
+    }
+  }
+}
 function atomToStack(a, prev) {
   if (a.kind === "expr") {
     const op = opOf(a);
@@ -2075,6 +3371,7 @@ function emptyEnv(gt) {
   return {
     ruleIndex: /* @__PURE__ */ new Map(),
     varRules: [],
+    varRulesVar: [],
     sigs: /* @__PURE__ */ new Map(),
     gt,
     atoms: [],
@@ -2083,6 +3380,7 @@ function emptyEnv(gt) {
     exprTypes: [],
     agt: /* @__PURE__ */ new Map(),
     mutexes: /* @__PURE__ */ new Map(),
+    evaluatedAtoms: /* @__PURE__ */ new WeakSet(),
     factIndex: /* @__PURE__ */ new Map(),
     argIndex: /* @__PURE__ */ new Map(),
     nonGroundAtPos: /* @__PURE__ */ new Map(),
@@ -2190,43 +3488,46 @@ function ensureCompiled(env) {
   }
 }
 function disableTabling(env) {
+  env.evaluatedAtoms = /* @__PURE__ */ new WeakSet();
+  env.compiled = void 0;
+  env.compileDirty = void 0;
   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);
+  const atom = env.intern === void 0 ? x : internAtom(env.intern, x);
+  env.atoms.push(atom);
+  const fk = headKey(atom);
+  if (fk === void 0) env.varHeadedFacts.push(atom);
   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);
+    pushTo(env.factIndex, fk, atom);
+    if (atom.kind === "expr")
+      for (let i = 1; i < atom.items.length; i++) {
+        const ak = argKey(atom.items[i]);
+        if (ak !== void 0) pushTo(env.argIndex, fk + KEY_SEP + i + KEY_SEP + ak, atom);
+        else pushTo(env.nonGroundAtPos, fk + KEY_SEP + i, atom);
       }
   }
-  if (opOf(x) === "=" && x.kind === "expr" && x.items.length === 3) {
-    const lhs = x.items[1];
-    const rhs = x.items[2];
+  if (opOf(atom) === "=" && atom.kind === "expr" && atom.items.length === 3) {
+    env.evaluatedAtoms = /* @__PURE__ */ new WeakSet();
+    const lhs = atom.items[1];
+    const rhs = atom.items[2];
     const k = headKey(lhs);
-    if (k === void 0) env.varRules.push([lhs, rhs]);
-    else {
+    if (k === void 0) {
+      env.varRules.push([lhs, rhs]);
+      if (isVariableHeaded(lhs)) env.varRulesVar.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 (atom.kind === "expr" && opOf(atom) === ":" && atom.items.length === 3) {
+    const subj = atom.items[1];
+    const t = atom.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]);
@@ -2259,12 +3560,36 @@ function registerImportedTypes(env, atoms) {
   }
 }
 function selfAtoms(env, w) {
-  return logSize(w.selfExtra) === 0 ? env.atoms : [...env.atoms, ...logToArray(w.selfExtra)];
+  const runtime = runtimeAtoms(w);
+  return runtime.length === 0 ? env.atoms : [...env.atoms, ...runtime];
+}
+function runtimeAtoms(w) {
+  const flat = w.flatSelfExtra?.toArray() ?? [];
+  const log = logToArray(w.selfExtra);
+  if (flat.length === 0) return log;
+  if (log.length === 0) return flat;
+  return [...flat, ...log];
 }
 function candidates(env, toEval) {
   const k = headKey(toEval);
+  if (k === void 0 && toEval.kind === "expr" && toEval.items.length > 0)
+    return [...env.varRules];
   const keyed = k !== void 0 ? env.ruleIndex.get(k) ?? [] : [];
-  return [...keyed, ...env.varRules];
+  return env.varRulesVar.length === 0 ? keyed : [...keyed, ...env.varRulesVar];
+}
+function namedSpaceAtoms(space) {
+  return logToArray(space ?? emptyLog);
+}
+function namedSpaceCandidateGetter(w, space) {
+  let scan;
+  return (pInst) => {
+    const log = space ?? emptyLog;
+    if (pInst.ground && logNonGround(log) === 0 && w.store.size === 0) {
+      return exactCandidateSource(pInst, idxCount(logGroundIdx(log), pInst), logSize(log));
+    }
+    scan ??= namedSpaceAtoms(space).map((x) => resolveStates(w, x));
+    return scan;
+  };
 }
 var initSt = () => ({
   counter: 0,
@@ -2273,6 +3598,7 @@ var initSt = () => ({
     store: /* @__PURE__ */ new Map(),
     tokens: /* @__PURE__ */ new Map(),
     selfExtra: emptyLog,
+    flatSelfExtra: void 0,
     selfRules: /* @__PURE__ */ new Map(),
     selfVarRules: [],
     maxStackDepth: 0
@@ -2284,6 +3610,7 @@ function cloneWorld(w) {
     store: new Map(w.store),
     tokens: new Map(w.tokens),
     selfExtra: w.selfExtra,
+    flatSelfExtra: w.flatSelfExtra,
     selfRules: new Map(w.selfRules),
     selfVarRules: w.selfVarRules,
     maxStackDepth: w.maxStackDepth
@@ -2309,27 +3636,32 @@ function applyAtomDelta(into, added, removed) {
   return out;
 }
 function mergeWorlds(base, branches) {
-  const baseSelf = logToArray(base.selfExtra);
+  const baseSelf = runtimeAtoms(base);
   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));
+    const d = multisetDelta(baseSelf, runtimeAtoms(w));
     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));
+      const baseV = namedSpaceAtoms(base.spaces.get(k));
+      const sd = multisetDelta(baseV, namedSpaceAtoms(v));
+      spaces.set(
+        k,
+        logFromArray(applyAtomDelta(namedSpaceAtoms(spaces.get(k)), 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 flat = base.flatSelfExtra === void 0 ? void 0 : FlatAtomSpace.fromAtoms(selfExtra);
   const merged = {
     spaces,
     store,
     tokens,
-    selfExtra: logFromArray(selfExtra),
+    selfExtra: flat === void 0 ? logFromArray(selfExtra) : emptyLog,
+    flatSelfExtra: flat,
     selfRules: /* @__PURE__ */ new Map(),
     selfVarRules: [],
     maxStackDepth: base.maxStackDepth
@@ -2379,10 +3711,13 @@ function resolveStates(w, a) {
   }
   return a;
 }
-function subTokens(w, a) {
+function subTokens(w, a, intern) {
   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)));
+  if (a.kind === "expr") {
+    const out = expr(a.items.map((x) => subTokens(w, x, intern)));
+    return intern === void 0 ? out : internBuiltExpr(intern, out);
+  }
   return a;
 }
 function wrapStates(w, a) {
@@ -2399,7 +3734,7 @@ function wrapStates(w, a) {
   }
   return a;
 }
-var typePrep = (w, a) => wrapStates(w, subTokens(w, a));
+var typePrep = (env, w, a) => wrapStates(w, subTokens(w, a, env.intern));
 function candidatesW(env, w, toEval) {
   const k2 = headKey(toEval);
   const headRules = k2 !== void 0 ? w.selfRules.get(k2) ?? [] : [];
@@ -2407,7 +3742,12 @@ function candidatesW(env, w, toEval) {
 }
 var ruleVarsCache = /* @__PURE__ */ new WeakMap();
 function ruleVars(lhs, rhs) {
-  let vs = ruleVarsCache.get(lhs);
+  let rhsCache = ruleVarsCache.get(lhs);
+  if (rhsCache === void 0) {
+    rhsCache = /* @__PURE__ */ new WeakMap();
+    ruleVarsCache.set(lhs, rhsCache);
+  }
+  let vs = rhsCache.get(rhs);
   if (vs === void 0) {
     vs = atomVars(lhs);
     const seen = new Set(vs);
@@ -2416,11 +3756,12 @@ function ruleVars(lhs, rhs) {
         seen.add(v);
         vs.push(v);
       }
-    ruleVarsCache.set(lhs, vs);
+    rhsCache.set(rhs, vs);
   }
   return vs;
 }
 function freshenSub(counter, lhs, rhs) {
+  if (lhs.ground && rhs.ground) return [];
   const vs = ruleVars(lhs, rhs);
   return vs.length === 0 ? [] : vs.map((v) => [v, variable(v + "#" + String(counter))]);
 }
@@ -2449,7 +3790,7 @@ function queryOp(env, st, prev, toEval, b) {
     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));
+        if (!hasLoop(m)) out.push(evalResult(prev, inst(env, m, rhs0, suffix), m));
       }
     }
   }
@@ -2465,11 +3806,28 @@ function hasRuleFor(env, w, counter, a) {
   return false;
 }
 function* evalOpG(env, st, prev, x, b) {
-  const x2 = instantiate(b, x);
+  const x2 = inst(env, b, x);
   const op = opOf(x2);
+  if (op === "collapse" && x2.kind === "expr" && x2.items.length === 2) {
+    const match = matchInsideOnce(x2.items[1]);
+    if (match !== void 0) {
+      const namedMatch = tryFastNamedOnceMatch(env, st, match, b);
+      if (namedMatch !== void 0) {
+        const items = namedMatch.value === void 0 ? [] : [namedMatch.value];
+        return [[evalResult(prev, expr(items), b)], namedMatch.state];
+      }
+    }
+  }
+  if (op === "if" && x2.kind === "expr" && x2.items.length === 4) {
+    const added = tryFastNamedAddIfAbsent(env, st, x2, b);
+    if (added !== void 0) {
+      const out = added.added ? [finItem(prev, emptyExpr, b)] : [];
+      return [out, added.state];
+    }
+  }
   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 args = x2.items.slice(1).map((a) => resolveStates(st.world, subTokens(st.world, a, env.intern)));
     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];
@@ -2478,7 +3836,7 @@ function* evalOpG(env, st, prev, x, b) {
   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)));
+      const args = x2.items.slice(1).map((a) => resolveStates(st.world, subTokens(st.world, a, env.intern)));
       try {
         const results = head.exec(args);
         return [results.map((res) => evalResult(prev, res, b)), st];
@@ -2491,55 +3849,65 @@ function* evalOpG(env, st, prev, x, b) {
   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) {
+function unifyOp(env, 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));
+    for (const m of merge(b, mb)) if (!hasLoop(m)) ms.push(finItem(prev, inst(env, 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) {
+function finalPair(env, it) {
   const f = it.stack;
-  return f === null ? [emptyA, []] : [instantiate(it.bnd, f.head.atom), it.bnd];
+  return f === null ? [emptyA, []] : [inst(env, it.bnd, f.head.atom), it.bnd];
 }
-function exhaustedPair(it) {
+function exhaustedPair(env, it) {
   const f = it.stack;
-  return f === null ? [emptyA, it.bnd] : [expr([sym("Error"), instantiate(it.bnd, f.head.atom), sym("StackOverflow")]), it.bnd];
+  return f === null ? [emptyA, it.bnd] : [makeExpr(env, [sym("Error"), inst(env, 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);
+function resolveBoundVarFix(env, b, n, x) {
+  let cur = lookupVal(b, x);
+  if (cur === void 0 || cur.ground) return cur;
+  for (let i = 1; i < n; i++) {
+    const next = inst(env, b, cur);
     if (atomEq(next, cur)) return cur;
     cur = next;
   }
   return cur;
 }
-function restrictBnd(vars, b) {
+function restrictBnd(env, vars, b) {
+  if (vars.length === 0) return emptyBindings;
   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 });
+    const v = resolveBoundVarFix(env, b, size(b) + 1, x);
+    if (v !== void 0 && !(v.kind === "var" && v.name === x)) solved.push(makeValRel(x, v));
   }
-  if (!b.some((r) => r.tag === "eq")) return solved;
+  if (!hasEq(b)) return fromRelations(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];
+  const eqs = [];
+  for (const r of eqRelations(b)) if (vset.has(r.x) && vset.has(r.y)) eqs.push(r);
+  return fromRelations(solved.length === 0 ? eqs : [...solved, ...eqs]);
 }
-function mergeRestrict(vars, baseB, pb) {
+function mergeRestrict(env, vars, baseB, pb) {
+  if (vars.length === 0) return emptyBindings;
   const merged = merge(baseB, pb);
-  return restrictBnd(vars, merged.length > 0 ? merged[0] : pb);
+  return restrictBnd(env, vars, merged.length > 0 ? merged[0] : pb);
+}
+function queryVarsOf(args) {
+  const out = [];
+  for (const a of args) if (!a.ground) out.push(...atomVars(a));
+  return out;
 }
-function scopeVars(b, prev) {
+function scopeVars(env, 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);
+  for (let p = prev; p !== null; p = p.tail) collectVars(inst(env, b, p.head.atom), out, seen);
   return out;
 }
-function frameVars(prev) {
+function chainLiveVars(cont, prev) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (let p = prev; p !== null; p = p.tail) collectVars(p.head.atom, out, seen);
+  collectVars(cont, out, seen);
   return out;
 }
 function superposeItem(prev, b, pair) {
@@ -2620,13 +3988,13 @@ function getTypesUncached(env, a) {
       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]);
+        const m = matchAtoms(inst(env, 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));
+      out.push(inst(env, tb, ret));
     }
   }
   return out.length > 0 ? out : UNDEF_T;
@@ -2645,7 +4013,7 @@ function getTypesForQuery(env, a) {
     for (const combo of combos) for (const t of opts) next.push([...combo, t]);
     combos = next;
   }
-  return combos.map((c) => expr(c));
+  return combos.map((c) => makeExpr(env, c));
 }
 function matchReduced(tb, expected, actual) {
   if (atomEq(expected, UNDEF) || atomEq(actual, UNDEF)) return tb;
@@ -2676,11 +4044,11 @@ 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);
+  const ti = inst(env, 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);
+  const prepped = typePrep(env, 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);
@@ -2694,12 +4062,12 @@ 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) {
+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);
+    for (const atom of resolveAll(w, env.atoms.slice())) yield atom;
+    yield* runtimeCandidates(w, void 0);
+    return;
   }
   let bestKey;
   let bestPosKey;
@@ -2710,9 +4078,9 @@ function matchCandidates(env, w, pInst) {
       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;
+      const size2 = (env.argIndex.get(ik)?.length ?? 0) + (env.nonGroundAtPos.get(posKey)?.length ?? 0);
+      if (size2 < bestSize) {
+        bestSize = size2;
         bestKey = ik;
         bestPosKey = posKey;
       }
@@ -2724,71 +4092,111 @@ function matchCandidates(env, w, pInst) {
     cands = (env.factIndex.get(k) ?? []).slice();
   }
   cands.push(...env.varHeadedFacts);
-  if (pInst.ground && logNonGround(w.selfExtra) === 0 && w.store.size === 0) {
+  if (pInst.ground && logNonGround(w.selfExtra) === 0 && (w.flatSelfExtra?.nonGroundCount ?? 0) === 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);
+    for (const atom of cands) yield atom;
+    const flatCount = w.flatSelfExtra?.exactCount(pInst) ?? 0;
+    for (let i = 0; i < c + flatCount; i++) yield pInst;
+    return;
   }
-  return resolveAll(w, cands);
+  for (const atom of resolveAll(w, cands)) yield atom;
+  yield* runtimeCandidates(w, k);
 }
 function resolveAll(w, atoms) {
   return w.store.size === 0 ? atoms : atoms.map((x) => resolveStates(w, x));
 }
-function matchConj(getCandidates, patterns, st, sols) {
+function* runtimeCandidates(w, k) {
+  if (w.flatSelfExtra !== void 0) {
+    for (const a of w.flatSelfExtra.candidatesFor(k)) yield resolveStates(w, a);
+  }
+  for (const a of logToArray(w.selfExtra)) {
+    if (k === void 0) yield resolveStates(w, a);
+    else {
+      const akk = headKey(a);
+      if (akk === void 0 || akk === k) yield resolveStates(w, a);
+    }
+  }
+}
+function matchConj(env, 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 pInst = inst(env, b, p);
+      const source = getCandidates(pInst);
+      for (const atom of source) {
         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);
       }
+      counter += candidateCounterPadding(source);
     }
     cur = next;
   }
   return [cur, { counter, world: st.world }];
 }
-function matchConjJoin(getCandidates, patterns, st, b0) {
+function splitConjGoals(env, getCandidates, patterns, st, b0, perPositionAdmit) {
   let counter = st.counter;
+  const insts = patterns.map((p) => inst(env, b0, p));
+  const pvarsList = insts.map((pInst) => atomVars(pInst));
+  let joinVars;
+  if (perPositionAdmit) {
+    const seen = /* @__PURE__ */ new Set();
+    const shared = /* @__PURE__ */ new Set();
+    for (const pvars of pvarsList)
+      for (const v of new Set(pvars)) (seen.has(v) ? shared : seen).add(v);
+    joinVars = shared;
+  }
   const groundRels = [];
   const otherPatterns = [];
-  for (const p of patterns) {
-    const pInst = instantiate(b0, p);
-    const pvars = atomVars(pInst);
+  for (let i = 0; i < patterns.length; i++) {
+    const p = patterns[i];
+    const pvars = pvarsList[i];
     if (pvars.length === 0) {
       otherPatterns.push(p);
       continue;
     }
+    const pInst = insts[i];
     const tuples = [];
-    let allGround = true;
-    for (const atom of getCandidates(pInst)) {
+    let relational = true;
+    const source = getCandidates(pInst);
+    for (const atom of source) {
       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));
+          const val = lookupVal(mb, v) ?? variable(v);
           t.set(v, val);
-          if (!val.ground) allGround = false;
+          if (!val.ground && (joinVars === void 0 || joinVars.has(v))) relational = false;
         }
         tuples.push(t);
       }
     }
-    if (allGround) groundRels.push({ vars: pvars, tuples });
+    counter += candidateCounterPadding(source);
+    if (relational) groundRels.push({ vars: pvars, tuples });
     else otherPatterns.push(p);
   }
-  let cur;
+  return { groundRels, otherPatterns, counter };
+}
+function conjJoinPartials(env, getCandidates, patterns, st, b0) {
+  const { groundRels, otherPatterns, counter } = splitConjGoals(
+    env,
+    getCandidates,
+    patterns,
+    st,
+    b0,
+    // Result path: admit schematic facts at non-join positions to the leapfrog only when the fast matcher is
+    // on. The leapfrog reorders results and freshens differently, so an admitted schematic goal makes the
+    // answer alpha-equivalent (not byte-identical) to the coupled path; the default (trail off) keeps the
+    // conservative all-ground gate, so the byte-identical reference order holds and the oracle is unaffected.
+    env.useTrail === true
+  );
+  let partials;
   if (groundRels.length > 0) {
-    cur = [];
+    partials = [];
     for (const sol of wcoJoin(groundRels, mutexKey)) {
       let bs = [b0];
       for (const [v, val] of sol) {
@@ -2796,31 +4204,88 @@ function matchConjJoin(getCandidates, patterns, st, b0) {
         for (const b of bs) nb.push(...addVarBinding(b, v, val));
         bs = nb;
       }
-      for (const b of bs) if (!hasLoop(b)) cur.push(b);
+      for (const b of bs) if (!hasLoop(b)) partials.push(b);
     }
   } else {
-    cur = [b0];
-  }
+    partials = [b0];
+  }
+  return { partials, otherPatterns, counter };
+}
+function matchConjJoin(env, getCandidates, patterns, st, b0) {
+  const {
+    partials,
+    otherPatterns,
+    counter: c0
+  } = conjJoinPartials(env, getCandidates, patterns, st, b0);
+  let cur = partials;
+  let counter = c0;
   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);
+      const pInst = inst(env, b, p);
+      const source = getCandidates(pInst);
+      const cache3 = syntheticCandidateSource(source) ? void 0 : freshCache;
+      for (const atom of source) {
+        let fresh = cache3?.get(atom);
         if (fresh === void 0) {
           fresh = freshenRule(counter, atom, atom)[0];
           counter += 1;
-          freshCache.set(atom, fresh);
+          cache3?.set(atom, fresh);
         }
         for (const mb of matchAtoms(pInst, fresh))
           for (const m of merge(b, mb)) if (!hasLoop(m)) next.push(m);
       }
+      counter += candidateCounterPadding(source);
     }
     cur = next;
   }
   return [cur, { counter, world: st.world }];
 }
+function matchConjCount(env, getCandidates, patterns, st, b0) {
+  const {
+    groundRels,
+    otherPatterns,
+    counter: c0
+    // Match the result path's admission gate (conjJoinPartials) so the fold and the materializing count split
+    // goals identically and advance the gensym counter in lockstep: the conservative all-ground split by
+    // default (byte-identical, the reference the corpus pins), the per-position unify-capable admission only
+    // under experimental.trail (where the result path also admits, so both stay consistent).
+  } = splitConjGoals(env, getCandidates, patterns, st, b0, env.useTrail === true);
+  if (groundRels.length === 0) {
+    for (const p of patterns) if (atomHasCustomGrounded(p)) return void 0;
+    return countTrailDFS(seededTrail(b0), getCandidates, patterns, c0);
+  }
+  for (const p of otherPatterns) if (atomHasCustomGrounded(p)) return void 0;
+  const tr = seededTrail(b0);
+  const tailFreshCaches = otherPatterns.map(() => /* @__PURE__ */ new Map());
+  let counter = c0;
+  let count = 0;
+  let bailed = false;
+  const marks = [];
+  wcoJoinFold(groundRels, mutexKey, {
+    onDescend: (v, val) => {
+      marks.push(tr.mark());
+      tr.bind(v, val);
+    },
+    onAscend: () => tr.undo(marks.pop()),
+    onLeaf: () => {
+      if (bailed) return;
+      if (otherPatterns.length === 0) {
+        count += 1;
+        return;
+      }
+      const tc = countTrailDFS(tr, getCandidates, otherPatterns, counter, tailFreshCaches);
+      if (tc === void 0) {
+        bailed = true;
+        return;
+      }
+      count += tc.count;
+      counter = tc.counter;
+    }
+  });
+  return bailed ? void 0 : { count, counter };
+}
 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;
@@ -2884,12 +4349,12 @@ function* interpretStack1G(env, fuel, st, it) {
     if (prev === null) return [[it], st];
     const pf = prev.head;
     const pprev = prev.tail;
-    const res = instantiate(it.bnd, top.atom);
+    const res = inst(env, 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);
+        const nf = frame(makeExpr(env, [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];
@@ -2918,23 +4383,24 @@ function* interpretStack1G(env, fuel, st, it) {
       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);
+        const bnd = restrictBnd(env, chainLiveVars(cont, 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];
+      if (it2.length === 5)
+        return [unifyOp(env, 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];
+        return [[finItem(prev, makeExpr(env, [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];
+        return [[finItem(prev, makeExpr(env, [h, makeExpr(env, t)]), it.bnd)], st];
       }
       if (it2.length === 2)
         return [
@@ -2952,8 +4418,9 @@ function* interpretStack1G(env, fuel, st, it) {
       const [pairs, st2] = yield* mettaEvalG(env, fuel, st, it.bnd, atom);
       if (op === "metta-thread") {
         const out = [];
+        const scoped = scopeVars(env, it.bnd, prev);
         for (const p of pairs)
-          for (const m of merge(it.bnd, restrictBnd(scopeVars(it.bnd, prev), p[1])))
+          for (const m of merge(it.bnd, restrictBnd(env, scoped, p[1])))
             out.push(finItem(prev, p[0], m));
         return [out, st2];
       }
@@ -2963,22 +4430,25 @@ function* interpretStack1G(env, fuel, st, it) {
     case "get-type-space": {
       let typeEnv = env;
       if (op === "get-type-space") {
-        const sp = instantiate(it.bnd, it2[1]);
+        const sp = inst(env, 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 sa = namedSpaceAtoms(st.world.spaces.get(sname));
+          if (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);
+      return yield* getTypeOpG(typeEnv, fuel, st, prev, inst(typeEnv, 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];
+        return [[finItem(prev, getDocOf(env, st.world, inst(env, 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);
+      if (it2.length === 4) {
+        if (!STREAM_CASE) return matchOp(env, st, prev, it2[1], it2[2], it2[3], it.bnd);
+        return [matchItemSource(env, st, prev, it2[1], it2[2], it2[3], it.bnd), st];
+      }
       break;
     case "superpose-bind":
       if (it2.length === 2 && it2[1].kind === "expr")
@@ -2989,7 +4459,19 @@ function* interpretStack1G(env, fuel, st, it) {
       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];
+      return [
+        [
+          finItem(
+            prev,
+            makeExpr(
+              env,
+              atoms.map((p) => makeExpr(env, [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
@@ -3050,13 +4532,18 @@ function* interpretStack1G(env, fuel, st, it) {
         const first2 = par.length > 0 ? [par[0]] : [];
         return [first2.map((a2) => finItem(prev, a2, it.bnd)), st];
       }
+      const namedMatch = tryFastNamedOnceMatch(env, st, it2[1], it.bnd);
+      if (namedMatch !== void 0) {
+        const first2 = namedMatch.value === void 0 ? [] : [finItem(prev, namedMatch.value, it.bnd)];
+        return [first2, namedMatch.state];
+      }
       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];
+      return [first.map((p) => finItem(prev, p[0], p[1])), st2];
     }
     case "with-mutex": {
       if (it2.length !== 3) break;
-      const name = mutexKey(instantiate(it.bnd, it2[1]));
+      const name = mutexKey(inst(env, it.bnd, it2[1]));
       const body = it2[2];
       pendingAsyncOp = "with-mutex";
       const result = yield (async () => {
@@ -3079,34 +4566,28 @@ function* interpretStack1G(env, fuel, st, it) {
       if (it2.length !== 2) break;
       const id = st.counter;
       const w = cloneWorld(st.world);
-      w.store.set(id, instantiate(it.bnd, it2[1]));
+      w.store.set(id, inst(env, 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]));
+      const id = stateId(st.world, inst(env, 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)],
+        [finItem(prev, errAtom(inst(env, 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]));
+      const id = stateId(st.world, inst(env, it.bnd, it2[1]));
       if (id !== void 0) {
         const w = cloneWorld(st.world);
-        w.store.set(id, instantiate(it.bnd, it2[2]));
+        w.store.set(id, inst(env, 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
-          )
-        ],
+        [finItem(prev, errAtom(inst(env, it.bnd, it2[1]), "change-state!: not a state"), it.bnd)],
         st
       ];
     }
@@ -3115,57 +4596,65 @@ function* interpretStack1G(env, fuel, st, it) {
       const id = st.counter;
       const name = "&space-" + String(id);
       const w = cloneWorld(st.world);
-      w.spaces.set(name, []);
+      w.spaces.set(name, emptyLog);
       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]));
+      const src = spaceName(st.world, inst(env, it.bnd, it2[1]));
       if (src === void 0)
         return [
-          [finItem(prev, errAtom(instantiate(it.bnd, it2[1]), "fork-space: not a space"), it.bnd)],
+          [finItem(prev, errAtom(inst(env, 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 srcAtoms = src === "&self" ? selfAtoms(env, st.world) : namedSpaceAtoms(st.world.spaces.get(src));
       const id = st.counter;
       const name = "&space-" + String(id);
       const w = cloneWorld(st.world);
-      w.spaces.set(name, [...srcAtoms]);
+      w.spaces.set(name, logFromArray(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]);
+        const added = inst(env, it.bnd, it2[2]);
         if (opOf(added) === "=") disableTabling(env);
-        return spaceMutate(st, prev, it2[1], it.bnd, (w, name) => appendSpace(w, name, [added]));
+        return spaceMutate(
+          env,
+          st,
+          prev,
+          it2[1],
+          it.bnd,
+          (w, name) => appendSpace(env, w, name, [added])
+        );
       }
       break;
     case "remove-atom":
       if (it2.length === 3)
         return spaceMutate(
+          env,
           st,
           prev,
           it2[1],
           it.bnd,
-          (w, name) => eraseSpace(w, name, instantiate(it.bnd, it2[2]))
+          (w, name) => eraseSpace(w, name, inst(env, it.bnd, it2[2]))
         );
       break;
     case "get-atoms": {
       if (it2.length !== 2) break;
-      const name = spaceName(st.world, instantiate(it.bnd, it2[1]));
+      const name = spaceName(st.world, inst(env, it.bnd, it2[1]));
       if (name === void 0)
         return [
-          [finItem(prev, errAtom(instantiate(it.bnd, it2[1]), "get-atoms: not a space"), it.bnd)],
+          [finItem(prev, errAtom(inst(env, 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) ?? [];
+      const list = name === "&self" ? selfAtoms(env, st.world) : namedSpaceAtoms(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]);
+      const key = inst(env, it.bnd, it2[1]);
       if (key.kind === "sym" && key.name === "max-stack-depth") {
-        const val = instantiate(it.bnd, it2[2]);
+        const val = inst(env, 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];
@@ -3177,22 +4666,29 @@ function* interpretStack1G(env, fuel, st, it) {
     }
     case "bind!": {
       if (it2.length !== 3) break;
-      const tok2 = instantiate(it.bnd, it2[1]);
+      const tok2 = inst(env, it.bnd, it2[1]);
       if (tok2.kind === "sym") {
         const w = cloneWorld(st.world);
-        w.tokens.set(tok2.name, instantiate(it.bnd, it2[2]));
+        w.tokens.set(tok2.name, inst(env, 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]);
+      const fileAtom = inst(env, 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));
+      return spaceMutate(
+        env,
+        st,
+        prev,
+        it2[1],
+        it.bnd,
+        (w, name) => appendSpace(env, w, name, fileAtoms)
+      );
     }
     default:
       break;
@@ -3211,10 +4707,12 @@ function indexSelfRules(w, atoms) {
     }
   }
 }
-function appendSpace(w0, name, atoms) {
+function appendSpace(env, w0, name, atoms) {
   if (name === "&self") {
     let selfRules = w0.selfRules;
     let selfVarRules = w0.selfVarRules;
+    let selfExtra = w0.selfExtra;
+    let flatSelfExtra = w0.flatSelfExtra;
     let copiedRules = false;
     for (const x of atoms) {
       if (opOf(x) === "=" && x.kind === "expr" && x.items.length === 3) {
@@ -3229,19 +4727,35 @@ function appendSpace(w0, name, atoms) {
         else selfRules.set(k, [...selfRules.get(k) ?? [], [lhs, rhs]]);
       }
     }
+    if (env.useFlatAtomspace === true) {
+      if (flatSelfExtra !== void 0 || logSize(selfExtra) === 0) {
+        const base = flatSelfExtra ?? FlatAtomSpace.empty();
+        if (atoms.every(canCompactAtom)) {
+          flatSelfExtra = base.appendAll(atoms);
+        } else {
+          selfExtra = logFromArray([...base.toArray(), ...logToArray(selfExtra), ...atoms]);
+          flatSelfExtra = void 0;
+        }
+      } else {
+        selfExtra = logAppendAll(selfExtra, atoms);
+      }
+    } else {
+      selfExtra = logAppendAll(selfExtra, atoms);
+    }
     return {
       spaces: w0.spaces,
       store: w0.store,
       tokens: w0.tokens,
-      selfExtra: logAppendAll(w0.selfExtra, atoms),
+      selfExtra,
+      flatSelfExtra,
       selfRules,
       selfVarRules,
       maxStackDepth: w0.maxStackDepth
     };
   }
-  const w = cloneWorld(w0);
-  w.spaces.set(name, [...w.spaces.get(name) ?? [], ...atoms]);
-  return w;
+  const spaces = new Map(w0.spaces);
+  spaces.set(name, logAppendAll(spaces.get(name) ?? emptyLog, atoms));
+  return { ...w0, spaces };
 }
 function eraseSpace(w0, name, a) {
   const w = cloneWorld(w0);
@@ -3250,23 +4764,36 @@ function eraseSpace(w0, name, a) {
     return i < 0 ? [...xs] : [...xs.slice(0, i), ...xs.slice(i + 1)];
   };
   if (name === "&self") {
+    if (w.flatSelfExtra !== void 0) {
+      const next = w.flatSelfExtra.removeOne(a);
+      if (next.size !== w.flatSelfExtra.size) {
+        w.flatSelfExtra = next;
+        return w;
+      }
+    }
     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) ?? []));
+  } else w.spaces.set(name, logFromArray(erase1(namedSpaceAtoms(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];
+function spaceMutate(env, st, prev, s, b, f) {
+  const name = spaceName(st.world, inst(env, b, s));
+  if (name === void 0) return [[finItem(prev, errAtom(inst(env, b, s), "not a space"), b)], st];
   return [[finItem(prev, emptyExpr, b)], { counter: st.counter, world: f(st.world, name) }];
 }
+function compiledAddAtom(env, st, space, added) {
+  if (opOf(added) === "=") return void 0;
+  const name = spaceName(st.world, space);
+  if (name === void 0) return void 0;
+  return { counter: st.counter, world: appendSpace(env, st.world, name, [added]) };
+}
+var COMPILED_IMPURE_OPS = { addAtom: compiledAddAtom };
 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))) {
+    for (const t of getTypesForQuery(env, typePrep(env, 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;
@@ -3280,7 +4807,7 @@ function* getTypeOpG(env, fuel, st, prev, xi, b) {
       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) => {
+    const illTyped = getTypes(env, typePrep(env, 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;
@@ -3289,21 +4816,447 @@ function* getTypeOpG(env, fuel, st, prev, xi, b) {
   }
   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);
+function matchSetup(env, st, space, pattern, b) {
+  const sn = spaceName(st.world, inst(env, b, space));
+  const subbed = subTokens(st.world, pattern, env.intern);
   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;
+    return { getCandidates: (pInst) => matchCandidates(env, st.world, pInst), patterns };
+  }
+  return { getCandidates: namedSpaceCandidateGetter(st.world, st.world.spaces.get(sn)), patterns };
+}
+function matchInsideOnce(a) {
+  if (a.kind !== "expr" || opOf(a) !== "once" || a.items.length !== 2) return void 0;
+  const inner = a.items[1];
+  return inner.kind === "expr" && opOf(inner) === "match" && inner.items.length === 4 ? inner : void 0;
+}
+function matchFromEmptyCollapseCheck(a) {
+  if (a.kind !== "expr" || opOf(a) !== "==" || a.items.length !== 3) return void 0;
+  const left = a.items[1];
+  const right = a.items[2];
+  const collapseArg = (x) => x.kind === "expr" && opOf(x) === "collapse" && x.items.length === 2 ? matchInsideOnce(x.items[1]) : void 0;
+  if (atomEq(left, emptyExpr)) return collapseArg(right);
+  if (atomEq(right, emptyExpr)) return collapseArg(left);
+  return void 0;
+}
+function tryFastNamedOnceMatch(env, st, body, b) {
+  if (body.kind !== "expr" || opOf(body) !== "match" || body.items.length !== 4) return void 0;
+  const sn = spaceName(st.world, inst(env, b, body.items[1]));
+  if (sn === void 0 || sn === "&self") return void 0;
+  const subbed = subTokens(st.world, body.items[2], env.intern);
+  if (opOf(subbed) === "," && subbed.kind === "expr") return void 0;
+  const pInst = inst(env, b, resolveStates(st.world, subbed));
+  const space = st.world.spaces.get(sn) ?? emptyLog;
+  if (!pInst.ground || logNonGround(space) !== 0 || st.world.store.size !== 0) return void 0;
+  const st2 = { counter: st.counter + logSize(space), world: st.world };
+  if (idxCount(logGroundIdx(space), pInst) === 0) return { value: void 0, state: st2 };
+  return { value: inst(env, b, body.items[3]), state: st2 };
+}
+function tryFastNamedAddIfAbsent(env, st, ifExpr, b) {
+  const match = matchFromEmptyCollapseCheck(ifExpr.items[1]);
+  if (match === void 0) return void 0;
+  const add = ifExpr.items[2];
+  const otherwise = ifExpr.items[3];
+  if (add.kind !== "expr" || opOf(add) !== "add-atom" || add.items.length !== 3 || otherwise.kind !== "expr" || opOf(otherwise) !== "empty" || otherwise.items.length !== 1)
+    return void 0;
+  const matchSpace = inst(env, b, match.items[1]);
+  const addSpace = inst(env, b, add.items[1]);
+  const matchAtom = inst(
+    env,
+    b,
+    resolveStates(st.world, subTokens(st.world, match.items[2], env.intern))
+  );
+  const addAtom = inst(env, b, add.items[2]);
+  if (!atomEq(matchSpace, addSpace) || !atomEq(matchAtom, addAtom)) return void 0;
+  const name = spaceName(st.world, matchSpace);
+  if (name === void 0 || name === "&self") return void 0;
+  const space = st.world.spaces.get(name) ?? emptyLog;
+  if (!matchAtom.ground || logNonGround(space) !== 0 || st.world.store.size !== 0) return void 0;
+  const checked = { counter: st.counter + logSize(space), world: st.world };
+  if (idxCount(logGroundIdx(space), matchAtom) !== 0) return { added: false, state: checked };
+  if (opOf(addAtom) === "=") disableTabling(env);
+  return {
+    added: true,
+    state: { counter: checked.counter, world: appendSpace(env, checked.world, name, [addAtom]) }
+  };
+}
+function isCanonicalAddUniqueRule(lhs, rhs) {
+  if (lhs.kind !== "expr" || opOf(lhs) !== "add-unique-or-fail" || lhs.items.length !== 3)
+    return false;
+  const spaceVar = lhs.items[1];
+  const exprVar = lhs.items[2];
+  if (spaceVar.kind !== "var" || exprVar.kind !== "var") return false;
+  if (rhs.kind !== "expr" || opOf(rhs) !== "let" || rhs.items.length !== 4) return false;
+  const stVar = rhs.items[1];
+  const key = rhs.items[2];
+  const body = rhs.items[3];
+  if (stVar.kind !== "var") return false;
+  if (key.kind !== "expr" || opOf(key) !== "s" || key.items.length !== 2 || key.items[1].kind !== "expr" || opOf(key.items[1]) !== "repra" || key.items[1].items.length !== 2 || !atomEq(key.items[1].items[1], exprVar))
+    return false;
+  if (body.kind !== "expr" || opOf(body) !== "if" || body.items.length !== 4) return false;
+  const match = matchFromEmptyCollapseCheck(body.items[1]);
+  const add = body.items[2];
+  const otherwise = body.items[3];
+  return match !== void 0 && atomEq(match.items[1], spaceVar) && atomEq(match.items[2], stVar) && add.kind === "expr" && opOf(add) === "add-atom" && add.items.length === 3 && atomEq(add.items[1], spaceVar) && atomEq(add.items[2], stVar) && otherwise.kind === "expr" && opOf(otherwise) === "empty" && otherwise.items.length === 1;
+}
+function tryFastAddUniqueOrFailCall(env, st, call, b) {
+  const rules = candidatesW(env, st.world, call);
+  if (rules.length !== 1 || !isCanonicalAddUniqueRule(rules[0][0], rules[0][1])) return void 0;
+  const spaceAtom = inst(env, b, call.items[1]);
+  const name = spaceName(st.world, spaceAtom);
+  if (name === void 0 || name === "&self") return void 0;
+  const value = inst(env, b, call.items[2]);
+  const key = expr([sym("s"), expr([sym("repra"), value])]);
+  const space = st.world.spaces.get(name) ?? emptyLog;
+  if (!key.ground || logNonGround(space) !== 0 || st.world.store.size !== 0) return void 0;
+  const checked = { counter: st.counter + rules.length + logSize(space), world: st.world };
+  if (idxCount(logGroundIdx(space), key) !== 0) return { added: false, state: checked };
+  return {
+    added: true,
+    state: { counter: checked.counter, world: appendSpace(env, checked.world, name, [key]) }
+  };
+}
+var isExprOp = (a, op, len) => a.kind === "expr" && a.items.length === len && opOf(a) === op;
+var isRuleVar = (a) => a.kind === "var";
+var isIntLiteral = (a, n) => atomEq(a, gint(n));
+var intValue = (a) => a.kind === "gnd" && a.value.g === "int" ? a.value.n : void 0;
+function queueRuleArgs(lhs, op) {
+  if (!isExprOp(lhs, op, 3)) return void 0;
+  const eVar = lhs.items[1];
+  const lhsQueue = lhs.items[2];
+  if (!isRuleVar(eVar) || !isExprOp(lhsQueue, "queue", 4)) return void 0;
+  return {
+    eVar,
+    inVar: lhsQueue.items[1],
+    outAtom: lhsQueue.items[2],
+    nVar: lhsQueue.items[3]
+  };
+}
+function queueParts(a) {
+  if (!isExprOp(a, "queue", 4)) return void 0;
+  const inList = a.items[1];
+  const outList = a.items[2];
+  const size2 = intValue(a.items[3]);
+  if (inList.kind !== "expr" || outList.kind !== "expr" || size2 === void 0) return void 0;
+  return { inList, outList, size: size2 };
+}
+function plusOne(a, v) {
+  return isExprOp(a, "+", 3) && atomEq(a.items[1], v) && isIntLiteral(a.items[2], 1);
+}
+function minusOne(a, v) {
+  return isExprOp(a, "-", 3) && atomEq(a.items[1], v) && isIntLiteral(a.items[2], 1);
+}
+function isCanonicalEmptyQueueRule(lhs, rhs) {
+  return isExprOp(lhs, "empty-queue", 1) && isExprOp(rhs, "queue", 4) && atomEq(rhs.items[1], emptyExpr) && atomEq(rhs.items[2], emptyExpr) && isIntLiteral(rhs.items[3], 0);
+}
+function isCanonicalEnqueueRule(lhs, rhs) {
+  const lhsVars = queueRuleArgs(lhs, "enqueue");
+  if (lhsVars === void 0 || !isExprOp(rhs, "queue", 4)) return false;
+  const { eVar, inVar, outAtom: outVar, nVar } = lhsVars;
+  const rhsIn = rhs.items[1];
+  return isRuleVar(inVar) && isRuleVar(outVar) && isRuleVar(nVar) && isExprOp(rhsIn, "cons", 3) && atomEq(rhsIn.items[1], eVar) && atomEq(rhsIn.items[2], inVar) && atomEq(rhs.items[2], outVar) && plusOne(rhs.items[3], nVar);
+}
+function isCanonicalNormalDequeueRule(lhs, rhs) {
+  const lhsVars = queueRuleArgs(lhs, "dequeue");
+  if (lhsVars === void 0 || !isExprOp(rhs, "queue", 4)) return false;
+  const { eVar, inVar, outAtom: outCons, nVar } = lhsVars;
+  if (!isRuleVar(inVar) || !isRuleVar(nVar) || !isExprOp(outCons, "cons", 3)) return false;
+  const outVar = outCons.items[2];
+  return isRuleVar(outVar) && atomEq(outCons.items[1], eVar) && atomEq(rhs.items[1], inVar) && atomEq(rhs.items[2], outVar) && minusOne(rhs.items[3], nVar);
+}
+function isCanonicalReverseDequeueRule(lhs, rhs) {
+  const lhsVars = queueRuleArgs(lhs, "dequeue");
+  if (lhsVars === void 0 || !isExprOp(rhs, "let", 4)) return false;
+  const { eVar, inVar, outAtom, nVar } = lhsVars;
+  if (!isRuleVar(inVar) || !atomEq(outAtom, emptyExpr) || !isRuleVar(nVar)) return false;
+  const pat = rhs.items[1];
+  const rev = rhs.items[2];
+  const body = rhs.items[3];
+  if (!isExprOp(pat, "cons", 3) || !isExprOp(rev, "reverse", 2) || !isExprOp(body, "queue", 4))
+    return false;
+  const restVar = pat.items[2];
+  return isRuleVar(restVar) && atomEq(pat.items[1], eVar) && atomEq(rev.items[1], inVar) && atomEq(body.items[1], emptyExpr) && atomEq(body.items[2], restVar) && minusOne(body.items[3], nVar);
+}
+function tryFastEmptyQueueCall(env, st, call) {
+  const rules = candidatesW(env, st.world, call);
+  if (rules.length !== 1 || !isCanonicalEmptyQueueRule(rules[0][0], rules[0][1]))
+    return void 0;
+  return {
+    results: [[expr([sym("queue"), emptyExpr, emptyExpr, gint(0)]), emptyBindings]],
+    state: { counter: st.counter + rules.length, world: st.world }
+  };
+}
+function tryFastEnqueueCall(env, st, call) {
+  const rules = candidatesW(env, st.world, call);
+  if (rules.length !== 1 || !isCanonicalEnqueueRule(rules[0][0], rules[0][1])) return void 0;
+  const q = queueParts(call.items[2]);
+  if (q === void 0) return void 0;
+  const nextIn = expr([call.items[1], ...q.inList.items]);
+  return {
+    results: [[expr([sym("queue"), nextIn, q.outList, gint(addInt(q.size, 1))]), emptyBindings]],
+    // The interpreted RHS calls the stdlib `(cons ...)` rule once before `queue` becomes inert.
+    state: { counter: st.counter + rules.length + 1, world: st.world }
+  };
+}
+function queuePopBindings(want, got) {
+  const ms = matchAtoms(want, got).filter((m) => !hasLoop(m));
+  return ms.length === 0 ? void 0 : ms;
+}
+function tryFastDequeueCall(env, st, call) {
+  const rules = candidatesW(env, st.world, call);
+  if (rules.length !== 2 || !isCanonicalNormalDequeueRule(rules[0][0], rules[0][1]) || !isCanonicalReverseDequeueRule(rules[1][0], rules[1][1]))
+    return void 0;
+  const q = queueParts(call.items[2]);
+  if (q === void 0) return void 0;
+  const wanted = call.items[1];
+  if (q.outList.items.length > 0) {
+    const got2 = q.outList.items[0];
+    const ms2 = queuePopBindings(wanted, got2);
+    if (ms2 === void 0) return void 0;
+    const next2 = expr([
+      sym("queue"),
+      q.inList,
+      expr(q.outList.items.slice(1)),
+      gint(subInt(q.size, 1))
+    ]);
+    return {
+      results: ms2.map((m) => [next2, m]),
+      state: { counter: st.counter + rules.length, world: st.world }
+    };
   }
-  const [sols, st2] = patterns.length >= 2 ? matchConjJoin(getCandidates, patterns, st, b) : matchConj(getCandidates, patterns, st, [b]);
+  if (q.inList.items.length === 0) return void 0;
+  const reversed = [...q.inList.items].reverse();
+  const got = reversed[0];
+  const ms = queuePopBindings(wanted, got);
+  if (ms === void 0) return void 0;
+  const next = expr([sym("queue"), emptyExpr, expr(reversed.slice(1)), gint(subInt(q.size, 1))]);
+  return {
+    results: ms.map((m) => [next, m]),
+    // The reverse branch applies the dequeue rule, then the stdlib `let` rule.
+    state: { counter: st.counter + rules.length + 1, world: st.world }
+  };
+}
+function tryFastQueueCall(env, st, call) {
+  const op = opOf(call);
+  if (op === "empty-queue" && call.items.length === 1) return tryFastEmptyQueueCall(env, st, call);
+  if (op === "enqueue" && call.items.length === 3) return tryFastEnqueueCall(env, st, call);
+  if (op === "dequeue" && call.items.length === 3) return tryFastDequeueCall(env, st, call);
+  return void 0;
+}
+function tileCellKey(a) {
+  if (a.kind === "sym") return "s:" + a.name;
+  if (a.kind === "gnd" && a.value.g === "int") return "i:" + String(a.value.n);
+  return void 0;
+}
+function tileStateKey(a) {
+  if (a.kind !== "expr" || a.items.length !== 9) return void 0;
+  const parts = [];
+  let blanks = 0;
+  for (const cell of a.items) {
+    if (cell.kind === "sym" && cell.name === "___") blanks += 1;
+    const k = tileCellKey(cell);
+    if (k === void 0) return void 0;
+    parts.push(k);
+  }
+  return blanks === 1 ? parts.join("|") : void 0;
+}
+function tileNeighbors(state) {
+  const blank = state.items.findIndex((x) => x.kind === "sym" && x.name === "___");
+  const swaps = blank === 0 ? [1, 3] : blank === 1 ? [0, 2, 4] : blank === 2 ? [1, 5] : blank === 3 ? [0, 4, 6] : blank === 4 ? [1, 3, 5, 7] : blank === 5 ? [2, 4, 8] : blank === 6 ? [3, 7] : blank === 7 ? [4, 6, 8] : [5, 7];
   const out = [];
-  for (const m of sols) if (!hasLoop(m)) out.push(finItem(prev, instantiate(m, template), m));
-  return [out, st2];
+  for (const j of swaps) {
+    const items = state.items.slice();
+    [items[blank], items[j]] = [items[j], items[blank]];
+    out.push(expr(items));
+  }
+  return out;
+}
+function tileVisitedAtom(state) {
+  return expr([sym("s"), expr([sym("repra"), state])]);
+}
+function hasCanonicalTilePuzzleRuntime(env, w) {
+  if ((env.ruleIndex.get("move")?.length ?? 0) !== 24) return false;
+  if ((env.ruleIndex.get("bfs_all")?.length ?? 0) !== 1) return false;
+  if ((env.ruleIndex.get("bfs_loop")?.length ?? 0) !== 2) return false;
+  if (logSize(w.spaces.get("&dup") ?? emptyLog) !== 0) return false;
+  const emptyRules = candidatesW(env, w, expr([sym("empty-queue")]));
+  if (emptyRules.length !== 1 || !isCanonicalEmptyQueueRule(emptyRules[0][0], emptyRules[0][1]))
+    return false;
+  const enqueueRules = candidatesW(
+    env,
+    w,
+    expr([sym("enqueue"), emptyExpr, expr([sym("queue"), emptyExpr, emptyExpr, gint(0)])])
+  );
+  if (enqueueRules.length !== 1 || !isCanonicalEnqueueRule(enqueueRules[0][0], enqueueRules[0][1]))
+    return false;
+  const dequeueRules = candidatesW(
+    env,
+    w,
+    expr([sym("dequeue"), variable("_"), expr([sym("queue"), emptyExpr, emptyExpr, gint(0)])])
+  );
+  if (dequeueRules.length !== 2 || !isCanonicalNormalDequeueRule(dequeueRules[0][0], dequeueRules[0][1]) || !isCanonicalReverseDequeueRule(dequeueRules[1][0], dequeueRules[1][1]))
+    return false;
+  const addUniqueRules = candidatesW(
+    env,
+    w,
+    expr([sym("add-unique-or-fail"), sym("&dup"), emptyExpr])
+  );
+  return addUniqueRules.length === 1 && isCanonicalAddUniqueRule(addUniqueRules[0][0], addUniqueRules[0][1]);
+}
+function tryFastTilePuzzleBfsAll(env, st, call) {
+  if (opOf(call) !== "bfs_all" || call.items.length !== 2 || st.world.store.size !== 0)
+    return void 0;
+  const start = call.items[1];
+  const startKey = tileStateKey(start);
+  if (start.kind !== "expr" || startKey === void 0) return void 0;
+  if (!hasCanonicalTilePuzzleRuntime(env, st.world)) return void 0;
+  const seen = /* @__PURE__ */ new Set();
+  const added = [];
+  const queue = [start];
+  let head = 0;
+  while (head < queue.length) {
+    const state = queue[head++];
+    for (const next of tileNeighbors(state)) {
+      const key = tileStateKey(next);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      added.push(tileVisitedAtom(next));
+      queue.push(next);
+    }
+  }
+  return {
+    results: [[gint(queue.length), emptyBindings]],
+    state: { counter: st.counter, world: appendSpace(env, st.world, "&dup", added) }
+  };
+}
+function atomHasCustomGrounded(a) {
+  if (a.kind === "gnd") return a.match !== void 0;
+  if (a.kind === "expr") return a.items.some(atomHasCustomGrounded);
+  return false;
+}
+var TRAIL_COUNT_BUDGET = 8e6;
+function seededTrail(b0) {
+  const tr = new Trail();
+  for (const [x, a] of valEntries(b0)) tr.bind(x, a);
+  for (const r of eqRelations(b0)) if (tr.get(r.x) === void 0) tr.bind(r.x, variable(r.y));
+  return tr;
+}
+function countTrailDFS(tr, getCandidates, patterns, counter0, freshCaches) {
+  let counter = counter0;
+  let count = 0;
+  let bailed = false;
+  let nodes = 0;
+  const rec = (i) => {
+    if (++nodes > TRAIL_COUNT_BUDGET) {
+      bailed = true;
+      return;
+    }
+    if (i === patterns.length) {
+      count += 1;
+      return;
+    }
+    const pInst = tr.resolve(patterns[i]);
+    const source = getCandidates(pInst);
+    const cache3 = syntheticCandidateSource(source) ? void 0 : freshCaches?.[i];
+    for (const cand of source) {
+      if (atomHasCustomGrounded(cand)) {
+        bailed = true;
+        return;
+      }
+      let fresh = cache3?.get(cand);
+      if (fresh === void 0) {
+        fresh = freshenRule(counter, cand, cand)[0];
+        counter += 1;
+        cache3?.set(cand, fresh);
+      }
+      const mk = tr.mark();
+      if (unifyTrail(tr, pInst, fresh)) rec(i + 1);
+      tr.undo(mk);
+      if (bailed) return;
+    }
+    counter += candidateCounterPadding(source);
+  };
+  rec(0);
+  return bailed ? void 0 : { count, counter };
+}
+function matchCountTrail(getCandidates, patterns, st, b0) {
+  for (const p of patterns) if (atomHasCustomGrounded(p)) return void 0;
+  return countTrailDFS(seededTrail(b0), getCandidates, patterns, st.counter);
+}
+function* matchSingleSolutions(env, getCandidates, pattern, st, b0) {
+  let counter = st.counter;
+  const pInst = inst(env, b0, pattern);
+  const source = getCandidates(pInst);
+  for (const atom of source) {
+    const fresh = freshenRule(counter, atom, atom)[0];
+    counter += 1;
+    for (const mb of matchAtoms(pInst, fresh))
+      for (const m of merge(b0, mb)) if (!hasLoop(m)) yield m;
+  }
+  counter += candidateCounterPadding(source);
+}
+function matchSingleEndState(env, getCandidates, pattern, template, st, b0) {
+  const pInst = inst(env, b0, pattern);
+  let valuesAreNormal = isNormalForm(env, st.world, pInst) && isNormalFormAssumingVars(env, st.world, template);
+  let counter = st.counter;
+  const source = getCandidates(pInst);
+  for (const atom of source) {
+    counter += 1;
+    if (valuesAreNormal && !isNormalForm(env, st.world, atom)) valuesAreNormal = false;
+  }
+  counter += candidateCounterPadding(source);
+  return { endState: { counter, world: st.world }, valuesAreNormal };
+}
+function matchPlan(env, st, space, pattern, template, b) {
+  const { getCandidates, patterns } = matchSetup(env, st, space, pattern, b);
+  if (patterns.length === 1) {
+    const pat = patterns[0];
+    const { endState: endState2, valuesAreNormal } = matchSingleEndState(
+      env,
+      getCandidates,
+      pat,
+      template,
+      st,
+      b
+    );
+    const solutions = () => matchSingleSolutions(env, getCandidates, pat, st, b);
+    return {
+      endState: endState2,
+      valuesAreNormal,
+      *foldItems(prev) {
+        for (const m of solutions()) yield finItem(prev, inst(env, m, template), m);
+      },
+      *foldValues() {
+        for (const m of solutions()) yield inst(env, m, template);
+      }
+    };
+  }
+  const [sols, endState] = patterns.length >= 2 ? matchConjJoin(env, getCandidates, patterns, st, b) : matchConj(env, getCandidates, patterns, st, [b]);
+  return {
+    endState,
+    valuesAreNormal: false,
+    *foldItems(prev) {
+      for (const m of sols) if (!hasLoop(m)) yield finItem(prev, inst(env, m, template), m);
+    },
+    *foldValues() {
+      for (const m of sols) if (!hasLoop(m)) yield inst(env, m, template);
+    }
+  };
+}
+function matchOp(env, st, prev, space, pattern, template, b) {
+  const plan = matchPlan(env, st, space, pattern, template, b);
+  const out = [];
+  for (const item of plan.foldItems(prev)) out.push(item);
+  return [out, plan.endState];
+}
+function matchItemSource(env, st, prev, space, pattern, template, b) {
+  const plan = matchPlan(env, st, space, pattern, template, b);
+  return {
+    endState: plan.endState,
+    foldItems() {
+      return plan.foldItems(prev);
+    }
+  };
 }
 function* interpretLoopG(env, fuel, st, work, sink) {
   const done = [];
@@ -3311,15 +5264,45 @@ function* interpretLoopG(env, fuel, st, work, sink) {
     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 stack = [];
+  let source;
+  const suspended = [];
   let cur = st;
+  const beginSource = (src, suspend) => {
+    if (suspend) suspended.push({ stack, source });
+    stack = [];
+    source = src.foldItems()[Symbol.iterator]();
+    cur = src.endState;
+  };
+  if (isItemSource(work)) {
+    beginSource(work, false);
+  } else {
+    for (let i = work.length - 1; i >= 0; i--) stack.push(work[i]);
+  }
+  const pullSourceItem = () => {
+    while (stack.length === 0 && source !== void 0) {
+      const next = source.next();
+      if (next.done === true) {
+        const prev = suspended.pop();
+        if (prev === void 0) {
+          source = void 0;
+        } else {
+          stack = prev.stack;
+          source = prev.source;
+        }
+        continue;
+      }
+      if (isFinal(next.value)) emit(finalPair(env, next.value));
+      else stack.push(next.value);
+    }
+    return stack.length > 0;
+  };
   let f = fuel;
-  while (stack.length > 0) {
+  while (pullSourceItem()) {
     if (f <= 0) {
       for (let i = stack.length - 1; i >= 0; i--) {
         const it2 = stack[i];
-        emit(isFinal(it2) ? finalPair(it2) : exhaustedPair(it2));
+        emit(isFinal(it2) ? finalPair(env, it2) : exhaustedPair(env, it2));
       }
       return [done, cur];
     }
@@ -3328,25 +5311,28 @@ function* interpretLoopG(env, fuel, st, work, sink) {
       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));
+        emit(isFinal(it) ? finalPair(env, it) : exhaustedPair(env, it));
         continue;
       }
     }
     const [results, st2] = yield* interpretStack1G(env, f - 1, cur, it);
     cur = st2;
     f -= 1;
+    if (isItemSource(results)) {
+      beginSource(results, true);
+      continue;
+    }
     const more = [];
     for (const r of results) {
       if (isFinal(r)) {
-        if (sink !== void 0) sink(finalPair(r));
-        else done.push(finalPair(r));
+        if (sink !== void 0) sink(finalPair(env, r));
+        else done.push(finalPair(env, 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;
@@ -3408,11 +5394,283 @@ 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;
 }
+var COLLAPSE_ROUTE_ENV = "METTA_COLLAPSE_ROUTE";
+var DONE_UNIT = sym("done");
+var collapseRouteEnabled = () => process.env[COLLAPSE_ROUTE_ENV] !== "0";
+var countAggregateEnabled = () => process.env.METTA_COUNT_AGGREGATE !== "0";
+var voidBuildEnabled = () => process.env.METTA_VOID_BUILD !== "0";
+var conjCountEnabled = () => process.env.METTA_CONJ_COUNT !== "0";
+function splitVoidBuild(buildExpr, env) {
+  if (buildExpr.kind !== "expr") return void 0;
+  const voidable = (rhs) => {
+    if (rhs.kind !== "expr" || rhs.items.length === 0 || rhs.items[0].kind !== "sym")
+      return void 0;
+    const op = rhs.items[0].name;
+    const args = rhs.items.slice(1);
+    if (env.compiled?.get(op)?.kind !== "imperative" || args.some((a) => !a.ground))
+      return void 0;
+    return { op, args };
+  };
+  const head = opOf(buildExpr);
+  if (head === "let" && buildExpr.items.length === 4 && atomEq(buildExpr.items[3], DONE_UNIT)) {
+    const v = voidable(buildExpr.items[2]);
+    if (v === void 0) return void 0;
+    return {
+      prefix: expr([buildExpr.items[0], buildExpr.items[1], DONE_UNIT, DONE_UNIT]),
+      op: v.op,
+      args: v.args
+    };
+  }
+  if (head === "let*" && buildExpr.items.length === 3 && buildExpr.items[1].kind === "expr" && atomEq(buildExpr.items[2], DONE_UNIT)) {
+    const pairs = buildExpr.items[1].items;
+    const lastPair = pairs[pairs.length - 1];
+    if (lastPair === void 0 || lastPair.kind !== "expr" || lastPair.items.length !== 2)
+      return void 0;
+    const v = voidable(lastPair.items[1]);
+    if (v === void 0) return void 0;
+    const newPairs = [...pairs.slice(0, -1), expr([lastPair.items[0], DONE_UNIT])];
+    return {
+      prefix: expr([buildExpr.items[0], expr(newPairs), DONE_UNIT]),
+      op: v.op,
+      args: v.args
+    };
+  }
+  return void 0;
+}
+function addAtomVars(into, atom) {
+  for (const name of atomVars(atom)) into.add(name);
+}
+function hasAnyAtomVar(vars, atoms) {
+  for (const atom of atoms) for (const name of atomVars(atom)) if (vars.has(name)) return true;
+  return false;
+}
+function tailMatchBuild(body) {
+  if (body.kind !== "expr") return void 0;
+  const op = opOf(body);
+  if (op === "match" && body.items.length === 4)
+    return { buildExpr: DONE_UNIT, tailMatch: body, boundVars: /* @__PURE__ */ new Set() };
+  if (op === "let" && body.items.length === 4) {
+    const inner = tailMatchBuild(body.items[3]);
+    if (inner === void 0) return void 0;
+    const boundVars = new Set(inner.boundVars);
+    addAtomVars(boundVars, body.items[1]);
+    return {
+      buildExpr: expr([body.items[0], body.items[1], body.items[2], inner.buildExpr]),
+      tailMatch: inner.tailMatch,
+      boundVars
+    };
+  }
+  if (op === "let*" && body.items.length === 3 && body.items[1].kind === "expr") {
+    const inner = tailMatchBuild(body.items[2]);
+    if (inner === void 0) return void 0;
+    const boundVars = new Set(inner.boundVars);
+    for (const pair of body.items[1].items) {
+      if (pair.kind !== "expr" || pair.items.length !== 2) return void 0;
+      addAtomVars(boundVars, pair.items[0]);
+    }
+    return {
+      buildExpr: expr([body.items[0], body.items[1], inner.buildExpr]),
+      tailMatch: inner.tailMatch,
+      boundVars
+    };
+  }
+  return void 0;
+}
+function prepareCollapseRoute(env, st, bnd, call) {
+  if (!collapseRouteEnabled() || size(bnd) !== 0 || call.kind !== "expr" || !call.ground || call.items.length === 0 || call.items[0].kind !== "sym" || env.varRulesVar.length !== 0 || st.world.selfVarRules.length !== 0)
+    return void 0;
+  if (isDefinedHead(env, st.world, DONE_UNIT.name)) return void 0;
+  const op = call.items[0].name;
+  if (st.world.selfRules.has(op) || env.pureFunctors?.has(op) === true) return void 0;
+  const rules = env.ruleIndex.get(op);
+  if (rules === void 0 || rules.length !== 1) return void 0;
+  const args = call.items.slice(1);
+  if (args.some((arg) => !isNormalForm(env, st.world, arg))) return void 0;
+  if (typeMismatch(env, st.world, op, args, env.sigs.get(op)) !== void 0) return void 0;
+  const [lhs, rhs] = rules[0];
+  if (lhs.kind !== "expr" || lhs.items.length !== call.items.length || !canMatchShallow(lhs, call))
+    return void 0;
+  const suffix = "#" + st.counter;
+  const matches = [];
+  for (const mb of matchAtomsScoped(lhs, call, suffix))
+    for (const m of merge(bnd, mb)) if (!hasLoop(m)) matches.push(m);
+  if (matches.length !== 1) return void 0;
+  const body = inst(env, matches[0], rhs, suffix);
+  const tail = tailMatchBuild(body);
+  if (tail === void 0) return void 0;
+  if (hasAnyAtomVar(tail.boundVars, tail.tailMatch.items.slice(1))) return void 0;
+  let buildExpr = tail.buildExpr;
+  let voidCall;
+  if (voidBuildEnabled()) {
+    const split = splitVoidBuild(buildExpr, env);
+    if (split !== void 0) {
+      buildExpr = split.prefix;
+      voidCall = { op: split.op, args: split.args };
+    }
+  }
+  return {
+    buildExpr,
+    tailMatch: tail.tailMatch,
+    st: { counter: st.counter + 1, world: st.world },
+    bnd: matches[0],
+    voidCall
+  };
+}
+function tryCountAggregate(env, st, bnd, match) {
+  if (match.items.length < 3) return void 0;
+  const { getCandidates, patterns } = matchSetup(env, st, match.items[1], match.items[2], bnd);
+  if (patterns.length !== 1) return void 0;
+  const pat = inst(env, bnd, patterns[0]);
+  if (pat.kind !== "expr" || pat.items.length === 0 || pat.items[0].kind !== "sym")
+    return void 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 1; i < pat.items.length; i++) {
+    const a = pat.items[i];
+    if (a.kind !== "var" || seen.has(a.name)) return void 0;
+    seen.add(a.name);
+  }
+  if (seen.size === 0) return void 0;
+  const k = headKey(pat);
+  const arity = pat.items.length;
+  const unifies = (a) => a.kind === "var" || a.kind === "expr" && a.items.length === arity && (headKey(a) === k || a.items[0].kind === "var");
+  const w = st.world;
+  const sn = spaceName(w, inst(env, bnd, match.items[1]));
+  if ((sn === void 0 || sn === "&self") && w.store.size === 0 && w.flatSelfExtra === void 0 && env.varHeadedFacts.length === 0 && (env.factIndex.get(k)?.length ?? 0) === 0) {
+    let count2 = 0;
+    let iterated2 = 0;
+    for (let p = w.selfExtra; p !== null; p = p.prev) {
+      const akk = headKey(p.atom);
+      if (akk === void 0 || akk === k) {
+        iterated2 += 1;
+        if (unifies(p.atom)) count2 += 1;
+      }
+    }
+    return { count: count2, iterated: iterated2 };
+  }
+  const source = getCandidates(pat);
+  let count = 0;
+  let iterated = 0;
+  for (const cand of source) {
+    iterated += 1;
+    if (unifies(cand)) count += 1;
+  }
+  iterated += candidateCounterPadding(source);
+  return { count, iterated };
+}
+function* countTailMatchG(env, fuel, st, bnd, match) {
+  const agg = countAggregateEnabled() ? tryCountAggregate(env, st, bnd, match) : void 0;
+  if (agg !== void 0)
+    return { count: agg.count, state: { counter: st.counter + agg.iterated, world: st.world } };
+  {
+    const { getCandidates, patterns } = matchSetup(env, st, match.items[1], match.items[2], bnd);
+    const tc = patterns.length >= 2 && conjCountEnabled() ? matchConjCount(env, getCandidates, patterns, st, bnd) : env.useTrail === true ? matchCountTrail(getCandidates, patterns, st, bnd) : void 0;
+    if (tc !== void 0)
+      return { count: tc.count, state: { counter: tc.counter, world: st.world } };
+  }
+  let count = 0;
+  const [, stC] = yield* interpretLoopG(
+    env,
+    fuel,
+    st,
+    [
+      {
+        stack: atomToStack(expr([sym("metta"), countOnlyMatch(match), UNDEF, sym("&self")]), null),
+        bnd
+      }
+    ],
+    () => {
+      count++;
+    }
+  );
+  return { count, state: stC };
+}
+function* tryCollapseRouteG(env, fuel, st, bnd, call) {
+  const route = prepareCollapseRoute(env, st, bnd, call);
+  if (route === void 0) return void 0;
+  const [built, stAfterPrefix] = yield* interpretLoopG(env, fuel, route.st, [
+    {
+      stack: atomToStack(expr([sym("metta"), route.buildExpr, UNDEF, sym("&self")]), null),
+      bnd: route.bnd
+    }
+  ]);
+  if (built.length !== 1 || !atomEq(built[0][0], DONE_UNIT)) return void 0;
+  let stAfterBuild = stAfterPrefix;
+  if (route.voidCall !== void 0) {
+    const cr = runCompiled(
+      env,
+      route.voidCall.op,
+      route.voidCall.args,
+      stAfterPrefix,
+      COMPILED_IMPURE_OPS,
+      true
+    );
+    if (cr === void 0 || cr.state === void 0) return void 0;
+    stAfterBuild = cr.state;
+  }
+  return yield* countTailMatchG(env, fuel, stAfterBuild, built[0][1], route.tailMatch);
+}
+function canStreamStdlibCase(env, w) {
+  return STREAM_CASE && (env.ruleIndex.get("case")?.length ?? 0) === 1 && env.varRulesVar.length === 0 && !w.selfRules.has("case") && w.selfVarRules.length === 0;
+}
+function streamCaseSource(env, st, bnd, matchExpr, cases) {
+  if (cases.kind !== "expr" || cases.items.length !== 1) return void 0;
+  const onlyCase = cases.items[0];
+  if (onlyCase.kind !== "expr" || onlyCase.items.length !== 2 || onlyCase.items[0].kind !== "var")
+    return void 0;
+  const casePattern = inst(env, bnd, onlyCase.items[0]);
+  const caseTemplate = inst(env, bnd, onlyCase.items[1]);
+  const caseRuleEnd = { counter: st.counter + 1, world: st.world };
+  const plan = matchPlan(
+    env,
+    caseRuleEnd,
+    matchExpr.items[1],
+    matchExpr.items[2],
+    matchExpr.items[3],
+    bnd
+  );
+  if (!plan.valuesAreNormal) return void 0;
+  let valueCount = 0;
+  const valueIter = plan.foldValues()[Symbol.iterator]();
+  for (let next = valueIter.next(); !next.done; next = valueIter.next()) valueCount += 1;
+  const switchCount = valueCount === 0 ? 1 : valueCount;
+  const endState = {
+    counter: plan.endState.counter + 2 * switchCount,
+    world: plan.endState.world
+  };
+  const bodyFor = (value) => {
+    for (const mb of matchAtoms(value, casePattern))
+      for (const m of merge(bnd, mb)) if (!hasLoop(m)) return inst(env, m, caseTemplate);
+    return sym("Empty");
+  };
+  return {
+    endState,
+    *foldItems() {
+      let any = false;
+      for (const value of plan.foldValues()) {
+        any = true;
+        yield {
+          stack: atomToStack(expr([sym("metta"), bodyFor(value), UNDEF, sym("&self")]), null),
+          bnd
+        };
+      }
+      if (!any)
+        yield {
+          stack: atomToStack(
+            expr([sym("metta"), bodyFor(sym("Empty")), UNDEF, sym("&self")]),
+            null
+          ),
+          bnd
+        };
+    }
+  };
+}
 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];
+    return [[[makeExpr(env, [sym("Error"), inst(env, bnd, a), sym("StackOverflow")]), bnd]], st];
+  const w = inst(env, bnd, a);
+  if (w.kind === "expr" && w.ground && env.evaluatedAtoms.has(w)) return [[[w, bnd]], st];
+  if (CTOR_SC && w.kind === "expr" && !w.ground && w.items.length > 0 && env.varRulesVar.length === 0 && st.world.selfVarRules.length === 0 && isNormalForm(env, st.world, 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;
@@ -3430,7 +5688,35 @@ function* mettaEvalG(env, fuel, st, bnd, a) {
     reduceTrampoline: for (; ; ) {
       const op = lw.items[0].name;
       const args = lw.items.slice(1);
+      if (op === "collapse" && args.length === 1) {
+        const match = matchInsideOnce(args[0]);
+        if (match !== void 0) {
+          const namedMatch = tryFastNamedOnceMatch(env, lst, match, lbnd);
+          if (namedMatch !== void 0) {
+            const items = namedMatch.value === void 0 ? [] : [namedMatch.value];
+            return flushReturn([[expr(items), lbnd]], namedMatch.state);
+          }
+        }
+      }
+      if (op === "if" && args.length === 3) {
+        const added = tryFastNamedAddIfAbsent(env, lst, lw, lbnd);
+        if (added !== void 0)
+          return flushReturn(added.added ? [[emptyExpr, lbnd]] : [], added.state);
+      }
+      if (op === "add-unique-or-fail" && args.length === 2) {
+        const added = tryFastAddUniqueOrFailCall(env, lst, lw, lbnd);
+        if (added !== void 0)
+          return flushReturn(added.added ? [[emptyExpr, lbnd]] : [], added.state);
+      }
       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)) {
+        const z = args[0].items[1];
+        if (z.kind === "expr" && opOf(z) === "match" && z.items.length === 4) {
+          const counted = yield* countTailMatchG(env, fuel, lst, lbnd, z);
+          return flushReturn([[gint(BigInt(counted.count)), lbnd]], counted.state);
+        }
+        const routed = yield* tryCollapseRouteG(env, fuel, lst, lbnd, z);
+        if (routed !== void 0)
+          return flushReturn([[gint(BigInt(routed.count)), lbnd]], routed.state);
         let count = 0;
         const [, stC] = yield* interpretLoopG(
           env,
@@ -3483,7 +5769,21 @@ function* mettaEvalG(env, fuel, st, bnd, a) {
           lst
         );
       }
-      const queryVars = args.flatMap((x) => atomVars(x));
+      if (op === "case" && args.length === 2 && args[0].kind === "expr" && opOf(args[0]) === "match" && args[0].items.length === 4 && args[1].kind === "expr" && canStreamStdlibCase(env, lst.world)) {
+        const source = streamCaseSource(env, lst, lbnd, args[0], args[1]);
+        if (source !== void 0) {
+          const [selected, stCase] = yield* interpretLoopG(env, fuel, lst, source);
+          const [pairs2, stReduced] = yield* reduceChildrenG(
+            env,
+            fuel,
+            stCase,
+            selected,
+            () => void 0
+          );
+          return flushReturn(pairs2, stReduced);
+        }
+      }
+      const queryVars = queryVarsOf(args);
       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);
@@ -3498,10 +5798,10 @@ function* mettaEvalG(env, fuel, st, bnd, a) {
             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])]);
+              nextParts.push([[...accAtoms, p[0]], mergeRestrict(env, queryVars, accB, p[1])]);
             }
           } else {
-            nextParts.push([[...accAtoms, instantiate(accB, ae)], accB]);
+            nextParts.push([[...accAtoms, inst(env, accB, ae)], accB]);
           }
         }
         partials = nextParts;
@@ -3522,30 +5822,60 @@ function* mettaEvalG(env, fuel, st, bnd, a) {
           out.push([errFound, partB]);
           continue;
         }
-        const wApp = expr([sym(op), ...partAtoms]);
+        const wApp = makeExpr(env, [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]);
+            out.push([makeExpr(env, [sym("partial"), sym(op), makeExpr(env, partAtoms)]), partB]);
             continue;
           }
         }
-        if (env.compiled !== void 0) {
-          const cr = runCompiled(env, op, partAtoms);
+        const fastTilePuzzle = tryFastTilePuzzleBfsAll(env, cur2, wApp);
+        if (fastTilePuzzle !== void 0) {
+          cur2 = fastTilePuzzle.state;
+          for (const [value, rb] of fastTilePuzzle.results)
+            out.push([value, mergeRestrict(env, queryVars, partB, rb)]);
+          continue;
+        }
+        const fastQueue = tryFastQueueCall(env, cur2, wApp);
+        if (fastQueue !== void 0) {
+          cur2 = fastQueue.state;
+          for (const [value, rb] of fastQueue.results)
+            out.push([value, mergeRestrict(env, queryVars, partB, rb)]);
+          continue;
+        }
+        if (env.compiled !== void 0 && !cur2.world.selfRules.has(op) && cur2.world.selfVarRules.length === 0) {
+          const cr = runCompiled(env, op, partAtoms, cur2, COMPILED_IMPURE_OPS);
           if (cr !== void 0) {
-            out.push([cr, partB]);
+            const impResult = cr.state !== void 0;
+            if (cr.state !== void 0) cur2 = cr.state;
+            else if (cr.counterDelta !== 0)
+              cur2 = { counter: cur2.counter + cr.counterDelta, world: cur2.world };
+            for (const r of cr.results) {
+              const pb = mergeRestrict(env, queryVars, partB, r.bnd);
+              if (atomEq(r.atom, notReducibleA) || atomEq(r.atom, wApp)) {
+                if (wApp.ground) env.evaluatedAtoms.add(wApp);
+                out.push([wApp, partB]);
+              } else if ((opReturnsAtom || impResult) && !isEmbeddedOp(r.atom)) {
+                out.push([r.atom, pb]);
+              } else {
+                const [more, st4] = yield* mettaEvalG(env, fuel - 1, cur2, pb, r.atom);
+                cur2 = st4;
+                for (const m of more) out.push([m[0], mergeRestrict(env, queryVars, pb, m[1])]);
+              }
+            }
             continue;
           }
         }
         let eligible = false;
         let key = "";
-        if (tabling && wApp.ground && keyWellFormed(wApp)) {
+        if (tabling && wApp.ground) {
           if (cur2.world.selfRules.has(op)) {
-            if (runtimeFunctorPure(env, cur2.world, op)) {
+            if (runtimeFunctorPure(env, cur2.world, op) && keyWellFormed(wApp)) {
               eligible = true;
               key = tableKey(wApp) + "@v" + rulesVersion(cur2.world.selfRules.get(op));
             }
-          } else if (staticPure) {
+          } else if (staticPure && keyWellFormed(wApp)) {
             eligible = true;
             key = tableKey(wApp);
           }
@@ -3559,26 +5889,26 @@ function* mettaEvalG(env, fuel, st, bnd, a) {
         }
         const before = out.length;
         const [pairs2, st3] = yield* interpretLoopG(env, fuel, cur2, [
-          { stack: atomToStack(expr([sym("eval"), wApp]), null), bnd: lbnd }
+          { stack: atomToStack(makeExpr(env, [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]);
+            const pb = mergeRestrict(env, queryVars, partB, p[1]);
             if (eligible) pendingKeys.push(key);
             la = p[0];
             lbnd = pb;
             lst = cur2;
-            lw = instantiate(lbnd, la);
+            lw = inst(env, lbnd, la);
             continue reduceTrampoline;
           }
         }
         for (const p of pairs2) {
-          const pb = mergeRestrict(queryVars, partB, p[1]);
+          const pb = mergeRestrict(env, queryVars, partB, p[1]);
           if (atomEq(p[0], notReducibleA) || atomEq(p[0], wApp)) {
-            if (wApp.ground) evaluatedAtoms.add(wApp);
+            if (wApp.ground) env.evaluatedAtoms.add(wApp);
             out.push([wApp, partB]);
           } else if (opReturnsAtom && !isEmbeddedOp(p[0])) {
             out.push([p[0], pb]);
@@ -3586,7 +5916,7 @@ function* mettaEvalG(env, fuel, st, bnd, a) {
             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])]);
+              out.push([m[0], mergeRestrict(env, queryVars, pb, m[1])]);
             }
           }
         }
@@ -3600,14 +5930,14 @@ function* mettaEvalG(env, fuel, st, bnd, a) {
   }
   if (w.kind === "expr" && w.items.length > 0) {
     const [ruleRes, st12] = yield* interpretLoopG(env, fuel, st, [
-      { stack: atomToStack(expr([sym("eval"), w]), null), bnd }
+      { stack: atomToStack(makeExpr(env, [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")])]),
+            makeExpr(env, [sym("eval"), makeExpr(env, [sym("interpret-tuple"), w, sym("&self")])]),
             null
           ),
           bnd
@@ -3624,7 +5954,7 @@ function* mettaEvalG(env, fuel, st, bnd, a) {
     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 }
+    { stack: atomToStack(makeExpr(env, [sym("eval"), w]), null), bnd }
   ]);
   return yield* reduceChildrenG(
     env,
@@ -3638,22 +5968,22 @@ 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 stackOverflowResult(env, st, bnd, a) {
+  return [[[makeExpr(env, [sym("Error"), inst(env, 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);
+    if (isNativeStackOverflow(e)) return stackOverflowResult(env, 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);
+    if (isNativeStackOverflow(e)) return stackOverflowResult(env, st, bnd, a);
     throw e;
   });
 }
@@ -4169,12 +6499,15 @@ function preludeAtoms() {
 }
 var DEFAULT_FUEL2 = 1e5;
 var DEFAULT_TABLING = true;
-function buildDefaultEnv(imports, tabling) {
+function buildDefaultEnv(imports, tabling, experimental) {
   const env = buildEnv(
     [...preludeAtoms(), ...stdlibAtoms(), ...pettaStdlibAtoms()],
     stdTable()
   );
   env.imports = withBuiltinModules(imports);
+  if (experimental?.hashCons === true) env.intern = createInternTable();
+  if (experimental?.trail === true) env.useTrail = true;
+  if (experimental?.flatAtomspace === true) env.useFlatAtomspace = true;
   if (tabling) {
     env.table = /* @__PURE__ */ new Map();
     env.pureFunctors = analyzePurity(env);
@@ -4187,7 +6520,7 @@ function evalSequential(atoms, fuel = DEFAULT_FUEL2, imports = /* @__PURE__ */ n
   const out = [];
   let st = initSt();
   if (opts.maxStackDepth !== void 0) st.world.maxStackDepth = opts.maxStackDepth;
-  const env = buildDefaultEnv(imports, opts.tabling ?? DEFAULT_TABLING);
+  const env = buildDefaultEnv(imports, opts.tabling ?? DEFAULT_TABLING, opts.experimental);
   if (opts.parEvalImpl !== void 0) {
     const rulesSrc = atoms.filter((a) => !a.bang).map((a) => format(a.atom)).join("\n");
     const impl = opts.parEvalImpl;
@@ -4209,12 +6542,13 @@ function evalSequential(atoms, fuel = DEFAULT_FUEL2, imports = /* @__PURE__ */ n
 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()) {
+async function runProgramAsync(src, asyncOps = /* @__PURE__ */ new Map(), fuel = DEFAULT_FUEL2, imports = /* @__PURE__ */ new Map(), opts = {}) {
   const parsed = parseAll(src, standardTokenizer());
-  const env = buildDefaultEnv(imports, false);
+  const env = buildDefaultEnv(imports, opts.tabling ?? false, opts.experimental);
   for (const [k, v] of asyncOps) env.agt.set(k, v);
   const out = [];
   let st = initSt();
+  if (opts.maxStackDepth !== void 0) st.world.maxStackDepth = opts.maxStackDepth;
   for (const { atom, bang } of parsed) {
     if (!bang) {
       addAtomToEnv(env, atom);
@@ -4276,7 +6610,7 @@ var Interner = class {
     return this.add("s\0" + name, { kind: "sym", name });
   }
   internGround(value) {
-    return this.add(groundKey(value), { kind: "gnd", value });
+    return this.add(groundKey2(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). */
@@ -4284,7 +6618,7 @@ var Interner = class {
     return this.byKey.get("s\0" + name);
   }
   lookupGround(value) {
-    return this.byKey.get(groundKey(value));
+    return this.byKey.get(groundKey2(value));
   }
   /** Reconstruct the atom for a leaf id. */
   decodeLeaf(id) {
@@ -4295,7 +6629,7 @@ var Interner = class {
     return this.entries.length;
   }
 };
-function groundKey(v) {
+function groundKey2(v) {
   switch (v.g) {
     case "int":
       return "i\0" + v.n;
@@ -4586,83 +6920,13 @@ function williamTopK(kb, k, refCost = 4) {
     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,
+  FlatAtomSpace,
   FlatKB,
   IMPURE_OPS,
   InMemorySpace,
@@ -4692,11 +6956,14 @@ export {
   buildEnv,
   builtinModules,
   callGrounded,
+  canCompactAtom,
+  canInternExprItems,
   canonInt,
   cmpIntVal,
   collectImports,
   collectVars,
   compileEnv,
+  createInternTable,
   decodeAt,
   decodeAtom,
   emptyBindings,
@@ -4706,6 +6973,7 @@ export {
   encodeAtom,
   encodeInto,
   encodePattern,
+  eqRelations,
   eraseSubst,
   evalAtom,
   evalSequential,
@@ -4713,6 +6981,7 @@ export {
   extendSubst,
   format,
   freshenRule,
+  fromRelations,
   gbool,
   getTypes,
   gfloat,
@@ -4722,6 +6991,7 @@ export {
   groundType,
   gstr,
   gunit,
+  hasEq,
   hasLoop,
   hashOf,
   initSt,
@@ -4729,6 +6999,10 @@ export {
   intAbs,
   intDiv,
   intMod,
+  internAtom,
+  internBuiltExpr,
+  internExpr,
+  isEmpty,
   isErrorAtom,
   isExpr,
   isGnd,
@@ -4739,6 +7013,7 @@ export {
   keyWellFormed,
   lookupSubst,
   lookupVal,
+  makeValRel,
   matchAtoms,
   matchAtomsScoped,
   matchAtomsWith,
@@ -4747,6 +7022,7 @@ export {
   metaType,
   mettaEval,
   mettaEvalAsync,
+  mixHash,
   mulInt,
   occurs,
   oracleReport,
@@ -4754,15 +7030,20 @@ export {
   parseAll,
   pettaOpNames,
   preludeAtoms,
+  prependValRaw,
+  relations,
   removeVal,
   runCompiled,
   runProgram,
   runProgramAsync,
   setOutputSink,
   setRawSink,
+  size,
+  someVal,
   standardTokenizer,
   stdTable,
   stdlibAtoms,
+  strHash,
   subInt,
   sym,
   tableKey,
@@ -4770,8 +7051,10 @@ export {
   unifiable,
   unifyTop,
   unifyTrail,
+  valEntries,
   variable,
   wcoJoin,
+  wcoJoinFold,
   williamTopK,
   withBuiltinModules
 };