@nodora/js 0.0.5 → 0.0.6

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Nodora
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2026 Nodora
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/README.md

@@ -1,3 +1,3 @@
-# @nodora/js
-
+# @nodora/js
+
 JS bindings for the Nodora rule engine. This library allows you to compile and evaluate Nodora rules.

package/lib/index.d.ts

@@ -1,89 +1,89 @@
-export type EmittedSignal = {
-  name: string;
-  args: any[];
-};
-
-export type EvaluationResult = {
-  outputs: Record<string, any>;
-  emitted_signals: EmittedSignal[];
-};
-
-export interface Evaluator {
-  /**
-   * Get evaluator id
-   */
-  getId(): number;
-
-  /**
-   * Register a callback for a signal
-   * @param signalName - Name of the signal to listen for
-   * @param callback - Callback function to invoke when signal is emitted
-   * @returns Evaluator instance for chaining
-   */
-  on(signalName: string, callback: (...args: any[]) => void): Evaluator;
-
-  /**
-   * Evaluates a rule with the given input
-   * @param ruleName - Name of the rule to evaluate
-   * @param input - Input values for the rule
-   * @returns Evaluation result
-   */
-  evaluate(ruleName: string, input?: Record<string, any>): EvaluationResult;
-
-  /**
-   * Asynchronously evaluates a rule with the given input
-   * @param ruleName - Name of the rule to evaluate
-   * @param input - Input values for the rule
-   * @returns Promise resolving to the evaluation result
-   */
-  evaluateAsync(
-    ruleName: string,
-    input?: Record<string, any>,
-  ): Promise<EvaluationResult>;
-
-  /**
-   * Clean up evaluator resources
-   */
-  destroy(): void;
-}
-
-/**
- * Create a new evaluator
- * @param programJSON - JSON string containing the compiled NIR program
- * @returns Promise resolving to an Evaluator instance
- */
-export function createEvaluator(programJSON: string): Promise<Evaluator>;
-
-/**
- * Compile a rule
- * @param src - Source code
- * @returns Promise resolving to a JSON string containing the compiled NIR program
- */
-export function compile(src: string): Promise<string>;
-
-type BaseType = "string" | "number" | "bool" | "object" | "any";
-type ArrayType = `array<${string}>`;
-type UnionType = `${string}|${string}`;
-export type Type = BaseType | ArrayType | UnionType;
-
-export interface FunctionArgSpec {
-  name: string;
-  type: Type;
-  required?: boolean;
-}
-
-export interface RegisterFunctionOptions {
-  name: string;
-  namespace?: string;
-  args?: FunctionArgSpec[];
-  returnType: Type;
-  fn: (...args: any[]) => any;
-}
-
-/**
- * Register a custom function in the registry. Must be called before compilation or evaluation.
- * @param options - Function specification and implementation
- */
-export function registerFunction(
-  options: RegisterFunctionOptions,
-): Promise<void>;
+export type EmittedSignal = {
+  name: string;
+  args: any[];
+};
+
+export type EvaluationResult = {
+  outputs: Record<string, any>;
+  emitted_signals: EmittedSignal[];
+};
+
+export interface Evaluator {
+  /**
+   * Get evaluator id
+   */
+  getId(): number;
+
+  /**
+   * Register a callback for a signal
+   * @param signalName - Name of the signal to listen for
+   * @param callback - Callback function to invoke when signal is emitted
+   * @returns Evaluator instance for chaining
+   */
+  on(signalName: string, callback: (...args: any[]) => void): Evaluator;
+
+  /**
+   * Evaluates a rule with the given input
+   * @param ruleName - Name of the rule to evaluate
+   * @param input - Input values for the rule
+   * @returns Evaluation result
+   */
+  evaluate(ruleName: string, input?: Record<string, any>): EvaluationResult;
+
+  /**
+   * Asynchronously evaluates a rule with the given input
+   * @param ruleName - Name of the rule to evaluate
+   * @param input - Input values for the rule
+   * @returns Promise resolving to the evaluation result
+   */
+  evaluateAsync(
+    ruleName: string,
+    input?: Record<string, any>,
+  ): Promise<EvaluationResult>;
+
+  /**
+   * Clean up evaluator resources
+   */
+  destroy(): void;
+}
+
+/**
+ * Create a new evaluator
+ * @param programJSON - JSON string containing the compiled NIR program
+ * @returns Promise resolving to an Evaluator instance
+ */
+export function createEvaluator(programJSON: string): Promise<Evaluator>;
+
+/**
+ * Compile a rule
+ * @param src - Source code
+ * @returns Promise resolving to a JSON string containing the compiled NIR program
+ */
+export function compile(src: string): Promise<string>;
+
+type BaseType = "string" | "number" | "bool" | "object" | "any";
+type ArrayType = `array<${string}>`;
+type UnionType = `${string}|${string}`;
+export type Type = BaseType | ArrayType | UnionType;
+
+export interface FunctionArgSpec {
+  name: string;
+  type: Type;
+  required?: boolean;
+}
+
+export interface RegisterFunctionOptions {
+  name: string;
+  namespace?: string;
+  args?: FunctionArgSpec[];
+  returnType: Type;
+  fn: (...args: any[]) => any;
+}
+
+/**
+ * Register a custom function in the registry. Must be called before compilation or evaluation.
+ * @param options - Function specification and implementation
+ */
+export function registerFunction(
+  options: RegisterFunctionOptions,
+): Promise<void>;

package/lib/index.js

@@ -1,141 +1,141 @@
-import "./wasm_exec.js";
-import { loadWasmBinary } from "#wasm-loader";
-
-let wasmInstance = null;
-let initPromise = null;
-
-async function init() {
-  if (initPromise) return initPromise;
-  initPromise = (async () => {
-    let GoClass = globalThis.Go;
-    if (!GoClass) {
-      throw new Error("wasm_exec.js did not define Go class");
-    }
-    const go = new GoClass();
-    const wasmBytes = await loadWasmBinary();
-
-    const result = await WebAssembly.instantiate(wasmBytes, go.importObject);
-    wasmInstance = result.instance;
-    go.run(wasmInstance);
-
-    return wasmInstance;
-  })();
-
-  try {
-    return await initPromise;
-  } catch (error) {
-    initPromise = null;
-    wasmInstance = null;
-    throw new Error(`init() failed: ${error.message}`);
-  }
-}
-
-class Evaluator {
-  constructor(evaluatorId) {
-    this.evaluatorId = evaluatorId;
-  }
-
-  getId() {
-    return this.evaluatorId;
-  }
-
-  evaluate(ruleName, input = {}) {
-    const result = globalThis.__nodoraEvaluate(
-      this.evaluatorId,
-      ruleName,
-      input,
-    );
-    if (result.error) throw new Error(result.error);
-    return result;
-  }
-
-  async evaluateAsync(ruleName, input = {}) {
-    return this.evaluate(ruleName, input);
-  }
-
-  on(signalName, callback) {
-    if (typeof callback !== "function") {
-      throw new Error("callback must be a function");
-    }
-
-    globalThis.__nodoraOnSignal(this.evaluatorId, signalName, callback);
-    return this;
-  }
-
-  destroy() {
-    globalThis.__nodoraDestroy(this.evaluatorId);
-  }
-}
-
-async function createEvaluator(programJSON) {
-  if (!wasmInstance) {
-    await init();
-  }
-
-  const result = globalThis.__nodoraCreateEvaluator(programJSON);
-  if (result.error) {
-    throw new Error(result.error);
-  }
-
-  return new Evaluator(result);
-}
-
-async function compile(src) {
-  if (!wasmInstance) {
-    await init();
-  }
-  const result = globalThis.__nodoraCompile(src);
-  if (result.error) throw result.error;
-  return result;
-}
-
-function assertType(x, type, err) {
-  if (!x || typeof x !== type) {
-    throw new Error(err);
-  }
-}
-
-async function registerFunction({ name, namespace, args, returnType, fn }) {
-  if (!wasmInstance) await init();
-
-  assertType(name, "string", "name is required and must be a string");
-  assertType(
-    returnType,
-    "string",
-    "returnType is required and must be a string",
-  );
-  assertType(fn, "function", "fn is required and must be a function");
-
-  args = (args || []).map((arg, i) => {
-    assertType(arg, "object", `args[${i}] must be an object`);
-    assertType(
-      arg.name,
-      "string",
-      `args[${i}].name is required and must be a string`,
-    );
-    assertType(
-      arg.type,
-      "string",
-      `args[${i}].type is required and must be a string`,
-    );
-
-    return {
-      name: arg.name,
-      type: arg.type,
-      required: !!(arg.required ?? true),
-    };
-  });
-
-  namespace = typeof namespace === "string" ? namespace : "";
-  const spec = {
-    name,
-    namespace,
-    args: args,
-    returnType,
-  };
-
-  const result = globalThis.__nodoraRegisterFunction(spec, fn);
-  if (result && result.error) throw new Error(result.error);
-}
-
-export { compile, createEvaluator, Evaluator, registerFunction };
+import "./wasm_exec.js";
+import { loadWasmBinary } from "#wasm-loader";
+
+let wasmInstance = null;
+let initPromise = null;
+
+async function init() {
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    let GoClass = globalThis.Go;
+    if (!GoClass) {
+      throw new Error("wasm_exec.js did not define Go class");
+    }
+    const go = new GoClass();
+    const wasmBytes = await loadWasmBinary();
+
+    const result = await WebAssembly.instantiate(wasmBytes, go.importObject);
+    wasmInstance = result.instance;
+    go.run(wasmInstance);
+
+    return wasmInstance;
+  })();
+
+  try {
+    return await initPromise;
+  } catch (error) {
+    initPromise = null;
+    wasmInstance = null;
+    throw new Error(`init() failed: ${error.message}`);
+  }
+}
+
+class Evaluator {
+  constructor(evaluatorId) {
+    this.evaluatorId = evaluatorId;
+  }
+
+  getId() {
+    return this.evaluatorId;
+  }
+
+  evaluate(ruleName, input = {}) {
+    const result = globalThis.__nodoraEvaluate(
+      this.evaluatorId,
+      ruleName,
+      input,
+    );
+    if (result.error) throw new Error(result.error);
+    return result;
+  }
+
+  async evaluateAsync(ruleName, input = {}) {
+    return this.evaluate(ruleName, input);
+  }
+
+  on(signalName, callback) {
+    if (typeof callback !== "function") {
+      throw new Error("callback must be a function");
+    }
+
+    globalThis.__nodoraOnSignal(this.evaluatorId, signalName, callback);
+    return this;
+  }
+
+  destroy() {
+    globalThis.__nodoraDestroy(this.evaluatorId);
+  }
+}
+
+async function createEvaluator(programJSON) {
+  if (!wasmInstance) {
+    await init();
+  }
+
+  const result = globalThis.__nodoraCreateEvaluator(programJSON);
+  if (result.error) {
+    throw new Error(result.error);
+  }
+
+  return new Evaluator(result);
+}
+
+async function compile(src) {
+  if (!wasmInstance) {
+    await init();
+  }
+  const result = globalThis.__nodoraCompile(src);
+  if (result.error) throw result.error;
+  return result;
+}
+
+function assertType(x, type, err) {
+  if (!x || typeof x !== type) {
+    throw new Error(err);
+  }
+}
+
+async function registerFunction({ name, namespace, args, returnType, fn }) {
+  if (!wasmInstance) await init();
+
+  assertType(name, "string", "name is required and must be a string");
+  assertType(
+    returnType,
+    "string",
+    "returnType is required and must be a string",
+  );
+  assertType(fn, "function", "fn is required and must be a function");
+
+  args = (args || []).map((arg, i) => {
+    assertType(arg, "object", `args[${i}] must be an object`);
+    assertType(
+      arg.name,
+      "string",
+      `args[${i}].name is required and must be a string`,
+    );
+    assertType(
+      arg.type,
+      "string",
+      `args[${i}].type is required and must be a string`,
+    );
+
+    return {
+      name: arg.name,
+      type: arg.type,
+      required: !!(arg.required ?? true),
+    };
+  });
+
+  namespace = typeof namespace === "string" ? namespace : "";
+  const spec = {
+    name,
+    namespace,
+    args: args,
+    returnType,
+  };
+
+  const result = globalThis.__nodoraRegisterFunction(spec, fn);
+  if (result && result.error) throw new Error(result.error);
+}
+
+export { compile, createEvaluator, Evaluator, registerFunction };

package/lib/wasm.browser.js

@@ -1,8 +1,13 @@
-export async function loadWasmBinary() {
-  const wasmUrl = new URL("./nodora.wasm", import.meta.url);
-  const response = await fetch(wasmUrl.href);
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-  }
-  return response.arrayBuffer();
-}
+export async function loadWasmBinary() {
+  const wasmUrl = new URL("./nodora.wasm.gz", import.meta.url);
+  const response = await fetch(wasmUrl.href);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  if (response.headers.get("Content-Encoding")?.includes("gzip")) {
+    return response.arrayBuffer();
+  }
+  const ds = new DecompressionStream("gzip");
+  const decompressed = response.body.pipeThrough(ds);
+  return await new Response(decompressed).arrayBuffer();
+}

package/lib/wasm.node.js

@@ -1,6 +1,13 @@
-import { readFile } from "fs/promises";
-import { fileURLToPath } from "url";
-
-export async function loadWasmBinary() {
-  return readFile(fileURLToPath(new URL("./nodora.wasm", import.meta.url)));
-}
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import { gunzip } from "zlib";
+import { promisify } from "util";
+
+const gunzipAsync = promisify(gunzip);
+
+export async function loadWasmBinary() {
+  const compressed = await readFile(
+    fileURLToPath(new URL("./nodora.wasm.gz", import.meta.url))
+  );
+  return gunzipAsync(compressed);
+}

package/lib/wasm_exec.js

@@ -572,4 +572,4 @@
 			};
 		}
 	}
-})();
+})();

package/package.json

@@ -1,41 +1,45 @@
-{
-  "name": "@nodora/js",
-  "version": "0.0.5",
-  "description": "JS bindings for Nodora rule engine",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "scripts": {
-    "build": "make build",
-    "clean": "make clean",
-    "test": "make test",
-    "prepublishOnly": "bun run build"
-  },
-  "files": [
-    "lib"
-  ],
-  "keywords": [
-    "nodora",
-    "rule",
-    "policy",
-    "engine"
-  ],
-  "author": "Nodora",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/nodora-org/nodora.git"
-  },
-  "exports": {
-    ".": {
-      "types": "./lib/index.d.ts",
-      "import": "./lib/index.js",
-      "require": "./lib/index.js"
-    }
-  },
-  "imports": {
-    "#wasm-loader": {
-      "browser": "./lib/wasm.browser.js",
-      "default": "./lib/wasm.node.js"
-    }
-  }
-}
+{
+  "name": "@nodora/js",
+  "version": "0.0.6",
+  "description": "JS bindings for Nodora rule engine",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "make build",
+    "clean": "make clean",
+    "test": "make test",
+    "prepublishOnly": "bun run build"
+  },
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts",
+    "lib/**/*.wasm.gz",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "nodora",
+    "rule",
+    "policy",
+    "engine"
+  ],
+  "author": "Nodora",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nodora-org/nodora.git"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.js"
+    }
+  },
+  "imports": {
+    "#wasm-loader": {
+      "browser": "./lib/wasm.browser.js",
+      "default": "./lib/wasm.node.js"
+    }
+  }
+}