nedb-engine 2.2.28__tar.gz → 2.2.32__tar.gz

{nedb_engine-2.2.28 → nedb_engine-2.2.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedb-engine
-Version: 2.2.28
+Version: 2.2.32
 Summary: NEDB — a versioned, self-compressing, time-traveling embedded database (replay-protected, idempotent, relational, searchable) with durable AOF persistence and a server daemon (nedbd).
 Project-URL: Homepage, https://github.com/aiassistsecure/nedb
 Project-URL: Repository, https://github.com/aiassistsecure/nedb
@@ -29,8 +29,9 @@ Replay-protected · idempotent · relational · filterable · sortable · search
 One Rust core → ships to **PyPI** and **npm** from a single source.
 
 [![PyPI](https://img.shields.io/pypi/v/nedb-engine?label=PyPI&color=6366f1)](https://pypi.org/project/nedb-engine/)
+[![crates.io](https://img.shields.io/crates/v/nedb-engine?label=crates.io&color=f97316)](https://crates.io/crates/nedb-engine)
 [![npm](https://img.shields.io/npm/v/nedb-engine?label=npm&color=00d4ff)](https://www.npmjs.com/package/nedb-engine)
-[![Tests](https://img.shields.io/badge/tests-266%20passing-34d399)](https://github.com/aiassistsecure/nedb/actions)
+[![CI](https://img.shields.io/github/actions/workflow/status/Eth-Interchained/nedb/release.yml?label=CI&color=34d399)](https://github.com/Eth-Interchained/nedb/actions)
 [![nedb-engine-client PyPI](https://img.shields.io/pypi/v/nedb-engine-client?label=nedb-engine-client&color=34d399)](https://pypi.org/project/nedb-engine-client/)
 [![nedb-engine-client npm](https://img.shields.io/npm/v/nedb-engine-client?label=nedb-engine-client&color=34d399)](https://www.npmjs.com/package/nedb-engine-client)
 
@@ -40,11 +41,11 @@ One Rust core → ships to **PyPI** and **npm** from a single source.
 
 ---
 
-## NEDB v2.0.36 — Production Stable
+## NEDB v2.2.31 — Production Stable
 
-**Current stable: 2.0.36** — Cross-platform native wheels shipping `nedbd-v2` binary inside `pip install nedb-engine`. Linux + Windows wheels built on GitHub Actions; macOS arm64 + x86_64 wheels built on Codemagic (M2 Mac Minis). All four platforms publish from one `v*` tag.
+**Current stable: 2.2.31** — Cross-platform native wheels shipping `nedbd-v2` binary inside `pip install nedb-engine`. Linux + Windows wheels built on GitHub Actions; macOS arm64 + x86_64 wheels built on Codemagic (M2 Mac Minis). All four platforms publish from one `v*` tag.
 
-NEDB v2 replaces the append-only log (AOF) with a **content-addressed Merkle DAG**. Every document version is an immutable, BLAKE2b-verified object. Nothing is ever overwritten. As of **v2.0.36**, restarts after the first open are **O(1) warm starts** (driven by a `MANIFEST` of `seq` + Merkle head), the **cold scan is deferred** so the daemon accepts connections immediately, and a new **`GET /events` SSE endpoint** streams scan progress + per-write events live.
+NEDB v2 replaces the append-only log (AOF) with a **content-addressed Merkle DAG**. Every document version is an immutable, BLAKE2b-verified object. Nothing is ever overwritten. As of **v2.2.31**, restarts after the first open are **O(1) warm starts** (driven by a `MANIFEST` of `seq` + Merkle head), the **cold scan is deferred** so the daemon accepts connections immediately, and a new **`GET /events` SSE endpoint** streams scan progress + per-write events live.
 
 ```bash
 # Run the v2 DAG engine — ships inside pip install nedb-engine
@@ -53,9 +54,9 @@ nedbd --dag --data ./data
 NEDBD_DAG=1 NEDB_TMK=<32-byte-hex> nedbd --data ./data
 
 curl http://127.0.0.1:7070/health
-# {"ok":true,"version":"2.0.36","service":"nedbd","engine":"dag","startup_ready":true,"encrypted":true}
+# {"ok":true,"version":"2.2.31","service":"nedbd","engine":"dag","startup_ready":true,"encrypted":true}
 
-# Tail the live event stream (new in v2.0.36)
+# Tail the live event stream (new in v2.2.31)
 curl http://127.0.0.1:7070/events
 # event: scan   data: {"objects":730000,"of":1310703,"rate":21043,"eta_s":28}
 # event: ready  data: {"seq":1310703,"head":"b2:9c14e07a…"}
@@ -79,7 +80,7 @@ curl http://127.0.0.1:7070/events
 
 **v1 AOF engine is still shipped and unchanged** — `nedbd` (no flag) runs v1.
 
-**Production status:** [vision.interchained.org](https://vision.interchained.org) is live on v2.0.36 — **1,310,703 sequences** indexed in the Vision database, AES-256-GCM encrypted at rest, at block height **620,989**.
+**Production status:** [vision.interchained.org](https://vision.interchained.org) is live on v2.2.31 — **1,310,703 sequences** indexed in the Vision database, AES-256-GCM encrypted at rest, at block height **620,989**.
 
 ---
 
@@ -244,11 +245,11 @@ nedbd --dag --data ./data                 # v2 DAG engine (or NEDBD_DAG=1)
 NEDBD_RESP2_PORT=6380 nedbd               # also speak RESP2 (redis-cli compatible)
 nedbd --log-level 2                       # 0=errors 1=requests 2=deploy 3=verbose
 
-# Live event stream (new in v2.0.36) — SSE: scan progress, ready, per-write head
+# Live event stream (new in v2.2.31) — SSE: scan progress, ready, per-write head
 curl http://127.0.0.1:7070/events
 ```
 
-### Startup modes (v2.0.36)
+### Startup modes (v2.2.31)
 
 - **Warm start** — every restart after the first open reads the `MANIFEST` file and restores `seq` + Merkle `head` in **O(1)**. No scan, no replay, independent of dataset size. Boots in milliseconds.
 - **Cold start** — first open of an existing dataset spawns the integrity scan in a background thread *and accepts connections immediately*. Reads serve instantly from the content-addressed DAG; writes return `HTTP 503 startup in progress` until the `startup_ready` gate flips. Progress (objects, rate, ETA) streams over `GET /events`.
@@ -258,7 +259,7 @@ curl http://127.0.0.1:7070/events
 | Variable | Default | Description |
 |---|---|---|
 | `NEDBD_DAG` | `0` | Set `1` to launch the v2 DAG engine (`nedbd-v2`). Same as `--dag`. |
-| `NEDBD_HOST` | `127.0.0.1` | Bind address. **v2.0.36** defaults to loopback (was `0.0.0.0`) — security hardening fix. Set explicitly to `0.0.0.0` to expose. |
+| `NEDBD_HOST` | `127.0.0.1` | Bind address. **v2.2.31** defaults to loopback (was `0.0.0.0`) — security hardening fix. Set explicitly to `0.0.0.0` to expose. |
 | `NEDBD_PORT` | `7070` | HTTP bind port. |
 | `NEDBD_TOKEN` | unset | Optional bearer token; required on every `/v1/*` request when set. |
 | `NEDB_TMK` | unset | 32-byte hex AES-256-GCM at-rest encryption key. |
@@ -321,7 +322,7 @@ db.query('FROM policy AS OF 200 VALID AS OF "2024-02-15"')
 
 ## Performance
 
-**v2 DAG Rust server (v2.0.36, Intel iMac — 10k writes / 100k reads / 30k objects, AES-256-GCM on):**
+**v2 DAG Rust server (v2.2.31, Intel iMac — 10k writes / 100k reads / 30k objects, AES-256-GCM on):**
 
 | Operation | Throughput | p50 | p99 |
 |---|---|---|---|

{nedb_engine-2.2.28 → nedb_engine-2.2.32}/README.md

@@ -8,8 +8,9 @@ Replay-protected · idempotent · relational · filterable · sortable · search
 One Rust core → ships to **PyPI** and **npm** from a single source.
 
 [![PyPI](https://img.shields.io/pypi/v/nedb-engine?label=PyPI&color=6366f1)](https://pypi.org/project/nedb-engine/)
+[![crates.io](https://img.shields.io/crates/v/nedb-engine?label=crates.io&color=f97316)](https://crates.io/crates/nedb-engine)
 [![npm](https://img.shields.io/npm/v/nedb-engine?label=npm&color=00d4ff)](https://www.npmjs.com/package/nedb-engine)
-[![Tests](https://img.shields.io/badge/tests-266%20passing-34d399)](https://github.com/aiassistsecure/nedb/actions)
+[![CI](https://img.shields.io/github/actions/workflow/status/Eth-Interchained/nedb/release.yml?label=CI&color=34d399)](https://github.com/Eth-Interchained/nedb/actions)
 [![nedb-engine-client PyPI](https://img.shields.io/pypi/v/nedb-engine-client?label=nedb-engine-client&color=34d399)](https://pypi.org/project/nedb-engine-client/)
 [![nedb-engine-client npm](https://img.shields.io/npm/v/nedb-engine-client?label=nedb-engine-client&color=34d399)](https://www.npmjs.com/package/nedb-engine-client)
 
@@ -19,11 +20,11 @@ One Rust core → ships to **PyPI** and **npm** from a single source.
 
 ---
 
-## NEDB v2.0.36 — Production Stable
+## NEDB v2.2.31 — Production Stable
 
-**Current stable: 2.0.36** — Cross-platform native wheels shipping `nedbd-v2` binary inside `pip install nedb-engine`. Linux + Windows wheels built on GitHub Actions; macOS arm64 + x86_64 wheels built on Codemagic (M2 Mac Minis). All four platforms publish from one `v*` tag.
+**Current stable: 2.2.31** — Cross-platform native wheels shipping `nedbd-v2` binary inside `pip install nedb-engine`. Linux + Windows wheels built on GitHub Actions; macOS arm64 + x86_64 wheels built on Codemagic (M2 Mac Minis). All four platforms publish from one `v*` tag.
 
-NEDB v2 replaces the append-only log (AOF) with a **content-addressed Merkle DAG**. Every document version is an immutable, BLAKE2b-verified object. Nothing is ever overwritten. As of **v2.0.36**, restarts after the first open are **O(1) warm starts** (driven by a `MANIFEST` of `seq` + Merkle head), the **cold scan is deferred** so the daemon accepts connections immediately, and a new **`GET /events` SSE endpoint** streams scan progress + per-write events live.
+NEDB v2 replaces the append-only log (AOF) with a **content-addressed Merkle DAG**. Every document version is an immutable, BLAKE2b-verified object. Nothing is ever overwritten. As of **v2.2.31**, restarts after the first open are **O(1) warm starts** (driven by a `MANIFEST` of `seq` + Merkle head), the **cold scan is deferred** so the daemon accepts connections immediately, and a new **`GET /events` SSE endpoint** streams scan progress + per-write events live.
 
 ```bash
 # Run the v2 DAG engine — ships inside pip install nedb-engine
@@ -32,9 +33,9 @@ nedbd --dag --data ./data
 NEDBD_DAG=1 NEDB_TMK=<32-byte-hex> nedbd --data ./data
 
 curl http://127.0.0.1:7070/health
-# {"ok":true,"version":"2.0.36","service":"nedbd","engine":"dag","startup_ready":true,"encrypted":true}
+# {"ok":true,"version":"2.2.31","service":"nedbd","engine":"dag","startup_ready":true,"encrypted":true}
 
-# Tail the live event stream (new in v2.0.36)
+# Tail the live event stream (new in v2.2.31)
 curl http://127.0.0.1:7070/events
 # event: scan   data: {"objects":730000,"of":1310703,"rate":21043,"eta_s":28}
 # event: ready  data: {"seq":1310703,"head":"b2:9c14e07a…"}
@@ -58,7 +59,7 @@ curl http://127.0.0.1:7070/events
 
 **v1 AOF engine is still shipped and unchanged** — `nedbd` (no flag) runs v1.
 
-**Production status:** [vision.interchained.org](https://vision.interchained.org) is live on v2.0.36 — **1,310,703 sequences** indexed in the Vision database, AES-256-GCM encrypted at rest, at block height **620,989**.
+**Production status:** [vision.interchained.org](https://vision.interchained.org) is live on v2.2.31 — **1,310,703 sequences** indexed in the Vision database, AES-256-GCM encrypted at rest, at block height **620,989**.
 
 ---
 
@@ -223,11 +224,11 @@ nedbd --dag --data ./data                 # v2 DAG engine (or NEDBD_DAG=1)
 NEDBD_RESP2_PORT=6380 nedbd               # also speak RESP2 (redis-cli compatible)
 nedbd --log-level 2                       # 0=errors 1=requests 2=deploy 3=verbose
 
-# Live event stream (new in v2.0.36) — SSE: scan progress, ready, per-write head
+# Live event stream (new in v2.2.31) — SSE: scan progress, ready, per-write head
 curl http://127.0.0.1:7070/events
 ```
 
-### Startup modes (v2.0.36)
+### Startup modes (v2.2.31)
 
 - **Warm start** — every restart after the first open reads the `MANIFEST` file and restores `seq` + Merkle `head` in **O(1)**. No scan, no replay, independent of dataset size. Boots in milliseconds.
 - **Cold start** — first open of an existing dataset spawns the integrity scan in a background thread *and accepts connections immediately*. Reads serve instantly from the content-addressed DAG; writes return `HTTP 503 startup in progress` until the `startup_ready` gate flips. Progress (objects, rate, ETA) streams over `GET /events`.
@@ -237,7 +238,7 @@ curl http://127.0.0.1:7070/events
 | Variable | Default | Description |
 |---|---|---|
 | `NEDBD_DAG` | `0` | Set `1` to launch the v2 DAG engine (`nedbd-v2`). Same as `--dag`. |
-| `NEDBD_HOST` | `127.0.0.1` | Bind address. **v2.0.36** defaults to loopback (was `0.0.0.0`) — security hardening fix. Set explicitly to `0.0.0.0` to expose. |
+| `NEDBD_HOST` | `127.0.0.1` | Bind address. **v2.2.31** defaults to loopback (was `0.0.0.0`) — security hardening fix. Set explicitly to `0.0.0.0` to expose. |
 | `NEDBD_PORT` | `7070` | HTTP bind port. |
 | `NEDBD_TOKEN` | unset | Optional bearer token; required on every `/v1/*` request when set. |
 | `NEDB_TMK` | unset | 32-byte hex AES-256-GCM at-rest encryption key. |
@@ -300,7 +301,7 @@ db.query('FROM policy AS OF 200 VALID AS OF "2024-02-15"')
 
 ## Performance
 
-**v2 DAG Rust server (v2.0.36, Intel iMac — 10k writes / 100k reads / 30k objects, AES-256-GCM on):**
+**v2 DAG Rust server (v2.2.31, Intel iMac — 10k writes / 100k reads / 30k objects, AES-256-GCM on):**
 
 | Operation | Throughput | p50 | p99 |
 |---|---|---|---|

{nedb_engine-2.2.28 → nedb_engine-2.2.32}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nedb-engine"
-version = "2.2.28"
+version = "2.2.32"
 description = "NEDB — a versioned, self-compressing, time-traveling embedded database (replay-protected, idempotent, relational, searchable) with durable AOF persistence and a server daemon (nedbd)."
 readme = "README.md"
 requires-python = ">=3.8"

{nedb_engine-2.2.28 → nedb_engine-2.2.32}/python/nedb/__init__.py

@@ -29,6 +29,7 @@ from .mongo import (
 from .autoindex import AutoIndexDB
 from .concurrent import Sequencer
 from .wrap_redis import wrap_redis, WrappedRedis
+from .proof import verify_proof, fold_head
 
 try:  # compiled Rust core, present in platform wheels (PyO3 via maturin)
     from . import _native  # type: ignore
@@ -38,21 +39,35 @@ except ImportError:  # pure-Python install (sdist / unsupported platform)
     # informative error instead of a bare ImportError with no guidance.
     import types as _types, sys as _sys
 
+    import sys as _sys_tmp, os as _os_tmp
+    _is_msys2 = bool(_os_tmp.environ.get("MSYSTEM")) or "mingw" in _sys_tmp.executable.lower()
+    del _sys_tmp, _os_tmp
+
     class _NativeStub(_types.ModuleType):
-        _MSG = (
+        # Primary fix: install the Rust crate → get the nedbd server → use HTTP mode.
+        # Secondary fix (CPython only): pip reinstall to get the platform wheel with _native embedded.
+        _MSG_MSYS2 = (
+            "\n\n"
+            "  nedb._native (embedded v2 DAG core) is not available on MSYS2/MinGW Python.\n\n"
+            "  To use NEDB v2 features, install the server binary and use HTTP mode:\n\n"
+            "    cargo install nedb-engine          # install nedbd v2 server\n"
+            "    nedbd --dag ./data                 # start DAG server\n"
+            "    NEDB_URL=http://localhost:7070 python3 your_script.py\n\n"
+            "  Run 'nedbd --doctor' for a full diagnosis.\n"
+        )
+        _MSG_OTHER = (
             "\n\n"
-            "  nedb._native is not available on this platform.\n\n"
-            "  The compiled Rust core ships with platform wheels (Linux x86_64,\n"
-            "  macOS arm64/x86_64, Windows x64 CPython).  It is NOT included in\n"
-            "  the universal wheel installed on MSYS2/MinGW Python.\n\n"
-            "  Options:\n"
-            "    1. Use the HTTP server instead (works on any platform):\n"
-            "         nedbd --dag ./data                              # start DAG server\n"
-            "         NEDB_URL=http://localhost:7070 python3 script.py\n\n"
-            "    2. Re-install on a platform that has a native wheel:\n"
-            "         pip install --force-reinstall --no-cache-dir nedb-engine\n\n"
-            "    3. Run 'nedbd --doctor' for a full diagnosis.\n"
+            "  nedb._native (embedded v2 DAG core) is not available.\n"
+            "  You have the universal wheel — reinstall to get the platform wheel:\n\n"
+            "    pip install --force-reinstall --no-cache-dir nedb-engine\n\n"
+            "  Or install the server binary and use HTTP mode (works everywhere):\n\n"
+            "    cargo install nedb-engine          # install nedbd v2 server\n"
+            "    nedbd --dag ./data                 # start DAG server\n"
+            "    NEDB_URL=http://localhost:7070 python3 your_script.py\n\n"
+            "  Run 'nedbd --doctor' for a full diagnosis.\n"
         )
+        _MSG = _MSG_MSYS2 if _is_msys2 else _MSG_OTHER
+
         def __getattr__(self, name: str):
             raise ImportError(f"nedb._native.{name} is not available.{self._MSG}")
 
@@ -71,6 +86,7 @@ __all__ = [
     "MongoCompat", "MongoClient", "MongoError", "MongoUnsupportedError", "ObjectId",
     "AutoIndexDB", "Sequencer",
     "wrap_redis", "WrappedRedis",
+    "verify_proof", "fold_head",
     "_native", "__has_native__",
 ]
-__version__ = "2.2.28"
+__version__ = "2.2.32"

nedb_engine-2.2.32/python/nedb/proof.py

@@ -0,0 +1,126 @@
+"""
+nedb.proof — Merkle inclusion proofs for the hash-chained op log.
+
+Every NEDB write produces an Op whose ``hash`` field is the chain head after that op
+(``op.hash = blake2b(prev_head.utf8 + canon(body))`` — see ``nedb.log``). The chain
+head therefore commits cryptographically to the entire write history.
+
+This module derives a *parallel*, compact Merkle commitment chain over the same
+op-hash sequence so a client can verify — offline, with no server round-trip and
+without re-running the engine — that a specific op-hash was at a specific seq in
+the log, and that the log's head followed from chaining all subsequent op-hashes
+on top of it.
+
+The chain step used by both ``verify_proof`` (client) and the server endpoint is::
+
+    head_next = blake2b(bytes.fromhex(head_prev) || bytes.fromhex(op_hash)).hexdigest()
+
+starting from the genesis head (the all-zero 32-byte string). Folding over the
+full ordered list of op-hashes yields a deterministic head; tamper with any op
+hash (or reorder ops) and the fold no longer matches. The Op's own ``hash`` field
+already commits to its body (payload, seq, nonce, ts, …) under the engine's chain
+formula, so this fold is a complete commitment to the write history through the
+op-hashes alone — exactly the property a Merkle inclusion proof needs.
+
+The fold's terminal value (``proof["head"]``) is a *derived* head, distinct from
+``db.head`` (the engine's UTF-8-hex chain) but a deterministic function of the
+same log. The server computes the derived head over the live log when issuing
+each proof, so any divergence between client fold and server fold means the
+proof was tampered with in transit.
+"""
+from __future__ import annotations
+
+import hashlib
+from typing import Dict, List
+
+# Genesis head matches the engine: all-zero 32-byte string in hex.
+GENESIS = "0" * 64
+
+
+def _blake(data: bytes) -> str:
+    """BLAKE2b-256 over raw bytes, returned as hex — same primitive the engine uses."""
+    return hashlib.blake2b(data, digest_size=32).hexdigest()
+
+
+def _chain_step(head_hex: str, op_hash_hex: str) -> str:
+    """One Merkle-chain step on raw bytes (decoded from hex).
+
+    Mirrors the user-facing spec exactly:
+        new_head = blake2b(prev_head_bytes || op_hash_bytes)
+    """
+    return _blake(bytes.fromhex(head_hex) + bytes.fromhex(op_hash_hex))
+
+
+def fold_head(op_hashes: List[str], start: str = GENESIS) -> str:
+    """Fold an ordered list of op-hashes into a Merkle-chain head.
+
+    Used by the server to produce ``proof["head"]`` for any given log state and
+    by tests to sanity-check that the fold is order-sensitive and deterministic.
+    """
+    head = start
+    for h in op_hashes:
+        head = _chain_step(head, h)
+    return head
+
+
+def verify_proof(proof: Dict) -> bool:
+    """Verify a Merkle inclusion proof client-side — no server, no engine needed.
+
+    ``proof`` shape::
+
+        {
+            "hash":       "<64-hex>",   # the document op's content hash (op.hash)
+            "seq":        N,            # sequence number of this op in the log
+            "prev_head":  "<64-hex>",   # chain head BEFORE this op (= op.prev_hash)
+            "subsequent": ["<64-hex>"], # op-hashes of every op AFTER this one
+            "head":       "<64-hex>",   # claimed final (derived) chain head
+        }
+
+    Verification (matches the spec):
+      1. ``head_at_seq = blake2b(prev_head_bytes || hash_bytes)``
+      2. For each ``sub_hash`` in subsequent:
+            ``head = blake2b(head_bytes || sub_hash_bytes)``
+      3. ``final head == proof["head"]``
+
+    Returns True iff every step is internally consistent. Tampering with any
+    field — flipping a byte of ``hash``, reordering ``subsequent``, swapping
+    ``prev_head``, etc. — will flip the fold and make this return False.
+    """
+    if not isinstance(proof, dict):
+        return False
+
+    # Required keys with the right shapes.
+    required = ("hash", "seq", "prev_head", "subsequent", "head")
+    if not all(k in proof for k in required):
+        return False
+    if not isinstance(proof["seq"], int) or proof["seq"] < 0:
+        return False
+    if not isinstance(proof["subsequent"], list):
+        return False
+
+    # Hex shape check on the 64-char fields. Anything malformed → not verified.
+    def _is_hex32(s: object) -> bool:
+        if not isinstance(s, str) or len(s) != 64:
+            return False
+        try:
+            bytes.fromhex(s)
+        except ValueError:
+            return False
+        return True
+
+    if not _is_hex32(proof["hash"]):       return False
+    if not _is_hex32(proof["prev_head"]):  return False
+    if not _is_hex32(proof["head"]):       return False
+    for s in proof["subsequent"]:
+        if not _is_hex32(s):
+            return False
+
+    # 1. Re-derive the chain head AT this op's seq from prev_head + this op's hash.
+    head = _chain_step(proof["prev_head"], proof["hash"])
+
+    # 2. Fold each subsequent op-hash on top to advance the chain to the tail.
+    for sub in proof["subsequent"]:
+        head = _chain_step(head, sub)
+
+    # 3. The fold must equal the claimed final head bit-for-bit.
+    return head == proof["head"]

{nedb_engine-2.2.28 → nedb_engine-2.2.32}/python/nedb/server.py

@@ -33,6 +33,7 @@ HTTP API (all JSON):
   POST   /v1/databases/<name>/files             {name, data_b64, tier?}  — store a file (Cascade-compressed)
   GET    /v1/databases/<name>/files/<filename>?version=N&tier=warm  — retrieve a file
   GET    /v1/databases/<name>/files/<filename>/root?version=N&tier=warm  — Merkle root (anchorable)
+  POST   /v1/databases/<name>/proof             {hash}  — Merkle inclusion proof (verifiable offline)
   POST   /v1/databases/<name>/checkpoint        — on-demand checkpoint
   GET    /v1/databases/<name>/batch             — batch writes (array of {op,coll,id,doc})
 """
@@ -368,6 +369,57 @@ def make_handler(manager: Manager, token: Optional[str]):
                         ops = [o.to_dict() for o in db.log.ops[-limit:]][::-1]
                         self._send(200, {"log": ops, "seq": db.seq, "head": db.head})
                         return
+                    # POST /v1/databases/<name>/proof
+                    # Body: {"hash": "<64-hex>"}  — the op.hash of a previously-written doc
+                    # Response: a self-contained Merkle inclusion proof + a verified flag.
+                    # The proof is verifiable client-side via nedb.verify_proof() with no
+                    # server / engine — the server's role is only to look up the seq,
+                    # collect the prev_head and subsequent op-hashes, and fold them into
+                    # the same derived head the client will re-derive locally.
+                    if method == "POST" and action == "proof":
+                        from .proof import verify_proof as _vp, fold_head as _fold, GENESIS as _GEN
+                        b = self._body()
+                        want = str(b.get("hash", "")).strip().lower()
+                        if not want or len(want) != 64:
+                            raise HttpError(400, "hash (64-char hex) is required")
+                        try:
+                            bytes.fromhex(want)
+                        except ValueError:
+                            raise HttpError(400, "hash must be 64-char hexadecimal")
+                        # Find the Op with this exact chain-hash.
+                        ops = db.log.ops
+                        target = None
+                        for o in ops:
+                            if o.hash == want:
+                                target = o
+                                break
+                        if target is None:
+                            raise HttpError(404, f"no op with hash={want[:16]}…")
+                        # The proof scheme is a Merkle fold over op-hashes — a
+                        # PARALLEL commitment to the engine's per-op chain. Both
+                        # are deterministic functions of the same log. Replay the
+                        # fold from GENESIS to determine the fold-value just before
+                        # this op (prev_head), then collect every subsequent op-hash
+                        # so the client can fold forward to the same derived head.
+                        op_hashes = [o.hash for o in ops]
+                        prev_head  = _fold(op_hashes[: target.seq], start=_GEN)
+                        subsequent = op_hashes[target.seq + 1:]
+                        derived_head = _fold(op_hashes, start=_GEN)
+                        proof = {
+                            "hash":       target.hash,
+                            "seq":        target.seq,
+                            "prev_head":  prev_head,
+                            "subsequent": subsequent,
+                            "head":       derived_head,
+                        }
+                        # Self-check: confirm the proof verifies before returning it,
+                        # so a 200 from this endpoint is a hard guarantee of soundness.
+                        proof["verified"] = _vp(proof)
+                        # Helpful extras for clients that want to anchor to db.head too.
+                        proof["engine_head"] = db.head
+                        proof["engine_seq"]  = db.seq
+                        self._send(200, proof)
+                        return
                     # MongoDB-compatible query endpoint
                     # POST /v1/databases/<name>/mongo
                     # Body: {collection, op, ...op-specific args}
@@ -676,7 +728,7 @@ def _run_doctor() -> None:  # noqa: C901
         step += 1
         if has_cargo:
             _cmd("install from crates.io (recommended)",
-                 "cargo install nedb-core-v2",
+                 "cargo install nedb-engine",
                  f"binary → {os.path.join(_cargo_bin, 'nedbd')}")
             print()
             _cmd("OR reinstall pip wheel (also bundles the binary)",
@@ -810,7 +862,7 @@ def main() -> None:
             print("", file=_sys.stderr)
             print("  Quick fixes:", file=_sys.stderr)
             print("    pip install --force-reinstall --no-cache-dir nedb-engine  # re-install with binary", file=_sys.stderr)
-            print("    cargo install nedb-core-v2                                # build from source (any platform)", file=_sys.stderr)
+            print("    cargo install nedb-engine                                # build from source (any platform)", file=_sys.stderr)
             print("", file=_sys.stderr)
             _sys.exit(1)
         # Rust binary: nedbd-v2 [data_dir]
@@ -861,6 +913,30 @@ def main() -> None:
     print(BANNER)
     level_label = {0: "errors-only", 1: "requests", 2: "deploy", 3: "verbose"}.get(_log_level, str(_log_level))
     print(f"  nedbd {__version__} — http://{host}:{port}  data={os.path.abspath(data)}  auth={auth}  log={level_label}")
+
+    # ── v2 DAG health notice ──────────────────────────────────────────────────
+    # Check once at startup whether the v2 binary and _native extension are available.
+    # Print a single actionable line if either is missing — non-blocking, no exit.
+    _has_native = False
+    try:
+        from nedb import __has_native__ as _has_native  # type: ignore[attr-defined]
+    except Exception:
+        pass
+    _dag_bin_available = shutil.which("nedbd-v2") or shutil.which("nedbd_v2") or \
+        any(os.path.isfile(os.path.join(os.path.dirname(os.path.abspath(__file__)), n))
+            for n in ["nedbd-v2", "nedbd-v2.exe", "nedbd_v2", "nedbd_v2.exe"])
+    if not _has_native or not _dag_bin_available:
+        print()
+    if not _dag_bin_available:
+        print("  ⚡ v2 DAG engine not found — for content-addressed, instant-cold-start mode:")
+        print("       cargo install nedb-engine   →   nedbd --dag ./data")
+    if not _has_native:
+        print("  ⚡ nedb._native not available — embedded v2 API requires the platform wheel")
+        print("       pip install --force-reinstall --no-cache-dir nedb-engine")
+        print("       OR use HTTP mode: NEDB_URL=http://localhost:7070 python3 your_script.py")
+    if not _has_native or not _dag_bin_available:
+        print("  ℹ  Run 'nedbd --doctor' for a full diagnosis and exact fix commands.")
+        print()
     # Eagerly open all known databases so backfill-encrypt (if needed) runs
     # immediately and is visible in the boot log, not hidden on first request.
     names = manager.names()

nedb_engine-2.2.32/rust/nedb-v2/README.md

@@ -0,0 +1,179 @@
+# nedb-engine
+
+**NEDB v2 — content-addressed DAG storage engine with NQL and HTTP server**
+
+[![crates.io](https://img.shields.io/crates/v/nedb-engine?color=f97316)](https://crates.io/crates/nedb-engine)
+[![License: BUSL-1.1](https://img.shields.io/badge/license-BUSL--1.1-blue)](https://github.com/aiassistsecure/nedb/blob/master/LICENSE)
+[![GitHub](https://img.shields.io/badge/github-aiassistsecure%2Fnedb-8da0cb)](https://github.com/aiassistsecure/nedb)
+
+This crate ships the **`nedbd`** binary — the NEDB v2 DAG HTTP server. Install it, point it at a data directory, and any language can speak to it over HTTP/JSON.
+
+```bash
+cargo install nedb-engine
+nedbd ./data              # AOF engine (pure Rust, v1-compatible)
+nedbd --dag ./data        # DAG engine (v2, content-addressed, recommended)
+```
+
+---
+
+## What is NEDB v2?
+
+NEDB v2 replaces the append-only log (AOF) with a **content-addressed Merkle DAG**:
+
+- Every document version is an **immutable, BLAKE2b-hashed object**. Nothing is ever overwritten.
+- Every write produces a new **chain head** — a BLAKE2b commitment over the entire database history.
+- **Time-travel**: read any document `AS OF seq N` to see exactly what it contained at that point.
+- **Causal provenance**: documents link to their causal parents via `caused_by` hashes. `TRACE caused_by` walks the full causal graph backward.
+- **TRAVERSE**: named graph relations via `__links__`. `FROM person WHERE _id = "robert" TRAVERSE parent_of` returns linked nodes.
+- **O(1) warm start**: a `MANIFEST` file stores `seq` + Merkle head so restarts never re-scan the entire object store.
+- **Instant cold start**: the daemon accepts connections immediately; background scan loads objects incrementally.
+- **AES-256-GCM at rest**: optional symmetric encryption with a double-envelope key structure (TMK wraps DEK).
+
+---
+
+## Install
+
+```bash
+cargo install nedb-engine
+```
+
+The `nedbd` binary lands in `~/.cargo/bin/`. Make sure that's on your `PATH`.
+
+To verify:
+
+```bash
+nedbd --doctor      # diagnose your NEDB environment
+```
+
+---
+
+## Usage
+
+```
+nedbd [OPTIONS] [data_dir]
+```
+
+| Argument | Default | Description |
+|---|---|---|
+| `data_dir` | `./nedb-data` | Directory for database files |
+| `--dag` | off | Use the v2 content-addressed DAG engine |
+| `--doctor` | — | Diagnose environment, print fix commands |
+
+### Environment variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `NEDBD_HOST` | `127.0.0.1` | Bind address |
+| `NEDBD_PORT` | `7070` | HTTP port |
+| `NEDBD_TOKEN` | — | Bearer token for auth (optional) |
+| `NEDB_TMK` | — | 64-char hex master key for AES-256-GCM encryption at rest |
+| `NEDBD_MEMORY` | — | `1` = pure in-memory mode (no disk I/O) |
+| `NEDBD_DAG` | — | `1` = same as `--dag` flag |
+
+---
+
+## HTTP API
+
+All endpoints return JSON. Auth: `Authorization: Bearer <token>` if `NEDBD_TOKEN` is set.
+
+```
+GET    /health
+GET    /v1/databases
+POST   /v1/databases                    {name, init?}
+GET    /v1/databases/<name>
+DELETE /v1/databases/<name>
+POST   /v1/databases/<name>/put         {coll, id, doc, caused_by?}
+POST   /v1/databases/<name>/query       {nql}
+POST   /v1/databases/<name>/link        {frm, rel, to}
+POST   /v1/databases/<name>/neighbors   {node, rel}
+GET    /v1/databases/<name>/verify
+POST   /v1/databases/<name>/checkpoint
+```
+
+---
+
+## NQL — NEDB Query Language
+
+```sql
+-- Basic queries
+FROM person LIMIT 10
+FROM driver WHERE status = "active"
+FROM driver WHERE rating >= 4.5 ORDER BY rating DESC
+
+-- Time-travel
+FROM will WHERE _id = "evans_will_2019" AS OF 5
+
+-- Causal trace (walks caused_by links backward)
+FROM event WHERE _id = "probate_filing" TRACE caused_by
+
+-- Graph traversal
+FROM person WHERE _id = "robert" TRAVERSE parent_of
+```
+
+---
+
+## Example: The Will — causal DAG in action
+
+```python
+import json, os, urllib.request
+
+def put(db_url, coll, id_, doc):
+    body = json.dumps({"coll": coll, "id": id_, "doc": doc}).encode()
+    req = urllib.request.Request(f"{db_url}/put", body,
+          {"Content-Type": "application/json"}, method="POST")
+    return json.loads(urllib.request.urlopen(req).read())["doc"]
+
+BASE = "http://localhost:7070/v1/databases/will"
+
+# Robert writes his will
+robert = put(BASE, "person", "robert", {"name": "Robert Evans", "role": "testator"})
+will_v1 = put(BASE, "will", "evans_will", {
+    "house": "mark", "business": "lisa",
+    "caused_by": [robert["_hash"]],   # causal link to testator record
+})
+
+# Amendment — chains off v1
+will_v2 = put(BASE, "will", "evans_will", {
+    "house": "mark", "business": "lisa", "vintage_car": "mark",
+    "caused_by": [will_v1["_hash"]],
+})
+
+# TRACE proves the amendment links back to the original
+query = json.dumps({"nql": 'FROM will WHERE _id = "evans_will" TRACE caused_by'}).encode()
+req = urllib.request.Request(f"{BASE}/query", query,
+      {"Content-Type": "application/json"}, method="POST")
+trace = json.loads(urllib.request.urlopen(req).read())["rows"]
+# → both versions + Robert's testator record, in causal order
+```
+
+---
+
+## Python companion
+
+The `nedb-engine` PyPI package ships the same server binary bundled in the wheel, plus:
+- Pure-Python AOF engine (`NEDB` class)
+- Embedded v2 DAG API (`nedb._native.NedbCore`) on supported platforms
+- `nedbd` console script
+
+```bash
+pip install nedb-engine
+
+# Use embedded API (Linux/macOS/Windows CPython)
+python3 -c "from nedb._native import NedbCore; db = NedbCore(); ..."
+
+# Use HTTP mode (any platform, including MSYS2/MinGW)
+NEDB_URL=http://localhost:7070 python3 your_script.py
+
+# Diagnose
+nedbd --doctor
+```
+
+---
+
+## License
+
+[BUSL-1.1](https://github.com/aiassistsecure/nedb/blob/master/LICENSE) — Business Source License. Free for development and evaluation; production use requires a commercial licence from INTERCHAINED, LLC.
+
+---
+
+*Built by [INTERCHAINED, LLC](https://interchained.org) × Claude Sonnet 4.6*