@metta-ts/core 1.0.3 → 1.0.5

package/dist/index.d.ts

@@ -209,15 +209,26 @@ declare class FlatAtomSpace {
     private readonly dead;
     readonly liveCount: number;
     readonly nonGroundCount: number;
+    private arr;
     private constructor();
     static empty(): FlatAtomSpace;
     static fromAtoms(atoms: readonly Atom[]): FlatAtomSpace | undefined;
     get size(): number;
-    appendAll(atoms: readonly Atom[]): FlatAtomSpace;
+    /** Append a batch as new visible facts. Returns undefined when some atom is not flat-storable (a
+     *  grounded executor/matcher); the caller keeps such a batch on the plain log instead. */
+    appendAll(atoms: readonly Atom[]): FlatAtomSpace | undefined;
     removeOne(atom: Atom): FlatAtomSpace;
     exactCount(atom: Atom): number;
     candidatesFor(patternHead: string | undefined): Iterable<Atom>;
     toArray(): Atom[];
+    /** Columnar mirror of the `&self` direct tally in eval.ts: over the visible facts the head filter
+     *  admits (head symbol `patternHead` or no symbol head, same filter as `candidatesFor`), count the
+     *  ones an all-distinct-variable pattern `(k $v..)` of `arity` items unifies with, without decoding
+     *  any fact. `iterated` is the admitted total (it advances the candidate counter). */
+    countHeadArity(patternHead: string, arity: number): {
+        count: number;
+        iterated: number;
+    };
     roundTrip(atom: Atom): Atom;
     private decodeFact;
     private visibleFactIds;
@@ -297,6 +308,20 @@ interface SymbolicHolder {
 }
 interface CompiledImpureOps {
     readonly addAtom: (env: MinEnv, st: St, space: Atom, atom: Atom) => St | undefined;
+    /** Solutions of a `(match space pattern template)` under the current world: the instantiated
+     *  template plus that solution's bindings, in the interpreter's own candidate order, and the
+     *  fresh-variable counter advance the interpreted match would have cost. Undefined = not a space. */
+    readonly matchSolutions?: (env: MinEnv, st: St, space: Atom, pattern: Atom, template: Atom) => {
+        readonly pairs: ReadonlyArray<readonly [Atom, Bindings]>;
+        readonly counterDelta: number;
+    } | undefined;
+    /** The add-if-absent idiom on a ground atom: exact-membership probe, then append when absent.
+     *  Undefined when the fast probe is unsound for this space (non-ground facts, static facts of the
+     *  same head, state handles), sending the caller back to the interpreter. */
+    readonly addIfAbsent?: (env: MinEnv, st: St, space: Atom, atom: Atom) => {
+        readonly added: boolean;
+        readonly state: St;
+    } | undefined;
 }
 type ImpEval = {
     readonly value: Atom;
@@ -308,7 +333,13 @@ interface ImperativeHolder {
     clauseCount: number;
     run: (partAtoms: readonly Atom[], st: St, ops: CompiledImpureOps, discard?: boolean) => ImpEval;
 }
-type CompiledHolder = FunctionalHolder | RewriteHolder | SymbolicHolder | ImperativeHolder;
+interface NondetHolder {
+    kind: "nondet";
+    arity: number;
+    clauseCount: number;
+    run: (env: MinEnv, partAtoms: readonly Atom[], st: St, ops: CompiledImpureOps) => CompiledRunResult | undefined;
+}
+type CompiledHolder = FunctionalHolder | RewriteHolder | SymbolicHolder | ImperativeHolder | NondetHolder;
 type CompiledFns = Map<string, CompiledHolder>;
 /** Compile every compilable pure single-clause function in `env` to a memoised native closure.
  *  Phase 1 infers return types (fixpoint, optimistic over recursion). Phase 2 compiles bodies with

package/dist/index.js

@@ -1048,6 +1048,7 @@ function canCompactAtom(a) {
       return a.items.every(canCompactAtom);
   }
 }
+var NOT_COMPACT = new Error("flat-atomspace: atom has an executor or custom matcher");
 var FlatAtomSpaceTable = class {
   termKind = new Int32Chunks();
   termStart = new Int32Chunks();
@@ -1057,7 +1058,17 @@ var FlatAtomSpaceTable = class {
   termData = new Int32Chunks();
   factRoot = new Int32Chunks();
   factHeadSym = new Int32Chunks();
-  hashBuckets = /* @__PURE__ */ new Map();
+  // Open-addressing intern table (linear probing over a power-of-two Int32Array; a slot holds
+  // termId + 1, 0 means empty; append-only, so no tombstones). Replaces a Map<number, TermId[]>
+  // whose per-hash bucket arrays were the dominant insert allocation on bulk loads.
+  slots = new Int32Array(1 << 12);
+  slotCount = 0;
+  // The empty slot where the last failed lookup probe for `missHash` ended. intern* runs
+  // lookup-then-push, so pushTerm claims this slot instead of re-probing the chain. Slots only ever
+  // fill (append-only), so a chain never shortens and the recorded slot stays on its hash's chain;
+  // pushTerm still re-checks the hash matches and the slot is still empty before trusting it.
+  missSlot = -1;
+  missHash = 0;
   symByName = /* @__PURE__ */ new Map();
   groundByKey = /* @__PURE__ */ new Map();
   varByName = /* @__PURE__ */ new Map();
@@ -1065,6 +1076,15 @@ var FlatAtomSpaceTable = class {
   symbols = [];
   grounds = [];
   vars = [];
+  // One canonical Atom per term, filled on first decode. Terms are interned and append-only, so a
+  // decoded atom is valid forever; without this, candidate enumeration rebuilt a fresh tree per fact
+  // per match, which on deep terms (peano's S^n numerals) made matching O(n^3) instead of O(n^2).
+  // Children resolve through the cache too, so the cached forest is maximally shared (hash-consed).
+  decoded = [];
+  // Reverse intern: an Atom object to its TermId. Weak, so the cache never pins an atom. Match
+  // bindings hold decoded (canonical) subterms, so an atom derived from them re-interns in O(new
+  // nodes) instead of O(depth), and a ground membership lookup is O(1) after its first walk.
+  termIdOf = /* @__PURE__ */ new WeakMap();
   get factCount() {
     return this.factRoot.length;
   }
@@ -1081,6 +1101,14 @@ var FlatAtomSpaceTable = class {
     return this.termFacts.get(term) ?? [];
   }
   insertAtom(atom) {
+    if (atom.kind !== "expr") return this.insertAtomUncached(atom);
+    const known = this.termIdOf.get(atom);
+    if (known !== void 0) return known;
+    const term = this.insertAtomUncached(atom);
+    this.termIdOf.set(atom, term);
+    return term;
+  }
+  insertAtomUncached(atom) {
     switch (atom.kind) {
       case "sym":
         return this.internLeaf(
@@ -1090,6 +1118,7 @@ var FlatAtomSpaceTable = class {
           true
         );
       case "gnd": {
+        if (atom.exec !== void 0 || atom.match !== void 0) throw NOT_COMPACT;
         const key = groundKey(atom.value);
         return this.internLeaf(
           TERM_GND,
@@ -1112,6 +1141,13 @@ var FlatAtomSpaceTable = class {
     }
   }
   lookupAtom(atom) {
+    const known = this.termIdOf.get(atom);
+    if (known !== void 0) return known;
+    const term = this.lookupAtomUncached(atom);
+    if (term !== void 0) this.termIdOf.set(atom, term);
+    return term;
+  }
+  lookupAtomUncached(atom) {
     switch (atom.kind) {
       case "sym": {
         const leaf = this.symByName.get(atom.name);
@@ -1139,6 +1175,14 @@ var FlatAtomSpaceTable = class {
     }
   }
   decodeTerm(term) {
+    const hit = this.decoded[term];
+    if (hit !== void 0) return hit;
+    const atom = this.decodeTermUncached(term);
+    this.decoded[term] = atom;
+    this.termIdOf.set(atom, term);
+    return atom;
+  }
+  decodeTermUncached(term) {
     const kind = this.termKind.get(term);
     const start = this.termStart.get(term);
     switch (kind) {
@@ -1203,11 +1247,22 @@ var FlatAtomSpaceTable = class {
     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;
+    hash |= 0;
+    const slots = this.slots;
+    const mask = slots.length - 1;
+    let i = hash & mask;
+    for (; ; ) {
+      const s = slots[i];
+      if (s === 0) {
+        this.missSlot = i;
+        this.missHash = hash;
+        return void 0;
+      }
+      const term = s - 1;
+      if (this.termHash.get(term) === hash && this.termKind.get(term) === kind && this.termStart.get(term) === leaf)
+        return term;
+      i = i + 1 & mask;
+    }
   }
   internExpr(children) {
     const existing = this.lookupExpr(children);
@@ -1222,33 +1277,69 @@ var FlatAtomSpaceTable = class {
     }
     return this.pushTerm(TERM_EXPR, start, children.length, hash, ground);
   }
+  // The probe skeleton repeats lookupLeaf's on purpose: sharing it would take a per-call equality
+  // closure, and avoiding that allocation on the intern path is why the open table exists.
   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;
+    hash |= 0;
+    const slots = this.slots;
+    const mask = slots.length - 1;
+    let i = hash & mask;
+    probe: for (; ; ) {
+      const s = slots[i];
+      if (s === 0) {
+        this.missSlot = i;
+        this.missHash = hash;
+        return void 0;
+      }
+      const term = s - 1;
+      if (this.termHash.get(term) === hash && this.termKind.get(term) === TERM_EXPR && this.termLen.get(term) === children.length) {
+        const start = this.termStart.get(term);
+        for (let j = 0; j < children.length; j++)
+          if (this.termData.get(start + j) !== children[j]) {
+            i = i + 1 & mask;
+            continue probe;
+          }
+        return term;
+      }
+      i = i + 1 & mask;
     }
-    return void 0;
   }
   pushTerm(kind, start, len, hash, ground) {
+    hash |= 0;
     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);
+    if ((this.slotCount + 1) * 4 > this.slots.length * 3) {
+      this.growSlots();
+      this.missSlot = -1;
+    }
+    let i = this.missSlot;
+    this.missSlot = -1;
+    if (i < 0 || this.missHash !== hash || this.slots[i] !== 0) {
+      const mask = this.slots.length - 1;
+      i = hash & mask;
+      while (this.slots[i] !== 0) i = i + 1 & mask;
+    }
+    this.slots[i] = term + 1;
+    this.slotCount += 1;
     return term;
   }
+  growSlots() {
+    const next = new Int32Array(this.slots.length * 2);
+    const mask = next.length - 1;
+    for (const s of this.slots) {
+      if (s === 0) continue;
+      let i = this.termHash.get(s - 1) & mask;
+      while (next[i] !== 0) i = i + 1 & mask;
+      next[i] = s;
+    }
+    this.slots = next;
+  }
 };
 var FlatAtomSpace = class _FlatAtomSpace {
   constructor(table, ranges, dead, liveCount, nonGroundCount) {
@@ -1263,23 +1354,31 @@ var FlatAtomSpace = class _FlatAtomSpace {
   dead;
   liveCount;
   nonGroundCount;
+  // toArray memo for this version (see toArray).
+  arr;
   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;
   }
+  /** Append a batch as new visible facts. Returns undefined when some atom is not flat-storable (a
+   *  grounded executor/matcher); the caller keeps such a batch on the plain log instead. */
   appendAll(atoms) {
     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;
+    try {
+      for (const atom of atoms) {
+        const fact = this.table.insertFact(atom);
+        if (!this.table.isTermGround(this.table.factRoot.get(fact))) nonGround += 1;
+      }
+    } catch (e) {
+      if (e === NOT_COMPACT) return void 0;
+      throw e;
     }
     const end = this.table.factCount;
     return new _FlatAtomSpace(
@@ -1293,8 +1392,8 @@ var FlatAtomSpace = class _FlatAtomSpace {
   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;
+    for (const fact of this.table.factsForTerm(term)) {
+      if (!this.factVisible(fact) || this.dead.has(fact)) continue;
       const dead = new Set(this.dead);
       dead.add(fact);
       const nonGround = this.table.isTermGround(term) ? this.nonGroundCount : this.nonGroundCount - 1;
@@ -1328,9 +1427,38 @@ var FlatAtomSpace = class _FlatAtomSpace {
     }
   }
   toArray() {
-    const out = [];
-    for (const fact of this.visibleFactIds()) out.push(this.decodeFact(fact));
-    return out;
+    if (this.arr === void 0) {
+      const out = [];
+      for (const fact of this.visibleFactIds()) out.push(this.decodeFact(fact));
+      this.arr = out;
+    }
+    return this.arr;
+  }
+  /** Columnar mirror of the `&self` direct tally in eval.ts: over the visible facts the head filter
+   *  admits (head symbol `patternHead` or no symbol head, same filter as `candidatesFor`), count the
+   *  ones an all-distinct-variable pattern `(k $v..)` of `arity` items unifies with, without decoding
+   *  any fact. `iterated` is the admitted total (it advances the candidate counter). */
+  countHeadArity(patternHead, arity) {
+    const t = this.table;
+    const headId = t.lookupHeadSym(patternHead);
+    let count = 0;
+    let iterated = 0;
+    for (const fact of this.visibleFactIds()) {
+      const fh = t.factHeadSym.get(fact);
+      if (fh !== ABSENT && fh !== headId) continue;
+      iterated += 1;
+      const root = t.factRoot.get(fact);
+      const kind = t.termKind.get(root);
+      if (kind === TERM_VAR) {
+        count += 1;
+        continue;
+      }
+      if (kind !== TERM_EXPR || t.termLen.get(root) !== arity) continue;
+      if (fh !== ABSENT) count += 1;
+      else if (arity > 0 && t.termKind.get(t.termData.get(t.termStart.get(root))) === TERM_VAR)
+        count += 1;
+    }
+    return { count, iterated };
   }
   roundTrip(atom) {
     return this.table.decodeTerm(this.table.insertAtom(atom));
@@ -2734,8 +2862,187 @@ function compileSymbolic(env, functor) {
   };
   return { kind: "symbolic", arity, clauseCount, run };
 }
+var NONDET_CALL_CAP = 4e6;
+function nondetIsData(env, a) {
+  if (a.kind !== "expr" || a.items.length === 0) return true;
+  const h = a.items[0];
+  if (h.kind === "expr" && h.items.length > 0) return false;
+  if (h.kind === "sym" && (env.ruleIndex.has(h.name) || env.gt.has(h.name) || IMPURE_OPS.has(h.name)))
+    return false;
+  return a.items.every((x) => nondetIsData(env, x));
+}
+function nondetCall(env, functor, val) {
+  if (val.kind !== "expr" || val.items.length === 0 || val.items[0].kind !== "sym")
+    return void 0;
+  const op = val.items[0].name;
+  if (op === "match" && val.items.length === 4) {
+    if (!nondetIsData(env, val.items[2]) || !nondetIsData(env, val.items[3])) return void 0;
+    return {
+      tag: "match",
+      space: val.items[1],
+      pattern: val.items[2],
+      template: val.items[3]
+    };
+  }
+  if (op === functor) {
+    const args = val.items.slice(1);
+    if (!args.every((x) => nondetIsData(env, x))) return void 0;
+    return { tag: "self", args };
+  }
+  return void 0;
+}
+function nondetUnwrap(env, functor, rhs) {
+  const goals = [];
+  let cur = rhs;
+  for (; ; ) {
+    if (cur.kind !== "expr" || cur.items.length === 0 || cur.items[0].kind !== "sym") break;
+    const op = cur.items[0].name;
+    if (op === "let*" && cur.items.length === 3 && cur.items[1].kind === "expr") {
+      for (const pv of cur.items[1].items) {
+        if (pv.kind !== "expr" || pv.items.length !== 2) return void 0;
+        if (!nondetIsData(env, pv.items[0])) return void 0;
+        const call = nondetCall(env, functor, pv.items[1]);
+        if (call === void 0) return void 0;
+        goals.push({ pat: pv.items[0], call });
+      }
+      cur = cur.items[2];
+      continue;
+    }
+    if (op === "let" && cur.items.length === 4) {
+      if (!nondetIsData(env, cur.items[1])) return void 0;
+      const call = nondetCall(env, functor, cur.items[2]);
+      if (call === void 0) return void 0;
+      goals.push({ pat: cur.items[1], call });
+      cur = cur.items[3];
+      continue;
+    }
+    break;
+  }
+  const tailCall = nondetCall(env, functor, cur);
+  if (tailCall !== void 0) return { goals, tail: tailCall };
+  if (!nondetIsData(env, cur)) return void 0;
+  return { goals, tail: { tag: "tpl", atom: cur } };
+}
+function compileNondet(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;
+  let hasCalls = false;
+  for (const [lhs, rhs] of eqs) {
+    if (lhs.kind !== "expr" || lhs.items.length === 0) return void 0;
+    const h = lhs.items[0];
+    if (h.kind !== "sym" || h.name !== functor) return void 0;
+    const a = lhs.items.length - 1;
+    if (arity === void 0) arity = a;
+    else if (a !== arity) return void 0;
+    if (!lhs.items.slice(1).every((x) => nondetIsData(env, x))) return void 0;
+    const un = nondetUnwrap(env, functor, rhs);
+    if (un === void 0) return void 0;
+    if (un.goals.length > 0 || un.tail.tag !== "tpl") hasCalls = true;
+    clauses.push({ lhs, goals: un.goals, tail: un.tail });
+  }
+  if (arity === void 0 || !hasCalls) return void 0;
+  const clauseCount = clauses.length;
+  const run = (envR, partAtoms, st, ops) => {
+    const matchSolutions = ops.matchSolutions;
+    if (matchSolutions === void 0) return void 0;
+    const ctr = { c: st.counter };
+    let dispatches = 0;
+    const world = st.world;
+    const walk = (b, a) => {
+      let v = a;
+      let hops = 0;
+      while (v.kind === "var") {
+        const next = lookupVal(b, v.name);
+        if (next === void 0) return v;
+        v = next;
+        if (++hops > 1e4) throw BAIL;
+      }
+      return v;
+    };
+    const walkStar = (b, a) => {
+      const v = walk(b, a);
+      if (v.ground || v.kind !== "expr") return v;
+      const its = v.items;
+      let items = null;
+      for (let i = 0; i < its.length; i++) {
+        const it = its[i];
+        const r = walkStar(b, it);
+        if (items !== null) items.push(r);
+        else if (r !== it) {
+          items = its.slice(0, i);
+          items.push(r);
+        }
+      }
+      return items === null ? v : expr(items);
+    };
+    const resolve = (b, a, suffix) => walkStar(b, instantiate(b, a, suffix));
+    const runMatch = (b, suffix, call) => {
+      const m = matchSolutions(
+        envR,
+        { counter: ctr.c, world },
+        resolve(b, call.space, suffix),
+        resolve(b, call.pattern, suffix),
+        resolve(b, call.template, suffix)
+      );
+      if (m === void 0) throw BAIL;
+      ctr.c += m.counterDelta;
+      return m.pairs;
+    };
+    const solve = (clause, gi, b, suffix, out) => {
+      if (gi === clause.goals.length) {
+        if (clause.tail.tag === "tpl") {
+          out.push([resolve(b, clause.tail.atom, suffix), b]);
+          return;
+        }
+        const pairs2 = clause.tail.tag === "match" ? runMatch(b, suffix, clause.tail) : runCall(clause.tail.args.map((x) => resolve(b, x, suffix)));
+        for (const [atom, vb] of pairs2)
+          for (const mm of merge(b, vb)) if (!hasLoop(mm)) out.push([atom, mm]);
+        return;
+      }
+      const goal = clause.goals[gi];
+      const pat = resolve(b, goal.pat, suffix);
+      const pairs = goal.call.tag === "match" ? runMatch(b, suffix, goal.call) : runCall(goal.call.args.map((x) => resolve(b, x, suffix)));
+      for (const [atom, vb] of pairs)
+        for (const withVal of merge(b, vb)) {
+          if (hasLoop(withVal)) continue;
+          for (const pm of matchAtoms(pat, atom))
+            for (const mm of merge(withVal, pm))
+              if (!hasLoop(mm)) solve(clause, gi + 1, mm, suffix, out);
+        }
+    };
+    const runCall = (args) => {
+      if (++dispatches > NONDET_CALL_CAP) throw BAIL;
+      const app = expr([sym(functor), ...args]);
+      const out = [];
+      for (const clause of clauses) {
+        const suffix = "#" + ctr.c;
+        ctr.c += 1;
+        for (const b0 of matchAtomsScoped(clause.lhs, app, suffix))
+          if (!hasLoop(b0)) solve(clause, 0, b0, suffix, out);
+      }
+      return out;
+    };
+    try {
+      const top = runCall(partAtoms);
+      const results = top.map(([atom, bnd]) => ({ atom, bnd }));
+      return { results, counterDelta: ctr.c - st.counter };
+    } catch (e) {
+      if (e === BAIL || e instanceof RangeError) return void 0;
+      throw e;
+    }
+  };
+  return { kind: "nondet", arity, clauseCount, run };
+}
 var IMP_GROUNDED = /* @__PURE__ */ new Set(["==", "<", ">", "<=", ">=", "+", "-", "*", "%"]);
-var DATA_DENY = /* @__PURE__ */ new Set([...KNOWN_OPS, "let*", "add-atom"]);
+var DATA_DENY_CACHE;
+function dataDeny() {
+  DATA_DENY_CACHE ??= /* @__PURE__ */ new Set([...KNOWN_OPS, ...IMPURE_OPS, "let*", "add-atom"]);
+  return DATA_DENY_CACHE;
+}
+var EMPTY_VALUE = sym("Empty");
 var addCounter = (st, n) => n === 0 ? st : { counter: st.counter + n, world: st.world };
 var impBail = () => BAIL;
 function impMeta(parts) {
@@ -2750,8 +3057,37 @@ function impMeta(parts) {
 function impConst(atom) {
   return { node: (_slots, st) => ({ value: atom, st }), directEffect: false, callees: /* @__PURE__ */ new Set() };
 }
+function impAssembleExpr(parts) {
+  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 impEvalArgs(parts, slots, st, ops) {
+  const vals = [];
+  let cur = st;
+  let empty = false;
+  for (const part of parts) {
+    const r = part.node(slots, cur, ops);
+    if (r === BAIL) return BAIL;
+    if (r.value === EMPTY_VALUE) empty = true;
+    vals.push(r.value);
+    cur = r.st;
+  }
+  return { vals, st: cur, empty };
+}
 function isDataSymbol(env, name) {
-  return !DATA_DENY.has(name) && !env.ruleIndex.has(name) && !env.gt.has(name);
+  return !dataDeny().has(name) && !env.ruleIndex.has(name) && !env.gt.has(name);
 }
 function compileImpStaticAtom(env, a, scope) {
   if (a.kind === "var") {
@@ -2771,21 +3107,7 @@ function compileImpStaticAtom(env, a, scope) {
   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)
-  };
+  return impAssembleExpr(items);
 }
 function compileImpGrounded(env, op, args, scope, holders) {
   if (env.ruleIndex.has(op)) return void 0;
@@ -2794,22 +3116,73 @@ function compileImpGrounded(env, op, args, scope, holders) {
   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;
+      const r = impEvalArgs(compiled, slots, st, ops);
+      if (r === BAIL) return BAIL;
+      if (r.empty) return { value: EMPTY_VALUE, st: r.st };
+      const gr = callGrounded(env.gt, op, r.vals);
+      return gr.tag === "ok" && gr.results.length === 1 ? { value: gr.results[0], st: r.st } : BAIL;
     },
     ...impMeta(compiled)
   };
 }
+function impMatchInsideOnce(a) {
+  if (a.kind !== "expr" || a.items.length !== 2) return void 0;
+  const h = a.items[0];
+  if (h.kind !== "sym" || h.name !== "once") return void 0;
+  const inner = a.items[1];
+  if (inner.kind !== "expr" || inner.items.length !== 4) return void 0;
+  const ih = inner.items[0];
+  return ih.kind === "sym" && ih.name === "match" ? inner : void 0;
+}
+function impEmptyCollapseMatch(a) {
+  if (a.kind !== "expr" || a.items.length !== 3) return void 0;
+  const h = a.items[0];
+  if (h.kind !== "sym" || h.name !== "==") return void 0;
+  const fromCollapse = (x) => {
+    if (x.kind !== "expr" || x.items.length !== 2) return void 0;
+    const ch = x.items[0];
+    return ch.kind === "sym" && ch.name === "collapse" ? impMatchInsideOnce(x.items[1]) : void 0;
+  };
+  if (atomEq(a.items[1], emptyExpr)) return fromCollapse(a.items[2]);
+  if (atomEq(a.items[2], emptyExpr)) return fromCollapse(a.items[1]);
+  return void 0;
+}
+function compileImpAddIfAbsent(env, args, scope) {
+  const match = impEmptyCollapseMatch(args[0]);
+  if (match === void 0) return void 0;
+  const add = args[1];
+  const otherwise = args[2];
+  if (add.kind !== "expr" || add.items.length !== 3) return void 0;
+  const addHead = add.items[0];
+  if (addHead.kind !== "sym" || addHead.name !== "add-atom") return void 0;
+  if (otherwise.kind !== "expr" || otherwise.items.length !== 1) return void 0;
+  const oh = otherwise.items[0];
+  if (oh.kind !== "sym" || oh.name !== "empty") return void 0;
+  if (!atomEq(match.items[1], add.items[1]) || !atomEq(match.items[2], match.items[3]) || !atomEq(match.items[2], add.items[2]))
+    return void 0;
+  const space = compileImpStaticAtom(env, add.items[1], scope);
+  const atom = compileImpStaticAtom(env, add.items[2], scope);
+  if (space === void 0 || atom === void 0) return void 0;
+  return {
+    node: (slots, st, ops) => {
+      const addIfAbsent = ops.addIfAbsent;
+      if (addIfAbsent === void 0) return BAIL;
+      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 r = addIfAbsent(env, a.st, s.value, a.value);
+      if (r === void 0) return BAIL;
+      return { value: r.added ? emptyExpr : EMPTY_VALUE, st: r.state };
+    },
+    directEffect: true,
+    callees: /* @__PURE__ */ new Set()
+  };
+}
 function compileImpIf(env, args, scope, holders) {
   if (args.length !== 3 || (env.ruleIndex.get("if")?.length ?? 0) !== 2) return void 0;
+  const addIfAbsent = compileImpAddIfAbsent(env, args, scope);
+  if (addIfAbsent !== void 0) return addIfAbsent;
   const cond = compileImpAtom(env, args[0], scope, holders);
   const then_ = compileImpAtom(env, args[1], scope, holders);
   const els = compileImpAtom(env, args[2], scope, holders);
@@ -2818,6 +3191,7 @@ function compileImpIf(env, args, scope, holders) {
     node: (slots, st, ops, discard) => {
       const c = cond.node(slots, st, ops);
       if (c === BAIL) return BAIL;
+      if (c.value === EMPTY_VALUE) return { value: EMPTY_VALUE, st: c.st };
       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);
@@ -2841,6 +3215,7 @@ function compileImpLet(env, args, scope, holders) {
     node: (slots, st, ops, discard) => {
       const v = value.node(slots, st, ops);
       if (v === BAIL) return BAIL;
+      if (v.value === EMPTY_VALUE) return { value: EMPTY_VALUE, st: v.st };
       const local = slots.slice();
       local[slot] = v.value;
       return body.node(local, addCounter(v.st, 1), ops, discard);
@@ -2875,6 +3250,7 @@ function compileImpLetStar(env, args, scope, holders) {
       for (const binding of bindings) {
         const v = binding.value.node(local, cur, ops);
         if (v === BAIL) return BAIL;
+        if (v.value === EMPTY_VALUE) return { value: EMPTY_VALUE, st: v.st };
         local[binding.slot] = v.value;
         cur = addCounter(addCounter(v.st, 1), 1);
       }
@@ -2904,6 +3280,72 @@ function compileImpAddAtom(env, args, scope) {
     callees: /* @__PURE__ */ new Set()
   };
 }
+function compileImpPatternAtom(a, scope) {
+  if (a.kind === "var") {
+    const slot = scope.vars.get(a.name);
+    if (slot === void 0) return impConst(a);
+    return {
+      node: (slots, st) => ({ value: slots[slot], st }),
+      directEffect: false,
+      callees: /* @__PURE__ */ new Set()
+    };
+  }
+  if (a.kind !== "expr" || a.items.length === 0) return impConst(a);
+  return impAssembleExpr(a.items.map((it) => compileImpPatternAtom(it, scope)));
+}
+function compileImpCaseMatch(env, args, scope, holders) {
+  if (args.length !== 2 || (env.ruleIndex.get("case")?.length ?? 0) !== 1) return void 0;
+  const scrut = args[0];
+  if (scrut.kind !== "expr" || scrut.items.length !== 4) return void 0;
+  const sh = scrut.items[0];
+  if (sh.kind !== "sym" || sh.name !== "match") return void 0;
+  const pairs = args[1];
+  if (pairs.kind !== "expr" || pairs.items.length !== 1) return void 0;
+  const branch = pairs.items[0];
+  if (branch.kind !== "expr" || branch.items.length !== 2 || branch.items[0].kind !== "var")
+    return void 0;
+  const space = compileImpStaticAtom(env, scrut.items[1], scope);
+  if (space === void 0) return void 0;
+  const pattern = compileImpPatternAtom(scrut.items[2], scope);
+  const template = compileImpPatternAtom(scrut.items[3], scope);
+  const slot = scope.len;
+  const branchScope = {
+    vars: new Map(scope.vars).set(branch.items[0].name, slot),
+    len: slot + 1
+  };
+  const body = compileImpAtom(env, branch.items[1], branchScope, holders);
+  if (body === void 0) return void 0;
+  return {
+    node: (slots, st, ops, discard) => {
+      const matchSolutions = ops.matchSolutions;
+      if (matchSolutions === void 0) return BAIL;
+      const s = space.node(slots, st, ops);
+      if (s === BAIL) return BAIL;
+      const p = pattern.node(slots, s.st, ops);
+      if (p === BAIL) return BAIL;
+      const t = template.node(slots, p.st, ops);
+      if (t === BAIL) return BAIL;
+      const m = matchSolutions(env, t.st, s.value, p.value, t.value);
+      if (m === void 0) return BAIL;
+      let cur = addCounter(t.st, m.counterDelta);
+      const local = slots.slice();
+      let survived;
+      for (const [value] of m.pairs) {
+        local[slot] = value;
+        const r = body.node(local, cur, ops, discard);
+        if (r === BAIL) return BAIL;
+        cur = r.st;
+        if (r.value !== EMPTY_VALUE) {
+          if (survived !== void 0) return BAIL;
+          survived = r.value;
+        }
+      }
+      return { value: survived ?? EMPTY_VALUE, st: cur };
+    },
+    directEffect: true,
+    callees: body.callees
+  };
+}
 function compileImpCall(env, op, args, scope, holders) {
   const h = holders.get(op);
   if (h === void 0 || args.length !== h.arity) return void 0;
@@ -2913,15 +3355,10 @@ function compileImpCall(env, op, args, scope, holders) {
   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);
+      const r = impEvalArgs(parts, slots, st, ops);
+      if (r === BAIL) return BAIL;
+      if (r.empty) return { value: EMPTY_VALUE, st: r.st };
+      return h.run(r.vals, r.st, ops, discard);
     },
     directEffect: meta.directEffect,
     callees: /* @__PURE__ */ new Set([...meta.callees, op])
@@ -2943,12 +3380,15 @@ function compileImpTuple(env, items, scope, holders) {
         return { value: emptyExpr, st: cur };
       }
       const out = [];
+      let empty = false;
       for (const part of compiled) {
         const r = part.node(slots, cur, ops);
         if (r === BAIL) return BAIL;
+        if (r.value === EMPTY_VALUE) empty = true;
         out.push(r.value);
         cur = r.st;
       }
+      if (empty) return { value: EMPTY_VALUE, st: cur };
       return { value: expr(out), st: cur };
     },
     ...impMeta(compiled)
@@ -2967,6 +3407,7 @@ function compileImpAtom(env, a, 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 (op === "case") return compileImpCaseMatch(env, args, scope, holders);
   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;
@@ -3112,6 +3553,11 @@ function compileEnv(env) {
         if (symbolic !== void 0) compiled.set(f, symbolic);
       }
       compileImperative(env, compiled);
+      for (const f of env.ruleIndex.keys()) {
+        if (compiled.has(f)) continue;
+        const nondet = compileNondet(env, f);
+        if (nondet !== void 0) compiled.set(f, nondet);
+      }
       return compiled;
     }
   }
@@ -3121,10 +3567,16 @@ function runCompiled(env, op, partAtoms, st, ops, discard) {
   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 === "nondet") {
+    if (ops === void 0) return void 0;
+    return h.run(env, partAtoms, st, ops);
+  }
   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 };
+    if (r === BAIL) return void 0;
+    if (r.value === EMPTY_VALUE) return { results: [], counterDelta: 0, state: r.st };
+    return { results: [{ atom: r.value, bnd: emptyBindings }], counterDelta: 0, state: r.st };
   }
   const vals = [];
   for (const a of partAtoms) {
@@ -4093,7 +4545,7 @@ function* matchCandidates(env, w, pInst) {
   }
   cands.push(...env.varHeadedFacts);
   if (pInst.ground && logNonGround(w.selfExtra) === 0 && (w.flatSelfExtra?.nonGroundCount ?? 0) === 0 && w.store.size === 0) {
-    const c = idxCount(logGroundIdx(w.selfExtra), pInst);
+    const c = w.selfExtra === null ? 0 : idxCount(logGroundIdx(w.selfExtra), pInst);
     for (const atom of cands) yield atom;
     const flatCount = w.flatSelfExtra?.exactCount(pInst) ?? 0;
     for (let i = 0; i < c + flatCount; i++) yield pInst;
@@ -4730,8 +5182,9 @@ function appendSpace(env, w0, name, atoms) {
     if (env.useFlatAtomspace === true) {
       if (flatSelfExtra !== void 0 || logSize(selfExtra) === 0) {
         const base = flatSelfExtra ?? FlatAtomSpace.empty();
-        if (atoms.every(canCompactAtom)) {
-          flatSelfExtra = base.appendAll(atoms);
+        const appended = base.appendAll(atoms);
+        if (appended !== void 0) {
+          flatSelfExtra = appended;
         } else {
           selfExtra = logFromArray([...base.toArray(), ...logToArray(selfExtra), ...atoms]);
           flatSelfExtra = void 0;
@@ -4788,7 +5241,52 @@ function compiledAddAtom(env, st, space, added) {
   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 compiledMatchSolutions(env, st, space, pattern, template) {
+  const { getCandidates, patterns } = matchSetup(env, st, space, pattern, emptyBindings);
+  if (patterns.length !== 1) return void 0;
+  const pat = patterns[0];
+  const { endState } = matchSingleEndState(env, getCandidates, pat, template, st, emptyBindings);
+  const pairs = [];
+  for (const m of matchSingleSolutions(env, getCandidates, pat, st, emptyBindings))
+    pairs.push([inst(env, m, template), m]);
+  return { pairs, counterDelta: endState.counter - st.counter };
+}
+function compiledAddIfAbsent(env, st, space, atom) {
+  if (!atom.ground || opOf(atom) === "=") return void 0;
+  const w = st.world;
+  if (w.store.size !== 0) return void 0;
+  const name = spaceName(w, space);
+  if (name === void 0) return void 0;
+  if (name === "&self") {
+    const k = headKey(atom);
+    if (k === void 0) return void 0;
+    if (env.varHeadedFacts.length !== 0 || (env.factIndex.get(k)?.length ?? 0) !== 0)
+      return void 0;
+    if (logNonGround(w.selfExtra) !== 0 || (w.flatSelfExtra?.nonGroundCount ?? 0) !== 0)
+      return void 0;
+    const size2 = logSize(w.selfExtra) + (w.flatSelfExtra?.size ?? 0);
+    const checked2 = { counter: st.counter + size2, world: w };
+    const present = idxCount(logGroundIdx(w.selfExtra), atom) + (w.flatSelfExtra?.exactCount(atom) ?? 0);
+    if (present !== 0) return { added: false, state: checked2 };
+    return {
+      added: true,
+      state: { counter: checked2.counter, world: appendSpace(env, w, "&self", [atom]) }
+    };
+  }
+  const log = w.spaces.get(name) ?? emptyLog;
+  if (logNonGround(log) !== 0) return void 0;
+  const checked = { counter: st.counter + logSize(log), world: w };
+  if (idxCount(logGroundIdx(log), atom) !== 0) return { added: false, state: checked };
+  return {
+    added: true,
+    state: { counter: checked.counter, world: appendSpace(env, w, name, [atom]) }
+  };
+}
+var COMPILED_IMPURE_OPS = {
+  addAtom: compiledAddAtom,
+  matchSolutions: compiledMatchSolutions,
+  addIfAbsent: compiledAddIfAbsent
+};
 function* getTypeOpG(env, fuel, st, prev, xi, b) {
   const emit = function* (st0) {
     let acc = [];
@@ -5535,7 +6033,7 @@ function tryCountAggregate(env, st, bnd, match) {
   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) {
+  if ((sn === void 0 || sn === "&self") && w.store.size === 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) {
@@ -5545,6 +6043,11 @@ function tryCountAggregate(env, st, bnd, match) {
         if (unifies(p.atom)) count2 += 1;
       }
     }
+    if (w.flatSelfExtra !== void 0) {
+      const flat = w.flatSelfExtra.countHeadArity(k, arity);
+      count2 += flat.count;
+      iterated2 += flat.iterated;
+    }
     return { count: count2, iterated: iterated2 };
   }
   const source = getCandidates(pat);
@@ -5822,7 +6325,7 @@ function* mettaEvalG(env, fuel, st, bnd, a) {
           out.push([errFound, partB]);
           continue;
         }
-        const wApp = makeExpr(env, [sym(op), ...partAtoms]);
+        const wApp = partAtoms.every((p, i) => p === args[i]) ? lw : 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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metta-ts/core",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",