Fix package READMEs: dedupe, absolute links, prose, experimental pointers

- browser: the whole second half was a verbatim duplicate (a second copy of the
  source-runners block and the Host Interop section); delete it.
- hyperon, das-client: relative `../pkg` links resolve wrong on npmjs.com;
  use the absolute GitHub URLs the other READMEs use.
- edsl, das-client: rewrite the "Bold label. Explanation" list items as plain
  sentences.
- core, hyperon: add a one-line pointer to the experimental streaming
  grounded-operation protocol, which was invisible from these pages.

Author: MesTTo

packages/browser/README.md

@@ -74,53 +74,6 @@ 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/MeTTa-TS/blob/main/LICENSE).

packages/core/README.md

@@ -28,6 +28,8 @@ for (const { query, results: rs } of results) {
 
 `runProgram` parses the source, adds every non-bang atom to the knowledge base, evaluates each `!`-query, and returns one result group per query. For a higher-level class API modeled on Python's `hyperon`, see [`@metta-ts/hyperon`](https://github.com/MesTTo/MeTTa-TS/tree/main/packages/hyperon).
 
+The experimental line adds a pull-based streaming grounded-operation protocol on the `experimental` npm tag; see [Experimental features](https://mestto.github.io/MeTTa-TS/guide/experimental).
+
 ## License
 
 [MIT](https://github.com/MesTTo/MeTTa-TS/blob/main/LICENSE).

packages/das-client/README.md

@@ -1,6 +1,6 @@
 # @metta-ts/das-client
 
-A client for SingularityNET's Distributed AtomSpace (DAS). It lets a MeTTa TS program query a remote, shared atomspace over gRPC, and it presents that DAS as a `Space` backend, so a DAS drops in wherever an in-memory space would. It is Node-only, because a participant hosts an inbound bus node; from the browser you reach a DAS through [`@metta-ts/das-gateway`](../das-gateway).
+A client for SingularityNET's Distributed AtomSpace (DAS). It lets a MeTTa TS program query a remote, shared atomspace over gRPC, and it presents that DAS as a `Space` backend, so a DAS drops in wherever an in-memory space would. It is Node-only, because a participant hosts an inbound bus node; from the browser you reach a DAS through [`@metta-ts/das-gateway`](https://github.com/MesTTo/MeTTa-TS/tree/main/packages/das-gateway).
 
 ## Install
 
@@ -43,8 +43,8 @@ DAS_LIVE=1 pnpm vitest run packages/das-client/src/live-query.test.ts
 
 Two things to know:
 
-- **Query leaves are bare Symbols, not quoted strings.** `animals.metta` stores `is_animal`, `human`, etc. as Symbols, so build the pattern with `sym("is_animal")`, not `gstr("is_animal")` / `sym('"is_animal"')`. (An older das quoted string literals; that is gone.)
-- **Linux only: pin MongoDB to 7.0.** On Linux kernels >= 6.19, das-cli's default `mongodb-community-server:8.x` refuses to start (`ERROR: ... tcmalloc ... known issue with the v6.19 and newer Linux kernel`). Set `MONGODB_IMAGE_NAME = "mongo"` and `MONGODB_IMAGE_VERSION = "7.0"` in das-cli's `settings/config.py` so `db start` succeeds. Other platforms (and older kernels) run the 8.x default fine.
+- Query leaves are bare Symbols, not quoted strings. `animals.metta` stores `is_animal`, `human`, etc. as Symbols, so build the pattern with `sym("is_animal")`, not `gstr("is_animal")` / `sym('"is_animal"')`. (An older das quoted string literals; that is gone.)
+- On Linux with kernel >= 6.19, pin MongoDB to 7.0: das-cli's default `mongodb-community-server:8.x` refuses to start (`ERROR: ... tcmalloc ... known issue with the v6.19 and newer Linux kernel`). Set `MONGODB_IMAGE_NAME = "mongo"` and `MONGODB_IMAGE_VERSION = "7.0"` in das-cli's `settings/config.py` so `db start` succeeds. Other platforms (and older kernels) run the 8.x default fine.
 
 A pattern with a variable then returns the matched bindings:
 

packages/edsl/README.md

@@ -42,17 +42,17 @@ factorial(6); // 720
 
 ## The two term surfaces
 
-- **Proxies + combinators.** `names()` and `vars()` mint names and variables (`const { parent, x } = ...`), and the capitalized combinators build the special forms: `If`, `Case`, `Let`, `LetStar`, `Match`, `Superpose`, `Collapse`, `Empty`, `Unify`, `Sealed`, `Quote`. Lowercase builders cover the grounded ops: `add`/`sub`/`mul`/`div`/`mod`, `eq`/`gt`/`lt`/`ge`/`le`, `and`/`or`/`not`, `carAtom`/`cdrAtom`/`consAtom`/`deconsAtom`, and `list`/`nil`/`e`. Builders compose, so nested patterns and repeated variables are just nested calls.
-- **The tagged template ``m`...` `` (and `mAll` for several atoms)** runs the real parser, so it expresses every MeTTa form, and `${value}` auto-grounds, which is the easiest way to drop a TS object in.
+- `names()` and `vars()` mint names and variables (`const { parent, x } = ...`), and the capitalized combinators build the special forms: `If`, `Case`, `Let`, `LetStar`, `Match`, `Superpose`, `Collapse`, `Empty`, `Unify`, `Sealed`, `Quote`. Lowercase builders cover the grounded ops: `add`/`sub`/`mul`/`div`/`mod`, `eq`/`gt`/`lt`/`ge`/`le`, `and`/`or`/`not`, `carAtom`/`cdrAtom`/`consAtom`/`deconsAtom`, and `list`/`nil`/`e`. Builders compose, so nested patterns and repeated variables are just nested calls.
+- The tagged template ``m`...` `` (and `mAll` for several atoms) runs the real parser, so it expresses every MeTTa form, and `${value}` auto-grounds, which is the easiest way to drop a TS object in.
 
 ## The runner and the host bridge
 
 `mettaDB()` keeps MeTTa's two query mechanisms distinct: `query(pattern)` does `match &self` over stored atoms and returns binding rows (keys inferred from the pattern, or typed by an explicit `vars` map); `eval(atom)` (and `evalJs`, `evalAsync`, `evalJsAsync`) rewrites with the `=` rules and returns the nondeterministic results.
 
 The host bridge runs both directions:
 
-- **TypeScript into MeTTa (grounded functions).** `db.fn("name", fn)` registers a plain typed function with arguments auto-unwrapped to JS and the result auto-grounded; `db.fns({ ... })` registers several at once keyed by name; `db.asyncFn` awaits an async function. The raw `db.op`/`db.asyncOp` stay for full atom control (multiple results, custom matching).
-- **MeTTa into TypeScript (backward import).** `db.call.<name>(...)` builds and evaluates `(<name> ...args)` and returns every result unwrapped to JS; use bracket access for hyphenated names (`db.call["is-even"](4)`). `db.import("name")` returns a callable.
+- Grounded functions bridge TypeScript into MeTTa. `db.fn("name", fn)` registers a plain typed function with arguments auto-unwrapped to JS and the result auto-grounded; `db.fns({ ... })` registers several at once keyed by name; `db.asyncFn` awaits an async function. The raw `db.op`/`db.asyncOp` stay for full atom control (multiple results, custom matching).
+- A backward import bridges MeTTa into TypeScript. `db.call.<name>(...)` builds and evaluates `(<name> ...args)` and returns every result unwrapped to JS; use bracket access for hyphenated names (`db.call["is-even"](4)`). `db.import("name")` returns a callable.
 
 ### Typing the host bridge
 

packages/hyperon/README.md

@@ -2,7 +2,7 @@
 
 A TypeScript class API for MeTTa atoms, spaces, and a runner, modeled on Hyperon's `hyperon.atoms`
 and `hyperon.base`. Where the Python package wraps a Rust core over FFI, this one wraps the immutable
-terms of [`@metta-ts/core`](../core) in classes. It runs anywhere TypeScript runs, with no native
+terms of [`@metta-ts/core`](https://github.com/MesTTo/MeTTa-TS/tree/main/packages/core) in classes. It runs anywhere TypeScript runs, with no native
 addon and no WASM.
 
 Hyperon's Python method names are kept as aliases next to the idiomatic TypeScript ones, so code
@@ -60,7 +60,7 @@ sp.subst(E(S("parent"), S("tom"), V("c")), V("c"))
   .map((a) => a.toString());       // ["bob", "liz"]
 ```
 
-For a Distributed AtomSpace backend, see [`@metta-ts/das-client`](../das-client), whose `DasLiveSpace`
+For a Distributed AtomSpace backend, see [`@metta-ts/das-client`](https://github.com/MesTTo/MeTTa-TS/tree/main/packages/das-client), whose `DasLiveSpace`
 is the async analogue (a remote query is a network round-trip).
 
 ## Running MeTTa
@@ -94,6 +94,8 @@ m.run("!(double 21)")[0].map((a) => a.toString()); // ["42"]
 `registerToken(regex, constr)` registers a custom token, `space()` exposes the knowledge base, and
 `getAtomTypes(atom)` returns the types the runner infers for an atom.
 
+An experimental pull-based variant, `registerStreamingOperation` (and its async twin), yields answers one at a time so a consumer such as `once` stops the producer rather than draining it. It ships on the `experimental` npm tag; see [Experimental features](https://mestto.github.io/MeTTa-TS/guide/experimental).
+
 The runner's `space()` is live: an atom added through it reaches the evaluator
 exactly as a non-bang atom in `run` does, querying it sees what the evaluator sees, and removing an
 atom retracts it from evaluation.