sensemaking 0.9.1 → 0.9.3

package/dist/cjs/cli/shared.js

@@ -9,6 +9,21 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get CONFIG () {
+        return CONFIG;
+    },
+    get FORMAT () {
+        return FORMAT;
+    },
+    get SEARCH_FLAGS () {
+        return SEARCH_FLAGS;
+    },
+    get formatOf () {
+        return formatOf;
+    },
+    get parse () {
+        return parse;
+    },
     get parseK () {
         return parseK;
     },
@@ -22,14 +37,19 @@ _export(exports, {
         return withDb;
     }
 });
+var _getoptscompat = /*#__PURE__*/ _interop_require_default(require("getopts-compat"));
 var _dbts = require("../db.js");
 var _outputts = require("../output.js");
 var _searcherrorts = require("../search-error.js");
+var _exitts = require("./exit.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
 function _array_without_holes(arr) {
     if (Array.isArray(arr)) return _array_like_to_array(arr);
 }
@@ -62,12 +82,99 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function _iterable_to_array(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _non_iterable_spread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
@@ -178,11 +285,134 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-function parseK(ctx) {
-    if (ctx.values.k === undefined) return undefined;
-    var k = Number(ctx.values.k);
-    if (!Number.isInteger(k) || k <= 0) ctx.usageError('--k expects a positive integer, got "'.concat(ctx.values.k, '"'));
-    return k;
+var FORMAT = {
+    format: {
+        type: 'string',
+        default: 'table'
+    }
+};
+var CONFIG = {
+    config: {
+        type: 'string'
+    }
+};
+var SEARCH_FLAGS = {
+    where: {
+        type: 'string'
+    },
+    k: {
+        type: 'string'
+    },
+    preset: {
+        type: 'string'
+    },
+    include: {
+        type: 'string',
+        multiple: true
+    },
+    lexical: {
+        type: 'boolean',
+        default: false
+    }
+};
+function formatOf(values) {
+    return values.format === 'json' ? 'json' : 'table';
+}
+function parse(argv, usage) {
+    var flags = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    var table = _object_spread_props(_object_spread({}, flags), {
+        help: {
+            type: 'boolean',
+            default: false,
+            short: 'h'
+        }
+    });
+    var string = [];
+    var boolean = [];
+    var alias = {};
+    var defaults = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(table)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], flag = _step_value[1];
+            (flag.type === 'boolean' ? boolean : string).push(name);
+            if (flag.default !== undefined) defaults[name] = flag.default;
+            if (flag.short !== undefined) alias[name] = flag.short;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    // getopts is lenient about undeclared flags -- they land in the result and are silently
+    // ignored, which is the bug 0.9.2 fixed. Record the first and fail below; returning false
+    // also keeps it out of the result. `--k -1` arrives here as unknown option "1", because
+    // getopts reads a leading dash as a new option rather than as --k's value; the message is
+    // blunter than the old one but it is still a usage error rather than a silent default.
+    var unknown;
+    var parsed = (0, _getoptscompat.default)(argv, {
+        string: string,
+        boolean: boolean,
+        alias: alias,
+        default: defaults,
+        unknown: function unknown1(name) {
+            if (unknown === undefined) unknown = name;
+            return false;
+        }
+    });
+    if (unknown !== undefined) (0, _exitts.usageError)("unknown option: ".concat(unknown), usage);
+    if (parsed.help) {
+        console.log(usage);
+        throw new _exitts.ExitError(0);
+    }
+    // Two getopts shapes the callers must not see: an unset string flag reads as "" rather
+    // than undefined, and a flag passed once reads as a string rather than a one-element
+    // array. Both matter -- `?? saved.field` means "flag absent", and --include is a list.
+    var values = {};
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+    try {
+        for(var _iterator1 = Object.entries(table)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+            var _step_value1 = _sliced_to_array(_step1.value, 2), name1 = _step_value1[0], flag1 = _step_value1[1];
+            var raw = parsed[name1];
+            if (flag1.type === 'boolean') values[name1] = raw;
+            else if (flag1.multiple) values[name1] = raw === '' ? undefined : Array.isArray(raw) ? raw : [
+                raw
+            ];
+            else values[name1] = raw === '' ? undefined : raw;
+        }
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+            }
+        } finally{
+            if (_didIteratorError1) {
+                throw _iteratorError1;
+            }
+        }
+    }
+    return {
+        values: values,
+        positionals: parsed._
+    };
+}
+function parseK(k, usageErrorFn) {
+    if (k === undefined) return undefined;
+    var parsed = Number(k);
+    if (!Number.isInteger(parsed) || parsed <= 0) usageErrorFn('--k expects a positive integer, got "'.concat(k, '"'));
+    return parsed;
 }
 function printWarnings(warnings) {
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
@@ -206,13 +436,13 @@ function printWarnings(warnings) {
         }
     }
 }
-function withDb(ctx, fn) {
+function withDb(ctx, configPath, fn) {
     return _async_to_generator(function() {
         var cfg, _open, db, warnings;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    cfg = ctx.resolveConfig();
+                    cfg = ctx.resolveConfig(configPath);
                     _open = (0, _dbts.open)(cfg), db = _open.db, warnings = _open.warnings;
                     printWarnings(warnings);
                     _state.label = 1;
@@ -249,10 +479,7 @@ function withDb(ctx, fn) {
 function runSql(cfg, sql, params, format, label) {
     var _sql_match;
     var placeholderCount = ((_sql_match = sql.match(/\?/g)) !== null && _sql_match !== void 0 ? _sql_match : []).length;
-    if (params.length !== placeholderCount) {
-        console.error("".concat(label, " expects ").concat(placeholderCount, " parameter(s), got ").concat(params.length));
-        process.exit(2);
-    }
+    if (params.length !== placeholderCount) (0, _exitts.usageError)("".concat(label, " expects ").concat(placeholderCount, " parameter(s), got ").concat(params.length));
     var _open = (0, _dbts.open)(cfg), db = _open.db, warnings = _open.warnings;
     printWarnings(warnings);
     var rows;

package/dist/cjs/cli/shared.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ResolvedConfig } from '../config.ts';\nimport type { OpenResult } from '../db.ts';\nimport { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { searchError } from '../search-error.ts';\nimport type { Ctx } from './types.ts';\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as\n// \"nothing\", and parseInt would silently truncate \"5.9\" -- all three are caller mistakes\n// worth a usage error, matching the config-level SavedSearch validation.\nexport function parseK(ctx: Ctx): number | undefined {\n  if (ctx.values.k === undefined) return undefined;\n  const k = Number(ctx.values.k);\n  if (!Number.isInteger(k) || k <= 0) ctx.usageError(`--k expects a positive integer, got \"${ctx.values.k}\"`);\n  return k;\n}\n\n// Shared open-query-close envelope for commands that touch the tree.\n\nexport function printWarnings(warnings: string[]): void {\n  for (const w of warnings) console.warn(w);\n}\n\nexport async function withDb(ctx: Ctx, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig();\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  try {\n    await fn(db, cfg);\n  } finally {\n    db.close();\n  }\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(2);\n  }\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  let rows: Row[];\n  try {\n    rows = db.prepare(sql).all(...params) as Row[];\n  } catch (err) {\n    db.close();\n    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5\n    // punctuation trap applies -- the bound parameters are the search terms there. SQL\n    // without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n    if (/\\bMATCH\\b/i.test(sql)) throw searchError(err as Error, params.join(' '));\n    throw err;\n  }\n  printRows(rows, format);\n  db.close();\n}\n"],"names":["parseK","printWarnings","runSql","withDb","ctx","values","k","undefined","Number","isInteger","usageError","warnings","w","console","warn","fn","cfg","open","db","resolveConfig","close","sql","params","format","label","placeholderCount","match","length","error","process","exit","rows","prepare","all","err","test","searchError","join","printRows"],"mappings":";;;;;;;;;;;QAWgBA;eAAAA;;QASAC;eAAAA;;QAgBAC;eAAAA;;QAZMC;eAAAA;;;oBAtBD;wBAEK;6BACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMrB,SAASH,OAAOI,GAAQ;IAC7B,IAAIA,IAAIC,MAAM,CAACC,CAAC,KAAKC,WAAW,OAAOA;IACvC,IAAMD,IAAIE,OAAOJ,IAAIC,MAAM,CAACC,CAAC;IAC7B,IAAI,CAACE,OAAOC,SAAS,CAACH,MAAMA,KAAK,GAAGF,IAAIM,UAAU,CAAC,AAAC,wCAAoD,OAAbN,IAAIC,MAAM,CAACC,CAAC,EAAC;IACxG,OAAOA;AACT;AAIO,SAASL,cAAcU,QAAkB;QACzC,kCAAA,2BAAA;;QAAL,QAAK,YAAWA,6BAAX,SAAA,6BAAA,QAAA,yBAAA;YAAA,IAAMC,IAAN;YAAqBC,QAAQC,IAAI,CAACF;;;QAAlC;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;AACP;AAEO,SAAeT,OAAOC,GAAQ,EAAEW,EAAuE;;YACtGC,KACmBC,OAAjBC,IAAIP;;;;oBADNK,MAAMZ,IAAIe,aAAa;oBACJF,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIP,WAAaM,MAAbN;oBACZV,cAAcU;;;;;;;;;oBAEZ;;wBAAMI,GAAGG,IAAIF;;;oBAAb;;;;;;oBAEAE,GAAGE,KAAK;;;;;;;;;;IAEZ;;AAGO,SAASlB,OAAOc,GAAmB,EAAEK,GAAW,EAAEC,MAAgB,EAAEC,MAAwB,EAAEC,KAAa;QACtFH;IAA1B,IAAMI,mBAAmB,EAACJ,aAAAA,IAAIK,KAAK,CAAC,oBAAVL,wBAAAA,aAAoB,EAAE,EAAEM,MAAM;IACxD,IAAIL,OAAOK,MAAM,KAAKF,kBAAkB;QACtCZ,QAAQe,KAAK,CAAC,AAAC,GAAmBH,OAAjBD,OAAM,aAAiDF,OAAtCG,kBAAiB,uBAAmC,OAAdH,OAAOK,MAAM;QACrFE,QAAQC,IAAI,CAAC;IACf;IACA,IAAyBb,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIP,WAAaM,MAAbN;IACZV,cAAcU;IACd,IAAIoB;IACJ,IAAI;YACKb;QAAPa,OAAOb,CAAAA,cAAAA,GAAGc,OAAO,CAACX,MAAKY,GAAG,OAAnBf,aAAoB,qBAAGI;IAChC,EAAE,OAAOY,KAAK;QACZhB,GAAGE,KAAK;QACR,gFAAgF;QAChF,mFAAmF;QACnF,sFAAsF;QACtF,IAAI,aAAae,IAAI,CAACd,MAAM,MAAMe,IAAAA,0BAAW,EAACF,KAAcZ,OAAOe,IAAI,CAAC;QACxE,MAAMH;IACR;IACAI,IAAAA,mBAAS,EAACP,MAAMR;IAChBL,GAAGE,KAAK;AACV"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import getopts from 'getopts-compat';\nimport type { ResolvedConfig } from '../config.ts';\nimport type { OpenResult } from '../db.ts';\nimport { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { searchError } from '../search-error.ts';\nimport { ExitError, usageError } from './exit.ts';\nimport type { Ctx } from './types.ts';\n\n// Flag descriptors, spreadable so one flag name keeps one meaning across every command's\n// table. parse() converts them to the getopts call the rest of the CLIs here make directly.\nexport interface Flag {\n  type: 'string' | 'boolean';\n  default?: string | boolean;\n  multiple?: boolean;\n  short?: string;\n}\nexport type Flags = Record<string, Flag>;\n\nexport const FORMAT: Flags = { format: { type: 'string', default: 'table' } };\nexport const CONFIG: Flags = { config: { type: 'string' } };\nexport const SEARCH_FLAGS: Flags = {\n  where: { type: 'string' },\n  k: { type: 'string' },\n  preset: { type: 'string' },\n  include: { type: 'string', multiple: true },\n  lexical: { type: 'boolean', default: false },\n};\n\nexport type Values = Record<string, string | boolean | string[] | undefined>;\n\nexport function formatOf(values: Values): 'table' | 'json' {\n  return values.format === 'json' ? 'json' : 'table';\n}\n\n// Per-command parse: strict (a foreign flag exits 2), and every table gets --help for free.\nexport function parse(argv: string[], usage: string, flags: Flags = {}): { values: Values; positionals: string[] } {\n  const table: Flags = { ...flags, help: { type: 'boolean', default: false, short: 'h' } };\n  const string: string[] = [];\n  const boolean: string[] = [];\n  const alias: Record<string, string> = {};\n  const defaults: Record<string, string | boolean> = {};\n  for (const [name, flag] of Object.entries(table)) {\n    (flag.type === 'boolean' ? boolean : string).push(name);\n    if (flag.default !== undefined) defaults[name] = flag.default;\n    if (flag.short !== undefined) alias[name] = flag.short;\n  }\n\n  // getopts is lenient about undeclared flags -- they land in the result and are silently\n  // ignored, which is the bug 0.9.2 fixed. Record the first and fail below; returning false\n  // also keeps it out of the result. `--k -1` arrives here as unknown option \"1\", because\n  // getopts reads a leading dash as a new option rather than as --k's value; the message is\n  // blunter than the old one but it is still a usage error rather than a silent default.\n  let unknown: string | undefined;\n  const parsed = getopts(argv, {\n    string,\n    boolean,\n    alias,\n    default: defaults,\n    unknown: (name: string): boolean => {\n      if (unknown === undefined) unknown = name;\n      return false;\n    },\n  });\n  if (unknown !== undefined) usageError(`unknown option: ${unknown}`, usage);\n  if (parsed.help) {\n    console.log(usage);\n    throw new ExitError(0);\n  }\n\n  // Two getopts shapes the callers must not see: an unset string flag reads as \"\" rather\n  // than undefined, and a flag passed once reads as a string rather than a one-element\n  // array. Both matter -- `?? saved.field` means \"flag absent\", and --include is a list.\n  const values: Values = {};\n  for (const [name, flag] of Object.entries(table)) {\n    const raw = parsed[name];\n    if (flag.type === 'boolean') values[name] = raw as boolean;\n    else if (flag.multiple) values[name] = raw === '' ? undefined : Array.isArray(raw) ? (raw as string[]) : [raw as string];\n    else values[name] = raw === '' ? undefined : (raw as string);\n  }\n  return { values, positionals: parsed._ };\n}\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as\n// \"nothing\", and parseInt would silently truncate \"5.9\" -- all three are caller mistakes\n// worth a usage error, matching the config-level SavedSearch validation.\nexport function parseK(k: string | undefined, usageErrorFn: (message: string) => never): number | undefined {\n  if (k === undefined) return undefined;\n  const parsed = Number(k);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageErrorFn(`--k expects a positive integer, got \"${k}\"`);\n  return parsed;\n}\n\n// Shared open-query-close envelope for commands that touch the tree.\n\nexport function printWarnings(warnings: string[]): void {\n  for (const w of warnings) console.warn(w);\n}\n\nexport async function withDb(ctx: Ctx, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath);\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  try {\n    await fn(db, cfg);\n  } finally {\n    db.close();\n  }\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) usageError(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  let rows: Row[];\n  try {\n    rows = db.prepare(sql).all(...params) as Row[];\n  } catch (err) {\n    db.close();\n    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5\n    // punctuation trap applies -- the bound parameters are the search terms there. SQL\n    // without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n    if (/\\bMATCH\\b/i.test(sql)) throw searchError(err as Error, params.join(' '));\n    throw err;\n  }\n  printRows(rows, format);\n  db.close();\n}\n"],"names":["CONFIG","FORMAT","SEARCH_FLAGS","formatOf","parse","parseK","printWarnings","runSql","withDb","format","type","default","config","where","k","preset","include","multiple","lexical","values","argv","usage","flags","table","help","short","string","boolean","alias","defaults","Object","entries","name","flag","push","undefined","unknown","parsed","getopts","usageError","console","log","ExitError","raw","Array","isArray","positionals","_","usageErrorFn","Number","isInteger","warnings","w","warn","ctx","configPath","fn","cfg","open","db","resolveConfig","close","sql","params","label","placeholderCount","match","length","rows","prepare","all","err","test","searchError","join","printRows"],"mappings":"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"}

package/dist/cjs/cli/status.js

@@ -12,6 +12,7 @@ var _commandsts = require("../commands.js");
 var _configts = require("../config.js");
 var _dbts = require("../db.js");
 var _outputts = require("../output.js");
+var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -53,7 +54,9 @@ function vectorState(db) {
     }
 }
 var status = function status(ctx) {
-    var cfg = ctx.resolveConfig();
+    var values = (0, _sharedts.parse)(ctx.argv, "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.status), _object_spread({}, _sharedts.FORMAT, _sharedts.CONFIG)).values;
+    var format = (0, _sharedts.formatOf)(values);
+    var cfg = ctx.resolveConfig(values.config);
     var _open = (0, _dbts.open)(cfg), db = _open.db, dbPath = _open.dbPath, warnings = _open.warnings;
     (0, _sharedts.printWarnings)(warnings);
     var features = (0, _configts.featureStates)(cfg);
@@ -78,7 +81,7 @@ var status = function status(ctx) {
         watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,
         busyTimeoutMs: busyTimeoutMs
     };
-    if (ctx.format === 'json') {
+    if (format === 'json') {
         console.log(JSON.stringify(result, null, 2));
     } else {
         console.log("db: ".concat(result.db));

package/dist/cjs/cli/status.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { presetCoverage } from '../commands.ts';\nimport { embedConfig, featureStates } from '../config.ts';\nimport { docCount, getMeta, open } from '../db.ts';\nimport { featuresLine, presetsLines } from '../output.ts';\nimport { printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// Vectors are computed on the first semantic query, not at reconcile, so a tree can have a\n// semantic-on preset with nothing embedded yet -- reported here because a fast `rebuild` on\n// such a tree otherwise reads as \"the feature isn't on\".\nfunction vectorState(db: ReturnType<typeof open>['db']): { embedded: number; pending: number } | null {\n  try {\n    const row = db.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings').get() as { embedded: number; pending: number };\n    return row;\n  } catch {\n    return null;\n  }\n}\n\nconst status: Command = (ctx) => {\n  const cfg = ctx.resolveConfig();\n  const { db, dbPath, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const features = featureStates(cfg);\n  const e = embedConfig(cfg);\n  const vectors = e ? vectorState(db) : null;\n  const presets = presetCoverage(db, cfg);\n  const heartbeat = getMeta(db, 'watch_heartbeat');\n  // Derived at open() (F): 3x the largest reconcile this cache has ever held its write\n  // transaction for, floored at 30s -- read back from the connection rather than\n  // recomputed here, so this always reports what open() actually set.\n  const busyTimeoutMs = (db.prepare('PRAGMA busy_timeout').get() as { timeout: number }).timeout;\n  const result = {\n    db: dbPath,\n    docs: docCount(db),\n    features: features.on,\n    featuresOff: features.off,\n    embed: e ? { type: e.type, model: e.model, ...(vectors ?? {}) } : null,\n    presets,\n    watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,\n    busyTimeoutMs,\n  };\n\n  if (ctx.format === 'json') {\n    console.log(JSON.stringify(result, null, 2));\n  } else {\n    console.log(`db: ${result.db}`);\n    console.log(`docs: ${result.docs}`);\n    console.log(featuresLine(features));\n    if (e) console.log(`embed: ${e.type} ${e.model}${vectors ? ` (vectors: ${vectors.embedded} embedded, ${vectors.pending} pending — embedded on the first semantic search)` : ''}`);\n    for (const line of presetsLines(presets)) console.log(line);\n    console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher: no watcher' : `watcher: last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n    console.log(`busy_timeout: ${result.busyTimeoutMs}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)`);\n  }\n  db.close();\n};\nexport default status;\n"],"names":["vectorState","db","row","prepare","get","status","ctx","cfg","resolveConfig","open","dbPath","warnings","printWarnings","features","featureStates","e","embedConfig","vectors","presets","presetCoverage","heartbeat","getMeta","busyTimeoutMs","timeout","result","docs","docCount","on","featuresOff","off","embed","type","model","watcherHeartbeatSecondsAgo","Math","round","Date","now","parse","format","console","log","JSON","stringify","featuresLine","embedded","pending","presetsLines","line","close"],"mappings":";;;;+BAyDA;;;eAAA;;;0BAzD+B;wBACY;oBACH;wBACG;wBACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG9B,2FAA2F;AAC3F,4FAA4F;AAC5F,yDAAyD;AACzD,SAASA,YAAYC,EAAiC;IACpD,IAAI;QACF,IAAMC,MAAMD,GAAGE,OAAO,CAAC,yFAAyFC,GAAG;QACnH,OAAOF;IACT,EAAE,eAAM;QACN,OAAO;IACT;AACF;AAEA,IAAMG,SAAkB,gBAACC;IACvB,IAAMC,MAAMD,IAAIE,aAAa;IAC7B,IAAiCC,QAAAA,IAAAA,UAAI,EAACF,MAA9BN,KAAyBQ,MAAzBR,IAAIS,SAAqBD,MAArBC,QAAQC,WAAaF,MAAbE;IACpBC,IAAAA,uBAAa,EAACD;IAEd,IAAME,WAAWC,IAAAA,uBAAa,EAACP;IAC/B,IAAMQ,IAAIC,IAAAA,qBAAW,EAACT;IACtB,IAAMU,UAAUF,IAAIf,YAAYC,MAAM;IACtC,IAAMiB,UAAUC,IAAAA,0BAAc,EAAClB,IAAIM;IACnC,IAAMa,YAAYC,IAAAA,aAAO,EAACpB,IAAI;IAC9B,qFAAqF;IACrF,+EAA+E;IAC/E,oEAAoE;IACpE,IAAMqB,gBAAgB,AAACrB,GAAGE,OAAO,CAAC,uBAAuBC,GAAG,GAA2BmB,OAAO;IAC9F,IAAMC,SAAS;QACbvB,IAAIS;QACJe,MAAMC,IAAAA,cAAQ,EAACzB;QACfY,UAAUA,SAASc,EAAE;QACrBC,aAAaf,SAASgB,GAAG;QACzBC,OAAOf,IAAI;YAAEgB,MAAMhB,EAAEgB,IAAI;YAAEC,OAAOjB,EAAEiB,KAAK;WAAMf,oBAAAA,qBAAAA,UAAW,CAAC,KAAO;QAClEC,SAAAA;QACAe,4BAA4Bb,YAAYc,KAAKC,KAAK,CAAC,AAACC,CAAAA,KAAKC,GAAG,KAAKD,KAAKE,KAAK,CAAClB,UAAS,IAAK,QAAQ;QAClGE,eAAAA;IACF;IAEA,IAAIhB,IAAIiC,MAAM,KAAK,QAAQ;QACzBC,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACnB,QAAQ,MAAM;IAC3C,OAAO;QACLgB,QAAQC,GAAG,CAAC,AAAC,OAAgB,OAAVjB,OAAOvB,EAAE;QAC5BuC,QAAQC,GAAG,CAAC,AAAC,SAAoB,OAAZjB,OAAOC,IAAI;QAChCe,QAAQC,GAAG,CAACG,IAAAA,sBAAY,EAAC/B;QACzB,IAAIE,GAAGyB,QAAQC,GAAG,CAAC,AAAC,UAAmB1B,OAAVA,EAAEgB,IAAI,EAAC,KAAad,OAAVF,EAAEiB,KAAK,EAAiI,OAA9Hf,UAAU,AAAC,cAA2CA,OAA9BA,QAAQ4B,QAAQ,EAAC,eAA6B,OAAhB5B,QAAQ6B,OAAO,EAAC,uDAAqD;YACvK,kCAAA,2BAAA;;YAAL,QAAK,YAAcC,IAAAA,sBAAY,EAAC7B,6BAA3B,SAAA,6BAAA,QAAA,yBAAA;gBAAA,IAAM8B,OAAN;gBAAqCR,QAAQC,GAAG,CAACO;;;YAAjD;YAAA;;;qBAAA,6BAAA;oBAAA;;;oBAAA;0BAAA;;;;QACLR,QAAQC,GAAG,CAACjB,OAAOS,0BAA0B,KAAK,OAAO,wBAAwB,AAAC,2BAA4D,OAAlCT,OAAOS,0BAA0B,EAAC;QAC9IO,QAAQC,GAAG,CAAC,AAAC,iBAAqC,OAArBjB,OAAOF,aAAa,EAAC;IACpD;IACArB,GAAGgD,KAAK;AACV;IACA,WAAe5C"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { presetCoverage } from '../commands.ts';\nimport { embedConfig, featureStates } from '../config.ts';\nimport { docCount, getMeta, open } from '../db.ts';\nimport { featuresLine, presetsLines } from '../output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// Vectors are computed on the first semantic query, not at reconcile, so a tree can have a\n// semantic-on preset with nothing embedded yet -- reported here because a fast `rebuild` on\n// such a tree otherwise reads as \"the feature isn't on\".\nfunction vectorState(db: ReturnType<typeof open>['db']): { embedded: number; pending: number } | null {\n  try {\n    const row = db.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings').get() as { embedded: number; pending: number };\n    return row;\n  } catch {\n    return null;\n  }\n}\n\nconst status: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.status}`, { ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const cfg = ctx.resolveConfig(values.config as string | undefined);\n  const { db, dbPath, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const features = featureStates(cfg);\n  const e = embedConfig(cfg);\n  const vectors = e ? vectorState(db) : null;\n  const presets = presetCoverage(db, cfg);\n  const heartbeat = getMeta(db, 'watch_heartbeat');\n  // Derived at open() (F): 3x the largest reconcile this cache has ever held its write\n  // transaction for, floored at 30s -- read back from the connection rather than\n  // recomputed here, so this always reports what open() actually set.\n  const busyTimeoutMs = (db.prepare('PRAGMA busy_timeout').get() as { timeout: number }).timeout;\n  const result = {\n    db: dbPath,\n    docs: docCount(db),\n    features: features.on,\n    featuresOff: features.off,\n    embed: e ? { type: e.type, model: e.model, ...(vectors ?? {}) } : null,\n    presets,\n    watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,\n    busyTimeoutMs,\n  };\n\n  if (format === 'json') {\n    console.log(JSON.stringify(result, null, 2));\n  } else {\n    console.log(`db: ${result.db}`);\n    console.log(`docs: ${result.docs}`);\n    console.log(featuresLine(features));\n    if (e) console.log(`embed: ${e.type} ${e.model}${vectors ? ` (vectors: ${vectors.embedded} embedded, ${vectors.pending} pending — embedded on the first semantic search)` : ''}`);\n    for (const line of presetsLines(presets)) console.log(line);\n    console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher: no watcher' : `watcher: last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n    console.log(`busy_timeout: ${result.busyTimeoutMs}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)`);\n  }\n  db.close();\n};\nexport default status;\n"],"names":["vectorState","db","row","prepare","get","status","ctx","values","parse","argv","USAGE","name","FORMAT","CONFIG","format","formatOf","cfg","resolveConfig","config","open","dbPath","warnings","printWarnings","features","featureStates","e","embedConfig","vectors","presets","presetCoverage","heartbeat","getMeta","busyTimeoutMs","timeout","result","docs","docCount","on","featuresOff","off","embed","type","model","watcherHeartbeatSecondsAgo","Math","round","Date","now","console","log","JSON","stringify","featuresLine","embedded","pending","presetsLines","line","close"],"mappings":"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"}

package/dist/cjs/cli/types.d.cts

@@ -1,18 +1,8 @@
 import type { ResolvedConfig } from '../config.js';
 export interface Ctx {
     name: string;
-    rest: string[];
-    format: 'table' | 'json';
-    values: {
-        config?: string;
-        where?: string;
-        k?: string;
-        preset?: string;
-        include?: string[];
-        force: boolean;
-        lexical: boolean;
-    };
-    resolveConfig(): ResolvedConfig;
+    argv: string[];
+    resolveConfig(configPath?: string): ResolvedConfig;
     usageError(message: string): never;
 }
 export type Command = (ctx: Ctx) => Promise<void> | void;

package/dist/cjs/cli/types.d.ts

@@ -1,18 +1,8 @@
 import type { ResolvedConfig } from '../config.js';
 export interface Ctx {
     name: string;
-    rest: string[];
-    format: 'table' | 'json';
-    values: {
-        config?: string;
-        where?: string;
-        k?: string;
-        preset?: string;
-        include?: string[];
-        force: boolean;
-        lexical: boolean;
-    };
-    resolveConfig(): ResolvedConfig;
+    argv: string[];
+    resolveConfig(configPath?: string): ResolvedConfig;
     usageError(message: string): never;
 }
 export type Command = (ctx: Ctx) => Promise<void> | void;

package/dist/cjs/cli/watch.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _watchts = require("../watch.js");
+var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -39,6 +40,34 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -140,13 +169,20 @@ function _ts_generator(thisArg, body) {
 }
 var watch = function watch(ctx) {
     return _async_to_generator(function() {
+        var values;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
+                    values = (0, _sharedts.parse)(ctx.argv, "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.watch), _object_spread({
+                        force: {
+                            type: 'boolean',
+                            default: false
+                        }
+                    }, _sharedts.CONFIG)).values;
                     return [
                         4,
-                        (0, _watchts.runWatch)(ctx.resolveConfig(), {
-                            force: ctx.values.force,
+                        (0, _watchts.runWatch)(ctx.resolveConfig(values.config), {
+                            force: values.force,
                             onEvent: function onEvent(event) {
                                 if (event.type === 'started') {
                                     console.log("".concat(ctx.name, " watch: watching ").concat(event.baseDir));

package/dist/cjs/cli/watch.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/watch.ts"],"sourcesContent":["import type { WatchEvent } from '../watch.ts';\nimport { runWatch } from '../watch.ts';\nimport { printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst watch: Command = async (ctx) => {\n  await runWatch(ctx.resolveConfig(), {\n    force: ctx.values.force,\n    onEvent: (event: WatchEvent) => {\n      if (event.type === 'started') {\n        console.log(`${ctx.name} watch: watching ${event.baseDir}`);\n        console.log(`${ctx.name} watch: db ${event.dbPath}`);\n      } else if (event.type === 'reconciled') {\n        printWarnings(event.warnings);\n        if (event.parsed > 0) console.log(`${ctx.name} watch: reconciled, ${event.parsed} file(s) reparsed (${event.total} total)`);\n      } else {\n        console.error(`${ctx.name} watch: reconcile error: ${event.message}`);\n      }\n    },\n  });\n};\nexport default watch;\n"],"names":["watch","ctx","runWatch","resolveConfig","force","values","onEvent","event","type","console","log","name","baseDir","dbPath","printWarnings","warnings","parsed","total","error","message"],"mappings":";;;;+BAqBA;;;eAAA;;;uBApByB;wBACK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG9B,IAAMA,QAAiB,eAAOC;;;;;oBAC5B;;wBAAMC,IAAAA,iBAAQ,EAACD,IAAIE,aAAa,IAAI;4BAClCC,OAAOH,IAAII,MAAM,CAACD,KAAK;4BACvBE,SAAS,SAATA,QAAUC;gCACR,IAAIA,MAAMC,IAAI,KAAK,WAAW;oCAC5BC,QAAQC,GAAG,CAAC,AAAC,GAA8BH,OAA5BN,IAAIU,IAAI,EAAC,qBAAiC,OAAdJ,MAAMK,OAAO;oCACxDH,QAAQC,GAAG,CAAC,AAAC,GAAwBH,OAAtBN,IAAIU,IAAI,EAAC,eAA0B,OAAbJ,MAAMM,MAAM;gCACnD,OAAO,IAAIN,MAAMC,IAAI,KAAK,cAAc;oCACtCM,IAAAA,uBAAa,EAACP,MAAMQ,QAAQ;oCAC5B,IAAIR,MAAMS,MAAM,GAAG,GAAGP,QAAQC,GAAG,CAAC,AAAC,GAAiCH,OAA/BN,IAAIU,IAAI,EAAC,wBAAwDJ,OAAlCA,MAAMS,MAAM,EAAC,uBAAiC,OAAZT,MAAMU,KAAK,EAAC;gCACpH,OAAO;oCACLR,QAAQS,KAAK,CAAC,AAAC,GAAsCX,OAApCN,IAAIU,IAAI,EAAC,6BAAyC,OAAdJ,MAAMY,OAAO;gCACpE;4BACF;wBACF;;;oBAbA;;;;;;IAcF;;IACA,WAAenB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/watch.ts"],"sourcesContent":["import type { WatchEvent } from '../watch.ts';\nimport { runWatch } from '../watch.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst watch: Command = async (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.watch}`, { force: { type: 'boolean', default: false }, ...CONFIG });\n  await runWatch(ctx.resolveConfig(values.config as string | undefined), {\n    force: values.force as boolean,\n    onEvent: (event: WatchEvent) => {\n      if (event.type === 'started') {\n        console.log(`${ctx.name} watch: watching ${event.baseDir}`);\n        console.log(`${ctx.name} watch: db ${event.dbPath}`);\n      } else if (event.type === 'reconciled') {\n        printWarnings(event.warnings);\n        if (event.parsed > 0) console.log(`${ctx.name} watch: reconciled, ${event.parsed} file(s) reparsed (${event.total} total)`);\n      } else {\n        console.error(`${ctx.name} watch: reconcile error: ${event.message}`);\n      }\n    },\n  });\n};\nexport default watch;\n"],"names":["watch","ctx","values","parse","argv","USAGE","name","force","type","default","CONFIG","runWatch","resolveConfig","config","onEvent","event","console","log","baseDir","dbPath","printWarnings","warnings","parsed","total","error","message"],"mappings":";;;;+BAuBA;;;eAAA;;;uBAtByB;uBACH;wBACuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7C,IAAMA,QAAiB,eAAOC;;YACpBC;;;;oBAAAA,SAAWC,IAAAA,eAAK,EAACF,IAAIG,IAAI,EAAE,AAAC,UAAqBC,OAAZJ,IAAIK,IAAI,EAAC,KAAe,OAAZD,cAAK,CAACL,KAAK,GAAI;wBAAEO,OAAO;4BAAEC,MAAM;4BAAWC,SAAS;wBAAM;uBAAMC,gBAAM,GAAvHR;oBACR;;wBAAMS,IAAAA,iBAAQ,EAACV,IAAIW,aAAa,CAACV,OAAOW,MAAM,GAAyB;4BACrEN,OAAOL,OAAOK,KAAK;4BACnBO,SAAS,SAATA,QAAUC;gCACR,IAAIA,MAAMP,IAAI,KAAK,WAAW;oCAC5BQ,QAAQC,GAAG,CAAC,AAAC,GAA8BF,OAA5Bd,IAAIK,IAAI,EAAC,qBAAiC,OAAdS,MAAMG,OAAO;oCACxDF,QAAQC,GAAG,CAAC,AAAC,GAAwBF,OAAtBd,IAAIK,IAAI,EAAC,eAA0B,OAAbS,MAAMI,MAAM;gCACnD,OAAO,IAAIJ,MAAMP,IAAI,KAAK,cAAc;oCACtCY,IAAAA,uBAAa,EAACL,MAAMM,QAAQ;oCAC5B,IAAIN,MAAMO,MAAM,GAAG,GAAGN,QAAQC,GAAG,CAAC,AAAC,GAAiCF,OAA/Bd,IAAIK,IAAI,EAAC,wBAAwDS,OAAlCA,MAAMO,MAAM,EAAC,uBAAiC,OAAZP,MAAMQ,KAAK,EAAC;gCACpH,OAAO;oCACLP,QAAQQ,KAAK,CAAC,AAAC,GAAsCT,OAApCd,IAAIK,IAAI,EAAC,6BAAyC,OAAdS,MAAMU,OAAO;gCACpE;4BACF;wBACF;;;oBAbA;;;;;;IAcF;;IACA,WAAezB"}