@plur-ai/core 0.4.0 → 0.4.1

package/dist/index.js

@@ -6,9 +6,787 @@ import {
   ftsTokenize,
   getSyncStatus,
   searchEngrams,
-  sync
-} from "./chunk-WPD4MPTT.js";
-import "./chunk-2ZDO52B4.js";
+  sync,
+  withLock
+} from "./chunk-KMVQYBNP.js";
+import {
+  __commonJS,
+  __require
+} from "./chunk-2ZDO52B4.js";
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js
+var require_util = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js"(exports) {
+    "use strict";
+    exports.getBooleanOption = (options, key) => {
+      let value = false;
+      if (key in options && typeof (value = options[key]) !== "boolean") {
+        throw new TypeError(`Expected the "${key}" option to be a boolean`);
+      }
+      return value;
+    };
+    exports.cppdb = /* @__PURE__ */ Symbol();
+    exports.inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/sqlite-error.js"(exports, module) {
+    "use strict";
+    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+    function SqliteError(message, code) {
+      if (new.target !== SqliteError) {
+        return new SqliteError(message, code);
+      }
+      if (typeof code !== "string") {
+        throw new TypeError("Expected second argument to be a string");
+      }
+      Error.call(this, message);
+      descriptor.value = "" + message;
+      Object.defineProperty(this, "message", descriptor);
+      Error.captureStackTrace(this, SqliteError);
+      this.code = code;
+    }
+    Object.setPrototypeOf(SqliteError, Error);
+    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+    Object.defineProperty(SqliteError.prototype, "name", descriptor);
+    module.exports = SqliteError;
+  }
+});
+
+// ../../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS({
+  "../../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js"(exports, module) {
+    "use strict";
+    var sep = __require("path").sep || "/";
+    module.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        throw new TypeError("must pass in a file:// URI to convert to a file path");
+      }
+      var rest = decodeURI(uri.substring(7));
+      var firstSlash = rest.indexOf("/");
+      var host = rest.substring(0, firstSlash);
+      var path2 = rest.substring(firstSlash + 1);
+      if ("localhost" == host) host = "";
+      if (host) {
+        host = sep + sep + host;
+      }
+      path2 = path2.replace(/^(.+)\|/, "$1:");
+      if (sep == "\\") {
+        path2 = path2.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path2)) {
+      } else {
+        path2 = sep + path2;
+      }
+      return host + path2;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js
+var require_bindings = __commonJS({
+  "../../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path2 = __require("path");
+    var fileURLToPath = require_file_uri_to_path();
+    var join3 = path2.join;
+    var dirname = path2.dirname;
+    var exists = fs3.accessSync && function(path3) {
+      try {
+        fs3.accessSync(path3);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    } || fs3.existsSync || path2.existsSync;
+    var defaults = {
+      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
+      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+      platform: process.platform,
+      arch: process.arch,
+      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+      version: process.versions.node,
+      bindings: "bindings.node",
+      try: [
+        // node-gyp's linked version in the "build" dir
+        ["module_root", "build", "bindings"],
+        // node-waf and gyp_addon (a.k.a node-gyp)
+        ["module_root", "build", "Debug", "bindings"],
+        ["module_root", "build", "Release", "bindings"],
+        // Debug files, for development (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Debug", "bindings"],
+        ["module_root", "Debug", "bindings"],
+        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Release", "bindings"],
+        ["module_root", "Release", "bindings"],
+        // Legacy from node-waf, node <= 0.4.x
+        ["module_root", "build", "default", "bindings"],
+        // Production "Release" buildtype binary (meh...)
+        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+        // node-qbs builds
+        ["module_root", "addon-build", "release", "install-root", "bindings"],
+        ["module_root", "addon-build", "debug", "install-root", "bindings"],
+        ["module_root", "addon-build", "default", "install-root", "bindings"],
+        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+      ]
+    };
+    function bindings(opts) {
+      if (typeof opts == "string") {
+        opts = { bindings: opts };
+      } else if (!opts) {
+        opts = {};
+      }
+      Object.keys(defaults).map(function(i2) {
+        if (!(i2 in opts)) opts[i2] = defaults[i2];
+      });
+      if (!opts.module_root) {
+        opts.module_root = exports.getRoot(exports.getFileName());
+      }
+      if (path2.extname(opts.bindings) != ".node") {
+        opts.bindings += ".node";
+      }
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+      var tries = [], i = 0, l = opts.try.length, n, b, err;
+      for (; i < l; i++) {
+        n = join3.apply(
+          null,
+          opts.try[i].map(function(p) {
+            return opts[p] || p;
+          })
+        );
+        tries.push(n);
+        try {
+          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+          if (!opts.path) {
+            b.path = n;
+          }
+          return b;
+        } catch (e) {
+          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
+            throw e;
+          }
+        }
+      }
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+          return opts.arrow + a;
+        }).join("\n")
+      );
+      err.tries = tries;
+      throw err;
+    }
+    module.exports = exports = bindings;
+    exports.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(e, st) {
+        for (var i = 0, l = st.length; i < l; i++) {
+          fileName = st[i].getFileName();
+          if (fileName !== __filename) {
+            if (calling_file) {
+              if (fileName !== calling_file) {
+                return;
+              }
+            } else {
+              return;
+            }
+          }
+        }
+      };
+      Error.captureStackTrace(dummy);
+      dummy.stack;
+      Error.prepareStackTrace = origPST;
+      Error.stackTraceLimit = origSTL;
+      var fileSchema = "file://";
+      if (fileName.indexOf(fileSchema) === 0) {
+        fileName = fileURLToPath(fileName);
+      }
+      return fileName;
+    };
+    exports.getRoot = function getRoot(file) {
+      var dir = dirname(file), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists(join3(dir, "package.json")) || exists(join3(dir, "node_modules"))) {
+          return dir;
+        }
+        if (prev === dir) {
+          throw new Error(
+            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
+          );
+        }
+        prev = dir;
+        dir = join3(dir, "..");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/wrappers.js"(exports) {
+    "use strict";
+    var { cppdb } = require_util();
+    exports.prepare = function prepare(sql) {
+      return this[cppdb].prepare(sql, this, false);
+    };
+    exports.exec = function exec(sql) {
+      this[cppdb].exec(sql);
+      return this;
+    };
+    exports.close = function close() {
+      this[cppdb].close();
+      return this;
+    };
+    exports.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
+    };
+    exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      return this;
+    };
+    exports.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
+    };
+    exports.getters = {
+      name: {
+        get: function name() {
+          return this[cppdb].name;
+        },
+        enumerable: true
+      },
+      open: {
+        get: function open() {
+          return this[cppdb].open;
+        },
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
+        },
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/transaction.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module.exports = function transaction(fn) {
+      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+      const db = this[cppdb];
+      const controller = getController(db, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    };
+    var getController = (db, self) => {
+      let controller = controllers.get(db);
+      if (!controller) {
+        const shared = {
+          commit: db.prepare("COMMIT", self, false),
+          rollback: db.prepare("ROLLBACK", self, false),
+          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db, controller = {
+          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
+      }
+      before.run();
+      try {
+        const result = apply.call(fn, this, arguments);
+        if (result && typeof result.then === "function") {
+          throw new TypeError("Transaction function cannot return a promise");
+        }
+        after.run();
+        return result;
+      } catch (ex) {
+        if (db.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/pragma.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function pragma(source, options) {
+      if (options == null) options = {};
+      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      const simple = getBooleanOption(options, "simple");
+      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path2 = __require("path");
+    var { promisify } = __require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify(fs3.access);
+    module.exports = async function backup(filename, options) {
+      if (options == null) options = {};
+      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      filename = filename.trim();
+      const attachedName = "attached" in options ? options.attached : "main";
+      const handler = "progress" in options ? options.progress : null;
+      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
+      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
+      await fsAccess(path2.dirname(filename)).catch(() => {
+        throw new TypeError("Cannot save backup because the directory does not exist");
+      });
+      const isNewFile = await fsAccess(filename).then(() => false, () => true);
+      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
+    };
+    var runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve, reject) => {
+        setImmediate(function step() {
+          try {
+            const progress = backup.transfer(rate);
+            if (!progress.remainingPages) {
+              backup.close();
+              resolve(progress);
+              return;
+            }
+            if (useDefault) {
+              useDefault = false;
+              rate = 100;
+            }
+            if (handler) {
+              const ret = handler(progress);
+              if (ret !== void 0) {
+                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+                else throw new TypeError("Expected progress callback to return a number or undefined");
+              }
+            }
+            setImmediate(step);
+          } catch (err) {
+            backup.close();
+            reject(err);
+          }
+        });
+      });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function serialize(options) {
+      if (options == null) options = {};
+      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
+      const attachedName = "attached" in options ? options.attached : "main";
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      return this[cppdb].serialize(attachedName);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/function.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineFunction(name, options, fn) {
+      if (options == null) options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = fn.length;
+        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/aggregate.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineAggregate(name, options) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const start = "start" in options ? options.start : null;
+      const step = getFunctionOption(options, "step", true);
+      const inverse = getFunctionOption(options, "inverse", false);
+      const result = getFunctionOption(options, "result", false);
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+        if (argCount > 0) argCount -= 1;
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, required) => {
+      const value = key in options ? options[key] : null;
+      if (typeof value === "function") return value;
+      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+      if (required) throw new TypeError(`Missing required option "${key}"`);
+      return null;
+    };
+    var getLength = ({ length }) => {
+      if (Number.isInteger(length) && length >= 0) return length;
+      throw new TypeError("Expected function.length to be a positive integer");
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/table.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function defineTable(name, factory) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
+      let eponymous = false;
+      if (typeof factory === "object" && factory !== null) {
+        eponymous = true;
+        factory = defer(parseTableDefinition(factory, "used", name));
+      } else {
+        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
+        factory = wrapFactory(factory);
+      }
+      this[cppdb].table(factory, name, eponymous);
+      return this;
+    };
+    function wrapFactory(factory) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.call(factory, thisObject, args);
+        if (typeof def !== "object" || def === null) {
+          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+        }
+        return parseTableDefinition(def, "returned", moduleName);
+      };
+    }
+    function parseTableDefinition(def, verb, moduleName) {
+      if (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+      }
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+      }
+      const rows = def.rows;
+      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+      }
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+      }
+      if (columns.length !== new Set(columns).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+      }
+      if (!columns.length) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+      }
+      let parameters;
+      if (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+        }
+      } else {
+        parameters = inferParameters(rows);
+      }
+      if (parameters.length !== new Set(parameters).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+      }
+      if (parameters.length > 32) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+      }
+      for (const parameter of parameters) {
+        if (columns.includes(parameter)) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+        }
+      }
+      let safeIntegers = 2;
+      if (hasOwnProperty.call(def, "safeIntegers")) {
+        const bool = def.safeIntegers;
+        if (typeof bool !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+        }
+        safeIntegers = +bool;
+      }
+      let directOnly = false;
+      if (hasOwnProperty.call(def, "directOnly")) {
+        directOnly = def.directOnly;
+        if (typeof directOnly !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+        }
+      }
+      const columnDefinitions = [
+        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
+        ...columns.map(identifier)
+      ];
+      return [
+        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+        wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
+    }
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+        for (let i = 0; i < columnMap.size; ++i) {
+          output.push(null);
+        }
+        for (const row of generator(...args)) {
+          if (Array.isArray(row)) {
+            extractRowArray(row, output, columnMap.size, moduleName);
+            yield output;
+          } else if (typeof row === "object" && row !== null) {
+            extractRowObject(row, output, columnMap, moduleName);
+            yield output;
+          } else {
+            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+          }
+        }
+      };
+    }
+    function extractRowArray(row, output, columnCount, moduleName) {
+      if (row.length !== columnCount) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+      }
+      const offset = output.length - columnCount;
+      for (let i = 0; i < columnCount; ++i) {
+        output[i + offset] = row[i];
+      }
+    }
+    function extractRowObject(row, output, columnMap, moduleName) {
+      let count = 0;
+      for (const key of Object.keys(row)) {
+        const index = columnMap.get(key);
+        if (index === void 0) {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+        }
+        output[index] = row[key];
+        count += 1;
+      }
+      if (count !== columnMap.size) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+      }
+    }
+    function inferParameters({ length }) {
+      if (!Number.isInteger(length) || length < 0) {
+        throw new TypeError("Expected function.length to be a positive integer");
+      }
+      const params = [];
+      for (let i = 0; i < length; ++i) {
+        params.push(`$${i + 1}`);
+      }
+      return params;
+    }
+    var { hasOwnProperty } = Object.prototype;
+    var { apply } = Function.prototype;
+    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
+    });
+    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+    var defer = (x) => () => x;
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/inspect.js"(exports, module) {
+    "use strict";
+    var DatabaseInspection = function Database2() {
+    };
+    module.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/database.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path2 = __require("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database2(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database2(filenameGiven, options);
+      }
+      let buffer;
+      if (Buffer.isBuffer(filenameGiven)) {
+        buffer = filenameGiven;
+        filenameGiven = ":memory:";
+      }
+      if (filenameGiven == null) filenameGiven = "";
+      if (options == null) options = {};
+      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+      const filename = filenameGiven.trim();
+      const anonymous = filename === "" || filename === ":memory:";
+      const readonly = util.getBooleanOption(options, "readonly");
+      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
+      const timeout = "timeout" in options ? options.timeout : 5e3;
+      const verbose = "verbose" in options ? options.verbose : null;
+      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+      if (readonly && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
+      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
+      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
+      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+      let addon;
+      if (nativeBinding == null) {
+        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+      } else if (typeof nativeBinding === "string") {
+        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
+        addon = requireFunc(path2.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
+      }
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
+      }
+      if (!anonymous && !fs3.existsSync(path2.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
+      }
+      Object.defineProperties(this, {
+        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
+        ...wrappers.getters
+      });
+    }
+    var wrappers = require_wrappers();
+    Database2.prototype.prepare = wrappers.prepare;
+    Database2.prototype.transaction = require_transaction();
+    Database2.prototype.pragma = require_pragma();
+    Database2.prototype.backup = require_backup();
+    Database2.prototype.serialize = require_serialize();
+    Database2.prototype.function = require_function();
+    Database2.prototype.aggregate = require_aggregate();
+    Database2.prototype.table = require_table();
+    Database2.prototype.loadExtension = wrappers.loadExtension;
+    Database2.prototype.exec = wrappers.exec;
+    Database2.prototype.close = wrappers.close;
+    Database2.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database2.prototype.unsafeMode = wrappers.unsafeMode;
+    Database2.prototype[util.inspect] = require_inspect();
+    module.exports = Database2;
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_database();
+    module.exports.SqliteError = require_sqlite_error();
+  }
+});
 
 // src/storage.ts
 import { existsSync, mkdirSync } from "fs";
@@ -26,98 +804,70 @@ function detectPlurStorage(explicitPath) {
     candidates: join(root, "candidates.yaml"),
     packs: packsDir,
     exchange: join(root, "exchange"),
-    config: join(root, "config.yaml")
+    config: join(root, "config.yaml"),
+    db: join(root, "engrams.db")
   };
 }
 
-// src/config.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import yaml from "js-yaml";
-
-// src/schemas/config.ts
-import { z } from "zod";
-var PlurConfigSchema = z.object({
-  auto_learn: z.boolean().default(true),
-  auto_capture: z.boolean().default(true),
-  injection_budget: z.number().default(2e3),
-  decay_enabled: z.boolean().default(true),
-  decay_threshold: z.number().default(0.15),
-  packs: z.array(z.string()).default([]),
-  injection: z.object({
-    spread_cap: z.number().default(3),
-    spread_budget: z.number().default(480),
-    co_access: z.boolean().default(true)
-  }).default({}),
-  allow_secrets: z.boolean().default(false)
-}).partial();
-
-// src/config.ts
-function loadConfig(configPath) {
-  if (!existsSync2(configPath)) return PlurConfigSchema.parse({});
-  try {
-    const raw = yaml.load(readFileSync(configPath, "utf8"));
-    return PlurConfigSchema.parse(raw ?? {});
-  } catch {
-    return PlurConfigSchema.parse({});
-  }
-}
+// src/storage-indexed.ts
+import { existsSync as existsSync3 } from "fs";
 
 // src/engrams.ts
 import * as fs from "fs";
-import * as yaml2 from "js-yaml";
+import * as yaml from "js-yaml";
 
 // src/schemas/engram.ts
-import { z as z2 } from "zod";
-var ActivationSchema = z2.object({
-  retrieval_strength: z2.number().min(0).max(1),
-  storage_strength: z2.number().min(0).max(1),
-  frequency: z2.number().int().min(0),
-  last_accessed: z2.string()
+import { z } from "zod";
+var ActivationSchema = z.object({
+  retrieval_strength: z.number().min(0).max(1),
+  storage_strength: z.number().min(0).max(1),
+  frequency: z.number().int().min(0),
+  last_accessed: z.string()
 });
-var KnowledgeTypeSchema = z2.object({
-  memory_class: z2.enum(["semantic", "episodic", "procedural", "metacognitive"]),
-  cognitive_level: z2.enum(["remember", "understand", "apply", "analyze", "evaluate", "create"])
+var KnowledgeTypeSchema = z.object({
+  memory_class: z.enum(["semantic", "episodic", "procedural", "metacognitive"]),
+  cognitive_level: z.enum(["remember", "understand", "apply", "analyze", "evaluate", "create"])
 });
-var KnowledgeAnchorSchema = z2.object({
-  path: z2.string(),
-  relevance: z2.enum(["primary", "supporting", "example"]).default("supporting"),
-  snippet: z2.string().max(200).optional(),
-  snippet_extracted_at: z2.string().optional()
+var KnowledgeAnchorSchema = z.object({
+  path: z.string(),
+  relevance: z.enum(["primary", "supporting", "example"]).default("supporting"),
+  snippet: z.string().max(200).optional(),
+  snippet_extracted_at: z.string().optional()
 });
-var AssociationSchema = z2.object({
-  target_type: z2.enum(["engram", "document"]),
-  target: z2.string(),
-  strength: z2.number().min(0).max(0.95),
-  type: z2.enum(["semantic", "temporal", "causal", "co_accessed"]),
-  updated_at: z2.string().optional()
+var AssociationSchema = z.object({
+  target_type: z.enum(["engram", "document"]),
+  target: z.string(),
+  strength: z.number().min(0).max(0.95),
+  type: z.enum(["semantic", "temporal", "causal", "co_accessed"]),
+  updated_at: z.string().optional()
 });
-var DualCodingSchema = z2.object({
-  example: z2.string().optional(),
-  analogy: z2.string().optional()
+var DualCodingSchema = z.object({
+  example: z.string().optional(),
+  analogy: z.string().optional()
 }).refine(
   (d) => d.example || d.analogy,
   "At least one of example or analogy must be provided"
 );
-var RelationsSchema = z2.object({
-  broader: z2.array(z2.string()).default([]),
-  narrower: z2.array(z2.string()).default([]),
-  related: z2.array(z2.string()).default([]),
-  conflicts: z2.array(z2.string()).default([])
+var RelationsSchema = z.object({
+  broader: z.array(z.string()).default([]),
+  narrower: z.array(z.string()).default([]),
+  related: z.array(z.string()).default([]),
+  conflicts: z.array(z.string()).default([])
 });
-var ProvenanceSchema = z2.object({
-  origin: z2.string(),
-  chain: z2.array(z2.string()).default([]),
-  signature: z2.string().nullable().default(null),
-  license: z2.string().default("cc-by-sa-4.0")
+var ProvenanceSchema = z.object({
+  origin: z.string(),
+  chain: z.array(z.string()).default([]),
+  signature: z.string().nullable().default(null),
+  license: z.string().default("cc-by-sa-4.0")
 });
-var FeedbackSignalsSchema = z2.object({
-  positive: z2.number().int().default(0),
-  negative: z2.number().int().default(0),
-  neutral: z2.number().int().default(0)
+var FeedbackSignalsSchema = z.object({
+  positive: z.number().int().default(0),
+  negative: z.number().int().default(0),
+  neutral: z.number().int().default(0)
 });
-var EntityRefSchema = z2.object({
-  name: z2.string(),
-  type: z2.enum([
+var EntityRefSchema = z.object({
+  name: z.string(),
+  type: z.enum([
     "person",
     "organization",
     "technology",
@@ -129,56 +879,56 @@ var EntityRefSchema = z2.object({
     "standard",
     "other"
   ]),
-  uri: z2.string().url().optional()
+  uri: z.string().url().optional()
 });
-var TemporalSchema = z2.object({
-  learned_at: z2.string(),
-  valid_from: z2.string().optional(),
-  valid_until: z2.string().optional(),
-  ingested_at: z2.string().optional()
+var TemporalSchema = z.object({
+  learned_at: z.string(),
+  valid_from: z.string().optional(),
+  valid_until: z.string().optional(),
+  ingested_at: z.string().optional()
 });
-var UsageStatsSchema = z2.object({
-  injections: z2.number().int().default(0),
-  hits: z2.number().int().default(0),
-  misses: z2.number().int().default(0),
-  last_hit_at: z2.string().optional()
+var UsageStatsSchema = z.object({
+  injections: z.number().int().default(0),
+  hits: z.number().int().default(0),
+  misses: z.number().int().default(0),
+  last_hit_at: z.string().optional()
 });
-var EpisodicFieldsSchema = z2.object({
-  emotional_weight: z2.number().int().min(1).max(10).default(5),
-  confidence: z2.number().int().min(1).max(10).default(5),
-  trigger_context: z2.string().optional(),
-  journal_ref: z2.string().optional()
+var EpisodicFieldsSchema = z.object({
+  emotional_weight: z.number().int().min(1).max(10).default(5),
+  confidence: z.number().int().min(1).max(10).default(5),
+  trigger_context: z.string().optional(),
+  journal_ref: z.string().optional()
 });
-var ExchangeMetadataSchema = z2.object({
-  fitness_score: z2.number().min(0).max(1).optional(),
-  environmental_diversity: z2.number().int().default(0),
-  adoption_count: z2.number().int().default(0),
-  contradiction_rate: z2.number().min(0).max(1).default(0)
+var ExchangeMetadataSchema = z.object({
+  fitness_score: z.number().min(0).max(1).optional(),
+  environmental_diversity: z.number().int().default(0),
+  adoption_count: z.number().int().default(0),
+  contradiction_rate: z.number().min(0).max(1).default(0)
 });
-var EngramSchema = z2.object({
+var EngramSchema = z.object({
   // Identity
-  id: z2.string().regex(/^(ENG|ABS|META)-[A-Za-z0-9-]+$/),
-  version: z2.number().int().min(1).default(2),
-  status: z2.enum(["active", "dormant", "retired", "candidate"]),
-  consolidated: z2.boolean().default(false),
-  type: z2.enum(["behavioral", "terminological", "procedural", "architectural"]),
-  scope: z2.string(),
-  visibility: z2.enum(["private", "public", "template"]).default("private"),
+  id: z.string().regex(/^(ENG|ABS|META)-[A-Za-z0-9-]+$/),
+  version: z.number().int().min(1).default(2),
+  status: z.enum(["active", "dormant", "retired", "candidate"]),
+  consolidated: z.boolean().default(false),
+  type: z.enum(["behavioral", "terminological", "procedural", "architectural"]),
+  scope: z.string(),
+  visibility: z.enum(["private", "public", "template"]).default("private"),
   // Content
-  statement: z2.string().min(1),
-  rationale: z2.string().optional(),
-  contraindications: z2.array(z2.string()).optional(),
+  statement: z.string().min(1),
+  rationale: z.string().optional(),
+  contraindications: z.array(z.string()).optional(),
   // Lineage
-  source: z2.string().optional(),
-  source_patterns: z2.array(z2.string()).optional(),
-  derivation_count: z2.number().int().min(0).default(1),
-  pack: z2.string().nullable().default(null),
-  abstract: z2.string().nullable().default(null),
-  derived_from: z2.string().nullable().default(null),
+  source: z.string().optional(),
+  source_patterns: z.array(z.string()).optional(),
+  derivation_count: z.number().int().min(0).default(1),
+  pack: z.string().nullable().default(null),
+  abstract: z.string().nullable().default(null),
+  derived_from: z.string().nullable().default(null),
   // Classification
   knowledge_type: KnowledgeTypeSchema.optional(),
-  domain: z2.string().optional(),
-  tags: z2.array(z2.string()).default([]),
+  domain: z.string().optional(),
+  tags: z.array(z.string()).default([]),
   // Activation (ACT-R model)
   activation: ActivationSchema.default({
     retrieval_strength: 0.7,
@@ -188,8 +938,8 @@ var EngramSchema = z2.object({
   }),
   // Relations & grounding
   relations: RelationsSchema.optional(),
-  associations: z2.array(AssociationSchema).default([]),
-  knowledge_anchors: z2.array(KnowledgeAnchorSchema).default([]),
+  associations: z.array(AssociationSchema).default([]),
+  knowledge_anchors: z.array(KnowledgeAnchorSchema).default([]),
   dual_coding: DualCodingSchema.optional(),
   // Provenance
   provenance: ProvenanceSchema.optional(),
@@ -197,7 +947,7 @@ var EngramSchema = z2.object({
   feedback_signals: FeedbackSignalsSchema.default({ positive: 0, negative: 0, neutral: 0 }),
   // === NEW OPTIONAL FIELDS (v2.1) ===
   /** Typed entity references extracted from statement. Enables graph queries. */
-  entities: z2.array(EntityRefSchema).optional(),
+  entities: z.array(EntityRefSchema).optional(),
   /** Temporal validity window. When is this knowledge true? */
   temporal: TemporalSchema.optional(),
   /** Automatic usage tracking. Injections, hits, misses. */
@@ -207,33 +957,33 @@ var EngramSchema = z2.object({
   /** Exchange marketplace metadata: fitness, adoption, diversity. */
   exchange: ExchangeMetadataSchema.optional(),
   /** Extensible key-value data for domain-specific fields. */
-  structured_data: z2.record(z2.string(), z2.unknown()).optional(),
+  structured_data: z.record(z.string(), z.unknown()).optional(),
   /** Polarity classification: 'do' for directives, 'dont' for prohibitions, null for unclassified. */
-  polarity: z2.enum(["do", "dont"]).nullable().default(null)
+  polarity: z.enum(["do", "dont"]).nullable().default(null)
 });
 
 // src/schemas/pack.ts
-import { z as z3 } from "zod";
-var PackManifestSchema = z3.object({
-  name: z3.string(),
-  version: z3.string(),
-  description: z3.string().optional(),
-  creator: z3.string().optional(),
-  license: z3.string().default("cc-by-sa-4.0"),
-  tags: z3.array(z3.string()).default([]),
-  metadata: z3.object({
-    id: z3.string().optional(),
-    injection_policy: z3.enum(["on_match", "on_request", "always"]).default("on_match"),
-    match_terms: z3.array(z3.string()).default([]),
-    domain: z3.string().optional(),
-    engram_count: z3.number().optional()
+import { z as z2 } from "zod";
+var PackManifestSchema = z2.object({
+  name: z2.string(),
+  version: z2.string(),
+  description: z2.string().optional(),
+  creator: z2.string().optional(),
+  license: z2.string().default("cc-by-sa-4.0"),
+  tags: z2.array(z2.string()).default([]),
+  metadata: z2.object({
+    id: z2.string().optional(),
+    injection_policy: z2.enum(["on_match", "on_request", "always"]).default("on_match"),
+    match_terms: z2.array(z2.string()).default([]),
+    domain: z2.string().optional(),
+    engram_count: z2.number().optional()
   }).optional(),
-  "x-datacore": z3.object({
-    id: z3.string(),
-    injection_policy: z3.enum(["on_match", "on_request"]),
-    match_terms: z3.array(z3.string()).default([]),
-    domain: z3.string().optional(),
-    engram_count: z3.number().int().min(0)
+  "x-datacore": z2.object({
+    id: z2.string(),
+    injection_policy: z2.enum(["on_match", "on_request"]),
+    match_terms: z2.array(z2.string()).default([]),
+    domain: z2.string().optional(),
+    engram_count: z2.number().int().min(0)
   }).optional()
 });
 
@@ -260,7 +1010,7 @@ var logger = {
 function loadEngrams(filePath) {
   if (!fs.existsSync(filePath)) return [];
   try {
-    const raw = yaml2.load(fs.readFileSync(filePath, "utf8"));
+    const raw = yaml.load(fs.readFileSync(filePath, "utf8"));
     if (!raw?.engrams || !Array.isArray(raw.engrams)) return [];
     const valid = [];
     let skipped = 0;
@@ -277,14 +1027,14 @@ function loadEngrams(filePath) {
   }
 }
 function saveEngrams(filePath, engrams) {
-  const content = yaml2.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  const content = yaml.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
   atomicWrite(filePath, content);
 }
 function parseSkillMdFrontmatter(filePath) {
   const content = fs.readFileSync(filePath, "utf8");
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) throw new Error(`No frontmatter found in ${filePath}`);
-  return yaml2.load(match[1]);
+  return yaml.load(match[1]);
 }
 function loadPack(packDir) {
   const skillMdPath = `${packDir}/SKILL.md`;
@@ -294,7 +1044,7 @@ function loadPack(packDir) {
   if (fs.existsSync(skillMdPath)) {
     rawManifest = parseSkillMdFrontmatter(skillMdPath);
   } else if (fs.existsSync(manifestYamlPath)) {
-    rawManifest = yaml2.load(fs.readFileSync(manifestYamlPath, "utf8"));
+    rawManifest = yaml.load(fs.readFileSync(manifestYamlPath, "utf8"));
   } else {
     throw new Error(`No SKILL.md or manifest.yaml found in ${packDir}`);
   }
@@ -326,6 +1076,165 @@ function generateEngramId(existing) {
   return `${prefix}${String(next).padStart(3, "0")}`;
 }
 
+// src/storage-indexed.ts
+var Database = null;
+function getDatabase() {
+  if (!Database) {
+    try {
+      Database = require_lib();
+    } catch {
+      throw new Error(
+        "better-sqlite3 is required for index: true. Install it with: npm install better-sqlite3"
+      );
+    }
+  }
+  return Database;
+}
+var IndexedStorage = class {
+  dbPath;
+  engramsPath;
+  db = null;
+  constructor(engramsPath, dbPath) {
+    this.engramsPath = engramsPath;
+    this.dbPath = dbPath;
+  }
+  getDb() {
+    if (!this.db) {
+      const DB = getDatabase();
+      this.db = new DB(this.dbPath);
+      this.db.pragma("journal_mode = WAL");
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS engrams (
+          id TEXT PRIMARY KEY,
+          status TEXT NOT NULL,
+          scope TEXT NOT NULL,
+          domain TEXT,
+          last_accessed TEXT,
+          data TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_status ON engrams(status);
+        CREATE INDEX IF NOT EXISTS idx_scope ON engrams(scope);
+        CREATE INDEX IF NOT EXISTS idx_domain ON engrams(domain);
+      `);
+    }
+    return this.db;
+  }
+  /** Load all engrams from SQLite index. Auto-rebuilds if db missing. */
+  loadAll() {
+    if (!existsSync3(this.dbPath)) {
+      this.reindex();
+    }
+    const db = this.getDb();
+    const rows = db.prepare("SELECT data FROM engrams").all();
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  /** Load engrams with SQL-level filtering. */
+  loadFiltered(filter) {
+    if (!existsSync3(this.dbPath)) {
+      this.reindex();
+    }
+    const db = this.getDb();
+    const conditions = [];
+    const params = [];
+    if (filter.status) {
+      conditions.push("status = ?");
+      params.push(filter.status);
+    }
+    if (filter.scope) {
+      conditions.push("(scope = 'global' OR scope = ? OR scope LIKE ? || '%')");
+      params.push(filter.scope, filter.scope);
+    }
+    if (filter.domain) {
+      conditions.push("domain LIKE ? || '%'");
+      params.push(filter.domain);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = db.prepare(`SELECT data FROM engrams ${where}`).all(...params);
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  /** Count engrams with optional status filter. */
+  count(filter) {
+    if (!existsSync3(this.dbPath)) {
+      this.reindex();
+    }
+    const db = this.getDb();
+    if (filter?.status) {
+      return db.prepare("SELECT COUNT(*) as c FROM engrams WHERE status = ?").get(filter.status).c;
+    }
+    return db.prepare("SELECT COUNT(*) as c FROM engrams").get().c;
+  }
+  /** Sync SQLite index from YAML source of truth. */
+  syncFromYaml() {
+    const engrams = loadEngrams(this.engramsPath);
+    const db = this.getDb();
+    const upsert = db.prepare(`
+      INSERT OR REPLACE INTO engrams (id, status, scope, domain, last_accessed, data)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    const deleteStmt = db.prepare("DELETE FROM engrams WHERE id = ?");
+    const yamlIds = new Set(engrams.map((e) => e.id));
+    const dbIds = new Set(
+      db.prepare("SELECT id FROM engrams").all().map((r) => r.id)
+    );
+    const tx = db.transaction(() => {
+      for (const e of engrams) {
+        upsert.run(e.id, e.status, e.scope, e.domain ?? null, e.activation.last_accessed, JSON.stringify(e));
+      }
+      for (const id of dbIds) {
+        if (!yamlIds.has(id)) deleteStmt.run(id);
+      }
+    });
+    tx();
+  }
+  /** Drop and rebuild the entire index from YAML. */
+  reindex() {
+    this.close();
+    const db = this.getDb();
+    db.exec("DELETE FROM engrams");
+    this.syncFromYaml();
+  }
+  /** Close the database connection. */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+};
+
+// src/config.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import yaml2 from "js-yaml";
+
+// src/schemas/config.ts
+import { z as z3 } from "zod";
+var PlurConfigSchema = z3.object({
+  auto_learn: z3.boolean().default(true),
+  auto_capture: z3.boolean().default(true),
+  injection_budget: z3.number().default(2e3),
+  decay_enabled: z3.boolean().default(true),
+  decay_threshold: z3.number().default(0.15),
+  packs: z3.array(z3.string()).default([]),
+  injection: z3.object({
+    spread_cap: z3.number().default(3),
+    spread_budget: z3.number().default(480),
+    co_access: z3.boolean().default(true)
+  }).default({}),
+  allow_secrets: z3.boolean().default(false),
+  index: z3.boolean().default(false)
+}).partial();
+
+// src/config.ts
+function loadConfig(configPath) {
+  if (!existsSync4(configPath)) return PlurConfigSchema.parse({});
+  try {
+    const raw = yaml2.load(readFileSync2(configPath, "utf8"));
+    return PlurConfigSchema.parse(raw ?? {});
+  } catch {
+    return PlurConfigSchema.parse({});
+  }
+}
+
 // src/decay.ts
 var DECAY_RATE = 0.05;
 var FLOOR = 0.05;
@@ -653,7 +1562,7 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
 }
 
 // src/episodes.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
 import yaml3 from "js-yaml";
 function generateEpisodeId() {
   const ts = Date.now();
@@ -688,7 +1597,7 @@ function queryTimeline(path2, query) {
   return episodes;
 }
 function loadEpisodes(path2) {
-  if (!existsSync4(path2)) return [];
+  if (!existsSync5(path2)) return [];
   try {
     const raw = yaml3.load(readFileSync3(path2, "utf8"));
     return Array.isArray(raw) ? raw : [];
@@ -1097,7 +2006,7 @@ async function computeSimilarityMatrix(templates) {
   const n = templates.length;
   const matrix = Array.from({ length: n }, () => Array(n).fill(0));
   try {
-    const { embed, cosineSimilarity } = await import("./embeddings-Q76LNQ5B.js");
+    const { embed, cosineSimilarity } = await import("./embeddings-2IODIQAF.js");
     const embeddings = [];
     for (const t of templates) {
       embeddings.push(await embed(t));
@@ -1832,9 +2741,13 @@ var INGEST_PATTERNS = [
 var Plur = class {
   paths;
   config;
+  indexedStorage = null;
   constructor(options) {
     this.paths = detectPlurStorage(options?.path);
     this.config = loadConfig(this.paths.config);
+    if (this.config.index) {
+      this.indexedStorage = new IndexedStorage(this.paths.engrams, this.paths.db);
+    }
   }
   /** Create engram, detect conflicts, save. Returns the created engram. */
   learn(statement, context) {
@@ -1844,48 +2757,51 @@ var Plur = class {
         throw new Error(`Secret detected in statement: ${secrets[0].pattern}. Use config.allow_secrets to override.`);
       }
     }
-    const engrams = loadEngrams(this.paths.engrams);
-    const id = generateEngramId(engrams);
-    const scope = context?.scope ?? "global";
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const conflictingEngrams = detectConflicts({ statement, scope }, engrams);
-    const conflictIds = conflictingEngrams.map((e) => e.id);
-    const engram = {
-      id,
-      version: 2,
-      status: "active",
-      consolidated: false,
-      type: context?.type ?? "behavioral",
-      scope,
-      visibility: "private",
-      statement,
-      source: context?.source,
-      domain: context?.domain,
-      activation: {
-        retrieval_strength: 0.7,
-        storage_strength: 1,
-        frequency: 0,
-        last_accessed: now.slice(0, 10)
-      },
-      feedback_signals: { positive: 0, negative: 0, neutral: 0 },
-      knowledge_anchors: [],
-      associations: [],
-      derivation_count: 1,
-      tags: [],
-      pack: null,
-      abstract: null,
-      derived_from: null,
-      polarity: null,
-      relations: conflictIds.length > 0 ? {
-        broader: [],
-        narrower: [],
-        related: [],
-        conflicts: conflictIds
-      } : void 0
-    };
-    engrams.push(engram);
-    saveEngrams(this.paths.engrams, engrams);
-    return engram;
+    return withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const id = generateEngramId(engrams);
+      const scope = context?.scope ?? "global";
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const conflictingEngrams = detectConflicts({ statement, scope }, engrams);
+      const conflictIds = conflictingEngrams.map((e) => e.id);
+      const engram = {
+        id,
+        version: 2,
+        status: "active",
+        consolidated: false,
+        type: context?.type ?? "behavioral",
+        scope,
+        visibility: "private",
+        statement,
+        source: context?.source,
+        domain: context?.domain,
+        activation: {
+          retrieval_strength: 0.7,
+          storage_strength: 1,
+          frequency: 0,
+          last_accessed: now.slice(0, 10)
+        },
+        feedback_signals: { positive: 0, negative: 0, neutral: 0 },
+        knowledge_anchors: [],
+        associations: [],
+        derivation_count: 1,
+        tags: [],
+        pack: null,
+        abstract: null,
+        derived_from: null,
+        polarity: null,
+        relations: conflictIds.length > 0 ? {
+          broader: [],
+          narrower: [],
+          related: [],
+          conflicts: conflictIds
+        } : void 0
+      };
+      engrams.push(engram);
+      saveEngrams(this.paths.engrams, engrams);
+      this._syncIndex();
+      return engram;
+    });
   }
   /**
    * Search engrams, filter by scope/domain/strength, reactivate accessed.
@@ -1939,75 +2855,89 @@ var Plur = class {
   }
   /** Filter engrams by scope/domain/strength (shared by both modes) */
   _filterEngrams(options) {
-    let engrams = loadEngrams(this.paths.engrams);
-    engrams = engrams.filter((e) => e.status === "active");
+    let engrams;
+    if (this.indexedStorage) {
+      engrams = this.indexedStorage.loadFiltered({
+        status: "active",
+        scope: options?.scope,
+        domain: options?.domain
+      });
+    } else {
+      engrams = loadEngrams(this.paths.engrams);
+      engrams = engrams.filter((e) => e.status === "active");
+      if (options?.domain) {
+        engrams = engrams.filter((e) => e.domain?.startsWith(options.domain));
+      }
+      if (options?.scope) {
+        const scope = options.scope;
+        engrams = engrams.filter(
+          (e) => e.scope === "global" || e.scope === scope || e.scope.startsWith(scope)
+        );
+      }
+    }
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     engrams = engrams.filter((e) => {
       if (e.temporal?.valid_until && e.temporal.valid_until < today) return false;
       if (e.temporal?.valid_from && e.temporal.valid_from > today) return false;
       return true;
     });
-    if (options?.domain) {
-      engrams = engrams.filter((e) => e.domain?.startsWith(options.domain));
-    }
     if (options?.min_strength !== void 0) {
       engrams = engrams.filter((e) => e.activation.retrieval_strength >= options.min_strength);
     }
-    if (options?.scope) {
-      const scope = options.scope;
-      engrams = engrams.filter(
-        (e) => e.scope === "global" || e.scope === scope || e.scope.startsWith(scope)
-      );
-    }
     return engrams;
   }
   /** Reactivate accessed engrams and update co-access associations */
   _reactivateResults(results) {
     if (results.length === 0) return;
-    const allEngrams = loadEngrams(this.paths.engrams);
-    const resultIds = new Set(results.map((e) => e.id));
-    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    let modified = false;
-    for (const e of allEngrams) {
-      if (resultIds.has(e.id)) {
-        e.activation.retrieval_strength = reactivate(e.activation.retrieval_strength);
-        e.activation.last_accessed = today;
-        e.activation.frequency += 1;
-        modified = true;
-      }
-    }
-    if (results.length >= 2 && this.config.injection?.co_access !== false) {
-      const topHalf = results.slice(0, Math.max(2, Math.ceil(results.length / 2)));
-      const topIds = topHalf.map((e) => e.id);
-      for (const sourceId of topIds) {
-        const source = allEngrams.find((e) => e.id === sourceId);
-        if (!source) continue;
-        for (const targetId of topIds) {
-          if (targetId === sourceId) continue;
-          const existing = source.associations.find(
-            (a) => a.type === "co_accessed" && a.target === targetId
-          );
-          if (existing) {
-            existing.strength = Math.min(0.95, existing.strength + 0.05);
-            existing.updated_at = today;
-            modified = true;
-          } else {
-            const coAccessCount = source.associations.filter((a) => a.type === "co_accessed").length;
-            if (coAccessCount < 5) {
-              source.associations.push({
-                target_type: "engram",
-                target: targetId,
-                type: "co_accessed",
-                strength: 0.3,
-                updated_at: today
-              });
+    withLock(this.paths.engrams, () => {
+      const allEngrams = loadEngrams(this.paths.engrams);
+      const resultIds = new Set(results.map((e) => e.id));
+      const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      let modified = false;
+      for (const e of allEngrams) {
+        if (resultIds.has(e.id)) {
+          e.activation.retrieval_strength = reactivate(e.activation.retrieval_strength);
+          e.activation.last_accessed = today;
+          e.activation.frequency += 1;
+          modified = true;
+        }
+      }
+      if (results.length >= 2 && this.config.injection?.co_access !== false) {
+        const topHalf = results.slice(0, Math.max(2, Math.ceil(results.length / 2)));
+        const topIds = topHalf.map((e) => e.id);
+        for (const sourceId of topIds) {
+          const source = allEngrams.find((e) => e.id === sourceId);
+          if (!source) continue;
+          for (const targetId of topIds) {
+            if (targetId === sourceId) continue;
+            const existing = source.associations.find(
+              (a) => a.type === "co_accessed" && a.target === targetId
+            );
+            if (existing) {
+              existing.strength = Math.min(0.95, existing.strength + 0.05);
+              existing.updated_at = today;
               modified = true;
+            } else {
+              const coAccessCount = source.associations.filter((a) => a.type === "co_accessed").length;
+              if (coAccessCount < 5) {
+                source.associations.push({
+                  target_type: "engram",
+                  target: targetId,
+                  type: "co_accessed",
+                  strength: 0.3,
+                  updated_at: today
+                });
+                modified = true;
+              }
             }
           }
         }
       }
-    }
-    if (modified) saveEngrams(this.paths.engrams, allEngrams);
+      if (modified) {
+        saveEngrams(this.paths.engrams, allEngrams);
+        this._syncIndex();
+      }
+    });
   }
   /** Scored injection within token budget (BM25 only). Returns formatted strings. */
   inject(task, options) {
@@ -2066,56 +2996,96 @@ var Plur = class {
   }
   /** Update feedback_signals and adjust retrieval_strength. */
   feedback(id, signal) {
-    const engrams = loadEngrams(this.paths.engrams);
-    const engram = engrams.find((e) => e.id === id);
-    if (!engram) throw new Error(`Engram not found: ${id}`);
-    if (!engram.feedback_signals) {
-      engram.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
-    }
-    engram.feedback_signals[signal] += 1;
-    if (signal === "positive") {
-      engram.activation.retrieval_strength = Math.min(1, engram.activation.retrieval_strength + 0.05);
-    } else if (signal === "negative") {
-      engram.activation.retrieval_strength = Math.max(0, engram.activation.retrieval_strength - 0.1);
-    }
-    saveEngrams(this.paths.engrams, engrams);
+    withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const engram = engrams.find((e) => e.id === id);
+      if (!engram) throw new Error(`Engram not found: ${id}`);
+      if (!engram.feedback_signals) {
+        engram.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
+      }
+      engram.feedback_signals[signal] += 1;
+      if (signal === "positive") {
+        engram.activation.retrieval_strength = Math.min(1, engram.activation.retrieval_strength + 0.05);
+      } else if (signal === "negative") {
+        engram.activation.retrieval_strength = Math.max(0, engram.activation.retrieval_strength - 0.1);
+      }
+      saveEngrams(this.paths.engrams, engrams);
+      this._syncIndex();
+    });
   }
   /** Save extracted meta-engrams to the engram store. Skips IDs that already exist. */
   saveMetaEngrams(metas) {
-    const engrams = loadEngrams(this.paths.engrams);
-    const existingIds = new Set(engrams.map((e) => e.id));
-    let saved = 0;
-    let skipped = 0;
-    for (const meta of metas) {
-      if (existingIds.has(meta.id)) {
-        skipped++;
-      } else {
-        engrams.push(meta);
-        saved++;
+    return withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const existingIds = new Set(engrams.map((e) => e.id));
+      let saved = 0;
+      let skipped = 0;
+      for (const meta of metas) {
+        if (existingIds.has(meta.id)) {
+          skipped++;
+        } else {
+          engrams.push(meta);
+          saved++;
+        }
       }
-    }
-    if (saved > 0) saveEngrams(this.paths.engrams, engrams);
-    return { saved, skipped };
+      if (saved > 0) {
+        saveEngrams(this.paths.engrams, engrams);
+        this._syncIndex();
+      }
+      return { saved, skipped };
+    });
   }
   /** Update an existing engram in the store by ID. Returns true if found and updated. */
   updateEngram(updated) {
-    const engrams = loadEngrams(this.paths.engrams);
-    const idx = engrams.findIndex((e) => e.id === updated.id);
-    if (idx === -1) return false;
-    engrams[idx] = updated;
-    saveEngrams(this.paths.engrams, engrams);
-    return true;
+    return withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const idx = engrams.findIndex((e) => e.id === updated.id);
+      if (idx === -1) return false;
+      engrams[idx] = updated;
+      saveEngrams(this.paths.engrams, engrams);
+      this._syncIndex();
+      return true;
+    });
   }
   /** Set engram status to 'retired'. */
   forget(id, reason) {
-    const engrams = loadEngrams(this.paths.engrams);
-    const engram = engrams.find((e) => e.id === id);
-    if (!engram) throw new Error(`Engram not found: ${id}`);
-    engram.status = "retired";
-    if (reason && !engram.rationale) {
-      engram.rationale = `Retired: ${reason}`;
+    withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const engram = engrams.find((e) => e.id === id);
+      if (!engram) throw new Error(`Engram not found: ${id}`);
+      engram.status = "retired";
+      if (reason && !engram.rationale) {
+        engram.rationale = `Retired: ${reason}`;
+      }
+      saveEngrams(this.paths.engrams, engrams);
+      this._syncIndex();
+    });
+  }
+  /** Remove retired engrams from storage. Returns count of removed and remaining. */
+  compact() {
+    return withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const active = engrams.filter((e) => e.status !== "retired");
+      const removed = engrams.length - active.length;
+      if (removed > 0) {
+        saveEngrams(this.paths.engrams, active);
+        this._syncIndex();
+      }
+      return { removed, remaining: active.length };
+    });
+  }
+  /** Rebuild SQLite index from YAML source of truth. Only works when index: true. */
+  reindex() {
+    if (!this.indexedStorage) {
+      this.indexedStorage = new IndexedStorage(this.paths.engrams, this.paths.db);
+    }
+    this.indexedStorage.reindex();
+  }
+  /** Sync SQLite index after YAML write (no-op if index disabled) */
+  _syncIndex() {
+    if (this.indexedStorage) {
+      this.indexedStorage.syncFromYaml();
     }
-    saveEngrams(this.paths.engrams, engrams);
   }
   /** Capture an episodic memory. */
   capture(summary, context) {
@@ -2196,6 +3166,7 @@ export {
   EvidenceEntrySchema,
   FalsificationSchema,
   HierarchyPositionSchema,
+  IndexedStorage,
   MetaConfidenceSchema,
   MetaFieldSchema,
   PLATITUDE_PATTERNS,