@smartergpt/lexrunner 1.0.0 → 1.3.0

package/dist/dist-CSOR2BL2.js

@@ -1,1144 +0,0 @@
-import {
-  __commonJS,
-  __publicField,
-  __require,
-  __toESM
-} from "./chunk-OQJUWTZV.js";
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/util.js
-var require_util = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/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 = Symbol();
-    exports.inspect = Symbol.for("nodejs.util.inspect.custom");
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/sqlite-error.js
-var require_sqlite_error = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/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;
-  }
-});
-
-// ../lexsona/node_modules/file-uri-to-path/index.js
-var require_file_uri_to_path = __commonJS({
-  "../lexsona/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 path = rest.substring(firstSlash + 1);
-      if ("localhost" == host) host = "";
-      if (host) {
-        host = sep + sep + host;
-      }
-      path = path.replace(/^(.+)\|/, "$1:");
-      if (sep == "\\") {
-        path = path.replace(/\//g, "\\");
-      }
-      if (/^.+\:/.test(path)) {
-      } else {
-        path = sep + path;
-      }
-      return host + path;
-    }
-  }
-});
-
-// ../lexsona/node_modules/bindings/bindings.js
-var require_bindings = __commonJS({
-  "../lexsona/node_modules/bindings/bindings.js"(exports, module) {
-    "use strict";
-    var fs = __require("fs");
-    var path = __require("path");
-    var fileURLToPath = require_file_uri_to_path();
-    var join2 = path.join;
-    var dirname = path.dirname;
-    var exists = fs.accessSync && function(path2) {
-      try {
-        fs.accessSync(path2);
-      } catch (e) {
-        return false;
-      }
-      return true;
-    } || fs.existsSync || path.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 (path.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 = join2.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(join2(dir, "package.json")) || exists(join2(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 = join2(dir, "..");
-      }
-    };
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/wrappers.js
-var require_wrappers = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/wrappers.js"(exports) {
-    "use strict";
-    var { cppdb } = require_util();
-    exports.prepare = function prepare(sql) {
-      return this[cppdb].prepare(sql, this, false);
-    };
-    exports.key = function key(key) {
-      if (!Buffer.isBuffer(key)) throw new TypeError("Expected first argument to be a Buffer");
-      return this[cppdb].key(key, key.length);
-    };
-    exports.rekey = function rekey(key) {
-      if (!Buffer.isBuffer(key)) throw new TypeError("Expected first argument to be a Buffer");
-      return this[cppdb].rekey(key, key.length);
-    };
-    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
-      }
-    };
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/transaction.js
-var require_transaction = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/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;
-      }
-    };
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/pragma.js
-var require_pragma = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/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();
-    };
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/backup.js
-var require_backup = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/backup.js"(exports, module) {
-    "use strict";
-    var fs = __require("fs");
-    var path = __require("path");
-    var { promisify } = __require("util");
-    var { cppdb } = require_util();
-    var fsAccess = promisify(fs.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(path.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);
-          }
-        });
-      });
-    };
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/serialize.js
-var require_serialize = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/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);
-    };
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/function.js
-var require_function = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/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;
-    };
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/aggregate.js
-var require_aggregate = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/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");
-    };
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/table.js
-var require_table = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/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;
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/inspect.js
-var require_inspect = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/methods/inspect.js"(exports, module) {
-    "use strict";
-    var DatabaseInspection = function Database2() {
-    };
-    module.exports = function inspect(depth, opts) {
-      return Object.assign(new DatabaseInspection(), this);
-    };
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/database.js
-var require_database = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/database.js"(exports, module) {
-    "use strict";
-    var fs = __require("fs");
-    var path = __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(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
-      } else {
-        addon = nativeBinding;
-      }
-      if (!addon.isInitialized) {
-        addon.setErrorConstructor(SqliteError);
-        addon.isInitialized = true;
-      }
-      if (!anonymous && !filename.startsWith("file:") && !fs.existsSync(path.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.key = wrappers.key;
-    Database2.prototype.rekey = wrappers.rekey;
-    Database2.prototype.close = wrappers.close;
-    Database2.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
-    Database2.prototype.unsafeMode = wrappers.unsafeMode;
-    Database2.prototype[util.inspect] = require_inspect();
-    module.exports = Database2;
-  }
-});
-
-// ../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/index.js
-var require_lib = __commonJS({
-  "../lexsona/node_modules/better-sqlite3-multiple-ciphers/lib/index.js"(exports, module) {
-    "use strict";
-    module.exports = require_database();
-    module.exports.SqliteError = require_sqlite_error();
-  }
-});
-
-// ../lexsona/dist/core/lexConnection.js
-var import_better_sqlite3_multiple_ciphers = __toESM(require_lib(), 1);
-import { existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-import { LEXSONA_DEFAULTS } from "@smartergpt/lex/lexsona";
-function getDefaultDbPath() {
-  const envPath = process.env.LEX_DB_PATH;
-  if (envPath) {
-    return envPath;
-  }
-  const localPath = join(process.cwd(), ".smartergpt", "lex", "lex.db");
-  if (existsSync(localPath)) {
-    return localPath;
-  }
-  return join(homedir(), ".smartergpt", "lex", "lex.db");
-}
-function connectToLex(config = {}) {
-  const dbPath = config.dbPath ?? getDefaultDbPath();
-  if (!existsSync(dbPath)) {
-    if (config.createIfMissing) {
-      return {
-        success: false,
-        error: `Database not found at ${dbPath}. Run 'lex init' to create it.`,
-        dbPath
-      };
-    }
-    return {
-      success: false,
-      error: `Database not found at ${dbPath}. Set LEX_DB_PATH or run 'lex init'.`,
-      dbPath
-    };
-  }
-  try {
-    const db = new import_better_sqlite3_multiple_ciphers.default(dbPath);
-    const tables = db.prepare(`
-      SELECT name FROM sqlite_master
-      WHERE type='table' AND name='lexsona_behavior_rules'
-    `).all();
-    if (tables.length === 0) {
-      db.close();
-      return {
-        success: false,
-        error: `Database at ${dbPath} is missing lexsona_behavior_rules table. Run 'lex migrate'.`,
-        dbPath
-      };
-    }
-    return {
-      success: true,
-      db,
-      dbPath
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-      dbPath
-    };
-  }
-}
-function closeConnection(db) {
-  if (db.open) {
-    db.close();
-  }
-}
-var LexStorageClient = class _LexStorageClient {
-  constructor(db, dbPath) {
-    __publicField(this, "db");
-    __publicField(this, "dbPath");
-    this.db = db;
-    this.dbPath = dbPath;
-  }
-  /**
-   * Create a new LexStorageClient
-   */
-  static connect(config = {}) {
-    const result = connectToLex(config);
-    if (!result.success || !result.db) {
-      throw new Error(result.error ?? "Unknown connection error");
-    }
-    return new _LexStorageClient(result.db, result.dbPath);
-  }
-  /**
-   * Get the database handle for direct API calls
-   */
-  getDatabase() {
-    return this.db;
-  }
-  /**
-   * Get the resolved database path
-   */
-  getDbPath() {
-    return this.dbPath;
-  }
-  /**
-   * Check if connection is open
-   */
-  isConnected() {
-    return this.db.open;
-  }
-  /**
-   * Close the connection
-   */
-  close() {
-    closeConnection(this.db);
-  }
-};
-
-// ../lexsona/dist/core/lexsona.js
-import { getRules, recordCorrection } from "@smartergpt/lex/lexsona";
-var LexSona = class _LexSona {
-  constructor(config) {
-    __publicField(this, "_config");
-    __publicField(this, "activePersona", null);
-    __publicField(this, "storageClient", null);
-    this._config = config;
-    this.activePersona = config.persona ?? null;
-  }
-  /**
-   * Connect to LexSona with the given configuration
-   */
-  static async connect(config = {}) {
-    const instance = new _LexSona(config);
-    const connectionConfig = {};
-    if (config.lexDb) {
-      connectionConfig.dbPath = config.lexDb;
-    }
-    try {
-      instance.storageClient = LexStorageClient.connect(connectionConfig);
-    } catch (error) {
-      console.warn(`LexSona: Could not connect to Lex database: ${error instanceof Error ? error.message : error}`);
-    }
-    return instance;
-  }
-  /**
-   * Check if connected to Lex storage
-   */
-  isConnected() {
-    return this.storageClient?.isConnected() ?? false;
-  }
-  /**
-   * Activate a named persona
-   *
-   * @param personaId - Persona identifier (behavioral naming, e.g., 'quality-first_engineering')
-   */
-  async activate(personaId) {
-    this.activePersona = personaId;
-  }
-  /**
-   * Derive constraints for the current context
-   *
-   * Combines:
-   * - Lex baseline constraints
-   * - Active persona rules
-   * - Learned behavioral rules from Lex store
-   *
-   * @returns Deterministic constraint set
-   */
-  async deriveConstraints(context) {
-    let rulesConsidered = 0;
-    const hasLexConnection = this.storageClient?.isConnected() ?? false;
-    if (hasLexConnection) {
-      const db = this.storageClient.getDatabase();
-      const ruleContext = {
-        module_id: context.module_id,
-        task_type: context.taskType,
-        environment: context.environment,
-        agent_family: context.agent_family,
-        context_tags: context.context_tags
-      };
-      const rules = getRules(db, ruleContext);
-      rulesConsidered = rules.length;
-    }
-    return {
-      personaId: this.activePersona ?? "none",
-      derivedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      context,
-      constraints: [],
-      principles: [],
-      metadata: {
-        rulesConsidered,
-        rulesFiltered: 0,
-        confidenceThreshold: 0.3,
-        offlineMode: !hasLexConnection,
-        confidenceCeiling: void 0
-      }
-    };
-  }
-  /**
-   * Learn from a behavioral correction
-   *
-   * Records the correction to Lex's behavioral rules store
-   * for future constraint derivation.
-   */
-  async learn(correction) {
-    if (!this.storageClient?.isConnected()) {
-      throw new Error("LexSona: Not connected to Lex database. Cannot record correction.");
-    }
-    const db = this.storageClient.getDatabase();
-    const lexCorrection = {
-      context: {
-        module_id: correction.context.module_id,
-        task_type: correction.context.task_type,
-        environment: correction.context.environment,
-        project: correction.context.project,
-        agent_family: correction.context.agent_family,
-        context_tags: correction.context.context_tags
-      },
-      correction: correction.correction,
-      category: correction.category,
-      severity: correction.severity,
-      polarity: correction.polarity
-    };
-    recordCorrection(db, lexCorrection);
-  }
-  /**
-   * Get the currently active persona ID
-   */
-  getActivePersona() {
-    return this.activePersona;
-  }
-  /**
-   * Get the current configuration
-   */
-  getConfig() {
-    return this._config;
-  }
-  /**
-   * Get rules from Lex storage with optional filtering
-   */
-  async getRules(filter) {
-    if (!this.storageClient?.isConnected()) {
-      return [];
-    }
-    const db = this.storageClient.getDatabase();
-    const context = {
-      module_id: filter?.domain
-    };
-    const rules = getRules(db, context);
-    if (filter?.minConfidence !== void 0) {
-      return rules.filter((r) => r.effective_confidence >= filter.minConfidence);
-    }
-    return rules;
-  }
-  /**
-   * Close the connection
-   */
-  close() {
-    this.storageClient?.close();
-    this.storageClient = null;
-  }
-};
-
-// ../lexsona/dist/constraints/derive.js
-var PersonaRequiresMemoryError = class extends Error {
-  constructor(personaId) {
-    super(`Persona "${personaId}" requires Lex memory connection, but none is available. Use an offline-safe persona (requires_memory: false) when disconnected.`);
-    this.name = "PersonaRequiresMemoryError";
-  }
-};
-var DEFAULT_CONFIG = {
-  confidenceThreshold: 0.3,
-  maxConstraints: 50,
-  includeStyle: true,
-  hasLexConnection: false
-  // Conservative default: assume disconnected
-};
-function scopeMatches(scope, context) {
-  if (scope.module_id && context.module_id && scope.module_id !== context.module_id) {
-    return false;
-  }
-  if (scope.task_type && context.taskType) {
-    if (!context.taskType.toLowerCase().includes(scope.task_type.toLowerCase())) {
-      return false;
-    }
-  }
-  if (scope.environment && context.environment && scope.environment !== context.environment) {
-    return false;
-  }
-  if (scope.agent_family && context.agent_family && scope.agent_family !== context.agent_family) {
-    return false;
-  }
-  if (scope.context_tags && scope.context_tags.length > 0 && context.context_tags) {
-    const contextTagSet = new Set(context.context_tags);
-    for (const tag of scope.context_tags) {
-      if (!contextTagSet.has(tag)) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function deriveConstraints(persona, rules, principles, context, config = {}) {
-  const cfg = { ...DEFAULT_CONFIG, ...config };
-  if (persona.requires_memory && !cfg.hasLexConnection) {
-    throw new PersonaRequiresMemoryError(persona.id);
-  }
-  const isOfflineMode = !cfg.hasLexConnection;
-  const confidenceCeiling = isOfflineMode && persona.offline_safe ? persona.offline_safe.confidence_ceiling : void 0;
-  const personaCategories = new Set(persona.ruleCategories);
-  const matchingRules = rules.filter((rule) => {
-    if (!personaCategories.has(rule.category)) {
-      return false;
-    }
-    if (!scopeMatches(rule.scope, context)) {
-      return false;
-    }
-    if (rule.effective_confidence < cfg.confidenceThreshold) {
-      return false;
-    }
-    if (!cfg.includeStyle && rule.severity === "style") {
-      return false;
-    }
-    return true;
-  });
-  const severityOrder = { must: 0, should: 1, style: 2 };
-  const sortedRules = matchingRules.sort((a, b) => {
-    const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
-    if (severityDiff !== 0)
-      return severityDiff;
-    return b.effective_confidence - a.effective_confidence;
-  });
-  const limitedRules = sortedRules.slice(0, cfg.maxConstraints);
-  const constraints = limitedRules.map((rule) => ({
-    rule_id: rule.rule_id,
-    text: rule.text,
-    severity: rule.severity,
-    confidence: confidenceCeiling !== void 0 ? Math.min(rule.effective_confidence, confidenceCeiling) : rule.effective_confidence,
-    category: rule.category
-  }));
-  return {
-    personaId: persona.id,
-    derivedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    context,
-    principles,
-    constraints,
-    metadata: {
-      rulesConsidered: rules.length,
-      rulesFiltered: rules.length - matchingRules.length,
-      confidenceThreshold: cfg.confidenceThreshold,
-      offlineMode: isOfflineMode,
-      confidenceCeiling
-    }
-  };
-}
-
-// ../lexsona/dist/index.js
-var VERSION = "0.1.0";
-export {
-  LexSona,
-  VERSION,
-  deriveConstraints
-};