@memories.sh/cli 0.2.0 → 0.2.2

package/dist/chunk-4GNYCHD4.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+import {
+  getDb
+} from "./chunk-BDPB4ABQ.js";
+
+// src/lib/embeddings.ts
+import { pipeline } from "@xenova/transformers";
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync, mkdirSync } from "fs";
+var MODEL_NAME = "Xenova/gte-base";
+var EMBEDDING_DIM = 768;
+var embedder = null;
+var modelLoading = null;
+function getModelCacheDir() {
+  const cacheDir = join(homedir(), ".cache", "memories", "models");
+  if (!existsSync(cacheDir)) {
+    mkdirSync(cacheDir, { recursive: true });
+  }
+  return cacheDir;
+}
+async function getEmbedder() {
+  if (embedder) return embedder;
+  if (modelLoading) return modelLoading;
+  modelLoading = (async () => {
+    const cacheDir = getModelCacheDir();
+    process.env.TRANSFORMERS_CACHE = cacheDir;
+    embedder = await pipeline("feature-extraction", MODEL_NAME, {
+      cache_dir: cacheDir,
+      quantized: true
+      // Use quantized model for faster loading
+    });
+    return embedder;
+  })();
+  return modelLoading;
+}
+async function getEmbedding(text) {
+  const model = await getEmbedder();
+  const output = await model(text, {
+    pooling: "mean",
+    normalize: true
+  });
+  const data = output.data;
+  return new Float32Array(data);
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function embeddingToBuffer(embedding) {
+  return Buffer.from(embedding.buffer);
+}
+function bufferToEmbedding(buffer) {
+  return new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4);
+}
+async function ensureEmbeddingsSchema() {
+  const db = await getDb();
+  const tableInfo = await db.execute("PRAGMA table_info(memories)");
+  const columns = tableInfo.rows;
+  const hasEmbedding = columns.some((c) => c.name === "embedding");
+  if (!hasEmbedding) {
+    await db.execute("ALTER TABLE memories ADD COLUMN embedding BLOB");
+  }
+}
+async function storeEmbedding(memoryId, embedding) {
+  const db = await getDb();
+  await ensureEmbeddingsSchema();
+  const buffer = embeddingToBuffer(embedding);
+  await db.execute({
+    sql: "UPDATE memories SET embedding = ? WHERE id = ?",
+    args: [buffer, memoryId]
+  });
+}
+async function getStoredEmbedding(memoryId) {
+  const db = await getDb();
+  const result = await db.execute({
+    sql: "SELECT embedding FROM memories WHERE id = ?",
+    args: [memoryId]
+  });
+  if (result.rows.length === 0) return null;
+  const row = result.rows[0];
+  if (!row.embedding) return null;
+  return new Float32Array(row.embedding);
+}
+async function semanticSearch(query, opts) {
+  const db = await getDb();
+  const limit = opts?.limit ?? 10;
+  const threshold = opts?.threshold ?? 0.3;
+  const queryEmbedding = await getEmbedding(query);
+  let sql = `
+    SELECT id, content, embedding, scope, project_id 
+    FROM memories 
+    WHERE deleted_at IS NULL AND embedding IS NOT NULL
+  `;
+  const args = [];
+  if (opts?.projectId) {
+    sql += " AND (scope = 'global' OR (scope = 'project' AND project_id = ?))";
+    args.push(opts.projectId);
+  }
+  const result = await db.execute({ sql, args });
+  const scored = [];
+  for (const row of result.rows) {
+    const r = row;
+    if (!r.embedding) continue;
+    const memEmbedding = new Float32Array(r.embedding);
+    const score = cosineSimilarity(queryEmbedding, memEmbedding);
+    if (score >= threshold) {
+      scored.push({ id: r.id, content: r.content, score });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit);
+}
+async function isModelAvailable() {
+  try {
+    await getEmbedder();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getEmbeddingDimension() {
+  return EMBEDDING_DIM;
+}
+
+export {
+  getEmbedding,
+  cosineSimilarity,
+  embeddingToBuffer,
+  bufferToEmbedding,
+  ensureEmbeddingsSchema,
+  storeEmbedding,
+  getStoredEmbedding,
+  semanticSearch,
+  isModelAvailable,
+  getEmbeddingDimension
+};

package/dist/chunk-BDPB4ABQ.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+// src/lib/db.ts
+import { createClient } from "@libsql/client";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function resolveConfigDir() {
+  return process.env.MEMORIES_DATA_DIR ?? join(homedir(), ".config", "memories");
+}
+function getConfigDir() {
+  return resolveConfigDir();
+}
+function getDbPath() {
+  return join(resolveConfigDir(), "local.db");
+}
+function getSyncConfigPath() {
+  return join(resolveConfigDir(), "sync.json");
+}
+var client;
+async function getDb() {
+  if (client) return client;
+  const configDir = resolveConfigDir();
+  const dbPath = getDbPath();
+  await mkdir(configDir, { recursive: true });
+  const sync = await readSyncConfig();
+  if (sync) {
+    client = createClient({
+      url: `file:${dbPath}`,
+      syncUrl: sync.syncUrl,
+      authToken: sync.syncToken
+    });
+    await runMigrations(client);
+    await client.sync();
+  } else {
+    client = createClient({ url: `file:${dbPath}` });
+    await runMigrations(client);
+  }
+  return client;
+}
+function resetDb() {
+  client?.close();
+  client = void 0;
+}
+async function syncDb() {
+  const db = await getDb();
+  await db.sync();
+}
+async function saveSyncConfig(config) {
+  const configDir = resolveConfigDir();
+  await mkdir(configDir, { recursive: true });
+  await writeFile(getSyncConfigPath(), JSON.stringify(config, null, 2), "utf-8");
+}
+async function readSyncConfig() {
+  const syncPath = getSyncConfigPath();
+  if (!existsSync(syncPath)) return null;
+  const raw = await readFile(syncPath, "utf-8");
+  return JSON.parse(raw);
+}
+async function runMigrations(db) {
+  await db.execute(
+    `CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      tags TEXT,
+      scope TEXT NOT NULL DEFAULT 'global',
+      project_id TEXT,
+      type TEXT NOT NULL DEFAULT 'note',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      deleted_at TEXT
+    )`
+  );
+  try {
+    await db.execute(`ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'global'`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE memories ADD COLUMN project_id TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE memories ADD COLUMN type TEXT NOT NULL DEFAULT 'note'`);
+  } catch {
+  }
+  await db.execute(
+    `CREATE TABLE IF NOT EXISTS configs (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )`
+  );
+  await db.execute(
+    `CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      path TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`
+  );
+  await db.execute(
+    `CREATE TABLE IF NOT EXISTS sync_state (
+      id TEXT PRIMARY KEY,
+      last_synced_at TEXT,
+      remote_url TEXT
+    )`
+  );
+  await db.execute(
+    `CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      content,
+      tags,
+      content='memories',
+      content_rowid='rowid'
+    )`
+  );
+  await db.execute(`DROP TRIGGER IF EXISTS memories_ai`);
+  await db.execute(`DROP TRIGGER IF EXISTS memories_ad`);
+  await db.execute(`DROP TRIGGER IF EXISTS memories_au`);
+  await db.execute(`
+    CREATE TRIGGER memories_ai AFTER INSERT ON memories
+    WHEN NEW.deleted_at IS NULL
+    BEGIN
+      INSERT INTO memories_fts(rowid, content, tags) VALUES (NEW.rowid, NEW.content, NEW.tags);
+    END
+  `);
+  await db.execute(`
+    CREATE TRIGGER memories_ad AFTER DELETE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, content, tags) VALUES('delete', OLD.rowid, OLD.content, OLD.tags);
+    END
+  `);
+  await db.execute(`
+    CREATE TRIGGER memories_au AFTER UPDATE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, content, tags) VALUES('delete', OLD.rowid, OLD.content, OLD.tags);
+      INSERT INTO memories_fts(rowid, content, tags)
+        SELECT NEW.rowid, NEW.content, NEW.tags WHERE NEW.deleted_at IS NULL;
+    END
+  `);
+  try {
+    await db.execute(`CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type)`);
+  } catch {
+  }
+  try {
+    await db.execute(`CREATE INDEX IF NOT EXISTS idx_memories_scope_project ON memories(scope, project_id)`);
+  } catch {
+  }
+}
+
+export {
+  getConfigDir,
+  getDb,
+  resetDb,
+  syncDb,
+  saveSyncConfig,
+  readSyncConfig
+};

package/dist/chunk-JMN3U7AI.js

@@ -0,0 +1,373 @@
+#!/usr/bin/env node
+import {
+  getDb
+} from "./chunk-BDPB4ABQ.js";
+
+// src/lib/memory.ts
+import { nanoid } from "nanoid";
+
+// src/lib/git.ts
+import { execSync } from "child_process";
+function getGitRemoteUrl(cwd) {
+  try {
+    const remote = execSync("git remote get-url origin", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return remote || null;
+  } catch {
+    return null;
+  }
+}
+function getGitRoot(cwd) {
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return root || null;
+  } catch {
+    return null;
+  }
+}
+function normalizeGitUrl(url) {
+  let normalized = url.trim();
+  if (normalized.endsWith(".git")) {
+    normalized = normalized.slice(0, -4);
+  }
+  const sshMatch = normalized.match(/^git@([^:]+):(.+)$/);
+  if (sshMatch) {
+    return `${sshMatch[1]}/${sshMatch[2]}`;
+  }
+  const httpsMatch = normalized.match(/^https?:\/\/([^/]+)\/(.+)$/);
+  if (httpsMatch) {
+    return `${httpsMatch[1]}/${httpsMatch[2]}`;
+  }
+  return normalized;
+}
+function getProjectId(cwd) {
+  const remoteUrl = getGitRemoteUrl(cwd);
+  if (!remoteUrl) return null;
+  return normalizeGitUrl(remoteUrl);
+}
+
+// src/lib/memory.ts
+async function recordMemoryHistory(memory, changeType) {
+  const db = await getDb();
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS memory_history (
+      id TEXT PRIMARY KEY,
+      memory_id TEXT NOT NULL,
+      content TEXT NOT NULL,
+      tags TEXT,
+      type TEXT NOT NULL,
+      changed_at TEXT NOT NULL DEFAULT (datetime('now')),
+      change_type TEXT NOT NULL
+    )
+  `);
+  const historyId = `${memory.id}-${Date.now()}`;
+  await db.execute({
+    sql: `INSERT INTO memory_history (id, memory_id, content, tags, type, change_type) VALUES (?, ?, ?, ?, ?, ?)`,
+    args: [historyId, memory.id, memory.content, memory.tags, memory.type, changeType]
+  });
+}
+async function addMemory(content, opts) {
+  const db = await getDb();
+  const id = nanoid(12);
+  const tags = opts?.tags?.length ? opts.tags.join(",") : null;
+  const type = opts?.type ?? "note";
+  let scope = "global";
+  let projectId = null;
+  if (!opts?.global) {
+    projectId = opts?.projectId ?? getProjectId();
+    if (projectId) {
+      scope = "project";
+    }
+  }
+  await db.execute({
+    sql: `INSERT INTO memories (id, content, tags, scope, project_id, type) VALUES (?, ?, ?, ?, ?, ?)`,
+    args: [id, content, tags, scope, projectId, type]
+  });
+  generateEmbeddingAsync(id, content);
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE id = ?`,
+    args: [id]
+  });
+  return result.rows[0];
+}
+async function generateEmbeddingAsync(memoryId, content) {
+  try {
+    const { getEmbedding, storeEmbedding, ensureEmbeddingsSchema } = await import("./embeddings-GH4HB6X7.js");
+    await ensureEmbeddingsSchema();
+    const embedding = await getEmbedding(content);
+    await storeEmbedding(memoryId, embedding);
+  } catch {
+  }
+}
+async function getMemoryById(id) {
+  const db = await getDb();
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE id = ? AND deleted_at IS NULL`,
+    args: [id]
+  });
+  return result.rows.length > 0 ? result.rows[0] : null;
+}
+async function searchMemories(query, opts) {
+  const db = await getDb();
+  const limit = opts?.limit ?? 20;
+  const includeGlobal = opts?.includeGlobal ?? true;
+  const projectId = opts?.globalOnly ? void 0 : opts?.projectId ?? getProjectId();
+  const scopeConditions = [];
+  const args = [];
+  if (includeGlobal) {
+    scopeConditions.push("m.scope = 'global'");
+  }
+  if (projectId) {
+    scopeConditions.push("(m.scope = 'project' AND m.project_id = ?)");
+    args.push(projectId);
+  }
+  if (scopeConditions.length === 0) {
+    return [];
+  }
+  let typeFilter = "";
+  if (opts?.types?.length) {
+    const placeholders = opts.types.map(() => "?").join(", ");
+    typeFilter = `AND m.type IN (${placeholders})`;
+    args.push(...opts.types);
+  }
+  const ftsQuery = query.split(/\s+/).filter(Boolean).map((term) => `"${term}"*`).join(" OR ");
+  args.push(limit);
+  try {
+    const result = await db.execute({
+      sql: `
+        SELECT m.*, bm25(memories_fts) as rank
+        FROM memories m
+        JOIN memories_fts fts ON m.rowid = fts.rowid
+        WHERE memories_fts MATCH ?
+          AND m.deleted_at IS NULL
+          AND (${scopeConditions.join(" OR ")})
+          ${typeFilter}
+        ORDER BY rank ASC, m.created_at DESC
+        LIMIT ?
+      `,
+      args: [ftsQuery, ...args]
+    });
+    return result.rows;
+  } catch (error) {
+    console.error("FTS search failed, falling back to LIKE:", error);
+    return searchMemoriesLike(query, opts);
+  }
+}
+async function searchMemoriesLike(query, opts) {
+  const db = await getDb();
+  const limit = opts?.limit ?? 20;
+  const includeGlobal = opts?.includeGlobal ?? true;
+  const projectId = opts?.globalOnly ? void 0 : opts?.projectId ?? getProjectId();
+  const conditions = ["deleted_at IS NULL", "content LIKE ?"];
+  const args = [`%${query}%`];
+  const scopeConditions = [];
+  if (includeGlobal) {
+    scopeConditions.push("scope = 'global'");
+  }
+  if (projectId) {
+    scopeConditions.push("(scope = 'project' AND project_id = ?)");
+    args.push(projectId);
+  }
+  if (scopeConditions.length === 0) {
+    return [];
+  }
+  conditions.push(`(${scopeConditions.join(" OR ")})`);
+  if (opts?.types?.length) {
+    const placeholders = opts.types.map(() => "?").join(", ");
+    conditions.push(`type IN (${placeholders})`);
+    args.push(...opts.types);
+  }
+  args.push(limit);
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC LIMIT ?`,
+    args
+  });
+  return result.rows;
+}
+async function listMemories(opts) {
+  const db = await getDb();
+  const limit = opts?.limit ?? 50;
+  const includeGlobal = opts?.includeGlobal ?? true;
+  const projectId = opts?.globalOnly ? void 0 : opts?.projectId ?? getProjectId();
+  const conditions = ["deleted_at IS NULL"];
+  const args = [];
+  const scopeConditions = [];
+  if (includeGlobal) {
+    scopeConditions.push("scope = 'global'");
+  }
+  if (projectId) {
+    scopeConditions.push("(scope = 'project' AND project_id = ?)");
+    args.push(projectId);
+  }
+  if (scopeConditions.length === 0) {
+    return [];
+  }
+  conditions.push(`(${scopeConditions.join(" OR ")})`);
+  if (opts?.tags?.length) {
+    const tagClauses = opts.tags.map(() => `tags LIKE ?`).join(" OR ");
+    conditions.push(`(${tagClauses})`);
+    args.push(...opts.tags.map((t) => `%${t}%`));
+  }
+  if (opts?.types?.length) {
+    const placeholders = opts.types.map(() => "?").join(", ");
+    conditions.push(`type IN (${placeholders})`);
+    args.push(...opts.types);
+  }
+  args.push(limit);
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY type ASC, scope ASC, created_at DESC LIMIT ?`,
+    args
+  });
+  return result.rows;
+}
+async function getRules(opts) {
+  const db = await getDb();
+  const projectId = opts?.projectId ?? getProjectId();
+  const conditions = ["deleted_at IS NULL", "type = 'rule'"];
+  const args = [];
+  const scopeConditions = ["scope = 'global'"];
+  if (projectId) {
+    scopeConditions.push("(scope = 'project' AND project_id = ?)");
+    args.push(projectId);
+  }
+  conditions.push(`(${scopeConditions.join(" OR ")})`);
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY scope ASC, created_at ASC`,
+    args
+  });
+  return result.rows;
+}
+async function getContext(query, opts) {
+  const projectId = opts?.projectId ?? getProjectId();
+  const limit = opts?.limit ?? 10;
+  const rules = await getRules({ projectId: projectId ?? void 0 });
+  let memories = [];
+  if (query) {
+    memories = await searchMemories(query, {
+      projectId: projectId ?? void 0,
+      limit,
+      types: ["decision", "fact", "note"]
+      // Exclude rules, they're already included
+    });
+  }
+  return { rules, memories };
+}
+async function updateMemory(id, updates, options) {
+  const db = await getDb();
+  const existing = await db.execute({
+    sql: `SELECT * FROM memories WHERE id = ? AND deleted_at IS NULL`,
+    args: [id]
+  });
+  if (existing.rows.length === 0) return null;
+  if (!options?.skipHistory) {
+    const old = existing.rows[0];
+    await recordMemoryHistory(old, "updated");
+  }
+  const setClauses = ["updated_at = datetime('now')"];
+  const args = [];
+  if (updates.content !== void 0) {
+    setClauses.push("content = ?");
+    args.push(updates.content);
+  }
+  if (updates.tags !== void 0) {
+    setClauses.push("tags = ?");
+    args.push(updates.tags.length ? updates.tags.join(",") : null);
+  }
+  if (updates.type !== void 0) {
+    setClauses.push("type = ?");
+    args.push(updates.type);
+  }
+  args.push(id);
+  await db.execute({
+    sql: `UPDATE memories SET ${setClauses.join(", ")} WHERE id = ?`,
+    args
+  });
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE id = ?`,
+    args: [id]
+  });
+  return result.rows[0];
+}
+async function forgetMemory(id) {
+  const db = await getDb();
+  const existing = await db.execute({
+    sql: `SELECT id FROM memories WHERE id = ? AND deleted_at IS NULL`,
+    args: [id]
+  });
+  if (existing.rows.length === 0) return false;
+  await db.execute({
+    sql: `UPDATE memories SET deleted_at = datetime('now') WHERE id = ?`,
+    args: [id]
+  });
+  return true;
+}
+async function findMemoriesToForget(filter) {
+  const db = await getDb();
+  const conditions = ["deleted_at IS NULL"];
+  const args = [];
+  if (filter.types?.length) {
+    const placeholders = filter.types.map(() => "?").join(", ");
+    conditions.push(`type IN (${placeholders})`);
+    args.push(...filter.types);
+  }
+  if (filter.tags?.length) {
+    const tagClauses = filter.tags.map(() => `tags LIKE ?`).join(" OR ");
+    conditions.push(`(${tagClauses})`);
+    args.push(...filter.tags.map((t) => `%${t}%`));
+  }
+  if (filter.olderThanDays !== void 0) {
+    conditions.push(`created_at < datetime('now', ?)`);
+    args.push(`-${filter.olderThanDays} days`);
+  }
+  if (filter.pattern) {
+    const likePattern = filter.pattern.replace(/%/g, "\\%").replace(/_/g, "\\_").replace(/\*/g, "%").replace(/\?/g, "_");
+    conditions.push(`content LIKE ? ESCAPE '\\'`);
+    args.push(`%${likePattern}%`);
+  }
+  if (filter.projectId) {
+    conditions.push("(scope = 'project' AND project_id = ?)");
+    args.push(filter.projectId);
+  }
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC`,
+    args
+  });
+  return result.rows;
+}
+async function bulkForgetByIds(ids) {
+  if (ids.length === 0) return 0;
+  const db = await getDb();
+  const batchSize = 500;
+  for (let i = 0; i < ids.length; i += batchSize) {
+    const batch = ids.slice(i, i + batchSize);
+    const placeholders = batch.map(() => "?").join(", ");
+    await db.execute({
+      sql: `UPDATE memories SET deleted_at = datetime('now') WHERE id IN (${placeholders})`,
+      args: batch
+    });
+  }
+  return ids.length;
+}
+
+export {
+  getGitRoot,
+  getProjectId,
+  recordMemoryHistory,
+  addMemory,
+  getMemoryById,
+  searchMemories,
+  listMemories,
+  getRules,
+  getContext,
+  updateMemory,
+  forgetMemory,
+  findMemoriesToForget,
+  bulkForgetByIds
+};

package/dist/embeddings-GH4HB6X7.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import {
+  bufferToEmbedding,
+  cosineSimilarity,
+  embeddingToBuffer,
+  ensureEmbeddingsSchema,
+  getEmbedding,
+  getEmbeddingDimension,
+  getStoredEmbedding,
+  isModelAvailable,
+  semanticSearch,
+  storeEmbedding
+} from "./chunk-4GNYCHD4.js";
+import "./chunk-BDPB4ABQ.js";
+export {
+  bufferToEmbedding,
+  cosineSimilarity,
+  embeddingToBuffer,
+  ensureEmbeddingsSchema,
+  getEmbedding,
+  getEmbeddingDimension,
+  getStoredEmbedding,
+  isModelAvailable,
+  semanticSearch,
+  storeEmbedding
+};