entroly-wasm 1.0.4 → 1.0.6

package/index.js

@@ -11,19 +11,47 @@
 //   npx entroly-wasm serve
 
 let WasmEntrolyEngine;
+let classifyQueryTransitionRust;
+let rewardWeightedOptimizeRust;
+let optimizeTaskProfilesRust;
+let classifyLearningQueryRust;
+function bindWasmExports(mod) {
+  ({
+    WasmEntrolyEngine,
+    classify_query_transition: classifyQueryTransitionRust,
+    reward_weighted_optimize: rewardWeightedOptimizeRust,
+    optimize_task_profiles: optimizeTaskProfilesRust,
+    classify_learning_query: classifyLearningQueryRust,
+  } = mod);
+}
+
+function buildAndBindWasm() {
+  const { execFileSync } = require('child_process');
+  execFileSync('wasm-pack', ['build', '--target', 'nodejs', '--out-dir', 'pkg'], {
+    cwd: __dirname,
+    stdio: 'inherit',
+  });
+  const pkgPath = require.resolve('./pkg/entroly_wasm');
+  delete require.cache[pkgPath];
+  bindWasmExports(require('./pkg/entroly_wasm'));
+}
+
 try {
-  ({ WasmEntrolyEngine } = require('./pkg/entroly_wasm'));
+  bindWasmExports(require('./pkg/entroly_wasm'));
+  if (
+    !classifyQueryTransitionRust ||
+    !rewardWeightedOptimizeRust ||
+    !optimizeTaskProfilesRust ||
+    !classifyLearningQueryRust
+  ) {
+    buildAndBindWasm();
+  }
 } catch (err) {
   if (err && err.code === 'MODULE_NOT_FOUND') {
     // Source checkouts do not commit wasm-pack output. Build it lazily so
     // `node -e "require('./entroly-wasm')"` and local smoke tests exercise the
     // same module shape that the published npm tarball contains.
-    const { execFileSync } = require('child_process');
-    execFileSync('wasm-pack', ['build', '--target', 'nodejs', '--out-dir', 'pkg'], {
-      cwd: __dirname,
-      stdio: 'inherit',
-    });
-    ({ WasmEntrolyEngine } = require('./pkg/entroly_wasm'));
+    buildAndBindWasm();
   } else {
     throw err;
   }
@@ -38,10 +66,42 @@ const { exportPromoted: exportAgentSkills } = require('./js/agentskills_export')
 const { TelegramGateway, DiscordGateway, SlackGateway } = require('./js/gateways');
 const { VaultObserver } = require('./js/vault_observer');
 
+function classifyQueryTransition(...args) {
+  if (!classifyQueryTransitionRust) {
+    throw new Error('Rust classify_query_transition is unavailable; rebuild entroly-wasm');
+  }
+  return classifyQueryTransitionRust(...args);
+}
+
+function rewardWeightedOptimize(...args) {
+  if (!rewardWeightedOptimizeRust) {
+    throw new Error('Rust reward_weighted_optimize is unavailable; rebuild entroly-wasm');
+  }
+  return rewardWeightedOptimizeRust(...args);
+}
+
+function optimizeTaskProfiles(...args) {
+  if (!optimizeTaskProfilesRust) {
+    throw new Error('Rust optimize_task_profiles is unavailable; rebuild entroly-wasm');
+  }
+  return optimizeTaskProfilesRust(...args);
+}
+
+function classifyLearningQuery(...args) {
+  if (!classifyLearningQueryRust) {
+    throw new Error('Rust classify_learning_query is unavailable; rebuild entroly-wasm');
+  }
+  return classifyLearningQueryRust(...args);
+}
+
 module.exports = {
   // Core engine (wasm)
   EntrolyEngine: WasmEntrolyEngine,
   WasmEntrolyEngine,
+  classifyQueryTransition,
+  rewardWeightedOptimize,
+  optimizeTaskProfiles,
+  classifyLearningQuery,
 
   // Configuration
   EntrolyConfig,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entroly-wasm",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Information-theoretic context optimization for AI coding agents. Zero-friction, pure WebAssembly - no Python dependency.",
   "main": "index.js",
   "types": "pkg/entroly_wasm.d.ts",

package/pkg/entroly_wasm.d.ts

@@ -200,3 +200,11 @@ export class WasmEntrolyEngine {
      */
     stats(): any;
 }
+
+export function classify_learning_query(query: string): string;
+
+export function classify_query_transition(prev_hash: bigint, current_query: string, elapsed_s: number, time_window_s: number, rephrase_threshold: number, topic_change_threshold: number): any;
+
+export function optimize_task_profiles(episodes_json: string): any;
+
+export function reward_weighted_optimize(episodes_json: string, current_weights_json: string): any;

package/pkg/entroly_wasm.js

@@ -436,6 +436,76 @@ class WasmEntrolyEngine {
 if (Symbol.dispose) WasmEntrolyEngine.prototype[Symbol.dispose] = WasmEntrolyEngine.prototype.free;
 exports.WasmEntrolyEngine = WasmEntrolyEngine;
 
+/**
+ * @param {string} query
+ * @returns {string}
+ */
+function classify_learning_query(query) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.classify_learning_query(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.classify_learning_query = classify_learning_query;
+
+/**
+ * @param {bigint} prev_hash
+ * @param {string} current_query
+ * @param {number} elapsed_s
+ * @param {number} time_window_s
+ * @param {number} rephrase_threshold
+ * @param {number} topic_change_threshold
+ * @returns {any}
+ */
+function classify_query_transition(prev_hash, current_query, elapsed_s, time_window_s, rephrase_threshold, topic_change_threshold) {
+    const ptr0 = passStringToWasm0(current_query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.classify_query_transition(prev_hash, ptr0, len0, elapsed_s, time_window_s, rephrase_threshold, topic_change_threshold);
+    return ret;
+}
+exports.classify_query_transition = classify_query_transition;
+
+/**
+ * @param {string} episodes_json
+ * @returns {any}
+ */
+function optimize_task_profiles(episodes_json) {
+    const ptr0 = passStringToWasm0(episodes_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.optimize_task_profiles(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.optimize_task_profiles = optimize_task_profiles;
+
+/**
+ * @param {string} episodes_json
+ * @param {string} current_weights_json
+ * @returns {any}
+ */
+function reward_weighted_optimize(episodes_json, current_weights_json) {
+    const ptr0 = passStringToWasm0(episodes_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(current_weights_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.reward_weighted_optimize(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.reward_weighted_optimize = reward_weighted_optimize;
+
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -446,6 +516,11 @@ function __wbg_get_imports() {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
         }, arguments); },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -531,6 +606,12 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
 function decodeText(ptr, len) {