sensemaking 0.17.0 → 0.18.0

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

@@ -0,0 +1,501 @@
+"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 openDuckdb () {
+        return openDuckdb;
+    }
+});
+var _nodefs = require("node:fs");
+var _nodepath = require("node:path");
+var _indexts = require("../../config/index.js");
+var _typests = require("../../embed/types.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 _sqlfunctionsts = require("./sql-functions.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.duckdb';
+var SCHEMA_VERSION = '2';
+// `content` is a plain table (not FTS-virtual): D1 builds DuckDB's fts index over it lazily,
+// only when a lexical query actually runs (see duckdb/lexical.ts), and reads it directly for
+// contains() substring/phrase/unspaced-script verification either way. No tokenizer resolution
+// -- this store always uses the fts extension's default (porter) stemmer, unlike sqlite's
+// configurable `content.tokenize` (not read here; D1 does not extend that knob to DuckDB).
+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" DOUBLE, "_ctime" DOUBLE, "_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,
+                        12,
+                        13,
+                        14
+                    ]);
+                    _iterator = (0, _indexts1.activeFeatures)(cfg)[Symbol.iterator]();
+                    _state.label = 6;
+                case 6:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        11
+                    ];
+                    feature = _step.value;
+                    if (!(feature.name === 'embed')) return [
+                        3,
+                        8
+                    ];
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE IF NOT EXISTS embeddings ("path" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, scale REAL, vector FLOAT['.concat(_typests.STORE_DIMS, '], PRIMARY KEY ("path", chunk))'))
+                    ];
+                case 7:
+                    _state.sent();
+                    return [
+                        3,
+                        10
+                    ];
+                case 8:
+                    return [
+                        4,
+                        feature.schema(conn)
+                    ];
+                case 9:
+                    _state.sent();
+                    _state.label = 10;
+                case 10:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        6
+                    ];
+                case 11:
+                    return [
+                        3,
+                        14
+                    ];
+                case 12:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        14
+                    ];
+                case 13:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 14:
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'schema_version')
+                    ];
+                case 15:
+                    if (!(_state.sent() === null)) return [
+                        3,
+                        17
+                    ];
+                    return [
+                        4,
+                        (0, _sharedts.setMeta)(conn, 'schema_version', SCHEMA_VERSION)
+                    ];
+                case 16:
+                    _state.sent();
+                    _state.label = 17;
+                case 17:
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'features')
+                    ];
+                case 18:
+                    if (!(_state.sent() === null)) return [
+                        3,
+                        20
+                    ];
+                    return [
+                        4,
+                        (0, _sharedts.setMeta)(conn, 'features', (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES))
+                    ];
+                case 19:
+                    _state.sent();
+                    _state.label = 20;
+                case 20:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function connect(cfg) {
+    return _async_to_generator(function() {
+        var stateDir, dbPath, DuckDBInstance, err, duckdb, instance, err1, closed, conn, version, features, wantFeatures, reason, _ref, 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.duckdbApi)()
+                    ];
+                case 2:
+                    DuckDBInstance = _state.sent().DuckDBInstance;
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    err = _state.sent();
+                    if (_instanceof(err, _errorsts.SenseError)) throw err;
+                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "duckdb" needs the '.concat(_nativets.DUCKDB_PACKAGE, " package (").concat(err.message, ")"));
+                case 4:
+                    _state.trys.push([
+                        4,
+                        7,
+                        ,
+                        8
+                    ]);
+                    return [
+                        4,
+                        DuckDBInstance.create(dbPath, {
+                            storage_compatibility_version: 'v1.5.0'
+                        })
+                    ];
+                case 5:
+                    // On-disk files default to an older storage format for cross-version compatibility, which
+                    // rejects VARIANT columns ("VARIANT columns are not supported in storage versions prior to
+                    // v1.5.0"); this store's dynamic frontmatter columns need VARIANT (see reconcile.ts), so
+                    // the format floor is pinned explicitly. :memory: databases are unaffected either way.
+                    instance = _state.sent();
+                    return [
+                        4,
+                        instance.connect()
+                    ];
+                case 6:
+                    duckdb = _state.sent();
+                    return [
+                        3,
+                        8
+                    ];
+                case 7:
+                    err1 = _state.sent();
+                    // create() may have succeeded before connect() failed: close it, or its WAL stays open.
+                    instance === null || instance === void 0 ? void 0 : instance.closeSync();
+                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "duckdb" failed to open '.concat(dbPath, ": ").concat(err1.message));
+                case 8:
+                    // A throw below (schema, reconcile's COLUMN_LIMIT) would leak the open instance, whose WAL
+                    // then locks the .duckdb file undeletable on Windows. closed marks the rebuild branch.
+                    closed = false;
+                    _state.label = 9;
+                case 9:
+                    _state.trys.push([
+                        9,
+                        16,
+                        ,
+                        17
+                    ]);
+                    return [
+                        4,
+                        (0, _sqlfunctionsts.registerFunctions)(duckdb)
+                    ];
+                case 10:
+                    _state.sent();
+                    conn = (0, _connectionts.createConnection)(duckdb);
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)')
+                    ];
+                case 11:
+                    _state.sent();
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'schema_version')
+                    ];
+                case 12:
+                    version = _state.sent();
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'features')
+                    ];
+                case 13:
+                    features = _state.sent();
+                    wantFeatures = (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES);
+                    if (version !== null && version !== SCHEMA_VERSION || features !== null && features !== wantFeatures) {
+                        // Reconcile only reparses changed files, so a stale cache can't be patched incrementally --
+                        // rebuild instead, same as sqlite's open() (see its comment for why this is announced).
+                        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"));
+                        // Close before clearCache deletes the files underneath the still-open instance.
+                        closed = true;
+                        duckdb.disconnectSync();
+                        instance.closeSync();
+                        (0, _opents.clearCache)(cfg);
+                        return [
+                            2,
+                            connect(cfg)
+                        ];
+                    }
+                    return [
+                        4,
+                        ensureSchema(conn, cfg)
+                    ];
+                case 14:
+                    _state.sent();
+                    return [
+                        4,
+                        (0, _reconcilets.reconcile)(conn, cfg, cfg.baseDir)
+                    ];
+                case 15:
+                    _ref = _state.sent(), parsed = _ref.parsed, warnings = _ref.warnings;
+                    return [
+                        2,
+                        {
+                            instance: instance,
+                            duckdb: duckdb,
+                            conn: conn,
+                            cfg: cfg,
+                            dbPath: dbPath,
+                            parsed: parsed,
+                            warnings: warnings
+                        }
+                    ];
+                case 16:
+                    err2 = _state.sent();
+                    if (!closed) {
+                        duckdb.disconnectSync();
+                        instance === null || instance === void 0 ? void 0 : instance.closeSync();
+                    }
+                    throw err2;
+                case 17:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function openDuckdb(cfg) {
+    return _async_to_generator(function() {
+        var _ref, instance, duckdb, 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(), instance = _ref.instance, duckdb = _ref.duckdb, conn = _ref.conn, resolvedCfg = _ref.cfg, dbPath = _ref.dbPath, parsed = _ref.parsed, warnings = _ref.warnings;
+                    return [
+                        2,
+                        {
+                            store: (0, _storets.createStore)(instance, duckdb, 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/duckdb/open.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/duckdb/open.ts"],"sourcesContent":["import { mkdirSync } from 'node:fs';\nimport { join } from 'node:path';\nimport type { DuckDBConnection, DuckDBInstance } from '@duckdb/node-api';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { featureSignature, STATE_DIR } from '../../config/index.ts';\nimport { STORE_DIMS } from '../../embed/types.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 { DUCKDB_PACKAGE, duckdbApi } from './native.ts';\nimport { reconcile } from './reconcile.ts';\nimport { registerFunctions } from './sql-functions.ts';\nimport { createStore } from './store.ts';\n\nexport const DB_FILENAME = 'cache.duckdb';\n// Independent of sqlite's SCHEMA_VERSION -- the two stores' cache shapes evolve separately\n// (VARIANT frontmatter columns instead of untyped ones), and the store name already joins the\n// feature signature (see featureSignature), so a config's `store` key switching cleanly\n// rebuilds rather than reusing the other engine's stale cache shape.\nexport const SCHEMA_VERSION = '2';\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): D1 builds DuckDB's fts index over it lazily,\n// only when a lexical query actually runs (see duckdb/lexical.ts), and reads it directly for\n// contains() substring/phrase/unspaced-script verification either way. No tokenizer resolution\n// -- this store always uses the fts extension's default (porter) stemmer, unlike sqlite's\n// configurable `content.tokenize` (not read here; D1 does not extend that knob to DuckDB).\nasync function ensureSchema(conn: Connection, cfg: Config): Promise<void> {\n  await conn.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" DOUBLE, \"_ctime\" DOUBLE, \"_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)) {\n    // Native FLOAT[STORE_DIMS] instead of the embed feature's engine-neutral BLOB+scale DDL\n    // (see duckdb/vectors.ts). `scale` is kept, unused, so the feature's shared reconcile-time\n    // INSERT/DELETE (src/features/embed.ts) still names a column that exists on both stores.\n    if (feature.name === 'embed') {\n      await conn.exec(`CREATE TABLE IF NOT EXISTS embeddings (\"path\" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, scale REAL, vector FLOAT[${STORE_DIMS}], PRIMARY KEY (\"path\", chunk))`);\n      continue;\n    }\n    await feature.schema(conn);\n  }\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\nasync function connect(cfg: ResolvedConfig): Promise<{ instance: DuckDBInstance; duckdb: DuckDBConnection; conn: Connection; cfg: ResolvedConfig; dbPath: string; parsed: number; warnings: string[] }> {\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: sqlite trees must never even attempt to resolve this\n  // optional peer dependency, so nothing in this store's module graph imports it as a value\n  // until a duckdb tree is actually opened (types-only imports elsewhere are erased and cost\n  // nothing either way). Installed on first use if missing, and shared with sql-functions.ts\n  // and vectors.ts (see native.ts's duckdbApi).\n  let DuckDBInstance: typeof import('@duckdb/node-api').DuckDBInstance;\n  try {\n    ({ DuckDBInstance } = await duckdbApi());\n  } catch (err) {\n    if (err instanceof SenseError) throw err;\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"duckdb\" needs the ${DUCKDB_PACKAGE} package (${(err as Error).message})`);\n  }\n\n  let duckdb: DuckDBConnection;\n  let instance: DuckDBInstance | undefined;\n  try {\n    // On-disk files default to an older storage format for cross-version compatibility, which\n    // rejects VARIANT columns (\"VARIANT columns are not supported in storage versions prior to\n    // v1.5.0\"); this store's dynamic frontmatter columns need VARIANT (see reconcile.ts), so\n    // the format floor is pinned explicitly. :memory: databases are unaffected either way.\n    instance = await DuckDBInstance.create(dbPath, { storage_compatibility_version: 'v1.5.0' });\n    duckdb = await instance.connect();\n  } catch (err) {\n    // create() may have succeeded before connect() failed: close it, or its WAL stays open.\n    instance?.closeSync();\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"duckdb\" failed to open ${dbPath}: ${(err as Error).message}`);\n  }\n  // A throw below (schema, reconcile's COLUMN_LIMIT) would leak the open instance, whose WAL\n  // then locks the .duckdb file undeletable on Windows. closed marks the rebuild branch.\n  let closed = false;\n  try {\n    await registerFunctions(duckdb);\n    const conn = createConnection(duckdb);\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 open() (see its comment for why this is announced).\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      // Close before clearCache deletes the files underneath the still-open instance.\n      closed = true;\n      duckdb.disconnectSync();\n      instance.closeSync();\n      clearCache(cfg);\n      return connect(cfg);\n    }\n\n    await ensureSchema(conn, cfg);\n\n    const { parsed, warnings } = await reconcile(conn, cfg, cfg.baseDir);\n    return { instance, duckdb, conn, cfg, dbPath, parsed, warnings };\n  } catch (err) {\n    if (!closed) {\n      duckdb.disconnectSync();\n      instance?.closeSync();\n    }\n    throw err;\n  }\n}\n\nexport async function openDuckdb(cfg: ResolvedConfig): Promise<OpenResult> {\n  const { instance, duckdb, conn, cfg: resolvedCfg, dbPath, parsed, warnings } = await connect(cfg);\n  return { store: createStore(instance, duckdb, conn, resolvedCfg, resolvedCfg.baseDir), cfg: resolvedCfg, dbPath, parsed, warnings };\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","openDuckdb","ensureSchema","conn","cfg","feature","exec","activeFeatures","name","STORE_DIMS","schema","getMeta","setMeta","featureSignature","FEATURES","connect","stateDir","dbPath","DuckDBInstance","err","duckdb","instance","closed","version","features","wantFeatures","reason","parsed","warnings","join","baseDir","STATE_DIR","mkdirSync","recursive","duckdbApi","SenseError","DUCKDB_PACKAGE","message","create","storage_compatibility_version","closeSync","registerFunctions","createConnection","console","error","disconnectSync","clearCache","reconcile","resolvedCfg","store","createStore"],"mappings":"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"}

package/dist/cjs/store/duckdb/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/duckdb/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[];
+}>;