@net-mesh/core 0.21.0 → 0.23.0

package/meshdb.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Result of {@link parseMeshDbErrorKind}: extracted structured
+ * discriminator + the human-readable message stripped of the
+ * `<<meshdb-kind:...>>` prefix.
+ */
+export interface ParsedMeshDbError {
+    kind: string;
+    message: string;
+}
+/**
+ * Pull the structured error kind out of a MeshDB error message.
+ *
+ * The Rust binding embeds the kind discriminator (one of the
+ * `MeshError` variant tags such as `planner_error`,
+ * `executor_error`, `query_cancelled`, `historical_range_unavailable`,
+ * `ambiguous_discovery`, etc.) at the start of the error message
+ * as `<<meshdb-kind:KIND>>MSG`. This helper parses it back.
+ *
+ * Returns `null` for errors that don't carry a kind prefix
+ * (SDK-side validation failures, factory rejections) — those
+ * surface with the plain message intact.
+ */
+export declare function parseMeshDbErrorKind(err: unknown): ParsedMeshDbError | null;

package/meshdb.js

@@ -0,0 +1,101 @@
+"use strict";
+// MeshDB AsyncIterable shim.
+//
+// Augments the napi-rs–generated `MeshQueryStream` class with
+// `[Symbol.asyncIterator]` so callers can write `for await (const row
+// of await runner.execute(query)) { ... }`. The locked Node SDK
+// decision is `Promise<AsyncIterable<Row>>`; importing this module
+// once at startup makes the shape land.
+//
+// Usage:
+//
+//   import "@net-mesh/core/meshdb";  // augments MeshQueryStream
+//   import { MeshQuery, MeshQueryRunner } from "@net-mesh/core";
+//
+//   const runner = new MeshQueryRunner(reader);
+//   const stream = await runner.execute(MeshQuery.latest(0xABn));
+//   for await (const row of stream) {
+//     console.log(row.seq, row.payload);
+//   }
+//
+// The shim is idempotent — re-imports are no-ops. It detaches
+// cleanly under tree-shaking too (no top-level side effects beyond
+// the prototype attach, which only fires when `MeshQueryStream` is
+// part of the loaded native binding).
+//
+// Phase-F note: this shim is a wire-shape ergonomics layer; it
+// doesn't change semantics. The underlying `next()` / `toArray()`
+// methods stay available for callers that prefer manual iteration
+// or batch drain.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMeshDbErrorKind = parseMeshDbErrorKind;
+// The napi-generated MeshQueryStream is a constructor function with a
+// prototype, but the original cast typed it as a plain object — the
+// later `typeof === "function"` narrowing then collapsed it to `never`
+// and reading `.prototype` errored under `-D warnings`. Cast as a
+// Function with a prototype so both type-guards line up.
+const native = require("./index");
+if (native.MeshQueryStream &&
+    typeof native.MeshQueryStream === "function" &&
+    !(Symbol.asyncIterator in native.MeshQueryStream.prototype)) {
+    Object.defineProperty(native.MeshQueryStream.prototype, Symbol.asyncIterator, {
+        value() {
+            const stream = this;
+            return {
+                async next() {
+                    const row = await stream.next();
+                    if (row === null || row === undefined) {
+                        return { value: undefined, done: true };
+                    }
+                    return { value: row, done: false };
+                },
+                // `return(value)` is invoked when a `for await (...)` loop
+                // `break`s, `return`s from the enclosing function, or an
+                // exception unwinds out of the loop body. Without this,
+                // the backing row Vec stays pinned on the AsyncMutex
+                // until JS GC eventually drops the stream — for a 10k+
+                // row result that's a sizeable memory pin.
+                async return(value) {
+                    if (typeof stream.release === "function") {
+                        await stream.release();
+                    }
+                    return { value, done: true };
+                },
+                // `throw(err)` is the iteration-protocol's error path.
+                // Symmetric to `return()`: free the buffer, then
+                // re-surface the error to the caller.
+                async throw(err) {
+                    if (typeof stream.release === "function") {
+                        await stream.release();
+                    }
+                    throw err;
+                },
+            };
+        },
+        enumerable: false,
+        configurable: true,
+        writable: true,
+    });
+}
+/**
+ * Pull the structured error kind out of a MeshDB error message.
+ *
+ * The Rust binding embeds the kind discriminator (one of the
+ * `MeshError` variant tags such as `planner_error`,
+ * `executor_error`, `query_cancelled`, `historical_range_unavailable`,
+ * `ambiguous_discovery`, etc.) at the start of the error message
+ * as `<<meshdb-kind:KIND>>MSG`. This helper parses it back.
+ *
+ * Returns `null` for errors that don't carry a kind prefix
+ * (SDK-side validation failures, factory rejections) — those
+ * surface with the plain message intact.
+ */
+function parseMeshDbErrorKind(err) {
+    if (!(err instanceof Error))
+        return null;
+    // Accept digits too (`protocol_v2_mismatch`-style future kinds).
+    const m = err.message.match(/^<<meshdb-kind:([a-z0-9_]+)>>(.*)$/s);
+    if (!m)
+        return null;
+    return { kind: m[1], message: m[2] };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@net-mesh/core",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "High-performance, schema-agnostic event bus for AI runtime workloads",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,6 +20,10 @@
     "./meshdb": {
       "types": "./meshdb.d.ts",
       "default": "./meshdb.js"
+    },
+    "./aggregator": {
+      "types": "./aggregator.d.ts",
+      "default": "./aggregator.js"
     }
   },
   "napi": {
@@ -56,6 +60,10 @@
     "errors.d.ts",
     "mesh_rpc.js",
     "mesh_rpc.d.ts",
+    "meshdb.js",
+    "meshdb.d.ts",
+    "aggregator.js",
+    "aggregator.d.ts",
     "*.node"
   ],
   "devDependencies": {
@@ -66,9 +74,9 @@
   },
   "scripts": {
     "artifacts": "napi artifacts",
-    "build": "napi build --platform --release --features redis,net,cortex,compute,groups,meshos,deck,meshdb",
-    "build:debug": "napi build --platform --features redis,net,cortex,compute,groups,meshos,deck,meshdb",
-    "build:test": "napi build --platform --features redis,net,cortex,compute,groups,meshos,deck,meshdb,test-helpers",
+    "build": "napi build --platform --release --features redis,net,cortex,compute,groups,meshos,deck,meshdb,aggregator",
+    "build:debug": "napi build --platform --features redis,net,cortex,compute,groups,meshos,deck,meshdb,aggregator",
+    "build:test": "napi build --platform --features redis,net,cortex,compute,groups,meshos,deck,meshdb,aggregator,test-helpers",
     "build:ts": "tsc -p tsconfig.build.json",
     "prepublishOnly": "npm run build:ts && napi prepublish -t npm",
     "test": "vitest run",
@@ -83,13 +91,13 @@
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@net-mesh/core-win32-x64-msvc": "0.21.0",
-    "@net-mesh/core-win32-arm64-msvc": "0.21.0",
-    "@net-mesh/core-darwin-x64": "0.21.0",
-    "@net-mesh/core-darwin-arm64": "0.21.0",
-    "@net-mesh/core-linux-x64-gnu": "0.21.0",
-    "@net-mesh/core-linux-x64-musl": "0.21.0",
-    "@net-mesh/core-linux-arm64-gnu": "0.21.0",
-    "@net-mesh/core-linux-arm64-musl": "0.21.0"
+    "@net-mesh/core-win32-x64-msvc": "0.23.0",
+    "@net-mesh/core-win32-arm64-msvc": "0.23.0",
+    "@net-mesh/core-darwin-x64": "0.23.0",
+    "@net-mesh/core-darwin-arm64": "0.23.0",
+    "@net-mesh/core-linux-x64-gnu": "0.23.0",
+    "@net-mesh/core-linux-x64-musl": "0.23.0",
+    "@net-mesh/core-linux-arm64-gnu": "0.23.0",
+    "@net-mesh/core-linux-arm64-musl": "0.23.0"
   }
 }