nedb-engine 3.0.0__tar.gz → 3.2.1__tar.gz

{nedb_engine-3.0.0 → nedb_engine-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nedb-engine
-Version: 3.0.0
+Version: 3.2.1
 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
@@ -47,86 +47,114 @@ One Rust core → ships to **PyPI** and **npm** from a single source.
 
 ---
 
-## ⚠️ New in 2.8.6 — Durability & Recovery (read this if you store anything you care about)
+## New in 3.2.0 — wrap the databases you already run
 
-Three defects found by killing a real engine at every persistence boundary and by filling a real
-filesystem to zero free blocks. All three are fixed. **If you are on 2.8.5 or earlier, upgrade.**
+NEDB adds **tamper-evident causal provenance to a database you already have**, in one line, without
+rip-and-replace. Five adapters, one surface:
 
-### 1. A failed flush silently discarded acknowledged writes
+```python
+from nedb import wrap_redis, wrap_sqlite, wrap_mysql, wrap_mongo, wrap_postgresql
 
-`IdIndex::flush_write_buf` cleared every buffered entry regardless of whether its disk write
-succeeded. So a flush that hit `ENOSPC` threw the entry away, and no later flush retried it.
+r = wrap_redis(redis.Redis())        # or wrap_sqlite(sqlite3.connect("app.db")), ...
+r.nedb.register("driver:*", "driver")   # teach NEDB the host's shape
+r.nedb.backfill()                       # import what is already there
+r.nedb.shadow_writes = True             # every future write is chained
 
-Reproduced on a full 22 MiB filesystem: **30 rows acknowledged by `put() -> Ok`, then `list()`
-returned 0 after reopen — while `verify()` reported all 30 objects healthy.** The content-addressed
-objects were durable; the id-index entries that make them findable were gone.
+r.set("driver:d1", json.dumps({"name": "Bob", "status": "active"}))
 
-```
-before:  try_flush_all() -> (no return value)      reopen -> 0 rows, verify() = 30 ok
-after:   try_flush_all() -> Err("id-index leaf rows/buf_25: No space left on device (os error 28)")
-         ...free space, retry -> Ok                reopen -> 30 rows
+r.nedb.query('FROM driver WHERE status = "active"')   # NQL over your Redis data
+r.nedb.query('FROM driver AS OF 41')                  # what it looked like at seq 41
+r.nedb.verify()                                       # True — BLAKE2b chain intact
 ```
 
-**Fixed:** an entry leaves the WAL only when its write actually landed. Failures stay buffered and
-retry on the next flush.
+| wrapper | host | shadowing |
+|---|---|---|
+| `wrap_redis` | `redis.Redis` / compatible | automatic — every write command intercepted |
+| `wrap_sqlite` | `sqlite3.Connection` | automatic — `execute()` intercepted post-write |
+| `wrap_mysql` | DB-API 2.0 (mysql-connector, PyMySQL) | explicit `shadow_row()` |
+| `wrap_mongo` | `pymongo.MongoClient` | explicit `shadow_row()` |
+| `wrap_postgresql` | DB-API 2.0 (psycopg2, psycopg 3) | explicit `shadow_row()` |
+
+**NEDB never writes into the host database's namespace.** Shadow data lives only in the NEDB engine.
+
+Three backends behind the same surface, selected by `backend="auto"`: **nedbd over HTTP** (`nedbd_url=`),
+**embedded v2/v3 DAG** (the Rust core, in-process, no server — `dag_path=` for a durable store,
+`dag_tmk=` for AES-256-GCM at rest), or the **v1 in-process AOF** engine as a universal fallback. On the
+DAG backend you also get `tip()`, `tip_collection()`, `since()` (changefeed) and `scan_status()`.
+
+### 🟢 MIT licensed since 3.0.0
+
+No production restriction, no copyleft, no Change Date. Use it in production, embed it commercially,
+ship it closed-source, fork it, sell it. License review is a wall, not a speed bump — that wall is gone.
+
+### Also in 3.2.0
+
+- **A durability defect that pinned every embedded database.** The background flush ticker held a
+  strong `Arc<Db>` in an unconditional loop, so the handle was never dropped: the exclusive data-dir
+  `LOCK` was never released (reopening the same path *in the same process* failed with "locked by
+  another process" naming your own pid), every `open()` leaked a thread and the whole `Db`, and
+  flush-on-close could never fire. The ticker now holds a `Weak<Db>` and exits when its owner does.
+  **Live in 2.8.5 through 3.1.0 — upgrade if you embed the engine.**
+- **`wrap_redis` crashed on any install without the native wheel** — the pure-Python fallback path
+  raised `AttributeError` from inside `wrap_redis()`. Fixed.
+- **Prebuilt binaries for `linux-arm64` and musl/Alpine**, on npm and PyPI. Graviton, Ampere, Linux
+  containers on Apple Silicon, and Alpine images previously installed cleanly and then failed at
+  import.
+- **CI actually runs the test suites.** Until now the only workflows fired on a version tag, so the
+  first automated opinion about a change arrived *after* it was published to three registries. All
+  26 suites now run on every push and pull request. It found four real defects in its first hour,
+  including two of the ones listed above.
 
-### 2. Flush errors were unobservable — new `try_flush_all()`
+---
 
-`flush_all()` returns `()` and logged fsync failures to stderr, so a caller could not tell a durable
-flush from a failed one. Anything that takes a destructive or externally-visible action on the
-strength of a persisted record needs to know.
+## Earlier — 2.8.6 durability & recovery
 
-```rust
-// Use this when the outcome matters:
-db.try_flush_all()?;      // Result<()> — id-index WAL + segment sync + MANIFEST
+Three defects found by killing a real engine at every persistence boundary and by filling a real
+filesystem to zero free blocks. **If you are on 2.8.5 or earlier, upgrade.**
 
-// Still available, still logs, nowhere to propagate (ticker / Drop):
-db.flush_all();
-```
+**1. A failed flush silently discarded acknowledged writes.** `IdIndex::flush_write_buf` cleared every
+buffered entry regardless of whether its disk write succeeded, so a flush that hit `ENOSPC` threw the
+entry away and no later flush retried it. Reproduced on a full 22 MiB filesystem: 30 rows acknowledged
+by `put() -> Ok`, then `list()` returned 0 after reopen — while `verify()` reported all 30 objects
+healthy. The content-addressed objects were durable; the id-index entries that make them findable were
+gone. An entry now leaves the WAL only when its write actually landed.
+
+**2. Flush errors were unobservable.** `flush_all()` returns `()`, so a caller could not tell a durable
+flush from a failed one.
 
-Also new: `Db::try_flush_manifest()` and `IdIndex::try_flush_write_buf()`.
+```rust
+db.try_flush_all()?;      // Result<()> — use this when the outcome matters
+db.flush_all();           // still logs; for ticker / Drop, nowhere to propagate
+```
 
-### 3. `repair` could not repair, and `since()` claimed "caught up" while behind
+Also added: `Db::try_flush_manifest()` and `IdIndex::try_flush_write_buf()`.
 
-The cold scan rebuilt `seq_index`, per-collection tips, the Merkle head and `MANIFEST` — but **never
-the id index**. A database whose WAL never reached disk came back with every object verifying and
-`list()` empty, and `nedb-cli repair` printed success without fixing it, because
-`start_cold_scan()` is a deliberate no-op on a warm store.
+**3. `repair` could not repair, and `since()` claimed "caught up" while behind.** The cold scan rebuilt
+`seq_index`, per-collection tips, the Merkle head and `MANIFEST` — but never the id index, and
+`start_cold_scan()` is a deliberate no-op on a warm store, so `nedb-cli repair` printed success on
+exactly the database it exists to fix.
 
 ```bash
 nedb-cli repair ./data
 # repaired: 203 id-index entr(ies) rebuilt, 203 node(s) verified, flushed
 ```
 
-```rust
-let restored = db.repair()?;   // rebuild id index from objects; highest seq wins
-```
-
-Every object carries its own `coll`, `id` and `seq`, so the id index is fully derivable — a lost WAL
-is recoverable and nothing is invented. `repair()` also recomputes head and tips, so a repaired
-database reopens **warm** instead of coming back up cold with an empty head.
-
-Separately, `since()` set `has_more = hit_limit` alone. On a warm boot the seq index is empty **by
-design** (that is why warm start is O(1)), so every lookup missed and `since()` returned zero nodes
-with `has_more = false` — indistinguishable from genuinely up to date. A consumer following the
-documented drain loop stopped one call in, with every record unread.
-
-**Fixed:** `has_more` is true whenever the cursor is behind the log head. `ScanStatus` gains
-**`seq_index_ready`** — replication consumers should gate on that, not on `scan_complete`, which is
-true on a warm boot precisely because the scan was skipped.
+Every object carries its own `coll`, `id` and `seq`, so the index is fully derivable — nothing is
+invented. Separately, `since()` set `has_more = hit_limit` alone; on a warm boot the seq index is empty
+*by design*, so `since()` returned zero nodes with `has_more = false` — indistinguishable from
+genuinely up to date, and a consumer following the documented drain loop stopped one call in with every
+record unread. `has_more` is now true whenever the cursor is behind head, and `ScanStatus` gains
+**`seq_index_ready`** — gate replication on that, not on `scan_complete`.
 
-### Known sharp edge (documented, not changed)
-
-`since()`'s cursor is **exclusive** and seqs start at 0, so `since(0, _)` returns `(0, head]` and the
-very first write in a database (seq 0) is unreachable through any cursor value. Ten writes drain as
-nine records. Changing the convention would break existing consumers; a replica seeded from
-`since()` alone starts one record short.
+**Known sharp edge (documented, not changed):** `since()`'s cursor is **exclusive** and seqs start at 0,
+so `since(0, _)` returns `(0, head]` and the very first write (seq 0) is unreachable through any cursor
+value. Ten writes drain as nine records. Changing the convention would break existing consumers.
 
 ---
 
-## NEDB v2.8.0 — Production Stable
+## NEDB v3.2.0 — Production Stable
 
-**Current stable: 2.8.0** — NEDB ships as **three version-aligned distributions** on one tag — `nedb-engine` (flagship), `crypto-database` (verifiable v2/v3 DAG), and `aof-db` (fast append-only) — across npm / PyPI / crates.io with full mac + linux + windows native addons (see [**Releasing**](#releasing) below). All native wheels (Linux + Windows on GitHub Actions; macOS arm64 + x86_64 on Codemagic M2 Mac Minis) **plus** the universal pure-Python wheel ship from a single `v*` tag, with the `nedbd-v2` binary bundled inside `pip install nedb-engine`.
+**Current stable: 3.2.0** — NEDB ships as **three version-aligned distributions** on one tag — `nedb-engine` (flagship), `crypto-database` (verifiable v2/v3 DAG), and `aof-db` (fast append-only) — across npm / PyPI / crates.io with native addons for **macOS (arm64 + x86_64), Linux (x86_64 + aarch64, glibc + musl) and Windows x86_64** (see [**Releasing**](#releasing) below). All native wheels (Linux + Windows on GitHub Actions; macOS on Codemagic M2 Mac Minis) **plus** the universal pure-Python wheel ship from a single `v*` tag, with the `nedbd-v2` binary bundled inside `pip install nedb-engine`.
 
 ### New in 2.8.0 — Cast: the database understands English
 
@@ -171,7 +199,7 @@ 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.2.31","service":"nedbd","engine":"dag","startup_ready":true,"encrypted":true}
+# {"ok":true,"version":"3.2.0","service":"nedbd","engine":"dag","startup_ready":true,"encrypted":true}
 
 # Tail the live event stream (new in v2.2.31)
 curl http://127.0.0.1:7070/events
@@ -225,6 +253,24 @@ pip install nedb-engine      # Python ≥ 3.8 — pure-Python + optional Rust na
 npm install nedb-engine       # Node ≥ 16   — napi-rs prebuilt binaries
 ```
 
+### Prebuilt platforms
+
+Both registries ship prebuilt binaries for:
+
+| Platform | libc | Python wheel | Node addon |
+|---|---|---|---|
+| Linux x86_64 | glibc | ✅ manylinux | ✅ |
+| Linux x86_64 | musl (Alpine) | ✅ musllinux | ✅ |
+| Linux aarch64 (Graviton, Ampere, Apple-Silicon containers) | glibc | ✅ manylinux | ✅ |
+| Linux aarch64 | musl (Alpine) | ✅ musllinux | ✅ |
+| macOS arm64 + x86_64 | — | ✅ | ✅ |
+| Windows x86_64 | MSVC | ✅ | ✅ |
+
+On Python, any platform without a prebuilt wheel still installs: pip falls back
+to the universal `py3-none-any` wheel and you get the pure-Python v1 AOF engine
+(correct, slower, no embedded DAG). On Node there is no such fallback — an
+unlisted platform has no addon.
+
 ---
 
 ## Python — 5-minute tour
@@ -934,7 +980,8 @@ Requires `GITHUB_TOKEN` (`repo` + `workflow` scope) in the environment. It never
 ## Authors
 
 Built by **[Mark Allen Evans Jr.](https://interchained.org)** (INTERCHAINED, LLC)
-with **Claude Sonnet 4.6** on [Hyperagent](https://hyperagent.com/refer/J2G6TCD7).
+with the **Interchained AI fleet** on [Hyperagent](https://hyperagent.com/refer/J2G6TCD7) —
+Vex (GLM · Claude Sonnet · Opus · Fable · GPT-6 Astra/Sol), across hundreds of sessions.
 
 > *"Take one idea, turn it into an LP, then an app, then a system, then a platform, then infrastructure that is irreplaceable."*
 

{nedb_engine-3.0.0 → nedb_engine-3.2.1}/README.md

@@ -26,86 +26,114 @@ One Rust core → ships to **PyPI** and **npm** from a single source.
 
 ---
 
-## ⚠️ New in 2.8.6 — Durability & Recovery (read this if you store anything you care about)
+## New in 3.2.0 — wrap the databases you already run
 
-Three defects found by killing a real engine at every persistence boundary and by filling a real
-filesystem to zero free blocks. All three are fixed. **If you are on 2.8.5 or earlier, upgrade.**
+NEDB adds **tamper-evident causal provenance to a database you already have**, in one line, without
+rip-and-replace. Five adapters, one surface:
 
-### 1. A failed flush silently discarded acknowledged writes
+```python
+from nedb import wrap_redis, wrap_sqlite, wrap_mysql, wrap_mongo, wrap_postgresql
 
-`IdIndex::flush_write_buf` cleared every buffered entry regardless of whether its disk write
-succeeded. So a flush that hit `ENOSPC` threw the entry away, and no later flush retried it.
+r = wrap_redis(redis.Redis())        # or wrap_sqlite(sqlite3.connect("app.db")), ...
+r.nedb.register("driver:*", "driver")   # teach NEDB the host's shape
+r.nedb.backfill()                       # import what is already there
+r.nedb.shadow_writes = True             # every future write is chained
 
-Reproduced on a full 22 MiB filesystem: **30 rows acknowledged by `put() -> Ok`, then `list()`
-returned 0 after reopen — while `verify()` reported all 30 objects healthy.** The content-addressed
-objects were durable; the id-index entries that make them findable were gone.
+r.set("driver:d1", json.dumps({"name": "Bob", "status": "active"}))
 
-```
-before:  try_flush_all() -> (no return value)      reopen -> 0 rows, verify() = 30 ok
-after:   try_flush_all() -> Err("id-index leaf rows/buf_25: No space left on device (os error 28)")
-         ...free space, retry -> Ok                reopen -> 30 rows
+r.nedb.query('FROM driver WHERE status = "active"')   # NQL over your Redis data
+r.nedb.query('FROM driver AS OF 41')                  # what it looked like at seq 41
+r.nedb.verify()                                       # True — BLAKE2b chain intact
 ```
 
-**Fixed:** an entry leaves the WAL only when its write actually landed. Failures stay buffered and
-retry on the next flush.
+| wrapper | host | shadowing |
+|---|---|---|
+| `wrap_redis` | `redis.Redis` / compatible | automatic — every write command intercepted |
+| `wrap_sqlite` | `sqlite3.Connection` | automatic — `execute()` intercepted post-write |
+| `wrap_mysql` | DB-API 2.0 (mysql-connector, PyMySQL) | explicit `shadow_row()` |
+| `wrap_mongo` | `pymongo.MongoClient` | explicit `shadow_row()` |
+| `wrap_postgresql` | DB-API 2.0 (psycopg2, psycopg 3) | explicit `shadow_row()` |
+
+**NEDB never writes into the host database's namespace.** Shadow data lives only in the NEDB engine.
+
+Three backends behind the same surface, selected by `backend="auto"`: **nedbd over HTTP** (`nedbd_url=`),
+**embedded v2/v3 DAG** (the Rust core, in-process, no server — `dag_path=` for a durable store,
+`dag_tmk=` for AES-256-GCM at rest), or the **v1 in-process AOF** engine as a universal fallback. On the
+DAG backend you also get `tip()`, `tip_collection()`, `since()` (changefeed) and `scan_status()`.
+
+### 🟢 MIT licensed since 3.0.0
+
+No production restriction, no copyleft, no Change Date. Use it in production, embed it commercially,
+ship it closed-source, fork it, sell it. License review is a wall, not a speed bump — that wall is gone.
+
+### Also in 3.2.0
+
+- **A durability defect that pinned every embedded database.** The background flush ticker held a
+  strong `Arc<Db>` in an unconditional loop, so the handle was never dropped: the exclusive data-dir
+  `LOCK` was never released (reopening the same path *in the same process* failed with "locked by
+  another process" naming your own pid), every `open()` leaked a thread and the whole `Db`, and
+  flush-on-close could never fire. The ticker now holds a `Weak<Db>` and exits when its owner does.
+  **Live in 2.8.5 through 3.1.0 — upgrade if you embed the engine.**
+- **`wrap_redis` crashed on any install without the native wheel** — the pure-Python fallback path
+  raised `AttributeError` from inside `wrap_redis()`. Fixed.
+- **Prebuilt binaries for `linux-arm64` and musl/Alpine**, on npm and PyPI. Graviton, Ampere, Linux
+  containers on Apple Silicon, and Alpine images previously installed cleanly and then failed at
+  import.
+- **CI actually runs the test suites.** Until now the only workflows fired on a version tag, so the
+  first automated opinion about a change arrived *after* it was published to three registries. All
+  26 suites now run on every push and pull request. It found four real defects in its first hour,
+  including two of the ones listed above.
 
-### 2. Flush errors were unobservable — new `try_flush_all()`
+---
 
-`flush_all()` returns `()` and logged fsync failures to stderr, so a caller could not tell a durable
-flush from a failed one. Anything that takes a destructive or externally-visible action on the
-strength of a persisted record needs to know.
+## Earlier — 2.8.6 durability & recovery
 
-```rust
-// Use this when the outcome matters:
-db.try_flush_all()?;      // Result<()> — id-index WAL + segment sync + MANIFEST
+Three defects found by killing a real engine at every persistence boundary and by filling a real
+filesystem to zero free blocks. **If you are on 2.8.5 or earlier, upgrade.**
 
-// Still available, still logs, nowhere to propagate (ticker / Drop):
-db.flush_all();
-```
+**1. A failed flush silently discarded acknowledged writes.** `IdIndex::flush_write_buf` cleared every
+buffered entry regardless of whether its disk write succeeded, so a flush that hit `ENOSPC` threw the
+entry away and no later flush retried it. Reproduced on a full 22 MiB filesystem: 30 rows acknowledged
+by `put() -> Ok`, then `list()` returned 0 after reopen — while `verify()` reported all 30 objects
+healthy. The content-addressed objects were durable; the id-index entries that make them findable were
+gone. An entry now leaves the WAL only when its write actually landed.
+
+**2. Flush errors were unobservable.** `flush_all()` returns `()`, so a caller could not tell a durable
+flush from a failed one.
 
-Also new: `Db::try_flush_manifest()` and `IdIndex::try_flush_write_buf()`.
+```rust
+db.try_flush_all()?;      // Result<()> — use this when the outcome matters
+db.flush_all();           // still logs; for ticker / Drop, nowhere to propagate
+```
 
-### 3. `repair` could not repair, and `since()` claimed "caught up" while behind
+Also added: `Db::try_flush_manifest()` and `IdIndex::try_flush_write_buf()`.
 
-The cold scan rebuilt `seq_index`, per-collection tips, the Merkle head and `MANIFEST` — but **never
-the id index**. A database whose WAL never reached disk came back with every object verifying and
-`list()` empty, and `nedb-cli repair` printed success without fixing it, because
-`start_cold_scan()` is a deliberate no-op on a warm store.
+**3. `repair` could not repair, and `since()` claimed "caught up" while behind.** The cold scan rebuilt
+`seq_index`, per-collection tips, the Merkle head and `MANIFEST` — but never the id index, and
+`start_cold_scan()` is a deliberate no-op on a warm store, so `nedb-cli repair` printed success on
+exactly the database it exists to fix.
 
 ```bash
 nedb-cli repair ./data
 # repaired: 203 id-index entr(ies) rebuilt, 203 node(s) verified, flushed
 ```
 
-```rust
-let restored = db.repair()?;   // rebuild id index from objects; highest seq wins
-```
-
-Every object carries its own `coll`, `id` and `seq`, so the id index is fully derivable — a lost WAL
-is recoverable and nothing is invented. `repair()` also recomputes head and tips, so a repaired
-database reopens **warm** instead of coming back up cold with an empty head.
-
-Separately, `since()` set `has_more = hit_limit` alone. On a warm boot the seq index is empty **by
-design** (that is why warm start is O(1)), so every lookup missed and `since()` returned zero nodes
-with `has_more = false` — indistinguishable from genuinely up to date. A consumer following the
-documented drain loop stopped one call in, with every record unread.
-
-**Fixed:** `has_more` is true whenever the cursor is behind the log head. `ScanStatus` gains
-**`seq_index_ready`** — replication consumers should gate on that, not on `scan_complete`, which is
-true on a warm boot precisely because the scan was skipped.
+Every object carries its own `coll`, `id` and `seq`, so the index is fully derivable — nothing is
+invented. Separately, `since()` set `has_more = hit_limit` alone; on a warm boot the seq index is empty
+*by design*, so `since()` returned zero nodes with `has_more = false` — indistinguishable from
+genuinely up to date, and a consumer following the documented drain loop stopped one call in with every
+record unread. `has_more` is now true whenever the cursor is behind head, and `ScanStatus` gains
+**`seq_index_ready`** — gate replication on that, not on `scan_complete`.
 
-### Known sharp edge (documented, not changed)
-
-`since()`'s cursor is **exclusive** and seqs start at 0, so `since(0, _)` returns `(0, head]` and the
-very first write in a database (seq 0) is unreachable through any cursor value. Ten writes drain as
-nine records. Changing the convention would break existing consumers; a replica seeded from
-`since()` alone starts one record short.
+**Known sharp edge (documented, not changed):** `since()`'s cursor is **exclusive** and seqs start at 0,
+so `since(0, _)` returns `(0, head]` and the very first write (seq 0) is unreachable through any cursor
+value. Ten writes drain as nine records. Changing the convention would break existing consumers.
 
 ---
 
-## NEDB v2.8.0 — Production Stable
+## NEDB v3.2.0 — Production Stable
 
-**Current stable: 2.8.0** — NEDB ships as **three version-aligned distributions** on one tag — `nedb-engine` (flagship), `crypto-database` (verifiable v2/v3 DAG), and `aof-db` (fast append-only) — across npm / PyPI / crates.io with full mac + linux + windows native addons (see [**Releasing**](#releasing) below). All native wheels (Linux + Windows on GitHub Actions; macOS arm64 + x86_64 on Codemagic M2 Mac Minis) **plus** the universal pure-Python wheel ship from a single `v*` tag, with the `nedbd-v2` binary bundled inside `pip install nedb-engine`.
+**Current stable: 3.2.0** — NEDB ships as **three version-aligned distributions** on one tag — `nedb-engine` (flagship), `crypto-database` (verifiable v2/v3 DAG), and `aof-db` (fast append-only) — across npm / PyPI / crates.io with native addons for **macOS (arm64 + x86_64), Linux (x86_64 + aarch64, glibc + musl) and Windows x86_64** (see [**Releasing**](#releasing) below). All native wheels (Linux + Windows on GitHub Actions; macOS on Codemagic M2 Mac Minis) **plus** the universal pure-Python wheel ship from a single `v*` tag, with the `nedbd-v2` binary bundled inside `pip install nedb-engine`.
 
 ### New in 2.8.0 — Cast: the database understands English
 
@@ -150,7 +178,7 @@ 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.2.31","service":"nedbd","engine":"dag","startup_ready":true,"encrypted":true}
+# {"ok":true,"version":"3.2.0","service":"nedbd","engine":"dag","startup_ready":true,"encrypted":true}
 
 # Tail the live event stream (new in v2.2.31)
 curl http://127.0.0.1:7070/events
@@ -204,6 +232,24 @@ pip install nedb-engine      # Python ≥ 3.8 — pure-Python + optional Rust na
 npm install nedb-engine       # Node ≥ 16   — napi-rs prebuilt binaries
 ```
 
+### Prebuilt platforms
+
+Both registries ship prebuilt binaries for:
+
+| Platform | libc | Python wheel | Node addon |
+|---|---|---|---|
+| Linux x86_64 | glibc | ✅ manylinux | ✅ |
+| Linux x86_64 | musl (Alpine) | ✅ musllinux | ✅ |
+| Linux aarch64 (Graviton, Ampere, Apple-Silicon containers) | glibc | ✅ manylinux | ✅ |
+| Linux aarch64 | musl (Alpine) | ✅ musllinux | ✅ |
+| macOS arm64 + x86_64 | — | ✅ | ✅ |
+| Windows x86_64 | MSVC | ✅ | ✅ |
+
+On Python, any platform without a prebuilt wheel still installs: pip falls back
+to the universal `py3-none-any` wheel and you get the pure-Python v1 AOF engine
+(correct, slower, no embedded DAG). On Node there is no such fallback — an
+unlisted platform has no addon.
+
 ---
 
 ## Python — 5-minute tour
@@ -913,7 +959,8 @@ Requires `GITHUB_TOKEN` (`repo` + `workflow` scope) in the environment. It never
 ## Authors
 
 Built by **[Mark Allen Evans Jr.](https://interchained.org)** (INTERCHAINED, LLC)
-with **Claude Sonnet 4.6** on [Hyperagent](https://hyperagent.com/refer/J2G6TCD7).
+with the **Interchained AI fleet** on [Hyperagent](https://hyperagent.com/refer/J2G6TCD7) —
+Vex (GLM · Claude Sonnet · Opus · Fable · GPT-6 Astra/Sol), across hundreds of sessions.
 
 > *"Take one idea, turn it into an LP, then an app, then a system, then a platform, then infrastructure that is irreplaceable."*
 

{nedb_engine-3.0.0 → nedb_engine-3.2.1}/client/node/README.md

@@ -11,11 +11,20 @@ Connect to any running `nedbd` instance from Node.js or the browser. No engine e
 
 ---
 
-## ⚠️ Upgrade your server to nedbd 2.8.6
+## ⚠️ Upgrade your server to nedbd 3.2.0
 
-This client talks to `nedbd`, so its durability comes from the server. **2.8.6 fixes three defects in
-2.8.5 and earlier** — a flush that hit a full disk silently discarded acknowledged writes, flush
-failures were unobservable, and `nedb-cli repair` could not actually rebuild a damaged id index.
+This client talks to `nedbd`, so its durability comes from the server. **Upgrade if you are on
+anything earlier than 3.2.0.**
+
+**3.2.0 — the embedded engine was pinning its own data directory.** The background flush ticker held
+a strong reference to the database in a loop that never exited, so the handle was never dropped: the
+exclusive data-dir `LOCK` was never released, reopening the same path in the same process failed with
+"locked by another process" naming your *own* pid, and every open leaked a thread and the whole
+database for the life of the process. Live in **2.8.5 through 3.1.0**.
+
+**2.8.6 fixed three defects in 2.8.5 and earlier** — a flush that hit a full disk silently discarded
+acknowledged writes, flush failures were unobservable, and `nedb-cli repair` could not actually
+rebuild a damaged id index.
 
 If a database ever returned rows and now returns none while `/verify` reports every object healthy,
 that is the lost-id-index symptom and it is recoverable:
@@ -86,7 +95,7 @@ NEDBD_DAG=1 NEDBD_CAST=1 nedbd --data ./data
 
 # Check health
 curl http://127.0.0.1:7070/health
-# {"ok":true,"version":"2.8.0","service":"nedbd","encrypted":true}
+# {"ok":true,"version":"3.2.0","service":"nedbd","encrypted":true}
 ```
 
 ---

{nedb_engine-3.0.0 → nedb_engine-3.2.1}/client/python/README.md

@@ -12,11 +12,20 @@ Connect to any running `nedbd` instance — local or remote — with a clean asy
 
 ---
 
-## ⚠️ Upgrade your server to nedbd 2.8.6
+## ⚠️ Upgrade your server to nedbd 3.2.0
 
-This client talks to `nedbd`, so its durability comes from the server. **2.8.6 fixes three defects in
-2.8.5 and earlier** — a flush that hit a full disk silently discarded acknowledged writes, flush
-failures were unobservable, and `nedb-cli repair` could not actually rebuild a damaged id index.
+This client talks to `nedbd`, so its durability comes from the server. **Upgrade if you are on
+anything earlier than 3.2.0.**
+
+**3.2.0 — the embedded engine was pinning its own data directory.** The background flush ticker held
+a strong reference to the database in a loop that never exited, so the handle was never dropped: the
+exclusive data-dir `LOCK` was never released, reopening the same path in the same process failed with
+"locked by another process" naming your *own* pid, and every open leaked a thread and the whole
+database for the life of the process. Live in **2.8.5 through 3.1.0**.
+
+**2.8.6 fixed three defects in 2.8.5 and earlier** — a flush that hit a full disk silently discarded
+acknowledged writes, flush failures were unobservable, and `nedb-cli repair` could not actually
+rebuild a damaged id index.
 
 If a database ever returned rows and now returns none while `/verify` reports every object healthy,
 that is the lost-id-index symptom and it is recoverable:
@@ -101,7 +110,7 @@ NEDBD_DAG=1 NEDBD_CAST=1 nedbd --data ./data
 
 # Check health
 curl http://127.0.0.1:7070/health
-# {"ok":true,"version":"2.8.0","service":"nedbd","encrypted":true}
+# {"ok":true,"version":"3.2.0","service":"nedbd","encrypted":true}
 ```
 
 ---

{nedb_engine-3.0.0 → nedb_engine-3.2.1}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nedb-engine"
-version = "3.0.0"
+version = "3.2.1"
 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-3.0.0 → nedb_engine-3.2.1}/python/nedb/__init__.py

@@ -35,6 +35,10 @@ from .autoindex import AutoIndexDB
 from .concurrent import Sequencer
 from .wrap_redis import wrap_redis, WrappedRedis
 from .proof import verify_proof, fold_head
+from .wrap_sqlite import wrap_sqlite, WrappedSqlite
+from .wrap_mysql import wrap_mysql, WrappedMysql
+from .wrap_mongo import wrap_mongo, WrappedMongoClient
+from .wrap_postgresql import wrap_postgresql, WrappedPostgres
 
 try:  # compiled Rust core, present in platform wheels (PyO3 via maturin)
     from . import _native  # type: ignore
@@ -91,7 +95,11 @@ __all__ = [
     "MongoCompat", "MongoClient", "MongoError", "MongoUnsupportedError", "ObjectId",
     "AutoIndexDB", "Sequencer",
     "wrap_redis", "WrappedRedis",
+    "wrap_sqlite", "WrappedSqlite",
+    "wrap_mysql", "WrappedMysql",
+    "wrap_mongo", "WrappedMongoClient",
+    "wrap_postgresql", "WrappedPostgres",
     "verify_proof", "fold_head",
     "_native", "__has_native__",
 ]
-__version__ = "3.0.0"
+__version__ = "3.2.1"