nedb-engine 0.1.3 → 1.0.1

package/LICENSE

@@ -1,201 +1,65 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or Derivative
-          Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and do
-          not modify the License. You may add Your own attribution notices
-          within Derivative Works that You distribute, alongside or as an
-          addendum to the NOTICE text from the Work, provided that such
-          additional attribution notices cannot be construed as modifying
-          the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 Interchained
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+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.

package/README.md

@@ -7,6 +7,8 @@
 Replay-protected · idempotent · relational · filterable · sortable · searchable · provable.
 One Rust core → ships to **PyPI** and **npm** from a single source.
 
+**[Website & docs → eth-interchained.github.io/nedb](https://eth-interchained.github.io/nedb/)**
+
 </div>
 
 ---
@@ -18,6 +20,7 @@ Redis is fast because it's in-memory and simple — but relations are hand-rolle
 - **Faster-than-Redis latency where it's honest to claim it** — NEDB runs **embedded, in-process**, so point reads pay *no socket hop*. The networked server (`nedbd`, RESP-compatible) competes on the Rust core's merits.
 - **Replay protection + idempotency in the core, not the app.** Every write carries a strictly-monotonic per-client nonce and an optional idempotency key. Retries are no-ops; stale/out-of-order ops are rejected. This is built into one **hash-chained, append-only log**.
 - **Time-travel.** Read the database *exactly as it existed* at any past sequence — `AS OF seq`. Debugging, audit, MVCC snapshots, and deterministic replay all fall out of the same log.
+- **Durable persistence, Redis-style.** Point a database at a path and every op is appended to the hash-chained log on disk (and `fsync`'d); it reloads by replaying that log on open. It's exactly Redis's AOF model — except the append-only log is the *same tamper-evident chain* the engine already trusts, so `verify()` and `AS OF` hold across restarts and the log is never rewritten.
 - **First-class relations.** Adjacency-list graph edges with O(1) traversal — *and the graph time-travels too*.
 - **Filter / sort / search.** Equality, ordered, and full-text inverted indexes, maintained incrementally.
 - **git-style files with maximum compression.** Content-defined chunking + content-addressed dedup + temperature tiers (fast warm codec, max-ratio cold archival). Every file version has a Merkle root you can **anchor on-chain**.
@@ -32,13 +35,14 @@ Redis is fast because it's in-memory and simple — but relations are hand-rolle
 git clone https://github.com/Eth-Interchained/nedb && cd nedb
 pip install -e .                 # pure-Python reference; no toolchain needed
 python3 examples/demo.py         # see every feature
-python3 tests/test_nedb.py       # 10/10 invariants
+python3 tests/test_nedb.py       # 11/11 invariants
 ```
 
 ```python
 from nedb import NEDB
 
-db = NEDB()
+db = NEDB("./mydata")            # durable: append-only log on disk, reloads on open
+# db = NEDB()                    # (no path = purely in-memory)
 db.create_index("users", "status", "eq")
 db.create_index("users", "age", "ordered")
 db.create_index("users", "bio", "search")
@@ -67,8 +71,63 @@ db.get("users", "alice", as_of=s)["city"]      # -> "Austin"
 # git-style files with Cascade compression + provable history
 v1 = db.put_file("notes.txt", open("notes.txt","rb").read())
 db.file_root("notes.txt", v1)                  # Merkle root — anchorable on ITC
+
+# Durable + provable across restarts
+db.close()
+db = NEDB("./mydata")                          # replays the log on open
+assert db.verify()                             # the hash chain is intact
+db.get("users", "alice", as_of=s)["city"]      # AS OF still works -> "Austin"
+```
+
+---
+
+## Persistence
+
+NEDB persists the way Redis does — by writing the operations, not by dumping pages — because the engine's whole thesis is that **state is a pure function of the log**.
+
+- `NEDB(path)` opens a **durable** database in a directory. Every op is appended to `log.aof` (one JSON line) and `fsync`'d; index configuration is snapshotted to `meta.json`. On open, NEDB replays the log to rebuild state.
+- `NEDB()` with no path is **in-memory** (unchanged).
+- The append-only log is the **same hash-chained, tamper-evident chain** that powers idempotency, replay protection, and time-travel — so `verify()`, `AS OF`, relations, and the anchorable head all survive a restart. The log is **never rewritten**, so the chain (and its commitment) stays provable.
+
+```python
+db = NEDB("./mydata")
+db.put("users", "alice", {"name": "Alice", "status": "active"})
+db.close()                       # flush + fsync
+
+again = NEDB("./mydata")         # replays log.aof
+assert again.verify()            # chain intact across the restart
+again.get("users", "alice")      # -> {"name": "Alice", ...}
 ```
 
+> Snapshotting (an RDB-style fast-load checkpoint that keeps the AOF intact) and Rust-core parity are tracked on the roadmap.
+
+---
+
+## nedbd — run NEDB as a server
+
+For client/server setups (multiple apps, a remote admin UI like NEDB Studio, or just keeping the database in its own process), `pip install nedb-engine` ships a daemon. It runs the engine as a long-lived process and serves an HTTP/JSON API; each named database is a durable `NEDB(path)` held open in memory. Connect to it the way you'd connect to Redis or Postgres — over a URL.
+
+```bash
+nedbd                       # http://127.0.0.1:7070, data in ./nedb-data
+# config via env: NEDBD_HOST, NEDBD_PORT, NEDBD_DATA, NEDBD_TOKEN (optional bearer auth)
+```
+
+```bash
+# create a database (optionally seeded with indexes / rows / links)
+curl -X POST localhost:7070/v1/databases -d '{"name":"shop","init":{
+  "indexes":[["users","status","eq"]],
+  "seed":{"users":[{"id":"u1","name":"Ada","status":"active"}]}}}'
+
+# query it (real NQL, real engine)
+curl -X POST localhost:7070/v1/databases/shop/query -d '{"nql":"FROM users WHERE status = \"active\""}'
+
+# write, verify, time-travel — all server-side on the durable log
+curl -X POST localhost:7070/v1/databases/shop/put   -d '{"coll":"users","id":"u2","doc":{"name":"Bo"}}'
+curl       localhost:7070/v1/databases/shop/verify
+```
+
+API: `GET /health` · `GET|POST /v1/databases` · `GET|DELETE /v1/databases/<name>` · `POST …/query` · `POST …/put` · `POST …/index` · `POST …/link` · `DELETE …/rows/<coll>/<id>` · `GET …/verify` · `GET …/log`. Databases persist across daemon restarts (the engine replays its append-only log on open).
+
 ---
 
 ## NQL — the NEDB Query Language
@@ -87,18 +146,27 @@ FROM <collection>
 
 ---
 
-## What's measured (reference engine, pure Python, 2 vCPU)
+## What's measured (v0.4.1 · pure Python · Linux x86_64)
 
-| Operation | Result |
-|---|---|
-| GET (embedded, in-process) | **~1.2M ops/s** (~800 ns/op) |
-| SET (logged + indexed) | ~77K ops/s |
-| Indexed query latency | ~75 µs |
-| File compression — warm (zlib stand-in) | **39.9×** |
-| File compression — cold (LZMA archival) | **88.9×** |
-| Cross-version dedup | 20 of 22 chunks reused on edit |
+Numbers from `python3 bench/benchmarks.py` — reproducible, not cherry-picked.
+Full results in [`bench/RESULTS.md`](bench/RESULTS.md).
 
-The reference engine proves the **architecture**. The Rust core (`rust/`) is the speed target — see `bench/bench_redis.py` for the embedded-vs-Redis harness.
+| Operation | Throughput | Latency |
+|---|---|---|
+| GET (embedded, in-process) | **1.30M/s** | 0.77 µs |
+| GET AS OF (time-travel) | 997K/s | 1.00 µs |
+| PUT (logged, no index) | 63.7K/s | 15.7 µs |
+| PUT durable (AOF + fsync) | 7.0K/s | 143 µs |
+| QUERY: eq filter, eq index | **1.42M/s** | 0.71 µs |
+| QUERY: eq filter, no index (scan) | 515K/s | 1.94 µs |
+| QUERY: SEARCH (inverted index) | 467K/s | 2.14 µs |
+| SQL SELECT → NQL (adapter) | 1.70M/s | 0.59 µs |
+| AutoIndexDB wrapper overhead | ~0% | 0.54 µs |
+| File compression — warm | **39.9×** | — |
+| File compression — cold (LZMA) | **88.9×** | — |
+| Cross-version dedup | 20 of 22 chunks | — |
+
+The reference engine proves the **architecture**. Run `python3 bench/benchmarks.py --redis` to compare against Redis TCP on your own machine. The Rust core (`rust/`) is the future speed target.
 
 ---
 
@@ -116,7 +184,7 @@ The reference engine proves the **architecture**. The Rust core (`rust/`) is the
    (time-travel)  (graph, AS OF)    eq/ordered/search  CDC+dedup+tiers, Merkle roots
 ```
 
-One Rust core (`nedb-core`) → **PyO3** wheels (PyPI) and **napi-rs** binaries (npm), plus a future `nedbd` server (RESP-compatible) and a WASM build for browser/edge.
+PyPI ships a **universal pure-Python wheel** (`pip install nedb-engine` works on every platform/Python, and includes the `nedbd` server) — the engine, persistence, and daemon are all pure Python. npm ships **napi-rs** native addons. Native PyO3 acceleration for PyPI is additive/roadmap (the public API is identical with or without it). A RESP-compatible `nedbd` wire protocol and a WASM build are also on the roadmap.
 
 Full design: [`docs/SPEC.md`](docs/SPEC.md).
 
@@ -137,12 +205,31 @@ docs/SPEC.md     architecture specification
 ## Roadmap
 
 - [x] Reference engine: log, MVCC, relations, indexes, NQL, Cascade, Merkle
-- [ ] Rust core parity + criterion benches + `cargo test`
-- [ ] PyO3 wheels + napi-rs binaries published on tag
-- [ ] `nedbd` server: RESP-compatible + native protocol
+- [x] Durable persistence: append-only log (AOF) on disk + replay-on-open; `verify()` / `AS OF` survive restarts
+- [ ] RDB-style snapshot checkpoint (fast load) that keeps the AOF chain intact
+- [ ] Rust core parity (persistence in `nedb._native`) + criterion benches + `cargo test`
+- [x] Universal pure-Python wheel + sdist on PyPI (installs everywhere; ships the `nedbd` command); napi-rs binaries on npm
+- [ ] Additive native PyO3 acceleration wheels for PyPI (optional speed; same API)
+- [x] `nedbd` server: HTTP/JSON daemon — durable, multi-database; `pip install` ships the `nedbd` command
+- [ ] `nedbd`: RESP-compatible wire protocol + native protocol
 - [ ] Similarity-picked deltas + schema-aware columnar transforms
 - [ ] On-chain (ITC) root anchoring; WASM build
 
+## NEDB Studio
+
+The agentic, prompt-to-database GUI for NEDB — natural language → schema, NQL, seed data, and Python/Node snippets — lives in its own repo: **[Eth-Interchained/nedb-studio](https://github.com/Eth-Interchained/nedb-studio)** (Portal-powered, GPLv3).
+
 ## License
 
-Apache-2.0. Part of the [Interchained](https://github.com/interchained) ecosystem.
+Apache-2.0 · © INTERCHAINED, LLC — [interchained.org](https://interchained.org). Built with [AiAssist](https://aiassist.net).
+
+---
+
+## Authors
+
+Built by **[Mark Allen Evans Jr.](https://interchained.org)** (INTERCHAINED, LLC) with **Claude Sonnet 4.6** on [Hyperagent](https://hyperagent.com/refer/J2G6TCD7).
+
+> *"Take one idea, turn it into an LP, then an app, then a system, then a platform, then infrastructure that is irreplaceable."*
+
+[![Built with Hyperagent](https://img.shields.io/badge/Built%20with-Hyperagent-6366f1?style=flat-square&logo=data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIxMiIgZmlsbD0id2hpdGUiLz48L3N2Zz4=)](https://hyperagent.com/refer/J2G6TCD7)
+

package/index.d.ts

@@ -4,13 +4,34 @@
 /* auto-generated by NAPI-RS */
 
 export declare class NedbCore {
+  /** Create an in-memory database. */
   constructor()
-  /** Auto-nonce put. `doc_json` is a JSON object string. */
-  put(coll: string, id: string, docJson: string): number
-  /** Replay-protected, idempotent put with explicit client/nonce/idem. */
-  putChecked(coll: string, id: string, docJson: string, client: string, nonce: number, idem?: string | undefined | null): number
+  /** Open a durable database at `path` (AOF persistence). */
+  static open(path: string): NedbCore
+  createIndex(coll: string, field: string, kind: string): void
+  /** Auto-nonce put. `doc_json` is a JSON object string. Returns the stored doc. */
+  put(coll: string, id: string, docJson: string): string
+  /** Full put with optional client / nonce / idempotency key. */
+  putEx(coll: string, id: string, docJson: string, client?: string | undefined | null, nonce?: bigint | undefined | null, idem?: string | undefined | null): string
+  delete(coll: string, id: string): void
+  deleteEx(coll: string, id: string, client?: string | undefined | null, nonce?: bigint | undefined | null, idem?: string | undefined | null): void
+  link(frm: string, rel: string, to: string): void
+  unlink(frm: string, rel: string, to: string): void
   get(coll: string, id: string): string | null
-  getAsOf(coll: string, id: string, seq: number): string | null
-  head(): string
+  /** Time-travel: return the document as it was at sequence `as_of`. */
+  getAsOf(coll: string, id: string, asOf: bigint): string | null
+  /**
+   * Execute an NQL query string. Returns an array of JSON document strings.
+   * Full grammar supported: WHERE, ORDER BY, LIMIT, GROUP BY, TRAVERSE,
+   * SEARCH, AS OF, VALID AS OF, TRACE caused_by.
+   */
+  query(nql: string): Array<string>
+  neighbors(frm: string, rel: string): Array<string>
+  neighborsAsOf(frm: string, rel: string, asOf: bigint): Array<string>
+  inbound(to: string, rel: string): Array<string>
+  inboundAsOf(to: string, rel: string, asOf: bigint): Array<string>
   verify(): boolean
+  head(): string
+  seq(): bigint
+  flush(): void
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nedb-engine",
-  "version": "0.1.3",
-  "description": "NEDB — a versioned, self-compressing, time-traveling embedded database (replay-protected, idempotent, relational, searchable). Native core via napi-rs.",
+  "version": "1.0.1",
+  "description": "NEDB — hash-chained, time-traveling, bi-temporal embedded database with Rust native core. SQL, Redis, MongoDB adapters. Causal Write Provenance. RESP2 wire protocol.",
   "main": "index.js",
   "types": "index.d.ts",
   "files": ["index.js", "index.d.ts", "*.node", "README.md", "LICENSE"],
@@ -11,8 +11,8 @@
     "url": "git+https://github.com/Eth-Interchained/nedb.git"
   },
   "keywords": [
-    "database", "embedded", "mvcc", "time-travel", "versioning",
-    "compression", "dedup", "graph", "search", "redis", "git", "napi-rs"
+    "database", "embedded", "mvcc", "time-travel", "bi-temporal", "causal-provenance",
+    "tamper-evident", "hash-chain", "versioning", "napi-rs", "rust", "nedb"
   ],
   "engines": { "node": ">= 16" },
   "napi": {