@lotargo/memory_plugin 1.5.3 → 1.6.0

package/mcp-server/ingest/pipeline.js

@@ -5,9 +5,11 @@ import { getDatabase, BLOBS_DIR } from "../db/database.js";
 import { saveBlob, deleteBlob } from "../storage/blob_store.js";
 import { normalizeContent, fetchUrlContent } from "./normalizer.js";
 import { buildTripleHierarchy } from "./chunker.js";
-import { embedText, embedBatch, vectorToBuffer } from "../ml/model_manager.js";
+import { embedBatch, vectorToBuffer } from "../ml/model_manager.js";
 import { buildGraphEdges, saveGraphEdges } from "../graph/graph_extractor.js";
 import { getConfig } from "../config/config_manager.js";
+import { assertIngestPathAllowed } from "../security/path_guard.js";
+import { logger } from "../logger.js";
 
 export async function ingestDocument({
   content,
@@ -34,9 +36,10 @@ export async function ingestDocument({
     const filePath = effectivePath || content;
     const needsRead = !content || content === filePath;
     if (needsRead && filePath) {
-      const ext = extname(filePath).toLowerCase();
+      const safePath = assertIngestPathAllowed(filePath);
+      const ext = extname(safePath).toLowerCase();
       const isBinary = [".pdf", ".docx", ".xlsx", ".xls"].includes(ext);
-      content = await readFile(filePath, isBinary ? null : "utf-8");
+      content = await readFile(safePath, isBinary ? null : "utf-8");
       effectivePath = filePath;
     }
   }
@@ -77,7 +80,7 @@ export async function ingestDocument({
     }
   } else {
     for (const micro of hierarchy.microChunks) {
-      micro.vector = Buffer.alloc(384 * 4);
+      micro.vector = Buffer.alloc(0);
     }
   }
 
@@ -155,7 +158,7 @@ export async function ingestDocument({
       const exportedData = await exportDocumentData(docId, db);
       await enqueueSyncTask("ingest_document", docId, exportedData);
     } catch (err) {
-      console.error("Failed to queue document ingest sync task:", err.message);
+      logger.error("Failed to queue document ingest sync task:", err.message);
     }
   }
 
@@ -226,9 +229,94 @@ export async function deleteDocument(docIdOrPath, customDb = null, customBlobDir
       const { enqueueSyncTask } = await import("../db/sync_queue.js");
       await enqueueSyncTask("delete_document", docIdOrPath);
     } catch (err) {
-      console.error("Failed to queue document delete sync task:", err.message);
+      logger.error("Failed to queue document delete sync task:", err.message);
     }
   }
 
   return { deleted: true, docId: doc.id, title: doc.title, linksCleaned: true };
 }
+
+export async function reindexEmbeddings({
+  model = null,
+  dimension = null,
+  customDb = null,
+  embedFn = null,
+  progressCallback = null,
+} = {}) {
+  const db = customDb || await getDatabase();
+  const config = getConfig();
+  const targetModel = model || config.embeddingModel || "Xenova/multilingual-e5-small";
+  const targetDim = dimension !== null && dimension !== undefined ? Number(dimension) : (config.vectorDimension || 0);
+
+  const countRow = await db.prepare("SELECT COUNT(*) as cnt FROM micro_chunks").get();
+  const total = countRow ? countRow.cnt : 0;
+  if (total === 0) return { reindexed: 0, documentsAffected: 0, model: targetModel, dimension: targetDim };
+
+  const rows = await db.prepare(`
+    SELECT m.id, m.doc_id, m.content, s.breadcrumbs, d.title as doc_title
+    FROM micro_chunks m
+    LEFT JOIN sections s ON m.section_id = s.id
+    LEFT JOIN documents d ON m.doc_id = d.id
+    ORDER BY m.doc_id, m.id
+  `).all();
+
+  const items = rows.map((r) => ({
+    id: r.id,
+    doc_id: r.doc_id,
+    text: r.breadcrumbs
+      ? `${r.content}\n\nContext: ${r.doc_title || ""} > ${r.breadcrumbs}`
+      : `${r.content}\n\nContext: ${r.doc_title || ""}`,
+  }));
+
+  const defaultEmbed = async (texts) =>
+    embedBatch(texts, false, targetModel, progressCallback, null, {}, targetDim || null);
+  const embed = embedFn || defaultEmbed;
+
+  const BATCH_SIZE = config.batchSize || 12;
+  const vectors = [];
+  for (let i = 0; i < items.length; i += BATCH_SIZE) {
+    const batch = items.slice(i, i + BATCH_SIZE);
+    const batchVecs = await embed(batch.map((b) => b.text));
+    if (!batchVecs || batchVecs.length !== batch.length) {
+      throw new Error(`Embedding batch returned ${batchVecs ? batchVecs.length : 0} vectors, expected ${batch.length}`);
+    }
+    for (let j = 0; j < batch.length; j++) {
+      vectors.push({ id: batch[j].id, doc_id: batch[j].doc_id, vector: vectorToBuffer(batchVecs[j]) });
+    }
+    if (progressCallback) progressCallback({ done: vectors.length, total });
+  }
+
+  await db.exec("BEGIN IMMEDIATE;");
+  try {
+    const stmt = db.prepare("UPDATE micro_chunks SET vector = ? WHERE id = ?;");
+    for (const v of vectors) {
+      await stmt.run(v.vector, v.id);
+    }
+    await db.exec("COMMIT;");
+  } catch (err) {
+    await db.exec("ROLLBACK;");
+    throw new Error(`Re-index transaction failed: ${err.message}`);
+  }
+
+  const affectedDocIds = [...new Set(items.map((i) => i.doc_id).filter(Boolean))];
+
+  if (config.mode === "hybrid-sync") {
+    try {
+      const { enqueueSyncTask } = await import("../db/sync_queue.js");
+      const { exportDocumentData } = await import("./exporter.js");
+      for (const docId of affectedDocIds) {
+        const exportedData = await exportDocumentData(docId, db);
+        await enqueueSyncTask("ingest_document", docId, exportedData);
+      }
+    } catch (err) {
+      logger.error("Failed to queue document re-index sync tasks:", err.message);
+    }
+  }
+
+  return {
+    reindexed: vectors.length,
+    documentsAffected: affectedDocIds.length,
+    model: targetModel,
+    dimension: targetDim,
+  };
+}

package/mcp-server/logger.js

@@ -0,0 +1,49 @@
+// Central logger. Everything goes to stderr: stdout is the MCP JSON-RPC
+// channel and any stray write there corrupts the protocol stream.
+//
+// Level is taken from MEMORY_LOG_LEVEL (silent|error|warn|info|debug),
+// defaulting to "warn". Hosts embedding the server can swap the sink with
+// setLogSink() — e.g. to forward into the OpenCode client log.
+
+const LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
+
+function envLevel() {
+  const raw = String(process.env.MEMORY_LOG_LEVEL || "").toLowerCase();
+  return raw in LEVELS ? raw : "warn";
+}
+
+let currentLevel = envLevel();
+let sink = (level, message) => {
+  process.stderr.write(`[memory:${level}] ${message}\n`);
+};
+
+export function setLogLevel(level) {
+  if (level in LEVELS) currentLevel = level;
+}
+
+export function getLogLevel() {
+  return currentLevel;
+}
+
+export function setLogSink(fn) {
+  sink = typeof fn === "function" ? fn : sink;
+}
+
+function emit(level, args) {
+  if (LEVELS[level] > LEVELS[currentLevel]) return;
+  const message = args
+    .map((a) => (a instanceof Error ? a.stack || a.message : typeof a === "string" ? a : JSON.stringify(a)))
+    .join(" ");
+  try {
+    sink(level, message);
+  } catch {}
+}
+
+export const logger = {
+  error: (...args) => emit("error", args),
+  warn: (...args) => emit("warn", args),
+  info: (...args) => emit("info", args),
+  debug: (...args) => emit("debug", args),
+};
+
+export default logger;

package/mcp-server/memory.js

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync } from "fs";
 import { join, basename, resolve } from "path";
 import { homedir } from "os";
 import { resolveProjectIdentity } from "./identity.js";
+import { logger } from "./logger.js";
 
 function resolveMemoryDir() {
   if (process.env.MEMORY_DIR) return process.env.MEMORY_DIR;
@@ -93,10 +94,6 @@ export function parseMeta(content) {
   return { key: m ? m[1].trim() : null };
 }
 
-function isSimpleKey(key) {
-  return /^[a-zA-Z0-9_-]+$/.test(key);
-}
-
 export async function readMemory(key) {
   if (!key) return [];
   const { getConfig } = await import("./config/config_manager.js");
@@ -110,7 +107,7 @@ export async function readMemory(key) {
         return row.content.split("\n").filter((l) => l.startsWith("- ["));
       }
     } catch (err) {
-      console.error("Failed to read memory from cloud database:", err.message);
+      logger.error("Failed to read memory from cloud database:", err.message);
     }
     return [];
   }
@@ -121,7 +118,7 @@ export async function readMemory(key) {
       const { ensureReverseSync } = await import("./db/sync_queue.js");
       await ensureReverseSync();
     } catch (err) {
-      console.error("Failed to reverse-sync before read:", err.message);
+      logger.error("Failed to reverse-sync before read:", err.message);
     }
   }
   if (existsSync(fp)) {
@@ -171,7 +168,7 @@ export async function writeMemory(key, entries) {
         ON CONFLICT(key) DO UPDATE SET content = excluded.content, updated_at = excluded.updated_at;
       `).run(key, content, Date.now());
     } catch (err) {
-      console.error("Failed to write memory to cloud database:", err.message);
+      logger.error("Failed to write memory to cloud database:", err.message);
     }
     return;
   }
@@ -183,7 +180,7 @@ export async function writeMemory(key, entries) {
       const { enqueueSyncTask } = await import("./db/sync_queue.js");
       await enqueueSyncTask("write_memory", key, content);
     } catch (err) {
-      console.error("Failed to queue memory sync task:", err.message);
+      logger.error("Failed to queue memory sync task:", err.message);
     }
   }
 }
@@ -214,7 +211,7 @@ export async function listProjectStores() {
       stores.sort((a, b) => a.basename.localeCompare(b.basename));
       return stores;
     } catch (err) {
-      console.error("Failed to list memory stores from cloud database:", err.message);
+      logger.error("Failed to list memory stores from cloud database:", err.message);
     }
     return [];
   }

package/mcp-server/ml/gpu_monitor.js

@@ -1,166 +1,169 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-const execFileAsync = promisify(execFile);
-
-export async function getGpuUtilizationAsync() {
-  try {
-    const { stdout } = await execFileAsync("nvidia-smi", 
-      ["--query-gpu=utilization.gpu", "--format=csv,noheader,nounits"],
-      { timeout: 1000 }
-    );
-    const val = parseInt(stdout.trim(), 10);
-    if (!isNaN(val)) return val;
-  } catch {}
-
-  if (process.platform === "win32") {
-    try {
-      const { stdout } = await execFileAsync("powershell", 
-        ["-NoProfile", "-Command", "(Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine | Measure-Object -Property UtilizationPercentage -Sum).Sum"],
-        { timeout: 1500 }
-      );
-      const val = parseInt(stdout.trim(), 10);
-      if (!isNaN(val)) return Math.min(100, val);
-    } catch {}
-  }
-
-  return null;
-}
-
-export class GpuMonitor {
-  constructor(sampleIntervalMs = 100) {
-    this.intervalMs = sampleIntervalMs;
-    this.samples = [];
-    this.timer = null;
-    this.isMonitoring = false;
-  }
-
-  start() {
-    this.samples = [];
-    this.isMonitoring = true;
-    this.sample();
-
-    this.timer = setInterval(() => {
-      if (this.isMonitoring) {
-        this.sample();
-      }
-    }, this.intervalMs);
-  }
-
-  async sample() {
-    const util = await getGpuUtilizationAsync();
-    if (util !== null) {
-      this.samples.push(util);
-    }
-  }
-
-  stop() {
-    this.isMonitoring = false;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-
-    if (this.samples.length === 0) {
-      return { avg: null, peak: null, samplesCount: 0 };
-    }
-
-    const max = Math.max(...this.samples);
-    const sum = this.samples.reduce((a, b) => a + b, 0);
-    const avg = Math.round(sum / this.samples.length);
-
-    return {
-      avg,
-      peak: max,
-      samplesCount: this.samples.length,
-      samples: this.samples,
-    };
-  }
-}
-
-export class ExecutionTracer {
-  constructor(name = "Batch Inference") {
-    this.name = name;
-    this.stages = [];
-    this.currentStage = null;
-    this.startTime = Date.now();
-  }
-
-  startStage(stageName, category = "CPU") {
-    const now = performance.now();
-    if (this.currentStage) {
-      this.currentStage.duration = now - this.currentStage.startTime;
-      this.stages.push(this.currentStage);
-    }
-    this.currentStage = {
-      name: stageName,
-      category, // "CPU" or "GPU"
-      startTime: now,
-      duration: 0,
-    };
-  }
-
-  endStage() {
-    const now = performance.now();
-    if (this.currentStage) {
-      this.currentStage.duration = now - this.currentStage.startTime;
-      this.stages.push(this.currentStage);
-      this.currentStage = null;
-    }
-  }
-
-  getSummary(gpuStats = null) {
-    this.endStage();
-    const totalMs = this.stages.reduce((sum, s) => sum + s.duration, 0);
-
-    const breakdown = this.stages.map((s) => ({
-      name: s.name,
-      category: s.category,
-      durationMs: parseFloat(s.duration.toFixed(2)),
-      pct: totalMs > 0 ? parseFloat(((s.duration / totalMs) * 100).toFixed(1)) : 0,
-    }));
-
-    const cpuTime = this.stages.filter((s) => s.category === "CPU").reduce((sum, s) => sum + s.duration, 0);
-    const gpuTime = this.stages.filter((s) => s.category === "GPU").reduce((sum, s) => sum + s.duration, 0);
-
-    return {
-      name: this.name,
-      totalMs: parseFloat(totalMs.toFixed(2)),
-      cpuMs: parseFloat(cpuTime.toFixed(2)),
-      gpuMs: parseFloat(gpuTime.toFixed(2)),
-      cpuPct: totalMs > 0 ? parseFloat(((cpuTime / totalMs) * 100).toFixed(1)) : 0,
-      gpuPct: totalMs > 0 ? parseFloat(((gpuTime / totalMs) * 100).toFixed(1)) : 0,
-      breakdown,
-      gpuStats,
-    };
-  }
-
-  printTraceReport(gpuStats = null, minGpuThreshold = 0) {
-    const summary = this.getSummary(gpuStats);
-    const line = "─".repeat(65);
-
-    console.log(`\n┌${line}┐`);
-    console.log(`│ CPU/GPU OPERATION TRACE & BOTTLENECK PROFILE: ${summary.name.padEnd(16)} │`);
-    console.log(`├${line}┤`);
-
-    for (const b of summary.breakdown) {
-      const icon = b.category === "GPU" ? "⚡ [GPU]" : "💻 [CPU]";
-      const label = `${icon} ${b.name}`.padEnd(42);
-      const timeStr = `${b.durationMs.toFixed(1)}ms (${b.pct.toFixed(1)}%)`.padStart(18);
-      console.log(`│ ${label}${timeStr} │`);
-    }
-
-    console.log(`├${line}┤`);
-    console.log(`│ Total Batch Time: ${summary.totalMs.toFixed(1)}ms | CPU Time: ${summary.cpuMs.toFixed(1)}ms (${summary.cpuPct}%) | GPU Engine Time: ${summary.gpuMs.toFixed(1)}ms (${summary.gpuPct}%) │`);
-
-    if (gpuStats && gpuStats.peak !== null) {
-      const statsBadge = `Peak: ${gpuStats.peak}%, Avg: ${gpuStats.avg}%`;
-      console.log(`│ GPU Hardware Load: ${statsBadge.padEnd(44)} │`);
-      console.log(`└${line}┘\n`);
-    } else {
-      console.log(`└${line}┘\n`);
-    }
-
-    return summary;
-  }
-}
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export async function getGpuUtilizationAsync() {
+  try {
+    const { stdout } = await execFileAsync("nvidia-smi", 
+      ["--query-gpu=utilization.gpu", "--format=csv,noheader,nounits"],
+      { timeout: 1000 }
+    );
+    const val = parseInt(stdout.trim(), 10);
+    if (!isNaN(val)) return val;
+  } catch {}
+
+  if (process.platform === "win32") {
+    try {
+      const { stdout } = await execFileAsync("powershell", 
+        ["-NoProfile", "-Command", "(Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine | Measure-Object -Property UtilizationPercentage -Sum).Sum"],
+        { timeout: 1500 }
+      );
+      const val = parseInt(stdout.trim(), 10);
+      if (!isNaN(val)) return Math.min(100, val);
+    } catch {}
+  }
+
+  return null;
+}
+
+export class GpuMonitor {
+  constructor(sampleIntervalMs = 100) {
+    this.intervalMs = sampleIntervalMs;
+    this.samples = [];
+    this.timer = null;
+    this.isMonitoring = false;
+  }
+
+  start() {
+    this.samples = [];
+    this.isMonitoring = true;
+    this.sample();
+
+    this.timer = setInterval(() => {
+      if (this.isMonitoring) {
+        this.sample();
+      }
+    }, this.intervalMs);
+  }
+
+  async sample() {
+    const util = await getGpuUtilizationAsync();
+    if (util !== null) {
+      this.samples.push(util);
+    }
+  }
+
+  stop() {
+    this.isMonitoring = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+
+    if (this.samples.length === 0) {
+      return { avg: null, peak: null, samplesCount: 0 };
+    }
+
+    const max = Math.max(...this.samples);
+    const sum = this.samples.reduce((a, b) => a + b, 0);
+    const avg = Math.round(sum / this.samples.length);
+
+    return {
+      avg,
+      peak: max,
+      samplesCount: this.samples.length,
+      samples: this.samples,
+    };
+  }
+}
+
+export class ExecutionTracer {
+  constructor(name = "Batch Inference") {
+    this.name = name;
+    this.stages = [];
+    this.currentStage = null;
+    this.startTime = Date.now();
+  }
+
+  startStage(stageName, category = "CPU") {
+    const now = performance.now();
+    if (this.currentStage) {
+      this.currentStage.duration = now - this.currentStage.startTime;
+      this.stages.push(this.currentStage);
+    }
+    this.currentStage = {
+      name: stageName,
+      category, // "CPU" or "GPU"
+      startTime: now,
+      duration: 0,
+    };
+  }
+
+  endStage() {
+    const now = performance.now();
+    if (this.currentStage) {
+      this.currentStage.duration = now - this.currentStage.startTime;
+      this.stages.push(this.currentStage);
+      this.currentStage = null;
+    }
+  }
+
+  getSummary(gpuStats = null) {
+    this.endStage();
+    const totalMs = this.stages.reduce((sum, s) => sum + s.duration, 0);
+
+    const breakdown = this.stages.map((s) => ({
+      name: s.name,
+      category: s.category,
+      durationMs: parseFloat(s.duration.toFixed(2)),
+      pct: totalMs > 0 ? parseFloat(((s.duration / totalMs) * 100).toFixed(1)) : 0,
+    }));
+
+    const cpuTime = this.stages.filter((s) => s.category === "CPU").reduce((sum, s) => sum + s.duration, 0);
+    const gpuTime = this.stages.filter((s) => s.category === "GPU").reduce((sum, s) => sum + s.duration, 0);
+
+    return {
+      name: this.name,
+      totalMs: parseFloat(totalMs.toFixed(2)),
+      cpuMs: parseFloat(cpuTime.toFixed(2)),
+      gpuMs: parseFloat(gpuTime.toFixed(2)),
+      cpuPct: totalMs > 0 ? parseFloat(((cpuTime / totalMs) * 100).toFixed(1)) : 0,
+      gpuPct: totalMs > 0 ? parseFloat(((gpuTime / totalMs) * 100).toFixed(1)) : 0,
+      breakdown,
+      gpuStats,
+    };
+  }
+
+  printTraceReport(gpuStats = null, minGpuThreshold = 0) {
+    const summary = this.getSummary(gpuStats);
+    const line = "─".repeat(65);
+    // stderr, never stdout: stdout is the MCP JSON-RPC channel and any stray
+    // write there corrupts the protocol stream.
+    const out = (msg) => console.error(msg);
+
+    out(`\n┌${line}┐`);
+    out(`│ CPU/GPU OPERATION TRACE & BOTTLENECK PROFILE: ${summary.name.padEnd(16)} │`);
+    out(`├${line}┤`);
+
+    for (const b of summary.breakdown) {
+      const icon = b.category === "GPU" ? "⚡ [GPU]" : "💻 [CPU]";
+      const label = `${icon} ${b.name}`.padEnd(42);
+      const timeStr = `${b.durationMs.toFixed(1)}ms (${b.pct.toFixed(1)}%)`.padStart(18);
+      out(`│ ${label}${timeStr} │`);
+    }
+
+    out(`├${line}┤`);
+    out(`│ Total Batch Time: ${summary.totalMs.toFixed(1)}ms | CPU Time: ${summary.cpuMs.toFixed(1)}ms (${summary.cpuPct}%) | GPU Engine Time: ${summary.gpuMs.toFixed(1)}ms (${summary.gpuPct}%) │`);
+
+    if (gpuStats && gpuStats.peak !== null) {
+      const statsBadge = `Peak: ${gpuStats.peak}%, Avg: ${gpuStats.avg}%`;
+      out(`│ GPU Hardware Load: ${statsBadge.padEnd(44)} │`);
+      out(`└${line}┘\n`);
+    } else {
+      out(`└${line}┘\n`);
+    }
+
+    return summary;
+  }
+}

package/mcp-server/ml/model_manager.js

@@ -255,7 +255,7 @@ export function formatInputText(text, isQuery = false, modelName = null, instruc
   return cleanText;
 }
 
-export async function embedText(text, isQuery = false, modelName = null, progressCallback = null, instruction = null) {
+export async function embedText(text, isQuery = false, modelName = null, progressCallback = null, instruction = null, vectorDimension = null) {
   const targetModel = modelName || getConfig().embeddingModel || "Xenova/multilingual-e5-small";
   const extractor = await getExtractor(targetModel, progressCallback);
   const formattedText = formatInputText(text, isQuery, targetModel, instruction);
@@ -270,14 +270,14 @@ export async function embedText(text, isQuery = false, modelName = null, progres
     max_length: maxLen,
   });
 
-  const result = output.data.slice();
+  const result = applyFixedDimension(output.data.slice(), vectorDimension);
   if (typeof output.dispose === 'function') {
     output.dispose();
   }
   return result;
 }
 
-export async function embedBatch(texts, isQuery = false, modelName = null, progressCallback = null, instruction = null, traceOptions = {}) {
+export async function embedBatch(texts, isQuery = false, modelName = null, progressCallback = null, instruction = null, traceOptions = {}, vectorDimension = null) {
   if (!texts || texts.length === 0) return [];
   const targetModel = modelName || getConfig().embeddingModel || "Xenova/multilingual-e5-small";
   
@@ -356,7 +356,7 @@ export async function embedBatch(texts, isQuery = false, modelName = null, progr
 
       for (let i = 0; i < batchSize; i++) {
         const byteOffset = i * vectorDim;
-        allResults.push(rawData.slice(byteOffset, byteOffset + vectorDim));
+        allResults.push(applyFixedDimension(rawData.slice(byteOffset, byteOffset + vectorDim), vectorDimension));
       }
 
       if (typeof output.dispose === 'function') {
@@ -474,6 +474,19 @@ export function vectorToBuffer(float32Array) {
   return Buffer.from(float32Array.buffer, float32Array.byteOffset, float32Array.byteLength);
 }
 
+export function resizeVector(float32Array, targetDim) {
+  const dim = Number(targetDim);
+  if (!dim || dim <= 0 || !float32Array || float32Array.length === dim) return float32Array;
+  const out = new Float32Array(dim);
+  out.set(float32Array.subarray(0, Math.min(float32Array.length, dim)));
+  return out;
+}
+
+function applyFixedDimension(float32Array, overrideDim = null) {
+  const dim = overrideDim !== null && overrideDim !== undefined ? overrideDim : (getConfig().vectorDimension || 0);
+  return resizeVector(float32Array, dim);
+}
+
 export function bufferToVector(buffer) {
   return new Float32Array(
     buffer.buffer,