sensemaking 0.18.2 → 0.18.4

package/dist/cjs/store/turso/open.js

@@ -0,0 +1,500 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DB_FILENAME () {
+        return DB_FILENAME;
+    },
+    get SCHEMA_VERSION () {
+        return SCHEMA_VERSION;
+    },
+    get openTurso () {
+        return openTurso;
+    }
+});
+var _nodefs = require("node:fs");
+var _nodepath = require("node:path");
+var _indexts = require("../../config/index.js");
+var _errorsts = require("../../errors.js");
+var _indexts1 = require("../../features/index.js");
+var _sharedts = require("../shared.js");
+var _opents = require("../sqlite/open.js");
+var _connectionts = require("./connection.js");
+var _nativets = require("./native.js");
+var _reconcilets = require("./reconcile.js");
+var _storets = require("./store.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var DB_FILENAME = 'cache.turso.db';
+var SCHEMA_VERSION = '1';
+// content is a plain table (not FTS-virtual): phase 1 creates no FTS index at all -- that is
+// phase 2's job (see the plan). Untyped ALTER TABLE ADD COLUMN, like sqlite -- turso's dialect
+// accepts it with no declared type (spike-confirmed), unlike duckdb which requires VARIANT.
+function ensureSchema(conn, cfg) {
+    return _async_to_generator(function() {
+        var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, feature, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE IF NOT EXISTS frontmatter ("path" TEXT PRIMARY KEY, "_mtime" REAL, "_ctime" REAL, "_size" INTEGER, "_parse_error" TEXT)')
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE IF NOT EXISTS content ("path" TEXT PRIMARY KEY, title TEXT, summary TEXT, text TEXT)')
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE IF NOT EXISTS preset_files ("path" TEXT, preset TEXT, PRIMARY KEY ("path", preset))')
+                    ];
+                case 3:
+                    _state.sent();
+                    return [
+                        4,
+                        conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)')
+                    ];
+                case 4:
+                    _state.sent();
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 5;
+                case 5:
+                    _state.trys.push([
+                        5,
+                        10,
+                        11,
+                        12
+                    ]);
+                    _iterator = (0, _indexts1.activeFeatures)(cfg)[Symbol.iterator]();
+                    _state.label = 6;
+                case 6:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        9
+                    ];
+                    feature = _step.value;
+                    return [
+                        4,
+                        feature.schema(conn)
+                    ];
+                case 7:
+                    _state.sent();
+                    _state.label = 8;
+                case 8:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        6
+                    ];
+                case 9:
+                    return [
+                        3,
+                        12
+                    ];
+                case 10:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        12
+                    ];
+                case 11:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 12:
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'schema_version')
+                    ];
+                case 13:
+                    if (!(_state.sent() === null)) return [
+                        3,
+                        15
+                    ];
+                    return [
+                        4,
+                        (0, _sharedts.setMeta)(conn, 'schema_version', SCHEMA_VERSION)
+                    ];
+                case 14:
+                    _state.sent();
+                    _state.label = 15;
+                case 15:
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'features')
+                    ];
+                case 16:
+                    if (!(_state.sent() === null)) return [
+                        3,
+                        18
+                    ];
+                    return [
+                        4,
+                        (0, _sharedts.setMeta)(conn, 'features', (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES))
+                    ];
+                case 17:
+                    _state.sent();
+                    _state.label = 18;
+                case 18:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function connect(cfg) {
+    return _async_to_generator(function() {
+        var stateDir, dbPath, turso, err, db, err1, closed, _ref, conn, version, features, wantFeatures, reason, recordedMaxMs, _ref1, parsed, warnings, err2;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    stateDir = (0, _nodepath.join)(cfg.baseDir, _indexts.STATE_DIR);
+                    (0, _nodefs.mkdirSync)(stateDir, {
+                        recursive: true
+                    });
+                    dbPath = (0, _nodepath.join)(stateDir, DB_FILENAME);
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    return [
+                        4,
+                        (0, _nativets.tursoApi)()
+                    ];
+                case 2:
+                    turso = _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    err = _state.sent();
+                    if (_instanceof(err, _errorsts.SenseError)) throw err;
+                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "turso" needs the '.concat(_nativets.TURSO_PACKAGE, " package (").concat(err.message, ")"));
+                case 4:
+                    _state.trys.push([
+                        4,
+                        6,
+                        ,
+                        7
+                    ]);
+                    return [
+                        4,
+                        turso.connect(dbPath, {
+                            timeout: 30000
+                        })
+                    ];
+                case 5:
+                    // Floored at the same 30s sqlite opens with. `timeout` is a connect-time option in this
+                    // client (no synchronous PRAGMA-at-open-time escape hatch), so the real derived value --
+                    // which depends on this cache's own recorded reconcile_max_ms, readable only once connected
+                    // -- is installed via a runtime PRAGMA below, right before the open-time reconcile, the same
+                    // lever sqlite's open() uses (spike-confirmed: raw PRAGMA busy_timeout works as a setter too).
+                    db = _state.sent();
+                    return [
+                        3,
+                        7
+                    ];
+                case 6:
+                    err1 = _state.sent();
+                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "turso" failed to open '.concat(dbPath, ": ").concat(err1.message));
+                case 7:
+                    // A throw below (schema, reconcile's COLUMN_LIMIT) must release this handle, or the leaked WAL
+                    // makes the db file undeletable on Windows. closed marks the rebuild branch that closes and
+                    // recurses, so the catch never double-closes.
+                    closed = false;
+                    _state.label = 8;
+                case 8:
+                    _state.trys.push([
+                        8,
+                        18,
+                        ,
+                        21
+                    ]);
+                    conn = (0, _connectionts.createConnection)(db);
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)')
+                    ];
+                case 9:
+                    _state.sent();
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'schema_version')
+                    ];
+                case 10:
+                    version = _state.sent();
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'features')
+                    ];
+                case 11:
+                    features = _state.sent();
+                    wantFeatures = (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES);
+                    if (!(version !== null && version !== SCHEMA_VERSION || features !== null && features !== wantFeatures)) return [
+                        3,
+                        13
+                    ];
+                    // Reconcile only reparses changed files, so a stale cache can't be patched incrementally --
+                    // rebuild instead, same as sqlite's and duckdb's open() (see their comments for why this is
+                    // announced). No tokenize-only or embed-identity-adopted partial path (sqlite's grace for
+                    // those): turso has no content.tokenize knob to special-case, and the grace is an
+                    // optimization, not a correctness requirement -- any mismatch rebuilds, duckdb's shape.
+                    reason = version !== null && version !== SCHEMA_VERSION ? 'cache format changed (new sensemaking version)' : 'config change (features, tokenizer, or presets)';
+                    console.error("sense: ".concat(reason, "; rebuilding the index"));
+                    closed = true;
+                    return [
+                        4,
+                        db.close()
+                    ];
+                case 12:
+                    _state.sent();
+                    (0, _opents.clearCache)(cfg);
+                    return [
+                        2,
+                        connect(cfg)
+                    ];
+                case 13:
+                    return [
+                        4,
+                        ensureSchema(conn, cfg)
+                    ];
+                case 14:
+                    _state.sent();
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'reconcile_max_ms')
+                    ];
+                case 15:
+                    recordedMaxMs = Number.apply(void 0, [
+                        (_ref = _state.sent()) !== null && _ref !== void 0 ? _ref : '0'
+                    ]);
+                    return [
+                        4,
+                        conn.exec("PRAGMA busy_timeout = ".concat(Math.min(Math.max(30000, 3 * recordedMaxMs), 600000)))
+                    ];
+                case 16:
+                    _state.sent();
+                    return [
+                        4,
+                        (0, _reconcilets.reconcile)(conn, cfg, cfg.baseDir)
+                    ];
+                case 17:
+                    _ref1 = _state.sent(), parsed = _ref1.parsed, warnings = _ref1.warnings;
+                    return [
+                        2,
+                        {
+                            db: db,
+                            conn: conn,
+                            cfg: cfg,
+                            dbPath: dbPath,
+                            parsed: parsed,
+                            warnings: warnings
+                        }
+                    ];
+                case 18:
+                    err2 = _state.sent();
+                    if (!!closed) return [
+                        3,
+                        20
+                    ];
+                    return [
+                        4,
+                        db.close()
+                    ];
+                case 19:
+                    _state.sent();
+                    _state.label = 20;
+                case 20:
+                    throw err2;
+                case 21:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function openTurso(cfg) {
+    return _async_to_generator(function() {
+        var _ref, db, conn, resolvedCfg, dbPath, parsed, warnings;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        connect(cfg)
+                    ];
+                case 1:
+                    _ref = _state.sent(), db = _ref.db, conn = _ref.conn, resolvedCfg = _ref.cfg, dbPath = _ref.dbPath, parsed = _ref.parsed, warnings = _ref.warnings;
+                    return [
+                        2,
+                        {
+                            store: (0, _storets.createStore)(db, conn, resolvedCfg, resolvedCfg.baseDir),
+                            cfg: resolvedCfg,
+                            dbPath: dbPath,
+                            parsed: parsed,
+                            warnings: warnings
+                        }
+                    ];
+            }
+        });
+    })();
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/store/turso/open.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/turso/open.ts"],"sourcesContent":["import { mkdirSync } from 'node:fs';\nimport { join } from 'node:path';\nimport type { Database } from '@tursodatabase/database';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { featureSignature, STATE_DIR } from '../../config/index.ts';\nimport { SenseError } from '../../errors.ts';\nimport { activeFeatures, FEATURES } from '../../features/index.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport { clearCache } from '../sqlite/open.ts';\nimport type { Connection, Store } from '../types.ts';\nimport { createConnection } from './connection.ts';\nimport { TURSO_PACKAGE, tursoApi } from './native.ts';\nimport { reconcile } from './reconcile.ts';\nimport { createStore } from './store.ts';\n\nexport const DB_FILENAME = 'cache.turso.db';\n// Independent of sqlite's SCHEMA_VERSION and duckdb's -- each store's cache shape evolves\n// separately, and the store name already joins the feature signature (see featureSignature), so\n// a config's `store` key switching cleanly rebuilds rather than reusing another engine's cache.\nexport const SCHEMA_VERSION = '1';\n\nexport interface OpenResult {\n  store: Store;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\n// content is a plain table (not FTS-virtual): phase 1 creates no FTS index at all -- that is\n// phase 2's job (see the plan). Untyped ALTER TABLE ADD COLUMN, like sqlite -- turso's dialect\n// accepts it with no declared type (spike-confirmed), unlike duckdb which requires VARIANT.\nasync function ensureSchema(conn: Connection, cfg: Config): Promise<void> {\n  await conn.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" REAL, \"_ctime\" REAL, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS content (\"path\" TEXT PRIMARY KEY, title TEXT, summary TEXT, text TEXT)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  await conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  for (const feature of activeFeatures(cfg)) await feature.schema(conn);\n  if ((await getMeta(conn, 'schema_version')) === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);\n  if ((await getMeta(conn, 'features')) === null) await setMeta(conn, 'features', featureSignature(cfg, FEATURES));\n}\n\ninterface ConnectResult {\n  db: Database;\n  conn: Connection;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\nasync function connect(cfg: ResolvedConfig): Promise<ConnectResult> {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, DB_FILENAME);\n\n  // Dynamic, not a top-level import: a sqlite or duckdb tree must never even attempt to resolve\n  // this optional dependency, so nothing in this store's module graph imports it as a value until\n  // a turso tree is actually opened (type-only imports elsewhere are erased and cost nothing\n  // either way). Installed on first use if missing (see native.ts's tursoApi).\n  let turso: Awaited<ReturnType<typeof tursoApi>>;\n  try {\n    turso = await tursoApi();\n  } catch (err) {\n    if (err instanceof SenseError) throw err;\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"turso\" needs the ${TURSO_PACKAGE} package (${(err as Error).message})`);\n  }\n\n  let db: Database;\n  try {\n    // Floored at the same 30s sqlite opens with. `timeout` is a connect-time option in this\n    // client (no synchronous PRAGMA-at-open-time escape hatch), so the real derived value --\n    // which depends on this cache's own recorded reconcile_max_ms, readable only once connected\n    // -- is installed via a runtime PRAGMA below, right before the open-time reconcile, the same\n    // lever sqlite's open() uses (spike-confirmed: raw PRAGMA busy_timeout works as a setter too).\n    db = await turso.connect(dbPath, { timeout: 30_000 });\n  } catch (err) {\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"turso\" failed to open ${dbPath}: ${(err as Error).message}`);\n  }\n  // A throw below (schema, reconcile's COLUMN_LIMIT) must release this handle, or the leaked WAL\n  // makes the db file undeletable on Windows. closed marks the rebuild branch that closes and\n  // recurses, so the catch never double-closes.\n  let closed = false;\n  try {\n    const conn = createConnection(db);\n\n    await conn.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n    const version = await getMeta(conn, 'schema_version');\n    const features = await getMeta(conn, 'features');\n    const wantFeatures = featureSignature(cfg, FEATURES);\n    if ((version !== null && version !== SCHEMA_VERSION) || (features !== null && features !== wantFeatures)) {\n      // Reconcile only reparses changed files, so a stale cache can't be patched incrementally --\n      // rebuild instead, same as sqlite's and duckdb's open() (see their comments for why this is\n      // announced). No tokenize-only or embed-identity-adopted partial path (sqlite's grace for\n      // those): turso has no content.tokenize knob to special-case, and the grace is an\n      // optimization, not a correctness requirement -- any mismatch rebuilds, duckdb's shape.\n      const reason = version !== null && version !== SCHEMA_VERSION ? 'cache format changed (new sensemaking version)' : 'config change (features, tokenizer, or presets)';\n      console.error(`sense: ${reason}; rebuilding the index`);\n      closed = true;\n      await db.close();\n      clearCache(cfg);\n      return connect(cfg);\n    }\n\n    await ensureSchema(conn, cfg);\n\n    // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.\n    // Installed before reconcile() -- that call is the one that races a watcher's transaction.\n    const recordedMaxMs = Number((await getMeta(conn, 'reconcile_max_ms')) ?? '0');\n    await conn.exec(`PRAGMA busy_timeout = ${Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000)}`);\n\n    const { parsed, warnings } = await reconcile(conn, cfg, cfg.baseDir);\n\n    return { db, conn, cfg, dbPath, parsed, warnings };\n  } catch (err) {\n    if (!closed) await db.close();\n    throw err;\n  }\n}\n\n// The turso store's open: connects (fully async, see connect() above), then wraps the resulting\n// connection in the Store interface.\nexport async function openTurso(cfg: ResolvedConfig): Promise<OpenResult> {\n  const { db, conn, cfg: resolvedCfg, dbPath, parsed, warnings } = await connect(cfg);\n  return { store: createStore(db, conn, resolvedCfg, resolvedCfg.baseDir), cfg: resolvedCfg, dbPath, parsed, warnings };\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","openTurso","ensureSchema","conn","cfg","feature","exec","activeFeatures","schema","getMeta","setMeta","featureSignature","FEATURES","connect","stateDir","dbPath","turso","err","db","closed","version","features","wantFeatures","reason","recordedMaxMs","parsed","warnings","join","baseDir","STATE_DIR","mkdirSync","recursive","tursoApi","SenseError","TURSO_PACKAGE","message","timeout","createConnection","console","error","close","clearCache","Number","Math","min","max","reconcile","resolvedCfg","store","createStore"],"mappings":"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"}

package/dist/cjs/store/turso/reconcile.d.cts

@@ -0,0 +1,6 @@
+import type { Config } from '../../config/index.js';
+import type { Connection } from '../types.js';
+export declare function reconcile(conn: Connection, cfg: Config, baseDir: string): Promise<{
+    parsed: number;
+    warnings: string[];
+}>;

package/dist/cjs/store/turso/reconcile.d.ts

@@ -0,0 +1,6 @@
+import type { Config } from '../../config/index.js';
+import type { Connection } from '../types.js';
+export declare function reconcile(conn: Connection, cfg: Config, baseDir: string): Promise<{
+    parsed: number;
+    warnings: string[];
+}>;