@digitalforgestudios/openclaw-sulcus 2.0.0 → 3.1.0

package/index.ts

@@ -1,6 +1,5 @@
-import { spawn, ChildProcess } from "node:child_process";
-import { createInterface } from "node:readline";
 import { resolve } from "node:path";
+import { existsSync } from "node:fs";
 import { Type } from "@sinclair/typebox";
 
 // ─── STATIC AWARENESS ───────────────────────────────────────────────────────
@@ -8,154 +7,174 @@ import { Type } from "@sinclair/typebox";
 // This is the absolute minimum the LLM needs to know Sulcus exists.
 // It fires even if build_context crashes, times out, or returns empty.
 // Build static awareness with runtime backend info
-function buildStaticAwareness(backendMode: string, namespace: string, serverUrl: string) {
+function buildStaticAwareness(backendMode: string, namespace: string) {
   return `## Persistent Memory (Sulcus)
 You have Sulcus — a persistent, reactive, thermodynamic memory system with reactive triggers.
 Memories survive across sessions. They have heat (0.0–1.0) that decays over time.
 
-**Connection:** Backend: ${backendMode} | Namespace: ${namespace} | Server: ${serverUrl}
+**Connection:** Backend: ${backendMode} | Namespace: ${namespace}
 
 **Your memory tools:**
 - \`memory_store\` — Save important information (preferences, facts, procedures, decisions, lessons)
-  Parameters: content, memory_type (episodic|semantic|preference|procedural|fact), decay_class (volatile|normal|stable|permanent), is_pinned, min_heat, key_points
+  Parameters: content, memory_type (episodic|semantic|preference|procedural|fact)
 - \`memory_recall\` — Search memories semantically. Use before answering about past work, decisions, or people.
   Parameters: query, limit
 
 **When to store:** User states a preference, important decision made, correction given, lesson learned, anything worth surviving this session.
 **When to search:** Questions about prior work/decisions, context seems incomplete, user references past conversations.
 
-**Memory types:** episodic (events, fast decay) · semantic (knowledge, slow) · preference (opinions, slower) · procedural (how-tos, slowest) · fact (data, slow)
-**Decay classes:** volatile (hours) · normal (days) · stable (weeks) · permanent (never)
-**Pinning:** is_pinned=true prevents decay. Use for critical knowledge.
-**Triggers:** Reactive rules on memory events. Active triggers and recent fires appear in your context below.`;
+**Memory types:** episodic (events, fast decay) · semantic (knowledge, slow) · preference (opinions, slower) · procedural (how-tos, slowest) · fact (data, slow)`;
 }
 
 // Legacy static string for backward compat (overwritten at register time)
-let STATIC_AWARENESS = buildStaticAwareness("local", "default", "local");
+let STATIC_AWARENESS = buildStaticAwareness("local", "default");
 
 // Fallback context when build_context fails — includes the cheatsheet
 // but warns that dynamic context is unavailable.
 const FALLBACK_AWARENESS = `<sulcus_context token_budget="500">
   <cheatsheet>
     You have Sulcus — persistent memory with reactive triggers.
-    STORE:    memory_store (content, memory_type, decay_class, is_pinned, key_points)
+    STORE:    memory_store (content, memory_type)
     FIND:     memory_recall (query, limit)
-    MANAGE:   memory_boost / memory_deprecate / memory_relate / memory_reclassify
-    PIN:      Set is_pinned=true to make a memory permanent (immune to decay).
-    TRIGGERS: create_trigger to set reactive rules on your memory graph
     TYPES:    episodic (fast fade), semantic (slow), preference, procedural (slowest), fact
     ⚠️ Context build failed this turn — use memory_recall to search manually.
     Below is your active context. Search for deeper recall. Unlimited storage.
   </cheatsheet>
 </sulcus_context>`;
 
-// MCP-over-stdio client for sulcus-local
-// This is the ONLY communication path — no REST/network calls in this plugin.
-// If serverUrl/apiKey are configured, they are passed as env vars to the spawn()
-// call below so that sulcus-sync (a dylib loaded by sulcus-local) can pick them
-// up for cloud replication. The plugin itself never makes any HTTP calls.
-class SulcusClient {
-  private child: ChildProcess | null = null;
-  private nextId = 1;
-  private pending = new Map<string | number, (res: any) => void>();
-  private configPath: string | undefined;
-  private spawnEnv: Record<string, string>;
+// ─── NATIVE LIB LOADER ──────────────────────────────────────────────────────
+// Loads libsulcus_store.dylib (embedded PG) and libsulcus_vectors.dylib (embeddings)
+// via koffi FFI. Provides queryFn and embedFn callbacks for SulcusMem.create().
+
+class NativeLibLoader {
+  private koffi: any = null;
+  private storeLib: any = null;
+  private vectorsLib: any = null;
+  private vectorsHandle: any = null;
+
+  // koffi function handles
+  private fn_store_init: any = null;
+  private fn_store_query: any = null;
+  private fn_store_free: any = null;
+  private fn_vectors_create: any = null;
+  private fn_vectors_text: any = null;
+  private fn_vectors_free: any = null;
+
+  public loaded = false;
+  public error: string | null = null;
 
   constructor(
-    private binaryPath: string,
-    configPath?: string,
-    spawnEnv: Record<string, string> = {}
-  ) {
-    this.configPath = configPath;
-    this.spawnEnv = spawnEnv;
-  }
+    private storeLibPath: string,
+    private vectorsLibPath: string
+  ) {}
 
-  // Launches sulcus-local binary as an MCP stdio sidecar.
-  // serverUrl/apiKey (if any) are passed via environment variables so that
-  // sulcus-sync (dylib) can perform cloud replication without this plugin
-  // making any network calls itself.
-  async start(configPath?: string) {
-    const cfgPath = configPath || this.configPath;
-    const args = cfgPath ? ["--config", cfgPath, "stdio"] : ["stdio"];
-    this.child = spawn(this.binaryPath, args, {
-      stdio: ["pipe", "pipe", "inherit"],
-      env: {
-        ...process.env,
-        RUST_LOG: "info",
-        ...this.spawnEnv,   // SULCUS_SERVER_URL and SULCUS_API_KEY forwarded here
-      }
-    });
+  init(logger: any): void {
+    try {
+      // koffi is a pure-JS FFI library — no native compilation needed
+      this.koffi = require("koffi");
+    } catch (e: any) {
+      this.error = `koffi not available: ${e.message}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
 
-    this.child.on("error", (err) => {
-      // Reject all pending calls if the process dies
-      for (const [_id, resolve] of this.pending) {
-        resolve({ error: { code: -1, message: `Sulcus process error: ${err.message}` } });
-      }
-      this.pending.clear();
-      this.child = null;
-    });
+    // ── Load libsulcus_store.dylib ──
+    if (!existsSync(this.storeLibPath)) {
+      this.error = `libsulcus_store not found at ${this.storeLibPath}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
+    if (!existsSync(this.vectorsLibPath)) {
+      this.error = `libsulcus_vectors not found at ${this.vectorsLibPath}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
+
+    try {
+      this.storeLib = this.koffi.load(this.storeLibPath);
+      this.fn_store_init  = this.storeLib.func("sulcus_store_init", "int",    ["str", "uint16"]);
+      this.fn_store_query = this.storeLib.func("sulcus_store_query", "char*", ["str"]);
+      this.fn_store_free  = this.storeLib.func("sulcus_store_free_string", "void", ["char*"]);
+    } catch (e: any) {
+      this.error = `Failed to load libsulcus_store: ${e.message}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
 
-    this.child.on("exit", (code) => {
-      for (const [_id, resolve] of this.pending) {
-        resolve({ error: { code: -1, message: `Sulcus process exited with code ${code}` } });
+    try {
+      this.vectorsLib = this.koffi.load(this.vectorsLibPath);
+      this.fn_vectors_create = this.vectorsLib.func("sulcus_vectors_create", "void*",  []);
+      this.fn_vectors_text   = this.vectorsLib.func("sulcus_vectors_text",   "char*",  ["void*", "str"]);
+      this.fn_vectors_free   = this.vectorsLib.func("sulcus_vectors_free_string", "void", ["char*"]);
+    } catch (e: any) {
+      this.error = `Failed to load libsulcus_vectors: ${e.message}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
+
+    // ── Initialise embedded PG store ──
+    try {
+      const dataDir = resolve(process.env.HOME || "~", ".sulcus/data");
+      const port = 15432;
+      const rc = this.fn_store_init(dataDir, port);
+      if (rc !== 0) {
+        this.error = `sulcus_store_init returned ${rc}`;
+        logger.warn(`memory-sulcus: ${this.error}`);
+        return;
       }
-      this.pending.clear();
-      this.child = null;
-    });
+    } catch (e: any) {
+      this.error = `sulcus_store_init failed: ${e.message}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
 
-    const rl = createInterface({ input: this.child.stdout! });
-    rl.on("line", (line) => {
-      try {
-        const msg = JSON.parse(line);
-        if (msg.id && this.pending.has(msg.id)) {
-          const resolve = this.pending.get(msg.id)!;
-          this.pending.delete(msg.id);
-          resolve(msg);
-        }
-      } catch (e) {}
-    });
+    // ── Create embed handle ──
+    try {
+      this.vectorsHandle = this.fn_vectors_create();
+    } catch (e: any) {
+      this.error = `sulcus_vectors_create failed: ${e.message}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
+
+    this.loaded = true;
+    logger.info(`memory-sulcus: native libs loaded (store: ${this.storeLibPath}, vectors: ${this.vectorsLibPath})`);
   }
 
-  async call(method: string, params: any = {}): Promise<any> {
-    if (!this.child) await this.start();
-    const id = this.nextId++;
-    const request = { jsonrpc: "2.0", id, method: "tools/call", params: { name: method, arguments: params } };
-    
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error(`Sulcus timeout: ${method}`)), 30000);
-      this.pending.set(id, (res) => {
-        clearTimeout(timeout);
-        if (res.error) reject(new Error(res.error.message));
-        else {
-          // MCP result format
-          try {
-            const content = JSON.parse(res.result.content[0].text);
-            resolve(content);
-          } catch (e) {
-            resolve(res.result);
-          }
-        }
-      });
-      this.child!.stdin!.write(JSON.stringify(request) + "\n");
-    });
+  // queryFn: async (sql: string, params: any[]) => any[]
+  // Calls sulcus_store_query which accepts plain SQL (params inlined by caller or
+  // passed as a JSON payload — the store lib handles parameterisation internally).
+  makeQueryFn(): (sql: string, params: any[]) => Promise<any[]> {
+    return async (sql: string, _params: any[]): Promise<any[]> => {
+      if (!this.loaded) throw new Error("Sulcus store not available");
+      // The store lib's query function takes a single JSON-encoded request
+      const payload = JSON.stringify({ sql, params: _params });
+      const raw: string = this.fn_store_query(payload);
+      if (!raw) return [];
+      try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : (parsed?.rows ?? [parsed]);
+      } finally {
+        // NOTE: koffi manages string memory automatically for char* returns;
+        // no manual free needed with koffi's default charset handling.
+        // If the ABI requires explicit free, call fn_store_free here.
+      }
+    };
   }
 
-  stop() {
-    if (this.child) this.child.kill();
+  // embedFn: async (text: string) => Float32Array
+  // Calls sulcus_vectors_text which returns a JSON float array string.
+  makeEmbedFn(): (text: string) => Promise<Float32Array> {
+    return async (text: string): Promise<Float32Array> => {
+      if (!this.loaded) throw new Error("Sulcus vectors not available");
+      const raw: string = this.fn_vectors_text(this.vectorsHandle, text);
+      if (!raw) throw new Error("sulcus_vectors_text returned null");
+      const arr: number[] = JSON.parse(raw);
+      return new Float32Array(arr);
+    };
   }
 }
 
-// NOTE: SulcusRestClient was removed — the plugin no longer makes any HTTP/REST
-// calls. All communication with sulcus-local goes through MCP over stdio via
-// SulcusClient above. If serverUrl/apiKey are provided in config, they are
-// forwarded as SULCUS_SERVER_URL / SULCUS_API_KEY environment variables to the
-// sulcus-local spawn so that sulcus-sync (dylib) can replicate to the cloud
-// without this plugin touching the network.
-
-// NOTE: SiuClassifier / ClientSiu / SiuModel were removed — sulcus-local
-// already has fastembed + ONNX for embeddings and handles classification
-// internally. A future PR may expose classification via an MCP tool if needed.
-
 // ─── PRE-SEND FILTER ─────────────────────────────────────────────────────────
 // Rule-based junk filter. Catches obvious noise before it hits the API.
 
@@ -176,65 +195,83 @@ const JUNK_PATTERNS = [
 
 function isJunkMemory(text: string): boolean {
   if (!text || text.length < 10) return true;
-  if (text.length > 10000) return true; // probably a raw dump
+  if (text.length > 10000) return true;
   for (const pattern of JUNK_PATTERNS) {
     if (pattern.test(text.trim())) return true;
   }
   return false;
 }
 
+// ─── PLUGIN ──────────────────────────────────────────────────────────────────
+
 const sulcusPlugin = {
   id: "memory-sulcus",
   name: "Sulcus vMMU",
-  description: "Sulcus-backed vMMU memory for OpenClaw — thermodynamic decay, reactive triggers, local-first with cloud sync",
+  description: "Sulcus-backed vMMU memory for OpenClaw — thermodynamic decay, reactive triggers, local-first",
   kind: "memory" as const,
 
   register(api: any) {
-    const binaryPath = api.config?.binaryPath || "/Users/dv00003-00/dev/sulcus/target/release/sulcus-local";
-    const iniPath = api.config?.iniPath || resolve(process.env.HOME || "~", ".config/sulcus/sulcus.ini");
+    // ── Configuration ──
+    const libDir = api.config?.libDir
+      ? resolve(api.config.libDir)
+      : resolve(process.env.HOME || "~", ".sulcus/lib");
+
+    const storeLibPath = api.config?.storeLibPath
+      ? resolve(api.config.storeLibPath)
+      : resolve(libDir, process.platform === "darwin" ? "libsulcus_store.dylib" : "libsulcus_store.so");
+
+    const vectorsLibPath = api.config?.vectorsLibPath
+      ? resolve(api.config.vectorsLibPath)
+      : resolve(libDir, process.platform === "darwin" ? "libsulcus_vectors.dylib" : "libsulcus_vectors.so");
+
+    const wasmDir = api.config?.wasmDir
+      ? resolve(api.config.wasmDir)
+      : resolve(__dirname, "wasm");
+
     // Default namespace = agent name (prevents everything landing in "default")
-    // Priority: explicit namespace config > agentId config > pluginConfig.agentId > "default"
     const agentId = api.config?.agentId || api.pluginConfig?.agentId;
     const namespace = api.config?.namespace === "default" && agentId
       ? agentId
       : (api.config?.namespace || agentId || "default");
 
-    // serverUrl/apiKey are NOT used by this plugin for HTTP calls.
-    // They are forwarded as env vars to sulcus-local so sulcus-sync (dylib)
-    // can replicate memories to the cloud without any network calls here.
-    const serverUrl = api.config?.serverUrl || "";
-    const apiKey = api.config?.apiKey || "";
-
-    // Build spawn env: pass cloud config to sulcus-local via environment
-    const spawnEnv: Record<string, string> = {};
-    if (serverUrl) spawnEnv["SULCUS_SERVER_URL"] = serverUrl;
-    if (apiKey)    spawnEnv["SULCUS_API_KEY"]    = apiKey;
+    // ── Load native dylibs ──
+    const nativeLoader = new NativeLibLoader(storeLibPath, vectorsLibPath);
+    nativeLoader.init(api.logger);
 
-    const client = new SulcusClient(binaryPath, iniPath, spawnEnv);
+    // ── Load WASM module ──
+    let sulcusMem: any = null;
+    let backendMode = "unavailable";
 
-    // Check binary availability
-    let hasBinary = false;
-    try {
-      const { existsSync } = require("node:fs");
-      hasBinary = existsSync(binaryPath);
-    } catch { }
-
-    const backendMode = hasBinary ? "local" : "unavailable";
-
-    // All memory calls go exclusively through MCP — no REST fallback.
-    // If the MCP client isn't connected (binary missing or crashed), we return
-    // an error rather than falling back to HTTP.
-    async function memoryCall(method: string, params: any): Promise<any> {
-      if (!hasBinary) {
-        throw new Error(`Sulcus unavailable: binary not found at ${binaryPath}`);
+    if (nativeLoader.loaded) {
+      const wasmJsPath = resolve(wasmDir, "sulcus_wasm.js");
+      if (existsSync(wasmJsPath)) {
+        try {
+          const { SulcusMem, on_init } = require(wasmJsPath);
+          // on_init sets up WASM internals (panic hooks etc.)
+          if (typeof on_init === "function") on_init();
+
+          const queryFn = nativeLoader.makeQueryFn();
+          const embedFn = nativeLoader.makeEmbedFn();
+          sulcusMem = SulcusMem.create(queryFn, embedFn);
+          backendMode = "wasm";
+          api.logger.info(`memory-sulcus: SulcusMem created via WASM (wasm: ${wasmJsPath})`);
+        } catch (e: any) {
+          api.logger.warn(`memory-sulcus: WASM load failed: ${e.message}`);
+          backendMode = "unavailable";
+        }
+      } else {
+        api.logger.warn(`memory-sulcus: WASM module not found at ${wasmJsPath}`);
       }
-      return client.call(method, params);
+    } else {
+      api.logger.warn(`memory-sulcus: native libs unavailable — ${nativeLoader.error}`);
     }
 
+    const isAvailable = sulcusMem !== null;
+
     // Update static awareness with runtime info
-    STATIC_AWARENESS = buildStaticAwareness(backendMode, namespace, serverUrl || "local");
+    STATIC_AWARENESS = buildStaticAwareness(backendMode, namespace);
 
-    api.logger.info(`memory-sulcus: registered (binary: ${binaryPath}, hasBinary: ${hasBinary}, namespace: ${namespace}, backend: ${backendMode})`);
+    api.logger.info(`memory-sulcus: registered (backend: ${backendMode}, namespace: ${namespace}, available: ${isAvailable})`);
 
     // ── Core memory tools ──
 
@@ -247,12 +284,14 @@ const sulcusPlugin = {
         limit: Type.Optional(Type.Number({ default: 5, description: "Maximum number of results to return (1-10)." }))
       }),
       async execute(_id: string, params: any) {
-        const res = await memoryCall("search_memory", { query: params.query, limit: params.limit });
-        const results = res?.results || res;
-        const provenance = res?.provenance || { backend: backendMode, namespace };
+        if (!isAvailable) {
+          throw new Error(`Sulcus unavailable: ${nativeLoader.error || "WASM not loaded"}`);
+        }
+        const res = await sulcusMem.search_memory(params.query, params.limit ?? 5);
+        const results = res?.results ?? res;
         return {
           content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
-          details: { ...res, provenance }
+          details: { results, backend: backendMode, namespace }
         };
       }
     }, { name: "memory_recall" });
@@ -260,10 +299,9 @@ const sulcusPlugin = {
     api.registerTool({
       name: "memory_store",
       label: "Memory Store",
-      description: "Record information in Sulcus memory. Supports Markdown formatting. You control the memory type, decay rate, importance, and key details at creation time.",
+      description: "Record information in Sulcus memory. Supports Markdown formatting. You control the memory type at creation time.",
       parameters: Type.Object({
         content: Type.String({ description: "Memory content. Supports Markdown formatting for structured content." }),
-        fold_name: Type.Optional(Type.String({ description: `Memory namespace/fold. Defaults to "${namespace}" (agent namespace).` })),
         memory_type: Type.Optional(Type.Union([
           Type.Literal("episodic"),
           Type.Literal("semantic"),
@@ -271,15 +309,6 @@ const sulcusPlugin = {
           Type.Literal("procedural"),
           Type.Literal("fact")
         ], { description: "Memory type. preference=user preferences, procedural=how-to/processes, fact=stable knowledge, semantic=concepts/relationships, episodic=events/experiences. Default: episodic" })),
-        decay_class: Type.Optional(Type.Union([
-          Type.Literal("volatile"),
-          Type.Literal("normal"),
-          Type.Literal("stable"),
-          Type.Literal("permanent")
-        ], { description: "Decay rate. volatile=fast decay, normal=default, stable=slow decay, permanent=never decays" })),
-        is_pinned: Type.Optional(Type.Boolean({ description: "Pin memory to freeze heat at current value, preventing ALL decay. Pinned memories never lose heat." })),
-        min_heat: Type.Optional(Type.Number({ description: "Minimum heat floor (0.0-1.0). Memory will never decay below this value." })),
-        key_points: Type.Optional(Type.Array(Type.String(), { description: "Key points to index for search. Extracted highlights." }))
       }),
       async execute(_id: string, params: any) {
         // Pre-send junk filter
@@ -291,25 +320,14 @@ const sulcusPlugin = {
           };
         }
 
-        const res = await memoryCall("record_memory", { ...params, namespace, fold_name: params.fold_name || namespace });
-        // Check for storage limit error
-        if (res?.error === "storage_limit_reached") {
-          return {
-            content: [{ type: "text", text: `⚠️ Storage limit reached: ${res.message}` }],
-            details: res
-          };
+        if (!isAvailable) {
+          throw new Error(`Sulcus unavailable: ${nativeLoader.error || "WASM not loaded"}`);
         }
-        const provenance = res?.provenance || {
-          backend: backendMode,
-          namespace,
-          server: serverUrl || "local",
-          sync_available: !!serverUrl,
-          siu_classified: false,
-        };
-        const provenanceStr = `[${provenance.backend}] namespace: ${provenance.namespace || namespace}, server: ${provenance.server || "local"}`;
+
+        const res = await sulcusMem.add_memory(params.content, params.memory_type ?? null);
         return {
-          content: [{ type: "text", text: `Stored [${params.memory_type || "episodic"}] memory: "${(params.content || "").substring(0, 80)}..." → ${provenanceStr}` }],
-          details: { ...res, provenance }
+          content: [{ type: "text", text: `Stored [${params.memory_type || "episodic"}] memory: "${(params.content || "").substring(0, 80)}..." → [${backendMode}] namespace: ${namespace}` }],
+          details: { ...res, backend: backendMode, namespace }
         };
       }
     }, { name: "memory_store" });
@@ -317,26 +335,35 @@ const sulcusPlugin = {
     api.registerTool({
       name: "memory_status",
       label: "Memory Status",
-      description: "Check Sulcus memory backend status: connection, namespace, capabilities, and memory count.",
+      description: "Check Sulcus memory backend status: connection, namespace, capabilities, and hot nodes.",
       parameters: Type.Object({}),
       async execute(_id: string, _params: any) {
-        if (!hasBinary) {
+        if (!isAvailable) {
           return {
             content: [{ type: "text", text: JSON.stringify({
               status: "unavailable",
               backend: backendMode,
               namespace,
-              binary: binaryPath,
-              server: serverUrl || "none (env forwarding only)",
+              error: nativeLoader.error || "WASM not loaded",
+              storeLib: storeLibPath,
+              vectorsLib: vectorsLibPath,
+              wasmDir,
             }, null, 2) }],
           };
         }
         try {
-          // Ask sulcus-local for status via MCP
-          const status = await memoryCall("memory_status", {});
+          const hotNodes = await sulcusMem.list_hot_nodes(20);
+          const nodeList = hotNodes?.nodes ?? hotNodes ?? [];
+          const count = Array.isArray(nodeList) ? nodeList.length : 0;
           return {
-            content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
-            details: status
+            content: [{ type: "text", text: JSON.stringify({
+              status: "ok",
+              backend: backendMode,
+              namespace,
+              hot_node_count: count,
+              hot_nodes: nodeList,
+            }, null, 2) }],
+            details: { status: "ok", backend: backendMode, namespace, count }
           };
         } catch (e: any) {
           return {
@@ -344,7 +371,6 @@ const sulcusPlugin = {
               status: "error",
               backend: backendMode,
               namespace,
-              server: serverUrl || "none (env forwarding only)",
               error: e.message,
             }, null, 2) }],
           };
@@ -371,32 +397,23 @@ const sulcusPlugin = {
         api.logger.debug(`memory-sulcus: autoRecall is disabled, skipping context build`);
         return;
       }
+      if (!isAvailable) return;
       api.logger.info(`memory-sulcus: before_agent_start hook triggered for agent ${event.agentId}`);
       if (!event.prompt) return;
       try {
-        api.logger.debug(`memory-sulcus: building context for prompt: ${event.prompt.substring(0, 50)}...`);
-        // include_recent: false — OpenClaw already has conversation context.
-        // Only inject curated preferences, facts, and procedures from Sulcus.
-        const res = await memoryCall("build_context", { prompt: event.prompt, token_budget: 2000, include_recent: false });
-        // build_context returns either:
-        //   - plain XML string (new format, post-4dca467)
-        //   - { context: "...", token_estimate: N } (old format)
-        // The MCP client resolves to the parsed JSON if valid, or the raw MCP result object.
-        let context: string | undefined;
-        if (typeof res === "string") {
-          context = res;
-        } else if (res?.context) {
-          context = res.context;
-        } else if (res?.content?.[0]?.text) {
-          context = res.content[0].text;
+        api.logger.debug(`memory-sulcus: searching context for prompt: ${event.prompt.substring(0, 50)}...`);
+        const res = await sulcusMem.search_memory(event.prompt, 5);
+        const results = res?.results ?? [];
+        if (!results || results.length === 0) {
+          return { prependSystemContext: FALLBACK_AWARENESS };
         }
-        if (context) {
-          api.logger.info(`memory-sulcus: context build successful, injecting ${context.length} chars`);
-          return { prependSystemContext: context };
-        }
-        // Context was empty — inject fallback so LLM still knows about Sulcus
-        api.logger.warn(`memory-sulcus: build_context returned empty, injecting fallback awareness`);
-        return { prependSystemContext: FALLBACK_AWARENESS };
+        // Format results as a concise XML context block
+        const items = results.map((r: any) =>
+          `    <memory id="${r.id}" heat="${(r.current_heat ?? r.score ?? 0).toFixed(2)}" type="${r.memory_type ?? "unknown"}">${r.label ?? r.pointer_summary ?? ""}</memory>`
+        ).join("\n");
+        const context = `<sulcus_context token_budget="500" namespace="${namespace}">\n${items}\n</sulcus_context>`;
+        api.logger.info(`memory-sulcus: injecting ${results.length} recalled memories (${context.length} chars)`);
+        return { prependSystemContext: context };
       } catch (e) {
         // build_context failed — inject fallback so the LLM isn't flying blind
         api.logger.warn(`memory-sulcus: context build failed: ${e} — injecting fallback awareness`);
@@ -405,18 +422,12 @@ const sulcusPlugin = {
     });
 
     // agent_end: Do NOT auto-record raw conversation turns.
-    // The LLM has record_memory as an MCP tool — it decides what's worth remembering.
-    // Auto-recording every turn flooded the store with 2000+ junk episodic nodes
-    // containing placeholder vectors and raw JSON conversation payloads.
+    // The LLM has memory_store as a tool — it decides what's worth remembering.
     api.on("agent_end", async (event: any) => {
       api.logger.debug(`memory-sulcus: agent_end hook triggered for agent ${event.agentId} (no auto-record)`);
     });
 
-    api.registerService({
-      id: "memory-sulcus",
-      start: () => client.start(),
-      stop: () => client.stop()
-    });
+    // No service registration needed — no background process to manage
   }
 };
 

package/openclaw.plugin.json

@@ -2,23 +2,23 @@
   "id": "openclaw-sulcus",
   "kind": "memory",
   "name": "Sulcus",
-  "description": "Reactive, thermodynamic memory for AI agents. Persistent memory with heat-based decay, semantic search, triggers, and cross-agent sync. Connects to a user-configured Sulcus server (cloud or self-hosted). No data is sent unless the user provides an API key. Auto-recall and auto-capture are disabled by default; enable them explicitly in config.",
+  "description": "Reactive, thermodynamic memory for AI agents. Runs entirely local via WASM + native dylibs (embedded PostgreSQL, sulcus-vectors). No network calls. Optional cloud sync via sulcus-sync dylib when serverUrl/apiKey are configured.",
   "privacy": {
-    "consentModel": "explicit-config",
-    "consentNote": "Plugin requires a user-provided API key to function. Auto-recall and auto-capture are off by default. All automatic data transmission requires explicit opt-in via config fields.",
-    "crossNamespaceAccess": "tenant-scoped",
-    "crossNamespaceNote": "Agents within the same tenant can share memories across namespaces. Cross-namespace access is controlled by server-side ACL rules, not the plugin. Users configure ACL via the Sulcus dashboard.",
+    "consentModel": "local-first",
+    "consentNote": "Plugin runs entirely in-process. No network calls. All data stays local in ~/.sulcus/. Cloud sync is opt-in via serverUrl/apiKey config, handled by sulcus-sync dylib loaded by sulcus-local.",
+    "crossNamespaceAccess": "local-only",
+    "crossNamespaceNote": "All memory operations are local. Cross-namespace access only applies if cloud sync is configured separately.",
     "dataFlows": [
       {
-        "direction": "outbound",
-        "destination": "User-configured Sulcus server (default: api.sulcus.ca, Canada)",
-        "data": "Memory text content, search queries",
-        "trigger": "User invokes memory_store/memory_search tools explicitly. Auto-recall and auto-capture are disabled by default and must be opted into via config.",
-        "auth": "Bearer API key (user-provided, stored in plugin config)"
+        "direction": "local-only",
+        "destination": "Local embedded PostgreSQL (~/.sulcus/data/)",
+        "data": "Memory text content, embeddings, search queries",
+        "trigger": "User invokes memory_store/memory_recall tools. Auto-recall opt-in via config.",
+        "auth": "None — all local"
       }
     ],
-    "storage": "Memories stored on configured server, isolated by tenant and namespace. Self-hosted option available via sulcus-local.",
-    "optOut": "autoRecall and autoCapture default to false. No automatic data transmission occurs unless the user explicitly enables these features. To disable after enabling, set them back to false."
+    "storage": "Memories stored locally in embedded PostgreSQL at ~/.sulcus/data/. Zero network by default.",
+    "optOut": "autoRecall defaults to false. No automatic context injection unless explicitly enabled."
   },
   "configSchema": {
     "type": "object",
@@ -26,12 +26,20 @@
     "properties": {
       "serverUrl": {
         "type": "string",
-        "description": "Sulcus server URL",
-        "default": "https://api.sulcus.ca"
+        "description": "Sulcus cloud server URL (for sulcus-sync replication). Passed as SULCUS_SERVER_URL env var. Leave empty for local-only."
       },
       "apiKey": {
         "type": "string",
-        "description": "Sulcus API key (Bearer token). Required for any data transmission."
+        "description": "Sulcus API key (for sulcus-sync replication). Passed as SULCUS_API_KEY env var. Leave empty for local-only."
+      },
+      "libDir": {
+        "type": "string",
+        "description": "Directory containing native dylibs (libsulcus_store, libsulcus_vectors)",
+        "default": "~/.sulcus/lib"
+      },
+      "wasmDir": {
+        "type": "string",
+        "description": "Directory containing WASM module (sulcus_wasm.js, sulcus_wasm_bg.wasm). Defaults to plugin's wasm/ subdirectory."
       },
       "agentId": {
         "type": "string",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitalforgestudios/openclaw-sulcus",
-  "version": "2.0.0",
+  "version": "3.1.0",
   "description": "Sulcus — reactive, thermodynamic memory plugin for OpenClaw. Opt-in persistent memory with heat-based decay, semantic search, and cross-agent sync. Auto-recall and auto-capture disabled by default.",
   "keywords": [
     "openclaw",
@@ -39,11 +39,13 @@
   },
   "files": [
     "index.ts",
+    "wasm/",
     "openclaw.plugin.json",
     "README.md"
   ],
   "dependencies": {
-    "@sinclair/typebox": "^0.34.0"
+    "@sinclair/typebox": "^0.34.0",
+    "koffi": "^2.9.0"
   },
   "peerDependencies": {
     "openclaw": ">=2026.3.0"

package/wasm/sulcus_wasm.js

@@ -0,0 +1,607 @@
+/* @ts-self-types="./sulcus_wasm.d.ts" */
+
+/**
+ * The main SULCUS memory handle.  Create once; keep alive for the session.
+ */
+class SulcusMem {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SulcusMem.prototype);
+        obj.__wbg_ptr = ptr;
+        SulcusMemFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SulcusMemFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sulcusmem_free(ptr, 0);
+    }
+    /**
+     * Record a new image memory.
+     *
+     * @param label        Human-readable label for the image (optional).
+     * @param bitmap       The raw image bytes (Uint8Array).
+     * @param mime         MIME type (e.g., "image/png").
+     * @param namespace    Optional: partition memory by namespace.
+     * @returns            `{ id: string, status: "added" }`
+     * @param {string | null | undefined} label
+     * @param {Uint8Array} bitmap
+     * @param {string} mime
+     * @param {string | null} [namespace]
+     * @returns {Promise<any>}
+     */
+    add_image_memory(label, bitmap, mime, namespace) {
+        var ptr0 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bitmap, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(mime, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(namespace) ? 0 : passStringToWasm0(namespace, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm.sulcusmem_add_image_memory(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        return ret;
+    }
+    /**
+     * Record a new memory.
+     *
+     * @param text         The raw text to remember.
+     * @param memory_type  Optional: "episodic" | "semantic" | "preference" | "procedural".
+     * @returns            `{ id: string, status: "added" }`
+     * @param {string} text
+     * @param {string | null} [memory_type]
+     * @returns {Promise<any>}
+     */
+    add_memory(text, memory_type) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(memory_type) ? 0 : passStringToWasm0(memory_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.sulcusmem_add_memory(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * Create a new `SulcusMem` instance.
+     *
+     * @param query_fn       `async (sql: string, params: any[]) => any[]`
+     * @param embed_fn       `async (text: string) => Float32Array`
+     * @param embed_image_fn  Optional: `async (bitmap: Uint8Array) => Float32Array`
+     * @param {Function} query_fn
+     * @param {Function} embed_fn
+     * @param {Function | null} [embed_image_fn]
+     * @returns {SulcusMem}
+     */
+    static create(query_fn, embed_fn, embed_image_fn) {
+        const ret = wasm.sulcusmem_create(query_fn, embed_fn, isLikeNone(embed_image_fn) ? 0 : addToExternrefTable0(embed_image_fn));
+        return SulcusMem.__wrap(ret);
+    }
+    /**
+     * List nodes ordered by current_heat DESC.
+     *
+     * @param limit  Max nodes to return (default 20).
+     * @returns      `{ nodes: Array<{ id, label, pointer_summary, current_heat, memory_type }> }`
+     * @param {number | null} [limit]
+     * @returns {Promise<any>}
+     */
+    list_hot_nodes(limit) {
+        const ret = wasm.sulcusmem_list_hot_nodes(this.__wbg_ptr, isLikeNone(limit) ? 0x100000001 : (limit) >>> 0);
+        return ret;
+    }
+    /**
+     * Search for similar memories using an image as query (CLIP).
+     *
+     * @param bitmap  The raw image bytes (Uint8Array).
+     * @param limit   Max results (default 10).
+     * @returns       `{ results: Array<{ id, label, pointer_summary, score }> }`
+     * @param {Uint8Array} bitmap
+     * @param {number | null} [limit]
+     * @returns {Promise<any>}
+     */
+    search_by_image(bitmap, limit) {
+        const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sulcusmem_search_by_image(this.__wbg_ptr, ptr0, len0, isLikeNone(limit) ? 0x100000001 : (limit) >>> 0);
+        return ret;
+    }
+    /**
+     * Hybrid FTS + cosine similarity search using native pgvector operators.
+     *
+     * @param query   Natural language query.
+     * @param limit   Max results (default 10).
+     * @returns       `{ results: Array<{ id, label, pointer_summary, score }> }`
+     * @param {string} query
+     * @param {number | null} [limit]
+     * @returns {Promise<any>}
+     */
+    search_memory(query, limit) {
+        const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sulcusmem_search_memory(this.__wbg_ptr, ptr0, len0, isLikeNone(limit) ? 0x100000001 : (limit) >>> 0);
+        return ret;
+    }
+    /**
+     * Run one thermodynamics cycle: decay all nodes, spread heat along edges,
+     * rebuild `active_index`.
+     *
+     * @param decay   Heat decay factor per tick (default 0.85).
+     * @param spread  Spreading activation weight (default 0.5).
+     * @param limit   Max nodes kept in `active_index` (default 20).
+     * @returns       `{ status: "tick_complete" }`
+     * @param {number} decay
+     * @param {number} spread
+     * @param {number} limit
+     * @returns {Promise<any>}
+     */
+    tick(decay, spread, limit) {
+        const ret = wasm.sulcusmem_tick(this.__wbg_ptr, decay, spread, limit);
+        return ret;
+    }
+    /**
+     * Run one thermodynamics cycle using the configurable ThermoConfig engine.
+     *
+     * @param config_json  JSON string of ThermoConfig (or `null` for defaults).
+     * @returns            `{ status: "tick_complete", engine: "thermo_v2", ... }`
+     * @param {string | null} [config_json]
+     * @returns {Promise<any>}
+     */
+    tick_v2(config_json) {
+        var ptr0 = isLikeNone(config_json) ? 0 : passStringToWasm0(config_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sulcusmem_tick_v2(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) SulcusMem.prototype[Symbol.dispose] = SulcusMem.prototype.free;
+exports.SulcusMem = SulcusMem;
+
+function on_init() {
+    wasm.on_init();
+}
+exports.on_init = on_init;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_debug_string_0bc8482c6e3508ae: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_string_get_72fb696202c56729: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg__wbg_cb_unref_d9b87ff7982e3b21: function(arg0) {
+            arg0._wbg_cb_unref();
+        },
+        __wbg_call_389efe28435a9388: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_call_4708e0c13bdc8e95: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_call_812d25f1510c13c8: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.call(arg1, arg2, arg3);
+            return ret;
+        }, arguments); },
+        __wbg_error_7534b8e9a36f1ab4: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_getRandomValues_71d446877d8b0ad4: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_instanceof_Float32Array_c882a172bf41d92a: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Float32Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Promise_0094681e3519d6ec: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Promise;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_length_9a7876c9728a0979: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_new_3eb36ae241fe6f44: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_8a6f238a6ece86ea: function() {
+            const ret = new Error();
+            return ret;
+        },
+        __wbg_new_b5d9e2fb389fef91: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen__convert__closures_____invoke__h8e726e14fdbe3765(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = state0.b = 0;
+            }
+        },
+        __wbg_new_from_slice_a3d2629dc1826784: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_no_args_1c7c842f08d00ebb: function(arg0, arg1) {
+            const ret = new Function(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_parse_708461a1feddfb38: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return ret;
+        }, arguments); },
+        __wbg_prototypesetcall_c7e6a26aeade796d: function(arg0, arg1, arg2) {
+            Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_push_8ffdcb2063340ba5: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
+        __wbg_queueMicrotask_0aa0a927f78f5d98: function(arg0) {
+            const ret = arg0.queueMicrotask;
+            return ret;
+        },
+        __wbg_queueMicrotask_5bb536982f78a56f: function(arg0) {
+            queueMicrotask(arg0);
+        },
+        __wbg_resolve_002c4b7d9d8f6b64: function(arg0) {
+            const ret = Promise.resolve(arg0);
+            return ret;
+        },
+        __wbg_stack_0ed75d68575b0f3c: function(arg0, arg1) {
+            const ret = arg1.stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_static_accessor_GLOBAL_12837167ad935116: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_SELF_a621d3dfbb60d0ce: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_WINDOW_f8727f0cf888e0bd: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_stringify_8d1cc6ff383e8bae: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_then_0d9fe2c7b1857d32: function(arg0, arg1, arg2) {
+            const ret = arg0.then(arg1, arg2);
+            return ret;
+        },
+        __wbg_then_b9e7b3b5f1a9e1b5: function(arg0, arg1) {
+            const ret = arg0.then(arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 170, function: Function { arguments: [Externref], shim_idx: 171, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__he93a1b3377269182, wasm_bindgen__convert__closures_____invoke__h668261b123d2ac6c);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: 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);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./sulcus_wasm_bg.js": import0,
+    };
+}
+
+function wasm_bindgen__convert__closures_____invoke__h668261b123d2ac6c(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h668261b123d2ac6c(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h8e726e14fdbe3765(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h8e726e14fdbe3765(arg0, arg1, arg2, arg3);
+}
+
+const SulcusMemFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sulcusmem_free(ptr >>> 0, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/sulcus_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+const wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();