MeTTa TS 1.1.2

Author: MesTTo

README.md

@@ -282,23 +282,23 @@ The pure-MeTTa path stays TypeScript throughout, with no escape to native code.
 
 ### Head-to-head with PeTTa
 
-A reproducible benchmark ([`packages/node/bench/corpus-bench.mjs`](packages/node/bench/corpus-bench.mjs)) runs the PeTTa example corpus through both engines as subprocesses and checks each program's embedded `(test …)` assertions. On the Hyperon-faithful subset (host-FFI examples and PeTTa-only execution-model examples are excluded, with the reason recorded for each), MeTTa TS passes 97 of the shared programs and is **faster than PeTTa on all 97**, median ~2x, on SWI-Prolog's GMP-backed integers, from pure TypeScript.
+A reproducible benchmark ([`packages/node/bench/corpus-bench.mjs`](packages/node/bench/corpus-bench.mjs)) runs the PeTTa example corpus through both engines as subprocesses and checks each program's embedded `(test …)` assertions. On the Hyperon-faithful subset (host-FFI examples and PeTTa-only execution-model examples are excluded, with the reason recorded for each), MeTTa TS passes 98 of the shared programs and is **faster than PeTTa on all 98**, median 1.82x and geomean 1.85x, on SWI-Prolog's GMP-backed integers, from pure TypeScript. Both-pass totals are PeTTa 28.8s and MeTTa TS 15.9s.
 
 A representative slice (wall-clock, subprocess including startup; `speedup` = PeTTa / MeTTa TS):
 
 | Program            |   PeTTa | MeTTa TS |  Speedup |
 | ------------------ | ------: | -------: | -------: |
-| `peano`            | 1692 ms |   220 ms | **7.7×** |
-| `fib`              |  456 ms |    79 ms | **5.8×** |
-| `fibadd`           |  459 ms |    84 ms | **5.5×** |
-| `peanofast`        |  520 ms |   112 ms | **4.6×** |
-| `tilepuzzle`       | 1554 ms |   402 ms | **3.9×** |
-| `he_minimalmetta`  | 1807 ms |   484 ms |     3.7× |
-| `matespacefast`    | 4258 ms |  1890 ms |     2.3× |
-| `factorial`        |  166 ms |    76 ms |     2.2× |
-| `permutations`     |  889 ms |   451 ms |     2.0× |
-| `nilbc`            |  713 ms |   399 ms | **1.8×** |
-| `hyperpose_primes` | 1100 ms |  1009 ms |     1.1× |
+| `peano`            | 1588 ms |   306 ms | **5.19×** |
+| `fib`              |  454 ms |    88 ms | **5.14×** |
+| `fibadd`           |  451 ms |   100 ms | **4.53×** |
+| `peanofast`        |  516 ms |   114 ms | **4.52×** |
+| `tilepuzzle`       | 1602 ms |   426 ms | **3.76×** |
+| `permutations`     |  867 ms |   483 ms |     1.80× |
+| `factorial`        |  160 ms |    91 ms |     1.76× |
+| `he_minimalmetta`  | 1825 ms |  1065 ms |     1.71× |
+| `matespacefast`    | 4348 ms |  3043 ms |     1.43× |
+| `nilbc`            |  761 ms |   709 ms |     1.07× |
+| `hyperpose_primes` | 1116 ms |  1062 ms |     1.05× |
 
 The full per-program table is in [`RESULTS-corpus.md`](packages/node/bench/RESULTS-corpus.md).
 
@@ -310,16 +310,16 @@ That speed comes from general engine work:
 - an O(1)-stack worklist for nondeterminism;
 - ground-atom type memoisation;
 - an exact-match ground-fact index;
-- automatic tabling of pure functions, including ones defined at runtime (via rule-set-versioned keys);
+- bounded automatic tabling of pure overlapping-recursive functions, with structural token keys and runtime rule-versioned entries;
 - a native-code compiler for the pure deterministic int/bool/tuple subset, with tail-recursion compiled to loops and PeTTa-style **higher-order specialisation** so a function passed as an argument (e.g. `iterate`'s `$step`) is bound and compiled rather than interpreted;
 - a compiler for **nondeterministic `let*`-chain functions** (the backward-chainer class): a multi-equation function whose clause bodies chain space matches and recursive calls compiles to a clause-major depth-first search, the same fragment PeTTa hands to Prolog's clause alternatives;
 - a compiler for **add-atom saturation loops**: the add-if-absent idiom becomes one exact-membership probe plus append, and a single-branch `case` over a space match becomes a snapshot-and-thread loop with Empty-pruned branches.
 
 Every one of these is verified against the 270-assertion Hyperon oracle and the LeaTTa differential; all are byte-identical except the nondeterministic compiler, whose results are alpha-equivalent (fresh variables get different gensym numbers, consistently renamed, deterministic run to run).
 
-The last holdouts fell in order. `permutations` is a 28-relation conjunctive `(length (collapse (match &self (, …) …)))`: MeTTa TS folds the worst-case-optimal join and counts each solution rather than materialising the ~360k answer atoms, which drops it from 3.6 s to 0.45 s, under PeTTa's 0.85 s. `hyperpose_primes` races `(once (hyperpose …))` across Node worker threads. `nilbc` is a dependently-typed backward chainer: compiling its clauses to a collect-all search with the interpreter's own unification takes it from 2.2 s to 0.40 s, under PeTTa's 0.71 s. `peano`, the final one, is an impure dedup-build loop: compiling its saturation step (a `case` over the space with add-if-absent branches) to membership probes on the exact-match index takes it from 2.7 s to 0.22 s, under PeTTa's 1.69 s. The remaining parity work (PLN/NARS library ports, PeTTa-only execution-model examples) is tracked in [`packages/node/bench/TODO-parity.md`](packages/node/bench/TODO-parity.md).
+The last holdouts fell in order. `permutations` is a 28-relation conjunctive `(length (collapse (match &self (, …) …)))`: MeTTa TS folds the worst-case-optimal join and counts each solution rather than materialising the ~360k answer atoms, which brings the current corpus run to 483 ms, under PeTTa's 867 ms. `hyperpose_primes` races `(once (hyperpose …))` across Node worker threads. `nilbc` is a dependently-typed backward chainer: compiling its clauses to a collect-all search with the interpreter's own unification brings the current run to 709 ms, just under PeTTa's 761 ms. `peano`, the final one, is an impure dedup-build loop: compiling its saturation step (a `case` over the space with add-if-absent branches) to membership probes on the exact-match index brings the current run to 306 ms, under PeTTa's 1588 ms. The remaining parity work (PLN/NARS library ports, PeTTa-only execution-model examples) is tracked in [`packages/node/bench/TODO-parity.md`](packages/node/bench/TODO-parity.md).
 
-`matespace`/`matespace2` are **PeTTa-specific** and excluded from the faithful subset. Their expected counts, 1063919 and 1297533, are produced only by PeTTa's compilation to Prolog: native backtracking over a globally-persistent atomspace, with duplicate adds pruned by failure, which is not minimal-MeTTa semantics. Run through `hyperon-experimental` itself, `(collapse (mate-space-demo K))` is empty, and LeaTTa agrees. PeTTa, real Hyperon, and MeTTa TS each compute a different result for the same program, so no Hyperon-faithful engine reproduces PeTTa's number. The faithful rewrite of the same workload is `matespacefast`, which uses deterministic tuple recursion instead of a `case`-driven non-deterministic build. MeTTa TS runs it about 2.0× faster than PeTTa, byte-identical.
+`matespace`/`matespace2` are **PeTTa-specific** and excluded from the faithful subset. Their expected counts, 1063919 and 1297533, are produced only by PeTTa's compilation to Prolog: native backtracking over a globally-persistent atomspace, with duplicate adds pruned by failure, which is not minimal-MeTTa semantics. Run through `hyperon-experimental` itself, `(collapse (mate-space-demo K))` is empty, and LeaTTa agrees. PeTTa, real Hyperon, and MeTTa TS each compute a different result for the same program, so no Hyperon-faithful engine reproduces PeTTa's number. The faithful rewrite of the same workload is `matespacefast`, which uses deterministic tuple recursion instead of a `case`-driven non-deterministic build. MeTTa TS runs it about 1.4× faster than PeTTa in the latest corpus run, byte-identical.
 
 ## Provenance
 

RELEASE_NOTES.md

@@ -1,4 +1,4 @@
-# MeTTa TS 1.1.1
+# MeTTa TS 1.1.2
 
 A pure-TypeScript implementation of [MeTTa](https://metta-lang.dev), the
 OpenCog Hyperon language. The core engine runs in the browser, Node, Deno, Bun,
@@ -10,19 +10,27 @@ asks for them.
 
 This release is prepared on Linux with Node 22 and pnpm 11. The release gate
 builds every package, typechecks the workspace, runs the full Vitest suite,
-builds the GitHub Pages documentation, runs the live Python, Pyodide,
-SWI-Prolog, and SWI-WASM adapter checks, and runs the benchmark suite before
-tagging.
-
-The Hyperon experimental conformance run is unchanged from the previous
-host-import slice. Core/ST reports 431 passed, 77 failed, 60 expected failures,
-and 0 skipped. Full/ST with `fileio,json,random` reports 470 passed, 174 failed,
-4 expected failures, and 26 skipped. The remaining gaps are the tracked
-parser/directive, kernel, typing, stdlib, feature, and concurrency divergences,
-so this release should not be described as full Hyperon conformance.
+builds the GitHub Pages documentation, runs the oracle checks, and runs the
+benchmark suite before tagging. Optional Python, Pyodide, SWI-Prolog, and
+SWI-WASM adapters are built and covered by their available tests, with live
+runtime checks depending on the host tools installed in the release
+environment.
+
+The current conformance rerun reports Core/ST at 431 passed, 77 failed, 60
+expected failures, and 0 skipped. Full/ST with `fileio,json,random` reports 470
+passed, 174 failed, 4 expected failures, and 26 skipped. The remaining gaps are
+the tracked parser/directive, kernel, typing, stdlib, feature, and concurrency
+divergences, so this release should not be described as full Hyperon
+conformance.
 
 ## What's new
 
+### Integrated host interop release train
+
+This release includes the full local host-interop train that followed 1.1.0:
+browser host adapters, Python and Prolog runtime splits, SWI-WASM, Pyodide,
+source runners, async effects, CLI checks, and the eDSL host builders.
+
 ### Browser Python and Prolog
 
 `@metta-ts/browser/host` composes optional host runtimes into the browser
@@ -92,6 +100,25 @@ pyCall("math.add", 40, 2); // (py-call (math.add 40 2))
 prologCall(["edge", "alice", x]); // (prolog-call (edge alice $x))
 ```
 
+### Bounded structural tabling
+
+Automatic tabling now uses structural token keys and a bounded table space
+instead of recursive printed-form keys. Pure overlapping-recursive calls can be
+memoized without table growth being unbounded:
+
+- completed pure entries are capped and LRU-evictable;
+- interner resets invalidate old opaque table keys;
+- runtime rules are version-keyed;
+- impure, meta, state, import, `match`, `collapse`, and concurrency paths stay
+  outside the table cache;
+- direct active variant recursion uses local-linear completion for finite answer
+  sets;
+- non-cyclic calls keep exact ordered-bag memoization.
+
+The stale-key path reported during release review is covered by a regression:
+old tail-call pending keys cannot write into a new interner generation after a
+table-space reset.
+
 ## Install
 
 ```bash

heatmap-example.png

@@ -74,6 +74,53 @@ await runner.dispose();
 See `examples/browser-interop` for a runnable smoke check and a bundle isolation
 check.
 
+For embedders that already resolved imports, `@metta-ts/browser/source` exposes source runners:
+
+```ts
+import { runSourceAsync } from "@metta-ts/browser/source";
+
+const results = await runSourceAsync(`
+  !(import! &self concurrency)
+  !(par (+ 1 1) (+ 2 2))
+`);
+```
+
+The async runner supports MeTTa's async forms (`par`, `race`, `with-mutex`) and uses Web Workers for
+`(once (hyperpose ...))` when the browser host provides them.
+
+## Host Interop
+
+`@metta-ts/browser/host` composes optional host runtimes such as Pyodide and
+SWI-Prolog WASM. The base browser package stays pure TypeScript. Import a host
+adapter only when the page needs it.
+
+```ts
+import { createBrowserRunner, createBrowserTextLoader } from "@metta-ts/browser/host";
+import { createPyodideInterop } from "@metta-ts/py/pyodide";
+import { createSwiWasmInterop } from "@metta-ts/prolog/swi-wasm";
+
+const files = new Map([
+  ["math.py", "def add(a, b):\n    return a + b\n"],
+  ["facts.pl", "edge(alice, bob).\n"],
+]);
+const loadText = createBrowserTextLoader({ files, baseUrl: import.meta.url });
+const py = await createPyodideInterop({ loadText });
+const prolog = await createSwiWasmInterop({ loadText });
+const runner = createBrowserRunner({ files, interops: [py, prolog] });
+
+const results = await runner.run(`
+  !(import! &self "math.py")
+  !(py-call (math.add 40 2))
+  !(import! &self "facts.pl")
+  !(prolog-call (edge alice $x))
+`);
+
+await runner.dispose();
+```
+
+See `examples/browser-interop` for a runnable smoke check and a bundle isolation
+check.
+
 ## License
 
 [MIT](https://github.com/MesTTo/Meta-TypeScript-Talk/blob/main/LICENSE).

heatmap-mapper.png

@@ -6,9 +6,9 @@ async hyperpose hook. Web Worker startup is covered by the LSP browser benchmark
 
 | benchmark | runs | min ms | median ms |
 |---|---:|---:|---:|
-| browser run VFS import | 21 | 0.87 | 1.54 |
-| browser runSourceAsync (+ 1 2) | 21 | 0.44 | 0.54 |
-| browser par 4x resolved async op | 21 | 0.49 | 0.59 |
-| browser race slow/fast async op | 13 | 0.49 | 0.60 |
-| browser with-mutex 4x awaited sections | 9 | 5.07 | 5.55 |
-| browser async hyperpose hook | 13 | 0.89 | 1.00 |
+| browser run VFS import | 21 | 0.61 | 1.11 |
+| browser runSourceAsync (+ 1 2) | 21 | 0.37 | 0.53 |
+| browser par 4x resolved async op | 21 | 0.55 | 0.77 |
+| browser race slow/fast async op | 13 | 0.45 | 0.53 |
+| browser with-mutex 4x awaited sections | 9 | 4.29 | 5.12 |
+| browser async hyperpose hook | 13 | 0.75 | 0.87 |

packages/browser/README.md

@@ -1,6 +1,6 @@
 {
   "name": "@metta-ts/browser",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",

packages/browser/bench/RESULTS-concurrency.md

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

packages/browser/package.json

@@ -0,0 +1,37 @@
+// SPDX-FileCopyrightText: 2026 MesTTo
+//
+// SPDX-License-Identifier: MIT
+
+import { describe, expect, it } from "vitest";
+import { format } from "./parser";
+import { runProgram } from "./runner";
+
+const results = (src: string): string[] =>
+  runProgram(src, 100_000, new Map(), { tabling: true })[0]!.results.map(format);
+
+describe("adaptive local-linear tabling", () => {
+  it("completes a finite direct left-recursive relation", () => {
+    const src = `
+      (= (edge a b) b)
+      (= (edge b c) c)
+      (= (edge c d) d)
+      (= (edge $x $y) (empty))
+      (= (path $x $z) (chain (path $x $y) $mid (path $mid $z)))
+      (= (path $x $y) (edge $x $y))
+      !(collapse (path a $z))
+    `;
+
+    expect(results(src)).toEqual(["(, b c d)"]);
+  });
+
+  it("keeps non-cyclic calls as exact ordered bags", () => {
+    const src = `
+      (= (choice $x) A)
+      (= (choice $x) A)
+      (= (choice $x) B)
+      !(collapse (choice $x))
+    `;
+
+    expect(results(src)).toEqual(["(, A A B)"]);
+  });
+});

packages/core/package.json

@@ -13,7 +13,8 @@ import { parseAll, format } from "./parser";
 import { pettaStdlibAtoms } from "./petta-stdlib";
 import { preludeAtoms, standardTokenizer } from "./runner";
 import { stdlibAtoms } from "./stdlib";
-import { analyzePurity } from "./tabling";
+import { analyzePurity, analyzeTableWorth, MODED_IMPURE_OPS } from "./tabling";
+import { TableSpace } from "./table-space";
 import { importsForBaseDir } from "./oracle-corpus";
 
 const ROUTE_ENV = "METTA_COLLAPSE_ROUTE";
@@ -36,8 +37,12 @@ afterEach(() => {
 function buildDefaultTestEnv(imports: Map<string, Atom[]>) {
   const env = buildEnv([...preludeAtoms(), ...stdlibAtoms(), ...pettaStdlibAtoms()], stdTable());
   env.imports = withBuiltinModules(imports);
-  env.table = new Map();
+  env.tableSpace = new TableSpace();
   env.pureFunctors = analyzePurity(env);
+  env.modedPureFunctors = analyzePurity(env, MODED_IMPURE_OPS);
+  env.tableWorth = analyzeTableWorth(env, env.pureFunctors);
+  env.modedTableWorth = analyzeTableWorth(env, env.modedPureFunctors);
+  env.tablingDirty = false;
   env.compiled = new Map();
   env.compileDirty = true;
   return env;