nitrodb 2.4.3__tar.gz

nitrodb-2.4.3/.gitignore

@@ -0,0 +1,24 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+build/
+dist/
+.venv/
+
+# Rust
+/rust/target/
+**/*.rs.bk
+Cargo.lock
+
+# Node / napi
+node_modules/
+*.node
+npm/
+
+# misc
+.DS_Store
+
+# Ephemeral maturin staging copy (CI stages python/nedb here before build)
+rust/crates/nedb-py/python/

nitrodb-2.4.3/LICENSE

@@ -0,0 +1,65 @@
+Business Source License 1.1
+
+Licensor: Interchained LLC, VibeCode 101, and/or the applicable copyright holders of NEDB
+
+Licensed Work: NEDB, including all source code, documentation, examples, tests, build scripts, specifications, APIs, SDKs, packages, binaries, and derivative works distributed from or based on the NEDB repository.
+
+Copyright: Copyright (c) 2026 Interchained LLC, VibeCode 101, and contributors. All rights reserved.
+
+Change Date: Four years after the first publicly available distribution of each specific version of the Licensed Work under this License.
+
+Change License: GNU Affero General Public License v3.0 or later.
+
+Additional Use Grant:
+
+You may use the Licensed Work only for non-production purposes, including evaluation, development, testing, research, local experimentation, security review, benchmarking, and personal learning.
+
+No production use is granted automatically.
+
+For clarity, the following uses are not permitted unless you have prior written permission from the Licensor:
+
+1. Using the Licensed Work in production.
+2. Using the Licensed Work to store, process, serve, index, replicate, query, or manage production data.
+3. Offering the Licensed Work, or any derivative work, as a hosted, managed, embedded, bundled, white-labeled, commercial, paid, revenue-generating, or customer-facing product or service.
+4. Offering database-as-a-service, storage-as-a-service, cache-as-a-service, search-as-a-service, analytics-as-a-service, AI-memory-as-a-service, agent-memory-as-a-service, blockchain-indexing-as-a-service, or any substantially similar service using the Licensed Work.
+5. Using the Licensed Work to compete with NEDB, Interchained LLC, VibeCode 101, AiAssist Secure, or any affiliated product, service, infrastructure platform, database engine, AI runtime, agent platform, or hosted developer infrastructure.
+6. Embedding the Licensed Work into commercial software, SaaS products, internal business systems, enterprise systems, hosted infrastructure, blockchain infrastructure, AI-agent infrastructure, or customer deliverables.
+7. Removing, hiding, modifying, or misrepresenting this License, copyright notices, attribution notices, authorship notices, repository references, or licensing notices.
+8. Circumventing license checks, access controls, paid licensing requirements, commercial-use restrictions, attribution requirements, or technical protections included with the Licensed Work.
+9. Using the Licensed Work in a way that implies endorsement, partnership, sponsorship, certification, or approval by the Licensor without written permission.
+10. Reselling, relicensing, sublicensing, renting, leasing, or otherwise commercially exploiting the Licensed Work except as expressly authorized in writing.
+
+Additional production, commercial, hosted, enterprise, embedded, OEM, resale, white-label, managed-service, competitive, or otherwise restricted use grants are available only by separate written permission from the Licensor.
+
+Written permission must be obtained from at least one of the following authorized licensing contacts:
+
+[founders@vibecode-101.com](mailto:founders@vibecode-101.com)
+[dev@interchained.org](mailto:dev@interchained.org)
+
+Permission is valid only if it is expressly granted in writing by an authorized representative of the Licensor and specifically identifies the permitted use, scope, duration, parties, and any applicable commercial terms.
+
+A general email conversation, informal message, pull request, issue comment, social media message, verbal discussion, repository access, package download, or contribution acceptance does not create a production, commercial, hosted, enterprise, resale, or competitive use license.
+
+Terms:
+
+The Licensor hereby grants you the right to copy, modify, create derivative works, redistribute, and make non-production use of the Licensed Work. The Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly available distribution of a specific version of the Licensed Work under this License, whichever comes first, the Licensor hereby grants you rights under the terms of the Change License, and the rights granted in the paragraph above terminate.
+
+If your use of the Licensed Work does not comply with the requirements currently in effect as described in this License, you must purchase or obtain a separate commercial license from the Licensor, its affiliated entities, or authorized resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works of the Licensed Work, are subject to this License. This License applies separately for each version of the Licensed Work, and the Change Date may vary for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy of the Licensed Work. If you receive the Licensed Work in original or modified form from a third party, the terms and conditions set forth in this License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically terminate your rights under this License for the current and all other versions of the Licensed Work.
+
+This License does not grant you any right in any trademark, service mark, trade name, logo, domain name, brand identity, product name, project name, or other identifier of Licensor or its affiliates, except as expressly required to preserve legally required notices.
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, TITLE, SECURITY, ACCURACY, AVAILABILITY, DATA INTEGRITY, PERFORMANCE, AND FITNESS FOR PRODUCTION USE.
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, LICENSOR SHALL NOT BE LIABLE FOR ANY CLAIM, DAMAGES, LOSSES, COSTS, EXPENSES, BUSINESS INTERRUPTION, LOST PROFITS, LOST REVENUE, LOST DATA, SECURITY INCIDENTS, SERVICE OUTAGES, OR OTHER LIABILITY ARISING FROM OR RELATED TO THE LICENSED WORK OR YOUR USE OF THE LICENSED WORK.
+
+Notice:
+
+The Business Source License is not an Open Source license. However, each version of the Licensed Work will become available under the Change License on the applicable Change Date, or on the fourth anniversary of the first publicly available distribution of that version under this License, whichever comes first.

nitrodb-2.4.3/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: nitrodb
+Version: 2.4.3
+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
+Author: Eth-Interchained
+License: GPL-3.0-or-later
+License-File: LICENSE
+Keywords: compression,database,dedup,embedded,git,graph,mvcc,persistence,redis,search,server,time-travel,versioning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database :: Database Engines/Servers
+Requires-Python: >=3.8
+Requires-Dist: pycryptodome>=3.19
+Provides-Extra: encryption
+Requires-Dist: cryptography>=41; extra == 'encryption'
+Description-Content-Type: text/markdown
+
+<h1 align="center">⚡ nitroDB</h1>
+<p align="center"><b>The embedded database that goes brrr.</b></p>
+<p align="center"><i>Stupid-fast, append-only, zero-server storage you drop into your app and forget about.</i></p>
+
+---
+
+```
+63,400 writes/sec        1,340,000 point reads/sec        one fsync per batch
+```
+
+nitroDB is a **tiny, blazing-fast, in-process** datastore. No daemon. No schema migrations. No 400 MB of dependencies. Just `import` it and start flooding it with data — it keeps up.
+
+## Why people can't shut up about it
+
+- 🏎️ **Fast where it counts.** Append-only + group-commit: one `fsync` per *batch*, not per record. Bigger batches get **cheaper per item**. Throughput goes *up* under load, not down.
+- 🪶 **Featherweight.** In-process, near-zero footprint. Boots instantly, runs in memory, persists when you say so.
+- 🧷 **Durable, not fragile.** Every write is hash-chained and the log replays clean on open — crash-safe without the ceremony.
+- 🚀 **Scales with your ambition.** Same engine family as **CryptoDB** — flip on the content-addressed DAG the day you need time-travel and tamper-evidence. Start fast, grow powerful.
+
+## Install (10 seconds, tops)
+
+```bash
+npm install nitrodb     #  pip install nitrodb     #  cargo add nitrodb
+```
+
+```js
+import { NedbCore } from "nitrodb";
+const db = new NedbCore();
+console.time("100k");
+for (let i = 0; i < 100_000; i++) db.put("events", String(i), JSON.stringify({ t: Date.now(), i }));
+db.flush();              // one durable group-commit for the whole burst
+console.timeEnd("100k"); // …go on, time it.
+```
+
+## Built for
+
+Edge & embedded · high-throughput event logging · local-first apps · game state · CLIs · **anywhere "just make it fast" beats "stand up a server."**
+
+<p align="center"><b>If nitroDB just saved your afternoon, ⭐ it and tell a friend.</b></p>
+
+---
+
+<sub>nitroDB is a distribution of the <b>NEDB</b> engine, tuned for speed + simplicity (benchmarks measured on commodity hardware — yours will vary). Engine development: <a href="https://github.com/Eth-Interchained/nedb">Eth-Interchained/nedb</a>. © Interchained LLC.</sub>

nitrodb-2.4.3/README.md

@@ -0,0 +1,43 @@
+<h1 align="center">⚡ nitroDB</h1>
+<p align="center"><b>The embedded database that goes brrr.</b></p>
+<p align="center"><i>Stupid-fast, append-only, zero-server storage you drop into your app and forget about.</i></p>
+
+---
+
+```
+63,400 writes/sec        1,340,000 point reads/sec        one fsync per batch
+```
+
+nitroDB is a **tiny, blazing-fast, in-process** datastore. No daemon. No schema migrations. No 400 MB of dependencies. Just `import` it and start flooding it with data — it keeps up.
+
+## Why people can't shut up about it
+
+- 🏎️ **Fast where it counts.** Append-only + group-commit: one `fsync` per *batch*, not per record. Bigger batches get **cheaper per item**. Throughput goes *up* under load, not down.
+- 🪶 **Featherweight.** In-process, near-zero footprint. Boots instantly, runs in memory, persists when you say so.
+- 🧷 **Durable, not fragile.** Every write is hash-chained and the log replays clean on open — crash-safe without the ceremony.
+- 🚀 **Scales with your ambition.** Same engine family as **CryptoDB** — flip on the content-addressed DAG the day you need time-travel and tamper-evidence. Start fast, grow powerful.
+
+## Install (10 seconds, tops)
+
+```bash
+npm install nitrodb     #  pip install nitrodb     #  cargo add nitrodb
+```
+
+```js
+import { NedbCore } from "nitrodb";
+const db = new NedbCore();
+console.time("100k");
+for (let i = 0; i < 100_000; i++) db.put("events", String(i), JSON.stringify({ t: Date.now(), i }));
+db.flush();              // one durable group-commit for the whole burst
+console.timeEnd("100k"); // …go on, time it.
+```
+
+## Built for
+
+Edge & embedded · high-throughput event logging · local-first apps · game state · CLIs · **anywhere "just make it fast" beats "stand up a server."**
+
+<p align="center"><b>If nitroDB just saved your afternoon, ⭐ it and tell a friend.</b></p>
+
+---
+
+<sub>nitroDB is a distribution of the <b>NEDB</b> engine, tuned for speed + simplicity (benchmarks measured on commodity hardware — yours will vary). Engine development: <a href="https://github.com/Eth-Interchained/nedb">Eth-Interchained/nedb</a>. © Interchained LLC.</sub>

nitrodb-2.4.3/client/node/README.md

@@ -0,0 +1,192 @@
+# nedb-engine-client
+
+> TypeScript/JavaScript client for [nedbd](https://github.com/Eth-Interchained/nedb) — the NEDB server daemon.
+
+[![npm](https://img.shields.io/npm/v/nedb-engine-client?color=00d4ff)](https://www.npmjs.com/package/nedb-engine-client)
+[![License](https://img.shields.io/badge/license-GPL--3.0--or--later-818cf8)](https://github.com/Eth-Interchained/nedb/blob/master/LICENSE)
+
+Connect to any running `nedbd` instance from Node.js or the browser. No engine embedded, no native dependencies. Just fetch.
+
+---
+
+## Install
+
+```bash
+npm install nedb-engine-client
+```
+
+Requires Node.js ≥ 18 (uses native `fetch`). Works in modern browsers too.
+
+---
+
+## Quick start
+
+```typescript
+import { NedbClient } from "nedb-engine-client";
+
+const db = new NedbClient({ url: "http://127.0.0.1:7070", db: "mydb" });
+
+// Write a document
+await db.put("blocks", "618000", {
+    height: 618000,
+    hash: "000000000000000000024bead8df69990852c202db0e0097c1a12ea637d7e96d",
+    txCount: 2734,
+});
+
+// Query with NQL
+const rows = await db.query("FROM blocks ORDER BY height DESC LIMIT 10");
+
+// Time-travel: what did the DB look like at seq 100?
+const old = await db.query("FROM blocks AS OF 100 WHERE height > 600000");
+
+// Bi-temporal: what was true on 2024-06-15?
+const valid = await db.query('FROM policy VALID AS OF "2024-06-15"');
+
+// BLAKE2b Merkle head — changes on every write, anchorable
+const head = await db.head();
+
+// Tamper-evidence check across all objects
+const report = await db.verify();
+console.assert(report.ok, "tamper detected!");
+```
+
+---
+
+## nedbd — start the server
+
+```bash
+npm install nedb-engine   # or: pip install nedb-engine
+
+# v2 DAG engine (recommended — instant cold start, tamper-evident)
+NEDBD_DAG=1 nedbd --data ./data
+
+# Check health
+curl http://127.0.0.1:7070/health
+# {"ok":true,"version":"2.0.8","service":"nedbd","encrypted":true}
+```
+
+---
+
+## API reference
+
+### Constructor
+
+```typescript
+const db = new NedbClient({
+    url:            "http://127.0.0.1:7070",  // nedbd base URL
+    db:             "mydb",                    // database name
+    token:          "secret",                  // bearer auth (optional)
+    autoCreate:     true,                      // create DB on first write
+    readTimeoutMs:  3_000,                     // query timeout
+    writeTimeoutMs: 30_000,                    // write timeout
+});
+```
+
+### Writes
+
+| Method | Description |
+|--------|-------------|
+| `db.put(coll, id, doc, opts?)` | Write a document |
+| `db.delete(coll, id)` | Tombstone delete (history preserved in DAG) |
+| `db.batch(ops)` | Batch put/del in one HTTP round-trip |
+| `db.createIndex(coll, field)` | Create sorted index for ORDER BY |
+
+**Put options:**
+
+```typescript
+await db.put("claims", "c1", { fact: "..." }, {
+    causedBy:   ["abc123hash"],  // DAG causal provenance
+    validFrom:  "2024-01-01",    // bi-temporal valid window
+    validTo:    "2024-12-31",
+    evidence:   "sensor-42",     // human-readable provenance note
+    confidence: 0.95,            // confidence score 0–1
+    idem:       "dedup-key",     // idempotency key
+});
+```
+
+### Reads
+
+| Method | Description |
+|--------|-------------|
+| `db.get(coll, id)` | Fetch current version of a document |
+| `db.query(nql)` | NQL query → array of objects |
+| `db.queryFull(nql)` | NQL query → full response (rows + seq + head) |
+
+### NQL — NEDB Query Language
+
+```
+FROM <collection>
+  [AS OF <seq>]                  transaction time (when was it written?)
+  [VALID AS OF "<date>"]         valid time (when was it true in the world?)
+  [WHERE field = value [AND ...]] op: = != < <= > >=
+  [ORDER BY field [DESC]]
+  [LIMIT n]
+  [GROUP BY field COUNT|SUM|AVG|MIN|MAX]
+  [TRACE caused_by [REVERSE]]    causal graph traversal
+  [SEARCH "text"]                full-text search
+```
+
+### Integrity
+
+| Method | Description |
+|--------|-------------|
+| `db.verify()` | BLAKE2b tamper-evidence check across all objects |
+| `db.head()` | Current Merkle root — changes on every write |
+| `db.seq()` | Current global sequence number |
+| `db.log(limit?)` | Recent write log |
+| `db.checkpoint()` | Explicit checkpoint (no-op on v2 DAG) |
+
+### Server management
+
+| Method | Description |
+|--------|-------------|
+| `db.health()` | Server health — version, databases, encryption |
+| `db.ping()` | Boolean reachability check |
+| `db.listDatabases()` | All databases on this server |
+| `db.createDatabase()` | Create this database explicitly |
+| `db.dropDatabase()` | Drop this database (irreversible) |
+
+---
+
+## Error handling
+
+```typescript
+import { NedbClient, NedbError } from "nedb-engine-client";
+
+try {
+    await db.put("coll", "id", { data: "value" });
+} catch (e) {
+    if (e instanceof NedbError) {
+        console.error(`HTTP ${e.status}: ${e.message}`);
+    }
+}
+```
+
+Queries on missing collections return `[]` rather than throwing — resilient by default.
+
+---
+
+## Batch writes
+
+```typescript
+await db.batch([
+    { op: "put", coll: "blocks", id: "618001", doc: { height: 618001 } },
+    { op: "put", coll: "blocks", id: "618002", doc: { height: 618002 } },
+    { op: "del", coll: "blocks", id: "617999" },
+]);
+```
+
+One HTTP request, multiple ops — best throughput for bulk ingestion.
+
+---
+
+## Links
+
+- **Engine:** [pip install nedb-engine](https://pypi.org/project/nedb-engine/) · [npm install nedb-engine](https://www.npmjs.com/package/nedb-engine)
+- **Python client:** [pip install nedb-engine-client](https://pypi.org/project/nedb-engine-client/)
+- **Source:** [github.com/Eth-Interchained/nedb](https://github.com/Eth-Interchained/nedb)
+- **Studio:** [studio.interchained.org](https://studio.interchained.org)
+
+---
+
+© [INTERCHAINED, LLC](https://interchained.org) · GPL-3.0-or-later · Built with [Hyperagent](https://hyperagent.com/refer/J2G6TCD7)

nitrodb-2.4.3/client/python/README.md

@@ -0,0 +1,191 @@
+# nedb-engine-client
+
+> Async Python client for [nedbd](https://github.com/Eth-Interchained/nedb) — the NEDB server daemon.
+
+[![PyPI](https://img.shields.io/pypi/v/nedb-engine-client?color=6366f1)](https://pypi.org/project/nedb-engine-client/)
+[![Python](https://img.shields.io/pypi/pyversions/nedb-engine-client?color=34d399)](https://pypi.org/project/nedb-engine-client/)
+[![License](https://img.shields.io/badge/license-GPL--3.0--or--later-818cf8)](https://github.com/Eth-Interchained/nedb/blob/master/LICENSE)
+
+Connect to any running `nedbd` instance — local or remote — with a clean async API. No engine code embedded, no Rust toolchain required. Just HTTP.
+
+---
+
+## Install
+
+```bash
+pip install nedb-engine-client
+```
+
+Requires Python ≥ 3.8 and `httpx`.
+
+---
+
+## Quick start
+
+```python
+import asyncio
+from nedb_client import NedbClient
+
+async def main():
+    async with NedbClient("http://127.0.0.1:7070", db="mydb") as db:
+
+        # Write a document
+        await db.put("blocks", "618000", {
+            "height": 618000,
+            "hash": "000000000000000000024bead8df69990852c202db0e0097c1a12ea637d7e96d",
+            "tx_count": 2734,
+        })
+
+        # Query with NQL
+        rows = await db.query("FROM blocks ORDER BY height DESC LIMIT 10")
+
+        # Time-travel: what did the DB look like at seq 100?
+        old = await db.query("FROM blocks AS OF 100 WHERE height > 600000")
+
+        # Bi-temporal: what was true on 2024-06-15?
+        valid = await db.query('FROM policy VALID AS OF "2024-06-15"')
+
+        # Causal trace: why was this written?
+        trace = await db.query("FROM blocks TRACE caused_by")
+
+        # BLAKE2b Merkle head — changes on every write, anchorable
+        head = await db.head()
+        print(f"head: {head}")
+
+        # Tamper-evidence check across all objects
+        report = await db.verify()
+        assert report["ok"], "tamper detected!"
+
+asyncio.run(main())
+```
+
+---
+
+## nedbd — start the server
+
+```bash
+pip install nedb-engine
+
+# v1 AOF engine (default)
+nedbd --data ./data
+
+# v2 DAG engine (recommended — instant cold start, tamper-evident)
+NEDBD_DAG=1 nedbd --data ./data
+
+# With AES-256-GCM encryption
+NEDBD_DAG=1 NEDB_TMK=<32-byte-hex> nedbd --data ./data
+
+# Check health
+curl http://127.0.0.1:7070/health
+# {"ok":true,"version":"2.0.8","service":"nedbd","encrypted":true}
+```
+
+---
+
+## API reference
+
+### Client lifecycle
+
+```python
+# Async context manager (recommended)
+async with NedbClient(url, db=name, token=token) as db:
+    ...
+
+# Manual
+db = NedbClient(url="http://127.0.0.1:7070", db="mydb", token="secret")
+await db.open()
+await db.close()
+```
+
+### Writes
+
+| Method | Description |
+|--------|-------------|
+| `await db.put(coll, id, doc, **opts)` | Write a document |
+| `await db.delete(coll, id)` | Tombstone delete (history preserved in DAG) |
+| `await db.batch(ops)` | Batch put/del in one HTTP round-trip |
+| `await db.create_index(coll, field)` | Create sorted index for ORDER BY |
+
+**Put options:**
+
+```python
+await db.put("claims", "c1", {"fact": "..."}, 
+    caused_by=["abc123hash"],   # DAG causal provenance
+    valid_from="2024-01-01",    # bi-temporal valid window
+    valid_to="2024-12-31",
+    evidence="sensor-42",       # human-readable provenance note
+    confidence=0.95,            # confidence score 0–1
+    idem="dedup-key",           # idempotency key
+)
+```
+
+### Reads
+
+| Method | Description |
+|--------|-------------|
+| `await db.get(coll, id)` | Fetch current version of a document |
+| `await db.query(nql)` | NQL query → list of dicts |
+| `await db.query_full(nql)` | NQL query → full response (rows + seq + head) |
+
+### NQL — NEDB Query Language
+
+```
+FROM <collection>
+  [AS OF <seq>]                  transaction time (when was it written?)
+  [VALID AS OF "<date>"]         valid time (when was it true in the world?)
+  [WHERE field = value [AND ...]] op: = != < <= > >=
+  [ORDER BY field [DESC]]
+  [LIMIT n]
+  [GROUP BY field COUNT|SUM|AVG|MIN|MAX]
+  [TRACE caused_by [REVERSE]]    causal graph traversal
+  [SEARCH "text"]                full-text search
+```
+
+### Integrity
+
+| Method | Description |
+|--------|-------------|
+| `await db.verify()` | BLAKE2b tamper-evidence check across all objects |
+| `await db.head()` | Current Merkle root — changes on every write |
+| `await db.seq()` | Current global sequence number |
+| `await db.log(limit)` | Recent write log |
+| `await db.checkpoint()` | Explicit checkpoint (no-op on v2 DAG) |
+
+### Server management
+
+| Method | Description |
+|--------|-------------|
+| `await db.health()` | Server health — version, databases, encryption |
+| `await db.ping()` | Boolean reachability check |
+| `await db.list_databases()` | All databases on this server |
+| `await db.create_database()` | Create this database explicitly |
+| `await db.drop_database()` | Drop this database (irreversible) |
+
+---
+
+## Error handling
+
+```python
+from nedb_client import NedbClient, NedbError
+
+async with NedbClient("http://127.0.0.1:7070", db="mydb") as db:
+    try:
+        await db.put("coll", "id", {"data": "value"})
+    except NedbError as e:
+        print(f"HTTP {e.status}: {e.message}")
+```
+
+Queries on missing collections return `[]` rather than raising — resilient by default.
+
+---
+
+## Links
+
+- **Engine:** [pip install nedb-engine](https://pypi.org/project/nedb-engine/) · [npm install nedb-engine](https://www.npmjs.com/package/nedb-engine)
+- **JS/TS client:** [npm install nedb-engine-client](https://www.npmjs.com/package/nedb-engine-client)
+- **Source:** [github.com/Eth-Interchained/nedb](https://github.com/Eth-Interchained/nedb)
+- **Studio:** [studio.interchained.org](https://studio.interchained.org)
+
+---
+
+© [INTERCHAINED, LLC](https://interchained.org) · GPL-3.0-or-later · Built with [Hyperagent](https://hyperagent.com/refer/J2G6TCD7)

nitrodb-2.4.3/examples/mini-chain/README.md

@@ -0,0 +1,39 @@
+# NEDB Mini-Chain
+
+> The database where your data **is** a blockchain.
+
+A ~80-line runnable micro case-study for `nedb-engine`. It tells NEDB's whole
+story in one gamified console run — and uses the exact primitives
+(`caused_by` / `AS OF` / `verify`) that back the real ITC node (**itcd**),
+where NEDB replaces LevelDB as the block-index + chainstate.
+
+## Run
+
+```bash
+npm install nedb-engine
+node mini-chain.mjs            # default 5,000 blocks
+node mini-chain.mjs 50000      # crank it
+```
+
+## What it demonstrates
+
+| Step | NEDB feature | Why it matters |
+|------|--------------|----------------|
+| ⛏ Mine N blocks | content-addressed writes | one doc per block; hash-chained automatically |
+| ⚡ Read them back | indexed `get` | real writes/sec + reads/sec from *your* machine |
+| ⏳ Time-travel | `getAsOf(seq)` (MVCC) | read any block as it was at a past sequence |
+| 🧭 Provenance | `link` / `neighbors` (causal DAG) | walk a block's `prev` edge |
+| 🛡 Tamper-evidence | `verify()` (BLAKE2b) | corrupt a block on disk → `verify()` flips to `false` |
+
+The tamper step is **real**: it flips a byte in a block's on-disk object and
+re-opens the store — `verify()` catches the BLAKE2b mismatch. You can't fake
+history in NEDB.
+
+## Storage strategy
+
+One document per block in a `blocks` collection, keyed by height, each carrying
+`prev`. Time-travel, causal provenance, and tamper-proofing come **free** — no
+extra tables, no external indexer. That is the same model itcd uses for the ITC
+chain.
+
+*© Interchained LLC — GPL-3.0-or-later*

nitrodb-2.4.3/pyproject.toml

@@ -0,0 +1,51 @@
+# nedb-engine — pure-Python distribution. The engine, durable AOF persistence,
+# and the nedbd server are all pure Python, so we ship a universal py3-none-any
+# wheel + sdist that installs on every platform/Python with no toolchain. The
+# Rust core (rust/) remains for the napi (npm) addon and future native PyPI
+# acceleration, reintroduced additively; `nedb._native` already imports lazily
+# and the package works identically without it.
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "nitrodb"
+version = "2.4.3"
+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"
+license = { text = "GPL-3.0-or-later" }
+authors = [{ name = "Eth-Interchained" }]
+keywords = ["database", "embedded", "mvcc", "time-travel", "versioning",
+            "compression", "dedup", "graph", "search", "redis", "git", "persistence", "server"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Database :: Database Engines/Servers",
+]
+
+dependencies = [
+    # AES-256-GCM at-rest encryption (pycryptodome — pre-built wheels for all platforms
+    # including Windows MinGW, no cffi / C compiler required).
+    # Also accepted: cryptography>=41 (falls back automatically if pycryptodome absent).
+    "pycryptodome>=3.19",
+]
+
+[project.optional-dependencies]
+# Alternative crypto backend (for installations that already have cryptography).
+encryption = ["cryptography>=41"]
+
+[project.scripts]
+nedbd = "nedb.server:main"
+
+[project.urls]
+Homepage = "https://github.com/aiassistsecure/nedb"
+Repository = "https://github.com/aiassistsecure/nedb"
+
+[tool.hatch.build.targets.wheel]
+packages = ["python/nedb"]
+
+[tool.hatch.build.targets.sdist]
+include = ["python/nedb", "README.md", "LICENSE"]