nedb-engine 8.8.8 → 9.0.0

package/README.md

@@ -171,18 +171,25 @@ evaluator with no flag to set, the `nesql` CLI likewise.
 [![neSQL on crates.io](https://img.shields.io/crates/v/nesql?label=nesql%20·%20crates.io&color=a855f7)](https://crates.io/crates/nesql)
 [![neSQL on npm](https://img.shields.io/npm/v/nesql-engine?label=nesql-engine%20·%20npm&color=a855f7)](https://www.npmjs.com/package/nesql-engine)
 
-Those three badges read **0.0.1** next to an engine at 8.0.0, and that is
-deliberate rather than neglected. They are **reserved names**: each package loads,
-reports the vendored PostgreSQL release, and answers `is_release() == false`,
-because a package that imports cleanly and then lies is worse than one that is not
-published. The engine you actually install is `nedb-engine`. The
-[neSQL repository](https://github.com/Eth-Interchained/neSQL) holds the language —
-both halves of the grammar and the CLI's source, side by side.
+The three neSQL packages are **real and version-aligned with the engine** — the
+badges above are live registry state, not placeholders. They split by delivery
+path, not by function:
+
+| package | registry | what it is |
+|---|---|---|
+| [`nesql`](https://crates.io/crates/nesql) | crates.io | **the real CLI crate** — `cargo add nesql`, builds against the registry engine |
+| [`nesql`](https://pypi.org/project/nesql/) | PyPI | the language reference (vendored-grammar facts, clause extensions) |
+| [`nesql-engine`](https://www.npmjs.com/package/nesql-engine) | npm | the language reference |
+
+The [neSQL repository](https://github.com/Eth-Interchained/neSQL) is the language's
+home: the vendored PostgreSQL grammar with its licence intact, the CLI crate source,
+the NQL grammar reference, and the NEDB specs. And because the CLI is also staged
+into every platform build of the engine (below), **one install carries everything**:
 
 ### `nesql` — the CLI, and it speaks neSQL
 
-Ships inside `pip install nedb-engine` — no daemon, no port — and answers both
-halves of the language through **one** `query` command:
+Ships inside `pip install nedb-engine` — no daemon, no port, the compiled binary on
+your PATH — and answers both halves of the language through **one** `query` command:
 
 ```console
 $ nesql --db ./store query "SELECT who, total FROM orders ORDER BY total DESC"

package/index.d.ts

@@ -1,64 +1,64 @@
-// nedb-engine — public type surface.
-//
-// Runtime behavior (durable-mode auto-flush-on-exit) is added by the wrapper in
-// index.js; the type surface is exactly the generated native binding's.
-export * from './native';
-
-// ── wrap adapter family (wrap/*.js) ─────────────────────────────────────────
-
-/** Options accepted by every wrap_* constructor. */
-export interface WrapOptions {
-  /** Logical database name (default "default"). */
-  dbName?: string;
-  /** HTTP nedbd server (v1 AOF, `--dag` v2, `--dag-v3` v3). Overrides embedded DAG. */
-  nedbdUrl?: string;
-  /** Bearer token for nedbd (NEDBD_TOKEN on the server). */
-  nedbdToken?: string;
-  /** Durable DAG store directory (embedded mode). */
-  dagPath?: string;
-  /** 64-hex TMK → AES-256-GCM at-rest encryption (embedded DAG mode). */
-  dagTmk?: string;
-  /** Explicit NedbCore class (testing / custom builds). */
-  native?: unknown;
-}
-
-/** The `.nedb` attribute — full NEDB layer-2 API. */
-export interface NedbSurface {
-  register(pattern: string, collection: string, opts?: {
-    idExtractor?: (key: string) => string;
-    valueParser?: (raw: unknown) => Record<string, unknown>;
-    valueType?: 'string' | 'hash' | 'json';
-  }): NedbSurface;
-  backfill(opts?: { pattern?: string; collection?: string; batchSize?: number }): number;
-  shadowWrites: boolean;
-  readonly engineKind: 'dag-embedded' | 'nedbd-http' | 'aof-embedded';
-
-  put(coll: string, id: string, doc: Record<string, unknown>): Record<string, unknown>;
-  get(coll: string, id: string, asOf?: number): Record<string, unknown> | null;
-  query(nql: string): Array<Record<string, unknown>>;
-  createIndex(coll: string, field: string, kind?: string): void;
-  delete(coll: string, id: string): void;
-  link(frm: string, rel: string, to: string): void;
-  unlink(frm: string, rel: string, to: string): void;
-  neighbors(frm: string, rel: string, asOf?: number): string[];
-  inbound(to: string, rel: string, asOf?: number): string[];
-  verify(): boolean;
-  readonly head: string;
-  readonly seq: number;
-  checkpoint(): string;
-  /** DAG-native: latest node (null on non-DAG backends). */
-  tip(): Record<string, unknown> | null;
-  /** DAG-native: changefeed page, after_seq exclusive. */
-  since(afterSeq: number | bigint, limit?: number): {
-    nodes: Array<Record<string, unknown>>; from_seq: number; to_seq: number;
-    head_seq: number; has_more: boolean;
-  };
-  /** DAG-native: replication readiness. */
-  scanStatus(): { scan_complete: boolean; tip_seq: number; indexed_count: number; [k: string]: unknown };
-}
-
-export declare function wrapRedis<T extends object = object>(client: T, opts?: WrapOptions): T & { nedb: NedbSurface };
-export declare function wrapSqlite<T extends object = object>(conn: T, opts?: WrapOptions): T & { nedb: NedbSurface };
-export declare function wrapMysql<T extends object = object>(conn: T, opts?: WrapOptions): T & { nedb: NedbSurface };
-export declare function wrapPg<T extends object = object>(conn: T, opts?: WrapOptions): T & { nedb: NedbSurface };
-export declare function wrapMongo<T extends object = object>(client: T, opts?: WrapOptions): T & { nedb: NedbSurface };
+// nedb-engine — public type surface.
+//
+// Runtime behavior (durable-mode auto-flush-on-exit) is added by the wrapper in
+// index.js; the type surface is exactly the generated native binding's.
+export * from './native';
+
+// ── wrap adapter family (wrap/*.js) ─────────────────────────────────────────
+
+/** Options accepted by every wrap_* constructor. */
+export interface WrapOptions {
+  /** Logical database name (default "default"). */
+  dbName?: string;
+  /** HTTP nedbd server (v1 AOF, `--dag` v2, `--dag-v3` v3). Overrides embedded DAG. */
+  nedbdUrl?: string;
+  /** Bearer token for nedbd (NEDBD_TOKEN on the server). */
+  nedbdToken?: string;
+  /** Durable DAG store directory (embedded mode). */
+  dagPath?: string;
+  /** 64-hex TMK → AES-256-GCM at-rest encryption (embedded DAG mode). */
+  dagTmk?: string;
+  /** Explicit NedbCore class (testing / custom builds). */
+  native?: unknown;
+}
+
+/** The `.nedb` attribute — full NEDB layer-2 API. */
+export interface NedbSurface {
+  register(pattern: string, collection: string, opts?: {
+    idExtractor?: (key: string) => string;
+    valueParser?: (raw: unknown) => Record<string, unknown>;
+    valueType?: 'string' | 'hash' | 'json';
+  }): NedbSurface;
+  backfill(opts?: { pattern?: string; collection?: string; batchSize?: number }): number;
+  shadowWrites: boolean;
+  readonly engineKind: 'dag-embedded' | 'nedbd-http' | 'aof-embedded';
+
+  put(coll: string, id: string, doc: Record<string, unknown>): Record<string, unknown>;
+  get(coll: string, id: string, asOf?: number): Record<string, unknown> | null;
+  query(nql: string): Array<Record<string, unknown>>;
+  createIndex(coll: string, field: string, kind?: string): void;
+  delete(coll: string, id: string): void;
+  link(frm: string, rel: string, to: string): void;
+  unlink(frm: string, rel: string, to: string): void;
+  neighbors(frm: string, rel: string, asOf?: number): string[];
+  inbound(to: string, rel: string, asOf?: number): string[];
+  verify(): boolean;
+  readonly head: string;
+  readonly seq: number;
+  checkpoint(): string;
+  /** DAG-native: latest node (null on non-DAG backends). */
+  tip(): Record<string, unknown> | null;
+  /** DAG-native: changefeed page, after_seq exclusive. */
+  since(afterSeq: number | bigint, limit?: number): {
+    nodes: Array<Record<string, unknown>>; from_seq: number; to_seq: number;
+    head_seq: number; has_more: boolean;
+  };
+  /** DAG-native: replication readiness. */
+  scanStatus(): { scan_complete: boolean; tip_seq: number; indexed_count: number; [k: string]: unknown };
+}
+
+export declare function wrapRedis<T extends object = object>(client: T, opts?: WrapOptions): T & { nedb: NedbSurface };
+export declare function wrapSqlite<T extends object = object>(conn: T, opts?: WrapOptions): T & { nedb: NedbSurface };
+export declare function wrapMysql<T extends object = object>(conn: T, opts?: WrapOptions): T & { nedb: NedbSurface };
+export declare function wrapPg<T extends object = object>(conn: T, opts?: WrapOptions): T & { nedb: NedbSurface };
+export declare function wrapMongo<T extends object = object>(client: T, opts?: WrapOptions): T & { nedb: NedbSurface };

package/index.js

@@ -1,84 +1,84 @@
-// SPDX-FileCopyrightText: 2026 INTERCHAINED LLC
-// SPDX-License-Identifier: BUSL-1.1
-// NEDB · © 2026 INTERCHAINED LLC × Eth-Interchained × Vex (Claude Opus 5)
-
-'use strict';
-// nedb-engine — durable-mode auto-flush-on-exit wrapper.
-//
-// The native addon (generated napi binding in ./native.js) exposes `NedbCore`.
-// A durable `NedbCore.open(path)` buffers writes in the engine's id-index WAL and
-// only makes them durable on `flush()`; a hard exit (Ctrl+C, `SIGTERM` from an
-// orchestrator, `pm2 stop`) that never runs an explicit flush would lose writes
-// staged since the last flush.
-//
-// We close that gap the libuv-cooperative way — `process.on('SIGINT'|'SIGTERM'
-// |'exit', () => db.flush())` — NOT a C-level signal handler inside the addon,
-// which would clobber libuv's own signal machinery. In-memory databases
-// (`new NedbCore()`) are never armed; there is nothing to flush.
-//
-// Escape hatch: set NEDB_NO_EXIT_FLUSH=1 to leave signal handling entirely to
-// the host app (it can still call `db.flush()` itself).
-//
-// © INTERCHAINED LLC × Vex (Interchained AI fleet: GLM · Claude · Opus · Fable · GPT-6)
-const native = require('./native.js');
-
-const Native = native.NedbCore;
-
-// The napi class defines `open` as a NON-writable, NON-configurable static, so the
-// 2.5.x wrapper's `NedbCore.open = …` threw ("Cannot assign to read only property")
-// — and CI's `napi build` was overwriting this file with the generated loader
-// anyway, so the published package never carried the wrapper at all. Both fixed
-// in 2.8.5: wrap by SUBCLASS (an own static on the subclass shadows the parent's),
-// build with `--js native.js` so this file survives, and gate the publish on
-// `NedbCore.__exitFlushWrapped` (see test/durability.test.mjs).
-let NedbCore = Native;
-if (Native && typeof Native.open === 'function' && !Native.__exitFlushWrapped) {
-  // Durable handles opened in this process. Strong refs: a durable DB is meant to
-  // live for the process, and we must be able to flush it on the way out.
-  const live = new Set();
-  let armed = false;
-
-  const flushAll = () => {
-    for (const db of live) {
-      try {
-        db.flush();
-      } catch (_) {
-        // Best-effort on shutdown — never throw out of an exit handler.
-      }
-    }
-  };
-
-  const arm = () => {
-    if (armed || process.env.NEDB_NO_EXIT_FLUSH) return;
-    armed = true;
-    // 'exit' fires on normal termination; handlers must be synchronous, and
-    // db.flush() is a synchronous native call — so this is safe and sufficient
-    // for clean exits and uncaught-exception exits.
-    process.on('exit', flushAll);
-    // Registering a SIGINT/SIGTERM listener SUPPRESSES Node's default
-    // termination, so once we listen we own the exit: flush, then terminate with
-    // the conventional 128+signum status.
-    const onSignal = (signum) => () => {
-      flushAll();
-      process.exit(128 + signum);
-    };
-    process.on('SIGINT', onSignal(2));
-    process.on('SIGTERM', onSignal(15));
-  };
-
-  NedbCore = class NedbCore extends Native {
-    static open(path) {
-      const db = Native.open(path);
-      live.add(db);
-      arm();
-      return db;
-    }
-  };
-  // Mark so a re-require (or a wrapped re-export) never double-wraps.
-  Object.defineProperty(NedbCore, '__exitFlushWrapped', { value: true, enumerable: false });
-}
-
-module.exports = { ...native, NedbCore };
-// Explicit named re-export so ESM `import { NedbCore } from 'nedb-engine'` (used
-// by the test suite) resolves the class through cjs-module-lexer.
-module.exports.NedbCore = NedbCore;
+// SPDX-FileCopyrightText: 2026 INTERCHAINED LLC
+// SPDX-License-Identifier: BUSL-1.1
+// NEDB · © 2026 INTERCHAINED LLC × Eth-Interchained × Vex (Claude Opus 5)
+
+'use strict';
+// nedb-engine — durable-mode auto-flush-on-exit wrapper.
+//
+// The native addon (generated napi binding in ./native.js) exposes `NedbCore`.
+// A durable `NedbCore.open(path)` buffers writes in the engine's id-index WAL and
+// only makes them durable on `flush()`; a hard exit (Ctrl+C, `SIGTERM` from an
+// orchestrator, `pm2 stop`) that never runs an explicit flush would lose writes
+// staged since the last flush.
+//
+// We close that gap the libuv-cooperative way — `process.on('SIGINT'|'SIGTERM'
+// |'exit', () => db.flush())` — NOT a C-level signal handler inside the addon,
+// which would clobber libuv's own signal machinery. In-memory databases
+// (`new NedbCore()`) are never armed; there is nothing to flush.
+//
+// Escape hatch: set NEDB_NO_EXIT_FLUSH=1 to leave signal handling entirely to
+// the host app (it can still call `db.flush()` itself).
+//
+// © INTERCHAINED LLC × Vex (Interchained AI fleet: GLM · Claude · Opus · Fable · GPT-6)
+const native = require('./native.js');
+
+const Native = native.NedbCore;
+
+// The napi class defines `open` as a NON-writable, NON-configurable static, so the
+// 2.5.x wrapper's `NedbCore.open = …` threw ("Cannot assign to read only property")
+// — and CI's `napi build` was overwriting this file with the generated loader
+// anyway, so the published package never carried the wrapper at all. Both fixed
+// in 2.8.5: wrap by SUBCLASS (an own static on the subclass shadows the parent's),
+// build with `--js native.js` so this file survives, and gate the publish on
+// `NedbCore.__exitFlushWrapped` (see test/durability.test.mjs).
+let NedbCore = Native;
+if (Native && typeof Native.open === 'function' && !Native.__exitFlushWrapped) {
+  // Durable handles opened in this process. Strong refs: a durable DB is meant to
+  // live for the process, and we must be able to flush it on the way out.
+  const live = new Set();
+  let armed = false;
+
+  const flushAll = () => {
+    for (const db of live) {
+      try {
+        db.flush();
+      } catch (_) {
+        // Best-effort on shutdown — never throw out of an exit handler.
+      }
+    }
+  };
+
+  const arm = () => {
+    if (armed || process.env.NEDB_NO_EXIT_FLUSH) return;
+    armed = true;
+    // 'exit' fires on normal termination; handlers must be synchronous, and
+    // db.flush() is a synchronous native call — so this is safe and sufficient
+    // for clean exits and uncaught-exception exits.
+    process.on('exit', flushAll);
+    // Registering a SIGINT/SIGTERM listener SUPPRESSES Node's default
+    // termination, so once we listen we own the exit: flush, then terminate with
+    // the conventional 128+signum status.
+    const onSignal = (signum) => () => {
+      flushAll();
+      process.exit(128 + signum);
+    };
+    process.on('SIGINT', onSignal(2));
+    process.on('SIGTERM', onSignal(15));
+  };
+
+  NedbCore = class NedbCore extends Native {
+    static open(path) {
+      const db = Native.open(path);
+      live.add(db);
+      arm();
+      return db;
+    }
+  };
+  // Mark so a re-require (or a wrapped re-export) never double-wraps.
+  Object.defineProperty(NedbCore, '__exitFlushWrapped', { value: true, enumerable: false });
+}
+
+module.exports = { ...native, NedbCore };
+// Explicit named re-export so ESM `import { NedbCore } from 'nedb-engine'` (used
+// by the test suite) resolves the class through cjs-module-lexer.
+module.exports.NedbCore = NedbCore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nedb-engine",
-  "version": "8.8.8",
+  "version": "9.0.0",
   "description": "NEDB \u2014 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",
   "exports": {